https://github.com/ojhunt updated https://github.com/llvm/llvm-project/pull/154490
>From 689d70c706546a5b0b2ee00ebe7e030041d6fb2b Mon Sep 17 00:00:00 2001 From: Oliver Hunt <oli...@apple.com> Date: Wed, 20 Aug 2025 01:28:29 -0700 Subject: [PATCH] [clang][PAC] Fix builtins that claim Address discriminated types are copyable A number of builtins report some variation of "this type is compatibile with some bitwise equivalent operation", but this is not true for address discriminated values. We had address a number of cases, but not all of them. This PR corrects the remaining builtins. Fixes #154394 --- clang/include/clang/AST/ASTContext.h | 11 +- clang/lib/AST/ASTContext.cpp | 9 +- clang/lib/AST/DeclCXX.cpp | 4 + clang/lib/AST/Type.cpp | 20 + clang/lib/Sema/SemaDecl.cpp | 1 + clang/lib/Sema/SemaTypeTraits.cpp | 5 +- clang/test/SemaCXX/ptrauth-triviality.cpp | 6 +- clang/test/SemaCXX/ptrauth-type-traits.cpp | 401 ++++++++++++++++++ .../SemaCXX/trivially-relocatable-ptrauth.cpp | 4 +- 9 files changed, 445 insertions(+), 16 deletions(-) create mode 100644 clang/test/SemaCXX/ptrauth-type-traits.cpp diff --git a/clang/include/clang/AST/ASTContext.h b/clang/include/clang/AST/ASTContext.h index 07f4935e06555..1c17333b722f8 100644 --- a/clang/include/clang/AST/ASTContext.h +++ b/clang/include/clang/AST/ASTContext.h @@ -642,7 +642,7 @@ class ASTContext : public RefCountedBase<ASTContext> { /// contain data that is address discriminated. This includes /// implicitly authenticated values like vtable pointers, as well as /// explicitly qualified fields. - bool containsAddressDiscriminatedPointerAuth(QualType T) { + bool containsAddressDiscriminatedPointerAuth(QualType T) const { if (!isPointerAuthenticationAvailable()) return false; return findPointerAuthContent(T) != PointerAuthContent::None; @@ -656,8 +656,7 @@ class ASTContext : public RefCountedBase<ASTContext> { bool containsNonRelocatablePointerAuth(QualType T) { if (!isPointerAuthenticationAvailable()) return false; - return findPointerAuthContent(T) == - PointerAuthContent::AddressDiscriminatedData; + return findPointerAuthContent(T) != PointerAuthContent::None; } private: @@ -675,8 +674,8 @@ class ASTContext : public RefCountedBase<ASTContext> { bool isPointerAuthenticationAvailable() const { return LangOpts.PointerAuthCalls || LangOpts.PointerAuthIntrinsics; } - PointerAuthContent findPointerAuthContent(QualType T); - llvm::DenseMap<const RecordDecl *, PointerAuthContent> + PointerAuthContent findPointerAuthContent(QualType T) const; + mutable llvm::DenseMap<const RecordDecl *, PointerAuthContent> RecordContainsAddressDiscriminatedPointerAuth; ImportDecl *FirstLocalImport = nullptr; @@ -3723,7 +3722,7 @@ OPT_LIST(V) /// Resolve the root record to be used to derive the vtable pointer /// authentication policy for the specified record. const CXXRecordDecl * - baseForVTableAuthentication(const CXXRecordDecl *ThisClass); + baseForVTableAuthentication(const CXXRecordDecl *ThisClass) const; bool useAbbreviatedThunkName(GlobalDecl VirtualMethodDecl, StringRef MangledName); diff --git a/clang/lib/AST/ASTContext.cpp b/clang/lib/AST/ASTContext.cpp index bbb957067c4c8..75a203db6dbcd 100644 --- a/clang/lib/AST/ASTContext.cpp +++ b/clang/lib/AST/ASTContext.cpp @@ -1708,7 +1708,7 @@ void ASTContext::setRelocationInfoForCXXRecord( } static bool primaryBaseHaseAddressDiscriminatedVTableAuthentication( - ASTContext &Context, const CXXRecordDecl *Class) { + const ASTContext &Context, const CXXRecordDecl *Class) { if (!Class->isPolymorphic()) return false; const CXXRecordDecl *BaseType = Context.baseForVTableAuthentication(Class); @@ -1723,7 +1723,8 @@ static bool primaryBaseHaseAddressDiscriminatedVTableAuthentication( return AddressDiscrimination == AuthAttr::AddressDiscrimination; } -ASTContext::PointerAuthContent ASTContext::findPointerAuthContent(QualType T) { +ASTContext::PointerAuthContent +ASTContext::findPointerAuthContent(QualType T) const { assert(isPointerAuthenticationAvailable()); T = T.getCanonicalType(); @@ -3040,7 +3041,7 @@ bool ASTContext::hasUniqueObjectRepresentations( return true; } - // All other pointers (except __ptrauth pointers) are unique. + // All other pointers are unique. if (Ty->isPointerType()) return !Ty.hasAddressDiscriminatedPointerAuth(); @@ -15203,7 +15204,7 @@ StringRef ASTContext::getCUIDHash() const { } const CXXRecordDecl * -ASTContext::baseForVTableAuthentication(const CXXRecordDecl *ThisClass) { +ASTContext::baseForVTableAuthentication(const CXXRecordDecl *ThisClass) const { assert(ThisClass); assert(ThisClass->isPolymorphic()); const CXXRecordDecl *PrimaryBase = ThisClass; diff --git a/clang/lib/AST/DeclCXX.cpp b/clang/lib/AST/DeclCXX.cpp index 50b1a1d000090..315a37338e9eb 100644 --- a/clang/lib/AST/DeclCXX.cpp +++ b/clang/lib/AST/DeclCXX.cpp @@ -1438,6 +1438,10 @@ void CXXRecordDecl::addedMember(Decl *D) { data().StructuralIfLiteral = false; } + if (!data().HasTrivialSpecialMembers && + T.hasAddressDiscriminatedPointerAuth()) + data().HasTrivialSpecialMembers = true; + // C++14 [meta.unary.prop]p4: // T is a class type [...] with [...] no non-static data members other // than subobjects of zero size diff --git a/clang/lib/AST/Type.cpp b/clang/lib/AST/Type.cpp index a70bc5424009c..dd51e03239374 100644 --- a/clang/lib/AST/Type.cpp +++ b/clang/lib/AST/Type.cpp @@ -2771,6 +2771,11 @@ bool QualType::isCXX98PODType(const ASTContext &Context) const { return false; QualType CanonicalType = getTypePtr()->CanonicalType; + + // Any type that is, or contains, address discriminated data is never POD. + if (Context.containsAddressDiscriminatedPointerAuth(CanonicalType)) + return false; + switch (CanonicalType->getTypeClass()) { // Everything not explicitly mentioned is not POD. default: @@ -2829,6 +2834,11 @@ bool QualType::isTrivialType(const ASTContext &Context) const { if (CanonicalType->isDependentType()) return false; + // Any type that is, or contains, address discriminated data is never a + // trivial type. + if (Context.containsAddressDiscriminatedPointerAuth(CanonicalType)) + return false; + // C++0x [basic.types]p9: // Scalar types, trivial class types, arrays of such types, and // cv-qualified versions of these types are collectively called trivial @@ -2930,6 +2940,12 @@ bool QualType::isBitwiseCloneableType(const ASTContext &Context) const { if (CanonicalType->isIncompleteType()) return false; + + // Any type that is, or contains, address discriminated data is never + // bitwise clonable. + if (Context.containsAddressDiscriminatedPointerAuth(CanonicalType)) + return false; + const auto *RD = CanonicalType->getAsRecordDecl(); // struct/union/class if (!RD) return true; @@ -3179,6 +3195,10 @@ bool QualType::isCXX11PODType(const ASTContext &Context) const { if (BaseTy->isIncompleteType()) return false; + // Any type that is, or contains, address discriminated data is non-POD + if (Context.containsAddressDiscriminatedPointerAuth(*this)) + return false; + // As an extension, Clang treats vector types as Scalar types. if (BaseTy->isScalarType() || BaseTy->isVectorType()) return true; diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp index 160d7353cacd9..b00eee119763f 100644 --- a/clang/lib/Sema/SemaDecl.cpp +++ b/clang/lib/Sema/SemaDecl.cpp @@ -19779,6 +19779,7 @@ void Sema::ActOnFields(Scope *S, SourceLocation RecLoc, Decl *EnclosingDecl, Q && Q.isAddressDiscriminated()) { Record->setArgPassingRestrictions( RecordArgPassingKind::CanNeverPassInRegs); + Record->setNonTrivialToPrimitiveCopy(true); } } diff --git a/clang/lib/Sema/SemaTypeTraits.cpp b/clang/lib/Sema/SemaTypeTraits.cpp index 9b9dd172003a0..c62f7a29cc912 100644 --- a/clang/lib/Sema/SemaTypeTraits.cpp +++ b/clang/lib/Sema/SemaTypeTraits.cpp @@ -1766,7 +1766,10 @@ static bool EvaluateBinaryTypeTrait(Sema &Self, TypeTrait BTT, // Objective-C lifetime, this is a non-trivial assignment. if (LhsT.getNonReferenceType().hasNonTrivialObjCLifetime()) return false; - + const ASTContext &Context = Self.getASTContext(); + if (Context.containsAddressDiscriminatedPointerAuth(LhsT) || + Context.containsAddressDiscriminatedPointerAuth(RhsT)) + return false; return !Result.get()->hasNonTrivialCall(Self.Context); } diff --git a/clang/test/SemaCXX/ptrauth-triviality.cpp b/clang/test/SemaCXX/ptrauth-triviality.cpp index ba8a8273d5c05..b1b334b59a59e 100644 --- a/clang/test/SemaCXX/ptrauth-triviality.cpp +++ b/clang/test/SemaCXX/ptrauth-triviality.cpp @@ -74,7 +74,7 @@ static_assert(__is_trivially_destructible(S3)); static_assert(!__is_trivially_copyable(S3)); static_assert(!__is_trivially_relocatable(S3)); // expected-warning{{deprecated}} //FIXME -static_assert(__builtin_is_cpp_trivially_relocatable(S3)); +static_assert(!__builtin_is_cpp_trivially_relocatable(S3)); static_assert(!__is_trivially_equality_comparable(S3)); @@ -84,7 +84,7 @@ static_assert(!__is_trivially_assignable(Holder<S3>, const Holder<S3>&)); static_assert(__is_trivially_destructible(Holder<S3>)); static_assert(!__is_trivially_copyable(Holder<S3>)); static_assert(!__is_trivially_relocatable(Holder<S3>)); // expected-warning{{deprecated}} -static_assert(__builtin_is_cpp_trivially_relocatable(Holder<S3>)); +static_assert(!__builtin_is_cpp_trivially_relocatable(Holder<S3>)); static_assert(!__is_trivially_equality_comparable(Holder<S3>)); struct IA S4 { @@ -207,7 +207,7 @@ template <class T> struct UnionWrapper trivially_relocatable_if_eligible { } u; }; -static_assert(test_is_trivially_relocatable_v<AddressDiscriminatedPolymorphicBase>); +static_assert(!test_is_trivially_relocatable_v<AddressDiscriminatedPolymorphicBase>); static_assert(test_is_trivially_relocatable_v<NoAddressDiscriminatedPolymorphicBase>); static_assert(inheritance_relocatability_matches_bases_v<AddressDiscriminatedPolymorphicBase, NoAddressDiscriminatedPolymorphicBase>); static_assert(inheritance_relocatability_matches_bases_v<NoAddressDiscriminatedPolymorphicBase, AddressDiscriminatedPolymorphicBase>); diff --git a/clang/test/SemaCXX/ptrauth-type-traits.cpp b/clang/test/SemaCXX/ptrauth-type-traits.cpp new file mode 100644 index 0000000000000..8b1eb6c9e7bbf --- /dev/null +++ b/clang/test/SemaCXX/ptrauth-type-traits.cpp @@ -0,0 +1,401 @@ +// RUN: %clang_cc1 -triple arm64 -std=c++26 -Wno-deprecated-builtins \ +// RUN: -fsyntax-only -verify %s +// RUN: %clang_cc1 -triple arm64-apple-darwin -fptrauth-calls -fptrauth-intrinsics \ +// RUN: -fptrauth-vtable-pointer-address-discrimination \ +// RUN: -std=c++26 -Wno-deprecated-builtins \ +// RUN: -fsyntax-only -verify %s + +// expected-no-diagnostics + +#ifdef __PTRAUTH__ + +#define NonAddressDiscriminatedVTablePtrAttr \ + [[clang::ptrauth_vtable_pointer(process_independent, no_address_discrimination, no_extra_discrimination)]] +#define AddressDiscriminatedVTablePtrAttr \ + [[clang::ptrauth_vtable_pointer(process_independent, address_discrimination, no_extra_discrimination)]] +#define ADDR_DISC_ENABLED true +#else +#define NonAddressDiscriminatedVTablePtrAttr +#define AddressDiscriminatedVTablePtrAttr +#define ADDR_DISC_ENABLED false +#define __ptrauth(...) +#endif + + +typedef int* __ptrauth(1,1,1) AddressDiscriminatedPtr; +typedef __UINT64_TYPE__ __ptrauth(1,1,1) AddressDiscriminatedInt64; +struct AddressDiscriminatedFields { + AddressDiscriminatedPtr ptr; +}; +struct RelocatableAddressDiscriminatedFields trivially_relocatable_if_eligible { + AddressDiscriminatedPtr ptr; +}; +struct AddressDiscriminatedFieldInBaseClass : AddressDiscriminatedFields { + void *newfield; +}; + +struct NonAddressDiscriminatedVTablePtrAttr NonAddressDiscriminatedVTablePtr { + virtual ~NonAddressDiscriminatedVTablePtr(); + void *i; +}; + +struct NonAddressDiscriminatedVTablePtrAttr NonAddressDiscriminatedVTablePtr2 { + virtual ~NonAddressDiscriminatedVTablePtr2(); + void *j; +}; + +struct NonAddressDiscriminatedVTablePtrAttr RelocatableNonAddressDiscriminatedVTablePtr trivially_relocatable_if_eligible { + virtual ~RelocatableNonAddressDiscriminatedVTablePtr(); + void *i; +}; + +struct NonAddressDiscriminatedVTablePtrAttr RelocatableNonAddressDiscriminatedVTablePtr2 trivially_relocatable_if_eligible { + virtual ~RelocatableNonAddressDiscriminatedVTablePtr2(); + void *j; +}; + +struct AddressDiscriminatedVTablePtrAttr AddressDiscriminatedVTablePtr { + virtual ~AddressDiscriminatedVTablePtr(); + void *k; +}; + +struct AddressDiscriminatedVTablePtrAttr RelocatableAddressDiscriminatedVTablePtr trivially_relocatable_if_eligible { + virtual ~RelocatableAddressDiscriminatedVTablePtr(); + void *k; +}; + +struct NoAddressDiscriminatedBaseClasses : NonAddressDiscriminatedVTablePtr, + NonAddressDiscriminatedVTablePtr2 { + void *l; +}; + +struct RelocatableNoAddressDiscriminatedBaseClasses trivially_relocatable_if_eligible : + NonAddressDiscriminatedVTablePtr, + NonAddressDiscriminatedVTablePtr2 { + void *l; +}; + +struct AddressDiscriminatedPrimaryBase : AddressDiscriminatedVTablePtr, + NonAddressDiscriminatedVTablePtr { + void *l; +}; +struct AddressDiscriminatedSecondaryBase : NonAddressDiscriminatedVTablePtr, + AddressDiscriminatedVTablePtr { + void *l; +}; + +struct RelocatableAddressDiscriminatedPrimaryBase : RelocatableAddressDiscriminatedVTablePtr, + RelocatableNonAddressDiscriminatedVTablePtr { + void *l; +}; +struct RelocatableAddressDiscriminatedSecondaryBase : RelocatableNonAddressDiscriminatedVTablePtr, + RelocatableAddressDiscriminatedVTablePtr { + void *l; +}; +struct EmbdeddedAddressDiscriminatedPolymorphicClass { + AddressDiscriminatedVTablePtr field; +}; +struct RelocatableEmbdeddedAddressDiscriminatedPolymorphicClass trivially_relocatable_if_eligible { + AddressDiscriminatedVTablePtr field; +}; + +static_assert( __is_pod(AddressDiscriminatedPtr) == !ADDR_DISC_ENABLED); +static_assert( __is_pod(AddressDiscriminatedInt64) == !ADDR_DISC_ENABLED); +static_assert( __is_pod(AddressDiscriminatedFields) == !ADDR_DISC_ENABLED); +static_assert( __is_pod(RelocatableAddressDiscriminatedFields) == !ADDR_DISC_ENABLED); +static_assert(!__is_pod(AddressDiscriminatedFieldInBaseClass)); +static_assert(!__is_pod(NonAddressDiscriminatedVTablePtr)); +static_assert(!__is_pod(NonAddressDiscriminatedVTablePtr2)); +static_assert(!__is_pod(RelocatableNonAddressDiscriminatedVTablePtr)); +static_assert(!__is_pod(RelocatableNonAddressDiscriminatedVTablePtr2)); +static_assert(!__is_pod(AddressDiscriminatedVTablePtr)); +static_assert(!__is_pod(RelocatableAddressDiscriminatedVTablePtr)); +static_assert(!__is_pod(NoAddressDiscriminatedBaseClasses)); +static_assert(!__is_pod(RelocatableNoAddressDiscriminatedBaseClasses)); +static_assert(!__is_pod(AddressDiscriminatedPrimaryBase)); +static_assert(!__is_pod(AddressDiscriminatedSecondaryBase)); +static_assert(!__is_pod(RelocatableAddressDiscriminatedPrimaryBase)); +static_assert(!__is_pod(RelocatableAddressDiscriminatedSecondaryBase)); +static_assert(!__is_pod(EmbdeddedAddressDiscriminatedPolymorphicClass)); +static_assert(!__is_pod(RelocatableEmbdeddedAddressDiscriminatedPolymorphicClass)); + +static_assert( __is_standard_layout(AddressDiscriminatedPtr)); +static_assert( __is_standard_layout(AddressDiscriminatedInt64)); +static_assert( __is_standard_layout(AddressDiscriminatedFields)); +static_assert( __is_standard_layout(RelocatableAddressDiscriminatedFields)); +static_assert(!__is_standard_layout(AddressDiscriminatedFieldInBaseClass)); +static_assert(!__is_standard_layout(NonAddressDiscriminatedVTablePtr)); +static_assert(!__is_standard_layout(NonAddressDiscriminatedVTablePtr2)); +static_assert(!__is_standard_layout(RelocatableNonAddressDiscriminatedVTablePtr)); +static_assert(!__is_standard_layout(RelocatableNonAddressDiscriminatedVTablePtr2)); +static_assert(!__is_standard_layout(AddressDiscriminatedVTablePtr)); +static_assert(!__is_standard_layout(RelocatableAddressDiscriminatedVTablePtr)); +static_assert(!__is_standard_layout(NoAddressDiscriminatedBaseClasses)); +static_assert(!__is_standard_layout(RelocatableNoAddressDiscriminatedBaseClasses)); +static_assert(!__is_standard_layout(AddressDiscriminatedPrimaryBase)); +static_assert(!__is_standard_layout(AddressDiscriminatedSecondaryBase)); +static_assert(!__is_standard_layout(RelocatableAddressDiscriminatedPrimaryBase)); +static_assert(!__is_standard_layout(RelocatableAddressDiscriminatedSecondaryBase)); +static_assert(!__is_standard_layout(EmbdeddedAddressDiscriminatedPolymorphicClass)); +static_assert(!__is_standard_layout(RelocatableEmbdeddedAddressDiscriminatedPolymorphicClass)); + +static_assert( __has_trivial_move_constructor(AddressDiscriminatedPtr) == !ADDR_DISC_ENABLED); +static_assert( __has_trivial_move_constructor(AddressDiscriminatedInt64) == !ADDR_DISC_ENABLED); +static_assert( __has_trivial_move_constructor(AddressDiscriminatedFields) == !ADDR_DISC_ENABLED); +static_assert( __has_trivial_move_constructor(RelocatableAddressDiscriminatedFields) == !ADDR_DISC_ENABLED); +static_assert( __has_trivial_move_constructor(AddressDiscriminatedFieldInBaseClass) == !ADDR_DISC_ENABLED); +static_assert(!__has_trivial_move_constructor(NonAddressDiscriminatedVTablePtr)); +static_assert(!__has_trivial_move_constructor(NonAddressDiscriminatedVTablePtr2)); +static_assert(!__has_trivial_move_constructor(RelocatableNonAddressDiscriminatedVTablePtr)); +static_assert(!__has_trivial_move_constructor(RelocatableNonAddressDiscriminatedVTablePtr2)); +static_assert(!__has_trivial_move_constructor(AddressDiscriminatedVTablePtr)); +static_assert(!__has_trivial_move_constructor(RelocatableAddressDiscriminatedVTablePtr)); +static_assert(!__has_trivial_move_constructor(NoAddressDiscriminatedBaseClasses)); +static_assert(!__has_trivial_move_constructor(RelocatableNoAddressDiscriminatedBaseClasses)); +static_assert(!__has_trivial_move_constructor(AddressDiscriminatedPrimaryBase)); +static_assert(!__has_trivial_move_constructor(AddressDiscriminatedSecondaryBase)); +static_assert(!__has_trivial_move_constructor(RelocatableAddressDiscriminatedPrimaryBase)); +static_assert(!__has_trivial_move_constructor(RelocatableAddressDiscriminatedSecondaryBase)); +static_assert(!__has_trivial_move_constructor(EmbdeddedAddressDiscriminatedPolymorphicClass)); +static_assert(!__has_trivial_move_constructor(RelocatableEmbdeddedAddressDiscriminatedPolymorphicClass)); + +static_assert( __has_trivial_copy(AddressDiscriminatedPtr) == !ADDR_DISC_ENABLED); +static_assert( __has_trivial_copy(AddressDiscriminatedInt64) == !ADDR_DISC_ENABLED); +static_assert( __has_trivial_copy(AddressDiscriminatedFields) == !ADDR_DISC_ENABLED); +static_assert( __has_trivial_copy(RelocatableAddressDiscriminatedFields) == !ADDR_DISC_ENABLED); +static_assert( __has_trivial_copy(AddressDiscriminatedFieldInBaseClass) == !ADDR_DISC_ENABLED); +static_assert(!__has_trivial_copy(NonAddressDiscriminatedVTablePtr)); +static_assert(!__has_trivial_copy(NonAddressDiscriminatedVTablePtr2)); +static_assert(!__has_trivial_copy(RelocatableNonAddressDiscriminatedVTablePtr)); +static_assert(!__has_trivial_copy(RelocatableNonAddressDiscriminatedVTablePtr2)); +static_assert(!__has_trivial_copy(AddressDiscriminatedVTablePtr)); +static_assert(!__has_trivial_copy(RelocatableAddressDiscriminatedVTablePtr)); +static_assert(!__has_trivial_copy(NoAddressDiscriminatedBaseClasses)); +static_assert(!__has_trivial_copy(RelocatableNoAddressDiscriminatedBaseClasses)); +static_assert(!__has_trivial_copy(AddressDiscriminatedPrimaryBase)); +static_assert(!__has_trivial_copy(AddressDiscriminatedSecondaryBase)); +static_assert(!__has_trivial_copy(RelocatableAddressDiscriminatedPrimaryBase)); +static_assert(!__has_trivial_copy(RelocatableAddressDiscriminatedSecondaryBase)); +static_assert(!__has_trivial_copy(EmbdeddedAddressDiscriminatedPolymorphicClass)); +static_assert(!__has_trivial_copy(RelocatableEmbdeddedAddressDiscriminatedPolymorphicClass)); + +static_assert( __has_trivial_assign(AddressDiscriminatedPtr) == !ADDR_DISC_ENABLED); +static_assert( __has_trivial_assign(AddressDiscriminatedInt64) == !ADDR_DISC_ENABLED); +static_assert( __has_trivial_assign(AddressDiscriminatedFields) == !ADDR_DISC_ENABLED); +static_assert( __has_trivial_assign(RelocatableAddressDiscriminatedFields) == !ADDR_DISC_ENABLED); +static_assert( __has_trivial_assign(AddressDiscriminatedFieldInBaseClass) == !ADDR_DISC_ENABLED); +static_assert(!__has_trivial_assign(NonAddressDiscriminatedVTablePtr)); +static_assert(!__has_trivial_assign(NonAddressDiscriminatedVTablePtr2)); +static_assert(!__has_trivial_assign(RelocatableNonAddressDiscriminatedVTablePtr)); +static_assert(!__has_trivial_assign(RelocatableNonAddressDiscriminatedVTablePtr2)); +static_assert(!__has_trivial_assign(AddressDiscriminatedVTablePtr)); +static_assert(!__has_trivial_assign(RelocatableAddressDiscriminatedVTablePtr)); +static_assert(!__has_trivial_assign(NoAddressDiscriminatedBaseClasses)); +static_assert(!__has_trivial_assign(RelocatableNoAddressDiscriminatedBaseClasses)); +static_assert(!__has_trivial_assign(AddressDiscriminatedPrimaryBase)); +static_assert(!__has_trivial_assign(AddressDiscriminatedSecondaryBase)); +static_assert(!__has_trivial_assign(RelocatableAddressDiscriminatedPrimaryBase)); +static_assert(!__has_trivial_assign(RelocatableAddressDiscriminatedSecondaryBase)); +static_assert(!__has_trivial_assign(EmbdeddedAddressDiscriminatedPolymorphicClass)); +static_assert(!__has_trivial_assign(RelocatableEmbdeddedAddressDiscriminatedPolymorphicClass)); + +static_assert( __has_trivial_move_assign(AddressDiscriminatedPtr) == !ADDR_DISC_ENABLED); +static_assert( __has_trivial_move_assign(AddressDiscriminatedInt64) == !ADDR_DISC_ENABLED); +static_assert( __has_trivial_move_assign(AddressDiscriminatedFields) == !ADDR_DISC_ENABLED); +static_assert( __has_trivial_move_assign(RelocatableAddressDiscriminatedFields) == !ADDR_DISC_ENABLED); +static_assert( __has_trivial_move_assign(AddressDiscriminatedFieldInBaseClass) == !ADDR_DISC_ENABLED); +static_assert(!__has_trivial_move_assign(NonAddressDiscriminatedVTablePtr)); +static_assert(!__has_trivial_move_assign(NonAddressDiscriminatedVTablePtr2)); +static_assert(!__has_trivial_move_assign(RelocatableNonAddressDiscriminatedVTablePtr)); +static_assert(!__has_trivial_move_assign(RelocatableNonAddressDiscriminatedVTablePtr2)); +static_assert(!__has_trivial_move_assign(AddressDiscriminatedVTablePtr)); +static_assert(!__has_trivial_move_assign(RelocatableAddressDiscriminatedVTablePtr)); +static_assert(!__has_trivial_move_assign(NoAddressDiscriminatedBaseClasses)); +static_assert(!__has_trivial_move_assign(RelocatableNoAddressDiscriminatedBaseClasses)); +static_assert(!__has_trivial_move_assign(AddressDiscriminatedPrimaryBase)); +static_assert(!__has_trivial_move_assign(AddressDiscriminatedSecondaryBase)); +static_assert(!__has_trivial_move_assign(RelocatableAddressDiscriminatedPrimaryBase)); +static_assert(!__has_trivial_move_assign(RelocatableAddressDiscriminatedSecondaryBase)); +static_assert(!__has_trivial_move_assign(EmbdeddedAddressDiscriminatedPolymorphicClass)); +static_assert(!__has_trivial_move_assign(RelocatableEmbdeddedAddressDiscriminatedPolymorphicClass)); + +static_assert( __is_trivial(AddressDiscriminatedPtr) == !ADDR_DISC_ENABLED); +static_assert( __is_trivial(AddressDiscriminatedInt64) == !ADDR_DISC_ENABLED); +static_assert( __is_trivial(AddressDiscriminatedFields) == !ADDR_DISC_ENABLED); +static_assert( __is_trivial(RelocatableAddressDiscriminatedFields) == !ADDR_DISC_ENABLED); +static_assert( __is_trivial(AddressDiscriminatedFieldInBaseClass) == !ADDR_DISC_ENABLED); +static_assert(!__is_trivial(NonAddressDiscriminatedVTablePtr)); +static_assert(!__is_trivial(NonAddressDiscriminatedVTablePtr2)); +static_assert(!__is_trivial(RelocatableNonAddressDiscriminatedVTablePtr)); +static_assert(!__is_trivial(RelocatableNonAddressDiscriminatedVTablePtr2)); +static_assert(!__is_trivial(AddressDiscriminatedVTablePtr)); +static_assert(!__is_trivial(RelocatableAddressDiscriminatedVTablePtr)); +static_assert(!__is_trivial(NoAddressDiscriminatedBaseClasses)); +static_assert(!__is_trivial(RelocatableNoAddressDiscriminatedBaseClasses)); +static_assert(!__is_trivial(AddressDiscriminatedPrimaryBase)); +static_assert(!__is_trivial(AddressDiscriminatedSecondaryBase)); +static_assert(!__is_trivial(RelocatableAddressDiscriminatedPrimaryBase)); +static_assert(!__is_trivial(RelocatableAddressDiscriminatedSecondaryBase)); +static_assert(!__is_trivial(EmbdeddedAddressDiscriminatedPolymorphicClass)); +static_assert(!__is_trivial(RelocatableEmbdeddedAddressDiscriminatedPolymorphicClass)); + +static_assert( __is_trivially_copyable(AddressDiscriminatedPtr) == !ADDR_DISC_ENABLED); +static_assert( __is_trivially_copyable(AddressDiscriminatedInt64) == !ADDR_DISC_ENABLED); +static_assert( __is_trivially_copyable(AddressDiscriminatedFields) == !ADDR_DISC_ENABLED); +static_assert( __is_trivially_copyable(RelocatableAddressDiscriminatedFields) == !ADDR_DISC_ENABLED); +static_assert( __is_trivially_copyable(AddressDiscriminatedFieldInBaseClass) == !ADDR_DISC_ENABLED); +static_assert(!__is_trivially_copyable(NonAddressDiscriminatedVTablePtr)); +static_assert(!__is_trivially_copyable(NonAddressDiscriminatedVTablePtr2)); +static_assert(!__is_trivially_copyable(RelocatableNonAddressDiscriminatedVTablePtr)); +static_assert(!__is_trivially_copyable(RelocatableNonAddressDiscriminatedVTablePtr2)); +static_assert(!__is_trivially_copyable(AddressDiscriminatedVTablePtr)); +static_assert(!__is_trivially_copyable(RelocatableAddressDiscriminatedVTablePtr)); +static_assert(!__is_trivially_copyable(NoAddressDiscriminatedBaseClasses)); +static_assert(!__is_trivially_copyable(RelocatableNoAddressDiscriminatedBaseClasses)); +static_assert(!__is_trivially_copyable(AddressDiscriminatedPrimaryBase)); +static_assert(!__is_trivially_copyable(AddressDiscriminatedSecondaryBase)); +static_assert(!__is_trivially_copyable(RelocatableAddressDiscriminatedPrimaryBase)); +static_assert(!__is_trivially_copyable(RelocatableAddressDiscriminatedSecondaryBase)); +static_assert(!__is_trivially_copyable(EmbdeddedAddressDiscriminatedPolymorphicClass)); +static_assert(!__is_trivially_copyable(RelocatableEmbdeddedAddressDiscriminatedPolymorphicClass)); + +static_assert( __is_trivially_equality_comparable(AddressDiscriminatedPtr) == !ADDR_DISC_ENABLED); +static_assert( __is_trivially_equality_comparable(AddressDiscriminatedInt64) == !ADDR_DISC_ENABLED); +static_assert(!__is_trivially_equality_comparable(AddressDiscriminatedFields)); +static_assert(!__is_trivially_equality_comparable(RelocatableAddressDiscriminatedFields)); +static_assert(!__is_trivially_equality_comparable(AddressDiscriminatedFieldInBaseClass)); +static_assert(!__is_trivially_equality_comparable(NonAddressDiscriminatedVTablePtr)); +static_assert(!__is_trivially_equality_comparable(NonAddressDiscriminatedVTablePtr2)); +static_assert(!__is_trivially_equality_comparable(RelocatableNonAddressDiscriminatedVTablePtr)); +static_assert(!__is_trivially_equality_comparable(RelocatableNonAddressDiscriminatedVTablePtr2)); +static_assert(!__is_trivially_equality_comparable(AddressDiscriminatedVTablePtr)); +static_assert(!__is_trivially_equality_comparable(RelocatableAddressDiscriminatedVTablePtr)); +static_assert(!__is_trivially_equality_comparable(NoAddressDiscriminatedBaseClasses)); +static_assert(!__is_trivially_equality_comparable(RelocatableNoAddressDiscriminatedBaseClasses)); +static_assert(!__is_trivially_equality_comparable(AddressDiscriminatedPrimaryBase)); +static_assert(!__is_trivially_equality_comparable(AddressDiscriminatedSecondaryBase)); +static_assert(!__is_trivially_equality_comparable(RelocatableAddressDiscriminatedPrimaryBase)); +static_assert(!__is_trivially_equality_comparable(RelocatableAddressDiscriminatedSecondaryBase)); +static_assert(!__is_trivially_equality_comparable(EmbdeddedAddressDiscriminatedPolymorphicClass)); +static_assert(!__is_trivially_equality_comparable(RelocatableEmbdeddedAddressDiscriminatedPolymorphicClass)); + +static_assert( __is_trivially_relocatable(AddressDiscriminatedPtr) == !ADDR_DISC_ENABLED); +static_assert( __is_trivially_relocatable(AddressDiscriminatedInt64) == !ADDR_DISC_ENABLED); +static_assert( __is_trivially_relocatable(AddressDiscriminatedFields) == !ADDR_DISC_ENABLED); +static_assert( __is_trivially_relocatable(RelocatableAddressDiscriminatedFields) == !ADDR_DISC_ENABLED); +static_assert( __is_trivially_relocatable(AddressDiscriminatedFieldInBaseClass) == !ADDR_DISC_ENABLED); +static_assert(!__is_trivially_relocatable(NonAddressDiscriminatedVTablePtr)); +static_assert(!__is_trivially_relocatable(NonAddressDiscriminatedVTablePtr2)); +static_assert(!__is_trivially_relocatable(RelocatableNonAddressDiscriminatedVTablePtr)); +static_assert(!__is_trivially_relocatable(RelocatableNonAddressDiscriminatedVTablePtr2)); +static_assert(!__is_trivially_relocatable(AddressDiscriminatedVTablePtr)); +static_assert(!__is_trivially_relocatable(RelocatableAddressDiscriminatedVTablePtr)); +static_assert(!__is_trivially_relocatable(NoAddressDiscriminatedBaseClasses)); +static_assert(!__is_trivially_relocatable(RelocatableNoAddressDiscriminatedBaseClasses)); +static_assert(!__is_trivially_relocatable(AddressDiscriminatedPrimaryBase)); +static_assert(!__is_trivially_relocatable(AddressDiscriminatedSecondaryBase)); +static_assert(!__is_trivially_relocatable(RelocatableAddressDiscriminatedPrimaryBase)); +static_assert(!__is_trivially_relocatable(RelocatableAddressDiscriminatedSecondaryBase)); +static_assert(!__is_trivially_relocatable(EmbdeddedAddressDiscriminatedPolymorphicClass)); +static_assert(!__is_trivially_relocatable(RelocatableEmbdeddedAddressDiscriminatedPolymorphicClass)); + +static_assert( __builtin_is_cpp_trivially_relocatable(AddressDiscriminatedPtr) == !ADDR_DISC_ENABLED); +static_assert( __builtin_is_cpp_trivially_relocatable(AddressDiscriminatedInt64) == !ADDR_DISC_ENABLED); +static_assert( __builtin_is_cpp_trivially_relocatable(AddressDiscriminatedFields) == !ADDR_DISC_ENABLED); +static_assert( __builtin_is_cpp_trivially_relocatable(RelocatableAddressDiscriminatedFields) == !ADDR_DISC_ENABLED); +static_assert( __builtin_is_cpp_trivially_relocatable(AddressDiscriminatedFieldInBaseClass) == !ADDR_DISC_ENABLED); +static_assert(!__builtin_is_cpp_trivially_relocatable(NonAddressDiscriminatedVTablePtr)); +static_assert(!__builtin_is_cpp_trivially_relocatable(NonAddressDiscriminatedVTablePtr2)); +static_assert( __builtin_is_cpp_trivially_relocatable(RelocatableNonAddressDiscriminatedVTablePtr)); +static_assert( __builtin_is_cpp_trivially_relocatable(RelocatableNonAddressDiscriminatedVTablePtr2)); +static_assert(!__builtin_is_cpp_trivially_relocatable(AddressDiscriminatedVTablePtr)); +static_assert( __builtin_is_cpp_trivially_relocatable(RelocatableAddressDiscriminatedVTablePtr) == !ADDR_DISC_ENABLED); +static_assert(!__builtin_is_cpp_trivially_relocatable(NoAddressDiscriminatedBaseClasses)); +static_assert(!__builtin_is_cpp_trivially_relocatable(RelocatableNoAddressDiscriminatedBaseClasses)); +static_assert(!__builtin_is_cpp_trivially_relocatable(AddressDiscriminatedPrimaryBase)); +static_assert(!__builtin_is_cpp_trivially_relocatable(AddressDiscriminatedSecondaryBase)); +static_assert( __builtin_is_cpp_trivially_relocatable(RelocatableAddressDiscriminatedPrimaryBase) == !ADDR_DISC_ENABLED); +static_assert( __builtin_is_cpp_trivially_relocatable(RelocatableAddressDiscriminatedSecondaryBase) == !ADDR_DISC_ENABLED); +static_assert(!__builtin_is_cpp_trivially_relocatable(EmbdeddedAddressDiscriminatedPolymorphicClass)); +static_assert(!__builtin_is_cpp_trivially_relocatable(RelocatableEmbdeddedAddressDiscriminatedPolymorphicClass)); + +static_assert( __builtin_is_replaceable(AddressDiscriminatedPtr)); +static_assert( __builtin_is_replaceable(AddressDiscriminatedInt64)); +static_assert( __builtin_is_replaceable(AddressDiscriminatedFields)); +static_assert( __builtin_is_replaceable(RelocatableAddressDiscriminatedFields)); +static_assert( __builtin_is_replaceable(AddressDiscriminatedFieldInBaseClass)); +static_assert(!__builtin_is_replaceable(NonAddressDiscriminatedVTablePtr)); +static_assert(!__builtin_is_replaceable(NonAddressDiscriminatedVTablePtr2)); +static_assert(!__builtin_is_replaceable(RelocatableNonAddressDiscriminatedVTablePtr)); +static_assert(!__builtin_is_replaceable(RelocatableNonAddressDiscriminatedVTablePtr2)); +static_assert(!__builtin_is_replaceable(AddressDiscriminatedVTablePtr)); +static_assert(!__builtin_is_replaceable(RelocatableAddressDiscriminatedVTablePtr)); +static_assert(!__builtin_is_replaceable(NoAddressDiscriminatedBaseClasses)); +static_assert(!__builtin_is_replaceable(RelocatableNoAddressDiscriminatedBaseClasses)); +static_assert(!__builtin_is_replaceable(AddressDiscriminatedPrimaryBase)); +static_assert(!__builtin_is_replaceable(AddressDiscriminatedSecondaryBase)); +static_assert(!__builtin_is_replaceable(RelocatableAddressDiscriminatedPrimaryBase)); +static_assert(!__builtin_is_replaceable(RelocatableAddressDiscriminatedSecondaryBase)); +static_assert(!__builtin_is_replaceable(EmbdeddedAddressDiscriminatedPolymorphicClass)); +static_assert(!__builtin_is_replaceable(RelocatableEmbdeddedAddressDiscriminatedPolymorphicClass)); + +static_assert( __is_bitwise_cloneable(AddressDiscriminatedPtr) == !ADDR_DISC_ENABLED); +static_assert( __is_bitwise_cloneable(AddressDiscriminatedInt64) == !ADDR_DISC_ENABLED); +static_assert( __is_bitwise_cloneable(AddressDiscriminatedFields) == !ADDR_DISC_ENABLED); +static_assert( __is_bitwise_cloneable(RelocatableAddressDiscriminatedFields) == !ADDR_DISC_ENABLED); +static_assert( __is_bitwise_cloneable(AddressDiscriminatedFieldInBaseClass) == !ADDR_DISC_ENABLED); +static_assert( __is_bitwise_cloneable(NonAddressDiscriminatedVTablePtr)); +static_assert( __is_bitwise_cloneable(NonAddressDiscriminatedVTablePtr2)); +static_assert( __is_bitwise_cloneable(RelocatableNonAddressDiscriminatedVTablePtr)); +static_assert( __is_bitwise_cloneable(RelocatableNonAddressDiscriminatedVTablePtr2)); +static_assert( __is_bitwise_cloneable(AddressDiscriminatedVTablePtr) == !ADDR_DISC_ENABLED); +static_assert( __is_bitwise_cloneable(RelocatableAddressDiscriminatedVTablePtr) == !ADDR_DISC_ENABLED); +static_assert( __is_bitwise_cloneable(NoAddressDiscriminatedBaseClasses)); +static_assert( __is_bitwise_cloneable(RelocatableNoAddressDiscriminatedBaseClasses)); +static_assert( __is_bitwise_cloneable(AddressDiscriminatedPrimaryBase) == !ADDR_DISC_ENABLED); +static_assert( __is_bitwise_cloneable(AddressDiscriminatedSecondaryBase) == !ADDR_DISC_ENABLED); +static_assert( __is_bitwise_cloneable(RelocatableAddressDiscriminatedPrimaryBase) == !ADDR_DISC_ENABLED); +static_assert( __is_bitwise_cloneable(RelocatableAddressDiscriminatedSecondaryBase) == !ADDR_DISC_ENABLED); +static_assert( __is_bitwise_cloneable(EmbdeddedAddressDiscriminatedPolymorphicClass) == !ADDR_DISC_ENABLED); +static_assert( __is_bitwise_cloneable(RelocatableEmbdeddedAddressDiscriminatedPolymorphicClass) == !ADDR_DISC_ENABLED); + +static_assert( __has_unique_object_representations(AddressDiscriminatedPtr) == !ADDR_DISC_ENABLED); +static_assert( __has_unique_object_representations(AddressDiscriminatedInt64) == !ADDR_DISC_ENABLED); +static_assert( __has_unique_object_representations(AddressDiscriminatedFields) == !ADDR_DISC_ENABLED); +static_assert( __has_unique_object_representations(RelocatableAddressDiscriminatedFields) == !ADDR_DISC_ENABLED); +static_assert( __has_unique_object_representations(AddressDiscriminatedFieldInBaseClass) == !ADDR_DISC_ENABLED); +static_assert(!__has_unique_object_representations(NonAddressDiscriminatedVTablePtr)); +static_assert(!__has_unique_object_representations(NonAddressDiscriminatedVTablePtr2)); +static_assert(!__has_unique_object_representations(RelocatableNonAddressDiscriminatedVTablePtr)); +static_assert(!__has_unique_object_representations(RelocatableNonAddressDiscriminatedVTablePtr2)); +static_assert(!__has_unique_object_representations(AddressDiscriminatedVTablePtr)); +static_assert(!__has_unique_object_representations(RelocatableAddressDiscriminatedVTablePtr)); +static_assert(!__has_unique_object_representations(NoAddressDiscriminatedBaseClasses)); +static_assert(!__has_unique_object_representations(RelocatableNoAddressDiscriminatedBaseClasses)); +static_assert(!__has_unique_object_representations(AddressDiscriminatedPrimaryBase)); +static_assert(!__has_unique_object_representations(AddressDiscriminatedSecondaryBase)); +static_assert(!__has_unique_object_representations(RelocatableAddressDiscriminatedPrimaryBase)); +static_assert(!__has_unique_object_representations(RelocatableAddressDiscriminatedSecondaryBase)); +static_assert(!__has_unique_object_representations(EmbdeddedAddressDiscriminatedPolymorphicClass)); +static_assert(!__has_unique_object_representations(RelocatableEmbdeddedAddressDiscriminatedPolymorphicClass)); + +#define ASSIGNABLE_WRAPPER(Type) __is_trivially_assignable(Type&, Type) +static_assert( ASSIGNABLE_WRAPPER(AddressDiscriminatedPtr) == !ADDR_DISC_ENABLED); +static_assert( ASSIGNABLE_WRAPPER(AddressDiscriminatedInt64) == !ADDR_DISC_ENABLED); +static_assert( ASSIGNABLE_WRAPPER(AddressDiscriminatedFields) == !ADDR_DISC_ENABLED); +static_assert( ASSIGNABLE_WRAPPER(RelocatableAddressDiscriminatedFields) == !ADDR_DISC_ENABLED); +static_assert( ASSIGNABLE_WRAPPER(AddressDiscriminatedFieldInBaseClass) == !ADDR_DISC_ENABLED); +static_assert(!ASSIGNABLE_WRAPPER(NonAddressDiscriminatedVTablePtr)); +static_assert(!ASSIGNABLE_WRAPPER(NonAddressDiscriminatedVTablePtr2)); +static_assert(!ASSIGNABLE_WRAPPER(RelocatableNonAddressDiscriminatedVTablePtr)); +static_assert(!ASSIGNABLE_WRAPPER(RelocatableNonAddressDiscriminatedVTablePtr2)); +static_assert(!ASSIGNABLE_WRAPPER(AddressDiscriminatedVTablePtr)); +static_assert(!ASSIGNABLE_WRAPPER(RelocatableAddressDiscriminatedVTablePtr)); +static_assert(!ASSIGNABLE_WRAPPER(NoAddressDiscriminatedBaseClasses)); +static_assert(!ASSIGNABLE_WRAPPER(RelocatableNoAddressDiscriminatedBaseClasses)); +static_assert(!ASSIGNABLE_WRAPPER(AddressDiscriminatedPrimaryBase)); +static_assert(!ASSIGNABLE_WRAPPER(AddressDiscriminatedSecondaryBase)); +static_assert(!ASSIGNABLE_WRAPPER(RelocatableAddressDiscriminatedPrimaryBase)); +static_assert(!ASSIGNABLE_WRAPPER(RelocatableAddressDiscriminatedSecondaryBase)); +static_assert(!ASSIGNABLE_WRAPPER(EmbdeddedAddressDiscriminatedPolymorphicClass)); +static_assert(!ASSIGNABLE_WRAPPER(RelocatableEmbdeddedAddressDiscriminatedPolymorphicClass)); diff --git a/clang/test/SemaCXX/trivially-relocatable-ptrauth.cpp b/clang/test/SemaCXX/trivially-relocatable-ptrauth.cpp index b38499a634fcf..4a907b8c1cb5e 100644 --- a/clang/test/SemaCXX/trivially-relocatable-ptrauth.cpp +++ b/clang/test/SemaCXX/trivially-relocatable-ptrauth.cpp @@ -57,7 +57,7 @@ struct Foo : Polymorphic { }; -static_assert(__builtin_is_cpp_trivially_relocatable(Polymorphic)); +static_assert(!__builtin_is_cpp_trivially_relocatable(Polymorphic)); struct [[clang::ptrauth_vtable_pointer(process_independent,no_address_discrimination,no_extra_discrimination)]] NonAddressDiscriminatedPolymorphic trivially_relocatable_if_eligible { virtual ~NonAddressDiscriminatedPolymorphic(); @@ -70,7 +70,7 @@ struct PolymorphicMembers { Polymorphic field; }; -static_assert(__builtin_is_cpp_trivially_relocatable(PolymorphicMembers)); +static_assert(!__builtin_is_cpp_trivially_relocatable(PolymorphicMembers)); struct UnionOfPolymorphic { union trivially_relocatable_if_eligible { _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits