[C++4OpenCL] Add extra diagnostics for kernel argument types

[olestrohm]

Summary

Adds extra error diagnostics when using unsupported types in kernel arguments.

This fixes https://bugs.llvm.org/show_bug.cgi?id=48099

[Anastasia]

clang/test/SemaOpenCLCXX/invalid-kernel.clcpp

44

Let's also test atomic and void pointer type since you are checking it in your patch?

This should be extended to references btw since clang implements them as a pointer type so we can allow that too.

Similarly for by-value parameters - let's test an OpenCL type too.

[olestrohm]

Added more exhaustive tests, as well as fixed the diagnostic to allow reference types.

[svenvh]

clang/lib/Sema/SemaDecl.cpp

8673

I am wondering if this should be made conditional on C++ mode? Or is there no possible way that this new return InvalidKernelParam can be triggered from OpenCL C mode?

[Anastasia]

LGTM from my side. I will leave final approval to Sven.

clang/lib/Sema/SemaDecl.cpp

8673

I think it shouldn't because C types are POD types which is a superset of standard layout types.

[olestrohm]

clang/lib/Sema/SemaDecl.cpp

8673

I believe these rules are correct, but just in case they are not, I will make it conditional on C++ mode to not accidentally break OpenCL C.

[olestrohm]

Restricted the checks to C++ for OpenCL and added another test for OpenCL vector types.

[svenvh]

LGTM, thanks!

clang/lib/Sema/SemaDecl.cpp

if (PointeeType->isPointerType()) {
       // Recursively check inner type.
       OpenCLParamType ParamKind = getOpenCLKernelParameterType(S, PointeeType);
       if (ParamKind == InvalidAddrSpacePtrKernelParam ||
           ParamKind == InvalidKernelParam)
         return ParamKind;
 
       return PtrPtrKernelParam;
     }
+
+  // C++ for OpenCL v1.0 s2.4:
+  // Moreover the types used in parameters of the kernel functions must be:
+  // Standard layout types for pointer parameters. The same applies to
+  // reference if an implementation supports them in kernel parameters.
+    if (!PointeeType->isAtomicType() && !PointeeType->isVoidType() && !PointeeType->isStandardLayoutType())
+    return InvalidKernelParam;
+
     return PtrKernelParam;
   }
 
   // OpenCL v1.2 s6.9.k:
   // Arguments to kernel functions in a program cannot be declared with the
   // built-in scalar types bool, half, size_t, ptrdiff_t, intptr_t, and
   // uintptr_t or a struct and/or union that contain fields declared to be one
   // of these built-in scalar types.
   if (isOpenCLSizeDependentType(S.getASTContext(), PT))
     return InvalidKernelParam;
 
   if (PT->isImageType())
     return PtrKernelParam;
 
   if (PT->isBooleanType() || PT->isEventT() || PT->isReserveIDT())
     return InvalidKernelParam;
 
   // OpenCL extension spec v1.2 s9.5:
   // This extension adds support for half scalar and vector types as built-in
   // types that can be used for arithmetic operations, conversions etc.
   if (!S.getOpenCLOptions().isAvailableOption("cl_khr_fp16", S.getLangOpts()) &&
       PT->isHalfType())
     return InvalidKernelParam;
 
-  if (PT->isRecordType())
-    return RecordKernelParam;
-
   // Look into an array argument to check if it has a forbidden type.
   if (PT->isArrayType()) {
     const Type *UnderlyingTy = PT->getPointeeOrArrayElementType();
     // Call ourself to check an underlying type of an array. Since the
     // getPointeeOrArrayElementType returns an innermost type which is not an
     // array, this recursive call only happens once.
     return getOpenCLKernelParameterType(S, QualType(UnderlyingTy, 0));
   }
 
+  // C++ for OpenCL v1.0 s2.4:
+  // Moreover the types used in parameters of the kernel functions must be:
+  // Trivial and standard-layout types C++17 [basic.types] (plain old data types)
+  // for parameters passed by value;
+  if (!PT->isOpenCLSpecificType() && !PT.isPODType(S.Context))
+    return InvalidKernelParam;
+
+  if (PT->isRecordType())
+    return RecordKernelParam;
+
   return ValidKernelParam;
 }
 
 static void checkIsValidOpenCLKernelParameter(
   Sema &S,
   Declarator &D,
   ParmVarDecl *Param,
   llvm::SmallPtrSetImpl<const Type *> &ValidTypes) {

clang/test/SemaOpenCLCXX/invalid-kernel.clcpp

 // RUN: %clang_cc1 %s -pedantic -verify -fsyntax-only
 
 struct C {
   kernel void m(); //expected-error{{kernel functions cannot be class members}}
 };
 
 template <typename T>
+//expected-error@+1{{'T' cannot be used as the type of a kernel parameter}}
 kernel void templ(T par) { //expected-error{{kernel functions cannot be used in a template declaration, instantiation or specialization}}
 }
 
 template <int>
 kernel void bar(int par) { //expected-error{{kernel functions cannot be used in a template declaration, instantiation or specialization}}
 }
 
 kernel void foo(int); //expected-note{{previous declaration is here}}
 
 kernel void foo(float); //expected-error{{conflicting types for 'foo'}}
+
+struct POD {
+  int a;
+  int b;
+};
+
+kernel void pod_v(POD in) {}
+kernel void pod_p(__global POD*__private in) {}
+
+struct StandardLayout {
+  int a;
+  int b;
+  StandardLayout(int a, int b) : a(a), b(b) {}
+};
+
+kernel void standard_v(StandardLayout in) {} //expected-error{{'__private StandardLayout' cannot be used as the type of a kernel parameter}}
+kernel void standard_p(__global StandardLayout*__private in) {}
+
+struct Trivial {
+  int a;
+private:
+  int b;
+};
+
+kernel void trivial_v(Trivial in) {} //expected-error{{'__private Trivial' cannot be used as the type of a kernel parameter}}
+kernel void trivial_p(__global Trivial*__private in) {} //expected-error{{'__global Trivial *__private' cannot be used as the type of a kernel parameter}}