Merge from 'master' to 'sycl-web' (#2)

  CONFLICT (content): Merge conflict in clang/include/clang/Basic/DiagnosticSemaKinds.td

Author: Valery N Dmitriev

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -10830,8 +10830,61 @@ def err_matrix_separate_incomplete_index: Error<
   "matrix row and column subscripts cannot be separated by any expression">;
 def err_matrix_subscript_comma: Error<
   "comma expressions are not allowed as indices in matrix subscript expressions">;
+def err_builtin_matrix_arg: Error<"1st argument must be a matrix">;
+def err_builtin_matrix_scalar_unsigned_arg: Error<
+  "%0 argument must be a constant unsigned integer expression">;
+def err_builtin_matrix_pointer_arg: Error<
+  "%ordinal0 argument must be a pointer to a valid matrix element type">;
+def err_builtin_matrix_pointer_arg_mismatch: Error<
+  "the pointee of the 2nd argument must match the element type of the 1st argument (%0 != %1)">;
+def err_builtin_matrix_store_to_const: Error<
+  "cannot store matrix to read-only pointer">;
+def err_builtin_matrix_stride_too_small: Error<
+  "stride must be greater or equal to the number of rows">;
+def err_builtin_matrix_invalid_dimension: Error<
+  "%0 dimension is outside the allowed range [1, %1]">;
+
+def warn_mismatched_import : Warning<
+  "import %select{module|name}0 (%1) does not match the import %select{module|name}0 (%2) of the "
+  "previous declaration">,
+  InGroup<IgnoredAttributes>;
+def warn_import_on_definition : Warning<
+  "import %select{module|name}0 cannot be applied to a function with a definition">,
+  InGroup<IgnoredAttributes>;
+
+def err_preserve_field_info_not_field : Error<
+  "__builtin_preserve_field_info argument %0 not a field access">;
+def err_preserve_field_info_not_const: Error<
+  "__builtin_preserve_field_info argument %0 not a constant">;
+def err_btf_type_id_not_const: Error<
+  "__builtin_btf_type_id argument %0 not a constant">;
+
+def err_bit_cast_non_trivially_copyable : Error<
+  "__builtin_bit_cast %select{source|destination}0 type must be trivially copyable">;
+def err_bit_cast_type_size_mismatch : Error<
+  "__builtin_bit_cast source size does not equal destination size (%0 vs %1)">;
 
 // SYCL-specific diagnostics
+def warn_sycl_kernel_num_of_template_params : Warning<
+  "'sycl_kernel' attribute only applies to a function template with at least"
+  " two template parameters">, InGroup<IgnoredAttributes>;
+def warn_sycl_kernel_invalid_template_param_type : Warning<
+  "template parameter of a function template with the 'sycl_kernel' attribute"
+  " cannot be a non-type template parameter">, InGroup<IgnoredAttributes>;
+def warn_sycl_kernel_num_of_function_params : Warning<
+  "function template with 'sycl_kernel' attribute must have a single parameter">,
+  InGroup<IgnoredAttributes>;
+def warn_sycl_kernel_return_type : Warning<
+  "function template with 'sycl_kernel' attribute must have a 'void' return type">,
+  InGroup<IgnoredAttributes>;
+
+def err_ext_int_bad_size : Error<"%select{signed|unsigned}0 _ExtInt must "
+                                 "have a bit size of at least %select{2|1}0">;
+def err_ext_int_max_size : Error<"%select{signed|unsigned}0 _ExtInt of bit "
+                                 "sizes greater than %1 not supported">;
+def err_esimd_glob_cant_init : Error<
+  "SYCL explicit SIMD does not permit private global variable to have an initializer">;
+
 def err_sycl_kernel_incorrectly_named : Error<
   "kernel %select{name is missing"
   "|needs to have a globally-visible name"
@@ -10900,66 +10953,11 @@ def warn_ivdep_redundant : Warning <"ignoring redundant Intel FPGA loop "
   "attribute 'ivdep': safelen %select{INF|%1}0 >= safelen %select{INF|%3}2">,
   InGroup<IgnoredAttributes>;
 
-def err_builtin_matrix_arg: Error<"first argument must be a matrix">;
-def err_builtin_matrix_scalar_unsigned_arg: Error<
-  "%0 argument must be a constant unsigned integer expression">;
-def err_builtin_matrix_pointer_arg: Error<
-  "%0 argument must be a pointer to a valid matrix element type">;
-def err_builtin_matrix_pointer_arg_mismatch: Error<
-  "the pointee of the second argument must match the element type of the first argument (%0 != %1)">;
-def err_builtin_matrix_store_to_const: Error<
-  "cannot store matrix to read-only pointer">;
-def err_builtin_matrix_stride_too_small: Error<
-  "stride must be greater or equal to the number of rows">;
-def err_builtin_matrix_invalid_dimension: Error<
-  "%0 dimension is outside the allowed range [1, %1]">;
-
-def warn_mismatched_import : Warning<
-  "import %select{module|name}0 (%1) does not match the import %select{module|name}0 (%2) of the "
-  "previous declaration">,
-  InGroup<IgnoredAttributes>;
-def warn_import_on_definition : Warning<
-  "import %select{module|name}0 cannot be applied to a function with a definition">,
-  InGroup<IgnoredAttributes>;
-
-def err_preserve_field_info_not_field : Error<
-  "__builtin_preserve_field_info argument %0 not a field access">;
-def err_preserve_field_info_not_const: Error<
-  "__builtin_preserve_field_info argument %0 not a constant">;
-def err_btf_type_id_not_const: Error<
-  "__builtin_btf_type_id argument %0 not a constant">;
-
-def err_bit_cast_non_trivially_copyable : Error<
-  "__builtin_bit_cast %select{source|destination}0 type must be trivially copyable">;
-def err_bit_cast_type_size_mismatch : Error<
-  "__builtin_bit_cast source size does not equal destination size (%0 vs %1)">;
-
 // errors of expect.with.probability
 def err_probability_not_constant_float : Error<
    "probability argument to __builtin_expect_with_probability must be constant "
    "floating-point expression">;
 def err_probability_out_of_range : Error<
    "probability argument to __builtin_expect_with_probability is outside the "
    "range [0.0, 1.0]">;
-
-// SYCL-specific diagnostics
-def warn_sycl_kernel_num_of_template_params : Warning<
-  "'sycl_kernel' attribute only applies to a function template with at least"
-  " two template parameters">, InGroup<IgnoredAttributes>;
-def warn_sycl_kernel_invalid_template_param_type : Warning<
-  "template parameter of a function template with the 'sycl_kernel' attribute"
-  " cannot be a non-type template parameter">, InGroup<IgnoredAttributes>;
-def warn_sycl_kernel_num_of_function_params : Warning<
-  "function template with 'sycl_kernel' attribute must have a single parameter">,
-  InGroup<IgnoredAttributes>;
-def warn_sycl_kernel_return_type : Warning<
-  "function template with 'sycl_kernel' attribute must have a 'void' return type">,
-  InGroup<IgnoredAttributes>;
-
-def err_ext_int_bad_size : Error<"%select{signed|unsigned}0 _ExtInt must "
-                                 "have a bit size of at least %select{2|1}0">;
-def err_ext_int_max_size : Error<"%select{signed|unsigned}0 _ExtInt of bit "
-                                 "sizes greater than %1 not supported">;
-def err_esimd_glob_cant_init : Error<
-  "SYCL explicit SIMD does not permit private global variable to have an initializer">;
 } // end of sema component.

clang/lib/Sema/SemaChecking.cpp

@@ -15431,7 +15431,8 @@ ExprResult Sema::SemaBuiltinMatrixColumnMajorLoad(CallExpr *TheCall,
   if (checkArgCount(*this, TheCall, 4))
     return ExprError();
 
-  Expr *PtrExpr = TheCall->getArg(0);
+  unsigned PtrArgIdx = 0;
+  Expr *PtrExpr = TheCall->getArg(PtrArgIdx);
   Expr *RowsExpr = TheCall->getArg(1);
   Expr *ColumnsExpr = TheCall->getArg(2);
   Expr *StrideExpr = TheCall->getArg(3);
@@ -15455,14 +15456,14 @@ ExprResult Sema::SemaBuiltinMatrixColumnMajorLoad(CallExpr *TheCall,
   QualType ElementTy;
   if (!PtrTy) {
     Diag(PtrExpr->getBeginLoc(), diag::err_builtin_matrix_pointer_arg)
-        << "first";
+        << PtrArgIdx + 1;
     ArgError = true;
   } else {
     ElementTy = PtrTy->getPointeeType().getUnqualifiedType();
 
     if (!ConstantMatrixType::isValidElementType(ElementTy)) {
       Diag(PtrExpr->getBeginLoc(), diag::err_builtin_matrix_pointer_arg)
-          << "first";
+          << PtrArgIdx + 1;
       ArgError = true;
     }
   }
@@ -15538,8 +15539,9 @@ ExprResult Sema::SemaBuiltinMatrixColumnMajorStore(CallExpr *TheCall,
   if (checkArgCount(*this, TheCall, 3))
     return ExprError();
 
+  unsigned PtrArgIdx = 1;
   Expr *MatrixExpr = TheCall->getArg(0);
-  Expr *PtrExpr = TheCall->getArg(1);
+  Expr *PtrExpr = TheCall->getArg(PtrArgIdx);
   Expr *StrideExpr = TheCall->getArg(2);
 
   bool ArgError = false;
@@ -15578,7 +15580,7 @@ ExprResult Sema::SemaBuiltinMatrixColumnMajorStore(CallExpr *TheCall,
   auto *PtrTy = PtrExpr->getType()->getAs<PointerType>();
   if (!PtrTy) {
     Diag(PtrExpr->getBeginLoc(), diag::err_builtin_matrix_pointer_arg)
-        << "second";
+        << PtrArgIdx + 1;
     ArgError = true;
   } else {
     QualType ElementTy = PtrTy->getPointeeType();

clang/test/Sema/matrix-type-builtins.c

@@ -11,11 +11,11 @@ void transpose(sx5x10_t a, ix3x2_t b, dx3x3 c, int *d, int e) {
   b = __builtin_matrix_transpose(b);
   // expected-error@-1 {{assigning to 'ix3x2_t' (aka 'int __attribute__((matrix_type(3, 2)))') from incompatible type 'int __attribute__((matrix_type(2, 3)))'}}
   __builtin_matrix_transpose(d);
-  // expected-error@-1 {{first argument must be a matrix}}
+  // expected-error@-1 {{1st argument must be a matrix}}
   __builtin_matrix_transpose(e);
-  // expected-error@-1 {{first argument must be a matrix}}
+  // expected-error@-1 {{1st argument must be a matrix}}
   __builtin_matrix_transpose("test");
-  // expected-error@-1 {{first argument must be a matrix}}
+  // expected-error@-1 {{1st argument must be a matrix}}
 
   ix3x3 m = __builtin_matrix_transpose(c);
   // expected-error@-1 {{initializing 'ix3x3' (aka 'unsigned int __attribute__((matrix_type(3, 3)))') with an expression of incompatible type 'double __attribute__((matrix_type(3, 3)))'}}
@@ -43,24 +43,24 @@ void column_major_load(float *p1, int *p2, _Bool *p3, struct Foo *p4) {
   // expected-error@-1 {{stride must be greater or equal to the number of rows}}
 
   sx5x10_t a8 = __builtin_matrix_column_major_load(p3, 5, 10, 6);
-  // expected-error@-1 {{first argument must be a pointer to a valid matrix element type}}
+  // expected-error@-1 {{1st argument must be a pointer to a valid matrix element type}}
 
   sx5x10_t a9 = __builtin_matrix_column_major_load(p4, 5, 10, 6);
-  // expected-error@-1 {{first argument must be a pointer to a valid matrix element type}}
+  // expected-error@-1 {{1st argument must be a pointer to a valid matrix element type}}
 
   sx5x10_t a10 = __builtin_matrix_column_major_load(p1, 1ull << 21, 10, 6);
   // expected-error@-1 {{row dimension is outside the allowed range [1, 1048575}}
   sx5x10_t a11 = __builtin_matrix_column_major_load(p1, 10, 1ull << 21, 10);
   // expected-error@-1 {{column dimension is outside the allowed range [1, 1048575}}
 
   sx5x10_t a12 = __builtin_matrix_column_major_load(
-      10,         // expected-error {{first argument must be a pointer to a valid matrix element type}}
+      10,         // expected-error {{1st argument must be a pointer to a valid matrix element type}}
       1ull << 21, // expected-error {{row dimension is outside the allowed range [1, 1048575]}}
       1ull << 21, // expected-error {{column dimension is outside the allowed range [1, 1048575]}}
       "");        // expected-warning {{incompatible pointer to integer conversion casting 'char [1]' to type 'unsigned long'}}
 
   sx5x10_t a13 = __builtin_matrix_column_major_load(
-      10,  // expected-error {{first argument must be a pointer to a valid matrix element type}}
+      10,  // expected-error {{1st argument must be a pointer to a valid matrix element type}}
       *p4, // expected-error {{casting 'struct Foo' to incompatible type 'unsigned long'}}
       "",  // expected-error {{column argument must be a constant unsigned integer expression}}
            // expected-warning@-1 {{incompatible pointer to integer conversion casting 'char [1]' to type 'unsigned long'}}
@@ -73,18 +73,18 @@ void column_major_store(sx5x10_t *m1, ix3x2_t *m2, float *p1, int *p2, struct Fo
   __builtin_matrix_column_major_store(*m1, p1, 0);
   // expected-error@-1 {{stride must be greater or equal to the number of rows}}
   __builtin_matrix_column_major_store(*m1, p2, 10);
-  // expected-error@-1 {{the pointee of the second argument must match the element type of the first argument ('int' != 'float')}}
+  // expected-error@-1 {{the pointee of the 2nd argument must match the element type of the 1st argument ('int' != 'float')}}
   __builtin_matrix_column_major_store(p1, p2, 10);
-  // expected-error@-1 {{first argument must be a matrix}}
+  // expected-error@-1 {{1st argument must be a matrix}}
 
   __builtin_matrix_column_major_store(
-      "",   // expected-error {{first argument must be a matrix}}
-      10,   // expected-error {{second argument must be a pointer to a valid matrix element type}}
+      "",   // expected-error {{1st argument must be a matrix}}
+      10,   // expected-error {{2nd argument must be a pointer to a valid matrix element type}}
       *p3); // expected-error {{casting 'struct Foo' to incompatible type 'unsigned long'}}
 
   __builtin_matrix_column_major_store(
       *m1,
-      10, // expected-error {{second argument must be a pointer to a valid matrix element type}}
+      10, // expected-error {{2nd argument must be a pointer to a valid matrix element type}}
       10);
 
   *m1 = __builtin_matrix_column_major_store(*m1, p1, 10);

clang/test/SemaCXX/matrix-type-builtins.cpp

@@ -15,9 +15,9 @@ typename MyMatrix<EltTy1, R1, C1>::matrix_t transpose(MyMatrix<EltTy0, R0, C0> &
   // expected-error@-3 {{cannot initialize a variable of type 'char *' with an rvalue of type 'unsigned int __attribute__((matrix_type(3, 3)))'}}
 
   __builtin_matrix_transpose(A);
-  // expected-error@-1 {{first argument must be a matrix}}
-  // expected-error@-2 {{first argument must be a matrix}}
-  // expected-error@-3 {{first argument must be a matrix}}
+  // expected-error@-1 {{1st argument must be a matrix}}
+  // expected-error@-2 {{1st argument must be a matrix}}
+  // expected-error@-3 {{1st argument must be a matrix}}
 
   return __builtin_matrix_transpose(A.value);
   // expected-error@-1 {{cannot initialize return object of type 'typename MyMatrix<unsigned int, 2U, 3U>::matrix_t' (aka 'unsigned int __attribute__((matrix_type(2, 3)))') with an rvalue of type 'unsigned int __attribute__((matrix_type(3, 2)))'}}
@@ -99,13 +99,13 @@ void call_column_major_load_temp(unsigned *Ptr, unsigned X) {
   // expected-error@-1 {{row argument must be a constant unsigned integer expression}}
   // expected-error@-2 {{column argument must be a constant unsigned integer expression}}
   (void)__builtin_matrix_column_major_load(X, 2, 2, 2);
-  // expected-error@-1 {{first argument must be a pointer to a valid matrix element type}}
+  // expected-error@-1 {{1st argument must be a pointer to a valid matrix element type}}
 }
 
 template <typename EltTy0, unsigned R0, unsigned C0, typename PtrTy>
 void column_major_store(MyMatrix<EltTy0, R0, C0> &A, PtrTy Ptr, unsigned Stride) {
   __builtin_matrix_column_major_store(A.value, Ptr, Stride);
-  // expected-error@-1 {{the pointee of the second argument must match the element type of the first argument ('float' != 'unsigned int')}}
+  // expected-error@-1 {{the pointee of the 2nd argument must match the element type of the 1st argument ('float' != 'unsigned int')}}
 }
 
 template <typename MTy, typename PtrTy, unsigned Stride>
@@ -126,14 +126,14 @@ template <typename EltTy0, unsigned R0, unsigned C0, typename EltTy1>
 void column_major_store(MyMatrix<EltTy0, R0, C0> &A, EltTy1 *Ptr) {
   __builtin_matrix_column_major_store(A.value, Ptr, 1);
   // expected-error@-1 3 {{stride must be greater or equal to the number of rows}}
-  // expected-error@-2 {{the pointee of the second argument must match the element type of the first argument ('float' != 'unsigned int')}}
-  // expected-error@-3 {{the pointee of the second argument must match the element type of the first argument ('unsigned int' != 'float')}}
+  // expected-error@-2 {{the pointee of the 2nd argument must match the element type of the 1st argument ('float' != 'unsigned int')}}
+  // expected-error@-3 {{the pointee of the 2nd argument must match the element type of the 1st argument ('unsigned int' != 'float')}}
 
   char *s;
   return __builtin_matrix_column_major_store(A.value, s, 20);
-  // expected-error@-1 {{the pointee of the second argument must match the element type of the first argument ('char' != 'unsigned int')}}
-  // expected-error@-2 {{the pointee of the second argument must match the element type of the first argument ('char' != 'unsigned int')}}
-  // expected-error@-3 {{he pointee of the second argument must match the element type of the first argument ('char' != 'float')}}
+  // expected-error@-1 {{the pointee of the 2nd argument must match the element type of the 1st argument ('char' != 'unsigned int')}}
+  // expected-error@-2 {{the pointee of the 2nd argument must match the element type of the 1st argument ('char' != 'unsigned int')}}
+  // expected-error@-3 {{he pointee of the 2nd argument must match the element type of the 1st argument ('char' != 'float')}}
 }
 
 void test_column_major_store_template(unsigned *Ptr1, float *Ptr2) {
@@ -152,15 +152,15 @@ void test_column_major_store_constexpr(unsigned *Ptr, MyMatrix<unsigned, 3, 3> &
   __builtin_matrix_column_major_store(M.value, Ptr, constexpr1());
   // expected-error@-1 {{stride must be greater or equal to the number of rows}}
   __builtin_matrix_column_major_store(constexpr1(), Ptr, 1);
-  // expected-error@-1 {{first argument must be a matrix}}
+  // expected-error@-1 {{1st argument must be a matrix}}
   __builtin_matrix_column_major_store(M.value, constexpr1(), 1);
-  // expected-error@-1 {{second argument must be a pointer to a valid matrix element type}}
+  // expected-error@-1 {{2nd argument must be a pointer to a valid matrix element type}}
   // expected-error@-2 {{stride must be greater or equal to the number of rows}}
 }
 
 void test_column_major_store_wrapper(unsigned *Ptr, MyMatrix<unsigned, 3, 3> &M, IntWrapper &W) {
   __builtin_matrix_column_major_store(M.value, Ptr, W);
 
   __builtin_matrix_column_major_store(W, Ptr, W);
-  // expected-error@-1 {{first argument must be a matrix}}
+  // expected-error@-1 {{1st argument must be a matrix}}
 }

clang/test/SemaObjC/matrix-type-builtins.m

@@ -22,10 +22,10 @@ void test_element_type_mismatch(u4x4 m, MatrixValue *mv) {
 
 double test_store(MatrixValue *mv, float *Ptr) {
   __builtin_matrix_column_major_store(mv.value, Ptr, 1);
-  // expected-error@-1 {{the pointee of the second argument must match the element type of the first argument ('float' != 'double')}}
+  // expected-error@-1 {{the pointee of the 2nd argument must match the element type of the 1st argument ('float' != 'double')}}
   // expected-error@-2 {{stride must be greater or equal to the number of rows}}
 
   __builtin_matrix_column_major_store(mv.value, mv.value, mv.value);
-  // expected-error@-1 {{second argument must be a pointer to a valid matrix element type}}
+  // expected-error@-1 {{2nd argument must be a pointer to a valid matrix element type}}
   // expected-error@-2 {{casting 'double4x4' (aka 'double __attribute__((matrix_type(4, 4)))') to incompatible type 'unsigned long}}
 }

llvm/lib/Target/ARM/MVETailPredication.cpp

@@ -354,8 +354,14 @@ bool MVETailPredication::IsPredicatedVectorLoop() {
           return false;
         MaskedInsts.push_back(cast<IntrinsicInst>(&I));
       } else if (auto *Int = dyn_cast<IntrinsicInst>(&I)) {
-        if (Int->getIntrinsicID() == Intrinsic::fma)
-          continue;
+        switch (Int->getIntrinsicID()) {
+          case Intrinsic::fma:
+          case Intrinsic::sadd_sat:
+          case Intrinsic::uadd_sat:
+            continue;
+          default:
+            break;
+        }
         for (auto &U : Int->args()) {
           if (isa<VectorType>(U->getType()))
             return false;