1 // RUN: llvm-mc -triple aarch64-none-linux-gnu -show-encoding -mattr=+fp-armv8 < %s | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-AARCH64
2 // RUN: llvm-mc -triple arm64-none-linux-gnu -show-encoding -mattr=+fp-armv8 < %s | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-ARM64
5 // Check that the assembler can handle the documented syntax from the ARM ARM.
6 // For complex constructs like shifter operands, check more thoroughly for them
7 // once then spot check that following instructions accept the form generally.
8 // This gives us good coverage while keeping the overall size of the test
15 //------------------------------------------------------------------------------
16 // Add/sub (extended register)
17 //------------------------------------------------------------------------------
18 // Basic extends 64-bit ops
20 add x20, sp, w19, uxth
21 add x12, x1, w20, uxtw
22 add x20, x3, x13, uxtx
23 add x17, x25, w20, sxtb
24 add x18, x13, w19, sxth
27 // CHECK: add x2, x4, w5, uxtb // encoding: [0x82,0x00,0x25,0x8b]
28 // CHECK: add x20, sp, w19, uxth // encoding: [0xf4,0x23,0x33,0x8b]
29 // CHECK: add x12, x1, w20, uxtw // encoding: [0x2c,0x40,0x34,0x8b]
30 // CHECK: add x20, x3, x13, uxtx // encoding: [0x74,0x60,0x2d,0x8b]
31 // CHECK: add x17, x25, w20, sxtb // encoding: [0x31,0x83,0x34,0x8b]
32 // CHECK: add x18, x13, w19, sxth // encoding: [0xb2,0xa1,0x33,0x8b]
33 // CHECK: add sp, x2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0x8b]
34 // CHECK: add x3, x5, x9, sxtx // encoding: [0xa3,0xe0,0x29,0x8b]
36 // Basic extends, 32-bit ops
38 add w21, w15, w17, uxth
39 add w30, w29, wzr, uxtw
40 add w19, w17, w1, uxtx // Goodness knows what this means
42 add w26, w17, w19, sxth
45 // CHECK: add w2, w5, w7, uxtb // encoding: [0xa2,0x00,0x27,0x0b]
46 // CHECK: add w21, w15, w17, uxth // encoding: [0xf5,0x21,0x31,0x0b]
47 // CHECK: add w30, w29, wzr, uxtw // encoding: [0xbe,0x43,0x3f,0x0b]
48 // CHECK: add w19, w17, w1, uxtx // encoding: [0x33,0x62,0x21,0x0b]
49 // CHECK: add w2, w5, w1, sxtb // encoding: [0xa2,0x80,0x21,0x0b]
50 // CHECK: add w26, w17, w19, sxth // encoding: [0x3a,0xa2,0x33,0x0b]
51 // CHECK: add w0, w2, w3, sxtw // encoding: [0x40,0xc0,0x23,0x0b]
52 // CHECK: add w2, w3, w5, sxtx // encoding: [0x62,0xe0,0x25,0x0b]
54 // Nonzero shift amounts
55 add x2, x3, w5, sxtb #0
56 add x7, x11, w13, uxth #4
57 add w17, w19, w23, uxtw #2
58 add w29, w23, w17, uxtx #1
59 // CHECK: add x2, x3, w5, sxtb // encoding: [0x62,0x80,0x25,0x8b]
60 // CHECK: add x7, x11, w13, uxth #4 // encoding: [0x67,0x31,0x2d,0x8b]
61 // CHECK: add w17, w19, w23, uxtw #2 // encoding: [0x71,0x4a,0x37,0x0b]
62 // CHECK: add w29, w23, w17, uxtx #1 // encoding: [0xfd,0x66,0x31,0x0b]
65 sub x2, x4, w5, uxtb #2
66 sub x20, sp, w19, uxth #4
67 sub x12, x1, w20, uxtw
68 sub x20, x3, x13, uxtx #0
69 sub x17, x25, w20, sxtb
70 sub x18, x13, w19, sxth
73 // CHECK: sub x2, x4, w5, uxtb #2 // encoding: [0x82,0x08,0x25,0xcb]
74 // CHECK: sub x20, sp, w19, uxth #4 // encoding: [0xf4,0x33,0x33,0xcb]
75 // CHECK: sub x12, x1, w20, uxtw // encoding: [0x2c,0x40,0x34,0xcb]
76 // CHECK: sub x20, x3, x13, uxtx // encoding: [0x74,0x60,0x2d,0xcb]
77 // CHECK: sub x17, x25, w20, sxtb // encoding: [0x31,0x83,0x34,0xcb]
78 // CHECK: sub x18, x13, w19, sxth // encoding: [0xb2,0xa1,0x33,0xcb]
79 // CHECK: sub sp, x2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0xcb]
80 // CHECK: sub x3, x5, x9, sxtx // encoding: [0xa3,0xe0,0x29,0xcb]
83 sub w21, w15, w17, uxth
84 sub w30, w29, wzr, uxtw
85 sub w19, w17, w1, uxtx // Goodness knows what this means
87 sub w26, wsp, w19, sxth
90 // CHECK: sub w2, w5, w7, uxtb // encoding: [0xa2,0x00,0x27,0x4b]
91 // CHECK: sub w21, w15, w17, uxth // encoding: [0xf5,0x21,0x31,0x4b]
92 // CHECK: sub w30, w29, wzr, uxtw // encoding: [0xbe,0x43,0x3f,0x4b]
93 // CHECK: sub w19, w17, w1, uxtx // encoding: [0x33,0x62,0x21,0x4b]
94 // CHECK: sub w2, w5, w1, sxtb // encoding: [0xa2,0x80,0x21,0x4b]
95 // CHECK: sub w26, wsp, w19, sxth // encoding: [0xfa,0xa3,0x33,0x4b]
96 // CHECK: sub wsp, w2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0x4b]
97 // CHECK: sub w2, w3, w5, sxtx // encoding: [0x62,0xe0,0x25,0x4b]
100 adds x2, x4, w5, uxtb #2
101 adds x20, sp, w19, uxth #4
102 adds x12, x1, w20, uxtw
103 adds x20, x3, x13, uxtx #0
104 adds xzr, x25, w20, sxtb #3
105 adds x18, sp, w19, sxth
106 adds xzr, x2, w3, sxtw
107 adds x3, x5, x9, sxtx #2
108 // CHECK: adds x2, x4, w5, uxtb #2 // encoding: [0x82,0x08,0x25,0xab]
109 // CHECK: adds x20, sp, w19, uxth #4 // encoding: [0xf4,0x33,0x33,0xab]
110 // CHECK: adds x12, x1, w20, uxtw // encoding: [0x2c,0x40,0x34,0xab]
111 // CHECK: adds x20, x3, x13, uxtx // encoding: [0x74,0x60,0x2d,0xab]
112 // CHECK: {{adds xzr,|cmn}} x25, w20, sxtb #3 // encoding: [0x3f,0x8f,0x34,0xab]
113 // CHECK: adds x18, sp, w19, sxth // encoding: [0xf2,0xa3,0x33,0xab]
114 // CHECK: {{adds xzr,|cmn}} x2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0xab]
115 // CHECK: adds x3, x5, x9, sxtx #2 // encoding: [0xa3,0xe8,0x29,0xab]
117 adds w2, w5, w7, uxtb
118 adds w21, w15, w17, uxth
119 adds w30, w29, wzr, uxtw
120 adds w19, w17, w1, uxtx // Goodness knows what this means
121 adds w2, w5, w1, sxtb #1
122 adds w26, wsp, w19, sxth
123 adds wzr, w2, w3, sxtw
124 adds w2, w3, w5, sxtx
125 // CHECK: adds w2, w5, w7, uxtb // encoding: [0xa2,0x00,0x27,0x2b]
126 // CHECK: adds w21, w15, w17, uxth // encoding: [0xf5,0x21,0x31,0x2b]
127 // CHECK: adds w30, w29, wzr, uxtw // encoding: [0xbe,0x43,0x3f,0x2b]
128 // CHECK: adds w19, w17, w1, uxtx // encoding: [0x33,0x62,0x21,0x2b]
129 // CHECK: adds w2, w5, w1, sxtb #1 // encoding: [0xa2,0x84,0x21,0x2b]
130 // CHECK: adds w26, wsp, w19, sxth // encoding: [0xfa,0xa3,0x33,0x2b]
131 // CHECK: adds wzr, w2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0x2b]
132 // CHECK: adds w2, w3, w5, sxtx // encoding: [0x62,0xe0,0x25,0x2b]
135 subs x2, x4, w5, uxtb #2
136 subs x20, sp, w19, uxth #4
137 subs x12, x1, w20, uxtw
138 subs x20, x3, x13, uxtx #0
139 subs xzr, x25, w20, sxtb #3
140 subs x18, sp, w19, sxth
141 subs xzr, x2, w3, sxtw
142 subs x3, x5, x9, sxtx #2
143 // CHECK: subs x2, x4, w5, uxtb #2 // encoding: [0x82,0x08,0x25,0xeb]
144 // CHECK: subs x20, sp, w19, uxth #4 // encoding: [0xf4,0x33,0x33,0xeb]
145 // CHECK: subs x12, x1, w20, uxtw // encoding: [0x2c,0x40,0x34,0xeb]
146 // CHECK: subs x20, x3, x13, uxtx // encoding: [0x74,0x60,0x2d,0xeb]
147 // CHECK: {{subs xzr,|cmp}} x25, w20, sxtb #3 // encoding: [0x3f,0x8f,0x34,0xeb]
148 // CHECK: subs x18, sp, w19, sxth // encoding: [0xf2,0xa3,0x33,0xeb]
149 // CHECK: {{subs xzr,|cmp}} x2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0xeb]
150 // CHECK: subs x3, x5, x9, sxtx #2 // encoding: [0xa3,0xe8,0x29,0xeb]
152 subs w2, w5, w7, uxtb
153 subs w21, w15, w17, uxth
154 subs w30, w29, wzr, uxtw
155 subs w19, w17, w1, uxtx // Goodness knows what this means
156 subs w2, w5, w1, sxtb #1
157 subs w26, wsp, w19, sxth
158 subs wzr, w2, w3, sxtw
159 subs w2, w3, w5, sxtx
160 // CHECK: subs w2, w5, w7, uxtb // encoding: [0xa2,0x00,0x27,0x6b]
161 // CHECK: subs w21, w15, w17, uxth // encoding: [0xf5,0x21,0x31,0x6b]
162 // CHECK: subs w30, w29, wzr, uxtw // encoding: [0xbe,0x43,0x3f,0x6b]
163 // CHECK: subs w19, w17, w1, uxtx // encoding: [0x33,0x62,0x21,0x6b]
164 // CHECK: subs w2, w5, w1, sxtb #1 // encoding: [0xa2,0x84,0x21,0x6b]
165 // CHECK: subs w26, wsp, w19, sxth // encoding: [0xfa,0xa3,0x33,0x6b]
166 // CHECK: {{subs wzr,|cmp}} w2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0x6b]
167 // CHECK: subs w2, w3, w5, sxtx // encoding: [0x62,0xe0,0x25,0x6b]
174 cmp x25, w20, sxtb #3
178 // CHECK: cmp x4, w5, uxtb #2 // encoding: [0x9f,0x08,0x25,0xeb]
179 // CHECK: cmp sp, w19, uxth #4 // encoding: [0xff,0x33,0x33,0xeb]
180 // CHECK: cmp x1, w20, uxtw // encoding: [0x3f,0x40,0x34,0xeb]
181 // CHECK: cmp x3, x13, uxtx // encoding: [0x7f,0x60,0x2d,0xeb]
182 // CHECK: cmp x25, w20, sxtb #3 // encoding: [0x3f,0x8f,0x34,0xeb]
183 // CHECK: cmp sp, w19, sxth // encoding: [0xff,0xa3,0x33,0xeb]
184 // CHECK: cmp x2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0xeb]
185 // CHECK: cmp x5, x9, sxtx #2 // encoding: [0xbf,0xe8,0x29,0xeb]
190 cmp w17, w1, uxtx // Goodness knows what this means
195 // CHECK: cmp w5, w7, uxtb // encoding: [0xbf,0x00,0x27,0x6b]
196 // CHECK: cmp w15, w17, uxth // encoding: [0xff,0x21,0x31,0x6b]
197 // CHECK: cmp w29, wzr, uxtw // encoding: [0xbf,0x43,0x3f,0x6b]
198 // CHECK: cmp w17, w1, uxtx // encoding: [0x3f,0x62,0x21,0x6b]
199 // CHECK: cmp w5, w1, sxtb #1 // encoding: [0xbf,0x84,0x21,0x6b]
200 // CHECK: cmp wsp, w19, sxth // encoding: [0xff,0xa3,0x33,0x6b]
201 // CHECK: cmp w2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0x6b]
202 // CHECK: cmp w3, w5, sxtx // encoding: [0x7f,0xe0,0x25,0x6b]
210 cmn x25, w20, sxtb #3
214 // CHECK: cmn x4, w5, uxtb #2 // encoding: [0x9f,0x08,0x25,0xab]
215 // CHECK: cmn sp, w19, uxth #4 // encoding: [0xff,0x33,0x33,0xab]
216 // CHECK: cmn x1, w20, uxtw // encoding: [0x3f,0x40,0x34,0xab]
217 // CHECK: cmn x3, x13, uxtx // encoding: [0x7f,0x60,0x2d,0xab]
218 // CHECK: cmn x25, w20, sxtb #3 // encoding: [0x3f,0x8f,0x34,0xab]
219 // CHECK: cmn sp, w19, sxth // encoding: [0xff,0xa3,0x33,0xab]
220 // CHECK: cmn x2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0xab]
221 // CHECK: cmn x5, x9, sxtx #2 // encoding: [0xbf,0xe8,0x29,0xab]
226 cmn w17, w1, uxtx // Goodness knows what this means
231 // CHECK: {{cmn|adds wzr,}} w5, w7, uxtb // encoding: [0xbf,0x00,0x27,0x2b]
232 // CHECK: {{cmn|adds wzr,}} w15, w17, uxth // encoding: [0xff,0x21,0x31,0x2b]
233 // CHECK: {{cmn|adds wzr,}} w29, wzr, uxtw // encoding: [0xbf,0x43,0x3f,0x2b]
234 // CHECK: {{cmn|adds wzr,}} w17, w1, uxtx // encoding: [0x3f,0x62,0x21,0x2b]
235 // CHECK: {{cmn|adds wzr,}} w5, w1, sxtb #1 // encoding: [0xbf,0x84,0x21,0x2b]
236 // CHECK: {{cmn|adds wzr,}} wsp, w19, sxth // encoding: [0xff,0xa3,0x33,0x2b]
237 // CHECK: {{cmn|adds wzr,}} w2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0x2b]
238 // CHECK: {{cmn|adds wzr,}} w3, w5, sxtx // encoding: [0x7f,0xe0,0x25,0x2b]
241 cmp x20, w29, uxtb #3
242 cmp x12, x13, uxtx #4
245 // CHECK: cmp x20, w29, uxtb #3 // encoding: [0x9f,0x0e,0x3d,0xeb]
246 // CHECK: cmp x12, x13, uxtx #4 // encoding: [0x9f,0x71,0x2d,0xeb]
247 // CHECK: cmp wsp, w1, uxtb // encoding: [0xff,0x03,0x21,0x6b]
248 // CHECK: {{cmn|adds wzr,}} wsp, wzr, sxtw // encoding: [0xff,0xc3,0x3f,0x2b]
250 // LSL variant if sp involved
251 sub sp, x3, x7, lsl #4
252 add w2, wsp, w3, lsl #1
254 adds wzr, wsp, w3, lsl #4
255 subs x3, sp, x9, lsl #2
256 // CHECK: sub sp, x3, x7, lsl #4 // encoding: [0x7f,0x70,0x27,0xcb]
257 // CHECK: add w2, wsp, w3, lsl #1 // encoding: [0xe2,0x47,0x23,0x0b]
258 // CHECK: cmp wsp, w9 // encoding: [0xff,0x43,0x29,0x6b]
259 // CHECK: adds wzr, wsp, w3, lsl #4 // encoding: [0xff,0x53,0x23,0x2b]
260 // CHECK: subs x3, sp, x9, lsl #2 // encoding: [0xe3,0x6b,0x29,0xeb]
262 //------------------------------------------------------------------------------
263 // Add/sub (immediate)
264 //------------------------------------------------------------------------------
266 // Check basic immediate values: an unsigned 12-bit immediate, optionally
267 // shifted left by 12 bits.
270 add w30, w29, #1, lsl #12
271 add w13, w5, #4095, lsl #12
273 // CHECK: add w4, w5, #0 // encoding: [0xa4,0x00,0x00,0x11]
274 // CHECK: add w2, w3, #4095 // encoding: [0x62,0xfc,0x3f,0x11]
275 // CHECK: add w30, w29, #1, lsl #12 // encoding: [0xbe,0x07,0x40,0x11]
276 // CHECK: add w13, w5, #4095, lsl #12 // encoding: [0xad,0xfc,0x7f,0x11]
277 // CHECK: add x5, x7, #1638 // encoding: [0xe5,0x98,0x19,0x91]
279 // All registers involved in the non-S variants have 31 encoding sp rather than zr
280 add w20, wsp, #801, lsl #0
283 // CHECK: add w20, wsp, #801 // encoding: [0xf4,0x87,0x0c,0x11]
284 // CHECK: add wsp, wsp, #1104 // encoding: [0xff,0x43,0x11,0x11]
285 // CHECK: add wsp, w30, #4084 // encoding: [0xdf,0xd3,0x3f,0x11]
287 // A few checks on the sanity of 64-bit versions
289 add x3, x24, #4095, lsl #12
292 // CHECK: add x0, x24, #291 // encoding: [0x00,0x8f,0x04,0x91]
293 // CHECK: add x3, x24, #4095, lsl #12 // encoding: [0x03,0xff,0x7f,0x91]
294 // CHECK: add x8, sp, #1074 // encoding: [0xe8,0xcb,0x10,0x91]
295 // CHECK: add sp, x29, #3816 // encoding: [0xbf,0xa3,0x3b,0x91]
299 sub w4, w20, #546, lsl #12
302 // CHECK: sub w0, wsp, #4077 // encoding: [0xe0,0xb7,0x3f,0x51]
303 // CHECK: sub w4, w20, #546, lsl #12 // encoding: [0x84,0x8a,0x48,0x51]
304 // CHECK: sub sp, sp, #288 // encoding: [0xff,0x83,0x04,0xd1]
305 // CHECK: sub wsp, w19, #16 // encoding: [0x7f,0x42,0x00,0x51]
307 // ADDS/SUBS accept zr in the Rd position but sp in the Rn position
308 adds w13, w23, #291, lsl #12
309 adds wzr, w2, #4095 // FIXME: canonically should be cmn
311 adds xzr, x3, #0x1, lsl #12 // FIXME: canonically should be cmn
312 // CHECK: adds w13, w23, #291, lsl #12 // encoding: [0xed,0x8e,0x44,0x31]
313 // CHECK: {{adds wzr,|cmn}} w2, #4095 // encoding: [0x5f,0xfc,0x3f,0x31]
314 // CHECK: adds w20, wsp, #0 // encoding: [0xf4,0x03,0x00,0x31]
315 // CHECK: {{adds xzr,|cmn}} x3, #1, lsl #12 // encoding: [0x7f,0x04,0x40,0xb1]
318 subs xzr, sp, #20, lsl #12 // FIXME: canonically should be cmp
319 subs xzr, x30, #4095, lsl #0 // FIXME: canonically should be cmp
321 // CHECK: {{subs xzr,|cmp}} sp, #20, lsl #12 // encoding: [0xff,0x53,0x40,0xf1]
322 // CHECK: {{subs xzr,|cmp}} x30, #4095 // encoding: [0xdf,0xff,0x3f,0xf1]
323 // CHECK: subs x4, sp, #3822 // encoding: [0xe4,0xbb,0x3b,0xf1]
325 // cmn is an alias for adds zr, ...
326 cmn w3, #291, lsl #12
327 cmn wsp, #1365, lsl #0
328 cmn sp, #1092, lsl #12
329 // CHECK: cmn w3, #291, lsl #12 // encoding: [0x7f,0x8c,0x44,0x31]
330 // CHECK: cmn wsp, #1365 // encoding: [0xff,0x57,0x15,0x31]
331 // CHECK: cmn sp, #1092, lsl #12 // encoding: [0xff,0x13,0x51,0xb1]
333 // cmp is an alias for subs zr, ... (FIXME: should always disassemble as such too).
334 cmp x4, #300, lsl #12
337 // CHECK: cmp x4, #300, lsl #12 // encoding: [0x9f,0xb0,0x44,0xf1]
338 // CHECK: cmp wsp, #500 // encoding: [0xff,0xd3,0x07,0x71]
339 // CHECK: cmp sp, #200 // encoding: [0xff,0x23,0x03,0xf1]
341 // A "MOV" involving sp is encoded in this manner: add Reg, Reg, #0
346 // CHECK: mov sp, x30 // encoding: [0xdf,0x03,0x00,0x91]
347 // CHECK: mov wsp, w20 // encoding: [0x9f,0x02,0x00,0x11]
348 // CHECK: mov x11, sp // encoding: [0xeb,0x03,0x00,0x91]
349 // CHECK: mov w24, wsp // encoding: [0xf8,0x03,0x00,0x11]
351 // A relocation check (default to lo12, which is the only sane relocation anyway really)
352 add x0, x4, #:lo12:var
353 // CHECK-AARCH64: add x0, x4, #:lo12:var // encoding: [0x80'A',A,A,0x91'A']
354 // CHECK-AARCH64: // fixup A - offset: 0, value: :lo12:var, kind: fixup_a64_add_lo12
355 // CHECK-ARM64: add x0, x4, :lo12:var // encoding: [0x80,0bAAAAAA00,0b00AAAAAA,0x91]
356 // CHECK-ARM64: // fixup A - offset: 0, value: :lo12:var, kind: fixup_arm64_add_imm12
358 //------------------------------------------------------------------------------
359 // Add-sub (shifted register)
360 //------------------------------------------------------------------------------
362 // As usual, we don't print the canonical forms of many instructions.
368 // CHECK: add w3, w5, w7 // encoding: [0xa3,0x00,0x07,0x0b]
369 // CHECK: add wzr, w3, w5 // encoding: [0x7f,0x00,0x05,0x0b]
370 // CHECK: add w20, wzr, w4 // encoding: [0xf4,0x03,0x04,0x0b]
371 // CHECK: add w4, w6, wzr // encoding: [0xc4,0x00,0x1f,0x0b]
373 add w11, w13, w15, lsl #0
374 add w9, w3, wzr, lsl #10
375 add w17, w29, w20, lsl #31
376 // CHECK: add w11, w13, w15 // encoding: [0xab,0x01,0x0f,0x0b]
377 // CHECK: add w9, w3, wzr, lsl #10 // encoding: [0x69,0x28,0x1f,0x0b]
378 // CHECK: add w17, w29, w20, lsl #31 // encoding: [0xb1,0x7f,0x14,0x0b]
380 add w21, w22, w23, lsr #0
381 add w24, w25, w26, lsr #18
382 add w27, w28, w29, lsr #31
383 // CHECK: add w21, w22, w23, lsr #0 // encoding: [0xd5,0x02,0x57,0x0b]
384 // CHECK: add w24, w25, w26, lsr #18 // encoding: [0x38,0x4b,0x5a,0x0b]
385 // CHECK: add w27, w28, w29, lsr #31 // encoding: [0x9b,0x7f,0x5d,0x0b]
387 add w2, w3, w4, asr #0
388 add w5, w6, w7, asr #21
389 add w8, w9, w10, asr #31
390 // CHECK: add w2, w3, w4, asr #0 // encoding: [0x62,0x00,0x84,0x0b]
391 // CHECK: add w5, w6, w7, asr #21 // encoding: [0xc5,0x54,0x87,0x0b]
392 // CHECK: add w8, w9, w10, asr #31 // encoding: [0x28,0x7d,0x8a,0x0b]
398 // CHECK: add x3, x5, x7 // encoding: [0xa3,0x00,0x07,0x8b]
399 // CHECK: add xzr, x3, x5 // encoding: [0x7f,0x00,0x05,0x8b]
400 // CHECK: add x20, xzr, x4 // encoding: [0xf4,0x03,0x04,0x8b]
401 // CHECK: add x4, x6, xzr // encoding: [0xc4,0x00,0x1f,0x8b]
403 add x11, x13, x15, lsl #0
404 add x9, x3, xzr, lsl #10
405 add x17, x29, x20, lsl #63
406 // CHECK: add x11, x13, x15 // encoding: [0xab,0x01,0x0f,0x8b]
407 // CHECK: add x9, x3, xzr, lsl #10 // encoding: [0x69,0x28,0x1f,0x8b]
408 // CHECK: add x17, x29, x20, lsl #63 // encoding: [0xb1,0xff,0x14,0x8b]
410 add x21, x22, x23, lsr #0
411 add x24, x25, x26, lsr #18
412 add x27, x28, x29, lsr #63
413 // CHECK: add x21, x22, x23, lsr #0 // encoding: [0xd5,0x02,0x57,0x8b]
414 // CHECK: add x24, x25, x26, lsr #18 // encoding: [0x38,0x4b,0x5a,0x8b]
415 // CHECK: add x27, x28, x29, lsr #63 // encoding: [0x9b,0xff,0x5d,0x8b]
417 add x2, x3, x4, asr #0
418 add x5, x6, x7, asr #21
419 add x8, x9, x10, asr #63
420 // CHECK: add x2, x3, x4, asr #0 // encoding: [0x62,0x00,0x84,0x8b]
421 // CHECK: add x5, x6, x7, asr #21 // encoding: [0xc5,0x54,0x87,0x8b]
422 // CHECK: add x8, x9, x10, asr #63 // encoding: [0x28,0xfd,0x8a,0x8b]
428 // CHECK: adds w3, w5, w7 // encoding: [0xa3,0x00,0x07,0x2b]
429 // CHECK: {{adds wzr,|cmn}} w3, w5 // encoding: [0x7f,0x00,0x05,0x2b]
430 // CHECK: adds w20, wzr, w4 // encoding: [0xf4,0x03,0x04,0x2b]
431 // CHECK: adds w4, w6, wzr // encoding: [0xc4,0x00,0x1f,0x2b]
433 adds w11, w13, w15, lsl #0
434 adds w9, w3, wzr, lsl #10
435 adds w17, w29, w20, lsl #31
436 // CHECK: adds w11, w13, w15 // encoding: [0xab,0x01,0x0f,0x2b]
437 // CHECK: adds w9, w3, wzr, lsl #10 // encoding: [0x69,0x28,0x1f,0x2b]
438 // CHECK: adds w17, w29, w20, lsl #31 // encoding: [0xb1,0x7f,0x14,0x2b]
440 adds w21, w22, w23, lsr #0
441 adds w24, w25, w26, lsr #18
442 adds w27, w28, w29, lsr #31
443 // CHECK: adds w21, w22, w23, lsr #0 // encoding: [0xd5,0x02,0x57,0x2b]
444 // CHECK: adds w24, w25, w26, lsr #18 // encoding: [0x38,0x4b,0x5a,0x2b]
445 // CHECK: adds w27, w28, w29, lsr #31 // encoding: [0x9b,0x7f,0x5d,0x2b]
447 adds w2, w3, w4, asr #0
448 adds w5, w6, w7, asr #21
449 adds w8, w9, w10, asr #31
450 // CHECK: adds w2, w3, w4, asr #0 // encoding: [0x62,0x00,0x84,0x2b]
451 // CHECK: adds w5, w6, w7, asr #21 // encoding: [0xc5,0x54,0x87,0x2b]
452 // CHECK: adds w8, w9, w10, asr #31 // encoding: [0x28,0x7d,0x8a,0x2b]
458 // CHECK: adds x3, x5, x7 // encoding: [0xa3,0x00,0x07,0xab]
459 // CHECK: {{adds xzr,|cmn}} x3, x5 // encoding: [0x7f,0x00,0x05,0xab]
460 // CHECK: adds x20, xzr, x4 // encoding: [0xf4,0x03,0x04,0xab]
461 // CHECK: adds x4, x6, xzr // encoding: [0xc4,0x00,0x1f,0xab]
463 adds x11, x13, x15, lsl #0
464 adds x9, x3, xzr, lsl #10
465 adds x17, x29, x20, lsl #63
466 // CHECK: adds x11, x13, x15 // encoding: [0xab,0x01,0x0f,0xab]
467 // CHECK: adds x9, x3, xzr, lsl #10 // encoding: [0x69,0x28,0x1f,0xab]
468 // CHECK: adds x17, x29, x20, lsl #63 // encoding: [0xb1,0xff,0x14,0xab]
470 adds x21, x22, x23, lsr #0
471 adds x24, x25, x26, lsr #18
472 adds x27, x28, x29, lsr #63
473 // CHECK: adds x21, x22, x23, lsr #0 // encoding: [0xd5,0x02,0x57,0xab]
474 // CHECK: adds x24, x25, x26, lsr #18 // encoding: [0x38,0x4b,0x5a,0xab]
475 // CHECK: adds x27, x28, x29, lsr #63 // encoding: [0x9b,0xff,0x5d,0xab]
477 adds x2, x3, x4, asr #0
478 adds x5, x6, x7, asr #21
479 adds x8, x9, x10, asr #63
480 // CHECK: adds x2, x3, x4, asr #0 // encoding: [0x62,0x00,0x84,0xab]
481 // CHECK: adds x5, x6, x7, asr #21 // encoding: [0xc5,0x54,0x87,0xab]
482 // CHECK: adds x8, x9, x10, asr #63 // encoding: [0x28,0xfd,0x8a,0xab]
488 // CHECK: sub w3, w5, w7 // encoding: [0xa3,0x00,0x07,0x4b]
489 // CHECK: sub wzr, w3, w5 // encoding: [0x7f,0x00,0x05,0x4b]
490 // CHECK-AARCH64: sub w20, wzr, w4 // encoding: [0xf4,0x03,0x04,0x4b]
491 // CHECK-ARM64: neg w20, w4 // encoding: [0xf4,0x03,0x04,0x4b]
492 // CHECK: sub w4, w6, wzr // encoding: [0xc4,0x00,0x1f,0x4b]
494 sub w11, w13, w15, lsl #0
495 sub w9, w3, wzr, lsl #10
496 sub w17, w29, w20, lsl #31
497 // CHECK: sub w11, w13, w15 // encoding: [0xab,0x01,0x0f,0x4b]
498 // CHECK: sub w9, w3, wzr, lsl #10 // encoding: [0x69,0x28,0x1f,0x4b]
499 // CHECK: sub w17, w29, w20, lsl #31 // encoding: [0xb1,0x7f,0x14,0x4b]
501 sub w21, w22, w23, lsr #0
502 sub w24, w25, w26, lsr #18
503 sub w27, w28, w29, lsr #31
504 // CHECK: sub w21, w22, w23, lsr #0 // encoding: [0xd5,0x02,0x57,0x4b]
505 // CHECK: sub w24, w25, w26, lsr #18 // encoding: [0x38,0x4b,0x5a,0x4b]
506 // CHECK: sub w27, w28, w29, lsr #31 // encoding: [0x9b,0x7f,0x5d,0x4b]
508 sub w2, w3, w4, asr #0
509 sub w5, w6, w7, asr #21
510 sub w8, w9, w10, asr #31
511 // CHECK: sub w2, w3, w4, asr #0 // encoding: [0x62,0x00,0x84,0x4b]
512 // CHECK: sub w5, w6, w7, asr #21 // encoding: [0xc5,0x54,0x87,0x4b]
513 // CHECK: sub w8, w9, w10, asr #31 // encoding: [0x28,0x7d,0x8a,0x4b]
519 // CHECK: sub x3, x5, x7 // encoding: [0xa3,0x00,0x07,0xcb]
520 // CHECK: sub xzr, x3, x5 // encoding: [0x7f,0x00,0x05,0xcb]
521 // CHECK-AARCH64: sub x20, xzr, x4 // encoding: [0xf4,0x03,0x04,0xcb]
522 // CHECK-ARM64: neg x20, x4 // encoding: [0xf4,0x03,0x04,0xcb]
523 // CHECK: sub x4, x6, xzr // encoding: [0xc4,0x00,0x1f,0xcb]
525 sub x11, x13, x15, lsl #0
526 sub x9, x3, xzr, lsl #10
527 sub x17, x29, x20, lsl #63
528 // CHECK: sub x11, x13, x15 // encoding: [0xab,0x01,0x0f,0xcb]
529 // CHECK: sub x9, x3, xzr, lsl #10 // encoding: [0x69,0x28,0x1f,0xcb]
530 // CHECK: sub x17, x29, x20, lsl #63 // encoding: [0xb1,0xff,0x14,0xcb]
532 sub x21, x22, x23, lsr #0
533 sub x24, x25, x26, lsr #18
534 sub x27, x28, x29, lsr #63
535 // CHECK: sub x21, x22, x23, lsr #0 // encoding: [0xd5,0x02,0x57,0xcb]
536 // CHECK: sub x24, x25, x26, lsr #18 // encoding: [0x38,0x4b,0x5a,0xcb]
537 // CHECK: sub x27, x28, x29, lsr #63 // encoding: [0x9b,0xff,0x5d,0xcb]
539 sub x2, x3, x4, asr #0
540 sub x5, x6, x7, asr #21
541 sub x8, x9, x10, asr #63
542 // CHECK: sub x2, x3, x4, asr #0 // encoding: [0x62,0x00,0x84,0xcb]
543 // CHECK: sub x5, x6, x7, asr #21 // encoding: [0xc5,0x54,0x87,0xcb]
544 // CHECK: sub x8, x9, x10, asr #63 // encoding: [0x28,0xfd,0x8a,0xcb]
550 // CHECK: subs w3, w5, w7 // encoding: [0xa3,0x00,0x07,0x6b]
551 // CHECK: {{subs wzr,|cmp}} w3, w5 // encoding: [0x7f,0x00,0x05,0x6b]
552 // CHECK-AARCH64: subs w20, wzr, w4 // encoding: [0xf4,0x03,0x04,0x6b]
553 // CHECK-ARM64: negs w20, w4 // encoding: [0xf4,0x03,0x04,0x6b]
554 // CHECK: subs w4, w6, wzr // encoding: [0xc4,0x00,0x1f,0x6b]
556 subs w11, w13, w15, lsl #0
557 subs w9, w3, wzr, lsl #10
558 subs w17, w29, w20, lsl #31
559 // CHECK: subs w11, w13, w15 // encoding: [0xab,0x01,0x0f,0x6b]
560 // CHECK: subs w9, w3, wzr, lsl #10 // encoding: [0x69,0x28,0x1f,0x6b]
561 // CHECK: subs w17, w29, w20, lsl #31 // encoding: [0xb1,0x7f,0x14,0x6b]
563 subs w21, w22, w23, lsr #0
564 subs w24, w25, w26, lsr #18
565 subs w27, w28, w29, lsr #31
566 // CHECK: subs w21, w22, w23, lsr #0 // encoding: [0xd5,0x02,0x57,0x6b]
567 // CHECK: subs w24, w25, w26, lsr #18 // encoding: [0x38,0x4b,0x5a,0x6b]
568 // CHECK: subs w27, w28, w29, lsr #31 // encoding: [0x9b,0x7f,0x5d,0x6b]
570 subs w2, w3, w4, asr #0
571 subs w5, w6, w7, asr #21
572 subs w8, w9, w10, asr #31
573 // CHECK: subs w2, w3, w4, asr #0 // encoding: [0x62,0x00,0x84,0x6b]
574 // CHECK: subs w5, w6, w7, asr #21 // encoding: [0xc5,0x54,0x87,0x6b]
575 // CHECK: subs w8, w9, w10, asr #31 // encoding: [0x28,0x7d,0x8a,0x6b]
581 // CHECK: subs x3, x5, x7 // encoding: [0xa3,0x00,0x07,0xeb]
582 // CHECK: {{subs xzr,|cmp}} x3, x5 // encoding: [0x7f,0x00,0x05,0xeb]
583 // CHECK-AARCH64: subs x20, xzr, x4 // encoding: [0xf4,0x03,0x04,0xeb]
584 // CHECK-ARM64: negs x20, x4 // encoding: [0xf4,0x03,0x04,0xeb]
585 // CHECK: subs x4, x6, xzr // encoding: [0xc4,0x00,0x1f,0xeb]
587 subs x11, x13, x15, lsl #0
588 subs x9, x3, xzr, lsl #10
589 subs x17, x29, x20, lsl #63
590 // CHECK: subs x11, x13, x15 // encoding: [0xab,0x01,0x0f,0xeb]
591 // CHECK: subs x9, x3, xzr, lsl #10 // encoding: [0x69,0x28,0x1f,0xeb]
592 // CHECK: subs x17, x29, x20, lsl #63 // encoding: [0xb1,0xff,0x14,0xeb]
594 subs x21, x22, x23, lsr #0
595 subs x24, x25, x26, lsr #18
596 subs x27, x28, x29, lsr #63
597 // CHECK: subs x21, x22, x23, lsr #0 // encoding: [0xd5,0x02,0x57,0xeb]
598 // CHECK: subs x24, x25, x26, lsr #18 // encoding: [0x38,0x4b,0x5a,0xeb]
599 // CHECK: subs x27, x28, x29, lsr #63 // encoding: [0x9b,0xff,0x5d,0xeb]
601 subs x2, x3, x4, asr #0
602 subs x5, x6, x7, asr #21
603 subs x8, x9, x10, asr #63
604 // CHECK: subs x2, x3, x4, asr #0 // encoding: [0x62,0x00,0x84,0xeb]
605 // CHECK: subs x5, x6, x7, asr #21 // encoding: [0xc5,0x54,0x87,0xeb]
606 // CHECK: subs x8, x9, x10, asr #63 // encoding: [0x28,0xfd,0x8a,0xeb]
611 // CHECK: cmn w0, w3 // encoding: [0x1f,0x00,0x03,0x2b]
612 // CHECK: cmn wzr, w4 // encoding: [0xff,0x03,0x04,0x2b]
613 // CHECK: cmn w5, wzr // encoding: [0xbf,0x00,0x1f,0x2b]
617 cmn w10, w11, lsl #31
618 // CHECK: cmn w6, w7 // encoding: [0xdf,0x00,0x07,0x2b]
619 // CHECK: cmn w8, w9, lsl #15 // encoding: [0x1f,0x3d,0x09,0x2b]
620 // CHECK: cmn w10, w11, lsl #31 // encoding: [0x5f,0x7d,0x0b,0x2b]
623 cmn w14, w15, lsr #21
624 cmn w16, w17, lsr #31
625 // CHECK: cmn w12, w13, lsr #0 // encoding: [0x9f,0x01,0x4d,0x2b]
626 // CHECK: cmn w14, w15, lsr #21 // encoding: [0xdf,0x55,0x4f,0x2b]
627 // CHECK: cmn w16, w17, lsr #31 // encoding: [0x1f,0x7e,0x51,0x2b]
630 cmn w20, w21, asr #22
631 cmn w22, w23, asr #31
632 // CHECK: cmn w18, w19, asr #0 // encoding: [0x5f,0x02,0x93,0x2b]
633 // CHECK: cmn w20, w21, asr #22 // encoding: [0x9f,0x5a,0x95,0x2b]
634 // CHECK: cmn w22, w23, asr #31 // encoding: [0xdf,0x7e,0x97,0x2b]
639 // CHECK: cmn x0, x3 // encoding: [0x1f,0x00,0x03,0xab]
640 // CHECK: cmn xzr, x4 // encoding: [0xff,0x03,0x04,0xab]
641 // CHECK: cmn x5, xzr // encoding: [0xbf,0x00,0x1f,0xab]
645 cmn x10, x11, lsl #63
646 // CHECK: cmn x6, x7 // encoding: [0xdf,0x00,0x07,0xab]
647 // CHECK: cmn x8, x9, lsl #15 // encoding: [0x1f,0x3d,0x09,0xab]
648 // CHECK: cmn x10, x11, lsl #63 // encoding: [0x5f,0xfd,0x0b,0xab]
651 cmn x14, x15, lsr #41
652 cmn x16, x17, lsr #63
653 // CHECK: cmn x12, x13, lsr #0 // encoding: [0x9f,0x01,0x4d,0xab]
654 // CHECK: cmn x14, x15, lsr #41 // encoding: [0xdf,0xa5,0x4f,0xab]
655 // CHECK: cmn x16, x17, lsr #63 // encoding: [0x1f,0xfe,0x51,0xab]
658 cmn x20, x21, asr #55
659 cmn x22, x23, asr #63
660 // CHECK: cmn x18, x19, asr #0 // encoding: [0x5f,0x02,0x93,0xab]
661 // CHECK: cmn x20, x21, asr #55 // encoding: [0x9f,0xde,0x95,0xab]
662 // CHECK: cmn x22, x23, asr #63 // encoding: [0xdf,0xfe,0x97,0xab]
667 // CHECK: cmp w0, w3 // encoding: [0x1f,0x00,0x03,0x6b]
668 // CHECK: cmp wzr, w4 // encoding: [0xff,0x03,0x04,0x6b]
669 // CHECK: cmp w5, wzr // encoding: [0xbf,0x00,0x1f,0x6b]
673 cmp w10, w11, lsl #31
674 // CHECK: cmp w6, w7 // encoding: [0xdf,0x00,0x07,0x6b]
675 // CHECK: cmp w8, w9, lsl #15 // encoding: [0x1f,0x3d,0x09,0x6b]
676 // CHECK: cmp w10, w11, lsl #31 // encoding: [0x5f,0x7d,0x0b,0x6b]
679 cmp w14, w15, lsr #21
680 cmp w16, w17, lsr #31
681 // CHECK: cmp w12, w13, lsr #0 // encoding: [0x9f,0x01,0x4d,0x6b]
682 // CHECK: cmp w14, w15, lsr #21 // encoding: [0xdf,0x55,0x4f,0x6b]
683 // CHECK: cmp w16, w17, lsr #31 // encoding: [0x1f,0x7e,0x51,0x6b]
686 cmp w20, w21, asr #22
687 cmp w22, w23, asr #31
688 // CHECK: cmp w18, w19, asr #0 // encoding: [0x5f,0x02,0x93,0x6b]
689 // CHECK: cmp w20, w21, asr #22 // encoding: [0x9f,0x5a,0x95,0x6b]
690 // CHECK: cmp w22, w23, asr #31 // encoding: [0xdf,0x7e,0x97,0x6b]
695 // CHECK: cmp x0, x3 // encoding: [0x1f,0x00,0x03,0xeb]
696 // CHECK: cmp xzr, x4 // encoding: [0xff,0x03,0x04,0xeb]
697 // CHECK: cmp x5, xzr // encoding: [0xbf,0x00,0x1f,0xeb]
701 cmp x10, x11, lsl #63
702 // CHECK: cmp x6, x7 // encoding: [0xdf,0x00,0x07,0xeb]
703 // CHECK: cmp x8, x9, lsl #15 // encoding: [0x1f,0x3d,0x09,0xeb]
704 // CHECK: cmp x10, x11, lsl #63 // encoding: [0x5f,0xfd,0x0b,0xeb]
707 cmp x14, x15, lsr #41
708 cmp x16, x17, lsr #63
709 // CHECK: cmp x12, x13, lsr #0 // encoding: [0x9f,0x01,0x4d,0xeb]
710 // CHECK: cmp x14, x15, lsr #41 // encoding: [0xdf,0xa5,0x4f,0xeb]
711 // CHECK: cmp x16, x17, lsr #63 // encoding: [0x1f,0xfe,0x51,0xeb]
714 cmp x20, x21, asr #55
715 cmp x22, x23, asr #63
716 // CHECK: cmp x18, x19, asr #0 // encoding: [0x5f,0x02,0x93,0xeb]
717 // CHECK: cmp x20, x21, asr #55 // encoding: [0x9f,0xde,0x95,0xeb]
718 // CHECK: cmp x22, x23, asr #63 // encoding: [0xdf,0xfe,0x97,0xeb]
723 // CHECK-AARCH64: sub w29, wzr, w30 // encoding: [0xfd,0x03,0x1e,0x4b]
724 // CHECK-AARCH64: sub w30, wzr, wzr // encoding: [0xfe,0x03,0x1f,0x4b]
725 // CHECK-AARCH64: sub wzr, wzr, w0 // encoding: [0xff,0x03,0x00,0x4b]
726 // CHECK-ARM64: neg w29, w30 // encoding: [0xfd,0x03,0x1e,0x4b]
727 // CHECK-ARM64: neg w30, wzr // encoding: [0xfe,0x03,0x1f,0x4b]
728 // CHECK-ARM64: neg wzr, w0 // encoding: [0xff,0x03,0x00,0x4b]
731 neg w26, w25, lsl #29
732 neg w24, w23, lsl #31
733 // CHECK-AARCH64: sub w28, wzr, w27 // encoding: [0xfc,0x03,0x1b,0x4b]
734 // CHECK-AARCH64: neg w26, w25, lsl #29 // encoding: [0xfa,0x77,0x19,0x4b]
735 // CHECK-AARCH64: neg w24, w23, lsl #31 // encoding: [0xf8,0x7f,0x17,0x4b]
737 // CHECK-ARM64: neg w28, w27 // encoding: [0xfc,0x03,0x1b,0x4b]
738 // CHECK-ARM64: sub w26, wzr, w25, lsl #29 // encoding: [0xfa,0x77,0x19,0x4b]
739 // CHECK-ARM64: sub w24, wzr, w23, lsl #31 // encoding: [0xf8,0x7f,0x17,0x4b]
743 neg w18, w17, lsr #31
744 // CHECK-AARCH64: neg w22, w21, lsr #0 // encoding: [0xf6,0x03,0x55,0x4b]
745 // CHECK-AARCH64: neg w20, w19, lsr #1 // encoding: [0xf4,0x07,0x53,0x4b]
746 // CHECK-AARCH64: neg w18, w17, lsr #31 // encoding: [0xf2,0x7f,0x51,0x4b]
748 // CHECK-ARM64: sub w22, wzr, w21, lsr #0 // encoding: [0xf6,0x03,0x55,0x4b]
749 // CHECK-ARM64: sub w20, wzr, w19, lsr #1 // encoding: [0xf4,0x07,0x53,0x4b]
750 // CHECK-ARM64: sub w18, wzr, w17, lsr #31 // encoding: [0xf2,0x7f,0x51,0x4b]
753 neg w14, w13, asr #12
754 neg w12, w11, asr #31
755 // CHECK-AARCH64: neg w16, w15, asr #0 // encoding: [0xf0,0x03,0x8f,0x4b]
756 // CHECK-AARCH64: neg w14, w13, asr #12 // encoding: [0xee,0x33,0x8d,0x4b]
757 // CHECK-AARCH64: neg w12, w11, asr #31 // encoding: [0xec,0x7f,0x8b,0x4b]
759 // CHECK-ARM64: sub w16, wzr, w15, asr #0 // encoding: [0xf0,0x03,0x8f,0x4b]
760 // CHECK-ARM64: sub w14, wzr, w13, asr #12 // encoding: [0xee,0x33,0x8d,0x4b]
761 // CHECK-ARM64: sub w12, wzr, w11, asr #31 // encoding: [0xec,0x7f,0x8b,0x4b]
766 // CHECK-AARCH64: sub x29, xzr, x30 // encoding: [0xfd,0x03,0x1e,0xcb]
767 // CHECK-AARCH64: sub x30, xzr, xzr // encoding: [0xfe,0x03,0x1f,0xcb]
768 // CHECK-AARCH64: sub xzr, xzr, x0 // encoding: [0xff,0x03,0x00,0xcb]
769 // CHECK-ARM64: neg x29, x30 // encoding: [0xfd,0x03,0x1e,0xcb]
770 // CHECK-ARM64: neg x30, xzr // encoding: [0xfe,0x03,0x1f,0xcb]
771 // CHECK-ARM64: neg xzr, x0 // encoding: [0xff,0x03,0x00,0xcb]
774 neg x26, x25, lsl #29
775 neg x24, x23, lsl #31
776 // CHECK-AARCH64: sub x28, xzr, x27 // encoding: [0xfc,0x03,0x1b,0xcb]
777 // CHECK-AARCH64: neg x26, x25, lsl #29 // encoding: [0xfa,0x77,0x19,0xcb]
778 // CHECK-AARCH64: neg x24, x23, lsl #31 // encoding: [0xf8,0x7f,0x17,0xcb]
780 // CHECK-ARM64: neg x28, x27 // encoding: [0xfc,0x03,0x1b,0xcb]
781 // CHECK-ARM64: sub x26, xzr, x25, lsl #29 // encoding: [0xfa,0x77,0x19,0xcb]
782 // CHECK-ARM64: sub x24, xzr, x23, lsl #31 // encoding: [0xf8,0x7f,0x17,0xcb]
786 neg x18, x17, lsr #31
787 // CHECK-AARCH64: neg x22, x21, lsr #0 // encoding: [0xf6,0x03,0x55,0xcb]
788 // CHECK-AARCH64: neg x20, x19, lsr #1 // encoding: [0xf4,0x07,0x53,0xcb]
789 // CHECK-AARCH64: neg x18, x17, lsr #31 // encoding: [0xf2,0x7f,0x51,0xcb]
791 // CHECK-ARM64: sub x22, xzr, x21, lsr #0 // encoding: [0xf6,0x03,0x55,0xcb]
792 // CHECK-ARM64: sub x20, xzr, x19, lsr #1 // encoding: [0xf4,0x07,0x53,0xcb]
793 // CHECK-ARM64: sub x18, xzr, x17, lsr #31 // encoding: [0xf2,0x7f,0x51,0xcb]
796 neg x14, x13, asr #12
797 neg x12, x11, asr #31
798 // CHECK-AARCH64: neg x16, x15, asr #0 // encoding: [0xf0,0x03,0x8f,0xcb]
799 // CHECK-AARCH64: neg x14, x13, asr #12 // encoding: [0xee,0x33,0x8d,0xcb]
800 // CHECK-AARCH64: neg x12, x11, asr #31 // encoding: [0xec,0x7f,0x8b,0xcb]
802 // CHECK-ARM64: sub x16, xzr, x15, asr #0 // encoding: [0xf0,0x03,0x8f,0xcb]
803 // CHECK-ARM64: sub x14, xzr, x13, asr #12 // encoding: [0xee,0x33,0x8d,0xcb]
804 // CHECK-ARM64: sub x12, xzr, x11, asr #31 // encoding: [0xec,0x7f,0x8b,0xcb]
809 // CHECK-AARCH64: subs w29, wzr, w30 // encoding: [0xfd,0x03,0x1e,0x6b]
810 // CHECK-AARCH64: subs w30, wzr, wzr // encoding: [0xfe,0x03,0x1f,0x6b]
811 // CHECK-AARCH64: subs wzr, wzr, w0 // encoding: [0xff,0x03,0x00,0x6b]
812 // CHECK-ARM64: negs w29, w30 // encoding: [0xfd,0x03,0x1e,0x6b]
813 // CHECK-ARM64: negs w30, wzr // encoding: [0xfe,0x03,0x1f,0x6b]
814 // CHECK-ARM64: cmp wzr, w0 // encoding: [0xff,0x03,0x00,0x6b]
816 negs w28, w27, lsl #0
817 negs w26, w25, lsl #29
818 negs w24, w23, lsl #31
819 // CHECK-AARCH64: subs w28, wzr, w27 // encoding: [0xfc,0x03,0x1b,0x6b]
820 // CHECK-AARCH64: negs w26, w25, lsl #29 // encoding: [0xfa,0x77,0x19,0x6b]
821 // CHECK-AARCH64: negs w24, w23, lsl #31 // encoding: [0xf8,0x7f,0x17,0x6b]
823 // CHECK-ARM64: negs w28, w27 // encoding: [0xfc,0x03,0x1b,0x6b]
824 // CHECK-ARM64: subs w26, wzr, w25, lsl #29 // encoding: [0xfa,0x77,0x19,0x6b]
825 // CHECK-ARM64: subs w24, wzr, w23, lsl #31 // encoding: [0xf8,0x7f,0x17,0x6b]
827 negs w22, w21, lsr #0
828 negs w20, w19, lsr #1
829 negs w18, w17, lsr #31
830 // CHECK-AARCH64: negs w22, w21, lsr #0 // encoding: [0xf6,0x03,0x55,0x6b]
831 // CHECK-AARCH64: negs w20, w19, lsr #1 // encoding: [0xf4,0x07,0x53,0x6b]
832 // CHECK-AARCH64: negs w18, w17, lsr #31 // encoding: [0xf2,0x7f,0x51,0x6b]
834 // CHECK-ARM64: subs w22, wzr, w21, lsr #0 // encoding: [0xf6,0x03,0x55,0x6b]
835 // CHECK-ARM64: subs w20, wzr, w19, lsr #1 // encoding: [0xf4,0x07,0x53,0x6b]
836 // CHECK-ARM64: subs w18, wzr, w17, lsr #31 // encoding: [0xf2,0x7f,0x51,0x6b]
838 negs w16, w15, asr #0
839 negs w14, w13, asr #12
840 negs w12, w11, asr #31
841 // CHECK-AARCH64: negs w16, w15, asr #0 // encoding: [0xf0,0x03,0x8f,0x6b]
842 // CHECK-AARCH64: negs w14, w13, asr #12 // encoding: [0xee,0x33,0x8d,0x6b]
843 // CHECK-AARCH64: negs w12, w11, asr #31 // encoding: [0xec,0x7f,0x8b,0x6b]
845 // CHECK-ARM64: subs w16, wzr, w15, asr #0 // encoding: [0xf0,0x03,0x8f,0x6b]
846 // CHECK-ARM64: subs w14, wzr, w13, asr #12 // encoding: [0xee,0x33,0x8d,0x6b]
847 // CHECK-ARM64: subs w12, wzr, w11, asr #31 // encoding: [0xec,0x7f,0x8b,0x6b]
852 // CHECK-AARCH64: subs x29, xzr, x30 // encoding: [0xfd,0x03,0x1e,0xeb]
853 // CHECK-AARCH64: subs x30, xzr, xzr // encoding: [0xfe,0x03,0x1f,0xeb]
854 // CHECK-AARCH64: subs xzr, xzr, x0 // encoding: [0xff,0x03,0x00,0xeb]
855 // CHECK-ARM64: negs x29, x30 // encoding: [0xfd,0x03,0x1e,0xeb]
856 // CHECK-ARM64: negs x30, xzr // encoding: [0xfe,0x03,0x1f,0xeb]
857 // CHECK-ARM64: cmp xzr, x0 // encoding: [0xff,0x03,0x00,0xeb]
859 negs x28, x27, lsl #0
860 negs x26, x25, lsl #29
861 negs x24, x23, lsl #31
862 // CHECK-AARCH64: subs x28, xzr, x27 // encoding: [0xfc,0x03,0x1b,0xeb]
863 // CHECK-AARCH64: negs x26, x25, lsl #29 // encoding: [0xfa,0x77,0x19,0xeb]
864 // CHECK-AARCH64: negs x24, x23, lsl #31 // encoding: [0xf8,0x7f,0x17,0xeb]
866 // CHECK-ARM64: negs x28, x27 // encoding: [0xfc,0x03,0x1b,0xeb]
867 // CHECK-ARM64: subs x26, xzr, x25, lsl #29 // encoding: [0xfa,0x77,0x19,0xeb]
868 // CHECK-ARM64: subs x24, xzr, x23, lsl #31 // encoding: [0xf8,0x7f,0x17,0xeb]
870 negs x22, x21, lsr #0
871 negs x20, x19, lsr #1
872 negs x18, x17, lsr #31
873 // CHECK-AARCH64: negs x22, x21, lsr #0 // encoding: [0xf6,0x03,0x55,0xeb]
874 // CHECK-AARCH64: negs x20, x19, lsr #1 // encoding: [0xf4,0x07,0x53,0xeb]
875 // CHECK-AARCH64: negs x18, x17, lsr #31 // encoding: [0xf2,0x7f,0x51,0xeb]
877 // CHECK-ARM64: subs x22, xzr, x21, lsr #0 // encoding: [0xf6,0x03,0x55,0xeb]
878 // CHECK-ARM64: subs x20, xzr, x19, lsr #1 // encoding: [0xf4,0x07,0x53,0xeb]
879 // CHECK-ARM64: subs x18, xzr, x17, lsr #31 // encoding: [0xf2,0x7f,0x51,0xeb]
881 negs x16, x15, asr #0
882 negs x14, x13, asr #12
883 negs x12, x11, asr #31
884 // CHECK-AARCH64: negs x16, x15, asr #0 // encoding: [0xf0,0x03,0x8f,0xeb]
885 // CHECK-AARCH64: negs x14, x13, asr #12 // encoding: [0xee,0x33,0x8d,0xeb]
886 // CHECK-AARCH64: negs x12, x11, asr #31 // encoding: [0xec,0x7f,0x8b,0xeb]
888 // CHECK-ARM64: subs x16, xzr, x15, asr #0 // encoding: [0xf0,0x03,0x8f,0xeb]
889 // CHECK-ARM64: subs x14, xzr, x13, asr #12 // encoding: [0xee,0x33,0x8d,0xeb]
890 // CHECK-ARM64: subs x12, xzr, x11, asr #31 // encoding: [0xec,0x7f,0x8b,0xeb]
892 //------------------------------------------------------------------------------
893 // Add-sub (shifted register)
894 //------------------------------------------------------------------------------
899 // CHECK: adc w29, w27, w25 // encoding: [0x7d,0x03,0x19,0x1a]
900 // CHECK: adc wzr, w3, w4 // encoding: [0x7f,0x00,0x04,0x1a]
901 // CHECK: adc w9, wzr, w10 // encoding: [0xe9,0x03,0x0a,0x1a]
902 // CHECK: adc w20, w0, wzr // encoding: [0x14,0x00,0x1f,0x1a]
908 // CHECK: adc x29, x27, x25 // encoding: [0x7d,0x03,0x19,0x9a]
909 // CHECK: adc xzr, x3, x4 // encoding: [0x7f,0x00,0x04,0x9a]
910 // CHECK: adc x9, xzr, x10 // encoding: [0xe9,0x03,0x0a,0x9a]
911 // CHECK: adc x20, x0, xzr // encoding: [0x14,0x00,0x1f,0x9a]
917 // CHECK: adcs w29, w27, w25 // encoding: [0x7d,0x03,0x19,0x3a]
918 // CHECK: adcs wzr, w3, w4 // encoding: [0x7f,0x00,0x04,0x3a]
919 // CHECK: adcs w9, wzr, w10 // encoding: [0xe9,0x03,0x0a,0x3a]
920 // CHECK: adcs w20, w0, wzr // encoding: [0x14,0x00,0x1f,0x3a]
926 // CHECK: adcs x29, x27, x25 // encoding: [0x7d,0x03,0x19,0xba]
927 // CHECK: adcs xzr, x3, x4 // encoding: [0x7f,0x00,0x04,0xba]
928 // CHECK: adcs x9, xzr, x10 // encoding: [0xe9,0x03,0x0a,0xba]
929 // CHECK: adcs x20, x0, xzr // encoding: [0x14,0x00,0x1f,0xba]
935 // CHECK: sbc w29, w27, w25 // encoding: [0x7d,0x03,0x19,0x5a]
936 // CHECK: sbc wzr, w3, w4 // encoding: [0x7f,0x00,0x04,0x5a]
937 // CHECK: ngc w9, w10 // encoding: [0xe9,0x03,0x0a,0x5a]
938 // CHECK: sbc w20, w0, wzr // encoding: [0x14,0x00,0x1f,0x5a]
944 // CHECK: sbc x29, x27, x25 // encoding: [0x7d,0x03,0x19,0xda]
945 // CHECK: sbc xzr, x3, x4 // encoding: [0x7f,0x00,0x04,0xda]
946 // CHECK: ngc x9, x10 // encoding: [0xe9,0x03,0x0a,0xda]
947 // CHECK: sbc x20, x0, xzr // encoding: [0x14,0x00,0x1f,0xda]
953 // CHECK: sbcs w29, w27, w25 // encoding: [0x7d,0x03,0x19,0x7a]
954 // CHECK: sbcs wzr, w3, w4 // encoding: [0x7f,0x00,0x04,0x7a]
955 // CHECK: ngcs w9, w10 // encoding: [0xe9,0x03,0x0a,0x7a]
956 // CHECK: sbcs w20, w0, wzr // encoding: [0x14,0x00,0x1f,0x7a]
962 // CHECK: sbcs x29, x27, x25 // encoding: [0x7d,0x03,0x19,0xfa]
963 // CHECK: sbcs xzr, x3, x4 // encoding: [0x7f,0x00,0x04,0xfa]
964 // CHECK: ngcs x9, x10 // encoding: [0xe9,0x03,0x0a,0xfa]
965 // CHECK: sbcs x20, x0, xzr // encoding: [0x14,0x00,0x1f,0xfa]
970 // CHECK: ngc w3, w12 // encoding: [0xe3,0x03,0x0c,0x5a]
971 // CHECK: ngc wzr, w9 // encoding: [0xff,0x03,0x09,0x5a]
972 // CHECK: ngc w23, wzr // encoding: [0xf7,0x03,0x1f,0x5a]
977 // CHECK: ngc x29, x30 // encoding: [0xfd,0x03,0x1e,0xda]
978 // CHECK: ngc xzr, x0 // encoding: [0xff,0x03,0x00,0xda]
979 // CHECK: ngc x0, xzr // encoding: [0xe0,0x03,0x1f,0xda]
984 // CHECK: ngcs w3, w12 // encoding: [0xe3,0x03,0x0c,0x7a]
985 // CHECK: ngcs wzr, w9 // encoding: [0xff,0x03,0x09,0x7a]
986 // CHECK: ngcs w23, wzr // encoding: [0xf7,0x03,0x1f,0x7a]
991 // CHECK: ngcs x29, x30 // encoding: [0xfd,0x03,0x1e,0xfa]
992 // CHECK: ngcs xzr, x0 // encoding: [0xff,0x03,0x00,0xfa]
993 // CHECK: ngcs x0, xzr // encoding: [0xe0,0x03,0x1f,0xfa]
995 //------------------------------------------------------------------------------
997 //------------------------------------------------------------------------------
1000 sbfm x3, x4, #63, #63
1001 sbfm wzr, wzr, #31, #31
1002 sbfm w12, w9, #0, #0
1003 // CHECK-AARCH64: sbfm x1, x2, #3, #4 // encoding: [0x41,0x10,0x43,0x93]
1004 // CHECK-AARCH64: sbfm x3, x4, #63, #63 // encoding: [0x83,0xfc,0x7f,0x93]
1005 // CHECK-AARCH64: sbfm wzr, wzr, #31, #31 // encoding: [0xff,0x7f,0x1f,0x13]
1006 // CHECK-AARCH64: sbfm w12, w9, #0, #0 // encoding: [0x2c,0x01,0x00,0x13]
1008 // CHECK-ARM64: sbfx x1, x2, #3, #2 // encoding: [0x41,0x10,0x43,0x93]
1009 // CHECK-ARM64: asr x3, x4, #63 // encoding: [0x83,0xfc,0x7f,0x93]
1010 // CHECK-ARM64: asr wzr, wzr, #31 // encoding: [0xff,0x7f,0x1f,0x13]
1011 // CHECK-ARM64: sbfx w12, w9, #0, #1 // encoding: [0x2c,0x01,0x00,0x13]
1013 ubfm x4, x5, #12, #10
1014 ubfm xzr, x4, #0, #0
1015 ubfm x4, xzr, #63, #5
1016 ubfm x5, x6, #12, #63
1017 // CHECK-AARCH64: ubfm x4, x5, #12, #10 // encoding: [0xa4,0x28,0x4c,0xd3]
1018 // CHECK-AARCH64: ubfm xzr, x4, #0, #0 // encoding: [0x9f,0x00,0x40,0xd3]
1019 // CHECK-AARCH64: ubfm x4, xzr, #63, #5 // encoding: [0xe4,0x17,0x7f,0xd3]
1020 // CHECK-AARCH64: ubfm x5, x6, #12, #63 // encoding: [0xc5,0xfc,0x4c,0xd3]
1021 // CHECK-ARM64: ubfiz x4, x5, #52, #11 // encoding: [0xa4,0x28,0x4c,0xd3]
1022 // CHECK-ARM64: ubfx xzr, x4, #0, #1 // encoding: [0x9f,0x00,0x40,0xd3]
1023 // CHECK-ARM64: ubfiz x4, xzr, #1, #6 // encoding: [0xe4,0x17,0x7f,0xd3]
1024 // CHECK-ARM64: lsr x5, x6, #12 // encoding: [0xc5,0xfc,0x4c,0xd3]
1026 bfm x4, x5, #12, #10
1028 bfm x4, xzr, #63, #5
1029 bfm x5, x6, #12, #63
1030 // CHECK-AARCH64: bfm x4, x5, #12, #10 // encoding: [0xa4,0x28,0x4c,0xb3]
1031 // CHECK-AARCH64: bfm xzr, x4, #0, #0 // encoding: [0x9f,0x00,0x40,0xb3]
1032 // CHECK-AARCH64: bfm x4, xzr, #63, #5 // encoding: [0xe4,0x17,0x7f,0xb3]
1033 // CHECK-AARCH64: bfm x5, x6, #12, #63 // encoding: [0xc5,0xfc,0x4c,0xb3]
1034 // CHECK-ARM64: bfi x4, x5, #52, #11 // encoding: [0xa4,0x28,0x4c,0xb3]
1035 // CHECK-ARM64: bfxil xzr, x4, #0, #1 // encoding: [0x9f,0x00,0x40,0xb3]
1036 // CHECK-ARM64: bfi x4, xzr, #1, #6 // encoding: [0xe4,0x17,0x7f,0xb3]
1037 // CHECK-ARM64: bfxil x5, x6, #12, #52 // encoding: [0xc5,0xfc,0x4c,0xb3]
1044 // CHECK: sxtb w1, w2 // encoding: [0x41,0x1c,0x00,0x13]
1045 // CHECK: sxtb xzr, w3 // encoding: [0x7f,0x1c,0x40,0x93]
1046 // CHECK: sxth w9, w10 // encoding: [0x49,0x3d,0x00,0x13]
1047 // CHECK: sxth x0, w1 // encoding: [0x20,0x3c,0x40,0x93]
1048 // CHECK: sxtw x3, w30 // encoding: [0xc3,0x7f,0x40,0x93]
1054 // CHECK: uxtb w1, w2 // encoding: [0x41,0x1c,0x00,0x53]
1055 // CHECK: uxtb {{[wx]}}zr, w3 // encoding: [0x7f,0x1c,0x00,0x53]
1056 // CHECK: uxth w9, w10 // encoding: [0x49,0x3d,0x00,0x53]
1057 // CHECK: uxth {{[wx]}}0, w1 // encoding: [0x20,0x3c,0x00,0x53]
1063 // CHECK: asr w3, w2, #0 // encoding: [0x43,0x7c,0x00,0x13]
1064 // CHECK: asr w9, w10, #31 // encoding: [0x49,0x7d,0x1f,0x13]
1065 // CHECK: asr x20, x21, #63 // encoding: [0xb4,0xfe,0x7f,0x93]
1066 // CHECK: asr w1, wzr, #3 // encoding: [0xe1,0x7f,0x03,0x13]
1072 // CHECK: lsr w3, w2, #0 // encoding: [0x43,0x7c,0x00,0x53]
1073 // CHECK: lsr w9, w10, #31 // encoding: [0x49,0x7d,0x1f,0x53]
1074 // CHECK: lsr x20, x21, #63 // encoding: [0xb4,0xfe,0x7f,0xd3]
1075 // CHECK: lsr wzr, wzr, #3 // encoding: [0xff,0x7f,0x03,0x53]
1081 // CHECK: {{lsl|lsr}} w3, w2, #0 // encoding: [0x43,0x7c,0x00,0x53]
1082 // CHECK: lsl w9, w10, #31 // encoding: [0x49,0x01,0x01,0x53]
1083 // CHECK: lsl x20, x21, #63 // encoding: [0xb4,0x02,0x41,0xd3]
1084 // CHECK: lsl w1, wzr, #3 // encoding: [0xe1,0x73,0x1d,0x53]
1086 sbfiz w9, w10, #0, #1
1087 sbfiz x2, x3, #63, #1
1088 sbfiz x19, x20, #0, #64
1089 sbfiz x9, x10, #5, #59
1090 sbfiz w9, w10, #0, #32
1091 sbfiz w11, w12, #31, #1
1092 sbfiz w13, w14, #29, #3
1093 sbfiz xzr, xzr, #10, #11
1094 // CHECK: {{sbfiz|sbfx}} w9, w10, #0, #1 // encoding: [0x49,0x01,0x00,0x13]
1095 // CHECK: sbfiz x2, x3, #63, #1 // encoding: [0x62,0x00,0x41,0x93]
1096 // CHECK-AARCH64: sbfiz x19, x20, #0, #64 // encoding: [0x93,0xfe,0x40,0x93]
1097 // CHECK-ARM64: asr x19, x20, #0 // encoding: [0x93,0xfe,0x40,0x93]
1098 // CHECK: sbfiz x9, x10, #5, #59 // encoding: [0x49,0xe9,0x7b,0x93]
1099 // CHECK-AARCH64: sbfiz w9, w10, #0, #32 // encoding: [0x49,0x7d,0x00,0x13]
1100 // CHECK-ARM64: asr w9, w10, #0 // encoding: [0x49,0x7d,0x00,0x13]
1101 // CHECK: sbfiz w11, w12, #31, #1 // encoding: [0x8b,0x01,0x01,0x13]
1102 // CHECK: sbfiz w13, w14, #29, #3 // encoding: [0xcd,0x09,0x03,0x13]
1103 // CHECK: sbfiz xzr, xzr, #10, #11 // encoding: [0xff,0x2b,0x76,0x93]
1105 sbfx w9, w10, #0, #1
1106 sbfx x2, x3, #63, #1
1107 sbfx x19, x20, #0, #64
1108 sbfx x9, x10, #5, #59
1109 sbfx w9, w10, #0, #32
1110 sbfx w11, w12, #31, #1
1111 sbfx w13, w14, #29, #3
1112 sbfx xzr, xzr, #10, #11
1113 // CHECK: sbfx w9, w10, #0, #1 // encoding: [0x49,0x01,0x00,0x13]
1114 // CHECK-AARCH64: sbfx x2, x3, #63, #1 // encoding: [0x62,0xfc,0x7f,0x93]
1115 // CHECK-ARM64: asr x2, x3, #63 // encoding: [0x62,0xfc,0x7f,0x93]
1116 // CHECK-AARCH64: sbfx x19, x20, #0, #64 // encoding: [0x93,0xfe,0x40,0x93]
1117 // CHECK-ARM64: asr x19, x20, #0 // encoding: [0x93,0xfe,0x40,0x93]
1118 // CHECK-AARCH64: sbfx x9, x10, #5, #59 // encoding: [0x49,0xfd,0x45,0x93]
1119 // CHECK-ARM64: asr x9, x10, #5 // encoding: [0x49,0xfd,0x45,0x93]
1120 // CHECK-AARCH64: sbfx w9, w10, #0, #32 // encoding: [0x49,0x7d,0x00,0x13]
1121 // CHECK-ARM64: asr w9, w10, #0 // encoding: [0x49,0x7d,0x00,0x13]
1122 // CHECK-AARCH64: sbfx w11, w12, #31, #1 // encoding: [0x8b,0x7d,0x1f,0x13]
1123 // CHECK-ARM64: asr w11, w12, #31 // encoding: [0x8b,0x7d,0x1f,0x13]
1124 // CHECK-AARCH64: sbfx w13, w14, #29, #3 // encoding: [0xcd,0x7d,0x1d,0x13]
1125 // CHECK-ARM64: asr w13, w14, #29 // encoding: [0xcd,0x7d,0x1d,0x13]
1126 // CHECK: sbfx xzr, xzr, #10, #11 // encoding: [0xff,0x53,0x4a,0x93]
1130 bfi x19, x20, #0, #64
1131 bfi x9, x10, #5, #59
1132 bfi w9, w10, #0, #32
1133 bfi w11, w12, #31, #1
1134 bfi w13, w14, #29, #3
1135 bfi xzr, xzr, #10, #11
1136 // CHECK-AARCH64: bfi w9, w10, #0, #1 // encoding: [0x49,0x01,0x00,0x33]
1137 // CHECK-AARCH64: bfi x2, x3, #63, #1 // encoding: [0x62,0x00,0x41,0xb3]
1138 // CHECK-AARCH64: bfi x19, x20, #0, #64 // encoding: [0x93,0xfe,0x40,0xb3]
1139 // CHECK-AARCH64: bfi x9, x10, #5, #59 // encoding: [0x49,0xe9,0x7b,0xb3]
1140 // CHECK-AARCH64: bfi w9, w10, #0, #32 // encoding: [0x49,0x7d,0x00,0x33]
1141 // CHECK-AARCH64: bfi w11, w12, #31, #1 // encoding: [0x8b,0x01,0x01,0x33]
1142 // CHECK-AARCH64: bfi w13, w14, #29, #3 // encoding: [0xcd,0x09,0x03,0x33]
1143 // CHECK-AARCH64: bfi xzr, xzr, #10, #11 // encoding: [0xff,0x2b,0x76,0xb3]
1145 // CHECK-ARM64: bfxil w9, w10, #0, #1 // encoding: [0x49,0x01,0x00,0x33]
1146 // CHECK-ARM64: bfi x2, x3, #63, #1 // encoding: [0x62,0x00,0x41,0xb3]
1147 // CHECK-ARM64: bfxil x19, x20, #0, #64 // encoding: [0x93,0xfe,0x40,0xb3]
1148 // CHECK-ARM64: bfi x9, x10, #5, #59 // encoding: [0x49,0xe9,0x7b,0xb3]
1149 // CHECK-ARM64: bfxil w9, w10, #0, #32 // encoding: [0x49,0x7d,0x00,0x33]
1150 // CHECK-ARM64: bfi w11, w12, #31, #1 // encoding: [0x8b,0x01,0x01,0x33]
1151 // CHECK-ARM64: bfi w13, w14, #29, #3 // encoding: [0xcd,0x09,0x03,0x33]
1152 // CHECK-ARM64: bfi xzr, xzr, #10, #11 // encoding: [0xff,0x2b,0x76,0xb3]
1154 bfxil w9, w10, #0, #1
1155 bfxil x2, x3, #63, #1
1156 bfxil x19, x20, #0, #64
1157 bfxil x9, x10, #5, #59
1158 bfxil w9, w10, #0, #32
1159 bfxil w11, w12, #31, #1
1160 bfxil w13, w14, #29, #3
1161 bfxil xzr, xzr, #10, #11
1162 // CHECK: bfxil w9, w10, #0, #1 // encoding: [0x49,0x01,0x00,0x33]
1163 // CHECK: bfxil x2, x3, #63, #1 // encoding: [0x62,0xfc,0x7f,0xb3]
1164 // CHECK: bfxil x19, x20, #0, #64 // encoding: [0x93,0xfe,0x40,0xb3]
1165 // CHECK: bfxil x9, x10, #5, #59 // encoding: [0x49,0xfd,0x45,0xb3]
1166 // CHECK: bfxil w9, w10, #0, #32 // encoding: [0x49,0x7d,0x00,0x33]
1167 // CHECK: bfxil w11, w12, #31, #1 // encoding: [0x8b,0x7d,0x1f,0x33]
1168 // CHECK: bfxil w13, w14, #29, #3 // encoding: [0xcd,0x7d,0x1d,0x33]
1169 // CHECK: bfxil xzr, xzr, #10, #11 // encoding: [0xff,0x53,0x4a,0xb3]
1171 ubfiz w9, w10, #0, #1
1172 ubfiz x2, x3, #63, #1
1173 ubfiz x19, x20, #0, #64
1174 ubfiz x9, x10, #5, #59
1175 ubfiz w9, w10, #0, #32
1176 ubfiz w11, w12, #31, #1
1177 ubfiz w13, w14, #29, #3
1178 ubfiz xzr, xzr, #10, #11
1179 // CHECK-AARCH64: ubfiz w9, w10, #0, #1 // encoding: [0x49,0x01,0x00,0x53]
1180 // CHECK-AARCH64: ubfiz x2, x3, #63, #1 // encoding: [0x62,0x00,0x41,0xd3]
1181 // CHECK-AARCH64: ubfiz x19, x20, #0, #64 // encoding: [0x93,0xfe,0x40,0xd3]
1182 // CHECK-AARCH64: ubfiz x9, x10, #5, #59 // encoding: [0x49,0xe9,0x7b,0xd3]
1183 // CHECK-AARCH64: ubfiz w9, w10, #0, #32 // encoding: [0x49,0x7d,0x00,0x53]
1184 // CHECK-AARCH64: ubfiz w11, w12, #31, #1 // encoding: [0x8b,0x01,0x01,0x53]
1185 // CHECK-AARCH64: ubfiz w13, w14, #29, #3 // encoding: [0xcd,0x09,0x03,0x53]
1186 // CHECK-AARCH64: ubfiz xzr, xzr, #10, #11 // encoding: [0xff,0x2b,0x76,0xd3]
1188 // CHECK-ARM64: ubfx w9, w10, #0, #1 // encoding: [0x49,0x01,0x00,0x53]
1189 // CHECK-ARM64: lsl x2, x3, #63 // encoding: [0x62,0x00,0x41,0xd3]
1190 // CHECK-ARM64: lsr x19, x20, #0 // encoding: [0x93,0xfe,0x40,0xd3]
1191 // CHECK-ARM64: lsl x9, x10, #5 // encoding: [0x49,0xe9,0x7b,0xd3]
1192 // CHECK-ARM64: lsr w9, w10, #0 // encoding: [0x49,0x7d,0x00,0x53]
1193 // CHECK-ARM64: lsl w11, w12, #31 // encoding: [0x8b,0x01,0x01,0x53]
1194 // CHECK-ARM64: lsl w13, w14, #29 // encoding: [0xcd,0x09,0x03,0x53]
1195 // CHECK-ARM64: ubfiz xzr, xzr, #10, #11 // encoding: [0xff,0x2b,0x76,0xd3]
1197 ubfx w9, w10, #0, #1
1198 ubfx x2, x3, #63, #1
1199 ubfx x19, x20, #0, #64
1200 ubfx x9, x10, #5, #59
1201 ubfx w9, w10, #0, #32
1202 ubfx w11, w12, #31, #1
1203 ubfx w13, w14, #29, #3
1204 ubfx xzr, xzr, #10, #11
1205 // CHECK-AARCH64: ubfx w9, w10, #0, #1 // encoding: [0x49,0x01,0x00,0x53]
1206 // CHECK-AARCH64: ubfx x2, x3, #63, #1 // encoding: [0x62,0xfc,0x7f,0xd3]
1207 // CHECK-AARCH64: ubfx x19, x20, #0, #64 // encoding: [0x93,0xfe,0x40,0xd3]
1208 // CHECK-AARCH64: ubfx x9, x10, #5, #59 // encoding: [0x49,0xfd,0x45,0xd3]
1209 // CHECK-AARCH64: ubfx w9, w10, #0, #32 // encoding: [0x49,0x7d,0x00,0x53]
1210 // CHECK-AARCH64: ubfx w11, w12, #31, #1 // encoding: [0x8b,0x7d,0x1f,0x53]
1211 // CHECK-AARCH64: ubfx w13, w14, #29, #3 // encoding: [0xcd,0x7d,0x1d,0x53]
1212 // CHECK-AARCH64: ubfx xzr, xzr, #10, #11 // encoding: [0xff,0x53,0x4a,0xd3]
1214 // CHECK-ARM64: ubfx w9, w10, #0, #1 // encoding: [0x49,0x01,0x00,0x53]
1215 // CHECK-ARM64: lsr x2, x3, #63 // encoding: [0x62,0xfc,0x7f,0xd3]
1216 // CHECK-ARM64: lsr x19, x20, #0 // encoding: [0x93,0xfe,0x40,0xd3]
1217 // CHECK-ARM64: lsr x9, x10, #5 // encoding: [0x49,0xfd,0x45,0xd3]
1218 // CHECK-ARM64: lsr w9, w10, #0 // encoding: [0x49,0x7d,0x00,0x53]
1219 // CHECK-ARM64: lsr w11, w12, #31 // encoding: [0x8b,0x7d,0x1f,0x53]
1220 // CHECK-ARM64: lsr w13, w14, #29 // encoding: [0xcd,0x7d,0x1d,0x53]
1221 // CHECK-ARM64: ubfx xzr, xzr, #10, #11 // encoding: [0xff,0x53,0x4a,0xd3]
1222 //------------------------------------------------------------------------------
1223 // Compare & branch (immediate)
1224 //------------------------------------------------------------------------------
1230 // CHECK-AARCH64: cbz w5, lbl // encoding: [0x05'A',A,A,0x34'A']
1231 // CHECK-AARCH64: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1232 // CHECK-AARCH64: cbz x5, lbl // encoding: [0x05'A',A,A,0xb4'A']
1233 // CHECK-AARCH64: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1234 // CHECK-AARCH64: cbnz x2, lbl // encoding: [0x02'A',A,A,0xb5'A']
1235 // CHECK-AARCH64: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1236 // CHECK-AARCH64: cbnz x26, lbl // encoding: [0x1a'A',A,A,0xb5'A']
1237 // CHECK-AARCH64: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1238 // CHECK-ARM64: cbz w5, lbl // encoding: [0bAAA00101,A,A,0x34]
1239 // CHECK-ARM64: // fixup A - offset: 0, value: lbl, kind: fixup_arm64_pcrel_branch19
1240 // CHECK-ARM64: cbz x5, lbl // encoding: [0bAAA00101,A,A,0xb4]
1241 // CHECK-ARM64: // fixup A - offset: 0, value: lbl, kind: fixup_arm64_pcrel_branch19
1242 // CHECK-ARM64: cbnz x2, lbl // encoding: [0bAAA00010,A,A,0xb5]
1243 // CHECK-ARM64: // fixup A - offset: 0, value: lbl, kind: fixup_arm64_pcrel_branch19
1244 // CHECK-ARM64: cbnz x26, lbl // encoding: [0bAAA11010,A,A,0xb5]
1245 // CHECK-ARM64: // fixup A - offset: 0, value: lbl, kind: fixup_arm64_pcrel_branch19
1249 // CHECK-AARCH64: cbz wzr, lbl // encoding: [0x1f'A',A,A,0x34'A']
1250 // CHECK-AARCH64: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1251 // CHECK-AARCH64: cbnz xzr, lbl // encoding: [0x1f'A',A,A,0xb5'A']
1252 // CHECK-AARCH64: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1254 // CHECK-ARM64: cbz wzr, lbl // encoding: [0bAAA11111,A,A,0x34]
1255 // CHECK-ARM64: // fixup A - offset: 0, value: lbl, kind: fixup_arm64_pcrel_branch19
1256 // CHECK-ARM64: cbnz xzr, lbl // encoding: [0bAAA11111,A,A,0xb5]
1257 // CHECK-ARM64: // fixup A - offset: 0, value: lbl, kind: fixup_arm64_pcrel_branch19
1263 // CHECK: cbz w5, #0 // encoding: [0x05,0x00,0x00,0x34]
1264 // CHECK: cbnz x3, #-4 // encoding: [0xe3,0xff,0xff,0xb5]
1265 // CHECK: cbz w20, #1048572 // encoding: [0xf4,0xff,0x7f,0x34]
1266 // CHECK: cbnz xzr, #-1048576 // encoding: [0x1f,0x00,0x80,0xb5]
1268 //------------------------------------------------------------------------------
1269 // Conditional branch (immediate)
1270 //------------------------------------------------------------------------------
1289 // CHECK-AARCH64: b.eq lbl // encoding: [A,A,A,0x54'A']
1290 // CHECK-AARCH64: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1291 // CHECK-AARCH64: b.ne lbl // encoding: [0x01'A',A,A,0x54'A']
1292 // CHECK-AARCH64: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1293 // CHECK-AARCH64: b.hs lbl // encoding: [0x02'A',A,A,0x54'A']
1294 // CHECK-AARCH64: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1295 // CHECK-AARCH64: b.hs lbl // encoding: [0x02'A',A,A,0x54'A']
1296 // CHECK-AARCH64: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1297 // CHECK-AARCH64: b.lo lbl // encoding: [0x03'A',A,A,0x54'A']
1298 // CHECK-AARCH64: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1299 // CHECK-AARCH64: b.lo lbl // encoding: [0x03'A',A,A,0x54'A']
1300 // CHECK-AARCH64: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1301 // CHECK-AARCH64: b.mi lbl // encoding: [0x04'A',A,A,0x54'A']
1302 // CHECK-AARCH64: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1303 // CHECK-AARCH64: b.pl lbl // encoding: [0x05'A',A,A,0x54'A']
1304 // CHECK-AARCH64: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1305 // CHECK-AARCH64: b.vs lbl // encoding: [0x06'A',A,A,0x54'A']
1306 // CHECK-AARCH64: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1307 // CHECK-AARCH64: b.vc lbl // encoding: [0x07'A',A,A,0x54'A']
1308 // CHECK-AARCH64: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1309 // CHECK-AARCH64: b.hi lbl // encoding: [0x08'A',A,A,0x54'A']
1310 // CHECK-AARCH64: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1311 // CHECK-AARCH64: b.ls lbl // encoding: [0x09'A',A,A,0x54'A']
1312 // CHECK-AARCH64: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1313 // CHECK-AARCH64: b.ge lbl // encoding: [0x0a'A',A,A,0x54'A']
1314 // CHECK-AARCH64: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1315 // CHECK-AARCH64: b.lt lbl // encoding: [0x0b'A',A,A,0x54'A']
1316 // CHECK-AARCH64: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1317 // CHECK-AARCH64: b.gt lbl // encoding: [0x0c'A',A,A,0x54'A']
1318 // CHECK-AARCH64: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1319 // CHECK-AARCH64: b.le lbl // encoding: [0x0d'A',A,A,0x54'A']
1320 // CHECK-AARCH64: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1321 // CHECK-AARCH64: b.al lbl // encoding: [0x0e'A',A,A,0x54'A']
1322 // CHECK-AARCH64: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1324 // CHECK-ARM64: b.eq lbl // encoding: [0bAAA00000,A,A,0x54]
1325 // CHECK-ARM64: // fixup A - offset: 0, value: lbl, kind: fixup_arm64_pcrel_branch19
1326 // CHECK-ARM64: b.ne lbl // encoding: [0bAAA00001,A,A,0x54]
1327 // CHECK-ARM64: // fixup A - offset: 0, value: lbl, kind: fixup_arm64_pcrel_branch19
1328 // CHECK-ARM64: b.hs lbl // encoding: [0bAAA00010,A,A,0x54]
1329 // CHECK-ARM64: // fixup A - offset: 0, value: lbl, kind: fixup_arm64_pcrel_branch19
1330 // CHECK-ARM64: b.hs lbl // encoding: [0bAAA00010,A,A,0x54]
1331 // CHECK-ARM64: // fixup A - offset: 0, value: lbl, kind: fixup_arm64_pcrel_branch19
1332 // CHECK-ARM64: b.lo lbl // encoding: [0bAAA00011,A,A,0x54]
1333 // CHECK-ARM64: // fixup A - offset: 0, value: lbl, kind: fixup_arm64_pcrel_branch19
1334 // CHECK-ARM64: b.lo lbl // encoding: [0bAAA00011,A,A,0x54]
1335 // CHECK-ARM64: // fixup A - offset: 0, value: lbl, kind: fixup_arm64_pcrel_branch19
1336 // CHECK-ARM64: b.mi lbl // encoding: [0bAAA00100,A,A,0x54]
1337 // CHECK-ARM64: // fixup A - offset: 0, value: lbl, kind: fixup_arm64_pcrel_branch19
1338 // CHECK-ARM64: b.pl lbl // encoding: [0bAAA00101,A,A,0x54]
1339 // CHECK-ARM64: // fixup A - offset: 0, value: lbl, kind: fixup_arm64_pcrel_branch19
1340 // CHECK-ARM64: b.vs lbl // encoding: [0bAAA00110,A,A,0x54]
1341 // CHECK-ARM64: // fixup A - offset: 0, value: lbl, kind: fixup_arm64_pcrel_branch19
1342 // CHECK-ARM64: b.vc lbl // encoding: [0bAAA00111,A,A,0x54]
1343 // CHECK-ARM64: // fixup A - offset: 0, value: lbl, kind: fixup_arm64_pcrel_branch19
1344 // CHECK-ARM64: b.hi lbl // encoding: [0bAAA01000,A,A,0x54]
1345 // CHECK-ARM64: // fixup A - offset: 0, value: lbl, kind: fixup_arm64_pcrel_branch19
1346 // CHECK-ARM64: b.ls lbl // encoding: [0bAAA01001,A,A,0x54]
1347 // CHECK-ARM64: // fixup A - offset: 0, value: lbl, kind: fixup_arm64_pcrel_branch19
1348 // CHECK-ARM64: b.ge lbl // encoding: [0bAAA01010,A,A,0x54]
1349 // CHECK-ARM64: // fixup A - offset: 0, value: lbl, kind: fixup_arm64_pcrel_branch19
1350 // CHECK-ARM64: b.lt lbl // encoding: [0bAAA01011,A,A,0x54]
1351 // CHECK-ARM64: // fixup A - offset: 0, value: lbl, kind: fixup_arm64_pcrel_branch19
1352 // CHECK-ARM64: b.gt lbl // encoding: [0bAAA01100,A,A,0x54]
1353 // CHECK-ARM64: // fixup A - offset: 0, value: lbl, kind: fixup_arm64_pcrel_branch19
1354 // CHECK-ARM64: b.le lbl // encoding: [0bAAA01101,A,A,0x54]
1355 // CHECK-ARM64: // fixup A - offset: 0, value: lbl, kind: fixup_arm64_pcrel_branch19
1356 // CHECK-ARM64: b.al lbl // encoding: [0bAAA01110,A,A,0x54]
1357 // CHECK-ARM64: // fixup A - offset: 0, value: lbl, kind: fixup_arm64_pcrel_branch19
1359 // ARM64 has these in a separate file
1377 // CHECK-AARCH64: b.eq lbl // encoding: [A,A,A,0x54'A']
1378 // CHECK-AARCH64: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1379 // CHECK-AARCH64: b.ne lbl // encoding: [0x01'A',A,A,0x54'A']
1380 // CHECK-AARCH64: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1381 // CHECK-AARCH64: b.hs lbl // encoding: [0x02'A',A,A,0x54'A']
1382 // CHECK-AARCH64: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1383 // CHECK-AARCH64: b.hs lbl // encoding: [0x02'A',A,A,0x54'A']
1384 // CHECK-AARCH64: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1385 // CHECK-AARCH64: b.lo lbl // encoding: [0x03'A',A,A,0x54'A']
1386 // CHECK-AARCH64: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1387 // CHECK-AARCH64: b.lo lbl // encoding: [0x03'A',A,A,0x54'A']
1388 // CHECK-AARCH64: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1389 // CHECK-AARCH64: b.mi lbl // encoding: [0x04'A',A,A,0x54'A']
1390 // CHECK-AARCH64: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1391 // CHECK-AARCH64: b.pl lbl // encoding: [0x05'A',A,A,0x54'A']
1392 // CHECK-AARCH64: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1393 // CHECK-AARCH64: b.vs lbl // encoding: [0x06'A',A,A,0x54'A']
1394 // CHECK-AARCH64: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1395 // CHECK-AARCH64: b.vc lbl // encoding: [0x07'A',A,A,0x54'A']
1396 // CHECK-AARCH64: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1397 // CHECK-AARCH64: b.hi lbl // encoding: [0x08'A',A,A,0x54'A']
1398 // CHECK-AARCH64: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1399 // CHECK-AARCH64: b.ls lbl // encoding: [0x09'A',A,A,0x54'A']
1400 // CHECK-AARCH64: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1401 // CHECK-AARCH64: b.ge lbl // encoding: [0x0a'A',A,A,0x54'A']
1402 // CHECK-AARCH64: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1403 // CHECK-AARCH64: b.lt lbl // encoding: [0x0b'A',A,A,0x54'A']
1404 // CHECK-AARCH64: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1405 // CHECK-AARCH64: b.gt lbl // encoding: [0x0c'A',A,A,0x54'A']
1406 // CHECK-AARCH64: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1407 // CHECK-AARCH64: b.le lbl // encoding: [0x0d'A',A,A,0x54'A']
1408 // CHECK-AARCH64: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1409 // CHECK-AARCH64: b.al lbl // encoding: [0x0e'A',A,A,0x54'A']
1410 // CHECK-AARCH64: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
1415 // CHECK: b.eq #0 // encoding: [0x00,0x00,0x00,0x54]
1416 // CHECK: b.lt #-4 // encoding: [0xeb,0xff,0xff,0x54]
1417 // CHECK: b.lo #1048572 // encoding: [0xe3,0xff,0x7f,0x54]
1419 //------------------------------------------------------------------------------
1420 // Conditional compare (immediate)
1421 //------------------------------------------------------------------------------
1423 ccmp w1, #31, #0, eq
1424 ccmp w3, #0, #15, hs
1425 ccmp wzr, #15, #13, cs
1426 // CHECK: ccmp w1, #31, #0, eq // encoding: [0x20,0x08,0x5f,0x7a]
1427 // CHECK: ccmp w3, #0, #15, hs // encoding: [0x6f,0x28,0x40,0x7a]
1428 // CHECK: ccmp wzr, #15, #13, hs // encoding: [0xed,0x2b,0x4f,0x7a]
1430 ccmp x9, #31, #0, le
1431 ccmp x3, #0, #15, gt
1432 ccmp xzr, #5, #7, ne
1433 // CHECK: ccmp x9, #31, #0, le // encoding: [0x20,0xd9,0x5f,0xfa]
1434 // CHECK: ccmp x3, #0, #15, gt // encoding: [0x6f,0xc8,0x40,0xfa]
1435 // CHECK: ccmp xzr, #5, #7, ne // encoding: [0xe7,0x1b,0x45,0xfa]
1437 ccmn w1, #31, #0, eq
1438 ccmn w3, #0, #15, hs
1439 ccmn wzr, #15, #13, cs
1440 // CHECK: ccmn w1, #31, #0, eq // encoding: [0x20,0x08,0x5f,0x3a]
1441 // CHECK: ccmn w3, #0, #15, hs // encoding: [0x6f,0x28,0x40,0x3a]
1442 // CHECK: ccmn wzr, #15, #13, hs // encoding: [0xed,0x2b,0x4f,0x3a]
1444 ccmn x9, #31, #0, le
1445 ccmn x3, #0, #15, gt
1446 ccmn xzr, #5, #7, ne
1447 // CHECK: ccmn x9, #31, #0, le // encoding: [0x20,0xd9,0x5f,0xba]
1448 // CHECK: ccmn x3, #0, #15, gt // encoding: [0x6f,0xc8,0x40,0xba]
1449 // CHECK: ccmn xzr, #5, #7, ne // encoding: [0xe7,0x1b,0x45,0xba]
1451 //------------------------------------------------------------------------------
1452 // Conditional compare (register)
1453 //------------------------------------------------------------------------------
1455 ccmp w1, wzr, #0, eq
1456 ccmp w3, w0, #15, hs
1457 ccmp wzr, w15, #13, cs
1458 // CHECK: ccmp w1, wzr, #0, eq // encoding: [0x20,0x00,0x5f,0x7a]
1459 // CHECK: ccmp w3, w0, #15, hs // encoding: [0x6f,0x20,0x40,0x7a]
1460 // CHECK: ccmp wzr, w15, #13, hs // encoding: [0xed,0x23,0x4f,0x7a]
1462 ccmp x9, xzr, #0, le
1463 ccmp x3, x0, #15, gt
1464 ccmp xzr, x5, #7, ne
1465 // CHECK: ccmp x9, xzr, #0, le // encoding: [0x20,0xd1,0x5f,0xfa]
1466 // CHECK: ccmp x3, x0, #15, gt // encoding: [0x6f,0xc0,0x40,0xfa]
1467 // CHECK: ccmp xzr, x5, #7, ne // encoding: [0xe7,0x13,0x45,0xfa]
1469 ccmn w1, wzr, #0, eq
1470 ccmn w3, w0, #15, hs
1471 ccmn wzr, w15, #13, cs
1472 // CHECK: ccmn w1, wzr, #0, eq // encoding: [0x20,0x00,0x5f,0x3a]
1473 // CHECK: ccmn w3, w0, #15, hs // encoding: [0x6f,0x20,0x40,0x3a]
1474 // CHECK: ccmn wzr, w15, #13, hs // encoding: [0xed,0x23,0x4f,0x3a]
1476 ccmn x9, xzr, #0, le
1477 ccmn x3, x0, #15, gt
1478 ccmn xzr, x5, #7, ne
1479 // CHECK: ccmn x9, xzr, #0, le // encoding: [0x20,0xd1,0x5f,0xba]
1480 // CHECK: ccmn x3, x0, #15, gt // encoding: [0x6f,0xc0,0x40,0xba]
1481 // CHECK: ccmn xzr, x5, #7, ne // encoding: [0xe7,0x13,0x45,0xba]
1483 //------------------------------------------------------------------------------
1484 // Conditional select
1485 //------------------------------------------------------------------------------
1486 csel w1, w0, w19, ne
1487 csel wzr, w5, w9, eq
1488 csel w9, wzr, w30, gt
1489 csel w1, w28, wzr, mi
1490 // CHECK: csel w1, w0, w19, ne // encoding: [0x01,0x10,0x93,0x1a]
1491 // CHECK: csel wzr, w5, w9, eq // encoding: [0xbf,0x00,0x89,0x1a]
1492 // CHECK: csel w9, wzr, w30, gt // encoding: [0xe9,0xc3,0x9e,0x1a]
1493 // CHECK: csel w1, w28, wzr, mi // encoding: [0x81,0x43,0x9f,0x1a]
1495 csel x19, x23, x29, lt
1496 csel xzr, x3, x4, ge
1497 csel x5, xzr, x6, cs
1498 csel x7, x8, xzr, cc
1499 // CHECK: csel x19, x23, x29, lt // encoding: [0xf3,0xb2,0x9d,0x9a]
1500 // CHECK: csel xzr, x3, x4, ge // encoding: [0x7f,0xa0,0x84,0x9a]
1501 // CHECK: csel x5, xzr, x6, hs // encoding: [0xe5,0x23,0x86,0x9a]
1502 // CHECK: csel x7, x8, xzr, lo // encoding: [0x07,0x31,0x9f,0x9a]
1504 csinc w1, w0, w19, ne
1505 csinc wzr, w5, w9, eq
1506 csinc w9, wzr, w30, gt
1507 csinc w1, w28, wzr, mi
1508 // CHECK: csinc w1, w0, w19, ne // encoding: [0x01,0x14,0x93,0x1a]
1509 // CHECK: csinc wzr, w5, w9, eq // encoding: [0xbf,0x04,0x89,0x1a]
1510 // CHECK: csinc w9, wzr, w30, gt // encoding: [0xe9,0xc7,0x9e,0x1a]
1511 // CHECK: csinc w1, w28, wzr, mi // encoding: [0x81,0x47,0x9f,0x1a]
1513 csinc x19, x23, x29, lt
1514 csinc xzr, x3, x4, ge
1515 csinc x5, xzr, x6, cs
1516 csinc x7, x8, xzr, cc
1517 // CHECK: csinc x19, x23, x29, lt // encoding: [0xf3,0xb6,0x9d,0x9a]
1518 // CHECK: csinc xzr, x3, x4, ge // encoding: [0x7f,0xa4,0x84,0x9a]
1519 // CHECK: csinc x5, xzr, x6, hs // encoding: [0xe5,0x27,0x86,0x9a]
1520 // CHECK: csinc x7, x8, xzr, lo // encoding: [0x07,0x35,0x9f,0x9a]
1522 csinv w1, w0, w19, ne
1523 csinv wzr, w5, w9, eq
1524 csinv w9, wzr, w30, gt
1525 csinv w1, w28, wzr, mi
1526 // CHECK: csinv w1, w0, w19, ne // encoding: [0x01,0x10,0x93,0x5a]
1527 // CHECK: csinv wzr, w5, w9, eq // encoding: [0xbf,0x00,0x89,0x5a]
1528 // CHECK: csinv w9, wzr, w30, gt // encoding: [0xe9,0xc3,0x9e,0x5a]
1529 // CHECK: csinv w1, w28, wzr, mi // encoding: [0x81,0x43,0x9f,0x5a]
1531 csinv x19, x23, x29, lt
1532 csinv xzr, x3, x4, ge
1533 csinv x5, xzr, x6, cs
1534 csinv x7, x8, xzr, cc
1535 // CHECK: csinv x19, x23, x29, lt // encoding: [0xf3,0xb2,0x9d,0xda]
1536 // CHECK: csinv xzr, x3, x4, ge // encoding: [0x7f,0xa0,0x84,0xda]
1537 // CHECK: csinv x5, xzr, x6, hs // encoding: [0xe5,0x23,0x86,0xda]
1538 // CHECK: csinv x7, x8, xzr, lo // encoding: [0x07,0x31,0x9f,0xda]
1540 csneg w1, w0, w19, ne
1541 csneg wzr, w5, w9, eq
1542 csneg w9, wzr, w30, gt
1543 csneg w1, w28, wzr, mi
1544 // CHECK: csneg w1, w0, w19, ne // encoding: [0x01,0x14,0x93,0x5a]
1545 // CHECK: csneg wzr, w5, w9, eq // encoding: [0xbf,0x04,0x89,0x5a]
1546 // CHECK: csneg w9, wzr, w30, gt // encoding: [0xe9,0xc7,0x9e,0x5a]
1547 // CHECK: csneg w1, w28, wzr, mi // encoding: [0x81,0x47,0x9f,0x5a]
1549 csneg x19, x23, x29, lt
1550 csneg xzr, x3, x4, ge
1551 csneg x5, xzr, x6, cs
1552 csneg x7, x8, xzr, cc
1553 // CHECK: csneg x19, x23, x29, lt // encoding: [0xf3,0xb6,0x9d,0xda]
1554 // CHECK: csneg xzr, x3, x4, ge // encoding: [0x7f,0xa4,0x84,0xda]
1555 // CHECK: csneg x5, xzr, x6, hs // encoding: [0xe5,0x27,0x86,0xda]
1556 // CHECK: csneg x7, x8, xzr, lo // encoding: [0x07,0x35,0x9f,0xda]
1560 // CHECK: cset w3, eq // encoding: [0xe3,0x17,0x9f,0x1a]
1561 // CHECK: cset x9, pl // encoding: [0xe9,0x47,0x9f,0x9a]
1565 // CHECK: csetm w20, ne // encoding: [0xf4,0x03,0x9f,0x5a]
1566 // CHECK: csetm x30, ge // encoding: [0xfe,0xb3,0x9f,0xda]
1571 // CHECK: cinc w3, w5, gt // encoding: [0xa3,0xd4,0x85,0x1a]
1572 // CHECK: cinc wzr, w4, le // encoding: [0x9f,0xc4,0x84,0x1a]
1573 // CHECK: cset w9, lt // encoding: [0xe9,0xa7,0x9f,0x1a]
1578 // CHECK: cinc x3, x5, gt // encoding: [0xa3,0xd4,0x85,0x9a]
1579 // CHECK: cinc xzr, x4, le // encoding: [0x9f,0xc4,0x84,0x9a]
1580 // CHECK: cset x9, lt // encoding: [0xe9,0xa7,0x9f,0x9a]
1585 // CHECK: cinv w3, w5, gt // encoding: [0xa3,0xd0,0x85,0x5a]
1586 // CHECK: cinv wzr, w4, le // encoding: [0x9f,0xc0,0x84,0x5a]
1587 // CHECK: csetm w9, lt // encoding: [0xe9,0xa3,0x9f,0x5a]
1592 // CHECK: cinv x3, x5, gt // encoding: [0xa3,0xd0,0x85,0xda]
1593 // CHECK: cinv xzr, x4, le // encoding: [0x9f,0xc0,0x84,0xda]
1594 // CHECK: csetm x9, lt // encoding: [0xe9,0xa3,0x9f,0xda]
1599 // CHECK: cneg w3, w5, gt // encoding: [0xa3,0xd4,0x85,0x5a]
1600 // CHECK: cneg wzr, w4, le // encoding: [0x9f,0xc4,0x84,0x5a]
1601 // CHECK: cneg w9, wzr, lt // encoding: [0xe9,0xa7,0x9f,0x5a]
1606 // CHECK: cneg x3, x5, gt // encoding: [0xa3,0xd4,0x85,0xda]
1607 // CHECK: cneg xzr, x4, le // encoding: [0x9f,0xc4,0x84,0xda]
1608 // CHECK: cneg x9, xzr, lt // encoding: [0xe9,0xa7,0x9f,0xda]
1610 //------------------------------------------------------------------------------
1611 // Data-processing (1 source)
1612 //------------------------------------------------------------------------------
1621 // CHECK: rbit w0, w7 // encoding: [0xe0,0x00,0xc0,0x5a]
1622 // CHECK: rbit x18, x3 // encoding: [0x72,0x00,0xc0,0xda]
1623 // CHECK: rev16 w17, w1 // encoding: [0x31,0x04,0xc0,0x5a]
1624 // CHECK: rev16 x5, x2 // encoding: [0x45,0x04,0xc0,0xda]
1625 // CHECK: rev w18, w0 // encoding: [0x12,0x08,0xc0,0x5a]
1626 // CHECK: rev32 x20, x1 // encoding: [0x34,0x08,0xc0,0xda]
1627 // CHECK: rev32 x20, xzr // encoding: [0xf4,0x0b,0xc0,0xda]
1636 // CHECK: rev x22, x2 // encoding: [0x56,0x0c,0xc0,0xda]
1637 // CHECK: rev x18, xzr // encoding: [0xf2,0x0f,0xc0,0xda]
1638 // CHECK: rev w7, wzr // encoding: [0xe7,0x0b,0xc0,0x5a]
1639 // CHECK: clz w24, w3 // encoding: [0x78,0x10,0xc0,0x5a]
1640 // CHECK: clz x26, x4 // encoding: [0x9a,0x10,0xc0,0xda]
1641 // CHECK: cls w3, w5 // encoding: [0xa3,0x14,0xc0,0x5a]
1642 // CHECK: cls x20, x5 // encoding: [0xb4,0x14,0xc0,0xda]
1646 // CHECK: clz w24, wzr // encoding: [0xf8,0x13,0xc0,0x5a]
1647 // CHECK: rev x22, xzr // encoding: [0xf6,0x0f,0xc0,0xda]
1649 //------------------------------------------------------------------------------
1650 // Data-processing (2 source)
1651 //------------------------------------------------------------------------------
1654 crc32h w28, wzr, w30
1658 crc32ch w13, w17, w25
1660 crc32cx w18, w16, xzr
1661 // CHECK: crc32b w5, w7, w20 // encoding: [0xe5,0x40,0xd4,0x1a]
1662 // CHECK: crc32h w28, wzr, w30 // encoding: [0xfc,0x47,0xde,0x1a]
1663 // CHECK: crc32w w0, w1, w2 // encoding: [0x20,0x48,0xc2,0x1a]
1664 // CHECK: crc32x w7, w9, x20 // encoding: [0x27,0x4d,0xd4,0x9a]
1665 // CHECK: crc32cb w9, w5, w4 // encoding: [0xa9,0x50,0xc4,0x1a]
1666 // CHECK: crc32ch w13, w17, w25 // encoding: [0x2d,0x56,0xd9,0x1a]
1667 // CHECK: crc32cw wzr, w3, w5 // encoding: [0x7f,0x58,0xc5,0x1a]
1668 // CHECK: crc32cx w18, w16, xzr // encoding: [0x12,0x5e,0xdf,0x9a]
1684 // CHECK: udiv w0, w7, w10 // encoding: [0xe0,0x08,0xca,0x1a]
1685 // CHECK: udiv x9, x22, x4 // encoding: [0xc9,0x0a,0xc4,0x9a]
1686 // CHECK: sdiv w12, w21, w0 // encoding: [0xac,0x0e,0xc0,0x1a]
1687 // CHECK: sdiv x13, x2, x1 // encoding: [0x4d,0x0c,0xc1,0x9a]
1688 // CHECK: lsl w11, w12, w13 // encoding: [0x8b,0x21,0xcd,0x1a]
1689 // CHECK: lsl x14, x15, x16 // encoding: [0xee,0x21,0xd0,0x9a]
1690 // CHECK: lsr w17, w18, w19 // encoding: [0x51,0x26,0xd3,0x1a]
1691 // CHECK: lsr x20, x21, x22 // encoding: [0xb4,0x26,0xd6,0x9a]
1692 // CHECK: asr w23, w24, w25 // encoding: [0x17,0x2b,0xd9,0x1a]
1693 // CHECK: asr x26, x27, x28 // encoding: [0x7a,0x2b,0xdc,0x9a]
1694 // CHECK: ror w0, w1, w2 // encoding: [0x20,0x2c,0xc2,0x1a]
1695 // CHECK: ror x3, x4, x5 // encoding: [0x83,0x2c,0xc5,0x9a]
1706 // CHECK: lsl w6, w7, w8 // encoding: [0xe6,0x20,0xc8,0x1a]
1707 // CHECK: lsl x9, x10, x11 // encoding: [0x49,0x21,0xcb,0x9a]
1708 // CHECK: lsr w12, w13, w14 // encoding: [0xac,0x25,0xce,0x1a]
1709 // CHECK: lsr x15, x16, x17 // encoding: [0x0f,0x26,0xd1,0x9a]
1710 // CHECK: asr w18, w19, w20 // encoding: [0x72,0x2a,0xd4,0x1a]
1711 // CHECK: asr x21, x22, x23 // encoding: [0xd5,0x2a,0xd7,0x9a]
1712 // CHECK: ror w24, w25, w26 // encoding: [0x38,0x2f,0xda,0x1a]
1713 // CHECK: ror x27, x28, x29 // encoding: [0x9b,0x2f,0xdd,0x9a]
1716 madd wzr, w0, w9, w11
1717 madd w13, wzr, w4, w4
1718 madd w19, w30, wzr, w29
1719 madd w4, w5, w6, wzr
1720 // CHECK: madd w1, w3, w7, w4 // encoding: [0x61,0x10,0x07,0x1b]
1721 // CHECK: madd wzr, w0, w9, w11 // encoding: [0x1f,0x2c,0x09,0x1b]
1722 // CHECK: madd w13, wzr, w4, w4 // encoding: [0xed,0x13,0x04,0x1b]
1723 // CHECK: madd w19, w30, wzr, w29 // encoding: [0xd3,0x77,0x1f,0x1b]
1724 // CHECK: mul w4, w5, w6 // encoding: [0xa4,0x7c,0x06,0x1b]
1727 madd xzr, x0, x9, x11
1728 madd x13, xzr, x4, x4
1729 madd x19, x30, xzr, x29
1730 madd x4, x5, x6, xzr
1731 // CHECK: madd x1, x3, x7, x4 // encoding: [0x61,0x10,0x07,0x9b]
1732 // CHECK: madd xzr, x0, x9, x11 // encoding: [0x1f,0x2c,0x09,0x9b]
1733 // CHECK: madd x13, xzr, x4, x4 // encoding: [0xed,0x13,0x04,0x9b]
1734 // CHECK: madd x19, x30, xzr, x29 // encoding: [0xd3,0x77,0x1f,0x9b]
1735 // CHECK: mul x4, x5, x6 // encoding: [0xa4,0x7c,0x06,0x9b]
1738 msub wzr, w0, w9, w11
1739 msub w13, wzr, w4, w4
1740 msub w19, w30, wzr, w29
1741 msub w4, w5, w6, wzr
1742 // CHECK: msub w1, w3, w7, w4 // encoding: [0x61,0x90,0x07,0x1b]
1743 // CHECK: msub wzr, w0, w9, w11 // encoding: [0x1f,0xac,0x09,0x1b]
1744 // CHECK: msub w13, wzr, w4, w4 // encoding: [0xed,0x93,0x04,0x1b]
1745 // CHECK: msub w19, w30, wzr, w29 // encoding: [0xd3,0xf7,0x1f,0x1b]
1746 // CHECK: mneg w4, w5, w6 // encoding: [0xa4,0xfc,0x06,0x1b]
1749 msub xzr, x0, x9, x11
1750 msub x13, xzr, x4, x4
1751 msub x19, x30, xzr, x29
1752 msub x4, x5, x6, xzr
1753 // CHECK: msub x1, x3, x7, x4 // encoding: [0x61,0x90,0x07,0x9b]
1754 // CHECK: msub xzr, x0, x9, x11 // encoding: [0x1f,0xac,0x09,0x9b]
1755 // CHECK: msub x13, xzr, x4, x4 // encoding: [0xed,0x93,0x04,0x9b]
1756 // CHECK: msub x19, x30, xzr, x29 // encoding: [0xd3,0xf7,0x1f,0x9b]
1757 // CHECK: mneg x4, x5, x6 // encoding: [0xa4,0xfc,0x06,0x9b]
1759 smaddl x3, w5, w2, x9
1760 smaddl xzr, w10, w11, x12
1761 smaddl x13, wzr, w14, x15
1762 smaddl x16, w17, wzr, x18
1763 smaddl x19, w20, w21, xzr
1764 // CHECK: smaddl x3, w5, w2, x9 // encoding: [0xa3,0x24,0x22,0x9b]
1765 // CHECK: smaddl xzr, w10, w11, x12 // encoding: [0x5f,0x31,0x2b,0x9b]
1766 // CHECK: smaddl x13, wzr, w14, x15 // encoding: [0xed,0x3f,0x2e,0x9b]
1767 // CHECK: smaddl x16, w17, wzr, x18 // encoding: [0x30,0x4a,0x3f,0x9b]
1768 // CHECK: smull x19, w20, w21 // encoding: [0x93,0x7e,0x35,0x9b]
1770 smsubl x3, w5, w2, x9
1771 smsubl xzr, w10, w11, x12
1772 smsubl x13, wzr, w14, x15
1773 smsubl x16, w17, wzr, x18
1774 smsubl x19, w20, w21, xzr
1775 // CHECK: smsubl x3, w5, w2, x9 // encoding: [0xa3,0xa4,0x22,0x9b]
1776 // CHECK: smsubl xzr, w10, w11, x12 // encoding: [0x5f,0xb1,0x2b,0x9b]
1777 // CHECK: smsubl x13, wzr, w14, x15 // encoding: [0xed,0xbf,0x2e,0x9b]
1778 // CHECK: smsubl x16, w17, wzr, x18 // encoding: [0x30,0xca,0x3f,0x9b]
1779 // CHECK: smnegl x19, w20, w21 // encoding: [0x93,0xfe,0x35,0x9b]
1781 umaddl x3, w5, w2, x9
1782 umaddl xzr, w10, w11, x12
1783 umaddl x13, wzr, w14, x15
1784 umaddl x16, w17, wzr, x18
1785 umaddl x19, w20, w21, xzr
1786 // CHECK: umaddl x3, w5, w2, x9 // encoding: [0xa3,0x24,0xa2,0x9b]
1787 // CHECK: umaddl xzr, w10, w11, x12 // encoding: [0x5f,0x31,0xab,0x9b]
1788 // CHECK: umaddl x13, wzr, w14, x15 // encoding: [0xed,0x3f,0xae,0x9b]
1789 // CHECK: umaddl x16, w17, wzr, x18 // encoding: [0x30,0x4a,0xbf,0x9b]
1790 // CHECK: umull x19, w20, w21 // encoding: [0x93,0x7e,0xb5,0x9b]
1794 umsubl x3, w5, w2, x9
1795 umsubl xzr, w10, w11, x12
1796 umsubl x13, wzr, w14, x15
1797 umsubl x16, w17, wzr, x18
1798 umsubl x19, w20, w21, xzr
1799 // CHECK: umsubl x3, w5, w2, x9 // encoding: [0xa3,0xa4,0xa2,0x9b]
1800 // CHECK: umsubl xzr, w10, w11, x12 // encoding: [0x5f,0xb1,0xab,0x9b]
1801 // CHECK: umsubl x13, wzr, w14, x15 // encoding: [0xed,0xbf,0xae,0x9b]
1802 // CHECK: umsubl x16, w17, wzr, x18 // encoding: [0x30,0xca,0xbf,0x9b]
1803 // CHECK: umnegl x19, w20, w21 // encoding: [0x93,0xfe,0xb5,0x9b]
1809 // CHECK: smulh x30, x29, x28 // encoding: [0xbe,0x7f,0x5c,0x9b]
1810 // CHECK: smulh xzr, x27, x26 // encoding: [0x7f,0x7f,0x5a,0x9b]
1811 // CHECK: smulh x25, xzr, x24 // encoding: [0xf9,0x7f,0x58,0x9b]
1812 // CHECK: smulh x23, x22, xzr // encoding: [0xd7,0x7e,0x5f,0x9b]
1818 // CHECK: umulh x30, x29, x28 // encoding: [0xbe,0x7f,0xdc,0x9b]
1819 // CHECK: umulh xzr, x27, x26 // encoding: [0x7f,0x7f,0xda,0x9b]
1820 // CHECK: umulh x25, xzr, x24 // encoding: [0xf9,0x7f,0xd8,0x9b]
1821 // CHECK: umulh x23, x22, xzr // encoding: [0xd7,0x7e,0xdf,0x9b]
1840 smnegl x11, w13, w17
1841 umnegl x11, w13, w17
1842 // CHECK: mul w3, w4, w5 // encoding: [0x83,0x7c,0x05,0x1b]
1843 // CHECK: mul wzr, w6, w7 // encoding: [0xdf,0x7c,0x07,0x1b]
1844 // CHECK: mul w8, wzr, w9 // encoding: [0xe8,0x7f,0x09,0x1b]
1845 // CHECK: mul w10, w11, wzr // encoding: [0x6a,0x7d,0x1f,0x1b]
1846 // CHECK: mul x12, x13, x14 // encoding: [0xac,0x7d,0x0e,0x9b]
1847 // CHECK: mul xzr, x15, x16 // encoding: [0xff,0x7d,0x10,0x9b]
1848 // CHECK: mul x17, xzr, x18 // encoding: [0xf1,0x7f,0x12,0x9b]
1849 // CHECK: mul x19, x20, xzr // encoding: [0x93,0x7e,0x1f,0x9b]
1850 // CHECK: mneg w21, w22, w23 // encoding: [0xd5,0xfe,0x17,0x1b]
1851 // CHECK: mneg wzr, w24, w25 // encoding: [0x1f,0xff,0x19,0x1b]
1852 // CHECK: mneg w26, wzr, w27 // encoding: [0xfa,0xff,0x1b,0x1b]
1853 // CHECK: mneg w28, w29, wzr // encoding: [0xbc,0xff,0x1f,0x1b]
1854 // CHECK: smull x11, w13, w17 // encoding: [0xab,0x7d,0x31,0x9b]
1855 // CHECK: umull x11, w13, w17 // encoding: [0xab,0x7d,0xb1,0x9b]
1856 // CHECK: smnegl x11, w13, w17 // encoding: [0xab,0xfd,0x31,0x9b]
1857 // CHECK: umnegl x11, w13, w17 // encoding: [0xab,0xfd,0xb1,0x9b]
1859 //------------------------------------------------------------------------------
1860 // Exception generation
1861 //------------------------------------------------------------------------------
1864 // CHECK: svc #0 // encoding: [0x01,0x00,0x00,0xd4]
1865 // CHECK: svc #{{65535|0xffff}} // encoding: [0xe1,0xff,0x1f,0xd4]
1871 // CHECK: hvc #{{1|0x1}} // encoding: [0x22,0x00,0x00,0xd4]
1872 // CHECK: smc #{{12000|0x2ee0}} // encoding: [0x03,0xdc,0x05,0xd4]
1873 // CHECK: brk #{{12|0xc}} // encoding: [0x80,0x01,0x20,0xd4]
1874 // CHECK: hlt #{{123|0x7b}} // encoding: [0x60,0x0f,0x40,0xd4]
1879 // CHECK: dcps1 #{{42|0x2a}} // encoding: [0x41,0x05,0xa0,0xd4]
1880 // CHECK: dcps2 #{{9|0x9}} // encoding: [0x22,0x01,0xa0,0xd4]
1881 // CHECK: dcps3 #{{1000|0x3e8}} // encoding: [0x03,0x7d,0xa0,0xd4]
1886 // CHECK: dcps1 // encoding: [0x01,0x00,0xa0,0xd4]
1887 // CHECK: dcps2 // encoding: [0x02,0x00,0xa0,0xd4]
1888 // CHECK: dcps3 // encoding: [0x03,0x00,0xa0,0xd4]
1890 //------------------------------------------------------------------------------
1891 // Extract (immediate)
1892 //------------------------------------------------------------------------------
1895 extr w11, w13, w17, #31
1896 // CHECK: extr w3, w5, w7, #0 // encoding: [0xa3,0x00,0x87,0x13]
1897 // CHECK: extr w11, w13, w17, #31 // encoding: [0xab,0x7d,0x91,0x13]
1899 extr x3, x5, x7, #15
1900 extr x11, x13, x17, #63
1901 // CHECK: extr x3, x5, x7, #15 // encoding: [0xa3,0x3c,0xc7,0x93]
1902 // CHECK: extr x11, x13, x17, #63 // encoding: [0xab,0xfd,0xd1,0x93]
1906 // CHECK: ror x19, x23, #24 // encoding: [0xf3,0x62,0xd7,0x93]
1907 // CHECK: ror x29, xzr, #63 // encoding: [0xfd,0xff,0xdf,0x93]
1910 // CHECK: ror w9, w13, #31 // encoding: [0xa9,0x7d,0x8d,0x13]
1912 //------------------------------------------------------------------------------
1913 // Floating-point compare
1914 //------------------------------------------------------------------------------
1918 // CHECK: fcmp s3, s5 // encoding: [0x60,0x20,0x25,0x1e]
1919 // CHECK: fcmp s31, #0.0 // encoding: [0xe8,0x23,0x20,0x1e]
1923 // CHECK: fcmpe s29, s30 // encoding: [0xb0,0x23,0x3e,0x1e]
1924 // CHECK: fcmpe s15, #0.0 // encoding: [0xf8,0x21,0x20,0x1e]
1928 // CHECK: fcmp d4, d12 // encoding: [0x80,0x20,0x6c,0x1e]
1929 // CHECK: fcmp d23, #0.0 // encoding: [0xe8,0x22,0x60,0x1e]
1933 // CHECK: fcmpe d26, d22 // encoding: [0x50,0x23,0x76,0x1e]
1934 // CHECK: fcmpe d29, #0.0 // encoding: [0xb8,0x23,0x60,0x1e]
1936 //------------------------------------------------------------------------------
1937 // Floating-point conditional compare
1938 //------------------------------------------------------------------------------
1940 fccmp s1, s31, #0, eq
1941 fccmp s3, s0, #15, hs
1942 fccmp s31, s15, #13, cs
1943 // CHECK: fccmp s1, s31, #0, eq // encoding: [0x20,0x04,0x3f,0x1e]
1944 // CHECK: fccmp s3, s0, #15, hs // encoding: [0x6f,0x24,0x20,0x1e]
1945 // CHECK: fccmp s31, s15, #13, hs // encoding: [0xed,0x27,0x2f,0x1e]
1947 fccmp d9, d31, #0, le
1948 fccmp d3, d0, #15, gt
1949 fccmp d31, d5, #7, ne
1950 // CHECK: fccmp d9, d31, #0, le // encoding: [0x20,0xd5,0x7f,0x1e]
1951 // CHECK: fccmp d3, d0, #15, gt // encoding: [0x6f,0xc4,0x60,0x1e]
1952 // CHECK: fccmp d31, d5, #7, ne // encoding: [0xe7,0x17,0x65,0x1e]
1954 fccmpe s1, s31, #0, eq
1955 fccmpe s3, s0, #15, hs
1956 fccmpe s31, s15, #13, cs
1957 // CHECK: fccmpe s1, s31, #0, eq // encoding: [0x30,0x04,0x3f,0x1e]
1958 // CHECK: fccmpe s3, s0, #15, hs // encoding: [0x7f,0x24,0x20,0x1e]
1959 // CHECK: fccmpe s31, s15, #13, hs // encoding: [0xfd,0x27,0x2f,0x1e]
1961 fccmpe d9, d31, #0, le
1962 fccmpe d3, d0, #15, gt
1963 fccmpe d31, d5, #7, ne
1964 // CHECK: fccmpe d9, d31, #0, le // encoding: [0x30,0xd5,0x7f,0x1e]
1965 // CHECK: fccmpe d3, d0, #15, gt // encoding: [0x7f,0xc4,0x60,0x1e]
1966 // CHECK: fccmpe d31, d5, #7, ne // encoding: [0xf7,0x17,0x65,0x1e]
1968 //------------------------------------------------------------------------------
1969 // Floating-point conditional compare
1970 //------------------------------------------------------------------------------
1972 fcsel s3, s20, s9, pl
1973 fcsel d9, d10, d11, mi
1974 // CHECK: fcsel s3, s20, s9, pl // encoding: [0x83,0x5e,0x29,0x1e]
1975 // CHECK: fcsel d9, d10, d11, mi // encoding: [0x49,0x4d,0x6b,0x1e]
1977 //------------------------------------------------------------------------------
1978 // Floating-point data-processing (1 source)
1979 //------------------------------------------------------------------------------
1994 // CHECK: fmov s0, s1 // encoding: [0x20,0x40,0x20,0x1e]
1995 // CHECK: fabs s2, s3 // encoding: [0x62,0xc0,0x20,0x1e]
1996 // CHECK: fneg s4, s5 // encoding: [0xa4,0x40,0x21,0x1e]
1997 // CHECK: fsqrt s6, s7 // encoding: [0xe6,0xc0,0x21,0x1e]
1998 // CHECK: fcvt d8, s9 // encoding: [0x28,0xc1,0x22,0x1e]
1999 // CHECK: fcvt h10, s11 // encoding: [0x6a,0xc1,0x23,0x1e]
2000 // CHECK: frintn s12, s13 // encoding: [0xac,0x41,0x24,0x1e]
2001 // CHECK: frintp s14, s15 // encoding: [0xee,0xc1,0x24,0x1e]
2002 // CHECK: frintm s16, s17 // encoding: [0x30,0x42,0x25,0x1e]
2003 // CHECK: frintz s18, s19 // encoding: [0x72,0xc2,0x25,0x1e]
2004 // CHECK: frinta s20, s21 // encoding: [0xb4,0x42,0x26,0x1e]
2005 // CHECK: frintx s22, s23 // encoding: [0xf6,0x42,0x27,0x1e]
2006 // CHECK: frinti s24, s25 // encoding: [0x38,0xc3,0x27,0x1e]
2021 // CHECK: fmov d0, d1 // encoding: [0x20,0x40,0x60,0x1e]
2022 // CHECK: fabs d2, d3 // encoding: [0x62,0xc0,0x60,0x1e]
2023 // CHECK: fneg d4, d5 // encoding: [0xa4,0x40,0x61,0x1e]
2024 // CHECK: fsqrt d6, d7 // encoding: [0xe6,0xc0,0x61,0x1e]
2025 // CHECK: fcvt s8, d9 // encoding: [0x28,0x41,0x62,0x1e]
2026 // CHECK: fcvt h10, d11 // encoding: [0x6a,0xc1,0x63,0x1e]
2027 // CHECK: frintn d12, d13 // encoding: [0xac,0x41,0x64,0x1e]
2028 // CHECK: frintp d14, d15 // encoding: [0xee,0xc1,0x64,0x1e]
2029 // CHECK: frintm d16, d17 // encoding: [0x30,0x42,0x65,0x1e]
2030 // CHECK: frintz d18, d19 // encoding: [0x72,0xc2,0x65,0x1e]
2031 // CHECK: frinta d20, d21 // encoding: [0xb4,0x42,0x66,0x1e]
2032 // CHECK: frintx d22, d23 // encoding: [0xf6,0x42,0x67,0x1e]
2033 // CHECK: frinti d24, d25 // encoding: [0x38,0xc3,0x67,0x1e]
2037 // CHECK: fcvt s26, h27 // encoding: [0x7a,0x43,0xe2,0x1e]
2038 // CHECK: fcvt d28, h29 // encoding: [0xbc,0xc3,0xe2,0x1e]
2040 //------------------------------------------------------------------------------
2041 // Floating-point data-processing (2 sources)
2042 //------------------------------------------------------------------------------
2050 fmaxnm s16, s17, s18
2051 fminnm s19, s20, s21
2053 // CHECK: fmul s20, s19, s17 // encoding: [0x74,0x0a,0x31,0x1e]
2054 // CHECK: fdiv s1, s2, s3 // encoding: [0x41,0x18,0x23,0x1e]
2055 // CHECK: fadd s4, s5, s6 // encoding: [0xa4,0x28,0x26,0x1e]
2056 // CHECK: fsub s7, s8, s9 // encoding: [0x07,0x39,0x29,0x1e]
2057 // CHECK: fmax s10, s11, s12 // encoding: [0x6a,0x49,0x2c,0x1e]
2058 // CHECK: fmin s13, s14, s15 // encoding: [0xcd,0x59,0x2f,0x1e]
2059 // CHECK: fmaxnm s16, s17, s18 // encoding: [0x30,0x6a,0x32,0x1e]
2060 // CHECK: fminnm s19, s20, s21 // encoding: [0x93,0x7a,0x35,0x1e]
2061 // CHECK: fnmul s22, s23, s24 // encoding: [0xf6,0x8a,0x38,0x1e]
2069 fmaxnm d16, d17, d18
2070 fminnm d19, d20, d21
2072 // CHECK: fmul d20, d19, d17 // encoding: [0x74,0x0a,0x71,0x1e]
2073 // CHECK: fdiv d1, d2, d3 // encoding: [0x41,0x18,0x63,0x1e]
2074 // CHECK: fadd d4, d5, d6 // encoding: [0xa4,0x28,0x66,0x1e]
2075 // CHECK: fsub d7, d8, d9 // encoding: [0x07,0x39,0x69,0x1e]
2076 // CHECK: fmax d10, d11, d12 // encoding: [0x6a,0x49,0x6c,0x1e]
2077 // CHECK: fmin d13, d14, d15 // encoding: [0xcd,0x59,0x6f,0x1e]
2078 // CHECK: fmaxnm d16, d17, d18 // encoding: [0x30,0x6a,0x72,0x1e]
2079 // CHECK: fminnm d19, d20, d21 // encoding: [0x93,0x7a,0x75,0x1e]
2080 // CHECK: fnmul d22, d23, d24 // encoding: [0xf6,0x8a,0x78,0x1e]
2082 //------------------------------------------------------------------------------
2083 // Floating-point data-processing (3 sources)
2084 //------------------------------------------------------------------------------
2086 fmadd s3, s5, s6, s31
2087 fmadd d3, d13, d0, d23
2088 fmsub s3, s5, s6, s31
2089 fmsub d3, d13, d0, d23
2090 fnmadd s3, s5, s6, s31
2091 fnmadd d3, d13, d0, d23
2092 fnmsub s3, s5, s6, s31
2093 fnmsub d3, d13, d0, d23
2094 // CHECK: fmadd s3, s5, s6, s31 // encoding: [0xa3,0x7c,0x06,0x1f]
2095 // CHECK: fmadd d3, d13, d0, d23 // encoding: [0xa3,0x5d,0x40,0x1f]
2096 // CHECK: fmsub s3, s5, s6, s31 // encoding: [0xa3,0xfc,0x06,0x1f]
2097 // CHECK: fmsub d3, d13, d0, d23 // encoding: [0xa3,0xdd,0x40,0x1f]
2098 // CHECK: fnmadd s3, s5, s6, s31 // encoding: [0xa3,0x7c,0x26,0x1f]
2099 // CHECK: fnmadd d3, d13, d0, d23 // encoding: [0xa3,0x5d,0x60,0x1f]
2100 // CHECK: fnmsub s3, s5, s6, s31 // encoding: [0xa3,0xfc,0x26,0x1f]
2101 // CHECK: fnmsub d3, d13, d0, d23 // encoding: [0xa3,0xdd,0x60,0x1f]
2103 //------------------------------------------------------------------------------
2104 // Floating-point <-> fixed-point conversion
2105 //------------------------------------------------------------------------------
2108 fcvtzs wzr, s20, #13
2110 // CHECK: fcvtzs w3, s5, #1 // encoding: [0xa3,0xfc,0x18,0x1e]
2111 // CHECK: fcvtzs wzr, s20, #13 // encoding: [0x9f,0xce,0x18,0x1e]
2112 // CHECK: fcvtzs w19, s0, #32 // encoding: [0x13,0x80,0x18,0x1e]
2115 fcvtzs x12, s30, #45
2117 // CHECK: fcvtzs x3, s5, #1 // encoding: [0xa3,0xfc,0x18,0x9e]
2118 // CHECK: fcvtzs x12, s30, #45 // encoding: [0xcc,0x4f,0x18,0x9e]
2119 // CHECK: fcvtzs x19, s0, #64 // encoding: [0x13,0x00,0x18,0x9e]
2122 fcvtzs wzr, d20, #13
2124 // CHECK: fcvtzs w3, d5, #1 // encoding: [0xa3,0xfc,0x58,0x1e]
2125 // CHECK: fcvtzs wzr, d20, #13 // encoding: [0x9f,0xce,0x58,0x1e]
2126 // CHECK: fcvtzs w19, d0, #32 // encoding: [0x13,0x80,0x58,0x1e]
2129 fcvtzs x12, d30, #45
2131 // CHECK: fcvtzs x3, d5, #1 // encoding: [0xa3,0xfc,0x58,0x9e]
2132 // CHECK: fcvtzs x12, d30, #45 // encoding: [0xcc,0x4f,0x58,0x9e]
2133 // CHECK: fcvtzs x19, d0, #64 // encoding: [0x13,0x00,0x58,0x9e]
2136 fcvtzu wzr, s20, #13
2138 // CHECK: fcvtzu w3, s5, #1 // encoding: [0xa3,0xfc,0x19,0x1e]
2139 // CHECK: fcvtzu wzr, s20, #13 // encoding: [0x9f,0xce,0x19,0x1e]
2140 // CHECK: fcvtzu w19, s0, #32 // encoding: [0x13,0x80,0x19,0x1e]
2143 fcvtzu x12, s30, #45
2145 // CHECK: fcvtzu x3, s5, #1 // encoding: [0xa3,0xfc,0x19,0x9e]
2146 // CHECK: fcvtzu x12, s30, #45 // encoding: [0xcc,0x4f,0x19,0x9e]
2147 // CHECK: fcvtzu x19, s0, #64 // encoding: [0x13,0x00,0x19,0x9e]
2150 fcvtzu wzr, d20, #13
2152 // CHECK: fcvtzu w3, d5, #1 // encoding: [0xa3,0xfc,0x59,0x1e]
2153 // CHECK: fcvtzu wzr, d20, #13 // encoding: [0x9f,0xce,0x59,0x1e]
2154 // CHECK: fcvtzu w19, d0, #32 // encoding: [0x13,0x80,0x59,0x1e]
2157 fcvtzu x12, d30, #45
2159 // CHECK: fcvtzu x3, d5, #1 // encoding: [0xa3,0xfc,0x59,0x9e]
2160 // CHECK: fcvtzu x12, d30, #45 // encoding: [0xcc,0x4f,0x59,0x9e]
2161 // CHECK: fcvtzu x19, d0, #64 // encoding: [0x13,0x00,0x59,0x9e]
2166 // CHECK: scvtf s23, w19, #1 // encoding: [0x77,0xfe,0x02,0x1e]
2167 // CHECK: scvtf s31, wzr, #20 // encoding: [0xff,0xb3,0x02,0x1e]
2168 // CHECK: scvtf s14, w0, #32 // encoding: [0x0e,0x80,0x02,0x1e]
2173 // CHECK: scvtf s23, x19, #1 // encoding: [0x77,0xfe,0x02,0x9e]
2174 // CHECK: scvtf s31, xzr, #20 // encoding: [0xff,0xb3,0x02,0x9e]
2175 // CHECK: scvtf s14, x0, #64 // encoding: [0x0e,0x00,0x02,0x9e]
2180 // CHECK: scvtf d23, w19, #1 // encoding: [0x77,0xfe,0x42,0x1e]
2181 // CHECK: scvtf d31, wzr, #20 // encoding: [0xff,0xb3,0x42,0x1e]
2182 // CHECK: scvtf d14, w0, #32 // encoding: [0x0e,0x80,0x42,0x1e]
2187 // CHECK: scvtf d23, x19, #1 // encoding: [0x77,0xfe,0x42,0x9e]
2188 // CHECK: scvtf d31, xzr, #20 // encoding: [0xff,0xb3,0x42,0x9e]
2189 // CHECK: scvtf d14, x0, #64 // encoding: [0x0e,0x00,0x42,0x9e]
2194 // CHECK: ucvtf s23, w19, #1 // encoding: [0x77,0xfe,0x03,0x1e]
2195 // CHECK: ucvtf s31, wzr, #20 // encoding: [0xff,0xb3,0x03,0x1e]
2196 // CHECK: ucvtf s14, w0, #32 // encoding: [0x0e,0x80,0x03,0x1e]
2201 // CHECK: ucvtf s23, x19, #1 // encoding: [0x77,0xfe,0x03,0x9e]
2202 // CHECK: ucvtf s31, xzr, #20 // encoding: [0xff,0xb3,0x03,0x9e]
2203 // CHECK: ucvtf s14, x0, #64 // encoding: [0x0e,0x00,0x03,0x9e]
2208 // CHECK: ucvtf d23, w19, #1 // encoding: [0x77,0xfe,0x43,0x1e]
2209 // CHECK: ucvtf d31, wzr, #20 // encoding: [0xff,0xb3,0x43,0x1e]
2210 // CHECK: ucvtf d14, w0, #32 // encoding: [0x0e,0x80,0x43,0x1e]
2215 // CHECK: ucvtf d23, x19, #1 // encoding: [0x77,0xfe,0x43,0x9e]
2216 // CHECK: ucvtf d31, xzr, #20 // encoding: [0xff,0xb3,0x43,0x9e]
2217 // CHECK: ucvtf d14, x0, #64 // encoding: [0x0e,0x00,0x43,0x9e]
2219 //------------------------------------------------------------------------------
2220 // Floating-point <-> integer conversion
2221 //------------------------------------------------------------------------------
2226 // CHECK: fcvtns w3, s31 // encoding: [0xe3,0x03,0x20,0x1e]
2227 // CHECK: fcvtns xzr, s12 // encoding: [0x9f,0x01,0x20,0x9e]
2228 // CHECK: fcvtnu wzr, s12 // encoding: [0x9f,0x01,0x21,0x1e]
2229 // CHECK: fcvtnu x0, s0 // encoding: [0x00,0x00,0x21,0x9e]
2235 // CHECK: fcvtps wzr, s9 // encoding: [0x3f,0x01,0x28,0x1e]
2236 // CHECK: fcvtps x12, s20 // encoding: [0x8c,0x02,0x28,0x9e]
2237 // CHECK: fcvtpu w30, s23 // encoding: [0xfe,0x02,0x29,0x1e]
2238 // CHECK: fcvtpu x29, s3 // encoding: [0x7d,0x00,0x29,0x9e]
2244 // CHECK: fcvtms w2, s3 // encoding: [0x62,0x00,0x30,0x1e]
2245 // CHECK: fcvtms x4, s5 // encoding: [0xa4,0x00,0x30,0x9e]
2246 // CHECK: fcvtmu w6, s7 // encoding: [0xe6,0x00,0x31,0x1e]
2247 // CHECK: fcvtmu x8, s9 // encoding: [0x28,0x01,0x31,0x9e]
2253 // CHECK: fcvtzs w10, s11 // encoding: [0x6a,0x01,0x38,0x1e]
2254 // CHECK: fcvtzs x12, s13 // encoding: [0xac,0x01,0x38,0x9e]
2255 // CHECK: fcvtzu w14, s15 // encoding: [0xee,0x01,0x39,0x1e]
2256 // CHECK: fcvtzu x15, s16 // encoding: [0x0f,0x02,0x39,0x9e]
2262 // CHECK: scvtf s17, w18 // encoding: [0x51,0x02,0x22,0x1e]
2263 // CHECK: scvtf s19, x20 // encoding: [0x93,0x02,0x22,0x9e]
2264 // CHECK: ucvtf s21, w22 // encoding: [0xd5,0x02,0x23,0x1e]
2265 // CHECK: scvtf s23, x24 // encoding: [0x17,0x03,0x22,0x9e]
2271 // CHECK: fcvtas w25, s26 // encoding: [0x59,0x03,0x24,0x1e]
2272 // CHECK: fcvtas x27, s28 // encoding: [0x9b,0x03,0x24,0x9e]
2273 // CHECK: fcvtau w29, s30 // encoding: [0xdd,0x03,0x25,0x1e]
2274 // CHECK: fcvtau xzr, s0 // encoding: [0x1f,0x00,0x25,0x9e]
2280 // CHECK: fcvtns w3, d31 // encoding: [0xe3,0x03,0x60,0x1e]
2281 // CHECK: fcvtns xzr, d12 // encoding: [0x9f,0x01,0x60,0x9e]
2282 // CHECK: fcvtnu wzr, d12 // encoding: [0x9f,0x01,0x61,0x1e]
2283 // CHECK: fcvtnu x0, d0 // encoding: [0x00,0x00,0x61,0x9e]
2289 // CHECK: fcvtps wzr, d9 // encoding: [0x3f,0x01,0x68,0x1e]
2290 // CHECK: fcvtps x12, d20 // encoding: [0x8c,0x02,0x68,0x9e]
2291 // CHECK: fcvtpu w30, d23 // encoding: [0xfe,0x02,0x69,0x1e]
2292 // CHECK: fcvtpu x29, d3 // encoding: [0x7d,0x00,0x69,0x9e]
2298 // CHECK: fcvtms w2, d3 // encoding: [0x62,0x00,0x70,0x1e]
2299 // CHECK: fcvtms x4, d5 // encoding: [0xa4,0x00,0x70,0x9e]
2300 // CHECK: fcvtmu w6, d7 // encoding: [0xe6,0x00,0x71,0x1e]
2301 // CHECK: fcvtmu x8, d9 // encoding: [0x28,0x01,0x71,0x9e]
2307 // CHECK: fcvtzs w10, d11 // encoding: [0x6a,0x01,0x78,0x1e]
2308 // CHECK: fcvtzs x12, d13 // encoding: [0xac,0x01,0x78,0x9e]
2309 // CHECK: fcvtzu w14, d15 // encoding: [0xee,0x01,0x79,0x1e]
2310 // CHECK: fcvtzu x15, d16 // encoding: [0x0f,0x02,0x79,0x9e]
2316 // CHECK: scvtf d17, w18 // encoding: [0x51,0x02,0x62,0x1e]
2317 // CHECK: scvtf d19, x20 // encoding: [0x93,0x02,0x62,0x9e]
2318 // CHECK: ucvtf d21, w22 // encoding: [0xd5,0x02,0x63,0x1e]
2319 // CHECK: ucvtf d23, x24 // encoding: [0x17,0x03,0x63,0x9e]
2325 // CHECK: fcvtas w25, d26 // encoding: [0x59,0x03,0x64,0x1e]
2326 // CHECK: fcvtas x27, d28 // encoding: [0x9b,0x03,0x64,0x9e]
2327 // CHECK: fcvtau w29, d30 // encoding: [0xdd,0x03,0x65,0x1e]
2328 // CHECK: fcvtau xzr, d0 // encoding: [0x1f,0x00,0x65,0x9e]
2332 // CHECK: fmov w3, s9 // encoding: [0x23,0x01,0x26,0x1e]
2333 // CHECK: fmov s9, w3 // encoding: [0x69,0x00,0x27,0x1e]
2337 // CHECK: fmov x20, d31 // encoding: [0xf4,0x03,0x66,0x9e]
2338 // CHECK: fmov d1, x15 // encoding: [0xe1,0x01,0x67,0x9e]
2343 // CHECK: fmov x3, v12.d[1] // encoding: [0x83,0x01,0xae,0x9e]
2344 // CHECK: fmov v1.d[1], x19 // encoding: [0x61,0x02,0xaf,0x9e]
2345 // CHECK: fmov v3.d[1], xzr // encoding: [0xe3,0x03,0xaf,0x9e]
2347 //------------------------------------------------------------------------------
2348 // Floating-point immediate
2349 //------------------------------------------------------------------------------
2354 // CHECK: fmov s2, #{{0.12500000|1.250*e-01}} // encoding: [0x02,0x10,0x28,0x1e]
2355 // CHECK: fmov s3, #{{1.00000000|1.0*e\+00}} // encoding: [0x03,0x10,0x2e,0x1e]
2356 // CHECK: fmov d30, #{{16.00000000|1.60*e\+01}} // encoding: [0x1e,0x10,0x66,0x1e]
2360 // CHECK: fmov s4, #{{1.06250*(e\+00)?}} // encoding: [0x04,0x30,0x2e,0x1e]
2361 // CHECK: fmov d10, #{{1.93750*(e\+00)?}} // encoding: [0x0a,0xf0,0x6f,0x1e]
2364 // CHECK: fmov s12, #{{-1.0*(e\+00)?}} // encoding: [0x0c,0x10,0x3e,0x1e]
2367 // CHECK: fmov d16, #{{8.50*(e\+00)?}} // encoding: [0x10,0x30,0x64,0x1e]
2369 //------------------------------------------------------------------------------
2370 // Load-register (literal)
2371 //------------------------------------------------------------------------------
2374 ldrsw xzr, everywhere
2375 // CHECK-AARCH64: ldr w3, here // encoding: [0x03'A',A,A,0x18'A']
2376 // CHECK-AARCH64: // fixup A - offset: 0, value: here, kind: fixup_a64_ld_prel
2377 // CHECK-AARCH64: ldr x29, there // encoding: [0x1d'A',A,A,0x58'A']
2378 // CHECK-AARCH64: // fixup A - offset: 0, value: there, kind: fixup_a64_ld_prel
2379 // CHECK-AARCH64: ldrsw xzr, everywhere // encoding: [0x1f'A',A,A,0x98'A']
2380 // CHECK-AARCH64: // fixup A - offset: 0, value: everywhere, kind: fixup_a64_ld_prel
2382 // CHECK-ARM64: ldr w3, here // encoding: [0bAAA00011,A,A,0x18]
2383 // CHECK-ARM64: // fixup A - offset: 0, value: here, kind: fixup_arm64_ldr_pcrel_imm19
2384 // CHECK-ARM64: ldr x29, there // encoding: [0bAAA11101,A,A,0x58]
2385 // CHECK-ARM64: // fixup A - offset: 0, value: there, kind: fixup_arm64_ldr_pcrel_imm19
2386 // CHECK-ARM64: ldrsw xzr, everywhere // encoding: [0bAAA11111,A,A,0x98]
2387 // CHECK-ARM64: // fixup A - offset: 0, value: everywhere, kind: fixup_arm64_ldr_pcrel_imm19
2391 ldr q0, there_must_be_a_better_way
2392 // CHECK-AARCH64: ldr s0, who_knows // encoding: [A,A,A,0x1c'A']
2393 // CHECK-AARCH64: // fixup A - offset: 0, value: who_knows, kind: fixup_a64_ld_prel
2394 // CHECK-AARCH64: ldr d0, i_dont // encoding: [A,A,A,0x5c'A']
2395 // CHECK-AARCH64: // fixup A - offset: 0, value: i_dont, kind: fixup_a64_ld_prel
2396 // CHECK-AARCH64: ldr q0, there_must_be_a_better_way // encoding: [A,A,A,0x9c'A']
2397 // CHECK-AARCH64: // fixup A - offset: 0, value: there_must_be_a_better_way, kind: fixup_a64_ld_prel
2399 // CHECK-ARM64: ldr s0, who_knows // encoding: [0bAAA00000,A,A,0x1c]
2400 // CHECK-ARM64: // fixup A - offset: 0, value: who_knows, kind: fixup_arm64_ldr_pcrel_imm19
2401 // CHECK-ARM64: ldr d0, i_dont // encoding: [0bAAA00000,A,A,0x5c]
2402 // CHECK-ARM64: // fixup A - offset: 0, value: i_dont, kind: fixup_arm64_ldr_pcrel_imm19
2403 // CHECK-ARM64: ldr q0, there_must_be_a_better_way // encoding: [0bAAA00000,A,A,0x9c]
2404 // CHECK-ARM64: // fixup A - offset: 0, value: there_must_be_a_better_way, kind: fixup_arm64_ldr_pcrel_imm19
2408 // CHECK: ldr w0, #1048572 // encoding: [0xe0,0xff,0x7f,0x18]
2409 // CHECK: ldr x10, #-1048576 // encoding: [0x0a,0x00,0x80,0x58]
2411 prfm pldl1strm, nowhere
2413 // CHECK-AARCH64: prfm pldl1strm, nowhere // encoding: [0x01'A',A,A,0xd8'A']
2414 // CHECK-AARCH64: // fixup A - offset: 0, value: nowhere, kind: fixup_a64_ld_prel
2415 // CHECK-AARCH64: prfm #22, somewhere // encoding: [0x16'A',A,A,0xd8'A']
2416 // CHECK-AARCH64: // fixup A - offset: 0, value: somewhere, kind: fixup_a64_ld_prel
2418 // CHECK-ARM64: prfm pldl1strm, nowhere // encoding: [0bAAA00001,A,A,0xd8]
2419 // CHECK-ARM64: // fixup A - offset: 0, value: nowhere, kind: fixup_arm64_ldr_pcrel_imm19
2420 // CHECK-ARM64: prfm #22, somewhere // encoding: [0bAAA10110,A,A,0xd8]
2421 // CHECK-ARM64: // fixup A - offset: 0, value: somewhere, kind: fixup_arm64_ldr_pcrel_imm19
2423 //------------------------------------------------------------------------------
2424 // Load/store exclusive
2425 //------------------------------------------------------------------------------
2427 stxrb w1, w2, [x3, #0]
2431 // CHECK: stxrb w1, w2, [x3] // encoding: [0x62,0x7c,0x01,0x08]
2432 // CHECK: stxrh w2, w3, [x4] // encoding: [0x83,0x7c,0x02,0x48]
2433 // CHECK: stxr wzr, w4, [sp] // encoding: [0xe4,0x7f,0x1f,0x88]
2434 // CHECK: stxr w5, x6, [x7] // encoding: [0xe6,0x7c,0x05,0xc8]
2440 // CHECK: ldxrb w7, [x9] // encoding: [0x27,0x7d,0x5f,0x08]
2441 // CHECK: ldxrh wzr, [x10] // encoding: [0x5f,0x7d,0x5f,0x48]
2442 // CHECK: ldxr w9, [sp] // encoding: [0xe9,0x7f,0x5f,0x88]
2443 // CHECK: ldxr x10, [x11] // encoding: [0x6a,0x7d,0x5f,0xc8]
2445 stxp w11, w12, w13, [x14]
2446 stxp wzr, x23, x14, [x15]
2447 // CHECK: stxp w11, w12, w13, [x14] // encoding: [0xcc,0x35,0x2b,0x88]
2448 // CHECK: stxp wzr, x23, x14, [x15] // encoding: [0xf7,0x39,0x3f,0xc8]
2451 ldxp x13, x14, [x15]
2452 // CHECK: ldxp w12, wzr, [sp] // encoding: [0xec,0x7f,0x7f,0x88]
2453 // CHECK: ldxp x13, x14, [x15] // encoding: [0xed,0x39,0x7f,0xc8]
2455 stlxrb w14, w15, [x16]
2456 stlxrh w15, w16, [x17,#0]
2457 stlxr wzr, w17, [sp]
2458 stlxr w18, x19, [x20]
2459 // CHECK: stlxrb w14, w15, [x16] // encoding: [0x0f,0xfe,0x0e,0x08]
2460 // CHECK: stlxrh w15, w16, [x17] // encoding: [0x30,0xfe,0x0f,0x48]
2461 // CHECK: stlxr wzr, w17, [sp] // encoding: [0xf1,0xff,0x1f,0x88]
2462 // CHECK: stlxr w18, x19, [x20] // encoding: [0x93,0xfe,0x12,0xc8]
2468 // CHECK: ldaxrb w19, [x21] // encoding: [0xb3,0xfe,0x5f,0x08]
2469 // CHECK: ldaxrh w20, [sp] // encoding: [0xf4,0xff,0x5f,0x48]
2470 // CHECK: ldaxr wzr, [x22] // encoding: [0xdf,0xfe,0x5f,0x88]
2471 // CHECK: ldaxr x21, [x23] // encoding: [0xf5,0xfe,0x5f,0xc8]
2473 stlxp wzr, w22, w23, [x24]
2474 stlxp w25, x26, x27, [sp]
2475 // CHECK: stlxp wzr, w22, w23, [x24] // encoding: [0x16,0xdf,0x3f,0x88]
2476 // CHECK: stlxp w25, x26, x27, [sp] // encoding: [0xfa,0xef,0x39,0xc8]
2478 ldaxp w26, wzr, [sp]
2479 ldaxp x27, x28, [x30]
2480 // CHECK: ldaxp w26, wzr, [sp] // encoding: [0xfa,0xff,0x7f,0x88]
2481 // CHECK: ldaxp x27, x28, [x30] // encoding: [0xdb,0xf3,0x7f,0xc8]
2487 // CHECK: stlrb w27, [sp] // encoding: [0xfb,0xff,0x9f,0x08]
2488 // CHECK: stlrh w28, [x0] // encoding: [0x1c,0xfc,0x9f,0x48]
2489 // CHECK: stlr wzr, [x1] // encoding: [0x3f,0xfc,0x9f,0x88]
2490 // CHECK: stlr x30, [x2] // encoding: [0x5e,0xfc,0x9f,0xc8]
2496 // CHECK: ldarb w29, [sp] // encoding: [0xfd,0xff,0xdf,0x08]
2497 // CHECK: ldarh w30, [x0] // encoding: [0x1e,0xfc,0xdf,0x48]
2498 // CHECK: ldar wzr, [x1] // encoding: [0x3f,0xfc,0xdf,0x88]
2499 // CHECK: ldar x1, [x2] // encoding: [0x41,0xfc,0xdf,0xc8]
2501 stlxp wzr, w22, w23, [x24,#0]
2502 // CHECK: stlxp wzr, w22, w23, [x24] // encoding: [0x16,0xdf,0x3f,0x88]
2504 //------------------------------------------------------------------------------
2505 // Load/store (unaligned immediate)
2506 //------------------------------------------------------------------------------
2509 sturh wzr, [x12, #255]
2510 stur w16, [x0, #-256]
2512 // CHECK: sturb w9, [sp] // encoding: [0xe9,0x03,0x00,0x38]
2513 // CHECK: sturh wzr, [x12, #255] // encoding: [0x9f,0xf1,0x0f,0x78]
2514 // CHECK: stur w16, [x0, #-256] // encoding: [0x10,0x00,0x10,0xb8]
2515 // CHECK: stur x28, [x14, #1] // encoding: [0xdc,0x11,0x00,0xf8]
2517 ldurb w1, [x20, #255]
2518 ldurh w20, [x1, #255]
2519 ldur w12, [sp, #255]
2520 ldur xzr, [x12, #255]
2521 // CHECK: ldurb w1, [x20, #255] // encoding: [0x81,0xf2,0x4f,0x38]
2522 // CHECK: ldurh w20, [x1, #255] // encoding: [0x34,0xf0,0x4f,0x78]
2523 // CHECK: ldur w12, [sp, #255] // encoding: [0xec,0xf3,0x4f,0xb8]
2524 // CHECK: ldur xzr, [x12, #255] // encoding: [0x9f,0xf1,0x4f,0xf8]
2526 ldursb x9, [x7, #-256]
2527 ldursh x17, [x19, #-256]
2528 ldursw x20, [x15, #-256]
2530 prfum pldl2keep, [sp, #-256]
2531 ldursb w19, [x1, #-256]
2532 ldursh w15, [x21, #-256]
2533 // CHECK: ldursb x9, [x7, #-256] // encoding: [0xe9,0x00,0x90,0x38]
2534 // CHECK: ldursh x17, [x19, #-256] // encoding: [0x71,0x02,0x90,0x78]
2535 // CHECK: ldursw x20, [x15, #-256] // encoding: [0xf4,0x01,0x90,0xb8]
2536 // CHECK: ldursw x13, [x2] // encoding: [0x4d,0x00,0x80,0xb8]
2537 // CHECK: prfum pldl2keep, [sp, #-256] // encoding: [0xe2,0x03,0x90,0xf8]
2538 // CHECK: ldursb w19, [x1, #-256] // encoding: [0x33,0x00,0xd0,0x38]
2539 // CHECK: ldursh w15, [x21, #-256] // encoding: [0xaf,0x02,0xd0,0x78]
2542 stur h12, [x12, #-1]
2543 stur s15, [x0, #255]
2546 // CHECK: stur b0, [sp, #1] // encoding: [0xe0,0x13,0x00,0x3c]
2547 // CHECK: stur h12, [x12, #-1] // encoding: [0x8c,0xf1,0x1f,0x7c]
2548 // CHECK: stur s15, [x0, #255] // encoding: [0x0f,0xf0,0x0f,0xbc]
2549 // CHECK: stur d31, [x5, #25] // encoding: [0xbf,0x90,0x01,0xfc]
2550 // CHECK: stur q9, [x5] // encoding: [0xa9,0x00,0x80,0x3c]
2553 ldur h5, [x4, #-256]
2557 // CHECK: ldur b3, [sp] // encoding: [0xe3,0x03,0x40,0x3c]
2558 // CHECK: ldur h5, [x4, #-256] // encoding: [0x85,0x00,0x50,0x7c]
2559 // CHECK: ldur s7, [x12, #-1] // encoding: [0x87,0xf1,0x5f,0xbc]
2560 // CHECK: ldur d11, [x19, #4] // encoding: [0x6b,0x42,0x40,0xfc]
2561 // CHECK: ldur q13, [x1, #2] // encoding: [0x2d,0x20,0xc0,0x3c]
2563 //------------------------------------------------------------------------------
2564 // Load/store (unsigned immediate)
2565 //------------------------------------------------------------------------------
2567 //// Basic addressing mode limits: 8 byte access
2570 ldr x30, [x12, #32760]
2572 // CHECK: ldr x0, [x0] // encoding: [0x00,0x00,0x40,0xf9]
2573 // CHECK: ldr x4, [x29] // encoding: [0xa4,0x03,0x40,0xf9]
2574 // CHECK: ldr x30, [x12, #32760] // encoding: [0x9e,0xfd,0x7f,0xf9]
2575 // CHECK: ldr x20, [sp, #8] // encoding: [0xf4,0x07,0x40,0xf9]
2577 //// Rt treats 31 as zero-register
2579 // CHECK: ldr xzr, [sp] // encoding: [0xff,0x03,0x40,0xf9]
2581 //// 4-byte load, check still 64-bit address, limits
2583 ldr w17, [sp, #16380]
2585 // CHECK: ldr w2, [sp] // encoding: [0xe2,0x03,0x40,0xb9]
2586 // CHECK: ldr w17, [sp, #16380] // encoding: [0xf1,0xff,0x7f,0xb9]
2587 // CHECK: ldr w13, [x2, #4] // encoding: [0x4d,0x04,0x40,0xb9]
2589 //// Signed 4-byte load. Limits.
2591 ldrsw x23, [sp, #16380]
2592 // CHECK: ldrsw x2, [x5, #4] // encoding: [0xa2,0x04,0x80,0xb9]
2593 // CHECK: ldrsw x23, [sp, #16380] // encoding: [0xf7,0xff,0xbf,0xb9]
2597 ldrsh w23, [x6, #8190]
2600 // CHECK: ldrh w2, [x4] // encoding: [0x82,0x00,0x40,0x79]
2601 // CHECK: ldrsh w23, [x6, #8190] // encoding: [0xd7,0xfc,0xff,0x79]
2602 // CHECK: ldrsh wzr, [sp, #2] // encoding: [0xff,0x07,0xc0,0x79]
2603 // CHECK: ldrsh x29, [x2, #2] // encoding: [0x5d,0x04,0x80,0x79]
2606 ldrb w26, [x3, #121]
2608 ldrsb w27, [sp, #4095]
2610 // CHECK: ldrb w26, [x3, #121] // encoding: [0x7a,0xe4,0x41,0x39]
2611 // CHECK: ldrb w12, [x2] // encoding: [0x4c,0x00,0x40,0x39]
2612 // CHECK: ldrsb w27, [sp, #4095] // encoding: [0xfb,0xff,0xff,0x39]
2613 // CHECK: ldrsb xzr, [x15] // encoding: [0xff,0x01,0x80,0x39]
2617 str w20, [x4, #16380]
2618 strh w20, [x10, #14]
2619 strh w17, [sp, #8190]
2620 strb w23, [x3, #4095]
2622 // CHECK: str x30, [sp] // encoding: [0xfe,0x03,0x00,0xf9]
2623 // CHECK: str w20, [x4, #16380] // encoding: [0x94,0xfc,0x3f,0xb9]
2624 // CHECK: strh w20, [x10, #14] // encoding: [0x54,0x1d,0x00,0x79]
2625 // CHECK: strh w17, [sp, #8190] // encoding: [0xf1,0xff,0x3f,0x79]
2626 // CHECK: strb w23, [x3, #4095] // encoding: [0x77,0xfc,0x3f,0x39]
2627 // CHECK: strb wzr, [x2] // encoding: [0x5f,0x00,0x00,0x39]
2630 str x15, [x5, #:lo12:sym]
2631 ldrb w15, [x5, #:lo12:sym]
2632 ldrsh x15, [x5, #:lo12:sym]
2633 ldrsw x15, [x5, #:lo12:sym]
2634 ldr x15, [x5, #:lo12:sym]
2635 ldr q3, [x2, #:lo12:sym]
2636 // CHECK-AARCH64: str x15, [x5, #:lo12:sym] // encoding: [0xaf'A',A,A,0xf9'A']
2637 // CHECK-AARCH64: // fixup A - offset: 0, value: :lo12:sym, kind: fixup_a64_ldst64_lo12
2638 // CHECK-AARCH64: ldrb w15, [x5, #:lo12:sym] // encoding: [0xaf'A',A,0x40'A',0x39'A']
2639 // CHECK-AARCH64: // fixup A - offset: 0, value: :lo12:sym, kind: fixup_a64_ldst8_lo12
2640 // CHECK-AARCH64: ldrsh x15, [x5, #:lo12:sym] // encoding: [0xaf'A',A,0x80'A',0x79'A']
2641 // CHECK-AARCH64: // fixup A - offset: 0, value: :lo12:sym, kind: fixup_a64_ldst16_lo12
2642 // CHECK-AARCH64: ldrsw x15, [x5, #:lo12:sym] // encoding: [0xaf'A',A,0x80'A',0xb9'A']
2643 // CHECK-AARCH64: // fixup A - offset: 0, value: :lo12:sym, kind: fixup_a64_ldst32_lo12
2644 // CHECK-AARCH64: ldr x15, [x5, #:lo12:sym] // encoding: [0xaf'A',A,0x40'A',0xf9'A']
2645 // CHECK-AARCH64: // fixup A - offset: 0, value: :lo12:sym, kind: fixup_a64_ldst64_lo12
2646 // CHECK-AARCH64: ldr q3, [x2, #:lo12:sym] // encoding: [0x43'A',A,0xc0'A',0x3d'A']
2647 // CHECK-AARCH64: // fixup A - offset: 0, value: :lo12:sym, kind: fixup_a64_ldst128_lo12
2649 // CHECK-ARM64: str x15, [x5, :lo12:sym] // encoding: [0xaf,0bAAAAAA00,0b00AAAAAA,0xf9]
2650 // CHECK-ARM64: // fixup A - offset: 0, value: :lo12:sym, kind: fixup_arm64_ldst_imm12_scale8
2651 // CHECK-ARM64: ldrb w15, [x5, :lo12:sym] // encoding: [0xaf,0bAAAAAA00,0b01AAAAAA,0x39]
2652 // CHECK-ARM64: // fixup A - offset: 0, value: :lo12:sym, kind: fixup_arm64_ldst_imm12_scale1
2653 // CHECK-ARM64: ldrsh x15, [x5, :lo12:sym] // encoding: [0xaf,0bAAAAAA00,0b10AAAAAA,0x79]
2654 // CHECK-ARM64: // fixup A - offset: 0, value: :lo12:sym, kind: fixup_arm64_ldst_imm12_scale2
2655 // CHECK-ARM64: ldrsw x15, [x5, :lo12:sym] // encoding: [0xaf,0bAAAAAA00,0b10AAAAAA,0xb9]
2656 // CHECK-ARM64: // fixup A - offset: 0, value: :lo12:sym, kind: fixup_arm64_ldst_imm12_scale4
2657 // CHECK-ARM64: ldr x15, [x5, :lo12:sym] // encoding: [0xaf,0bAAAAAA00,0b01AAAAAA,0xf9]
2658 // CHECK-ARM64: // fixup A - offset: 0, value: :lo12:sym, kind: fixup_arm64_ldst_imm12_scale8
2659 // CHECK-ARM64: ldr q3, [x2, :lo12:sym] // encoding: [0x43,0bAAAAAA00,0b11AAAAAA,0x3d]
2660 // CHECK-ARM64: // fixup A - offset: 0, value: :lo12:sym, kind: fixup_arm64_ldst_imm12_scale16
2662 prfm pldl1keep, [sp, #8]
2663 prfm pldl1strm, [x3]
2664 prfm pldl2keep, [x5,#16]
2665 prfm pldl2strm, [x2]
2666 prfm pldl3keep, [x5]
2667 prfm pldl3strm, [x6]
2668 prfm plil1keep, [sp, #8]
2669 prfm plil1strm, [x3]
2670 prfm plil2keep, [x5,#16]
2671 prfm plil2strm, [x2]
2672 prfm plil3keep, [x5]
2673 prfm plil3strm, [x6]
2674 prfm pstl1keep, [sp, #8]
2675 prfm pstl1strm, [x3]
2676 prfm pstl2keep, [x5,#16]
2677 prfm pstl2strm, [x2]
2678 prfm pstl3keep, [x5]
2679 prfm pstl3strm, [x6]
2681 // CHECK: prfm pldl1keep, [sp, #8] // encoding: [0xe0,0x07,0x80,0xf9]
2682 // CHECK: prfm pldl1strm, [x3{{(, #0)?}}] // encoding: [0x61,0x00,0x80,0xf9]
2683 // CHECK: prfm pldl2keep, [x5, #16] // encoding: [0xa2,0x08,0x80,0xf9]
2684 // CHECK: prfm pldl2strm, [x2{{(, #0)?}}] // encoding: [0x43,0x00,0x80,0xf9]
2685 // CHECK: prfm pldl3keep, [x5{{(, #0)?}}] // encoding: [0xa4,0x00,0x80,0xf9]
2686 // CHECK: prfm pldl3strm, [x6{{(, #0)?}}] // encoding: [0xc5,0x00,0x80,0xf9]
2687 // CHECK: prfm plil1keep, [sp, #8] // encoding: [0xe8,0x07,0x80,0xf9]
2688 // CHECK: prfm plil1strm, [x3{{(, #0)?}}] // encoding: [0x69,0x00,0x80,0xf9]
2689 // CHECK: prfm plil2keep, [x5, #16] // encoding: [0xaa,0x08,0x80,0xf9]
2690 // CHECK: prfm plil2strm, [x2{{(, #0)?}}] // encoding: [0x4b,0x00,0x80,0xf9]
2691 // CHECK: prfm plil3keep, [x5{{(, #0)?}}] // encoding: [0xac,0x00,0x80,0xf9]
2692 // CHECK: prfm plil3strm, [x6{{(, #0)?}}] // encoding: [0xcd,0x00,0x80,0xf9]
2693 // CHECK: prfm pstl1keep, [sp, #8] // encoding: [0xf0,0x07,0x80,0xf9]
2694 // CHECK: prfm pstl1strm, [x3{{(, #0)?}}] // encoding: [0x71,0x00,0x80,0xf9]
2695 // CHECK: prfm pstl2keep, [x5, #16] // encoding: [0xb2,0x08,0x80,0xf9]
2696 // CHECK: prfm pstl2strm, [x2{{(, #0)?}}] // encoding: [0x53,0x00,0x80,0xf9]
2697 // CHECK: prfm pstl3keep, [x5{{(, #0)?}}] // encoding: [0xb4,0x00,0x80,0xf9]
2698 // CHECK: prfm pstl3strm, [x6{{(, #0)?}}] // encoding: [0xd5,0x00,0x80,0xf9]
2699 // CHECK: prfm #15, [sp{{(, #0)?}}] // encoding: [0xef,0x03,0x80,0xf9]
2701 //// Floating-point versions
2703 ldr b31, [sp, #4095]
2704 ldr h20, [x2, #8190]
2705 ldr s10, [x19, #16380]
2706 ldr d3, [x10, #32760]
2707 str q12, [sp, #65520]
2708 // CHECK: ldr b31, [sp, #4095] // encoding: [0xff,0xff,0x7f,0x3d]
2709 // CHECK: ldr h20, [x2, #8190] // encoding: [0x54,0xfc,0x7f,0x7d]
2710 // CHECK: ldr s10, [x19, #16380] // encoding: [0x6a,0xfe,0x7f,0xbd]
2711 // CHECK: ldr d3, [x10, #32760] // encoding: [0x43,0xfd,0x7f,0xfd]
2712 // CHECK: str q12, [sp, #65520] // encoding: [0xec,0xff,0xbf,0x3d]
2714 //------------------------------------------------------------------------------
2715 // Load/store register (register offset)
2716 //------------------------------------------------------------------------------
2719 ldrb w9, [x27, x6, lsl #0]
2720 ldrsb w10, [x30, x7]
2721 ldrb w11, [x29, x3, sxtx]
2722 strb w12, [x28, xzr, sxtx #0]
2723 ldrb w14, [x26, w6, uxtw]
2724 ldrsb w15, [x25, w7, uxtw #0]
2725 ldrb w17, [x23, w9, sxtw]
2726 ldrsb x18, [x22, w10, sxtw #0]
2727 // CHECK: ldrb w3, [sp, x5] // encoding: [0xe3,0x6b,0x65,0x38]
2728 // CHECK: ldrb w9, [x27, x6, lsl #0] // encoding: [0x69,0x7b,0x66,0x38]
2729 // CHECK: ldrsb w10, [x30, x7] // encoding: [0xca,0x6b,0xe7,0x38]
2730 // CHECK: ldrb w11, [x29, x3, sxtx] // encoding: [0xab,0xeb,0x63,0x38]
2731 // CHECK: strb w12, [x28, xzr, sxtx #0] // encoding: [0x8c,0xfb,0x3f,0x38]
2732 // CHECK: ldrb w14, [x26, w6, uxtw] // encoding: [0x4e,0x4b,0x66,0x38]
2733 // CHECK: ldrsb w15, [x25, w7, uxtw #0] // encoding: [0x2f,0x5b,0xe7,0x38]
2734 // CHECK: ldrb w17, [x23, w9, sxtw] // encoding: [0xf1,0xca,0x69,0x38]
2735 // CHECK: ldrsb x18, [x22, w10, sxtw #0] // encoding: [0xd2,0xda,0xaa,0x38]
2738 ldrsh w9, [x27, x6, lsl #0]
2739 ldrh w10, [x30, x7, lsl #1]
2740 strh w11, [x29, x3, sxtx]
2741 ldrh w12, [x28, xzr, sxtx #0]
2742 ldrsh x13, [x27, x5, sxtx #1]
2743 ldrh w14, [x26, w6, uxtw]
2744 ldrh w15, [x25, w7, uxtw #0]
2745 ldrsh w16, [x24, w8, uxtw #1]
2746 ldrh w17, [x23, w9, sxtw]
2747 ldrh w18, [x22, w10, sxtw #0]
2748 strh w19, [x21, wzr, sxtw #1]
2749 // CHECK: ldrsh w3, [sp, x5] // encoding: [0xe3,0x6b,0xe5,0x78]
2750 // CHECK: ldrsh w9, [x27, x6] // encoding: [0x69,0x6b,0xe6,0x78]
2751 // CHECK: ldrh w10, [x30, x7, lsl #1] // encoding: [0xca,0x7b,0x67,0x78]
2752 // CHECK: strh w11, [x29, x3, sxtx] // encoding: [0xab,0xeb,0x23,0x78]
2753 // CHECK: ldrh w12, [x28, xzr, sxtx] // encoding: [0x8c,0xeb,0x7f,0x78]
2754 // CHECK: ldrsh x13, [x27, x5, sxtx #1] // encoding: [0x6d,0xfb,0xa5,0x78]
2755 // CHECK: ldrh w14, [x26, w6, uxtw] // encoding: [0x4e,0x4b,0x66,0x78]
2756 // CHECK: ldrh w15, [x25, w7, uxtw] // encoding: [0x2f,0x4b,0x67,0x78]
2757 // CHECK: ldrsh w16, [x24, w8, uxtw #1] // encoding: [0x10,0x5b,0xe8,0x78]
2758 // CHECK: ldrh w17, [x23, w9, sxtw] // encoding: [0xf1,0xca,0x69,0x78]
2759 // CHECK: ldrh w18, [x22, w10, sxtw] // encoding: [0xd2,0xca,0x6a,0x78]
2760 // CHECK: strh w19, [x21, wzr, sxtw #1] // encoding: [0xb3,0xda,0x3f,0x78]
2763 ldr s9, [x27, x6, lsl #0]
2764 ldr w10, [x30, x7, lsl #2]
2765 ldr w11, [x29, x3, sxtx]
2766 str s12, [x28, xzr, sxtx #0]
2767 str w13, [x27, x5, sxtx #2]
2768 str w14, [x26, w6, uxtw]
2769 ldr w15, [x25, w7, uxtw #0]
2770 ldr w16, [x24, w8, uxtw #2]
2771 ldrsw x17, [x23, w9, sxtw]
2772 ldr w18, [x22, w10, sxtw #0]
2773 ldrsw x19, [x21, wzr, sxtw #2]
2774 // CHECK: ldr w3, [sp, x5] // encoding: [0xe3,0x6b,0x65,0xb8]
2775 // CHECK: ldr s9, [x27, x6] // encoding: [0x69,0x6b,0x66,0xbc]
2776 // CHECK: ldr w10, [x30, x7, lsl #2] // encoding: [0xca,0x7b,0x67,0xb8]
2777 // CHECK: ldr w11, [x29, x3, sxtx] // encoding: [0xab,0xeb,0x63,0xb8]
2778 // CHECK: str s12, [x28, xzr, sxtx] // encoding: [0x8c,0xeb,0x3f,0xbc]
2779 // CHECK: str w13, [x27, x5, sxtx #2] // encoding: [0x6d,0xfb,0x25,0xb8]
2780 // CHECK: str w14, [x26, w6, uxtw] // encoding: [0x4e,0x4b,0x26,0xb8]
2781 // CHECK: ldr w15, [x25, w7, uxtw] // encoding: [0x2f,0x4b,0x67,0xb8]
2782 // CHECK: ldr w16, [x24, w8, uxtw #2] // encoding: [0x10,0x5b,0x68,0xb8]
2783 // CHECK: ldrsw x17, [x23, w9, sxtw] // encoding: [0xf1,0xca,0xa9,0xb8]
2784 // CHECK: ldr w18, [x22, w10, sxtw] // encoding: [0xd2,0xca,0x6a,0xb8]
2785 // CHECK: ldrsw x19, [x21, wzr, sxtw #2] // encoding: [0xb3,0xda,0xbf,0xb8]
2788 str x9, [x27, x6, lsl #0]
2789 ldr d10, [x30, x7, lsl #3]
2790 str x11, [x29, x3, sxtx]
2791 ldr x12, [x28, xzr, sxtx #0]
2792 ldr x13, [x27, x5, sxtx #3]
2793 prfm pldl1keep, [x26, w6, uxtw]
2794 ldr x15, [x25, w7, uxtw #0]
2795 ldr x16, [x24, w8, uxtw #3]
2796 ldr x17, [x23, w9, sxtw]
2797 ldr x18, [x22, w10, sxtw #0]
2798 str d19, [x21, wzr, sxtw #3]
2800 // CHECK: ldr x3, [sp, x5] // encoding: [0xe3,0x6b,0x65,0xf8]
2801 // CHECK: str x9, [x27, x6] // encoding: [0x69,0x6b,0x26,0xf8]
2802 // CHECK: ldr d10, [x30, x7, lsl #3] // encoding: [0xca,0x7b,0x67,0xfc]
2803 // CHECK: str x11, [x29, x3, sxtx] // encoding: [0xab,0xeb,0x23,0xf8]
2804 // CHECK: ldr x12, [x28, xzr, sxtx] // encoding: [0x8c,0xeb,0x7f,0xf8]
2805 // CHECK: ldr x13, [x27, x5, sxtx #3] // encoding: [0x6d,0xfb,0x65,0xf8]
2806 // CHECK: prfm pldl1keep, [x26, w6, uxtw] // encoding: [0x40,0x4b,0xa6,0xf8]
2807 // CHECK: ldr x15, [x25, w7, uxtw] // encoding: [0x2f,0x4b,0x67,0xf8]
2808 // CHECK: ldr x16, [x24, w8, uxtw #3] // encoding: [0x10,0x5b,0x68,0xf8]
2809 // CHECK: ldr x17, [x23, w9, sxtw] // encoding: [0xf1,0xca,0x69,0xf8]
2810 // CHECK: ldr x18, [x22, w10, sxtw] // encoding: [0xd2,0xca,0x6a,0xf8]
2811 // CHECK: str d19, [x21, wzr, sxtw #3] // encoding: [0xb3,0xda,0x3f,0xfc]
2812 // CHECK: prfm #6, [x0, x5{{(, lsl #0)?}}] // encoding: [0x06,0x68,0xa5,0xf8]
2815 ldr q9, [x27, x6, lsl #0]
2816 ldr q10, [x30, x7, lsl #4]
2817 str q11, [x29, x3, sxtx]
2818 str q12, [x28, xzr, sxtx #0]
2819 str q13, [x27, x5, sxtx #4]
2820 ldr q14, [x26, w6, uxtw]
2821 ldr q15, [x25, w7, uxtw #0]
2822 ldr q16, [x24, w8, uxtw #4]
2823 ldr q17, [x23, w9, sxtw]
2824 str q18, [x22, w10, sxtw #0]
2825 ldr q19, [x21, wzr, sxtw #4]
2826 // CHECK: ldr q3, [sp, x5] // encoding: [0xe3,0x6b,0xe5,0x3c]
2827 // CHECK: ldr q9, [x27, x6] // encoding: [0x69,0x6b,0xe6,0x3c]
2828 // CHECK: ldr q10, [x30, x7, lsl #4] // encoding: [0xca,0x7b,0xe7,0x3c]
2829 // CHECK: str q11, [x29, x3, sxtx] // encoding: [0xab,0xeb,0xa3,0x3c]
2830 // CHECK: str q12, [x28, xzr, sxtx] // encoding: [0x8c,0xeb,0xbf,0x3c]
2831 // CHECK: str q13, [x27, x5, sxtx #4] // encoding: [0x6d,0xfb,0xa5,0x3c]
2832 // CHECK: ldr q14, [x26, w6, uxtw] // encoding: [0x4e,0x4b,0xe6,0x3c]
2833 // CHECK: ldr q15, [x25, w7, uxtw] // encoding: [0x2f,0x4b,0xe7,0x3c]
2834 // CHECK: ldr q16, [x24, w8, uxtw #4] // encoding: [0x10,0x5b,0xe8,0x3c]
2835 // CHECK: ldr q17, [x23, w9, sxtw] // encoding: [0xf1,0xca,0xe9,0x3c]
2836 // CHECK: str q18, [x22, w10, sxtw] // encoding: [0xd2,0xca,0xaa,0x3c]
2837 // CHECK: ldr q19, [x21, wzr, sxtw #4] // encoding: [0xb3,0xda,0xff,0x3c]
2839 //------------------------------------------------------------------------------
2840 // Load/store register (immediate post-indexed)
2841 //------------------------------------------------------------------------------
2845 strb w10, [x3], #-256
2848 strh w10, [x3], #-256
2849 // CHECK: strb w9, [x2], #255 // encoding: [0x49,0xf4,0x0f,0x38]
2850 // CHECK: strb w10, [x3], #1 // encoding: [0x6a,0x14,0x00,0x38]
2851 // CHECK: strb w10, [x3], #-256 // encoding: [0x6a,0x04,0x10,0x38]
2852 // CHECK: strh w9, [x2], #255 // encoding: [0x49,0xf4,0x0f,0x78]
2853 // CHECK: strh w9, [x2], #1 // encoding: [0x49,0x14,0x00,0x78]
2854 // CHECK: strh w10, [x3], #-256 // encoding: [0x6a,0x04,0x10,0x78]
2858 str w21, [x12], #-256
2861 str x19, [x12], #-256
2862 // CHECK: str w19, [sp], #255 // encoding: [0xf3,0xf7,0x0f,0xb8]
2863 // CHECK: str w20, [x30], #1 // encoding: [0xd4,0x17,0x00,0xb8]
2864 // CHECK: str w21, [x12], #-256 // encoding: [0x95,0x05,0x10,0xb8]
2865 // CHECK: str xzr, [x9], #255 // encoding: [0x3f,0xf5,0x0f,0xf8]
2866 // CHECK: str x2, [x3], #1 // encoding: [0x62,0x14,0x00,0xf8]
2867 // CHECK: str x19, [x12], #-256 // encoding: [0x93,0x05,0x10,0xf8]
2871 ldrb w10, [x3], #-256
2874 ldrh w10, [x3], #-256
2875 // CHECK: ldrb w9, [x2], #255 // encoding: [0x49,0xf4,0x4f,0x38]
2876 // CHECK: ldrb w10, [x3], #1 // encoding: [0x6a,0x14,0x40,0x38]
2877 // CHECK: ldrb w10, [x3], #-256 // encoding: [0x6a,0x04,0x50,0x38]
2878 // CHECK: ldrh w9, [x2], #255 // encoding: [0x49,0xf4,0x4f,0x78]
2879 // CHECK: ldrh w9, [x2], #1 // encoding: [0x49,0x14,0x40,0x78]
2880 // CHECK: ldrh w10, [x3], #-256 // encoding: [0x6a,0x04,0x50,0x78]
2884 ldr w21, [x12], #-256
2887 ldr x19, [x12], #-256
2888 // CHECK: ldr w19, [sp], #255 // encoding: [0xf3,0xf7,0x4f,0xb8]
2889 // CHECK: ldr w20, [x30], #1 // encoding: [0xd4,0x17,0x40,0xb8]
2890 // CHECK: ldr w21, [x12], #-256 // encoding: [0x95,0x05,0x50,0xb8]
2891 // CHECK: ldr xzr, [x9], #255 // encoding: [0x3f,0xf5,0x4f,0xf8]
2892 // CHECK: ldr x2, [x3], #1 // encoding: [0x62,0x14,0x40,0xf8]
2893 // CHECK: ldr x19, [x12], #-256 // encoding: [0x93,0x05,0x50,0xf8]
2895 ldrsb xzr, [x9], #255
2897 ldrsb x19, [x12], #-256
2898 ldrsh xzr, [x9], #255
2900 ldrsh x19, [x12], #-256
2901 ldrsw xzr, [x9], #255
2903 ldrsw x19, [x12], #-256
2904 // CHECK: ldrsb xzr, [x9], #255 // encoding: [0x3f,0xf5,0x8f,0x38]
2905 // CHECK: ldrsb x2, [x3], #1 // encoding: [0x62,0x14,0x80,0x38]
2906 // CHECK: ldrsb x19, [x12], #-256 // encoding: [0x93,0x05,0x90,0x38]
2907 // CHECK: ldrsh xzr, [x9], #255 // encoding: [0x3f,0xf5,0x8f,0x78]
2908 // CHECK: ldrsh x2, [x3], #1 // encoding: [0x62,0x14,0x80,0x78]
2909 // CHECK: ldrsh x19, [x12], #-256 // encoding: [0x93,0x05,0x90,0x78]
2910 // CHECK: ldrsw xzr, [x9], #255 // encoding: [0x3f,0xf5,0x8f,0xb8]
2911 // CHECK: ldrsw x2, [x3], #1 // encoding: [0x62,0x14,0x80,0xb8]
2912 // CHECK: ldrsw x19, [x12], #-256 // encoding: [0x93,0x05,0x90,0xb8]
2914 ldrsb wzr, [x9], #255
2916 ldrsb w19, [x12], #-256
2917 ldrsh wzr, [x9], #255
2919 ldrsh w19, [x12], #-256
2920 // CHECK: ldrsb wzr, [x9], #255 // encoding: [0x3f,0xf5,0xcf,0x38]
2921 // CHECK: ldrsb w2, [x3], #1 // encoding: [0x62,0x14,0xc0,0x38]
2922 // CHECK: ldrsb w19, [x12], #-256 // encoding: [0x93,0x05,0xd0,0x38]
2923 // CHECK: ldrsh wzr, [x9], #255 // encoding: [0x3f,0xf5,0xcf,0x78]
2924 // CHECK: ldrsh w2, [x3], #1 // encoding: [0x62,0x14,0xc0,0x78]
2925 // CHECK: ldrsh w19, [x12], #-256 // encoding: [0x93,0x05,0xd0,0x78]
2930 str h10, [x10], #255
2932 str h15, [sp], #-256
2933 str s20, [x20], #255
2935 str s25, [x0], #-256
2936 str d20, [x20], #255
2938 str d25, [x0], #-256
2939 // CHECK: str b0, [x0], #255 // encoding: [0x00,0xf4,0x0f,0x3c]
2940 // CHECK: str b3, [x3], #1 // encoding: [0x63,0x14,0x00,0x3c]
2941 // CHECK: str b5, [sp], #-256 // encoding: [0xe5,0x07,0x10,0x3c]
2942 // CHECK: str h10, [x10], #255 // encoding: [0x4a,0xf5,0x0f,0x7c]
2943 // CHECK: str h13, [x23], #1 // encoding: [0xed,0x16,0x00,0x7c]
2944 // CHECK: str h15, [sp], #-256 // encoding: [0xef,0x07,0x10,0x7c]
2945 // CHECK: str s20, [x20], #255 // encoding: [0x94,0xf6,0x0f,0xbc]
2946 // CHECK: str s23, [x23], #1 // encoding: [0xf7,0x16,0x00,0xbc]
2947 // CHECK: str s25, [x0], #-256 // encoding: [0x19,0x04,0x10,0xbc]
2948 // CHECK: str d20, [x20], #255 // encoding: [0x94,0xf6,0x0f,0xfc]
2949 // CHECK: str d23, [x23], #1 // encoding: [0xf7,0x16,0x00,0xfc]
2950 // CHECK: str d25, [x0], #-256 // encoding: [0x19,0x04,0x10,0xfc]
2955 ldr h10, [x10], #255
2957 ldr h15, [sp], #-256
2958 ldr s20, [x20], #255
2960 ldr s25, [x0], #-256
2961 ldr d20, [x20], #255
2963 ldr d25, [x0], #-256
2964 // CHECK: ldr b0, [x0], #255 // encoding: [0x00,0xf4,0x4f,0x3c]
2965 // CHECK: ldr b3, [x3], #1 // encoding: [0x63,0x14,0x40,0x3c]
2966 // CHECK: ldr b5, [sp], #-256 // encoding: [0xe5,0x07,0x50,0x3c]
2967 // CHECK: ldr h10, [x10], #255 // encoding: [0x4a,0xf5,0x4f,0x7c]
2968 // CHECK: ldr h13, [x23], #1 // encoding: [0xed,0x16,0x40,0x7c]
2969 // CHECK: ldr h15, [sp], #-256 // encoding: [0xef,0x07,0x50,0x7c]
2970 // CHECK: ldr s20, [x20], #255 // encoding: [0x94,0xf6,0x4f,0xbc]
2971 // CHECK: ldr s23, [x23], #1 // encoding: [0xf7,0x16,0x40,0xbc]
2972 // CHECK: ldr s25, [x0], #-256 // encoding: [0x19,0x04,0x50,0xbc]
2973 // CHECK: ldr d20, [x20], #255 // encoding: [0x94,0xf6,0x4f,0xfc]
2974 // CHECK: ldr d23, [x23], #1 // encoding: [0xf7,0x16,0x40,0xfc]
2975 // CHECK: ldr d25, [x0], #-256 // encoding: [0x19,0x04,0x50,0xfc]
2979 ldr q25, [x20], #-256
2982 str q21, [x20], #-256
2983 // CHECK: ldr q20, [x1], #255 // encoding: [0x34,0xf4,0xcf,0x3c]
2984 // CHECK: ldr q23, [x9], #1 // encoding: [0x37,0x15,0xc0,0x3c]
2985 // CHECK: ldr q25, [x20], #-256 // encoding: [0x99,0x06,0xd0,0x3c]
2986 // CHECK: str q10, [x1], #255 // encoding: [0x2a,0xf4,0x8f,0x3c]
2987 // CHECK: str q22, [sp], #1 // encoding: [0xf6,0x17,0x80,0x3c]
2988 // CHECK: str q21, [x20], #-256 // encoding: [0x95,0x06,0x90,0x3c]
2990 //------------------------------------------------------------------------------
2991 // Load/store register (immediate pre-indexed)
2992 //------------------------------------------------------------------------------
2996 // CHECK: ldr x3, [x4, #0]! // encoding: [0x83,0x0c,0x40,0xf8]
2997 // CHECK: ldr xzr, [sp, #0]! // encoding: [0xff,0x0f,0x40,0xf8]
2999 strb w9, [x2, #255]!
3001 strb w10, [x3, #-256]!
3002 strh w9, [x2, #255]!
3004 strh w10, [x3, #-256]!
3005 // CHECK: strb w9, [x2, #255]! // encoding: [0x49,0xfc,0x0f,0x38]
3006 // CHECK: strb w10, [x3, #1]! // encoding: [0x6a,0x1c,0x00,0x38]
3007 // CHECK: strb w10, [x3, #-256]! // encoding: [0x6a,0x0c,0x10,0x38]
3008 // CHECK: strh w9, [x2, #255]! // encoding: [0x49,0xfc,0x0f,0x78]
3009 // CHECK: strh w9, [x2, #1]! // encoding: [0x49,0x1c,0x00,0x78]
3010 // CHECK: strh w10, [x3, #-256]! // encoding: [0x6a,0x0c,0x10,0x78]
3012 str w19, [sp, #255]!
3014 str w21, [x12, #-256]!
3015 str xzr, [x9, #255]!
3017 str x19, [x12, #-256]!
3018 // CHECK: str w19, [sp, #255]! // encoding: [0xf3,0xff,0x0f,0xb8]
3019 // CHECK: str w20, [x30, #1]! // encoding: [0xd4,0x1f,0x00,0xb8]
3020 // CHECK: str w21, [x12, #-256]! // encoding: [0x95,0x0d,0x10,0xb8]
3021 // CHECK: str xzr, [x9, #255]! // encoding: [0x3f,0xfd,0x0f,0xf8]
3022 // CHECK: str x2, [x3, #1]! // encoding: [0x62,0x1c,0x00,0xf8]
3023 // CHECK: str x19, [x12, #-256]! // encoding: [0x93,0x0d,0x10,0xf8]
3025 ldrb w9, [x2, #255]!
3027 ldrb w10, [x3, #-256]!
3028 ldrh w9, [x2, #255]!
3030 ldrh w10, [x3, #-256]!
3031 // CHECK: ldrb w9, [x2, #255]! // encoding: [0x49,0xfc,0x4f,0x38]
3032 // CHECK: ldrb w10, [x3, #1]! // encoding: [0x6a,0x1c,0x40,0x38]
3033 // CHECK: ldrb w10, [x3, #-256]! // encoding: [0x6a,0x0c,0x50,0x38]
3034 // CHECK: ldrh w9, [x2, #255]! // encoding: [0x49,0xfc,0x4f,0x78]
3035 // CHECK: ldrh w9, [x2, #1]! // encoding: [0x49,0x1c,0x40,0x78]
3036 // CHECK: ldrh w10, [x3, #-256]! // encoding: [0x6a,0x0c,0x50,0x78]
3038 ldr w19, [sp, #255]!
3040 ldr w21, [x12, #-256]!
3041 ldr xzr, [x9, #255]!
3043 ldr x19, [x12, #-256]!
3044 // CHECK: ldr w19, [sp, #255]! // encoding: [0xf3,0xff,0x4f,0xb8]
3045 // CHECK: ldr w20, [x30, #1]! // encoding: [0xd4,0x1f,0x40,0xb8]
3046 // CHECK: ldr w21, [x12, #-256]! // encoding: [0x95,0x0d,0x50,0xb8]
3047 // CHECK: ldr xzr, [x9, #255]! // encoding: [0x3f,0xfd,0x4f,0xf8]
3048 // CHECK: ldr x2, [x3, #1]! // encoding: [0x62,0x1c,0x40,0xf8]
3049 // CHECK: ldr x19, [x12, #-256]! // encoding: [0x93,0x0d,0x50,0xf8]
3051 ldrsb xzr, [x9, #255]!
3053 ldrsb x19, [x12, #-256]!
3054 ldrsh xzr, [x9, #255]!
3056 ldrsh x19, [x12, #-256]!
3057 ldrsw xzr, [x9, #255]!
3059 ldrsw x19, [x12, #-256]!
3060 // CHECK: ldrsb xzr, [x9, #255]! // encoding: [0x3f,0xfd,0x8f,0x38]
3061 // CHECK: ldrsb x2, [x3, #1]! // encoding: [0x62,0x1c,0x80,0x38]
3062 // CHECK: ldrsb x19, [x12, #-256]! // encoding: [0x93,0x0d,0x90,0x38]
3063 // CHECK: ldrsh xzr, [x9, #255]! // encoding: [0x3f,0xfd,0x8f,0x78]
3064 // CHECK: ldrsh x2, [x3, #1]! // encoding: [0x62,0x1c,0x80,0x78]
3065 // CHECK: ldrsh x19, [x12, #-256]! // encoding: [0x93,0x0d,0x90,0x78]
3066 // CHECK: ldrsw xzr, [x9, #255]! // encoding: [0x3f,0xfd,0x8f,0xb8]
3067 // CHECK: ldrsw x2, [x3, #1]! // encoding: [0x62,0x1c,0x80,0xb8]
3068 // CHECK: ldrsw x19, [x12, #-256]! // encoding: [0x93,0x0d,0x90,0xb8]
3070 ldrsb wzr, [x9, #255]!
3072 ldrsb w19, [x12, #-256]!
3073 ldrsh wzr, [x9, #255]!
3075 ldrsh w19, [x12, #-256]!
3076 // CHECK: ldrsb wzr, [x9, #255]! // encoding: [0x3f,0xfd,0xcf,0x38]
3077 // CHECK: ldrsb w2, [x3, #1]! // encoding: [0x62,0x1c,0xc0,0x38]
3078 // CHECK: ldrsb w19, [x12, #-256]! // encoding: [0x93,0x0d,0xd0,0x38]
3079 // CHECK: ldrsh wzr, [x9, #255]! // encoding: [0x3f,0xfd,0xcf,0x78]
3080 // CHECK: ldrsh w2, [x3, #1]! // encoding: [0x62,0x1c,0xc0,0x78]
3081 // CHECK: ldrsh w19, [x12, #-256]! // encoding: [0x93,0x0d,0xd0,0x78]
3085 str b5, [sp, #-256]!
3086 str h10, [x10, #255]!
3088 str h15, [sp, #-256]!
3089 str s20, [x20, #255]!
3091 str s25, [x0, #-256]!
3092 str d20, [x20, #255]!
3094 str d25, [x0, #-256]!
3095 // CHECK: str b0, [x0, #255]! // encoding: [0x00,0xfc,0x0f,0x3c]
3096 // CHECK: str b3, [x3, #1]! // encoding: [0x63,0x1c,0x00,0x3c]
3097 // CHECK: str b5, [sp, #-256]! // encoding: [0xe5,0x0f,0x10,0x3c]
3098 // CHECK: str h10, [x10, #255]! // encoding: [0x4a,0xfd,0x0f,0x7c]
3099 // CHECK: str h13, [x23, #1]! // encoding: [0xed,0x1e,0x00,0x7c]
3100 // CHECK: str h15, [sp, #-256]! // encoding: [0xef,0x0f,0x10,0x7c]
3101 // CHECK: str s20, [x20, #255]! // encoding: [0x94,0xfe,0x0f,0xbc]
3102 // CHECK: str s23, [x23, #1]! // encoding: [0xf7,0x1e,0x00,0xbc]
3103 // CHECK: str s25, [x0, #-256]! // encoding: [0x19,0x0c,0x10,0xbc]
3104 // CHECK: str d20, [x20, #255]! // encoding: [0x94,0xfe,0x0f,0xfc]
3105 // CHECK: str d23, [x23, #1]! // encoding: [0xf7,0x1e,0x00,0xfc]
3106 // CHECK: str d25, [x0, #-256]! // encoding: [0x19,0x0c,0x10,0xfc]
3110 ldr b5, [sp, #-256]!
3111 ldr h10, [x10, #255]!
3113 ldr h15, [sp, #-256]!
3114 ldr s20, [x20, #255]!
3116 ldr s25, [x0, #-256]!
3117 ldr d20, [x20, #255]!
3119 ldr d25, [x0, #-256]!
3120 // CHECK: ldr b0, [x0, #255]! // encoding: [0x00,0xfc,0x4f,0x3c]
3121 // CHECK: ldr b3, [x3, #1]! // encoding: [0x63,0x1c,0x40,0x3c]
3122 // CHECK: ldr b5, [sp, #-256]! // encoding: [0xe5,0x0f,0x50,0x3c]
3123 // CHECK: ldr h10, [x10, #255]! // encoding: [0x4a,0xfd,0x4f,0x7c]
3124 // CHECK: ldr h13, [x23, #1]! // encoding: [0xed,0x1e,0x40,0x7c]
3125 // CHECK: ldr h15, [sp, #-256]! // encoding: [0xef,0x0f,0x50,0x7c]
3126 // CHECK: ldr s20, [x20, #255]! // encoding: [0x94,0xfe,0x4f,0xbc]
3127 // CHECK: ldr s23, [x23, #1]! // encoding: [0xf7,0x1e,0x40,0xbc]
3128 // CHECK: ldr s25, [x0, #-256]! // encoding: [0x19,0x0c,0x50,0xbc]
3129 // CHECK: ldr d20, [x20, #255]! // encoding: [0x94,0xfe,0x4f,0xfc]
3130 // CHECK: ldr d23, [x23, #1]! // encoding: [0xf7,0x1e,0x40,0xfc]
3131 // CHECK: ldr d25, [x0, #-256]! // encoding: [0x19,0x0c,0x50,0xfc]
3133 ldr q20, [x1, #255]!
3135 ldr q25, [x20, #-256]!
3136 str q10, [x1, #255]!
3138 str q21, [x20, #-256]!
3139 // CHECK: ldr q20, [x1, #255]! // encoding: [0x34,0xfc,0xcf,0x3c]
3140 // CHECK: ldr q23, [x9, #1]! // encoding: [0x37,0x1d,0xc0,0x3c]
3141 // CHECK: ldr q25, [x20, #-256]! // encoding: [0x99,0x0e,0xd0,0x3c]
3142 // CHECK: str q10, [x1, #255]! // encoding: [0x2a,0xfc,0x8f,0x3c]
3143 // CHECK: str q22, [sp, #1]! // encoding: [0xf6,0x1f,0x80,0x3c]
3144 // CHECK: str q21, [x20, #-256]! // encoding: [0x95,0x0e,0x90,0x3c]
3146 //------------------------------------------------------------------------------
3147 // Load/store (unprivileged)
3148 //------------------------------------------------------------------------------
3151 sttrh wzr, [x12, #255]
3152 sttr w16, [x0, #-256]
3154 // CHECK: sttrb w9, [sp] // encoding: [0xe9,0x0b,0x00,0x38]
3155 // CHECK: sttrh wzr, [x12, #255] // encoding: [0x9f,0xf9,0x0f,0x78]
3156 // CHECK: sttr w16, [x0, #-256] // encoding: [0x10,0x08,0x10,0xb8]
3157 // CHECK: sttr x28, [x14, #1] // encoding: [0xdc,0x19,0x00,0xf8]
3159 ldtrb w1, [x20, #255]
3160 ldtrh w20, [x1, #255]
3161 ldtr w12, [sp, #255]
3162 ldtr xzr, [x12, #255]
3163 // CHECK: ldtrb w1, [x20, #255] // encoding: [0x81,0xfa,0x4f,0x38]
3164 // CHECK: ldtrh w20, [x1, #255] // encoding: [0x34,0xf8,0x4f,0x78]
3165 // CHECK: ldtr w12, [sp, #255] // encoding: [0xec,0xfb,0x4f,0xb8]
3166 // CHECK: ldtr xzr, [x12, #255] // encoding: [0x9f,0xf9,0x4f,0xf8]
3168 ldtrsb x9, [x7, #-256]
3169 ldtrsh x17, [x19, #-256]
3170 ldtrsw x20, [x15, #-256]
3171 ldtrsb w19, [x1, #-256]
3172 ldtrsh w15, [x21, #-256]
3173 // CHECK: ldtrsb x9, [x7, #-256] // encoding: [0xe9,0x08,0x90,0x38]
3174 // CHECK: ldtrsh x17, [x19, #-256] // encoding: [0x71,0x0a,0x90,0x78]
3175 // CHECK: ldtrsw x20, [x15, #-256] // encoding: [0xf4,0x09,0x90,0xb8]
3176 // CHECK: ldtrsb w19, [x1, #-256] // encoding: [0x33,0x08,0xd0,0x38]
3177 // CHECK: ldtrsh w15, [x21, #-256] // encoding: [0xaf,0x0a,0xd0,0x78]
3179 //------------------------------------------------------------------------------
3180 // Load/store register pair (offset)
3181 //------------------------------------------------------------------------------
3184 stp wzr, w9, [sp, #252]
3185 ldp w2, wzr, [sp, #-256]
3186 ldp w9, w10, [sp, #4]
3187 // CHECK: ldp w3, w5, [sp] // encoding: [0xe3,0x17,0x40,0x29]
3188 // CHECK: stp wzr, w9, [sp, #252] // encoding: [0xff,0xa7,0x1f,0x29]
3189 // CHECK: ldp w2, wzr, [sp, #-256] // encoding: [0xe2,0x7f,0x60,0x29]
3190 // CHECK: ldp w9, w10, [sp, #4] // encoding: [0xe9,0xab,0x40,0x29]
3192 ldpsw x9, x10, [sp, #4]
3193 ldpsw x9, x10, [x2, #-256]
3194 ldpsw x20, x30, [sp, #252]
3195 // CHECK: ldpsw x9, x10, [sp, #4] // encoding: [0xe9,0xab,0x40,0x69]
3196 // CHECK: ldpsw x9, x10, [x2, #-256] // encoding: [0x49,0x28,0x60,0x69]
3197 // CHECK: ldpsw x20, x30, [sp, #252] // encoding: [0xf4,0xfb,0x5f,0x69]
3199 ldp x21, x29, [x2, #504]
3200 ldp x22, x23, [x3, #-512]
3201 ldp x24, x25, [x4, #8]
3202 // CHECK: ldp x21, x29, [x2, #504] // encoding: [0x55,0xf4,0x5f,0xa9]
3203 // CHECK: ldp x22, x23, [x3, #-512] // encoding: [0x76,0x5c,0x60,0xa9]
3204 // CHECK: ldp x24, x25, [x4, #8] // encoding: [0x98,0xe4,0x40,0xa9]
3206 ldp s29, s28, [sp, #252]
3207 stp s27, s26, [sp, #-256]
3208 ldp s1, s2, [x3, #44]
3209 // CHECK: ldp s29, s28, [sp, #252] // encoding: [0xfd,0xf3,0x5f,0x2d]
3210 // CHECK: stp s27, s26, [sp, #-256] // encoding: [0xfb,0x6b,0x20,0x2d]
3211 // CHECK: ldp s1, s2, [x3, #44] // encoding: [0x61,0x88,0x45,0x2d]
3213 stp d3, d5, [x9, #504]
3214 stp d7, d11, [x10, #-512]
3215 ldp d2, d3, [x30, #-8]
3216 // CHECK: stp d3, d5, [x9, #504] // encoding: [0x23,0x95,0x1f,0x6d]
3217 // CHECK: stp d7, d11, [x10, #-512] // encoding: [0x47,0x2d,0x20,0x6d]
3218 // CHECK: ldp d2, d3, [x30, #-8] // encoding: [0xc2,0x8f,0x7f,0x6d]
3221 stp q17, q19, [sp, #1008]
3222 ldp q23, q29, [x1, #-1024]
3223 // CHECK: stp q3, q5, [sp] // encoding: [0xe3,0x17,0x00,0xad]
3224 // CHECK: stp q17, q19, [sp, #1008] // encoding: [0xf1,0xcf,0x1f,0xad]
3225 // CHECK: ldp q23, q29, [x1, #-1024] // encoding: [0x37,0x74,0x60,0xad]
3227 //------------------------------------------------------------------------------
3228 // Load/store register pair (post-indexed)
3229 //------------------------------------------------------------------------------
3231 ldp w3, w5, [sp], #0
3232 stp wzr, w9, [sp], #252
3233 ldp w2, wzr, [sp], #-256
3234 ldp w9, w10, [sp], #4
3235 // CHECK: ldp w3, w5, [sp], #0 // encoding: [0xe3,0x17,0xc0,0x28]
3236 // CHECK: stp wzr, w9, [sp], #252 // encoding: [0xff,0xa7,0x9f,0x28]
3237 // CHECK: ldp w2, wzr, [sp], #-256 // encoding: [0xe2,0x7f,0xe0,0x28]
3238 // CHECK: ldp w9, w10, [sp], #4 // encoding: [0xe9,0xab,0xc0,0x28]
3240 ldpsw x9, x10, [sp], #4
3241 ldpsw x9, x10, [x2], #-256
3242 ldpsw x20, x30, [sp], #252
3243 // CHECK: ldpsw x9, x10, [sp], #4 // encoding: [0xe9,0xab,0xc0,0x68]
3244 // CHECK: ldpsw x9, x10, [x2], #-256 // encoding: [0x49,0x28,0xe0,0x68]
3245 // CHECK: ldpsw x20, x30, [sp], #252 // encoding: [0xf4,0xfb,0xdf,0x68]
3247 ldp x21, x29, [x2], #504
3248 ldp x22, x23, [x3], #-512
3249 ldp x24, x25, [x4], #8
3250 // CHECK: ldp x21, x29, [x2], #504 // encoding: [0x55,0xf4,0xdf,0xa8]
3251 // CHECK: ldp x22, x23, [x3], #-512 // encoding: [0x76,0x5c,0xe0,0xa8]
3252 // CHECK: ldp x24, x25, [x4], #8 // encoding: [0x98,0xe4,0xc0,0xa8]
3254 ldp s29, s28, [sp], #252
3255 stp s27, s26, [sp], #-256
3256 ldp s1, s2, [x3], #44
3257 // CHECK: ldp s29, s28, [sp], #252 // encoding: [0xfd,0xf3,0xdf,0x2c]
3258 // CHECK: stp s27, s26, [sp], #-256 // encoding: [0xfb,0x6b,0xa0,0x2c]
3259 // CHECK: ldp s1, s2, [x3], #44 // encoding: [0x61,0x88,0xc5,0x2c]
3261 stp d3, d5, [x9], #504
3262 stp d7, d11, [x10], #-512
3263 ldp d2, d3, [x30], #-8
3264 // CHECK: stp d3, d5, [x9], #504 // encoding: [0x23,0x95,0x9f,0x6c]
3265 // CHECK: stp d7, d11, [x10], #-512 // encoding: [0x47,0x2d,0xa0,0x6c]
3266 // CHECK: ldp d2, d3, [x30], #-8 // encoding: [0xc2,0x8f,0xff,0x6c]
3268 stp q3, q5, [sp], #0
3269 stp q17, q19, [sp], #1008
3270 ldp q23, q29, [x1], #-1024
3271 // CHECK: stp q3, q5, [sp], #0 // encoding: [0xe3,0x17,0x80,0xac]
3272 // CHECK: stp q17, q19, [sp], #1008 // encoding: [0xf1,0xcf,0x9f,0xac]
3273 // CHECK: ldp q23, q29, [x1], #-1024 // encoding: [0x37,0x74,0xe0,0xac]
3275 //------------------------------------------------------------------------------
3276 // Load/store register pair (pre-indexed)
3277 //------------------------------------------------------------------------------
3278 ldp w3, w5, [sp, #0]!
3279 stp wzr, w9, [sp, #252]!
3280 ldp w2, wzr, [sp, #-256]!
3281 ldp w9, w10, [sp, #4]!
3282 // CHECK: ldp w3, w5, [sp, #0]! // encoding: [0xe3,0x17,0xc0,0x29]
3283 // CHECK: stp wzr, w9, [sp, #252]! // encoding: [0xff,0xa7,0x9f,0x29]
3284 // CHECK: ldp w2, wzr, [sp, #-256]! // encoding: [0xe2,0x7f,0xe0,0x29]
3285 // CHECK: ldp w9, w10, [sp, #4]! // encoding: [0xe9,0xab,0xc0,0x29]
3287 ldpsw x9, x10, [sp, #4]!
3288 ldpsw x9, x10, [x2, #-256]!
3289 ldpsw x20, x30, [sp, #252]!
3290 // CHECK: ldpsw x9, x10, [sp, #4]! // encoding: [0xe9,0xab,0xc0,0x69]
3291 // CHECK: ldpsw x9, x10, [x2, #-256]! // encoding: [0x49,0x28,0xe0,0x69]
3292 // CHECK: ldpsw x20, x30, [sp, #252]! // encoding: [0xf4,0xfb,0xdf,0x69]
3294 ldp x21, x29, [x2, #504]!
3295 ldp x22, x23, [x3, #-512]!
3296 ldp x24, x25, [x4, #8]!
3297 // CHECK: ldp x21, x29, [x2, #504]! // encoding: [0x55,0xf4,0xdf,0xa9]
3298 // CHECK: ldp x22, x23, [x3, #-512]! // encoding: [0x76,0x5c,0xe0,0xa9]
3299 // CHECK: ldp x24, x25, [x4, #8]! // encoding: [0x98,0xe4,0xc0,0xa9]
3301 ldp s29, s28, [sp, #252]!
3302 stp s27, s26, [sp, #-256]!
3303 ldp s1, s2, [x3, #44]!
3304 // CHECK: ldp s29, s28, [sp, #252]! // encoding: [0xfd,0xf3,0xdf,0x2d]
3305 // CHECK: stp s27, s26, [sp, #-256]! // encoding: [0xfb,0x6b,0xa0,0x2d]
3306 // CHECK: ldp s1, s2, [x3, #44]! // encoding: [0x61,0x88,0xc5,0x2d]
3308 stp d3, d5, [x9, #504]!
3309 stp d7, d11, [x10, #-512]!
3310 ldp d2, d3, [x30, #-8]!
3311 // CHECK: stp d3, d5, [x9, #504]! // encoding: [0x23,0x95,0x9f,0x6d]
3312 // CHECK: stp d7, d11, [x10, #-512]! // encoding: [0x47,0x2d,0xa0,0x6d]
3313 // CHECK: ldp d2, d3, [x30, #-8]! // encoding: [0xc2,0x8f,0xff,0x6d]
3315 stp q3, q5, [sp, #0]!
3316 stp q17, q19, [sp, #1008]!
3317 ldp q23, q29, [x1, #-1024]!
3318 // CHECK: stp q3, q5, [sp, #0]! // encoding: [0xe3,0x17,0x80,0xad]
3319 // CHECK: stp q17, q19, [sp, #1008]! // encoding: [0xf1,0xcf,0x9f,0xad]
3320 // CHECK: ldp q23, q29, [x1, #-1024]! // encoding: [0x37,0x74,0xe0,0xad]
3322 //------------------------------------------------------------------------------
3323 // Load/store non-temporal register pair (offset)
3324 //------------------------------------------------------------------------------
3327 stnp wzr, w9, [sp, #252]
3328 ldnp w2, wzr, [sp, #-256]
3329 ldnp w9, w10, [sp, #4]
3330 // CHECK: ldnp w3, w5, [sp] // encoding: [0xe3,0x17,0x40,0x28]
3331 // CHECK: stnp wzr, w9, [sp, #252] // encoding: [0xff,0xa7,0x1f,0x28]
3332 // CHECK: ldnp w2, wzr, [sp, #-256] // encoding: [0xe2,0x7f,0x60,0x28]
3333 // CHECK: ldnp w9, w10, [sp, #4] // encoding: [0xe9,0xab,0x40,0x28]
3335 ldnp x21, x29, [x2, #504]
3336 ldnp x22, x23, [x3, #-512]
3337 ldnp x24, x25, [x4, #8]
3338 // CHECK: ldnp x21, x29, [x2, #504] // encoding: [0x55,0xf4,0x5f,0xa8]
3339 // CHECK: ldnp x22, x23, [x3, #-512] // encoding: [0x76,0x5c,0x60,0xa8]
3340 // CHECK: ldnp x24, x25, [x4, #8] // encoding: [0x98,0xe4,0x40,0xa8]
3342 ldnp s29, s28, [sp, #252]
3343 stnp s27, s26, [sp, #-256]
3344 ldnp s1, s2, [x3, #44]
3345 // CHECK: ldnp s29, s28, [sp, #252] // encoding: [0xfd,0xf3,0x5f,0x2c]
3346 // CHECK: stnp s27, s26, [sp, #-256] // encoding: [0xfb,0x6b,0x20,0x2c]
3347 // CHECK: ldnp s1, s2, [x3, #44] // encoding: [0x61,0x88,0x45,0x2c]
3349 stnp d3, d5, [x9, #504]
3350 stnp d7, d11, [x10, #-512]
3351 ldnp d2, d3, [x30, #-8]
3352 // CHECK: stnp d3, d5, [x9, #504] // encoding: [0x23,0x95,0x1f,0x6c]
3353 // CHECK: stnp d7, d11, [x10, #-512] // encoding: [0x47,0x2d,0x20,0x6c]
3354 // CHECK: ldnp d2, d3, [x30, #-8] // encoding: [0xc2,0x8f,0x7f,0x6c]
3357 stnp q17, q19, [sp, #1008]
3358 ldnp q23, q29, [x1, #-1024]
3359 // CHECK: stnp q3, q5, [sp] // encoding: [0xe3,0x17,0x00,0xac]
3360 // CHECK: stnp q17, q19, [sp, #1008] // encoding: [0xf1,0xcf,0x1f,0xac]
3361 // CHECK: ldnp q23, q29, [x1, #-1024] // encoding: [0x37,0x74,0x60,0xac]
3363 //------------------------------------------------------------------------------
3364 // Logical (immediate)
3365 //------------------------------------------------------------------------------
3366 // 32 bit replication-width
3367 orr w3, w9, #0xffff0000
3368 orr wsp, w10, #0xe00000ff
3369 orr w9, w10, #0x000003ff
3370 // CHECK: orr w3, w9, #0xffff0000 // encoding: [0x23,0x3d,0x10,0x32]
3371 // CHECK: orr wsp, w10, #0xe00000ff // encoding: [0x5f,0x29,0x03,0x32]
3372 // CHECK: orr w9, w10, #0x3ff // encoding: [0x49,0x25,0x00,0x32]
3374 // 16 bit replication width
3375 and w14, w15, #0x80008000
3376 and w12, w13, #0xffc3ffc3
3377 and w11, wzr, #0x00030003
3378 // CHECK: and w14, w15, #0x80008000 // encoding: [0xee,0x81,0x01,0x12]
3379 // CHECK: and w12, w13, #0xffc3ffc3 // encoding: [0xac,0xad,0x0a,0x12]
3380 // CHECK: and w11, wzr, #0x30003 // encoding: [0xeb,0x87,0x00,0x12]
3382 // 8 bit replication width
3383 eor w3, w6, #0xe0e0e0e0
3384 eor wsp, wzr, #0x03030303
3385 eor w16, w17, #0x81818181
3386 // CHECK: eor w3, w6, #0xe0e0e0e0 // encoding: [0xc3,0xc8,0x03,0x52]
3387 // CHECK: eor wsp, wzr, #0x3030303 // encoding: [0xff,0xc7,0x00,0x52]
3388 // CHECK: eor w16, w17, #0x81818181 // encoding: [0x30,0xc6,0x01,0x52]
3390 // 4 bit replication width
3391 ands wzr, w18, #0xcccccccc
3392 ands w19, w20, #0x33333333
3393 ands w21, w22, #0x99999999
3394 // CHECK: {{ands wzr,|tst}} w18, #0xcccccccc // encoding: [0x5f,0xe6,0x02,0x72]
3395 // CHECK: ands w19, w20, #0x33333333 // encoding: [0x93,0xe6,0x00,0x72]
3396 // CHECK: ands w21, w22, #0x99999999 // encoding: [0xd5,0xe6,0x01,0x72]
3398 // 2 bit replication width
3400 tst wzr, #0x55555555
3401 // CHECK: {{ands wzr,|tst}} w3, #0xaaaaaaaa // encoding: [0x7f,0xf0,0x01,0x72]
3402 // CHECK: {{ands wzr,|tst}} wzr, #0x55555555 // encoding: [0xff,0xf3,0x00,0x72]
3404 // 64 bit replication-width
3405 eor x3, x5, #0xffffffffc000000
3406 and x9, x10, #0x00007fffffffffff
3407 orr x11, x12, #0x8000000000000fff
3408 // CHECK: eor x3, x5, #0xffffffffc000000 // encoding: [0xa3,0x84,0x66,0xd2]
3409 // CHECK: and x9, x10, #0x7fffffffffff // encoding: [0x49,0xb9,0x40,0x92]
3410 // CHECK: orr x11, x12, #0x8000000000000fff // encoding: [0x8b,0x31,0x41,0xb2]
3412 // 32 bit replication-width
3413 orr x3, x9, #0xffff0000ffff0000
3414 orr sp, x10, #0xe00000ffe00000ff
3415 orr x9, x10, #0x000003ff000003ff
3416 // CHECK: orr x3, x9, #0xffff0000ffff0000 // encoding: [0x23,0x3d,0x10,0xb2]
3417 // CHECK: orr sp, x10, #0xe00000ffe00000ff // encoding: [0x5f,0x29,0x03,0xb2]
3418 // CHECK: orr x9, x10, #0x3ff000003ff // encoding: [0x49,0x25,0x00,0xb2]
3420 // 16 bit replication-width
3421 and x14, x15, #0x8000800080008000
3422 and x12, x13, #0xffc3ffc3ffc3ffc3
3423 and x11, xzr, #0x0003000300030003
3424 // CHECK: and x14, x15, #0x8000800080008000 // encoding: [0xee,0x81,0x01,0x92]
3425 // CHECK: and x12, x13, #0xffc3ffc3ffc3ffc3 // encoding: [0xac,0xad,0x0a,0x92]
3426 // CHECK: and x11, xzr, #0x3000300030003 // encoding: [0xeb,0x87,0x00,0x92]
3428 // 8 bit replication-width
3429 eor x3, x6, #0xe0e0e0e0e0e0e0e0
3430 eor sp, xzr, #0x0303030303030303
3431 eor x16, x17, #0x8181818181818181
3432 // CHECK: eor x3, x6, #0xe0e0e0e0e0e0e0e0 // encoding: [0xc3,0xc8,0x03,0xd2]
3433 // CHECK: eor sp, xzr, #0x303030303030303 // encoding: [0xff,0xc7,0x00,0xd2]
3434 // CHECK: eor x16, x17, #0x8181818181818181 // encoding: [0x30,0xc6,0x01,0xd2]
3436 // 4 bit replication-width
3437 ands xzr, x18, #0xcccccccccccccccc
3438 ands x19, x20, #0x3333333333333333
3439 ands x21, x22, #0x9999999999999999
3440 // CHECK: {{ands xzr,|tst}} x18, #0xcccccccccccccccc // encoding: [0x5f,0xe6,0x02,0xf2]
3441 // CHECK: ands x19, x20, #0x3333333333333333 // encoding: [0x93,0xe6,0x00,0xf2]
3442 // CHECK: ands x21, x22, #0x9999999999999999 // encoding: [0xd5,0xe6,0x01,0xf2]
3444 // 2 bit replication-width
3445 tst x3, #0xaaaaaaaaaaaaaaaa
3446 tst xzr, #0x5555555555555555
3447 // CHECK: {{ands xzr,|tst}} x3, #0xaaaaaaaaaaaaaaaa // encoding: [0x7f,0xf0,0x01,0xf2]
3448 // CHECK: {{ands xzr,|tst}} xzr, #0x5555555555555555 // encoding: [0xff,0xf3,0x00,0xf2]
3451 mov x10, #0xaaaaaaaaaaaaaaaa
3452 // CHECK: orr w3, wzr, #0xf000f // encoding: [0xe3,0x8f,0x00,0x32]
3453 // CHECK: orr x10, xzr, #0xaaaaaaaaaaaaaaaa // encoding: [0xea,0xf3,0x01,0xb2]
3455 //------------------------------------------------------------------------------
3456 // Logical (shifted register)
3457 //------------------------------------------------------------------------------
3460 and w16, w15, w1, lsl #1
3461 and w9, w4, w10, lsl #31
3462 and w3, w30, w11, lsl #0
3463 and x3, x5, x7, lsl #63
3464 // CHECK: and w12, w23, w21 // encoding: [0xec,0x02,0x15,0x0a]
3465 // CHECK: and w16, w15, w1, lsl #1 // encoding: [0xf0,0x05,0x01,0x0a]
3466 // CHECK: and w9, w4, w10, lsl #31 // encoding: [0x89,0x7c,0x0a,0x0a]
3467 // CHECK: and w3, w30, w11 // encoding: [0xc3,0x03,0x0b,0x0a]
3468 // CHECK: and x3, x5, x7, lsl #63 // encoding: [0xa3,0xfc,0x07,0x8a]
3470 and x5, x14, x19, asr #4
3471 and w3, w17, w19, ror #31
3472 and w0, w2, wzr, lsr #17
3473 and w3, w30, w11, asr #0
3474 // CHECK: and x5, x14, x19, asr #4 // encoding: [0xc5,0x11,0x93,0x8a]
3475 // CHECK: and w3, w17, w19, ror #31 // encoding: [0x23,0x7e,0xd3,0x0a]
3476 // CHECK: and w0, w2, wzr, lsr #17 // encoding: [0x40,0x44,0x5f,0x0a]
3477 // CHECK: and w3, w30, w11, asr #0 // encoding: [0xc3,0x03,0x8b,0x0a]
3479 and xzr, x4, x26, lsl #0
3480 and w3, wzr, w20, ror #0
3481 and x7, x20, xzr, asr #63
3482 // CHECK: and xzr, x4, x26 // encoding: [0x9f,0x00,0x1a,0x8a]
3483 // CHECK: and w3, wzr, w20, ror #0 // encoding: [0xe3,0x03,0xd4,0x0a]
3484 // CHECK: and x7, x20, xzr, asr #63 // encoding: [0x87,0xfe,0x9f,0x8a]
3486 bic x13, x20, x14, lsl #47
3488 orr w2, w7, w0, asr #31
3489 orr x8, x9, x10, lsl #12
3490 orn x3, x5, x7, asr #0
3492 // CHECK: bic x13, x20, x14, lsl #47 // encoding: [0x8d,0xbe,0x2e,0x8a]
3493 // CHECK: bic w2, w7, w9 // encoding: [0xe2,0x00,0x29,0x0a]
3494 // CHECK: orr w2, w7, w0, asr #31 // encoding: [0xe2,0x7c,0x80,0x2a]
3495 // CHECK: orr x8, x9, x10, lsl #12 // encoding: [0x28,0x31,0x0a,0xaa]
3496 // CHECK: orn x3, x5, x7, asr #0 // encoding: [0xa3,0x00,0xa7,0xaa]
3497 // CHECK: orn w2, w5, w29 // encoding: [0xa2,0x00,0x3d,0x2a]
3499 ands w7, wzr, w9, lsl #1
3500 ands x3, x5, x20, ror #63
3501 bics w3, w5, w7, lsl #0
3502 bics x3, xzr, x3, lsl #1
3503 // CHECK: ands w7, wzr, w9, lsl #1 // encoding: [0xe7,0x07,0x09,0x6a]
3504 // CHECK: ands x3, x5, x20, ror #63 // encoding: [0xa3,0xfc,0xd4,0xea]
3505 // CHECK: bics w3, w5, w7 // encoding: [0xa3,0x00,0x27,0x6a]
3506 // CHECK: bics x3, xzr, x3, lsl #1 // encoding: [0xe3,0x07,0x23,0xea]
3510 // CHECK: tst w3, w7, lsl #31 // encoding: [0x7f,0x7c,0x07,0x6a]
3511 // CHECK: tst x2, x20, asr #0 // encoding: [0x5f,0x00,0x94,0xea]
3517 // CHECK: mov x3, x6 // encoding: [0xe3,0x03,0x06,0xaa]
3518 // CHECK: mov x3, xzr // encoding: [0xe3,0x03,0x1f,0xaa]
3519 // CHECK: mov wzr, w2 // encoding: [0xff,0x03,0x02,0x2a]
3520 // CHECK: mov w3, w5 // encoding: [0xe3,0x03,0x05,0x2a]
3522 //------------------------------------------------------------------------------
3523 // Move wide (immediate)
3524 //------------------------------------------------------------------------------
3526 movz w1, #65535, lsl #0
3527 movz w2, #0, lsl #16
3528 movn w2, #1234, lsl #0
3529 // CHECK: movz w1, #{{65535|0xffff}} // encoding: [0xe1,0xff,0x9f,0x52]
3530 // CHECK: movz w2, #0, lsl #16 // encoding: [0x02,0x00,0xa0,0x52]
3531 // CHECK: movn w2, #{{1234|0x4d2}} // encoding: [0x42,0x9a,0x80,0x12]
3533 movz x2, #1234, lsl #32
3534 movk xzr, #4321, lsl #48
3535 // CHECK: movz x2, #{{1234|0x4d2}}, lsl #32 // encoding: [0x42,0x9a,0xc0,0xd2]
3536 // CHECK: movk xzr, #{{4321|0x10e1}}, lsl #48 // encoding: [0x3f,0x1c,0xe2,0xf2]
3538 movz x2, #:abs_g0:sym
3539 movk w3, #:abs_g0_nc:sym
3540 // CHECK-AARCH64: movz x2, #:abs_g0:sym // encoding: [0x02'A',A,0x80'A',0xd2'A']
3541 // CHECK-AARCH64-NEXT: // fixup A - offset: 0, value: :abs_g0:sym, kind: fixup_a64_movw_uabs_g0
3542 // CHECK-AARCH64: movk w3, #:abs_g0_nc:sym // encoding: [0x03'A',A,0x80'A',0x72'A']
3543 // CHECK-AARCH64-NEXT: // fixup A - offset: 0, value: :abs_g0_nc:sym, kind: fixup_a64_movw_uabs_g0_nc
3545 // CHECK-ARM64: movz x2, #:abs_g0:sym // encoding: [0bAAA00010,A,0b100AAAAA,0xd2]
3546 // CHECK-ARM64-NEXT: // fixup A - offset: 0, value: :abs_g0:sym, kind: fixup_arm64_movw
3547 // CHECK-ARM64: movk w3, #:abs_g0_nc:sym // encoding: [0bAAA00011,A,0b100AAAAA,0x72]
3548 // CHECK-ARM64-NEXT: // fixup A - offset: 0, value: :abs_g0_nc:sym, kind: fixup_arm64_movw
3550 movz x4, #:abs_g1:sym
3551 movk w5, #:abs_g1_nc:sym
3552 // CHECK-AARCH64: movz x4, #:abs_g1:sym // encoding: [0x04'A',A,0xa0'A',0xd2'A']
3553 // CHECK-AARCH64-NEXT: // fixup A - offset: 0, value: :abs_g1:sym, kind: fixup_a64_movw_uabs_g1
3554 // CHECK-AARCH64: movk w5, #:abs_g1_nc:sym // encoding: [0x05'A',A,0xa0'A',0x72'A']
3555 // CHECK-AARCH64-NEXT: // fixup A - offset: 0, value: :abs_g1_nc:sym, kind: fixup_a64_movw_uabs_g1_nc
3557 // CHECK-ARM64: movz x4, #:abs_g1:sym // encoding: [0bAAA00100,A,0b101AAAAA,0xd2]
3558 // CHECK-ARM64-NEXT: // fixup A - offset: 0, value: :abs_g1:sym, kind: fixup_arm64_movw
3559 // CHECK-ARM64: movk w5, #:abs_g1_nc:sym // encoding: [0bAAA00101,A,0b101AAAAA,0x72]
3560 // CHECK-ARM64-NEXT: // fixup A - offset: 0, value: :abs_g1_nc:sym, kind: fixup_arm64_movw
3562 movz x6, #:abs_g2:sym
3563 movk x7, #:abs_g2_nc:sym
3564 // CHECK-AARCH64: movz x6, #:abs_g2:sym // encoding: [0x06'A',A,0xc0'A',0xd2'A']
3565 // CHECK-AARCH64-NEXT: // fixup A - offset: 0, value: :abs_g2:sym, kind: fixup_a64_movw_uabs_g2
3566 // CHECK-AARCH64: movk x7, #:abs_g2_nc:sym // encoding: [0x07'A',A,0xc0'A',0xf2'A']
3567 // CHECK-AARCH64-NEXT: // fixup A - offset: 0, value: :abs_g2_nc:sym, kind: fixup_a64_movw_uabs_g2_nc
3569 // CHECK-ARM64: movz x6, #:abs_g2:sym // encoding: [0bAAA00110,A,0b110AAAAA,0xd2]
3570 // CHECK-ARM64-NEXT: // fixup A - offset: 0, value: :abs_g2:sym, kind: fixup_arm64_movw
3571 // CHECK-ARM64: movk x7, #:abs_g2_nc:sym // encoding: [0bAAA00111,A,0b110AAAAA,0xf2]
3572 // CHECK-ARM64-NEXT: // fixup A - offset: 0, value: :abs_g2_nc:sym, kind: fixup_arm64_movw
3574 movz x8, #:abs_g3:sym
3575 movk x9, #:abs_g3:sym
3576 // CHECK-AARCH64: movz x8, #:abs_g3:sym // encoding: [0x08'A',A,0xe0'A',0xd2'A']
3577 // CHECK-AARCH64-NEXT: // fixup A - offset: 0, value: :abs_g3:sym, kind: fixup_a64_movw_uabs_g3
3578 // CHECK-AARCH64: movk x9, #:abs_g3:sym // encoding: [0x09'A',A,0xe0'A',0xf2'A']
3579 // CHECK-AARCH64-NEXT: // fixup A - offset: 0, value: :abs_g3:sym, kind: fixup_a64_movw_uabs_g3
3581 // CHECK-ARM64: movz x8, #:abs_g3:sym // encoding: [0bAAA01000,A,0b111AAAAA,0xd2]
3582 // CHECK-ARM64-NEXT: // fixup A - offset: 0, value: :abs_g3:sym, kind: fixup_arm64_movw
3583 // CHECK-ARM64: movk x9, #:abs_g3:sym // encoding: [0bAAA01001,A,0b111AAAAA,0xf2]
3584 // CHECK-ARM64-NEXT: // fixup A - offset: 0, value: :abs_g3:sym, kind: fixup_arm64_movw
3587 movn x30, #:abs_g0_s:sym
3588 movz x19, #:abs_g0_s:sym
3589 movn w10, #:abs_g0_s:sym
3590 movz w25, #:abs_g0_s:sym
3591 // CHECK-AARCH64: movn x30, #:abs_g0_s:sym // encoding: [0x1e'A',A,0x80'A',0x92'A']
3592 // CHECK-AARCH64-NEXT: // fixup A - offset: 0, value: :abs_g0_s:sym, kind: fixup_a64_movw_sabs_g0
3593 // CHECK-AARCH64: movz x19, #:abs_g0_s:sym // encoding: [0x13'A',A,0x80'A',0x92'A']
3594 // CHECK-AARCH64-NEXT: // fixup A - offset: 0, value: :abs_g0_s:sym, kind: fixup_a64_movw_sabs_g0
3595 // CHECK-AARCH64: movn w10, #:abs_g0_s:sym // encoding: [0x0a'A',A,0x80'A',0x12'A']
3596 // CHECK-AARCH64-NEXT: // fixup A - offset: 0, value: :abs_g0_s:sym, kind: fixup_a64_movw_sabs_g0
3597 // CHECK-AARCH64: movz w25, #:abs_g0_s:sym // encoding: [0x19'A',A,0x80'A',0x12'A']
3598 // CHECK-AARCH64-NEXT: // fixup A - offset: 0, value: :abs_g0_s:sym, kind: fixup_a64_movw_sabs_g0
3600 // CHECK-ARM64: movn x30, #:abs_g0_s:sym // encoding: [0bAAA11110,A,0b100AAAAA,0x92]
3601 // CHECK-ARM64-NEXT: // fixup A - offset: 0, value: :abs_g0_s:sym, kind: fixup_arm64_movw
3602 // CHECK-ARM64: movz x19, #:abs_g0_s:sym // encoding: [0bAAA10011,A,0b100AAAAA,0xd2]
3603 // CHECK-ARM64-NEXT: // fixup A - offset: 0, value: :abs_g0_s:sym, kind: fixup_arm64_movw
3604 // CHECK-ARM64: movn w10, #:abs_g0_s:sym // encoding: [0bAAA01010,A,0b100AAAAA,0x12]
3605 // CHECK-ARM64-NEXT: // fixup A - offset: 0, value: :abs_g0_s:sym, kind: fixup_arm64_movw
3606 // CHECK-ARM64: movz w25, #:abs_g0_s:sym // encoding: [0bAAA11001,A,0b100AAAAA,0x52]
3607 // CHECK-ARM64-NEXT: // fixup A - offset: 0, value: :abs_g0_s:sym, kind: fixup_arm64_movw
3609 movn x30, #:abs_g1_s:sym
3610 movz x19, #:abs_g1_s:sym
3611 movn w10, #:abs_g1_s:sym
3612 movz w25, #:abs_g1_s:sym
3613 // CHECK-AARCH64: movn x30, #:abs_g1_s:sym // encoding: [0x1e'A',A,0xa0'A',0x92'A']
3614 // CHECK-AARCH64-NEXT: // fixup A - offset: 0, value: :abs_g1_s:sym, kind: fixup_a64_movw_sabs_g1
3615 // CHECK-AARCH64: movz x19, #:abs_g1_s:sym // encoding: [0x13'A',A,0xa0'A',0x92'A']
3616 // CHECK-AARCH64-NEXT: // fixup A - offset: 0, value: :abs_g1_s:sym, kind: fixup_a64_movw_sabs_g1
3617 // CHECK-AARCH64: movn w10, #:abs_g1_s:sym // encoding: [0x0a'A',A,0xa0'A',0x12'A']
3618 // CHECK-AARCH64-NEXT: // fixup A - offset: 0, value: :abs_g1_s:sym, kind: fixup_a64_movw_sabs_g1
3619 // CHECK-AARCH64: movz w25, #:abs_g1_s:sym // encoding: [0x19'A',A,0xa0'A',0x12'A']
3620 // CHECK-AARCH64-NEXT: // fixup A - offset: 0, value: :abs_g1_s:sym, kind: fixup_a64_movw_sabs_g1
3622 // CHECK-ARM64: movn x30, #:abs_g1_s:sym // encoding: [0bAAA11110,A,0b101AAAAA,0x92]
3623 // CHECK-ARM64-NEXT: // fixup A - offset: 0, value: :abs_g1_s:sym, kind: fixup_arm64_movw
3624 // CHECK-ARM64: movz x19, #:abs_g1_s:sym // encoding: [0bAAA10011,A,0b101AAAAA,0xd2]
3625 // CHECK-ARM64-NEXT: // fixup A - offset: 0, value: :abs_g1_s:sym, kind: fixup_arm64_movw
3626 // CHECK-ARM64: movn w10, #:abs_g1_s:sym // encoding: [0bAAA01010,A,0b101AAAAA,0x12]
3627 // CHECK-ARM64-NEXT: // fixup A - offset: 0, value: :abs_g1_s:sym, kind: fixup_arm64_movw
3628 // CHECK-ARM64: movz w25, #:abs_g1_s:sym // encoding: [0bAAA11001,A,0b101AAAAA,0x52]
3629 // CHECK-ARM64-NEXT: // fixup A - offset: 0, value: :abs_g1_s:sym, kind: fixup_arm64_movw
3631 movn x30, #:abs_g2_s:sym
3632 movz x19, #:abs_g2_s:sym
3633 // CHECK-AARCH64: movn x30, #:abs_g2_s:sym // encoding: [0x1e'A',A,0xc0'A',0x92'A']
3634 // CHECK-AARCH64-NEXT: // fixup A - offset: 0, value: :abs_g2_s:sym, kind: fixup_a64_movw_sabs_g2
3635 // CHECK-AARCH64: movz x19, #:abs_g2_s:sym // encoding: [0x13'A',A,0xc0'A',0x92'A']
3636 // CHECK-AARCH64-NEXT: // fixup A - offset: 0, value: :abs_g2_s:sym, kind: fixup_a64_movw_sabs_g2
3638 // CHECK-ARM64: movn x30, #:abs_g2_s:sym // encoding: [0bAAA11110,A,0b110AAAAA,0x92]
3639 // CHECK-ARM64-NEXT: // fixup A - offset: 0, value: :abs_g2_s:sym, kind: fixup_arm64_movw
3640 // CHECK-ARM64: movz x19, #:abs_g2_s:sym // encoding: [0bAAA10011,A,0b110AAAAA,0xd2]
3641 // CHECK-ARM64-NEXT: // fixup A - offset: 0, value: :abs_g2_s:sym, kind: fixup_arm64_movw
3643 //------------------------------------------------------------------------------
3644 // PC-relative addressing
3645 //------------------------------------------------------------------------------
3649 // CHECK-AARCH64: adr x2, loc // encoding: [0x02'A',A,A,0x10'A']
3650 // CHECK-AARCH64: // fixup A - offset: 0, value: loc, kind: fixup_a64_adr_prel
3651 // CHECK-AARCH64: adr xzr, loc // encoding: [0x1f'A',A,A,0x10'A']
3652 // CHECK-AARCH64: // fixup A - offset: 0, value: loc, kind: fixup_a64_adr_prel
3654 // CHECK-ARM64: adr x2, loc // encoding: [0x02'A',A,A,0x10'A']
3655 // CHECK-ARM64: // fixup A - offset: 0, value: loc, kind: fixup_arm64_pcrel_adr_imm21
3656 // CHECK-ARM64: adr xzr, loc // encoding: [0x1f'A',A,A,0x10'A']
3657 // CHECK-ARM64: // fixup A - offset: 0, value: loc, kind: fixup_arm64_pcrel_adr_imm21
3660 // CHECK-AARCH64: adrp x29, loc // encoding: [0x1d'A',A,A,0x90'A']
3661 // CHECK-AARCH64: // fixup A - offset: 0, value: loc, kind: fixup_a64_adr_prel_page
3663 // CHECK-ARM64: adrp x29, loc // encoding: [0x1d'A',A,A,0x90'A']
3664 // CHECK-ARM64: // fixup A - offset: 0, value: loc, kind: fixup_arm64_pcrel_adrp_imm21
3669 // CHECK: adrp x30, #4096 // encoding: [0x1e,0x00,0x00,0xb0]
3670 // CHECK: adr x20, #0 // encoding: [0x14,0x00,0x00,0x10]
3671 // CHECK: adr x9, #-1 // encoding: [0xe9,0xff,0xff,0x70]
3672 // CHECK: adr x5, #1048575 // encoding: [0xe5,0xff,0x7f,0x70]
3676 adrp x9, #4294963200
3677 adrp x20, #-4294967296
3678 // CHECK: adr x9, #1048575 // encoding: [0xe9,0xff,0x7f,0x70]
3679 // CHECK: adr x2, #-1048576 // encoding: [0x02,0x00,0x80,0x10]
3680 // CHECK: adrp x9, #4294963200 // encoding: [0xe9,0xff,0x7f,0xf0]
3681 // CHECK: adrp x20, #-4294967296 // encoding: [0x14,0x00,0x80,0x90]
3683 //------------------------------------------------------------------------------
3685 //------------------------------------------------------------------------------
3689 // CHECK: nop // encoding: [0x1f,0x20,0x03,0xd5]
3690 // CHECK: hint #{{127|0x7f}} // encoding: [0xff,0x2f,0x03,0xd5]
3698 // CHECK: nop // encoding: [0x1f,0x20,0x03,0xd5]
3699 // CHECK: yield // encoding: [0x3f,0x20,0x03,0xd5]
3700 // CHECK: wfe // encoding: [0x5f,0x20,0x03,0xd5]
3701 // CHECK: wfi // encoding: [0x7f,0x20,0x03,0xd5]
3702 // CHECK: sev // encoding: [0x9f,0x20,0x03,0xd5]
3703 // CHECK: sevl // encoding: [0xbf,0x20,0x03,0xd5]
3709 // CHECK: clrex // encoding: [0x5f,0x3f,0x03,0xd5]
3710 // CHECK: clrex #0 // encoding: [0x5f,0x30,0x03,0xd5]
3711 // CHECK: clrex #7 // encoding: [0x5f,0x37,0x03,0xd5]
3712 // CHECK: clrex // encoding: [0x5f,0x3f,0x03,0xd5]
3729 // CHECK: dsb #0 // encoding: [0x9f,0x30,0x03,0xd5]
3730 // CHECK: dsb #12 // encoding: [0x9f,0x3c,0x03,0xd5]
3731 // CHECK: dsb sy // encoding: [0x9f,0x3f,0x03,0xd5]
3732 // CHECK: dsb oshld // encoding: [0x9f,0x31,0x03,0xd5]
3733 // CHECK: dsb oshst // encoding: [0x9f,0x32,0x03,0xd5]
3734 // CHECK: dsb osh // encoding: [0x9f,0x33,0x03,0xd5]
3735 // CHECK: dsb nshld // encoding: [0x9f,0x35,0x03,0xd5]
3736 // CHECK: dsb nshst // encoding: [0x9f,0x36,0x03,0xd5]
3737 // CHECK: dsb nsh // encoding: [0x9f,0x37,0x03,0xd5]
3738 // CHECK: dsb ishld // encoding: [0x9f,0x39,0x03,0xd5]
3739 // CHECK: dsb ishst // encoding: [0x9f,0x3a,0x03,0xd5]
3740 // CHECK: dsb ish // encoding: [0x9f,0x3b,0x03,0xd5]
3741 // CHECK: dsb ld // encoding: [0x9f,0x3d,0x03,0xd5]
3742 // CHECK: dsb st // encoding: [0x9f,0x3e,0x03,0xd5]
3743 // CHECK: dsb sy // encoding: [0x9f,0x3f,0x03,0xd5]
3760 // CHECK: dmb #0 // encoding: [0xbf,0x30,0x03,0xd5]
3761 // CHECK: dmb #12 // encoding: [0xbf,0x3c,0x03,0xd5]
3762 // CHECK: dmb sy // encoding: [0xbf,0x3f,0x03,0xd5]
3763 // CHECK: dmb oshld // encoding: [0xbf,0x31,0x03,0xd5]
3764 // CHECK: dmb oshst // encoding: [0xbf,0x32,0x03,0xd5]
3765 // CHECK: dmb osh // encoding: [0xbf,0x33,0x03,0xd5]
3766 // CHECK: dmb nshld // encoding: [0xbf,0x35,0x03,0xd5]
3767 // CHECK: dmb nshst // encoding: [0xbf,0x36,0x03,0xd5]
3768 // CHECK: dmb nsh // encoding: [0xbf,0x37,0x03,0xd5]
3769 // CHECK: dmb ishld // encoding: [0xbf,0x39,0x03,0xd5]
3770 // CHECK: dmb ishst // encoding: [0xbf,0x3a,0x03,0xd5]
3771 // CHECK: dmb ish // encoding: [0xbf,0x3b,0x03,0xd5]
3772 // CHECK: dmb ld // encoding: [0xbf,0x3d,0x03,0xd5]
3773 // CHECK: dmb st // encoding: [0xbf,0x3e,0x03,0xd5]
3774 // CHECK: dmb sy // encoding: [0xbf,0x3f,0x03,0xd5]
3779 // CHECK: isb // encoding: [0xdf,0x3f,0x03,0xd5]
3780 // CHECK: isb // encoding: [0xdf,0x3f,0x03,0xd5]
3781 // CHECK: isb #12 // encoding: [0xdf,0x3c,0x03,0xd5]
3787 // CHECK: msr {{spsel|SPSEL}}, #0 // encoding: [0xbf,0x40,0x00,0xd5]
3788 // CHECK: msr {{daifset|DAIFSET}}, #15 // encoding: [0xdf,0x4f,0x03,0xd5]
3789 // CHECK: msr {{daifclr|DAIFCLR}}, #12 // encoding: [0xff,0x4c,0x03,0xd5]
3791 sys #7, c5, c9, #7, x5
3792 sys #0, c15, c15, #2
3793 // CHECK: sys #7, c5, c9, #7, x5 // encoding: [0xe5,0x59,0x0f,0xd5]
3794 // CHECK: sys #0, c15, c15, #2 // encoding: [0x5f,0xff,0x08,0xd5]
3796 sysl x9, #7, c5, c9, #7
3797 sysl x1, #0, c15, c15, #2
3798 // CHECK: sysl x9, #7, c5, c9, #7 // encoding: [0xe9,0x59,0x2f,0xd5]
3799 // CHECK: sysl x1, #0, c15, c15, #2 // encoding: [0x41,0xff,0x28,0xd5]
3804 // CHECK: ic ialluis // encoding: [0x1f,0x71,0x08,0xd5]
3805 // CHECK: ic iallu // encoding: [0x1f,0x75,0x08,0xd5]
3806 // CHECK: ic ivau, x9 // encoding: [0x29,0x75,0x0b,0xd5]
3816 // CHECK: dc zva, x12 // encoding: [0x2c,0x74,0x0b,0xd5]
3817 // CHECK: dc ivac, xzr // encoding: [0x3f,0x76,0x08,0xd5]
3818 // CHECK: dc isw, x2 // encoding: [0x42,0x76,0x08,0xd5]
3819 // CHECK: dc cvac, x9 // encoding: [0x29,0x7a,0x0b,0xd5]
3820 // CHECK: dc csw, x10 // encoding: [0x4a,0x7a,0x08,0xd5]
3821 // CHECK: dc cvau, x0 // encoding: [0x20,0x7b,0x0b,0xd5]
3822 // CHECK: dc civac, x3 // encoding: [0x23,0x7e,0x0b,0xd5]
3823 // CHECK: dc cisw, x30 // encoding: [0x5e,0x7e,0x08,0xd5]
3837 // CHECK: at s1e1r, x19 // encoding: [0x13,0x78,0x08,0xd5]
3838 // CHECK: at s1e2r, x19 // encoding: [0x13,0x78,0x0c,0xd5]
3839 // CHECK: at s1e3r, x19 // encoding: [0x13,0x78,0x0e,0xd5]
3840 // CHECK: at s1e1w, x19 // encoding: [0x33,0x78,0x08,0xd5]
3841 // CHECK: at s1e2w, x19 // encoding: [0x33,0x78,0x0c,0xd5]
3842 // CHECK: at s1e3w, x19 // encoding: [0x33,0x78,0x0e,0xd5]
3843 // CHECK: at s1e0r, x19 // encoding: [0x53,0x78,0x08,0xd5]
3844 // CHECK: at s1e0w, x19 // encoding: [0x73,0x78,0x08,0xd5]
3845 // CHECK: at s12e1r, x20 // encoding: [0x94,0x78,0x0c,0xd5]
3846 // CHECK: at s12e1w, x20 // encoding: [0xb4,0x78,0x0c,0xd5]
3847 // CHECK: at s12e0r, x20 // encoding: [0xd4,0x78,0x0c,0xd5]
3848 // CHECK: at s12e0w, x20 // encoding: [0xf4,0x78,0x0c,0xd5]
3882 // CHECK: tlbi ipas2e1is, x4 // encoding: [0x24,0x80,0x0c,0xd5]
3883 // CHECK: tlbi ipas2le1is, x9 // encoding: [0xa9,0x80,0x0c,0xd5]
3884 // CHECK: tlbi vmalle1is // encoding: [0x1f,0x83,0x08,0xd5]
3885 // CHECK: tlbi alle2is // encoding: [0x1f,0x83,0x0c,0xd5]
3886 // CHECK: tlbi alle3is // encoding: [0x1f,0x83,0x0e,0xd5]
3887 // CHECK: tlbi vae1is, x1 // encoding: [0x21,0x83,0x08,0xd5]
3888 // CHECK: tlbi vae2is, x2 // encoding: [0x22,0x83,0x0c,0xd5]
3889 // CHECK: tlbi vae3is, x3 // encoding: [0x23,0x83,0x0e,0xd5]
3890 // CHECK: tlbi aside1is, x5 // encoding: [0x45,0x83,0x08,0xd5]
3891 // CHECK: tlbi vaae1is, x9 // encoding: [0x69,0x83,0x08,0xd5]
3892 // CHECK: tlbi alle1is // encoding: [0x9f,0x83,0x0c,0xd5]
3893 // CHECK: tlbi vale1is, x10 // encoding: [0xaa,0x83,0x08,0xd5]
3894 // CHECK: tlbi vale2is, x11 // encoding: [0xab,0x83,0x0c,0xd5]
3895 // CHECK: tlbi vale3is, x13 // encoding: [0xad,0x83,0x0e,0xd5]
3896 // CHECK: tlbi vmalls12e1is // encoding: [0xdf,0x83,0x0c,0xd5]
3897 // CHECK: tlbi vaale1is, x14 // encoding: [0xee,0x83,0x08,0xd5]
3898 // CHECK: tlbi ipas2e1, x15 // encoding: [0x2f,0x84,0x0c,0xd5]
3899 // CHECK: tlbi ipas2le1, x16 // encoding: [0xb0,0x84,0x0c,0xd5]
3900 // CHECK: tlbi vmalle1 // encoding: [0x1f,0x87,0x08,0xd5]
3901 // CHECK: tlbi alle2 // encoding: [0x1f,0x87,0x0c,0xd5]
3902 // CHECK: tlbi alle3 // encoding: [0x1f,0x87,0x0e,0xd5]
3903 // CHECK: tlbi vae1, x17 // encoding: [0x31,0x87,0x08,0xd5]
3904 // CHECK: tlbi vae2, x18 // encoding: [0x32,0x87,0x0c,0xd5]
3905 // CHECK: tlbi vae3, x19 // encoding: [0x33,0x87,0x0e,0xd5]
3906 // CHECK: tlbi aside1, x20 // encoding: [0x54,0x87,0x08,0xd5]
3907 // CHECK: tlbi vaae1, x21 // encoding: [0x75,0x87,0x08,0xd5]
3908 // CHECK: tlbi alle1 // encoding: [0x9f,0x87,0x0c,0xd5]
3909 // CHECK: tlbi vale1, x22 // encoding: [0xb6,0x87,0x08,0xd5]
3910 // CHECK: tlbi vale2, x23 // encoding: [0xb7,0x87,0x0c,0xd5]
3911 // CHECK: tlbi vale3, x24 // encoding: [0xb8,0x87,0x0e,0xd5]
3912 // CHECK: tlbi vmalls12e1 // encoding: [0xdf,0x87,0x0c,0xd5]
3913 // CHECK: tlbi vaale1, x25 // encoding: [0xf9,0x87,0x08,0xd5]
3915 msr TEECR32_EL1, x12
3916 msr OSDTRRX_EL1, x12
3917 msr MDCCINT_EL1, x12
3919 msr OSDTRTX_EL1, x12
3921 msr DBGDTRTX_EL0, x12
3923 msr DBGVCR32_EL2, x12
3924 msr DBGBVR0_EL1, x12
3925 msr DBGBVR1_EL1, x12
3926 msr DBGBVR2_EL1, x12
3927 msr DBGBVR3_EL1, x12
3928 msr DBGBVR4_EL1, x12
3929 msr DBGBVR5_EL1, x12
3930 msr DBGBVR6_EL1, x12
3931 msr DBGBVR7_EL1, x12
3932 msr DBGBVR8_EL1, x12
3933 msr DBGBVR9_EL1, x12
3934 msr DBGBVR10_EL1, x12
3935 msr DBGBVR11_EL1, x12
3936 msr DBGBVR12_EL1, x12
3937 msr DBGBVR13_EL1, x12
3938 msr DBGBVR14_EL1, x12
3939 msr DBGBVR15_EL1, x12
3940 msr DBGBCR0_EL1, x12
3941 msr DBGBCR1_EL1, x12
3942 msr DBGBCR2_EL1, x12
3943 msr DBGBCR3_EL1, x12
3944 msr DBGBCR4_EL1, x12
3945 msr DBGBCR5_EL1, x12
3946 msr DBGBCR6_EL1, x12
3947 msr DBGBCR7_EL1, x12
3948 msr DBGBCR8_EL1, x12
3949 msr DBGBCR9_EL1, x12
3950 msr DBGBCR10_EL1, x12
3951 msr DBGBCR11_EL1, x12
3952 msr DBGBCR12_EL1, x12
3953 msr DBGBCR13_EL1, x12
3954 msr DBGBCR14_EL1, x12
3955 msr DBGBCR15_EL1, x12
3956 msr DBGWVR0_EL1, x12
3957 msr DBGWVR1_EL1, x12
3958 msr DBGWVR2_EL1, x12
3959 msr DBGWVR3_EL1, x12
3960 msr DBGWVR4_EL1, x12
3961 msr DBGWVR5_EL1, x12
3962 msr DBGWVR6_EL1, x12
3963 msr DBGWVR7_EL1, x12
3964 msr DBGWVR8_EL1, x12
3965 msr DBGWVR9_EL1, x12
3966 msr DBGWVR10_EL1, x12
3967 msr DBGWVR11_EL1, x12
3968 msr DBGWVR12_EL1, x12
3969 msr DBGWVR13_EL1, x12
3970 msr DBGWVR14_EL1, x12
3971 msr DBGWVR15_EL1, x12
3972 msr DBGWCR0_EL1, x12
3973 msr DBGWCR1_EL1, x12
3974 msr DBGWCR2_EL1, x12
3975 msr DBGWCR3_EL1, x12
3976 msr DBGWCR4_EL1, x12
3977 msr DBGWCR5_EL1, x12
3978 msr DBGWCR6_EL1, x12
3979 msr DBGWCR7_EL1, x12
3980 msr DBGWCR8_EL1, x12
3981 msr DBGWCR9_EL1, x12
3982 msr DBGWCR10_EL1, x12
3983 msr DBGWCR11_EL1, x12
3984 msr DBGWCR12_EL1, x12
3985 msr DBGWCR13_EL1, x12
3986 msr DBGWCR14_EL1, x12
3987 msr DBGWCR15_EL1, x12
3988 msr TEEHBR32_EL1, x12
3991 msr DBGPRCR_EL1, x12
3992 msr DBGCLAIMSET_EL1, x12
3993 msr DBGCLAIMCLR_EL1, x12
4054 msr FPEXC32_EL2, x12
4061 msr PMCNTENSET_EL0, x12
4062 msr PMCNTENCLR_EL0, x12
4063 msr PMOVSCLR_EL0, x12
4065 msr PMCCNTR_EL0, x12
4066 msr PMXEVTYPER_EL0, x12
4067 msr PMXEVCNTR_EL0, x12
4068 msr PMUSERENR_EL0, x12
4069 msr PMINTENSET_EL1, x12
4070 msr PMINTENCLR_EL1, x12
4071 msr PMOVSSET_EL0, x12
4084 msr CONTEXTIDR_EL1, x12
4088 msr TPIDRRO_EL0, x12
4091 msr CNTVOFF_EL2, x12
4092 msr CNTKCTL_EL1, x12
4093 msr CNTHCTL_EL2, x12
4094 msr CNTP_TVAL_EL0, x12
4095 msr CNTHP_TVAL_EL2, x12
4096 msr CNTPS_TVAL_EL1, x12
4097 msr CNTP_CTL_EL0, x12
4098 msr CNTHP_CTL_EL2, x12
4099 msr CNTPS_CTL_EL1, x12
4100 msr CNTP_CVAL_EL0, x12
4101 msr CNTHP_CVAL_EL2, x12
4102 msr CNTPS_CVAL_EL1, x12
4103 msr CNTV_TVAL_EL0, x12
4104 msr CNTV_CTL_EL0, x12
4105 msr CNTV_CVAL_EL0, x12
4106 msr PMEVCNTR0_EL0, x12
4107 msr PMEVCNTR1_EL0, x12
4108 msr PMEVCNTR2_EL0, x12
4109 msr PMEVCNTR3_EL0, x12
4110 msr PMEVCNTR4_EL0, x12
4111 msr PMEVCNTR5_EL0, x12
4112 msr PMEVCNTR6_EL0, x12
4113 msr PMEVCNTR7_EL0, x12
4114 msr PMEVCNTR8_EL0, x12
4115 msr PMEVCNTR9_EL0, x12
4116 msr PMEVCNTR10_EL0, x12
4117 msr PMEVCNTR11_EL0, x12
4118 msr PMEVCNTR12_EL0, x12
4119 msr PMEVCNTR13_EL0, x12
4120 msr PMEVCNTR14_EL0, x12
4121 msr PMEVCNTR15_EL0, x12
4122 msr PMEVCNTR16_EL0, x12
4123 msr PMEVCNTR17_EL0, x12
4124 msr PMEVCNTR18_EL0, x12
4125 msr PMEVCNTR19_EL0, x12
4126 msr PMEVCNTR20_EL0, x12
4127 msr PMEVCNTR21_EL0, x12
4128 msr PMEVCNTR22_EL0, x12
4129 msr PMEVCNTR23_EL0, x12
4130 msr PMEVCNTR24_EL0, x12
4131 msr PMEVCNTR25_EL0, x12
4132 msr PMEVCNTR26_EL0, x12
4133 msr PMEVCNTR27_EL0, x12
4134 msr PMEVCNTR28_EL0, x12
4135 msr PMEVCNTR29_EL0, x12
4136 msr PMEVCNTR30_EL0, x12
4137 msr PMCCFILTR_EL0, x12
4138 msr PMEVTYPER0_EL0, x12
4139 msr PMEVTYPER1_EL0, x12
4140 msr PMEVTYPER2_EL0, x12
4141 msr PMEVTYPER3_EL0, x12
4142 msr PMEVTYPER4_EL0, x12
4143 msr PMEVTYPER5_EL0, x12
4144 msr PMEVTYPER6_EL0, x12
4145 msr PMEVTYPER7_EL0, x12
4146 msr PMEVTYPER8_EL0, x12
4147 msr PMEVTYPER9_EL0, x12
4148 msr PMEVTYPER10_EL0, x12
4149 msr PMEVTYPER11_EL0, x12
4150 msr PMEVTYPER12_EL0, x12
4151 msr PMEVTYPER13_EL0, x12
4152 msr PMEVTYPER14_EL0, x12
4153 msr PMEVTYPER15_EL0, x12
4154 msr PMEVTYPER16_EL0, x12
4155 msr PMEVTYPER17_EL0, x12
4156 msr PMEVTYPER18_EL0, x12
4157 msr PMEVTYPER19_EL0, x12
4158 msr PMEVTYPER20_EL0, x12
4159 msr PMEVTYPER21_EL0, x12
4160 msr PMEVTYPER22_EL0, x12
4161 msr PMEVTYPER23_EL0, x12
4162 msr PMEVTYPER24_EL0, x12
4163 msr PMEVTYPER25_EL0, x12
4164 msr PMEVTYPER26_EL0, x12
4165 msr PMEVTYPER27_EL0, x12
4166 msr PMEVTYPER28_EL0, x12
4167 msr PMEVTYPER29_EL0, x12
4168 msr PMEVTYPER30_EL0, x12
4169 // CHECK: msr {{teecr32_el1|TEECR32_EL1}}, x12 // encoding: [0x0c,0x00,0x12,0xd5]
4170 // CHECK: msr {{osdtrrx_el1|OSDTRRX_EL1}}, x12 // encoding: [0x4c,0x00,0x10,0xd5]
4171 // CHECK: msr {{mdccint_el1|MDCCINT_EL1}}, x12 // encoding: [0x0c,0x02,0x10,0xd5]
4172 // CHECK: msr {{mdscr_el1|MDSCR_EL1}}, x12 // encoding: [0x4c,0x02,0x10,0xd5]
4173 // CHECK: msr {{osdtrtx_el1|OSDTRTX_EL1}}, x12 // encoding: [0x4c,0x03,0x10,0xd5]
4174 // CHECK: msr {{dbgdtr_el0|DBGDTR_EL0}}, x12 // encoding: [0x0c,0x04,0x13,0xd5]
4175 // CHECK: msr {{dbgdtrtx_el0|DBGDTRTX_EL0}}, x12 // encoding: [0x0c,0x05,0x13,0xd5]
4176 // CHECK: msr {{oseccr_el1|OSECCR_EL1}}, x12 // encoding: [0x4c,0x06,0x10,0xd5]
4177 // CHECK: msr {{dbgvcr32_el2|DBGVCR32_EL2}}, x12 // encoding: [0x0c,0x07,0x14,0xd5]
4178 // CHECK: msr {{dbgbvr0_el1|DBGBVR0_EL1}}, x12 // encoding: [0x8c,0x00,0x10,0xd5]
4179 // CHECK: msr {{dbgbvr1_el1|DBGBVR1_EL1}}, x12 // encoding: [0x8c,0x01,0x10,0xd5]
4180 // CHECK: msr {{dbgbvr2_el1|DBGBVR2_EL1}}, x12 // encoding: [0x8c,0x02,0x10,0xd5]
4181 // CHECK: msr {{dbgbvr3_el1|DBGBVR3_EL1}}, x12 // encoding: [0x8c,0x03,0x10,0xd5]
4182 // CHECK: msr {{dbgbvr4_el1|DBGBVR4_EL1}}, x12 // encoding: [0x8c,0x04,0x10,0xd5]
4183 // CHECK: msr {{dbgbvr5_el1|DBGBVR5_EL1}}, x12 // encoding: [0x8c,0x05,0x10,0xd5]
4184 // CHECK: msr {{dbgbvr6_el1|DBGBVR6_EL1}}, x12 // encoding: [0x8c,0x06,0x10,0xd5]
4185 // CHECK: msr {{dbgbvr7_el1|DBGBVR7_EL1}}, x12 // encoding: [0x8c,0x07,0x10,0xd5]
4186 // CHECK: msr {{dbgbvr8_el1|DBGBVR8_EL1}}, x12 // encoding: [0x8c,0x08,0x10,0xd5]
4187 // CHECK: msr {{dbgbvr9_el1|DBGBVR9_EL1}}, x12 // encoding: [0x8c,0x09,0x10,0xd5]
4188 // CHECK: msr {{dbgbvr10_el1|DBGBVR10_EL1}}, x12 // encoding: [0x8c,0x0a,0x10,0xd5]
4189 // CHECK: msr {{dbgbvr11_el1|DBGBVR11_EL1}}, x12 // encoding: [0x8c,0x0b,0x10,0xd5]
4190 // CHECK: msr {{dbgbvr12_el1|DBGBVR12_EL1}}, x12 // encoding: [0x8c,0x0c,0x10,0xd5]
4191 // CHECK: msr {{dbgbvr13_el1|DBGBVR13_EL1}}, x12 // encoding: [0x8c,0x0d,0x10,0xd5]
4192 // CHECK: msr {{dbgbvr14_el1|DBGBVR14_EL1}}, x12 // encoding: [0x8c,0x0e,0x10,0xd5]
4193 // CHECK: msr {{dbgbvr15_el1|DBGBVR15_EL1}}, x12 // encoding: [0x8c,0x0f,0x10,0xd5]
4194 // CHECK: msr {{dbgbcr0_el1|DBGBCR0_EL1}}, x12 // encoding: [0xac,0x00,0x10,0xd5]
4195 // CHECK: msr {{dbgbcr1_el1|DBGBCR1_EL1}}, x12 // encoding: [0xac,0x01,0x10,0xd5]
4196 // CHECK: msr {{dbgbcr2_el1|DBGBCR2_EL1}}, x12 // encoding: [0xac,0x02,0x10,0xd5]
4197 // CHECK: msr {{dbgbcr3_el1|DBGBCR3_EL1}}, x12 // encoding: [0xac,0x03,0x10,0xd5]
4198 // CHECK: msr {{dbgbcr4_el1|DBGBCR4_EL1}}, x12 // encoding: [0xac,0x04,0x10,0xd5]
4199 // CHECK: msr {{dbgbcr5_el1|DBGBCR5_EL1}}, x12 // encoding: [0xac,0x05,0x10,0xd5]
4200 // CHECK: msr {{dbgbcr6_el1|DBGBCR6_EL1}}, x12 // encoding: [0xac,0x06,0x10,0xd5]
4201 // CHECK: msr {{dbgbcr7_el1|DBGBCR7_EL1}}, x12 // encoding: [0xac,0x07,0x10,0xd5]
4202 // CHECK: msr {{dbgbcr8_el1|DBGBCR8_EL1}}, x12 // encoding: [0xac,0x08,0x10,0xd5]
4203 // CHECK: msr {{dbgbcr9_el1|DBGBCR9_EL1}}, x12 // encoding: [0xac,0x09,0x10,0xd5]
4204 // CHECK: msr {{dbgbcr10_el1|DBGBCR10_EL1}}, x12 // encoding: [0xac,0x0a,0x10,0xd5]
4205 // CHECK: msr {{dbgbcr11_el1|DBGBCR11_EL1}}, x12 // encoding: [0xac,0x0b,0x10,0xd5]
4206 // CHECK: msr {{dbgbcr12_el1|DBGBCR12_EL1}}, x12 // encoding: [0xac,0x0c,0x10,0xd5]
4207 // CHECK: msr {{dbgbcr13_el1|DBGBCR13_EL1}}, x12 // encoding: [0xac,0x0d,0x10,0xd5]
4208 // CHECK: msr {{dbgbcr14_el1|DBGBCR14_EL1}}, x12 // encoding: [0xac,0x0e,0x10,0xd5]
4209 // CHECK: msr {{dbgbcr15_el1|DBGBCR15_EL1}}, x12 // encoding: [0xac,0x0f,0x10,0xd5]
4210 // CHECK: msr {{dbgwvr0_el1|DBGWVR0_EL1}}, x12 // encoding: [0xcc,0x00,0x10,0xd5]
4211 // CHECK: msr {{dbgwvr1_el1|DBGWVR1_EL1}}, x12 // encoding: [0xcc,0x01,0x10,0xd5]
4212 // CHECK: msr {{dbgwvr2_el1|DBGWVR2_EL1}}, x12 // encoding: [0xcc,0x02,0x10,0xd5]
4213 // CHECK: msr {{dbgwvr3_el1|DBGWVR3_EL1}}, x12 // encoding: [0xcc,0x03,0x10,0xd5]
4214 // CHECK: msr {{dbgwvr4_el1|DBGWVR4_EL1}}, x12 // encoding: [0xcc,0x04,0x10,0xd5]
4215 // CHECK: msr {{dbgwvr5_el1|DBGWVR5_EL1}}, x12 // encoding: [0xcc,0x05,0x10,0xd5]
4216 // CHECK: msr {{dbgwvr6_el1|DBGWVR6_EL1}}, x12 // encoding: [0xcc,0x06,0x10,0xd5]
4217 // CHECK: msr {{dbgwvr7_el1|DBGWVR7_EL1}}, x12 // encoding: [0xcc,0x07,0x10,0xd5]
4218 // CHECK: msr {{dbgwvr8_el1|DBGWVR8_EL1}}, x12 // encoding: [0xcc,0x08,0x10,0xd5]
4219 // CHECK: msr {{dbgwvr9_el1|DBGWVR9_EL1}}, x12 // encoding: [0xcc,0x09,0x10,0xd5]
4220 // CHECK: msr {{dbgwvr10_el1|DBGWVR10_EL1}}, x12 // encoding: [0xcc,0x0a,0x10,0xd5]
4221 // CHECK: msr {{dbgwvr11_el1|DBGWVR11_EL1}}, x12 // encoding: [0xcc,0x0b,0x10,0xd5]
4222 // CHECK: msr {{dbgwvr12_el1|DBGWVR12_EL1}}, x12 // encoding: [0xcc,0x0c,0x10,0xd5]
4223 // CHECK: msr {{dbgwvr13_el1|DBGWVR13_EL1}}, x12 // encoding: [0xcc,0x0d,0x10,0xd5]
4224 // CHECK: msr {{dbgwvr14_el1|DBGWVR14_EL1}}, x12 // encoding: [0xcc,0x0e,0x10,0xd5]
4225 // CHECK: msr {{dbgwvr15_el1|DBGWVR15_EL1}}, x12 // encoding: [0xcc,0x0f,0x10,0xd5]
4226 // CHECK: msr {{dbgwcr0_el1|DBGWCR0_EL1}}, x12 // encoding: [0xec,0x00,0x10,0xd5]
4227 // CHECK: msr {{dbgwcr1_el1|DBGWCR1_EL1}}, x12 // encoding: [0xec,0x01,0x10,0xd5]
4228 // CHECK: msr {{dbgwcr2_el1|DBGWCR2_EL1}}, x12 // encoding: [0xec,0x02,0x10,0xd5]
4229 // CHECK: msr {{dbgwcr3_el1|DBGWCR3_EL1}}, x12 // encoding: [0xec,0x03,0x10,0xd5]
4230 // CHECK: msr {{dbgwcr4_el1|DBGWCR4_EL1}}, x12 // encoding: [0xec,0x04,0x10,0xd5]
4231 // CHECK: msr {{dbgwcr5_el1|DBGWCR5_EL1}}, x12 // encoding: [0xec,0x05,0x10,0xd5]
4232 // CHECK: msr {{dbgwcr6_el1|DBGWCR6_EL1}}, x12 // encoding: [0xec,0x06,0x10,0xd5]
4233 // CHECK: msr {{dbgwcr7_el1|DBGWCR7_EL1}}, x12 // encoding: [0xec,0x07,0x10,0xd5]
4234 // CHECK: msr {{dbgwcr8_el1|DBGWCR8_EL1}}, x12 // encoding: [0xec,0x08,0x10,0xd5]
4235 // CHECK: msr {{dbgwcr9_el1|DBGWCR9_EL1}}, x12 // encoding: [0xec,0x09,0x10,0xd5]
4236 // CHECK: msr {{dbgwcr10_el1|DBGWCR10_EL1}}, x12 // encoding: [0xec,0x0a,0x10,0xd5]
4237 // CHECK: msr {{dbgwcr11_el1|DBGWCR11_EL1}}, x12 // encoding: [0xec,0x0b,0x10,0xd5]
4238 // CHECK: msr {{dbgwcr12_el1|DBGWCR12_EL1}}, x12 // encoding: [0xec,0x0c,0x10,0xd5]
4239 // CHECK: msr {{dbgwcr13_el1|DBGWCR13_EL1}}, x12 // encoding: [0xec,0x0d,0x10,0xd5]
4240 // CHECK: msr {{dbgwcr14_el1|DBGWCR14_EL1}}, x12 // encoding: [0xec,0x0e,0x10,0xd5]
4241 // CHECK: msr {{dbgwcr15_el1|DBGWCR15_EL1}}, x12 // encoding: [0xec,0x0f,0x10,0xd5]
4242 // CHECK: msr {{teehbr32_el1|TEEHBR32_EL1}}, x12 // encoding: [0x0c,0x10,0x12,0xd5]
4243 // CHECK: msr {{oslar_el1|OSLAR_EL1}}, x12 // encoding: [0x8c,0x10,0x10,0xd5]
4244 // CHECK: msr {{osdlr_el1|OSDLR_EL1}}, x12 // encoding: [0x8c,0x13,0x10,0xd5]
4245 // CHECK: msr {{dbgprcr_el1|DBGPRCR_EL1}}, x12 // encoding: [0x8c,0x14,0x10,0xd5]
4246 // CHECK: msr {{dbgclaimset_el1|DBGCLAIMSET_EL1}}, x12 // encoding: [0xcc,0x78,0x10,0xd5]
4247 // CHECK: msr {{dbgclaimclr_el1|DBGCLAIMCLR_EL1}}, x12 // encoding: [0xcc,0x79,0x10,0xd5]
4248 // CHECK: msr {{csselr_el1|CSSELR_EL1}}, x12 // encoding: [0x0c,0x00,0x1a,0xd5]
4249 // CHECK: msr {{vpidr_el2|VPIDR_EL2}}, x12 // encoding: [0x0c,0x00,0x1c,0xd5]
4250 // CHECK: msr {{vmpidr_el2|VMPIDR_EL2}}, x12 // encoding: [0xac,0x00,0x1c,0xd5]
4251 // CHECK: msr {{sctlr_el1|SCTLR_EL1}}, x12 // encoding: [0x0c,0x10,0x18,0xd5]
4252 // CHECK: msr {{sctlr_el2|SCTLR_EL2}}, x12 // encoding: [0x0c,0x10,0x1c,0xd5]
4253 // CHECK: msr {{sctlr_el3|SCTLR_EL3}}, x12 // encoding: [0x0c,0x10,0x1e,0xd5]
4254 // CHECK: msr {{actlr_el1|ACTLR_EL1}}, x12 // encoding: [0x2c,0x10,0x18,0xd5]
4255 // CHECK: msr {{actlr_el2|ACTLR_EL2}}, x12 // encoding: [0x2c,0x10,0x1c,0xd5]
4256 // CHECK: msr {{actlr_el3|ACTLR_EL3}}, x12 // encoding: [0x2c,0x10,0x1e,0xd5]
4257 // CHECK: msr {{cpacr_el1|CPACR_EL1}}, x12 // encoding: [0x4c,0x10,0x18,0xd5]
4258 // CHECK: msr {{hcr_el2|HCR_EL2}}, x12 // encoding: [0x0c,0x11,0x1c,0xd5]
4259 // CHECK: msr {{scr_el3|SCR_EL3}}, x12 // encoding: [0x0c,0x11,0x1e,0xd5]
4260 // CHECK: msr {{mdcr_el2|MDCR_EL2}}, x12 // encoding: [0x2c,0x11,0x1c,0xd5]
4261 // CHECK: msr {{sder32_el3|SDER32_EL3}}, x12 // encoding: [0x2c,0x11,0x1e,0xd5]
4262 // CHECK: msr {{cptr_el2|CPTR_EL2}}, x12 // encoding: [0x4c,0x11,0x1c,0xd5]
4263 // CHECK: msr {{cptr_el3|CPTR_EL3}}, x12 // encoding: [0x4c,0x11,0x1e,0xd5]
4264 // CHECK: msr {{hstr_el2|HSTR_EL2}}, x12 // encoding: [0x6c,0x11,0x1c,0xd5]
4265 // CHECK: msr {{hacr_el2|HACR_EL2}}, x12 // encoding: [0xec,0x11,0x1c,0xd5]
4266 // CHECK: msr {{mdcr_el3|MDCR_EL3}}, x12 // encoding: [0x2c,0x13,0x1e,0xd5]
4267 // CHECK: msr {{ttbr0_el1|TTBR0_EL1}}, x12 // encoding: [0x0c,0x20,0x18,0xd5]
4268 // CHECK: msr {{ttbr0_el2|TTBR0_EL2}}, x12 // encoding: [0x0c,0x20,0x1c,0xd5]
4269 // CHECK: msr {{ttbr0_el3|TTBR0_EL3}}, x12 // encoding: [0x0c,0x20,0x1e,0xd5]
4270 // CHECK: msr {{ttbr1_el1|TTBR1_EL1}}, x12 // encoding: [0x2c,0x20,0x18,0xd5]
4271 // CHECK: msr {{tcr_el1|TCR_EL1}}, x12 // encoding: [0x4c,0x20,0x18,0xd5]
4272 // CHECK: msr {{tcr_el2|TCR_EL2}}, x12 // encoding: [0x4c,0x20,0x1c,0xd5]
4273 // CHECK: msr {{tcr_el3|TCR_EL3}}, x12 // encoding: [0x4c,0x20,0x1e,0xd5]
4274 // CHECK: msr {{vttbr_el2|VTTBR_EL2}}, x12 // encoding: [0x0c,0x21,0x1c,0xd5]
4275 // CHECK: msr {{vtcr_el2|VTCR_EL2}}, x12 // encoding: [0x4c,0x21,0x1c,0xd5]
4276 // CHECK: msr {{dacr32_el2|DACR32_EL2}}, x12 // encoding: [0x0c,0x30,0x1c,0xd5]
4277 // CHECK: msr {{spsr_el1|SPSR_EL1}}, x12 // encoding: [0x0c,0x40,0x18,0xd5]
4278 // CHECK: msr {{spsr_el2|SPSR_EL2}}, x12 // encoding: [0x0c,0x40,0x1c,0xd5]
4279 // CHECK: msr {{spsr_el3|SPSR_EL3}}, x12 // encoding: [0x0c,0x40,0x1e,0xd5]
4280 // CHECK: msr {{elr_el1|ELR_EL1}}, x12 // encoding: [0x2c,0x40,0x18,0xd5]
4281 // CHECK: msr {{elr_el2|ELR_EL2}}, x12 // encoding: [0x2c,0x40,0x1c,0xd5]
4282 // CHECK: msr {{elr_el3|ELR_EL3}}, x12 // encoding: [0x2c,0x40,0x1e,0xd5]
4283 // CHECK: msr {{sp_el0|SP_EL0}}, x12 // encoding: [0x0c,0x41,0x18,0xd5]
4284 // CHECK: msr {{sp_el1|SP_EL1}}, x12 // encoding: [0x0c,0x41,0x1c,0xd5]
4285 // CHECK: msr {{sp_el2|SP_EL2}}, x12 // encoding: [0x0c,0x41,0x1e,0xd5]
4286 // CHECK: msr {{spsel|SPSEL}}, x12 // encoding: [0x0c,0x42,0x18,0xd5]
4287 // CHECK: msr {{nzcv|NZCV}}, x12 // encoding: [0x0c,0x42,0x1b,0xd5]
4288 // CHECK: msr {{daif|DAIF}}, x12 // encoding: [0x2c,0x42,0x1b,0xd5]
4289 // CHECK: msr {{currentel|CURRENTEL}}, x12 // encoding: [0x4c,0x42,0x18,0xd5]
4290 // CHECK: msr {{spsr_irq|SPSR_IRQ}}, x12 // encoding: [0x0c,0x43,0x1c,0xd5]
4291 // CHECK: msr {{spsr_abt|SPSR_ABT}}, x12 // encoding: [0x2c,0x43,0x1c,0xd5]
4292 // CHECK: msr {{spsr_und|SPSR_UND}}, x12 // encoding: [0x4c,0x43,0x1c,0xd5]
4293 // CHECK: msr {{spsr_fiq|SPSR_FIQ}}, x12 // encoding: [0x6c,0x43,0x1c,0xd5]
4294 // CHECK: msr {{fpcr|FPCR}}, x12 // encoding: [0x0c,0x44,0x1b,0xd5]
4295 // CHECK: msr {{fpsr|FPSR}}, x12 // encoding: [0x2c,0x44,0x1b,0xd5]
4296 // CHECK: msr {{dspsr_el0|DSPSR_EL0}}, x12 // encoding: [0x0c,0x45,0x1b,0xd5]
4297 // CHECK: msr {{dlr_el0|DLR_EL0}}, x12 // encoding: [0x2c,0x45,0x1b,0xd5]
4298 // CHECK: msr {{ifsr32_el2|IFSR32_EL2}}, x12 // encoding: [0x2c,0x50,0x1c,0xd5]
4299 // CHECK: msr {{afsr0_el1|AFSR0_EL1}}, x12 // encoding: [0x0c,0x51,0x18,0xd5]
4300 // CHECK: msr {{afsr0_el2|AFSR0_EL2}}, x12 // encoding: [0x0c,0x51,0x1c,0xd5]
4301 // CHECK: msr {{afsr0_el3|AFSR0_EL3}}, x12 // encoding: [0x0c,0x51,0x1e,0xd5]
4302 // CHECK: msr {{afsr1_el1|AFSR1_EL1}}, x12 // encoding: [0x2c,0x51,0x18,0xd5]
4303 // CHECK: msr {{afsr1_el2|AFSR1_EL2}}, x12 // encoding: [0x2c,0x51,0x1c,0xd5]
4304 // CHECK: msr {{afsr1_el3|AFSR1_EL3}}, x12 // encoding: [0x2c,0x51,0x1e,0xd5]
4305 // CHECK: msr {{esr_el1|ESR_EL1}}, x12 // encoding: [0x0c,0x52,0x18,0xd5]
4306 // CHECK: msr {{esr_el2|ESR_EL2}}, x12 // encoding: [0x0c,0x52,0x1c,0xd5]
4307 // CHECK: msr {{esr_el3|ESR_EL3}}, x12 // encoding: [0x0c,0x52,0x1e,0xd5]
4308 // CHECK: msr {{fpexc32_el2|FPEXC32_EL2}}, x12 // encoding: [0x0c,0x53,0x1c,0xd5]
4309 // CHECK: msr {{far_el1|FAR_EL1}}, x12 // encoding: [0x0c,0x60,0x18,0xd5]
4310 // CHECK: msr {{far_el2|FAR_EL2}}, x12 // encoding: [0x0c,0x60,0x1c,0xd5]
4311 // CHECK: msr {{far_el3|FAR_EL3}}, x12 // encoding: [0x0c,0x60,0x1e,0xd5]
4312 // CHECK: msr {{hpfar_el2|HPFAR_EL2}}, x12 // encoding: [0x8c,0x60,0x1c,0xd5]
4313 // CHECK: msr {{par_el1|PAR_EL1}}, x12 // encoding: [0x0c,0x74,0x18,0xd5]
4314 // CHECK: msr {{pmcr_el0|PMCR_EL0}}, x12 // encoding: [0x0c,0x9c,0x1b,0xd5]
4315 // CHECK: msr {{pmcntenset_el0|PMCNTENSET_EL0}}, x12 // encoding: [0x2c,0x9c,0x1b,0xd5]
4316 // CHECK: msr {{pmcntenclr_el0|PMCNTENCLR_EL0}}, x12 // encoding: [0x4c,0x9c,0x1b,0xd5]
4317 // CHECK: msr {{pmovsclr_el0|PMOVSCLR_EL0}}, x12 // encoding: [0x6c,0x9c,0x1b,0xd5]
4318 // CHECK: msr {{pmselr_el0|PMSELR_EL0}}, x12 // encoding: [0xac,0x9c,0x1b,0xd5]
4319 // CHECK: msr {{pmccntr_el0|PMCCNTR_EL0}}, x12 // encoding: [0x0c,0x9d,0x1b,0xd5]
4320 // CHECK: msr {{pmxevtyper_el0|PMXEVTYPER_EL0}}, x12 // encoding: [0x2c,0x9d,0x1b,0xd5]
4321 // CHECK: msr {{pmxevcntr_el0|PMXEVCNTR_EL0}}, x12 // encoding: [0x4c,0x9d,0x1b,0xd5]
4322 // CHECK: msr {{pmuserenr_el0|PMUSERENR_EL0}}, x12 // encoding: [0x0c,0x9e,0x1b,0xd5]
4323 // CHECK: msr {{pmintenset_el1|PMINTENSET_EL1}}, x12 // encoding: [0x2c,0x9e,0x18,0xd5]
4324 // CHECK: msr {{pmintenclr_el1|PMINTENCLR_EL1}}, x12 // encoding: [0x4c,0x9e,0x18,0xd5]
4325 // CHECK: msr {{pmovsset_el0|PMOVSSET_EL0}}, x12 // encoding: [0x6c,0x9e,0x1b,0xd5]
4326 // CHECK: msr {{mair_el1|MAIR_EL1}}, x12 // encoding: [0x0c,0xa2,0x18,0xd5]
4327 // CHECK: msr {{mair_el2|MAIR_EL2}}, x12 // encoding: [0x0c,0xa2,0x1c,0xd5]
4328 // CHECK: msr {{mair_el3|MAIR_EL3}}, x12 // encoding: [0x0c,0xa2,0x1e,0xd5]
4329 // CHECK: msr {{amair_el1|AMAIR_EL1}}, x12 // encoding: [0x0c,0xa3,0x18,0xd5]
4330 // CHECK: msr {{amair_el2|AMAIR_EL2}}, x12 // encoding: [0x0c,0xa3,0x1c,0xd5]
4331 // CHECK: msr {{amair_el3|AMAIR_EL3}}, x12 // encoding: [0x0c,0xa3,0x1e,0xd5]
4332 // CHECK: msr {{vbar_el1|VBAR_EL1}}, x12 // encoding: [0x0c,0xc0,0x18,0xd5]
4333 // CHECK: msr {{vbar_el2|VBAR_EL2}}, x12 // encoding: [0x0c,0xc0,0x1c,0xd5]
4334 // CHECK: msr {{vbar_el3|VBAR_EL3}}, x12 // encoding: [0x0c,0xc0,0x1e,0xd5]
4335 // CHECK: msr {{rmr_el1|RMR_EL1}}, x12 // encoding: [0x4c,0xc0,0x18,0xd5]
4336 // CHECK: msr {{rmr_el2|RMR_EL2}}, x12 // encoding: [0x4c,0xc0,0x1c,0xd5]
4337 // CHECK: msr {{rmr_el3|RMR_EL3}}, x12 // encoding: [0x4c,0xc0,0x1e,0xd5]
4338 // CHECK: msr {{contextidr_el1|CONTEXTIDR_EL1}}, x12 // encoding: [0x2c,0xd0,0x18,0xd5]
4339 // CHECK: msr {{tpidr_el0|TPIDR_EL0}}, x12 // encoding: [0x4c,0xd0,0x1b,0xd5]
4340 // CHECK: msr {{tpidr_el2|TPIDR_EL2}}, x12 // encoding: [0x4c,0xd0,0x1c,0xd5]
4341 // CHECK: msr {{tpidr_el3|TPIDR_EL3}}, x12 // encoding: [0x4c,0xd0,0x1e,0xd5]
4342 // CHECK: msr {{tpidrro_el0|TPIDRRO_EL0}}, x12 // encoding: [0x6c,0xd0,0x1b,0xd5]
4343 // CHECK: msr {{tpidr_el1|TPIDR_EL1}}, x12 // encoding: [0x8c,0xd0,0x18,0xd5]
4344 // CHECK: msr {{cntfrq_el0|CNTFRQ_EL0}}, x12 // encoding: [0x0c,0xe0,0x1b,0xd5]
4345 // CHECK: msr {{cntvoff_el2|CNTVOFF_EL2}}, x12 // encoding: [0x6c,0xe0,0x1c,0xd5]
4346 // CHECK: msr {{cntkctl_el1|CNTKCTL_EL1}}, x12 // encoding: [0x0c,0xe1,0x18,0xd5]
4347 // CHECK: msr {{cnthctl_el2|CNTHCTL_EL2}}, x12 // encoding: [0x0c,0xe1,0x1c,0xd5]
4348 // CHECK: msr {{cntp_tval_el0|CNTP_TVAL_EL0}}, x12 // encoding: [0x0c,0xe2,0x1b,0xd5]
4349 // CHECK: msr {{cnthp_tval_el2|CNTHP_TVAL_EL2}}, x12 // encoding: [0x0c,0xe2,0x1c,0xd5]
4350 // CHECK: msr {{cntps_tval_el1|CNTPS_TVAL_EL1}}, x12 // encoding: [0x0c,0xe2,0x1f,0xd5]
4351 // CHECK: msr {{cntp_ctl_el0|CNTP_CTL_EL0}}, x12 // encoding: [0x2c,0xe2,0x1b,0xd5]
4352 // CHECK: msr {{cnthp_ctl_el2|CNTHP_CTL_EL2}}, x12 // encoding: [0x2c,0xe2,0x1c,0xd5]
4353 // CHECK: msr {{cntps_ctl_el1|CNTPS_CTL_EL1}}, x12 // encoding: [0x2c,0xe2,0x1f,0xd5]
4354 // CHECK: msr {{cntp_cval_el0|CNTP_CVAL_EL0}}, x12 // encoding: [0x4c,0xe2,0x1b,0xd5]
4355 // CHECK: msr {{cnthp_cval_el2|CNTHP_CVAL_EL2}}, x12 // encoding: [0x4c,0xe2,0x1c,0xd5]
4356 // CHECK: msr {{cntps_cval_el1|CNTPS_CVAL_EL1}}, x12 // encoding: [0x4c,0xe2,0x1f,0xd5]
4357 // CHECK: msr {{cntv_tval_el0|CNTV_TVAL_EL0}}, x12 // encoding: [0x0c,0xe3,0x1b,0xd5]
4358 // CHECK: msr {{cntv_ctl_el0|CNTV_CTL_EL0}}, x12 // encoding: [0x2c,0xe3,0x1b,0xd5]
4359 // CHECK: msr {{cntv_cval_el0|CNTV_CVAL_EL0}}, x12 // encoding: [0x4c,0xe3,0x1b,0xd5]
4360 // CHECK: msr {{pmevcntr0_el0|PMEVCNTR0_EL0}}, x12 // encoding: [0x0c,0xe8,0x1b,0xd5]
4361 // CHECK: msr {{pmevcntr1_el0|PMEVCNTR1_EL0}}, x12 // encoding: [0x2c,0xe8,0x1b,0xd5]
4362 // CHECK: msr {{pmevcntr2_el0|PMEVCNTR2_EL0}}, x12 // encoding: [0x4c,0xe8,0x1b,0xd5]
4363 // CHECK: msr {{pmevcntr3_el0|PMEVCNTR3_EL0}}, x12 // encoding: [0x6c,0xe8,0x1b,0xd5]
4364 // CHECK: msr {{pmevcntr4_el0|PMEVCNTR4_EL0}}, x12 // encoding: [0x8c,0xe8,0x1b,0xd5]
4365 // CHECK: msr {{pmevcntr5_el0|PMEVCNTR5_EL0}}, x12 // encoding: [0xac,0xe8,0x1b,0xd5]
4366 // CHECK: msr {{pmevcntr6_el0|PMEVCNTR6_EL0}}, x12 // encoding: [0xcc,0xe8,0x1b,0xd5]
4367 // CHECK: msr {{pmevcntr7_el0|PMEVCNTR7_EL0}}, x12 // encoding: [0xec,0xe8,0x1b,0xd5]
4368 // CHECK: msr {{pmevcntr8_el0|PMEVCNTR8_EL0}}, x12 // encoding: [0x0c,0xe9,0x1b,0xd5]
4369 // CHECK: msr {{pmevcntr9_el0|PMEVCNTR9_EL0}}, x12 // encoding: [0x2c,0xe9,0x1b,0xd5]
4370 // CHECK: msr {{pmevcntr10_el0|PMEVCNTR10_EL0}}, x12 // encoding: [0x4c,0xe9,0x1b,0xd5]
4371 // CHECK: msr {{pmevcntr11_el0|PMEVCNTR11_EL0}}, x12 // encoding: [0x6c,0xe9,0x1b,0xd5]
4372 // CHECK: msr {{pmevcntr12_el0|PMEVCNTR12_EL0}}, x12 // encoding: [0x8c,0xe9,0x1b,0xd5]
4373 // CHECK: msr {{pmevcntr13_el0|PMEVCNTR13_EL0}}, x12 // encoding: [0xac,0xe9,0x1b,0xd5]
4374 // CHECK: msr {{pmevcntr14_el0|PMEVCNTR14_EL0}}, x12 // encoding: [0xcc,0xe9,0x1b,0xd5]
4375 // CHECK: msr {{pmevcntr15_el0|PMEVCNTR15_EL0}}, x12 // encoding: [0xec,0xe9,0x1b,0xd5]
4376 // CHECK: msr {{pmevcntr16_el0|PMEVCNTR16_EL0}}, x12 // encoding: [0x0c,0xea,0x1b,0xd5]
4377 // CHECK: msr {{pmevcntr17_el0|PMEVCNTR17_EL0}}, x12 // encoding: [0x2c,0xea,0x1b,0xd5]
4378 // CHECK: msr {{pmevcntr18_el0|PMEVCNTR18_EL0}}, x12 // encoding: [0x4c,0xea,0x1b,0xd5]
4379 // CHECK: msr {{pmevcntr19_el0|PMEVCNTR19_EL0}}, x12 // encoding: [0x6c,0xea,0x1b,0xd5]
4380 // CHECK: msr {{pmevcntr20_el0|PMEVCNTR20_EL0}}, x12 // encoding: [0x8c,0xea,0x1b,0xd5]
4381 // CHECK: msr {{pmevcntr21_el0|PMEVCNTR21_EL0}}, x12 // encoding: [0xac,0xea,0x1b,0xd5]
4382 // CHECK: msr {{pmevcntr22_el0|PMEVCNTR22_EL0}}, x12 // encoding: [0xcc,0xea,0x1b,0xd5]
4383 // CHECK: msr {{pmevcntr23_el0|PMEVCNTR23_EL0}}, x12 // encoding: [0xec,0xea,0x1b,0xd5]
4384 // CHECK: msr {{pmevcntr24_el0|PMEVCNTR24_EL0}}, x12 // encoding: [0x0c,0xeb,0x1b,0xd5]
4385 // CHECK: msr {{pmevcntr25_el0|PMEVCNTR25_EL0}}, x12 // encoding: [0x2c,0xeb,0x1b,0xd5]
4386 // CHECK: msr {{pmevcntr26_el0|PMEVCNTR26_EL0}}, x12 // encoding: [0x4c,0xeb,0x1b,0xd5]
4387 // CHECK: msr {{pmevcntr27_el0|PMEVCNTR27_EL0}}, x12 // encoding: [0x6c,0xeb,0x1b,0xd5]
4388 // CHECK: msr {{pmevcntr28_el0|PMEVCNTR28_EL0}}, x12 // encoding: [0x8c,0xeb,0x1b,0xd5]
4389 // CHECK: msr {{pmevcntr29_el0|PMEVCNTR29_EL0}}, x12 // encoding: [0xac,0xeb,0x1b,0xd5]
4390 // CHECK: msr {{pmevcntr30_el0|PMEVCNTR30_EL0}}, x12 // encoding: [0xcc,0xeb,0x1b,0xd5]
4391 // CHECK: msr {{pmccfiltr_el0|PMCCFILTR_EL0}}, x12 // encoding: [0xec,0xef,0x1b,0xd5]
4392 // CHECK: msr {{pmevtyper0_el0|PMEVTYPER0_EL0}}, x12 // encoding: [0x0c,0xec,0x1b,0xd5]
4393 // CHECK: msr {{pmevtyper1_el0|PMEVTYPER1_EL0}}, x12 // encoding: [0x2c,0xec,0x1b,0xd5]
4394 // CHECK: msr {{pmevtyper2_el0|PMEVTYPER2_EL0}}, x12 // encoding: [0x4c,0xec,0x1b,0xd5]
4395 // CHECK: msr {{pmevtyper3_el0|PMEVTYPER3_EL0}}, x12 // encoding: [0x6c,0xec,0x1b,0xd5]
4396 // CHECK: msr {{pmevtyper4_el0|PMEVTYPER4_EL0}}, x12 // encoding: [0x8c,0xec,0x1b,0xd5]
4397 // CHECK: msr {{pmevtyper5_el0|PMEVTYPER5_EL0}}, x12 // encoding: [0xac,0xec,0x1b,0xd5]
4398 // CHECK: msr {{pmevtyper6_el0|PMEVTYPER6_EL0}}, x12 // encoding: [0xcc,0xec,0x1b,0xd5]
4399 // CHECK: msr {{pmevtyper7_el0|PMEVTYPER7_EL0}}, x12 // encoding: [0xec,0xec,0x1b,0xd5]
4400 // CHECK: msr {{pmevtyper8_el0|PMEVTYPER8_EL0}}, x12 // encoding: [0x0c,0xed,0x1b,0xd5]
4401 // CHECK: msr {{pmevtyper9_el0|PMEVTYPER9_EL0}}, x12 // encoding: [0x2c,0xed,0x1b,0xd5]
4402 // CHECK: msr {{pmevtyper10_el0|PMEVTYPER10_EL0}}, x12 // encoding: [0x4c,0xed,0x1b,0xd5]
4403 // CHECK: msr {{pmevtyper11_el0|PMEVTYPER11_EL0}}, x12 // encoding: [0x6c,0xed,0x1b,0xd5]
4404 // CHECK: msr {{pmevtyper12_el0|PMEVTYPER12_EL0}}, x12 // encoding: [0x8c,0xed,0x1b,0xd5]
4405 // CHECK: msr {{pmevtyper13_el0|PMEVTYPER13_EL0}}, x12 // encoding: [0xac,0xed,0x1b,0xd5]
4406 // CHECK: msr {{pmevtyper14_el0|PMEVTYPER14_EL0}}, x12 // encoding: [0xcc,0xed,0x1b,0xd5]
4407 // CHECK: msr {{pmevtyper15_el0|PMEVTYPER15_EL0}}, x12 // encoding: [0xec,0xed,0x1b,0xd5]
4408 // CHECK: msr {{pmevtyper16_el0|PMEVTYPER16_EL0}}, x12 // encoding: [0x0c,0xee,0x1b,0xd5]
4409 // CHECK: msr {{pmevtyper17_el0|PMEVTYPER17_EL0}}, x12 // encoding: [0x2c,0xee,0x1b,0xd5]
4410 // CHECK: msr {{pmevtyper18_el0|PMEVTYPER18_EL0}}, x12 // encoding: [0x4c,0xee,0x1b,0xd5]
4411 // CHECK: msr {{pmevtyper19_el0|PMEVTYPER19_EL0}}, x12 // encoding: [0x6c,0xee,0x1b,0xd5]
4412 // CHECK: msr {{pmevtyper20_el0|PMEVTYPER20_EL0}}, x12 // encoding: [0x8c,0xee,0x1b,0xd5]
4413 // CHECK: msr {{pmevtyper21_el0|PMEVTYPER21_EL0}}, x12 // encoding: [0xac,0xee,0x1b,0xd5]
4414 // CHECK: msr {{pmevtyper22_el0|PMEVTYPER22_EL0}}, x12 // encoding: [0xcc,0xee,0x1b,0xd5]
4415 // CHECK: msr {{pmevtyper23_el0|PMEVTYPER23_EL0}}, x12 // encoding: [0xec,0xee,0x1b,0xd5]
4416 // CHECK: msr {{pmevtyper24_el0|PMEVTYPER24_EL0}}, x12 // encoding: [0x0c,0xef,0x1b,0xd5]
4417 // CHECK: msr {{pmevtyper25_el0|PMEVTYPER25_EL0}}, x12 // encoding: [0x2c,0xef,0x1b,0xd5]
4418 // CHECK: msr {{pmevtyper26_el0|PMEVTYPER26_EL0}}, x12 // encoding: [0x4c,0xef,0x1b,0xd5]
4419 // CHECK: msr {{pmevtyper27_el0|PMEVTYPER27_EL0}}, x12 // encoding: [0x6c,0xef,0x1b,0xd5]
4420 // CHECK: msr {{pmevtyper28_el0|PMEVTYPER28_EL0}}, x12 // encoding: [0x8c,0xef,0x1b,0xd5]
4421 // CHECK: msr {{pmevtyper29_el0|PMEVTYPER29_EL0}}, x12 // encoding: [0xac,0xef,0x1b,0xd5]
4422 // CHECK: msr {{pmevtyper30_el0|PMEVTYPER30_EL0}}, x12 // encoding: [0xcc,0xef,0x1b,0xd5]
4431 mrs x9, DBGDTRRX_EL0
4433 mrs x9, DBGVCR32_EL2
4444 mrs x9, DBGBVR10_EL1
4445 mrs x9, DBGBVR11_EL1
4446 mrs x9, DBGBVR12_EL1
4447 mrs x9, DBGBVR13_EL1
4448 mrs x9, DBGBVR14_EL1
4449 mrs x9, DBGBVR15_EL1
4460 mrs x9, DBGBCR10_EL1
4461 mrs x9, DBGBCR11_EL1
4462 mrs x9, DBGBCR12_EL1
4463 mrs x9, DBGBCR13_EL1
4464 mrs x9, DBGBCR14_EL1
4465 mrs x9, DBGBCR15_EL1
4476 mrs x9, DBGWVR10_EL1
4477 mrs x9, DBGWVR11_EL1
4478 mrs x9, DBGWVR12_EL1
4479 mrs x9, DBGWVR13_EL1
4480 mrs x9, DBGWVR14_EL1
4481 mrs x9, DBGWVR15_EL1
4492 mrs x9, DBGWCR10_EL1
4493 mrs x9, DBGWCR11_EL1
4494 mrs x9, DBGWCR12_EL1
4495 mrs x9, DBGWCR13_EL1
4496 mrs x9, DBGWCR14_EL1
4497 mrs x9, DBGWCR15_EL1
4499 mrs x9, TEEHBR32_EL1
4503 mrs x9, DBGCLAIMSET_EL1
4504 mrs x9, DBGCLAIMCLR_EL1
4505 mrs x9, DBGAUTHSTATUS_EL1
4521 mrs x9, ID_MMFR0_EL1
4522 mrs x9, ID_MMFR1_EL1
4523 mrs x9, ID_MMFR2_EL1
4524 mrs x9, ID_MMFR3_EL1
4525 mrs x9, ID_ISAR0_EL1
4526 mrs x9, ID_ISAR1_EL1
4527 mrs x9, ID_ISAR2_EL1
4528 mrs x9, ID_ISAR3_EL1
4529 mrs x9, ID_ISAR4_EL1
4530 mrs x9, ID_ISAR5_EL1
4534 mrs x9, ID_AA64PFR0_EL1
4535 mrs x9, ID_AA64PFR1_EL1
4536 mrs x9, ID_AA64DFR0_EL1
4537 mrs x9, ID_AA64DFR1_EL1
4538 mrs x9, ID_AA64AFR0_EL1
4539 mrs x9, ID_AA64AFR1_EL1
4540 mrs x9, ID_AA64ISAR0_EL1
4541 mrs x9, ID_AA64ISAR1_EL1
4542 mrs x9, ID_AA64MMFR0_EL1
4543 mrs x9, ID_AA64MMFR1_EL1
4608 mrs x9, PMCNTENSET_EL0
4609 mrs x9, PMCNTENCLR_EL0
4610 mrs x9, PMOVSCLR_EL0
4615 mrs x9, PMXEVTYPER_EL0
4616 mrs x9, PMXEVCNTR_EL0
4617 mrs x9, PMUSERENR_EL0
4618 mrs x9, PMINTENSET_EL1
4619 mrs x9, PMINTENCLR_EL1
4620 mrs x9, PMOVSSET_EL0
4637 mrs x9, CONTEXTIDR_EL1
4649 mrs x9, CNTP_TVAL_EL0
4650 mrs x9, CNTHP_TVAL_EL2
4651 mrs x9, CNTPS_TVAL_EL1
4652 mrs x9, CNTP_CTL_EL0
4653 mrs x9, CNTHP_CTL_EL2
4654 mrs x9, CNTPS_CTL_EL1
4655 mrs x9, CNTP_CVAL_EL0
4656 mrs x9, CNTHP_CVAL_EL2
4657 mrs x9, CNTPS_CVAL_EL1
4658 mrs x9, CNTV_TVAL_EL0
4659 mrs x9, CNTV_CTL_EL0
4660 mrs x9, CNTV_CVAL_EL0
4661 mrs x9, PMEVCNTR0_EL0
4662 mrs x9, PMEVCNTR1_EL0
4663 mrs x9, PMEVCNTR2_EL0
4664 mrs x9, PMEVCNTR3_EL0
4665 mrs x9, PMEVCNTR4_EL0
4666 mrs x9, PMEVCNTR5_EL0
4667 mrs x9, PMEVCNTR6_EL0
4668 mrs x9, PMEVCNTR7_EL0
4669 mrs x9, PMEVCNTR8_EL0
4670 mrs x9, PMEVCNTR9_EL0
4671 mrs x9, PMEVCNTR10_EL0
4672 mrs x9, PMEVCNTR11_EL0
4673 mrs x9, PMEVCNTR12_EL0
4674 mrs x9, PMEVCNTR13_EL0
4675 mrs x9, PMEVCNTR14_EL0
4676 mrs x9, PMEVCNTR15_EL0
4677 mrs x9, PMEVCNTR16_EL0
4678 mrs x9, PMEVCNTR17_EL0
4679 mrs x9, PMEVCNTR18_EL0
4680 mrs x9, PMEVCNTR19_EL0
4681 mrs x9, PMEVCNTR20_EL0
4682 mrs x9, PMEVCNTR21_EL0
4683 mrs x9, PMEVCNTR22_EL0
4684 mrs x9, PMEVCNTR23_EL0
4685 mrs x9, PMEVCNTR24_EL0
4686 mrs x9, PMEVCNTR25_EL0
4687 mrs x9, PMEVCNTR26_EL0
4688 mrs x9, PMEVCNTR27_EL0
4689 mrs x9, PMEVCNTR28_EL0
4690 mrs x9, PMEVCNTR29_EL0
4691 mrs x9, PMEVCNTR30_EL0
4692 mrs x9, PMCCFILTR_EL0
4693 mrs x9, PMEVTYPER0_EL0
4694 mrs x9, PMEVTYPER1_EL0
4695 mrs x9, PMEVTYPER2_EL0
4696 mrs x9, PMEVTYPER3_EL0
4697 mrs x9, PMEVTYPER4_EL0
4698 mrs x9, PMEVTYPER5_EL0
4699 mrs x9, PMEVTYPER6_EL0
4700 mrs x9, PMEVTYPER7_EL0
4701 mrs x9, PMEVTYPER8_EL0
4702 mrs x9, PMEVTYPER9_EL0
4703 mrs x9, PMEVTYPER10_EL0
4704 mrs x9, PMEVTYPER11_EL0
4705 mrs x9, PMEVTYPER12_EL0
4706 mrs x9, PMEVTYPER13_EL0
4707 mrs x9, PMEVTYPER14_EL0
4708 mrs x9, PMEVTYPER15_EL0
4709 mrs x9, PMEVTYPER16_EL0
4710 mrs x9, PMEVTYPER17_EL0
4711 mrs x9, PMEVTYPER18_EL0
4712 mrs x9, PMEVTYPER19_EL0
4713 mrs x9, PMEVTYPER20_EL0
4714 mrs x9, PMEVTYPER21_EL0
4715 mrs x9, PMEVTYPER22_EL0
4716 mrs x9, PMEVTYPER23_EL0
4717 mrs x9, PMEVTYPER24_EL0
4718 mrs x9, PMEVTYPER25_EL0
4719 mrs x9, PMEVTYPER26_EL0
4720 mrs x9, PMEVTYPER27_EL0
4721 mrs x9, PMEVTYPER28_EL0
4722 mrs x9, PMEVTYPER29_EL0
4723 mrs x9, PMEVTYPER30_EL0
4724 // CHECK: mrs x9, {{teecr32_el1|TEECR32_EL1}} // encoding: [0x09,0x00,0x32,0xd5]
4725 // CHECK: mrs x9, {{osdtrrx_el1|OSDTRRX_EL1}} // encoding: [0x49,0x00,0x30,0xd5]
4726 // CHECK: mrs x9, {{mdccsr_el0|MDCCSR_EL0}} // encoding: [0x09,0x01,0x33,0xd5]
4727 // CHECK: mrs x9, {{mdccint_el1|MDCCINT_EL1}} // encoding: [0x09,0x02,0x30,0xd5]
4728 // CHECK: mrs x9, {{mdscr_el1|MDSCR_EL1}} // encoding: [0x49,0x02,0x30,0xd5]
4729 // CHECK: mrs x9, {{osdtrtx_el1|OSDTRTX_EL1}} // encoding: [0x49,0x03,0x30,0xd5]
4730 // CHECK: mrs x9, {{dbgdtr_el0|DBGDTR_EL0}} // encoding: [0x09,0x04,0x33,0xd5]
4731 // CHECK: mrs x9, {{dbgdtrrx_el0|DBGDTRRX_EL0}} // encoding: [0x09,0x05,0x33,0xd5]
4732 // CHECK: mrs x9, {{oseccr_el1|OSECCR_EL1}} // encoding: [0x49,0x06,0x30,0xd5]
4733 // CHECK: mrs x9, {{dbgvcr32_el2|DBGVCR32_EL2}} // encoding: [0x09,0x07,0x34,0xd5]
4734 // CHECK: mrs x9, {{dbgbvr0_el1|DBGBVR0_EL1}} // encoding: [0x89,0x00,0x30,0xd5]
4735 // CHECK: mrs x9, {{dbgbvr1_el1|DBGBVR1_EL1}} // encoding: [0x89,0x01,0x30,0xd5]
4736 // CHECK: mrs x9, {{dbgbvr2_el1|DBGBVR2_EL1}} // encoding: [0x89,0x02,0x30,0xd5]
4737 // CHECK: mrs x9, {{dbgbvr3_el1|DBGBVR3_EL1}} // encoding: [0x89,0x03,0x30,0xd5]
4738 // CHECK: mrs x9, {{dbgbvr4_el1|DBGBVR4_EL1}} // encoding: [0x89,0x04,0x30,0xd5]
4739 // CHECK: mrs x9, {{dbgbvr5_el1|DBGBVR5_EL1}} // encoding: [0x89,0x05,0x30,0xd5]
4740 // CHECK: mrs x9, {{dbgbvr6_el1|DBGBVR6_EL1}} // encoding: [0x89,0x06,0x30,0xd5]
4741 // CHECK: mrs x9, {{dbgbvr7_el1|DBGBVR7_EL1}} // encoding: [0x89,0x07,0x30,0xd5]
4742 // CHECK: mrs x9, {{dbgbvr8_el1|DBGBVR8_EL1}} // encoding: [0x89,0x08,0x30,0xd5]
4743 // CHECK: mrs x9, {{dbgbvr9_el1|DBGBVR9_EL1}} // encoding: [0x89,0x09,0x30,0xd5]
4744 // CHECK: mrs x9, {{dbgbvr10_el1|DBGBVR10_EL1}} // encoding: [0x89,0x0a,0x30,0xd5]
4745 // CHECK: mrs x9, {{dbgbvr11_el1|DBGBVR11_EL1}} // encoding: [0x89,0x0b,0x30,0xd5]
4746 // CHECK: mrs x9, {{dbgbvr12_el1|DBGBVR12_EL1}} // encoding: [0x89,0x0c,0x30,0xd5]
4747 // CHECK: mrs x9, {{dbgbvr13_el1|DBGBVR13_EL1}} // encoding: [0x89,0x0d,0x30,0xd5]
4748 // CHECK: mrs x9, {{dbgbvr14_el1|DBGBVR14_EL1}} // encoding: [0x89,0x0e,0x30,0xd5]
4749 // CHECK: mrs x9, {{dbgbvr15_el1|DBGBVR15_EL1}} // encoding: [0x89,0x0f,0x30,0xd5]
4750 // CHECK: mrs x9, {{dbgbcr0_el1|DBGBCR0_EL1}} // encoding: [0xa9,0x00,0x30,0xd5]
4751 // CHECK: mrs x9, {{dbgbcr1_el1|DBGBCR1_EL1}} // encoding: [0xa9,0x01,0x30,0xd5]
4752 // CHECK: mrs x9, {{dbgbcr2_el1|DBGBCR2_EL1}} // encoding: [0xa9,0x02,0x30,0xd5]
4753 // CHECK: mrs x9, {{dbgbcr3_el1|DBGBCR3_EL1}} // encoding: [0xa9,0x03,0x30,0xd5]
4754 // CHECK: mrs x9, {{dbgbcr4_el1|DBGBCR4_EL1}} // encoding: [0xa9,0x04,0x30,0xd5]
4755 // CHECK: mrs x9, {{dbgbcr5_el1|DBGBCR5_EL1}} // encoding: [0xa9,0x05,0x30,0xd5]
4756 // CHECK: mrs x9, {{dbgbcr6_el1|DBGBCR6_EL1}} // encoding: [0xa9,0x06,0x30,0xd5]
4757 // CHECK: mrs x9, {{dbgbcr7_el1|DBGBCR7_EL1}} // encoding: [0xa9,0x07,0x30,0xd5]
4758 // CHECK: mrs x9, {{dbgbcr8_el1|DBGBCR8_EL1}} // encoding: [0xa9,0x08,0x30,0xd5]
4759 // CHECK: mrs x9, {{dbgbcr9_el1|DBGBCR9_EL1}} // encoding: [0xa9,0x09,0x30,0xd5]
4760 // CHECK: mrs x9, {{dbgbcr10_el1|DBGBCR10_EL1}} // encoding: [0xa9,0x0a,0x30,0xd5]
4761 // CHECK: mrs x9, {{dbgbcr11_el1|DBGBCR11_EL1}} // encoding: [0xa9,0x0b,0x30,0xd5]
4762 // CHECK: mrs x9, {{dbgbcr12_el1|DBGBCR12_EL1}} // encoding: [0xa9,0x0c,0x30,0xd5]
4763 // CHECK: mrs x9, {{dbgbcr13_el1|DBGBCR13_EL1}} // encoding: [0xa9,0x0d,0x30,0xd5]
4764 // CHECK: mrs x9, {{dbgbcr14_el1|DBGBCR14_EL1}} // encoding: [0xa9,0x0e,0x30,0xd5]
4765 // CHECK: mrs x9, {{dbgbcr15_el1|DBGBCR15_EL1}} // encoding: [0xa9,0x0f,0x30,0xd5]
4766 // CHECK: mrs x9, {{dbgwvr0_el1|DBGWVR0_EL1}} // encoding: [0xc9,0x00,0x30,0xd5]
4767 // CHECK: mrs x9, {{dbgwvr1_el1|DBGWVR1_EL1}} // encoding: [0xc9,0x01,0x30,0xd5]
4768 // CHECK: mrs x9, {{dbgwvr2_el1|DBGWVR2_EL1}} // encoding: [0xc9,0x02,0x30,0xd5]
4769 // CHECK: mrs x9, {{dbgwvr3_el1|DBGWVR3_EL1}} // encoding: [0xc9,0x03,0x30,0xd5]
4770 // CHECK: mrs x9, {{dbgwvr4_el1|DBGWVR4_EL1}} // encoding: [0xc9,0x04,0x30,0xd5]
4771 // CHECK: mrs x9, {{dbgwvr5_el1|DBGWVR5_EL1}} // encoding: [0xc9,0x05,0x30,0xd5]
4772 // CHECK: mrs x9, {{dbgwvr6_el1|DBGWVR6_EL1}} // encoding: [0xc9,0x06,0x30,0xd5]
4773 // CHECK: mrs x9, {{dbgwvr7_el1|DBGWVR7_EL1}} // encoding: [0xc9,0x07,0x30,0xd5]
4774 // CHECK: mrs x9, {{dbgwvr8_el1|DBGWVR8_EL1}} // encoding: [0xc9,0x08,0x30,0xd5]
4775 // CHECK: mrs x9, {{dbgwvr9_el1|DBGWVR9_EL1}} // encoding: [0xc9,0x09,0x30,0xd5]
4776 // CHECK: mrs x9, {{dbgwvr10_el1|DBGWVR10_EL1}} // encoding: [0xc9,0x0a,0x30,0xd5]
4777 // CHECK: mrs x9, {{dbgwvr11_el1|DBGWVR11_EL1}} // encoding: [0xc9,0x0b,0x30,0xd5]
4778 // CHECK: mrs x9, {{dbgwvr12_el1|DBGWVR12_EL1}} // encoding: [0xc9,0x0c,0x30,0xd5]
4779 // CHECK: mrs x9, {{dbgwvr13_el1|DBGWVR13_EL1}} // encoding: [0xc9,0x0d,0x30,0xd5]
4780 // CHECK: mrs x9, {{dbgwvr14_el1|DBGWVR14_EL1}} // encoding: [0xc9,0x0e,0x30,0xd5]
4781 // CHECK: mrs x9, {{dbgwvr15_el1|DBGWVR15_EL1}} // encoding: [0xc9,0x0f,0x30,0xd5]
4782 // CHECK: mrs x9, {{dbgwcr0_el1|DBGWCR0_EL1}} // encoding: [0xe9,0x00,0x30,0xd5]
4783 // CHECK: mrs x9, {{dbgwcr1_el1|DBGWCR1_EL1}} // encoding: [0xe9,0x01,0x30,0xd5]
4784 // CHECK: mrs x9, {{dbgwcr2_el1|DBGWCR2_EL1}} // encoding: [0xe9,0x02,0x30,0xd5]
4785 // CHECK: mrs x9, {{dbgwcr3_el1|DBGWCR3_EL1}} // encoding: [0xe9,0x03,0x30,0xd5]
4786 // CHECK: mrs x9, {{dbgwcr4_el1|DBGWCR4_EL1}} // encoding: [0xe9,0x04,0x30,0xd5]
4787 // CHECK: mrs x9, {{dbgwcr5_el1|DBGWCR5_EL1}} // encoding: [0xe9,0x05,0x30,0xd5]
4788 // CHECK: mrs x9, {{dbgwcr6_el1|DBGWCR6_EL1}} // encoding: [0xe9,0x06,0x30,0xd5]
4789 // CHECK: mrs x9, {{dbgwcr7_el1|DBGWCR7_EL1}} // encoding: [0xe9,0x07,0x30,0xd5]
4790 // CHECK: mrs x9, {{dbgwcr8_el1|DBGWCR8_EL1}} // encoding: [0xe9,0x08,0x30,0xd5]
4791 // CHECK: mrs x9, {{dbgwcr9_el1|DBGWCR9_EL1}} // encoding: [0xe9,0x09,0x30,0xd5]
4792 // CHECK: mrs x9, {{dbgwcr10_el1|DBGWCR10_EL1}} // encoding: [0xe9,0x0a,0x30,0xd5]
4793 // CHECK: mrs x9, {{dbgwcr11_el1|DBGWCR11_EL1}} // encoding: [0xe9,0x0b,0x30,0xd5]
4794 // CHECK: mrs x9, {{dbgwcr12_el1|DBGWCR12_EL1}} // encoding: [0xe9,0x0c,0x30,0xd5]
4795 // CHECK: mrs x9, {{dbgwcr13_el1|DBGWCR13_EL1}} // encoding: [0xe9,0x0d,0x30,0xd5]
4796 // CHECK: mrs x9, {{dbgwcr14_el1|DBGWCR14_EL1}} // encoding: [0xe9,0x0e,0x30,0xd5]
4797 // CHECK: mrs x9, {{dbgwcr15_el1|DBGWCR15_EL1}} // encoding: [0xe9,0x0f,0x30,0xd5]
4798 // CHECK: mrs x9, {{mdrar_el1|MDRAR_EL1}} // encoding: [0x09,0x10,0x30,0xd5]
4799 // CHECK: mrs x9, {{teehbr32_el1|TEEHBR32_EL1}} // encoding: [0x09,0x10,0x32,0xd5]
4800 // CHECK: mrs x9, {{oslsr_el1|OSLSR_EL1}} // encoding: [0x89,0x11,0x30,0xd5]
4801 // CHECK: mrs x9, {{osdlr_el1|OSDLR_EL1}} // encoding: [0x89,0x13,0x30,0xd5]
4802 // CHECK: mrs x9, {{dbgprcr_el1|DBGPRCR_EL1}} // encoding: [0x89,0x14,0x30,0xd5]
4803 // CHECK: mrs x9, {{dbgclaimset_el1|DBGCLAIMSET_EL1}} // encoding: [0xc9,0x78,0x30,0xd5]
4804 // CHECK: mrs x9, {{dbgclaimclr_el1|DBGCLAIMCLR_EL1}} // encoding: [0xc9,0x79,0x30,0xd5]
4805 // CHECK: mrs x9, {{dbgauthstatus_el1|DBGAUTHSTATUS_EL1}} // encoding: [0xc9,0x7e,0x30,0xd5]
4806 // CHECK: mrs x9, {{midr_el1|MIDR_EL1}} // encoding: [0x09,0x00,0x38,0xd5]
4807 // CHECK: mrs x9, {{ccsidr_el1|CCSIDR_EL1}} // encoding: [0x09,0x00,0x39,0xd5]
4808 // CHECK: mrs x9, {{csselr_el1|CSSELR_EL1}} // encoding: [0x09,0x00,0x3a,0xd5]
4809 // CHECK: mrs x9, {{vpidr_el2|VPIDR_EL2}} // encoding: [0x09,0x00,0x3c,0xd5]
4810 // CHECK: mrs x9, {{clidr_el1|CLIDR_EL1}} // encoding: [0x29,0x00,0x39,0xd5]
4811 // CHECK: mrs x9, {{ctr_el0|CTR_EL0}} // encoding: [0x29,0x00,0x3b,0xd5]
4812 // CHECK: mrs x9, {{mpidr_el1|MPIDR_EL1}} // encoding: [0xa9,0x00,0x38,0xd5]
4813 // CHECK: mrs x9, {{vmpidr_el2|VMPIDR_EL2}} // encoding: [0xa9,0x00,0x3c,0xd5]
4814 // CHECK: mrs x9, {{revidr_el1|REVIDR_EL1}} // encoding: [0xc9,0x00,0x38,0xd5]
4815 // CHECK: mrs x9, {{aidr_el1|AIDR_EL1}} // encoding: [0xe9,0x00,0x39,0xd5]
4816 // CHECK: mrs x9, {{dczid_el0|DCZID_EL0}} // encoding: [0xe9,0x00,0x3b,0xd5]
4817 // CHECK: mrs x9, {{id_pfr0_el1|ID_PFR0_EL1}} // encoding: [0x09,0x01,0x38,0xd5]
4818 // CHECK: mrs x9, {{id_pfr1_el1|ID_PFR1_EL1}} // encoding: [0x29,0x01,0x38,0xd5]
4819 // CHECK: mrs x9, {{id_dfr0_el1|ID_DFR0_EL1}} // encoding: [0x49,0x01,0x38,0xd5]
4820 // CHECK: mrs x9, {{id_afr0_el1|ID_AFR0_EL1}} // encoding: [0x69,0x01,0x38,0xd5]
4821 // CHECK: mrs x9, {{id_mmfr0_el1|ID_MMFR0_EL1}} // encoding: [0x89,0x01,0x38,0xd5]
4822 // CHECK: mrs x9, {{id_mmfr1_el1|ID_MMFR1_EL1}} // encoding: [0xa9,0x01,0x38,0xd5]
4823 // CHECK: mrs x9, {{id_mmfr2_el1|ID_MMFR2_EL1}} // encoding: [0xc9,0x01,0x38,0xd5]
4824 // CHECK: mrs x9, {{id_mmfr3_el1|ID_MMFR3_EL1}} // encoding: [0xe9,0x01,0x38,0xd5]
4825 // CHECK: mrs x9, {{id_isar0_el1|ID_ISAR0_EL1}} // encoding: [0x09,0x02,0x38,0xd5]
4826 // CHECK: mrs x9, {{id_isar1_el1|ID_ISAR1_EL1}} // encoding: [0x29,0x02,0x38,0xd5]
4827 // CHECK: mrs x9, {{id_isar2_el1|ID_ISAR2_EL1}} // encoding: [0x49,0x02,0x38,0xd5]
4828 // CHECK: mrs x9, {{id_isar3_el1|ID_ISAR3_EL1}} // encoding: [0x69,0x02,0x38,0xd5]
4829 // CHECK: mrs x9, {{id_isar4_el1|ID_ISAR4_EL1}} // encoding: [0x89,0x02,0x38,0xd5]
4830 // CHECK: mrs x9, {{id_isar5_el1|ID_ISAR5_EL1}} // encoding: [0xa9,0x02,0x38,0xd5]
4831 // CHECK: mrs x9, {{mvfr0_el1|MVFR0_EL1}} // encoding: [0x09,0x03,0x38,0xd5]
4832 // CHECK: mrs x9, {{mvfr1_el1|MVFR1_EL1}} // encoding: [0x29,0x03,0x38,0xd5]
4833 // CHECK: mrs x9, {{mvfr2_el1|MVFR2_EL1}} // encoding: [0x49,0x03,0x38,0xd5]
4834 // CHECK: mrs x9, {{id_aa64pfr0_el1|ID_AA64PFR0_EL1}} // encoding: [0x09,0x04,0x38,0xd5]
4835 // CHECK: mrs x9, {{id_aa64pfr1_el1|ID_AA64PFR1_EL1}} // encoding: [0x29,0x04,0x38,0xd5]
4836 // CHECK: mrs x9, {{id_aa64dfr0_el1|ID_AA64DFR0_EL1}} // encoding: [0x09,0x05,0x38,0xd5]
4837 // CHECK: mrs x9, {{id_aa64dfr1_el1|ID_AA64DFR1_EL1}} // encoding: [0x29,0x05,0x38,0xd5]
4838 // CHECK: mrs x9, {{id_aa64afr0_el1|ID_AA64AFR0_EL1}} // encoding: [0x89,0x05,0x38,0xd5]
4839 // CHECK: mrs x9, {{id_aa64afr1_el1|ID_AA64AFR1_EL1}} // encoding: [0xa9,0x05,0x38,0xd5]
4840 // CHECK: mrs x9, {{id_aa64isar0_el1|ID_AA64ISAR0_EL1}} // encoding: [0x09,0x06,0x38,0xd5]
4841 // CHECK: mrs x9, {{id_aa64isar1_el1|ID_AA64ISAR1_EL1}} // encoding: [0x29,0x06,0x38,0xd5]
4842 // CHECK: mrs x9, {{id_aa64mmfr0_el1|ID_AA64MMFR0_EL1}} // encoding: [0x09,0x07,0x38,0xd5]
4843 // CHECK: mrs x9, {{id_aa64mmfr1_el1|ID_AA64MMFR1_EL1}} // encoding: [0x29,0x07,0x38,0xd5]
4844 // CHECK: mrs x9, {{sctlr_el1|SCTLR_EL1}} // encoding: [0x09,0x10,0x38,0xd5]
4845 // CHECK: mrs x9, {{sctlr_el2|SCTLR_EL2}} // encoding: [0x09,0x10,0x3c,0xd5]
4846 // CHECK: mrs x9, {{sctlr_el3|SCTLR_EL3}} // encoding: [0x09,0x10,0x3e,0xd5]
4847 // CHECK: mrs x9, {{actlr_el1|ACTLR_EL1}} // encoding: [0x29,0x10,0x38,0xd5]
4848 // CHECK: mrs x9, {{actlr_el2|ACTLR_EL2}} // encoding: [0x29,0x10,0x3c,0xd5]
4849 // CHECK: mrs x9, {{actlr_el3|ACTLR_EL3}} // encoding: [0x29,0x10,0x3e,0xd5]
4850 // CHECK: mrs x9, {{cpacr_el1|CPACR_EL1}} // encoding: [0x49,0x10,0x38,0xd5]
4851 // CHECK: mrs x9, {{hcr_el2|HCR_EL2}} // encoding: [0x09,0x11,0x3c,0xd5]
4852 // CHECK: mrs x9, {{scr_el3|SCR_EL3}} // encoding: [0x09,0x11,0x3e,0xd5]
4853 // CHECK: mrs x9, {{mdcr_el2|MDCR_EL2}} // encoding: [0x29,0x11,0x3c,0xd5]
4854 // CHECK: mrs x9, {{sder32_el3|SDER32_EL3}} // encoding: [0x29,0x11,0x3e,0xd5]
4855 // CHECK: mrs x9, {{cptr_el2|CPTR_EL2}} // encoding: [0x49,0x11,0x3c,0xd5]
4856 // CHECK: mrs x9, {{cptr_el3|CPTR_EL3}} // encoding: [0x49,0x11,0x3e,0xd5]
4857 // CHECK: mrs x9, {{hstr_el2|HSTR_EL2}} // encoding: [0x69,0x11,0x3c,0xd5]
4858 // CHECK: mrs x9, {{hacr_el2|HACR_EL2}} // encoding: [0xe9,0x11,0x3c,0xd5]
4859 // CHECK: mrs x9, {{mdcr_el3|MDCR_EL3}} // encoding: [0x29,0x13,0x3e,0xd5]
4860 // CHECK: mrs x9, {{ttbr0_el1|TTBR0_EL1}} // encoding: [0x09,0x20,0x38,0xd5]
4861 // CHECK: mrs x9, {{ttbr0_el2|TTBR0_EL2}} // encoding: [0x09,0x20,0x3c,0xd5]
4862 // CHECK: mrs x9, {{ttbr0_el3|TTBR0_EL3}} // encoding: [0x09,0x20,0x3e,0xd5]
4863 // CHECK: mrs x9, {{ttbr1_el1|TTBR1_EL1}} // encoding: [0x29,0x20,0x38,0xd5]
4864 // CHECK: mrs x9, {{tcr_el1|TCR_EL1}} // encoding: [0x49,0x20,0x38,0xd5]
4865 // CHECK: mrs x9, {{tcr_el2|TCR_EL2}} // encoding: [0x49,0x20,0x3c,0xd5]
4866 // CHECK: mrs x9, {{tcr_el3|TCR_EL3}} // encoding: [0x49,0x20,0x3e,0xd5]
4867 // CHECK: mrs x9, {{vttbr_el2|VTTBR_EL2}} // encoding: [0x09,0x21,0x3c,0xd5]
4868 // CHECK: mrs x9, {{vtcr_el2|VTCR_EL2}} // encoding: [0x49,0x21,0x3c,0xd5]
4869 // CHECK: mrs x9, {{dacr32_el2|DACR32_EL2}} // encoding: [0x09,0x30,0x3c,0xd5]
4870 // CHECK: mrs x9, {{spsr_el1|SPSR_EL1}} // encoding: [0x09,0x40,0x38,0xd5]
4871 // CHECK: mrs x9, {{spsr_el2|SPSR_EL2}} // encoding: [0x09,0x40,0x3c,0xd5]
4872 // CHECK: mrs x9, {{spsr_el3|SPSR_EL3}} // encoding: [0x09,0x40,0x3e,0xd5]
4873 // CHECK: mrs x9, {{elr_el1|ELR_EL1}} // encoding: [0x29,0x40,0x38,0xd5]
4874 // CHECK: mrs x9, {{elr_el2|ELR_EL2}} // encoding: [0x29,0x40,0x3c,0xd5]
4875 // CHECK: mrs x9, {{elr_el3|ELR_EL3}} // encoding: [0x29,0x40,0x3e,0xd5]
4876 // CHECK: mrs x9, {{sp_el0|SP_EL0}} // encoding: [0x09,0x41,0x38,0xd5]
4877 // CHECK: mrs x9, {{sp_el1|SP_EL1}} // encoding: [0x09,0x41,0x3c,0xd5]
4878 // CHECK: mrs x9, {{sp_el2|SP_EL2}} // encoding: [0x09,0x41,0x3e,0xd5]
4879 // CHECK: mrs x9, {{spsel|SPSEL}} // encoding: [0x09,0x42,0x38,0xd5]
4880 // CHECK: mrs x9, {{nzcv|NZCV}} // encoding: [0x09,0x42,0x3b,0xd5]
4881 // CHECK: mrs x9, {{daif|DAIF}} // encoding: [0x29,0x42,0x3b,0xd5]
4882 // CHECK: mrs x9, {{currentel|CURRENTEL}} // encoding: [0x49,0x42,0x38,0xd5]
4883 // CHECK: mrs x9, {{spsr_irq|SPSR_IRQ}} // encoding: [0x09,0x43,0x3c,0xd5]
4884 // CHECK: mrs x9, {{spsr_abt|SPSR_ABT}} // encoding: [0x29,0x43,0x3c,0xd5]
4885 // CHECK: mrs x9, {{spsr_und|SPSR_UND}} // encoding: [0x49,0x43,0x3c,0xd5]
4886 // CHECK: mrs x9, {{spsr_fiq|SPSR_FIQ}} // encoding: [0x69,0x43,0x3c,0xd5]
4887 // CHECK: mrs x9, {{fpcr|FPCR}} // encoding: [0x09,0x44,0x3b,0xd5]
4888 // CHECK: mrs x9, {{fpsr|FPSR}} // encoding: [0x29,0x44,0x3b,0xd5]
4889 // CHECK: mrs x9, {{dspsr_el0|DSPSR_EL0}} // encoding: [0x09,0x45,0x3b,0xd5]
4890 // CHECK: mrs x9, {{dlr_el0|DLR_EL0}} // encoding: [0x29,0x45,0x3b,0xd5]
4891 // CHECK: mrs x9, {{ifsr32_el2|IFSR32_EL2}} // encoding: [0x29,0x50,0x3c,0xd5]
4892 // CHECK: mrs x9, {{afsr0_el1|AFSR0_EL1}} // encoding: [0x09,0x51,0x38,0xd5]
4893 // CHECK: mrs x9, {{afsr0_el2|AFSR0_EL2}} // encoding: [0x09,0x51,0x3c,0xd5]
4894 // CHECK: mrs x9, {{afsr0_el3|AFSR0_EL3}} // encoding: [0x09,0x51,0x3e,0xd5]
4895 // CHECK: mrs x9, {{afsr1_el1|AFSR1_EL1}} // encoding: [0x29,0x51,0x38,0xd5]
4896 // CHECK: mrs x9, {{afsr1_el2|AFSR1_EL2}} // encoding: [0x29,0x51,0x3c,0xd5]
4897 // CHECK: mrs x9, {{afsr1_el3|AFSR1_EL3}} // encoding: [0x29,0x51,0x3e,0xd5]
4898 // CHECK: mrs x9, {{esr_el1|ESR_EL1}} // encoding: [0x09,0x52,0x38,0xd5]
4899 // CHECK: mrs x9, {{esr_el2|ESR_EL2}} // encoding: [0x09,0x52,0x3c,0xd5]
4900 // CHECK: mrs x9, {{esr_el3|ESR_EL3}} // encoding: [0x09,0x52,0x3e,0xd5]
4901 // CHECK: mrs x9, {{fpexc32_el2|FPEXC32_EL2}} // encoding: [0x09,0x53,0x3c,0xd5]
4902 // CHECK: mrs x9, {{far_el1|FAR_EL1}} // encoding: [0x09,0x60,0x38,0xd5]
4903 // CHECK: mrs x9, {{far_el2|FAR_EL2}} // encoding: [0x09,0x60,0x3c,0xd5]
4904 // CHECK: mrs x9, {{far_el3|FAR_EL3}} // encoding: [0x09,0x60,0x3e,0xd5]
4905 // CHECK: mrs x9, {{hpfar_el2|HPFAR_EL2}} // encoding: [0x89,0x60,0x3c,0xd5]
4906 // CHECK: mrs x9, {{par_el1|PAR_EL1}} // encoding: [0x09,0x74,0x38,0xd5]
4907 // CHECK: mrs x9, {{pmcr_el0|PMCR_EL0}} // encoding: [0x09,0x9c,0x3b,0xd5]
4908 // CHECK: mrs x9, {{pmcntenset_el0|PMCNTENSET_EL0}} // encoding: [0x29,0x9c,0x3b,0xd5]
4909 // CHECK: mrs x9, {{pmcntenclr_el0|PMCNTENCLR_EL0}} // encoding: [0x49,0x9c,0x3b,0xd5]
4910 // CHECK: mrs x9, {{pmovsclr_el0|PMOVSCLR_EL0}} // encoding: [0x69,0x9c,0x3b,0xd5]
4911 // CHECK: mrs x9, {{pmselr_el0|PMSELR_EL0}} // encoding: [0xa9,0x9c,0x3b,0xd5]
4912 // CHECK: mrs x9, {{pmceid0_el0|PMCEID0_EL0}} // encoding: [0xc9,0x9c,0x3b,0xd5]
4913 // CHECK: mrs x9, {{pmceid1_el0|PMCEID1_EL0}} // encoding: [0xe9,0x9c,0x3b,0xd5]
4914 // CHECK: mrs x9, {{pmccntr_el0|PMCCNTR_EL0}} // encoding: [0x09,0x9d,0x3b,0xd5]
4915 // CHECK: mrs x9, {{pmxevtyper_el0|PMXEVTYPER_EL0}} // encoding: [0x29,0x9d,0x3b,0xd5]
4916 // CHECK: mrs x9, {{pmxevcntr_el0|PMXEVCNTR_EL0}} // encoding: [0x49,0x9d,0x3b,0xd5]
4917 // CHECK: mrs x9, {{pmuserenr_el0|PMUSERENR_EL0}} // encoding: [0x09,0x9e,0x3b,0xd5]
4918 // CHECK: mrs x9, {{pmintenset_el1|PMINTENSET_EL1}} // encoding: [0x29,0x9e,0x38,0xd5]
4919 // CHECK: mrs x9, {{pmintenclr_el1|PMINTENCLR_EL1}} // encoding: [0x49,0x9e,0x38,0xd5]
4920 // CHECK: mrs x9, {{pmovsset_el0|PMOVSSET_EL0}} // encoding: [0x69,0x9e,0x3b,0xd5]
4921 // CHECK: mrs x9, {{mair_el1|MAIR_EL1}} // encoding: [0x09,0xa2,0x38,0xd5]
4922 // CHECK: mrs x9, {{mair_el2|MAIR_EL2}} // encoding: [0x09,0xa2,0x3c,0xd5]
4923 // CHECK: mrs x9, {{mair_el3|MAIR_EL3}} // encoding: [0x09,0xa2,0x3e,0xd5]
4924 // CHECK: mrs x9, {{amair_el1|AMAIR_EL1}} // encoding: [0x09,0xa3,0x38,0xd5]
4925 // CHECK: mrs x9, {{amair_el2|AMAIR_EL2}} // encoding: [0x09,0xa3,0x3c,0xd5]
4926 // CHECK: mrs x9, {{amair_el3|AMAIR_EL3}} // encoding: [0x09,0xa3,0x3e,0xd5]
4927 // CHECK: mrs x9, {{vbar_el1|VBAR_EL1}} // encoding: [0x09,0xc0,0x38,0xd5]
4928 // CHECK: mrs x9, {{vbar_el2|VBAR_EL2}} // encoding: [0x09,0xc0,0x3c,0xd5]
4929 // CHECK: mrs x9, {{vbar_el3|VBAR_EL3}} // encoding: [0x09,0xc0,0x3e,0xd5]
4930 // CHECK: mrs x9, {{rvbar_el1|RVBAR_EL1}} // encoding: [0x29,0xc0,0x38,0xd5]
4931 // CHECK: mrs x9, {{rvbar_el2|RVBAR_EL2}} // encoding: [0x29,0xc0,0x3c,0xd5]
4932 // CHECK: mrs x9, {{rvbar_el3|RVBAR_EL3}} // encoding: [0x29,0xc0,0x3e,0xd5]
4933 // CHECK: mrs x9, {{rmr_el1|RMR_EL1}} // encoding: [0x49,0xc0,0x38,0xd5]
4934 // CHECK: mrs x9, {{rmr_el2|RMR_EL2}} // encoding: [0x49,0xc0,0x3c,0xd5]
4935 // CHECK: mrs x9, {{rmr_el3|RMR_EL3}} // encoding: [0x49,0xc0,0x3e,0xd5]
4936 // CHECK: mrs x9, {{isr_el1|ISR_EL1}} // encoding: [0x09,0xc1,0x38,0xd5]
4937 // CHECK: mrs x9, {{contextidr_el1|CONTEXTIDR_EL1}} // encoding: [0x29,0xd0,0x38,0xd5]
4938 // CHECK: mrs x9, {{tpidr_el0|TPIDR_EL0}} // encoding: [0x49,0xd0,0x3b,0xd5]
4939 // CHECK: mrs x9, {{tpidr_el2|TPIDR_EL2}} // encoding: [0x49,0xd0,0x3c,0xd5]
4940 // CHECK: mrs x9, {{tpidr_el3|TPIDR_EL3}} // encoding: [0x49,0xd0,0x3e,0xd5]
4941 // CHECK: mrs x9, {{tpidrro_el0|TPIDRRO_EL0}} // encoding: [0x69,0xd0,0x3b,0xd5]
4942 // CHECK: mrs x9, {{tpidr_el1|TPIDR_EL1}} // encoding: [0x89,0xd0,0x38,0xd5]
4943 // CHECK: mrs x9, {{cntfrq_el0|CNTFRQ_EL0}} // encoding: [0x09,0xe0,0x3b,0xd5]
4944 // CHECK: mrs x9, {{cntpct_el0|CNTPCT_EL0}} // encoding: [0x29,0xe0,0x3b,0xd5]
4945 // CHECK: mrs x9, {{cntvct_el0|CNTVCT_EL0}} // encoding: [0x49,0xe0,0x3b,0xd5]
4946 // CHECK: mrs x9, {{cntvoff_el2|CNTVOFF_EL2}} // encoding: [0x69,0xe0,0x3c,0xd5]
4947 // CHECK: mrs x9, {{cntkctl_el1|CNTKCTL_EL1}} // encoding: [0x09,0xe1,0x38,0xd5]
4948 // CHECK: mrs x9, {{cnthctl_el2|CNTHCTL_EL2}} // encoding: [0x09,0xe1,0x3c,0xd5]
4949 // CHECK: mrs x9, {{cntp_tval_el0|CNTP_TVAL_EL0}} // encoding: [0x09,0xe2,0x3b,0xd5]
4950 // CHECK: mrs x9, {{cnthp_tval_el2|CNTHP_TVAL_EL2}} // encoding: [0x09,0xe2,0x3c,0xd5]
4951 // CHECK: mrs x9, {{cntps_tval_el1|CNTPS_TVAL_EL1}} // encoding: [0x09,0xe2,0x3f,0xd5]
4952 // CHECK: mrs x9, {{cntp_ctl_el0|CNTP_CTL_EL0}} // encoding: [0x29,0xe2,0x3b,0xd5]
4953 // CHECK: mrs x9, {{cnthp_ctl_el2|CNTHP_CTL_EL2}} // encoding: [0x29,0xe2,0x3c,0xd5]
4954 // CHECK: mrs x9, {{cntps_ctl_el1|CNTPS_CTL_EL1}} // encoding: [0x29,0xe2,0x3f,0xd5]
4955 // CHECK: mrs x9, {{cntp_cval_el0|CNTP_CVAL_EL0}} // encoding: [0x49,0xe2,0x3b,0xd5]
4956 // CHECK: mrs x9, {{cnthp_cval_el2|CNTHP_CVAL_EL2}} // encoding: [0x49,0xe2,0x3c,0xd5]
4957 // CHECK: mrs x9, {{cntps_cval_el1|CNTPS_CVAL_EL1}} // encoding: [0x49,0xe2,0x3f,0xd5]
4958 // CHECK: mrs x9, {{cntv_tval_el0|CNTV_TVAL_EL0}} // encoding: [0x09,0xe3,0x3b,0xd5]
4959 // CHECK: mrs x9, {{cntv_ctl_el0|CNTV_CTL_EL0}} // encoding: [0x29,0xe3,0x3b,0xd5]
4960 // CHECK: mrs x9, {{cntv_cval_el0|CNTV_CVAL_EL0}} // encoding: [0x49,0xe3,0x3b,0xd5]
4961 // CHECK: mrs x9, {{pmevcntr0_el0|PMEVCNTR0_EL0}} // encoding: [0x09,0xe8,0x3b,0xd5]
4962 // CHECK: mrs x9, {{pmevcntr1_el0|PMEVCNTR1_EL0}} // encoding: [0x29,0xe8,0x3b,0xd5]
4963 // CHECK: mrs x9, {{pmevcntr2_el0|PMEVCNTR2_EL0}} // encoding: [0x49,0xe8,0x3b,0xd5]
4964 // CHECK: mrs x9, {{pmevcntr3_el0|PMEVCNTR3_EL0}} // encoding: [0x69,0xe8,0x3b,0xd5]
4965 // CHECK: mrs x9, {{pmevcntr4_el0|PMEVCNTR4_EL0}} // encoding: [0x89,0xe8,0x3b,0xd5]
4966 // CHECK: mrs x9, {{pmevcntr5_el0|PMEVCNTR5_EL0}} // encoding: [0xa9,0xe8,0x3b,0xd5]
4967 // CHECK: mrs x9, {{pmevcntr6_el0|PMEVCNTR6_EL0}} // encoding: [0xc9,0xe8,0x3b,0xd5]
4968 // CHECK: mrs x9, {{pmevcntr7_el0|PMEVCNTR7_EL0}} // encoding: [0xe9,0xe8,0x3b,0xd5]
4969 // CHECK: mrs x9, {{pmevcntr8_el0|PMEVCNTR8_EL0}} // encoding: [0x09,0xe9,0x3b,0xd5]
4970 // CHECK: mrs x9, {{pmevcntr9_el0|PMEVCNTR9_EL0}} // encoding: [0x29,0xe9,0x3b,0xd5]
4971 // CHECK: mrs x9, {{pmevcntr10_el0|PMEVCNTR10_EL0}} // encoding: [0x49,0xe9,0x3b,0xd5]
4972 // CHECK: mrs x9, {{pmevcntr11_el0|PMEVCNTR11_EL0}} // encoding: [0x69,0xe9,0x3b,0xd5]
4973 // CHECK: mrs x9, {{pmevcntr12_el0|PMEVCNTR12_EL0}} // encoding: [0x89,0xe9,0x3b,0xd5]
4974 // CHECK: mrs x9, {{pmevcntr13_el0|PMEVCNTR13_EL0}} // encoding: [0xa9,0xe9,0x3b,0xd5]
4975 // CHECK: mrs x9, {{pmevcntr14_el0|PMEVCNTR14_EL0}} // encoding: [0xc9,0xe9,0x3b,0xd5]
4976 // CHECK: mrs x9, {{pmevcntr15_el0|PMEVCNTR15_EL0}} // encoding: [0xe9,0xe9,0x3b,0xd5]
4977 // CHECK: mrs x9, {{pmevcntr16_el0|PMEVCNTR16_EL0}} // encoding: [0x09,0xea,0x3b,0xd5]
4978 // CHECK: mrs x9, {{pmevcntr17_el0|PMEVCNTR17_EL0}} // encoding: [0x29,0xea,0x3b,0xd5]
4979 // CHECK: mrs x9, {{pmevcntr18_el0|PMEVCNTR18_EL0}} // encoding: [0x49,0xea,0x3b,0xd5]
4980 // CHECK: mrs x9, {{pmevcntr19_el0|PMEVCNTR19_EL0}} // encoding: [0x69,0xea,0x3b,0xd5]
4981 // CHECK: mrs x9, {{pmevcntr20_el0|PMEVCNTR20_EL0}} // encoding: [0x89,0xea,0x3b,0xd5]
4982 // CHECK: mrs x9, {{pmevcntr21_el0|PMEVCNTR21_EL0}} // encoding: [0xa9,0xea,0x3b,0xd5]
4983 // CHECK: mrs x9, {{pmevcntr22_el0|PMEVCNTR22_EL0}} // encoding: [0xc9,0xea,0x3b,0xd5]
4984 // CHECK: mrs x9, {{pmevcntr23_el0|PMEVCNTR23_EL0}} // encoding: [0xe9,0xea,0x3b,0xd5]
4985 // CHECK: mrs x9, {{pmevcntr24_el0|PMEVCNTR24_EL0}} // encoding: [0x09,0xeb,0x3b,0xd5]
4986 // CHECK: mrs x9, {{pmevcntr25_el0|PMEVCNTR25_EL0}} // encoding: [0x29,0xeb,0x3b,0xd5]
4987 // CHECK: mrs x9, {{pmevcntr26_el0|PMEVCNTR26_EL0}} // encoding: [0x49,0xeb,0x3b,0xd5]
4988 // CHECK: mrs x9, {{pmevcntr27_el0|PMEVCNTR27_EL0}} // encoding: [0x69,0xeb,0x3b,0xd5]
4989 // CHECK: mrs x9, {{pmevcntr28_el0|PMEVCNTR28_EL0}} // encoding: [0x89,0xeb,0x3b,0xd5]
4990 // CHECK: mrs x9, {{pmevcntr29_el0|PMEVCNTR29_EL0}} // encoding: [0xa9,0xeb,0x3b,0xd5]
4991 // CHECK: mrs x9, {{pmevcntr30_el0|PMEVCNTR30_EL0}} // encoding: [0xc9,0xeb,0x3b,0xd5]
4992 // CHECK: mrs x9, {{pmccfiltr_el0|PMCCFILTR_EL0}} // encoding: [0xe9,0xef,0x3b,0xd5]
4993 // CHECK: mrs x9, {{pmevtyper0_el0|PMEVTYPER0_EL0}} // encoding: [0x09,0xec,0x3b,0xd5]
4994 // CHECK: mrs x9, {{pmevtyper1_el0|PMEVTYPER1_EL0}} // encoding: [0x29,0xec,0x3b,0xd5]
4995 // CHECK: mrs x9, {{pmevtyper2_el0|PMEVTYPER2_EL0}} // encoding: [0x49,0xec,0x3b,0xd5]
4996 // CHECK: mrs x9, {{pmevtyper3_el0|PMEVTYPER3_EL0}} // encoding: [0x69,0xec,0x3b,0xd5]
4997 // CHECK: mrs x9, {{pmevtyper4_el0|PMEVTYPER4_EL0}} // encoding: [0x89,0xec,0x3b,0xd5]
4998 // CHECK: mrs x9, {{pmevtyper5_el0|PMEVTYPER5_EL0}} // encoding: [0xa9,0xec,0x3b,0xd5]
4999 // CHECK: mrs x9, {{pmevtyper6_el0|PMEVTYPER6_EL0}} // encoding: [0xc9,0xec,0x3b,0xd5]
5000 // CHECK: mrs x9, {{pmevtyper7_el0|PMEVTYPER7_EL0}} // encoding: [0xe9,0xec,0x3b,0xd5]
5001 // CHECK: mrs x9, {{pmevtyper8_el0|PMEVTYPER8_EL0}} // encoding: [0x09,0xed,0x3b,0xd5]
5002 // CHECK: mrs x9, {{pmevtyper9_el0|PMEVTYPER9_EL0}} // encoding: [0x29,0xed,0x3b,0xd5]
5003 // CHECK: mrs x9, {{pmevtyper10_el0|PMEVTYPER10_EL0}} // encoding: [0x49,0xed,0x3b,0xd5]
5004 // CHECK: mrs x9, {{pmevtyper11_el0|PMEVTYPER11_EL0}} // encoding: [0x69,0xed,0x3b,0xd5]
5005 // CHECK: mrs x9, {{pmevtyper12_el0|PMEVTYPER12_EL0}} // encoding: [0x89,0xed,0x3b,0xd5]
5006 // CHECK: mrs x9, {{pmevtyper13_el0|PMEVTYPER13_EL0}} // encoding: [0xa9,0xed,0x3b,0xd5]
5007 // CHECK: mrs x9, {{pmevtyper14_el0|PMEVTYPER14_EL0}} // encoding: [0xc9,0xed,0x3b,0xd5]
5008 // CHECK: mrs x9, {{pmevtyper15_el0|PMEVTYPER15_EL0}} // encoding: [0xe9,0xed,0x3b,0xd5]
5009 // CHECK: mrs x9, {{pmevtyper16_el0|PMEVTYPER16_EL0}} // encoding: [0x09,0xee,0x3b,0xd5]
5010 // CHECK: mrs x9, {{pmevtyper17_el0|PMEVTYPER17_EL0}} // encoding: [0x29,0xee,0x3b,0xd5]
5011 // CHECK: mrs x9, {{pmevtyper18_el0|PMEVTYPER18_EL0}} // encoding: [0x49,0xee,0x3b,0xd5]
5012 // CHECK: mrs x9, {{pmevtyper19_el0|PMEVTYPER19_EL0}} // encoding: [0x69,0xee,0x3b,0xd5]
5013 // CHECK: mrs x9, {{pmevtyper20_el0|PMEVTYPER20_EL0}} // encoding: [0x89,0xee,0x3b,0xd5]
5014 // CHECK: mrs x9, {{pmevtyper21_el0|PMEVTYPER21_EL0}} // encoding: [0xa9,0xee,0x3b,0xd5]
5015 // CHECK: mrs x9, {{pmevtyper22_el0|PMEVTYPER22_EL0}} // encoding: [0xc9,0xee,0x3b,0xd5]
5016 // CHECK: mrs x9, {{pmevtyper23_el0|PMEVTYPER23_EL0}} // encoding: [0xe9,0xee,0x3b,0xd5]
5017 // CHECK: mrs x9, {{pmevtyper24_el0|PMEVTYPER24_EL0}} // encoding: [0x09,0xef,0x3b,0xd5]
5018 // CHECK: mrs x9, {{pmevtyper25_el0|PMEVTYPER25_EL0}} // encoding: [0x29,0xef,0x3b,0xd5]
5019 // CHECK: mrs x9, {{pmevtyper26_el0|PMEVTYPER26_EL0}} // encoding: [0x49,0xef,0x3b,0xd5]
5020 // CHECK: mrs x9, {{pmevtyper27_el0|PMEVTYPER27_EL0}} // encoding: [0x69,0xef,0x3b,0xd5]
5021 // CHECK: mrs x9, {{pmevtyper28_el0|PMEVTYPER28_EL0}} // encoding: [0x89,0xef,0x3b,0xd5]
5022 // CHECK: mrs x9, {{pmevtyper29_el0|PMEVTYPER29_EL0}} // encoding: [0xa9,0xef,0x3b,0xd5]
5023 // CHECK: mrs x9, {{pmevtyper30_el0|PMEVTYPER30_EL0}} // encoding: [0xc9,0xef,0x3b,0xd5]
5025 mrs x12, s3_7_c15_c1_5
5026 mrs x13, s3_2_c11_c15_7
5027 msr s3_0_c15_c0_0, x12
5028 msr s3_7_c11_c13_7, x5
5029 // CHECK: mrs x12, {{s3_7_c15_c1_5|S3_7_C15_C1_5}} // encoding: [0xac,0xf1,0x3f,0xd5]
5030 // CHECK: mrs x13, {{s3_2_c11_c15_7|S3_2_C11_C15_7}} // encoding: [0xed,0xbf,0x3a,0xd5]
5031 // CHECK: msr {{s3_0_c15_c0_0|S3_0_C15_C0_0}}, x12 // encoding: [0x0c,0xf0,0x18,0xd5]
5032 // CHECK: msr {{s3_7_c11_c13_7|S3_7_C11_C13_7}}, x5 // encoding: [0xe5,0xbd,0x1f,0xd5]
5034 //------------------------------------------------------------------------------
5035 // Unconditional branch (immediate)
5036 //------------------------------------------------------------------------------
5038 tbz x5, #0, somewhere
5039 tbz xzr, #63, elsewhere
5040 tbnz x5, #45, nowhere
5041 // CHECK-AARCH64: tbz x5, #0, somewhere // encoding: [0x05'A',A,A,0x36'A']
5042 // CHECK-AARCH64: // fixup A - offset: 0, value: somewhere, kind: fixup_a64_tstbr
5043 // CHECK-AARCH64: tbz xzr, #63, elsewhere // encoding: [0x1f'A',A,0xf8'A',0xb6'A']
5044 // CHECK-AARCH64: // fixup A - offset: 0, value: elsewhere, kind: fixup_a64_tstbr
5045 // CHECK-AARCH64: tbnz x5, #45, nowhere // encoding: [0x05'A',A,0x68'A',0xb7'A']
5046 // CHECK-AARCH64: // fixup A - offset: 0, value: nowhere, kind: fixup_a64_tstbr
5048 // CHECK-ARM64: tbz w5, #0, somewhere // encoding: [0bAAA00101,A,0b00000AAA,0x36]
5049 // CHECK-ARM64: // fixup A - offset: 0, value: somewhere, kind: fixup_arm64_pcrel_branch14
5050 // CHECK-ARM64: tbz xzr, #63, elsewhere // encoding: [0bAAA11111,A,0b11111AAA,0xb6]
5051 // CHECK-ARM64: // fixup A - offset: 0, value: elsewhere, kind: fixup_arm64_pcrel_branch14
5052 // CHECK-ARM64: tbnz x5, #45, nowhere // encoding: [0bAAA00101,A,0b01101AAA,0xb7]
5053 // CHECK-ARM64: // fixup A - offset: 0, value: nowhere, kind: fixup_arm64_pcrel_branch14
5057 tbnz wzr, #31, nowhere
5058 tbz w5, #12, anywhere
5059 // CHECK-AARCH64: tbnz w3, #2, there // encoding: [0x03'A',A,0x10'A',0x37'A']
5060 // CHECK-AARCH64: // fixup A - offset: 0, value: there, kind: fixup_a64_tstbr
5061 // CHECK-AARCH64: tbnz wzr, #31, nowhere // encoding: [0x1f'A',A,0xf8'A',0x37'A']
5062 // CHECK-AARCH64: // fixup A - offset: 0, value: nowhere, kind: fixup_a64_tstbr
5063 // CHECK-AARCH64: tbz w5, #12, anywhere // encoding: [0x05'A',A,0x60'A',0x36'A']
5064 // CHECK-AARCH64: // fixup A - offset: 0, value: anywhere, kind: fixup_a64_tstbr
5066 // CHECK-ARM64: tbnz w3, #2, there // encoding: [0bAAA00011,A,0b00010AAA,0x37]
5067 // CHECK-ARM64: // fixup A - offset: 0, value: there, kind: fixup_arm64_pcrel_branch14
5068 // CHECK-ARM64: tbnz wzr, #31, nowhere // encoding: [0bAAA11111,A,0b11111AAA,0x37]
5069 // CHECK-ARM64: // fixup A - offset: 0, value: nowhere, kind: fixup_arm64_pcrel_branch14
5070 // CHECK-ARM64: tbz w5, #12, anywhere // encoding: [0bAAA00101,A,0b01100AAA,0x36]
5071 // CHECK-ARM64: // fixup A - offset: 0, value: anywhere, kind: fixup_arm64_pcrel_branch14
5073 //------------------------------------------------------------------------------
5074 // Unconditional branch (immediate)
5075 //------------------------------------------------------------------------------
5079 // CHECK-AARCH64: b somewhere // encoding: [A,A,A,0x14'A']
5080 // CHECK-AARCH64: // fixup A - offset: 0, value: somewhere, kind: fixup_a64_uncondbr
5081 // CHECK-AARCH64: bl elsewhere // encoding: [A,A,A,0x94'A']
5082 // CHECK-AARCH64: // fixup A - offset: 0, value: elsewhere, kind: fixup_a64_call
5084 // CHECK-ARM64: b somewhere // encoding: [A,A,A,0b000101AA]
5085 // CHECK-ARM64: // fixup A - offset: 0, value: somewhere, kind: fixup_arm64_pcrel_branch26
5086 // CHECK-ARM64: bl elsewhere // encoding: [A,A,A,0b100101AA]
5087 // CHECK-ARM64: // fixup A - offset: 0, value: elsewhere, kind: fixup_arm64_pcrel_call26
5093 // CHECK: b #4 // encoding: [0x01,0x00,0x00,0x14]
5094 // CHECK: bl #0 // encoding: [0x00,0x00,0x00,0x94]
5095 // CHECK: b #134217724 // encoding: [0xff,0xff,0xff,0x15]
5096 // CHECK: bl #-134217728 // encoding: [0x00,0x00,0x00,0x96]
5098 //------------------------------------------------------------------------------
5099 // Unconditional branch (register)
5100 //------------------------------------------------------------------------------
5105 // CHECK: br x20 // encoding: [0x80,0x02,0x1f,0xd6]
5106 // CHECK: blr xzr // encoding: [0xe0,0x03,0x3f,0xd6]
5107 // CHECK: ret x10 // encoding: [0x40,0x01,0x5f,0xd6]
5112 // CHECK: ret // encoding: [0xc0,0x03,0x5f,0xd6]
5113 // CHECK: eret // encoding: [0xe0,0x03,0x9f,0xd6]
5114 // CHECK: drps // encoding: [0xe0,0x03,0xbf,0xd6]