Merge from 'sycl' to 'sycl-web' (#1)

Author: iclsrc

clang/lib/Sema/SemaChecking.cpp

@@ -4545,6 +4545,12 @@ void Sema::checkCall(NamedDecl *FDecl, const FunctionProtoType *Proto,
 
   if (FD)
     diagnoseArgDependentDiagnoseIfAttrs(FD, ThisArg, Args, Loc);
+
+  // Diagnose variadic calls in SYCL.
+  if (FD && FD ->isVariadic() && getLangOpts().SYCLIsDevice &&
+      !isUnevaluatedContext() && !isKnownGoodSYCLDecl(FD))
+    SYCLDiagIfDeviceCode(Loc, diag::err_sycl_restrict)
+        << Sema::KernelCallVariadicFunction;
 }
 
 /// CheckConstructorCall - Check a constructor call for correctness and safety

clang/lib/Sema/SemaExpr.cpp

@@ -5404,12 +5404,6 @@ bool Sema::GatherArgumentsForCall(SourceLocation CallLoc, FunctionDecl *FDecl,
 
     // Otherwise do argument promotion, (C99 6.5.2.2p7).
     } else {
-      // Diagnose variadic calls in SYCL.
-      if (getLangOpts().SYCLIsDevice && !isUnevaluatedContext() &&
-          !isKnownGoodSYCLDecl(FDecl))
-        SYCLDiagIfDeviceCode(CallLoc, diag::err_sycl_restrict)
-            << Sema::KernelCallVariadicFunction;
-
       for (Expr *A : Args.slice(ArgIx)) {
         ExprResult Arg = DefaultVariadicArgumentPromotion(A, CallType, FDecl);
         Invalid |= Arg.isInvalid();

clang/lib/Sema/SemaOverload.cpp

@@ -14297,11 +14297,6 @@ Sema::BuildCallToObjectOfClassType(Scope *S, Expr *Obj,
 
   // If this is a variadic call, handle args passed through "...".
   if (Proto->isVariadic()) {
-    // Diagnose variadic calls in SYCL.
-    if (getLangOpts().SYCLIsDevice && !isUnevaluatedContext())
-      SYCLDiagIfDeviceCode(LParenLoc, diag::err_sycl_restrict)
-          << Sema::KernelCallVariadicFunction;
-
     // Promote the arguments (C99 6.5.2.2p7).
     for (unsigned i = NumParams, e = Args.size(); i < e; i++) {
       ExprResult Arg = DefaultVariadicArgumentPromotion(Args[i], VariadicMethod,

clang/lib/Sema/SemaSYCL.cpp

@@ -1393,10 +1393,6 @@ static bool isKnownEmitted(Sema &S, FunctionDecl *FD) {
   if (!FD)
     return true; // Seen in LIT testing
 
-  // Templates are emitted when they're instantiated.
-  if (FD->isDependentContext())
-    return false;
-
   if (FD->hasAttr<SYCLDeviceAttr>() || FD->hasAttr<SYCLKernelAttr>())
     return true;
 
@@ -1411,7 +1407,7 @@ Sema::DeviceDiagBuilder Sema::SYCLDiagIfDeviceCode(SourceLocation Loc,
          "Should only be called during SYCL compilation");
   FunctionDecl *FD = dyn_cast<FunctionDecl>(getCurLexicalContext());
   DeviceDiagBuilder::Kind DiagKind = [this, FD] {
-    if (ConstructingOpenCLKernel || (FD && FD->isDependentContext()))
+    if (ConstructingOpenCLKernel)
       return DeviceDiagBuilder::K_Nop;
     else if (isKnownEmitted(*this, FD))
       return DeviceDiagBuilder::K_ImmediateWithCallStack;

clang/test/SemaSYCL/inline-asm.cpp

@@ -23,6 +23,11 @@ template <typename name, typename Func>
 __attribute__((sycl_kernel)) void kernel_single_task(Func kernelFunc) {
   // expected-note@+1 {{called by 'kernel_single_task<fake_kernel, (lambda}}
   kernelFunc();
+#ifdef LINUX_ASM
+   __asm__("int3");  // expected-error {{SYCL kernel cannot use inline assembly}}
+#else
+   __asm int 3 // expected-error {{SYCL kernel cannot use inline assembly}}
+#endif // LINUX_ASM
 }
 
 int main() {

clang/test/SemaSYCL/sycl-callstack.cpp

@@ -0,0 +1,18 @@
+// RUN: %clang_cc1 -fcxx-exceptions -fsycl-is-device -verify -fsyntax-only -std=c++17 %s
+
+template <typename name, typename Func>
+__attribute__((sycl_kernel))
+void kernel_single_task(Func kernelFunc) {
+  // expected-note@+1 {{called by 'kernel_single_task}}
+    kernelFunc();
+}
+
+void foo() {
+    // expected-error@+1 {{SYCL kernel cannot use exceptions}}
+   throw 3;
+}
+
+int main() {
+// expected-note@+1 {{called by 'operator()'}}
+kernel_single_task<class fake_kernel>([]() { foo(); });
+}

clang/test/SemaSYCL/sycl-restrict.cpp

@@ -124,7 +124,6 @@ void eh_not_ok(void)
 
 void usage(myFuncDef functionPtr) {
 
-  // expected-note@+1 {{called by 'usage'}}
   eh_not_ok();
 
 #if ALLOW_FP
@@ -170,6 +169,7 @@ int use2 ( a_type ab, a_type *abp ) {
   return ns::glob +
   // expected-error@+1 {{SYCL kernel cannot use a global variable}}
     AnotherNS::moar_globals;
+  // expected-note@+1 {{called by 'use2'}}
   eh_not_ok();
   Check_RTTI_Restriction:: A *a;
   Check_RTTI_Restriction:: isa_B(a);
@@ -180,16 +180,15 @@ int use2 ( a_type ab, a_type *abp ) {
 
 template <typename name, typename Func>
 __attribute__((sycl_kernel)) void kernel_single_task(Func kernelFunc) {
-  // expected-note@+1 {{called by 'kernel_single_task}}
   kernelFunc();
   a_type ab;
   a_type *p;
+  // expected-note@+1 {{called by 'kernel_single_task'}}
   use2(ab, p);
 }
 
 int main() {
   a_type ab;
-  // expected-note@+1 {{called by 'operator()'}}
   kernel_single_task<class fake_kernel>([]() { usage(  &addInt ); });
   return 0;
 }

sycl/doc/SYCLCompilerAndRuntimeDesign.md

@@ -154,22 +154,16 @@ targets like SPIR-V).
 
 #### Enable SYCL offload
 
-To enable compilation following the SYCL specification, a special option
+To enable compilation following single-source multiple compiler-passes (SMCP)
+technique which is described in the SYCL specification, a special option
 must be passed to the clang driver:
 
 `-fsycl`
 
 With this option specified, the driver will invoke the host SYCL compiler and a
 number of device compilers for targets specified in the `-fsycl-targets`
-option.  If this option is not specified, then single SPIR-V target is assumed,
-and single device compiler for this target is invoked.
-
-In the driver, the following bools are defined to determine the compilation
-mode in SYCL:
-
-* IsSYCL : True if the user has passed `-fsycl-device-only` to the compilation
-* IsSYCLOffloadDevice: True if calling clang to set up a device compilation
-* IsSYCLHost: True if setting up a call to clang to do a host compilation
+option.  If `-fsycl-targets` is not specified, then single SPIR-V target is
+assumed, and single device compiler for this target is invoked.
 
 The option `-sycl-std` allows specifying which version of
 the SYCL standard will be used for the compilation.