1 // RUN: llvm-mc -triple=aarch64 -show-encoding < %s | FileCheck %s
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
14 //------------------------------------------------------------------------------
15 // Add/sub (extended register)
16 //------------------------------------------------------------------------------
17 // Basic extends 64-bit ops
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
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]
35 // Basic extends, 32-bit ops
37 add w21, w15, w17, uxth
38 add w30, w29, wzr, uxtw
39 add w19, w17, w1, uxtx // Goodness knows what this means
41 add w26, w17, w19, sxth
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]
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]
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
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]
82 sub w21, w15, w17, uxth
83 sub w30, w29, wzr, uxtw
84 sub w19, w17, w1, uxtx // Goodness knows what this means
86 sub w26, wsp, w19, sxth
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]
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, 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, x2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0xab]
114 // CHECK: adds x3, x5, x9, sxtx #2 // encoding: [0xa3,0xe8,0x29,0xab]
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: adds wzr, w2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0x2b]
131 // CHECK: adds w2, w3, w5, sxtx // encoding: [0x62,0xe0,0x25,0x2b]
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, 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, x2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0xeb]
149 // CHECK: subs x3, x5, x9, sxtx #2 // encoding: [0xa3,0xe8,0x29,0xeb]
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, w2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0x6b]
166 // CHECK: subs w2, w3, w5, sxtx // encoding: [0x62,0xe0,0x25,0x6b]
173 cmp x25, w20, sxtb #3
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]
189 cmp w17, w1, uxtx // Goodness knows what this means
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]
209 cmn x25, w20, sxtb #3
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]
225 cmn w17, w1, uxtx // Goodness knows what this means
230 // CHECK: cmn w5, w7, uxtb // encoding: [0xbf,0x00,0x27,0x2b]
231 // CHECK: cmn w15, w17, uxth // encoding: [0xff,0x21,0x31,0x2b]
232 // CHECK: cmn w29, wzr, uxtw // encoding: [0xbf,0x43,0x3f,0x2b]
233 // CHECK: cmn w17, w1, uxtx // encoding: [0x3f,0x62,0x21,0x2b]
234 // CHECK: cmn w5, w1, sxtb #1 // encoding: [0xbf,0x84,0x21,0x2b]
235 // CHECK: cmn wsp, w19, sxth // encoding: [0xff,0xa3,0x33,0x2b]
236 // CHECK: cmn w2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0x2b]
237 // CHECK: cmn w3, w5, sxtx // encoding: [0x7f,0xe0,0x25,0x2b]
240 cmp x20, w29, uxtb #3
241 cmp x12, x13, uxtx #4
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 wsp, wzr, sxtw // encoding: [0xff,0xc3,0x3f,0x2b]
249 // LSL variant if sp involved
250 sub sp, x3, x7, lsl #4
251 add w2, wsp, w3, lsl #1
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: adds wzr, wsp, w3, lsl #4 // encoding: [0xff,0x53,0x23,0x2b]
259 // CHECK: subs x3, sp, x9, lsl #2 // encoding: [0xe3,0x6b,0x29,0xeb]
261 //------------------------------------------------------------------------------
262 // Add/sub (immediate)
263 //------------------------------------------------------------------------------
265 // Check basic immediate values: an unsigned 12-bit immediate, optionally
266 // shifted left by 12 bits.
269 add w30, w29, #1, lsl #12
270 add w13, w5, #4095, lsl #12
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]
278 // All registers involved in the non-S variants have 31 encoding sp rather than zr
279 add w20, wsp, #801, lsl #0
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]
286 // A few checks on the sanity of 64-bit versions
288 add x3, x24, #4095, lsl #12
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]
298 sub w4, w20, #546, lsl #12
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]
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
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, w2, #4095 // encoding: [0x5f,0xfc,0x3f,0x31]
313 // CHECK: adds w20, wsp, #0 // encoding: [0xf4,0x03,0x00,0x31]
314 // CHECK: adds xzr, x3, #1, lsl #12 // encoding: [0x7f,0x04,0x40,0xb1]
317 subs xzr, sp, #20, lsl #12 // FIXME: canonically should be cmp
318 subs xzr, x30, #4095, lsl #0 // FIXME: canonically should be cmp
320 // CHECK: subs xzr, sp, #20, lsl #12 // encoding: [0xff,0x53,0x40,0xf1]
321 // CHECK: subs xzr, x30, #4095 // encoding: [0xdf,0xff,0x3f,0xf1]
322 // CHECK: subs x4, sp, #3822 // encoding: [0xe4,0xbb,0x3b,0xf1]
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]
332 // cmp is an alias for subs zr, ... (FIXME: should always disassemble as such too).
333 cmp x4, #300, lsl #12
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]
340 // A "MOV" involving sp is encoded in this manner: add Reg, Reg, #0
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]
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'A',A,A,0x91'A']
353 // CHECK: // fixup A - offset: 0, value: :lo12:var, kind: fixup_a64_add_lo12
355 //------------------------------------------------------------------------------
356 // Add-sub (shifted register)
357 //------------------------------------------------------------------------------
359 // As usual, we don't print the canonical forms of many instructions.
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]
370 add w11, w13, w15, lsl #0
371 add w9, w3, wzr, lsl #10
372 add w17, w29, w20, lsl #31
373 // CHECK: add w11, w13, w15 // encoding: [0xab,0x01,0x0f,0x0b]
374 // CHECK: add w9, w3, wzr, lsl #10 // encoding: [0x69,0x28,0x1f,0x0b]
375 // CHECK: add w17, w29, w20, lsl #31 // encoding: [0xb1,0x7f,0x14,0x0b]
377 add w21, w22, w23, lsr #0
378 add w24, w25, w26, lsr #18
379 add w27, w28, w29, lsr #31
380 // CHECK: add w21, w22, w23, lsr #0 // encoding: [0xd5,0x02,0x57,0x0b]
381 // CHECK: add w24, w25, w26, lsr #18 // encoding: [0x38,0x4b,0x5a,0x0b]
382 // CHECK: add w27, w28, w29, lsr #31 // encoding: [0x9b,0x7f,0x5d,0x0b]
384 add w2, w3, w4, asr #0
385 add w5, w6, w7, asr #21
386 add w8, w9, w10, asr #31
387 // CHECK: add w2, w3, w4, asr #0 // encoding: [0x62,0x00,0x84,0x0b]
388 // CHECK: add w5, w6, w7, asr #21 // encoding: [0xc5,0x54,0x87,0x0b]
389 // CHECK: add w8, w9, w10, asr #31 // encoding: [0x28,0x7d,0x8a,0x0b]
395 // CHECK: add x3, x5, x7 // encoding: [0xa3,0x00,0x07,0x8b]
396 // CHECK: add xzr, x3, x5 // encoding: [0x7f,0x00,0x05,0x8b]
397 // CHECK: add x20, xzr, x4 // encoding: [0xf4,0x03,0x04,0x8b]
398 // CHECK: add x4, x6, xzr // encoding: [0xc4,0x00,0x1f,0x8b]
400 add x11, x13, x15, lsl #0
401 add x9, x3, xzr, lsl #10
402 add x17, x29, x20, lsl #63
403 // CHECK: add x11, x13, x15 // encoding: [0xab,0x01,0x0f,0x8b]
404 // CHECK: add x9, x3, xzr, lsl #10 // encoding: [0x69,0x28,0x1f,0x8b]
405 // CHECK: add x17, x29, x20, lsl #63 // encoding: [0xb1,0xff,0x14,0x8b]
407 add x21, x22, x23, lsr #0
408 add x24, x25, x26, lsr #18
409 add x27, x28, x29, lsr #63
410 // CHECK: add x21, x22, x23, lsr #0 // encoding: [0xd5,0x02,0x57,0x8b]
411 // CHECK: add x24, x25, x26, lsr #18 // encoding: [0x38,0x4b,0x5a,0x8b]
412 // CHECK: add x27, x28, x29, lsr #63 // encoding: [0x9b,0xff,0x5d,0x8b]
414 add x2, x3, x4, asr #0
415 add x5, x6, x7, asr #21
416 add x8, x9, x10, asr #63
417 // CHECK: add x2, x3, x4, asr #0 // encoding: [0x62,0x00,0x84,0x8b]
418 // CHECK: add x5, x6, x7, asr #21 // encoding: [0xc5,0x54,0x87,0x8b]
419 // CHECK: add x8, x9, x10, asr #63 // encoding: [0x28,0xfd,0x8a,0x8b]
425 // CHECK: adds w3, w5, w7 // encoding: [0xa3,0x00,0x07,0x2b]
426 // CHECK: adds wzr, w3, w5 // encoding: [0x7f,0x00,0x05,0x2b]
427 // CHECK: adds w20, wzr, w4 // encoding: [0xf4,0x03,0x04,0x2b]
428 // CHECK: adds w4, w6, wzr // encoding: [0xc4,0x00,0x1f,0x2b]
430 adds w11, w13, w15, lsl #0
431 adds w9, w3, wzr, lsl #10
432 adds w17, w29, w20, lsl #31
433 // CHECK: adds w11, w13, w15 // encoding: [0xab,0x01,0x0f,0x2b]
434 // CHECK: adds w9, w3, wzr, lsl #10 // encoding: [0x69,0x28,0x1f,0x2b]
435 // CHECK: adds w17, w29, w20, lsl #31 // encoding: [0xb1,0x7f,0x14,0x2b]
437 adds w21, w22, w23, lsr #0
438 adds w24, w25, w26, lsr #18
439 adds w27, w28, w29, lsr #31
440 // CHECK: adds w21, w22, w23, lsr #0 // encoding: [0xd5,0x02,0x57,0x2b]
441 // CHECK: adds w24, w25, w26, lsr #18 // encoding: [0x38,0x4b,0x5a,0x2b]
442 // CHECK: adds w27, w28, w29, lsr #31 // encoding: [0x9b,0x7f,0x5d,0x2b]
444 adds w2, w3, w4, asr #0
445 adds w5, w6, w7, asr #21
446 adds w8, w9, w10, asr #31
447 // CHECK: adds w2, w3, w4, asr #0 // encoding: [0x62,0x00,0x84,0x2b]
448 // CHECK: adds w5, w6, w7, asr #21 // encoding: [0xc5,0x54,0x87,0x2b]
449 // CHECK: adds w8, w9, w10, asr #31 // encoding: [0x28,0x7d,0x8a,0x2b]
455 // CHECK: adds x3, x5, x7 // encoding: [0xa3,0x00,0x07,0xab]
456 // CHECK: adds xzr, x3, x5 // encoding: [0x7f,0x00,0x05,0xab]
457 // CHECK: adds x20, xzr, x4 // encoding: [0xf4,0x03,0x04,0xab]
458 // CHECK: adds x4, x6, xzr // encoding: [0xc4,0x00,0x1f,0xab]
460 adds x11, x13, x15, lsl #0
461 adds x9, x3, xzr, lsl #10
462 adds x17, x29, x20, lsl #63
463 // CHECK: adds x11, x13, x15 // encoding: [0xab,0x01,0x0f,0xab]
464 // CHECK: adds x9, x3, xzr, lsl #10 // encoding: [0x69,0x28,0x1f,0xab]
465 // CHECK: adds x17, x29, x20, lsl #63 // encoding: [0xb1,0xff,0x14,0xab]
467 adds x21, x22, x23, lsr #0
468 adds x24, x25, x26, lsr #18
469 adds x27, x28, x29, lsr #63
470 // CHECK: adds x21, x22, x23, lsr #0 // encoding: [0xd5,0x02,0x57,0xab]
471 // CHECK: adds x24, x25, x26, lsr #18 // encoding: [0x38,0x4b,0x5a,0xab]
472 // CHECK: adds x27, x28, x29, lsr #63 // encoding: [0x9b,0xff,0x5d,0xab]
474 adds x2, x3, x4, asr #0
475 adds x5, x6, x7, asr #21
476 adds x8, x9, x10, asr #63
477 // CHECK: adds x2, x3, x4, asr #0 // encoding: [0x62,0x00,0x84,0xab]
478 // CHECK: adds x5, x6, x7, asr #21 // encoding: [0xc5,0x54,0x87,0xab]
479 // CHECK: adds x8, x9, x10, asr #63 // encoding: [0x28,0xfd,0x8a,0xab]
485 // CHECK: sub w3, w5, w7 // encoding: [0xa3,0x00,0x07,0x4b]
486 // CHECK: sub wzr, w3, w5 // encoding: [0x7f,0x00,0x05,0x4b]
487 // CHECK: sub w20, wzr, w4 // encoding: [0xf4,0x03,0x04,0x4b]
488 // CHECK: sub w4, w6, wzr // encoding: [0xc4,0x00,0x1f,0x4b]
490 sub w11, w13, w15, lsl #0
491 sub w9, w3, wzr, lsl #10
492 sub w17, w29, w20, lsl #31
493 // CHECK: sub w11, w13, w15 // encoding: [0xab,0x01,0x0f,0x4b]
494 // CHECK: sub w9, w3, wzr, lsl #10 // encoding: [0x69,0x28,0x1f,0x4b]
495 // CHECK: sub w17, w29, w20, lsl #31 // encoding: [0xb1,0x7f,0x14,0x4b]
497 sub w21, w22, w23, lsr #0
498 sub w24, w25, w26, lsr #18
499 sub w27, w28, w29, lsr #31
500 // CHECK: sub w21, w22, w23, lsr #0 // encoding: [0xd5,0x02,0x57,0x4b]
501 // CHECK: sub w24, w25, w26, lsr #18 // encoding: [0x38,0x4b,0x5a,0x4b]
502 // CHECK: sub w27, w28, w29, lsr #31 // encoding: [0x9b,0x7f,0x5d,0x4b]
504 sub w2, w3, w4, asr #0
505 sub w5, w6, w7, asr #21
506 sub w8, w9, w10, asr #31
507 // CHECK: sub w2, w3, w4, asr #0 // encoding: [0x62,0x00,0x84,0x4b]
508 // CHECK: sub w5, w6, w7, asr #21 // encoding: [0xc5,0x54,0x87,0x4b]
509 // CHECK: sub w8, w9, w10, asr #31 // encoding: [0x28,0x7d,0x8a,0x4b]
515 // CHECK: sub x3, x5, x7 // encoding: [0xa3,0x00,0x07,0xcb]
516 // CHECK: sub xzr, x3, x5 // encoding: [0x7f,0x00,0x05,0xcb]
517 // CHECK: sub x20, xzr, x4 // encoding: [0xf4,0x03,0x04,0xcb]
518 // CHECK: sub x4, x6, xzr // encoding: [0xc4,0x00,0x1f,0xcb]
520 sub x11, x13, x15, lsl #0
521 sub x9, x3, xzr, lsl #10
522 sub x17, x29, x20, lsl #63
523 // CHECK: sub x11, x13, x15 // encoding: [0xab,0x01,0x0f,0xcb]
524 // CHECK: sub x9, x3, xzr, lsl #10 // encoding: [0x69,0x28,0x1f,0xcb]
525 // CHECK: sub x17, x29, x20, lsl #63 // encoding: [0xb1,0xff,0x14,0xcb]
527 sub x21, x22, x23, lsr #0
528 sub x24, x25, x26, lsr #18
529 sub x27, x28, x29, lsr #63
530 // CHECK: sub x21, x22, x23, lsr #0 // encoding: [0xd5,0x02,0x57,0xcb]
531 // CHECK: sub x24, x25, x26, lsr #18 // encoding: [0x38,0x4b,0x5a,0xcb]
532 // CHECK: sub x27, x28, x29, lsr #63 // encoding: [0x9b,0xff,0x5d,0xcb]
534 sub x2, x3, x4, asr #0
535 sub x5, x6, x7, asr #21
536 sub x8, x9, x10, asr #63
537 // CHECK: sub x2, x3, x4, asr #0 // encoding: [0x62,0x00,0x84,0xcb]
538 // CHECK: sub x5, x6, x7, asr #21 // encoding: [0xc5,0x54,0x87,0xcb]
539 // CHECK: sub x8, x9, x10, asr #63 // encoding: [0x28,0xfd,0x8a,0xcb]
545 // CHECK: subs w3, w5, w7 // encoding: [0xa3,0x00,0x07,0x6b]
546 // CHECK: subs wzr, w3, w5 // encoding: [0x7f,0x00,0x05,0x6b]
547 // CHECK: subs w20, wzr, w4 // encoding: [0xf4,0x03,0x04,0x6b]
548 // CHECK: subs w4, w6, wzr // encoding: [0xc4,0x00,0x1f,0x6b]
550 subs w11, w13, w15, lsl #0
551 subs w9, w3, wzr, lsl #10
552 subs w17, w29, w20, lsl #31
553 // CHECK: subs w11, w13, w15 // encoding: [0xab,0x01,0x0f,0x6b]
554 // CHECK: subs w9, w3, wzr, lsl #10 // encoding: [0x69,0x28,0x1f,0x6b]
555 // CHECK: subs w17, w29, w20, lsl #31 // encoding: [0xb1,0x7f,0x14,0x6b]
557 subs w21, w22, w23, lsr #0
558 subs w24, w25, w26, lsr #18
559 subs w27, w28, w29, lsr #31
560 // CHECK: subs w21, w22, w23, lsr #0 // encoding: [0xd5,0x02,0x57,0x6b]
561 // CHECK: subs w24, w25, w26, lsr #18 // encoding: [0x38,0x4b,0x5a,0x6b]
562 // CHECK: subs w27, w28, w29, lsr #31 // encoding: [0x9b,0x7f,0x5d,0x6b]
564 subs w2, w3, w4, asr #0
565 subs w5, w6, w7, asr #21
566 subs w8, w9, w10, asr #31
567 // CHECK: subs w2, w3, w4, asr #0 // encoding: [0x62,0x00,0x84,0x6b]
568 // CHECK: subs w5, w6, w7, asr #21 // encoding: [0xc5,0x54,0x87,0x6b]
569 // CHECK: subs w8, w9, w10, asr #31 // encoding: [0x28,0x7d,0x8a,0x6b]
575 // CHECK: subs x3, x5, x7 // encoding: [0xa3,0x00,0x07,0xeb]
576 // CHECK: subs xzr, x3, x5 // encoding: [0x7f,0x00,0x05,0xeb]
577 // CHECK: subs x20, xzr, x4 // encoding: [0xf4,0x03,0x04,0xeb]
578 // CHECK: subs x4, x6, xzr // encoding: [0xc4,0x00,0x1f,0xeb]
580 subs x11, x13, x15, lsl #0
581 subs x9, x3, xzr, lsl #10
582 subs x17, x29, x20, lsl #63
583 // CHECK: subs x11, x13, x15 // encoding: [0xab,0x01,0x0f,0xeb]
584 // CHECK: subs x9, x3, xzr, lsl #10 // encoding: [0x69,0x28,0x1f,0xeb]
585 // CHECK: subs x17, x29, x20, lsl #63 // encoding: [0xb1,0xff,0x14,0xeb]
587 subs x21, x22, x23, lsr #0
588 subs x24, x25, x26, lsr #18
589 subs x27, x28, x29, lsr #63
590 // CHECK: subs x21, x22, x23, lsr #0 // encoding: [0xd5,0x02,0x57,0xeb]
591 // CHECK: subs x24, x25, x26, lsr #18 // encoding: [0x38,0x4b,0x5a,0xeb]
592 // CHECK: subs x27, x28, x29, lsr #63 // encoding: [0x9b,0xff,0x5d,0xeb]
594 subs x2, x3, x4, asr #0
595 subs x5, x6, x7, asr #21
596 subs x8, x9, x10, asr #63
597 // CHECK: subs x2, x3, x4, asr #0 // encoding: [0x62,0x00,0x84,0xeb]
598 // CHECK: subs x5, x6, x7, asr #21 // encoding: [0xc5,0x54,0x87,0xeb]
599 // CHECK: subs x8, x9, x10, asr #63 // encoding: [0x28,0xfd,0x8a,0xeb]
604 // CHECK: cmn w0, w3 // encoding: [0x1f,0x00,0x03,0x2b]
605 // CHECK: cmn wzr, w4 // encoding: [0xff,0x03,0x04,0x2b]
606 // CHECK: cmn w5, wzr // encoding: [0xbf,0x00,0x1f,0x2b]
610 cmn w10, w11, lsl #31
611 // CHECK: cmn w6, w7 // encoding: [0xdf,0x00,0x07,0x2b]
612 // CHECK: cmn w8, w9, lsl #15 // encoding: [0x1f,0x3d,0x09,0x2b]
613 // CHECK: cmn w10, w11, lsl #31 // encoding: [0x5f,0x7d,0x0b,0x2b]
616 cmn w14, w15, lsr #21
617 cmn w16, w17, lsr #31
618 // CHECK: cmn w12, w13, lsr #0 // encoding: [0x9f,0x01,0x4d,0x2b]
619 // CHECK: cmn w14, w15, lsr #21 // encoding: [0xdf,0x55,0x4f,0x2b]
620 // CHECK: cmn w16, w17, lsr #31 // encoding: [0x1f,0x7e,0x51,0x2b]
623 cmn w20, w21, asr #22
624 cmn w22, w23, asr #31
625 // CHECK: cmn w18, w19, asr #0 // encoding: [0x5f,0x02,0x93,0x2b]
626 // CHECK: cmn w20, w21, asr #22 // encoding: [0x9f,0x5a,0x95,0x2b]
627 // CHECK: cmn w22, w23, asr #31 // encoding: [0xdf,0x7e,0x97,0x2b]
632 // CHECK: cmn x0, x3 // encoding: [0x1f,0x00,0x03,0xab]
633 // CHECK: cmn xzr, x4 // encoding: [0xff,0x03,0x04,0xab]
634 // CHECK: cmn x5, xzr // encoding: [0xbf,0x00,0x1f,0xab]
638 cmn x10, x11, lsl #63
639 // CHECK: cmn x6, x7 // encoding: [0xdf,0x00,0x07,0xab]
640 // CHECK: cmn x8, x9, lsl #15 // encoding: [0x1f,0x3d,0x09,0xab]
641 // CHECK: cmn x10, x11, lsl #63 // encoding: [0x5f,0xfd,0x0b,0xab]
644 cmn x14, x15, lsr #41
645 cmn x16, x17, lsr #63
646 // CHECK: cmn x12, x13, lsr #0 // encoding: [0x9f,0x01,0x4d,0xab]
647 // CHECK: cmn x14, x15, lsr #41 // encoding: [0xdf,0xa5,0x4f,0xab]
648 // CHECK: cmn x16, x17, lsr #63 // encoding: [0x1f,0xfe,0x51,0xab]
651 cmn x20, x21, asr #55
652 cmn x22, x23, asr #63
653 // CHECK: cmn x18, x19, asr #0 // encoding: [0x5f,0x02,0x93,0xab]
654 // CHECK: cmn x20, x21, asr #55 // encoding: [0x9f,0xde,0x95,0xab]
655 // CHECK: cmn x22, x23, asr #63 // encoding: [0xdf,0xfe,0x97,0xab]
660 // CHECK: cmp w0, w3 // encoding: [0x1f,0x00,0x03,0x6b]
661 // CHECK: cmp wzr, w4 // encoding: [0xff,0x03,0x04,0x6b]
662 // CHECK: cmp w5, wzr // encoding: [0xbf,0x00,0x1f,0x6b]
666 cmp w10, w11, lsl #31
667 // CHECK: cmp w6, w7 // encoding: [0xdf,0x00,0x07,0x6b]
668 // CHECK: cmp w8, w9, lsl #15 // encoding: [0x1f,0x3d,0x09,0x6b]
669 // CHECK: cmp w10, w11, lsl #31 // encoding: [0x5f,0x7d,0x0b,0x6b]
672 cmp w14, w15, lsr #21
673 cmp w16, w17, lsr #31
674 // CHECK: cmp w12, w13, lsr #0 // encoding: [0x9f,0x01,0x4d,0x6b]
675 // CHECK: cmp w14, w15, lsr #21 // encoding: [0xdf,0x55,0x4f,0x6b]
676 // CHECK: cmp w16, w17, lsr #31 // encoding: [0x1f,0x7e,0x51,0x6b]
679 cmp w20, w21, asr #22
680 cmp w22, w23, asr #31
681 // CHECK: cmp w18, w19, asr #0 // encoding: [0x5f,0x02,0x93,0x6b]
682 // CHECK: cmp w20, w21, asr #22 // encoding: [0x9f,0x5a,0x95,0x6b]
683 // CHECK: cmp w22, w23, asr #31 // encoding: [0xdf,0x7e,0x97,0x6b]
688 // CHECK: cmp x0, x3 // encoding: [0x1f,0x00,0x03,0xeb]
689 // CHECK: cmp xzr, x4 // encoding: [0xff,0x03,0x04,0xeb]
690 // CHECK: cmp x5, xzr // encoding: [0xbf,0x00,0x1f,0xeb]
694 cmp x10, x11, lsl #63
695 // CHECK: cmp x6, x7 // encoding: [0xdf,0x00,0x07,0xeb]
696 // CHECK: cmp x8, x9, lsl #15 // encoding: [0x1f,0x3d,0x09,0xeb]
697 // CHECK: cmp x10, x11, lsl #63 // encoding: [0x5f,0xfd,0x0b,0xeb]
700 cmp x14, x15, lsr #41
701 cmp x16, x17, lsr #63
702 // CHECK: cmp x12, x13, lsr #0 // encoding: [0x9f,0x01,0x4d,0xeb]
703 // CHECK: cmp x14, x15, lsr #41 // encoding: [0xdf,0xa5,0x4f,0xeb]
704 // CHECK: cmp x16, x17, lsr #63 // encoding: [0x1f,0xfe,0x51,0xeb]
707 cmp x20, x21, asr #55
708 cmp x22, x23, asr #63
709 // CHECK: cmp x18, x19, asr #0 // encoding: [0x5f,0x02,0x93,0xeb]
710 // CHECK: cmp x20, x21, asr #55 // encoding: [0x9f,0xde,0x95,0xeb]
711 // CHECK: cmp x22, x23, asr #63 // encoding: [0xdf,0xfe,0x97,0xeb]
716 // CHECK: sub w29, wzr, w30 // encoding: [0xfd,0x03,0x1e,0x4b]
717 // CHECK: sub w30, wzr, wzr // encoding: [0xfe,0x03,0x1f,0x4b]
718 // CHECK: sub wzr, wzr, w0 // encoding: [0xff,0x03,0x00,0x4b]
721 neg w26, w25, lsl #29
722 neg w24, w23, lsl #31
723 // CHECK: sub w28, wzr, w27 // encoding: [0xfc,0x03,0x1b,0x4b]
724 // CHECK: sub w26, wzr, w25, lsl #29 // encoding: [0xfa,0x77,0x19,0x4b]
725 // CHECK: sub w24, wzr, w23, lsl #31 // encoding: [0xf8,0x7f,0x17,0x4b]
729 neg w18, w17, lsr #31
730 // CHECK: sub w22, wzr, w21, lsr #0 // encoding: [0xf6,0x03,0x55,0x4b]
731 // CHECK: sub w20, wzr, w19, lsr #1 // encoding: [0xf4,0x07,0x53,0x4b]
732 // CHECK: sub w18, wzr, w17, lsr #31 // encoding: [0xf2,0x7f,0x51,0x4b]
735 neg w14, w13, asr #12
736 neg w12, w11, asr #31
737 // CHECK: sub w16, wzr, w15, asr #0 // encoding: [0xf0,0x03,0x8f,0x4b]
738 // CHECK: sub w14, wzr, w13, asr #12 // encoding: [0xee,0x33,0x8d,0x4b]
739 // CHECK: sub w12, wzr, w11, asr #31 // encoding: [0xec,0x7f,0x8b,0x4b]
744 // CHECK: sub x29, xzr, x30 // encoding: [0xfd,0x03,0x1e,0xcb]
745 // CHECK: sub x30, xzr, xzr // encoding: [0xfe,0x03,0x1f,0xcb]
746 // CHECK: sub xzr, xzr, x0 // encoding: [0xff,0x03,0x00,0xcb]
749 neg x26, x25, lsl #29
750 neg x24, x23, lsl #31
751 // CHECK: sub x28, xzr, x27 // encoding: [0xfc,0x03,0x1b,0xcb]
752 // CHECK: sub x26, xzr, x25, lsl #29 // encoding: [0xfa,0x77,0x19,0xcb]
753 // CHECK: sub x24, xzr, x23, lsl #31 // encoding: [0xf8,0x7f,0x17,0xcb]
757 neg x18, x17, lsr #31
758 // CHECK: sub x22, xzr, x21, lsr #0 // encoding: [0xf6,0x03,0x55,0xcb]
759 // CHECK: sub x20, xzr, x19, lsr #1 // encoding: [0xf4,0x07,0x53,0xcb]
760 // CHECK: sub x18, xzr, x17, lsr #31 // encoding: [0xf2,0x7f,0x51,0xcb]
763 neg x14, x13, asr #12
764 neg x12, x11, asr #31
765 // CHECK: sub x16, xzr, x15, asr #0 // encoding: [0xf0,0x03,0x8f,0xcb]
766 // CHECK: sub x14, xzr, x13, asr #12 // encoding: [0xee,0x33,0x8d,0xcb]
767 // CHECK: sub x12, xzr, x11, asr #31 // encoding: [0xec,0x7f,0x8b,0xcb]
772 // CHECK: subs w29, wzr, w30 // encoding: [0xfd,0x03,0x1e,0x6b]
773 // CHECK: subs w30, wzr, wzr // encoding: [0xfe,0x03,0x1f,0x6b]
774 // CHECK: subs wzr, wzr, w0 // encoding: [0xff,0x03,0x00,0x6b]
776 negs w28, w27, lsl #0
777 negs w26, w25, lsl #29
778 negs w24, w23, lsl #31
779 // CHECK: subs w28, wzr, w27 // encoding: [0xfc,0x03,0x1b,0x6b]
780 // CHECK: subs w26, wzr, w25, lsl #29 // encoding: [0xfa,0x77,0x19,0x6b]
781 // CHECK: subs w24, wzr, w23, lsl #31 // encoding: [0xf8,0x7f,0x17,0x6b]
783 negs w22, w21, lsr #0
784 negs w20, w19, lsr #1
785 negs w18, w17, lsr #31
786 // CHECK: subs w22, wzr, w21, lsr #0 // encoding: [0xf6,0x03,0x55,0x6b]
787 // CHECK: subs w20, wzr, w19, lsr #1 // encoding: [0xf4,0x07,0x53,0x6b]
788 // CHECK: subs w18, wzr, w17, lsr #31 // encoding: [0xf2,0x7f,0x51,0x6b]
790 negs w16, w15, asr #0
791 negs w14, w13, asr #12
792 negs w12, w11, asr #31
793 // CHECK: subs w16, wzr, w15, asr #0 // encoding: [0xf0,0x03,0x8f,0x6b]
794 // CHECK: subs w14, wzr, w13, asr #12 // encoding: [0xee,0x33,0x8d,0x6b]
795 // CHECK: subs w12, wzr, w11, asr #31 // encoding: [0xec,0x7f,0x8b,0x6b]
800 // CHECK: subs x29, xzr, x30 // encoding: [0xfd,0x03,0x1e,0xeb]
801 // CHECK: subs x30, xzr, xzr // encoding: [0xfe,0x03,0x1f,0xeb]
802 // CHECK: subs xzr, xzr, x0 // encoding: [0xff,0x03,0x00,0xeb]
804 negs x28, x27, lsl #0
805 negs x26, x25, lsl #29
806 negs x24, x23, lsl #31
807 // CHECK: subs x28, xzr, x27 // encoding: [0xfc,0x03,0x1b,0xeb]
808 // CHECK: subs x26, xzr, x25, lsl #29 // encoding: [0xfa,0x77,0x19,0xeb]
809 // CHECK: subs x24, xzr, x23, lsl #31 // encoding: [0xf8,0x7f,0x17,0xeb]
811 negs x22, x21, lsr #0
812 negs x20, x19, lsr #1
813 negs x18, x17, lsr #31
814 // CHECK: subs x22, xzr, x21, lsr #0 // encoding: [0xf6,0x03,0x55,0xeb]
815 // CHECK: subs x20, xzr, x19, lsr #1 // encoding: [0xf4,0x07,0x53,0xeb]
816 // CHECK: subs x18, xzr, x17, lsr #31 // encoding: [0xf2,0x7f,0x51,0xeb]
818 negs x16, x15, asr #0
819 negs x14, x13, asr #12
820 negs x12, x11, asr #31
821 // CHECK: subs x16, xzr, x15, asr #0 // encoding: [0xf0,0x03,0x8f,0xeb]
822 // CHECK: subs x14, xzr, x13, asr #12 // encoding: [0xee,0x33,0x8d,0xeb]
823 // CHECK: subs x12, xzr, x11, asr #31 // encoding: [0xec,0x7f,0x8b,0xeb]
825 //------------------------------------------------------------------------------
826 // Add-sub (shifted register)
827 //------------------------------------------------------------------------------
832 // CHECK: adc w29, w27, w25 // encoding: [0x7d,0x03,0x19,0x1a]
833 // CHECK: adc wzr, w3, w4 // encoding: [0x7f,0x00,0x04,0x1a]
834 // CHECK: adc w9, wzr, w10 // encoding: [0xe9,0x03,0x0a,0x1a]
835 // CHECK: adc w20, w0, wzr // encoding: [0x14,0x00,0x1f,0x1a]
841 // CHECK: adc x29, x27, x25 // encoding: [0x7d,0x03,0x19,0x9a]
842 // CHECK: adc xzr, x3, x4 // encoding: [0x7f,0x00,0x04,0x9a]
843 // CHECK: adc x9, xzr, x10 // encoding: [0xe9,0x03,0x0a,0x9a]
844 // CHECK: adc x20, x0, xzr // encoding: [0x14,0x00,0x1f,0x9a]
850 // CHECK: adcs w29, w27, w25 // encoding: [0x7d,0x03,0x19,0x3a]
851 // CHECK: adcs wzr, w3, w4 // encoding: [0x7f,0x00,0x04,0x3a]
852 // CHECK: adcs w9, wzr, w10 // encoding: [0xe9,0x03,0x0a,0x3a]
853 // CHECK: adcs w20, w0, wzr // encoding: [0x14,0x00,0x1f,0x3a]
859 // CHECK: adcs x29, x27, x25 // encoding: [0x7d,0x03,0x19,0xba]
860 // CHECK: adcs xzr, x3, x4 // encoding: [0x7f,0x00,0x04,0xba]
861 // CHECK: adcs x9, xzr, x10 // encoding: [0xe9,0x03,0x0a,0xba]
862 // CHECK: adcs x20, x0, xzr // encoding: [0x14,0x00,0x1f,0xba]
868 // CHECK: sbc w29, w27, w25 // encoding: [0x7d,0x03,0x19,0x5a]
869 // CHECK: sbc wzr, w3, w4 // encoding: [0x7f,0x00,0x04,0x5a]
870 // CHECK: ngc w9, w10 // encoding: [0xe9,0x03,0x0a,0x5a]
871 // CHECK: sbc w20, w0, wzr // encoding: [0x14,0x00,0x1f,0x5a]
877 // CHECK: sbc x29, x27, x25 // encoding: [0x7d,0x03,0x19,0xda]
878 // CHECK: sbc xzr, x3, x4 // encoding: [0x7f,0x00,0x04,0xda]
879 // CHECK: ngc x9, x10 // encoding: [0xe9,0x03,0x0a,0xda]
880 // CHECK: sbc x20, x0, xzr // encoding: [0x14,0x00,0x1f,0xda]
886 // CHECK: sbcs w29, w27, w25 // encoding: [0x7d,0x03,0x19,0x7a]
887 // CHECK: sbcs wzr, w3, w4 // encoding: [0x7f,0x00,0x04,0x7a]
888 // CHECK: ngcs w9, w10 // encoding: [0xe9,0x03,0x0a,0x7a]
889 // CHECK: sbcs w20, w0, wzr // encoding: [0x14,0x00,0x1f,0x7a]
895 // CHECK: sbcs x29, x27, x25 // encoding: [0x7d,0x03,0x19,0xfa]
896 // CHECK: sbcs xzr, x3, x4 // encoding: [0x7f,0x00,0x04,0xfa]
897 // CHECK: ngcs x9, x10 // encoding: [0xe9,0x03,0x0a,0xfa]
898 // CHECK: sbcs x20, x0, xzr // encoding: [0x14,0x00,0x1f,0xfa]
903 // CHECK: ngc w3, w12 // encoding: [0xe3,0x03,0x0c,0x5a]
904 // CHECK: ngc wzr, w9 // encoding: [0xff,0x03,0x09,0x5a]
905 // CHECK: ngc w23, wzr // encoding: [0xf7,0x03,0x1f,0x5a]
910 // CHECK: ngc x29, x30 // encoding: [0xfd,0x03,0x1e,0xda]
911 // CHECK: ngc xzr, x0 // encoding: [0xff,0x03,0x00,0xda]
912 // CHECK: ngc x0, xzr // encoding: [0xe0,0x03,0x1f,0xda]
917 // CHECK: ngcs w3, w12 // encoding: [0xe3,0x03,0x0c,0x7a]
918 // CHECK: ngcs wzr, w9 // encoding: [0xff,0x03,0x09,0x7a]
919 // CHECK: ngcs w23, wzr // encoding: [0xf7,0x03,0x1f,0x7a]
924 // CHECK: ngcs x29, x30 // encoding: [0xfd,0x03,0x1e,0xfa]
925 // CHECK: ngcs xzr, x0 // encoding: [0xff,0x03,0x00,0xfa]
926 // CHECK: ngcs x0, xzr // encoding: [0xe0,0x03,0x1f,0xfa]
928 //------------------------------------------------------------------------------
930 //------------------------------------------------------------------------------
933 sbfm x3, x4, #63, #63
934 sbfm wzr, wzr, #31, #31
936 // CHECK: sbfm x1, x2, #3, #4 // encoding: [0x41,0x10,0x43,0x93]
937 // CHECK: sbfm x3, x4, #63, #63 // encoding: [0x83,0xfc,0x7f,0x93]
938 // CHECK: sbfm wzr, wzr, #31, #31 // encoding: [0xff,0x7f,0x1f,0x13]
939 // CHECK: sbfm w12, w9, #0, #0 // encoding: [0x2c,0x01,0x00,0x13]
941 ubfm x4, x5, #12, #10
943 ubfm x4, xzr, #63, #5
944 ubfm x5, x6, #12, #63
945 // CHECK: ubfm x4, x5, #12, #10 // encoding: [0xa4,0x28,0x4c,0xd3]
946 // CHECK: ubfm xzr, x4, #0, #0 // encoding: [0x9f,0x00,0x40,0xd3]
947 // CHECK: ubfm x4, xzr, #63, #5 // encoding: [0xe4,0x17,0x7f,0xd3]
948 // CHECK: ubfm x5, x6, #12, #63 // encoding: [0xc5,0xfc,0x4c,0xd3]
954 // CHECK: bfm x4, x5, #12, #10 // encoding: [0xa4,0x28,0x4c,0xb3]
955 // CHECK: bfm xzr, x4, #0, #0 // encoding: [0x9f,0x00,0x40,0xb3]
956 // CHECK: bfm x4, xzr, #63, #5 // encoding: [0xe4,0x17,0x7f,0xb3]
957 // CHECK: bfm x5, x6, #12, #63 // encoding: [0xc5,0xfc,0x4c,0xb3]
964 // CHECK: sxtb w1, w2 // encoding: [0x41,0x1c,0x00,0x13]
965 // CHECK: sxtb xzr, w3 // encoding: [0x7f,0x1c,0x40,0x93]
966 // CHECK: sxth w9, w10 // encoding: [0x49,0x3d,0x00,0x13]
967 // CHECK: sxth x0, w1 // encoding: [0x20,0x3c,0x40,0x93]
968 // CHECK: sxtw x3, w30 // encoding: [0xc3,0x7f,0x40,0x93]
974 // CHECK: uxtb w1, w2 // encoding: [0x41,0x1c,0x00,0x53]
975 // CHECK: uxtb xzr, w3 // encoding: [0x7f,0x1c,0x00,0x53]
976 // CHECK: uxth w9, w10 // encoding: [0x49,0x3d,0x00,0x53]
977 // CHECK: uxth x0, w1 // encoding: [0x20,0x3c,0x00,0x53]
983 // CHECK: asr w3, w2, #0 // encoding: [0x43,0x7c,0x00,0x13]
984 // CHECK: asr w9, w10, #31 // encoding: [0x49,0x7d,0x1f,0x13]
985 // CHECK: asr x20, x21, #63 // encoding: [0xb4,0xfe,0x7f,0x93]
986 // CHECK: asr w1, wzr, #3 // encoding: [0xe1,0x7f,0x03,0x13]
992 // CHECK: lsr w3, w2, #0 // encoding: [0x43,0x7c,0x00,0x53]
993 // CHECK: lsr w9, w10, #31 // encoding: [0x49,0x7d,0x1f,0x53]
994 // CHECK: lsr x20, x21, #63 // encoding: [0xb4,0xfe,0x7f,0xd3]
995 // CHECK: lsr wzr, wzr, #3 // encoding: [0xff,0x7f,0x03,0x53]
1001 // CHECK: lsl w3, w2, #0 // encoding: [0x43,0x7c,0x00,0x53]
1002 // CHECK: lsl w9, w10, #31 // encoding: [0x49,0x01,0x01,0x53]
1003 // CHECK: lsl x20, x21, #63 // encoding: [0xb4,0x02,0x41,0xd3]
1004 // CHECK: lsl w1, wzr, #3 // encoding: [0xe1,0x73,0x1d,0x53]
1006 sbfiz w9, w10, #0, #1
1007 sbfiz x2, x3, #63, #1
1008 sbfiz x19, x20, #0, #64
1009 sbfiz x9, x10, #5, #59
1010 sbfiz w9, w10, #0, #32
1011 sbfiz w11, w12, #31, #1
1012 sbfiz w13, w14, #29, #3
1013 sbfiz xzr, xzr, #10, #11
1014 // CHECK: sbfiz w9, w10, #0, #1 // encoding: [0x49,0x01,0x00,0x13]
1015 // CHECK: sbfiz x2, x3, #63, #1 // encoding: [0x62,0x00,0x41,0x93]
1016 // CHECK: sbfiz x19, x20, #0, #64 // encoding: [0x93,0xfe,0x40,0x93]
1017 // CHECK: sbfiz x9, x10, #5, #59 // encoding: [0x49,0xe9,0x7b,0x93]
1018 // CHECK: sbfiz w9, w10, #0, #32 // encoding: [0x49,0x7d,0x00,0x13]
1019 // CHECK: sbfiz w11, w12, #31, #1 // encoding: [0x8b,0x01,0x01,0x13]
1020 // CHECK: sbfiz w13, w14, #29, #3 // encoding: [0xcd,0x09,0x03,0x13]
1021 // CHECK: sbfiz xzr, xzr, #10, #11 // encoding: [0xff,0x2b,0x76,0x93]
1023 sbfx w9, w10, #0, #1
1024 sbfx x2, x3, #63, #1
1025 sbfx x19, x20, #0, #64
1026 sbfx x9, x10, #5, #59
1027 sbfx w9, w10, #0, #32
1028 sbfx w11, w12, #31, #1
1029 sbfx w13, w14, #29, #3
1030 sbfx xzr, xzr, #10, #11
1031 // CHECK: sbfx w9, w10, #0, #1 // encoding: [0x49,0x01,0x00,0x13]
1032 // CHECK: sbfx x2, x3, #63, #1 // encoding: [0x62,0xfc,0x7f,0x93]
1033 // CHECK: sbfx x19, x20, #0, #64 // encoding: [0x93,0xfe,0x40,0x93]
1034 // CHECK: sbfx x9, x10, #5, #59 // encoding: [0x49,0xfd,0x45,0x93]
1035 // CHECK: sbfx w9, w10, #0, #32 // encoding: [0x49,0x7d,0x00,0x13]
1036 // CHECK: sbfx w11, w12, #31, #1 // encoding: [0x8b,0x7d,0x1f,0x13]
1037 // CHECK: sbfx w13, w14, #29, #3 // encoding: [0xcd,0x7d,0x1d,0x13]
1038 // CHECK: sbfx xzr, xzr, #10, #11 // encoding: [0xff,0x53,0x4a,0x93]
1042 bfi x19, x20, #0, #64
1043 bfi x9, x10, #5, #59
1044 bfi w9, w10, #0, #32
1045 bfi w11, w12, #31, #1
1046 bfi w13, w14, #29, #3
1047 bfi xzr, xzr, #10, #11
1048 // CHECK: bfi w9, w10, #0, #1 // encoding: [0x49,0x01,0x00,0x33]
1049 // CHECK: bfi x2, x3, #63, #1 // encoding: [0x62,0x00,0x41,0xb3]
1050 // CHECK: bfi x19, x20, #0, #64 // encoding: [0x93,0xfe,0x40,0xb3]
1051 // CHECK: bfi x9, x10, #5, #59 // encoding: [0x49,0xe9,0x7b,0xb3]
1052 // CHECK: bfi w9, w10, #0, #32 // encoding: [0x49,0x7d,0x00,0x33]
1053 // CHECK: bfi w11, w12, #31, #1 // encoding: [0x8b,0x01,0x01,0x33]
1054 // CHECK: bfi w13, w14, #29, #3 // encoding: [0xcd,0x09,0x03,0x33]
1055 // CHECK: bfi xzr, xzr, #10, #11 // encoding: [0xff,0x2b,0x76,0xb3]
1057 bfxil w9, w10, #0, #1
1058 bfxil x2, x3, #63, #1
1059 bfxil x19, x20, #0, #64
1060 bfxil x9, x10, #5, #59
1061 bfxil w9, w10, #0, #32
1062 bfxil w11, w12, #31, #1
1063 bfxil w13, w14, #29, #3
1064 bfxil xzr, xzr, #10, #11
1065 // CHECK: bfxil w9, w10, #0, #1 // encoding: [0x49,0x01,0x00,0x33]
1066 // CHECK: bfxil x2, x3, #63, #1 // encoding: [0x62,0xfc,0x7f,0xb3]
1067 // CHECK: bfxil x19, x20, #0, #64 // encoding: [0x93,0xfe,0x40,0xb3]
1068 // CHECK: bfxil x9, x10, #5, #59 // encoding: [0x49,0xfd,0x45,0xb3]
1069 // CHECK: bfxil w9, w10, #0, #32 // encoding: [0x49,0x7d,0x00,0x33]
1070 // CHECK: bfxil w11, w12, #31, #1 // encoding: [0x8b,0x7d,0x1f,0x33]
1071 // CHECK: bfxil w13, w14, #29, #3 // encoding: [0xcd,0x7d,0x1d,0x33]
1072 // CHECK: bfxil xzr, xzr, #10, #11 // encoding: [0xff,0x53,0x4a,0xb3]
1074 ubfiz w9, w10, #0, #1
1075 ubfiz x2, x3, #63, #1
1076 ubfiz x19, x20, #0, #64
1077 ubfiz x9, x10, #5, #59
1078 ubfiz w9, w10, #0, #32
1079 ubfiz w11, w12, #31, #1
1080 ubfiz w13, w14, #29, #3
1081 ubfiz xzr, xzr, #10, #11
1082 // CHECK: ubfiz w9, w10, #0, #1 // encoding: [0x49,0x01,0x00,0x53]
1083 // CHECK: ubfiz x2, x3, #63, #1 // encoding: [0x62,0x00,0x41,0xd3]
1084 // CHECK: ubfiz x19, x20, #0, #64 // encoding: [0x93,0xfe,0x40,0xd3]
1085 // CHECK: ubfiz x9, x10, #5, #59 // encoding: [0x49,0xe9,0x7b,0xd3]
1086 // CHECK: ubfiz w9, w10, #0, #32 // encoding: [0x49,0x7d,0x00,0x53]
1087 // CHECK: ubfiz w11, w12, #31, #1 // encoding: [0x8b,0x01,0x01,0x53]
1088 // CHECK: ubfiz w13, w14, #29, #3 // encoding: [0xcd,0x09,0x03,0x53]
1089 // CHECK: ubfiz xzr, xzr, #10, #11 // encoding: [0xff,0x2b,0x76,0xd3]
1091 ubfx w9, w10, #0, #1
1092 ubfx x2, x3, #63, #1
1093 ubfx x19, x20, #0, #64
1094 ubfx x9, x10, #5, #59
1095 ubfx w9, w10, #0, #32
1096 ubfx w11, w12, #31, #1
1097 ubfx w13, w14, #29, #3
1098 ubfx xzr, xzr, #10, #11
1099 // CHECK: ubfx w9, w10, #0, #1 // encoding: [0x49,0x01,0x00,0x53]
1100 // CHECK: ubfx x2, x3, #63, #1 // encoding: [0x62,0xfc,0x7f,0xd3]
1101 // CHECK: ubfx x19, x20, #0, #64 // encoding: [0x93,0xfe,0x40,0xd3]
1102 // CHECK: ubfx x9, x10, #5, #59 // encoding: [0x49,0xfd,0x45,0xd3]
1103 // CHECK: ubfx w9, w10, #0, #32 // encoding: [0x49,0x7d,0x00,0x53]
1104 // CHECK: ubfx w11, w12, #31, #1 // encoding: [0x8b,0x7d,0x1f,0x53]
1105 // CHECK: ubfx w13, w14, #29, #3 // encoding: [0xcd,0x7d,0x1d,0x53]
1106 // CHECK: ubfx xzr, xzr, #10, #11 // encoding: [0xff,0x53,0x4a,0xd3]
1108 //------------------------------------------------------------------------------
1109 // Compare & branch (immediate)
1110 //------------------------------------------------------------------------------
1116 // CHECK: cbz w5, lbl // encoding: [0x05'A',A,A,0x34'A']
1117 // CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1118 // CHECK: cbz x5, lbl // encoding: [0x05'A',A,A,0xb4'A']
1119 // CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1120 // CHECK: cbnz x2, lbl // encoding: [0x02'A',A,A,0xb5'A']
1121 // CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1122 // CHECK: cbnz x26, lbl // encoding: [0x1a'A',A,A,0xb5'A']
1123 // CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1127 // CHECK: cbz wzr, lbl // encoding: [0x1f'A',A,A,0x34'A']
1128 // CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1129 // CHECK: cbnz xzr, lbl // encoding: [0x1f'A',A,A,0xb5'A']
1130 // CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1136 // CHECK: cbz w5, #0 // encoding: [0x05,0x00,0x00,0x34]
1137 // CHECK: cbnz x3, #-4 // encoding: [0xe3,0xff,0xff,0xb5]
1138 // CHECK: cbz w20, #1048572 // encoding: [0xf4,0xff,0x7f,0x34]
1139 // CHECK: cbnz xzr, #-1048576 // encoding: [0x1f,0x00,0x80,0xb5]
1141 //------------------------------------------------------------------------------
1142 // Conditional branch (immediate)
1143 //------------------------------------------------------------------------------
1162 // CHECK: b.eq lbl // encoding: [A,A,A,0x54'A']
1163 // CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1164 // CHECK: b.ne lbl // encoding: [0x01'A',A,A,0x54'A']
1165 // CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1166 // CHECK: b.hs lbl // encoding: [0x02'A',A,A,0x54'A']
1167 // CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1168 // CHECK: b.hs lbl // encoding: [0x02'A',A,A,0x54'A']
1169 // CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1170 // CHECK: b.lo lbl // encoding: [0x03'A',A,A,0x54'A']
1171 // CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1172 // CHECK: b.lo lbl // encoding: [0x03'A',A,A,0x54'A']
1173 // CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1174 // CHECK: b.mi lbl // encoding: [0x04'A',A,A,0x54'A']
1175 // CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1176 // CHECK: b.pl lbl // encoding: [0x05'A',A,A,0x54'A']
1177 // CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1178 // CHECK: b.vs lbl // encoding: [0x06'A',A,A,0x54'A']
1179 // CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1180 // CHECK: b.vc lbl // encoding: [0x07'A',A,A,0x54'A']
1181 // CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1182 // CHECK: b.hi lbl // encoding: [0x08'A',A,A,0x54'A']
1183 // CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1184 // CHECK: b.ls lbl // encoding: [0x09'A',A,A,0x54'A']
1185 // CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1186 // CHECK: b.ge lbl // encoding: [0x0a'A',A,A,0x54'A']
1187 // CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1188 // CHECK: b.lt lbl // encoding: [0x0b'A',A,A,0x54'A']
1189 // CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1190 // CHECK: b.gt lbl // encoding: [0x0c'A',A,A,0x54'A']
1191 // CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1192 // CHECK: b.le lbl // encoding: [0x0d'A',A,A,0x54'A']
1193 // CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1194 // CHECK: b.al lbl // encoding: [0x0e'A',A,A,0x54'A']
1195 // CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1200 // CHECK: b.eq #0 // encoding: [0x00,0x00,0x00,0x54]
1201 // CHECK: b.lt #-4 // encoding: [0xeb,0xff,0xff,0x54]
1202 // CHECK: b.lo #1048572 // encoding: [0xe3,0xff,0x7f,0x54]
1204 //------------------------------------------------------------------------------
1205 // Conditional compare (immediate)
1206 //------------------------------------------------------------------------------
1208 ccmp w1, #31, #0, eq
1209 ccmp w3, #0, #15, hs
1210 ccmp wzr, #15, #13, cs
1211 // CHECK: ccmp w1, #31, #0, eq // encoding: [0x20,0x08,0x5f,0x7a]
1212 // CHECK: ccmp w3, #0, #15, hs // encoding: [0x6f,0x28,0x40,0x7a]
1213 // CHECK: ccmp wzr, #15, #13, hs // encoding: [0xed,0x2b,0x4f,0x7a]
1215 ccmp x9, #31, #0, le
1216 ccmp x3, #0, #15, gt
1217 ccmp xzr, #5, #7, ne
1218 // CHECK: ccmp x9, #31, #0, le // encoding: [0x20,0xd9,0x5f,0xfa]
1219 // CHECK: ccmp x3, #0, #15, gt // encoding: [0x6f,0xc8,0x40,0xfa]
1220 // CHECK: ccmp xzr, #5, #7, ne // encoding: [0xe7,0x1b,0x45,0xfa]
1222 ccmn w1, #31, #0, eq
1223 ccmn w3, #0, #15, hs
1224 ccmn wzr, #15, #13, cs
1225 // CHECK: ccmn w1, #31, #0, eq // encoding: [0x20,0x08,0x5f,0x3a]
1226 // CHECK: ccmn w3, #0, #15, hs // encoding: [0x6f,0x28,0x40,0x3a]
1227 // CHECK: ccmn wzr, #15, #13, hs // encoding: [0xed,0x2b,0x4f,0x3a]
1229 ccmn x9, #31, #0, le
1230 ccmn x3, #0, #15, gt
1231 ccmn xzr, #5, #7, ne
1232 // CHECK: ccmn x9, #31, #0, le // encoding: [0x20,0xd9,0x5f,0xba]
1233 // CHECK: ccmn x3, #0, #15, gt // encoding: [0x6f,0xc8,0x40,0xba]
1234 // CHECK: ccmn xzr, #5, #7, ne // encoding: [0xe7,0x1b,0x45,0xba]
1236 //------------------------------------------------------------------------------
1237 // Conditional compare (register)
1238 //------------------------------------------------------------------------------
1240 ccmp w1, wzr, #0, eq
1241 ccmp w3, w0, #15, hs
1242 ccmp wzr, w15, #13, cs
1243 // CHECK: ccmp w1, wzr, #0, eq // encoding: [0x20,0x00,0x5f,0x7a]
1244 // CHECK: ccmp w3, w0, #15, hs // encoding: [0x6f,0x20,0x40,0x7a]
1245 // CHECK: ccmp wzr, w15, #13, hs // encoding: [0xed,0x23,0x4f,0x7a]
1247 ccmp x9, xzr, #0, le
1248 ccmp x3, x0, #15, gt
1249 ccmp xzr, x5, #7, ne
1250 // CHECK: ccmp x9, xzr, #0, le // encoding: [0x20,0xd1,0x5f,0xfa]
1251 // CHECK: ccmp x3, x0, #15, gt // encoding: [0x6f,0xc0,0x40,0xfa]
1252 // CHECK: ccmp xzr, x5, #7, ne // encoding: [0xe7,0x13,0x45,0xfa]
1254 ccmn w1, wzr, #0, eq
1255 ccmn w3, w0, #15, hs
1256 ccmn wzr, w15, #13, cs
1257 // CHECK: ccmn w1, wzr, #0, eq // encoding: [0x20,0x00,0x5f,0x3a]
1258 // CHECK: ccmn w3, w0, #15, hs // encoding: [0x6f,0x20,0x40,0x3a]
1259 // CHECK: ccmn wzr, w15, #13, hs // encoding: [0xed,0x23,0x4f,0x3a]
1261 ccmn x9, xzr, #0, le
1262 ccmn x3, x0, #15, gt
1263 ccmn xzr, x5, #7, ne
1264 // CHECK: ccmn x9, xzr, #0, le // encoding: [0x20,0xd1,0x5f,0xba]
1265 // CHECK: ccmn x3, x0, #15, gt // encoding: [0x6f,0xc0,0x40,0xba]
1266 // CHECK: ccmn xzr, x5, #7, ne // encoding: [0xe7,0x13,0x45,0xba]
1268 //------------------------------------------------------------------------------
1269 // Conditional select
1270 //------------------------------------------------------------------------------
1271 csel w1, w0, w19, ne
1272 csel wzr, w5, w9, eq
1273 csel w9, wzr, w30, gt
1274 csel w1, w28, wzr, mi
1275 // CHECK: csel w1, w0, w19, ne // encoding: [0x01,0x10,0x93,0x1a]
1276 // CHECK: csel wzr, w5, w9, eq // encoding: [0xbf,0x00,0x89,0x1a]
1277 // CHECK: csel w9, wzr, w30, gt // encoding: [0xe9,0xc3,0x9e,0x1a]
1278 // CHECK: csel w1, w28, wzr, mi // encoding: [0x81,0x43,0x9f,0x1a]
1280 csel x19, x23, x29, lt
1281 csel xzr, x3, x4, ge
1282 csel x5, xzr, x6, cs
1283 csel x7, x8, xzr, cc
1284 // CHECK: csel x19, x23, x29, lt // encoding: [0xf3,0xb2,0x9d,0x9a]
1285 // CHECK: csel xzr, x3, x4, ge // encoding: [0x7f,0xa0,0x84,0x9a]
1286 // CHECK: csel x5, xzr, x6, hs // encoding: [0xe5,0x23,0x86,0x9a]
1287 // CHECK: csel x7, x8, xzr, lo // encoding: [0x07,0x31,0x9f,0x9a]
1289 csinc w1, w0, w19, ne
1290 csinc wzr, w5, w9, eq
1291 csinc w9, wzr, w30, gt
1292 csinc w1, w28, wzr, mi
1293 // CHECK: csinc w1, w0, w19, ne // encoding: [0x01,0x14,0x93,0x1a]
1294 // CHECK: csinc wzr, w5, w9, eq // encoding: [0xbf,0x04,0x89,0x1a]
1295 // CHECK: csinc w9, wzr, w30, gt // encoding: [0xe9,0xc7,0x9e,0x1a]
1296 // CHECK: csinc w1, w28, wzr, mi // encoding: [0x81,0x47,0x9f,0x1a]
1298 csinc x19, x23, x29, lt
1299 csinc xzr, x3, x4, ge
1300 csinc x5, xzr, x6, cs
1301 csinc x7, x8, xzr, cc
1302 // CHECK: csinc x19, x23, x29, lt // encoding: [0xf3,0xb6,0x9d,0x9a]
1303 // CHECK: csinc xzr, x3, x4, ge // encoding: [0x7f,0xa4,0x84,0x9a]
1304 // CHECK: csinc x5, xzr, x6, hs // encoding: [0xe5,0x27,0x86,0x9a]
1305 // CHECK: csinc x7, x8, xzr, lo // encoding: [0x07,0x35,0x9f,0x9a]
1307 csinv w1, w0, w19, ne
1308 csinv wzr, w5, w9, eq
1309 csinv w9, wzr, w30, gt
1310 csinv w1, w28, wzr, mi
1311 // CHECK: csinv w1, w0, w19, ne // encoding: [0x01,0x10,0x93,0x5a]
1312 // CHECK: csinv wzr, w5, w9, eq // encoding: [0xbf,0x00,0x89,0x5a]
1313 // CHECK: csinv w9, wzr, w30, gt // encoding: [0xe9,0xc3,0x9e,0x5a]
1314 // CHECK: csinv w1, w28, wzr, mi // encoding: [0x81,0x43,0x9f,0x5a]
1316 csinv x19, x23, x29, lt
1317 csinv xzr, x3, x4, ge
1318 csinv x5, xzr, x6, cs
1319 csinv x7, x8, xzr, cc
1320 // CHECK: csinv x19, x23, x29, lt // encoding: [0xf3,0xb2,0x9d,0xda]
1321 // CHECK: csinv xzr, x3, x4, ge // encoding: [0x7f,0xa0,0x84,0xda]
1322 // CHECK: csinv x5, xzr, x6, hs // encoding: [0xe5,0x23,0x86,0xda]
1323 // CHECK: csinv x7, x8, xzr, lo // encoding: [0x07,0x31,0x9f,0xda]
1325 csneg w1, w0, w19, ne
1326 csneg wzr, w5, w9, eq
1327 csneg w9, wzr, w30, gt
1328 csneg w1, w28, wzr, mi
1329 // CHECK: csneg w1, w0, w19, ne // encoding: [0x01,0x14,0x93,0x5a]
1330 // CHECK: csneg wzr, w5, w9, eq // encoding: [0xbf,0x04,0x89,0x5a]
1331 // CHECK: csneg w9, wzr, w30, gt // encoding: [0xe9,0xc7,0x9e,0x5a]
1332 // CHECK: csneg w1, w28, wzr, mi // encoding: [0x81,0x47,0x9f,0x5a]
1334 csneg x19, x23, x29, lt
1335 csneg xzr, x3, x4, ge
1336 csneg x5, xzr, x6, cs
1337 csneg x7, x8, xzr, cc
1338 // CHECK: csneg x19, x23, x29, lt // encoding: [0xf3,0xb6,0x9d,0xda]
1339 // CHECK: csneg xzr, x3, x4, ge // encoding: [0x7f,0xa4,0x84,0xda]
1340 // CHECK: csneg x5, xzr, x6, hs // encoding: [0xe5,0x27,0x86,0xda]
1341 // CHECK: csneg x7, x8, xzr, lo // encoding: [0x07,0x35,0x9f,0xda]
1345 // CHECK: csinc w3, wzr, wzr, ne // encoding: [0xe3,0x17,0x9f,0x1a]
1346 // CHECK: csinc x9, xzr, xzr, mi // encoding: [0xe9,0x47,0x9f,0x9a]
1350 // CHECK: csinv w20, wzr, wzr, eq // encoding: [0xf4,0x03,0x9f,0x5a]
1351 // CHECK: csinv x30, xzr, xzr, lt // encoding: [0xfe,0xb3,0x9f,0xda]
1356 // CHECK: csinc w3, w5, w5, le // encoding: [0xa3,0xd4,0x85,0x1a]
1357 // CHECK: csinc wzr, w4, w4, gt // encoding: [0x9f,0xc4,0x84,0x1a]
1358 // CHECK: csinc w9, wzr, wzr, ge // encoding: [0xe9,0xa7,0x9f,0x1a]
1363 // CHECK: csinc x3, x5, x5, le // encoding: [0xa3,0xd4,0x85,0x9a]
1364 // CHECK: csinc xzr, x4, x4, gt // encoding: [0x9f,0xc4,0x84,0x9a]
1365 // CHECK: csinc x9, xzr, xzr, ge // encoding: [0xe9,0xa7,0x9f,0x9a]
1370 // CHECK: csinv w3, w5, w5, le // encoding: [0xa3,0xd0,0x85,0x5a]
1371 // CHECK: csinv wzr, w4, w4, gt // encoding: [0x9f,0xc0,0x84,0x5a]
1372 // CHECK: csinv w9, wzr, wzr, ge // encoding: [0xe9,0xa3,0x9f,0x5a]
1377 // CHECK: csinv x3, x5, x5, le // encoding: [0xa3,0xd0,0x85,0xda]
1378 // CHECK: csinv xzr, x4, x4, gt // encoding: [0x9f,0xc0,0x84,0xda]
1379 // CHECK: csinv x9, xzr, xzr, ge // encoding: [0xe9,0xa3,0x9f,0xda]
1384 // CHECK: csneg w3, w5, w5, le // encoding: [0xa3,0xd4,0x85,0x5a]
1385 // CHECK: csneg wzr, w4, w4, gt // encoding: [0x9f,0xc4,0x84,0x5a]
1386 // CHECK: csneg w9, wzr, wzr, ge // encoding: [0xe9,0xa7,0x9f,0x5a]
1391 // CHECK: csneg x3, x5, x5, le // encoding: [0xa3,0xd4,0x85,0xda]
1392 // CHECK: csneg xzr, x4, x4, gt // encoding: [0x9f,0xc4,0x84,0xda]
1393 // CHECK: csneg x9, xzr, xzr, ge // encoding: [0xe9,0xa7,0x9f,0xda]
1395 //------------------------------------------------------------------------------
1396 // Data-processing (1 source)
1397 //------------------------------------------------------------------------------
1406 // CHECK: rbit w0, w7 // encoding: [0xe0,0x00,0xc0,0x5a]
1407 // CHECK: rbit x18, x3 // encoding: [0x72,0x00,0xc0,0xda]
1408 // CHECK: rev16 w17, w1 // encoding: [0x31,0x04,0xc0,0x5a]
1409 // CHECK: rev16 x5, x2 // encoding: [0x45,0x04,0xc0,0xda]
1410 // CHECK: rev w18, w0 // encoding: [0x12,0x08,0xc0,0x5a]
1411 // CHECK: rev32 x20, x1 // encoding: [0x34,0x08,0xc0,0xda]
1412 // CHECK: rev32 x20, xzr // encoding: [0xf4,0x0b,0xc0,0xda]
1421 // CHECK: rev x22, x2 // encoding: [0x56,0x0c,0xc0,0xda]
1422 // CHECK: rev x18, xzr // encoding: [0xf2,0x0f,0xc0,0xda]
1423 // CHECK: rev w7, wzr // encoding: [0xe7,0x0b,0xc0,0x5a]
1424 // CHECK: clz w24, w3 // encoding: [0x78,0x10,0xc0,0x5a]
1425 // CHECK: clz x26, x4 // encoding: [0x9a,0x10,0xc0,0xda]
1426 // CHECK: cls w3, w5 // encoding: [0xa3,0x14,0xc0,0x5a]
1427 // CHECK: cls x20, x5 // encoding: [0xb4,0x14,0xc0,0xda]
1431 // CHECK: clz w24, wzr // encoding: [0xf8,0x13,0xc0,0x5a]
1432 // CHECK: rev x22, xzr // encoding: [0xf6,0x0f,0xc0,0xda]
1434 //------------------------------------------------------------------------------
1435 // Data-processing (2 source)
1436 //------------------------------------------------------------------------------
1452 // CHECK: udiv w0, w7, w10 // encoding: [0xe0,0x08,0xca,0x1a]
1453 // CHECK: udiv x9, x22, x4 // encoding: [0xc9,0x0a,0xc4,0x9a]
1454 // CHECK: sdiv w12, w21, w0 // encoding: [0xac,0x0e,0xc0,0x1a]
1455 // CHECK: sdiv x13, x2, x1 // encoding: [0x4d,0x0c,0xc1,0x9a]
1456 // CHECK: lsl w11, w12, w13 // encoding: [0x8b,0x21,0xcd,0x1a]
1457 // CHECK: lsl x14, x15, x16 // encoding: [0xee,0x21,0xd0,0x9a]
1458 // CHECK: lsr w17, w18, w19 // encoding: [0x51,0x26,0xd3,0x1a]
1459 // CHECK: lsr x20, x21, x22 // encoding: [0xb4,0x26,0xd6,0x9a]
1460 // CHECK: asr w23, w24, w25 // encoding: [0x17,0x2b,0xd9,0x1a]
1461 // CHECK: asr x26, x27, x28 // encoding: [0x7a,0x2b,0xdc,0x9a]
1462 // CHECK: ror w0, w1, w2 // encoding: [0x20,0x2c,0xc2,0x1a]
1463 // CHECK: ror x3, x4, x5 // encoding: [0x83,0x2c,0xc5,0x9a]
1474 // CHECK: lsl w6, w7, w8 // encoding: [0xe6,0x20,0xc8,0x1a]
1475 // CHECK: lsl x9, x10, x11 // encoding: [0x49,0x21,0xcb,0x9a]
1476 // CHECK: lsr w12, w13, w14 // encoding: [0xac,0x25,0xce,0x1a]
1477 // CHECK: lsr x15, x16, x17 // encoding: [0x0f,0x26,0xd1,0x9a]
1478 // CHECK: asr w18, w19, w20 // encoding: [0x72,0x2a,0xd4,0x1a]
1479 // CHECK: asr x21, x22, x23 // encoding: [0xd5,0x2a,0xd7,0x9a]
1480 // CHECK: ror w24, w25, w26 // encoding: [0x38,0x2f,0xda,0x1a]
1481 // CHECK: ror x27, x28, x29 // encoding: [0x9b,0x2f,0xdd,0x9a]
1484 madd wzr, w0, w9, w11
1485 madd w13, wzr, w4, w4
1486 madd w19, w30, wzr, w29
1487 madd w4, w5, w6, wzr
1488 // CHECK: madd w1, w3, w7, w4 // encoding: [0x61,0x10,0x07,0x1b]
1489 // CHECK: madd wzr, w0, w9, w11 // encoding: [0x1f,0x2c,0x09,0x1b]
1490 // CHECK: madd w13, wzr, w4, w4 // encoding: [0xed,0x13,0x04,0x1b]
1491 // CHECK: madd w19, w30, wzr, w29 // encoding: [0xd3,0x77,0x1f,0x1b]
1492 // CHECK: mul w4, w5, w6 // encoding: [0xa4,0x7c,0x06,0x1b]
1495 madd xzr, x0, x9, x11
1496 madd x13, xzr, x4, x4
1497 madd x19, x30, xzr, x29
1498 madd x4, x5, x6, xzr
1499 // CHECK: madd x1, x3, x7, x4 // encoding: [0x61,0x10,0x07,0x9b]
1500 // CHECK: madd xzr, x0, x9, x11 // encoding: [0x1f,0x2c,0x09,0x9b]
1501 // CHECK: madd x13, xzr, x4, x4 // encoding: [0xed,0x13,0x04,0x9b]
1502 // CHECK: madd x19, x30, xzr, x29 // encoding: [0xd3,0x77,0x1f,0x9b]
1503 // CHECK: mul x4, x5, x6 // encoding: [0xa4,0x7c,0x06,0x9b]
1506 msub wzr, w0, w9, w11
1507 msub w13, wzr, w4, w4
1508 msub w19, w30, wzr, w29
1509 msub w4, w5, w6, wzr
1510 // CHECK: msub w1, w3, w7, w4 // encoding: [0x61,0x90,0x07,0x1b]
1511 // CHECK: msub wzr, w0, w9, w11 // encoding: [0x1f,0xac,0x09,0x1b]
1512 // CHECK: msub w13, wzr, w4, w4 // encoding: [0xed,0x93,0x04,0x1b]
1513 // CHECK: msub w19, w30, wzr, w29 // encoding: [0xd3,0xf7,0x1f,0x1b]
1514 // CHECK: mneg w4, w5, w6 // encoding: [0xa4,0xfc,0x06,0x1b]
1517 msub xzr, x0, x9, x11
1518 msub x13, xzr, x4, x4
1519 msub x19, x30, xzr, x29
1520 msub x4, x5, x6, xzr
1521 // CHECK: msub x1, x3, x7, x4 // encoding: [0x61,0x90,0x07,0x9b]
1522 // CHECK: msub xzr, x0, x9, x11 // encoding: [0x1f,0xac,0x09,0x9b]
1523 // CHECK: msub x13, xzr, x4, x4 // encoding: [0xed,0x93,0x04,0x9b]
1524 // CHECK: msub x19, x30, xzr, x29 // encoding: [0xd3,0xf7,0x1f,0x9b]
1525 // CHECK: mneg x4, x5, x6 // encoding: [0xa4,0xfc,0x06,0x9b]
1527 smaddl x3, w5, w2, x9
1528 smaddl xzr, w10, w11, x12
1529 smaddl x13, wzr, w14, x15
1530 smaddl x16, w17, wzr, x18
1531 smaddl x19, w20, w21, xzr
1532 // CHECK: smaddl x3, w5, w2, x9 // encoding: [0xa3,0x24,0x22,0x9b]
1533 // CHECK: smaddl xzr, w10, w11, x12 // encoding: [0x5f,0x31,0x2b,0x9b]
1534 // CHECK: smaddl x13, wzr, w14, x15 // encoding: [0xed,0x3f,0x2e,0x9b]
1535 // CHECK: smaddl x16, w17, wzr, x18 // encoding: [0x30,0x4a,0x3f,0x9b]
1536 // CHECK: smull x19, w20, w21 // encoding: [0x93,0x7e,0x35,0x9b]
1538 smsubl x3, w5, w2, x9
1539 smsubl xzr, w10, w11, x12
1540 smsubl x13, wzr, w14, x15
1541 smsubl x16, w17, wzr, x18
1542 smsubl x19, w20, w21, xzr
1543 // CHECK: smsubl x3, w5, w2, x9 // encoding: [0xa3,0xa4,0x22,0x9b]
1544 // CHECK: smsubl xzr, w10, w11, x12 // encoding: [0x5f,0xb1,0x2b,0x9b]
1545 // CHECK: smsubl x13, wzr, w14, x15 // encoding: [0xed,0xbf,0x2e,0x9b]
1546 // CHECK: smsubl x16, w17, wzr, x18 // encoding: [0x30,0xca,0x3f,0x9b]
1547 // CHECK: smnegl x19, w20, w21 // encoding: [0x93,0xfe,0x35,0x9b]
1549 umaddl x3, w5, w2, x9
1550 umaddl xzr, w10, w11, x12
1551 umaddl x13, wzr, w14, x15
1552 umaddl x16, w17, wzr, x18
1553 umaddl x19, w20, w21, xzr
1554 // CHECK: umaddl x3, w5, w2, x9 // encoding: [0xa3,0x24,0xa2,0x9b]
1555 // CHECK: umaddl xzr, w10, w11, x12 // encoding: [0x5f,0x31,0xab,0x9b]
1556 // CHECK: umaddl x13, wzr, w14, x15 // encoding: [0xed,0x3f,0xae,0x9b]
1557 // CHECK: umaddl x16, w17, wzr, x18 // encoding: [0x30,0x4a,0xbf,0x9b]
1558 // CHECK: umull x19, w20, w21 // encoding: [0x93,0x7e,0xb5,0x9b]
1562 umsubl x3, w5, w2, x9
1563 umsubl xzr, w10, w11, x12
1564 umsubl x13, wzr, w14, x15
1565 umsubl x16, w17, wzr, x18
1566 umsubl x19, w20, w21, xzr
1567 // CHECK: umsubl x3, w5, w2, x9 // encoding: [0xa3,0xa4,0xa2,0x9b]
1568 // CHECK: umsubl xzr, w10, w11, x12 // encoding: [0x5f,0xb1,0xab,0x9b]
1569 // CHECK: umsubl x13, wzr, w14, x15 // encoding: [0xed,0xbf,0xae,0x9b]
1570 // CHECK: umsubl x16, w17, wzr, x18 // encoding: [0x30,0xca,0xbf,0x9b]
1571 // CHECK: umnegl x19, w20, w21 // encoding: [0x93,0xfe,0xb5,0x9b]
1577 // CHECK: smulh x30, x29, x28 // encoding: [0xbe,0x7f,0x5c,0x9b]
1578 // CHECK: smulh xzr, x27, x26 // encoding: [0x7f,0x7f,0x5a,0x9b]
1579 // CHECK: smulh x25, xzr, x24 // encoding: [0xf9,0x7f,0x58,0x9b]
1580 // CHECK: smulh x23, x22, xzr // encoding: [0xd7,0x7e,0x5f,0x9b]
1586 // CHECK: umulh x30, x29, x28 // encoding: [0xbe,0x7f,0xdc,0x9b]
1587 // CHECK: umulh xzr, x27, x26 // encoding: [0x7f,0x7f,0xda,0x9b]
1588 // CHECK: umulh x25, xzr, x24 // encoding: [0xf9,0x7f,0xd8,0x9b]
1589 // CHECK: umulh x23, x22, xzr // encoding: [0xd7,0x7e,0xdf,0x9b]
1608 smnegl x11, w13, w17
1609 umnegl x11, w13, w17
1610 // CHECK: mul w3, w4, w5 // encoding: [0x83,0x7c,0x05,0x1b]
1611 // CHECK: mul wzr, w6, w7 // encoding: [0xdf,0x7c,0x07,0x1b]
1612 // CHECK: mul w8, wzr, w9 // encoding: [0xe8,0x7f,0x09,0x1b]
1613 // CHECK: mul w10, w11, wzr // encoding: [0x6a,0x7d,0x1f,0x1b]
1614 // CHECK: mul x12, x13, x14 // encoding: [0xac,0x7d,0x0e,0x9b]
1615 // CHECK: mul xzr, x15, x16 // encoding: [0xff,0x7d,0x10,0x9b]
1616 // CHECK: mul x17, xzr, x18 // encoding: [0xf1,0x7f,0x12,0x9b]
1617 // CHECK: mul x19, x20, xzr // encoding: [0x93,0x7e,0x1f,0x9b]
1618 // CHECK: mneg w21, w22, w23 // encoding: [0xd5,0xfe,0x17,0x1b]
1619 // CHECK: mneg wzr, w24, w25 // encoding: [0x1f,0xff,0x19,0x1b]
1620 // CHECK: mneg w26, wzr, w27 // encoding: [0xfa,0xff,0x1b,0x1b]
1621 // CHECK: mneg w28, w29, wzr // encoding: [0xbc,0xff,0x1f,0x1b]
1622 // CHECK: smull x11, w13, w17 // encoding: [0xab,0x7d,0x31,0x9b]
1623 // CHECK: umull x11, w13, w17 // encoding: [0xab,0x7d,0xb1,0x9b]
1624 // CHECK: smnegl x11, w13, w17 // encoding: [0xab,0xfd,0x31,0x9b]
1625 // CHECK: umnegl x11, w13, w17 // encoding: [0xab,0xfd,0xb1,0x9b]
1627 //------------------------------------------------------------------------------
1628 // Exception generation
1629 //------------------------------------------------------------------------------
1632 // CHECK: svc #0 // encoding: [0x01,0x00,0x00,0xd4]
1633 // CHECK: svc #65535 // encoding: [0xe1,0xff,0x1f,0xd4]
1639 // CHECK: hvc #1 // encoding: [0x22,0x00,0x00,0xd4]
1640 // CHECK: smc #12000 // encoding: [0x03,0xdc,0x05,0xd4]
1641 // CHECK: brk #12 // encoding: [0x80,0x01,0x20,0xd4]
1642 // CHECK: hlt #123 // encoding: [0x60,0x0f,0x40,0xd4]
1647 // CHECK: dcps1 #42 // encoding: [0x41,0x05,0xa0,0xd4]
1648 // CHECK: dcps2 #9 // encoding: [0x22,0x01,0xa0,0xd4]
1649 // CHECK: dcps3 #1000 // encoding: [0x03,0x7d,0xa0,0xd4]
1654 // CHECK: dcps1 // encoding: [0x01,0x00,0xa0,0xd4]
1655 // CHECK: dcps2 // encoding: [0x02,0x00,0xa0,0xd4]
1656 // CHECK: dcps3 // encoding: [0x03,0x00,0xa0,0xd4]
1658 //------------------------------------------------------------------------------
1659 // Extract (immediate)
1660 //------------------------------------------------------------------------------
1663 extr w11, w13, w17, #31
1664 // CHECK: extr w3, w5, w7, #0 // encoding: [0xa3,0x00,0x87,0x13]
1665 // CHECK: extr w11, w13, w17, #31 // encoding: [0xab,0x7d,0x91,0x13]
1667 extr x3, x5, x7, #15
1668 extr x11, x13, x17, #63
1669 // CHECK: extr x3, x5, x7, #15 // encoding: [0xa3,0x3c,0xc7,0x93]
1670 // CHECK: extr x11, x13, x17, #63 // encoding: [0xab,0xfd,0xd1,0x93]
1674 // CHECK: extr x19, x23, x23, #24 // encoding: [0xf3,0x62,0xd7,0x93]
1675 // CHECK: extr x29, xzr, xzr, #63 // encoding: [0xfd,0xff,0xdf,0x93]
1678 // CHECK: extr w9, w13, w13, #31 // encoding: [0xa9,0x7d,0x8d,0x13]
1680 //------------------------------------------------------------------------------
1681 // Floating-point compare
1682 //------------------------------------------------------------------------------
1686 // CHECK: fcmp s3, s5 // encoding: [0x60,0x20,0x25,0x1e]
1687 // CHECK: fcmp s31, #0.0 // encoding: [0xe8,0x23,0x20,0x1e]
1691 // CHECK: fcmpe s29, s30 // encoding: [0xb0,0x23,0x3e,0x1e]
1692 // CHECK: fcmpe s15, #0.0 // encoding: [0xf8,0x21,0x20,0x1e]
1696 // CHECK: fcmp d4, d12 // encoding: [0x80,0x20,0x6c,0x1e]
1697 // CHECK: fcmp d23, #0.0 // encoding: [0xe8,0x22,0x60,0x1e]
1701 // CHECK: fcmpe d26, d22 // encoding: [0x50,0x23,0x76,0x1e]
1702 // CHECK: fcmpe d29, #0.0 // encoding: [0xb8,0x23,0x60,0x1e]
1704 //------------------------------------------------------------------------------
1705 // Floating-point conditional compare
1706 //------------------------------------------------------------------------------
1708 fccmp s1, s31, #0, eq
1709 fccmp s3, s0, #15, hs
1710 fccmp s31, s15, #13, cs
1711 // CHECK: fccmp s1, s31, #0, eq // encoding: [0x20,0x04,0x3f,0x1e]
1712 // CHECK: fccmp s3, s0, #15, hs // encoding: [0x6f,0x24,0x20,0x1e]
1713 // CHECK: fccmp s31, s15, #13, hs // encoding: [0xed,0x27,0x2f,0x1e]
1715 fccmp d9, d31, #0, le
1716 fccmp d3, d0, #15, gt
1717 fccmp d31, d5, #7, ne
1718 // CHECK: fccmp d9, d31, #0, le // encoding: [0x20,0xd5,0x7f,0x1e]
1719 // CHECK: fccmp d3, d0, #15, gt // encoding: [0x6f,0xc4,0x60,0x1e]
1720 // CHECK: fccmp d31, d5, #7, ne // encoding: [0xe7,0x17,0x65,0x1e]
1722 fccmpe s1, s31, #0, eq
1723 fccmpe s3, s0, #15, hs
1724 fccmpe s31, s15, #13, cs
1725 // CHECK: fccmpe s1, s31, #0, eq // encoding: [0x30,0x04,0x3f,0x1e]
1726 // CHECK: fccmpe s3, s0, #15, hs // encoding: [0x7f,0x24,0x20,0x1e]
1727 // CHECK: fccmpe s31, s15, #13, hs // encoding: [0xfd,0x27,0x2f,0x1e]
1729 fccmpe d9, d31, #0, le
1730 fccmpe d3, d0, #15, gt
1731 fccmpe d31, d5, #7, ne
1732 // CHECK: fccmpe d9, d31, #0, le // encoding: [0x30,0xd5,0x7f,0x1e]
1733 // CHECK: fccmpe d3, d0, #15, gt // encoding: [0x7f,0xc4,0x60,0x1e]
1734 // CHECK: fccmpe d31, d5, #7, ne // encoding: [0xf7,0x17,0x65,0x1e]
1736 //------------------------------------------------------------------------------
1737 // Floating-point conditional compare
1738 //------------------------------------------------------------------------------
1740 fcsel s3, s20, s9, pl
1741 fcsel d9, d10, d11, mi
1742 // CHECK: fcsel s3, s20, s9, pl // encoding: [0x83,0x5e,0x29,0x1e]
1743 // CHECK: fcsel d9, d10, d11, mi // encoding: [0x49,0x4d,0x6b,0x1e]
1745 //------------------------------------------------------------------------------
1746 // Floating-point data-processing (1 source)
1747 //------------------------------------------------------------------------------
1762 // CHECK: fmov s0, s1 // encoding: [0x20,0x40,0x20,0x1e]
1763 // CHECK: fabs s2, s3 // encoding: [0x62,0xc0,0x20,0x1e]
1764 // CHECK: fneg s4, s5 // encoding: [0xa4,0x40,0x21,0x1e]
1765 // CHECK: fsqrt s6, s7 // encoding: [0xe6,0xc0,0x21,0x1e]
1766 // CHECK: fcvt d8, s9 // encoding: [0x28,0xc1,0x22,0x1e]
1767 // CHECK: fcvt h10, s11 // encoding: [0x6a,0xc1,0x23,0x1e]
1768 // CHECK: frintn s12, s13 // encoding: [0xac,0x41,0x24,0x1e]
1769 // CHECK: frintp s14, s15 // encoding: [0xee,0xc1,0x24,0x1e]
1770 // CHECK: frintm s16, s17 // encoding: [0x30,0x42,0x25,0x1e]
1771 // CHECK: frintz s18, s19 // encoding: [0x72,0xc2,0x25,0x1e]
1772 // CHECK: frinta s20, s21 // encoding: [0xb4,0x42,0x26,0x1e]
1773 // CHECK: frintx s22, s23 // encoding: [0xf6,0x42,0x27,0x1e]
1774 // CHECK: frinti s24, s25 // encoding: [0x38,0xc3,0x27,0x1e]
1789 // CHECK: fmov d0, d1 // encoding: [0x20,0x40,0x60,0x1e]
1790 // CHECK: fabs d2, d3 // encoding: [0x62,0xc0,0x60,0x1e]
1791 // CHECK: fneg d4, d5 // encoding: [0xa4,0x40,0x61,0x1e]
1792 // CHECK: fsqrt d6, d7 // encoding: [0xe6,0xc0,0x61,0x1e]
1793 // CHECK: fcvt s8, d9 // encoding: [0x28,0x41,0x62,0x1e]
1794 // CHECK: fcvt h10, d11 // encoding: [0x6a,0xc1,0x63,0x1e]
1795 // CHECK: frintn d12, d13 // encoding: [0xac,0x41,0x64,0x1e]
1796 // CHECK: frintp d14, d15 // encoding: [0xee,0xc1,0x64,0x1e]
1797 // CHECK: frintm d16, d17 // encoding: [0x30,0x42,0x65,0x1e]
1798 // CHECK: frintz d18, d19 // encoding: [0x72,0xc2,0x65,0x1e]
1799 // CHECK: frinta d20, d21 // encoding: [0xb4,0x42,0x66,0x1e]
1800 // CHECK: frintx d22, d23 // encoding: [0xf6,0x42,0x67,0x1e]
1801 // CHECK: frinti d24, d25 // encoding: [0x38,0xc3,0x67,0x1e]
1805 // CHECK: fcvt s26, h27 // encoding: [0x7a,0x43,0xe2,0x1e]
1806 // CHECK: fcvt d28, h29 // encoding: [0xbc,0xc3,0xe2,0x1e]
1808 //------------------------------------------------------------------------------
1809 // Floating-point data-processing (2 sources)
1810 //------------------------------------------------------------------------------
1818 fmaxnm s16, s17, s18
1819 fminnm s19, s20, s21
1821 // CHECK: fmul s20, s19, s17 // encoding: [0x74,0x0a,0x31,0x1e]
1822 // CHECK: fdiv s1, s2, s3 // encoding: [0x41,0x18,0x23,0x1e]
1823 // CHECK: fadd s4, s5, s6 // encoding: [0xa4,0x28,0x26,0x1e]
1824 // CHECK: fsub s7, s8, s9 // encoding: [0x07,0x39,0x29,0x1e]
1825 // CHECK: fmax s10, s11, s12 // encoding: [0x6a,0x49,0x2c,0x1e]
1826 // CHECK: fmin s13, s14, s15 // encoding: [0xcd,0x59,0x2f,0x1e]
1827 // CHECK: fmaxnm s16, s17, s18 // encoding: [0x30,0x6a,0x32,0x1e]
1828 // CHECK: fminnm s19, s20, s21 // encoding: [0x93,0x7a,0x35,0x1e]
1829 // CHECK: fnmul s22, s23, s24 // encoding: [0xf6,0x8a,0x38,0x1e]
1837 fmaxnm d16, d17, d18
1838 fminnm d19, d20, d21
1840 // CHECK: fmul d20, d19, d17 // encoding: [0x74,0x0a,0x71,0x1e]
1841 // CHECK: fdiv d1, d2, d3 // encoding: [0x41,0x18,0x63,0x1e]
1842 // CHECK: fadd d4, d5, d6 // encoding: [0xa4,0x28,0x66,0x1e]
1843 // CHECK: fsub d7, d8, d9 // encoding: [0x07,0x39,0x69,0x1e]
1844 // CHECK: fmax d10, d11, d12 // encoding: [0x6a,0x49,0x6c,0x1e]
1845 // CHECK: fmin d13, d14, d15 // encoding: [0xcd,0x59,0x6f,0x1e]
1846 // CHECK: fmaxnm d16, d17, d18 // encoding: [0x30,0x6a,0x72,0x1e]
1847 // CHECK: fminnm d19, d20, d21 // encoding: [0x93,0x7a,0x75,0x1e]
1848 // CHECK: fnmul d22, d23, d24 // encoding: [0xf6,0x8a,0x78,0x1e]
1850 //------------------------------------------------------------------------------
1851 // Floating-point data-processing (3 sources)
1852 //------------------------------------------------------------------------------
1854 fmadd s3, s5, s6, s31
1855 fmadd d3, d13, d0, d23
1856 fmsub s3, s5, s6, s31
1857 fmsub d3, d13, d0, d23
1858 fnmadd s3, s5, s6, s31
1859 fnmadd d3, d13, d0, d23
1860 fnmsub s3, s5, s6, s31
1861 fnmsub d3, d13, d0, d23
1862 // CHECK: fmadd s3, s5, s6, s31 // encoding: [0xa3,0x7c,0x06,0x1f]
1863 // CHECK: fmadd d3, d13, d0, d23 // encoding: [0xa3,0x5d,0x40,0x1f]
1864 // CHECK: fmsub s3, s5, s6, s31 // encoding: [0xa3,0xfc,0x06,0x1f]
1865 // CHECK: fmsub d3, d13, d0, d23 // encoding: [0xa3,0xdd,0x40,0x1f]
1866 // CHECK: fnmadd s3, s5, s6, s31 // encoding: [0xa3,0x7c,0x26,0x1f]
1867 // CHECK: fnmadd d3, d13, d0, d23 // encoding: [0xa3,0x5d,0x60,0x1f]
1868 // CHECK: fnmsub s3, s5, s6, s31 // encoding: [0xa3,0xfc,0x26,0x1f]
1869 // CHECK: fnmsub d3, d13, d0, d23 // encoding: [0xa3,0xdd,0x60,0x1f]
1871 //------------------------------------------------------------------------------
1872 // Floating-point <-> fixed-point conversion
1873 //------------------------------------------------------------------------------
1876 fcvtzs wzr, s20, #13
1878 // CHECK: fcvtzs w3, s5, #1 // encoding: [0xa3,0xfc,0x18,0x1e]
1879 // CHECK: fcvtzs wzr, s20, #13 // encoding: [0x9f,0xce,0x18,0x1e]
1880 // CHECK: fcvtzs w19, s0, #32 // encoding: [0x13,0x80,0x18,0x1e]
1883 fcvtzs x12, s30, #45
1885 // CHECK: fcvtzs x3, s5, #1 // encoding: [0xa3,0xfc,0x18,0x9e]
1886 // CHECK: fcvtzs x12, s30, #45 // encoding: [0xcc,0x4f,0x18,0x9e]
1887 // CHECK: fcvtzs x19, s0, #64 // encoding: [0x13,0x00,0x18,0x9e]
1890 fcvtzs wzr, d20, #13
1892 // CHECK: fcvtzs w3, d5, #1 // encoding: [0xa3,0xfc,0x58,0x1e]
1893 // CHECK: fcvtzs wzr, d20, #13 // encoding: [0x9f,0xce,0x58,0x1e]
1894 // CHECK: fcvtzs w19, d0, #32 // encoding: [0x13,0x80,0x58,0x1e]
1897 fcvtzs x12, d30, #45
1899 // CHECK: fcvtzs x3, d5, #1 // encoding: [0xa3,0xfc,0x58,0x9e]
1900 // CHECK: fcvtzs x12, d30, #45 // encoding: [0xcc,0x4f,0x58,0x9e]
1901 // CHECK: fcvtzs x19, d0, #64 // encoding: [0x13,0x00,0x58,0x9e]
1904 fcvtzu wzr, s20, #13
1906 // CHECK: fcvtzu w3, s5, #1 // encoding: [0xa3,0xfc,0x19,0x1e]
1907 // CHECK: fcvtzu wzr, s20, #13 // encoding: [0x9f,0xce,0x19,0x1e]
1908 // CHECK: fcvtzu w19, s0, #32 // encoding: [0x13,0x80,0x19,0x1e]
1911 fcvtzu x12, s30, #45
1913 // CHECK: fcvtzu x3, s5, #1 // encoding: [0xa3,0xfc,0x19,0x9e]
1914 // CHECK: fcvtzu x12, s30, #45 // encoding: [0xcc,0x4f,0x19,0x9e]
1915 // CHECK: fcvtzu x19, s0, #64 // encoding: [0x13,0x00,0x19,0x9e]
1918 fcvtzu wzr, d20, #13
1920 // CHECK: fcvtzu w3, d5, #1 // encoding: [0xa3,0xfc,0x59,0x1e]
1921 // CHECK: fcvtzu wzr, d20, #13 // encoding: [0x9f,0xce,0x59,0x1e]
1922 // CHECK: fcvtzu w19, d0, #32 // encoding: [0x13,0x80,0x59,0x1e]
1925 fcvtzu x12, d30, #45
1927 // CHECK: fcvtzu x3, d5, #1 // encoding: [0xa3,0xfc,0x59,0x9e]
1928 // CHECK: fcvtzu x12, d30, #45 // encoding: [0xcc,0x4f,0x59,0x9e]
1929 // CHECK: fcvtzu x19, d0, #64 // encoding: [0x13,0x00,0x59,0x9e]
1934 // CHECK: scvtf s23, w19, #1 // encoding: [0x77,0xfe,0x02,0x1e]
1935 // CHECK: scvtf s31, wzr, #20 // encoding: [0xff,0xb3,0x02,0x1e]
1936 // CHECK: scvtf s14, w0, #32 // encoding: [0x0e,0x80,0x02,0x1e]
1941 // CHECK: scvtf s23, x19, #1 // encoding: [0x77,0xfe,0x02,0x9e]
1942 // CHECK: scvtf s31, xzr, #20 // encoding: [0xff,0xb3,0x02,0x9e]
1943 // CHECK: scvtf s14, x0, #64 // encoding: [0x0e,0x00,0x02,0x9e]
1948 // CHECK: scvtf d23, w19, #1 // encoding: [0x77,0xfe,0x42,0x1e]
1949 // CHECK: scvtf d31, wzr, #20 // encoding: [0xff,0xb3,0x42,0x1e]
1950 // CHECK: scvtf d14, w0, #32 // encoding: [0x0e,0x80,0x42,0x1e]
1955 // CHECK: scvtf d23, x19, #1 // encoding: [0x77,0xfe,0x42,0x9e]
1956 // CHECK: scvtf d31, xzr, #20 // encoding: [0xff,0xb3,0x42,0x9e]
1957 // CHECK: scvtf d14, x0, #64 // encoding: [0x0e,0x00,0x42,0x9e]
1962 // CHECK: ucvtf s23, w19, #1 // encoding: [0x77,0xfe,0x03,0x1e]
1963 // CHECK: ucvtf s31, wzr, #20 // encoding: [0xff,0xb3,0x03,0x1e]
1964 // CHECK: ucvtf s14, w0, #32 // encoding: [0x0e,0x80,0x03,0x1e]
1969 // CHECK: ucvtf s23, x19, #1 // encoding: [0x77,0xfe,0x03,0x9e]
1970 // CHECK: ucvtf s31, xzr, #20 // encoding: [0xff,0xb3,0x03,0x9e]
1971 // CHECK: ucvtf s14, x0, #64 // encoding: [0x0e,0x00,0x03,0x9e]
1976 // CHECK: ucvtf d23, w19, #1 // encoding: [0x77,0xfe,0x43,0x1e]
1977 // CHECK: ucvtf d31, wzr, #20 // encoding: [0xff,0xb3,0x43,0x1e]
1978 // CHECK: ucvtf d14, w0, #32 // encoding: [0x0e,0x80,0x43,0x1e]
1983 // CHECK: ucvtf d23, x19, #1 // encoding: [0x77,0xfe,0x43,0x9e]
1984 // CHECK: ucvtf d31, xzr, #20 // encoding: [0xff,0xb3,0x43,0x9e]
1985 // CHECK: ucvtf d14, x0, #64 // encoding: [0x0e,0x00,0x43,0x9e]
1987 //------------------------------------------------------------------------------
1988 // Floating-point <-> integer conversion
1989 //------------------------------------------------------------------------------
1994 // CHECK: fcvtns w3, s31 // encoding: [0xe3,0x03,0x20,0x1e]
1995 // CHECK: fcvtns xzr, s12 // encoding: [0x9f,0x01,0x20,0x9e]
1996 // CHECK: fcvtnu wzr, s12 // encoding: [0x9f,0x01,0x21,0x1e]
1997 // CHECK: fcvtnu x0, s0 // encoding: [0x00,0x00,0x21,0x9e]
2003 // CHECK: fcvtps wzr, s9 // encoding: [0x3f,0x01,0x28,0x1e]
2004 // CHECK: fcvtps x12, s20 // encoding: [0x8c,0x02,0x28,0x9e]
2005 // CHECK: fcvtpu w30, s23 // encoding: [0xfe,0x02,0x29,0x1e]
2006 // CHECK: fcvtpu x29, s3 // encoding: [0x7d,0x00,0x29,0x9e]
2012 // CHECK: fcvtms w2, s3 // encoding: [0x62,0x00,0x30,0x1e]
2013 // CHECK: fcvtms x4, s5 // encoding: [0xa4,0x00,0x30,0x9e]
2014 // CHECK: fcvtmu w6, s7 // encoding: [0xe6,0x00,0x31,0x1e]
2015 // CHECK: fcvtmu x8, s9 // encoding: [0x28,0x01,0x31,0x9e]
2021 // CHECK: fcvtzs w10, s11 // encoding: [0x6a,0x01,0x38,0x1e]
2022 // CHECK: fcvtzs x12, s13 // encoding: [0xac,0x01,0x38,0x9e]
2023 // CHECK: fcvtzu w14, s15 // encoding: [0xee,0x01,0x39,0x1e]
2024 // CHECK: fcvtzu x15, s16 // encoding: [0x0f,0x02,0x39,0x9e]
2030 // CHECK: scvtf s17, w18 // encoding: [0x51,0x02,0x22,0x1e]
2031 // CHECK: scvtf s19, x20 // encoding: [0x93,0x02,0x22,0x9e]
2032 // CHECK: ucvtf s21, w22 // encoding: [0xd5,0x02,0x23,0x1e]
2033 // CHECK: scvtf s23, x24 // encoding: [0x17,0x03,0x22,0x9e]
2039 // CHECK: fcvtas w25, s26 // encoding: [0x59,0x03,0x24,0x1e]
2040 // CHECK: fcvtas x27, s28 // encoding: [0x9b,0x03,0x24,0x9e]
2041 // CHECK: fcvtau w29, s30 // encoding: [0xdd,0x03,0x25,0x1e]
2042 // CHECK: fcvtau xzr, s0 // encoding: [0x1f,0x00,0x25,0x9e]
2048 // CHECK: fcvtns w3, d31 // encoding: [0xe3,0x03,0x60,0x1e]
2049 // CHECK: fcvtns xzr, d12 // encoding: [0x9f,0x01,0x60,0x9e]
2050 // CHECK: fcvtnu wzr, d12 // encoding: [0x9f,0x01,0x61,0x1e]
2051 // CHECK: fcvtnu x0, d0 // encoding: [0x00,0x00,0x61,0x9e]
2057 // CHECK: fcvtps wzr, d9 // encoding: [0x3f,0x01,0x68,0x1e]
2058 // CHECK: fcvtps x12, d20 // encoding: [0x8c,0x02,0x68,0x9e]
2059 // CHECK: fcvtpu w30, d23 // encoding: [0xfe,0x02,0x69,0x1e]
2060 // CHECK: fcvtpu x29, d3 // encoding: [0x7d,0x00,0x69,0x9e]
2066 // CHECK: fcvtms w2, d3 // encoding: [0x62,0x00,0x70,0x1e]
2067 // CHECK: fcvtms x4, d5 // encoding: [0xa4,0x00,0x70,0x9e]
2068 // CHECK: fcvtmu w6, d7 // encoding: [0xe6,0x00,0x71,0x1e]
2069 // CHECK: fcvtmu x8, d9 // encoding: [0x28,0x01,0x71,0x9e]
2075 // CHECK: fcvtzs w10, d11 // encoding: [0x6a,0x01,0x78,0x1e]
2076 // CHECK: fcvtzs x12, d13 // encoding: [0xac,0x01,0x78,0x9e]
2077 // CHECK: fcvtzu w14, d15 // encoding: [0xee,0x01,0x79,0x1e]
2078 // CHECK: fcvtzu x15, d16 // encoding: [0x0f,0x02,0x79,0x9e]
2084 // CHECK: scvtf d17, w18 // encoding: [0x51,0x02,0x62,0x1e]
2085 // CHECK: scvtf d19, x20 // encoding: [0x93,0x02,0x62,0x9e]
2086 // CHECK: ucvtf d21, w22 // encoding: [0xd5,0x02,0x63,0x1e]
2087 // CHECK: ucvtf d23, x24 // encoding: [0x17,0x03,0x63,0x9e]
2093 // CHECK: fcvtas w25, d26 // encoding: [0x59,0x03,0x64,0x1e]
2094 // CHECK: fcvtas x27, d28 // encoding: [0x9b,0x03,0x64,0x9e]
2095 // CHECK: fcvtau w29, d30 // encoding: [0xdd,0x03,0x65,0x1e]
2096 // CHECK: fcvtau xzr, d0 // encoding: [0x1f,0x00,0x65,0x9e]
2100 // CHECK: fmov w3, s9 // encoding: [0x23,0x01,0x26,0x1e]
2101 // CHECK: fmov s9, w3 // encoding: [0x69,0x00,0x27,0x1e]
2105 // CHECK: fmov x20, d31 // encoding: [0xf4,0x03,0x66,0x9e]
2106 // CHECK: fmov d1, x15 // encoding: [0xe1,0x01,0x67,0x9e]
2111 // CHECK: fmov x3, v12.d[1] // encoding: [0x83,0x01,0xae,0x9e]
2112 // CHECK: fmov v1.d[1], x19 // encoding: [0x61,0x02,0xaf,0x9e]
2113 // CHECK: fmov v3.d[1], xzr // encoding: [0xe3,0x03,0xaf,0x9e]
2115 //------------------------------------------------------------------------------
2116 // Floating-point immediate
2117 //------------------------------------------------------------------------------
2122 // CHECK: fmov s2, #0.12500000 // encoding: [0x02,0x10,0x28,0x1e]
2123 // CHECK: fmov s3, #1.00000000 // encoding: [0x03,0x10,0x2e,0x1e]
2124 // CHECK: fmov d30, #16.00000000 // encoding: [0x1e,0x10,0x66,0x1e]
2128 // CHECK: fmov s4, #1.06250000 // encoding: [0x04,0x30,0x2e,0x1e]
2129 // CHECK: fmov d10, #1.93750000 // encoding: [0x0a,0xf0,0x6f,0x1e]
2132 // CHECK: fmov s12, #-1.00000000 // encoding: [0x0c,0x10,0x3e,0x1e]
2135 // CHECK: fmov d16, #8.50000000 // encoding: [0x10,0x30,0x64,0x1e]
2137 //------------------------------------------------------------------------------
2138 // Load-register (literal)
2139 //------------------------------------------------------------------------------
2142 ldrsw xzr, everywhere
2143 // CHECK: ldr w3, here // encoding: [0x03'A',A,A,0x18'A']
2144 // CHECK: // fixup A - offset: 0, value: here, kind: fixup_a64_ld_prel
2145 // CHECK: ldr x29, there // encoding: [0x1d'A',A,A,0x58'A']
2146 // CHECK: // fixup A - offset: 0, value: there, kind: fixup_a64_ld_prel
2147 // CHECK: ldrsw xzr, everywhere // encoding: [0x1f'A',A,A,0x98'A']
2148 // CHECK: // fixup A - offset: 0, value: everywhere, kind: fixup_a64_ld_prel
2152 ldr q0, there_must_be_a_better_way
2153 // CHECK: ldr s0, who_knows // encoding: [A,A,A,0x1c'A']
2154 // CHECK: // fixup A - offset: 0, value: who_knows, kind: fixup_a64_ld_prel
2155 // CHECK: ldr d0, i_dont // encoding: [A,A,A,0x5c'A']
2156 // CHECK: // fixup A - offset: 0, value: i_dont, kind: fixup_a64_ld_prel
2157 // CHECK: ldr q0, there_must_be_a_better_way // encoding: [A,A,A,0x9c'A']
2158 // CHECK: // fixup A - offset: 0, value: there_must_be_a_better_way, kind: fixup_a64_ld_prel
2162 // CHECK: ldr w0, #1048572 // encoding: [0xe0,0xff,0x7f,0x18]
2163 // CHECK: ldr x10, #-1048576 // encoding: [0x0a,0x00,0x80,0x58]
2165 prfm pldl1strm, nowhere
2167 // CHECK: prfm pldl1strm, nowhere // encoding: [0x01'A',A,A,0xd8'A']
2168 // CHECK: // fixup A - offset: 0, value: nowhere, kind: fixup_a64_ld_prel
2169 // CHECK: prfm #22, somewhere // encoding: [0x16'A',A,A,0xd8'A']
2170 // CHECK: // fixup A - offset: 0, value: somewhere, kind: fixup_a64_ld_prel
2172 //------------------------------------------------------------------------------
2173 // Floating-point immediate
2174 //------------------------------------------------------------------------------
2179 // CHECK: fmov s2, #0.12500000 // encoding: [0x02,0x10,0x28,0x1e]
2180 // CHECK: fmov s3, #1.00000000 // encoding: [0x03,0x10,0x2e,0x1e]
2181 // CHECK: fmov d30, #16.00000000 // encoding: [0x1e,0x10,0x66,0x1e]
2185 // CHECK: fmov s4, #1.06250000 // encoding: [0x04,0x30,0x2e,0x1e]
2186 // CHECK: fmov d10, #1.93750000 // encoding: [0x0a,0xf0,0x6f,0x1e]
2189 // CHECK: fmov s12, #-1.00000000 // encoding: [0x0c,0x10,0x3e,0x1e]
2192 // CHECK: fmov d16, #8.50000000 // encoding: [0x10,0x30,0x64,0x1e]
2194 //------------------------------------------------------------------------------
2195 // Load/store exclusive
2196 //------------------------------------------------------------------------------
2198 stxrb w1, w2, [x3, #0]
2202 // CHECK: stxrb w1, w2, [x3] // encoding: [0x62,0x7c,0x01,0x08]
2203 // CHECK: stxrh w2, w3, [x4] // encoding: [0x83,0x7c,0x02,0x48]
2204 // CHECK: stxr wzr, w4, [sp] // encoding: [0xe4,0x7f,0x1f,0x88]
2205 // CHECK: stxr w5, x6, [x7] // encoding: [0xe6,0x7c,0x05,0xc8]
2211 // CHECK: ldxrb w7, [x9] // encoding: [0x27,0x7d,0x5f,0x08]
2212 // CHECK: ldxrh wzr, [x10] // encoding: [0x5f,0x7d,0x5f,0x48]
2213 // CHECK: ldxr w9, [sp] // encoding: [0xe9,0x7f,0x5f,0x88]
2214 // CHECK: ldxr x10, [x11] // encoding: [0x6a,0x7d,0x5f,0xc8]
2216 stxp w11, w12, w13, [x14]
2217 stxp wzr, x23, x14, [x15]
2218 // CHECK: stxp w11, w12, w13, [x14] // encoding: [0xcc,0x35,0x2b,0x88]
2219 // CHECK: stxp wzr, x23, x14, [x15] // encoding: [0xf7,0x39,0x3f,0xc8]
2222 ldxp x13, x14, [x15]
2223 // CHECK: ldxp w12, wzr, [sp] // encoding: [0xec,0x7f,0x7f,0x88]
2224 // CHECK: ldxp x13, x14, [x15] // encoding: [0xed,0x39,0x7f,0xc8]
2226 stlxrb w14, w15, [x16]
2227 stlxrh w15, w16, [x17,#0]
2228 stlxr wzr, w17, [sp]
2229 stlxr w18, x19, [x20]
2230 // CHECK: stlxrb w14, w15, [x16] // encoding: [0x0f,0xfe,0x0e,0x08]
2231 // CHECK: stlxrh w15, w16, [x17] // encoding: [0x30,0xfe,0x0f,0x48]
2232 // CHECK: stlxr wzr, w17, [sp] // encoding: [0xf1,0xff,0x1f,0x88]
2233 // CHECK: stlxr w18, x19, [x20] // encoding: [0x93,0xfe,0x12,0xc8]
2239 // CHECK: ldaxrb w19, [x21] // encoding: [0xb3,0xfe,0x5f,0x08]
2240 // CHECK: ldaxrh w20, [sp] // encoding: [0xf4,0xff,0x5f,0x48]
2241 // CHECK: ldaxr wzr, [x22] // encoding: [0xdf,0xfe,0x5f,0x88]
2242 // CHECK: ldaxr x21, [x23] // encoding: [0xf5,0xfe,0x5f,0xc8]
2244 stlxp wzr, w22, w23, [x24]
2245 stlxp w25, x26, x27, [sp]
2246 // CHECK: stlxp wzr, w22, w23, [x24] // encoding: [0x16,0xdf,0x3f,0x88]
2247 // CHECK: stlxp w25, x26, x27, [sp] // encoding: [0xfa,0xef,0x39,0xc8]
2249 ldaxp w26, wzr, [sp]
2250 ldaxp x27, x28, [x30]
2251 // CHECK: ldaxp w26, wzr, [sp] // encoding: [0xfa,0xff,0x7f,0x88]
2252 // CHECK: ldaxp x27, x28, [x30] // encoding: [0xdb,0xf3,0x7f,0xc8]
2258 // CHECK: stlrb w27, [sp] // encoding: [0xfb,0xff,0x9f,0x08]
2259 // CHECK: stlrh w28, [x0] // encoding: [0x1c,0xfc,0x9f,0x48]
2260 // CHECK: stlr wzr, [x1] // encoding: [0x3f,0xfc,0x9f,0x88]
2261 // CHECK: stlr x30, [x2] // encoding: [0x5e,0xfc,0x9f,0xc8]
2267 // CHECK: ldarb w29, [sp] // encoding: [0xfd,0xff,0xdf,0x08]
2268 // CHECK: ldarh w30, [x0] // encoding: [0x1e,0xfc,0xdf,0x48]
2269 // CHECK: ldar wzr, [x1] // encoding: [0x3f,0xfc,0xdf,0x88]
2270 // CHECK: ldar x1, [x2] // encoding: [0x41,0xfc,0xdf,0xc8]
2272 stlxp wzr, w22, w23, [x24,#0]
2273 // CHECK: stlxp wzr, w22, w23, [x24] // encoding: [0x16,0xdf,0x3f,0x88]
2275 //------------------------------------------------------------------------------
2276 // Load/store (unaligned immediate)
2277 //------------------------------------------------------------------------------
2280 sturh wzr, [x12, #255]
2281 stur w16, [x0, #-256]
2283 // CHECK: sturb w9, [sp] // encoding: [0xe9,0x03,0x00,0x38]
2284 // CHECK: sturh wzr, [x12, #255] // encoding: [0x9f,0xf1,0x0f,0x78]
2285 // CHECK: stur w16, [x0, #-256] // encoding: [0x10,0x00,0x10,0xb8]
2286 // CHECK: stur x28, [x14, #1] // encoding: [0xdc,0x11,0x00,0xf8]
2288 ldurb w1, [x20, #255]
2289 ldurh w20, [x1, #255]
2290 ldur w12, [sp, #255]
2291 ldur xzr, [x12, #255]
2292 // CHECK: ldurb w1, [x20, #255] // encoding: [0x81,0xf2,0x4f,0x38]
2293 // CHECK: ldurh w20, [x1, #255] // encoding: [0x34,0xf0,0x4f,0x78]
2294 // CHECK: ldur w12, [sp, #255] // encoding: [0xec,0xf3,0x4f,0xb8]
2295 // CHECK: ldur xzr, [x12, #255] // encoding: [0x9f,0xf1,0x4f,0xf8]
2297 ldursb x9, [x7, #-256]
2298 ldursh x17, [x19, #-256]
2299 ldursw x20, [x15, #-256]
2301 prfum pldl2keep, [sp, #-256]
2302 ldursb w19, [x1, #-256]
2303 ldursh w15, [x21, #-256]
2304 // CHECK: ldursb x9, [x7, #-256] // encoding: [0xe9,0x00,0x90,0x38]
2305 // CHECK: ldursh x17, [x19, #-256] // encoding: [0x71,0x02,0x90,0x78]
2306 // CHECK: ldursw x20, [x15, #-256] // encoding: [0xf4,0x01,0x90,0xb8]
2307 // CHECK: ldursw x13, [x2] // encoding: [0x4d,0x00,0x80,0xb8]
2308 // CHECK: prfum pldl2keep, [sp, #-256] // encoding: [0xe2,0x03,0x90,0xf8]
2309 // CHECK: ldursb w19, [x1, #-256] // encoding: [0x33,0x00,0xd0,0x38]
2310 // CHECK: ldursh w15, [x21, #-256] // encoding: [0xaf,0x02,0xd0,0x78]
2313 stur h12, [x12, #-1]
2314 stur s15, [x0, #255]
2317 // CHECK: stur b0, [sp, #1] // encoding: [0xe0,0x13,0x00,0x3c]
2318 // CHECK: stur h12, [x12, #-1] // encoding: [0x8c,0xf1,0x1f,0x7c]
2319 // CHECK: stur s15, [x0, #255] // encoding: [0x0f,0xf0,0x0f,0xbc]
2320 // CHECK: stur d31, [x5, #25] // encoding: [0xbf,0x90,0x01,0xfc]
2321 // CHECK: stur q9, [x5] // encoding: [0xa9,0x00,0x80,0x3c]
2324 ldur h5, [x4, #-256]
2328 // CHECK: ldur b3, [sp] // encoding: [0xe3,0x03,0x40,0x3c]
2329 // CHECK: ldur h5, [x4, #-256] // encoding: [0x85,0x00,0x50,0x7c]
2330 // CHECK: ldur s7, [x12, #-1] // encoding: [0x87,0xf1,0x5f,0xbc]
2331 // CHECK: ldur d11, [x19, #4] // encoding: [0x6b,0x42,0x40,0xfc]
2332 // CHECK: ldur q13, [x1, #2] // encoding: [0x2d,0x20,0xc0,0x3c]
2334 //------------------------------------------------------------------------------
2335 // Load/store (unsigned immediate)
2336 //------------------------------------------------------------------------------
2338 //// Basic addressing mode limits: 8 byte access
2341 ldr x30, [x12, #32760]
2343 // CHECK: ldr x0, [x0] // encoding: [0x00,0x00,0x40,0xf9]
2344 // CHECK: ldr x4, [x29] // encoding: [0xa4,0x03,0x40,0xf9]
2345 // CHECK: ldr x30, [x12, #32760] // encoding: [0x9e,0xfd,0x7f,0xf9]
2346 // CHECK: ldr x20, [sp, #8] // encoding: [0xf4,0x07,0x40,0xf9]
2348 //// Rt treats 31 as zero-register
2350 // CHECK: ldr xzr, [sp] // encoding: [0xff,0x03,0x40,0xf9]
2352 //// 4-byte load, check still 64-bit address, limits
2354 ldr w17, [sp, #16380]
2356 // CHECK: ldr w2, [sp] // encoding: [0xe2,0x03,0x40,0xb9]
2357 // CHECK: ldr w17, [sp, #16380] // encoding: [0xf1,0xff,0x7f,0xb9]
2358 // CHECK: ldr w13, [x2, #4] // encoding: [0x4d,0x04,0x40,0xb9]
2360 //// Signed 4-byte load. Limits.
2362 ldrsw x23, [sp, #16380]
2363 // CHECK: ldrsw x2, [x5, #4] // encoding: [0xa2,0x04,0x80,0xb9]
2364 // CHECK: ldrsw x23, [sp, #16380] // encoding: [0xf7,0xff,0xbf,0xb9]
2368 ldrsh w23, [x6, #8190]
2371 // CHECK: ldrh w2, [x4] // encoding: [0x82,0x00,0x40,0x79]
2372 // CHECK: ldrsh w23, [x6, #8190] // encoding: [0xd7,0xfc,0xff,0x79]
2373 // CHECK: ldrsh wzr, [sp, #2] // encoding: [0xff,0x07,0xc0,0x79]
2374 // CHECK: ldrsh x29, [x2, #2] // encoding: [0x5d,0x04,0x80,0x79]
2377 ldrb w26, [x3, #121]
2379 ldrsb w27, [sp, #4095]
2381 // CHECK: ldrb w26, [x3, #121] // encoding: [0x7a,0xe4,0x41,0x39]
2382 // CHECK: ldrb w12, [x2] // encoding: [0x4c,0x00,0x40,0x39]
2383 // CHECK: ldrsb w27, [sp, #4095] // encoding: [0xfb,0xff,0xff,0x39]
2384 // CHECK: ldrsb xzr, [x15] // encoding: [0xff,0x01,0x80,0x39]
2388 str w20, [x4, #16380]
2389 strh w20, [x10, #14]
2390 strh w17, [sp, #8190]
2391 strb w23, [x3, #4095]
2393 // CHECK: str x30, [sp] // encoding: [0xfe,0x03,0x00,0xf9]
2394 // CHECK: str w20, [x4, #16380] // encoding: [0x94,0xfc,0x3f,0xb9]
2395 // CHECK: strh w20, [x10, #14] // encoding: [0x54,0x1d,0x00,0x79]
2396 // CHECK: strh w17, [sp, #8190] // encoding: [0xf1,0xff,0x3f,0x79]
2397 // CHECK: strb w23, [x3, #4095] // encoding: [0x77,0xfc,0x3f,0x39]
2398 // CHECK: strb wzr, [x2] // encoding: [0x5f,0x00,0x00,0x39]
2401 str x15, [x5, #:lo12:sym]
2402 ldrb w15, [x5, #:lo12:sym]
2403 ldrsh x15, [x5, #:lo12:sym]
2404 ldrsw x15, [x5, #:lo12:sym]
2405 ldr x15, [x5, #:lo12:sym]
2406 ldr q3, [x2, #:lo12:sym]
2407 // CHECK: str x15, [x5, #:lo12:sym] // encoding: [0xaf'A',A,A,0xf9'A']
2408 // CHECK: // fixup A - offset: 0, value: :lo12:sym, kind: fixup_a64_ldst64_lo12
2409 // CHECK: ldrb w15, [x5, #:lo12:sym] // encoding: [0xaf'A',A,0x40'A',0x39'A']
2410 // CHECK: // fixup A - offset: 0, value: :lo12:sym, kind: fixup_a64_ldst8_lo12
2411 // CHECK: ldrsh x15, [x5, #:lo12:sym] // encoding: [0xaf'A',A,0x80'A',0x79'A']
2412 // CHECK: // fixup A - offset: 0, value: :lo12:sym, kind: fixup_a64_ldst16_lo12
2413 // CHECK: ldrsw x15, [x5, #:lo12:sym] // encoding: [0xaf'A',A,0x80'A',0xb9'A']
2414 // CHECK: // fixup A - offset: 0, value: :lo12:sym, kind: fixup_a64_ldst32_lo12
2415 // CHECK: ldr x15, [x5, #:lo12:sym] // encoding: [0xaf'A',A,0x40'A',0xf9'A']
2416 // CHECK: // fixup A - offset: 0, value: :lo12:sym, kind: fixup_a64_ldst64_lo12
2417 // CHECK: ldr q3, [x2, #:lo12:sym] // encoding: [0x43'A',A,0xc0'A',0x3d'A']
2418 // CHECK: // fixup A - offset: 0, value: :lo12:sym, kind: fixup_a64_ldst128_lo12
2420 prfm pldl1keep, [sp, #8]
2421 prfm pldl1strm, [x3]
2422 prfm pldl2keep, [x5,#16]
2423 prfm pldl2strm, [x2]
2424 prfm pldl3keep, [x5]
2425 prfm pldl3strm, [x6]
2426 prfm plil1keep, [sp, #8]
2427 prfm plil1strm, [x3]
2428 prfm plil2keep, [x5,#16]
2429 prfm plil2strm, [x2]
2430 prfm plil3keep, [x5]
2431 prfm plil3strm, [x6]
2432 prfm pstl1keep, [sp, #8]
2433 prfm pstl1strm, [x3]
2434 prfm pstl2keep, [x5,#16]
2435 prfm pstl2strm, [x2]
2436 prfm pstl3keep, [x5]
2437 prfm pstl3strm, [x6]
2439 // CHECK: prfm pldl1keep, [sp, #8] // encoding: [0xe0,0x07,0x80,0xf9]
2440 // CHECK: prfm pldl1strm, [x3, #0] // encoding: [0x61,0x00,0x80,0xf9]
2441 // CHECK: prfm pldl2keep, [x5, #16] // encoding: [0xa2,0x08,0x80,0xf9]
2442 // CHECK: prfm pldl2strm, [x2, #0] // encoding: [0x43,0x00,0x80,0xf9]
2443 // CHECK: prfm pldl3keep, [x5, #0] // encoding: [0xa4,0x00,0x80,0xf9]
2444 // CHECK: prfm pldl3strm, [x6, #0] // encoding: [0xc5,0x00,0x80,0xf9]
2445 // CHECK: prfm plil1keep, [sp, #8] // encoding: [0xe8,0x07,0x80,0xf9]
2446 // CHECK: prfm plil1strm, [x3, #0] // encoding: [0x69,0x00,0x80,0xf9]
2447 // CHECK: prfm plil2keep, [x5, #16] // encoding: [0xaa,0x08,0x80,0xf9]
2448 // CHECK: prfm plil2strm, [x2, #0] // encoding: [0x4b,0x00,0x80,0xf9]
2449 // CHECK: prfm plil3keep, [x5, #0] // encoding: [0xac,0x00,0x80,0xf9]
2450 // CHECK: prfm plil3strm, [x6, #0] // encoding: [0xcd,0x00,0x80,0xf9]
2451 // CHECK: prfm pstl1keep, [sp, #8] // encoding: [0xf0,0x07,0x80,0xf9]
2452 // CHECK: prfm pstl1strm, [x3, #0] // encoding: [0x71,0x00,0x80,0xf9]
2453 // CHECK: prfm pstl2keep, [x5, #16] // encoding: [0xb2,0x08,0x80,0xf9]
2454 // CHECK: prfm pstl2strm, [x2, #0] // encoding: [0x53,0x00,0x80,0xf9]
2455 // CHECK: prfm pstl3keep, [x5, #0] // encoding: [0xb4,0x00,0x80,0xf9]
2456 // CHECK: prfm pstl3strm, [x6, #0] // encoding: [0xd5,0x00,0x80,0xf9]
2457 // CHECK: prfm #15, [sp, #0] // encoding: [0xef,0x03,0x80,0xf9]
2459 //// Floating-point versions
2461 ldr b31, [sp, #4095]
2462 ldr h20, [x2, #8190]
2463 ldr s10, [x19, #16380]
2464 ldr d3, [x10, #32760]
2465 str q12, [sp, #65520]
2466 // CHECK: ldr b31, [sp, #4095] // encoding: [0xff,0xff,0x7f,0x3d]
2467 // CHECK: ldr h20, [x2, #8190] // encoding: [0x54,0xfc,0x7f,0x7d]
2468 // CHECK: ldr s10, [x19, #16380] // encoding: [0x6a,0xfe,0x7f,0xbd]
2469 // CHECK: ldr d3, [x10, #32760] // encoding: [0x43,0xfd,0x7f,0xfd]
2470 // CHECK: str q12, [sp, #65520] // encoding: [0xec,0xff,0xbf,0x3d]
2472 //------------------------------------------------------------------------------
2473 // Load/store register (register offset)
2474 //------------------------------------------------------------------------------
2477 ldrb w9, [x27, x6, lsl #0]
2478 ldrsb w10, [x30, x7]
2479 ldrb w11, [x29, x3, sxtx]
2480 strb w12, [x28, xzr, sxtx #0]
2481 ldrb w14, [x26, w6, uxtw]
2482 ldrsb w15, [x25, w7, uxtw #0]
2483 ldrb w17, [x23, w9, sxtw]
2484 ldrsb x18, [x22, w10, sxtw #0]
2485 // CHECK: ldrb w3, [sp, x5] // encoding: [0xe3,0x6b,0x65,0x38]
2486 // CHECK: ldrb w9, [x27, x6, lsl #0] // encoding: [0x69,0x7b,0x66,0x38]
2487 // CHECK: ldrsb w10, [x30, x7] // encoding: [0xca,0x6b,0xe7,0x38]
2488 // CHECK: ldrb w11, [x29, x3, sxtx] // encoding: [0xab,0xeb,0x63,0x38]
2489 // CHECK: strb w12, [x28, xzr, sxtx #0] // encoding: [0x8c,0xfb,0x3f,0x38]
2490 // CHECK: ldrb w14, [x26, w6, uxtw] // encoding: [0x4e,0x4b,0x66,0x38]
2491 // CHECK: ldrsb w15, [x25, w7, uxtw #0] // encoding: [0x2f,0x5b,0xe7,0x38]
2492 // CHECK: ldrb w17, [x23, w9, sxtw] // encoding: [0xf1,0xca,0x69,0x38]
2493 // CHECK: ldrsb x18, [x22, w10, sxtw #0] // encoding: [0xd2,0xda,0xaa,0x38]
2496 ldrsh w9, [x27, x6, lsl #0]
2497 ldrh w10, [x30, x7, lsl #1]
2498 strh w11, [x29, x3, sxtx]
2499 ldrh w12, [x28, xzr, sxtx #0]
2500 ldrsh x13, [x27, x5, sxtx #1]
2501 ldrh w14, [x26, w6, uxtw]
2502 ldrh w15, [x25, w7, uxtw #0]
2503 ldrsh w16, [x24, w8, uxtw #1]
2504 ldrh w17, [x23, w9, sxtw]
2505 ldrh w18, [x22, w10, sxtw #0]
2506 strh w19, [x21, wzr, sxtw #1]
2507 // CHECK: ldrsh w3, [sp, x5] // encoding: [0xe3,0x6b,0xe5,0x78]
2508 // CHECK: ldrsh w9, [x27, x6] // encoding: [0x69,0x6b,0xe6,0x78]
2509 // CHECK: ldrh w10, [x30, x7, lsl #1] // encoding: [0xca,0x7b,0x67,0x78]
2510 // CHECK: strh w11, [x29, x3, sxtx] // encoding: [0xab,0xeb,0x23,0x78]
2511 // CHECK: ldrh w12, [x28, xzr, sxtx] // encoding: [0x8c,0xeb,0x7f,0x78]
2512 // CHECK: ldrsh x13, [x27, x5, sxtx #1] // encoding: [0x6d,0xfb,0xa5,0x78]
2513 // CHECK: ldrh w14, [x26, w6, uxtw] // encoding: [0x4e,0x4b,0x66,0x78]
2514 // CHECK: ldrh w15, [x25, w7, uxtw] // encoding: [0x2f,0x4b,0x67,0x78]
2515 // CHECK: ldrsh w16, [x24, w8, uxtw #1] // encoding: [0x10,0x5b,0xe8,0x78]
2516 // CHECK: ldrh w17, [x23, w9, sxtw] // encoding: [0xf1,0xca,0x69,0x78]
2517 // CHECK: ldrh w18, [x22, w10, sxtw] // encoding: [0xd2,0xca,0x6a,0x78]
2518 // CHECK: strh w19, [x21, wzr, sxtw #1] // encoding: [0xb3,0xda,0x3f,0x78]
2521 ldr s9, [x27, x6, lsl #0]
2522 ldr w10, [x30, x7, lsl #2]
2523 ldr w11, [x29, x3, sxtx]
2524 str s12, [x28, xzr, sxtx #0]
2525 str w13, [x27, x5, sxtx #2]
2526 str w14, [x26, w6, uxtw]
2527 ldr w15, [x25, w7, uxtw #0]
2528 ldr w16, [x24, w8, uxtw #2]
2529 ldrsw x17, [x23, w9, sxtw]
2530 ldr w18, [x22, w10, sxtw #0]
2531 ldrsw x19, [x21, wzr, sxtw #2]
2532 // CHECK: ldr w3, [sp, x5] // encoding: [0xe3,0x6b,0x65,0xb8]
2533 // CHECK: ldr s9, [x27, x6] // encoding: [0x69,0x6b,0x66,0xbc]
2534 // CHECK: ldr w10, [x30, x7, lsl #2] // encoding: [0xca,0x7b,0x67,0xb8]
2535 // CHECK: ldr w11, [x29, x3, sxtx] // encoding: [0xab,0xeb,0x63,0xb8]
2536 // CHECK: str s12, [x28, xzr, sxtx] // encoding: [0x8c,0xeb,0x3f,0xbc]
2537 // CHECK: str w13, [x27, x5, sxtx #2] // encoding: [0x6d,0xfb,0x25,0xb8]
2538 // CHECK: str w14, [x26, w6, uxtw] // encoding: [0x4e,0x4b,0x26,0xb8]
2539 // CHECK: ldr w15, [x25, w7, uxtw] // encoding: [0x2f,0x4b,0x67,0xb8]
2540 // CHECK: ldr w16, [x24, w8, uxtw #2] // encoding: [0x10,0x5b,0x68,0xb8]
2541 // CHECK: ldrsw x17, [x23, w9, sxtw] // encoding: [0xf1,0xca,0xa9,0xb8]
2542 // CHECK: ldr w18, [x22, w10, sxtw] // encoding: [0xd2,0xca,0x6a,0xb8]
2543 // CHECK: ldrsw x19, [x21, wzr, sxtw #2] // encoding: [0xb3,0xda,0xbf,0xb8]
2546 str x9, [x27, x6, lsl #0]
2547 ldr d10, [x30, x7, lsl #3]
2548 str x11, [x29, x3, sxtx]
2549 ldr x12, [x28, xzr, sxtx #0]
2550 ldr x13, [x27, x5, sxtx #3]
2551 prfm pldl1keep, [x26, w6, uxtw]
2552 ldr x15, [x25, w7, uxtw #0]
2553 ldr x16, [x24, w8, uxtw #3]
2554 ldr x17, [x23, w9, sxtw]
2555 ldr x18, [x22, w10, sxtw #0]
2556 str d19, [x21, wzr, sxtw #3]
2558 // CHECK: ldr x3, [sp, x5] // encoding: [0xe3,0x6b,0x65,0xf8]
2559 // CHECK: str x9, [x27, x6] // encoding: [0x69,0x6b,0x26,0xf8]
2560 // CHECK: ldr d10, [x30, x7, lsl #3] // encoding: [0xca,0x7b,0x67,0xfc]
2561 // CHECK: str x11, [x29, x3, sxtx] // encoding: [0xab,0xeb,0x23,0xf8]
2562 // CHECK: ldr x12, [x28, xzr, sxtx] // encoding: [0x8c,0xeb,0x7f,0xf8]
2563 // CHECK: ldr x13, [x27, x5, sxtx #3] // encoding: [0x6d,0xfb,0x65,0xf8]
2564 // CHECK: prfm pldl1keep, [x26, w6, uxtw] // encoding: [0x40,0x4b,0xa6,0xf8]
2565 // CHECK: ldr x15, [x25, w7, uxtw] // encoding: [0x2f,0x4b,0x67,0xf8]
2566 // CHECK: ldr x16, [x24, w8, uxtw #3] // encoding: [0x10,0x5b,0x68,0xf8]
2567 // CHECK: ldr x17, [x23, w9, sxtw] // encoding: [0xf1,0xca,0x69,0xf8]
2568 // CHECK: ldr x18, [x22, w10, sxtw] // encoding: [0xd2,0xca,0x6a,0xf8]
2569 // CHECK: str d19, [x21, wzr, sxtw #3] // encoding: [0xb3,0xda,0x3f,0xfc]
2570 // CHECK: prfm #6, [x0, x5, lsl #0] // encoding: [0x06,0x68,0xa5,0xf8]
2573 ldr q9, [x27, x6, lsl #0]
2574 ldr q10, [x30, x7, lsl #4]
2575 str q11, [x29, x3, sxtx]
2576 str q12, [x28, xzr, sxtx #0]
2577 str q13, [x27, x5, sxtx #4]
2578 ldr q14, [x26, w6, uxtw]
2579 ldr q15, [x25, w7, uxtw #0]
2580 ldr q16, [x24, w8, uxtw #4]
2581 ldr q17, [x23, w9, sxtw]
2582 str q18, [x22, w10, sxtw #0]
2583 ldr q19, [x21, wzr, sxtw #4]
2584 // CHECK: ldr q3, [sp, x5] // encoding: [0xe3,0x6b,0xe5,0x3c]
2585 // CHECK: ldr q9, [x27, x6] // encoding: [0x69,0x6b,0xe6,0x3c]
2586 // CHECK: ldr q10, [x30, x7, lsl #4] // encoding: [0xca,0x7b,0xe7,0x3c]
2587 // CHECK: str q11, [x29, x3, sxtx] // encoding: [0xab,0xeb,0xa3,0x3c]
2588 // CHECK: str q12, [x28, xzr, sxtx] // encoding: [0x8c,0xeb,0xbf,0x3c]
2589 // CHECK: str q13, [x27, x5, sxtx #4] // encoding: [0x6d,0xfb,0xa5,0x3c]
2590 // CHECK: ldr q14, [x26, w6, uxtw] // encoding: [0x4e,0x4b,0xe6,0x3c]
2591 // CHECK: ldr q15, [x25, w7, uxtw] // encoding: [0x2f,0x4b,0xe7,0x3c]
2592 // CHECK: ldr q16, [x24, w8, uxtw #4] // encoding: [0x10,0x5b,0xe8,0x3c]
2593 // CHECK: ldr q17, [x23, w9, sxtw] // encoding: [0xf1,0xca,0xe9,0x3c]
2594 // CHECK: str q18, [x22, w10, sxtw] // encoding: [0xd2,0xca,0xaa,0x3c]
2595 // CHECK: ldr q19, [x21, wzr, sxtw #4] // encoding: [0xb3,0xda,0xff,0x3c]
2597 //------------------------------------------------------------------------------
2598 // Load/store register (immediate post-indexed)
2599 //------------------------------------------------------------------------------
2603 strb w10, [x3], #-256
2606 strh w10, [x3], #-256
2607 // CHECK: strb w9, [x2], #255 // encoding: [0x49,0xf4,0x0f,0x38]
2608 // CHECK: strb w10, [x3], #1 // encoding: [0x6a,0x14,0x00,0x38]
2609 // CHECK: strb w10, [x3], #-256 // encoding: [0x6a,0x04,0x10,0x38]
2610 // CHECK: strh w9, [x2], #255 // encoding: [0x49,0xf4,0x0f,0x78]
2611 // CHECK: strh w9, [x2], #1 // encoding: [0x49,0x14,0x00,0x78]
2612 // CHECK: strh w10, [x3], #-256 // encoding: [0x6a,0x04,0x10,0x78]
2616 str w21, [x12], #-256
2619 str x19, [x12], #-256
2620 // CHECK: str w19, [sp], #255 // encoding: [0xf3,0xf7,0x0f,0xb8]
2621 // CHECK: str w20, [x30], #1 // encoding: [0xd4,0x17,0x00,0xb8]
2622 // CHECK: str w21, [x12], #-256 // encoding: [0x95,0x05,0x10,0xb8]
2623 // CHECK: str xzr, [x9], #255 // encoding: [0x3f,0xf5,0x0f,0xf8]
2624 // CHECK: str x2, [x3], #1 // encoding: [0x62,0x14,0x00,0xf8]
2625 // CHECK: str x19, [x12], #-256 // encoding: [0x93,0x05,0x10,0xf8]
2629 ldrb w10, [x3], #-256
2632 ldrh w10, [x3], #-256
2633 // CHECK: ldrb w9, [x2], #255 // encoding: [0x49,0xf4,0x4f,0x38]
2634 // CHECK: ldrb w10, [x3], #1 // encoding: [0x6a,0x14,0x40,0x38]
2635 // CHECK: ldrb w10, [x3], #-256 // encoding: [0x6a,0x04,0x50,0x38]
2636 // CHECK: ldrh w9, [x2], #255 // encoding: [0x49,0xf4,0x4f,0x78]
2637 // CHECK: ldrh w9, [x2], #1 // encoding: [0x49,0x14,0x40,0x78]
2638 // CHECK: ldrh w10, [x3], #-256 // encoding: [0x6a,0x04,0x50,0x78]
2642 ldr w21, [x12], #-256
2645 ldr x19, [x12], #-256
2646 // CHECK: ldr w19, [sp], #255 // encoding: [0xf3,0xf7,0x4f,0xb8]
2647 // CHECK: ldr w20, [x30], #1 // encoding: [0xd4,0x17,0x40,0xb8]
2648 // CHECK: ldr w21, [x12], #-256 // encoding: [0x95,0x05,0x50,0xb8]
2649 // CHECK: ldr xzr, [x9], #255 // encoding: [0x3f,0xf5,0x4f,0xf8]
2650 // CHECK: ldr x2, [x3], #1 // encoding: [0x62,0x14,0x40,0xf8]
2651 // CHECK: ldr x19, [x12], #-256 // encoding: [0x93,0x05,0x50,0xf8]
2653 ldrsb xzr, [x9], #255
2655 ldrsb x19, [x12], #-256
2656 ldrsh xzr, [x9], #255
2658 ldrsh x19, [x12], #-256
2659 ldrsw xzr, [x9], #255
2661 ldrsw x19, [x12], #-256
2662 // CHECK: ldrsb xzr, [x9], #255 // encoding: [0x3f,0xf5,0x8f,0x38]
2663 // CHECK: ldrsb x2, [x3], #1 // encoding: [0x62,0x14,0x80,0x38]
2664 // CHECK: ldrsb x19, [x12], #-256 // encoding: [0x93,0x05,0x90,0x38]
2665 // CHECK: ldrsh xzr, [x9], #255 // encoding: [0x3f,0xf5,0x8f,0x78]
2666 // CHECK: ldrsh x2, [x3], #1 // encoding: [0x62,0x14,0x80,0x78]
2667 // CHECK: ldrsh x19, [x12], #-256 // encoding: [0x93,0x05,0x90,0x78]
2668 // CHECK: ldrsw xzr, [x9], #255 // encoding: [0x3f,0xf5,0x8f,0xb8]
2669 // CHECK: ldrsw x2, [x3], #1 // encoding: [0x62,0x14,0x80,0xb8]
2670 // CHECK: ldrsw x19, [x12], #-256 // encoding: [0x93,0x05,0x90,0xb8]
2672 ldrsb wzr, [x9], #255
2674 ldrsb w19, [x12], #-256
2675 ldrsh wzr, [x9], #255
2677 ldrsh w19, [x12], #-256
2678 // CHECK: ldrsb wzr, [x9], #255 // encoding: [0x3f,0xf5,0xcf,0x38]
2679 // CHECK: ldrsb w2, [x3], #1 // encoding: [0x62,0x14,0xc0,0x38]
2680 // CHECK: ldrsb w19, [x12], #-256 // encoding: [0x93,0x05,0xd0,0x38]
2681 // CHECK: ldrsh wzr, [x9], #255 // encoding: [0x3f,0xf5,0xcf,0x78]
2682 // CHECK: ldrsh w2, [x3], #1 // encoding: [0x62,0x14,0xc0,0x78]
2683 // CHECK: ldrsh w19, [x12], #-256 // encoding: [0x93,0x05,0xd0,0x78]
2688 str h10, [x10], #255
2690 str h15, [sp], #-256
2691 str s20, [x20], #255
2693 str s25, [x0], #-256
2694 str d20, [x20], #255
2696 str d25, [x0], #-256
2697 // CHECK: str b0, [x0], #255 // encoding: [0x00,0xf4,0x0f,0x3c]
2698 // CHECK: str b3, [x3], #1 // encoding: [0x63,0x14,0x00,0x3c]
2699 // CHECK: str b5, [sp], #-256 // encoding: [0xe5,0x07,0x10,0x3c]
2700 // CHECK: str h10, [x10], #255 // encoding: [0x4a,0xf5,0x0f,0x7c]
2701 // CHECK: str h13, [x23], #1 // encoding: [0xed,0x16,0x00,0x7c]
2702 // CHECK: str h15, [sp], #-256 // encoding: [0xef,0x07,0x10,0x7c]
2703 // CHECK: str s20, [x20], #255 // encoding: [0x94,0xf6,0x0f,0xbc]
2704 // CHECK: str s23, [x23], #1 // encoding: [0xf7,0x16,0x00,0xbc]
2705 // CHECK: str s25, [x0], #-256 // encoding: [0x19,0x04,0x10,0xbc]
2706 // CHECK: str d20, [x20], #255 // encoding: [0x94,0xf6,0x0f,0xfc]
2707 // CHECK: str d23, [x23], #1 // encoding: [0xf7,0x16,0x00,0xfc]
2708 // CHECK: str d25, [x0], #-256 // encoding: [0x19,0x04,0x10,0xfc]
2713 ldr h10, [x10], #255
2715 ldr h15, [sp], #-256
2716 ldr s20, [x20], #255
2718 ldr s25, [x0], #-256
2719 ldr d20, [x20], #255
2721 ldr d25, [x0], #-256
2722 // CHECK: ldr b0, [x0], #255 // encoding: [0x00,0xf4,0x4f,0x3c]
2723 // CHECK: ldr b3, [x3], #1 // encoding: [0x63,0x14,0x40,0x3c]
2724 // CHECK: ldr b5, [sp], #-256 // encoding: [0xe5,0x07,0x50,0x3c]
2725 // CHECK: ldr h10, [x10], #255 // encoding: [0x4a,0xf5,0x4f,0x7c]
2726 // CHECK: ldr h13, [x23], #1 // encoding: [0xed,0x16,0x40,0x7c]
2727 // CHECK: ldr h15, [sp], #-256 // encoding: [0xef,0x07,0x50,0x7c]
2728 // CHECK: ldr s20, [x20], #255 // encoding: [0x94,0xf6,0x4f,0xbc]
2729 // CHECK: ldr s23, [x23], #1 // encoding: [0xf7,0x16,0x40,0xbc]
2730 // CHECK: ldr s25, [x0], #-256 // encoding: [0x19,0x04,0x50,0xbc]
2731 // CHECK: ldr d20, [x20], #255 // encoding: [0x94,0xf6,0x4f,0xfc]
2732 // CHECK: ldr d23, [x23], #1 // encoding: [0xf7,0x16,0x40,0xfc]
2733 // CHECK: ldr d25, [x0], #-256 // encoding: [0x19,0x04,0x50,0xfc]
2737 ldr q25, [x20], #-256
2740 str q21, [x20], #-256
2741 // CHECK: ldr q20, [x1], #255 // encoding: [0x34,0xf4,0xcf,0x3c]
2742 // CHECK: ldr q23, [x9], #1 // encoding: [0x37,0x15,0xc0,0x3c]
2743 // CHECK: ldr q25, [x20], #-256 // encoding: [0x99,0x06,0xd0,0x3c]
2744 // CHECK: str q10, [x1], #255 // encoding: [0x2a,0xf4,0x8f,0x3c]
2745 // CHECK: str q22, [sp], #1 // encoding: [0xf6,0x17,0x80,0x3c]
2746 // CHECK: str q21, [x20], #-256 // encoding: [0x95,0x06,0x90,0x3c]
2748 //------------------------------------------------------------------------------
2749 // Load/store register (immediate pre-indexed)
2750 //------------------------------------------------------------------------------
2754 // CHECK: ldr x3, [x4, #0]! // encoding: [0x83,0x0c,0x40,0xf8]
2755 // CHECK: ldr xzr, [sp, #0]! // encoding: [0xff,0x0f,0x40,0xf8]
2757 strb w9, [x2, #255]!
2759 strb w10, [x3, #-256]!
2760 strh w9, [x2, #255]!
2762 strh w10, [x3, #-256]!
2763 // CHECK: strb w9, [x2, #255]! // encoding: [0x49,0xfc,0x0f,0x38]
2764 // CHECK: strb w10, [x3, #1]! // encoding: [0x6a,0x1c,0x00,0x38]
2765 // CHECK: strb w10, [x3, #-256]! // encoding: [0x6a,0x0c,0x10,0x38]
2766 // CHECK: strh w9, [x2, #255]! // encoding: [0x49,0xfc,0x0f,0x78]
2767 // CHECK: strh w9, [x2, #1]! // encoding: [0x49,0x1c,0x00,0x78]
2768 // CHECK: strh w10, [x3, #-256]! // encoding: [0x6a,0x0c,0x10,0x78]
2770 str w19, [sp, #255]!
2772 str w21, [x12, #-256]!
2773 str xzr, [x9, #255]!
2775 str x19, [x12, #-256]!
2776 // CHECK: str w19, [sp, #255]! // encoding: [0xf3,0xff,0x0f,0xb8]
2777 // CHECK: str w20, [x30, #1]! // encoding: [0xd4,0x1f,0x00,0xb8]
2778 // CHECK: str w21, [x12, #-256]! // encoding: [0x95,0x0d,0x10,0xb8]
2779 // CHECK: str xzr, [x9, #255]! // encoding: [0x3f,0xfd,0x0f,0xf8]
2780 // CHECK: str x2, [x3, #1]! // encoding: [0x62,0x1c,0x00,0xf8]
2781 // CHECK: str x19, [x12, #-256]! // encoding: [0x93,0x0d,0x10,0xf8]
2783 ldrb w9, [x2, #255]!
2785 ldrb w10, [x3, #-256]!
2786 ldrh w9, [x2, #255]!
2788 ldrh w10, [x3, #-256]!
2789 // CHECK: ldrb w9, [x2, #255]! // encoding: [0x49,0xfc,0x4f,0x38]
2790 // CHECK: ldrb w10, [x3, #1]! // encoding: [0x6a,0x1c,0x40,0x38]
2791 // CHECK: ldrb w10, [x3, #-256]! // encoding: [0x6a,0x0c,0x50,0x38]
2792 // CHECK: ldrh w9, [x2, #255]! // encoding: [0x49,0xfc,0x4f,0x78]
2793 // CHECK: ldrh w9, [x2, #1]! // encoding: [0x49,0x1c,0x40,0x78]
2794 // CHECK: ldrh w10, [x3, #-256]! // encoding: [0x6a,0x0c,0x50,0x78]
2796 ldr w19, [sp, #255]!
2798 ldr w21, [x12, #-256]!
2799 ldr xzr, [x9, #255]!
2801 ldr x19, [x12, #-256]!
2802 // CHECK: ldr w19, [sp, #255]! // encoding: [0xf3,0xff,0x4f,0xb8]
2803 // CHECK: ldr w20, [x30, #1]! // encoding: [0xd4,0x1f,0x40,0xb8]
2804 // CHECK: ldr w21, [x12, #-256]! // encoding: [0x95,0x0d,0x50,0xb8]
2805 // CHECK: ldr xzr, [x9, #255]! // encoding: [0x3f,0xfd,0x4f,0xf8]
2806 // CHECK: ldr x2, [x3, #1]! // encoding: [0x62,0x1c,0x40,0xf8]
2807 // CHECK: ldr x19, [x12, #-256]! // encoding: [0x93,0x0d,0x50,0xf8]
2809 ldrsb xzr, [x9, #255]!
2811 ldrsb x19, [x12, #-256]!
2812 ldrsh xzr, [x9, #255]!
2814 ldrsh x19, [x12, #-256]!
2815 ldrsw xzr, [x9, #255]!
2817 ldrsw x19, [x12, #-256]!
2818 // CHECK: ldrsb xzr, [x9, #255]! // encoding: [0x3f,0xfd,0x8f,0x38]
2819 // CHECK: ldrsb x2, [x3, #1]! // encoding: [0x62,0x1c,0x80,0x38]
2820 // CHECK: ldrsb x19, [x12, #-256]! // encoding: [0x93,0x0d,0x90,0x38]
2821 // CHECK: ldrsh xzr, [x9, #255]! // encoding: [0x3f,0xfd,0x8f,0x78]
2822 // CHECK: ldrsh x2, [x3, #1]! // encoding: [0x62,0x1c,0x80,0x78]
2823 // CHECK: ldrsh x19, [x12, #-256]! // encoding: [0x93,0x0d,0x90,0x78]
2824 // CHECK: ldrsw xzr, [x9, #255]! // encoding: [0x3f,0xfd,0x8f,0xb8]
2825 // CHECK: ldrsw x2, [x3, #1]! // encoding: [0x62,0x1c,0x80,0xb8]
2826 // CHECK: ldrsw x19, [x12, #-256]! // encoding: [0x93,0x0d,0x90,0xb8]
2828 ldrsb wzr, [x9, #255]!
2830 ldrsb w19, [x12, #-256]!
2831 ldrsh wzr, [x9, #255]!
2833 ldrsh w19, [x12, #-256]!
2834 // CHECK: ldrsb wzr, [x9, #255]! // encoding: [0x3f,0xfd,0xcf,0x38]
2835 // CHECK: ldrsb w2, [x3, #1]! // encoding: [0x62,0x1c,0xc0,0x38]
2836 // CHECK: ldrsb w19, [x12, #-256]! // encoding: [0x93,0x0d,0xd0,0x38]
2837 // CHECK: ldrsh wzr, [x9, #255]! // encoding: [0x3f,0xfd,0xcf,0x78]
2838 // CHECK: ldrsh w2, [x3, #1]! // encoding: [0x62,0x1c,0xc0,0x78]
2839 // CHECK: ldrsh w19, [x12, #-256]! // encoding: [0x93,0x0d,0xd0,0x78]
2843 str b5, [sp, #-256]!
2844 str h10, [x10, #255]!
2846 str h15, [sp, #-256]!
2847 str s20, [x20, #255]!
2849 str s25, [x0, #-256]!
2850 str d20, [x20, #255]!
2852 str d25, [x0, #-256]!
2853 // CHECK: str b0, [x0, #255]! // encoding: [0x00,0xfc,0x0f,0x3c]
2854 // CHECK: str b3, [x3, #1]! // encoding: [0x63,0x1c,0x00,0x3c]
2855 // CHECK: str b5, [sp, #-256]! // encoding: [0xe5,0x0f,0x10,0x3c]
2856 // CHECK: str h10, [x10, #255]! // encoding: [0x4a,0xfd,0x0f,0x7c]
2857 // CHECK: str h13, [x23, #1]! // encoding: [0xed,0x1e,0x00,0x7c]
2858 // CHECK: str h15, [sp, #-256]! // encoding: [0xef,0x0f,0x10,0x7c]
2859 // CHECK: str s20, [x20, #255]! // encoding: [0x94,0xfe,0x0f,0xbc]
2860 // CHECK: str s23, [x23, #1]! // encoding: [0xf7,0x1e,0x00,0xbc]
2861 // CHECK: str s25, [x0, #-256]! // encoding: [0x19,0x0c,0x10,0xbc]
2862 // CHECK: str d20, [x20, #255]! // encoding: [0x94,0xfe,0x0f,0xfc]
2863 // CHECK: str d23, [x23, #1]! // encoding: [0xf7,0x1e,0x00,0xfc]
2864 // CHECK: str d25, [x0, #-256]! // encoding: [0x19,0x0c,0x10,0xfc]
2868 ldr b5, [sp, #-256]!
2869 ldr h10, [x10, #255]!
2871 ldr h15, [sp, #-256]!
2872 ldr s20, [x20, #255]!
2874 ldr s25, [x0, #-256]!
2875 ldr d20, [x20, #255]!
2877 ldr d25, [x0, #-256]!
2878 // CHECK: ldr b0, [x0, #255]! // encoding: [0x00,0xfc,0x4f,0x3c]
2879 // CHECK: ldr b3, [x3, #1]! // encoding: [0x63,0x1c,0x40,0x3c]
2880 // CHECK: ldr b5, [sp, #-256]! // encoding: [0xe5,0x0f,0x50,0x3c]
2881 // CHECK: ldr h10, [x10, #255]! // encoding: [0x4a,0xfd,0x4f,0x7c]
2882 // CHECK: ldr h13, [x23, #1]! // encoding: [0xed,0x1e,0x40,0x7c]
2883 // CHECK: ldr h15, [sp, #-256]! // encoding: [0xef,0x0f,0x50,0x7c]
2884 // CHECK: ldr s20, [x20, #255]! // encoding: [0x94,0xfe,0x4f,0xbc]
2885 // CHECK: ldr s23, [x23, #1]! // encoding: [0xf7,0x1e,0x40,0xbc]
2886 // CHECK: ldr s25, [x0, #-256]! // encoding: [0x19,0x0c,0x50,0xbc]
2887 // CHECK: ldr d20, [x20, #255]! // encoding: [0x94,0xfe,0x4f,0xfc]
2888 // CHECK: ldr d23, [x23, #1]! // encoding: [0xf7,0x1e,0x40,0xfc]
2889 // CHECK: ldr d25, [x0, #-256]! // encoding: [0x19,0x0c,0x50,0xfc]
2891 ldr q20, [x1, #255]!
2893 ldr q25, [x20, #-256]!
2894 str q10, [x1, #255]!
2896 str q21, [x20, #-256]!
2897 // CHECK: ldr q20, [x1, #255]! // encoding: [0x34,0xfc,0xcf,0x3c]
2898 // CHECK: ldr q23, [x9, #1]! // encoding: [0x37,0x1d,0xc0,0x3c]
2899 // CHECK: ldr q25, [x20, #-256]! // encoding: [0x99,0x0e,0xd0,0x3c]
2900 // CHECK: str q10, [x1, #255]! // encoding: [0x2a,0xfc,0x8f,0x3c]
2901 // CHECK: str q22, [sp, #1]! // encoding: [0xf6,0x1f,0x80,0x3c]
2902 // CHECK: str q21, [x20, #-256]! // encoding: [0x95,0x0e,0x90,0x3c]
2904 //------------------------------------------------------------------------------
2905 // Load/store (unprivileged)
2906 //------------------------------------------------------------------------------
2909 sttrh wzr, [x12, #255]
2910 sttr w16, [x0, #-256]
2912 // CHECK: sttrb w9, [sp] // encoding: [0xe9,0x0b,0x00,0x38]
2913 // CHECK: sttrh wzr, [x12, #255] // encoding: [0x9f,0xf9,0x0f,0x78]
2914 // CHECK: sttr w16, [x0, #-256] // encoding: [0x10,0x08,0x10,0xb8]
2915 // CHECK: sttr x28, [x14, #1] // encoding: [0xdc,0x19,0x00,0xf8]
2917 ldtrb w1, [x20, #255]
2918 ldtrh w20, [x1, #255]
2919 ldtr w12, [sp, #255]
2920 ldtr xzr, [x12, #255]
2921 // CHECK: ldtrb w1, [x20, #255] // encoding: [0x81,0xfa,0x4f,0x38]
2922 // CHECK: ldtrh w20, [x1, #255] // encoding: [0x34,0xf8,0x4f,0x78]
2923 // CHECK: ldtr w12, [sp, #255] // encoding: [0xec,0xfb,0x4f,0xb8]
2924 // CHECK: ldtr xzr, [x12, #255] // encoding: [0x9f,0xf9,0x4f,0xf8]
2926 ldtrsb x9, [x7, #-256]
2927 ldtrsh x17, [x19, #-256]
2928 ldtrsw x20, [x15, #-256]
2929 ldtrsb w19, [x1, #-256]
2930 ldtrsh w15, [x21, #-256]
2931 // CHECK: ldtrsb x9, [x7, #-256] // encoding: [0xe9,0x08,0x90,0x38]
2932 // CHECK: ldtrsh x17, [x19, #-256] // encoding: [0x71,0x0a,0x90,0x78]
2933 // CHECK: ldtrsw x20, [x15, #-256] // encoding: [0xf4,0x09,0x90,0xb8]
2934 // CHECK: ldtrsb w19, [x1, #-256] // encoding: [0x33,0x08,0xd0,0x38]
2935 // CHECK: ldtrsh w15, [x21, #-256] // encoding: [0xaf,0x0a,0xd0,0x78]
2937 //------------------------------------------------------------------------------
2938 // Load/store register pair (offset)
2939 //------------------------------------------------------------------------------
2942 stp wzr, w9, [sp, #252]
2943 ldp w2, wzr, [sp, #-256]
2944 ldp w9, w10, [sp, #4]
2945 // CHECK: ldp w3, w5, [sp] // encoding: [0xe3,0x17,0x40,0x29]
2946 // CHECK: stp wzr, w9, [sp, #252] // encoding: [0xff,0xa7,0x1f,0x29]
2947 // CHECK: ldp w2, wzr, [sp, #-256] // encoding: [0xe2,0x7f,0x60,0x29]
2948 // CHECK: ldp w9, w10, [sp, #4] // encoding: [0xe9,0xab,0x40,0x29]
2950 ldpsw x9, x10, [sp, #4]
2951 ldpsw x9, x10, [x2, #-256]
2952 ldpsw x20, x30, [sp, #252]
2953 // CHECK: ldpsw x9, x10, [sp, #4] // encoding: [0xe9,0xab,0x40,0x69]
2954 // CHECK: ldpsw x9, x10, [x2, #-256] // encoding: [0x49,0x28,0x60,0x69]
2955 // CHECK: ldpsw x20, x30, [sp, #252] // encoding: [0xf4,0xfb,0x5f,0x69]
2957 ldp x21, x29, [x2, #504]
2958 ldp x22, x23, [x3, #-512]
2959 ldp x24, x25, [x4, #8]
2960 // CHECK: ldp x21, x29, [x2, #504] // encoding: [0x55,0xf4,0x5f,0xa9]
2961 // CHECK: ldp x22, x23, [x3, #-512] // encoding: [0x76,0x5c,0x60,0xa9]
2962 // CHECK: ldp x24, x25, [x4, #8] // encoding: [0x98,0xe4,0x40,0xa9]
2964 ldp s29, s28, [sp, #252]
2965 stp s27, s26, [sp, #-256]
2966 ldp s1, s2, [x3, #44]
2967 // CHECK: ldp s29, s28, [sp, #252] // encoding: [0xfd,0xf3,0x5f,0x2d]
2968 // CHECK: stp s27, s26, [sp, #-256] // encoding: [0xfb,0x6b,0x20,0x2d]
2969 // CHECK: ldp s1, s2, [x3, #44] // encoding: [0x61,0x88,0x45,0x2d]
2971 stp d3, d5, [x9, #504]
2972 stp d7, d11, [x10, #-512]
2973 ldp d2, d3, [x30, #-8]
2974 // CHECK: stp d3, d5, [x9, #504] // encoding: [0x23,0x95,0x1f,0x6d]
2975 // CHECK: stp d7, d11, [x10, #-512] // encoding: [0x47,0x2d,0x20,0x6d]
2976 // CHECK: ldp d2, d3, [x30, #-8] // encoding: [0xc2,0x8f,0x7f,0x6d]
2979 stp q17, q19, [sp, #1008]
2980 ldp q23, q29, [x1, #-1024]
2981 // CHECK: stp q3, q5, [sp] // encoding: [0xe3,0x17,0x00,0xad]
2982 // CHECK: stp q17, q19, [sp, #1008] // encoding: [0xf1,0xcf,0x1f,0xad]
2983 // CHECK: ldp q23, q29, [x1, #-1024] // encoding: [0x37,0x74,0x60,0xad]
2985 //------------------------------------------------------------------------------
2986 // Load/store register pair (post-indexed)
2987 //------------------------------------------------------------------------------
2989 ldp w3, w5, [sp], #0
2990 stp wzr, w9, [sp], #252
2991 ldp w2, wzr, [sp], #-256
2992 ldp w9, w10, [sp], #4
2993 // CHECK: ldp w3, w5, [sp], #0 // encoding: [0xe3,0x17,0xc0,0x28]
2994 // CHECK: stp wzr, w9, [sp], #252 // encoding: [0xff,0xa7,0x9f,0x28]
2995 // CHECK: ldp w2, wzr, [sp], #-256 // encoding: [0xe2,0x7f,0xe0,0x28]
2996 // CHECK: ldp w9, w10, [sp], #4 // encoding: [0xe9,0xab,0xc0,0x28]
2998 ldpsw x9, x10, [sp], #4
2999 ldpsw x9, x10, [x2], #-256
3000 ldpsw x20, x30, [sp], #252
3001 // CHECK: ldpsw x9, x10, [sp], #4 // encoding: [0xe9,0xab,0xc0,0x68]
3002 // CHECK: ldpsw x9, x10, [x2], #-256 // encoding: [0x49,0x28,0xe0,0x68]
3003 // CHECK: ldpsw x20, x30, [sp], #252 // encoding: [0xf4,0xfb,0xdf,0x68]
3005 ldp x21, x29, [x2], #504
3006 ldp x22, x23, [x3], #-512
3007 ldp x24, x25, [x4], #8
3008 // CHECK: ldp x21, x29, [x2], #504 // encoding: [0x55,0xf4,0xdf,0xa8]
3009 // CHECK: ldp x22, x23, [x3], #-512 // encoding: [0x76,0x5c,0xe0,0xa8]
3010 // CHECK: ldp x24, x25, [x4], #8 // encoding: [0x98,0xe4,0xc0,0xa8]
3012 ldp s29, s28, [sp], #252
3013 stp s27, s26, [sp], #-256
3014 ldp s1, s2, [x3], #44
3015 // CHECK: ldp s29, s28, [sp], #252 // encoding: [0xfd,0xf3,0xdf,0x2c]
3016 // CHECK: stp s27, s26, [sp], #-256 // encoding: [0xfb,0x6b,0xa0,0x2c]
3017 // CHECK: ldp s1, s2, [x3], #44 // encoding: [0x61,0x88,0xc5,0x2c]
3019 stp d3, d5, [x9], #504
3020 stp d7, d11, [x10], #-512
3021 ldp d2, d3, [x30], #-8
3022 // CHECK: stp d3, d5, [x9], #504 // encoding: [0x23,0x95,0x9f,0x6c]
3023 // CHECK: stp d7, d11, [x10], #-512 // encoding: [0x47,0x2d,0xa0,0x6c]
3024 // CHECK: ldp d2, d3, [x30], #-8 // encoding: [0xc2,0x8f,0xff,0x6c]
3026 stp q3, q5, [sp], #0
3027 stp q17, q19, [sp], #1008
3028 ldp q23, q29, [x1], #-1024
3029 // CHECK: stp q3, q5, [sp], #0 // encoding: [0xe3,0x17,0x80,0xac]
3030 // CHECK: stp q17, q19, [sp], #1008 // encoding: [0xf1,0xcf,0x9f,0xac]
3031 // CHECK: ldp q23, q29, [x1], #-1024 // encoding: [0x37,0x74,0xe0,0xac]
3033 //------------------------------------------------------------------------------
3034 // Load/store register pair (pre-indexed)
3035 //------------------------------------------------------------------------------
3036 ldp w3, w5, [sp, #0]!
3037 stp wzr, w9, [sp, #252]!
3038 ldp w2, wzr, [sp, #-256]!
3039 ldp w9, w10, [sp, #4]!
3040 // CHECK: ldp w3, w5, [sp, #0]! // encoding: [0xe3,0x17,0xc0,0x29]
3041 // CHECK: stp wzr, w9, [sp, #252]! // encoding: [0xff,0xa7,0x9f,0x29]
3042 // CHECK: ldp w2, wzr, [sp, #-256]! // encoding: [0xe2,0x7f,0xe0,0x29]
3043 // CHECK: ldp w9, w10, [sp, #4]! // encoding: [0xe9,0xab,0xc0,0x29]
3045 ldpsw x9, x10, [sp, #4]!
3046 ldpsw x9, x10, [x2, #-256]!
3047 ldpsw x20, x30, [sp, #252]!
3048 // CHECK: ldpsw x9, x10, [sp, #4]! // encoding: [0xe9,0xab,0xc0,0x69]
3049 // CHECK: ldpsw x9, x10, [x2, #-256]! // encoding: [0x49,0x28,0xe0,0x69]
3050 // CHECK: ldpsw x20, x30, [sp, #252]! // encoding: [0xf4,0xfb,0xdf,0x69]
3052 ldp x21, x29, [x2, #504]!
3053 ldp x22, x23, [x3, #-512]!
3054 ldp x24, x25, [x4, #8]!
3055 // CHECK: ldp x21, x29, [x2, #504]! // encoding: [0x55,0xf4,0xdf,0xa9]
3056 // CHECK: ldp x22, x23, [x3, #-512]! // encoding: [0x76,0x5c,0xe0,0xa9]
3057 // CHECK: ldp x24, x25, [x4, #8]! // encoding: [0x98,0xe4,0xc0,0xa9]
3059 ldp s29, s28, [sp, #252]!
3060 stp s27, s26, [sp, #-256]!
3061 ldp s1, s2, [x3, #44]!
3062 // CHECK: ldp s29, s28, [sp, #252]! // encoding: [0xfd,0xf3,0xdf,0x2d]
3063 // CHECK: stp s27, s26, [sp, #-256]! // encoding: [0xfb,0x6b,0xa0,0x2d]
3064 // CHECK: ldp s1, s2, [x3, #44]! // encoding: [0x61,0x88,0xc5,0x2d]
3066 stp d3, d5, [x9, #504]!
3067 stp d7, d11, [x10, #-512]!
3068 ldp d2, d3, [x30, #-8]!
3069 // CHECK: stp d3, d5, [x9, #504]! // encoding: [0x23,0x95,0x9f,0x6d]
3070 // CHECK: stp d7, d11, [x10, #-512]! // encoding: [0x47,0x2d,0xa0,0x6d]
3071 // CHECK: ldp d2, d3, [x30, #-8]! // encoding: [0xc2,0x8f,0xff,0x6d]
3073 stp q3, q5, [sp, #0]!
3074 stp q17, q19, [sp, #1008]!
3075 ldp q23, q29, [x1, #-1024]!
3076 // CHECK: stp q3, q5, [sp, #0]! // encoding: [0xe3,0x17,0x80,0xad]
3077 // CHECK: stp q17, q19, [sp, #1008]! // encoding: [0xf1,0xcf,0x9f,0xad]
3078 // CHECK: ldp q23, q29, [x1, #-1024]! // encoding: [0x37,0x74,0xe0,0xad]
3080 //------------------------------------------------------------------------------
3081 // Load/store non-temporal register pair (offset)
3082 //------------------------------------------------------------------------------
3085 stnp wzr, w9, [sp, #252]
3086 ldnp w2, wzr, [sp, #-256]
3087 ldnp w9, w10, [sp, #4]
3088 // CHECK: ldnp w3, w5, [sp] // encoding: [0xe3,0x17,0x40,0x28]
3089 // CHECK: stnp wzr, w9, [sp, #252] // encoding: [0xff,0xa7,0x1f,0x28]
3090 // CHECK: ldnp w2, wzr, [sp, #-256] // encoding: [0xe2,0x7f,0x60,0x28]
3091 // CHECK: ldnp w9, w10, [sp, #4] // encoding: [0xe9,0xab,0x40,0x28]
3093 ldnp x21, x29, [x2, #504]
3094 ldnp x22, x23, [x3, #-512]
3095 ldnp x24, x25, [x4, #8]
3096 // CHECK: ldnp x21, x29, [x2, #504] // encoding: [0x55,0xf4,0x5f,0xa8]
3097 // CHECK: ldnp x22, x23, [x3, #-512] // encoding: [0x76,0x5c,0x60,0xa8]
3098 // CHECK: ldnp x24, x25, [x4, #8] // encoding: [0x98,0xe4,0x40,0xa8]
3100 ldnp s29, s28, [sp, #252]
3101 stnp s27, s26, [sp, #-256]
3102 ldnp s1, s2, [x3, #44]
3103 // CHECK: ldnp s29, s28, [sp, #252] // encoding: [0xfd,0xf3,0x5f,0x2c]
3104 // CHECK: stnp s27, s26, [sp, #-256] // encoding: [0xfb,0x6b,0x20,0x2c]
3105 // CHECK: ldnp s1, s2, [x3, #44] // encoding: [0x61,0x88,0x45,0x2c]
3107 stnp d3, d5, [x9, #504]
3108 stnp d7, d11, [x10, #-512]
3109 ldnp d2, d3, [x30, #-8]
3110 // CHECK: stnp d3, d5, [x9, #504] // encoding: [0x23,0x95,0x1f,0x6c]
3111 // CHECK: stnp d7, d11, [x10, #-512] // encoding: [0x47,0x2d,0x20,0x6c]
3112 // CHECK: ldnp d2, d3, [x30, #-8] // encoding: [0xc2,0x8f,0x7f,0x6c]
3115 stnp q17, q19, [sp, #1008]
3116 ldnp q23, q29, [x1, #-1024]
3117 // CHECK: stnp q3, q5, [sp] // encoding: [0xe3,0x17,0x00,0xac]
3118 // CHECK: stnp q17, q19, [sp, #1008] // encoding: [0xf1,0xcf,0x1f,0xac]
3119 // CHECK: ldnp q23, q29, [x1, #-1024] // encoding: [0x37,0x74,0x60,0xac]
3121 //------------------------------------------------------------------------------
3122 // Logical (immediate)
3123 //------------------------------------------------------------------------------
3124 // 32 bit replication-width
3125 orr w3, w9, #0xffff0000
3126 orr wsp, w10, #0xe00000ff
3127 orr w9, w10, #0x000003ff
3128 // CHECK: orr w3, w9, #0xffff0000 // encoding: [0x23,0x3d,0x10,0x32]
3129 // CHECK: orr wsp, w10, #0xe00000ff // encoding: [0x5f,0x29,0x03,0x32]
3130 // CHECK: orr w9, w10, #0x3ff // encoding: [0x49,0x25,0x00,0x32]
3132 // 16 bit replication width
3133 and w14, w15, #0x80008000
3134 and w12, w13, #0xffc3ffc3
3135 and w11, wzr, #0x00030003
3136 // CHECK: and w14, w15, #0x80008000 // encoding: [0xee,0x81,0x01,0x12]
3137 // CHECK: and w12, w13, #0xffc3ffc3 // encoding: [0xac,0xad,0x0a,0x12]
3138 // CHECK: and w11, wzr, #0x30003 // encoding: [0xeb,0x87,0x00,0x12]
3140 // 8 bit replication width
3141 eor w3, w6, #0xe0e0e0e0
3142 eor wsp, wzr, #0x03030303
3143 eor w16, w17, #0x81818181
3144 // CHECK: eor w3, w6, #0xe0e0e0e0 // encoding: [0xc3,0xc8,0x03,0x52]
3145 // CHECK: eor wsp, wzr, #0x3030303 // encoding: [0xff,0xc7,0x00,0x52]
3146 // CHECK: eor w16, w17, #0x81818181 // encoding: [0x30,0xc6,0x01,0x52]
3148 // 4 bit replication width
3149 ands wzr, w18, #0xcccccccc
3150 ands w19, w20, #0x33333333
3151 ands w21, w22, #0x99999999
3152 // CHECK: ands wzr, w18, #0xcccccccc // encoding: [0x5f,0xe6,0x02,0x72]
3153 // CHECK: ands w19, w20, #0x33333333 // encoding: [0x93,0xe6,0x00,0x72]
3154 // CHECK: ands w21, w22, #0x99999999 // encoding: [0xd5,0xe6,0x01,0x72]
3156 // 2 bit replication width
3158 tst wzr, #0x55555555
3159 // CHECK: ands wzr, w3, #0xaaaaaaaa // encoding: [0x7f,0xf0,0x01,0x72]
3160 // CHECK: ands wzr, wzr, #0x55555555 // encoding: [0xff,0xf3,0x00,0x72]
3162 // 64 bit replication-width
3163 eor x3, x5, #0xffffffffc000000
3164 and x9, x10, #0x00007fffffffffff
3165 orr x11, x12, #0x8000000000000fff
3166 // CHECK: eor x3, x5, #0xffffffffc000000 // encoding: [0xa3,0x84,0x66,0xd2]
3167 // CHECK: and x9, x10, #0x7fffffffffff // encoding: [0x49,0xb9,0x40,0x92]
3168 // CHECK: orr x11, x12, #0x8000000000000fff // encoding: [0x8b,0x31,0x41,0xb2]
3170 // 32 bit replication-width
3171 orr x3, x9, #0xffff0000ffff0000
3172 orr sp, x10, #0xe00000ffe00000ff
3173 orr x9, x10, #0x000003ff000003ff
3174 // CHECK: orr x3, x9, #0xffff0000ffff0000 // encoding: [0x23,0x3d,0x10,0xb2]
3175 // CHECK: orr sp, x10, #0xe00000ffe00000ff // encoding: [0x5f,0x29,0x03,0xb2]
3176 // CHECK: orr x9, x10, #0x3ff000003ff // encoding: [0x49,0x25,0x00,0xb2]
3178 // 16 bit replication-width
3179 and x14, x15, #0x8000800080008000
3180 and x12, x13, #0xffc3ffc3ffc3ffc3
3181 and x11, xzr, #0x0003000300030003
3182 // CHECK: and x14, x15, #0x8000800080008000 // encoding: [0xee,0x81,0x01,0x92]
3183 // CHECK: and x12, x13, #0xffc3ffc3ffc3ffc3 // encoding: [0xac,0xad,0x0a,0x92]
3184 // CHECK: and x11, xzr, #0x3000300030003 // encoding: [0xeb,0x87,0x00,0x92]
3186 // 8 bit replication-width
3187 eor x3, x6, #0xe0e0e0e0e0e0e0e0
3188 eor sp, xzr, #0x0303030303030303
3189 eor x16, x17, #0x8181818181818181
3190 // CHECK: eor x3, x6, #0xe0e0e0e0e0e0e0e0 // encoding: [0xc3,0xc8,0x03,0xd2]
3191 // CHECK: eor sp, xzr, #0x303030303030303 // encoding: [0xff,0xc7,0x00,0xd2]
3192 // CHECK: eor x16, x17, #0x8181818181818181 // encoding: [0x30,0xc6,0x01,0xd2]
3194 // 4 bit replication-width
3195 ands xzr, x18, #0xcccccccccccccccc
3196 ands x19, x20, #0x3333333333333333
3197 ands x21, x22, #0x9999999999999999
3198 // CHECK: ands xzr, x18, #0xcccccccccccccccc // encoding: [0x5f,0xe6,0x02,0xf2]
3199 // CHECK: ands x19, x20, #0x3333333333333333 // encoding: [0x93,0xe6,0x00,0xf2]
3200 // CHECK: ands x21, x22, #0x9999999999999999 // encoding: [0xd5,0xe6,0x01,0xf2]
3202 // 2 bit replication-width
3203 tst x3, #0xaaaaaaaaaaaaaaaa
3204 tst xzr, #0x5555555555555555
3205 // CHECK: ands xzr, x3, #0xaaaaaaaaaaaaaaaa // encoding: [0x7f,0xf0,0x01,0xf2]
3206 // CHECK: ands xzr, xzr, #0x5555555555555555 // encoding: [0xff,0xf3,0x00,0xf2]
3209 mov x10, #0xaaaaaaaaaaaaaaaa
3210 // CHECK: orr w3, wzr, #0xf000f // encoding: [0xe3,0x8f,0x00,0x32]
3211 // CHECK: orr x10, xzr, #0xaaaaaaaaaaaaaaaa // encoding: [0xea,0xf3,0x01,0xb2]
3213 //------------------------------------------------------------------------------
3214 // Logical (shifted register)
3215 //------------------------------------------------------------------------------
3218 and w16, w15, w1, lsl #1
3219 and w9, w4, w10, lsl #31
3220 and w3, w30, w11, lsl #0
3221 and x3, x5, x7, lsl #63
3222 // CHECK: and w12, w23, w21 // encoding: [0xec,0x02,0x15,0x0a]
3223 // CHECK: and w16, w15, w1, lsl #1 // encoding: [0xf0,0x05,0x01,0x0a]
3224 // CHECK: and w9, w4, w10, lsl #31 // encoding: [0x89,0x7c,0x0a,0x0a]
3225 // CHECK: and w3, w30, w11 // encoding: [0xc3,0x03,0x0b,0x0a]
3226 // CHECK: and x3, x5, x7, lsl #63 // encoding: [0xa3,0xfc,0x07,0x8a]
3228 and x5, x14, x19, asr #4
3229 and w3, w17, w19, ror #31
3230 and w0, w2, wzr, lsr #17
3231 and w3, w30, w11, asr #0
3232 // CHECK: and x5, x14, x19, asr #4 // encoding: [0xc5,0x11,0x93,0x8a]
3233 // CHECK: and w3, w17, w19, ror #31 // encoding: [0x23,0x7e,0xd3,0x0a]
3234 // CHECK: and w0, w2, wzr, lsr #17 // encoding: [0x40,0x44,0x5f,0x0a]
3235 // CHECK: and w3, w30, w11, asr #0 // encoding: [0xc3,0x03,0x8b,0x0a]
3237 and xzr, x4, x26, lsl #0
3238 and w3, wzr, w20, ror #0
3239 and x7, x20, xzr, asr #63
3240 // CHECK: and xzr, x4, x26 // encoding: [0x9f,0x00,0x1a,0x8a]
3241 // CHECK: and w3, wzr, w20, ror #0 // encoding: [0xe3,0x03,0xd4,0x0a]
3242 // CHECK: and x7, x20, xzr, asr #63 // encoding: [0x87,0xfe,0x9f,0x8a]
3244 bic x13, x20, x14, lsl #47
3246 orr w2, w7, w0, asr #31
3247 orr x8, x9, x10, lsl #12
3248 orn x3, x5, x7, asr #0
3250 // CHECK: bic x13, x20, x14, lsl #47 // encoding: [0x8d,0xbe,0x2e,0x8a]
3251 // CHECK: bic w2, w7, w9 // encoding: [0xe2,0x00,0x29,0x0a]
3252 // CHECK: orr w2, w7, w0, asr #31 // encoding: [0xe2,0x7c,0x80,0x2a]
3253 // CHECK: orr x8, x9, x10, lsl #12 // encoding: [0x28,0x31,0x0a,0xaa]
3254 // CHECK: orn x3, x5, x7, asr #0 // encoding: [0xa3,0x00,0xa7,0xaa]
3255 // CHECK: orn w2, w5, w29 // encoding: [0xa2,0x00,0x3d,0x2a]
3257 ands w7, wzr, w9, lsl #1
3258 ands x3, x5, x20, ror #63
3259 bics w3, w5, w7, lsl #0
3260 bics x3, xzr, x3, lsl #1
3261 // CHECK: ands w7, wzr, w9, lsl #1 // encoding: [0xe7,0x07,0x09,0x6a]
3262 // CHECK: ands x3, x5, x20, ror #63 // encoding: [0xa3,0xfc,0xd4,0xea]
3263 // CHECK: bics w3, w5, w7 // encoding: [0xa3,0x00,0x27,0x6a]
3264 // CHECK: bics x3, xzr, x3, lsl #1 // encoding: [0xe3,0x07,0x23,0xea]
3268 // CHECK: tst w3, w7, lsl #31 // encoding: [0x7f,0x7c,0x07,0x6a]
3269 // CHECK: tst x2, x20, asr #0 // encoding: [0x5f,0x00,0x94,0xea]
3275 // CHECK: mov x3, x6 // encoding: [0xe3,0x03,0x06,0xaa]
3276 // CHECK: mov x3, xzr // encoding: [0xe3,0x03,0x1f,0xaa]
3277 // CHECK: mov wzr, w2 // encoding: [0xff,0x03,0x02,0x2a]
3278 // CHECK: mov w3, w5 // encoding: [0xe3,0x03,0x05,0x2a]
3280 //------------------------------------------------------------------------------
3281 // Move wide (immediate)
3282 //------------------------------------------------------------------------------
3284 movz w1, #65535, lsl #0
3285 movz w2, #0, lsl #16
3286 movn w2, #1234, lsl #0
3287 // CHECK: movz w1, #65535 // encoding: [0xe1,0xff,0x9f,0x52]
3288 // CHECK: movz w2, #0, lsl #16 // encoding: [0x02,0x00,0xa0,0x52]
3289 // CHECK: movn w2, #1234 // encoding: [0x42,0x9a,0x80,0x12]
3291 movz x2, #1234, lsl #32
3292 movk xzr, #4321, lsl #48
3293 // CHECK: movz x2, #1234, lsl #32 // encoding: [0x42,0x9a,0xc0,0xd2]
3294 // CHECK: movk xzr, #4321, lsl #48 // encoding: [0x3f,0x1c,0xe2,0xf2]
3296 movz x2, #:abs_g0:sym
3297 movk w3, #:abs_g0_nc:sym
3298 // CHECK: movz x2, #:abs_g0:sym // encoding: [0x02'A',A,0x80'A',0xd2'A']
3299 // CHECK-NEXT: // fixup A - offset: 0, value: :abs_g0:sym, kind: fixup_a64_movw_uabs_g0
3300 // CHECK: movk w3, #:abs_g0_nc:sym // encoding: [0x03'A',A,0x80'A',0x72'A']
3301 // CHECK-NEXT: // fixup A - offset: 0, value: :abs_g0_nc:sym, kind: fixup_a64_movw_uabs_g0_nc
3303 movz x4, #:abs_g1:sym
3304 movk w5, #:abs_g1_nc:sym
3305 // CHECK: movz x4, #:abs_g1:sym // encoding: [0x04'A',A,0xa0'A',0xd2'A']
3306 // CHECK-NEXT: // fixup A - offset: 0, value: :abs_g1:sym, kind: fixup_a64_movw_uabs_g1
3307 // CHECK: movk w5, #:abs_g1_nc:sym // encoding: [0x05'A',A,0xa0'A',0x72'A']
3308 // CHECK-NEXT: // fixup A - offset: 0, value: :abs_g1_nc:sym, kind: fixup_a64_movw_uabs_g1_nc
3310 movz x6, #:abs_g2:sym
3311 movk x7, #:abs_g2_nc:sym
3312 // CHECK: movz x6, #:abs_g2:sym // encoding: [0x06'A',A,0xc0'A',0xd2'A']
3313 // CHECK-NEXT: // fixup A - offset: 0, value: :abs_g2:sym, kind: fixup_a64_movw_uabs_g2
3314 // CHECK: movk x7, #:abs_g2_nc:sym // encoding: [0x07'A',A,0xc0'A',0xf2'A']
3315 // CHECK-NEXT: // fixup A - offset: 0, value: :abs_g2_nc:sym, kind: fixup_a64_movw_uabs_g2_nc
3317 movz x8, #:abs_g3:sym
3318 movk x9, #:abs_g3:sym
3319 // CHECK: movz x8, #:abs_g3:sym // encoding: [0x08'A',A,0xe0'A',0xd2'A']
3320 // CHECK-NEXT: // fixup A - offset: 0, value: :abs_g3:sym, kind: fixup_a64_movw_uabs_g3
3321 // CHECK: movk x9, #:abs_g3:sym // encoding: [0x09'A',A,0xe0'A',0xf2'A']
3322 // CHECK-NEXT: // fixup A - offset: 0, value: :abs_g3:sym, kind: fixup_a64_movw_uabs_g3
3324 movn x30, #:abs_g0_s:sym
3325 movz x19, #:abs_g0_s:sym
3326 movn w10, #:abs_g0_s:sym
3327 movz w25, #:abs_g0_s:sym
3328 // CHECK: movn x30, #:abs_g0_s:sym // encoding: [0x1e'A',A,0x80'A',0x92'A']
3329 // CHECK-NEXT: // fixup A - offset: 0, value: :abs_g0_s:sym, kind: fixup_a64_movw_sabs_g0
3330 // CHECK: movz x19, #:abs_g0_s:sym // encoding: [0x13'A',A,0x80'A',0x92'A']
3331 // CHECK-NEXT: // fixup A - offset: 0, value: :abs_g0_s:sym, kind: fixup_a64_movw_sabs_g0
3332 // CHECK: movn w10, #:abs_g0_s:sym // encoding: [0x0a'A',A,0x80'A',0x12'A']
3333 // CHECK-NEXT: // fixup A - offset: 0, value: :abs_g0_s:sym, kind: fixup_a64_movw_sabs_g0
3334 // CHECK: movz w25, #:abs_g0_s:sym // encoding: [0x19'A',A,0x80'A',0x12'A']
3335 // CHECK-NEXT: // fixup A - offset: 0, value: :abs_g0_s:sym, kind: fixup_a64_movw_sabs_g0
3337 movn x30, #:abs_g1_s:sym
3338 movz x19, #:abs_g1_s:sym
3339 movn w10, #:abs_g1_s:sym
3340 movz w25, #:abs_g1_s:sym
3341 // CHECK: movn x30, #:abs_g1_s:sym // encoding: [0x1e'A',A,0xa0'A',0x92'A']
3342 // CHECK-NEXT: // fixup A - offset: 0, value: :abs_g1_s:sym, kind: fixup_a64_movw_sabs_g1
3343 // CHECK: movz x19, #:abs_g1_s:sym // encoding: [0x13'A',A,0xa0'A',0x92'A']
3344 // CHECK-NEXT: // fixup A - offset: 0, value: :abs_g1_s:sym, kind: fixup_a64_movw_sabs_g1
3345 // CHECK: movn w10, #:abs_g1_s:sym // encoding: [0x0a'A',A,0xa0'A',0x12'A']
3346 // CHECK-NEXT: // fixup A - offset: 0, value: :abs_g1_s:sym, kind: fixup_a64_movw_sabs_g1
3347 // CHECK: movz w25, #:abs_g1_s:sym // encoding: [0x19'A',A,0xa0'A',0x12'A']
3348 // CHECK-NEXT: // fixup A - offset: 0, value: :abs_g1_s:sym, kind: fixup_a64_movw_sabs_g1
3350 movn x30, #:abs_g2_s:sym
3351 movz x19, #:abs_g2_s:sym
3352 // CHECK: movn x30, #:abs_g2_s:sym // encoding: [0x1e'A',A,0xc0'A',0x92'A']
3353 // CHECK-NEXT: // fixup A - offset: 0, value: :abs_g2_s:sym, kind: fixup_a64_movw_sabs_g2
3354 // CHECK: movz x19, #:abs_g2_s:sym // encoding: [0x13'A',A,0xc0'A',0x92'A']
3355 // CHECK-NEXT: // fixup A - offset: 0, value: :abs_g2_s:sym, kind: fixup_a64_movw_sabs_g2
3357 //------------------------------------------------------------------------------
3358 // PC-relative addressing
3359 //------------------------------------------------------------------------------
3363 // CHECK: adr x2, loc // encoding: [0x02'A',A,A,0x10'A']
3364 // CHECK: // fixup A - offset: 0, value: loc, kind: fixup_a64_adr_prel
3365 // CHECK: adr xzr, loc // encoding: [0x1f'A',A,A,0x10'A']
3366 // CHECK: // fixup A - offset: 0, value: loc, kind: fixup_a64_adr_prel
3369 // CHECK: adrp x29, loc // encoding: [0x1d'A',A,A,0x90'A']
3370 // CHECK: // fixup A - offset: 0, value: loc, kind: fixup_a64_adr_prel_page
3376 // CHECK: adrp x30, #4096 // encoding: [0x1e,0x00,0x00,0xb0]
3377 // CHECK: adr x20, #0 // encoding: [0x14,0x00,0x00,0x10]
3378 // CHECK: adr x9, #-1 // encoding: [0xe9,0xff,0xff,0x70]
3379 // CHECK: adr x5, #1048575 // encoding: [0xe5,0xff,0x7f,0x70]
3383 adrp x9, #4294963200
3384 adrp x20, #-4294967296
3385 // CHECK: adr x9, #1048575 // encoding: [0xe9,0xff,0x7f,0x70]
3386 // CHECK: adr x2, #-1048576 // encoding: [0x02,0x00,0x80,0x10]
3387 // CHECK: adrp x9, #4294963200 // encoding: [0xe9,0xff,0x7f,0xf0]
3388 // CHECK: adrp x20, #-4294967296 // encoding: [0x14,0x00,0x80,0x90]
3390 //------------------------------------------------------------------------------
3392 //------------------------------------------------------------------------------
3396 // CHECK: nop // encoding: [0x1f,0x20,0x03,0xd5]
3397 // CHECK: hint #127 // encoding: [0xff,0x2f,0x03,0xd5]
3405 // CHECK: nop // encoding: [0x1f,0x20,0x03,0xd5]
3406 // CHECK: yield // encoding: [0x3f,0x20,0x03,0xd5]
3407 // CHECK: wfe // encoding: [0x5f,0x20,0x03,0xd5]
3408 // CHECK: wfi // encoding: [0x7f,0x20,0x03,0xd5]
3409 // CHECK: sev // encoding: [0x9f,0x20,0x03,0xd5]
3410 // CHECK: sevl // encoding: [0xbf,0x20,0x03,0xd5]
3416 // CHECK: clrex // encoding: [0x5f,0x3f,0x03,0xd5]
3417 // CHECK: clrex #0 // encoding: [0x5f,0x30,0x03,0xd5]
3418 // CHECK: clrex #7 // encoding: [0x5f,0x37,0x03,0xd5]
3419 // CHECK: clrex // encoding: [0x5f,0x3f,0x03,0xd5]
3436 // CHECK: dsb #0 // encoding: [0x9f,0x30,0x03,0xd5]
3437 // CHECK: dsb #12 // encoding: [0x9f,0x3c,0x03,0xd5]
3438 // CHECK: dsb sy // encoding: [0x9f,0x3f,0x03,0xd5]
3439 // CHECK: dsb oshld // encoding: [0x9f,0x31,0x03,0xd5]
3440 // CHECK: dsb oshst // encoding: [0x9f,0x32,0x03,0xd5]
3441 // CHECK: dsb osh // encoding: [0x9f,0x33,0x03,0xd5]
3442 // CHECK: dsb nshld // encoding: [0x9f,0x35,0x03,0xd5]
3443 // CHECK: dsb nshst // encoding: [0x9f,0x36,0x03,0xd5]
3444 // CHECK: dsb nsh // encoding: [0x9f,0x37,0x03,0xd5]
3445 // CHECK: dsb ishld // encoding: [0x9f,0x39,0x03,0xd5]
3446 // CHECK: dsb ishst // encoding: [0x9f,0x3a,0x03,0xd5]
3447 // CHECK: dsb ish // encoding: [0x9f,0x3b,0x03,0xd5]
3448 // CHECK: dsb ld // encoding: [0x9f,0x3d,0x03,0xd5]
3449 // CHECK: dsb st // encoding: [0x9f,0x3e,0x03,0xd5]
3450 // CHECK: dsb sy // encoding: [0x9f,0x3f,0x03,0xd5]
3467 // CHECK: dmb #0 // encoding: [0xbf,0x30,0x03,0xd5]
3468 // CHECK: dmb #12 // encoding: [0xbf,0x3c,0x03,0xd5]
3469 // CHECK: dmb sy // encoding: [0xbf,0x3f,0x03,0xd5]
3470 // CHECK: dmb oshld // encoding: [0xbf,0x31,0x03,0xd5]
3471 // CHECK: dmb oshst // encoding: [0xbf,0x32,0x03,0xd5]
3472 // CHECK: dmb osh // encoding: [0xbf,0x33,0x03,0xd5]
3473 // CHECK: dmb nshld // encoding: [0xbf,0x35,0x03,0xd5]
3474 // CHECK: dmb nshst // encoding: [0xbf,0x36,0x03,0xd5]
3475 // CHECK: dmb nsh // encoding: [0xbf,0x37,0x03,0xd5]
3476 // CHECK: dmb ishld // encoding: [0xbf,0x39,0x03,0xd5]
3477 // CHECK: dmb ishst // encoding: [0xbf,0x3a,0x03,0xd5]
3478 // CHECK: dmb ish // encoding: [0xbf,0x3b,0x03,0xd5]
3479 // CHECK: dmb ld // encoding: [0xbf,0x3d,0x03,0xd5]
3480 // CHECK: dmb st // encoding: [0xbf,0x3e,0x03,0xd5]
3481 // CHECK: dmb sy // encoding: [0xbf,0x3f,0x03,0xd5]
3486 // CHECK: isb // encoding: [0xdf,0x3f,0x03,0xd5]
3487 // CHECK: isb // encoding: [0xdf,0x3f,0x03,0xd5]
3488 // CHECK: isb #12 // encoding: [0xdf,0x3c,0x03,0xd5]
3494 // CHECK: msr spsel, #0 // encoding: [0xbf,0x40,0x00,0xd5]
3495 // CHECK: msr daifset, #15 // encoding: [0xdf,0x4f,0x03,0xd5]
3496 // CHECK: msr daifclr, #12 // encoding: [0xff,0x4c,0x03,0xd5]
3498 sys #7, c5, c9, #7, x5
3499 sys #0, c15, c15, #2
3500 // CHECK: sys #7, c5, c9, #7, x5 // encoding: [0xe5,0x59,0x0f,0xd5]
3501 // CHECK: sys #0, c15, c15, #2, xzr // encoding: [0x5f,0xff,0x08,0xd5]
3503 sysl x9, #7, c5, c9, #7
3504 sysl x1, #0, c15, c15, #2
3505 // CHECK: sysl x9, #7, c5, c9, #7 // encoding: [0xe9,0x59,0x2f,0xd5]
3506 // CHECK: sysl x1, #0, c15, c15, #2 // encoding: [0x41,0xff,0x28,0xd5]
3511 // CHECK: ic ialluis // encoding: [0x1f,0x71,0x08,0xd5]
3512 // CHECK: ic iallu // encoding: [0x1f,0x75,0x08,0xd5]
3513 // CHECK: ic ivau, x9 // encoding: [0x29,0x75,0x0b,0xd5]
3523 // CHECK: dc zva, x12 // encoding: [0x2c,0x74,0x0b,0xd5]
3524 // CHECK: dc ivac, xzr // encoding: [0x3f,0x76,0x08,0xd5]
3525 // CHECK: dc isw, x2 // encoding: [0x42,0x76,0x08,0xd5]
3526 // CHECK: dc cvac, x9 // encoding: [0x29,0x7a,0x0b,0xd5]
3527 // CHECK: dc csw, x10 // encoding: [0x4a,0x7a,0x08,0xd5]
3528 // CHECK: dc cvau, x0 // encoding: [0x20,0x7b,0x0b,0xd5]
3529 // CHECK: dc civac, x3 // encoding: [0x23,0x7e,0x0b,0xd5]
3530 // CHECK: dc cisw, x30 // encoding: [0x5e,0x7e,0x08,0xd5]
3544 // CHECK: at s1e1r, x19 // encoding: [0x13,0x78,0x08,0xd5]
3545 // CHECK: at s1e2r, x19 // encoding: [0x13,0x78,0x0c,0xd5]
3546 // CHECK: at s1e3r, x19 // encoding: [0x13,0x78,0x0e,0xd5]
3547 // CHECK: at s1e1w, x19 // encoding: [0x33,0x78,0x08,0xd5]
3548 // CHECK: at s1e2w, x19 // encoding: [0x33,0x78,0x0c,0xd5]
3549 // CHECK: at s1e3w, x19 // encoding: [0x33,0x78,0x0e,0xd5]
3550 // CHECK: at s1e0r, x19 // encoding: [0x53,0x78,0x08,0xd5]
3551 // CHECK: at s1e0w, x19 // encoding: [0x73,0x78,0x08,0xd5]
3552 // CHECK: at s12e1r, x20 // encoding: [0x94,0x78,0x0c,0xd5]
3553 // CHECK: at s12e1w, x20 // encoding: [0xb4,0x78,0x0c,0xd5]
3554 // CHECK: at s12e0r, x20 // encoding: [0xd4,0x78,0x0c,0xd5]
3555 // CHECK: at s12e0w, x20 // encoding: [0xf4,0x78,0x0c,0xd5]
3589 // CHECK: tlbi ipas2e1is, x4 // encoding: [0x24,0x80,0x0c,0xd5]
3590 // CHECK: tlbi ipas2le1is, x9 // encoding: [0xa9,0x80,0x0c,0xd5]
3591 // CHECK: tlbi vmalle1is // encoding: [0x1f,0x83,0x08,0xd5]
3592 // CHECK: tlbi alle2is // encoding: [0x1f,0x83,0x0c,0xd5]
3593 // CHECK: tlbi alle3is // encoding: [0x1f,0x83,0x0e,0xd5]
3594 // CHECK: tlbi vae1is, x1 // encoding: [0x21,0x83,0x08,0xd5]
3595 // CHECK: tlbi vae2is, x2 // encoding: [0x22,0x83,0x0c,0xd5]
3596 // CHECK: tlbi vae3is, x3 // encoding: [0x23,0x83,0x0e,0xd5]
3597 // CHECK: tlbi aside1is, x5 // encoding: [0x45,0x83,0x08,0xd5]
3598 // CHECK: tlbi vaae1is, x9 // encoding: [0x69,0x83,0x08,0xd5]
3599 // CHECK: tlbi alle1is // encoding: [0x9f,0x83,0x0c,0xd5]
3600 // CHECK: tlbi vale1is, x10 // encoding: [0xaa,0x83,0x08,0xd5]
3601 // CHECK: tlbi vale2is, x11 // encoding: [0xab,0x83,0x0c,0xd5]
3602 // CHECK: tlbi vale3is, x13 // encoding: [0xad,0x83,0x0e,0xd5]
3603 // CHECK: tlbi vmalls12e1is // encoding: [0xdf,0x83,0x0c,0xd5]
3604 // CHECK: tlbi vaale1is, x14 // encoding: [0xee,0x83,0x08,0xd5]
3605 // CHECK: tlbi ipas2e1, x15 // encoding: [0x2f,0x84,0x0c,0xd5]
3606 // CHECK: tlbi ipas2le1, x16 // encoding: [0xb0,0x84,0x0c,0xd5]
3607 // CHECK: tlbi vmalle1 // encoding: [0x1f,0x87,0x08,0xd5]
3608 // CHECK: tlbi alle2 // encoding: [0x1f,0x87,0x0c,0xd5]
3609 // CHECK: tlbi alle3 // encoding: [0x1f,0x87,0x0e,0xd5]
3610 // CHECK: tlbi vae1, x17 // encoding: [0x31,0x87,0x08,0xd5]
3611 // CHECK: tlbi vae2, x18 // encoding: [0x32,0x87,0x0c,0xd5]
3612 // CHECK: tlbi vae3, x19 // encoding: [0x33,0x87,0x0e,0xd5]
3613 // CHECK: tlbi aside1, x20 // encoding: [0x54,0x87,0x08,0xd5]
3614 // CHECK: tlbi vaae1, x21 // encoding: [0x75,0x87,0x08,0xd5]
3615 // CHECK: tlbi alle1 // encoding: [0x9f,0x87,0x0c,0xd5]
3616 // CHECK: tlbi vale1, x22 // encoding: [0xb6,0x87,0x08,0xd5]
3617 // CHECK: tlbi vale2, x23 // encoding: [0xb7,0x87,0x0c,0xd5]
3618 // CHECK: tlbi vale3, x24 // encoding: [0xb8,0x87,0x0e,0xd5]
3619 // CHECK: tlbi vmalls12e1 // encoding: [0xdf,0x87,0x0c,0xd5]
3620 // CHECK: tlbi vaale1, x25 // encoding: [0xf9,0x87,0x08,0xd5]
3622 msr TEECR32_EL1, x12
3623 msr OSDTRRX_EL1, x12
3624 msr MDCCINT_EL1, x12
3626 msr OSDTRTX_EL1, x12
3628 msr DBGDTRTX_EL0, x12
3630 msr DBGVCR32_EL2, x12
3631 msr DBGBVR0_EL1, x12
3632 msr DBGBVR1_EL1, x12
3633 msr DBGBVR2_EL1, x12
3634 msr DBGBVR3_EL1, x12
3635 msr DBGBVR4_EL1, x12
3636 msr DBGBVR5_EL1, x12
3637 msr DBGBVR6_EL1, x12
3638 msr DBGBVR7_EL1, x12
3639 msr DBGBVR8_EL1, x12
3640 msr DBGBVR9_EL1, x12
3641 msr DBGBVR10_EL1, x12
3642 msr DBGBVR11_EL1, x12
3643 msr DBGBVR12_EL1, x12
3644 msr DBGBVR13_EL1, x12
3645 msr DBGBVR14_EL1, x12
3646 msr DBGBVR15_EL1, x12
3647 msr DBGBCR0_EL1, x12
3648 msr DBGBCR1_EL1, x12
3649 msr DBGBCR2_EL1, x12
3650 msr DBGBCR3_EL1, x12
3651 msr DBGBCR4_EL1, x12
3652 msr DBGBCR5_EL1, x12
3653 msr DBGBCR6_EL1, x12
3654 msr DBGBCR7_EL1, x12
3655 msr DBGBCR8_EL1, x12
3656 msr DBGBCR9_EL1, x12
3657 msr DBGBCR10_EL1, x12
3658 msr DBGBCR11_EL1, x12
3659 msr DBGBCR12_EL1, x12
3660 msr DBGBCR13_EL1, x12
3661 msr DBGBCR14_EL1, x12
3662 msr DBGBCR15_EL1, x12
3663 msr DBGWVR0_EL1, x12
3664 msr DBGWVR1_EL1, x12
3665 msr DBGWVR2_EL1, x12
3666 msr DBGWVR3_EL1, x12
3667 msr DBGWVR4_EL1, x12
3668 msr DBGWVR5_EL1, x12
3669 msr DBGWVR6_EL1, x12
3670 msr DBGWVR7_EL1, x12
3671 msr DBGWVR8_EL1, x12
3672 msr DBGWVR9_EL1, x12
3673 msr DBGWVR10_EL1, x12
3674 msr DBGWVR11_EL1, x12
3675 msr DBGWVR12_EL1, x12
3676 msr DBGWVR13_EL1, x12
3677 msr DBGWVR14_EL1, x12
3678 msr DBGWVR15_EL1, x12
3679 msr DBGWCR0_EL1, x12
3680 msr DBGWCR1_EL1, x12
3681 msr DBGWCR2_EL1, x12
3682 msr DBGWCR3_EL1, x12
3683 msr DBGWCR4_EL1, x12
3684 msr DBGWCR5_EL1, x12
3685 msr DBGWCR6_EL1, x12
3686 msr DBGWCR7_EL1, x12
3687 msr DBGWCR8_EL1, x12
3688 msr DBGWCR9_EL1, x12
3689 msr DBGWCR10_EL1, x12
3690 msr DBGWCR11_EL1, x12
3691 msr DBGWCR12_EL1, x12
3692 msr DBGWCR13_EL1, x12
3693 msr DBGWCR14_EL1, x12
3694 msr DBGWCR15_EL1, x12
3695 msr TEEHBR32_EL1, x12
3698 msr DBGPRCR_EL1, x12
3699 msr DBGCLAIMSET_EL1, x12
3700 msr DBGCLAIMCLR_EL1, x12
3761 msr FPEXC32_EL2, x12
3768 msr PMCNTENSET_EL0, x12
3769 msr PMCNTENCLR_EL0, x12
3770 msr PMOVSCLR_EL0, x12
3772 msr PMCCNTR_EL0, x12
3773 msr PMXEVTYPER_EL0, x12
3774 msr PMXEVCNTR_EL0, x12
3775 msr PMUSERENR_EL0, x12
3776 msr PMINTENSET_EL1, x12
3777 msr PMINTENCLR_EL1, x12
3778 msr PMOVSSET_EL0, x12
3791 msr CONTEXTIDR_EL1, x12
3795 msr TPIDRRO_EL0, x12
3798 msr CNTVOFF_EL2, x12
3799 msr CNTKCTL_EL1, x12
3800 msr CNTHCTL_EL2, x12
3801 msr CNTP_TVAL_EL0, x12
3802 msr CNTHP_TVAL_EL2, x12
3803 msr CNTPS_TVAL_EL1, x12
3804 msr CNTP_CTL_EL0, x12
3805 msr CNTHP_CTL_EL2, x12
3806 msr CNTPS_CTL_EL1, x12
3807 msr CNTP_CVAL_EL0, x12
3808 msr CNTHP_CVAL_EL2, x12
3809 msr CNTPS_CVAL_EL1, x12
3810 msr CNTV_TVAL_EL0, x12
3811 msr CNTV_CTL_EL0, x12
3812 msr CNTV_CVAL_EL0, x12
3813 msr PMEVCNTR0_EL0, x12
3814 msr PMEVCNTR1_EL0, x12
3815 msr PMEVCNTR2_EL0, x12
3816 msr PMEVCNTR3_EL0, x12
3817 msr PMEVCNTR4_EL0, x12
3818 msr PMEVCNTR5_EL0, x12
3819 msr PMEVCNTR6_EL0, x12
3820 msr PMEVCNTR7_EL0, x12
3821 msr PMEVCNTR8_EL0, x12
3822 msr PMEVCNTR9_EL0, x12
3823 msr PMEVCNTR10_EL0, x12
3824 msr PMEVCNTR11_EL0, x12
3825 msr PMEVCNTR12_EL0, x12
3826 msr PMEVCNTR13_EL0, x12
3827 msr PMEVCNTR14_EL0, x12
3828 msr PMEVCNTR15_EL0, x12
3829 msr PMEVCNTR16_EL0, x12
3830 msr PMEVCNTR17_EL0, x12
3831 msr PMEVCNTR18_EL0, x12
3832 msr PMEVCNTR19_EL0, x12
3833 msr PMEVCNTR20_EL0, x12
3834 msr PMEVCNTR21_EL0, x12
3835 msr PMEVCNTR22_EL0, x12
3836 msr PMEVCNTR23_EL0, x12
3837 msr PMEVCNTR24_EL0, x12
3838 msr PMEVCNTR25_EL0, x12
3839 msr PMEVCNTR26_EL0, x12
3840 msr PMEVCNTR27_EL0, x12
3841 msr PMEVCNTR28_EL0, x12
3842 msr PMEVCNTR29_EL0, x12
3843 msr PMEVCNTR30_EL0, x12
3844 msr PMCCFILTR_EL0, x12
3845 msr PMEVTYPER0_EL0, x12
3846 msr PMEVTYPER1_EL0, x12
3847 msr PMEVTYPER2_EL0, x12
3848 msr PMEVTYPER3_EL0, x12
3849 msr PMEVTYPER4_EL0, x12
3850 msr PMEVTYPER5_EL0, x12
3851 msr PMEVTYPER6_EL0, x12
3852 msr PMEVTYPER7_EL0, x12
3853 msr PMEVTYPER8_EL0, x12
3854 msr PMEVTYPER9_EL0, x12
3855 msr PMEVTYPER10_EL0, x12
3856 msr PMEVTYPER11_EL0, x12
3857 msr PMEVTYPER12_EL0, x12
3858 msr PMEVTYPER13_EL0, x12
3859 msr PMEVTYPER14_EL0, x12
3860 msr PMEVTYPER15_EL0, x12
3861 msr PMEVTYPER16_EL0, x12
3862 msr PMEVTYPER17_EL0, x12
3863 msr PMEVTYPER18_EL0, x12
3864 msr PMEVTYPER19_EL0, x12
3865 msr PMEVTYPER20_EL0, x12
3866 msr PMEVTYPER21_EL0, x12
3867 msr PMEVTYPER22_EL0, x12
3868 msr PMEVTYPER23_EL0, x12
3869 msr PMEVTYPER24_EL0, x12
3870 msr PMEVTYPER25_EL0, x12
3871 msr PMEVTYPER26_EL0, x12
3872 msr PMEVTYPER27_EL0, x12
3873 msr PMEVTYPER28_EL0, x12
3874 msr PMEVTYPER29_EL0, x12
3875 msr PMEVTYPER30_EL0, x12
3876 // CHECK: msr teecr32_el1, x12 // encoding: [0x0c,0x00,0x12,0xd5]
3877 // CHECK: msr osdtrrx_el1, x12 // encoding: [0x4c,0x00,0x10,0xd5]
3878 // CHECK: msr mdccint_el1, x12 // encoding: [0x0c,0x02,0x10,0xd5]
3879 // CHECK: msr mdscr_el1, x12 // encoding: [0x4c,0x02,0x10,0xd5]
3880 // CHECK: msr osdtrtx_el1, x12 // encoding: [0x4c,0x03,0x10,0xd5]
3881 // CHECK: msr dbgdtr_el0, x12 // encoding: [0x0c,0x04,0x13,0xd5]
3882 // CHECK: msr dbgdtrtx_el0, x12 // encoding: [0x0c,0x05,0x13,0xd5]
3883 // CHECK: msr oseccr_el1, x12 // encoding: [0x4c,0x06,0x10,0xd5]
3884 // CHECK: msr dbgvcr32_el2, x12 // encoding: [0x0c,0x07,0x14,0xd5]
3885 // CHECK: msr dbgbvr0_el1, x12 // encoding: [0x8c,0x00,0x10,0xd5]
3886 // CHECK: msr dbgbvr1_el1, x12 // encoding: [0x8c,0x01,0x10,0xd5]
3887 // CHECK: msr dbgbvr2_el1, x12 // encoding: [0x8c,0x02,0x10,0xd5]
3888 // CHECK: msr dbgbvr3_el1, x12 // encoding: [0x8c,0x03,0x10,0xd5]
3889 // CHECK: msr dbgbvr4_el1, x12 // encoding: [0x8c,0x04,0x10,0xd5]
3890 // CHECK: msr dbgbvr5_el1, x12 // encoding: [0x8c,0x05,0x10,0xd5]
3891 // CHECK: msr dbgbvr6_el1, x12 // encoding: [0x8c,0x06,0x10,0xd5]
3892 // CHECK: msr dbgbvr7_el1, x12 // encoding: [0x8c,0x07,0x10,0xd5]
3893 // CHECK: msr dbgbvr8_el1, x12 // encoding: [0x8c,0x08,0x10,0xd5]
3894 // CHECK: msr dbgbvr9_el1, x12 // encoding: [0x8c,0x09,0x10,0xd5]
3895 // CHECK: msr dbgbvr10_el1, x12 // encoding: [0x8c,0x0a,0x10,0xd5]
3896 // CHECK: msr dbgbvr11_el1, x12 // encoding: [0x8c,0x0b,0x10,0xd5]
3897 // CHECK: msr dbgbvr12_el1, x12 // encoding: [0x8c,0x0c,0x10,0xd5]
3898 // CHECK: msr dbgbvr13_el1, x12 // encoding: [0x8c,0x0d,0x10,0xd5]
3899 // CHECK: msr dbgbvr14_el1, x12 // encoding: [0x8c,0x0e,0x10,0xd5]
3900 // CHECK: msr dbgbvr15_el1, x12 // encoding: [0x8c,0x0f,0x10,0xd5]
3901 // CHECK: msr dbgbcr0_el1, x12 // encoding: [0xac,0x00,0x10,0xd5]
3902 // CHECK: msr dbgbcr1_el1, x12 // encoding: [0xac,0x01,0x10,0xd5]
3903 // CHECK: msr dbgbcr2_el1, x12 // encoding: [0xac,0x02,0x10,0xd5]
3904 // CHECK: msr dbgbcr3_el1, x12 // encoding: [0xac,0x03,0x10,0xd5]
3905 // CHECK: msr dbgbcr4_el1, x12 // encoding: [0xac,0x04,0x10,0xd5]
3906 // CHECK: msr dbgbcr5_el1, x12 // encoding: [0xac,0x05,0x10,0xd5]
3907 // CHECK: msr dbgbcr6_el1, x12 // encoding: [0xac,0x06,0x10,0xd5]
3908 // CHECK: msr dbgbcr7_el1, x12 // encoding: [0xac,0x07,0x10,0xd5]
3909 // CHECK: msr dbgbcr8_el1, x12 // encoding: [0xac,0x08,0x10,0xd5]
3910 // CHECK: msr dbgbcr9_el1, x12 // encoding: [0xac,0x09,0x10,0xd5]
3911 // CHECK: msr dbgbcr10_el1, x12 // encoding: [0xac,0x0a,0x10,0xd5]
3912 // CHECK: msr dbgbcr11_el1, x12 // encoding: [0xac,0x0b,0x10,0xd5]
3913 // CHECK: msr dbgbcr12_el1, x12 // encoding: [0xac,0x0c,0x10,0xd5]
3914 // CHECK: msr dbgbcr13_el1, x12 // encoding: [0xac,0x0d,0x10,0xd5]
3915 // CHECK: msr dbgbcr14_el1, x12 // encoding: [0xac,0x0e,0x10,0xd5]
3916 // CHECK: msr dbgbcr15_el1, x12 // encoding: [0xac,0x0f,0x10,0xd5]
3917 // CHECK: msr dbgwvr0_el1, x12 // encoding: [0xcc,0x00,0x10,0xd5]
3918 // CHECK: msr dbgwvr1_el1, x12 // encoding: [0xcc,0x01,0x10,0xd5]
3919 // CHECK: msr dbgwvr2_el1, x12 // encoding: [0xcc,0x02,0x10,0xd5]
3920 // CHECK: msr dbgwvr3_el1, x12 // encoding: [0xcc,0x03,0x10,0xd5]
3921 // CHECK: msr dbgwvr4_el1, x12 // encoding: [0xcc,0x04,0x10,0xd5]
3922 // CHECK: msr dbgwvr5_el1, x12 // encoding: [0xcc,0x05,0x10,0xd5]
3923 // CHECK: msr dbgwvr6_el1, x12 // encoding: [0xcc,0x06,0x10,0xd5]
3924 // CHECK: msr dbgwvr7_el1, x12 // encoding: [0xcc,0x07,0x10,0xd5]
3925 // CHECK: msr dbgwvr8_el1, x12 // encoding: [0xcc,0x08,0x10,0xd5]
3926 // CHECK: msr dbgwvr9_el1, x12 // encoding: [0xcc,0x09,0x10,0xd5]
3927 // CHECK: msr dbgwvr10_el1, x12 // encoding: [0xcc,0x0a,0x10,0xd5]
3928 // CHECK: msr dbgwvr11_el1, x12 // encoding: [0xcc,0x0b,0x10,0xd5]
3929 // CHECK: msr dbgwvr12_el1, x12 // encoding: [0xcc,0x0c,0x10,0xd5]
3930 // CHECK: msr dbgwvr13_el1, x12 // encoding: [0xcc,0x0d,0x10,0xd5]
3931 // CHECK: msr dbgwvr14_el1, x12 // encoding: [0xcc,0x0e,0x10,0xd5]
3932 // CHECK: msr dbgwvr15_el1, x12 // encoding: [0xcc,0x0f,0x10,0xd5]
3933 // CHECK: msr dbgwcr0_el1, x12 // encoding: [0xec,0x00,0x10,0xd5]
3934 // CHECK: msr dbgwcr1_el1, x12 // encoding: [0xec,0x01,0x10,0xd5]
3935 // CHECK: msr dbgwcr2_el1, x12 // encoding: [0xec,0x02,0x10,0xd5]
3936 // CHECK: msr dbgwcr3_el1, x12 // encoding: [0xec,0x03,0x10,0xd5]
3937 // CHECK: msr dbgwcr4_el1, x12 // encoding: [0xec,0x04,0x10,0xd5]
3938 // CHECK: msr dbgwcr5_el1, x12 // encoding: [0xec,0x05,0x10,0xd5]
3939 // CHECK: msr dbgwcr6_el1, x12 // encoding: [0xec,0x06,0x10,0xd5]
3940 // CHECK: msr dbgwcr7_el1, x12 // encoding: [0xec,0x07,0x10,0xd5]
3941 // CHECK: msr dbgwcr8_el1, x12 // encoding: [0xec,0x08,0x10,0xd5]
3942 // CHECK: msr dbgwcr9_el1, x12 // encoding: [0xec,0x09,0x10,0xd5]
3943 // CHECK: msr dbgwcr10_el1, x12 // encoding: [0xec,0x0a,0x10,0xd5]
3944 // CHECK: msr dbgwcr11_el1, x12 // encoding: [0xec,0x0b,0x10,0xd5]
3945 // CHECK: msr dbgwcr12_el1, x12 // encoding: [0xec,0x0c,0x10,0xd5]
3946 // CHECK: msr dbgwcr13_el1, x12 // encoding: [0xec,0x0d,0x10,0xd5]
3947 // CHECK: msr dbgwcr14_el1, x12 // encoding: [0xec,0x0e,0x10,0xd5]
3948 // CHECK: msr dbgwcr15_el1, x12 // encoding: [0xec,0x0f,0x10,0xd5]
3949 // CHECK: msr teehbr32_el1, x12 // encoding: [0x0c,0x10,0x12,0xd5]
3950 // CHECK: msr oslar_el1, x12 // encoding: [0x8c,0x10,0x10,0xd5]
3951 // CHECK: msr osdlr_el1, x12 // encoding: [0x8c,0x13,0x10,0xd5]
3952 // CHECK: msr dbgprcr_el1, x12 // encoding: [0x8c,0x14,0x10,0xd5]
3953 // CHECK: msr dbgclaimset_el1, x12 // encoding: [0xcc,0x78,0x10,0xd5]
3954 // CHECK: msr dbgclaimclr_el1, x12 // encoding: [0xcc,0x79,0x10,0xd5]
3955 // CHECK: msr csselr_el1, x12 // encoding: [0x0c,0x00,0x1a,0xd5]
3956 // CHECK: msr vpidr_el2, x12 // encoding: [0x0c,0x00,0x1c,0xd5]
3957 // CHECK: msr vmpidr_el2, x12 // encoding: [0xac,0x00,0x1c,0xd5]
3958 // CHECK: msr sctlr_el1, x12 // encoding: [0x0c,0x10,0x18,0xd5]
3959 // CHECK: msr sctlr_el2, x12 // encoding: [0x0c,0x10,0x1c,0xd5]
3960 // CHECK: msr sctlr_el3, x12 // encoding: [0x0c,0x10,0x1e,0xd5]
3961 // CHECK: msr actlr_el1, x12 // encoding: [0x2c,0x10,0x18,0xd5]
3962 // CHECK: msr actlr_el2, x12 // encoding: [0x2c,0x10,0x1c,0xd5]
3963 // CHECK: msr actlr_el3, x12 // encoding: [0x2c,0x10,0x1e,0xd5]
3964 // CHECK: msr cpacr_el1, x12 // encoding: [0x4c,0x10,0x18,0xd5]
3965 // CHECK: msr hcr_el2, x12 // encoding: [0x0c,0x11,0x1c,0xd5]
3966 // CHECK: msr scr_el3, x12 // encoding: [0x0c,0x11,0x1e,0xd5]
3967 // CHECK: msr mdcr_el2, x12 // encoding: [0x2c,0x11,0x1c,0xd5]
3968 // CHECK: msr sder32_el3, x12 // encoding: [0x2c,0x11,0x1e,0xd5]
3969 // CHECK: msr cptr_el2, x12 // encoding: [0x4c,0x11,0x1c,0xd5]
3970 // CHECK: msr cptr_el3, x12 // encoding: [0x4c,0x11,0x1e,0xd5]
3971 // CHECK: msr hstr_el2, x12 // encoding: [0x6c,0x11,0x1c,0xd5]
3972 // CHECK: msr hacr_el2, x12 // encoding: [0xec,0x11,0x1c,0xd5]
3973 // CHECK: msr mdcr_el3, x12 // encoding: [0x2c,0x13,0x1e,0xd5]
3974 // CHECK: msr ttbr0_el1, x12 // encoding: [0x0c,0x20,0x18,0xd5]
3975 // CHECK: msr ttbr0_el2, x12 // encoding: [0x0c,0x20,0x1c,0xd5]
3976 // CHECK: msr ttbr0_el3, x12 // encoding: [0x0c,0x20,0x1e,0xd5]
3977 // CHECK: msr ttbr1_el1, x12 // encoding: [0x2c,0x20,0x18,0xd5]
3978 // CHECK: msr tcr_el1, x12 // encoding: [0x4c,0x20,0x18,0xd5]
3979 // CHECK: msr tcr_el2, x12 // encoding: [0x4c,0x20,0x1c,0xd5]
3980 // CHECK: msr tcr_el3, x12 // encoding: [0x4c,0x20,0x1e,0xd5]
3981 // CHECK: msr vttbr_el2, x12 // encoding: [0x0c,0x21,0x1c,0xd5]
3982 // CHECK: msr vtcr_el2, x12 // encoding: [0x4c,0x21,0x1c,0xd5]
3983 // CHECK: msr dacr32_el2, x12 // encoding: [0x0c,0x30,0x1c,0xd5]
3984 // CHECK: msr spsr_el1, x12 // encoding: [0x0c,0x40,0x18,0xd5]
3985 // CHECK: msr spsr_el2, x12 // encoding: [0x0c,0x40,0x1c,0xd5]
3986 // CHECK: msr spsr_el3, x12 // encoding: [0x0c,0x40,0x1e,0xd5]
3987 // CHECK: msr elr_el1, x12 // encoding: [0x2c,0x40,0x18,0xd5]
3988 // CHECK: msr elr_el2, x12 // encoding: [0x2c,0x40,0x1c,0xd5]
3989 // CHECK: msr elr_el3, x12 // encoding: [0x2c,0x40,0x1e,0xd5]
3990 // CHECK: msr sp_el0, x12 // encoding: [0x0c,0x41,0x18,0xd5]
3991 // CHECK: msr sp_el1, x12 // encoding: [0x0c,0x41,0x1c,0xd5]
3992 // CHECK: msr sp_el2, x12 // encoding: [0x0c,0x41,0x1e,0xd5]
3993 // CHECK: msr spsel, x12 // encoding: [0x0c,0x42,0x18,0xd5]
3994 // CHECK: msr nzcv, x12 // encoding: [0x0c,0x42,0x1b,0xd5]
3995 // CHECK: msr daif, x12 // encoding: [0x2c,0x42,0x1b,0xd5]
3996 // CHECK: msr currentel, x12 // encoding: [0x4c,0x42,0x18,0xd5]
3997 // CHECK: msr spsr_irq, x12 // encoding: [0x0c,0x43,0x1c,0xd5]
3998 // CHECK: msr spsr_abt, x12 // encoding: [0x2c,0x43,0x1c,0xd5]
3999 // CHECK: msr spsr_und, x12 // encoding: [0x4c,0x43,0x1c,0xd5]
4000 // CHECK: msr spsr_fiq, x12 // encoding: [0x6c,0x43,0x1c,0xd5]
4001 // CHECK: msr fpcr, x12 // encoding: [0x0c,0x44,0x1b,0xd5]
4002 // CHECK: msr fpsr, x12 // encoding: [0x2c,0x44,0x1b,0xd5]
4003 // CHECK: msr dspsr_el0, x12 // encoding: [0x0c,0x45,0x1b,0xd5]
4004 // CHECK: msr dlr_el0, x12 // encoding: [0x2c,0x45,0x1b,0xd5]
4005 // CHECK: msr ifsr32_el2, x12 // encoding: [0x2c,0x50,0x1c,0xd5]
4006 // CHECK: msr afsr0_el1, x12 // encoding: [0x0c,0x51,0x18,0xd5]
4007 // CHECK: msr afsr0_el2, x12 // encoding: [0x0c,0x51,0x1c,0xd5]
4008 // CHECK: msr afsr0_el3, x12 // encoding: [0x0c,0x51,0x1e,0xd5]
4009 // CHECK: msr afsr1_el1, x12 // encoding: [0x2c,0x51,0x18,0xd5]
4010 // CHECK: msr afsr1_el2, x12 // encoding: [0x2c,0x51,0x1c,0xd5]
4011 // CHECK: msr afsr1_el3, x12 // encoding: [0x2c,0x51,0x1e,0xd5]
4012 // CHECK: msr esr_el1, x12 // encoding: [0x0c,0x52,0x18,0xd5]
4013 // CHECK: msr esr_el2, x12 // encoding: [0x0c,0x52,0x1c,0xd5]
4014 // CHECK: msr esr_el3, x12 // encoding: [0x0c,0x52,0x1e,0xd5]
4015 // CHECK: msr fpexc32_el2, x12 // encoding: [0x0c,0x53,0x1c,0xd5]
4016 // CHECK: msr far_el1, x12 // encoding: [0x0c,0x60,0x18,0xd5]
4017 // CHECK: msr far_el2, x12 // encoding: [0x0c,0x60,0x1c,0xd5]
4018 // CHECK: msr far_el3, x12 // encoding: [0x0c,0x60,0x1e,0xd5]
4019 // CHECK: msr hpfar_el2, x12 // encoding: [0x8c,0x60,0x1c,0xd5]
4020 // CHECK: msr par_el1, x12 // encoding: [0x0c,0x74,0x18,0xd5]
4021 // CHECK: msr pmcr_el0, x12 // encoding: [0x0c,0x9c,0x1b,0xd5]
4022 // CHECK: msr pmcntenset_el0, x12 // encoding: [0x2c,0x9c,0x1b,0xd5]
4023 // CHECK: msr pmcntenclr_el0, x12 // encoding: [0x4c,0x9c,0x1b,0xd5]
4024 // CHECK: msr pmovsclr_el0, x12 // encoding: [0x6c,0x9c,0x1b,0xd5]
4025 // CHECK: msr pmselr_el0, x12 // encoding: [0xac,0x9c,0x1b,0xd5]
4026 // CHECK: msr pmccntr_el0, x12 // encoding: [0x0c,0x9d,0x1b,0xd5]
4027 // CHECK: msr pmxevtyper_el0, x12 // encoding: [0x2c,0x9d,0x1b,0xd5]
4028 // CHECK: msr pmxevcntr_el0, x12 // encoding: [0x4c,0x9d,0x1b,0xd5]
4029 // CHECK: msr pmuserenr_el0, x12 // encoding: [0x0c,0x9e,0x1b,0xd5]
4030 // CHECK: msr pmintenset_el1, x12 // encoding: [0x2c,0x9e,0x18,0xd5]
4031 // CHECK: msr pmintenclr_el1, x12 // encoding: [0x4c,0x9e,0x18,0xd5]
4032 // CHECK: msr pmovsset_el0, x12 // encoding: [0x6c,0x9e,0x1b,0xd5]
4033 // CHECK: msr mair_el1, x12 // encoding: [0x0c,0xa2,0x18,0xd5]
4034 // CHECK: msr mair_el2, x12 // encoding: [0x0c,0xa2,0x1c,0xd5]
4035 // CHECK: msr mair_el3, x12 // encoding: [0x0c,0xa2,0x1e,0xd5]
4036 // CHECK: msr amair_el1, x12 // encoding: [0x0c,0xa3,0x18,0xd5]
4037 // CHECK: msr amair_el2, x12 // encoding: [0x0c,0xa3,0x1c,0xd5]
4038 // CHECK: msr amair_el3, x12 // encoding: [0x0c,0xa3,0x1e,0xd5]
4039 // CHECK: msr vbar_el1, x12 // encoding: [0x0c,0xc0,0x18,0xd5]
4040 // CHECK: msr vbar_el2, x12 // encoding: [0x0c,0xc0,0x1c,0xd5]
4041 // CHECK: msr vbar_el3, x12 // encoding: [0x0c,0xc0,0x1e,0xd5]
4042 // CHECK: msr rmr_el1, x12 // encoding: [0x4c,0xc0,0x18,0xd5]
4043 // CHECK: msr rmr_el2, x12 // encoding: [0x4c,0xc0,0x1c,0xd5]
4044 // CHECK: msr rmr_el3, x12 // encoding: [0x4c,0xc0,0x1e,0xd5]
4045 // CHECK: msr contextidr_el1, x12 // encoding: [0x2c,0xd0,0x18,0xd5]
4046 // CHECK: msr tpidr_el0, x12 // encoding: [0x4c,0xd0,0x1b,0xd5]
4047 // CHECK: msr tpidr_el2, x12 // encoding: [0x4c,0xd0,0x1c,0xd5]
4048 // CHECK: msr tpidr_el3, x12 // encoding: [0x4c,0xd0,0x1e,0xd5]
4049 // CHECK: msr tpidrro_el0, x12 // encoding: [0x6c,0xd0,0x1b,0xd5]
4050 // CHECK: msr tpidr_el1, x12 // encoding: [0x8c,0xd0,0x18,0xd5]
4051 // CHECK: msr cntfrq_el0, x12 // encoding: [0x0c,0xe0,0x1b,0xd5]
4052 // CHECK: msr cntvoff_el2, x12 // encoding: [0x6c,0xe0,0x1c,0xd5]
4053 // CHECK: msr cntkctl_el1, x12 // encoding: [0x0c,0xe1,0x18,0xd5]
4054 // CHECK: msr cnthctl_el2, x12 // encoding: [0x0c,0xe1,0x1c,0xd5]
4055 // CHECK: msr cntp_tval_el0, x12 // encoding: [0x0c,0xe2,0x1b,0xd5]
4056 // CHECK: msr cnthp_tval_el2, x12 // encoding: [0x0c,0xe2,0x1c,0xd5]
4057 // CHECK: msr cntps_tval_el1, x12 // encoding: [0x0c,0xe2,0x1f,0xd5]
4058 // CHECK: msr cntp_ctl_el0, x12 // encoding: [0x2c,0xe2,0x1b,0xd5]
4059 // CHECK: msr cnthp_ctl_el2, x12 // encoding: [0x2c,0xe2,0x1c,0xd5]
4060 // CHECK: msr cntps_ctl_el1, x12 // encoding: [0x2c,0xe2,0x1f,0xd5]
4061 // CHECK: msr cntp_cval_el0, x12 // encoding: [0x4c,0xe2,0x1b,0xd5]
4062 // CHECK: msr cnthp_cval_el2, x12 // encoding: [0x4c,0xe2,0x1c,0xd5]
4063 // CHECK: msr cntps_cval_el1, x12 // encoding: [0x4c,0xe2,0x1f,0xd5]
4064 // CHECK: msr cntv_tval_el0, x12 // encoding: [0x0c,0xe3,0x1b,0xd5]
4065 // CHECK: msr cntv_ctl_el0, x12 // encoding: [0x2c,0xe3,0x1b,0xd5]
4066 // CHECK: msr cntv_cval_el0, x12 // encoding: [0x4c,0xe3,0x1b,0xd5]
4067 // CHECK: msr pmevcntr0_el0, x12 // encoding: [0x0c,0xe8,0x1b,0xd5]
4068 // CHECK: msr pmevcntr1_el0, x12 // encoding: [0x2c,0xe8,0x1b,0xd5]
4069 // CHECK: msr pmevcntr2_el0, x12 // encoding: [0x4c,0xe8,0x1b,0xd5]
4070 // CHECK: msr pmevcntr3_el0, x12 // encoding: [0x6c,0xe8,0x1b,0xd5]
4071 // CHECK: msr pmevcntr4_el0, x12 // encoding: [0x8c,0xe8,0x1b,0xd5]
4072 // CHECK: msr pmevcntr5_el0, x12 // encoding: [0xac,0xe8,0x1b,0xd5]
4073 // CHECK: msr pmevcntr6_el0, x12 // encoding: [0xcc,0xe8,0x1b,0xd5]
4074 // CHECK: msr pmevcntr7_el0, x12 // encoding: [0xec,0xe8,0x1b,0xd5]
4075 // CHECK: msr pmevcntr8_el0, x12 // encoding: [0x0c,0xe9,0x1b,0xd5]
4076 // CHECK: msr pmevcntr9_el0, x12 // encoding: [0x2c,0xe9,0x1b,0xd5]
4077 // CHECK: msr pmevcntr10_el0, x12 // encoding: [0x4c,0xe9,0x1b,0xd5]
4078 // CHECK: msr pmevcntr11_el0, x12 // encoding: [0x6c,0xe9,0x1b,0xd5]
4079 // CHECK: msr pmevcntr12_el0, x12 // encoding: [0x8c,0xe9,0x1b,0xd5]
4080 // CHECK: msr pmevcntr13_el0, x12 // encoding: [0xac,0xe9,0x1b,0xd5]
4081 // CHECK: msr pmevcntr14_el0, x12 // encoding: [0xcc,0xe9,0x1b,0xd5]
4082 // CHECK: msr pmevcntr15_el0, x12 // encoding: [0xec,0xe9,0x1b,0xd5]
4083 // CHECK: msr pmevcntr16_el0, x12 // encoding: [0x0c,0xea,0x1b,0xd5]
4084 // CHECK: msr pmevcntr17_el0, x12 // encoding: [0x2c,0xea,0x1b,0xd5]
4085 // CHECK: msr pmevcntr18_el0, x12 // encoding: [0x4c,0xea,0x1b,0xd5]
4086 // CHECK: msr pmevcntr19_el0, x12 // encoding: [0x6c,0xea,0x1b,0xd5]
4087 // CHECK: msr pmevcntr20_el0, x12 // encoding: [0x8c,0xea,0x1b,0xd5]
4088 // CHECK: msr pmevcntr21_el0, x12 // encoding: [0xac,0xea,0x1b,0xd5]
4089 // CHECK: msr pmevcntr22_el0, x12 // encoding: [0xcc,0xea,0x1b,0xd5]
4090 // CHECK: msr pmevcntr23_el0, x12 // encoding: [0xec,0xea,0x1b,0xd5]
4091 // CHECK: msr pmevcntr24_el0, x12 // encoding: [0x0c,0xeb,0x1b,0xd5]
4092 // CHECK: msr pmevcntr25_el0, x12 // encoding: [0x2c,0xeb,0x1b,0xd5]
4093 // CHECK: msr pmevcntr26_el0, x12 // encoding: [0x4c,0xeb,0x1b,0xd5]
4094 // CHECK: msr pmevcntr27_el0, x12 // encoding: [0x6c,0xeb,0x1b,0xd5]
4095 // CHECK: msr pmevcntr28_el0, x12 // encoding: [0x8c,0xeb,0x1b,0xd5]
4096 // CHECK: msr pmevcntr29_el0, x12 // encoding: [0xac,0xeb,0x1b,0xd5]
4097 // CHECK: msr pmevcntr30_el0, x12 // encoding: [0xcc,0xeb,0x1b,0xd5]
4098 // CHECK: msr pmccfiltr_el0, x12 // encoding: [0xec,0xef,0x1b,0xd5]
4099 // CHECK: msr pmevtyper0_el0, x12 // encoding: [0x0c,0xec,0x1b,0xd5]
4100 // CHECK: msr pmevtyper1_el0, x12 // encoding: [0x2c,0xec,0x1b,0xd5]
4101 // CHECK: msr pmevtyper2_el0, x12 // encoding: [0x4c,0xec,0x1b,0xd5]
4102 // CHECK: msr pmevtyper3_el0, x12 // encoding: [0x6c,0xec,0x1b,0xd5]
4103 // CHECK: msr pmevtyper4_el0, x12 // encoding: [0x8c,0xec,0x1b,0xd5]
4104 // CHECK: msr pmevtyper5_el0, x12 // encoding: [0xac,0xec,0x1b,0xd5]
4105 // CHECK: msr pmevtyper6_el0, x12 // encoding: [0xcc,0xec,0x1b,0xd5]
4106 // CHECK: msr pmevtyper7_el0, x12 // encoding: [0xec,0xec,0x1b,0xd5]
4107 // CHECK: msr pmevtyper8_el0, x12 // encoding: [0x0c,0xed,0x1b,0xd5]
4108 // CHECK: msr pmevtyper9_el0, x12 // encoding: [0x2c,0xed,0x1b,0xd5]
4109 // CHECK: msr pmevtyper10_el0, x12 // encoding: [0x4c,0xed,0x1b,0xd5]
4110 // CHECK: msr pmevtyper11_el0, x12 // encoding: [0x6c,0xed,0x1b,0xd5]
4111 // CHECK: msr pmevtyper12_el0, x12 // encoding: [0x8c,0xed,0x1b,0xd5]
4112 // CHECK: msr pmevtyper13_el0, x12 // encoding: [0xac,0xed,0x1b,0xd5]
4113 // CHECK: msr pmevtyper14_el0, x12 // encoding: [0xcc,0xed,0x1b,0xd5]
4114 // CHECK: msr pmevtyper15_el0, x12 // encoding: [0xec,0xed,0x1b,0xd5]
4115 // CHECK: msr pmevtyper16_el0, x12 // encoding: [0x0c,0xee,0x1b,0xd5]
4116 // CHECK: msr pmevtyper17_el0, x12 // encoding: [0x2c,0xee,0x1b,0xd5]
4117 // CHECK: msr pmevtyper18_el0, x12 // encoding: [0x4c,0xee,0x1b,0xd5]
4118 // CHECK: msr pmevtyper19_el0, x12 // encoding: [0x6c,0xee,0x1b,0xd5]
4119 // CHECK: msr pmevtyper20_el0, x12 // encoding: [0x8c,0xee,0x1b,0xd5]
4120 // CHECK: msr pmevtyper21_el0, x12 // encoding: [0xac,0xee,0x1b,0xd5]
4121 // CHECK: msr pmevtyper22_el0, x12 // encoding: [0xcc,0xee,0x1b,0xd5]
4122 // CHECK: msr pmevtyper23_el0, x12 // encoding: [0xec,0xee,0x1b,0xd5]
4123 // CHECK: msr pmevtyper24_el0, x12 // encoding: [0x0c,0xef,0x1b,0xd5]
4124 // CHECK: msr pmevtyper25_el0, x12 // encoding: [0x2c,0xef,0x1b,0xd5]
4125 // CHECK: msr pmevtyper26_el0, x12 // encoding: [0x4c,0xef,0x1b,0xd5]
4126 // CHECK: msr pmevtyper27_el0, x12 // encoding: [0x6c,0xef,0x1b,0xd5]
4127 // CHECK: msr pmevtyper28_el0, x12 // encoding: [0x8c,0xef,0x1b,0xd5]
4128 // CHECK: msr pmevtyper29_el0, x12 // encoding: [0xac,0xef,0x1b,0xd5]
4129 // CHECK: msr pmevtyper30_el0, x12 // encoding: [0xcc,0xef,0x1b,0xd5]
4138 mrs x9, DBGDTRRX_EL0
4140 mrs x9, DBGVCR32_EL2
4151 mrs x9, DBGBVR10_EL1
4152 mrs x9, DBGBVR11_EL1
4153 mrs x9, DBGBVR12_EL1
4154 mrs x9, DBGBVR13_EL1
4155 mrs x9, DBGBVR14_EL1
4156 mrs x9, DBGBVR15_EL1
4167 mrs x9, DBGBCR10_EL1
4168 mrs x9, DBGBCR11_EL1
4169 mrs x9, DBGBCR12_EL1
4170 mrs x9, DBGBCR13_EL1
4171 mrs x9, DBGBCR14_EL1
4172 mrs x9, DBGBCR15_EL1
4183 mrs x9, DBGWVR10_EL1
4184 mrs x9, DBGWVR11_EL1
4185 mrs x9, DBGWVR12_EL1
4186 mrs x9, DBGWVR13_EL1
4187 mrs x9, DBGWVR14_EL1
4188 mrs x9, DBGWVR15_EL1
4199 mrs x9, DBGWCR10_EL1
4200 mrs x9, DBGWCR11_EL1
4201 mrs x9, DBGWCR12_EL1
4202 mrs x9, DBGWCR13_EL1
4203 mrs x9, DBGWCR14_EL1
4204 mrs x9, DBGWCR15_EL1
4206 mrs x9, TEEHBR32_EL1
4210 mrs x9, DBGCLAIMSET_EL1
4211 mrs x9, DBGCLAIMCLR_EL1
4212 mrs x9, DBGAUTHSTATUS_EL1
4228 mrs x9, ID_MMFR0_EL1
4229 mrs x9, ID_MMFR1_EL1
4230 mrs x9, ID_MMFR2_EL1
4231 mrs x9, ID_MMFR3_EL1
4232 mrs x9, ID_ISAR0_EL1
4233 mrs x9, ID_ISAR1_EL1
4234 mrs x9, ID_ISAR2_EL1
4235 mrs x9, ID_ISAR3_EL1
4236 mrs x9, ID_ISAR4_EL1
4237 mrs x9, ID_ISAR5_EL1
4241 mrs x9, ID_AA64PFR0_EL1
4242 mrs x9, ID_AA64PFR1_EL1
4243 mrs x9, ID_AA64DFR0_EL1
4244 mrs x9, ID_AA64DFR1_EL1
4245 mrs x9, ID_AA64AFR0_EL1
4246 mrs x9, ID_AA64AFR1_EL1
4247 mrs x9, ID_AA64ISAR0_EL1
4248 mrs x9, ID_AA64ISAR1_EL1
4249 mrs x9, ID_AA64MMFR0_EL1
4250 mrs x9, ID_AA64MMFR1_EL1
4315 mrs x9, PMCNTENSET_EL0
4316 mrs x9, PMCNTENCLR_EL0
4317 mrs x9, PMOVSCLR_EL0
4322 mrs x9, PMXEVTYPER_EL0
4323 mrs x9, PMXEVCNTR_EL0
4324 mrs x9, PMUSERENR_EL0
4325 mrs x9, PMINTENSET_EL1
4326 mrs x9, PMINTENCLR_EL1
4327 mrs x9, PMOVSSET_EL0
4344 mrs x9, CONTEXTIDR_EL1
4356 mrs x9, CNTP_TVAL_EL0
4357 mrs x9, CNTHP_TVAL_EL2
4358 mrs x9, CNTPS_TVAL_EL1
4359 mrs x9, CNTP_CTL_EL0
4360 mrs x9, CNTHP_CTL_EL2
4361 mrs x9, CNTPS_CTL_EL1
4362 mrs x9, CNTP_CVAL_EL0
4363 mrs x9, CNTHP_CVAL_EL2
4364 mrs x9, CNTPS_CVAL_EL1
4365 mrs x9, CNTV_TVAL_EL0
4366 mrs x9, CNTV_CTL_EL0
4367 mrs x9, CNTV_CVAL_EL0
4368 mrs x9, PMEVCNTR0_EL0
4369 mrs x9, PMEVCNTR1_EL0
4370 mrs x9, PMEVCNTR2_EL0
4371 mrs x9, PMEVCNTR3_EL0
4372 mrs x9, PMEVCNTR4_EL0
4373 mrs x9, PMEVCNTR5_EL0
4374 mrs x9, PMEVCNTR6_EL0
4375 mrs x9, PMEVCNTR7_EL0
4376 mrs x9, PMEVCNTR8_EL0
4377 mrs x9, PMEVCNTR9_EL0
4378 mrs x9, PMEVCNTR10_EL0
4379 mrs x9, PMEVCNTR11_EL0
4380 mrs x9, PMEVCNTR12_EL0
4381 mrs x9, PMEVCNTR13_EL0
4382 mrs x9, PMEVCNTR14_EL0
4383 mrs x9, PMEVCNTR15_EL0
4384 mrs x9, PMEVCNTR16_EL0
4385 mrs x9, PMEVCNTR17_EL0
4386 mrs x9, PMEVCNTR18_EL0
4387 mrs x9, PMEVCNTR19_EL0
4388 mrs x9, PMEVCNTR20_EL0
4389 mrs x9, PMEVCNTR21_EL0
4390 mrs x9, PMEVCNTR22_EL0
4391 mrs x9, PMEVCNTR23_EL0
4392 mrs x9, PMEVCNTR24_EL0
4393 mrs x9, PMEVCNTR25_EL0
4394 mrs x9, PMEVCNTR26_EL0
4395 mrs x9, PMEVCNTR27_EL0
4396 mrs x9, PMEVCNTR28_EL0
4397 mrs x9, PMEVCNTR29_EL0
4398 mrs x9, PMEVCNTR30_EL0
4399 mrs x9, PMCCFILTR_EL0
4400 mrs x9, PMEVTYPER0_EL0
4401 mrs x9, PMEVTYPER1_EL0
4402 mrs x9, PMEVTYPER2_EL0
4403 mrs x9, PMEVTYPER3_EL0
4404 mrs x9, PMEVTYPER4_EL0
4405 mrs x9, PMEVTYPER5_EL0
4406 mrs x9, PMEVTYPER6_EL0
4407 mrs x9, PMEVTYPER7_EL0
4408 mrs x9, PMEVTYPER8_EL0
4409 mrs x9, PMEVTYPER9_EL0
4410 mrs x9, PMEVTYPER10_EL0
4411 mrs x9, PMEVTYPER11_EL0
4412 mrs x9, PMEVTYPER12_EL0
4413 mrs x9, PMEVTYPER13_EL0
4414 mrs x9, PMEVTYPER14_EL0
4415 mrs x9, PMEVTYPER15_EL0
4416 mrs x9, PMEVTYPER16_EL0
4417 mrs x9, PMEVTYPER17_EL0
4418 mrs x9, PMEVTYPER18_EL0
4419 mrs x9, PMEVTYPER19_EL0
4420 mrs x9, PMEVTYPER20_EL0
4421 mrs x9, PMEVTYPER21_EL0
4422 mrs x9, PMEVTYPER22_EL0
4423 mrs x9, PMEVTYPER23_EL0
4424 mrs x9, PMEVTYPER24_EL0
4425 mrs x9, PMEVTYPER25_EL0
4426 mrs x9, PMEVTYPER26_EL0
4427 mrs x9, PMEVTYPER27_EL0
4428 mrs x9, PMEVTYPER28_EL0
4429 mrs x9, PMEVTYPER29_EL0
4430 mrs x9, PMEVTYPER30_EL0
4431 // CHECK: mrs x9, teecr32_el1 // encoding: [0x09,0x00,0x32,0xd5]
4432 // CHECK: mrs x9, osdtrrx_el1 // encoding: [0x49,0x00,0x30,0xd5]
4433 // CHECK: mrs x9, mdccsr_el0 // encoding: [0x09,0x01,0x33,0xd5]
4434 // CHECK: mrs x9, mdccint_el1 // encoding: [0x09,0x02,0x30,0xd5]
4435 // CHECK: mrs x9, mdscr_el1 // encoding: [0x49,0x02,0x30,0xd5]
4436 // CHECK: mrs x9, osdtrtx_el1 // encoding: [0x49,0x03,0x30,0xd5]
4437 // CHECK: mrs x9, dbgdtr_el0 // encoding: [0x09,0x04,0x33,0xd5]
4438 // CHECK: mrs x9, dbgdtrrx_el0 // encoding: [0x09,0x05,0x33,0xd5]
4439 // CHECK: mrs x9, oseccr_el1 // encoding: [0x49,0x06,0x30,0xd5]
4440 // CHECK: mrs x9, dbgvcr32_el2 // encoding: [0x09,0x07,0x34,0xd5]
4441 // CHECK: mrs x9, dbgbvr0_el1 // encoding: [0x89,0x00,0x30,0xd5]
4442 // CHECK: mrs x9, dbgbvr1_el1 // encoding: [0x89,0x01,0x30,0xd5]
4443 // CHECK: mrs x9, dbgbvr2_el1 // encoding: [0x89,0x02,0x30,0xd5]
4444 // CHECK: mrs x9, dbgbvr3_el1 // encoding: [0x89,0x03,0x30,0xd5]
4445 // CHECK: mrs x9, dbgbvr4_el1 // encoding: [0x89,0x04,0x30,0xd5]
4446 // CHECK: mrs x9, dbgbvr5_el1 // encoding: [0x89,0x05,0x30,0xd5]
4447 // CHECK: mrs x9, dbgbvr6_el1 // encoding: [0x89,0x06,0x30,0xd5]
4448 // CHECK: mrs x9, dbgbvr7_el1 // encoding: [0x89,0x07,0x30,0xd5]
4449 // CHECK: mrs x9, dbgbvr8_el1 // encoding: [0x89,0x08,0x30,0xd5]
4450 // CHECK: mrs x9, dbgbvr9_el1 // encoding: [0x89,0x09,0x30,0xd5]
4451 // CHECK: mrs x9, dbgbvr10_el1 // encoding: [0x89,0x0a,0x30,0xd5]
4452 // CHECK: mrs x9, dbgbvr11_el1 // encoding: [0x89,0x0b,0x30,0xd5]
4453 // CHECK: mrs x9, dbgbvr12_el1 // encoding: [0x89,0x0c,0x30,0xd5]
4454 // CHECK: mrs x9, dbgbvr13_el1 // encoding: [0x89,0x0d,0x30,0xd5]
4455 // CHECK: mrs x9, dbgbvr14_el1 // encoding: [0x89,0x0e,0x30,0xd5]
4456 // CHECK: mrs x9, dbgbvr15_el1 // encoding: [0x89,0x0f,0x30,0xd5]
4457 // CHECK: mrs x9, dbgbcr0_el1 // encoding: [0xa9,0x00,0x30,0xd5]
4458 // CHECK: mrs x9, dbgbcr1_el1 // encoding: [0xa9,0x01,0x30,0xd5]
4459 // CHECK: mrs x9, dbgbcr2_el1 // encoding: [0xa9,0x02,0x30,0xd5]
4460 // CHECK: mrs x9, dbgbcr3_el1 // encoding: [0xa9,0x03,0x30,0xd5]
4461 // CHECK: mrs x9, dbgbcr4_el1 // encoding: [0xa9,0x04,0x30,0xd5]
4462 // CHECK: mrs x9, dbgbcr5_el1 // encoding: [0xa9,0x05,0x30,0xd5]
4463 // CHECK: mrs x9, dbgbcr6_el1 // encoding: [0xa9,0x06,0x30,0xd5]
4464 // CHECK: mrs x9, dbgbcr7_el1 // encoding: [0xa9,0x07,0x30,0xd5]
4465 // CHECK: mrs x9, dbgbcr8_el1 // encoding: [0xa9,0x08,0x30,0xd5]
4466 // CHECK: mrs x9, dbgbcr9_el1 // encoding: [0xa9,0x09,0x30,0xd5]
4467 // CHECK: mrs x9, dbgbcr10_el1 // encoding: [0xa9,0x0a,0x30,0xd5]
4468 // CHECK: mrs x9, dbgbcr11_el1 // encoding: [0xa9,0x0b,0x30,0xd5]
4469 // CHECK: mrs x9, dbgbcr12_el1 // encoding: [0xa9,0x0c,0x30,0xd5]
4470 // CHECK: mrs x9, dbgbcr13_el1 // encoding: [0xa9,0x0d,0x30,0xd5]
4471 // CHECK: mrs x9, dbgbcr14_el1 // encoding: [0xa9,0x0e,0x30,0xd5]
4472 // CHECK: mrs x9, dbgbcr15_el1 // encoding: [0xa9,0x0f,0x30,0xd5]
4473 // CHECK: mrs x9, dbgwvr0_el1 // encoding: [0xc9,0x00,0x30,0xd5]
4474 // CHECK: mrs x9, dbgwvr1_el1 // encoding: [0xc9,0x01,0x30,0xd5]
4475 // CHECK: mrs x9, dbgwvr2_el1 // encoding: [0xc9,0x02,0x30,0xd5]
4476 // CHECK: mrs x9, dbgwvr3_el1 // encoding: [0xc9,0x03,0x30,0xd5]
4477 // CHECK: mrs x9, dbgwvr4_el1 // encoding: [0xc9,0x04,0x30,0xd5]
4478 // CHECK: mrs x9, dbgwvr5_el1 // encoding: [0xc9,0x05,0x30,0xd5]
4479 // CHECK: mrs x9, dbgwvr6_el1 // encoding: [0xc9,0x06,0x30,0xd5]
4480 // CHECK: mrs x9, dbgwvr7_el1 // encoding: [0xc9,0x07,0x30,0xd5]
4481 // CHECK: mrs x9, dbgwvr8_el1 // encoding: [0xc9,0x08,0x30,0xd5]
4482 // CHECK: mrs x9, dbgwvr9_el1 // encoding: [0xc9,0x09,0x30,0xd5]
4483 // CHECK: mrs x9, dbgwvr10_el1 // encoding: [0xc9,0x0a,0x30,0xd5]
4484 // CHECK: mrs x9, dbgwvr11_el1 // encoding: [0xc9,0x0b,0x30,0xd5]
4485 // CHECK: mrs x9, dbgwvr12_el1 // encoding: [0xc9,0x0c,0x30,0xd5]
4486 // CHECK: mrs x9, dbgwvr13_el1 // encoding: [0xc9,0x0d,0x30,0xd5]
4487 // CHECK: mrs x9, dbgwvr14_el1 // encoding: [0xc9,0x0e,0x30,0xd5]
4488 // CHECK: mrs x9, dbgwvr15_el1 // encoding: [0xc9,0x0f,0x30,0xd5]
4489 // CHECK: mrs x9, dbgwcr0_el1 // encoding: [0xe9,0x00,0x30,0xd5]
4490 // CHECK: mrs x9, dbgwcr1_el1 // encoding: [0xe9,0x01,0x30,0xd5]
4491 // CHECK: mrs x9, dbgwcr2_el1 // encoding: [0xe9,0x02,0x30,0xd5]
4492 // CHECK: mrs x9, dbgwcr3_el1 // encoding: [0xe9,0x03,0x30,0xd5]
4493 // CHECK: mrs x9, dbgwcr4_el1 // encoding: [0xe9,0x04,0x30,0xd5]
4494 // CHECK: mrs x9, dbgwcr5_el1 // encoding: [0xe9,0x05,0x30,0xd5]
4495 // CHECK: mrs x9, dbgwcr6_el1 // encoding: [0xe9,0x06,0x30,0xd5]
4496 // CHECK: mrs x9, dbgwcr7_el1 // encoding: [0xe9,0x07,0x30,0xd5]
4497 // CHECK: mrs x9, dbgwcr8_el1 // encoding: [0xe9,0x08,0x30,0xd5]
4498 // CHECK: mrs x9, dbgwcr9_el1 // encoding: [0xe9,0x09,0x30,0xd5]
4499 // CHECK: mrs x9, dbgwcr10_el1 // encoding: [0xe9,0x0a,0x30,0xd5]
4500 // CHECK: mrs x9, dbgwcr11_el1 // encoding: [0xe9,0x0b,0x30,0xd5]
4501 // CHECK: mrs x9, dbgwcr12_el1 // encoding: [0xe9,0x0c,0x30,0xd5]
4502 // CHECK: mrs x9, dbgwcr13_el1 // encoding: [0xe9,0x0d,0x30,0xd5]
4503 // CHECK: mrs x9, dbgwcr14_el1 // encoding: [0xe9,0x0e,0x30,0xd5]
4504 // CHECK: mrs x9, dbgwcr15_el1 // encoding: [0xe9,0x0f,0x30,0xd5]
4505 // CHECK: mrs x9, mdrar_el1 // encoding: [0x09,0x10,0x30,0xd5]
4506 // CHECK: mrs x9, teehbr32_el1 // encoding: [0x09,0x10,0x32,0xd5]
4507 // CHECK: mrs x9, oslsr_el1 // encoding: [0x89,0x11,0x30,0xd5]
4508 // CHECK: mrs x9, osdlr_el1 // encoding: [0x89,0x13,0x30,0xd5]
4509 // CHECK: mrs x9, dbgprcr_el1 // encoding: [0x89,0x14,0x30,0xd5]
4510 // CHECK: mrs x9, dbgclaimset_el1 // encoding: [0xc9,0x78,0x30,0xd5]
4511 // CHECK: mrs x9, dbgclaimclr_el1 // encoding: [0xc9,0x79,0x30,0xd5]
4512 // CHECK: mrs x9, dbgauthstatus_el1 // encoding: [0xc9,0x7e,0x30,0xd5]
4513 // CHECK: mrs x9, midr_el1 // encoding: [0x09,0x00,0x38,0xd5]
4514 // CHECK: mrs x9, ccsidr_el1 // encoding: [0x09,0x00,0x39,0xd5]
4515 // CHECK: mrs x9, csselr_el1 // encoding: [0x09,0x00,0x3a,0xd5]
4516 // CHECK: mrs x9, vpidr_el2 // encoding: [0x09,0x00,0x3c,0xd5]
4517 // CHECK: mrs x9, clidr_el1 // encoding: [0x29,0x00,0x39,0xd5]
4518 // CHECK: mrs x9, ctr_el0 // encoding: [0x29,0x00,0x3b,0xd5]
4519 // CHECK: mrs x9, mpidr_el1 // encoding: [0xa9,0x00,0x38,0xd5]
4520 // CHECK: mrs x9, vmpidr_el2 // encoding: [0xa9,0x00,0x3c,0xd5]
4521 // CHECK: mrs x9, revidr_el1 // encoding: [0xc9,0x00,0x38,0xd5]
4522 // CHECK: mrs x9, aidr_el1 // encoding: [0xe9,0x00,0x39,0xd5]
4523 // CHECK: mrs x9, dczid_el0 // encoding: [0xe9,0x00,0x3b,0xd5]
4524 // CHECK: mrs x9, id_pfr0_el1 // encoding: [0x09,0x01,0x38,0xd5]
4525 // CHECK: mrs x9, id_pfr1_el1 // encoding: [0x29,0x01,0x38,0xd5]
4526 // CHECK: mrs x9, id_dfr0_el1 // encoding: [0x49,0x01,0x38,0xd5]
4527 // CHECK: mrs x9, id_afr0_el1 // encoding: [0x69,0x01,0x38,0xd5]
4528 // CHECK: mrs x9, id_mmfr0_el1 // encoding: [0x89,0x01,0x38,0xd5]
4529 // CHECK: mrs x9, id_mmfr1_el1 // encoding: [0xa9,0x01,0x38,0xd5]
4530 // CHECK: mrs x9, id_mmfr2_el1 // encoding: [0xc9,0x01,0x38,0xd5]
4531 // CHECK: mrs x9, id_mmfr3_el1 // encoding: [0xe9,0x01,0x38,0xd5]
4532 // CHECK: mrs x9, id_isar0_el1 // encoding: [0x09,0x02,0x38,0xd5]
4533 // CHECK: mrs x9, id_isar1_el1 // encoding: [0x29,0x02,0x38,0xd5]
4534 // CHECK: mrs x9, id_isar2_el1 // encoding: [0x49,0x02,0x38,0xd5]
4535 // CHECK: mrs x9, id_isar3_el1 // encoding: [0x69,0x02,0x38,0xd5]
4536 // CHECK: mrs x9, id_isar4_el1 // encoding: [0x89,0x02,0x38,0xd5]
4537 // CHECK: mrs x9, id_isar5_el1 // encoding: [0xa9,0x02,0x38,0xd5]
4538 // CHECK: mrs x9, mvfr0_el1 // encoding: [0x09,0x03,0x38,0xd5]
4539 // CHECK: mrs x9, mvfr1_el1 // encoding: [0x29,0x03,0x38,0xd5]
4540 // CHECK: mrs x9, mvfr2_el1 // encoding: [0x49,0x03,0x38,0xd5]
4541 // CHECK: mrs x9, id_aa64pfr0_el1 // encoding: [0x09,0x04,0x38,0xd5]
4542 // CHECK: mrs x9, id_aa64pfr1_el1 // encoding: [0x29,0x04,0x38,0xd5]
4543 // CHECK: mrs x9, id_aa64dfr0_el1 // encoding: [0x09,0x05,0x38,0xd5]
4544 // CHECK: mrs x9, id_aa64dfr1_el1 // encoding: [0x29,0x05,0x38,0xd5]
4545 // CHECK: mrs x9, id_aa64afr0_el1 // encoding: [0x89,0x05,0x38,0xd5]
4546 // CHECK: mrs x9, id_aa64afr1_el1 // encoding: [0xa9,0x05,0x38,0xd5]
4547 // CHECK: mrs x9, id_aa64isar0_el1 // encoding: [0x09,0x06,0x38,0xd5]
4548 // CHECK: mrs x9, id_aa64isar1_el1 // encoding: [0x29,0x06,0x38,0xd5]
4549 // CHECK: mrs x9, id_aa64mmfr0_el1 // encoding: [0x09,0x07,0x38,0xd5]
4550 // CHECK: mrs x9, id_aa64mmfr1_el1 // encoding: [0x29,0x07,0x38,0xd5]
4551 // CHECK: mrs x9, sctlr_el1 // encoding: [0x09,0x10,0x38,0xd5]
4552 // CHECK: mrs x9, sctlr_el2 // encoding: [0x09,0x10,0x3c,0xd5]
4553 // CHECK: mrs x9, sctlr_el3 // encoding: [0x09,0x10,0x3e,0xd5]
4554 // CHECK: mrs x9, actlr_el1 // encoding: [0x29,0x10,0x38,0xd5]
4555 // CHECK: mrs x9, actlr_el2 // encoding: [0x29,0x10,0x3c,0xd5]
4556 // CHECK: mrs x9, actlr_el3 // encoding: [0x29,0x10,0x3e,0xd5]
4557 // CHECK: mrs x9, cpacr_el1 // encoding: [0x49,0x10,0x38,0xd5]
4558 // CHECK: mrs x9, hcr_el2 // encoding: [0x09,0x11,0x3c,0xd5]
4559 // CHECK: mrs x9, scr_el3 // encoding: [0x09,0x11,0x3e,0xd5]
4560 // CHECK: mrs x9, mdcr_el2 // encoding: [0x29,0x11,0x3c,0xd5]
4561 // CHECK: mrs x9, sder32_el3 // encoding: [0x29,0x11,0x3e,0xd5]
4562 // CHECK: mrs x9, cptr_el2 // encoding: [0x49,0x11,0x3c,0xd5]
4563 // CHECK: mrs x9, cptr_el3 // encoding: [0x49,0x11,0x3e,0xd5]
4564 // CHECK: mrs x9, hstr_el2 // encoding: [0x69,0x11,0x3c,0xd5]
4565 // CHECK: mrs x9, hacr_el2 // encoding: [0xe9,0x11,0x3c,0xd5]
4566 // CHECK: mrs x9, mdcr_el3 // encoding: [0x29,0x13,0x3e,0xd5]
4567 // CHECK: mrs x9, ttbr0_el1 // encoding: [0x09,0x20,0x38,0xd5]
4568 // CHECK: mrs x9, ttbr0_el2 // encoding: [0x09,0x20,0x3c,0xd5]
4569 // CHECK: mrs x9, ttbr0_el3 // encoding: [0x09,0x20,0x3e,0xd5]
4570 // CHECK: mrs x9, ttbr1_el1 // encoding: [0x29,0x20,0x38,0xd5]
4571 // CHECK: mrs x9, tcr_el1 // encoding: [0x49,0x20,0x38,0xd5]
4572 // CHECK: mrs x9, tcr_el2 // encoding: [0x49,0x20,0x3c,0xd5]
4573 // CHECK: mrs x9, tcr_el3 // encoding: [0x49,0x20,0x3e,0xd5]
4574 // CHECK: mrs x9, vttbr_el2 // encoding: [0x09,0x21,0x3c,0xd5]
4575 // CHECK: mrs x9, vtcr_el2 // encoding: [0x49,0x21,0x3c,0xd5]
4576 // CHECK: mrs x9, dacr32_el2 // encoding: [0x09,0x30,0x3c,0xd5]
4577 // CHECK: mrs x9, spsr_el1 // encoding: [0x09,0x40,0x38,0xd5]
4578 // CHECK: mrs x9, spsr_el2 // encoding: [0x09,0x40,0x3c,0xd5]
4579 // CHECK: mrs x9, spsr_el3 // encoding: [0x09,0x40,0x3e,0xd5]
4580 // CHECK: mrs x9, elr_el1 // encoding: [0x29,0x40,0x38,0xd5]
4581 // CHECK: mrs x9, elr_el2 // encoding: [0x29,0x40,0x3c,0xd5]
4582 // CHECK: mrs x9, elr_el3 // encoding: [0x29,0x40,0x3e,0xd5]
4583 // CHECK: mrs x9, sp_el0 // encoding: [0x09,0x41,0x38,0xd5]
4584 // CHECK: mrs x9, sp_el1 // encoding: [0x09,0x41,0x3c,0xd5]
4585 // CHECK: mrs x9, sp_el2 // encoding: [0x09,0x41,0x3e,0xd5]
4586 // CHECK: mrs x9, spsel // encoding: [0x09,0x42,0x38,0xd5]
4587 // CHECK: mrs x9, nzcv // encoding: [0x09,0x42,0x3b,0xd5]
4588 // CHECK: mrs x9, daif // encoding: [0x29,0x42,0x3b,0xd5]
4589 // CHECK: mrs x9, currentel // encoding: [0x49,0x42,0x38,0xd5]
4590 // CHECK: mrs x9, spsr_irq // encoding: [0x09,0x43,0x3c,0xd5]
4591 // CHECK: mrs x9, spsr_abt // encoding: [0x29,0x43,0x3c,0xd5]
4592 // CHECK: mrs x9, spsr_und // encoding: [0x49,0x43,0x3c,0xd5]
4593 // CHECK: mrs x9, spsr_fiq // encoding: [0x69,0x43,0x3c,0xd5]
4594 // CHECK: mrs x9, fpcr // encoding: [0x09,0x44,0x3b,0xd5]
4595 // CHECK: mrs x9, fpsr // encoding: [0x29,0x44,0x3b,0xd5]
4596 // CHECK: mrs x9, dspsr_el0 // encoding: [0x09,0x45,0x3b,0xd5]
4597 // CHECK: mrs x9, dlr_el0 // encoding: [0x29,0x45,0x3b,0xd5]
4598 // CHECK: mrs x9, ifsr32_el2 // encoding: [0x29,0x50,0x3c,0xd5]
4599 // CHECK: mrs x9, afsr0_el1 // encoding: [0x09,0x51,0x38,0xd5]
4600 // CHECK: mrs x9, afsr0_el2 // encoding: [0x09,0x51,0x3c,0xd5]
4601 // CHECK: mrs x9, afsr0_el3 // encoding: [0x09,0x51,0x3e,0xd5]
4602 // CHECK: mrs x9, afsr1_el1 // encoding: [0x29,0x51,0x38,0xd5]
4603 // CHECK: mrs x9, afsr1_el2 // encoding: [0x29,0x51,0x3c,0xd5]
4604 // CHECK: mrs x9, afsr1_el3 // encoding: [0x29,0x51,0x3e,0xd5]
4605 // CHECK: mrs x9, esr_el1 // encoding: [0x09,0x52,0x38,0xd5]
4606 // CHECK: mrs x9, esr_el2 // encoding: [0x09,0x52,0x3c,0xd5]
4607 // CHECK: mrs x9, esr_el3 // encoding: [0x09,0x52,0x3e,0xd5]
4608 // CHECK: mrs x9, fpexc32_el2 // encoding: [0x09,0x53,0x3c,0xd5]
4609 // CHECK: mrs x9, far_el1 // encoding: [0x09,0x60,0x38,0xd5]
4610 // CHECK: mrs x9, far_el2 // encoding: [0x09,0x60,0x3c,0xd5]
4611 // CHECK: mrs x9, far_el3 // encoding: [0x09,0x60,0x3e,0xd5]
4612 // CHECK: mrs x9, hpfar_el2 // encoding: [0x89,0x60,0x3c,0xd5]
4613 // CHECK: mrs x9, par_el1 // encoding: [0x09,0x74,0x38,0xd5]
4614 // CHECK: mrs x9, pmcr_el0 // encoding: [0x09,0x9c,0x3b,0xd5]
4615 // CHECK: mrs x9, pmcntenset_el0 // encoding: [0x29,0x9c,0x3b,0xd5]
4616 // CHECK: mrs x9, pmcntenclr_el0 // encoding: [0x49,0x9c,0x3b,0xd5]
4617 // CHECK: mrs x9, pmovsclr_el0 // encoding: [0x69,0x9c,0x3b,0xd5]
4618 // CHECK: mrs x9, pmselr_el0 // encoding: [0xa9,0x9c,0x3b,0xd5]
4619 // CHECK: mrs x9, pmceid0_el0 // encoding: [0xc9,0x9c,0x3b,0xd5]
4620 // CHECK: mrs x9, pmceid1_el0 // encoding: [0xe9,0x9c,0x3b,0xd5]
4621 // CHECK: mrs x9, pmccntr_el0 // encoding: [0x09,0x9d,0x3b,0xd5]
4622 // CHECK: mrs x9, pmxevtyper_el0 // encoding: [0x29,0x9d,0x3b,0xd5]
4623 // CHECK: mrs x9, pmxevcntr_el0 // encoding: [0x49,0x9d,0x3b,0xd5]
4624 // CHECK: mrs x9, pmuserenr_el0 // encoding: [0x09,0x9e,0x3b,0xd5]
4625 // CHECK: mrs x9, pmintenset_el1 // encoding: [0x29,0x9e,0x38,0xd5]
4626 // CHECK: mrs x9, pmintenclr_el1 // encoding: [0x49,0x9e,0x38,0xd5]
4627 // CHECK: mrs x9, pmovsset_el0 // encoding: [0x69,0x9e,0x3b,0xd5]
4628 // CHECK: mrs x9, mair_el1 // encoding: [0x09,0xa2,0x38,0xd5]
4629 // CHECK: mrs x9, mair_el2 // encoding: [0x09,0xa2,0x3c,0xd5]
4630 // CHECK: mrs x9, mair_el3 // encoding: [0x09,0xa2,0x3e,0xd5]
4631 // CHECK: mrs x9, amair_el1 // encoding: [0x09,0xa3,0x38,0xd5]
4632 // CHECK: mrs x9, amair_el2 // encoding: [0x09,0xa3,0x3c,0xd5]
4633 // CHECK: mrs x9, amair_el3 // encoding: [0x09,0xa3,0x3e,0xd5]
4634 // CHECK: mrs x9, vbar_el1 // encoding: [0x09,0xc0,0x38,0xd5]
4635 // CHECK: mrs x9, vbar_el2 // encoding: [0x09,0xc0,0x3c,0xd5]
4636 // CHECK: mrs x9, vbar_el3 // encoding: [0x09,0xc0,0x3e,0xd5]
4637 // CHECK: mrs x9, rvbar_el1 // encoding: [0x29,0xc0,0x38,0xd5]
4638 // CHECK: mrs x9, rvbar_el2 // encoding: [0x29,0xc0,0x3c,0xd5]
4639 // CHECK: mrs x9, rvbar_el3 // encoding: [0x29,0xc0,0x3e,0xd5]
4640 // CHECK: mrs x9, rmr_el1 // encoding: [0x49,0xc0,0x38,0xd5]
4641 // CHECK: mrs x9, rmr_el2 // encoding: [0x49,0xc0,0x3c,0xd5]
4642 // CHECK: mrs x9, rmr_el3 // encoding: [0x49,0xc0,0x3e,0xd5]
4643 // CHECK: mrs x9, isr_el1 // encoding: [0x09,0xc1,0x38,0xd5]
4644 // CHECK: mrs x9, contextidr_el1 // encoding: [0x29,0xd0,0x38,0xd5]
4645 // CHECK: mrs x9, tpidr_el0 // encoding: [0x49,0xd0,0x3b,0xd5]
4646 // CHECK: mrs x9, tpidr_el2 // encoding: [0x49,0xd0,0x3c,0xd5]
4647 // CHECK: mrs x9, tpidr_el3 // encoding: [0x49,0xd0,0x3e,0xd5]
4648 // CHECK: mrs x9, tpidrro_el0 // encoding: [0x69,0xd0,0x3b,0xd5]
4649 // CHECK: mrs x9, tpidr_el1 // encoding: [0x89,0xd0,0x38,0xd5]
4650 // CHECK: mrs x9, cntfrq_el0 // encoding: [0x09,0xe0,0x3b,0xd5]
4651 // CHECK: mrs x9, cntpct_el0 // encoding: [0x29,0xe0,0x3b,0xd5]
4652 // CHECK: mrs x9, cntvct_el0 // encoding: [0x49,0xe0,0x3b,0xd5]
4653 // CHECK: mrs x9, cntvoff_el2 // encoding: [0x69,0xe0,0x3c,0xd5]
4654 // CHECK: mrs x9, cntkctl_el1 // encoding: [0x09,0xe1,0x38,0xd5]
4655 // CHECK: mrs x9, cnthctl_el2 // encoding: [0x09,0xe1,0x3c,0xd5]
4656 // CHECK: mrs x9, cntp_tval_el0 // encoding: [0x09,0xe2,0x3b,0xd5]
4657 // CHECK: mrs x9, cnthp_tval_el2 // encoding: [0x09,0xe2,0x3c,0xd5]
4658 // CHECK: mrs x9, cntps_tval_el1 // encoding: [0x09,0xe2,0x3f,0xd5]
4659 // CHECK: mrs x9, cntp_ctl_el0 // encoding: [0x29,0xe2,0x3b,0xd5]
4660 // CHECK: mrs x9, cnthp_ctl_el2 // encoding: [0x29,0xe2,0x3c,0xd5]
4661 // CHECK: mrs x9, cntps_ctl_el1 // encoding: [0x29,0xe2,0x3f,0xd5]
4662 // CHECK: mrs x9, cntp_cval_el0 // encoding: [0x49,0xe2,0x3b,0xd5]
4663 // CHECK: mrs x9, cnthp_cval_el2 // encoding: [0x49,0xe2,0x3c,0xd5]
4664 // CHECK: mrs x9, cntps_cval_el1 // encoding: [0x49,0xe2,0x3f,0xd5]
4665 // CHECK: mrs x9, cntv_tval_el0 // encoding: [0x09,0xe3,0x3b,0xd5]
4666 // CHECK: mrs x9, cntv_ctl_el0 // encoding: [0x29,0xe3,0x3b,0xd5]
4667 // CHECK: mrs x9, cntv_cval_el0 // encoding: [0x49,0xe3,0x3b,0xd5]
4668 // CHECK: mrs x9, pmevcntr0_el0 // encoding: [0x09,0xe8,0x3b,0xd5]
4669 // CHECK: mrs x9, pmevcntr1_el0 // encoding: [0x29,0xe8,0x3b,0xd5]
4670 // CHECK: mrs x9, pmevcntr2_el0 // encoding: [0x49,0xe8,0x3b,0xd5]
4671 // CHECK: mrs x9, pmevcntr3_el0 // encoding: [0x69,0xe8,0x3b,0xd5]
4672 // CHECK: mrs x9, pmevcntr4_el0 // encoding: [0x89,0xe8,0x3b,0xd5]
4673 // CHECK: mrs x9, pmevcntr5_el0 // encoding: [0xa9,0xe8,0x3b,0xd5]
4674 // CHECK: mrs x9, pmevcntr6_el0 // encoding: [0xc9,0xe8,0x3b,0xd5]
4675 // CHECK: mrs x9, pmevcntr7_el0 // encoding: [0xe9,0xe8,0x3b,0xd5]
4676 // CHECK: mrs x9, pmevcntr8_el0 // encoding: [0x09,0xe9,0x3b,0xd5]
4677 // CHECK: mrs x9, pmevcntr9_el0 // encoding: [0x29,0xe9,0x3b,0xd5]
4678 // CHECK: mrs x9, pmevcntr10_el0 // encoding: [0x49,0xe9,0x3b,0xd5]
4679 // CHECK: mrs x9, pmevcntr11_el0 // encoding: [0x69,0xe9,0x3b,0xd5]
4680 // CHECK: mrs x9, pmevcntr12_el0 // encoding: [0x89,0xe9,0x3b,0xd5]
4681 // CHECK: mrs x9, pmevcntr13_el0 // encoding: [0xa9,0xe9,0x3b,0xd5]
4682 // CHECK: mrs x9, pmevcntr14_el0 // encoding: [0xc9,0xe9,0x3b,0xd5]
4683 // CHECK: mrs x9, pmevcntr15_el0 // encoding: [0xe9,0xe9,0x3b,0xd5]
4684 // CHECK: mrs x9, pmevcntr16_el0 // encoding: [0x09,0xea,0x3b,0xd5]
4685 // CHECK: mrs x9, pmevcntr17_el0 // encoding: [0x29,0xea,0x3b,0xd5]
4686 // CHECK: mrs x9, pmevcntr18_el0 // encoding: [0x49,0xea,0x3b,0xd5]
4687 // CHECK: mrs x9, pmevcntr19_el0 // encoding: [0x69,0xea,0x3b,0xd5]
4688 // CHECK: mrs x9, pmevcntr20_el0 // encoding: [0x89,0xea,0x3b,0xd5]
4689 // CHECK: mrs x9, pmevcntr21_el0 // encoding: [0xa9,0xea,0x3b,0xd5]
4690 // CHECK: mrs x9, pmevcntr22_el0 // encoding: [0xc9,0xea,0x3b,0xd5]
4691 // CHECK: mrs x9, pmevcntr23_el0 // encoding: [0xe9,0xea,0x3b,0xd5]
4692 // CHECK: mrs x9, pmevcntr24_el0 // encoding: [0x09,0xeb,0x3b,0xd5]
4693 // CHECK: mrs x9, pmevcntr25_el0 // encoding: [0x29,0xeb,0x3b,0xd5]
4694 // CHECK: mrs x9, pmevcntr26_el0 // encoding: [0x49,0xeb,0x3b,0xd5]
4695 // CHECK: mrs x9, pmevcntr27_el0 // encoding: [0x69,0xeb,0x3b,0xd5]
4696 // CHECK: mrs x9, pmevcntr28_el0 // encoding: [0x89,0xeb,0x3b,0xd5]
4697 // CHECK: mrs x9, pmevcntr29_el0 // encoding: [0xa9,0xeb,0x3b,0xd5]
4698 // CHECK: mrs x9, pmevcntr30_el0 // encoding: [0xc9,0xeb,0x3b,0xd5]
4699 // CHECK: mrs x9, pmccfiltr_el0 // encoding: [0xe9,0xef,0x3b,0xd5]
4700 // CHECK: mrs x9, pmevtyper0_el0 // encoding: [0x09,0xec,0x3b,0xd5]
4701 // CHECK: mrs x9, pmevtyper1_el0 // encoding: [0x29,0xec,0x3b,0xd5]
4702 // CHECK: mrs x9, pmevtyper2_el0 // encoding: [0x49,0xec,0x3b,0xd5]
4703 // CHECK: mrs x9, pmevtyper3_el0 // encoding: [0x69,0xec,0x3b,0xd5]
4704 // CHECK: mrs x9, pmevtyper4_el0 // encoding: [0x89,0xec,0x3b,0xd5]
4705 // CHECK: mrs x9, pmevtyper5_el0 // encoding: [0xa9,0xec,0x3b,0xd5]
4706 // CHECK: mrs x9, pmevtyper6_el0 // encoding: [0xc9,0xec,0x3b,0xd5]
4707 // CHECK: mrs x9, pmevtyper7_el0 // encoding: [0xe9,0xec,0x3b,0xd5]
4708 // CHECK: mrs x9, pmevtyper8_el0 // encoding: [0x09,0xed,0x3b,0xd5]
4709 // CHECK: mrs x9, pmevtyper9_el0 // encoding: [0x29,0xed,0x3b,0xd5]
4710 // CHECK: mrs x9, pmevtyper10_el0 // encoding: [0x49,0xed,0x3b,0xd5]
4711 // CHECK: mrs x9, pmevtyper11_el0 // encoding: [0x69,0xed,0x3b,0xd5]
4712 // CHECK: mrs x9, pmevtyper12_el0 // encoding: [0x89,0xed,0x3b,0xd5]
4713 // CHECK: mrs x9, pmevtyper13_el0 // encoding: [0xa9,0xed,0x3b,0xd5]
4714 // CHECK: mrs x9, pmevtyper14_el0 // encoding: [0xc9,0xed,0x3b,0xd5]
4715 // CHECK: mrs x9, pmevtyper15_el0 // encoding: [0xe9,0xed,0x3b,0xd5]
4716 // CHECK: mrs x9, pmevtyper16_el0 // encoding: [0x09,0xee,0x3b,0xd5]
4717 // CHECK: mrs x9, pmevtyper17_el0 // encoding: [0x29,0xee,0x3b,0xd5]
4718 // CHECK: mrs x9, pmevtyper18_el0 // encoding: [0x49,0xee,0x3b,0xd5]
4719 // CHECK: mrs x9, pmevtyper19_el0 // encoding: [0x69,0xee,0x3b,0xd5]
4720 // CHECK: mrs x9, pmevtyper20_el0 // encoding: [0x89,0xee,0x3b,0xd5]
4721 // CHECK: mrs x9, pmevtyper21_el0 // encoding: [0xa9,0xee,0x3b,0xd5]
4722 // CHECK: mrs x9, pmevtyper22_el0 // encoding: [0xc9,0xee,0x3b,0xd5]
4723 // CHECK: mrs x9, pmevtyper23_el0 // encoding: [0xe9,0xee,0x3b,0xd5]
4724 // CHECK: mrs x9, pmevtyper24_el0 // encoding: [0x09,0xef,0x3b,0xd5]
4725 // CHECK: mrs x9, pmevtyper25_el0 // encoding: [0x29,0xef,0x3b,0xd5]
4726 // CHECK: mrs x9, pmevtyper26_el0 // encoding: [0x49,0xef,0x3b,0xd5]
4727 // CHECK: mrs x9, pmevtyper27_el0 // encoding: [0x69,0xef,0x3b,0xd5]
4728 // CHECK: mrs x9, pmevtyper28_el0 // encoding: [0x89,0xef,0x3b,0xd5]
4729 // CHECK: mrs x9, pmevtyper29_el0 // encoding: [0xa9,0xef,0x3b,0xd5]
4730 // CHECK: mrs x9, pmevtyper30_el0 // encoding: [0xc9,0xef,0x3b,0xd5]
4732 mrs x12, s3_7_c15_c1_5
4733 mrs x13, s3_2_c11_c15_7
4734 msr s3_0_c15_c0_0, x12
4735 msr s3_7_c11_c13_7, x5
4736 // CHECK: mrs x12, s3_7_c15_c1_5 // encoding: [0xac,0xf1,0x3f,0xd5]
4737 // CHECK: mrs x13, s3_2_c11_c15_7 // encoding: [0xed,0xbf,0x3a,0xd5]
4738 // CHECK: msr s3_0_c15_c0_0, x12 // encoding: [0x0c,0xf0,0x18,0xd5]
4739 // CHECK: msr s3_7_c11_c13_7, x5 // encoding: [0xe5,0xbd,0x1f,0xd5]
4741 //------------------------------------------------------------------------------
4742 // Unconditional branch (immediate)
4743 //------------------------------------------------------------------------------
4745 tbz x5, #0, somewhere
4746 tbz xzr, #63, elsewhere
4747 tbnz x5, #45, nowhere
4748 // CHECK: tbz x5, #0, somewhere // encoding: [0x05'A',A,A,0x36'A']
4749 // CHECK: // fixup A - offset: 0, value: somewhere, kind: fixup_a64_tstbr
4750 // CHECK: tbz xzr, #63, elsewhere // encoding: [0x1f'A',A,0xf8'A',0xb6'A']
4751 // CHECK: // fixup A - offset: 0, value: elsewhere, kind: fixup_a64_tstbr
4752 // CHECK: tbnz x5, #45, nowhere // encoding: [0x05'A',A,0x68'A',0xb7'A']
4753 // CHECK: // fixup A - offset: 0, value: nowhere, kind: fixup_a64_tstbr
4756 tbnz wzr, #31, nowhere
4757 tbz w5, #12, anywhere
4758 // CHECK: tbnz w3, #2, there // encoding: [0x03'A',A,0x10'A',0x37'A']
4759 // CHECK: // fixup A - offset: 0, value: there, kind: fixup_a64_tstbr
4760 // CHECK: tbnz wzr, #31, nowhere // encoding: [0x1f'A',A,0xf8'A',0x37'A']
4761 // CHECK: // fixup A - offset: 0, value: nowhere, kind: fixup_a64_tstbr
4762 // CHECK: tbz w5, #12, anywhere // encoding: [0x05'A',A,0x60'A',0x36'A']
4763 // CHECK: // fixup A - offset: 0, value: anywhere, kind: fixup_a64_tstbr
4765 //------------------------------------------------------------------------------
4766 // Unconditional branch (immediate)
4767 //------------------------------------------------------------------------------
4771 // CHECK: b somewhere // encoding: [A,A,A,0x14'A']
4772 // CHECK: // fixup A - offset: 0, value: somewhere, kind: fixup_a64_uncondbr
4773 // CHECK: bl elsewhere // encoding: [A,A,A,0x94'A']
4774 // CHECK: // fixup A - offset: 0, value: elsewhere, kind: fixup_a64_call
4780 // CHECK: b #4 // encoding: [0x01,0x00,0x00,0x14]
4781 // CHECK: bl #0 // encoding: [0x00,0x00,0x00,0x94]
4782 // CHECK: b #134217724 // encoding: [0xff,0xff,0xff,0x15]
4783 // CHECK: bl #-134217728 // encoding: [0x00,0x00,0x00,0x96]
4785 //------------------------------------------------------------------------------
4786 // Unconditional branch (register)
4787 //------------------------------------------------------------------------------
4792 // CHECK: br x20 // encoding: [0x80,0x02,0x1f,0xd6]
4793 // CHECK: blr xzr // encoding: [0xe0,0x03,0x3f,0xd6]
4794 // CHECK: ret x10 // encoding: [0x40,0x01,0x5f,0xd6]
4799 // CHECK: ret // encoding: [0xc0,0x03,0x5f,0xd6]
4800 // CHECK: eret // encoding: [0xe0,0x03,0x9f,0xd6]
4801 // CHECK: drps // encoding: [0xe0,0x03,0xbf,0xd6]