https://github.com/cor3ntin created https://github.com/llvm/llvm-project/pull/174344
In Kona, WG21 decided to revert trivial relocation (P2786). Keep the notion of relocatability (used in the wild and likely to come back), but remove the keyword which is no longer conforming >From 4a9679de24fa6ef2bfa70b77e19fab8108f1f9ea Mon Sep 17 00:00:00 2001 From: Corentin Jabot <[email protected]> Date: Sun, 4 Jan 2026 20:36:45 +0100 Subject: [PATCH] [Clang] expunge `trivially_relocate_if_eligible` In Kona, WG21 decided to revert trivial relocation (P2786). Keep the notion of relocatability (used in the wild and likely to come back), but remove the keyword which is no longer conforming --- clang/docs/ReleaseNotes.rst | 8 +- clang/include/clang/Basic/Attr.td | 8 - .../clang/Basic/DiagnosticParseKinds.td | 13 -- clang/include/clang/Parse/Parser.h | 5 - clang/include/clang/Sema/Sema.h | 1 - clang/lib/Parse/ParseDeclCXX.cpp | 51 +----- clang/lib/Parse/Parser.cpp | 1 - clang/lib/Sema/SemaDecl.cpp | 5 - clang/lib/Sema/SemaTypeTraits.cpp | 6 - .../cxx2c-trivially-relocatable.cpp | 4 +- .../Parser/cxx2c-trivially-relocatable.cpp | 31 ---- .../SemaCXX/cxx2c-trivially-relocatable.cpp | 123 --------------- clang/test/SemaCXX/ptrauth-triviality.cpp | 24 --- clang/test/SemaCXX/ptrauth-type-traits.cpp | 148 ------------------ .../SemaCXX/trivially-relocatable-ptrauth.cpp | 43 ----- .../SemaCXX/type-traits-unsatisfied-diags.cpp | 21 --- 16 files changed, 13 insertions(+), 479 deletions(-) delete mode 100644 clang/test/Parser/cxx2c-trivially-relocatable.cpp diff --git a/clang/docs/ReleaseNotes.rst b/clang/docs/ReleaseNotes.rst index 69497505bbb30..54c311914468a 100644 --- a/clang/docs/ReleaseNotes.rst +++ b/clang/docs/ReleaseNotes.rst @@ -130,6 +130,12 @@ C++ Specific Potentially Breaking Changes - ``VarTemplateSpecializationDecl::getTemplateArgsAsWritten()`` method now returns ``nullptr`` for implicitly instantiated declarations. +- ``__builtin_is_replaceable``, ``trivially_relocable_if_eligible``, and ``replaceable_if_eligible`` + have been removed as `P2786 <https://wg21.link/P2786>`_ have been removed from C++2c. + ``__builtin_is_cpp_trivially_relocatable`` and ``__builtin_trivially_relocate`` have been kept back, + with the `P2786 <https://wg21.link/P2786>`_ semantics, except there is no longer a way + to explicitly specify a type is relocatable. + ABI Changes in This Version --------------------------- - Fix AArch64 argument passing for C++ empty classes with large explicitly specified alignment. @@ -197,7 +203,7 @@ C++2c Feature Support ^^^^^^^^^^^^^^^^^^^^^ - Started the implementation of `P2686R5 <https://wg21.link/P2686R5>`_ Constexpr structured bindings. - At this timem, references to constexpr and decomposition of *tuple-like* types are not supported + At this time, references to constexpr and decomposition of *tuple-like* types are not supported (only arrays and aggregates are). C++23 Feature Support diff --git a/clang/include/clang/Basic/Attr.td b/clang/include/clang/Basic/Attr.td index b017906a8d690..efa64dbe4b51e 100644 --- a/clang/include/clang/Basic/Attr.td +++ b/clang/include/clang/Basic/Attr.td @@ -1944,14 +1944,6 @@ def Final : InheritableAttr { let Documentation = [InternalOnly]; } -def TriviallyRelocatable : InheritableAttr { - let Spellings = [CustomKeyword<"trivially_relocatable_if_eligible">]; - let SemaHandler = 0; - // Omitted from docs, since this is language syntax, not an attribute, as far - // as users are concerned. - let Documentation = [InternalOnly]; -} - def MinSize : InheritableAttr { let Spellings = [Clang<"minsize">]; let Subjects = SubjectList<[Function, ObjCMethod], ErrorDiag>; diff --git a/clang/include/clang/Basic/DiagnosticParseKinds.td b/clang/include/clang/Basic/DiagnosticParseKinds.td index 662fe16d965b6..f4cdc827239f5 100644 --- a/clang/include/clang/Basic/DiagnosticParseKinds.td +++ b/clang/include/clang/Basic/DiagnosticParseKinds.td @@ -1079,25 +1079,12 @@ def ext_ms_abstract_keyword : ExtWarn< "'abstract' keyword is a Microsoft extension">, InGroup<MicrosoftAbstract>; -def ext_relocatable_keyword - : ExtWarn< - "'trivially_relocatable_if_eligible' keyword is a C++2c extension">, - InGroup<CXX26>; -def warn_relocatable_keyword - : Warning<"'trivially_relocatable_if_eligible' keyword is incompatible " - "with standards before C++2c">, - DefaultIgnore, - InGroup<CXXPre26Compat>; - def err_access_specifier_interface : Error< "interface types cannot specify '%select{private|protected}0' access">; def err_duplicate_class_virt_specifier : Error< "class already marked '%0'">; -def err_duplicate_class_relocation_specifier - : Error<"class already marked 'trivially_relocatable_if_eligible'">; - def err_duplicate_virt_specifier : Error< "class member already marked '%0'">; diff --git a/clang/include/clang/Parse/Parser.h b/clang/include/clang/Parse/Parser.h index e03d7994e2fa5..9d21c507959f1 100644 --- a/clang/include/clang/Parse/Parser.h +++ b/clang/include/clang/Parse/Parser.h @@ -2834,7 +2834,6 @@ class Parser : public CodeCompletionHandler { mutable IdentifierInfo *Ident_final; mutable IdentifierInfo *Ident_GNU_final; mutable IdentifierInfo *Ident_override; - mutable IdentifierInfo *Ident_trivially_relocatable_if_eligible; /// Representation of a class that has been parsed, including /// any member function declarations or definitions that need to be @@ -3598,10 +3597,6 @@ class Parser : public CodeCompletionHandler { /// \endverbatim AccessSpecifier getAccessSpecifierIfPresent() const; - bool isCXX2CTriviallyRelocatableKeyword(Token Tok) const; - bool isCXX2CTriviallyRelocatableKeyword() const; - void ParseCXX2CTriviallyRelocatableSpecifier(SourceLocation &TRS); - /// 'final', a C++26 'trivially_relocatable_if_eligible', /// or Microsoft 'sealed' or 'abstract' contextual /// keyword. diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h index c9ad6860dc625..b0fc2034eb336 100644 --- a/clang/include/clang/Sema/Sema.h +++ b/clang/include/clang/Sema/Sema.h @@ -4365,7 +4365,6 @@ class Sema final : public SemaBase { SourceLocation FinalLoc, bool IsFinalSpelledSealed, bool IsAbstract, - SourceLocation TriviallyRelocatable, SourceLocation LBraceLoc); /// ActOnTagFinishDefinition - Invoked once we have finished parsing diff --git a/clang/lib/Parse/ParseDeclCXX.cpp b/clang/lib/Parse/ParseDeclCXX.cpp index 6b67a2aa99cc7..af0361c10a011 100644 --- a/clang/lib/Parse/ParseDeclCXX.cpp +++ b/clang/lib/Parse/ParseDeclCXX.cpp @@ -1871,8 +1871,7 @@ void Parser::ParseClassSpecifier(tok::TokenKind TagTokKind, (NextToken().is(tok::l_square) || NextToken().is(tok::kw_alignas) || NextToken().isRegularKeywordAttribute() || - isCXX11VirtSpecifier(NextToken()) != VirtSpecifiers::VS_None || - isCXX2CTriviallyRelocatableKeyword())) { + isCXX11VirtSpecifier(NextToken()) != VirtSpecifiers::VS_None)) { // We can't tell if this is a definition or reference // until we skipped the 'final' and C++11 attribute specifiers. TentativeParsingAction PA(*this); @@ -2478,34 +2477,7 @@ bool Parser::isCXX11FinalKeyword() const { Specifier == VirtSpecifiers::VS_Sealed; } -bool Parser::isCXX2CTriviallyRelocatableKeyword(Token Tok) const { - if (!getLangOpts().CPlusPlus || Tok.isNot(tok::identifier)) - return false; - if (!Ident_trivially_relocatable_if_eligible) - Ident_trivially_relocatable_if_eligible = - &PP.getIdentifierTable().get("trivially_relocatable_if_eligible"); - IdentifierInfo *II = Tok.getIdentifierInfo(); - return II == Ident_trivially_relocatable_if_eligible; -} - -bool Parser::isCXX2CTriviallyRelocatableKeyword() const { - return isCXX2CTriviallyRelocatableKeyword(Tok); -} - -void Parser::ParseCXX2CTriviallyRelocatableSpecifier(SourceLocation &TRS) { - assert(isCXX2CTriviallyRelocatableKeyword() && - "expected a trivially_relocatable specifier"); - - Diag(Tok.getLocation(), getLangOpts().CPlusPlus26 - ? diag::warn_relocatable_keyword - : diag::ext_relocatable_keyword); - - TRS = ConsumeToken(); -} - bool Parser::isClassCompatibleKeyword(Token Tok) const { - if (isCXX2CTriviallyRelocatableKeyword(Tok)) - return true; VirtSpecifiers::Specifier Specifier = isCXX11VirtSpecifier(Tok); return Specifier == VirtSpecifiers::VS_Final || Specifier == VirtSpecifiers::VS_GNU_Final || @@ -3559,24 +3531,12 @@ void Parser::ParseCXXMemberSpecification(SourceLocation RecordLoc, SourceLocation AbstractLoc; bool IsFinalSpelledSealed = false; bool IsAbstract = false; - SourceLocation TriviallyRelocatable; // Parse the optional 'final' keyword. if (getLangOpts().CPlusPlus && Tok.is(tok::identifier)) { while (true) { VirtSpecifiers::Specifier Specifier = isCXX11VirtSpecifier(Tok); if (Specifier == VirtSpecifiers::VS_None) { - if (isCXX2CTriviallyRelocatableKeyword(Tok)) { - if (TriviallyRelocatable.isValid()) { - auto Skipped = Tok; - ConsumeToken(); - Diag(Skipped, diag::err_duplicate_class_relocation_specifier) - << TriviallyRelocatable; - } else { - ParseCXX2CTriviallyRelocatableSpecifier(TriviallyRelocatable); - } - continue; - } break; } if (isCXX11FinalKeyword()) { @@ -3614,8 +3574,7 @@ void Parser::ParseCXXMemberSpecification(SourceLocation RecordLoc, else if (Specifier == VirtSpecifiers::VS_GNU_Final) Diag(FinalLoc, diag::ext_warn_gnu_final); } - assert((FinalLoc.isValid() || AbstractLoc.isValid() || - TriviallyRelocatable.isValid()) && + assert((FinalLoc.isValid() || AbstractLoc.isValid()) && "not a class definition"); // Parse any C++11 attributes after 'final' keyword. @@ -3688,9 +3647,9 @@ void Parser::ParseCXXMemberSpecification(SourceLocation RecordLoc, T.consumeOpen(); if (TagDecl) - Actions.ActOnStartCXXMemberDeclarations( - getCurScope(), TagDecl, FinalLoc, IsFinalSpelledSealed, IsAbstract, - TriviallyRelocatable, T.getOpenLocation()); + Actions.ActOnStartCXXMemberDeclarations(getCurScope(), TagDecl, FinalLoc, + IsFinalSpelledSealed, IsAbstract, + T.getOpenLocation()); // C++ 11p3: Members of a class defined with the keyword class are private // by default. Members of a class defined with the keywords struct or union diff --git a/clang/lib/Parse/Parser.cpp b/clang/lib/Parse/Parser.cpp index 1f32bf8009ded..8f6f023dd79d0 100644 --- a/clang/lib/Parse/Parser.cpp +++ b/clang/lib/Parse/Parser.cpp @@ -514,7 +514,6 @@ void Parser::Initialize() { Ident_sealed = nullptr; Ident_abstract = nullptr; Ident_override = nullptr; - Ident_trivially_relocatable_if_eligible = nullptr; Ident_GNU_final = nullptr; Ident_import = nullptr; Ident_module = nullptr; diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp index b943ea2f85030..d55b8afc1b7f7 100644 --- a/clang/lib/Sema/SemaDecl.cpp +++ b/clang/lib/Sema/SemaDecl.cpp @@ -18806,7 +18806,6 @@ void Sema::ActOnStartCXXMemberDeclarations(Scope *S, Decl *TagD, SourceLocation FinalLoc, bool IsFinalSpelledSealed, bool IsAbstract, - SourceLocation TriviallyRelocatable, SourceLocation LBraceLoc) { AdjustDeclIfTemplate(TagD); CXXRecordDecl *Record = cast<CXXRecordDecl>(TagD); @@ -18826,10 +18825,6 @@ void Sema::ActOnStartCXXMemberDeclarations(Scope *S, Decl *TagD, : FinalAttr::Keyword_final)); } - if (TriviallyRelocatable.isValid()) - Record->addAttr( - TriviallyRelocatableAttr::Create(Context, TriviallyRelocatable)); - // C++ [class]p2: // [...] The class-name is also inserted into the scope of the // class itself; this is known as the injected-class-name. For diff --git a/clang/lib/Sema/SemaTypeTraits.cpp b/clang/lib/Sema/SemaTypeTraits.cpp index f9d223a67e393..be2c8853d6433 100644 --- a/clang/lib/Sema/SemaTypeTraits.cpp +++ b/clang/lib/Sema/SemaTypeTraits.cpp @@ -243,10 +243,6 @@ Sema::CheckCXX2CRelocatable(const CXXRecordDecl *D) { if (!IsEligibleForTrivialRelocation(*this, D)) return false; - // has the trivially_relocatable_if_eligible class-property-specifier, - if (D->hasAttr<TriviallyRelocatableAttr>()) - return true; - // is a union with no user-declared special member functions, or if (IsUnion()) return true; @@ -2082,8 +2078,6 @@ static void DiagnoseNonTriviallyRelocatableReason(Sema &SemaRef, << diag::TraitNotSatisfiedReason::DeletedDtr << /*Deleted*/ 0 << D->getDestructor()->getSourceRange(); - if (D->hasAttr<TriviallyRelocatableAttr>()) - return; DiagnoseNonDefaultMovable(SemaRef, Loc, D); } diff --git a/clang/test/CodeGenCXX/cxx2c-trivially-relocatable.cpp b/clang/test/CodeGenCXX/cxx2c-trivially-relocatable.cpp index 465e539d363e8..c772c82ae0b4f 100644 --- a/clang/test/CodeGenCXX/cxx2c-trivially-relocatable.cpp +++ b/clang/test/CodeGenCXX/cxx2c-trivially-relocatable.cpp @@ -2,9 +2,7 @@ typedef __SIZE_TYPE__ size_t; -struct S trivially_relocatable_if_eligible { - S(const S&); - ~S(); +struct S { int a; int b; }; diff --git a/clang/test/Parser/cxx2c-trivially-relocatable.cpp b/clang/test/Parser/cxx2c-trivially-relocatable.cpp deleted file mode 100644 index e47fe2a32972c..0000000000000 --- a/clang/test/Parser/cxx2c-trivially-relocatable.cpp +++ /dev/null @@ -1,31 +0,0 @@ -// RUN: %clang_cc1 -std=c++03 -verify=expected,cxx11,cxx03 -fsyntax-only %s -// RUN: %clang_cc1 -std=c++11 -verify=expected,cxx11 -fsyntax-only %s -// RUN: %clang_cc1 -std=c++2c -verify=expected -fsyntax-only %s - - -class A trivially_relocatable_if_eligible {}; -// cxx11-warning@-1 {{'trivially_relocatable_if_eligible' keyword is a C++2c extension}} -class E final trivially_relocatable_if_eligible {}; -// cxx11-warning@-1 {{'trivially_relocatable_if_eligible' keyword is a C++2c extension}} -// cxx03-warning@-2 {{'final' keyword is a C++11 extension}} -class G trivially_relocatable_if_eligible final{}; -// cxx11-warning@-1 {{'trivially_relocatable_if_eligible' keyword is a C++2c extension}} -// cxx03-warning@-2 {{'final' keyword is a C++11 extension}} -class I trivially_relocatable_if_eligible trivially_relocatable_if_eligible final {}; -// expected-error@-1 {{class already marked 'trivially_relocatable_if_eligible'}} -// cxx11-warning@-2 {{'trivially_relocatable_if_eligible' keyword is a C++2c extension}} -// cxx03-warning@-3 {{'final' keyword is a C++11 extension}} -class trivially_relocatable_if_eligible trivially_relocatable_if_eligible {}; -// cxx11-warning@-1 {{'trivially_relocatable_if_eligible' keyword is a C++2c extension}} -class L trivially_relocatable_if_eligible final {}; -// cxx11-warning@-1 {{'trivially_relocatable_if_eligible' keyword is a C++2c extension}} -// cxx03-warning@-2 {{'final' keyword is a C++11 extension}} -class M final trivially_relocatable_if_eligible {}; -// cxx11-warning@-1 {{'trivially_relocatable_if_eligible' keyword is a C++2c extension}} -// cxx03-warning@-2 {{'final' keyword is a C++11 extension}} -class N final trivially_relocatable_if_eligible {}; -// cxx11-warning@-1 {{'trivially_relocatable_if_eligible' keyword is a C++2c extension}} -// cxx03-warning@-2 {{'final' keyword is a C++11 extension}} -class O trivially_relocatable_if_eligible final {}; -// cxx11-warning@-1 {{'trivially_relocatable_if_eligible' keyword is a C++2c extension}} -// cxx03-warning@-2 {{'final' keyword is a C++11 extension}} diff --git a/clang/test/SemaCXX/cxx2c-trivially-relocatable.cpp b/clang/test/SemaCXX/cxx2c-trivially-relocatable.cpp index 1fdce9cf2ec0b..deaa3d1057d3f 100644 --- a/clang/test/SemaCXX/cxx2c-trivially-relocatable.cpp +++ b/clang/test/SemaCXX/cxx2c-trivially-relocatable.cpp @@ -8,59 +8,6 @@ struct NonRelocatable { }; static NonRelocatable NonRelocatable_g; -class A trivially_relocatable_if_eligible {}; -static_assert(__builtin_is_cpp_trivially_relocatable(A)); - - -class B trivially_relocatable_if_eligible : Trivial{}; -static_assert(__builtin_is_cpp_trivially_relocatable(B)); - -class C trivially_relocatable_if_eligible { - int a; - void* b; - int c[3]; - Trivial d[3]; - NonRelocatable& e = NonRelocatable_g; -}; -static_assert(__builtin_is_cpp_trivially_relocatable(C)); - - -class D trivially_relocatable_if_eligible : Trivial {}; -static_assert(__builtin_is_cpp_trivially_relocatable(D)); - - -class E trivially_relocatable_if_eligible : virtual Trivial {}; -static_assert(!__builtin_is_cpp_trivially_relocatable(E)); - - -class F trivially_relocatable_if_eligible : NonRelocatable {}; -static_assert(!__builtin_is_cpp_trivially_relocatable(F)); - -class G trivially_relocatable_if_eligible { - G(G&&); -}; -static_assert(__builtin_is_cpp_trivially_relocatable(G)); - -class H trivially_relocatable_if_eligible { - ~H(); -}; -static_assert(__builtin_is_cpp_trivially_relocatable(H)); - -class I trivially_relocatable_if_eligible { - NonRelocatable a; - NonRelocatable b[1]; - const NonRelocatable c; - const NonRelocatable d[1]; -}; -static_assert(!__builtin_is_cpp_trivially_relocatable(I)); - - -class J trivially_relocatable_if_eligible: virtual Trivial, NonRelocatable { - NonRelocatable a; -}; -static_assert(!__builtin_is_cpp_trivially_relocatable(J)); - - struct Incomplete; // expected-note {{forward declaration of 'Incomplete'}} static_assert(__builtin_is_cpp_trivially_relocatable(Incomplete)); // expected-error {{incomplete type 'Incomplete' used in type trait expression}} static_assert(__builtin_is_cpp_trivially_relocatable(int)); @@ -76,11 +23,6 @@ struct WithConst { }; static_assert(!__builtin_is_cpp_trivially_relocatable(WithConst)); -struct WithConstExplicit trivially_relocatable_if_eligible { - const int i; -}; -static_assert(__builtin_is_cpp_trivially_relocatable(WithConstExplicit)); - struct UserDtr { ~UserDtr(); }; @@ -130,11 +72,6 @@ static_assert(__builtin_is_cpp_trivially_relocatable(UserMoveAssignDefault)); static_assert(__builtin_is_cpp_trivially_relocatable(UserCopyDefault)); static_assert(!__builtin_is_cpp_trivially_relocatable(UserDeletedMove)); -template <typename T> -class TestDependentErrors trivially_relocatable_if_eligible : T {}; -TestDependentErrors<Trivial> Ok; -TestDependentErrors<NonRelocatable> Err; - struct DeletedMove { DeletedMove(DeletedMove&&) = delete; }; @@ -155,13 +92,6 @@ static_assert(!__builtin_is_cpp_trivially_relocatable(DeletedMoveAssign)); static_assert(!__builtin_is_cpp_trivially_relocatable(DeletedDtr)); -union U { - G g; -}; -static_assert(!__is_trivially_copyable(U)); -static_assert(__builtin_is_cpp_trivially_relocatable(U)); - - template <typename T> struct S { T t; @@ -175,21 +105,6 @@ static_assert(__builtin_is_cpp_trivially_relocatable(S<int[2]>)); static_assert(!__builtin_is_cpp_trivially_relocatable(S<const int[2]>)); static_assert(__builtin_is_cpp_trivially_relocatable(S<int[]>)); - -template <typename T> -struct SExplicit trivially_relocatable_if_eligible{ - T t; -}; -static_assert(__builtin_is_cpp_trivially_relocatable(SExplicit<int>)); -static_assert(__builtin_is_cpp_trivially_relocatable(SExplicit<volatile int>)); -static_assert(__builtin_is_cpp_trivially_relocatable(SExplicit<const int>)); -static_assert(__builtin_is_cpp_trivially_relocatable(SExplicit<const int&>)); -static_assert(__builtin_is_cpp_trivially_relocatable(SExplicit<int&>)); -static_assert(__builtin_is_cpp_trivially_relocatable(SExplicit<int[2]>)); -static_assert(__builtin_is_cpp_trivially_relocatable(SExplicit<const int[2]>)); -static_assert(__builtin_is_cpp_trivially_relocatable(SExplicit<int[]>)); - - namespace replaceable { struct DeletedMove { @@ -252,15 +167,6 @@ static_assert(!__builtin_is_cpp_trivially_relocatable(int[n])); // expected-note@-2 {{read of non-const variable 'n' is not allowed in a constant expression}} -struct S42 trivially_relocatable_if_eligible { - S42(S42&&); - S42& operator=(S42&&) = default; -}; -struct S43 trivially_relocatable_if_eligible { - S43(S43&&) = default; - S43& operator=(S43&&); -}; - struct Copyable1Explicit { Copyable1Explicit(Copyable1Explicit const &) = default; @@ -348,32 +254,3 @@ C& C::operator=(const C&) = default; static_assert (!__builtin_is_cpp_trivially_relocatable(C)); } - -namespace GH144232 { - -struct E trivially_relocatable_if_eligible { - E (E &&); - E &operator= (E &&) = default; -}; - -struct F trivially_relocatable_if_eligible { - F (F &&) = default; - F &operator= (F &&); -}; - -struct G trivially_relocatable_if_eligible { G (G const &) = default; }; - -struct I trivially_relocatable_if_eligible { I &operator= (const I &) = default; }; - -struct J trivially_relocatable_if_eligible { J (J const &); }; -struct K trivially_relocatable_if_eligible { K (K const &); }; - - -static_assert (__builtin_is_cpp_trivially_relocatable(E)); -static_assert (__builtin_is_cpp_trivially_relocatable(F)); -static_assert (__builtin_is_cpp_trivially_relocatable(G)); -static_assert (__builtin_is_cpp_trivially_relocatable(I)); -static_assert (__builtin_is_cpp_trivially_relocatable(J)); -static_assert (__builtin_is_cpp_trivially_relocatable(K)); - -} diff --git a/clang/test/SemaCXX/ptrauth-triviality.cpp b/clang/test/SemaCXX/ptrauth-triviality.cpp index b1b334b59a59e..900c5293bcd3b 100644 --- a/clang/test/SemaCXX/ptrauth-triviality.cpp +++ b/clang/test/SemaCXX/ptrauth-triviality.cpp @@ -192,27 +192,3 @@ template <class... Types> static const bool inheritance_relocatability_matches_b static_assert(multiple_inheritance_is_relocatable<S4, S5> == multiple_inheritance_is_relocatable<S5, S4>); static_assert(inheritance_relocatability_matches_bases_v<S4, S5>); static_assert(inheritance_relocatability_matches_bases_v<S5, S4>); - -struct AA AddressDiscriminatedPolymorphicBase trivially_relocatable_if_eligible { - virtual void foo(); -}; - -struct IA NoAddressDiscriminatedPolymorphicBase trivially_relocatable_if_eligible { - virtual void bar(); -}; - -template <class T> struct UnionWrapper trivially_relocatable_if_eligible { - union U { - T field1; - } u; -}; - -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>); - -static_assert(!test_is_trivially_relocatable_v<UnionWrapper<AddressDiscriminatedPolymorphicBase>>); -static_assert(test_is_trivially_relocatable_v<UnionWrapper<NoAddressDiscriminatedPolymorphicBase>>); -static_assert(!test_is_trivially_relocatable_v<UnionWrapper<MultipleInheriter<NoAddressDiscriminatedPolymorphicBase, AddressDiscriminatedPolymorphicBase>>>); -static_assert(!test_is_trivially_relocatable_v<UnionWrapper<MultipleInheriter<AddressDiscriminatedPolymorphicBase, NoAddressDiscriminatedPolymorphicBase>>>); diff --git a/clang/test/SemaCXX/ptrauth-type-traits.cpp b/clang/test/SemaCXX/ptrauth-type-traits.cpp index be4e17aa81ceb..2776ca809058a 100644 --- a/clang/test/SemaCXX/ptrauth-type-traits.cpp +++ b/clang/test/SemaCXX/ptrauth-type-traits.cpp @@ -28,9 +28,6 @@ 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; }; @@ -45,37 +42,15 @@ struct NonAddressDiscriminatedVTablePtrAttr 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; @@ -85,301 +60,178 @@ struct AddressDiscriminatedSecondaryBase : NonAddressDiscriminatedVTablePtr, 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( __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)); namespace GH159505 { class A { diff --git a/clang/test/SemaCXX/trivially-relocatable-ptrauth.cpp b/clang/test/SemaCXX/trivially-relocatable-ptrauth.cpp index 4a907b8c1cb5e..02deac3e8c96c 100644 --- a/clang/test/SemaCXX/trivially-relocatable-ptrauth.cpp +++ b/clang/test/SemaCXX/trivially-relocatable-ptrauth.cpp @@ -47,49 +47,6 @@ struct UnionOfPtrauth { static_assert(!__builtin_is_cpp_trivially_relocatable(UnionOfPtrauth)); -struct [[clang::ptrauth_vtable_pointer(process_independent,address_discrimination,no_extra_discrimination)]] Polymorphic trivially_relocatable_if_eligible { - virtual ~Polymorphic(); -}; - -struct Foo : Polymorphic { - Foo(const Foo&); - ~Foo(); -}; - - -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(); -}; - -static_assert(__builtin_is_cpp_trivially_relocatable(NonAddressDiscriminatedPolymorphic)); - - -struct PolymorphicMembers { - Polymorphic field; -}; - -static_assert(!__builtin_is_cpp_trivially_relocatable(PolymorphicMembers)); - -struct UnionOfPolymorphic { - union trivially_relocatable_if_eligible { - Polymorphic p; - int i; - } u; -}; - -static_assert(!__builtin_is_cpp_trivially_relocatable(UnionOfPolymorphic)); - - -struct UnionOfNonAddressDiscriminatedPolymorphic { - union trivially_relocatable_if_eligible { - NonAddressDiscriminatedPolymorphic p; - int i; - } u; -}; -static_assert(!__builtin_is_cpp_trivially_relocatable(UnionOfNonAddressDiscriminatedPolymorphic)); - struct UnionOfNonAddressDiscriminatedPtrauth { union { NonAddressDiscPtrauth p; diff --git a/clang/test/SemaCXX/type-traits-unsatisfied-diags.cpp b/clang/test/SemaCXX/type-traits-unsatisfied-diags.cpp index 2ab5b6ec372ed..3bde5b06a3aba 100644 --- a/clang/test/SemaCXX/type-traits-unsatisfied-diags.cpp +++ b/clang/test/SemaCXX/type-traits-unsatisfied-diags.cpp @@ -121,27 +121,6 @@ static_assert(__builtin_is_cpp_trivially_relocatable(U)); // expected-note@-1 {{because it is a union with a user-declared move constructor}} \ // expected-note@-1 {{because it is a union with a user-declared move assignment operator}} // expected-note@#tr-U {{'U' defined here}} -struct S4 trivially_relocatable_if_eligible { // #tr-S4 - ~S4(); - B b; -}; -static_assert(__builtin_is_cpp_trivially_relocatable(S4)); -// expected-error@-1 {{static assertion failed due to requirement '__builtin_is_cpp_trivially_relocatable(trivially_relocatable::S4)'}} \ -// expected-note@-1 {{'S4' is not trivially relocatable}} \ -// expected-note@-1 {{because it has a non-trivially-relocatable member 'b' of type 'B'}} \ -// expected-note@#tr-S4 {{'S4' defined here}} - -union U2 trivially_relocatable_if_eligible { // #tr-U2 - U2(const U2&); - U2(U2&&); - B b; -}; -static_assert(__builtin_is_cpp_trivially_relocatable(U2)); -// expected-error@-1 {{static assertion failed due to requirement '__builtin_is_cpp_trivially_relocatable(trivially_relocatable::U2)'}} \ -// expected-note@-1 {{'U2' is not trivially relocatable}} \ -// expected-note@-1 {{because it has a deleted destructor}} \ -// expected-note@-1 {{because it has a non-trivially-relocatable member 'b' of type 'B'}} \ -// expected-note@#tr-U2 {{'U2' defined here}} } _______________________________________________ cfe-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
