[OpenCL] Enables passing sampler initializer to function argument

[yaxunl]

I am not sure if this is going to work. At least you need to add a codegen test for this new usage.

[Anastasia]

test/SemaOpenCL/sampler_t.cl

68–69

I think we could keep just an int value (i.e. 5) as well.

Could we add a case with an error though. To make sure we are testing the diagnostic too.

[yaxunl]

LGTM. Thanks.

[Anastasia]

LGTM!

lib/Sema/SemaInit.cpp

case SK_OCLSamplerInit: {
       // calls as arguments, we only need to replace them when handling the
       // argument passing.
       assert(Step->Type->isSamplerT() &&
              "Sampler initialization on non-sampler type.");
       Expr *Init = CurInit.get();
       QualType SourceType = Init->getType();
       // Case 1
       if (Entity.isParameterKind()) {
-        if (!SourceType->isSamplerT()) {
+        if (!SourceType->isSamplerT() && !SourceType->isIntegerType()) {
           S.Diag(Kind.getLocation(), diag::err_sampler_argument_required)
             << SourceType;
           break;
         } else if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Init)) {
           auto Var = cast<VarDecl>(DRE->getDecl());
           // Case 1b and 1c
           // No cast from integer to sampler is needed.
           if (!Var->hasGlobalStorage()) {

test/CodeGenOpenCL/sampler.cl

kernel void foo(sampler_t smp_par) {
   fnc4smp(glb_smp);
   // CHECK: [[SAMP:%[0-9]+]] = call %opencl.sampler_t addrspace(2)* @__translate_sampler_initializer(i32 35)
   // CHECK: call spir_func void @fnc4smp(%opencl.sampler_t addrspace(2)* [[SAMP]])
 
   // Case 1c
   fnc4smp(smp_par);
   // CHECK: [[SAMP:%[0-9]+]] = load %opencl.sampler_t addrspace(2)*, %opencl.sampler_t addrspace(2)** [[smp_par_ptr]]
   // CHECK: call spir_func void @fnc4smp(%opencl.sampler_t addrspace(2)* [[SAMP]])
+
+  fnc4smp(5);
+  // CHECK: [[SAMP:%[0-9]+]] = call %opencl.sampler_t addrspace(2)* @__translate_sampler_initializer(i32 5)
+  // CHECK: call spir_func void @fnc4smp(%opencl.sampler_t addrspace(2)* [[SAMP]])
 }

test/SemaOpenCL/sampler_t.cl

 
 int f(void);
 constant sampler_t glb_smp7 = f(); // expected-error{{initializer element is not a compile-time constant}}
 
 constant sampler_t glb_smp8 = 1.0f; // expected-error{{initializing '__constant sampler_t' with an expression of incompatible type 'float'}}
 
 constant sampler_t glb_smp9 = 0x100000000LL; // expected-error{{sampler_t initialization requires 32-bit integer, not 'long long'}}
 
-void foo(sampler_t);
+void foo(sampler_t); // expected-note{{passing argument to parameter here}}
 
 constant struct sampler_s {
   sampler_t smp; // expected-error{{the 'sampler_t' type cannot be used to declare a structure or union field}}
 } sampler_str = {0};
 
 sampler_t bad(void); //expected-error{{declaring function return value of type 'sampler_t' is not allowed}}
 
 void kernel ker(sampler_t argsmp) {
void kernel ker(sampler_t argsmp) {
   foo(sampler_str.smp);
   foo(const_smp);
   foo(const_smp2);
   foo(const_smp3);
   foo(const_smp4);
   foo(const_smp5);
   foo(const_smp6);
   foo(argsmp);
-  foo(5); // expected-error{{sampler_t variable required - got 'int'}}
+  foo(5);
+  foo(5.0f); // expected-error {{passing 'float' to parameter of incompatible type 'sampler_t'}}
   sampler_t sa[] = {argsmp, const_smp}; // expected-error {{array of 'sampler_t' type is invalid in OpenCL}}
   foo(sa[0]);
   foo(bad());
 }
 
 void bad(sampler_t*); // expected-error{{pointer to type 'sampler_t' is invalid in OpenCL}}
 
 void bar() {