[SYCL] Add support for __builtin_sycl_kernel_name

The builtin takes the kernel name type as it's argument
and returns the mangled name for the kernel caller
function.

Author: elizabethandrews

clang/include/clang/Basic/Builtins.h

@@ -45,6 +45,7 @@ enum LanguageID : uint16_t {
   ALL_OCL_LANGUAGES = 0x800, // builtin for OCL languages.
   HLSL_LANG = 0x1000,        // builtin requires HLSL.
   C23_LANG = 0x2000,         // builtin requires C23 or later.
+  SYCL_LANG = 0x2000,        // builtin requires SYCL.
   ALL_LANGUAGES = C_LANG | CXX_LANG | OBJC_LANG, // builtin for all languages.
   ALL_GNU_LANGUAGES = ALL_LANGUAGES | GNU_LANG,  // builtin requires GNU mode.
   ALL_MS_LANGUAGES = ALL_LANGUAGES | MS_LANG     // builtin requires MS mode.

clang/include/clang/Basic/Builtins.td

@@ -4794,6 +4794,13 @@ def GetDeviceSideMangledName : LangBuiltin<"CUDA_LANG"> {
   let Prototype = "char const*(...)";
 }
 
+// SYCL
+def SYCLKernelName : LangBuiltin<"SYCL_LANG"> {
+  let Spellings = ["__builtin_sycl_kernel_name"];
+  let Attributes = [NoThrow, CustomTypeChecking];
+  let Prototype = "char const*(...)";
+}
+
 // HLSL
 def HLSLAddUint64: LangBuiltin<"HLSL_LANG"> {
   let Spellings = ["__builtin_hlsl_adduint64"];

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -12789,6 +12789,9 @@ def err_sycl_entry_point_deduced_return_type : Error<
 def warn_cuda_maxclusterrank_sm_90 : Warning<
   "maxclusterrank requires sm_90 or higher, CUDA arch provided: %0, ignoring "
   "%1 attribute">, InGroup<IgnoredAttributes>;
+def err_builtin_invalid_argument_count : Error<"builtin requires exactly 1 argument">;
+def err_builtin_invalid_argument : Error<"invalid argument; argument must be a class or struct type"
+                                         " with a member type alias named 'type'">;
 
 // VTable pointer authentication errors
 def err_non_polymorphic_vtable_pointer_auth : Error<

clang/lib/Basic/Builtins.cpp

@@ -185,6 +185,9 @@ static bool builtinIsSupported(const llvm::StringTable &Strings,
   /* CUDA Unsupported */
   if (!LangOpts.CUDA && BuiltinInfo.Langs == CUDA_LANG)
     return false;
+  /*  SYCL Unsupported */
+  if (!LangOpts.isSYCL() && BuiltinInfo.Langs == SYCL_LANG)
+    return false;
   /* CPlusPlus Unsupported */
   if (!LangOpts.CPlusPlus && BuiltinInfo.Langs == CXX_LANG)
     return false;

clang/lib/CodeGen/CGBuiltin.cpp

@@ -29,6 +29,7 @@
 #include "clang/Basic/TargetBuiltins.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Basic/TargetOptions.h"
+#include "clang/Basic/IdentifierTable.h"
 #include "clang/Frontend/FrontendDiagnostic.h"
 #include "llvm/IR/InlineAsm.h"
 #include "llvm/IR/Intrinsics.h"
@@ -6219,6 +6220,25 @@ RValue CodeGenFunction::EmitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
     auto Str = CGM.GetAddrOfConstantCString(Name, "");
     return RValue::get(Str.getPointer());
   }
+  case Builtin::BI__builtin_sycl_kernel_name: {
+    ASTContext &Ctx = getContext();
+    // Argument to the builtin is a kernel_id_t type trait which is used
+    // to retrieve the kernel name type.
+    RecordDecl *RD = E->getArg(0)->getType()->castAs<RecordType>()->getDecl();
+    IdentifierTable &IdentTable = Ctx.Idents;
+    auto Name = DeclarationName(&(IdentTable.get("type")));
+    NamedDecl *ND = (RD->lookup(Name)).front();
+    TypeAliasDecl *TD = cast<TypeAliasDecl>(ND);
+    QualType KernelNameType = TD->getUnderlyingType().getCanonicalType();
+
+    // Retrieve the mangled name corresponding to kernel name type.
+    const SYCLKernelInfo *KernelInfo = Ctx.findSYCLKernelInfo(KernelNameType);
+    assert(KernelInfo && "Type does not correspond to a SYCL kernel name.");
+    
+    // Emit the mangled name.
+    auto Str = CGM.GetAddrOfConstantCString(KernelInfo->GetKernelName(), "");
+    return RValue::get(Str.getPointer());
+  }
   }
 
   // If this is an alias for a lib function (e.g. __builtin_sin), emit

clang/lib/Sema/SemaChecking.cpp

@@ -2219,6 +2219,25 @@ static bool BuiltinCountZeroBitsGeneric(Sema &S, CallExpr *TheCall) {
   return false;
 }
 
+// The argument must be a class or struct with a member
+// named type.
+static bool CheckBuiltinSyclKernelName(Sema &S, CallExpr *TheCall) {
+  QualType ArgTy = TheCall->getArg(0)->getType();
+  const auto *RT = ArgTy->getAs<RecordType>();
+
+  if(!RT)
+    return true;
+
+  RecordDecl *RD = RT->getDecl();
+  IdentifierTable &IdentTable = S.Context.Idents;
+  auto Name = DeclarationName(&(IdentTable.get("type")));
+  DeclContext::lookup_result Lookup = RD->lookup(Name);
+  if (Lookup.empty() || !Lookup.isSingleResult() || !isa<TypeAliasDecl>(Lookup.front()))
+    return true;
+
+  return false;
+}
+
 ExprResult
 Sema::CheckBuiltinFunctionCall(FunctionDecl *FDecl, unsigned BuiltinID,
                                CallExpr *TheCall) {
@@ -3030,6 +3049,20 @@ Sema::CheckBuiltinFunctionCall(FunctionDecl *FDecl, unsigned BuiltinID,
     }
     break;
   }
+  case Builtin::BI__builtin_sycl_kernel_name: {
+    // Builtin takes 1 argument
+    if (TheCall->getNumArgs() != 1) {
+      Diag(TheCall->getBeginLoc(), diag::err_builtin_invalid_argument_count);
+      return ExprError();
+    }
+
+    if (CheckBuiltinSyclKernelName(*this, TheCall)) {
+      Diag(TheCall->getArg(0)->getBeginLoc(), diag::err_builtin_invalid_argument);
+      return ExprError();
+    }
+
+    break;
+  }
   case Builtin::BI__builtin_popcountg:
     if (BuiltinPopcountg(*this, TheCall))
       return ExprError();

clang/test/CodeGenSYCL/builtin-sycl-kernel-name.cpp

@@ -0,0 +1,60 @@
+// RUN: %clang_cc1 -fsycl-is-host -emit-llvm -triple x86_64 %s -o - | FileCheck %s
+
+// Test IR generated by __builtin_sycl_kernel_name(). This builtin accepts a SYCL
+// kernel name type and returns it's mangled name.
+
+class kernel_name_1;
+class kernel_name_2;
+typedef kernel_name_2 kernel_name_TD;
+class kernel_name_3;
+class kernel_name_4;
+typedef kernel_name_4 kernel_name_TD2;
+
+template<typename KN>
+struct kernel_id_t {
+  using type = KN;
+};
+
+struct kernel_id_nt {
+  using type = kernel_name_3;
+};
+
+template <typename name, typename Func>
+__attribute__((sycl_kernel_entry_point(name))) void kernel_single_task(const Func kernelFunc) {
+  kernelFunc();
+}
+
+struct SYCLKernel {
+  int m;
+  public:
+  void operator()() const {}
+};
+
+void test() {
+  SYCLKernel Obj;
+  kernel_single_task<kernel_name_1>(Obj);
+  kernel_single_task<kernel_name_TD>(Obj);
+  kernel_single_task<kernel_name_3>(Obj);
+  kernel_single_task<kernel_name_TD2>(Obj);
+  const char* test1 = __builtin_sycl_kernel_name(kernel_id_t<kernel_name_1>());
+  const char* test2 = __builtin_sycl_kernel_name(kernel_id_t<kernel_name_TD>());
+  const char* test3 = __builtin_sycl_kernel_name(kernel_id_nt());
+  const char* test4 = __builtin_sycl_kernel_name(kernel_id_t<kernel_name_4>());
+}
+
+// Kernel names retrieved from KernelInfo map
+// CHECK: @0 = private unnamed_addr constant [44 x i8] c"_Z20__sycl_kernel_callerI13kernel_name_1Evv\00", align 1
+// CHECK: @1 = private unnamed_addr constant [44 x i8] c"_Z20__sycl_kernel_callerI13kernel_name_2Evv\00", align 1
+// CHECK: @2 = private unnamed_addr constant [44 x i8] c"_Z20__sycl_kernel_callerI13kernel_name_3Evv\00", align 1
+// CHECK: @3 = private unnamed_addr constant [44 x i8] c"_Z20__sycl_kernel_callerI13kernel_name_4Evv\00", align 1
+
+// CHECK: define dso_local void @_Z4testv()
+// CHECK: %test1 = alloca ptr, align 8
+// CHECK: %test2 = alloca ptr, align 8
+// CHECK: %test3 = alloca ptr, align 8
+// CHECK: %test4 = alloca ptr, align 8
+// CHECK: store ptr @0, ptr %test1, align 8
+// CHECK: store ptr @1, ptr %test2, align 8
+// CHECK: store ptr @2, ptr %test3, align 8
+// CHECK: store ptr @3, ptr %test4, align 8
+

clang/test/SemaSYCL/builtin-sycl-kernel-name.cpp

@@ -0,0 +1,44 @@
+// RUN: %clang_cc1 -fsycl-is-host -fsyntax-only -verify %s
+
+class kernel_name_1;
+class kernel_name_2;
+class kernel_name_3;
+typedef kernel_name_3 kernel_name_TD;
+
+template<typename KN>
+struct kernel_id_1 {
+  using type = KN;
+};
+
+struct kernel_id_2 {
+  using type = kernel_name_2;
+};
+
+struct kernel_id_3 {
+  using invalid_name = kernel_name_2;
+};
+
+template <typename name, typename Func>
+__attribute__((sycl_kernel_entry_point(name))) void kernel_single_task(const Func kernelFunc) {
+  kernelFunc();
+}
+
+struct SYCLKernel {
+  int m;
+  public:
+  void operator()() const {}
+};
+
+void test() {
+  SYCLKernel Obj;
+  kernel_single_task<kernel_name_1>(Obj);
+  kernel_single_task<kernel_name_2>(Obj);
+  kernel_single_task<kernel_name_TD>(Obj);
+  const char* test1 = __builtin_sycl_kernel_name(kernel_id_1<kernel_name_1>()); // Valid
+  const char* test2 = __builtin_sycl_kernel_name(kernel_id_1<kernel_name_TD>()); // Valid
+  const char* test3 = __builtin_sycl_kernel_name(kernel_id_2()); // Valid
+  const char* test4 = __builtin_sycl_kernel_name(kernel_id_3()); // expected-error {{invalid argument; argument must be a class or struct type with a member type alias named 'type'}}
+  const char* test5 = __builtin_sycl_kernel_name("str"); // expected-error {{invalid argument; argument must be a class or struct type with a member type alias named 'type'}}
+  const char* test6 = __builtin_sycl_kernel_name(kernel_id_2(), kernel_id_2()); // expected-error {{builtin requires exactly 1 argument}}
+}
+