[SYCL] Add __builtin_num_fields and __builtin_field_type (#3658)

This is an experimental branch to see whether we can implement the
device copyability checking functionality within the SYCL library by
using some builtins to provide super rudimentary introspection of
structures and lambdas. These builtins will tell you how many fields
are in the structure or how many captures are in the lambda, and tell
you what types those fields are.

__builtin_num_fields() accepts a type id and returns the number of
fields in the given type as an integer constant expression.
__builtin_field_type() accepts a type id and an integer constant
expression and returns a "value" of the field at the given offset from
the given type. The call should always be wrapped in a decltype (or
similar) expression to get the actual type of the field. The value
returned is meaningless and it is UB to inspect it. Note: if we wish to
upstream any of this functionality, this builtin should be replaced by
a new type in the type system, akin to how decltype and typeof work.

More work is still needed for the SYCL library to fully support the
checking in that there is a need to get the number of base classes and
the base class type information.

Author: AaronBallman

clang/include/clang/AST/ComputeDependence.h

@@ -102,6 +102,10 @@ class ObjCSubscriptRefExpr;
 class ObjCIsaExpr;
 class ObjCIndirectCopyRestoreExpr;
 class ObjCMessageExpr;
+class SYCLBuiltinNumFieldsExpr;
+class SYCLBuiltinNumBasesExpr;
+class SYCLBuiltinFieldTypeExpr;
+class SYCLBuiltinBaseTypeExpr;
 
 // The following functions are called from constructors of `Expr`, so they
 // should not access anything beyond basic
@@ -194,5 +198,10 @@ ExprDependence computeDependence(ObjCIsaExpr *E);
 ExprDependence computeDependence(ObjCIndirectCopyRestoreExpr *E);
 ExprDependence computeDependence(ObjCMessageExpr *E);
 
+ExprDependence computeDependence(SYCLBuiltinNumFieldsExpr *E);
+ExprDependence computeDependence(SYCLBuiltinNumBasesExpr *E);
+ExprDependence computeDependence(SYCLBuiltinFieldTypeExpr *E);
+ExprDependence computeDependence(SYCLBuiltinBaseTypeExpr *E);
+
 } // namespace clang
 #endif

clang/include/clang/AST/ExprCXX.h

@@ -4902,6 +4902,186 @@ class BuiltinBitCastExpr final
   }
 };
 
+/// Represents a __builtin_num_fields expression.
+class SYCLBuiltinNumFieldsExpr : public Expr {
+  friend class ASTStmtReader;
+
+  SourceLocation Loc;
+  QualType SourceTy;
+
+public:
+  SYCLBuiltinNumFieldsExpr(SourceLocation Loc, QualType SourceTy,
+                           QualType RetTy)
+      : Expr(SYCLBuiltinNumFieldsExprClass, RetTy, VK_RValue, OK_Ordinary),
+        Loc(Loc), SourceTy(SourceTy) {
+    setDependence(computeDependence(this));
+  }
+
+  explicit SYCLBuiltinNumFieldsExpr(EmptyShell Empty)
+      : Expr(SYCLBuiltinNumFieldsExprClass, Empty) {}
+
+  QualType getSourceType() const { return SourceTy; }
+  unsigned getNumFields() const {
+    assert(!SourceTy->isDependentType());
+    assert(SourceTy->isRecordType());
+    const auto *RD = SourceTy->getAsRecordDecl();
+    assert(RD);
+    return static_cast<unsigned>(
+        std::distance(RD->field_begin(), RD->field_end()));
+  }
+
+  SourceLocation getBeginLoc() const { return Loc; }
+  SourceLocation getEndLoc() const { return Loc; }
+
+  SourceLocation getLocation() const { return Loc; }
+  void setLocation(SourceLocation L) { Loc = L; }
+
+  child_range children() {
+    return child_range(child_iterator(), child_iterator());
+  }
+
+  const_child_range children() const {
+    return const_child_range(const_child_iterator(), const_child_iterator());
+  }
+
+  static bool classof(const Stmt *T) {
+    return T->getStmtClass() == SYCLBuiltinNumFieldsExprClass;
+  }
+};
+
+/// Represents a __builtin_field_type expression. This does not actually return
+/// the type itself (it would need to be a new type in the type system rather
+/// than an expression to do that), but instead is a valueless expression of
+/// the field's type. The expected usage is to use decltype to extract the
+/// actual type information. This expression can only be used in an unevaluated
+/// context.
+class SYCLBuiltinFieldTypeExpr : public Expr {
+  friend class ASTStmtReader;
+
+  SourceLocation Loc;
+  QualType SourceTy;
+  Stmt *Index;
+
+public:
+  SYCLBuiltinFieldTypeExpr(SourceLocation Loc, QualType SourceTy, Expr *Index,
+                           QualType FieldTy, ExprValueKind ValueKind)
+      : Expr(SYCLBuiltinFieldTypeExprClass, FieldTy, ValueKind, OK_Ordinary),
+        Loc(Loc), SourceTy(SourceTy), Index(Index) {
+    setDependence(computeDependence(this));
+  }
+
+  explicit SYCLBuiltinFieldTypeExpr(EmptyShell Empty)
+      : Expr(SYCLBuiltinFieldTypeExprClass, Empty) {}
+
+  QualType getSourceType() const { return SourceTy; }
+
+  const Expr *getIndex() const { return static_cast<const Expr *>(Index); }
+  Expr *getIndex() { return static_cast<Expr *>(Index); }
+
+  SourceLocation getBeginLoc() const { return Loc; }
+  SourceLocation getEndLoc() const { return Loc; }
+
+  SourceLocation getLocation() const { return Loc; }
+  void setLocation(SourceLocation L) { Loc = L; }
+
+  static bool classof(const Stmt *T) {
+    return T->getStmtClass() == SYCLBuiltinFieldTypeExprClass;
+  }
+
+  child_range children() { return child_range(&Index, &Index + 1); }
+
+  const_child_range children() const {
+    return const_child_range(&Index, &Index + 1);
+  }
+};
+
+/// Represents a __builtin_num_bases expression.
+class SYCLBuiltinNumBasesExpr : public Expr {
+  friend class ASTStmtReader;
+
+  SourceLocation Loc;
+  QualType SourceTy;
+
+public:
+  SYCLBuiltinNumBasesExpr(SourceLocation Loc, QualType SourceTy, QualType RetTy)
+      : Expr(SYCLBuiltinNumBasesExprClass, RetTy, VK_RValue, OK_Ordinary),
+        Loc(Loc), SourceTy(SourceTy) {
+    setDependence(computeDependence(this));
+  }
+
+  explicit SYCLBuiltinNumBasesExpr(EmptyShell Empty)
+      : Expr(SYCLBuiltinNumBasesExprClass, Empty) {}
+
+  QualType getSourceType() const { return SourceTy; }
+  unsigned getNumBases() const {
+    assert(!SourceTy->isDependentType());
+    assert(SourceTy->isRecordType());
+    const auto *RD = SourceTy->getAsCXXRecordDecl();
+    assert(RD);
+    return RD->getNumBases();
+  }
+
+  SourceLocation getBeginLoc() const { return Loc; }
+  SourceLocation getEndLoc() const { return Loc; }
+
+  SourceLocation getLocation() const { return Loc; }
+  void setLocation(SourceLocation L) { Loc = L; }
+
+  child_range children() {
+    return child_range(child_iterator(), child_iterator());
+  }
+
+  const_child_range children() const {
+    return const_child_range(const_child_iterator(), const_child_iterator());
+  }
+
+  static bool classof(const Stmt *T) {
+    return T->getStmtClass() == SYCLBuiltinNumBasesExprClass;
+  }
+};
+
+/// Represents a __builtin_base_type expression. This has the same behavior and
+/// constraints as __builtin_field_type.
+class SYCLBuiltinBaseTypeExpr : public Expr {
+  friend class ASTStmtReader;
+
+  SourceLocation Loc;
+  QualType SourceTy;
+  Stmt *Index;
+
+public:
+  SYCLBuiltinBaseTypeExpr(SourceLocation Loc, QualType SourceTy, Expr *Index,
+                          QualType BaseTy)
+      : Expr(SYCLBuiltinBaseTypeExprClass, BaseTy, VK_RValue, OK_Ordinary),
+        Loc(Loc), SourceTy(SourceTy), Index(Index) {
+    setDependence(computeDependence(this));
+  }
+
+  explicit SYCLBuiltinBaseTypeExpr(EmptyShell Empty)
+      : Expr(SYCLBuiltinBaseTypeExprClass, Empty) {}
+
+  QualType getSourceType() const { return SourceTy; }
+
+  const Expr *getIndex() const { return static_cast<const Expr *>(Index); }
+  Expr *getIndex() { return static_cast<Expr *>(Index); }
+
+  SourceLocation getBeginLoc() const { return Loc; }
+  SourceLocation getEndLoc() const { return Loc; }
+
+  SourceLocation getLocation() const { return Loc; }
+  void setLocation(SourceLocation L) { Loc = L; }
+
+  static bool classof(const Stmt *T) {
+    return T->getStmtClass() == SYCLBuiltinBaseTypeExprClass;
+  }
+
+  child_range children() { return child_range(&Index, &Index + 1); }
+
+  const_child_range children() const {
+    return const_child_range(&Index, &Index + 1);
+  }
+};
+
 } // namespace clang
 
 #endif // LLVM_CLANG_AST_EXPRCXX_H

clang/include/clang/AST/RecursiveASTVisitor.h

@@ -2359,6 +2359,20 @@ DEF_TRAVERSE_STMT(BuiltinBitCastExpr, {
   TRY_TO(TraverseTypeLoc(S->getTypeInfoAsWritten()->getTypeLoc()));
 })
 
+DEF_TRAVERSE_STMT(SYCLBuiltinFieldTypeExpr, {
+  TRY_TO(TraverseType(S->getSourceType()));
+})
+DEF_TRAVERSE_STMT(SYCLBuiltinBaseTypeExpr, {
+  TRY_TO(TraverseType(S->getSourceType()));
+})
+
+DEF_TRAVERSE_STMT(SYCLBuiltinNumFieldsExpr, {
+  TRY_TO(TraverseType(S->getSourceType()));
+})
+DEF_TRAVERSE_STMT(SYCLBuiltinNumBasesExpr, {
+  TRY_TO(TraverseType(S->getSourceType()));
+})
+
 template <typename Derived>
 bool RecursiveASTVisitor<Derived>::TraverseSynOrSemInitListExpr(
     InitListExpr *S, DataRecursionQueue *Queue) {

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -11351,6 +11351,21 @@ def warn_sycl_kernel_too_big_args : Warning<
 def err_sycl_virtual_types : Error<
   "no class with a vtable can be used in a SYCL kernel or any code included in the kernel">;
 def note_sycl_recursive_function_declared_here: Note<"function implemented using recursion declared here">;
+def err_sycl_type_trait_requires_complete_type : Error<
+  "'%select{__builtin_num_fields|__builtin_field_type|__builtin_num_bases|"
+  "__builtin_base_type}0' requires a complete type">;
+def err_sycl_type_trait_requires_record_type : Error<
+  "'%select{__builtin_num_fields|__builtin_field_type|__builtin_num_bases|"
+  "__builtin_base_type}0' requires a structure "
+  "or lambda type">;
+def err_sycl_builtin_type_trait_index_out_of_range : Error<
+  "index %0 is greater than the number of %select{fields|bases}2 in type %1">;
+def err_sycl_type_trait_requires_nonnegative_index : Error<
+  "'%select{__builtin_field_type|__builtin_base_type}0' requires a "
+  "non-negative index">;
+def err_sycl_builtin_type_trait_evaluated : Error<
+  "'%select{__builtin_field_type|__builtin_base_type}0' cannot be used in an "
+  "evaluated context">;
 def err_sycl_non_trivially_copy_ctor_dtor_type
     : Error<"kernel parameter has non-trivially %select{copy "
             "constructible|destructible}0 class/struct type %1">;

clang/include/clang/Basic/StmtNodes.td

@@ -194,6 +194,12 @@ def ObjCBridgedCastExpr : StmtNode<ExplicitCastExpr>;
 // CUDA Expressions.
 def CUDAKernelCallExpr : StmtNode<CallExpr>;
 
+// SYCL Extensions.
+def SYCLBuiltinNumFieldsExpr : StmtNode<Expr>;
+def SYCLBuiltinFieldTypeExpr : StmtNode<Expr>;
+def SYCLBuiltinNumBasesExpr : StmtNode<Expr>;
+def SYCLBuiltinBaseTypeExpr : StmtNode<Expr>;
+
 // Clang Extensions.
 def ShuffleVectorExpr : StmtNode<Expr>;
 def ConvertVectorExpr : StmtNode<Expr>;

clang/include/clang/Basic/TokenKinds.def

@@ -508,6 +508,12 @@ TYPE_TRAIT_1(__has_unique_object_representations,
              HasUniqueObjectRepresentations, KEYCXX)
 KEYWORD(__underlying_type           , KEYCXX)
 
+// SYCL Type Traits
+KEYWORD(__builtin_num_fields, KEYSYCL)
+KEYWORD(__builtin_field_type, KEYSYCL)
+KEYWORD(__builtin_num_bases, KEYSYCL)
+KEYWORD(__builtin_base_type, KEYSYCL)
+
 // Clang-only C++ Type Traits
 TYPE_TRAIT_2(__reference_binds_to_temporary, ReferenceBindsToTemporary, KEYCXX)
 

clang/include/clang/Parse/Parser.h

@@ -3460,6 +3460,12 @@ class Parser : public CodeCompletionHandler {
   ExprResult ParseArrayTypeTrait();
   ExprResult ParseExpressionTrait();
 
+  /// SYCL Type Traits
+  // __builtin_num_fields, __builtin_num_bases
+  ExprResult ParseSYCLBuiltinNum();
+  // __builtin_field_type, __builtin_base_type
+  ExprResult ParseSYCLBuiltinType();
+
   //===--------------------------------------------------------------------===//
   // Preprocessor code-completion pass-through
   void CodeCompleteDirective(bool InConditional) override;

clang/include/clang/Sema/Sema.h

@@ -13250,6 +13250,28 @@ class Sema final {
   void ConstructOpenCLKernel(FunctionDecl *KernelCallerFunc, MangleContext &MC);
   void MarkDevices();
 
+  /// Get the number of fields or captures within the parsed type.
+  ExprResult ActOnSYCLBuiltinNumFieldsExpr(ParsedType PT);
+  ExprResult BuildSYCLBuiltinNumFieldsExpr(SourceLocation Loc,
+                                           QualType SourceTy);
+
+  /// Get a value based on the type of the given field number so that callers
+  /// can wrap it in a decltype() to get the actual type of the field.
+  ExprResult ActOnSYCLBuiltinFieldTypeExpr(ParsedType PT, Expr *Idx);
+  ExprResult BuildSYCLBuiltinFieldTypeExpr(SourceLocation Loc,
+                                           QualType SourceTy, Expr *Idx);
+
+  /// Get the number of base classes within the parsed type.
+  ExprResult ActOnSYCLBuiltinNumBasesExpr(ParsedType PT);
+  ExprResult BuildSYCLBuiltinNumBasesExpr(SourceLocation Loc,
+                                          QualType SourceTy);
+
+  /// Get a value based on the type of the given base number so that callers
+  /// can wrap it in a decltype() to get the actual type of the base class.
+  ExprResult ActOnSYCLBuiltinBaseTypeExpr(ParsedType PT, Expr *Idx);
+  ExprResult BuildSYCLBuiltinBaseTypeExpr(SourceLocation Loc, QualType SourceTy,
+                                          Expr *Idx);
+
   /// Emit a diagnostic about the given attribute having a deprecated name, and
   /// also emit a fixit hint to generate the new attribute name.
   void DiagnoseDeprecatedAttribute(const ParsedAttr &A, StringRef NewScope,

clang/include/clang/Serialization/ASTBitCodes.h

@@ -1966,7 +1966,11 @@ enum StmtCode {
   // FixedPointLiteral
   EXPR_FIXEDPOINT_LITERAL,
 
-  // SYCLUniqueStableNameExpr
+  // SYCL
+  EXPR_SYCL_BUILTIN_NUM_FIELDS,
+  EXPR_SYCL_BUILTIN_FIELD_TYPE,
+  EXPR_SYCL_BUILTIN_NUM_BASES,
+  EXPR_SYCL_BUILTIN_BASE_TYPE,
   EXPR_SYCL_UNIQUE_STABLE_NAME,
 };
 

clang/lib/AST/ComputeDependence.cpp

@@ -846,3 +846,27 @@ ExprDependence clang::computeDependence(ObjCMessageExpr *E) {
     D |= A->getDependence();
   return D;
 }
+
+ExprDependence clang::computeDependence(SYCLBuiltinNumFieldsExpr *E) {
+  return toExprDependence(E->getSourceType()->getDependence()) &
+         ~ExprDependence::Type;
+}
+
+ExprDependence clang::computeDependence(SYCLBuiltinNumBasesExpr *E) {
+  return toExprDependence(E->getSourceType()->getDependence()) &
+         ~ExprDependence::Type;
+}
+
+ExprDependence clang::computeDependence(SYCLBuiltinFieldTypeExpr *E) {
+  auto D = toExprDependence(E->getSourceType()->getDependence()) &
+           ~ExprDependence::Type;
+  D |= E->getIndex()->getDependence();
+  return D;
+}
+
+ExprDependence clang::computeDependence(SYCLBuiltinBaseTypeExpr *E) {
+  auto D = toExprDependence(E->getSourceType()->getDependence()) &
+           ~ExprDependence::Type;
+  D |= E->getIndex()->getDependence();
+  return D;
+}

clang/lib/AST/Expr.cpp

@@ -3445,6 +3445,10 @@ bool Expr::HasSideEffects(const ASTContext &Ctx,
   case SourceLocExprClass:
   case ConceptSpecializationExprClass:
   case RequiresExprClass:
+  case SYCLBuiltinNumFieldsExprClass:
+  case SYCLBuiltinFieldTypeExprClass:
+  case SYCLBuiltinNumBasesExprClass:
+  case SYCLBuiltinBaseTypeExprClass:
   case SYCLUniqueStableNameExprClass:
     // These never have a side-effect.
     return false;

clang/lib/AST/ExprClassification.cpp

@@ -197,6 +197,10 @@ static Cl::Kinds ClassifyInternal(ASTContext &Ctx, const Expr *E) {
   case Expr::SourceLocExprClass:
   case Expr::ConceptSpecializationExprClass:
   case Expr::RequiresExprClass:
+  case Expr::SYCLBuiltinNumFieldsExprClass:
+  case Expr::SYCLBuiltinFieldTypeExprClass:
+  case Expr::SYCLBuiltinNumBasesExprClass:
+  case Expr::SYCLBuiltinBaseTypeExprClass:
     return Cl::CL_PRValue;
 
   case Expr::ConstantExprClass: