[SYCL] Implement a builtin to mark a sycl kernel

clang/docs/LanguageExtensions.rst

@@ -2438,6 +2438,22 @@ their usual pattern without any special treatment.
   // Computes a unique stable name for the given type.
   constexpr const char * __builtin_sycl_unique_stable_name( type-id );
 
+``__builtin_sycl_mark_kernel_name``
+---------------------------------
+
+``__builtin_sycl_mark_kernel_name`` is a builtin that can be used with
+``__builtin_sycl_unique_stable_name`` to make sure a kernel is properly 'marked'
+as a kernel without having to instantiate a sycl_kernel function.  This is useful
+for cases where the library needs to do some work with KernelInfo on the kernel
+type before the instantiation.
+
+**Syntax**:
+
+.. code-block:: c
+
+  // Marks a type as the name of a sycl kernel.
+  constexpr bool  __builtin_sycl_mark_kernel_name( type-id );
+
 Multiprecision Arithmetic Builtins
 ----------------------------------
 

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -6395,8 +6395,8 @@ def warn_gnu_null_ptr_arith : Warning<
   "arithmetic on a null pointer treated as a cast from integer to pointer is a GNU extension">,
   InGroup<NullPointerArithmetic>, DefaultIgnore;
 def err_kernel_invalidates_sycl_unique_stable_name
-    : Error<"kernel instantiation changes the result of an evaluated "
-            "'__builtin_sycl_unique_stable_name'">;
+    : Error<"kernel %select{naming|instantiation}0 changes the result of an "
+            "evaluated '__builtin_sycl_unique_stable_name'">;
 def note_sycl_unique_stable_name_evaluated_here
     : Note<"'__builtin_sycl_unique_stable_name' evaluated here">;
 

clang/include/clang/Basic/TokenKinds.def

@@ -710,6 +710,8 @@ KEYWORD(__builtin_bit_cast               , KEYALL)
 KEYWORD(__builtin_available              , KEYALL)
 KEYWORD(__builtin_sycl_unique_stable_name, KEYSYCL)
 
+TYPE_TRAIT_1(__builtin_sycl_mark_kernel_name, SYCLMarkKernelName, KEYSYCL)
+
 // Clang-specific keywords enabled only in testing.
 TESTING_KEYWORD(__unknown_anytype , KEYALL)
 

clang/include/clang/Sema/Sema.h

@@ -1069,8 +1069,13 @@ class Sema final {
     OpaqueParser = P;
   }
 
+  // Marks a type as a SYCL Kernel without necessarily adding it.  Additionally,
+  // it diagnoses if this causes any of the evaluated
+  // __builtin_sycl_unique_stable_name values to change.
+  void MarkSYCLKernel(SourceLocation NewLoc, QualType Ty, bool IsInstantiation);
   // Does the work necessary to deal with a SYCL kernel lambda. At the moment,
-  // this just marks the list of lambdas required to name the kernel.
+  // this just marks the list of lambdas required to name the kernel. It does
+  // this by dispatching to MarkSYCLKernel, so it also does the diagnostics.
   void AddSYCLKernelLambda(const FunctionDecl *FD);
 
   class DelayedDiagnostics;

clang/lib/Parse/ParseExpr.cpp

@@ -893,6 +893,7 @@ class CastExpressionIdValidator final : public CorrectionCandidateCallback {
 /// [Clang] unary-type-trait:
 ///                   '__is_aggregate'
 ///                   '__trivially_copyable'
+///                   '__builtin_sycl_mark_kernel_name'
 ///
 ///       binary-type-trait:
 /// [GNU]             '__is_base_of'

clang/lib/Sema/SemaExprCXX.cpp

@@ -4728,6 +4728,10 @@ static bool CheckUnaryTypeTraitTypeCompleteness(Sema &S, TypeTrait UTT,
 
     return !S.RequireCompleteType(
         Loc, ArgTy, diag::err_incomplete_type_used_in_type_trait_expr);
+
+  // Only the type name matters, not the completeness, so always return true.
+  case UTT_SYCLMarkKernelName:
+    return true;
   }
 }
 
@@ -5164,6 +5168,9 @@ static bool EvaluateUnaryTypeTrait(Sema &Self, TypeTrait UTT,
     return !T->isIncompleteType();
   case UTT_HasUniqueObjectRepresentations:
     return C.hasUniqueObjectRepresentations(T);
+  case UTT_SYCLMarkKernelName:
+    Self.MarkSYCLKernel(KeyLoc, T, /*IsInstantiation*/ false);
+    return true;
   }
 }
 

clang/lib/Sema/SemaSYCL.cpp

@@ -5222,7 +5222,8 @@ static QualType GetSYCLKernelObjectType(const FunctionDecl *KernelCaller) {
   return KernelParamTy;
 }
 
-void Sema::AddSYCLKernelLambda(const FunctionDecl *FD) {
+void Sema::MarkSYCLKernel(SourceLocation NewLoc, QualType Ty,
+                          bool IsInstantiation) {
   auto MangleCallback = [](ASTContext &Ctx,
                            const NamedDecl *ND) -> llvm::Optional<unsigned> {
     if (const auto *RD = dyn_cast<CXXRecordDecl>(ND))
@@ -5232,9 +5233,27 @@ void Sema::AddSYCLKernelLambda(const FunctionDecl *FD) {
     return 1;
   };
 
-  QualType Ty = GetSYCLKernelObjectType(FD);
   std::unique_ptr<MangleContext> Ctx{ItaniumMangleContext::create(
       Context, Context.getDiagnostics(), MangleCallback)};
   llvm::raw_null_ostream Out;
   Ctx->mangleTypeName(Ty, Out);
+
+  // Evaluate whether this would change any of the already evaluated
+  // __builtin_sycl_unique_stable_name values.
+  for (auto &Itr : Context.SYCLUniqueStableNameEvaluatedValues) {
+    const std::string &CurName = Itr.first->ComputeName(Context);
+    if (Itr.second != CurName) {
+      Diag(NewLoc, diag::err_kernel_invalidates_sycl_unique_stable_name)
+          << IsInstantiation;
+      Diag(Itr.first->getLocation(),
+           diag::note_sycl_unique_stable_name_evaluated_here);
+      // Update this so future diagnostics work correctly.
+      Itr.second = CurName;
+    }
+  }
+}
+
+void Sema::AddSYCLKernelLambda(const FunctionDecl *FD) {
+  QualType Ty = GetSYCLKernelObjectType(FD);
+  MarkSYCLKernel(FD->getLocation(), Ty, /*IsInstantiation*/ true);
 }

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

@@ -773,20 +773,6 @@ static void instantiateDependentSYCLKernelAttr(
   // instantiation of a kernel.
   S.AddSYCLKernelLambda(cast<FunctionDecl>(New));
 
-  // Evaluate whether this would change any of the already evaluated
-  // __builtin_sycl_unique_stable_name values.
-  for (auto &Itr : S.Context.SYCLUniqueStableNameEvaluatedValues) {
-    const std::string &CurName = Itr.first->ComputeName(S.Context);
-    if (Itr.second != CurName) {
-      S.Diag(New->getLocation(),
-             diag::err_kernel_invalidates_sycl_unique_stable_name);
-      S.Diag(Itr.first->getLocation(),
-             diag::note_sycl_unique_stable_name_evaluated_here);
-      // Update this so future diagnostics work correctly.
-      Itr.second = CurName;
-    }
-  }
-
   New->addAttr(Attr.clone(S.getASTContext()));
 }
 

clang/test/CodeGenSYCL/mark-kernel-name.cpp

@@ -0,0 +1,17 @@
+// RUN: %clang_cc1 -triple x86_64-linux-pc  -fsycl-is-host -disable-llvm-passes -emit-llvm %s -o - | FileCheck %s
+
+
+int main() {
+  auto lambda1 = [](){};
+  auto lambda2 = [](){};
+
+  (void)__builtin_sycl_unique_stable_name(decltype(lambda1));
+  // CHECK: [17 x i8] c"_ZTSZ4mainEUlvE_\00"
+
+  // Should change the unique-stable-name of the lambda.
+  (void)__builtin_sycl_mark_kernel_name(decltype(lambda2));
+  (void)__builtin_sycl_unique_stable_name(decltype(lambda2));
+  // CHECK: [22 x i8] c"_ZTSZ4mainEUlvE10000_\00"
+}
+
+

clang/test/SemaSYCL/mark-kernel-name.cpp

@@ -0,0 +1,50 @@
+// RUN: %clang_cc1 %s -std=c++17 -triple x86_64-linux-gnu -Wno-sycl-2020-compat -fsycl-is-device -verify -fsyntax-only -Wno-unused
+
+template <typename KernelName, typename KernelType>
+[[clang::sycl_kernel]] void kernel_single_task(KernelType kernelFunc) { // #kernelSingleTask
+  kernelFunc();
+}
+
+template <typename KN>
+struct KernelInfo {
+  static constexpr const char *c = __builtin_sycl_unique_stable_name(KN); // #KI_USN
+};
+
+template <typename KN>
+struct FixedKernelInfo {
+  static constexpr bool b = __builtin_sycl_mark_kernel_name(KN);
+  // making 'c' dependent on 'b' is necessary to ensure 'b' gets called first.
+  static constexpr const char *c = b
+                                       ? __builtin_sycl_unique_stable_name(KN)
+                                       : nullptr;
+};
+
+template <template <typename> class KI,
+          typename KernelName,
+          typename KernelType>
+void wrapper(KernelType KernelFunc) {
+  (void)KI<KernelName>::c;
+  kernel_single_task<KernelName>(KernelFunc); // #SingleTaskInst
+}
+
+int main() {
+  []() {
+    class KernelName1;
+    constexpr const char *C = __builtin_sycl_unique_stable_name(KernelName1);
+    // expected-error@+2 {{kernel naming changes the result of an evaluated '__builtin_sycl_unique_stable_name'}}
+    // expected-note@-2 {{'__builtin_sycl_unique_stable_name' evaluated here}}
+    __builtin_sycl_mark_kernel_name(KernelName1);
+  }();
+
+  []() {
+    // expected-error@#kernelSingleTask {{kernel instantiation changes the result of an evaluated '__builtin_sycl_unique_stable_name'}}
+    // expected-note@#SingleTaskInst {{in instantiation of function template}}
+    // expected-note@+2 {{in instantiation of function template}}
+    // expected-note@#KI_USN {{'__builtin_sycl_unique_stable_name' evaluated here}}
+    wrapper<KernelInfo, class KernelName2>([]() {});
+  }();
+
+  []() {
+    wrapper<FixedKernelInfo, class KernelName3>([]() {});
+  }();
+}

sycl/include/CL/sycl/detail/kernel_desc.hpp

@@ -105,7 +105,17 @@ using make_index_sequence =
 
 template <typename T> struct KernelInfoImpl {
 private:
-  static constexpr auto n = __builtin_sycl_unique_stable_name(T);
+  // This is necessary to ensure that any kernels we get info for are properly
+  // labeled as such before we call __builtin_sycl_unique_stable_name in a
+  // constant expression, otherwise subsequent calls to a sycl_kernel function
+  // could cause the kernel name to altered, and change the result of the
+  // builtin.
+  // Additionally, we make this a dependency of 'n' so that we can guarantee
+  // that this is evaluated first. The builtin always returns 'true', so the
+  // 'else' branch of 'n's ternary is never evaluated.
+  static constexpr bool b = __builtin_sycl_mark_kernel_name(T);
+  static constexpr auto n = b ? __builtin_sycl_unique_stable_name(T)
+                              : __builtin_sycl_unique_stable_name(T);
   template <unsigned long long... I>
   static KernelInfoData<n[I]...> impl(index_sequence<I...>) {
     return {};