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