[PowerPC] Allow MMA built-ins to accept restrict and volatile qualified pointers

[saghir]

Summary

This patch allows MMA built-ins on PowerPC to accept restrict
and volatile qualified pointers.

[nemanjai]

clang/lib/Sema/SemaChecking.cpp

7444–7447

Parentheses here seem superfluous. Also, am I reading this correctly? Does this mean that if the argument type is __restrict anything, we are accepting it? That is not the intent here. We don't want to accept just ANY restrict qualified type. We want to accept either: ExpectedType or ExpectedType __restrict.

[saghir]

Addressed review comments. Added another test case.

[nemanjai]

clang/lib/Sema/SemaChecking.cpp

7446

I am not in favour of the "single use lambda" idiom. We don't really need a lambda here. Also, this will handle restrict, but it won't handle const/volatile which also shouldn't be a problem for the loads.

I think we should do the following:

• Change the signatures in the .def file to specify all allowed const/volatile/restrict qualifiers
• Add the qualifiers in DecodePPCMMATypeFromStr()
• Ensure that the expected and arg types match with hasSameUnqualifiedType()
• Ensure that the actual type is not more qualified than the expected type (for example, if the expected type doesn't have const/restrict/volatile and the actual type does, we have a type mismatch).

[saghir]

Addressed review comments.

[saghir]

update test case name to be consistent with existing ones.

[saghir]

Changed approach for Sema checks.

[saghir]

Stripped RV qualifiers for Sema checking.

[nemanjai]

LGTM.

clang/lib/Sema/SemaChecking.cpp

while (*TypeStr != '\0') {
     QualType ExpectedType = DecodePPCMMATypeFromStr(Context, TypeStr, Mask);
     if (ArgNum >= TheCall->getNumArgs()) {
       ArgNum++;
       break;
     }
 
     Expr *Arg = TheCall->getArg(ArgNum);
     QualType ArgType = Arg->getType();
+    bool IsRestrictOrVolatile =
+        ArgType.isRestrictQualified() || ArgType.isVolatileQualified();
 
     if ((ExpectedType->isVoidPointerType() && !ArgType->isPointerType()) ||
         (!ExpectedType->isVoidPointerType() &&
-           ArgType.getCanonicalType() != ExpectedType))
+         ((IsRestrictOrVolatile &&
+           ArgType.getCanonicalType().getUnqualifiedType() != ExpectedType) ||
+          (!IsRestrictOrVolatile &&
+           ArgType.getCanonicalType() != ExpectedType))))
       return Diag(Arg->getBeginLoc(), diag::err_typecheck_convert_incompatible)
              << ArgType << ExpectedType << 1 << 0 << 0;
 
     // If the value of the Mask is not 0, we have a constraint in the size of
     // the integer argument so here we ensure the argument is a constant that
     // is in the valid range.
     if (Mask != 0 &&
         SemaBuiltinConstantArgRange(TheCall, ArgNum, 0, Mask, true))

clang/test/Sema/ppc-pair-mma-types.c

void testBuiltinTypes2(__vector_pair *vpp, const __vector_pair *vp2, unsigned char c) {
   __vector_pair vp = __builtin_vsx_lxvp(6LL, vpp); // expected-error {{passing '__vector_pair *' to parameter of incompatible type 'const __vector_pair *'}}
   __builtin_vsx_stxvp(vp, c, vp2);                 // expected-error {{passing 'unsigned char' to parameter of incompatible type 'long long'}}
 }
 
 void testBuiltinTypes3(vector int v, __vector_pair *vp2, signed long long ll, unsigned short s) {
   __vector_pair vp = __builtin_vsx_lxvp(ll, v); // expected-error {{passing '__vector int' (vector of 4 'int' values) to parameter of incompatible type 'const __vector_pair *'}}
   __builtin_vsx_stxvp(vp, ll, s);               // expected-error {{passing 'unsigned short' to parameter of incompatible type 'const __vector_pair *'}}
 }
+
+void testRestrictQualifiedPointer1(int *__restrict acc) {
+  vector float arr[4];
+  __builtin_mma_disassemble_acc((void*)arr, acc); // expected-error {{passing 'int *restrict' to parameter of incompatible type '__vector_quad *'}}
+}
+
+void testRestrictQualifiedPointer2(__vector_quad *__restrict acc) {
+  vector float arr[4];
+  __builtin_mma_disassemble_acc((void*)arr, acc);
+}
+
+void testVolatileQualifiedPointer1(int *__volatile acc) {
+  vector float arr[4];
+  __builtin_mma_disassemble_acc((void*)arr, acc); // expected-error {{passing 'int *volatile' to parameter of incompatible type '__vector_quad *'}}
+}
+
+void testVolatileQualifiedPointer2(__vector_quad *__volatile acc) {
+  vector float arr[4];
+  __builtin_mma_disassemble_acc((void*)arr, acc);
+}