[OpenCL] Disallows static kernel functions in C++ for OpenCL

[Topotuna]

Summary

It is disallowed in OpenCL C to declare static kernel functions and
C++ for OpenCL is expected to inherit such behaviour. Error is now
correctly reported in C++ for OpenCL when declaring a static kernel
function.

[Anastasia]

clang/lib/Sema/SemaDecl.cpp

9972

I wonder though if we should just drop a version check here completely.

I don't think we can allow this in the earlier OpenCL versions. The reason why it doesn't apply to earlier versions is that static/extern wasn't allowed at all so presumably frontend would reject such a case earlier.

I think the extra check is not doing anything useful here, but only adds extra code to read and maintain.

[Topotuna]

clang/lib/Sema/SemaDecl.cpp

9972

That is correct. If static or extern is used in OpenCL C 1.0, diagnostic err_opencl_unknown_type_specifier is displayed before control flow reaches this part of code. And so removing the check here doesn't seem to change the compiler behaviour.

[Topotuna]

Condition on OpenCL C / C++ for OpenCL version removed because it was redundant.

[Anastasia]

Cool! Thanks

clang/lib/Sema/SemaDecl.cpp

Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC,
   }
 
   MarkUnusedFileScopedDecl(NewFD);
 
 
 
   if (getLangOpts().OpenCL && NewFD->hasAttr<OpenCLKernelAttr>()) {
     // OpenCL v1.2 s6.8 static is invalid for kernel functions.
-    if ((getLangOpts().OpenCLVersion >= 120)
-        && (SC == SC_Static)) {
+    if ((getLangOpts().getOpenCLCompatibleVersion() >= 120) &&
+        (SC == SC_Static)) {
       Diag(D.getIdentifierLoc(), diag::err_static_kernel);
       D.setInvalidType();
     }
 
     // OpenCL v1.2, s6.9 -- Kernels can only have return type void.
     if (!NewFD->getReturnType()->isVoidType()) {
       SourceRange RTRange = NewFD->getReturnTypeSourceRange();
       Diag(D.getIdentifierLoc(), diag::err_expected_kernel_void_return_type)

clang/test/SemaOpenCL/storageclass-cl20.cl

 // RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=CL2.0
+// RUN: %clang_cc1 %s -verify -pedantic -fsyntax-only -cl-std=clc++1.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}}
 
 static float g_implicit_static_var = 0;
 static constant float g_constant_static_var = 0;
 static global float g_global_static_var = 0;
 static local float g_local_static_var = 0;     // expected-error {{program scope variable must reside in global or constant address space}}
 static private float g_private_static_var = 0; // expected-error {{program scope variable must reside in global or constant address space}}
 static generic float g_generic_static_var = 0; // expected-error {{program scope variable must reside in global or constant address space}}
 
 extern float g_implicit_extern_var;
 extern constant float g_constant_extern_var;
 extern global float g_global_extern_var;
 extern local float g_local_extern_var;     // expected-error {{extern variable must reside in global or constant address space}}
 extern private float g_private_extern_var; // expected-error {{extern variable must reside in global or constant address space}}
 extern generic float g_generic_extern_var; // expected-error {{extern variable must reside in global or constant address space}}
 
+static void kernel bar() { // expected-error{{kernel functions cannot be declared static}}
+}
+
 void kernel foo() {
   constant int L1 = 0;
   local int L2;
   global int L3;                              // expected-error{{function scope variable cannot be declared in global address space}}
   generic int L4;                             // expected-error{{automatic variable qualified with an invalid address space}}
   __attribute__((address_space(100))) int L5; // expected-error{{automatic variable qualified with an invalid address space}}
 
   static float l_implicit_static_var = 0;