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