[OpenCL] Diagnose program scope pointers

[Anastasia]

Summary

Programs scope pointers should point to objects in constant AS or for OpenCL 2.0 in global AS.

[mgrang]

lib/Sema/SemaDecl.cpp

6605

Check alignment of comments.

6625

Can you combine the assignment to PT inside the if condition? Like:

if (foo = something())

6629

Any reason why this cannot be a while loop instead of a do..while loop?

[yaxunl]

I am not sure about the restriction that program scope pointer must point to global or constant addr space. Can you provide reference to the OpenCL 2.0 spec?

https://www.khronos.org/registry/cl/specs/opencl-2.0-openclc.pdf

On page 36 there are examples for program-scope pointers:

int *foo; // OK. foo is allocated in global address space.

// pointer to foo in generic address space

int * global ptr; // OK.

It seems at least program-scope pointers pointing to generic addr space is also allowed.

[Anastasia]

After clarifying with Khronos, it doesn't seem like this is needed indeed!

include/clang/Basic/DiagnosticSemaKinds.td

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">;
 def err_sampler_argument_required : Error<
   "sampler_t variable required - got %0">;
 def err_wrong_sampler_addressspace: Error<
   "sampler type cannot be used with the __local and __global address space qualifiers">;
 def err_opencl_global_invalid_addr_space : Error<
-  "program scope variable must reside in %0 address space">;
+  "program scope %select{variable|pointer}0 must %select{reside in|point to}0 %1 address space">;
 def err_missing_actual_pipe_type : Error<
   "missing actual type specifier for pipe">;
 def err_reference_pipe_type : Error <
   "pipes packet types cannot be of reference type">;
 def err_opencl_no_main : Error<"%select{function|kernel}0 cannot be called 'main'">;
 def err_opencl_kernel_attr :
   Error<"attribute %0 can only be applied to a kernel function">;
 def err_opencl_return_value_with_address_space : Error<

lib/Sema/SemaDecl.cpp

if (T->isBlockPointerType()) {
         return;
       }
     }
     // OpenCL v1.2 s6.5 - All program scope variables must be declared in the
     // __constant address space.
     // OpenCL v2.0 s6.5.1 - Variables defined at program scope and static
     // variables inside a function can also be declared in the global
     // address space.
-    if (NewVD->isFileVarDecl()) {
+    if (NewVD->isFileVarDecl() || NewVD->isStaticLocal()) {
+      // Program scope pointers can only point to data at the constant or global
+       // address space.
+      const PointerType *PT = nullptr;
+      bool IsPointerDecl = false;
+      do {
         if (!T->isSamplerT() &&
             !(T.getAddressSpace() == LangAS::opencl_constant ||
               (T.getAddressSpace() == LangAS::opencl_global &&
                getLangOpts().OpenCLVersion == 200))) {
           if (getLangOpts().OpenCLVersion == 200)
-          Diag(NewVD->getLocation(), diag::err_opencl_global_invalid_addr_space)
-              << "global or constant";
-        else
-          Diag(NewVD->getLocation(), diag::err_opencl_global_invalid_addr_space)
-              << "constant";
+            Diag(NewVD->getLocation(),
+                 diag::err_opencl_global_invalid_addr_space)
+                << IsPointerDecl << "global or constant";
+          else
+            Diag(NewVD->getLocation(),
+                 diag::err_opencl_global_invalid_addr_space)
+                << IsPointerDecl << "constant";
           NewVD->setInvalidDecl();
           return;
         }
-    } else {
-      // OpenCL v2.0 s6.5.1 - Variables defined at program scope and static
-      // variables inside a function can also be declared in the global
-      // address space.
-      if (NewVD->isStaticLocal() &&
-          !(T.getAddressSpace() == LangAS::opencl_constant ||
-            (T.getAddressSpace() == LangAS::opencl_global &&
-             getLangOpts().OpenCLVersion == 200))) {
-        if (getLangOpts().OpenCLVersion == 200)
-          Diag(NewVD->getLocation(), diag::err_opencl_global_invalid_addr_space)
-              << "global or constant";
-        else
-          Diag(NewVD->getLocation(), diag::err_opencl_global_invalid_addr_space)
-              << "constant";
-        NewVD->setInvalidDecl();
-        return;
+        PT = dyn_cast<const PointerType>(T.getTypePtr());
+        if (PT) {
+          T = PT->getPointeeType();
+          IsPointerDecl = true;
         }
+      } while (PT);
+    } else {
       // OpenCL v1.1 s6.5.2 and s6.5.3 no local or constant variables
       // in functions.
       if (T.getAddressSpace() == LangAS::opencl_constant ||
           T.getAddressSpace() == LangAS::opencl_local) {
         FunctionDecl *FD = getCurFunctionDecl();
         if (FD && !FD->hasAttr<OpenCLKernelAttr>()) {
           if (T.getAddressSpace() == LangAS::opencl_constant)
             Diag(NewVD->getLocation(), diag::err_opencl_non_kernel_variable)

test/CodeGenOpenCL/address-spaces.cl

 void fl(local int *arg) {}
 
 // CHECK: i32 addrspace(3)* %arg
 void fc(constant int *arg) {}
 
 #ifdef CL20
 int i;
 // CL20-DAG: @i = common addrspace(1) global i32 0
-int *ptr;
-// CL20-DAG: @ptr = common addrspace(1) global i32 addrspace(4)* null
+global int *ptr;
+// CL20-DAG: @ptr = common addrspace(1) global i32 addrspace(1)* null
 #endif
 
 // CHECK: i32* %arg
 // CL20-DAG: i32 addrspace(4)* %arg
 void f(int *arg) {
 
   int i;
 // CHECK: %i = alloca i32,
 // CL20-DAG: %i = alloca i32,
 
 #ifdef CL20
   static int ii;
 // CL20-DAG: @f.ii = internal addrspace(1) global i32 0
 #endif
 }

test/SemaOpenCL/storageclass-cl20.cl

 // RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -DCL20 -cl-std=CL2.0
 
 static constant int G1 = 0;
 int G2 = 0;
 global int G3 = 0;
-local int G4 = 0;// expected-error{{program scope variable must reside in global or constant address space}}
+local int G4 = 0;              // expected-error{{program scope variable must reside in global or constant address space}}
+global int **constant GP5 = 0; // expected-error{{program scope pointer must point to global or constant address space}}
+global int *global GP6 = 0;
 
 void kernel foo() {
   static int S1 = 5;
   static global int S2 = 5;
-  static private int S3 = 5;// expected-error{{program scope variable must reside in global or constant address space}}
+  static private int S3 = 5;   // expected-error{{program scope variable must reside in global or constant address space}}
+  static local int *global S4; // expected-error{{program scope pointer must point to global or constant address space}}
+  static constant int *global S5;
 
   constant int L1 = 0;
   local int L2;
 }

test/SemaOpenCL/storageclass.cl

 // RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL1.2
 
 static constant int G1 = 0;
 constant int G2 = 0;
 int G3 = 0;        // expected-error{{program scope variable must reside in constant address space}}
 global int G4 = 0; // expected-error{{program scope variable must reside in constant address space}}
 
+int *constant GP1 = 0;           // expected-error{{program scope pointer must point to constant address space}}
+int *constant *constant GP2 = 0; // expected-error{{program scope pointer must point to constant address space}}
+int **constant GP3 = 0;          // expected-error{{program scope pointer must point to constant address space}}
+constant int **constant GP4 = 0; // expected-error{{program scope pointer must point to constant address space}}
+global int *constant GP5 = 0;    // expected-error{{program scope pointer must point to constant address space}}
+constant int *constant GP6 = 0;
+
 void kernel foo() {
   // static is not allowed at local scope before CL2.0
   static int S1 = 5;          // expected-error{{variables in function scope cannot be declared static}}
   static constant int S2 = 5; // expected-error{{variables in function scope cannot be declared static}}
 
   constant int L1 = 0;
   local int L2;