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