Address review comments.

Author: hokein

clang/docs/LanguageExtensions.rst

@@ -4016,6 +4016,50 @@ Note that the `size` argument must be a compile time constant.
 
 Note that this intrinsic cannot yet be called in a ``constexpr`` context.
 
+``__is_bitwise_cloneable``
+-------------------------
+
+A type trait is used to check whether a type can be safely copied by memcpy.
+
+**Syntax**:
+
+.. code-block:: c++
+
+  bool __is_bitwise_cloneable(Type)
+
+** Example of Use**:
+
+.. code-block:: c++
+
+  // Return a cloned object of the given default instance.
+  Foo* Clone(const Foo* default_instance, char* buffer, unsigned size) {
+    if constexpr __is_bitwise_cloneable(decltype(*default_instance)) {
+      // Fast path via memcopy, without calling class constructor.
+      memcpy(buffer, default_instance, size);
+      // Explicitly start the lifetime of the cloned object.
+      return __builtin_start_object_lifetime(reinterpret_cast<Foo*>(buffer));
+    }
+    // Fallback the operator new, which invoke the class constructor.
+    return new(buffer) Foo(*default_instance);
+  }
+
+**Description**:
+
+It is common for library owners to perform memcpy/memmove on types that aren't
+trivally copyable for performance reason. However, according to the C++ standard,
+it is undefined bheavior to mempcy non-trivially-copyable types, even though
+it may work in pratice. This builtin is designed to bridge that gap.
+
+Objects of bitwise cloneable types can be bitwise copied by memcpy/memmove. The
+Clang compiler warrants that this behavior is well defined, and won't be
+broken by compiler optimizations.
+
+After the copy, the lifetime of the new object isn't started yet (unless the
+type is trivially copyable). Users must explicitly start its lifetime by the
+`__builtin_start_object_lifetime` mechanism to avoid undefined behavior.
+
+This builtin can be used in constant expressions.
+
 Atomic Min/Max builtins with memory ordering
 --------------------------------------------
 

clang/include/clang/AST/Type.h

@@ -1120,17 +1120,13 @@ class QualType {
   /// Return true if this is a trivially copyable type (C++0x [basic.types]p9)
   bool isTriviallyCopyableType(const ASTContext &Context) const;
 
-  /// Return true if this is a bitwise copyable type.
+  /// Return true if the type is safe to bitwise copy by memcpy.
   ///
-  /// This is an extension in clang: bitwise copyable types act as trivially
-  /// copyable types, underlying bytes of bitwise copyable type can be safely
-  /// copied by memcpy or memmove. Clang guarantees that both source and
-  /// destination objects have the same **object** representations after the
-  /// copy, and the lifetime of the destination object implicitly starts.
-  ///
-  /// bitwise copyable types cover a wider range of types, e.g. classes with
-  /// virtual methods.
-  bool isBitwiseCopyableType(const ASTContext &Context) const;
+  /// This is an extension in clang: bitwise clonable types act as trivially
+  /// copyable types, their underlying bytes can be safely copied by memcpy or
+  /// memmove. Clang guarantees that the destination has the same **object**
+  /// representations after the copy.
+  bool isBitwiseCloneableType(const ASTContext &Context) const;
 
   /// Return true if this is a trivially copyable type
   bool isTriviallyCopyConstructibleType(const ASTContext &Context) const;

clang/include/clang/Basic/TokenKinds.def

@@ -527,7 +527,6 @@ TYPE_TRAIT_2(__is_pointer_interconvertible_base_of, IsPointerInterconvertibleBas
 #include "clang/Basic/TransformTypeTraits.def"
 
 // Clang-only C++ Type Traits
-TYPE_TRAIT_1(__is_bitwise_copyable, IsBitwiseCopyable, KEYCXX)
 TYPE_TRAIT_1(__is_trivially_relocatable, IsTriviallyRelocatable, KEYCXX)
 TYPE_TRAIT_1(__is_trivially_equality_comparable, IsTriviallyEqualityComparable, KEYCXX)
 TYPE_TRAIT_1(__is_bounded_array, IsBoundedArray, KEYCXX)
@@ -540,6 +539,8 @@ TYPE_TRAIT_2(__reference_binds_to_temporary, ReferenceBindsToTemporary, KEYCXX)
 TYPE_TRAIT_2(__reference_constructs_from_temporary, ReferenceConstructsFromTemporary, KEYCXX)
 TYPE_TRAIT_2(__reference_converts_from_temporary, ReferenceConvertsFromTemporary, KEYCXX)
 
+TYPE_TRAIT_1(__is_bitwise_cloneable, IsBitwiseCloneable, KEYALL)
+
 // Embarcadero Expression Traits
 EXPRESSION_TRAIT(__is_lvalue_expr, IsLValueExpr, KEYCXX)
 EXPRESSION_TRAIT(__is_rvalue_expr, IsRValueExpr, KEYCXX)

clang/lib/AST/Type.cpp

@@ -2731,22 +2731,29 @@ bool QualType::isTriviallyCopyableType(const ASTContext &Context) const {
                                      /*IsCopyConstructible=*/false);
 }
 
-bool QualType::isBitwiseCopyableType(const ASTContext & Context) const {
+bool QualType::isBitwiseCloneableType(const ASTContext & Context) const {
   QualType CanonicalType = getCanonicalType();
   if (CanonicalType->isIncompleteType() || CanonicalType->isDependentType())
     return false;
-  // Trivially copyable types are bitwise copyable, e.g. scalar types.
+  // Trivially copyable types are bitwise clonable, e.g. scalar types.
   if (CanonicalType.isTriviallyCopyableType(Context))
     return true;
 
   if (CanonicalType->isArrayType())
     return Context.getBaseElementType(CanonicalType)
-        .isBitwiseCopyableType(Context);
+        .isBitwiseCloneableType(Context);
 
   if (const auto *RD = CanonicalType->getAsCXXRecordDecl()) {
+    for (auto Base : RD->bases())
+      if (!Base.getType().isBitwiseCloneableType(Context))
+        return false;
+    for (auto VBase : RD->vbases())
+      if (!VBase.getType().isBitwiseCloneableType(Context))
+        return false;
+
     for (auto *const Field : RD->fields()) {
       QualType T = Context.getBaseElementType(Field->getType());
-      if (!T.isBitwiseCopyableType(Context))
+      if (!T.isBitwiseCloneableType(Context))
         return false;
     }
     return true;

clang/lib/Sema/SemaExprCXX.cpp

@@ -5128,8 +5128,7 @@ static bool CheckUnaryTypeTraitTypeCompleteness(Sema &S, TypeTrait UTT,
   case UTT_IsStandardLayout:
   case UTT_IsPOD:
   case UTT_IsLiteral:
-  // Clang extension:
-  case UTT_IsBitwiseCopyable:
+  case UTT_IsBitwiseCloneable:
   // By analogy, is_trivially_relocatable and is_trivially_equality_comparable
   // impose the same constraints.
   case UTT_IsTriviallyRelocatable:
@@ -5615,8 +5614,8 @@ static bool EvaluateUnaryTypeTrait(Sema &Self, TypeTrait UTT,
     return C.hasUniqueObjectRepresentations(T);
   case UTT_IsTriviallyRelocatable:
     return T.isTriviallyRelocatableType(C);
-  case UTT_IsBitwiseCopyable:
-    return T.isBitwiseCopyableType(C);
+  case UTT_IsBitwiseCloneable:
+    return T.isBitwiseCloneableType(C);
   case UTT_IsReferenceable:
     return T.isReferenceable();
   case UTT_CanPassInRegs:

clang/test/SemaCXX/builtin-is-bitwise-cloneable.cpp

@@ -0,0 +1,41 @@
+// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify %s
+
+// Scalar types are bitwise clonable.
+static_assert(__is_bitwise_cloneable(int));
+static_assert(__is_bitwise_cloneable(int*));
+// array
+static_assert(__is_bitwise_cloneable(int[10]));
+
+// non-scalar types.
+static_assert(!__is_bitwise_cloneable(int&));
+
+
+struct Forward; // expected-note 2{{forward declaration of 'Forward'}}
+static_assert(!__is_bitwise_cloneable(Forward)); // expected-error {{incomplete type 'Forward' used in type trait expression}}
+
+struct Foo { int a; };
+static_assert(__is_bitwise_cloneable(Foo));
+
+struct DynamicClass { virtual int Foo(); };
+static_assert(__is_bitwise_cloneable(DynamicClass));
+
+struct Bar { int& b; }; // trivially copyable
+static_assert(__is_trivially_copyable(Bar));
+static_assert(__is_bitwise_cloneable(Bar));
+
+struct Bar2 { Bar2(const Bar2&); int& b; }; // non-trivially copyable
+static_assert(!__is_trivially_copyable(Bar2));
+static_assert(!__is_bitwise_cloneable(Bar2)); // int& non-scalar member.
+
+struct DerivedBar2 : public Bar2 {};
+static_assert(!__is_bitwise_cloneable(DerivedBar2)); // base Bar2 is non-bitwise-cloneable.
+
+
+template <typename T>
+void TemplateFunction() {
+  static_assert(__is_bitwise_cloneable(T)); // expected-error {{incomplete type 'Forward' used in type trait expression}}
+}
+void CallTemplateFunc() {
+  TemplateFunction<Forward>(); // expected-note {{in instantiation of function template specialization}}
+  TemplateFunction<Foo>();
+}