Package arm64

import "cmd/internal/obj/arm64"
Overview
Index

Overview ▾

Package arm64 implements an ARM64 assembler. Go assembly syntax is different from GNU ARM64 syntax, but we can still follow the general rules to map between them.

Instructions mnemonics mapping rules

1. Most instructions use width suffixes of instruction names to indicate operand width rather than using different register names.

Examples: 

ADC R24, R14, R12          <=>     adc x12, x14, x24
ADDW R26->24, R21, R15     <=>     add w15, w21, w26, asr #24
FCMPS F2, F3               <=>     fcmp s3, s2
FCMPD F2, F3               <=>     fcmp d3, d2
FCVTDH F2, F3              <=>     fcvt h3, d2

2. Go uses .P and .W suffixes to indicate post-increment and pre-increment.

Examples: 

MOVD.P -8(R10), R8         <=>      ldr x8, [x10],#-8
MOVB.W 16(R16), R10        <=>      ldrsb x10, [x16,#16]!
MOVBU.W 16(R16), R10       <=>      ldrb x10, [x16,#16]!

3. Go uses a series of MOV instructions as load and store.

64-bit variant ldr, str, stur => MOVD; 32-bit variant str, stur, ldrsw => MOVW; 32-bit variant ldr => MOVWU; ldrb => MOVBU; ldrh => MOVHU; ldrsb, sturb, strb => MOVB; ldrsh, sturh, strh => MOVH.

4. Go moves conditions into opcode suffix, like BLT.

5. Go adds a V prefix for most floating-point and SIMD instructions, except cryptographic extension instructions and floating-point(scalar) instructions.

Examples: 

VADD V5.H8, V18.H8, V9.H8         <=>      add v9.8h, v18.8h, v5.8h
VLD1.P (R6)(R11), [V31.D1]        <=>      ld1 {v31.1d}, [x6], x11
VFMLA V29.S2, V20.S2, V14.S2      <=>      fmla v14.2s, v20.2s, v29.2s
AESD V22.B16, V19.B16             <=>      aesd v19.16b, v22.16b
SCVTFWS R3, F16                   <=>      scvtf s17, w6

6. Align directive

Go asm supports the PCALIGN directive, which indicates that the next instruction should be aligned to a specified boundary by padding with NOOP instruction. The alignment value supported on arm64 must be a power of 2 and in the range of [8, 2048].

Examples: 

PCALIGN $16
MOVD $2, R0          // This instruction is aligned with 16 bytes.
PCALIGN $1024
MOVD $3, R1          // This instruction is aligned with 1024 bytes.

PCALIGN also changes the function alignment. If a function has one or more PCALIGN directives, its address will be aligned to the same or coarser boundary, which is the maximum of all the alignment values.

In the following example, the function Add is aligned with 128 bytes.

Examples: 

TEXT ·Add(SB),$40-16
MOVD $2, R0
PCALIGN $32
MOVD $4, R1
PCALIGN $128
MOVD $8, R2
RET

On arm64, functions in Go are aligned to 16 bytes by default, we can also use PCALIGN to set the function alignment. The functions that need to be aligned are preferably using NOFRAME and NOSPLIT to avoid the impact of the prologues inserted by the assembler, so that the function address will have the same alignment as the first hand-written instruction.

In the following example, PCALIGN at the entry of the function Add will align its address to 2048 bytes.

Examples: 

TEXT ·Add(SB),NOSPLIT|NOFRAME,$0
  PCALIGN $2048
  MOVD $1, R0
  MOVD $1, R1
  RET

7. Move large constants to vector registers.

Go asm uses VMOVQ/VMOVD/VMOVS to move 128-bit, 64-bit and 32-bit constants into vector registers, respectively. And for a 128-bit integer, it take two 64-bit operands, for the low and high parts separately.

Examples: 

VMOVS $0x11223344, V0
VMOVD $0x1122334455667788, V1
VMOVQ $0x1122334455667788, $0x99aabbccddeeff00, V2   // V2=0x99aabbccddeeff001122334455667788

8. Move an optionally-shifted 16-bit immediate value to a register.

The instructions are MOVK(W), MOVZ(W) and MOVN(W), the assembly syntax is "op $(uimm16<<shift), <Rd>". The <uimm16> is the 16-bit unsigned immediate, in the range 0 to 65535; For the 32-bit variant, the <shift> is 0 or 16, for the 64-bit variant, the <shift> is 0, 16, 32 or 48.

The current Go assembler does not accept zero shifts, such as "op $0, Rd" and "op $(0<<(16|32|48)), Rd" instructions.

Examples: 

MOVK $(10<<32), R20     <=>      movk x20, #10, lsl #32
MOVZW $(20<<16), R8     <=>      movz w8, #20, lsl #16
MOVK $(0<<16), R10 will be reported as an error by the assembler.

Special Cases.

(1) umov is written as VMOV.

(2) br is renamed JMP, blr is renamed CALL.

(3) No need to add "W" suffix: LDARB, LDARH, LDAXRB, LDAXRH, LDTRH, LDXRB, LDXRH.

(4) In Go assembly syntax, NOP is a zero-width pseudo-instruction serves generic purpose, nothing related to real ARM64 instruction. NOOP serves for the hardware nop instruction. NOOP is an alias of HINT $0.

Examples: 

VMOV V13.B[1], R20      <=>      mov x20, v13.b[1]
VMOV V13.H[1], R20      <=>      mov w20, v13.h[1]
JMP (R3)                <=>      br x3
CALL (R17)              <=>      blr x17
LDAXRB (R19), R16       <=>      ldaxrb w16, [x19]
NOOP                    <=>      nop

Register mapping rules

1. All basic register names are written as Rn.

2. Go uses ZR as the zero register and RSP as the stack pointer.

3. Bn, Hn, Dn, Sn and Qn instructions are written as Fn in floating-point instructions and as Vn in SIMD instructions.

Argument mapping rules

1. The operands appear in left-to-right assignment order.

Go reverses the arguments of most instructions.

Examples: 

ADD R11.SXTB<<1, RSP, R25      <=>      add x25, sp, w11, sxtb #1
VADD V16, V19, V14             <=>      add d14, d19, d16

Special Cases.

(1) Argument order is the same as in the GNU ARM64 syntax: cbz, cbnz and some store instructions, such as str, stur, strb, sturb, strh, sturh stlr, stlrb. stlrh, st1.

Examples: 

MOVD R29, 384(R19)    <=>    str x29, [x19,#384]
MOVB.P R30, 30(R4)    <=>    strb w30, [x4],#30
STLRH R21, (R19)      <=>    stlrh w21, [x19]

(2) MADD, MADDW, MSUB, MSUBW, SMADDL, SMSUBL, UMADDL, UMSUBL <Rm>, <Ra>, <Rn>, <Rd>

Examples: 

MADD R2, R30, R22, R6       <=>    madd x6, x22, x2, x30
SMSUBL R10, R3, R17, R27    <=>    smsubl x27, w17, w10, x3

(3) FMADDD, FMADDS, FMSUBD, FMSUBS, FNMADDD, FNMADDS, FNMSUBD, FNMSUBS <Fm>, <Fa>, <Fn>, <Fd>

Examples: 

FMADDD F30, F20, F3, F29    <=>    fmadd d29, d3, d30, d20
FNMSUBS F7, F25, F7, F22    <=>    fnmsub s22, s7, s7, s25

(4) BFI, BFXIL, SBFIZ, SBFX, UBFIZ, UBFX $<lsb>, <Rn>, $<width>, <Rd>

Examples: 

BFIW $16, R20, $6, R0      <=>    bfi w0, w20, #16, #6
UBFIZ $34, R26, $5, R20    <=>    ubfiz x20, x26, #34, #5

(5) FCCMPD, FCCMPS, FCCMPED, FCCMPES <cond>, Fm. Fn, $<nzcv>

Examples: 

FCCMPD AL, F8, F26, $0     <=>    fccmp d26, d8, #0x0, al
FCCMPS VS, F29, F4, $4     <=>    fccmp s4, s29, #0x4, vs
FCCMPED LE, F20, F5, $13   <=>    fccmpe d5, d20, #0xd, le
FCCMPES NE, F26, F10, $0   <=>    fccmpe s10, s26, #0x0, ne

(6) CCMN, CCMNW, CCMP, CCMPW <cond>, <Rn>, $<imm>, $<nzcv>

Examples: 

CCMP MI, R22, $12, $13     <=>    ccmp x22, #0xc, #0xd, mi
CCMNW AL, R1, $11, $8      <=>    ccmn w1, #0xb, #0x8, al

(7) CCMN, CCMNW, CCMP, CCMPW <cond>, <Rn>, <Rm>, $<nzcv>

Examples: 

CCMN VS, R13, R22, $10     <=>    ccmn x13, x22, #0xa, vs
CCMPW HS, R19, R14, $11    <=>    ccmp w19, w14, #0xb, cs

(9) CSEL, CSELW, CSNEG, CSNEGW, CSINC, CSINCW <cond>, <Rn>, <Rm>, <Rd> ; FCSELD, FCSELS <cond>, <Fn>, <Fm>, <Fd>

Examples: 

CSEL GT, R0, R19, R1        <=>    csel x1, x0, x19, gt
CSNEGW GT, R7, R17, R8      <=>    csneg w8, w7, w17, gt
FCSELD EQ, F15, F18, F16    <=>    fcsel d16, d15, d18, eq

(10) TBNZ, TBZ $<imm>, <Rt>, <label>

(11) STLXR, STLXRW, STXR, STXRW, STLXRB, STLXRH, STXRB, STXRH <Rf>, (<Rn|RSP>), <Rs>

Examples: 

STLXR ZR, (R15), R16    <=>    stlxr w16, xzr, [x15]
STXRB R9, (R21), R19    <=>    stxrb w19, w9, [x21]

(12) STLXP, STLXPW, STXP, STXPW (<Rf1>, <Rf2>), (<Rn|RSP>), <Rs>

Examples: 

STLXP (R17, R19), (R4), R5      <=>    stlxp w5, x17, x19, [x4]
STXPW (R30, R25), (R22), R13    <=>    stxp w13, w30, w25, [x22]

2. Expressions for special arguments.

#<immediate> is written as $<immediate>.

Optionally-shifted immediate.

Examples: 

ADD $(3151<<12), R14, R20     <=>    add x20, x14, #0xc4f, lsl #12
ADDW $1864, R25, R6           <=>    add w6, w25, #0x748

Optionally-shifted registers are written as <Rm>{<shift><amount>}. The <shift> can be <<(lsl), >>(lsr), ->(asr), @>(ror).

Examples: 

ADD R19>>30, R10, R24     <=>    add x24, x10, x19, lsr #30
ADDW R26->24, R21, R15    <=>    add w15, w21, w26, asr #24

Extended registers are written as <Rm>{.<extend>{<<<amount>}}. <extend> can be UXTB, UXTH, UXTW, UXTX, SXTB, SXTH, SXTW or SXTX.

Examples: 

ADDS R19.UXTB<<4, R9, R26     <=>    adds x26, x9, w19, uxtb #4
ADDSW R14.SXTX, R14, R6       <=>    adds w6, w14, w14, sxtx

Memory references: [<Xn|SP>{,#0}] is written as (Rn|RSP), a base register and an immediate offset is written as imm(Rn|RSP), a base register and an offset register is written as (Rn|RSP)(Rm).

Examples: 

LDAR (R22), R9                  <=>    ldar x9, [x22]
LDP 28(R17), (R15, R23)         <=>    ldp x15, x23, [x17,#28]
MOVWU (R4)(R12<<2), R8          <=>    ldr w8, [x4, x12, lsl #2]
MOVD (R7)(R11.UXTW<<3), R25     <=>    ldr x25, [x7,w11,uxtw #3]
MOVBU (R27)(R23), R14           <=>    ldrb w14, [x27,x23]

Register pairs are written as (Rt1, Rt2).

Examples: 

LDP.P -240(R11), (R12, R26)    <=>    ldp x12, x26, [x11],#-240

Register with arrangement and register with arrangement and index.

Examples: 

VADD V5.H8, V18.H8, V9.H8                     <=>    add v9.8h, v18.8h, v5.8h
VLD1 (R2), [V21.B16]                          <=>    ld1 {v21.16b}, [x2]
VST1.P V9.S[1], (R16)(R21)                    <=>    st1 {v9.s}[1], [x16], x28
VST1.P [V13.H8, V14.H8, V15.H8], (R3)(R14)    <=>    st1 {v13.8h-v15.8h}, [x3], x14
VST1.P [V14.D1, V15.D1], (R7)(R23)            <=>    st1 {v14.1d, v15.1d}, [x7], x23

Index ▾

Constants
Variables
func ADR(p uint32, o uint32, rt uint32) uint32
func ASIMDALL(u, size, opcode uint32) uint32
func ASIMDDIFF(u, opcode uint32) uint32
func ASIMDMISC(u, size, opcode uint32) uint32
func ASIMDPERM(opcode uint32) uint32
func ASIMDSAME(u, size, opcode uint32) uint32
func ASIMDSHF(u, opcode uint32) uint32
func DRconv(a int) string
func EncodeRegisterExtension(a *obj.Addr, ext string, reg, num int16, isAmount, isIndex bool) error
func FPCCMP(m uint32, s uint32, type_ uint32, op uint32) uint32
func FPCMP(m uint32, s uint32, type_ uint32, op uint32, op2 uint32) uint32
func FPCVTI(sf uint32, s uint32, type_ uint32, rmode uint32, op uint32) uint32
func FPOP1S(m uint32, s uint32, type_ uint32, op uint32) uint32
func FPOP2S(m uint32, s uint32, type_ uint32, op uint32) uint32
func FPOP3S(m uint32, s uint32, type_ uint32, op uint32, op2 uint32) uint32
func IsAtomicInstruction(as obj.As) bool
func LD2STR(o uint32) uint32
func LDSTR(sz uint32, v uint32, opc uint32) uint32
func LDSTX(sz uint32, o2 uint32, l uint32, o1 uint32, o0 uint32) uint32
func MOVCONST(d int64, s int, rt int) uint32
func OPBIT(x uint32) uint32
func OPBLR(x uint32) uint32
func OPBcc(x uint32) uint32
func OPDP2(x uint32) uint32
func OPDP3(sf uint32, op54 uint32, op31 uint32, o0 uint32) uint32
func RegisterArrangement(reg int16, arng int16, isIndex bool) (int16, error)
func RegisterListOffset(firstReg, regCnt int, arrangement int64, scale int16) (int64, error)
func SPCconv(a int64) string
func SYSARG4(op1 int, Cn int, Cm int, op2 int) int
func SYSARG5(op0 int, op1 int, Cn int, Cm int, op2 int) int
func SYSHINT(x uint32) uint32
func SYSOP(l uint32, op0 uint32, op1 uint32, crn uint32, crm uint32, op2 uint32, rt uint32) uint32
func SysRegEnc(r int16) (string, uint32, uint8)
type AClass
type Optab
type SpecialOperand
    func (i SpecialOperand) String() string

Package files

a.out.go anames.go anames7.go anames_gen.go asm7.go doc.go encoding_gen.go goops_gen.go inst.go inst_gen.go list7.go obj7.go specialoperand_string.go sysRegEnc.go

Constants

const (
    NSNAME = 8
    NSYM   = 50
    NREG   = 32 /* number of general registers */
    NFREG  = 32 /* number of floating point registers */
)

General purpose registers, kept in the low bits of Prog.Reg. 

const (
    // integer
    REG_R0 = obj.RBaseARM64 + iota
    REG_R1
    REG_R2
    REG_R3
    REG_R4
    REG_R5
    REG_R6
    REG_R7
    REG_R8
    REG_R9
    REG_R10
    REG_R11
    REG_R12
    REG_R13
    REG_R14
    REG_R15
    REG_R16
    REG_R17
    REG_R18
    REG_R19
    REG_R20
    REG_R21
    REG_R22
    REG_R23
    REG_R24
    REG_R25
    REG_R26
    REG_R27
    REG_R28
    REG_R29
    REG_R30
    REG_R31

    // scalar floating point
    REG_F0
    REG_F1
    REG_F2
    REG_F3
    REG_F4
    REG_F5
    REG_F6
    REG_F7
    REG_F8
    REG_F9
    REG_F10
    REG_F11
    REG_F12
    REG_F13
    REG_F14
    REG_F15
    REG_F16
    REG_F17
    REG_F18
    REG_F19
    REG_F20
    REG_F21
    REG_F22
    REG_F23
    REG_F24
    REG_F25
    REG_F26
    REG_F27
    REG_F28
    REG_F29
    REG_F30
    REG_F31

    // SIMD
    REG_V0
    REG_V1
    REG_V2
    REG_V3
    REG_V4
    REG_V5
    REG_V6
    REG_V7
    REG_V8
    REG_V9
    REG_V10
    REG_V11
    REG_V12
    REG_V13
    REG_V14
    REG_V15
    REG_V16
    REG_V17
    REG_V18
    REG_V19
    REG_V20
    REG_V21
    REG_V22
    REG_V23
    REG_V24
    REG_V25
    REG_V26
    REG_V27
    REG_V28
    REG_V29
    REG_V30
    REG_V31

    // SVE (Scalable Vector Extension) scalable vector registers
    // The order matters, make sure that each
    // kind of register starts numbering from the lowest bit.
    REG_Z0
    REG_Z1
    REG_Z2
    REG_Z3
    REG_Z4
    REG_Z5
    REG_Z6
    REG_Z7
    REG_Z8
    REG_Z9
    REG_Z10
    REG_Z11
    REG_Z12
    REG_Z13
    REG_Z14
    REG_Z15
    REG_Z16
    REG_Z17
    REG_Z18
    REG_Z19
    REG_Z20
    REG_Z21
    REG_Z22
    REG_Z23
    REG_Z24
    REG_Z25
    REG_Z26
    REG_Z27
    REG_Z28
    REG_Z29
    REG_Z30
    REG_Z31

    REG_P0
    REG_P1
    REG_P2
    REG_P3
    REG_P4
    REG_P5
    REG_P6
    REG_P7
    REG_P8
    REG_P9
    REG_P10
    REG_P11
    REG_P12
    REG_P13
    REG_P14
    REG_P15

    REG_PN0
    REG_PN1
    REG_PN2
    REG_PN3
    REG_PN4
    REG_PN5
    REG_PN6
    REG_PN7
    REG_PN8
    REG_PN9
    REG_PN10
    REG_PN11
    REG_PN12
    REG_PN13
    REG_PN14
    REG_PN15

    REG_RSP = (REG_PN15 + 1) | 0x1f // to differentiate ZR/SP, REG_RSP&0x1f = 31
)

bits 0-4 indicates register: Vn bits 5-8 indicates arrangement: <T> TODO: consider putting the register and arrangement in different fields of an obj.Prog to make the bit pattern less confusing. 

const (
    REG_ARNG      = obj.RBaseARM64 + 1<<10 + iota<<9 // Vn.<T>
    REG_ELEM                                         // Vn.<T>[index]
    REG_ZARNG                                        // Zn.<T>
    REG_ZARNGELEM                                    // Zn.<T>[index]
    // PZELEM is taking a portion of the P or Z register.
    // Since it does not have an arrangement, it interpret bit 5 differently:
    // bit 5 = 0: Z register
    // bit 5 = 1: P register
    REG_PZELEM  // Zn[index] or Pn[index] or PNd[index]
    REG_PARNGZM // Pn.<T> or Pn/M, Pn/Z
    // This currently overlaps with REG_EXT, if more arrangements are to be added,
    // move REG_EXT to a higher range and update RBase.*.
    REG_PARNGZM_END
)
const (
    REG_UXTB = REG_EXT + iota<<8
    REG_UXTH
    REG_UXTW
    REG_UXTX
    REG_SXTB
    REG_SXTH
    REG_SXTW
    REG_SXTX
)

Register assignments:

compiler allocates R0 up as temps compiler allocates register variables R7-R25 compiler allocates external registers R26 down

compiler allocates register variables F7-F26 compiler allocates external registers F26 down 

const (
    REGMIN = REG_R7  // register variables allocated from here to REGMAX
    REGRT1 = REG_R16 // ARM64 IP0, external linker may use as a scratch register in trampoline
    REGRT2 = REG_R17 // ARM64 IP1, external linker may use as a scratch register in trampoline
    REGPR  = REG_R18 // ARM64 platform register, unused in the Go toolchain
    REGMAX = REG_R25

    REGCTXT = REG_R26 // environment for closures
    REGTMP  = REG_R27 // reserved for liblink
    REGG    = REG_R28 // G
    REGFP   = REG_R29 // frame pointer
    REGLINK = REG_R30

    // ARM64 uses R31 as both stack pointer and zero register,
    // depending on the instruction. To differentiate RSP from ZR,
    // we use a different numeric value for REGZERO and REGSP.
    REGZERO = REG_R31
    REGSP   = REG_RSP

    FREGRET = REG_F0
    FREGMIN = REG_F7  // first register variable
    FREGMAX = REG_F26 // last register variable for 7g only
    FREGEXT = REG_F26 // first external register
)
const (
    /* mark flags */
    LABEL = 1 << iota
    LEAF
    FLOAT
    BRANCH
    LOAD
    FCMP
    SYNC
    LIST
    FOLL
    NOSCHED
)
const (
    // optab is sorted based on the order of these constants
    // and the first match is chosen.
    // The more specific class needs to come earlier.
    C_NONE   = iota + 1 // starting from 1, leave unclassified Addr's class as 0
    C_REG               // R0..R30
    C_ZREG              // R0..R30, ZR
    C_RSP               // R0..R30, RSP
    C_FREG              // F0..F31
    C_VREG              // V0..V31
    C_PAIR              // (Rn, Rm)
    C_SHIFT             // Rn<<2
    C_EXTREG            // Rn.UXTB[<<3]
    C_SPR               // REG_NZCV
    C_COND              // condition code, EQ, NE, etc.
    C_SPOP              // special operand, PLDL1KEEP, VMALLE1IS, etc.
    C_ARNG              // Vn.<T>
    C_ELEM              // Vn.<T>[index]
    C_LIST              // [V1, V2, V3]

    C_ZCON     // $0
    C_ABCON0   // could be C_ADDCON0 or C_BITCON
    C_ADDCON0  // 12-bit unsigned, unshifted
    C_ABCON    // could be C_ADDCON or C_BITCON
    C_AMCON    // could be C_ADDCON or C_MOVCON
    C_ADDCON   // 12-bit unsigned, shifted left by 0 or 12
    C_MBCON    // could be C_MOVCON or C_BITCON
    C_MOVCON   // generated by a 16-bit constant, optionally inverted and/or shifted by multiple of 16
    C_BITCON   // bitfield and logical immediate masks
    C_ADDCON2  // 24-bit constant
    C_LCON     // 32-bit constant
    C_MOVCON2  // a constant that can be loaded with one MOVZ/MOVN and one MOVK
    C_MOVCON3  // a constant that can be loaded with one MOVZ/MOVN and two MOVKs
    C_VCON     // 64-bit constant
    C_FCON     // floating-point constant
    C_VCONADDR // 64-bit memory address

    C_AACON  // ADDCON offset in auto constant $a(FP)
    C_AACON2 // 24-bit offset in auto constant $a(FP)
    C_LACON  // 32-bit offset in auto constant $a(FP)
    C_AECON  // ADDCON offset in extern constant $e(SB)

    // TODO(aram): only one branch class should be enough
    C_SBRA // for TYPE_BRANCH
    C_LBRA

    C_ZAUTO       // 0(RSP)
    C_NSAUTO_16   // -256 <= x < 0, 0 mod 16
    C_NSAUTO_8    // -256 <= x < 0, 0 mod 8
    C_NSAUTO_4    // -256 <= x < 0, 0 mod 4
    C_NSAUTO      // -256 <= x < 0
    C_NPAUTO_16   // -512 <= x < 0, 0 mod 16
    C_NPAUTO      // -512 <= x < 0, 0 mod 8
    C_NQAUTO_16   // -1024 <= x < 0, 0 mod 16
    C_NAUTO4K     // -4095 <= x < 0
    C_PSAUTO_16   // 0 to 255, 0 mod 16
    C_PSAUTO_8    // 0 to 255, 0 mod 8
    C_PSAUTO_4    // 0 to 255, 0 mod 4
    C_PSAUTO      // 0 to 255
    C_PPAUTO_16   // 0 to 504, 0 mod 16
    C_PPAUTO      // 0 to 504, 0 mod 8
    C_PQAUTO_16   // 0 to 1008, 0 mod 16
    C_UAUTO4K_16  // 0 to 4095, 0 mod 16
    C_UAUTO4K_8   // 0 to 4095, 0 mod 8
    C_UAUTO4K_4   // 0 to 4095, 0 mod 4
    C_UAUTO4K_2   // 0 to 4095, 0 mod 2
    C_UAUTO4K     // 0 to 4095
    C_UAUTO8K_16  // 0 to 8190, 0 mod 16
    C_UAUTO8K_8   // 0 to 8190, 0 mod 8
    C_UAUTO8K_4   // 0 to 8190, 0 mod 4
    C_UAUTO8K     // 0 to 8190, 0 mod 2  + C_PSAUTO
    C_UAUTO16K_16 // 0 to 16380, 0 mod 16
    C_UAUTO16K_8  // 0 to 16380, 0 mod 8
    C_UAUTO16K    // 0 to 16380, 0 mod 4 + C_PSAUTO
    C_UAUTO32K_16 // 0 to 32760, 0 mod 16 + C_PSAUTO
    C_UAUTO32K    // 0 to 32760, 0 mod 8 + C_PSAUTO
    C_UAUTO64K    // 0 to 65520, 0 mod 16 + C_PSAUTO
    C_LAUTOPOOL   // any other constant up to 64 bits (needs pool literal)
    C_LAUTO       // any other constant up to 64 bits

    C_SEXT1  // 0 to 4095, direct
    C_SEXT2  // 0 to 8190
    C_SEXT4  // 0 to 16380
    C_SEXT8  // 0 to 32760
    C_SEXT16 // 0 to 65520
    C_LEXT

    C_ZOREG     // 0(R)
    C_NSOREG_16 // must mirror C_NSAUTO_16, etc
    C_NSOREG_8
    C_NSOREG_4
    C_NSOREG
    C_NPOREG_16
    C_NPOREG
    C_NQOREG_16
    C_NOREG4K
    C_PSOREG_16
    C_PSOREG_8
    C_PSOREG_4
    C_PSOREG
    C_PPOREG_16
    C_PPOREG
    C_PQOREG_16
    C_UOREG4K_16
    C_UOREG4K_8
    C_UOREG4K_4
    C_UOREG4K_2
    C_UOREG4K
    C_UOREG8K_16
    C_UOREG8K_8
    C_UOREG8K_4
    C_UOREG8K
    C_UOREG16K_16
    C_UOREG16K_8
    C_UOREG16K
    C_UOREG32K_16
    C_UOREG32K
    C_UOREG64K
    C_LOREGPOOL
    C_LOREG

    C_ADDR // TODO(aram): explain difference from C_VCONADDR

    // The GOT slot for a symbol in -dynlink mode.
    C_GOTADDR

    // TLS "var" in local exec mode: will become a constant offset from
    // thread local base that is ultimately chosen by the program linker.
    C_TLS_LE

    // TLS "var" in initial exec mode: will become a memory address (chosen
    // by the program linker) that the dynamic linker will fill with the
    // offset from the thread local base.
    C_TLS_IE

    C_ROFF // register offset (including register extended)

    C_GOK
    C_TEXTSIZE
    C_NCLASS // must be last
)
const (
    C_XPRE  = 1 << 6 // match arm.C_WBIT, so Prog.String know how to print it
    C_XPOST = 1 << 5 // match arm.C_PBIT, so Prog.String know how to print it
)
const (
    AADC = obj.ABaseARM64 + obj.A_ARCHSPECIFIC + iota
    AADCS
    AADCSW
    AADCW
    AADD
    AADDS
    AADDSW
    AADDW
    AADR
    AADRP
    AAESD
    AAESE
    AAESIMC
    AAESMC
    AAND
    AANDS
    AANDSW
    AANDW
    AASR
    AASRW
    AAT
    ABCC
    ABCS
    ABEQ
    ABFI
    ABFIW
    ABFM
    ABFMW
    ABFXIL
    ABFXILW
    ABGE
    ABGT
    ABHI
    ABHS
    ABIC
    ABICS
    ABICSW
    ABICW
    ABLE
    ABLO
    ABLS
    ABLT
    ABMI
    ABNE
    ABPL
    ABRK
    ABVC
    ABVS
    ACASAD
    ACASALB
    ACASALD
    ACASALH
    ACASALW
    ACASAW
    ACASB
    ACASD
    ACASH
    ACASLD
    ACASLW
    ACASPD
    ACASPW
    ACASW
    ACBNZ
    ACBNZW
    ACBZ
    ACBZW
    ACCMN
    ACCMNW
    ACCMP
    ACCMPW
    ACINC
    ACINCW
    ACINV
    ACINVW
    ACLREX
    ACLS
    ACLSW
    ACLZ
    ACLZW
    ACMN
    ACMNW
    ACMP
    ACMPW
    ACNEG
    ACNEGW
    ACRC32B
    ACRC32CB
    ACRC32CH
    ACRC32CW
    ACRC32CX
    ACRC32H
    ACRC32W
    ACRC32X
    ACSEL
    ACSELW
    ACSET
    ACSETM
    ACSETMW
    ACSETW
    ACSINC
    ACSINCW
    ACSINV
    ACSINVW
    ACSNEG
    ACSNEGW
    ADC
    ADCPS1
    ADCPS2
    ADCPS3
    ADMB
    ADRPS
    ADSB
    ADWORD
    AEON
    AEONW
    AEOR
    AEORW
    AERET
    AEXTR
    AEXTRW
    AFABSD
    AFABSS
    AFADDD
    AFADDS
    AFCCMPD
    AFCCMPED
    AFCCMPES
    AFCCMPS
    AFCMPD
    AFCMPED
    AFCMPES
    AFCMPS
    AFCSELD
    AFCSELS
    AFCVTDH
    AFCVTDS
    AFCVTHD
    AFCVTHS
    AFCVTSD
    AFCVTSH
    AFCVTZSD
    AFCVTZSDW
    AFCVTZSS
    AFCVTZSSW
    AFCVTZUD
    AFCVTZUDW
    AFCVTZUS
    AFCVTZUSW
    AFDIVD
    AFDIVS
    AFLDPD
    AFLDPQ
    AFLDPS
    AFMADDD
    AFMADDS
    AFMAXD
    AFMAXNMD
    AFMAXNMS
    AFMAXS
    AFMIND
    AFMINNMD
    AFMINNMS
    AFMINS
    AFMOVD
    AFMOVQ
    AFMOVS
    AFMSUBD
    AFMSUBS
    AFMULD
    AFMULS
    AFNEGD
    AFNEGS
    AFNMADDD
    AFNMADDS
    AFNMSUBD
    AFNMSUBS
    AFNMULD
    AFNMULS
    AFRINTAD
    AFRINTAS
    AFRINTID
    AFRINTIS
    AFRINTMD
    AFRINTMS
    AFRINTND
    AFRINTNS
    AFRINTPD
    AFRINTPS
    AFRINTXD
    AFRINTXS
    AFRINTZD
    AFRINTZS
    AFSQRTD
    AFSQRTS
    AFSTPD
    AFSTPQ
    AFSTPS
    AFSUBD
    AFSUBS
    AHINT
    AHLT
    AHVC
    AIC
    AISB
    ALDADDAB
    ALDADDAD
    ALDADDAH
    ALDADDALB
    ALDADDALD
    ALDADDALH
    ALDADDALW
    ALDADDAW
    ALDADDB
    ALDADDD
    ALDADDH
    ALDADDLB
    ALDADDLD
    ALDADDLH
    ALDADDLW
    ALDADDW
    ALDAR
    ALDARB
    ALDARH
    ALDARW
    ALDAXP
    ALDAXPW
    ALDAXR
    ALDAXRB
    ALDAXRH
    ALDAXRW
    ALDCLRAB
    ALDCLRAD
    ALDCLRAH
    ALDCLRALB
    ALDCLRALD
    ALDCLRALH
    ALDCLRALW
    ALDCLRAW
    ALDCLRB
    ALDCLRD
    ALDCLRH
    ALDCLRLB
    ALDCLRLD
    ALDCLRLH
    ALDCLRLW
    ALDCLRW
    ALDEORAB
    ALDEORAD
    ALDEORAH
    ALDEORALB
    ALDEORALD
    ALDEORALH
    ALDEORALW
    ALDEORAW
    ALDEORB
    ALDEORD
    ALDEORH
    ALDEORLB
    ALDEORLD
    ALDEORLH
    ALDEORLW
    ALDEORW
    ALDORAB
    ALDORAD
    ALDORAH
    ALDORALB
    ALDORALD
    ALDORALH
    ALDORALW
    ALDORAW
    ALDORB
    ALDORD
    ALDORH
    ALDORLB
    ALDORLD
    ALDORLH
    ALDORLW
    ALDORW
    ALDP
    ALDPSW
    ALDPW
    ALDXP
    ALDXPW
    ALDXR
    ALDXRB
    ALDXRH
    ALDXRW
    ALSL
    ALSLW
    ALSR
    ALSRW
    AMADD
    AMADDW
    AMNEG
    AMNEGW
    AMOVB
    AMOVBU
    AMOVD
    AMOVH
    AMOVHU
    AMOVK
    AMOVKW
    AMOVN
    AMOVNW
    AMOVP
    AMOVPD
    AMOVPQ
    AMOVPS
    AMOVPSW
    AMOVPW
    AMOVW
    AMOVWU
    AMOVZ
    AMOVZW
    AMRS
    AMSR
    AMSUB
    AMSUBW
    AMUL
    AMULW
    AMVN
    AMVNW
    ANEG
    ANEGS
    ANEGSW
    ANEGW
    ANGC
    ANGCS
    ANGCSW
    ANGCW
    ANOOP
    AORN
    AORNW
    AORR
    AORRW
    APRFM
    APRFUM
    ARBIT
    ARBITW
    AREM
    AREMW
    AREV
    AREV16
    AREV16W
    AREV32
    AREVW
    AROR
    ARORW
    ARPRFM
    ASB
    ASBC
    ASBCS
    ASBCSW
    ASBCW
    ASBFIZ
    ASBFIZW
    ASBFM
    ASBFMW
    ASBFX
    ASBFXW
    ASCVTFD
    ASCVTFS
    ASCVTFWD
    ASCVTFWS
    ASDIV
    ASDIVW
    ASEV
    ASEVL
    ASHA1C
    ASHA1H
    ASHA1M
    ASHA1P
    ASHA1SU0
    ASHA1SU1
    ASHA256H
    ASHA256H2
    ASHA256SU0
    ASHA256SU1
    ASHA512H
    ASHA512H2
    ASHA512SU0
    ASHA512SU1
    ASMADDL
    ASMC
    ASMNEGL
    ASMSUBL
    ASMULH
    ASMULL
    ASTLR
    ASTLRB
    ASTLRH
    ASTLRW
    ASTLXP
    ASTLXPW
    ASTLXR
    ASTLXRB
    ASTLXRH
    ASTLXRW
    ASTP
    ASTPW
    ASTXP
    ASTXPW
    ASTXR
    ASTXRB
    ASTXRH
    ASTXRW
    ASUB
    ASUBS
    ASUBSW
    ASUBW
    ASVC
    ASWPAB
    ASWPAD
    ASWPAH
    ASWPALB
    ASWPALD
    ASWPALH
    ASWPALW
    ASWPAW
    ASWPB
    ASWPD
    ASWPH
    ASWPLB
    ASWPLD
    ASWPLH
    ASWPLW
    ASWPW
    ASXTB
    ASXTBW
    ASXTH
    ASXTHW
    ASXTW
    ASYS
    ASYSL
    ATBNZ
    ATBZ
    ATLBI
    ATST
    ATSTW
    AUBFIZ
    AUBFIZW
    AUBFM
    AUBFMW
    AUBFX
    AUBFXW
    AUCVTFD
    AUCVTFS
    AUCVTFWD
    AUCVTFWS
    AUDIV
    AUDIVW
    AUMADDL
    AUMNEGL
    AUMSUBL
    AUMULH
    AUMULL
    AUREM
    AUREMW
    AUXTB
    AUXTBW
    AUXTH
    AUXTHW
    AUXTW
    AVADD
    AVADDP
    AVSHADD
    AVSRHADD
    AVADDV
    AVFMAXV
    AVFMAXNMV
    AVFMINV
    AVFMINNMV
    AVSMAXV
    AVSMINV
    AVUMAXV
    AVUMINV
    AVAND
    AVBCAX
    AVBIF
    AVBIT
    AVBSL
    AVCMEQ
    AVCLS
    AVCLZ
    AVCMGE
    AVCMGT
    AVCMHI
    AVCMHS
    AVCMLE
    AVCMLT
    AVCMTST
    AVCNT
    AVDUP
    AVEOR
    AVEOR3
    AVEXT
    AVFMLA
    AVFMLS
    AVFCMEQ
    AVFCMGE
    AVFCMGT
    AVFCMLE
    AVFCMLT
    AVFADDP
    AVFADD
    AVFSUB
    AVFMUL
    AVFDIV
    AVFMAX
    AVFMAXNM
    AVFMAXP
    AVFMIN
    AVFMINNM
    AVFMINP
    AVFMAXNMP
    AVFMINNMP
    AVSQADD
    AVUQADD
    AVSQSUB
    AVSQABS
    AVSQNEG
    AVUQSUB
    AVUHADD
    AVURHADD
    AVMUL
    AVMLA
    AVMLS
    AVLD1
    AVLD1R
    AVLD2
    AVLD2R
    AVLD3
    AVLD3R
    AVLD4
    AVLD4R
    AVMOV
    AVMOVD
    AVMOVI
    AVMOVQ
    AVMOVS
    AVORR
    AVORN
    AVBIC
    AVPMULL
    AVPMULL2
    AVSMLAL
    AVSMLAL2
    AVSMLSL
    AVSMLSL2
    AVSMULL
    AVSMULL2
    AVUMLAL
    AVUMLAL2
    AVUMLSL
    AVUMLSL2
    AVUMULL
    AVUMULL2
    AVRAX1
    AVRBIT
    AVREV16
    AVREV32
    AVREV64
    AVABS
    AVFABS
    AVFNEG
    AVFSQRT
    AVFRINTN
    AVFRINTP
    AVFRINTM
    AVFRINTZ
    AVNEG
    AVNOT
    AVSHL
    AVSHRN
    AVSHRN2
    AVSLI
    AVSQSHL
    AVSSHL
    AVUSHL
    AVUQSHL
    AVSRI
    AVST1
    AVST2
    AVST3
    AVST4
    AVSUB
    AVSMAX
    AVSMIN
    AVSMAXP
    AVSMINP
    AVTBL
    AVTBX
    AVTRN1
    AVTRN2
    AVUADDLV
    AVUADDW
    AVUADDW2
    AVUMAX
    AVUMIN
    AVUMAXP
    AVUMINP
    AVUSHLL
    AVUSHLL2
    AVUSHR
    AVSRSHR
    AVSSHR
    AVUSRA
    AVUXTL
    AVUXTL2
    AVXTN
    AVXTN2
    AVSSHLL
    AVSSHLL2
    AVSXTL
    AVSXTL2
    AVSQXTN
    AVSQXTN2
    AVSQXTUN
    AVSQXTUN2
    AVUQXTN
    AVUQXTN2
    AVFCVTZS
    AVFCVTZU
    AVSCVTF
    AVUCVTF
    AVFCVTN
    AVFCVTN2
    AVFCVTL
    AVFCVTL2
    AVUZP1
    AVUZP2
    AVXAR
    AVZIP1
    AVZIP2
    AWFE
    AWFI
    AWORD
    AYIELD
    ABTI
    APACIASP
    AAUTIASP
    APACIBSP
    AAUTIBSP
    AAUTIA1716
    AAUTIB1716
    ASVESTART
    AB  = obj.AJMP
    ABL = obj.ACALL
)
const (
    // shift types
    SHIFT_LL  = 0 << 22
    SHIFT_LR  = 1 << 22
    SHIFT_AR  = 2 << 22
    SHIFT_ROR = 3 << 22
)

Arrangement for ARM64 SIMD instructions 

const (
    // arrangement types
    ARNG_8B = iota
    ARNG_16B
    ARNG_1D
    ARNG_4H
    ARNG_8H
    ARNG_2S
    ARNG_4S
    ARNG_2D
    ARNG_1Q
    ARNG_B
    ARNG_H
    ARNG_S
    ARNG_D
    ARNG_Q
    PRED_M
    PRED_Z
)
const (
    S32     = 0 << 31
    S64     = 1 << 31
    Sbit    = 1 << 29
    LSL0_32 = 2 << 13
    LSL0_64 = 3 << 13
)
const (
    // Optab.flag
    LFROM        = 1 << iota // p.From uses constant pool
    LTO                      // p.To uses constant pool
    NOTUSETMP                // p expands to multiple instructions, but does NOT use REGTMP
    BRANCH14BITS             // branch instruction encodes 14 bits
    BRANCH19BITS             // branch instruction encodes 19 bits
)
const (
    AADDPL obj.As = ASVESTART + 1 + iota
    AADDVL
    ACTERMEQ
    ACTERMEQW
    ACTERMNE
    ACTERMNEW
    APAND
    APANDS
    APBIC
    APBICS
    APBRKA
    APBRKAS
    APBRKB
    APBRKBS
    APBRKN
    APBRKNS
    APBRKPA
    APBRKPAS
    APBRKPB
    APBRKPBS
    APCNTP
    APDECP
    APEOR
    APEORS
    APFIRSTP
    APINCP
    APLASTP
    APLDR
    APNAND
    APNANDS
    APNOR
    APNORS
    APORN
    APORNS
    APORR
    APORRS
    APPEXT
    APPFALSE
    APPFIRST
    APPNEXT
    APPRFB
    APPRFD
    APPRFH
    APPRFW
    APPTEST
    APPTRUE
    APPUNPKHI
    APPUNPKLO
    APRDFFR
    APRDFFRS
    APREV
    APSEL
    APSQDECP
    APSQDECPW
    APSQINCP
    APSQINCPW
    APSTR
    APTRN1
    APTRN2
    APUQDECP
    APUQDECPW
    APUQINCP
    APUQINCPW
    APUZP1
    APUZP2
    APWHILEGE
    APWHILEGEW
    APWHILEGT
    APWHILEGTW
    APWHILEHI
    APWHILEHIW
    APWHILEHS
    APWHILEHSW
    APWHILELE
    APWHILELEW
    APWHILELO
    APWHILELOW
    APWHILELS
    APWHILELSW
    APWHILELT
    APWHILELTW
    APWHILERW
    APWHILEWR
    APWRFFR
    APZIP1
    APZIP2
    ARDVL
    ASETFFR
    AZABS
    AZADCLB
    AZADCLT
    AZADD
    AZADDHNB
    AZADDHNT
    AZADDP
    AZADDPT
    AZADDQP
    AZADDQV
    AZADDSUBP
    AZADR
    AZAESD
    AZAESDIMC
    AZAESE
    AZAESEMC
    AZAESIMC
    AZAESMC
    AZAND
    AZANDQV
    AZANDVB
    AZANDVD
    AZANDVH
    AZANDVS
    AZASR
    AZASRD
    AZASRR
    AZBCAX
    AZBDEP
    AZBEXT
    AZBF1CVT
    AZBF1CVTLT
    AZBF2CVT
    AZBF2CVTLT
    AZBFADD
    AZBFCLAMP
    AZBFCVT
    AZBFCVTN
    AZBFCVTNT
    AZBFDOT
    AZBFMAX
    AZBFMAXNM
    AZBFMIN
    AZBFMINNM
    AZBFMLA
    AZBFMLALB
    AZBFMLALT
    AZBFMLS
    AZBFMLSLB
    AZBFMLSLT
    AZBFMMLA
    AZBFMUL
    AZBFSCALE
    AZBFSUB
    AZBGRP
    AZBIC
    AZBSL
    AZBSL1N
    AZBSL2N
    AZCADD
    AZCDOT
    AZCLASTA
    AZCLASTAB
    AZCLASTAD
    AZCLASTAH
    AZCLASTAS
    AZCLASTAW
    AZCLASTB
    AZCLASTBB
    AZCLASTBD
    AZCLASTBH
    AZCLASTBS
    AZCLASTBW
    AZCLS
    AZCLZ
    AZCMLA
    AZCMPEQ
    AZCMPGE
    AZCMPGT
    AZCMPHI
    AZCMPHS
    AZCMPLE
    AZCMPLO
    AZCMPLS
    AZCMPLT
    AZCMPNE
    AZCNOT
    AZCNT
    AZCOMPACT
    AZCPY
    AZCPYB
    AZCPYD
    AZCPYH
    AZCPYS
    AZCPYW
    AZDECP
    AZDUP
    AZDUPM
    AZDUPQ
    AZDUPW
    AZEOR
    AZEOR3
    AZEORBT
    AZEORQV
    AZEORTB
    AZEORVB
    AZEORVD
    AZEORVH
    AZEORVS
    AZEXPAND
    AZEXT
    AZEXTQ
    AZF1CVT
    AZF1CVTLT
    AZF2CVT
    AZF2CVTLT
    AZFABD
    AZFABS
    AZFACGE
    AZFACGT
    AZFADD
    AZFADDAD
    AZFADDAH
    AZFADDAS
    AZFADDP
    AZFADDQV
    AZFADDVD
    AZFADDVH
    AZFADDVS
    AZFAMAX
    AZFAMIN
    AZFCADD
    AZFCLAMP
    AZFCMEQ
    AZFCMGE
    AZFCMGT
    AZFCMLA
    AZFCMLE
    AZFCMLT
    AZFCMNE
    AZFCMUO
    AZFCPY
    AZFCVT
    AZFCVTLT
    AZFCVTN
    AZFCVTNB
    AZFCVTNT
    AZFCVTX
    AZFCVTXNT
    AZFCVTZS
    AZFCVTZSN
    AZFCVTZU
    AZFCVTZUN
    AZFDIV
    AZFDIVR
    AZFDOT
    AZFDUP
    AZFEXPA
    AZFLOGB
    AZFMAD
    AZFMAX
    AZFMAXNM
    AZFMAXNMP
    AZFMAXNMQV
    AZFMAXNMVD
    AZFMAXNMVH
    AZFMAXNMVS
    AZFMAXP
    AZFMAXQV
    AZFMAXVD
    AZFMAXVH
    AZFMAXVS
    AZFMIN
    AZFMINNM
    AZFMINNMP
    AZFMINNMQV
    AZFMINNMVD
    AZFMINNMVH
    AZFMINNMVS
    AZFMINP
    AZFMINQV
    AZFMINVD
    AZFMINVH
    AZFMINVS
    AZFMLA
    AZFMLALB
    AZFMLALLBB
    AZFMLALLBT
    AZFMLALLTB
    AZFMLALLTT
    AZFMLALT
    AZFMLS
    AZFMLSLB
    AZFMLSLT
    AZFMMLA
    AZFMSB
    AZFMUL
    AZFMULX
    AZFNEG
    AZFNMAD
    AZFNMLA
    AZFNMLS
    AZFNMSB
    AZFRECPE
    AZFRECPS
    AZFRECPX
    AZFRINT32X
    AZFRINT32Z
    AZFRINT64X
    AZFRINT64Z
    AZFRINTA
    AZFRINTI
    AZFRINTM
    AZFRINTN
    AZFRINTP
    AZFRINTX
    AZFRINTZ
    AZFRSQRTE
    AZFRSQRTS
    AZFSCALE
    AZFSQRT
    AZFSUB
    AZFSUBR
    AZFTMAD
    AZFTSMUL
    AZFTSSEL
    AZHISTCNT
    AZHISTSEG
    AZINCP
    AZINDEX
    AZINDEXW
    AZINSR
    AZINSRB
    AZINSRD
    AZINSRH
    AZINSRS
    AZINSRW
    AZLASTA
    AZLASTAB
    AZLASTAD
    AZLASTAH
    AZLASTAS
    AZLASTAW
    AZLASTB
    AZLASTBB
    AZLASTBD
    AZLASTBH
    AZLASTBS
    AZLASTBW
    AZLD1B
    AZLD1D
    AZLD1H
    AZLD1Q
    AZLD1RB
    AZLD1RD
    AZLD1RH
    AZLD1ROB
    AZLD1ROD
    AZLD1ROH
    AZLD1ROW
    AZLD1RQB
    AZLD1RQD
    AZLD1RQH
    AZLD1RQW
    AZLD1RSB
    AZLD1RSH
    AZLD1RSW
    AZLD1RW
    AZLD1SB
    AZLD1SH
    AZLD1SW
    AZLD1W
    AZLD2B
    AZLD2D
    AZLD2H
    AZLD2Q
    AZLD2W
    AZLD3B
    AZLD3D
    AZLD3H
    AZLD3Q
    AZLD3W
    AZLD4B
    AZLD4D
    AZLD4H
    AZLD4Q
    AZLD4W
    AZLDFF1B
    AZLDFF1D
    AZLDFF1H
    AZLDFF1SB
    AZLDFF1SH
    AZLDFF1SW
    AZLDFF1W
    AZLDNF1B
    AZLDNF1D
    AZLDNF1H
    AZLDNF1SB
    AZLDNF1SH
    AZLDNF1SW
    AZLDNF1W
    AZLDNT1B
    AZLDNT1D
    AZLDNT1H
    AZLDNT1SB
    AZLDNT1SH
    AZLDNT1SW
    AZLDNT1W
    AZLDR
    AZLSL
    AZLSLR
    AZLSR
    AZLSRR
    AZLUTI2
    AZLUTI4
    AZLUTI6
    AZMAD
    AZMADPT
    AZMATCH
    AZMLA
    AZMLAPT
    AZMLS
    AZMOVPRFX
    AZMSB
    AZMUL
    AZNBSL
    AZNEG
    AZNMATCH
    AZNOT
    AZORQV
    AZORR
    AZORVB
    AZORVD
    AZORVH
    AZORVS
    AZPMLAL
    AZPMOV
    AZPMUL
    AZPMULL
    AZPMULLB
    AZPMULLT
    AZPRFB
    AZPRFD
    AZPRFH
    AZPRFW
    AZRADDHNB
    AZRADDHNT
    AZRAX1
    AZRBIT
    AZREV
    AZREVB
    AZREVD
    AZREVH
    AZREVW
    AZRSHRNB
    AZRSHRNT
    AZRSUBHNB
    AZRSUBHNT
    AZSABA
    AZSABAL
    AZSABALB
    AZSABALT
    AZSABD
    AZSABDLB
    AZSABDLT
    AZSADALP
    AZSADDLB
    AZSADDLBT
    AZSADDLT
    AZSADDVD
    AZSADDWB
    AZSADDWT
    AZSBCLB
    AZSBCLT
    AZSCLAMP
    AZSCVTF
    AZSCVTFLT
    AZSDIV
    AZSDIVR
    AZSDOT
    AZSEL
    AZSHADD
    AZSHRNB
    AZSHRNT
    AZSHSUB
    AZSHSUBR
    AZSLI
    AZSM4E
    AZSM4EKEY
    AZSMAX
    AZSMAXP
    AZSMAXQV
    AZSMAXVB
    AZSMAXVD
    AZSMAXVH
    AZSMAXVS
    AZSMIN
    AZSMINP
    AZSMINQV
    AZSMINVB
    AZSMINVD
    AZSMINVH
    AZSMINVS
    AZSMLALB
    AZSMLALT
    AZSMLSLB
    AZSMLSLT
    AZSMMLA
    AZSMULH
    AZSMULLB
    AZSMULLT
    AZSPLICE
    AZSQABS
    AZSQADD
    AZSQCADD
    AZSQCVTN
    AZSQCVTUN
    AZSQDECP
    AZSQDMLALB
    AZSQDMLALBT
    AZSQDMLALT
    AZSQDMLSLB
    AZSQDMLSLBT
    AZSQDMLSLT
    AZSQDMULH
    AZSQDMULLB
    AZSQDMULLT
    AZSQINCP
    AZSQNEG
    AZSQRDCMLAH
    AZSQRDMLAH
    AZSQRDMLSH
    AZSQRDMULH
    AZSQRSHL
    AZSQRSHLR
    AZSQRSHRN
    AZSQRSHRNB
    AZSQRSHRNT
    AZSQRSHRUN
    AZSQRSHRUNB
    AZSQRSHRUNT
    AZSQSHL
    AZSQSHLR
    AZSQSHLU
    AZSQSHRN
    AZSQSHRNB
    AZSQSHRNT
    AZSQSHRUN
    AZSQSHRUNB
    AZSQSHRUNT
    AZSQSUB
    AZSQSUBR
    AZSQXTNB
    AZSQXTNT
    AZSQXTUNB
    AZSQXTUNT
    AZSRHADD
    AZSRI
    AZSRSHL
    AZSRSHLR
    AZSRSHR
    AZSRSRA
    AZSSHLLB
    AZSSHLLT
    AZSSRA
    AZSSUBLB
    AZSSUBLBT
    AZSSUBLT
    AZSSUBLTB
    AZSSUBWB
    AZSSUBWT
    AZST1B
    AZST1D
    AZST1H
    AZST1Q
    AZST1W
    AZST2B
    AZST2D
    AZST2H
    AZST2Q
    AZST2W
    AZST3B
    AZST3D
    AZST3H
    AZST3Q
    AZST3W
    AZST4B
    AZST4D
    AZST4H
    AZST4Q
    AZST4W
    AZSTNT1B
    AZSTNT1D
    AZSTNT1H
    AZSTNT1W
    AZSTR
    AZSUB
    AZSUBHNB
    AZSUBHNT
    AZSUBP
    AZSUBPT
    AZSUBR
    AZSUDOT
    AZSUNPKHI
    AZSUNPKLO
    AZSUQADD
    AZSXTB
    AZSXTH
    AZSXTW
    AZTBL
    AZTBLQ
    AZTBX
    AZTBXQ
    AZTRN1
    AZTRN2
    AZUABA
    AZUABAL
    AZUABALB
    AZUABALT
    AZUABD
    AZUABDLB
    AZUABDLT
    AZUADALP
    AZUADDLB
    AZUADDLT
    AZUADDVD
    AZUADDWB
    AZUADDWT
    AZUCLAMP
    AZUCVTF
    AZUCVTFLT
    AZUDIV
    AZUDIVR
    AZUDOT
    AZUHADD
    AZUHSUB
    AZUHSUBR
    AZUMAX
    AZUMAXP
    AZUMAXQV
    AZUMAXVB
    AZUMAXVD
    AZUMAXVH
    AZUMAXVS
    AZUMIN
    AZUMINP
    AZUMINQV
    AZUMINVB
    AZUMINVD
    AZUMINVH
    AZUMINVS
    AZUMLALB
    AZUMLALT
    AZUMLSLB
    AZUMLSLT
    AZUMMLA
    AZUMULH
    AZUMULLB
    AZUMULLT
    AZUQADD
    AZUQCVTN
    AZUQDECP
    AZUQINCP
    AZUQRSHL
    AZUQRSHLR
    AZUQRSHRN
    AZUQRSHRNB
    AZUQRSHRNT
    AZUQSHL
    AZUQSHLR
    AZUQSHRN
    AZUQSHRNB
    AZUQSHRNT
    AZUQSUB
    AZUQSUBR
    AZUQXTNB
    AZUQXTNT
    AZURECPE
    AZURHADD
    AZURSHL
    AZURSHLR
    AZURSHR
    AZURSQRTE
    AZURSRA
    AZUSDOT
    AZUSHLLB
    AZUSHLLT
    AZUSMMLA
    AZUSQADD
    AZUSRA
    AZUSUBLB
    AZUSUBLT
    AZUSUBWB
    AZUSUBWT
    AZUUNPKHI
    AZUUNPKLO
    AZUXTB
    AZUXTH
    AZUXTW
    AZUZP1
    AZUZP2
    AZUZPQ1
    AZUZPQ2
    AZXAR
    AZZIP1
    AZZIP2
    AZZIPQ1
    AZZIPQ2
    ALAST
)
const (
    SYSREG_BEGIN = REG_SPECIAL + iota
    REG_ACTLR_EL1
    REG_AFSR0_EL1
    REG_AFSR1_EL1
    REG_AIDR_EL1
    REG_AMAIR_EL1
    REG_AMCFGR_EL0
    REG_AMCGCR_EL0
    REG_AMCNTENCLR0_EL0
    REG_AMCNTENCLR1_EL0
    REG_AMCNTENSET0_EL0
    REG_AMCNTENSET1_EL0
    REG_AMCR_EL0
    REG_AMEVCNTR00_EL0
    REG_AMEVCNTR01_EL0
    REG_AMEVCNTR02_EL0
    REG_AMEVCNTR03_EL0
    REG_AMEVCNTR04_EL0
    REG_AMEVCNTR05_EL0
    REG_AMEVCNTR06_EL0
    REG_AMEVCNTR07_EL0
    REG_AMEVCNTR08_EL0
    REG_AMEVCNTR09_EL0
    REG_AMEVCNTR010_EL0
    REG_AMEVCNTR011_EL0
    REG_AMEVCNTR012_EL0
    REG_AMEVCNTR013_EL0
    REG_AMEVCNTR014_EL0
    REG_AMEVCNTR015_EL0
    REG_AMEVCNTR10_EL0
    REG_AMEVCNTR11_EL0
    REG_AMEVCNTR12_EL0
    REG_AMEVCNTR13_EL0
    REG_AMEVCNTR14_EL0
    REG_AMEVCNTR15_EL0
    REG_AMEVCNTR16_EL0
    REG_AMEVCNTR17_EL0
    REG_AMEVCNTR18_EL0
    REG_AMEVCNTR19_EL0
    REG_AMEVCNTR110_EL0
    REG_AMEVCNTR111_EL0
    REG_AMEVCNTR112_EL0
    REG_AMEVCNTR113_EL0
    REG_AMEVCNTR114_EL0
    REG_AMEVCNTR115_EL0
    REG_AMEVTYPER00_EL0
    REG_AMEVTYPER01_EL0
    REG_AMEVTYPER02_EL0
    REG_AMEVTYPER03_EL0
    REG_AMEVTYPER04_EL0
    REG_AMEVTYPER05_EL0
    REG_AMEVTYPER06_EL0
    REG_AMEVTYPER07_EL0
    REG_AMEVTYPER08_EL0
    REG_AMEVTYPER09_EL0
    REG_AMEVTYPER010_EL0
    REG_AMEVTYPER011_EL0
    REG_AMEVTYPER012_EL0
    REG_AMEVTYPER013_EL0
    REG_AMEVTYPER014_EL0
    REG_AMEVTYPER015_EL0
    REG_AMEVTYPER10_EL0
    REG_AMEVTYPER11_EL0
    REG_AMEVTYPER12_EL0
    REG_AMEVTYPER13_EL0
    REG_AMEVTYPER14_EL0
    REG_AMEVTYPER15_EL0
    REG_AMEVTYPER16_EL0
    REG_AMEVTYPER17_EL0
    REG_AMEVTYPER18_EL0
    REG_AMEVTYPER19_EL0
    REG_AMEVTYPER110_EL0
    REG_AMEVTYPER111_EL0
    REG_AMEVTYPER112_EL0
    REG_AMEVTYPER113_EL0
    REG_AMEVTYPER114_EL0
    REG_AMEVTYPER115_EL0
    REG_AMUSERENR_EL0
    REG_APDAKeyHi_EL1
    REG_APDAKeyLo_EL1
    REG_APDBKeyHi_EL1
    REG_APDBKeyLo_EL1
    REG_APGAKeyHi_EL1
    REG_APGAKeyLo_EL1
    REG_APIAKeyHi_EL1
    REG_APIAKeyLo_EL1
    REG_APIBKeyHi_EL1
    REG_APIBKeyLo_EL1
    REG_CCSIDR2_EL1
    REG_CCSIDR_EL1
    REG_CLIDR_EL1
    REG_CNTFRQ_EL0
    REG_CNTKCTL_EL1
    REG_CNTP_CTL_EL0
    REG_CNTP_CVAL_EL0
    REG_CNTP_TVAL_EL0
    REG_CNTPCT_EL0
    REG_CNTPS_CTL_EL1
    REG_CNTPS_CVAL_EL1
    REG_CNTPS_TVAL_EL1
    REG_CNTV_CTL_EL0
    REG_CNTV_CVAL_EL0
    REG_CNTV_TVAL_EL0
    REG_CNTVCT_EL0
    REG_CONTEXTIDR_EL1
    REG_CPACR_EL1
    REG_CSSELR_EL1
    REG_CTR_EL0
    REG_CurrentEL
    REG_DAIF
    REG_DBGAUTHSTATUS_EL1
    REG_DBGBCR0_EL1
    REG_DBGBCR1_EL1
    REG_DBGBCR2_EL1
    REG_DBGBCR3_EL1
    REG_DBGBCR4_EL1
    REG_DBGBCR5_EL1
    REG_DBGBCR6_EL1
    REG_DBGBCR7_EL1
    REG_DBGBCR8_EL1
    REG_DBGBCR9_EL1
    REG_DBGBCR10_EL1
    REG_DBGBCR11_EL1
    REG_DBGBCR12_EL1
    REG_DBGBCR13_EL1
    REG_DBGBCR14_EL1
    REG_DBGBCR15_EL1
    REG_DBGBVR0_EL1
    REG_DBGBVR1_EL1
    REG_DBGBVR2_EL1
    REG_DBGBVR3_EL1
    REG_DBGBVR4_EL1
    REG_DBGBVR5_EL1
    REG_DBGBVR6_EL1
    REG_DBGBVR7_EL1
    REG_DBGBVR8_EL1
    REG_DBGBVR9_EL1
    REG_DBGBVR10_EL1
    REG_DBGBVR11_EL1
    REG_DBGBVR12_EL1
    REG_DBGBVR13_EL1
    REG_DBGBVR14_EL1
    REG_DBGBVR15_EL1
    REG_DBGCLAIMCLR_EL1
    REG_DBGCLAIMSET_EL1
    REG_DBGDTR_EL0
    REG_DBGDTRRX_EL0
    REG_DBGDTRTX_EL0
    REG_DBGPRCR_EL1
    REG_DBGWCR0_EL1
    REG_DBGWCR1_EL1
    REG_DBGWCR2_EL1
    REG_DBGWCR3_EL1
    REG_DBGWCR4_EL1
    REG_DBGWCR5_EL1
    REG_DBGWCR6_EL1
    REG_DBGWCR7_EL1
    REG_DBGWCR8_EL1
    REG_DBGWCR9_EL1
    REG_DBGWCR10_EL1
    REG_DBGWCR11_EL1
    REG_DBGWCR12_EL1
    REG_DBGWCR13_EL1
    REG_DBGWCR14_EL1
    REG_DBGWCR15_EL1
    REG_DBGWVR0_EL1
    REG_DBGWVR1_EL1
    REG_DBGWVR2_EL1
    REG_DBGWVR3_EL1
    REG_DBGWVR4_EL1
    REG_DBGWVR5_EL1
    REG_DBGWVR6_EL1
    REG_DBGWVR7_EL1
    REG_DBGWVR8_EL1
    REG_DBGWVR9_EL1
    REG_DBGWVR10_EL1
    REG_DBGWVR11_EL1
    REG_DBGWVR12_EL1
    REG_DBGWVR13_EL1
    REG_DBGWVR14_EL1
    REG_DBGWVR15_EL1
    REG_DCZID_EL0
    REG_DISR_EL1
    REG_DIT
    REG_DLR_EL0
    REG_DSPSR_EL0
    REG_ELR_EL1
    REG_ERRIDR_EL1
    REG_ERRSELR_EL1
    REG_ERXADDR_EL1
    REG_ERXCTLR_EL1
    REG_ERXFR_EL1
    REG_ERXMISC0_EL1
    REG_ERXMISC1_EL1
    REG_ERXMISC2_EL1
    REG_ERXMISC3_EL1
    REG_ERXPFGCDN_EL1
    REG_ERXPFGCTL_EL1
    REG_ERXPFGF_EL1
    REG_ERXSTATUS_EL1
    REG_ESR_EL1
    REG_FAR_EL1
    REG_FPCR
    REG_FPSR
    REG_GCR_EL1
    REG_GMID_EL1
    REG_ICC_AP0R0_EL1
    REG_ICC_AP0R1_EL1
    REG_ICC_AP0R2_EL1
    REG_ICC_AP0R3_EL1
    REG_ICC_AP1R0_EL1
    REG_ICC_AP1R1_EL1
    REG_ICC_AP1R2_EL1
    REG_ICC_AP1R3_EL1
    REG_ICC_ASGI1R_EL1
    REG_ICC_BPR0_EL1
    REG_ICC_BPR1_EL1
    REG_ICC_CTLR_EL1
    REG_ICC_DIR_EL1
    REG_ICC_EOIR0_EL1
    REG_ICC_EOIR1_EL1
    REG_ICC_HPPIR0_EL1
    REG_ICC_HPPIR1_EL1
    REG_ICC_IAR0_EL1
    REG_ICC_IAR1_EL1
    REG_ICC_IGRPEN0_EL1
    REG_ICC_IGRPEN1_EL1
    REG_ICC_PMR_EL1
    REG_ICC_RPR_EL1
    REG_ICC_SGI0R_EL1
    REG_ICC_SGI1R_EL1
    REG_ICC_SRE_EL1
    REG_ICV_AP0R0_EL1
    REG_ICV_AP0R1_EL1
    REG_ICV_AP0R2_EL1
    REG_ICV_AP0R3_EL1
    REG_ICV_AP1R0_EL1
    REG_ICV_AP1R1_EL1
    REG_ICV_AP1R2_EL1
    REG_ICV_AP1R3_EL1
    REG_ICV_BPR0_EL1
    REG_ICV_BPR1_EL1
    REG_ICV_CTLR_EL1
    REG_ICV_DIR_EL1
    REG_ICV_EOIR0_EL1
    REG_ICV_EOIR1_EL1
    REG_ICV_HPPIR0_EL1
    REG_ICV_HPPIR1_EL1
    REG_ICV_IAR0_EL1
    REG_ICV_IAR1_EL1
    REG_ICV_IGRPEN0_EL1
    REG_ICV_IGRPEN1_EL1
    REG_ICV_PMR_EL1
    REG_ICV_RPR_EL1
    REG_ID_AA64AFR0_EL1
    REG_ID_AA64AFR1_EL1
    REG_ID_AA64DFR0_EL1
    REG_ID_AA64DFR1_EL1
    REG_ID_AA64ISAR0_EL1
    REG_ID_AA64ISAR1_EL1
    REG_ID_AA64MMFR0_EL1
    REG_ID_AA64MMFR1_EL1
    REG_ID_AA64MMFR2_EL1
    REG_ID_AA64PFR0_EL1
    REG_ID_AA64PFR1_EL1
    REG_ID_AA64ZFR0_EL1
    REG_ID_AFR0_EL1
    REG_ID_DFR0_EL1
    REG_ID_ISAR0_EL1
    REG_ID_ISAR1_EL1
    REG_ID_ISAR2_EL1
    REG_ID_ISAR3_EL1
    REG_ID_ISAR4_EL1
    REG_ID_ISAR5_EL1
    REG_ID_ISAR6_EL1
    REG_ID_MMFR0_EL1
    REG_ID_MMFR1_EL1
    REG_ID_MMFR2_EL1
    REG_ID_MMFR3_EL1
    REG_ID_MMFR4_EL1
    REG_ID_PFR0_EL1
    REG_ID_PFR1_EL1
    REG_ID_PFR2_EL1
    REG_ISR_EL1
    REG_LORC_EL1
    REG_LOREA_EL1
    REG_LORID_EL1
    REG_LORN_EL1
    REG_LORSA_EL1
    REG_MAIR_EL1
    REG_MDCCINT_EL1
    REG_MDCCSR_EL0
    REG_MDRAR_EL1
    REG_MDSCR_EL1
    REG_MIDR_EL1
    REG_MPAM0_EL1
    REG_MPAM1_EL1
    REG_MPAMIDR_EL1
    REG_MPIDR_EL1
    REG_MVFR0_EL1
    REG_MVFR1_EL1
    REG_MVFR2_EL1
    REG_NZCV
    REG_OSDLR_EL1
    REG_OSDTRRX_EL1
    REG_OSDTRTX_EL1
    REG_OSECCR_EL1
    REG_OSLAR_EL1
    REG_OSLSR_EL1
    REG_PAN
    REG_PAR_EL1
    REG_PMBIDR_EL1
    REG_PMBLIMITR_EL1
    REG_PMBPTR_EL1
    REG_PMBSR_EL1
    REG_PMCCFILTR_EL0
    REG_PMCCNTR_EL0
    REG_PMCEID0_EL0
    REG_PMCEID1_EL0
    REG_PMCNTENCLR_EL0
    REG_PMCNTENSET_EL0
    REG_PMCR_EL0
    REG_PMEVCNTR0_EL0
    REG_PMEVCNTR1_EL0
    REG_PMEVCNTR2_EL0
    REG_PMEVCNTR3_EL0
    REG_PMEVCNTR4_EL0
    REG_PMEVCNTR5_EL0
    REG_PMEVCNTR6_EL0
    REG_PMEVCNTR7_EL0
    REG_PMEVCNTR8_EL0
    REG_PMEVCNTR9_EL0
    REG_PMEVCNTR10_EL0
    REG_PMEVCNTR11_EL0
    REG_PMEVCNTR12_EL0
    REG_PMEVCNTR13_EL0
    REG_PMEVCNTR14_EL0
    REG_PMEVCNTR15_EL0
    REG_PMEVCNTR16_EL0
    REG_PMEVCNTR17_EL0
    REG_PMEVCNTR18_EL0
    REG_PMEVCNTR19_EL0
    REG_PMEVCNTR20_EL0
    REG_PMEVCNTR21_EL0
    REG_PMEVCNTR22_EL0
    REG_PMEVCNTR23_EL0
    REG_PMEVCNTR24_EL0
    REG_PMEVCNTR25_EL0
    REG_PMEVCNTR26_EL0
    REG_PMEVCNTR27_EL0
    REG_PMEVCNTR28_EL0
    REG_PMEVCNTR29_EL0
    REG_PMEVCNTR30_EL0
    REG_PMEVTYPER0_EL0
    REG_PMEVTYPER1_EL0
    REG_PMEVTYPER2_EL0
    REG_PMEVTYPER3_EL0
    REG_PMEVTYPER4_EL0
    REG_PMEVTYPER5_EL0
    REG_PMEVTYPER6_EL0
    REG_PMEVTYPER7_EL0
    REG_PMEVTYPER8_EL0
    REG_PMEVTYPER9_EL0
    REG_PMEVTYPER10_EL0
    REG_PMEVTYPER11_EL0
    REG_PMEVTYPER12_EL0
    REG_PMEVTYPER13_EL0
    REG_PMEVTYPER14_EL0
    REG_PMEVTYPER15_EL0
    REG_PMEVTYPER16_EL0
    REG_PMEVTYPER17_EL0
    REG_PMEVTYPER18_EL0
    REG_PMEVTYPER19_EL0
    REG_PMEVTYPER20_EL0
    REG_PMEVTYPER21_EL0
    REG_PMEVTYPER22_EL0
    REG_PMEVTYPER23_EL0
    REG_PMEVTYPER24_EL0
    REG_PMEVTYPER25_EL0
    REG_PMEVTYPER26_EL0
    REG_PMEVTYPER27_EL0
    REG_PMEVTYPER28_EL0
    REG_PMEVTYPER29_EL0
    REG_PMEVTYPER30_EL0
    REG_PMINTENCLR_EL1
    REG_PMINTENSET_EL1
    REG_PMMIR_EL1
    REG_PMOVSCLR_EL0
    REG_PMOVSSET_EL0
    REG_PMSCR_EL1
    REG_PMSELR_EL0
    REG_PMSEVFR_EL1
    REG_PMSFCR_EL1
    REG_PMSICR_EL1
    REG_PMSIDR_EL1
    REG_PMSIRR_EL1
    REG_PMSLATFR_EL1
    REG_PMSWINC_EL0
    REG_PMUSERENR_EL0
    REG_PMXEVCNTR_EL0
    REG_PMXEVTYPER_EL0
    REG_REVIDR_EL1
    REG_RGSR_EL1
    REG_RMR_EL1
    REG_RNDR
    REG_RNDRRS
    REG_RVBAR_EL1
    REG_SCTLR_EL1
    REG_SCXTNUM_EL0
    REG_SCXTNUM_EL1
    REG_SP_EL0
    REG_SP_EL1
    REG_SPSel
    REG_SPSR_abt
    REG_SPSR_EL1
    REG_SPSR_fiq
    REG_SPSR_irq
    REG_SPSR_und
    REG_SSBS
    REG_TCO
    REG_TCR_EL1
    REG_TFSR_EL1
    REG_TFSRE0_EL1
    REG_TPIDR_EL0
    REG_TPIDR_EL1
    REG_TPIDRRO_EL0
    REG_TRFCR_EL1
    REG_TTBR0_EL1
    REG_TTBR1_EL1
    REG_UAO
    REG_VBAR_EL1
    REG_ZCR_EL1
    SYSREG_END
)
const (
    SR_READ = 1 << iota
    SR_WRITE
)
const (
    BIG = 2048 - 8
)

Used for padding NOOP instruction 

const OP_NOOP = 0xd503201f
const (
    REGFROM = 1
)
const REG_EXT = obj.RBaseARM64 + 1<<12

Not registers, but flags that can be combined with regular register constants to indicate extended register conversion. When checking, you should subtract obj.RBaseARM64 first. From this difference, bit 12 indicates extended register, bits 8-10 select the conversion mode. REG_LSL is the index shift specifier, bit 9 indicates shifted offset register. 

const REG_LSL = obj.RBaseARM64 + 1<<9

Special registers, after subtracting obj.RBaseARM64, bit 13 indicates a special register and the low bits select the register. SYSREG_END is the last item in the automatically generated system register declaration, and it is defined in the sysRegEnc.go file. Define the special register after REG_SPECIAL, the first value of it should be REG_{name} = SYSREG_END + iota. 

const (
    REG_SPECIAL = obj.RBaseARM64 + 1<<13
)

Variables

http://infocenter.arm.com/help/topic/com.arm.doc.ecm0665627/abi_sve_aadwarf_100985_0000_00_en.pdf 

var ARM64DWARFRegisters = map[int16]int16{
    REG_R0:  0,
    REG_R1:  1,
    REG_R2:  2,
    REG_R3:  3,
    REG_R4:  4,
    REG_R5:  5,
    REG_R6:  6,
    REG_R7:  7,
    REG_R8:  8,
    REG_R9:  9,
    REG_R10: 10,
    REG_R11: 11,
    REG_R12: 12,
    REG_R13: 13,
    REG_R14: 14,
    REG_R15: 15,
    REG_R16: 16,
    REG_R17: 17,
    REG_R18: 18,
    REG_R19: 19,
    REG_R20: 20,
    REG_R21: 21,
    REG_R22: 22,
    REG_R23: 23,
    REG_R24: 24,
    REG_R25: 25,
    REG_R26: 26,
    REG_R27: 27,
    REG_R28: 28,
    REG_R29: 29,
    REG_R30: 30,

    REG_P0:  48,
    REG_P1:  49,
    REG_P2:  50,
    REG_P3:  51,
    REG_P4:  52,
    REG_P5:  53,
    REG_P6:  54,
    REG_P7:  55,
    REG_P8:  56,
    REG_P9:  57,
    REG_P10: 58,
    REG_P11: 59,
    REG_P12: 60,
    REG_P13: 61,
    REG_P14: 62,
    REG_P15: 63,

    REG_F0:  64,
    REG_F1:  65,
    REG_F2:  66,
    REG_F3:  67,
    REG_F4:  68,
    REG_F5:  69,
    REG_F6:  70,
    REG_F7:  71,
    REG_F8:  72,
    REG_F9:  73,
    REG_F10: 74,
    REG_F11: 75,
    REG_F12: 76,
    REG_F13: 77,
    REG_F14: 78,
    REG_F15: 79,
    REG_F16: 80,
    REG_F17: 81,
    REG_F18: 82,
    REG_F19: 83,
    REG_F20: 84,
    REG_F21: 85,
    REG_F22: 86,
    REG_F23: 87,
    REG_F24: 88,
    REG_F25: 89,
    REG_F26: 90,
    REG_F27: 91,
    REG_F28: 92,
    REG_F29: 93,
    REG_F30: 94,
    REG_F31: 95,

    REG_V0:  64,
    REG_V1:  65,
    REG_V2:  66,
    REG_V3:  67,
    REG_V4:  68,
    REG_V5:  69,
    REG_V6:  70,
    REG_V7:  71,
    REG_V8:  72,
    REG_V9:  73,
    REG_V10: 74,
    REG_V11: 75,
    REG_V12: 76,
    REG_V13: 77,
    REG_V14: 78,
    REG_V15: 79,
    REG_V16: 80,
    REG_V17: 81,
    REG_V18: 82,
    REG_V19: 83,
    REG_V20: 84,
    REG_V21: 85,
    REG_V22: 86,
    REG_V23: 87,
    REG_V24: 88,
    REG_V25: 89,
    REG_V26: 90,
    REG_V27: 91,
    REG_V28: 92,
    REG_V29: 93,
    REG_V30: 94,
    REG_V31: 95,

    REG_Z0:  96,
    REG_Z1:  97,
    REG_Z2:  98,
    REG_Z3:  99,
    REG_Z4:  100,
    REG_Z5:  101,
    REG_Z6:  102,
    REG_Z7:  103,
    REG_Z8:  104,
    REG_Z9:  105,
    REG_Z10: 106,
    REG_Z11: 107,
    REG_Z12: 108,
    REG_Z13: 109,
    REG_Z14: 110,
    REG_Z15: 111,
    REG_Z16: 112,
    REG_Z17: 113,
    REG_Z18: 114,
    REG_Z19: 115,
    REG_Z20: 116,
    REG_Z21: 117,
    REG_Z22: 118,
    REG_Z23: 119,
    REG_Z24: 120,
    REG_Z25: 121,
    REG_Z26: 122,
    REG_Z27: 123,
    REG_Z28: 124,
    REG_Z29: 125,
    REG_Z30: 126,
    REG_Z31: 127,
}
var Anames = []string{
    obj.A_ARCHSPECIFIC: "ADC",
    "ADCS",
    "ADCSW",
    "ADCW",
    "ADD",
    "ADDS",
    "ADDSW",
    "ADDW",
    "ADR",
    "ADRP",
    "AESD",
    "AESE",
    "AESIMC",
    "AESMC",
    "AND",
    "ANDS",
    "ANDSW",
    "ANDW",
    "ASR",
    "ASRW",
    "AT",
    "BCC",
    "BCS",
    "BEQ",
    "BFI",
    "BFIW",
    "BFM",
    "BFMW",
    "BFXIL",
    "BFXILW",
    "BGE",
    "BGT",
    "BHI",
    "BHS",
    "BIC",
    "BICS",
    "BICSW",
    "BICW",
    "BLE",
    "BLO",
    "BLS",
    "BLT",
    "BMI",
    "BNE",
    "BPL",
    "BRK",
    "BVC",
    "BVS",
    "CASAD",
    "CASALB",
    "CASALD",
    "CASALH",
    "CASALW",
    "CASAW",
    "CASB",
    "CASD",
    "CASH",
    "CASLD",
    "CASLW",
    "CASPD",
    "CASPW",
    "CASW",
    "CBNZ",
    "CBNZW",
    "CBZ",
    "CBZW",
    "CCMN",
    "CCMNW",
    "CCMP",
    "CCMPW",
    "CINC",
    "CINCW",
    "CINV",
    "CINVW",
    "CLREX",
    "CLS",
    "CLSW",
    "CLZ",
    "CLZW",
    "CMN",
    "CMNW",
    "CMP",
    "CMPW",
    "CNEG",
    "CNEGW",
    "CRC32B",
    "CRC32CB",
    "CRC32CH",
    "CRC32CW",
    "CRC32CX",
    "CRC32H",
    "CRC32W",
    "CRC32X",
    "CSEL",
    "CSELW",
    "CSET",
    "CSETM",
    "CSETMW",
    "CSETW",
    "CSINC",
    "CSINCW",
    "CSINV",
    "CSINVW",
    "CSNEG",
    "CSNEGW",
    "DC",
    "DCPS1",
    "DCPS2",
    "DCPS3",
    "DMB",
    "DRPS",
    "DSB",
    "DWORD",
    "EON",
    "EONW",
    "EOR",
    "EORW",
    "ERET",
    "EXTR",
    "EXTRW",
    "FABSD",
    "FABSS",
    "FADDD",
    "FADDS",
    "FCCMPD",
    "FCCMPED",
    "FCCMPES",
    "FCCMPS",
    "FCMPD",
    "FCMPED",
    "FCMPES",
    "FCMPS",
    "FCSELD",
    "FCSELS",
    "FCVTDH",
    "FCVTDS",
    "FCVTHD",
    "FCVTHS",
    "FCVTSD",
    "FCVTSH",
    "FCVTZSD",
    "FCVTZSDW",
    "FCVTZSS",
    "FCVTZSSW",
    "FCVTZUD",
    "FCVTZUDW",
    "FCVTZUS",
    "FCVTZUSW",
    "FDIVD",
    "FDIVS",
    "FLDPD",
    "FLDPQ",
    "FLDPS",
    "FMADDD",
    "FMADDS",
    "FMAXD",
    "FMAXNMD",
    "FMAXNMS",
    "FMAXS",
    "FMIND",
    "FMINNMD",
    "FMINNMS",
    "FMINS",
    "FMOVD",
    "FMOVQ",
    "FMOVS",
    "FMSUBD",
    "FMSUBS",
    "FMULD",
    "FMULS",
    "FNEGD",
    "FNEGS",
    "FNMADDD",
    "FNMADDS",
    "FNMSUBD",
    "FNMSUBS",
    "FNMULD",
    "FNMULS",
    "FRINTAD",
    "FRINTAS",
    "FRINTID",
    "FRINTIS",
    "FRINTMD",
    "FRINTMS",
    "FRINTND",
    "FRINTNS",
    "FRINTPD",
    "FRINTPS",
    "FRINTXD",
    "FRINTXS",
    "FRINTZD",
    "FRINTZS",
    "FSQRTD",
    "FSQRTS",
    "FSTPD",
    "FSTPQ",
    "FSTPS",
    "FSUBD",
    "FSUBS",
    "HINT",
    "HLT",
    "HVC",
    "IC",
    "ISB",
    "LDADDAB",
    "LDADDAD",
    "LDADDAH",
    "LDADDALB",
    "LDADDALD",
    "LDADDALH",
    "LDADDALW",
    "LDADDAW",
    "LDADDB",
    "LDADDD",
    "LDADDH",
    "LDADDLB",
    "LDADDLD",
    "LDADDLH",
    "LDADDLW",
    "LDADDW",
    "LDAR",
    "LDARB",
    "LDARH",
    "LDARW",
    "LDAXP",
    "LDAXPW",
    "LDAXR",
    "LDAXRB",
    "LDAXRH",
    "LDAXRW",
    "LDCLRAB",
    "LDCLRAD",
    "LDCLRAH",
    "LDCLRALB",
    "LDCLRALD",
    "LDCLRALH",
    "LDCLRALW",
    "LDCLRAW",
    "LDCLRB",
    "LDCLRD",
    "LDCLRH",
    "LDCLRLB",
    "LDCLRLD",
    "LDCLRLH",
    "LDCLRLW",
    "LDCLRW",
    "LDEORAB",
    "LDEORAD",
    "LDEORAH",
    "LDEORALB",
    "LDEORALD",
    "LDEORALH",
    "LDEORALW",
    "LDEORAW",
    "LDEORB",
    "LDEORD",
    "LDEORH",
    "LDEORLB",
    "LDEORLD",
    "LDEORLH",
    "LDEORLW",
    "LDEORW",
    "LDORAB",
    "LDORAD",
    "LDORAH",
    "LDORALB",
    "LDORALD",
    "LDORALH",
    "LDORALW",
    "LDORAW",
    "LDORB",
    "LDORD",
    "LDORH",
    "LDORLB",
    "LDORLD",
    "LDORLH",
    "LDORLW",
    "LDORW",
    "LDP",
    "LDPSW",
    "LDPW",
    "LDXP",
    "LDXPW",
    "LDXR",
    "LDXRB",
    "LDXRH",
    "LDXRW",
    "LSL",
    "LSLW",
    "LSR",
    "LSRW",
    "MADD",
    "MADDW",
    "MNEG",
    "MNEGW",
    "MOVB",
    "MOVBU",
    "MOVD",
    "MOVH",
    "MOVHU",
    "MOVK",
    "MOVKW",
    "MOVN",
    "MOVNW",
    "MOVP",
    "MOVPD",
    "MOVPQ",
    "MOVPS",
    "MOVPSW",
    "MOVPW",
    "MOVW",
    "MOVWU",
    "MOVZ",
    "MOVZW",
    "MRS",
    "MSR",
    "MSUB",
    "MSUBW",
    "MUL",
    "MULW",
    "MVN",
    "MVNW",
    "NEG",
    "NEGS",
    "NEGSW",
    "NEGW",
    "NGC",
    "NGCS",
    "NGCSW",
    "NGCW",
    "NOOP",
    "ORN",
    "ORNW",
    "ORR",
    "ORRW",
    "PRFM",
    "PRFUM",
    "RBIT",
    "RBITW",
    "REM",
    "REMW",
    "REV",
    "REV16",
    "REV16W",
    "REV32",
    "REVW",
    "ROR",
    "RORW",
    "RPRFM",
    "SB",
    "SBC",
    "SBCS",
    "SBCSW",
    "SBCW",
    "SBFIZ",
    "SBFIZW",
    "SBFM",
    "SBFMW",
    "SBFX",
    "SBFXW",
    "SCVTFD",
    "SCVTFS",
    "SCVTFWD",
    "SCVTFWS",
    "SDIV",
    "SDIVW",
    "SEV",
    "SEVL",
    "SHA1C",
    "SHA1H",
    "SHA1M",
    "SHA1P",
    "SHA1SU0",
    "SHA1SU1",
    "SHA256H",
    "SHA256H2",
    "SHA256SU0",
    "SHA256SU1",
    "SHA512H",
    "SHA512H2",
    "SHA512SU0",
    "SHA512SU1",
    "SMADDL",
    "SMC",
    "SMNEGL",
    "SMSUBL",
    "SMULH",
    "SMULL",
    "STLR",
    "STLRB",
    "STLRH",
    "STLRW",
    "STLXP",
    "STLXPW",
    "STLXR",
    "STLXRB",
    "STLXRH",
    "STLXRW",
    "STP",
    "STPW",
    "STXP",
    "STXPW",
    "STXR",
    "STXRB",
    "STXRH",
    "STXRW",
    "SUB",
    "SUBS",
    "SUBSW",
    "SUBW",
    "SVC",
    "SWPAB",
    "SWPAD",
    "SWPAH",
    "SWPALB",
    "SWPALD",
    "SWPALH",
    "SWPALW",
    "SWPAW",
    "SWPB",
    "SWPD",
    "SWPH",
    "SWPLB",
    "SWPLD",
    "SWPLH",
    "SWPLW",
    "SWPW",
    "SXTB",
    "SXTBW",
    "SXTH",
    "SXTHW",
    "SXTW",
    "SYS",
    "SYSL",
    "TBNZ",
    "TBZ",
    "TLBI",
    "TST",
    "TSTW",
    "UBFIZ",
    "UBFIZW",
    "UBFM",
    "UBFMW",
    "UBFX",
    "UBFXW",
    "UCVTFD",
    "UCVTFS",
    "UCVTFWD",
    "UCVTFWS",
    "UDIV",
    "UDIVW",
    "UMADDL",
    "UMNEGL",
    "UMSUBL",
    "UMULH",
    "UMULL",
    "UREM",
    "UREMW",
    "UXTB",
    "UXTBW",
    "UXTH",
    "UXTHW",
    "UXTW",
    "VADD",
    "VADDP",
    "VSHADD",
    "VSRHADD",
    "VADDV",
    "VFMAXV",
    "VFMAXNMV",
    "VFMINV",
    "VFMINNMV",
    "VSMAXV",
    "VSMINV",
    "VUMAXV",
    "VUMINV",
    "VAND",
    "VBCAX",
    "VBIF",
    "VBIT",
    "VBSL",
    "VCMEQ",
    "VCLS",
    "VCLZ",
    "VCMGE",
    "VCMGT",
    "VCMHI",
    "VCMHS",
    "VCMLE",
    "VCMLT",
    "VCMTST",
    "VCNT",
    "VDUP",
    "VEOR",
    "VEOR3",
    "VEXT",
    "VFMLA",
    "VFMLS",
    "VFCMEQ",
    "VFCMGE",
    "VFCMGT",
    "VFCMLE",
    "VFCMLT",
    "VFADDP",
    "VFADD",
    "VFSUB",
    "VFMUL",
    "VFDIV",
    "VFMAX",
    "VFMAXNM",
    "VFMAXP",
    "VFMIN",
    "VFMINNM",
    "VFMINP",
    "VFMAXNMP",
    "VFMINNMP",
    "VSQADD",
    "VUQADD",
    "VSQSUB",
    "VSQABS",
    "VSQNEG",
    "VUQSUB",
    "VUHADD",
    "VURHADD",
    "VMUL",
    "VMLA",
    "VMLS",
    "VLD1",
    "VLD1R",
    "VLD2",
    "VLD2R",
    "VLD3",
    "VLD3R",
    "VLD4",
    "VLD4R",
    "VMOV",
    "VMOVD",
    "VMOVI",
    "VMOVQ",
    "VMOVS",
    "VORR",
    "VORN",
    "VBIC",
    "VPMULL",
    "VPMULL2",
    "VSMLAL",
    "VSMLAL2",
    "VSMLSL",
    "VSMLSL2",
    "VSMULL",
    "VSMULL2",
    "VUMLAL",
    "VUMLAL2",
    "VUMLSL",
    "VUMLSL2",
    "VUMULL",
    "VUMULL2",
    "VRAX1",
    "VRBIT",
    "VREV16",
    "VREV32",
    "VREV64",
    "VABS",
    "VFABS",
    "VFNEG",
    "VFSQRT",
    "VFRINTN",
    "VFRINTP",
    "VFRINTM",
    "VFRINTZ",
    "VNEG",
    "VNOT",
    "VSHL",
    "VSHRN",
    "VSHRN2",
    "VSLI",
    "VSQSHL",
    "VSSHL",
    "VUSHL",
    "VUQSHL",
    "VSRI",
    "VST1",
    "VST2",
    "VST3",
    "VST4",
    "VSUB",
    "VSMAX",
    "VSMIN",
    "VSMAXP",
    "VSMINP",
    "VTBL",
    "VTBX",
    "VTRN1",
    "VTRN2",
    "VUADDLV",
    "VUADDW",
    "VUADDW2",
    "VUMAX",
    "VUMIN",
    "VUMAXP",
    "VUMINP",
    "VUSHLL",
    "VUSHLL2",
    "VUSHR",
    "VSRSHR",
    "VSSHR",
    "VUSRA",
    "VUXTL",
    "VUXTL2",
    "VXTN",
    "VXTN2",
    "VSSHLL",
    "VSSHLL2",
    "VSXTL",
    "VSXTL2",
    "VSQXTN",
    "VSQXTN2",
    "VSQXTUN",
    "VSQXTUN2",
    "VUQXTN",
    "VUQXTN2",
    "VFCVTZS",
    "VFCVTZU",
    "VSCVTF",
    "VUCVTF",
    "VFCVTN",
    "VFCVTN2",
    "VFCVTL",
    "VFCVTL2",
    "VUZP1",
    "VUZP2",
    "VXAR",
    "VZIP1",
    "VZIP2",
    "WFE",
    "WFI",
    "WORD",
    "YIELD",
    "BTI",
    "PACIASP",
    "AUTIASP",
    "PACIBSP",
    "AUTIBSP",
    "AUTIA1716",
    "AUTIB1716",
}
var Linkarm64 = obj.LinkArch{
    Arch:           sys.ArchARM64,
    Init:           buildop,
    Preprocess:     preprocess,
    Assemble:       span7,
    Progedit:       progedit,
    UnaryDst:       unaryDst,
    DWARFRegisters: ARM64DWARFRegisters,
}
var PNd_T = []operand{
    a_ARNG_PNd_SizeBHSD2224,
}
var PNn_imm___Pd_T = []operand{
    a_PREGIDX_PnN_58_Noop_Imm2_810,
    a_ARNG_Pd_SizeBHSD2224,
}
var PNn_imm____Pd1_T__Pd2_T_ = []operand{
    a_PREGIDX_PnN_58_Noop_I189,
    a_REGLIST2_Pd04_SizeBHSD2224_Pd04Plus1_SizeBHSD2224,
}
var Pd_B = []operand{
    a_ARNG_Pd_ArngBCheck,
}
var Pdm_B__Pn_B__PgZ__Pdm_B = []operand{
    a_ARNG_PdmDest_ArngBCheck,
    a_ARNG_Pn59_ArngBCheck,
    a_PREGZM_Pg1014_ZeroPredCheck,
    a_ARNG_PdmDest_ArngBCheck,
}
var Pdn_B__Pg__Pdn_B = []operand{
    a_ARNG_PdnSrcDst_ArngBCheck,
    a_PREG_Pg59_Noop,
    a_ARNG_PdnSrcDst_ArngBCheck,
}
var Pdn_T__Pv__Pdn_T = []operand{
    a_ARNG_PdnDest_SizeBHSD2224,
    a_PREG_Pv59_Noop,
    a_ARNG_PdnDest_SizeBHSD2224,
}
var PgZ__Pd_B = []operand{
    a_PREGZM_Pg59_ZeroPredCheck,
    a_ARNG_Pd_ArngBCheck,
}
var Pm_B__Pn_B__PgZ__Pd_B = []operand{
    a_ARNG_Pm1620_ArngBCheck,
    a_ARNG_Pn59_ArngBCheck,
    a_PREGZM_Pg1014_ZeroPredCheck,
    a_ARNG_Pd_ArngBCheck,
}
var Pm_B__Pn_B__Pg__Pd_B = []operand{
    a_ARNG_Pm1620_ArngBCheck,
    a_ARNG_Pn59_ArngBCheck,
    a_PREG_Pg1014_Noop,
    a_ARNG_Pd_ArngBCheck,
}
var Pm_T__Pn_T__Pd_T = []operand{
    a_ARNG_Pm1620_SizeBHSD2224,
    a_ARNG_Pn59_SizeBHSD2224,
    a_ARNG_Pd_SizeBHSD2224,
}
var Pm_T__Wdn = []operand{
    a_ARNG_Pm59V1_SizeBHSD2224,
    a_SPZGREG_Noop_Wdn05,
}
var Pm_T__Xdn = []operand{
    a_ARNG_Pm59V1_SizeBHSD2224,
    a_SPZGREG_Noop_Xdn05,
}
var Pm_T__Zdn_T = []operand{
    a_ARNG_Pm59V1_SizeHSD2224,
    a_ARNG_ZdnSrcDst_SizeHSD2224,
}
var Pn_B = []operand{
    a_ARNG_Pn59V2_ArngBCheck,
}
var Pn_B__Pd_H = []operand{
    a_ARNG_Pn59V2_ArngBCheck,
    a_ARNG_Pd_ArngHCheck,
}
var Pn_B__Pg = []operand{
    a_ARNG_Pn59V2_ArngBCheck,
    a_PREG_Pg1014_Noop,
}
var Pn_B__PgZM__Pd_B = []operand{
    a_ARNG_Pn59V2_ArngBCheck,
    a_PREGZM_Pg1014_PredQualM45,
    a_ARNG_Pd_ArngBCheck,
}
var Pn_B__PgZ__Pd_B = []operand{
    a_ARNG_Pn59V2_ArngBCheck,
    a_PREGZM_Pg1014_ZeroPredCheck,
    a_ARNG_Pd_ArngBCheck,
}
var Pn_B__Zd = []operand{
    a_ARNG_Pn59V2_ArngBCheck,
    a_ZREG_Zd_Noop,
}
var Pn_D__Zd_imm_ = []operand{
    a_ARNG_Pn59V2_ArngDCheck,
    a_ZREGIDX_Zd_Noop_I3hI3l_1722_Doubleword,
}
var Pn_H__Zd_imm_ = []operand{
    a_ARNG_Pn59V2_ArngHCheck,
    a_ZREGIDX_Zd_Noop_I1_1718_Halfword,
}
var Pn_S__Zd_imm_ = []operand{
    a_ARNG_Pn59V2_ArngSCheck,
    a_ZREGIDX_Zd_Noop_I2_1719_Word,
}
var Pn_T__Pd_T = []operand{
    a_ARNG_Pn59V2_SizeBHSD2224,
    a_ARNG_Pd_SizeBHSD2224,
}
var Pn_T__Pg__Xd = []operand{
    a_ARNG_Pn59V2_SizeBHSD2224,
    a_PREG_Pg1014_Noop,
    a_SPZGREG_Noop_Rd05,
}
var Pt___XnSP__cimm__MUL_VL_ = []operand{
    a_PREG_Pt04V2_Noop,
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm9h1622L1013,
}
var Rm__Rn = []operand{
    a_SPZGREG_Noop_Rm1621ZR,
    a_SPZGREG_Noop_Rn510ZR,
}
var Rm__Rn__Pd_T = []operand{
    a_SPZGREG_Noop_Rm1621ZR,
    a_SPZGREG_Noop_Rn510ZR,
    a_ARNG_Pd_SizeBHSD2224,
}
var Rm__Rn__Zd_T = []operand{
    a_SPZGREG_Noop_Rm1621ZR,
    a_SPZGREG_Noop_Rn510ZR,
    a_ARNG_Zd_SizeBHSD2224,
}
var Rm__Zdn_T = []operand{
    a_SPZGREG_Noop_Rm510ZR,
    a_ARNG_ZdnSrcDst_SizeBHSD2224,
}
var Rm__cimm__Zd_T = []operand{
    a_SPZGREG_Noop_Rm1621ZR,
    a_IMM_Imm5Signed510Unique,
    a_ARNG_Zd_SizeBHSD2224,
}
var RnSP__PgM__Zd_T = []operand{
    a_SPZGREG_Noop_Rn510SPV1,
    a_PREGZM_Pg1013_MergePredCheck,
    a_ARNG_Zd_SizeBHSD2224,
}
var RnSP__Zd_T = []operand{
    a_SPZGREG_Noop_Rn510SPV1,
    a_ARNG_Zd_SizeBHSD2224,
}
var SystemReg = []struct {
    Name string
    Reg  int16
    Enc  uint32
    // AccessFlags is the readable and writeable property of system register.
    AccessFlags uint8
}{
    {"ACTLR_EL1", REG_ACTLR_EL1, 0x181020, SR_READ | SR_WRITE},
    {"AFSR0_EL1", REG_AFSR0_EL1, 0x185100, SR_READ | SR_WRITE},
    {"AFSR1_EL1", REG_AFSR1_EL1, 0x185120, SR_READ | SR_WRITE},
    {"AIDR_EL1", REG_AIDR_EL1, 0x1900e0, SR_READ},
    {"AMAIR_EL1", REG_AMAIR_EL1, 0x18a300, SR_READ | SR_WRITE},
    {"AMCFGR_EL0", REG_AMCFGR_EL0, 0x1bd220, SR_READ},
    {"AMCGCR_EL0", REG_AMCGCR_EL0, 0x1bd240, SR_READ},
    {"AMCNTENCLR0_EL0", REG_AMCNTENCLR0_EL0, 0x1bd280, SR_READ | SR_WRITE},
    {"AMCNTENCLR1_EL0", REG_AMCNTENCLR1_EL0, 0x1bd300, SR_READ | SR_WRITE},
    {"AMCNTENSET0_EL0", REG_AMCNTENSET0_EL0, 0x1bd2a0, SR_READ | SR_WRITE},
    {"AMCNTENSET1_EL0", REG_AMCNTENSET1_EL0, 0x1bd320, SR_READ | SR_WRITE},
    {"AMCR_EL0", REG_AMCR_EL0, 0x1bd200, SR_READ | SR_WRITE},
    {"AMEVCNTR00_EL0", REG_AMEVCNTR00_EL0, 0x1bd400, SR_READ | SR_WRITE},
    {"AMEVCNTR01_EL0", REG_AMEVCNTR01_EL0, 0x1bd420, SR_READ | SR_WRITE},
    {"AMEVCNTR02_EL0", REG_AMEVCNTR02_EL0, 0x1bd440, SR_READ | SR_WRITE},
    {"AMEVCNTR03_EL0", REG_AMEVCNTR03_EL0, 0x1bd460, SR_READ | SR_WRITE},
    {"AMEVCNTR04_EL0", REG_AMEVCNTR04_EL0, 0x1bd480, SR_READ | SR_WRITE},
    {"AMEVCNTR05_EL0", REG_AMEVCNTR05_EL0, 0x1bd4a0, SR_READ | SR_WRITE},
    {"AMEVCNTR06_EL0", REG_AMEVCNTR06_EL0, 0x1bd4c0, SR_READ | SR_WRITE},
    {"AMEVCNTR07_EL0", REG_AMEVCNTR07_EL0, 0x1bd4e0, SR_READ | SR_WRITE},
    {"AMEVCNTR08_EL0", REG_AMEVCNTR08_EL0, 0x1bd500, SR_READ | SR_WRITE},
    {"AMEVCNTR09_EL0", REG_AMEVCNTR09_EL0, 0x1bd520, SR_READ | SR_WRITE},
    {"AMEVCNTR010_EL0", REG_AMEVCNTR010_EL0, 0x1bd540, SR_READ | SR_WRITE},
    {"AMEVCNTR011_EL0", REG_AMEVCNTR011_EL0, 0x1bd560, SR_READ | SR_WRITE},
    {"AMEVCNTR012_EL0", REG_AMEVCNTR012_EL0, 0x1bd580, SR_READ | SR_WRITE},
    {"AMEVCNTR013_EL0", REG_AMEVCNTR013_EL0, 0x1bd5a0, SR_READ | SR_WRITE},
    {"AMEVCNTR014_EL0", REG_AMEVCNTR014_EL0, 0x1bd5c0, SR_READ | SR_WRITE},
    {"AMEVCNTR015_EL0", REG_AMEVCNTR015_EL0, 0x1bd5e0, SR_READ | SR_WRITE},
    {"AMEVCNTR10_EL0", REG_AMEVCNTR10_EL0, 0x1bdc00, SR_READ | SR_WRITE},
    {"AMEVCNTR11_EL0", REG_AMEVCNTR11_EL0, 0x1bdc20, SR_READ | SR_WRITE},
    {"AMEVCNTR12_EL0", REG_AMEVCNTR12_EL0, 0x1bdc40, SR_READ | SR_WRITE},
    {"AMEVCNTR13_EL0", REG_AMEVCNTR13_EL0, 0x1bdc60, SR_READ | SR_WRITE},
    {"AMEVCNTR14_EL0", REG_AMEVCNTR14_EL0, 0x1bdc80, SR_READ | SR_WRITE},
    {"AMEVCNTR15_EL0", REG_AMEVCNTR15_EL0, 0x1bdca0, SR_READ | SR_WRITE},
    {"AMEVCNTR16_EL0", REG_AMEVCNTR16_EL0, 0x1bdcc0, SR_READ | SR_WRITE},
    {"AMEVCNTR17_EL0", REG_AMEVCNTR17_EL0, 0x1bdce0, SR_READ | SR_WRITE},
    {"AMEVCNTR18_EL0", REG_AMEVCNTR18_EL0, 0x1bdd00, SR_READ | SR_WRITE},
    {"AMEVCNTR19_EL0", REG_AMEVCNTR19_EL0, 0x1bdd20, SR_READ | SR_WRITE},
    {"AMEVCNTR110_EL0", REG_AMEVCNTR110_EL0, 0x1bdd40, SR_READ | SR_WRITE},
    {"AMEVCNTR111_EL0", REG_AMEVCNTR111_EL0, 0x1bdd60, SR_READ | SR_WRITE},
    {"AMEVCNTR112_EL0", REG_AMEVCNTR112_EL0, 0x1bdd80, SR_READ | SR_WRITE},
    {"AMEVCNTR113_EL0", REG_AMEVCNTR113_EL0, 0x1bdda0, SR_READ | SR_WRITE},
    {"AMEVCNTR114_EL0", REG_AMEVCNTR114_EL0, 0x1bddc0, SR_READ | SR_WRITE},
    {"AMEVCNTR115_EL0", REG_AMEVCNTR115_EL0, 0x1bdde0, SR_READ | SR_WRITE},
    {"AMEVTYPER00_EL0", REG_AMEVTYPER00_EL0, 0x1bd600, SR_READ},
    {"AMEVTYPER01_EL0", REG_AMEVTYPER01_EL0, 0x1bd620, SR_READ},
    {"AMEVTYPER02_EL0", REG_AMEVTYPER02_EL0, 0x1bd640, SR_READ},
    {"AMEVTYPER03_EL0", REG_AMEVTYPER03_EL0, 0x1bd660, SR_READ},
    {"AMEVTYPER04_EL0", REG_AMEVTYPER04_EL0, 0x1bd680, SR_READ},
    {"AMEVTYPER05_EL0", REG_AMEVTYPER05_EL0, 0x1bd6a0, SR_READ},
    {"AMEVTYPER06_EL0", REG_AMEVTYPER06_EL0, 0x1bd6c0, SR_READ},
    {"AMEVTYPER07_EL0", REG_AMEVTYPER07_EL0, 0x1bd6e0, SR_READ},
    {"AMEVTYPER08_EL0", REG_AMEVTYPER08_EL0, 0x1bd700, SR_READ},
    {"AMEVTYPER09_EL0", REG_AMEVTYPER09_EL0, 0x1bd720, SR_READ},
    {"AMEVTYPER010_EL0", REG_AMEVTYPER010_EL0, 0x1bd740, SR_READ},
    {"AMEVTYPER011_EL0", REG_AMEVTYPER011_EL0, 0x1bd760, SR_READ},
    {"AMEVTYPER012_EL0", REG_AMEVTYPER012_EL0, 0x1bd780, SR_READ},
    {"AMEVTYPER013_EL0", REG_AMEVTYPER013_EL0, 0x1bd7a0, SR_READ},
    {"AMEVTYPER014_EL0", REG_AMEVTYPER014_EL0, 0x1bd7c0, SR_READ},
    {"AMEVTYPER015_EL0", REG_AMEVTYPER015_EL0, 0x1bd7e0, SR_READ},
    {"AMEVTYPER10_EL0", REG_AMEVTYPER10_EL0, 0x1bde00, SR_READ | SR_WRITE},
    {"AMEVTYPER11_EL0", REG_AMEVTYPER11_EL0, 0x1bde20, SR_READ | SR_WRITE},
    {"AMEVTYPER12_EL0", REG_AMEVTYPER12_EL0, 0x1bde40, SR_READ | SR_WRITE},
    {"AMEVTYPER13_EL0", REG_AMEVTYPER13_EL0, 0x1bde60, SR_READ | SR_WRITE},
    {"AMEVTYPER14_EL0", REG_AMEVTYPER14_EL0, 0x1bde80, SR_READ | SR_WRITE},
    {"AMEVTYPER15_EL0", REG_AMEVTYPER15_EL0, 0x1bdea0, SR_READ | SR_WRITE},
    {"AMEVTYPER16_EL0", REG_AMEVTYPER16_EL0, 0x1bdec0, SR_READ | SR_WRITE},
    {"AMEVTYPER17_EL0", REG_AMEVTYPER17_EL0, 0x1bdee0, SR_READ | SR_WRITE},
    {"AMEVTYPER18_EL0", REG_AMEVTYPER18_EL0, 0x1bdf00, SR_READ | SR_WRITE},
    {"AMEVTYPER19_EL0", REG_AMEVTYPER19_EL0, 0x1bdf20, SR_READ | SR_WRITE},
    {"AMEVTYPER110_EL0", REG_AMEVTYPER110_EL0, 0x1bdf40, SR_READ | SR_WRITE},
    {"AMEVTYPER111_EL0", REG_AMEVTYPER111_EL0, 0x1bdf60, SR_READ | SR_WRITE},
    {"AMEVTYPER112_EL0", REG_AMEVTYPER112_EL0, 0x1bdf80, SR_READ | SR_WRITE},
    {"AMEVTYPER113_EL0", REG_AMEVTYPER113_EL0, 0x1bdfa0, SR_READ | SR_WRITE},
    {"AMEVTYPER114_EL0", REG_AMEVTYPER114_EL0, 0x1bdfc0, SR_READ | SR_WRITE},
    {"AMEVTYPER115_EL0", REG_AMEVTYPER115_EL0, 0x1bdfe0, SR_READ | SR_WRITE},
    {"AMUSERENR_EL0", REG_AMUSERENR_EL0, 0x1bd260, SR_READ | SR_WRITE},
    {"APDAKeyHi_EL1", REG_APDAKeyHi_EL1, 0x182220, SR_READ | SR_WRITE},
    {"APDAKeyLo_EL1", REG_APDAKeyLo_EL1, 0x182200, SR_READ | SR_WRITE},
    {"APDBKeyHi_EL1", REG_APDBKeyHi_EL1, 0x182260, SR_READ | SR_WRITE},
    {"APDBKeyLo_EL1", REG_APDBKeyLo_EL1, 0x182240, SR_READ | SR_WRITE},
    {"APGAKeyHi_EL1", REG_APGAKeyHi_EL1, 0x182320, SR_READ | SR_WRITE},
    {"APGAKeyLo_EL1", REG_APGAKeyLo_EL1, 0x182300, SR_READ | SR_WRITE},
    {"APIAKeyHi_EL1", REG_APIAKeyHi_EL1, 0x182120, SR_READ | SR_WRITE},
    {"APIAKeyLo_EL1", REG_APIAKeyLo_EL1, 0x182100, SR_READ | SR_WRITE},
    {"APIBKeyHi_EL1", REG_APIBKeyHi_EL1, 0x182160, SR_READ | SR_WRITE},
    {"APIBKeyLo_EL1", REG_APIBKeyLo_EL1, 0x182140, SR_READ | SR_WRITE},
    {"CCSIDR2_EL1", REG_CCSIDR2_EL1, 0x190040, SR_READ},
    {"CCSIDR_EL1", REG_CCSIDR_EL1, 0x190000, SR_READ},
    {"CLIDR_EL1", REG_CLIDR_EL1, 0x190020, SR_READ},
    {"CNTFRQ_EL0", REG_CNTFRQ_EL0, 0x1be000, SR_READ | SR_WRITE},
    {"CNTKCTL_EL1", REG_CNTKCTL_EL1, 0x18e100, SR_READ | SR_WRITE},
    {"CNTP_CTL_EL0", REG_CNTP_CTL_EL0, 0x1be220, SR_READ | SR_WRITE},
    {"CNTP_CVAL_EL0", REG_CNTP_CVAL_EL0, 0x1be240, SR_READ | SR_WRITE},
    {"CNTP_TVAL_EL0", REG_CNTP_TVAL_EL0, 0x1be200, SR_READ | SR_WRITE},
    {"CNTPCT_EL0", REG_CNTPCT_EL0, 0x1be020, SR_READ},
    {"CNTPS_CTL_EL1", REG_CNTPS_CTL_EL1, 0x1fe220, SR_READ | SR_WRITE},
    {"CNTPS_CVAL_EL1", REG_CNTPS_CVAL_EL1, 0x1fe240, SR_READ | SR_WRITE},
    {"CNTPS_TVAL_EL1", REG_CNTPS_TVAL_EL1, 0x1fe200, SR_READ | SR_WRITE},
    {"CNTV_CTL_EL0", REG_CNTV_CTL_EL0, 0x1be320, SR_READ | SR_WRITE},
    {"CNTV_CVAL_EL0", REG_CNTV_CVAL_EL0, 0x1be340, SR_READ | SR_WRITE},
    {"CNTV_TVAL_EL0", REG_CNTV_TVAL_EL0, 0x1be300, SR_READ | SR_WRITE},
    {"CNTVCT_EL0", REG_CNTVCT_EL0, 0x1be040, SR_READ},
    {"CONTEXTIDR_EL1", REG_CONTEXTIDR_EL1, 0x18d020, SR_READ | SR_WRITE},
    {"CPACR_EL1", REG_CPACR_EL1, 0x181040, SR_READ | SR_WRITE},
    {"CSSELR_EL1", REG_CSSELR_EL1, 0x1a0000, SR_READ | SR_WRITE},
    {"CTR_EL0", REG_CTR_EL0, 0x1b0020, SR_READ},
    {"CurrentEL", REG_CurrentEL, 0x184240, SR_READ},
    {"DAIF", REG_DAIF, 0x1b4220, SR_READ | SR_WRITE},
    {"DBGAUTHSTATUS_EL1", REG_DBGAUTHSTATUS_EL1, 0x107ec0, SR_READ},
    {"DBGBCR0_EL1", REG_DBGBCR0_EL1, 0x1000a0, SR_READ | SR_WRITE},
    {"DBGBCR1_EL1", REG_DBGBCR1_EL1, 0x1001a0, SR_READ | SR_WRITE},
    {"DBGBCR2_EL1", REG_DBGBCR2_EL1, 0x1002a0, SR_READ | SR_WRITE},
    {"DBGBCR3_EL1", REG_DBGBCR3_EL1, 0x1003a0, SR_READ | SR_WRITE},
    {"DBGBCR4_EL1", REG_DBGBCR4_EL1, 0x1004a0, SR_READ | SR_WRITE},
    {"DBGBCR5_EL1", REG_DBGBCR5_EL1, 0x1005a0, SR_READ | SR_WRITE},
    {"DBGBCR6_EL1", REG_DBGBCR6_EL1, 0x1006a0, SR_READ | SR_WRITE},
    {"DBGBCR7_EL1", REG_DBGBCR7_EL1, 0x1007a0, SR_READ | SR_WRITE},
    {"DBGBCR8_EL1", REG_DBGBCR8_EL1, 0x1008a0, SR_READ | SR_WRITE},
    {"DBGBCR9_EL1", REG_DBGBCR9_EL1, 0x1009a0, SR_READ | SR_WRITE},
    {"DBGBCR10_EL1", REG_DBGBCR10_EL1, 0x100aa0, SR_READ | SR_WRITE},
    {"DBGBCR11_EL1", REG_DBGBCR11_EL1, 0x100ba0, SR_READ | SR_WRITE},
    {"DBGBCR12_EL1", REG_DBGBCR12_EL1, 0x100ca0, SR_READ | SR_WRITE},
    {"DBGBCR13_EL1", REG_DBGBCR13_EL1, 0x100da0, SR_READ | SR_WRITE},
    {"DBGBCR14_EL1", REG_DBGBCR14_EL1, 0x100ea0, SR_READ | SR_WRITE},
    {"DBGBCR15_EL1", REG_DBGBCR15_EL1, 0x100fa0, SR_READ | SR_WRITE},
    {"DBGBVR0_EL1", REG_DBGBVR0_EL1, 0x100080, SR_READ | SR_WRITE},
    {"DBGBVR1_EL1", REG_DBGBVR1_EL1, 0x100180, SR_READ | SR_WRITE},
    {"DBGBVR2_EL1", REG_DBGBVR2_EL1, 0x100280, SR_READ | SR_WRITE},
    {"DBGBVR3_EL1", REG_DBGBVR3_EL1, 0x100380, SR_READ | SR_WRITE},
    {"DBGBVR4_EL1", REG_DBGBVR4_EL1, 0x100480, SR_READ | SR_WRITE},
    {"DBGBVR5_EL1", REG_DBGBVR5_EL1, 0x100580, SR_READ | SR_WRITE},
    {"DBGBVR6_EL1", REG_DBGBVR6_EL1, 0x100680, SR_READ | SR_WRITE},
    {"DBGBVR7_EL1", REG_DBGBVR7_EL1, 0x100780, SR_READ | SR_WRITE},
    {"DBGBVR8_EL1", REG_DBGBVR8_EL1, 0x100880, SR_READ | SR_WRITE},
    {"DBGBVR9_EL1", REG_DBGBVR9_EL1, 0x100980, SR_READ | SR_WRITE},
    {"DBGBVR10_EL1", REG_DBGBVR10_EL1, 0x100a80, SR_READ | SR_WRITE},
    {"DBGBVR11_EL1", REG_DBGBVR11_EL1, 0x100b80, SR_READ | SR_WRITE},
    {"DBGBVR12_EL1", REG_DBGBVR12_EL1, 0x100c80, SR_READ | SR_WRITE},
    {"DBGBVR13_EL1", REG_DBGBVR13_EL1, 0x100d80, SR_READ | SR_WRITE},
    {"DBGBVR14_EL1", REG_DBGBVR14_EL1, 0x100e80, SR_READ | SR_WRITE},
    {"DBGBVR15_EL1", REG_DBGBVR15_EL1, 0x100f80, SR_READ | SR_WRITE},
    {"DBGCLAIMCLR_EL1", REG_DBGCLAIMCLR_EL1, 0x1079c0, SR_READ | SR_WRITE},
    {"DBGCLAIMSET_EL1", REG_DBGCLAIMSET_EL1, 0x1078c0, SR_READ | SR_WRITE},
    {"DBGDTR_EL0", REG_DBGDTR_EL0, 0x130400, SR_READ | SR_WRITE},
    {"DBGDTRRX_EL0", REG_DBGDTRRX_EL0, 0x130500, SR_READ},
    {"DBGDTRTX_EL0", REG_DBGDTRTX_EL0, 0x130500, SR_WRITE},
    {"DBGPRCR_EL1", REG_DBGPRCR_EL1, 0x101480, SR_READ | SR_WRITE},
    {"DBGWCR0_EL1", REG_DBGWCR0_EL1, 0x1000e0, SR_READ | SR_WRITE},
    {"DBGWCR1_EL1", REG_DBGWCR1_EL1, 0x1001e0, SR_READ | SR_WRITE},
    {"DBGWCR2_EL1", REG_DBGWCR2_EL1, 0x1002e0, SR_READ | SR_WRITE},
    {"DBGWCR3_EL1", REG_DBGWCR3_EL1, 0x1003e0, SR_READ | SR_WRITE},
    {"DBGWCR4_EL1", REG_DBGWCR4_EL1, 0x1004e0, SR_READ | SR_WRITE},
    {"DBGWCR5_EL1", REG_DBGWCR5_EL1, 0x1005e0, SR_READ | SR_WRITE},
    {"DBGWCR6_EL1", REG_DBGWCR6_EL1, 0x1006e0, SR_READ | SR_WRITE},
    {"DBGWCR7_EL1", REG_DBGWCR7_EL1, 0x1007e0, SR_READ | SR_WRITE},
    {"DBGWCR8_EL1", REG_DBGWCR8_EL1, 0x1008e0, SR_READ | SR_WRITE},
    {"DBGWCR9_EL1", REG_DBGWCR9_EL1, 0x1009e0, SR_READ | SR_WRITE},
    {"DBGWCR10_EL1", REG_DBGWCR10_EL1, 0x100ae0, SR_READ | SR_WRITE},
    {"DBGWCR11_EL1", REG_DBGWCR11_EL1, 0x100be0, SR_READ | SR_WRITE},
    {"DBGWCR12_EL1", REG_DBGWCR12_EL1, 0x100ce0, SR_READ | SR_WRITE},
    {"DBGWCR13_EL1", REG_DBGWCR13_EL1, 0x100de0, SR_READ | SR_WRITE},
    {"DBGWCR14_EL1", REG_DBGWCR14_EL1, 0x100ee0, SR_READ | SR_WRITE},
    {"DBGWCR15_EL1", REG_DBGWCR15_EL1, 0x100fe0, SR_READ | SR_WRITE},
    {"DBGWVR0_EL1", REG_DBGWVR0_EL1, 0x1000c0, SR_READ | SR_WRITE},
    {"DBGWVR1_EL1", REG_DBGWVR1_EL1, 0x1001c0, SR_READ | SR_WRITE},
    {"DBGWVR2_EL1", REG_DBGWVR2_EL1, 0x1002c0, SR_READ | SR_WRITE},
    {"DBGWVR3_EL1", REG_DBGWVR3_EL1, 0x1003c0, SR_READ | SR_WRITE},
    {"DBGWVR4_EL1", REG_DBGWVR4_EL1, 0x1004c0, SR_READ | SR_WRITE},
    {"DBGWVR5_EL1", REG_DBGWVR5_EL1, 0x1005c0, SR_READ | SR_WRITE},
    {"DBGWVR6_EL1", REG_DBGWVR6_EL1, 0x1006c0, SR_READ | SR_WRITE},
    {"DBGWVR7_EL1", REG_DBGWVR7_EL1, 0x1007c0, SR_READ | SR_WRITE},
    {"DBGWVR8_EL1", REG_DBGWVR8_EL1, 0x1008c0, SR_READ | SR_WRITE},
    {"DBGWVR9_EL1", REG_DBGWVR9_EL1, 0x1009c0, SR_READ | SR_WRITE},
    {"DBGWVR10_EL1", REG_DBGWVR10_EL1, 0x100ac0, SR_READ | SR_WRITE},
    {"DBGWVR11_EL1", REG_DBGWVR11_EL1, 0x100bc0, SR_READ | SR_WRITE},
    {"DBGWVR12_EL1", REG_DBGWVR12_EL1, 0x100cc0, SR_READ | SR_WRITE},
    {"DBGWVR13_EL1", REG_DBGWVR13_EL1, 0x100dc0, SR_READ | SR_WRITE},
    {"DBGWVR14_EL1", REG_DBGWVR14_EL1, 0x100ec0, SR_READ | SR_WRITE},
    {"DBGWVR15_EL1", REG_DBGWVR15_EL1, 0x100fc0, SR_READ | SR_WRITE},
    {"DCZID_EL0", REG_DCZID_EL0, 0x1b00e0, SR_READ},
    {"DISR_EL1", REG_DISR_EL1, 0x18c120, SR_READ | SR_WRITE},
    {"DIT", REG_DIT, 0x1b42a0, SR_READ | SR_WRITE},
    {"DLR_EL0", REG_DLR_EL0, 0x1b4520, SR_READ | SR_WRITE},
    {"DSPSR_EL0", REG_DSPSR_EL0, 0x1b4500, SR_READ | SR_WRITE},
    {"ELR_EL1", REG_ELR_EL1, 0x184020, SR_READ | SR_WRITE},
    {"ERRIDR_EL1", REG_ERRIDR_EL1, 0x185300, SR_READ},
    {"ERRSELR_EL1", REG_ERRSELR_EL1, 0x185320, SR_READ | SR_WRITE},
    {"ERXADDR_EL1", REG_ERXADDR_EL1, 0x185460, SR_READ | SR_WRITE},
    {"ERXCTLR_EL1", REG_ERXCTLR_EL1, 0x185420, SR_READ | SR_WRITE},
    {"ERXFR_EL1", REG_ERXFR_EL1, 0x185400, SR_READ},
    {"ERXMISC0_EL1", REG_ERXMISC0_EL1, 0x185500, SR_READ | SR_WRITE},
    {"ERXMISC1_EL1", REG_ERXMISC1_EL1, 0x185520, SR_READ | SR_WRITE},
    {"ERXMISC2_EL1", REG_ERXMISC2_EL1, 0x185540, SR_READ | SR_WRITE},
    {"ERXMISC3_EL1", REG_ERXMISC3_EL1, 0x185560, SR_READ | SR_WRITE},
    {"ERXPFGCDN_EL1", REG_ERXPFGCDN_EL1, 0x1854c0, SR_READ | SR_WRITE},
    {"ERXPFGCTL_EL1", REG_ERXPFGCTL_EL1, 0x1854a0, SR_READ | SR_WRITE},
    {"ERXPFGF_EL1", REG_ERXPFGF_EL1, 0x185480, SR_READ},
    {"ERXSTATUS_EL1", REG_ERXSTATUS_EL1, 0x185440, SR_READ | SR_WRITE},
    {"ESR_EL1", REG_ESR_EL1, 0x185200, SR_READ | SR_WRITE},
    {"FAR_EL1", REG_FAR_EL1, 0x186000, SR_READ | SR_WRITE},
    {"FPCR", REG_FPCR, 0x1b4400, SR_READ | SR_WRITE},
    {"FPSR", REG_FPSR, 0x1b4420, SR_READ | SR_WRITE},
    {"GCR_EL1", REG_GCR_EL1, 0x1810c0, SR_READ | SR_WRITE},
    {"GMID_EL1", REG_GMID_EL1, 0x31400, SR_READ},
    {"ICC_AP0R0_EL1", REG_ICC_AP0R0_EL1, 0x18c880, SR_READ | SR_WRITE},
    {"ICC_AP0R1_EL1", REG_ICC_AP0R1_EL1, 0x18c8a0, SR_READ | SR_WRITE},
    {"ICC_AP0R2_EL1", REG_ICC_AP0R2_EL1, 0x18c8c0, SR_READ | SR_WRITE},
    {"ICC_AP0R3_EL1", REG_ICC_AP0R3_EL1, 0x18c8e0, SR_READ | SR_WRITE},
    {"ICC_AP1R0_EL1", REG_ICC_AP1R0_EL1, 0x18c900, SR_READ | SR_WRITE},
    {"ICC_AP1R1_EL1", REG_ICC_AP1R1_EL1, 0x18c920, SR_READ | SR_WRITE},
    {"ICC_AP1R2_EL1", REG_ICC_AP1R2_EL1, 0x18c940, SR_READ | SR_WRITE},
    {"ICC_AP1R3_EL1", REG_ICC_AP1R3_EL1, 0x18c960, SR_READ | SR_WRITE},
    {"ICC_ASGI1R_EL1", REG_ICC_ASGI1R_EL1, 0x18cbc0, SR_WRITE},
    {"ICC_BPR0_EL1", REG_ICC_BPR0_EL1, 0x18c860, SR_READ | SR_WRITE},
    {"ICC_BPR1_EL1", REG_ICC_BPR1_EL1, 0x18cc60, SR_READ | SR_WRITE},
    {"ICC_CTLR_EL1", REG_ICC_CTLR_EL1, 0x18cc80, SR_READ | SR_WRITE},
    {"ICC_DIR_EL1", REG_ICC_DIR_EL1, 0x18cb20, SR_WRITE},
    {"ICC_EOIR0_EL1", REG_ICC_EOIR0_EL1, 0x18c820, SR_WRITE},
    {"ICC_EOIR1_EL1", REG_ICC_EOIR1_EL1, 0x18cc20, SR_WRITE},
    {"ICC_HPPIR0_EL1", REG_ICC_HPPIR0_EL1, 0x18c840, SR_READ},
    {"ICC_HPPIR1_EL1", REG_ICC_HPPIR1_EL1, 0x18cc40, SR_READ},
    {"ICC_IAR0_EL1", REG_ICC_IAR0_EL1, 0x18c800, SR_READ},
    {"ICC_IAR1_EL1", REG_ICC_IAR1_EL1, 0x18cc00, SR_READ},
    {"ICC_IGRPEN0_EL1", REG_ICC_IGRPEN0_EL1, 0x18ccc0, SR_READ | SR_WRITE},
    {"ICC_IGRPEN1_EL1", REG_ICC_IGRPEN1_EL1, 0x18cce0, SR_READ | SR_WRITE},
    {"ICC_PMR_EL1", REG_ICC_PMR_EL1, 0x184600, SR_READ | SR_WRITE},
    {"ICC_RPR_EL1", REG_ICC_RPR_EL1, 0x18cb60, SR_READ},
    {"ICC_SGI0R_EL1", REG_ICC_SGI0R_EL1, 0x18cbe0, SR_WRITE},
    {"ICC_SGI1R_EL1", REG_ICC_SGI1R_EL1, 0x18cba0, SR_WRITE},
    {"ICC_SRE_EL1", REG_ICC_SRE_EL1, 0x18cca0, SR_READ | SR_WRITE},
    {"ICV_AP0R0_EL1", REG_ICV_AP0R0_EL1, 0x18c880, SR_READ | SR_WRITE},
    {"ICV_AP0R1_EL1", REG_ICV_AP0R1_EL1, 0x18c8a0, SR_READ | SR_WRITE},
    {"ICV_AP0R2_EL1", REG_ICV_AP0R2_EL1, 0x18c8c0, SR_READ | SR_WRITE},
    {"ICV_AP0R3_EL1", REG_ICV_AP0R3_EL1, 0x18c8e0, SR_READ | SR_WRITE},
    {"ICV_AP1R0_EL1", REG_ICV_AP1R0_EL1, 0x18c900, SR_READ | SR_WRITE},
    {"ICV_AP1R1_EL1", REG_ICV_AP1R1_EL1, 0x18c920, SR_READ | SR_WRITE},
    {"ICV_AP1R2_EL1", REG_ICV_AP1R2_EL1, 0x18c940, SR_READ | SR_WRITE},
    {"ICV_AP1R3_EL1", REG_ICV_AP1R3_EL1, 0x18c960, SR_READ | SR_WRITE},
    {"ICV_BPR0_EL1", REG_ICV_BPR0_EL1, 0x18c860, SR_READ | SR_WRITE},
    {"ICV_BPR1_EL1", REG_ICV_BPR1_EL1, 0x18cc60, SR_READ | SR_WRITE},
    {"ICV_CTLR_EL1", REG_ICV_CTLR_EL1, 0x18cc80, SR_READ | SR_WRITE},
    {"ICV_DIR_EL1", REG_ICV_DIR_EL1, 0x18cb20, SR_WRITE},
    {"ICV_EOIR0_EL1", REG_ICV_EOIR0_EL1, 0x18c820, SR_WRITE},
    {"ICV_EOIR1_EL1", REG_ICV_EOIR1_EL1, 0x18cc20, SR_WRITE},
    {"ICV_HPPIR0_EL1", REG_ICV_HPPIR0_EL1, 0x18c840, SR_READ},
    {"ICV_HPPIR1_EL1", REG_ICV_HPPIR1_EL1, 0x18cc40, SR_READ},
    {"ICV_IAR0_EL1", REG_ICV_IAR0_EL1, 0x18c800, SR_READ},
    {"ICV_IAR1_EL1", REG_ICV_IAR1_EL1, 0x18cc00, SR_READ},
    {"ICV_IGRPEN0_EL1", REG_ICV_IGRPEN0_EL1, 0x18ccc0, SR_READ | SR_WRITE},
    {"ICV_IGRPEN1_EL1", REG_ICV_IGRPEN1_EL1, 0x18cce0, SR_READ | SR_WRITE},
    {"ICV_PMR_EL1", REG_ICV_PMR_EL1, 0x184600, SR_READ | SR_WRITE},
    {"ICV_RPR_EL1", REG_ICV_RPR_EL1, 0x18cb60, SR_READ},
    {"ID_AA64AFR0_EL1", REG_ID_AA64AFR0_EL1, 0x180580, SR_READ},
    {"ID_AA64AFR1_EL1", REG_ID_AA64AFR1_EL1, 0x1805a0, SR_READ},
    {"ID_AA64DFR0_EL1", REG_ID_AA64DFR0_EL1, 0x180500, SR_READ},
    {"ID_AA64DFR1_EL1", REG_ID_AA64DFR1_EL1, 0x180520, SR_READ},
    {"ID_AA64ISAR0_EL1", REG_ID_AA64ISAR0_EL1, 0x180600, SR_READ},
    {"ID_AA64ISAR1_EL1", REG_ID_AA64ISAR1_EL1, 0x180620, SR_READ},
    {"ID_AA64MMFR0_EL1", REG_ID_AA64MMFR0_EL1, 0x180700, SR_READ},
    {"ID_AA64MMFR1_EL1", REG_ID_AA64MMFR1_EL1, 0x180720, SR_READ},
    {"ID_AA64MMFR2_EL1", REG_ID_AA64MMFR2_EL1, 0x180740, SR_READ},
    {"ID_AA64PFR0_EL1", REG_ID_AA64PFR0_EL1, 0x180400, SR_READ},
    {"ID_AA64PFR1_EL1", REG_ID_AA64PFR1_EL1, 0x180420, SR_READ},
    {"ID_AA64ZFR0_EL1", REG_ID_AA64ZFR0_EL1, 0x180480, SR_READ},
    {"ID_AFR0_EL1", REG_ID_AFR0_EL1, 0x180160, SR_READ},
    {"ID_DFR0_EL1", REG_ID_DFR0_EL1, 0x180140, SR_READ},
    {"ID_ISAR0_EL1", REG_ID_ISAR0_EL1, 0x180200, SR_READ},
    {"ID_ISAR1_EL1", REG_ID_ISAR1_EL1, 0x180220, SR_READ},
    {"ID_ISAR2_EL1", REG_ID_ISAR2_EL1, 0x180240, SR_READ},
    {"ID_ISAR3_EL1", REG_ID_ISAR3_EL1, 0x180260, SR_READ},
    {"ID_ISAR4_EL1", REG_ID_ISAR4_EL1, 0x180280, SR_READ},
    {"ID_ISAR5_EL1", REG_ID_ISAR5_EL1, 0x1802a0, SR_READ},
    {"ID_ISAR6_EL1", REG_ID_ISAR6_EL1, 0x1802e0, SR_READ},
    {"ID_MMFR0_EL1", REG_ID_MMFR0_EL1, 0x180180, SR_READ},
    {"ID_MMFR1_EL1", REG_ID_MMFR1_EL1, 0x1801a0, SR_READ},
    {"ID_MMFR2_EL1", REG_ID_MMFR2_EL1, 0x1801c0, SR_READ},
    {"ID_MMFR3_EL1", REG_ID_MMFR3_EL1, 0x1801e0, SR_READ},
    {"ID_MMFR4_EL1", REG_ID_MMFR4_EL1, 0x1802c0, SR_READ},
    {"ID_PFR0_EL1", REG_ID_PFR0_EL1, 0x180100, SR_READ},
    {"ID_PFR1_EL1", REG_ID_PFR1_EL1, 0x180120, SR_READ},
    {"ID_PFR2_EL1", REG_ID_PFR2_EL1, 0x180380, SR_READ},
    {"ISR_EL1", REG_ISR_EL1, 0x18c100, SR_READ},
    {"LORC_EL1", REG_LORC_EL1, 0x18a460, SR_READ | SR_WRITE},
    {"LOREA_EL1", REG_LOREA_EL1, 0x18a420, SR_READ | SR_WRITE},
    {"LORID_EL1", REG_LORID_EL1, 0x18a4e0, SR_READ},
    {"LORN_EL1", REG_LORN_EL1, 0x18a440, SR_READ | SR_WRITE},
    {"LORSA_EL1", REG_LORSA_EL1, 0x18a400, SR_READ | SR_WRITE},
    {"MAIR_EL1", REG_MAIR_EL1, 0x18a200, SR_READ | SR_WRITE},
    {"MDCCINT_EL1", REG_MDCCINT_EL1, 0x100200, SR_READ | SR_WRITE},
    {"MDCCSR_EL0", REG_MDCCSR_EL0, 0x130100, SR_READ},
    {"MDRAR_EL1", REG_MDRAR_EL1, 0x101000, SR_READ},
    {"MDSCR_EL1", REG_MDSCR_EL1, 0x100240, SR_READ | SR_WRITE},
    {"MIDR_EL1", REG_MIDR_EL1, 0x180000, SR_READ},
    {"MPAM0_EL1", REG_MPAM0_EL1, 0x18a520, SR_READ | SR_WRITE},
    {"MPAM1_EL1", REG_MPAM1_EL1, 0x18a500, SR_READ | SR_WRITE},
    {"MPAMIDR_EL1", REG_MPAMIDR_EL1, 0x18a480, SR_READ},
    {"MPIDR_EL1", REG_MPIDR_EL1, 0x1800a0, SR_READ},
    {"MVFR0_EL1", REG_MVFR0_EL1, 0x180300, SR_READ},
    {"MVFR1_EL1", REG_MVFR1_EL1, 0x180320, SR_READ},
    {"MVFR2_EL1", REG_MVFR2_EL1, 0x180340, SR_READ},
    {"NZCV", REG_NZCV, 0x1b4200, SR_READ | SR_WRITE},
    {"OSDLR_EL1", REG_OSDLR_EL1, 0x101380, SR_READ | SR_WRITE},
    {"OSDTRRX_EL1", REG_OSDTRRX_EL1, 0x100040, SR_READ | SR_WRITE},
    {"OSDTRTX_EL1", REG_OSDTRTX_EL1, 0x100340, SR_READ | SR_WRITE},
    {"OSECCR_EL1", REG_OSECCR_EL1, 0x100640, SR_READ | SR_WRITE},
    {"OSLAR_EL1", REG_OSLAR_EL1, 0x101080, SR_WRITE},
    {"OSLSR_EL1", REG_OSLSR_EL1, 0x101180, SR_READ},
    {"PAN", REG_PAN, 0x184260, SR_READ | SR_WRITE},
    {"PAR_EL1", REG_PAR_EL1, 0x187400, SR_READ | SR_WRITE},
    {"PMBIDR_EL1", REG_PMBIDR_EL1, 0x189ae0, SR_READ},
    {"PMBLIMITR_EL1", REG_PMBLIMITR_EL1, 0x189a00, SR_READ | SR_WRITE},
    {"PMBPTR_EL1", REG_PMBPTR_EL1, 0x189a20, SR_READ | SR_WRITE},
    {"PMBSR_EL1", REG_PMBSR_EL1, 0x189a60, SR_READ | SR_WRITE},
    {"PMCCFILTR_EL0", REG_PMCCFILTR_EL0, 0x1befe0, SR_READ | SR_WRITE},
    {"PMCCNTR_EL0", REG_PMCCNTR_EL0, 0x1b9d00, SR_READ | SR_WRITE},
    {"PMCEID0_EL0", REG_PMCEID0_EL0, 0x1b9cc0, SR_READ},
    {"PMCEID1_EL0", REG_PMCEID1_EL0, 0x1b9ce0, SR_READ},
    {"PMCNTENCLR_EL0", REG_PMCNTENCLR_EL0, 0x1b9c40, SR_READ | SR_WRITE},
    {"PMCNTENSET_EL0", REG_PMCNTENSET_EL0, 0x1b9c20, SR_READ | SR_WRITE},
    {"PMCR_EL0", REG_PMCR_EL0, 0x1b9c00, SR_READ | SR_WRITE},
    {"PMEVCNTR0_EL0", REG_PMEVCNTR0_EL0, 0x1be800, SR_READ | SR_WRITE},
    {"PMEVCNTR1_EL0", REG_PMEVCNTR1_EL0, 0x1be820, SR_READ | SR_WRITE},
    {"PMEVCNTR2_EL0", REG_PMEVCNTR2_EL0, 0x1be840, SR_READ | SR_WRITE},
    {"PMEVCNTR3_EL0", REG_PMEVCNTR3_EL0, 0x1be860, SR_READ | SR_WRITE},
    {"PMEVCNTR4_EL0", REG_PMEVCNTR4_EL0, 0x1be880, SR_READ | SR_WRITE},
    {"PMEVCNTR5_EL0", REG_PMEVCNTR5_EL0, 0x1be8a0, SR_READ | SR_WRITE},
    {"PMEVCNTR6_EL0", REG_PMEVCNTR6_EL0, 0x1be8c0, SR_READ | SR_WRITE},
    {"PMEVCNTR7_EL0", REG_PMEVCNTR7_EL0, 0x1be8e0, SR_READ | SR_WRITE},
    {"PMEVCNTR8_EL0", REG_PMEVCNTR8_EL0, 0x1be900, SR_READ | SR_WRITE},
    {"PMEVCNTR9_EL0", REG_PMEVCNTR9_EL0, 0x1be920, SR_READ | SR_WRITE},
    {"PMEVCNTR10_EL0", REG_PMEVCNTR10_EL0, 0x1be940, SR_READ | SR_WRITE},
    {"PMEVCNTR11_EL0", REG_PMEVCNTR11_EL0, 0x1be960, SR_READ | SR_WRITE},
    {"PMEVCNTR12_EL0", REG_PMEVCNTR12_EL0, 0x1be980, SR_READ | SR_WRITE},
    {"PMEVCNTR13_EL0", REG_PMEVCNTR13_EL0, 0x1be9a0, SR_READ | SR_WRITE},
    {"PMEVCNTR14_EL0", REG_PMEVCNTR14_EL0, 0x1be9c0, SR_READ | SR_WRITE},
    {"PMEVCNTR15_EL0", REG_PMEVCNTR15_EL0, 0x1be9e0, SR_READ | SR_WRITE},
    {"PMEVCNTR16_EL0", REG_PMEVCNTR16_EL0, 0x1bea00, SR_READ | SR_WRITE},
    {"PMEVCNTR17_EL0", REG_PMEVCNTR17_EL0, 0x1bea20, SR_READ | SR_WRITE},
    {"PMEVCNTR18_EL0", REG_PMEVCNTR18_EL0, 0x1bea40, SR_READ | SR_WRITE},
    {"PMEVCNTR19_EL0", REG_PMEVCNTR19_EL0, 0x1bea60, SR_READ | SR_WRITE},
    {"PMEVCNTR20_EL0", REG_PMEVCNTR20_EL0, 0x1bea80, SR_READ | SR_WRITE},
    {"PMEVCNTR21_EL0", REG_PMEVCNTR21_EL0, 0x1beaa0, SR_READ | SR_WRITE},
    {"PMEVCNTR22_EL0", REG_PMEVCNTR22_EL0, 0x1beac0, SR_READ | SR_WRITE},
    {"PMEVCNTR23_EL0", REG_PMEVCNTR23_EL0, 0x1beae0, SR_READ | SR_WRITE},
    {"PMEVCNTR24_EL0", REG_PMEVCNTR24_EL0, 0x1beb00, SR_READ | SR_WRITE},
    {"PMEVCNTR25_EL0", REG_PMEVCNTR25_EL0, 0x1beb20, SR_READ | SR_WRITE},
    {"PMEVCNTR26_EL0", REG_PMEVCNTR26_EL0, 0x1beb40, SR_READ | SR_WRITE},
    {"PMEVCNTR27_EL0", REG_PMEVCNTR27_EL0, 0x1beb60, SR_READ | SR_WRITE},
    {"PMEVCNTR28_EL0", REG_PMEVCNTR28_EL0, 0x1beb80, SR_READ | SR_WRITE},
    {"PMEVCNTR29_EL0", REG_PMEVCNTR29_EL0, 0x1beba0, SR_READ | SR_WRITE},
    {"PMEVCNTR30_EL0", REG_PMEVCNTR30_EL0, 0x1bebc0, SR_READ | SR_WRITE},
    {"PMEVTYPER0_EL0", REG_PMEVTYPER0_EL0, 0x1bec00, SR_READ | SR_WRITE},
    {"PMEVTYPER1_EL0", REG_PMEVTYPER1_EL0, 0x1bec20, SR_READ | SR_WRITE},
    {"PMEVTYPER2_EL0", REG_PMEVTYPER2_EL0, 0x1bec40, SR_READ | SR_WRITE},
    {"PMEVTYPER3_EL0", REG_PMEVTYPER3_EL0, 0x1bec60, SR_READ | SR_WRITE},
    {"PMEVTYPER4_EL0", REG_PMEVTYPER4_EL0, 0x1bec80, SR_READ | SR_WRITE},
    {"PMEVTYPER5_EL0", REG_PMEVTYPER5_EL0, 0x1beca0, SR_READ | SR_WRITE},
    {"PMEVTYPER6_EL0", REG_PMEVTYPER6_EL0, 0x1becc0, SR_READ | SR_WRITE},
    {"PMEVTYPER7_EL0", REG_PMEVTYPER7_EL0, 0x1bece0, SR_READ | SR_WRITE},
    {"PMEVTYPER8_EL0", REG_PMEVTYPER8_EL0, 0x1bed00, SR_READ | SR_WRITE},
    {"PMEVTYPER9_EL0", REG_PMEVTYPER9_EL0, 0x1bed20, SR_READ | SR_WRITE},
    {"PMEVTYPER10_EL0", REG_PMEVTYPER10_EL0, 0x1bed40, SR_READ | SR_WRITE},
    {"PMEVTYPER11_EL0", REG_PMEVTYPER11_EL0, 0x1bed60, SR_READ | SR_WRITE},
    {"PMEVTYPER12_EL0", REG_PMEVTYPER12_EL0, 0x1bed80, SR_READ | SR_WRITE},
    {"PMEVTYPER13_EL0", REG_PMEVTYPER13_EL0, 0x1beda0, SR_READ | SR_WRITE},
    {"PMEVTYPER14_EL0", REG_PMEVTYPER14_EL0, 0x1bedc0, SR_READ | SR_WRITE},
    {"PMEVTYPER15_EL0", REG_PMEVTYPER15_EL0, 0x1bede0, SR_READ | SR_WRITE},
    {"PMEVTYPER16_EL0", REG_PMEVTYPER16_EL0, 0x1bee00, SR_READ | SR_WRITE},
    {"PMEVTYPER17_EL0", REG_PMEVTYPER17_EL0, 0x1bee20, SR_READ | SR_WRITE},
    {"PMEVTYPER18_EL0", REG_PMEVTYPER18_EL0, 0x1bee40, SR_READ | SR_WRITE},
    {"PMEVTYPER19_EL0", REG_PMEVTYPER19_EL0, 0x1bee60, SR_READ | SR_WRITE},
    {"PMEVTYPER20_EL0", REG_PMEVTYPER20_EL0, 0x1bee80, SR_READ | SR_WRITE},
    {"PMEVTYPER21_EL0", REG_PMEVTYPER21_EL0, 0x1beea0, SR_READ | SR_WRITE},
    {"PMEVTYPER22_EL0", REG_PMEVTYPER22_EL0, 0x1beec0, SR_READ | SR_WRITE},
    {"PMEVTYPER23_EL0", REG_PMEVTYPER23_EL0, 0x1beee0, SR_READ | SR_WRITE},
    {"PMEVTYPER24_EL0", REG_PMEVTYPER24_EL0, 0x1bef00, SR_READ | SR_WRITE},
    {"PMEVTYPER25_EL0", REG_PMEVTYPER25_EL0, 0x1bef20, SR_READ | SR_WRITE},
    {"PMEVTYPER26_EL0", REG_PMEVTYPER26_EL0, 0x1bef40, SR_READ | SR_WRITE},
    {"PMEVTYPER27_EL0", REG_PMEVTYPER27_EL0, 0x1bef60, SR_READ | SR_WRITE},
    {"PMEVTYPER28_EL0", REG_PMEVTYPER28_EL0, 0x1bef80, SR_READ | SR_WRITE},
    {"PMEVTYPER29_EL0", REG_PMEVTYPER29_EL0, 0x1befa0, SR_READ | SR_WRITE},
    {"PMEVTYPER30_EL0", REG_PMEVTYPER30_EL0, 0x1befc0, SR_READ | SR_WRITE},
    {"PMINTENCLR_EL1", REG_PMINTENCLR_EL1, 0x189e40, SR_READ | SR_WRITE},
    {"PMINTENSET_EL1", REG_PMINTENSET_EL1, 0x189e20, SR_READ | SR_WRITE},
    {"PMMIR_EL1", REG_PMMIR_EL1, 0x189ec0, SR_READ},
    {"PMOVSCLR_EL0", REG_PMOVSCLR_EL0, 0x1b9c60, SR_READ | SR_WRITE},
    {"PMOVSSET_EL0", REG_PMOVSSET_EL0, 0x1b9e60, SR_READ | SR_WRITE},
    {"PMSCR_EL1", REG_PMSCR_EL1, 0x189900, SR_READ | SR_WRITE},
    {"PMSELR_EL0", REG_PMSELR_EL0, 0x1b9ca0, SR_READ | SR_WRITE},
    {"PMSEVFR_EL1", REG_PMSEVFR_EL1, 0x1899a0, SR_READ | SR_WRITE},
    {"PMSFCR_EL1", REG_PMSFCR_EL1, 0x189980, SR_READ | SR_WRITE},
    {"PMSICR_EL1", REG_PMSICR_EL1, 0x189940, SR_READ | SR_WRITE},
    {"PMSIDR_EL1", REG_PMSIDR_EL1, 0x1899e0, SR_READ},
    {"PMSIRR_EL1", REG_PMSIRR_EL1, 0x189960, SR_READ | SR_WRITE},
    {"PMSLATFR_EL1", REG_PMSLATFR_EL1, 0x1899c0, SR_READ | SR_WRITE},
    {"PMSWINC_EL0", REG_PMSWINC_EL0, 0x1b9c80, SR_WRITE},
    {"PMUSERENR_EL0", REG_PMUSERENR_EL0, 0x1b9e00, SR_READ | SR_WRITE},
    {"PMXEVCNTR_EL0", REG_PMXEVCNTR_EL0, 0x1b9d40, SR_READ | SR_WRITE},
    {"PMXEVTYPER_EL0", REG_PMXEVTYPER_EL0, 0x1b9d20, SR_READ | SR_WRITE},
    {"REVIDR_EL1", REG_REVIDR_EL1, 0x1800c0, SR_READ},
    {"RGSR_EL1", REG_RGSR_EL1, 0x1810a0, SR_READ | SR_WRITE},
    {"RMR_EL1", REG_RMR_EL1, 0x18c040, SR_READ | SR_WRITE},
    {"RNDR", REG_RNDR, 0x1b2400, SR_READ},
    {"RNDRRS", REG_RNDRRS, 0x1b2420, SR_READ},
    {"RVBAR_EL1", REG_RVBAR_EL1, 0x18c020, SR_READ},
    {"SCTLR_EL1", REG_SCTLR_EL1, 0x181000, SR_READ | SR_WRITE},
    {"SCXTNUM_EL0", REG_SCXTNUM_EL0, 0x1bd0e0, SR_READ | SR_WRITE},
    {"SCXTNUM_EL1", REG_SCXTNUM_EL1, 0x18d0e0, SR_READ | SR_WRITE},
    {"SP_EL0", REG_SP_EL0, 0x184100, SR_READ | SR_WRITE},
    {"SP_EL1", REG_SP_EL1, 0x1c4100, SR_READ | SR_WRITE},
    {"SPSel", REG_SPSel, 0x184200, SR_READ | SR_WRITE},
    {"SPSR_abt", REG_SPSR_abt, 0x1c4320, SR_READ | SR_WRITE},
    {"SPSR_EL1", REG_SPSR_EL1, 0x184000, SR_READ | SR_WRITE},
    {"SPSR_fiq", REG_SPSR_fiq, 0x1c4360, SR_READ | SR_WRITE},
    {"SPSR_irq", REG_SPSR_irq, 0x1c4300, SR_READ | SR_WRITE},
    {"SPSR_und", REG_SPSR_und, 0x1c4340, SR_READ | SR_WRITE},
    {"SSBS", REG_SSBS, 0x1b42c0, SR_READ | SR_WRITE},
    {"TCO", REG_TCO, 0x1b42e0, SR_READ | SR_WRITE},
    {"TCR_EL1", REG_TCR_EL1, 0x182040, SR_READ | SR_WRITE},
    {"TFSR_EL1", REG_TFSR_EL1, 0x185600, SR_READ | SR_WRITE},
    {"TFSRE0_EL1", REG_TFSRE0_EL1, 0x185620, SR_READ | SR_WRITE},
    {"TPIDR_EL0", REG_TPIDR_EL0, 0x1bd040, SR_READ | SR_WRITE},
    {"TPIDR_EL1", REG_TPIDR_EL1, 0x18d080, SR_READ | SR_WRITE},
    {"TPIDRRO_EL0", REG_TPIDRRO_EL0, 0x1bd060, SR_READ | SR_WRITE},
    {"TRFCR_EL1", REG_TRFCR_EL1, 0x181220, SR_READ | SR_WRITE},
    {"TTBR0_EL1", REG_TTBR0_EL1, 0x182000, SR_READ | SR_WRITE},
    {"TTBR1_EL1", REG_TTBR1_EL1, 0x182020, SR_READ | SR_WRITE},
    {"UAO", REG_UAO, 0x184280, SR_READ | SR_WRITE},
    {"VBAR_EL1", REG_VBAR_EL1, 0x18c000, SR_READ | SR_WRITE},
    {"ZCR_EL1", REG_ZCR_EL1, 0x181200, SR_READ | SR_WRITE},
}
var Vm__Zdn_T = []operand{
    a_VREG_Noop_Vm510,
    a_ARNG_ZdnSrcDst_SizeBHSD2224,
}
var Vn__PgM__Zd_T = []operand{
    a_VREG_Noop_Vn510,
    a_PREGZM_Pg1013_MergePredCheck,
    a_ARNG_Zd_SizeBHSD2224,
}
var Wdn__Pm_T__Xdn = []operand{
    a_SPZGREG_Noop_Wdn05,
    a_ARNG_Pm59V1_SizeBHSD2224,
    a_SPZGREG_Noop_Xdn05,
}
var Xm__Xn__Pd_T = []operand{
    a_SPZGREG_Noop_Rm1621V1,
    a_SPZGREG_Noop_Rn510,
    a_ARNG_Pd_SizeBHSD2224,
}
var Xm__Xn___Pd1_T__Pd2_T_ = []operand{
    a_SPZGREG_Noop_Rm1621V1,
    a_SPZGREG_Noop_Rn510,
    a_REGLIST2_Pd14_SizeBHSD2224_Pd14Plus1_SizeBHSD2224,
}
var XnSP__Xm__LSL_c1___PNgZ___Zt1_H_Zt2_H_ = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt1Check,
    a_PREGZM_PNg1013_ZeroPredCheck,
    a_REGLIST_RANGE_Zt15V1_ArngHCheck_Zt15V2_ArngHCheck,
}
var XnSP__Xm__LSL_c1___PNgZ___Zt1_H_Zt4_H_ = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt1Check,
    a_PREGZM_PNg1013_ZeroPredCheck,
    a_REGLIST_RANGE_Zt25V1_ArngHCheck_Zt25V2_ArngHCheck,
}
var XnSP__Xm__LSL_c1___PgZ___Zt1_H__Zt2_H_ = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt1Check,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST2_Zt051_ArngHCheck_Zt052_ArngHCheck,
}
var XnSP__Xm__LSL_c1___PgZ___Zt1_H__Zt2_H__Zt3_H_ = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt1Check,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST3_Zt051_ArngHCheck_Zt052_ArngHCheck_Zt053_ArngHCheck,
}
var XnSP__Xm__LSL_c1___PgZ___Zt1_H__Zt2_H__Zt3_H__Zt4_H_ = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt1Check,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST4_Zt051_ArngHCheck_Zt052_ArngHCheck_Zt053_ArngHCheck_Zt054_ArngHCheck,
}
var XnSP__Xm__LSL_c1___PgZ___Zt_D_ = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt1Check,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngDCheck,
}
var XnSP__Xm__LSL_c1___PgZ___Zt_D__V2 = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621XZR_Noop_ModLSLCheck_ModAmt1Check,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngDCheck,
}
var XnSP__Xm__LSL_c1___PgZ___Zt_H_ = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt1Check,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngHCheck,
}
var XnSP__Xm__LSL_c1___PgZ___Zt_H__V2 = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621XZR_Noop_ModLSLCheck_ModAmt1Check,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngHCheck,
}
var XnSP__Xm__LSL_c1___PgZ___Zt_S_ = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt1Check,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngSCheck,
}
var XnSP__Xm__LSL_c1___PgZ___Zt_S__V2 = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621XZR_Noop_ModLSLCheck_ModAmt1Check,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngSCheck,
}
var XnSP__Xm__LSL_c1___Pg__prfop = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt1Check,
    a_PREG_Pg1013_Noop,
    a_SPECIAL_Prfop04,
}
var XnSP__Xm__LSL_c2___PNgZ___Zt1_S_Zt2_S_ = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt2Check,
    a_PREGZM_PNg1013_ZeroPredCheck,
    a_REGLIST_RANGE_Zt15V1_ArngSCheck_Zt15V2_ArngSCheck,
}
var XnSP__Xm__LSL_c2___PNgZ___Zt1_S_Zt4_S_ = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt2Check,
    a_PREGZM_PNg1013_ZeroPredCheck,
    a_REGLIST_RANGE_Zt25V1_ArngSCheck_Zt25V2_ArngSCheck,
}
var XnSP__Xm__LSL_c2___PgZ___Zt1_S__Zt2_S_ = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt2Check,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST2_Zt051_ArngSCheck_Zt052_ArngSCheck,
}
var XnSP__Xm__LSL_c2___PgZ___Zt1_S__Zt2_S__Zt3_S_ = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt2Check,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST3_Zt051_ArngSCheck_Zt052_ArngSCheck_Zt053_ArngSCheck,
}
var XnSP__Xm__LSL_c2___PgZ___Zt1_S__Zt2_S__Zt3_S__Zt4_S_ = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt2Check,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST4_Zt051_ArngSCheck_Zt052_ArngSCheck_Zt053_ArngSCheck_Zt054_ArngSCheck,
}
var XnSP__Xm__LSL_c2___PgZ___Zt_D_ = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt2Check,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngDCheck,
}
var XnSP__Xm__LSL_c2___PgZ___Zt_D__V2 = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621XZR_Noop_ModLSLCheck_ModAmt2Check,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngDCheck,
}
var XnSP__Xm__LSL_c2___PgZ___Zt_Q_ = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt2Check,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngQCheck,
}
var XnSP__Xm__LSL_c2___PgZ___Zt_S_ = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt2Check,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngSCheck,
}
var XnSP__Xm__LSL_c2___PgZ___Zt_S__V2 = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621XZR_Noop_ModLSLCheck_ModAmt2Check,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngSCheck,
}
var XnSP__Xm__LSL_c2___Pg__prfop = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt2Check,
    a_PREG_Pg1013_Noop,
    a_SPECIAL_Prfop04,
}
var XnSP__Xm__LSL_c3___PNgZ___Zt1_D_Zt2_D_ = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt3Check,
    a_PREGZM_PNg1013_ZeroPredCheck,
    a_REGLIST_RANGE_Zt15V1_ArngDCheck_Zt15V2_ArngDCheck,
}
var XnSP__Xm__LSL_c3___PNgZ___Zt1_D_Zt4_D_ = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt3Check,
    a_PREGZM_PNg1013_ZeroPredCheck,
    a_REGLIST_RANGE_Zt25V1_ArngDCheck_Zt25V2_ArngDCheck,
}
var XnSP__Xm__LSL_c3___PgZ___Zt1_D__Zt2_D_ = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt3Check,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST2_Zt051_ArngDCheck_Zt052_ArngDCheck,
}
var XnSP__Xm__LSL_c3___PgZ___Zt1_D__Zt2_D__Zt3_D_ = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt3Check,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST3_Zt051_ArngDCheck_Zt052_ArngDCheck_Zt053_ArngDCheck,
}
var XnSP__Xm__LSL_c3___PgZ___Zt1_D__Zt2_D__Zt3_D__Zt4_D_ = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt3Check,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST4_Zt051_ArngDCheck_Zt052_ArngDCheck_Zt053_ArngDCheck_Zt054_ArngDCheck,
}
var XnSP__Xm__LSL_c3___PgZ___Zt_D_ = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt3Check,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngDCheck,
}
var XnSP__Xm__LSL_c3___PgZ___Zt_D__V2 = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621XZR_Noop_ModLSLCheck_ModAmt3Check,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngDCheck,
}
var XnSP__Xm__LSL_c3___PgZ___Zt_Q_ = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt3Check,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngQCheck,
}
var XnSP__Xm__LSL_c3___Pg__prfop = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt3Check,
    a_PREG_Pg1013_Noop,
    a_SPECIAL_Prfop04,
}
var XnSP__Xm__LSL_c4___PgZ___Zt1_Q__Zt2_Q_ = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt4Check,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST2_Zt051_ArngQCheck_Zt052_ArngQCheck,
}
var XnSP__Xm__LSL_c4___PgZ___Zt1_Q__Zt2_Q__Zt3_Q_ = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt4Check,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST3_Zt051_ArngQCheck_Zt052_ArngQCheck_Zt053_ArngQCheck,
}
var XnSP__Xm__LSL_c4___PgZ___Zt1_Q__Zt2_Q__Zt3_Q__Zt4_Q_ = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt4Check,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST4_Zt051_ArngQCheck_Zt052_ArngQCheck_Zt053_ArngQCheck_Zt054_ArngQCheck,
}
var XnSP__Xm___PNgZ___Zt1_B_Zt2_B_ = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_NoModCheck_NoAmtCheck,
    a_PREGZM_PNg1013_ZeroPredCheck,
    a_REGLIST_RANGE_Zt15V1_ArngBCheck_Zt15V2_ArngBCheck,
}
var XnSP__Xm___PNgZ___Zt1_B_Zt4_B_ = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_NoModCheck_NoAmtCheck,
    a_PREGZM_PNg1013_ZeroPredCheck,
    a_REGLIST_RANGE_Zt25V1_ArngBCheck_Zt25V2_ArngBCheck,
}
var XnSP__Xm___PgZ___Zt1_B__Zt2_B_ = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_NoModCheck_NoAmtCheck,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST2_Zt051_ArngBCheck_Zt052_ArngBCheck,
}
var XnSP__Xm___PgZ___Zt1_B__Zt2_B__Zt3_B_ = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_NoModCheck_NoAmtCheck,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST3_Zt051_ArngBCheck_Zt052_ArngBCheck_Zt053_ArngBCheck,
}
var XnSP__Xm___PgZ___Zt1_B__Zt2_B__Zt3_B__Zt4_B_ = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_NoModCheck_NoAmtCheck,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST4_Zt051_ArngBCheck_Zt052_ArngBCheck_Zt053_ArngBCheck_Zt054_ArngBCheck,
}
var XnSP__Xm___PgZ___Zt_B_ = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_NoModCheck_NoAmtCheck,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngBCheck,
}
var XnSP__Xm___PgZ___Zt_B__V2 = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621XZR_Noop_NoModCheck_NoAmtCheck,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngBCheck,
}
var XnSP__Xm___PgZ___Zt_D_ = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_NoModCheck_NoAmtCheck,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngDCheck,
}
var XnSP__Xm___PgZ___Zt_D__V2 = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621XZR_Noop_NoModCheck_NoAmtCheck,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngDCheck,
}
var XnSP__Xm___PgZ___Zt_H_ = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_NoModCheck_NoAmtCheck,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngHCheck,
}
var XnSP__Xm___PgZ___Zt_H__V2 = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621XZR_Noop_NoModCheck_NoAmtCheck,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngHCheck,
}
var XnSP__Xm___PgZ___Zt_S_ = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_NoModCheck_NoAmtCheck,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngSCheck,
}
var XnSP__Xm___PgZ___Zt_S__V2 = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621XZR_Noop_NoModCheck_NoAmtCheck,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngSCheck,
}
var XnSP__Xm___Pg__prfop = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_NoModCheck_NoAmtCheck,
    a_PREG_Pg1013_Noop,
    a_SPECIAL_Prfop04,
}
var XnSP__Zm_D__LSL_c1___PgZ___Zt_D_ = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Zm1621V3_ArngDCheck_ModLSLCheck_ModAmt1Check,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngDCheck,
}
var XnSP__Zm_D__LSL_c1___Pg__prfop = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Zm1621V3_ArngDCheck_ModLSLCheck_ModAmt1Check,
    a_PREG_Pg1013_Noop,
    a_SPECIAL_Prfop04,
}
var XnSP__Zm_D__LSL_c2___PgZ___Zt_D_ = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Zm1621V3_ArngDCheck_ModLSLCheck_ModAmt2Check,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngDCheck,
}
var XnSP__Zm_D__LSL_c2___Pg__prfop = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Zm1621V3_ArngDCheck_ModLSLCheck_ModAmt2Check,
    a_PREG_Pg1013_Noop,
    a_SPECIAL_Prfop04,
}
var XnSP__Zm_D__LSL_c3___PgZ___Zt_D_ = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Zm1621V3_ArngDCheck_ModLSLCheck_ModAmt3Check,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngDCheck,
}
var XnSP__Zm_D__LSL_c3___Pg__prfop = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Zm1621V3_ArngDCheck_ModLSLCheck_ModAmt3Check,
    a_PREG_Pg1013_Noop,
    a_SPECIAL_Prfop04,
}
var XnSP__Zm_D___PgZ___Zt_D_ = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Zm1621V3_ArngDCheck_NoModCheck_NoAmtCheck,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngDCheck,
}
var XnSP__Zm_D___Pg__prfop = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Zm1621V3_ArngDCheck_NoModCheck_NoAmtCheck,
    a_PREG_Pg1013_Noop,
    a_SPECIAL_Prfop04,
}
var XnSP__Zm_D__mod___PgZ___Zt_D_ = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Zm1621V3_ArngDCheck_Xs2223_NoAmtCheck,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngDCheck,
}
var XnSP__Zm_D__mod___Pg__prfop = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Zm1621V3_ArngDCheck_Xs2223_NoAmtCheck,
    a_PREG_Pg1013_Noop,
    a_SPECIAL_Prfop04,
}
var XnSP__Zm_D__mod_c1___PgZ___Zt_D_ = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Zm1621V3_ArngDCheck_Xs2223_ModAmt1Check,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngDCheck,
}
var XnSP__Zm_D__mod_c1___Pg__prfop = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Zm1621V3_ArngDCheck_Xs2223_ModAmt1Check,
    a_PREG_Pg1013_Noop,
    a_SPECIAL_Prfop04,
}
var XnSP__Zm_D__mod_c2___PgZ___Zt_D_ = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Zm1621V3_ArngDCheck_Xs2223_ModAmt2Check,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngDCheck,
}
var XnSP__Zm_D__mod_c2___Pg__prfop = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Zm1621V3_ArngDCheck_Xs2223_ModAmt2Check,
    a_PREG_Pg1013_Noop,
    a_SPECIAL_Prfop04,
}
var XnSP__Zm_D__mod_c3___PgZ___Zt_D_ = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Zm1621V3_ArngDCheck_Xs2223_ModAmt3Check,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngDCheck,
}
var XnSP__Zm_D__mod_c3___Pg__prfop = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Zm1621V3_ArngDCheck_Xs2223_ModAmt3Check,
    a_PREG_Pg1013_Noop,
    a_SPECIAL_Prfop04,
}
var XnSP__Zm_S__mod___PgZ___Zt_S_ = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Zm1621V3_ArngSCheck_Xs2223_NoAmtCheck,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngSCheck,
}
var XnSP__Zm_S__mod___Pg__prfop = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Zm1621V3_ArngSCheck_Xs2223_NoAmtCheck,
    a_PREG_Pg1013_Noop,
    a_SPECIAL_Prfop04,
}
var XnSP__Zm_S__mod_c1___PgZ___Zt_S_ = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Zm1621V3_ArngSCheck_Xs2223_ModAmt1Check,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngSCheck,
}
var XnSP__Zm_S__mod_c1___Pg__prfop = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Zm1621V3_ArngSCheck_Xs2223_ModAmt1Check,
    a_PREG_Pg1013_Noop,
    a_SPECIAL_Prfop04,
}
var XnSP__Zm_S__mod_c2___PgZ___Zt_S_ = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Zm1621V3_ArngSCheck_Xs2223_ModAmt2Check,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngSCheck,
}
var XnSP__Zm_S__mod_c2___Pg__prfop = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Zm1621V3_ArngSCheck_Xs2223_ModAmt2Check,
    a_PREG_Pg1013_Noop,
    a_SPECIAL_Prfop04,
}
var XnSP__Zm_S__mod_c3___Pg__prfop = []operand{
    a_MEMEXT_Rn510SPV2_Noop_Zm1621V3_ArngSCheck_Xs2223_ModAmt3Check,
    a_PREG_Pg1013_Noop,
    a_SPECIAL_Prfop04,
}
var XnSP__cimm__MUL_VL___PNgZ___Zt1_B_Zt2_B_ = []operand{
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V9,
    a_PREGZM_PNg1013_ZeroPredCheck,
    a_REGLIST_RANGE_Zt15V1_ArngBCheck_Zt15V2_ArngBCheck,
}
var XnSP__cimm__MUL_VL___PNgZ___Zt1_B_Zt4_B_ = []operand{
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V8,
    a_PREGZM_PNg1013_ZeroPredCheck,
    a_REGLIST_RANGE_Zt25V1_ArngBCheck_Zt25V2_ArngBCheck,
}
var XnSP__cimm__MUL_VL___PNgZ___Zt1_D_Zt2_D_ = []operand{
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V9,
    a_PREGZM_PNg1013_ZeroPredCheck,
    a_REGLIST_RANGE_Zt15V1_ArngDCheck_Zt15V2_ArngDCheck,
}
var XnSP__cimm__MUL_VL___PNgZ___Zt1_D_Zt4_D_ = []operand{
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V8,
    a_PREGZM_PNg1013_ZeroPredCheck,
    a_REGLIST_RANGE_Zt25V1_ArngDCheck_Zt25V2_ArngDCheck,
}
var XnSP__cimm__MUL_VL___PNgZ___Zt1_H_Zt2_H_ = []operand{
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V9,
    a_PREGZM_PNg1013_ZeroPredCheck,
    a_REGLIST_RANGE_Zt15V1_ArngHCheck_Zt15V2_ArngHCheck,
}
var XnSP__cimm__MUL_VL___PNgZ___Zt1_H_Zt4_H_ = []operand{
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V8,
    a_PREGZM_PNg1013_ZeroPredCheck,
    a_REGLIST_RANGE_Zt25V1_ArngHCheck_Zt25V2_ArngHCheck,
}
var XnSP__cimm__MUL_VL___PNgZ___Zt1_S_Zt2_S_ = []operand{
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V9,
    a_PREGZM_PNg1013_ZeroPredCheck,
    a_REGLIST_RANGE_Zt15V1_ArngSCheck_Zt15V2_ArngSCheck,
}
var XnSP__cimm__MUL_VL___PNgZ___Zt1_S_Zt4_S_ = []operand{
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V8,
    a_PREGZM_PNg1013_ZeroPredCheck,
    a_REGLIST_RANGE_Zt25V1_ArngSCheck_Zt25V2_ArngSCheck,
}
var XnSP__cimm__MUL_VL___PgZ___Zt1_B__Zt2_B_ = []operand{
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V6,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST2_Zt051_ArngBCheck_Zt052_ArngBCheck,
}
var XnSP__cimm__MUL_VL___PgZ___Zt1_B__Zt2_B__Zt3_B_ = []operand{
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V3,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST3_Zt051_ArngBCheck_Zt052_ArngBCheck_Zt053_ArngBCheck,
}
var XnSP__cimm__MUL_VL___PgZ___Zt1_B__Zt2_B__Zt3_B__Zt4_B_ = []operand{
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V4,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST4_Zt051_ArngBCheck_Zt052_ArngBCheck_Zt053_ArngBCheck_Zt054_ArngBCheck,
}
var XnSP__cimm__MUL_VL___PgZ___Zt1_D__Zt2_D_ = []operand{
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V6,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST2_Zt051_ArngDCheck_Zt052_ArngDCheck,
}
var XnSP__cimm__MUL_VL___PgZ___Zt1_D__Zt2_D__Zt3_D_ = []operand{
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V3,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST3_Zt051_ArngDCheck_Zt052_ArngDCheck_Zt053_ArngDCheck,
}
var XnSP__cimm__MUL_VL___PgZ___Zt1_D__Zt2_D__Zt3_D__Zt4_D_ = []operand{
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V4,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST4_Zt051_ArngDCheck_Zt052_ArngDCheck_Zt053_ArngDCheck_Zt054_ArngDCheck,
}
var XnSP__cimm__MUL_VL___PgZ___Zt1_H__Zt2_H_ = []operand{
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V6,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST2_Zt051_ArngHCheck_Zt052_ArngHCheck,
}
var XnSP__cimm__MUL_VL___PgZ___Zt1_H__Zt2_H__Zt3_H_ = []operand{
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V3,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST3_Zt051_ArngHCheck_Zt052_ArngHCheck_Zt053_ArngHCheck,
}
var XnSP__cimm__MUL_VL___PgZ___Zt1_H__Zt2_H__Zt3_H__Zt4_H_ = []operand{
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V4,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST4_Zt051_ArngHCheck_Zt052_ArngHCheck_Zt053_ArngHCheck_Zt054_ArngHCheck,
}
var XnSP__cimm__MUL_VL___PgZ___Zt1_Q__Zt2_Q_ = []operand{
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V6,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST2_Zt051_ArngQCheck_Zt052_ArngQCheck,
}
var XnSP__cimm__MUL_VL___PgZ___Zt1_Q__Zt2_Q__Zt3_Q_ = []operand{
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V3,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST3_Zt051_ArngQCheck_Zt052_ArngQCheck_Zt053_ArngQCheck,
}
var XnSP__cimm__MUL_VL___PgZ___Zt1_Q__Zt2_Q__Zt3_Q__Zt4_Q_ = []operand{
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V4,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST4_Zt051_ArngQCheck_Zt052_ArngQCheck_Zt053_ArngQCheck_Zt054_ArngQCheck,
}
var XnSP__cimm__MUL_VL___PgZ___Zt1_S__Zt2_S_ = []operand{
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V6,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST2_Zt051_ArngSCheck_Zt052_ArngSCheck,
}
var XnSP__cimm__MUL_VL___PgZ___Zt1_S__Zt2_S__Zt3_S_ = []operand{
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V3,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST3_Zt051_ArngSCheck_Zt052_ArngSCheck_Zt053_ArngSCheck,
}
var XnSP__cimm__MUL_VL___PgZ___Zt1_S__Zt2_S__Zt3_S__Zt4_S_ = []operand{
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V4,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST4_Zt051_ArngSCheck_Zt052_ArngSCheck_Zt053_ArngSCheck_Zt054_ArngSCheck,
}
var XnSP__cimm__MUL_VL___PgZ___Zt_B_ = []operand{
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V5,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngBCheck,
}
var XnSP__cimm__MUL_VL___PgZ___Zt_D_ = []operand{
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V5,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngDCheck,
}
var XnSP__cimm__MUL_VL___PgZ___Zt_H_ = []operand{
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V5,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngHCheck,
}
var XnSP__cimm__MUL_VL___PgZ___Zt_Q_ = []operand{
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V5,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngQCheck,
}
var XnSP__cimm__MUL_VL___PgZ___Zt_S_ = []operand{
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V5,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngSCheck,
}
var XnSP__cimm__MUL_VL___Pg__prfop = []operand{
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm61622V5,
    a_PREG_Pg1013_Noop,
    a_SPECIAL_Prfop04,
}
var XnSP__cimm__MUL_VL___Pt = []operand{
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm9h1622L1013,
    a_PREG_Pt04V1_Noop,
}
var XnSP__cimm__MUL_VL___Zt = []operand{
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm9h1622L1013,
    a_ZREG_Zt05_Noop,
}
var XnSP__cimm___PgZ___Zt_B___1 = []operand{
    a_MEMOFF_Rn510SPV2_Noop_Imm61622V4,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngBCheck,
}
var XnSP__cimm___PgZ___Zt_B___2 = []operand{
    a_MEMOFF_Rn510SPV2_Noop_Imm41620V2,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngBCheck,
}
var XnSP__cimm___PgZ___Zt_B___3 = []operand{
    a_MEMOFF_Rn510SPV2_Noop_Imm41620V1,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngBCheck,
}
var XnSP__cimm___PgZ___Zt_D___1 = []operand{
    a_MEMOFF_Rn510SPV2_Noop_Imm61622V4,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngDCheck,
}
var XnSP__cimm___PgZ___Zt_D___2 = []operand{
    a_MEMOFF_Rn510SPV2_Noop_Imm61622V1,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngDCheck,
}
var XnSP__cimm___PgZ___Zt_D___3 = []operand{
    a_MEMOFF_Rn510SPV2_Noop_Imm61622V2,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngDCheck,
}
var XnSP__cimm___PgZ___Zt_D___4 = []operand{
    a_MEMOFF_Rn510SPV2_Noop_Imm61622V3,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngDCheck,
}
var XnSP__cimm___PgZ___Zt_D___5 = []operand{
    a_MEMOFF_Rn510SPV2_Noop_Imm41620V2,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngDCheck,
}
var XnSP__cimm___PgZ___Zt_D___6 = []operand{
    a_MEMOFF_Rn510SPV2_Noop_Imm41620V1,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngDCheck,
}
var XnSP__cimm___PgZ___Zt_H___1 = []operand{
    a_MEMOFF_Rn510SPV2_Noop_Imm61622V4,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngHCheck,
}
var XnSP__cimm___PgZ___Zt_H___2 = []operand{
    a_MEMOFF_Rn510SPV2_Noop_Imm61622V1,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngHCheck,
}
var XnSP__cimm___PgZ___Zt_H___3 = []operand{
    a_MEMOFF_Rn510SPV2_Noop_Imm41620V2,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngHCheck,
}
var XnSP__cimm___PgZ___Zt_H___4 = []operand{
    a_MEMOFF_Rn510SPV2_Noop_Imm41620V1,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngHCheck,
}
var XnSP__cimm___PgZ___Zt_S___1 = []operand{
    a_MEMOFF_Rn510SPV2_Noop_Imm61622V4,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngSCheck,
}
var XnSP__cimm___PgZ___Zt_S___2 = []operand{
    a_MEMOFF_Rn510SPV2_Noop_Imm61622V1,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngSCheck,
}
var XnSP__cimm___PgZ___Zt_S___3 = []operand{
    a_MEMOFF_Rn510SPV2_Noop_Imm41620V2,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngSCheck,
}
var XnSP__cimm___PgZ___Zt_S___4 = []operand{
    a_MEMOFF_Rn510SPV2_Noop_Imm41620V1,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngSCheck,
}
var XnSP__cimm___PgZ___Zt_S___5 = []operand{
    a_MEMOFF_Rn510SPV2_Noop_Imm61622V2,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngSCheck,
}
var Za_D__Zm_D__Zdn_D = []operand{
    a_ARNG_Za5103Rd_ArngDCheck,
    a_ARNG_Zm1621V2_ArngDCheck,
    a_ARNG_ZdnDest_ArngDCheck,
}
var Za_T__Zm_T__PgM__Zdn_T__1 = []operand{
    a_ARNG_Za16213Rd_SizeHSD2224,
    a_ARNG_Zm510V1_SizeHSD2224,
    a_PREGZM_Pg1013_MergePredCheck,
    a_ARNG_ZdnDest_SizeHSD2224,
}
var Za_T__Zm_T__PgM__Zdn_T__2 = []operand{
    a_ARNG_Za5103Rd_SizeBHSD2224,
    a_ARNG_Zm1621V2_SizeBHSD2224,
    a_PREGZM_Pg1013_MergePredCheck,
    a_ARNG_ZdnDest_SizeBHSD2224,
}
var Zdn_B__Zdn_B = []operand{
    a_ARNG_ZdnSrcDst_ArngBCheck,
    a_ARNG_ZdnSrcDst_ArngBCheck,
}
var Zk_D__Zm_D__Zdn_D__Zdn_D = []operand{
    a_ARNG_Zk5103Rd_ArngDCheck,
    a_ARNG_Zm1621V2_ArngDCheck,
    a_ARNG_ZdnDest_ArngDCheck,
    a_ARNG_ZdnDest_ArngDCheck,
}
var Zm_B__Zdn_B__Zdn_B = []operand{
    a_ARNG_Zm510V1_ArngBCheck,
    a_ARNG_ZdnDest_ArngBCheck,
    a_ARNG_ZdnDest_ArngBCheck,
}
var Zm_B__Zn_B__Zd_B = []operand{
    a_ARNG_Zm1621V2_ArngBCheck,
    a_ARNG_Zn510V1_ArngBCheck,
    a_ARNG_Zd_ArngBCheck,
}
var Zm_B__Zn_B__Zda_H = []operand{
    a_ARNG_Zm1621V2_ArngBCheck,
    a_ARNG_Zn510V1_ArngBCheck,
    a_ARNG_Zda3RdSrcDst_ArngHCheck,
}
var Zm_B__Zn_B__Zda_S = []operand{
    a_ARNG_Zm1621V2_ArngBCheck,
    a_ARNG_Zn510V1_ArngBCheck,
    a_ARNG_Zda3RdSrcDst_ArngSCheck,
}
var Zm_B_imm___Zn_B__Zda_H__1 = []operand{
    a_ARNGIDX_Zm_1619_Range0_7V2_ArngBCheck_I4hI4l_1019,
    a_ARNG_Zn510V1_ArngBCheck,
    a_ARNG_Zda3RdSrcDst_ArngHCheck,
}
var Zm_B_imm___Zn_B__Zda_H__2 = []operand{
    a_ARNGIDX_Zm_1619_Range0_7V2_ArngBCheck_I3hI3l_1923_8To16Bit,
    a_ARNG_Zn510V1_ArngBCheck,
    a_ARNG_Zda3RdSrcDst_ArngHCheck,
}
var Zm_B_imm___Zn_B__Zda_H__3 = []operand{
    a_ARNGIDX_Zm_1619_Range0_7V2_ArngBCheck_I3hI3l_1119_Pair8Bit,
    a_ARNG_Zn510V1_ArngBCheck,
    a_ARNG_Zda3RdSrcDst_ArngHCheck,
}
var Zm_B_imm___Zn_B__Zda_S__1 = []operand{
    a_ARNGIDX_Zm_1619_Range0_7V2_ArngBCheck_I4hI4l_1019,
    a_ARNG_Zn510V1_ArngBCheck,
    a_ARNG_Zda3RdSrcDst_ArngSCheck,
}
var Zm_B_imm___Zn_B__Zda_S__2 = []operand{
    a_ARNGIDX_Zm_1619_Range0_7V2_ArngBCheck_I2_1921_8BitGroup,
    a_ARNG_Zn510V1_ArngBCheck,
    a_ARNG_Zda3RdSrcDst_ArngSCheck,
}
var Zm_B_imm___Zn_B__Zda_S__3 = []operand{
    a_ARNGIDX_Zm1619_8To32Bit_ArngBCheck_I2_1921_8To32Bit,
    a_ARNG_Zn510V1_ArngBCheck,
    a_ARNG_Zda3RdSrcDst_ArngSCheck,
}
var Zm_D__Zdn_D__PgM__Zdn_D = []operand{
    a_ARNG_Zm510V1_ArngDCheck,
    a_ARNG_ZdnDest_ArngDCheck,
    a_PREGZM_Pg1013_MergePredCheck,
    a_ARNG_ZdnDest_ArngDCheck,
}
var Zm_D__Zdn_T__PgM__Zdn_T = []operand{
    a_ARNG_Zm510V1_ArngDCheck,
    a_ARNG_ZdnDest_SizeBHS2224,
    a_PREGZM_Pg1013_MergePredCheck,
    a_ARNG_ZdnDest_SizeBHS2224,
}
var Zm_D__Zn_D__Zd_D = []operand{
    a_ARNG_Zm1621V2_ArngDCheck,
    a_ARNG_Zn510V1_ArngDCheck,
    a_ARNG_Zd_ArngDCheck,
}
var Zm_D__Zn_D__Zd_Q = []operand{
    a_ARNG_Zm1621V2_ArngDCheck,
    a_ARNG_Zn510V1_ArngDCheck,
    a_ARNG_Zd_ArngQCheck,
}
var Zm_D__Zn_D__Zda_D = []operand{
    a_ARNG_Zm1621V2_ArngDCheck,
    a_ARNG_Zn510V1_ArngDCheck,
    a_ARNG_Zda3RdSrcDst_ArngDCheck,
}
var Zm_D__Zn_D___Zd1_Q_Zd2_Q_ = []operand{
    a_ARNG_Zm1621V2_ArngDCheck,
    a_ARNG_Zn510V1_ArngDCheck,
    a_REGLIST_RANGE_Zd15V1_ArngQCheck_Zd15V2_ArngQCheck,
}
var Zm_D__Zn_D___Zda1_Q_Zda2_Q_ = []operand{
    a_ARNG_Zm1621V2_ArngDCheck,
    a_ARNG_Zn510V1_ArngDCheck,
    a_REGLIST_RANGE_Zda15V1_ArngQCheck_Zda15V2_ArngQCheck,
}
var Zm_D__Zn_T__PgZ__Pd_T = []operand{
    a_ARNG_Zm1621V2_ArngDCheck,
    a_ARNG_Zn510V1_SizeBHS2224,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_ARNG_Pd_SizeBHS2224,
}
var Zm_D__Zn_T__Zd_T = []operand{
    a_ARNG_Zm1621V2_ArngDCheck,
    a_ARNG_Zn510V1_SizeBHS2224,
    a_ARNG_Zd_SizeBHS2224,
}
var Zm_D_imm___Zn_D__Zd_D__1 = []operand{
    a_ARNGIDX_Zm1620_64Bit_ArngDCheck_I1_2021_64Bit,
    a_ARNG_Zn510V1_ArngDCheck,
    a_ARNG_Zd_ArngDCheck,
}
var Zm_D_imm___Zn_D__Zd_D__2 = []operand{
    a_ARNGIDX_Zm1620_DoublePrecision_ArngDCheck_I1_2021_DoublePrecision,
    a_ARNG_Zn510V1_ArngDCheck,
    a_ARNG_Zd_ArngDCheck,
}
var Zm_D_imm___Zn_D__Zda_D__1 = []operand{
    a_ARNGIDX_Zm1620_64Bit_ArngDCheck_I1_2021_64Bit,
    a_ARNG_Zn510V1_ArngDCheck,
    a_ARNG_Zda3RdSrcDst_ArngDCheck,
}
var Zm_D_imm___Zn_D__Zda_D__2 = []operand{
    a_ARNGIDX_Zm1620_DoublePrecision_ArngDCheck_I1_2021_DoublePrecision,
    a_ARNG_Zn510V1_ArngDCheck,
    a_ARNG_Zda3RdSrcDst_ArngDCheck,
}
var Zm_H__Zdn_H__PgM__Zdn_H = []operand{
    a_ARNG_Zm510V1_ArngHCheck,
    a_ARNG_ZdnDest_ArngHCheck,
    a_PREGZM_Pg1013_MergePredCheck,
    a_ARNG_ZdnDest_ArngHCheck,
}
var Zm_H__Zn_H__PgM__Zda_H = []operand{
    a_ARNG_Zm1621V2_ArngHCheck,
    a_ARNG_Zn510V1_ArngHCheck,
    a_PREGZM_Pg1013_MergePredCheck,
    a_ARNG_Zda3RdSrcDst_ArngHCheck,
}
var Zm_H__Zn_H__Zd_H = []operand{
    a_ARNG_Zm1621V2_ArngHCheck,
    a_ARNG_Zn510V1_ArngHCheck,
    a_ARNG_Zd_ArngHCheck,
}
var Zm_H__Zn_H__Zda_H = []operand{
    a_ARNG_Zm1621V2_ArngHCheck,
    a_ARNG_Zn510V1_ArngHCheck,
    a_ARNG_Zda3RdSrcDst_ArngHCheck,
}
var Zm_H__Zn_H__Zda_S = []operand{
    a_ARNG_Zm1621V2_ArngHCheck,
    a_ARNG_Zn510V1_ArngHCheck,
    a_ARNG_Zda3RdSrcDst_ArngSCheck,
}
var Zm_H_imm___Zn_H__Zd_H__1 = []operand{
    a_ARNGIDX_Zm1619_16Bit32Bit_ArngHCheck_I3hI3l_1923_16Bit,
    a_ARNG_Zn510V1_ArngHCheck,
    a_ARNG_Zd_ArngHCheck,
}
var Zm_H_imm___Zn_H__Zd_H__2 = []operand{
    a_ARNGIDX_Zm_1619_Range0_7V2_ArngHCheck_I3hI3l_1922,
    a_ARNG_Zn510V1_ArngHCheck,
    a_ARNG_Zd_ArngHCheck,
}
var Zm_H_imm___Zn_H__Zd_H__3 = []operand{
    a_ARNGIDX_Zm1619_HalfSinglePrecision_ArngHCheck_I3hI3l_1923_HalfPrecision,
    a_ARNG_Zn510V1_ArngHCheck,
    a_ARNG_Zd_ArngHCheck,
}
var Zm_H_imm___Zn_H__Zd_S = []operand{
    a_ARNGIDX_Zm1619_32Bit_ArngHCheck_I3hI3l_1119_32Bit,
    a_ARNG_Zn510V1_ArngHCheck,
    a_ARNG_Zd_ArngSCheck,
}
var Zm_H_imm___Zn_H__Zda_D = []operand{
    a_ARNGIDX_Zm1620_16To64Bit_ArngHCheck_I1_2021_16To64Bit,
    a_ARNG_Zn510V1_ArngHCheck,
    a_ARNG_Zda3RdSrcDst_ArngDCheck,
}
var Zm_H_imm___Zn_H__Zda_H__1 = []operand{
    a_ARNGIDX_Zm1619_16Bit32Bit_ArngHCheck_I3hI3l_1923_16Bit,
    a_ARNG_Zn510V1_ArngHCheck,
    a_ARNG_Zda3RdSrcDst_ArngHCheck,
}
var Zm_H_imm___Zn_H__Zda_H__2 = []operand{
    a_ARNGIDX_Zm_1619_Range0_7V2_ArngHCheck_I3hI3l_1922,
    a_ARNG_Zn510V1_ArngHCheck,
    a_ARNG_Zda3RdSrcDst_ArngHCheck,
}
var Zm_H_imm___Zn_H__Zda_H__3 = []operand{
    a_ARNGIDX_Zm1619_HalfSinglePrecision_ArngHCheck_I3hI3l_1923_HalfPrecision,
    a_ARNG_Zn510V1_ArngHCheck,
    a_ARNG_Zda3RdSrcDst_ArngHCheck,
}
var Zm_H_imm___Zn_H__Zda_S__1 = []operand{
    a_ARNGIDX_Zm1619_32Bit_ArngHCheck_I3hI3l_1119_32Bit,
    a_ARNG_Zn510V1_ArngHCheck,
    a_ARNG_Zda3RdSrcDst_ArngSCheck,
}
var Zm_H_imm___Zn_H__Zda_S__2 = []operand{
    a_ARNGIDX_Zm_1619_Range0_7V2_ArngHCheck_I3hI3l_1119,
    a_ARNG_Zn510V1_ArngHCheck,
    a_ARNG_Zda3RdSrcDst_ArngSCheck,
}
var Zm_H_imm___Zn_H__Zda_S__3 = []operand{
    a_ARNGIDX_Zm_1619_Range0_7V2_ArngHCheck_I2_1921_Pair16Bit,
    a_ARNG_Zn510V1_ArngHCheck,
    a_ARNG_Zda3RdSrcDst_ArngSCheck,
}
var Zm_H_imm___Zn_H__Zda_S__4 = []operand{
    a_ARNGIDX_Zm_1619_Range0_7V2_ArngHCheck_I2_1921_16To32Bit,
    a_ARNG_Zn510V1_ArngHCheck,
    a_ARNG_Zda3RdSrcDst_ArngSCheck,
}
var Zm_Q__Zn_Q__Zd_Q = []operand{
    a_ARNG_Zm1621V2_ArngQCheck,
    a_ARNG_Zn510V1_ArngQCheck,
    a_ARNG_Zd_ArngQCheck,
}
var Zm_Q_index____Zdn1_B_Zdn2_B____Zdn1_B_Zdn2_B_ = []operand{
    a_ARNGIDX_Zm510V1_ArngQCheck_I21921,
    a_REGLIST_RANGE_Zdn15V1_ArngBCheck_Zdn15V2_ArngBCheck,
    a_REGLIST_RANGE_Zdn15V1_ArngBCheck_Zdn15V2_ArngBCheck,
}
var Zm_Q_index____Zdn1_B_Zdn4_B____Zdn1_B_Zdn4_B_ = []operand{
    a_ARNGIDX_Zm510V1_ArngQCheck_I21921,
    a_REGLIST_RANGE_Zdn25V1_ArngBCheck_Zdn25V2_ArngBCheck,
    a_REGLIST_RANGE_Zdn25V1_ArngBCheck_Zdn25V2_ArngBCheck,
}
var Zm_S__Zdn_S__Zdn_S = []operand{
    a_ARNG_Zm510V1_ArngSCheck,
    a_ARNG_ZdnDest_ArngSCheck,
    a_ARNG_ZdnDest_ArngSCheck,
}
var Zm_S__Zn_S__Zd_S = []operand{
    a_ARNG_Zm1621V2_ArngSCheck,
    a_ARNG_Zn510V1_ArngSCheck,
    a_ARNG_Zd_ArngSCheck,
}
var Zm_S__Zn_S__Zda_S = []operand{
    a_ARNG_Zm1621V2_ArngSCheck,
    a_ARNG_Zn510V1_ArngSCheck,
    a_ARNG_Zda3RdSrcDst_ArngSCheck,
}
var Zm_S_imm___Zn_S__Zd_D = []operand{
    a_ARNGIDX_Zm1620_64Bit_ArngSCheck_I2hI2l_1120_64Bit,
    a_ARNG_Zn510V1_ArngSCheck,
    a_ARNG_Zd_ArngDCheck,
}
var Zm_S_imm___Zn_S__Zd_S__1 = []operand{
    a_ARNGIDX_Zm1619_16Bit32Bit_ArngSCheck_I2_1921_32Bit,
    a_ARNG_Zn510V1_ArngSCheck,
    a_ARNG_Zd_ArngSCheck,
}
var Zm_S_imm___Zn_S__Zd_S__2 = []operand{
    a_ARNGIDX_Zm1619_HalfSinglePrecision_ArngSCheck_I2_1921_SinglePrecision,
    a_ARNG_Zn510V1_ArngSCheck,
    a_ARNG_Zd_ArngSCheck,
}
var Zm_S_imm___Zn_S__Zda_D = []operand{
    a_ARNGIDX_Zm1620_64Bit_ArngSCheck_I2hI2l_1120_64Bit,
    a_ARNG_Zn510V1_ArngSCheck,
    a_ARNG_Zda3RdSrcDst_ArngDCheck,
}
var Zm_S_imm___Zn_S__Zda_S__1 = []operand{
    a_ARNGIDX_Zm1619_16Bit32Bit_ArngSCheck_I2_1921_32Bit,
    a_ARNG_Zn510V1_ArngSCheck,
    a_ARNG_Zda3RdSrcDst_ArngSCheck,
}
var Zm_S_imm___Zn_S__Zda_S__2 = []operand{
    a_ARNGIDX_Zm1619_HalfSinglePrecision_ArngSCheck_I2_1921_SinglePrecision,
    a_ARNG_Zn510V1_ArngSCheck,
    a_ARNG_Zda3RdSrcDst_ArngSCheck,
}
var Zm_T__Rdn__Pg__Rdn = []operand{
    a_ARNG_Zm510V2_SizeBHSD2224,
    a_SPZGREG_Noop_Rdn05ZR,
    a_PREG_Pg1013_Noop,
    a_SPZGREG_Noop_Rdn05ZR,
}
var Zm_T__Vdn__Pg__Vdn__1 = []operand{
    a_ARNG_Zm510V2_SizeBHSD2224,
    a_VREG_Noop_Vdn05,
    a_PREG_Pg1013_Noop,
    a_VREG_Noop_Vdn05,
}
var Zm_T__Vdn__Pg__Vdn__2 = []operand{
    a_ARNG_Zm510V2_SizeHSD2224,
    a_VREG_Noop_Vdn05,
    a_PREG_Pg1013_Noop,
    a_VREG_Noop_Vdn05,
}
var Zm_T__Zdn_T__PgM__Zdn_T__1 = []operand{
    a_ARNG_Zm510V1_SizeBHSD2224,
    a_ARNG_ZdnDest_SizeBHSD2224,
    a_PREGZM_Pg1013_MergePredCheck,
    a_ARNG_ZdnDest_SizeBHSD2224,
}
var Zm_T__Zdn_T__PgM__Zdn_T__2 = []operand{
    a_ARNG_Zm510V1_SizeHSD2224,
    a_ARNG_ZdnDest_SizeHSD2224,
    a_PREGZM_Pg1013_MergePredCheck,
    a_ARNG_ZdnDest_SizeHSD2224,
}
var Zm_T__Zdn_T__PgM__Zdn_T__3 = []operand{
    a_ARNG_Zm510V1_SizeHSD2224No00,
    a_ARNG_ZdnDest_SizeHSD2224No00,
    a_PREGZM_Pg1013_MergePredCheck,
    a_ARNG_ZdnDest_SizeHSD2224No00,
}
var Zm_T__Zdn_T__PgM__Zdn_T__4 = []operand{
    a_ARNG_Zm510V1_Size0SD2223,
    a_ARNG_ZdnDest_Size0SD2223,
    a_PREGZM_Pg1013_MergePredCheck,
    a_ARNG_ZdnDest_Size0SD2223,
}
var Zm_T__Zdn_T__Pg__Zdn_T = []operand{
    a_ARNG_Zm510V1_SizeBHSD2224,
    a_ARNG_ZdnDest_SizeBHSD2224,
    a_PREG_Pg1013_Noop,
    a_ARNG_ZdnDest_SizeBHSD2224,
}
var Zm_T__Zdn_T__Pv__Zdn_T = []operand{
    a_ARNG_Zm510V1_SizeBHSD2224,
    a_ARNG_ZdnDest_SizeBHSD2224,
    a_PREG_Pv1013_Noop,
    a_ARNG_ZdnDest_SizeBHSD2224,
}
var Zm_T__Zn_T__PgM__Zda_T__1 = []operand{
    a_ARNG_Zm1621V2_SizeHSD2224No00,
    a_ARNG_Zn510V1_SizeHSD2224No00,
    a_PREGZM_Pg1013_MergePredCheck,
    a_ARNG_Zda3RdSrcDst_SizeHSD2224No00,
}
var Zm_T__Zn_T__PgM__Zda_T__2 = []operand{
    a_ARNG_Zm1621V2_SizeBHSD2224,
    a_ARNG_Zn510V1_SizeBHSD2224,
    a_PREGZM_Pg1013_MergePredCheck,
    a_ARNG_Zda3RdSrcDst_SizeBHSD2224,
}
var Zm_T__Zn_T__PgZ__Pd_T__1 = []operand{
    a_ARNG_Zm1621V2_SizeHSD2224,
    a_ARNG_Zn510V1_SizeHSD2224,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_ARNG_Pd_SizeHSD2224,
}
var Zm_T__Zn_T__PgZ__Pd_T__2 = []operand{
    a_ARNG_Zm1621V2_SizeBHSD2224,
    a_ARNG_Zn510V1_SizeBHSD2224,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_ARNG_Pd_SizeBHSD2224,
}
var Zm_T__Zn_T__PgZ__Pd_T__3 = []operand{
    a_ARNG_Zm1621V2_Size0BH2223,
    a_ARNG_Zn510V1_Size0BH2223,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_ARNG_Pd_Size0BH2223,
}
var Zm_T__Zn_T__PgZ__Zd_T = []operand{
    a_ARNG_Zm1621V2_Size0SD2223,
    a_ARNG_Zn510V1_Size0SD2223,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_ARNG_Zd_Size0SD2223,
}
var Zm_T__Zn_T__Pv__Zd_T = []operand{
    a_ARNG_Zm1621V2_SizeBHSD2224,
    a_ARNG_Zn510V1_SizeBHSD2224,
    a_PREG_Pv1014_Noop,
    a_ARNG_Zd_SizeBHSD2224,
}
var Zm_T__Zn_T__Zd_T__1 = []operand{
    a_ARNG_Zm1621V2_SizeBHSD2224,
    a_ARNG_Zn510V1_SizeBHSD2224,
    a_ARNG_Zd_SizeBHSD2224,
}
var Zm_T__Zn_T__Zd_T__2 = []operand{
    a_ARNG_Zm1621V2_SizeHSD2224No00,
    a_ARNG_Zn510V1_SizeHSD2224No00,
    a_ARNG_Zd_SizeHSD2224No00,
}
var Zm_T__Zn_T__Zd_T__3 = []operand{
    a_ARNG_Zm1621V2_SizeHSD2224,
    a_ARNG_Zn510V1_SizeHSD2224,
    a_ARNG_Zd_SizeHSD2224,
}
var Zm_T__Zn_T__Zda_T__1 = []operand{
    a_ARNG_Zm1621V2_SzSD2223,
    a_ARNG_Zn510V1_SzSD2223,
    a_ARNG_Zda3RdSrcDst_SzSD2223,
}
var Zm_T__Zn_T__Zda_T__2 = []operand{
    a_ARNG_Zm1621V2_SizeBHSD2224,
    a_ARNG_Zn510V1_SizeBHSD2224,
    a_ARNG_Zda3RdSrcDst_SizeBHSD2224,
}
var Zm_T___Zn1_T__Zn2_T___Zd_T = []operand{
    a_ARNG_Zm1621V2_SizeBHSD2224,
    a_REGLIST2_GenZn510V1_SizeBHSD2224_GenZn510V2_SizeBHSD2224,
    a_ARNG_Zd_SizeBHSD2224,
}
var Zm_T___Zn_T___Zd_T = []operand{
    a_ARNG_Zm1621V2_SizeBHSD2224,
    a_REGLIST1_Zn510V1_SizeBHSD2224,
    a_ARNG_Zd_SizeBHSD2224,
}
var Zm_Tb__Zn_T__Zd_T = []operand{
    a_ARNG_Zm1621V2_SizeTbBHS2224,
    a_ARNG_Zn510V1_SizeHSD2224,
    a_ARNG_Zd_SizeHSD2224,
}
var Zm_Tb__Zn_Tb__Zd_T__1 = []operand{
    a_ARNG_Zm1621V2_SizeTbBHS2224,
    a_ARNG_Zn510V1_SizeTbBHS2224,
    a_ARNG_Zd_SizeHSD2224,
}
var Zm_Tb__Zn_Tb__Zd_T__2 = []operand{
    a_ARNG_Zm1621V2_SizeTbHSD2224Offset1,
    a_ARNG_Zn510V1_SizeTbHSD2224Offset1,
    a_ARNG_Zd_SizeBHS2224Offset1,
}
var Zm_Tb__Zn_Tb__Zd_T__3 = []operand{
    a_ARNG_Zm1621V2_SizeTbBS2224,
    a_ARNG_Zn510V1_SizeTbBS2224,
    a_ARNG_Zd_SizeHD2224,
}
var Zm_Tb__Zn_Tb__Zda_T__1 = []operand{
    a_ARNG_Zm1621V2_SizeTbBHS2224,
    a_ARNG_Zn510V1_SizeTbBHS2224,
    a_ARNG_Zda3RdSrcDst_SizeHSD2224,
}
var Zm_Tb__Zn_Tb__Zda_T__2 = []operand{
    a_ARNG_Zm1621V2_Size0TbBH2223,
    a_ARNG_Zn510V1_Size0TbBH2223,
    a_ARNG_Zda3RdSrcDst_Size0SD2223,
}
var Zm___Zn1_B__Zn2_B___Zd_B = []operand{
    a_ZREG_Zm1621V1_Noop,
    a_REGLIST2_Zn510Table1_ArngBCheck_Zn510Table2_ArngBCheck,
    a_ARNG_Zd_ArngBCheck,
}
var Zm_index____Zn1_H__Zn2_H___Zd_H__1 = []operand{
    a_ZREGIDX_Zm1621V1_Noop_I22224HW,
    a_REGLIST2_Zn510Table1_ArngHCheck_Zn510Table2_ArngHCheck,
    a_ARNG_Zd_ArngHCheck,
}
var Zm_index____Zn1_H__Zn2_H___Zd_H__2 = []operand{
    a_ZREGIDX_Zm1621V1_Noop_I12324,
    a_REGLIST2_Zn510Table1_ArngHCheck_Zn510Table2_ArngHCheck,
    a_ARNG_Zd_ArngHCheck,
}
var Zm_index____Zn_B___Zd_B__1 = []operand{
    a_ZREGIDX_Zm1621V1_Noop_I22224,
    a_REGLIST1_Zn510Table3_ArngBCheck,
    a_ARNG_Zd_ArngBCheck,
}
var Zm_index____Zn_B___Zd_B__2 = []operand{
    a_ZREGIDX_Zm1621V1_Noop_I12324B,
    a_REGLIST1_Zn510Table3_ArngBCheck,
    a_ARNG_Zd_ArngBCheck,
}
var Zm_index____Zn_H___Zd_H__1 = []operand{
    a_ZREGIDX_Zm1621V1_Noop_I3224I31213,
    a_REGLIST1_Zn510Table3_ArngHCheck,
    a_ARNG_Zd_ArngHCheck,
}
var Zm_index____Zn_H___Zd_H__2 = []operand{
    a_ZREGIDX_Zm1621V1_Noop_I22224HW,
    a_REGLIST1_Zn510Table3_ArngHCheck,
    a_ARNG_Zd_ArngHCheck,
}
var Zn1_H_Zn2_H___Zd_B = []operand{
    a_REGLIST_RANGE_Zn610V1_ArngHCheck_Zn610V2_ArngHCheck,
    a_ARNG_Zd_ArngBCheck,
}
var Zn1_S_Zn2_S___Zd_B = []operand{
    a_REGLIST_RANGE_Zn610V1_ArngSCheck_Zn610V2_ArngSCheck,
    a_ARNG_Zd_ArngBCheck,
}
var Zn1_S_Zn2_S___Zd_H = []operand{
    a_REGLIST_RANGE_Zn610V1_ArngSCheck_Zn610V2_ArngSCheck,
    a_ARNG_Zd_ArngHCheck,
}
var Zn1_T__Zn2_T___Pv__Zd_T = []operand{
    a_REGLIST2_Zn510MultiSrc1_SizeBHSD2224_Zn510MultiSrc2_SizeBHSD2224,
    a_PREG_Pv1013_Noop,
    a_ARNG_Zd_SizeBHSD2224,
}
var Zn1_Tb_Zn2_Tb___Zd_T = []operand{
    a_REGLIST_RANGE_Zn610V1_SizeTbHSD2224Offset1_Zn610V2_SizeTbHSD2224Offset1,
    a_ARNG_Zd_SizeBHS2224Offset1,
}
var Zn_B__Zd_H = []operand{
    a_ARNG_Zn510Src_ArngBCheck,
    a_ARNG_Zd_ArngHCheck,
}
var Zn_D__PgM__Zd_D = []operand{
    a_ARNG_Zn510Src_ArngDCheck,
    a_PREGZM_Pg1013_MergePredCheck,
    a_ARNG_Zd_ArngDCheck,
}
var Zn_D__PgM__Zd_H = []operand{
    a_ARNG_Zn510Src_ArngDCheck,
    a_PREGZM_Pg1013_MergePredCheck,
    a_ARNG_Zd_ArngHCheck,
}
var Zn_D__PgM__Zd_S = []operand{
    a_ARNG_Zn510Src_ArngDCheck,
    a_PREGZM_Pg1013_MergePredCheck,
    a_ARNG_Zd_ArngSCheck,
}
var Zn_D__PgZ__Zd_D = []operand{
    a_ARNG_Zn510Src_ArngDCheck,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_ARNG_Zd_ArngDCheck,
}
var Zn_D__PgZ__Zd_H = []operand{
    a_ARNG_Zn510Src_ArngDCheck,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_ARNG_Zd_ArngHCheck,
}
var Zn_D__PgZ__Zd_S = []operand{
    a_ARNG_Zn510Src_ArngDCheck,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_ARNG_Zd_ArngSCheck,
}
var Zn_D__Xm___PgZ___Zt_D_ = []operand{
    a_MEMEXT_Zn510V2_ArngDCheck_Rm1621XZR_Noop_NoModCheck_NoAmtCheck,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngDCheck,
}
var Zn_D__Xm___PgZ___Zt_Q_ = []operand{
    a_MEMEXT_Zn510V2_ArngDCheck_Rm1621XZR_Noop_NoModCheck_NoAmtCheck,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngQCheck,
}
var Zn_D__Zm_D__SXTWamount___Zd_D = []operand{
    a_MEMEXT_Zn510V2_ArngDCheck_Zm1621V3_ArngDCheck_ModSXTWCheck_Msz1012Amount,
    a_ARNG_Zd_ArngDCheck,
}
var Zn_D__Zm_D__UXTWamount___Zd_D = []operand{
    a_MEMEXT_Zn510V2_ArngDCheck_Zm1621V3_ArngDCheck_ModUXTWCheck_Msz1012Amount,
    a_ARNG_Zd_ArngDCheck,
}
var Zn_D__cimm___PgZ___Zt_D___1 = []operand{
    a_MEMOFF_Zn510V2_ArngDCheck_Imm51621V4,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngDCheck,
}
var Zn_D__cimm___PgZ___Zt_D___2 = []operand{
    a_MEMOFF_Zn510V2_ArngDCheck_Imm51621V1,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngDCheck,
}
var Zn_D__cimm___PgZ___Zt_D___3 = []operand{
    a_MEMOFF_Zn510V2_ArngDCheck_Imm51621V2,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngDCheck,
}
var Zn_D__cimm___PgZ___Zt_D___4 = []operand{
    a_MEMOFF_Zn510V2_ArngDCheck_Imm51621V3,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngDCheck,
}
var Zn_D__cimm___Pg__prfop__1 = []operand{
    a_MEMOFF_Zn510V2_ArngDCheck_Imm51621V4,
    a_PREG_Pg1013_Noop,
    a_SPECIAL_Prfop04,
}
var Zn_D__cimm___Pg__prfop__2 = []operand{
    a_MEMOFF_Zn510V2_ArngDCheck_Imm51621V3,
    a_PREG_Pg1013_Noop,
    a_SPECIAL_Prfop04,
}
var Zn_D__cimm___Pg__prfop__3 = []operand{
    a_MEMOFF_Zn510V2_ArngDCheck_Imm51621V1,
    a_PREG_Pg1013_Noop,
    a_SPECIAL_Prfop04,
}
var Zn_D__cimm___Pg__prfop__4 = []operand{
    a_MEMOFF_Zn510V2_ArngDCheck_Imm51621V2,
    a_PREG_Pg1013_Noop,
    a_SPECIAL_Prfop04,
}
var Zn_H__PgM__Zd_D = []operand{
    a_ARNG_Zn510Src_ArngHCheck,
    a_PREGZM_Pg1013_MergePredCheck,
    a_ARNG_Zd_ArngDCheck,
}
var Zn_H__PgM__Zd_H = []operand{
    a_ARNG_Zn510Src_ArngHCheck,
    a_PREGZM_Pg1013_MergePredCheck,
    a_ARNG_Zd_ArngHCheck,
}
var Zn_H__PgM__Zd_S = []operand{
    a_ARNG_Zn510Src_ArngHCheck,
    a_PREGZM_Pg1013_MergePredCheck,
    a_ARNG_Zd_ArngSCheck,
}
var Zn_H__PgZ__Zd_D = []operand{
    a_ARNG_Zn510Src_ArngHCheck,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_ARNG_Zd_ArngDCheck,
}
var Zn_H__PgZ__Zd_H = []operand{
    a_ARNG_Zn510Src_ArngHCheck,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_ARNG_Zd_ArngHCheck,
}
var Zn_H__PgZ__Zd_S = []operand{
    a_ARNG_Zn510Src_ArngHCheck,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_ARNG_Zd_ArngSCheck,
}
var Zn_Q__PgM__Zd_Q = []operand{
    a_ARNG_Zn510Src_ArngQCheck,
    a_PREGZM_Pg1013_MergePredCheck,
    a_ARNG_Zd_ArngQCheck,
}
var Zn_Q__PgZ__Zd_Q = []operand{
    a_ARNG_Zn510Src_ArngQCheck,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_ARNG_Zd_ArngQCheck,
}
var Zn_S__PgM__Zd_D = []operand{
    a_ARNG_Zn510Src_ArngSCheck,
    a_PREGZM_Pg1013_MergePredCheck,
    a_ARNG_Zd_ArngDCheck,
}
var Zn_S__PgM__Zd_H = []operand{
    a_ARNG_Zn510Src_ArngSCheck,
    a_PREGZM_Pg1013_MergePredCheck,
    a_ARNG_Zd_ArngHCheck,
}
var Zn_S__PgM__Zd_S = []operand{
    a_ARNG_Zn510Src_ArngSCheck,
    a_PREGZM_Pg1013_MergePredCheck,
    a_ARNG_Zd_ArngSCheck,
}
var Zn_S__PgZ__Zd_D = []operand{
    a_ARNG_Zn510Src_ArngSCheck,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_ARNG_Zd_ArngDCheck,
}
var Zn_S__PgZ__Zd_H = []operand{
    a_ARNG_Zn510Src_ArngSCheck,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_ARNG_Zd_ArngHCheck,
}
var Zn_S__PgZ__Zd_S = []operand{
    a_ARNG_Zn510Src_ArngSCheck,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_ARNG_Zd_ArngSCheck,
}
var Zn_S__Xm___PgZ___Zt_S_ = []operand{
    a_MEMEXT_Zn510V2_ArngSCheck_Rm1621XZR_Noop_NoModCheck_NoAmtCheck,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngSCheck,
}
var Zn_S__cimm___PgZ___Zt_S___1 = []operand{
    a_MEMOFF_Zn510V2_ArngSCheck_Imm51621V4,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngSCheck,
}
var Zn_S__cimm___PgZ___Zt_S___2 = []operand{
    a_MEMOFF_Zn510V2_ArngSCheck_Imm51621V1,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngSCheck,
}
var Zn_S__cimm___PgZ___Zt_S___3 = []operand{
    a_MEMOFF_Zn510V2_ArngSCheck_Imm51621V2,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_REGLIST1_Zt05_ArngSCheck,
}
var Zn_S__cimm___Pg__prfop__1 = []operand{
    a_MEMOFF_Zn510V2_ArngSCheck_Imm51621V4,
    a_PREG_Pg1013_Noop,
    a_SPECIAL_Prfop04,
}
var Zn_S__cimm___Pg__prfop__2 = []operand{
    a_MEMOFF_Zn510V2_ArngSCheck_Imm51621V3,
    a_PREG_Pg1013_Noop,
    a_SPECIAL_Prfop04,
}
var Zn_S__cimm___Pg__prfop__3 = []operand{
    a_MEMOFF_Zn510V2_ArngSCheck_Imm51621V1,
    a_PREG_Pg1013_Noop,
    a_SPECIAL_Prfop04,
}
var Zn_S__cimm___Pg__prfop__4 = []operand{
    a_MEMOFF_Zn510V2_ArngSCheck_Imm51621V2,
    a_PREG_Pg1013_Noop,
    a_SPECIAL_Prfop04,
}
var Zn_T__PgM__Zd_T__1 = []operand{
    a_ARNG_Zn510Src_SizeHSD2224,
    a_PREGZM_Pg1013_MergePredCheck,
    a_ARNG_Zd_SizeHSD2224,
}
var Zn_T__PgM__Zd_T__2 = []operand{
    a_ARNG_Zn510Src_SizeBHSD2224,
    a_PREGZM_Pg1013_MergePredCheck,
    a_ARNG_Zd_SizeBHSD2224,
}
var Zn_T__PgM__Zd_T__3 = []operand{
    a_ARNG_Zn510Src_SzSD1718,
    a_PREGZM_Pg1013_MergePredCheck,
    a_ARNG_Zd_SzSD1718,
}
var Zn_T__PgM__Zd_T__4 = []operand{
    a_ARNG_Zn510Src_SizeByteMergeZero,
    a_PREGZM_Pg1013_MergePredCheck,
    a_ARNG_Zd_SizeByteMergeZero,
}
var Zn_T__PgM__Zd_T__5 = []operand{
    a_ARNG_Zn510Src_Size0HalfwordMergeZero,
    a_PREGZM_Pg1013_MergePredCheck,
    a_ARNG_Zd_Size0HalfwordMergeZero,
}
var Zn_T__PgM__Zd_T__6 = []operand{
    a_ARNG_Zn510Src_SizeHSD1719,
    a_PREGZM_Pg1013_MergePredCheck,
    a_ARNG_Zd_SizeHSD1719,
}
var Zn_T__PgZM__Zd_T = []operand{
    a_ARNG_Zn510Src_SizeBHSD2224,
    a_PREGZM_Pg1013_PredQualM1617,
    a_ARNG_Zd_SizeBHSD2224,
}
var Zn_T__PgZ__Zd_T__1 = []operand{
    a_ARNG_Zn510Src_SizeHSD2224,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_ARNG_Zd_SizeHSD2224,
}
var Zn_T__PgZ__Zd_T__2 = []operand{
    a_ARNG_Zn510Src_SizeBHSD2224,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_ARNG_Zd_SizeBHSD2224,
}
var Zn_T__PgZ__Zd_T__3 = []operand{
    a_ARNG_Zn510Src_SzSD1415,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_ARNG_Zd_SzSD1415,
}
var Zn_T__PgZ__Zd_T__4 = []operand{
    a_ARNG_Zn510Src_SizeByteMergeZero,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_ARNG_Zd_SizeByteMergeZero,
}
var Zn_T__PgZ__Zd_T__5 = []operand{
    a_ARNG_Zn510Src_Size0HalfwordMergeZero,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_ARNG_Zd_Size0HalfwordMergeZero,
}
var Zn_T__PgZ__Zd_T__6 = []operand{
    a_ARNG_Zn510Src_SizeHSD1315,
    a_PREGZM_Pg1013_ZeroPredCheck,
    a_ARNG_Zd_SizeHSD1315,
}
var Zn_T__Pg__Dd__1 = []operand{
    a_ARNG_Zn510Src_SizeBHS2224,
    a_PREG_Pg1013_Noop,
    a_VREG_Noop_Vd0564,
}
var Zn_T__Pg__Dd__2 = []operand{
    a_ARNG_Zn510Src_SizeBHSD2224,
    a_PREG_Pg1013_Noop,
    a_VREG_Noop_Vd0564,
}
var Zn_T__Pg__Rd = []operand{
    a_ARNG_Zn510Src_SizeBHSD2224,
    a_PREG_Pg1013_Noop,
    a_SPZGREG_Noop_Rd05ZR,
}
var Zn_T__Pg__Vd__1 = []operand{
    a_ARNG_Zn510Src_SizeBHSD2224,
    a_PREG_Pg1013_Noop,
    a_VREG_Noop_Vd05,
}
var Zn_T__Pg__Vd__2 = []operand{
    a_ARNG_Zn510Src_SizeHSD2224,
    a_PREG_Pg1013_Noop,
    a_VREG_Noop_Vd05,
}
var Zn_T__Pg__Zd_T__1 = []operand{
    a_ARNG_Zn510Src_SzByteHalfword,
    a_PREG_Pg1013_Noop,
    a_ARNG_Zd_SzByteHalfword,
}
var Zn_T__Pg__Zd_T__2 = []operand{
    a_ARNG_Zn510Src_SzWordDoubleword,
    a_PREG_Pg1013_Noop,
    a_ARNG_Zd_SzWordDoubleword,
}
var Zn_T__Pg__Zd_T__3 = []operand{
    a_ARNG_Zn510Src_SizeBHSD2224,
    a_PREG_Pg1013_Noop,
    a_ARNG_Zd_SizeBHSD2224,
}
var Zn_T__Zd_T__1 = []operand{
    a_ARNG_Zn510Src_SizeHSD2224,
    a_ARNG_Zd_SizeHSD2224,
}
var Zn_T__Zd_T__2 = []operand{
    a_ARNG_Zn510Src_SizeBHSD2224,
    a_ARNG_Zd_SizeBHSD2224,
}
var Zn_T__Zm_T__mod_amount___Zd_T = []operand{
    a_MEMEXT_Zn510V2_SzSD2223_Zm1621V3_SzSD2223_Msz1012_Msz1012Amount,
    a_ARNG_Zd_SzSD2223,
}
var Zn_T_imm___Zd_T__1 = []operand{
    a_ARNGIDX_Zn510Src_Tsz_1621_SizeSpecifier5_Imm2Tsz_Delegate,
    a_ARNG_Zd_Tsz_1621_SizeSpecifier5,
}
var Zn_T_imm___Zd_T__2 = []operand{
    a_ARNGIDX_Zn510Src_Tsz_1620_SizeSpecifier4_I1Tsz_Delegate,
    a_ARNG_Zd_Tsz_1620_SizeSpecifier4,
}
var Zn_Tb__PgM__Zda_T = []operand{
    a_ARNG_Zn510V1_SizeTbBHS2224,
    a_PREGZM_Pg1013_MergePredCheck,
    a_ARNG_ZdaDest_SizeHSD2224,
}
var Zn_Tb__Pg__Vd_T__1 = []operand{
    a_ARNG_Zn510Src_SizeTbBHSD2224,
    a_PREG_Pg1013_Noop,
    a_ARNG_Vd_Size16B8H4S2D,
}
var Zn_Tb__Pg__Vd_T__2 = []operand{
    a_ARNG_Zn510Src_SizeTbHSD2224Offset1,
    a_PREG_Pg1013_Noop,
    a_ARNG_Vd_Size8H4S2D,
}
var Zn_Tb__Zd_T__1 = []operand{
    a_ARNG_Zn510Src_SizeTbBHS2224,
    a_ARNG_Zd_SizeHSD2224,
}
var Zn_Tb__Zd_T__2 = []operand{
    a_ARNG_Zn510Src_TszhTszlTbHSD,
    a_ARNG_Zd_TszhTszlBHS,
}
var Zn__Pd_B = []operand{
    a_ZREG_Zn510Src_Noop,
    a_ARNG_Pd_ArngBCheck,
}
var Zn__Zd = []operand{
    a_ZREG_Zn510Src_Noop,
    a_ZREG_Zd_Noop,
}
var Zn_imm___Pd_D = []operand{
    a_ZREGIDX_Zn510Src_Noop_I3hI3l_1722_Doubleword,
    a_ARNG_Pd_ArngDCheck,
}
var Zn_imm___Pd_H = []operand{
    a_ZREGIDX_Zn510Src_Noop_I1_1718_Halfword,
    a_ARNG_Pd_ArngHCheck,
}
var Zn_imm___Pd_S = []operand{
    a_ZREGIDX_Zn510Src_Noop_I2_1719_Word,
    a_ARNG_Pd_ArngSCheck,
}
var Zt1_B_Zt2_B___PNg___XnSP__Xm_ = []operand{
    a_REGLIST_RANGE_Zt15V1_ArngBCheck_Zt15V2_ArngBCheck,
    a_PREG_PNg1013_Noop,
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_NoModCheck_NoAmtCheck,
}
var Zt1_B_Zt2_B___PNg___XnSP__cimm__MUL_VL_ = []operand{
    a_REGLIST_RANGE_Zt15V1_ArngBCheck_Zt15V2_ArngBCheck,
    a_PREG_PNg1013_Noop,
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V9,
}
var Zt1_B_Zt4_B___PNg___XnSP__Xm_ = []operand{
    a_REGLIST_RANGE_Zt25V1_ArngBCheck_Zt25V2_ArngBCheck,
    a_PREG_PNg1013_Noop,
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_NoModCheck_NoAmtCheck,
}
var Zt1_B_Zt4_B___PNg___XnSP__cimm__MUL_VL_ = []operand{
    a_REGLIST_RANGE_Zt25V1_ArngBCheck_Zt25V2_ArngBCheck,
    a_PREG_PNg1013_Noop,
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V8,
}
var Zt1_B__Zt2_B__Zt3_B__Zt4_B___Pg___XnSP__Xm_ = []operand{
    a_REGLIST4_Zt051_ArngBCheck_Zt052_ArngBCheck_Zt053_ArngBCheck_Zt054_ArngBCheck,
    a_PREG_Pg1013_Noop,
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_NoModCheck_NoAmtCheck,
}
var Zt1_B__Zt2_B__Zt3_B__Zt4_B___Pg___XnSP__cimm__MUL_VL_ = []operand{
    a_REGLIST4_Zt051_ArngBCheck_Zt052_ArngBCheck_Zt053_ArngBCheck_Zt054_ArngBCheck,
    a_PREG_Pg1013_Noop,
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V4,
}
var Zt1_B__Zt2_B__Zt3_B___Pg___XnSP__Xm_ = []operand{
    a_REGLIST3_Zt051_ArngBCheck_Zt052_ArngBCheck_Zt053_ArngBCheck,
    a_PREG_Pg1013_Noop,
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_NoModCheck_NoAmtCheck,
}
var Zt1_B__Zt2_B__Zt3_B___Pg___XnSP__cimm__MUL_VL_ = []operand{
    a_REGLIST3_Zt051_ArngBCheck_Zt052_ArngBCheck_Zt053_ArngBCheck,
    a_PREG_Pg1013_Noop,
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V3,
}
var Zt1_B__Zt2_B___Pg___XnSP__Xm_ = []operand{
    a_REGLIST2_Zt051_ArngBCheck_Zt052_ArngBCheck,
    a_PREG_Pg1013_Noop,
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_NoModCheck_NoAmtCheck,
}
var Zt1_B__Zt2_B___Pg___XnSP__cimm__MUL_VL_ = []operand{
    a_REGLIST2_Zt051_ArngBCheck_Zt052_ArngBCheck,
    a_PREG_Pg1013_Noop,
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V6,
}
var Zt1_D_Zt2_D___PNg___XnSP__Xm__LSL_c3_ = []operand{
    a_REGLIST_RANGE_Zt15V1_ArngDCheck_Zt15V2_ArngDCheck,
    a_PREG_PNg1013_Noop,
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt3Check,
}
var Zt1_D_Zt2_D___PNg___XnSP__cimm__MUL_VL_ = []operand{
    a_REGLIST_RANGE_Zt15V1_ArngDCheck_Zt15V2_ArngDCheck,
    a_PREG_PNg1013_Noop,
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V9,
}
var Zt1_D_Zt4_D___PNg___XnSP__Xm__LSL_c3_ = []operand{
    a_REGLIST_RANGE_Zt25V1_ArngDCheck_Zt25V2_ArngDCheck,
    a_PREG_PNg1013_Noop,
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt3Check,
}
var Zt1_D_Zt4_D___PNg___XnSP__cimm__MUL_VL_ = []operand{
    a_REGLIST_RANGE_Zt25V1_ArngDCheck_Zt25V2_ArngDCheck,
    a_PREG_PNg1013_Noop,
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V8,
}
var Zt1_D__Zt2_D__Zt3_D__Zt4_D___Pg___XnSP__Xm__LSL_c3_ = []operand{
    a_REGLIST4_Zt051_ArngDCheck_Zt052_ArngDCheck_Zt053_ArngDCheck_Zt054_ArngDCheck,
    a_PREG_Pg1013_Noop,
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt3Check,
}
var Zt1_D__Zt2_D__Zt3_D__Zt4_D___Pg___XnSP__cimm__MUL_VL_ = []operand{
    a_REGLIST4_Zt051_ArngDCheck_Zt052_ArngDCheck_Zt053_ArngDCheck_Zt054_ArngDCheck,
    a_PREG_Pg1013_Noop,
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V4,
}
var Zt1_D__Zt2_D__Zt3_D___Pg___XnSP__Xm__LSL_c3_ = []operand{
    a_REGLIST3_Zt051_ArngDCheck_Zt052_ArngDCheck_Zt053_ArngDCheck,
    a_PREG_Pg1013_Noop,
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt3Check,
}
var Zt1_D__Zt2_D__Zt3_D___Pg___XnSP__cimm__MUL_VL_ = []operand{
    a_REGLIST3_Zt051_ArngDCheck_Zt052_ArngDCheck_Zt053_ArngDCheck,
    a_PREG_Pg1013_Noop,
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V3,
}
var Zt1_D__Zt2_D___Pg___XnSP__Xm__LSL_c3_ = []operand{
    a_REGLIST2_Zt051_ArngDCheck_Zt052_ArngDCheck,
    a_PREG_Pg1013_Noop,
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt3Check,
}
var Zt1_D__Zt2_D___Pg___XnSP__cimm__MUL_VL_ = []operand{
    a_REGLIST2_Zt051_ArngDCheck_Zt052_ArngDCheck,
    a_PREG_Pg1013_Noop,
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V6,
}
var Zt1_H_Zt2_H___PNg___XnSP__Xm__LSL_c1_ = []operand{
    a_REGLIST_RANGE_Zt15V1_ArngHCheck_Zt15V2_ArngHCheck,
    a_PREG_PNg1013_Noop,
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt1Check,
}
var Zt1_H_Zt2_H___PNg___XnSP__cimm__MUL_VL_ = []operand{
    a_REGLIST_RANGE_Zt15V1_ArngHCheck_Zt15V2_ArngHCheck,
    a_PREG_PNg1013_Noop,
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V9,
}
var Zt1_H_Zt4_H___PNg___XnSP__Xm__LSL_c1_ = []operand{
    a_REGLIST_RANGE_Zt25V1_ArngHCheck_Zt25V2_ArngHCheck,
    a_PREG_PNg1013_Noop,
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt1Check,
}
var Zt1_H_Zt4_H___PNg___XnSP__cimm__MUL_VL_ = []operand{
    a_REGLIST_RANGE_Zt25V1_ArngHCheck_Zt25V2_ArngHCheck,
    a_PREG_PNg1013_Noop,
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V8,
}
var Zt1_H__Zt2_H__Zt3_H__Zt4_H___Pg___XnSP__Xm__LSL_c1_ = []operand{
    a_REGLIST4_Zt051_ArngHCheck_Zt052_ArngHCheck_Zt053_ArngHCheck_Zt054_ArngHCheck,
    a_PREG_Pg1013_Noop,
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt1Check,
}
var Zt1_H__Zt2_H__Zt3_H__Zt4_H___Pg___XnSP__cimm__MUL_VL_ = []operand{
    a_REGLIST4_Zt051_ArngHCheck_Zt052_ArngHCheck_Zt053_ArngHCheck_Zt054_ArngHCheck,
    a_PREG_Pg1013_Noop,
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V4,
}
var Zt1_H__Zt2_H__Zt3_H___Pg___XnSP__Xm__LSL_c1_ = []operand{
    a_REGLIST3_Zt051_ArngHCheck_Zt052_ArngHCheck_Zt053_ArngHCheck,
    a_PREG_Pg1013_Noop,
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt1Check,
}
var Zt1_H__Zt2_H__Zt3_H___Pg___XnSP__cimm__MUL_VL_ = []operand{
    a_REGLIST3_Zt051_ArngHCheck_Zt052_ArngHCheck_Zt053_ArngHCheck,
    a_PREG_Pg1013_Noop,
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V3,
}
var Zt1_H__Zt2_H___Pg___XnSP__Xm__LSL_c1_ = []operand{
    a_REGLIST2_Zt051_ArngHCheck_Zt052_ArngHCheck,
    a_PREG_Pg1013_Noop,
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt1Check,
}
var Zt1_H__Zt2_H___Pg___XnSP__cimm__MUL_VL_ = []operand{
    a_REGLIST2_Zt051_ArngHCheck_Zt052_ArngHCheck,
    a_PREG_Pg1013_Noop,
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V6,
}
var Zt1_Q__Zt2_Q__Zt3_Q__Zt4_Q___Pg___XnSP__Xm__LSL_c4_ = []operand{
    a_REGLIST4_Zt051_ArngQCheck_Zt052_ArngQCheck_Zt053_ArngQCheck_Zt054_ArngQCheck,
    a_PREG_Pg1013_Noop,
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt4Check,
}
var Zt1_Q__Zt2_Q__Zt3_Q__Zt4_Q___Pg___XnSP__cimm__MUL_VL_ = []operand{
    a_REGLIST4_Zt051_ArngQCheck_Zt052_ArngQCheck_Zt053_ArngQCheck_Zt054_ArngQCheck,
    a_PREG_Pg1013_Noop,
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V4,
}
var Zt1_Q__Zt2_Q__Zt3_Q___Pg___XnSP__Xm__LSL_c4_ = []operand{
    a_REGLIST3_Zt051_ArngQCheck_Zt052_ArngQCheck_Zt053_ArngQCheck,
    a_PREG_Pg1013_Noop,
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt4Check,
}
var Zt1_Q__Zt2_Q__Zt3_Q___Pg___XnSP__cimm__MUL_VL_ = []operand{
    a_REGLIST3_Zt051_ArngQCheck_Zt052_ArngQCheck_Zt053_ArngQCheck,
    a_PREG_Pg1013_Noop,
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V3,
}
var Zt1_Q__Zt2_Q___Pg___XnSP__Xm__LSL_c4_ = []operand{
    a_REGLIST2_Zt051_ArngQCheck_Zt052_ArngQCheck,
    a_PREG_Pg1013_Noop,
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt4Check,
}
var Zt1_Q__Zt2_Q___Pg___XnSP__cimm__MUL_VL_ = []operand{
    a_REGLIST2_Zt051_ArngQCheck_Zt052_ArngQCheck,
    a_PREG_Pg1013_Noop,
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V6,
}
var Zt1_S_Zt2_S___PNg___XnSP__Xm__LSL_c2_ = []operand{
    a_REGLIST_RANGE_Zt15V1_ArngSCheck_Zt15V2_ArngSCheck,
    a_PREG_PNg1013_Noop,
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt2Check,
}
var Zt1_S_Zt2_S___PNg___XnSP__cimm__MUL_VL_ = []operand{
    a_REGLIST_RANGE_Zt15V1_ArngSCheck_Zt15V2_ArngSCheck,
    a_PREG_PNg1013_Noop,
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V9,
}
var Zt1_S_Zt4_S___PNg___XnSP__Xm__LSL_c2_ = []operand{
    a_REGLIST_RANGE_Zt25V1_ArngSCheck_Zt25V2_ArngSCheck,
    a_PREG_PNg1013_Noop,
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt2Check,
}
var Zt1_S_Zt4_S___PNg___XnSP__cimm__MUL_VL_ = []operand{
    a_REGLIST_RANGE_Zt25V1_ArngSCheck_Zt25V2_ArngSCheck,
    a_PREG_PNg1013_Noop,
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V8,
}
var Zt1_S__Zt2_S__Zt3_S__Zt4_S___Pg___XnSP__Xm__LSL_c2_ = []operand{
    a_REGLIST4_Zt051_ArngSCheck_Zt052_ArngSCheck_Zt053_ArngSCheck_Zt054_ArngSCheck,
    a_PREG_Pg1013_Noop,
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt2Check,
}
var Zt1_S__Zt2_S__Zt3_S__Zt4_S___Pg___XnSP__cimm__MUL_VL_ = []operand{
    a_REGLIST4_Zt051_ArngSCheck_Zt052_ArngSCheck_Zt053_ArngSCheck_Zt054_ArngSCheck,
    a_PREG_Pg1013_Noop,
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V4,
}
var Zt1_S__Zt2_S__Zt3_S___Pg___XnSP__Xm__LSL_c2_ = []operand{
    a_REGLIST3_Zt051_ArngSCheck_Zt052_ArngSCheck_Zt053_ArngSCheck,
    a_PREG_Pg1013_Noop,
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt2Check,
}
var Zt1_S__Zt2_S__Zt3_S___Pg___XnSP__cimm__MUL_VL_ = []operand{
    a_REGLIST3_Zt051_ArngSCheck_Zt052_ArngSCheck_Zt053_ArngSCheck,
    a_PREG_Pg1013_Noop,
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V3,
}
var Zt1_S__Zt2_S___Pg___XnSP__Xm__LSL_c2_ = []operand{
    a_REGLIST2_Zt051_ArngSCheck_Zt052_ArngSCheck,
    a_PREG_Pg1013_Noop,
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt2Check,
}
var Zt1_S__Zt2_S___Pg___XnSP__cimm__MUL_VL_ = []operand{
    a_REGLIST2_Zt051_ArngSCheck_Zt052_ArngSCheck,
    a_PREG_Pg1013_Noop,
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V6,
}
var Zt_B___Pg___XnSP__Xm_ = []operand{
    a_REGLIST1_Zt05_ArngBCheck,
    a_PREG_Pg1013_Noop,
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_NoModCheck_NoAmtCheck,
}
var Zt_B___Pg___XnSP__cimm__MUL_VL_ = []operand{
    a_REGLIST1_Zt05_ArngBCheck,
    a_PREG_Pg1013_Noop,
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V5,
}
var Zt_D___Pg___XnSP__Xm__LSL_c3_ = []operand{
    a_REGLIST1_Zt05_ArngDCheck,
    a_PREG_Pg1013_Noop,
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt3Check,
}
var Zt_D___Pg___XnSP__Zm_D_ = []operand{
    a_REGLIST1_Zt05_ArngDCheck,
    a_PREG_Pg1013_Noop,
    a_MEMEXT_Rn510SPV2_Noop_Zm1621V3_ArngDCheck_NoModCheck_NoAmtCheck,
}
var Zt_D___Pg___XnSP__Zm_D__LSL_c1_ = []operand{
    a_REGLIST1_Zt05_ArngDCheck,
    a_PREG_Pg1013_Noop,
    a_MEMEXT_Rn510SPV2_Noop_Zm1621V3_ArngDCheck_ModLSLCheck_ModAmt1Check,
}
var Zt_D___Pg___XnSP__Zm_D__LSL_c2_ = []operand{
    a_REGLIST1_Zt05_ArngDCheck,
    a_PREG_Pg1013_Noop,
    a_MEMEXT_Rn510SPV2_Noop_Zm1621V3_ArngDCheck_ModLSLCheck_ModAmt2Check,
}
var Zt_D___Pg___XnSP__Zm_D__LSL_c3_ = []operand{
    a_REGLIST1_Zt05_ArngDCheck,
    a_PREG_Pg1013_Noop,
    a_MEMEXT_Rn510SPV2_Noop_Zm1621V3_ArngDCheck_ModLSLCheck_ModAmt3Check,
}
var Zt_D___Pg___XnSP__Zm_D__mod_ = []operand{
    a_REGLIST1_Zt05_ArngDCheck,
    a_PREG_Pg1013_Noop,
    a_MEMEXT_Rn510SPV2_Noop_Zm1621V3_ArngDCheck_Xs1415_NoAmtCheck,
}
var Zt_D___Pg___XnSP__Zm_D__mod_c1_ = []operand{
    a_REGLIST1_Zt05_ArngDCheck,
    a_PREG_Pg1013_Noop,
    a_MEMEXT_Rn510SPV2_Noop_Zm1621V3_ArngDCheck_Xs1415_ModAmt1Check,
}
var Zt_D___Pg___XnSP__Zm_D__mod_c2_ = []operand{
    a_REGLIST1_Zt05_ArngDCheck,
    a_PREG_Pg1013_Noop,
    a_MEMEXT_Rn510SPV2_Noop_Zm1621V3_ArngDCheck_Xs1415_ModAmt2Check,
}
var Zt_D___Pg___XnSP__Zm_D__mod_c3_ = []operand{
    a_REGLIST1_Zt05_ArngDCheck,
    a_PREG_Pg1013_Noop,
    a_MEMEXT_Rn510SPV2_Noop_Zm1621V3_ArngDCheck_Xs1415_ModAmt3Check,
}
var Zt_D___Pg___XnSP__cimm__MUL_VL_ = []operand{
    a_REGLIST1_Zt05_ArngDCheck,
    a_PREG_Pg1013_Noop,
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V5,
}
var Zt_D___Pg___Zn_D__Xm_ = []operand{
    a_REGLIST1_Zt05_ArngDCheck,
    a_PREG_Pg1013_Noop,
    a_MEMEXT_Zn510V2_ArngDCheck_Rm1621XZR_Noop_NoModCheck_NoAmtCheck,
}
var Zt_D___Pg___Zn_D__cimm___1 = []operand{
    a_REGLIST1_Zt05_ArngDCheck,
    a_PREG_Pg1013_Noop,
    a_MEMOFF_Zn510V2_ArngDCheck_Imm51621V4,
}
var Zt_D___Pg___Zn_D__cimm___2 = []operand{
    a_REGLIST1_Zt05_ArngDCheck,
    a_PREG_Pg1013_Noop,
    a_MEMOFF_Zn510V2_ArngDCheck_Imm51621V3,
}
var Zt_D___Pg___Zn_D__cimm___3 = []operand{
    a_REGLIST1_Zt05_ArngDCheck,
    a_PREG_Pg1013_Noop,
    a_MEMOFF_Zn510V2_ArngDCheck_Imm51621V1,
}
var Zt_D___Pg___Zn_D__cimm___4 = []operand{
    a_REGLIST1_Zt05_ArngDCheck,
    a_PREG_Pg1013_Noop,
    a_MEMOFF_Zn510V2_ArngDCheck_Imm51621V2,
}
var Zt_H___Pg___XnSP__Xm__LSL_c1_ = []operand{
    a_REGLIST1_Zt05_ArngHCheck,
    a_PREG_Pg1013_Noop,
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt1Check,
}
var Zt_H___Pg___XnSP__cimm__MUL_VL_ = []operand{
    a_REGLIST1_Zt05_ArngHCheck,
    a_PREG_Pg1013_Noop,
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V5,
}
var Zt_Q___Pg___XnSP__Xm__LSL_c2_ = []operand{
    a_REGLIST1_Zt05_ArngQCheck,
    a_PREG_Pg1013_Noop,
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt2Check,
}
var Zt_Q___Pg___XnSP__Xm__LSL_c3_ = []operand{
    a_REGLIST1_Zt05_ArngQCheck,
    a_PREG_Pg1013_Noop,
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt3Check,
}
var Zt_Q___Pg___XnSP__cimm__MUL_VL_ = []operand{
    a_REGLIST1_Zt05_ArngQCheck,
    a_PREG_Pg1013_Noop,
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V5,
}
var Zt_Q___Pg___Zn_D__Xm_ = []operand{
    a_REGLIST1_Zt05_ArngQCheck,
    a_PREG_Pg1013_Noop,
    a_MEMEXT_Zn510V2_ArngDCheck_Rm1621XZR_Noop_NoModCheck_NoAmtCheck,
}
var Zt_S___Pg___XnSP__Xm__LSL_c2_ = []operand{
    a_REGLIST1_Zt05_ArngSCheck,
    a_PREG_Pg1013_Noop,
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt2Check,
}
var Zt_S___Pg___XnSP__Zm_S__mod_ = []operand{
    a_REGLIST1_Zt05_ArngSCheck,
    a_PREG_Pg1013_Noop,
    a_MEMEXT_Rn510SPV2_Noop_Zm1621V3_ArngSCheck_Xs1415_NoAmtCheck,
}
var Zt_S___Pg___XnSP__Zm_S__mod_c1_ = []operand{
    a_REGLIST1_Zt05_ArngSCheck,
    a_PREG_Pg1013_Noop,
    a_MEMEXT_Rn510SPV2_Noop_Zm1621V3_ArngSCheck_Xs1415_ModAmt1Check,
}
var Zt_S___Pg___XnSP__Zm_S__mod_c2_ = []operand{
    a_REGLIST1_Zt05_ArngSCheck,
    a_PREG_Pg1013_Noop,
    a_MEMEXT_Rn510SPV2_Noop_Zm1621V3_ArngSCheck_Xs1415_ModAmt2Check,
}
var Zt_S___Pg___XnSP__cimm__MUL_VL_ = []operand{
    a_REGLIST1_Zt05_ArngSCheck,
    a_PREG_Pg1013_Noop,
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V5,
}
var Zt_S___Pg___Zn_S__Xm_ = []operand{
    a_REGLIST1_Zt05_ArngSCheck,
    a_PREG_Pg1013_Noop,
    a_MEMEXT_Zn510V2_ArngSCheck_Rm1621XZR_Noop_NoModCheck_NoAmtCheck,
}
var Zt_S___Pg___Zn_S__cimm___1 = []operand{
    a_REGLIST1_Zt05_ArngSCheck,
    a_PREG_Pg1013_Noop,
    a_MEMOFF_Zn510V2_ArngSCheck_Imm51621V4,
}
var Zt_S___Pg___Zn_S__cimm___2 = []operand{
    a_REGLIST1_Zt05_ArngSCheck,
    a_PREG_Pg1013_Noop,
    a_MEMOFF_Zn510V2_ArngSCheck_Imm51621V1,
}
var Zt_S___Pg___Zn_S__cimm___3 = []operand{
    a_REGLIST1_Zt05_ArngSCheck,
    a_PREG_Pg1013_Noop,
    a_MEMOFF_Zn510V2_ArngSCheck_Imm51621V2,
}
var Zt_T___Pg___XnSP__Xm_ = []operand{
    a_REGLIST1_Zt05_Size2123V1,
    a_PREG_Pg1013_Noop,
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_NoModCheck_NoAmtCheck,
}
var Zt_T___Pg___XnSP__Xm__LSL_c1_ = []operand{
    a_REGLIST1_Zt05_Size2123V2,
    a_PREG_Pg1013_Noop,
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt1Check,
}
var Zt_T___Pg___XnSP__Xm__LSL_c2_ = []operand{
    a_REGLIST1_Zt05_Sz2122,
    a_PREG_Pg1013_Noop,
    a_MEMEXT_Rn510SPV2_Noop_Rm1621V2_Noop_ModLSLCheck_ModAmt2Check,
}
var Zt_T___Pg___XnSP__cimm__MUL_VL___1 = []operand{
    a_REGLIST1_Zt05_Size2123V1,
    a_PREG_Pg1013_Noop,
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V5,
}
var Zt_T___Pg___XnSP__cimm__MUL_VL___2 = []operand{
    a_REGLIST1_Zt05_Size2123V2,
    a_PREG_Pg1013_Noop,
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V5,
}
var Zt_T___Pg___XnSP__cimm__MUL_VL___3 = []operand{
    a_REGLIST1_Zt05_Sz2122,
    a_PREG_Pg1013_Noop,
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm41620V5,
}
var Zt___XnSP__cimm__MUL_VL_ = []operand{
    a_ZREG_Zt05_Noop,
    a_MEMOFFMULVL_Rn510SPV2_Noop_Imm9h1622L1013,
}

func ADR 

func ADR(p uint32, o uint32, rt uint32) uint32

func ASIMDALL 

func ASIMDALL(u, size, opcode uint32) uint32

func ASIMDDIFF 

func ASIMDDIFF(u, opcode uint32) uint32

func ASIMDMISC 

func ASIMDMISC(u, size, opcode uint32) uint32

func ASIMDPERM 

func ASIMDPERM(opcode uint32) uint32

func ASIMDSAME 

func ASIMDSAME(u, size, opcode uint32) uint32

func ASIMDSHF 

func ASIMDSHF(u, opcode uint32) uint32

func DRconv 

func DRconv(a int) string

func EncodeRegisterExtension 

func EncodeRegisterExtension(a *obj.Addr, ext string, reg, num int16, isAmount, isIndex bool) error

EncodeRegisterExtension constructs an ARM64 register with extension or arrangement in the argument a.

func FPCCMP 

func FPCCMP(m uint32, s uint32, type_ uint32, op uint32) uint32

func FPCMP 

func FPCMP(m uint32, s uint32, type_ uint32, op uint32, op2 uint32) uint32

func FPCVTI 

func FPCVTI(sf uint32, s uint32, type_ uint32, rmode uint32, op uint32) uint32

func FPOP1S 

func FPOP1S(m uint32, s uint32, type_ uint32, op uint32) uint32

func FPOP2S 

func FPOP2S(m uint32, s uint32, type_ uint32, op uint32) uint32

func FPOP3S 

func FPOP3S(m uint32, s uint32, type_ uint32, op uint32, op2 uint32) uint32

func IsAtomicInstruction 

func IsAtomicInstruction(as obj.As) bool

func LD2STR 

func LD2STR(o uint32) uint32

func LDSTR 

func LDSTR(sz uint32, v uint32, opc uint32) uint32

func LDSTX 

func LDSTX(sz uint32, o2 uint32, l uint32, o1 uint32, o0 uint32) uint32

func MOVCONST 

func MOVCONST(d int64, s int, rt int) uint32

func OPBIT 

func OPBIT(x uint32) uint32

func OPBLR 

func OPBLR(x uint32) uint32

func OPBcc 

func OPBcc(x uint32) uint32

func OPDP2 

func OPDP2(x uint32) uint32

func OPDP3 

func OPDP3(sf uint32, op54 uint32, op31 uint32, o0 uint32) uint32

func RegisterArrangement 

func RegisterArrangement(reg int16, arng int16, isIndex bool) (int16, error)

RegisterArrangement encodes specified simd register number and arrangement.

func RegisterListOffset 

func RegisterListOffset(firstReg, regCnt int, arrangement int64, scale int16) (int64, error)

RegisterListOffset generates offset encoding according to AArch64 specification.

func SPCconv 

func SPCconv(a int64) string

func SYSARG4 

func SYSARG4(op1 int, Cn int, Cm int, op2 int) int

func SYSARG5 

func SYSARG5(op0 int, op1 int, Cn int, Cm int, op2 int) int

form offset parameter to SYS; special register number

func SYSHINT 

func SYSHINT(x uint32) uint32

func SYSOP 

func SYSOP(l uint32, op0 uint32, op1 uint32, crn uint32, crm uint32, op2 uint32, rt uint32) uint32

func SysRegEnc 

func SysRegEnc(r int16) (string, uint32, uint8)

type AClass 

type AClass uint16 // operand type

[insts] is sorted based on the order of these constants and the first match is chosen. 

const (
    AC_NONE AClass = iota
    // TODO: probably make this AClass split into AC_REG (R0...R30), AC_RSP (R0...R30, RSP), AC_ZR (R0...R30, ZR).
    AC_SPZGREG // general purpose registers R0..R30 and RSP and ZR
    AC_VREG    // vector registers, such as V1
    AC_ZREG    // the scalable vector registers, such as Z1
    AC_PREG    // the scalable predicate registers, such as P1
    AC_PREGZM  // Pg.Z or Pg.M
    AC_PREGIDX // P8[1] or PN1[1] or Z1[1]
    AC_ZREGIDX // P8[1] or PN1[1] or Z1[1]
    AC_PREGSEL // P0[R1, 1], index is calculated as R1 + 1
    AC_ARNG    // vector register with arrangement, such as Z1.D
    AC_ARNGIDX // vector register with arrangement and index, such as Z1.D[1]

    AC_IMM // constants

    AC_REGLIST1      // list of 1 vector register, such as [Z1]
    AC_REGLIST2      // list of 2 vector registers, such as [Z0, Z8]
    AC_REGLIST3      // list of 3 vector registers, such as [Z1, Z2, Z3]
    AC_REGLIST4      // list of 4 vector registers, such as [Z0, Z4, Z8, Z12]
    AC_REGLIST_RANGE // list of vector register lists in range format, such as [Z0-Z4].

    AC_MEMOFF      // address with optional constant offset, the offset is an immediate, such as 4(Z1.D)
    AC_MEMOFFMULVL // address with optional constant offset, the offset is an immediate multiplied by the vector's in-memory size, such as (2*VL)(Z1.D)
    AC_MEMEXT      // address with register offset with extensions, such as (Z2.D.UXTW<<3)(RSP)

    AC_PREG_PATTERN // register with pattern, such as VL1*3(P1.D)
    AC_REG_PATTERN  // register with pattern, such as VL1*3(R1)
    AC_ZREG_PATTERN // register with pattern, such as VL1*3(Z1.D)

    AC_SPECIAL // VL*i pattern, one of: VL*2, VL*4, or prefetch pattern, such as PLDL1KEEP, more patterns might come in the future.
)

type Optab 

type Optab struct {
    // contains filtered or unexported fields
}

type SpecialOperand 

type SpecialOperand int
const (
    // PRFM
    SPOP_PLDL1KEEP SpecialOperand = obj.SpecialOperandARM64Base + iota     // must be the first one
    SPOP_BEGIN     SpecialOperand = obj.SpecialOperandARM64Base + iota - 1 // set as the lower bound
    SPOP_PLDL1STRM
    SPOP_PLDL2KEEP
    SPOP_PLDL2STRM
    SPOP_PLDL3KEEP
    SPOP_PLDL3STRM
    SPOP_PLIL1KEEP
    SPOP_PLIL1STRM
    SPOP_PLIL2KEEP
    SPOP_PLIL2STRM
    SPOP_PLIL3KEEP
    SPOP_PLIL3STRM
    SPOP_PSTL1KEEP
    SPOP_PSTL1STRM
    SPOP_PSTL2KEEP
    SPOP_PSTL2STRM
    SPOP_PSTL3KEEP
    SPOP_PSTL3STRM

    // VL
    SPOP_VLx2
    SPOP_VLx4

    // TLBI
    SPOP_VMALLE1IS
    SPOP_VAE1IS
    SPOP_ASIDE1IS
    SPOP_VAAE1IS
    SPOP_VALE1IS
    SPOP_VAALE1IS
    SPOP_VMALLE1
    SPOP_VAE1
    SPOP_ASIDE1
    SPOP_VAAE1
    SPOP_VALE1
    SPOP_VAALE1
    SPOP_IPAS2E1IS
    SPOP_IPAS2LE1IS
    SPOP_ALLE2IS
    SPOP_VAE2IS
    SPOP_ALLE1IS
    SPOP_VALE2IS
    SPOP_VMALLS12E1IS
    SPOP_IPAS2E1
    SPOP_IPAS2LE1
    SPOP_ALLE2
    SPOP_VAE2
    SPOP_ALLE1
    SPOP_VALE2
    SPOP_VMALLS12E1
    SPOP_ALLE3IS
    SPOP_VAE3IS
    SPOP_VALE3IS
    SPOP_ALLE3
    SPOP_VAE3
    SPOP_VALE3
    SPOP_VMALLE1OS
    SPOP_VAE1OS
    SPOP_ASIDE1OS
    SPOP_VAAE1OS
    SPOP_VALE1OS
    SPOP_VAALE1OS
    SPOP_RVAE1IS
    SPOP_RVAAE1IS
    SPOP_RVALE1IS
    SPOP_RVAALE1IS
    SPOP_RVAE1OS
    SPOP_RVAAE1OS
    SPOP_RVALE1OS
    SPOP_RVAALE1OS
    SPOP_RVAE1
    SPOP_RVAAE1
    SPOP_RVALE1
    SPOP_RVAALE1
    SPOP_RIPAS2E1IS
    SPOP_RIPAS2LE1IS
    SPOP_ALLE2OS
    SPOP_VAE2OS
    SPOP_ALLE1OS
    SPOP_VALE2OS
    SPOP_VMALLS12E1OS
    SPOP_RVAE2IS
    SPOP_RVALE2IS
    SPOP_IPAS2E1OS
    SPOP_RIPAS2E1
    SPOP_RIPAS2E1OS
    SPOP_IPAS2LE1OS
    SPOP_RIPAS2LE1
    SPOP_RIPAS2LE1OS
    SPOP_RVAE2OS
    SPOP_RVALE2OS
    SPOP_RVAE2
    SPOP_RVALE2
    SPOP_ALLE3OS
    SPOP_VAE3OS
    SPOP_VALE3OS
    SPOP_RVAE3IS
    SPOP_RVALE3IS
    SPOP_RVAE3OS
    SPOP_RVALE3OS
    SPOP_RVAE3
    SPOP_RVALE3

    // DC
    SPOP_IVAC
    SPOP_ISW
    SPOP_CSW
    SPOP_CISW
    SPOP_ZVA
    SPOP_CVAC
    SPOP_CVAU
    SPOP_CIVAC
    SPOP_IGVAC
    SPOP_IGSW
    SPOP_IGDVAC
    SPOP_IGDSW
    SPOP_CGSW
    SPOP_CGDSW
    SPOP_CIGSW
    SPOP_CIGDSW
    SPOP_GVA
    SPOP_GZVA
    SPOP_CGVAC
    SPOP_CGDVAC
    SPOP_CGVAP
    SPOP_CGDVAP
    SPOP_CGVADP
    SPOP_CGDVADP
    SPOP_CIGVAC
    SPOP_CIGDVAC
    SPOP_CVAP
    SPOP_CVADP

    // PSTATE fields
    SPOP_DAIFSet
    SPOP_DAIFClr

    // Condition code, EQ, NE, etc. Their relative order to EQ matters.
    SPOP_EQ
    SPOP_NE
    SPOP_HS
    SPOP_LO
    SPOP_MI
    SPOP_PL
    SPOP_VS
    SPOP_VC
    SPOP_HI
    SPOP_LS
    SPOP_GE
    SPOP_LT
    SPOP_GT
    SPOP_LE
    SPOP_AL
    SPOP_NV

    // Branch Target Indicator (BTI) targets
    SPOP_C
    SPOP_J
    SPOP_JC

    // Range PReFetch of Memory (RPRFM)
    SPOP_PLDKEEP
    SPOP_PSTKEEP
    SPOP_PLDSTRM
    SPOP_PSTSTRM

    SPOP_END
)

func (SpecialOperand) String 

func (i SpecialOperand) String() string
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.