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

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