Skip to content

Commit 10ae9e9

Browse files
pccpcc
committed
[𝘀𝗽𝗿] changes introduced through rebase
Created using spr 1.3.6-beta.1 [skip ci]
1 parent aa01285 commit 10ae9e9

File tree

10 files changed

+58
-64
lines changed

10 files changed

+58
-64
lines changed

‎libcxx/include/__config‎

Lines changed: 2 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1275,11 +1275,9 @@ typedef __char32_t char32_t;
12751275
# define _LIBCPP_HAS_EXPLICIT_THIS_PARAMETER 0
12761276
# endif
12771277

1278-
# if defined(__POINTER_FIELD_PROTECTION__)
1279-
# define _LIBCPP_PFP [[clang::pointer_field_protection]]
1280-
# define _LIBCPP_NO_PFP [[clang::no_field_protection]]
1278+
# if __has_cpp_attribute(_Clang::__no_field_protection__)
1279+
# define _LIBCPP_NO_PFP [[_Clang::__no_field_protection__]]
12811280
# else
1282-
# define _LIBCPP_PFP
12831281
# define _LIBCPP_NO_PFP
12841282
# endif
12851283

‎libcxx/test/libcxx/gdb/gdb_pretty_printer_test.sh.cpp‎

Lines changed: 0 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -256,12 +256,9 @@ void unique_ptr_test() {
256256
ComparePrettyPrintToRegex(std::move(forty_two),
257257
R"(std::unique_ptr<int> containing = {__ptr_ = 0x[a-f0-9]+})");
258258

259-
#if !defined(__POINTER_FIELD_PROTECTION__)
260-
// GDB doesn't know how to read PFP fields correctly yet.
261259
std::unique_ptr<int> this_is_null;
262260
ComparePrettyPrintToChars(std::move(this_is_null),
263261
R"(std::unique_ptr is nullptr)");
264-
#endif
265262
}
266263

267264
void bitset_test() {
@@ -357,8 +354,6 @@ void map_test() {
357354
}
358355

359356
void multimap_test() {
360-
#if !defined(__POINTER_FIELD_PROTECTION__)
361-
// GDB doesn't know how to read PFP fields correctly yet.
362357
std::multimap<int, int> i_am_empty{};
363358
ComparePrettyPrintToChars(i_am_empty, "std::multimap is empty");
364359

@@ -374,7 +369,6 @@ void multimap_test() {
374369
"std::multimap with 6 elements = "
375370
R"({[1] = "one", [1] = "ein", [1] = "bir", )"
376371
R"([2] = "two", [2] = "zwei", [3] = "three"})");
377-
#endif
378372
}
379373

380374
void queue_test() {
@@ -447,16 +441,13 @@ void stack_test() {
447441
}
448442

449443
void multiset_test() {
450-
#if !defined(__POINTER_FIELD_PROTECTION__)
451-
// GDB doesn't know how to read PFP fields correctly yet.
452444
std::multiset<int> i_am_empty;
453445
ComparePrettyPrintToChars(i_am_empty, "std::multiset is empty");
454446

455447
std::multiset<std::string> one_two_three {"1:one", "2:two", "3:three", "1:one"};
456448
ComparePrettyPrintToChars(one_two_three,
457449
"std::multiset with 4 elements = {"
458450
R"("1:one", "1:one", "2:two", "3:three"})");
459-
#endif
460451
}
461452

462453
void vector_test() {
@@ -490,13 +481,10 @@ void vector_test() {
490481
"std::vector of length "
491482
"3, capacity 3 = {5, 6, 7}");
492483

493-
#if !defined(__POINTER_FIELD_PROTECTION__)
494-
// GDB doesn't know how to read PFP fields correctly yet.
495484
std::vector<int, UncompressibleAllocator<int>> test3({7, 8});
496485
ComparePrettyPrintToChars(std::move(test3),
497486
"std::vector of length "
498487
"2, capacity 2 = {7, 8}");
499-
#endif
500488
}
501489

502490
void set_iterator_test() {
@@ -667,11 +655,8 @@ void shared_ptr_test() {
667655
test0,
668656
R"(std::shared_ptr<int> count [3\?], weak [0\?]( \(libc\+\+ missing debug info\))? containing = {__ptr_ = 0x[a-f0-9]+})");
669657

670-
#if !defined(__POINTER_FIELD_PROTECTION__)
671-
// GDB doesn't know how to read PFP fields correctly yet.
672658
std::shared_ptr<const int> test3;
673659
ComparePrettyPrintToChars(test3, "std::shared_ptr is nullptr");
674-
#endif
675660
}
676661

677662
void streampos_test() {

‎libcxx/test/libcxx/type_traits/is_trivially_relocatable.compile.pass.cpp‎

Lines changed: 31 additions & 37 deletions
Original file line numberDiff line numberDiff line change
@@ -26,12 +26,6 @@
2626
# include <locale>
2727
#endif
2828

29-
#if defined(__POINTER_FIELD_PROTECTION__)
30-
constexpr bool pfp_disabled = false;
31-
#else
32-
constexpr bool pfp_disabled = true;
33-
#endif
34-
3529
static_assert(std::__libcpp_is_trivially_relocatable<char>::value, "");
3630
static_assert(std::__libcpp_is_trivially_relocatable<int>::value, "");
3731
static_assert(std::__libcpp_is_trivially_relocatable<double>::value, "");
@@ -74,8 +68,8 @@ static_assert(!std::__libcpp_is_trivially_relocatable<NonTrivialDestructor>::val
7468
// ----------------------
7569

7670
// __split_buffer
77-
static_assert(std::__libcpp_is_trivially_relocatable<std::__split_buffer<int> >::value == pfp_disabled, "");
78-
static_assert(std::__libcpp_is_trivially_relocatable<std::__split_buffer<NotTriviallyCopyable> >::value == pfp_disabled, "");
71+
static_assert(std::__libcpp_is_trivially_relocatable<std::__split_buffer<int> >::value, "");
72+
static_assert(std::__libcpp_is_trivially_relocatable<std::__split_buffer<NotTriviallyCopyable> >::value, "");
7973
static_assert(!std::__libcpp_is_trivially_relocatable<std::__split_buffer<int, test_allocator<int> > >::value, "");
8074

8175
// standard library types
@@ -88,7 +82,7 @@ static_assert(std::__libcpp_is_trivially_relocatable<std::array<std::unique_ptr<
8882

8983
static_assert(std::__libcpp_is_trivially_relocatable<std::array<int, 1> >::value, "");
9084
static_assert(!std::__libcpp_is_trivially_relocatable<std::array<NotTriviallyCopyable, 1> >::value, "");
91-
static_assert(std::__libcpp_is_trivially_relocatable<std::array<std::unique_ptr<int>, 1> >::value == pfp_disabled, "");
85+
static_assert(std::__libcpp_is_trivially_relocatable<std::array<std::unique_ptr<int>, 1> >::value, "");
9286

9387
// basic_string
9488
#if !__has_feature(address_sanitizer) || !_LIBCPP_INSTRUMENTED_WITH_ASAN
@@ -103,17 +97,17 @@ struct NotTriviallyRelocatableCharTraits : constexpr_char_traits<T> {
10397
};
10498

10599
static_assert(std::__libcpp_is_trivially_relocatable<
106-
std::basic_string<char, std::char_traits<char>, std::allocator<char> > >::value == pfp_disabled,
100+
std::basic_string<char, std::char_traits<char>, std::allocator<char> > >::value,
107101
"");
108102
static_assert(std::__libcpp_is_trivially_relocatable<
109-
std::basic_string<char, NotTriviallyRelocatableCharTraits<char>, std::allocator<char> > >::value == pfp_disabled,
103+
std::basic_string<char, NotTriviallyRelocatableCharTraits<char>, std::allocator<char> > >::value,
110104
"");
111105
static_assert(std::__libcpp_is_trivially_relocatable<
112-
std::basic_string<MyChar, constexpr_char_traits<MyChar>, std::allocator<MyChar> > >::value == pfp_disabled,
106+
std::basic_string<MyChar, constexpr_char_traits<MyChar>, std::allocator<MyChar> > >::value,
113107
"");
114108
static_assert(
115109
std::__libcpp_is_trivially_relocatable<
116-
std::basic_string<MyChar, NotTriviallyRelocatableCharTraits<MyChar>, std::allocator<MyChar> > >::value == pfp_disabled,
110+
std::basic_string<MyChar, NotTriviallyRelocatableCharTraits<MyChar>, std::allocator<MyChar> > >::value,
117111
"");
118112
static_assert(!std::__libcpp_is_trivially_relocatable<
119113
std::basic_string<char, std::char_traits<char>, test_allocator<char> > >::value,
@@ -125,21 +119,21 @@ static_assert(
125119
#endif
126120

127121
// deque
128-
static_assert(std::__libcpp_is_trivially_relocatable<std::deque<int> >::value == pfp_disabled, "");
129-
static_assert(std::__libcpp_is_trivially_relocatable<std::deque<NotTriviallyCopyable> >::value == pfp_disabled, "");
122+
static_assert(std::__libcpp_is_trivially_relocatable<std::deque<int> >::value, "");
123+
static_assert(std::__libcpp_is_trivially_relocatable<std::deque<NotTriviallyCopyable> >::value, "");
130124
static_assert(!std::__libcpp_is_trivially_relocatable<std::deque<int, test_allocator<int> > >::value, "");
131125

132126
// exception_ptr
133127
#ifndef _LIBCPP_ABI_MICROSOFT // FIXME: Is this also the case on windows?
134-
static_assert(std::__libcpp_is_trivially_relocatable<std::exception_ptr>::value == pfp_disabled, "");
128+
static_assert(std::__libcpp_is_trivially_relocatable<std::exception_ptr>::value, "");
135129
#endif
136130

137131
// expected
138132
#if TEST_STD_VER >= 23
139-
static_assert(std::__libcpp_is_trivially_relocatable<std::expected<int, int> >::value == pfp_disabled);
140-
static_assert(std::__libcpp_is_trivially_relocatable<std::expected<std::unique_ptr<int>, int>>::value == pfp_disabled);
141-
static_assert(std::__libcpp_is_trivially_relocatable<std::expected<int, std::unique_ptr<int>>>::value == pfp_disabled);
142-
static_assert(std::__libcpp_is_trivially_relocatable<std::expected<std::unique_ptr<int>, std::unique_ptr<int>>>::value == pfp_disabled);
133+
static_assert(std::__libcpp_is_trivially_relocatable<std::expected<int, int> >::value);
134+
static_assert(std::__libcpp_is_trivially_relocatable<std::expected<std::unique_ptr<int>, int>>::value);
135+
static_assert(std::__libcpp_is_trivially_relocatable<std::expected<int, std::unique_ptr<int>>>::value);
136+
static_assert(std::__libcpp_is_trivially_relocatable<std::expected<std::unique_ptr<int>, std::unique_ptr<int>>>::value);
143137

144138
static_assert(!std::__libcpp_is_trivially_relocatable<std::expected<int, NotTriviallyCopyable>>::value);
145139
static_assert(!std::__libcpp_is_trivially_relocatable<std::expected<NotTriviallyCopyable, int>>::value);
@@ -149,42 +143,42 @@ static_assert(
149143

150144
// locale
151145
#ifndef TEST_HAS_NO_LOCALIZATION
152-
static_assert(std::__libcpp_is_trivially_relocatable<std::locale>::value == pfp_disabled, "");
146+
static_assert(std::__libcpp_is_trivially_relocatable<std::locale>::value, "");
153147
#endif
154148

155149
// optional
156150
#if TEST_STD_VER >= 17
157151
static_assert(std::__libcpp_is_trivially_relocatable<std::optional<int>>::value, "");
158152
static_assert(!std::__libcpp_is_trivially_relocatable<std::optional<NotTriviallyCopyable>>::value, "");
159-
static_assert(std::__libcpp_is_trivially_relocatable<std::optional<std::unique_ptr<int>>>::value == pfp_disabled, "");
153+
static_assert(std::__libcpp_is_trivially_relocatable<std::optional<std::unique_ptr<int>>>::value, "");
160154
#endif // TEST_STD_VER >= 17
161155

162156
// pair
163-
static_assert(std::__libcpp_is_trivially_relocatable<std::pair<int, int> >::value == pfp_disabled, "");
157+
static_assert(std::__libcpp_is_trivially_relocatable<std::pair<int, int> >::value, "");
164158
static_assert(!std::__libcpp_is_trivially_relocatable<std::pair<NotTriviallyCopyable, int> >::value, "");
165159
static_assert(!std::__libcpp_is_trivially_relocatable<std::pair<int, NotTriviallyCopyable> >::value, "");
166160
static_assert(!std::__libcpp_is_trivially_relocatable<std::pair<NotTriviallyCopyable, NotTriviallyCopyable> >::value,
167161
"");
168-
static_assert(std::__libcpp_is_trivially_relocatable<std::pair<std::unique_ptr<int>, std::unique_ptr<int> > >::value == pfp_disabled,
162+
static_assert(std::__libcpp_is_trivially_relocatable<std::pair<std::unique_ptr<int>, std::unique_ptr<int> > >::value,
169163
"");
170164

171165
// shared_ptr
172-
static_assert(std::__libcpp_is_trivially_relocatable<std::shared_ptr<NotTriviallyCopyable> >::value == pfp_disabled, "");
166+
static_assert(std::__libcpp_is_trivially_relocatable<std::shared_ptr<NotTriviallyCopyable> >::value, "");
173167

174168
// tuple
175169
#if TEST_STD_VER >= 11
176170
static_assert(std::__libcpp_is_trivially_relocatable<std::tuple<> >::value, "");
177171

178-
static_assert(std::__libcpp_is_trivially_relocatable<std::tuple<int> >::value == pfp_disabled, "");
172+
static_assert(std::__libcpp_is_trivially_relocatable<std::tuple<int> >::value, "");
179173
static_assert(!std::__libcpp_is_trivially_relocatable<std::tuple<NotTriviallyCopyable> >::value, "");
180-
static_assert(std::__libcpp_is_trivially_relocatable<std::tuple<std::unique_ptr<int> > >::value == pfp_disabled, "");
174+
static_assert(std::__libcpp_is_trivially_relocatable<std::tuple<std::unique_ptr<int> > >::value, "");
181175

182-
static_assert(std::__libcpp_is_trivially_relocatable<std::tuple<int, int> >::value == pfp_disabled, "");
176+
static_assert(std::__libcpp_is_trivially_relocatable<std::tuple<int, int> >::value, "");
183177
static_assert(!std::__libcpp_is_trivially_relocatable<std::tuple<NotTriviallyCopyable, int> >::value, "");
184178
static_assert(!std::__libcpp_is_trivially_relocatable<std::tuple<int, NotTriviallyCopyable> >::value, "");
185179
static_assert(!std::__libcpp_is_trivially_relocatable<std::tuple<NotTriviallyCopyable, NotTriviallyCopyable> >::value,
186180
"");
187-
static_assert(std::__libcpp_is_trivially_relocatable<std::tuple<std::unique_ptr<int>, std::unique_ptr<int> > >::value == pfp_disabled,
181+
static_assert(std::__libcpp_is_trivially_relocatable<std::tuple<std::unique_ptr<int>, std::unique_ptr<int> > >::value,
188182
"");
189183
#endif // TEST_STD_VER >= 11
190184

@@ -209,9 +203,9 @@ struct NotTriviallyRelocatablePointer {
209203
void operator()(T*);
210204
};
211205

212-
static_assert(std::__libcpp_is_trivially_relocatable<std::unique_ptr<int> >::value == pfp_disabled, "");
213-
static_assert(std::__libcpp_is_trivially_relocatable<std::unique_ptr<NotTriviallyCopyable> >::value == pfp_disabled, "");
214-
static_assert(std::__libcpp_is_trivially_relocatable<std::unique_ptr<int[]> >::value == pfp_disabled, "");
206+
static_assert(std::__libcpp_is_trivially_relocatable<std::unique_ptr<int> >::value, "");
207+
static_assert(std::__libcpp_is_trivially_relocatable<std::unique_ptr<NotTriviallyCopyable> >::value, "");
208+
static_assert(std::__libcpp_is_trivially_relocatable<std::unique_ptr<int[]> >::value, "");
215209
static_assert(!std::__libcpp_is_trivially_relocatable<std::unique_ptr<int, NotTriviallyRelocatableDeleter> >::value,
216210
"");
217211
static_assert(!std::__libcpp_is_trivially_relocatable<std::unique_ptr<int[], NotTriviallyRelocatableDeleter> >::value,
@@ -225,23 +219,23 @@ static_assert(!std::__libcpp_is_trivially_relocatable<std::unique_ptr<int[], Not
225219
#if TEST_STD_VER >= 17
226220
static_assert(std::__libcpp_is_trivially_relocatable<std::variant<int> >::value, "");
227221
static_assert(!std::__libcpp_is_trivially_relocatable<std::variant<NotTriviallyCopyable> >::value, "");
228-
static_assert(std::__libcpp_is_trivially_relocatable<std::variant<std::unique_ptr<int> > >::value == pfp_disabled, "");
222+
static_assert(std::__libcpp_is_trivially_relocatable<std::variant<std::unique_ptr<int> > >::value, "");
229223

230224
static_assert(std::__libcpp_is_trivially_relocatable<std::variant<int, int> >::value, "");
231225
static_assert(!std::__libcpp_is_trivially_relocatable<std::variant<NotTriviallyCopyable, int> >::value, "");
232226
static_assert(!std::__libcpp_is_trivially_relocatable<std::variant<int, NotTriviallyCopyable> >::value, "");
233227
static_assert(!std::__libcpp_is_trivially_relocatable<std::variant<NotTriviallyCopyable, NotTriviallyCopyable> >::value,
234228
"");
235-
static_assert(std::__libcpp_is_trivially_relocatable<std::variant<std::unique_ptr<int>, std::unique_ptr<int> > >::value == pfp_disabled,
229+
static_assert(std::__libcpp_is_trivially_relocatable<std::variant<std::unique_ptr<int>, std::unique_ptr<int> > >::value,
236230
"");
237231
#endif // TEST_STD_VER >= 17
238232

239233
// vector
240-
static_assert(std::__libcpp_is_trivially_relocatable<std::vector<int> >::value == pfp_disabled, "");
241-
static_assert(std::__libcpp_is_trivially_relocatable<std::vector<NotTriviallyCopyable> >::value == pfp_disabled, "");
234+
static_assert(std::__libcpp_is_trivially_relocatable<std::vector<int> >::value, "");
235+
static_assert(std::__libcpp_is_trivially_relocatable<std::vector<NotTriviallyCopyable> >::value, "");
242236
static_assert(!std::__libcpp_is_trivially_relocatable<std::vector<int, test_allocator<int> > >::value, "");
243237

244238
// weak_ptr
245-
static_assert(std::__libcpp_is_trivially_relocatable<std::weak_ptr<NotTriviallyCopyable> >::value == pfp_disabled, "");
239+
static_assert(std::__libcpp_is_trivially_relocatable<std::weak_ptr<NotTriviallyCopyable> >::value, "");
246240

247241
// TODO: Mark all the trivially relocatable STL types as such

‎libcxxabi/include/__cxxabi_config.h‎

Lines changed: 2 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -109,12 +109,8 @@
109109
# define _LIBCXXABI_NOEXCEPT noexcept
110110
#endif
111111

112-
#if defined(_LIBCXXABI_COMPILER_CLANG)
113-
# if defined(__POINTER_FIELD_PROTECTION__)
114-
# define _LIBCXXABI_NO_PFP [[clang::no_field_protection]]
115-
# else
116-
# define _LIBCXXABI_NO_PFP
117-
# endif
112+
#if defined(__POINTER_FIELD_PROTECTION__)
113+
# define _LIBCXXABI_NO_PFP [[_Clang::__no_field_protection__]]
118114
#else
119115
# define _LIBCXXABI_NO_PFP
120116
#endif

‎llvm/docs/LangRef.rst‎

Lines changed: 10 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -3092,13 +3092,16 @@ A "convergencectrl" operand bundle is only valid on a ``convergent`` operation.
30923092
When present, the operand bundle must contain exactly one value of token type.
30933093
See the :doc:`ConvergentOperations` document for details.
30943094

3095+
.. _deactivationsymbol:
3096+
30953097
Deactivation Symbol Operand Bundles
30963098
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
30973099

30983100
A ``"deactivation-symbol"`` operand bundle is valid on the following
30993101
instructions (AArch64 only):
31003102

3101-
- Call to a normal function with ``notail`` attribute.
3103+
- Call to a normal function with ``notail`` attribute and a first argument and
3104+
return value of type ``ptr``.
31023105
- Call to ``llvm.ptrauth.sign`` or ``llvm.ptrauth.auth`` intrinsics.
31033106

31043107
This operand bundle specifies that if the deactivation symbol is defined
@@ -5148,7 +5151,7 @@ need to refer to the actual function body.
51485151
Pointer Authentication Constants
51495152
--------------------------------
51505153

5151-
``ptrauth (ptr CST, i32 KEY[, i64 DISC[, ptr ADDRDISC]?]?)``
5154+
``ptrauth (ptr CST, i32 KEY[, i64 DISC[, ptr ADDRDISC[, ptr DS]?]?]?)``
51525155

51535156
A '``ptrauth``' constant represents a pointer with a cryptographic
51545157
authentication signature embedded into some bits, as described in the
@@ -5177,6 +5180,11 @@ Otherwise, the expression is equivalent to:
51775180
%tmp2 = call i64 @llvm.ptrauth.sign(i64 ptrtoint (ptr CST to i64), i32 KEY, i64 %tmp1)
51785181
%val = inttoptr i64 %tmp2 to ptr
51795182

5183+
If the deactivation symbol operand ``DS`` has a non-null value,
5184+
the semantics are as if a :ref:`deactivation-symbol operand bundle
5185+
<deactivationsymbol>` were added to the ``llvm.ptrauth.sign`` intrinsic
5186+
calls above, with ``DS`` as the only operand.
5187+
51805188
.. _constantexprs:
51815189

51825190
Constant Expressions

‎llvm/lib/Bitcode/Reader/BitcodeReader.cpp‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1613,6 +1613,9 @@ Expected<Value *> BitcodeReader::materializeValue(unsigned StartValID,
16131613
ConstOps.size() > 4 ? ConstOps[4]
16141614
: ConstantPointerNull::get(cast<PointerType>(
16151615
ConstOps[3]->getType()));
1616+
if (!DeactivationSymbol->getType()->isPointerTy())
1617+
return error(
1618+
"ptrauth deactivation symbol operand must be a pointer");
16161619

16171620
C = ConstantPtrAuth::get(ConstOps[0], Key, Disc, ConstOps[3],
16181621
DeactivationSymbol);

‎llvm/lib/IR/Constants.cpp‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2082,6 +2082,7 @@ ConstantPtrAuth::ConstantPtrAuth(Constant *Ptr, ConstantInt *Key,
20822082
assert(Key->getBitWidth() == 32);
20832083
assert(Disc->getBitWidth() == 64);
20842084
assert(AddrDisc->getType()->isPointerTy());
2085+
assert(DeactivationSymbol->getType()->isPointerTy());
20852086
setOperand(0, Ptr);
20862087
setOperand(1, Key);
20872088
setOperand(2, Disc);

‎llvm/lib/IR/Verifier.cpp‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2632,6 +2632,9 @@ void Verifier::visitConstantPtrAuth(const ConstantPtrAuth *CPA) {
26322632
Check(CPA->getDiscriminator()->getBitWidth() == 64,
26332633
"signed ptrauth constant discriminator must be i64 constant integer");
26342634

2635+
Check(CPA->getDeactivationSymbol()->getType()->isPointerTy(),
2636+
"signed ptrauth constant deactivation symbol must be a pointer");
2637+
26352638
Check(isa<GlobalValue>(CPA->getDeactivationSymbol()) ||
26362639
CPA->getDeactivationSymbol()->isNullValue(),
26372640
"signed ptrauth constant deactivation symbol must be a global value "

‎llvm/test/Assembler/invalid-ptrauth-const6.ll‎

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,6 @@
1+
; RUN: not llvm-as < %s 2>&1 | FileCheck %s
2+
3+
@var = global i32 0
4+
5+
; CHECK: error: constant ptrauth deactivation symbol must be a pointer
6+
@ptr = global ptr ptrauth (ptr @var, i32 0, i64 65535, ptr null, i64 0)

‎llvm/test/Transforms/Util/phi-protected-field-ptr.ll‎ renamed to ‎llvm/test/Transforms/PhaseOrdering/phi-protected-field-ptr.ll‎

File renamed without changes.

0 commit comments

Comments
 (0)