test/MC/AArch64/basic-a64-instructions.s

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