[SYCL] Suppress warning for use of dllimport/dllexport attribute when

compile with -fsycl.

The change do following:
1>	Suppress warning for "_declspec attribute 'dllexport' is not
supported" when run with -fsycl
2>	Emit error when import function is called in the sycl kernel.

For example: for the test following:

bash-4.2$ clang -cc1 -triple spir64-unknown-windows-sycldevice
-fsycl-is-device -fms-extensions sycl-dllimport-dllexport.cpp

sycl-dllimport-dllexport.cpp:10:48: error: SYCL kernel cannot call a
dllimport function
  kernel_single_task<class fake_kernel>([]() { bar(); });
                                               ^
sycl-dllimport-dllexport.cpp:1:28: note: 'bar' declared here
int __declspec(dllimport) bar();
		          ^
1 error generated.
=== test ==
int __declspec(dllimport) bar();

template <typename name, typename Func> __attribute__((sycl_kernel))
void kernel_single_task(Func kernelFunc) {
    kernelFunc();
}
int main() {
 t status
 kernel_single_task<class fake_kernel>([]() { bar(); });
  return 0;
}

Signed-off-by: Yu <[email protected]>

Author: jyu2-git

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -9793,6 +9793,7 @@ def err_sycl_restrict : Error<
   "|allocate storage"
   "|use inline assembly"
   "|have a class with a virtual function table"
+  "|call a dllimport function"
   "|call a variadic function}0">;
 def err_sycl_virtual_types : Error<
   "No class with a vtable can be used in a SYCL kernel or any code included in the kernel">;

clang/include/clang/Sema/Sema.h

@@ -11426,6 +11426,7 @@ class Sema {
     KernelAllocateStorage,
     KernelUseAssembly,
     KernelHavePolymorphicClass,
+    KernelCallDllimportFunction,
     KernelCallVariadicFunction
  };
   DeviceDiagBuilder SYCLDiagIfDeviceCode(SourceLocation Loc, unsigned DiagID);

clang/lib/Sema/SemaDeclAttr.cpp

@@ -2066,7 +2066,10 @@ bool Sema::CheckAttrNoArgs(const ParsedAttr &Attrs) {
 
 bool Sema::CheckAttrTarget(const ParsedAttr &AL) {
   // Check whether the attribute is valid on the current target.
-  if (!AL.existsInTarget(Context.getTargetInfo())) {
+  const TargetInfo *Aux = Context.getAuxTargetInfo();
+  if (!(AL.existsInTarget(Context.getTargetInfo()) ||
+        (Context.getLangOpts().SYCLIsDevice &&
+         Aux && AL.existsInTarget(*Aux)))) {
     Diag(AL.getLoc(), diag::warn_unknown_attribute_ignored) << AL;
     AL.setInvalid();
     return true;
@@ -6935,8 +6938,11 @@ static void ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D,
   // Unknown attributes are automatically warned on. Target-specific attributes
   // which do not apply to the current target architecture are treated as
   // though they were unknown attributes.
+  const TargetInfo *Aux = S.Context.getAuxTargetInfo();
   if (AL.getKind() == ParsedAttr::UnknownAttribute ||
-      !AL.existsInTarget(S.Context.getTargetInfo())) {
+      !(AL.existsInTarget(S.Context.getTargetInfo()) ||
+        (S.Context.getLangOpts().SYCLIsDevice &&
+         Aux && AL.existsInTarget(*Aux)))) {
     S.Diag(AL.getLoc(),
            AL.isDeclspecAttribute()
                ? (unsigned)diag::warn_unhandled_ms_attribute_ignored

clang/lib/Sema/SemaSYCL.cpp

@@ -119,6 +119,18 @@ class MarkDeviceFunction : public RecursiveASTVisitor<MarkDeviceFunction> {
           SemaRef.addSyclDeviceDecl(Def);
         }
       }
+      if (auto const *FD = dyn_cast<FunctionDecl>(Callee)) {
+        //FIXME: We need check all target specified attributes for error if that
+        //function with attribute can not be called from sycl kernel.  The info
+        //is in ParsedAttr. We don't have to map from Attr to ParsedAttr
+        //currently. Erich is currently working on that in LLVM, once that is
+        //committed we need to change this".
+        if (FD->hasAttr<DLLImportAttr>()) {
+          SemaRef.Diag(e->getExprLoc(), diag::err_sycl_restrict)
+            << Sema::KernelCallDllimportFunction;
+          SemaRef.Diag(FD->getLocation(), diag::note_callee_decl) << FD;
+        }
+      }
     } else if (!SemaRef.getLangOpts().SYCLAllowFuncPtr &&
                !e->isTypeDependent())
       SemaRef.Diag(e->getExprLoc(), diag::err_sycl_restrict)

clang/test/SemaSYCL/sycl-dllimport-dllexport.cpp

@@ -0,0 +1,68 @@
+// RUN: %clang_cc1 -triple spir64-unknown-linux-sycldevice -fms-extensions \
+// RUN: -aux-triple x86_64-unknown-linux-gnu -fsycl-is-device  -fsyntax-only \
+// RUN: -DWARNCHECK %s -o /dev/null 2>&1 | FileCheck %s 
+// check random triple aux-triple with sycl-device
+
+// RUN: %clang_cc1 -triple spir64-unknown-windows-sycldevice  -fsyntax-only \
+// RUN: -fms-extensions -DWARNCHECK %s -o /dev/null 2>&1 | FileCheck %s 
+// check without -aux-triple but sycl-device
+
+// RUN: %clang_cc1 -triple spir64-unknown-windows-sycldevice -fsycl-is-device \
+// RUN: -aux-triple x86_64-pc-windows-msvc -fms-extensions -fsyntax-only \
+// RUN: -DWARNCHECK %s -o /dev/null 2>&1 | FileCheck %s --check-prefixes CHECKALL
+// check -aux-tripe without sycl-device 
+
+// RUN: %clang_cc1 -triple spir64-unknown-windows-sycldevice -fsyntax-only \
+// RUN: -aux-triple x86_64-pc-windows-msvc -fsycl-is-device -fms-extensions \
+// RUN: -verify  %s
+// check error message when dllimport function gets called in sycl-kernel cdoe
+
+#if defined(WARNCHECK)
+// CHECK: warning: __declspec attribute 'dllexport' is not supported
+int __declspec(dllexport) foo(int a) {
+  return a;
+}
+
+// CHECK: warning: __declspec attribute 'dllimport' is not supported
+int __declspec(dllimport) bar();
+
+
+// CHECK: warning: unknown attribute 'dllimport' ignored
+int [[dllimport]]xoo();
+
+// CHECKALL: warning: unknown attribute 'dllimport' ignored
+int zoo() __attribute__((dllimport));
+
+#else
+
+// emit error if dllimport function is called in sycl kernel
+int  __declspec(dllexport) foo(int a) {
+   return a;
+}
+// expected-note@+1 {{'bar' declared here}}
+int __declspec(dllimport) bar();
+// expected-note@+2 {{previous attribute is here}}
+// expected-note@+1 {{previous declaration is here}}
+int __declspec(dllimport) foobar();
+int foobar()  // expected-warning {{'foobar' redeclared without 'dllimport' attribute: previous 'dllimport' ignored}}
+{
+  return 10;
+}
+
+template <typename name, typename Func>
+__attribute__((sycl_kernel)) void kernel_single_task(Func kernelFunc) {
+  kernelFunc();
+}
+
+int main() {
+  foo(10);  // expected-no-error
+  bar();  // expected-no-error
+  kernel_single_task<class fake_kernel>([]() {
+    foo(10);// expected-no-error
+    bar(); // expected-error {{SYCL kernel cannot call a dllimport function}}
+    foobar(); // expected-no-error
+  });
+  bar();  // expected-no-error
+  return 0;
+}
+#endif