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