mirror of
https://github.com/RPCS3/llvm.git
synced 2024-12-30 16:34:03 +00:00
cbff068398
These instructions are a late addition to the architecture, and may yet end up behind an optional attribute, but for now they're available at all times. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@174496 91177308-0d34-0410-b5e6-96231b3b80d8
4820 lines
235 KiB
ArmAsm
4820 lines
235 KiB
ArmAsm
// RUN: llvm-mc -triple=aarch64 -show-encoding < %s | FileCheck %s
|
|
.globl _func
|
|
|
|
// Check that the assembler can handle the documented syntax from the ARM ARM.
|
|
// For complex constructs like shifter operands, check more thoroughly for them
|
|
// once then spot check that following instructions accept the form generally.
|
|
// This gives us good coverage while keeping the overall size of the test
|
|
// more reasonable.
|
|
|
|
|
|
_func:
|
|
// CHECK: _func
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Add/sub (extended register)
|
|
//------------------------------------------------------------------------------
|
|
// Basic extends 64-bit ops
|
|
add x2, x4, w5, uxtb
|
|
add x20, sp, w19, uxth
|
|
add x12, x1, w20, uxtw
|
|
add x20, x3, x13, uxtx
|
|
add x17, x25, w20, sxtb
|
|
add x18, x13, w19, sxth
|
|
add sp, x2, w3, sxtw
|
|
add x3, x5, x9, sxtx
|
|
// CHECK: add x2, x4, w5, uxtb // encoding: [0x82,0x00,0x25,0x8b]
|
|
// CHECK: add x20, sp, w19, uxth // encoding: [0xf4,0x23,0x33,0x8b]
|
|
// CHECK: add x12, x1, w20, uxtw // encoding: [0x2c,0x40,0x34,0x8b]
|
|
// CHECK: add x20, x3, x13, uxtx // encoding: [0x74,0x60,0x2d,0x8b]
|
|
// CHECK: add x17, x25, w20, sxtb // encoding: [0x31,0x83,0x34,0x8b]
|
|
// CHECK: add x18, x13, w19, sxth // encoding: [0xb2,0xa1,0x33,0x8b]
|
|
// CHECK: add sp, x2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0x8b]
|
|
// CHECK: add x3, x5, x9, sxtx // encoding: [0xa3,0xe0,0x29,0x8b]
|
|
|
|
// Basic extends, 32-bit ops
|
|
add w2, w5, w7, uxtb
|
|
add w21, w15, w17, uxth
|
|
add w30, w29, wzr, uxtw
|
|
add w19, w17, w1, uxtx // Goodness knows what this means
|
|
add w2, w5, w1, sxtb
|
|
add w26, w17, w19, sxth
|
|
add w0, w2, w3, sxtw
|
|
add w2, w3, w5, sxtx
|
|
// CHECK: add w2, w5, w7, uxtb // encoding: [0xa2,0x00,0x27,0x0b]
|
|
// CHECK: add w21, w15, w17, uxth // encoding: [0xf5,0x21,0x31,0x0b]
|
|
// CHECK: add w30, w29, wzr, uxtw // encoding: [0xbe,0x43,0x3f,0x0b]
|
|
// CHECK: add w19, w17, w1, uxtx // encoding: [0x33,0x62,0x21,0x0b]
|
|
// CHECK: add w2, w5, w1, sxtb // encoding: [0xa2,0x80,0x21,0x0b]
|
|
// CHECK: add w26, w17, w19, sxth // encoding: [0x3a,0xa2,0x33,0x0b]
|
|
// CHECK: add w0, w2, w3, sxtw // encoding: [0x40,0xc0,0x23,0x0b]
|
|
// CHECK: add w2, w3, w5, sxtx // encoding: [0x62,0xe0,0x25,0x0b]
|
|
|
|
// Nonzero shift amounts
|
|
add x2, x3, w5, sxtb #0
|
|
add x7, x11, w13, uxth #4
|
|
add w17, w19, w23, uxtw #2
|
|
add w29, w23, w17, uxtx #1
|
|
// CHECK: add x2, x3, w5, sxtb // encoding: [0x62,0x80,0x25,0x8b]
|
|
// CHECK: add x7, x11, w13, uxth #4 // encoding: [0x67,0x31,0x2d,0x8b]
|
|
// CHECK: add w17, w19, w23, uxtw #2 // encoding: [0x71,0x4a,0x37,0x0b]
|
|
// CHECK: add w29, w23, w17, uxtx #1 // encoding: [0xfd,0x66,0x31,0x0b]
|
|
|
|
// Sub
|
|
sub x2, x4, w5, uxtb #2
|
|
sub x20, sp, w19, uxth #4
|
|
sub x12, x1, w20, uxtw
|
|
sub x20, x3, x13, uxtx #0
|
|
sub x17, x25, w20, sxtb
|
|
sub x18, x13, w19, sxth
|
|
sub sp, x2, w3, sxtw
|
|
sub x3, x5, x9, sxtx
|
|
// CHECK: sub x2, x4, w5, uxtb #2 // encoding: [0x82,0x08,0x25,0xcb]
|
|
// CHECK: sub x20, sp, w19, uxth #4 // encoding: [0xf4,0x33,0x33,0xcb]
|
|
// CHECK: sub x12, x1, w20, uxtw // encoding: [0x2c,0x40,0x34,0xcb]
|
|
// CHECK: sub x20, x3, x13, uxtx // encoding: [0x74,0x60,0x2d,0xcb]
|
|
// CHECK: sub x17, x25, w20, sxtb // encoding: [0x31,0x83,0x34,0xcb]
|
|
// CHECK: sub x18, x13, w19, sxth // encoding: [0xb2,0xa1,0x33,0xcb]
|
|
// CHECK: sub sp, x2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0xcb]
|
|
// CHECK: sub x3, x5, x9, sxtx // encoding: [0xa3,0xe0,0x29,0xcb]
|
|
|
|
sub w2, w5, w7, uxtb
|
|
sub w21, w15, w17, uxth
|
|
sub w30, w29, wzr, uxtw
|
|
sub w19, w17, w1, uxtx // Goodness knows what this means
|
|
sub w2, w5, w1, sxtb
|
|
sub w26, wsp, w19, sxth
|
|
sub wsp, w2, w3, sxtw
|
|
sub w2, w3, w5, sxtx
|
|
// CHECK: sub w2, w5, w7, uxtb // encoding: [0xa2,0x00,0x27,0x4b]
|
|
// CHECK: sub w21, w15, w17, uxth // encoding: [0xf5,0x21,0x31,0x4b]
|
|
// CHECK: sub w30, w29, wzr, uxtw // encoding: [0xbe,0x43,0x3f,0x4b]
|
|
// CHECK: sub w19, w17, w1, uxtx // encoding: [0x33,0x62,0x21,0x4b]
|
|
// CHECK: sub w2, w5, w1, sxtb // encoding: [0xa2,0x80,0x21,0x4b]
|
|
// CHECK: sub w26, wsp, w19, sxth // encoding: [0xfa,0xa3,0x33,0x4b]
|
|
// CHECK: sub wsp, w2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0x4b]
|
|
// CHECK: sub w2, w3, w5, sxtx // encoding: [0x62,0xe0,0x25,0x4b]
|
|
|
|
// Adds
|
|
adds x2, x4, w5, uxtb #2
|
|
adds x20, sp, w19, uxth #4
|
|
adds x12, x1, w20, uxtw
|
|
adds x20, x3, x13, uxtx #0
|
|
adds xzr, x25, w20, sxtb #3
|
|
adds x18, sp, w19, sxth
|
|
adds xzr, x2, w3, sxtw
|
|
adds x3, x5, x9, sxtx #2
|
|
// CHECK: adds x2, x4, w5, uxtb #2 // encoding: [0x82,0x08,0x25,0xab]
|
|
// CHECK: adds x20, sp, w19, uxth #4 // encoding: [0xf4,0x33,0x33,0xab]
|
|
// CHECK: adds x12, x1, w20, uxtw // encoding: [0x2c,0x40,0x34,0xab]
|
|
// CHECK: adds x20, x3, x13, uxtx // encoding: [0x74,0x60,0x2d,0xab]
|
|
// CHECK: adds xzr, x25, w20, sxtb #3 // encoding: [0x3f,0x8f,0x34,0xab]
|
|
// CHECK: adds x18, sp, w19, sxth // encoding: [0xf2,0xa3,0x33,0xab]
|
|
// CHECK: adds xzr, x2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0xab]
|
|
// CHECK: adds x3, x5, x9, sxtx #2 // encoding: [0xa3,0xe8,0x29,0xab]
|
|
|
|
adds w2, w5, w7, uxtb
|
|
adds w21, w15, w17, uxth
|
|
adds w30, w29, wzr, uxtw
|
|
adds w19, w17, w1, uxtx // Goodness knows what this means
|
|
adds w2, w5, w1, sxtb #1
|
|
adds w26, wsp, w19, sxth
|
|
adds wzr, w2, w3, sxtw
|
|
adds w2, w3, w5, sxtx
|
|
// CHECK: adds w2, w5, w7, uxtb // encoding: [0xa2,0x00,0x27,0x2b]
|
|
// CHECK: adds w21, w15, w17, uxth // encoding: [0xf5,0x21,0x31,0x2b]
|
|
// CHECK: adds w30, w29, wzr, uxtw // encoding: [0xbe,0x43,0x3f,0x2b]
|
|
// CHECK: adds w19, w17, w1, uxtx // encoding: [0x33,0x62,0x21,0x2b]
|
|
// CHECK: adds w2, w5, w1, sxtb #1 // encoding: [0xa2,0x84,0x21,0x2b]
|
|
// CHECK: adds w26, wsp, w19, sxth // encoding: [0xfa,0xa3,0x33,0x2b]
|
|
// CHECK: adds wzr, w2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0x2b]
|
|
// CHECK: adds w2, w3, w5, sxtx // encoding: [0x62,0xe0,0x25,0x2b]
|
|
|
|
// subs
|
|
subs x2, x4, w5, uxtb #2
|
|
subs x20, sp, w19, uxth #4
|
|
subs x12, x1, w20, uxtw
|
|
subs x20, x3, x13, uxtx #0
|
|
subs xzr, x25, w20, sxtb #3
|
|
subs x18, sp, w19, sxth
|
|
subs xzr, x2, w3, sxtw
|
|
subs x3, x5, x9, sxtx #2
|
|
// CHECK: subs x2, x4, w5, uxtb #2 // encoding: [0x82,0x08,0x25,0xeb]
|
|
// CHECK: subs x20, sp, w19, uxth #4 // encoding: [0xf4,0x33,0x33,0xeb]
|
|
// CHECK: subs x12, x1, w20, uxtw // encoding: [0x2c,0x40,0x34,0xeb]
|
|
// CHECK: subs x20, x3, x13, uxtx // encoding: [0x74,0x60,0x2d,0xeb]
|
|
// CHECK: subs xzr, x25, w20, sxtb #3 // encoding: [0x3f,0x8f,0x34,0xeb]
|
|
// CHECK: subs x18, sp, w19, sxth // encoding: [0xf2,0xa3,0x33,0xeb]
|
|
// CHECK: subs xzr, x2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0xeb]
|
|
// CHECK: subs x3, x5, x9, sxtx #2 // encoding: [0xa3,0xe8,0x29,0xeb]
|
|
|
|
subs w2, w5, w7, uxtb
|
|
subs w21, w15, w17, uxth
|
|
subs w30, w29, wzr, uxtw
|
|
subs w19, w17, w1, uxtx // Goodness knows what this means
|
|
subs w2, w5, w1, sxtb #1
|
|
subs w26, wsp, w19, sxth
|
|
subs wzr, w2, w3, sxtw
|
|
subs w2, w3, w5, sxtx
|
|
// CHECK: subs w2, w5, w7, uxtb // encoding: [0xa2,0x00,0x27,0x6b]
|
|
// CHECK: subs w21, w15, w17, uxth // encoding: [0xf5,0x21,0x31,0x6b]
|
|
// CHECK: subs w30, w29, wzr, uxtw // encoding: [0xbe,0x43,0x3f,0x6b]
|
|
// CHECK: subs w19, w17, w1, uxtx // encoding: [0x33,0x62,0x21,0x6b]
|
|
// CHECK: subs w2, w5, w1, sxtb #1 // encoding: [0xa2,0x84,0x21,0x6b]
|
|
// CHECK: subs w26, wsp, w19, sxth // encoding: [0xfa,0xa3,0x33,0x6b]
|
|
// CHECK: subs wzr, w2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0x6b]
|
|
// CHECK: subs w2, w3, w5, sxtx // encoding: [0x62,0xe0,0x25,0x6b]
|
|
|
|
// cmp
|
|
cmp x4, w5, uxtb #2
|
|
cmp sp, w19, uxth #4
|
|
cmp x1, w20, uxtw
|
|
cmp x3, x13, uxtx #0
|
|
cmp x25, w20, sxtb #3
|
|
cmp sp, w19, sxth
|
|
cmp x2, w3, sxtw
|
|
cmp x5, x9, sxtx #2
|
|
// CHECK: cmp x4, w5, uxtb #2 // encoding: [0x9f,0x08,0x25,0xeb]
|
|
// CHECK: cmp sp, w19, uxth #4 // encoding: [0xff,0x33,0x33,0xeb]
|
|
// CHECK: cmp x1, w20, uxtw // encoding: [0x3f,0x40,0x34,0xeb]
|
|
// CHECK: cmp x3, x13, uxtx // encoding: [0x7f,0x60,0x2d,0xeb]
|
|
// CHECK: cmp x25, w20, sxtb #3 // encoding: [0x3f,0x8f,0x34,0xeb]
|
|
// CHECK: cmp sp, w19, sxth // encoding: [0xff,0xa3,0x33,0xeb]
|
|
// CHECK: cmp x2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0xeb]
|
|
// CHECK: cmp x5, x9, sxtx #2 // encoding: [0xbf,0xe8,0x29,0xeb]
|
|
|
|
cmp w5, w7, uxtb
|
|
cmp w15, w17, uxth
|
|
cmp w29, wzr, uxtw
|
|
cmp w17, w1, uxtx // Goodness knows what this means
|
|
cmp w5, w1, sxtb #1
|
|
cmp wsp, w19, sxth
|
|
cmp w2, w3, sxtw
|
|
cmp w3, w5, sxtx
|
|
// CHECK: cmp w5, w7, uxtb // encoding: [0xbf,0x00,0x27,0x6b]
|
|
// CHECK: cmp w15, w17, uxth // encoding: [0xff,0x21,0x31,0x6b]
|
|
// CHECK: cmp w29, wzr, uxtw // encoding: [0xbf,0x43,0x3f,0x6b]
|
|
// CHECK: cmp w17, w1, uxtx // encoding: [0x3f,0x62,0x21,0x6b]
|
|
// CHECK: cmp w5, w1, sxtb #1 // encoding: [0xbf,0x84,0x21,0x6b]
|
|
// CHECK: cmp wsp, w19, sxth // encoding: [0xff,0xa3,0x33,0x6b]
|
|
// CHECK: cmp w2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0x6b]
|
|
// CHECK: cmp w3, w5, sxtx // encoding: [0x7f,0xe0,0x25,0x6b]
|
|
|
|
|
|
// cmn
|
|
cmn x4, w5, uxtb #2
|
|
cmn sp, w19, uxth #4
|
|
cmn x1, w20, uxtw
|
|
cmn x3, x13, uxtx #0
|
|
cmn x25, w20, sxtb #3
|
|
cmn sp, w19, sxth
|
|
cmn x2, w3, sxtw
|
|
cmn x5, x9, sxtx #2
|
|
// CHECK: cmn x4, w5, uxtb #2 // encoding: [0x9f,0x08,0x25,0xab]
|
|
// CHECK: cmn sp, w19, uxth #4 // encoding: [0xff,0x33,0x33,0xab]
|
|
// CHECK: cmn x1, w20, uxtw // encoding: [0x3f,0x40,0x34,0xab]
|
|
// CHECK: cmn x3, x13, uxtx // encoding: [0x7f,0x60,0x2d,0xab]
|
|
// CHECK: cmn x25, w20, sxtb #3 // encoding: [0x3f,0x8f,0x34,0xab]
|
|
// CHECK: cmn sp, w19, sxth // encoding: [0xff,0xa3,0x33,0xab]
|
|
// CHECK: cmn x2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0xab]
|
|
// CHECK: cmn x5, x9, sxtx #2 // encoding: [0xbf,0xe8,0x29,0xab]
|
|
|
|
cmn w5, w7, uxtb
|
|
cmn w15, w17, uxth
|
|
cmn w29, wzr, uxtw
|
|
cmn w17, w1, uxtx // Goodness knows what this means
|
|
cmn w5, w1, sxtb #1
|
|
cmn wsp, w19, sxth
|
|
cmn w2, w3, sxtw
|
|
cmn w3, w5, sxtx
|
|
// CHECK: cmn w5, w7, uxtb // encoding: [0xbf,0x00,0x27,0x2b]
|
|
// CHECK: cmn w15, w17, uxth // encoding: [0xff,0x21,0x31,0x2b]
|
|
// CHECK: cmn w29, wzr, uxtw // encoding: [0xbf,0x43,0x3f,0x2b]
|
|
// CHECK: cmn w17, w1, uxtx // encoding: [0x3f,0x62,0x21,0x2b]
|
|
// CHECK: cmn w5, w1, sxtb #1 // encoding: [0xbf,0x84,0x21,0x2b]
|
|
// CHECK: cmn wsp, w19, sxth // encoding: [0xff,0xa3,0x33,0x2b]
|
|
// CHECK: cmn w2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0x2b]
|
|
// CHECK: cmn w3, w5, sxtx // encoding: [0x7f,0xe0,0x25,0x2b]
|
|
|
|
// operands for cmp
|
|
cmp x20, w29, uxtb #3
|
|
cmp x12, x13, uxtx #4
|
|
cmp wsp, w1, uxtb
|
|
cmn wsp, wzr, sxtw
|
|
// CHECK: cmp x20, w29, uxtb #3 // encoding: [0x9f,0x0e,0x3d,0xeb]
|
|
// CHECK: cmp x12, x13, uxtx #4 // encoding: [0x9f,0x71,0x2d,0xeb]
|
|
// CHECK: cmp wsp, w1, uxtb // encoding: [0xff,0x03,0x21,0x6b]
|
|
// CHECK: cmn wsp, wzr, sxtw // encoding: [0xff,0xc3,0x3f,0x2b]
|
|
|
|
// LSL variant if sp involved
|
|
sub sp, x3, x7, lsl #4
|
|
add w2, wsp, w3, lsl #1
|
|
cmp wsp, w9, lsl #0
|
|
adds wzr, wsp, w3, lsl #4
|
|
subs x3, sp, x9, lsl #2
|
|
// CHECK: sub sp, x3, x7, lsl #4 // encoding: [0x7f,0x70,0x27,0xcb]
|
|
// CHECK: add w2, wsp, w3, lsl #1 // encoding: [0xe2,0x47,0x23,0x0b]
|
|
// CHECK: cmp wsp, w9 // encoding: [0xff,0x43,0x29,0x6b]
|
|
// CHECK: adds wzr, wsp, w3, lsl #4 // encoding: [0xff,0x53,0x23,0x2b]
|
|
// CHECK: subs x3, sp, x9, lsl #2 // encoding: [0xe3,0x6b,0x29,0xeb]
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Add/sub (immediate)
|
|
//------------------------------------------------------------------------------
|
|
|
|
// Check basic immediate values: an unsigned 12-bit immediate, optionally
|
|
// shifted left by 12 bits.
|
|
add w4, w5, #0x0
|
|
add w2, w3, #4095
|
|
add w30, w29, #1, lsl #12
|
|
add w13, w5, #4095, lsl #12
|
|
add x5, x7, #1638
|
|
// CHECK: add w4, w5, #0 // encoding: [0xa4,0x00,0x00,0x11]
|
|
// CHECK: add w2, w3, #4095 // encoding: [0x62,0xfc,0x3f,0x11]
|
|
// CHECK: add w30, w29, #1, lsl #12 // encoding: [0xbe,0x07,0x40,0x11]
|
|
// CHECK: add w13, w5, #4095, lsl #12 // encoding: [0xad,0xfc,0x7f,0x11]
|
|
// CHECK: add x5, x7, #1638 // encoding: [0xe5,0x98,0x19,0x91]
|
|
|
|
// All registers involved in the non-S variants have 31 encoding sp rather than zr
|
|
add w20, wsp, #801, lsl #0
|
|
add wsp, wsp, #1104
|
|
add wsp, w30, #4084
|
|
// CHECK: add w20, wsp, #801 // encoding: [0xf4,0x87,0x0c,0x11]
|
|
// CHECK: add wsp, wsp, #1104 // encoding: [0xff,0x43,0x11,0x11]
|
|
// CHECK: add wsp, w30, #4084 // encoding: [0xdf,0xd3,0x3f,0x11]
|
|
|
|
// A few checks on the sanity of 64-bit versions
|
|
add x0, x24, #291
|
|
add x3, x24, #4095, lsl #12
|
|
add x8, sp, #1074
|
|
add sp, x29, #3816
|
|
// CHECK: add x0, x24, #291 // encoding: [0x00,0x8f,0x04,0x91]
|
|
// CHECK: add x3, x24, #4095, lsl #12 // encoding: [0x03,0xff,0x7f,0x91]
|
|
// CHECK: add x8, sp, #1074 // encoding: [0xe8,0xcb,0x10,0x91]
|
|
// CHECK: add sp, x29, #3816 // encoding: [0xbf,0xa3,0x3b,0x91]
|
|
|
|
// And on sub
|
|
sub w0, wsp, #4077
|
|
sub w4, w20, #546, lsl #12
|
|
sub sp, sp, #288
|
|
sub wsp, w19, #16
|
|
// CHECK: sub w0, wsp, #4077 // encoding: [0xe0,0xb7,0x3f,0x51]
|
|
// CHECK: sub w4, w20, #546, lsl #12 // encoding: [0x84,0x8a,0x48,0x51]
|
|
// CHECK: sub sp, sp, #288 // encoding: [0xff,0x83,0x04,0xd1]
|
|
// CHECK: sub wsp, w19, #16 // encoding: [0x7f,0x42,0x00,0x51]
|
|
|
|
// ADDS/SUBS accept zr in the Rd position but sp in the Rn position
|
|
adds w13, w23, #291, lsl #12
|
|
adds wzr, w2, #4095 // FIXME: canonically should be cmn
|
|
adds w20, wsp, #0x0
|
|
adds xzr, x3, #0x1, lsl #12 // FIXME: canonically should be cmn
|
|
// CHECK: adds w13, w23, #291, lsl #12 // encoding: [0xed,0x8e,0x44,0x31]
|
|
// CHECK: adds wzr, w2, #4095 // encoding: [0x5f,0xfc,0x3f,0x31]
|
|
// CHECK: adds w20, wsp, #0 // encoding: [0xf4,0x03,0x00,0x31]
|
|
// CHECK: adds xzr, x3, #1, lsl #12 // encoding: [0x7f,0x04,0x40,0xb1]
|
|
|
|
// Checks for subs
|
|
subs xzr, sp, #20, lsl #12 // FIXME: canonically should be cmp
|
|
subs xzr, x30, #4095, lsl #0 // FIXME: canonically should be cmp
|
|
subs x4, sp, #3822
|
|
// CHECK: subs xzr, sp, #20, lsl #12 // encoding: [0xff,0x53,0x40,0xf1]
|
|
// CHECK: subs xzr, x30, #4095 // encoding: [0xdf,0xff,0x3f,0xf1]
|
|
// CHECK: subs x4, sp, #3822 // encoding: [0xe4,0xbb,0x3b,0xf1]
|
|
|
|
// cmn is an alias for adds zr, ...
|
|
cmn w3, #291, lsl #12
|
|
cmn wsp, #1365, lsl #0
|
|
cmn sp, #1092, lsl #12
|
|
// CHECK: cmn w3, #291, lsl #12 // encoding: [0x7f,0x8c,0x44,0x31]
|
|
// CHECK: cmn wsp, #1365 // encoding: [0xff,0x57,0x15,0x31]
|
|
// CHECK: cmn sp, #1092, lsl #12 // encoding: [0xff,0x13,0x51,0xb1]
|
|
|
|
// cmp is an alias for subs zr, ... (FIXME: should always disassemble as such too).
|
|
cmp x4, #300, lsl #12
|
|
cmp wsp, #500
|
|
cmp sp, #200, lsl #0
|
|
// CHECK: cmp x4, #300, lsl #12 // encoding: [0x9f,0xb0,0x44,0xf1]
|
|
// CHECK: cmp wsp, #500 // encoding: [0xff,0xd3,0x07,0x71]
|
|
// CHECK: cmp sp, #200 // encoding: [0xff,0x23,0x03,0xf1]
|
|
|
|
// A "MOV" involving sp is encoded in this manner: add Reg, Reg, #0
|
|
mov sp, x30
|
|
mov wsp, w20
|
|
mov x11, sp
|
|
mov w24, wsp
|
|
// CHECK: mov sp, x30 // encoding: [0xdf,0x03,0x00,0x91]
|
|
// CHECK: mov wsp, w20 // encoding: [0x9f,0x02,0x00,0x11]
|
|
// CHECK: mov x11, sp // encoding: [0xeb,0x03,0x00,0x91]
|
|
// CHECK: mov w24, wsp // encoding: [0xf8,0x03,0x00,0x11]
|
|
|
|
// A relocation check (default to lo12, which is the only sane relocation anyway really)
|
|
add x0, x4, #:lo12:var
|
|
// CHECK: add x0, x4, #:lo12:var // encoding: [0x80'A',A,A,0x91'A']
|
|
// CHECK: // fixup A - offset: 0, value: :lo12:var, kind: fixup_a64_add_lo12
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Add-sub (shifted register)
|
|
//------------------------------------------------------------------------------
|
|
|
|
// As usual, we don't print the canonical forms of many instructions.
|
|
|
|
add w3, w5, w7
|
|
add wzr, w3, w5
|
|
add w20, wzr, w4
|
|
add w4, w6, wzr
|
|
// CHECK: add w3, w5, w7 // encoding: [0xa3,0x00,0x07,0x0b]
|
|
// CHECK: add wzr, w3, w5 // encoding: [0x7f,0x00,0x05,0x0b]
|
|
// CHECK: add w20, wzr, w4 // encoding: [0xf4,0x03,0x04,0x0b]
|
|
// CHECK: add w4, w6, wzr // encoding: [0xc4,0x00,0x1f,0x0b]
|
|
|
|
add w11, w13, w15, lsl #0
|
|
add w9, w3, wzr, lsl #10
|
|
add w17, w29, w20, lsl #31
|
|
// CHECK: add w11, w13, w15 // encoding: [0xab,0x01,0x0f,0x0b]
|
|
// CHECK: add w9, w3, wzr, lsl #10 // encoding: [0x69,0x28,0x1f,0x0b]
|
|
// CHECK: add w17, w29, w20, lsl #31 // encoding: [0xb1,0x7f,0x14,0x0b]
|
|
|
|
add w21, w22, w23, lsr #0
|
|
add w24, w25, w26, lsr #18
|
|
add w27, w28, w29, lsr #31
|
|
// CHECK: add w21, w22, w23, lsr #0 // encoding: [0xd5,0x02,0x57,0x0b]
|
|
// CHECK: add w24, w25, w26, lsr #18 // encoding: [0x38,0x4b,0x5a,0x0b]
|
|
// CHECK: add w27, w28, w29, lsr #31 // encoding: [0x9b,0x7f,0x5d,0x0b]
|
|
|
|
add w2, w3, w4, asr #0
|
|
add w5, w6, w7, asr #21
|
|
add w8, w9, w10, asr #31
|
|
// CHECK: add w2, w3, w4, asr #0 // encoding: [0x62,0x00,0x84,0x0b]
|
|
// CHECK: add w5, w6, w7, asr #21 // encoding: [0xc5,0x54,0x87,0x0b]
|
|
// CHECK: add w8, w9, w10, asr #31 // encoding: [0x28,0x7d,0x8a,0x0b]
|
|
|
|
add x3, x5, x7
|
|
add xzr, x3, x5
|
|
add x20, xzr, x4
|
|
add x4, x6, xzr
|
|
// CHECK: add x3, x5, x7 // encoding: [0xa3,0x00,0x07,0x8b]
|
|
// CHECK: add xzr, x3, x5 // encoding: [0x7f,0x00,0x05,0x8b]
|
|
// CHECK: add x20, xzr, x4 // encoding: [0xf4,0x03,0x04,0x8b]
|
|
// CHECK: add x4, x6, xzr // encoding: [0xc4,0x00,0x1f,0x8b]
|
|
|
|
add x11, x13, x15, lsl #0
|
|
add x9, x3, xzr, lsl #10
|
|
add x17, x29, x20, lsl #63
|
|
// CHECK: add x11, x13, x15 // encoding: [0xab,0x01,0x0f,0x8b]
|
|
// CHECK: add x9, x3, xzr, lsl #10 // encoding: [0x69,0x28,0x1f,0x8b]
|
|
// CHECK: add x17, x29, x20, lsl #63 // encoding: [0xb1,0xff,0x14,0x8b]
|
|
|
|
add x21, x22, x23, lsr #0
|
|
add x24, x25, x26, lsr #18
|
|
add x27, x28, x29, lsr #63
|
|
// CHECK: add x21, x22, x23, lsr #0 // encoding: [0xd5,0x02,0x57,0x8b]
|
|
// CHECK: add x24, x25, x26, lsr #18 // encoding: [0x38,0x4b,0x5a,0x8b]
|
|
// CHECK: add x27, x28, x29, lsr #63 // encoding: [0x9b,0xff,0x5d,0x8b]
|
|
|
|
add x2, x3, x4, asr #0
|
|
add x5, x6, x7, asr #21
|
|
add x8, x9, x10, asr #63
|
|
// CHECK: add x2, x3, x4, asr #0 // encoding: [0x62,0x00,0x84,0x8b]
|
|
// CHECK: add x5, x6, x7, asr #21 // encoding: [0xc5,0x54,0x87,0x8b]
|
|
// CHECK: add x8, x9, x10, asr #63 // encoding: [0x28,0xfd,0x8a,0x8b]
|
|
|
|
adds w3, w5, w7
|
|
adds wzr, w3, w5
|
|
adds w20, wzr, w4
|
|
adds w4, w6, wzr
|
|
// CHECK: adds w3, w5, w7 // encoding: [0xa3,0x00,0x07,0x2b]
|
|
// CHECK: adds wzr, w3, w5 // encoding: [0x7f,0x00,0x05,0x2b]
|
|
// CHECK: adds w20, wzr, w4 // encoding: [0xf4,0x03,0x04,0x2b]
|
|
// CHECK: adds w4, w6, wzr // encoding: [0xc4,0x00,0x1f,0x2b]
|
|
|
|
adds w11, w13, w15, lsl #0
|
|
adds w9, w3, wzr, lsl #10
|
|
adds w17, w29, w20, lsl #31
|
|
// CHECK: adds w11, w13, w15 // encoding: [0xab,0x01,0x0f,0x2b]
|
|
// CHECK: adds w9, w3, wzr, lsl #10 // encoding: [0x69,0x28,0x1f,0x2b]
|
|
// CHECK: adds w17, w29, w20, lsl #31 // encoding: [0xb1,0x7f,0x14,0x2b]
|
|
|
|
adds w21, w22, w23, lsr #0
|
|
adds w24, w25, w26, lsr #18
|
|
adds w27, w28, w29, lsr #31
|
|
// CHECK: adds w21, w22, w23, lsr #0 // encoding: [0xd5,0x02,0x57,0x2b]
|
|
// CHECK: adds w24, w25, w26, lsr #18 // encoding: [0x38,0x4b,0x5a,0x2b]
|
|
// CHECK: adds w27, w28, w29, lsr #31 // encoding: [0x9b,0x7f,0x5d,0x2b]
|
|
|
|
adds w2, w3, w4, asr #0
|
|
adds w5, w6, w7, asr #21
|
|
adds w8, w9, w10, asr #31
|
|
// CHECK: adds w2, w3, w4, asr #0 // encoding: [0x62,0x00,0x84,0x2b]
|
|
// CHECK: adds w5, w6, w7, asr #21 // encoding: [0xc5,0x54,0x87,0x2b]
|
|
// CHECK: adds w8, w9, w10, asr #31 // encoding: [0x28,0x7d,0x8a,0x2b]
|
|
|
|
adds x3, x5, x7
|
|
adds xzr, x3, x5
|
|
adds x20, xzr, x4
|
|
adds x4, x6, xzr
|
|
// CHECK: adds x3, x5, x7 // encoding: [0xa3,0x00,0x07,0xab]
|
|
// CHECK: adds xzr, x3, x5 // encoding: [0x7f,0x00,0x05,0xab]
|
|
// CHECK: adds x20, xzr, x4 // encoding: [0xf4,0x03,0x04,0xab]
|
|
// CHECK: adds x4, x6, xzr // encoding: [0xc4,0x00,0x1f,0xab]
|
|
|
|
adds x11, x13, x15, lsl #0
|
|
adds x9, x3, xzr, lsl #10
|
|
adds x17, x29, x20, lsl #63
|
|
// CHECK: adds x11, x13, x15 // encoding: [0xab,0x01,0x0f,0xab]
|
|
// CHECK: adds x9, x3, xzr, lsl #10 // encoding: [0x69,0x28,0x1f,0xab]
|
|
// CHECK: adds x17, x29, x20, lsl #63 // encoding: [0xb1,0xff,0x14,0xab]
|
|
|
|
adds x21, x22, x23, lsr #0
|
|
adds x24, x25, x26, lsr #18
|
|
adds x27, x28, x29, lsr #63
|
|
// CHECK: adds x21, x22, x23, lsr #0 // encoding: [0xd5,0x02,0x57,0xab]
|
|
// CHECK: adds x24, x25, x26, lsr #18 // encoding: [0x38,0x4b,0x5a,0xab]
|
|
// CHECK: adds x27, x28, x29, lsr #63 // encoding: [0x9b,0xff,0x5d,0xab]
|
|
|
|
adds x2, x3, x4, asr #0
|
|
adds x5, x6, x7, asr #21
|
|
adds x8, x9, x10, asr #63
|
|
// CHECK: adds x2, x3, x4, asr #0 // encoding: [0x62,0x00,0x84,0xab]
|
|
// CHECK: adds x5, x6, x7, asr #21 // encoding: [0xc5,0x54,0x87,0xab]
|
|
// CHECK: adds x8, x9, x10, asr #63 // encoding: [0x28,0xfd,0x8a,0xab]
|
|
|
|
sub w3, w5, w7
|
|
sub wzr, w3, w5
|
|
sub w20, wzr, w4
|
|
sub w4, w6, wzr
|
|
// CHECK: sub w3, w5, w7 // encoding: [0xa3,0x00,0x07,0x4b]
|
|
// CHECK: sub wzr, w3, w5 // encoding: [0x7f,0x00,0x05,0x4b]
|
|
// CHECK: sub w20, wzr, w4 // encoding: [0xf4,0x03,0x04,0x4b]
|
|
// CHECK: sub w4, w6, wzr // encoding: [0xc4,0x00,0x1f,0x4b]
|
|
|
|
sub w11, w13, w15, lsl #0
|
|
sub w9, w3, wzr, lsl #10
|
|
sub w17, w29, w20, lsl #31
|
|
// CHECK: sub w11, w13, w15 // encoding: [0xab,0x01,0x0f,0x4b]
|
|
// CHECK: sub w9, w3, wzr, lsl #10 // encoding: [0x69,0x28,0x1f,0x4b]
|
|
// CHECK: sub w17, w29, w20, lsl #31 // encoding: [0xb1,0x7f,0x14,0x4b]
|
|
|
|
sub w21, w22, w23, lsr #0
|
|
sub w24, w25, w26, lsr #18
|
|
sub w27, w28, w29, lsr #31
|
|
// CHECK: sub w21, w22, w23, lsr #0 // encoding: [0xd5,0x02,0x57,0x4b]
|
|
// CHECK: sub w24, w25, w26, lsr #18 // encoding: [0x38,0x4b,0x5a,0x4b]
|
|
// CHECK: sub w27, w28, w29, lsr #31 // encoding: [0x9b,0x7f,0x5d,0x4b]
|
|
|
|
sub w2, w3, w4, asr #0
|
|
sub w5, w6, w7, asr #21
|
|
sub w8, w9, w10, asr #31
|
|
// CHECK: sub w2, w3, w4, asr #0 // encoding: [0x62,0x00,0x84,0x4b]
|
|
// CHECK: sub w5, w6, w7, asr #21 // encoding: [0xc5,0x54,0x87,0x4b]
|
|
// CHECK: sub w8, w9, w10, asr #31 // encoding: [0x28,0x7d,0x8a,0x4b]
|
|
|
|
sub x3, x5, x7
|
|
sub xzr, x3, x5
|
|
sub x20, xzr, x4
|
|
sub x4, x6, xzr
|
|
// CHECK: sub x3, x5, x7 // encoding: [0xa3,0x00,0x07,0xcb]
|
|
// CHECK: sub xzr, x3, x5 // encoding: [0x7f,0x00,0x05,0xcb]
|
|
// CHECK: sub x20, xzr, x4 // encoding: [0xf4,0x03,0x04,0xcb]
|
|
// CHECK: sub x4, x6, xzr // encoding: [0xc4,0x00,0x1f,0xcb]
|
|
|
|
sub x11, x13, x15, lsl #0
|
|
sub x9, x3, xzr, lsl #10
|
|
sub x17, x29, x20, lsl #63
|
|
// CHECK: sub x11, x13, x15 // encoding: [0xab,0x01,0x0f,0xcb]
|
|
// CHECK: sub x9, x3, xzr, lsl #10 // encoding: [0x69,0x28,0x1f,0xcb]
|
|
// CHECK: sub x17, x29, x20, lsl #63 // encoding: [0xb1,0xff,0x14,0xcb]
|
|
|
|
sub x21, x22, x23, lsr #0
|
|
sub x24, x25, x26, lsr #18
|
|
sub x27, x28, x29, lsr #63
|
|
// CHECK: sub x21, x22, x23, lsr #0 // encoding: [0xd5,0x02,0x57,0xcb]
|
|
// CHECK: sub x24, x25, x26, lsr #18 // encoding: [0x38,0x4b,0x5a,0xcb]
|
|
// CHECK: sub x27, x28, x29, lsr #63 // encoding: [0x9b,0xff,0x5d,0xcb]
|
|
|
|
sub x2, x3, x4, asr #0
|
|
sub x5, x6, x7, asr #21
|
|
sub x8, x9, x10, asr #63
|
|
// CHECK: sub x2, x3, x4, asr #0 // encoding: [0x62,0x00,0x84,0xcb]
|
|
// CHECK: sub x5, x6, x7, asr #21 // encoding: [0xc5,0x54,0x87,0xcb]
|
|
// CHECK: sub x8, x9, x10, asr #63 // encoding: [0x28,0xfd,0x8a,0xcb]
|
|
|
|
subs w3, w5, w7
|
|
subs wzr, w3, w5
|
|
subs w20, wzr, w4
|
|
subs w4, w6, wzr
|
|
// CHECK: subs w3, w5, w7 // encoding: [0xa3,0x00,0x07,0x6b]
|
|
// CHECK: subs wzr, w3, w5 // encoding: [0x7f,0x00,0x05,0x6b]
|
|
// CHECK: subs w20, wzr, w4 // encoding: [0xf4,0x03,0x04,0x6b]
|
|
// CHECK: subs w4, w6, wzr // encoding: [0xc4,0x00,0x1f,0x6b]
|
|
|
|
subs w11, w13, w15, lsl #0
|
|
subs w9, w3, wzr, lsl #10
|
|
subs w17, w29, w20, lsl #31
|
|
// CHECK: subs w11, w13, w15 // encoding: [0xab,0x01,0x0f,0x6b]
|
|
// CHECK: subs w9, w3, wzr, lsl #10 // encoding: [0x69,0x28,0x1f,0x6b]
|
|
// CHECK: subs w17, w29, w20, lsl #31 // encoding: [0xb1,0x7f,0x14,0x6b]
|
|
|
|
subs w21, w22, w23, lsr #0
|
|
subs w24, w25, w26, lsr #18
|
|
subs w27, w28, w29, lsr #31
|
|
// CHECK: subs w21, w22, w23, lsr #0 // encoding: [0xd5,0x02,0x57,0x6b]
|
|
// CHECK: subs w24, w25, w26, lsr #18 // encoding: [0x38,0x4b,0x5a,0x6b]
|
|
// CHECK: subs w27, w28, w29, lsr #31 // encoding: [0x9b,0x7f,0x5d,0x6b]
|
|
|
|
subs w2, w3, w4, asr #0
|
|
subs w5, w6, w7, asr #21
|
|
subs w8, w9, w10, asr #31
|
|
// CHECK: subs w2, w3, w4, asr #0 // encoding: [0x62,0x00,0x84,0x6b]
|
|
// CHECK: subs w5, w6, w7, asr #21 // encoding: [0xc5,0x54,0x87,0x6b]
|
|
// CHECK: subs w8, w9, w10, asr #31 // encoding: [0x28,0x7d,0x8a,0x6b]
|
|
|
|
subs x3, x5, x7
|
|
subs xzr, x3, x5
|
|
subs x20, xzr, x4
|
|
subs x4, x6, xzr
|
|
// CHECK: subs x3, x5, x7 // encoding: [0xa3,0x00,0x07,0xeb]
|
|
// CHECK: subs xzr, x3, x5 // encoding: [0x7f,0x00,0x05,0xeb]
|
|
// CHECK: subs x20, xzr, x4 // encoding: [0xf4,0x03,0x04,0xeb]
|
|
// CHECK: subs x4, x6, xzr // encoding: [0xc4,0x00,0x1f,0xeb]
|
|
|
|
subs x11, x13, x15, lsl #0
|
|
subs x9, x3, xzr, lsl #10
|
|
subs x17, x29, x20, lsl #63
|
|
// CHECK: subs x11, x13, x15 // encoding: [0xab,0x01,0x0f,0xeb]
|
|
// CHECK: subs x9, x3, xzr, lsl #10 // encoding: [0x69,0x28,0x1f,0xeb]
|
|
// CHECK: subs x17, x29, x20, lsl #63 // encoding: [0xb1,0xff,0x14,0xeb]
|
|
|
|
subs x21, x22, x23, lsr #0
|
|
subs x24, x25, x26, lsr #18
|
|
subs x27, x28, x29, lsr #63
|
|
// CHECK: subs x21, x22, x23, lsr #0 // encoding: [0xd5,0x02,0x57,0xeb]
|
|
// CHECK: subs x24, x25, x26, lsr #18 // encoding: [0x38,0x4b,0x5a,0xeb]
|
|
// CHECK: subs x27, x28, x29, lsr #63 // encoding: [0x9b,0xff,0x5d,0xeb]
|
|
|
|
subs x2, x3, x4, asr #0
|
|
subs x5, x6, x7, asr #21
|
|
subs x8, x9, x10, asr #63
|
|
// CHECK: subs x2, x3, x4, asr #0 // encoding: [0x62,0x00,0x84,0xeb]
|
|
// CHECK: subs x5, x6, x7, asr #21 // encoding: [0xc5,0x54,0x87,0xeb]
|
|
// CHECK: subs x8, x9, x10, asr #63 // encoding: [0x28,0xfd,0x8a,0xeb]
|
|
|
|
cmn w0, w3
|
|
cmn wzr, w4
|
|
cmn w5, wzr
|
|
// CHECK: cmn w0, w3 // encoding: [0x1f,0x00,0x03,0x2b]
|
|
// CHECK: cmn wzr, w4 // encoding: [0xff,0x03,0x04,0x2b]
|
|
// CHECK: cmn w5, wzr // encoding: [0xbf,0x00,0x1f,0x2b]
|
|
|
|
cmn w6, w7, lsl #0
|
|
cmn w8, w9, lsl #15
|
|
cmn w10, w11, lsl #31
|
|
// CHECK: cmn w6, w7 // encoding: [0xdf,0x00,0x07,0x2b]
|
|
// CHECK: cmn w8, w9, lsl #15 // encoding: [0x1f,0x3d,0x09,0x2b]
|
|
// CHECK: cmn w10, w11, lsl #31 // encoding: [0x5f,0x7d,0x0b,0x2b]
|
|
|
|
cmn w12, w13, lsr #0
|
|
cmn w14, w15, lsr #21
|
|
cmn w16, w17, lsr #31
|
|
// CHECK: cmn w12, w13, lsr #0 // encoding: [0x9f,0x01,0x4d,0x2b]
|
|
// CHECK: cmn w14, w15, lsr #21 // encoding: [0xdf,0x55,0x4f,0x2b]
|
|
// CHECK: cmn w16, w17, lsr #31 // encoding: [0x1f,0x7e,0x51,0x2b]
|
|
|
|
cmn w18, w19, asr #0
|
|
cmn w20, w21, asr #22
|
|
cmn w22, w23, asr #31
|
|
// CHECK: cmn w18, w19, asr #0 // encoding: [0x5f,0x02,0x93,0x2b]
|
|
// CHECK: cmn w20, w21, asr #22 // encoding: [0x9f,0x5a,0x95,0x2b]
|
|
// CHECK: cmn w22, w23, asr #31 // encoding: [0xdf,0x7e,0x97,0x2b]
|
|
|
|
cmn x0, x3
|
|
cmn xzr, x4
|
|
cmn x5, xzr
|
|
// CHECK: cmn x0, x3 // encoding: [0x1f,0x00,0x03,0xab]
|
|
// CHECK: cmn xzr, x4 // encoding: [0xff,0x03,0x04,0xab]
|
|
// CHECK: cmn x5, xzr // encoding: [0xbf,0x00,0x1f,0xab]
|
|
|
|
cmn x6, x7, lsl #0
|
|
cmn x8, x9, lsl #15
|
|
cmn x10, x11, lsl #63
|
|
// CHECK: cmn x6, x7 // encoding: [0xdf,0x00,0x07,0xab]
|
|
// CHECK: cmn x8, x9, lsl #15 // encoding: [0x1f,0x3d,0x09,0xab]
|
|
// CHECK: cmn x10, x11, lsl #63 // encoding: [0x5f,0xfd,0x0b,0xab]
|
|
|
|
cmn x12, x13, lsr #0
|
|
cmn x14, x15, lsr #41
|
|
cmn x16, x17, lsr #63
|
|
// CHECK: cmn x12, x13, lsr #0 // encoding: [0x9f,0x01,0x4d,0xab]
|
|
// CHECK: cmn x14, x15, lsr #41 // encoding: [0xdf,0xa5,0x4f,0xab]
|
|
// CHECK: cmn x16, x17, lsr #63 // encoding: [0x1f,0xfe,0x51,0xab]
|
|
|
|
cmn x18, x19, asr #0
|
|
cmn x20, x21, asr #55
|
|
cmn x22, x23, asr #63
|
|
// CHECK: cmn x18, x19, asr #0 // encoding: [0x5f,0x02,0x93,0xab]
|
|
// CHECK: cmn x20, x21, asr #55 // encoding: [0x9f,0xde,0x95,0xab]
|
|
// CHECK: cmn x22, x23, asr #63 // encoding: [0xdf,0xfe,0x97,0xab]
|
|
|
|
cmp w0, w3
|
|
cmp wzr, w4
|
|
cmp w5, wzr
|
|
// CHECK: cmp w0, w3 // encoding: [0x1f,0x00,0x03,0x6b]
|
|
// CHECK: cmp wzr, w4 // encoding: [0xff,0x03,0x04,0x6b]
|
|
// CHECK: cmp w5, wzr // encoding: [0xbf,0x00,0x1f,0x6b]
|
|
|
|
cmp w6, w7, lsl #0
|
|
cmp w8, w9, lsl #15
|
|
cmp w10, w11, lsl #31
|
|
// CHECK: cmp w6, w7 // encoding: [0xdf,0x00,0x07,0x6b]
|
|
// CHECK: cmp w8, w9, lsl #15 // encoding: [0x1f,0x3d,0x09,0x6b]
|
|
// CHECK: cmp w10, w11, lsl #31 // encoding: [0x5f,0x7d,0x0b,0x6b]
|
|
|
|
cmp w12, w13, lsr #0
|
|
cmp w14, w15, lsr #21
|
|
cmp w16, w17, lsr #31
|
|
// CHECK: cmp w12, w13, lsr #0 // encoding: [0x9f,0x01,0x4d,0x6b]
|
|
// CHECK: cmp w14, w15, lsr #21 // encoding: [0xdf,0x55,0x4f,0x6b]
|
|
// CHECK: cmp w16, w17, lsr #31 // encoding: [0x1f,0x7e,0x51,0x6b]
|
|
|
|
cmp w18, w19, asr #0
|
|
cmp w20, w21, asr #22
|
|
cmp w22, w23, asr #31
|
|
// CHECK: cmp w18, w19, asr #0 // encoding: [0x5f,0x02,0x93,0x6b]
|
|
// CHECK: cmp w20, w21, asr #22 // encoding: [0x9f,0x5a,0x95,0x6b]
|
|
// CHECK: cmp w22, w23, asr #31 // encoding: [0xdf,0x7e,0x97,0x6b]
|
|
|
|
cmp x0, x3
|
|
cmp xzr, x4
|
|
cmp x5, xzr
|
|
// CHECK: cmp x0, x3 // encoding: [0x1f,0x00,0x03,0xeb]
|
|
// CHECK: cmp xzr, x4 // encoding: [0xff,0x03,0x04,0xeb]
|
|
// CHECK: cmp x5, xzr // encoding: [0xbf,0x00,0x1f,0xeb]
|
|
|
|
cmp x6, x7, lsl #0
|
|
cmp x8, x9, lsl #15
|
|
cmp x10, x11, lsl #63
|
|
// CHECK: cmp x6, x7 // encoding: [0xdf,0x00,0x07,0xeb]
|
|
// CHECK: cmp x8, x9, lsl #15 // encoding: [0x1f,0x3d,0x09,0xeb]
|
|
// CHECK: cmp x10, x11, lsl #63 // encoding: [0x5f,0xfd,0x0b,0xeb]
|
|
|
|
cmp x12, x13, lsr #0
|
|
cmp x14, x15, lsr #41
|
|
cmp x16, x17, lsr #63
|
|
// CHECK: cmp x12, x13, lsr #0 // encoding: [0x9f,0x01,0x4d,0xeb]
|
|
// CHECK: cmp x14, x15, lsr #41 // encoding: [0xdf,0xa5,0x4f,0xeb]
|
|
// CHECK: cmp x16, x17, lsr #63 // encoding: [0x1f,0xfe,0x51,0xeb]
|
|
|
|
cmp x18, x19, asr #0
|
|
cmp x20, x21, asr #55
|
|
cmp x22, x23, asr #63
|
|
// CHECK: cmp x18, x19, asr #0 // encoding: [0x5f,0x02,0x93,0xeb]
|
|
// CHECK: cmp x20, x21, asr #55 // encoding: [0x9f,0xde,0x95,0xeb]
|
|
// CHECK: cmp x22, x23, asr #63 // encoding: [0xdf,0xfe,0x97,0xeb]
|
|
|
|
neg w29, w30
|
|
neg w30, wzr
|
|
neg wzr, w0
|
|
// CHECK: sub w29, wzr, w30 // encoding: [0xfd,0x03,0x1e,0x4b]
|
|
// CHECK: sub w30, wzr, wzr // encoding: [0xfe,0x03,0x1f,0x4b]
|
|
// CHECK: sub wzr, wzr, w0 // encoding: [0xff,0x03,0x00,0x4b]
|
|
|
|
neg w28, w27, lsl #0
|
|
neg w26, w25, lsl #29
|
|
neg w24, w23, lsl #31
|
|
// CHECK: sub w28, wzr, w27 // encoding: [0xfc,0x03,0x1b,0x4b]
|
|
// CHECK: sub w26, wzr, w25, lsl #29 // encoding: [0xfa,0x77,0x19,0x4b]
|
|
// CHECK: sub w24, wzr, w23, lsl #31 // encoding: [0xf8,0x7f,0x17,0x4b]
|
|
|
|
neg w22, w21, lsr #0
|
|
neg w20, w19, lsr #1
|
|
neg w18, w17, lsr #31
|
|
// CHECK: sub w22, wzr, w21, lsr #0 // encoding: [0xf6,0x03,0x55,0x4b]
|
|
// CHECK: sub w20, wzr, w19, lsr #1 // encoding: [0xf4,0x07,0x53,0x4b]
|
|
// CHECK: sub w18, wzr, w17, lsr #31 // encoding: [0xf2,0x7f,0x51,0x4b]
|
|
|
|
neg w16, w15, asr #0
|
|
neg w14, w13, asr #12
|
|
neg w12, w11, asr #31
|
|
// CHECK: sub w16, wzr, w15, asr #0 // encoding: [0xf0,0x03,0x8f,0x4b]
|
|
// CHECK: sub w14, wzr, w13, asr #12 // encoding: [0xee,0x33,0x8d,0x4b]
|
|
// CHECK: sub w12, wzr, w11, asr #31 // encoding: [0xec,0x7f,0x8b,0x4b]
|
|
|
|
neg x29, x30
|
|
neg x30, xzr
|
|
neg xzr, x0
|
|
// CHECK: sub x29, xzr, x30 // encoding: [0xfd,0x03,0x1e,0xcb]
|
|
// CHECK: sub x30, xzr, xzr // encoding: [0xfe,0x03,0x1f,0xcb]
|
|
// CHECK: sub xzr, xzr, x0 // encoding: [0xff,0x03,0x00,0xcb]
|
|
|
|
neg x28, x27, lsl #0
|
|
neg x26, x25, lsl #29
|
|
neg x24, x23, lsl #31
|
|
// CHECK: sub x28, xzr, x27 // encoding: [0xfc,0x03,0x1b,0xcb]
|
|
// CHECK: sub x26, xzr, x25, lsl #29 // encoding: [0xfa,0x77,0x19,0xcb]
|
|
// CHECK: sub x24, xzr, x23, lsl #31 // encoding: [0xf8,0x7f,0x17,0xcb]
|
|
|
|
neg x22, x21, lsr #0
|
|
neg x20, x19, lsr #1
|
|
neg x18, x17, lsr #31
|
|
// CHECK: sub x22, xzr, x21, lsr #0 // encoding: [0xf6,0x03,0x55,0xcb]
|
|
// CHECK: sub x20, xzr, x19, lsr #1 // encoding: [0xf4,0x07,0x53,0xcb]
|
|
// CHECK: sub x18, xzr, x17, lsr #31 // encoding: [0xf2,0x7f,0x51,0xcb]
|
|
|
|
neg x16, x15, asr #0
|
|
neg x14, x13, asr #12
|
|
neg x12, x11, asr #31
|
|
// CHECK: sub x16, xzr, x15, asr #0 // encoding: [0xf0,0x03,0x8f,0xcb]
|
|
// CHECK: sub x14, xzr, x13, asr #12 // encoding: [0xee,0x33,0x8d,0xcb]
|
|
// CHECK: sub x12, xzr, x11, asr #31 // encoding: [0xec,0x7f,0x8b,0xcb]
|
|
|
|
negs w29, w30
|
|
negs w30, wzr
|
|
negs wzr, w0
|
|
// CHECK: subs w29, wzr, w30 // encoding: [0xfd,0x03,0x1e,0x6b]
|
|
// CHECK: subs w30, wzr, wzr // encoding: [0xfe,0x03,0x1f,0x6b]
|
|
// CHECK: subs wzr, wzr, w0 // encoding: [0xff,0x03,0x00,0x6b]
|
|
|
|
negs w28, w27, lsl #0
|
|
negs w26, w25, lsl #29
|
|
negs w24, w23, lsl #31
|
|
// CHECK: subs w28, wzr, w27 // encoding: [0xfc,0x03,0x1b,0x6b]
|
|
// CHECK: subs w26, wzr, w25, lsl #29 // encoding: [0xfa,0x77,0x19,0x6b]
|
|
// CHECK: subs w24, wzr, w23, lsl #31 // encoding: [0xf8,0x7f,0x17,0x6b]
|
|
|
|
negs w22, w21, lsr #0
|
|
negs w20, w19, lsr #1
|
|
negs w18, w17, lsr #31
|
|
// CHECK: subs w22, wzr, w21, lsr #0 // encoding: [0xf6,0x03,0x55,0x6b]
|
|
// CHECK: subs w20, wzr, w19, lsr #1 // encoding: [0xf4,0x07,0x53,0x6b]
|
|
// CHECK: subs w18, wzr, w17, lsr #31 // encoding: [0xf2,0x7f,0x51,0x6b]
|
|
|
|
negs w16, w15, asr #0
|
|
negs w14, w13, asr #12
|
|
negs w12, w11, asr #31
|
|
// CHECK: subs w16, wzr, w15, asr #0 // encoding: [0xf0,0x03,0x8f,0x6b]
|
|
// CHECK: subs w14, wzr, w13, asr #12 // encoding: [0xee,0x33,0x8d,0x6b]
|
|
// CHECK: subs w12, wzr, w11, asr #31 // encoding: [0xec,0x7f,0x8b,0x6b]
|
|
|
|
negs x29, x30
|
|
negs x30, xzr
|
|
negs xzr, x0
|
|
// CHECK: subs x29, xzr, x30 // encoding: [0xfd,0x03,0x1e,0xeb]
|
|
// CHECK: subs x30, xzr, xzr // encoding: [0xfe,0x03,0x1f,0xeb]
|
|
// CHECK: subs xzr, xzr, x0 // encoding: [0xff,0x03,0x00,0xeb]
|
|
|
|
negs x28, x27, lsl #0
|
|
negs x26, x25, lsl #29
|
|
negs x24, x23, lsl #31
|
|
// CHECK: subs x28, xzr, x27 // encoding: [0xfc,0x03,0x1b,0xeb]
|
|
// CHECK: subs x26, xzr, x25, lsl #29 // encoding: [0xfa,0x77,0x19,0xeb]
|
|
// CHECK: subs x24, xzr, x23, lsl #31 // encoding: [0xf8,0x7f,0x17,0xeb]
|
|
|
|
negs x22, x21, lsr #0
|
|
negs x20, x19, lsr #1
|
|
negs x18, x17, lsr #31
|
|
// CHECK: subs x22, xzr, x21, lsr #0 // encoding: [0xf6,0x03,0x55,0xeb]
|
|
// CHECK: subs x20, xzr, x19, lsr #1 // encoding: [0xf4,0x07,0x53,0xeb]
|
|
// CHECK: subs x18, xzr, x17, lsr #31 // encoding: [0xf2,0x7f,0x51,0xeb]
|
|
|
|
negs x16, x15, asr #0
|
|
negs x14, x13, asr #12
|
|
negs x12, x11, asr #31
|
|
// CHECK: subs x16, xzr, x15, asr #0 // encoding: [0xf0,0x03,0x8f,0xeb]
|
|
// CHECK: subs x14, xzr, x13, asr #12 // encoding: [0xee,0x33,0x8d,0xeb]
|
|
// CHECK: subs x12, xzr, x11, asr #31 // encoding: [0xec,0x7f,0x8b,0xeb]
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Add-sub (shifted register)
|
|
//------------------------------------------------------------------------------
|
|
adc w29, w27, w25
|
|
adc wzr, w3, w4
|
|
adc w9, wzr, w10
|
|
adc w20, w0, wzr
|
|
// CHECK: adc w29, w27, w25 // encoding: [0x7d,0x03,0x19,0x1a]
|
|
// CHECK: adc wzr, w3, w4 // encoding: [0x7f,0x00,0x04,0x1a]
|
|
// CHECK: adc w9, wzr, w10 // encoding: [0xe9,0x03,0x0a,0x1a]
|
|
// CHECK: adc w20, w0, wzr // encoding: [0x14,0x00,0x1f,0x1a]
|
|
|
|
adc x29, x27, x25
|
|
adc xzr, x3, x4
|
|
adc x9, xzr, x10
|
|
adc x20, x0, xzr
|
|
// CHECK: adc x29, x27, x25 // encoding: [0x7d,0x03,0x19,0x9a]
|
|
// CHECK: adc xzr, x3, x4 // encoding: [0x7f,0x00,0x04,0x9a]
|
|
// CHECK: adc x9, xzr, x10 // encoding: [0xe9,0x03,0x0a,0x9a]
|
|
// CHECK: adc x20, x0, xzr // encoding: [0x14,0x00,0x1f,0x9a]
|
|
|
|
adcs w29, w27, w25
|
|
adcs wzr, w3, w4
|
|
adcs w9, wzr, w10
|
|
adcs w20, w0, wzr
|
|
// CHECK: adcs w29, w27, w25 // encoding: [0x7d,0x03,0x19,0x3a]
|
|
// CHECK: adcs wzr, w3, w4 // encoding: [0x7f,0x00,0x04,0x3a]
|
|
// CHECK: adcs w9, wzr, w10 // encoding: [0xe9,0x03,0x0a,0x3a]
|
|
// CHECK: adcs w20, w0, wzr // encoding: [0x14,0x00,0x1f,0x3a]
|
|
|
|
adcs x29, x27, x25
|
|
adcs xzr, x3, x4
|
|
adcs x9, xzr, x10
|
|
adcs x20, x0, xzr
|
|
// CHECK: adcs x29, x27, x25 // encoding: [0x7d,0x03,0x19,0xba]
|
|
// CHECK: adcs xzr, x3, x4 // encoding: [0x7f,0x00,0x04,0xba]
|
|
// CHECK: adcs x9, xzr, x10 // encoding: [0xe9,0x03,0x0a,0xba]
|
|
// CHECK: adcs x20, x0, xzr // encoding: [0x14,0x00,0x1f,0xba]
|
|
|
|
sbc w29, w27, w25
|
|
sbc wzr, w3, w4
|
|
sbc w9, wzr, w10
|
|
sbc w20, w0, wzr
|
|
// CHECK: sbc w29, w27, w25 // encoding: [0x7d,0x03,0x19,0x5a]
|
|
// CHECK: sbc wzr, w3, w4 // encoding: [0x7f,0x00,0x04,0x5a]
|
|
// CHECK: ngc w9, w10 // encoding: [0xe9,0x03,0x0a,0x5a]
|
|
// CHECK: sbc w20, w0, wzr // encoding: [0x14,0x00,0x1f,0x5a]
|
|
|
|
sbc x29, x27, x25
|
|
sbc xzr, x3, x4
|
|
sbc x9, xzr, x10
|
|
sbc x20, x0, xzr
|
|
// CHECK: sbc x29, x27, x25 // encoding: [0x7d,0x03,0x19,0xda]
|
|
// CHECK: sbc xzr, x3, x4 // encoding: [0x7f,0x00,0x04,0xda]
|
|
// CHECK: ngc x9, x10 // encoding: [0xe9,0x03,0x0a,0xda]
|
|
// CHECK: sbc x20, x0, xzr // encoding: [0x14,0x00,0x1f,0xda]
|
|
|
|
sbcs w29, w27, w25
|
|
sbcs wzr, w3, w4
|
|
sbcs w9, wzr, w10
|
|
sbcs w20, w0, wzr
|
|
// CHECK: sbcs w29, w27, w25 // encoding: [0x7d,0x03,0x19,0x7a]
|
|
// CHECK: sbcs wzr, w3, w4 // encoding: [0x7f,0x00,0x04,0x7a]
|
|
// CHECK: ngcs w9, w10 // encoding: [0xe9,0x03,0x0a,0x7a]
|
|
// CHECK: sbcs w20, w0, wzr // encoding: [0x14,0x00,0x1f,0x7a]
|
|
|
|
sbcs x29, x27, x25
|
|
sbcs xzr, x3, x4
|
|
sbcs x9, xzr, x10
|
|
sbcs x20, x0, xzr
|
|
// CHECK: sbcs x29, x27, x25 // encoding: [0x7d,0x03,0x19,0xfa]
|
|
// CHECK: sbcs xzr, x3, x4 // encoding: [0x7f,0x00,0x04,0xfa]
|
|
// CHECK: ngcs x9, x10 // encoding: [0xe9,0x03,0x0a,0xfa]
|
|
// CHECK: sbcs x20, x0, xzr // encoding: [0x14,0x00,0x1f,0xfa]
|
|
|
|
ngc w3, w12
|
|
ngc wzr, w9
|
|
ngc w23, wzr
|
|
// CHECK: ngc w3, w12 // encoding: [0xe3,0x03,0x0c,0x5a]
|
|
// CHECK: ngc wzr, w9 // encoding: [0xff,0x03,0x09,0x5a]
|
|
// CHECK: ngc w23, wzr // encoding: [0xf7,0x03,0x1f,0x5a]
|
|
|
|
ngc x29, x30
|
|
ngc xzr, x0
|
|
ngc x0, xzr
|
|
// CHECK: ngc x29, x30 // encoding: [0xfd,0x03,0x1e,0xda]
|
|
// CHECK: ngc xzr, x0 // encoding: [0xff,0x03,0x00,0xda]
|
|
// CHECK: ngc x0, xzr // encoding: [0xe0,0x03,0x1f,0xda]
|
|
|
|
ngcs w3, w12
|
|
ngcs wzr, w9
|
|
ngcs w23, wzr
|
|
// CHECK: ngcs w3, w12 // encoding: [0xe3,0x03,0x0c,0x7a]
|
|
// CHECK: ngcs wzr, w9 // encoding: [0xff,0x03,0x09,0x7a]
|
|
// CHECK: ngcs w23, wzr // encoding: [0xf7,0x03,0x1f,0x7a]
|
|
|
|
ngcs x29, x30
|
|
ngcs xzr, x0
|
|
ngcs x0, xzr
|
|
// CHECK: ngcs x29, x30 // encoding: [0xfd,0x03,0x1e,0xfa]
|
|
// CHECK: ngcs xzr, x0 // encoding: [0xff,0x03,0x00,0xfa]
|
|
// CHECK: ngcs x0, xzr // encoding: [0xe0,0x03,0x1f,0xfa]
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Bitfield
|
|
//------------------------------------------------------------------------------
|
|
|
|
sbfm x1, x2, #3, #4
|
|
sbfm x3, x4, #63, #63
|
|
sbfm wzr, wzr, #31, #31
|
|
sbfm w12, w9, #0, #0
|
|
// CHECK: sbfm x1, x2, #3, #4 // encoding: [0x41,0x10,0x43,0x93]
|
|
// CHECK: sbfm x3, x4, #63, #63 // encoding: [0x83,0xfc,0x7f,0x93]
|
|
// CHECK: sbfm wzr, wzr, #31, #31 // encoding: [0xff,0x7f,0x1f,0x13]
|
|
// CHECK: sbfm w12, w9, #0, #0 // encoding: [0x2c,0x01,0x00,0x13]
|
|
|
|
ubfm x4, x5, #12, #10
|
|
ubfm xzr, x4, #0, #0
|
|
ubfm x4, xzr, #63, #5
|
|
ubfm x5, x6, #12, #63
|
|
// CHECK: ubfm x4, x5, #12, #10 // encoding: [0xa4,0x28,0x4c,0xd3]
|
|
// CHECK: ubfm xzr, x4, #0, #0 // encoding: [0x9f,0x00,0x40,0xd3]
|
|
// CHECK: ubfm x4, xzr, #63, #5 // encoding: [0xe4,0x17,0x7f,0xd3]
|
|
// CHECK: ubfm x5, x6, #12, #63 // encoding: [0xc5,0xfc,0x4c,0xd3]
|
|
|
|
bfm x4, x5, #12, #10
|
|
bfm xzr, x4, #0, #0
|
|
bfm x4, xzr, #63, #5
|
|
bfm x5, x6, #12, #63
|
|
// CHECK: bfm x4, x5, #12, #10 // encoding: [0xa4,0x28,0x4c,0xb3]
|
|
// CHECK: bfm xzr, x4, #0, #0 // encoding: [0x9f,0x00,0x40,0xb3]
|
|
// CHECK: bfm x4, xzr, #63, #5 // encoding: [0xe4,0x17,0x7f,0xb3]
|
|
// CHECK: bfm x5, x6, #12, #63 // encoding: [0xc5,0xfc,0x4c,0xb3]
|
|
|
|
sxtb w1, w2
|
|
sxtb xzr, w3
|
|
sxth w9, w10
|
|
sxth x0, w1
|
|
sxtw x3, w30
|
|
// CHECK: sxtb w1, w2 // encoding: [0x41,0x1c,0x00,0x13]
|
|
// CHECK: sxtb xzr, w3 // encoding: [0x7f,0x1c,0x40,0x93]
|
|
// CHECK: sxth w9, w10 // encoding: [0x49,0x3d,0x00,0x13]
|
|
// CHECK: sxth x0, w1 // encoding: [0x20,0x3c,0x40,0x93]
|
|
// CHECK: sxtw x3, w30 // encoding: [0xc3,0x7f,0x40,0x93]
|
|
|
|
uxtb w1, w2
|
|
uxtb xzr, w3
|
|
uxth w9, w10
|
|
uxth x0, w1
|
|
// CHECK: uxtb w1, w2 // encoding: [0x41,0x1c,0x00,0x53]
|
|
// CHECK: uxtb xzr, w3 // encoding: [0x7f,0x1c,0x00,0x53]
|
|
// CHECK: uxth w9, w10 // encoding: [0x49,0x3d,0x00,0x53]
|
|
// CHECK: uxth x0, w1 // encoding: [0x20,0x3c,0x00,0x53]
|
|
|
|
asr w3, w2, #0
|
|
asr w9, w10, #31
|
|
asr x20, x21, #63
|
|
asr w1, wzr, #3
|
|
// CHECK: asr w3, w2, #0 // encoding: [0x43,0x7c,0x00,0x13]
|
|
// CHECK: asr w9, w10, #31 // encoding: [0x49,0x7d,0x1f,0x13]
|
|
// CHECK: asr x20, x21, #63 // encoding: [0xb4,0xfe,0x7f,0x93]
|
|
// CHECK: asr w1, wzr, #3 // encoding: [0xe1,0x7f,0x03,0x13]
|
|
|
|
lsr w3, w2, #0
|
|
lsr w9, w10, #31
|
|
lsr x20, x21, #63
|
|
lsr wzr, wzr, #3
|
|
// CHECK: lsr w3, w2, #0 // encoding: [0x43,0x7c,0x00,0x53]
|
|
// CHECK: lsr w9, w10, #31 // encoding: [0x49,0x7d,0x1f,0x53]
|
|
// CHECK: lsr x20, x21, #63 // encoding: [0xb4,0xfe,0x7f,0xd3]
|
|
// CHECK: lsr wzr, wzr, #3 // encoding: [0xff,0x7f,0x03,0x53]
|
|
|
|
lsl w3, w2, #0
|
|
lsl w9, w10, #31
|
|
lsl x20, x21, #63
|
|
lsl w1, wzr, #3
|
|
// CHECK: lsl w3, w2, #0 // encoding: [0x43,0x7c,0x00,0x53]
|
|
// CHECK: lsl w9, w10, #31 // encoding: [0x49,0x01,0x01,0x53]
|
|
// CHECK: lsl x20, x21, #63 // encoding: [0xb4,0x02,0x41,0xd3]
|
|
// CHECK: lsl w1, wzr, #3 // encoding: [0xe1,0x73,0x1d,0x53]
|
|
|
|
sbfiz w9, w10, #0, #1
|
|
sbfiz x2, x3, #63, #1
|
|
sbfiz x19, x20, #0, #64
|
|
sbfiz x9, x10, #5, #59
|
|
sbfiz w9, w10, #0, #32
|
|
sbfiz w11, w12, #31, #1
|
|
sbfiz w13, w14, #29, #3
|
|
sbfiz xzr, xzr, #10, #11
|
|
// CHECK: sbfiz w9, w10, #0, #1 // encoding: [0x49,0x01,0x00,0x13]
|
|
// CHECK: sbfiz x2, x3, #63, #1 // encoding: [0x62,0x00,0x41,0x93]
|
|
// CHECK: sbfiz x19, x20, #0, #64 // encoding: [0x93,0xfe,0x40,0x93]
|
|
// CHECK: sbfiz x9, x10, #5, #59 // encoding: [0x49,0xe9,0x7b,0x93]
|
|
// CHECK: sbfiz w9, w10, #0, #32 // encoding: [0x49,0x7d,0x00,0x13]
|
|
// CHECK: sbfiz w11, w12, #31, #1 // encoding: [0x8b,0x01,0x01,0x13]
|
|
// CHECK: sbfiz w13, w14, #29, #3 // encoding: [0xcd,0x09,0x03,0x13]
|
|
// CHECK: sbfiz xzr, xzr, #10, #11 // encoding: [0xff,0x2b,0x76,0x93]
|
|
|
|
sbfx w9, w10, #0, #1
|
|
sbfx x2, x3, #63, #1
|
|
sbfx x19, x20, #0, #64
|
|
sbfx x9, x10, #5, #59
|
|
sbfx w9, w10, #0, #32
|
|
sbfx w11, w12, #31, #1
|
|
sbfx w13, w14, #29, #3
|
|
sbfx xzr, xzr, #10, #11
|
|
// CHECK: sbfx w9, w10, #0, #1 // encoding: [0x49,0x01,0x00,0x13]
|
|
// CHECK: sbfx x2, x3, #63, #1 // encoding: [0x62,0xfc,0x7f,0x93]
|
|
// CHECK: sbfx x19, x20, #0, #64 // encoding: [0x93,0xfe,0x40,0x93]
|
|
// CHECK: sbfx x9, x10, #5, #59 // encoding: [0x49,0xfd,0x45,0x93]
|
|
// CHECK: sbfx w9, w10, #0, #32 // encoding: [0x49,0x7d,0x00,0x13]
|
|
// CHECK: sbfx w11, w12, #31, #1 // encoding: [0x8b,0x7d,0x1f,0x13]
|
|
// CHECK: sbfx w13, w14, #29, #3 // encoding: [0xcd,0x7d,0x1d,0x13]
|
|
// CHECK: sbfx xzr, xzr, #10, #11 // encoding: [0xff,0x53,0x4a,0x93]
|
|
|
|
bfi w9, w10, #0, #1
|
|
bfi x2, x3, #63, #1
|
|
bfi x19, x20, #0, #64
|
|
bfi x9, x10, #5, #59
|
|
bfi w9, w10, #0, #32
|
|
bfi w11, w12, #31, #1
|
|
bfi w13, w14, #29, #3
|
|
bfi xzr, xzr, #10, #11
|
|
// CHECK: bfi w9, w10, #0, #1 // encoding: [0x49,0x01,0x00,0x33]
|
|
// CHECK: bfi x2, x3, #63, #1 // encoding: [0x62,0x00,0x41,0xb3]
|
|
// CHECK: bfi x19, x20, #0, #64 // encoding: [0x93,0xfe,0x40,0xb3]
|
|
// CHECK: bfi x9, x10, #5, #59 // encoding: [0x49,0xe9,0x7b,0xb3]
|
|
// CHECK: bfi w9, w10, #0, #32 // encoding: [0x49,0x7d,0x00,0x33]
|
|
// CHECK: bfi w11, w12, #31, #1 // encoding: [0x8b,0x01,0x01,0x33]
|
|
// CHECK: bfi w13, w14, #29, #3 // encoding: [0xcd,0x09,0x03,0x33]
|
|
// CHECK: bfi xzr, xzr, #10, #11 // encoding: [0xff,0x2b,0x76,0xb3]
|
|
|
|
bfxil w9, w10, #0, #1
|
|
bfxil x2, x3, #63, #1
|
|
bfxil x19, x20, #0, #64
|
|
bfxil x9, x10, #5, #59
|
|
bfxil w9, w10, #0, #32
|
|
bfxil w11, w12, #31, #1
|
|
bfxil w13, w14, #29, #3
|
|
bfxil xzr, xzr, #10, #11
|
|
// CHECK: bfxil w9, w10, #0, #1 // encoding: [0x49,0x01,0x00,0x33]
|
|
// CHECK: bfxil x2, x3, #63, #1 // encoding: [0x62,0xfc,0x7f,0xb3]
|
|
// CHECK: bfxil x19, x20, #0, #64 // encoding: [0x93,0xfe,0x40,0xb3]
|
|
// CHECK: bfxil x9, x10, #5, #59 // encoding: [0x49,0xfd,0x45,0xb3]
|
|
// CHECK: bfxil w9, w10, #0, #32 // encoding: [0x49,0x7d,0x00,0x33]
|
|
// CHECK: bfxil w11, w12, #31, #1 // encoding: [0x8b,0x7d,0x1f,0x33]
|
|
// CHECK: bfxil w13, w14, #29, #3 // encoding: [0xcd,0x7d,0x1d,0x33]
|
|
// CHECK: bfxil xzr, xzr, #10, #11 // encoding: [0xff,0x53,0x4a,0xb3]
|
|
|
|
ubfiz w9, w10, #0, #1
|
|
ubfiz x2, x3, #63, #1
|
|
ubfiz x19, x20, #0, #64
|
|
ubfiz x9, x10, #5, #59
|
|
ubfiz w9, w10, #0, #32
|
|
ubfiz w11, w12, #31, #1
|
|
ubfiz w13, w14, #29, #3
|
|
ubfiz xzr, xzr, #10, #11
|
|
// CHECK: ubfiz w9, w10, #0, #1 // encoding: [0x49,0x01,0x00,0x53]
|
|
// CHECK: ubfiz x2, x3, #63, #1 // encoding: [0x62,0x00,0x41,0xd3]
|
|
// CHECK: ubfiz x19, x20, #0, #64 // encoding: [0x93,0xfe,0x40,0xd3]
|
|
// CHECK: ubfiz x9, x10, #5, #59 // encoding: [0x49,0xe9,0x7b,0xd3]
|
|
// CHECK: ubfiz w9, w10, #0, #32 // encoding: [0x49,0x7d,0x00,0x53]
|
|
// CHECK: ubfiz w11, w12, #31, #1 // encoding: [0x8b,0x01,0x01,0x53]
|
|
// CHECK: ubfiz w13, w14, #29, #3 // encoding: [0xcd,0x09,0x03,0x53]
|
|
// CHECK: ubfiz xzr, xzr, #10, #11 // encoding: [0xff,0x2b,0x76,0xd3]
|
|
|
|
ubfx w9, w10, #0, #1
|
|
ubfx x2, x3, #63, #1
|
|
ubfx x19, x20, #0, #64
|
|
ubfx x9, x10, #5, #59
|
|
ubfx w9, w10, #0, #32
|
|
ubfx w11, w12, #31, #1
|
|
ubfx w13, w14, #29, #3
|
|
ubfx xzr, xzr, #10, #11
|
|
// CHECK: ubfx w9, w10, #0, #1 // encoding: [0x49,0x01,0x00,0x53]
|
|
// CHECK: ubfx x2, x3, #63, #1 // encoding: [0x62,0xfc,0x7f,0xd3]
|
|
// CHECK: ubfx x19, x20, #0, #64 // encoding: [0x93,0xfe,0x40,0xd3]
|
|
// CHECK: ubfx x9, x10, #5, #59 // encoding: [0x49,0xfd,0x45,0xd3]
|
|
// CHECK: ubfx w9, w10, #0, #32 // encoding: [0x49,0x7d,0x00,0x53]
|
|
// CHECK: ubfx w11, w12, #31, #1 // encoding: [0x8b,0x7d,0x1f,0x53]
|
|
// CHECK: ubfx w13, w14, #29, #3 // encoding: [0xcd,0x7d,0x1d,0x53]
|
|
// CHECK: ubfx xzr, xzr, #10, #11 // encoding: [0xff,0x53,0x4a,0xd3]
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Compare & branch (immediate)
|
|
//------------------------------------------------------------------------------
|
|
|
|
cbz w5, lbl
|
|
cbz x5, lbl
|
|
cbnz x2, lbl
|
|
cbnz x26, lbl
|
|
// CHECK: cbz w5, lbl // encoding: [0x05'A',A,A,0x34'A']
|
|
// CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
|
|
// CHECK: cbz x5, lbl // encoding: [0x05'A',A,A,0xb4'A']
|
|
// CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
|
|
// CHECK: cbnz x2, lbl // encoding: [0x02'A',A,A,0xb5'A']
|
|
// CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
|
|
// CHECK: cbnz x26, lbl // encoding: [0x1a'A',A,A,0xb5'A']
|
|
// CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
|
|
|
|
cbz wzr, lbl
|
|
cbnz xzr, lbl
|
|
// CHECK: cbz wzr, lbl // encoding: [0x1f'A',A,A,0x34'A']
|
|
// CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
|
|
// CHECK: cbnz xzr, lbl // encoding: [0x1f'A',A,A,0xb5'A']
|
|
// CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
|
|
|
|
cbz w5, #0
|
|
cbnz x3, #-4
|
|
cbz w20, #1048572
|
|
cbnz xzr, #-1048576
|
|
// CHECK: cbz w5, #0 // encoding: [0x05,0x00,0x00,0x34]
|
|
// CHECK: cbnz x3, #-4 // encoding: [0xe3,0xff,0xff,0xb5]
|
|
// CHECK: cbz w20, #1048572 // encoding: [0xf4,0xff,0x7f,0x34]
|
|
// CHECK: cbnz xzr, #-1048576 // encoding: [0x1f,0x00,0x80,0xb5]
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Conditional branch (immediate)
|
|
//------------------------------------------------------------------------------
|
|
|
|
b.eq lbl
|
|
b.ne lbl
|
|
b.cs lbl
|
|
b.hs lbl
|
|
b.lo lbl
|
|
b.cc lbl
|
|
b.mi lbl
|
|
b.pl lbl
|
|
b.vs lbl
|
|
b.vc lbl
|
|
b.hi lbl
|
|
b.ls lbl
|
|
b.ge lbl
|
|
b.lt lbl
|
|
b.gt lbl
|
|
b.le lbl
|
|
b.al lbl
|
|
// CHECK: b.eq lbl // encoding: [A,A,A,0x54'A']
|
|
// CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
|
|
// CHECK: b.ne lbl // encoding: [0x01'A',A,A,0x54'A']
|
|
// CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
|
|
// CHECK: b.hs lbl // encoding: [0x02'A',A,A,0x54'A']
|
|
// CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
|
|
// CHECK: b.hs lbl // encoding: [0x02'A',A,A,0x54'A']
|
|
// CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
|
|
// CHECK: b.lo lbl // encoding: [0x03'A',A,A,0x54'A']
|
|
// CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
|
|
// CHECK: b.lo lbl // encoding: [0x03'A',A,A,0x54'A']
|
|
// CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
|
|
// CHECK: b.mi lbl // encoding: [0x04'A',A,A,0x54'A']
|
|
// CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
|
|
// CHECK: b.pl lbl // encoding: [0x05'A',A,A,0x54'A']
|
|
// CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
|
|
// CHECK: b.vs lbl // encoding: [0x06'A',A,A,0x54'A']
|
|
// CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
|
|
// CHECK: b.vc lbl // encoding: [0x07'A',A,A,0x54'A']
|
|
// CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
|
|
// CHECK: b.hi lbl // encoding: [0x08'A',A,A,0x54'A']
|
|
// CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
|
|
// CHECK: b.ls lbl // encoding: [0x09'A',A,A,0x54'A']
|
|
// CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
|
|
// CHECK: b.ge lbl // encoding: [0x0a'A',A,A,0x54'A']
|
|
// CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
|
|
// CHECK: b.lt lbl // encoding: [0x0b'A',A,A,0x54'A']
|
|
// CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
|
|
// CHECK: b.gt lbl // encoding: [0x0c'A',A,A,0x54'A']
|
|
// CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
|
|
// CHECK: b.le lbl // encoding: [0x0d'A',A,A,0x54'A']
|
|
// CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
|
|
// CHECK: b.al lbl // encoding: [0x0e'A',A,A,0x54'A']
|
|
// CHECK: // fixup A - offset: 0, value: lbl, kind: fixup_a64_condbr
|
|
|
|
b.eq #0
|
|
b.lt #-4
|
|
b.cc #1048572
|
|
// CHECK: b.eq #0 // encoding: [0x00,0x00,0x00,0x54]
|
|
// CHECK: b.lt #-4 // encoding: [0xeb,0xff,0xff,0x54]
|
|
// CHECK: b.lo #1048572 // encoding: [0xe3,0xff,0x7f,0x54]
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Conditional compare (immediate)
|
|
//------------------------------------------------------------------------------
|
|
|
|
ccmp w1, #31, #0, eq
|
|
ccmp w3, #0, #15, hs
|
|
ccmp wzr, #15, #13, cs
|
|
// CHECK: ccmp w1, #31, #0, eq // encoding: [0x20,0x08,0x5f,0x7a]
|
|
// CHECK: ccmp w3, #0, #15, hs // encoding: [0x6f,0x28,0x40,0x7a]
|
|
// CHECK: ccmp wzr, #15, #13, hs // encoding: [0xed,0x2b,0x4f,0x7a]
|
|
|
|
ccmp x9, #31, #0, le
|
|
ccmp x3, #0, #15, gt
|
|
ccmp xzr, #5, #7, ne
|
|
// CHECK: ccmp x9, #31, #0, le // encoding: [0x20,0xd9,0x5f,0xfa]
|
|
// CHECK: ccmp x3, #0, #15, gt // encoding: [0x6f,0xc8,0x40,0xfa]
|
|
// CHECK: ccmp xzr, #5, #7, ne // encoding: [0xe7,0x1b,0x45,0xfa]
|
|
|
|
ccmn w1, #31, #0, eq
|
|
ccmn w3, #0, #15, hs
|
|
ccmn wzr, #15, #13, cs
|
|
// CHECK: ccmn w1, #31, #0, eq // encoding: [0x20,0x08,0x5f,0x3a]
|
|
// CHECK: ccmn w3, #0, #15, hs // encoding: [0x6f,0x28,0x40,0x3a]
|
|
// CHECK: ccmn wzr, #15, #13, hs // encoding: [0xed,0x2b,0x4f,0x3a]
|
|
|
|
ccmn x9, #31, #0, le
|
|
ccmn x3, #0, #15, gt
|
|
ccmn xzr, #5, #7, ne
|
|
// CHECK: ccmn x9, #31, #0, le // encoding: [0x20,0xd9,0x5f,0xba]
|
|
// CHECK: ccmn x3, #0, #15, gt // encoding: [0x6f,0xc8,0x40,0xba]
|
|
// CHECK: ccmn xzr, #5, #7, ne // encoding: [0xe7,0x1b,0x45,0xba]
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Conditional compare (register)
|
|
//------------------------------------------------------------------------------
|
|
|
|
ccmp w1, wzr, #0, eq
|
|
ccmp w3, w0, #15, hs
|
|
ccmp wzr, w15, #13, cs
|
|
// CHECK: ccmp w1, wzr, #0, eq // encoding: [0x20,0x00,0x5f,0x7a]
|
|
// CHECK: ccmp w3, w0, #15, hs // encoding: [0x6f,0x20,0x40,0x7a]
|
|
// CHECK: ccmp wzr, w15, #13, hs // encoding: [0xed,0x23,0x4f,0x7a]
|
|
|
|
ccmp x9, xzr, #0, le
|
|
ccmp x3, x0, #15, gt
|
|
ccmp xzr, x5, #7, ne
|
|
// CHECK: ccmp x9, xzr, #0, le // encoding: [0x20,0xd1,0x5f,0xfa]
|
|
// CHECK: ccmp x3, x0, #15, gt // encoding: [0x6f,0xc0,0x40,0xfa]
|
|
// CHECK: ccmp xzr, x5, #7, ne // encoding: [0xe7,0x13,0x45,0xfa]
|
|
|
|
ccmn w1, wzr, #0, eq
|
|
ccmn w3, w0, #15, hs
|
|
ccmn wzr, w15, #13, cs
|
|
// CHECK: ccmn w1, wzr, #0, eq // encoding: [0x20,0x00,0x5f,0x3a]
|
|
// CHECK: ccmn w3, w0, #15, hs // encoding: [0x6f,0x20,0x40,0x3a]
|
|
// CHECK: ccmn wzr, w15, #13, hs // encoding: [0xed,0x23,0x4f,0x3a]
|
|
|
|
ccmn x9, xzr, #0, le
|
|
ccmn x3, x0, #15, gt
|
|
ccmn xzr, x5, #7, ne
|
|
// CHECK: ccmn x9, xzr, #0, le // encoding: [0x20,0xd1,0x5f,0xba]
|
|
// CHECK: ccmn x3, x0, #15, gt // encoding: [0x6f,0xc0,0x40,0xba]
|
|
// CHECK: ccmn xzr, x5, #7, ne // encoding: [0xe7,0x13,0x45,0xba]
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Conditional select
|
|
//------------------------------------------------------------------------------
|
|
csel w1, w0, w19, ne
|
|
csel wzr, w5, w9, eq
|
|
csel w9, wzr, w30, gt
|
|
csel w1, w28, wzr, mi
|
|
// CHECK: csel w1, w0, w19, ne // encoding: [0x01,0x10,0x93,0x1a]
|
|
// CHECK: csel wzr, w5, w9, eq // encoding: [0xbf,0x00,0x89,0x1a]
|
|
// CHECK: csel w9, wzr, w30, gt // encoding: [0xe9,0xc3,0x9e,0x1a]
|
|
// CHECK: csel w1, w28, wzr, mi // encoding: [0x81,0x43,0x9f,0x1a]
|
|
|
|
csel x19, x23, x29, lt
|
|
csel xzr, x3, x4, ge
|
|
csel x5, xzr, x6, cs
|
|
csel x7, x8, xzr, cc
|
|
// CHECK: csel x19, x23, x29, lt // encoding: [0xf3,0xb2,0x9d,0x9a]
|
|
// CHECK: csel xzr, x3, x4, ge // encoding: [0x7f,0xa0,0x84,0x9a]
|
|
// CHECK: csel x5, xzr, x6, hs // encoding: [0xe5,0x23,0x86,0x9a]
|
|
// CHECK: csel x7, x8, xzr, lo // encoding: [0x07,0x31,0x9f,0x9a]
|
|
|
|
csinc w1, w0, w19, ne
|
|
csinc wzr, w5, w9, eq
|
|
csinc w9, wzr, w30, gt
|
|
csinc w1, w28, wzr, mi
|
|
// CHECK: csinc w1, w0, w19, ne // encoding: [0x01,0x14,0x93,0x1a]
|
|
// CHECK: csinc wzr, w5, w9, eq // encoding: [0xbf,0x04,0x89,0x1a]
|
|
// CHECK: csinc w9, wzr, w30, gt // encoding: [0xe9,0xc7,0x9e,0x1a]
|
|
// CHECK: csinc w1, w28, wzr, mi // encoding: [0x81,0x47,0x9f,0x1a]
|
|
|
|
csinc x19, x23, x29, lt
|
|
csinc xzr, x3, x4, ge
|
|
csinc x5, xzr, x6, cs
|
|
csinc x7, x8, xzr, cc
|
|
// CHECK: csinc x19, x23, x29, lt // encoding: [0xf3,0xb6,0x9d,0x9a]
|
|
// CHECK: csinc xzr, x3, x4, ge // encoding: [0x7f,0xa4,0x84,0x9a]
|
|
// CHECK: csinc x5, xzr, x6, hs // encoding: [0xe5,0x27,0x86,0x9a]
|
|
// CHECK: csinc x7, x8, xzr, lo // encoding: [0x07,0x35,0x9f,0x9a]
|
|
|
|
csinv w1, w0, w19, ne
|
|
csinv wzr, w5, w9, eq
|
|
csinv w9, wzr, w30, gt
|
|
csinv w1, w28, wzr, mi
|
|
// CHECK: csinv w1, w0, w19, ne // encoding: [0x01,0x10,0x93,0x5a]
|
|
// CHECK: csinv wzr, w5, w9, eq // encoding: [0xbf,0x00,0x89,0x5a]
|
|
// CHECK: csinv w9, wzr, w30, gt // encoding: [0xe9,0xc3,0x9e,0x5a]
|
|
// CHECK: csinv w1, w28, wzr, mi // encoding: [0x81,0x43,0x9f,0x5a]
|
|
|
|
csinv x19, x23, x29, lt
|
|
csinv xzr, x3, x4, ge
|
|
csinv x5, xzr, x6, cs
|
|
csinv x7, x8, xzr, cc
|
|
// CHECK: csinv x19, x23, x29, lt // encoding: [0xf3,0xb2,0x9d,0xda]
|
|
// CHECK: csinv xzr, x3, x4, ge // encoding: [0x7f,0xa0,0x84,0xda]
|
|
// CHECK: csinv x5, xzr, x6, hs // encoding: [0xe5,0x23,0x86,0xda]
|
|
// CHECK: csinv x7, x8, xzr, lo // encoding: [0x07,0x31,0x9f,0xda]
|
|
|
|
csneg w1, w0, w19, ne
|
|
csneg wzr, w5, w9, eq
|
|
csneg w9, wzr, w30, gt
|
|
csneg w1, w28, wzr, mi
|
|
// CHECK: csneg w1, w0, w19, ne // encoding: [0x01,0x14,0x93,0x5a]
|
|
// CHECK: csneg wzr, w5, w9, eq // encoding: [0xbf,0x04,0x89,0x5a]
|
|
// CHECK: csneg w9, wzr, w30, gt // encoding: [0xe9,0xc7,0x9e,0x5a]
|
|
// CHECK: csneg w1, w28, wzr, mi // encoding: [0x81,0x47,0x9f,0x5a]
|
|
|
|
csneg x19, x23, x29, lt
|
|
csneg xzr, x3, x4, ge
|
|
csneg x5, xzr, x6, cs
|
|
csneg x7, x8, xzr, cc
|
|
// CHECK: csneg x19, x23, x29, lt // encoding: [0xf3,0xb6,0x9d,0xda]
|
|
// CHECK: csneg xzr, x3, x4, ge // encoding: [0x7f,0xa4,0x84,0xda]
|
|
// CHECK: csneg x5, xzr, x6, hs // encoding: [0xe5,0x27,0x86,0xda]
|
|
// CHECK: csneg x7, x8, xzr, lo // encoding: [0x07,0x35,0x9f,0xda]
|
|
|
|
cset w3, eq
|
|
cset x9, pl
|
|
// CHECK: csinc w3, wzr, wzr, ne // encoding: [0xe3,0x17,0x9f,0x1a]
|
|
// CHECK: csinc x9, xzr, xzr, mi // encoding: [0xe9,0x47,0x9f,0x9a]
|
|
|
|
csetm w20, ne
|
|
csetm x30, ge
|
|
// CHECK: csinv w20, wzr, wzr, eq // encoding: [0xf4,0x03,0x9f,0x5a]
|
|
// CHECK: csinv x30, xzr, xzr, lt // encoding: [0xfe,0xb3,0x9f,0xda]
|
|
|
|
cinc w3, w5, gt
|
|
cinc wzr, w4, le
|
|
cinc w9, wzr, lt
|
|
// CHECK: csinc w3, w5, w5, le // encoding: [0xa3,0xd4,0x85,0x1a]
|
|
// CHECK: csinc wzr, w4, w4, gt // encoding: [0x9f,0xc4,0x84,0x1a]
|
|
// CHECK: csinc w9, wzr, wzr, ge // encoding: [0xe9,0xa7,0x9f,0x1a]
|
|
|
|
cinc x3, x5, gt
|
|
cinc xzr, x4, le
|
|
cinc x9, xzr, lt
|
|
// CHECK: csinc x3, x5, x5, le // encoding: [0xa3,0xd4,0x85,0x9a]
|
|
// CHECK: csinc xzr, x4, x4, gt // encoding: [0x9f,0xc4,0x84,0x9a]
|
|
// CHECK: csinc x9, xzr, xzr, ge // encoding: [0xe9,0xa7,0x9f,0x9a]
|
|
|
|
cinv w3, w5, gt
|
|
cinv wzr, w4, le
|
|
cinv w9, wzr, lt
|
|
// CHECK: csinv w3, w5, w5, le // encoding: [0xa3,0xd0,0x85,0x5a]
|
|
// CHECK: csinv wzr, w4, w4, gt // encoding: [0x9f,0xc0,0x84,0x5a]
|
|
// CHECK: csinv w9, wzr, wzr, ge // encoding: [0xe9,0xa3,0x9f,0x5a]
|
|
|
|
cinv x3, x5, gt
|
|
cinv xzr, x4, le
|
|
cinv x9, xzr, lt
|
|
// CHECK: csinv x3, x5, x5, le // encoding: [0xa3,0xd0,0x85,0xda]
|
|
// CHECK: csinv xzr, x4, x4, gt // encoding: [0x9f,0xc0,0x84,0xda]
|
|
// CHECK: csinv x9, xzr, xzr, ge // encoding: [0xe9,0xa3,0x9f,0xda]
|
|
|
|
cneg w3, w5, gt
|
|
cneg wzr, w4, le
|
|
cneg w9, wzr, lt
|
|
// CHECK: csneg w3, w5, w5, le // encoding: [0xa3,0xd4,0x85,0x5a]
|
|
// CHECK: csneg wzr, w4, w4, gt // encoding: [0x9f,0xc4,0x84,0x5a]
|
|
// CHECK: csneg w9, wzr, wzr, ge // encoding: [0xe9,0xa7,0x9f,0x5a]
|
|
|
|
cneg x3, x5, gt
|
|
cneg xzr, x4, le
|
|
cneg x9, xzr, lt
|
|
// CHECK: csneg x3, x5, x5, le // encoding: [0xa3,0xd4,0x85,0xda]
|
|
// CHECK: csneg xzr, x4, x4, gt // encoding: [0x9f,0xc4,0x84,0xda]
|
|
// CHECK: csneg x9, xzr, xzr, ge // encoding: [0xe9,0xa7,0x9f,0xda]
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Data-processing (1 source)
|
|
//------------------------------------------------------------------------------
|
|
|
|
rbit w0, w7
|
|
rbit x18, x3
|
|
rev16 w17, w1
|
|
rev16 x5, x2
|
|
rev w18, w0
|
|
rev32 x20, x1
|
|
rev32 x20, xzr
|
|
// CHECK: rbit w0, w7 // encoding: [0xe0,0x00,0xc0,0x5a]
|
|
// CHECK: rbit x18, x3 // encoding: [0x72,0x00,0xc0,0xda]
|
|
// CHECK: rev16 w17, w1 // encoding: [0x31,0x04,0xc0,0x5a]
|
|
// CHECK: rev16 x5, x2 // encoding: [0x45,0x04,0xc0,0xda]
|
|
// CHECK: rev w18, w0 // encoding: [0x12,0x08,0xc0,0x5a]
|
|
// CHECK: rev32 x20, x1 // encoding: [0x34,0x08,0xc0,0xda]
|
|
// CHECK: rev32 x20, xzr // encoding: [0xf4,0x0b,0xc0,0xda]
|
|
|
|
rev x22, x2
|
|
rev x18, xzr
|
|
rev w7, wzr
|
|
clz w24, w3
|
|
clz x26, x4
|
|
cls w3, w5
|
|
cls x20, x5
|
|
// CHECK: rev x22, x2 // encoding: [0x56,0x0c,0xc0,0xda]
|
|
// CHECK: rev x18, xzr // encoding: [0xf2,0x0f,0xc0,0xda]
|
|
// CHECK: rev w7, wzr // encoding: [0xe7,0x0b,0xc0,0x5a]
|
|
// CHECK: clz w24, w3 // encoding: [0x78,0x10,0xc0,0x5a]
|
|
// CHECK: clz x26, x4 // encoding: [0x9a,0x10,0xc0,0xda]
|
|
// CHECK: cls w3, w5 // encoding: [0xa3,0x14,0xc0,0x5a]
|
|
// CHECK: cls x20, x5 // encoding: [0xb4,0x14,0xc0,0xda]
|
|
|
|
clz w24, wzr
|
|
rev x22, xzr
|
|
// CHECK: clz w24, wzr // encoding: [0xf8,0x13,0xc0,0x5a]
|
|
// CHECK: rev x22, xzr // encoding: [0xf6,0x0f,0xc0,0xda]
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Data-processing (2 source)
|
|
//------------------------------------------------------------------------------
|
|
|
|
crc32b w5, w7, w20
|
|
crc32h w28, wzr, w30
|
|
crc32w w0, w1, w2
|
|
crc32x w7, w9, x20
|
|
crc32cb w9, w5, w4
|
|
crc32ch w13, w17, w25
|
|
crc32cw wzr, w3, w5
|
|
crc32cx w18, w16, xzr
|
|
// CHECK: crc32b w5, w7, w20 // encoding: [0xe5,0x40,0xd4,0x1a]
|
|
// CHECK: crc32h w28, wzr, w30 // encoding: [0xfc,0x47,0xde,0x1a]
|
|
// CHECK: crc32w w0, w1, w2 // encoding: [0x20,0x48,0xc2,0x1a]
|
|
// CHECK: crc32x w7, w9, x20 // encoding: [0x27,0x4d,0xd4,0x9a]
|
|
// CHECK: crc32cb w9, w5, w4 // encoding: [0xa9,0x50,0xc4,0x1a]
|
|
// CHECK: crc32ch w13, w17, w25 // encoding: [0x2d,0x56,0xd9,0x1a]
|
|
// CHECK: crc32cw wzr, w3, w5 // encoding: [0x7f,0x58,0xc5,0x1a]
|
|
// CHECK: crc32cx w18, w16, xzr // encoding: [0x12,0x5e,0xdf,0x9a]
|
|
|
|
udiv w0, w7, w10
|
|
udiv x9, x22, x4
|
|
sdiv w12, w21, w0
|
|
sdiv x13, x2, x1
|
|
lslv w11, w12, w13
|
|
lslv x14, x15, x16
|
|
lsrv w17, w18, w19
|
|
lsrv x20, x21, x22
|
|
asrv w23, w24, w25
|
|
asrv x26, x27, x28
|
|
rorv w0, w1, w2
|
|
rorv x3, x4, x5
|
|
|
|
|
|
// CHECK: udiv w0, w7, w10 // encoding: [0xe0,0x08,0xca,0x1a]
|
|
// CHECK: udiv x9, x22, x4 // encoding: [0xc9,0x0a,0xc4,0x9a]
|
|
// CHECK: sdiv w12, w21, w0 // encoding: [0xac,0x0e,0xc0,0x1a]
|
|
// CHECK: sdiv x13, x2, x1 // encoding: [0x4d,0x0c,0xc1,0x9a]
|
|
// CHECK: lsl w11, w12, w13 // encoding: [0x8b,0x21,0xcd,0x1a]
|
|
// CHECK: lsl x14, x15, x16 // encoding: [0xee,0x21,0xd0,0x9a]
|
|
// CHECK: lsr w17, w18, w19 // encoding: [0x51,0x26,0xd3,0x1a]
|
|
// CHECK: lsr x20, x21, x22 // encoding: [0xb4,0x26,0xd6,0x9a]
|
|
// CHECK: asr w23, w24, w25 // encoding: [0x17,0x2b,0xd9,0x1a]
|
|
// CHECK: asr x26, x27, x28 // encoding: [0x7a,0x2b,0xdc,0x9a]
|
|
// CHECK: ror w0, w1, w2 // encoding: [0x20,0x2c,0xc2,0x1a]
|
|
// CHECK: ror x3, x4, x5 // encoding: [0x83,0x2c,0xc5,0x9a]
|
|
|
|
|
|
lsl w6, w7, w8
|
|
lsl x9, x10, x11
|
|
lsr w12, w13, w14
|
|
lsr x15, x16, x17
|
|
asr w18, w19, w20
|
|
asr x21, x22, x23
|
|
ror w24, w25, w26
|
|
ror x27, x28, x29
|
|
// CHECK: lsl w6, w7, w8 // encoding: [0xe6,0x20,0xc8,0x1a]
|
|
// CHECK: lsl x9, x10, x11 // encoding: [0x49,0x21,0xcb,0x9a]
|
|
// CHECK: lsr w12, w13, w14 // encoding: [0xac,0x25,0xce,0x1a]
|
|
// CHECK: lsr x15, x16, x17 // encoding: [0x0f,0x26,0xd1,0x9a]
|
|
// CHECK: asr w18, w19, w20 // encoding: [0x72,0x2a,0xd4,0x1a]
|
|
// CHECK: asr x21, x22, x23 // encoding: [0xd5,0x2a,0xd7,0x9a]
|
|
// CHECK: ror w24, w25, w26 // encoding: [0x38,0x2f,0xda,0x1a]
|
|
// CHECK: ror x27, x28, x29 // encoding: [0x9b,0x2f,0xdd,0x9a]
|
|
|
|
madd w1, w3, w7, w4
|
|
madd wzr, w0, w9, w11
|
|
madd w13, wzr, w4, w4
|
|
madd w19, w30, wzr, w29
|
|
madd w4, w5, w6, wzr
|
|
// CHECK: madd w1, w3, w7, w4 // encoding: [0x61,0x10,0x07,0x1b]
|
|
// CHECK: madd wzr, w0, w9, w11 // encoding: [0x1f,0x2c,0x09,0x1b]
|
|
// CHECK: madd w13, wzr, w4, w4 // encoding: [0xed,0x13,0x04,0x1b]
|
|
// CHECK: madd w19, w30, wzr, w29 // encoding: [0xd3,0x77,0x1f,0x1b]
|
|
// CHECK: mul w4, w5, w6 // encoding: [0xa4,0x7c,0x06,0x1b]
|
|
|
|
madd x1, x3, x7, x4
|
|
madd xzr, x0, x9, x11
|
|
madd x13, xzr, x4, x4
|
|
madd x19, x30, xzr, x29
|
|
madd x4, x5, x6, xzr
|
|
// CHECK: madd x1, x3, x7, x4 // encoding: [0x61,0x10,0x07,0x9b]
|
|
// CHECK: madd xzr, x0, x9, x11 // encoding: [0x1f,0x2c,0x09,0x9b]
|
|
// CHECK: madd x13, xzr, x4, x4 // encoding: [0xed,0x13,0x04,0x9b]
|
|
// CHECK: madd x19, x30, xzr, x29 // encoding: [0xd3,0x77,0x1f,0x9b]
|
|
// CHECK: mul x4, x5, x6 // encoding: [0xa4,0x7c,0x06,0x9b]
|
|
|
|
msub w1, w3, w7, w4
|
|
msub wzr, w0, w9, w11
|
|
msub w13, wzr, w4, w4
|
|
msub w19, w30, wzr, w29
|
|
msub w4, w5, w6, wzr
|
|
// CHECK: msub w1, w3, w7, w4 // encoding: [0x61,0x90,0x07,0x1b]
|
|
// CHECK: msub wzr, w0, w9, w11 // encoding: [0x1f,0xac,0x09,0x1b]
|
|
// CHECK: msub w13, wzr, w4, w4 // encoding: [0xed,0x93,0x04,0x1b]
|
|
// CHECK: msub w19, w30, wzr, w29 // encoding: [0xd3,0xf7,0x1f,0x1b]
|
|
// CHECK: mneg w4, w5, w6 // encoding: [0xa4,0xfc,0x06,0x1b]
|
|
|
|
msub x1, x3, x7, x4
|
|
msub xzr, x0, x9, x11
|
|
msub x13, xzr, x4, x4
|
|
msub x19, x30, xzr, x29
|
|
msub x4, x5, x6, xzr
|
|
// CHECK: msub x1, x3, x7, x4 // encoding: [0x61,0x90,0x07,0x9b]
|
|
// CHECK: msub xzr, x0, x9, x11 // encoding: [0x1f,0xac,0x09,0x9b]
|
|
// CHECK: msub x13, xzr, x4, x4 // encoding: [0xed,0x93,0x04,0x9b]
|
|
// CHECK: msub x19, x30, xzr, x29 // encoding: [0xd3,0xf7,0x1f,0x9b]
|
|
// CHECK: mneg x4, x5, x6 // encoding: [0xa4,0xfc,0x06,0x9b]
|
|
|
|
smaddl x3, w5, w2, x9
|
|
smaddl xzr, w10, w11, x12
|
|
smaddl x13, wzr, w14, x15
|
|
smaddl x16, w17, wzr, x18
|
|
smaddl x19, w20, w21, xzr
|
|
// CHECK: smaddl x3, w5, w2, x9 // encoding: [0xa3,0x24,0x22,0x9b]
|
|
// CHECK: smaddl xzr, w10, w11, x12 // encoding: [0x5f,0x31,0x2b,0x9b]
|
|
// CHECK: smaddl x13, wzr, w14, x15 // encoding: [0xed,0x3f,0x2e,0x9b]
|
|
// CHECK: smaddl x16, w17, wzr, x18 // encoding: [0x30,0x4a,0x3f,0x9b]
|
|
// CHECK: smull x19, w20, w21 // encoding: [0x93,0x7e,0x35,0x9b]
|
|
|
|
smsubl x3, w5, w2, x9
|
|
smsubl xzr, w10, w11, x12
|
|
smsubl x13, wzr, w14, x15
|
|
smsubl x16, w17, wzr, x18
|
|
smsubl x19, w20, w21, xzr
|
|
// CHECK: smsubl x3, w5, w2, x9 // encoding: [0xa3,0xa4,0x22,0x9b]
|
|
// CHECK: smsubl xzr, w10, w11, x12 // encoding: [0x5f,0xb1,0x2b,0x9b]
|
|
// CHECK: smsubl x13, wzr, w14, x15 // encoding: [0xed,0xbf,0x2e,0x9b]
|
|
// CHECK: smsubl x16, w17, wzr, x18 // encoding: [0x30,0xca,0x3f,0x9b]
|
|
// CHECK: smnegl x19, w20, w21 // encoding: [0x93,0xfe,0x35,0x9b]
|
|
|
|
umaddl x3, w5, w2, x9
|
|
umaddl xzr, w10, w11, x12
|
|
umaddl x13, wzr, w14, x15
|
|
umaddl x16, w17, wzr, x18
|
|
umaddl x19, w20, w21, xzr
|
|
// CHECK: umaddl x3, w5, w2, x9 // encoding: [0xa3,0x24,0xa2,0x9b]
|
|
// CHECK: umaddl xzr, w10, w11, x12 // encoding: [0x5f,0x31,0xab,0x9b]
|
|
// CHECK: umaddl x13, wzr, w14, x15 // encoding: [0xed,0x3f,0xae,0x9b]
|
|
// CHECK: umaddl x16, w17, wzr, x18 // encoding: [0x30,0x4a,0xbf,0x9b]
|
|
// CHECK: umull x19, w20, w21 // encoding: [0x93,0x7e,0xb5,0x9b]
|
|
|
|
|
|
|
|
umsubl x3, w5, w2, x9
|
|
umsubl xzr, w10, w11, x12
|
|
umsubl x13, wzr, w14, x15
|
|
umsubl x16, w17, wzr, x18
|
|
umsubl x19, w20, w21, xzr
|
|
// CHECK: umsubl x3, w5, w2, x9 // encoding: [0xa3,0xa4,0xa2,0x9b]
|
|
// CHECK: umsubl xzr, w10, w11, x12 // encoding: [0x5f,0xb1,0xab,0x9b]
|
|
// CHECK: umsubl x13, wzr, w14, x15 // encoding: [0xed,0xbf,0xae,0x9b]
|
|
// CHECK: umsubl x16, w17, wzr, x18 // encoding: [0x30,0xca,0xbf,0x9b]
|
|
// CHECK: umnegl x19, w20, w21 // encoding: [0x93,0xfe,0xb5,0x9b]
|
|
|
|
smulh x30, x29, x28
|
|
smulh xzr, x27, x26
|
|
smulh x25, xzr, x24
|
|
smulh x23, x22, xzr
|
|
// CHECK: smulh x30, x29, x28 // encoding: [0xbe,0x7f,0x5c,0x9b]
|
|
// CHECK: smulh xzr, x27, x26 // encoding: [0x7f,0x7f,0x5a,0x9b]
|
|
// CHECK: smulh x25, xzr, x24 // encoding: [0xf9,0x7f,0x58,0x9b]
|
|
// CHECK: smulh x23, x22, xzr // encoding: [0xd7,0x7e,0x5f,0x9b]
|
|
|
|
umulh x30, x29, x28
|
|
umulh xzr, x27, x26
|
|
umulh x25, xzr, x24
|
|
umulh x23, x22, xzr
|
|
// CHECK: umulh x30, x29, x28 // encoding: [0xbe,0x7f,0xdc,0x9b]
|
|
// CHECK: umulh xzr, x27, x26 // encoding: [0x7f,0x7f,0xda,0x9b]
|
|
// CHECK: umulh x25, xzr, x24 // encoding: [0xf9,0x7f,0xd8,0x9b]
|
|
// CHECK: umulh x23, x22, xzr // encoding: [0xd7,0x7e,0xdf,0x9b]
|
|
|
|
mul w3, w4, w5
|
|
mul wzr, w6, w7
|
|
mul w8, wzr, w9
|
|
mul w10, w11, wzr
|
|
|
|
mul x12, x13, x14
|
|
mul xzr, x15, x16
|
|
mul x17, xzr, x18
|
|
mul x19, x20, xzr
|
|
|
|
mneg w21, w22, w23
|
|
mneg wzr, w24, w25
|
|
mneg w26, wzr, w27
|
|
mneg w28, w29, wzr
|
|
|
|
smull x11, w13, w17
|
|
umull x11, w13, w17
|
|
smnegl x11, w13, w17
|
|
umnegl x11, w13, w17
|
|
// CHECK: mul w3, w4, w5 // encoding: [0x83,0x7c,0x05,0x1b]
|
|
// CHECK: mul wzr, w6, w7 // encoding: [0xdf,0x7c,0x07,0x1b]
|
|
// CHECK: mul w8, wzr, w9 // encoding: [0xe8,0x7f,0x09,0x1b]
|
|
// CHECK: mul w10, w11, wzr // encoding: [0x6a,0x7d,0x1f,0x1b]
|
|
// CHECK: mul x12, x13, x14 // encoding: [0xac,0x7d,0x0e,0x9b]
|
|
// CHECK: mul xzr, x15, x16 // encoding: [0xff,0x7d,0x10,0x9b]
|
|
// CHECK: mul x17, xzr, x18 // encoding: [0xf1,0x7f,0x12,0x9b]
|
|
// CHECK: mul x19, x20, xzr // encoding: [0x93,0x7e,0x1f,0x9b]
|
|
// CHECK: mneg w21, w22, w23 // encoding: [0xd5,0xfe,0x17,0x1b]
|
|
// CHECK: mneg wzr, w24, w25 // encoding: [0x1f,0xff,0x19,0x1b]
|
|
// CHECK: mneg w26, wzr, w27 // encoding: [0xfa,0xff,0x1b,0x1b]
|
|
// CHECK: mneg w28, w29, wzr // encoding: [0xbc,0xff,0x1f,0x1b]
|
|
// CHECK: smull x11, w13, w17 // encoding: [0xab,0x7d,0x31,0x9b]
|
|
// CHECK: umull x11, w13, w17 // encoding: [0xab,0x7d,0xb1,0x9b]
|
|
// CHECK: smnegl x11, w13, w17 // encoding: [0xab,0xfd,0x31,0x9b]
|
|
// CHECK: umnegl x11, w13, w17 // encoding: [0xab,0xfd,0xb1,0x9b]
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Exception generation
|
|
//------------------------------------------------------------------------------
|
|
svc #0
|
|
svc #65535
|
|
// CHECK: svc #0 // encoding: [0x01,0x00,0x00,0xd4]
|
|
// CHECK: svc #65535 // encoding: [0xe1,0xff,0x1f,0xd4]
|
|
|
|
hvc #1
|
|
smc #12000
|
|
brk #12
|
|
hlt #123
|
|
// CHECK: hvc #1 // encoding: [0x22,0x00,0x00,0xd4]
|
|
// CHECK: smc #12000 // encoding: [0x03,0xdc,0x05,0xd4]
|
|
// CHECK: brk #12 // encoding: [0x80,0x01,0x20,0xd4]
|
|
// CHECK: hlt #123 // encoding: [0x60,0x0f,0x40,0xd4]
|
|
|
|
dcps1 #42
|
|
dcps2 #9
|
|
dcps3 #1000
|
|
// CHECK: dcps1 #42 // encoding: [0x41,0x05,0xa0,0xd4]
|
|
// CHECK: dcps2 #9 // encoding: [0x22,0x01,0xa0,0xd4]
|
|
// CHECK: dcps3 #1000 // encoding: [0x03,0x7d,0xa0,0xd4]
|
|
|
|
dcps1
|
|
dcps2
|
|
dcps3
|
|
// CHECK: dcps1 // encoding: [0x01,0x00,0xa0,0xd4]
|
|
// CHECK: dcps2 // encoding: [0x02,0x00,0xa0,0xd4]
|
|
// CHECK: dcps3 // encoding: [0x03,0x00,0xa0,0xd4]
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Extract (immediate)
|
|
//------------------------------------------------------------------------------
|
|
|
|
extr w3, w5, w7, #0
|
|
extr w11, w13, w17, #31
|
|
// CHECK: extr w3, w5, w7, #0 // encoding: [0xa3,0x00,0x87,0x13]
|
|
// CHECK: extr w11, w13, w17, #31 // encoding: [0xab,0x7d,0x91,0x13]
|
|
|
|
extr x3, x5, x7, #15
|
|
extr x11, x13, x17, #63
|
|
// CHECK: extr x3, x5, x7, #15 // encoding: [0xa3,0x3c,0xc7,0x93]
|
|
// CHECK: extr x11, x13, x17, #63 // encoding: [0xab,0xfd,0xd1,0x93]
|
|
|
|
ror x19, x23, #24
|
|
ror x29, xzr, #63
|
|
// CHECK: extr x19, x23, x23, #24 // encoding: [0xf3,0x62,0xd7,0x93]
|
|
// CHECK: extr x29, xzr, xzr, #63 // encoding: [0xfd,0xff,0xdf,0x93]
|
|
|
|
ror w9, w13, #31
|
|
// CHECK: extr w9, w13, w13, #31 // encoding: [0xa9,0x7d,0x8d,0x13]
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Floating-point compare
|
|
//------------------------------------------------------------------------------
|
|
|
|
fcmp s3, s5
|
|
fcmp s31, #0.0
|
|
// CHECK: fcmp s3, s5 // encoding: [0x60,0x20,0x25,0x1e]
|
|
// CHECK: fcmp s31, #0.0 // encoding: [0xe8,0x23,0x20,0x1e]
|
|
|
|
fcmpe s29, s30
|
|
fcmpe s15, #0.0
|
|
// CHECK: fcmpe s29, s30 // encoding: [0xb0,0x23,0x3e,0x1e]
|
|
// CHECK: fcmpe s15, #0.0 // encoding: [0xf8,0x21,0x20,0x1e]
|
|
|
|
fcmp d4, d12
|
|
fcmp d23, #0.0
|
|
// CHECK: fcmp d4, d12 // encoding: [0x80,0x20,0x6c,0x1e]
|
|
// CHECK: fcmp d23, #0.0 // encoding: [0xe8,0x22,0x60,0x1e]
|
|
|
|
fcmpe d26, d22
|
|
fcmpe d29, #0.0
|
|
// CHECK: fcmpe d26, d22 // encoding: [0x50,0x23,0x76,0x1e]
|
|
// CHECK: fcmpe d29, #0.0 // encoding: [0xb8,0x23,0x60,0x1e]
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Floating-point conditional compare
|
|
//------------------------------------------------------------------------------
|
|
|
|
fccmp s1, s31, #0, eq
|
|
fccmp s3, s0, #15, hs
|
|
fccmp s31, s15, #13, cs
|
|
// CHECK: fccmp s1, s31, #0, eq // encoding: [0x20,0x04,0x3f,0x1e]
|
|
// CHECK: fccmp s3, s0, #15, hs // encoding: [0x6f,0x24,0x20,0x1e]
|
|
// CHECK: fccmp s31, s15, #13, hs // encoding: [0xed,0x27,0x2f,0x1e]
|
|
|
|
fccmp d9, d31, #0, le
|
|
fccmp d3, d0, #15, gt
|
|
fccmp d31, d5, #7, ne
|
|
// CHECK: fccmp d9, d31, #0, le // encoding: [0x20,0xd5,0x7f,0x1e]
|
|
// CHECK: fccmp d3, d0, #15, gt // encoding: [0x6f,0xc4,0x60,0x1e]
|
|
// CHECK: fccmp d31, d5, #7, ne // encoding: [0xe7,0x17,0x65,0x1e]
|
|
|
|
fccmpe s1, s31, #0, eq
|
|
fccmpe s3, s0, #15, hs
|
|
fccmpe s31, s15, #13, cs
|
|
// CHECK: fccmpe s1, s31, #0, eq // encoding: [0x30,0x04,0x3f,0x1e]
|
|
// CHECK: fccmpe s3, s0, #15, hs // encoding: [0x7f,0x24,0x20,0x1e]
|
|
// CHECK: fccmpe s31, s15, #13, hs // encoding: [0xfd,0x27,0x2f,0x1e]
|
|
|
|
fccmpe d9, d31, #0, le
|
|
fccmpe d3, d0, #15, gt
|
|
fccmpe d31, d5, #7, ne
|
|
// CHECK: fccmpe d9, d31, #0, le // encoding: [0x30,0xd5,0x7f,0x1e]
|
|
// CHECK: fccmpe d3, d0, #15, gt // encoding: [0x7f,0xc4,0x60,0x1e]
|
|
// CHECK: fccmpe d31, d5, #7, ne // encoding: [0xf7,0x17,0x65,0x1e]
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Floating-point conditional compare
|
|
//------------------------------------------------------------------------------
|
|
|
|
fcsel s3, s20, s9, pl
|
|
fcsel d9, d10, d11, mi
|
|
// CHECK: fcsel s3, s20, s9, pl // encoding: [0x83,0x5e,0x29,0x1e]
|
|
// CHECK: fcsel d9, d10, d11, mi // encoding: [0x49,0x4d,0x6b,0x1e]
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Floating-point data-processing (1 source)
|
|
//------------------------------------------------------------------------------
|
|
|
|
fmov s0, s1
|
|
fabs s2, s3
|
|
fneg s4, s5
|
|
fsqrt s6, s7
|
|
fcvt d8, s9
|
|
fcvt h10, s11
|
|
frintn s12, s13
|
|
frintp s14, s15
|
|
frintm s16, s17
|
|
frintz s18, s19
|
|
frinta s20, s21
|
|
frintx s22, s23
|
|
frinti s24, s25
|
|
// CHECK: fmov s0, s1 // encoding: [0x20,0x40,0x20,0x1e]
|
|
// CHECK: fabs s2, s3 // encoding: [0x62,0xc0,0x20,0x1e]
|
|
// CHECK: fneg s4, s5 // encoding: [0xa4,0x40,0x21,0x1e]
|
|
// CHECK: fsqrt s6, s7 // encoding: [0xe6,0xc0,0x21,0x1e]
|
|
// CHECK: fcvt d8, s9 // encoding: [0x28,0xc1,0x22,0x1e]
|
|
// CHECK: fcvt h10, s11 // encoding: [0x6a,0xc1,0x23,0x1e]
|
|
// CHECK: frintn s12, s13 // encoding: [0xac,0x41,0x24,0x1e]
|
|
// CHECK: frintp s14, s15 // encoding: [0xee,0xc1,0x24,0x1e]
|
|
// CHECK: frintm s16, s17 // encoding: [0x30,0x42,0x25,0x1e]
|
|
// CHECK: frintz s18, s19 // encoding: [0x72,0xc2,0x25,0x1e]
|
|
// CHECK: frinta s20, s21 // encoding: [0xb4,0x42,0x26,0x1e]
|
|
// CHECK: frintx s22, s23 // encoding: [0xf6,0x42,0x27,0x1e]
|
|
// CHECK: frinti s24, s25 // encoding: [0x38,0xc3,0x27,0x1e]
|
|
|
|
fmov d0, d1
|
|
fabs d2, d3
|
|
fneg d4, d5
|
|
fsqrt d6, d7
|
|
fcvt s8, d9
|
|
fcvt h10, d11
|
|
frintn d12, d13
|
|
frintp d14, d15
|
|
frintm d16, d17
|
|
frintz d18, d19
|
|
frinta d20, d21
|
|
frintx d22, d23
|
|
frinti d24, d25
|
|
// CHECK: fmov d0, d1 // encoding: [0x20,0x40,0x60,0x1e]
|
|
// CHECK: fabs d2, d3 // encoding: [0x62,0xc0,0x60,0x1e]
|
|
// CHECK: fneg d4, d5 // encoding: [0xa4,0x40,0x61,0x1e]
|
|
// CHECK: fsqrt d6, d7 // encoding: [0xe6,0xc0,0x61,0x1e]
|
|
// CHECK: fcvt s8, d9 // encoding: [0x28,0x41,0x62,0x1e]
|
|
// CHECK: fcvt h10, d11 // encoding: [0x6a,0xc1,0x63,0x1e]
|
|
// CHECK: frintn d12, d13 // encoding: [0xac,0x41,0x64,0x1e]
|
|
// CHECK: frintp d14, d15 // encoding: [0xee,0xc1,0x64,0x1e]
|
|
// CHECK: frintm d16, d17 // encoding: [0x30,0x42,0x65,0x1e]
|
|
// CHECK: frintz d18, d19 // encoding: [0x72,0xc2,0x65,0x1e]
|
|
// CHECK: frinta d20, d21 // encoding: [0xb4,0x42,0x66,0x1e]
|
|
// CHECK: frintx d22, d23 // encoding: [0xf6,0x42,0x67,0x1e]
|
|
// CHECK: frinti d24, d25 // encoding: [0x38,0xc3,0x67,0x1e]
|
|
|
|
fcvt s26, h27
|
|
fcvt d28, h29
|
|
// CHECK: fcvt s26, h27 // encoding: [0x7a,0x43,0xe2,0x1e]
|
|
// CHECK: fcvt d28, h29 // encoding: [0xbc,0xc3,0xe2,0x1e]
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Floating-point data-processing (2 sources)
|
|
//------------------------------------------------------------------------------
|
|
|
|
fmul s20, s19, s17
|
|
fdiv s1, s2, s3
|
|
fadd s4, s5, s6
|
|
fsub s7, s8, s9
|
|
fmax s10, s11, s12
|
|
fmin s13, s14, s15
|
|
fmaxnm s16, s17, s18
|
|
fminnm s19, s20, s21
|
|
fnmul s22, s23, s24
|
|
// CHECK: fmul s20, s19, s17 // encoding: [0x74,0x0a,0x31,0x1e]
|
|
// CHECK: fdiv s1, s2, s3 // encoding: [0x41,0x18,0x23,0x1e]
|
|
// CHECK: fadd s4, s5, s6 // encoding: [0xa4,0x28,0x26,0x1e]
|
|
// CHECK: fsub s7, s8, s9 // encoding: [0x07,0x39,0x29,0x1e]
|
|
// CHECK: fmax s10, s11, s12 // encoding: [0x6a,0x49,0x2c,0x1e]
|
|
// CHECK: fmin s13, s14, s15 // encoding: [0xcd,0x59,0x2f,0x1e]
|
|
// CHECK: fmaxnm s16, s17, s18 // encoding: [0x30,0x6a,0x32,0x1e]
|
|
// CHECK: fminnm s19, s20, s21 // encoding: [0x93,0x7a,0x35,0x1e]
|
|
// CHECK: fnmul s22, s23, s24 // encoding: [0xf6,0x8a,0x38,0x1e]
|
|
|
|
fmul d20, d19, d17
|
|
fdiv d1, d2, d3
|
|
fadd d4, d5, d6
|
|
fsub d7, d8, d9
|
|
fmax d10, d11, d12
|
|
fmin d13, d14, d15
|
|
fmaxnm d16, d17, d18
|
|
fminnm d19, d20, d21
|
|
fnmul d22, d23, d24
|
|
// CHECK: fmul d20, d19, d17 // encoding: [0x74,0x0a,0x71,0x1e]
|
|
// CHECK: fdiv d1, d2, d3 // encoding: [0x41,0x18,0x63,0x1e]
|
|
// CHECK: fadd d4, d5, d6 // encoding: [0xa4,0x28,0x66,0x1e]
|
|
// CHECK: fsub d7, d8, d9 // encoding: [0x07,0x39,0x69,0x1e]
|
|
// CHECK: fmax d10, d11, d12 // encoding: [0x6a,0x49,0x6c,0x1e]
|
|
// CHECK: fmin d13, d14, d15 // encoding: [0xcd,0x59,0x6f,0x1e]
|
|
// CHECK: fmaxnm d16, d17, d18 // encoding: [0x30,0x6a,0x72,0x1e]
|
|
// CHECK: fminnm d19, d20, d21 // encoding: [0x93,0x7a,0x75,0x1e]
|
|
// CHECK: fnmul d22, d23, d24 // encoding: [0xf6,0x8a,0x78,0x1e]
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Floating-point data-processing (3 sources)
|
|
//------------------------------------------------------------------------------
|
|
|
|
fmadd s3, s5, s6, s31
|
|
fmadd d3, d13, d0, d23
|
|
fmsub s3, s5, s6, s31
|
|
fmsub d3, d13, d0, d23
|
|
fnmadd s3, s5, s6, s31
|
|
fnmadd d3, d13, d0, d23
|
|
fnmsub s3, s5, s6, s31
|
|
fnmsub d3, d13, d0, d23
|
|
// CHECK: fmadd s3, s5, s6, s31 // encoding: [0xa3,0x7c,0x06,0x1f]
|
|
// CHECK: fmadd d3, d13, d0, d23 // encoding: [0xa3,0x5d,0x40,0x1f]
|
|
// CHECK: fmsub s3, s5, s6, s31 // encoding: [0xa3,0xfc,0x06,0x1f]
|
|
// CHECK: fmsub d3, d13, d0, d23 // encoding: [0xa3,0xdd,0x40,0x1f]
|
|
// CHECK: fnmadd s3, s5, s6, s31 // encoding: [0xa3,0x7c,0x26,0x1f]
|
|
// CHECK: fnmadd d3, d13, d0, d23 // encoding: [0xa3,0x5d,0x60,0x1f]
|
|
// CHECK: fnmsub s3, s5, s6, s31 // encoding: [0xa3,0xfc,0x26,0x1f]
|
|
// CHECK: fnmsub d3, d13, d0, d23 // encoding: [0xa3,0xdd,0x60,0x1f]
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Floating-point <-> fixed-point conversion
|
|
//------------------------------------------------------------------------------
|
|
|
|
fcvtzs w3, s5, #1
|
|
fcvtzs wzr, s20, #13
|
|
fcvtzs w19, s0, #32
|
|
// CHECK: fcvtzs w3, s5, #1 // encoding: [0xa3,0xfc,0x18,0x1e]
|
|
// CHECK: fcvtzs wzr, s20, #13 // encoding: [0x9f,0xce,0x18,0x1e]
|
|
// CHECK: fcvtzs w19, s0, #32 // encoding: [0x13,0x80,0x18,0x1e]
|
|
|
|
fcvtzs x3, s5, #1
|
|
fcvtzs x12, s30, #45
|
|
fcvtzs x19, s0, #64
|
|
// CHECK: fcvtzs x3, s5, #1 // encoding: [0xa3,0xfc,0x18,0x9e]
|
|
// CHECK: fcvtzs x12, s30, #45 // encoding: [0xcc,0x4f,0x18,0x9e]
|
|
// CHECK: fcvtzs x19, s0, #64 // encoding: [0x13,0x00,0x18,0x9e]
|
|
|
|
fcvtzs w3, d5, #1
|
|
fcvtzs wzr, d20, #13
|
|
fcvtzs w19, d0, #32
|
|
// CHECK: fcvtzs w3, d5, #1 // encoding: [0xa3,0xfc,0x58,0x1e]
|
|
// CHECK: fcvtzs wzr, d20, #13 // encoding: [0x9f,0xce,0x58,0x1e]
|
|
// CHECK: fcvtzs w19, d0, #32 // encoding: [0x13,0x80,0x58,0x1e]
|
|
|
|
fcvtzs x3, d5, #1
|
|
fcvtzs x12, d30, #45
|
|
fcvtzs x19, d0, #64
|
|
// CHECK: fcvtzs x3, d5, #1 // encoding: [0xa3,0xfc,0x58,0x9e]
|
|
// CHECK: fcvtzs x12, d30, #45 // encoding: [0xcc,0x4f,0x58,0x9e]
|
|
// CHECK: fcvtzs x19, d0, #64 // encoding: [0x13,0x00,0x58,0x9e]
|
|
|
|
fcvtzu w3, s5, #1
|
|
fcvtzu wzr, s20, #13
|
|
fcvtzu w19, s0, #32
|
|
// CHECK: fcvtzu w3, s5, #1 // encoding: [0xa3,0xfc,0x19,0x1e]
|
|
// CHECK: fcvtzu wzr, s20, #13 // encoding: [0x9f,0xce,0x19,0x1e]
|
|
// CHECK: fcvtzu w19, s0, #32 // encoding: [0x13,0x80,0x19,0x1e]
|
|
|
|
fcvtzu x3, s5, #1
|
|
fcvtzu x12, s30, #45
|
|
fcvtzu x19, s0, #64
|
|
// CHECK: fcvtzu x3, s5, #1 // encoding: [0xa3,0xfc,0x19,0x9e]
|
|
// CHECK: fcvtzu x12, s30, #45 // encoding: [0xcc,0x4f,0x19,0x9e]
|
|
// CHECK: fcvtzu x19, s0, #64 // encoding: [0x13,0x00,0x19,0x9e]
|
|
|
|
fcvtzu w3, d5, #1
|
|
fcvtzu wzr, d20, #13
|
|
fcvtzu w19, d0, #32
|
|
// CHECK: fcvtzu w3, d5, #1 // encoding: [0xa3,0xfc,0x59,0x1e]
|
|
// CHECK: fcvtzu wzr, d20, #13 // encoding: [0x9f,0xce,0x59,0x1e]
|
|
// CHECK: fcvtzu w19, d0, #32 // encoding: [0x13,0x80,0x59,0x1e]
|
|
|
|
fcvtzu x3, d5, #1
|
|
fcvtzu x12, d30, #45
|
|
fcvtzu x19, d0, #64
|
|
// CHECK: fcvtzu x3, d5, #1 // encoding: [0xa3,0xfc,0x59,0x9e]
|
|
// CHECK: fcvtzu x12, d30, #45 // encoding: [0xcc,0x4f,0x59,0x9e]
|
|
// CHECK: fcvtzu x19, d0, #64 // encoding: [0x13,0x00,0x59,0x9e]
|
|
|
|
scvtf s23, w19, #1
|
|
scvtf s31, wzr, #20
|
|
scvtf s14, w0, #32
|
|
// CHECK: scvtf s23, w19, #1 // encoding: [0x77,0xfe,0x02,0x1e]
|
|
// CHECK: scvtf s31, wzr, #20 // encoding: [0xff,0xb3,0x02,0x1e]
|
|
// CHECK: scvtf s14, w0, #32 // encoding: [0x0e,0x80,0x02,0x1e]
|
|
|
|
scvtf s23, x19, #1
|
|
scvtf s31, xzr, #20
|
|
scvtf s14, x0, #64
|
|
// CHECK: scvtf s23, x19, #1 // encoding: [0x77,0xfe,0x02,0x9e]
|
|
// CHECK: scvtf s31, xzr, #20 // encoding: [0xff,0xb3,0x02,0x9e]
|
|
// CHECK: scvtf s14, x0, #64 // encoding: [0x0e,0x00,0x02,0x9e]
|
|
|
|
scvtf d23, w19, #1
|
|
scvtf d31, wzr, #20
|
|
scvtf d14, w0, #32
|
|
// CHECK: scvtf d23, w19, #1 // encoding: [0x77,0xfe,0x42,0x1e]
|
|
// CHECK: scvtf d31, wzr, #20 // encoding: [0xff,0xb3,0x42,0x1e]
|
|
// CHECK: scvtf d14, w0, #32 // encoding: [0x0e,0x80,0x42,0x1e]
|
|
|
|
scvtf d23, x19, #1
|
|
scvtf d31, xzr, #20
|
|
scvtf d14, x0, #64
|
|
// CHECK: scvtf d23, x19, #1 // encoding: [0x77,0xfe,0x42,0x9e]
|
|
// CHECK: scvtf d31, xzr, #20 // encoding: [0xff,0xb3,0x42,0x9e]
|
|
// CHECK: scvtf d14, x0, #64 // encoding: [0x0e,0x00,0x42,0x9e]
|
|
|
|
ucvtf s23, w19, #1
|
|
ucvtf s31, wzr, #20
|
|
ucvtf s14, w0, #32
|
|
// CHECK: ucvtf s23, w19, #1 // encoding: [0x77,0xfe,0x03,0x1e]
|
|
// CHECK: ucvtf s31, wzr, #20 // encoding: [0xff,0xb3,0x03,0x1e]
|
|
// CHECK: ucvtf s14, w0, #32 // encoding: [0x0e,0x80,0x03,0x1e]
|
|
|
|
ucvtf s23, x19, #1
|
|
ucvtf s31, xzr, #20
|
|
ucvtf s14, x0, #64
|
|
// CHECK: ucvtf s23, x19, #1 // encoding: [0x77,0xfe,0x03,0x9e]
|
|
// CHECK: ucvtf s31, xzr, #20 // encoding: [0xff,0xb3,0x03,0x9e]
|
|
// CHECK: ucvtf s14, x0, #64 // encoding: [0x0e,0x00,0x03,0x9e]
|
|
|
|
ucvtf d23, w19, #1
|
|
ucvtf d31, wzr, #20
|
|
ucvtf d14, w0, #32
|
|
// CHECK: ucvtf d23, w19, #1 // encoding: [0x77,0xfe,0x43,0x1e]
|
|
// CHECK: ucvtf d31, wzr, #20 // encoding: [0xff,0xb3,0x43,0x1e]
|
|
// CHECK: ucvtf d14, w0, #32 // encoding: [0x0e,0x80,0x43,0x1e]
|
|
|
|
ucvtf d23, x19, #1
|
|
ucvtf d31, xzr, #20
|
|
ucvtf d14, x0, #64
|
|
// CHECK: ucvtf d23, x19, #1 // encoding: [0x77,0xfe,0x43,0x9e]
|
|
// CHECK: ucvtf d31, xzr, #20 // encoding: [0xff,0xb3,0x43,0x9e]
|
|
// CHECK: ucvtf d14, x0, #64 // encoding: [0x0e,0x00,0x43,0x9e]
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Floating-point <-> integer conversion
|
|
//------------------------------------------------------------------------------
|
|
fcvtns w3, s31
|
|
fcvtns xzr, s12
|
|
fcvtnu wzr, s12
|
|
fcvtnu x0, s0
|
|
// CHECK: fcvtns w3, s31 // encoding: [0xe3,0x03,0x20,0x1e]
|
|
// CHECK: fcvtns xzr, s12 // encoding: [0x9f,0x01,0x20,0x9e]
|
|
// CHECK: fcvtnu wzr, s12 // encoding: [0x9f,0x01,0x21,0x1e]
|
|
// CHECK: fcvtnu x0, s0 // encoding: [0x00,0x00,0x21,0x9e]
|
|
|
|
fcvtps wzr, s9
|
|
fcvtps x12, s20
|
|
fcvtpu w30, s23
|
|
fcvtpu x29, s3
|
|
// CHECK: fcvtps wzr, s9 // encoding: [0x3f,0x01,0x28,0x1e]
|
|
// CHECK: fcvtps x12, s20 // encoding: [0x8c,0x02,0x28,0x9e]
|
|
// CHECK: fcvtpu w30, s23 // encoding: [0xfe,0x02,0x29,0x1e]
|
|
// CHECK: fcvtpu x29, s3 // encoding: [0x7d,0x00,0x29,0x9e]
|
|
|
|
fcvtms w2, s3
|
|
fcvtms x4, s5
|
|
fcvtmu w6, s7
|
|
fcvtmu x8, s9
|
|
// CHECK: fcvtms w2, s3 // encoding: [0x62,0x00,0x30,0x1e]
|
|
// CHECK: fcvtms x4, s5 // encoding: [0xa4,0x00,0x30,0x9e]
|
|
// CHECK: fcvtmu w6, s7 // encoding: [0xe6,0x00,0x31,0x1e]
|
|
// CHECK: fcvtmu x8, s9 // encoding: [0x28,0x01,0x31,0x9e]
|
|
|
|
fcvtzs w10, s11
|
|
fcvtzs x12, s13
|
|
fcvtzu w14, s15
|
|
fcvtzu x15, s16
|
|
// CHECK: fcvtzs w10, s11 // encoding: [0x6a,0x01,0x38,0x1e]
|
|
// CHECK: fcvtzs x12, s13 // encoding: [0xac,0x01,0x38,0x9e]
|
|
// CHECK: fcvtzu w14, s15 // encoding: [0xee,0x01,0x39,0x1e]
|
|
// CHECK: fcvtzu x15, s16 // encoding: [0x0f,0x02,0x39,0x9e]
|
|
|
|
scvtf s17, w18
|
|
scvtf s19, x20
|
|
ucvtf s21, w22
|
|
scvtf s23, x24
|
|
// CHECK: scvtf s17, w18 // encoding: [0x51,0x02,0x22,0x1e]
|
|
// CHECK: scvtf s19, x20 // encoding: [0x93,0x02,0x22,0x9e]
|
|
// CHECK: ucvtf s21, w22 // encoding: [0xd5,0x02,0x23,0x1e]
|
|
// CHECK: scvtf s23, x24 // encoding: [0x17,0x03,0x22,0x9e]
|
|
|
|
fcvtas w25, s26
|
|
fcvtas x27, s28
|
|
fcvtau w29, s30
|
|
fcvtau xzr, s0
|
|
// CHECK: fcvtas w25, s26 // encoding: [0x59,0x03,0x24,0x1e]
|
|
// CHECK: fcvtas x27, s28 // encoding: [0x9b,0x03,0x24,0x9e]
|
|
// CHECK: fcvtau w29, s30 // encoding: [0xdd,0x03,0x25,0x1e]
|
|
// CHECK: fcvtau xzr, s0 // encoding: [0x1f,0x00,0x25,0x9e]
|
|
|
|
fcvtns w3, d31
|
|
fcvtns xzr, d12
|
|
fcvtnu wzr, d12
|
|
fcvtnu x0, d0
|
|
// CHECK: fcvtns w3, d31 // encoding: [0xe3,0x03,0x60,0x1e]
|
|
// CHECK: fcvtns xzr, d12 // encoding: [0x9f,0x01,0x60,0x9e]
|
|
// CHECK: fcvtnu wzr, d12 // encoding: [0x9f,0x01,0x61,0x1e]
|
|
// CHECK: fcvtnu x0, d0 // encoding: [0x00,0x00,0x61,0x9e]
|
|
|
|
fcvtps wzr, d9
|
|
fcvtps x12, d20
|
|
fcvtpu w30, d23
|
|
fcvtpu x29, d3
|
|
// CHECK: fcvtps wzr, d9 // encoding: [0x3f,0x01,0x68,0x1e]
|
|
// CHECK: fcvtps x12, d20 // encoding: [0x8c,0x02,0x68,0x9e]
|
|
// CHECK: fcvtpu w30, d23 // encoding: [0xfe,0x02,0x69,0x1e]
|
|
// CHECK: fcvtpu x29, d3 // encoding: [0x7d,0x00,0x69,0x9e]
|
|
|
|
fcvtms w2, d3
|
|
fcvtms x4, d5
|
|
fcvtmu w6, d7
|
|
fcvtmu x8, d9
|
|
// CHECK: fcvtms w2, d3 // encoding: [0x62,0x00,0x70,0x1e]
|
|
// CHECK: fcvtms x4, d5 // encoding: [0xa4,0x00,0x70,0x9e]
|
|
// CHECK: fcvtmu w6, d7 // encoding: [0xe6,0x00,0x71,0x1e]
|
|
// CHECK: fcvtmu x8, d9 // encoding: [0x28,0x01,0x71,0x9e]
|
|
|
|
fcvtzs w10, d11
|
|
fcvtzs x12, d13
|
|
fcvtzu w14, d15
|
|
fcvtzu x15, d16
|
|
// CHECK: fcvtzs w10, d11 // encoding: [0x6a,0x01,0x78,0x1e]
|
|
// CHECK: fcvtzs x12, d13 // encoding: [0xac,0x01,0x78,0x9e]
|
|
// CHECK: fcvtzu w14, d15 // encoding: [0xee,0x01,0x79,0x1e]
|
|
// CHECK: fcvtzu x15, d16 // encoding: [0x0f,0x02,0x79,0x9e]
|
|
|
|
scvtf d17, w18
|
|
scvtf d19, x20
|
|
ucvtf d21, w22
|
|
ucvtf d23, x24
|
|
// CHECK: scvtf d17, w18 // encoding: [0x51,0x02,0x62,0x1e]
|
|
// CHECK: scvtf d19, x20 // encoding: [0x93,0x02,0x62,0x9e]
|
|
// CHECK: ucvtf d21, w22 // encoding: [0xd5,0x02,0x63,0x1e]
|
|
// CHECK: ucvtf d23, x24 // encoding: [0x17,0x03,0x63,0x9e]
|
|
|
|
fcvtas w25, d26
|
|
fcvtas x27, d28
|
|
fcvtau w29, d30
|
|
fcvtau xzr, d0
|
|
// CHECK: fcvtas w25, d26 // encoding: [0x59,0x03,0x64,0x1e]
|
|
// CHECK: fcvtas x27, d28 // encoding: [0x9b,0x03,0x64,0x9e]
|
|
// CHECK: fcvtau w29, d30 // encoding: [0xdd,0x03,0x65,0x1e]
|
|
// CHECK: fcvtau xzr, d0 // encoding: [0x1f,0x00,0x65,0x9e]
|
|
|
|
fmov w3, s9
|
|
fmov s9, w3
|
|
// CHECK: fmov w3, s9 // encoding: [0x23,0x01,0x26,0x1e]
|
|
// CHECK: fmov s9, w3 // encoding: [0x69,0x00,0x27,0x1e]
|
|
|
|
fmov x20, d31
|
|
fmov d1, x15
|
|
// CHECK: fmov x20, d31 // encoding: [0xf4,0x03,0x66,0x9e]
|
|
// CHECK: fmov d1, x15 // encoding: [0xe1,0x01,0x67,0x9e]
|
|
|
|
fmov x3, v12.d[1]
|
|
fmov v1.d[1], x19
|
|
fmov v3.2d[1], xzr
|
|
// CHECK: fmov x3, v12.d[1] // encoding: [0x83,0x01,0xae,0x9e]
|
|
// CHECK: fmov v1.d[1], x19 // encoding: [0x61,0x02,0xaf,0x9e]
|
|
// CHECK: fmov v3.d[1], xzr // encoding: [0xe3,0x03,0xaf,0x9e]
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Floating-point immediate
|
|
//------------------------------------------------------------------------------
|
|
|
|
fmov s2, #0.125
|
|
fmov s3, #1.0
|
|
fmov d30, #16.0
|
|
// CHECK: fmov s2, #0.12500000 // encoding: [0x02,0x10,0x28,0x1e]
|
|
// CHECK: fmov s3, #1.00000000 // encoding: [0x03,0x10,0x2e,0x1e]
|
|
// CHECK: fmov d30, #16.00000000 // encoding: [0x1e,0x10,0x66,0x1e]
|
|
|
|
fmov s4, #1.0625
|
|
fmov d10, #1.9375
|
|
// CHECK: fmov s4, #1.06250000 // encoding: [0x04,0x30,0x2e,0x1e]
|
|
// CHECK: fmov d10, #1.93750000 // encoding: [0x0a,0xf0,0x6f,0x1e]
|
|
|
|
fmov s12, #-1.0
|
|
// CHECK: fmov s12, #-1.00000000 // encoding: [0x0c,0x10,0x3e,0x1e]
|
|
|
|
fmov d16, #8.5
|
|
// CHECK: fmov d16, #8.50000000 // encoding: [0x10,0x30,0x64,0x1e]
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Load-register (literal)
|
|
//------------------------------------------------------------------------------
|
|
ldr w3, here
|
|
ldr x29, there
|
|
ldrsw xzr, everywhere
|
|
// CHECK: ldr w3, here // encoding: [0x03'A',A,A,0x18'A']
|
|
// CHECK: // fixup A - offset: 0, value: here, kind: fixup_a64_ld_prel
|
|
// CHECK: ldr x29, there // encoding: [0x1d'A',A,A,0x58'A']
|
|
// CHECK: // fixup A - offset: 0, value: there, kind: fixup_a64_ld_prel
|
|
// CHECK: ldrsw xzr, everywhere // encoding: [0x1f'A',A,A,0x98'A']
|
|
// CHECK: // fixup A - offset: 0, value: everywhere, kind: fixup_a64_ld_prel
|
|
|
|
ldr s0, who_knows
|
|
ldr d0, i_dont
|
|
ldr q0, there_must_be_a_better_way
|
|
// CHECK: ldr s0, who_knows // encoding: [A,A,A,0x1c'A']
|
|
// CHECK: // fixup A - offset: 0, value: who_knows, kind: fixup_a64_ld_prel
|
|
// CHECK: ldr d0, i_dont // encoding: [A,A,A,0x5c'A']
|
|
// CHECK: // fixup A - offset: 0, value: i_dont, kind: fixup_a64_ld_prel
|
|
// CHECK: ldr q0, there_must_be_a_better_way // encoding: [A,A,A,0x9c'A']
|
|
// CHECK: // fixup A - offset: 0, value: there_must_be_a_better_way, kind: fixup_a64_ld_prel
|
|
|
|
ldr w0, #1048572
|
|
ldr x10, #-1048576
|
|
// CHECK: ldr w0, #1048572 // encoding: [0xe0,0xff,0x7f,0x18]
|
|
// CHECK: ldr x10, #-1048576 // encoding: [0x0a,0x00,0x80,0x58]
|
|
|
|
prfm pldl1strm, nowhere
|
|
prfm #22, somewhere
|
|
// CHECK: prfm pldl1strm, nowhere // encoding: [0x01'A',A,A,0xd8'A']
|
|
// CHECK: // fixup A - offset: 0, value: nowhere, kind: fixup_a64_ld_prel
|
|
// CHECK: prfm #22, somewhere // encoding: [0x16'A',A,A,0xd8'A']
|
|
// CHECK: // fixup A - offset: 0, value: somewhere, kind: fixup_a64_ld_prel
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Floating-point immediate
|
|
//------------------------------------------------------------------------------
|
|
|
|
fmov s2, #0.125
|
|
fmov s3, #1.0
|
|
fmov d30, #16.0
|
|
// CHECK: fmov s2, #0.12500000 // encoding: [0x02,0x10,0x28,0x1e]
|
|
// CHECK: fmov s3, #1.00000000 // encoding: [0x03,0x10,0x2e,0x1e]
|
|
// CHECK: fmov d30, #16.00000000 // encoding: [0x1e,0x10,0x66,0x1e]
|
|
|
|
fmov s4, #1.0625
|
|
fmov d10, #1.9375
|
|
// CHECK: fmov s4, #1.06250000 // encoding: [0x04,0x30,0x2e,0x1e]
|
|
// CHECK: fmov d10, #1.93750000 // encoding: [0x0a,0xf0,0x6f,0x1e]
|
|
|
|
fmov s12, #-1.0
|
|
// CHECK: fmov s12, #-1.00000000 // encoding: [0x0c,0x10,0x3e,0x1e]
|
|
|
|
fmov d16, #8.5
|
|
// CHECK: fmov d16, #8.50000000 // encoding: [0x10,0x30,0x64,0x1e]
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Load/store exclusive
|
|
//------------------------------------------------------------------------------
|
|
|
|
stxrb w1, w2, [x3, #0]
|
|
stxrh w2, w3, [x4]
|
|
stxr wzr, w4, [sp]
|
|
stxr w5, x6, [x7]
|
|
// CHECK: stxrb w1, w2, [x3] // encoding: [0x62,0x7c,0x01,0x08]
|
|
// CHECK: stxrh w2, w3, [x4] // encoding: [0x83,0x7c,0x02,0x48]
|
|
// CHECK: stxr wzr, w4, [sp] // encoding: [0xe4,0x7f,0x1f,0x88]
|
|
// CHECK: stxr w5, x6, [x7] // encoding: [0xe6,0x7c,0x05,0xc8]
|
|
|
|
ldxrb w7, [x9]
|
|
ldxrh wzr, [x10]
|
|
ldxr w9, [sp]
|
|
ldxr x10, [x11]
|
|
// CHECK: ldxrb w7, [x9] // encoding: [0x27,0x7d,0x5f,0x08]
|
|
// CHECK: ldxrh wzr, [x10] // encoding: [0x5f,0x7d,0x5f,0x48]
|
|
// CHECK: ldxr w9, [sp] // encoding: [0xe9,0x7f,0x5f,0x88]
|
|
// CHECK: ldxr x10, [x11] // encoding: [0x6a,0x7d,0x5f,0xc8]
|
|
|
|
stxp w11, w12, w13, [x14]
|
|
stxp wzr, x23, x14, [x15]
|
|
// CHECK: stxp w11, w12, w13, [x14] // encoding: [0xcc,0x35,0x2b,0x88]
|
|
// CHECK: stxp wzr, x23, x14, [x15] // encoding: [0xf7,0x39,0x3f,0xc8]
|
|
|
|
ldxp w12, wzr, [sp]
|
|
ldxp x13, x14, [x15]
|
|
// CHECK: ldxp w12, wzr, [sp] // encoding: [0xec,0x7f,0x7f,0x88]
|
|
// CHECK: ldxp x13, x14, [x15] // encoding: [0xed,0x39,0x7f,0xc8]
|
|
|
|
stlxrb w14, w15, [x16]
|
|
stlxrh w15, w16, [x17,#0]
|
|
stlxr wzr, w17, [sp]
|
|
stlxr w18, x19, [x20]
|
|
// CHECK: stlxrb w14, w15, [x16] // encoding: [0x0f,0xfe,0x0e,0x08]
|
|
// CHECK: stlxrh w15, w16, [x17] // encoding: [0x30,0xfe,0x0f,0x48]
|
|
// CHECK: stlxr wzr, w17, [sp] // encoding: [0xf1,0xff,0x1f,0x88]
|
|
// CHECK: stlxr w18, x19, [x20] // encoding: [0x93,0xfe,0x12,0xc8]
|
|
|
|
ldaxrb w19, [x21]
|
|
ldaxrh w20, [sp]
|
|
ldaxr wzr, [x22]
|
|
ldaxr x21, [x23]
|
|
// CHECK: ldaxrb w19, [x21] // encoding: [0xb3,0xfe,0x5f,0x08]
|
|
// CHECK: ldaxrh w20, [sp] // encoding: [0xf4,0xff,0x5f,0x48]
|
|
// CHECK: ldaxr wzr, [x22] // encoding: [0xdf,0xfe,0x5f,0x88]
|
|
// CHECK: ldaxr x21, [x23] // encoding: [0xf5,0xfe,0x5f,0xc8]
|
|
|
|
stlxp wzr, w22, w23, [x24]
|
|
stlxp w25, x26, x27, [sp]
|
|
// CHECK: stlxp wzr, w22, w23, [x24] // encoding: [0x16,0xdf,0x3f,0x88]
|
|
// CHECK: stlxp w25, x26, x27, [sp] // encoding: [0xfa,0xef,0x39,0xc8]
|
|
|
|
ldaxp w26, wzr, [sp]
|
|
ldaxp x27, x28, [x30]
|
|
// CHECK: ldaxp w26, wzr, [sp] // encoding: [0xfa,0xff,0x7f,0x88]
|
|
// CHECK: ldaxp x27, x28, [x30] // encoding: [0xdb,0xf3,0x7f,0xc8]
|
|
|
|
stlrb w27, [sp]
|
|
stlrh w28, [x0]
|
|
stlr wzr, [x1]
|
|
stlr x30, [x2]
|
|
// CHECK: stlrb w27, [sp] // encoding: [0xfb,0xff,0x9f,0x08]
|
|
// CHECK: stlrh w28, [x0] // encoding: [0x1c,0xfc,0x9f,0x48]
|
|
// CHECK: stlr wzr, [x1] // encoding: [0x3f,0xfc,0x9f,0x88]
|
|
// CHECK: stlr x30, [x2] // encoding: [0x5e,0xfc,0x9f,0xc8]
|
|
|
|
ldarb w29, [sp]
|
|
ldarh w30, [x0]
|
|
ldar wzr, [x1]
|
|
ldar x1, [x2]
|
|
// CHECK: ldarb w29, [sp] // encoding: [0xfd,0xff,0xdf,0x08]
|
|
// CHECK: ldarh w30, [x0] // encoding: [0x1e,0xfc,0xdf,0x48]
|
|
// CHECK: ldar wzr, [x1] // encoding: [0x3f,0xfc,0xdf,0x88]
|
|
// CHECK: ldar x1, [x2] // encoding: [0x41,0xfc,0xdf,0xc8]
|
|
|
|
stlxp wzr, w22, w23, [x24,#0]
|
|
// CHECK: stlxp wzr, w22, w23, [x24] // encoding: [0x16,0xdf,0x3f,0x88]
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Load/store (unaligned immediate)
|
|
//------------------------------------------------------------------------------
|
|
|
|
sturb w9, [sp, #0]
|
|
sturh wzr, [x12, #255]
|
|
stur w16, [x0, #-256]
|
|
stur x28, [x14, #1]
|
|
// CHECK: sturb w9, [sp] // encoding: [0xe9,0x03,0x00,0x38]
|
|
// CHECK: sturh wzr, [x12, #255] // encoding: [0x9f,0xf1,0x0f,0x78]
|
|
// CHECK: stur w16, [x0, #-256] // encoding: [0x10,0x00,0x10,0xb8]
|
|
// CHECK: stur x28, [x14, #1] // encoding: [0xdc,0x11,0x00,0xf8]
|
|
|
|
ldurb w1, [x20, #255]
|
|
ldurh w20, [x1, #255]
|
|
ldur w12, [sp, #255]
|
|
ldur xzr, [x12, #255]
|
|
// CHECK: ldurb w1, [x20, #255] // encoding: [0x81,0xf2,0x4f,0x38]
|
|
// CHECK: ldurh w20, [x1, #255] // encoding: [0x34,0xf0,0x4f,0x78]
|
|
// CHECK: ldur w12, [sp, #255] // encoding: [0xec,0xf3,0x4f,0xb8]
|
|
// CHECK: ldur xzr, [x12, #255] // encoding: [0x9f,0xf1,0x4f,0xf8]
|
|
|
|
ldursb x9, [x7, #-256]
|
|
ldursh x17, [x19, #-256]
|
|
ldursw x20, [x15, #-256]
|
|
ldursw x13, [x2]
|
|
prfum pldl2keep, [sp, #-256]
|
|
ldursb w19, [x1, #-256]
|
|
ldursh w15, [x21, #-256]
|
|
// CHECK: ldursb x9, [x7, #-256] // encoding: [0xe9,0x00,0x90,0x38]
|
|
// CHECK: ldursh x17, [x19, #-256] // encoding: [0x71,0x02,0x90,0x78]
|
|
// CHECK: ldursw x20, [x15, #-256] // encoding: [0xf4,0x01,0x90,0xb8]
|
|
// CHECK: ldursw x13, [x2] // encoding: [0x4d,0x00,0x80,0xb8]
|
|
// CHECK: prfum pldl2keep, [sp, #-256] // encoding: [0xe2,0x03,0x90,0xf8]
|
|
// CHECK: ldursb w19, [x1, #-256] // encoding: [0x33,0x00,0xd0,0x38]
|
|
// CHECK: ldursh w15, [x21, #-256] // encoding: [0xaf,0x02,0xd0,0x78]
|
|
|
|
stur b0, [sp, #1]
|
|
stur h12, [x12, #-1]
|
|
stur s15, [x0, #255]
|
|
stur d31, [x5, #25]
|
|
stur q9, [x5]
|
|
// CHECK: stur b0, [sp, #1] // encoding: [0xe0,0x13,0x00,0x3c]
|
|
// CHECK: stur h12, [x12, #-1] // encoding: [0x8c,0xf1,0x1f,0x7c]
|
|
// CHECK: stur s15, [x0, #255] // encoding: [0x0f,0xf0,0x0f,0xbc]
|
|
// CHECK: stur d31, [x5, #25] // encoding: [0xbf,0x90,0x01,0xfc]
|
|
// CHECK: stur q9, [x5] // encoding: [0xa9,0x00,0x80,0x3c]
|
|
|
|
ldur b3, [sp]
|
|
ldur h5, [x4, #-256]
|
|
ldur s7, [x12, #-1]
|
|
ldur d11, [x19, #4]
|
|
ldur q13, [x1, #2]
|
|
// CHECK: ldur b3, [sp] // encoding: [0xe3,0x03,0x40,0x3c]
|
|
// CHECK: ldur h5, [x4, #-256] // encoding: [0x85,0x00,0x50,0x7c]
|
|
// CHECK: ldur s7, [x12, #-1] // encoding: [0x87,0xf1,0x5f,0xbc]
|
|
// CHECK: ldur d11, [x19, #4] // encoding: [0x6b,0x42,0x40,0xfc]
|
|
// CHECK: ldur q13, [x1, #2] // encoding: [0x2d,0x20,0xc0,0x3c]
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Load/store (unsigned immediate)
|
|
//------------------------------------------------------------------------------
|
|
|
|
//// Basic addressing mode limits: 8 byte access
|
|
ldr x0, [x0]
|
|
ldr x4, [x29, #0]
|
|
ldr x30, [x12, #32760]
|
|
ldr x20, [sp, #8]
|
|
// CHECK: ldr x0, [x0] // encoding: [0x00,0x00,0x40,0xf9]
|
|
// CHECK: ldr x4, [x29] // encoding: [0xa4,0x03,0x40,0xf9]
|
|
// CHECK: ldr x30, [x12, #32760] // encoding: [0x9e,0xfd,0x7f,0xf9]
|
|
// CHECK: ldr x20, [sp, #8] // encoding: [0xf4,0x07,0x40,0xf9]
|
|
|
|
//// Rt treats 31 as zero-register
|
|
ldr xzr, [sp]
|
|
// CHECK: ldr xzr, [sp] // encoding: [0xff,0x03,0x40,0xf9]
|
|
|
|
//// 4-byte load, check still 64-bit address, limits
|
|
ldr w2, [sp]
|
|
ldr w17, [sp, #16380]
|
|
ldr w13, [x2, #4]
|
|
// CHECK: ldr w2, [sp] // encoding: [0xe2,0x03,0x40,0xb9]
|
|
// CHECK: ldr w17, [sp, #16380] // encoding: [0xf1,0xff,0x7f,0xb9]
|
|
// CHECK: ldr w13, [x2, #4] // encoding: [0x4d,0x04,0x40,0xb9]
|
|
|
|
//// Signed 4-byte load. Limits.
|
|
ldrsw x2, [x5,#4]
|
|
ldrsw x23, [sp, #16380]
|
|
// CHECK: ldrsw x2, [x5, #4] // encoding: [0xa2,0x04,0x80,0xb9]
|
|
// CHECK: ldrsw x23, [sp, #16380] // encoding: [0xf7,0xff,0xbf,0xb9]
|
|
|
|
//// 2-byte loads
|
|
ldrh w2, [x4]
|
|
ldrsh w23, [x6, #8190]
|
|
ldrsh wzr, [sp, #2]
|
|
ldrsh x29, [x2, #2]
|
|
// CHECK: ldrh w2, [x4] // encoding: [0x82,0x00,0x40,0x79]
|
|
// CHECK: ldrsh w23, [x6, #8190] // encoding: [0xd7,0xfc,0xff,0x79]
|
|
// CHECK: ldrsh wzr, [sp, #2] // encoding: [0xff,0x07,0xc0,0x79]
|
|
// CHECK: ldrsh x29, [x2, #2] // encoding: [0x5d,0x04,0x80,0x79]
|
|
|
|
//// 1-byte loads
|
|
ldrb w26, [x3, #121]
|
|
ldrb w12, [x2, #0]
|
|
ldrsb w27, [sp, #4095]
|
|
ldrsb xzr, [x15]
|
|
// CHECK: ldrb w26, [x3, #121] // encoding: [0x7a,0xe4,0x41,0x39]
|
|
// CHECK: ldrb w12, [x2] // encoding: [0x4c,0x00,0x40,0x39]
|
|
// CHECK: ldrsb w27, [sp, #4095] // encoding: [0xfb,0xff,0xff,0x39]
|
|
// CHECK: ldrsb xzr, [x15] // encoding: [0xff,0x01,0x80,0x39]
|
|
|
|
//// Stores
|
|
str x30, [sp]
|
|
str w20, [x4, #16380]
|
|
strh w20, [x10, #14]
|
|
strh w17, [sp, #8190]
|
|
strb w23, [x3, #4095]
|
|
strb wzr, [x2]
|
|
// CHECK: str x30, [sp] // encoding: [0xfe,0x03,0x00,0xf9]
|
|
// CHECK: str w20, [x4, #16380] // encoding: [0x94,0xfc,0x3f,0xb9]
|
|
// CHECK: strh w20, [x10, #14] // encoding: [0x54,0x1d,0x00,0x79]
|
|
// CHECK: strh w17, [sp, #8190] // encoding: [0xf1,0xff,0x3f,0x79]
|
|
// CHECK: strb w23, [x3, #4095] // encoding: [0x77,0xfc,0x3f,0x39]
|
|
// CHECK: strb wzr, [x2] // encoding: [0x5f,0x00,0x00,0x39]
|
|
|
|
//// Relocations
|
|
str x15, [x5, #:lo12:sym]
|
|
ldrb w15, [x5, #:lo12:sym]
|
|
ldrsh x15, [x5, #:lo12:sym]
|
|
ldrsw x15, [x5, #:lo12:sym]
|
|
ldr x15, [x5, #:lo12:sym]
|
|
ldr q3, [x2, #:lo12:sym]
|
|
// CHECK: str x15, [x5, #:lo12:sym] // encoding: [0xaf'A',A,A,0xf9'A']
|
|
// CHECK: // fixup A - offset: 0, value: :lo12:sym, kind: fixup_a64_ldst64_lo12
|
|
// CHECK: ldrb w15, [x5, #:lo12:sym] // encoding: [0xaf'A',A,0x40'A',0x39'A']
|
|
// CHECK: // fixup A - offset: 0, value: :lo12:sym, kind: fixup_a64_ldst8_lo12
|
|
// CHECK: ldrsh x15, [x5, #:lo12:sym] // encoding: [0xaf'A',A,0x80'A',0x79'A']
|
|
// CHECK: // fixup A - offset: 0, value: :lo12:sym, kind: fixup_a64_ldst16_lo12
|
|
// CHECK: ldrsw x15, [x5, #:lo12:sym] // encoding: [0xaf'A',A,0x80'A',0xb9'A']
|
|
// CHECK: // fixup A - offset: 0, value: :lo12:sym, kind: fixup_a64_ldst32_lo12
|
|
// CHECK: ldr x15, [x5, #:lo12:sym] // encoding: [0xaf'A',A,0x40'A',0xf9'A']
|
|
// CHECK: // fixup A - offset: 0, value: :lo12:sym, kind: fixup_a64_ldst64_lo12
|
|
// CHECK: ldr q3, [x2, #:lo12:sym] // encoding: [0x43'A',A,0xc0'A',0x3d'A']
|
|
// CHECK: // fixup A - offset: 0, value: :lo12:sym, kind: fixup_a64_ldst128_lo12
|
|
|
|
prfm pldl1keep, [sp, #8]
|
|
prfm pldl1strm, [x3]
|
|
prfm pldl2keep, [x5,#16]
|
|
prfm pldl2strm, [x2]
|
|
prfm pldl3keep, [x5]
|
|
prfm pldl3strm, [x6]
|
|
prfm plil1keep, [sp, #8]
|
|
prfm plil1strm, [x3]
|
|
prfm plil2keep, [x5,#16]
|
|
prfm plil2strm, [x2]
|
|
prfm plil3keep, [x5]
|
|
prfm plil3strm, [x6]
|
|
prfm pstl1keep, [sp, #8]
|
|
prfm pstl1strm, [x3]
|
|
prfm pstl2keep, [x5,#16]
|
|
prfm pstl2strm, [x2]
|
|
prfm pstl3keep, [x5]
|
|
prfm pstl3strm, [x6]
|
|
prfm #15, [sp]
|
|
// CHECK: prfm pldl1keep, [sp, #8] // encoding: [0xe0,0x07,0x80,0xf9]
|
|
// CHECK: prfm pldl1strm, [x3, #0] // encoding: [0x61,0x00,0x80,0xf9]
|
|
// CHECK: prfm pldl2keep, [x5, #16] // encoding: [0xa2,0x08,0x80,0xf9]
|
|
// CHECK: prfm pldl2strm, [x2, #0] // encoding: [0x43,0x00,0x80,0xf9]
|
|
// CHECK: prfm pldl3keep, [x5, #0] // encoding: [0xa4,0x00,0x80,0xf9]
|
|
// CHECK: prfm pldl3strm, [x6, #0] // encoding: [0xc5,0x00,0x80,0xf9]
|
|
// CHECK: prfm plil1keep, [sp, #8] // encoding: [0xe8,0x07,0x80,0xf9]
|
|
// CHECK: prfm plil1strm, [x3, #0] // encoding: [0x69,0x00,0x80,0xf9]
|
|
// CHECK: prfm plil2keep, [x5, #16] // encoding: [0xaa,0x08,0x80,0xf9]
|
|
// CHECK: prfm plil2strm, [x2, #0] // encoding: [0x4b,0x00,0x80,0xf9]
|
|
// CHECK: prfm plil3keep, [x5, #0] // encoding: [0xac,0x00,0x80,0xf9]
|
|
// CHECK: prfm plil3strm, [x6, #0] // encoding: [0xcd,0x00,0x80,0xf9]
|
|
// CHECK: prfm pstl1keep, [sp, #8] // encoding: [0xf0,0x07,0x80,0xf9]
|
|
// CHECK: prfm pstl1strm, [x3, #0] // encoding: [0x71,0x00,0x80,0xf9]
|
|
// CHECK: prfm pstl2keep, [x5, #16] // encoding: [0xb2,0x08,0x80,0xf9]
|
|
// CHECK: prfm pstl2strm, [x2, #0] // encoding: [0x53,0x00,0x80,0xf9]
|
|
// CHECK: prfm pstl3keep, [x5, #0] // encoding: [0xb4,0x00,0x80,0xf9]
|
|
// CHECK: prfm pstl3strm, [x6, #0] // encoding: [0xd5,0x00,0x80,0xf9]
|
|
// CHECK: prfm #15, [sp, #0] // encoding: [0xef,0x03,0x80,0xf9]
|
|
|
|
//// Floating-point versions
|
|
|
|
ldr b31, [sp, #4095]
|
|
ldr h20, [x2, #8190]
|
|
ldr s10, [x19, #16380]
|
|
ldr d3, [x10, #32760]
|
|
str q12, [sp, #65520]
|
|
// CHECK: ldr b31, [sp, #4095] // encoding: [0xff,0xff,0x7f,0x3d]
|
|
// CHECK: ldr h20, [x2, #8190] // encoding: [0x54,0xfc,0x7f,0x7d]
|
|
// CHECK: ldr s10, [x19, #16380] // encoding: [0x6a,0xfe,0x7f,0xbd]
|
|
// CHECK: ldr d3, [x10, #32760] // encoding: [0x43,0xfd,0x7f,0xfd]
|
|
// CHECK: str q12, [sp, #65520] // encoding: [0xec,0xff,0xbf,0x3d]
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Load/store register (register offset)
|
|
//------------------------------------------------------------------------------
|
|
|
|
ldrb w3, [sp, x5]
|
|
ldrb w9, [x27, x6, lsl #0]
|
|
ldrsb w10, [x30, x7]
|
|
ldrb w11, [x29, x3, sxtx]
|
|
strb w12, [x28, xzr, sxtx #0]
|
|
ldrb w14, [x26, w6, uxtw]
|
|
ldrsb w15, [x25, w7, uxtw #0]
|
|
ldrb w17, [x23, w9, sxtw]
|
|
ldrsb x18, [x22, w10, sxtw #0]
|
|
// CHECK: ldrb w3, [sp, x5] // encoding: [0xe3,0x6b,0x65,0x38]
|
|
// CHECK: ldrb w9, [x27, x6, lsl #0] // encoding: [0x69,0x7b,0x66,0x38]
|
|
// CHECK: ldrsb w10, [x30, x7] // encoding: [0xca,0x6b,0xe7,0x38]
|
|
// CHECK: ldrb w11, [x29, x3, sxtx] // encoding: [0xab,0xeb,0x63,0x38]
|
|
// CHECK: strb w12, [x28, xzr, sxtx #0] // encoding: [0x8c,0xfb,0x3f,0x38]
|
|
// CHECK: ldrb w14, [x26, w6, uxtw] // encoding: [0x4e,0x4b,0x66,0x38]
|
|
// CHECK: ldrsb w15, [x25, w7, uxtw #0] // encoding: [0x2f,0x5b,0xe7,0x38]
|
|
// CHECK: ldrb w17, [x23, w9, sxtw] // encoding: [0xf1,0xca,0x69,0x38]
|
|
// CHECK: ldrsb x18, [x22, w10, sxtw #0] // encoding: [0xd2,0xda,0xaa,0x38]
|
|
|
|
ldrsh w3, [sp, x5]
|
|
ldrsh w9, [x27, x6, lsl #0]
|
|
ldrh w10, [x30, x7, lsl #1]
|
|
strh w11, [x29, x3, sxtx]
|
|
ldrh w12, [x28, xzr, sxtx #0]
|
|
ldrsh x13, [x27, x5, sxtx #1]
|
|
ldrh w14, [x26, w6, uxtw]
|
|
ldrh w15, [x25, w7, uxtw #0]
|
|
ldrsh w16, [x24, w8, uxtw #1]
|
|
ldrh w17, [x23, w9, sxtw]
|
|
ldrh w18, [x22, w10, sxtw #0]
|
|
strh w19, [x21, wzr, sxtw #1]
|
|
// CHECK: ldrsh w3, [sp, x5] // encoding: [0xe3,0x6b,0xe5,0x78]
|
|
// CHECK: ldrsh w9, [x27, x6] // encoding: [0x69,0x6b,0xe6,0x78]
|
|
// CHECK: ldrh w10, [x30, x7, lsl #1] // encoding: [0xca,0x7b,0x67,0x78]
|
|
// CHECK: strh w11, [x29, x3, sxtx] // encoding: [0xab,0xeb,0x23,0x78]
|
|
// CHECK: ldrh w12, [x28, xzr, sxtx] // encoding: [0x8c,0xeb,0x7f,0x78]
|
|
// CHECK: ldrsh x13, [x27, x5, sxtx #1] // encoding: [0x6d,0xfb,0xa5,0x78]
|
|
// CHECK: ldrh w14, [x26, w6, uxtw] // encoding: [0x4e,0x4b,0x66,0x78]
|
|
// CHECK: ldrh w15, [x25, w7, uxtw] // encoding: [0x2f,0x4b,0x67,0x78]
|
|
// CHECK: ldrsh w16, [x24, w8, uxtw #1] // encoding: [0x10,0x5b,0xe8,0x78]
|
|
// CHECK: ldrh w17, [x23, w9, sxtw] // encoding: [0xf1,0xca,0x69,0x78]
|
|
// CHECK: ldrh w18, [x22, w10, sxtw] // encoding: [0xd2,0xca,0x6a,0x78]
|
|
// CHECK: strh w19, [x21, wzr, sxtw #1] // encoding: [0xb3,0xda,0x3f,0x78]
|
|
|
|
ldr w3, [sp, x5]
|
|
ldr s9, [x27, x6, lsl #0]
|
|
ldr w10, [x30, x7, lsl #2]
|
|
ldr w11, [x29, x3, sxtx]
|
|
str s12, [x28, xzr, sxtx #0]
|
|
str w13, [x27, x5, sxtx #2]
|
|
str w14, [x26, w6, uxtw]
|
|
ldr w15, [x25, w7, uxtw #0]
|
|
ldr w16, [x24, w8, uxtw #2]
|
|
ldrsw x17, [x23, w9, sxtw]
|
|
ldr w18, [x22, w10, sxtw #0]
|
|
ldrsw x19, [x21, wzr, sxtw #2]
|
|
// CHECK: ldr w3, [sp, x5] // encoding: [0xe3,0x6b,0x65,0xb8]
|
|
// CHECK: ldr s9, [x27, x6] // encoding: [0x69,0x6b,0x66,0xbc]
|
|
// CHECK: ldr w10, [x30, x7, lsl #2] // encoding: [0xca,0x7b,0x67,0xb8]
|
|
// CHECK: ldr w11, [x29, x3, sxtx] // encoding: [0xab,0xeb,0x63,0xb8]
|
|
// CHECK: str s12, [x28, xzr, sxtx] // encoding: [0x8c,0xeb,0x3f,0xbc]
|
|
// CHECK: str w13, [x27, x5, sxtx #2] // encoding: [0x6d,0xfb,0x25,0xb8]
|
|
// CHECK: str w14, [x26, w6, uxtw] // encoding: [0x4e,0x4b,0x26,0xb8]
|
|
// CHECK: ldr w15, [x25, w7, uxtw] // encoding: [0x2f,0x4b,0x67,0xb8]
|
|
// CHECK: ldr w16, [x24, w8, uxtw #2] // encoding: [0x10,0x5b,0x68,0xb8]
|
|
// CHECK: ldrsw x17, [x23, w9, sxtw] // encoding: [0xf1,0xca,0xa9,0xb8]
|
|
// CHECK: ldr w18, [x22, w10, sxtw] // encoding: [0xd2,0xca,0x6a,0xb8]
|
|
// CHECK: ldrsw x19, [x21, wzr, sxtw #2] // encoding: [0xb3,0xda,0xbf,0xb8]
|
|
|
|
ldr x3, [sp, x5]
|
|
str x9, [x27, x6, lsl #0]
|
|
ldr d10, [x30, x7, lsl #3]
|
|
str x11, [x29, x3, sxtx]
|
|
ldr x12, [x28, xzr, sxtx #0]
|
|
ldr x13, [x27, x5, sxtx #3]
|
|
prfm pldl1keep, [x26, w6, uxtw]
|
|
ldr x15, [x25, w7, uxtw #0]
|
|
ldr x16, [x24, w8, uxtw #3]
|
|
ldr x17, [x23, w9, sxtw]
|
|
ldr x18, [x22, w10, sxtw #0]
|
|
str d19, [x21, wzr, sxtw #3]
|
|
prfm #6, [x0, x5]
|
|
// CHECK: ldr x3, [sp, x5] // encoding: [0xe3,0x6b,0x65,0xf8]
|
|
// CHECK: str x9, [x27, x6] // encoding: [0x69,0x6b,0x26,0xf8]
|
|
// CHECK: ldr d10, [x30, x7, lsl #3] // encoding: [0xca,0x7b,0x67,0xfc]
|
|
// CHECK: str x11, [x29, x3, sxtx] // encoding: [0xab,0xeb,0x23,0xf8]
|
|
// CHECK: ldr x12, [x28, xzr, sxtx] // encoding: [0x8c,0xeb,0x7f,0xf8]
|
|
// CHECK: ldr x13, [x27, x5, sxtx #3] // encoding: [0x6d,0xfb,0x65,0xf8]
|
|
// CHECK: prfm pldl1keep, [x26, w6, uxtw] // encoding: [0x40,0x4b,0xa6,0xf8]
|
|
// CHECK: ldr x15, [x25, w7, uxtw] // encoding: [0x2f,0x4b,0x67,0xf8]
|
|
// CHECK: ldr x16, [x24, w8, uxtw #3] // encoding: [0x10,0x5b,0x68,0xf8]
|
|
// CHECK: ldr x17, [x23, w9, sxtw] // encoding: [0xf1,0xca,0x69,0xf8]
|
|
// CHECK: ldr x18, [x22, w10, sxtw] // encoding: [0xd2,0xca,0x6a,0xf8]
|
|
// CHECK: str d19, [x21, wzr, sxtw #3] // encoding: [0xb3,0xda,0x3f,0xfc]
|
|
// CHECK: prfm #6, [x0, x5, lsl #0] // encoding: [0x06,0x68,0xa5,0xf8]
|
|
|
|
ldr q3, [sp, x5]
|
|
ldr q9, [x27, x6, lsl #0]
|
|
ldr q10, [x30, x7, lsl #4]
|
|
str q11, [x29, x3, sxtx]
|
|
str q12, [x28, xzr, sxtx #0]
|
|
str q13, [x27, x5, sxtx #4]
|
|
ldr q14, [x26, w6, uxtw]
|
|
ldr q15, [x25, w7, uxtw #0]
|
|
ldr q16, [x24, w8, uxtw #4]
|
|
ldr q17, [x23, w9, sxtw]
|
|
str q18, [x22, w10, sxtw #0]
|
|
ldr q19, [x21, wzr, sxtw #4]
|
|
// CHECK: ldr q3, [sp, x5] // encoding: [0xe3,0x6b,0xe5,0x3c]
|
|
// CHECK: ldr q9, [x27, x6] // encoding: [0x69,0x6b,0xe6,0x3c]
|
|
// CHECK: ldr q10, [x30, x7, lsl #4] // encoding: [0xca,0x7b,0xe7,0x3c]
|
|
// CHECK: str q11, [x29, x3, sxtx] // encoding: [0xab,0xeb,0xa3,0x3c]
|
|
// CHECK: str q12, [x28, xzr, sxtx] // encoding: [0x8c,0xeb,0xbf,0x3c]
|
|
// CHECK: str q13, [x27, x5, sxtx #4] // encoding: [0x6d,0xfb,0xa5,0x3c]
|
|
// CHECK: ldr q14, [x26, w6, uxtw] // encoding: [0x4e,0x4b,0xe6,0x3c]
|
|
// CHECK: ldr q15, [x25, w7, uxtw] // encoding: [0x2f,0x4b,0xe7,0x3c]
|
|
// CHECK: ldr q16, [x24, w8, uxtw #4] // encoding: [0x10,0x5b,0xe8,0x3c]
|
|
// CHECK: ldr q17, [x23, w9, sxtw] // encoding: [0xf1,0xca,0xe9,0x3c]
|
|
// CHECK: str q18, [x22, w10, sxtw] // encoding: [0xd2,0xca,0xaa,0x3c]
|
|
// CHECK: ldr q19, [x21, wzr, sxtw #4] // encoding: [0xb3,0xda,0xff,0x3c]
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Load/store register (immediate post-indexed)
|
|
//------------------------------------------------------------------------------
|
|
|
|
strb w9, [x2], #255
|
|
strb w10, [x3], #1
|
|
strb w10, [x3], #-256
|
|
strh w9, [x2], #255
|
|
strh w9, [x2], #1
|
|
strh w10, [x3], #-256
|
|
// CHECK: strb w9, [x2], #255 // encoding: [0x49,0xf4,0x0f,0x38]
|
|
// CHECK: strb w10, [x3], #1 // encoding: [0x6a,0x14,0x00,0x38]
|
|
// CHECK: strb w10, [x3], #-256 // encoding: [0x6a,0x04,0x10,0x38]
|
|
// CHECK: strh w9, [x2], #255 // encoding: [0x49,0xf4,0x0f,0x78]
|
|
// CHECK: strh w9, [x2], #1 // encoding: [0x49,0x14,0x00,0x78]
|
|
// CHECK: strh w10, [x3], #-256 // encoding: [0x6a,0x04,0x10,0x78]
|
|
|
|
str w19, [sp], #255
|
|
str w20, [x30], #1
|
|
str w21, [x12], #-256
|
|
str xzr, [x9], #255
|
|
str x2, [x3], #1
|
|
str x19, [x12], #-256
|
|
// CHECK: str w19, [sp], #255 // encoding: [0xf3,0xf7,0x0f,0xb8]
|
|
// CHECK: str w20, [x30], #1 // encoding: [0xd4,0x17,0x00,0xb8]
|
|
// CHECK: str w21, [x12], #-256 // encoding: [0x95,0x05,0x10,0xb8]
|
|
// CHECK: str xzr, [x9], #255 // encoding: [0x3f,0xf5,0x0f,0xf8]
|
|
// CHECK: str x2, [x3], #1 // encoding: [0x62,0x14,0x00,0xf8]
|
|
// CHECK: str x19, [x12], #-256 // encoding: [0x93,0x05,0x10,0xf8]
|
|
|
|
ldrb w9, [x2], #255
|
|
ldrb w10, [x3], #1
|
|
ldrb w10, [x3], #-256
|
|
ldrh w9, [x2], #255
|
|
ldrh w9, [x2], #1
|
|
ldrh w10, [x3], #-256
|
|
// CHECK: ldrb w9, [x2], #255 // encoding: [0x49,0xf4,0x4f,0x38]
|
|
// CHECK: ldrb w10, [x3], #1 // encoding: [0x6a,0x14,0x40,0x38]
|
|
// CHECK: ldrb w10, [x3], #-256 // encoding: [0x6a,0x04,0x50,0x38]
|
|
// CHECK: ldrh w9, [x2], #255 // encoding: [0x49,0xf4,0x4f,0x78]
|
|
// CHECK: ldrh w9, [x2], #1 // encoding: [0x49,0x14,0x40,0x78]
|
|
// CHECK: ldrh w10, [x3], #-256 // encoding: [0x6a,0x04,0x50,0x78]
|
|
|
|
ldr w19, [sp], #255
|
|
ldr w20, [x30], #1
|
|
ldr w21, [x12], #-256
|
|
ldr xzr, [x9], #255
|
|
ldr x2, [x3], #1
|
|
ldr x19, [x12], #-256
|
|
// CHECK: ldr w19, [sp], #255 // encoding: [0xf3,0xf7,0x4f,0xb8]
|
|
// CHECK: ldr w20, [x30], #1 // encoding: [0xd4,0x17,0x40,0xb8]
|
|
// CHECK: ldr w21, [x12], #-256 // encoding: [0x95,0x05,0x50,0xb8]
|
|
// CHECK: ldr xzr, [x9], #255 // encoding: [0x3f,0xf5,0x4f,0xf8]
|
|
// CHECK: ldr x2, [x3], #1 // encoding: [0x62,0x14,0x40,0xf8]
|
|
// CHECK: ldr x19, [x12], #-256 // encoding: [0x93,0x05,0x50,0xf8]
|
|
|
|
ldrsb xzr, [x9], #255
|
|
ldrsb x2, [x3], #1
|
|
ldrsb x19, [x12], #-256
|
|
ldrsh xzr, [x9], #255
|
|
ldrsh x2, [x3], #1
|
|
ldrsh x19, [x12], #-256
|
|
ldrsw xzr, [x9], #255
|
|
ldrsw x2, [x3], #1
|
|
ldrsw x19, [x12], #-256
|
|
// CHECK: ldrsb xzr, [x9], #255 // encoding: [0x3f,0xf5,0x8f,0x38]
|
|
// CHECK: ldrsb x2, [x3], #1 // encoding: [0x62,0x14,0x80,0x38]
|
|
// CHECK: ldrsb x19, [x12], #-256 // encoding: [0x93,0x05,0x90,0x38]
|
|
// CHECK: ldrsh xzr, [x9], #255 // encoding: [0x3f,0xf5,0x8f,0x78]
|
|
// CHECK: ldrsh x2, [x3], #1 // encoding: [0x62,0x14,0x80,0x78]
|
|
// CHECK: ldrsh x19, [x12], #-256 // encoding: [0x93,0x05,0x90,0x78]
|
|
// CHECK: ldrsw xzr, [x9], #255 // encoding: [0x3f,0xf5,0x8f,0xb8]
|
|
// CHECK: ldrsw x2, [x3], #1 // encoding: [0x62,0x14,0x80,0xb8]
|
|
// CHECK: ldrsw x19, [x12], #-256 // encoding: [0x93,0x05,0x90,0xb8]
|
|
|
|
ldrsb wzr, [x9], #255
|
|
ldrsb w2, [x3], #1
|
|
ldrsb w19, [x12], #-256
|
|
ldrsh wzr, [x9], #255
|
|
ldrsh w2, [x3], #1
|
|
ldrsh w19, [x12], #-256
|
|
// CHECK: ldrsb wzr, [x9], #255 // encoding: [0x3f,0xf5,0xcf,0x38]
|
|
// CHECK: ldrsb w2, [x3], #1 // encoding: [0x62,0x14,0xc0,0x38]
|
|
// CHECK: ldrsb w19, [x12], #-256 // encoding: [0x93,0x05,0xd0,0x38]
|
|
// CHECK: ldrsh wzr, [x9], #255 // encoding: [0x3f,0xf5,0xcf,0x78]
|
|
// CHECK: ldrsh w2, [x3], #1 // encoding: [0x62,0x14,0xc0,0x78]
|
|
// CHECK: ldrsh w19, [x12], #-256 // encoding: [0x93,0x05,0xd0,0x78]
|
|
|
|
str b0, [x0], #255
|
|
str b3, [x3], #1
|
|
str b5, [sp], #-256
|
|
str h10, [x10], #255
|
|
str h13, [x23], #1
|
|
str h15, [sp], #-256
|
|
str s20, [x20], #255
|
|
str s23, [x23], #1
|
|
str s25, [x0], #-256
|
|
str d20, [x20], #255
|
|
str d23, [x23], #1
|
|
str d25, [x0], #-256
|
|
// CHECK: str b0, [x0], #255 // encoding: [0x00,0xf4,0x0f,0x3c]
|
|
// CHECK: str b3, [x3], #1 // encoding: [0x63,0x14,0x00,0x3c]
|
|
// CHECK: str b5, [sp], #-256 // encoding: [0xe5,0x07,0x10,0x3c]
|
|
// CHECK: str h10, [x10], #255 // encoding: [0x4a,0xf5,0x0f,0x7c]
|
|
// CHECK: str h13, [x23], #1 // encoding: [0xed,0x16,0x00,0x7c]
|
|
// CHECK: str h15, [sp], #-256 // encoding: [0xef,0x07,0x10,0x7c]
|
|
// CHECK: str s20, [x20], #255 // encoding: [0x94,0xf6,0x0f,0xbc]
|
|
// CHECK: str s23, [x23], #1 // encoding: [0xf7,0x16,0x00,0xbc]
|
|
// CHECK: str s25, [x0], #-256 // encoding: [0x19,0x04,0x10,0xbc]
|
|
// CHECK: str d20, [x20], #255 // encoding: [0x94,0xf6,0x0f,0xfc]
|
|
// CHECK: str d23, [x23], #1 // encoding: [0xf7,0x16,0x00,0xfc]
|
|
// CHECK: str d25, [x0], #-256 // encoding: [0x19,0x04,0x10,0xfc]
|
|
|
|
ldr b0, [x0], #255
|
|
ldr b3, [x3], #1
|
|
ldr b5, [sp], #-256
|
|
ldr h10, [x10], #255
|
|
ldr h13, [x23], #1
|
|
ldr h15, [sp], #-256
|
|
ldr s20, [x20], #255
|
|
ldr s23, [x23], #1
|
|
ldr s25, [x0], #-256
|
|
ldr d20, [x20], #255
|
|
ldr d23, [x23], #1
|
|
ldr d25, [x0], #-256
|
|
// CHECK: ldr b0, [x0], #255 // encoding: [0x00,0xf4,0x4f,0x3c]
|
|
// CHECK: ldr b3, [x3], #1 // encoding: [0x63,0x14,0x40,0x3c]
|
|
// CHECK: ldr b5, [sp], #-256 // encoding: [0xe5,0x07,0x50,0x3c]
|
|
// CHECK: ldr h10, [x10], #255 // encoding: [0x4a,0xf5,0x4f,0x7c]
|
|
// CHECK: ldr h13, [x23], #1 // encoding: [0xed,0x16,0x40,0x7c]
|
|
// CHECK: ldr h15, [sp], #-256 // encoding: [0xef,0x07,0x50,0x7c]
|
|
// CHECK: ldr s20, [x20], #255 // encoding: [0x94,0xf6,0x4f,0xbc]
|
|
// CHECK: ldr s23, [x23], #1 // encoding: [0xf7,0x16,0x40,0xbc]
|
|
// CHECK: ldr s25, [x0], #-256 // encoding: [0x19,0x04,0x50,0xbc]
|
|
// CHECK: ldr d20, [x20], #255 // encoding: [0x94,0xf6,0x4f,0xfc]
|
|
// CHECK: ldr d23, [x23], #1 // encoding: [0xf7,0x16,0x40,0xfc]
|
|
// CHECK: ldr d25, [x0], #-256 // encoding: [0x19,0x04,0x50,0xfc]
|
|
|
|
ldr q20, [x1], #255
|
|
ldr q23, [x9], #1
|
|
ldr q25, [x20], #-256
|
|
str q10, [x1], #255
|
|
str q22, [sp], #1
|
|
str q21, [x20], #-256
|
|
// CHECK: ldr q20, [x1], #255 // encoding: [0x34,0xf4,0xcf,0x3c]
|
|
// CHECK: ldr q23, [x9], #1 // encoding: [0x37,0x15,0xc0,0x3c]
|
|
// CHECK: ldr q25, [x20], #-256 // encoding: [0x99,0x06,0xd0,0x3c]
|
|
// CHECK: str q10, [x1], #255 // encoding: [0x2a,0xf4,0x8f,0x3c]
|
|
// CHECK: str q22, [sp], #1 // encoding: [0xf6,0x17,0x80,0x3c]
|
|
// CHECK: str q21, [x20], #-256 // encoding: [0x95,0x06,0x90,0x3c]
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Load/store register (immediate pre-indexed)
|
|
//------------------------------------------------------------------------------
|
|
|
|
ldr x3, [x4, #0]!
|
|
ldr xzr, [sp, #0]!
|
|
// CHECK: ldr x3, [x4, #0]! // encoding: [0x83,0x0c,0x40,0xf8]
|
|
// CHECK: ldr xzr, [sp, #0]! // encoding: [0xff,0x0f,0x40,0xf8]
|
|
|
|
strb w9, [x2, #255]!
|
|
strb w10, [x3, #1]!
|
|
strb w10, [x3, #-256]!
|
|
strh w9, [x2, #255]!
|
|
strh w9, [x2, #1]!
|
|
strh w10, [x3, #-256]!
|
|
// CHECK: strb w9, [x2, #255]! // encoding: [0x49,0xfc,0x0f,0x38]
|
|
// CHECK: strb w10, [x3, #1]! // encoding: [0x6a,0x1c,0x00,0x38]
|
|
// CHECK: strb w10, [x3, #-256]! // encoding: [0x6a,0x0c,0x10,0x38]
|
|
// CHECK: strh w9, [x2, #255]! // encoding: [0x49,0xfc,0x0f,0x78]
|
|
// CHECK: strh w9, [x2, #1]! // encoding: [0x49,0x1c,0x00,0x78]
|
|
// CHECK: strh w10, [x3, #-256]! // encoding: [0x6a,0x0c,0x10,0x78]
|
|
|
|
str w19, [sp, #255]!
|
|
str w20, [x30, #1]!
|
|
str w21, [x12, #-256]!
|
|
str xzr, [x9, #255]!
|
|
str x2, [x3, #1]!
|
|
str x19, [x12, #-256]!
|
|
// CHECK: str w19, [sp, #255]! // encoding: [0xf3,0xff,0x0f,0xb8]
|
|
// CHECK: str w20, [x30, #1]! // encoding: [0xd4,0x1f,0x00,0xb8]
|
|
// CHECK: str w21, [x12, #-256]! // encoding: [0x95,0x0d,0x10,0xb8]
|
|
// CHECK: str xzr, [x9, #255]! // encoding: [0x3f,0xfd,0x0f,0xf8]
|
|
// CHECK: str x2, [x3, #1]! // encoding: [0x62,0x1c,0x00,0xf8]
|
|
// CHECK: str x19, [x12, #-256]! // encoding: [0x93,0x0d,0x10,0xf8]
|
|
|
|
ldrb w9, [x2, #255]!
|
|
ldrb w10, [x3, #1]!
|
|
ldrb w10, [x3, #-256]!
|
|
ldrh w9, [x2, #255]!
|
|
ldrh w9, [x2, #1]!
|
|
ldrh w10, [x3, #-256]!
|
|
// CHECK: ldrb w9, [x2, #255]! // encoding: [0x49,0xfc,0x4f,0x38]
|
|
// CHECK: ldrb w10, [x3, #1]! // encoding: [0x6a,0x1c,0x40,0x38]
|
|
// CHECK: ldrb w10, [x3, #-256]! // encoding: [0x6a,0x0c,0x50,0x38]
|
|
// CHECK: ldrh w9, [x2, #255]! // encoding: [0x49,0xfc,0x4f,0x78]
|
|
// CHECK: ldrh w9, [x2, #1]! // encoding: [0x49,0x1c,0x40,0x78]
|
|
// CHECK: ldrh w10, [x3, #-256]! // encoding: [0x6a,0x0c,0x50,0x78]
|
|
|
|
ldr w19, [sp, #255]!
|
|
ldr w20, [x30, #1]!
|
|
ldr w21, [x12, #-256]!
|
|
ldr xzr, [x9, #255]!
|
|
ldr x2, [x3, #1]!
|
|
ldr x19, [x12, #-256]!
|
|
// CHECK: ldr w19, [sp, #255]! // encoding: [0xf3,0xff,0x4f,0xb8]
|
|
// CHECK: ldr w20, [x30, #1]! // encoding: [0xd4,0x1f,0x40,0xb8]
|
|
// CHECK: ldr w21, [x12, #-256]! // encoding: [0x95,0x0d,0x50,0xb8]
|
|
// CHECK: ldr xzr, [x9, #255]! // encoding: [0x3f,0xfd,0x4f,0xf8]
|
|
// CHECK: ldr x2, [x3, #1]! // encoding: [0x62,0x1c,0x40,0xf8]
|
|
// CHECK: ldr x19, [x12, #-256]! // encoding: [0x93,0x0d,0x50,0xf8]
|
|
|
|
ldrsb xzr, [x9, #255]!
|
|
ldrsb x2, [x3, #1]!
|
|
ldrsb x19, [x12, #-256]!
|
|
ldrsh xzr, [x9, #255]!
|
|
ldrsh x2, [x3, #1]!
|
|
ldrsh x19, [x12, #-256]!
|
|
ldrsw xzr, [x9, #255]!
|
|
ldrsw x2, [x3, #1]!
|
|
ldrsw x19, [x12, #-256]!
|
|
// CHECK: ldrsb xzr, [x9, #255]! // encoding: [0x3f,0xfd,0x8f,0x38]
|
|
// CHECK: ldrsb x2, [x3, #1]! // encoding: [0x62,0x1c,0x80,0x38]
|
|
// CHECK: ldrsb x19, [x12, #-256]! // encoding: [0x93,0x0d,0x90,0x38]
|
|
// CHECK: ldrsh xzr, [x9, #255]! // encoding: [0x3f,0xfd,0x8f,0x78]
|
|
// CHECK: ldrsh x2, [x3, #1]! // encoding: [0x62,0x1c,0x80,0x78]
|
|
// CHECK: ldrsh x19, [x12, #-256]! // encoding: [0x93,0x0d,0x90,0x78]
|
|
// CHECK: ldrsw xzr, [x9, #255]! // encoding: [0x3f,0xfd,0x8f,0xb8]
|
|
// CHECK: ldrsw x2, [x3, #1]! // encoding: [0x62,0x1c,0x80,0xb8]
|
|
// CHECK: ldrsw x19, [x12, #-256]! // encoding: [0x93,0x0d,0x90,0xb8]
|
|
|
|
ldrsb wzr, [x9, #255]!
|
|
ldrsb w2, [x3, #1]!
|
|
ldrsb w19, [x12, #-256]!
|
|
ldrsh wzr, [x9, #255]!
|
|
ldrsh w2, [x3, #1]!
|
|
ldrsh w19, [x12, #-256]!
|
|
// CHECK: ldrsb wzr, [x9, #255]! // encoding: [0x3f,0xfd,0xcf,0x38]
|
|
// CHECK: ldrsb w2, [x3, #1]! // encoding: [0x62,0x1c,0xc0,0x38]
|
|
// CHECK: ldrsb w19, [x12, #-256]! // encoding: [0x93,0x0d,0xd0,0x38]
|
|
// CHECK: ldrsh wzr, [x9, #255]! // encoding: [0x3f,0xfd,0xcf,0x78]
|
|
// CHECK: ldrsh w2, [x3, #1]! // encoding: [0x62,0x1c,0xc0,0x78]
|
|
// CHECK: ldrsh w19, [x12, #-256]! // encoding: [0x93,0x0d,0xd0,0x78]
|
|
|
|
str b0, [x0, #255]!
|
|
str b3, [x3, #1]!
|
|
str b5, [sp, #-256]!
|
|
str h10, [x10, #255]!
|
|
str h13, [x23, #1]!
|
|
str h15, [sp, #-256]!
|
|
str s20, [x20, #255]!
|
|
str s23, [x23, #1]!
|
|
str s25, [x0, #-256]!
|
|
str d20, [x20, #255]!
|
|
str d23, [x23, #1]!
|
|
str d25, [x0, #-256]!
|
|
// CHECK: str b0, [x0, #255]! // encoding: [0x00,0xfc,0x0f,0x3c]
|
|
// CHECK: str b3, [x3, #1]! // encoding: [0x63,0x1c,0x00,0x3c]
|
|
// CHECK: str b5, [sp, #-256]! // encoding: [0xe5,0x0f,0x10,0x3c]
|
|
// CHECK: str h10, [x10, #255]! // encoding: [0x4a,0xfd,0x0f,0x7c]
|
|
// CHECK: str h13, [x23, #1]! // encoding: [0xed,0x1e,0x00,0x7c]
|
|
// CHECK: str h15, [sp, #-256]! // encoding: [0xef,0x0f,0x10,0x7c]
|
|
// CHECK: str s20, [x20, #255]! // encoding: [0x94,0xfe,0x0f,0xbc]
|
|
// CHECK: str s23, [x23, #1]! // encoding: [0xf7,0x1e,0x00,0xbc]
|
|
// CHECK: str s25, [x0, #-256]! // encoding: [0x19,0x0c,0x10,0xbc]
|
|
// CHECK: str d20, [x20, #255]! // encoding: [0x94,0xfe,0x0f,0xfc]
|
|
// CHECK: str d23, [x23, #1]! // encoding: [0xf7,0x1e,0x00,0xfc]
|
|
// CHECK: str d25, [x0, #-256]! // encoding: [0x19,0x0c,0x10,0xfc]
|
|
|
|
ldr b0, [x0, #255]!
|
|
ldr b3, [x3, #1]!
|
|
ldr b5, [sp, #-256]!
|
|
ldr h10, [x10, #255]!
|
|
ldr h13, [x23, #1]!
|
|
ldr h15, [sp, #-256]!
|
|
ldr s20, [x20, #255]!
|
|
ldr s23, [x23, #1]!
|
|
ldr s25, [x0, #-256]!
|
|
ldr d20, [x20, #255]!
|
|
ldr d23, [x23, #1]!
|
|
ldr d25, [x0, #-256]!
|
|
// CHECK: ldr b0, [x0, #255]! // encoding: [0x00,0xfc,0x4f,0x3c]
|
|
// CHECK: ldr b3, [x3, #1]! // encoding: [0x63,0x1c,0x40,0x3c]
|
|
// CHECK: ldr b5, [sp, #-256]! // encoding: [0xe5,0x0f,0x50,0x3c]
|
|
// CHECK: ldr h10, [x10, #255]! // encoding: [0x4a,0xfd,0x4f,0x7c]
|
|
// CHECK: ldr h13, [x23, #1]! // encoding: [0xed,0x1e,0x40,0x7c]
|
|
// CHECK: ldr h15, [sp, #-256]! // encoding: [0xef,0x0f,0x50,0x7c]
|
|
// CHECK: ldr s20, [x20, #255]! // encoding: [0x94,0xfe,0x4f,0xbc]
|
|
// CHECK: ldr s23, [x23, #1]! // encoding: [0xf7,0x1e,0x40,0xbc]
|
|
// CHECK: ldr s25, [x0, #-256]! // encoding: [0x19,0x0c,0x50,0xbc]
|
|
// CHECK: ldr d20, [x20, #255]! // encoding: [0x94,0xfe,0x4f,0xfc]
|
|
// CHECK: ldr d23, [x23, #1]! // encoding: [0xf7,0x1e,0x40,0xfc]
|
|
// CHECK: ldr d25, [x0, #-256]! // encoding: [0x19,0x0c,0x50,0xfc]
|
|
|
|
ldr q20, [x1, #255]!
|
|
ldr q23, [x9, #1]!
|
|
ldr q25, [x20, #-256]!
|
|
str q10, [x1, #255]!
|
|
str q22, [sp, #1]!
|
|
str q21, [x20, #-256]!
|
|
// CHECK: ldr q20, [x1, #255]! // encoding: [0x34,0xfc,0xcf,0x3c]
|
|
// CHECK: ldr q23, [x9, #1]! // encoding: [0x37,0x1d,0xc0,0x3c]
|
|
// CHECK: ldr q25, [x20, #-256]! // encoding: [0x99,0x0e,0xd0,0x3c]
|
|
// CHECK: str q10, [x1, #255]! // encoding: [0x2a,0xfc,0x8f,0x3c]
|
|
// CHECK: str q22, [sp, #1]! // encoding: [0xf6,0x1f,0x80,0x3c]
|
|
// CHECK: str q21, [x20, #-256]! // encoding: [0x95,0x0e,0x90,0x3c]
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Load/store (unprivileged)
|
|
//------------------------------------------------------------------------------
|
|
|
|
sttrb w9, [sp, #0]
|
|
sttrh wzr, [x12, #255]
|
|
sttr w16, [x0, #-256]
|
|
sttr x28, [x14, #1]
|
|
// CHECK: sttrb w9, [sp] // encoding: [0xe9,0x0b,0x00,0x38]
|
|
// CHECK: sttrh wzr, [x12, #255] // encoding: [0x9f,0xf9,0x0f,0x78]
|
|
// CHECK: sttr w16, [x0, #-256] // encoding: [0x10,0x08,0x10,0xb8]
|
|
// CHECK: sttr x28, [x14, #1] // encoding: [0xdc,0x19,0x00,0xf8]
|
|
|
|
ldtrb w1, [x20, #255]
|
|
ldtrh w20, [x1, #255]
|
|
ldtr w12, [sp, #255]
|
|
ldtr xzr, [x12, #255]
|
|
// CHECK: ldtrb w1, [x20, #255] // encoding: [0x81,0xfa,0x4f,0x38]
|
|
// CHECK: ldtrh w20, [x1, #255] // encoding: [0x34,0xf8,0x4f,0x78]
|
|
// CHECK: ldtr w12, [sp, #255] // encoding: [0xec,0xfb,0x4f,0xb8]
|
|
// CHECK: ldtr xzr, [x12, #255] // encoding: [0x9f,0xf9,0x4f,0xf8]
|
|
|
|
ldtrsb x9, [x7, #-256]
|
|
ldtrsh x17, [x19, #-256]
|
|
ldtrsw x20, [x15, #-256]
|
|
ldtrsb w19, [x1, #-256]
|
|
ldtrsh w15, [x21, #-256]
|
|
// CHECK: ldtrsb x9, [x7, #-256] // encoding: [0xe9,0x08,0x90,0x38]
|
|
// CHECK: ldtrsh x17, [x19, #-256] // encoding: [0x71,0x0a,0x90,0x78]
|
|
// CHECK: ldtrsw x20, [x15, #-256] // encoding: [0xf4,0x09,0x90,0xb8]
|
|
// CHECK: ldtrsb w19, [x1, #-256] // encoding: [0x33,0x08,0xd0,0x38]
|
|
// CHECK: ldtrsh w15, [x21, #-256] // encoding: [0xaf,0x0a,0xd0,0x78]
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Load/store register pair (offset)
|
|
//------------------------------------------------------------------------------
|
|
|
|
ldp w3, w5, [sp]
|
|
stp wzr, w9, [sp, #252]
|
|
ldp w2, wzr, [sp, #-256]
|
|
ldp w9, w10, [sp, #4]
|
|
// CHECK: ldp w3, w5, [sp] // encoding: [0xe3,0x17,0x40,0x29]
|
|
// CHECK: stp wzr, w9, [sp, #252] // encoding: [0xff,0xa7,0x1f,0x29]
|
|
// CHECK: ldp w2, wzr, [sp, #-256] // encoding: [0xe2,0x7f,0x60,0x29]
|
|
// CHECK: ldp w9, w10, [sp, #4] // encoding: [0xe9,0xab,0x40,0x29]
|
|
|
|
ldpsw x9, x10, [sp, #4]
|
|
ldpsw x9, x10, [x2, #-256]
|
|
ldpsw x20, x30, [sp, #252]
|
|
// CHECK: ldpsw x9, x10, [sp, #4] // encoding: [0xe9,0xab,0x40,0x69]
|
|
// CHECK: ldpsw x9, x10, [x2, #-256] // encoding: [0x49,0x28,0x60,0x69]
|
|
// CHECK: ldpsw x20, x30, [sp, #252] // encoding: [0xf4,0xfb,0x5f,0x69]
|
|
|
|
ldp x21, x29, [x2, #504]
|
|
ldp x22, x23, [x3, #-512]
|
|
ldp x24, x25, [x4, #8]
|
|
// CHECK: ldp x21, x29, [x2, #504] // encoding: [0x55,0xf4,0x5f,0xa9]
|
|
// CHECK: ldp x22, x23, [x3, #-512] // encoding: [0x76,0x5c,0x60,0xa9]
|
|
// CHECK: ldp x24, x25, [x4, #8] // encoding: [0x98,0xe4,0x40,0xa9]
|
|
|
|
ldp s29, s28, [sp, #252]
|
|
stp s27, s26, [sp, #-256]
|
|
ldp s1, s2, [x3, #44]
|
|
// CHECK: ldp s29, s28, [sp, #252] // encoding: [0xfd,0xf3,0x5f,0x2d]
|
|
// CHECK: stp s27, s26, [sp, #-256] // encoding: [0xfb,0x6b,0x20,0x2d]
|
|
// CHECK: ldp s1, s2, [x3, #44] // encoding: [0x61,0x88,0x45,0x2d]
|
|
|
|
stp d3, d5, [x9, #504]
|
|
stp d7, d11, [x10, #-512]
|
|
ldp d2, d3, [x30, #-8]
|
|
// CHECK: stp d3, d5, [x9, #504] // encoding: [0x23,0x95,0x1f,0x6d]
|
|
// CHECK: stp d7, d11, [x10, #-512] // encoding: [0x47,0x2d,0x20,0x6d]
|
|
// CHECK: ldp d2, d3, [x30, #-8] // encoding: [0xc2,0x8f,0x7f,0x6d]
|
|
|
|
stp q3, q5, [sp]
|
|
stp q17, q19, [sp, #1008]
|
|
ldp q23, q29, [x1, #-1024]
|
|
// CHECK: stp q3, q5, [sp] // encoding: [0xe3,0x17,0x00,0xad]
|
|
// CHECK: stp q17, q19, [sp, #1008] // encoding: [0xf1,0xcf,0x1f,0xad]
|
|
// CHECK: ldp q23, q29, [x1, #-1024] // encoding: [0x37,0x74,0x60,0xad]
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Load/store register pair (post-indexed)
|
|
//------------------------------------------------------------------------------
|
|
|
|
ldp w3, w5, [sp], #0
|
|
stp wzr, w9, [sp], #252
|
|
ldp w2, wzr, [sp], #-256
|
|
ldp w9, w10, [sp], #4
|
|
// CHECK: ldp w3, w5, [sp], #0 // encoding: [0xe3,0x17,0xc0,0x28]
|
|
// CHECK: stp wzr, w9, [sp], #252 // encoding: [0xff,0xa7,0x9f,0x28]
|
|
// CHECK: ldp w2, wzr, [sp], #-256 // encoding: [0xe2,0x7f,0xe0,0x28]
|
|
// CHECK: ldp w9, w10, [sp], #4 // encoding: [0xe9,0xab,0xc0,0x28]
|
|
|
|
ldpsw x9, x10, [sp], #4
|
|
ldpsw x9, x10, [x2], #-256
|
|
ldpsw x20, x30, [sp], #252
|
|
// CHECK: ldpsw x9, x10, [sp], #4 // encoding: [0xe9,0xab,0xc0,0x68]
|
|
// CHECK: ldpsw x9, x10, [x2], #-256 // encoding: [0x49,0x28,0xe0,0x68]
|
|
// CHECK: ldpsw x20, x30, [sp], #252 // encoding: [0xf4,0xfb,0xdf,0x68]
|
|
|
|
ldp x21, x29, [x2], #504
|
|
ldp x22, x23, [x3], #-512
|
|
ldp x24, x25, [x4], #8
|
|
// CHECK: ldp x21, x29, [x2], #504 // encoding: [0x55,0xf4,0xdf,0xa8]
|
|
// CHECK: ldp x22, x23, [x3], #-512 // encoding: [0x76,0x5c,0xe0,0xa8]
|
|
// CHECK: ldp x24, x25, [x4], #8 // encoding: [0x98,0xe4,0xc0,0xa8]
|
|
|
|
ldp s29, s28, [sp], #252
|
|
stp s27, s26, [sp], #-256
|
|
ldp s1, s2, [x3], #44
|
|
// CHECK: ldp s29, s28, [sp], #252 // encoding: [0xfd,0xf3,0xdf,0x2c]
|
|
// CHECK: stp s27, s26, [sp], #-256 // encoding: [0xfb,0x6b,0xa0,0x2c]
|
|
// CHECK: ldp s1, s2, [x3], #44 // encoding: [0x61,0x88,0xc5,0x2c]
|
|
|
|
stp d3, d5, [x9], #504
|
|
stp d7, d11, [x10], #-512
|
|
ldp d2, d3, [x30], #-8
|
|
// CHECK: stp d3, d5, [x9], #504 // encoding: [0x23,0x95,0x9f,0x6c]
|
|
// CHECK: stp d7, d11, [x10], #-512 // encoding: [0x47,0x2d,0xa0,0x6c]
|
|
// CHECK: ldp d2, d3, [x30], #-8 // encoding: [0xc2,0x8f,0xff,0x6c]
|
|
|
|
stp q3, q5, [sp], #0
|
|
stp q17, q19, [sp], #1008
|
|
ldp q23, q29, [x1], #-1024
|
|
// CHECK: stp q3, q5, [sp], #0 // encoding: [0xe3,0x17,0x80,0xac]
|
|
// CHECK: stp q17, q19, [sp], #1008 // encoding: [0xf1,0xcf,0x9f,0xac]
|
|
// CHECK: ldp q23, q29, [x1], #-1024 // encoding: [0x37,0x74,0xe0,0xac]
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Load/store register pair (pre-indexed)
|
|
//------------------------------------------------------------------------------
|
|
ldp w3, w5, [sp, #0]!
|
|
stp wzr, w9, [sp, #252]!
|
|
ldp w2, wzr, [sp, #-256]!
|
|
ldp w9, w10, [sp, #4]!
|
|
// CHECK: ldp w3, w5, [sp, #0]! // encoding: [0xe3,0x17,0xc0,0x29]
|
|
// CHECK: stp wzr, w9, [sp, #252]! // encoding: [0xff,0xa7,0x9f,0x29]
|
|
// CHECK: ldp w2, wzr, [sp, #-256]! // encoding: [0xe2,0x7f,0xe0,0x29]
|
|
// CHECK: ldp w9, w10, [sp, #4]! // encoding: [0xe9,0xab,0xc0,0x29]
|
|
|
|
ldpsw x9, x10, [sp, #4]!
|
|
ldpsw x9, x10, [x2, #-256]!
|
|
ldpsw x20, x30, [sp, #252]!
|
|
// CHECK: ldpsw x9, x10, [sp, #4]! // encoding: [0xe9,0xab,0xc0,0x69]
|
|
// CHECK: ldpsw x9, x10, [x2, #-256]! // encoding: [0x49,0x28,0xe0,0x69]
|
|
// CHECK: ldpsw x20, x30, [sp, #252]! // encoding: [0xf4,0xfb,0xdf,0x69]
|
|
|
|
ldp x21, x29, [x2, #504]!
|
|
ldp x22, x23, [x3, #-512]!
|
|
ldp x24, x25, [x4, #8]!
|
|
// CHECK: ldp x21, x29, [x2, #504]! // encoding: [0x55,0xf4,0xdf,0xa9]
|
|
// CHECK: ldp x22, x23, [x3, #-512]! // encoding: [0x76,0x5c,0xe0,0xa9]
|
|
// CHECK: ldp x24, x25, [x4, #8]! // encoding: [0x98,0xe4,0xc0,0xa9]
|
|
|
|
ldp s29, s28, [sp, #252]!
|
|
stp s27, s26, [sp, #-256]!
|
|
ldp s1, s2, [x3, #44]!
|
|
// CHECK: ldp s29, s28, [sp, #252]! // encoding: [0xfd,0xf3,0xdf,0x2d]
|
|
// CHECK: stp s27, s26, [sp, #-256]! // encoding: [0xfb,0x6b,0xa0,0x2d]
|
|
// CHECK: ldp s1, s2, [x3, #44]! // encoding: [0x61,0x88,0xc5,0x2d]
|
|
|
|
stp d3, d5, [x9, #504]!
|
|
stp d7, d11, [x10, #-512]!
|
|
ldp d2, d3, [x30, #-8]!
|
|
// CHECK: stp d3, d5, [x9, #504]! // encoding: [0x23,0x95,0x9f,0x6d]
|
|
// CHECK: stp d7, d11, [x10, #-512]! // encoding: [0x47,0x2d,0xa0,0x6d]
|
|
// CHECK: ldp d2, d3, [x30, #-8]! // encoding: [0xc2,0x8f,0xff,0x6d]
|
|
|
|
stp q3, q5, [sp, #0]!
|
|
stp q17, q19, [sp, #1008]!
|
|
ldp q23, q29, [x1, #-1024]!
|
|
// CHECK: stp q3, q5, [sp, #0]! // encoding: [0xe3,0x17,0x80,0xad]
|
|
// CHECK: stp q17, q19, [sp, #1008]! // encoding: [0xf1,0xcf,0x9f,0xad]
|
|
// CHECK: ldp q23, q29, [x1, #-1024]! // encoding: [0x37,0x74,0xe0,0xad]
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Load/store non-temporal register pair (offset)
|
|
//------------------------------------------------------------------------------
|
|
|
|
ldnp w3, w5, [sp]
|
|
stnp wzr, w9, [sp, #252]
|
|
ldnp w2, wzr, [sp, #-256]
|
|
ldnp w9, w10, [sp, #4]
|
|
// CHECK: ldnp w3, w5, [sp] // encoding: [0xe3,0x17,0x40,0x28]
|
|
// CHECK: stnp wzr, w9, [sp, #252] // encoding: [0xff,0xa7,0x1f,0x28]
|
|
// CHECK: ldnp w2, wzr, [sp, #-256] // encoding: [0xe2,0x7f,0x60,0x28]
|
|
// CHECK: ldnp w9, w10, [sp, #4] // encoding: [0xe9,0xab,0x40,0x28]
|
|
|
|
ldnp x21, x29, [x2, #504]
|
|
ldnp x22, x23, [x3, #-512]
|
|
ldnp x24, x25, [x4, #8]
|
|
// CHECK: ldnp x21, x29, [x2, #504] // encoding: [0x55,0xf4,0x5f,0xa8]
|
|
// CHECK: ldnp x22, x23, [x3, #-512] // encoding: [0x76,0x5c,0x60,0xa8]
|
|
// CHECK: ldnp x24, x25, [x4, #8] // encoding: [0x98,0xe4,0x40,0xa8]
|
|
|
|
ldnp s29, s28, [sp, #252]
|
|
stnp s27, s26, [sp, #-256]
|
|
ldnp s1, s2, [x3, #44]
|
|
// CHECK: ldnp s29, s28, [sp, #252] // encoding: [0xfd,0xf3,0x5f,0x2c]
|
|
// CHECK: stnp s27, s26, [sp, #-256] // encoding: [0xfb,0x6b,0x20,0x2c]
|
|
// CHECK: ldnp s1, s2, [x3, #44] // encoding: [0x61,0x88,0x45,0x2c]
|
|
|
|
stnp d3, d5, [x9, #504]
|
|
stnp d7, d11, [x10, #-512]
|
|
ldnp d2, d3, [x30, #-8]
|
|
// CHECK: stnp d3, d5, [x9, #504] // encoding: [0x23,0x95,0x1f,0x6c]
|
|
// CHECK: stnp d7, d11, [x10, #-512] // encoding: [0x47,0x2d,0x20,0x6c]
|
|
// CHECK: ldnp d2, d3, [x30, #-8] // encoding: [0xc2,0x8f,0x7f,0x6c]
|
|
|
|
stnp q3, q5, [sp]
|
|
stnp q17, q19, [sp, #1008]
|
|
ldnp q23, q29, [x1, #-1024]
|
|
// CHECK: stnp q3, q5, [sp] // encoding: [0xe3,0x17,0x00,0xac]
|
|
// CHECK: stnp q17, q19, [sp, #1008] // encoding: [0xf1,0xcf,0x1f,0xac]
|
|
// CHECK: ldnp q23, q29, [x1, #-1024] // encoding: [0x37,0x74,0x60,0xac]
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Logical (immediate)
|
|
//------------------------------------------------------------------------------
|
|
// 32 bit replication-width
|
|
orr w3, w9, #0xffff0000
|
|
orr wsp, w10, #0xe00000ff
|
|
orr w9, w10, #0x000003ff
|
|
// CHECK: orr w3, w9, #0xffff0000 // encoding: [0x23,0x3d,0x10,0x32]
|
|
// CHECK: orr wsp, w10, #0xe00000ff // encoding: [0x5f,0x29,0x03,0x32]
|
|
// CHECK: orr w9, w10, #0x3ff // encoding: [0x49,0x25,0x00,0x32]
|
|
|
|
// 16 bit replication width
|
|
and w14, w15, #0x80008000
|
|
and w12, w13, #0xffc3ffc3
|
|
and w11, wzr, #0x00030003
|
|
// CHECK: and w14, w15, #0x80008000 // encoding: [0xee,0x81,0x01,0x12]
|
|
// CHECK: and w12, w13, #0xffc3ffc3 // encoding: [0xac,0xad,0x0a,0x12]
|
|
// CHECK: and w11, wzr, #0x30003 // encoding: [0xeb,0x87,0x00,0x12]
|
|
|
|
// 8 bit replication width
|
|
eor w3, w6, #0xe0e0e0e0
|
|
eor wsp, wzr, #0x03030303
|
|
eor w16, w17, #0x81818181
|
|
// CHECK: eor w3, w6, #0xe0e0e0e0 // encoding: [0xc3,0xc8,0x03,0x52]
|
|
// CHECK: eor wsp, wzr, #0x3030303 // encoding: [0xff,0xc7,0x00,0x52]
|
|
// CHECK: eor w16, w17, #0x81818181 // encoding: [0x30,0xc6,0x01,0x52]
|
|
|
|
// 4 bit replication width
|
|
ands wzr, w18, #0xcccccccc
|
|
ands w19, w20, #0x33333333
|
|
ands w21, w22, #0x99999999
|
|
// CHECK: ands wzr, w18, #0xcccccccc // encoding: [0x5f,0xe6,0x02,0x72]
|
|
// CHECK: ands w19, w20, #0x33333333 // encoding: [0x93,0xe6,0x00,0x72]
|
|
// CHECK: ands w21, w22, #0x99999999 // encoding: [0xd5,0xe6,0x01,0x72]
|
|
|
|
// 2 bit replication width
|
|
tst w3, #0xaaaaaaaa
|
|
tst wzr, #0x55555555
|
|
// CHECK: ands wzr, w3, #0xaaaaaaaa // encoding: [0x7f,0xf0,0x01,0x72]
|
|
// CHECK: ands wzr, wzr, #0x55555555 // encoding: [0xff,0xf3,0x00,0x72]
|
|
|
|
// 64 bit replication-width
|
|
eor x3, x5, #0xffffffffc000000
|
|
and x9, x10, #0x00007fffffffffff
|
|
orr x11, x12, #0x8000000000000fff
|
|
// CHECK: eor x3, x5, #0xffffffffc000000 // encoding: [0xa3,0x84,0x66,0xd2]
|
|
// CHECK: and x9, x10, #0x7fffffffffff // encoding: [0x49,0xb9,0x40,0x92]
|
|
// CHECK: orr x11, x12, #0x8000000000000fff // encoding: [0x8b,0x31,0x41,0xb2]
|
|
|
|
// 32 bit replication-width
|
|
orr x3, x9, #0xffff0000ffff0000
|
|
orr sp, x10, #0xe00000ffe00000ff
|
|
orr x9, x10, #0x000003ff000003ff
|
|
// CHECK: orr x3, x9, #0xffff0000ffff0000 // encoding: [0x23,0x3d,0x10,0xb2]
|
|
// CHECK: orr sp, x10, #0xe00000ffe00000ff // encoding: [0x5f,0x29,0x03,0xb2]
|
|
// CHECK: orr x9, x10, #0x3ff000003ff // encoding: [0x49,0x25,0x00,0xb2]
|
|
|
|
// 16 bit replication-width
|
|
and x14, x15, #0x8000800080008000
|
|
and x12, x13, #0xffc3ffc3ffc3ffc3
|
|
and x11, xzr, #0x0003000300030003
|
|
// CHECK: and x14, x15, #0x8000800080008000 // encoding: [0xee,0x81,0x01,0x92]
|
|
// CHECK: and x12, x13, #0xffc3ffc3ffc3ffc3 // encoding: [0xac,0xad,0x0a,0x92]
|
|
// CHECK: and x11, xzr, #0x3000300030003 // encoding: [0xeb,0x87,0x00,0x92]
|
|
|
|
// 8 bit replication-width
|
|
eor x3, x6, #0xe0e0e0e0e0e0e0e0
|
|
eor sp, xzr, #0x0303030303030303
|
|
eor x16, x17, #0x8181818181818181
|
|
// CHECK: eor x3, x6, #0xe0e0e0e0e0e0e0e0 // encoding: [0xc3,0xc8,0x03,0xd2]
|
|
// CHECK: eor sp, xzr, #0x303030303030303 // encoding: [0xff,0xc7,0x00,0xd2]
|
|
// CHECK: eor x16, x17, #0x8181818181818181 // encoding: [0x30,0xc6,0x01,0xd2]
|
|
|
|
// 4 bit replication-width
|
|
ands xzr, x18, #0xcccccccccccccccc
|
|
ands x19, x20, #0x3333333333333333
|
|
ands x21, x22, #0x9999999999999999
|
|
// CHECK: ands xzr, x18, #0xcccccccccccccccc // encoding: [0x5f,0xe6,0x02,0xf2]
|
|
// CHECK: ands x19, x20, #0x3333333333333333 // encoding: [0x93,0xe6,0x00,0xf2]
|
|
// CHECK: ands x21, x22, #0x9999999999999999 // encoding: [0xd5,0xe6,0x01,0xf2]
|
|
|
|
// 2 bit replication-width
|
|
tst x3, #0xaaaaaaaaaaaaaaaa
|
|
tst xzr, #0x5555555555555555
|
|
// CHECK: ands xzr, x3, #0xaaaaaaaaaaaaaaaa // encoding: [0x7f,0xf0,0x01,0xf2]
|
|
// CHECK: ands xzr, xzr, #0x5555555555555555 // encoding: [0xff,0xf3,0x00,0xf2]
|
|
|
|
mov w3, #0xf000f
|
|
mov x10, #0xaaaaaaaaaaaaaaaa
|
|
// CHECK: orr w3, wzr, #0xf000f // encoding: [0xe3,0x8f,0x00,0x32]
|
|
// CHECK: orr x10, xzr, #0xaaaaaaaaaaaaaaaa // encoding: [0xea,0xf3,0x01,0xb2]
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Logical (shifted register)
|
|
//------------------------------------------------------------------------------
|
|
|
|
and w12, w23, w21
|
|
and w16, w15, w1, lsl #1
|
|
and w9, w4, w10, lsl #31
|
|
and w3, w30, w11, lsl #0
|
|
and x3, x5, x7, lsl #63
|
|
// CHECK: and w12, w23, w21 // encoding: [0xec,0x02,0x15,0x0a]
|
|
// CHECK: and w16, w15, w1, lsl #1 // encoding: [0xf0,0x05,0x01,0x0a]
|
|
// CHECK: and w9, w4, w10, lsl #31 // encoding: [0x89,0x7c,0x0a,0x0a]
|
|
// CHECK: and w3, w30, w11 // encoding: [0xc3,0x03,0x0b,0x0a]
|
|
// CHECK: and x3, x5, x7, lsl #63 // encoding: [0xa3,0xfc,0x07,0x8a]
|
|
|
|
and x5, x14, x19, asr #4
|
|
and w3, w17, w19, ror #31
|
|
and w0, w2, wzr, lsr #17
|
|
and w3, w30, w11, asr #0
|
|
// CHECK: and x5, x14, x19, asr #4 // encoding: [0xc5,0x11,0x93,0x8a]
|
|
// CHECK: and w3, w17, w19, ror #31 // encoding: [0x23,0x7e,0xd3,0x0a]
|
|
// CHECK: and w0, w2, wzr, lsr #17 // encoding: [0x40,0x44,0x5f,0x0a]
|
|
// CHECK: and w3, w30, w11, asr #0 // encoding: [0xc3,0x03,0x8b,0x0a]
|
|
|
|
and xzr, x4, x26, lsl #0
|
|
and w3, wzr, w20, ror #0
|
|
and x7, x20, xzr, asr #63
|
|
// CHECK: and xzr, x4, x26 // encoding: [0x9f,0x00,0x1a,0x8a]
|
|
// CHECK: and w3, wzr, w20, ror #0 // encoding: [0xe3,0x03,0xd4,0x0a]
|
|
// CHECK: and x7, x20, xzr, asr #63 // encoding: [0x87,0xfe,0x9f,0x8a]
|
|
|
|
bic x13, x20, x14, lsl #47
|
|
bic w2, w7, w9
|
|
orr w2, w7, w0, asr #31
|
|
orr x8, x9, x10, lsl #12
|
|
orn x3, x5, x7, asr #0
|
|
orn w2, w5, w29
|
|
// CHECK: bic x13, x20, x14, lsl #47 // encoding: [0x8d,0xbe,0x2e,0x8a]
|
|
// CHECK: bic w2, w7, w9 // encoding: [0xe2,0x00,0x29,0x0a]
|
|
// CHECK: orr w2, w7, w0, asr #31 // encoding: [0xe2,0x7c,0x80,0x2a]
|
|
// CHECK: orr x8, x9, x10, lsl #12 // encoding: [0x28,0x31,0x0a,0xaa]
|
|
// CHECK: orn x3, x5, x7, asr #0 // encoding: [0xa3,0x00,0xa7,0xaa]
|
|
// CHECK: orn w2, w5, w29 // encoding: [0xa2,0x00,0x3d,0x2a]
|
|
|
|
ands w7, wzr, w9, lsl #1
|
|
ands x3, x5, x20, ror #63
|
|
bics w3, w5, w7, lsl #0
|
|
bics x3, xzr, x3, lsl #1
|
|
// CHECK: ands w7, wzr, w9, lsl #1 // encoding: [0xe7,0x07,0x09,0x6a]
|
|
// CHECK: ands x3, x5, x20, ror #63 // encoding: [0xa3,0xfc,0xd4,0xea]
|
|
// CHECK: bics w3, w5, w7 // encoding: [0xa3,0x00,0x27,0x6a]
|
|
// CHECK: bics x3, xzr, x3, lsl #1 // encoding: [0xe3,0x07,0x23,0xea]
|
|
|
|
tst w3, w7, lsl #31
|
|
tst x2, x20, asr #0
|
|
// CHECK: tst w3, w7, lsl #31 // encoding: [0x7f,0x7c,0x07,0x6a]
|
|
// CHECK: tst x2, x20, asr #0 // encoding: [0x5f,0x00,0x94,0xea]
|
|
|
|
mov x3, x6
|
|
mov x3, xzr
|
|
mov wzr, w2
|
|
mov w3, w5
|
|
// CHECK: mov x3, x6 // encoding: [0xe3,0x03,0x06,0xaa]
|
|
// CHECK: mov x3, xzr // encoding: [0xe3,0x03,0x1f,0xaa]
|
|
// CHECK: mov wzr, w2 // encoding: [0xff,0x03,0x02,0x2a]
|
|
// CHECK: mov w3, w5 // encoding: [0xe3,0x03,0x05,0x2a]
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Move wide (immediate)
|
|
//------------------------------------------------------------------------------
|
|
|
|
movz w1, #65535, lsl #0
|
|
movz w2, #0, lsl #16
|
|
movn w2, #1234, lsl #0
|
|
// CHECK: movz w1, #65535 // encoding: [0xe1,0xff,0x9f,0x52]
|
|
// CHECK: movz w2, #0, lsl #16 // encoding: [0x02,0x00,0xa0,0x52]
|
|
// CHECK: movn w2, #1234 // encoding: [0x42,0x9a,0x80,0x12]
|
|
|
|
movz x2, #1234, lsl #32
|
|
movk xzr, #4321, lsl #48
|
|
// CHECK: movz x2, #1234, lsl #32 // encoding: [0x42,0x9a,0xc0,0xd2]
|
|
// CHECK: movk xzr, #4321, lsl #48 // encoding: [0x3f,0x1c,0xe2,0xf2]
|
|
|
|
movz x2, #:abs_g0:sym
|
|
movk w3, #:abs_g0_nc:sym
|
|
// CHECK: movz x2, #:abs_g0:sym // encoding: [0x02'A',A,0x80'A',0xd2'A']
|
|
// CHECK-NEXT: // fixup A - offset: 0, value: :abs_g0:sym, kind: fixup_a64_movw_uabs_g0
|
|
// CHECK: movk w3, #:abs_g0_nc:sym // encoding: [0x03'A',A,0x80'A',0x72'A']
|
|
// CHECK-NEXT: // fixup A - offset: 0, value: :abs_g0_nc:sym, kind: fixup_a64_movw_uabs_g0_nc
|
|
|
|
movz x4, #:abs_g1:sym
|
|
movk w5, #:abs_g1_nc:sym
|
|
// CHECK: movz x4, #:abs_g1:sym // encoding: [0x04'A',A,0xa0'A',0xd2'A']
|
|
// CHECK-NEXT: // fixup A - offset: 0, value: :abs_g1:sym, kind: fixup_a64_movw_uabs_g1
|
|
// CHECK: movk w5, #:abs_g1_nc:sym // encoding: [0x05'A',A,0xa0'A',0x72'A']
|
|
// CHECK-NEXT: // fixup A - offset: 0, value: :abs_g1_nc:sym, kind: fixup_a64_movw_uabs_g1_nc
|
|
|
|
movz x6, #:abs_g2:sym
|
|
movk x7, #:abs_g2_nc:sym
|
|
// CHECK: movz x6, #:abs_g2:sym // encoding: [0x06'A',A,0xc0'A',0xd2'A']
|
|
// CHECK-NEXT: // fixup A - offset: 0, value: :abs_g2:sym, kind: fixup_a64_movw_uabs_g2
|
|
// CHECK: movk x7, #:abs_g2_nc:sym // encoding: [0x07'A',A,0xc0'A',0xf2'A']
|
|
// CHECK-NEXT: // fixup A - offset: 0, value: :abs_g2_nc:sym, kind: fixup_a64_movw_uabs_g2_nc
|
|
|
|
movz x8, #:abs_g3:sym
|
|
movk x9, #:abs_g3:sym
|
|
// CHECK: movz x8, #:abs_g3:sym // encoding: [0x08'A',A,0xe0'A',0xd2'A']
|
|
// CHECK-NEXT: // fixup A - offset: 0, value: :abs_g3:sym, kind: fixup_a64_movw_uabs_g3
|
|
// CHECK: movk x9, #:abs_g3:sym // encoding: [0x09'A',A,0xe0'A',0xf2'A']
|
|
// CHECK-NEXT: // fixup A - offset: 0, value: :abs_g3:sym, kind: fixup_a64_movw_uabs_g3
|
|
|
|
movn x30, #:abs_g0_s:sym
|
|
movz x19, #:abs_g0_s:sym
|
|
movn w10, #:abs_g0_s:sym
|
|
movz w25, #:abs_g0_s:sym
|
|
// CHECK: movn x30, #:abs_g0_s:sym // encoding: [0x1e'A',A,0x80'A',0x92'A']
|
|
// CHECK-NEXT: // fixup A - offset: 0, value: :abs_g0_s:sym, kind: fixup_a64_movw_sabs_g0
|
|
// CHECK: movz x19, #:abs_g0_s:sym // encoding: [0x13'A',A,0x80'A',0x92'A']
|
|
// CHECK-NEXT: // fixup A - offset: 0, value: :abs_g0_s:sym, kind: fixup_a64_movw_sabs_g0
|
|
// CHECK: movn w10, #:abs_g0_s:sym // encoding: [0x0a'A',A,0x80'A',0x12'A']
|
|
// CHECK-NEXT: // fixup A - offset: 0, value: :abs_g0_s:sym, kind: fixup_a64_movw_sabs_g0
|
|
// CHECK: movz w25, #:abs_g0_s:sym // encoding: [0x19'A',A,0x80'A',0x12'A']
|
|
// CHECK-NEXT: // fixup A - offset: 0, value: :abs_g0_s:sym, kind: fixup_a64_movw_sabs_g0
|
|
|
|
movn x30, #:abs_g1_s:sym
|
|
movz x19, #:abs_g1_s:sym
|
|
movn w10, #:abs_g1_s:sym
|
|
movz w25, #:abs_g1_s:sym
|
|
// CHECK: movn x30, #:abs_g1_s:sym // encoding: [0x1e'A',A,0xa0'A',0x92'A']
|
|
// CHECK-NEXT: // fixup A - offset: 0, value: :abs_g1_s:sym, kind: fixup_a64_movw_sabs_g1
|
|
// CHECK: movz x19, #:abs_g1_s:sym // encoding: [0x13'A',A,0xa0'A',0x92'A']
|
|
// CHECK-NEXT: // fixup A - offset: 0, value: :abs_g1_s:sym, kind: fixup_a64_movw_sabs_g1
|
|
// CHECK: movn w10, #:abs_g1_s:sym // encoding: [0x0a'A',A,0xa0'A',0x12'A']
|
|
// CHECK-NEXT: // fixup A - offset: 0, value: :abs_g1_s:sym, kind: fixup_a64_movw_sabs_g1
|
|
// CHECK: movz w25, #:abs_g1_s:sym // encoding: [0x19'A',A,0xa0'A',0x12'A']
|
|
// CHECK-NEXT: // fixup A - offset: 0, value: :abs_g1_s:sym, kind: fixup_a64_movw_sabs_g1
|
|
|
|
movn x30, #:abs_g2_s:sym
|
|
movz x19, #:abs_g2_s:sym
|
|
// CHECK: movn x30, #:abs_g2_s:sym // encoding: [0x1e'A',A,0xc0'A',0x92'A']
|
|
// CHECK-NEXT: // fixup A - offset: 0, value: :abs_g2_s:sym, kind: fixup_a64_movw_sabs_g2
|
|
// CHECK: movz x19, #:abs_g2_s:sym // encoding: [0x13'A',A,0xc0'A',0x92'A']
|
|
// CHECK-NEXT: // fixup A - offset: 0, value: :abs_g2_s:sym, kind: fixup_a64_movw_sabs_g2
|
|
|
|
//------------------------------------------------------------------------------
|
|
// PC-relative addressing
|
|
//------------------------------------------------------------------------------
|
|
|
|
adr x2, loc
|
|
adr xzr, loc
|
|
// CHECK: adr x2, loc // encoding: [0x02'A',A,A,0x10'A']
|
|
// CHECK: // fixup A - offset: 0, value: loc, kind: fixup_a64_adr_prel
|
|
// CHECK: adr xzr, loc // encoding: [0x1f'A',A,A,0x10'A']
|
|
// CHECK: // fixup A - offset: 0, value: loc, kind: fixup_a64_adr_prel
|
|
|
|
adrp x29, loc
|
|
// CHECK: adrp x29, loc // encoding: [0x1d'A',A,A,0x90'A']
|
|
// CHECK: // fixup A - offset: 0, value: loc, kind: fixup_a64_adr_prel_page
|
|
|
|
adrp x30, #4096
|
|
adr x20, #0
|
|
adr x9, #-1
|
|
adr x5, #1048575
|
|
// CHECK: adrp x30, #4096 // encoding: [0x1e,0x00,0x00,0xb0]
|
|
// CHECK: adr x20, #0 // encoding: [0x14,0x00,0x00,0x10]
|
|
// CHECK: adr x9, #-1 // encoding: [0xe9,0xff,0xff,0x70]
|
|
// CHECK: adr x5, #1048575 // encoding: [0xe5,0xff,0x7f,0x70]
|
|
|
|
adr x9, #1048575
|
|
adr x2, #-1048576
|
|
adrp x9, #4294963200
|
|
adrp x20, #-4294967296
|
|
// CHECK: adr x9, #1048575 // encoding: [0xe9,0xff,0x7f,0x70]
|
|
// CHECK: adr x2, #-1048576 // encoding: [0x02,0x00,0x80,0x10]
|
|
// CHECK: adrp x9, #4294963200 // encoding: [0xe9,0xff,0x7f,0xf0]
|
|
// CHECK: adrp x20, #-4294967296 // encoding: [0x14,0x00,0x80,0x90]
|
|
|
|
//------------------------------------------------------------------------------
|
|
// System
|
|
//------------------------------------------------------------------------------
|
|
|
|
hint #0
|
|
hint #127
|
|
// CHECK: nop // encoding: [0x1f,0x20,0x03,0xd5]
|
|
// CHECK: hint #127 // encoding: [0xff,0x2f,0x03,0xd5]
|
|
|
|
nop
|
|
yield
|
|
wfe
|
|
wfi
|
|
sev
|
|
sevl
|
|
// CHECK: nop // encoding: [0x1f,0x20,0x03,0xd5]
|
|
// CHECK: yield // encoding: [0x3f,0x20,0x03,0xd5]
|
|
// CHECK: wfe // encoding: [0x5f,0x20,0x03,0xd5]
|
|
// CHECK: wfi // encoding: [0x7f,0x20,0x03,0xd5]
|
|
// CHECK: sev // encoding: [0x9f,0x20,0x03,0xd5]
|
|
// CHECK: sevl // encoding: [0xbf,0x20,0x03,0xd5]
|
|
|
|
clrex
|
|
clrex #0
|
|
clrex #7
|
|
clrex #15
|
|
// CHECK: clrex // encoding: [0x5f,0x3f,0x03,0xd5]
|
|
// CHECK: clrex #0 // encoding: [0x5f,0x30,0x03,0xd5]
|
|
// CHECK: clrex #7 // encoding: [0x5f,0x37,0x03,0xd5]
|
|
// CHECK: clrex // encoding: [0x5f,0x3f,0x03,0xd5]
|
|
|
|
dsb #0
|
|
dsb #12
|
|
dsb #15
|
|
dsb oshld
|
|
dsb oshst
|
|
dsb osh
|
|
dsb nshld
|
|
dsb nshst
|
|
dsb nsh
|
|
dsb ishld
|
|
dsb ishst
|
|
dsb ish
|
|
dsb ld
|
|
dsb st
|
|
dsb sy
|
|
// CHECK: dsb #0 // encoding: [0x9f,0x30,0x03,0xd5]
|
|
// CHECK: dsb #12 // encoding: [0x9f,0x3c,0x03,0xd5]
|
|
// CHECK: dsb sy // encoding: [0x9f,0x3f,0x03,0xd5]
|
|
// CHECK: dsb oshld // encoding: [0x9f,0x31,0x03,0xd5]
|
|
// CHECK: dsb oshst // encoding: [0x9f,0x32,0x03,0xd5]
|
|
// CHECK: dsb osh // encoding: [0x9f,0x33,0x03,0xd5]
|
|
// CHECK: dsb nshld // encoding: [0x9f,0x35,0x03,0xd5]
|
|
// CHECK: dsb nshst // encoding: [0x9f,0x36,0x03,0xd5]
|
|
// CHECK: dsb nsh // encoding: [0x9f,0x37,0x03,0xd5]
|
|
// CHECK: dsb ishld // encoding: [0x9f,0x39,0x03,0xd5]
|
|
// CHECK: dsb ishst // encoding: [0x9f,0x3a,0x03,0xd5]
|
|
// CHECK: dsb ish // encoding: [0x9f,0x3b,0x03,0xd5]
|
|
// CHECK: dsb ld // encoding: [0x9f,0x3d,0x03,0xd5]
|
|
// CHECK: dsb st // encoding: [0x9f,0x3e,0x03,0xd5]
|
|
// CHECK: dsb sy // encoding: [0x9f,0x3f,0x03,0xd5]
|
|
|
|
dmb #0
|
|
dmb #12
|
|
dmb #15
|
|
dmb oshld
|
|
dmb oshst
|
|
dmb osh
|
|
dmb nshld
|
|
dmb nshst
|
|
dmb nsh
|
|
dmb ishld
|
|
dmb ishst
|
|
dmb ish
|
|
dmb ld
|
|
dmb st
|
|
dmb sy
|
|
// CHECK: dmb #0 // encoding: [0xbf,0x30,0x03,0xd5]
|
|
// CHECK: dmb #12 // encoding: [0xbf,0x3c,0x03,0xd5]
|
|
// CHECK: dmb sy // encoding: [0xbf,0x3f,0x03,0xd5]
|
|
// CHECK: dmb oshld // encoding: [0xbf,0x31,0x03,0xd5]
|
|
// CHECK: dmb oshst // encoding: [0xbf,0x32,0x03,0xd5]
|
|
// CHECK: dmb osh // encoding: [0xbf,0x33,0x03,0xd5]
|
|
// CHECK: dmb nshld // encoding: [0xbf,0x35,0x03,0xd5]
|
|
// CHECK: dmb nshst // encoding: [0xbf,0x36,0x03,0xd5]
|
|
// CHECK: dmb nsh // encoding: [0xbf,0x37,0x03,0xd5]
|
|
// CHECK: dmb ishld // encoding: [0xbf,0x39,0x03,0xd5]
|
|
// CHECK: dmb ishst // encoding: [0xbf,0x3a,0x03,0xd5]
|
|
// CHECK: dmb ish // encoding: [0xbf,0x3b,0x03,0xd5]
|
|
// CHECK: dmb ld // encoding: [0xbf,0x3d,0x03,0xd5]
|
|
// CHECK: dmb st // encoding: [0xbf,0x3e,0x03,0xd5]
|
|
// CHECK: dmb sy // encoding: [0xbf,0x3f,0x03,0xd5]
|
|
|
|
isb sy
|
|
isb
|
|
isb #12
|
|
// CHECK: isb // encoding: [0xdf,0x3f,0x03,0xd5]
|
|
// CHECK: isb // encoding: [0xdf,0x3f,0x03,0xd5]
|
|
// CHECK: isb #12 // encoding: [0xdf,0x3c,0x03,0xd5]
|
|
|
|
|
|
msr spsel, #0
|
|
msr daifset, #15
|
|
msr daifclr, #12
|
|
// CHECK: msr spsel, #0 // encoding: [0xbf,0x40,0x00,0xd5]
|
|
// CHECK: msr daifset, #15 // encoding: [0xdf,0x4f,0x03,0xd5]
|
|
// CHECK: msr daifclr, #12 // encoding: [0xff,0x4c,0x03,0xd5]
|
|
|
|
sys #7, c5, c9, #7, x5
|
|
sys #0, c15, c15, #2
|
|
// CHECK: sys #7, c5, c9, #7, x5 // encoding: [0xe5,0x59,0x0f,0xd5]
|
|
// CHECK: sys #0, c15, c15, #2, xzr // encoding: [0x5f,0xff,0x08,0xd5]
|
|
|
|
sysl x9, #7, c5, c9, #7
|
|
sysl x1, #0, c15, c15, #2
|
|
// CHECK: sysl x9, #7, c5, c9, #7 // encoding: [0xe9,0x59,0x2f,0xd5]
|
|
// CHECK: sysl x1, #0, c15, c15, #2 // encoding: [0x41,0xff,0x28,0xd5]
|
|
|
|
ic ialluis
|
|
ic iallu
|
|
ic ivau, x9
|
|
// CHECK: ic ialluis // encoding: [0x1f,0x71,0x08,0xd5]
|
|
// CHECK: ic iallu // encoding: [0x1f,0x75,0x08,0xd5]
|
|
// CHECK: ic ivau, x9 // encoding: [0x29,0x75,0x0b,0xd5]
|
|
|
|
dc zva, x12
|
|
dc ivac, xzr
|
|
dc isw, x2
|
|
dc cvac, x9
|
|
dc csw, x10
|
|
dc cvau, x0
|
|
dc civac, x3
|
|
dc cisw, x30
|
|
// CHECK: dc zva, x12 // encoding: [0x2c,0x74,0x0b,0xd5]
|
|
// CHECK: dc ivac, xzr // encoding: [0x3f,0x76,0x08,0xd5]
|
|
// CHECK: dc isw, x2 // encoding: [0x42,0x76,0x08,0xd5]
|
|
// CHECK: dc cvac, x9 // encoding: [0x29,0x7a,0x0b,0xd5]
|
|
// CHECK: dc csw, x10 // encoding: [0x4a,0x7a,0x08,0xd5]
|
|
// CHECK: dc cvau, x0 // encoding: [0x20,0x7b,0x0b,0xd5]
|
|
// CHECK: dc civac, x3 // encoding: [0x23,0x7e,0x0b,0xd5]
|
|
// CHECK: dc cisw, x30 // encoding: [0x5e,0x7e,0x08,0xd5]
|
|
|
|
at S1E1R, x19
|
|
at S1E2R, x19
|
|
at S1E3R, x19
|
|
at S1E1W, x19
|
|
at S1E2W, x19
|
|
at S1E3W, x19
|
|
at S1E0R, x19
|
|
at S1E0W, x19
|
|
at S12E1R, x20
|
|
at S12E1W, x20
|
|
at S12E0R, x20
|
|
at S12E0W, x20
|
|
// CHECK: at s1e1r, x19 // encoding: [0x13,0x78,0x08,0xd5]
|
|
// CHECK: at s1e2r, x19 // encoding: [0x13,0x78,0x0c,0xd5]
|
|
// CHECK: at s1e3r, x19 // encoding: [0x13,0x78,0x0e,0xd5]
|
|
// CHECK: at s1e1w, x19 // encoding: [0x33,0x78,0x08,0xd5]
|
|
// CHECK: at s1e2w, x19 // encoding: [0x33,0x78,0x0c,0xd5]
|
|
// CHECK: at s1e3w, x19 // encoding: [0x33,0x78,0x0e,0xd5]
|
|
// CHECK: at s1e0r, x19 // encoding: [0x53,0x78,0x08,0xd5]
|
|
// CHECK: at s1e0w, x19 // encoding: [0x73,0x78,0x08,0xd5]
|
|
// CHECK: at s12e1r, x20 // encoding: [0x94,0x78,0x0c,0xd5]
|
|
// CHECK: at s12e1w, x20 // encoding: [0xb4,0x78,0x0c,0xd5]
|
|
// CHECK: at s12e0r, x20 // encoding: [0xd4,0x78,0x0c,0xd5]
|
|
// CHECK: at s12e0w, x20 // encoding: [0xf4,0x78,0x0c,0xd5]
|
|
|
|
tlbi IPAS2E1IS, x4
|
|
tlbi IPAS2LE1IS, x9
|
|
tlbi VMALLE1IS
|
|
tlbi ALLE2IS
|
|
tlbi ALLE3IS
|
|
tlbi VAE1IS, x1
|
|
tlbi VAE2IS, x2
|
|
tlbi VAE3IS, x3
|
|
tlbi ASIDE1IS, x5
|
|
tlbi VAAE1IS, x9
|
|
tlbi ALLE1IS
|
|
tlbi VALE1IS, x10
|
|
tlbi VALE2IS, x11
|
|
tlbi VALE3IS, x13
|
|
tlbi VMALLS12E1IS
|
|
tlbi VAALE1IS, x14
|
|
tlbi IPAS2E1, x15
|
|
tlbi IPAS2LE1, x16
|
|
tlbi VMALLE1
|
|
tlbi ALLE2
|
|
tlbi ALLE3
|
|
tlbi VAE1, x17
|
|
tlbi VAE2, x18
|
|
tlbi VAE3, x19
|
|
tlbi ASIDE1, x20
|
|
tlbi VAAE1, x21
|
|
tlbi ALLE1
|
|
tlbi VALE1, x22
|
|
tlbi VALE2, x23
|
|
tlbi VALE3, x24
|
|
tlbi VMALLS12E1
|
|
tlbi VAALE1, x25
|
|
// CHECK: tlbi ipas2e1is, x4 // encoding: [0x24,0x80,0x0c,0xd5]
|
|
// CHECK: tlbi ipas2le1is, x9 // encoding: [0xa9,0x80,0x0c,0xd5]
|
|
// CHECK: tlbi vmalle1is // encoding: [0x1f,0x83,0x08,0xd5]
|
|
// CHECK: tlbi alle2is // encoding: [0x1f,0x83,0x0c,0xd5]
|
|
// CHECK: tlbi alle3is // encoding: [0x1f,0x83,0x0e,0xd5]
|
|
// CHECK: tlbi vae1is, x1 // encoding: [0x21,0x83,0x08,0xd5]
|
|
// CHECK: tlbi vae2is, x2 // encoding: [0x22,0x83,0x0c,0xd5]
|
|
// CHECK: tlbi vae3is, x3 // encoding: [0x23,0x83,0x0e,0xd5]
|
|
// CHECK: tlbi aside1is, x5 // encoding: [0x45,0x83,0x08,0xd5]
|
|
// CHECK: tlbi vaae1is, x9 // encoding: [0x69,0x83,0x08,0xd5]
|
|
// CHECK: tlbi alle1is // encoding: [0x9f,0x83,0x0c,0xd5]
|
|
// CHECK: tlbi vale1is, x10 // encoding: [0xaa,0x83,0x08,0xd5]
|
|
// CHECK: tlbi vale2is, x11 // encoding: [0xab,0x83,0x0c,0xd5]
|
|
// CHECK: tlbi vale3is, x13 // encoding: [0xad,0x83,0x0e,0xd5]
|
|
// CHECK: tlbi vmalls12e1is // encoding: [0xdf,0x83,0x0c,0xd5]
|
|
// CHECK: tlbi vaale1is, x14 // encoding: [0xee,0x83,0x08,0xd5]
|
|
// CHECK: tlbi ipas2e1, x15 // encoding: [0x2f,0x84,0x0c,0xd5]
|
|
// CHECK: tlbi ipas2le1, x16 // encoding: [0xb0,0x84,0x0c,0xd5]
|
|
// CHECK: tlbi vmalle1 // encoding: [0x1f,0x87,0x08,0xd5]
|
|
// CHECK: tlbi alle2 // encoding: [0x1f,0x87,0x0c,0xd5]
|
|
// CHECK: tlbi alle3 // encoding: [0x1f,0x87,0x0e,0xd5]
|
|
// CHECK: tlbi vae1, x17 // encoding: [0x31,0x87,0x08,0xd5]
|
|
// CHECK: tlbi vae2, x18 // encoding: [0x32,0x87,0x0c,0xd5]
|
|
// CHECK: tlbi vae3, x19 // encoding: [0x33,0x87,0x0e,0xd5]
|
|
// CHECK: tlbi aside1, x20 // encoding: [0x54,0x87,0x08,0xd5]
|
|
// CHECK: tlbi vaae1, x21 // encoding: [0x75,0x87,0x08,0xd5]
|
|
// CHECK: tlbi alle1 // encoding: [0x9f,0x87,0x0c,0xd5]
|
|
// CHECK: tlbi vale1, x22 // encoding: [0xb6,0x87,0x08,0xd5]
|
|
// CHECK: tlbi vale2, x23 // encoding: [0xb7,0x87,0x0c,0xd5]
|
|
// CHECK: tlbi vale3, x24 // encoding: [0xb8,0x87,0x0e,0xd5]
|
|
// CHECK: tlbi vmalls12e1 // encoding: [0xdf,0x87,0x0c,0xd5]
|
|
// CHECK: tlbi vaale1, x25 // encoding: [0xf9,0x87,0x08,0xd5]
|
|
|
|
msr TEECR32_EL1, x12
|
|
msr OSDTRRX_EL1, x12
|
|
msr MDCCINT_EL1, x12
|
|
msr MDSCR_EL1, x12
|
|
msr OSDTRTX_EL1, x12
|
|
msr DBGDTR_EL0, x12
|
|
msr DBGDTRTX_EL0, x12
|
|
msr OSECCR_EL1, x12
|
|
msr DBGVCR32_EL2, x12
|
|
msr DBGBVR0_EL1, x12
|
|
msr DBGBVR1_EL1, x12
|
|
msr DBGBVR2_EL1, x12
|
|
msr DBGBVR3_EL1, x12
|
|
msr DBGBVR4_EL1, x12
|
|
msr DBGBVR5_EL1, x12
|
|
msr DBGBVR6_EL1, x12
|
|
msr DBGBVR7_EL1, x12
|
|
msr DBGBVR8_EL1, x12
|
|
msr DBGBVR9_EL1, x12
|
|
msr DBGBVR10_EL1, x12
|
|
msr DBGBVR11_EL1, x12
|
|
msr DBGBVR12_EL1, x12
|
|
msr DBGBVR13_EL1, x12
|
|
msr DBGBVR14_EL1, x12
|
|
msr DBGBVR15_EL1, x12
|
|
msr DBGBCR0_EL1, x12
|
|
msr DBGBCR1_EL1, x12
|
|
msr DBGBCR2_EL1, x12
|
|
msr DBGBCR3_EL1, x12
|
|
msr DBGBCR4_EL1, x12
|
|
msr DBGBCR5_EL1, x12
|
|
msr DBGBCR6_EL1, x12
|
|
msr DBGBCR7_EL1, x12
|
|
msr DBGBCR8_EL1, x12
|
|
msr DBGBCR9_EL1, x12
|
|
msr DBGBCR10_EL1, x12
|
|
msr DBGBCR11_EL1, x12
|
|
msr DBGBCR12_EL1, x12
|
|
msr DBGBCR13_EL1, x12
|
|
msr DBGBCR14_EL1, x12
|
|
msr DBGBCR15_EL1, x12
|
|
msr DBGWVR0_EL1, x12
|
|
msr DBGWVR1_EL1, x12
|
|
msr DBGWVR2_EL1, x12
|
|
msr DBGWVR3_EL1, x12
|
|
msr DBGWVR4_EL1, x12
|
|
msr DBGWVR5_EL1, x12
|
|
msr DBGWVR6_EL1, x12
|
|
msr DBGWVR7_EL1, x12
|
|
msr DBGWVR8_EL1, x12
|
|
msr DBGWVR9_EL1, x12
|
|
msr DBGWVR10_EL1, x12
|
|
msr DBGWVR11_EL1, x12
|
|
msr DBGWVR12_EL1, x12
|
|
msr DBGWVR13_EL1, x12
|
|
msr DBGWVR14_EL1, x12
|
|
msr DBGWVR15_EL1, x12
|
|
msr DBGWCR0_EL1, x12
|
|
msr DBGWCR1_EL1, x12
|
|
msr DBGWCR2_EL1, x12
|
|
msr DBGWCR3_EL1, x12
|
|
msr DBGWCR4_EL1, x12
|
|
msr DBGWCR5_EL1, x12
|
|
msr DBGWCR6_EL1, x12
|
|
msr DBGWCR7_EL1, x12
|
|
msr DBGWCR8_EL1, x12
|
|
msr DBGWCR9_EL1, x12
|
|
msr DBGWCR10_EL1, x12
|
|
msr DBGWCR11_EL1, x12
|
|
msr DBGWCR12_EL1, x12
|
|
msr DBGWCR13_EL1, x12
|
|
msr DBGWCR14_EL1, x12
|
|
msr DBGWCR15_EL1, x12
|
|
msr TEEHBR32_EL1, x12
|
|
msr OSLAR_EL1, x12
|
|
msr OSDLR_EL1, x12
|
|
msr DBGPRCR_EL1, x12
|
|
msr DBGCLAIMSET_EL1, x12
|
|
msr DBGCLAIMCLR_EL1, x12
|
|
msr CSSELR_EL1, x12
|
|
msr VPIDR_EL2, x12
|
|
msr VMPIDR_EL2, x12
|
|
msr SCTLR_EL1, x12
|
|
msr SCTLR_EL2, x12
|
|
msr SCTLR_EL3, x12
|
|
msr ACTLR_EL1, x12
|
|
msr ACTLR_EL2, x12
|
|
msr ACTLR_EL3, x12
|
|
msr CPACR_EL1, x12
|
|
msr HCR_EL2, x12
|
|
msr SCR_EL3, x12
|
|
msr MDCR_EL2, x12
|
|
msr SDER32_EL3, x12
|
|
msr CPTR_EL2, x12
|
|
msr CPTR_EL3, x12
|
|
msr HSTR_EL2, x12
|
|
msr HACR_EL2, x12
|
|
msr MDCR_EL3, x12
|
|
msr TTBR0_EL1, x12
|
|
msr TTBR0_EL2, x12
|
|
msr TTBR0_EL3, x12
|
|
msr TTBR1_EL1, x12
|
|
msr TCR_EL1, x12
|
|
msr TCR_EL2, x12
|
|
msr TCR_EL3, x12
|
|
msr VTTBR_EL2, x12
|
|
msr VTCR_EL2, x12
|
|
msr DACR32_EL2, x12
|
|
msr SPSR_EL1, x12
|
|
msr SPSR_EL2, x12
|
|
msr SPSR_EL3, x12
|
|
msr ELR_EL1, x12
|
|
msr ELR_EL2, x12
|
|
msr ELR_EL3, x12
|
|
msr SP_EL0, x12
|
|
msr SP_EL1, x12
|
|
msr SP_EL2, x12
|
|
msr SPSel, x12
|
|
msr NZCV, x12
|
|
msr DAIF, x12
|
|
msr CurrentEL, x12
|
|
msr SPSR_irq, x12
|
|
msr SPSR_abt, x12
|
|
msr SPSR_und, x12
|
|
msr SPSR_fiq, x12
|
|
msr FPCR, x12
|
|
msr FPSR, x12
|
|
msr DSPSR_EL0, x12
|
|
msr DLR_EL0, x12
|
|
msr IFSR32_EL2, x12
|
|
msr AFSR0_EL1, x12
|
|
msr AFSR0_EL2, x12
|
|
msr AFSR0_EL3, x12
|
|
msr AFSR1_EL1, x12
|
|
msr AFSR1_EL2, x12
|
|
msr AFSR1_EL3, x12
|
|
msr ESR_EL1, x12
|
|
msr ESR_EL2, x12
|
|
msr ESR_EL3, x12
|
|
msr FPEXC32_EL2, x12
|
|
msr FAR_EL1, x12
|
|
msr FAR_EL2, x12
|
|
msr FAR_EL3, x12
|
|
msr HPFAR_EL2, x12
|
|
msr PAR_EL1, x12
|
|
msr PMCR_EL0, x12
|
|
msr PMCNTENSET_EL0, x12
|
|
msr PMCNTENCLR_EL0, x12
|
|
msr PMOVSCLR_EL0, x12
|
|
msr PMSELR_EL0, x12
|
|
msr PMCCNTR_EL0, x12
|
|
msr PMXEVTYPER_EL0, x12
|
|
msr PMXEVCNTR_EL0, x12
|
|
msr PMUSERENR_EL0, x12
|
|
msr PMINTENSET_EL1, x12
|
|
msr PMINTENCLR_EL1, x12
|
|
msr PMOVSSET_EL0, x12
|
|
msr MAIR_EL1, x12
|
|
msr MAIR_EL2, x12
|
|
msr MAIR_EL3, x12
|
|
msr AMAIR_EL1, x12
|
|
msr AMAIR_EL2, x12
|
|
msr AMAIR_EL3, x12
|
|
msr VBAR_EL1, x12
|
|
msr VBAR_EL2, x12
|
|
msr VBAR_EL3, x12
|
|
msr RMR_EL1, x12
|
|
msr RMR_EL2, x12
|
|
msr RMR_EL3, x12
|
|
msr CONTEXTIDR_EL1, x12
|
|
msr TPIDR_EL0, x12
|
|
msr TPIDR_EL2, x12
|
|
msr TPIDR_EL3, x12
|
|
msr TPIDRRO_EL0, x12
|
|
msr TPIDR_EL1, x12
|
|
msr CNTFRQ_EL0, x12
|
|
msr CNTVOFF_EL2, x12
|
|
msr CNTKCTL_EL1, x12
|
|
msr CNTHCTL_EL2, x12
|
|
msr CNTP_TVAL_EL0, x12
|
|
msr CNTHP_TVAL_EL2, x12
|
|
msr CNTPS_TVAL_EL1, x12
|
|
msr CNTP_CTL_EL0, x12
|
|
msr CNTHP_CTL_EL2, x12
|
|
msr CNTPS_CTL_EL1, x12
|
|
msr CNTP_CVAL_EL0, x12
|
|
msr CNTHP_CVAL_EL2, x12
|
|
msr CNTPS_CVAL_EL1, x12
|
|
msr CNTV_TVAL_EL0, x12
|
|
msr CNTV_CTL_EL0, x12
|
|
msr CNTV_CVAL_EL0, x12
|
|
msr PMEVCNTR0_EL0, x12
|
|
msr PMEVCNTR1_EL0, x12
|
|
msr PMEVCNTR2_EL0, x12
|
|
msr PMEVCNTR3_EL0, x12
|
|
msr PMEVCNTR4_EL0, x12
|
|
msr PMEVCNTR5_EL0, x12
|
|
msr PMEVCNTR6_EL0, x12
|
|
msr PMEVCNTR7_EL0, x12
|
|
msr PMEVCNTR8_EL0, x12
|
|
msr PMEVCNTR9_EL0, x12
|
|
msr PMEVCNTR10_EL0, x12
|
|
msr PMEVCNTR11_EL0, x12
|
|
msr PMEVCNTR12_EL0, x12
|
|
msr PMEVCNTR13_EL0, x12
|
|
msr PMEVCNTR14_EL0, x12
|
|
msr PMEVCNTR15_EL0, x12
|
|
msr PMEVCNTR16_EL0, x12
|
|
msr PMEVCNTR17_EL0, x12
|
|
msr PMEVCNTR18_EL0, x12
|
|
msr PMEVCNTR19_EL0, x12
|
|
msr PMEVCNTR20_EL0, x12
|
|
msr PMEVCNTR21_EL0, x12
|
|
msr PMEVCNTR22_EL0, x12
|
|
msr PMEVCNTR23_EL0, x12
|
|
msr PMEVCNTR24_EL0, x12
|
|
msr PMEVCNTR25_EL0, x12
|
|
msr PMEVCNTR26_EL0, x12
|
|
msr PMEVCNTR27_EL0, x12
|
|
msr PMEVCNTR28_EL0, x12
|
|
msr PMEVCNTR29_EL0, x12
|
|
msr PMEVCNTR30_EL0, x12
|
|
msr PMCCFILTR_EL0, x12
|
|
msr PMEVTYPER0_EL0, x12
|
|
msr PMEVTYPER1_EL0, x12
|
|
msr PMEVTYPER2_EL0, x12
|
|
msr PMEVTYPER3_EL0, x12
|
|
msr PMEVTYPER4_EL0, x12
|
|
msr PMEVTYPER5_EL0, x12
|
|
msr PMEVTYPER6_EL0, x12
|
|
msr PMEVTYPER7_EL0, x12
|
|
msr PMEVTYPER8_EL0, x12
|
|
msr PMEVTYPER9_EL0, x12
|
|
msr PMEVTYPER10_EL0, x12
|
|
msr PMEVTYPER11_EL0, x12
|
|
msr PMEVTYPER12_EL0, x12
|
|
msr PMEVTYPER13_EL0, x12
|
|
msr PMEVTYPER14_EL0, x12
|
|
msr PMEVTYPER15_EL0, x12
|
|
msr PMEVTYPER16_EL0, x12
|
|
msr PMEVTYPER17_EL0, x12
|
|
msr PMEVTYPER18_EL0, x12
|
|
msr PMEVTYPER19_EL0, x12
|
|
msr PMEVTYPER20_EL0, x12
|
|
msr PMEVTYPER21_EL0, x12
|
|
msr PMEVTYPER22_EL0, x12
|
|
msr PMEVTYPER23_EL0, x12
|
|
msr PMEVTYPER24_EL0, x12
|
|
msr PMEVTYPER25_EL0, x12
|
|
msr PMEVTYPER26_EL0, x12
|
|
msr PMEVTYPER27_EL0, x12
|
|
msr PMEVTYPER28_EL0, x12
|
|
msr PMEVTYPER29_EL0, x12
|
|
msr PMEVTYPER30_EL0, x12
|
|
// CHECK: msr teecr32_el1, x12 // encoding: [0x0c,0x00,0x12,0xd5]
|
|
// CHECK: msr osdtrrx_el1, x12 // encoding: [0x4c,0x00,0x10,0xd5]
|
|
// CHECK: msr mdccint_el1, x12 // encoding: [0x0c,0x02,0x10,0xd5]
|
|
// CHECK: msr mdscr_el1, x12 // encoding: [0x4c,0x02,0x10,0xd5]
|
|
// CHECK: msr osdtrtx_el1, x12 // encoding: [0x4c,0x03,0x10,0xd5]
|
|
// CHECK: msr dbgdtr_el0, x12 // encoding: [0x0c,0x04,0x13,0xd5]
|
|
// CHECK: msr dbgdtrtx_el0, x12 // encoding: [0x0c,0x05,0x13,0xd5]
|
|
// CHECK: msr oseccr_el1, x12 // encoding: [0x4c,0x06,0x10,0xd5]
|
|
// CHECK: msr dbgvcr32_el2, x12 // encoding: [0x0c,0x07,0x14,0xd5]
|
|
// CHECK: msr dbgbvr0_el1, x12 // encoding: [0x8c,0x00,0x10,0xd5]
|
|
// CHECK: msr dbgbvr1_el1, x12 // encoding: [0x8c,0x01,0x10,0xd5]
|
|
// CHECK: msr dbgbvr2_el1, x12 // encoding: [0x8c,0x02,0x10,0xd5]
|
|
// CHECK: msr dbgbvr3_el1, x12 // encoding: [0x8c,0x03,0x10,0xd5]
|
|
// CHECK: msr dbgbvr4_el1, x12 // encoding: [0x8c,0x04,0x10,0xd5]
|
|
// CHECK: msr dbgbvr5_el1, x12 // encoding: [0x8c,0x05,0x10,0xd5]
|
|
// CHECK: msr dbgbvr6_el1, x12 // encoding: [0x8c,0x06,0x10,0xd5]
|
|
// CHECK: msr dbgbvr7_el1, x12 // encoding: [0x8c,0x07,0x10,0xd5]
|
|
// CHECK: msr dbgbvr8_el1, x12 // encoding: [0x8c,0x08,0x10,0xd5]
|
|
// CHECK: msr dbgbvr9_el1, x12 // encoding: [0x8c,0x09,0x10,0xd5]
|
|
// CHECK: msr dbgbvr10_el1, x12 // encoding: [0x8c,0x0a,0x10,0xd5]
|
|
// CHECK: msr dbgbvr11_el1, x12 // encoding: [0x8c,0x0b,0x10,0xd5]
|
|
// CHECK: msr dbgbvr12_el1, x12 // encoding: [0x8c,0x0c,0x10,0xd5]
|
|
// CHECK: msr dbgbvr13_el1, x12 // encoding: [0x8c,0x0d,0x10,0xd5]
|
|
// CHECK: msr dbgbvr14_el1, x12 // encoding: [0x8c,0x0e,0x10,0xd5]
|
|
// CHECK: msr dbgbvr15_el1, x12 // encoding: [0x8c,0x0f,0x10,0xd5]
|
|
// CHECK: msr dbgbcr0_el1, x12 // encoding: [0xac,0x00,0x10,0xd5]
|
|
// CHECK: msr dbgbcr1_el1, x12 // encoding: [0xac,0x01,0x10,0xd5]
|
|
// CHECK: msr dbgbcr2_el1, x12 // encoding: [0xac,0x02,0x10,0xd5]
|
|
// CHECK: msr dbgbcr3_el1, x12 // encoding: [0xac,0x03,0x10,0xd5]
|
|
// CHECK: msr dbgbcr4_el1, x12 // encoding: [0xac,0x04,0x10,0xd5]
|
|
// CHECK: msr dbgbcr5_el1, x12 // encoding: [0xac,0x05,0x10,0xd5]
|
|
// CHECK: msr dbgbcr6_el1, x12 // encoding: [0xac,0x06,0x10,0xd5]
|
|
// CHECK: msr dbgbcr7_el1, x12 // encoding: [0xac,0x07,0x10,0xd5]
|
|
// CHECK: msr dbgbcr8_el1, x12 // encoding: [0xac,0x08,0x10,0xd5]
|
|
// CHECK: msr dbgbcr9_el1, x12 // encoding: [0xac,0x09,0x10,0xd5]
|
|
// CHECK: msr dbgbcr10_el1, x12 // encoding: [0xac,0x0a,0x10,0xd5]
|
|
// CHECK: msr dbgbcr11_el1, x12 // encoding: [0xac,0x0b,0x10,0xd5]
|
|
// CHECK: msr dbgbcr12_el1, x12 // encoding: [0xac,0x0c,0x10,0xd5]
|
|
// CHECK: msr dbgbcr13_el1, x12 // encoding: [0xac,0x0d,0x10,0xd5]
|
|
// CHECK: msr dbgbcr14_el1, x12 // encoding: [0xac,0x0e,0x10,0xd5]
|
|
// CHECK: msr dbgbcr15_el1, x12 // encoding: [0xac,0x0f,0x10,0xd5]
|
|
// CHECK: msr dbgwvr0_el1, x12 // encoding: [0xcc,0x00,0x10,0xd5]
|
|
// CHECK: msr dbgwvr1_el1, x12 // encoding: [0xcc,0x01,0x10,0xd5]
|
|
// CHECK: msr dbgwvr2_el1, x12 // encoding: [0xcc,0x02,0x10,0xd5]
|
|
// CHECK: msr dbgwvr3_el1, x12 // encoding: [0xcc,0x03,0x10,0xd5]
|
|
// CHECK: msr dbgwvr4_el1, x12 // encoding: [0xcc,0x04,0x10,0xd5]
|
|
// CHECK: msr dbgwvr5_el1, x12 // encoding: [0xcc,0x05,0x10,0xd5]
|
|
// CHECK: msr dbgwvr6_el1, x12 // encoding: [0xcc,0x06,0x10,0xd5]
|
|
// CHECK: msr dbgwvr7_el1, x12 // encoding: [0xcc,0x07,0x10,0xd5]
|
|
// CHECK: msr dbgwvr8_el1, x12 // encoding: [0xcc,0x08,0x10,0xd5]
|
|
// CHECK: msr dbgwvr9_el1, x12 // encoding: [0xcc,0x09,0x10,0xd5]
|
|
// CHECK: msr dbgwvr10_el1, x12 // encoding: [0xcc,0x0a,0x10,0xd5]
|
|
// CHECK: msr dbgwvr11_el1, x12 // encoding: [0xcc,0x0b,0x10,0xd5]
|
|
// CHECK: msr dbgwvr12_el1, x12 // encoding: [0xcc,0x0c,0x10,0xd5]
|
|
// CHECK: msr dbgwvr13_el1, x12 // encoding: [0xcc,0x0d,0x10,0xd5]
|
|
// CHECK: msr dbgwvr14_el1, x12 // encoding: [0xcc,0x0e,0x10,0xd5]
|
|
// CHECK: msr dbgwvr15_el1, x12 // encoding: [0xcc,0x0f,0x10,0xd5]
|
|
// CHECK: msr dbgwcr0_el1, x12 // encoding: [0xec,0x00,0x10,0xd5]
|
|
// CHECK: msr dbgwcr1_el1, x12 // encoding: [0xec,0x01,0x10,0xd5]
|
|
// CHECK: msr dbgwcr2_el1, x12 // encoding: [0xec,0x02,0x10,0xd5]
|
|
// CHECK: msr dbgwcr3_el1, x12 // encoding: [0xec,0x03,0x10,0xd5]
|
|
// CHECK: msr dbgwcr4_el1, x12 // encoding: [0xec,0x04,0x10,0xd5]
|
|
// CHECK: msr dbgwcr5_el1, x12 // encoding: [0xec,0x05,0x10,0xd5]
|
|
// CHECK: msr dbgwcr6_el1, x12 // encoding: [0xec,0x06,0x10,0xd5]
|
|
// CHECK: msr dbgwcr7_el1, x12 // encoding: [0xec,0x07,0x10,0xd5]
|
|
// CHECK: msr dbgwcr8_el1, x12 // encoding: [0xec,0x08,0x10,0xd5]
|
|
// CHECK: msr dbgwcr9_el1, x12 // encoding: [0xec,0x09,0x10,0xd5]
|
|
// CHECK: msr dbgwcr10_el1, x12 // encoding: [0xec,0x0a,0x10,0xd5]
|
|
// CHECK: msr dbgwcr11_el1, x12 // encoding: [0xec,0x0b,0x10,0xd5]
|
|
// CHECK: msr dbgwcr12_el1, x12 // encoding: [0xec,0x0c,0x10,0xd5]
|
|
// CHECK: msr dbgwcr13_el1, x12 // encoding: [0xec,0x0d,0x10,0xd5]
|
|
// CHECK: msr dbgwcr14_el1, x12 // encoding: [0xec,0x0e,0x10,0xd5]
|
|
// CHECK: msr dbgwcr15_el1, x12 // encoding: [0xec,0x0f,0x10,0xd5]
|
|
// CHECK: msr teehbr32_el1, x12 // encoding: [0x0c,0x10,0x12,0xd5]
|
|
// CHECK: msr oslar_el1, x12 // encoding: [0x8c,0x10,0x10,0xd5]
|
|
// CHECK: msr osdlr_el1, x12 // encoding: [0x8c,0x13,0x10,0xd5]
|
|
// CHECK: msr dbgprcr_el1, x12 // encoding: [0x8c,0x14,0x10,0xd5]
|
|
// CHECK: msr dbgclaimset_el1, x12 // encoding: [0xcc,0x78,0x10,0xd5]
|
|
// CHECK: msr dbgclaimclr_el1, x12 // encoding: [0xcc,0x79,0x10,0xd5]
|
|
// CHECK: msr csselr_el1, x12 // encoding: [0x0c,0x00,0x1a,0xd5]
|
|
// CHECK: msr vpidr_el2, x12 // encoding: [0x0c,0x00,0x1c,0xd5]
|
|
// CHECK: msr vmpidr_el2, x12 // encoding: [0xac,0x00,0x1c,0xd5]
|
|
// CHECK: msr sctlr_el1, x12 // encoding: [0x0c,0x10,0x18,0xd5]
|
|
// CHECK: msr sctlr_el2, x12 // encoding: [0x0c,0x10,0x1c,0xd5]
|
|
// CHECK: msr sctlr_el3, x12 // encoding: [0x0c,0x10,0x1e,0xd5]
|
|
// CHECK: msr actlr_el1, x12 // encoding: [0x2c,0x10,0x18,0xd5]
|
|
// CHECK: msr actlr_el2, x12 // encoding: [0x2c,0x10,0x1c,0xd5]
|
|
// CHECK: msr actlr_el3, x12 // encoding: [0x2c,0x10,0x1e,0xd5]
|
|
// CHECK: msr cpacr_el1, x12 // encoding: [0x4c,0x10,0x18,0xd5]
|
|
// CHECK: msr hcr_el2, x12 // encoding: [0x0c,0x11,0x1c,0xd5]
|
|
// CHECK: msr scr_el3, x12 // encoding: [0x0c,0x11,0x1e,0xd5]
|
|
// CHECK: msr mdcr_el2, x12 // encoding: [0x2c,0x11,0x1c,0xd5]
|
|
// CHECK: msr sder32_el3, x12 // encoding: [0x2c,0x11,0x1e,0xd5]
|
|
// CHECK: msr cptr_el2, x12 // encoding: [0x4c,0x11,0x1c,0xd5]
|
|
// CHECK: msr cptr_el3, x12 // encoding: [0x4c,0x11,0x1e,0xd5]
|
|
// CHECK: msr hstr_el2, x12 // encoding: [0x6c,0x11,0x1c,0xd5]
|
|
// CHECK: msr hacr_el2, x12 // encoding: [0xec,0x11,0x1c,0xd5]
|
|
// CHECK: msr mdcr_el3, x12 // encoding: [0x2c,0x13,0x1e,0xd5]
|
|
// CHECK: msr ttbr0_el1, x12 // encoding: [0x0c,0x20,0x18,0xd5]
|
|
// CHECK: msr ttbr0_el2, x12 // encoding: [0x0c,0x20,0x1c,0xd5]
|
|
// CHECK: msr ttbr0_el3, x12 // encoding: [0x0c,0x20,0x1e,0xd5]
|
|
// CHECK: msr ttbr1_el1, x12 // encoding: [0x2c,0x20,0x18,0xd5]
|
|
// CHECK: msr tcr_el1, x12 // encoding: [0x4c,0x20,0x18,0xd5]
|
|
// CHECK: msr tcr_el2, x12 // encoding: [0x4c,0x20,0x1c,0xd5]
|
|
// CHECK: msr tcr_el3, x12 // encoding: [0x4c,0x20,0x1e,0xd5]
|
|
// CHECK: msr vttbr_el2, x12 // encoding: [0x0c,0x21,0x1c,0xd5]
|
|
// CHECK: msr vtcr_el2, x12 // encoding: [0x4c,0x21,0x1c,0xd5]
|
|
// CHECK: msr dacr32_el2, x12 // encoding: [0x0c,0x30,0x1c,0xd5]
|
|
// CHECK: msr spsr_el1, x12 // encoding: [0x0c,0x40,0x18,0xd5]
|
|
// CHECK: msr spsr_el2, x12 // encoding: [0x0c,0x40,0x1c,0xd5]
|
|
// CHECK: msr spsr_el3, x12 // encoding: [0x0c,0x40,0x1e,0xd5]
|
|
// CHECK: msr elr_el1, x12 // encoding: [0x2c,0x40,0x18,0xd5]
|
|
// CHECK: msr elr_el2, x12 // encoding: [0x2c,0x40,0x1c,0xd5]
|
|
// CHECK: msr elr_el3, x12 // encoding: [0x2c,0x40,0x1e,0xd5]
|
|
// CHECK: msr sp_el0, x12 // encoding: [0x0c,0x41,0x18,0xd5]
|
|
// CHECK: msr sp_el1, x12 // encoding: [0x0c,0x41,0x1c,0xd5]
|
|
// CHECK: msr sp_el2, x12 // encoding: [0x0c,0x41,0x1e,0xd5]
|
|
// CHECK: msr spsel, x12 // encoding: [0x0c,0x42,0x18,0xd5]
|
|
// CHECK: msr nzcv, x12 // encoding: [0x0c,0x42,0x1b,0xd5]
|
|
// CHECK: msr daif, x12 // encoding: [0x2c,0x42,0x1b,0xd5]
|
|
// CHECK: msr currentel, x12 // encoding: [0x4c,0x42,0x18,0xd5]
|
|
// CHECK: msr spsr_irq, x12 // encoding: [0x0c,0x43,0x1c,0xd5]
|
|
// CHECK: msr spsr_abt, x12 // encoding: [0x2c,0x43,0x1c,0xd5]
|
|
// CHECK: msr spsr_und, x12 // encoding: [0x4c,0x43,0x1c,0xd5]
|
|
// CHECK: msr spsr_fiq, x12 // encoding: [0x6c,0x43,0x1c,0xd5]
|
|
// CHECK: msr fpcr, x12 // encoding: [0x0c,0x44,0x1b,0xd5]
|
|
// CHECK: msr fpsr, x12 // encoding: [0x2c,0x44,0x1b,0xd5]
|
|
// CHECK: msr dspsr_el0, x12 // encoding: [0x0c,0x45,0x1b,0xd5]
|
|
// CHECK: msr dlr_el0, x12 // encoding: [0x2c,0x45,0x1b,0xd5]
|
|
// CHECK: msr ifsr32_el2, x12 // encoding: [0x2c,0x50,0x1c,0xd5]
|
|
// CHECK: msr afsr0_el1, x12 // encoding: [0x0c,0x51,0x18,0xd5]
|
|
// CHECK: msr afsr0_el2, x12 // encoding: [0x0c,0x51,0x1c,0xd5]
|
|
// CHECK: msr afsr0_el3, x12 // encoding: [0x0c,0x51,0x1e,0xd5]
|
|
// CHECK: msr afsr1_el1, x12 // encoding: [0x2c,0x51,0x18,0xd5]
|
|
// CHECK: msr afsr1_el2, x12 // encoding: [0x2c,0x51,0x1c,0xd5]
|
|
// CHECK: msr afsr1_el3, x12 // encoding: [0x2c,0x51,0x1e,0xd5]
|
|
// CHECK: msr esr_el1, x12 // encoding: [0x0c,0x52,0x18,0xd5]
|
|
// CHECK: msr esr_el2, x12 // encoding: [0x0c,0x52,0x1c,0xd5]
|
|
// CHECK: msr esr_el3, x12 // encoding: [0x0c,0x52,0x1e,0xd5]
|
|
// CHECK: msr fpexc32_el2, x12 // encoding: [0x0c,0x53,0x1c,0xd5]
|
|
// CHECK: msr far_el1, x12 // encoding: [0x0c,0x60,0x18,0xd5]
|
|
// CHECK: msr far_el2, x12 // encoding: [0x0c,0x60,0x1c,0xd5]
|
|
// CHECK: msr far_el3, x12 // encoding: [0x0c,0x60,0x1e,0xd5]
|
|
// CHECK: msr hpfar_el2, x12 // encoding: [0x8c,0x60,0x1c,0xd5]
|
|
// CHECK: msr par_el1, x12 // encoding: [0x0c,0x74,0x18,0xd5]
|
|
// CHECK: msr pmcr_el0, x12 // encoding: [0x0c,0x9c,0x1b,0xd5]
|
|
// CHECK: msr pmcntenset_el0, x12 // encoding: [0x2c,0x9c,0x1b,0xd5]
|
|
// CHECK: msr pmcntenclr_el0, x12 // encoding: [0x4c,0x9c,0x1b,0xd5]
|
|
// CHECK: msr pmovsclr_el0, x12 // encoding: [0x6c,0x9c,0x1b,0xd5]
|
|
// CHECK: msr pmselr_el0, x12 // encoding: [0xac,0x9c,0x1b,0xd5]
|
|
// CHECK: msr pmccntr_el0, x12 // encoding: [0x0c,0x9d,0x1b,0xd5]
|
|
// CHECK: msr pmxevtyper_el0, x12 // encoding: [0x2c,0x9d,0x1b,0xd5]
|
|
// CHECK: msr pmxevcntr_el0, x12 // encoding: [0x4c,0x9d,0x1b,0xd5]
|
|
// CHECK: msr pmuserenr_el0, x12 // encoding: [0x0c,0x9e,0x1b,0xd5]
|
|
// CHECK: msr pmintenset_el1, x12 // encoding: [0x2c,0x9e,0x18,0xd5]
|
|
// CHECK: msr pmintenclr_el1, x12 // encoding: [0x4c,0x9e,0x18,0xd5]
|
|
// CHECK: msr pmovsset_el0, x12 // encoding: [0x6c,0x9e,0x1b,0xd5]
|
|
// CHECK: msr mair_el1, x12 // encoding: [0x0c,0xa2,0x18,0xd5]
|
|
// CHECK: msr mair_el2, x12 // encoding: [0x0c,0xa2,0x1c,0xd5]
|
|
// CHECK: msr mair_el3, x12 // encoding: [0x0c,0xa2,0x1e,0xd5]
|
|
// CHECK: msr amair_el1, x12 // encoding: [0x0c,0xa3,0x18,0xd5]
|
|
// CHECK: msr amair_el2, x12 // encoding: [0x0c,0xa3,0x1c,0xd5]
|
|
// CHECK: msr amair_el3, x12 // encoding: [0x0c,0xa3,0x1e,0xd5]
|
|
// CHECK: msr vbar_el1, x12 // encoding: [0x0c,0xc0,0x18,0xd5]
|
|
// CHECK: msr vbar_el2, x12 // encoding: [0x0c,0xc0,0x1c,0xd5]
|
|
// CHECK: msr vbar_el3, x12 // encoding: [0x0c,0xc0,0x1e,0xd5]
|
|
// CHECK: msr rmr_el1, x12 // encoding: [0x4c,0xc0,0x18,0xd5]
|
|
// CHECK: msr rmr_el2, x12 // encoding: [0x4c,0xc0,0x1c,0xd5]
|
|
// CHECK: msr rmr_el3, x12 // encoding: [0x4c,0xc0,0x1e,0xd5]
|
|
// CHECK: msr contextidr_el1, x12 // encoding: [0x2c,0xd0,0x18,0xd5]
|
|
// CHECK: msr tpidr_el0, x12 // encoding: [0x4c,0xd0,0x1b,0xd5]
|
|
// CHECK: msr tpidr_el2, x12 // encoding: [0x4c,0xd0,0x1c,0xd5]
|
|
// CHECK: msr tpidr_el3, x12 // encoding: [0x4c,0xd0,0x1e,0xd5]
|
|
// CHECK: msr tpidrro_el0, x12 // encoding: [0x6c,0xd0,0x1b,0xd5]
|
|
// CHECK: msr tpidr_el1, x12 // encoding: [0x8c,0xd0,0x18,0xd5]
|
|
// CHECK: msr cntfrq_el0, x12 // encoding: [0x0c,0xe0,0x1b,0xd5]
|
|
// CHECK: msr cntvoff_el2, x12 // encoding: [0x6c,0xe0,0x1c,0xd5]
|
|
// CHECK: msr cntkctl_el1, x12 // encoding: [0x0c,0xe1,0x18,0xd5]
|
|
// CHECK: msr cnthctl_el2, x12 // encoding: [0x0c,0xe1,0x1c,0xd5]
|
|
// CHECK: msr cntp_tval_el0, x12 // encoding: [0x0c,0xe2,0x1b,0xd5]
|
|
// CHECK: msr cnthp_tval_el2, x12 // encoding: [0x0c,0xe2,0x1c,0xd5]
|
|
// CHECK: msr cntps_tval_el1, x12 // encoding: [0x0c,0xe2,0x1f,0xd5]
|
|
// CHECK: msr cntp_ctl_el0, x12 // encoding: [0x2c,0xe2,0x1b,0xd5]
|
|
// CHECK: msr cnthp_ctl_el2, x12 // encoding: [0x2c,0xe2,0x1c,0xd5]
|
|
// CHECK: msr cntps_ctl_el1, x12 // encoding: [0x2c,0xe2,0x1f,0xd5]
|
|
// CHECK: msr cntp_cval_el0, x12 // encoding: [0x4c,0xe2,0x1b,0xd5]
|
|
// CHECK: msr cnthp_cval_el2, x12 // encoding: [0x4c,0xe2,0x1c,0xd5]
|
|
// CHECK: msr cntps_cval_el1, x12 // encoding: [0x4c,0xe2,0x1f,0xd5]
|
|
// CHECK: msr cntv_tval_el0, x12 // encoding: [0x0c,0xe3,0x1b,0xd5]
|
|
// CHECK: msr cntv_ctl_el0, x12 // encoding: [0x2c,0xe3,0x1b,0xd5]
|
|
// CHECK: msr cntv_cval_el0, x12 // encoding: [0x4c,0xe3,0x1b,0xd5]
|
|
// CHECK: msr pmevcntr0_el0, x12 // encoding: [0x0c,0xe8,0x1b,0xd5]
|
|
// CHECK: msr pmevcntr1_el0, x12 // encoding: [0x2c,0xe8,0x1b,0xd5]
|
|
// CHECK: msr pmevcntr2_el0, x12 // encoding: [0x4c,0xe8,0x1b,0xd5]
|
|
// CHECK: msr pmevcntr3_el0, x12 // encoding: [0x6c,0xe8,0x1b,0xd5]
|
|
// CHECK: msr pmevcntr4_el0, x12 // encoding: [0x8c,0xe8,0x1b,0xd5]
|
|
// CHECK: msr pmevcntr5_el0, x12 // encoding: [0xac,0xe8,0x1b,0xd5]
|
|
// CHECK: msr pmevcntr6_el0, x12 // encoding: [0xcc,0xe8,0x1b,0xd5]
|
|
// CHECK: msr pmevcntr7_el0, x12 // encoding: [0xec,0xe8,0x1b,0xd5]
|
|
// CHECK: msr pmevcntr8_el0, x12 // encoding: [0x0c,0xe9,0x1b,0xd5]
|
|
// CHECK: msr pmevcntr9_el0, x12 // encoding: [0x2c,0xe9,0x1b,0xd5]
|
|
// CHECK: msr pmevcntr10_el0, x12 // encoding: [0x4c,0xe9,0x1b,0xd5]
|
|
// CHECK: msr pmevcntr11_el0, x12 // encoding: [0x6c,0xe9,0x1b,0xd5]
|
|
// CHECK: msr pmevcntr12_el0, x12 // encoding: [0x8c,0xe9,0x1b,0xd5]
|
|
// CHECK: msr pmevcntr13_el0, x12 // encoding: [0xac,0xe9,0x1b,0xd5]
|
|
// CHECK: msr pmevcntr14_el0, x12 // encoding: [0xcc,0xe9,0x1b,0xd5]
|
|
// CHECK: msr pmevcntr15_el0, x12 // encoding: [0xec,0xe9,0x1b,0xd5]
|
|
// CHECK: msr pmevcntr16_el0, x12 // encoding: [0x0c,0xea,0x1b,0xd5]
|
|
// CHECK: msr pmevcntr17_el0, x12 // encoding: [0x2c,0xea,0x1b,0xd5]
|
|
// CHECK: msr pmevcntr18_el0, x12 // encoding: [0x4c,0xea,0x1b,0xd5]
|
|
// CHECK: msr pmevcntr19_el0, x12 // encoding: [0x6c,0xea,0x1b,0xd5]
|
|
// CHECK: msr pmevcntr20_el0, x12 // encoding: [0x8c,0xea,0x1b,0xd5]
|
|
// CHECK: msr pmevcntr21_el0, x12 // encoding: [0xac,0xea,0x1b,0xd5]
|
|
// CHECK: msr pmevcntr22_el0, x12 // encoding: [0xcc,0xea,0x1b,0xd5]
|
|
// CHECK: msr pmevcntr23_el0, x12 // encoding: [0xec,0xea,0x1b,0xd5]
|
|
// CHECK: msr pmevcntr24_el0, x12 // encoding: [0x0c,0xeb,0x1b,0xd5]
|
|
// CHECK: msr pmevcntr25_el0, x12 // encoding: [0x2c,0xeb,0x1b,0xd5]
|
|
// CHECK: msr pmevcntr26_el0, x12 // encoding: [0x4c,0xeb,0x1b,0xd5]
|
|
// CHECK: msr pmevcntr27_el0, x12 // encoding: [0x6c,0xeb,0x1b,0xd5]
|
|
// CHECK: msr pmevcntr28_el0, x12 // encoding: [0x8c,0xeb,0x1b,0xd5]
|
|
// CHECK: msr pmevcntr29_el0, x12 // encoding: [0xac,0xeb,0x1b,0xd5]
|
|
// CHECK: msr pmevcntr30_el0, x12 // encoding: [0xcc,0xeb,0x1b,0xd5]
|
|
// CHECK: msr pmccfiltr_el0, x12 // encoding: [0xec,0xef,0x1b,0xd5]
|
|
// CHECK: msr pmevtyper0_el0, x12 // encoding: [0x0c,0xec,0x1b,0xd5]
|
|
// CHECK: msr pmevtyper1_el0, x12 // encoding: [0x2c,0xec,0x1b,0xd5]
|
|
// CHECK: msr pmevtyper2_el0, x12 // encoding: [0x4c,0xec,0x1b,0xd5]
|
|
// CHECK: msr pmevtyper3_el0, x12 // encoding: [0x6c,0xec,0x1b,0xd5]
|
|
// CHECK: msr pmevtyper4_el0, x12 // encoding: [0x8c,0xec,0x1b,0xd5]
|
|
// CHECK: msr pmevtyper5_el0, x12 // encoding: [0xac,0xec,0x1b,0xd5]
|
|
// CHECK: msr pmevtyper6_el0, x12 // encoding: [0xcc,0xec,0x1b,0xd5]
|
|
// CHECK: msr pmevtyper7_el0, x12 // encoding: [0xec,0xec,0x1b,0xd5]
|
|
// CHECK: msr pmevtyper8_el0, x12 // encoding: [0x0c,0xed,0x1b,0xd5]
|
|
// CHECK: msr pmevtyper9_el0, x12 // encoding: [0x2c,0xed,0x1b,0xd5]
|
|
// CHECK: msr pmevtyper10_el0, x12 // encoding: [0x4c,0xed,0x1b,0xd5]
|
|
// CHECK: msr pmevtyper11_el0, x12 // encoding: [0x6c,0xed,0x1b,0xd5]
|
|
// CHECK: msr pmevtyper12_el0, x12 // encoding: [0x8c,0xed,0x1b,0xd5]
|
|
// CHECK: msr pmevtyper13_el0, x12 // encoding: [0xac,0xed,0x1b,0xd5]
|
|
// CHECK: msr pmevtyper14_el0, x12 // encoding: [0xcc,0xed,0x1b,0xd5]
|
|
// CHECK: msr pmevtyper15_el0, x12 // encoding: [0xec,0xed,0x1b,0xd5]
|
|
// CHECK: msr pmevtyper16_el0, x12 // encoding: [0x0c,0xee,0x1b,0xd5]
|
|
// CHECK: msr pmevtyper17_el0, x12 // encoding: [0x2c,0xee,0x1b,0xd5]
|
|
// CHECK: msr pmevtyper18_el0, x12 // encoding: [0x4c,0xee,0x1b,0xd5]
|
|
// CHECK: msr pmevtyper19_el0, x12 // encoding: [0x6c,0xee,0x1b,0xd5]
|
|
// CHECK: msr pmevtyper20_el0, x12 // encoding: [0x8c,0xee,0x1b,0xd5]
|
|
// CHECK: msr pmevtyper21_el0, x12 // encoding: [0xac,0xee,0x1b,0xd5]
|
|
// CHECK: msr pmevtyper22_el0, x12 // encoding: [0xcc,0xee,0x1b,0xd5]
|
|
// CHECK: msr pmevtyper23_el0, x12 // encoding: [0xec,0xee,0x1b,0xd5]
|
|
// CHECK: msr pmevtyper24_el0, x12 // encoding: [0x0c,0xef,0x1b,0xd5]
|
|
// CHECK: msr pmevtyper25_el0, x12 // encoding: [0x2c,0xef,0x1b,0xd5]
|
|
// CHECK: msr pmevtyper26_el0, x12 // encoding: [0x4c,0xef,0x1b,0xd5]
|
|
// CHECK: msr pmevtyper27_el0, x12 // encoding: [0x6c,0xef,0x1b,0xd5]
|
|
// CHECK: msr pmevtyper28_el0, x12 // encoding: [0x8c,0xef,0x1b,0xd5]
|
|
// CHECK: msr pmevtyper29_el0, x12 // encoding: [0xac,0xef,0x1b,0xd5]
|
|
// CHECK: msr pmevtyper30_el0, x12 // encoding: [0xcc,0xef,0x1b,0xd5]
|
|
|
|
mrs x9, TEECR32_EL1
|
|
mrs x9, OSDTRRX_EL1
|
|
mrs x9, MDCCSR_EL0
|
|
mrs x9, MDCCINT_EL1
|
|
mrs x9, MDSCR_EL1
|
|
mrs x9, OSDTRTX_EL1
|
|
mrs x9, DBGDTR_EL0
|
|
mrs x9, DBGDTRRX_EL0
|
|
mrs x9, OSECCR_EL1
|
|
mrs x9, DBGVCR32_EL2
|
|
mrs x9, DBGBVR0_EL1
|
|
mrs x9, DBGBVR1_EL1
|
|
mrs x9, DBGBVR2_EL1
|
|
mrs x9, DBGBVR3_EL1
|
|
mrs x9, DBGBVR4_EL1
|
|
mrs x9, DBGBVR5_EL1
|
|
mrs x9, DBGBVR6_EL1
|
|
mrs x9, DBGBVR7_EL1
|
|
mrs x9, DBGBVR8_EL1
|
|
mrs x9, DBGBVR9_EL1
|
|
mrs x9, DBGBVR10_EL1
|
|
mrs x9, DBGBVR11_EL1
|
|
mrs x9, DBGBVR12_EL1
|
|
mrs x9, DBGBVR13_EL1
|
|
mrs x9, DBGBVR14_EL1
|
|
mrs x9, DBGBVR15_EL1
|
|
mrs x9, DBGBCR0_EL1
|
|
mrs x9, DBGBCR1_EL1
|
|
mrs x9, DBGBCR2_EL1
|
|
mrs x9, DBGBCR3_EL1
|
|
mrs x9, DBGBCR4_EL1
|
|
mrs x9, DBGBCR5_EL1
|
|
mrs x9, DBGBCR6_EL1
|
|
mrs x9, DBGBCR7_EL1
|
|
mrs x9, DBGBCR8_EL1
|
|
mrs x9, DBGBCR9_EL1
|
|
mrs x9, DBGBCR10_EL1
|
|
mrs x9, DBGBCR11_EL1
|
|
mrs x9, DBGBCR12_EL1
|
|
mrs x9, DBGBCR13_EL1
|
|
mrs x9, DBGBCR14_EL1
|
|
mrs x9, DBGBCR15_EL1
|
|
mrs x9, DBGWVR0_EL1
|
|
mrs x9, DBGWVR1_EL1
|
|
mrs x9, DBGWVR2_EL1
|
|
mrs x9, DBGWVR3_EL1
|
|
mrs x9, DBGWVR4_EL1
|
|
mrs x9, DBGWVR5_EL1
|
|
mrs x9, DBGWVR6_EL1
|
|
mrs x9, DBGWVR7_EL1
|
|
mrs x9, DBGWVR8_EL1
|
|
mrs x9, DBGWVR9_EL1
|
|
mrs x9, DBGWVR10_EL1
|
|
mrs x9, DBGWVR11_EL1
|
|
mrs x9, DBGWVR12_EL1
|
|
mrs x9, DBGWVR13_EL1
|
|
mrs x9, DBGWVR14_EL1
|
|
mrs x9, DBGWVR15_EL1
|
|
mrs x9, DBGWCR0_EL1
|
|
mrs x9, DBGWCR1_EL1
|
|
mrs x9, DBGWCR2_EL1
|
|
mrs x9, DBGWCR3_EL1
|
|
mrs x9, DBGWCR4_EL1
|
|
mrs x9, DBGWCR5_EL1
|
|
mrs x9, DBGWCR6_EL1
|
|
mrs x9, DBGWCR7_EL1
|
|
mrs x9, DBGWCR8_EL1
|
|
mrs x9, DBGWCR9_EL1
|
|
mrs x9, DBGWCR10_EL1
|
|
mrs x9, DBGWCR11_EL1
|
|
mrs x9, DBGWCR12_EL1
|
|
mrs x9, DBGWCR13_EL1
|
|
mrs x9, DBGWCR14_EL1
|
|
mrs x9, DBGWCR15_EL1
|
|
mrs x9, MDRAR_EL1
|
|
mrs x9, TEEHBR32_EL1
|
|
mrs x9, OSLSR_EL1
|
|
mrs x9, OSDLR_EL1
|
|
mrs x9, DBGPRCR_EL1
|
|
mrs x9, DBGCLAIMSET_EL1
|
|
mrs x9, DBGCLAIMCLR_EL1
|
|
mrs x9, DBGAUTHSTATUS_EL1
|
|
mrs x9, MIDR_EL1
|
|
mrs x9, CCSIDR_EL1
|
|
mrs x9, CSSELR_EL1
|
|
mrs x9, VPIDR_EL2
|
|
mrs x9, CLIDR_EL1
|
|
mrs x9, CTR_EL0
|
|
mrs x9, MPIDR_EL1
|
|
mrs x9, VMPIDR_EL2
|
|
mrs x9, REVIDR_EL1
|
|
mrs x9, AIDR_EL1
|
|
mrs x9, DCZID_EL0
|
|
mrs x9, ID_PFR0_EL1
|
|
mrs x9, ID_PFR1_EL1
|
|
mrs x9, ID_DFR0_EL1
|
|
mrs x9, ID_AFR0_EL1
|
|
mrs x9, ID_MMFR0_EL1
|
|
mrs x9, ID_MMFR1_EL1
|
|
mrs x9, ID_MMFR2_EL1
|
|
mrs x9, ID_MMFR3_EL1
|
|
mrs x9, ID_ISAR0_EL1
|
|
mrs x9, ID_ISAR1_EL1
|
|
mrs x9, ID_ISAR2_EL1
|
|
mrs x9, ID_ISAR3_EL1
|
|
mrs x9, ID_ISAR4_EL1
|
|
mrs x9, ID_ISAR5_EL1
|
|
mrs x9, MVFR0_EL1
|
|
mrs x9, MVFR1_EL1
|
|
mrs x9, MVFR2_EL1
|
|
mrs x9, ID_AA64PFR0_EL1
|
|
mrs x9, ID_AA64PFR1_EL1
|
|
mrs x9, ID_AA64DFR0_EL1
|
|
mrs x9, ID_AA64DFR1_EL1
|
|
mrs x9, ID_AA64AFR0_EL1
|
|
mrs x9, ID_AA64AFR1_EL1
|
|
mrs x9, ID_AA64ISAR0_EL1
|
|
mrs x9, ID_AA64ISAR1_EL1
|
|
mrs x9, ID_AA64MMFR0_EL1
|
|
mrs x9, ID_AA64MMFR1_EL1
|
|
mrs x9, SCTLR_EL1
|
|
mrs x9, SCTLR_EL2
|
|
mrs x9, SCTLR_EL3
|
|
mrs x9, ACTLR_EL1
|
|
mrs x9, ACTLR_EL2
|
|
mrs x9, ACTLR_EL3
|
|
mrs x9, CPACR_EL1
|
|
mrs x9, HCR_EL2
|
|
mrs x9, SCR_EL3
|
|
mrs x9, MDCR_EL2
|
|
mrs x9, SDER32_EL3
|
|
mrs x9, CPTR_EL2
|
|
mrs x9, CPTR_EL3
|
|
mrs x9, HSTR_EL2
|
|
mrs x9, HACR_EL2
|
|
mrs x9, MDCR_EL3
|
|
mrs x9, TTBR0_EL1
|
|
mrs x9, TTBR0_EL2
|
|
mrs x9, TTBR0_EL3
|
|
mrs x9, TTBR1_EL1
|
|
mrs x9, TCR_EL1
|
|
mrs x9, TCR_EL2
|
|
mrs x9, TCR_EL3
|
|
mrs x9, VTTBR_EL2
|
|
mrs x9, VTCR_EL2
|
|
mrs x9, DACR32_EL2
|
|
mrs x9, SPSR_EL1
|
|
mrs x9, SPSR_EL2
|
|
mrs x9, SPSR_EL3
|
|
mrs x9, ELR_EL1
|
|
mrs x9, ELR_EL2
|
|
mrs x9, ELR_EL3
|
|
mrs x9, SP_EL0
|
|
mrs x9, SP_EL1
|
|
mrs x9, SP_EL2
|
|
mrs x9, SPSel
|
|
mrs x9, NZCV
|
|
mrs x9, DAIF
|
|
mrs x9, CurrentEL
|
|
mrs x9, SPSR_irq
|
|
mrs x9, SPSR_abt
|
|
mrs x9, SPSR_und
|
|
mrs x9, SPSR_fiq
|
|
mrs x9, FPCR
|
|
mrs x9, FPSR
|
|
mrs x9, DSPSR_EL0
|
|
mrs x9, DLR_EL0
|
|
mrs x9, IFSR32_EL2
|
|
mrs x9, AFSR0_EL1
|
|
mrs x9, AFSR0_EL2
|
|
mrs x9, AFSR0_EL3
|
|
mrs x9, AFSR1_EL1
|
|
mrs x9, AFSR1_EL2
|
|
mrs x9, AFSR1_EL3
|
|
mrs x9, ESR_EL1
|
|
mrs x9, ESR_EL2
|
|
mrs x9, ESR_EL3
|
|
mrs x9, FPEXC32_EL2
|
|
mrs x9, FAR_EL1
|
|
mrs x9, FAR_EL2
|
|
mrs x9, FAR_EL3
|
|
mrs x9, HPFAR_EL2
|
|
mrs x9, PAR_EL1
|
|
mrs x9, PMCR_EL0
|
|
mrs x9, PMCNTENSET_EL0
|
|
mrs x9, PMCNTENCLR_EL0
|
|
mrs x9, PMOVSCLR_EL0
|
|
mrs x9, PMSELR_EL0
|
|
mrs x9, PMCEID0_EL0
|
|
mrs x9, PMCEID1_EL0
|
|
mrs x9, PMCCNTR_EL0
|
|
mrs x9, PMXEVTYPER_EL0
|
|
mrs x9, PMXEVCNTR_EL0
|
|
mrs x9, PMUSERENR_EL0
|
|
mrs x9, PMINTENSET_EL1
|
|
mrs x9, PMINTENCLR_EL1
|
|
mrs x9, PMOVSSET_EL0
|
|
mrs x9, MAIR_EL1
|
|
mrs x9, MAIR_EL2
|
|
mrs x9, MAIR_EL3
|
|
mrs x9, AMAIR_EL1
|
|
mrs x9, AMAIR_EL2
|
|
mrs x9, AMAIR_EL3
|
|
mrs x9, VBAR_EL1
|
|
mrs x9, VBAR_EL2
|
|
mrs x9, VBAR_EL3
|
|
mrs x9, RVBAR_EL1
|
|
mrs x9, RVBAR_EL2
|
|
mrs x9, RVBAR_EL3
|
|
mrs x9, RMR_EL1
|
|
mrs x9, RMR_EL2
|
|
mrs x9, RMR_EL3
|
|
mrs x9, ISR_EL1
|
|
mrs x9, CONTEXTIDR_EL1
|
|
mrs x9, TPIDR_EL0
|
|
mrs x9, TPIDR_EL2
|
|
mrs x9, TPIDR_EL3
|
|
mrs x9, TPIDRRO_EL0
|
|
mrs x9, TPIDR_EL1
|
|
mrs x9, CNTFRQ_EL0
|
|
mrs x9, CNTPCT_EL0
|
|
mrs x9, CNTVCT_EL0
|
|
mrs x9, CNTVOFF_EL2
|
|
mrs x9, CNTKCTL_EL1
|
|
mrs x9, CNTHCTL_EL2
|
|
mrs x9, CNTP_TVAL_EL0
|
|
mrs x9, CNTHP_TVAL_EL2
|
|
mrs x9, CNTPS_TVAL_EL1
|
|
mrs x9, CNTP_CTL_EL0
|
|
mrs x9, CNTHP_CTL_EL2
|
|
mrs x9, CNTPS_CTL_EL1
|
|
mrs x9, CNTP_CVAL_EL0
|
|
mrs x9, CNTHP_CVAL_EL2
|
|
mrs x9, CNTPS_CVAL_EL1
|
|
mrs x9, CNTV_TVAL_EL0
|
|
mrs x9, CNTV_CTL_EL0
|
|
mrs x9, CNTV_CVAL_EL0
|
|
mrs x9, PMEVCNTR0_EL0
|
|
mrs x9, PMEVCNTR1_EL0
|
|
mrs x9, PMEVCNTR2_EL0
|
|
mrs x9, PMEVCNTR3_EL0
|
|
mrs x9, PMEVCNTR4_EL0
|
|
mrs x9, PMEVCNTR5_EL0
|
|
mrs x9, PMEVCNTR6_EL0
|
|
mrs x9, PMEVCNTR7_EL0
|
|
mrs x9, PMEVCNTR8_EL0
|
|
mrs x9, PMEVCNTR9_EL0
|
|
mrs x9, PMEVCNTR10_EL0
|
|
mrs x9, PMEVCNTR11_EL0
|
|
mrs x9, PMEVCNTR12_EL0
|
|
mrs x9, PMEVCNTR13_EL0
|
|
mrs x9, PMEVCNTR14_EL0
|
|
mrs x9, PMEVCNTR15_EL0
|
|
mrs x9, PMEVCNTR16_EL0
|
|
mrs x9, PMEVCNTR17_EL0
|
|
mrs x9, PMEVCNTR18_EL0
|
|
mrs x9, PMEVCNTR19_EL0
|
|
mrs x9, PMEVCNTR20_EL0
|
|
mrs x9, PMEVCNTR21_EL0
|
|
mrs x9, PMEVCNTR22_EL0
|
|
mrs x9, PMEVCNTR23_EL0
|
|
mrs x9, PMEVCNTR24_EL0
|
|
mrs x9, PMEVCNTR25_EL0
|
|
mrs x9, PMEVCNTR26_EL0
|
|
mrs x9, PMEVCNTR27_EL0
|
|
mrs x9, PMEVCNTR28_EL0
|
|
mrs x9, PMEVCNTR29_EL0
|
|
mrs x9, PMEVCNTR30_EL0
|
|
mrs x9, PMCCFILTR_EL0
|
|
mrs x9, PMEVTYPER0_EL0
|
|
mrs x9, PMEVTYPER1_EL0
|
|
mrs x9, PMEVTYPER2_EL0
|
|
mrs x9, PMEVTYPER3_EL0
|
|
mrs x9, PMEVTYPER4_EL0
|
|
mrs x9, PMEVTYPER5_EL0
|
|
mrs x9, PMEVTYPER6_EL0
|
|
mrs x9, PMEVTYPER7_EL0
|
|
mrs x9, PMEVTYPER8_EL0
|
|
mrs x9, PMEVTYPER9_EL0
|
|
mrs x9, PMEVTYPER10_EL0
|
|
mrs x9, PMEVTYPER11_EL0
|
|
mrs x9, PMEVTYPER12_EL0
|
|
mrs x9, PMEVTYPER13_EL0
|
|
mrs x9, PMEVTYPER14_EL0
|
|
mrs x9, PMEVTYPER15_EL0
|
|
mrs x9, PMEVTYPER16_EL0
|
|
mrs x9, PMEVTYPER17_EL0
|
|
mrs x9, PMEVTYPER18_EL0
|
|
mrs x9, PMEVTYPER19_EL0
|
|
mrs x9, PMEVTYPER20_EL0
|
|
mrs x9, PMEVTYPER21_EL0
|
|
mrs x9, PMEVTYPER22_EL0
|
|
mrs x9, PMEVTYPER23_EL0
|
|
mrs x9, PMEVTYPER24_EL0
|
|
mrs x9, PMEVTYPER25_EL0
|
|
mrs x9, PMEVTYPER26_EL0
|
|
mrs x9, PMEVTYPER27_EL0
|
|
mrs x9, PMEVTYPER28_EL0
|
|
mrs x9, PMEVTYPER29_EL0
|
|
mrs x9, PMEVTYPER30_EL0
|
|
// CHECK: mrs x9, teecr32_el1 // encoding: [0x09,0x00,0x32,0xd5]
|
|
// CHECK: mrs x9, osdtrrx_el1 // encoding: [0x49,0x00,0x30,0xd5]
|
|
// CHECK: mrs x9, mdccsr_el0 // encoding: [0x09,0x01,0x33,0xd5]
|
|
// CHECK: mrs x9, mdccint_el1 // encoding: [0x09,0x02,0x30,0xd5]
|
|
// CHECK: mrs x9, mdscr_el1 // encoding: [0x49,0x02,0x30,0xd5]
|
|
// CHECK: mrs x9, osdtrtx_el1 // encoding: [0x49,0x03,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgdtr_el0 // encoding: [0x09,0x04,0x33,0xd5]
|
|
// CHECK: mrs x9, dbgdtrrx_el0 // encoding: [0x09,0x05,0x33,0xd5]
|
|
// CHECK: mrs x9, oseccr_el1 // encoding: [0x49,0x06,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgvcr32_el2 // encoding: [0x09,0x07,0x34,0xd5]
|
|
// CHECK: mrs x9, dbgbvr0_el1 // encoding: [0x89,0x00,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgbvr1_el1 // encoding: [0x89,0x01,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgbvr2_el1 // encoding: [0x89,0x02,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgbvr3_el1 // encoding: [0x89,0x03,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgbvr4_el1 // encoding: [0x89,0x04,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgbvr5_el1 // encoding: [0x89,0x05,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgbvr6_el1 // encoding: [0x89,0x06,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgbvr7_el1 // encoding: [0x89,0x07,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgbvr8_el1 // encoding: [0x89,0x08,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgbvr9_el1 // encoding: [0x89,0x09,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgbvr10_el1 // encoding: [0x89,0x0a,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgbvr11_el1 // encoding: [0x89,0x0b,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgbvr12_el1 // encoding: [0x89,0x0c,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgbvr13_el1 // encoding: [0x89,0x0d,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgbvr14_el1 // encoding: [0x89,0x0e,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgbvr15_el1 // encoding: [0x89,0x0f,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgbcr0_el1 // encoding: [0xa9,0x00,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgbcr1_el1 // encoding: [0xa9,0x01,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgbcr2_el1 // encoding: [0xa9,0x02,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgbcr3_el1 // encoding: [0xa9,0x03,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgbcr4_el1 // encoding: [0xa9,0x04,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgbcr5_el1 // encoding: [0xa9,0x05,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgbcr6_el1 // encoding: [0xa9,0x06,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgbcr7_el1 // encoding: [0xa9,0x07,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgbcr8_el1 // encoding: [0xa9,0x08,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgbcr9_el1 // encoding: [0xa9,0x09,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgbcr10_el1 // encoding: [0xa9,0x0a,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgbcr11_el1 // encoding: [0xa9,0x0b,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgbcr12_el1 // encoding: [0xa9,0x0c,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgbcr13_el1 // encoding: [0xa9,0x0d,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgbcr14_el1 // encoding: [0xa9,0x0e,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgbcr15_el1 // encoding: [0xa9,0x0f,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgwvr0_el1 // encoding: [0xc9,0x00,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgwvr1_el1 // encoding: [0xc9,0x01,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgwvr2_el1 // encoding: [0xc9,0x02,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgwvr3_el1 // encoding: [0xc9,0x03,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgwvr4_el1 // encoding: [0xc9,0x04,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgwvr5_el1 // encoding: [0xc9,0x05,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgwvr6_el1 // encoding: [0xc9,0x06,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgwvr7_el1 // encoding: [0xc9,0x07,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgwvr8_el1 // encoding: [0xc9,0x08,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgwvr9_el1 // encoding: [0xc9,0x09,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgwvr10_el1 // encoding: [0xc9,0x0a,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgwvr11_el1 // encoding: [0xc9,0x0b,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgwvr12_el1 // encoding: [0xc9,0x0c,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgwvr13_el1 // encoding: [0xc9,0x0d,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgwvr14_el1 // encoding: [0xc9,0x0e,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgwvr15_el1 // encoding: [0xc9,0x0f,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgwcr0_el1 // encoding: [0xe9,0x00,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgwcr1_el1 // encoding: [0xe9,0x01,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgwcr2_el1 // encoding: [0xe9,0x02,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgwcr3_el1 // encoding: [0xe9,0x03,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgwcr4_el1 // encoding: [0xe9,0x04,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgwcr5_el1 // encoding: [0xe9,0x05,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgwcr6_el1 // encoding: [0xe9,0x06,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgwcr7_el1 // encoding: [0xe9,0x07,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgwcr8_el1 // encoding: [0xe9,0x08,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgwcr9_el1 // encoding: [0xe9,0x09,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgwcr10_el1 // encoding: [0xe9,0x0a,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgwcr11_el1 // encoding: [0xe9,0x0b,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgwcr12_el1 // encoding: [0xe9,0x0c,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgwcr13_el1 // encoding: [0xe9,0x0d,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgwcr14_el1 // encoding: [0xe9,0x0e,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgwcr15_el1 // encoding: [0xe9,0x0f,0x30,0xd5]
|
|
// CHECK: mrs x9, mdrar_el1 // encoding: [0x09,0x10,0x30,0xd5]
|
|
// CHECK: mrs x9, teehbr32_el1 // encoding: [0x09,0x10,0x32,0xd5]
|
|
// CHECK: mrs x9, oslsr_el1 // encoding: [0x89,0x11,0x30,0xd5]
|
|
// CHECK: mrs x9, osdlr_el1 // encoding: [0x89,0x13,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgprcr_el1 // encoding: [0x89,0x14,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgclaimset_el1 // encoding: [0xc9,0x78,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgclaimclr_el1 // encoding: [0xc9,0x79,0x30,0xd5]
|
|
// CHECK: mrs x9, dbgauthstatus_el1 // encoding: [0xc9,0x7e,0x30,0xd5]
|
|
// CHECK: mrs x9, midr_el1 // encoding: [0x09,0x00,0x38,0xd5]
|
|
// CHECK: mrs x9, ccsidr_el1 // encoding: [0x09,0x00,0x39,0xd5]
|
|
// CHECK: mrs x9, csselr_el1 // encoding: [0x09,0x00,0x3a,0xd5]
|
|
// CHECK: mrs x9, vpidr_el2 // encoding: [0x09,0x00,0x3c,0xd5]
|
|
// CHECK: mrs x9, clidr_el1 // encoding: [0x29,0x00,0x39,0xd5]
|
|
// CHECK: mrs x9, ctr_el0 // encoding: [0x29,0x00,0x3b,0xd5]
|
|
// CHECK: mrs x9, mpidr_el1 // encoding: [0xa9,0x00,0x38,0xd5]
|
|
// CHECK: mrs x9, vmpidr_el2 // encoding: [0xa9,0x00,0x3c,0xd5]
|
|
// CHECK: mrs x9, revidr_el1 // encoding: [0xc9,0x00,0x38,0xd5]
|
|
// CHECK: mrs x9, aidr_el1 // encoding: [0xe9,0x00,0x39,0xd5]
|
|
// CHECK: mrs x9, dczid_el0 // encoding: [0xe9,0x00,0x3b,0xd5]
|
|
// CHECK: mrs x9, id_pfr0_el1 // encoding: [0x09,0x01,0x38,0xd5]
|
|
// CHECK: mrs x9, id_pfr1_el1 // encoding: [0x29,0x01,0x38,0xd5]
|
|
// CHECK: mrs x9, id_dfr0_el1 // encoding: [0x49,0x01,0x38,0xd5]
|
|
// CHECK: mrs x9, id_afr0_el1 // encoding: [0x69,0x01,0x38,0xd5]
|
|
// CHECK: mrs x9, id_mmfr0_el1 // encoding: [0x89,0x01,0x38,0xd5]
|
|
// CHECK: mrs x9, id_mmfr1_el1 // encoding: [0xa9,0x01,0x38,0xd5]
|
|
// CHECK: mrs x9, id_mmfr2_el1 // encoding: [0xc9,0x01,0x38,0xd5]
|
|
// CHECK: mrs x9, id_mmfr3_el1 // encoding: [0xe9,0x01,0x38,0xd5]
|
|
// CHECK: mrs x9, id_isar0_el1 // encoding: [0x09,0x02,0x38,0xd5]
|
|
// CHECK: mrs x9, id_isar1_el1 // encoding: [0x29,0x02,0x38,0xd5]
|
|
// CHECK: mrs x9, id_isar2_el1 // encoding: [0x49,0x02,0x38,0xd5]
|
|
// CHECK: mrs x9, id_isar3_el1 // encoding: [0x69,0x02,0x38,0xd5]
|
|
// CHECK: mrs x9, id_isar4_el1 // encoding: [0x89,0x02,0x38,0xd5]
|
|
// CHECK: mrs x9, id_isar5_el1 // encoding: [0xa9,0x02,0x38,0xd5]
|
|
// CHECK: mrs x9, mvfr0_el1 // encoding: [0x09,0x03,0x38,0xd5]
|
|
// CHECK: mrs x9, mvfr1_el1 // encoding: [0x29,0x03,0x38,0xd5]
|
|
// CHECK: mrs x9, mvfr2_el1 // encoding: [0x49,0x03,0x38,0xd5]
|
|
// CHECK: mrs x9, id_aa64pfr0_el1 // encoding: [0x09,0x04,0x38,0xd5]
|
|
// CHECK: mrs x9, id_aa64pfr1_el1 // encoding: [0x29,0x04,0x38,0xd5]
|
|
// CHECK: mrs x9, id_aa64dfr0_el1 // encoding: [0x09,0x05,0x38,0xd5]
|
|
// CHECK: mrs x9, id_aa64dfr1_el1 // encoding: [0x29,0x05,0x38,0xd5]
|
|
// CHECK: mrs x9, id_aa64afr0_el1 // encoding: [0x89,0x05,0x38,0xd5]
|
|
// CHECK: mrs x9, id_aa64afr1_el1 // encoding: [0xa9,0x05,0x38,0xd5]
|
|
// CHECK: mrs x9, id_aa64isar0_el1 // encoding: [0x09,0x06,0x38,0xd5]
|
|
// CHECK: mrs x9, id_aa64isar1_el1 // encoding: [0x29,0x06,0x38,0xd5]
|
|
// CHECK: mrs x9, id_aa64mmfr0_el1 // encoding: [0x09,0x07,0x38,0xd5]
|
|
// CHECK: mrs x9, id_aa64mmfr1_el1 // encoding: [0x29,0x07,0x38,0xd5]
|
|
// CHECK: mrs x9, sctlr_el1 // encoding: [0x09,0x10,0x38,0xd5]
|
|
// CHECK: mrs x9, sctlr_el2 // encoding: [0x09,0x10,0x3c,0xd5]
|
|
// CHECK: mrs x9, sctlr_el3 // encoding: [0x09,0x10,0x3e,0xd5]
|
|
// CHECK: mrs x9, actlr_el1 // encoding: [0x29,0x10,0x38,0xd5]
|
|
// CHECK: mrs x9, actlr_el2 // encoding: [0x29,0x10,0x3c,0xd5]
|
|
// CHECK: mrs x9, actlr_el3 // encoding: [0x29,0x10,0x3e,0xd5]
|
|
// CHECK: mrs x9, cpacr_el1 // encoding: [0x49,0x10,0x38,0xd5]
|
|
// CHECK: mrs x9, hcr_el2 // encoding: [0x09,0x11,0x3c,0xd5]
|
|
// CHECK: mrs x9, scr_el3 // encoding: [0x09,0x11,0x3e,0xd5]
|
|
// CHECK: mrs x9, mdcr_el2 // encoding: [0x29,0x11,0x3c,0xd5]
|
|
// CHECK: mrs x9, sder32_el3 // encoding: [0x29,0x11,0x3e,0xd5]
|
|
// CHECK: mrs x9, cptr_el2 // encoding: [0x49,0x11,0x3c,0xd5]
|
|
// CHECK: mrs x9, cptr_el3 // encoding: [0x49,0x11,0x3e,0xd5]
|
|
// CHECK: mrs x9, hstr_el2 // encoding: [0x69,0x11,0x3c,0xd5]
|
|
// CHECK: mrs x9, hacr_el2 // encoding: [0xe9,0x11,0x3c,0xd5]
|
|
// CHECK: mrs x9, mdcr_el3 // encoding: [0x29,0x13,0x3e,0xd5]
|
|
// CHECK: mrs x9, ttbr0_el1 // encoding: [0x09,0x20,0x38,0xd5]
|
|
// CHECK: mrs x9, ttbr0_el2 // encoding: [0x09,0x20,0x3c,0xd5]
|
|
// CHECK: mrs x9, ttbr0_el3 // encoding: [0x09,0x20,0x3e,0xd5]
|
|
// CHECK: mrs x9, ttbr1_el1 // encoding: [0x29,0x20,0x38,0xd5]
|
|
// CHECK: mrs x9, tcr_el1 // encoding: [0x49,0x20,0x38,0xd5]
|
|
// CHECK: mrs x9, tcr_el2 // encoding: [0x49,0x20,0x3c,0xd5]
|
|
// CHECK: mrs x9, tcr_el3 // encoding: [0x49,0x20,0x3e,0xd5]
|
|
// CHECK: mrs x9, vttbr_el2 // encoding: [0x09,0x21,0x3c,0xd5]
|
|
// CHECK: mrs x9, vtcr_el2 // encoding: [0x49,0x21,0x3c,0xd5]
|
|
// CHECK: mrs x9, dacr32_el2 // encoding: [0x09,0x30,0x3c,0xd5]
|
|
// CHECK: mrs x9, spsr_el1 // encoding: [0x09,0x40,0x38,0xd5]
|
|
// CHECK: mrs x9, spsr_el2 // encoding: [0x09,0x40,0x3c,0xd5]
|
|
// CHECK: mrs x9, spsr_el3 // encoding: [0x09,0x40,0x3e,0xd5]
|
|
// CHECK: mrs x9, elr_el1 // encoding: [0x29,0x40,0x38,0xd5]
|
|
// CHECK: mrs x9, elr_el2 // encoding: [0x29,0x40,0x3c,0xd5]
|
|
// CHECK: mrs x9, elr_el3 // encoding: [0x29,0x40,0x3e,0xd5]
|
|
// CHECK: mrs x9, sp_el0 // encoding: [0x09,0x41,0x38,0xd5]
|
|
// CHECK: mrs x9, sp_el1 // encoding: [0x09,0x41,0x3c,0xd5]
|
|
// CHECK: mrs x9, sp_el2 // encoding: [0x09,0x41,0x3e,0xd5]
|
|
// CHECK: mrs x9, spsel // encoding: [0x09,0x42,0x38,0xd5]
|
|
// CHECK: mrs x9, nzcv // encoding: [0x09,0x42,0x3b,0xd5]
|
|
// CHECK: mrs x9, daif // encoding: [0x29,0x42,0x3b,0xd5]
|
|
// CHECK: mrs x9, currentel // encoding: [0x49,0x42,0x38,0xd5]
|
|
// CHECK: mrs x9, spsr_irq // encoding: [0x09,0x43,0x3c,0xd5]
|
|
// CHECK: mrs x9, spsr_abt // encoding: [0x29,0x43,0x3c,0xd5]
|
|
// CHECK: mrs x9, spsr_und // encoding: [0x49,0x43,0x3c,0xd5]
|
|
// CHECK: mrs x9, spsr_fiq // encoding: [0x69,0x43,0x3c,0xd5]
|
|
// CHECK: mrs x9, fpcr // encoding: [0x09,0x44,0x3b,0xd5]
|
|
// CHECK: mrs x9, fpsr // encoding: [0x29,0x44,0x3b,0xd5]
|
|
// CHECK: mrs x9, dspsr_el0 // encoding: [0x09,0x45,0x3b,0xd5]
|
|
// CHECK: mrs x9, dlr_el0 // encoding: [0x29,0x45,0x3b,0xd5]
|
|
// CHECK: mrs x9, ifsr32_el2 // encoding: [0x29,0x50,0x3c,0xd5]
|
|
// CHECK: mrs x9, afsr0_el1 // encoding: [0x09,0x51,0x38,0xd5]
|
|
// CHECK: mrs x9, afsr0_el2 // encoding: [0x09,0x51,0x3c,0xd5]
|
|
// CHECK: mrs x9, afsr0_el3 // encoding: [0x09,0x51,0x3e,0xd5]
|
|
// CHECK: mrs x9, afsr1_el1 // encoding: [0x29,0x51,0x38,0xd5]
|
|
// CHECK: mrs x9, afsr1_el2 // encoding: [0x29,0x51,0x3c,0xd5]
|
|
// CHECK: mrs x9, afsr1_el3 // encoding: [0x29,0x51,0x3e,0xd5]
|
|
// CHECK: mrs x9, esr_el1 // encoding: [0x09,0x52,0x38,0xd5]
|
|
// CHECK: mrs x9, esr_el2 // encoding: [0x09,0x52,0x3c,0xd5]
|
|
// CHECK: mrs x9, esr_el3 // encoding: [0x09,0x52,0x3e,0xd5]
|
|
// CHECK: mrs x9, fpexc32_el2 // encoding: [0x09,0x53,0x3c,0xd5]
|
|
// CHECK: mrs x9, far_el1 // encoding: [0x09,0x60,0x38,0xd5]
|
|
// CHECK: mrs x9, far_el2 // encoding: [0x09,0x60,0x3c,0xd5]
|
|
// CHECK: mrs x9, far_el3 // encoding: [0x09,0x60,0x3e,0xd5]
|
|
// CHECK: mrs x9, hpfar_el2 // encoding: [0x89,0x60,0x3c,0xd5]
|
|
// CHECK: mrs x9, par_el1 // encoding: [0x09,0x74,0x38,0xd5]
|
|
// CHECK: mrs x9, pmcr_el0 // encoding: [0x09,0x9c,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmcntenset_el0 // encoding: [0x29,0x9c,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmcntenclr_el0 // encoding: [0x49,0x9c,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmovsclr_el0 // encoding: [0x69,0x9c,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmselr_el0 // encoding: [0xa9,0x9c,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmceid0_el0 // encoding: [0xc9,0x9c,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmceid1_el0 // encoding: [0xe9,0x9c,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmccntr_el0 // encoding: [0x09,0x9d,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmxevtyper_el0 // encoding: [0x29,0x9d,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmxevcntr_el0 // encoding: [0x49,0x9d,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmuserenr_el0 // encoding: [0x09,0x9e,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmintenset_el1 // encoding: [0x29,0x9e,0x38,0xd5]
|
|
// CHECK: mrs x9, pmintenclr_el1 // encoding: [0x49,0x9e,0x38,0xd5]
|
|
// CHECK: mrs x9, pmovsset_el0 // encoding: [0x69,0x9e,0x3b,0xd5]
|
|
// CHECK: mrs x9, mair_el1 // encoding: [0x09,0xa2,0x38,0xd5]
|
|
// CHECK: mrs x9, mair_el2 // encoding: [0x09,0xa2,0x3c,0xd5]
|
|
// CHECK: mrs x9, mair_el3 // encoding: [0x09,0xa2,0x3e,0xd5]
|
|
// CHECK: mrs x9, amair_el1 // encoding: [0x09,0xa3,0x38,0xd5]
|
|
// CHECK: mrs x9, amair_el2 // encoding: [0x09,0xa3,0x3c,0xd5]
|
|
// CHECK: mrs x9, amair_el3 // encoding: [0x09,0xa3,0x3e,0xd5]
|
|
// CHECK: mrs x9, vbar_el1 // encoding: [0x09,0xc0,0x38,0xd5]
|
|
// CHECK: mrs x9, vbar_el2 // encoding: [0x09,0xc0,0x3c,0xd5]
|
|
// CHECK: mrs x9, vbar_el3 // encoding: [0x09,0xc0,0x3e,0xd5]
|
|
// CHECK: mrs x9, rvbar_el1 // encoding: [0x29,0xc0,0x38,0xd5]
|
|
// CHECK: mrs x9, rvbar_el2 // encoding: [0x29,0xc0,0x3c,0xd5]
|
|
// CHECK: mrs x9, rvbar_el3 // encoding: [0x29,0xc0,0x3e,0xd5]
|
|
// CHECK: mrs x9, rmr_el1 // encoding: [0x49,0xc0,0x38,0xd5]
|
|
// CHECK: mrs x9, rmr_el2 // encoding: [0x49,0xc0,0x3c,0xd5]
|
|
// CHECK: mrs x9, rmr_el3 // encoding: [0x49,0xc0,0x3e,0xd5]
|
|
// CHECK: mrs x9, isr_el1 // encoding: [0x09,0xc1,0x38,0xd5]
|
|
// CHECK: mrs x9, contextidr_el1 // encoding: [0x29,0xd0,0x38,0xd5]
|
|
// CHECK: mrs x9, tpidr_el0 // encoding: [0x49,0xd0,0x3b,0xd5]
|
|
// CHECK: mrs x9, tpidr_el2 // encoding: [0x49,0xd0,0x3c,0xd5]
|
|
// CHECK: mrs x9, tpidr_el3 // encoding: [0x49,0xd0,0x3e,0xd5]
|
|
// CHECK: mrs x9, tpidrro_el0 // encoding: [0x69,0xd0,0x3b,0xd5]
|
|
// CHECK: mrs x9, tpidr_el1 // encoding: [0x89,0xd0,0x38,0xd5]
|
|
// CHECK: mrs x9, cntfrq_el0 // encoding: [0x09,0xe0,0x3b,0xd5]
|
|
// CHECK: mrs x9, cntpct_el0 // encoding: [0x29,0xe0,0x3b,0xd5]
|
|
// CHECK: mrs x9, cntvct_el0 // encoding: [0x49,0xe0,0x3b,0xd5]
|
|
// CHECK: mrs x9, cntvoff_el2 // encoding: [0x69,0xe0,0x3c,0xd5]
|
|
// CHECK: mrs x9, cntkctl_el1 // encoding: [0x09,0xe1,0x38,0xd5]
|
|
// CHECK: mrs x9, cnthctl_el2 // encoding: [0x09,0xe1,0x3c,0xd5]
|
|
// CHECK: mrs x9, cntp_tval_el0 // encoding: [0x09,0xe2,0x3b,0xd5]
|
|
// CHECK: mrs x9, cnthp_tval_el2 // encoding: [0x09,0xe2,0x3c,0xd5]
|
|
// CHECK: mrs x9, cntps_tval_el1 // encoding: [0x09,0xe2,0x3f,0xd5]
|
|
// CHECK: mrs x9, cntp_ctl_el0 // encoding: [0x29,0xe2,0x3b,0xd5]
|
|
// CHECK: mrs x9, cnthp_ctl_el2 // encoding: [0x29,0xe2,0x3c,0xd5]
|
|
// CHECK: mrs x9, cntps_ctl_el1 // encoding: [0x29,0xe2,0x3f,0xd5]
|
|
// CHECK: mrs x9, cntp_cval_el0 // encoding: [0x49,0xe2,0x3b,0xd5]
|
|
// CHECK: mrs x9, cnthp_cval_el2 // encoding: [0x49,0xe2,0x3c,0xd5]
|
|
// CHECK: mrs x9, cntps_cval_el1 // encoding: [0x49,0xe2,0x3f,0xd5]
|
|
// CHECK: mrs x9, cntv_tval_el0 // encoding: [0x09,0xe3,0x3b,0xd5]
|
|
// CHECK: mrs x9, cntv_ctl_el0 // encoding: [0x29,0xe3,0x3b,0xd5]
|
|
// CHECK: mrs x9, cntv_cval_el0 // encoding: [0x49,0xe3,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevcntr0_el0 // encoding: [0x09,0xe8,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevcntr1_el0 // encoding: [0x29,0xe8,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevcntr2_el0 // encoding: [0x49,0xe8,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevcntr3_el0 // encoding: [0x69,0xe8,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevcntr4_el0 // encoding: [0x89,0xe8,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevcntr5_el0 // encoding: [0xa9,0xe8,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevcntr6_el0 // encoding: [0xc9,0xe8,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevcntr7_el0 // encoding: [0xe9,0xe8,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevcntr8_el0 // encoding: [0x09,0xe9,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevcntr9_el0 // encoding: [0x29,0xe9,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevcntr10_el0 // encoding: [0x49,0xe9,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevcntr11_el0 // encoding: [0x69,0xe9,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevcntr12_el0 // encoding: [0x89,0xe9,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevcntr13_el0 // encoding: [0xa9,0xe9,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevcntr14_el0 // encoding: [0xc9,0xe9,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevcntr15_el0 // encoding: [0xe9,0xe9,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevcntr16_el0 // encoding: [0x09,0xea,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevcntr17_el0 // encoding: [0x29,0xea,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevcntr18_el0 // encoding: [0x49,0xea,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevcntr19_el0 // encoding: [0x69,0xea,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevcntr20_el0 // encoding: [0x89,0xea,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevcntr21_el0 // encoding: [0xa9,0xea,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevcntr22_el0 // encoding: [0xc9,0xea,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevcntr23_el0 // encoding: [0xe9,0xea,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevcntr24_el0 // encoding: [0x09,0xeb,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevcntr25_el0 // encoding: [0x29,0xeb,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevcntr26_el0 // encoding: [0x49,0xeb,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevcntr27_el0 // encoding: [0x69,0xeb,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevcntr28_el0 // encoding: [0x89,0xeb,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevcntr29_el0 // encoding: [0xa9,0xeb,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevcntr30_el0 // encoding: [0xc9,0xeb,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmccfiltr_el0 // encoding: [0xe9,0xef,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevtyper0_el0 // encoding: [0x09,0xec,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevtyper1_el0 // encoding: [0x29,0xec,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevtyper2_el0 // encoding: [0x49,0xec,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevtyper3_el0 // encoding: [0x69,0xec,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevtyper4_el0 // encoding: [0x89,0xec,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevtyper5_el0 // encoding: [0xa9,0xec,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevtyper6_el0 // encoding: [0xc9,0xec,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevtyper7_el0 // encoding: [0xe9,0xec,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevtyper8_el0 // encoding: [0x09,0xed,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevtyper9_el0 // encoding: [0x29,0xed,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevtyper10_el0 // encoding: [0x49,0xed,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevtyper11_el0 // encoding: [0x69,0xed,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevtyper12_el0 // encoding: [0x89,0xed,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevtyper13_el0 // encoding: [0xa9,0xed,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevtyper14_el0 // encoding: [0xc9,0xed,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevtyper15_el0 // encoding: [0xe9,0xed,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevtyper16_el0 // encoding: [0x09,0xee,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevtyper17_el0 // encoding: [0x29,0xee,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevtyper18_el0 // encoding: [0x49,0xee,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevtyper19_el0 // encoding: [0x69,0xee,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevtyper20_el0 // encoding: [0x89,0xee,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevtyper21_el0 // encoding: [0xa9,0xee,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevtyper22_el0 // encoding: [0xc9,0xee,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevtyper23_el0 // encoding: [0xe9,0xee,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevtyper24_el0 // encoding: [0x09,0xef,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevtyper25_el0 // encoding: [0x29,0xef,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevtyper26_el0 // encoding: [0x49,0xef,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevtyper27_el0 // encoding: [0x69,0xef,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevtyper28_el0 // encoding: [0x89,0xef,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevtyper29_el0 // encoding: [0xa9,0xef,0x3b,0xd5]
|
|
// CHECK: mrs x9, pmevtyper30_el0 // encoding: [0xc9,0xef,0x3b,0xd5]
|
|
|
|
mrs x12, s3_7_c15_c1_5
|
|
mrs x13, s3_2_c11_c15_7
|
|
msr s3_0_c15_c0_0, x12
|
|
msr s3_7_c11_c13_7, x5
|
|
// CHECK: mrs x12, s3_7_c15_c1_5 // encoding: [0xac,0xf1,0x3f,0xd5]
|
|
// CHECK: mrs x13, s3_2_c11_c15_7 // encoding: [0xed,0xbf,0x3a,0xd5]
|
|
// CHECK: msr s3_0_c15_c0_0, x12 // encoding: [0x0c,0xf0,0x18,0xd5]
|
|
// CHECK: msr s3_7_c11_c13_7, x5 // encoding: [0xe5,0xbd,0x1f,0xd5]
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Unconditional branch (immediate)
|
|
//------------------------------------------------------------------------------
|
|
|
|
tbz x5, #0, somewhere
|
|
tbz xzr, #63, elsewhere
|
|
tbnz x5, #45, nowhere
|
|
// CHECK: tbz x5, #0, somewhere // encoding: [0x05'A',A,A,0x36'A']
|
|
// CHECK: // fixup A - offset: 0, value: somewhere, kind: fixup_a64_tstbr
|
|
// CHECK: tbz xzr, #63, elsewhere // encoding: [0x1f'A',A,0xf8'A',0xb6'A']
|
|
// CHECK: // fixup A - offset: 0, value: elsewhere, kind: fixup_a64_tstbr
|
|
// CHECK: tbnz x5, #45, nowhere // encoding: [0x05'A',A,0x68'A',0xb7'A']
|
|
// CHECK: // fixup A - offset: 0, value: nowhere, kind: fixup_a64_tstbr
|
|
|
|
tbnz w3, #2, there
|
|
tbnz wzr, #31, nowhere
|
|
tbz w5, #12, anywhere
|
|
// CHECK: tbnz w3, #2, there // encoding: [0x03'A',A,0x10'A',0x37'A']
|
|
// CHECK: // fixup A - offset: 0, value: there, kind: fixup_a64_tstbr
|
|
// CHECK: tbnz wzr, #31, nowhere // encoding: [0x1f'A',A,0xf8'A',0x37'A']
|
|
// CHECK: // fixup A - offset: 0, value: nowhere, kind: fixup_a64_tstbr
|
|
// CHECK: tbz w5, #12, anywhere // encoding: [0x05'A',A,0x60'A',0x36'A']
|
|
// CHECK: // fixup A - offset: 0, value: anywhere, kind: fixup_a64_tstbr
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Unconditional branch (immediate)
|
|
//------------------------------------------------------------------------------
|
|
|
|
b somewhere
|
|
bl elsewhere
|
|
// CHECK: b somewhere // encoding: [A,A,A,0x14'A']
|
|
// CHECK: // fixup A - offset: 0, value: somewhere, kind: fixup_a64_uncondbr
|
|
// CHECK: bl elsewhere // encoding: [A,A,A,0x94'A']
|
|
// CHECK: // fixup A - offset: 0, value: elsewhere, kind: fixup_a64_call
|
|
|
|
b #4
|
|
bl #0
|
|
b #134217724
|
|
bl #-134217728
|
|
// CHECK: b #4 // encoding: [0x01,0x00,0x00,0x14]
|
|
// CHECK: bl #0 // encoding: [0x00,0x00,0x00,0x94]
|
|
// CHECK: b #134217724 // encoding: [0xff,0xff,0xff,0x15]
|
|
// CHECK: bl #-134217728 // encoding: [0x00,0x00,0x00,0x96]
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Unconditional branch (register)
|
|
//------------------------------------------------------------------------------
|
|
|
|
br x20
|
|
blr xzr
|
|
ret x10
|
|
// CHECK: br x20 // encoding: [0x80,0x02,0x1f,0xd6]
|
|
// CHECK: blr xzr // encoding: [0xe0,0x03,0x3f,0xd6]
|
|
// CHECK: ret x10 // encoding: [0x40,0x01,0x5f,0xd6]
|
|
|
|
ret
|
|
eret
|
|
drps
|
|
// CHECK: ret // encoding: [0xc0,0x03,0x5f,0xd6]
|
|
// CHECK: eret // encoding: [0xe0,0x03,0x9f,0xd6]
|
|
// CHECK: drps // encoding: [0xe0,0x03,0xbf,0xd6]
|
|
|