[OpenCL] Add Sema checks for types

[pxli168]

Summary

Add Sema checks for opencl type: image, pipe....
This patch is partitioned from http://reviews.llvm.org/D16047

[yaxunl]

test/SemaOpenCL/invalid-pipes-cl2.0.cl

9

Do we have a test for diagnosing pipe type for OCL < 2.0 ?

[Anastasia]

lib/Sema/SemaDecl.cpp

5714

Move to the line above, separate with -.

5725

Remove 'getLangOpts().OpenCLVersion >= 200'. Parser will only allow pipe for CL2.0. Ideally we don't need to check getLangOpts().OpenCL either, but might be good to leave it for documentation purposes.

However could we merge with the previous:

if (getLangOpts().OpenCL) {
 if (...) ... // image type
 if (...) ... // pipe type
}

10763

Here you only check the pointer and not the other bits. So please modify the comment according to what the code does.

Does the same restriction apply to other OpenCL types i.e. sampler, event, queue, etc?

test/CodeGenOpenCL/opencl_types.cl

39

Could you please not remove this mangling test as it's not being tested elsewhere.

You can remove * from parameters though!

[pxli168]

Refine comments and diag.

lib/Sema/SemaDecl.cpp

5725

Ok, it should be more clear.

10763

Good suggestion. I will have a look and try to add them.

test/CodeGenOpenCL/opencl_types.cl

39

OK, I will try to make this mangle right for different target.

test/SemaOpenCL/invalid-pipes-cl2.0.cl

9

We have one called test/SemaOpenCL/pipes-1.2-negative.cl

[yaxunl]

do we need to add a test that pointer to sampler is invalid?

[Anastasia]

test/SemaOpenCL/invalid-image.cl

4

Could we add similar tests for other types too. I think we could put them in existing cl files.

[Anastasia]

test/SemaOpenCL/invalid-image.cl

4

At least sampler test could go into test/SemaOpenCL/sampler_t.cl

[pxli168]

Add array check for types.

[yaxunl]

LGTM. Thanks!

lib/Sema/SemaType.cpp

2180

remove extra space

[Anastasia]

test/SemaOpenCL/sampler_t.cl

13

put whitespace after ,

include/clang/Basic/DiagnosticSemaKinds.td

 def err_opencl_dereferencing : Error<
   "dereferencing pointer of type %0 is not allowed in OpenCL">;
 def err_opencl_block_proto_variadic : Error<
   "invalid block prototype, variadic arguments are not allowed in OpenCL">;
 def err_opencl_invalid_type_array : Error<
   "array of %0 type is invalid in OpenCL">;
 def err_opencl_ternary_with_block : Error<
   "block type cannot be used as expression in ternary expression in OpenCL">;
+def err_opencl_pointer_to_type : Error<
+  "pointer to type %0 is invalid in OpenCL">;
+def err_opencl_type_can_only_be_used_as_function_parameter : Error <
+  "type %0 can only be used as a function parameter in OpenCL">;
 
 // OpenCL v2.0 s6.13.6 -- Builtin Pipe Functions
 def err_opencl_builtin_pipe_first_arg : Error<
   "first argument to %0 must be a pipe type">;
 def err_opencl_builtin_pipe_arg_num : Error<
     "invalid number of arguments to function: %0">;
 def err_opencl_builtin_pipe_invalid_arg : Error<
   "invalid argument type to function %0 (expecting %1)">;

lib/Sema/SemaDecl.cpp

 NamedDecl *
 Sema::ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC,
                               TypeSourceInfo *TInfo, LookupResult &Previous,
                               MultiTemplateParamsArg TemplateParamLists,
                               bool &AddToScope) {
   QualType R = TInfo->getType();
   DeclarationName Name = GetNameForDeclarator(D).getName();
 
+  // OpenCL v2.0 s6.9.b - Image type can only be used as a function argument.
+  // OpenCL v2.0 s6.13.16.1 - Pipe type can only be used as a function
+  // argument.
+  if (getLangOpts().OpenCL && (R->isImageType() || R->isPipeType())) {
+    Diag(D.getIdentifierLoc(),
+         diag::err_opencl_type_can_only_be_used_as_function_parameter)
+        << R;
+    D.setInvalidType();
+    return nullptr;
+  }
+
   DeclSpec::SCS SCSpec = D.getDeclSpec().getStorageClassSpec();
   StorageClass SC = StorageClassSpecToVarDeclStorageClass(D.getDeclSpec());
 
   // dllimport globals without explicit storage class are treated as extern. We
   // have to change the storage class this early to get the right DeclContext.
   if (SC == SC_None && !DC->isRecord() &&
       hasParsedAttr(S, D, AttributeList::AT_DLLImport) &&
       !hasParsedAttr(S, D, AttributeList::AT_DLLExport))
     SC = SC_Extern;
 
ParmVarDecl *Sema::CheckParameter(DeclContext *DC, SourceLocation StartLoc,
   // an address space.
   if (T.getAddressSpace() != 0) {
     // OpenCL allows function arguments declared to be an array of a type
     // to be qualified with an address space.
     if (!(getLangOpts().OpenCL && T->isArrayType())) {
       Diag(NameLoc, diag::err_arg_with_address_space);
       New->setInvalidDecl();
     }
-  }   
+  }
 
+  // OpenCL v2.0 s6.9b - Pointer to image/sampler cannot be used.
+  // OpenCL v2.0 s6.13.16.1 - Pointer to pipe cannot be used.
+  if (getLangOpts().OpenCL && T->isPointerType()) {
+    const QualType PTy = T->getPointeeType();
+    if (PTy->isImageType() || PTy->isSamplerT() || PTy->isPipeType()) {
+      Diag(NameLoc, diag::err_opencl_pointer_to_type) << PTy;
+      New->setInvalidDecl();
+    }
+  }
+
   return New;
 }
 
 void Sema::ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D,
                                            SourceLocation LocAfterDecls) {
   DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
 
   // Verify 6.9.1p6: 'every identifier in the identifier list shall be declared'
   // for a K&R function.

lib/Sema/SemaType.cpp

QualType Sema::BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM,
   }
 
   if (T->isVariableArrayType()) {
     // Warn about VLAs for -Wvla.
     Diag(Loc, diag::warn_vla_used);
   }
 
   // OpenCL v2.0 s6.12.5 - Arrays of blocks are not supported.
+  // OpenCL v2.0 s6.16.13.1 - Arrays of pipe type are not supported.
+  //  OpenCL v2.0 s6.9.b - Arrays of image/sampler type are not supported.
   if (getLangOpts().OpenCL) {
     const QualType ArrType = Context.getBaseElementType(T);
-    if (ArrType->isBlockPointerType()) {
+    if (ArrType->isBlockPointerType() || ArrType->isPipeType() ||
+        ArrType->isSamplerT() || ArrType->isImageType()) {
       Diag(Loc, diag::err_opencl_invalid_type_array) << ArrType;
       return QualType();
     }
   }
 
   return T;
 }
 

test/CodeGenOpenCL/opencl_types.cl

 // CHECK: alloca %opencl.event_t*
 // CHECK: store i32 5,
   fnc4smp(smp);
 // CHECK: call {{.*}}void @fnc4smp(i32
   fnc4smp(glb_smp);
 // CHECK: call {{.*}}void @fnc4smp(i32
 }
 
-void __attribute__((overloadable)) bad1(image1d_t *b, image2d_t *c, image2d_t *d) {}
-// CHECK-LABEL: @{{_Z4bad1P11ocl_image1dP11ocl_image2dS2_|"\\01\?bad1@@\$\$J0YAXPE?APAUocl_image1d@@PE?APAUocl_image2d@@1@Z"}}
+void __attribute__((overloadable)) bad1(image1d_t b, image2d_t c, image2d_t d) {}
+// CHECK-LABEL: @{{_Z4bad111ocl_image1d11ocl_image2dS0_|"\\01\?bad1@@\$\$J0YAXPAUocl_image1d@@PAUocl_image2d@@1@Z"}}

test/SemaOpenCL/invalid-image.cl

+// RUN: %clang_cc1 -verify %s
+
+void test1(image1d_t *i){} // expected-error {{pointer to type 'image1d_t' is invalid in OpenCL}}
+
+void test2(image1d_t i) {
+  image1d_t ti; // expected-error {{type 'image1d_t' can only be used as a function parameter}}
+  image1d_t ai[] = {i,i};// expected-error {{array of 'image1d_t' type is invalid in OpenCL}}
+}

test/SemaOpenCL/invalid-pipes-cl2.0.cl

 // RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL2.0
 
 void test1(pipe int *p){// expected-error {{pipes packet types cannot be of reference type}}
 }
 void test2(pipe p){// expected-error {{missing actual type specifier for pipe}}
 }
 void test3(int pipe p){// expected-error {{cannot combine with previous 'int' declaration specifier}}
 }
+void test4() {
+  pipe int p; // expected-error {{type 'pipe' can only be used as a function parameter}}
+}

test/SemaOpenCL/sampler_t.cl

 // RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only
 
 constant sampler_t glb_smp = 5;
 
 void foo(sampler_t); 
 
 void kernel ker(sampler_t argsmp) {
   local sampler_t smp; // expected-error {{sampler type cannot be used with the __local and __global address space qualifiers}}
   const sampler_t const_smp = 7;
   foo(glb_smp);
   foo(const_smp);
   foo(5); // expected-error {{sampler_t variable required - got 'int'}}
+  sampler_t sa[] = {argsmp,const_smp}; // expected-error {{array of 'sampler_t' type is invalid in OpenCL}}
 }
+
+void bad(sampler_t*); // expected-error {{pointer to type 'sampler_t' is invalid in OpenCL}}