Implement the __is_trivially_copyable type trait

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@131270 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/clang/AST/Type.h b/include/clang/AST/Type.h
index 9fc776d051094d173e02ff55900983bbec9b71ff..b883002f9f4419d2b561698b1ac9b86f0d15fdc6 100644 (file)
--- a/include/clang/AST/Type.h
+++ b/include/clang/AST/Type.h
@@ -1189,6 +1189,10 @@ public:
   /// (C++0x [basic.types]p9)
   bool isTrivialType() const;
 
+  /// isTriviallyCopyableType - Return true if this is a trivially copyable type
+  /// (C++0x [basic.types]p9
+  bool isTriviallyCopyableType() const;
+
   /// \brief Test if this type is a standard-layout type.
   /// (C++0x [basic.type]p9)
   bool isStandardLayoutType() const;

diff --git a/include/clang/Basic/TokenKinds.def b/include/clang/Basic/TokenKinds.def
index 131bfe3afea98e240931325ebbb779286d7d917e..239c5b83e101dd516ea4480d173a1dbd5146af0d 100644 (file)
--- a/include/clang/Basic/TokenKinds.def
+++ b/include/clang/Basic/TokenKinds.def
@@ -346,6 +346,9 @@ KEYWORD(__is_polymorphic            , KEYCXX)
 KEYWORD(__is_trivial                , KEYCXX)
 KEYWORD(__is_union                  , KEYCXX)
 
+// Clang-only C++ Type Traits
+KEYWORD(__is_trivially_copyable     , KEYCXX)
+
 // Embarcadero Expression Traits
 KEYWORD(__is_lvalue_expr            , KEYCXX)
 KEYWORD(__is_rvalue_expr            , KEYCXX)

diff --git a/include/clang/Basic/TypeTraits.h b/include/clang/Basic/TypeTraits.h
index b9b94a6f751fb622913d476e95b194fe9fb741dd..a7a45bded82076e3939569940ac30712265cfa2e 100644 (file)
--- a/include/clang/Basic/TypeTraits.h
+++ b/include/clang/Basic/TypeTraits.h
@@ -54,6 +54,7 @@ namespace clang {
     UTT_IsSigned,
     UTT_IsStandardLayout,
     UTT_IsTrivial,
+    UTT_IsTriviallyCopyable,
     UTT_IsUnion,
     UTT_IsUnsigned,
     UTT_IsVoid,

diff --git a/lib/AST/StmtPrinter.cpp b/lib/AST/StmtPrinter.cpp
index 094864b1ebf9a377f165dc09c20625e5a5934101..1ef601c09be47726fac71e0859e7c05dc742e10a 100644 (file)
--- a/lib/AST/StmtPrinter.cpp
+++ b/lib/AST/StmtPrinter.cpp
@@ -1329,6 +1329,7 @@ static const char *getTypeTraitName(UnaryTypeTrait UTT) {
   case UTT_IsSigned:                return "__is_signed";
   case UTT_IsStandardLayout:        return "__is_standard_layout";
   case UTT_IsTrivial:               return "__is_trivial";
+  case UTT_IsTriviallyCopyable:     return "__is_trivially_copyable";
   case UTT_IsUnion:               return "__is_union";
   case UTT_IsUnsigned:              return "__is_unsigned";
   case UTT_IsVoid:                  return "__is_void";

diff --git a/lib/AST/Type.cpp b/lib/AST/Type.cpp
index 638c4dcf281d69b096077800247c5f7687763edd..1e7839334146030aa1815063fcf4b0e51ac78e69 100644 (file)
--- a/lib/AST/Type.cpp
+++ b/lib/AST/Type.cpp
@@ -964,6 +964,37 @@ bool Type::isTrivialType() const {
   return false;
 }
 
+bool Type::isTriviallyCopyableType() const {
+  if (isDependentType())
+    return false;
+
+  // C++0x [basic.types]p9
+  //   Scalar types, trivially copyable class types, arrays of such types, and
+  //   cv-qualified versions of these types are collectively called trivial
+  //   types.
+  const Type *BaseTy = getBaseElementTypeUnsafe();
+  assert(BaseTy && "NULL element type");
+
+  // Return false for incomplete types after skipping any incomplete array types
+  // which are expressly allowed by the standard and thus our API.
+  if (BaseTy->isIncompleteType())
+    return false;
+ 
+  // As an extension, Clang treats vector types as Scalar types.
+  if (BaseTy->isScalarType() || BaseTy->isVectorType()) return true;
+  if (const RecordType *RT = BaseTy->getAs<RecordType>()) {
+    if (const CXXRecordDecl *ClassDecl =
+        dyn_cast<CXXRecordDecl>(RT->getDecl())) {
+      if (!ClassDecl->isTriviallyCopyable()) return false;
+    }
+
+    return true;
+  }
+
+  // No other types can match.
+  return false;
+}
+
 bool Type::isStandardLayoutType() const {
   if (isDependentType())
     return false;

diff --git a/lib/Lex/PPMacroExpansion.cpp b/lib/Lex/PPMacroExpansion.cpp
index ce7acf7806f6cbaa25cd835eecff10af9d0f790b..bc3c9b5a59c593aa23d0e27b06830e83dd9e77fe 100644 (file)
--- a/lib/Lex/PPMacroExpansion.cpp
+++ b/lib/Lex/PPMacroExpansion.cpp
@@ -597,6 +597,7 @@ static bool HasFeature(const Preprocessor &PP, const IdentifierInfo *II) {
            .Case("is_pod", LangOpts.CPlusPlus)
            .Case("is_polymorphic", LangOpts.CPlusPlus)
            .Case("is_trivial", LangOpts.CPlusPlus)
+           .Case("is_trivially_copyable", LangOpts.CPlusPlus)
            .Case("is_union", LangOpts.CPlusPlus)
            .Case("tls", PP.getTargetInfo().isTLSSupported())
            .Default(false);

diff --git a/lib/Parse/ParseExpr.cpp b/lib/Parse/ParseExpr.cpp
index 91fe1e1935e9dbae544e1a8f49a170f1ccee05ce..25d505c2c595768218d8bb503d4a0f109b5f3cb1 100644 (file)
--- a/lib/Parse/ParseExpr.cpp
+++ b/lib/Parse/ParseExpr.cpp
@@ -566,6 +566,9 @@ ExprResult Parser::ParseCastExpression(bool isUnaryExpression,
 ///                   '__is_trivial'
 ///                   '__is_union'
 ///
+/// [Clang] unary-type-trait:
+///                   '__trivially_copyable'
+///
 ///       binary-type-trait:
 /// [GNU]             '__is_base_of'       
 /// [MS]              '__is_convertible_to'
@@ -1060,6 +1063,7 @@ ExprResult Parser::ParseCastExpression(bool isUnaryExpression,
   case tok::kw___is_pod:
   case tok::kw___is_polymorphic:
   case tok::kw___is_trivial:
+  case tok::kw___is_trivially_copyable:
   case tok::kw___is_union:
   case tok::kw___has_trivial_constructor:
   case tok::kw___has_trivial_copy:

diff --git a/lib/Parse/ParseExprCXX.cpp b/lib/Parse/ParseExprCXX.cpp
index c8f95ff4f605b6c698dbd37c8e7fd59863d416b3..7410dbecf1f3ecafa60456c728fd6e8fa639558b 100644 (file)
--- a/lib/Parse/ParseExprCXX.cpp
+++ b/lib/Parse/ParseExprCXX.cpp
@@ -1958,6 +1958,7 @@ static UnaryTypeTrait UnaryTypeTraitFromTokKind(tok::TokenKind kind) {
   case tok::kw___is_signed:                  return UTT_IsSigned;
   case tok::kw___is_standard_layout:         return UTT_IsStandardLayout;
   case tok::kw___is_trivial:                 return UTT_IsTrivial;
+  case tok::kw___is_trivially_copyable:      return UTT_IsTriviallyCopyable;
   case tok::kw___is_union:                return UTT_IsUnion;
   case tok::kw___is_unsigned:                return UTT_IsUnsigned;
   case tok::kw___is_void:                    return UTT_IsVoid;

diff --git a/lib/Parse/ParseTentative.cpp b/lib/Parse/ParseTentative.cpp
index 1c4e2b3ddc8b2a8d0b0ba4b54c0126d6632621d9..12152c36cc3a61d35cba7a2ff1a3dac706c3b2ca 100644 (file)
--- a/lib/Parse/ParseTentative.cpp
+++ b/lib/Parse/ParseTentative.cpp
@@ -664,6 +664,7 @@ Parser::isExpressionOrTypeSpecifierSimple(tok::TokenKind Kind) {
   case tok::kw___is_pod:
   case tok::kw___is_polymorphic:
   case tok::kw___is_trivial:
+  case tok::kw___is_trivially_copyable:
   case tok::kw___is_union:
   case tok::kw___uuidof:
     return TPResult::True();

diff --git a/lib/Sema/SemaExprCXX.cpp b/lib/Sema/SemaExprCXX.cpp
index a843ba428499a2b5a1aff3614baab92b96adb759..f0faa8c29cbcde9498bf8061b0c1301a3702a84f 100644 (file)
--- a/lib/Sema/SemaExprCXX.cpp
+++ b/lib/Sema/SemaExprCXX.cpp
@@ -2436,6 +2436,7 @@ static bool CheckUnaryTypeTraitTypeCompleteness(Sema &S,
     // C++0x [meta.unary.prop] Table 49 requires the following traits to be
     // applied to a complete type.
   case UTT_IsTrivial:
+  case UTT_IsTriviallyCopyable:
   case UTT_IsStandardLayout:
   case UTT_IsPOD:
   case UTT_IsLiteral:
@@ -2532,6 +2533,8 @@ static bool EvaluateUnaryTypeTrait(Sema &Self, UnaryTypeTrait UTT,
     return T.isVolatileQualified();
   case UTT_IsTrivial:
     return T->isTrivialType();
+  case UTT_IsTriviallyCopyable:
+    return T->isTriviallyCopyableType();
   case UTT_IsStandardLayout:
     return T->isStandardLayoutType();
   case UTT_IsPOD:

diff --git a/test/Lexer/has_feature_type_traits.cpp b/test/Lexer/has_feature_type_traits.cpp
index c887563c2dd8250f07c01a915d5ac35a56fd38bf..5da845f06512085bb3c90a9182733d406ba39d2c 100644 (file)
--- a/test/Lexer/has_feature_type_traits.cpp
+++ b/test/Lexer/has_feature_type_traits.cpp
@@ -94,3 +94,8 @@ int is_literal();
 int is_standard_layout();
 #endif
 // CHECK: int is_standard_layout();
+
+#if __has_feature(is_trivially_copyable)
+int is_trivially_copyable();
+#endif
+// CHECK: int is_trivially_copyable();

diff --git a/test/SemaCXX/type-traits.cpp b/test/SemaCXX/type-traits.cpp
index 96e9696a041c5e2afd2f0d3b1284a13badc70423..c3470d4c16b96124580990253f31caa916d2919d 100644 (file)
--- a/test/SemaCXX/type-traits.cpp
+++ b/test/SemaCXX/type-traits.cpp
@@ -870,6 +870,15 @@ struct NonTrivialStruct {
   }
 };
 
+struct SuperNonTrivialStruct {
+  SuperNonTrivialStruct() { }
+  ~SuperNonTrivialStruct() { }
+};
+
+struct NonTCStruct {
+  NonTCStruct(const NonTCStruct&) {}
+};
+
 void is_trivial2()
 {
   int t01[T(__is_trivial(char))];
@@ -897,6 +906,39 @@ void is_trivial2()
 
   int t30[F(__is_trivial(void))];
   int t31[F(__is_trivial(NonTrivialStruct))];
+  int t32[F(__is_trivial(SuperNonTrivialStruct))];
+  int t33[F(__is_trivial(NonTCStruct))];
+}
+
+void is_trivially_copyable2()
+{
+  int t01[T(__is_trivially_copyable(char))];
+  int t02[T(__is_trivially_copyable(int))];
+  int t03[T(__is_trivially_copyable(long))];
+  int t04[T(__is_trivially_copyable(short))];
+  int t05[T(__is_trivially_copyable(signed char))];
+  int t06[T(__is_trivially_copyable(wchar_t))];
+  int t07[T(__is_trivially_copyable(bool))];
+  int t08[T(__is_trivially_copyable(float))];
+  int t09[T(__is_trivially_copyable(double))];
+  int t10[T(__is_trivially_copyable(long double))];
+  int t11[T(__is_trivially_copyable(unsigned char))];
+  int t12[T(__is_trivially_copyable(unsigned int))];
+  int t13[T(__is_trivially_copyable(unsigned long long))];
+  int t14[T(__is_trivially_copyable(unsigned long))];
+  int t15[T(__is_trivially_copyable(unsigned short))];
+  int t16[T(__is_trivially_copyable(ClassType))];
+  int t17[T(__is_trivially_copyable(Derives))];
+  int t18[T(__is_trivially_copyable(Enum))];
+  int t19[T(__is_trivially_copyable(IntAr))];
+  int t20[T(__is_trivially_copyable(Union))];
+  int t21[T(__is_trivially_copyable(UnionAr))];
+  int t22[T(__is_trivially_copyable(TrivialStruct))];
+  int t23[T(__is_trivially_copyable(NonTrivialStruct))];
+
+  int t30[F(__is_trivially_copyable(void))];
+  int t32[F(__is_trivially_copyable(SuperNonTrivialStruct))];
+  int t31[F(__is_trivially_copyable(NonTCStruct))];
 }
 
 struct CStruct {
@@ -1474,6 +1516,51 @@ void is_trivial()
   { int arr[F(__is_trivial(cvoid))]; }
 }
 
+void is_trivially_copyable()
+{
+  { int arr[T(__is_trivially_copyable(int))]; }
+  { int arr[T(__is_trivially_copyable(Enum))]; }
+  { int arr[T(__is_trivially_copyable(POD))]; }
+  { int arr[T(__is_trivially_copyable(Int))]; }
+  { int arr[T(__is_trivially_copyable(IntAr))]; }
+  { int arr[T(__is_trivially_copyable(IntArNB))]; }
+  { int arr[T(__is_trivially_copyable(Statics))]; }
+  { int arr[T(__is_trivially_copyable(Empty))]; }
+  { int arr[T(__is_trivially_copyable(EmptyUnion))]; }
+  { int arr[T(__is_trivially_copyable(Union))]; }
+  { int arr[T(__is_trivially_copyable(Derives))]; }
+  { int arr[T(__is_trivially_copyable(DerivesAr))]; }
+  { int arr[T(__is_trivially_copyable(DerivesArNB))]; }
+  { int arr[T(__is_trivially_copyable(DerivesEmpty))]; }
+  { int arr[T(__is_trivially_copyable(HasFunc))]; }
+  { int arr[T(__is_trivially_copyable(HasOp))]; }
+  { int arr[T(__is_trivially_copyable(HasConv))]; }
+  { int arr[T(__is_trivially_copyable(HasAssign))]; }
+  { int arr[T(__is_trivially_copyable(HasAnonymousUnion))]; }
+  { int arr[T(__is_trivially_copyable(HasPriv))]; }
+  { int arr[T(__is_trivially_copyable(HasProt))]; }
+  { int arr[T(__is_trivially_copyable(DerivesHasPriv))]; }
+  { int arr[T(__is_trivially_copyable(DerivesHasProt))]; }
+  { int arr[T(__is_trivially_copyable(Vector))]; }
+  { int arr[T(__is_trivially_copyable(VectorExt))]; }
+  { int arr[T(__is_trivially_copyable(HasCons))]; }
+  { int arr[T(__is_trivially_copyable(HasRef))]; }
+  { int arr[T(__is_trivially_copyable(HasNonPOD))]; }
+  { int arr[T(__is_trivially_copyable(DerivesHasCons))]; }
+  { int arr[T(__is_trivially_copyable(DerivesHasRef))]; }
+
+  { int arr[F(__is_trivially_copyable(HasCopyAssign))]; }
+  { int arr[F(__is_trivially_copyable(HasMoveAssign))]; }
+  { int arr[F(__is_trivially_copyable(HasDest))]; }
+  { int arr[F(__is_trivially_copyable(HasVirt))]; }
+  { int arr[F(__is_trivially_copyable(DerivesHasCopyAssign))]; }
+  { int arr[F(__is_trivially_copyable(DerivesHasMoveAssign))]; }
+  { int arr[F(__is_trivially_copyable(DerivesHasDest))]; }
+  { int arr[F(__is_trivially_copyable(DerivesHasVirt))]; }
+  { int arr[F(__is_trivially_copyable(void))]; }
+  { int arr[F(__is_trivially_copyable(cvoid))]; }
+}
+
 void array_rank() {
   int t01[T(__array_rank(IntAr) == 1)];
   int t02[T(__array_rank(ConstIntArAr) == 2)];