?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[InstCombine] Signed saturation patterns
[llvm-core.git] / test / MC / AArch64 / basic-a64-instructions.s
blob6c0c16e3f78e61dbc4a51362a16819b1e0ab8cd0
1 // RUN: llvm-mc -triple aarch64-none-linux-gnu -show-encoding -mattr=+fp-armv8 < %s | FileCheck %s
2 .globl _func
3
4 // Check that the assembler can handle the documented syntax from the ARM ARM.
5 // For complex constructs like shifter operands, check more thoroughly for them
6 // once then spot check that following instructions accept the form generally.
7 // This gives us good coverage while keeping the overall size of the test
8 // more reasonable.
9
10
11 _func:
12 // CHECK: _func
13
14 //------------------------------------------------------------------------------
15 // Add/sub (extended register)
16 //------------------------------------------------------------------------------
17 // Basic extends 64-bit ops
18 add x2, x4, w5, uxtb
19 add x20, sp, w19, uxth
20 add x12, x1, w20, uxtw
21 add x20, x3, x13, uxtx
22 add x17, x25, w20, sxtb
23 add x18, x13, w19, sxth
24 add sp, x2, w3, sxtw
25 add x3, x5, x9, sxtx
26 // CHECK: add x2, x4, w5, uxtb // encoding: [0x82,0x00,0x25,0x8b]
27 // CHECK: add x20, sp, w19, uxth // encoding: [0xf4,0x23,0x33,0x8b]
28 // CHECK: add x12, x1, w20, uxtw // encoding: [0x2c,0x40,0x34,0x8b]
29 // CHECK: add x20, x3, x13, uxtx // encoding: [0x74,0x60,0x2d,0x8b]
30 // CHECK: add x17, x25, w20, sxtb // encoding: [0x31,0x83,0x34,0x8b]
31 // CHECK: add x18, x13, w19, sxth // encoding: [0xb2,0xa1,0x33,0x8b]
32 // CHECK: add sp, x2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0x8b]
33 // CHECK: add x3, x5, x9, sxtx // encoding: [0xa3,0xe0,0x29,0x8b]
34
35 // Basic extends, 32-bit ops
36 add w2, w5, w7, uxtb
37 add w21, w15, w17, uxth
38 add w30, w29, wzr, uxtw
39 add w19, w17, w1, uxtx // Goodness knows what this means
40 add w2, w5, w1, sxtb
41 add w26, w17, w19, sxth
42 add w0, w2, w3, sxtw
43 add w2, w3, w5, sxtx
44 // CHECK: add w2, w5, w7, uxtb // encoding: [0xa2,0x00,0x27,0x0b]
45 // CHECK: add w21, w15, w17, uxth // encoding: [0xf5,0x21,0x31,0x0b]
46 // CHECK: add w30, w29, wzr, uxtw // encoding: [0xbe,0x43,0x3f,0x0b]
47 // CHECK: add w19, w17, w1, uxtx // encoding: [0x33,0x62,0x21,0x0b]
48 // CHECK: add w2, w5, w1, sxtb // encoding: [0xa2,0x80,0x21,0x0b]
49 // CHECK: add w26, w17, w19, sxth // encoding: [0x3a,0xa2,0x33,0x0b]
50 // CHECK: add w0, w2, w3, sxtw // encoding: [0x40,0xc0,0x23,0x0b]
51 // CHECK: add w2, w3, w5, sxtx // encoding: [0x62,0xe0,0x25,0x0b]
52
53 // Nonzero shift amounts
54 add x2, x3, w5, sxtb #0
55 add x7, x11, w13, uxth #4
56 add w17, w19, w23, uxtw #2
57 add w29, w23, w17, uxtx #1
58 // CHECK: add x2, x3, w5, sxtb // encoding: [0x62,0x80,0x25,0x8b]
59 // CHECK: add x7, x11, w13, uxth #4 // encoding: [0x67,0x31,0x2d,0x8b]
60 // CHECK: add w17, w19, w23, uxtw #2 // encoding: [0x71,0x4a,0x37,0x0b]
61 // CHECK: add w29, w23, w17, uxtx #1 // encoding: [0xfd,0x66,0x31,0x0b]
62
63 // Sub
64 sub x2, x4, w5, uxtb #2
65 sub x20, sp, w19, uxth #4
66 sub x12, x1, w20, uxtw
67 sub x20, x3, x13, uxtx #0
68 sub x17, x25, w20, sxtb
69 sub x18, x13, w19, sxth
70 sub sp, x2, w3, sxtw
71 sub x3, x5, x9, sxtx
72 // CHECK: sub x2, x4, w5, uxtb #2 // encoding: [0x82,0x08,0x25,0xcb]
73 // CHECK: sub x20, sp, w19, uxth #4 // encoding: [0xf4,0x33,0x33,0xcb]
74 // CHECK: sub x12, x1, w20, uxtw // encoding: [0x2c,0x40,0x34,0xcb]
75 // CHECK: sub x20, x3, x13, uxtx // encoding: [0x74,0x60,0x2d,0xcb]
76 // CHECK: sub x17, x25, w20, sxtb // encoding: [0x31,0x83,0x34,0xcb]
77 // CHECK: sub x18, x13, w19, sxth // encoding: [0xb2,0xa1,0x33,0xcb]
78 // CHECK: sub sp, x2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0xcb]
79 // CHECK: sub x3, x5, x9, sxtx // encoding: [0xa3,0xe0,0x29,0xcb]
80
81 sub w2, w5, w7, uxtb
82 sub w21, w15, w17, uxth
83 sub w30, w29, wzr, uxtw
84 sub w19, w17, w1, uxtx // Goodness knows what this means
85 sub w2, w5, w1, sxtb
86 sub w26, wsp, w19, sxth
87 sub wsp, w2, w3, sxtw
88 sub w2, w3, w5, sxtx
89 // CHECK: sub w2, w5, w7, uxtb // encoding: [0xa2,0x00,0x27,0x4b]
90 // CHECK: sub w21, w15, w17, uxth // encoding: [0xf5,0x21,0x31,0x4b]
91 // CHECK: sub w30, w29, wzr, uxtw // encoding: [0xbe,0x43,0x3f,0x4b]
92 // CHECK: sub w19, w17, w1, uxtx // encoding: [0x33,0x62,0x21,0x4b]
93 // CHECK: sub w2, w5, w1, sxtb // encoding: [0xa2,0x80,0x21,0x4b]
94 // CHECK: sub w26, wsp, w19, sxth // encoding: [0xfa,0xa3,0x33,0x4b]
95 // CHECK: sub wsp, w2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0x4b]
96 // CHECK: sub w2, w3, w5, sxtx // encoding: [0x62,0xe0,0x25,0x4b]
97
98 // Adds
99 adds x2, x4, w5, uxtb #2
100 adds x20, sp, w19, uxth #4
101 adds x12, x1, w20, uxtw
102 adds x20, x3, x13, uxtx #0
103 adds xzr, x25, w20, sxtb #3
104 adds x18, sp, w19, sxth
105 adds xzr, x2, w3, sxtw
106 adds x3, x5, x9, sxtx #2
107 // CHECK: adds x2, x4, w5, uxtb #2 // encoding: [0x82,0x08,0x25,0xab]
108 // CHECK: adds x20, sp, w19, uxth #4 // encoding: [0xf4,0x33,0x33,0xab]
109 // CHECK: adds x12, x1, w20, uxtw // encoding: [0x2c,0x40,0x34,0xab]
110 // CHECK: adds x20, x3, x13, uxtx // encoding: [0x74,0x60,0x2d,0xab]
111 // CHECK: {{adds xzr,|cmn}} x25, w20, sxtb #3 // encoding: [0x3f,0x8f,0x34,0xab]
112 // CHECK: adds x18, sp, w19, sxth // encoding: [0xf2,0xa3,0x33,0xab]
113 // CHECK: {{adds xzr,|cmn}} x2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0xab]
114 // CHECK: adds x3, x5, x9, sxtx #2 // encoding: [0xa3,0xe8,0x29,0xab]
115
116 adds w2, w5, w7, uxtb
117 adds w21, w15, w17, uxth
118 adds w30, w29, wzr, uxtw
119 adds w19, w17, w1, uxtx // Goodness knows what this means
120 adds w2, w5, w1, sxtb #1
121 adds w26, wsp, w19, sxth
122 adds wzr, w2, w3, sxtw
123 adds w2, w3, w5, sxtx
124 // CHECK: adds w2, w5, w7, uxtb // encoding: [0xa2,0x00,0x27,0x2b]
125 // CHECK: adds w21, w15, w17, uxth // encoding: [0xf5,0x21,0x31,0x2b]
126 // CHECK: adds w30, w29, wzr, uxtw // encoding: [0xbe,0x43,0x3f,0x2b]
127 // CHECK: adds w19, w17, w1, uxtx // encoding: [0x33,0x62,0x21,0x2b]
128 // CHECK: adds w2, w5, w1, sxtb #1 // encoding: [0xa2,0x84,0x21,0x2b]
129 // CHECK: adds w26, wsp, w19, sxth // encoding: [0xfa,0xa3,0x33,0x2b]
130 // CHECK: cmn w2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0x2b]
131 // CHECK: adds w2, w3, w5, sxtx // encoding: [0x62,0xe0,0x25,0x2b]
132
133 // subs
134 subs x2, x4, w5, uxtb #2
135 subs x20, sp, w19, uxth #4
136 subs x12, x1, w20, uxtw
137 subs x20, x3, x13, uxtx #0
138 subs xzr, x25, w20, sxtb #3
139 subs x18, sp, w19, sxth
140 subs xzr, x2, w3, sxtw
141 subs x3, x5, x9, sxtx #2
142 // CHECK: subs x2, x4, w5, uxtb #2 // encoding: [0x82,0x08,0x25,0xeb]
143 // CHECK: subs x20, sp, w19, uxth #4 // encoding: [0xf4,0x33,0x33,0xeb]
144 // CHECK: subs x12, x1, w20, uxtw // encoding: [0x2c,0x40,0x34,0xeb]
145 // CHECK: subs x20, x3, x13, uxtx // encoding: [0x74,0x60,0x2d,0xeb]
146 // CHECK: {{subs xzr,|cmp}} x25, w20, sxtb #3 // encoding: [0x3f,0x8f,0x34,0xeb]
147 // CHECK: subs x18, sp, w19, sxth // encoding: [0xf2,0xa3,0x33,0xeb]
148 // CHECK: {{subs xzr,|cmp}} x2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0xeb]
149 // CHECK: subs x3, x5, x9, sxtx #2 // encoding: [0xa3,0xe8,0x29,0xeb]
150
151 subs w2, w5, w7, uxtb
152 subs w21, w15, w17, uxth
153 subs w30, w29, wzr, uxtw
154 subs w19, w17, w1, uxtx // Goodness knows what this means
155 subs w2, w5, w1, sxtb #1
156 subs w26, wsp, w19, sxth
157 subs wzr, w2, w3, sxtw
158 subs w2, w3, w5, sxtx
159 // CHECK: subs w2, w5, w7, uxtb // encoding: [0xa2,0x00,0x27,0x6b]
160 // CHECK: subs w21, w15, w17, uxth // encoding: [0xf5,0x21,0x31,0x6b]
161 // CHECK: subs w30, w29, wzr, uxtw // encoding: [0xbe,0x43,0x3f,0x6b]
162 // CHECK: subs w19, w17, w1, uxtx // encoding: [0x33,0x62,0x21,0x6b]
163 // CHECK: subs w2, w5, w1, sxtb #1 // encoding: [0xa2,0x84,0x21,0x6b]
164 // CHECK: subs w26, wsp, w19, sxth // encoding: [0xfa,0xa3,0x33,0x6b]
165 // CHECK: {{subs wzr,|cmp}} w2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0x6b]
166 // CHECK: subs w2, w3, w5, sxtx // encoding: [0x62,0xe0,0x25,0x6b]
167
168 // cmp
169 cmp x4, w5, uxtb #2
170 cmp sp, w19, uxth #4
171 cmp x1, w20, uxtw
172 cmp x3, x13, uxtx #0
173 cmp x25, w20, sxtb #3
174 cmp sp, w19, sxth
175 cmp x2, w3, sxtw
176 cmp x5, x9, sxtx #2
177 // CHECK: cmp x4, w5, uxtb #2 // encoding: [0x9f,0x08,0x25,0xeb]
178 // CHECK: cmp sp, w19, uxth #4 // encoding: [0xff,0x33,0x33,0xeb]
179 // CHECK: cmp x1, w20, uxtw // encoding: [0x3f,0x40,0x34,0xeb]
180 // CHECK: cmp x3, x13, uxtx // encoding: [0x7f,0x60,0x2d,0xeb]
181 // CHECK: cmp x25, w20, sxtb #3 // encoding: [0x3f,0x8f,0x34,0xeb]
182 // CHECK: cmp sp, w19, sxth // encoding: [0xff,0xa3,0x33,0xeb]
183 // CHECK: cmp x2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0xeb]
184 // CHECK: cmp x5, x9, sxtx #2 // encoding: [0xbf,0xe8,0x29,0xeb]
185
186 cmp w5, w7, uxtb
187 cmp w15, w17, uxth
188 cmp w29, wzr, uxtw
189 cmp w17, w1, uxtx // Goodness knows what this means
190 cmp w5, w1, sxtb #1
191 cmp wsp, w19, sxth
192 cmp w2, w3, sxtw
193 cmp w3, w5, sxtx
194 // CHECK: cmp w5, w7, uxtb // encoding: [0xbf,0x00,0x27,0x6b]
195 // CHECK: cmp w15, w17, uxth // encoding: [0xff,0x21,0x31,0x6b]
196 // CHECK: cmp w29, wzr, uxtw // encoding: [0xbf,0x43,0x3f,0x6b]
197 // CHECK: cmp w17, w1, uxtx // encoding: [0x3f,0x62,0x21,0x6b]
198 // CHECK: cmp w5, w1, sxtb #1 // encoding: [0xbf,0x84,0x21,0x6b]
199 // CHECK: cmp wsp, w19, sxth // encoding: [0xff,0xa3,0x33,0x6b]
200 // CHECK: cmp w2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0x6b]
201 // CHECK: cmp w3, w5, sxtx // encoding: [0x7f,0xe0,0x25,0x6b]
202
203
204 // cmn
205 cmn x4, w5, uxtb #2
206 cmn sp, w19, uxth #4
207 cmn x1, w20, uxtw
208 cmn x3, x13, uxtx #0
209 cmn x25, w20, sxtb #3
210 cmn sp, w19, sxth
211 cmn x2, w3, sxtw
212 cmn x5, x9, sxtx #2
213 // CHECK: cmn x4, w5, uxtb #2 // encoding: [0x9f,0x08,0x25,0xab]
214 // CHECK: cmn sp, w19, uxth #4 // encoding: [0xff,0x33,0x33,0xab]
215 // CHECK: cmn x1, w20, uxtw // encoding: [0x3f,0x40,0x34,0xab]
216 // CHECK: cmn x3, x13, uxtx // encoding: [0x7f,0x60,0x2d,0xab]
217 // CHECK: cmn x25, w20, sxtb #3 // encoding: [0x3f,0x8f,0x34,0xab]
218 // CHECK: cmn sp, w19, sxth // encoding: [0xff,0xa3,0x33,0xab]
219 // CHECK: cmn x2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0xab]
220 // CHECK: cmn x5, x9, sxtx #2 // encoding: [0xbf,0xe8,0x29,0xab]
221
222 cmn w5, w7, uxtb
223 cmn w15, w17, uxth
224 cmn w29, wzr, uxtw
225 cmn w17, w1, uxtx // Goodness knows what this means
226 cmn w5, w1, sxtb #1
227 cmn wsp, w19, sxth
228 cmn w2, w3, sxtw
229 cmn w3, w5, sxtx
230 // CHECK: {{cmn|adds wzr,}} w5, w7, uxtb // encoding: [0xbf,0x00,0x27,0x2b]
231 // CHECK: {{cmn|adds wzr,}} w15, w17, uxth // encoding: [0xff,0x21,0x31,0x2b]
232 // CHECK: {{cmn|adds wzr,}} w29, wzr, uxtw // encoding: [0xbf,0x43,0x3f,0x2b]
233 // CHECK: {{cmn|adds wzr,}} w17, w1, uxtx // encoding: [0x3f,0x62,0x21,0x2b]
234 // CHECK: {{cmn|adds wzr,}} w5, w1, sxtb #1 // encoding: [0xbf,0x84,0x21,0x2b]
235 // CHECK: {{cmn|adds wzr,}} wsp, w19, sxth // encoding: [0xff,0xa3,0x33,0x2b]
236 // CHECK: {{cmn|adds wzr,}} w2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0x2b]
237 // CHECK: {{cmn|adds wzr,}} w3, w5, sxtx // encoding: [0x7f,0xe0,0x25,0x2b]
238
239 // operands for cmp
240 cmp x20, w29, uxtb #3
241 cmp x12, x13, uxtx #4
242 cmp wsp, w1, uxtb
243 cmn wsp, wzr, sxtw
244 // CHECK: cmp x20, w29, uxtb #3 // encoding: [0x9f,0x0e,0x3d,0xeb]
245 // CHECK: cmp x12, x13, uxtx #4 // encoding: [0x9f,0x71,0x2d,0xeb]
246 // CHECK: cmp wsp, w1, uxtb // encoding: [0xff,0x03,0x21,0x6b]
247 // CHECK: {{cmn|adds wzr,}} wsp, wzr, sxtw // encoding: [0xff,0xc3,0x3f,0x2b]
248
249 // LSL variant if sp involved
250 sub sp, x3, x7, lsl #4
251 add w2, wsp, w3, lsl #1
252 cmp wsp, w9, lsl #0
253 adds wzr, wsp, w3, lsl #4
254 subs x3, sp, x9, lsl #2
255 // CHECK: sub sp, x3, x7, lsl #4 // encoding: [0x7f,0x70,0x27,0xcb]
256 // CHECK: add w2, wsp, w3, lsl #1 // encoding: [0xe2,0x47,0x23,0x0b]
257 // CHECK: cmp wsp, w9 // encoding: [0xff,0x43,0x29,0x6b]
258 // CHECK: cmn wsp, w3, lsl #4 // encoding: [0xff,0x53,0x23,0x2b]
259 // CHECK: subs x3, sp, x9, lsl #2 // encoding: [0xe3,0x6b,0x29,0xeb]
260
261 //------------------------------------------------------------------------------
262 // Add/sub (immediate)
263 //------------------------------------------------------------------------------
264
265 // Check basic immediate values: an unsigned 12-bit immediate, optionally
266 // shifted left by 12 bits.
267 add w4, w5, #0x0
268 add w2, w3, #4095
269 add w30, w29, #1, lsl #12
270 add w13, w5, #4095, lsl #12
271 add x5, x7, #1638
272 // CHECK: add w4, w5, #0 // encoding: [0xa4,0x00,0x00,0x11]
273 // CHECK: add w2, w3, #4095 // encoding: [0x62,0xfc,0x3f,0x11]
274 // CHECK: add w30, w29, #1, lsl #12 // encoding: [0xbe,0x07,0x40,0x11]
275 // CHECK: add w13, w5, #4095, lsl #12 // encoding: [0xad,0xfc,0x7f,0x11]
276 // CHECK: add x5, x7, #1638 // encoding: [0xe5,0x98,0x19,0x91]
277
278 // All registers involved in the non-S variants have 31 encoding sp rather than zr
279 add w20, wsp, #801, lsl #0
280 add wsp, wsp, #1104
281 add wsp, w30, #4084
282 // CHECK: add w20, wsp, #801 // encoding: [0xf4,0x87,0x0c,0x11]
283 // CHECK: add wsp, wsp, #1104 // encoding: [0xff,0x43,0x11,0x11]
284 // CHECK: add wsp, w30, #4084 // encoding: [0xdf,0xd3,0x3f,0x11]
285
286 // A few checks on the sanity of 64-bit versions
287 add x0, x24, #291
288 add x3, x24, #4095, lsl #12
289 add x8, sp, #1074
290 add sp, x29, #3816
291 // CHECK: add x0, x24, #291 // encoding: [0x00,0x8f,0x04,0x91]
292 // CHECK: add x3, x24, #4095, lsl #12 // encoding: [0x03,0xff,0x7f,0x91]
293 // CHECK: add x8, sp, #1074 // encoding: [0xe8,0xcb,0x10,0x91]
294 // CHECK: add sp, x29, #3816 // encoding: [0xbf,0xa3,0x3b,0x91]
295
296 // And on sub
297 sub w0, wsp, #4077
298 sub w4, w20, #546, lsl #12
299 sub sp, sp, #288
300 sub wsp, w19, #16
301 // CHECK: sub w0, wsp, #4077 // encoding: [0xe0,0xb7,0x3f,0x51]
302 // CHECK: sub w4, w20, #546, lsl #12 // encoding: [0x84,0x8a,0x48,0x51]
303 // CHECK: sub sp, sp, #288 // encoding: [0xff,0x83,0x04,0xd1]
304 // CHECK: sub wsp, w19, #16 // encoding: [0x7f,0x42,0x00,0x51]
305
306 // ADDS/SUBS accept zr in the Rd position but sp in the Rn position
307 adds w13, w23, #291, lsl #12
308 adds wzr, w2, #4095 // FIXME: canonically should be cmn
309 adds w20, wsp, #0x0
310 adds xzr, x3, #0x1, lsl #12 // FIXME: canonically should be cmn
311 // CHECK: adds w13, w23, #291, lsl #12 // encoding: [0xed,0x8e,0x44,0x31]
312 // CHECK: {{adds wzr,|cmn}} w2, #4095 // encoding: [0x5f,0xfc,0x3f,0x31]
313 // CHECK: adds w20, wsp, #0 // encoding: [0xf4,0x03,0x00,0x31]
314 // CHECK: {{adds xzr,|cmn}} x3, #1, lsl #12 // encoding: [0x7f,0x04,0x40,0xb1]
315
316 // Checks for subs
317 subs xzr, sp, #20, lsl #12 // FIXME: canonically should be cmp
318 subs xzr, x30, #4095, lsl #0 // FIXME: canonically should be cmp
319 subs x4, sp, #3822
320 // CHECK: {{subs xzr,|cmp}} sp, #20, lsl #12 // encoding: [0xff,0x53,0x40,0xf1]
321 // CHECK: {{subs xzr,|cmp}} x30, #4095 // encoding: [0xdf,0xff,0x3f,0xf1]
322 // CHECK: subs x4, sp, #3822 // encoding: [0xe4,0xbb,0x3b,0xf1]
323
324 // cmn is an alias for adds zr, ...
325 cmn w3, #291, lsl #12
326 cmn wsp, #1365, lsl #0
327 cmn sp, #1092, lsl #12
328 // CHECK: cmn w3, #291, lsl #12 // encoding: [0x7f,0x8c,0x44,0x31]
329 // CHECK: cmn wsp, #1365 // encoding: [0xff,0x57,0x15,0x31]
330 // CHECK: cmn sp, #1092, lsl #12 // encoding: [0xff,0x13,0x51,0xb1]
331
332 // cmp is an alias for subs zr, ... (FIXME: should always disassemble as such too).
333 cmp x4, #300, lsl #12
334 cmp wsp, #500
335 cmp sp, #200, lsl #0
336 // CHECK: cmp x4, #300, lsl #12 // encoding: [0x9f,0xb0,0x44,0xf1]
337 // CHECK: cmp wsp, #500 // encoding: [0xff,0xd3,0x07,0x71]
338 // CHECK: cmp sp, #200 // encoding: [0xff,0x23,0x03,0xf1]
339
340 // A "MOV" involving sp is encoded in this manner: add Reg, Reg, #0
341 mov sp, x30
342 mov wsp, w20
343 mov x11, sp
344 mov w24, wsp
345 // CHECK: mov sp, x30 // encoding: [0xdf,0x03,0x00,0x91]
346 // CHECK: mov wsp, w20 // encoding: [0x9f,0x02,0x00,0x11]
347 // CHECK: mov x11, sp // encoding: [0xeb,0x03,0x00,0x91]
348 // CHECK: mov w24, wsp // encoding: [0xf8,0x03,0x00,0x11]
349
350 // A relocation check (default to lo12, which is the only sane relocation anyway really)
351 add x0, x4, #:lo12:var
352 // CHECK: add x0, x4, :lo12:var // encoding: [0x80,0bAAAAAA00,0b00AAAAAA,0x91]
353 // CHECK: // fixup A - offset: 0, value: :lo12:var, kind: fixup_aarch64_add_imm12
354
355 //------------------------------------------------------------------------------
356 // Add-sub (shifted register)
357 //------------------------------------------------------------------------------
358
359 // As usual, we don't print the canonical forms of many instructions.
360
361 add w3, w5, w7
362 add wzr, w3, w5
363 add w20, wzr, w4
364 add w4, w6, wzr
365 // CHECK: add w3, w5, w7 // encoding: [0xa3,0x00,0x07,0x0b]
366 // CHECK: add wzr, w3, w5 // encoding: [0x7f,0x00,0x05,0x0b]
367 // CHECK: add w20, wzr, w4 // encoding: [0xf4,0x03,0x04,0x0b]
368 // CHECK: add w4, w6, wzr // encoding: [0xc4,0x00,0x1f,0x0b]
369
370 add w11, w13, w15, lsl #0
371 add w9, w3, wzr, lsl #10
372 add w17, w29, w20, lsl #31
373 add w17, w29, w20, lsl #(31-2)
374 // CHECK: add w11, w13, w15 // encoding: [0xab,0x01,0x0f,0x0b]
375 // CHECK: add w9, w3, wzr, lsl #10 // encoding: [0x69,0x28,0x1f,0x0b]
376 // CHECK: add w17, w29, w20, lsl #31 // encoding: [0xb1,0x7f,0x14,0x0b]
377 // CHECK: add w17, w29, w20, lsl #29 // encoding: [0xb1,0x77,0x14,0x0b]
378
379 add w21, w22, w23, lsr #0
380 add w24, w25, w26, lsr #18
381 add w27, w28, w29, lsr #31
382 add w27, w28, w29, lsr #(31-2)
383 // CHECK: add w21, w22, w23, lsr #0 // encoding: [0xd5,0x02,0x57,0x0b]
384 // CHECK: add w24, w25, w26, lsr #18 // encoding: [0x38,0x4b,0x5a,0x0b]
385 // CHECK: add w27, w28, w29, lsr #31 // encoding: [0x9b,0x7f,0x5d,0x0b]
386 // CHECK: add w27, w28, w29, lsr #29 // encoding: [0x9b,0x77,0x5d,0x0b]
387
388 add w2, w3, w4, asr #0
389 add w5, w6, w7, asr #21
390 add w8, w9, w10, asr #31
391 add w8, w9, w10, asr #(31-2)
392 // CHECK: add w2, w3, w4, asr #0 // encoding: [0x62,0x00,0x84,0x0b]
393 // CHECK: add w5, w6, w7, asr #21 // encoding: [0xc5,0x54,0x87,0x0b]
394 // CHECK: add w8, w9, w10, asr #31 // encoding: [0x28,0x7d,0x8a,0x0b]
395 // CHECK: add w8, w9, w10, asr #29 // encoding: [0x28,0x75,0x8a,0x0b]
396
397 add x3, x5, x7
398 add xzr, x3, x5
399 add x20, xzr, x4
400 add x4, x6, xzr
401 // CHECK: add x3, x5, x7 // encoding: [0xa3,0x00,0x07,0x8b]
402 // CHECK: add xzr, x3, x5 // encoding: [0x7f,0x00,0x05,0x8b]
403 // CHECK: add x20, xzr, x4 // encoding: [0xf4,0x03,0x04,0x8b]
404 // CHECK: add x4, x6, xzr // encoding: [0xc4,0x00,0x1f,0x8b]
405
406 add x11, x13, x15, lsl #0
407 add x9, x3, xzr, lsl #10
408 add x17, x29, x20, lsl #63
409 add x17, x29, x20, lsl #(63-5)
410 // CHECK: add x11, x13, x15 // encoding: [0xab,0x01,0x0f,0x8b]
411 // CHECK: add x9, x3, xzr, lsl #10 // encoding: [0x69,0x28,0x1f,0x8b]
412 // CHECK: add x17, x29, x20, lsl #63 // encoding: [0xb1,0xff,0x14,0x8b]
413 // CHECK: add x17, x29, x20, lsl #58 // encoding: [0xb1,0xeb,0x14,0x8b]
414
415 add x21, x22, x23, lsr #0
416 add x24, x25, x26, lsr #18
417 add x27, x28, x29, lsr #63
418 add x17, x29, x20, lsr #(63-5)
419 // CHECK: add x21, x22, x23, lsr #0 // encoding: [0xd5,0x02,0x57,0x8b]
420 // CHECK: add x24, x25, x26, lsr #18 // encoding: [0x38,0x4b,0x5a,0x8b]
421 // CHECK: add x27, x28, x29, lsr #63 // encoding: [0x9b,0xff,0x5d,0x8b]
422 // CHECK: add x17, x29, x20, lsr #58 // encoding: [0xb1,0xeb,0x54,0x8b]
423
424 add x2, x3, x4, asr #0
425 add x5, x6, x7, asr #21
426 add x8, x9, x10, asr #63
427 add x17, x29, x20, asr #(63-5)
428 // CHECK: add x2, x3, x4, asr #0 // encoding: [0x62,0x00,0x84,0x8b]
429 // CHECK: add x5, x6, x7, asr #21 // encoding: [0xc5,0x54,0x87,0x8b]
430 // CHECK: add x8, x9, x10, asr #63 // encoding: [0x28,0xfd,0x8a,0x8b]
431 // CHECK: add x17, x29, x20, asr #58 // encoding: [0xb1,0xeb,0x94,0x8b]
432
433 adds w3, w5, w7
434 adds wzr, w3, w5
435 adds w20, wzr, w4
436 adds w4, w6, wzr
437 // CHECK: adds w3, w5, w7 // encoding: [0xa3,0x00,0x07,0x2b]
438 // CHECK: {{adds wzr,|cmn}} w3, w5 // encoding: [0x7f,0x00,0x05,0x2b]
439 // CHECK: adds w20, wzr, w4 // encoding: [0xf4,0x03,0x04,0x2b]
440 // CHECK: adds w4, w6, wzr // encoding: [0xc4,0x00,0x1f,0x2b]
441
442 adds w11, w13, w15, lsl #0
443 adds w9, w3, wzr, lsl #10
444 adds w17, w29, w20, lsl #31
445 // CHECK: adds w11, w13, w15 // encoding: [0xab,0x01,0x0f,0x2b]
446 // CHECK: adds w9, w3, wzr, lsl #10 // encoding: [0x69,0x28,0x1f,0x2b]
447 // CHECK: adds w17, w29, w20, lsl #31 // encoding: [0xb1,0x7f,0x14,0x2b]
448
449 adds w21, w22, w23, lsr #0
450 adds w24, w25, w26, lsr #18
451 adds w27, w28, w29, lsr #31
452 // CHECK: adds w21, w22, w23, lsr #0 // encoding: [0xd5,0x02,0x57,0x2b]
453 // CHECK: adds w24, w25, w26, lsr #18 // encoding: [0x38,0x4b,0x5a,0x2b]
454 // CHECK: adds w27, w28, w29, lsr #31 // encoding: [0x9b,0x7f,0x5d,0x2b]
455
456 adds w2, w3, w4, asr #0
457 adds w5, w6, w7, asr #21
458 adds w8, w9, w10, asr #31
459 // CHECK: adds w2, w3, w4, asr #0 // encoding: [0x62,0x00,0x84,0x2b]
460 // CHECK: adds w5, w6, w7, asr #21 // encoding: [0xc5,0x54,0x87,0x2b]
461 // CHECK: adds w8, w9, w10, asr #31 // encoding: [0x28,0x7d,0x8a,0x2b]
462
463 adds x3, x5, x7
464 adds xzr, x3, x5
465 adds x20, xzr, x4
466 adds x4, x6, xzr
467 // CHECK: adds x3, x5, x7 // encoding: [0xa3,0x00,0x07,0xab]
468 // CHECK: {{adds xzr,|cmn}} x3, x5 // encoding: [0x7f,0x00,0x05,0xab]
469 // CHECK: adds x20, xzr, x4 // encoding: [0xf4,0x03,0x04,0xab]
470 // CHECK: adds x4, x6, xzr // encoding: [0xc4,0x00,0x1f,0xab]
471
472 adds x11, x13, x15, lsl #0
473 adds x9, x3, xzr, lsl #10
474 adds x17, x29, x20, lsl #63
475 // CHECK: adds x11, x13, x15 // encoding: [0xab,0x01,0x0f,0xab]
476 // CHECK: adds x9, x3, xzr, lsl #10 // encoding: [0x69,0x28,0x1f,0xab]
477 // CHECK: adds x17, x29, x20, lsl #63 // encoding: [0xb1,0xff,0x14,0xab]
478
479 adds x21, x22, x23, lsr #0
480 adds x24, x25, x26, lsr #18
481 adds x27, x28, x29, lsr #63
482 // CHECK: adds x21, x22, x23, lsr #0 // encoding: [0xd5,0x02,0x57,0xab]
483 // CHECK: adds x24, x25, x26, lsr #18 // encoding: [0x38,0x4b,0x5a,0xab]
484 // CHECK: adds x27, x28, x29, lsr #63 // encoding: [0x9b,0xff,0x5d,0xab]
485
486 adds x2, x3, x4, asr #0
487 adds x5, x6, x7, asr #21
488 adds x8, x9, x10, asr #63
489 // CHECK: adds x2, x3, x4, asr #0 // encoding: [0x62,0x00,0x84,0xab]
490 // CHECK: adds x5, x6, x7, asr #21 // encoding: [0xc5,0x54,0x87,0xab]
491 // CHECK: adds x8, x9, x10, asr #63 // encoding: [0x28,0xfd,0x8a,0xab]
492
493 sub w3, w5, w7
494 sub wzr, w3, w5
495 sub w20, wzr, w4
496 sub w4, w6, wzr
497 // CHECK: sub w3, w5, w7 // encoding: [0xa3,0x00,0x07,0x4b]
498 // CHECK: sub wzr, w3, w5 // encoding: [0x7f,0x00,0x05,0x4b]
499 // CHECK: neg w20, w4 // encoding: [0xf4,0x03,0x04,0x4b]
500 // CHECK: sub w4, w6, wzr // encoding: [0xc4,0x00,0x1f,0x4b]
501
502 sub w11, w13, w15, lsl #0
503 sub w9, w3, wzr, lsl #10
504 sub w17, w29, w20, lsl #31
505 // CHECK: sub w11, w13, w15 // encoding: [0xab,0x01,0x0f,0x4b]
506 // CHECK: sub w9, w3, wzr, lsl #10 // encoding: [0x69,0x28,0x1f,0x4b]
507 // CHECK: sub w17, w29, w20, lsl #31 // encoding: [0xb1,0x7f,0x14,0x4b]
508
509 sub w21, w22, w23, lsr #0
510 sub w24, w25, w26, lsr #18
511 sub w27, w28, w29, lsr #31
512 // CHECK: sub w21, w22, w23, lsr #0 // encoding: [0xd5,0x02,0x57,0x4b]
513 // CHECK: sub w24, w25, w26, lsr #18 // encoding: [0x38,0x4b,0x5a,0x4b]
514 // CHECK: sub w27, w28, w29, lsr #31 // encoding: [0x9b,0x7f,0x5d,0x4b]
515
516 sub w2, w3, w4, asr #0
517 sub w5, w6, w7, asr #21
518 sub w8, w9, w10, asr #31
519 // CHECK: sub w2, w3, w4, asr #0 // encoding: [0x62,0x00,0x84,0x4b]
520 // CHECK: sub w5, w6, w7, asr #21 // encoding: [0xc5,0x54,0x87,0x4b]
521 // CHECK: sub w8, w9, w10, asr #31 // encoding: [0x28,0x7d,0x8a,0x4b]
522
523 sub x3, x5, x7
524 sub xzr, x3, x5
525 sub x20, xzr, x4
526 sub x4, x6, xzr
527 // CHECK: sub x3, x5, x7 // encoding: [0xa3,0x00,0x07,0xcb]
528 // CHECK: sub xzr, x3, x5 // encoding: [0x7f,0x00,0x05,0xcb]
529 // CHECK: neg x20, x4 // encoding: [0xf4,0x03,0x04,0xcb]
530 // CHECK: sub x4, x6, xzr // encoding: [0xc4,0x00,0x1f,0xcb]
531
532 sub x11, x13, x15, lsl #0
533 sub x9, x3, xzr, lsl #10
534 sub x17, x29, x20, lsl #63
535 // CHECK: sub x11, x13, x15 // encoding: [0xab,0x01,0x0f,0xcb]
536 // CHECK: sub x9, x3, xzr, lsl #10 // encoding: [0x69,0x28,0x1f,0xcb]
537 // CHECK: sub x17, x29, x20, lsl #63 // encoding: [0xb1,0xff,0x14,0xcb]
538
539 sub x21, x22, x23, lsr #0
540 sub x24, x25, x26, lsr #18
541 sub x27, x28, x29, lsr #63
542 // CHECK: sub x21, x22, x23, lsr #0 // encoding: [0xd5,0x02,0x57,0xcb]
543 // CHECK: sub x24, x25, x26, lsr #18 // encoding: [0x38,0x4b,0x5a,0xcb]
544 // CHECK: sub x27, x28, x29, lsr #63 // encoding: [0x9b,0xff,0x5d,0xcb]
545
546 sub x2, x3, x4, asr #0
547 sub x5, x6, x7, asr #21
548 sub x8, x9, x10, asr #63
549 // CHECK: sub x2, x3, x4, asr #0 // encoding: [0x62,0x00,0x84,0xcb]
550 // CHECK: sub x5, x6, x7, asr #21 // encoding: [0xc5,0x54,0x87,0xcb]
551 // CHECK: sub x8, x9, x10, asr #63 // encoding: [0x28,0xfd,0x8a,0xcb]
552
553 subs w3, w5, w7
554 subs wzr, w3, w5
555 subs w20, wzr, w4
556 subs w4, w6, wzr
557 // CHECK: subs w3, w5, w7 // encoding: [0xa3,0x00,0x07,0x6b]
558 // CHECK: {{subs wzr,|cmp}} w3, w5 // encoding: [0x7f,0x00,0x05,0x6b]
559 // CHECK: negs w20, w4 // encoding: [0xf4,0x03,0x04,0x6b]
560 // CHECK: subs w4, w6, wzr // encoding: [0xc4,0x00,0x1f,0x6b]
561
562 subs w11, w13, w15, lsl #0
563 subs w9, w3, wzr, lsl #10
564 subs w17, w29, w20, lsl #31
565 // CHECK: subs w11, w13, w15 // encoding: [0xab,0x01,0x0f,0x6b]
566 // CHECK: subs w9, w3, wzr, lsl #10 // encoding: [0x69,0x28,0x1f,0x6b]
567 // CHECK: subs w17, w29, w20, lsl #31 // encoding: [0xb1,0x7f,0x14,0x6b]
568
569 subs w21, w22, w23, lsr #0
570 subs w24, w25, w26, lsr #18
571 subs w27, w28, w29, lsr #31
572 // CHECK: subs w21, w22, w23, lsr #0 // encoding: [0xd5,0x02,0x57,0x6b]
573 // CHECK: subs w24, w25, w26, lsr #18 // encoding: [0x38,0x4b,0x5a,0x6b]
574 // CHECK: subs w27, w28, w29, lsr #31 // encoding: [0x9b,0x7f,0x5d,0x6b]
575
576 subs w2, w3, w4, asr #0
577 subs w5, w6, w7, asr #21
578 subs w8, w9, w10, asr #31
579 // CHECK: subs w2, w3, w4, asr #0 // encoding: [0x62,0x00,0x84,0x6b]
580 // CHECK: subs w5, w6, w7, asr #21 // encoding: [0xc5,0x54,0x87,0x6b]
581 // CHECK: subs w8, w9, w10, asr #31 // encoding: [0x28,0x7d,0x8a,0x6b]
582
583 subs x3, x5, x7
584 subs xzr, x3, x5
585 subs x20, xzr, x4
586 subs x4, x6, xzr
587 // CHECK: subs x3, x5, x7 // encoding: [0xa3,0x00,0x07,0xeb]
588 // CHECK: {{subs xzr,|cmp}} x3, x5 // encoding: [0x7f,0x00,0x05,0xeb]
589 // CHECK: negs x20, x4 // encoding: [0xf4,0x03,0x04,0xeb]
590 // CHECK: subs x4, x6, xzr // encoding: [0xc4,0x00,0x1f,0xeb]
591
592 subs x11, x13, x15, lsl #0
593 subs x9, x3, xzr, lsl #10
594 subs x17, x29, x20, lsl #63
595 // CHECK: subs x11, x13, x15 // encoding: [0xab,0x01,0x0f,0xeb]
596 // CHECK: subs x9, x3, xzr, lsl #10 // encoding: [0x69,0x28,0x1f,0xeb]
597 // CHECK: subs x17, x29, x20, lsl #63 // encoding: [0xb1,0xff,0x14,0xeb]
598
599 subs x21, x22, x23, lsr #0
600 subs x24, x25, x26, lsr #18
601 subs x27, x28, x29, lsr #63
602 // CHECK: subs x21, x22, x23, lsr #0 // encoding: [0xd5,0x02,0x57,0xeb]
603 // CHECK: subs x24, x25, x26, lsr #18 // encoding: [0x38,0x4b,0x5a,0xeb]
604 // CHECK: subs x27, x28, x29, lsr #63 // encoding: [0x9b,0xff,0x5d,0xeb]
605
606 subs x2, x3, x4, asr #0
607 subs x5, x6, x7, asr #21
608 subs x8, x9, x10, asr #63
609 // CHECK: subs x2, x3, x4, asr #0 // encoding: [0x62,0x00,0x84,0xeb]
610 // CHECK: subs x5, x6, x7, asr #21 // encoding: [0xc5,0x54,0x87,0xeb]
611 // CHECK: subs x8, x9, x10, asr #63 // encoding: [0x28,0xfd,0x8a,0xeb]
612
613 cmn w0, w3
614 cmn wzr, w4
615 cmn w5, wzr
616 cmn wsp, w6
617 // CHECK: cmn w0, w3 // encoding: [0x1f,0x00,0x03,0x2b]
618 // CHECK: cmn wzr, w4 // encoding: [0xff,0x03,0x04,0x2b]
619 // CHECK: cmn w5, wzr // encoding: [0xbf,0x00,0x1f,0x2b]
620 // CHECK: cmn wsp, w6 // encoding: [0xff,0x43,0x26,0x2b]
621
622 cmn w6, w7, lsl #0
623 cmn w8, w9, lsl #15
624 cmn w10, w11, lsl #31
625 // CHECK: cmn w6, w7 // encoding: [0xdf,0x00,0x07,0x2b]
626 // CHECK: cmn w8, w9, lsl #15 // encoding: [0x1f,0x3d,0x09,0x2b]
627 // CHECK: cmn w10, w11, lsl #31 // encoding: [0x5f,0x7d,0x0b,0x2b]
628
629 cmn w12, w13, lsr #0
630 cmn w14, w15, lsr #21
631 cmn w16, w17, lsr #31
632 // CHECK: cmn w12, w13, lsr #0 // encoding: [0x9f,0x01,0x4d,0x2b]
633 // CHECK: cmn w14, w15, lsr #21 // encoding: [0xdf,0x55,0x4f,0x2b]
634 // CHECK: cmn w16, w17, lsr #31 // encoding: [0x1f,0x7e,0x51,0x2b]
635
636 cmn w18, w19, asr #0
637 cmn w20, w21, asr #22
638 cmn w22, w23, asr #31
639 // CHECK: cmn w18, w19, asr #0 // encoding: [0x5f,0x02,0x93,0x2b]
640 // CHECK: cmn w20, w21, asr #22 // encoding: [0x9f,0x5a,0x95,0x2b]
641 // CHECK: cmn w22, w23, asr #31 // encoding: [0xdf,0x7e,0x97,0x2b]
642
643 cmn x0, x3
644 cmn xzr, x4
645 cmn x5, xzr
646 cmn sp, x6
647 // CHECK: cmn x0, x3 // encoding: [0x1f,0x00,0x03,0xab]
648 // CHECK: cmn xzr, x4 // encoding: [0xff,0x03,0x04,0xab]
649 // CHECK: cmn x5, xzr // encoding: [0xbf,0x00,0x1f,0xab]
650 // CHECK: cmn sp, x6 // encoding: [0xff,0x63,0x26,0xab]
651
652 cmn x6, x7, lsl #0
653 cmn x8, x9, lsl #15
654 cmn x10, x11, lsl #63
655 // CHECK: cmn x6, x7 // encoding: [0xdf,0x00,0x07,0xab]
656 // CHECK: cmn x8, x9, lsl #15 // encoding: [0x1f,0x3d,0x09,0xab]
657 // CHECK: cmn x10, x11, lsl #63 // encoding: [0x5f,0xfd,0x0b,0xab]
658
659 cmn x12, x13, lsr #0
660 cmn x14, x15, lsr #41
661 cmn x16, x17, lsr #63
662 // CHECK: cmn x12, x13, lsr #0 // encoding: [0x9f,0x01,0x4d,0xab]
663 // CHECK: cmn x14, x15, lsr #41 // encoding: [0xdf,0xa5,0x4f,0xab]
664 // CHECK: cmn x16, x17, lsr #63 // encoding: [0x1f,0xfe,0x51,0xab]
665
666 cmn x18, x19, asr #0
667 cmn x20, x21, asr #55
668 cmn x22, x23, asr #63
669 // CHECK: cmn x18, x19, asr #0 // encoding: [0x5f,0x02,0x93,0xab]
670 // CHECK: cmn x20, x21, asr #55 // encoding: [0x9f,0xde,0x95,0xab]
671 // CHECK: cmn x22, x23, asr #63 // encoding: [0xdf,0xfe,0x97,0xab]
672
673 cmp w0, w3
674 cmp wzr, w4
675 cmp w5, wzr
676 cmp wsp, w6
677 // CHECK: cmp w0, w3 // encoding: [0x1f,0x00,0x03,0x6b]
678 // CHECK: cmp wzr, w4 // encoding: [0xff,0x03,0x04,0x6b]
679 // CHECK: cmp w5, wzr // encoding: [0xbf,0x00,0x1f,0x6b]
680 // CHECK: cmp wsp, w6 // encoding: [0xff,0x43,0x26,0x6b]
681
682 cmp w6, w7, lsl #0
683 cmp w8, w9, lsl #15
684 cmp w10, w11, lsl #31
685 // CHECK: cmp w6, w7 // encoding: [0xdf,0x00,0x07,0x6b]
686 // CHECK: cmp w8, w9, lsl #15 // encoding: [0x1f,0x3d,0x09,0x6b]
687 // CHECK: cmp w10, w11, lsl #31 // encoding: [0x5f,0x7d,0x0b,0x6b]
688
689 cmp w12, w13, lsr #0
690 cmp w14, w15, lsr #21
691 cmp w16, w17, lsr #31
692 // CHECK: cmp w12, w13, lsr #0 // encoding: [0x9f,0x01,0x4d,0x6b]
693 // CHECK: cmp w14, w15, lsr #21 // encoding: [0xdf,0x55,0x4f,0x6b]
694 // CHECK: cmp w16, w17, lsr #31 // encoding: [0x1f,0x7e,0x51,0x6b]
695
696 cmp w18, w19, asr #0
697 cmp w20, w21, asr #22
698 cmp w22, w23, asr #31
699 // CHECK: cmp w18, w19, asr #0 // encoding: [0x5f,0x02,0x93,0x6b]
700 // CHECK: cmp w20, w21, asr #22 // encoding: [0x9f,0x5a,0x95,0x6b]
701 // CHECK: cmp w22, w23, asr #31 // encoding: [0xdf,0x7e,0x97,0x6b]
702
703 cmp x0, x3
704 cmp xzr, x4
705 cmp x5, xzr
706 cmp sp, x6
707 // CHECK: cmp x0, x3 // encoding: [0x1f,0x00,0x03,0xeb]
708 // CHECK: cmp xzr, x4 // encoding: [0xff,0x03,0x04,0xeb]
709 // CHECK: cmp x5, xzr // encoding: [0xbf,0x00,0x1f,0xeb]
710 // CHECK: cmp sp, x6 // encoding: [0xff,0x63,0x26,0xeb]
711
712 cmp x6, x7, lsl #0
713 cmp x8, x9, lsl #15
714 cmp x10, x11, lsl #63
715 // CHECK: cmp x6, x7 // encoding: [0xdf,0x00,0x07,0xeb]
716 // CHECK: cmp x8, x9, lsl #15 // encoding: [0x1f,0x3d,0x09,0xeb]
717 // CHECK: cmp x10, x11, lsl #63 // encoding: [0x5f,0xfd,0x0b,0xeb]
718
719 cmp x12, x13, lsr #0
720 cmp x14, x15, lsr #41
721 cmp x16, x17, lsr #63
722 // CHECK: cmp x12, x13, lsr #0 // encoding: [0x9f,0x01,0x4d,0xeb]
723 // CHECK: cmp x14, x15, lsr #41 // encoding: [0xdf,0xa5,0x4f,0xeb]
724 // CHECK: cmp x16, x17, lsr #63 // encoding: [0x1f,0xfe,0x51,0xeb]
725
726 cmp x18, x19, asr #0
727 cmp x20, x21, asr #55
728 cmp x22, x23, asr #63
729 // CHECK: cmp x18, x19, asr #0 // encoding: [0x5f,0x02,0x93,0xeb]
730 // CHECK: cmp x20, x21, asr #55 // encoding: [0x9f,0xde,0x95,0xeb]
731 // CHECK: cmp x22, x23, asr #63 // encoding: [0xdf,0xfe,0x97,0xeb]
732
733 neg w29, w30
734 neg w30, wzr
735 neg wzr, w0
736 // CHECK: neg w29, w30 // encoding: [0xfd,0x03,0x1e,0x4b]
737 // CHECK: neg w30, wzr // encoding: [0xfe,0x03,0x1f,0x4b]
738 // CHECK: neg wzr, w0 // encoding: [0xff,0x03,0x00,0x4b]
739
740 neg w28, w27, lsl #0
741 neg w26, w25, lsl #29
742 neg w24, w23, lsl #31
743
744 // CHECK: neg w28, w27 // encoding: [0xfc,0x03,0x1b,0x4b]
745 // CHECK: neg w26, w25, lsl #29 // encoding: [0xfa,0x77,0x19,0x4b]
746 // CHECK: neg w24, w23, lsl #31 // encoding: [0xf8,0x7f,0x17,0x4b]
747
748 neg w22, w21, lsr #0
749 neg w20, w19, lsr #1
750 neg w18, w17, lsr #31
751 // CHECK: neg w22, w21, lsr #0 // encoding: [0xf6,0x03,0x55,0x4b]
752 // CHECK: neg w20, w19, lsr #1 // encoding: [0xf4,0x07,0x53,0x4b]
753 // CHECK: neg w18, w17, lsr #31 // encoding: [0xf2,0x7f,0x51,0x4b]
754
755 neg w16, w15, asr #0
756 neg w14, w13, asr #12
757 neg w12, w11, asr #31
758 // CHECK: neg w16, w15, asr #0 // encoding: [0xf0,0x03,0x8f,0x4b]
759 // CHECK: neg w14, w13, asr #12 // encoding: [0xee,0x33,0x8d,0x4b]
760 // CHECK: neg w12, w11, asr #31 // encoding: [0xec,0x7f,0x8b,0x4b]
761
762 neg x29, x30
763 neg x30, xzr
764 neg xzr, x0
765 // CHECK: neg x29, x30 // encoding: [0xfd,0x03,0x1e,0xcb]
766 // CHECK: neg x30, xzr // encoding: [0xfe,0x03,0x1f,0xcb]
767 // CHECK: neg xzr, x0 // encoding: [0xff,0x03,0x00,0xcb]
768
769 neg x28, x27, lsl #0
770 neg x26, x25, lsl #29
771 neg x24, x23, lsl #31
772
773 // CHECK: neg x28, x27 // encoding: [0xfc,0x03,0x1b,0xcb]
774 // CHECK: neg x26, x25, lsl #29 // encoding: [0xfa,0x77,0x19,0xcb]
775 // CHECK: neg x24, x23, lsl #31 // encoding: [0xf8,0x7f,0x17,0xcb]
776
777 neg x22, x21, lsr #0
778 neg x20, x19, lsr #1
779 neg x18, x17, lsr #31
780 // CHECK: neg x22, x21, lsr #0 // encoding: [0xf6,0x03,0x55,0xcb]
781 // CHECK: neg x20, x19, lsr #1 // encoding: [0xf4,0x07,0x53,0xcb]
782 // CHECK: neg x18, x17, lsr #31 // encoding: [0xf2,0x7f,0x51,0xcb]
783
784 neg x16, x15, asr #0
785 neg x14, x13, asr #12
786 neg x12, x11, asr #31
787 // CHECK: neg x16, x15, asr #0 // encoding: [0xf0,0x03,0x8f,0xcb]
788 // CHECK: neg x14, x13, asr #12 // encoding: [0xee,0x33,0x8d,0xcb]
789 // CHECK: neg x12, x11, asr #31 // encoding: [0xec,0x7f,0x8b,0xcb]
790
791 negs w29, w30
792 negs w30, wzr
793 negs wzr, w0
794 // CHECK: negs w29, w30 // encoding: [0xfd,0x03,0x1e,0x6b]
795 // CHECK: negs w30, wzr // encoding: [0xfe,0x03,0x1f,0x6b]
796 // CHECK: cmp wzr, w0 // encoding: [0xff,0x03,0x00,0x6b]
797
798 negs w28, w27, lsl #0
799 negs w26, w25, lsl #29
800 negs w24, w23, lsl #31
801
802 // CHECK: negs w28, w27 // encoding: [0xfc,0x03,0x1b,0x6b]
803 // CHECK: negs w26, w25, lsl #29 // encoding: [0xfa,0x77,0x19,0x6b]
804 // CHECK: negs w24, w23, lsl #31 // encoding: [0xf8,0x7f,0x17,0x6b]
805
806 negs w22, w21, lsr #0
807 negs w20, w19, lsr #1
808 negs w18, w17, lsr #31
809 // CHECK: negs w22, w21, lsr #0 // encoding: [0xf6,0x03,0x55,0x6b]
810 // CHECK: negs w20, w19, lsr #1 // encoding: [0xf4,0x07,0x53,0x6b]
811 // CHECK: negs w18, w17, lsr #31 // encoding: [0xf2,0x7f,0x51,0x6b]
812
813 negs w16, w15, asr #0
814 negs w14, w13, asr #12
815 negs w12, w11, asr #31
816 // CHECK: negs w16, w15, asr #0 // encoding: [0xf0,0x03,0x8f,0x6b]
817 // CHECK: negs w14, w13, asr #12 // encoding: [0xee,0x33,0x8d,0x6b]
818 // CHECK: negs w12, w11, asr #31 // encoding: [0xec,0x7f,0x8b,0x6b]
819
820 negs x29, x30
821 negs x30, xzr
822 negs xzr, x0
823 // CHECK: negs x29, x30 // encoding: [0xfd,0x03,0x1e,0xeb]
824 // CHECK: negs x30, xzr // encoding: [0xfe,0x03,0x1f,0xeb]
825 // CHECK: cmp xzr, x0 // encoding: [0xff,0x03,0x00,0xeb]
826
827 negs x28, x27, lsl #0
828 negs x26, x25, lsl #29
829 negs x24, x23, lsl #31
830
831 // CHECK: negs x28, x27 // encoding: [0xfc,0x03,0x1b,0xeb]
832 // CHECK: negs x26, x25, lsl #29 // encoding: [0xfa,0x77,0x19,0xeb]
833 // CHECK: negs x24, x23, lsl #31 // encoding: [0xf8,0x7f,0x17,0xeb]
834
835 negs x22, x21, lsr #0
836 negs x20, x19, lsr #1
837 negs x18, x17, lsr #31
838 // CHECK: negs x22, x21, lsr #0 // encoding: [0xf6,0x03,0x55,0xeb]
839 // CHECK: negs x20, x19, lsr #1 // encoding: [0xf4,0x07,0x53,0xeb]
840 // CHECK: negs x18, x17, lsr #31 // encoding: [0xf2,0x7f,0x51,0xeb]
841
842 negs x16, x15, asr #0
843 negs x14, x13, asr #12
844 negs x12, x11, asr #31
845 // CHECK: negs x16, x15, asr #0 // encoding: [0xf0,0x03,0x8f,0xeb]
846 // CHECK: negs x14, x13, asr #12 // encoding: [0xee,0x33,0x8d,0xeb]
847 // CHECK: negs x12, x11, asr #31 // encoding: [0xec,0x7f,0x8b,0xeb]
848
849 //------------------------------------------------------------------------------
850 // Add-sub (shifted register)
851 //------------------------------------------------------------------------------
852 adc w29, w27, w25
853 adc wzr, w3, w4
854 adc w9, wzr, w10
855 adc w20, w0, wzr
856 // CHECK: adc w29, w27, w25 // encoding: [0x7d,0x03,0x19,0x1a]
857 // CHECK: adc wzr, w3, w4 // encoding: [0x7f,0x00,0x04,0x1a]
858 // CHECK: adc w9, wzr, w10 // encoding: [0xe9,0x03,0x0a,0x1a]
859 // CHECK: adc w20, w0, wzr // encoding: [0x14,0x00,0x1f,0x1a]
860
861 adc x29, x27, x25
862 adc xzr, x3, x4
863 adc x9, xzr, x10
864 adc x20, x0, xzr
865 // CHECK: adc x29, x27, x25 // encoding: [0x7d,0x03,0x19,0x9a]
866 // CHECK: adc xzr, x3, x4 // encoding: [0x7f,0x00,0x04,0x9a]
867 // CHECK: adc x9, xzr, x10 // encoding: [0xe9,0x03,0x0a,0x9a]
868 // CHECK: adc x20, x0, xzr // encoding: [0x14,0x00,0x1f,0x9a]
869
870 adcs w29, w27, w25
871 adcs wzr, w3, w4
872 adcs w9, wzr, w10
873 adcs w20, w0, wzr
874 // CHECK: adcs w29, w27, w25 // encoding: [0x7d,0x03,0x19,0x3a]
875 // CHECK: adcs wzr, w3, w4 // encoding: [0x7f,0x00,0x04,0x3a]
876 // CHECK: adcs w9, wzr, w10 // encoding: [0xe9,0x03,0x0a,0x3a]
877 // CHECK: adcs w20, w0, wzr // encoding: [0x14,0x00,0x1f,0x3a]
878
879 adcs x29, x27, x25
880 adcs xzr, x3, x4
881 adcs x9, xzr, x10
882 adcs x20, x0, xzr
883 // CHECK: adcs x29, x27, x25 // encoding: [0x7d,0x03,0x19,0xba]
884 // CHECK: adcs xzr, x3, x4 // encoding: [0x7f,0x00,0x04,0xba]
885 // CHECK: adcs x9, xzr, x10 // encoding: [0xe9,0x03,0x0a,0xba]
886 // CHECK: adcs x20, x0, xzr // encoding: [0x14,0x00,0x1f,0xba]
887
888 sbc w29, w27, w25
889 sbc wzr, w3, w4
890 sbc w9, wzr, w10
891 sbc w20, w0, wzr
892 // CHECK: sbc w29, w27, w25 // encoding: [0x7d,0x03,0x19,0x5a]
893 // CHECK: sbc wzr, w3, w4 // encoding: [0x7f,0x00,0x04,0x5a]
894 // CHECK: ngc w9, w10 // encoding: [0xe9,0x03,0x0a,0x5a]
895 // CHECK: sbc w20, w0, wzr // encoding: [0x14,0x00,0x1f,0x5a]
896
897 sbc x29, x27, x25
898 sbc xzr, x3, x4
899 sbc x9, xzr, x10
900 sbc x20, x0, xzr
901 // CHECK: sbc x29, x27, x25 // encoding: [0x7d,0x03,0x19,0xda]
902 // CHECK: sbc xzr, x3, x4 // encoding: [0x7f,0x00,0x04,0xda]
903 // CHECK: ngc x9, x10 // encoding: [0xe9,0x03,0x0a,0xda]
904 // CHECK: sbc x20, x0, xzr // encoding: [0x14,0x00,0x1f,0xda]
905
906 sbcs w29, w27, w25
907 sbcs wzr, w3, w4
908 sbcs w9, wzr, w10
909 sbcs w20, w0, wzr
910 // CHECK: sbcs w29, w27, w25 // encoding: [0x7d,0x03,0x19,0x7a]
911 // CHECK: sbcs wzr, w3, w4 // encoding: [0x7f,0x00,0x04,0x7a]
912 // CHECK: ngcs w9, w10 // encoding: [0xe9,0x03,0x0a,0x7a]
913 // CHECK: sbcs w20, w0, wzr // encoding: [0x14,0x00,0x1f,0x7a]
914
915 sbcs x29, x27, x25
916 sbcs xzr, x3, x4
917 sbcs x9, xzr, x10
918 sbcs x20, x0, xzr
919 // CHECK: sbcs x29, x27, x25 // encoding: [0x7d,0x03,0x19,0xfa]
920 // CHECK: sbcs xzr, x3, x4 // encoding: [0x7f,0x00,0x04,0xfa]
921 // CHECK: ngcs x9, x10 // encoding: [0xe9,0x03,0x0a,0xfa]
922 // CHECK: sbcs x20, x0, xzr // encoding: [0x14,0x00,0x1f,0xfa]
923
924 ngc w3, w12
925 ngc wzr, w9
926 ngc w23, wzr
927 // CHECK: ngc w3, w12 // encoding: [0xe3,0x03,0x0c,0x5a]
928 // CHECK: ngc wzr, w9 // encoding: [0xff,0x03,0x09,0x5a]
929 // CHECK: ngc w23, wzr // encoding: [0xf7,0x03,0x1f,0x5a]
930
931 ngc x29, x30
932 ngc xzr, x0
933 ngc x0, xzr
934 // CHECK: ngc x29, x30 // encoding: [0xfd,0x03,0x1e,0xda]
935 // CHECK: ngc xzr, x0 // encoding: [0xff,0x03,0x00,0xda]
936 // CHECK: ngc x0, xzr // encoding: [0xe0,0x03,0x1f,0xda]
937
938 ngcs w3, w12
939 ngcs wzr, w9
940 ngcs w23, wzr
941 // CHECK: ngcs w3, w12 // encoding: [0xe3,0x03,0x0c,0x7a]
942 // CHECK: ngcs wzr, w9 // encoding: [0xff,0x03,0x09,0x7a]
943 // CHECK: ngcs w23, wzr // encoding: [0xf7,0x03,0x1f,0x7a]
944
945 ngcs x29, x30
946 ngcs xzr, x0
947 ngcs x0, xzr
948 // CHECK: ngcs x29, x30 // encoding: [0xfd,0x03,0x1e,0xfa]
949 // CHECK: ngcs xzr, x0 // encoding: [0xff,0x03,0x00,0xfa]
950 // CHECK: ngcs x0, xzr // encoding: [0xe0,0x03,0x1f,0xfa]
951
952 //------------------------------------------------------------------------------
953 // Bitfield
954 //------------------------------------------------------------------------------
955
956 sbfm x1, x2, #3, #4
957 sbfm x3, x4, #63, #63
958 sbfm wzr, wzr, #31, #31
959 sbfm w12, w9, #0, #0
960
961 // CHECK: sbfx x1, x2, #3, #2 // encoding: [0x41,0x10,0x43,0x93]
962 // CHECK: asr x3, x4, #63 // encoding: [0x83,0xfc,0x7f,0x93]
963 // CHECK: asr wzr, wzr, #31 // encoding: [0xff,0x7f,0x1f,0x13]
964 // CHECK: sbfx w12, w9, #0, #1 // encoding: [0x2c,0x01,0x00,0x13]
965
966 ubfm x4, x5, #12, #10
967 ubfm xzr, x4, #0, #0
968 ubfm x4, xzr, #63, #5
969 ubfm x5, x6, #12, #63
970 // CHECK: ubfiz x4, x5, #52, #11 // encoding: [0xa4,0x28,0x4c,0xd3]
971 // CHECK: ubfx xzr, x4, #0, #1 // encoding: [0x9f,0x00,0x40,0xd3]
972 // CHECK: ubfiz x4, xzr, #1, #6 // encoding: [0xe4,0x17,0x7f,0xd3]
973 // CHECK: lsr x5, x6, #12 // encoding: [0xc5,0xfc,0x4c,0xd3]
974
975 bfm x4, x5, #12, #10
976 bfm xzr, x4, #0, #0
977 bfm x4, xzr, #63, #5
978 bfm x5, x6, #12, #63
979 // CHECK: bfi x4, x5, #52, #11 // encoding: [0xa4,0x28,0x4c,0xb3]
980 // CHECK: bfxil xzr, x4, #0, #1 // encoding: [0x9f,0x00,0x40,0xb3]
981 // CHECK: bfi x4, xzr, #1, #6 // encoding: [0xe4,0x17,0x7f,0xb3]
982 // CHECK: bfxil x5, x6, #12, #52 // encoding: [0xc5,0xfc,0x4c,0xb3]
983
984 sxtb w1, w2
985 sxtb xzr, w3
986 sxth w9, w10
987 sxth x0, w1
988 sxtw x3, w30
989 // CHECK: sxtb w1, w2 // encoding: [0x41,0x1c,0x00,0x13]
990 // CHECK: sxtb xzr, w3 // encoding: [0x7f,0x1c,0x40,0x93]
991 // CHECK: sxth w9, w10 // encoding: [0x49,0x3d,0x00,0x13]
992 // CHECK: sxth x0, w1 // encoding: [0x20,0x3c,0x40,0x93]
993 // CHECK: sxtw x3, w30 // encoding: [0xc3,0x7f,0x40,0x93]
994
995 uxtb w1, w2
996 uxtb xzr, w3
997 uxth w9, w10
998 uxth x0, w1
999 // CHECK: uxtb w1, w2 // encoding: [0x41,0x1c,0x00,0x53]
1000 // CHECK: uxtb {{[wx]}}zr, w3 // encoding: [0x7f,0x1c,0x00,0x53]
1001 // CHECK: uxth w9, w10 // encoding: [0x49,0x3d,0x00,0x53]
1002 // CHECK: uxth {{[wx]}}0, w1 // encoding: [0x20,0x3c,0x00,0x53]
1003
1004 asr w3, w2, #0
1005 asr w9, w10, #31
1006 asr x20, x21, #63
1007 asr w1, wzr, #3
1008 // CHECK: asr w3, w2, #0 // encoding: [0x43,0x7c,0x00,0x13]
1009 // CHECK: asr w9, w10, #31 // encoding: [0x49,0x7d,0x1f,0x13]
1010 // CHECK: asr x20, x21, #63 // encoding: [0xb4,0xfe,0x7f,0x93]
1011 // CHECK: asr w1, wzr, #3 // encoding: [0xe1,0x7f,0x03,0x13]
1012
1013 lsr w3, w2, #0
1014 lsr w9, w10, #31
1015 lsr x20, x21, #63
1016 lsr wzr, wzr, #3
1017 // CHECK: lsr w3, w2, #0 // encoding: [0x43,0x7c,0x00,0x53]
1018 // CHECK: lsr w9, w10, #31 // encoding: [0x49,0x7d,0x1f,0x53]
1019 // CHECK: lsr x20, x21, #63 // encoding: [0xb4,0xfe,0x7f,0xd3]
1020 // CHECK: lsr wzr, wzr, #3 // encoding: [0xff,0x7f,0x03,0x53]
1021
1022 lsl w3, w2, #0
1023 lsl w9, w10, #31
1024 lsl x20, x21, #63
1025 lsl w1, wzr, #3
1026 // CHECK: {{lsl|lsr}} w3, w2, #0 // encoding: [0x43,0x7c,0x00,0x53]
1027 // CHECK: lsl w9, w10, #31 // encoding: [0x49,0x01,0x01,0x53]
1028 // CHECK: lsl x20, x21, #63 // encoding: [0xb4,0x02,0x41,0xd3]
1029 // CHECK: lsl w1, wzr, #3 // encoding: [0xe1,0x73,0x1d,0x53]
1030
1031 sbfiz w9, w10, #0, #1
1032 sbfiz x2, x3, #63, #1
1033 sbfiz x19, x20, #0, #64
1034 sbfiz x9, x10, #5, #59
1035 sbfiz w9, w10, #0, #32
1036 sbfiz w11, w12, #31, #1
1037 sbfiz w13, w14, #29, #3
1038 sbfiz xzr, xzr, #10, #11
1039 // CHECK: {{sbfiz|sbfx}} w9, w10, #0, #1 // encoding: [0x49,0x01,0x00,0x13]
1040 // CHECK: sbfiz x2, x3, #63, #1 // encoding: [0x62,0x00,0x41,0x93]
1041 // CHECK: asr x19, x20, #0 // encoding: [0x93,0xfe,0x40,0x93]
1042 // CHECK: sbfiz x9, x10, #5, #59 // encoding: [0x49,0xe9,0x7b,0x93]
1043 // CHECK: asr w9, w10, #0 // encoding: [0x49,0x7d,0x00,0x13]
1044 // CHECK: sbfiz w11, w12, #31, #1 // encoding: [0x8b,0x01,0x01,0x13]
1045 // CHECK: sbfiz w13, w14, #29, #3 // encoding: [0xcd,0x09,0x03,0x13]
1046 // CHECK: sbfiz xzr, xzr, #10, #11 // encoding: [0xff,0x2b,0x76,0x93]
1047
1048 sbfx w9, w10, #0, #1
1049 sbfx x2, x3, #63, #1
1050 sbfx x19, x20, #0, #64
1051 sbfx x9, x10, #5, #59
1052 sbfx w9, w10, #0, #32
1053 sbfx w11, w12, #31, #1
1054 sbfx w13, w14, #29, #3
1055 sbfx xzr, xzr, #10, #11
1056 // CHECK: sbfx w9, w10, #0, #1 // encoding: [0x49,0x01,0x00,0x13]
1057 // CHECK: asr x2, x3, #63 // encoding: [0x62,0xfc,0x7f,0x93]
1058 // CHECK: asr x19, x20, #0 // encoding: [0x93,0xfe,0x40,0x93]
1059 // CHECK: asr x9, x10, #5 // encoding: [0x49,0xfd,0x45,0x93]
1060 // CHECK: asr w9, w10, #0 // encoding: [0x49,0x7d,0x00,0x13]
1061 // CHECK: asr w11, w12, #31 // encoding: [0x8b,0x7d,0x1f,0x13]
1062 // CHECK: asr w13, w14, #29 // encoding: [0xcd,0x7d,0x1d,0x13]
1063 // CHECK: sbfx xzr, xzr, #10, #11 // encoding: [0xff,0x53,0x4a,0x93]
1064
1065 bfi w9, w10, #0, #1
1066 bfi x2, x3, #63, #1
1067 bfi x19, x20, #0, #64
1068 bfi x9, x10, #5, #59
1069 bfi w9, w10, #0, #32
1070 bfi w11, w12, #31, #1
1071 bfi w13, w14, #29, #3
1072 bfi xzr, xzr, #10, #11
1073
1074 // CHECK: bfxil w9, w10, #0, #1 // encoding: [0x49,0x01,0x00,0x33]
1075 // CHECK: bfi x2, x3, #63, #1 // encoding: [0x62,0x00,0x41,0xb3]
1076 // CHECK: bfxil x19, x20, #0, #64 // encoding: [0x93,0xfe,0x40,0xb3]
1077 // CHECK: bfi x9, x10, #5, #59 // encoding: [0x49,0xe9,0x7b,0xb3]
1078 // CHECK: bfxil w9, w10, #0, #32 // encoding: [0x49,0x7d,0x00,0x33]
1079 // CHECK: bfi w11, w12, #31, #1 // encoding: [0x8b,0x01,0x01,0x33]
1080 // CHECK: bfi w13, w14, #29, #3 // encoding: [0xcd,0x09,0x03,0x33]
1081 // CHECK: bfi xzr, xzr, #10, #11 // encoding: [0xff,0x2b,0x76,0xb3]
1082
1083 bfxil w9, w10, #0, #1
1084 bfxil x2, x3, #63, #1
1085 bfxil x19, x20, #0, #64
1086 bfxil x9, x10, #5, #59
1087 bfxil w9, w10, #0, #32
1088 bfxil w11, w12, #31, #1
1089 bfxil w13, w14, #29, #3
1090 bfxil xzr, xzr, #10, #11
1091 // CHECK: bfxil w9, w10, #0, #1 // encoding: [0x49,0x01,0x00,0x33]
1092 // CHECK: bfxil x2, x3, #63, #1 // encoding: [0x62,0xfc,0x7f,0xb3]
1093 // CHECK: bfxil x19, x20, #0, #64 // encoding: [0x93,0xfe,0x40,0xb3]
1094 // CHECK: bfxil x9, x10, #5, #59 // encoding: [0x49,0xfd,0x45,0xb3]
1095 // CHECK: bfxil w9, w10, #0, #32 // encoding: [0x49,0x7d,0x00,0x33]
1096 // CHECK: bfxil w11, w12, #31, #1 // encoding: [0x8b,0x7d,0x1f,0x33]
1097 // CHECK: bfxil w13, w14, #29, #3 // encoding: [0xcd,0x7d,0x1d,0x33]
1098 // CHECK: bfxil xzr, xzr, #10, #11 // encoding: [0xff,0x53,0x4a,0xb3]
1099
1100 ubfiz w9, w10, #0, #1
1101 ubfiz x2, x3, #63, #1
1102 ubfiz x19, x20, #0, #64
1103 ubfiz x9, x10, #5, #59
1104 ubfiz w9, w10, #0, #32
1105 ubfiz w11, w12, #31, #1
1106 ubfiz w13, w14, #29, #3
1107 ubfiz xzr, xzr, #10, #11
1108
1109 // CHECK: ubfx w9, w10, #0, #1 // encoding: [0x49,0x01,0x00,0x53]
1110 // CHECK: lsl x2, x3, #63 // encoding: [0x62,0x00,0x41,0xd3]
1111 // CHECK: lsr x19, x20, #0 // encoding: [0x93,0xfe,0x40,0xd3]
1112 // CHECK: lsl x9, x10, #5 // encoding: [0x49,0xe9,0x7b,0xd3]
1113 // CHECK: lsr w9, w10, #0 // encoding: [0x49,0x7d,0x00,0x53]
1114 // CHECK: lsl w11, w12, #31 // encoding: [0x8b,0x01,0x01,0x53]
1115 // CHECK: lsl w13, w14, #29 // encoding: [0xcd,0x09,0x03,0x53]
1116 // CHECK: ubfiz xzr, xzr, #10, #11 // encoding: [0xff,0x2b,0x76,0xd3]
1117
1118 ubfx w9, w10, #0, #1
1119 ubfx x2, x3, #63, #1
1120 ubfx x19, x20, #0, #64
1121 ubfx x9, x10, #5, #59
1122 ubfx w9, w10, #0, #32
1123 ubfx w11, w12, #31, #1
1124 ubfx w13, w14, #29, #3
1125 ubfx xzr, xzr, #10, #11
1126
1127 // CHECK: ubfx w9, w10, #0, #1 // encoding: [0x49,0x01,0x00,0x53]
1128 // CHECK: lsr x2, x3, #63 // encoding: [0x62,0xfc,0x7f,0xd3]
1129 // CHECK: lsr x19, x20, #0 // encoding: [0x93,0xfe,0x40,0xd3]
1130 // CHECK: lsr x9, x10, #5 // encoding: [0x49,0xfd,0x45,0xd3]
1131 // CHECK: lsr w9, w10, #0 // encoding: [0x49,0x7d,0x00,0x53]
1132 // CHECK: lsr w11, w12, #31 // encoding: [0x8b,0x7d,0x1f,0x53]
1133 // CHECK: lsr w13, w14, #29 // encoding: [0xcd,0x7d,0x1d,0x53]
1134 // CHECK: ubfx xzr, xzr, #10, #11 // encoding: [0xff,0x53,0x4a,0xd3]
1135
1136 bfc w3, #0, #32
1137 bfc wzr, #31, #1
1138 bfc x0, #5, #9
1139 bfc xzr, #63, #1
1140 // CHECK: bfxil w3, wzr, #0, #32 // encoding: [0xe3,0x7f,0x00,0x33]
1141 // CHECK: bfi wzr, wzr, #31, #1 // encoding: [0xff,0x03,0x01,0x33]
1142 // CHECK: bfi x0, xzr, #5, #9 // encoding: [0xe0,0x23,0x7b,0xb3]
1143 // CHECK: bfi xzr, xzr, #63, #1 // encoding: [0xff,0x03,0x41,0xb3]
1144
1145 //------------------------------------------------------------------------------
1146 // Compare & branch (immediate)
1147 //------------------------------------------------------------------------------
1148
1149 cbz w5, lbl
1150 cbz x5, lbl
1151 cbnz x2, lbl
1152 cbnz x26, lbl
1153 // CHECK: cbz w5, lbl // encoding: [0bAAA00101,A,A,0x34]
1154 // CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_aarch64_pcrel_branch19
1155 // CHECK: cbz x5, lbl // encoding: [0bAAA00101,A,A,0xb4]
1156 // CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_aarch64_pcrel_branch19
1157 // CHECK: cbnz x2, lbl // encoding: [0bAAA00010,A,A,0xb5]
1158 // CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_aarch64_pcrel_branch19
1159 // CHECK: cbnz x26, lbl // encoding: [0bAAA11010,A,A,0xb5]
1160 // CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_aarch64_pcrel_branch19
1161
1162 cbz wzr, lbl
1163 cbnz xzr, lbl
1164
1165 // CHECK: cbz wzr, lbl // encoding: [0bAAA11111,A,A,0x34]
1166 // CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_aarch64_pcrel_branch19
1167 // CHECK: cbnz xzr, lbl // encoding: [0bAAA11111,A,A,0xb5]
1168 // CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_aarch64_pcrel_branch19
1169
1170 cbz w5, #0
1171 cbnz x3, #-4
1172 cbz w20, #1048572
1173 cbnz xzr, #-1048576
1174 // CHECK: cbz w5, #0 // encoding: [0x05,0x00,0x00,0x34]
1175 // CHECK: cbnz x3, #-4 // encoding: [0xe3,0xff,0xff,0xb5]
1176 // CHECK: cbz w20, #1048572 // encoding: [0xf4,0xff,0x7f,0x34]
1177 // CHECK: cbnz xzr, #-1048576 // encoding: [0x1f,0x00,0x80,0xb5]
1178
1179 //------------------------------------------------------------------------------
1180 // Conditional branch (immediate)
1181 //------------------------------------------------------------------------------
1182
1183 b.eq lbl
1184 b.ne lbl
1185 b.cs lbl
1186 b.hs lbl
1187 b.lo lbl
1188 b.cc lbl
1189 b.mi lbl
1190 b.pl lbl
1191 b.vs lbl
1192 b.vc lbl
1193 b.hi lbl
1194 b.ls lbl
1195 b.ge lbl
1196 b.lt lbl
1197 b.gt lbl
1198 b.le lbl
1199 b.al lbl
1200
1201 // CHECK: b.eq lbl // encoding: [0bAAA00000,A,A,0x54]
1202 // CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_aarch64_pcrel_branch19
1203 // CHECK: b.ne lbl // encoding: [0bAAA00001,A,A,0x54]
1204 // CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_aarch64_pcrel_branch19
1205 // CHECK: b.hs lbl // encoding: [0bAAA00010,A,A,0x54]
1206 // CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_aarch64_pcrel_branch19
1207 // CHECK: b.hs lbl // encoding: [0bAAA00010,A,A,0x54]
1208 // CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_aarch64_pcrel_branch19
1209 // CHECK: b.lo lbl // encoding: [0bAAA00011,A,A,0x54]
1210 // CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_aarch64_pcrel_branch19
1211 // CHECK: b.lo lbl // encoding: [0bAAA00011,A,A,0x54]
1212 // CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_aarch64_pcrel_branch19
1213 // CHECK: b.mi lbl // encoding: [0bAAA00100,A,A,0x54]
1214 // CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_aarch64_pcrel_branch19
1215 // CHECK: b.pl lbl // encoding: [0bAAA00101,A,A,0x54]
1216 // CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_aarch64_pcrel_branch19
1217 // CHECK: b.vs lbl // encoding: [0bAAA00110,A,A,0x54]
1218 // CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_aarch64_pcrel_branch19
1219 // CHECK: b.vc lbl // encoding: [0bAAA00111,A,A,0x54]
1220 // CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_aarch64_pcrel_branch19
1221 // CHECK: b.hi lbl // encoding: [0bAAA01000,A,A,0x54]
1222 // CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_aarch64_pcrel_branch19
1223 // CHECK: b.ls lbl // encoding: [0bAAA01001,A,A,0x54]
1224 // CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_aarch64_pcrel_branch19
1225 // CHECK: b.ge lbl // encoding: [0bAAA01010,A,A,0x54]
1226 // CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_aarch64_pcrel_branch19
1227 // CHECK: b.lt lbl // encoding: [0bAAA01011,A,A,0x54]
1228 // CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_aarch64_pcrel_branch19
1229 // CHECK: b.gt lbl // encoding: [0bAAA01100,A,A,0x54]
1230 // CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_aarch64_pcrel_branch19
1231 // CHECK: b.le lbl // encoding: [0bAAA01101,A,A,0x54]
1232 // CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_aarch64_pcrel_branch19
1233 // CHECK: b.al lbl // encoding: [0bAAA01110,A,A,0x54]
1234 // CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_aarch64_pcrel_branch19
1235
1236 // ARM64 has these in a separate file
1237 beq lbl
1238 bne lbl
1239 bcs lbl
1240 bhs lbl
1241 blo lbl
1242 bcc lbl
1243 bmi lbl
1244 bpl lbl
1245 bvs lbl
1246 bvc lbl
1247 bhi lbl
1248 bls lbl
1249 bge lbl
1250 blt lbl
1251 bgt lbl
1252 ble lbl
1253 bal lbl
1254
1255 b.eq #0
1256 b.lt #-4
1257 b.cc #1048572
1258 // CHECK: b.eq #0 // encoding: [0x00,0x00,0x00,0x54]
1259 // CHECK: b.lt #-4 // encoding: [0xeb,0xff,0xff,0x54]
1260 // CHECK: b.lo #1048572 // encoding: [0xe3,0xff,0x7f,0x54]
1261
1262 //------------------------------------------------------------------------------
1263 // Conditional compare (immediate)
1264 //------------------------------------------------------------------------------
1265
1266 ccmp w1, #31, #0, eq
1267 ccmp w3, #0, #15, hs
1268 ccmp wzr, #15, #13, cs
1269 // CHECK: ccmp w1, #31, #0, eq // encoding: [0x20,0x08,0x5f,0x7a]
1270 // CHECK: ccmp w3, #0, #15, hs // encoding: [0x6f,0x28,0x40,0x7a]
1271 // CHECK: ccmp wzr, #15, #13, hs // encoding: [0xed,0x2b,0x4f,0x7a]
1272
1273 ccmp x9, #31, #0, le
1274 ccmp x3, #0, #15, gt
1275 ccmp xzr, #5, #7, ne
1276 // CHECK: ccmp x9, #31, #0, le // encoding: [0x20,0xd9,0x5f,0xfa]
1277 // CHECK: ccmp x3, #0, #15, gt // encoding: [0x6f,0xc8,0x40,0xfa]
1278 // CHECK: ccmp xzr, #5, #7, ne // encoding: [0xe7,0x1b,0x45,0xfa]
1279
1280 ccmn w1, #31, #0, eq
1281 ccmn w3, #0, #15, hs
1282 ccmn wzr, #15, #13, cs
1283 // CHECK: ccmn w1, #31, #0, eq // encoding: [0x20,0x08,0x5f,0x3a]
1284 // CHECK: ccmn w3, #0, #15, hs // encoding: [0x6f,0x28,0x40,0x3a]
1285 // CHECK: ccmn wzr, #15, #13, hs // encoding: [0xed,0x2b,0x4f,0x3a]
1286
1287 ccmn x9, #31, #0, le
1288 ccmn x3, #0, #15, gt
1289 ccmn xzr, #5, #7, ne
1290 // CHECK: ccmn x9, #31, #0, le // encoding: [0x20,0xd9,0x5f,0xba]
1291 // CHECK: ccmn x3, #0, #15, gt // encoding: [0x6f,0xc8,0x40,0xba]
1292 // CHECK: ccmn xzr, #5, #7, ne // encoding: [0xe7,0x1b,0x45,0xba]
1293
1294 //------------------------------------------------------------------------------
1295 // Conditional compare (register)
1296 //------------------------------------------------------------------------------
1297
1298 ccmp w1, wzr, #0, eq
1299 ccmp w3, w0, #15, hs
1300 ccmp wzr, w15, #13, cs
1301 // CHECK: ccmp w1, wzr, #0, eq // encoding: [0x20,0x00,0x5f,0x7a]
1302 // CHECK: ccmp w3, w0, #15, hs // encoding: [0x6f,0x20,0x40,0x7a]
1303 // CHECK: ccmp wzr, w15, #13, hs // encoding: [0xed,0x23,0x4f,0x7a]
1304
1305 ccmp x9, xzr, #0, le
1306 ccmp x3, x0, #15, gt
1307 ccmp xzr, x5, #7, ne
1308 // CHECK: ccmp x9, xzr, #0, le // encoding: [0x20,0xd1,0x5f,0xfa]
1309 // CHECK: ccmp x3, x0, #15, gt // encoding: [0x6f,0xc0,0x40,0xfa]
1310 // CHECK: ccmp xzr, x5, #7, ne // encoding: [0xe7,0x13,0x45,0xfa]
1311
1312 ccmn w1, wzr, #0, eq
1313 ccmn w3, w0, #15, hs
1314 ccmn wzr, w15, #13, cs
1315 // CHECK: ccmn w1, wzr, #0, eq // encoding: [0x20,0x00,0x5f,0x3a]
1316 // CHECK: ccmn w3, w0, #15, hs // encoding: [0x6f,0x20,0x40,0x3a]
1317 // CHECK: ccmn wzr, w15, #13, hs // encoding: [0xed,0x23,0x4f,0x3a]
1318
1319 ccmn x9, xzr, #0, le
1320 ccmn x3, x0, #15, gt
1321 ccmn xzr, x5, #7, ne
1322 // CHECK: ccmn x9, xzr, #0, le // encoding: [0x20,0xd1,0x5f,0xba]
1323 // CHECK: ccmn x3, x0, #15, gt // encoding: [0x6f,0xc0,0x40,0xba]
1324 // CHECK: ccmn xzr, x5, #7, ne // encoding: [0xe7,0x13,0x45,0xba]
1325
1326 //------------------------------------------------------------------------------
1327 // Conditional select
1328 //------------------------------------------------------------------------------
1329 csel w1, w0, w19, ne
1330 csel wzr, w5, w9, eq
1331 csel w9, wzr, w30, gt
1332 csel w1, w28, wzr, mi
1333 // CHECK: csel w1, w0, w19, ne // encoding: [0x01,0x10,0x93,0x1a]
1334 // CHECK: csel wzr, w5, w9, eq // encoding: [0xbf,0x00,0x89,0x1a]
1335 // CHECK: csel w9, wzr, w30, gt // encoding: [0xe9,0xc3,0x9e,0x1a]
1336 // CHECK: csel w1, w28, wzr, mi // encoding: [0x81,0x43,0x9f,0x1a]
1337
1338 csel x19, x23, x29, lt
1339 csel xzr, x3, x4, ge
1340 csel x5, xzr, x6, cs
1341 csel x7, x8, xzr, cc
1342 // CHECK: csel x19, x23, x29, lt // encoding: [0xf3,0xb2,0x9d,0x9a]
1343 // CHECK: csel xzr, x3, x4, ge // encoding: [0x7f,0xa0,0x84,0x9a]
1344 // CHECK: csel x5, xzr, x6, hs // encoding: [0xe5,0x23,0x86,0x9a]
1345 // CHECK: csel x7, x8, xzr, lo // encoding: [0x07,0x31,0x9f,0x9a]
1346
1347 csinc w1, w0, w19, ne
1348 csinc wzr, w5, w9, eq
1349 csinc w9, wzr, w30, gt
1350 csinc w1, w28, wzr, mi
1351 // CHECK: csinc w1, w0, w19, ne // encoding: [0x01,0x14,0x93,0x1a]
1352 // CHECK: csinc wzr, w5, w9, eq // encoding: [0xbf,0x04,0x89,0x1a]
1353 // CHECK: csinc w9, wzr, w30, gt // encoding: [0xe9,0xc7,0x9e,0x1a]
1354 // CHECK: csinc w1, w28, wzr, mi // encoding: [0x81,0x47,0x9f,0x1a]
1355
1356 csinc x19, x23, x29, lt
1357 csinc xzr, x3, x4, ge
1358 csinc x5, xzr, x6, cs
1359 csinc x7, x8, xzr, cc
1360 // CHECK: csinc x19, x23, x29, lt // encoding: [0xf3,0xb6,0x9d,0x9a]
1361 // CHECK: csinc xzr, x3, x4, ge // encoding: [0x7f,0xa4,0x84,0x9a]
1362 // CHECK: csinc x5, xzr, x6, hs // encoding: [0xe5,0x27,0x86,0x9a]
1363 // CHECK: csinc x7, x8, xzr, lo // encoding: [0x07,0x35,0x9f,0x9a]
1364
1365 csinv w1, w0, w19, ne
1366 csinv wzr, w5, w9, eq
1367 csinv w9, wzr, w30, gt
1368 csinv w1, w28, wzr, mi
1369 // CHECK: csinv w1, w0, w19, ne // encoding: [0x01,0x10,0x93,0x5a]
1370 // CHECK: csinv wzr, w5, w9, eq // encoding: [0xbf,0x00,0x89,0x5a]
1371 // CHECK: csinv w9, wzr, w30, gt // encoding: [0xe9,0xc3,0x9e,0x5a]
1372 // CHECK: csinv w1, w28, wzr, mi // encoding: [0x81,0x43,0x9f,0x5a]
1373
1374 csinv x19, x23, x29, lt
1375 csinv xzr, x3, x4, ge
1376 csinv x5, xzr, x6, cs
1377 csinv x7, x8, xzr, cc
1378 // CHECK: csinv x19, x23, x29, lt // encoding: [0xf3,0xb2,0x9d,0xda]
1379 // CHECK: csinv xzr, x3, x4, ge // encoding: [0x7f,0xa0,0x84,0xda]
1380 // CHECK: csinv x5, xzr, x6, hs // encoding: [0xe5,0x23,0x86,0xda]
1381 // CHECK: csinv x7, x8, xzr, lo // encoding: [0x07,0x31,0x9f,0xda]
1382
1383 csneg w1, w0, w19, ne
1384 csneg wzr, w5, w9, eq
1385 csneg w9, wzr, w30, gt
1386 csneg w1, w28, wzr, mi
1387 // CHECK: csneg w1, w0, w19, ne // encoding: [0x01,0x14,0x93,0x5a]
1388 // CHECK: csneg wzr, w5, w9, eq // encoding: [0xbf,0x04,0x89,0x5a]
1389 // CHECK: csneg w9, wzr, w30, gt // encoding: [0xe9,0xc7,0x9e,0x5a]
1390 // CHECK: csneg w1, w28, wzr, mi // encoding: [0x81,0x47,0x9f,0x5a]
1391
1392 csneg x19, x23, x29, lt
1393 csneg xzr, x3, x4, ge
1394 csneg x5, xzr, x6, cs
1395 csneg x7, x8, xzr, cc
1396 // CHECK: csneg x19, x23, x29, lt // encoding: [0xf3,0xb6,0x9d,0xda]
1397 // CHECK: csneg xzr, x3, x4, ge // encoding: [0x7f,0xa4,0x84,0xda]
1398 // CHECK: csneg x5, xzr, x6, hs // encoding: [0xe5,0x27,0x86,0xda]
1399 // CHECK: csneg x7, x8, xzr, lo // encoding: [0x07,0x35,0x9f,0xda]
1400
1401 cset w3, eq
1402 cset x9, pl
1403 // CHECK: cset w3, eq // encoding: [0xe3,0x17,0x9f,0x1a]
1404 // CHECK: cset x9, pl // encoding: [0xe9,0x47,0x9f,0x9a]
1405
1406 csetm w20, ne
1407 csetm x30, ge
1408 // CHECK: csetm w20, ne // encoding: [0xf4,0x03,0x9f,0x5a]
1409 // CHECK: csetm x30, ge // encoding: [0xfe,0xb3,0x9f,0xda]
1410
1411 cinc w3, w5, gt
1412 cinc wzr, w4, le
1413 cinc w9, wzr, lt
1414 // CHECK: cinc w3, w5, gt // encoding: [0xa3,0xd4,0x85,0x1a]
1415 // CHECK: cinc wzr, w4, le // encoding: [0x9f,0xc4,0x84,0x1a]
1416 // CHECK: cset w9, lt // encoding: [0xe9,0xa7,0x9f,0x1a]
1417
1418 cinc x3, x5, gt
1419 cinc xzr, x4, le
1420 cinc x9, xzr, lt
1421 // CHECK: cinc x3, x5, gt // encoding: [0xa3,0xd4,0x85,0x9a]
1422 // CHECK: cinc xzr, x4, le // encoding: [0x9f,0xc4,0x84,0x9a]
1423 // CHECK: cset x9, lt // encoding: [0xe9,0xa7,0x9f,0x9a]
1424
1425 cinv w3, w5, gt
1426 cinv wzr, w4, le
1427 cinv w9, wzr, lt
1428 // CHECK: cinv w3, w5, gt // encoding: [0xa3,0xd0,0x85,0x5a]
1429 // CHECK: cinv wzr, w4, le // encoding: [0x9f,0xc0,0x84,0x5a]
1430 // CHECK: csetm w9, lt // encoding: [0xe9,0xa3,0x9f,0x5a]
1431
1432 cinv x3, x5, gt
1433 cinv xzr, x4, le
1434 cinv x9, xzr, lt
1435 // CHECK: cinv x3, x5, gt // encoding: [0xa3,0xd0,0x85,0xda]
1436 // CHECK: cinv xzr, x4, le // encoding: [0x9f,0xc0,0x84,0xda]
1437 // CHECK: csetm x9, lt // encoding: [0xe9,0xa3,0x9f,0xda]
1438
1439 cneg w3, w5, gt
1440 cneg wzr, w4, le
1441 cneg w9, wzr, lt
1442 // CHECK: cneg w3, w5, gt // encoding: [0xa3,0xd4,0x85,0x5a]
1443 // CHECK: cneg wzr, w4, le // encoding: [0x9f,0xc4,0x84,0x5a]
1444 // CHECK: cneg w9, wzr, lt // encoding: [0xe9,0xa7,0x9f,0x5a]
1445
1446 cneg x3, x5, gt
1447 cneg xzr, x4, le
1448 cneg x9, xzr, lt
1449 // CHECK: cneg x3, x5, gt // encoding: [0xa3,0xd4,0x85,0xda]
1450 // CHECK: cneg xzr, x4, le // encoding: [0x9f,0xc4,0x84,0xda]
1451 // CHECK: cneg x9, xzr, lt // encoding: [0xe9,0xa7,0x9f,0xda]
1452
1453 //------------------------------------------------------------------------------
1454 // Data-processing (1 source)
1455 //------------------------------------------------------------------------------
1456
1457 rbit w0, w7
1458 rbit x18, x3
1459 rev16 w17, w1
1460 rev16 x5, x2
1461 rev w18, w0
1462 rev32 x20, x1
1463 rev32 x20, xzr
1464 // CHECK: rbit w0, w7 // encoding: [0xe0,0x00,0xc0,0x5a]
1465 // CHECK: rbit x18, x3 // encoding: [0x72,0x00,0xc0,0xda]
1466 // CHECK: rev16 w17, w1 // encoding: [0x31,0x04,0xc0,0x5a]
1467 // CHECK: rev16 x5, x2 // encoding: [0x45,0x04,0xc0,0xda]
1468 // CHECK: rev w18, w0 // encoding: [0x12,0x08,0xc0,0x5a]
1469 // CHECK: rev32 x20, x1 // encoding: [0x34,0x08,0xc0,0xda]
1470 // CHECK: rev32 x20, xzr // encoding: [0xf4,0x0b,0xc0,0xda]
1471
1472 rev x22, x2
1473 rev x18, xzr
1474 rev w7, wzr
1475 clz w24, w3
1476 clz x26, x4
1477 cls w3, w5
1478 cls x20, x5
1479 // CHECK: rev x22, x2 // encoding: [0x56,0x0c,0xc0,0xda]
1480 // CHECK: rev x18, xzr // encoding: [0xf2,0x0f,0xc0,0xda]
1481 // CHECK: rev w7, wzr // encoding: [0xe7,0x0b,0xc0,0x5a]
1482 // CHECK: clz w24, w3 // encoding: [0x78,0x10,0xc0,0x5a]
1483 // CHECK: clz x26, x4 // encoding: [0x9a,0x10,0xc0,0xda]
1484 // CHECK: cls w3, w5 // encoding: [0xa3,0x14,0xc0,0x5a]
1485 // CHECK: cls x20, x5 // encoding: [0xb4,0x14,0xc0,0xda]
1486
1487 clz w24, wzr
1488 rev x22, xzr
1489 // CHECK: clz w24, wzr // encoding: [0xf8,0x13,0xc0,0x5a]
1490 // CHECK: rev x22, xzr // encoding: [0xf6,0x0f,0xc0,0xda]
1491
1492 rev64 x13, x12
1493 // CHECK: rev x13, x12 // encoding: [0x8d,0x0d,0xc0,0xda]
1494
1495 //------------------------------------------------------------------------------
1496 // Data-processing (2 source)
1497 //------------------------------------------------------------------------------
1498
1499 udiv w0, w7, w10
1500 udiv x9, x22, x4
1501 sdiv w12, w21, w0
1502 sdiv x13, x2, x1
1503 lslv w11, w12, w13
1504 lslv x14, x15, x16
1505 lsrv w17, w18, w19
1506 lsrv x20, x21, x22
1507 asrv w23, w24, w25
1508 asrv x26, x27, x28
1509 rorv w0, w1, w2
1510 rorv x3, x4, x5
1511
1512
1513 // CHECK: udiv w0, w7, w10 // encoding: [0xe0,0x08,0xca,0x1a]
1514 // CHECK: udiv x9, x22, x4 // encoding: [0xc9,0x0a,0xc4,0x9a]
1515 // CHECK: sdiv w12, w21, w0 // encoding: [0xac,0x0e,0xc0,0x1a]
1516 // CHECK: sdiv x13, x2, x1 // encoding: [0x4d,0x0c,0xc1,0x9a]
1517 // CHECK: lsl w11, w12, w13 // encoding: [0x8b,0x21,0xcd,0x1a]
1518 // CHECK: lsl x14, x15, x16 // encoding: [0xee,0x21,0xd0,0x9a]
1519 // CHECK: lsr w17, w18, w19 // encoding: [0x51,0x26,0xd3,0x1a]
1520 // CHECK: lsr x20, x21, x22 // encoding: [0xb4,0x26,0xd6,0x9a]
1521 // CHECK: asr w23, w24, w25 // encoding: [0x17,0x2b,0xd9,0x1a]
1522 // CHECK: asr x26, x27, x28 // encoding: [0x7a,0x2b,0xdc,0x9a]
1523 // CHECK: ror w0, w1, w2 // encoding: [0x20,0x2c,0xc2,0x1a]
1524 // CHECK: ror x3, x4, x5 // encoding: [0x83,0x2c,0xc5,0x9a]
1525
1526
1527 lsl w6, w7, w8
1528 lsl x9, x10, x11
1529 lsr w12, w13, w14
1530 lsr x15, x16, x17
1531 asr w18, w19, w20
1532 asr x21, x22, x23
1533 ror w24, w25, w26
1534 ror x27, x28, x29
1535 // CHECK: lsl w6, w7, w8 // encoding: [0xe6,0x20,0xc8,0x1a]
1536 // CHECK: lsl x9, x10, x11 // encoding: [0x49,0x21,0xcb,0x9a]
1537 // CHECK: lsr w12, w13, w14 // encoding: [0xac,0x25,0xce,0x1a]
1538 // CHECK: lsr x15, x16, x17 // encoding: [0x0f,0x26,0xd1,0x9a]
1539 // CHECK: asr w18, w19, w20 // encoding: [0x72,0x2a,0xd4,0x1a]
1540 // CHECK: asr x21, x22, x23 // encoding: [0xd5,0x2a,0xd7,0x9a]
1541 // CHECK: ror w24, w25, w26 // encoding: [0x38,0x2f,0xda,0x1a]
1542 // CHECK: ror x27, x28, x29 // encoding: [0x9b,0x2f,0xdd,0x9a]
1543
1544 madd w1, w3, w7, w4
1545 madd wzr, w0, w9, w11
1546 madd w13, wzr, w4, w4
1547 madd w19, w30, wzr, w29
1548 madd w4, w5, w6, wzr
1549 // CHECK: madd w1, w3, w7, w4 // encoding: [0x61,0x10,0x07,0x1b]
1550 // CHECK: madd wzr, w0, w9, w11 // encoding: [0x1f,0x2c,0x09,0x1b]
1551 // CHECK: madd w13, wzr, w4, w4 // encoding: [0xed,0x13,0x04,0x1b]
1552 // CHECK: madd w19, w30, wzr, w29 // encoding: [0xd3,0x77,0x1f,0x1b]
1553 // CHECK: mul w4, w5, w6 // encoding: [0xa4,0x7c,0x06,0x1b]
1554
1555 madd x1, x3, x7, x4
1556 madd xzr, x0, x9, x11
1557 madd x13, xzr, x4, x4
1558 madd x19, x30, xzr, x29
1559 madd x4, x5, x6, xzr
1560 // CHECK: madd x1, x3, x7, x4 // encoding: [0x61,0x10,0x07,0x9b]
1561 // CHECK: madd xzr, x0, x9, x11 // encoding: [0x1f,0x2c,0x09,0x9b]
1562 // CHECK: madd x13, xzr, x4, x4 // encoding: [0xed,0x13,0x04,0x9b]
1563 // CHECK: madd x19, x30, xzr, x29 // encoding: [0xd3,0x77,0x1f,0x9b]
1564 // CHECK: mul x4, x5, x6 // encoding: [0xa4,0x7c,0x06,0x9b]
1565
1566 msub w1, w3, w7, w4
1567 msub wzr, w0, w9, w11
1568 msub w13, wzr, w4, w4
1569 msub w19, w30, wzr, w29
1570 msub w4, w5, w6, wzr
1571 // CHECK: msub w1, w3, w7, w4 // encoding: [0x61,0x90,0x07,0x1b]
1572 // CHECK: msub wzr, w0, w9, w11 // encoding: [0x1f,0xac,0x09,0x1b]
1573 // CHECK: msub w13, wzr, w4, w4 // encoding: [0xed,0x93,0x04,0x1b]
1574 // CHECK: msub w19, w30, wzr, w29 // encoding: [0xd3,0xf7,0x1f,0x1b]
1575 // CHECK: mneg w4, w5, w6 // encoding: [0xa4,0xfc,0x06,0x1b]
1576
1577 msub x1, x3, x7, x4
1578 msub xzr, x0, x9, x11
1579 msub x13, xzr, x4, x4
1580 msub x19, x30, xzr, x29
1581 msub x4, x5, x6, xzr
1582 // CHECK: msub x1, x3, x7, x4 // encoding: [0x61,0x90,0x07,0x9b]
1583 // CHECK: msub xzr, x0, x9, x11 // encoding: [0x1f,0xac,0x09,0x9b]
1584 // CHECK: msub x13, xzr, x4, x4 // encoding: [0xed,0x93,0x04,0x9b]
1585 // CHECK: msub x19, x30, xzr, x29 // encoding: [0xd3,0xf7,0x1f,0x9b]
1586 // CHECK: mneg x4, x5, x6 // encoding: [0xa4,0xfc,0x06,0x9b]
1587
1588 smaddl x3, w5, w2, x9
1589 smaddl xzr, w10, w11, x12
1590 smaddl x13, wzr, w14, x15
1591 smaddl x16, w17, wzr, x18
1592 smaddl x19, w20, w21, xzr
1593 // CHECK: smaddl x3, w5, w2, x9 // encoding: [0xa3,0x24,0x22,0x9b]
1594 // CHECK: smaddl xzr, w10, w11, x12 // encoding: [0x5f,0x31,0x2b,0x9b]
1595 // CHECK: smaddl x13, wzr, w14, x15 // encoding: [0xed,0x3f,0x2e,0x9b]
1596 // CHECK: smaddl x16, w17, wzr, x18 // encoding: [0x30,0x4a,0x3f,0x9b]
1597 // CHECK: smull x19, w20, w21 // encoding: [0x93,0x7e,0x35,0x9b]
1598
1599 smsubl x3, w5, w2, x9
1600 smsubl xzr, w10, w11, x12
1601 smsubl x13, wzr, w14, x15
1602 smsubl x16, w17, wzr, x18
1603 smsubl x19, w20, w21, xzr
1604 // CHECK: smsubl x3, w5, w2, x9 // encoding: [0xa3,0xa4,0x22,0x9b]
1605 // CHECK: smsubl xzr, w10, w11, x12 // encoding: [0x5f,0xb1,0x2b,0x9b]
1606 // CHECK: smsubl x13, wzr, w14, x15 // encoding: [0xed,0xbf,0x2e,0x9b]
1607 // CHECK: smsubl x16, w17, wzr, x18 // encoding: [0x30,0xca,0x3f,0x9b]
1608 // CHECK: smnegl x19, w20, w21 // encoding: [0x93,0xfe,0x35,0x9b]
1609
1610 umaddl x3, w5, w2, x9
1611 umaddl xzr, w10, w11, x12
1612 umaddl x13, wzr, w14, x15
1613 umaddl x16, w17, wzr, x18
1614 umaddl x19, w20, w21, xzr
1615 // CHECK: umaddl x3, w5, w2, x9 // encoding: [0xa3,0x24,0xa2,0x9b]
1616 // CHECK: umaddl xzr, w10, w11, x12 // encoding: [0x5f,0x31,0xab,0x9b]
1617 // CHECK: umaddl x13, wzr, w14, x15 // encoding: [0xed,0x3f,0xae,0x9b]
1618 // CHECK: umaddl x16, w17, wzr, x18 // encoding: [0x30,0x4a,0xbf,0x9b]
1619 // CHECK: umull x19, w20, w21 // encoding: [0x93,0x7e,0xb5,0x9b]
1620
1621
1622
1623 umsubl x3, w5, w2, x9
1624 umsubl xzr, w10, w11, x12
1625 umsubl x13, wzr, w14, x15
1626 umsubl x16, w17, wzr, x18
1627 umsubl x19, w20, w21, xzr
1628 // CHECK: umsubl x3, w5, w2, x9 // encoding: [0xa3,0xa4,0xa2,0x9b]
1629 // CHECK: umsubl xzr, w10, w11, x12 // encoding: [0x5f,0xb1,0xab,0x9b]
1630 // CHECK: umsubl x13, wzr, w14, x15 // encoding: [0xed,0xbf,0xae,0x9b]
1631 // CHECK: umsubl x16, w17, wzr, x18 // encoding: [0x30,0xca,0xbf,0x9b]
1632 // CHECK: umnegl x19, w20, w21 // encoding: [0x93,0xfe,0xb5,0x9b]
1633
1634 smulh x30, x29, x28
1635 smulh xzr, x27, x26
1636 smulh x25, xzr, x24
1637 smulh x23, x22, xzr
1638 // CHECK: smulh x30, x29, x28 // encoding: [0xbe,0x7f,0x5c,0x9b]
1639 // CHECK: smulh xzr, x27, x26 // encoding: [0x7f,0x7f,0x5a,0x9b]
1640 // CHECK: smulh x25, xzr, x24 // encoding: [0xf9,0x7f,0x58,0x9b]
1641 // CHECK: smulh x23, x22, xzr // encoding: [0xd7,0x7e,0x5f,0x9b]
1642
1643 umulh x30, x29, x28
1644 umulh xzr, x27, x26
1645 umulh x25, xzr, x24
1646 umulh x23, x22, xzr
1647 // CHECK: umulh x30, x29, x28 // encoding: [0xbe,0x7f,0xdc,0x9b]
1648 // CHECK: umulh xzr, x27, x26 // encoding: [0x7f,0x7f,0xda,0x9b]
1649 // CHECK: umulh x25, xzr, x24 // encoding: [0xf9,0x7f,0xd8,0x9b]
1650 // CHECK: umulh x23, x22, xzr // encoding: [0xd7,0x7e,0xdf,0x9b]
1651
1652 mul w3, w4, w5
1653 mul wzr, w6, w7
1654 mul w8, wzr, w9
1655 mul w10, w11, wzr
1656
1657 mul x12, x13, x14
1658 mul xzr, x15, x16
1659 mul x17, xzr, x18
1660 mul x19, x20, xzr
1661
1662 mneg w21, w22, w23
1663 mneg wzr, w24, w25
1664 mneg w26, wzr, w27
1665 mneg w28, w29, wzr
1666
1667 smull x11, w13, w17
1668 umull x11, w13, w17
1669 smnegl x11, w13, w17
1670 umnegl x11, w13, w17
1671 // CHECK: mul w3, w4, w5 // encoding: [0x83,0x7c,0x05,0x1b]
1672 // CHECK: mul wzr, w6, w7 // encoding: [0xdf,0x7c,0x07,0x1b]
1673 // CHECK: mul w8, wzr, w9 // encoding: [0xe8,0x7f,0x09,0x1b]
1674 // CHECK: mul w10, w11, wzr // encoding: [0x6a,0x7d,0x1f,0x1b]
1675 // CHECK: mul x12, x13, x14 // encoding: [0xac,0x7d,0x0e,0x9b]
1676 // CHECK: mul xzr, x15, x16 // encoding: [0xff,0x7d,0x10,0x9b]
1677 // CHECK: mul x17, xzr, x18 // encoding: [0xf1,0x7f,0x12,0x9b]
1678 // CHECK: mul x19, x20, xzr // encoding: [0x93,0x7e,0x1f,0x9b]
1679 // CHECK: mneg w21, w22, w23 // encoding: [0xd5,0xfe,0x17,0x1b]
1680 // CHECK: mneg wzr, w24, w25 // encoding: [0x1f,0xff,0x19,0x1b]
1681 // CHECK: mneg w26, wzr, w27 // encoding: [0xfa,0xff,0x1b,0x1b]
1682 // CHECK: mneg w28, w29, wzr // encoding: [0xbc,0xff,0x1f,0x1b]
1683 // CHECK: smull x11, w13, w17 // encoding: [0xab,0x7d,0x31,0x9b]
1684 // CHECK: umull x11, w13, w17 // encoding: [0xab,0x7d,0xb1,0x9b]
1685 // CHECK: smnegl x11, w13, w17 // encoding: [0xab,0xfd,0x31,0x9b]
1686 // CHECK: umnegl x11, w13, w17 // encoding: [0xab,0xfd,0xb1,0x9b]
1687
1688 //------------------------------------------------------------------------------
1689 // Exception generation
1690 //------------------------------------------------------------------------------
1691 svc #0
1692 svc #65535
1693 // CHECK: svc #0 // encoding: [0x01,0x00,0x00,0xd4]
1694 // CHECK: svc #{{65535|0xffff}} // encoding: [0xe1,0xff,0x1f,0xd4]
1695
1696 hvc #1
1697 smc #12000
1698 brk #12
1699 hlt #123
1700 // CHECK: hvc #{{1|0x1}} // encoding: [0x22,0x00,0x00,0xd4]
1701 // CHECK: smc #{{12000|0x2ee0}} // encoding: [0x03,0xdc,0x05,0xd4]
1702 // CHECK: brk #{{12|0xc}} // encoding: [0x80,0x01,0x20,0xd4]
1703 // CHECK: hlt #{{123|0x7b}} // encoding: [0x60,0x0f,0x40,0xd4]
1704
1705 dcps1 #42
1706 dcps2 #9
1707 dcps3 #1000
1708 // CHECK: dcps1 #{{42|0x2a}} // encoding: [0x41,0x05,0xa0,0xd4]
1709 // CHECK: dcps2 #{{9|0x9}} // encoding: [0x22,0x01,0xa0,0xd4]
1710 // CHECK: dcps3 #{{1000|0x3e8}} // encoding: [0x03,0x7d,0xa0,0xd4]
1711
1712 dcps1
1713 dcps2
1714 dcps3
1715 // CHECK: dcps1 // encoding: [0x01,0x00,0xa0,0xd4]
1716 // CHECK: dcps2 // encoding: [0x02,0x00,0xa0,0xd4]
1717 // CHECK: dcps3 // encoding: [0x03,0x00,0xa0,0xd4]
1718
1719 //------------------------------------------------------------------------------
1720 // Extract (immediate)
1721 //------------------------------------------------------------------------------
1722
1723 extr w3, w5, w7, #0
1724 extr w11, w13, w17, #31
1725 // CHECK: extr w3, w5, w7, #0 // encoding: [0xa3,0x00,0x87,0x13]
1726 // CHECK: extr w11, w13, w17, #31 // encoding: [0xab,0x7d,0x91,0x13]
1727
1728 extr x3, x5, x7, #15
1729 extr x11, x13, x17, #63
1730 // CHECK: extr x3, x5, x7, #15 // encoding: [0xa3,0x3c,0xc7,0x93]
1731 // CHECK: extr x11, x13, x17, #63 // encoding: [0xab,0xfd,0xd1,0x93]
1732
1733 ror x19, x23, #24
1734 ror x29, xzr, #63
1735 // CHECK: ror x19, x23, #24 // encoding: [0xf3,0x62,0xd7,0x93]
1736 // CHECK: ror x29, xzr, #63 // encoding: [0xfd,0xff,0xdf,0x93]
1737
1738 ror w9, w13, #31
1739 // CHECK: ror w9, w13, #31 // encoding: [0xa9,0x7d,0x8d,0x13]
1740
1741 //------------------------------------------------------------------------------
1742 // Floating-point compare
1743 //------------------------------------------------------------------------------
1744
1745 fcmp s3, s5
1746 fcmp s31, #0.0
1747 // CHECK: fcmp s3, s5 // encoding: [0x60,0x20,0x25,0x1e]
1748 // CHECK: fcmp s31, #0.0 // encoding: [0xe8,0x23,0x20,0x1e]
1749
1750 fcmpe s29, s30
1751 fcmpe s15, #0.0
1752 // CHECK: fcmpe s29, s30 // encoding: [0xb0,0x23,0x3e,0x1e]
1753 // CHECK: fcmpe s15, #0.0 // encoding: [0xf8,0x21,0x20,0x1e]
1754
1755 fcmp d4, d12
1756 fcmp d23, #0.0
1757 // CHECK: fcmp d4, d12 // encoding: [0x80,0x20,0x6c,0x1e]
1758 // CHECK: fcmp d23, #0.0 // encoding: [0xe8,0x22,0x60,0x1e]
1759
1760 fcmpe d26, d22
1761 fcmpe d29, #0.0
1762 // CHECK: fcmpe d26, d22 // encoding: [0x50,0x23,0x76,0x1e]
1763 // CHECK: fcmpe d29, #0.0 // encoding: [0xb8,0x23,0x60,0x1e]
1764
1765 //------------------------------------------------------------------------------
1766 // Floating-point conditional compare
1767 //------------------------------------------------------------------------------
1768
1769 fccmp s1, s31, #0, eq
1770 fccmp s3, s0, #15, hs
1771 fccmp s31, s15, #13, cs
1772 // CHECK: fccmp s1, s31, #0, eq // encoding: [0x20,0x04,0x3f,0x1e]
1773 // CHECK: fccmp s3, s0, #15, hs // encoding: [0x6f,0x24,0x20,0x1e]
1774 // CHECK: fccmp s31, s15, #13, hs // encoding: [0xed,0x27,0x2f,0x1e]
1775
1776 fccmp d9, d31, #0, le
1777 fccmp d3, d0, #15, gt
1778 fccmp d31, d5, #7, ne
1779 // CHECK: fccmp d9, d31, #0, le // encoding: [0x20,0xd5,0x7f,0x1e]
1780 // CHECK: fccmp d3, d0, #15, gt // encoding: [0x6f,0xc4,0x60,0x1e]
1781 // CHECK: fccmp d31, d5, #7, ne // encoding: [0xe7,0x17,0x65,0x1e]
1782
1783 fccmpe s1, s31, #0, eq
1784 fccmpe s3, s0, #15, hs
1785 fccmpe s31, s15, #13, cs
1786 // CHECK: fccmpe s1, s31, #0, eq // encoding: [0x30,0x04,0x3f,0x1e]
1787 // CHECK: fccmpe s3, s0, #15, hs // encoding: [0x7f,0x24,0x20,0x1e]
1788 // CHECK: fccmpe s31, s15, #13, hs // encoding: [0xfd,0x27,0x2f,0x1e]
1789
1790 fccmpe d9, d31, #0, le
1791 fccmpe d3, d0, #15, gt
1792 fccmpe d31, d5, #7, ne
1793 // CHECK: fccmpe d9, d31, #0, le // encoding: [0x30,0xd5,0x7f,0x1e]
1794 // CHECK: fccmpe d3, d0, #15, gt // encoding: [0x7f,0xc4,0x60,0x1e]
1795 // CHECK: fccmpe d31, d5, #7, ne // encoding: [0xf7,0x17,0x65,0x1e]
1796
1797 //------------------------------------------------------------------------------
1798 // Floating-point conditional compare
1799 //------------------------------------------------------------------------------
1800
1801 fcsel s3, s20, s9, pl
1802 fcsel d9, d10, d11, mi
1803 // CHECK: fcsel s3, s20, s9, pl // encoding: [0x83,0x5e,0x29,0x1e]
1804 // CHECK: fcsel d9, d10, d11, mi // encoding: [0x49,0x4d,0x6b,0x1e]
1805
1806 //------------------------------------------------------------------------------
1807 // Floating-point data-processing (1 source)
1808 //------------------------------------------------------------------------------
1809
1810 fmov s0, s1
1811 fabs s2, s3
1812 fneg s4, s5
1813 fsqrt s6, s7
1814 fcvt d8, s9
1815 fcvt h10, s11
1816 frintn s12, s13
1817 frintp s14, s15
1818 frintm s16, s17
1819 frintz s18, s19
1820 frinta s20, s21
1821 frintx s22, s23
1822 frinti s24, s25
1823 // CHECK: fmov s0, s1 // encoding: [0x20,0x40,0x20,0x1e]
1824 // CHECK: fabs s2, s3 // encoding: [0x62,0xc0,0x20,0x1e]
1825 // CHECK: fneg s4, s5 // encoding: [0xa4,0x40,0x21,0x1e]
1826 // CHECK: fsqrt s6, s7 // encoding: [0xe6,0xc0,0x21,0x1e]
1827 // CHECK: fcvt d8, s9 // encoding: [0x28,0xc1,0x22,0x1e]
1828 // CHECK: fcvt h10, s11 // encoding: [0x6a,0xc1,0x23,0x1e]
1829 // CHECK: frintn s12, s13 // encoding: [0xac,0x41,0x24,0x1e]
1830 // CHECK: frintp s14, s15 // encoding: [0xee,0xc1,0x24,0x1e]
1831 // CHECK: frintm s16, s17 // encoding: [0x30,0x42,0x25,0x1e]
1832 // CHECK: frintz s18, s19 // encoding: [0x72,0xc2,0x25,0x1e]
1833 // CHECK: frinta s20, s21 // encoding: [0xb4,0x42,0x26,0x1e]
1834 // CHECK: frintx s22, s23 // encoding: [0xf6,0x42,0x27,0x1e]
1835 // CHECK: frinti s24, s25 // encoding: [0x38,0xc3,0x27,0x1e]
1836
1837 fmov d0, d1
1838 fabs d2, d3
1839 fneg d4, d5
1840 fsqrt d6, d7
1841 fcvt s8, d9
1842 fcvt h10, d11
1843 frintn d12, d13
1844 frintp d14, d15
1845 frintm d16, d17
1846 frintz d18, d19
1847 frinta d20, d21
1848 frintx d22, d23
1849 frinti d24, d25
1850 // CHECK: fmov d0, d1 // encoding: [0x20,0x40,0x60,0x1e]
1851 // CHECK: fabs d2, d3 // encoding: [0x62,0xc0,0x60,0x1e]
1852 // CHECK: fneg d4, d5 // encoding: [0xa4,0x40,0x61,0x1e]
1853 // CHECK: fsqrt d6, d7 // encoding: [0xe6,0xc0,0x61,0x1e]
1854 // CHECK: fcvt s8, d9 // encoding: [0x28,0x41,0x62,0x1e]
1855 // CHECK: fcvt h10, d11 // encoding: [0x6a,0xc1,0x63,0x1e]
1856 // CHECK: frintn d12, d13 // encoding: [0xac,0x41,0x64,0x1e]
1857 // CHECK: frintp d14, d15 // encoding: [0xee,0xc1,0x64,0x1e]
1858 // CHECK: frintm d16, d17 // encoding: [0x30,0x42,0x65,0x1e]
1859 // CHECK: frintz d18, d19 // encoding: [0x72,0xc2,0x65,0x1e]
1860 // CHECK: frinta d20, d21 // encoding: [0xb4,0x42,0x66,0x1e]
1861 // CHECK: frintx d22, d23 // encoding: [0xf6,0x42,0x67,0x1e]
1862 // CHECK: frinti d24, d25 // encoding: [0x38,0xc3,0x67,0x1e]
1863
1864 fcvt s26, h27
1865 fcvt d28, h29
1866 // CHECK: fcvt s26, h27 // encoding: [0x7a,0x43,0xe2,0x1e]
1867 // CHECK: fcvt d28, h29 // encoding: [0xbc,0xc3,0xe2,0x1e]
1868
1869 //------------------------------------------------------------------------------
1870 // Floating-point data-processing (2 sources)
1871 //------------------------------------------------------------------------------
1872
1873 fmul s20, s19, s17
1874 fdiv s1, s2, s3
1875 fadd s4, s5, s6
1876 fsub s7, s8, s9
1877 fmax s10, s11, s12
1878 fmin s13, s14, s15
1879 fmaxnm s16, s17, s18
1880 fminnm s19, s20, s21
1881 fnmul s22, s23, s24
1882 // CHECK: fmul s20, s19, s17 // encoding: [0x74,0x0a,0x31,0x1e]
1883 // CHECK: fdiv s1, s2, s3 // encoding: [0x41,0x18,0x23,0x1e]
1884 // CHECK: fadd s4, s5, s6 // encoding: [0xa4,0x28,0x26,0x1e]
1885 // CHECK: fsub s7, s8, s9 // encoding: [0x07,0x39,0x29,0x1e]
1886 // CHECK: fmax s10, s11, s12 // encoding: [0x6a,0x49,0x2c,0x1e]
1887 // CHECK: fmin s13, s14, s15 // encoding: [0xcd,0x59,0x2f,0x1e]
1888 // CHECK: fmaxnm s16, s17, s18 // encoding: [0x30,0x6a,0x32,0x1e]
1889 // CHECK: fminnm s19, s20, s21 // encoding: [0x93,0x7a,0x35,0x1e]
1890 // CHECK: fnmul s22, s23, s24 // encoding: [0xf6,0x8a,0x38,0x1e]
1891
1892 fmul d20, d19, d17
1893 fdiv d1, d2, d3
1894 fadd d4, d5, d6
1895 fsub d7, d8, d9
1896 fmax d10, d11, d12
1897 fmin d13, d14, d15
1898 fmaxnm d16, d17, d18
1899 fminnm d19, d20, d21
1900 fnmul d22, d23, d24
1901 // CHECK: fmul d20, d19, d17 // encoding: [0x74,0x0a,0x71,0x1e]
1902 // CHECK: fdiv d1, d2, d3 // encoding: [0x41,0x18,0x63,0x1e]
1903 // CHECK: fadd d4, d5, d6 // encoding: [0xa4,0x28,0x66,0x1e]
1904 // CHECK: fsub d7, d8, d9 // encoding: [0x07,0x39,0x69,0x1e]
1905 // CHECK: fmax d10, d11, d12 // encoding: [0x6a,0x49,0x6c,0x1e]
1906 // CHECK: fmin d13, d14, d15 // encoding: [0xcd,0x59,0x6f,0x1e]
1907 // CHECK: fmaxnm d16, d17, d18 // encoding: [0x30,0x6a,0x72,0x1e]
1908 // CHECK: fminnm d19, d20, d21 // encoding: [0x93,0x7a,0x75,0x1e]
1909 // CHECK: fnmul d22, d23, d24 // encoding: [0xf6,0x8a,0x78,0x1e]
1910
1911 //------------------------------------------------------------------------------
1912 // Floating-point data-processing (3 sources)
1913 //------------------------------------------------------------------------------
1914
1915 fmadd s3, s5, s6, s31
1916 fmadd d3, d13, d0, d23
1917 fmsub s3, s5, s6, s31
1918 fmsub d3, d13, d0, d23
1919 fnmadd s3, s5, s6, s31
1920 fnmadd d3, d13, d0, d23
1921 fnmsub s3, s5, s6, s31
1922 fnmsub d3, d13, d0, d23
1923 // CHECK: fmadd s3, s5, s6, s31 // encoding: [0xa3,0x7c,0x06,0x1f]
1924 // CHECK: fmadd d3, d13, d0, d23 // encoding: [0xa3,0x5d,0x40,0x1f]
1925 // CHECK: fmsub s3, s5, s6, s31 // encoding: [0xa3,0xfc,0x06,0x1f]
1926 // CHECK: fmsub d3, d13, d0, d23 // encoding: [0xa3,0xdd,0x40,0x1f]
1927 // CHECK: fnmadd s3, s5, s6, s31 // encoding: [0xa3,0x7c,0x26,0x1f]
1928 // CHECK: fnmadd d3, d13, d0, d23 // encoding: [0xa3,0x5d,0x60,0x1f]
1929 // CHECK: fnmsub s3, s5, s6, s31 // encoding: [0xa3,0xfc,0x26,0x1f]
1930 // CHECK: fnmsub d3, d13, d0, d23 // encoding: [0xa3,0xdd,0x60,0x1f]
1931
1932 //------------------------------------------------------------------------------
1933 // Floating-point <-> fixed-point conversion
1934 //------------------------------------------------------------------------------
1935
1936 fcvtzs w3, s5, #1
1937 fcvtzs wzr, s20, #13
1938 fcvtzs w19, s0, #32
1939 // CHECK: fcvtzs w3, s5, #1 // encoding: [0xa3,0xfc,0x18,0x1e]
1940 // CHECK: fcvtzs wzr, s20, #13 // encoding: [0x9f,0xce,0x18,0x1e]
1941 // CHECK: fcvtzs w19, s0, #32 // encoding: [0x13,0x80,0x18,0x1e]
1942
1943 fcvtzs x3, s5, #1
1944 fcvtzs x12, s30, #45
1945 fcvtzs x19, s0, #64
1946 // CHECK: fcvtzs x3, s5, #1 // encoding: [0xa3,0xfc,0x18,0x9e]
1947 // CHECK: fcvtzs x12, s30, #45 // encoding: [0xcc,0x4f,0x18,0x9e]
1948 // CHECK: fcvtzs x19, s0, #64 // encoding: [0x13,0x00,0x18,0x9e]
1949
1950 fcvtzs w3, d5, #1
1951 fcvtzs wzr, d20, #13
1952 fcvtzs w19, d0, #32
1953 // CHECK: fcvtzs w3, d5, #1 // encoding: [0xa3,0xfc,0x58,0x1e]
1954 // CHECK: fcvtzs wzr, d20, #13 // encoding: [0x9f,0xce,0x58,0x1e]
1955 // CHECK: fcvtzs w19, d0, #32 // encoding: [0x13,0x80,0x58,0x1e]
1956
1957 fcvtzs x3, d5, #1
1958 fcvtzs x12, d30, #45
1959 fcvtzs x19, d0, #64
1960 // CHECK: fcvtzs x3, d5, #1 // encoding: [0xa3,0xfc,0x58,0x9e]
1961 // CHECK: fcvtzs x12, d30, #45 // encoding: [0xcc,0x4f,0x58,0x9e]
1962 // CHECK: fcvtzs x19, d0, #64 // encoding: [0x13,0x00,0x58,0x9e]
1963
1964 fcvtzu w3, s5, #1
1965 fcvtzu wzr, s20, #13
1966 fcvtzu w19, s0, #32
1967 // CHECK: fcvtzu w3, s5, #1 // encoding: [0xa3,0xfc,0x19,0x1e]
1968 // CHECK: fcvtzu wzr, s20, #13 // encoding: [0x9f,0xce,0x19,0x1e]
1969 // CHECK: fcvtzu w19, s0, #32 // encoding: [0x13,0x80,0x19,0x1e]
1970
1971 fcvtzu x3, s5, #1
1972 fcvtzu x12, s30, #45
1973 fcvtzu x19, s0, #64
1974 // CHECK: fcvtzu x3, s5, #1 // encoding: [0xa3,0xfc,0x19,0x9e]
1975 // CHECK: fcvtzu x12, s30, #45 // encoding: [0xcc,0x4f,0x19,0x9e]
1976 // CHECK: fcvtzu x19, s0, #64 // encoding: [0x13,0x00,0x19,0x9e]
1977
1978 fcvtzu w3, d5, #1
1979 fcvtzu wzr, d20, #13
1980 fcvtzu w19, d0, #32
1981 // CHECK: fcvtzu w3, d5, #1 // encoding: [0xa3,0xfc,0x59,0x1e]
1982 // CHECK: fcvtzu wzr, d20, #13 // encoding: [0x9f,0xce,0x59,0x1e]
1983 // CHECK: fcvtzu w19, d0, #32 // encoding: [0x13,0x80,0x59,0x1e]
1984
1985 fcvtzu x3, d5, #1
1986 fcvtzu x12, d30, #45
1987 fcvtzu x19, d0, #64
1988 // CHECK: fcvtzu x3, d5, #1 // encoding: [0xa3,0xfc,0x59,0x9e]
1989 // CHECK: fcvtzu x12, d30, #45 // encoding: [0xcc,0x4f,0x59,0x9e]
1990 // CHECK: fcvtzu x19, d0, #64 // encoding: [0x13,0x00,0x59,0x9e]
1991
1992 scvtf s23, w19, #1
1993 scvtf s31, wzr, #20
1994 scvtf s14, w0, #32
1995 // CHECK: scvtf s23, w19, #1 // encoding: [0x77,0xfe,0x02,0x1e]
1996 // CHECK: scvtf s31, wzr, #20 // encoding: [0xff,0xb3,0x02,0x1e]
1997 // CHECK: scvtf s14, w0, #32 // encoding: [0x0e,0x80,0x02,0x1e]
1998
1999 scvtf s23, x19, #1
2000 scvtf s31, xzr, #20
2001 scvtf s14, x0, #64
2002 // CHECK: scvtf s23, x19, #1 // encoding: [0x77,0xfe,0x02,0x9e]
2003 // CHECK: scvtf s31, xzr, #20 // encoding: [0xff,0xb3,0x02,0x9e]
2004 // CHECK: scvtf s14, x0, #64 // encoding: [0x0e,0x00,0x02,0x9e]
2005
2006 scvtf d23, w19, #1
2007 scvtf d31, wzr, #20
2008 scvtf d14, w0, #32
2009 // CHECK: scvtf d23, w19, #1 // encoding: [0x77,0xfe,0x42,0x1e]
2010 // CHECK: scvtf d31, wzr, #20 // encoding: [0xff,0xb3,0x42,0x1e]
2011 // CHECK: scvtf d14, w0, #32 // encoding: [0x0e,0x80,0x42,0x1e]
2012
2013 scvtf d23, x19, #1
2014 scvtf d31, xzr, #20
2015 scvtf d14, x0, #64
2016 // CHECK: scvtf d23, x19, #1 // encoding: [0x77,0xfe,0x42,0x9e]
2017 // CHECK: scvtf d31, xzr, #20 // encoding: [0xff,0xb3,0x42,0x9e]
2018 // CHECK: scvtf d14, x0, #64 // encoding: [0x0e,0x00,0x42,0x9e]
2019
2020 ucvtf s23, w19, #1
2021 ucvtf s31, wzr, #20
2022 ucvtf s14, w0, #32
2023 // CHECK: ucvtf s23, w19, #1 // encoding: [0x77,0xfe,0x03,0x1e]
2024 // CHECK: ucvtf s31, wzr, #20 // encoding: [0xff,0xb3,0x03,0x1e]
2025 // CHECK: ucvtf s14, w0, #32 // encoding: [0x0e,0x80,0x03,0x1e]
2026
2027 ucvtf s23, x19, #1
2028 ucvtf s31, xzr, #20
2029 ucvtf s14, x0, #64
2030 // CHECK: ucvtf s23, x19, #1 // encoding: [0x77,0xfe,0x03,0x9e]
2031 // CHECK: ucvtf s31, xzr, #20 // encoding: [0xff,0xb3,0x03,0x9e]
2032 // CHECK: ucvtf s14, x0, #64 // encoding: [0x0e,0x00,0x03,0x9e]
2033
2034 ucvtf d23, w19, #1
2035 ucvtf d31, wzr, #20
2036 ucvtf d14, w0, #32
2037 // CHECK: ucvtf d23, w19, #1 // encoding: [0x77,0xfe,0x43,0x1e]
2038 // CHECK: ucvtf d31, wzr, #20 // encoding: [0xff,0xb3,0x43,0x1e]
2039 // CHECK: ucvtf d14, w0, #32 // encoding: [0x0e,0x80,0x43,0x1e]
2040
2041 ucvtf d23, x19, #1
2042 ucvtf d31, xzr, #20
2043 ucvtf d14, x0, #64
2044 // CHECK: ucvtf d23, x19, #1 // encoding: [0x77,0xfe,0x43,0x9e]
2045 // CHECK: ucvtf d31, xzr, #20 // encoding: [0xff,0xb3,0x43,0x9e]
2046 // CHECK: ucvtf d14, x0, #64 // encoding: [0x0e,0x00,0x43,0x9e]
2047
2048 //------------------------------------------------------------------------------
2049 // Floating-point <-> integer conversion
2050 //------------------------------------------------------------------------------
2051 fcvtns w3, s31
2052 fcvtns xzr, s12
2053 fcvtnu wzr, s12
2054 fcvtnu x0, s0
2055 // CHECK: fcvtns w3, s31 // encoding: [0xe3,0x03,0x20,0x1e]
2056 // CHECK: fcvtns xzr, s12 // encoding: [0x9f,0x01,0x20,0x9e]
2057 // CHECK: fcvtnu wzr, s12 // encoding: [0x9f,0x01,0x21,0x1e]
2058 // CHECK: fcvtnu x0, s0 // encoding: [0x00,0x00,0x21,0x9e]
2059
2060 fcvtps wzr, s9
2061 fcvtps x12, s20
2062 fcvtpu w30, s23
2063 fcvtpu x29, s3
2064 // CHECK: fcvtps wzr, s9 // encoding: [0x3f,0x01,0x28,0x1e]
2065 // CHECK: fcvtps x12, s20 // encoding: [0x8c,0x02,0x28,0x9e]
2066 // CHECK: fcvtpu w30, s23 // encoding: [0xfe,0x02,0x29,0x1e]
2067 // CHECK: fcvtpu x29, s3 // encoding: [0x7d,0x00,0x29,0x9e]
2068
2069 fcvtms w2, s3
2070 fcvtms x4, s5
2071 fcvtmu w6, s7
2072 fcvtmu x8, s9
2073 // CHECK: fcvtms w2, s3 // encoding: [0x62,0x00,0x30,0x1e]
2074 // CHECK: fcvtms x4, s5 // encoding: [0xa4,0x00,0x30,0x9e]
2075 // CHECK: fcvtmu w6, s7 // encoding: [0xe6,0x00,0x31,0x1e]
2076 // CHECK: fcvtmu x8, s9 // encoding: [0x28,0x01,0x31,0x9e]
2077
2078 fcvtzs w10, s11
2079 fcvtzs x12, s13
2080 fcvtzu w14, s15
2081 fcvtzu x15, s16
2082 // CHECK: fcvtzs w10, s11 // encoding: [0x6a,0x01,0x38,0x1e]
2083 // CHECK: fcvtzs x12, s13 // encoding: [0xac,0x01,0x38,0x9e]
2084 // CHECK: fcvtzu w14, s15 // encoding: [0xee,0x01,0x39,0x1e]
2085 // CHECK: fcvtzu x15, s16 // encoding: [0x0f,0x02,0x39,0x9e]
2086
2087 scvtf s17, w18
2088 scvtf s19, x20
2089 ucvtf s21, w22
2090 scvtf s23, x24
2091 // CHECK: scvtf s17, w18 // encoding: [0x51,0x02,0x22,0x1e]
2092 // CHECK: scvtf s19, x20 // encoding: [0x93,0x02,0x22,0x9e]
2093 // CHECK: ucvtf s21, w22 // encoding: [0xd5,0x02,0x23,0x1e]
2094 // CHECK: scvtf s23, x24 // encoding: [0x17,0x03,0x22,0x9e]
2095
2096 fcvtas w25, s26
2097 fcvtas x27, s28
2098 fcvtau w29, s30
2099 fcvtau xzr, s0
2100 // CHECK: fcvtas w25, s26 // encoding: [0x59,0x03,0x24,0x1e]
2101 // CHECK: fcvtas x27, s28 // encoding: [0x9b,0x03,0x24,0x9e]
2102 // CHECK: fcvtau w29, s30 // encoding: [0xdd,0x03,0x25,0x1e]
2103 // CHECK: fcvtau xzr, s0 // encoding: [0x1f,0x00,0x25,0x9e]
2104
2105 fcvtns w3, d31
2106 fcvtns xzr, d12
2107 fcvtnu wzr, d12
2108 fcvtnu x0, d0
2109 // CHECK: fcvtns w3, d31 // encoding: [0xe3,0x03,0x60,0x1e]
2110 // CHECK: fcvtns xzr, d12 // encoding: [0x9f,0x01,0x60,0x9e]
2111 // CHECK: fcvtnu wzr, d12 // encoding: [0x9f,0x01,0x61,0x1e]
2112 // CHECK: fcvtnu x0, d0 // encoding: [0x00,0x00,0x61,0x9e]
2113
2114 fcvtps wzr, d9
2115 fcvtps x12, d20
2116 fcvtpu w30, d23
2117 fcvtpu x29, d3
2118 // CHECK: fcvtps wzr, d9 // encoding: [0x3f,0x01,0x68,0x1e]
2119 // CHECK: fcvtps x12, d20 // encoding: [0x8c,0x02,0x68,0x9e]
2120 // CHECK: fcvtpu w30, d23 // encoding: [0xfe,0x02,0x69,0x1e]
2121 // CHECK: fcvtpu x29, d3 // encoding: [0x7d,0x00,0x69,0x9e]
2122
2123 fcvtms w2, d3
2124 fcvtms x4, d5
2125 fcvtmu w6, d7
2126 fcvtmu x8, d9
2127 // CHECK: fcvtms w2, d3 // encoding: [0x62,0x00,0x70,0x1e]
2128 // CHECK: fcvtms x4, d5 // encoding: [0xa4,0x00,0x70,0x9e]
2129 // CHECK: fcvtmu w6, d7 // encoding: [0xe6,0x00,0x71,0x1e]
2130 // CHECK: fcvtmu x8, d9 // encoding: [0x28,0x01,0x71,0x9e]
2131
2132 fcvtzs w10, d11
2133 fcvtzs x12, d13
2134 fcvtzu w14, d15
2135 fcvtzu x15, d16
2136 // CHECK: fcvtzs w10, d11 // encoding: [0x6a,0x01,0x78,0x1e]
2137 // CHECK: fcvtzs x12, d13 // encoding: [0xac,0x01,0x78,0x9e]
2138 // CHECK: fcvtzu w14, d15 // encoding: [0xee,0x01,0x79,0x1e]
2139 // CHECK: fcvtzu x15, d16 // encoding: [0x0f,0x02,0x79,0x9e]
2140
2141 scvtf d17, w18
2142 scvtf d19, x20
2143 ucvtf d21, w22
2144 ucvtf d23, x24
2145 // CHECK: scvtf d17, w18 // encoding: [0x51,0x02,0x62,0x1e]
2146 // CHECK: scvtf d19, x20 // encoding: [0x93,0x02,0x62,0x9e]
2147 // CHECK: ucvtf d21, w22 // encoding: [0xd5,0x02,0x63,0x1e]
2148 // CHECK: ucvtf d23, x24 // encoding: [0x17,0x03,0x63,0x9e]
2149
2150 fcvtas w25, d26
2151 fcvtas x27, d28
2152 fcvtau w29, d30
2153 fcvtau xzr, d0
2154 // CHECK: fcvtas w25, d26 // encoding: [0x59,0x03,0x64,0x1e]
2155 // CHECK: fcvtas x27, d28 // encoding: [0x9b,0x03,0x64,0x9e]
2156 // CHECK: fcvtau w29, d30 // encoding: [0xdd,0x03,0x65,0x1e]
2157 // CHECK: fcvtau xzr, d0 // encoding: [0x1f,0x00,0x65,0x9e]
2158
2159 fmov w3, s9
2160 fmov s9, w3
2161 // CHECK: fmov w3, s9 // encoding: [0x23,0x01,0x26,0x1e]
2162 // CHECK: fmov s9, w3 // encoding: [0x69,0x00,0x27,0x1e]
2163
2164 fmov x20, d31
2165 fmov d1, x15
2166 // CHECK: fmov x20, d31 // encoding: [0xf4,0x03,0x66,0x9e]
2167 // CHECK: fmov d1, x15 // encoding: [0xe1,0x01,0x67,0x9e]
2168
2169 fmov x3, v12.d[1]
2170 fmov v1.d[1], x19
2171 fmov v3.d[1], xzr
2172 // CHECK: fmov x3, v12.d[1] // encoding: [0x83,0x01,0xae,0x9e]
2173 // CHECK: fmov v1.d[1], x19 // encoding: [0x61,0x02,0xaf,0x9e]
2174 // CHECK: fmov v3.d[1], xzr // encoding: [0xe3,0x03,0xaf,0x9e]
2175
2176 //------------------------------------------------------------------------------
2177 // Floating-point immediate
2178 //------------------------------------------------------------------------------
2179
2180 fmov s2, #0.125
2181 fmov s3, #1.0
2182 fmov d30, #16.0
2183 // CHECK: fmov s2, #{{0.12500000|1.250*e-01}} // encoding: [0x02,0x10,0x28,0x1e]
2184 // CHECK: fmov s3, #{{1.00000000|1.0*e\+00}} // encoding: [0x03,0x10,0x2e,0x1e]
2185 // CHECK: fmov d30, #{{16.00000000|1.60*e\+01}} // encoding: [0x1e,0x10,0x66,0x1e]
2186
2187 fmov s4, #1.0625
2188 fmov d10, #1.9375
2189 // CHECK: fmov s4, #{{1.06250*(e\+00)?}} // encoding: [0x04,0x30,0x2e,0x1e]
2190 // CHECK: fmov d10, #{{1.93750*(e\+00)?}} // encoding: [0x0a,0xf0,0x6f,0x1e]
2191
2192 fmov s12, #-1.0
2193 // CHECK: fmov s12, #{{-1.0*(e\+00)?}} // encoding: [0x0c,0x10,0x3e,0x1e]
2194
2195 fmov d16, #8.5
2196 // CHECK: fmov d16, #{{8.50*(e\+00)?}} // encoding: [0x10,0x30,0x64,0x1e]
2197
2198 //------------------------------------------------------------------------------
2199 // Load-register (literal)
2200 //------------------------------------------------------------------------------
2201 ldr w3, here
2202 ldr x29, there
2203 ldrsw xzr, everywhere
2204
2205 // CHECK: ldr w3, here // encoding: [0bAAA00011,A,A,0x18]
2206 // CHECK: // fixup A - offset: 0, value: here, kind: fixup_aarch64_ldr_pcrel_imm19
2207 // CHECK: ldr x29, there // encoding: [0bAAA11101,A,A,0x58]
2208 // CHECK: // fixup A - offset: 0, value: there, kind: fixup_aarch64_ldr_pcrel_imm19
2209 // CHECK: ldrsw xzr, everywhere // encoding: [0bAAA11111,A,A,0x98]
2210 // CHECK: // fixup A - offset: 0, value: everywhere, kind: fixup_aarch64_ldr_pcrel_imm19
2211
2212 ldr s0, who_knows
2213 ldr d0, i_dont
2214 ldr q0, there_must_be_a_better_way
2215
2216 // CHECK: ldr s0, who_knows // encoding: [0bAAA00000,A,A,0x1c]
2217 // CHECK: // fixup A - offset: 0, value: who_knows, kind: fixup_aarch64_ldr_pcrel_imm19
2218 // CHECK: ldr d0, i_dont // encoding: [0bAAA00000,A,A,0x5c]
2219 // CHECK: // fixup A - offset: 0, value: i_dont, kind: fixup_aarch64_ldr_pcrel_imm19
2220 // CHECK: ldr q0, there_must_be_a_better_way // encoding: [0bAAA00000,A,A,0x9c]
2221 // CHECK: // fixup A - offset: 0, value: there_must_be_a_better_way, kind: fixup_aarch64_ldr_pcrel_imm19
2222
2223 ldr w0, #1048572
2224 ldr x10, #-1048576
2225 // CHECK: ldr w0, #1048572 // encoding: [0xe0,0xff,0x7f,0x18]
2226 // CHECK: ldr x10, #-1048576 // encoding: [0x0a,0x00,0x80,0x58]
2227
2228 prfm pldl1strm, nowhere
2229 prfm #22, somewhere
2230
2231 // CHECK: prfm pldl1strm, nowhere // encoding: [0bAAA00001,A,A,0xd8]
2232 // CHECK: // fixup A - offset: 0, value: nowhere, kind: fixup_aarch64_ldr_pcrel_imm19
2233 // CHECK: prfm #22, somewhere // encoding: [0bAAA10110,A,A,0xd8]
2234 // CHECK: // fixup A - offset: 0, value: somewhere, kind: fixup_aarch64_ldr_pcrel_imm19
2235
2236 //------------------------------------------------------------------------------
2237 // Load/store exclusive
2238 //------------------------------------------------------------------------------
2239
2240 stxrb w1, w2, [x3, #0]
2241 stxrh w2, w3, [x4]
2242 stxr wzr, w4, [sp]
2243 stxr w5, x6, [x7]
2244 // CHECK: stxrb w1, w2, [x3] // encoding: [0x62,0x7c,0x01,0x08]
2245 // CHECK: stxrh w2, w3, [x4] // encoding: [0x83,0x7c,0x02,0x48]
2246 // CHECK: stxr wzr, w4, [sp] // encoding: [0xe4,0x7f,0x1f,0x88]
2247 // CHECK: stxr w5, x6, [x7] // encoding: [0xe6,0x7c,0x05,0xc8]
2248
2249 ldxrb w7, [x9]
2250 ldxrh wzr, [x10]
2251 ldxr w9, [sp]
2252 ldxr x10, [x11]
2253 // CHECK: ldxrb w7, [x9] // encoding: [0x27,0x7d,0x5f,0x08]
2254 // CHECK: ldxrh wzr, [x10] // encoding: [0x5f,0x7d,0x5f,0x48]
2255 // CHECK: ldxr w9, [sp] // encoding: [0xe9,0x7f,0x5f,0x88]
2256 // CHECK: ldxr x10, [x11] // encoding: [0x6a,0x7d,0x5f,0xc8]
2257
2258 stxp w11, w12, w13, [x14]
2259 stxp wzr, x23, x14, [x15]
2260 // CHECK: stxp w11, w12, w13, [x14] // encoding: [0xcc,0x35,0x2b,0x88]
2261 // CHECK: stxp wzr, x23, x14, [x15] // encoding: [0xf7,0x39,0x3f,0xc8]
2262
2263 ldxp w12, wzr, [sp]
2264 ldxp x13, x14, [x15]
2265 // CHECK: ldxp w12, wzr, [sp] // encoding: [0xec,0x7f,0x7f,0x88]
2266 // CHECK: ldxp x13, x14, [x15] // encoding: [0xed,0x39,0x7f,0xc8]
2267
2268 stlxrb w14, w15, [x16]
2269 stlxrh w15, w16, [x17,#0]
2270 stlxr wzr, w17, [sp]
2271 stlxr w18, x19, [x20]
2272 // CHECK: stlxrb w14, w15, [x16] // encoding: [0x0f,0xfe,0x0e,0x08]
2273 // CHECK: stlxrh w15, w16, [x17] // encoding: [0x30,0xfe,0x0f,0x48]
2274 // CHECK: stlxr wzr, w17, [sp] // encoding: [0xf1,0xff,0x1f,0x88]
2275 // CHECK: stlxr w18, x19, [x20] // encoding: [0x93,0xfe,0x12,0xc8]
2276
2277 ldaxrb w19, [x21]
2278 ldaxrh w20, [sp]
2279 ldaxr wzr, [x22]
2280 ldaxr x21, [x23]
2281 // CHECK: ldaxrb w19, [x21] // encoding: [0xb3,0xfe,0x5f,0x08]
2282 // CHECK: ldaxrh w20, [sp] // encoding: [0xf4,0xff,0x5f,0x48]
2283 // CHECK: ldaxr wzr, [x22] // encoding: [0xdf,0xfe,0x5f,0x88]
2284 // CHECK: ldaxr x21, [x23] // encoding: [0xf5,0xfe,0x5f,0xc8]
2285
2286 stlxp wzr, w22, w23, [x24]
2287 stlxp w25, x26, x27, [sp]
2288 // CHECK: stlxp wzr, w22, w23, [x24] // encoding: [0x16,0xdf,0x3f,0x88]
2289 // CHECK: stlxp w25, x26, x27, [sp] // encoding: [0xfa,0xef,0x39,0xc8]
2290
2291 ldaxp w26, wzr, [sp]
2292 ldaxp x27, x28, [x30]
2293 // CHECK: ldaxp w26, wzr, [sp] // encoding: [0xfa,0xff,0x7f,0x88]
2294 // CHECK: ldaxp x27, x28, [x30] // encoding: [0xdb,0xf3,0x7f,0xc8]
2295
2296 stlrb w27, [sp]
2297 stlrh w28, [x0]
2298 stlr wzr, [x1]
2299 stlr x30, [x2]
2300 // CHECK: stlrb w27, [sp] // encoding: [0xfb,0xff,0x9f,0x08]
2301 // CHECK: stlrh w28, [x0] // encoding: [0x1c,0xfc,0x9f,0x48]
2302 // CHECK: stlr wzr, [x1] // encoding: [0x3f,0xfc,0x9f,0x88]
2303 // CHECK: stlr x30, [x2] // encoding: [0x5e,0xfc,0x9f,0xc8]
2304
2305 ldarb w29, [sp]
2306 ldarh w30, [x0]
2307 ldar wzr, [x1]
2308 ldar x1, [x2]
2309 // CHECK: ldarb w29, [sp] // encoding: [0xfd,0xff,0xdf,0x08]
2310 // CHECK: ldarh w30, [x0] // encoding: [0x1e,0xfc,0xdf,0x48]
2311 // CHECK: ldar wzr, [x1] // encoding: [0x3f,0xfc,0xdf,0x88]
2312 // CHECK: ldar x1, [x2] // encoding: [0x41,0xfc,0xdf,0xc8]
2313
2314 stlxp wzr, w22, w23, [x24,#0]
2315 // CHECK: stlxp wzr, w22, w23, [x24] // encoding: [0x16,0xdf,0x3f,0x88]
2316
2317 //------------------------------------------------------------------------------
2318 // Load/store (unaligned immediate)
2319 //------------------------------------------------------------------------------
2320
2321 sturb w9, [sp, #0]
2322 sturh wzr, [x12, #255]
2323 stur w16, [x0, #-256]
2324 stur x28, [x14, #1]
2325 // CHECK: sturb w9, [sp] // encoding: [0xe9,0x03,0x00,0x38]
2326 // CHECK: sturh wzr, [x12, #255] // encoding: [0x9f,0xf1,0x0f,0x78]
2327 // CHECK: stur w16, [x0, #-256] // encoding: [0x10,0x00,0x10,0xb8]
2328 // CHECK: stur x28, [x14, #1] // encoding: [0xdc,0x11,0x00,0xf8]
2329
2330 ldurb w1, [x20, #255]
2331 ldurh w20, [x1, #255]
2332 ldur w12, [sp, #255]
2333 ldur xzr, [x12, #255]
2334 // CHECK: ldurb w1, [x20, #255] // encoding: [0x81,0xf2,0x4f,0x38]
2335 // CHECK: ldurh w20, [x1, #255] // encoding: [0x34,0xf0,0x4f,0x78]
2336 // CHECK: ldur w12, [sp, #255] // encoding: [0xec,0xf3,0x4f,0xb8]
2337 // CHECK: ldur xzr, [x12, #255] // encoding: [0x9f,0xf1,0x4f,0xf8]
2338
2339 ldursb x9, [x7, #-256]
2340 ldursh x17, [x19, #-256]
2341 ldursw x20, [x15, #-256]
2342 ldursw x13, [x2]
2343 prfum pldl2keep, [sp, #-256]
2344 ldursb w19, [x1, #-256]
2345 ldursh w15, [x21, #-256]
2346 // CHECK: ldursb x9, [x7, #-256] // encoding: [0xe9,0x00,0x90,0x38]
2347 // CHECK: ldursh x17, [x19, #-256] // encoding: [0x71,0x02,0x90,0x78]
2348 // CHECK: ldursw x20, [x15, #-256] // encoding: [0xf4,0x01,0x90,0xb8]
2349 // CHECK: ldursw x13, [x2] // encoding: [0x4d,0x00,0x80,0xb8]
2350 // CHECK: prfum pldl2keep, [sp, #-256] // encoding: [0xe2,0x03,0x90,0xf8]
2351 // CHECK: ldursb w19, [x1, #-256] // encoding: [0x33,0x00,0xd0,0x38]
2352 // CHECK: ldursh w15, [x21, #-256] // encoding: [0xaf,0x02,0xd0,0x78]
2353
2354 stur b0, [sp, #1]
2355 stur h12, [x12, #-1]
2356 stur s15, [x0, #255]
2357 stur d31, [x5, #25]
2358 stur q9, [x5]
2359 // CHECK: stur b0, [sp, #1] // encoding: [0xe0,0x13,0x00,0x3c]
2360 // CHECK: stur h12, [x12, #-1] // encoding: [0x8c,0xf1,0x1f,0x7c]
2361 // CHECK: stur s15, [x0, #255] // encoding: [0x0f,0xf0,0x0f,0xbc]
2362 // CHECK: stur d31, [x5, #25] // encoding: [0xbf,0x90,0x01,0xfc]
2363 // CHECK: stur q9, [x5] // encoding: [0xa9,0x00,0x80,0x3c]
2364
2365 ldur b3, [sp]
2366 ldur h5, [x4, #-256]
2367 ldur s7, [x12, #-1]
2368 ldur d11, [x19, #4]
2369 ldur q13, [x1, #2]
2370 // CHECK: ldur b3, [sp] // encoding: [0xe3,0x03,0x40,0x3c]
2371 // CHECK: ldur h5, [x4, #-256] // encoding: [0x85,0x00,0x50,0x7c]
2372 // CHECK: ldur s7, [x12, #-1] // encoding: [0x87,0xf1,0x5f,0xbc]
2373 // CHECK: ldur d11, [x19, #4] // encoding: [0x6b,0x42,0x40,0xfc]
2374 // CHECK: ldur q13, [x1, #2] // encoding: [0x2d,0x20,0xc0,0x3c]
2375
2376 //------------------------------------------------------------------------------
2377 // Load/store (unsigned immediate)
2378 //------------------------------------------------------------------------------
2379
2380 //// Basic addressing mode limits: 8 byte access
2381 ldr x0, [x0]
2382 ldr x4, [x29, #0]
2383 ldr x30, [x12, #32760]
2384 ldr x20, [sp, #8]
2385 // CHECK: ldr x0, [x0] // encoding: [0x00,0x00,0x40,0xf9]
2386 // CHECK: ldr x4, [x29] // encoding: [0xa4,0x03,0x40,0xf9]
2387 // CHECK: ldr x30, [x12, #32760] // encoding: [0x9e,0xfd,0x7f,0xf9]
2388 // CHECK: ldr x20, [sp, #8] // encoding: [0xf4,0x07,0x40,0xf9]
2389
2390 //// Rt treats 31 as zero-register
2391 ldr xzr, [sp]
2392 // CHECK: ldr xzr, [sp] // encoding: [0xff,0x03,0x40,0xf9]
2393
2394 //// 4-byte load, check still 64-bit address, limits
2395 ldr w2, [sp]
2396 ldr w17, [sp, #16380]
2397 ldr w13, [x2, #4]
2398 // CHECK: ldr w2, [sp] // encoding: [0xe2,0x03,0x40,0xb9]
2399 // CHECK: ldr w17, [sp, #16380] // encoding: [0xf1,0xff,0x7f,0xb9]
2400 // CHECK: ldr w13, [x2, #4] // encoding: [0x4d,0x04,0x40,0xb9]
2401
2402 //// Signed 4-byte load. Limits.
2403 ldrsw x2, [x5,#4]
2404 ldrsw x23, [sp, #16380]
2405 // CHECK: ldrsw x2, [x5, #4] // encoding: [0xa2,0x04,0x80,0xb9]
2406 // CHECK: ldrsw x23, [sp, #16380] // encoding: [0xf7,0xff,0xbf,0xb9]
2407
2408 //// 2-byte loads
2409 ldrh w2, [x4]
2410 ldrsh w23, [x6, #8190]
2411 ldrsh wzr, [sp, #2]
2412 ldrsh x29, [x2, #2]
2413 // CHECK: ldrh w2, [x4] // encoding: [0x82,0x00,0x40,0x79]
2414 // CHECK: ldrsh w23, [x6, #8190] // encoding: [0xd7,0xfc,0xff,0x79]
2415 // CHECK: ldrsh wzr, [sp, #2] // encoding: [0xff,0x07,0xc0,0x79]
2416 // CHECK: ldrsh x29, [x2, #2] // encoding: [0x5d,0x04,0x80,0x79]
2417
2418 //// 1-byte loads
2419 ldrb w26, [x3, #121]
2420 ldrb w12, [x2, #0]
2421 ldrsb w27, [sp, #4095]
2422 ldrsb xzr, [x15]
2423 // CHECK: ldrb w26, [x3, #121] // encoding: [0x7a,0xe4,0x41,0x39]
2424 // CHECK: ldrb w12, [x2] // encoding: [0x4c,0x00,0x40,0x39]
2425 // CHECK: ldrsb w27, [sp, #4095] // encoding: [0xfb,0xff,0xff,0x39]
2426 // CHECK: ldrsb xzr, [x15] // encoding: [0xff,0x01,0x80,0x39]
2427
2428 //// Stores
2429 str x30, [sp]
2430 str w20, [x4, #16380]
2431 strh w20, [x10, #14]
2432 strh w17, [sp, #8190]
2433 strb w23, [x3, #4095]
2434 strb wzr, [x2]
2435 // CHECK: str x30, [sp] // encoding: [0xfe,0x03,0x00,0xf9]
2436 // CHECK: str w20, [x4, #16380] // encoding: [0x94,0xfc,0x3f,0xb9]
2437 // CHECK: strh w20, [x10, #14] // encoding: [0x54,0x1d,0x00,0x79]
2438 // CHECK: strh w17, [sp, #8190] // encoding: [0xf1,0xff,0x3f,0x79]
2439 // CHECK: strb w23, [x3, #4095] // encoding: [0x77,0xfc,0x3f,0x39]
2440 // CHECK: strb wzr, [x2] // encoding: [0x5f,0x00,0x00,0x39]
2441
2442 //// Relocations
2443 str x15, [x5, #:lo12:sym]
2444 ldrb w15, [x5, #:lo12:sym]
2445 ldrsh x15, [x5, #:lo12:sym]
2446 ldrsw x15, [x5, #:lo12:sym]
2447 ldr x15, [x5, #:lo12:sym]
2448 ldr q3, [x2, #:lo12:sym]
2449
2450 // CHECK: str x15, [x5, :lo12:sym] // encoding: [0xaf,0bAAAAAA00,0b00AAAAAA,0xf9]
2451 // CHECK: // fixup A - offset: 0, value: :lo12:sym, kind: fixup_aarch64_ldst_imm12_scale8
2452 // CHECK: ldrb w15, [x5, :lo12:sym] // encoding: [0xaf,0bAAAAAA00,0b01AAAAAA,0x39]
2453 // CHECK: // fixup A - offset: 0, value: :lo12:sym, kind: fixup_aarch64_ldst_imm12_scale1
2454 // CHECK: ldrsh x15, [x5, :lo12:sym] // encoding: [0xaf,0bAAAAAA00,0b10AAAAAA,0x79]
2455 // CHECK: // fixup A - offset: 0, value: :lo12:sym, kind: fixup_aarch64_ldst_imm12_scale2
2456 // CHECK: ldrsw x15, [x5, :lo12:sym] // encoding: [0xaf,0bAAAAAA00,0b10AAAAAA,0xb9]
2457 // CHECK: // fixup A - offset: 0, value: :lo12:sym, kind: fixup_aarch64_ldst_imm12_scale4
2458 // CHECK: ldr x15, [x5, :lo12:sym] // encoding: [0xaf,0bAAAAAA00,0b01AAAAAA,0xf9]
2459 // CHECK: // fixup A - offset: 0, value: :lo12:sym, kind: fixup_aarch64_ldst_imm12_scale8
2460 // CHECK: ldr q3, [x2, :lo12:sym] // encoding: [0x43,0bAAAAAA00,0b11AAAAAA,0x3d]
2461 // CHECK: // fixup A - offset: 0, value: :lo12:sym, kind: fixup_aarch64_ldst_imm12_scale16
2462
2463 prfm pldl1keep, [sp, #8]
2464 prfm pldl1strm, [x3]
2465 prfm pldl2keep, [x5,#16]
2466 prfm pldl2strm, [x2]
2467 prfm pldl3keep, [x5]
2468 prfm pldl3strm, [x6]
2469 prfm plil1keep, [sp, #8]
2470 prfm plil1strm, [x3]
2471 prfm plil2keep, [x5,#16]
2472 prfm plil2strm, [x2]
2473 prfm plil3keep, [x5]
2474 prfm plil3strm, [x6]
2475 prfm pstl1keep, [sp, #8]
2476 prfm pstl1strm, [x3]
2477 prfm pstl2keep, [x5,#16]
2478 prfm pstl2strm, [x2]
2479 prfm pstl3keep, [x5]
2480 prfm pstl3strm, [x6]
2481 prfm #15, [sp]
2482 // CHECK: prfm pldl1keep, [sp, #8] // encoding: [0xe0,0x07,0x80,0xf9]
2483 // CHECK: prfm pldl1strm, [x3{{(, #0)?}}] // encoding: [0x61,0x00,0x80,0xf9]
2484 // CHECK: prfm pldl2keep, [x5, #16] // encoding: [0xa2,0x08,0x80,0xf9]
2485 // CHECK: prfm pldl2strm, [x2{{(, #0)?}}] // encoding: [0x43,0x00,0x80,0xf9]
2486 // CHECK: prfm pldl3keep, [x5{{(, #0)?}}] // encoding: [0xa4,0x00,0x80,0xf9]
2487 // CHECK: prfm pldl3strm, [x6{{(, #0)?}}] // encoding: [0xc5,0x00,0x80,0xf9]
2488 // CHECK: prfm plil1keep, [sp, #8] // encoding: [0xe8,0x07,0x80,0xf9]
2489 // CHECK: prfm plil1strm, [x3{{(, #0)?}}] // encoding: [0x69,0x00,0x80,0xf9]
2490 // CHECK: prfm plil2keep, [x5, #16] // encoding: [0xaa,0x08,0x80,0xf9]
2491 // CHECK: prfm plil2strm, [x2{{(, #0)?}}] // encoding: [0x4b,0x00,0x80,0xf9]
2492 // CHECK: prfm plil3keep, [x5{{(, #0)?}}] // encoding: [0xac,0x00,0x80,0xf9]
2493 // CHECK: prfm plil3strm, [x6{{(, #0)?}}] // encoding: [0xcd,0x00,0x80,0xf9]
2494 // CHECK: prfm pstl1keep, [sp, #8] // encoding: [0xf0,0x07,0x80,0xf9]
2495 // CHECK: prfm pstl1strm, [x3{{(, #0)?}}] // encoding: [0x71,0x00,0x80,0xf9]
2496 // CHECK: prfm pstl2keep, [x5, #16] // encoding: [0xb2,0x08,0x80,0xf9]
2497 // CHECK: prfm pstl2strm, [x2{{(, #0)?}}] // encoding: [0x53,0x00,0x80,0xf9]
2498 // CHECK: prfm pstl3keep, [x5{{(, #0)?}}] // encoding: [0xb4,0x00,0x80,0xf9]
2499 // CHECK: prfm pstl3strm, [x6{{(, #0)?}}] // encoding: [0xd5,0x00,0x80,0xf9]
2500 // CHECK: prfm #15, [sp{{(, #0)?}}] // encoding: [0xef,0x03,0x80,0xf9]
2501
2502 //// Floating-point versions
2503
2504 ldr b31, [sp, #4095]
2505 ldr h20, [x2, #8190]
2506 ldr s10, [x19, #16380]
2507 ldr d3, [x10, #32760]
2508 str q12, [sp, #65520]
2509 // CHECK: ldr b31, [sp, #4095] // encoding: [0xff,0xff,0x7f,0x3d]
2510 // CHECK: ldr h20, [x2, #8190] // encoding: [0x54,0xfc,0x7f,0x7d]
2511 // CHECK: ldr s10, [x19, #16380] // encoding: [0x6a,0xfe,0x7f,0xbd]
2512 // CHECK: ldr d3, [x10, #32760] // encoding: [0x43,0xfd,0x7f,0xfd]
2513 // CHECK: str q12, [sp, #65520] // encoding: [0xec,0xff,0xbf,0x3d]
2514
2515 //------------------------------------------------------------------------------
2516 // Load/store register (register offset)
2517 //------------------------------------------------------------------------------
2518
2519 ldrb w3, [sp, x5]
2520 ldrb w9, [x27, x6, lsl #0]
2521 ldrsb w10, [x30, x7]
2522 ldrb w11, [x29, x3, sxtx]
2523 strb w12, [x28, xzr, sxtx #0]
2524 ldrb w14, [x26, w6, uxtw]
2525 ldrsb w15, [x25, w7, uxtw #0]
2526 ldrb w17, [x23, w9, sxtw]
2527 ldrsb x18, [x22, w10, sxtw #0]
2528 // CHECK: ldrb w3, [sp, x5] // encoding: [0xe3,0x6b,0x65,0x38]
2529 // CHECK: ldrb w9, [x27, x6, lsl #0] // encoding: [0x69,0x7b,0x66,0x38]
2530 // CHECK: ldrsb w10, [x30, x7] // encoding: [0xca,0x6b,0xe7,0x38]
2531 // CHECK: ldrb w11, [x29, x3, sxtx] // encoding: [0xab,0xeb,0x63,0x38]
2532 // CHECK: strb w12, [x28, xzr, sxtx #0] // encoding: [0x8c,0xfb,0x3f,0x38]
2533 // CHECK: ldrb w14, [x26, w6, uxtw] // encoding: [0x4e,0x4b,0x66,0x38]
2534 // CHECK: ldrsb w15, [x25, w7, uxtw #0] // encoding: [0x2f,0x5b,0xe7,0x38]
2535 // CHECK: ldrb w17, [x23, w9, sxtw] // encoding: [0xf1,0xca,0x69,0x38]
2536 // CHECK: ldrsb x18, [x22, w10, sxtw #0] // encoding: [0xd2,0xda,0xaa,0x38]
2537
2538 ldrsh w3, [sp, x5]
2539 ldrsh w9, [x27, x6, lsl #0]
2540 ldrh w10, [x30, x7, lsl #1]
2541 strh w11, [x29, x3, sxtx]
2542 ldrh w12, [x28, xzr, sxtx #0]
2543 ldrsh x13, [x27, x5, sxtx #1]
2544 ldrh w14, [x26, w6, uxtw]
2545 ldrh w15, [x25, w7, uxtw #0]
2546 ldrsh w16, [x24, w8, uxtw #1]
2547 ldrh w17, [x23, w9, sxtw]
2548 ldrh w18, [x22, w10, sxtw #0]
2549 strh w19, [x21, wzr, sxtw #1]
2550 // CHECK: ldrsh w3, [sp, x5] // encoding: [0xe3,0x6b,0xe5,0x78]
2551 // CHECK: ldrsh w9, [x27, x6] // encoding: [0x69,0x6b,0xe6,0x78]
2552 // CHECK: ldrh w10, [x30, x7, lsl #1] // encoding: [0xca,0x7b,0x67,0x78]
2553 // CHECK: strh w11, [x29, x3, sxtx] // encoding: [0xab,0xeb,0x23,0x78]
2554 // CHECK: ldrh w12, [x28, xzr, sxtx] // encoding: [0x8c,0xeb,0x7f,0x78]
2555 // CHECK: ldrsh x13, [x27, x5, sxtx #1] // encoding: [0x6d,0xfb,0xa5,0x78]
2556 // CHECK: ldrh w14, [x26, w6, uxtw] // encoding: [0x4e,0x4b,0x66,0x78]
2557 // CHECK: ldrh w15, [x25, w7, uxtw] // encoding: [0x2f,0x4b,0x67,0x78]
2558 // CHECK: ldrsh w16, [x24, w8, uxtw #1] // encoding: [0x10,0x5b,0xe8,0x78]
2559 // CHECK: ldrh w17, [x23, w9, sxtw] // encoding: [0xf1,0xca,0x69,0x78]
2560 // CHECK: ldrh w18, [x22, w10, sxtw] // encoding: [0xd2,0xca,0x6a,0x78]
2561 // CHECK: strh w19, [x21, wzr, sxtw #1] // encoding: [0xb3,0xda,0x3f,0x78]
2562
2563 ldr w3, [sp, x5]
2564 ldr s9, [x27, x6, lsl #0]
2565 ldr w10, [x30, x7, lsl #2]
2566 ldr w11, [x29, x3, sxtx]
2567 str s12, [x28, xzr, sxtx #0]
2568 str w13, [x27, x5, sxtx #2]
2569 str w14, [x26, w6, uxtw]
2570 ldr w15, [x25, w7, uxtw #0]
2571 ldr w16, [x24, w8, uxtw #2]
2572 ldrsw x17, [x23, w9, sxtw]
2573 ldr w18, [x22, w10, sxtw #0]
2574 ldrsw x19, [x21, wzr, sxtw #2]
2575 // CHECK: ldr w3, [sp, x5] // encoding: [0xe3,0x6b,0x65,0xb8]
2576 // CHECK: ldr s9, [x27, x6] // encoding: [0x69,0x6b,0x66,0xbc]
2577 // CHECK: ldr w10, [x30, x7, lsl #2] // encoding: [0xca,0x7b,0x67,0xb8]
2578 // CHECK: ldr w11, [x29, x3, sxtx] // encoding: [0xab,0xeb,0x63,0xb8]
2579 // CHECK: str s12, [x28, xzr, sxtx] // encoding: [0x8c,0xeb,0x3f,0xbc]
2580 // CHECK: str w13, [x27, x5, sxtx #2] // encoding: [0x6d,0xfb,0x25,0xb8]
2581 // CHECK: str w14, [x26, w6, uxtw] // encoding: [0x4e,0x4b,0x26,0xb8]
2582 // CHECK: ldr w15, [x25, w7, uxtw] // encoding: [0x2f,0x4b,0x67,0xb8]
2583 // CHECK: ldr w16, [x24, w8, uxtw #2] // encoding: [0x10,0x5b,0x68,0xb8]
2584 // CHECK: ldrsw x17, [x23, w9, sxtw] // encoding: [0xf1,0xca,0xa9,0xb8]
2585 // CHECK: ldr w18, [x22, w10, sxtw] // encoding: [0xd2,0xca,0x6a,0xb8]
2586 // CHECK: ldrsw x19, [x21, wzr, sxtw #2] // encoding: [0xb3,0xda,0xbf,0xb8]
2587
2588 ldr x3, [sp, x5]
2589 str x9, [x27, x6, lsl #0]
2590 ldr d10, [x30, x7, lsl #3]
2591 str x11, [x29, x3, sxtx]
2592 ldr x12, [x28, xzr, sxtx #0]
2593 ldr x13, [x27, x5, sxtx #3]
2594 prfm pldl1keep, [x26, w6, uxtw]
2595 ldr x15, [x25, w7, uxtw #0]
2596 ldr x16, [x24, w8, uxtw #3]
2597 ldr x17, [x23, w9, sxtw]
2598 ldr x18, [x22, w10, sxtw #0]
2599 str d19, [x21, wzr, sxtw #3]
2600 prfm #6, [x0, x5]
2601 // CHECK: ldr x3, [sp, x5] // encoding: [0xe3,0x6b,0x65,0xf8]
2602 // CHECK: str x9, [x27, x6] // encoding: [0x69,0x6b,0x26,0xf8]
2603 // CHECK: ldr d10, [x30, x7, lsl #3] // encoding: [0xca,0x7b,0x67,0xfc]
2604 // CHECK: str x11, [x29, x3, sxtx] // encoding: [0xab,0xeb,0x23,0xf8]
2605 // CHECK: ldr x12, [x28, xzr, sxtx] // encoding: [0x8c,0xeb,0x7f,0xf8]
2606 // CHECK: ldr x13, [x27, x5, sxtx #3] // encoding: [0x6d,0xfb,0x65,0xf8]
2607 // CHECK: prfm pldl1keep, [x26, w6, uxtw] // encoding: [0x40,0x4b,0xa6,0xf8]
2608 // CHECK: ldr x15, [x25, w7, uxtw] // encoding: [0x2f,0x4b,0x67,0xf8]
2609 // CHECK: ldr x16, [x24, w8, uxtw #3] // encoding: [0x10,0x5b,0x68,0xf8]
2610 // CHECK: ldr x17, [x23, w9, sxtw] // encoding: [0xf1,0xca,0x69,0xf8]
2611 // CHECK: ldr x18, [x22, w10, sxtw] // encoding: [0xd2,0xca,0x6a,0xf8]
2612 // CHECK: str d19, [x21, wzr, sxtw #3] // encoding: [0xb3,0xda,0x3f,0xfc]
2613 // CHECK: prfm #6, [x0, x5{{(, lsl #0)?}}] // encoding: [0x06,0x68,0xa5,0xf8]
2614
2615 ldr q3, [sp, x5]
2616 ldr q9, [x27, x6, lsl #0]
2617 ldr q10, [x30, x7, lsl #4]
2618 str q11, [x29, x3, sxtx]
2619 str q12, [x28, xzr, sxtx #0]
2620 str q13, [x27, x5, sxtx #4]
2621 ldr q14, [x26, w6, uxtw]
2622 ldr q15, [x25, w7, uxtw #0]
2623 ldr q16, [x24, w8, uxtw #4]
2624 ldr q17, [x23, w9, sxtw]
2625 str q18, [x22, w10, sxtw #0]
2626 ldr q19, [x21, wzr, sxtw #4]
2627 // CHECK: ldr q3, [sp, x5] // encoding: [0xe3,0x6b,0xe5,0x3c]
2628 // CHECK: ldr q9, [x27, x6] // encoding: [0x69,0x6b,0xe6,0x3c]
2629 // CHECK: ldr q10, [x30, x7, lsl #4] // encoding: [0xca,0x7b,0xe7,0x3c]
2630 // CHECK: str q11, [x29, x3, sxtx] // encoding: [0xab,0xeb,0xa3,0x3c]
2631 // CHECK: str q12, [x28, xzr, sxtx] // encoding: [0x8c,0xeb,0xbf,0x3c]
2632 // CHECK: str q13, [x27, x5, sxtx #4] // encoding: [0x6d,0xfb,0xa5,0x3c]
2633 // CHECK: ldr q14, [x26, w6, uxtw] // encoding: [0x4e,0x4b,0xe6,0x3c]
2634 // CHECK: ldr q15, [x25, w7, uxtw] // encoding: [0x2f,0x4b,0xe7,0x3c]
2635 // CHECK: ldr q16, [x24, w8, uxtw #4] // encoding: [0x10,0x5b,0xe8,0x3c]
2636 // CHECK: ldr q17, [x23, w9, sxtw] // encoding: [0xf1,0xca,0xe9,0x3c]
2637 // CHECK: str q18, [x22, w10, sxtw] // encoding: [0xd2,0xca,0xaa,0x3c]
2638 // CHECK: ldr q19, [x21, wzr, sxtw #4] // encoding: [0xb3,0xda,0xff,0x3c]
2639
2640 //------------------------------------------------------------------------------
2641 // Load/store register (immediate post-indexed)
2642 //------------------------------------------------------------------------------
2643
2644 strb w9, [x2], #255
2645 strb w10, [x3], #1
2646 strb w10, [x3], #-256
2647 strh w9, [x2], #255
2648 strh w9, [x2], #1
2649 strh w10, [x3], #-256
2650 // CHECK: strb w9, [x2], #255 // encoding: [0x49,0xf4,0x0f,0x38]
2651 // CHECK: strb w10, [x3], #1 // encoding: [0x6a,0x14,0x00,0x38]
2652 // CHECK: strb w10, [x3], #-256 // encoding: [0x6a,0x04,0x10,0x38]
2653 // CHECK: strh w9, [x2], #255 // encoding: [0x49,0xf4,0x0f,0x78]
2654 // CHECK: strh w9, [x2], #1 // encoding: [0x49,0x14,0x00,0x78]
2655 // CHECK: strh w10, [x3], #-256 // encoding: [0x6a,0x04,0x10,0x78]
2656
2657 str w19, [sp], #255
2658 str w20, [x30], #1
2659 str w21, [x12], #-256
2660 str xzr, [x9], #255
2661 str x2, [x3], #1
2662 str x19, [x12], #-256
2663 // CHECK: str w19, [sp], #255 // encoding: [0xf3,0xf7,0x0f,0xb8]
2664 // CHECK: str w20, [x30], #1 // encoding: [0xd4,0x17,0x00,0xb8]
2665 // CHECK: str w21, [x12], #-256 // encoding: [0x95,0x05,0x10,0xb8]
2666 // CHECK: str xzr, [x9], #255 // encoding: [0x3f,0xf5,0x0f,0xf8]
2667 // CHECK: str x2, [x3], #1 // encoding: [0x62,0x14,0x00,0xf8]
2668 // CHECK: str x19, [x12], #-256 // encoding: [0x93,0x05,0x10,0xf8]
2669
2670 ldrb w9, [x2], #255
2671 ldrb w10, [x3], #1
2672 ldrb w10, [x3], #-256
2673 ldrh w9, [x2], #255
2674 ldrh w9, [x2], #1
2675 ldrh w10, [x3], #-256
2676 // CHECK: ldrb w9, [x2], #255 // encoding: [0x49,0xf4,0x4f,0x38]
2677 // CHECK: ldrb w10, [x3], #1 // encoding: [0x6a,0x14,0x40,0x38]
2678 // CHECK: ldrb w10, [x3], #-256 // encoding: [0x6a,0x04,0x50,0x38]
2679 // CHECK: ldrh w9, [x2], #255 // encoding: [0x49,0xf4,0x4f,0x78]
2680 // CHECK: ldrh w9, [x2], #1 // encoding: [0x49,0x14,0x40,0x78]
2681 // CHECK: ldrh w10, [x3], #-256 // encoding: [0x6a,0x04,0x50,0x78]
2682
2683 ldr w19, [sp], #255
2684 ldr w20, [x30], #1
2685 ldr w21, [x12], #-256
2686 ldr xzr, [x9], #255
2687 ldr x2, [x3], #1
2688 ldr x19, [x12], #-256
2689 // CHECK: ldr w19, [sp], #255 // encoding: [0xf3,0xf7,0x4f,0xb8]
2690 // CHECK: ldr w20, [x30], #1 // encoding: [0xd4,0x17,0x40,0xb8]
2691 // CHECK: ldr w21, [x12], #-256 // encoding: [0x95,0x05,0x50,0xb8]
2692 // CHECK: ldr xzr, [x9], #255 // encoding: [0x3f,0xf5,0x4f,0xf8]
2693 // CHECK: ldr x2, [x3], #1 // encoding: [0x62,0x14,0x40,0xf8]
2694 // CHECK: ldr x19, [x12], #-256 // encoding: [0x93,0x05,0x50,0xf8]
2695
2696 ldrsb xzr, [x9], #255
2697 ldrsb x2, [x3], #1
2698 ldrsb x19, [x12], #-256
2699 ldrsh xzr, [x9], #255
2700 ldrsh x2, [x3], #1
2701 ldrsh x19, [x12], #-256
2702 ldrsw xzr, [x9], #255
2703 ldrsw x2, [x3], #1
2704 ldrsw x19, [x12], #-256
2705 // CHECK: ldrsb xzr, [x9], #255 // encoding: [0x3f,0xf5,0x8f,0x38]
2706 // CHECK: ldrsb x2, [x3], #1 // encoding: [0x62,0x14,0x80,0x38]
2707 // CHECK: ldrsb x19, [x12], #-256 // encoding: [0x93,0x05,0x90,0x38]
2708 // CHECK: ldrsh xzr, [x9], #255 // encoding: [0x3f,0xf5,0x8f,0x78]
2709 // CHECK: ldrsh x2, [x3], #1 // encoding: [0x62,0x14,0x80,0x78]
2710 // CHECK: ldrsh x19, [x12], #-256 // encoding: [0x93,0x05,0x90,0x78]
2711 // CHECK: ldrsw xzr, [x9], #255 // encoding: [0x3f,0xf5,0x8f,0xb8]
2712 // CHECK: ldrsw x2, [x3], #1 // encoding: [0x62,0x14,0x80,0xb8]
2713 // CHECK: ldrsw x19, [x12], #-256 // encoding: [0x93,0x05,0x90,0xb8]
2714
2715 ldrsb wzr, [x9], #255
2716 ldrsb w2, [x3], #1
2717 ldrsb w19, [x12], #-256
2718 ldrsh wzr, [x9], #255
2719 ldrsh w2, [x3], #1
2720 ldrsh w19, [x12], #-256
2721 // CHECK: ldrsb wzr, [x9], #255 // encoding: [0x3f,0xf5,0xcf,0x38]
2722 // CHECK: ldrsb w2, [x3], #1 // encoding: [0x62,0x14,0xc0,0x38]
2723 // CHECK: ldrsb w19, [x12], #-256 // encoding: [0x93,0x05,0xd0,0x38]
2724 // CHECK: ldrsh wzr, [x9], #255 // encoding: [0x3f,0xf5,0xcf,0x78]
2725 // CHECK: ldrsh w2, [x3], #1 // encoding: [0x62,0x14,0xc0,0x78]
2726 // CHECK: ldrsh w19, [x12], #-256 // encoding: [0x93,0x05,0xd0,0x78]
2727
2728 str b0, [x0], #255
2729 str b3, [x3], #1
2730 str b5, [sp], #-256
2731 str h10, [x10], #255
2732 str h13, [x23], #1
2733 str h15, [sp], #-256
2734 str s20, [x20], #255
2735 str s23, [x23], #1
2736 str s25, [x0], #-256
2737 str d20, [x20], #255
2738 str d23, [x23], #1
2739 str d25, [x0], #-256
2740 // CHECK: str b0, [x0], #255 // encoding: [0x00,0xf4,0x0f,0x3c]
2741 // CHECK: str b3, [x3], #1 // encoding: [0x63,0x14,0x00,0x3c]
2742 // CHECK: str b5, [sp], #-256 // encoding: [0xe5,0x07,0x10,0x3c]
2743 // CHECK: str h10, [x10], #255 // encoding: [0x4a,0xf5,0x0f,0x7c]
2744 // CHECK: str h13, [x23], #1 // encoding: [0xed,0x16,0x00,0x7c]
2745 // CHECK: str h15, [sp], #-256 // encoding: [0xef,0x07,0x10,0x7c]
2746 // CHECK: str s20, [x20], #255 // encoding: [0x94,0xf6,0x0f,0xbc]
2747 // CHECK: str s23, [x23], #1 // encoding: [0xf7,0x16,0x00,0xbc]
2748 // CHECK: str s25, [x0], #-256 // encoding: [0x19,0x04,0x10,0xbc]
2749 // CHECK: str d20, [x20], #255 // encoding: [0x94,0xf6,0x0f,0xfc]
2750 // CHECK: str d23, [x23], #1 // encoding: [0xf7,0x16,0x00,0xfc]
2751 // CHECK: str d25, [x0], #-256 // encoding: [0x19,0x04,0x10,0xfc]
2752
2753 ldr b0, [x0], #255
2754 ldr b3, [x3], #1
2755 ldr b5, [sp], #-256
2756 ldr h10, [x10], #255
2757 ldr h13, [x23], #1
2758 ldr h15, [sp], #-256
2759 ldr s20, [x20], #255
2760 ldr s23, [x23], #1
2761 ldr s25, [x0], #-256
2762 ldr d20, [x20], #255
2763 ldr d23, [x23], #1
2764 ldr d25, [x0], #-256
2765 // CHECK: ldr b0, [x0], #255 // encoding: [0x00,0xf4,0x4f,0x3c]
2766 // CHECK: ldr b3, [x3], #1 // encoding: [0x63,0x14,0x40,0x3c]
2767 // CHECK: ldr b5, [sp], #-256 // encoding: [0xe5,0x07,0x50,0x3c]
2768 // CHECK: ldr h10, [x10], #255 // encoding: [0x4a,0xf5,0x4f,0x7c]
2769 // CHECK: ldr h13, [x23], #1 // encoding: [0xed,0x16,0x40,0x7c]
2770 // CHECK: ldr h15, [sp], #-256 // encoding: [0xef,0x07,0x50,0x7c]
2771 // CHECK: ldr s20, [x20], #255 // encoding: [0x94,0xf6,0x4f,0xbc]
2772 // CHECK: ldr s23, [x23], #1 // encoding: [0xf7,0x16,0x40,0xbc]
2773 // CHECK: ldr s25, [x0], #-256 // encoding: [0x19,0x04,0x50,0xbc]
2774 // CHECK: ldr d20, [x20], #255 // encoding: [0x94,0xf6,0x4f,0xfc]
2775 // CHECK: ldr d23, [x23], #1 // encoding: [0xf7,0x16,0x40,0xfc]
2776 // CHECK: ldr d25, [x0], #-256 // encoding: [0x19,0x04,0x50,0xfc]
2777
2778 ldr q20, [x1], #255
2779 ldr q23, [x9], #1
2780 ldr q25, [x20], #-256
2781 str q10, [x1], #255
2782 str q22, [sp], #1
2783 str q21, [x20], #-256
2784 // CHECK: ldr q20, [x1], #255 // encoding: [0x34,0xf4,0xcf,0x3c]
2785 // CHECK: ldr q23, [x9], #1 // encoding: [0x37,0x15,0xc0,0x3c]
2786 // CHECK: ldr q25, [x20], #-256 // encoding: [0x99,0x06,0xd0,0x3c]
2787 // CHECK: str q10, [x1], #255 // encoding: [0x2a,0xf4,0x8f,0x3c]
2788 // CHECK: str q22, [sp], #1 // encoding: [0xf6,0x17,0x80,0x3c]
2789 // CHECK: str q21, [x20], #-256 // encoding: [0x95,0x06,0x90,0x3c]
2790
2791 //------------------------------------------------------------------------------
2792 // Load/store register (immediate pre-indexed)
2793 //------------------------------------------------------------------------------
2794
2795 ldr x3, [x4, #0]!
2796 ldr xzr, [sp, #0]!
2797 // CHECK: ldr x3, [x4, #0]! // encoding: [0x83,0x0c,0x40,0xf8]
2798 // CHECK: ldr xzr, [sp, #0]! // encoding: [0xff,0x0f,0x40,0xf8]
2799
2800 strb w9, [x2, #255]!
2801 strb w10, [x3, #1]!
2802 strb w10, [x3, #-256]!
2803 strh w9, [x2, #255]!
2804 strh w9, [x2, #1]!
2805 strh w10, [x3, #-256]!
2806 // CHECK: strb w9, [x2, #255]! // encoding: [0x49,0xfc,0x0f,0x38]
2807 // CHECK: strb w10, [x3, #1]! // encoding: [0x6a,0x1c,0x00,0x38]
2808 // CHECK: strb w10, [x3, #-256]! // encoding: [0x6a,0x0c,0x10,0x38]
2809 // CHECK: strh w9, [x2, #255]! // encoding: [0x49,0xfc,0x0f,0x78]
2810 // CHECK: strh w9, [x2, #1]! // encoding: [0x49,0x1c,0x00,0x78]
2811 // CHECK: strh w10, [x3, #-256]! // encoding: [0x6a,0x0c,0x10,0x78]
2812
2813 str w19, [sp, #255]!
2814 str w20, [x30, #1]!
2815 str w21, [x12, #-256]!
2816 str xzr, [x9, #255]!
2817 str x2, [x3, #1]!
2818 str x19, [x12, #-256]!
2819 // CHECK: str w19, [sp, #255]! // encoding: [0xf3,0xff,0x0f,0xb8]
2820 // CHECK: str w20, [x30, #1]! // encoding: [0xd4,0x1f,0x00,0xb8]
2821 // CHECK: str w21, [x12, #-256]! // encoding: [0x95,0x0d,0x10,0xb8]
2822 // CHECK: str xzr, [x9, #255]! // encoding: [0x3f,0xfd,0x0f,0xf8]
2823 // CHECK: str x2, [x3, #1]! // encoding: [0x62,0x1c,0x00,0xf8]
2824 // CHECK: str x19, [x12, #-256]! // encoding: [0x93,0x0d,0x10,0xf8]
2825
2826 ldrb w9, [x2, #255]!
2827 ldrb w10, [x3, #1]!
2828 ldrb w10, [x3, #-256]!
2829 ldrh w9, [x2, #255]!
2830 ldrh w9, [x2, #1]!
2831 ldrh w10, [x3, #-256]!
2832 // CHECK: ldrb w9, [x2, #255]! // encoding: [0x49,0xfc,0x4f,0x38]
2833 // CHECK: ldrb w10, [x3, #1]! // encoding: [0x6a,0x1c,0x40,0x38]
2834 // CHECK: ldrb w10, [x3, #-256]! // encoding: [0x6a,0x0c,0x50,0x38]
2835 // CHECK: ldrh w9, [x2, #255]! // encoding: [0x49,0xfc,0x4f,0x78]
2836 // CHECK: ldrh w9, [x2, #1]! // encoding: [0x49,0x1c,0x40,0x78]
2837 // CHECK: ldrh w10, [x3, #-256]! // encoding: [0x6a,0x0c,0x50,0x78]
2838
2839 ldr w19, [sp, #255]!
2840 ldr w20, [x30, #1]!
2841 ldr w21, [x12, #-256]!
2842 ldr xzr, [x9, #255]!
2843 ldr x2, [x3, #1]!
2844 ldr x19, [x12, #-256]!
2845 // CHECK: ldr w19, [sp, #255]! // encoding: [0xf3,0xff,0x4f,0xb8]
2846 // CHECK: ldr w20, [x30, #1]! // encoding: [0xd4,0x1f,0x40,0xb8]
2847 // CHECK: ldr w21, [x12, #-256]! // encoding: [0x95,0x0d,0x50,0xb8]
2848 // CHECK: ldr xzr, [x9, #255]! // encoding: [0x3f,0xfd,0x4f,0xf8]
2849 // CHECK: ldr x2, [x3, #1]! // encoding: [0x62,0x1c,0x40,0xf8]
2850 // CHECK: ldr x19, [x12, #-256]! // encoding: [0x93,0x0d,0x50,0xf8]
2851
2852 ldrsb xzr, [x9, #255]!
2853 ldrsb x2, [x3, #1]!
2854 ldrsb x19, [x12, #-256]!
2855 ldrsh xzr, [x9, #255]!
2856 ldrsh x2, [x3, #1]!
2857 ldrsh x19, [x12, #-256]!
2858 ldrsw xzr, [x9, #255]!
2859 ldrsw x2, [x3, #1]!
2860 ldrsw x19, [x12, #-256]!
2861 // CHECK: ldrsb xzr, [x9, #255]! // encoding: [0x3f,0xfd,0x8f,0x38]
2862 // CHECK: ldrsb x2, [x3, #1]! // encoding: [0x62,0x1c,0x80,0x38]
2863 // CHECK: ldrsb x19, [x12, #-256]! // encoding: [0x93,0x0d,0x90,0x38]
2864 // CHECK: ldrsh xzr, [x9, #255]! // encoding: [0x3f,0xfd,0x8f,0x78]
2865 // CHECK: ldrsh x2, [x3, #1]! // encoding: [0x62,0x1c,0x80,0x78]
2866 // CHECK: ldrsh x19, [x12, #-256]! // encoding: [0x93,0x0d,0x90,0x78]
2867 // CHECK: ldrsw xzr, [x9, #255]! // encoding: [0x3f,0xfd,0x8f,0xb8]
2868 // CHECK: ldrsw x2, [x3, #1]! // encoding: [0x62,0x1c,0x80,0xb8]
2869 // CHECK: ldrsw x19, [x12, #-256]! // encoding: [0x93,0x0d,0x90,0xb8]
2870
2871 ldrsb wzr, [x9, #255]!
2872 ldrsb w2, [x3, #1]!
2873 ldrsb w19, [x12, #-256]!
2874 ldrsh wzr, [x9, #255]!
2875 ldrsh w2, [x3, #1]!
2876 ldrsh w19, [x12, #-256]!
2877 // CHECK: ldrsb wzr, [x9, #255]! // encoding: [0x3f,0xfd,0xcf,0x38]
2878 // CHECK: ldrsb w2, [x3, #1]! // encoding: [0x62,0x1c,0xc0,0x38]
2879 // CHECK: ldrsb w19, [x12, #-256]! // encoding: [0x93,0x0d,0xd0,0x38]
2880 // CHECK: ldrsh wzr, [x9, #255]! // encoding: [0x3f,0xfd,0xcf,0x78]
2881 // CHECK: ldrsh w2, [x3, #1]! // encoding: [0x62,0x1c,0xc0,0x78]
2882 // CHECK: ldrsh w19, [x12, #-256]! // encoding: [0x93,0x0d,0xd0,0x78]
2883
2884 str b0, [x0, #255]!
2885 str b3, [x3, #1]!
2886 str b5, [sp, #-256]!
2887 str h10, [x10, #255]!
2888 str h13, [x23, #1]!
2889 str h15, [sp, #-256]!
2890 str s20, [x20, #255]!
2891 str s23, [x23, #1]!
2892 str s25, [x0, #-256]!
2893 str d20, [x20, #255]!
2894 str d23, [x23, #1]!
2895 str d25, [x0, #-256]!
2896 // CHECK: str b0, [x0, #255]! // encoding: [0x00,0xfc,0x0f,0x3c]
2897 // CHECK: str b3, [x3, #1]! // encoding: [0x63,0x1c,0x00,0x3c]
2898 // CHECK: str b5, [sp, #-256]! // encoding: [0xe5,0x0f,0x10,0x3c]
2899 // CHECK: str h10, [x10, #255]! // encoding: [0x4a,0xfd,0x0f,0x7c]
2900 // CHECK: str h13, [x23, #1]! // encoding: [0xed,0x1e,0x00,0x7c]
2901 // CHECK: str h15, [sp, #-256]! // encoding: [0xef,0x0f,0x10,0x7c]
2902 // CHECK: str s20, [x20, #255]! // encoding: [0x94,0xfe,0x0f,0xbc]
2903 // CHECK: str s23, [x23, #1]! // encoding: [0xf7,0x1e,0x00,0xbc]
2904 // CHECK: str s25, [x0, #-256]! // encoding: [0x19,0x0c,0x10,0xbc]
2905 // CHECK: str d20, [x20, #255]! // encoding: [0x94,0xfe,0x0f,0xfc]
2906 // CHECK: str d23, [x23, #1]! // encoding: [0xf7,0x1e,0x00,0xfc]
2907 // CHECK: str d25, [x0, #-256]! // encoding: [0x19,0x0c,0x10,0xfc]
2908
2909 ldr b0, [x0, #255]!
2910 ldr b3, [x3, #1]!
2911 ldr b5, [sp, #-256]!
2912 ldr h10, [x10, #255]!
2913 ldr h13, [x23, #1]!
2914 ldr h15, [sp, #-256]!
2915 ldr s20, [x20, #255]!
2916 ldr s23, [x23, #1]!
2917 ldr s25, [x0, #-256]!
2918 ldr d20, [x20, #255]!
2919 ldr d23, [x23, #1]!
2920 ldr d25, [x0, #-256]!
2921 // CHECK: ldr b0, [x0, #255]! // encoding: [0x00,0xfc,0x4f,0x3c]
2922 // CHECK: ldr b3, [x3, #1]! // encoding: [0x63,0x1c,0x40,0x3c]
2923 // CHECK: ldr b5, [sp, #-256]! // encoding: [0xe5,0x0f,0x50,0x3c]
2924 // CHECK: ldr h10, [x10, #255]! // encoding: [0x4a,0xfd,0x4f,0x7c]
2925 // CHECK: ldr h13, [x23, #1]! // encoding: [0xed,0x1e,0x40,0x7c]
2926 // CHECK: ldr h15, [sp, #-256]! // encoding: [0xef,0x0f,0x50,0x7c]
2927 // CHECK: ldr s20, [x20, #255]! // encoding: [0x94,0xfe,0x4f,0xbc]
2928 // CHECK: ldr s23, [x23, #1]! // encoding: [0xf7,0x1e,0x40,0xbc]
2929 // CHECK: ldr s25, [x0, #-256]! // encoding: [0x19,0x0c,0x50,0xbc]
2930 // CHECK: ldr d20, [x20, #255]! // encoding: [0x94,0xfe,0x4f,0xfc]
2931 // CHECK: ldr d23, [x23, #1]! // encoding: [0xf7,0x1e,0x40,0xfc]
2932 // CHECK: ldr d25, [x0, #-256]! // encoding: [0x19,0x0c,0x50,0xfc]
2933
2934 ldr q20, [x1, #255]!
2935 ldr q23, [x9, #1]!
2936 ldr q25, [x20, #-256]!
2937 str q10, [x1, #255]!
2938 str q22, [sp, #1]!
2939 str q21, [x20, #-256]!
2940 // CHECK: ldr q20, [x1, #255]! // encoding: [0x34,0xfc,0xcf,0x3c]
2941 // CHECK: ldr q23, [x9, #1]! // encoding: [0x37,0x1d,0xc0,0x3c]
2942 // CHECK: ldr q25, [x20, #-256]! // encoding: [0x99,0x0e,0xd0,0x3c]
2943 // CHECK: str q10, [x1, #255]! // encoding: [0x2a,0xfc,0x8f,0x3c]
2944 // CHECK: str q22, [sp, #1]! // encoding: [0xf6,0x1f,0x80,0x3c]
2945 // CHECK: str q21, [x20, #-256]! // encoding: [0x95,0x0e,0x90,0x3c]
2946
2947 //------------------------------------------------------------------------------
2948 // Load/store (unprivileged)
2949 //------------------------------------------------------------------------------
2950
2951 sttrb w9, [sp, #0]
2952 sttrh wzr, [x12, #255]
2953 sttr w16, [x0, #-256]
2954 sttr x28, [x14, #1]
2955 // CHECK: sttrb w9, [sp] // encoding: [0xe9,0x0b,0x00,0x38]
2956 // CHECK: sttrh wzr, [x12, #255] // encoding: [0x9f,0xf9,0x0f,0x78]
2957 // CHECK: sttr w16, [x0, #-256] // encoding: [0x10,0x08,0x10,0xb8]
2958 // CHECK: sttr x28, [x14, #1] // encoding: [0xdc,0x19,0x00,0xf8]
2959
2960 ldtrb w1, [x20, #255]
2961 ldtrh w20, [x1, #255]
2962 ldtr w12, [sp, #255]
2963 ldtr xzr, [x12, #255]
2964 // CHECK: ldtrb w1, [x20, #255] // encoding: [0x81,0xfa,0x4f,0x38]
2965 // CHECK: ldtrh w20, [x1, #255] // encoding: [0x34,0xf8,0x4f,0x78]
2966 // CHECK: ldtr w12, [sp, #255] // encoding: [0xec,0xfb,0x4f,0xb8]
2967 // CHECK: ldtr xzr, [x12, #255] // encoding: [0x9f,0xf9,0x4f,0xf8]
2968
2969 ldtrsb x9, [x7, #-256]
2970 ldtrsh x17, [x19, #-256]
2971 ldtrsw x20, [x15, #-256]
2972 ldtrsb w19, [x1, #-256]
2973 ldtrsh w15, [x21, #-256]
2974 // CHECK: ldtrsb x9, [x7, #-256] // encoding: [0xe9,0x08,0x90,0x38]
2975 // CHECK: ldtrsh x17, [x19, #-256] // encoding: [0x71,0x0a,0x90,0x78]
2976 // CHECK: ldtrsw x20, [x15, #-256] // encoding: [0xf4,0x09,0x90,0xb8]
2977 // CHECK: ldtrsb w19, [x1, #-256] // encoding: [0x33,0x08,0xd0,0x38]
2978 // CHECK: ldtrsh w15, [x21, #-256] // encoding: [0xaf,0x0a,0xd0,0x78]
2979
2980 //------------------------------------------------------------------------------
2981 // Load/store register pair (offset)
2982 //------------------------------------------------------------------------------
2983
2984 ldp w3, w5, [sp]
2985 stp wzr, w9, [sp, #252]
2986 ldp w2, wzr, [sp, #-256]
2987 ldp w9, w10, [sp, #4]
2988 // CHECK: ldp w3, w5, [sp] // encoding: [0xe3,0x17,0x40,0x29]
2989 // CHECK: stp wzr, w9, [sp, #252] // encoding: [0xff,0xa7,0x1f,0x29]
2990 // CHECK: ldp w2, wzr, [sp, #-256] // encoding: [0xe2,0x7f,0x60,0x29]
2991 // CHECK: ldp w9, w10, [sp, #4] // encoding: [0xe9,0xab,0x40,0x29]
2992
2993 ldpsw x9, x10, [sp, #4]
2994 ldpsw x9, x10, [x2, #-256]
2995 ldpsw x20, x30, [sp, #252]
2996 // CHECK: ldpsw x9, x10, [sp, #4] // encoding: [0xe9,0xab,0x40,0x69]
2997 // CHECK: ldpsw x9, x10, [x2, #-256] // encoding: [0x49,0x28,0x60,0x69]
2998 // CHECK: ldpsw x20, x30, [sp, #252] // encoding: [0xf4,0xfb,0x5f,0x69]
2999
3000 ldp x21, x29, [x2, #504]
3001 ldp x22, x23, [x3, #-512]
3002 ldp x24, x25, [x4, #8]
3003 // CHECK: ldp x21, x29, [x2, #504] // encoding: [0x55,0xf4,0x5f,0xa9]
3004 // CHECK: ldp x22, x23, [x3, #-512] // encoding: [0x76,0x5c,0x60,0xa9]
3005 // CHECK: ldp x24, x25, [x4, #8] // encoding: [0x98,0xe4,0x40,0xa9]
3006
3007 ldp s29, s28, [sp, #252]
3008 stp s27, s26, [sp, #-256]
3009 ldp s1, s2, [x3, #44]
3010 // CHECK: ldp s29, s28, [sp, #252] // encoding: [0xfd,0xf3,0x5f,0x2d]
3011 // CHECK: stp s27, s26, [sp, #-256] // encoding: [0xfb,0x6b,0x20,0x2d]
3012 // CHECK: ldp s1, s2, [x3, #44] // encoding: [0x61,0x88,0x45,0x2d]
3013
3014 stp d3, d5, [x9, #504]
3015 stp d7, d11, [x10, #-512]
3016 ldp d2, d3, [x30, #-8]
3017 // CHECK: stp d3, d5, [x9, #504] // encoding: [0x23,0x95,0x1f,0x6d]
3018 // CHECK: stp d7, d11, [x10, #-512] // encoding: [0x47,0x2d,0x20,0x6d]
3019 // CHECK: ldp d2, d3, [x30, #-8] // encoding: [0xc2,0x8f,0x7f,0x6d]
3020
3021 stp q3, q5, [sp]
3022 stp q17, q19, [sp, #1008]
3023 ldp q23, q29, [x1, #-1024]
3024 // CHECK: stp q3, q5, [sp] // encoding: [0xe3,0x17,0x00,0xad]
3025 // CHECK: stp q17, q19, [sp, #1008] // encoding: [0xf1,0xcf,0x1f,0xad]
3026 // CHECK: ldp q23, q29, [x1, #-1024] // encoding: [0x37,0x74,0x60,0xad]
3027
3028 //------------------------------------------------------------------------------
3029 // Load/store register pair (post-indexed)
3030 //------------------------------------------------------------------------------
3031
3032 ldp w3, w5, [sp], #0
3033 stp wzr, w9, [sp], #252
3034 ldp w2, wzr, [sp], #-256
3035 ldp w9, w10, [sp], #4
3036 // CHECK: ldp w3, w5, [sp], #0 // encoding: [0xe3,0x17,0xc0,0x28]
3037 // CHECK: stp wzr, w9, [sp], #252 // encoding: [0xff,0xa7,0x9f,0x28]
3038 // CHECK: ldp w2, wzr, [sp], #-256 // encoding: [0xe2,0x7f,0xe0,0x28]
3039 // CHECK: ldp w9, w10, [sp], #4 // encoding: [0xe9,0xab,0xc0,0x28]
3040
3041 ldpsw x9, x10, [sp], #4
3042 ldpsw x9, x10, [x2], #-256
3043 ldpsw x20, x30, [sp], #252
3044 // CHECK: ldpsw x9, x10, [sp], #4 // encoding: [0xe9,0xab,0xc0,0x68]
3045 // CHECK: ldpsw x9, x10, [x2], #-256 // encoding: [0x49,0x28,0xe0,0x68]
3046 // CHECK: ldpsw x20, x30, [sp], #252 // encoding: [0xf4,0xfb,0xdf,0x68]
3047
3048 ldp x21, x29, [x2], #504
3049 ldp x22, x23, [x3], #-512
3050 ldp x24, x25, [x4], #8
3051 // CHECK: ldp x21, x29, [x2], #504 // encoding: [0x55,0xf4,0xdf,0xa8]
3052 // CHECK: ldp x22, x23, [x3], #-512 // encoding: [0x76,0x5c,0xe0,0xa8]
3053 // CHECK: ldp x24, x25, [x4], #8 // encoding: [0x98,0xe4,0xc0,0xa8]
3054
3055 ldp s29, s28, [sp], #252
3056 stp s27, s26, [sp], #-256
3057 ldp s1, s2, [x3], #44
3058 // CHECK: ldp s29, s28, [sp], #252 // encoding: [0xfd,0xf3,0xdf,0x2c]
3059 // CHECK: stp s27, s26, [sp], #-256 // encoding: [0xfb,0x6b,0xa0,0x2c]
3060 // CHECK: ldp s1, s2, [x3], #44 // encoding: [0x61,0x88,0xc5,0x2c]
3061
3062 stp d3, d5, [x9], #504
3063 stp d7, d11, [x10], #-512
3064 ldp d2, d3, [x30], #-8
3065 // CHECK: stp d3, d5, [x9], #504 // encoding: [0x23,0x95,0x9f,0x6c]
3066 // CHECK: stp d7, d11, [x10], #-512 // encoding: [0x47,0x2d,0xa0,0x6c]
3067 // CHECK: ldp d2, d3, [x30], #-8 // encoding: [0xc2,0x8f,0xff,0x6c]
3068
3069 stp q3, q5, [sp], #0
3070 stp q17, q19, [sp], #1008
3071 ldp q23, q29, [x1], #-1024
3072 // CHECK: stp q3, q5, [sp], #0 // encoding: [0xe3,0x17,0x80,0xac]
3073 // CHECK: stp q17, q19, [sp], #1008 // encoding: [0xf1,0xcf,0x9f,0xac]
3074 // CHECK: ldp q23, q29, [x1], #-1024 // encoding: [0x37,0x74,0xe0,0xac]
3075
3076 //------------------------------------------------------------------------------
3077 // Load/store register pair (pre-indexed)
3078 //------------------------------------------------------------------------------
3079 ldp w3, w5, [sp, #0]!
3080 stp wzr, w9, [sp, #252]!
3081 ldp w2, wzr, [sp, #-256]!
3082 ldp w9, w10, [sp, #4]!
3083 // CHECK: ldp w3, w5, [sp, #0]! // encoding: [0xe3,0x17,0xc0,0x29]
3084 // CHECK: stp wzr, w9, [sp, #252]! // encoding: [0xff,0xa7,0x9f,0x29]
3085 // CHECK: ldp w2, wzr, [sp, #-256]! // encoding: [0xe2,0x7f,0xe0,0x29]
3086 // CHECK: ldp w9, w10, [sp, #4]! // encoding: [0xe9,0xab,0xc0,0x29]
3087
3088 ldpsw x9, x10, [sp, #4]!
3089 ldpsw x9, x10, [x2, #-256]!
3090 ldpsw x20, x30, [sp, #252]!
3091 // CHECK: ldpsw x9, x10, [sp, #4]! // encoding: [0xe9,0xab,0xc0,0x69]
3092 // CHECK: ldpsw x9, x10, [x2, #-256]! // encoding: [0x49,0x28,0xe0,0x69]
3093 // CHECK: ldpsw x20, x30, [sp, #252]! // encoding: [0xf4,0xfb,0xdf,0x69]
3094
3095 ldp x21, x29, [x2, #504]!
3096 ldp x22, x23, [x3, #-512]!
3097 ldp x24, x25, [x4, #8]!
3098 // CHECK: ldp x21, x29, [x2, #504]! // encoding: [0x55,0xf4,0xdf,0xa9]
3099 // CHECK: ldp x22, x23, [x3, #-512]! // encoding: [0x76,0x5c,0xe0,0xa9]
3100 // CHECK: ldp x24, x25, [x4, #8]! // encoding: [0x98,0xe4,0xc0,0xa9]
3101
3102 ldp s29, s28, [sp, #252]!
3103 stp s27, s26, [sp, #-256]!
3104 ldp s1, s2, [x3, #44]!
3105 // CHECK: ldp s29, s28, [sp, #252]! // encoding: [0xfd,0xf3,0xdf,0x2d]
3106 // CHECK: stp s27, s26, [sp, #-256]! // encoding: [0xfb,0x6b,0xa0,0x2d]
3107 // CHECK: ldp s1, s2, [x3, #44]! // encoding: [0x61,0x88,0xc5,0x2d]
3108
3109 stp d3, d5, [x9, #504]!
3110 stp d7, d11, [x10, #-512]!
3111 ldp d2, d3, [x30, #-8]!
3112 // CHECK: stp d3, d5, [x9, #504]! // encoding: [0x23,0x95,0x9f,0x6d]
3113 // CHECK: stp d7, d11, [x10, #-512]! // encoding: [0x47,0x2d,0xa0,0x6d]
3114 // CHECK: ldp d2, d3, [x30, #-8]! // encoding: [0xc2,0x8f,0xff,0x6d]
3115
3116 stp q3, q5, [sp, #0]!
3117 stp q17, q19, [sp, #1008]!
3118 ldp q23, q29, [x1, #-1024]!
3119 // CHECK: stp q3, q5, [sp, #0]! // encoding: [0xe3,0x17,0x80,0xad]
3120 // CHECK: stp q17, q19, [sp, #1008]! // encoding: [0xf1,0xcf,0x9f,0xad]
3121 // CHECK: ldp q23, q29, [x1, #-1024]! // encoding: [0x37,0x74,0xe0,0xad]
3122
3123 //------------------------------------------------------------------------------
3124 // Load/store non-temporal register pair (offset)
3125 //------------------------------------------------------------------------------
3126
3127 ldnp w3, w5, [sp]
3128 stnp wzr, w9, [sp, #252]
3129 ldnp w2, wzr, [sp, #-256]
3130 ldnp w9, w10, [sp, #4]
3131 // CHECK: ldnp w3, w5, [sp] // encoding: [0xe3,0x17,0x40,0x28]
3132 // CHECK: stnp wzr, w9, [sp, #252] // encoding: [0xff,0xa7,0x1f,0x28]
3133 // CHECK: ldnp w2, wzr, [sp, #-256] // encoding: [0xe2,0x7f,0x60,0x28]
3134 // CHECK: ldnp w9, w10, [sp, #4] // encoding: [0xe9,0xab,0x40,0x28]
3135
3136 ldnp x21, x29, [x2, #504]
3137 ldnp x22, x23, [x3, #-512]
3138 ldnp x24, x25, [x4, #8]
3139 // CHECK: ldnp x21, x29, [x2, #504] // encoding: [0x55,0xf4,0x5f,0xa8]
3140 // CHECK: ldnp x22, x23, [x3, #-512] // encoding: [0x76,0x5c,0x60,0xa8]
3141 // CHECK: ldnp x24, x25, [x4, #8] // encoding: [0x98,0xe4,0x40,0xa8]
3142
3143 ldnp s29, s28, [sp, #252]
3144 stnp s27, s26, [sp, #-256]
3145 ldnp s1, s2, [x3, #44]
3146 // CHECK: ldnp s29, s28, [sp, #252] // encoding: [0xfd,0xf3,0x5f,0x2c]
3147 // CHECK: stnp s27, s26, [sp, #-256] // encoding: [0xfb,0x6b,0x20,0x2c]
3148 // CHECK: ldnp s1, s2, [x3, #44] // encoding: [0x61,0x88,0x45,0x2c]
3149
3150 stnp d3, d5, [x9, #504]
3151 stnp d7, d11, [x10, #-512]
3152 ldnp d2, d3, [x30, #-8]
3153 // CHECK: stnp d3, d5, [x9, #504] // encoding: [0x23,0x95,0x1f,0x6c]
3154 // CHECK: stnp d7, d11, [x10, #-512] // encoding: [0x47,0x2d,0x20,0x6c]
3155 // CHECK: ldnp d2, d3, [x30, #-8] // encoding: [0xc2,0x8f,0x7f,0x6c]
3156
3157 stnp q3, q5, [sp]
3158 stnp q17, q19, [sp, #1008]
3159 ldnp q23, q29, [x1, #-1024]
3160 // CHECK: stnp q3, q5, [sp] // encoding: [0xe3,0x17,0x00,0xac]
3161 // CHECK: stnp q17, q19, [sp, #1008] // encoding: [0xf1,0xcf,0x1f,0xac]
3162 // CHECK: ldnp q23, q29, [x1, #-1024] // encoding: [0x37,0x74,0x60,0xac]
3163
3164 //------------------------------------------------------------------------------
3165 // Logical (immediate)
3166 //------------------------------------------------------------------------------
3167 // 32 bit replication-width
3168 orr w3, w9, #0xffff0000
3169 orr wsp, w10, #0xe00000ff
3170 orr w9, w10, #0x000003ff
3171 // CHECK: orr w3, w9, #0xffff0000 // encoding: [0x23,0x3d,0x10,0x32]
3172 // CHECK: orr wsp, w10, #0xe00000ff // encoding: [0x5f,0x29,0x03,0x32]
3173 // CHECK: orr w9, w10, #0x3ff // encoding: [0x49,0x25,0x00,0x32]
3174
3175 // 16 bit replication width
3176 and w14, w15, #0x80008000
3177 and w12, w13, #0xffc3ffc3
3178 and w11, wzr, #0x00030003
3179 // CHECK: and w14, w15, #0x80008000 // encoding: [0xee,0x81,0x01,0x12]
3180 // CHECK: and w12, w13, #0xffc3ffc3 // encoding: [0xac,0xad,0x0a,0x12]
3181 // CHECK: and w11, wzr, #0x30003 // encoding: [0xeb,0x87,0x00,0x12]
3182
3183 // 8 bit replication width
3184 eor w3, w6, #0xe0e0e0e0
3185 eor wsp, wzr, #0x03030303
3186 eor w16, w17, #0x81818181
3187 // CHECK: eor w3, w6, #0xe0e0e0e0 // encoding: [0xc3,0xc8,0x03,0x52]
3188 // CHECK: eor wsp, wzr, #0x3030303 // encoding: [0xff,0xc7,0x00,0x52]
3189 // CHECK: eor w16, w17, #0x81818181 // encoding: [0x30,0xc6,0x01,0x52]
3190
3191 // 4 bit replication width
3192 ands wzr, w18, #0xcccccccc
3193 ands w19, w20, #0x33333333
3194 ands w21, w22, #0x99999999
3195 // CHECK: {{ands wzr,|tst}} w18, #0xcccccccc // encoding: [0x5f,0xe6,0x02,0x72]
3196 // CHECK: ands w19, w20, #0x33333333 // encoding: [0x93,0xe6,0x00,0x72]
3197 // CHECK: ands w21, w22, #0x99999999 // encoding: [0xd5,0xe6,0x01,0x72]
3198
3199 // 2 bit replication width
3200 tst w3, #0xaaaaaaaa
3201 tst wzr, #0x55555555
3202 // CHECK: {{ands wzr,|tst}} w3, #0xaaaaaaaa // encoding: [0x7f,0xf0,0x01,0x72]
3203 // CHECK: {{ands wzr,|tst}} wzr, #0x55555555 // encoding: [0xff,0xf3,0x00,0x72]
3204
3205 // 64 bit replication-width
3206 eor x3, x5, #0xffffffffc000000
3207 and x9, x10, #0x00007fffffffffff
3208 orr x11, x12, #0x8000000000000fff
3209 // CHECK: eor x3, x5, #0xffffffffc000000 // encoding: [0xa3,0x84,0x66,0xd2]
3210 // CHECK: and x9, x10, #0x7fffffffffff // encoding: [0x49,0xb9,0x40,0x92]
3211 // CHECK: orr x11, x12, #0x8000000000000fff // encoding: [0x8b,0x31,0x41,0xb2]
3212
3213 // 32 bit replication-width
3214 orr x3, x9, #0xffff0000ffff0000
3215 orr sp, x10, #0xe00000ffe00000ff
3216 orr x9, x10, #0x000003ff000003ff
3217 // CHECK: orr x3, x9, #0xffff0000ffff0000 // encoding: [0x23,0x3d,0x10,0xb2]
3218 // CHECK: orr sp, x10, #0xe00000ffe00000ff // encoding: [0x5f,0x29,0x03,0xb2]
3219 // CHECK: orr x9, x10, #0x3ff000003ff // encoding: [0x49,0x25,0x00,0xb2]
3220
3221 // 16 bit replication-width
3222 and x14, x15, #0x8000800080008000
3223 and x12, x13, #0xffc3ffc3ffc3ffc3
3224 and x11, xzr, #0x0003000300030003
3225 // CHECK: and x14, x15, #0x8000800080008000 // encoding: [0xee,0x81,0x01,0x92]
3226 // CHECK: and x12, x13, #0xffc3ffc3ffc3ffc3 // encoding: [0xac,0xad,0x0a,0x92]
3227 // CHECK: and x11, xzr, #0x3000300030003 // encoding: [0xeb,0x87,0x00,0x92]
3228
3229 // 8 bit replication-width
3230 eor x3, x6, #0xe0e0e0e0e0e0e0e0
3231 eor sp, xzr, #0x0303030303030303
3232 eor x16, x17, #0x8181818181818181
3233 // CHECK: eor x3, x6, #0xe0e0e0e0e0e0e0e0 // encoding: [0xc3,0xc8,0x03,0xd2]
3234 // CHECK: eor sp, xzr, #0x303030303030303 // encoding: [0xff,0xc7,0x00,0xd2]
3235 // CHECK: eor x16, x17, #0x8181818181818181 // encoding: [0x30,0xc6,0x01,0xd2]
3236
3237 // 4 bit replication-width
3238 ands xzr, x18, #0xcccccccccccccccc
3239 ands x19, x20, #0x3333333333333333
3240 ands x21, x22, #0x9999999999999999
3241 // CHECK: {{ands xzr,|tst}} x18, #0xcccccccccccccccc // encoding: [0x5f,0xe6,0x02,0xf2]
3242 // CHECK: ands x19, x20, #0x3333333333333333 // encoding: [0x93,0xe6,0x00,0xf2]
3243 // CHECK: ands x21, x22, #0x9999999999999999 // encoding: [0xd5,0xe6,0x01,0xf2]
3244
3245 // 2 bit replication-width
3246 tst x3, #0xaaaaaaaaaaaaaaaa
3247 tst xzr, #0x5555555555555555
3248 // CHECK: {{ands xzr,|tst}} x3, #0xaaaaaaaaaaaaaaaa // encoding: [0x7f,0xf0,0x01,0xf2]
3249 // CHECK: {{ands xzr,|tst}} xzr, #0x5555555555555555 // encoding: [0xff,0xf3,0x00,0xf2]
3250
3251 mov w3, #0xf000f
3252 mov x10, #0xaaaaaaaaaaaaaaaa
3253 // CHECK: mov w3, #983055 // encoding: [0xe3,0x8f,0x00,0x32]
3254 // CHECK: mov x10, #-6148914691236517206 // encoding: [0xea,0xf3,0x01,0xb2]
3255
3256 // The Imm field of logicalImm operations has to be truncated to the
3257 // register width, i.e. 32 bits
3258 and w2, w3, #-3
3259 orr w0, w1, #~2
3260 eor w16, w17, #-7
3261 ands w19, w20, #~15
3262 // CHECK: and w2, w3, #0xfffffffd // encoding: [0x62,0x78,0x1e,0x12]
3263 // CHECK: orr w0, w1, #0xfffffffd // encoding: [0x20,0x78,0x1e,0x32]
3264 // CHECK: eor w16, w17, #0xfffffff9 // encoding: [0x30,0x76,0x1d,0x52]
3265 // CHECK: ands w19, w20, #0xfffffff0 // encoding: [0x93,0x6e,0x1c,0x72]
3266
3267 //------------------------------------------------------------------------------
3268 // Logical (shifted register)
3269 //------------------------------------------------------------------------------
3270
3271 and w12, w23, w21
3272 and w16, w15, w1, lsl #1
3273 and w9, w4, w10, lsl #31
3274 and w3, w30, w11, lsl #0
3275 and x3, x5, x7, lsl #63
3276 // CHECK: and w12, w23, w21 // encoding: [0xec,0x02,0x15,0x0a]
3277 // CHECK: and w16, w15, w1, lsl #1 // encoding: [0xf0,0x05,0x01,0x0a]
3278 // CHECK: and w9, w4, w10, lsl #31 // encoding: [0x89,0x7c,0x0a,0x0a]
3279 // CHECK: and w3, w30, w11 // encoding: [0xc3,0x03,0x0b,0x0a]
3280 // CHECK: and x3, x5, x7, lsl #63 // encoding: [0xa3,0xfc,0x07,0x8a]
3281
3282 and x5, x14, x19, asr #4
3283 and w3, w17, w19, ror #31
3284 and w0, w2, wzr, lsr #17
3285 and w3, w30, w11, asr #0
3286 // CHECK: and x5, x14, x19, asr #4 // encoding: [0xc5,0x11,0x93,0x8a]
3287 // CHECK: and w3, w17, w19, ror #31 // encoding: [0x23,0x7e,0xd3,0x0a]
3288 // CHECK: and w0, w2, wzr, lsr #17 // encoding: [0x40,0x44,0x5f,0x0a]
3289 // CHECK: and w3, w30, w11, asr #0 // encoding: [0xc3,0x03,0x8b,0x0a]
3290
3291 and xzr, x4, x26, lsl #0
3292 and w3, wzr, w20, ror #0
3293 and x7, x20, xzr, asr #63
3294 // CHECK: and xzr, x4, x26 // encoding: [0x9f,0x00,0x1a,0x8a]
3295 // CHECK: and w3, wzr, w20, ror #0 // encoding: [0xe3,0x03,0xd4,0x0a]
3296 // CHECK: and x7, x20, xzr, asr #63 // encoding: [0x87,0xfe,0x9f,0x8a]
3297
3298 bic x13, x20, x14, lsl #47
3299 bic w2, w7, w9
3300 orr w2, w7, w0, asr #31
3301 orr x8, x9, x10, lsl #12
3302 orn x3, x5, x7, asr #0
3303 orn w2, w5, w29
3304 // CHECK: bic x13, x20, x14, lsl #47 // encoding: [0x8d,0xbe,0x2e,0x8a]
3305 // CHECK: bic w2, w7, w9 // encoding: [0xe2,0x00,0x29,0x0a]
3306 // CHECK: orr w2, w7, w0, asr #31 // encoding: [0xe2,0x7c,0x80,0x2a]
3307 // CHECK: orr x8, x9, x10, lsl #12 // encoding: [0x28,0x31,0x0a,0xaa]
3308 // CHECK: orn x3, x5, x7, asr #0 // encoding: [0xa3,0x00,0xa7,0xaa]
3309 // CHECK: orn w2, w5, w29 // encoding: [0xa2,0x00,0x3d,0x2a]
3310
3311 ands w7, wzr, w9, lsl #1
3312 ands x3, x5, x20, ror #63
3313 bics w3, w5, w7, lsl #0
3314 bics x3, xzr, x3, lsl #1
3315 // CHECK: ands w7, wzr, w9, lsl #1 // encoding: [0xe7,0x07,0x09,0x6a]
3316 // CHECK: ands x3, x5, x20, ror #63 // encoding: [0xa3,0xfc,0xd4,0xea]
3317 // CHECK: bics w3, w5, w7 // encoding: [0xa3,0x00,0x27,0x6a]
3318 // CHECK: bics x3, xzr, x3, lsl #1 // encoding: [0xe3,0x07,0x23,0xea]
3319
3320 tst w3, w7, lsl #31
3321 tst x2, x20, asr #0
3322 // CHECK: tst w3, w7, lsl #31 // encoding: [0x7f,0x7c,0x07,0x6a]
3323 // CHECK: tst x2, x20, asr #0 // encoding: [0x5f,0x00,0x94,0xea]
3324
3325 mov x3, x6
3326 mov x3, xzr
3327 mov wzr, w2
3328 mov w3, w5
3329 // CHECK: mov x3, x6 // encoding: [0xe3,0x03,0x06,0xaa]
3330 // CHECK: mov x3, xzr // encoding: [0xe3,0x03,0x1f,0xaa]
3331 // CHECK: mov wzr, w2 // encoding: [0xff,0x03,0x02,0x2a]
3332 // CHECK: mov w3, w5 // encoding: [0xe3,0x03,0x05,0x2a]
3333
3334 //------------------------------------------------------------------------------
3335 // Move wide (immediate)
3336 //------------------------------------------------------------------------------
3337
3338 movz w1, #65535, lsl #0
3339 movz w2, #0, lsl #16
3340 movn w2, #1234, lsl #0
3341 // CHECK: mov w1, #65535 // encoding: [0xe1,0xff,0x9f,0x52]
3342 // CHECK: movz w2, #0, lsl #16 // encoding: [0x02,0x00,0xa0,0x52]
3343 // CHECK: mov w2, #-1235 // encoding: [0x42,0x9a,0x80,0x12]
3344
3345 movz x2, #1234, lsl #32
3346 movk xzr, #4321, lsl #48
3347 // CHECK: mov x2, #5299989643264 // encoding: [0x42,0x9a,0xc0,0xd2]
3348 // CHECK: movk xzr, #{{4321|0x10e1}}, lsl #48 // encoding: [0x3f,0x1c,0xe2,0xf2]
3349
3350 movz x2, #:abs_g0:sym
3351 movk w3, #:abs_g0_nc:sym
3352
3353 // CHECK: movz x2, #:abs_g0:sym // encoding: [0bAAA00010,A,0b100AAAAA,0xd2]
3354 // CHECK-NEXT: // fixup A - offset: 0, value: :abs_g0:sym, kind: fixup_aarch64_movw
3355 // CHECK: movk w3, #:abs_g0_nc:sym // encoding: [0bAAA00011,A,0b100AAAAA,0x72]
3356 // CHECK-NEXT: // fixup A - offset: 0, value: :abs_g0_nc:sym, kind: fixup_aarch64_movw
3357
3358 movz x4, #:abs_g1:sym
3359 movk w5, #:abs_g1_nc:sym
3360
3361 // CHECK: movz x4, #:abs_g1:sym // encoding: [0bAAA00100,A,0b101AAAAA,0xd2]
3362 // CHECK-NEXT: // fixup A - offset: 0, value: :abs_g1:sym, kind: fixup_aarch64_movw
3363 // CHECK: movk w5, #:abs_g1_nc:sym // encoding: [0bAAA00101,A,0b101AAAAA,0x72]
3364 // CHECK-NEXT: // fixup A - offset: 0, value: :abs_g1_nc:sym, kind: fixup_aarch64_movw
3365
3366 movz x6, #:abs_g2:sym
3367 movk x7, #:abs_g2_nc:sym
3368
3369 // CHECK: movz x6, #:abs_g2:sym // encoding: [0bAAA00110,A,0b110AAAAA,0xd2]
3370 // CHECK-NEXT: // fixup A - offset: 0, value: :abs_g2:sym, kind: fixup_aarch64_movw
3371 // CHECK: movk x7, #:abs_g2_nc:sym // encoding: [0bAAA00111,A,0b110AAAAA,0xf2]
3372 // CHECK-NEXT: // fixup A - offset: 0, value: :abs_g2_nc:sym, kind: fixup_aarch64_movw
3373
3374 movz x8, #:abs_g3:sym
3375 movk x9, #:abs_g3:sym
3376
3377 // CHECK: movz x8, #:abs_g3:sym // encoding: [0bAAA01000,A,0b111AAAAA,0xd2]
3378 // CHECK-NEXT: // fixup A - offset: 0, value: :abs_g3:sym, kind: fixup_aarch64_movw
3379 // CHECK: movk x9, #:abs_g3:sym // encoding: [0bAAA01001,A,0b111AAAAA,0xf2]
3380 // CHECK-NEXT: // fixup A - offset: 0, value: :abs_g3:sym, kind: fixup_aarch64_movw
3381
3382
3383 movn x30, #:abs_g0_s:sym
3384 movz x19, #:abs_g0_s:sym
3385 movn w10, #:abs_g0_s:sym
3386 movz w25, #:abs_g0_s:sym
3387
3388 // CHECK: movn x30, #:abs_g0_s:sym // encoding: [0bAAA11110,A,0b100AAAAA,0x92]
3389 // CHECK-NEXT: // fixup A - offset: 0, value: :abs_g0_s:sym, kind: fixup_aarch64_movw
3390 // CHECK: movz x19, #:abs_g0_s:sym // encoding: [0bAAA10011,A,0b100AAAAA,0xd2]
3391 // CHECK-NEXT: // fixup A - offset: 0, value: :abs_g0_s:sym, kind: fixup_aarch64_movw
3392 // CHECK: movn w10, #:abs_g0_s:sym // encoding: [0bAAA01010,A,0b100AAAAA,0x12]
3393 // CHECK-NEXT: // fixup A - offset: 0, value: :abs_g0_s:sym, kind: fixup_aarch64_movw
3394 // CHECK: movz w25, #:abs_g0_s:sym // encoding: [0bAAA11001,A,0b100AAAAA,0x52]
3395 // CHECK-NEXT: // fixup A - offset: 0, value: :abs_g0_s:sym, kind: fixup_aarch64_movw
3396
3397 movn x30, #:abs_g1_s:sym
3398 movz x19, #:abs_g1_s:sym
3399 movn w10, #:abs_g1_s:sym
3400 movz w25, #:abs_g1_s:sym
3401
3402 // CHECK: movn x30, #:abs_g1_s:sym // encoding: [0bAAA11110,A,0b101AAAAA,0x92]
3403 // CHECK-NEXT: // fixup A - offset: 0, value: :abs_g1_s:sym, kind: fixup_aarch64_movw
3404 // CHECK: movz x19, #:abs_g1_s:sym // encoding: [0bAAA10011,A,0b101AAAAA,0xd2]
3405 // CHECK-NEXT: // fixup A - offset: 0, value: :abs_g1_s:sym, kind: fixup_aarch64_movw
3406 // CHECK: movn w10, #:abs_g1_s:sym // encoding: [0bAAA01010,A,0b101AAAAA,0x12]
3407 // CHECK-NEXT: // fixup A - offset: 0, value: :abs_g1_s:sym, kind: fixup_aarch64_movw
3408 // CHECK: movz w25, #:abs_g1_s:sym // encoding: [0bAAA11001,A,0b101AAAAA,0x52]
3409 // CHECK-NEXT: // fixup A - offset: 0, value: :abs_g1_s:sym, kind: fixup_aarch64_movw
3410
3411 movn x30, #:abs_g2_s:sym
3412 movz x19, #:abs_g2_s:sym
3413
3414 // CHECK: movn x30, #:abs_g2_s:sym // encoding: [0bAAA11110,A,0b110AAAAA,0x92]
3415 // CHECK-NEXT: // fixup A - offset: 0, value: :abs_g2_s:sym, kind: fixup_aarch64_movw
3416 // CHECK: movz x19, #:abs_g2_s:sym // encoding: [0bAAA10011,A,0b110AAAAA,0xd2]
3417 // CHECK-NEXT: // fixup A - offset: 0, value: :abs_g2_s:sym, kind: fixup_aarch64_movw
3418
3419 //------------------------------------------------------------------------------
3420 // PC-relative addressing
3421 //------------------------------------------------------------------------------
3422
3423 adr x2, loc
3424 adr xzr, loc
3425
3426 // CHECK: adr x2, loc // encoding: [0x02'A',A,A,0x10'A']
3427 // CHECK: // fixup A - offset: 0, value: loc, kind: fixup_aarch64_pcrel_adr_imm21
3428 // CHECK: adr xzr, loc // encoding: [0x1f'A',A,A,0x10'A']
3429 // CHECK: // fixup A - offset: 0, value: loc, kind: fixup_aarch64_pcrel_adr_imm21
3430
3431 adrp x29, loc
3432
3433 // CHECK: adrp x29, loc // encoding: [0x1d'A',A,A,0x90'A']
3434 // CHECK: // fixup A - offset: 0, value: loc, kind: fixup_aarch64_pcrel_adrp_imm21
3435 adrp x30, #4096
3436 adr x20, #0
3437 adr x9, #-1
3438 adr x5, #1048575
3439 // CHECK: adrp x30, #4096 // encoding: [0x1e,0x00,0x00,0xb0]
3440 // CHECK: adr x20, #0 // encoding: [0x14,0x00,0x00,0x10]
3441 // CHECK: adr x9, #-1 // encoding: [0xe9,0xff,0xff,0x70]
3442 // CHECK: adr x5, #1048575 // encoding: [0xe5,0xff,0x7f,0x70]
3443
3444 adr x9, #1048575
3445 adr x2, #-1048576
3446 adrp x9, #4294963200
3447 adrp x20, #-4294967296
3448 // CHECK: adr x9, #1048575 // encoding: [0xe9,0xff,0x7f,0x70]
3449 // CHECK: adr x2, #-1048576 // encoding: [0x02,0x00,0x80,0x10]
3450 // CHECK: adrp x9, #4294963200 // encoding: [0xe9,0xff,0x7f,0xf0]
3451 // CHECK: adrp x20, #-4294967296 // encoding: [0x14,0x00,0x80,0x90]
3452
3453 //------------------------------------------------------------------------------
3454 // System
3455 //------------------------------------------------------------------------------
3456
3457 hint #0
3458 hint #127
3459 // CHECK: nop // encoding: [0x1f,0x20,0x03,0xd5]
3460 // CHECK: hint #{{127|0x7f}} // encoding: [0xff,0x2f,0x03,0xd5]
3461
3462 nop
3463 yield
3464 wfe
3465 wfi
3466 sev
3467 sevl
3468 // CHECK: nop // encoding: [0x1f,0x20,0x03,0xd5]
3469 // CHECK: yield // encoding: [0x3f,0x20,0x03,0xd5]
3470 // CHECK: wfe // encoding: [0x5f,0x20,0x03,0xd5]
3471 // CHECK: wfi // encoding: [0x7f,0x20,0x03,0xd5]
3472 // CHECK: sev // encoding: [0x9f,0x20,0x03,0xd5]
3473 // CHECK: sevl // encoding: [0xbf,0x20,0x03,0xd5]
3474
3475 clrex
3476 clrex #0
3477 clrex #7
3478 clrex #15
3479 // CHECK: clrex // encoding: [0x5f,0x3f,0x03,0xd5]
3480 // CHECK: clrex #0 // encoding: [0x5f,0x30,0x03,0xd5]
3481 // CHECK: clrex #7 // encoding: [0x5f,0x37,0x03,0xd5]
3482 // CHECK: clrex // encoding: [0x5f,0x3f,0x03,0xd5]
3483
3484 dsb #0
3485 dsb #4
3486 dsb #12
3487 dsb #15
3488 dsb oshld
3489 dsb oshst
3490 dsb osh
3491 dsb nshld
3492 dsb nshst
3493 dsb nsh
3494 dsb ishld
3495 dsb ishst
3496 dsb ish
3497 dsb ld
3498 dsb st
3499 dsb sy
3500 // CHECK: ssbb // encoding: [0x9f,0x30,0x03,0xd5]
3501 // CHECK: pssbb // encoding: [0x9f,0x34,0x03,0xd5]
3502 // CHECK: dsb #12 // encoding: [0x9f,0x3c,0x03,0xd5]
3503 // CHECK: dsb sy // encoding: [0x9f,0x3f,0x03,0xd5]
3504 // CHECK: dsb oshld // encoding: [0x9f,0x31,0x03,0xd5]
3505 // CHECK: dsb oshst // encoding: [0x9f,0x32,0x03,0xd5]
3506 // CHECK: dsb osh // encoding: [0x9f,0x33,0x03,0xd5]
3507 // CHECK: dsb nshld // encoding: [0x9f,0x35,0x03,0xd5]
3508 // CHECK: dsb nshst // encoding: [0x9f,0x36,0x03,0xd5]
3509 // CHECK: dsb nsh // encoding: [0x9f,0x37,0x03,0xd5]
3510 // CHECK: dsb ishld // encoding: [0x9f,0x39,0x03,0xd5]
3511 // CHECK: dsb ishst // encoding: [0x9f,0x3a,0x03,0xd5]
3512 // CHECK: dsb ish // encoding: [0x9f,0x3b,0x03,0xd5]
3513 // CHECK: dsb ld // encoding: [0x9f,0x3d,0x03,0xd5]
3514 // CHECK: dsb st // encoding: [0x9f,0x3e,0x03,0xd5]
3515 // CHECK: dsb sy // encoding: [0x9f,0x3f,0x03,0xd5]
3516
3517 dmb #0
3518 dmb #12
3519 dmb #15
3520 dmb oshld
3521 dmb oshst
3522 dmb osh
3523 dmb nshld
3524 dmb nshst
3525 dmb nsh
3526 dmb ishld
3527 dmb ishst
3528 dmb ish
3529 dmb ld
3530 dmb st
3531 dmb sy
3532 // CHECK: dmb #0 // encoding: [0xbf,0x30,0x03,0xd5]
3533 // CHECK: dmb #12 // encoding: [0xbf,0x3c,0x03,0xd5]
3534 // CHECK: dmb sy // encoding: [0xbf,0x3f,0x03,0xd5]
3535 // CHECK: dmb oshld // encoding: [0xbf,0x31,0x03,0xd5]
3536 // CHECK: dmb oshst // encoding: [0xbf,0x32,0x03,0xd5]
3537 // CHECK: dmb osh // encoding: [0xbf,0x33,0x03,0xd5]
3538 // CHECK: dmb nshld // encoding: [0xbf,0x35,0x03,0xd5]
3539 // CHECK: dmb nshst // encoding: [0xbf,0x36,0x03,0xd5]
3540 // CHECK: dmb nsh // encoding: [0xbf,0x37,0x03,0xd5]
3541 // CHECK: dmb ishld // encoding: [0xbf,0x39,0x03,0xd5]
3542 // CHECK: dmb ishst // encoding: [0xbf,0x3a,0x03,0xd5]
3543 // CHECK: dmb ish // encoding: [0xbf,0x3b,0x03,0xd5]
3544 // CHECK: dmb ld // encoding: [0xbf,0x3d,0x03,0xd5]
3545 // CHECK: dmb st // encoding: [0xbf,0x3e,0x03,0xd5]
3546 // CHECK: dmb sy // encoding: [0xbf,0x3f,0x03,0xd5]
3547
3548 isb sy
3549 isb
3550 isb #12
3551 // CHECK: isb // encoding: [0xdf,0x3f,0x03,0xd5]
3552 // CHECK: isb // encoding: [0xdf,0x3f,0x03,0xd5]
3553 // CHECK: isb #12 // encoding: [0xdf,0x3c,0x03,0xd5]
3554
3555
3556 msr spsel, #0
3557 msr daifset, #15
3558 msr daifclr, #12
3559 // CHECK: msr {{SPSel|SPSEL}}, #0 // encoding: [0xbf,0x40,0x00,0xd5]
3560 // CHECK: msr {{DAIFSet|DAIFSET}}, #15 // encoding: [0xdf,0x4f,0x03,0xd5]
3561 // CHECK: msr {{DAIFClr|DAIFCLR}}, #12 // encoding: [0xff,0x4c,0x03,0xd5]
3562
3563 sys #7, c5, c9, #7, x5
3564 sys #0, c15, c15, #2
3565 // CHECK: sys #7, c5, c9, #7, x5 // encoding: [0xe5,0x59,0x0f,0xd5]
3566 // CHECK: sys #0, c15, c15, #2 // encoding: [0x5f,0xff,0x08,0xd5]
3567
3568 sysl x9, #7, c5, c9, #7
3569 sysl x1, #0, c15, c15, #2
3570 // CHECK: sysl x9, #7, c5, c9, #7 // encoding: [0xe9,0x59,0x2f,0xd5]
3571 // CHECK: sysl x1, #0, c15, c15, #2 // encoding: [0x41,0xff,0x28,0xd5]
3572
3573 ic ialluis
3574 ic iallu
3575 ic ivau, x9
3576 // CHECK: ic ialluis // encoding: [0x1f,0x71,0x08,0xd5]
3577 // CHECK: ic iallu // encoding: [0x1f,0x75,0x08,0xd5]
3578 // CHECK: ic ivau, x9 // encoding: [0x29,0x75,0x0b,0xd5]
3579
3580 dc zva, x12
3581 dc ivac, xzr
3582 dc isw, x2
3583 dc cvac, x9
3584 dc csw, x10
3585 dc cvau, x0
3586 dc civac, x3
3587 dc cisw, x30
3588 // CHECK: dc zva, x12 // encoding: [0x2c,0x74,0x0b,0xd5]
3589 // CHECK: dc ivac, xzr // encoding: [0x3f,0x76,0x08,0xd5]
3590 // CHECK: dc isw, x2 // encoding: [0x42,0x76,0x08,0xd5]
3591 // CHECK: dc cvac, x9 // encoding: [0x29,0x7a,0x0b,0xd5]
3592 // CHECK: dc csw, x10 // encoding: [0x4a,0x7a,0x08,0xd5]
3593 // CHECK: dc cvau, x0 // encoding: [0x20,0x7b,0x0b,0xd5]
3594 // CHECK: dc civac, x3 // encoding: [0x23,0x7e,0x0b,0xd5]
3595 // CHECK: dc cisw, x30 // encoding: [0x5e,0x7e,0x08,0xd5]
3596
3597 at S1E1R, x19
3598 at S1E2R, x19
3599 at S1E3R, x19
3600 at S1E1W, x19
3601 at S1E2W, x19
3602 at S1E3W, x19
3603 at S1E0R, x19
3604 at S1E0W, x19
3605 at S12E1R, x20
3606 at S12E1W, x20
3607 at S12E0R, x20
3608 at S12E0W, x20
3609 // CHECK: at s1e1r, x19 // encoding: [0x13,0x78,0x08,0xd5]
3610 // CHECK: at s1e2r, x19 // encoding: [0x13,0x78,0x0c,0xd5]
3611 // CHECK: at s1e3r, x19 // encoding: [0x13,0x78,0x0e,0xd5]
3612 // CHECK: at s1e1w, x19 // encoding: [0x33,0x78,0x08,0xd5]
3613 // CHECK: at s1e2w, x19 // encoding: [0x33,0x78,0x0c,0xd5]
3614 // CHECK: at s1e3w, x19 // encoding: [0x33,0x78,0x0e,0xd5]
3615 // CHECK: at s1e0r, x19 // encoding: [0x53,0x78,0x08,0xd5]
3616 // CHECK: at s1e0w, x19 // encoding: [0x73,0x78,0x08,0xd5]
3617 // CHECK: at s12e1r, x20 // encoding: [0x94,0x78,0x0c,0xd5]
3618 // CHECK: at s12e1w, x20 // encoding: [0xb4,0x78,0x0c,0xd5]
3619 // CHECK: at s12e0r, x20 // encoding: [0xd4,0x78,0x0c,0xd5]
3620 // CHECK: at s12e0w, x20 // encoding: [0xf4,0x78,0x0c,0xd5]
3621
3622 tlbi IPAS2E1IS, x4
3623 tlbi IPAS2LE1IS, x9
3624 tlbi VMALLE1IS
3625 tlbi ALLE2IS
3626 tlbi ALLE3IS
3627 tlbi VAE1IS, x1
3628 tlbi VAE2IS, x2
3629 tlbi VAE3IS, x3
3630 tlbi ASIDE1IS, x5
3631 tlbi VAAE1IS, x9
3632 tlbi ALLE1IS
3633 tlbi VALE1IS, x10
3634 tlbi VALE2IS, x11
3635 tlbi VALE3IS, x13
3636 tlbi VMALLS12E1IS
3637 tlbi VAALE1IS, x14
3638 tlbi IPAS2E1, x15
3639 tlbi IPAS2LE1, x16
3640 tlbi VMALLE1
3641 tlbi ALLE2
3642 tlbi ALLE3
3643 tlbi VAE1, x17
3644 tlbi VAE2, x18
3645 tlbi VAE3, x19
3646 tlbi ASIDE1, x20
3647 tlbi VAAE1, x21
3648 tlbi ALLE1
3649 tlbi VALE1, x22
3650 tlbi VALE2, x23
3651 tlbi VALE3, x24
3652 tlbi VMALLS12E1
3653 tlbi VAALE1, x25
3654 // CHECK: tlbi ipas2e1is, x4 // encoding: [0x24,0x80,0x0c,0xd5]
3655 // CHECK: tlbi ipas2le1is, x9 // encoding: [0xa9,0x80,0x0c,0xd5]
3656 // CHECK: tlbi vmalle1is // encoding: [0x1f,0x83,0x08,0xd5]
3657 // CHECK: tlbi alle2is // encoding: [0x1f,0x83,0x0c,0xd5]
3658 // CHECK: tlbi alle3is // encoding: [0x1f,0x83,0x0e,0xd5]
3659 // CHECK: tlbi vae1is, x1 // encoding: [0x21,0x83,0x08,0xd5]
3660 // CHECK: tlbi vae2is, x2 // encoding: [0x22,0x83,0x0c,0xd5]
3661 // CHECK: tlbi vae3is, x3 // encoding: [0x23,0x83,0x0e,0xd5]
3662 // CHECK: tlbi aside1is, x5 // encoding: [0x45,0x83,0x08,0xd5]
3663 // CHECK: tlbi vaae1is, x9 // encoding: [0x69,0x83,0x08,0xd5]
3664 // CHECK: tlbi alle1is // encoding: [0x9f,0x83,0x0c,0xd5]
3665 // CHECK: tlbi vale1is, x10 // encoding: [0xaa,0x83,0x08,0xd5]
3666 // CHECK: tlbi vale2is, x11 // encoding: [0xab,0x83,0x0c,0xd5]
3667 // CHECK: tlbi vale3is, x13 // encoding: [0xad,0x83,0x0e,0xd5]
3668 // CHECK: tlbi vmalls12e1is // encoding: [0xdf,0x83,0x0c,0xd5]
3669 // CHECK: tlbi vaale1is, x14 // encoding: [0xee,0x83,0x08,0xd5]
3670 // CHECK: tlbi ipas2e1, x15 // encoding: [0x2f,0x84,0x0c,0xd5]
3671 // CHECK: tlbi ipas2le1, x16 // encoding: [0xb0,0x84,0x0c,0xd5]
3672 // CHECK: tlbi vmalle1 // encoding: [0x1f,0x87,0x08,0xd5]
3673 // CHECK: tlbi alle2 // encoding: [0x1f,0x87,0x0c,0xd5]
3674 // CHECK: tlbi alle3 // encoding: [0x1f,0x87,0x0e,0xd5]
3675 // CHECK: tlbi vae1, x17 // encoding: [0x31,0x87,0x08,0xd5]
3676 // CHECK: tlbi vae2, x18 // encoding: [0x32,0x87,0x0c,0xd5]
3677 // CHECK: tlbi vae3, x19 // encoding: [0x33,0x87,0x0e,0xd5]
3678 // CHECK: tlbi aside1, x20 // encoding: [0x54,0x87,0x08,0xd5]
3679 // CHECK: tlbi vaae1, x21 // encoding: [0x75,0x87,0x08,0xd5]
3680 // CHECK: tlbi alle1 // encoding: [0x9f,0x87,0x0c,0xd5]
3681 // CHECK: tlbi vale1, x22 // encoding: [0xb6,0x87,0x08,0xd5]
3682 // CHECK: tlbi vale2, x23 // encoding: [0xb7,0x87,0x0c,0xd5]
3683 // CHECK: tlbi vale3, x24 // encoding: [0xb8,0x87,0x0e,0xd5]
3684 // CHECK: tlbi vmalls12e1 // encoding: [0xdf,0x87,0x0c,0xd5]
3685 // CHECK: tlbi vaale1, x25 // encoding: [0xf9,0x87,0x08,0xd5]
3686
3687 msr TEECR32_EL1, x12
3688 msr OSDTRRX_EL1, x12
3689 msr MDCCINT_EL1, x12
3690 msr MDSCR_EL1, x12
3691 msr OSDTRTX_EL1, x12
3692 msr DBGDTR_EL0, x12
3693 msr DBGDTRTX_EL0, x12
3694 msr OSECCR_EL1, x12
3695 msr DBGVCR32_EL2, x12
3696 msr DBGBVR0_EL1, x12
3697 msr DBGBVR1_EL1, x12
3698 msr DBGBVR2_EL1, x12
3699 msr DBGBVR3_EL1, x12
3700 msr DBGBVR4_EL1, x12
3701 msr DBGBVR5_EL1, x12
3702 msr DBGBVR6_EL1, x12
3703 msr DBGBVR7_EL1, x12
3704 msr DBGBVR8_EL1, x12
3705 msr DBGBVR9_EL1, x12
3706 msr DBGBVR10_EL1, x12
3707 msr DBGBVR11_EL1, x12
3708 msr DBGBVR12_EL1, x12
3709 msr DBGBVR13_EL1, x12
3710 msr DBGBVR14_EL1, x12
3711 msr DBGBVR15_EL1, x12
3712 msr DBGBCR0_EL1, x12
3713 msr DBGBCR1_EL1, x12
3714 msr DBGBCR2_EL1, x12
3715 msr DBGBCR3_EL1, x12
3716 msr DBGBCR4_EL1, x12
3717 msr DBGBCR5_EL1, x12
3718 msr DBGBCR6_EL1, x12
3719 msr DBGBCR7_EL1, x12
3720 msr DBGBCR8_EL1, x12
3721 msr DBGBCR9_EL1, x12
3722 msr DBGBCR10_EL1, x12
3723 msr DBGBCR11_EL1, x12
3724 msr DBGBCR12_EL1, x12
3725 msr DBGBCR13_EL1, x12
3726 msr DBGBCR14_EL1, x12
3727 msr DBGBCR15_EL1, x12
3728 msr DBGWVR0_EL1, x12
3729 msr DBGWVR1_EL1, x12
3730 msr DBGWVR2_EL1, x12
3731 msr DBGWVR3_EL1, x12
3732 msr DBGWVR4_EL1, x12
3733 msr DBGWVR5_EL1, x12
3734 msr DBGWVR6_EL1, x12
3735 msr DBGWVR7_EL1, x12
3736 msr DBGWVR8_EL1, x12
3737 msr DBGWVR9_EL1, x12
3738 msr DBGWVR10_EL1, x12
3739 msr DBGWVR11_EL1, x12
3740 msr DBGWVR12_EL1, x12
3741 msr DBGWVR13_EL1, x12
3742 msr DBGWVR14_EL1, x12
3743 msr DBGWVR15_EL1, x12
3744 msr DBGWCR0_EL1, x12
3745 msr DBGWCR1_EL1, x12
3746 msr DBGWCR2_EL1, x12
3747 msr DBGWCR3_EL1, x12
3748 msr DBGWCR4_EL1, x12
3749 msr DBGWCR5_EL1, x12
3750 msr DBGWCR6_EL1, x12
3751 msr DBGWCR7_EL1, x12
3752 msr DBGWCR8_EL1, x12
3753 msr DBGWCR9_EL1, x12
3754 msr DBGWCR10_EL1, x12
3755 msr DBGWCR11_EL1, x12
3756 msr DBGWCR12_EL1, x12
3757 msr DBGWCR13_EL1, x12
3758 msr DBGWCR14_EL1, x12
3759 msr DBGWCR15_EL1, x12
3760 msr TEEHBR32_EL1, x12
3761 msr OSLAR_EL1, x12
3762 msr OSDLR_EL1, x12
3763 msr DBGPRCR_EL1, x12
3764 msr DBGCLAIMSET_EL1, x12
3765 msr DBGCLAIMCLR_EL1, x12
3766 msr CSSELR_EL1, x12
3767 msr VPIDR_EL2, x12
3768 msr VMPIDR_EL2, x12
3769 msr SCTLR_EL1, x12
3770 msr SCTLR_EL2, x12
3771 msr SCTLR_EL3, x12
3772 msr ACTLR_EL1, x12
3773 msr ACTLR_EL2, x12
3774 msr ACTLR_EL3, x12
3775 msr CPACR_EL1, x12
3776 msr HCR_EL2, x12
3777 msr SCR_EL3, x12
3778 msr MDCR_EL2, x12
3779 msr SDER32_EL3, x12
3780 msr CPTR_EL2, x12
3781 msr CPTR_EL3, x12
3782 msr HSTR_EL2, x12
3783 msr HACR_EL2, x12
3784 msr MDCR_EL3, x12
3785 msr TTBR0_EL1, x12
3786 msr TTBR0_EL2, x12
3787 msr TTBR0_EL3, x12
3788 msr TTBR1_EL1, x12
3789 msr TCR_EL1, x12
3790 msr TCR_EL2, x12
3791 msr TCR_EL3, x12
3792 msr VTTBR_EL2, x12
3793 msr VTCR_EL2, x12
3794 msr DACR32_EL2, x12
3795 msr SPSR_EL1, x12
3796 msr SPSR_EL2, x12
3797 msr SPSR_EL3, x12
3798 msr ELR_EL1, x12
3799 msr ELR_EL2, x12
3800 msr ELR_EL3, x12
3801 msr SP_EL0, x12
3802 msr SP_EL1, x12
3803 msr SP_EL2, x12
3804 msr SPSel, x12
3805 msr NZCV, x12
3806 msr DAIF, x12
3807 msr CurrentEL, x12
3808 msr SPSR_irq, x12
3809 msr SPSR_abt, x12
3810 msr SPSR_und, x12
3811 msr SPSR_fiq, x12
3812 msr FPCR, x12
3813 msr FPSR, x12
3814 msr DSPSR_EL0, x12
3815 msr DLR_EL0, x12
3816 msr IFSR32_EL2, x12
3817 msr AFSR0_EL1, x12
3818 msr AFSR0_EL2, x12
3819 msr AFSR0_EL3, x12
3820 msr AFSR1_EL1, x12
3821 msr AFSR1_EL2, x12
3822 msr AFSR1_EL3, x12
3823 msr ESR_EL1, x12
3824 msr ESR_EL2, x12
3825 msr ESR_EL3, x12
3826 msr FPEXC32_EL2, x12
3827 msr FAR_EL1, x12
3828 msr FAR_EL2, x12
3829 msr FAR_EL3, x12
3830 msr HPFAR_EL2, x12
3831 msr PAR_EL1, x12
3832 msr PMCR_EL0, x12
3833 msr PMCNTENSET_EL0, x12
3834 msr PMCNTENCLR_EL0, x12
3835 msr PMOVSCLR_EL0, x12
3836 msr PMSELR_EL0, x12
3837 msr PMCCNTR_EL0, x12
3838 msr PMXEVTYPER_EL0, x12
3839 msr PMXEVCNTR_EL0, x12
3840 msr PMUSERENR_EL0, x12
3841 msr PMINTENSET_EL1, x12
3842 msr PMINTENCLR_EL1, x12
3843 msr PMOVSSET_EL0, x12
3844 msr MAIR_EL1, x12
3845 msr MAIR_EL2, x12
3846 msr MAIR_EL3, x12
3847 msr AMAIR_EL1, x12
3848 msr AMAIR_EL2, x12
3849 msr AMAIR_EL3, x12
3850 msr VBAR_EL1, x12
3851 msr VBAR_EL2, x12
3852 msr VBAR_EL3, x12
3853 msr RMR_EL1, x12
3854 msr RMR_EL2, x12
3855 msr RMR_EL3, x12
3856 msr CONTEXTIDR_EL1, x12
3857 msr TPIDR_EL0, x12
3858 msr TPIDR_EL2, x12
3859 msr TPIDR_EL3, x12
3860 msr TPIDRRO_EL0, x12
3861 msr TPIDR_EL1, x12
3862 msr CNTFRQ_EL0, x12
3863 msr CNTVOFF_EL2, x12
3864 msr CNTKCTL_EL1, x12
3865 msr CNTHCTL_EL2, x12
3866 msr CNTP_TVAL_EL0, x12
3867 msr CNTHP_TVAL_EL2, x12
3868 msr CNTPS_TVAL_EL1, x12
3869 msr CNTP_CTL_EL0, x12
3870 msr CNTHP_CTL_EL2, x12
3871 msr CNTPS_CTL_EL1, x12
3872 msr CNTP_CVAL_EL0, x12
3873 msr CNTHP_CVAL_EL2, x12
3874 msr CNTPS_CVAL_EL1, x12
3875 msr CNTV_TVAL_EL0, x12
3876 msr CNTV_CTL_EL0, x12
3877 msr CNTV_CVAL_EL0, x12
3878 msr PMEVCNTR0_EL0, x12
3879 msr PMEVCNTR1_EL0, x12
3880 msr PMEVCNTR2_EL0, x12
3881 msr PMEVCNTR3_EL0, x12
3882 msr PMEVCNTR4_EL0, x12
3883 msr PMEVCNTR5_EL0, x12
3884 msr PMEVCNTR6_EL0, x12
3885 msr PMEVCNTR7_EL0, x12
3886 msr PMEVCNTR8_EL0, x12
3887 msr PMEVCNTR9_EL0, x12
3888 msr PMEVCNTR10_EL0, x12
3889 msr PMEVCNTR11_EL0, x12
3890 msr PMEVCNTR12_EL0, x12
3891 msr PMEVCNTR13_EL0, x12
3892 msr PMEVCNTR14_EL0, x12
3893 msr PMEVCNTR15_EL0, x12
3894 msr PMEVCNTR16_EL0, x12
3895 msr PMEVCNTR17_EL0, x12
3896 msr PMEVCNTR18_EL0, x12
3897 msr PMEVCNTR19_EL0, x12
3898 msr PMEVCNTR20_EL0, x12
3899 msr PMEVCNTR21_EL0, x12
3900 msr PMEVCNTR22_EL0, x12
3901 msr PMEVCNTR23_EL0, x12
3902 msr PMEVCNTR24_EL0, x12
3903 msr PMEVCNTR25_EL0, x12
3904 msr PMEVCNTR26_EL0, x12
3905 msr PMEVCNTR27_EL0, x12
3906 msr PMEVCNTR28_EL0, x12
3907 msr PMEVCNTR29_EL0, x12
3908 msr PMEVCNTR30_EL0, x12
3909 msr PMCCFILTR_EL0, x12
3910 msr PMEVTYPER0_EL0, x12
3911 msr PMEVTYPER1_EL0, x12
3912 msr PMEVTYPER2_EL0, x12
3913 msr PMEVTYPER3_EL0, x12
3914 msr PMEVTYPER4_EL0, x12
3915 msr PMEVTYPER5_EL0, x12
3916 msr PMEVTYPER6_EL0, x12
3917 msr PMEVTYPER7_EL0, x12
3918 msr PMEVTYPER8_EL0, x12
3919 msr PMEVTYPER9_EL0, x12
3920 msr PMEVTYPER10_EL0, x12
3921 msr PMEVTYPER11_EL0, x12
3922 msr PMEVTYPER12_EL0, x12
3923 msr PMEVTYPER13_EL0, x12
3924 msr PMEVTYPER14_EL0, x12
3925 msr PMEVTYPER15_EL0, x12
3926 msr PMEVTYPER16_EL0, x12
3927 msr PMEVTYPER17_EL0, x12
3928 msr PMEVTYPER18_EL0, x12
3929 msr PMEVTYPER19_EL0, x12
3930 msr PMEVTYPER20_EL0, x12
3931 msr PMEVTYPER21_EL0, x12
3932 msr PMEVTYPER22_EL0, x12
3933 msr PMEVTYPER23_EL0, x12
3934 msr PMEVTYPER24_EL0, x12
3935 msr PMEVTYPER25_EL0, x12
3936 msr PMEVTYPER26_EL0, x12
3937 msr PMEVTYPER27_EL0, x12
3938 msr PMEVTYPER28_EL0, x12
3939 msr PMEVTYPER29_EL0, x12
3940 msr PMEVTYPER30_EL0, x12
3941 // CHECK: msr {{teecr32_el1|TEECR32_EL1}}, x12 // encoding: [0x0c,0x00,0x12,0xd5]
3942 // CHECK: msr {{osdtrrx_el1|OSDTRRX_EL1}}, x12 // encoding: [0x4c,0x00,0x10,0xd5]
3943 // CHECK: msr {{mdccint_el1|MDCCINT_EL1}}, x12 // encoding: [0x0c,0x02,0x10,0xd5]
3944 // CHECK: msr {{mdscr_el1|MDSCR_EL1}}, x12 // encoding: [0x4c,0x02,0x10,0xd5]
3945 // CHECK: msr {{osdtrtx_el1|OSDTRTX_EL1}}, x12 // encoding: [0x4c,0x03,0x10,0xd5]
3946 // CHECK: msr {{dbgdtr_el0|DBGDTR_EL0}}, x12 // encoding: [0x0c,0x04,0x13,0xd5]
3947 // CHECK: msr {{dbgdtrtx_el0|DBGDTRTX_EL0}}, x12 // encoding: [0x0c,0x05,0x13,0xd5]
3948 // CHECK: msr {{oseccr_el1|OSECCR_EL1}}, x12 // encoding: [0x4c,0x06,0x10,0xd5]
3949 // CHECK: msr {{dbgvcr32_el2|DBGVCR32_EL2}}, x12 // encoding: [0x0c,0x07,0x14,0xd5]
3950 // CHECK: msr {{dbgbvr0_el1|DBGBVR0_EL1}}, x12 // encoding: [0x8c,0x00,0x10,0xd5]
3951 // CHECK: msr {{dbgbvr1_el1|DBGBVR1_EL1}}, x12 // encoding: [0x8c,0x01,0x10,0xd5]
3952 // CHECK: msr {{dbgbvr2_el1|DBGBVR2_EL1}}, x12 // encoding: [0x8c,0x02,0x10,0xd5]
3953 // CHECK: msr {{dbgbvr3_el1|DBGBVR3_EL1}}, x12 // encoding: [0x8c,0x03,0x10,0xd5]
3954 // CHECK: msr {{dbgbvr4_el1|DBGBVR4_EL1}}, x12 // encoding: [0x8c,0x04,0x10,0xd5]
3955 // CHECK: msr {{dbgbvr5_el1|DBGBVR5_EL1}}, x12 // encoding: [0x8c,0x05,0x10,0xd5]
3956 // CHECK: msr {{dbgbvr6_el1|DBGBVR6_EL1}}, x12 // encoding: [0x8c,0x06,0x10,0xd5]
3957 // CHECK: msr {{dbgbvr7_el1|DBGBVR7_EL1}}, x12 // encoding: [0x8c,0x07,0x10,0xd5]
3958 // CHECK: msr {{dbgbvr8_el1|DBGBVR8_EL1}}, x12 // encoding: [0x8c,0x08,0x10,0xd5]
3959 // CHECK: msr {{dbgbvr9_el1|DBGBVR9_EL1}}, x12 // encoding: [0x8c,0x09,0x10,0xd5]
3960 // CHECK: msr {{dbgbvr10_el1|DBGBVR10_EL1}}, x12 // encoding: [0x8c,0x0a,0x10,0xd5]
3961 // CHECK: msr {{dbgbvr11_el1|DBGBVR11_EL1}}, x12 // encoding: [0x8c,0x0b,0x10,0xd5]
3962 // CHECK: msr {{dbgbvr12_el1|DBGBVR12_EL1}}, x12 // encoding: [0x8c,0x0c,0x10,0xd5]
3963 // CHECK: msr {{dbgbvr13_el1|DBGBVR13_EL1}}, x12 // encoding: [0x8c,0x0d,0x10,0xd5]
3964 // CHECK: msr {{dbgbvr14_el1|DBGBVR14_EL1}}, x12 // encoding: [0x8c,0x0e,0x10,0xd5]
3965 // CHECK: msr {{dbgbvr15_el1|DBGBVR15_EL1}}, x12 // encoding: [0x8c,0x0f,0x10,0xd5]
3966 // CHECK: msr {{dbgbcr0_el1|DBGBCR0_EL1}}, x12 // encoding: [0xac,0x00,0x10,0xd5]
3967 // CHECK: msr {{dbgbcr1_el1|DBGBCR1_EL1}}, x12 // encoding: [0xac,0x01,0x10,0xd5]
3968 // CHECK: msr {{dbgbcr2_el1|DBGBCR2_EL1}}, x12 // encoding: [0xac,0x02,0x10,0xd5]
3969 // CHECK: msr {{dbgbcr3_el1|DBGBCR3_EL1}}, x12 // encoding: [0xac,0x03,0x10,0xd5]
3970 // CHECK: msr {{dbgbcr4_el1|DBGBCR4_EL1}}, x12 // encoding: [0xac,0x04,0x10,0xd5]
3971 // CHECK: msr {{dbgbcr5_el1|DBGBCR5_EL1}}, x12 // encoding: [0xac,0x05,0x10,0xd5]
3972 // CHECK: msr {{dbgbcr6_el1|DBGBCR6_EL1}}, x12 // encoding: [0xac,0x06,0x10,0xd5]
3973 // CHECK: msr {{dbgbcr7_el1|DBGBCR7_EL1}}, x12 // encoding: [0xac,0x07,0x10,0xd5]
3974 // CHECK: msr {{dbgbcr8_el1|DBGBCR8_EL1}}, x12 // encoding: [0xac,0x08,0x10,0xd5]
3975 // CHECK: msr {{dbgbcr9_el1|DBGBCR9_EL1}}, x12 // encoding: [0xac,0x09,0x10,0xd5]
3976 // CHECK: msr {{dbgbcr10_el1|DBGBCR10_EL1}}, x12 // encoding: [0xac,0x0a,0x10,0xd5]
3977 // CHECK: msr {{dbgbcr11_el1|DBGBCR11_EL1}}, x12 // encoding: [0xac,0x0b,0x10,0xd5]
3978 // CHECK: msr {{dbgbcr12_el1|DBGBCR12_EL1}}, x12 // encoding: [0xac,0x0c,0x10,0xd5]
3979 // CHECK: msr {{dbgbcr13_el1|DBGBCR13_EL1}}, x12 // encoding: [0xac,0x0d,0x10,0xd5]
3980 // CHECK: msr {{dbgbcr14_el1|DBGBCR14_EL1}}, x12 // encoding: [0xac,0x0e,0x10,0xd5]
3981 // CHECK: msr {{dbgbcr15_el1|DBGBCR15_EL1}}, x12 // encoding: [0xac,0x0f,0x10,0xd5]
3982 // CHECK: msr {{dbgwvr0_el1|DBGWVR0_EL1}}, x12 // encoding: [0xcc,0x00,0x10,0xd5]
3983 // CHECK: msr {{dbgwvr1_el1|DBGWVR1_EL1}}, x12 // encoding: [0xcc,0x01,0x10,0xd5]
3984 // CHECK: msr {{dbgwvr2_el1|DBGWVR2_EL1}}, x12 // encoding: [0xcc,0x02,0x10,0xd5]
3985 // CHECK: msr {{dbgwvr3_el1|DBGWVR3_EL1}}, x12 // encoding: [0xcc,0x03,0x10,0xd5]
3986 // CHECK: msr {{dbgwvr4_el1|DBGWVR4_EL1}}, x12 // encoding: [0xcc,0x04,0x10,0xd5]
3987 // CHECK: msr {{dbgwvr5_el1|DBGWVR5_EL1}}, x12 // encoding: [0xcc,0x05,0x10,0xd5]
3988 // CHECK: msr {{dbgwvr6_el1|DBGWVR6_EL1}}, x12 // encoding: [0xcc,0x06,0x10,0xd5]
3989 // CHECK: msr {{dbgwvr7_el1|DBGWVR7_EL1}}, x12 // encoding: [0xcc,0x07,0x10,0xd5]
3990 // CHECK: msr {{dbgwvr8_el1|DBGWVR8_EL1}}, x12 // encoding: [0xcc,0x08,0x10,0xd5]
3991 // CHECK: msr {{dbgwvr9_el1|DBGWVR9_EL1}}, x12 // encoding: [0xcc,0x09,0x10,0xd5]
3992 // CHECK: msr {{dbgwvr10_el1|DBGWVR10_EL1}}, x12 // encoding: [0xcc,0x0a,0x10,0xd5]
3993 // CHECK: msr {{dbgwvr11_el1|DBGWVR11_EL1}}, x12 // encoding: [0xcc,0x0b,0x10,0xd5]
3994 // CHECK: msr {{dbgwvr12_el1|DBGWVR12_EL1}}, x12 // encoding: [0xcc,0x0c,0x10,0xd5]
3995 // CHECK: msr {{dbgwvr13_el1|DBGWVR13_EL1}}, x12 // encoding: [0xcc,0x0d,0x10,0xd5]
3996 // CHECK: msr {{dbgwvr14_el1|DBGWVR14_EL1}}, x12 // encoding: [0xcc,0x0e,0x10,0xd5]
3997 // CHECK: msr {{dbgwvr15_el1|DBGWVR15_EL1}}, x12 // encoding: [0xcc,0x0f,0x10,0xd5]
3998 // CHECK: msr {{dbgwcr0_el1|DBGWCR0_EL1}}, x12 // encoding: [0xec,0x00,0x10,0xd5]
3999 // CHECK: msr {{dbgwcr1_el1|DBGWCR1_EL1}}, x12 // encoding: [0xec,0x01,0x10,0xd5]
4000 // CHECK: msr {{dbgwcr2_el1|DBGWCR2_EL1}}, x12 // encoding: [0xec,0x02,0x10,0xd5]
4001 // CHECK: msr {{dbgwcr3_el1|DBGWCR3_EL1}}, x12 // encoding: [0xec,0x03,0x10,0xd5]
4002 // CHECK: msr {{dbgwcr4_el1|DBGWCR4_EL1}}, x12 // encoding: [0xec,0x04,0x10,0xd5]
4003 // CHECK: msr {{dbgwcr5_el1|DBGWCR5_EL1}}, x12 // encoding: [0xec,0x05,0x10,0xd5]
4004 // CHECK: msr {{dbgwcr6_el1|DBGWCR6_EL1}}, x12 // encoding: [0xec,0x06,0x10,0xd5]
4005 // CHECK: msr {{dbgwcr7_el1|DBGWCR7_EL1}}, x12 // encoding: [0xec,0x07,0x10,0xd5]
4006 // CHECK: msr {{dbgwcr8_el1|DBGWCR8_EL1}}, x12 // encoding: [0xec,0x08,0x10,0xd5]
4007 // CHECK: msr {{dbgwcr9_el1|DBGWCR9_EL1}}, x12 // encoding: [0xec,0x09,0x10,0xd5]
4008 // CHECK: msr {{dbgwcr10_el1|DBGWCR10_EL1}}, x12 // encoding: [0xec,0x0a,0x10,0xd5]
4009 // CHECK: msr {{dbgwcr11_el1|DBGWCR11_EL1}}, x12 // encoding: [0xec,0x0b,0x10,0xd5]
4010 // CHECK: msr {{dbgwcr12_el1|DBGWCR12_EL1}}, x12 // encoding: [0xec,0x0c,0x10,0xd5]
4011 // CHECK: msr {{dbgwcr13_el1|DBGWCR13_EL1}}, x12 // encoding: [0xec,0x0d,0x10,0xd5]
4012 // CHECK: msr {{dbgwcr14_el1|DBGWCR14_EL1}}, x12 // encoding: [0xec,0x0e,0x10,0xd5]
4013 // CHECK: msr {{dbgwcr15_el1|DBGWCR15_EL1}}, x12 // encoding: [0xec,0x0f,0x10,0xd5]
4014 // CHECK: msr {{teehbr32_el1|TEEHBR32_EL1}}, x12 // encoding: [0x0c,0x10,0x12,0xd5]
4015 // CHECK: msr {{oslar_el1|OSLAR_EL1}}, x12 // encoding: [0x8c,0x10,0x10,0xd5]
4016 // CHECK: msr {{osdlr_el1|OSDLR_EL1}}, x12 // encoding: [0x8c,0x13,0x10,0xd5]
4017 // CHECK: msr {{dbgprcr_el1|DBGPRCR_EL1}}, x12 // encoding: [0x8c,0x14,0x10,0xd5]
4018 // CHECK: msr {{dbgclaimset_el1|DBGCLAIMSET_EL1}}, x12 // encoding: [0xcc,0x78,0x10,0xd5]
4019 // CHECK: msr {{dbgclaimclr_el1|DBGCLAIMCLR_EL1}}, x12 // encoding: [0xcc,0x79,0x10,0xd5]
4020 // CHECK: msr {{csselr_el1|CSSELR_EL1}}, x12 // encoding: [0x0c,0x00,0x1a,0xd5]
4021 // CHECK: msr {{vpidr_el2|VPIDR_EL2}}, x12 // encoding: [0x0c,0x00,0x1c,0xd5]
4022 // CHECK: msr {{vmpidr_el2|VMPIDR_EL2}}, x12 // encoding: [0xac,0x00,0x1c,0xd5]
4023 // CHECK: msr {{sctlr_el1|SCTLR_EL1}}, x12 // encoding: [0x0c,0x10,0x18,0xd5]
4024 // CHECK: msr {{sctlr_el2|SCTLR_EL2}}, x12 // encoding: [0x0c,0x10,0x1c,0xd5]
4025 // CHECK: msr {{sctlr_el3|SCTLR_EL3}}, x12 // encoding: [0x0c,0x10,0x1e,0xd5]
4026 // CHECK: msr {{actlr_el1|ACTLR_EL1}}, x12 // encoding: [0x2c,0x10,0x18,0xd5]
4027 // CHECK: msr {{actlr_el2|ACTLR_EL2}}, x12 // encoding: [0x2c,0x10,0x1c,0xd5]
4028 // CHECK: msr {{actlr_el3|ACTLR_EL3}}, x12 // encoding: [0x2c,0x10,0x1e,0xd5]
4029 // CHECK: msr {{cpacr_el1|CPACR_EL1}}, x12 // encoding: [0x4c,0x10,0x18,0xd5]
4030 // CHECK: msr {{hcr_el2|HCR_EL2}}, x12 // encoding: [0x0c,0x11,0x1c,0xd5]
4031 // CHECK: msr {{scr_el3|SCR_EL3}}, x12 // encoding: [0x0c,0x11,0x1e,0xd5]
4032 // CHECK: msr {{mdcr_el2|MDCR_EL2}}, x12 // encoding: [0x2c,0x11,0x1c,0xd5]
4033 // CHECK: msr {{sder32_el3|SDER32_EL3}}, x12 // encoding: [0x2c,0x11,0x1e,0xd5]
4034 // CHECK: msr {{cptr_el2|CPTR_EL2}}, x12 // encoding: [0x4c,0x11,0x1c,0xd5]
4035 // CHECK: msr {{cptr_el3|CPTR_EL3}}, x12 // encoding: [0x4c,0x11,0x1e,0xd5]
4036 // CHECK: msr {{hstr_el2|HSTR_EL2}}, x12 // encoding: [0x6c,0x11,0x1c,0xd5]
4037 // CHECK: msr {{hacr_el2|HACR_EL2}}, x12 // encoding: [0xec,0x11,0x1c,0xd5]
4038 // CHECK: msr {{mdcr_el3|MDCR_EL3}}, x12 // encoding: [0x2c,0x13,0x1e,0xd5]
4039 // CHECK: msr {{ttbr0_el1|TTBR0_EL1}}, x12 // encoding: [0x0c,0x20,0x18,0xd5]
4040 // CHECK: msr {{ttbr0_el2|TTBR0_EL2}}, x12 // encoding: [0x0c,0x20,0x1c,0xd5]
4041 // CHECK: msr {{ttbr0_el3|TTBR0_EL3}}, x12 // encoding: [0x0c,0x20,0x1e,0xd5]
4042 // CHECK: msr {{ttbr1_el1|TTBR1_EL1}}, x12 // encoding: [0x2c,0x20,0x18,0xd5]
4043 // CHECK: msr {{tcr_el1|TCR_EL1}}, x12 // encoding: [0x4c,0x20,0x18,0xd5]
4044 // CHECK: msr {{tcr_el2|TCR_EL2}}, x12 // encoding: [0x4c,0x20,0x1c,0xd5]
4045 // CHECK: msr {{tcr_el3|TCR_EL3}}, x12 // encoding: [0x4c,0x20,0x1e,0xd5]
4046 // CHECK: msr {{vttbr_el2|VTTBR_EL2}}, x12 // encoding: [0x0c,0x21,0x1c,0xd5]
4047 // CHECK: msr {{vtcr_el2|VTCR_EL2}}, x12 // encoding: [0x4c,0x21,0x1c,0xd5]
4048 // CHECK: msr {{dacr32_el2|DACR32_EL2}}, x12 // encoding: [0x0c,0x30,0x1c,0xd5]
4049 // CHECK: msr {{spsr_el1|SPSR_EL1}}, x12 // encoding: [0x0c,0x40,0x18,0xd5]
4050 // CHECK: msr {{spsr_el2|SPSR_EL2}}, x12 // encoding: [0x0c,0x40,0x1c,0xd5]
4051 // CHECK: msr {{spsr_el3|SPSR_EL3}}, x12 // encoding: [0x0c,0x40,0x1e,0xd5]
4052 // CHECK: msr {{elr_el1|ELR_EL1}}, x12 // encoding: [0x2c,0x40,0x18,0xd5]
4053 // CHECK: msr {{elr_el2|ELR_EL2}}, x12 // encoding: [0x2c,0x40,0x1c,0xd5]
4054 // CHECK: msr {{elr_el3|ELR_EL3}}, x12 // encoding: [0x2c,0x40,0x1e,0xd5]
4055 // CHECK: msr {{sp_el0|SP_EL0}}, x12 // encoding: [0x0c,0x41,0x18,0xd5]
4056 // CHECK: msr {{sp_el1|SP_EL1}}, x12 // encoding: [0x0c,0x41,0x1c,0xd5]
4057 // CHECK: msr {{sp_el2|SP_EL2}}, x12 // encoding: [0x0c,0x41,0x1e,0xd5]
4058 // CHECK: msr {{SPSel|SPSEL}}, x12 // encoding: [0x0c,0x42,0x18,0xd5]
4059 // CHECK: msr {{nzcv|NZCV}}, x12 // encoding: [0x0c,0x42,0x1b,0xd5]
4060 // CHECK: msr {{daif|DAIF}}, x12 // encoding: [0x2c,0x42,0x1b,0xd5]
4061 // CHECK: msr {{CurrentEL|CURRENTEL}}, x12 // encoding: [0x4c,0x42,0x18,0xd5]
4062 // CHECK: msr {{SPSR_irq|SPSR_IRQ}}, x12 // encoding: [0x0c,0x43,0x1c,0xd5]
4063 // CHECK: msr {{SPSR_abt|SPSR_ABT}}, x12 // encoding: [0x2c,0x43,0x1c,0xd5]
4064 // CHECK: msr {{SPSR_und|SPSR_UND}}, x12 // encoding: [0x4c,0x43,0x1c,0xd5]
4065 // CHECK: msr {{SPSR_fiq|SPSR_FIQ}}, x12 // encoding: [0x6c,0x43,0x1c,0xd5]
4066 // CHECK: msr {{fpcr|FPCR}}, x12 // encoding: [0x0c,0x44,0x1b,0xd5]
4067 // CHECK: msr {{fpsr|FPSR}}, x12 // encoding: [0x2c,0x44,0x1b,0xd5]
4068 // CHECK: msr {{dspsr_el0|DSPSR_EL0}}, x12 // encoding: [0x0c,0x45,0x1b,0xd5]
4069 // CHECK: msr {{dlr_el0|DLR_EL0}}, x12 // encoding: [0x2c,0x45,0x1b,0xd5]
4070 // CHECK: msr {{ifsr32_el2|IFSR32_EL2}}, x12 // encoding: [0x2c,0x50,0x1c,0xd5]
4071 // CHECK: msr {{afsr0_el1|AFSR0_EL1}}, x12 // encoding: [0x0c,0x51,0x18,0xd5]
4072 // CHECK: msr {{afsr0_el2|AFSR0_EL2}}, x12 // encoding: [0x0c,0x51,0x1c,0xd5]
4073 // CHECK: msr {{afsr0_el3|AFSR0_EL3}}, x12 // encoding: [0x0c,0x51,0x1e,0xd5]
4074 // CHECK: msr {{afsr1_el1|AFSR1_EL1}}, x12 // encoding: [0x2c,0x51,0x18,0xd5]
4075 // CHECK: msr {{afsr1_el2|AFSR1_EL2}}, x12 // encoding: [0x2c,0x51,0x1c,0xd5]
4076 // CHECK: msr {{afsr1_el3|AFSR1_EL3}}, x12 // encoding: [0x2c,0x51,0x1e,0xd5]
4077 // CHECK: msr {{esr_el1|ESR_EL1}}, x12 // encoding: [0x0c,0x52,0x18,0xd5]
4078 // CHECK: msr {{esr_el2|ESR_EL2}}, x12 // encoding: [0x0c,0x52,0x1c,0xd5]
4079 // CHECK: msr {{esr_el3|ESR_EL3}}, x12 // encoding: [0x0c,0x52,0x1e,0xd5]
4080 // CHECK: msr {{fpexc32_el2|FPEXC32_EL2}}, x12 // encoding: [0x0c,0x53,0x1c,0xd5]
4081 // CHECK: msr {{far_el1|FAR_EL1}}, x12 // encoding: [0x0c,0x60,0x18,0xd5]
4082 // CHECK: msr {{far_el2|FAR_EL2}}, x12 // encoding: [0x0c,0x60,0x1c,0xd5]
4083 // CHECK: msr {{far_el3|FAR_EL3}}, x12 // encoding: [0x0c,0x60,0x1e,0xd5]
4084 // CHECK: msr {{hpfar_el2|HPFAR_EL2}}, x12 // encoding: [0x8c,0x60,0x1c,0xd5]
4085 // CHECK: msr {{par_el1|PAR_EL1}}, x12 // encoding: [0x0c,0x74,0x18,0xd5]
4086 // CHECK: msr {{pmcr_el0|PMCR_EL0}}, x12 // encoding: [0x0c,0x9c,0x1b,0xd5]
4087 // CHECK: msr {{pmcntenset_el0|PMCNTENSET_EL0}}, x12 // encoding: [0x2c,0x9c,0x1b,0xd5]
4088 // CHECK: msr {{pmcntenclr_el0|PMCNTENCLR_EL0}}, x12 // encoding: [0x4c,0x9c,0x1b,0xd5]
4089 // CHECK: msr {{pmovsclr_el0|PMOVSCLR_EL0}}, x12 // encoding: [0x6c,0x9c,0x1b,0xd5]
4090 // CHECK: msr {{pmselr_el0|PMSELR_EL0}}, x12 // encoding: [0xac,0x9c,0x1b,0xd5]
4091 // CHECK: msr {{pmccntr_el0|PMCCNTR_EL0}}, x12 // encoding: [0x0c,0x9d,0x1b,0xd5]
4092 // CHECK: msr {{pmxevtyper_el0|PMXEVTYPER_EL0}}, x12 // encoding: [0x2c,0x9d,0x1b,0xd5]
4093 // CHECK: msr {{pmxevcntr_el0|PMXEVCNTR_EL0}}, x12 // encoding: [0x4c,0x9d,0x1b,0xd5]
4094 // CHECK: msr {{pmuserenr_el0|PMUSERENR_EL0}}, x12 // encoding: [0x0c,0x9e,0x1b,0xd5]
4095 // CHECK: msr {{pmintenset_el1|PMINTENSET_EL1}}, x12 // encoding: [0x2c,0x9e,0x18,0xd5]
4096 // CHECK: msr {{pmintenclr_el1|PMINTENCLR_EL1}}, x12 // encoding: [0x4c,0x9e,0x18,0xd5]
4097 // CHECK: msr {{pmovsset_el0|PMOVSSET_EL0}}, x12 // encoding: [0x6c,0x9e,0x1b,0xd5]
4098 // CHECK: msr {{mair_el1|MAIR_EL1}}, x12 // encoding: [0x0c,0xa2,0x18,0xd5]
4099 // CHECK: msr {{mair_el2|MAIR_EL2}}, x12 // encoding: [0x0c,0xa2,0x1c,0xd5]
4100 // CHECK: msr {{mair_el3|MAIR_EL3}}, x12 // encoding: [0x0c,0xa2,0x1e,0xd5]
4101 // CHECK: msr {{amair_el1|AMAIR_EL1}}, x12 // encoding: [0x0c,0xa3,0x18,0xd5]
4102 // CHECK: msr {{amair_el2|AMAIR_EL2}}, x12 // encoding: [0x0c,0xa3,0x1c,0xd5]
4103 // CHECK: msr {{amair_el3|AMAIR_EL3}}, x12 // encoding: [0x0c,0xa3,0x1e,0xd5]
4104 // CHECK: msr {{vbar_el1|VBAR_EL1}}, x12 // encoding: [0x0c,0xc0,0x18,0xd5]
4105 // CHECK: msr {{vbar_el2|VBAR_EL2}}, x12 // encoding: [0x0c,0xc0,0x1c,0xd5]
4106 // CHECK: msr {{vbar_el3|VBAR_EL3}}, x12 // encoding: [0x0c,0xc0,0x1e,0xd5]
4107 // CHECK: msr {{rmr_el1|RMR_EL1}}, x12 // encoding: [0x4c,0xc0,0x18,0xd5]
4108 // CHECK: msr {{rmr_el2|RMR_EL2}}, x12 // encoding: [0x4c,0xc0,0x1c,0xd5]
4109 // CHECK: msr {{rmr_el3|RMR_EL3}}, x12 // encoding: [0x4c,0xc0,0x1e,0xd5]
4110 // CHECK: msr {{contextidr_el1|CONTEXTIDR_EL1}}, x12 // encoding: [0x2c,0xd0,0x18,0xd5]
4111 // CHECK: msr {{tpidr_el0|TPIDR_EL0}}, x12 // encoding: [0x4c,0xd0,0x1b,0xd5]
4112 // CHECK: msr {{tpidr_el2|TPIDR_EL2}}, x12 // encoding: [0x4c,0xd0,0x1c,0xd5]
4113 // CHECK: msr {{tpidr_el3|TPIDR_EL3}}, x12 // encoding: [0x4c,0xd0,0x1e,0xd5]
4114 // CHECK: msr {{tpidrro_el0|TPIDRRO_EL0}}, x12 // encoding: [0x6c,0xd0,0x1b,0xd5]
4115 // CHECK: msr {{tpidr_el1|TPIDR_EL1}}, x12 // encoding: [0x8c,0xd0,0x18,0xd5]
4116 // CHECK: msr {{cntfrq_el0|CNTFRQ_EL0}}, x12 // encoding: [0x0c,0xe0,0x1b,0xd5]
4117 // CHECK: msr {{cntvoff_el2|CNTVOFF_EL2}}, x12 // encoding: [0x6c,0xe0,0x1c,0xd5]
4118 // CHECK: msr {{cntkctl_el1|CNTKCTL_EL1}}, x12 // encoding: [0x0c,0xe1,0x18,0xd5]
4119 // CHECK: msr {{cnthctl_el2|CNTHCTL_EL2}}, x12 // encoding: [0x0c,0xe1,0x1c,0xd5]
4120 // CHECK: msr {{cntp_tval_el0|CNTP_TVAL_EL0}}, x12 // encoding: [0x0c,0xe2,0x1b,0xd5]
4121 // CHECK: msr {{cnthp_tval_el2|CNTHP_TVAL_EL2}}, x12 // encoding: [0x0c,0xe2,0x1c,0xd5]
4122 // CHECK: msr {{cntps_tval_el1|CNTPS_TVAL_EL1}}, x12 // encoding: [0x0c,0xe2,0x1f,0xd5]
4123 // CHECK: msr {{cntp_ctl_el0|CNTP_CTL_EL0}}, x12 // encoding: [0x2c,0xe2,0x1b,0xd5]
4124 // CHECK: msr {{cnthp_ctl_el2|CNTHP_CTL_EL2}}, x12 // encoding: [0x2c,0xe2,0x1c,0xd5]
4125 // CHECK: msr {{cntps_ctl_el1|CNTPS_CTL_EL1}}, x12 // encoding: [0x2c,0xe2,0x1f,0xd5]
4126 // CHECK: msr {{cntp_cval_el0|CNTP_CVAL_EL0}}, x12 // encoding: [0x4c,0xe2,0x1b,0xd5]
4127 // CHECK: msr {{cnthp_cval_el2|CNTHP_CVAL_EL2}}, x12 // encoding: [0x4c,0xe2,0x1c,0xd5]
4128 // CHECK: msr {{cntps_cval_el1|CNTPS_CVAL_EL1}}, x12 // encoding: [0x4c,0xe2,0x1f,0xd5]
4129 // CHECK: msr {{cntv_tval_el0|CNTV_TVAL_EL0}}, x12 // encoding: [0x0c,0xe3,0x1b,0xd5]
4130 // CHECK: msr {{cntv_ctl_el0|CNTV_CTL_EL0}}, x12 // encoding: [0x2c,0xe3,0x1b,0xd5]
4131 // CHECK: msr {{cntv_cval_el0|CNTV_CVAL_EL0}}, x12 // encoding: [0x4c,0xe3,0x1b,0xd5]
4132 // CHECK: msr {{pmevcntr0_el0|PMEVCNTR0_EL0}}, x12 // encoding: [0x0c,0xe8,0x1b,0xd5]
4133 // CHECK: msr {{pmevcntr1_el0|PMEVCNTR1_EL0}}, x12 // encoding: [0x2c,0xe8,0x1b,0xd5]
4134 // CHECK: msr {{pmevcntr2_el0|PMEVCNTR2_EL0}}, x12 // encoding: [0x4c,0xe8,0x1b,0xd5]
4135 // CHECK: msr {{pmevcntr3_el0|PMEVCNTR3_EL0}}, x12 // encoding: [0x6c,0xe8,0x1b,0xd5]
4136 // CHECK: msr {{pmevcntr4_el0|PMEVCNTR4_EL0}}, x12 // encoding: [0x8c,0xe8,0x1b,0xd5]
4137 // CHECK: msr {{pmevcntr5_el0|PMEVCNTR5_EL0}}, x12 // encoding: [0xac,0xe8,0x1b,0xd5]
4138 // CHECK: msr {{pmevcntr6_el0|PMEVCNTR6_EL0}}, x12 // encoding: [0xcc,0xe8,0x1b,0xd5]
4139 // CHECK: msr {{pmevcntr7_el0|PMEVCNTR7_EL0}}, x12 // encoding: [0xec,0xe8,0x1b,0xd5]
4140 // CHECK: msr {{pmevcntr8_el0|PMEVCNTR8_EL0}}, x12 // encoding: [0x0c,0xe9,0x1b,0xd5]
4141 // CHECK: msr {{pmevcntr9_el0|PMEVCNTR9_EL0}}, x12 // encoding: [0x2c,0xe9,0x1b,0xd5]
4142 // CHECK: msr {{pmevcntr10_el0|PMEVCNTR10_EL0}}, x12 // encoding: [0x4c,0xe9,0x1b,0xd5]
4143 // CHECK: msr {{pmevcntr11_el0|PMEVCNTR11_EL0}}, x12 // encoding: [0x6c,0xe9,0x1b,0xd5]
4144 // CHECK: msr {{pmevcntr12_el0|PMEVCNTR12_EL0}}, x12 // encoding: [0x8c,0xe9,0x1b,0xd5]
4145 // CHECK: msr {{pmevcntr13_el0|PMEVCNTR13_EL0}}, x12 // encoding: [0xac,0xe9,0x1b,0xd5]
4146 // CHECK: msr {{pmevcntr14_el0|PMEVCNTR14_EL0}}, x12 // encoding: [0xcc,0xe9,0x1b,0xd5]
4147 // CHECK: msr {{pmevcntr15_el0|PMEVCNTR15_EL0}}, x12 // encoding: [0xec,0xe9,0x1b,0xd5]
4148 // CHECK: msr {{pmevcntr16_el0|PMEVCNTR16_EL0}}, x12 // encoding: [0x0c,0xea,0x1b,0xd5]
4149 // CHECK: msr {{pmevcntr17_el0|PMEVCNTR17_EL0}}, x12 // encoding: [0x2c,0xea,0x1b,0xd5]
4150 // CHECK: msr {{pmevcntr18_el0|PMEVCNTR18_EL0}}, x12 // encoding: [0x4c,0xea,0x1b,0xd5]
4151 // CHECK: msr {{pmevcntr19_el0|PMEVCNTR19_EL0}}, x12 // encoding: [0x6c,0xea,0x1b,0xd5]
4152 // CHECK: msr {{pmevcntr20_el0|PMEVCNTR20_EL0}}, x12 // encoding: [0x8c,0xea,0x1b,0xd5]
4153 // CHECK: msr {{pmevcntr21_el0|PMEVCNTR21_EL0}}, x12 // encoding: [0xac,0xea,0x1b,0xd5]
4154 // CHECK: msr {{pmevcntr22_el0|PMEVCNTR22_EL0}}, x12 // encoding: [0xcc,0xea,0x1b,0xd5]
4155 // CHECK: msr {{pmevcntr23_el0|PMEVCNTR23_EL0}}, x12 // encoding: [0xec,0xea,0x1b,0xd5]
4156 // CHECK: msr {{pmevcntr24_el0|PMEVCNTR24_EL0}}, x12 // encoding: [0x0c,0xeb,0x1b,0xd5]
4157 // CHECK: msr {{pmevcntr25_el0|PMEVCNTR25_EL0}}, x12 // encoding: [0x2c,0xeb,0x1b,0xd5]
4158 // CHECK: msr {{pmevcntr26_el0|PMEVCNTR26_EL0}}, x12 // encoding: [0x4c,0xeb,0x1b,0xd5]
4159 // CHECK: msr {{pmevcntr27_el0|PMEVCNTR27_EL0}}, x12 // encoding: [0x6c,0xeb,0x1b,0xd5]
4160 // CHECK: msr {{pmevcntr28_el0|PMEVCNTR28_EL0}}, x12 // encoding: [0x8c,0xeb,0x1b,0xd5]
4161 // CHECK: msr {{pmevcntr29_el0|PMEVCNTR29_EL0}}, x12 // encoding: [0xac,0xeb,0x1b,0xd5]
4162 // CHECK: msr {{pmevcntr30_el0|PMEVCNTR30_EL0}}, x12 // encoding: [0xcc,0xeb,0x1b,0xd5]
4163 // CHECK: msr {{pmccfiltr_el0|PMCCFILTR_EL0}}, x12 // encoding: [0xec,0xef,0x1b,0xd5]
4164 // CHECK: msr {{pmevtyper0_el0|PMEVTYPER0_EL0}}, x12 // encoding: [0x0c,0xec,0x1b,0xd5]
4165 // CHECK: msr {{pmevtyper1_el0|PMEVTYPER1_EL0}}, x12 // encoding: [0x2c,0xec,0x1b,0xd5]
4166 // CHECK: msr {{pmevtyper2_el0|PMEVTYPER2_EL0}}, x12 // encoding: [0x4c,0xec,0x1b,0xd5]
4167 // CHECK: msr {{pmevtyper3_el0|PMEVTYPER3_EL0}}, x12 // encoding: [0x6c,0xec,0x1b,0xd5]
4168 // CHECK: msr {{pmevtyper4_el0|PMEVTYPER4_EL0}}, x12 // encoding: [0x8c,0xec,0x1b,0xd5]
4169 // CHECK: msr {{pmevtyper5_el0|PMEVTYPER5_EL0}}, x12 // encoding: [0xac,0xec,0x1b,0xd5]
4170 // CHECK: msr {{pmevtyper6_el0|PMEVTYPER6_EL0}}, x12 // encoding: [0xcc,0xec,0x1b,0xd5]
4171 // CHECK: msr {{pmevtyper7_el0|PMEVTYPER7_EL0}}, x12 // encoding: [0xec,0xec,0x1b,0xd5]
4172 // CHECK: msr {{pmevtyper8_el0|PMEVTYPER8_EL0}}, x12 // encoding: [0x0c,0xed,0x1b,0xd5]
4173 // CHECK: msr {{pmevtyper9_el0|PMEVTYPER9_EL0}}, x12 // encoding: [0x2c,0xed,0x1b,0xd5]
4174 // CHECK: msr {{pmevtyper10_el0|PMEVTYPER10_EL0}}, x12 // encoding: [0x4c,0xed,0x1b,0xd5]
4175 // CHECK: msr {{pmevtyper11_el0|PMEVTYPER11_EL0}}, x12 // encoding: [0x6c,0xed,0x1b,0xd5]
4176 // CHECK: msr {{pmevtyper12_el0|PMEVTYPER12_EL0}}, x12 // encoding: [0x8c,0xed,0x1b,0xd5]
4177 // CHECK: msr {{pmevtyper13_el0|PMEVTYPER13_EL0}}, x12 // encoding: [0xac,0xed,0x1b,0xd5]
4178 // CHECK: msr {{pmevtyper14_el0|PMEVTYPER14_EL0}}, x12 // encoding: [0xcc,0xed,0x1b,0xd5]
4179 // CHECK: msr {{pmevtyper15_el0|PMEVTYPER15_EL0}}, x12 // encoding: [0xec,0xed,0x1b,0xd5]
4180 // CHECK: msr {{pmevtyper16_el0|PMEVTYPER16_EL0}}, x12 // encoding: [0x0c,0xee,0x1b,0xd5]
4181 // CHECK: msr {{pmevtyper17_el0|PMEVTYPER17_EL0}}, x12 // encoding: [0x2c,0xee,0x1b,0xd5]
4182 // CHECK: msr {{pmevtyper18_el0|PMEVTYPER18_EL0}}, x12 // encoding: [0x4c,0xee,0x1b,0xd5]
4183 // CHECK: msr {{pmevtyper19_el0|PMEVTYPER19_EL0}}, x12 // encoding: [0x6c,0xee,0x1b,0xd5]
4184 // CHECK: msr {{pmevtyper20_el0|PMEVTYPER20_EL0}}, x12 // encoding: [0x8c,0xee,0x1b,0xd5]
4185 // CHECK: msr {{pmevtyper21_el0|PMEVTYPER21_EL0}}, x12 // encoding: [0xac,0xee,0x1b,0xd5]
4186 // CHECK: msr {{pmevtyper22_el0|PMEVTYPER22_EL0}}, x12 // encoding: [0xcc,0xee,0x1b,0xd5]
4187 // CHECK: msr {{pmevtyper23_el0|PMEVTYPER23_EL0}}, x12 // encoding: [0xec,0xee,0x1b,0xd5]
4188 // CHECK: msr {{pmevtyper24_el0|PMEVTYPER24_EL0}}, x12 // encoding: [0x0c,0xef,0x1b,0xd5]
4189 // CHECK: msr {{pmevtyper25_el0|PMEVTYPER25_EL0}}, x12 // encoding: [0x2c,0xef,0x1b,0xd5]
4190 // CHECK: msr {{pmevtyper26_el0|PMEVTYPER26_EL0}}, x12 // encoding: [0x4c,0xef,0x1b,0xd5]
4191 // CHECK: msr {{pmevtyper27_el0|PMEVTYPER27_EL0}}, x12 // encoding: [0x6c,0xef,0x1b,0xd5]
4192 // CHECK: msr {{pmevtyper28_el0|PMEVTYPER28_EL0}}, x12 // encoding: [0x8c,0xef,0x1b,0xd5]
4193 // CHECK: msr {{pmevtyper29_el0|PMEVTYPER29_EL0}}, x12 // encoding: [0xac,0xef,0x1b,0xd5]
4194 // CHECK: msr {{pmevtyper30_el0|PMEVTYPER30_EL0}}, x12 // encoding: [0xcc,0xef,0x1b,0xd5]
4195
4196 mrs x9, TEECR32_EL1
4197 mrs x9, OSDTRRX_EL1
4198 mrs x9, MDCCSR_EL0
4199 mrs x9, MDCCINT_EL1
4200 mrs x9, MDSCR_EL1
4201 mrs x9, OSDTRTX_EL1
4202 mrs x9, DBGDTR_EL0
4203 mrs x9, DBGDTRRX_EL0
4204 mrs x9, OSECCR_EL1
4205 mrs x9, DBGVCR32_EL2
4206 mrs x9, DBGBVR0_EL1
4207 mrs x9, DBGBVR1_EL1
4208 mrs x9, DBGBVR2_EL1
4209 mrs x9, DBGBVR3_EL1
4210 mrs x9, DBGBVR4_EL1
4211 mrs x9, DBGBVR5_EL1
4212 mrs x9, DBGBVR6_EL1
4213 mrs x9, DBGBVR7_EL1
4214 mrs x9, DBGBVR8_EL1
4215 mrs x9, DBGBVR9_EL1
4216 mrs x9, DBGBVR10_EL1
4217 mrs x9, DBGBVR11_EL1
4218 mrs x9, DBGBVR12_EL1
4219 mrs x9, DBGBVR13_EL1
4220 mrs x9, DBGBVR14_EL1
4221 mrs x9, DBGBVR15_EL1
4222 mrs x9, DBGBCR0_EL1
4223 mrs x9, DBGBCR1_EL1
4224 mrs x9, DBGBCR2_EL1
4225 mrs x9, DBGBCR3_EL1
4226 mrs x9, DBGBCR4_EL1
4227 mrs x9, DBGBCR5_EL1
4228 mrs x9, DBGBCR6_EL1
4229 mrs x9, DBGBCR7_EL1
4230 mrs x9, DBGBCR8_EL1
4231 mrs x9, DBGBCR9_EL1
4232 mrs x9, DBGBCR10_EL1
4233 mrs x9, DBGBCR11_EL1
4234 mrs x9, DBGBCR12_EL1
4235 mrs x9, DBGBCR13_EL1
4236 mrs x9, DBGBCR14_EL1
4237 mrs x9, DBGBCR15_EL1
4238 mrs x9, DBGWVR0_EL1
4239 mrs x9, DBGWVR1_EL1
4240 mrs x9, DBGWVR2_EL1
4241 mrs x9, DBGWVR3_EL1
4242 mrs x9, DBGWVR4_EL1
4243 mrs x9, DBGWVR5_EL1
4244 mrs x9, DBGWVR6_EL1
4245 mrs x9, DBGWVR7_EL1
4246 mrs x9, DBGWVR8_EL1
4247 mrs x9, DBGWVR9_EL1
4248 mrs x9, DBGWVR10_EL1
4249 mrs x9, DBGWVR11_EL1
4250 mrs x9, DBGWVR12_EL1
4251 mrs x9, DBGWVR13_EL1
4252 mrs x9, DBGWVR14_EL1
4253 mrs x9, DBGWVR15_EL1
4254 mrs x9, DBGWCR0_EL1
4255 mrs x9, DBGWCR1_EL1
4256 mrs x9, DBGWCR2_EL1
4257 mrs x9, DBGWCR3_EL1
4258 mrs x9, DBGWCR4_EL1
4259 mrs x9, DBGWCR5_EL1
4260 mrs x9, DBGWCR6_EL1
4261 mrs x9, DBGWCR7_EL1
4262 mrs x9, DBGWCR8_EL1
4263 mrs x9, DBGWCR9_EL1
4264 mrs x9, DBGWCR10_EL1
4265 mrs x9, DBGWCR11_EL1
4266 mrs x9, DBGWCR12_EL1
4267 mrs x9, DBGWCR13_EL1
4268 mrs x9, DBGWCR14_EL1
4269 mrs x9, DBGWCR15_EL1
4270 mrs x9, MDRAR_EL1
4271 mrs x9, TEEHBR32_EL1
4272 mrs x9, OSLSR_EL1
4273 mrs x9, OSDLR_EL1
4274 mrs x9, DBGPRCR_EL1
4275 mrs x9, DBGCLAIMSET_EL1
4276 mrs x9, DBGCLAIMCLR_EL1
4277 mrs x9, DBGAUTHSTATUS_EL1
4278 mrs x9, MIDR_EL1
4279 mrs x9, CCSIDR_EL1
4280 mrs x9, CSSELR_EL1
4281 mrs x9, VPIDR_EL2
4282 mrs x9, CLIDR_EL1
4283 mrs x9, CTR_EL0
4284 mrs x9, MPIDR_EL1
4285 mrs x9, VMPIDR_EL2
4286 mrs x9, REVIDR_EL1
4287 mrs x9, AIDR_EL1
4288 mrs x9, DCZID_EL0
4289 mrs x9, ID_PFR0_EL1
4290 mrs x9, ID_PFR1_EL1
4291 mrs x9, ID_DFR0_EL1
4292 mrs x9, ID_AFR0_EL1
4293 mrs x9, ID_MMFR0_EL1
4294 mrs x9, ID_MMFR1_EL1
4295 mrs x9, ID_MMFR2_EL1
4296 mrs x9, ID_MMFR3_EL1
4297 mrs x9, ID_MMFR4_EL1
4298 mrs x9, ID_MMFR5_EL1
4299 mrs x9, ID_ISAR0_EL1
4300 mrs x9, ID_ISAR1_EL1
4301 mrs x9, ID_ISAR2_EL1
4302 mrs x9, ID_ISAR3_EL1
4303 mrs x9, ID_ISAR4_EL1
4304 mrs x9, ID_ISAR5_EL1
4305 mrs x9, MVFR0_EL1
4306 mrs x9, MVFR1_EL1
4307 mrs x9, MVFR2_EL1
4308 mrs x9, ID_AA64PFR0_EL1
4309 mrs x9, ID_AA64PFR1_EL1
4310 mrs x9, ID_AA64DFR0_EL1
4311 mrs x9, ID_AA64DFR1_EL1
4312 mrs x9, ID_AA64AFR0_EL1
4313 mrs x9, ID_AA64AFR1_EL1
4314 mrs x9, ID_AA64ISAR0_EL1
4315 mrs x9, ID_AA64ISAR1_EL1
4316 mrs x9, ID_AA64MMFR0_EL1
4317 mrs x9, ID_AA64MMFR1_EL1
4318 mrs x9, SCTLR_EL1
4319 mrs x9, SCTLR_EL2
4320 mrs x9, SCTLR_EL3
4321 mrs x9, ACTLR_EL1
4322 mrs x9, ACTLR_EL2
4323 mrs x9, ACTLR_EL3
4324 mrs x9, CPACR_EL1
4325 mrs x9, HCR_EL2
4326 mrs x9, SCR_EL3
4327 mrs x9, MDCR_EL2
4328 mrs x9, SDER32_EL3
4329 mrs x9, CPTR_EL2
4330 mrs x9, CPTR_EL3
4331 mrs x9, HSTR_EL2
4332 mrs x9, HACR_EL2
4333 mrs x9, MDCR_EL3
4334 mrs x9, TTBR0_EL1
4335 mrs x9, TTBR0_EL2
4336 mrs x9, TTBR0_EL3
4337 mrs x9, TTBR1_EL1
4338 mrs x9, TCR_EL1
4339 mrs x9, TCR_EL2
4340 mrs x9, TCR_EL3
4341 mrs x9, VTTBR_EL2
4342 mrs x9, VTCR_EL2
4343 mrs x9, DACR32_EL2
4344 mrs x9, SPSR_EL1
4345 mrs x9, SPSR_EL2
4346 mrs x9, SPSR_EL3
4347 mrs x9, ELR_EL1
4348 mrs x9, ELR_EL2
4349 mrs x9, ELR_EL3
4350 mrs x9, SP_EL0
4351 mrs x9, SP_EL1
4352 mrs x9, SP_EL2
4353 mrs x9, SPSel
4354 mrs x9, NZCV
4355 mrs x9, DAIF
4356 mrs x9, CurrentEL
4357 mrs x9, SPSR_irq
4358 mrs x9, SPSR_abt
4359 mrs x9, SPSR_und
4360 mrs x9, SPSR_fiq
4361 mrs x9, FPCR
4362 mrs x9, FPSR
4363 mrs x9, DSPSR_EL0
4364 mrs x9, DLR_EL0
4365 mrs x9, IFSR32_EL2
4366 mrs x9, AFSR0_EL1
4367 mrs x9, AFSR0_EL2
4368 mrs x9, AFSR0_EL3
4369 mrs x9, AFSR1_EL1
4370 mrs x9, AFSR1_EL2
4371 mrs x9, AFSR1_EL3
4372 mrs x9, ESR_EL1
4373 mrs x9, ESR_EL2
4374 mrs x9, ESR_EL3
4375 mrs x9, FPEXC32_EL2
4376 mrs x9, FAR_EL1
4377 mrs x9, FAR_EL2
4378 mrs x9, FAR_EL3
4379 mrs x9, HPFAR_EL2
4380 mrs x9, PAR_EL1
4381 mrs x9, PMCR_EL0
4382 mrs x9, PMCNTENSET_EL0
4383 mrs x9, PMCNTENCLR_EL0
4384 mrs x9, PMOVSCLR_EL0
4385 mrs x9, PMSELR_EL0
4386 mrs x9, PMCEID0_EL0
4387 mrs x9, PMCEID1_EL0
4388 mrs x9, PMCCNTR_EL0
4389 mrs x9, PMXEVTYPER_EL0
4390 mrs x9, PMXEVCNTR_EL0
4391 mrs x9, PMUSERENR_EL0
4392 mrs x9, PMINTENSET_EL1
4393 mrs x9, PMINTENCLR_EL1
4394 mrs x9, PMOVSSET_EL0
4395 mrs x9, MAIR_EL1
4396 mrs x9, MAIR_EL2
4397 mrs x9, MAIR_EL3
4398 mrs x9, AMAIR_EL1
4399 mrs x9, AMAIR_EL2
4400 mrs x9, AMAIR_EL3
4401 mrs x9, VBAR_EL1
4402 mrs x9, VBAR_EL2
4403 mrs x9, VBAR_EL3
4404 mrs x9, RVBAR_EL1
4405 mrs x9, RVBAR_EL2
4406 mrs x9, RVBAR_EL3
4407 mrs x9, RMR_EL1
4408 mrs x9, RMR_EL2
4409 mrs x9, RMR_EL3
4410 mrs x9, ISR_EL1
4411 mrs x9, CONTEXTIDR_EL1
4412 mrs x9, TPIDR_EL0
4413 mrs x9, TPIDR_EL2
4414 mrs x9, TPIDR_EL3
4415 mrs x9, TPIDRRO_EL0
4416 mrs x9, TPIDR_EL1
4417 mrs x9, CNTFRQ_EL0
4418 mrs x9, CNTPCT_EL0
4419 mrs x9, CNTVCT_EL0
4420 mrs x9, CNTVOFF_EL2
4421 mrs x9, CNTKCTL_EL1
4422 mrs x9, CNTHCTL_EL2
4423 mrs x9, CNTP_TVAL_EL0
4424 mrs x9, CNTHP_TVAL_EL2
4425 mrs x9, CNTPS_TVAL_EL1
4426 mrs x9, CNTP_CTL_EL0
4427 mrs x9, CNTHP_CTL_EL2
4428 mrs x9, CNTPS_CTL_EL1
4429 mrs x9, CNTP_CVAL_EL0
4430 mrs x9, CNTHP_CVAL_EL2
4431 mrs x9, CNTPS_CVAL_EL1
4432 mrs x9, CNTV_TVAL_EL0
4433 mrs x9, CNTV_CTL_EL0
4434 mrs x9, CNTV_CVAL_EL0
4435 mrs x9, PMEVCNTR0_EL0
4436 mrs x9, PMEVCNTR1_EL0
4437 mrs x9, PMEVCNTR2_EL0
4438 mrs x9, PMEVCNTR3_EL0
4439 mrs x9, PMEVCNTR4_EL0
4440 mrs x9, PMEVCNTR5_EL0
4441 mrs x9, PMEVCNTR6_EL0
4442 mrs x9, PMEVCNTR7_EL0
4443 mrs x9, PMEVCNTR8_EL0
4444 mrs x9, PMEVCNTR9_EL0
4445 mrs x9, PMEVCNTR10_EL0
4446 mrs x9, PMEVCNTR11_EL0
4447 mrs x9, PMEVCNTR12_EL0
4448 mrs x9, PMEVCNTR13_EL0
4449 mrs x9, PMEVCNTR14_EL0
4450 mrs x9, PMEVCNTR15_EL0
4451 mrs x9, PMEVCNTR16_EL0
4452 mrs x9, PMEVCNTR17_EL0
4453 mrs x9, PMEVCNTR18_EL0
4454 mrs x9, PMEVCNTR19_EL0
4455 mrs x9, PMEVCNTR20_EL0
4456 mrs x9, PMEVCNTR21_EL0
4457 mrs x9, PMEVCNTR22_EL0
4458 mrs x9, PMEVCNTR23_EL0
4459 mrs x9, PMEVCNTR24_EL0
4460 mrs x9, PMEVCNTR25_EL0
4461 mrs x9, PMEVCNTR26_EL0
4462 mrs x9, PMEVCNTR27_EL0
4463 mrs x9, PMEVCNTR28_EL0
4464 mrs x9, PMEVCNTR29_EL0
4465 mrs x9, PMEVCNTR30_EL0
4466 mrs x9, PMCCFILTR_EL0
4467 mrs x9, PMEVTYPER0_EL0
4468 mrs x9, PMEVTYPER1_EL0
4469 mrs x9, PMEVTYPER2_EL0
4470 mrs x9, PMEVTYPER3_EL0
4471 mrs x9, PMEVTYPER4_EL0
4472 mrs x9, PMEVTYPER5_EL0
4473 mrs x9, PMEVTYPER6_EL0
4474 mrs x9, PMEVTYPER7_EL0
4475 mrs x9, PMEVTYPER8_EL0
4476 mrs x9, PMEVTYPER9_EL0
4477 mrs x9, PMEVTYPER10_EL0
4478 mrs x9, PMEVTYPER11_EL0
4479 mrs x9, PMEVTYPER12_EL0
4480 mrs x9, PMEVTYPER13_EL0
4481 mrs x9, PMEVTYPER14_EL0
4482 mrs x9, PMEVTYPER15_EL0
4483 mrs x9, PMEVTYPER16_EL0
4484 mrs x9, PMEVTYPER17_EL0
4485 mrs x9, PMEVTYPER18_EL0
4486 mrs x9, PMEVTYPER19_EL0
4487 mrs x9, PMEVTYPER20_EL0
4488 mrs x9, PMEVTYPER21_EL0
4489 mrs x9, PMEVTYPER22_EL0
4490 mrs x9, PMEVTYPER23_EL0
4491 mrs x9, PMEVTYPER24_EL0
4492 mrs x9, PMEVTYPER25_EL0
4493 mrs x9, PMEVTYPER26_EL0
4494 mrs x9, PMEVTYPER27_EL0
4495 mrs x9, PMEVTYPER28_EL0
4496 mrs x9, PMEVTYPER29_EL0
4497 mrs x9, PMEVTYPER30_EL0
4498 // CHECK: mrs x9, {{teecr32_el1|TEECR32_EL1}} // encoding: [0x09,0x00,0x32,0xd5]
4499 // CHECK: mrs x9, {{osdtrrx_el1|OSDTRRX_EL1}} // encoding: [0x49,0x00,0x30,0xd5]
4500 // CHECK: mrs x9, {{mdccsr_el0|MDCCSR_EL0}} // encoding: [0x09,0x01,0x33,0xd5]
4501 // CHECK: mrs x9, {{mdccint_el1|MDCCINT_EL1}} // encoding: [0x09,0x02,0x30,0xd5]
4502 // CHECK: mrs x9, {{mdscr_el1|MDSCR_EL1}} // encoding: [0x49,0x02,0x30,0xd5]
4503 // CHECK: mrs x9, {{osdtrtx_el1|OSDTRTX_EL1}} // encoding: [0x49,0x03,0x30,0xd5]
4504 // CHECK: mrs x9, {{dbgdtr_el0|DBGDTR_EL0}} // encoding: [0x09,0x04,0x33,0xd5]
4505 // CHECK: mrs x9, {{dbgdtrrx_el0|DBGDTRRX_EL0}} // encoding: [0x09,0x05,0x33,0xd5]
4506 // CHECK: mrs x9, {{oseccr_el1|OSECCR_EL1}} // encoding: [0x49,0x06,0x30,0xd5]
4507 // CHECK: mrs x9, {{dbgvcr32_el2|DBGVCR32_EL2}} // encoding: [0x09,0x07,0x34,0xd5]
4508 // CHECK: mrs x9, {{dbgbvr0_el1|DBGBVR0_EL1}} // encoding: [0x89,0x00,0x30,0xd5]
4509 // CHECK: mrs x9, {{dbgbvr1_el1|DBGBVR1_EL1}} // encoding: [0x89,0x01,0x30,0xd5]
4510 // CHECK: mrs x9, {{dbgbvr2_el1|DBGBVR2_EL1}} // encoding: [0x89,0x02,0x30,0xd5]
4511 // CHECK: mrs x9, {{dbgbvr3_el1|DBGBVR3_EL1}} // encoding: [0x89,0x03,0x30,0xd5]
4512 // CHECK: mrs x9, {{dbgbvr4_el1|DBGBVR4_EL1}} // encoding: [0x89,0x04,0x30,0xd5]
4513 // CHECK: mrs x9, {{dbgbvr5_el1|DBGBVR5_EL1}} // encoding: [0x89,0x05,0x30,0xd5]
4514 // CHECK: mrs x9, {{dbgbvr6_el1|DBGBVR6_EL1}} // encoding: [0x89,0x06,0x30,0xd5]
4515 // CHECK: mrs x9, {{dbgbvr7_el1|DBGBVR7_EL1}} // encoding: [0x89,0x07,0x30,0xd5]
4516 // CHECK: mrs x9, {{dbgbvr8_el1|DBGBVR8_EL1}} // encoding: [0x89,0x08,0x30,0xd5]
4517 // CHECK: mrs x9, {{dbgbvr9_el1|DBGBVR9_EL1}} // encoding: [0x89,0x09,0x30,0xd5]
4518 // CHECK: mrs x9, {{dbgbvr10_el1|DBGBVR10_EL1}} // encoding: [0x89,0x0a,0x30,0xd5]
4519 // CHECK: mrs x9, {{dbgbvr11_el1|DBGBVR11_EL1}} // encoding: [0x89,0x0b,0x30,0xd5]
4520 // CHECK: mrs x9, {{dbgbvr12_el1|DBGBVR12_EL1}} // encoding: [0x89,0x0c,0x30,0xd5]
4521 // CHECK: mrs x9, {{dbgbvr13_el1|DBGBVR13_EL1}} // encoding: [0x89,0x0d,0x30,0xd5]
4522 // CHECK: mrs x9, {{dbgbvr14_el1|DBGBVR14_EL1}} // encoding: [0x89,0x0e,0x30,0xd5]
4523 // CHECK: mrs x9, {{dbgbvr15_el1|DBGBVR15_EL1}} // encoding: [0x89,0x0f,0x30,0xd5]
4524 // CHECK: mrs x9, {{dbgbcr0_el1|DBGBCR0_EL1}} // encoding: [0xa9,0x00,0x30,0xd5]
4525 // CHECK: mrs x9, {{dbgbcr1_el1|DBGBCR1_EL1}} // encoding: [0xa9,0x01,0x30,0xd5]
4526 // CHECK: mrs x9, {{dbgbcr2_el1|DBGBCR2_EL1}} // encoding: [0xa9,0x02,0x30,0xd5]
4527 // CHECK: mrs x9, {{dbgbcr3_el1|DBGBCR3_EL1}} // encoding: [0xa9,0x03,0x30,0xd5]
4528 // CHECK: mrs x9, {{dbgbcr4_el1|DBGBCR4_EL1}} // encoding: [0xa9,0x04,0x30,0xd5]
4529 // CHECK: mrs x9, {{dbgbcr5_el1|DBGBCR5_EL1}} // encoding: [0xa9,0x05,0x30,0xd5]
4530 // CHECK: mrs x9, {{dbgbcr6_el1|DBGBCR6_EL1}} // encoding: [0xa9,0x06,0x30,0xd5]
4531 // CHECK: mrs x9, {{dbgbcr7_el1|DBGBCR7_EL1}} // encoding: [0xa9,0x07,0x30,0xd5]
4532 // CHECK: mrs x9, {{dbgbcr8_el1|DBGBCR8_EL1}} // encoding: [0xa9,0x08,0x30,0xd5]
4533 // CHECK: mrs x9, {{dbgbcr9_el1|DBGBCR9_EL1}} // encoding: [0xa9,0x09,0x30,0xd5]
4534 // CHECK: mrs x9, {{dbgbcr10_el1|DBGBCR10_EL1}} // encoding: [0xa9,0x0a,0x30,0xd5]
4535 // CHECK: mrs x9, {{dbgbcr11_el1|DBGBCR11_EL1}} // encoding: [0xa9,0x0b,0x30,0xd5]
4536 // CHECK: mrs x9, {{dbgbcr12_el1|DBGBCR12_EL1}} // encoding: [0xa9,0x0c,0x30,0xd5]
4537 // CHECK: mrs x9, {{dbgbcr13_el1|DBGBCR13_EL1}} // encoding: [0xa9,0x0d,0x30,0xd5]
4538 // CHECK: mrs x9, {{dbgbcr14_el1|DBGBCR14_EL1}} // encoding: [0xa9,0x0e,0x30,0xd5]
4539 // CHECK: mrs x9, {{dbgbcr15_el1|DBGBCR15_EL1}} // encoding: [0xa9,0x0f,0x30,0xd5]
4540 // CHECK: mrs x9, {{dbgwvr0_el1|DBGWVR0_EL1}} // encoding: [0xc9,0x00,0x30,0xd5]
4541 // CHECK: mrs x9, {{dbgwvr1_el1|DBGWVR1_EL1}} // encoding: [0xc9,0x01,0x30,0xd5]
4542 // CHECK: mrs x9, {{dbgwvr2_el1|DBGWVR2_EL1}} // encoding: [0xc9,0x02,0x30,0xd5]
4543 // CHECK: mrs x9, {{dbgwvr3_el1|DBGWVR3_EL1}} // encoding: [0xc9,0x03,0x30,0xd5]
4544 // CHECK: mrs x9, {{dbgwvr4_el1|DBGWVR4_EL1}} // encoding: [0xc9,0x04,0x30,0xd5]
4545 // CHECK: mrs x9, {{dbgwvr5_el1|DBGWVR5_EL1}} // encoding: [0xc9,0x05,0x30,0xd5]
4546 // CHECK: mrs x9, {{dbgwvr6_el1|DBGWVR6_EL1}} // encoding: [0xc9,0x06,0x30,0xd5]
4547 // CHECK: mrs x9, {{dbgwvr7_el1|DBGWVR7_EL1}} // encoding: [0xc9,0x07,0x30,0xd5]
4548 // CHECK: mrs x9, {{dbgwvr8_el1|DBGWVR8_EL1}} // encoding: [0xc9,0x08,0x30,0xd5]
4549 // CHECK: mrs x9, {{dbgwvr9_el1|DBGWVR9_EL1}} // encoding: [0xc9,0x09,0x30,0xd5]
4550 // CHECK: mrs x9, {{dbgwvr10_el1|DBGWVR10_EL1}} // encoding: [0xc9,0x0a,0x30,0xd5]
4551 // CHECK: mrs x9, {{dbgwvr11_el1|DBGWVR11_EL1}} // encoding: [0xc9,0x0b,0x30,0xd5]
4552 // CHECK: mrs x9, {{dbgwvr12_el1|DBGWVR12_EL1}} // encoding: [0xc9,0x0c,0x30,0xd5]
4553 // CHECK: mrs x9, {{dbgwvr13_el1|DBGWVR13_EL1}} // encoding: [0xc9,0x0d,0x30,0xd5]
4554 // CHECK: mrs x9, {{dbgwvr14_el1|DBGWVR14_EL1}} // encoding: [0xc9,0x0e,0x30,0xd5]
4555 // CHECK: mrs x9, {{dbgwvr15_el1|DBGWVR15_EL1}} // encoding: [0xc9,0x0f,0x30,0xd5]
4556 // CHECK: mrs x9, {{dbgwcr0_el1|DBGWCR0_EL1}} // encoding: [0xe9,0x00,0x30,0xd5]
4557 // CHECK: mrs x9, {{dbgwcr1_el1|DBGWCR1_EL1}} // encoding: [0xe9,0x01,0x30,0xd5]
4558 // CHECK: mrs x9, {{dbgwcr2_el1|DBGWCR2_EL1}} // encoding: [0xe9,0x02,0x30,0xd5]
4559 // CHECK: mrs x9, {{dbgwcr3_el1|DBGWCR3_EL1}} // encoding: [0xe9,0x03,0x30,0xd5]
4560 // CHECK: mrs x9, {{dbgwcr4_el1|DBGWCR4_EL1}} // encoding: [0xe9,0x04,0x30,0xd5]
4561 // CHECK: mrs x9, {{dbgwcr5_el1|DBGWCR5_EL1}} // encoding: [0xe9,0x05,0x30,0xd5]
4562 // CHECK: mrs x9, {{dbgwcr6_el1|DBGWCR6_EL1}} // encoding: [0xe9,0x06,0x30,0xd5]
4563 // CHECK: mrs x9, {{dbgwcr7_el1|DBGWCR7_EL1}} // encoding: [0xe9,0x07,0x30,0xd5]
4564 // CHECK: mrs x9, {{dbgwcr8_el1|DBGWCR8_EL1}} // encoding: [0xe9,0x08,0x30,0xd5]
4565 // CHECK: mrs x9, {{dbgwcr9_el1|DBGWCR9_EL1}} // encoding: [0xe9,0x09,0x30,0xd5]
4566 // CHECK: mrs x9, {{dbgwcr10_el1|DBGWCR10_EL1}} // encoding: [0xe9,0x0a,0x30,0xd5]
4567 // CHECK: mrs x9, {{dbgwcr11_el1|DBGWCR11_EL1}} // encoding: [0xe9,0x0b,0x30,0xd5]
4568 // CHECK: mrs x9, {{dbgwcr12_el1|DBGWCR12_EL1}} // encoding: [0xe9,0x0c,0x30,0xd5]
4569 // CHECK: mrs x9, {{dbgwcr13_el1|DBGWCR13_EL1}} // encoding: [0xe9,0x0d,0x30,0xd5]
4570 // CHECK: mrs x9, {{dbgwcr14_el1|DBGWCR14_EL1}} // encoding: [0xe9,0x0e,0x30,0xd5]
4571 // CHECK: mrs x9, {{dbgwcr15_el1|DBGWCR15_EL1}} // encoding: [0xe9,0x0f,0x30,0xd5]
4572 // CHECK: mrs x9, {{mdrar_el1|MDRAR_EL1}} // encoding: [0x09,0x10,0x30,0xd5]
4573 // CHECK: mrs x9, {{teehbr32_el1|TEEHBR32_EL1}} // encoding: [0x09,0x10,0x32,0xd5]
4574 // CHECK: mrs x9, {{oslsr_el1|OSLSR_EL1}} // encoding: [0x89,0x11,0x30,0xd5]
4575 // CHECK: mrs x9, {{osdlr_el1|OSDLR_EL1}} // encoding: [0x89,0x13,0x30,0xd5]
4576 // CHECK: mrs x9, {{dbgprcr_el1|DBGPRCR_EL1}} // encoding: [0x89,0x14,0x30,0xd5]
4577 // CHECK: mrs x9, {{dbgclaimset_el1|DBGCLAIMSET_EL1}} // encoding: [0xc9,0x78,0x30,0xd5]
4578 // CHECK: mrs x9, {{dbgclaimclr_el1|DBGCLAIMCLR_EL1}} // encoding: [0xc9,0x79,0x30,0xd5]
4579 // CHECK: mrs x9, {{dbgauthstatus_el1|DBGAUTHSTATUS_EL1}} // encoding: [0xc9,0x7e,0x30,0xd5]
4580 // CHECK: mrs x9, {{midr_el1|MIDR_EL1}} // encoding: [0x09,0x00,0x38,0xd5]
4581 // CHECK: mrs x9, {{ccsidr_el1|CCSIDR_EL1}} // encoding: [0x09,0x00,0x39,0xd5]
4582 // CHECK: mrs x9, {{csselr_el1|CSSELR_EL1}} // encoding: [0x09,0x00,0x3a,0xd5]
4583 // CHECK: mrs x9, {{vpidr_el2|VPIDR_EL2}} // encoding: [0x09,0x00,0x3c,0xd5]
4584 // CHECK: mrs x9, {{clidr_el1|CLIDR_EL1}} // encoding: [0x29,0x00,0x39,0xd5]
4585 // CHECK: mrs x9, {{ctr_el0|CTR_EL0}} // encoding: [0x29,0x00,0x3b,0xd5]
4586 // CHECK: mrs x9, {{mpidr_el1|MPIDR_EL1}} // encoding: [0xa9,0x00,0x38,0xd5]
4587 // CHECK: mrs x9, {{vmpidr_el2|VMPIDR_EL2}} // encoding: [0xa9,0x00,0x3c,0xd5]
4588 // CHECK: mrs x9, {{revidr_el1|REVIDR_EL1}} // encoding: [0xc9,0x00,0x38,0xd5]
4589 // CHECK: mrs x9, {{aidr_el1|AIDR_EL1}} // encoding: [0xe9,0x00,0x39,0xd5]
4590 // CHECK: mrs x9, {{dczid_el0|DCZID_EL0}} // encoding: [0xe9,0x00,0x3b,0xd5]
4591 // CHECK: mrs x9, {{id_pfr0_el1|ID_PFR0_EL1}} // encoding: [0x09,0x01,0x38,0xd5]
4592 // CHECK: mrs x9, {{id_pfr1_el1|ID_PFR1_EL1}} // encoding: [0x29,0x01,0x38,0xd5]
4593 // CHECK: mrs x9, {{id_dfr0_el1|ID_DFR0_EL1}} // encoding: [0x49,0x01,0x38,0xd5]
4594 // CHECK: mrs x9, {{id_afr0_el1|ID_AFR0_EL1}} // encoding: [0x69,0x01,0x38,0xd5]
4595 // CHECK: mrs x9, {{id_mmfr0_el1|ID_MMFR0_EL1}} // encoding: [0x89,0x01,0x38,0xd5]
4596 // CHECK: mrs x9, {{id_mmfr1_el1|ID_MMFR1_EL1}} // encoding: [0xa9,0x01,0x38,0xd5]
4597 // CHECK: mrs x9, {{id_mmfr2_el1|ID_MMFR2_EL1}} // encoding: [0xc9,0x01,0x38,0xd5]
4598 // CHECK: mrs x9, {{id_mmfr3_el1|ID_MMFR3_EL1}} // encoding: [0xe9,0x01,0x38,0xd5]
4599 // CHECK: mrs x9, {{id_mmfr4_el1|ID_MMFR4_EL1}} // encoding: [0xc9,0x02,0x38,0xd5]
4600 // CHECK: mrs x9, {{id_mmfr5_el1|ID_MMFR5_EL1}} // encoding: [0xc9,0x03,0x38,0xd5]
4601 // CHECK: mrs x9, {{id_isar0_el1|ID_ISAR0_EL1}} // encoding: [0x09,0x02,0x38,0xd5]
4602 // CHECK: mrs x9, {{id_isar1_el1|ID_ISAR1_EL1}} // encoding: [0x29,0x02,0x38,0xd5]
4603 // CHECK: mrs x9, {{id_isar2_el1|ID_ISAR2_EL1}} // encoding: [0x49,0x02,0x38,0xd5]
4604 // CHECK: mrs x9, {{id_isar3_el1|ID_ISAR3_EL1}} // encoding: [0x69,0x02,0x38,0xd5]
4605 // CHECK: mrs x9, {{id_isar4_el1|ID_ISAR4_EL1}} // encoding: [0x89,0x02,0x38,0xd5]
4606 // CHECK: mrs x9, {{id_isar5_el1|ID_ISAR5_EL1}} // encoding: [0xa9,0x02,0x38,0xd5]
4607 // CHECK: mrs x9, {{mvfr0_el1|MVFR0_EL1}} // encoding: [0x09,0x03,0x38,0xd5]
4608 // CHECK: mrs x9, {{mvfr1_el1|MVFR1_EL1}} // encoding: [0x29,0x03,0x38,0xd5]
4609 // CHECK: mrs x9, {{mvfr2_el1|MVFR2_EL1}} // encoding: [0x49,0x03,0x38,0xd5]
4610 // CHECK: mrs x9, {{id_aa64pfr0_el1|ID_AA64PFR0_EL1}} // encoding: [0x09,0x04,0x38,0xd5]
4611 // CHECK: mrs x9, {{id_aa64pfr1_el1|ID_AA64PFR1_EL1}} // encoding: [0x29,0x04,0x38,0xd5]
4612 // CHECK: mrs x9, {{id_aa64dfr0_el1|ID_AA64DFR0_EL1}} // encoding: [0x09,0x05,0x38,0xd5]
4613 // CHECK: mrs x9, {{id_aa64dfr1_el1|ID_AA64DFR1_EL1}} // encoding: [0x29,0x05,0x38,0xd5]
4614 // CHECK: mrs x9, {{id_aa64afr0_el1|ID_AA64AFR0_EL1}} // encoding: [0x89,0x05,0x38,0xd5]
4615 // CHECK: mrs x9, {{id_aa64afr1_el1|ID_AA64AFR1_EL1}} // encoding: [0xa9,0x05,0x38,0xd5]
4616 // CHECK: mrs x9, {{id_aa64isar0_el1|ID_AA64ISAR0_EL1}} // encoding: [0x09,0x06,0x38,0xd5]
4617 // CHECK: mrs x9, {{id_aa64isar1_el1|ID_AA64ISAR1_EL1}} // encoding: [0x29,0x06,0x38,0xd5]
4618 // CHECK: mrs x9, {{id_aa64mmfr0_el1|ID_AA64MMFR0_EL1}} // encoding: [0x09,0x07,0x38,0xd5]
4619 // CHECK: mrs x9, {{id_aa64mmfr1_el1|ID_AA64MMFR1_EL1}} // encoding: [0x29,0x07,0x38,0xd5]
4620 // CHECK: mrs x9, {{sctlr_el1|SCTLR_EL1}} // encoding: [0x09,0x10,0x38,0xd5]
4621 // CHECK: mrs x9, {{sctlr_el2|SCTLR_EL2}} // encoding: [0x09,0x10,0x3c,0xd5]
4622 // CHECK: mrs x9, {{sctlr_el3|SCTLR_EL3}} // encoding: [0x09,0x10,0x3e,0xd5]
4623 // CHECK: mrs x9, {{actlr_el1|ACTLR_EL1}} // encoding: [0x29,0x10,0x38,0xd5]
4624 // CHECK: mrs x9, {{actlr_el2|ACTLR_EL2}} // encoding: [0x29,0x10,0x3c,0xd5]
4625 // CHECK: mrs x9, {{actlr_el3|ACTLR_EL3}} // encoding: [0x29,0x10,0x3e,0xd5]
4626 // CHECK: mrs x9, {{cpacr_el1|CPACR_EL1}} // encoding: [0x49,0x10,0x38,0xd5]
4627 // CHECK: mrs x9, {{hcr_el2|HCR_EL2}} // encoding: [0x09,0x11,0x3c,0xd5]
4628 // CHECK: mrs x9, {{scr_el3|SCR_EL3}} // encoding: [0x09,0x11,0x3e,0xd5]
4629 // CHECK: mrs x9, {{mdcr_el2|MDCR_EL2}} // encoding: [0x29,0x11,0x3c,0xd5]
4630 // CHECK: mrs x9, {{sder32_el3|SDER32_EL3}} // encoding: [0x29,0x11,0x3e,0xd5]
4631 // CHECK: mrs x9, {{cptr_el2|CPTR_EL2}} // encoding: [0x49,0x11,0x3c,0xd5]
4632 // CHECK: mrs x9, {{cptr_el3|CPTR_EL3}} // encoding: [0x49,0x11,0x3e,0xd5]
4633 // CHECK: mrs x9, {{hstr_el2|HSTR_EL2}} // encoding: [0x69,0x11,0x3c,0xd5]
4634 // CHECK: mrs x9, {{hacr_el2|HACR_EL2}} // encoding: [0xe9,0x11,0x3c,0xd5]
4635 // CHECK: mrs x9, {{mdcr_el3|MDCR_EL3}} // encoding: [0x29,0x13,0x3e,0xd5]
4636 // CHECK: mrs x9, {{ttbr0_el1|TTBR0_EL1}} // encoding: [0x09,0x20,0x38,0xd5]
4637 // CHECK: mrs x9, {{ttbr0_el2|TTBR0_EL2}} // encoding: [0x09,0x20,0x3c,0xd5]
4638 // CHECK: mrs x9, {{ttbr0_el3|TTBR0_EL3}} // encoding: [0x09,0x20,0x3e,0xd5]
4639 // CHECK: mrs x9, {{ttbr1_el1|TTBR1_EL1}} // encoding: [0x29,0x20,0x38,0xd5]
4640 // CHECK: mrs x9, {{tcr_el1|TCR_EL1}} // encoding: [0x49,0x20,0x38,0xd5]
4641 // CHECK: mrs x9, {{tcr_el2|TCR_EL2}} // encoding: [0x49,0x20,0x3c,0xd5]
4642 // CHECK: mrs x9, {{tcr_el3|TCR_EL3}} // encoding: [0x49,0x20,0x3e,0xd5]
4643 // CHECK: mrs x9, {{vttbr_el2|VTTBR_EL2}} // encoding: [0x09,0x21,0x3c,0xd5]
4644 // CHECK: mrs x9, {{vtcr_el2|VTCR_EL2}} // encoding: [0x49,0x21,0x3c,0xd5]
4645 // CHECK: mrs x9, {{dacr32_el2|DACR32_EL2}} // encoding: [0x09,0x30,0x3c,0xd5]
4646 // CHECK: mrs x9, {{spsr_el1|SPSR_EL1}} // encoding: [0x09,0x40,0x38,0xd5]
4647 // CHECK: mrs x9, {{spsr_el2|SPSR_EL2}} // encoding: [0x09,0x40,0x3c,0xd5]
4648 // CHECK: mrs x9, {{spsr_el3|SPSR_EL3}} // encoding: [0x09,0x40,0x3e,0xd5]
4649 // CHECK: mrs x9, {{elr_el1|ELR_EL1}} // encoding: [0x29,0x40,0x38,0xd5]
4650 // CHECK: mrs x9, {{elr_el2|ELR_EL2}} // encoding: [0x29,0x40,0x3c,0xd5]
4651 // CHECK: mrs x9, {{elr_el3|ELR_EL3}} // encoding: [0x29,0x40,0x3e,0xd5]
4652 // CHECK: mrs x9, {{sp_el0|SP_EL0}} // encoding: [0x09,0x41,0x38,0xd5]
4653 // CHECK: mrs x9, {{sp_el1|SP_EL1}} // encoding: [0x09,0x41,0x3c,0xd5]
4654 // CHECK: mrs x9, {{sp_el2|SP_EL2}} // encoding: [0x09,0x41,0x3e,0xd5]
4655 // CHECK: mrs x9, {{SPSel|SPSEL}} // encoding: [0x09,0x42,0x38,0xd5]
4656 // CHECK: mrs x9, {{nzcv|NZCV}} // encoding: [0x09,0x42,0x3b,0xd5]
4657 // CHECK: mrs x9, {{daif|DAIF}} // encoding: [0x29,0x42,0x3b,0xd5]
4658 // CHECK: mrs x9, {{CurrentEL|CURRENTEL}} // encoding: [0x49,0x42,0x38,0xd5]
4659 // CHECK: mrs x9, {{SPSR_irq|SPSR_IRQ}} // encoding: [0x09,0x43,0x3c,0xd5]
4660 // CHECK: mrs x9, {{SPSR_abt|SPSR_ABT}} // encoding: [0x29,0x43,0x3c,0xd5]
4661 // CHECK: mrs x9, {{SPSR_und|SPSR_UND}} // encoding: [0x49,0x43,0x3c,0xd5]
4662 // CHECK: mrs x9, {{SPSR_fiq|SPSR_FIQ}} // encoding: [0x69,0x43,0x3c,0xd5]
4663 // CHECK: mrs x9, {{fpcr|FPCR}} // encoding: [0x09,0x44,0x3b,0xd5]
4664 // CHECK: mrs x9, {{fpsr|FPSR}} // encoding: [0x29,0x44,0x3b,0xd5]
4665 // CHECK: mrs x9, {{dspsr_el0|DSPSR_EL0}} // encoding: [0x09,0x45,0x3b,0xd5]
4666 // CHECK: mrs x9, {{dlr_el0|DLR_EL0}} // encoding: [0x29,0x45,0x3b,0xd5]
4667 // CHECK: mrs x9, {{ifsr32_el2|IFSR32_EL2}} // encoding: [0x29,0x50,0x3c,0xd5]
4668 // CHECK: mrs x9, {{afsr0_el1|AFSR0_EL1}} // encoding: [0x09,0x51,0x38,0xd5]
4669 // CHECK: mrs x9, {{afsr0_el2|AFSR0_EL2}} // encoding: [0x09,0x51,0x3c,0xd5]
4670 // CHECK: mrs x9, {{afsr0_el3|AFSR0_EL3}} // encoding: [0x09,0x51,0x3e,0xd5]
4671 // CHECK: mrs x9, {{afsr1_el1|AFSR1_EL1}} // encoding: [0x29,0x51,0x38,0xd5]
4672 // CHECK: mrs x9, {{afsr1_el2|AFSR1_EL2}} // encoding: [0x29,0x51,0x3c,0xd5]
4673 // CHECK: mrs x9, {{afsr1_el3|AFSR1_EL3}} // encoding: [0x29,0x51,0x3e,0xd5]
4674 // CHECK: mrs x9, {{esr_el1|ESR_EL1}} // encoding: [0x09,0x52,0x38,0xd5]
4675 // CHECK: mrs x9, {{esr_el2|ESR_EL2}} // encoding: [0x09,0x52,0x3c,0xd5]
4676 // CHECK: mrs x9, {{esr_el3|ESR_EL3}} // encoding: [0x09,0x52,0x3e,0xd5]
4677 // CHECK: mrs x9, {{fpexc32_el2|FPEXC32_EL2}} // encoding: [0x09,0x53,0x3c,0xd5]
4678 // CHECK: mrs x9, {{far_el1|FAR_EL1}} // encoding: [0x09,0x60,0x38,0xd5]
4679 // CHECK: mrs x9, {{far_el2|FAR_EL2}} // encoding: [0x09,0x60,0x3c,0xd5]
4680 // CHECK: mrs x9, {{far_el3|FAR_EL3}} // encoding: [0x09,0x60,0x3e,0xd5]
4681 // CHECK: mrs x9, {{hpfar_el2|HPFAR_EL2}} // encoding: [0x89,0x60,0x3c,0xd5]
4682 // CHECK: mrs x9, {{par_el1|PAR_EL1}} // encoding: [0x09,0x74,0x38,0xd5]
4683 // CHECK: mrs x9, {{pmcr_el0|PMCR_EL0}} // encoding: [0x09,0x9c,0x3b,0xd5]
4684 // CHECK: mrs x9, {{pmcntenset_el0|PMCNTENSET_EL0}} // encoding: [0x29,0x9c,0x3b,0xd5]
4685 // CHECK: mrs x9, {{pmcntenclr_el0|PMCNTENCLR_EL0}} // encoding: [0x49,0x9c,0x3b,0xd5]
4686 // CHECK: mrs x9, {{pmovsclr_el0|PMOVSCLR_EL0}} // encoding: [0x69,0x9c,0x3b,0xd5]
4687 // CHECK: mrs x9, {{pmselr_el0|PMSELR_EL0}} // encoding: [0xa9,0x9c,0x3b,0xd5]
4688 // CHECK: mrs x9, {{pmceid0_el0|PMCEID0_EL0}} // encoding: [0xc9,0x9c,0x3b,0xd5]
4689 // CHECK: mrs x9, {{pmceid1_el0|PMCEID1_EL0}} // encoding: [0xe9,0x9c,0x3b,0xd5]
4690 // CHECK: mrs x9, {{pmccntr_el0|PMCCNTR_EL0}} // encoding: [0x09,0x9d,0x3b,0xd5]
4691 // CHECK: mrs x9, {{pmxevtyper_el0|PMXEVTYPER_EL0}} // encoding: [0x29,0x9d,0x3b,0xd5]
4692 // CHECK: mrs x9, {{pmxevcntr_el0|PMXEVCNTR_EL0}} // encoding: [0x49,0x9d,0x3b,0xd5]
4693 // CHECK: mrs x9, {{pmuserenr_el0|PMUSERENR_EL0}} // encoding: [0x09,0x9e,0x3b,0xd5]
4694 // CHECK: mrs x9, {{pmintenset_el1|PMINTENSET_EL1}} // encoding: [0x29,0x9e,0x38,0xd5]
4695 // CHECK: mrs x9, {{pmintenclr_el1|PMINTENCLR_EL1}} // encoding: [0x49,0x9e,0x38,0xd5]
4696 // CHECK: mrs x9, {{pmovsset_el0|PMOVSSET_EL0}} // encoding: [0x69,0x9e,0x3b,0xd5]
4697 // CHECK: mrs x9, {{mair_el1|MAIR_EL1}} // encoding: [0x09,0xa2,0x38,0xd5]
4698 // CHECK: mrs x9, {{mair_el2|MAIR_EL2}} // encoding: [0x09,0xa2,0x3c,0xd5]
4699 // CHECK: mrs x9, {{mair_el3|MAIR_EL3}} // encoding: [0x09,0xa2,0x3e,0xd5]
4700 // CHECK: mrs x9, {{amair_el1|AMAIR_EL1}} // encoding: [0x09,0xa3,0x38,0xd5]
4701 // CHECK: mrs x9, {{amair_el2|AMAIR_EL2}} // encoding: [0x09,0xa3,0x3c,0xd5]
4702 // CHECK: mrs x9, {{amair_el3|AMAIR_EL3}} // encoding: [0x09,0xa3,0x3e,0xd5]
4703 // CHECK: mrs x9, {{vbar_el1|VBAR_EL1}} // encoding: [0x09,0xc0,0x38,0xd5]
4704 // CHECK: mrs x9, {{vbar_el2|VBAR_EL2}} // encoding: [0x09,0xc0,0x3c,0xd5]
4705 // CHECK: mrs x9, {{vbar_el3|VBAR_EL3}} // encoding: [0x09,0xc0,0x3e,0xd5]
4706 // CHECK: mrs x9, {{rvbar_el1|RVBAR_EL1}} // encoding: [0x29,0xc0,0x38,0xd5]
4707 // CHECK: mrs x9, {{rvbar_el2|RVBAR_EL2}} // encoding: [0x29,0xc0,0x3c,0xd5]
4708 // CHECK: mrs x9, {{rvbar_el3|RVBAR_EL3}} // encoding: [0x29,0xc0,0x3e,0xd5]
4709 // CHECK: mrs x9, {{rmr_el1|RMR_EL1}} // encoding: [0x49,0xc0,0x38,0xd5]
4710 // CHECK: mrs x9, {{rmr_el2|RMR_EL2}} // encoding: [0x49,0xc0,0x3c,0xd5]
4711 // CHECK: mrs x9, {{rmr_el3|RMR_EL3}} // encoding: [0x49,0xc0,0x3e,0xd5]
4712 // CHECK: mrs x9, {{isr_el1|ISR_EL1}} // encoding: [0x09,0xc1,0x38,0xd5]
4713 // CHECK: mrs x9, {{contextidr_el1|CONTEXTIDR_EL1}} // encoding: [0x29,0xd0,0x38,0xd5]
4714 // CHECK: mrs x9, {{tpidr_el0|TPIDR_EL0}} // encoding: [0x49,0xd0,0x3b,0xd5]
4715 // CHECK: mrs x9, {{tpidr_el2|TPIDR_EL2}} // encoding: [0x49,0xd0,0x3c,0xd5]
4716 // CHECK: mrs x9, {{tpidr_el3|TPIDR_EL3}} // encoding: [0x49,0xd0,0x3e,0xd5]
4717 // CHECK: mrs x9, {{tpidrro_el0|TPIDRRO_EL0}} // encoding: [0x69,0xd0,0x3b,0xd5]
4718 // CHECK: mrs x9, {{tpidr_el1|TPIDR_EL1}} // encoding: [0x89,0xd0,0x38,0xd5]
4719 // CHECK: mrs x9, {{cntfrq_el0|CNTFRQ_EL0}} // encoding: [0x09,0xe0,0x3b,0xd5]
4720 // CHECK: mrs x9, {{cntpct_el0|CNTPCT_EL0}} // encoding: [0x29,0xe0,0x3b,0xd5]
4721 // CHECK: mrs x9, {{cntvct_el0|CNTVCT_EL0}} // encoding: [0x49,0xe0,0x3b,0xd5]
4722 // CHECK: mrs x9, {{cntvoff_el2|CNTVOFF_EL2}} // encoding: [0x69,0xe0,0x3c,0xd5]
4723 // CHECK: mrs x9, {{cntkctl_el1|CNTKCTL_EL1}} // encoding: [0x09,0xe1,0x38,0xd5]
4724 // CHECK: mrs x9, {{cnthctl_el2|CNTHCTL_EL2}} // encoding: [0x09,0xe1,0x3c,0xd5]
4725 // CHECK: mrs x9, {{cntp_tval_el0|CNTP_TVAL_EL0}} // encoding: [0x09,0xe2,0x3b,0xd5]
4726 // CHECK: mrs x9, {{cnthp_tval_el2|CNTHP_TVAL_EL2}} // encoding: [0x09,0xe2,0x3c,0xd5]
4727 // CHECK: mrs x9, {{cntps_tval_el1|CNTPS_TVAL_EL1}} // encoding: [0x09,0xe2,0x3f,0xd5]
4728 // CHECK: mrs x9, {{cntp_ctl_el0|CNTP_CTL_EL0}} // encoding: [0x29,0xe2,0x3b,0xd5]
4729 // CHECK: mrs x9, {{cnthp_ctl_el2|CNTHP_CTL_EL2}} // encoding: [0x29,0xe2,0x3c,0xd5]
4730 // CHECK: mrs x9, {{cntps_ctl_el1|CNTPS_CTL_EL1}} // encoding: [0x29,0xe2,0x3f,0xd5]
4731 // CHECK: mrs x9, {{cntp_cval_el0|CNTP_CVAL_EL0}} // encoding: [0x49,0xe2,0x3b,0xd5]
4732 // CHECK: mrs x9, {{cnthp_cval_el2|CNTHP_CVAL_EL2}} // encoding: [0x49,0xe2,0x3c,0xd5]
4733 // CHECK: mrs x9, {{cntps_cval_el1|CNTPS_CVAL_EL1}} // encoding: [0x49,0xe2,0x3f,0xd5]
4734 // CHECK: mrs x9, {{cntv_tval_el0|CNTV_TVAL_EL0}} // encoding: [0x09,0xe3,0x3b,0xd5]
4735 // CHECK: mrs x9, {{cntv_ctl_el0|CNTV_CTL_EL0}} // encoding: [0x29,0xe3,0x3b,0xd5]
4736 // CHECK: mrs x9, {{cntv_cval_el0|CNTV_CVAL_EL0}} // encoding: [0x49,0xe3,0x3b,0xd5]
4737 // CHECK: mrs x9, {{pmevcntr0_el0|PMEVCNTR0_EL0}} // encoding: [0x09,0xe8,0x3b,0xd5]
4738 // CHECK: mrs x9, {{pmevcntr1_el0|PMEVCNTR1_EL0}} // encoding: [0x29,0xe8,0x3b,0xd5]
4739 // CHECK: mrs x9, {{pmevcntr2_el0|PMEVCNTR2_EL0}} // encoding: [0x49,0xe8,0x3b,0xd5]
4740 // CHECK: mrs x9, {{pmevcntr3_el0|PMEVCNTR3_EL0}} // encoding: [0x69,0xe8,0x3b,0xd5]
4741 // CHECK: mrs x9, {{pmevcntr4_el0|PMEVCNTR4_EL0}} // encoding: [0x89,0xe8,0x3b,0xd5]
4742 // CHECK: mrs x9, {{pmevcntr5_el0|PMEVCNTR5_EL0}} // encoding: [0xa9,0xe8,0x3b,0xd5]
4743 // CHECK: mrs x9, {{pmevcntr6_el0|PMEVCNTR6_EL0}} // encoding: [0xc9,0xe8,0x3b,0xd5]
4744 // CHECK: mrs x9, {{pmevcntr7_el0|PMEVCNTR7_EL0}} // encoding: [0xe9,0xe8,0x3b,0xd5]
4745 // CHECK: mrs x9, {{pmevcntr8_el0|PMEVCNTR8_EL0}} // encoding: [0x09,0xe9,0x3b,0xd5]
4746 // CHECK: mrs x9, {{pmevcntr9_el0|PMEVCNTR9_EL0}} // encoding: [0x29,0xe9,0x3b,0xd5]
4747 // CHECK: mrs x9, {{pmevcntr10_el0|PMEVCNTR10_EL0}} // encoding: [0x49,0xe9,0x3b,0xd5]
4748 // CHECK: mrs x9, {{pmevcntr11_el0|PMEVCNTR11_EL0}} // encoding: [0x69,0xe9,0x3b,0xd5]
4749 // CHECK: mrs x9, {{pmevcntr12_el0|PMEVCNTR12_EL0}} // encoding: [0x89,0xe9,0x3b,0xd5]
4750 // CHECK: mrs x9, {{pmevcntr13_el0|PMEVCNTR13_EL0}} // encoding: [0xa9,0xe9,0x3b,0xd5]
4751 // CHECK: mrs x9, {{pmevcntr14_el0|PMEVCNTR14_EL0}} // encoding: [0xc9,0xe9,0x3b,0xd5]
4752 // CHECK: mrs x9, {{pmevcntr15_el0|PMEVCNTR15_EL0}} // encoding: [0xe9,0xe9,0x3b,0xd5]
4753 // CHECK: mrs x9, {{pmevcntr16_el0|PMEVCNTR16_EL0}} // encoding: [0x09,0xea,0x3b,0xd5]
4754 // CHECK: mrs x9, {{pmevcntr17_el0|PMEVCNTR17_EL0}} // encoding: [0x29,0xea,0x3b,0xd5]
4755 // CHECK: mrs x9, {{pmevcntr18_el0|PMEVCNTR18_EL0}} // encoding: [0x49,0xea,0x3b,0xd5]
4756 // CHECK: mrs x9, {{pmevcntr19_el0|PMEVCNTR19_EL0}} // encoding: [0x69,0xea,0x3b,0xd5]
4757 // CHECK: mrs x9, {{pmevcntr20_el0|PMEVCNTR20_EL0}} // encoding: [0x89,0xea,0x3b,0xd5]
4758 // CHECK: mrs x9, {{pmevcntr21_el0|PMEVCNTR21_EL0}} // encoding: [0xa9,0xea,0x3b,0xd5]
4759 // CHECK: mrs x9, {{pmevcntr22_el0|PMEVCNTR22_EL0}} // encoding: [0xc9,0xea,0x3b,0xd5]
4760 // CHECK: mrs x9, {{pmevcntr23_el0|PMEVCNTR23_EL0}} // encoding: [0xe9,0xea,0x3b,0xd5]
4761 // CHECK: mrs x9, {{pmevcntr24_el0|PMEVCNTR24_EL0}} // encoding: [0x09,0xeb,0x3b,0xd5]
4762 // CHECK: mrs x9, {{pmevcntr25_el0|PMEVCNTR25_EL0}} // encoding: [0x29,0xeb,0x3b,0xd5]
4763 // CHECK: mrs x9, {{pmevcntr26_el0|PMEVCNTR26_EL0}} // encoding: [0x49,0xeb,0x3b,0xd5]
4764 // CHECK: mrs x9, {{pmevcntr27_el0|PMEVCNTR27_EL0}} // encoding: [0x69,0xeb,0x3b,0xd5]
4765 // CHECK: mrs x9, {{pmevcntr28_el0|PMEVCNTR28_EL0}} // encoding: [0x89,0xeb,0x3b,0xd5]
4766 // CHECK: mrs x9, {{pmevcntr29_el0|PMEVCNTR29_EL0}} // encoding: [0xa9,0xeb,0x3b,0xd5]
4767 // CHECK: mrs x9, {{pmevcntr30_el0|PMEVCNTR30_EL0}} // encoding: [0xc9,0xeb,0x3b,0xd5]
4768 // CHECK: mrs x9, {{pmccfiltr_el0|PMCCFILTR_EL0}} // encoding: [0xe9,0xef,0x3b,0xd5]
4769 // CHECK: mrs x9, {{pmevtyper0_el0|PMEVTYPER0_EL0}} // encoding: [0x09,0xec,0x3b,0xd5]
4770 // CHECK: mrs x9, {{pmevtyper1_el0|PMEVTYPER1_EL0}} // encoding: [0x29,0xec,0x3b,0xd5]
4771 // CHECK: mrs x9, {{pmevtyper2_el0|PMEVTYPER2_EL0}} // encoding: [0x49,0xec,0x3b,0xd5]
4772 // CHECK: mrs x9, {{pmevtyper3_el0|PMEVTYPER3_EL0}} // encoding: [0x69,0xec,0x3b,0xd5]
4773 // CHECK: mrs x9, {{pmevtyper4_el0|PMEVTYPER4_EL0}} // encoding: [0x89,0xec,0x3b,0xd5]
4774 // CHECK: mrs x9, {{pmevtyper5_el0|PMEVTYPER5_EL0}} // encoding: [0xa9,0xec,0x3b,0xd5]
4775 // CHECK: mrs x9, {{pmevtyper6_el0|PMEVTYPER6_EL0}} // encoding: [0xc9,0xec,0x3b,0xd5]
4776 // CHECK: mrs x9, {{pmevtyper7_el0|PMEVTYPER7_EL0}} // encoding: [0xe9,0xec,0x3b,0xd5]
4777 // CHECK: mrs x9, {{pmevtyper8_el0|PMEVTYPER8_EL0}} // encoding: [0x09,0xed,0x3b,0xd5]
4778 // CHECK: mrs x9, {{pmevtyper9_el0|PMEVTYPER9_EL0}} // encoding: [0x29,0xed,0x3b,0xd5]
4779 // CHECK: mrs x9, {{pmevtyper10_el0|PMEVTYPER10_EL0}} // encoding: [0x49,0xed,0x3b,0xd5]
4780 // CHECK: mrs x9, {{pmevtyper11_el0|PMEVTYPER11_EL0}} // encoding: [0x69,0xed,0x3b,0xd5]
4781 // CHECK: mrs x9, {{pmevtyper12_el0|PMEVTYPER12_EL0}} // encoding: [0x89,0xed,0x3b,0xd5]
4782 // CHECK: mrs x9, {{pmevtyper13_el0|PMEVTYPER13_EL0}} // encoding: [0xa9,0xed,0x3b,0xd5]
4783 // CHECK: mrs x9, {{pmevtyper14_el0|PMEVTYPER14_EL0}} // encoding: [0xc9,0xed,0x3b,0xd5]
4784 // CHECK: mrs x9, {{pmevtyper15_el0|PMEVTYPER15_EL0}} // encoding: [0xe9,0xed,0x3b,0xd5]
4785 // CHECK: mrs x9, {{pmevtyper16_el0|PMEVTYPER16_EL0}} // encoding: [0x09,0xee,0x3b,0xd5]
4786 // CHECK: mrs x9, {{pmevtyper17_el0|PMEVTYPER17_EL0}} // encoding: [0x29,0xee,0x3b,0xd5]
4787 // CHECK: mrs x9, {{pmevtyper18_el0|PMEVTYPER18_EL0}} // encoding: [0x49,0xee,0x3b,0xd5]
4788 // CHECK: mrs x9, {{pmevtyper19_el0|PMEVTYPER19_EL0}} // encoding: [0x69,0xee,0x3b,0xd5]
4789 // CHECK: mrs x9, {{pmevtyper20_el0|PMEVTYPER20_EL0}} // encoding: [0x89,0xee,0x3b,0xd5]
4790 // CHECK: mrs x9, {{pmevtyper21_el0|PMEVTYPER21_EL0}} // encoding: [0xa9,0xee,0x3b,0xd5]
4791 // CHECK: mrs x9, {{pmevtyper22_el0|PMEVTYPER22_EL0}} // encoding: [0xc9,0xee,0x3b,0xd5]
4792 // CHECK: mrs x9, {{pmevtyper23_el0|PMEVTYPER23_EL0}} // encoding: [0xe9,0xee,0x3b,0xd5]
4793 // CHECK: mrs x9, {{pmevtyper24_el0|PMEVTYPER24_EL0}} // encoding: [0x09,0xef,0x3b,0xd5]
4794 // CHECK: mrs x9, {{pmevtyper25_el0|PMEVTYPER25_EL0}} // encoding: [0x29,0xef,0x3b,0xd5]
4795 // CHECK: mrs x9, {{pmevtyper26_el0|PMEVTYPER26_EL0}} // encoding: [0x49,0xef,0x3b,0xd5]
4796 // CHECK: mrs x9, {{pmevtyper27_el0|PMEVTYPER27_EL0}} // encoding: [0x69,0xef,0x3b,0xd5]
4797 // CHECK: mrs x9, {{pmevtyper28_el0|PMEVTYPER28_EL0}} // encoding: [0x89,0xef,0x3b,0xd5]
4798 // CHECK: mrs x9, {{pmevtyper29_el0|PMEVTYPER29_EL0}} // encoding: [0xa9,0xef,0x3b,0xd5]
4799 // CHECK: mrs x9, {{pmevtyper30_el0|PMEVTYPER30_EL0}} // encoding: [0xc9,0xef,0x3b,0xd5]
4800
4801 mrs x12, s3_7_c15_c1_5
4802 mrs x13, s3_2_c11_c15_7
4803 mrs x14, s1_3_c9_c2_1
4804 msr s3_0_c15_c0_0, x12
4805 msr s3_7_c11_c13_7, x5
4806 msr s1_3_c9_c2_1, x4
4807 // CHECK: mrs x12, {{s3_7_c15_c1_5|S3_7_C15_C1_5}} // encoding: [0xac,0xf1,0x3f,0xd5]
4808 // CHECK: mrs x13, {{s3_2_c11_c15_7|S3_2_C11_C15_7}} // encoding: [0xed,0xbf,0x3a,0xd5]
4809 // CHECK: mrs x14, {{s1_3_c9_c2_1|S1_3_C9_C2_1}} // encoding: [0x2e,0x92,0x2b,0xd5]
4810 // CHECK: msr {{s3_0_c15_c0_0|S3_0_C15_C0_0}}, x12 // encoding: [0x0c,0xf0,0x18,0xd5]
4811 // CHECK: msr {{s3_7_c11_c13_7|S3_7_C11_C13_7}}, x5 // encoding: [0xe5,0xbd,0x1f,0xd5]
4812 // CHECK: msr {{s1_3_c9_c2_1|S1_3_C9_C2_1}}, x4 // encoding: [0x24,0x92,0x0b,0xd5]
4813
4814 //------------------------------------------------------------------------------
4815 // Unconditional branch (immediate)
4816 //------------------------------------------------------------------------------
4817
4818 tbz x5, #0, somewhere
4819 tbz xzr, #63, elsewhere
4820 tbnz x5, #45, nowhere
4821
4822 // CHECK: tbz w5, #0, somewhere // encoding: [0bAAA00101,A,0b00000AAA,0x36]
4823 // CHECK: // fixup A - offset: 0, value: somewhere, kind: fixup_aarch64_pcrel_branch14
4824 // CHECK: tbz xzr, #63, elsewhere // encoding: [0bAAA11111,A,0b11111AAA,0xb6]
4825 // CHECK: // fixup A - offset: 0, value: elsewhere, kind: fixup_aarch64_pcrel_branch14
4826 // CHECK: tbnz x5, #45, nowhere // encoding: [0bAAA00101,A,0b01101AAA,0xb7]
4827 // CHECK: // fixup A - offset: 0, value: nowhere, kind: fixup_aarch64_pcrel_branch14
4828
4829
4830 tbnz w3, #2, there
4831 tbnz wzr, #31, nowhere
4832 tbz w5, #12, anywhere
4833
4834 // CHECK: tbnz w3, #2, there // encoding: [0bAAA00011,A,0b00010AAA,0x37]
4835 // CHECK: // fixup A - offset: 0, value: there, kind: fixup_aarch64_pcrel_branch14
4836 // CHECK: tbnz wzr, #31, nowhere // encoding: [0bAAA11111,A,0b11111AAA,0x37]
4837 // CHECK: // fixup A - offset: 0, value: nowhere, kind: fixup_aarch64_pcrel_branch14
4838 // CHECK: tbz w5, #12, anywhere // encoding: [0bAAA00101,A,0b01100AAA,0x36]
4839 // CHECK: // fixup A - offset: 0, value: anywhere, kind: fixup_aarch64_pcrel_branch14
4840
4841 //------------------------------------------------------------------------------
4842 // Unconditional branch (immediate)
4843 //------------------------------------------------------------------------------
4844
4845 b somewhere
4846 bl elsewhere
4847
4848 // CHECK: b somewhere // encoding: [A,A,A,0b000101AA]
4849 // CHECK: // fixup A - offset: 0, value: somewhere, kind: fixup_aarch64_pcrel_branch26
4850 // CHECK: bl elsewhere // encoding: [A,A,A,0b100101AA]
4851 // CHECK: // fixup A - offset: 0, value: elsewhere, kind: fixup_aarch64_pcrel_call26
4852
4853 b #4
4854 bl #0
4855 b #134217724
4856 bl #-134217728
4857 // CHECK: b #4 // encoding: [0x01,0x00,0x00,0x14]
4858 // CHECK: bl #0 // encoding: [0x00,0x00,0x00,0x94]
4859 // CHECK: b #134217724 // encoding: [0xff,0xff,0xff,0x15]
4860 // CHECK: bl #-134217728 // encoding: [0x00,0x00,0x00,0x96]
4861
4862 //------------------------------------------------------------------------------
4863 // Unconditional branch (register)
4864 //------------------------------------------------------------------------------
4865
4866 br x20
4867 blr xzr
4868 ret x10
4869 // CHECK: br x20 // encoding: [0x80,0x02,0x1f,0xd6]
4870 // CHECK: blr xzr // encoding: [0xe0,0x03,0x3f,0xd6]
4871 // CHECK: ret x10 // encoding: [0x40,0x01,0x5f,0xd6]
4872
4873 ret
4874 eret
4875 drps
4876 // CHECK: ret // encoding: [0xc0,0x03,0x5f,0xd6]
4877 // CHECK: eret // encoding: [0xe0,0x03,0x9f,0xd6]
4878 // CHECK: drps // encoding: [0xe0,0x03,0xbf,0xd6]
4879
The LLVM Project is a collection of modular and reusable compiler and toolchain technologies.