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