[SYCL] Error out instead of crash when templated global var used (#5195)

SYCL deferred diagnostics couldn't catch the case like:
```
template <typename T>
class randomType {
 public:
  randomType() {}
  T val;
};

template <typename T>
const randomType<T> Var;

SYCL_EXTERNAL void foo() {
  (void)Var<int>;
}
```
And CodeGen was crashing due to attempt to emit invalid cast.
That happened because use of `Var` should be diagnosed. The diagnostic
wasn't emitted because at the places where deferred diagnostic is issued
for this case, templated variable doesn't yet has initializer, or it has
it but current lexical context is out of device code (in this particular
case it will be a translation unit). This patch follows the logic
invented by `finalizeOpenMPDelayedAnalysis` and `finalizeSYCLDelayedAnalysis`
routines, i.e. emit immediate diagnostic when post-parsing of AST for
deferred diagnostics happens.

Author: Fznamznon

clang/lib/Sema/Sema.cpp

@@ -1679,6 +1679,15 @@ class DeferredDiagnosticsEmitter
   }
 
   void visitUsedDecl(SourceLocation Loc, Decl *D) {
+    if (S.LangOpts.SYCLIsDevice && ShouldEmitRootNode) {
+      if (auto *VD = dyn_cast<VarDecl>(D)) {
+        if (!S.checkAllowedSYCLInitializer(VD)) {
+          S.Diag(Loc, diag::err_sycl_restrict)
+              << Sema::KernelConstStaticVariable;
+          return;
+        }
+      }
+    }
     if (isa<VarDecl>(D))
       return;
     if (auto *FD = dyn_cast<FunctionDecl>(D)) {

clang/lib/Sema/SemaDecl.cpp

@@ -18729,16 +18729,14 @@ Sema::FunctionEmissionStatus Sema::getEmissionStatus(FunctionDecl *FD,
                                                      bool Final) {
   assert(FD && "Expected non-null FunctionDecl");
 
-  // SYCL functions can be template, so we check if they have appropriate
-  // attribute prior to checking if it is a template.
-  if (LangOpts.SYCLIsDevice &&
-      (FD->hasAttr<SYCLDeviceAttr>() || FD->hasAttr<SYCLKernelAttr>()))
-    return FunctionEmissionStatus::Emitted;
-
   // Templates are emitted when they're instantiated.
   if (FD->isDependentContext())
     return FunctionEmissionStatus::TemplateDiscarded;
 
+  if (LangOpts.SYCLIsDevice &&
+      (FD->hasAttr<SYCLDeviceAttr>() || FD->hasAttr<SYCLKernelAttr>()))
+    return FunctionEmissionStatus::Emitted;
+
   // Check whether this function is an externally visible definition.
   auto IsEmittedForExternalSymbol = [this, FD]() {
     // We have to check the GVA linkage of the function's *definition* -- if we

clang/lib/Sema/SemaExpr.cpp

@@ -246,12 +246,6 @@ bool Sema::DiagnoseUseOfDecl(NamedDecl *D, ArrayRef<SourceLocation> Locs,
         SYCLDiagIfDeviceCode(*Locs.begin(),
                              diag::err_esimd_global_in_sycl_context,
                              Sema::DeviceDiagnosticReason::Sycl);
-      // Disallow const statics and globals that are not zero-initialized
-      // or constant-initialized.
-      else if (IsRuntimeEvaluated && IsConst && VD->hasGlobalStorage() &&
-               !VD->isConstexpr() && !checkAllowedSYCLInitializer(VD))
-        SYCLDiagIfDeviceCode(*Locs.begin(), diag::err_sycl_restrict)
-            << Sema::KernelConstStaticVariable;
     } else if (auto *FDecl = dyn_cast<FunctionDecl>(D)) {
       // SYCL device function cannot be called from an ESIMD context. However,
       // funcitons that start with '__spirv_' or '__sycl_' are exceptions to

clang/lib/Sema/SemaSYCL.cpp

@@ -4050,11 +4050,6 @@ void Sema::finalizeSYCLDelayedAnalysis(const FunctionDecl *Caller,
                                        const FunctionDecl *Callee,
                                        SourceLocation Loc,
                                        DeviceDiagnosticReason Reason) {
-  // Somehow an unspecialized template appears to be in callgraph or list of
-  // device functions. We don't want to emit diagnostic here.
-  if (Callee->getTemplatedKind() == FunctionDecl::TK_FunctionTemplate)
-    return;
-
   Callee = Callee->getMostRecentDecl();
 
   // If the reason for the emission of this diagnostic is not SYCL-specific,

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

@@ -5717,10 +5717,6 @@ void Sema::InstantiateVariableInitializer(
 
   if (getLangOpts().CUDA)
     checkAllowedCUDAInitializer(Var);
-
-  if (getLangOpts().SYCLIsDevice && !checkAllowedSYCLInitializer(Var))
-    SYCLDiagIfDeviceCode(Var->getLocation(), diag::err_sycl_restrict)
-        << Sema::KernelConstStaticVariable;
 }
 
 /// Instantiate the definition of the given variable from its

clang/test/SemaSYCL/inline-asm.cpp

@@ -22,7 +22,7 @@ static __inline unsigned int
 asm_func_2(unsigned int __leaf, unsigned long __d[]) {
   unsigned int __result;
 #ifdef SPIR_CHECK
-  //expected-error@+2 2{{invalid output constraint '=a' in asm}}
+  // expected-error@+2 {{invalid output constraint '=a' in asm}}
   __asm__("enclu"
           : "=a"(__result), "=b"(__d[0]), "=c"(__d[1]), "=d"(__d[2])
           : "a"(__leaf), "b"(__d[0]), "c"(__d[1]), "d"(__d[2])
@@ -58,7 +58,7 @@ __attribute__((sycl_kernel)) void kernel_single_task(const Func &kernelFunc) {
 #ifdef SPIR_CHECK
   unsigned int i = 3;
   unsigned long d[4];
-  //expected-note@+1 2{{called by 'kernel_single_task}}
+  // expected-note@+1 {{called by 'kernel_single_task}}
   asm_func_2(i, d);
 #endif // SPIR_CHECK
 #else

clang/test/SemaSYCL/sycl-device-const-static.cpp

@@ -22,6 +22,16 @@ template struct U<Base>;
 
 const S s5;
 
+template <typename T>
+class randomType {
+public:
+  randomType() {}
+  T val;
+};
+
+template <typename T>
+const randomType<T> Var;
+
 void usage() {
   // expected-error@+1{{SYCL kernel cannot use a non-const static data variable}}
   static int s1;
@@ -34,11 +44,13 @@ void usage() {
   (void)s5;
   // expected-error@+1{{SYCL kernel cannot use a const static or global variable that is neither zero-initialized nor constant-initialized}}
   (void)s6;
+
+  // expected-error@+1{{SYCL kernel cannot use a const static or global variable that is neither zero-initialized nor constant-initialized}}
+  (void)Var<int>;
 }
 
 template <typename Name, typename Func>
 __attribute__((sycl_kernel)) void kernel_single_task(const Func &kernelFunc) {
-  // expected-error@+1{{SYCL kernel cannot use a non-const static data variable}}
   static int z;
   // expected-note-re@+3{{called by 'kernel_single_task<fake_kernel, (lambda at {{.*}})>}}
   // expected-note-re@+2{{called by 'kernel_single_task<fake_kernel, (lambda at {{.*}})>}}