Add constant evaluation support for builtins

Author: elizabethandrews

clang/include/clang/Basic/Builtins.h

@@ -45,7 +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.
+  SYCL_LANG = 0x4000,        // 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/lib/AST/ExprConstant.cpp

@@ -52,6 +52,7 @@
 #include "clang/Basic/Builtins.h"
 #include "clang/Basic/DiagnosticSema.h"
 #include "clang/Basic/TargetBuiltins.h"
+#include "clang/Basic/IdentifierTable.h"
 #include "clang/Basic/TargetInfo.h"
 #include "llvm/ADT/APFixedPoint.h"
 #include "llvm/ADT/Sequence.h"
@@ -9918,6 +9919,26 @@ static bool isOneByteCharacterType(QualType T) {
   return T->isCharType() || T->isChar8Type();
 }
 
+static const SYCLKernelInfo *GetSYCLKernelInfo(ASTContext &Ctx,
+                                               const CallExpr *E) {
+  // Argument to the builtin is a type trait which is used to retrieve the
+  // kernel name type.
+  // FIXME: Improve the comment.
+  const Expr *NameExpr = E->getArg(0);
+  // FIXME: Implement diagnostic instead of assert.
+  assert(NameExpr->isEvaluatable(Ctx) &&
+         "KernelNameType should be evaluatable");
+  RecordDecl *RD = NameExpr->getType()->castAs<RecordType>()->getDecl();
+  IdentifierTable &IdentTable = Ctx.Idents;
+  auto Name = DeclarationName(&(IdentTable.get("type")));
+  NamedDecl *ND = (RD->lookup(Name)).front();
+  TypedefNameDecl *TD = cast<TypedefNameDecl>(ND);
+  CanQualType KernelNameType = Ctx.getCanonicalType(TD->getUnderlyingType());
+
+  // Retrieve KernelInfo using the kernel name.
+  return Ctx.findSYCLKernelInfo(KernelNameType);
+}
+
 bool PointerExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E,
                                                 unsigned BuiltinOp) {
   if (IsOpaqueConstantCall(E))
@@ -10273,6 +10294,23 @@ bool PointerExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E,
         return false;
     }
   }
+  case Builtin::BI__builtin_sycl_kernel_name: {
+    const SYCLKernelInfo *KernelInfo = GetSYCLKernelInfo(Info.Ctx, E);
+    assert(KernelInfo && "Type does not correspond to a SYCL kernel name.");
+    // Retrieve the mangled name corresponding to kernel name type.
+    std::string ResultStr = KernelInfo->GetKernelName();
+    APInt Size(Info.Ctx.getTypeSize(Info.Ctx.getSizeType()),
+               ResultStr.size() + 1);
+    QualType StrTy =
+        Info.Ctx.getConstantArrayType(Info.Ctx.CharTy.withConst(), Size,
+                                      nullptr, ArraySizeModifier::Normal, 0);
+    StringLiteral *SL =
+        StringLiteral::Create(Info.Ctx, ResultStr, StringLiteralKind::Ordinary,
+                              /*Pascal*/ false, StrTy, SourceLocation());
+    evaluateLValue(SL, Result);
+    Result.addArray(Info, E, cast<ConstantArrayType>(StrTy));
+    return true;
+  }
 
   default:
     return false;

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

@@ -10,6 +10,8 @@ class kernel_name_3;
 class kernel_name_4;
 typedef kernel_name_4 kernel_name_TD2;
 
+struct constexpr_kernel_name;
+
 template<typename KN>
 struct kernel_id_t {
   using type = KN;
@@ -36,25 +38,30 @@ void test() {
   kernel_single_task<kernel_name_TD>(Obj);
   kernel_single_task<kernel_name_3>(Obj);
   kernel_single_task<kernel_name_TD2>(Obj);
+  kernel_single_task<constexpr_kernel_name>(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>());
+  constexpr const char* test5 = __builtin_sycl_kernel_name(kernel_id_t<constexpr_kernel_name>());
 }
 
 // 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: @.str = private unnamed_addr constant [52 x i8] c"_Z20__sycl_kernel_callerI21constexpr_kernel_nameEvv\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: %test5 = 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
+// CHECK: store ptr @.str, ptr %test5, align 8