[SYCL] Report deferred diagnostics in function templates

clang/lib/Sema/Sema.cpp

@@ -1770,8 +1770,15 @@ class DeferredDiagnosticsEmitter
   // Emit any deferred diagnostics for FD
   void emitDeferredDiags(FunctionDecl *FD, bool ShowCallStack) {
     auto It = S.DeviceDeferredDiags.find(FD);
-    if (It == S.DeviceDeferredDiags.end())
+    if (It == S.DeviceDeferredDiags.end()) {
+      // If this is a template instantiation, check if its declaration
+      // is on the deferred diagnostics stack.
+      if (FD->isTemplateInstantiation()) {
+        FD = FD->getTemplateInstantiationPattern();
+        emitDeferredDiags(FD, ShowCallStack);
+      }
       return;
+    }
     bool HasWarningOrError = false;
     bool FirstDiag = true;
     for (Sema::DeviceDeferredDiagnostic &D : It->second) {

clang/test/CodeGenSYCL/static-var-address-space.cpp

@@ -1,26 +1,12 @@
 // RUN: %clang_cc1 -fsycl-is-device -triple spir64-unknown-unknown -disable-llvm-passes -emit-llvm %s -o - | FileCheck %s
 #include "Inputs/sycl.hpp"
-struct C {
-  static int c;
-};
-
-template <typename T>
-struct D {
-  static T d;
-};
 
 template <typename T>
 void test() {
   // CHECK: @_ZZ4testIiEvvE1a = linkonce_odr addrspace(1) constant i32 0, comdat, align 4
   static const int a = 0;
   // CHECK: @_ZZ4testIiEvvE1b = linkonce_odr addrspace(1) constant i32 0, comdat, align 4
   static const T b = T(0);
-  // CHECK: @_ZN1C1cE = external addrspace(1) global i32, align 4
-  C::c = 10;
-  const C struct_c;
-  // CHECK: @_ZN1DIiE1dE = external addrspace(1) global i32, align 4
-  D<int>::d = 11;
-  const D<int> struct_d;
 }
 
 int main() {

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

@@ -51,13 +51,34 @@ void usage() {
 
 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 {{.*}})>}}
   // expected-error@+1{{SYCL kernel cannot use a const static or global variable that is neither zero-initialized nor constant-initialized}}
   kernelFunc(U<Base>::s2);
 }
 
+struct C {
+  static int c;
+};
+
+template <typename T>
+struct D {
+  static T d;
+};
+
+template <typename T>
+T D<T>::d = T();
+
+template <typename T>
+void test() {
+  // expected-error@+1{{SYCL kernel cannot use a non-const static data variable}}
+  C::c = 10;
+  // expected-error@+1{{SYCL kernel cannot use a non-const static data variable}}
+  D<int>::d = 11;
+}
+
 int main() {
   static int s2;
   kernel_single_task<class fake_kernel>([](S s4) {
@@ -66,6 +87,7 @@ int main() {
     s4.foo();
     // expected-error@+1{{SYCL kernel cannot use a non-const static data variable}}
     static int s3;
+    test<int>();
   });
 
   return 0;

clang/test/SemaSYCL/sycl-device-template-diag.cpp

@@ -0,0 +1,25 @@
+// RUN: %clang_cc1 -fsycl-is-device -verify -Wno-sycl-2017-compat -fsyntax-only %s -internal-isystem %S/Inputs
+
+// This test verifies that we generate deferred diagnostics when
+// such diagnostics are in a function template.
+
+#include "sycl.hpp"
+
+using namespace cl::sycl;
+queue q;
+
+int global_value = -1;
+
+template <typename T>
+void kernel_wrapper() {
+  q.submit([&](handler &h) {
+    h.single_task([=] {
+      // expected-error@+1{{SYCL kernel cannot use a non-const global variable}}
+      (void)global_value;
+    });
+  });
+}
+
+int main() {
+  kernel_wrapper<int>();
+}

clang/test/SemaSYCL/wrong-address-taking.cpp

@@ -45,14 +45,12 @@ void basicUsage() {
 
 template <typename T> void templatedContext() {
 
-  // FIXME: this is likely not diagnosed because of a common problem among
-  // deferred diagnostics. They don't work from templated context if the
-  // problematic code doesn't depend on a template parameter. See
-  // https://github.com/intel/llvm/pull/5114 for an explanation of the problem
-  // and possible solution.
+  // expected-error@+1 {{taking address of a function not marked with 'intel::device_indirectly_callable' attribute is not allowed in SYCL device code}}
   int (*p)(int) = &badFoo;
+  // expected-error@+1 {{taking address of a function not marked with 'intel::device_indirectly_callable' attribute is not allowed in SYCL device code}}
   auto p1 = &ForMembers::badMember;
 
+  // expected-error@+2 {{taking address of a function not marked with 'intel::device_indirectly_callable' attribute is not allowed in SYCL device code}}
   // expected-note@+1 {{called by 'templatedContext<int>'}}
   templateCaller1<badFoo>(1);
 }