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