|
150
|
1 // REQUIRES: aarch64
|
|
|
2 // RUN: llvm-mc -filetype=obj -triple=aarch64-none-linux %s -o %t.o
|
|
|
3 // RUN: ld.lld -fix-cortex-a53-843419 -z separate-code -verbose %t.o -o %t2 2>&1 | FileCheck -check-prefix CHECK-PRINT %s
|
|
173
|
4 // RUN: llvm-objdump --triple=aarch64-linux-gnu -d %t2 | FileCheck %s --check-prefixes=CHECK,CHECK-FIX
|
|
150
|
5 // RUN: ld.lld %t.o -z separate-code -o %t3
|
|
173
|
6 // RUN: llvm-objdump --triple=aarch64-linux-gnu -d %t3 | FileCheck %s --check-prefixes=CHECK,CHECK-NOFIX
|
|
150
|
7 // RUN: ld.lld -fix-cortex-a53-843419 -r -z separate-code %t.o -o %t4
|
|
173
|
8 // RUN: llvm-objdump --triple=aarch64-linux-gnu -d %t4 | FileCheck %s --check-prefixes=CHECK-RELOCATABLE
|
|
150
|
9 // Test cases for Cortex-A53 Erratum 843419
|
|
|
10 // See ARM-EPM-048406 Cortex_A53_MPCore_Software_Developers_Errata_Notice.pdf
|
|
|
11 // for full erratum details.
|
|
|
12 // In Summary
|
|
|
13 // 1.)
|
|
|
14 // ADRP (0xff8 or 0xffc).
|
|
|
15 // 2.)
|
|
|
16 // - load or store single register or either integer or vector registers.
|
|
|
17 // - STP or STNP of either vector or vector registers.
|
|
|
18 // - Advanced SIMD ST1 store instruction.
|
|
|
19 // - Must not write Rn.
|
|
|
20 // 3.) optional instruction, can't be a branch, must not write Rn, may read Rn.
|
|
|
21 // 4.) A load or store instruction from the Load/Store register unsigned
|
|
|
22 // immediate class using Rn as the base register.
|
|
|
23
|
|
|
24 // Each section contains a sequence of instructions that should be recognized
|
|
|
25 // as erratum 843419. The test cases cover the major variations such as:
|
|
|
26 // - adrp starts at 0xfff8 or 0xfffc.
|
|
|
27 // - Variations in instruction class for instruction 2.
|
|
|
28 // - Optional instruction 3 present or not.
|
|
|
29 // - Load or store for instruction 4.
|
|
|
30
|
|
|
31 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 211FF8 in unpatched output.
|
|
173
|
32 // CHECK: <t3_ff8_ldr>:
|
|
150
|
33 // CHECK-NEXT: 211ff8: 60 02 00 f0 adrp x0, #323584
|
|
|
34 // CHECK-NEXT: 211ffc: 21 00 40 f9 ldr x1, [x1]
|
|
173
|
35 // CHECK-FIX: 212000: 03 c8 00 14 b 0x24400c
|
|
150
|
36 // CHECK-NOFIX: 212000: 00 00 40 f9 ldr x0, [x0]
|
|
|
37 // CHECK-NEXT: 212004: c0 03 5f d6 ret
|
|
173
|
38 // CHECK-RELOCATABLE: <t3_ff8_ldr>:
|
|
150
|
39 // CHECK-RELOCATABLE-NEXT: ff8: 00 00 00 90 adrp x0, #0
|
|
|
40 // CHECK-RELOCATABLE-NEXT: ffc: 21 00 40 f9 ldr x1, [x1]
|
|
|
41 // CHECK-RELOCATABLE-NEXT: 1000: 00 00 40 f9 ldr x0, [x0]
|
|
|
42 // CHECK-RELOCATABLE-NEXT: 1004: c0 03 5f d6 ret
|
|
|
43
|
|
|
44 .section .text.01, "ax", %progbits
|
|
|
45 .balign 4096
|
|
|
46 .globl t3_ff8_ldr
|
|
|
47 .type t3_ff8_ldr, %function
|
|
|
48 .space 4096 - 8
|
|
|
49 t3_ff8_ldr:
|
|
|
50 adrp x0, dat1
|
|
|
51 ldr x1, [x1, #0]
|
|
|
52 ldr x0, [x0, :got_lo12:dat1]
|
|
|
53 ret
|
|
|
54
|
|
|
55 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 213FF8 in unpatched output.
|
|
173
|
56 // CHECK: <t3_ff8_ldrsimd>:
|
|
150
|
57 // CHECK-NEXT: 213ff8: 60 02 00 b0 adrp x0, #315392
|
|
|
58 // CHECK-NEXT: 213ffc: 21 00 40 bd ldr s1, [x1]
|
|
173
|
59 // CHECK-FIX: 214000: 05 c0 00 14 b 0x244014
|
|
150
|
60 // CHECK-NOFIX: 214000: 02 04 40 f9 ldr x2, [x0, #8]
|
|
|
61 // CHECK-NEXT: 214004: c0 03 5f d6 ret
|
|
|
62 .section .text.02, "ax", %progbits
|
|
|
63 .balign 4096
|
|
|
64 .globl t3_ff8_ldrsimd
|
|
|
65 .type t3_ff8_ldrsimd, %function
|
|
|
66 .space 4096 - 8
|
|
|
67 t3_ff8_ldrsimd:
|
|
|
68 adrp x0, dat2
|
|
|
69 ldr s1, [x1, #0]
|
|
|
70 ldr x2, [x0, :got_lo12:dat2]
|
|
|
71 ret
|
|
|
72
|
|
|
73 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 215FFC in unpatched output.
|
|
173
|
74 // CHECK: <t3_ffc_ldrpost>:
|
|
150
|
75 // CHECK-NEXT: 215ffc: 40 02 00 f0 adrp x0, #307200
|
|
|
76 // CHECK-NEXT: 216000: 21 84 40 bc ldr s1, [x1], #8
|
|
173
|
77 // CHECK-FIX: 216004: 06 b8 00 14 b 0x24401c
|
|
150
|
78 // CHECK-NOFIX: 216004: 03 08 40 f9 ldr x3, [x0, #16]
|
|
|
79 // CHECK-NEXT: 216008: c0 03 5f d6 ret
|
|
|
80 .section .text.03, "ax", %progbits
|
|
|
81 .balign 4096
|
|
|
82 .globl t3_ffc_ldrpost
|
|
|
83 .type t3_ffc_ldrpost, %function
|
|
|
84 .space 4096 - 4
|
|
|
85 t3_ffc_ldrpost:
|
|
|
86 adrp x0, dat3
|
|
|
87 ldr s1, [x1], #8
|
|
|
88 ldr x3, [x0, :got_lo12:dat3]
|
|
|
89 ret
|
|
|
90
|
|
|
91 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 217FF8 in unpatched output.
|
|
173
|
92 // CHECK: <t3_ff8_strpre>:
|
|
150
|
93 // CHECK-NEXT: 217ff8: 40 02 00 b0 adrp x0, #299008
|
|
|
94 // CHECK-NEXT: 217ffc: 21 8c 00 bc str s1, [x1, #8]!
|
|
173
|
95 // CHECK-FIX: 218000: 09 b0 00 14 b 0x244024
|
|
150
|
96 // CHECK-NOFIX: 218000: 02 0c 40 f9 ldr x2, [x0, #24]
|
|
|
97 // CHECK-NEXT: 218004: c0 03 5f d6 ret
|
|
|
98 .section .text.04, "ax", %progbits
|
|
|
99 .balign 4096
|
|
|
100 .globl t3_ff8_strpre
|
|
|
101 .type t3_ff8_strpre, %function
|
|
|
102 .space 4096 - 8
|
|
|
103 t3_ff8_strpre:
|
|
|
104 adrp x0, dat1
|
|
|
105 str s1, [x1, #8]!
|
|
|
106 ldr x2, [x0, :lo12:dat1]
|
|
|
107 ret
|
|
|
108
|
|
|
109 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 219FFC in unpatched output.
|
|
173
|
110 // CHECK: <t3_ffc_str>:
|
|
150
|
111 // CHECK-NEXT: 219ffc: 3c 02 00 f0 adrp x28, #290816
|
|
|
112 // CHECK-NEXT: 21a000: 42 00 00 f9 str x2, [x2]
|
|
173
|
113 // CHECK-FIX: 21a004: 0a a8 00 14 b 0x24402c
|
|
150
|
114 // CHECK-NOFIX: 21a004: 9c 13 00 f9 str x28, [x28, #32]
|
|
|
115 // CHECK-NEXT: 21a008: c0 03 5f d6 ret
|
|
|
116 .section .text.05, "ax", %progbits
|
|
|
117 .balign 4096
|
|
|
118 .globl t3_ffc_str
|
|
|
119 .type t3_ffc_str, %function
|
|
|
120 .space 4096 - 4
|
|
|
121 t3_ffc_str:
|
|
|
122 adrp x28, dat2
|
|
|
123 str x2, [x2, #0]
|
|
|
124 str x28, [x28, :lo12:dat2]
|
|
|
125 ret
|
|
|
126
|
|
|
127 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 21BFFC in unpatched output.
|
|
173
|
128 // CHECK: <t3_ffc_strsimd>:
|
|
150
|
129 // CHECK-NEXT: 21bffc: 3c 02 00 b0 adrp x28, #282624
|
|
|
130 // CHECK-NEXT: 21c000: 44 00 00 b9 str w4, [x2]
|
|
173
|
131 // CHECK-FIX: 21c004: 0c a0 00 14 b 0x244034
|
|
150
|
132 // CHECK-NOFIX: 21c004: 84 17 00 f9 str x4, [x28, #40]
|
|
|
133 // CHECK-NEXT: 21c008: c0 03 5f d6 ret
|
|
|
134 .section .text.06, "ax", %progbits
|
|
|
135 .balign 4096
|
|
|
136 .globl t3_ffc_strsimd
|
|
|
137 .type t3_ffc_strsimd, %function
|
|
|
138 .space 4096 - 4
|
|
|
139 t3_ffc_strsimd:
|
|
|
140 adrp x28, dat3
|
|
|
141 str w4, [x2, #0]
|
|
|
142 str x4, [x28, :lo12:dat3]
|
|
|
143 ret
|
|
|
144
|
|
|
145 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 21DFF8 in unpatched output.
|
|
173
|
146 // CHECK: <t3_ff8_ldrunpriv>:
|
|
150
|
147 // CHECK-NEXT: 21dff8: 1d 02 00 f0 adrp x29, #274432
|
|
|
148 // CHECK-NEXT: 21dffc: 41 08 40 38 ldtrb w1, [x2]
|
|
173
|
149 // CHECK-FIX: 21e000: 0f 98 00 14 b 0x24403c
|
|
150
|
150 // CHECK-NOFIX: 21e000: bd 03 40 f9 ldr x29, [x29]
|
|
|
151 // CHECK-NEXT: 21e004: c0 03 5f d6 ret
|
|
|
152 .section .text.07, "ax", %progbits
|
|
|
153 .balign 4096
|
|
|
154 .globl t3_ff8_ldrunpriv
|
|
|
155 .type t3_ff8_ldrunpriv, %function
|
|
|
156 .space 4096 - 8
|
|
|
157 t3_ff8_ldrunpriv:
|
|
|
158 adrp x29, dat1
|
|
|
159 ldtrb w1, [x2, #0]
|
|
|
160 ldr x29, [x29, :got_lo12:dat1]
|
|
|
161 ret
|
|
|
162
|
|
|
163 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 21FFFC in unpatched output.
|
|
173
|
164 // CHECK: <t3_ffc_ldur>:
|
|
150
|
165 // CHECK-NEXT: 21fffc: 1d 02 00 b0 adrp x29, #266240
|
|
|
166 // CHECK-NEXT: 220000: 42 40 40 b8 ldur w2, [x2, #4]
|
|
173
|
167 // CHECK-FIX: 220004: 10 90 00 14 b 0x244044
|
|
150
|
168 // CHECK-NOFIX: 220004: bd 07 40 f9 ldr x29, [x29, #8]
|
|
|
169 // CHECK-NEXT: 220008: c0 03 5f d6 ret
|
|
|
170 .balign 4096
|
|
|
171 .globl t3_ffc_ldur
|
|
|
172 .type t3_ffc_ldur, %function
|
|
|
173 .space 4096 - 4
|
|
|
174 t3_ffc_ldur:
|
|
|
175 adrp x29, dat2
|
|
|
176 ldur w2, [x2, #4]
|
|
|
177 ldr x29, [x29, :got_lo12:dat2]
|
|
|
178 ret
|
|
|
179
|
|
|
180 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 221FFC in unpatched output.
|
|
173
|
181 // CHECK: <t3_ffc_sturh>:
|
|
150
|
182 // CHECK-NEXT: 221ffc: f2 01 00 f0 adrp x18, #258048
|
|
|
183 // CHECK-NEXT: 222000: 43 40 00 78 sturh w3, [x2, #4]
|
|
173
|
184 // CHECK-FIX: 222004: 12 88 00 14 b 0x24404c
|
|
150
|
185 // CHECK-NOFIX: 222004: 41 0a 40 f9 ldr x1, [x18, #16]
|
|
|
186 // CHECK-NEXT: 222008: c0 03 5f d6 ret
|
|
|
187 .section .text.09, "ax", %progbits
|
|
|
188 .balign 4096
|
|
|
189 .globl t3_ffc_sturh
|
|
|
190 .type t3_ffc_sturh, %function
|
|
|
191 .space 4096 - 4
|
|
|
192 t3_ffc_sturh:
|
|
|
193 adrp x18, dat3
|
|
|
194 sturh w3, [x2, #4]
|
|
|
195 ldr x1, [x18, :got_lo12:dat3]
|
|
|
196 ret
|
|
|
197
|
|
|
198 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 223FF8 in unpatched output.
|
|
173
|
199 // CHECK: <t3_ff8_literal>:
|
|
150
|
200 // CHECK-NEXT: 223ff8: f2 01 00 b0 adrp x18, #249856
|
|
173
|
201 // CHECK-NEXT: 223ffc: e3 ff ff 58 ldr x3, 0x223ff8
|
|
|
202 // CHECK-FIX: 224000: 15 80 00 14 b 0x244054
|
|
150
|
203 // CHECK-NOFIX: 224000: 52 0e 40 f9 ldr x18, [x18, #24]
|
|
|
204 // CHECK-NEXT: 224004: c0 03 5f d6 ret
|
|
|
205 .section .text.10, "ax", %progbits
|
|
|
206 .balign 4096
|
|
|
207 .globl t3_ff8_literal
|
|
|
208 .type t3_ff8_literal, %function
|
|
|
209 .space 4096 - 8
|
|
|
210 t3_ff8_literal:
|
|
|
211 adrp x18, dat1
|
|
|
212 ldr x3, t3_ff8_literal
|
|
|
213 ldr x18, [x18, :lo12:dat1]
|
|
|
214 ret
|
|
|
215
|
|
|
216 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 225FFC in unpatched output.
|
|
173
|
217 // CHECK: <t3_ffc_register>:
|
|
150
|
218 // CHECK-NEXT: 225ffc: cf 01 00 f0 adrp x15, #241664
|
|
|
219 // CHECK-NEXT: 226000: 43 68 61 f8 ldr x3, [x2, x1]
|
|
173
|
220 // CHECK-FIX: 226004: 16 78 00 14 b 0x24405c
|
|
150
|
221 // CHECK-NOFIX: 226004: ea 11 40 f9 ldr x10, [x15, #32]
|
|
|
222 // CHECK-NEXT: 226008: c0 03 5f d6 ret
|
|
|
223 .section .text.11, "ax", %progbits
|
|
|
224 .balign 4096
|
|
|
225 .globl t3_ffc_register
|
|
|
226 .type t3_ffc_register, %function
|
|
|
227 .space 4096 - 4
|
|
|
228 t3_ffc_register:
|
|
|
229 adrp x15, dat2
|
|
|
230 ldr x3, [x2, x1]
|
|
|
231 ldr x10, [x15, :lo12:dat2]
|
|
|
232 ret
|
|
|
233
|
|
|
234 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 227FF8 in unpatched output.
|
|
173
|
235 // CHECK: <t3_ff8_stp>:
|
|
150
|
236 // CHECK-NEXT: 227ff8: d0 01 00 b0 adrp x16, #233472
|
|
|
237 // CHECK-NEXT: 227ffc: 61 08 00 a9 stp x1, x2, [x3]
|
|
173
|
238 // CHECK-FIX: 228000: 19 70 00 14 b 0x244064
|
|
150
|
239 // CHECK-NOFIX: 228000: 0d 16 40 f9 ldr x13, [x16, #40]
|
|
|
240 // CHECK-NEXT: 228004: c0 03 5f d6 ret
|
|
|
241 .section .text.12, "ax", %progbits
|
|
|
242 .balign 4096
|
|
|
243 .globl t3_ff8_stp
|
|
|
244 .type t3_ff8_stp, %function
|
|
|
245 .space 4096 - 8
|
|
|
246 t3_ff8_stp:
|
|
|
247 adrp x16, dat3
|
|
|
248 stp x1,x2, [x3, #0]
|
|
|
249 ldr x13, [x16, :lo12:dat3]
|
|
|
250 ret
|
|
|
251
|
|
|
252 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 229FFC in unpatched output.
|
|
173
|
253 // CHECK: <t3_ffc_stnp>:
|
|
150
|
254 // CHECK-NEXT: 229ffc: a7 01 00 f0 adrp x7, #225280
|
|
|
255 // CHECK-NEXT: 22a000: 61 08 00 a8 stnp x1, x2, [x3]
|
|
173
|
256 // CHECK-FIX: 22a004: 1a 68 00 14 b 0x24406c
|
|
150
|
257 // CHECK-NOFIX: 22a004: e9 0c 40 f9 ldr x9, [x7, #24]
|
|
|
258 // CHECK-NEXT: 22a008: c0 03 5f d6 ret
|
|
|
259 .section .text.13, "ax", %progbits
|
|
|
260 .balign 4096
|
|
|
261 .globl t3_ffc_stnp
|
|
|
262 .type t3_ffc_stnp, %function
|
|
|
263 .space 4096 - 4
|
|
|
264 t3_ffc_stnp:
|
|
|
265 adrp x7, dat1
|
|
|
266 stnp x1,x2, [x3, #0]
|
|
|
267 ldr x9, [x7, :lo12:dat1]
|
|
|
268 ret
|
|
|
269
|
|
|
270 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 22BFFC in unpatched output.
|
|
173
|
271 // CHECK: <t3_ffc_st1singlepost>:
|
|
150
|
272 // CHECK-NEXT: 22bffc: b7 01 00 b0 adrp x23, #217088
|
|
|
273 // CHECK-NEXT: 22c000: 20 04 82 0d st1 { v0.b }[1], [x1], x2
|
|
173
|
274 // CHECK-FIX: 22c004: 1c 60 00 14 b 0x244074
|
|
150
|
275 // CHECK-NOFIX: 22c004: f6 12 40 f9 ldr x22, [x23, #32]
|
|
|
276 // CHECK-NEXT: 22c008: c0 03 5f d6 ret
|
|
|
277 .section .text.14, "ax", %progbits
|
|
|
278 .balign 4096
|
|
|
279 .globl t3_ffc_st1singlepost
|
|
|
280 .type t3_ffc_st1singlepost, %function
|
|
|
281 .space 4096 - 4
|
|
|
282 t3_ffc_st1singlepost:
|
|
|
283 adrp x23, dat2
|
|
|
284 st1 { v0.b }[1], [x1], x2
|
|
|
285 ldr x22, [x23, :lo12:dat2]
|
|
|
286 ret
|
|
|
287
|
|
|
288 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 22DFF8 in unpatched output.
|
|
173
|
289 // CHECK: <t3_ff8_st1multiple>:
|
|
150
|
290 // CHECK-NEXT: 22dff8: 97 01 00 f0 adrp x23, #208896
|
|
|
291 // CHECK-NEXT: 22dffc: 20 a0 00 4c st1 { v0.16b, v1.16b }, [x1]
|
|
173
|
292 // CHECK-FIX: 22e000: 1f 58 00 14 b 0x24407c
|
|
150
|
293 // CHECK-NOFIX: 22e000: f8 16 40 f9 ldr x24, [x23, #40]
|
|
|
294 // CHECK-NEXT: 22e004: c0 03 5f d6 ret
|
|
|
295 .section .text.15, "ax", %progbits
|
|
|
296 .balign 4096
|
|
|
297 .globl t3_ff8_st1multiple
|
|
|
298 .type t3_ff8_st1muliple, %function
|
|
|
299 .space 4096 - 8
|
|
|
300 t3_ff8_st1multiple:
|
|
|
301 adrp x23, dat3
|
|
|
302 st1 { v0.16b, v1.16b }, [x1]
|
|
|
303 ldr x24, [x23, :lo12:dat3]
|
|
|
304 ret
|
|
|
305
|
|
|
306 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 22FFF8 in unpatched output.
|
|
173
|
307 // CHECK: <t4_ff8_ldr>:
|
|
150
|
308 // CHECK-NEXT: 22fff8: 80 01 00 b0 adrp x0, #200704
|
|
|
309 // CHECK-NEXT: 22fffc: 21 00 40 f9 ldr x1, [x1]
|
|
|
310 // CHECK-NEXT: 230000: 42 00 00 8b add x2, x2, x0
|
|
173
|
311 // CHECK-FIX: 230004: 20 50 00 14 b 0x244084
|
|
150
|
312 // CHECK-NOFIX: 230004: 02 00 40 f9 ldr x2, [x0]
|
|
|
313 // CHECK-NEXT: 230008: c0 03 5f d6 ret
|
|
|
314 .section .text.16, "ax", %progbits
|
|
|
315 .balign 4096
|
|
|
316 .globl t4_ff8_ldr
|
|
|
317 .type t4_ff8_ldr, %function
|
|
|
318 .space 4096 - 8
|
|
|
319 t4_ff8_ldr:
|
|
|
320 adrp x0, dat1
|
|
|
321 ldr x1, [x1, #0]
|
|
|
322 add x2, x2, x0
|
|
|
323 ldr x2, [x0, :got_lo12:dat1]
|
|
|
324 ret
|
|
|
325
|
|
|
326 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 231FFC in unpatched output.
|
|
173
|
327 // CHECK: <t4_ffc_str>:
|
|
150
|
328 // CHECK-NEXT: 231ffc: 7c 01 00 f0 adrp x28, #192512
|
|
|
329 // CHECK-NEXT: 232000: 42 00 00 f9 str x2, [x2]
|
|
|
330 // CHECK-NEXT: 232004: 20 00 02 cb sub x0, x1, x2
|
|
173
|
331 // CHECK-FIX: 232008: 21 48 00 14 b 0x24408c
|
|
150
|
332 // CHECK-NOFIX: 232008: 9b 07 00 f9 str x27, [x28, #8]
|
|
|
333 // CHECK-NEXT: 23200c: c0 03 5f d6 ret
|
|
|
334 .section .text.17, "ax", %progbits
|
|
|
335 .balign 4096
|
|
|
336 .globl t4_ffc_str
|
|
|
337 .type t4_ffc_str, %function
|
|
|
338 .space 4096 - 4
|
|
|
339 t4_ffc_str:
|
|
|
340 adrp x28, dat2
|
|
|
341 str x2, [x2, #0]
|
|
|
342 sub x0, x1, x2
|
|
|
343 str x27, [x28, :got_lo12:dat2]
|
|
|
344 ret
|
|
|
345
|
|
|
346 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 233FF8 in unpatched output.
|
|
173
|
347 // CHECK: <t4_ff8_stp>:
|
|
150
|
348 // CHECK-NEXT: 233ff8: 70 01 00 b0 adrp x16, #184320
|
|
|
349 // CHECK-NEXT: 233ffc: 61 08 00 a9 stp x1, x2, [x3]
|
|
|
350 // CHECK-NEXT: 234000: 03 7e 10 9b mul x3, x16, x16
|
|
173
|
351 // CHECK-FIX: 234004: 24 40 00 14 b 0x244094
|
|
150
|
352 // CHECK-NOFIX: 234004: 0e 0a 40 f9 ldr x14, [x16, #16]
|
|
|
353 // CHECK-NEXT: 234008: c0 03 5f d6 ret
|
|
|
354 .section .text.18, "ax", %progbits
|
|
|
355 .balign 4096
|
|
|
356 .globl t4_ff8_stp
|
|
|
357 .type t4_ff8_stp, %function
|
|
|
358 .space 4096 - 8
|
|
|
359 t4_ff8_stp:
|
|
|
360 adrp x16, dat3
|
|
|
361 stp x1,x2, [x3, #0]
|
|
|
362 mul x3, x16, x16
|
|
|
363 ldr x14, [x16, :got_lo12:dat3]
|
|
|
364 ret
|
|
|
365
|
|
|
366 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 235FF8 in unpatched output.
|
|
173
|
367 // CHECK: <t4_ff8_stppre>:
|
|
150
|
368 // CHECK-NEXT: 235ff8: 50 01 00 f0 adrp x16, #176128
|
|
|
369 // CHECK-NEXT: 235ffc: 61 08 81 a9 stp x1, x2, [x3, #16]!
|
|
|
370 // CHECK-NEXT: 236000: 03 7e 10 9b mul x3, x16, x16
|
|
173
|
371 // CHECK-FIX: 236004: 26 38 00 14 b 0x24409c
|
|
150
|
372 // CHECK-NOFIX: 236004: 0e 06 40 f9 ldr x14, [x16, #8]
|
|
|
373 // CHECK-NEXT: 236008: c0 03 5f d6 ret
|
|
|
374 .section .text.19, "ax", %progbits
|
|
|
375 .balign 4096
|
|
|
376 .globl t4_ff8_stppre
|
|
|
377 .type t4_ff8_stppre, %function
|
|
|
378 .space 4096 - 8
|
|
|
379 t4_ff8_stppre:
|
|
|
380 adrp x16, dat1
|
|
|
381 stp x1,x2, [x3, #16]!
|
|
|
382 mul x3, x16, x16
|
|
|
383 ldr x14, [x16, #8]
|
|
|
384 ret
|
|
|
385
|
|
|
386 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 237FF8 in unpatched output.
|
|
173
|
387 // CHECK: <t4_ff8_stppost>:
|
|
150
|
388 // CHECK-NEXT: 237ff8: 50 01 00 b0 adrp x16, #167936
|
|
|
389 // CHECK-NEXT: 237ffc: 61 08 81 a8 stp x1, x2, [x3], #16
|
|
|
390 // CHECK-NEXT: 238000: 03 7e 10 9b mul x3, x16, x16
|
|
173
|
391 // CHECK-FIX: 238004: 28 30 00 14 b 0x2440a4
|
|
150
|
392 // CHECK-NOFIX: 238004: 0e 06 40 f9 ldr x14, [x16, #8]
|
|
|
393 // CHECK-NEXT: 238008: c0 03 5f d6 ret
|
|
|
394 .section .text.20, "ax", %progbits
|
|
|
395 .balign 4096
|
|
|
396 .globl t4_ff8_stppost
|
|
|
397 .type t4_ff8_stppost, %function
|
|
|
398 .space 4096 - 8
|
|
|
399 t4_ff8_stppost:
|
|
|
400 adrp x16, dat2
|
|
|
401 stp x1,x2, [x3], #16
|
|
|
402 mul x3, x16, x16
|
|
|
403 ldr x14, [x16, #8]
|
|
|
404 ret
|
|
|
405
|
|
|
406 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 239FFC in unpatched output.
|
|
173
|
407 // CHECK: <t4_ffc_stpsimd>:
|
|
150
|
408 // CHECK-NEXT: 239ffc: 30 01 00 f0 adrp x16, #159744
|
|
|
409 // CHECK-NEXT: 23a000: 61 08 00 ad stp q1, q2, [x3]
|
|
|
410 // CHECK-NEXT: 23a004: 03 7e 10 9b mul x3, x16, x16
|
|
173
|
411 // CHECK-FIX: 23a008: 29 28 00 14 b 0x2440ac
|
|
150
|
412 // CHECK-NOFIX: 23a008: 0e 06 40 f9 ldr x14, [x16, #8]
|
|
|
413 // CHECK-NEXT: 23a00c: c0 03 5f d6 ret
|
|
|
414 .section .text.21, "ax", %progbits
|
|
|
415 .balign 4096
|
|
|
416 .globl t4_ffc_stpsimd
|
|
|
417 .type t4_ffc_stpsimd, %function
|
|
|
418 .space 4096 - 4
|
|
|
419 t4_ffc_stpsimd:
|
|
|
420 adrp x16, dat3
|
|
|
421 stp q1,q2, [x3, #0]
|
|
|
422 mul x3, x16, x16
|
|
|
423 ldr x14, [x16, #8]
|
|
|
424 ret
|
|
|
425
|
|
|
426 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 23BFFC in unpatched output.
|
|
173
|
427 // CHECK: <t4_ffc_stnp>:
|
|
150
|
428 // CHECK-NEXT: 23bffc: 27 01 00 b0 adrp x7, #151552
|
|
|
429 // CHECK-NEXT: 23c000: 61 08 00 a8 stnp x1, x2, [x3]
|
|
|
430 // CHECK-NEXT: 23c004: 1f 20 03 d5 nop
|
|
173
|
431 // CHECK-FIX: 23c008: 2b 20 00 14 b 0x2440b4
|
|
150
|
432 // CHECK-NOFIX: 23c008: ea 00 40 f9 ldr x10, [x7]
|
|
|
433 // CHECK-NEXT: 23c00c: c0 03 5f d6 ret
|
|
|
434 .section .text.22, "ax", %progbits
|
|
|
435 .balign 4096
|
|
|
436 .globl t4_ffc_stnp
|
|
|
437 .type t4_ffc_stnp, %function
|
|
|
438 .space 4096 - 4
|
|
|
439 t4_ffc_stnp:
|
|
|
440 adrp x7, dat1
|
|
|
441 stnp x1,x2, [x3, #0]
|
|
|
442 nop
|
|
|
443 ldr x10, [x7, :got_lo12:dat1]
|
|
|
444 ret
|
|
|
445
|
|
|
446 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 23DFFC in unpatched output.
|
|
173
|
447 // CHECK: <t4_ffc_st1>:
|
|
150
|
448 // CHECK-NEXT: 23dffc: 18 01 00 f0 adrp x24, #143360
|
|
|
449 // CHECK-NEXT: 23e000: 20 80 00 4d st1 { v0.s }[2], [x1]
|
|
|
450 // CHECK-NEXT: 23e004: f6 06 40 f9 ldr x22, [x23, #8]
|
|
173
|
451 // CHECK-FIX: 23e008: 2d 18 00 14 b 0x2440bc
|
|
150
|
452 // CHECK-NOFIX: 23e008: 18 ff 3f f9 str x24, [x24, #32760]
|
|
|
453 // CHECK-NEXT: 23e00c: c0 03 5f d6 ret
|
|
|
454 .section .text.23, "ax", %progbits
|
|
|
455 .balign 4096
|
|
|
456 .globl t4_ffc_st1
|
|
|
457 .type t4_ffc_st1, %function
|
|
|
458 .space 4096 - 4
|
|
|
459 t4_ffc_st1:
|
|
|
460 adrp x24, dat2
|
|
|
461 st1 { v0.s }[2], [x1]
|
|
|
462 ldr x22, [x23, :got_lo12:dat2]
|
|
|
463 str x24, [x24, #32760]
|
|
|
464 ret
|
|
|
465
|
|
|
466 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 23FFF8 in unpatched output.
|
|
173
|
467 // CHECK: <t3_ff8_ldr_once>:
|
|
150
|
468 // CHECK-NEXT: 23fff8: 00 01 00 b0 adrp x0, #135168
|
|
|
469 // CHECK-NEXT: 23fffc: 20 70 82 4c st1 { v0.16b }, [x1], x2
|
|
173
|
470 // CHECK-FIX: 240000: 31 10 00 14 b 0x2440c4
|
|
150
|
471 // CHECK-NOFIX: 240000: 01 08 40 f9 ldr x1, [x0, #16]
|
|
|
472 // CHECK-NEXT: 240004: 02 08 40 f9 ldr x2, [x0, #16]
|
|
|
473 // CHECK-NEXT: 240008: c0 03 5f d6 ret
|
|
|
474 .section .text.24, "ax", %progbits
|
|
|
475 .balign 4096
|
|
|
476 .globl t3_ff8_ldr_once
|
|
|
477 .type t3_ff8_ldr_once, %function
|
|
|
478 .space 4096 - 8
|
|
|
479 t3_ff8_ldr_once:
|
|
|
480 adrp x0, dat3
|
|
|
481 st1 { v0.16b }, [x1], x2
|
|
|
482 ldr x1, [x0, #16]
|
|
|
483 ldr x2, [x0, #16]
|
|
|
484 ret
|
|
|
485
|
|
|
486 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 241FF8 in unpatched output.
|
|
173
|
487 // CHECK: <t3_ff8_ldxr>:
|
|
150
|
488 // CHECK-NEXT: 241ff8: e0 00 00 f0 adrp x0, #126976
|
|
|
489 // CHECK-NEXT: 241ffc: 03 7c 5f c8 ldxr x3, [x0]
|
|
173
|
490 // CHECK-FIX: 242000: 33 08 00 14 b 0x2440cc
|
|
150
|
491 // CHECK-NOFIX: 242000: 01 08 40 f9 ldr x1, [x0, #16]
|
|
|
492 // CHECK: 242004: 02 08 40 f9 ldr x2, [x0, #16]
|
|
|
493 // CHECK-NEXT: 242008: c0 03 5f d6 ret
|
|
|
494 .section .text.25, "ax", %progbits
|
|
|
495 .balign 4096
|
|
|
496 .globl t3_ff8_ldxr
|
|
|
497 .type t3_ff8_ldxr, %function
|
|
|
498 .space 4096 - 8
|
|
|
499 t3_ff8_ldxr:
|
|
|
500 adrp x0, dat3
|
|
|
501 ldxr x3, [x0]
|
|
|
502 ldr x1, [x0, #16]
|
|
|
503 ldr x2, [x0, #16]
|
|
|
504 ret
|
|
|
505
|
|
|
506 // CHECK-PRINT: detected cortex-a53-843419 erratum sequence starting at 243FF8 in unpatched output.
|
|
173
|
507 // CHECK: <t3_ff8_stxr>:
|
|
150
|
508 // CHECK-NEXT: 243ff8: e0 00 00 b0 adrp x0, #118784
|
|
|
509 // CHECK-NEXT: 243ffc: 03 7c 04 c8 stxr w4, x3, [x0]
|
|
173
|
510 // CHECK-FIX: 244000: 35 00 00 14 b 0x2440d4
|
|
150
|
511 // CHECK-NOFIX: 244000: 01 08 40 f9 ldr x1, [x0, #16]
|
|
|
512 // CHECK: 244004: 02 08 40 f9 ldr x2, [x0, #16]
|
|
|
513 // CHECK-NEXT: 244008: c0 03 5f d6 ret
|
|
|
514 .section .text.26, "ax", %progbits
|
|
|
515 .balign 4096
|
|
|
516 .globl t3_ff8_stxr
|
|
|
517 .type t3_ff8_stxr, %function
|
|
|
518 .space 4096 - 8
|
|
|
519 t3_ff8_stxr:
|
|
|
520 adrp x0, dat3
|
|
|
521 stxr w4, x3, [x0]
|
|
|
522 ldr x1, [x0, #16]
|
|
|
523 ldr x2, [x0, #16]
|
|
|
524 ret
|
|
|
525
|
|
|
526 .text
|
|
|
527 .globl _start
|
|
|
528 .type _start, %function
|
|
|
529 _start:
|
|
|
530 ret
|
|
|
531
|
|
173
|
532 // CHECK-FIX: <__CortexA53843419_212000>:
|
|
150
|
533 // CHECK-FIX-NEXT: 24400c: 00 00 40 f9 ldr x0, [x0]
|
|
173
|
534 // CHECK-FIX-NEXT: 244010: fd 37 ff 17 b 0x212004
|
|
|
535 // CHECK-FIX: <__CortexA53843419_214000>:
|
|
150
|
536 // CHECK-FIX-NEXT: 244014: 02 04 40 f9 ldr x2, [x0, #8]
|
|
173
|
537 // CHECK-FIX-NEXT: 244018: fb 3f ff 17 b 0x214004
|
|
|
538 // CHECK-FIX: <__CortexA53843419_216004>:
|
|
150
|
539 // CHECK-FIX-NEXT: 24401c: 03 08 40 f9 ldr x3, [x0, #16]
|
|
173
|
540 // CHECK-FIX-NEXT: 244020: fa 47 ff 17 b 0x216008
|
|
|
541 // CHECK-FIX: <__CortexA53843419_218000>:
|
|
150
|
542 // CHECK-FIX-NEXT: 244024: 02 0c 40 f9 ldr x2, [x0, #24]
|
|
173
|
543 // CHECK-FIX-NEXT: 244028: f7 4f ff 17 b 0x218004
|
|
|
544 // CHECK-FIX: <__CortexA53843419_21A004>:
|
|
150
|
545 // CHECK-FIX-NEXT: 24402c: 9c 13 00 f9 str x28, [x28, #32]
|
|
173
|
546 // CHECK-FIX-NEXT: 244030: f6 57 ff 17 b 0x21a008
|
|
|
547 // CHECK-FIX: <__CortexA53843419_21C004>:
|
|
150
|
548 // CHECK-FIX-NEXT: 244034: 84 17 00 f9 str x4, [x28, #40]
|
|
173
|
549 // CHECK-FIX-NEXT: 244038: f4 5f ff 17 b 0x21c008
|
|
|
550 // CHECK-FIX: <__CortexA53843419_21E000>:
|
|
150
|
551 // CHECK-FIX-NEXT: 24403c: bd 03 40 f9 ldr x29, [x29]
|
|
173
|
552 // CHECK-FIX-NEXT: 244040: f1 67 ff 17 b 0x21e004
|
|
|
553 // CHECK-FIX: <__CortexA53843419_220004>:
|
|
150
|
554 // CHECK-FIX-NEXT: 244044: bd 07 40 f9 ldr x29, [x29, #8]
|
|
173
|
555 // CHECK-FIX-NEXT: 244048: f0 6f ff 17 b 0x220008
|
|
|
556 // CHECK-FIX: <__CortexA53843419_222004>:
|
|
150
|
557 // CHECK-FIX-NEXT: 24404c: 41 0a 40 f9 ldr x1, [x18, #16]
|
|
173
|
558 // CHECK-FIX-NEXT: 244050: ee 77 ff 17 b 0x222008
|
|
|
559 // CHECK-FIX: <__CortexA53843419_224000>:
|
|
150
|
560 // CHECK-FIX-NEXT: 244054: 52 0e 40 f9 ldr x18, [x18, #24]
|
|
173
|
561 // CHECK-FIX-NEXT: 244058: eb 7f ff 17 b 0x224004
|
|
|
562 // CHECK-FIX: <__CortexA53843419_226004>:
|
|
150
|
563 // CHECK-FIX-NEXT: 24405c: ea 11 40 f9 ldr x10, [x15, #32]
|
|
173
|
564 // CHECK-FIX-NEXT: 244060: ea 87 ff 17 b 0x226008
|
|
|
565 // CHECK-FIX: <__CortexA53843419_228000>:
|
|
150
|
566 // CHECK-FIX-NEXT: 244064: 0d 16 40 f9 ldr x13, [x16, #40]
|
|
173
|
567 // CHECK-FIX-NEXT: 244068: e7 8f ff 17 b 0x228004
|
|
|
568 // CHECK-FIX: <__CortexA53843419_22A004>:
|
|
150
|
569 // CHECK-FIX-NEXT: 24406c: e9 0c 40 f9 ldr x9, [x7, #24]
|
|
173
|
570 // CHECK-FIX-NEXT: 244070: e6 97 ff 17 b 0x22a008
|
|
|
571 // CHECK-FIX: <__CortexA53843419_22C004>:
|
|
150
|
572 // CHECK-FIX-NEXT: 244074: f6 12 40 f9 ldr x22, [x23, #32]
|
|
173
|
573 // CHECK-FIX-NEXT: 244078: e4 9f ff 17 b 0x22c008
|
|
|
574 // CHECK-FIX: <__CortexA53843419_22E000>:
|
|
150
|
575 // CHECK-FIX-NEXT: 24407c: f8 16 40 f9 ldr x24, [x23, #40]
|
|
173
|
576 // CHECK-FIX-NEXT: 244080: e1 a7 ff 17 b 0x22e004
|
|
|
577 // CHECK-FIX: <__CortexA53843419_230004>:
|
|
150
|
578 // CHECK-FIX-NEXT: 244084: 02 00 40 f9 ldr x2, [x0]
|
|
173
|
579 // CHECK-FIX-NEXT: 244088: e0 af ff 17 b 0x230008
|
|
|
580 // CHECK-FIX: <__CortexA53843419_232008>:
|
|
150
|
581 // CHECK-FIX-NEXT: 24408c: 9b 07 00 f9 str x27, [x28, #8]
|
|
173
|
582 // CHECK-FIX-NEXT: 244090: df b7 ff 17 b 0x23200c
|
|
|
583 // CHECK-FIX: <__CortexA53843419_234004>:
|
|
150
|
584 // CHECK-FIX-NEXT: 244094: 0e 0a 40 f9 ldr x14, [x16, #16]
|
|
173
|
585 // CHECK-FIX-NEXT: 244098: dc bf ff 17 b 0x234008
|
|
|
586 // CHECK-FIX: <__CortexA53843419_236004>:
|
|
150
|
587 // CHECK-FIX-NEXT: 24409c: 0e 06 40 f9 ldr x14, [x16, #8]
|
|
173
|
588 // CHECK-FIX-NEXT: 2440a0: da c7 ff 17 b 0x236008
|
|
|
589 // CHECK-FIX: <__CortexA53843419_238004>:
|
|
150
|
590 // CHECK-FIX-NEXT: 2440a4: 0e 06 40 f9 ldr x14, [x16, #8]
|
|
173
|
591 // CHECK-FIX-NEXT: 2440a8: d8 cf ff 17 b 0x238008
|
|
|
592 // CHECK-FIX: <__CortexA53843419_23A008>:
|
|
150
|
593 // CHECK-FIX-NEXT: 2440ac: 0e 06 40 f9 ldr x14, [x16, #8]
|
|
173
|
594 // CHECK-FIX-NEXT: 2440b0: d7 d7 ff 17 b 0x23a00c
|
|
|
595 // CHECK-FIX: <__CortexA53843419_23C008>:
|
|
150
|
596 // CHECK-FIX-NEXT: 2440b4: ea 00 40 f9 ldr x10, [x7]
|
|
173
|
597 // CHECK-FIX-NEXT: 2440b8: d5 df ff 17 b 0x23c00c
|
|
|
598 // CHECK-FIX: <__CortexA53843419_23E008>:
|
|
150
|
599 // CHECK-FIX-NEXT: 2440bc: 18 ff 3f f9 str x24, [x24, #32760]
|
|
173
|
600 // CHECK-FIX-NEXT: 2440c0: d3 e7 ff 17 b 0x23e00c
|
|
|
601 // CHECK-FIX: <__CortexA53843419_240000>:
|
|
150
|
602 // CHECK-FIX-NEXT: 2440c4: 01 08 40 f9 ldr x1, [x0, #16]
|
|
173
|
603 // CHECK-FIX-NEXT: 2440c8: cf ef ff 17 b 0x240004
|
|
|
604 // CHECK-FIX: <__CortexA53843419_242000>:
|
|
150
|
605 // CHECK-FIX-NEXT: 2440cc: 01 08 40 f9 ldr x1, [x0, #16]
|
|
173
|
606 // CHECK-FIX-NEXT: 2440d0: cd f7 ff 17 b 0x242004
|
|
|
607 // CHECK-FIX: <__CortexA53843419_244000>:
|
|
150
|
608 // CHECK-FIX-NEXT: 2440d4: 01 08 40 f9 ldr x1, [x0, #16]
|
|
173
|
609 // CHECK-FIX-NEXT: 2440d8: cb ff ff 17 b 0x244004
|
|
150
|
610 .data
|
|
|
611 .globl dat
|
|
|
612 .globl dat2
|
|
|
613 .globl dat3
|
|
|
614 dat1: .quad 1
|
|
|
615 dat2: .quad 2
|
|
|
616 dat3: .quad 3
|
