[SYCL] non-const static variables defined outside kernel must be forbidden in it. (fix #4)

Signed-off-by: Aleksander Fadeev <[email protected]>

Author: fadeeval

clang/lib/Sema/SemaSYCL.cpp

@@ -322,15 +322,15 @@ class MarkDeviceFunction : public RecursiveASTVisitor<MarkDeviceFunction> {
   }
 
   bool VisitDeclRefExpr(DeclRefExpr *E) {
-    Decl* D = E->getDecl();
+    Decl *D = E->getDecl();
     if (SemaRef.isKnownGoodSYCLDecl(D))
       return true;
 
     CheckSYCLType(E->getType(), E->getSourceRange());
     if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
       bool IsConst = VD->getType().getNonReferenceType().isConstQualified();
       if (!IsConst && VD->hasGlobalStorage() && !VD->isStaticLocal() &&
-               !VD->isStaticDataMember() && !isa<ParmVarDecl>(VD)) {
+          !VD->isStaticDataMember() && !isa<ParmVarDecl>(VD)) {
         if (VD->getTLSKind() != VarDecl::TLS_None)
           SemaRef.Diag(E->getLocation(), diag::err_thread_unsupported);
         SemaRef.Diag(E->getLocation(), diag::err_sycl_restrict)

clang/test/SemaSYCL/sycl-restrict.cpp

@@ -2,40 +2,39 @@
 // RUN: %clang_cc1 -fcxx-exceptions -triple spir64 -fsycl-is-device -fno-sycl-allow-func-ptr -Wno-return-type -verify -fsyntax-only -std=c++17 %s
 // RUN: %clang_cc1 -fcxx-exceptions -triple spir64 -fsycl-is-device -DALLOW_FP=1 -fsycl-allow-func-ptr -Wno-return-type -verify -fsyntax-only -std=c++17 %s
 
-
 namespace std {
-  class type_info;
-  typedef __typeof__(sizeof(int)) size_t;
-}
+class type_info;
+typedef __typeof__(sizeof(int)) size_t;
+} // namespace std
 namespace Check_User_Operators {
-class Fraction
-{
-    // expected-error@+2 {{SYCL kernel cannot call a recursive function}}
-    // expected-note@+1 {{function implemented using recursion declared here}}
-    int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
-    int n, d;
+class Fraction {
+  // expected-error@+2 {{SYCL kernel cannot call a recursive function}}
+  // expected-note@+1 {{function implemented using recursion declared here}}
+  int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
+  int n, d;
+
 public:
-    Fraction(int n, int d = 1) : n(n/gcd(n, d)), d(d/gcd(n, d)) { }
-    int num() const { return n; }
-    int den() const { return d; }
+  Fraction(int n, int d = 1) : n(n / gcd(n, d)), d(d / gcd(n, d)) {}
+  int num() const { return n; }
+  int den() const { return d; }
 };
-bool operator==(const Fraction& lhs, const Fraction& rhs)
-{
-    new int; // expected-error {{SYCL kernel cannot allocate storage}}
-    return lhs.num() == rhs.num() && lhs.den() == rhs.den();
-}}
+bool operator==(const Fraction &lhs, const Fraction &rhs) {
+  new int; // expected-error {{SYCL kernel cannot allocate storage}}
+  return lhs.num() == rhs.num() && lhs.den() == rhs.den();
+}
+} // namespace Check_User_Operators
 
 namespace Check_VLA_Restriction {
 void no_restriction(int p) {
-  int index[p+2];
+  int index[p + 2];
 }
 void restriction(int p) {
   // expected-error@+1 {{variable length arrays are not supported for the current target}}
-  int index[p+2];
-}
+  int index[p + 2];
 }
+} // namespace Check_VLA_Restriction
 
-void* operator new (std::size_t size, void* ptr) throw() { return ptr; };
+void *operator new(std::size_t size, void *ptr) throw() { return ptr; };
 namespace Check_RTTI_Restriction {
 struct A {
   virtual ~A(){};
@@ -50,35 +49,38 @@ struct OverloadedNewDelete {
   void *operator new(std::size_t size) throw() {
     // expected-error@+1 {{SYCL kernel cannot allocate storage}}
     float *pt = new float;
-    return 0;}
+    return 0;
+  }
   // This overload does not allocate: no diagnostic.
-  void *operator new[](std::size_t size) throw() {return 0;}
+  void *operator new[](std::size_t size) throw() { return 0; }
   void operator delete(void *){};
   void operator delete[](void *){};
 };
 
 bool isa_B(A *a) {
   Check_User_Operators::Fraction f1(3, 8), f2(1, 2), f3(10, 2);
-  if (f1 == f2) return false;
+  if (f1 == f2)
+    return false;
 
   Check_VLA_Restriction::restriction(7);
   // expected-error@+1 {{SYCL kernel cannot allocate storage}}
   int *ip = new int;
-  int i; int *p3 = new(&i) int; // no error on placement new
+  int i;
+  int *p3 = new (&i) int; // no error on placement new
   // expected-note@+1 {{called by 'isa_B'}}
-  OverloadedNewDelete *x = new( struct OverloadedNewDelete );
-  auto y = new struct OverloadedNewDelete [5];
+  OverloadedNewDelete *x = new (struct OverloadedNewDelete);
+  auto y = new struct OverloadedNewDelete[5];
   // expected-error@+1 {{SYCL kernel cannot use rtti}}
   (void)typeid(int);
   // expected-error@+1 {{SYCL kernel cannot use rtti}}
   return dynamic_cast<B *>(a) != 0;
 }
 
-template<typename N, typename L>
+template <typename N, typename L>
 __attribute__((sycl_kernel)) void kernel1(L l) {
   l();
 }
-}
+} // namespace Check_RTTI_Restriction
 
 typedef struct Base {
   virtual void f() const {}
@@ -87,22 +89,19 @@ typedef struct Base {
 typedef struct A {
   static int stat_member;
   const static int const_stat_member;
-  constexpr static int constexpr_stat_member=0;
+  constexpr static int constexpr_stat_member = 0;
 
-  int fm(void)
-  {
+  int fm(void) {
     // expected-error@+1 {{SYCL kernel cannot use a non-const static data variable}}
     return stat_member;
   }
 } a_type;
 
-
 b_type b;
 
-using myFuncDef = int(int,int);
+using myFuncDef = int(int, int);
 
-void eh_ok(void)
-{
+void eh_ok(void) {
   __float128 A;
   try {
     ;
@@ -112,8 +111,7 @@ void eh_ok(void)
   throw 20;
 }
 
-void eh_not_ok(void)
-{
+void eh_not_ok(void) {
   // expected-error@+1 {{SYCL kernel cannot use exceptions}}
   try {
     ;
@@ -146,45 +144,51 @@ void usage(myFuncDef functionPtr) {
 }
 
 namespace ns {
-  int glob;
+int glob;
 }
 extern "C++" {
-  int another_global = 5;
-  namespace AnotherNS {
-    int moar_globals = 5;
-   }
+int another_global = 5;
+namespace AnotherNS {
+int moar_globals = 5;
+}
 }
 
 int addInt(int n, int m) {
-    return n+m;
+  return n + m;
 }
 
-int use2 ( a_type ab, a_type *abp ) {
+int use2(a_type ab, a_type *abp) {
 
-  if (ab.constexpr_stat_member) return 2;
-  if (ab.const_stat_member) return 1;
+  if (ab.constexpr_stat_member)
+    return 2;
+  if (ab.const_stat_member)
+    return 1;
   // expected-error@+1 {{SYCL kernel cannot use a non-const static data variable}}
-  if (ab.stat_member) return 0;
+  if (ab.stat_member)
+    return 0;
   // expected-error@+1 {{SYCL kernel cannot use a non-const static data variable}}
-  if (abp->stat_member) return 0;
+  if (abp->stat_member)
+    return 0;
   // expected-note@+1 {{called by 'use2'}}
-  if (ab.fm()) return 0;
+  if (ab.fm())
+    return 0;
   // expected-error@+1 {{SYCL kernel cannot use a non-const global variable}}
-  return another_global ;
+  return another_global;
   // expected-error@+1 {{SYCL kernel cannot use a non-const global variable}}
   return ns::glob +
-  // expected-error@+1 {{SYCL kernel cannot use a non-const global variable}}
-    AnotherNS::moar_globals;
+         // expected-error@+1 {{SYCL kernel cannot use a non-const global variable}}
+         AnotherNS::moar_globals;
   // expected-note@+1 {{called by 'use2'}}
   eh_not_ok();
-  Check_RTTI_Restriction:: A *a;
+  Check_RTTI_Restriction::A *a;
   // expected-note@+1 2{{called by 'use2'}}
-  Check_RTTI_Restriction:: isa_B(a);
+  Check_RTTI_Restriction::isa_B(a);
   // expected-note@+1 {{called by 'use2'}}
   usage(&addInt);
   Check_User_Operators::Fraction f1(3, 8), f2(1, 2), f3(10, 2);
   // expected-note@+1 {{called by 'use2'}}
-  if (f1 == f2) return false;
+  if (f1 == f2)
+    return false;
 }
 
 template <typename name, typename Func>
@@ -198,7 +202,6 @@ __attribute__((sycl_kernel)) void kernel_single_task(Func kernelFunc) {
 
 int main() {
   a_type ab;
-  kernel_single_task<class fake_kernel>([]() { usage(  &addInt ); });
+  kernel_single_task<class fake_kernel>([]() { usage(&addInt); });
   return 0;
 }
-