[PATCH] D151061: [test] Add ext_vector_type tests for C

2023-05-22 Thread Cassie Jones via Phabricator via cfe-commits
porglezomp created this revision.
porglezomp added reviewers: aaron.ballman, fhahn.
Herald added a subscriber: StephenFan.
Herald added a project: All.
porglezomp requested review of this revision.
Herald added a project: clang.
Herald added a subscriber: cfe-commits.

Test that all vector-vs-scalar builtin operators type check
successfully.


Repository:
  rG LLVM Github Monorepo

https://reviews.llvm.org/D151061

Files:
  clang/test/Sema/ext_vector_ops.c
  clang/test/Sema/vecshift.c

Index: clang/test/Sema/vecshift.c
===
--- clang/test/Sema/vecshift.c
+++ clang/test/Sema/vecshift.c
@@ -65,6 +65,20 @@
   vs8 = ui << vs8;
   vus8 = 1 << vus8;
 
+  vc8 = vc8 << c;
+  vuc8 = vuc8 << uc;
+  vs8 = vs8 << s;
+  vus8 = vus8 << us;
+  vi8 = vi8 << i;
+  vui8 = vui8 << ui;
+
+  vc8 = vc8 << i;
+  vuc8 = vuc8 << i;
+  vs8 = vs8 << i;
+  vus8 = vus8 << i;
+  vi8 = vi8 << i;
+  vui8 = vui8 << i;
+
   vc8 = vc8 << vc8;
 #ifdef ERR
   vi8 = vi8 << vuc8; // expected-error {{vector operands do not have the same elements sizes}}
Index: clang/test/Sema/ext_vector_ops.c
===
--- clang/test/Sema/ext_vector_ops.c
+++ clang/test/Sema/ext_vector_ops.c
@@ -25,3 +25,210 @@
   v2u *v2u_ptr = 0;
   v2s *v2s_ptr;
 }
+
+void test_int_vector_scalar(unsigned int ua, v2u v2ua) {
+  // Integer vector vs integer operators. These will splat
+  (void)(v2ua + ua);
+  (void)(ua + v2ua);
+  (void)(v2ua - ua);
+  (void)(ua - v2ua);
+  (void)(v2ua * ua);
+  (void)(ua * v2ua);
+  (void)(v2ua / ua);
+  (void)(ua / v2ua);
+  (void)(v2ua % ua);
+  (void)(ua % v2ua);
+
+  (void)(v2ua == ua);
+  (void)(ua == v2ua);
+  (void)(v2ua != ua);
+  (void)(ua != v2ua);
+  (void)(v2ua <= ua);
+  (void)(ua <= v2ua);
+  (void)(v2ua >= ua);
+  (void)(ua >= v2ua);
+  (void)(v2ua < ua);
+  (void)(ua < v2ua);
+  (void)(v2ua > ua);
+  (void)(ua > v2ua);
+  (void)(v2ua && ua);
+  (void)(ua && v2ua);
+  (void)(v2ua || ua);
+  (void)(ua || v2ua);
+
+  (void)(v2ua & ua);
+  (void)(ua & v2ua);
+  (void)(v2ua | ua);
+  (void)(ua | v2ua);
+  (void)(v2ua ^ ua);
+  (void)(ua ^ v2ua);
+  (void)(v2ua << ua);
+  (void)(ua << v2ua);
+  (void)(v2ua >> ua);
+  (void)(ua >> v2ua);
+
+  v2ua += ua;
+  v2ua -= ua;
+  v2ua *= ua;
+  v2ua /= ua;
+  v2ua %= ua;
+  v2ua &= ua;
+  v2ua |= ua;
+  v2ua ^= ua;
+  v2ua >>= ua;
+  v2ua <<= ua;
+
+  ua += v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}}
+  ua -= v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}}
+  ua *= v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}}
+  ua /= v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}}
+  ua %= v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}}
+  ua &= v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}}
+  ua |= v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}}
+  ua ^= v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}}
+  ua >>= v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}}
+  ua <<= v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}}
+}
+
+void test_float_vector_scalar(float fa, unsigned int ua, v2f v2fa) {
+  // Float vector vs float operators. These will splat
+  (void)(v2fa + fa);
+  (void)(fa + v2fa);
+  (void)(v2fa - fa);
+  (void)(fa - v2fa);
+  (void)(v2fa * fa);
+  (void)(fa * v2fa);
+  (void)(v2fa / fa);
+  (void)(fa / v2fa);
+  (void)(v2fa % fa); // expected-error{{invalid operands to binary expression}}
+  (void)(fa % v2fa); // expected-error{{invalid operands to binary expression}}
+
+  (void)(v2fa == fa);
+  (void)(fa == v2fa);
+  (void)(v2fa != fa);
+  (void)(fa != v2fa);
+  (void)(v2fa <= fa);
+  (void)(fa <= v2fa);
+  (void)(v2fa >= fa);
+  (void)(fa >= v2fa);
+  (void)(v2fa < fa);
+  (void)(fa < v2fa);
+  (void)(v2fa > fa);
+  (void)(fa > v2fa);
+  (void)(v2fa && fa);
+  (void)(fa && v2fa);
+  (void)(v2fa || fa);
+  (void)(fa || v2fa);
+
+  (void)(v2fa & fa); // expected-error{{invalid operands to binary expression}}
+  (void)(fa & v2fa); // expected-error{{invalid operands to binary expression}}
+  (void)(v2fa | fa); // expected-error{{invalid operands to binary expression}}
+  (void)(fa | v2fa); // expected-error{{invalid operands to binary expression}}
+  (void)(v2fa ^ fa); // expected-error{{invalid operands to binary expression}}
+  (void)(fa ^ v2fa); // expected-error{{invalid operands to binary expression}}
+  (void)(v2fa << fa); // expected-error{{used type 'v2f' (vector of 2 'float' values) where integer is required}}
+  (void)(v2fa << ua); // expected-error{{used type 'v2f' (vector of 2 'float' values) where integer is required}}
+  (void)(fa << v2fa); // expected-error{{used type 'float' where integer is required}}
+ 

[PATCH] D151061: [test] Add ext_vector_type tests for C

2023-05-22 Thread Cassie Jones via Phabricator via cfe-commits
porglezomp added a comment.

See also: very similar baseline tests for C++: D151059 


I'm interested in any feedback about the correct semantics for this.
I started writing these tests while investigating the behavior of vector vs 
scalar operations in C++ for D151060  and 
finding a lot of that inconsistent.
I want to get down checks that these cases are all appropriately accepted.
Interested in feedback from anyone working with the ext_vector_types.


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D151061/new/

https://reviews.llvm.org/D151061

___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D151059: [test] Add C++ ext_vector_type tests

2023-05-22 Thread Cassie Jones via Phabricator via cfe-commits
porglezomp added a comment.

See also: C versions of these test cases: D151061 


I think the C versions behave correctly and that C++ should match that behavior.
Interested in feedback from anyone working with ext_vector_types.


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D151059/new/

https://reviews.llvm.org/D151059

___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[clang] 5e92298 - [2/11][POC][Clang][RISCV] Define RVV tuple types

2023-05-22 Thread via cfe-commits

Author: eopXD
Date: 2023-05-22T00:50:40-07:00
New Revision: 5e92298f76875e1a89ad58bab042cd7abe9fc004

URL: 
https://github.com/llvm/llvm-project/commit/5e92298f76875e1a89ad58bab042cd7abe9fc004
DIFF: 
https://github.com/llvm/llvm-project/commit/5e92298f76875e1a89ad58bab042cd7abe9fc004.diff

LOG: [2/11][POC][Clang][RISCV] Define RVV tuple types

For the cover letter of this patch-set, please checkout D146872.

Depends on D146872.

This is the 2nd patch of the patch-set. This patch originates from
D97264. This patch further allows local variable declaration and
function parameter passing by adjustment in clang lowering.

Test cases are provided to demonstrate the LLVM IR generated.

Note: This patch is currently only a proof-of-concept with only a
single RVV tuple type declared here, the rest will be added when
the concept of this patch-set is accepted.

Authored-by: eop Chen 
Co-Authored-by: Hsiangkai Wang 

Reviewed By: craig.topper

Differential Revision: https://reviews.llvm.org/D146873

Added: 
clang/test/CodeGen/RISCV/rvv-intrinsics-handcrafted/rvv-tuple-type.c

Modified: 
clang/include/clang/Basic/RISCVVTypes.def
clang/lib/CodeGen/CGCall.cpp
clang/lib/CodeGen/CodeGenTypes.cpp
clang/test/Sema/riscv-types.c

Removed: 




diff  --git a/clang/include/clang/Basic/RISCVVTypes.def 
b/clang/include/clang/Basic/RISCVVTypes.def
index b21a3bb4d5a6b..9702103861ac9 100644
--- a/clang/include/clang/Basic/RISCVVTypes.def
+++ b/clang/include/clang/Basic/RISCVVTypes.def
@@ -144,6 +144,10 @@ RVV_PREDICATE_TYPE("__rvv_bool16_t", RvvBool16, 
RvvBool16Ty, 4)
 RVV_PREDICATE_TYPE("__rvv_bool32_t", RvvBool32, RvvBool32Ty, 2)
 RVV_PREDICATE_TYPE("__rvv_bool64_t", RvvBool64, RvvBool64Ty, 1)
 
+//===- Tuple vector types 
-===//
+
+RVV_VECTOR_TYPE_INT("__rvv_int32m1x2_t", RvvInt32m1x2, RvvInt32m1x2Ty, 2,  32, 
2, true)
+
 #undef RVV_VECTOR_TYPE_FLOAT
 #undef RVV_VECTOR_TYPE_INT
 #undef RVV_VECTOR_TYPE

diff  --git a/clang/lib/CodeGen/CGCall.cpp b/clang/lib/CodeGen/CGCall.cpp
index 9cdf689b74440..6a1d549c53a28 100644
--- a/clang/lib/CodeGen/CGCall.cpp
+++ b/clang/lib/CodeGen/CGCall.cpp
@@ -3132,30 +3132,51 @@ void CodeGenFunction::EmitFunctionProlog(const 
CGFunctionInfo &FI,
   llvm::StructType *STy = 
dyn_cast(ArgI.getCoerceToType());
   if (ArgI.isDirect() && ArgI.getCanBeFlattened() && STy &&
   STy->getNumElements() > 1) {
-uint64_t SrcSize = CGM.getDataLayout().getTypeAllocSize(STy);
-llvm::Type *DstTy = Ptr.getElementType();
-uint64_t DstSize = CGM.getDataLayout().getTypeAllocSize(DstTy);
+llvm::TypeSize StructSize = CGM.getDataLayout().getTypeAllocSize(STy);
+llvm::TypeSize PtrElementSize =
+CGM.getDataLayout().getTypeAllocSize(Ptr.getElementType());
+if (StructSize.isScalable()) {
+  assert(STy->containsHomogeneousScalableVectorTypes() &&
+ "ABI only supports structure with homogeneous scalable vector 
"
+ "type");
+  assert(StructSize == PtrElementSize &&
+ "Only allow non-fractional movement of structure with"
+ "homogeneous scalable vector type");
+  assert(STy->getNumElements() == NumIRArgs);
+
+  llvm::Value *LoadedStructValue = llvm::PoisonValue::get(STy);
+  for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
+auto *AI = Fn->getArg(FirstIRArg + i);
+AI->setName(Arg->getName() + ".coerce" + Twine(i));
+LoadedStructValue =
+Builder.CreateInsertValue(LoadedStructValue, AI, i);
+  }
 
-Address AddrToStoreInto = Address::invalid();
-if (SrcSize <= DstSize) {
-  AddrToStoreInto = Builder.CreateElementBitCast(Ptr, STy);
+  Builder.CreateStore(LoadedStructValue, Ptr);
 } else {
-  AddrToStoreInto =
-CreateTempAlloca(STy, Alloca.getAlignment(), "coerce");
-}
+  uint64_t SrcSize = StructSize.getFixedValue();
+  uint64_t DstSize = PtrElementSize.getFixedValue();
+
+  Address AddrToStoreInto = Address::invalid();
+  if (SrcSize <= DstSize) {
+AddrToStoreInto = Builder.CreateElementBitCast(Ptr, STy);
+  } else {
+AddrToStoreInto =
+CreateTempAlloca(STy, Alloca.getAlignment(), "coerce");
+  }
 
-assert(STy->getNumElements() == NumIRArgs);
-for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
-  auto AI = Fn->getArg(FirstIRArg + i);
-  AI->setName(Arg->getName() + ".coerce" + Twine(i));
-  Address EltPtr = Builder.CreateStructGEP(AddrToStoreInto, i);
-  Builder.CreateStore(AI, EltPtr);
-}
+  assert(STy->getNumElements() == NumIRArgs);
+  for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {

[PATCH] D146873: [2/11][POC][Clang][RISCV] Define RVV tuple types

2023-05-22 Thread Yueh-Ting (eop) Chen via Phabricator via cfe-commits
This revision was landed with ongoing or failed builds.
This revision was automatically updated to reflect the committed changes.
Closed by commit rG5e92298f7687: [2/11][POC][Clang][RISCV] Define RVV tuple 
types (authored by eopXD).

Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D146873/new/

https://reviews.llvm.org/D146873

Files:
  clang/include/clang/Basic/RISCVVTypes.def
  clang/lib/CodeGen/CGCall.cpp
  clang/lib/CodeGen/CodeGenTypes.cpp
  clang/test/CodeGen/RISCV/rvv-intrinsics-handcrafted/rvv-tuple-type.c
  clang/test/Sema/riscv-types.c

Index: clang/test/Sema/riscv-types.c
===
--- clang/test/Sema/riscv-types.c
+++ clang/test/Sema/riscv-types.c
@@ -133,6 +133,9 @@
 
   // CHECK: __rvv_int8mf2_t x43;
   __rvv_int8mf2_t x43;
+
+  // CHECK: __rvv_int32m1x2_t x44;
+  __rvv_int32m1x2_t x44;
 }
 
 typedef __rvv_bool4_t vbool4_t;
Index: clang/test/CodeGen/RISCV/rvv-intrinsics-handcrafted/rvv-tuple-type.c
===
--- /dev/null
+++ clang/test/CodeGen/RISCV/rvv-intrinsics-handcrafted/rvv-tuple-type.c
@@ -0,0 +1,90 @@
+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --version 2
+// RUN: %clang_cc1 -triple riscv64 -target-feature +zve32x -O0 \
+// RUN:   -emit-llvm %s -o - | FileCheck %s --check-prefix=O0
+// RUN: %clang_cc1 -triple riscv64 -target-feature +zve32x -disable-O0-optnone \
+// RUN:   -emit-llvm %s -o - | opt -S -passes=mem2reg | FileCheck %s --check-prefix=AFTER_MEM2REG
+
+
+#include 
+
+// Declare local variable
+// O0-LABEL: define dso_local void @foo
+// O0-SAME: () #[[ATTR0:[0-9]+]] {
+// O0-NEXT:  entry:
+// O0-NEXT:[[V_TUPLE:%.*]] = alloca { ,  }, align 4
+// O0-NEXT:ret void
+//
+// AFTER_MEM2REG-LABEL: define dso_local void @foo
+// AFTER_MEM2REG-SAME: () #[[ATTR0:[0-9]+]] {
+// AFTER_MEM2REG-NEXT:  entry:
+// AFTER_MEM2REG-NEXT:ret void
+//
+void foo() {
+  __rvv_int32m1x2_t v_tuple;
+}
+
+// Declare local variable and return
+// O0-LABEL: define dso_local { ,  } @bar
+// O0-SAME: () #[[ATTR0]] {
+// O0-NEXT:  entry:
+// O0-NEXT:[[V_TUPLE:%.*]] = alloca { ,  }, align 4
+// O0-NEXT:[[TMP0:%.*]] = load { ,  }, ptr [[V_TUPLE]], align 4
+// O0-NEXT:ret { ,  } [[TMP0]]
+//
+// AFTER_MEM2REG-LABEL: define dso_local { ,  } @bar
+// AFTER_MEM2REG-SAME: () #[[ATTR0]] {
+// AFTER_MEM2REG-NEXT:  entry:
+// AFTER_MEM2REG-NEXT:ret { ,  } undef
+//
+__rvv_int32m1x2_t bar() {
+  __rvv_int32m1x2_t v_tuple;
+  return v_tuple;
+}
+
+// Pass as function parameter
+// O0-LABEL: define dso_local void @baz
+// O0-SAME: ( [[V_TUPLE_COERCE0:%.*]],  [[V_TUPLE_COERCE1:%.*]]) #[[ATTR0]] {
+// O0-NEXT:  entry:
+// O0-NEXT:[[V_TUPLE:%.*]] = alloca { ,  }, align 4
+// O0-NEXT:[[V_TUPLE_ADDR:%.*]] = alloca { ,  }, align 4
+// O0-NEXT:[[TMP0:%.*]] = insertvalue { ,  } poison,  [[V_TUPLE_COERCE0]], 0
+// O0-NEXT:[[TMP1:%.*]] = insertvalue { ,  } [[TMP0]],  [[V_TUPLE_COERCE1]], 1
+// O0-NEXT:store { ,  } [[TMP1]], ptr [[V_TUPLE]], align 4
+// O0-NEXT:[[V_TUPLE1:%.*]] = load { ,  }, ptr [[V_TUPLE]], align 4
+// O0-NEXT:store { ,  } [[V_TUPLE1]], ptr [[V_TUPLE_ADDR]], align 4
+// O0-NEXT:ret void
+//
+// AFTER_MEM2REG-LABEL: define dso_local void @baz
+// AFTER_MEM2REG-SAME: ( [[V_TUPLE_COERCE0:%.*]],  [[V_TUPLE_COERCE1:%.*]]) #[[ATTR0]] {
+// AFTER_MEM2REG-NEXT:  entry:
+// AFTER_MEM2REG-NEXT:[[TMP0:%.*]] = insertvalue { ,  } poison,  [[V_TUPLE_COERCE0]], 0
+// AFTER_MEM2REG-NEXT:[[TMP1:%.*]] = insertvalue { ,  } [[TMP0]],  [[V_TUPLE_COERCE1]], 1
+// AFTER_MEM2REG-NEXT:ret void
+//
+void baz(__rvv_int32m1x2_t v_tuple) {
+}
+
+// Pass as function parameter and return
+// O0-LABEL: define dso_local { ,  } @qux
+// O0-SAME: ( [[V_TUPLE_COERCE0:%.*]],  [[V_TUPLE_COERCE1:%.*]]) #[[ATTR0]] {
+// O0-NEXT:  entry:
+// O0-NEXT:[[V_TUPLE:%.*]] = alloca { ,  }, align 4
+// O0-NEXT:[[V_TUPLE_ADDR:%.*]] = alloca { ,  }, align 4
+// O0-NEXT:[[TMP0:%.*]] = insertvalue { ,  } poison,  [[V_TUPLE_COERCE0]], 0
+// O0-NEXT:[[TMP1:%.*]] = insertvalue { ,  } [[TMP0]],  [[V_TUPLE_COERCE1]], 1
+// O0-NEXT:store { ,  } [[TMP1]], ptr [[V_TUPLE]], align 4
+// O0-NEXT:[[V_TUPLE1:%.*]] = load { ,  }, ptr [[V_TUPLE]], align 4
+// O0-NEXT:store { ,  } [[V_TUPLE1]], ptr [[V_TUPLE_ADDR]], align 4
+// O0-NEXT:[[TMP2:%.*]] = load { ,  }, ptr [[V_TUPLE_ADDR]], align 4
+// O0-NEXT:ret { ,  } [[TMP2]]
+//
+// AFTER_MEM2REG-LABEL: define dso_local { ,  } @qux
+// AFTER_MEM2REG-SAME: ( [[V_TUPLE_COERCE0:%.*]],  [[V_TUPLE_COERCE1:%.*]]) #[[ATTR0]] {
+// AFTER_MEM2REG-NEXT:  entry:
+// AFTER_MEM2REG-NEXT:[[TMP0:%.*]] = insertvalue { ,  } poison,  [[V_TUPLE_COERCE0]], 0
+// AFTER_MEM2REG-NEXT:[[TMP1:%.*]] = insertvalue { ,  } [[TMP0]],  [[V_TUPLE_COERCE1]], 1
+// AFTER_MEM2REG-NEXT:ret { ,  } [[TMP1]]
+//
+__rvv_int32m1x2_t qux(__rvv_int32m1

[PATCH] D147731: [3/11][POC][Clang][RISCV] Add typedef of the tuple type and define tuple type variant of vlseg2e32

2023-05-22 Thread Yueh-Ting (eop) Chen via Phabricator via cfe-commits
eopXD updated this revision to Diff 524182.
eopXD added a comment.

Bump CI.


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D147731/new/

https://reviews.llvm.org/D147731

Files:
  clang/include/clang/AST/ASTContext.h
  clang/include/clang/Basic/riscv_vector.td
  clang/include/clang/Basic/riscv_vector_common.td
  clang/include/clang/Support/RISCVVIntrinsicUtils.h
  clang/lib/AST/ASTContext.cpp
  clang/lib/Sema/SemaRISCVVectorLookup.cpp
  clang/lib/Support/RISCVVIntrinsicUtils.cpp
  
clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vlseg2e32_tuple.c
  clang/utils/TableGen/RISCVVEmitter.cpp

Index: clang/utils/TableGen/RISCVVEmitter.cpp
===
--- clang/utils/TableGen/RISCVVEmitter.cpp
+++ clang/utils/TableGen/RISCVVEmitter.cpp
@@ -65,6 +65,7 @@
   bool HasMaskedOffOperand :1;
   bool HasTailPolicy : 1;
   bool HasMaskPolicy : 1;
+  bool IsTuple : 1;
   uint8_t UnMaskedPolicyScheme : 2;
   uint8_t MaskedPolicyScheme : 2;
 };
@@ -363,6 +364,16 @@
 TypeModifier::UnsignedInteger));
 printType(*UT);
   }
+  // FIXME: Expand more type declaration
+  if (I == 'i' && Log2LMUL == 0) { // vint32m1x2_t
+auto TupleT = TypeCache.computeType(
+BT, Log2LMUL,
+PrototypeDescriptor(BaseTypeModifier::Vector,
+VectorTypeModifier::Tuple2,
+TypeModifier::SignedInteger));
+if (TupleT)
+  printType(*TupleT);
+  }
 }
   }
 
@@ -512,6 +523,7 @@
 StringRef IRName = R->getValueAsString("IRName");
 StringRef MaskedIRName = R->getValueAsString("MaskedIRName");
 unsigned NF = R->getValueAsInt("NF");
+bool IsTuple = R->getValueAsBit("IsTuple");
 
 const Policy DefaultPolicy;
 SmallVector SupportedUnMaskedPolicies =
@@ -532,10 +544,10 @@
 auto Prototype = RVVIntrinsic::computeBuiltinTypes(
 BasicPrototype, /*IsMasked=*/false,
 /*HasMaskedOffOperand=*/false, HasVL, NF, UnMaskedPolicyScheme,
-DefaultPolicy);
+DefaultPolicy, IsTuple);
 auto MaskedPrototype = RVVIntrinsic::computeBuiltinTypes(
 BasicPrototype, /*IsMasked=*/true, HasMaskedOffOperand, HasVL, NF,
-MaskedPolicyScheme, DefaultPolicy);
+MaskedPolicyScheme, DefaultPolicy, IsTuple);
 
 // Create Intrinsics for each type and LMUL.
 for (char I : TypeRange) {
@@ -557,14 +569,14 @@
 /*IsMasked=*/false, /*HasMaskedOffOperand=*/false, HasVL,
 UnMaskedPolicyScheme, SupportOverloading, HasBuiltinAlias,
 ManualCodegen, *Types, IntrinsicTypes, RequiredFeatures, NF,
-DefaultPolicy));
+DefaultPolicy, IsTuple));
 if (UnMaskedPolicyScheme != PolicyScheme::SchemeNone)
   for (auto P : SupportedUnMaskedPolicies) {
 SmallVector PolicyPrototype =
 RVVIntrinsic::computeBuiltinTypes(
 BasicPrototype, /*IsMasked=*/false,
 /*HasMaskedOffOperand=*/false, HasVL, NF,
-UnMaskedPolicyScheme, P);
+UnMaskedPolicyScheme, P, IsTuple);
 std::optional PolicyTypes =
 TypeCache.computeTypes(BT, Log2LMUL, NF, PolicyPrototype);
 Out.push_back(std::make_unique(
@@ -572,7 +584,7 @@
 /*IsMask=*/false, /*HasMaskedOffOperand=*/false, HasVL,
 UnMaskedPolicyScheme, SupportOverloading, HasBuiltinAlias,
 ManualCodegen, *PolicyTypes, IntrinsicTypes, RequiredFeatures,
-NF, P));
+NF, P, IsTuple));
   }
 if (!HasMasked)
   continue;
@@ -583,14 +595,14 @@
 Name, SuffixStr, OverloadedName, OverloadedSuffixStr, MaskedIRName,
 /*IsMasked=*/true, HasMaskedOffOperand, HasVL, MaskedPolicyScheme,
 SupportOverloading, HasBuiltinAlias, ManualCodegen, *MaskTypes,
-IntrinsicTypes, RequiredFeatures, NF, DefaultPolicy));
+IntrinsicTypes, RequiredFeatures, NF, DefaultPolicy, IsTuple));
 if (MaskedPolicyScheme == PolicyScheme::SchemeNone)
   continue;
 for (auto P : SupportedMaskedPolicies) {
   SmallVector PolicyPrototype =
   RVVIntrinsic::computeBuiltinTypes(
   BasicPrototype, /*IsMasked=*/true, HasMaskedOffOperand, HasVL,
-  NF, MaskedPolicyScheme, P);
+  NF, MaskedPolicyScheme, P, IsTuple);
   std::optional PolicyTypes =
   TypeCache.computeTypes(BT, Log2LMUL, NF, PolicyPrototype);
   Out.push_back(std::make_unique(
@@ -598,7 +610,7 @@
   MaskedIRName, /*IsMasked=*/true, HasMaskedOffOperand, HasVL,
   MaskedPolicyScheme, SupportOverloading, HasBuiltinAlias,
   ManualCodegen, *PolicyTypes, IntrinsicTypes, Requi

[PATCH] D150635: [clangd] Implement end-definition-comment inlay hints

2023-05-22 Thread Qingyuan Zheng via Phabricator via cfe-commits
daiyousei-qz updated this revision to Diff 524183.
daiyousei-qz marked 19 inline comments as done.
daiyousei-qz added a comment.

Address review comments


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D150635/new/

https://reviews.llvm.org/D150635

Files:
  clang-tools-extra/clangd/Config.h
  clang-tools-extra/clangd/ConfigCompile.cpp
  clang-tools-extra/clangd/ConfigFragment.h
  clang-tools-extra/clangd/ConfigYAML.cpp
  clang-tools-extra/clangd/InlayHints.cpp
  clang-tools-extra/clangd/Protocol.cpp
  clang-tools-extra/clangd/Protocol.h
  clang-tools-extra/clangd/unittests/InlayHintTests.cpp

Index: clang-tools-extra/clangd/unittests/InlayHintTests.cpp
===
--- clang-tools-extra/clangd/unittests/InlayHintTests.cpp
+++ clang-tools-extra/clangd/unittests/InlayHintTests.cpp
@@ -77,6 +77,7 @@
   C.InlayHints.Parameters = false;
   C.InlayHints.DeducedTypes = false;
   C.InlayHints.Designators = false;
+  C.InlayHints.BlockEnd = false;
   return C;
 }
 
@@ -122,6 +123,15 @@
   assertHints(InlayHintKind::Designator, AnnotatedSource, Expected...);
 }
 
+template 
+void assertBlockEndHints(llvm::StringRef AnnotatedSource,
+ ExpectedHints... Expected) {
+  Config Cfg;
+  Cfg.InlayHints.BlockEnd = true;
+  WithContextValue WithCfg(Config::Key, std::move(Cfg));
+  assertHints(InlayHintKind::BlockEnd, AnnotatedSource, Expected...);
+}
+
 TEST(ParameterHints, Smoke) {
   assertParameterHints(R"cpp(
 void foo(int param);
@@ -1550,6 +1560,194 @@
   ExpectedHint{"a: ", "param1"}, ExpectedHint{"b: ", "param2"},
   ExpectedHint{"c: ", "param3"});
 }
+
+TEST(BlockEndHints, Functions) {
+  assertBlockEndHints(R"cpp(
+int foo() {
+  return 41;
+$foo[[}]]
+
+template 
+int bar() { 
+  // No hint for lambda for now
+  auto f = []() { 
+return X; 
+  };
+  return f(); 
+$bar[[}]]
+
+// No hint because this isn't a definition
+int buz();
+
+struct S{};
+bool operator==(S, S) {
+  return true;
+$opEqual[[}]]
+  )cpp",
+  ExpectedHint{" // foo", "foo"},
+  ExpectedHint{" // bar", "bar"},
+  ExpectedHint{" // operator==", "opEqual"});
+}
+
+TEST(BlockEndHints, Methods) {
+  assertBlockEndHints(R"cpp(
+struct Test {
+  // No hint because there's no function body
+  Test() = default;
+  
+  ~Test() {
+  $dtor[[}]]
+
+  void method1() {
+  $method1[[}]]
+
+  // No hint because this isn't a definition
+  void method2();
+
+  template 
+  void method3() {
+  $method3[[}]]
+
+  // No hint because this isn't a definition
+  template 
+  void method4();
+
+  Test operator+(int) const {
+return *this;
+  $opIdentity[[}]]
+
+  operator bool() const {
+return true;
+  $opBool[[}]]
+
+  // No hint because there's no function body
+  operator int() const = delete;
+} x;
+
+void Test::method2() {
+$method2[[}]]
+
+template 
+void Test::method4() {
+$method4[[}]]
+  )cpp",
+  ExpectedHint{" // ~Test", "dtor"},
+  ExpectedHint{" // method1", "method1"},
+  ExpectedHint{" // method3", "method3"},
+  ExpectedHint{" // operator+", "opIdentity"},
+  ExpectedHint{" // operator bool", "opBool"},
+  ExpectedHint{" // Test::method2", "method2"},
+  ExpectedHint{" // Test::method4", "method4"});
+}
+
+TEST(BlockEndHints, Namespaces) {
+  assertBlockEndHints(
+  R"cpp(
+namespace {
+  void foo();
+$anon[[}]]
+
+namespace ns {
+  void bar();
+$ns[[}]]
+  )cpp",
+  ExpectedHint{" // namespace", "anon"},
+  ExpectedHint{" // namespace ns", "ns"});
+}
+
+TEST(BlockEndHints, Types) {
+  assertBlockEndHints(
+  R"cpp(
+struct S {
+$S[[};]]
+
+class C {
+$C[[};]]
+
+union U {
+$U[[};]]
+
+enum E1 {
+$E1[[};]]
+
+enum class E2 {
+$E2[[};]]
+  )cpp",
+  ExpectedHint{" // struct S", "S"}, ExpectedHint{" // class C", "C"},
+  ExpectedHint{" // union U", "U"}, ExpectedHint{" // enum E1", "E1"},
+  ExpectedHint{" // enum class E2", "E2"});
+}
+
+TEST(BlockEndHints, TrailingSemicolon) {
+  assertBlockEndHints(R"cpp(
+// The hint is placed after the trailing ';'
+struct S1 {
+$S1[[}  ;]]   
+
+// The hint is always placed in the same line with the closing '}'.
+// So in this case where ';' is missing, it is attached to '}'.
+struct S2 {
+$S2[[}]]
+
+;
+
+// No hint because only one trailing ';' is allowed
+struct S3 {
+};;
+
+// No hint because trailing ';' is only allowed for class/struct/union/enum
+void foo() {
+};
+
+// Rare case, but yes we'll have a hint here.
+struct {
+  in

[PATCH] D150635: [clangd] Implement end-definition-comment inlay hints

2023-05-22 Thread Qingyuan Zheng via Phabricator via cfe-commits
daiyousei-qz marked an inline comment as done.
daiyousei-qz added a comment.

Addressed most review comments.

I'm currently using the name "BlockEnd" as suggested. Though I'm proposing a 
name like "DeclBlockEnd" to make it clearer. What do you think?




Comment at: clang-tools-extra/clangd/InlayHints.cpp:285-286
+  bool VisitEnumDecl(EnumDecl *D) {
+if (Cfg.InlayHints.EndDefinitionComments &&
+D->isThisDeclarationADefinition()) {
+  StringRef DeclPrefix;

zyounan wrote:
> nit: bail out early?
> 
No longer needed as merged into VisitTagDecl



Comment at: clang-tools-extra/clangd/InlayHints.cpp:777
+  void addEndDefinitionCommentHint(const NamedDecl &D, StringRef DeclPrefix,
+   bool SkipSemicolon) {
+size_t SkippedChars = 0;

sammccall wrote:
> SkipSemicolon doesn't need to be optional, a trailing semicolon never adds 
> any ambiguity about what the hint is for
Yes, no ambiguity. But the following hint looks weird to me:
```
void foo() {
}; // foo
```

Since this isn't that complicated to filter them out, I'd prefer making it more 
precise.



Comment at: clang-tools-extra/clangd/InlayHints.cpp:783
+// Note this range doesn't include the trailing ';' in type definitions.
+// So we have to add SkippedChars to the end character.
+SourceRange R = D.getSourceRange();

sammccall wrote:
> This is too much arithmetic and fiddly coupling between this function and 
> shouldHintEndDefinitionComment.
> 
> Among other things, it allows for confusion between unicode characters 
> (UTF-32), clang bytes (UTF-8), and LSP characters (usually UTF-16). And we do 
> have a bug here: shouldHintEndDefinition provides SkippedChars in clang 
> bytes, but you add it to end.character below which is in LSP characters.
> 
> ---
> 
> Let's redesign a little... 
> 
> We have a `}` on some line. We want to compute a sensible part of that line 
> to attach to.
> A suitable range may not exist, in which case we're going to omit the hint.
> 
> - The line consists of text we don't care about , the `}`, and then some mix 
> of whitespace, "trivial" punctuation, and "nontrivial" chars.
> - the range should always start at the `}`, since that's what we're really 
> hinting
> - to get the hint in the right place, the range should end after the trivial 
> chars, but before any trailing whitespace
> - if there are any nontrivial chars, there's no suitable range
> 
> so something like:
> 
> ```
> optional findBraceTargetRange(SourceLocation CloseBrace) {
>   auto [File, Offset] = SM.getDecomposedLoc(SM.getFileLoc(CloseBrace));
>   if (File != MainFileID) return std::nullopt;
>   StringRef RestOfLine = MainFileBuf.substr(Offset).split('\n').first.rtrim();
>   if (!RestOfLine.consume_front("{")) return;
>   if (StringRef::npos != Punctuation.find_first_of(" ,;")) return 
> std::nullopt;
>   return {offsetToPosition(MainFileBuf, Offset), 
> offsetToPosition(MainFileBuf, Result.bytes_end() - MainFileBuf.bytes_end()};
> }
> ```
> 
> and then call from addEndDefinitionComment, the result is LSPRange already.
Done, also moved min-line and max-length logic to this function. Btw, I think 
we should avoid `offsetToPosition` as much as possible. It is a large overhead 
considering inlay hints are recomputed throughout the entire file for each 
edit. I frequently work with source code that's nearly 1MB large (Yes, I don't 
think we should have source file this large, but it is what it is).



Comment at: clang-tools-extra/clangd/InlayHints.cpp:797
+  // differently.
+  assert(Label.empty());
+  Label += printName(AST, D);

zyounan wrote:
> nit: `assert(Label.empty() && "Label should be empty with FunctionDecl")`. 
> might be helpful for debugging.
No longer needed as this assert is removed.



Comment at: clang-tools-extra/clangd/InlayHints.cpp:671
+
+  void addInlayHint(Range LSPRange, HintSide Side, InlayHintKind Kind,
+llvm::StringRef Prefix, llvm::StringRef Label,

sammccall wrote:
> I don't really like this signature change.
> 
> I understand the goal to avoid duplicating the range computation but it seems 
> unlikely to be critical.
> Also, the caller could get the line numbers of the `{}` from the 
> SourceManager and compare those, which should be cheaper than computing the 
> range, so we wouldn't be duplicating all of the work.
As per another comment below, this change is kept.



Comment at: clang-tools-extra/clangd/InlayHints.cpp:760
+// Note this range doesn't include the trailing ';' in type definitions.
+SourceRange R = D.getSourceRange();
+auto LSPRange = getHintRange(R);

sammccall wrote:
> I believe it makes more sense to target the `}` rather than the whole 
> declaration here - we're really talking about what the `}` closes, rather 
> than wh

[PATCH] D148489: [clangd] Implement configs to stop clangd produce a certain semantic tokens

2023-05-22 Thread Qingyuan Zheng via Phabricator via cfe-commits
daiyousei-qz added a comment.

Yes please.


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D148489/new/

https://reviews.llvm.org/D148489

___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[clang] 5a61920 - [Clang][RISCV] Add missing requirement in test case rvv-tuple-type.c

2023-05-22 Thread via cfe-commits

Author: eopXD
Date: 2023-05-22T01:10:22-07:00
New Revision: 5a61920ed8b3e76d8f9bf39f2c1e18d552fcc976

URL: 
https://github.com/llvm/llvm-project/commit/5a61920ed8b3e76d8f9bf39f2c1e18d552fcc976
DIFF: 
https://github.com/llvm/llvm-project/commit/5a61920ed8b3e76d8f9bf39f2c1e18d552fcc976.diff

LOG: [Clang][RISCV] Add missing requirement in test case rvv-tuple-type.c

Signed-off by: eop Chen 

Added: 


Modified: 
clang/test/CodeGen/RISCV/rvv-intrinsics-handcrafted/rvv-tuple-type.c

Removed: 




diff  --git 
a/clang/test/CodeGen/RISCV/rvv-intrinsics-handcrafted/rvv-tuple-type.c 
b/clang/test/CodeGen/RISCV/rvv-intrinsics-handcrafted/rvv-tuple-type.c
index 2b16392164b68..bd2b2a98ebd14 100644
--- a/clang/test/CodeGen/RISCV/rvv-intrinsics-handcrafted/rvv-tuple-type.c
+++ b/clang/test/CodeGen/RISCV/rvv-intrinsics-handcrafted/rvv-tuple-type.c
@@ -1,4 +1,5 @@
 // NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py 
UTC_ARGS: --version 2
+// REQUIRES: riscv-registered-target
 // RUN: %clang_cc1 -triple riscv64 -target-feature +zve32x -O0 \
 // RUN:   -emit-llvm %s -o - | FileCheck %s --check-prefix=O0
 // RUN: %clang_cc1 -triple riscv64 -target-feature +zve32x -disable-O0-optnone 
\



___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D147731: [3/11][POC][Clang][RISCV] Add typedef of the tuple type and define tuple type variant of vlseg2e32

2023-05-22 Thread Yueh-Ting (eop) Chen via Phabricator via cfe-commits
eopXD updated this revision to Diff 524186.
eopXD added a comment.

Bump CI again due to latest fix (5a61920ed8b3e76d8f9bf39f2c1e18d552fcc976 
) for 
D146873  
(5e92298f76875e1a89ad58bab042cd7abe9fc004 
).


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D147731/new/

https://reviews.llvm.org/D147731

Files:
  clang/include/clang/AST/ASTContext.h
  clang/include/clang/Basic/riscv_vector.td
  clang/include/clang/Basic/riscv_vector_common.td
  clang/include/clang/Support/RISCVVIntrinsicUtils.h
  clang/lib/AST/ASTContext.cpp
  clang/lib/Sema/SemaRISCVVectorLookup.cpp
  clang/lib/Support/RISCVVIntrinsicUtils.cpp
  
clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vlseg2e32_tuple.c
  clang/utils/TableGen/RISCVVEmitter.cpp

Index: clang/utils/TableGen/RISCVVEmitter.cpp
===
--- clang/utils/TableGen/RISCVVEmitter.cpp
+++ clang/utils/TableGen/RISCVVEmitter.cpp
@@ -65,6 +65,7 @@
   bool HasMaskedOffOperand :1;
   bool HasTailPolicy : 1;
   bool HasMaskPolicy : 1;
+  bool IsTuple : 1;
   uint8_t UnMaskedPolicyScheme : 2;
   uint8_t MaskedPolicyScheme : 2;
 };
@@ -363,6 +364,16 @@
 TypeModifier::UnsignedInteger));
 printType(*UT);
   }
+  // FIXME: Expand more type declaration
+  if (I == 'i' && Log2LMUL == 0) { // vint32m1x2_t
+auto TupleT = TypeCache.computeType(
+BT, Log2LMUL,
+PrototypeDescriptor(BaseTypeModifier::Vector,
+VectorTypeModifier::Tuple2,
+TypeModifier::SignedInteger));
+if (TupleT)
+  printType(*TupleT);
+  }
 }
   }
 
@@ -512,6 +523,7 @@
 StringRef IRName = R->getValueAsString("IRName");
 StringRef MaskedIRName = R->getValueAsString("MaskedIRName");
 unsigned NF = R->getValueAsInt("NF");
+bool IsTuple = R->getValueAsBit("IsTuple");
 
 const Policy DefaultPolicy;
 SmallVector SupportedUnMaskedPolicies =
@@ -532,10 +544,10 @@
 auto Prototype = RVVIntrinsic::computeBuiltinTypes(
 BasicPrototype, /*IsMasked=*/false,
 /*HasMaskedOffOperand=*/false, HasVL, NF, UnMaskedPolicyScheme,
-DefaultPolicy);
+DefaultPolicy, IsTuple);
 auto MaskedPrototype = RVVIntrinsic::computeBuiltinTypes(
 BasicPrototype, /*IsMasked=*/true, HasMaskedOffOperand, HasVL, NF,
-MaskedPolicyScheme, DefaultPolicy);
+MaskedPolicyScheme, DefaultPolicy, IsTuple);
 
 // Create Intrinsics for each type and LMUL.
 for (char I : TypeRange) {
@@ -557,14 +569,14 @@
 /*IsMasked=*/false, /*HasMaskedOffOperand=*/false, HasVL,
 UnMaskedPolicyScheme, SupportOverloading, HasBuiltinAlias,
 ManualCodegen, *Types, IntrinsicTypes, RequiredFeatures, NF,
-DefaultPolicy));
+DefaultPolicy, IsTuple));
 if (UnMaskedPolicyScheme != PolicyScheme::SchemeNone)
   for (auto P : SupportedUnMaskedPolicies) {
 SmallVector PolicyPrototype =
 RVVIntrinsic::computeBuiltinTypes(
 BasicPrototype, /*IsMasked=*/false,
 /*HasMaskedOffOperand=*/false, HasVL, NF,
-UnMaskedPolicyScheme, P);
+UnMaskedPolicyScheme, P, IsTuple);
 std::optional PolicyTypes =
 TypeCache.computeTypes(BT, Log2LMUL, NF, PolicyPrototype);
 Out.push_back(std::make_unique(
@@ -572,7 +584,7 @@
 /*IsMask=*/false, /*HasMaskedOffOperand=*/false, HasVL,
 UnMaskedPolicyScheme, SupportOverloading, HasBuiltinAlias,
 ManualCodegen, *PolicyTypes, IntrinsicTypes, RequiredFeatures,
-NF, P));
+NF, P, IsTuple));
   }
 if (!HasMasked)
   continue;
@@ -583,14 +595,14 @@
 Name, SuffixStr, OverloadedName, OverloadedSuffixStr, MaskedIRName,
 /*IsMasked=*/true, HasMaskedOffOperand, HasVL, MaskedPolicyScheme,
 SupportOverloading, HasBuiltinAlias, ManualCodegen, *MaskTypes,
-IntrinsicTypes, RequiredFeatures, NF, DefaultPolicy));
+IntrinsicTypes, RequiredFeatures, NF, DefaultPolicy, IsTuple));
 if (MaskedPolicyScheme == PolicyScheme::SchemeNone)
   continue;
 for (auto P : SupportedMaskedPolicies) {
   SmallVector PolicyPrototype =
   RVVIntrinsic::computeBuiltinTypes(
   BasicPrototype, /*IsMasked=*/true, HasMaskedOffOperand, HasVL,
-  NF, MaskedPolicyScheme, P);
+  NF, MaskedPolicyScheme, P, IsTuple);
   std::optional PolicyTypes =
   TypeCache.computeTypes(BT, Log2LMU

[PATCH] D146873: [2/11][POC][Clang][RISCV] Define RVV tuple types

2023-05-22 Thread Yueh-Ting (eop) Chen via Phabricator via cfe-commits
eopXD added a comment.

Committing this patch caused build failure in non-RISC-V buildbot CI-s because 
of the missing `REQUIRES` line in the test case 
`clang/test/CodeGen/RISCV/rvv-intrinsics-handcrafted/rvv-tuple-type.c`.

This is addressed in the 5a61920ed8b3e76d8f9bf39f2c1e18d552fcc976 
.


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D146873/new/

https://reviews.llvm.org/D146873

___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D147731: [3/11][POC][Clang][RISCV] Add typedef of the tuple type and define tuple type variant of vlseg2e32

2023-05-22 Thread Yueh-Ting (eop) Chen via Phabricator via cfe-commits
eopXD updated this revision to Diff 524187.
eopXD added a comment.

Bump CI again, the previous patch application failed.


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D147731/new/

https://reviews.llvm.org/D147731

Files:
  clang/include/clang/AST/ASTContext.h
  clang/include/clang/Basic/riscv_vector.td
  clang/include/clang/Basic/riscv_vector_common.td
  clang/include/clang/Support/RISCVVIntrinsicUtils.h
  clang/lib/AST/ASTContext.cpp
  clang/lib/Sema/SemaRISCVVectorLookup.cpp
  clang/lib/Support/RISCVVIntrinsicUtils.cpp
  
clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vlseg2e32_tuple.c
  clang/utils/TableGen/RISCVVEmitter.cpp

Index: clang/utils/TableGen/RISCVVEmitter.cpp
===
--- clang/utils/TableGen/RISCVVEmitter.cpp
+++ clang/utils/TableGen/RISCVVEmitter.cpp
@@ -65,6 +65,7 @@
   bool HasMaskedOffOperand :1;
   bool HasTailPolicy : 1;
   bool HasMaskPolicy : 1;
+  bool IsTuple : 1;
   uint8_t UnMaskedPolicyScheme : 2;
   uint8_t MaskedPolicyScheme : 2;
 };
@@ -363,6 +364,16 @@
 TypeModifier::UnsignedInteger));
 printType(*UT);
   }
+  // FIXME: Expand more type declaration
+  if (I == 'i' && Log2LMUL == 0) { // vint32m1x2_t
+auto TupleT = TypeCache.computeType(
+BT, Log2LMUL,
+PrototypeDescriptor(BaseTypeModifier::Vector,
+VectorTypeModifier::Tuple2,
+TypeModifier::SignedInteger));
+if (TupleT)
+  printType(*TupleT);
+  }
 }
   }
 
@@ -512,6 +523,7 @@
 StringRef IRName = R->getValueAsString("IRName");
 StringRef MaskedIRName = R->getValueAsString("MaskedIRName");
 unsigned NF = R->getValueAsInt("NF");
+bool IsTuple = R->getValueAsBit("IsTuple");
 
 const Policy DefaultPolicy;
 SmallVector SupportedUnMaskedPolicies =
@@ -532,10 +544,10 @@
 auto Prototype = RVVIntrinsic::computeBuiltinTypes(
 BasicPrototype, /*IsMasked=*/false,
 /*HasMaskedOffOperand=*/false, HasVL, NF, UnMaskedPolicyScheme,
-DefaultPolicy);
+DefaultPolicy, IsTuple);
 auto MaskedPrototype = RVVIntrinsic::computeBuiltinTypes(
 BasicPrototype, /*IsMasked=*/true, HasMaskedOffOperand, HasVL, NF,
-MaskedPolicyScheme, DefaultPolicy);
+MaskedPolicyScheme, DefaultPolicy, IsTuple);
 
 // Create Intrinsics for each type and LMUL.
 for (char I : TypeRange) {
@@ -557,14 +569,14 @@
 /*IsMasked=*/false, /*HasMaskedOffOperand=*/false, HasVL,
 UnMaskedPolicyScheme, SupportOverloading, HasBuiltinAlias,
 ManualCodegen, *Types, IntrinsicTypes, RequiredFeatures, NF,
-DefaultPolicy));
+DefaultPolicy, IsTuple));
 if (UnMaskedPolicyScheme != PolicyScheme::SchemeNone)
   for (auto P : SupportedUnMaskedPolicies) {
 SmallVector PolicyPrototype =
 RVVIntrinsic::computeBuiltinTypes(
 BasicPrototype, /*IsMasked=*/false,
 /*HasMaskedOffOperand=*/false, HasVL, NF,
-UnMaskedPolicyScheme, P);
+UnMaskedPolicyScheme, P, IsTuple);
 std::optional PolicyTypes =
 TypeCache.computeTypes(BT, Log2LMUL, NF, PolicyPrototype);
 Out.push_back(std::make_unique(
@@ -572,7 +584,7 @@
 /*IsMask=*/false, /*HasMaskedOffOperand=*/false, HasVL,
 UnMaskedPolicyScheme, SupportOverloading, HasBuiltinAlias,
 ManualCodegen, *PolicyTypes, IntrinsicTypes, RequiredFeatures,
-NF, P));
+NF, P, IsTuple));
   }
 if (!HasMasked)
   continue;
@@ -583,14 +595,14 @@
 Name, SuffixStr, OverloadedName, OverloadedSuffixStr, MaskedIRName,
 /*IsMasked=*/true, HasMaskedOffOperand, HasVL, MaskedPolicyScheme,
 SupportOverloading, HasBuiltinAlias, ManualCodegen, *MaskTypes,
-IntrinsicTypes, RequiredFeatures, NF, DefaultPolicy));
+IntrinsicTypes, RequiredFeatures, NF, DefaultPolicy, IsTuple));
 if (MaskedPolicyScheme == PolicyScheme::SchemeNone)
   continue;
 for (auto P : SupportedMaskedPolicies) {
   SmallVector PolicyPrototype =
   RVVIntrinsic::computeBuiltinTypes(
   BasicPrototype, /*IsMasked=*/true, HasMaskedOffOperand, HasVL,
-  NF, MaskedPolicyScheme, P);
+  NF, MaskedPolicyScheme, P, IsTuple);
   std::optional PolicyTypes =
   TypeCache.computeTypes(BT, Log2LMUL, NF, PolicyPrototype);
   Out.push_back(std::make_unique(
@@ -598,7 +610,7 @@
   MaskedIRName, /*IsMasked=*/true, HasMaskedOffOperand, HasVL,
   MaskedPolicyScheme, SupportOverloading, HasBuiltinAlias,
   Manua

[PATCH] D149573: [Clang][C++23] Implement core language changes from P1467R9 extended floating-point types and standard names and adapt __bf16 to be arithmetic type

2023-05-22 Thread Ties Stuij via Phabricator via cfe-commits
stuij added a comment.

In D149573#4341323 , @codemzs wrote:

> @stuij, as you initially introduced `__bf16` as a storage-type, your review 
> on this adjustment would be greatly appreciated.

Sorry for the late reaction, was on holiday. Yes, I'll have a look. I've put it 
on my todo.


CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D149573/new/

https://reviews.llvm.org/D149573

___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D151047: [clang-format] Fix indentation for selective formatting.

2023-05-22 Thread MyDeveloperDay via Phabricator via cfe-commits
MyDeveloperDay accepted this revision.
MyDeveloperDay added a comment.
This revision is now accepted and ready to land.

Thank you for the indepth explaination in 
https://github.com/llvm/llvm-project/issues/59178, that was really helpful for 
me trying to understand what the problem was.

I thik your explaination is clear, the reason why you are suggesting this 
change, and as it passed all the test, hopefully we can apply the "Beyonce 
Rule" on  https://github.com/llvm/llvm-project/issues/56352, I recommend we 
pull in @curdeius  as a review

I'm going to accept this, but I would ask one of the others gives it the all 
clear too, let us know if you have commit access and if not and want one of us 
to land it we'll need you name and email to attribute the change to you.


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D151047/new/

https://reviews.llvm.org/D151047

___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D150685: [clangd] Renaming: Treat member functions like other functions

2023-05-22 Thread Christian Kandeler via Phabricator via cfe-commits
ckandeler added inline comments.



Comment at: clang-tools-extra/clangd/refactor/Rename.cpp:519
+if (RenameDecl.getKind() != Decl::Function &&
+RenameDecl.getKind() != Decl::CXXMethod) {
   if (auto *Conflict = lookupSiblingWithName(ASTCtx, RenameDecl, NewName))

hokein wrote:
> The change looks good. It would be nice to have a testcase, can you add one 
> in the `RenameTest, Renameable` unit test?
For a function, the rename result ends up in LocalChanges (because there is no 
index), whereas the test assumes they are in GlobalChanges. Should I adapt the 
test code accordingly or is it not the right one for this case?


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D150685/new/

https://reviews.llvm.org/D150685

___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D147717: [C++20][NFC] Claim full support for consteval again

2023-05-22 Thread Mariya Podchishchaeva via Phabricator via cfe-commits
Fznamznon added a comment.

Friendly ping. It is been a while.
@cjdb , any chance for an update?


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D147717/new/

https://reviews.llvm.org/D147717

___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D146242: [ARM] Fixing ABI mismatch for packed structs and fields

2023-05-22 Thread Tomas Matheson via Phabricator via cfe-commits
tmatheson added a comment.

Reverse-ping  @JiruiWu


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D146242/new/

https://reviews.llvm.org/D146242

___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D150685: [clangd] Renaming: Treat member functions like other functions

2023-05-22 Thread Haojian Wu via Phabricator via cfe-commits
hokein added inline comments.



Comment at: clang-tools-extra/clangd/refactor/Rename.cpp:519
+if (RenameDecl.getKind() != Decl::Function &&
+RenameDecl.getKind() != Decl::CXXMethod) {
   if (auto *Conflict = lookupSiblingWithName(ASTCtx, RenameDecl, NewName))

ckandeler wrote:
> hokein wrote:
> > The change looks good. It would be nice to have a testcase, can you add one 
> > in the `RenameTest, Renameable` unit test?
> For a function, the rename result ends up in LocalChanges (because there is 
> no index), whereas the test assumes they are in GlobalChanges. Should I adapt 
> the test code accordingly or is it not the right one for this case?
I see, you're right, sorry for missing this bit.

I think it makes sense to change the `RenameTest.Renamable` to use 
`LocalChanges` (comparing ranges should be enough), as all testcases there are 
a single file.




Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D150685/new/

https://reviews.llvm.org/D150685

___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D148206: [clang] Do not crash after suggesting typo correction to constexpr if condition

2023-05-22 Thread Zixuan Wu via Phabricator via cfe-commits
zixuan-wu added inline comments.



Comment at: clang/test/SemaCXX/invalid-if-constexpr.cpp:7
+}
+void a() { if constexpr (__adl_swap<>) {}} // expected-error{{use of 
undeclared identifier '__adl_swap'; did you mean '__sync_swap'?}} \
+   // expected-note {{'__sync_swap' 
declared here}}

Hi, why  `did you mean '__sync_swap'` is not reported in riscv target? So it's 
failed in check-all.


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D148206/new/

https://reviews.llvm.org/D148206

___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[clang] 0019226 - [3/11][POC][Clang][RISCV] Add typedef of the tuple type and define tuple type variant of vlseg2e32

2023-05-22 Thread via cfe-commits

Author: eopXD
Date: 2023-05-22T02:51:14-07:00
New Revision: 0019226ceef779c7d9aa55f2f56b30e948cc9251

URL: 
https://github.com/llvm/llvm-project/commit/0019226ceef779c7d9aa55f2f56b30e948cc9251
DIFF: 
https://github.com/llvm/llvm-project/commit/0019226ceef779c7d9aa55f2f56b30e948cc9251.diff

LOG: [3/11][POC][Clang][RISCV] Add typedef of the tuple type and define tuple 
type variant of vlseg2e32

For the cover letter of this patch-set, please checkout D146872.

Depends on D146873.

This is the 3rd patch of the patch-set. This patch originates from
D99593.

Note: This patch is a proof-of-concept and will be extended to full
coverage in the future. Currently, the old non-tuple unit-stride
segment load is not removed, and only signed integer unit-strided
segment load of NF=2, EEW=32 is defined here.

When replacing the old intrinsics, the extra `IsTuple` parameter under
various places will be redundant and removed.

Authored-by: eop Chen 
Co-Authored-by: Hsiangkai Wang 

Reviewed By: craig.topper

Differential Revision: https://reviews.llvm.org/D147731

Added: 

clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vlseg2e32_tuple.c

Modified: 
clang/include/clang/AST/ASTContext.h
clang/include/clang/Basic/riscv_vector.td
clang/include/clang/Basic/riscv_vector_common.td
clang/include/clang/Support/RISCVVIntrinsicUtils.h
clang/lib/AST/ASTContext.cpp
clang/lib/Sema/SemaRISCVVectorLookup.cpp
clang/lib/Support/RISCVVIntrinsicUtils.cpp
clang/utils/TableGen/RISCVVEmitter.cpp

Removed: 




diff  --git a/clang/include/clang/AST/ASTContext.h 
b/clang/include/clang/AST/ASTContext.h
index 06ba21a3bf391..bc4a0df296d71 100644
--- a/clang/include/clang/AST/ASTContext.h
+++ b/clang/include/clang/AST/ASTContext.h
@@ -1472,9 +1472,12 @@ class ASTContext : public RefCountedBase {
 
   /// Return the unique reference to a scalable vector type of the specified
   /// element type and scalable number of elements.
+  /// For RISC-V, number of fields is also provided when it fetching for
+  /// tuple type.
   ///
   /// \pre \p EltTy must be a built-in type.
-  QualType getScalableVectorType(QualType EltTy, unsigned NumElts) const;
+  QualType getScalableVectorType(QualType EltTy, unsigned NumElts,
+ unsigned NumFields = 1) const;
 
   /// Return a WebAssembly externref type.
   QualType getWebAssemblyExternrefType() const;

diff  --git a/clang/include/clang/Basic/riscv_vector.td 
b/clang/include/clang/Basic/riscv_vector.td
index 4fd769e0680d5..278b1cef74c71 100644
--- a/clang/include/clang/Basic/riscv_vector.td
+++ b/clang/include/clang/Basic/riscv_vector.td
@@ -1503,6 +1503,58 @@ defm : RVVStridedSegLoad<"vlsseg">;
 defm : RVVIndexedSegLoad<"vluxseg">;
 defm : RVVIndexedSegLoad<"vloxseg">;
 }
+
+multiclass RVVUnitStridedSegLoadTuple {
+  foreach type = ["i"] in {
+defvar eew = !cond(!eq(type, "i") : "32");
+  foreach nf = [2] in {
+let Name = op # nf # "e" # eew # "_v_tuple",
+OverloadedName = op # nf # "e" # eew # "_tuple",
+IRName = op # nf,
+MaskedIRName = op # nf # "_mask",
+NF = nf,
+ManualCodegen = [{
+{
+  assert(((IsMasked && (PolicyAttrs & RVV_VTA) && (PolicyAttrs & RVV_VMA)) 
||
+(!IsMasked && (PolicyAttrs & RVV_VTA))) &&
+"FIXME: Only handling default policy (TAMA) for now");
+
+  llvm::Type *ElementVectorType = 
cast(ResultType)->elements()[0];
+  IntrinsicTypes = {ElementVectorType, Ops.back()->getType()};
+  SmallVector Operands;
+
+  Operands.append(NF, llvm::PoisonValue::get(ElementVectorType));
+
+  unsigned Offset = IsMasked ? 1 : 0;
+  Operands.push_back(Ops[Offset]); // Ptr
+  if (IsMasked)
+Operands.push_back(Ops[0]);
+  Operands.push_back(Ops[Offset + 1]); // VL
+  if (IsMasked)
+Operands.push_back(ConstantInt::get(Ops.back()->getType(), 
PolicyAttrs));
+
+  llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
+
+  llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
+  if (ReturnValue.isNull())
+return LoadValue;
+  else
+return Builder.CreateStore(LoadValue, ReturnValue.getValue());
+}
+}] in {
+  defvar T = "(Tuple:" # nf # ")";
+  def : RVVBuiltin<"v", T # "vPCe", type>;
+  }
+}
+  }
+}
+// TODO: Extend for policy
+let UnMaskedPolicyScheme = NonePolicy,
+MaskedPolicyScheme = NonePolicy,
+IsTuple = true in {
+defm : RVVUnitStridedSegLoadTuple<"vlseg">;
+}
+
 let UnMaskedPolicyScheme = NonePolicy,
 MaskedPolicyScheme = NonePolicy in {
 defm : RVVUnitStridedSegStore<"vsseg">;

diff  --git a/clang/include/clang/Basic/riscv_vector_common.td 
b/clang/include/clang/Basic/riscv_vector_common.td
index 6fd1dbde52be4..f98432839f1d2 100644
--- a/clang/include/clang/Basic/riscv_vector_common.td
+++

[PATCH] D147731: [3/11][POC][Clang][RISCV] Add typedef of the tuple type and define tuple type variant of vlseg2e32

2023-05-22 Thread Yueh-Ting (eop) Chen via Phabricator via cfe-commits
This revision was automatically updated to reflect the committed changes.
Closed by commit rG0019226ceef7: [3/11][POC][Clang][RISCV] Add typedef of the 
tuple type and define tuple type… (authored by eopXD).

Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D147731/new/

https://reviews.llvm.org/D147731

Files:
  clang/include/clang/AST/ASTContext.h
  clang/include/clang/Basic/riscv_vector.td
  clang/include/clang/Basic/riscv_vector_common.td
  clang/include/clang/Support/RISCVVIntrinsicUtils.h
  clang/lib/AST/ASTContext.cpp
  clang/lib/Sema/SemaRISCVVectorLookup.cpp
  clang/lib/Support/RISCVVIntrinsicUtils.cpp
  
clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vlseg2e32_tuple.c
  clang/utils/TableGen/RISCVVEmitter.cpp

Index: clang/utils/TableGen/RISCVVEmitter.cpp
===
--- clang/utils/TableGen/RISCVVEmitter.cpp
+++ clang/utils/TableGen/RISCVVEmitter.cpp
@@ -65,6 +65,7 @@
   bool HasMaskedOffOperand :1;
   bool HasTailPolicy : 1;
   bool HasMaskPolicy : 1;
+  bool IsTuple : 1;
   uint8_t UnMaskedPolicyScheme : 2;
   uint8_t MaskedPolicyScheme : 2;
 };
@@ -363,6 +364,16 @@
 TypeModifier::UnsignedInteger));
 printType(*UT);
   }
+  // FIXME: Expand more type declaration
+  if (I == 'i' && Log2LMUL == 0) { // vint32m1x2_t
+auto TupleT = TypeCache.computeType(
+BT, Log2LMUL,
+PrototypeDescriptor(BaseTypeModifier::Vector,
+VectorTypeModifier::Tuple2,
+TypeModifier::SignedInteger));
+if (TupleT)
+  printType(*TupleT);
+  }
 }
   }
 
@@ -512,6 +523,7 @@
 StringRef IRName = R->getValueAsString("IRName");
 StringRef MaskedIRName = R->getValueAsString("MaskedIRName");
 unsigned NF = R->getValueAsInt("NF");
+bool IsTuple = R->getValueAsBit("IsTuple");
 
 const Policy DefaultPolicy;
 SmallVector SupportedUnMaskedPolicies =
@@ -532,10 +544,10 @@
 auto Prototype = RVVIntrinsic::computeBuiltinTypes(
 BasicPrototype, /*IsMasked=*/false,
 /*HasMaskedOffOperand=*/false, HasVL, NF, UnMaskedPolicyScheme,
-DefaultPolicy);
+DefaultPolicy, IsTuple);
 auto MaskedPrototype = RVVIntrinsic::computeBuiltinTypes(
 BasicPrototype, /*IsMasked=*/true, HasMaskedOffOperand, HasVL, NF,
-MaskedPolicyScheme, DefaultPolicy);
+MaskedPolicyScheme, DefaultPolicy, IsTuple);
 
 // Create Intrinsics for each type and LMUL.
 for (char I : TypeRange) {
@@ -557,14 +569,14 @@
 /*IsMasked=*/false, /*HasMaskedOffOperand=*/false, HasVL,
 UnMaskedPolicyScheme, SupportOverloading, HasBuiltinAlias,
 ManualCodegen, *Types, IntrinsicTypes, RequiredFeatures, NF,
-DefaultPolicy));
+DefaultPolicy, IsTuple));
 if (UnMaskedPolicyScheme != PolicyScheme::SchemeNone)
   for (auto P : SupportedUnMaskedPolicies) {
 SmallVector PolicyPrototype =
 RVVIntrinsic::computeBuiltinTypes(
 BasicPrototype, /*IsMasked=*/false,
 /*HasMaskedOffOperand=*/false, HasVL, NF,
-UnMaskedPolicyScheme, P);
+UnMaskedPolicyScheme, P, IsTuple);
 std::optional PolicyTypes =
 TypeCache.computeTypes(BT, Log2LMUL, NF, PolicyPrototype);
 Out.push_back(std::make_unique(
@@ -572,7 +584,7 @@
 /*IsMask=*/false, /*HasMaskedOffOperand=*/false, HasVL,
 UnMaskedPolicyScheme, SupportOverloading, HasBuiltinAlias,
 ManualCodegen, *PolicyTypes, IntrinsicTypes, RequiredFeatures,
-NF, P));
+NF, P, IsTuple));
   }
 if (!HasMasked)
   continue;
@@ -583,14 +595,14 @@
 Name, SuffixStr, OverloadedName, OverloadedSuffixStr, MaskedIRName,
 /*IsMasked=*/true, HasMaskedOffOperand, HasVL, MaskedPolicyScheme,
 SupportOverloading, HasBuiltinAlias, ManualCodegen, *MaskTypes,
-IntrinsicTypes, RequiredFeatures, NF, DefaultPolicy));
+IntrinsicTypes, RequiredFeatures, NF, DefaultPolicy, IsTuple));
 if (MaskedPolicyScheme == PolicyScheme::SchemeNone)
   continue;
 for (auto P : SupportedMaskedPolicies) {
   SmallVector PolicyPrototype =
   RVVIntrinsic::computeBuiltinTypes(
   BasicPrototype, /*IsMasked=*/true, HasMaskedOffOperand, HasVL,
-  NF, MaskedPolicyScheme, P);
+  NF, MaskedPolicyScheme, P, IsTuple);
   std::optional PolicyTypes =
   TypeCache.computeTypes(BT, Log2LMUL, NF, PolicyPrototype);
   Out.push_back(std::make_unique(
@@ -598,7 +610,7 @@
   MaskedIRName, /*IsMasked=*/true, HasMaskedOffOperand, HasVL,
   

[PATCH] D150685: [clangd] Renaming: Treat member functions like other functions

2023-05-22 Thread Christian Kandeler via Phabricator via cfe-commits
ckandeler updated this revision to Diff 524203.
ckandeler added a comment.

Added test cases.


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D150685/new/

https://reviews.llvm.org/D150685

Files:
  clang-tools-extra/clangd/refactor/Rename.cpp
  clang-tools-extra/clangd/unittests/RenameTests.cpp


Index: clang-tools-extra/clangd/unittests/RenameTests.cpp
===
--- clang-tools-extra/clangd/unittests/RenameTests.cpp
+++ clang-tools-extra/clangd/unittests/RenameTests.cpp
@@ -1061,7 +1061,20 @@
 }
   )cpp",
"conflict", !HeaderFile, "Conflict"},
-
+  
+  {R"cpp(
+void func(int);
+void [[o^therFunc]](double);
+  )cpp",
+   nullptr, !HeaderFile, "func"},
+  {R"cpp(
+struct S {
+  void func(int);
+  void [[o^therFunc]](double);
+};
+  )cpp",
+   nullptr, !HeaderFile, "func"},
+  
   {R"cpp(
 int V^ar;
   )cpp",
@@ -1121,9 +1134,7 @@
 } else {
   EXPECT_TRUE(bool(Results)) << "rename returned an error: "
  << llvm::toString(Results.takeError());
-  ASSERT_EQ(1u, Results->GlobalChanges.size());
-  EXPECT_EQ(applyEdits(std::move(Results->GlobalChanges)).front().second,
-expectedResult(T, NewName));
+  EXPECT_EQ(Results->LocalChanges, T.ranges());
 }
   }
 }
Index: clang-tools-extra/clangd/refactor/Rename.cpp
===
--- clang-tools-extra/clangd/refactor/Rename.cpp
+++ clang-tools-extra/clangd/refactor/Rename.cpp
@@ -515,7 +515,8 @@
   else {
 // Name conflict detection.
 // Function conflicts are subtle (overloading), so ignore them.
-if (RenameDecl.getKind() != Decl::Function) {
+if (RenameDecl.getKind() != Decl::Function &&
+RenameDecl.getKind() != Decl::CXXMethod) {
   if (auto *Conflict = lookupSiblingWithName(ASTCtx, RenameDecl, NewName))
 Result = InvalidName{
 InvalidName::Conflict,


Index: clang-tools-extra/clangd/unittests/RenameTests.cpp
===
--- clang-tools-extra/clangd/unittests/RenameTests.cpp
+++ clang-tools-extra/clangd/unittests/RenameTests.cpp
@@ -1061,7 +1061,20 @@
 }
   )cpp",
"conflict", !HeaderFile, "Conflict"},
-
+  
+  {R"cpp(
+void func(int);
+void [[o^therFunc]](double);
+  )cpp",
+   nullptr, !HeaderFile, "func"},
+  {R"cpp(
+struct S {
+  void func(int);
+  void [[o^therFunc]](double);
+};
+  )cpp",
+   nullptr, !HeaderFile, "func"},
+  
   {R"cpp(
 int V^ar;
   )cpp",
@@ -1121,9 +1134,7 @@
 } else {
   EXPECT_TRUE(bool(Results)) << "rename returned an error: "
  << llvm::toString(Results.takeError());
-  ASSERT_EQ(1u, Results->GlobalChanges.size());
-  EXPECT_EQ(applyEdits(std::move(Results->GlobalChanges)).front().second,
-expectedResult(T, NewName));
+  EXPECT_EQ(Results->LocalChanges, T.ranges());
 }
   }
 }
Index: clang-tools-extra/clangd/refactor/Rename.cpp
===
--- clang-tools-extra/clangd/refactor/Rename.cpp
+++ clang-tools-extra/clangd/refactor/Rename.cpp
@@ -515,7 +515,8 @@
   else {
 // Name conflict detection.
 // Function conflicts are subtle (overloading), so ignore them.
-if (RenameDecl.getKind() != Decl::Function) {
+if (RenameDecl.getKind() != Decl::Function &&
+RenameDecl.getKind() != Decl::CXXMethod) {
   if (auto *Conflict = lookupSiblingWithName(ASTCtx, RenameDecl, NewName))
 Result = InvalidName{
 InvalidName::Conflict,
___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[clang] f4d70d6 - [4/11][POC][Clang][RISCV] Define tuple type variant of vsseg2e32

2023-05-22 Thread via cfe-commits

Author: eopXD
Date: 2023-05-22T02:52:36-07:00
New Revision: f4d70d68e72d267afab7294918f340e232b94870

URL: 
https://github.com/llvm/llvm-project/commit/f4d70d68e72d267afab7294918f340e232b94870
DIFF: 
https://github.com/llvm/llvm-project/commit/f4d70d68e72d267afab7294918f340e232b94870.diff

LOG: [4/11][POC][Clang][RISCV] Define tuple type variant of vsseg2e32

For the cover letter of this patch-set, please checkout D146872.

Depends on D147731.

This is the 4th patch of the patch-set.

This patch is a proof-of-concept and will be extended to full coverage
in the future. Currently, the old non-tuple unit-stride segment store is
not removed, and only signed integer unit-strided segment store of NF=2,
EEW=32 is defined here.

Reviewed By: craig.topper

Differential Revision: https://reviews.llvm.org/D147774

Added: 

clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vsseg2e32_tuple.c

Modified: 
clang/include/clang/Basic/riscv_vector.td
clang/lib/CodeGen/CGBuiltin.cpp

Removed: 




diff  --git a/clang/include/clang/Basic/riscv_vector.td 
b/clang/include/clang/Basic/riscv_vector.td
index 278b1cef74c71..81f8da8b824d6 100644
--- a/clang/include/clang/Basic/riscv_vector.td
+++ b/clang/include/clang/Basic/riscv_vector.td
@@ -1548,6 +1548,49 @@ multiclass RVVUnitStridedSegLoadTuple {
 }
   }
 }
+
+multiclass RVVUnitStridedSegStoreTuple {
+  foreach type = ["i"] in {
+defvar eew = !cond(!eq(type, "i") : "32");
+foreach nf = [2] in {
+  let Name = op # nf # "e" # eew # "_v_tuple",
+  OverloadedName = op # nf # "e" # eew # "_tuple",
+  IRName = op # nf,
+  MaskedIRName = op # nf # "_mask",
+  NF = nf,
+  HasMaskedOffOperand = false,
+  ManualCodegen = [{
+{
+  // Masked
+  // Builtin: (mask, ptr, v_tuple, vl)
+  // Intrinsic: (val0, val1, ..., ptr, mask, vl)
+  // Unmasked
+  // Builtin: (ptr, v_tuple, vl)
+  // Intrinsic: (val0, val1, ..., ptr, vl)
+  unsigned Offset = IsMasked ? 1 : 0;
+  llvm::Value *VTupleOperand = Ops[Offset + 1];
+
+  SmallVector Operands;
+  for (unsigned I = 0; I < NF; ++I) {
+llvm::Value *V = Builder.CreateExtractValue(VTupleOperand, {I});
+Operands.push_back(V);
+  }
+  Operands.push_back(Ops[Offset]); // Ptr
+  if (IsMasked)
+Operands.push_back(Ops[0]);
+  Operands.push_back(Ops[Offset + 2]); // VL
+
+  IntrinsicTypes = {Operands[0]->getType(), Operands.back()->getType()};
+  llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
+  return Builder.CreateCall(F, Operands, "");
+   }
+  }] in {
+  defvar T = "(Tuple:" # nf # ")";
+  def : RVVBuiltin<"v", "0Pe" # T # "v", type>;
+  }
+}
+  }
+}
 // TODO: Extend for policy
 let UnMaskedPolicyScheme = NonePolicy,
 MaskedPolicyScheme = NonePolicy,
@@ -1555,6 +1598,13 @@ let UnMaskedPolicyScheme = NonePolicy,
 defm : RVVUnitStridedSegLoadTuple<"vlseg">;
 }
 
+let UnMaskedPolicyScheme = NonePolicy,
+MaskedPolicyScheme = NonePolicy,
+IsTuple = true in {
+defm : RVVUnitStridedSegStoreTuple<"vsseg">;
+}
+
+
 let UnMaskedPolicyScheme = NonePolicy,
 MaskedPolicyScheme = NonePolicy in {
 defm : RVVUnitStridedSegStore<"vsseg">;

diff  --git a/clang/lib/CodeGen/CGBuiltin.cpp b/clang/lib/CodeGen/CGBuiltin.cpp
index b4dae69702608..736d2332a2f5e 100644
--- a/clang/lib/CodeGen/CGBuiltin.cpp
+++ b/clang/lib/CodeGen/CGBuiltin.cpp
@@ -19793,6 +19793,14 @@ Value *CodeGenFunction::EmitRISCVBuiltinExpr(unsigned 
BuiltinID,
 ICEArguments |= (1 << 2);
 
   for (unsigned i = 0, e = E->getNumArgs(); i != e; i++) {
+// Handle aggregate argument, namely RVV tuple types in segment load/store
+if (hasAggregateEvaluationKind(E->getArg(i)->getType())) {
+  LValue L = EmitAggExprToLValue(E->getArg(i));
+  llvm::Value *AggValue = Builder.CreateLoad(L.getAddress(*this));
+  Ops.push_back(AggValue);
+  continue;
+}
+
 // If this is a normal argument, just emit it as a scalar.
 if ((ICEArguments & (1 << i)) == 0) {
   Ops.push_back(EmitScalarExpr(E->getArg(i)));

diff  --git 
a/clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vsseg2e32_tuple.c
 
b/clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vsseg2e32_tuple.c
new file mode 100644
index 0..1f3512ec0f6af
--- /dev/null
+++ 
b/clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vsseg2e32_tuple.c
@@ -0,0 +1,31 @@
+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py 
UTC_ARGS: --version 2
+// REQUIRES: riscv-registered-target
+// RUN: %clang_cc1 -triple riscv64 -target-feature +v -target-feature +zfh \
+// RUN:   -target-feature +experimental-zvfh -disable-O0-optnone  \
+// RUN:   -emit-llvm %s -o - | opt -S -passes=mem2reg | \
+// RUN:

[PATCH] D147774: [4/11][POC][Clang][RISCV] Define tuple type variant of vsseg2e32

2023-05-22 Thread Yueh-Ting (eop) Chen via Phabricator via cfe-commits
This revision was landed with ongoing or failed builds.
This revision was automatically updated to reflect the committed changes.
Closed by commit rGf4d70d68e72d: [4/11][POC][Clang][RISCV] Define tuple type 
variant of vsseg2e32 (authored by eopXD).

Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D147774/new/

https://reviews.llvm.org/D147774

Files:
  clang/include/clang/Basic/riscv_vector.td
  clang/lib/CodeGen/CGBuiltin.cpp
  
clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vsseg2e32_tuple.c

Index: clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vsseg2e32_tuple.c
===
--- /dev/null
+++ clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vsseg2e32_tuple.c
@@ -0,0 +1,31 @@
+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --version 2
+// REQUIRES: riscv-registered-target
+// RUN: %clang_cc1 -triple riscv64 -target-feature +v -target-feature +zfh \
+// RUN:   -target-feature +experimental-zvfh -disable-O0-optnone  \
+// RUN:   -emit-llvm %s -o - | opt -S -passes=mem2reg | \
+// RUN:   FileCheck --check-prefix=CHECK-RV64 %s
+#include 
+
+// CHECK-RV64-LABEL: define dso_local void @test_vsseg2e32_v_tuple_i32m1
+// CHECK-RV64-SAME: (ptr noundef [[BASE:%.*]],  [[V_TUPLE_COERCE0:%.*]],  [[V_TUPLE_COERCE1:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0:[0-9]+]] {
+// CHECK-RV64-NEXT:  entry:
+// CHECK-RV64-NEXT:[[TMP0:%.*]] = insertvalue { ,  } poison,  [[V_TUPLE_COERCE0]], 0
+// CHECK-RV64-NEXT:[[TMP1:%.*]] = insertvalue { ,  } [[TMP0]],  [[V_TUPLE_COERCE1]], 1
+// CHECK-RV64-NEXT:[[TMP2:%.*]] = extractvalue { ,  } [[TMP1]], 0
+// CHECK-RV64-NEXT:[[TMP3:%.*]] = extractvalue { ,  } [[TMP1]], 1
+// CHECK-RV64-NEXT:call void @llvm.riscv.vsseg2.nxv2i32.i64( [[TMP2]],  [[TMP3]], ptr [[BASE]], i64 [[VL]])
+// CHECK-RV64-NEXT:ret void
+//
+void test_vsseg2e32_v_tuple_i32m1(int32_t *base, vint32m1x2_t v_tuple, size_t vl) {
+  return __riscv_vsseg2e32_v_tuple_i32m1(base, v_tuple, vl);
+}
+
+// CHECK-RV64-LABEL: define dso_local void @test_vsseg2e32_v_i32m1_m
+// CHECK-RV64-SAME: ( [[MASK:%.*]], ptr noundef [[BASE:%.*]],  [[V0:%.*]],  [[V1:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] {
+// CHECK-RV64-NEXT:  entry:
+// CHECK-RV64-NEXT:call void @llvm.riscv.vsseg2.mask.nxv2i32.i64( [[V0]],  [[V1]], ptr [[BASE]],  [[MASK]], i64 [[VL]])
+// CHECK-RV64-NEXT:ret void
+//
+void test_vsseg2e32_v_i32m1_m(vbool32_t mask, int32_t *base, vint32m1_t v0, vint32m1_t v1, size_t vl) {
+  return __riscv_vsseg2e32_v_i32m1_m(mask, base, v0, v1, vl);
+}
Index: clang/lib/CodeGen/CGBuiltin.cpp
===
--- clang/lib/CodeGen/CGBuiltin.cpp
+++ clang/lib/CodeGen/CGBuiltin.cpp
@@ -19793,6 +19793,14 @@
 ICEArguments |= (1 << 2);
 
   for (unsigned i = 0, e = E->getNumArgs(); i != e; i++) {
+// Handle aggregate argument, namely RVV tuple types in segment load/store
+if (hasAggregateEvaluationKind(E->getArg(i)->getType())) {
+  LValue L = EmitAggExprToLValue(E->getArg(i));
+  llvm::Value *AggValue = Builder.CreateLoad(L.getAddress(*this));
+  Ops.push_back(AggValue);
+  continue;
+}
+
 // If this is a normal argument, just emit it as a scalar.
 if ((ICEArguments & (1 << i)) == 0) {
   Ops.push_back(EmitScalarExpr(E->getArg(i)));
Index: clang/include/clang/Basic/riscv_vector.td
===
--- clang/include/clang/Basic/riscv_vector.td
+++ clang/include/clang/Basic/riscv_vector.td
@@ -1548,6 +1548,49 @@
 }
   }
 }
+
+multiclass RVVUnitStridedSegStoreTuple {
+  foreach type = ["i"] in {
+defvar eew = !cond(!eq(type, "i") : "32");
+foreach nf = [2] in {
+  let Name = op # nf # "e" # eew # "_v_tuple",
+  OverloadedName = op # nf # "e" # eew # "_tuple",
+  IRName = op # nf,
+  MaskedIRName = op # nf # "_mask",
+  NF = nf,
+  HasMaskedOffOperand = false,
+  ManualCodegen = [{
+{
+  // Masked
+  // Builtin: (mask, ptr, v_tuple, vl)
+  // Intrinsic: (val0, val1, ..., ptr, mask, vl)
+  // Unmasked
+  // Builtin: (ptr, v_tuple, vl)
+  // Intrinsic: (val0, val1, ..., ptr, vl)
+  unsigned Offset = IsMasked ? 1 : 0;
+  llvm::Value *VTupleOperand = Ops[Offset + 1];
+
+  SmallVector Operands;
+  for (unsigned I = 0; I < NF; ++I) {
+llvm::Value *V = Builder.CreateExtractValue(VTupleOperand, {I});
+Operands.push_back(V);
+  }
+  Operands.push_back(Ops[Offset]); // Ptr
+  if (IsMasked)
+Operands.push_back(Ops[0]);
+  Operands.push_back(Ops[Offset + 2]); // VL
+
+  IntrinsicTypes = {Operands[0]->getType(), Operands.back()->getType()};
+  llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
+  ret

[PATCH] D151071: [clang][dataflow] Fix a null pointer crash in `computeBlockInputState()`.

2023-05-22 Thread Martin Böhme via Phabricator via cfe-commits
mboehme created this revision.
Herald added subscribers: martong, xazax.hun.
Herald added a reviewer: NoQ.
Herald added a project: All.
mboehme requested review of this revision.
Herald added a project: clang.
Herald added a subscriber: cfe-commits.

The crash was due to unconditionally calling
`Block.succ_begin()->getReachableBlock()->hasNoReturnElement()`, but
`getReachableBlock()` can return null now that we have turned
`PruneTriviallyFalseEdges` on.

This patch adds two tests that crash without the fix.


Repository:
  rG LLVM Github Monorepo

https://reviews.llvm.org/D151071

Files:
  clang/lib/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.cpp
  clang/unittests/Analysis/FlowSensitive/TypeErasedDataflowAnalysisTest.cpp


Index: clang/unittests/Analysis/FlowSensitive/TypeErasedDataflowAnalysisTest.cpp
===
--- clang/unittests/Analysis/FlowSensitive/TypeErasedDataflowAnalysisTest.cpp
+++ clang/unittests/Analysis/FlowSensitive/TypeErasedDataflowAnalysisTest.cpp
@@ -296,6 +296,22 @@
  UnorderedElementsAre("foo"));
 }
 
+TEST_F(NoreturnDestructorTest,
+   ConditionalOperatorConstantCondition_LeftBranchReturns) {
+  std::string Code = R"(
+#include "noreturn_destructor_test_defs.h"
+
+void target() {
+  int value = true ? foo() : Fatal().bar();
+  (void)0;
+  // [[p]]
+}
+  )";
+  runDataflow(Code, UnorderedElementsAre(IsStringMapEntry(
+"p", HoldsFunctionCallLattice(HasCalledFunctions(
+ UnorderedElementsAre("foo"));
+}
+
 TEST_F(NoreturnDestructorTest, ConditionalOperatorRightBranchReturns) {
   std::string Code = R"(
 #include "noreturn_destructor_test_defs.h"
@@ -311,6 +327,22 @@
  UnorderedElementsAre("foo"));
 }
 
+TEST_F(NoreturnDestructorTest,
+   ConditionalOperatorConstantCondition_RightBranchReturns) {
+  std::string Code = R"(
+#include "noreturn_destructor_test_defs.h"
+
+void target() {
+  int value = false ? Fatal().bar() : foo();
+  (void)0;
+  // [[p]]
+}
+  )";
+  runDataflow(Code, UnorderedElementsAre(IsStringMapEntry(
+"p", HoldsFunctionCallLattice(HasCalledFunctions(
+ UnorderedElementsAre("foo"));
+}
+
 TEST_F(NoreturnDestructorTest, ConditionalOperatorNestedBranchesDoNotReturn) {
   std::string Code = R"(
 #include "noreturn_destructor_test_defs.h"
Index: clang/lib/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.cpp
===
--- clang/lib/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.cpp
+++ clang/lib/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.cpp
@@ -219,7 +219,8 @@
 // operator includes a branch that contains a noreturn destructor call.
 //
 // See `NoreturnDestructorTest` for concrete examples.
-if (Block.succ_begin()->getReachableBlock()->hasNoReturnElement()) {
+if (Block.succ_begin()->getReachableBlock() != nullptr &&
+Block.succ_begin()->getReachableBlock()->hasNoReturnElement()) {
   auto &StmtToBlock = AC.CFCtx.getStmtToBlock();
   auto StmtBlock = StmtToBlock.find(Block.getTerminatorStmt());
   assert(StmtBlock != StmtToBlock.end());


Index: clang/unittests/Analysis/FlowSensitive/TypeErasedDataflowAnalysisTest.cpp
===
--- clang/unittests/Analysis/FlowSensitive/TypeErasedDataflowAnalysisTest.cpp
+++ clang/unittests/Analysis/FlowSensitive/TypeErasedDataflowAnalysisTest.cpp
@@ -296,6 +296,22 @@
  UnorderedElementsAre("foo"));
 }
 
+TEST_F(NoreturnDestructorTest,
+   ConditionalOperatorConstantCondition_LeftBranchReturns) {
+  std::string Code = R"(
+#include "noreturn_destructor_test_defs.h"
+
+void target() {
+  int value = true ? foo() : Fatal().bar();
+  (void)0;
+  // [[p]]
+}
+  )";
+  runDataflow(Code, UnorderedElementsAre(IsStringMapEntry(
+"p", HoldsFunctionCallLattice(HasCalledFunctions(
+ UnorderedElementsAre("foo"));
+}
+
 TEST_F(NoreturnDestructorTest, ConditionalOperatorRightBranchReturns) {
   std::string Code = R"(
 #include "noreturn_destructor_test_defs.h"
@@ -311,6 +327,22 @@
  UnorderedElementsAre("foo"));
 }
 
+TEST_F(NoreturnDestructorTest,
+   ConditionalOperatorConstantCondition_RightBranchReturns) {
+  std::string Code = R"(
+#include "noreturn_destructor_test_defs.h"
+
+void target() {
+  int value = false ? Fatal().bar() : foo();
+  (void)0;
+  // [[p]]
+}
+  )";
+  runDataflow(Code, UnorderedElementsAre(IsStringMapEntry(
+"p", HoldsFunctionCallLattice(HasCalledFunctions(
+ UnorderedElementsAre("foo"));
+}
+
 TEST_F

[PATCH] D150685: [clangd] Renaming: Treat member functions like other functions

2023-05-22 Thread Christian Kandeler via Phabricator via cfe-commits
ckandeler updated this revision to Diff 524206.
ckandeler added a comment.

Formatting glitch.


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D150685/new/

https://reviews.llvm.org/D150685

Files:
  clang-tools-extra/clangd/refactor/Rename.cpp
  clang-tools-extra/clangd/unittests/RenameTests.cpp


Index: clang-tools-extra/clangd/unittests/RenameTests.cpp
===
--- clang-tools-extra/clangd/unittests/RenameTests.cpp
+++ clang-tools-extra/clangd/unittests/RenameTests.cpp
@@ -1062,6 +1062,19 @@
   )cpp",
"conflict", !HeaderFile, "Conflict"},
 
+  {R"cpp(
+void func(int);
+void [[o^therFunc]](double);
+  )cpp",
+   nullptr, !HeaderFile, "func"},
+  {R"cpp(
+struct S {
+  void func(int);
+  void [[o^therFunc]](double);
+};
+  )cpp",
+   nullptr, !HeaderFile, "func"},
+  
   {R"cpp(
 int V^ar;
   )cpp",
@@ -1121,9 +1134,7 @@
 } else {
   EXPECT_TRUE(bool(Results)) << "rename returned an error: "
  << llvm::toString(Results.takeError());
-  ASSERT_EQ(1u, Results->GlobalChanges.size());
-  EXPECT_EQ(applyEdits(std::move(Results->GlobalChanges)).front().second,
-expectedResult(T, NewName));
+  EXPECT_EQ(Results->LocalChanges, T.ranges());
 }
   }
 }
Index: clang-tools-extra/clangd/refactor/Rename.cpp
===
--- clang-tools-extra/clangd/refactor/Rename.cpp
+++ clang-tools-extra/clangd/refactor/Rename.cpp
@@ -515,7 +515,8 @@
   else {
 // Name conflict detection.
 // Function conflicts are subtle (overloading), so ignore them.
-if (RenameDecl.getKind() != Decl::Function) {
+if (RenameDecl.getKind() != Decl::Function &&
+RenameDecl.getKind() != Decl::CXXMethod) {
   if (auto *Conflict = lookupSiblingWithName(ASTCtx, RenameDecl, NewName))
 Result = InvalidName{
 InvalidName::Conflict,


Index: clang-tools-extra/clangd/unittests/RenameTests.cpp
===
--- clang-tools-extra/clangd/unittests/RenameTests.cpp
+++ clang-tools-extra/clangd/unittests/RenameTests.cpp
@@ -1062,6 +1062,19 @@
   )cpp",
"conflict", !HeaderFile, "Conflict"},
 
+  {R"cpp(
+void func(int);
+void [[o^therFunc]](double);
+  )cpp",
+   nullptr, !HeaderFile, "func"},
+  {R"cpp(
+struct S {
+  void func(int);
+  void [[o^therFunc]](double);
+};
+  )cpp",
+   nullptr, !HeaderFile, "func"},
+  
   {R"cpp(
 int V^ar;
   )cpp",
@@ -1121,9 +1134,7 @@
 } else {
   EXPECT_TRUE(bool(Results)) << "rename returned an error: "
  << llvm::toString(Results.takeError());
-  ASSERT_EQ(1u, Results->GlobalChanges.size());
-  EXPECT_EQ(applyEdits(std::move(Results->GlobalChanges)).front().second,
-expectedResult(T, NewName));
+  EXPECT_EQ(Results->LocalChanges, T.ranges());
 }
   }
 }
Index: clang-tools-extra/clangd/refactor/Rename.cpp
===
--- clang-tools-extra/clangd/refactor/Rename.cpp
+++ clang-tools-extra/clangd/refactor/Rename.cpp
@@ -515,7 +515,8 @@
   else {
 // Name conflict detection.
 // Function conflicts are subtle (overloading), so ignore them.
-if (RenameDecl.getKind() != Decl::Function) {
+if (RenameDecl.getKind() != Decl::Function &&
+RenameDecl.getKind() != Decl::CXXMethod) {
   if (auto *Conflict = lookupSiblingWithName(ASTCtx, RenameDecl, NewName))
 Result = InvalidName{
 InvalidName::Conflict,
___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D150685: [clangd] Renaming: Treat member functions like other functions

2023-05-22 Thread Haojian Wu via Phabricator via cfe-commits
hokein accepted this revision.
hokein added a comment.
This revision is now accepted and ready to land.

nice, thank you!


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D150685/new/

https://reviews.llvm.org/D150685

___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D151073: [clang] Fix label (de-)serialization in ASM statements.

2023-05-22 Thread Viktoriia Bakalova via Phabricator via cfe-commits
VitaNuo created this revision.
Herald added a project: All.
VitaNuo requested review of this revision.
Herald added a project: clang.
Herald added a subscriber: cfe-commits.

Repository:
  rG LLVM Github Monorepo

https://reviews.llvm.org/D151073

Files:
  clang/lib/Serialization/ASTReaderStmt.cpp
  clang/lib/Serialization/ASTWriterStmt.cpp
  clang/test/PCH/asm-label.cpp


Index: clang/test/PCH/asm-label.cpp
===
--- /dev/null
+++ clang/test/PCH/asm-label.cpp
@@ -0,0 +1,24 @@
+// RUN: %clang_cc1 -emit-pch %s -o %t
+// RUN: %clang_cc1 -include-pch %t %s -verify
+#ifndef HEADER_H
+#define HEADER_H
+#pragma once
+template 
+void MyMethod() {
+  void *bar;
+  some_path:
+  asm goto
+  (
+  "mov %w[foo], %w[foo]"
+  : [foo] "=r"(bar)
+  : [foo2] "r"(bar)
+  : 
+  : some_path
+  );
+  }
+#else
+void test() {
+ MyMethod();
+// expected-no-diagnostics
+}
+#endif
Index: clang/lib/Serialization/ASTWriterStmt.cpp
===
--- clang/lib/Serialization/ASTWriterStmt.cpp
+++ clang/lib/Serialization/ASTWriterStmt.cpp
@@ -317,7 +317,10 @@
 Record.AddStmt(S->getClobberStringLiteral(I));
 
   // Labels
-  for (auto *E : S->labels()) Record.AddStmt(E);
+  for (unsigned I = 0, N = S->getNumLabels(); I != N; ++I) {
+Record.AddIdentifierRef(S->getLabelIdentifier(I));
+Record.AddStmt(S->getLabelExpr(I));
+  }
 
   Code = serialization::STMT_GCCASM;
 }
Index: clang/lib/Serialization/ASTReaderStmt.cpp
===
--- clang/lib/Serialization/ASTReaderStmt.cpp
+++ clang/lib/Serialization/ASTReaderStmt.cpp
@@ -400,8 +400,10 @@
 Clobbers.push_back(cast_or_null(Record.readSubStmt()));
 
   // Labels
-  for (unsigned I = 0, N = NumLabels; I != N; ++I)
+  for (unsigned I = 0, N = NumLabels; I != N; ++I) {
+Names.push_back(Record.readIdentifier());
 Exprs.push_back(Record.readSubStmt());
+  }
 
   S->setOutputsAndInputsAndClobbers(Record.getContext(),
 Names.data(), Constraints.data(),


Index: clang/test/PCH/asm-label.cpp
===
--- /dev/null
+++ clang/test/PCH/asm-label.cpp
@@ -0,0 +1,24 @@
+// RUN: %clang_cc1 -emit-pch %s -o %t
+// RUN: %clang_cc1 -include-pch %t %s -verify
+#ifndef HEADER_H
+#define HEADER_H
+#pragma once
+template 
+void MyMethod() {
+  void *bar;
+  some_path:
+  asm goto
+  (
+  "mov %w[foo], %w[foo]"
+  : [foo] "=r"(bar)
+  : [foo2] "r"(bar)
+  : 
+  : some_path
+  );
+  }
+#else
+void test() {
+ MyMethod();
+// expected-no-diagnostics
+}
+#endif
Index: clang/lib/Serialization/ASTWriterStmt.cpp
===
--- clang/lib/Serialization/ASTWriterStmt.cpp
+++ clang/lib/Serialization/ASTWriterStmt.cpp
@@ -317,7 +317,10 @@
 Record.AddStmt(S->getClobberStringLiteral(I));
 
   // Labels
-  for (auto *E : S->labels()) Record.AddStmt(E);
+  for (unsigned I = 0, N = S->getNumLabels(); I != N; ++I) {
+Record.AddIdentifierRef(S->getLabelIdentifier(I));
+Record.AddStmt(S->getLabelExpr(I));
+  }
 
   Code = serialization::STMT_GCCASM;
 }
Index: clang/lib/Serialization/ASTReaderStmt.cpp
===
--- clang/lib/Serialization/ASTReaderStmt.cpp
+++ clang/lib/Serialization/ASTReaderStmt.cpp
@@ -400,8 +400,10 @@
 Clobbers.push_back(cast_or_null(Record.readSubStmt()));
 
   // Labels
-  for (unsigned I = 0, N = NumLabels; I != N; ++I)
+  for (unsigned I = 0, N = NumLabels; I != N; ++I) {
+Names.push_back(Record.readIdentifier());
 Exprs.push_back(Record.readSubStmt());
+  }
 
   S->setOutputsAndInputsAndClobbers(Record.getContext(),
 Names.data(), Constraints.data(),
___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D151073: [clang] Fix label (de-)serialization in ASM statements.

2023-05-22 Thread Viktoriia Bakalova via Phabricator via cfe-commits
VitaNuo updated this revision to Diff 524211.
VitaNuo added a comment.

Remove template param.


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D151073/new/

https://reviews.llvm.org/D151073

Files:
  clang/lib/Serialization/ASTReaderStmt.cpp
  clang/lib/Serialization/ASTWriterStmt.cpp
  clang/test/PCH/asm-label.cpp


Index: clang/test/PCH/asm-label.cpp
===
--- /dev/null
+++ clang/test/PCH/asm-label.cpp
@@ -0,0 +1,23 @@
+// RUN: %clang_cc1 -emit-pch %s -o %t
+// RUN: %clang_cc1 -include-pch %t %s -verify
+#ifndef HEADER_H
+#define HEADER_H
+#pragma once
+void MyMethod() {
+  void *bar;
+  some_path:
+  asm goto
+  (
+  "mov %w[foo], %w[foo]"
+  : [foo] "=r"(bar)
+  : [foo2] "r"(bar)
+  : 
+  : some_path
+  );
+  }
+#else
+void test() {
+ MyMethod();
+// expected-no-diagnostics
+}
+#endif
Index: clang/lib/Serialization/ASTWriterStmt.cpp
===
--- clang/lib/Serialization/ASTWriterStmt.cpp
+++ clang/lib/Serialization/ASTWriterStmt.cpp
@@ -317,7 +317,10 @@
 Record.AddStmt(S->getClobberStringLiteral(I));
 
   // Labels
-  for (auto *E : S->labels()) Record.AddStmt(E);
+  for (unsigned I = 0, N = S->getNumLabels(); I != N; ++I) {
+Record.AddIdentifierRef(S->getLabelIdentifier(I));
+Record.AddStmt(S->getLabelExpr(I));
+  }
 
   Code = serialization::STMT_GCCASM;
 }
Index: clang/lib/Serialization/ASTReaderStmt.cpp
===
--- clang/lib/Serialization/ASTReaderStmt.cpp
+++ clang/lib/Serialization/ASTReaderStmt.cpp
@@ -400,8 +400,10 @@
 Clobbers.push_back(cast_or_null(Record.readSubStmt()));
 
   // Labels
-  for (unsigned I = 0, N = NumLabels; I != N; ++I)
+  for (unsigned I = 0, N = NumLabels; I != N; ++I) {
+Names.push_back(Record.readIdentifier());
 Exprs.push_back(Record.readSubStmt());
+  }
 
   S->setOutputsAndInputsAndClobbers(Record.getContext(),
 Names.data(), Constraints.data(),


Index: clang/test/PCH/asm-label.cpp
===
--- /dev/null
+++ clang/test/PCH/asm-label.cpp
@@ -0,0 +1,23 @@
+// RUN: %clang_cc1 -emit-pch %s -o %t
+// RUN: %clang_cc1 -include-pch %t %s -verify
+#ifndef HEADER_H
+#define HEADER_H
+#pragma once
+void MyMethod() {
+  void *bar;
+  some_path:
+  asm goto
+  (
+  "mov %w[foo], %w[foo]"
+  : [foo] "=r"(bar)
+  : [foo2] "r"(bar)
+  : 
+  : some_path
+  );
+  }
+#else
+void test() {
+ MyMethod();
+// expected-no-diagnostics
+}
+#endif
Index: clang/lib/Serialization/ASTWriterStmt.cpp
===
--- clang/lib/Serialization/ASTWriterStmt.cpp
+++ clang/lib/Serialization/ASTWriterStmt.cpp
@@ -317,7 +317,10 @@
 Record.AddStmt(S->getClobberStringLiteral(I));
 
   // Labels
-  for (auto *E : S->labels()) Record.AddStmt(E);
+  for (unsigned I = 0, N = S->getNumLabels(); I != N; ++I) {
+Record.AddIdentifierRef(S->getLabelIdentifier(I));
+Record.AddStmt(S->getLabelExpr(I));
+  }
 
   Code = serialization::STMT_GCCASM;
 }
Index: clang/lib/Serialization/ASTReaderStmt.cpp
===
--- clang/lib/Serialization/ASTReaderStmt.cpp
+++ clang/lib/Serialization/ASTReaderStmt.cpp
@@ -400,8 +400,10 @@
 Clobbers.push_back(cast_or_null(Record.readSubStmt()));
 
   // Labels
-  for (unsigned I = 0, N = NumLabels; I != N; ++I)
+  for (unsigned I = 0, N = NumLabels; I != N; ++I) {
+Names.push_back(Record.readIdentifier());
 Exprs.push_back(Record.readSubStmt());
+  }
 
   S->setOutputsAndInputsAndClobbers(Record.getContext(),
 Names.data(), Constraints.data(),
___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[libclc] 382b56d - [libclc] Fix linking against libLLVMSupport

2023-05-22 Thread Nikita Popov via cfe-commits

Author: Thomas Debesse
Date: 2023-05-22T12:22:05+02:00
New Revision: 382b56d5bd0356ba53bbaf9bfb988f315a7530b5

URL: 
https://github.com/llvm/llvm-project/commit/382b56d5bd0356ba53bbaf9bfb988f315a7530b5
DIFF: 
https://github.com/llvm/llvm-project/commit/382b56d5bd0356ba53bbaf9bfb988f315a7530b5.diff

LOG: [libclc] Fix linking against libLLVMSupport

Fixes https://github.com/llvm/llvm-project/issues/62018.

Added: 


Modified: 
libclc/CMakeLists.txt

Removed: 




diff  --git a/libclc/CMakeLists.txt b/libclc/CMakeLists.txt
index 0eda12670b710..4a1c8b1ba4932 100644
--- a/libclc/CMakeLists.txt
+++ b/libclc/CMakeLists.txt
@@ -115,6 +115,7 @@ set(LLVM_LINK_COMPONENTS
   BitReader
   BitWriter
   Core
+  Support
 )
 add_llvm_executable( prepare_builtins utils/prepare-builtins.cpp )
 target_compile_definitions( prepare_builtins PRIVATE ${LLVM_VERSION_DEFINE} )



___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D150685: [clangd] Renaming: Treat member functions like other functions

2023-05-22 Thread Christian Kandeler via Phabricator via cfe-commits
ckandeler updated this revision to Diff 524214.
ckandeler added a comment.

Fixed clang-format complaints.


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D150685/new/

https://reviews.llvm.org/D150685

Files:
  clang-tools-extra/clangd/refactor/Rename.cpp
  clang-tools-extra/clangd/unittests/RenameTests.cpp


Index: clang-tools-extra/clangd/unittests/RenameTests.cpp
===
--- clang-tools-extra/clangd/unittests/RenameTests.cpp
+++ clang-tools-extra/clangd/unittests/RenameTests.cpp
@@ -1062,6 +1062,19 @@
   )cpp",
"conflict", !HeaderFile, "Conflict"},
 
+  {R"cpp(
+void func(int);
+void [[o^therFunc]](double);
+  )cpp",
+   nullptr, !HeaderFile, "func"},
+  {R"cpp(
+struct S {
+  void func(int);
+  void [[o^therFunc]](double);
+};
+  )cpp",
+   nullptr, !HeaderFile, "func"},
+
   {R"cpp(
 int V^ar;
   )cpp",
@@ -1121,9 +1134,7 @@
 } else {
   EXPECT_TRUE(bool(Results)) << "rename returned an error: "
  << llvm::toString(Results.takeError());
-  ASSERT_EQ(1u, Results->GlobalChanges.size());
-  EXPECT_EQ(applyEdits(std::move(Results->GlobalChanges)).front().second,
-expectedResult(T, NewName));
+  EXPECT_EQ(Results->LocalChanges, T.ranges());
 }
   }
 }
Index: clang-tools-extra/clangd/refactor/Rename.cpp
===
--- clang-tools-extra/clangd/refactor/Rename.cpp
+++ clang-tools-extra/clangd/refactor/Rename.cpp
@@ -515,7 +515,8 @@
   else {
 // Name conflict detection.
 // Function conflicts are subtle (overloading), so ignore them.
-if (RenameDecl.getKind() != Decl::Function) {
+if (RenameDecl.getKind() != Decl::Function &&
+RenameDecl.getKind() != Decl::CXXMethod) {
   if (auto *Conflict = lookupSiblingWithName(ASTCtx, RenameDecl, NewName))
 Result = InvalidName{
 InvalidName::Conflict,


Index: clang-tools-extra/clangd/unittests/RenameTests.cpp
===
--- clang-tools-extra/clangd/unittests/RenameTests.cpp
+++ clang-tools-extra/clangd/unittests/RenameTests.cpp
@@ -1062,6 +1062,19 @@
   )cpp",
"conflict", !HeaderFile, "Conflict"},
 
+  {R"cpp(
+void func(int);
+void [[o^therFunc]](double);
+  )cpp",
+   nullptr, !HeaderFile, "func"},
+  {R"cpp(
+struct S {
+  void func(int);
+  void [[o^therFunc]](double);
+};
+  )cpp",
+   nullptr, !HeaderFile, "func"},
+
   {R"cpp(
 int V^ar;
   )cpp",
@@ -1121,9 +1134,7 @@
 } else {
   EXPECT_TRUE(bool(Results)) << "rename returned an error: "
  << llvm::toString(Results.takeError());
-  ASSERT_EQ(1u, Results->GlobalChanges.size());
-  EXPECT_EQ(applyEdits(std::move(Results->GlobalChanges)).front().second,
-expectedResult(T, NewName));
+  EXPECT_EQ(Results->LocalChanges, T.ranges());
 }
   }
 }
Index: clang-tools-extra/clangd/refactor/Rename.cpp
===
--- clang-tools-extra/clangd/refactor/Rename.cpp
+++ clang-tools-extra/clangd/refactor/Rename.cpp
@@ -515,7 +515,8 @@
   else {
 // Name conflict detection.
 // Function conflicts are subtle (overloading), so ignore them.
-if (RenameDecl.getKind() != Decl::Function) {
+if (RenameDecl.getKind() != Decl::Function &&
+RenameDecl.getKind() != Decl::CXXMethod) {
   if (auto *Conflict = lookupSiblingWithName(ASTCtx, RenameDecl, NewName))
 Result = InvalidName{
 InvalidName::Conflict,
___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D147731: [3/11][POC][Clang][RISCV] Add typedef of the tuple type and define tuple type variant of vlseg2e32

2023-05-22 Thread Mikael Holmén via Phabricator via cfe-commits
uabelho added inline comments.



Comment at: clang/include/clang/Support/RISCVVIntrinsicUtils.h:384
   Policy PolicyAttrs;
+  bool IsTuple = false;
 

```
/home/buildbots/docker-RHEL84-buildbot/SetupBot/worker_env/ppc64le-clang-rhel-test/clang-ppc64le-rhel/llvm-project/clang/include/clang/Support/RISCVVIntrinsicUtils.h:384:8:
 error: private field 'IsTuple' is not used [-Werror,-Wunused-private-field]
  bool IsTuple = false;
   ^
1 error generated.
```
Seen e.g. here:
 https://lab.llvm.org/buildbot/#/builders/57/builds/26989/steps/5/logs/stdio


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D147731/new/

https://reviews.llvm.org/D147731

___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D151075: [clang][Diagnostics] Simplify emitSnippet()

2023-05-22 Thread Timm Bäder via Phabricator via cfe-commits
tbaeder created this revision.
tbaeder added a reviewer: aaron.ballman.
Herald added a project: All.
tbaeder requested review of this revision.
Herald added a project: clang.
Herald added a subscriber: cfe-commits.

  Don't try to minimize the times we invoke operator<< on the output
  stream by keeping a ToPrint string around. Instead, just print the
  characters as we iterate over them.


Repository:
  rG LLVM Github Monorepo

https://reviews.llvm.org/D151075

Files:
  clang/lib/Frontend/TextDiagnostic.cpp


Index: clang/lib/Frontend/TextDiagnostic.cpp
===
--- clang/lib/Frontend/TextDiagnostic.cpp
+++ clang/lib/Frontend/TextDiagnostic.cpp
@@ -1322,6 +1322,7 @@
 OS << " | ";
   }
 
+  // Print the source line one character at a time.
   bool PrintReversed = false;
   std::string ToPrint;
   size_t I = 0;
@@ -1329,23 +1330,20 @@
 auto [Str, WasPrintable] =
 printableTextForNextCharacter(SourceLine, &I, DiagOpts->TabStop);
 
-if (DiagOpts->ShowColors && WasPrintable == PrintReversed) {
-  if (PrintReversed)
-OS.reverseColor();
-  OS << ToPrint;
-  ToPrint.clear();
-  if (DiagOpts->ShowColors)
-OS.resetColor();
+// Toggle inverted colors on or off for this character.
+if (DiagOpts->ShowColors) {
+  if (WasPrintable == PrintReversed) {
+PrintReversed = !PrintReversed;
+if (PrintReversed)
+  OS.reverseColor();
+else
+  OS.resetColor();
+  }
 }
-
-PrintReversed = !WasPrintable;
-ToPrint += Str;
+OS << Str;
   }
 
-  if (PrintReversed && DiagOpts->ShowColors)
-OS.reverseColor();
-  OS << ToPrint;
-  if (PrintReversed && DiagOpts->ShowColors)
+  if (DiagOpts->ShowColors)
 OS.resetColor();
 
   OS << '\n';


Index: clang/lib/Frontend/TextDiagnostic.cpp
===
--- clang/lib/Frontend/TextDiagnostic.cpp
+++ clang/lib/Frontend/TextDiagnostic.cpp
@@ -1322,6 +1322,7 @@
 OS << " | ";
   }
 
+  // Print the source line one character at a time.
   bool PrintReversed = false;
   std::string ToPrint;
   size_t I = 0;
@@ -1329,23 +1330,20 @@
 auto [Str, WasPrintable] =
 printableTextForNextCharacter(SourceLine, &I, DiagOpts->TabStop);
 
-if (DiagOpts->ShowColors && WasPrintable == PrintReversed) {
-  if (PrintReversed)
-OS.reverseColor();
-  OS << ToPrint;
-  ToPrint.clear();
-  if (DiagOpts->ShowColors)
-OS.resetColor();
+// Toggle inverted colors on or off for this character.
+if (DiagOpts->ShowColors) {
+  if (WasPrintable == PrintReversed) {
+PrintReversed = !PrintReversed;
+if (PrintReversed)
+  OS.reverseColor();
+else
+  OS.resetColor();
+  }
 }
-
-PrintReversed = !WasPrintable;
-ToPrint += Str;
+OS << Str;
   }
 
-  if (PrintReversed && DiagOpts->ShowColors)
-OS.reverseColor();
-  OS << ToPrint;
-  if (PrintReversed && DiagOpts->ShowColors)
+  if (DiagOpts->ShowColors)
 OS.resetColor();
 
   OS << '\n';
___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D151075: [clang][Diagnostics] Simplify emitSnippet()

2023-05-22 Thread Timm Bäder via Phabricator via cfe-commits
tbaeder updated this revision to Diff 524216.

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D151075/new/

https://reviews.llvm.org/D151075

Files:
  clang/lib/Frontend/TextDiagnostic.cpp


Index: clang/lib/Frontend/TextDiagnostic.cpp
===
--- clang/lib/Frontend/TextDiagnostic.cpp
+++ clang/lib/Frontend/TextDiagnostic.cpp
@@ -1322,30 +1322,27 @@
 OS << " | ";
   }
 
+  // Print the source line one character at a time.
   bool PrintReversed = false;
-  std::string ToPrint;
   size_t I = 0;
   while (I < SourceLine.size()) {
 auto [Str, WasPrintable] =
 printableTextForNextCharacter(SourceLine, &I, DiagOpts->TabStop);
 
-if (DiagOpts->ShowColors && WasPrintable == PrintReversed) {
-  if (PrintReversed)
-OS.reverseColor();
-  OS << ToPrint;
-  ToPrint.clear();
-  if (DiagOpts->ShowColors)
-OS.resetColor();
+// Toggle inverted colors on or off for this character.
+if (DiagOpts->ShowColors) {
+  if (WasPrintable == PrintReversed) {
+PrintReversed = !PrintReversed;
+if (PrintReversed)
+  OS.reverseColor();
+else
+  OS.resetColor();
+  }
 }
-
-PrintReversed = !WasPrintable;
-ToPrint += Str;
+OS << Str;
   }
 
-  if (PrintReversed && DiagOpts->ShowColors)
-OS.reverseColor();
-  OS << ToPrint;
-  if (PrintReversed && DiagOpts->ShowColors)
+  if (DiagOpts->ShowColors)
 OS.resetColor();
 
   OS << '\n';


Index: clang/lib/Frontend/TextDiagnostic.cpp
===
--- clang/lib/Frontend/TextDiagnostic.cpp
+++ clang/lib/Frontend/TextDiagnostic.cpp
@@ -1322,30 +1322,27 @@
 OS << " | ";
   }
 
+  // Print the source line one character at a time.
   bool PrintReversed = false;
-  std::string ToPrint;
   size_t I = 0;
   while (I < SourceLine.size()) {
 auto [Str, WasPrintable] =
 printableTextForNextCharacter(SourceLine, &I, DiagOpts->TabStop);
 
-if (DiagOpts->ShowColors && WasPrintable == PrintReversed) {
-  if (PrintReversed)
-OS.reverseColor();
-  OS << ToPrint;
-  ToPrint.clear();
-  if (DiagOpts->ShowColors)
-OS.resetColor();
+// Toggle inverted colors on or off for this character.
+if (DiagOpts->ShowColors) {
+  if (WasPrintable == PrintReversed) {
+PrintReversed = !PrintReversed;
+if (PrintReversed)
+  OS.reverseColor();
+else
+  OS.resetColor();
+  }
 }
-
-PrintReversed = !WasPrintable;
-ToPrint += Str;
+OS << Str;
   }
 
-  if (PrintReversed && DiagOpts->ShowColors)
-OS.reverseColor();
-  OS << ToPrint;
-  if (PrintReversed && DiagOpts->ShowColors)
+  if (DiagOpts->ShowColors)
 OS.resetColor();
 
   OS << '\n';
___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D148206: [clang] Do not crash after suggesting typo correction to constexpr if condition

2023-05-22 Thread Mariya Podchishchaeva via Phabricator via cfe-commits
Fznamznon added inline comments.



Comment at: clang/test/SemaCXX/invalid-if-constexpr.cpp:7
+}
+void a() { if constexpr (__adl_swap<>) {}} // expected-error{{use of 
undeclared identifier '__adl_swap'; did you mean '__sync_swap'?}} \
+   // expected-note {{'__sync_swap' 
declared here}}

zixuan-wu wrote:
> Hi, why  `did you mean '__sync_swap'` is not reported in riscv target? So 
> it's failed in check-all.
I haven't seen any buildbot issues with the issue like this.
Adding -triple riscv64-unknown-unknown doesn't help me to see the issue, as 
well as adding -DLLVM_TARGETS_TO_BUILD="RISCV" to cmake line and running 
check-clang. Could you please help to reproduce the issue? I'm not quite 
familiar with RISCV targets.


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D148206/new/

https://reviews.llvm.org/D148206

___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D151076: [IRGen] Handle infinite cycles in findDominatingStoreToReturnValue.

2023-05-22 Thread Florian Hahn via Phabricator via cfe-commits
fhahn created this revision.
fhahn added reviewers: rjmccall, aaron.ballman, efriedma.
Herald added a subscriber: StephenFan.
Herald added a project: All.
fhahn requested review of this revision.
Herald added a project: clang.
Herald added a subscriber: cfe-commits.

If there is an infinite cycle in the IR, the loop will never exit. Keep
track of visited basic blocks in a set and return nullptr if a block is
visited again.

Fixes #62830.


Repository:
  rG LLVM Github Monorepo

https://reviews.llvm.org/D151076

Files:
  clang/lib/CodeGen/CGCall.cpp
  clang/test/CodeGen/dominating-store-infinite-cycle.c


Index: clang/test/CodeGen/dominating-store-infinite-cycle.c
===
--- /dev/null
+++ clang/test/CodeGen/dominating-store-infinite-cycle.c
@@ -0,0 +1,33 @@
+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py 
UTC_ARGS: --version 2
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -S -emit-llvm %s -o - | 
FileCheck %s
+
+// Test for PR62830 where there are 2 infinite cycles using goto. Make sure
+// clang codegen doesn't hang.
+int a;
+
+// CHECK-LABEL: define dso_local i32 @main
+// CHECK-SAME: () #[[ATTR0:[0-9]+]] {
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:[[RETVAL:%.*]] = alloca i32, align 4
+// CHECK-NEXT:store i32 0, ptr [[RETVAL]], align 4
+// CHECK-NEXT:br label [[L1:%.*]]
+// CHECK:   L1:
+// CHECK-NEXT:br label [[L1]]
+// CHECK:   L2:
+// CHECK-NEXT:[[TMP0:%.*]] = load i32, ptr @a, align 4
+// CHECK-NEXT:[[TOBOOL:%.*]] = icmp ne i32 [[TMP0]], 0
+// CHECK-NEXT:br i1 [[TOBOOL]], label [[IF_END:%.*]], label [[IF_THEN:%.*]]
+// CHECK:   if.then:
+// CHECK-NEXT:br label [[L2:%.*]]
+// CHECK:   if.end:
+// CHECK-NEXT:[[TMP1:%.*]] = load i32, ptr [[RETVAL]], align 4
+// CHECK-NEXT:ret i32 [[TMP1]]
+//
+int main() {
+L1:
+  goto L1;
+
+L2:
+  if (!a)
+goto L2;
+}
Index: clang/lib/CodeGen/CGCall.cpp
===
--- clang/lib/CodeGen/CGCall.cpp
+++ clang/lib/CodeGen/CGCall.cpp
@@ -3461,8 +3461,9 @@
   // single-predecessors chain from the current insertion point.
   llvm::BasicBlock *StoreBB = store->getParent();
   llvm::BasicBlock *IP = CGF.Builder.GetInsertBlock();
+  llvm::SmallPtrSet SeenBBs;
   while (IP != StoreBB) {
-if (!(IP = IP->getSinglePredecessor()))
+if (!SeenBBs.insert(IP).second || !(IP = IP->getSinglePredecessor()))
   return nullptr;
   }
 


Index: clang/test/CodeGen/dominating-store-infinite-cycle.c
===
--- /dev/null
+++ clang/test/CodeGen/dominating-store-infinite-cycle.c
@@ -0,0 +1,33 @@
+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --version 2
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -S -emit-llvm %s -o - | FileCheck %s
+
+// Test for PR62830 where there are 2 infinite cycles using goto. Make sure
+// clang codegen doesn't hang.
+int a;
+
+// CHECK-LABEL: define dso_local i32 @main
+// CHECK-SAME: () #[[ATTR0:[0-9]+]] {
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:[[RETVAL:%.*]] = alloca i32, align 4
+// CHECK-NEXT:store i32 0, ptr [[RETVAL]], align 4
+// CHECK-NEXT:br label [[L1:%.*]]
+// CHECK:   L1:
+// CHECK-NEXT:br label [[L1]]
+// CHECK:   L2:
+// CHECK-NEXT:[[TMP0:%.*]] = load i32, ptr @a, align 4
+// CHECK-NEXT:[[TOBOOL:%.*]] = icmp ne i32 [[TMP0]], 0
+// CHECK-NEXT:br i1 [[TOBOOL]], label [[IF_END:%.*]], label [[IF_THEN:%.*]]
+// CHECK:   if.then:
+// CHECK-NEXT:br label [[L2:%.*]]
+// CHECK:   if.end:
+// CHECK-NEXT:[[TMP1:%.*]] = load i32, ptr [[RETVAL]], align 4
+// CHECK-NEXT:ret i32 [[TMP1]]
+//
+int main() {
+L1:
+  goto L1;
+
+L2:
+  if (!a)
+goto L2;
+}
Index: clang/lib/CodeGen/CGCall.cpp
===
--- clang/lib/CodeGen/CGCall.cpp
+++ clang/lib/CodeGen/CGCall.cpp
@@ -3461,8 +3461,9 @@
   // single-predecessors chain from the current insertion point.
   llvm::BasicBlock *StoreBB = store->getParent();
   llvm::BasicBlock *IP = CGF.Builder.GetInsertBlock();
+  llvm::SmallPtrSet SeenBBs;
   while (IP != StoreBB) {
-if (!(IP = IP->getSinglePredecessor()))
+if (!SeenBBs.insert(IP).second || !(IP = IP->getSinglePredecessor()))
   return nullptr;
   }
 
___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[clang] 3814025 - [Clang][RISCV] Remove unused variable `IsTuple` for structure `RVVIntrinsic`

2023-05-22 Thread via cfe-commits

Author: eopXD
Date: 2023-05-22T03:40:12-07:00
New Revision: 38140255113297fe3e7926d311cd45004928779e

URL: 
https://github.com/llvm/llvm-project/commit/38140255113297fe3e7926d311cd45004928779e
DIFF: 
https://github.com/llvm/llvm-project/commit/38140255113297fe3e7926d311cd45004928779e.diff

LOG: [Clang][RISCV] Remove unused variable `IsTuple` for structure 
`RVVIntrinsic`

Signed-off by: eop Chen 

Added: 


Modified: 
clang/include/clang/Support/RISCVVIntrinsicUtils.h
clang/lib/Support/RISCVVIntrinsicUtils.cpp
clang/utils/TableGen/RISCVVEmitter.cpp

Removed: 




diff  --git a/clang/include/clang/Support/RISCVVIntrinsicUtils.h 
b/clang/include/clang/Support/RISCVVIntrinsicUtils.h
index 07c6bbad5edde..2a81e7972358e 100644
--- a/clang/include/clang/Support/RISCVVIntrinsicUtils.h
+++ b/clang/include/clang/Support/RISCVVIntrinsicUtils.h
@@ -381,7 +381,6 @@ class RVVIntrinsic {
   std::vector IntrinsicTypes;
   unsigned NF = 1;
   Policy PolicyAttrs;
-  bool IsTuple = false;
 
 public:
   RVVIntrinsic(llvm::StringRef Name, llvm::StringRef Suffix,
@@ -392,7 +391,7 @@ class RVVIntrinsic {
const RVVTypes &Types,
const std::vector &IntrinsicTypes,
const std::vector &RequiredFeatures,
-   unsigned NF, Policy PolicyAttrs, bool IsTuple);
+   unsigned NF, Policy PolicyAttrs);
   ~RVVIntrinsic() = default;
 
   RVVTypePtr getOutputType() const { return OutputType; }

diff  --git a/clang/lib/Support/RISCVVIntrinsicUtils.cpp 
b/clang/lib/Support/RISCVVIntrinsicUtils.cpp
index a41c77d40020c..353e0cb4422f2 100644
--- a/clang/lib/Support/RISCVVIntrinsicUtils.cpp
+++ b/clang/lib/Support/RISCVVIntrinsicUtils.cpp
@@ -877,12 +877,11 @@ RVVIntrinsic::RVVIntrinsic(StringRef NewName, StringRef 
Suffix,
const RVVTypes &OutInTypes,
const std::vector &NewIntrinsicTypes,
const std::vector &RequiredFeatures,
-   unsigned NF, Policy NewPolicyAttrs, bool IsTuple)
+   unsigned NF, Policy NewPolicyAttrs)
 : IRName(IRName), IsMasked(IsMasked),
   HasMaskedOffOperand(HasMaskedOffOperand), HasVL(HasVL), Scheme(Scheme),
   SupportOverloading(SupportOverloading), HasBuiltinAlias(HasBuiltinAlias),
-  ManualCodegen(ManualCodegen.str()), NF(NF), PolicyAttrs(NewPolicyAttrs),
-  IsTuple(IsTuple) {
+  ManualCodegen(ManualCodegen.str()), NF(NF), PolicyAttrs(NewPolicyAttrs) {
 
   // Init BuiltinName, Name and OverloadedName
   BuiltinName = NewName.str();

diff  --git a/clang/utils/TableGen/RISCVVEmitter.cpp 
b/clang/utils/TableGen/RISCVVEmitter.cpp
index 7ecb6a0a87fa6..c9f454a4ea323 100644
--- a/clang/utils/TableGen/RISCVVEmitter.cpp
+++ b/clang/utils/TableGen/RISCVVEmitter.cpp
@@ -569,7 +569,7 @@ void RVVEmitter::createRVVIntrinsics(
 /*IsMasked=*/false, /*HasMaskedOffOperand=*/false, HasVL,
 UnMaskedPolicyScheme, SupportOverloading, HasBuiltinAlias,
 ManualCodegen, *Types, IntrinsicTypes, RequiredFeatures, NF,
-DefaultPolicy, IsTuple));
+DefaultPolicy));
 if (UnMaskedPolicyScheme != PolicyScheme::SchemeNone)
   for (auto P : SupportedUnMaskedPolicies) {
 SmallVector PolicyPrototype =
@@ -584,7 +584,7 @@ void RVVEmitter::createRVVIntrinsics(
 /*IsMask=*/false, /*HasMaskedOffOperand=*/false, HasVL,
 UnMaskedPolicyScheme, SupportOverloading, HasBuiltinAlias,
 ManualCodegen, *PolicyTypes, IntrinsicTypes, RequiredFeatures,
-NF, P, IsTuple));
+NF, P));
   }
 if (!HasMasked)
   continue;
@@ -595,7 +595,7 @@ void RVVEmitter::createRVVIntrinsics(
 Name, SuffixStr, OverloadedName, OverloadedSuffixStr, MaskedIRName,
 /*IsMasked=*/true, HasMaskedOffOperand, HasVL, MaskedPolicyScheme,
 SupportOverloading, HasBuiltinAlias, ManualCodegen, *MaskTypes,
-IntrinsicTypes, RequiredFeatures, NF, DefaultPolicy, IsTuple));
+IntrinsicTypes, RequiredFeatures, NF, DefaultPolicy));
 if (MaskedPolicyScheme == PolicyScheme::SchemeNone)
   continue;
 for (auto P : SupportedMaskedPolicies) {
@@ -610,7 +610,7 @@ void RVVEmitter::createRVVIntrinsics(
   MaskedIRName, /*IsMasked=*/true, HasMaskedOffOperand, HasVL,
   MaskedPolicyScheme, SupportOverloading, HasBuiltinAlias,
   ManualCodegen, *PolicyTypes, IntrinsicTypes, RequiredFeatures, 
NF,
-  P, IsTuple));
+  P));
 }
   } // End for Log2LMULList
 }   // End for TypeRange



___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D151061: [test] Add ext_vector_type tests for C

2023-05-22 Thread Florian Hahn via Phabricator via cfe-commits
fhahn added a comment.

Thanks for texting the test coverage!




Comment at: clang/test/Sema/ext_vector_ops.c:30
+void test_int_vector_scalar(unsigned int ua, v2u v2ua) {
+  // Integer vector vs integer operators. These will splat
+  (void)(v2ua + ua);

Not sure if `vs` is the right connector here, maybe something like `Operators 
with one integer vector and scalar.`. Period at end of `These will splat`


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D151061/new/

https://reviews.llvm.org/D151061

___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D147731: [3/11][POC][Clang][RISCV] Add typedef of the tuple type and define tuple type variant of vlseg2e32

2023-05-22 Thread Yueh-Ting (eop) Chen via Phabricator via cfe-commits
eopXD marked an inline comment as done.
eopXD added inline comments.



Comment at: clang/include/clang/Support/RISCVVIntrinsicUtils.h:384
   Policy PolicyAttrs;
+  bool IsTuple = false;
 

uabelho wrote:
> ```
> /home/buildbots/docker-RHEL84-buildbot/SetupBot/worker_env/ppc64le-clang-rhel-test/clang-ppc64le-rhel/llvm-project/clang/include/clang/Support/RISCVVIntrinsicUtils.h:384:8:
>  error: private field 'IsTuple' is not used [-Werror,-Wunused-private-field]
>   bool IsTuple = false;
>^
> 1 error generated.
> ```
> Seen e.g. here:
>  https://lab.llvm.org/buildbot/#/builders/57/builds/26989/steps/5/logs/stdio
Thank you for the report. Resolved this in commit 
38140255113297fe3e7926d311cd45004928779e.


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D147731/new/

https://reviews.llvm.org/D147731

___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[clang-tools-extra] 008cb29 - [clangd] Renaming: Treat member functions like other functions

2023-05-22 Thread Christian Kandeler via cfe-commits

Author: Christian Kandeler
Date: 2023-05-22T12:50:38+02:00
New Revision: 008cb29f87f3af391eb6c3747bdad16f2e386161

URL: 
https://github.com/llvm/llvm-project/commit/008cb29f87f3af391eb6c3747bdad16f2e386161
DIFF: 
https://github.com/llvm/llvm-project/commit/008cb29f87f3af391eb6c3747bdad16f2e386161.diff

LOG: [clangd] Renaming: Treat member functions like other functions

... by skipping the conflict check. The same considerations apply.

Reviewed By: hokein

Differential Revision: https://reviews.llvm.org/D150685

Added: 


Modified: 
clang-tools-extra/clangd/refactor/Rename.cpp
clang-tools-extra/clangd/unittests/RenameTests.cpp

Removed: 




diff  --git a/clang-tools-extra/clangd/refactor/Rename.cpp 
b/clang-tools-extra/clangd/refactor/Rename.cpp
index 6362768f9b475..b3270534b13b1 100644
--- a/clang-tools-extra/clangd/refactor/Rename.cpp
+++ b/clang-tools-extra/clangd/refactor/Rename.cpp
@@ -515,7 +515,8 @@ std::optional checkName(const NamedDecl 
&RenameDecl,
   else {
 // Name conflict detection.
 // Function conflicts are subtle (overloading), so ignore them.
-if (RenameDecl.getKind() != Decl::Function) {
+if (RenameDecl.getKind() != Decl::Function &&
+RenameDecl.getKind() != Decl::CXXMethod) {
   if (auto *Conflict = lookupSiblingWithName(ASTCtx, RenameDecl, NewName))
 Result = InvalidName{
 InvalidName::Conflict,

diff  --git a/clang-tools-extra/clangd/unittests/RenameTests.cpp 
b/clang-tools-extra/clangd/unittests/RenameTests.cpp
index 5b99f8c4fc44c..9be4a970a7cfb 100644
--- a/clang-tools-extra/clangd/unittests/RenameTests.cpp
+++ b/clang-tools-extra/clangd/unittests/RenameTests.cpp
@@ -1062,6 +1062,19 @@ TEST(RenameTest, Renameable) {
   )cpp",
"conflict", !HeaderFile, "Conflict"},
 
+  {R"cpp(
+void func(int);
+void [[o^therFunc]](double);
+  )cpp",
+   nullptr, !HeaderFile, "func"},
+  {R"cpp(
+struct S {
+  void func(int);
+  void [[o^therFunc]](double);
+};
+  )cpp",
+   nullptr, !HeaderFile, "func"},
+
   {R"cpp(
 int V^ar;
   )cpp",
@@ -1121,9 +1134,7 @@ TEST(RenameTest, Renameable) {
 } else {
   EXPECT_TRUE(bool(Results)) << "rename returned an error: "
  << llvm::toString(Results.takeError());
-  ASSERT_EQ(1u, Results->GlobalChanges.size());
-  EXPECT_EQ(applyEdits(std::move(Results->GlobalChanges)).front().second,
-expectedResult(T, NewName));
+  EXPECT_EQ(Results->LocalChanges, T.ranges());
 }
   }
 }



___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D150685: [clangd] Renaming: Treat member functions like other functions

2023-05-22 Thread Christian Kandeler via Phabricator via cfe-commits
This revision was automatically updated to reflect the committed changes.
Closed by commit rG008cb29f87f3: [clangd] Renaming: Treat member functions like 
other functions (authored by ckandeler).

Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D150685/new/

https://reviews.llvm.org/D150685

Files:
  clang-tools-extra/clangd/refactor/Rename.cpp
  clang-tools-extra/clangd/unittests/RenameTests.cpp


Index: clang-tools-extra/clangd/unittests/RenameTests.cpp
===
--- clang-tools-extra/clangd/unittests/RenameTests.cpp
+++ clang-tools-extra/clangd/unittests/RenameTests.cpp
@@ -1062,6 +1062,19 @@
   )cpp",
"conflict", !HeaderFile, "Conflict"},
 
+  {R"cpp(
+void func(int);
+void [[o^therFunc]](double);
+  )cpp",
+   nullptr, !HeaderFile, "func"},
+  {R"cpp(
+struct S {
+  void func(int);
+  void [[o^therFunc]](double);
+};
+  )cpp",
+   nullptr, !HeaderFile, "func"},
+
   {R"cpp(
 int V^ar;
   )cpp",
@@ -1121,9 +1134,7 @@
 } else {
   EXPECT_TRUE(bool(Results)) << "rename returned an error: "
  << llvm::toString(Results.takeError());
-  ASSERT_EQ(1u, Results->GlobalChanges.size());
-  EXPECT_EQ(applyEdits(std::move(Results->GlobalChanges)).front().second,
-expectedResult(T, NewName));
+  EXPECT_EQ(Results->LocalChanges, T.ranges());
 }
   }
 }
Index: clang-tools-extra/clangd/refactor/Rename.cpp
===
--- clang-tools-extra/clangd/refactor/Rename.cpp
+++ clang-tools-extra/clangd/refactor/Rename.cpp
@@ -515,7 +515,8 @@
   else {
 // Name conflict detection.
 // Function conflicts are subtle (overloading), so ignore them.
-if (RenameDecl.getKind() != Decl::Function) {
+if (RenameDecl.getKind() != Decl::Function &&
+RenameDecl.getKind() != Decl::CXXMethod) {
   if (auto *Conflict = lookupSiblingWithName(ASTCtx, RenameDecl, NewName))
 Result = InvalidName{
 InvalidName::Conflict,


Index: clang-tools-extra/clangd/unittests/RenameTests.cpp
===
--- clang-tools-extra/clangd/unittests/RenameTests.cpp
+++ clang-tools-extra/clangd/unittests/RenameTests.cpp
@@ -1062,6 +1062,19 @@
   )cpp",
"conflict", !HeaderFile, "Conflict"},
 
+  {R"cpp(
+void func(int);
+void [[o^therFunc]](double);
+  )cpp",
+   nullptr, !HeaderFile, "func"},
+  {R"cpp(
+struct S {
+  void func(int);
+  void [[o^therFunc]](double);
+};
+  )cpp",
+   nullptr, !HeaderFile, "func"},
+
   {R"cpp(
 int V^ar;
   )cpp",
@@ -1121,9 +1134,7 @@
 } else {
   EXPECT_TRUE(bool(Results)) << "rename returned an error: "
  << llvm::toString(Results.takeError());
-  ASSERT_EQ(1u, Results->GlobalChanges.size());
-  EXPECT_EQ(applyEdits(std::move(Results->GlobalChanges)).front().second,
-expectedResult(T, NewName));
+  EXPECT_EQ(Results->LocalChanges, T.ranges());
 }
   }
 }
Index: clang-tools-extra/clangd/refactor/Rename.cpp
===
--- clang-tools-extra/clangd/refactor/Rename.cpp
+++ clang-tools-extra/clangd/refactor/Rename.cpp
@@ -515,7 +515,8 @@
   else {
 // Name conflict detection.
 // Function conflicts are subtle (overloading), so ignore them.
-if (RenameDecl.getKind() != Decl::Function) {
+if (RenameDecl.getKind() != Decl::Function &&
+RenameDecl.getKind() != Decl::CXXMethod) {
   if (auto *Conflict = lookupSiblingWithName(ASTCtx, RenameDecl, NewName))
 Result = InvalidName{
 InvalidName::Conflict,
___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D150966: [clang] Don't define predefined macros multiple times

2023-05-22 Thread John Brawn via Phabricator via cfe-commits
john.brawn added a comment.

In D150966#4356779 , @barannikov88 
wrote:

>   Check that the predefined macros don't contain anything that causes a 
> warning
>
> What is 'anything', exactly? Does it include duplicate predefined macros, or 
> it tests something else?
> Sorry for the silly question.

D144654  caused a failure 
http://45.33.8.238/macm1/60903/step_7.txt that caused it to be reverted. The 
failure was in tests that use -Wsystem-headers and was because the host that 
clang was built on (aarch64 macos) had duplicate predefines and those tests 
don't specify a target and so the default (i.e. host) target is used. This test 
is mainly so that we have a test that uses -Wsystem-headers that doesn't depend 
on the host machine so that I know D144654  
won't cause further problems when I re-commit it.


CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D150966/new/

https://reviews.llvm.org/D150966

___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[clang] deb63f4 - [5/11][POC][Clang][RISCV] Define tuple type variant of vlseg2e32ff

2023-05-22 Thread via cfe-commits

Author: eopXD
Date: 2023-05-22T04:05:14-07:00
New Revision: deb63f4a54e66b44e81ccc249f5c9ae786b16d27

URL: 
https://github.com/llvm/llvm-project/commit/deb63f4a54e66b44e81ccc249f5c9ae786b16d27
DIFF: 
https://github.com/llvm/llvm-project/commit/deb63f4a54e66b44e81ccc249f5c9ae786b16d27.diff

LOG: [5/11][POC][Clang][RISCV] Define tuple type variant of vlseg2e32ff

For the cover letter of this patch-set, please checkout D146872.

Depends on D147774.

This is the 5th patch of the patch-set.

This patch is a proof-of-concept and will be extended to full coverage
in the future. Currently, the old non-tuple unit-stride fault-first
segment load is not removed, and only signed integer unit-stride
fault-first segment load of NF=2, EEW=32 is defined here.

Reviewed By: craig.topper

Differential Revision: https://reviews.llvm.org/D147911

Added: 

clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vlseg2e32ff_tuple.c

Modified: 
clang/include/clang/Basic/riscv_vector.td

Removed: 




diff  --git a/clang/include/clang/Basic/riscv_vector.td 
b/clang/include/clang/Basic/riscv_vector.td
index 81f8da8b824d6..42375c265b088 100644
--- a/clang/include/clang/Basic/riscv_vector.td
+++ b/clang/include/clang/Basic/riscv_vector.td
@@ -1591,11 +1591,73 @@ multiclass RVVUnitStridedSegStoreTuple {
 }
   }
 }
+
+multiclass RVVUnitStridedSegLoadFFTuple {
+  foreach type = ["i"] in {
+defvar eew = !cond(!eq(type, "i") : "32");
+  foreach nf = [2] in {
+let Name = op # nf # "e" # eew # "ff_v_tuple",
+OverloadedName = op # nf # "e" # eew # "ff_tuple",
+IRName = op # nf # "ff",
+MaskedIRName = op # nf # "ff_mask",
+NF = nf,
+ManualCodegen = [{
+{
+  assert(((IsMasked && (PolicyAttrs & RVV_VTA) && (PolicyAttrs & RVV_VMA)) 
||
+ (!IsMasked && (PolicyAttrs & RVV_VTA))) &&
+ "FIXME: Only handling default policy (TAMA) for now");
+
+  llvm::Type *ElementVectorType = 
cast(ResultType)->elements()[0];
+
+  IntrinsicTypes = {ElementVectorType, Ops.back()->getType()};
+  SmallVector Operands;
+
+  Operands.append(NF, llvm::PoisonValue::get(ElementVectorType));
+
+  unsigned Offset = IsMasked ? 1 : 0;
+  Operands.push_back(Ops[Offset]); // Ptr
+  if (IsMasked)
+Operands.push_back(Ops[0]);
+  Operands.push_back(Ops[Offset + 2]); // vl
+  if (IsMasked)
+Operands.push_back(ConstantInt::get(Ops.back()->getType(), 
PolicyAttrs));
+
+  llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
+
+  llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
+  // Get alignment from the new vl operand
+  clang::CharUnits Align =
+  CGM.getNaturalPointeeTypeAlignment(E->getArg(Offset + 1)->getType());
+
+  llvm::Value *ReturnTuple = llvm::PoisonValue::get(ResultType);
+  for (unsigned I = 0; I < NF; ++I) {
+llvm::Value *V = Builder.CreateExtractValue(LoadValue, {I});
+ReturnTuple = Builder.CreateInsertValue(ReturnTuple, V, {I});
+  }
+
+  // Store new_vl
+  llvm::Value *V = Builder.CreateExtractValue(LoadValue, {NF});
+  Builder.CreateStore(V, Address(Ops[Offset + 1], V->getType(), Align));
+
+  if (ReturnValue.isNull())
+return ReturnTuple;
+  else
+return Builder.CreateStore(ReturnTuple, ReturnValue.getValue());
+}
+}] in {
+  defvar T = "(Tuple:" # nf # ")";
+  def : RVVBuiltin<"v", T # "vPCePz", type>;
+  }
+}
+  }
+}
+
 // TODO: Extend for policy
 let UnMaskedPolicyScheme = NonePolicy,
 MaskedPolicyScheme = NonePolicy,
 IsTuple = true in {
 defm : RVVUnitStridedSegLoadTuple<"vlseg">;
+defm : RVVUnitStridedSegLoadFFTuple<"vlseg">;
 }
 
 let UnMaskedPolicyScheme = NonePolicy,

diff  --git 
a/clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vlseg2e32ff_tuple.c
 
b/clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vlseg2e32ff_tuple.c
new file mode 100644
index 0..1003570a9bfd5
--- /dev/null
+++ 
b/clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vlseg2e32ff_tuple.c
@@ -0,0 +1,39 @@
+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py 
UTC_ARGS: --version 2
+// REQUIRES: riscv-registered-target
+// RUN: %clang_cc1 -triple riscv64 -target-feature +v -target-feature +zfh \
+// RUN:   -target-feature +experimental-zvfh -disable-O0-optnone  \
+// RUN:   -emit-llvm %s -o - | opt -S -passes=mem2reg | \
+// RUN:   FileCheck --check-prefix=CHECK-RV64 %s
+#include 
+
+// CHECK-RV64-LABEL: define dso_local { ,  
} @test_vlseg2e32ff_v_tuple_i32m1
+// CHECK-RV64-SAME: (ptr noundef [[BASE:%.*]], ptr noundef [[NEW_VL:%.*]], i64 
noundef [[VL:%.*]]) #[[ATTR0:[0-9]+]] {
+// CHECK-RV64-NEXT:  entry:
+// CHECK-RV64-NEXT:[[TMP0:%.*]] = 

[PATCH] D147911: [5/11][POC][Clang][RISCV] Define tuple type variant of vlseg2e32ff

2023-05-22 Thread Yueh-Ting (eop) Chen via Phabricator via cfe-commits
This revision was landed with ongoing or failed builds.
This revision was automatically updated to reflect the committed changes.
Closed by commit rGdeb63f4a54e6: [5/11][POC][Clang][RISCV] Define tuple type 
variant of vlseg2e32ff (authored by eopXD).

Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D147911/new/

https://reviews.llvm.org/D147911

Files:
  clang/include/clang/Basic/riscv_vector.td
  
clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vlseg2e32ff_tuple.c

Index: clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vlseg2e32ff_tuple.c
===
--- /dev/null
+++ clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vlseg2e32ff_tuple.c
@@ -0,0 +1,39 @@
+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --version 2
+// REQUIRES: riscv-registered-target
+// RUN: %clang_cc1 -triple riscv64 -target-feature +v -target-feature +zfh \
+// RUN:   -target-feature +experimental-zvfh -disable-O0-optnone  \
+// RUN:   -emit-llvm %s -o - | opt -S -passes=mem2reg | \
+// RUN:   FileCheck --check-prefix=CHECK-RV64 %s
+#include 
+
+// CHECK-RV64-LABEL: define dso_local { ,  } @test_vlseg2e32ff_v_tuple_i32m1
+// CHECK-RV64-SAME: (ptr noundef [[BASE:%.*]], ptr noundef [[NEW_VL:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0:[0-9]+]] {
+// CHECK-RV64-NEXT:  entry:
+// CHECK-RV64-NEXT:[[TMP0:%.*]] = call { , , i64 } @llvm.riscv.vlseg2ff.nxv2i32.i64( poison,  poison, ptr [[BASE]], i64 [[VL]])
+// CHECK-RV64-NEXT:[[TMP1:%.*]] = extractvalue { , , i64 } [[TMP0]], 0
+// CHECK-RV64-NEXT:[[TMP2:%.*]] = insertvalue { ,  } poison,  [[TMP1]], 0
+// CHECK-RV64-NEXT:[[TMP3:%.*]] = extractvalue { , , i64 } [[TMP0]], 1
+// CHECK-RV64-NEXT:[[TMP4:%.*]] = insertvalue { ,  } [[TMP2]],  [[TMP3]], 1
+// CHECK-RV64-NEXT:[[TMP5:%.*]] = extractvalue { , , i64 } [[TMP0]], 2
+// CHECK-RV64-NEXT:store i64 [[TMP5]], ptr [[NEW_VL]], align 8
+// CHECK-RV64-NEXT:ret { ,  } [[TMP4]]
+//
+vint32m1x2_t test_vlseg2e32ff_v_tuple_i32m1(const int32_t *base, size_t *new_vl, size_t vl) {
+  return __riscv_vlseg2e32ff_v_tuple_i32m1(base, new_vl, vl);
+}
+
+// CHECK-RV64-LABEL: define dso_local { ,  } @test_vlseg2e32ff_v_tuple_i32m1_m
+// CHECK-RV64-SAME: ( [[MASK:%.*]], ptr noundef [[BASE:%.*]], ptr noundef [[NEW_VL:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] {
+// CHECK-RV64-NEXT:  entry:
+// CHECK-RV64-NEXT:[[TMP0:%.*]] = call { , , i64 } @llvm.riscv.vlseg2ff.mask.nxv2i32.i64( poison,  poison, ptr [[BASE]],  [[MASK]], i64 [[VL]], i64 3)
+// CHECK-RV64-NEXT:[[TMP1:%.*]] = extractvalue { , , i64 } [[TMP0]], 0
+// CHECK-RV64-NEXT:[[TMP2:%.*]] = insertvalue { ,  } poison,  [[TMP1]], 0
+// CHECK-RV64-NEXT:[[TMP3:%.*]] = extractvalue { , , i64 } [[TMP0]], 1
+// CHECK-RV64-NEXT:[[TMP4:%.*]] = insertvalue { ,  } [[TMP2]],  [[TMP3]], 1
+// CHECK-RV64-NEXT:[[TMP5:%.*]] = extractvalue { , , i64 } [[TMP0]], 2
+// CHECK-RV64-NEXT:store i64 [[TMP5]], ptr [[NEW_VL]], align 8
+// CHECK-RV64-NEXT:ret { ,  } [[TMP4]]
+//
+vint32m1x2_t test_vlseg2e32ff_v_tuple_i32m1_m(vbool32_t mask, const int32_t *base, size_t *new_vl, size_t vl) {
+  return __riscv_vlseg2e32ff_v_tuple_i32m1_m(mask, base, new_vl, vl);
+}
Index: clang/include/clang/Basic/riscv_vector.td
===
--- clang/include/clang/Basic/riscv_vector.td
+++ clang/include/clang/Basic/riscv_vector.td
@@ -1591,11 +1591,73 @@
 }
   }
 }
+
+multiclass RVVUnitStridedSegLoadFFTuple {
+  foreach type = ["i"] in {
+defvar eew = !cond(!eq(type, "i") : "32");
+  foreach nf = [2] in {
+let Name = op # nf # "e" # eew # "ff_v_tuple",
+OverloadedName = op # nf # "e" # eew # "ff_tuple",
+IRName = op # nf # "ff",
+MaskedIRName = op # nf # "ff_mask",
+NF = nf,
+ManualCodegen = [{
+{
+  assert(((IsMasked && (PolicyAttrs & RVV_VTA) && (PolicyAttrs & RVV_VMA)) ||
+ (!IsMasked && (PolicyAttrs & RVV_VTA))) &&
+ "FIXME: Only handling default policy (TAMA) for now");
+
+  llvm::Type *ElementVectorType = cast(ResultType)->elements()[0];
+
+  IntrinsicTypes = {ElementVectorType, Ops.back()->getType()};
+  SmallVector Operands;
+
+  Operands.append(NF, llvm::PoisonValue::get(ElementVectorType));
+
+  unsigned Offset = IsMasked ? 1 : 0;
+  Operands.push_back(Ops[Offset]); // Ptr
+  if (IsMasked)
+Operands.push_back(Ops[0]);
+  Operands.push_back(Ops[Offset + 2]); // vl
+  if (IsMasked)
+Operands.push_back(ConstantInt::get(Ops.back()->getType(), PolicyAttrs));
+
+  llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
+
+  llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
+  // Get alignment from the new vl operand
+  cla

[PATCH] D151078: [clang][Diagnostics] Use llvm::raw_ostream::indent()

2023-05-22 Thread Timm Bäder via Phabricator via cfe-commits
tbaeder created this revision.
tbaeder added reviewers: aaron.ballman, cjdb.
Herald added a project: All.
tbaeder requested review of this revision.
Herald added a project: clang.
Herald added a subscriber: cfe-commits.

TIL that this exists.


Repository:
  rG LLVM Github Monorepo

https://reviews.llvm.org/D151078

Files:
  clang/lib/Frontend/TextDiagnostic.cpp


Index: clang/lib/Frontend/TextDiagnostic.cpp
===
--- clang/lib/Frontend/TextDiagnostic.cpp
+++ clang/lib/Frontend/TextDiagnostic.cpp
@@ -623,9 +623,6 @@
   const unsigned Length = std::min(Str.find('\n'), Str.size());
   bool TextNormal = true;
 
-  // The string used to indent each line.
-  SmallString<16> IndentStr;
-  IndentStr.assign(Indentation, ' ');
   bool Wrapped = false;
   for (unsigned WordStart = 0, WordEnd; WordStart < Length;
WordStart = WordEnd) {
@@ -654,7 +651,7 @@
 // This word does not fit on the current line, so wrap to the next
 // line.
 OS << '\n';
-OS.write(&IndentStr[0], Indentation);
+OS.indent(Indentation);
 applyTemplateHighlighting(OS, Str.substr(WordStart, WordLength),
   TextNormal, Bold);
 Column = Indentation + WordLength;
@@ -1196,12 +1193,8 @@
   ? std::max(4u, getNumDisplayWidth(DisplayLineNo + MaxLines))
   : 0;
   auto indentForLineNumbers = [&] {
-if (MaxLineNoDisplayWidth > 0) {
-  OS << ' ';
-  for (unsigned I = 0; I != MaxLineNoDisplayWidth; ++I)
-OS << ' ';
-  OS << " | ";
-}
+if (MaxLineNoDisplayWidth > 0)
+  OS.indent(MaxLineNoDisplayWidth + 4);
   };
 
   for (unsigned LineNo = Lines.first; LineNo != Lines.second + 1;
@@ -1315,9 +1308,7 @@
   // Emit line number.
   if (MaxLineNoDisplayWidth > 0) {
 unsigned LineNoDisplayWidth = getNumDisplayWidth(LineNo);
-OS << ' ';
-for (unsigned I = LineNoDisplayWidth; I < MaxLineNoDisplayWidth; ++I)
-  OS << ' ';
+OS.indent(MaxLineNoDisplayWidth - LineNoDisplayWidth + 1);
 OS << LineNo;
 OS << " | ";
   }


Index: clang/lib/Frontend/TextDiagnostic.cpp
===
--- clang/lib/Frontend/TextDiagnostic.cpp
+++ clang/lib/Frontend/TextDiagnostic.cpp
@@ -623,9 +623,6 @@
   const unsigned Length = std::min(Str.find('\n'), Str.size());
   bool TextNormal = true;
 
-  // The string used to indent each line.
-  SmallString<16> IndentStr;
-  IndentStr.assign(Indentation, ' ');
   bool Wrapped = false;
   for (unsigned WordStart = 0, WordEnd; WordStart < Length;
WordStart = WordEnd) {
@@ -654,7 +651,7 @@
 // This word does not fit on the current line, so wrap to the next
 // line.
 OS << '\n';
-OS.write(&IndentStr[0], Indentation);
+OS.indent(Indentation);
 applyTemplateHighlighting(OS, Str.substr(WordStart, WordLength),
   TextNormal, Bold);
 Column = Indentation + WordLength;
@@ -1196,12 +1193,8 @@
   ? std::max(4u, getNumDisplayWidth(DisplayLineNo + MaxLines))
   : 0;
   auto indentForLineNumbers = [&] {
-if (MaxLineNoDisplayWidth > 0) {
-  OS << ' ';
-  for (unsigned I = 0; I != MaxLineNoDisplayWidth; ++I)
-OS << ' ';
-  OS << " | ";
-}
+if (MaxLineNoDisplayWidth > 0)
+  OS.indent(MaxLineNoDisplayWidth + 4);
   };
 
   for (unsigned LineNo = Lines.first; LineNo != Lines.second + 1;
@@ -1315,9 +1308,7 @@
   // Emit line number.
   if (MaxLineNoDisplayWidth > 0) {
 unsigned LineNoDisplayWidth = getNumDisplayWidth(LineNo);
-OS << ' ';
-for (unsigned I = LineNoDisplayWidth; I < MaxLineNoDisplayWidth; ++I)
-  OS << ' ';
+OS.indent(MaxLineNoDisplayWidth - LineNoDisplayWidth + 1);
 OS << LineNo;
 OS << " | ";
   }
___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[clang] bf2511b - [6/11][POC][Clang][RISCV] Define tuple type variant of vlsseg2e32

2023-05-22 Thread via cfe-commits

Author: eopXD
Date: 2023-05-22T04:09:22-07:00
New Revision: bf2511bdd8143f6f3d898b1d7d9f351e0eeb0f12

URL: 
https://github.com/llvm/llvm-project/commit/bf2511bdd8143f6f3d898b1d7d9f351e0eeb0f12
DIFF: 
https://github.com/llvm/llvm-project/commit/bf2511bdd8143f6f3d898b1d7d9f351e0eeb0f12.diff

LOG: [6/11][POC][Clang][RISCV] Define tuple type variant of vlsseg2e32

For the cover letter of this patch-set, please checkout D146872.

Depends on D147911.

This is the 6th patch of the patch-set.

This patch is a proof-of-concept and will be extended to full coverage
in the future. Currently, the old non-tuple strided segment load is not
removed, and only signed integer strided segment load of NF=2, EEW=32
is defined here.

Reviewed By: craig.topper

Differential Revision: https://reviews.llvm.org/D147912

Added: 

clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vlsseg2e32_tuple.c

Modified: 
clang/include/clang/Basic/riscv_vector.td

Removed: 




diff  --git a/clang/include/clang/Basic/riscv_vector.td 
b/clang/include/clang/Basic/riscv_vector.td
index 42375c265b088..b323ac57bdeb4 100644
--- a/clang/include/clang/Basic/riscv_vector.td
+++ b/clang/include/clang/Basic/riscv_vector.td
@@ -1652,12 +1652,60 @@ multiclass RVVUnitStridedSegLoadFFTuple {
   }
 }
 
+multiclass RVVStridedSegLoadTuple {
+  foreach type = ["i"] in {
+defvar eew = !cond(!eq(type, "i") : "32");
+  foreach nf = [2] in {
+let Name = op # nf # "e" # eew # "_v_tuple",
+OverloadedName = op # nf # "e" # eew # "_tuple",
+IRName = op # nf,
+MaskedIRName = op # nf # "_mask",
+NF = nf,
+ManualCodegen = [{
+{
+  assert(((IsMasked && (PolicyAttrs & RVV_VTA) && (PolicyAttrs & RVV_VMA)) 
||
+ (!IsMasked && (PolicyAttrs & RVV_VTA))) &&
+ "FIXME: Only handling default policy (TAMA) for now");
+
+  llvm::Type *ElementVectorType = 
cast(ResultType)->elements()[0];
+
+  IntrinsicTypes = {ElementVectorType, Ops.back()->getType()};
+  SmallVector Operands;
+
+  Operands.append(NF, llvm::PoisonValue::get(ElementVectorType));
+
+  unsigned Offset = IsMasked ? 1 : 0;
+  Operands.push_back(Ops[Offset]); // Ptr
+  Operands.push_back(Ops[Offset + 1]); // Stride
+  if (IsMasked)
+Operands.push_back(Ops[0]);
+  Operands.push_back(Ops[Offset + 2]); // VL
+  if (IsMasked)
+Operands.push_back(ConstantInt::get(Ops.back()->getType(), 
PolicyAttrs));
+
+  llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
+  llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
+
+  if (ReturnValue.isNull())
+return LoadValue;
+  else
+return Builder.CreateStore(LoadValue, ReturnValue.getValue());
+}
+}] in {
+  defvar T = "(Tuple:" # nf # ")";
+  def : RVVBuiltin<"v", T # "vPCet", type>;
+  }
+}
+  }
+}
+
 // TODO: Extend for policy
 let UnMaskedPolicyScheme = NonePolicy,
 MaskedPolicyScheme = NonePolicy,
 IsTuple = true in {
 defm : RVVUnitStridedSegLoadTuple<"vlseg">;
 defm : RVVUnitStridedSegLoadFFTuple<"vlseg">;
+defm : RVVStridedSegLoadTuple<"vlsseg">;
 }
 
 let UnMaskedPolicyScheme = NonePolicy,

diff  --git 
a/clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vlsseg2e32_tuple.c
 
b/clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vlsseg2e32_tuple.c
new file mode 100644
index 0..8d63d030e8529
--- /dev/null
+++ 
b/clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vlsseg2e32_tuple.c
@@ -0,0 +1,27 @@
+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py 
UTC_ARGS: --version 2
+// REQUIRES: riscv-registered-target
+// RUN: %clang_cc1 -triple riscv64 -target-feature +v -target-feature +zfh \
+// RUN:   -target-feature +experimental-zvfh -disable-O0-optnone  \
+// RUN:   -emit-llvm %s -o - | opt -S -passes=mem2reg | \
+// RUN:   FileCheck --check-prefix=CHECK-RV64 %s
+#include 
+
+// CHECK-RV64-LABEL: define dso_local { ,  
} @test_vlsseg2e32_v_tuple_i32m1
+// CHECK-RV64-SAME: (ptr noundef [[BASE:%.*]], i64 noundef [[BSTRIDE:%.*]], 
i64 noundef [[VL:%.*]]) #[[ATTR0:[0-9]+]] {
+// CHECK-RV64-NEXT:  entry:
+// CHECK-RV64-NEXT:[[TMP0:%.*]] = call { ,  } @llvm.riscv.vlsseg2.nxv2i32.i64( poison,  poison, ptr [[BASE]], i64 [[BSTRIDE]], i64 [[VL]])
+// CHECK-RV64-NEXT:ret { ,  } [[TMP0]]
+//
+vint32m1x2_t test_vlsseg2e32_v_tuple_i32m1(const int32_t *base, ptr
diff _t bstride, size_t vl) {
+  return __riscv_vlsseg2e32_v_tuple_i32m1(base, bstride, vl);
+}
+
+// CHECK-RV64-LABEL: define dso_local { ,  
} @test_vlsseg2e32_v_tuple_i32m1_m
+// CHECK-RV64-SAME: ( [[MASK:%.*]], ptr noundef [[BASE:%.*]], 
i64 noundef [[BSTRIDE:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] {
+// CHECK-RV64-NEXT:  entry:
+// CHECK-RV

[PATCH] D147912: [6/11][POC][Clang][RISCV] Define tuple type variant of vlsseg2e32

2023-05-22 Thread Yueh-Ting (eop) Chen via Phabricator via cfe-commits
This revision was landed with ongoing or failed builds.
This revision was automatically updated to reflect the committed changes.
Closed by commit rGbf2511bdd814: [6/11][POC][Clang][RISCV] Define tuple type 
variant of vlsseg2e32 (authored by eopXD).

Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D147912/new/

https://reviews.llvm.org/D147912

Files:
  clang/include/clang/Basic/riscv_vector.td
  
clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vlsseg2e32_tuple.c


Index: 
clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vlsseg2e32_tuple.c
===
--- /dev/null
+++ 
clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vlsseg2e32_tuple.c
@@ -0,0 +1,27 @@
+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py 
UTC_ARGS: --version 2
+// REQUIRES: riscv-registered-target
+// RUN: %clang_cc1 -triple riscv64 -target-feature +v -target-feature +zfh \
+// RUN:   -target-feature +experimental-zvfh -disable-O0-optnone  \
+// RUN:   -emit-llvm %s -o - | opt -S -passes=mem2reg | \
+// RUN:   FileCheck --check-prefix=CHECK-RV64 %s
+#include 
+
+// CHECK-RV64-LABEL: define dso_local { ,  
} @test_vlsseg2e32_v_tuple_i32m1
+// CHECK-RV64-SAME: (ptr noundef [[BASE:%.*]], i64 noundef [[BSTRIDE:%.*]], 
i64 noundef [[VL:%.*]]) #[[ATTR0:[0-9]+]] {
+// CHECK-RV64-NEXT:  entry:
+// CHECK-RV64-NEXT:[[TMP0:%.*]] = call { ,  } @llvm.riscv.vlsseg2.nxv2i32.i64( poison,  poison, ptr [[BASE]], i64 [[BSTRIDE]], i64 [[VL]])
+// CHECK-RV64-NEXT:ret { ,  } [[TMP0]]
+//
+vint32m1x2_t test_vlsseg2e32_v_tuple_i32m1(const int32_t *base, ptrdiff_t 
bstride, size_t vl) {
+  return __riscv_vlsseg2e32_v_tuple_i32m1(base, bstride, vl);
+}
+
+// CHECK-RV64-LABEL: define dso_local { ,  
} @test_vlsseg2e32_v_tuple_i32m1_m
+// CHECK-RV64-SAME: ( [[MASK:%.*]], ptr noundef [[BASE:%.*]], 
i64 noundef [[BSTRIDE:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] {
+// CHECK-RV64-NEXT:  entry:
+// CHECK-RV64-NEXT:[[TMP0:%.*]] = call { ,  } @llvm.riscv.vlsseg2.mask.nxv2i32.i64( poison,  poison, ptr [[BASE]], i64 [[BSTRIDE]],  [[MASK]], 
i64 [[VL]], i64 3)
+// CHECK-RV64-NEXT:ret { ,  } [[TMP0]]
+//
+vint32m1x2_t test_vlsseg2e32_v_tuple_i32m1_m(vbool32_t mask, const int32_t 
*base, ptrdiff_t bstride, size_t vl) {
+  return __riscv_vlsseg2e32_v_tuple_i32m1_m(mask, base, bstride, vl);
+}
Index: clang/include/clang/Basic/riscv_vector.td
===
--- clang/include/clang/Basic/riscv_vector.td
+++ clang/include/clang/Basic/riscv_vector.td
@@ -1652,12 +1652,60 @@
   }
 }
 
+multiclass RVVStridedSegLoadTuple {
+  foreach type = ["i"] in {
+defvar eew = !cond(!eq(type, "i") : "32");
+  foreach nf = [2] in {
+let Name = op # nf # "e" # eew # "_v_tuple",
+OverloadedName = op # nf # "e" # eew # "_tuple",
+IRName = op # nf,
+MaskedIRName = op # nf # "_mask",
+NF = nf,
+ManualCodegen = [{
+{
+  assert(((IsMasked && (PolicyAttrs & RVV_VTA) && (PolicyAttrs & RVV_VMA)) 
||
+ (!IsMasked && (PolicyAttrs & RVV_VTA))) &&
+ "FIXME: Only handling default policy (TAMA) for now");
+
+  llvm::Type *ElementVectorType = 
cast(ResultType)->elements()[0];
+
+  IntrinsicTypes = {ElementVectorType, Ops.back()->getType()};
+  SmallVector Operands;
+
+  Operands.append(NF, llvm::PoisonValue::get(ElementVectorType));
+
+  unsigned Offset = IsMasked ? 1 : 0;
+  Operands.push_back(Ops[Offset]); // Ptr
+  Operands.push_back(Ops[Offset + 1]); // Stride
+  if (IsMasked)
+Operands.push_back(Ops[0]);
+  Operands.push_back(Ops[Offset + 2]); // VL
+  if (IsMasked)
+Operands.push_back(ConstantInt::get(Ops.back()->getType(), 
PolicyAttrs));
+
+  llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
+  llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
+
+  if (ReturnValue.isNull())
+return LoadValue;
+  else
+return Builder.CreateStore(LoadValue, ReturnValue.getValue());
+}
+}] in {
+  defvar T = "(Tuple:" # nf # ")";
+  def : RVVBuiltin<"v", T # "vPCet", type>;
+  }
+}
+  }
+}
+
 // TODO: Extend for policy
 let UnMaskedPolicyScheme = NonePolicy,
 MaskedPolicyScheme = NonePolicy,
 IsTuple = true in {
 defm : RVVUnitStridedSegLoadTuple<"vlseg">;
 defm : RVVUnitStridedSegLoadFFTuple<"vlseg">;
+defm : RVVStridedSegLoadTuple<"vlsseg">;
 }
 
 let UnMaskedPolicyScheme = NonePolicy,


Index: clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vlsseg2e32_tuple.c
===
--- /dev/null
+++ clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vlsseg2e32_tuple.c
@@ -0,0 +1,27 @@

[clang] f2ffdaa - [7/11][POC][Clang][RISCV] Define tuple type variant of vssseg2e32

2023-05-22 Thread via cfe-commits

Author: eopXD
Date: 2023-05-22T04:13:51-07:00
New Revision: f2ffdaaae6bf246a8bc00b4b9924393d10835264

URL: 
https://github.com/llvm/llvm-project/commit/f2ffdaaae6bf246a8bc00b4b9924393d10835264
DIFF: 
https://github.com/llvm/llvm-project/commit/f2ffdaaae6bf246a8bc00b4b9924393d10835264.diff

LOG: [7/11][POC][Clang][RISCV] Define tuple type variant of vssseg2e32

For the cover letter of this patch-set, please checkout D146872.

Depends on D147912.

This is the 7th patch of the patch-set.

This patch is a proof-of-concept and will be extended to full coverage
in the future. Currently, the old non-tuple strided segment store is
not removed, and only signed integer strided segment store of NF=2,
EEW=32 is defined here.

Reviewed By: craig.topper

Differential Revision: https://reviews.llvm.org/D147913

Added: 

clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vssseg2e32_tuple.c

Modified: 
clang/include/clang/Basic/riscv_vector.td

Removed: 




diff  --git a/clang/include/clang/Basic/riscv_vector.td 
b/clang/include/clang/Basic/riscv_vector.td
index b323ac57bdeb4..ca0227cb6edb5 100644
--- a/clang/include/clang/Basic/riscv_vector.td
+++ b/clang/include/clang/Basic/riscv_vector.td
@@ -1699,6 +1699,51 @@ multiclass RVVStridedSegLoadTuple {
   }
 }
 
+multiclass RVVStridedSegStoreTuple {
+  foreach type = ["i"] in {
+defvar eew = !cond(!eq(type, "i") : "32");
+  foreach nf = [2] in {
+let Name = op # nf # "e" # eew # "_v_tuple",
+OverloadedName = op # nf # "e" # eew # "_tuple",
+IRName = op # nf,
+MaskedIRName = op # nf # "_mask",
+NF = nf,
+HasMaskedOffOperand = false,
+MaskedPolicyScheme = NonePolicy,
+ManualCodegen = [{
+{
+  // Masked
+  // Builtin: (mask, ptr, stride, v_tuple, vl)
+  // Intrinsic: (val0, val1, ..., ptr, stride, mask, vl)
+  // Unmasked
+  // Builtin: (ptr, stride, v_tuple, vl)
+  // Intrinsic: (val0, val1, ..., ptr, stride, vl)
+  unsigned Offset = IsMasked ? 1 : 0;
+  llvm::Value *VTupleOperand = Ops[Offset + 2];
+
+  SmallVector Operands;
+  for (unsigned I = 0; I < NF; ++I) {
+llvm::Value *V = Builder.CreateExtractValue(VTupleOperand, {I});
+Operands.push_back(V);
+  }
+  Operands.push_back(Ops[Offset]); // Ptr
+  Operands.push_back(Ops[Offset + 1]); // Stride
+  if (IsMasked)
+Operands.push_back(Ops[0]);
+  Operands.push_back(Ops[Offset + 3]); // VL
+
+  IntrinsicTypes = {Operands[0]->getType(), Operands.back()->getType()};
+  llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
+  return Builder.CreateCall(F, Operands, "");
+}
+}] in {
+  defvar T = "(Tuple:" # nf # ")";
+  def : RVVBuiltin<"v", "0Pet" # T # "v", type>;
+  }
+}
+  }
+}
+
 // TODO: Extend for policy
 let UnMaskedPolicyScheme = NonePolicy,
 MaskedPolicyScheme = NonePolicy,
@@ -1712,6 +1757,7 @@ let UnMaskedPolicyScheme = NonePolicy,
 MaskedPolicyScheme = NonePolicy,
 IsTuple = true in {
 defm : RVVUnitStridedSegStoreTuple<"vsseg">;
+defm : RVVStridedSegStoreTuple<"vssseg">;
 }
 
 

diff  --git 
a/clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vssseg2e32_tuple.c
 
b/clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vssseg2e32_tuple.c
new file mode 100644
index 0..548e1104b9b7d
--- /dev/null
+++ 
b/clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vssseg2e32_tuple.c
@@ -0,0 +1,36 @@
+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py 
UTC_ARGS: --version 2
+// REQUIRES: riscv-registered-target
+// RUN: %clang_cc1 -triple riscv64 -target-feature +v -target-feature +zfh \
+// RUN:   -target-feature +experimental-zvfh -disable-O0-optnone  \
+// RUN:   -emit-llvm %s -o - | opt -S -passes=mem2reg | \
+// RUN:   FileCheck --check-prefix=CHECK-RV64 %s
+
+#include 
+
+// CHECK-RV64-LABEL: define dso_local void @test_vssseg2e32_v_tuple_i32m1
+// CHECK-RV64-SAME: (ptr noundef [[BASE:%.*]], i64 noundef [[BSTRIDE:%.*]], 
 [[V_TUPLE_COERCE0:%.*]],  
[[V_TUPLE_COERCE1:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0:[0-9]+]] {
+// CHECK-RV64-NEXT:  entry:
+// CHECK-RV64-NEXT:[[TMP0:%.*]] = insertvalue { , 
 } poison,  [[V_TUPLE_COERCE0]], 0
+// CHECK-RV64-NEXT:[[TMP1:%.*]] = insertvalue { , 
 } [[TMP0]],  [[V_TUPLE_COERCE1]], 1
+// CHECK-RV64-NEXT:[[TMP2:%.*]] = extractvalue { , 
 } [[TMP1]], 0
+// CHECK-RV64-NEXT:[[TMP3:%.*]] = extractvalue { , 
 } [[TMP1]], 1
+// CHECK-RV64-NEXT:call void @llvm.riscv.vssseg2.nxv2i32.i64( [[TMP2]],  [[TMP3]], ptr [[BASE]], i64 [[BSTRIDE]], i64 
[[VL]])
+// CHECK-RV64-NEXT:ret void
+//
+void test_vssseg2e32_v_tuple_i32m1(int32_t *base, ptr
diff _t bstride, vint32m1x2_t v_tuple, size_t vl)

[PATCH] D147913: [7/11][POC][Clang][RISCV] Define tuple type variant of vssseg2e32

2023-05-22 Thread Yueh-Ting (eop) Chen via Phabricator via cfe-commits
This revision was landed with ongoing or failed builds.
This revision was automatically updated to reflect the committed changes.
Closed by commit rGf2ffdaaae6bf: [7/11][POC][Clang][RISCV] Define tuple type 
variant of vssseg2e32 (authored by eopXD).

Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D147913/new/

https://reviews.llvm.org/D147913

Files:
  clang/include/clang/Basic/riscv_vector.td
  
clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vssseg2e32_tuple.c

Index: clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vssseg2e32_tuple.c
===
--- /dev/null
+++ clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vssseg2e32_tuple.c
@@ -0,0 +1,36 @@
+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --version 2
+// REQUIRES: riscv-registered-target
+// RUN: %clang_cc1 -triple riscv64 -target-feature +v -target-feature +zfh \
+// RUN:   -target-feature +experimental-zvfh -disable-O0-optnone  \
+// RUN:   -emit-llvm %s -o - | opt -S -passes=mem2reg | \
+// RUN:   FileCheck --check-prefix=CHECK-RV64 %s
+
+#include 
+
+// CHECK-RV64-LABEL: define dso_local void @test_vssseg2e32_v_tuple_i32m1
+// CHECK-RV64-SAME: (ptr noundef [[BASE:%.*]], i64 noundef [[BSTRIDE:%.*]],  [[V_TUPLE_COERCE0:%.*]],  [[V_TUPLE_COERCE1:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0:[0-9]+]] {
+// CHECK-RV64-NEXT:  entry:
+// CHECK-RV64-NEXT:[[TMP0:%.*]] = insertvalue { ,  } poison,  [[V_TUPLE_COERCE0]], 0
+// CHECK-RV64-NEXT:[[TMP1:%.*]] = insertvalue { ,  } [[TMP0]],  [[V_TUPLE_COERCE1]], 1
+// CHECK-RV64-NEXT:[[TMP2:%.*]] = extractvalue { ,  } [[TMP1]], 0
+// CHECK-RV64-NEXT:[[TMP3:%.*]] = extractvalue { ,  } [[TMP1]], 1
+// CHECK-RV64-NEXT:call void @llvm.riscv.vssseg2.nxv2i32.i64( [[TMP2]],  [[TMP3]], ptr [[BASE]], i64 [[BSTRIDE]], i64 [[VL]])
+// CHECK-RV64-NEXT:ret void
+//
+void test_vssseg2e32_v_tuple_i32m1(int32_t *base, ptrdiff_t bstride, vint32m1x2_t v_tuple, size_t vl) {
+  return __riscv_vssseg2e32_v_tuple_i32m1(base, bstride, v_tuple, vl);
+}
+
+// CHECK-RV64-LABEL: define dso_local void @test_vssseg2e32_v_tuple_i32m1_m
+// CHECK-RV64-SAME: ( [[MASK:%.*]], ptr noundef [[BASE:%.*]], i64 noundef [[BSTRIDE:%.*]],  [[V_TUPLE_COERCE0:%.*]],  [[V_TUPLE_COERCE1:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] {
+// CHECK-RV64-NEXT:  entry:
+// CHECK-RV64-NEXT:[[TMP0:%.*]] = insertvalue { ,  } poison,  [[V_TUPLE_COERCE0]], 0
+// CHECK-RV64-NEXT:[[TMP1:%.*]] = insertvalue { ,  } [[TMP0]],  [[V_TUPLE_COERCE1]], 1
+// CHECK-RV64-NEXT:[[TMP2:%.*]] = extractvalue { ,  } [[TMP1]], 0
+// CHECK-RV64-NEXT:[[TMP3:%.*]] = extractvalue { ,  } [[TMP1]], 1
+// CHECK-RV64-NEXT:call void @llvm.riscv.vssseg2.mask.nxv2i32.i64( [[TMP2]],  [[TMP3]], ptr [[BASE]], i64 [[BSTRIDE]],  [[MASK]], i64 [[VL]])
+// CHECK-RV64-NEXT:ret void
+//
+void test_vssseg2e32_v_tuple_i32m1_m(vbool32_t mask, int32_t *base, ptrdiff_t bstride, vint32m1x2_t v_tuple, size_t vl) {
+  return __riscv_vssseg2e32_v_tuple_i32m1_m(mask, base, bstride, v_tuple, vl);
+}
Index: clang/include/clang/Basic/riscv_vector.td
===
--- clang/include/clang/Basic/riscv_vector.td
+++ clang/include/clang/Basic/riscv_vector.td
@@ -1699,6 +1699,51 @@
   }
 }
 
+multiclass RVVStridedSegStoreTuple {
+  foreach type = ["i"] in {
+defvar eew = !cond(!eq(type, "i") : "32");
+  foreach nf = [2] in {
+let Name = op # nf # "e" # eew # "_v_tuple",
+OverloadedName = op # nf # "e" # eew # "_tuple",
+IRName = op # nf,
+MaskedIRName = op # nf # "_mask",
+NF = nf,
+HasMaskedOffOperand = false,
+MaskedPolicyScheme = NonePolicy,
+ManualCodegen = [{
+{
+  // Masked
+  // Builtin: (mask, ptr, stride, v_tuple, vl)
+  // Intrinsic: (val0, val1, ..., ptr, stride, mask, vl)
+  // Unmasked
+  // Builtin: (ptr, stride, v_tuple, vl)
+  // Intrinsic: (val0, val1, ..., ptr, stride, vl)
+  unsigned Offset = IsMasked ? 1 : 0;
+  llvm::Value *VTupleOperand = Ops[Offset + 2];
+
+  SmallVector Operands;
+  for (unsigned I = 0; I < NF; ++I) {
+llvm::Value *V = Builder.CreateExtractValue(VTupleOperand, {I});
+Operands.push_back(V);
+  }
+  Operands.push_back(Ops[Offset]); // Ptr
+  Operands.push_back(Ops[Offset + 1]); // Stride
+  if (IsMasked)
+Operands.push_back(Ops[0]);
+  Operands.push_back(Ops[Offset + 3]); // VL
+
+  IntrinsicTypes = {Operands[0]->getType(), Operands.back()->getType()};
+  llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
+  return Builder.CreateCall(F, Operands, "");
+}
+}] in {
+  defvar T = "(Tuple:" # nf # ")";
+  def : RVVBuiltin<"v", "0Pet" 

[clang] 827f439 - [8/11][POC][Clang][RISCV] Define tuple type variant of vloxseg2ei32 vluxseg2ei32

2023-05-22 Thread via cfe-commits

Author: eopXD
Date: 2023-05-22T04:20:09-07:00
New Revision: 827f43918836fa3a2ec1abaf3592fb4a74dcaf48

URL: 
https://github.com/llvm/llvm-project/commit/827f43918836fa3a2ec1abaf3592fb4a74dcaf48
DIFF: 
https://github.com/llvm/llvm-project/commit/827f43918836fa3a2ec1abaf3592fb4a74dcaf48.diff

LOG: [8/11][POC][Clang][RISCV] Define tuple type variant of vloxseg2ei32 
vluxseg2ei32

For the cover letter of this patch-set, please checkout D146872.

Depends on D147913.

This is the 8th patch of the patch-set.

This patch is a proof-of-concept and will be extended to full coverage
in the future. Currently, the old non-tuple indexed segment load is
not removed, and only signed integer indexed segment load of NF=2,
EEW=32 is defined here.

Reviewed By: craig.topper

Differential Revision: https://reviews.llvm.org/D147914

Added: 

clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vloxseg2ei32_tuple.c

clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vluxseg2ei32_tuple.c

Modified: 
clang/include/clang/Basic/riscv_vector.td

Removed: 




diff  --git a/clang/include/clang/Basic/riscv_vector.td 
b/clang/include/clang/Basic/riscv_vector.td
index ca0227cb6edb5..72d037512dcab 100644
--- a/clang/include/clang/Basic/riscv_vector.td
+++ b/clang/include/clang/Basic/riscv_vector.td
@@ -1744,6 +1744,57 @@ multiclass RVVStridedSegStoreTuple {
   }
 }
 
+multiclass RVVIndexedSegLoadTuple {
+  foreach type = ["i"] in {
+foreach eew_info = [["32", "(Log2EEW:5)"]] in {
+  defvar eew = eew_info[0];
+  defvar eew_type = eew_info[1];
+  foreach nf = [2] in {
+let Name = op # nf # "ei" # eew # "_v_tuple",
+OverloadedName = op # nf # "ei" # eew # "_tuple",
+IRName = op # nf,
+MaskedIRName = op # nf # "_mask",
+NF = nf,
+ManualCodegen = [{
+{
+  assert(((IsMasked && (PolicyAttrs & RVV_VTA) && (PolicyAttrs & RVV_VMA)) 
||
+ (!IsMasked && (PolicyAttrs & RVV_VTA))) &&
+ "FIXME: Only handling default policy (TAMA) for now");
+
+  llvm::Type *ElementVectorType = 
cast(ResultType)->elements()[0];
+
+  SmallVector Operands;
+
+  Operands.append(NF, llvm::PoisonValue::get(ElementVectorType));
+
+  unsigned Offset = IsMasked ? 1 : 0;
+  Operands.push_back(Ops[Offset]); // Ptr
+  Operands.push_back(Ops[Offset + 1]); // Idx
+  if (IsMasked)
+Operands.push_back(Ops[0]);
+  Operands.push_back(Ops[Offset + 2]); // VL
+  if (IsMasked)
+Operands.push_back(ConstantInt::get(Ops.back()->getType(), 
PolicyAttrs));
+
+  IntrinsicTypes = {ElementVectorType, Ops[Offset + 1]->getType(),
+Ops.back()->getType()};
+  llvm::Function *F = CGM.getIntrinsic(ID, IntrinsicTypes);
+  llvm::Value *LoadValue = Builder.CreateCall(F, Operands, "");
+
+  if (ReturnValue.isNull())
+return LoadValue;
+  else
+return Builder.CreateStore(LoadValue, ReturnValue.getValue());
+}
+}] in {
+  defvar T = "(Tuple:" # nf # ")";
+  def : RVVBuiltin<"v", T # "vPCe" # eew_type # "Uv", type>;
+}
+  }
+}
+  }
+}
+
 // TODO: Extend for policy
 let UnMaskedPolicyScheme = NonePolicy,
 MaskedPolicyScheme = NonePolicy,
@@ -1751,6 +1802,8 @@ let UnMaskedPolicyScheme = NonePolicy,
 defm : RVVUnitStridedSegLoadTuple<"vlseg">;
 defm : RVVUnitStridedSegLoadFFTuple<"vlseg">;
 defm : RVVStridedSegLoadTuple<"vlsseg">;
+defm : RVVIndexedSegLoadTuple<"vluxseg">;
+defm : RVVIndexedSegLoadTuple<"vloxseg">;
 }
 
 let UnMaskedPolicyScheme = NonePolicy,

diff  --git 
a/clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vloxseg2ei32_tuple.c
 
b/clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vloxseg2ei32_tuple.c
new file mode 100644
index 0..e626b19b147d6
--- /dev/null
+++ 
b/clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vloxseg2ei32_tuple.c
@@ -0,0 +1,28 @@
+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py 
UTC_ARGS: --version 2
+// REQUIRES: riscv-registered-target
+// RUN: %clang_cc1 -triple riscv64 -target-feature +v -target-feature +zfh \
+// RUN:   -target-feature +experimental-zvfh -disable-O0-optnone  \
+// RUN:   -emit-llvm %s -o - | opt -S -passes=mem2reg | \
+// RUN:   FileCheck --check-prefix=CHECK-RV64 %s
+
+#include 
+
+// CHECK-RV64-LABEL: define dso_local { ,  
} @test_vloxseg2ei32_v_tuple_i32m1
+// CHECK-RV64-SAME: (ptr noundef [[BASE:%.*]],  
[[BINDEX:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0:[0-9]+]] {
+// CHECK-RV64-NEXT:  entry:
+// CHECK-RV64-NEXT:[[TMP0:%.*]] = call { ,  } @llvm.riscv.vloxseg2.nxv2i32.nxv2i32.i64( poison, 
 poison, ptr [[BASE]],  [[BINDEX]], i64 
[[VL]])
+// CHECK-RV64-NEXT:ret { ,  } [[TMP0]]
+//
+vint32m1x2_t tes

[PATCH] D147914: [8/11][POC][Clang][RISCV] Define tuple type variant of vloxseg2ei32 vluxseg2ei32

2023-05-22 Thread Yueh-Ting (eop) Chen via Phabricator via cfe-commits
This revision was landed with ongoing or failed builds.
This revision was automatically updated to reflect the committed changes.
Closed by commit rG827f43918836: [8/11][POC][Clang][RISCV] Define tuple type 
variant of vloxseg2ei32 vluxseg2ei32 (authored by eopXD).

Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D147914/new/

https://reviews.llvm.org/D147914

Files:
  clang/include/clang/Basic/riscv_vector.td
  
clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vloxseg2ei32_tuple.c
  
clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vluxseg2ei32_tuple.c

Index: clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vluxseg2ei32_tuple.c
===
--- /dev/null
+++ clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vluxseg2ei32_tuple.c
@@ -0,0 +1,28 @@
+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --version 2
+// REQUIRES: riscv-registered-target
+// RUN: %clang_cc1 -triple riscv64 -target-feature +v -target-feature +zfh \
+// RUN:   -target-feature +experimental-zvfh -disable-O0-optnone  \
+// RUN:   -emit-llvm %s -o - | opt -S -passes=mem2reg | \
+// RUN:   FileCheck --check-prefix=CHECK-RV64 %s
+
+#include 
+
+// CHECK-RV64-LABEL: define dso_local { ,  } @test_vluxseg2ei32_v_tuple_i32m1
+// CHECK-RV64-SAME: (ptr noundef [[BASE:%.*]],  [[BINDEX:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0:[0-9]+]] {
+// CHECK-RV64-NEXT:  entry:
+// CHECK-RV64-NEXT:[[TMP0:%.*]] = call { ,  } @llvm.riscv.vluxseg2.nxv2i32.nxv2i32.i64( poison,  poison, ptr [[BASE]],  [[BINDEX]], i64 [[VL]])
+// CHECK-RV64-NEXT:ret { ,  } [[TMP0]]
+//
+vint32m1x2_t test_vluxseg2ei32_v_tuple_i32m1(const int32_t *base, vuint32m1_t bindex, size_t vl) {
+  return __riscv_vluxseg2ei32_v_tuple_i32m1(base, bindex, vl);
+}
+
+// CHECK-RV64-LABEL: define dso_local { ,  } @test_vluxseg2ei32_v_tuple_i32m1_m
+// CHECK-RV64-SAME: ( [[MASK:%.*]], ptr noundef [[BASE:%.*]],  [[BINDEX:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] {
+// CHECK-RV64-NEXT:  entry:
+// CHECK-RV64-NEXT:[[TMP0:%.*]] = call { ,  } @llvm.riscv.vluxseg2.mask.nxv2i32.nxv2i32.i64( poison,  poison, ptr [[BASE]],  [[BINDEX]],  [[MASK]], i64 [[VL]], i64 3)
+// CHECK-RV64-NEXT:ret { ,  } [[TMP0]]
+//
+vint32m1x2_t test_vluxseg2ei32_v_tuple_i32m1_m(vbool32_t mask, const int32_t *base, vuint32m1_t bindex, size_t vl) {
+  return __riscv_vluxseg2ei32_v_tuple_i32m1_m(mask, base, bindex, vl);
+}
Index: clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vloxseg2ei32_tuple.c
===
--- /dev/null
+++ clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vloxseg2ei32_tuple.c
@@ -0,0 +1,28 @@
+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --version 2
+// REQUIRES: riscv-registered-target
+// RUN: %clang_cc1 -triple riscv64 -target-feature +v -target-feature +zfh \
+// RUN:   -target-feature +experimental-zvfh -disable-O0-optnone  \
+// RUN:   -emit-llvm %s -o - | opt -S -passes=mem2reg | \
+// RUN:   FileCheck --check-prefix=CHECK-RV64 %s
+
+#include 
+
+// CHECK-RV64-LABEL: define dso_local { ,  } @test_vloxseg2ei32_v_tuple_i32m1
+// CHECK-RV64-SAME: (ptr noundef [[BASE:%.*]],  [[BINDEX:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0:[0-9]+]] {
+// CHECK-RV64-NEXT:  entry:
+// CHECK-RV64-NEXT:[[TMP0:%.*]] = call { ,  } @llvm.riscv.vloxseg2.nxv2i32.nxv2i32.i64( poison,  poison, ptr [[BASE]],  [[BINDEX]], i64 [[VL]])
+// CHECK-RV64-NEXT:ret { ,  } [[TMP0]]
+//
+vint32m1x2_t test_vloxseg2ei32_v_tuple_i32m1(const int32_t *base, vuint32m1_t bindex, size_t vl) {
+  return __riscv_vloxseg2ei32_v_tuple_i32m1(base, bindex, vl);
+}
+
+// CHECK-RV64-LABEL: define dso_local { ,  } @test_vloxseg2ei32_v_tuple_i32m1_m
+// CHECK-RV64-SAME: ( [[MASK:%.*]], ptr noundef [[BASE:%.*]],  [[BINDEX:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] {
+// CHECK-RV64-NEXT:  entry:
+// CHECK-RV64-NEXT:[[TMP0:%.*]] = call { ,  } @llvm.riscv.vloxseg2.mask.nxv2i32.nxv2i32.i64( poison,  poison, ptr [[BASE]],  [[BINDEX]],  [[MASK]], i64 [[VL]], i64 3)
+// CHECK-RV64-NEXT:ret { ,  } [[TMP0]]
+//
+vint32m1x2_t test_vloxseg2ei32_v_tuple_i32m1_m(vbool32_t mask, const int32_t *base, vuint32m1_t bindex, size_t vl) {
+  return __riscv_vloxseg2ei32_v_tuple_i32m1_m(mask, base, bindex, vl);
+}
Index: clang/include/clang/Basic/riscv_vector.td
===
--- clang/include/clang/Basic/riscv_vector.td
+++ clang/include/clang/Basic/riscv_vector.td
@@ -1744,6 +1744,57 @@
   }
 }
 
+multiclass RVVIndexedSegLoadTuple {
+  foreach type = ["i"] in {
+foreach eew_info = [["32", "(Log2EEW:5)"]] in {
+  defvar eew = eew_info[0];
+  defvar eew_type = eew_info[1];
+  for

[PATCH] D147915: [9/11][POC][Clang][RISCV] Define tuple type variant of vsoxseg2ei32 vsuxseg2ei32

2023-05-22 Thread Yueh-Ting (eop) Chen via Phabricator via cfe-commits
This revision was landed with ongoing or failed builds.
This revision was automatically updated to reflect the committed changes.
Closed by commit rG5eb1b1fc1f88: [9/11][POC][Clang][RISCV] Define tuple type 
variant of vsoxseg2ei32 vsuxseg2ei32 (authored by eopXD).

Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D147915/new/

https://reviews.llvm.org/D147915

Files:
  clang/include/clang/Basic/riscv_vector.td
  
clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vsoxseg2ei32_tuple.c
  
clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vsuxseg2ei32_tuple.c

Index: clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vsuxseg2ei32_tuple.c
===
--- /dev/null
+++ clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vsuxseg2ei32_tuple.c
@@ -0,0 +1,36 @@
+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --version 2
+// REQUIRES: riscv-registered-target
+// RUN: %clang_cc1 -triple riscv64 -target-feature +v -target-feature +zfh \
+// RUN:   -target-feature +experimental-zvfh -disable-O0-optnone  \
+// RUN:   -emit-llvm %s -o - | opt -S -passes=mem2reg | \
+// RUN:   FileCheck --check-prefix=CHECK-RV64 %s
+
+#include 
+
+// CHECK-RV64-LABEL: define dso_local void @test_vsuxseg2ei32_v_tuple_i32m1
+// CHECK-RV64-SAME: (ptr noundef [[BASE:%.*]],  [[BINDEX:%.*]],  [[V_TUPLE_COERCE0:%.*]],  [[V_TUPLE_COERCE1:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0:[0-9]+]] {
+// CHECK-RV64-NEXT:  entry:
+// CHECK-RV64-NEXT:[[TMP0:%.*]] = insertvalue { ,  } poison,  [[V_TUPLE_COERCE0]], 0
+// CHECK-RV64-NEXT:[[TMP1:%.*]] = insertvalue { ,  } [[TMP0]],  [[V_TUPLE_COERCE1]], 1
+// CHECK-RV64-NEXT:[[TMP2:%.*]] = extractvalue { ,  } [[TMP1]], 0
+// CHECK-RV64-NEXT:[[TMP3:%.*]] = extractvalue { ,  } [[TMP1]], 1
+// CHECK-RV64-NEXT:call void @llvm.riscv.vsuxseg2.nxv2i32.nxv2i32.i64( [[TMP2]],  [[TMP3]], ptr [[BASE]],  [[BINDEX]], i64 [[VL]])
+// CHECK-RV64-NEXT:ret void
+//
+void test_vsuxseg2ei32_v_tuple_i32m1(int32_t *base, vuint32m1_t bindex, vint32m1x2_t v_tuple, size_t vl) {
+  return __riscv_vsuxseg2ei32_v_tuple_i32m1(base, bindex, v_tuple, vl);
+}
+
+// CHECK-RV64-LABEL: define dso_local void @test_vsuxseg2ei32_v_tuple_i32m1_m
+// CHECK-RV64-SAME: ( [[MASK:%.*]], ptr noundef [[BASE:%.*]],  [[BINDEX:%.*]],  [[V_TUPLE_COERCE0:%.*]],  [[V_TUPLE_COERCE1:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] {
+// CHECK-RV64-NEXT:  entry:
+// CHECK-RV64-NEXT:[[TMP0:%.*]] = insertvalue { ,  } poison,  [[V_TUPLE_COERCE0]], 0
+// CHECK-RV64-NEXT:[[TMP1:%.*]] = insertvalue { ,  } [[TMP0]],  [[V_TUPLE_COERCE1]], 1
+// CHECK-RV64-NEXT:[[TMP2:%.*]] = extractvalue { ,  } [[TMP1]], 0
+// CHECK-RV64-NEXT:[[TMP3:%.*]] = extractvalue { ,  } [[TMP1]], 1
+// CHECK-RV64-NEXT:call void @llvm.riscv.vsuxseg2.mask.nxv2i32.nxv2i32.i64( [[TMP2]],  [[TMP3]], ptr [[BASE]],  [[BINDEX]],  [[MASK]], i64 [[VL]])
+// CHECK-RV64-NEXT:ret void
+//
+void test_vsuxseg2ei32_v_tuple_i32m1_m(vbool32_t mask, int32_t *base, vuint32m1_t bindex, vint32m1x2_t v_tuple, size_t vl) {
+  return __riscv_vsuxseg2ei32_v_tuple_i32m1_m(mask, base, bindex, v_tuple, vl);
+}
Index: clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vsoxseg2ei32_tuple.c
===
--- /dev/null
+++ clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vsoxseg2ei32_tuple.c
@@ -0,0 +1,36 @@
+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --version 2
+// REQUIRES: riscv-registered-target
+// RUN: %clang_cc1 -triple riscv64 -target-feature +v -target-feature +zfh \
+// RUN:   -target-feature +experimental-zvfh -disable-O0-optnone  \
+// RUN:   -emit-llvm %s -o - | opt -S -passes=mem2reg | \
+// RUN:   FileCheck --check-prefix=CHECK-RV64 %s
+
+#include 
+
+// CHECK-RV64-LABEL: define dso_local void @test_vsoxseg2ei32_v_tuple_i32m1
+// CHECK-RV64-SAME: (ptr noundef [[BASE:%.*]],  [[BINDEX:%.*]],  [[V_TUPLE_COERCE0:%.*]],  [[V_TUPLE_COERCE1:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0:[0-9]+]] {
+// CHECK-RV64-NEXT:  entry:
+// CHECK-RV64-NEXT:[[TMP0:%.*]] = insertvalue { ,  } poison,  [[V_TUPLE_COERCE0]], 0
+// CHECK-RV64-NEXT:[[TMP1:%.*]] = insertvalue { ,  } [[TMP0]],  [[V_TUPLE_COERCE1]], 1
+// CHECK-RV64-NEXT:[[TMP2:%.*]] = extractvalue { ,  } [[TMP1]], 0
+// CHECK-RV64-NEXT:[[TMP3:%.*]] = extractvalue { ,  } [[TMP1]], 1
+// CHECK-RV64-NEXT:call void @llvm.riscv.vsoxseg2.nxv2i32.nxv2i32.i64( [[TMP2]],  [[TMP3]], ptr [[BASE]],  [[BINDEX]], i64 [[VL]])
+// CHECK-RV64-NEXT:ret void
+//
+void test_vsoxseg2ei32_v_tuple_i32m1(int32_t *base, vuint32m1_t bindex, vint32m1x2_t v_tuple, size_t vl) {
+  return __riscv_vsoxseg2ei32_v_tuple_i32m1(base, bindex, v_tuple

[PATCH] D150446: [analyzer] Check ArraySubscriptExprs in ArrayBoundCheckerV2

2023-05-22 Thread Donát Nagy via Phabricator via cfe-commits
donat.nagy added a comment.

@steakhal What is your first impression about this commit? Is this the (or at 
least //a//) good direction? May I continue with creating additional 
improvements (e.g. better error messages) that depend on this commit?


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D150446/new/

https://reviews.llvm.org/D150446

___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[clang] 6a097e2 - [10/11][POC][Clang][RISCV] Define vget for tuple type

2023-05-22 Thread via cfe-commits

Author: eopXD
Date: 2023-05-22T04:29:28-07:00
New Revision: 6a097e279c7831d12e9ed56ca5cc021e68315c12

URL: 
https://github.com/llvm/llvm-project/commit/6a097e279c7831d12e9ed56ca5cc021e68315c12
DIFF: 
https://github.com/llvm/llvm-project/commit/6a097e279c7831d12e9ed56ca5cc021e68315c12.diff

LOG: [10/11][POC][Clang][RISCV] Define vget for tuple type

For the cover letter of this patch-set, please checkout D146872.

Depends on D147915.

This is the 10th patch of the patch-set.

This patch is a proof-of-concept and will be extended to full coverage
in the future. Only vget for tuple type of NF=2, EEW=32, LMUL=1 is
defined now.

Reviewed By: craig.topper

Differential Revision: https://reviews.llvm.org/D147916

Added: 

clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vget_tuple.c

Modified: 
clang/include/clang/Basic/riscv_vector.td
clang/lib/Sema/SemaChecking.cpp
clang/lib/Support/RISCVVIntrinsicUtils.cpp

clang/test/CodeGen/RISCV/rvv-intrinsics-handcrafted/vget-index-out-of-range.c

Removed: 




diff  --git a/clang/include/clang/Basic/riscv_vector.td 
b/clang/include/clang/Basic/riscv_vector.td
index c7e6a1b76dab9..3b070109b2e3d 100644
--- a/clang/include/clang/Basic/riscv_vector.td
+++ b/clang/include/clang/Basic/riscv_vector.td
@@ -2536,6 +2536,11 @@ let HasMasked = false, HasVL = false, IRName = "" in {
   let Name = "vget_v", MaskedPolicyScheme = NonePolicy,
   ManualCodegen = [{
   {
+if (isa(Ops[0]->getType())) // For tuple type
+  // Extract value from index (operand 1) of vtuple (operand 0)
+  return Builder.CreateExtractValue(
+Ops[0],
+{(unsigned)cast(Ops[1])->getZExtValue()});
 auto *VecTy = cast(ResultType);
 auto *OpVecTy = cast(Ops[0]->getType());
 // Mask to only valid indices.
@@ -2553,6 +2558,12 @@ let HasMasked = false, HasVL = false, IRName = "" in {
   def : RVVBuiltin<"v" # dst_lmul # "v", dst_lmul # "vvKz", "csilxfd", 
dst_lmul # "v">;
   def : RVVBuiltin<"Uv" # dst_lmul # "Uv", dst_lmul # "UvUvKz", "csil", 
dst_lmul # "Uv">;
 }
+foreach nf = [2] in {
+  let Log2LMUL = [0] in {
+defvar T = "(Tuple:" # nf # ")";
+def : RVVBuiltin;
+  }
+}
   }
 
   let Name = "vset_v", Log2LMUL = [0, 1, 2], MaskedPolicyScheme = NonePolicy,

diff  --git a/clang/lib/Sema/SemaChecking.cpp b/clang/lib/Sema/SemaChecking.cpp
index 06739beba4f91..7aceade260ad3 100644
--- a/clang/lib/Sema/SemaChecking.cpp
+++ b/clang/lib/Sema/SemaChecking.cpp
@@ -4522,9 +4522,12 @@ bool Sema::CheckRISCVBuiltinFunctionCall(const 
TargetInfo &TI,
 ASTContext::BuiltinVectorTypeInfo VecInfo =
 Context.getBuiltinVectorTypeInfo(cast(
 TheCall->getArg(0)->getType().getCanonicalType().getTypePtr()));
-unsigned MaxIndex =
-(VecInfo.EC.getKnownMinValue() * VecInfo.NumVectors) /
-(ResVecInfo.EC.getKnownMinValue() * ResVecInfo.NumVectors);
+unsigned MaxIndex;
+if (VecInfo.NumVectors != 1) // vget for tuple type
+  MaxIndex = VecInfo.NumVectors;
+else // vget for non-tuple type
+  MaxIndex = (VecInfo.EC.getKnownMinValue() * VecInfo.NumVectors) /
+ (ResVecInfo.EC.getKnownMinValue() * ResVecInfo.NumVectors);
 return SemaBuiltinConstantArgRange(TheCall, 1, 0, MaxIndex - 1);
   }
   case RISCVVector::BI__builtin_rvv_vset_v: {

diff  --git a/clang/lib/Support/RISCVVIntrinsicUtils.cpp 
b/clang/lib/Support/RISCVVIntrinsicUtils.cpp
index 353e0cb4422f2..74849d8137484 100644
--- a/clang/lib/Support/RISCVVIntrinsicUtils.cpp
+++ b/clang/lib/Support/RISCVVIntrinsicUtils.cpp
@@ -332,6 +332,8 @@ void RVVType::initShortStr() {
   }
   if (isVector())
 ShortStr += LMUL.str();
+  if (isTuple())
+ShortStr += "x" + utostr(NF);
 }
 
 void RVVType::applyBasicType() {

diff  --git 
a/clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vget_tuple.c
 
b/clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vget_tuple.c
new file mode 100644
index 0..48a797ad3ab70
--- /dev/null
+++ 
b/clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vget_tuple.c
@@ -0,0 +1,20 @@
+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py 
UTC_ARGS: --version 2
+// REQUIRES: riscv-registered-target
+// RUN: %clang_cc1 -triple riscv64 -target-feature +v -target-feature +zfh \
+// RUN:   -target-feature +experimental-zvfh -disable-O0-optnone  \
+// RUN:   -emit-llvm %s -o - | opt -S -passes=mem2reg | \
+// RUN:   FileCheck --check-prefix=CHECK-RV64 %s
+
+#include 
+
+// CHECK-RV64-LABEL: define dso_local  
@test_vget_v_i32m1x2_i32m1
+// CHECK-RV64-SAME: ( [[SRC_COERCE0:%.*]],  [[SRC_COERCE1:%.*]]) #[[ATTR0:[0-9]+]] {
+// CHECK-RV64-NEXT:  entry:
+// CHECK-RV64-NEXT:[[TMP0:%.*]] = insertvalue { , 
 } poison,  [[SRC_COERCE0]]

[PATCH] D147916: [10/11][POC][Clang][RISCV] Define vget for tuple type

2023-05-22 Thread Yueh-Ting (eop) Chen via Phabricator via cfe-commits
This revision was landed with ongoing or failed builds.
This revision was automatically updated to reflect the committed changes.
Closed by commit rG6a097e279c78: [10/11][POC][Clang][RISCV] Define vget for 
tuple type (authored by eopXD).

Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D147916/new/

https://reviews.llvm.org/D147916

Files:
  clang/include/clang/Basic/riscv_vector.td
  clang/lib/Sema/SemaChecking.cpp
  clang/lib/Support/RISCVVIntrinsicUtils.cpp
  
clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vget_tuple.c
  clang/test/CodeGen/RISCV/rvv-intrinsics-handcrafted/vget-index-out-of-range.c


Index: 
clang/test/CodeGen/RISCV/rvv-intrinsics-handcrafted/vget-index-out-of-range.c
===
--- 
clang/test/CodeGen/RISCV/rvv-intrinsics-handcrafted/vget-index-out-of-range.c
+++ 
clang/test/CodeGen/RISCV/rvv-intrinsics-handcrafted/vget-index-out-of-range.c
@@ -339,3 +339,8 @@
   // expected-error@+1 {{argument value 2 is outside the valid range [0, 1]}}
   return __riscv_vget_v_f16m8_f16m4(src, 2);
 }
+
+vint32m1_t test_vget_v_i32m1x2_i32m1(vint32m1x2_t src) {
+  // expected-error@+1 {{argument value 2 is outside the valid range [0, 1]}}
+  return __riscv_vget_v_i32m1x2_i32m1(src, 2);
+}
Index: 
clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vget_tuple.c
===
--- /dev/null
+++ 
clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vget_tuple.c
@@ -0,0 +1,20 @@
+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py 
UTC_ARGS: --version 2
+// REQUIRES: riscv-registered-target
+// RUN: %clang_cc1 -triple riscv64 -target-feature +v -target-feature +zfh \
+// RUN:   -target-feature +experimental-zvfh -disable-O0-optnone  \
+// RUN:   -emit-llvm %s -o - | opt -S -passes=mem2reg | \
+// RUN:   FileCheck --check-prefix=CHECK-RV64 %s
+
+#include 
+
+// CHECK-RV64-LABEL: define dso_local  
@test_vget_v_i32m1x2_i32m1
+// CHECK-RV64-SAME: ( [[SRC_COERCE0:%.*]],  [[SRC_COERCE1:%.*]]) #[[ATTR0:[0-9]+]] {
+// CHECK-RV64-NEXT:  entry:
+// CHECK-RV64-NEXT:[[TMP0:%.*]] = insertvalue { , 
 } poison,  [[SRC_COERCE0]], 0
+// CHECK-RV64-NEXT:[[TMP1:%.*]] = insertvalue { , 
 } [[TMP0]],  [[SRC_COERCE1]], 1
+// CHECK-RV64-NEXT:[[TMP2:%.*]] = extractvalue { , 
 } [[TMP1]], 0
+// CHECK-RV64-NEXT:ret  [[TMP2]]
+//
+vint32m1_t test_vget_v_i32m1x2_i32m1(vint32m1x2_t src) {
+  return __riscv_vget_v_i32m1x2_i32m1(src, 0);
+}
Index: clang/lib/Support/RISCVVIntrinsicUtils.cpp
===
--- clang/lib/Support/RISCVVIntrinsicUtils.cpp
+++ clang/lib/Support/RISCVVIntrinsicUtils.cpp
@@ -332,6 +332,8 @@
   }
   if (isVector())
 ShortStr += LMUL.str();
+  if (isTuple())
+ShortStr += "x" + utostr(NF);
 }
 
 void RVVType::applyBasicType() {
Index: clang/lib/Sema/SemaChecking.cpp
===
--- clang/lib/Sema/SemaChecking.cpp
+++ clang/lib/Sema/SemaChecking.cpp
@@ -4522,9 +4522,12 @@
 ASTContext::BuiltinVectorTypeInfo VecInfo =
 Context.getBuiltinVectorTypeInfo(cast(
 TheCall->getArg(0)->getType().getCanonicalType().getTypePtr()));
-unsigned MaxIndex =
-(VecInfo.EC.getKnownMinValue() * VecInfo.NumVectors) /
-(ResVecInfo.EC.getKnownMinValue() * ResVecInfo.NumVectors);
+unsigned MaxIndex;
+if (VecInfo.NumVectors != 1) // vget for tuple type
+  MaxIndex = VecInfo.NumVectors;
+else // vget for non-tuple type
+  MaxIndex = (VecInfo.EC.getKnownMinValue() * VecInfo.NumVectors) /
+ (ResVecInfo.EC.getKnownMinValue() * ResVecInfo.NumVectors);
 return SemaBuiltinConstantArgRange(TheCall, 1, 0, MaxIndex - 1);
   }
   case RISCVVector::BI__builtin_rvv_vset_v: {
Index: clang/include/clang/Basic/riscv_vector.td
===
--- clang/include/clang/Basic/riscv_vector.td
+++ clang/include/clang/Basic/riscv_vector.td
@@ -2536,6 +2536,11 @@
   let Name = "vget_v", MaskedPolicyScheme = NonePolicy,
   ManualCodegen = [{
   {
+if (isa(Ops[0]->getType())) // For tuple type
+  // Extract value from index (operand 1) of vtuple (operand 0)
+  return Builder.CreateExtractValue(
+Ops[0],
+{(unsigned)cast(Ops[1])->getZExtValue()});
 auto *VecTy = cast(ResultType);
 auto *OpVecTy = cast(Ops[0]->getType());
 // Mask to only valid indices.
@@ -2553,6 +2558,12 @@
   def : RVVBuiltin<"v" # dst_lmul # "v", dst_lmul # "vvKz", "csilxfd", 
dst_lmul # "v">;
   def : RVVBuiltin<"Uv" # dst_lmul # "Uv", dst_lmul # "UvUvKz", "csil", 
dst_lmul # "Uv">;
 }
+foreach nf = [2] in {
+  let Log2LMUL = [0] in {
+defvar T = "(Tuple:" # nf # 

[PATCH] D150435: [clang] Fix crash on attempt to initialize union with flexible array member

2023-05-22 Thread Mariya Podchishchaeva via Phabricator via cfe-commits
Fznamznon added a comment.

@aaron.ballman , WDYT?


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D150435/new/

https://reviews.llvm.org/D150435

___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[clang] 61346ed - [11/11][POC][Clang][RISCV] Define vset for tuple type

2023-05-22 Thread via cfe-commits

Author: eopXD
Date: 2023-05-22T04:32:43-07:00
New Revision: 61346ed51fdab0314694f3dbbf6563bc2cc9cde2

URL: 
https://github.com/llvm/llvm-project/commit/61346ed51fdab0314694f3dbbf6563bc2cc9cde2
DIFF: 
https://github.com/llvm/llvm-project/commit/61346ed51fdab0314694f3dbbf6563bc2cc9cde2.diff

LOG: [11/11][POC][Clang][RISCV] Define vset for tuple type

For the cover letter of this patch-set, please checkout D146872.

Depends on D147916.

This is the 11th patch of the patch-set.

This patch is a proof-of-concept and will be extended to full coverage
in the future. Only vset for tuple type of NF=2, EEW=32, LMUL=1 is
defined now.

Reviewed By: craig.topper

Differential Revision: https://reviews.llvm.org/D147917

Added: 

clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vset_tuple.c

Modified: 
clang/include/clang/Basic/riscv_vector.td
clang/lib/Sema/SemaChecking.cpp

clang/test/CodeGen/RISCV/rvv-intrinsics-handcrafted/vset-index-out-of-range.c

Removed: 




diff  --git a/clang/include/clang/Basic/riscv_vector.td 
b/clang/include/clang/Basic/riscv_vector.td
index 3b070109b2e3d..4d48c38adb578 100644
--- a/clang/include/clang/Basic/riscv_vector.td
+++ b/clang/include/clang/Basic/riscv_vector.td
@@ -2569,6 +2569,11 @@ let HasMasked = false, HasVL = false, IRName = "" in {
   let Name = "vset_v", Log2LMUL = [0, 1, 2], MaskedPolicyScheme = NonePolicy,
   ManualCodegen = [{
   {
+if (isa(ResultType)) // For tuple type
+  // Insert value (operand 2) into index (operand 1) of vtuple 
(operand 0)
+  return Builder.CreateInsertValue(
+Ops[0], Ops[2],
+{(unsigned)cast(Ops[1])->getZExtValue()});
 auto *ResVecTy = cast(ResultType);
 auto *VecTy = cast(Ops[2]->getType());
 // Mask to only valid indices.
@@ -2586,5 +2591,11 @@ let HasMasked = false, HasVL = false, IRName = "" in {
   def : RVVBuiltin<"v" # dst_lmul # "v", dst_lmul # "v" # dst_lmul # 
"vKzv", "csilxfd">;
   def : RVVBuiltin<"Uv" # dst_lmul # "Uv", dst_lmul # "Uv" # dst_lmul 
#"UvKzUv", "csil">;
 }
+foreach nf = [2] in {
+  let Log2LMUL = [0] in {
+defvar T = "(Tuple:" # nf # ")";
+def : RVVBuiltin;
+  }
+}
   }
 }

diff  --git a/clang/lib/Sema/SemaChecking.cpp b/clang/lib/Sema/SemaChecking.cpp
index 7aceade260ad3..6c2cbc60a81d2 100644
--- a/clang/lib/Sema/SemaChecking.cpp
+++ b/clang/lib/Sema/SemaChecking.cpp
@@ -4537,9 +4537,12 @@ bool Sema::CheckRISCVBuiltinFunctionCall(const 
TargetInfo &TI,
 ASTContext::BuiltinVectorTypeInfo VecInfo =
 Context.getBuiltinVectorTypeInfo(cast(
 TheCall->getArg(2)->getType().getCanonicalType().getTypePtr()));
-unsigned MaxIndex =
-(ResVecInfo.EC.getKnownMinValue() * ResVecInfo.NumVectors) /
-(VecInfo.EC.getKnownMinValue() * VecInfo.NumVectors);
+unsigned MaxIndex;
+if (ResVecInfo.NumVectors != 1) // vset for tuple type
+  MaxIndex = ResVecInfo.NumVectors;
+else // vset fo non-tuple type
+  MaxIndex = (ResVecInfo.EC.getKnownMinValue() * ResVecInfo.NumVectors) /
+ (VecInfo.EC.getKnownMinValue() * VecInfo.NumVectors);
 return SemaBuiltinConstantArgRange(TheCall, 1, 0, MaxIndex - 1);
   }
   case RISCVVector::BI__builtin_rvv_sf_vc_i_se_u8mf8:

diff  --git 
a/clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vset_tuple.c
 
b/clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vset_tuple.c
new file mode 100644
index 0..70bd7acfdd1e0
--- /dev/null
+++ 
b/clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vset_tuple.c
@@ -0,0 +1,20 @@
+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py 
UTC_ARGS: --version 2
+// REQUIRES: riscv-registered-target
+// RUN: %clang_cc1 -triple riscv64 -target-feature +v -target-feature +zfh \
+// RUN:   -target-feature +experimental-zvfh -disable-O0-optnone  \
+// RUN:   -emit-llvm %s -o - | opt -S -passes=mem2reg | \
+// RUN:   FileCheck --check-prefix=CHECK-RV64 %s
+
+#include 
+
+// CHECK-RV64-LABEL: define dso_local { ,  
} @test_vset_v_i32m1x2_i32m1
+// CHECK-RV64-SAME: ( [[DEST_COERCE0:%.*]],  [[DEST_COERCE1:%.*]],  [[VAL:%.*]]) #[[ATTR0:[0-9]+]] {
+// CHECK-RV64-NEXT:  entry:
+// CHECK-RV64-NEXT:[[TMP0:%.*]] = insertvalue { , 
 } poison,  [[DEST_COERCE0]], 0
+// CHECK-RV64-NEXT:[[TMP1:%.*]] = insertvalue { , 
 } [[TMP0]],  [[DEST_COERCE1]], 1
+// CHECK-RV64-NEXT:[[TMP2:%.*]] = insertvalue { , 
 } [[TMP1]],  [[VAL]], 0
+// CHECK-RV64-NEXT:ret { ,  } [[TMP2]]
+//
+vint32m1x2_t test_vset_v_i32m1x2_i32m1(vint32m1x2_t dest, vint32m1_t val) {
+  return __riscv_vset_v_i32m1x2_i32m1(dest, 0, val);
+}

diff  --git 
a/clang/test/CodeGen/RISCV/rvv-intrinsics-handcrafted/vset-index-out-of-range.c 
b/clang/test/CodeGen/RISCV/rvv-intrinsics

[PATCH] D58346: [Sema] Change addr space diagnostics in casts to follow C++ style

2023-05-22 Thread Joseph Huber via Phabricator via cfe-commits
jhuber6 added a comment.

In D58346#4359631 , @ebevhan wrote:

> In D58346#4359291 , @jhuber6 wrote:
>
>> should C++ really be limited by OpenCL here?
>
> It probably shouldn't. There's many places in the codebase where OpenCL flags 
> restrict generic address space behavior. I have a patch at D62574 
>  that attempts to formalize the address 
> space rules a bit more (which I think also gets rid of the OpenCL 
> restrictions you mention) but there's never been any huge interest and I 
> don't have the time to push for it.
>
> Whether that patch actually solves your problem or not, I don't know.

A quick scan on where the error gets printed suggests not, since we'd also like 
the ability to add an address space. My suggestion is to allow 
`reinterpret_cast` to remove and and add address spaces for C++, OpenCL will 
remain the same.


Repository:
  rL LLVM

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D58346/new/

https://reviews.llvm.org/D58346

___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D147917: [11/11][POC][Clang][RISCV] Define vset for tuple type

2023-05-22 Thread Yueh-Ting (eop) Chen via Phabricator via cfe-commits
This revision was landed with ongoing or failed builds.
This revision was automatically updated to reflect the committed changes.
Closed by commit rG61346ed51fda: [11/11][POC][Clang][RISCV] Define vset for 
tuple type (authored by eopXD).

Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D147917/new/

https://reviews.llvm.org/D147917

Files:
  clang/include/clang/Basic/riscv_vector.td
  clang/lib/Sema/SemaChecking.cpp
  
clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vset_tuple.c
  clang/test/CodeGen/RISCV/rvv-intrinsics-handcrafted/vset-index-out-of-range.c


Index: 
clang/test/CodeGen/RISCV/rvv-intrinsics-handcrafted/vset-index-out-of-range.c
===
--- 
clang/test/CodeGen/RISCV/rvv-intrinsics-handcrafted/vset-index-out-of-range.c
+++ 
clang/test/CodeGen/RISCV/rvv-intrinsics-handcrafted/vset-index-out-of-range.c
@@ -339,3 +339,8 @@
   // expected-error@+1 {{argument value 2 is outside the valid range [0, 1]}}
   return __riscv_vset_v_f16m4_f16m8(dest, 2, val);
 }
+
+vint32m1x2_t test_vset_v_i32m1x2_i32m1(vint32m1x2_t dest, vint32m1_t val) {
+  // expected-error@+1 {{argument value 2 is outside the valid range [0, 1]}}
+  return __riscv_vset_v_i32m1x2_i32m1(dest, 2, val);
+}
Index: 
clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vset_tuple.c
===
--- /dev/null
+++ 
clang/test/CodeGen/RISCV/rvv-intrinsics-autogenerated/non-policy/non-overloaded/vset_tuple.c
@@ -0,0 +1,20 @@
+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py 
UTC_ARGS: --version 2
+// REQUIRES: riscv-registered-target
+// RUN: %clang_cc1 -triple riscv64 -target-feature +v -target-feature +zfh \
+// RUN:   -target-feature +experimental-zvfh -disable-O0-optnone  \
+// RUN:   -emit-llvm %s -o - | opt -S -passes=mem2reg | \
+// RUN:   FileCheck --check-prefix=CHECK-RV64 %s
+
+#include 
+
+// CHECK-RV64-LABEL: define dso_local { ,  
} @test_vset_v_i32m1x2_i32m1
+// CHECK-RV64-SAME: ( [[DEST_COERCE0:%.*]],  [[DEST_COERCE1:%.*]],  [[VAL:%.*]]) #[[ATTR0:[0-9]+]] {
+// CHECK-RV64-NEXT:  entry:
+// CHECK-RV64-NEXT:[[TMP0:%.*]] = insertvalue { , 
 } poison,  [[DEST_COERCE0]], 0
+// CHECK-RV64-NEXT:[[TMP1:%.*]] = insertvalue { , 
 } [[TMP0]],  [[DEST_COERCE1]], 1
+// CHECK-RV64-NEXT:[[TMP2:%.*]] = insertvalue { , 
 } [[TMP1]],  [[VAL]], 0
+// CHECK-RV64-NEXT:ret { ,  } [[TMP2]]
+//
+vint32m1x2_t test_vset_v_i32m1x2_i32m1(vint32m1x2_t dest, vint32m1_t val) {
+  return __riscv_vset_v_i32m1x2_i32m1(dest, 0, val);
+}
Index: clang/lib/Sema/SemaChecking.cpp
===
--- clang/lib/Sema/SemaChecking.cpp
+++ clang/lib/Sema/SemaChecking.cpp
@@ -4537,9 +4537,12 @@
 ASTContext::BuiltinVectorTypeInfo VecInfo =
 Context.getBuiltinVectorTypeInfo(cast(
 TheCall->getArg(2)->getType().getCanonicalType().getTypePtr()));
-unsigned MaxIndex =
-(ResVecInfo.EC.getKnownMinValue() * ResVecInfo.NumVectors) /
-(VecInfo.EC.getKnownMinValue() * VecInfo.NumVectors);
+unsigned MaxIndex;
+if (ResVecInfo.NumVectors != 1) // vset for tuple type
+  MaxIndex = ResVecInfo.NumVectors;
+else // vset fo non-tuple type
+  MaxIndex = (ResVecInfo.EC.getKnownMinValue() * ResVecInfo.NumVectors) /
+ (VecInfo.EC.getKnownMinValue() * VecInfo.NumVectors);
 return SemaBuiltinConstantArgRange(TheCall, 1, 0, MaxIndex - 1);
   }
   case RISCVVector::BI__builtin_rvv_sf_vc_i_se_u8mf8:
Index: clang/include/clang/Basic/riscv_vector.td
===
--- clang/include/clang/Basic/riscv_vector.td
+++ clang/include/clang/Basic/riscv_vector.td
@@ -2569,6 +2569,11 @@
   let Name = "vset_v", Log2LMUL = [0, 1, 2], MaskedPolicyScheme = NonePolicy,
   ManualCodegen = [{
   {
+if (isa(ResultType)) // For tuple type
+  // Insert value (operand 2) into index (operand 1) of vtuple 
(operand 0)
+  return Builder.CreateInsertValue(
+Ops[0], Ops[2],
+{(unsigned)cast(Ops[1])->getZExtValue()});
 auto *ResVecTy = cast(ResultType);
 auto *VecTy = cast(Ops[2]->getType());
 // Mask to only valid indices.
@@ -2586,5 +2591,11 @@
   def : RVVBuiltin<"v" # dst_lmul # "v", dst_lmul # "v" # dst_lmul # 
"vKzv", "csilxfd">;
   def : RVVBuiltin<"Uv" # dst_lmul # "Uv", dst_lmul # "Uv" # dst_lmul 
#"UvKzUv", "csil">;
 }
+foreach nf = [2] in {
+  let Log2LMUL = [0] in {
+defvar T = "(Tuple:" # nf # ")";
+def : RVVBuiltin;
+  }
+}
   }
 }


Index: clang/test/CodeGen/RISCV/rvv-intrinsics-handcrafted/vset-index-out-of-range.c
===
--- clang/test/CodeGen/RISCV/rvv-intrinsics-handcrafted/vset-index-

[PATCH] D144509: [CMake] Bumps minimum version to 3.20.0.

2023-05-22 Thread Hans Wennborg via Phabricator via cfe-commits
hans added a comment.

>>> Do you have a suggestion how we can move this patch forward?
>>
>> IIRC, D150688  + the diff in 
>> https://github.com/llvm/llvm-project/issues/62719#issuecomment-1552903385 + 
>> upgrading the pre-merge linux bot should take care of all known issues.
>
> Would it make sense to put all these patches in one new review and then test 
> that on Chromium and ask @glandium to test that too. Then we know whether it 
> solves the issues. Do you want me to make a patch or do you want to do it?

I tested 
https://github.com/llvm/llvm-project/issues/62719#issuecomment-1552903385 on 
Chromium already, and that looks good.


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D144509/new/

https://reviews.llvm.org/D144509

___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D150997: [llvm] Split out DenseMapInfo specialization

2023-05-22 Thread Kadir Cetinkaya via Phabricator via cfe-commits
kadircet added a comment.

In D150997#4357589 , @nikic wrote:

> It looks like you forgot to `git add` the new file maybe?
>
> This was added in https://reviews.llvm.org/D133200, maybe @kadircet can 
> comment on what this was intended for.

It was already pointed out by you :) this is used by 
clang-tools-extra/include-cleaner/include/clang-include-cleaner/Types.h, and 
your changes there LG.
You should also update `llvm/unittests/ADT/DenseMapTest.cpp`, you can see build 
breakage information at the top (search for `pre-merge checks`).

Also, thanks for pointing out the discrepancy in implementation of `isEqual`. 
Sent out https://reviews.llvm.org/D151079. Happy to land it before or after 
your change.


CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D150997/new/

https://reviews.llvm.org/D150997

___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D150997: [llvm] Split out DenseMapInfo specialization

2023-05-22 Thread Kadir Cetinkaya via Phabricator via cfe-commits
kadircet added a comment.

In D150997#4357589 , @nikic wrote:

> It looks like you forgot to `git add` the new file maybe?
>
> This was added in https://reviews.llvm.org/D133200, maybe @kadircet can 
> comment on what this was intended for.

It was already pointed out by you :) this is used by 
clang-tools-extra/include-cleaner/include/clang-include-cleaner/Types.h, and 
your changes there LG.
You should also update `llvm/unittests/ADT/DenseMapTest.cpp`, you can see build 
breakage information at the top (search for `pre-merge checks`).

Also, thanks for pointing out the discrepancy in implementation of `isEqual`. 
Sent out https://reviews.llvm.org/D151079. Happy to land it before or after 
your change.


CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D150997/new/

https://reviews.llvm.org/D150997

___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D151078: [clang][Diagnostics] Use llvm::raw_ostream::indent()

2023-05-22 Thread Aaron Ballman via Phabricator via cfe-commits
aaron.ballman added inline comments.



Comment at: clang/lib/Frontend/TextDiagnostic.cpp:1195-1197
   auto indentForLineNumbers = [&] {
-if (MaxLineNoDisplayWidth > 0) {
-  OS << ' ';
-  for (unsigned I = 0; I != MaxLineNoDisplayWidth; ++I)
-OS << ' ';
-  OS << " | ";
-}
+if (MaxLineNoDisplayWidth > 0)
+  OS.indent(MaxLineNoDisplayWidth + 4);

This drops the output of `|` -- is that intentional?


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D151078/new/

https://reviews.llvm.org/D151078

___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D151078: [clang][Diagnostics] Use llvm::raw_ostream::indent()

2023-05-22 Thread Timm Bäder via Phabricator via cfe-commits
tbaeder added inline comments.



Comment at: clang/lib/Frontend/TextDiagnostic.cpp:1195-1197
   auto indentForLineNumbers = [&] {
-if (MaxLineNoDisplayWidth > 0) {
-  OS << ' ';
-  for (unsigned I = 0; I != MaxLineNoDisplayWidth; ++I)
-OS << ' ';
-  OS << " | ";
-}
+if (MaxLineNoDisplayWidth > 0)
+  OS.indent(MaxLineNoDisplayWidth + 4);

aaron.ballman wrote:
> This drops the output of `|` -- is that intentional?
No! Looks like I got a bit too excited about removing code.


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D151078/new/

https://reviews.llvm.org/D151078

___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D150840: [clang][NFC] Refactor emitSnippet()

2023-05-22 Thread Aaron Ballman via Phabricator via cfe-commits
aaron.ballman accepted this revision.
aaron.ballman added a comment.
This revision is now accepted and ready to land.

In D150840#4359570 , @tbaeder wrote:

> Side-note: The `ToPrint` stuff here is just useful to "cache" the output 
> string, isn't it? Is that really useful? I'd expect the output stream to be 
> cached anyway?

Yeah, that does seem like a kind of caching operation, I'm not certain what 
it's purpose is though.

LGTM!


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D150840/new/

https://reviews.llvm.org/D150840

___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D151071: [clang][dataflow] Fix a null pointer crash in `computeBlockInputState()`.

2023-05-22 Thread Yitzhak Mandelbaum via Phabricator via cfe-commits
ymandel accepted this revision.
ymandel added inline comments.
This revision is now accepted and ready to land.



Comment at: 
clang/lib/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.cpp:221-223
 // See `NoreturnDestructorTest` for concrete examples.
-if (Block.succ_begin()->getReachableBlock()->hasNoReturnElement()) {
+if (Block.succ_begin()->getReachableBlock() != nullptr &&
+Block.succ_begin()->getReachableBlock()->hasNoReturnElement()) {

Nit.


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D151071/new/

https://reviews.llvm.org/D151071

___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D151073: [clang] Fix label (de-)serialization in ASM statements.

2023-05-22 Thread Kadir Cetinkaya via Phabricator via cfe-commits
kadircet added inline comments.



Comment at: clang/test/PCH/asm-label.cpp:5
+#define HEADER_H
+#pragma once
+void MyMethod() {

you can drop `#pragma once` know, as it won't be parsed again anyways



Comment at: clang/test/PCH/asm-label.cpp:6
+#pragma once
+void MyMethod() {
+  void *bar;

let's still make sure this crashes with current version (I know i said we can 
simplify it, but it looks like we don't have any assertions, and moreover it's 
really hard to have any without significantly changing interfaces). So let's 
keep the template and at least 5 different operand names:

```
template  void foo() {
label:
  void *bar;
  asm goto(""
   :
   : [op1] "r"(bar), [op2] "r"(bar), [op3] "r"(bar), [op4] "r"(bar)
   :
   : label);
}
```


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D151073/new/

https://reviews.llvm.org/D151073

___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[clang] 09841d7 - Add WG14 N2607 to the list of backported features

2023-05-22 Thread Aaron Ballman via cfe-commits

Author: Aaron Ballman
Date: 2023-05-22T08:16:32-04:00
New Revision: 09841d792f47310cf582156b92ffd9fa232853d6

URL: 
https://github.com/llvm/llvm-project/commit/09841d792f47310cf582156b92ffd9fa232853d6
DIFF: 
https://github.com/llvm/llvm-project/commit/09841d792f47310cf582156b92ffd9fa232853d6.diff

LOG: Add WG14 N2607 to the list of backported features

Arrays and their element types are identically qualified as of C2x,
and we support that behavior as far back as C89.

As a drive-by, this adds the paper number for designated initializers
so that all the WG14 features can be uniquely identified despite the
lack of a feature testing macro.

Added: 


Modified: 
clang/docs/LanguageExtensions.rst

Removed: 




diff  --git a/clang/docs/LanguageExtensions.rst 
b/clang/docs/LanguageExtensions.rst
index 5b186c4f81774..d881568b13994 100644
--- a/clang/docs/LanguageExtensions.rst
+++ b/clang/docs/LanguageExtensions.rst
@@ -1373,37 +1373,38 @@ More information could be found `here 

 Language Extensions Back-ported to Previous Standards
 =
 
-===  
= = ==
-Feature Feature Test Macro   
Introduced In Backported To Required Flags
-===  
= = ==
-variadic templates  __cpp_variadic_templates C++11 
C++03
-Alias templates __cpp_alias_templatesC++11 
C++03
-Non-static data member initializers __cpp_nsdmi  C++11 
C++03
-Range-based ``for`` loop__cpp_range_based_forC++11 
C++03
-RValue references   __cpp_rvalue_references  C++11 
C++03
-Attributes  __cpp_attributes C++11 
C++03 -fdouble-square-bracket-attributes
-variable templates  __cpp_variable_templates C++14 
C++03
-Binary literals __cpp_binary_literalsC++14 
C++03
-Relaxed constexpr   __cpp_constexpr  C++14 
C++11
-``if constexpr``__cpp_if_constexpr   C++17 
C++11
-fold expressions__cpp_fold_expressions   C++17 
C++03
-Lambda capture of \*this by value   __cpp_capture_star_this  C++17 
C++11
-Attributes on enums __cpp_enumerator_attributes  C++17 
C++11
-Guaranteed copy elision __cpp_guaranteed_copy_elisionC++17 
C++03
-Hexadecimal floating literals   __cpp_hex_float  C++17 
C++03
-``inline`` variables__cpp_inline_variables   C++17 
C++03
-Attributes on namespaces__cpp_namespace_attributes   C++17 
C++11
-Structured bindings __cpp_structured_bindingsC++17 
C++03
-template template arguments __cpp_template_template_args C++17 
C++03
-``static operator[]``   __cpp_multidimensional_subscript C++20 
C++03
-Designated initializers __cpp_designated_initializersC++20 
C++03
-Conditional ``explicit``__cpp_conditional_explicit   C++20 
C++03
-``using enum``  __cpp_using_enum C++20 
C++03
-``if consteval``__cpp_if_consteval   C++23 
C++20
-``static operator()``   __cpp_static_call_operator   C++23 
C++03
  
- - --
-Designated initializers  C99   
C89
-===  
= = ==
+==  
= = ==
+FeatureFeature Test Macro   
Introduced In Backported To Required Flags
+==  
= = ==
+variadic templates __cpp_variadic_templates C++11  
   C++03
+Alias templates__cpp_alias_templatesC++11  
   C++03
+Non-static data member initializers__cpp_nsdmi  C++11  
   C++03
+Range-based ``for`` loop  

[PATCH] D151081: [Clang][SVE2.1] Add svpext builtins

2023-05-22 Thread Caroline via Phabricator via cfe-commits
CarolineConcatto created this revision.
Herald added subscribers: kristof.beyls, tschuett.
Herald added a project: All.
CarolineConcatto requested review of this revision.
Herald added a project: clang.
Herald added a subscriber: cfe-commits.

As described in: https://github.com/ARM-software/acle/pull/257


Repository:
  rG LLVM Github Monorepo

https://reviews.llvm.org/D151081

Files:
  clang/include/clang/Basic/arm_sve.td
  clang/lib/CodeGen/CGBuiltin.cpp
  clang/lib/CodeGen/CodeGenFunction.h
  clang/test/CodeGen/aarch64-sve2p1-intrinsics/acle_sve2p1_pext.c
  clang/test/Sema/aarch64-sve2p1-intrinsics/acle_sve2p1_imm.cpp
  clang/utils/TableGen/SveEmitter.cpp

Index: clang/utils/TableGen/SveEmitter.cpp
===
--- clang/utils/TableGen/SveEmitter.cpp
+++ clang/utils/TableGen/SveEmitter.cpp
@@ -73,12 +73,12 @@
 public:
   SVEType() : SVEType(TypeSpec(), 'v') {}
 
-  SVEType(TypeSpec TS, char CharMod)
+  SVEType(TypeSpec TS, char CharMod, unsigned NumVectors = 1)
   : TS(TS), Float(false), Signed(true), Immediate(false), Void(false),
 Constant(false), Pointer(false), BFloat(false), DefaultType(false),
 IsScalable(true), Predicate(false), PredicatePattern(false),
 PrefetchOp(false), Svcount(false), Bitwidth(128), ElementBitwidth(~0U),
-NumVectors(1) {
+NumVectors(NumVectors) {
 if (!TS.empty())
   applyTypespec();
 applyModifier(CharMod);
@@ -194,7 +194,9 @@
   SVEType getReturnType() const { return Types[0]; }
   ArrayRef getTypes() const { return Types; }
   SVEType getParamType(unsigned I) const { return Types[I + 1]; }
-  unsigned getNumParams() const { return Proto.size() - 1; }
+  unsigned getNumParams() const {
+return Proto.size() - (2 * std::count(Proto.begin(), Proto.end(), '.')) - 1;
+  }
 
   uint64_t getFlags() const { return Flags; }
   bool isFlagSet(uint64_t Flag) const { return Flags & Flag;}
@@ -228,11 +230,19 @@
 
   /// Return the parameter index of the splat operand.
   unsigned getSplatIdx() const {
-// These prototype modifiers are described in arm_sve.td.
-auto Idx = Proto.find_first_of("ajfrKLR@");
-assert(Idx != std::string::npos && Idx > 0 &&
-   "Prototype has no splat operand");
-return Idx - 1;
+unsigned I = 1, Param = 0;
+for (; I < Proto.size(); ++I, ++Param) {
+  if (Proto[I] == 'a' || Proto[I] == 'j' || Proto[I] == 'f' ||
+  Proto[I] == 'r' || Proto[I] == 'K' || Proto[I] == 'L' ||
+  Proto[I] == 'R' || Proto[I] == '@')
+break;
+
+  // Multivector modifier can be skipped
+  if (Proto[I] == '.')
+I += 2;
+}
+assert(I != Proto.size() && "Prototype has no splat operand");
+return Param;
   }
 
   /// Emits the intrinsic declaration to the ostream.
@@ -524,15 +534,6 @@
 
 void SVEType::applyModifier(char Mod) {
   switch (Mod) {
-  case '2':
-NumVectors = 2;
-break;
-  case '3':
-NumVectors = 3;
-break;
-  case '4':
-NumVectors = 4;
-break;
   case 'v':
 Void = true;
 break;
@@ -838,11 +839,36 @@
 Float = false;
 BFloat = false;
 break;
+  case '.':
+llvm_unreachable(". should never be a type");
+break;
   default:
 llvm_unreachable("Unhandled character!");
   }
 }
 
+/// Returns the modifier and number of vectors for the given operand \p Op.
+std::pair getProtoModifier(StringRef Proto, unsigned Op) {
+  for (unsigned P = 0; !Proto.empty(); ++P) {
+unsigned NumVectors = 1;
+unsigned CharsToSkip = 1;
+char Mod = Proto[0];
+if (Mod == '2' || Mod == '3' || Mod == '4') {
+  NumVectors = Mod - '0';
+  Mod = 'd';
+  if (Proto.size() > 1 && Proto[1] == '.') {
+Mod = Proto[2];
+CharsToSkip = 3;
+  }
+}
+
+if (P == Op)
+  return {Mod, NumVectors};
+
+Proto = Proto.drop_front(CharsToSkip);
+  }
+  llvm_unreachable("Unexpected Op");
+}
 
 //===--===//
 // Intrinsic implementation
@@ -858,8 +884,11 @@
   MergeSuffix(MergeSuffix.str()), BaseType(BT, 'd'), Flags(Flags),
   ImmChecks(Checks.begin(), Checks.end()) {
   // Types[0] is the return value.
-  for (unsigned I = 0; I < Proto.size(); ++I) {
-SVEType T(BaseTypeSpec, Proto[I]);
+  for (unsigned I = 0; I < (getNumParams() + 1); ++I) {
+char Mod;
+unsigned NumVectors;
+std::tie(Mod, NumVectors) = getProtoModifier(Proto, I);
+SVEType T(BaseTypeSpec, Mod, NumVectors);
 Types.push_back(T);
 
 // Add range checks for immediates
@@ -1087,10 +1116,11 @@
   assert(Arg >= 0 && Kind >= 0 && "Arg and Kind must be nonnegative");
 
   unsigned ElementSizeInBits = 0;
+  char Mod;
+  unsigned NumVectors;
+  std::tie(Mod, NumVectors) = getProtoModifier(Proto, EltSizeArg + 1);
   if (EltSizeArg >= 0)
-ElementSizeInBits =
-SVEType(TS, Proto[EltSizeArg + /* offset by return arg */ 1])
-   

[clang] a9e90f7 - [clang][dataflow] Fix a null pointer crash in `computeBlockInputState()`.

2023-05-22 Thread Martin Braenne via cfe-commits

Author: Martin Braenne
Date: 2023-05-22T12:19:55Z
New Revision: a9e90f7994222dde987154ed009504afbf3c2166

URL: 
https://github.com/llvm/llvm-project/commit/a9e90f7994222dde987154ed009504afbf3c2166
DIFF: 
https://github.com/llvm/llvm-project/commit/a9e90f7994222dde987154ed009504afbf3c2166.diff

LOG: [clang][dataflow] Fix a null pointer crash in `computeBlockInputState()`.

The crash was due to unconditionally calling
`Block.succ_begin()->getReachableBlock()->hasNoReturnElement()`, but
`getReachableBlock()` can return null now that we have turned
`PruneTriviallyFalseEdges` on.

This patch adds two tests that crash without the fix.

Reviewed By: ymandel

Differential Revision: https://reviews.llvm.org/D151071

Added: 


Modified: 
clang/lib/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.cpp
clang/unittests/Analysis/FlowSensitive/TypeErasedDataflowAnalysisTest.cpp

Removed: 




diff  --git a/clang/lib/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.cpp 
b/clang/lib/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.cpp
index 4fc8f27ffc9b2..37dd7081ae986 100644
--- a/clang/lib/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.cpp
+++ b/clang/lib/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.cpp
@@ -216,7 +216,8 @@ computeBlockInputState(const CFGBlock &Block, 
AnalysisContext &AC) {
 // operator includes a branch that contains a noreturn destructor call.
 //
 // See `NoreturnDestructorTest` for concrete examples.
-if (Block.succ_begin()->getReachableBlock()->hasNoReturnElement()) {
+if (Block.succ_begin()->getReachableBlock() != nullptr &&
+Block.succ_begin()->getReachableBlock()->hasNoReturnElement()) {
   auto &StmtToBlock = AC.CFCtx.getStmtToBlock();
   auto StmtBlock = StmtToBlock.find(Block.getTerminatorStmt());
   assert(StmtBlock != StmtToBlock.end());

diff  --git 
a/clang/unittests/Analysis/FlowSensitive/TypeErasedDataflowAnalysisTest.cpp 
b/clang/unittests/Analysis/FlowSensitive/TypeErasedDataflowAnalysisTest.cpp
index 30aef86e7a26e..5bfb9e53778b0 100644
--- a/clang/unittests/Analysis/FlowSensitive/TypeErasedDataflowAnalysisTest.cpp
+++ b/clang/unittests/Analysis/FlowSensitive/TypeErasedDataflowAnalysisTest.cpp
@@ -296,6 +296,22 @@ TEST_F(NoreturnDestructorTest, 
ConditionalOperatorLeftBranchReturns) {
  UnorderedElementsAre("foo"));
 }
 
+TEST_F(NoreturnDestructorTest,
+   ConditionalOperatorConstantCondition_LeftBranchReturns) {
+  std::string Code = R"(
+#include "noreturn_destructor_test_defs.h"
+
+void target() {
+  int value = true ? foo() : Fatal().bar();
+  (void)0;
+  // [[p]]
+}
+  )";
+  runDataflow(Code, UnorderedElementsAre(IsStringMapEntry(
+"p", HoldsFunctionCallLattice(HasCalledFunctions(
+ UnorderedElementsAre("foo"));
+}
+
 TEST_F(NoreturnDestructorTest, ConditionalOperatorRightBranchReturns) {
   std::string Code = R"(
 #include "noreturn_destructor_test_defs.h"
@@ -311,6 +327,22 @@ TEST_F(NoreturnDestructorTest, 
ConditionalOperatorRightBranchReturns) {
  UnorderedElementsAre("foo"));
 }
 
+TEST_F(NoreturnDestructorTest,
+   ConditionalOperatorConstantCondition_RightBranchReturns) {
+  std::string Code = R"(
+#include "noreturn_destructor_test_defs.h"
+
+void target() {
+  int value = false ? Fatal().bar() : foo();
+  (void)0;
+  // [[p]]
+}
+  )";
+  runDataflow(Code, UnorderedElementsAre(IsStringMapEntry(
+"p", HoldsFunctionCallLattice(HasCalledFunctions(
+ UnorderedElementsAre("foo"));
+}
+
 TEST_F(NoreturnDestructorTest, ConditionalOperatorNestedBranchesDoNotReturn) {
   std::string Code = R"(
 #include "noreturn_destructor_test_defs.h"



___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D151071: [clang][dataflow] Fix a null pointer crash in `computeBlockInputState()`.

2023-05-22 Thread Martin Böhme via Phabricator via cfe-commits
This revision was automatically updated to reflect the committed changes.
Closed by commit rGa9e90f799422: [clang][dataflow] Fix a null pointer crash in 
`computeBlockInputState()`. (authored by mboehme).

Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D151071/new/

https://reviews.llvm.org/D151071

Files:
  clang/lib/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.cpp
  clang/unittests/Analysis/FlowSensitive/TypeErasedDataflowAnalysisTest.cpp


Index: clang/unittests/Analysis/FlowSensitive/TypeErasedDataflowAnalysisTest.cpp
===
--- clang/unittests/Analysis/FlowSensitive/TypeErasedDataflowAnalysisTest.cpp
+++ clang/unittests/Analysis/FlowSensitive/TypeErasedDataflowAnalysisTest.cpp
@@ -296,6 +296,22 @@
  UnorderedElementsAre("foo"));
 }
 
+TEST_F(NoreturnDestructorTest,
+   ConditionalOperatorConstantCondition_LeftBranchReturns) {
+  std::string Code = R"(
+#include "noreturn_destructor_test_defs.h"
+
+void target() {
+  int value = true ? foo() : Fatal().bar();
+  (void)0;
+  // [[p]]
+}
+  )";
+  runDataflow(Code, UnorderedElementsAre(IsStringMapEntry(
+"p", HoldsFunctionCallLattice(HasCalledFunctions(
+ UnorderedElementsAre("foo"));
+}
+
 TEST_F(NoreturnDestructorTest, ConditionalOperatorRightBranchReturns) {
   std::string Code = R"(
 #include "noreturn_destructor_test_defs.h"
@@ -311,6 +327,22 @@
  UnorderedElementsAre("foo"));
 }
 
+TEST_F(NoreturnDestructorTest,
+   ConditionalOperatorConstantCondition_RightBranchReturns) {
+  std::string Code = R"(
+#include "noreturn_destructor_test_defs.h"
+
+void target() {
+  int value = false ? Fatal().bar() : foo();
+  (void)0;
+  // [[p]]
+}
+  )";
+  runDataflow(Code, UnorderedElementsAre(IsStringMapEntry(
+"p", HoldsFunctionCallLattice(HasCalledFunctions(
+ UnorderedElementsAre("foo"));
+}
+
 TEST_F(NoreturnDestructorTest, ConditionalOperatorNestedBranchesDoNotReturn) {
   std::string Code = R"(
 #include "noreturn_destructor_test_defs.h"
Index: clang/lib/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.cpp
===
--- clang/lib/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.cpp
+++ clang/lib/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.cpp
@@ -216,7 +216,8 @@
 // operator includes a branch that contains a noreturn destructor call.
 //
 // See `NoreturnDestructorTest` for concrete examples.
-if (Block.succ_begin()->getReachableBlock()->hasNoReturnElement()) {
+if (Block.succ_begin()->getReachableBlock() != nullptr &&
+Block.succ_begin()->getReachableBlock()->hasNoReturnElement()) {
   auto &StmtToBlock = AC.CFCtx.getStmtToBlock();
   auto StmtBlock = StmtToBlock.find(Block.getTerminatorStmt());
   assert(StmtBlock != StmtToBlock.end());


Index: clang/unittests/Analysis/FlowSensitive/TypeErasedDataflowAnalysisTest.cpp
===
--- clang/unittests/Analysis/FlowSensitive/TypeErasedDataflowAnalysisTest.cpp
+++ clang/unittests/Analysis/FlowSensitive/TypeErasedDataflowAnalysisTest.cpp
@@ -296,6 +296,22 @@
  UnorderedElementsAre("foo"));
 }
 
+TEST_F(NoreturnDestructorTest,
+   ConditionalOperatorConstantCondition_LeftBranchReturns) {
+  std::string Code = R"(
+#include "noreturn_destructor_test_defs.h"
+
+void target() {
+  int value = true ? foo() : Fatal().bar();
+  (void)0;
+  // [[p]]
+}
+  )";
+  runDataflow(Code, UnorderedElementsAre(IsStringMapEntry(
+"p", HoldsFunctionCallLattice(HasCalledFunctions(
+ UnorderedElementsAre("foo"));
+}
+
 TEST_F(NoreturnDestructorTest, ConditionalOperatorRightBranchReturns) {
   std::string Code = R"(
 #include "noreturn_destructor_test_defs.h"
@@ -311,6 +327,22 @@
  UnorderedElementsAre("foo"));
 }
 
+TEST_F(NoreturnDestructorTest,
+   ConditionalOperatorConstantCondition_RightBranchReturns) {
+  std::string Code = R"(
+#include "noreturn_destructor_test_defs.h"
+
+void target() {
+  int value = false ? Fatal().bar() : foo();
+  (void)0;
+  // [[p]]
+}
+  )";
+  runDataflow(Code, UnorderedElementsAre(IsStringMapEntry(
+"p", HoldsFunctionCallLattice(HasCalledFunctions(
+ UnorderedElementsAre("foo"));
+}
+
 TEST_F(NoreturnDestructorTest, ConditionalOperatorNestedBranchesDoNotReturn) {
   std::string Code = R"(
 #include "noreturn_destructor_test_defs.h"
Index: clang/lib/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.cpp

[PATCH] D151078: [clang][Diagnostics] Use llvm::raw_ostream::indent()

2023-05-22 Thread Timm Bäder via Phabricator via cfe-commits
tbaeder updated this revision to Diff 524253.

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D151078/new/

https://reviews.llvm.org/D151078

Files:
  clang/lib/Frontend/TextDiagnostic.cpp


Index: clang/lib/Frontend/TextDiagnostic.cpp
===
--- clang/lib/Frontend/TextDiagnostic.cpp
+++ clang/lib/Frontend/TextDiagnostic.cpp
@@ -623,9 +623,6 @@
   const unsigned Length = std::min(Str.find('\n'), Str.size());
   bool TextNormal = true;
 
-  // The string used to indent each line.
-  SmallString<16> IndentStr;
-  IndentStr.assign(Indentation, ' ');
   bool Wrapped = false;
   for (unsigned WordStart = 0, WordEnd; WordStart < Length;
WordStart = WordEnd) {
@@ -654,7 +651,7 @@
 // This word does not fit on the current line, so wrap to the next
 // line.
 OS << '\n';
-OS.write(&IndentStr[0], Indentation);
+OS.indent(Indentation);
 applyTemplateHighlighting(OS, Str.substr(WordStart, WordLength),
   TextNormal, Bold);
 Column = Indentation + WordLength;
@@ -1197,10 +1194,8 @@
   : 0;
   auto indentForLineNumbers = [&] {
 if (MaxLineNoDisplayWidth > 0) {
-  OS << ' ';
-  for (unsigned I = 0; I != MaxLineNoDisplayWidth; ++I)
-OS << ' ';
-  OS << " | ";
+  OS.indent(MaxLineNoDisplayWidth + 2);
+  OS << "| ";
 }
   };
 
@@ -1315,9 +1310,7 @@
   // Emit line number.
   if (MaxLineNoDisplayWidth > 0) {
 unsigned LineNoDisplayWidth = getNumDisplayWidth(LineNo);
-OS << ' ';
-for (unsigned I = LineNoDisplayWidth; I < MaxLineNoDisplayWidth; ++I)
-  OS << ' ';
+OS.indent(MaxLineNoDisplayWidth - LineNoDisplayWidth + 1);
 OS << LineNo;
 OS << " | ";
   }


Index: clang/lib/Frontend/TextDiagnostic.cpp
===
--- clang/lib/Frontend/TextDiagnostic.cpp
+++ clang/lib/Frontend/TextDiagnostic.cpp
@@ -623,9 +623,6 @@
   const unsigned Length = std::min(Str.find('\n'), Str.size());
   bool TextNormal = true;
 
-  // The string used to indent each line.
-  SmallString<16> IndentStr;
-  IndentStr.assign(Indentation, ' ');
   bool Wrapped = false;
   for (unsigned WordStart = 0, WordEnd; WordStart < Length;
WordStart = WordEnd) {
@@ -654,7 +651,7 @@
 // This word does not fit on the current line, so wrap to the next
 // line.
 OS << '\n';
-OS.write(&IndentStr[0], Indentation);
+OS.indent(Indentation);
 applyTemplateHighlighting(OS, Str.substr(WordStart, WordLength),
   TextNormal, Bold);
 Column = Indentation + WordLength;
@@ -1197,10 +1194,8 @@
   : 0;
   auto indentForLineNumbers = [&] {
 if (MaxLineNoDisplayWidth > 0) {
-  OS << ' ';
-  for (unsigned I = 0; I != MaxLineNoDisplayWidth; ++I)
-OS << ' ';
-  OS << " | ";
+  OS.indent(MaxLineNoDisplayWidth + 2);
+  OS << "| ";
 }
   };
 
@@ -1315,9 +1310,7 @@
   // Emit line number.
   if (MaxLineNoDisplayWidth > 0) {
 unsigned LineNoDisplayWidth = getNumDisplayWidth(LineNo);
-OS << ' ';
-for (unsigned I = LineNoDisplayWidth; I < MaxLineNoDisplayWidth; ++I)
-  OS << ' ';
+OS.indent(MaxLineNoDisplayWidth - LineNoDisplayWidth + 1);
 OS << LineNo;
 OS << " | ";
   }
___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D151078: [clang][Diagnostics] Use llvm::raw_ostream::indent()

2023-05-22 Thread Aaron Ballman via Phabricator via cfe-commits
aaron.ballman accepted this revision.
aaron.ballman added a comment.
This revision is now accepted and ready to land.

LGTM!


CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D151078/new/

https://reviews.llvm.org/D151078

___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D150435: [clang] Fix crash on attempt to initialize union with flexible array member

2023-05-22 Thread Aaron Ballman via Phabricator via cfe-commits
aaron.ballman accepted this revision.
aaron.ballman added a comment.

LGTM with a minor tweak to the test, thanks!




Comment at: clang/test/Sema/flexible-array-in-union.c:1-16
+// RUN: %clang_cc1 %s -verify -fsyntax-only -DERROR
+// RUN: %clang_cc1 %s -verify -fsyntax-only -x c++
+// RUN: %clang_cc1 %s -verify -fsyntax-only -fms-compatibility
+// RUN: %clang_cc1 %s -verify -fsyntax-only -fms-compatibility -x c++
+
+// The test checks that an attempt to initialize union with flexible array
+// member with an initializer list doesn't crash clang.

Slight tweak to get rid of the preprocessor stuff and simplify the test a bit; 
NFC.


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D150435/new/

https://reviews.llvm.org/D150435

___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D151087: [Clang] Permit address space casts with 'reinterpret_cast' in C++

2023-05-22 Thread Joseph Huber via Phabricator via cfe-commits
jhuber6 created this revision.
jhuber6 added reviewers: rjmccall, ebevhan, jdoerfert, JonChesterfield, 
aaron.ballman.
Herald added subscribers: arichardson, Anastasia.
Herald added a project: All.
jhuber6 requested review of this revision.
Herald added a project: clang.
Herald added a subscriber: cfe-commits.

Previously, D58346  changed the rules to not 
permit address space casts
in C++. The cited reason was that `reinterpret_cast` is not allowed to
remove qualifiers, however the standard only explicitly says that
`const`  and `volatile` qualifiers cannot be removed, see
http://eel.is/c++draft/expr.reinterpret.cast#7. The current behaviour is
suboptimal as it means there is no way in C++ to change address spaces
and we need to rely on unsafe C style casts that aren't permitted by
many styles. This patch changes the handling to only apply to OpenCL.


Repository:
  rG LLVM Github Monorepo

https://reviews.llvm.org/D151087

Files:
  clang/lib/Sema/SemaCast.cpp
  clang/test/SemaCXX/address-space-conversion.cpp


Index: clang/test/SemaCXX/address-space-conversion.cpp
===
--- clang/test/SemaCXX/address-space-conversion.cpp
+++ clang/test/SemaCXX/address-space-conversion.cpp
@@ -132,23 +132,23 @@
A_ptr ap, A_ptr_1 ap1, A_ptr_2 ap2,
B_ptr bp, B_ptr_1 bp1, B_ptr_2 bp2,
const void __attribute__((address_space(1))) * 
cvp1) {
-  // reinterpret_cast can't be used to cast to a different address space 
unless they are matching (i.e. overlapping).
-  (void)reinterpret_cast(ap1); // expected-error{{reinterpret_cast from 
'A_ptr_1' (aka '__attribute__((address_space(1))) A *') to 'A_ptr' (aka 'A *') 
is not allowed}}
-  (void)reinterpret_cast(ap2); // expected-error{{reinterpret_cast from 
'A_ptr_2' (aka '__attribute__((address_space(2))) A *') to 'A_ptr' (aka 'A *') 
is not allowed}}
+  // reinterpret_cast can be used to cast to a different address space.
+  (void)reinterpret_cast(ap1);
+  (void)reinterpret_cast(ap2);
   (void)reinterpret_cast(bp);
-  (void)reinterpret_cast(bp1); // expected-error{{reinterpret_cast from 
'B_ptr_1' (aka '__attribute__((address_space(1))) B *') to 'A_ptr' (aka 'A *') 
is not allowed}}
-  (void)reinterpret_cast(bp2); // expected-error{{reinterpret_cast from 
'B_ptr_2' (aka '__attribute__((address_space(2))) B *') to 'A_ptr' (aka 'A *') 
is not allowed}}
+  (void)reinterpret_cast(bp1);
+  (void)reinterpret_cast(bp2);
   (void)reinterpret_cast(vp);
-  (void)reinterpret_cast(vp1);   // expected-error{{reinterpret_cast 
from 'void_ptr_1' (aka '__attribute__((address_space(1))) void *') to 'A_ptr' 
(aka 'A *') is not allowed}}
-  (void)reinterpret_cast(vp2);   // expected-error{{reinterpret_cast 
from 'void_ptr_2' (aka '__attribute__((address_space(2))) void *') to 'A_ptr' 
(aka 'A *') is not allowed}}
-  (void)reinterpret_cast(ap);  // expected-error{{reinterpret_cast 
from 'A_ptr' (aka 'A *') to 'A_ptr_1' (aka '__attribute__((address_space(1))) A 
*') is not allowed}}
-  (void)reinterpret_cast(ap2); // expected-error{{reinterpret_cast 
from 'A_ptr_2' (aka '__attribute__((address_space(2))) A *') to 'A_ptr_1' (aka 
'__attribute__((address_space(1))) A *') is not allowed}}
-  (void)reinterpret_cast(bp);  // expected-error{{reinterpret_cast 
from 'B_ptr' (aka 'B *') to 'A_ptr_1' (aka '__attribute__((address_space(1))) A 
*') is not allowed}}
+  (void)reinterpret_cast(vp1);
+  (void)reinterpret_cast(vp2);
+  (void)reinterpret_cast(ap);
+  (void)reinterpret_cast(ap2);
+  (void)reinterpret_cast(bp);
   (void)reinterpret_cast(bp1);
-  (void)reinterpret_cast(bp2); // expected-error{{reinterpret_cast 
from 'B_ptr_2' (aka '__attribute__((address_space(2))) B *') to 'A_ptr_1' (aka 
'__attribute__((address_space(1))) A *') is not allowed}}
-  (void)reinterpret_cast(vp);  // expected-error{{reinterpret_cast 
from 'void_ptr' (aka 'void *') to 'A_ptr_1' (aka 
'__attribute__((address_space(1))) A *') is not allowed}}
+  (void)reinterpret_cast(bp2);
+  (void)reinterpret_cast(vp);
   (void)reinterpret_cast(vp1);
-  (void)reinterpret_cast(vp2); // expected-error{{reinterpret_cast 
from 'void_ptr_2' (aka '__attribute__((address_space(2))) void *') to 'A_ptr_1' 
(aka '__attribute__((address_space(1))) A *') is not allowed}}
+  (void)reinterpret_cast(vp2);
 
   // ... but don't try to cast away constness!
   (void)reinterpret_cast(cvp1); // expected-error{{casts away 
qualifiers}}
Index: clang/lib/Sema/SemaCast.cpp
===
--- clang/lib/Sema/SemaCast.cpp
+++ clang/lib/Sema/SemaCast.cpp
@@ -2481,7 +2481,11 @@
   if (IsAddressSpaceConversion(SrcType, DestType)) {
 Kind = CK_AddressSpaceConversion;
 assert(SrcType->isPointerType() && DestType->isPointerType());
+// C++ 7.6.1.10: The reinterpret_cast operator is only forbidden from
+// casting away constness or vo

[PATCH] D151088: [flang][hlfir] Separate -emit-fir and -emit-hlfir

2023-05-22 Thread Tom Eccles via Phabricator via cfe-commits
tblah created this revision.
tblah added reviewers: awarzynski, vzakhari, jeanPerier, clementval.
Herald added a reviewer: sscalpone.
Herald added a subscriber: sunshaoce.
Herald added projects: Flang, All.
tblah requested review of this revision.
Herald added subscribers: cfe-commits, jdoerfert.
Herald added a project: clang.

In review for https://reviews.llvm.org/D146278, @vzakhari asked to
separate -emit-fir and -emit-hlfir. This will allow FIR to be easily
outputted after the HLFIR passes have been run.

The new semantics are as follows:

| Action  | -flang-experimental-hlfir? | Result  |
| === | == | === |
| -emit-hlfir | N  | Outputs HLFIR   |
| -emit-hlfir | Y  | Outputs HLFIR   |
| -emit-fir   | N  | Outputs FIR, using old lowering |
| -emit-fir   | Y  | Outputs FIR, lowering via HLFIR |
|

A patch for bbc will follow.


Repository:
  rG LLVM Github Monorepo

https://reviews.llvm.org/D151088

Files:
  clang/include/clang/Driver/Options.td
  flang/include/flang/Frontend/FrontendActions.h
  flang/include/flang/Frontend/FrontendOptions.h
  flang/lib/Frontend/CompilerInvocation.cpp
  flang/lib/Frontend/FrontendActions.cpp
  flang/lib/FrontendTool/ExecuteCompilerInvocation.cpp
  flang/test/Driver/driver-help.f90
  flang/test/HLFIR/flang-experimental-hlfir-flag.f90

Index: flang/test/HLFIR/flang-experimental-hlfir-flag.f90
===
--- flang/test/HLFIR/flang-experimental-hlfir-flag.f90
+++ flang/test/HLFIR/flang-experimental-hlfir-flag.f90
@@ -1,19 +1,38 @@
-! Test -flang-experimental-hlfir flag
-! RUN: %flang_fc1 -flang-experimental-hlfir -emit-fir -o - %s | FileCheck %s
-! RUN: %flang_fc1 -emit-fir -o - %s | FileCheck %s --check-prefix NO-HLFIR
+! Test -flang-experimental-hlfir, -emit-hlfir, -emit-fir flags
+! RUN: %flang_fc1 -emit-hlfir -o - %s | FileCheck --check-prefix HLFIR --check-prefix ALL %s
+! RUN: %flang_fc1 -emit-hlfir -flang-experimental-hlfir -o - %s | FileCheck --check-prefix HLFIR --check-prefix ALL %s
+! RUN: %flang_fc1 -emit-fir -o - %s | FileCheck %s --check-prefix NO-HLFIR --check-prefix ALL
+! RUN: %flang_fc1 -emit-fir -flang-experimental-hlfir -o - %s | FileCheck --check-prefix FIR --check-prefix ALL %s
+
+! | Action  | -flang-experimental-hlfir? | Result  |
+! | === | == | === |
+! | -emit-hlfir | N  | Outputs HLFIR   |
+! | -emit-hlfir | Y  | Outputs HLFIR   |
+! | -emit-fir   | N  | Outputs FIR, using old lowering |
+! | -emit-fir   | Y  | Outputs FIR, lowering via HLFIR |
 
 subroutine test(a, res)
   real :: a(:), res
   res = SUM(a)
 end subroutine
-! CHECK-LABEL: func.func @_QPtest
-! CHECK:   %[[A:.*]]: !fir.box>
-! CHECK:   %[[RES:.*]]: !fir.ref
-! CHECK-DAG: %[[A_VAR:.*]]:2 = hlfir.declare %[[A]]
-! CHECK-DAG: %[[RES_VAR:.*]]:2 = hlfir.declare %[[RES]]
-! CHECK-NEXT:%[[SUM_RES:.*]] = hlfir.sum %[[A_VAR]]#0
-! CHECK-NEXT:hlfir.assign %[[SUM_RES]] to %[[RES_VAR]]#0
-! CHECK-NEXT:return
-! CHECK-NEXT:  }
+! ALL-LABEL: func.func @_QPtest
+! ALL: %[[A:.*]]: !fir.box>
+! ALL: %[[RES:.*]]: !fir.ref
+
+! HLFIR: %[[A_VAR:.*]]:2 = hlfir.declare %[[A]]
+! fir.declare is only generated via the hlfir -> fir lowering
+! FIR:   %[[A_VAR:.*]] = fir.declare %[[A]]
+! NO-HLFIR-NOT:  fir.declare
+
+! HLFIR-DAG: %[[RES_VAR:.*]]:2 = hlfir.declare %[[RES]]
+! FIR:   %[[RES_VAR:.*]] = fir.declare %[[RES]]
+! NO-HLFIR-NOT:  fir.declare
+
+! HLFIR-NEXT:%[[SUM_RES:.*]] = hlfir.sum %[[A_VAR]]#0
+! HLFIR-NEXT:hlfir.assign %[[SUM_RES]] to %[[RES_VAR]]#0
+! FIR-NOT:   hlfir.
+! NO-HLFIR-NOT:  hlfir.
+
+! ALL:   return
+! ALL-NEXT:  }
 
-! NO-HLFIR-NOT: hlfir.
Index: flang/test/Driver/driver-help.f90
===
--- flang/test/Driver/driver-help.f90
+++ flang/test/Driver/driver-help.f90
@@ -94,9 +94,10 @@
 ! HELP-FC1-NEXT:OPTIONS:
 ! HELP-FC1-NEXT: -cpp   Enable predefined and command line preprocessor macros
 ! HELP-FC1-NEXT: -D = Define  to  (or 1 if  omitted)
+! HELP-FC1-NEXT: -emit-hlfirBuild the parse tree, then lower it to HLFIR
 ! HELP-FC1-NEXT: -emit-llvm-bc  Build ASTs then convert to LLVM, emit .bc file
 ! HELP-FC1-NEXT: -emit-llvm Use the LLVM representation for assembler and object files
-! HELP-FC1-NEXT: -emit-mlir Build the parse tree, then lower it to MLIR
+! HELP-FC1-NEXT: -emit-mlir Build the parse tree, then lower it to FIR
 ! HELP-FC1-NEXT: -emit-obj Emit native object files
 ! HELP-FC1-NEXT: -E  

[PATCH] D146278: [flang] add -flang-experimental-hlfir flag to flang-new

2023-05-22 Thread Tom Eccles via Phabricator via cfe-commits
tblah added inline comments.
Herald added a subscriber: bviyer.



Comment at: flang/include/flang/Tools/CLOptions.inc:251
+bool stackArrays = false, bool underscoring = true, bool useHLFIR = false) 
{
+  if (useHLFIR)
+fir::createHLFIRToFIRPassPipeline(pm, optLevel);

tblah wrote:
> vzakhari wrote:
> > Is this check and the option really needed?  Except for the extra 
> > canonicalizer pass the newly added passes will be no-ops, so maybe we 
> > should just run them unconditionally.
> > 
> > It may be too much to ask for, but will it make sense not to bundle these 
> > passes into `MLIRToLLVM` pipeline and have the possibility to let driver 
> > emit post-HLFIR-lowering MLIR (under `-emit-fir`) and pre-HLFIR-lowering 
> > (under some new option)?
> Okay I'll run the HLFIR passes unconditionally.
> 
> I made -emit-fir output HLFIR to match what bbc already does, but I can see 
> the usefulness of having both -emit-fir and -emit-hlfir. I won't do it in 
> this patch but I will get around to this at some point (but feel free to jump 
> in sooner if you need the flag for something).
`-emit-fir` and `-emit-hlfir` are separated in https://reviews.llvm.org/D151088


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D146278/new/

https://reviews.llvm.org/D146278

___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D150435: [clang] Fix crash on attempt to initialize union with flexible array member

2023-05-22 Thread Mariya Podchishchaeva via Phabricator via cfe-commits
Fznamznon added inline comments.



Comment at: clang/test/Sema/flexible-array-in-union.c:1-16
+// RUN: %clang_cc1 %s -verify -fsyntax-only -DERROR
+// RUN: %clang_cc1 %s -verify -fsyntax-only -x c++
+// RUN: %clang_cc1 %s -verify -fsyntax-only -fms-compatibility
+// RUN: %clang_cc1 %s -verify -fsyntax-only -fms-compatibility -x c++
+
+// The test checks that an attempt to initialize union with flexible array
+// member with an initializer list doesn't crash clang.

aaron.ballman wrote:
> Slight tweak to get rid of the preprocessor stuff and simplify the test a 
> bit; NFC.
Neat! Thank you.


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D150435/new/

https://reviews.llvm.org/D150435

___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D151071: [clang][dataflow] Fix a null pointer crash in `computeBlockInputState()`.

2023-05-22 Thread Dmitri Gribenko via Phabricator via cfe-commits
gribozavr2 added a comment.

LGTM too.


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D151071/new/

https://reviews.llvm.org/D151071

___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D151040: [NFC][CLANG] Fix static code analyzer concerns

2023-05-22 Thread Erich Keane via Phabricator via cfe-commits
erichkeane added inline comments.



Comment at: clang/lib/AST/ExprConstant.cpp:10172
   Info.Ctx.getAsConstantArrayType(E->getSubExpr()->getType());
+  assert(ArrayType && "unexpected type for array initializer");
 

I think this ends up being a regression if the LValue doesn't evaluate right.  
This should probably go down near 10179.


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D151040/new/

https://reviews.llvm.org/D151040

___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D151078: [clang][Diagnostics] Use llvm::raw_ostream::indent()

2023-05-22 Thread Timm Bäder via Phabricator via cfe-commits
tbaeder updated this revision to Diff 524271.

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D151078/new/

https://reviews.llvm.org/D151078

Files:
  clang/lib/Frontend/TextDiagnostic.cpp


Index: clang/lib/Frontend/TextDiagnostic.cpp
===
--- clang/lib/Frontend/TextDiagnostic.cpp
+++ clang/lib/Frontend/TextDiagnostic.cpp
@@ -623,9 +623,6 @@
   const unsigned Length = std::min(Str.find('\n'), Str.size());
   bool TextNormal = true;
 
-  // The string used to indent each line.
-  SmallString<16> IndentStr;
-  IndentStr.assign(Indentation, ' ');
   bool Wrapped = false;
   for (unsigned WordStart = 0, WordEnd; WordStart < Length;
WordStart = WordEnd) {
@@ -654,7 +651,7 @@
 // This word does not fit on the current line, so wrap to the next
 // line.
 OS << '\n';
-OS.write(&IndentStr[0], Indentation);
+OS.indent(Indentation);
 applyTemplateHighlighting(OS, Str.substr(WordStart, WordLength),
   TextNormal, Bold);
 Column = Indentation + WordLength;
@@ -1196,12 +1193,8 @@
   ? std::max(4u, getNumDisplayWidth(DisplayLineNo + MaxLines))
   : 0;
   auto indentForLineNumbers = [&] {
-if (MaxLineNoDisplayWidth > 0) {
-  OS << ' ';
-  for (unsigned I = 0; I != MaxLineNoDisplayWidth; ++I)
-OS << ' ';
-  OS << " | ";
-}
+if (MaxLineNoDisplayWidth > 0)
+  OS.indent(MaxLineNoDisplayWidth + 2) << "| ";
   };
 
   for (unsigned LineNo = Lines.first; LineNo != Lines.second + 1;
@@ -1315,11 +1308,8 @@
   // Emit line number.
   if (MaxLineNoDisplayWidth > 0) {
 unsigned LineNoDisplayWidth = getNumDisplayWidth(LineNo);
-OS << ' ';
-for (unsigned I = LineNoDisplayWidth; I < MaxLineNoDisplayWidth; ++I)
-  OS << ' ';
-OS << LineNo;
-OS << " | ";
+OS.indent(MaxLineNoDisplayWidth - LineNoDisplayWidth + 1)
+<< LineNo << " | ";
   }
 
   // Print the source line one character at a time.


Index: clang/lib/Frontend/TextDiagnostic.cpp
===
--- clang/lib/Frontend/TextDiagnostic.cpp
+++ clang/lib/Frontend/TextDiagnostic.cpp
@@ -623,9 +623,6 @@
   const unsigned Length = std::min(Str.find('\n'), Str.size());
   bool TextNormal = true;
 
-  // The string used to indent each line.
-  SmallString<16> IndentStr;
-  IndentStr.assign(Indentation, ' ');
   bool Wrapped = false;
   for (unsigned WordStart = 0, WordEnd; WordStart < Length;
WordStart = WordEnd) {
@@ -654,7 +651,7 @@
 // This word does not fit on the current line, so wrap to the next
 // line.
 OS << '\n';
-OS.write(&IndentStr[0], Indentation);
+OS.indent(Indentation);
 applyTemplateHighlighting(OS, Str.substr(WordStart, WordLength),
   TextNormal, Bold);
 Column = Indentation + WordLength;
@@ -1196,12 +1193,8 @@
   ? std::max(4u, getNumDisplayWidth(DisplayLineNo + MaxLines))
   : 0;
   auto indentForLineNumbers = [&] {
-if (MaxLineNoDisplayWidth > 0) {
-  OS << ' ';
-  for (unsigned I = 0; I != MaxLineNoDisplayWidth; ++I)
-OS << ' ';
-  OS << " | ";
-}
+if (MaxLineNoDisplayWidth > 0)
+  OS.indent(MaxLineNoDisplayWidth + 2) << "| ";
   };
 
   for (unsigned LineNo = Lines.first; LineNo != Lines.second + 1;
@@ -1315,11 +1308,8 @@
   // Emit line number.
   if (MaxLineNoDisplayWidth > 0) {
 unsigned LineNoDisplayWidth = getNumDisplayWidth(LineNo);
-OS << ' ';
-for (unsigned I = LineNoDisplayWidth; I < MaxLineNoDisplayWidth; ++I)
-  OS << ' ';
-OS << LineNo;
-OS << " | ";
+OS.indent(MaxLineNoDisplayWidth - LineNoDisplayWidth + 1)
+<< LineNo << " | ";
   }
 
   // Print the source line one character at a time.
___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D151092: [clang-tidy]performance-no-automatic-move: fix false negative on `const T&&` ctors.

2023-05-22 Thread Clement Courbet via Phabricator via cfe-commits
courbet created this revision.
courbet added a reviewer: gnanabit.
Herald added subscribers: PiotrZSL, carlosgalvezp, xazax.hun.
Herald added a reviewer: njames93.
Herald added a project: All.
courbet requested review of this revision.
Herald added a project: clang-tools-extra.

We were only handling `const T&`/`T&&` ctor pairs, and we were missing 
uref-based ctors.


Repository:
  rG LLVM Github Monorepo

https://reviews.llvm.org/D151092

Files:
  clang-tools-extra/clang-tidy/performance/NoAutomaticMoveCheck.cpp
  clang-tools-extra/docs/ReleaseNotes.rst
  clang-tools-extra/test/clang-tidy/checkers/performance/no-automatic-move.cpp

Index: clang-tools-extra/test/clang-tidy/checkers/performance/no-automatic-move.cpp
===
--- clang-tools-extra/test/clang-tidy/checkers/performance/no-automatic-move.cpp
+++ clang-tools-extra/test/clang-tidy/checkers/performance/no-automatic-move.cpp
@@ -7,30 +7,42 @@
   virtual ~Obj();
 };
 
-template 
-struct StatusOr {
-  StatusOr(const T &);
-  StatusOr(T &&);
-};
-
 struct NonTemplate {
   NonTemplate(const Obj &);
   NonTemplate(Obj &&);
 };
 
+template  struct TemplateCtorPair {
+  TemplateCtorPair(const T &);
+  TemplateCtorPair(T &&value);
+};
+
+template  struct UrefCtor {
+  template  UrefCtor(U &&value);
+};
+
 template 
 T Make();
 
-StatusOr PositiveStatusOrConstValue() {
+NonTemplate PositiveNonTemplate() {
   const Obj obj = Make();
-  return obj;
-  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: constness of 'obj' prevents automatic move [performance-no-automatic-move]
+  return obj; // selects `NonTemplate(const Obj&)`
+  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: constness of 'obj' prevents
+  // automatic move [performance-no-automatic-move]
 }
 
-NonTemplate PositiveNonTemplateConstValue() {
+TemplateCtorPair PositiveTemplateCtorPair() {
   const Obj obj = Make();
-  return obj;
-  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: constness of 'obj' prevents automatic move [performance-no-automatic-move]
+  return obj; // selects `TemplateCtorPair(const T&)`
+  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: constness of 'obj' prevents
+  // automatic move [performance-no-automatic-move]
+}
+
+UrefCtor PositiveUrefCtor() {
+  const Obj obj = Make();
+  return obj; // selects `UrefCtor(const T&&)`
+  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: constness of 'obj' prevents
+  // automatic move [performance-no-automatic-move]
 }
 
 Obj PositiveCantNrvo(bool b) {
@@ -51,22 +63,18 @@
 }
 
 // FIXME: Ideally we would warn here too.
-StatusOr PositiveStatusOrLifetimeExtension() {
+UrefCtor PositiveUrefCtorLifetimeExtension() {
   const Obj &obj = Make();
   return obj;
 }
 
 // Negatives.
 
-StatusOr Temporary() {
-  return Make();
-}
+UrefCtor Temporary() { return Make(); }
 
-StatusOr ConstTemporary() {
-  return Make();
-}
+UrefCtor ConstTemporary() { return Make(); }
 
-StatusOr ConvertingMoveConstructor() {
+UrefCtor ConvertingMoveConstructor() {
   Obj obj = Make();
   return obj;
 }
@@ -85,21 +93,19 @@
   return obj2;
 }
 
-StatusOr Ref() {
+UrefCtor Ref() {
   Obj &obj = Make();
   return obj;
 }
 
-StatusOr ConstRef() {
+UrefCtor ConstRef() {
   const Obj &obj = Make();
   return obj;
 }
 
 const Obj global;
 
-StatusOr Global() {
-  return global;
-}
+UrefCtor Global() { return global; }
 
 struct FromConstRefOnly {
   FromConstRefOnly(const Obj &);
@@ -109,3 +115,4 @@
   const Obj obj = Make();
   return obj;
 }
+
Index: clang-tools-extra/docs/ReleaseNotes.rst
===
--- clang-tools-extra/docs/ReleaseNotes.rst
+++ clang-tools-extra/docs/ReleaseNotes.rst
@@ -106,6 +106,9 @@
 - Support specifying `SystemHeaders` in the `.clang-tidy` configuration file,
   with the same functionality as the command-line option `--system-headers`.
 
+- Check :doc:`performance-no-automatic-move
+  ` now warns on `const &&` constructors.
+
 New checks
 ^^
 
Index: clang-tools-extra/clang-tidy/performance/NoAutomaticMoveCheck.cpp
===
--- clang-tools-extra/clang-tidy/performance/NoAutomaticMoveCheck.cpp
+++ clang-tools-extra/clang-tidy/performance/NoAutomaticMoveCheck.cpp
@@ -48,15 +48,23 @@
   hasParameter(0, hasType(rValueReferenceType(
   pointee(type(equalsBoundNode("SrcT")));
 
+  // A matcher for `DstT::DstT(const Src&&)`, which typically comes from an
+  // instantiation of `template  DstT::DstT(U&&)`.
+  const auto ConstRefRefCtor = cxxConstructorDecl(
+  parameterCountIs(1),
+  hasParameter(0,
+   hasType(rValueReferenceType(pointee(isConstQualified());
+
   Finder->addMatcher(
-  traverse(TK_AsIs,
-   returnStmt(hasReturnValue(
-   ignoringElidableConstructorCall(ignoringParenImpCasts(
-   cxxConstructExpr(
-   hasDeclaration(LValueRefCt

[PATCH] D151092: [clang-tidy]performance-no-automatic-move: fix false negative on `const T&&` ctors.

2023-05-22 Thread Clement Courbet via Phabricator via cfe-commits
courbet updated this revision to Diff 524276.
courbet added a comment.

fix release note placemenfix release note placement


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D151092/new/

https://reviews.llvm.org/D151092

Files:
  clang-tools-extra/clang-tidy/performance/NoAutomaticMoveCheck.cpp
  clang-tools-extra/docs/ReleaseNotes.rst
  clang-tools-extra/test/clang-tidy/checkers/performance/no-automatic-move.cpp

Index: clang-tools-extra/test/clang-tidy/checkers/performance/no-automatic-move.cpp
===
--- clang-tools-extra/test/clang-tidy/checkers/performance/no-automatic-move.cpp
+++ clang-tools-extra/test/clang-tidy/checkers/performance/no-automatic-move.cpp
@@ -7,30 +7,42 @@
   virtual ~Obj();
 };
 
-template 
-struct StatusOr {
-  StatusOr(const T &);
-  StatusOr(T &&);
-};
-
 struct NonTemplate {
   NonTemplate(const Obj &);
   NonTemplate(Obj &&);
 };
 
+template  struct TemplateCtorPair {
+  TemplateCtorPair(const T &);
+  TemplateCtorPair(T &&value);
+};
+
+template  struct UrefCtor {
+  template  UrefCtor(U &&value);
+};
+
 template 
 T Make();
 
-StatusOr PositiveStatusOrConstValue() {
+NonTemplate PositiveNonTemplate() {
   const Obj obj = Make();
-  return obj;
-  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: constness of 'obj' prevents automatic move [performance-no-automatic-move]
+  return obj; // selects `NonTemplate(const Obj&)`
+  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: constness of 'obj' prevents
+  // automatic move [performance-no-automatic-move]
 }
 
-NonTemplate PositiveNonTemplateConstValue() {
+TemplateCtorPair PositiveTemplateCtorPair() {
   const Obj obj = Make();
-  return obj;
-  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: constness of 'obj' prevents automatic move [performance-no-automatic-move]
+  return obj; // selects `TemplateCtorPair(const T&)`
+  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: constness of 'obj' prevents
+  // automatic move [performance-no-automatic-move]
+}
+
+UrefCtor PositiveUrefCtor() {
+  const Obj obj = Make();
+  return obj; // selects `UrefCtor(const T&&)`
+  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: constness of 'obj' prevents
+  // automatic move [performance-no-automatic-move]
 }
 
 Obj PositiveCantNrvo(bool b) {
@@ -51,22 +63,18 @@
 }
 
 // FIXME: Ideally we would warn here too.
-StatusOr PositiveStatusOrLifetimeExtension() {
+UrefCtor PositiveUrefCtorLifetimeExtension() {
   const Obj &obj = Make();
   return obj;
 }
 
 // Negatives.
 
-StatusOr Temporary() {
-  return Make();
-}
+UrefCtor Temporary() { return Make(); }
 
-StatusOr ConstTemporary() {
-  return Make();
-}
+UrefCtor ConstTemporary() { return Make(); }
 
-StatusOr ConvertingMoveConstructor() {
+UrefCtor ConvertingMoveConstructor() {
   Obj obj = Make();
   return obj;
 }
@@ -85,21 +93,19 @@
   return obj2;
 }
 
-StatusOr Ref() {
+UrefCtor Ref() {
   Obj &obj = Make();
   return obj;
 }
 
-StatusOr ConstRef() {
+UrefCtor ConstRef() {
   const Obj &obj = Make();
   return obj;
 }
 
 const Obj global;
 
-StatusOr Global() {
-  return global;
-}
+UrefCtor Global() { return global; }
 
 struct FromConstRefOnly {
   FromConstRefOnly(const Obj &);
@@ -109,3 +115,4 @@
   const Obj obj = Make();
   return obj;
 }
+
Index: clang-tools-extra/docs/ReleaseNotes.rst
===
--- clang-tools-extra/docs/ReleaseNotes.rst
+++ clang-tools-extra/docs/ReleaseNotes.rst
@@ -381,6 +381,10 @@
   ` when warning would be
   emitted for a const local variable to which NRVO is applied.
 
+- Improved :doc:`performance-no-automatic-move
+  `: warn on `const &&`
+  constructors.
+
 Removed checks
 ^^
 
Index: clang-tools-extra/clang-tidy/performance/NoAutomaticMoveCheck.cpp
===
--- clang-tools-extra/clang-tidy/performance/NoAutomaticMoveCheck.cpp
+++ clang-tools-extra/clang-tidy/performance/NoAutomaticMoveCheck.cpp
@@ -48,15 +48,23 @@
   hasParameter(0, hasType(rValueReferenceType(
   pointee(type(equalsBoundNode("SrcT")));
 
+  // A matcher for `DstT::DstT(const Src&&)`, which typically comes from an
+  // instantiation of `template  DstT::DstT(U&&)`.
+  const auto ConstRefRefCtor = cxxConstructorDecl(
+  parameterCountIs(1),
+  hasParameter(0,
+   hasType(rValueReferenceType(pointee(isConstQualified());
+
   Finder->addMatcher(
-  traverse(TK_AsIs,
-   returnStmt(hasReturnValue(
-   ignoringElidableConstructorCall(ignoringParenImpCasts(
-   cxxConstructExpr(
-   hasDeclaration(LValueRefCtor),
-   hasArgument(0, ignoringParenImpCasts(declRefExpr(
-  to(NonNrvoConstLocalVariable)
-   .bind("ctor_call")),
+  traverse(

[PATCH] D151093: [clang][Diagnostic] Simplify emitDiagnosticLoc

2023-05-22 Thread Timm Bäder via Phabricator via cfe-commits
tbaeder created this revision.
tbaeder added reviewers: aaron.ballman, cjdb, clang.
Herald added a project: All.
tbaeder requested review of this revision.
Herald added a project: clang.
Herald added a subscriber: cfe-commits.

  We don't use the offset returned from SourceManager::getDecomposedLoc
  here, so we might as well just use getFileID().


Repository:
  rG LLVM Github Monorepo

https://reviews.llvm.org/D151093

Files:
  clang/lib/Frontend/TextDiagnostic.cpp


Index: clang/lib/Frontend/TextDiagnostic.cpp
===
--- clang/lib/Frontend/TextDiagnostic.cpp
+++ clang/lib/Frontend/TextDiagnostic.cpp
@@ -858,30 +858,26 @@
   if (DiagOpts->ShowSourceRanges && !Ranges.empty()) {
 FileID CaretFileID = Loc.getExpansionLoc().getFileID();
 bool PrintedRange = false;
+const SourceManager &SM = Loc.getManager();
 
 for (const auto &R : Ranges) {
   // Ignore invalid ranges.
   if (!R.isValid())
 continue;
 
-  auto &SM = Loc.getManager();
   SourceLocation B = SM.getExpansionLoc(R.getBegin());
   CharSourceRange ERange = SM.getExpansionRange(R.getEnd());
   SourceLocation E = ERange.getEnd();
-  bool IsTokenRange = ERange.isTokenRange();
 
-  std::pair BInfo = SM.getDecomposedLoc(B);
-  std::pair EInfo = SM.getDecomposedLoc(E);
-
-  // If the start or end of the range is in another file, just discard
-  // it.
-  if (BInfo.first != CaretFileID || EInfo.first != CaretFileID)
+  // If the start or end of the range is in another file, just
+  // discard it.
+  if (SM.getFileID(B) != CaretFileID || SM.getFileID(E) != CaretFileID)
 continue;
 
   // Add in the length of the token, so that we cover multi-char
   // tokens.
   unsigned TokSize = 0;
-  if (IsTokenRange)
+  if (ERange.isTokenRange())
 TokSize = Lexer::MeasureTokenLength(E, SM, LangOpts);
 
   FullSourceLoc BF(B, SM), EF(E, SM);


Index: clang/lib/Frontend/TextDiagnostic.cpp
===
--- clang/lib/Frontend/TextDiagnostic.cpp
+++ clang/lib/Frontend/TextDiagnostic.cpp
@@ -858,30 +858,26 @@
   if (DiagOpts->ShowSourceRanges && !Ranges.empty()) {
 FileID CaretFileID = Loc.getExpansionLoc().getFileID();
 bool PrintedRange = false;
+const SourceManager &SM = Loc.getManager();
 
 for (const auto &R : Ranges) {
   // Ignore invalid ranges.
   if (!R.isValid())
 continue;
 
-  auto &SM = Loc.getManager();
   SourceLocation B = SM.getExpansionLoc(R.getBegin());
   CharSourceRange ERange = SM.getExpansionRange(R.getEnd());
   SourceLocation E = ERange.getEnd();
-  bool IsTokenRange = ERange.isTokenRange();
 
-  std::pair BInfo = SM.getDecomposedLoc(B);
-  std::pair EInfo = SM.getDecomposedLoc(E);
-
-  // If the start or end of the range is in another file, just discard
-  // it.
-  if (BInfo.first != CaretFileID || EInfo.first != CaretFileID)
+  // If the start or end of the range is in another file, just
+  // discard it.
+  if (SM.getFileID(B) != CaretFileID || SM.getFileID(E) != CaretFileID)
 continue;
 
   // Add in the length of the token, so that we cover multi-char
   // tokens.
   unsigned TokSize = 0;
-  if (IsTokenRange)
+  if (ERange.isTokenRange())
 TokSize = Lexer::MeasureTokenLength(E, SM, LangOpts);
 
   FullSourceLoc BF(B, SM), EF(E, SM);
___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[clang] 8f8e450 - [clang] Fix crash on attempt to initialize union with flexible array member

2023-05-22 Thread Mariya Podchishchaeva via cfe-commits

Author: Mariya Podchishchaeva
Date: 2023-05-22T09:32:04-04:00
New Revision: 8f8e450b668219c211284b68c36ba25b3193a2b0

URL: 
https://github.com/llvm/llvm-project/commit/8f8e450b668219c211284b68c36ba25b3193a2b0
DIFF: 
https://github.com/llvm/llvm-project/commit/8f8e450b668219c211284b68c36ba25b3193a2b0.diff

LOG: [clang] Fix crash on attempt to initialize union with flexible array member

Due to missing check on union, there was a null expression
added to init list that caused crash later.

Fixes https://github.com/llvm/llvm-project/issues/61746

Reviewed By: aaron.ballman, shafik

Differential Revision: https://reviews.llvm.org/D150435

Added: 
clang/test/Sema/flexible-array-in-union.c

Modified: 
clang/docs/ReleaseNotes.rst
clang/lib/Sema/SemaInit.cpp

Removed: 




diff  --git a/clang/docs/ReleaseNotes.rst b/clang/docs/ReleaseNotes.rst
index 911bd9eb6435..c80cc8994f38 100644
--- a/clang/docs/ReleaseNotes.rst
+++ b/clang/docs/ReleaseNotes.rst
@@ -418,6 +418,8 @@ Bug Fixes in This Version
 - Propagate the value-dependent bit for VAArgExpr. Fixes a crash where a
   __builtin_va_arg call has invalid arguments.
   (`#62711 `_).
+- Fix crash on attempt to initialize union with flexible array member.
+  (`#61746 `_).
 
 Bug Fixes to Compiler Builtins
 ^^

diff  --git a/clang/lib/Sema/SemaInit.cpp b/clang/lib/Sema/SemaInit.cpp
index 4777f2d37b77..eaddba3e7c75 100644
--- a/clang/lib/Sema/SemaInit.cpp
+++ b/clang/lib/Sema/SemaInit.cpp
@@ -811,7 +811,7 @@ InitListChecker::FillInEmptyInitializations(const 
InitializedEntity &Entity,
   // order to leave them uninitialized, the ILE is expanded and the extra
   // fields are then filled with NoInitExpr.
   unsigned NumElems = numStructUnionElements(ILE->getType());
-  if (RDecl->hasFlexibleArrayMember())
+  if (!RDecl->isUnion() && RDecl->hasFlexibleArrayMember())
 ++NumElems;
   if (!VerifyOnly && ILE->getNumInits() < NumElems)
 ILE->resizeInits(SemaRef.Context, NumElems);

diff  --git a/clang/test/Sema/flexible-array-in-union.c 
b/clang/test/Sema/flexible-array-in-union.c
new file mode 100644
index ..5fabfbe0b1ea
--- /dev/null
+++ b/clang/test/Sema/flexible-array-in-union.c
@@ -0,0 +1,13 @@
+// RUN: %clang_cc1 %s -verify=c -fsyntax-only
+// RUN: %clang_cc1 %s -verify -fsyntax-only -x c++
+// RUN: %clang_cc1 %s -verify -fsyntax-only -fms-compatibility
+// RUN: %clang_cc1 %s -verify -fsyntax-only -fms-compatibility -x c++
+
+// The test checks that an attempt to initialize union with flexible array
+// member with an initializer list doesn't crash clang.
+
+
+union { char x[]; } r = {0}; // c-error {{flexible array member 'x' in a union 
is not allowed}}
+
+// expected-no-diagnostics
+



___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D150435: [clang] Fix crash on attempt to initialize union with flexible array member

2023-05-22 Thread Mariya Podchishchaeva via Phabricator via cfe-commits
This revision was automatically updated to reflect the committed changes.
Closed by commit rG8f8e450b6682: [clang] Fix crash on attempt to initialize 
union with flexible array member (authored by Fznamznon).

Changed prior to commit:
  https://reviews.llvm.org/D150435?vs=523723&id=524278#toc

Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D150435/new/

https://reviews.llvm.org/D150435

Files:
  clang/docs/ReleaseNotes.rst
  clang/lib/Sema/SemaInit.cpp
  clang/test/Sema/flexible-array-in-union.c


Index: clang/test/Sema/flexible-array-in-union.c
===
--- /dev/null
+++ clang/test/Sema/flexible-array-in-union.c
@@ -0,0 +1,13 @@
+// RUN: %clang_cc1 %s -verify=c -fsyntax-only
+// RUN: %clang_cc1 %s -verify -fsyntax-only -x c++
+// RUN: %clang_cc1 %s -verify -fsyntax-only -fms-compatibility
+// RUN: %clang_cc1 %s -verify -fsyntax-only -fms-compatibility -x c++
+
+// The test checks that an attempt to initialize union with flexible array
+// member with an initializer list doesn't crash clang.
+
+
+union { char x[]; } r = {0}; // c-error {{flexible array member 'x' in a union 
is not allowed}}
+
+// expected-no-diagnostics
+
Index: clang/lib/Sema/SemaInit.cpp
===
--- clang/lib/Sema/SemaInit.cpp
+++ clang/lib/Sema/SemaInit.cpp
@@ -811,7 +811,7 @@
   // order to leave them uninitialized, the ILE is expanded and the extra
   // fields are then filled with NoInitExpr.
   unsigned NumElems = numStructUnionElements(ILE->getType());
-  if (RDecl->hasFlexibleArrayMember())
+  if (!RDecl->isUnion() && RDecl->hasFlexibleArrayMember())
 ++NumElems;
   if (!VerifyOnly && ILE->getNumInits() < NumElems)
 ILE->resizeInits(SemaRef.Context, NumElems);
Index: clang/docs/ReleaseNotes.rst
===
--- clang/docs/ReleaseNotes.rst
+++ clang/docs/ReleaseNotes.rst
@@ -418,6 +418,8 @@
 - Propagate the value-dependent bit for VAArgExpr. Fixes a crash where a
   __builtin_va_arg call has invalid arguments.
   (`#62711 `_).
+- Fix crash on attempt to initialize union with flexible array member.
+  (`#61746 `_).
 
 Bug Fixes to Compiler Builtins
 ^^


Index: clang/test/Sema/flexible-array-in-union.c
===
--- /dev/null
+++ clang/test/Sema/flexible-array-in-union.c
@@ -0,0 +1,13 @@
+// RUN: %clang_cc1 %s -verify=c -fsyntax-only
+// RUN: %clang_cc1 %s -verify -fsyntax-only -x c++
+// RUN: %clang_cc1 %s -verify -fsyntax-only -fms-compatibility
+// RUN: %clang_cc1 %s -verify -fsyntax-only -fms-compatibility -x c++
+
+// The test checks that an attempt to initialize union with flexible array
+// member with an initializer list doesn't crash clang.
+
+
+union { char x[]; } r = {0}; // c-error {{flexible array member 'x' in a union is not allowed}}
+
+// expected-no-diagnostics
+
Index: clang/lib/Sema/SemaInit.cpp
===
--- clang/lib/Sema/SemaInit.cpp
+++ clang/lib/Sema/SemaInit.cpp
@@ -811,7 +811,7 @@
   // order to leave them uninitialized, the ILE is expanded and the extra
   // fields are then filled with NoInitExpr.
   unsigned NumElems = numStructUnionElements(ILE->getType());
-  if (RDecl->hasFlexibleArrayMember())
+  if (!RDecl->isUnion() && RDecl->hasFlexibleArrayMember())
 ++NumElems;
   if (!VerifyOnly && ILE->getNumInits() < NumElems)
 ILE->resizeInits(SemaRef.Context, NumElems);
Index: clang/docs/ReleaseNotes.rst
===
--- clang/docs/ReleaseNotes.rst
+++ clang/docs/ReleaseNotes.rst
@@ -418,6 +418,8 @@
 - Propagate the value-dependent bit for VAArgExpr. Fixes a crash where a
   __builtin_va_arg call has invalid arguments.
   (`#62711 `_).
+- Fix crash on attempt to initialize union with flexible array member.
+  (`#61746 `_).
 
 Bug Fixes to Compiler Builtins
 ^^
___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D149162: [Clang][OpenMP][IRBuilder] Move registerTargetGlobalVariable & getAddrOfDeclareTargetVar into the OMPIRBuilder

2023-05-22 Thread Andrew Gozillon via Phabricator via cfe-commits
agozillon updated this revision to Diff 524279.
agozillon added a comment.

Rebase, squash patch history and clang-format to please the buildbot lords


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D149162/new/

https://reviews.llvm.org/D149162

Files:
  clang/lib/CodeGen/CGOpenMPRuntime.cpp
  llvm/include/llvm/Frontend/OpenMP/OMPIRBuilder.h
  llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp
  llvm/unittests/Frontend/OpenMPIRBuilderTest.cpp

Index: llvm/unittests/Frontend/OpenMPIRBuilderTest.cpp
===
--- llvm/unittests/Frontend/OpenMPIRBuilderTest.cpp
+++ llvm/unittests/Frontend/OpenMPIRBuilderTest.cpp
@@ -5855,4 +5855,84 @@
   GlobalValue::WeakAnyLinkage);
   EXPECT_TRUE(InfoManager.hasDeviceGlobalVarEntryInfo("gvar"));
 }
+
+// Tests both registerTargetGlobalVariable and getAddrOfDeclareTargetVar as they
+// call each other (recursively in some cases). The test case test these
+// functions by utilising them for host code generation for declare target
+// global variables
+TEST_F(OpenMPIRBuilderTest, registerTargetGlobalVariable) {
+  OpenMPIRBuilder OMPBuilder(*M);
+  OMPBuilder.initialize();
+  OpenMPIRBuilderConfig Config(false, false, false, false);
+  OMPBuilder.setConfig(Config);
+
+  std::vector TargetTriple;
+  TargetTriple.emplace_back("amdgcn-amd-amdhsa");
+
+  TargetRegionEntryInfo EntryInfo("", 42, 4711, 17);
+  std::vector RefsGathered;
+
+  std::vector Globals;
+  auto *IntTy = Type::getInt32Ty(Ctx);
+  for (int I = 0; I < 2; ++I) {
+Globals.push_back(M->getOrInsertGlobal(
+"test_data_int_" + std::to_string(I), IntTy, [&]() -> GlobalVariable * {
+  return new GlobalVariable(
+  *M, IntTy, false, GlobalValue::LinkageTypes::WeakAnyLinkage,
+  ConstantInt::get(IntTy, I), "test_data_int_" + std::to_string(I));
+}));
+  }
+
+  OMPBuilder.registerTargetGlobalVariable(
+  OffloadEntriesInfoManager::OMPTargetGlobalVarEntryTo,
+  OffloadEntriesInfoManager::OMPTargetDeviceClauseAny, false, true,
+  EntryInfo, Globals[0]->getName(), RefsGathered, false, TargetTriple,
+  nullptr, nullptr, Globals[0]->getType(), Globals[0]);
+
+  OMPBuilder.registerTargetGlobalVariable(
+  OffloadEntriesInfoManager::OMPTargetGlobalVarEntryLink,
+  OffloadEntriesInfoManager::OMPTargetDeviceClauseAny, false, true,
+  EntryInfo, Globals[1]->getName(), RefsGathered, false, TargetTriple,
+  nullptr, nullptr, Globals[1]->getType(), Globals[1]);
+
+  llvm::OpenMPIRBuilder::EmitMetadataErrorReportFunctionTy &&ErrorReportfn =
+  [](llvm::OpenMPIRBuilder::EmitMetadataErrorKind Kind,
+ const llvm::TargetRegionEntryInfo &EntryInfo) -> void {
+// If this is invoked, then we want to emit an error, even if it is not
+// neccesarily the most readable, as something has went wrong. The
+// test-suite unfortunately eats up all error output
+ASSERT_EQ(Kind, Kind);
+  };
+
+  OMPBuilder.createOffloadEntriesAndInfoMetadata(ErrorReportfn);
+
+  // Clauses for data_int_0 with To + Any clauses for the host
+  std::vector OffloadEntries;
+  OffloadEntries.push_back(M->getNamedGlobal(".omp_offloading.entry_name"));
+  OffloadEntries.push_back(
+  M->getNamedGlobal(".omp_offloading.entry.test_data_int_0"));
+
+  // Clauses for data_int_1 with Link + Any clauses for the host
+  OffloadEntries.push_back(
+  M->getNamedGlobal("test_data_int_1_decl_tgt_ref_ptr"));
+  OffloadEntries.push_back(M->getNamedGlobal(".omp_offloading.entry_name.1"));
+  OffloadEntries.push_back(M->getNamedGlobal(
+  ".omp_offloading.entry.test_data_int_1_decl_tgt_ref_ptr"));
+
+  for (unsigned I = 0; I < OffloadEntries.size(); ++I)
+EXPECT_NE(OffloadEntries[I], nullptr);
+
+  // Metadata generated for the host offload module
+  NamedMDNode *OffloadMetadata = M->getNamedMetadata("omp_offload.info");
+  EXPECT_NE(OffloadMetadata, nullptr);
+  if (OffloadMetadata) {
+EXPECT_EQ(OffloadMetadata->getOperand(0)->getOperand(1).equalsStr(
+  "test_data_int_0"),
+  true);
+EXPECT_EQ(OffloadMetadata->getOperand(1)->getOperand(1).equalsStr(
+  "test_data_int_1_decl_tgt_ref_ptr"),
+  true);
+  }
+}
+
 } // namespace
Index: llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp
===
--- llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp
+++ llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp
@@ -33,6 +33,7 @@
 #include "llvm/IR/Value.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Support/CommandLine.h"
+#include "llvm/Support/FileSystem.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Target/TargetOptions.h"
 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
@@ -5130,7 +5131,8 @@
   static_cast(
   CE->getFlags());
   switch (Flags) {
-  case OffloadEntriesInfoManager::OMPTargetGlobalVarEntryTo: {
+  case OffloadEn

[PATCH] D151094: [clang][wip] Implement P2564 "consteval must propagate up"

2023-05-22 Thread Corentin Jabot via Phabricator via cfe-commits
cor3ntin created this revision.
Herald added a project: All.
cor3ntin requested review of this revision.
Herald added a project: clang.
Herald added a subscriber: cfe-commits.

Repository:
  rG LLVM Github Monorepo

https://reviews.llvm.org/D151094

Files:
  clang/docs/ReleaseNotes.rst
  clang/include/clang/AST/Decl.h
  clang/include/clang/AST/DeclBase.h
  clang/include/clang/Basic/DiagnosticSemaKinds.td
  clang/include/clang/Sema/ScopeInfo.h
  clang/include/clang/Sema/Sema.h
  clang/lib/AST/Decl.cpp
  clang/lib/AST/VTableBuilder.cpp
  clang/lib/CodeGen/CodeGenModule.cpp
  clang/lib/Frontend/InitPreprocessor.cpp
  clang/lib/Parse/ParseDecl.cpp
  clang/lib/Parse/ParseDeclCXX.cpp
  clang/lib/Sema/ScopeInfo.cpp
  clang/lib/Sema/SemaDecl.cpp
  clang/lib/Sema/SemaDeclCXX.cpp
  clang/lib/Sema/SemaExpr.cpp
  clang/lib/Sema/SemaLambda.cpp
  clang/lib/Sema/SemaStmt.cpp
  clang/lib/Sema/SemaTemplateDeduction.cpp
  clang/test/CodeGenCXX/cxx20-consteval-crash.cpp
  clang/test/SemaCXX/cxx2a-consteval-default-params.cpp
  clang/test/SemaCXX/cxx2a-consteval.cpp
  clang/test/SemaCXX/cxx2b-consteval-propagate.cpp
  clang/www/cxx_status.html

Index: clang/www/cxx_status.html
===
--- clang/www/cxx_status.html
+++ clang/www/cxx_status.html
@@ -363,7 +363,7 @@
 
   consteval needs to propagate up
   https://wg21.link/P2564R3";>P2564R3 (DR)
-  No
+  Clang 17
 
 
   Lifetime extension in range-based for loops
Index: clang/test/SemaCXX/cxx2b-consteval-propagate.cpp
===
--- /dev/null
+++ clang/test/SemaCXX/cxx2b-consteval-propagate.cpp
@@ -0,0 +1,130 @@
+
+// RUN: %clang_cc1 -std=c++2a -emit-llvm-only -Wno-unused-value %s -verify
+// RUN: %clang_cc1 -std=c++2b -emit-llvm-only -Wno-unused-value %s -verify
+
+consteval int id(int i) { return i; }
+constexpr char id(char c) { return c; }
+
+namespace examples {
+
+template 
+constexpr int f(T t) { // expected-note {{declared here}}
+return t + id(t);
+}
+auto a = &f; // ok, f is not an immediate function
+auto b = &f;  // expected-error {{cannot take address of immediate function 'f' outside of an immediate invocation}}
+
+static_assert(f(3) == 6); // ok
+
+template 
+constexpr int g(T t) {// g is not an immediate function
+return t + id(42);// because id(42) is already a constant
+}
+
+template 
+constexpr bool is_not(T t, F f) {
+return not f(t);
+}
+
+consteval bool is_even(int i) { return i % 2 == 0; }
+
+static_assert(is_not(5, is_even));
+
+int x = 0; // expected-note {{declared here}}
+
+template 
+constexpr T h(T t = id(x)) { // expected-note {{read of non-const variable 'x' is not allowed in a constant expression}}
+return t;
+}
+
+template 
+constexpr T hh() {   // hh is an immediate function
+return h();
+}
+
+int i = hh(); // expected-error {{call to consteval function 'examples::hh' is not a constant expression}} \
+   // expected-note {{in call to 'hh()'}}
+
+struct A {
+  int x;
+  int y = id(x);
+};
+
+template 
+constexpr int k(int) {
+  return A(42).y;
+}
+
+}
+
+namespace e2{
+template 
+constexpr int f(T t);
+auto a = &f;
+auto b = &f;
+}
+
+namespace forward_declare_constexpr{
+template 
+constexpr int f(T t);
+
+auto a = &f;
+auto b = &f;
+
+template 
+constexpr int f(T t) {
+return id(0);
+}
+}
+
+namespace forward_declare_consteval{
+template 
+constexpr int f(T t);  // expected-note {{'f' defined here}}
+
+auto a = &f;
+auto b = &f; // expected-error {{immediate function 'f' used before it is defined}} \
+  // expected-note {{in instantiation of function template specialization}}
+
+template 
+constexpr int f(T t) {
+return id(t); // expected-note {{'f' is an immediate function because its body contains a call to a consteval function 'id' and that call is not a constant expression}}
+}
+}
+
+namespace constructors {
+consteval int f(int) {
+  return 0;
+}
+struct S {
+  constexpr S(auto i) {
+f(i);
+  }
+};
+constexpr void g(auto i) {
+  [[maybe_unused]] S s{i};
+}
+void test() {
+  g(0);
+}
+}
+
+namespace aggregate {
+consteval int f(int);
+struct S{
+int a = 0;
+int b = f(a);
+};
+
+constexpr bool test(auto i) {
+S s{i};
+return s.b == 2 *i;
+}
+consteval int f(int i) {
+return 2 * i;
+}
+
+void test() {
+static_assert(test(42));
+}
+
+}
Index: clang/test/SemaCXX/cxx2a-consteval.cpp
===
--- clang/test/SemaCXX/cxx2a-consteval.cpp
+++ clang/test/SemaCXX/cxx2a-consteval.cpp
@@ -250,14 +250,14 @@
   return f(i);
 };
 
-auto l1 = [](int i) constexpr {
-// expected-note@-1 {{declared here}}
+auto l1 = [](int i) constexpr { // expected-error{{cannot take address of immediate call operator}} \
+// expected-note {{declared here}}
   int t = f(i);
-// expected-error@-1 {{is not a constant expression}}
-// expecte

[PATCH] D151087: [Clang] Permit address space casts with 'reinterpret_cast' in C++

2023-05-22 Thread Bevin Hansson via Phabricator via cfe-commits
ebevhan added a comment.

What would be the semantics of such an operation if the address spaces are 
disjoint? Or, if the underlying pointer widths aren't the same?


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D151087/new/

https://reviews.llvm.org/D151087

___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D151092: [clang-tidy]performance-no-automatic-move: fix false negative on `const T&&` ctors.

2023-05-22 Thread Eugene Zelenko via Phabricator via cfe-commits
Eugene.Zelenko added inline comments.



Comment at: clang-tools-extra/docs/ReleaseNotes.rst:385
+- Improved :doc:`performance-no-automatic-move
+  `: warn on 
`const &&`
+  constructors.

Please use double back-ticks for `const &&`.



Comment at: 
clang-tools-extra/test/clang-tidy/checkers/performance/no-automatic-move.cpp:118
 }
+

Is it really needed?


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D151092/new/

https://reviews.llvm.org/D151092

___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D151087: [Clang] Permit address space casts with 'reinterpret_cast' in C++

2023-05-22 Thread Joseph Huber via Phabricator via cfe-commits
jhuber6 added a comment.

In D151087#4360577 , @ebevhan wrote:

> What would be the semantics of such an operation if the address spaces are 
> disjoint? Or, if the underlying pointer widths aren't the same?

It would most likely invalid, but I'm not asserting that `clang` should be 
responsible for diagnosing misuse in these cases. Especially because in generic 
freestanding C++ we don't have any language options to suggest the actual 
semantics.


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D151087/new/

https://reviews.llvm.org/D151087

___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D151092: [clang-tidy]performance-no-automatic-move: fix false negative on `const T&&` ctors.

2023-05-22 Thread Clement Courbet via Phabricator via cfe-commits
courbet updated this revision to Diff 524288.
courbet marked 2 inline comments as done.
courbet added a comment.

address review comments


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D151092/new/

https://reviews.llvm.org/D151092

Files:
  clang-tools-extra/clang-tidy/performance/NoAutomaticMoveCheck.cpp
  clang-tools-extra/docs/ReleaseNotes.rst
  clang-tools-extra/test/clang-tidy/checkers/performance/no-automatic-move.cpp

Index: clang-tools-extra/test/clang-tidy/checkers/performance/no-automatic-move.cpp
===
--- clang-tools-extra/test/clang-tidy/checkers/performance/no-automatic-move.cpp
+++ clang-tools-extra/test/clang-tidy/checkers/performance/no-automatic-move.cpp
@@ -7,30 +7,42 @@
   virtual ~Obj();
 };
 
-template 
-struct StatusOr {
-  StatusOr(const T &);
-  StatusOr(T &&);
-};
-
 struct NonTemplate {
   NonTemplate(const Obj &);
   NonTemplate(Obj &&);
 };
 
+template  struct TemplateCtorPair {
+  TemplateCtorPair(const T &);
+  TemplateCtorPair(T &&value);
+};
+
+template  struct UrefCtor {
+  template  UrefCtor(U &&value);
+};
+
 template 
 T Make();
 
-StatusOr PositiveStatusOrConstValue() {
+NonTemplate PositiveNonTemplate() {
   const Obj obj = Make();
-  return obj;
-  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: constness of 'obj' prevents automatic move [performance-no-automatic-move]
+  return obj; // selects `NonTemplate(const Obj&)`
+  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: constness of 'obj' prevents
+  // automatic move [performance-no-automatic-move]
 }
 
-NonTemplate PositiveNonTemplateConstValue() {
+TemplateCtorPair PositiveTemplateCtorPair() {
   const Obj obj = Make();
-  return obj;
-  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: constness of 'obj' prevents automatic move [performance-no-automatic-move]
+  return obj; // selects `TemplateCtorPair(const T&)`
+  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: constness of 'obj' prevents
+  // automatic move [performance-no-automatic-move]
+}
+
+UrefCtor PositiveUrefCtor() {
+  const Obj obj = Make();
+  return obj; // selects `UrefCtor(const T&&)`
+  // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: constness of 'obj' prevents
+  // automatic move [performance-no-automatic-move]
 }
 
 Obj PositiveCantNrvo(bool b) {
@@ -51,22 +63,18 @@
 }
 
 // FIXME: Ideally we would warn here too.
-StatusOr PositiveStatusOrLifetimeExtension() {
+UrefCtor PositiveUrefCtorLifetimeExtension() {
   const Obj &obj = Make();
   return obj;
 }
 
 // Negatives.
 
-StatusOr Temporary() {
-  return Make();
-}
+UrefCtor Temporary() { return Make(); }
 
-StatusOr ConstTemporary() {
-  return Make();
-}
+UrefCtor ConstTemporary() { return Make(); }
 
-StatusOr ConvertingMoveConstructor() {
+UrefCtor ConvertingMoveConstructor() {
   Obj obj = Make();
   return obj;
 }
@@ -85,21 +93,19 @@
   return obj2;
 }
 
-StatusOr Ref() {
+UrefCtor Ref() {
   Obj &obj = Make();
   return obj;
 }
 
-StatusOr ConstRef() {
+UrefCtor ConstRef() {
   const Obj &obj = Make();
   return obj;
 }
 
 const Obj global;
 
-StatusOr Global() {
-  return global;
-}
+UrefCtor Global() { return global; }
 
 struct FromConstRefOnly {
   FromConstRefOnly(const Obj &);
Index: clang-tools-extra/docs/ReleaseNotes.rst
===
--- clang-tools-extra/docs/ReleaseNotes.rst
+++ clang-tools-extra/docs/ReleaseNotes.rst
@@ -381,6 +381,10 @@
   ` when warning would be
   emitted for a const local variable to which NRVO is applied.
 
+- Improved :doc:`performance-no-automatic-move
+  `: warn on ``const &&``
+  constructors.
+
 Removed checks
 ^^
 
Index: clang-tools-extra/clang-tidy/performance/NoAutomaticMoveCheck.cpp
===
--- clang-tools-extra/clang-tidy/performance/NoAutomaticMoveCheck.cpp
+++ clang-tools-extra/clang-tidy/performance/NoAutomaticMoveCheck.cpp
@@ -48,15 +48,23 @@
   hasParameter(0, hasType(rValueReferenceType(
   pointee(type(equalsBoundNode("SrcT")));
 
+  // A matcher for `DstT::DstT(const Src&&)`, which typically comes from an
+  // instantiation of `template  DstT::DstT(U&&)`.
+  const auto ConstRefRefCtor = cxxConstructorDecl(
+  parameterCountIs(1),
+  hasParameter(0,
+   hasType(rValueReferenceType(pointee(isConstQualified());
+
   Finder->addMatcher(
-  traverse(TK_AsIs,
-   returnStmt(hasReturnValue(
-   ignoringElidableConstructorCall(ignoringParenImpCasts(
-   cxxConstructExpr(
-   hasDeclaration(LValueRefCtor),
-   hasArgument(0, ignoringParenImpCasts(declRefExpr(
-  to(NonNrvoConstLocalVariable)
-   .bind("ctor_call")),
+  traverse(
+  TK_AsIs,
+  returnStmt(hasReturn

[PATCH] D151098: [Clang][Docs] Add help test to `-march` and `-mcpu` to suggest `-mcpu=help`

2023-05-22 Thread Joseph Huber via Phabricator via cfe-commits
jhuber6 created this revision.
jhuber6 added reviewers: MaskRay, aaron.ballman.
Herald added a project: All.
jhuber6 requested review of this revision.
Herald added a project: clang.
Herald added a subscriber: cfe-commits.

Currently there is no documentation for these flags, users might find it
confusing to know which values are permitted. This change simply adds
documentation to suggest using `-mcpu=help` to list the availible target
names.


Repository:
  rG LLVM Github Monorepo

https://reviews.llvm.org/D151098

Files:
  clang/include/clang/Driver/Options.td


Index: clang/include/clang/Driver/Options.td
===
--- clang/include/clang/Driver/Options.td
+++ clang/include/clang/Driver/Options.td
@@ -3494,7 +3494,8 @@
 def mwatchos_version_min_EQ : Joined<["-"], "mwatchos-version-min=">, 
Group;
 def mwatchos_simulator_version_min_EQ : Joined<["-"], 
"mwatchos-simulator-version-min=">;
 def mwatchsimulator_version_min_EQ : Joined<["-"], 
"mwatchsimulator-version-min=">, Alias;
-def march_EQ : Joined<["-"], "march=">, Group, Flags<[CoreOption]>;
+def march_EQ : Joined<["-"], "march=">, Group, Flags<[CoreOption]>,
+  HelpText<"For a list of availible architectures for the target use 
'-mcpu=help'">;
 def masm_EQ : Joined<["-"], "masm=">, Group, Flags<[NoXarchOption]>;
 def inline_asm_EQ : Joined<["-"], "inline-asm=">, Group, 
Flags<[CC1Option]>,
   Values<"att,intel">,
@@ -3518,7 +3519,8 @@
 def mguard_EQ : Joined<["-"], "mguard=">, Group, 
Flags<[NoXarchOption]>,
   HelpText<"Enable or disable Control Flow Guard checks and guard tables 
emission">,
   Values<"none,cf,cf-nochecks">;
-def mcpu_EQ : Joined<["-"], "mcpu=">, Group;
+def mcpu_EQ : Joined<["-"], "mcpu=">, Group, 
+  HelpText<"For a list of availible CPUs for the target use '-mcpu=help'">;
 def mmcu_EQ : Joined<["-"], "mmcu=">, Group;
 def msim : Flag<["-"], "msim">, Group;
 def mdynamic_no_pic : Joined<["-"], "mdynamic-no-pic">, Group;


Index: clang/include/clang/Driver/Options.td
===
--- clang/include/clang/Driver/Options.td
+++ clang/include/clang/Driver/Options.td
@@ -3494,7 +3494,8 @@
 def mwatchos_version_min_EQ : Joined<["-"], "mwatchos-version-min=">, Group;
 def mwatchos_simulator_version_min_EQ : Joined<["-"], "mwatchos-simulator-version-min=">;
 def mwatchsimulator_version_min_EQ : Joined<["-"], "mwatchsimulator-version-min=">, Alias;
-def march_EQ : Joined<["-"], "march=">, Group, Flags<[CoreOption]>;
+def march_EQ : Joined<["-"], "march=">, Group, Flags<[CoreOption]>,
+  HelpText<"For a list of availible architectures for the target use '-mcpu=help'">;
 def masm_EQ : Joined<["-"], "masm=">, Group, Flags<[NoXarchOption]>;
 def inline_asm_EQ : Joined<["-"], "inline-asm=">, Group, Flags<[CC1Option]>,
   Values<"att,intel">,
@@ -3518,7 +3519,8 @@
 def mguard_EQ : Joined<["-"], "mguard=">, Group, Flags<[NoXarchOption]>,
   HelpText<"Enable or disable Control Flow Guard checks and guard tables emission">,
   Values<"none,cf,cf-nochecks">;
-def mcpu_EQ : Joined<["-"], "mcpu=">, Group;
+def mcpu_EQ : Joined<["-"], "mcpu=">, Group, 
+  HelpText<"For a list of availible CPUs for the target use '-mcpu=help'">;
 def mmcu_EQ : Joined<["-"], "mmcu=">, Group;
 def msim : Flag<["-"], "msim">, Group;
 def mdynamic_no_pic : Joined<["-"], "mdynamic-no-pic">, Group;
___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D151040: [NFC][CLANG] Fix static code analyzer concerns

2023-05-22 Thread Soumi Manna via Phabricator via cfe-commits
Manna updated this revision to Diff 524291.
Manna added a comment.

Thank you @erichkeane for reviews. I have updated patch to avoid regression if 
the LValue doesn't evaluate right.


CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D151040/new/

https://reviews.llvm.org/D151040

Files:
  clang/lib/AST/ExprConstant.cpp


Index: clang/lib/AST/ExprConstant.cpp
===
--- clang/lib/AST/ExprConstant.cpp
+++ clang/lib/AST/ExprConstant.cpp
@@ -10174,6 +10174,8 @@
   if (!EvaluateLValue(E->getSubExpr(), Array, Info))
 return false;
 
+  assert(ArrayType && "unexpected type for array initializer");
+
   // Get a pointer to the first element of the array.
   Array.addArray(Info, E, ArrayType);
 


Index: clang/lib/AST/ExprConstant.cpp
===
--- clang/lib/AST/ExprConstant.cpp
+++ clang/lib/AST/ExprConstant.cpp
@@ -10174,6 +10174,8 @@
   if (!EvaluateLValue(E->getSubExpr(), Array, Info))
 return false;
 
+  assert(ArrayType && "unexpected type for array initializer");
+
   // Get a pointer to the first element of the array.
   Array.addArray(Info, E, ArrayType);
 
___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D146418: Support for OpenMP 5.0 sec 2.12.7 - Declare Target initializer expressions

2023-05-22 Thread Ritanya via Phabricator via cfe-commits
RitanyaB updated this revision to Diff 524290.

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D146418/new/

https://reviews.llvm.org/D146418

Files:
  clang/include/clang/Sema/Sema.h
  clang/lib/Sema/SemaDecl.cpp
  clang/lib/Sema/SemaOpenMP.cpp
  clang/test/OpenMP/declare_target_messages.cpp
  clang/test/OpenMP/declare_target_variables_ast_print.cpp
  clang/test/OpenMP/nvptx_target_exceptions_messages.cpp

Index: clang/test/OpenMP/nvptx_target_exceptions_messages.cpp
===
--- clang/test/OpenMP/nvptx_target_exceptions_messages.cpp
+++ clang/test/OpenMP/nvptx_target_exceptions_messages.cpp
@@ -95,7 +95,7 @@
 int (*D)() = C; // expected-note {{used here}}
 // host-note@-1 {{used here}}
 #pragma omp end declare target
-int foobar3() { throw 1; }
+int foobar3() { throw 1; } // expected-error {{cannot use 'throw' with exceptions disabled}}
 
 // Check no infinite recursion in deferred diagnostic emitter.
 long E = (long)&E;
Index: clang/test/OpenMP/declare_target_variables_ast_print.cpp
===
--- /dev/null
+++ clang/test/OpenMP/declare_target_variables_ast_print.cpp
@@ -0,0 +1,111 @@
+// RUN: %clang_cc1 -w -verify -fopenmp -I %S/Inputs -ast-print %s | FileCheck %s --check-prefix=CHECK
+// expected-no-diagnostics
+
+static int variable = 100; 
+static float variable1 = 200;
+static float variable2 = variable1; 
+
+static int var = 1;
+
+static int var1 = 10;
+static int *var2 = &var1;
+static int **ptr1 = &var2;
+
+int arr[2] = {1,2};
+int (*arrptr)[2] = &arr;
+
+class declare{
+  public: int x;
+  void print();
+};
+declare obj1;
+declare *obj2 = &obj1;
+
+struct target{
+  int x;
+  void print();
+};
+static target S;
+
+#pragma omp declare target
+int target_var = variable;
+float target_var1 = variable2;
+int *ptr = &var;
+int ***ptr2 = &ptr1;
+int (**ptr3)[2] = &arrptr;
+declare **obj3 = &obj2;
+target *S1 = &S;
+#pragma omp end declare target
+// CHECK: #pragma omp declare target
+// CHECK-NEXT: static int variable = 100;
+// CHECK-NEXT: #pragma omp end declare target
+
+// CHECK-NEXT: #pragma omp declare target
+// CHECK-NEXT: static float variable1 = 200;
+// CHECK-NEXT: #pragma omp end declare target
+// CHECK-NEXT: #pragma omp declare target
+// CHECK-NEXT: static float variable2 = variable1;
+// CHECK-NEXT: #pragma omp end declare target
+
+// CHECK: #pragma omp declare target
+// CHECK-NEXT: static int var = 1;
+// CHECK-NEXT: #pragma omp end declare target
+
+// CHECK-NEXT: #pragma omp declare target
+// CHECK-NEXT: static int var1 = 10;
+// CHECK-NEXT: #pragma omp end declare target
+// CHECK-NEXT: #pragma omp declare target
+// CHECK-NEXT: static int *var2 = &var1;
+// CHECK-NEXT: #pragma omp end declare target
+// CHECK-NEXT: #pragma omp declare target
+// CHECK-NEXT: static int **ptr1 = &var2;
+// CHECK-NEXT: #pragma omp end declare target
+
+// CHECK-NEXT: #pragma omp declare target
+// CHECK-NEXT: int arr[2] = {1, 2};
+// CHECK-NEXT: #pragma omp end declare target
+// CHECK-NEXT: #pragma omp declare target
+// CHECK-NEXT: int (*arrptr)[2] = &arr;
+// CHECK-NEXT: #pragma omp end declare target
+
+// CHECK-NEXT: class declare {
+// CHECK-NEXT: public: 
+// CHECK-NEXT:  int x;
+// CHECK-NEXT:  void print();
+// CHECK-NEXT: };
+// CHECK-NEXT: #pragma omp declare target
+// CHECK-NEXT: declare obj1;
+// CHECK-NEXT: #pragma omp end declare target
+// CHECK-NEXT: #pragma omp declare target
+// CHECK-NEXT: declare *obj2 = &obj1;
+// CHECK-NEXT: #pragma omp end declare target
+
+// CHECK-NEXT: struct target {
+// CHECK-NEXT:  int x;
+// CHECK-NEXT:  void print();
+// CHECK-NEXT: };
+// CHECK-NEXT: #pragma omp declare target
+// CHECK-NEXT: static target S;
+// CHECK-NEXT: #pragma omp end declare target
+
+// CHECK-NEXT: #pragma omp declare target
+// CHECK-NEXT: int target_var = variable;
+// CHECK-NEXT: #pragma omp end declare target
+// CHECK-NEXT: #pragma omp declare target
+// CHECK-NEXT: float target_var1 = variable2;
+// CHECK-NEXT: #pragma omp end declare target
+// CHECK-NEXT: #pragma omp declare target
+// CHECK-NEXT: int *ptr = &var;
+// CHECK-NEXT: #pragma omp end declare target
+// CHECK-NEXT: #pragma omp declare target
+// CHECK-NEXT: int ***ptr2 = &ptr1;
+// CHECK-NEXT: #pragma omp end declare target
+// CHECK-NEXT: #pragma omp declare target
+// CHECK-NEXT: int (**ptr3)[2] = &arrptr;
+// CHECK-NEXT: #pragma omp end declare target
+// CHECK-NEXT: #pragma omp declare target
+// CHECK-NEXT: declare **obj3 = &obj2; 
+// CHECK-NEXT: #pragma omp end declare target
+// CHECK-NEXT: #pragma omp declare target
+// CHECK-NEXT: target *S1 = &S;
+// CHECK-NEXT: #pragma omp end declare target
Index: clang/test/OpenMP/declare_target_messages.cpp
===
--- clang/test/OpenMP/declare_target_messages.cpp
+++ clang/test/OpenMP/declare_target_messages.cpp
@@ -233,6 +233,42 @@
 #pragma omp declar

[PATCH] D151094: [clang][wip] Implement P2564 "consteval must propagate up"

2023-05-22 Thread Aaron Ballman via Phabricator via cfe-commits
aaron.ballman added inline comments.



Comment at: clang/include/clang/AST/DeclBase.h:1695
   /// Number of non-inherited bits in FunctionDeclBitfields.
   enum { NumFunctionDeclBits = 29 };
 

Need to update this as well.



Comment at: clang/include/clang/Sema/ScopeInfo.h:239
 
+  /// Whether we found an immediate-escalating expression
+  Expr *ImmediateEscalatingExpression = nullptr;





Comment at: clang/lib/AST/Decl.cpp:3180
+  // consteval specifier,
+  if (isDefaulted() && !isConsteval())
+return true;

Should this be looking at `isExplicitlyDefaulted()` instead?



Comment at: clang/lib/AST/Decl.cpp:3184
+  // defined with the constexpr specifier.
+  auto TK = getTemplatedKind();
+  if ((TK != TK_NonTemplate && TK != TK_DependentNonTemplate) &&

Spell out the type.



Comment at: clang/lib/AST/Decl.cpp:3185
+  auto TK = getTemplatedKind();
+  if ((TK != TK_NonTemplate && TK != TK_DependentNonTemplate) &&
+  isConstexprSpecified())





Comment at: clang/lib/AST/Decl.cpp:3199
+  // immediate-escalating expression
+  if (auto *MD = dyn_cast(this);
+  MD && MD->isLambdaStaticInvoker())

This code doesn't seem to match the comment (it matches the code below though).



Comment at: clang/lib/AST/Decl.cpp:3203-3205
+  if (isImmediateEscalating() && BodyContainsImmediateEscalatingExpressions())
+return true;
+  return false;





Comment at: clang/lib/Sema/SemaDeclCXX.cpp:2453
+  Diag(FD->getLocation(), diag::note_defined_here) << FD;
+  if (auto *CE = llvm::dyn_cast(
+  ImmediateEscalatingExpression->IgnoreImplicit())) {





Comment at: clang/lib/Sema/SemaExpr.cpp:17983
+  if (!E.get()->isValueDependent() &&
+  !E.get()->isCXX11ConstantExpr(getASTContext()) &&
+  ExprEvalContexts.back().InImmediateEscalatingFunctionContext &&

Ouch, this is pretty expensive because it actually evaluates the constant 
expression (and promptly forgets what it evaluated).



Comment at: clang/lib/Sema/SemaTemplateDeduction.cpp:5027-5029
+if (CallOp->isInvalidDecl())
+  return true;
+return false;




Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D151094/new/

https://reviews.llvm.org/D151094

___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D151087: [Clang] Permit address space casts with 'reinterpret_cast' in C++

2023-05-22 Thread Matt Arsenault via Phabricator via cfe-commits
arsenm added a comment.

In D151087#4360606 , @jhuber6 wrote:

> In D151087#4360577 , @ebevhan wrote:
>
>> What would be the semantics of such an operation if the address spaces are 
>> disjoint? Or, if the underlying pointer widths aren't the same?
>
> It would most likely invalid, but I'm not asserting that `clang` should be 
> responsible for diagnosing misuse in these cases. Especially because in 
> generic freestanding C++ we don't have any language options to suggest the 
> actual semantics.

If the pointer sizes don’t match I think it has to be rejected since it’s no 
longer a pure bitcast


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D151087/new/

https://reviews.llvm.org/D151087

___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D146418: Support for OpenMP 5.0 sec 2.12.7 - Declare Target initializer expressions

2023-05-22 Thread Alexey Bataev via Phabricator via cfe-commits
ABataev added inline comments.



Comment at: clang/lib/Sema/SemaDecl.cpp:14475-14477
+  VD->hasGlobalStorage()) {
+ActOnOpenMPDeclareTargetInitializer(D);
+  }

Remove braces



Comment at: clang/lib/Sema/SemaOpenMP.cpp:23091
 
+class GlobalDeclRefChecker final
+: public ConstStmtVisitor {

Please, add comments, describing the class and its functionality



Comment at: clang/lib/Sema/SemaOpenMP.cpp:23095
+  Decl *TargetDecl;
+  void SetTargetDecl(Decl *TD) { TargetDecl = TD; }
+  bool CheckDeclVector() { return DeclVector.empty(); }

setTargetDecl



Comment at: clang/lib/Sema/SemaOpenMP.cpp:23096
+  void SetTargetDecl(Decl *TD) { TargetDecl = TD; }
+  bool CheckDeclVector() { return DeclVector.empty(); }
+  void pushDecl(VarDecl *TargetVarDecl) { DeclVector.push_back(TargetVarDecl); 
}

1. checkDeclVector
2. const member function



Comment at: clang/lib/Sema/SemaOpenMP.cpp:23098
+  void pushDecl(VarDecl *TargetVarDecl) { DeclVector.push_back(TargetVarDecl); 
}
+  VarDecl *popDecl() { return DeclVector.pop_back_val(); }
+

const member function



Comment at: clang/lib/Sema/SemaOpenMP.cpp:23104
+  VD->addAttr(this->TargetDecl->getAttr());
+  this->pushDecl(VD);
+}

Remove this->



Comment at: clang/lib/Sema/SemaOpenMP.cpp:23113
+  }
+  void DeclTargetInitializer(Decl *TD) {
+SetTargetDecl(TD);

1. Better to make it static member function.
2. Follow the rules for function names.


CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D146418/new/

https://reviews.llvm.org/D146418

___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


[PATCH] D151094: [clang][wip] Implement P2564 "consteval must propagate up"

2023-05-22 Thread Timm Bäder via Phabricator via cfe-commits
tbaeder added inline comments.



Comment at: clang/include/clang/AST/Decl.h:2391
+
+  bool isImmediateFunction() const;
+

Some documentation on the new API would be useful; seems like most calls to 
`isConsteval()` should be using `isImmediateFunction()` instead?


Repository:
  rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D151094/new/

https://reviews.llvm.org/D151094

___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits


  1   2   3   >