Error on illegal OpenCL kernel argument types

[arsenm]

Summary

OpenCL disallows various types (bool, size_t, pointers, or structs containing them) to be used for kernel arguments, but currently they are accepted. The error message in the struct case is currently a bit awkward since it doesn't describe which struct member is at fault for not allowing the kernel argument.

[arsenm]

Ping!

[eli.friedman]

+ if (const TypedefType *Typedef = dyn_cast<TypedefType>(PT)) {
+ const IdentifierInfo *Identifier = Typedef->getDecl()->getIdentifier();
+ StringRef Name = Identifier->getName();
+
+ if (Name == "size_t" ||
+ Name == "ptrdiff_t" ||
+ Name == "intptr_t" ||
+ Name == "uintptr_t") {
+ return false;
+ }
+ }

No. It's completely insane to print an error message based on typedef
sugar. Someone could write "typedef size_t mysize_t;", or "typedef
__typeof(sizeof(int)) mysize_t;", or "#if SIZE_MAX == UINT_MAX [...]
typdef unsigned mysize_t [...]".

+static const RecordType *getAsStructOrUnionType(QualType QT) {
+ const RecordType *RT = QT->getAsStructureType();
+ if (!RT)
+ RT = QT->getAsUnionType();
+
+ return RT;
+}

This is equivalent to QT->getAs<RecordType>().

+ if (!isValidOpenCLKernelArgumentType(QT)) {
+ TODO: A more specific warning about which struct members forbid this
+ would be useful
+ Diag(Param->getLocation(), diag::err_bad_kernel_arg_type) << PT;
+ D.setInvalidType();

Diag(FD->getLocation(), diag::note_field_declared_here);

Please just fix this.

+kernel void bool_arg(bool x) // expected-error{{'bool' cannot be used
to declare a kernel function argument}}
+{
+
+}

"kernel void bool_arg(bool x) {}" would save 3 lines of useless whitespace.

-Eli

[rsmith]

lib/Sema/SemaDecl.cpp

5917

"...ParameterType" not "...ArgumentType".

5919

I assume this part of the OpenCL spec is defective and it means "Parameters" not "Arguments" here?

5927–5937

OpenCL 6.1.1 seems to imply that size_t, ptrdiff_t, intptr_t and uintptr_t are distinct built-in types in OpenCL, rather than being typedefs for some standard integer type, and it's the underlying types that we should be checking for here, not the typedefs. "typedef size_t my_size_t;" should also be prohibited here (as should, presumably, a typedef for __typeof(sizeof(0))).

However, the OpenCL spec is unclear, so I'm somewhat guessing... :(

5952–5958

This is just QT->getAs<RecordType>().

5960

This doesn't need to be a Sema member; a static non-member function would be preferred.

5966–5969

It would seem cleaner to fold both this pointer check and the one below into isValidOpenCLKernelArgumentType. You can return an enum value from there to indicate the flavor of problem, and fold together the diagnostics with a %select. You can also pass a value into this function to indicate whether you're checking a direct argument (where only a pointer-to-pointer is blocked) or a field of an argument (where any pointer is blocked).

5989–5990

Have you considered caching the result of this check? Or at least, storing a set of the types for which you've performed the check -- we don't really need to diagnose the same type more than once.

6000–6002

Maybe reformulate the queue as a recursive walk, and produce notes on the way back up after diagnosing a problem?

[arsenm]

Partially address review comments. Remove Sema member, rename argument to parameter, combine parameter check function, and use diag::note_member_declared_here on structs with invalid types in them. Does not yet show the chain of fields that are problematic, just the lowest one. Also update event_t test for changed warning.

lib/Sema/SemaDecl.cpp

5919

I just copied the text out of the spec

5927–5937

I wasn't really sure what to do about these. I didn't see an equivalent in the builtin type enums I found. It sort of depends on the library implementation. Apple and libclc at least implicitly include a header before the program which has these typedefs in them.

For example, the Apple header defines them as
typedef typeof(((int*)0)-((int*)0)) ptrdiff_t;
typedef SIZE_TYPE size_t;
typedef SIZE_TYPE uintptr_t;
typedef PTRDIFF_TYPE intptr_t;
typedef size_t event_t;

I don't actually see them defined in libclc, but size_t is used so I have no idea where that is coming from.

5989–5990

The type itself isn't the problem, it's only when used as a kernel argument. I don't think only diagnosing it on the first parameter found and then not on a second use as another argument would make much sense.

[arsenm]

Make warning report which nested struct fields invalidate the argument, reporting first the outermost struct, followed by the nested fields from the outermost to the first found illegal one.

For example, for a nested struct case like this:
struct InnerInner
{

int* foo;

};

struct Valid
{

float c;
float d;

};

struct Inner
{

struct Valid v;
struct InnerInner a;
struct Valid g;
struct InnerInner b;

};

struct NestedPointer
{

int x;
struct Inner inner;

};

kernel void pointer_in_nested_struct_arg(struct NestedPointer arg) { }

The diagnostic produced is:

error: struct or union kernel parameters may not contain OpenCL objects
kernel void pointer_in_nested_struct_arg(struct NestedPointer arg, struct NestedPointer second) { }// expected-error{{struct or union kernel parameters may not contain OpenCL objects}}

^

test/SemaOpenCL/arst2.cl:29:8: note: 'NestedPointer' declared here
struct NestedPointer

^

test/SemaOpenCL/arst2.cl:32:16: note: member 'inner' declared here

struct Inner inner;
             ^

test/SemaOpenCL/arst2.cl:26:21: note: member 'b' declared here

struct InnerInner b;
                  ^

test/SemaOpenCL/arst2.cl:12:8: note: member 'foo' declared here

int* foo;
     ^

[rsmith]

For the struct diagnostic, it's not very clear what the notes mean (sure, there are members declared there, but why are you pointing them out?). Maybe you could produce something like:

test/SemaOpenCL/arst2.cl:35:62: error: 'NestedPointer' cannot be used as the type of a kernel function parameter because it contains a field of pointer type
        kernel void pointer_in_nested_struct_arg(struct NestedPointer arg, struct NestedPointer second) { }// expected-error{{struct or union kernel parameters may not contain OpenCL objects}}
                                                                      ^
test/SemaOpenCL/arst2.cl:32:16: note: within field of type 'Inner' declared here
          struct Inner inner;
                       ^
test/SemaOpenCL/arst2.cl:26:21: note: within field of type 'InnerInner' declared here
          struct InnerInner b;
                            ^
test/SemaOpenCL/arst2.cl:12:8: note: field of pointer type 'int*' declared here
          int* foo;
               ^

include/clang/Basic/DiagnosticSemaKinds.td

6453

"%0 cannot be used as the type of a kernel function parameter" would be better.

6454–6455

Instead of "struct or union", please say which, and instead of "OpenCL objects" (which is not correct in several cases) please include the actual type as you do in the previous diagnostic.

include/clang/Sema/Sema.h

1449–1450

Remove this, you don't define such a Sema member any more.

lib/Sema/SemaDecl.cpp

6178–6196

This would be cleaner if you made this function recursive.

6236

I don't think this is necessary.

[arsenm]

Change wording of nested struct notes, remove old Sema member declaration, fix pop_back on empty vector.

Add cache of valid types encountered (but only is within the same kernel declaration).

error: struct kernel parameters may not contain OpenCL objects
kernel void pointer_in_nested_struct_arg(struct NestedPointer arg) { }

^

/tmp/arst.cl:23:8: note: within field of type 'NestedPointer' declared here
struct NestedPointer

^

/tmp/arst.cl:27:14: note: within field of type 'struct Inner' declared here
struct Inner inner;

^

/tmp/arst.cl:20:19: note: within field of type 'struct InnerInner' declared here
struct InnerInner b;

^

/tmp/arst.cl:4:6: note: field of illegal pointer type 'int *' declared here
int* foo;

^

Or for a non-pointer
error: 'struct NestedBool' cannot be used as the type of a kernel parameter
kernel void bool_in_nested_struct_arg(struct NestedBool arg) { }

^

/tmp/arst.cl:23:8: note: within field of type 'NestedBool' declared here
struct NestedBool

^

/tmp/arst.cl:27:14: note: within field of type 'struct Inner' declared here
struct Inner inner;

^

/tmp/arst.cl:20:19: note: within field of type 'struct InnerInner' declared here
struct InnerInner b;

^

/tmp/arst.cl:4:6: note: field of illegal type 'bool' declared here
bool foo;

[rsmith]

Couple of minor tweaks, then LGTM

include/clang/Basic/DiagnosticSemaKinds.td

6459–6460

"may not contain OpenCL objects" doesn't seem appropriate here. "may not contain pointers" seems to match the cases where this diagnostic is emitted.

6463–6464

Please use a %select in the place of %0 here (we try to keep our diagnostics translatable, even though we don't support localization yet).

[arsenm]

Use select, say pointers instead of OpenCL objects

[rsmith]

LGTM. Do you have commit access?

[arsenm]

Yes, committed r186908.

include/clang/Basic/DiagnosticSemaKinds.td

 def err_filter_expression_integral : Error<
   "filter expression type should be an integral value not %0">;
 
 // OpenCL warnings and errors.
 def err_invalid_astype_of_different_size : Error<
   "invalid reinterpretation: sizes of %0 and %1 must match">;
 def err_static_kernel : Error<
   "kernel functions cannot be declared static">;
-def err_opencl_ptrptr_kernel_arg : Error<
-  "kernel argument cannot be declared as a pointer to a pointer">;
+def err_opencl_ptrptr_kernel_param : Error<
+  "kernel parameter cannot be declared as a pointer to a pointer">;
 def err_static_function_scope : Error<
   "variables in function scope cannot be declared static">;
 def err_opencl_bitfields : Error<
   "bitfields are not supported in OpenCL">;
 def err_opencl_vla : Error<
   "variable length arrays are not supported in OpenCL">;
-def err_event_t_kernel_arg : Error<
-  "the event_t type cannot be used to declare a kernel function argument">;
+def err_bad_kernel_param_type : Error<
+  "%0 cannot be used as the type of a kernel parameter">;
+def err_record_with_pointers_kernel_param : Error<
+  "%select{struct|union}0 kernel parameters may not contain pointers">;
+def note_within_field_of_type : Note<
+  "within field of type %0 declared here">;
+def note_illegal_field_declared_here : Note<
+  "field of illegal %select{type|pointer type}0 %1 declared here">;
 def err_event_t_global_var : Error<
   "the event_t type cannot be used to declare a program scope variable">;
 def err_event_t_struct_field : Error<
   "the event_t type cannot be used to declare a structure or union field">;
 def err_event_t_addr_space_qual : Error<
   "the event_t type can only be used with __private address space qualifier">;
 def err_expected_kernel_void_return_type : Error<
   "kernel must have void return type">;

include/clang/Sema/Sema.h

   NamedDecl* ActOnTypedefDeclarator(Scope* S, Declarator& D, DeclContext* DC,
                                     TypeSourceInfo *TInfo,
                                     LookupResult &Previous);
   NamedDecl* ActOnTypedefNameDecl(Scope* S, DeclContext* DC, TypedefNameDecl *D,
                                   LookupResult &Previous, bool &Redeclaration);
   NamedDecl* ActOnVariableDeclarator(Scope* S, Declarator& D, DeclContext* DC,
                                      TypeSourceInfo *TInfo,
                                      LookupResult &Previous,
                                      MultiTemplateParamsArg TemplateParamLists);
   // Returns true if the variable declaration is a redeclaration
   bool CheckVariableDeclaration(VarDecl *NewVD, LookupResult &Previous);
   void CheckVariableDeclarationType(VarDecl *NewVD);
   void CheckCompleteVariableDeclaration(VarDecl *var);
   void MaybeSuggestAddingStaticToDecl(const FunctionDecl *D);
   void ActOnStartFunctionDeclarator();
   void ActOnEndFunctionDeclarator();
+
   NamedDecl* ActOnFunctionDeclarator(Scope* S, Declarator& D, DeclContext* DC,
                                      TypeSourceInfo *TInfo,
                                      LookupResult &Previous,
                                      MultiTemplateParamsArg TemplateParamLists,
                                      bool &AddToScope);
   bool AddOverriddenMethods(CXXRecordDecl *DC, CXXMethodDecl *MD);
   void checkVoidParamDecl(ParmVarDecl *Param);
 

lib/Sema/SemaDecl.cpp

 }
 
 static FunctionDecl* CreateNewFunctionDecl(Sema &SemaRef, Declarator &D,
                                            DeclContext *DC, QualType &R,
                                            TypeSourceInfo *TInfo,
                                            FunctionDecl::StorageClass SC,
                                            bool &IsVirtualOkay) {
   DeclarationNameInfo NameInfo = SemaRef.GetNameForDeclarator(D);
   DeclarationName Name = NameInfo.getName();
 
   FunctionDecl *NewFD = 0;
   bool isInline = D.getDeclSpec().isInlineSpecified();
 
   if (!SemaRef.getLangOpts().CPlusPlus) {
     // Determine whether the function was written with a
     // prototype. This true when:
     //   - there is a prototype in the declarator, or
     //   - the type R of the function is some kind of typedef or other reference
     //     to a type name (which eventually refers to a function type).
     bool HasPrototype =
       (D.isFunctionDeclarator() && D.getFunctionTypeInfo().hasPrototype) ||
       (!isa<FunctionType>(R.getTypePtr()) && R->isFunctionProtoType());
 
     NewFD = FunctionDecl::Create(SemaRef.Context, DC,
                                  D.getLocStart(), NameInfo, R,
                                  TInfo, SC, isInline,
                                  HasPrototype, false);
     if (D.isInvalidType())
       NewFD->setInvalidDecl();
 
     // Set the lexical context.
     NewFD->setLexicalDeclContext(SemaRef.CurContext);
 
     return NewFD;
   }
 
   bool isExplicit = D.getDeclSpec().isExplicitSpecified();
   bool isConstexpr = D.getDeclSpec().isConstexprSpecified();
 
   // Check that the return type is not an abstract class type.
   // For record types, this is done by the AbstractClassUsageDiagnoser once
   // the class has been completely parsed.
   if (!DC->isRecord() &&
       SemaRef.RequireNonAbstractType(D.getIdentifierLoc(),
                                      R->getAs<FunctionType>()->getResultType(),
                                      diag::err_abstract_type_in_decl,
                                      SemaRef.AbstractReturnType))
     D.setInvalidType();
 
   if (Name.getNameKind() == DeclarationName::CXXConstructorName) {
     // This is a C++ constructor declaration.
     assert(DC->isRecord() &&
            "Constructors can only be declared in a member context");
 
     R = SemaRef.CheckConstructorDeclarator(D, R, SC);
     return CXXConstructorDecl::Create(SemaRef.Context, cast<CXXRecordDecl>(DC),
                                       D.getLocStart(), NameInfo,
                                       R, TInfo, isExplicit, isInline,
                                       /*isImplicitlyDeclared=*/false,
                                       isConstexpr);
 
   } else if (Name.getNameKind() == DeclarationName::CXXDestructorName) {
     // This is a C++ destructor declaration.
     if (DC->isRecord()) {
       R = SemaRef.CheckDestructorDeclarator(D, R, SC);
       CXXRecordDecl *Record = cast<CXXRecordDecl>(DC);
       CXXDestructorDecl *NewDD = CXXDestructorDecl::Create(
                                         SemaRef.Context, Record,
                                         D.getLocStart(),
                                         NameInfo, R, TInfo, isInline,
                                         /*isImplicitlyDeclared=*/false);
 
       // If the class is complete, then we now create the implicit exception
       // specification. If the class is incomplete or dependent, we can't do
       // it yet.
       if (SemaRef.getLangOpts().CPlusPlus11 && !Record->isDependentType() &&
           Record->getDefinition() && !Record->isBeingDefined() &&
           R->getAs<FunctionProtoType>()->getExceptionSpecType() == EST_None) {
         SemaRef.AdjustDestructorExceptionSpec(Record, NewDD);
       }
 
       // The Microsoft ABI requires that we perform the destructor body
       // checks (i.e. operator delete() lookup) at every declaration, as
       // any translation unit may need to emit a deleting destructor.
       if (SemaRef.Context.getTargetInfo().getCXXABI().isMicrosoft() &&
           !Record->isDependentType() && Record->getDefinition() &&
           !Record->isBeingDefined()) {
         SemaRef.CheckDestructor(NewDD);
       }
 
       IsVirtualOkay = true;
       return NewDD;
 
     } else {
       SemaRef.Diag(D.getIdentifierLoc(), diag::err_destructor_not_member);
       D.setInvalidType();
 
       // Create a FunctionDecl to satisfy the function definition parsing
       // code path.
       return FunctionDecl::Create(SemaRef.Context, DC,
                                   D.getLocStart(),
                                   D.getIdentifierLoc(), Name, R, TInfo,

     else if (const TemplateSpecializationType *TST =
                Param->getType()->getAs<TemplateSpecializationType>())
       IsTypeAlias = TST->isTypeAlias();
     Diag(Param->getLocation(), diag::err_param_typedef_of_void)
       << IsTypeAlias;
   }
 }
 
+enum OpenCLParamType {
+  ValidKernelParam,
+  PtrPtrKernelParam,
+  PtrKernelParam,
+  InvalidKernelParam,
+  RecordKernelParam
+};
+
+static OpenCLParamType getOpenCLKernelParameterType(QualType PT) {
+  if (PT->isPointerType()) {
+    QualType PointeeType = PT->getPointeeType();
+    return PointeeType->isPointerType() ? PtrPtrKernelParam : PtrKernelParam;
+  }
+
+  // TODO: Forbid the other integer types (size_t, ptrdiff_t...) when they can
+  // be used as builtin types.
+
+  if (PT->isImageType())
+    return PtrKernelParam;
+
+  if (PT->isBooleanType())
+    return InvalidKernelParam;
+
+  if (PT->isEventT())
+    return InvalidKernelParam;
+
+  if (PT->isHalfType())
+    return InvalidKernelParam;
+
+  if (PT->isRecordType())
+    return RecordKernelParam;
+
+  return ValidKernelParam;
+}
+
+static void checkIsValidOpenCLKernelParameter(
+  Sema &S,
+  Declarator &D,
+  ParmVarDecl *Param,
+  llvm::SmallPtrSet<const Type *, 16> &ValidTypes) {
+  QualType PT = Param->getType();
+
+  // Cache the valid types we encounter to avoid rechecking structs that are
+  // used again
+  if (ValidTypes.count(PT.getTypePtr()))
+    return;
+
+  switch (getOpenCLKernelParameterType(PT)) {
+  case PtrPtrKernelParam:
+    // OpenCL v1.2 s6.9.a:
+    // A kernel function argument cannot be declared as a
+    // pointer to a pointer type.
+    S.Diag(Param->getLocation(), diag::err_opencl_ptrptr_kernel_param);
+    D.setInvalidType();
+    return;
+
+    // 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.
+
+  case InvalidKernelParam:
+    // OpenCL v1.2 s6.8 n:
+    // A kernel function argument cannot be declared
+    // of event_t type.
+    S.Diag(Param->getLocation(), diag::err_bad_kernel_param_type) << PT;
+    D.setInvalidType();
+    return;
+
+  case PtrKernelParam:
+  case ValidKernelParam:
+    ValidTypes.insert(PT.getTypePtr());
+    return;
+
+  case RecordKernelParam:
+    break;
+  }
+
+  // Track nested structs we will inspect
+  SmallVector<const Decl *, 4> VisitStack;
+
+  // Track where we are in the nested structs. Items will migrate from
+  // VisitStack to HistoryStack as we do the DFS for bad field.
+  SmallVector<const FieldDecl *, 4> HistoryStack;
+  HistoryStack.push_back((const FieldDecl *) 0);
+
+  const RecordDecl *PD = PT->castAs<RecordType>()->getDecl();
+  VisitStack.push_back(PD);
+
+  assert(VisitStack.back() && "First decl null?");
+
+  do {
+    const Decl *Next = VisitStack.pop_back_val();
+    if (!Next) {
+      assert(!HistoryStack.empty());
+      // Found a marker, we have gone up a level
+      if (const FieldDecl *Hist = HistoryStack.pop_back_val())
+        ValidTypes.insert(Hist->getType().getTypePtr());
+
+      continue;
+    }
+
+    // Adds everything except the original parameter declaration (which is not a
+    // field itself) to the history stack.
+    const RecordDecl *RD;
+    if (const FieldDecl *Field = dyn_cast<FieldDecl>(Next)) {
+      HistoryStack.push_back(Field);
+      RD = Field->getType()->castAs<RecordType>()->getDecl();
+    } else {
+      RD = cast<RecordDecl>(Next);
+    }
+
+    // Add a null marker so we know when we've gone back up a level
+    VisitStack.push_back((const Decl *) 0);
+
+    for (RecordDecl::field_iterator I = RD->field_begin(),
+           E = RD->field_end(); I != E; ++I) {
+      const FieldDecl *FD = *I;
+      QualType QT = FD->getType();
+
+      if (ValidTypes.count(QT.getTypePtr()))
+        continue;
+
+      OpenCLParamType ParamType = getOpenCLKernelParameterType(QT);
+      if (ParamType == ValidKernelParam)
+        continue;
+
+      if (ParamType == RecordKernelParam) {
+        VisitStack.push_back(FD);
+        continue;
+      }
+
+      // OpenCL v1.2 s6.9.p:
+      // Arguments to kernel functions that are declared to be a struct or union
+      // do not allow OpenCL objects to be passed as elements of the struct or
+      // union.
+      if (ParamType == PtrKernelParam || ParamType == PtrPtrKernelParam) {
+        S.Diag(Param->getLocation(),
+               diag::err_record_with_pointers_kernel_param)
+          << PT->isUnionType()
+          << PT;
+      } else {
+        S.Diag(Param->getLocation(), diag::err_bad_kernel_param_type) << PT;
+      }
+
+      S.Diag(PD->getLocation(), diag::note_within_field_of_type)
+        << PD->getDeclName();
+
+      // We have an error, now let's go back up through history and show where
+      // the offending field came from
+      for (ArrayRef<const FieldDecl *>::const_iterator I = HistoryStack.begin() + 1,
+             E = HistoryStack.end(); I != E; ++I) {
+        const FieldDecl *OuterField = *I;
+        S.Diag(OuterField->getLocation(), diag::note_within_field_of_type)
+          << OuterField->getType();
+      }
+
+      S.Diag(FD->getLocation(), diag::note_illegal_field_declared_here)
+        << QT->isPointerType()
+        << QT;
+      D.setInvalidType();
+      return;
+    }
+  } while (!VisitStack.empty());
+}
+
 NamedDecl*
 Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC,
                               TypeSourceInfo *TInfo, LookupResult &Previous,
                               MultiTemplateParamsArg TemplateParamLists,
                               bool &AddToScope) {
   QualType R = TInfo->getType();
 
   assert(R.getTypePtr()->isFunctionType());

 
     // OpenCL v1.2, s6.9 -- Kernels can only have return type void.
     if (!NewFD->getResultType()->isVoidType()) {
       Diag(D.getIdentifierLoc(),
            diag::err_expected_kernel_void_return_type);
       D.setInvalidType();
     }
 
+    llvm::SmallPtrSet<const Type *, 16> ValidTypes;
     for (FunctionDecl::param_iterator PI = NewFD->param_begin(),
          PE = NewFD->param_end(); PI != PE; ++PI) {
       ParmVarDecl *Param = *PI;
-      QualType PT = Param->getType();
-
-      // OpenCL v1.2 s6.9.a:
-      // A kernel function argument cannot be declared as a
-      // pointer to a pointer type.
-      if (PT->isPointerType() && PT->getPointeeType()->isPointerType()) {
-        Diag(Param->getLocation(), diag::err_opencl_ptrptr_kernel_arg);
-        D.setInvalidType();
-      }
-
-      // OpenCL v1.2 s6.8 n:
-      // A kernel function argument cannot be declared
-      // of event_t type.
-      if (PT->isEventT()) {
-        Diag(Param->getLocation(), diag::err_event_t_kernel_arg);
-        D.setInvalidType();
-      }
+      checkIsValidOpenCLKernelParameter(*this, D, Param, ValidTypes);
     }
   }
 
   MarkUnusedFileScopedDecl(NewFD);
 
   if (getLangOpts().CUDA)
     if (IdentifierInfo *II = NewFD->getIdentifier())
       if (!NewFD->isInvalidDecl() &&

test/SemaOpenCL/event_t.cl

 // RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only
 
 event_t glb_evt; // expected-error {{the event_t type cannot be used to declare a program scope variable}}
 
 constant struct evt_s {
   event_t evt;  // expected-error {{the event_t type cannot be used to declare a structure or union field}}
 } evt_str;
 
 void foo(event_t evt); // expected-note {{passing argument to parameter 'evt' here}}
 
-void kernel ker(event_t argevt) { // expected-error {{the event_t type cannot be used to declare a kernel function argument}}
+void kernel ker(event_t argevt) { // expected-error {{'event_t' cannot be used as the type of a kernel parameter}}
   event_t e;
   constant event_t const_evt; // expected-error {{the event_t type can only be used with __private address space qualifier}}
   foo(e);
   foo(0);
   foo(5); // expected-error {{passing 'int' to parameter of incompatible type 'event_t'}}
 }
+

test/SemaOpenCL/invalid-kernel-parameters.cl

+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+#pragma OPENCL EXTENSION cl_khr_fp16 : enable
+
+
+// Disallowed: parameters with type
+// bool, half, size_t, ptrdiff_t, intptr_t, and uintptr_t
+// or a struct / union with any of these types in them
+
+// TODO: Ban int types, size_t, ptrdiff_t ...
+
+kernel void bool_arg(bool x) { } // expected-error{{'bool' cannot be used as the type of a kernel parameter}}
+
+kernel void half_arg(half x) { } // expected-error{{'half' cannot be used as the type of a kernel parameter}}
+
+typedef struct ContainsBool // expected-note{{within field of type 'ContainsBool' declared here}}
+{
+  bool x; // expected-note{{field of illegal type 'bool' declared here}}
+} ContainsBool;
+
+kernel void bool_in_struct_arg(ContainsBool x) { } // expected-error{{'ContainsBool' (aka 'struct ContainsBool') cannot be used as the type of a kernel parameter}}
+
+
+
+typedef struct FooImage2D // expected-note{{within field of type 'FooImage2D' declared here}}
+{
+  image2d_t imageField; // expected-note{{field of illegal type 'image2d_t' declared here}}
+} FooImage2D;
+
+kernel void image_in_struct_arg(FooImage2D arg) { } // expected-error{{struct kernel parameters may not contain pointers}}
+
+typedef struct Foo // expected-note{{within field of type 'Foo' declared here}}
+{
+  int* ptrField; // expected-note{{field of illegal pointer type 'int *' declared here}}
+} Foo;
+
+kernel void pointer_in_struct_arg(Foo arg) { } // expected-error{{struct kernel parameters may not contain pointers}}
+
+typedef union FooUnion // expected-note{{within field of type 'FooUnion' declared here}}
+{
+  int* ptrField; // expected-note{{field of illegal pointer type 'int *' declared here}}
+} FooUnion;
+
+kernel void pointer_in_union_arg(FooUnion arg) { }// expected-error{{union kernel parameters may not contain pointers}}
+
+typedef struct NestedPointer // expected-note 2 {{within field of type 'NestedPointer' declared here}}
+{
+  int x;
+  struct InnerNestedPointer
+  {
+    int* ptrField; // expected-note 3 {{field of illegal pointer type 'int *' declared here}}
+  } inner; // expected-note 3 {{within field of type 'struct InnerNestedPointer' declared here}}
+} NestedPointer;
+
+kernel void pointer_in_nested_struct_arg(NestedPointer arg) { }// expected-error{{struct kernel parameters may not contain pointers}}
+
+struct NestedPointerComplex // expected-note{{within field of type 'NestedPointerComplex' declared here}}
+{
+  int foo;
+  float bar;
+
+  struct InnerNestedPointerComplex
+  {
+    int innerFoo;
+    int* innerPtrField; // expected-note{{field of illegal pointer type 'int *' declared here}}
+  } inner; // expected-note{{within field of type 'struct InnerNestedPointerComplex' declared here}}
+
+  float y;
+  float z[4];
+};
+
+kernel void pointer_in_nested_struct_arg_complex(struct NestedPointerComplex arg) { }// expected-error{{struct kernel parameters may not contain pointers}}
+
+typedef struct NestedBool // expected-note 2 {{within field of type 'NestedBool' declared here}}
+{
+  int x;
+  struct InnerNestedBool
+  {
+    bool boolField; // expected-note 2 {{field of illegal type 'bool' declared here}}
+  } inner; // expected-note 2 {{within field of type 'struct InnerNestedBool' declared here}}
+} NestedBool;
+
+kernel void bool_in_nested_struct_arg(NestedBool arg) { } // expected-error{{'NestedBool' (aka 'struct NestedBool') cannot be used as the type of a kernel parameter}}
+
+// Warning emitted again for argument used in other kernel
+kernel void bool_in_nested_struct_arg_again(NestedBool arg) { } // expected-error{{'NestedBool' (aka 'struct NestedBool') cannot be used as the type of a kernel parameter}}
+
+
+// Check for note with a struct not defined inside the struct
+typedef struct NestedBool2Inner
+{
+  bool boolField; // expected-note{{field of illegal type 'bool' declared here}}
+} NestedBool2Inner;
+
+typedef struct NestedBool2 // expected-note{{within field of type 'NestedBool2' declared here}}
+{
+  int x;
+  NestedBool2Inner inner; // expected-note{{within field of type 'NestedBool2Inner' (aka 'struct NestedBool2Inner') declared here}}
+} NestedBool2;
+
+kernel void bool_in_nested_struct_2_arg(NestedBool2 arg) { } // expected-error{{'NestedBool2' (aka 'struct NestedBool2') cannot be used as the type of a kernel parameter}}
+
+
+struct InnerInner
+{
+  int* foo;
+  bool x;
+};
+
+struct Valid
+{
+  float c;
+  float d;
+};
+
+struct Inner
+{
+  struct Valid v;
+  struct InnerInner a;
+  struct Valid g;
+  struct InnerInner b;
+};
+
+struct AlsoUser // expected-note{{within field of type 'AlsoUser' declared here}}
+{
+  float x;
+  struct Valid valid1;
+  struct Valid valid2;
+  struct NestedPointer aaaa; // expected-note{{within field of type 'struct NestedPointer' declared here}}
+};
+
+kernel void pointer_in_nested_struct_arg_2(struct Valid valid, struct NestedPointer arg, struct AlsoUser also) { } // expected-error 2 {{struct kernel parameters may not contain pointers}}

test/SemaOpenCL/invalid-kernel.cl

 // RUN: %clang_cc1 -verify %s
 
-kernel void no_ptrptr(global int **i) { } // expected-error{{kernel argument cannot be declared as a pointer to a pointer}}
+kernel void no_ptrptr(global int **i) { } // expected-error{{kernel parameter cannot be declared as a pointer to a pointer}}
 
 kernel int bar()  { // expected-error {{kernel must have void return type}}
   return 6;
 }