[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

7529–7530

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

7531

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

bool Sema::SemaBuiltinPPCMMACall(CallExpr *TheCall, unsigned BuiltinID,
   while (*TypeStr != '\0') {
     Mask = 0;
     QualType ExpectedType = DecodePPCMMATypeFromStr(Context, TypeStr, Mask);
     if (ArgNum >= TheCall->getNumArgs()) {
       ArgNum++;
       break;
     }
 
     Expr *Arg = TheCall->getArg(ArgNum);
-    QualType ArgType = Arg->getType();
+    QualType PassedType = Arg->getType();
+    QualType StrippedRVType = PassedType.getCanonicalType();
 
-    if ((ExpectedType->isVoidPointerType() && !ArgType->isPointerType()) ||
-        (!ExpectedType->isVoidPointerType() &&
-           ArgType.getCanonicalType() != ExpectedType))
-      return Diag(Arg->getBeginLoc(), diag::err_typecheck_convert_incompatible)
-             << ArgType << ExpectedType << 1 << 0 << 0;
+    // Strip Restrict/Volatile qualifiers.
+    if (StrippedRVType.isRestrictQualified() ||
+        StrippedRVType.isVolatileQualified())
+      StrippedRVType = StrippedRVType.getCanonicalType().getUnqualifiedType();
+
+    // The only case where the argument type and expected type are allowed to
+    // mismatch is if the argument type is a non-void pointer and expected type
+    // is a void pointer.
+    if (StrippedRVType != ExpectedType)
+      if (!(ExpectedType->isVoidPointerType() &&
+            StrippedRVType->isPointerType()))
+        return Diag(Arg->getBeginLoc(),
+                    diag::err_typecheck_convert_incompatible)
+               << PassedType << 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))
       return 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(6L, 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'}}
 }
 
 void testBuiltinTypes3(vector int v, __vector_pair *vp2, signed long l, unsigned short s) {
   __vector_pair vp = __builtin_vsx_lxvp(l, v); // expected-error {{passing '__vector int' (vector of 4 'int' values) to parameter of incompatible type 'const __vector_pair *'}}
   __builtin_vsx_stxvp(vp, l, 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);
+}