[SYCL] Implement __builtin_sycl_unique_id to support spec-constants (#3890)

This works similar to the unique-stable-name implementation, except it
instead takes a DeclRefExpr to a VarDecl (with Global Storage!), and
produces the mangled name of the variable.  For variables without
external linkage, it prepends it with the unique identifier passed on
the command line from the driver.

Author: Erich Keane

clang/docs/LanguageExtensions.rst

@@ -2452,6 +2452,27 @@ 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_unique_stable_id``
+----------------------------------
+
+Like ``__builtin_sycl_unique_stable_name``, this builtin generates a unique and
+stable name as a string literal to support sharing it across split compliations.
+
+However, this builtin takes the name of a variable with global storage and
+provides the name for that.  In the case of names with internal linkage, it
+prepends an optional value if provided by ``-fsycl-unique-prefix`` on the command
+line, which the driver will do for SYCL invocations.
+
+This builtin produces a string that can be demangled, except when its argument has
+internal linkage.
+
+**Syntax**:
+
+.. code-block:: c++
+
+  // Computes a unique stable name for a given variable.
+  constexpr bool  __builtin_sycl_unique_stable_id( expr );
+
 ``__builtin_sycl_mark_kernel_name``
 -----------------------------------
 

clang/include/clang/AST/ASTContext.h

@@ -3175,8 +3175,9 @@ OPT_LIST(V)
   unsigned GetSYCLKernelNamingIndex(const NamedDecl *RD);
   /// A SourceLocation to store whether we have evaluated a kernel name already,
   /// and where it happened.  If so, we need to diagnose an illegal use of the
-  /// builtin.
-  llvm::MapVector<const SYCLUniqueStableNameExpr *, std::string>
+  /// builtin. This should only contain SYCLUniqueStableNameExprs and
+  /// SYCLUniqueStableIdExprs.
+  llvm::MapVector<const Expr *, std::string>
       SYCLUniqueStableNameEvaluatedValues;
 
 private:

clang/include/clang/AST/ComputeDependence.h

@@ -78,6 +78,7 @@ class MaterializeTemporaryExpr;
 class CXXFoldExpr;
 class TypeTraitExpr;
 class ConceptSpecializationExpr;
+class SYCLUniqueStableIdExpr;
 class SYCLUniqueStableNameExpr;
 class PredefinedExpr;
 class CallExpr;
@@ -171,6 +172,7 @@ ExprDependence computeDependence(ConceptSpecializationExpr *E,
                                  bool ValueDependent);
 
 ExprDependence computeDependence(SYCLUniqueStableNameExpr *E);
+ExprDependence computeDependence(SYCLUniqueStableIdExpr *E);
 ExprDependence computeDependence(PredefinedExpr *E);
 ExprDependence computeDependence(CallExpr *E, llvm::ArrayRef<Expr *> PreArgs);
 ExprDependence computeDependence(OffsetOfExpr *E);

clang/include/clang/AST/Expr.h

@@ -2097,6 +2097,58 @@ class SYCLUniqueStableNameExpr final : public Expr {
   static std::string ComputeName(ASTContext &Context, QualType Ty);
 };
 
+class SYCLUniqueStableIdExpr final : public Expr {
+  friend class ASTStmtReader;
+  SourceLocation OpLoc, LParen, RParen;
+  // A statement instead of an expression because otherwise implementing
+  // 'children' is awkward.
+  Stmt *DRE = nullptr;
+
+  SYCLUniqueStableIdExpr(EmptyShell Empty, QualType ResultTy);
+  SYCLUniqueStableIdExpr(SourceLocation OpLoc, SourceLocation LParen,
+                         SourceLocation RParen, QualType ResultTy, Expr *E);
+
+  void setExpr(Expr *E) { DRE = E; }
+
+  void setLocation(SourceLocation L) { OpLoc = L; }
+  void setLParenLocation(SourceLocation L) { LParen = L; }
+  void setRParenLocation(SourceLocation L) { RParen = L; }
+
+public:
+  Expr *getExpr() { return cast<Expr>(DRE); }
+  const Expr *getExpr() const { return cast<Expr>(DRE); }
+
+  static SYCLUniqueStableIdExpr *Create(const ASTContext &Ctx,
+                                        SourceLocation OpLoc,
+                                        SourceLocation LParen,
+                                        SourceLocation RParen, Expr *E);
+
+  static SYCLUniqueStableIdExpr *CreateEmpty(const ASTContext &Ctx);
+
+  SourceLocation getBeginLoc() const { return getLocation(); }
+  SourceLocation getEndLoc() const { return RParen; }
+  SourceLocation getLocation() const { return OpLoc; }
+  SourceLocation getLParenLocation() const { return LParen; }
+  SourceLocation getRParenLocation() const { return RParen; }
+
+  static bool classof(const Stmt *T) {
+    return T->getStmtClass() == SYCLUniqueStableIdExprClass;
+  }
+
+  // Iterators
+  child_range children() { return child_range(&DRE, &DRE + 1); }
+  const_child_range children() const {
+    return const_child_range(&DRE, &DRE + 1);
+  }
+
+  // Convenience function to generate the name of the currently stored type.
+  std::string ComputeName(ASTContext &Context) const;
+
+  // Get the generated name of the type.  Note that this only works after all
+  // kernels have been instantiated.
+  static std::string ComputeName(ASTContext &Context, const VarDecl *VD);
+};
+
 /// ParenExpr - This represents a parethesized expression, e.g. "(1)".  This
 /// AST node is only formed if full location information is requested.
 class ParenExpr : public Expr {

clang/include/clang/AST/JSONNodeDumper.h

@@ -264,6 +264,7 @@ class JSONNodeDumper
 
   void VisitDeclRefExpr(const DeclRefExpr *DRE);
   void VisitSYCLUniqueStableNameExpr(const SYCLUniqueStableNameExpr *E);
+  void VisitSYCLUniqueStableIdExpr(const SYCLUniqueStableIdExpr *E);
   void VisitPredefinedExpr(const PredefinedExpr *PE);
   void VisitUnaryOperator(const UnaryOperator *UO);
   void VisitBinaryOperator(const BinaryOperator *BO);

clang/include/clang/AST/RecursiveASTVisitor.h

@@ -2679,6 +2679,7 @@ DEF_TRAVERSE_STMT(ParenListExpr, {})
 DEF_TRAVERSE_STMT(SYCLUniqueStableNameExpr, {
   TRY_TO(TraverseTypeLoc(S->getTypeSourceInfo()->getTypeLoc()));
 })
+DEF_TRAVERSE_STMT(SYCLUniqueStableIdExpr, {})
 DEF_TRAVERSE_STMT(PredefinedExpr, {})
 DEF_TRAVERSE_STMT(ShuffleVectorExpr, {})
 DEF_TRAVERSE_STMT(ConvertVectorExpr, {})

clang/include/clang/AST/TextNodeDumper.h

@@ -250,6 +250,7 @@ class TextNodeDumper
   void VisitImplicitCastExpr(const ImplicitCastExpr *Node);
   void VisitDeclRefExpr(const DeclRefExpr *Node);
   void VisitSYCLUniqueStableNameExpr(const SYCLUniqueStableNameExpr *Node);
+  void VisitSYCLUniqueStableIdExpr(const SYCLUniqueStableIdExpr *Node);
   void VisitPredefinedExpr(const PredefinedExpr *Node);
   void VisitCharacterLiteral(const CharacterLiteral *Node);
   void VisitIntegerLiteral(const IntegerLiteral *Node);

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -6411,9 +6411,13 @@ def warn_gnu_null_ptr_arith : Warning<
   InGroup<NullPointerArithmetic>, DefaultIgnore;
 def err_kernel_invalidates_sycl_unique_stable_name
     : Error<"kernel %select{naming|instantiation}0 changes the result of an "
-            "evaluated '__builtin_sycl_unique_stable_name'">;
+            "evaluated '__builtin_sycl_unique_stable_%select{name|id}1'">;
 def note_sycl_unique_stable_name_evaluated_here
-    : Note<"'__builtin_sycl_unique_stable_name' evaluated here">;
+    : Note<"'__builtin_sycl_unique_stable_%select{name|id}0' evaluated here">;
+def err_unique_stable_id_expected_var : Error<"expected variable name">;
+def err_unique_stable_id_global_storage
+    : Error<"argument passed to '__builtin_sycl_unique_stable_id' must have "
+            "global storage">;
 
 def warn_floatingpoint_eq : Warning<
   "comparing floating point with == or != is unsafe">,

clang/include/clang/Basic/StmtNodes.td

@@ -58,6 +58,7 @@ def CoreturnStmt : StmtNode<Stmt>;
 def Expr : StmtNode<ValueStmt, 1>;
 def PredefinedExpr : StmtNode<Expr>;
 def SYCLUniqueStableNameExpr : StmtNode<Expr>;
+def SYCLUniqueStableIdExpr : StmtNode<Expr>;
 def DeclRefExpr : StmtNode<Expr>;
 def IntegerLiteral : StmtNode<Expr>;
 def FixedPointLiteral : StmtNode<Expr>;

clang/include/clang/Basic/TokenKinds.def

@@ -709,6 +709,7 @@ ALIAS("__char32_t"   , char32_t          , KEYCXX)
 KEYWORD(__builtin_bit_cast               , KEYALL)
 KEYWORD(__builtin_available              , KEYALL)
 KEYWORD(__builtin_sycl_unique_stable_name, KEYSYCL)
+KEYWORD(__builtin_sycl_unique_stable_id  , KEYSYCL)
 
 TYPE_TRAIT_1(__builtin_sycl_mark_kernel_name, SYCLMarkKernelName, KEYSYCL)
 

clang/include/clang/Parse/Parser.h

@@ -1802,6 +1802,7 @@ class Parser : public CodeCompletionHandler {
   ExprResult ParseUnaryExprOrTypeTraitExpression();
   ExprResult ParseBuiltinPrimaryExpression();
   ExprResult ParseSYCLUniqueStableNameExpression();
+  ExprResult ParseSYCLUniqueStableIdExpression();
 
   ExprResult ParseExprAfterUnaryExprOrTypeTrait(const Token &OpTok,
                                                      bool &isCastExpr,

clang/include/clang/Sema/Sema.h

@@ -5449,6 +5449,13 @@ class Sema final {
                                            SourceLocation RParen,
                                            ParsedType ParsedTy);
 
+  ExprResult BuildSYCLUniqueStableIdExpr(SourceLocation OpLoc,
+                                         SourceLocation LParen,
+                                         SourceLocation RParen, Expr *E);
+  ExprResult ActOnSYCLUniqueStableIdExpr(SourceLocation OpLoc,
+                                         SourceLocation LParen,
+                                         SourceLocation RParen, Expr *E);
+
   bool CheckLoopHintExpr(Expr *E, SourceLocation Loc);
 
   ExprResult ActOnNumericConstant(const Token &Tok, Scope *UDLScope = nullptr);

clang/include/clang/Serialization/ASTBitCodes.h

@@ -1975,6 +1975,8 @@ enum StmtCode {
   EXPR_SYCL_BUILTIN_NUM_BASES,
   EXPR_SYCL_BUILTIN_BASE_TYPE,
   EXPR_SYCL_UNIQUE_STABLE_NAME,
+  // SYCLUniqueStableIdExpr
+  EXPR_SYCL_UNIQUE_STABLE_ID,
 };
 
 /// The kinds of designators that can occur in a

clang/lib/AST/ComputeDependence.cpp

@@ -560,6 +560,10 @@ ExprDependence clang::computeDependence(SYCLUniqueStableNameExpr *E) {
   return toExprDependence(E->getTypeSourceInfo()->getType()->getDependence());
 }
 
+ExprDependence clang::computeDependence(SYCLUniqueStableIdExpr *E) {
+  return E->getExpr()->getDependence();
+}
+
 ExprDependence clang::computeDependence(PredefinedExpr *E) {
   return toExprDependence(E->getType()->getDependence()) &
          ~ExprDependence::UnexpandedPack;

clang/lib/AST/Expr.cpp

@@ -539,26 +539,27 @@ std::string SYCLUniqueStableNameExpr::ComputeName(ASTContext &Context) const {
                                                getTypeSourceInfo()->getType());
 }
 
+static llvm::Optional<unsigned> SYCLMangleCallback(ASTContext &Ctx,
+                                                   const NamedDecl *ND) {
+  // This replaces the 'lambda number' in the mangling with a unique number
+  // based on its order in the declaration.  To provide some level of visual
+  // notability (actual uniqueness from normal lambdas isn't necessary, as
+  // these are used differently), we add 10,000 to the number.
+  // For example:
+  // _ZTSZ3foovEUlvE10005_
+  // Demangles to: typeinfo name for foo()::'lambda10005'()
+  // Note that the mangler subtracts 2, since with normal lambdas the lambda
+  // mangling number '0' is an anonymous struct mangle, and '1' is omitted.
+  // So 10,002 results in the first number being 10,000.
+  if (Ctx.IsSYCLKernelNamingDecl(ND))
+    return 10'002 + Ctx.GetSYCLKernelNamingIndex(ND);
+  return llvm::None;
+}
+
 std::string SYCLUniqueStableNameExpr::ComputeName(ASTContext &Context,
                                                   QualType Ty) {
-  auto MangleCallback = [](ASTContext &Ctx,
-                           const NamedDecl *ND) -> llvm::Optional<unsigned> {
-    // This replaces the 'lambda number' in the mangling with a unique number
-    // based on its order in the declaration.  To provide some level of visual
-    // notability (actual uniqueness from normal lambdas isn't necessary, as
-    // these are used differently), we add 10,000 to the number.
-    // For example:
-    // _ZTSZ3foovEUlvE10005_
-    // Demangles to: typeinfo name for foo()::'lambda10005'()
-    // Note that the mangler subtracts 2, since with normal lambdas the lambda
-    // mangling number '0' is an anonymous struct mangle, and '1' is omitted.
-    // So 10,002 results in the first number being 10,000.
-    if (Ctx.IsSYCLKernelNamingDecl(ND))
-      return 10'002 + Ctx.GetSYCLKernelNamingIndex(ND);
-    return llvm::None;
-  };
   std::unique_ptr<MangleContext> Ctx{ItaniumMangleContext::create(
-      Context, Context.getDiagnostics(), MangleCallback)};
+      Context, Context.getDiagnostics(), SYCLMangleCallback)};
 
   std::string Buffer;
   Buffer.reserve(128);
@@ -568,6 +569,60 @@ std::string SYCLUniqueStableNameExpr::ComputeName(ASTContext &Context,
   return Out.str();
 }
 
+SYCLUniqueStableIdExpr::SYCLUniqueStableIdExpr(EmptyShell Empty,
+                                               QualType ResultTy)
+    : Expr(SYCLUniqueStableIdExprClass, ResultTy, VK_RValue, OK_Ordinary) {}
+
+SYCLUniqueStableIdExpr::SYCLUniqueStableIdExpr(SourceLocation OpLoc,
+                                               SourceLocation LParen,
+                                               SourceLocation RParen,
+                                               QualType ResultTy, Expr *E)
+    : Expr(SYCLUniqueStableIdExprClass, ResultTy, VK_RValue, OK_Ordinary),
+      OpLoc(OpLoc), LParen(LParen), RParen(RParen), DRE(E) {
+  setDependence(computeDependence(this));
+}
+
+SYCLUniqueStableIdExpr *SYCLUniqueStableIdExpr::Create(const ASTContext &Ctx,
+                                                       SourceLocation OpLoc,
+                                                       SourceLocation LParen,
+                                                       SourceLocation RParen,
+                                                       Expr *E) {
+  QualType ResultTy = Ctx.getPointerType(Ctx.CharTy.withConst());
+  return new (Ctx) SYCLUniqueStableIdExpr(OpLoc, LParen, RParen, ResultTy, E);
+}
+
+SYCLUniqueStableIdExpr *
+SYCLUniqueStableIdExpr::CreateEmpty(const ASTContext &Ctx) {
+  QualType ResultTy = Ctx.getPointerType(Ctx.CharTy.withConst());
+  return new (Ctx) SYCLUniqueStableIdExpr(EmptyShell(), ResultTy);
+}
+
+std::string SYCLUniqueStableIdExpr::ComputeName(ASTContext &Context) const {
+  assert(!isInstantiationDependent() &&
+         "Can't compute name of uninstantiated value");
+
+  auto *DR = cast<DeclRefExpr>(getExpr()->IgnoreUnlessSpelledInSource());
+  auto *VD = cast<VarDecl>(DR->getDecl());
+
+  return ComputeName(Context, VD);
+}
+
+std::string SYCLUniqueStableIdExpr::ComputeName(ASTContext &Context,
+                                                const VarDecl *VD) {
+  std::unique_ptr<MangleContext> Ctx{ItaniumMangleContext::create(
+      Context, Context.getDiagnostics(), SYCLMangleCallback)};
+
+  std::string Buffer;
+  Buffer.reserve(128);
+  llvm::raw_string_ostream Out(Buffer);
+  Ctx->mangleName(GlobalDecl{VD}, Out);
+
+  if (VD->isExternallyVisible())
+    return Out.str();
+
+  return Context.getLangOpts().SYCLUniquePrefix + "___" + Out.str();
+}
+
 PredefinedExpr::PredefinedExpr(SourceLocation L, QualType FNTy, IdentKind IK,
                                StringLiteral *SL)
     : Expr(PredefinedExprClass, FNTy, VK_LValue, OK_Ordinary) {
@@ -3450,6 +3505,7 @@ bool Expr::HasSideEffects(const ASTContext &Ctx,
   case SYCLBuiltinNumBasesExprClass:
   case SYCLBuiltinBaseTypeExprClass:
   case SYCLUniqueStableNameExprClass:
+  case SYCLUniqueStableIdExprClass:
     // These never have a side-effect.
     return false;
 

clang/lib/AST/ExprClassification.cpp

@@ -438,6 +438,7 @@ static Cl::Kinds ClassifyInternal(ASTContext &Ctx, const Expr *E) {
   case Expr::CoyieldExprClass:
     return ClassifyInternal(Ctx, cast<CoroutineSuspendExpr>(E)->getResumeExpr());
   case Expr::SYCLUniqueStableNameExprClass:
+  case Expr::SYCLUniqueStableIdExprClass:
     return Cl::CL_PRValue;
     break;
   }

clang/lib/AST/ExprConstant.cpp

@@ -8689,6 +8689,26 @@ class PointerExprEvaluator
     return true;
   }
 
+  bool VisitSYCLUniqueStableIdExpr(const SYCLUniqueStableIdExpr *E) {
+    std::string ResultStr = E->ComputeName(Info.Ctx);
+
+    Info.Ctx.SYCLUniqueStableNameEvaluatedValues[E] = ResultStr;
+
+    QualType CharTy = Info.Ctx.CharTy.withConst();
+    APInt Size(Info.Ctx.getTypeSize(Info.Ctx.getSizeType()),
+               ResultStr.size() + 1);
+    QualType ArrayTy = Info.Ctx.getConstantArrayType(CharTy, Size, nullptr,
+                                                     ArrayType::Normal, 0);
+
+    StringLiteral *SL =
+        StringLiteral::Create(Info.Ctx, ResultStr, StringLiteral::Ascii,
+                              /*Pascal*/ false, ArrayTy, E->getLocation());
+
+    evaluateLValue(SL, Result);
+    Result.addArray(Info, E, cast<ConstantArrayType>(ArrayTy));
+    return true;
+  }
+
   // FIXME: Missing: @protocol, @selector
 };
 } // end anonymous namespace
@@ -15190,6 +15210,7 @@ static ICEDiag CheckICE(const Expr* E, const ASTContext &Ctx) {
   case Expr::SYCLBuiltinFieldTypeExprClass:
   case Expr::SYCLBuiltinBaseTypeExprClass:
   case Expr::SYCLUniqueStableNameExprClass:
+  case Expr::SYCLUniqueStableIdExprClass:
     return ICEDiag(IK_NotICE, E->getBeginLoc());
 
   case Expr::InitListExprClass: {

clang/lib/AST/ItaniumMangle.cpp

@@ -5056,6 +5056,15 @@ void CXXNameMangler::mangleExpression(const Expr *E, unsigned Arity,
     Out << "E";
     break;
   }
+  case Expr::SYCLUniqueStableIdExprClass: {
+    const auto *USID = cast<SYCLUniqueStableIdExpr>(E);
+    NotPrimaryExpr();
+
+    Out << "cl31__builtin_sycl_unique_stable_id";
+    mangleExpression(USID->getExpr());
+    Out << "E";
+    break;
+  }
   }
 
   if (AsTemplateArg && !IsPrimaryExpr)

clang/lib/AST/JSONNodeDumper.cpp

@@ -1170,6 +1170,9 @@ void JSONNodeDumper::VisitSYCLUniqueStableNameExpr(
                 createQualType(E->getTypeSourceInfo()->getType()));
 }
 
+void JSONNodeDumper::VisitSYCLUniqueStableIdExpr(
+    const SYCLUniqueStableIdExpr *E) {}
+
 void JSONNodeDumper::VisitPredefinedExpr(const PredefinedExpr *PE) {
   JOS.attribute("name", PredefinedExpr::getIdentKindName(PE->getIdentKind()));
 }