[probably not for upstream] CodeGen, libcxx: Introduce __has_non_relocatable_fields.

In order to properly benchmark PFP we need to be able to do an A/B
comparison and make A and B as equal as possible. This includes not
disabling libc++'s non-standard trivially relocatable optimizations
wherever possible. In the upstream code we just made trivially_relocatable
equivalent to trivially_copyable but in the benchmarking version of
the code (also more aligned to what will be possible in C++26) restore
trivially_relocatable logic but also check whether any of the fields
are non-relocatable using a temporarily introduced builtin.

Author: pcc

clang/include/clang/Basic/TokenKinds.def

@@ -544,6 +544,7 @@ TYPE_TRAIT_2(__is_pointer_interconvertible_base_of, IsPointerInterconvertibleBas
 #include "clang/Basic/TransformTypeTraits.def"
 
 // Clang-only C++ Type Traits
+TYPE_TRAIT_1(__has_non_relocatable_fields, HasNonRelocatableFields, KEYCXX)
 TYPE_TRAIT_1(__is_trivially_equality_comparable, IsTriviallyEqualityComparable, KEYCXX)
 TYPE_TRAIT_1(__is_bounded_array, IsBoundedArray, KEYCXX)
 TYPE_TRAIT_1(__is_unbounded_array, IsUnboundedArray, KEYCXX)

clang/lib/Sema/SemaTypeTraits.cpp

@@ -533,6 +533,7 @@ static bool CheckUnaryTypeTraitTypeCompleteness(Sema &S, TypeTrait UTT,
   case UTT_IsTriviallyEqualityComparable:
   case UTT_IsCppTriviallyRelocatable:
   case UTT_IsReplaceable:
+  case UTT_HasNonRelocatableFields:
   case UTT_CanPassInRegs:
   // Per the GCC type traits documentation, T shall be a complete type, cv void,
   // or an array of unknown bound. But GCC actually imposes the same constraints
@@ -1132,6 +1133,10 @@ static bool EvaluateUnaryTypeTrait(Sema &Self, TypeTrait UTT,
     return C.hasUniqueObjectRepresentations(T);
   case UTT_IsTriviallyRelocatable:
     return IsTriviallyRelocatableType(Self, T);
+  case UTT_HasNonRelocatableFields:
+    return T->getAsCXXRecordDecl() &&
+           !C.arePFPFieldsTriviallyRelocatable(T->getAsCXXRecordDecl()) &&
+           C.hasPFPFields(T);
   case UTT_IsBitwiseCloneable:
     return T.isBitwiseCloneableType(C);
   case UTT_IsCppTriviallyRelocatable:

libcxx/include/__type_traits/is_trivially_relocatable.h

@@ -34,14 +34,14 @@ template <class _Tp, class = void>
 struct __libcpp_is_trivially_relocatable : is_trivially_copyable<_Tp> {};
 #endif
 
-// __trivially_relocatable on libc++'s builtin types does not currently return the right answer with PFP.
-#if !__has_feature(pointer_field_protection)
 template <class _Tp>
 struct __libcpp_is_trivially_relocatable<_Tp,
                                          __enable_if_t<is_same<_Tp, typename _Tp::__trivially_relocatable>::value
-                                         __enable_if_t<is_same<_Tp, typename _Tp::__trivially_relocatable>::value> >
-    : true_type {};
+#if __has_builtin(__has_non_relocatable_fields)
+                                                       && !__has_non_relocatable_fields(_Tp)
 #endif
+                                                       > > : true_type {
+};
 
 _LIBCPP_END_NAMESPACE_STD