219 lines · cpp
1// RUN: %clang_cc1 -triple arm64-apple-ios -std=c++26 -fptrauth-calls -fptrauth-intrinsics -verify -fsyntax-only %s2// RUN: %clang_cc1 -triple aarch64-linux-gnu -std=c++26 -fptrauth-calls -fptrauth-intrinsics -verify -fsyntax-only %s3 4#define AQ __ptrauth(1,1,50)5#define IQ __ptrauth(1,0,50)6#define AQ_IP __ptrauth(1,1,50)7#define IQ_IP __ptrauth(1,0,50)8#define AA [[clang::ptrauth_vtable_pointer(process_independent,address_discrimination,no_extra_discrimination)]]9#define IA [[clang::ptrauth_vtable_pointer(process_independent,no_address_discrimination,type_discrimination)]]10#define PA [[clang::ptrauth_vtable_pointer(process_dependent,no_address_discrimination,no_extra_discrimination)]]11 12template <class T>13struct Holder {14 T t_;15 bool operator==(const Holder&) const = default;16};17 18struct S1 {19 int * AQ p_;20 void *payload_;21 bool operator==(const S1&) const = default;22};23static_assert(__is_trivially_constructible(S1));24static_assert(!__is_trivially_constructible(S1, const S1&));25static_assert(!__is_trivially_assignable(S1, const S1&));26static_assert(__is_trivially_destructible(S1));27static_assert(!__is_trivially_copyable(S1));28static_assert(!__is_trivially_relocatable(S1)); // expected-warning{{deprecated}}29static_assert(!__builtin_is_cpp_trivially_relocatable(S1));30static_assert(!__is_trivially_equality_comparable(S1));31 32static_assert(__is_trivially_constructible(Holder<S1>));33static_assert(!__is_trivially_constructible(Holder<S1>, const Holder<S1>&));34static_assert(!__is_trivially_assignable(Holder<S1>, const Holder<S1>&));35static_assert(__is_trivially_destructible(Holder<S1>));36static_assert(!__is_trivially_copyable(Holder<S1>));37static_assert(!__is_trivially_relocatable(Holder<S1>)); // expected-warning{{deprecated}}38static_assert(!__builtin_is_cpp_trivially_relocatable(Holder<S1>));39static_assert(!__is_trivially_equality_comparable(Holder<S1>));40 41struct S2 {42 int * IQ p_;43 void *payload_;44 bool operator==(const S2&) const = default;45};46static_assert(__is_trivially_constructible(S2));47static_assert(__is_trivially_constructible(S2, const S2&));48static_assert(__is_trivially_assignable(S2, const S2&));49static_assert(__is_trivially_destructible(S2));50static_assert(__is_trivially_copyable(S2));51static_assert(__is_trivially_relocatable(S2)); // expected-warning{{deprecated}}52static_assert(__builtin_is_cpp_trivially_relocatable(S2));53static_assert(__is_trivially_equality_comparable(S2));54 55static_assert(__is_trivially_constructible(Holder<S2>));56static_assert(__is_trivially_constructible(Holder<S2>, const Holder<S2>&));57static_assert(__is_trivially_assignable(Holder<S2>, const Holder<S2>&));58static_assert(__is_trivially_destructible(Holder<S2>));59static_assert(__is_trivially_copyable(Holder<S2>));60static_assert(__is_trivially_relocatable(Holder<S2>)); // expected-warning{{deprecated}}61static_assert(__builtin_is_cpp_trivially_relocatable(Holder<S2>));62static_assert(__is_trivially_equality_comparable(Holder<S2>));63 64struct AA S3 {65 virtual void f();66 void *payload_;67 bool operator==(const S3&) const = default;68};69 70static_assert(!__is_trivially_constructible(S3));71static_assert(!__is_trivially_constructible(S3, const S3&));72static_assert(!__is_trivially_assignable(S3, const S3&));73static_assert(__is_trivially_destructible(S3));74static_assert(!__is_trivially_copyable(S3));75static_assert(!__is_trivially_relocatable(S3)); // expected-warning{{deprecated}}76//FIXME77static_assert(!__builtin_is_cpp_trivially_relocatable(S3));78static_assert(!__is_trivially_equality_comparable(S3));79 80 81static_assert(!__is_trivially_constructible(Holder<S3>));82static_assert(!__is_trivially_constructible(Holder<S3>, const Holder<S3>&));83static_assert(!__is_trivially_assignable(Holder<S3>, const Holder<S3>&));84static_assert(__is_trivially_destructible(Holder<S3>));85static_assert(!__is_trivially_copyable(Holder<S3>));86static_assert(!__is_trivially_relocatable(Holder<S3>)); // expected-warning{{deprecated}}87static_assert(!__builtin_is_cpp_trivially_relocatable(Holder<S3>));88static_assert(!__is_trivially_equality_comparable(Holder<S3>));89 90struct IA S4 {91 virtual void f();92 void *payload_;93 bool operator==(const S4&) const = default;94};95 96static_assert(!__is_trivially_constructible(S4));97static_assert(!__is_trivially_constructible(S4, const S4&));98static_assert(!__is_trivially_assignable(S4, const S4&));99static_assert(__is_trivially_destructible(S4));100static_assert(!__is_trivially_copyable(S4));101static_assert(!__is_trivially_relocatable(S4)); // expected-warning{{deprecated}}102static_assert(__builtin_is_cpp_trivially_relocatable(S4));103static_assert(!__is_trivially_equality_comparable(S4));104 105static_assert(!__is_trivially_constructible(Holder<S4>));106static_assert(!__is_trivially_constructible(Holder<S4>, const Holder<S4>&));107static_assert(!__is_trivially_assignable(Holder<S4>, const Holder<S4>&));108static_assert(__is_trivially_destructible(Holder<S4>));109static_assert(!__is_trivially_copyable(Holder<S4>));110static_assert(__is_trivially_relocatable(Holder<S4>)); // expected-warning{{deprecated}}111static_assert(__builtin_is_cpp_trivially_relocatable(Holder<S4>));112static_assert(!__is_trivially_equality_comparable(Holder<S4>));113 114struct PA S5 {115 virtual void f();116 void *payload_;117 bool operator==(const S5&) const = default;118};119 120static_assert(!__is_trivially_constructible(S5));121static_assert(!__is_trivially_constructible(S5, const S5&));122static_assert(!__is_trivially_assignable(S5, const S5&));123static_assert(__is_trivially_destructible(S5));124static_assert(!__is_trivially_copyable(S5));125static_assert(!__is_trivially_relocatable(S5)); // expected-warning{{deprecated}}126static_assert(__builtin_is_cpp_trivially_relocatable(S5));127static_assert(!__is_trivially_equality_comparable(S5));128 129static_assert(!__is_trivially_constructible(Holder<S5>));130static_assert(!__is_trivially_constructible(Holder<S5>, const Holder<S5>&));131static_assert(!__is_trivially_assignable(Holder<S5>, const Holder<S5>&));132static_assert(__is_trivially_destructible(Holder<S5>));133static_assert(!__is_trivially_copyable(Holder<S5>));134static_assert(__is_trivially_relocatable(Holder<S5>)); // expected-warning{{deprecated}}135static_assert(__builtin_is_cpp_trivially_relocatable(Holder<S5>));136static_assert(!__is_trivially_equality_comparable(Holder<S5>));137 138struct S6 {139 __INTPTR_TYPE__ AQ_IP p_;140 void *payload_;141 bool operator==(const S6&) const = default;142};143static_assert(__is_trivially_constructible(S6));144static_assert(!__is_trivially_constructible(S6, const S6&));145static_assert(!__is_trivially_assignable(S6, const S6&));146static_assert(__is_trivially_destructible(S6));147static_assert(!__is_trivially_copyable(S6));148static_assert(!__is_trivially_relocatable(S6)); // expected-warning{{deprecated}}149static_assert(!__builtin_is_cpp_trivially_relocatable(S6));150static_assert(!__is_trivially_equality_comparable(S6));151 152static_assert(__is_trivially_constructible(Holder<S6>));153static_assert(!__is_trivially_constructible(Holder<S6>, const Holder<S6>&));154static_assert(!__is_trivially_assignable(Holder<S6>, const Holder<S6>&));155static_assert(__is_trivially_destructible(Holder<S6>));156static_assert(!__is_trivially_copyable(Holder<S6>));157static_assert(!__is_trivially_relocatable(Holder<S6>)); // expected-warning{{deprecated}}158static_assert(!__builtin_is_cpp_trivially_relocatable(Holder<S6>));159static_assert(!__is_trivially_equality_comparable(Holder<S6>));160 161struct S7 {162 __INTPTR_TYPE__ IQ_IP p_;163 void *payload_;164 bool operator==(const S7&) const = default;165};166static_assert(__is_trivially_constructible(S7));167static_assert(__is_trivially_constructible(S7, const S7&));168static_assert(__is_trivially_assignable(S7&, const S7&));169static_assert(__is_trivially_destructible(S7));170static_assert(__is_trivially_copyable(S7));171static_assert(__is_trivially_relocatable(S7)); // expected-warning{{deprecated}}172static_assert(__builtin_is_cpp_trivially_relocatable(S7));173static_assert(__is_trivially_equality_comparable(S7));174 175static_assert(__is_trivially_constructible(Holder<S7>));176static_assert(__is_trivially_constructible(Holder<S7>, const Holder<S7>&));177static_assert(__is_trivially_assignable(Holder<S7>, const Holder<S7>&));178static_assert(__is_trivially_destructible(Holder<S7>));179static_assert(__is_trivially_copyable(Holder<S7>));180static_assert(__is_trivially_relocatable(Holder<S7>)); // expected-warning{{deprecated}}181static_assert(__builtin_is_cpp_trivially_relocatable(Holder<S7>));182static_assert(__is_trivially_equality_comparable(Holder<S7>));183 184template <class... Bases> struct MultipleInheriter : Bases... {185};186 187template <class T> static const bool test_is_trivially_relocatable_v = __builtin_is_cpp_trivially_relocatable(T);188template <class... Types> static const bool multiple_inheritance_is_relocatable = test_is_trivially_relocatable_v<MultipleInheriter<Types...>>;189template <class... Types> static const bool inheritance_relocatability_matches_bases_v =190 (test_is_trivially_relocatable_v<Types> && ...) == multiple_inheritance_is_relocatable<Types...>;191 192static_assert(multiple_inheritance_is_relocatable<S4, S5> == multiple_inheritance_is_relocatable<S5, S4>);193static_assert(inheritance_relocatability_matches_bases_v<S4, S5>);194static_assert(inheritance_relocatability_matches_bases_v<S5, S4>);195 196struct AA AddressDiscriminatedPolymorphicBase trivially_relocatable_if_eligible {197 virtual void foo();198};199 200struct IA NoAddressDiscriminatedPolymorphicBase trivially_relocatable_if_eligible {201 virtual void bar();202};203 204template <class T> struct UnionWrapper trivially_relocatable_if_eligible {205 union U {206 T field1;207 } u;208};209 210static_assert(!test_is_trivially_relocatable_v<AddressDiscriminatedPolymorphicBase>);211static_assert(test_is_trivially_relocatable_v<NoAddressDiscriminatedPolymorphicBase>);212static_assert(inheritance_relocatability_matches_bases_v<AddressDiscriminatedPolymorphicBase, NoAddressDiscriminatedPolymorphicBase>);213static_assert(inheritance_relocatability_matches_bases_v<NoAddressDiscriminatedPolymorphicBase, AddressDiscriminatedPolymorphicBase>);214 215static_assert(!test_is_trivially_relocatable_v<UnionWrapper<AddressDiscriminatedPolymorphicBase>>);216static_assert(test_is_trivially_relocatable_v<UnionWrapper<NoAddressDiscriminatedPolymorphicBase>>);217static_assert(!test_is_trivially_relocatable_v<UnionWrapper<MultipleInheriter<NoAddressDiscriminatedPolymorphicBase, AddressDiscriminatedPolymorphicBase>>>);218static_assert(!test_is_trivially_relocatable_v<UnionWrapper<MultipleInheriter<AddressDiscriminatedPolymorphicBase, NoAddressDiscriminatedPolymorphicBase>>>);219