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

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