Merge remote-tracking branch 'origin/sycl' into memcpy_for_libdevice

Author: jinge90

.github/workflows/gh_pages.yml

@@ -24,7 +24,9 @@ jobs:
         python $GITHUB_WORKSPACE/repo/buildbot/configure.py -w $GITHUB_WORKSPACE \
         -s $GITHUB_WORKSPACE/repo -o $GITHUB_WORKSPACE/build -t Release --docs
         cmake --build . --target doxygen-sycl
+        cmake --build . --target doxygen-clang
         cmake --build . --target docs-sycl-html
+        cmake --build . --target docs-clang-html
     - name: Deploy
       env:
         SSH_KEY: ${{secrets.ACTIONS_DEPLOY_KEY}}
@@ -41,6 +43,10 @@ jobs:
         yes | \cp -rf $GITHUB_WORKSPACE/build/tools/sycl/doc/html/* .
         mkdir doxygen
         yes | \cp -rf $GITHUB_WORKSPACE/build/tools/sycl/doc/doxygen/html/* doxygen/
+        mkdir clang
+        yes | \cp -rf $GITHUB_WORKSPACE/build/tools/clang/docs/html/* clang/
+        mkdir clang_doxygen
+        yes | \cp -rf $GITHUB_WORKSPACE/build/tools/clang/docs/doxygen/html/* clang_doxygen/
         git config --global user.name "iclsrc"
         git config --global user.email "[email protected]"
         git add .

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/AttrDocs.td

@@ -4543,6 +4543,7 @@ used to specify full unrolling or partial unrolling by a specified amount.
 
 def IntelReqdSubGroupSizeDocs : Documentation {
   let Category = DocCatStmt;
+  let Heading = "intel_reqd_sub_group_size";
   let Content = [{
 This attribute can be used in both OpenCL and SYCL.
 
@@ -4563,7 +4564,7 @@ to a sub-group size supported by the device, or device compilation will fail.
 
 The ``[[intel::sub_group_size(n)]]`` attribute has the same effect as the other
 attribute spellings, except that it follows the SYCL 2020 Attribute Rules. See
- the ``[[intel::named_sub_group_size(NAME)]]`` documentation for clarification.
+the ``[[intel::named_sub_group_size(NAME)]]`` documentation for clarification.
 
 This attribute is mutually exclusive with ``[[intel::named_sub_group_size(NAME)]]``
 and ``[[intel::sycl_explicit_simd]]``.

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">,