package core:rexcode/isa/arm32

⌘K
Ctrl+K
or
/

    Overview

    rexcode · Brendan Punsky (dotbmp@github), original author

    rexcode · Brendan Punsky (dotbmp@github), original author

    rexcode · Brendan Punsky (dotbmp@github), original author

    rexcode · Brendan Punsky (dotbmp@github), original author

    rexcode · Brendan Punsky (dotbmp@github), original author

    rexcode · Brendan Punsky (dotbmp@github), original author

    rexcode · Brendan Punsky (dotbmp@github), original author

    rexcode · Brendan Punsky (dotbmp@github), original author

    rexcode · Brendan Punsky (dotbmp@github), original author

    rexcode · Brendan Punsky (dotbmp@github), original author

    rexcode · Brendan Punsky (dotbmp@github), original author

    rexcode · Brendan Punsky (dotbmp@github), original author

    Index

    Constants (168)
    Procedures (2687)

    Types

    Decode_Entry ¶

    Decode_Entry :: struct #packed {
    	mnemonic: Mnemonic,
    	// 2
    	ops:      [4]Operand_Type,
    	// 4
    	enc:      [4]Operand_Encoding,
    	// 4
    	bits:     u32,
    	// 4
    	mask:     u32,
    	// 4
    	feature:  Feature,
    	// 1
    	mode:     Mode,
    	// 1
    	flags:    Encoding_Flags,
    }

    Decode_Index ¶

    Decode_Index :: struct #packed {
    	start: u16,
    	count: u16,
    }

    Encode_Run ¶

    Encode_Run :: struct {
    	start: u32,
    	count: u32,
    }
     

    Companion run index: ENCODE_RUNS[mnemonic] -> contiguous run in ENCODE_FORMS.

    Encoding ¶

    Encoding :: struct #packed {
    	mnemonic: Mnemonic,
    	// 2
    	ops:      [4]Operand_Type,
    	// 4
    	enc:      [4]Operand_Encoding,
    	// 4
    	bits:     u32,
    	// 4
    	mask:     u32,
    	// 4
    	feature:  Feature,
    	// 1
    	mode:     Mode,
    	// 1
    	flags:    Encoding_Flags,
    }

    Encoding_Flags ¶

    Encoding_Flags :: distinct bit_field u8 {
    	sets_flags:  bool | 1,
    	cond_in_28:  bool | 1,
    	branch:      bool | 1,
    	cond_branch: bool | 1,
    	writes_pc:   bool | 1,
    	thumb32:     bool | 1,
    	deprecated:  bool | 1,
    	_:           u8 | 1,
    }
    Related Procedures With Returns

    Error ¶

    Error :: rexcode_isa.Error

    Error_Code ¶

    Error_Code :: rexcode_isa.Error_Code

    Feature ¶

    Feature :: enum u8 {
    	BASE,         // ARMv4 base ISA (works on every ARM core including ARM7TDMI / GBA)
    	THUMB,        // Thumb-1 (ARMv4T+)
    	V5T,          // ARMv5T additions (BLX, CLZ, BKPT)
    	V5TE,         // ARMv5TE DSP extensions (SMLAxy / SMULxy / etc.)
    	V5TEJ,        // ARMv5TEJ (BXJ; Jazelle support)
    	V6,           // ARMv6 SIMD-on-GPR + REV/SXTB/etc.
    	V6K,          // ARMv6K (CLREX, multiprocessing hints)
    	V6T2,         // ARMv6T2 (Thumb-2, MOVW/MOVT, bitfield)
    	V7,           // ARMv7-A/R base (DMB/DSB/ISB, LDREX/STREX full set)
    	V7VE,         // ARMv7-A Virtualisation Extensions (HVC, ERET)
    	V8,           // ARMv8-A AArch32 (HLT, SEVL, MVN nzcvqg)
    	DIV,          // SDIV/UDIV (ARMv7-A optional, ARMv7-R/M mandatory)
    	VFPV2,        // VFP version 2 (double-precision FP)
    	VFPV3,        // VFP version 3 (D32, VCVTB/T half-prec)
    	VFPV4,        // VFP version 4 (VFMA family)
    	HALF_FP,      // FP16 storage support
    	NEON,         // Advanced SIMD
    	NEON_HALF_FP, // FP16 NEON arithmetic
    	CRYPTO,       // ARMv8 crypto (AES + SHA1 + SHA2)
    	CRC32,        // ARMv8 CRC32B/H/W + CRC32CB/H/W
    	DOT,          // ARMv8.2 dot product (VSDOT/VUDOT)
    	BF16,         // ARMv8.6 BFloat16
    	FCMA,         // ARMv8.3 complex number (VCMLA/VCADD)
    	FHM,          // ARMv8.2 FP16 multiply-acc-long
    	// ---- M-profile ARMv8-M extensions ----
    	V8M,          // ARMv8-M baseline (Cortex-M23, M33, M55, M85)
    	V8M_SE,       // ARMv8-M Security Extensions (TT/TTT/TTA/TTAT)
    	V81M,         // ARMv8.1-M mainline (low-overhead loops, MVE)
    	MVE_INT,      // M-profile Vector Extension (Helium) integer (Cortex-M55+)
    	MVE_FP,       // M-profile Vector Extension floating-point
    	CDE,          // Custom Datapath Extension (Cortex-M33+)
    }

    Index_Mode ¶

    Index_Mode :: enum u8 {
    	OFFSET     = 0, // [Rn, #imm]      -- no writeback
    	PRE_INDEX  = 1, // [Rn, #imm]!     -- writeback after addr calc
    	POST_INDEX = 2, // [Rn], #imm      -- writeback, base = Rn pre-update
    }

    Instruction ¶

    Instruction :: struct #packed {
    	ops:           [4]Operand `fmt:"v,operand_count"`,
    	// 4 * 18 = 68
    	mnemonic:      Mnemonic,
    	// 2
    	cond:          u8,
    	// 0..15 (AL=14)
    	operand_count: u8,
    	// 0..4
    	flags:         Instruction_Flags,
    	// 1
    	mode:          Mode,
    	// 1 (A32 or T32)
    	length:        u8,
    	// Form-id hint: when non-zero, this is (1 + the index into
    	// ENCODING_TABLE[mnemonic]) of the form the decoder produced. The encoder
    	// uses it as a tie-breaker for shape-ambiguous entries (NEON size variants
    	// share an operand shape but live in distinct entries with different fixed
    	// bits). User-constructed instructions leave it at 0; the encoder then
    	// falls back to first-shape-match. Stored as u16 over the two padding bytes.
    	form_id:       u16,
    	_:             [7]u8,
    }
    Related Procedures With Parameters
    Related Procedures With Returns

    Instruction_Flags ¶

    Instruction_Flags :: distinct bit_field u8 {
    	sets_flags: bool | 1,
    	wide:       bool | 1,
    	_:          u8 | 6,
    }

    Instruction_Info ¶

    Instruction_Info :: struct {
    	offset:       u32,
    	decode_entry: u16,
    	_:            u16,
    }

    Label_Definition ¶

    Label_Definition :: rexcode_isa.Label_Definition
    Related Constants

    Label_Map ¶

    Label_Map :: rexcode_isa.Label_Map

    Memory ¶

    Memory :: struct #packed {
    	base:       Register,
    	// GPR base register
    	index:      Register,
    	// GPR or .NONE for imm-only forms
    	shift_type: Shift_Type,
    	shift_amt:  u8,
    	// 0..31 immediate shift
    	mode:       Index_Mode,
    	sign:       i8,
    	disp:       i32,
    }
    Related Procedures With Parameters
    Related Procedures With Returns

    Mnemonic ¶

    Mnemonic :: enum u16 {
    	INVALID       = 0, 
    	// -------------------------------------------------------------------------
    	// Data processing -- core 16 ops (A32 + T32)
    	// -------------------------------------------------------------------------
    	AND, 
    	EOR, 
    	SUB, 
    	RSB, 
    	ADD, 
    	ADC, 
    	SBC, 
    	RSC, 
    	TST, 
    	TEQ, 
    	CMP, 
    	CMN, 
    	ORR, 
    	MOV, 
    	BIC, 
    	MVN, 
    	// Shift mnemonics (in A32 these are MOV aliases with shift, but in Thumb
    	// they are first-class encodings, so they have their own Mnemonic entries)
    	LSL, 
    	LSR, 
    	ASR, 
    	ROR, 
    	RRX, 
    	// Thumb-1 specific: ADR is an alias for ADD Rd, PC, #imm  (also exists in
    	// A32 as an ADD/SUB imm to PC alias)
    	ADR, 
    	NEG,               // Thumb-1 only: NEG Rd, Rm = RSB Rd, Rm, #0
    	// ARMv6T2: 16-bit immediate moves
    	MOVW,              // MOV with 16-bit immediate (low half)
    	MOVT,              // MOV-Top (high half, preserves low)
    	// ARMv6T2: bit field manipulation
    	BFC, 
    	BFI, 
    	SBFX, 
    	UBFX, 
    	// ARMv6: register operand sign/zero extends with optional rotation
    	SXTB, 
    	SXTB16, 
    	SXTH, 
    	UXTB, 
    	UXTB16, 
    	UXTH, 
    	SXTAB, 
    	SXTAB16, 
    	SXTAH, 
    	UXTAB, 
    	UXTAB16, 
    	UXTAH, 
    	// ARMv6: bit reverse / byte swap / count leading zeros
    	CLZ, 
    	RBIT, 
    	REV, 
    	REV16, 
    	REVSH, 
    	SEL,               // select bytes per APSR.GE flags
    	// ARMv6T2/v7: PKHBT/PKHTB (pack halfword)
    	PKHBT, 
    	PKHTB, 
    	// ARMv6: USAD8 (sum of absolute differences)
    	USAD8, 
    	USADA8, 
    	// ARMv6: saturating arithmetic
    	SSAT, 
    	USAT, 
    	SSAT16, 
    	USAT16, 
    	QADD, 
    	QSUB, 
    	QDADD, 
    	QDSUB, 
    	// ARMv6: SIMD on GPRs (8/16-bit lanes packed in 32-bit reg)
    	SADD8, 
    	SADD16, 
    	SASX, 
    	SSAX, 
    	SSUB8, 
    	SSUB16, 
    	UADD8, 
    	UADD16, 
    	UASX, 
    	USAX, 
    	USUB8, 
    	USUB16, 
    	QADD8, 
    	QADD16, 
    	QASX, 
    	QSAX, 
    	QSUB8, 
    	QSUB16, 
    	UQADD8, 
    	UQADD16, 
    	UQASX, 
    	UQSAX, 
    	UQSUB8, 
    	UQSUB16, 
    	SHADD8, 
    	SHADD16, 
    	SHASX, 
    	SHSAX, 
    	SHSUB8, 
    	SHSUB16, 
    	UHADD8, 
    	UHADD16, 
    	UHASX, 
    	UHSAX, 
    	UHSUB8, 
    	UHSUB16, 
    	// ARMv6: dual multiply-accumulate
    	SMUAD, 
    	SMUADX, 
    	SMUSD, 
    	SMUSDX, 
    	SMLAD, 
    	SMLADX, 
    	SMLSD, 
    	SMLSDX, 
    	SMLALD, 
    	SMLALDX, 
    	SMLSLD, 
    	SMLSLDX, 
    	// Most-significant-word multiply
    	SMMUL, 
    	SMMULR, 
    	SMMLA, 
    	SMMLAR, 
    	SMMLS, 
    	SMMLSR, 
    	// Multiply / multiply-accumulate (ARMv4+ core)
    	MUL, 
    	MLA, 
    	MLS,               // ARMv6T2: multiply-subtract
    	UMULL, 
    	UMLAL, 
    	SMULL, 
    	SMLAL, 
    	UMAAL,             // ARMv6: unsigned long multiply-acc-acc
    	// Halfword multiply (ARMv5TE / ARMv6 DSP):
    	//   SMLA{x}{y}, SMLAW{y}, SMUL{x}{y}, SMULW{y}, SMLAL{x}{y}
    	SMLABB, 
    	SMLABT, 
    	SMLATB, 
    	SMLATT, 
    	SMLAWB, 
    	SMLAWT, 
    	SMULBB, 
    	SMULBT, 
    	SMULTB, 
    	SMULTT, 
    	SMULWB, 
    	SMULWT, 
    	SMLALBB, 
    	SMLALBT, 
    	SMLALTB, 
    	SMLALTT, 
    	// Integer division (ARMv7-A optional, ARMv7-R/M mandatory; v7VE adds A-profile)
    	SDIV, 
    	UDIV, 
    	// -------------------------------------------------------------------------
    	// Branches
    	// -------------------------------------------------------------------------
    	B,                 // signed 24/26-bit branch
    	BL,                // branch + link
    	BX,                // branch and exchange (to ARM/Thumb)
    	BLX,               // branch+link+exchange (reg or imm)
    	BXJ,               // branch and exchange to Jazelle (deprecated)
    	// ARMv6T2+: compare and branch (Thumb-only)
    	CBZ, 
    	CBNZ, 
    	// ARMv6T2+: table branch (Thumb-only)
    	TBB, 
    	TBH, 
    	// -------------------------------------------------------------------------
    	// Status register access / hint instructions
    	// -------------------------------------------------------------------------
    	MSR, 
    	MRS, 
    	CPS,               // change processor state
    	SETEND,            // set endianness (deprecated in v8)
    	NOP, 
    	YIELD, 
    	WFE, 
    	WFI, 
    	SEV, 
    	SEVL,              // ARMv8: sev local
    	DBG, 
    	HINT,              // generic hint with imm
    	DMB, 
    	DSB, 
    	ISB,               // ARMv7 barriers
    	CLREX,             // clear exclusive monitor
    	PLD, 
    	PLDW, 
    	PLI,               // preload
    	// ARMv8 AArch32 additions
    	HLT,               // halt instruction (debug)
    	DCPS1, 
    	DCPS2, 
    	DCPS3,             // debug change processor state
    	ERET,              // exception return (PL2+)
    	// ARMv8 security/profiling/trace barriers (FEAT_RAS, FEAT_SB, FEAT_SPE, FEAT_TRF)
    	ESB,               // error synchronization barrier (HINT #16)
    	PSB_CSYNC,         // profile sync barrier (HINT #17)
    	TSB_CSYNC,         // trace sync barrier (HINT #18)
    	CSDB,              // consumption of speculative data barrier (HINT #20)
    	SB,                // synchronization barrier (ARMv8.5, dedicated encoding)
    	// ARMv8.1 PAN (Privileged Access Never) bit toggle
    	SETPAN, 
    	// -------------------------------------------------------------------------
    	// Exception generation
    	// -------------------------------------------------------------------------
    	SVC,               // supervisor call (was SWI)
    	BKPT,              // breakpoint
    	HVC,               // hypervisor call (ARMv7VE)
    	SMC,               // secure monitor call (TrustZone)
    	UDF,               // permanently undefined
    	// -------------------------------------------------------------------------
    	// Load / Store
    	// -------------------------------------------------------------------------
    	LDR, 
    	STR,               // word
    	LDRB, 
    	STRB,              // byte
    	LDRH, 
    	STRH,              // halfword
    	LDRSB, 
    	LDRSH,             // signed loads
    	LDRD, 
    	STRD,              // doubleword (Rt/Rt+1 pair)
    	LDRT, 
    	STRT,              // user-mode (privileged-mode pretend)
    	LDRBT, 
    	STRBT, 
    	LDRHT, 
    	STRHT, 
    	LDRSBT, 
    	LDRSHT, 
    	// ARMv6+ acquire/release
    	LDA, 
    	STL,               // word acquire/release
    	LDAB, 
    	STLB,              // byte
    	LDAH, 
    	STLH,              // halfword
    	// ARMv6 exclusive load/store
    	LDREX, 
    	STREX, 
    	LDREXB, 
    	STREXB, 
    	LDREXH, 
    	STREXH, 
    	LDREXD, 
    	STREXD, 
    	LDAEX, 
    	STLEX,             // ARMv8 acquire/release exclusive
    	LDAEXB, 
    	STLEXB, 
    	LDAEXH, 
    	STLEXH, 
    	LDAEXD, 
    	STLEXD, 
    	// Block move
    	LDM, 
    	STM,               // base mnemonic w/ IA/IB/DA/DB suffix flag
    	// Stack convenience aliases
    	PUSH, 
    	POP, 
    	// Swap (deprecated since ARMv6 but still encoded)
    	SWP, 
    	SWPB, 
    	// -------------------------------------------------------------------------
    	// ARMv6 / Return-from-Exception
    	// -------------------------------------------------------------------------
    	RFE,               // return from exception
    	SRS,               // store return state
    	// -------------------------------------------------------------------------
    	// Coprocessor (legacy CP-space; many subsumed by VFP/NEON)
    	// -------------------------------------------------------------------------
    	CDP, 
    	CDP2, 
    	MCR, 
    	MCR2, 
    	MRC, 
    	MRC2, 
    	MCRR, 
    	MCRR2, 
    	MRRC, 
    	MRRC2, 
    	LDC, 
    	LDC2, 
    	STC, 
    	STC2, 
    	// -------------------------------------------------------------------------
    	// ARMv8 AArch32 CRC32 (FEAT_CRC32)
    	// -------------------------------------------------------------------------
    	CRC32B, 
    	CRC32H, 
    	CRC32W, 
    	CRC32CB, 
    	CRC32CH, 
    	CRC32CW, 
    	// -------------------------------------------------------------------------
    	// VFP / Advanced SIMD shared opcodes
    	// -------------------------------------------------------------------------
    	// -- Scalar FP arithmetic (operates on S<n>, D<n>) -------------------------
    	VADD, 
    	VSUB, 
    	VMUL, 
    	VDIV, 
    	VMLA, 
    	VMLS, 
    	VNMUL, 
    	VNMLA, 
    	VNMLS, 
    	VFMA, 
    	VFMS, 
    	VFNMA, 
    	VFNMS, 
    	VABS, 
    	VNEG, 
    	VSQRT, 
    	VCMP, 
    	VCMPE, 
    	VCVT,              // cross-format conversion (encoded via cmode bits)
    	VCVTB, 
    	VCVTT,             // half-precision conversion (bottom/top lane)
    	VCVTA, 
    	VCVTN, 
    	VCVTP, 
    	VCVTM,             // ARMv8: rounding-mode FP-to-int
    	VCVTR,             // FP-to-int using FPSCR rounding
    	VMOV,              // many forms (reg-reg, reg-imm, GPR-FPR)
    	VMRS, 
    	VMSR,              // FPSCR/coprocessor access
    	VLDR, 
    	VSTR, 
    	VLDM, 
    	VSTM, 
    	VPUSH, 
    	VPOP, 
    	VSEL,              // ARMv8 conditional select
    	VMAXNM, 
    	VMINNM,            // ARMv8 IEEE 754-2008 min/max
    	VRINTA, 
    	VRINTN, 
    	VRINTP, 
    	VRINTM,            // ARMv8 round-to-int by mode
    	VRINTR, 
    	VRINTZ, 
    	VRINTX,            // round to int per current/zero/exact
    	// -- NEON-specific (vector D/Q reg) -----------------------------------------
    	VADDL, 
    	VADDW, 
    	VSUBL, 
    	VSUBW, 
    	VHADD, 
    	VHSUB, 
    	VRHADD, 
    	VQADD, 
    	VQSUB, 
    	VMULL, 
    	VMLAL, 
    	VMLSL, 
    	VQDMULL, 
    	VQDMLAL, 
    	VQDMLSL, 
    	VQDMULH, 
    	VQRDMULH, 
    	VQDMULH_LANE, 
    	VQRDMULH_LANE,     // indexed variants
    	// ARMv8.1 FEAT_RDM: rounding doubling multiply-accumulate
    	VQRDMLAH, 
    	VQRDMLSH, 
    	VABA, 
    	VABAL, 
    	VABD, 
    	VABDL, 
    	VAND, 
    	VBIC, 
    	VORR, 
    	VORN, 
    	VEOR, 
    	VBSL, 
    	VBIT, 
    	VBIF, 
    	VMVN, 
    	VMOVN, 
    	VQMOVN, 
    	VQMOVUN, 
    	VMOVL,             // extend halve-width to full-width
    	VTST, 
    	VCEQ, 
    	VCGE, 
    	VCGT, 
    	VCLE, 
    	VCLT, 
    	VACGE, 
    	VACGT,             // absolute compare for FP
    	VACLE, 
    	VACLT, 
    	VMAX, 
    	VMIN, 
    	VPMAX, 
    	VPMIN, 
    	VPADD, 
    	VPADDL, 
    	VPADAL, 
    	VRECPE, 
    	VRECPS,            // reciprocal estimate / step
    	VRSQRTE, 
    	VRSQRTS, 
    	VSHL, 
    	VSHR, 
    	VSRA, 
    	VRSHL, 
    	VRSHR, 
    	VRSRA, 
    	VSLI, 
    	VSRI, 
    	VQSHL, 
    	VQSHRN, 
    	VQSHRUN, 
    	VQRSHL, 
    	VQRSHRN, 
    	VQRSHRUN, 
    	VSHRN, 
    	VRSHRN, 
    	VSHLL,             // shift-left long
    	VCLS, 
    	VCLZ, 
    	VCNT, 
    	VPADD_F, 
    	VRECPE_F, 
    	VRSQRTE_F,         // (placeholders; canonical via operand types)
    	VREV16, 
    	VREV32, 
    	VREV64, 
    	VEXT,              // vector extract
    	VTBL, 
    	VTBX,              // table lookup
    	VTRN, 
    	VUZP, 
    	VZIP, 
    	VDUP,              // duplicate scalar to vector
    	VSWP,              // swap
    	// Lane access
    	VMOV_LANE,         // VMOV.<dt> R, D[i] / VMOV.<dt> D[i], R
    	// Load/Store structures (NEON)
    	VLD1, 
    	VLD2, 
    	VLD3, 
    	VLD4, 
    	VST1, 
    	VST2, 
    	VST3, 
    	VST4, 
    	// -- Advanced SIMD / NEON crypto (ARMv8 AArch32 FEAT_AES + FEAT_SHA1/2) ---
    	AESE, 
    	AESD, 
    	AESMC, 
    	AESIMC, 
    	SHA1H, 
    	SHA1SU0, 
    	SHA1SU1, 
    	SHA1C, 
    	SHA1M, 
    	SHA1P, 
    	SHA256H, 
    	SHA256H2, 
    	SHA256SU0, 
    	SHA256SU1, 
    	// -- VFP rounding (ARMv8 FEAT_FP) ----------------------------------------
    	VJCVT,             // VJCVT: F64-to-S32 with FPSCR.RM rounding
    	// -- Dot Product (FEAT_DotProd) ------------------------------------------
    	VSDOT, 
    	VUDOT, 
    	VSDOT_LANE, 
    	VUDOT_LANE, 
    	// -- BF16 (FEAT_BF16) ----------------------------------------------------
    	VCVT_BF16,         // BF16<->F32
    	VDOT_BF16, 
    	VFMA_BF16, 
    	VMMLA_BF16, 
    	// -- FHM (FEAT_FHM) FP16 matrix mul/acc ----------------------------------
    	VFMAL, 
    	VFMSL,             // F16 fused multiply-add long
    	// -- ComplexNum (FEAT_FCMA) ----------------------------------------------
    	VCMLA, 
    	VCADD, 
    	VCMLA_LANE,        // VCMLA by indexed scalar
    	// -- I8MM (FEAT_I8MM, ARMv8.6) integer matrix multiply + mixed-sign dot --
    	VSMMLA,            // signed-signed 8x8 matrix mul
    	VUMMLA,            // unsigned-unsigned
    	VUSMMLA,           // unsigned-signed
    	VSUDOT,            // signed-unsigned dot product
    	VUSDOT,            // unsigned-signed dot product
    	VSUDOT_LANE, 
    	VUSDOT_LANE, 
    	// -- Lane-indexed NEON multiply / MAC forms (heavily used in DSP/codec) --
    	VMUL_LANE, 
    	VMLA_LANE, 
    	VMLS_LANE, 
    	VMULL_LANE, 
    	VMLAL_LANE, 
    	VMLSL_LANE, 
    	VQDMULL_LANE, 
    	VQDMLAL_LANE, 
    	VQDMLSL_LANE, 
    	VFMA_LANE, 
    	VFMS_LANE, 
    	VQRDMLAH_LANE, 
    	VQRDMLSH_LANE, 
    	// -- MVE saturating unary -----------------------------------------------
    	VQABS, 
    	VQNEG, 
    	// -- MVE FP lane manipulation (F16 packing) -----------------------------
    	VMOVX,             // extract high F16 lane from S-reg
    	VINS,              // insert F16 into high lane of S-reg
    	// -- MVE gather/scatter (vector offset addressing) ----------------------
    	VLDRB_GATHER, 
    	VLDRH_GATHER, 
    	VLDRW_GATHER, 
    	VLDRD_GATHER, 
    	VSTRB_SCATTER, 
    	VSTRH_SCATTER, 
    	VSTRW_SCATTER, 
    	VSTRD_SCATTER, 
    	// -- NEON compare-with-zero (distinct encodings from reg-vs-reg) --------
    	VCEQ_Z, 
    	VCGE_Z, 
    	VCGT_Z, 
    	VCLE_Z, 
    	VCLT_Z, 
    	// -- NEON replicate loads (broadcast one element to all lanes) ----------
    	//    VLD1R already covered in VLD1; these are the 2/3/4 variants.
    	VLD2R, 
    	VLD3R, 
    	VLD4R, 
    	// -- NEON single-element-lane load/store (lane form, not multi-vec) -----
    	VLD1_LANE, 
    	VLD2_LANE, 
    	VLD3_LANE, 
    	VLD4_LANE, 
    	VST1_LANE, 
    	VST2_LANE, 
    	VST3_LANE, 
    	VST4_LANE, 
    	// -- VFP fixed-point conversions (with #fbits operand) ------------------
    	VCVT_FIXED,        // VCVT.<dt> Sd, Sd, #fbits family
    	// -------------------------------------------------------------------------
    	// Thumb-only mnemonics (extra ones not shared with A32)
    	// -------------------------------------------------------------------------
    	IT,                // if-then block (Thumb-2)
    	// -------------------------------------------------------------------------
    	// ARMv8-M Security Extensions (TrustZone-M)
    	// -------------------------------------------------------------------------
    	TT,                // test target
    	TTT,               // test target unprivileged
    	TTA,               // test target alternate domain
    	TTAT,              // test target alternate domain unprivileged
    	SG,                // secure gateway (enter secure state)
    	BXNS,              // branch and exchange non-secure
    	BLXNS,             // branch with link and exchange non-secure
    	// -------------------------------------------------------------------------
    	// PACBTI for ARMv8.1-M (Cortex-M85)
    	// -------------------------------------------------------------------------
    	PAC,               // PAC R12, LR, SP
    	PACBTI,            // PACBTI R12, LR, SP (combined PAC + BTI marker)
    	AUT,               // AUT R12, LR, SP
    	AUTG,              // AUTG Rd, Rn, Rm (general form)
    	BTI,               // M-profile branch target identification
    	// -------------------------------------------------------------------------
    	// ARMv8.1-M low-overhead loops (Helium prerequisite, but useful even without MVE)
    	// -------------------------------------------------------------------------
    	WLS,               // while loop start
    	WLSTP,             // while loop start with tail predication
    	DLS,               // do loop start
    	DLSTP,             // do loop start with tail predication
    	LE,                // loop end
    	LETP,              // loop end with tail predication
    	LCTP,              // loop clear tail predication
    	// Branch Future (ARMv8.1-M). T32, encoded via REL_BF + BF_BOFF/BF_BLOC/BF_RM
    	// operand encodings and BF_BOFF_T32/BF_BLOC_T32 relocations (see encoder.odin).
    	// bf-point imm4 at hw0[10:7]; branch target J:imm10 at hw1[11]:[10:1]; BFLX/BFX
    	// use a register target Rm at hw0[3:0]; BFCSEL adds a 4-bit condition at
    	// hw0[5:2] (its else-target is the implicit fall-through). Byte-exact vs llvm-mc.
    	BF,                // branch future
    	BFI_BR,            // branch future indirect (bfx)
    	BFL,               // branch future and link
    	BFLX,              // branch future link and exchange
    	BFCSEL,            // branch future conditional select
    	// -------------------------------------------------------------------------
    	// Custom Datapath Extension (CDE)
    	// -------------------------------------------------------------------------
    	CX1, 
    	CX1A,              // dual-coprocessor + GPR dest (32-bit)
    	CX1D, 
    	CX1DA,             // 64-bit GPR pair dest
    	CX2, 
    	CX2A, 
    	CX2D, 
    	CX2DA, 
    	CX3, 
    	CX3A, 
    	CX3D, 
    	CX3DA, 
    	VCX1, 
    	VCX1A,             // VFP S/D-reg dest
    	VCX2, 
    	VCX2A, 
    	VCX3, 
    	VCX3A, 
    	// Predication block (then/else interleaved)
    	VPT,               // predicate-then block
    	VPST,              // predicate-then-set block (single)
    	VPSEL,             // predicate select (per-element)
    	VPNOT,             // invert VPR
    	VCTP,              // create tail predicate (.8/.16/.32/.64)
    	// Reductions (single-vector accumulate)
    	VADDV, 
    	VADDVA,            // accumulate sum across vector (signed/unsigned, +acc)
    	VADDLV, 
    	VADDLVA,           // long version (S64 accumulator)
    	VMAXV, 
    	VMAXAV,            // max (and absolute)
    	VMINV, 
    	VMINAV, 
    	VMAXNMV, 
    	VMAXNMAV,          // FP max-num
    	VMINNMV, 
    	VMINNMAV, 
    	// Dual MAC reductions (multiply-accumulate then sum)
    	VABAV,             // accumulate absolute difference
    	VMLADAV, 
    	VMLADAVA, 
    	VMLADAVX, 
    	VMLADAVAX, 
    	VMLALDAV, 
    	VMLALDAVA, 
    	VMLALDAVX, 
    	VMLALDAVAX, 
    	VMLSDAV, 
    	VMLSDAVA, 
    	VMLSDAVX, 
    	VMLSDAVAX, 
    	VMLSLDAV, 
    	VMLSLDAVA, 
    	VMLSLDAVX, 
    	VMLSLDAVAX, 
    	VRMLALDAVH, 
    	VRMLALDAVHA, 
    	VRMLALDAVHX, 
    	VRMLALDAVHAX, 
    	VRMLSLDAVH, 
    	VRMLSLDAVHA, 
    	VRMLSLDAVHX, 
    	VRMLSLDAVHAX, 
    	VMLAV, 
    	VMLAVA,            // simple MAC across vector
    	VMLSV, 
    	VMLSVA, 
    	// Complex arithmetic (Q-register vector form)
    	VCMUL,             // complex multiply (separate from VCMLA)
    	VHCADD,            // halving complex add
    	// Bit reverse + shifts unique to MVE
    	VBRSR,             // bit reverse with shift right
    	VSHLC,             // shift left with carry
    	VDDUP,             // decrement and duplicate
    	VIDUP,             // increment and duplicate
    	VDWDUP,            // decrement-wrap and duplicate
    	VIWDUP,            // increment-wrap and duplicate
    	// Narrowing with B/T (bottom/top)
    	VMOVNB, 
    	VMOVNT,            // narrow bottom/top
    	VQMOVNB, 
    	VQMOVNT,           // saturating narrow B/T
    	VQMOVUNB, 
    	VQMOVUNT,          // saturating-unsigned narrow B/T
    	// Widening with B/T
    	VSHLLB, 
    	VSHLLT,            // shift left long bottom/top
    	VMULLB, 
    	VMULLT,            // multiply long B/T
    	VMLALB, 
    	VMLALT,            // multiply-accumulate long B/T
    	VMLSLB, 
    	VMLSLT, 
    	VSHRNB, 
    	VSHRNT,            // shift right narrow B/T
    	VRSHRNB, 
    	VRSHRNT, 
    	VQSHRNB, 
    	VQSHRNT, 
    	VQRSHRNB, 
    	VQRSHRNT, 
    	VQSHRUNB, 
    	VQSHRUNT, 
    	VQRSHRUNB, 
    	VQRSHRUNT, 
    	// Move between Qd-lane and GPR (MVE-specific 4-element split forms)
    	VMOV_Q_R,          // VMOV Qd[i], Rt  -- single lane to GPR
    	VMOV_R_Q,          // VMOV Rt, Qd[i]
    	VMOV_2GPR_Q,       // VMOV Qd[2*i], Qd[2*i+1], Rt, Rt2 -- pair
    	// Saturating doubling MAC reductions
    	VQDMLADH, 
    	VQDMLADHX, 
    	VQDMLSDH, 
    	VQDMLSDHX, 
    	VQRDMLADH, 
    	VQRDMLADHX, 
    	VQRDMLSDH, 
    	VQRDMLSDHX, 
    	// Misc
    	VHCADD_SAT,        // (rarely used)
    	VCMLA_MVE,         // (MVE form; VCMLA already exists)
    	// MVE load/store (mostly reuses VLDR/VSTR but distinct forms exist):
    	VLDRB, 
    	VLDRH, 
    	VLDRW, 
    	VLDRD,             // MVE contiguous load (B/H/W/D)
    	VSTRB, 
    	VSTRH, 
    	VSTRW, 
    	VSTRD,             // MVE contiguous store
    	VLD20, 
    	VLD21,             // 2-vector interleaved (halves)
    	VLD40, 
    	VLD41, 
    	VLD42, 
    	VLD43,             // 4-vector interleaved (quarters)
    	VST20, 
    	VST21, 
    	VST40, 
    	VST41, 
    	VST42, 
    	VST43, 
    	// -------------------------------------------------------------------------
    	// Sentinel
    	// -------------------------------------------------------------------------
    	_COUNT, 
    }
    Related Procedures With Parameters

    Mode ¶

    Mode :: enum u8 {
    	A32 = 0, // 32-bit ARM
    	T32 = 1, // Thumb (16-bit or 32-bit T2)
    }
    Related Procedures With Parameters

    NEON_Imm_Form ¶

    NEON_Imm_Form :: struct {
    	raw_imm32: u32,
    	// the 32-bit constant the user wants
    	cmode:     u8,
    	// selected cmode (0..15)
    	op:        u8,
    	// op bit (0 or 1)
    	abcdefgh:  u8,
    }
    Related Procedures With Parameters
    Related Procedures With Returns

    Operand ¶

    Operand :: struct #packed {
    	using _:    struct #packed #raw_union {
    		reg:       Register,
    		mem:       Memory,
    		immediate: i64,
    		relative:  i64,
    	},
    	kind:       Operand_Kind,
    	size:       u8,
    	shift_type: Shift_Type,
    	// for GPR_SHIFTED operands (otherwise NONE)
    	shift_amt:  u8,
    	// immediate shift amount 0..31 (or Rs index for RSR)
    	lane:       u8,
    	// SIMD lane index for DPR_ELEM / QPR_ELEM
    	cond:       u8,
    }
    Related Procedures With Returns

    Operand_Encoding ¶

    Operand_Encoding :: enum u8 {
    	NONE, 
    	IMPL,               // implicit operand (no bits emitted)
    	// ---- A32 GPR slots ----
    	RD,                 // bits 15-12 (data-proc dest)
    	RN_A32,             // bits 19-16
    	RM_A32,             // bits 3-0
    	RS_A32,             // bits 11-8  (register-shifted-register shift amount)
    	RT_A32,             // bits 15-12 (load/store target = RD slot)
    	RT2_A32,            // bits 15-12 + 1 (LDRD/STRD even-odd pair, implicit)
    	RA_A32,             // bits 15-12 (MLA, MLS accumulator)
    	RDLO_A32,           // bits 15-12 (UMULL/SMULL low result)
    	RDHI_A32,           // bits 19-16 (UMULL/SMULL high result)
    	// ---- T32 (Thumb-2 32-bit) slots ----
    	RD_T32,             // bits 11-8 of second halfword (high half of u32)
    	RN_T32,             // bits 19-16 of first halfword (low 4 bits of byte at offset 2)
    	RM_T32,             // bits 3-0 of second halfword
    	RT_T32,             // load/store target
    	RT2_T32,            // second load/store register
    	RA_T32,             // accumulator (MLA/MLS)
    	// ---- T16 slots ----
    	RD_T16_LO,          // bits 2-0 of halfword (low 3 bits)
    	RM_T16_LO,          // bits 5-3
    	RN_T16_LO,          // bits 5-3 (alias)
    	RD_T16_HI,          // hi-reg form: rd[3] at bit 7, rd[2:0] at bits 2-0
    	RM_T16_HI,          // rm at bits 6-3 (4-bit hi-reg)
    	// ---- Modified immediate ----
    	A32_IMM_MOD,        // bits 11-0 carry rotate(11:8) + value(7:0)
    	T32_IMM_MOD,        // Thumb-2 modified-imm in i:imm3:imm8 (bits 26, 14-12, 7-0)
    	A32_IMM12_ROT,      // identical to A32_IMM_MOD; alternate name for clarity
    	// ---- Immediate field placements (A32) ----
    	A32_IMM12,          // bits 11-0 (LDR/STR offset)
    	A32_IMM_SHIFT,      // bits 11-7 (data-proc shift_imm)
    	A32_SHIFT_TYPE,     // bits 6-5
    	A32_RS_SHIFT,       // bits 11-8 (RSR uses Rs register)
    	A32_IMM24,          // bits 23-0 (B/BL/SVC)
    	A32_IMM4,           // bits 3-0 in modified-imm rotate or SAT amount
    	A32_IMM4_ROTATE,    // bits 11-8 (rotation in some forms)
    	A32_IMM5_LSB,       // bits 11-7 (BFC/BFI/UBFX lsb)
    	A32_IMM5_W,         // bits 20-16 (BFC/BFI msb -- width = msb - lsb + 1)
    	A32_COND_FIELD,     // bits 31-28
    	A32_REG_LIST,       // bits 15-0 (LDM/STM/PUSH/POP bitmask of R0..R15)
    	// ---- VFP / NEON register fields ----
    	VD_S,               // S<reg>: Vd<4:1>=bits 15-12, D=bit 22; combined 5-bit reg
    	VN_S,               // S<reg>: Vn<4:1>=bits 19-16, N=bit 7
    	VM_S,               // S<reg>: Vm<4:1>=bits 3-0,  M=bit 5
    	VD_D,               // D<reg>: D=bit 22, Vd<3:0>=bits 15-12
    	VN_D,               // D<reg>: N=bit 7,  Vn<3:0>=bits 19-16
    	VM_D,               // D<reg>: M=bit 5,  Vm<3:0>=bits 3-0
    	VD_Q,               // Q<reg>: D=bit 22, Vd<3:0>=bits 15-12 (must be even)
    	VN_Q,               // Q<reg>: N=bit 7,  Vn<3:0>=bits 19-16 (must be even)
    	VM_Q,               // Q<reg>: M=bit 5,  Vm<3:0>=bits 3-0 (must be even)
    	// NEON by-element scalar Dm[lane] (VQDMULH/VQRDMULH-by-scalar):
    	//   .16: Dm in D0..D7 at bits 2:0, lane = bit5:bit3
    	//   .32: Dm in D0..D15 at bits 3:0, lane = bit5
    	NEON_VM_SCALAR16, 
    	NEON_VM_SCALAR32, 
    	// VMOV (core register to scalar) destination Dd[lane]: Dd at bits 19:16 +
    	// bit 7; the lane bits depend on element size:
    	//   .8  lane[2:0] = bit22 : bit21 : bit5     .16 lane[1:0] = bit21 : bit6
    	//   .32 lane[0]   = bit21
    	VMOV_LANE_8, 
    	VMOV_LANE_16, 
    	VMOV_LANE_32, 
    	// MVE complex-op rotation immediate (user passes degrees):
    	//   MVE_ROT_HCADD: #90/#270 -> bit 12;  MVE_ROT_CMLA: #0/90/180/270 -> bits 24:23
    	MVE_ROT_HCADD, 
    	MVE_ROT_CMLA, 
    	// MVE 3-bit Q registers (Q0..Q7): Qn at bits 19:17, Qm at bits 3:1.
    	VN_Q_MVE, 
    	VM_Q_MVE, 
    	VFP_IMM8,           // VFP immediate (VMOV.F32/F64 #imm)
    	NEON_IMM8_ABCDEFGH, // bits 18-16 (abc) + bits 3-0 (defgh)
    	NEON_CMODE,         // bits 11-8 (cmode for VMOV/VMVN immediate)
    	NEON_OP_BIT,        // bit 5 (op for VMOV immediate variant)
    	// ---- VFP / NEON list ----
    	VFP_S_LIST,         // VLDM/VSTM single-prec list (8-bit count, start in Vd_S)
    	VFP_D_LIST,         // VLDM/VSTM double-prec list (8-bit count, start in Vd_D)
    	// ---- Memory addressing composites ----
    	MEM_IMM12_OFFSET,   // [Rn, #±imm12]
    	MEM_IMM8_OFFSET,    // [Rn, #±imm8] (LDRH/STRH/LDRSB/STRD)
    	MEM_REG_OFFSET,     // [Rn, ±Rm{, shift}]
    	MEM_PRE_INDEX,      // [Rn, #imm]! / [Rn, ±Rm]!
    	MEM_POST_INDEX,     // [Rn], #imm / [Rn], ±Rm
    	MEM_LITERAL,        // [PC, #imm]  (LDR literal)
    	MEM_DOUBLEREG,      // [Rn, Rm] for LDRD/STRD register offset
    	// ---- Coprocessor ----
    	COPROC_NUM_FIELD,   // bits 11-8 in CDP/LDC/STC (cp_num)
    	COPROC_OPC1_FIELD,  // bits 23-20 (CDP / MCR / MRC opc1)
    	COPROC_OPC2_FIELD,  // bits 7-5  (MCR/MRC opc2)
    	COPROC_CRN_FIELD,   // bits 19-16
    	COPROC_CRM_FIELD,   // bits 3-0
    	COPROC_OPC_MCRR,    // bits 7-4 (MCRR/MRRC 4-bit opcode)
    	// ---- Branch fields ----
    	BRANCH_24,          // A32 imm24 at bits 23-0 (scaled ×4, ±32MB)
    	BRANCH_24_T32,      // T32 unconditional: S/J1/J2 + imm10 + imm11 (scaled ×2)
    	BRANCH_20_T32,      // T32 conditional: S + cond + imm6 + J1 + J2 + imm11
    	BRANCH_11_T16,      // T16 unconditional (imm11, scaled ×2, ±2KB)
    	BRANCH_8_T16,       // T16 conditional (cond + imm8, scaled ×2, ±256B)
    	BRANCH_CBZ,         // T16 CBZ/CBNZ (i + imm5 + Rn, scaled ×2)
    	// ARMv8.1-M Branch Future fields (T32):
    	BF_BOFF,            // bf-point offset: imm4 at hw0[10:7], (label-PC-4)/2
    	BF_BLOC,            // branch target: J at hw1[11] + imm10 at hw1[10:1]
    	BF_RM,              // BFLX/BFX register target at hw0[3:0]
    	BFCSEL_COND,        // BFCSEL condition at hw0[5:2]
    	// ---- Misc ----
    	PSR_FIELD_MASK,     // APSR fields_mask at bits 19-16 (MSR)
    	SYSM_FIELD,         // SYSm at bits 7-0 (MRS_BANKED)
    	BARRIER_TYPE,       // bits 3-0 for DMB/DSB/ISB
    	IT_MASK,            // bits 7-0 for IT block (mask + cond)
    	CPS_IFLAGS,         // imod + iflags + mode for CPS
    	HINT_FIELD,         // hint imm
    	// ---- Saturate ----
    	SAT_IMM5,           // bits 20-16: SSAT/USAT saturate-to width
    	SAT_IMM5_T32,       // Thumb-2 saturate amount
    	// ---- BFC/BFI/SBFX/UBFX ----
    	BFI_MSB,            // bits 20-16 (msb position)
    	BFI_LSB,            // bits 11-7  (lsb position; also shift_imm slot)
    	BFI_LSB_T32,        // Thumb-2 BFI lsb (different layout)
    	// ---- NEON shift-immediate (imm6 in bits 21:16, with element-size hint
    	//      in bit 22 = L bit for 64-bit shifts) ----
    	NEON_SHIFT_IMM6,    // 6-bit shift amount at bits 21:16 (NEON VSHR/VSRA/...)
    	NEON_SHIFT_IMM3,    // 3-bit shift at bits 18:16 (.I8 form, top 3 bits zero)
    	// ---- ARMv8-M / MVE / CDE ----
    	QD_MVE,             // MVE Qd: bit 22 fixed 0, bits 15:13 = Qd[2:0]
    	QN_MVE,             // MVE Qn: bit 7, bits 19:17 = Qn[2:0]
    	QM_MVE,             // MVE Qm: bit 5, bits 3:1 = Qm[2:0]
    	MVE_SIZE_FIELD,     // 2-bit size in bits 21:20 (B/H/W/D)
    	MVE_VPT_MASK_FIELD, // VPT mask in bits 3:0 of second halfword
    	MVE_LOOP_IMM,       // low-overhead-loop immediate
    	CDE_COPROC_FIELD,   // CDE p<n> coprocessor selector (bits 11:8)
    	CDE_IMM_FIELD,      // CDE immediate (variable layout)
    	CDE_ACC_FIELD,      // CDE accumulator bit (distinguishes CX1/CX1A)
    	V8M_TT_AT_BITS,     // TT/TTA/TTT/TTAT A and T bit field at bits 7:6
    }

    Operand_Kind ¶

    Operand_Kind :: enum u8 {
    	NONE, 
    	REGISTER, 
    	IMMEDIATE, 
    	MEMORY, 
    	RELATIVE, 
    	REG_LIST,  // LDM/STM/PUSH/POP bitmask (low 16 bits = R0..R15)
    }

    Operand_Type ¶

    Operand_Type :: enum u8 {
    	NONE, 
    	// ---- Integer registers ----
    	GPR,             // R0..R15 (or SP/LR/PC by alias)
    	GPR_NOPC,        // R0..R14 (PC disallowed by spec)
    	GPR_NOSP,        // R0..R14 except SP
    	GPR_LOW,         // R0..R7 (Thumb-1 low-reg encoding)
    	GPR_SHIFTED,     // Rm + shift type + immediate shift amount
    	GPR_RSR,         // Rm + shift type + Rs register-shifted-register
    	GPR_LIST,        // Register list (LDM/STM/PUSH/POP); bitmask 16 GPRs
    	// ---- Floating point / SIMD ----
    	SPR,             // S0..S31
    	DPR,             // D0..D31
    	QPR,             // Q0..Q15
    	SPR_LIST,        // VLDM/VSTM/VPUSH/VPOP list of S regs
    	DPR_LIST,        // VLDM/VSTM list of D regs
    	SPR_ELEM,        // S<n> with no extra shape info
    	DPR_ELEM,        // D<n>[lane] for scalar-FP-in-SIMD operations
    	QPR_ELEM,        // Q<n>[lane]
    	// ---- Immediates ----
    	IMM,             // generic immediate (sized per encoding)
    	IMM_MOD,         // A32 modified-immediate (8-bit + 4-bit rotate)
    	IMM_T32_MOD,     // Thumb-2 modified-immediate (similar but distinct encoding)
    	IMM16_LO_HI,     // MOVW/MOVT 16-bit immediate split into imm4 + imm12
    	IMM12,           // unsigned 12-bit (LDR/STR offset)
    	IMM5,            // 5-bit (shift_imm, BFC/BFI lsb)
    	IMM5_W,          // 5-bit field width (BFC/BFI/SBFX/UBFX)
    	IMM4,            // 4-bit (rotate, ext rotation amount)
    	IMM4_SAT,        // SSAT/USAT saturation amount
    	IMM8,            // 8-bit (NEON VMOV, ConstantPool index, etc.)
    	IMM3,            // 3-bit Thumb register-encoded immediate
    	IMM_HINT,        // hint number (DBG, HINT)
    	IMM_BARRIER,     // DMB/DSB/ISB barrier type
    	IMM_ENDIAN,      // 1-bit BE/LE for SETEND
    	IMM_IFLAGS,      // CPS iflags + mode
    	IMM_BANKED,      // banked register selector (MSR/MRS banked)
    	IMM_SYSM,        // 7-bit SYSm field
    	IMM_COPROC,      // coprocessor number 0..15
    	IMM_COPROC_OP,   // coprocessor opcode (CDP / MCR / MRC: opcode1/2 fields)
    	NEON_IMM,        // NEON modified-immediate (with cmode + abcdefgh)
    	// ---- PC-relative ----
    	REL24,           // A32 B / BL (signed 24-bit << 2)
    	REL24_T32,       // T32 B unconditional (J1/J2 + imm10 + imm11)
    	REL20,           // T32 B<cond> (signed 20-bit equivalent)
    	REL11,           // T16 B<cond>
    	REL8,            // T16 conditional branch (signed 8-bit)
    	REL_LDR_LITERAL, // PC-relative literal load offset
    	REL_BF,          // ARMv8.1-M Branch Future label (bf-point / branch target)
    	// ---- Condition code ----
    	COND,            // 4-bit cond field (for IT block / B<cond> / etc.)
    	// ---- Memory ----
    	MEM,             // memory operand; addressing mode in operand payload
    	// ---- Coprocessor ----
    	COPROC_REG,      // CRn / CRm (coprocessor register identifier)
    	COPROC_NUM,      // pX (coprocessor number 0..15)
    	// ---- Misc ----
    	PSR_FIELD,       // APSR/CPSR field selector (_nzcvq, _g, _nzcvqg, _s, _x, _c)
    	// ---- ARMv8-M / MVE / CDE operand classes ----
    	VPR,             // VPR predicate register (single; bit-wise predicate state)
    	QPR_MVE,         // MVE Q-register (Q0..Q7; 3-bit index; bit 22 = 0 always)
    	QPR_MVE_LIST,    // MVE multi-Q list (e.g. VLD2x2 etc.)
    	MVE_VPT_MASK,    // VPT block mask (4-bit then/else pattern)
    	MVE_VCTP_SIZE,   // 2-bit element-size selector for VCTP (B/H/W/D)
    	MVE_LOOP_TGT,    // low-overhead-loop branch target (WLS/LE/DLS imm)
    	CDE_COPROC,      // CDE coprocessor number 0..7
    	CDE_IMM,         // CDE immediate (varies per CX1/CX2/CX3 form)
    	CDE_VFP_REG,     // CDE VCX1/2/3 destination S/D-reg
    }
    Print_Result :: rexcode_isa.Print_Result

    Register ¶

    Register :: distinct u16
    Related Procedures With Parameters
    Related Constants

    Relocation ¶

    Relocation :: struct #packed {
    	offset:   u32,
    	label_id: u32,
    	addend:   i32,
    	type:     Relocation_Type,
    	size:     u8,
    	// 2 (T16) or 4 (A32/T32)
    	inst_idx: u16,
    }

    Relocation_Type ¶

    Relocation_Type :: enum u8 {
    	NONE            = 0, 
    	// A32 branches
    	BRANCH_A32_24,       // B / BL, 24-bit signed << 2
    	BLX_A32,             // BLX imm, 24-bit signed << 2 + H bit at bit 24
    	// T32 branches
    	BRANCH_T32_25,       // T32 B unconditional (J1/J2 + imm10 + imm11)
    	BRANCH_T32_21,       // T32 B<cond> (S + cond + imm6 + J1/J2 + imm11)
    	// T16 branches
    	BRANCH_T16_11,       // T16 B unconditional (signed 11-bit << 1)
    	BRANCH_T16_8,        // T16 B<cond> (signed 8-bit << 1)
    	BRANCH_T16_CBZ,      // T16 CBZ/CBNZ (i + imm5 + Rn)
    	// T32 low-overhead loops (ARMv8.1-M)
    	BRANCH_T32_WLS,      // WLS / WLSTP imm11
    	BRANCH_T32_LE,       // LE / LETP imm11
    	// T32 Branch Future (ARMv8.1-M)
    	BF_BOFF_T32,         // bf-point: imm4 at hw0[10:7] = (label - (PC+4))/2
    	BF_BLOC_T32,         // branch target: J at hw1[11] + imm10 at hw1[10:1]
    	// Literal load (ADR / LDR PC-rel)
    	LDR_LITERAL_A32,     // signed 12-bit (U bit + imm12)
    	LDR_LITERAL_T32,     // signed 12-bit (U bit + imm12) Thumb-2
    	LDR_LITERAL_T16,     // unsigned 8-bit << 2 (Thumb-1 PC-rel)
    	ADR_A32,             // ADR encoded as ADD/SUB to PC
    	ADR_T32, 
    	ADR_T16,             // Thumb-1 ADR (imm8 << 2)
    	// Absolute forms via MOVW + MOVT pair
    	MOVW_ABS,            // imm16 low half
    	MOVT_ABS,            // imm16 high half
    }

    Shift_Type ¶

    Shift_Type :: enum u8 {
    	LSL     = 0, 
    	LSR     = 1, 
    	ASR     = 2, 
    	ROR     = 3, 
    	RRX     = 4, // pseudo: encoded as ROR #0
    	NONE    = 5, 
    	// Register-shifted-register markers: the shift count comes from the Rs
    	// register stored in shift_amt (0..15), not from an immediate. Encoder
    	// packs bits 11..8 = Rs, 6..5 = (type - LSL_REG) low 2 bits, bit 4 = 1.
    	LSL_REG = 6, 
    	LSR_REG = 7, 
    	ASR_REG = 8, 
    	ROR_REG = 9, 
    }
    Related Procedures With Parameters

    Token ¶

    Token :: rexcode_isa.Token

    Token_Kind ¶

    Token_Kind :: rexcode_isa.Token_Kind

    Constants

    APSR ¶

    APSR :: Register(REG_SREG | 0)
     

    ---- Status / control registers ---------------------------------------------

    COND_AL ¶

    COND_AL :: u32(0xE)

    COND_CC ¶

    COND_CC :: u32(0x3)

    COND_CS ¶

    COND_CS :: u32(0x2)

    COND_EQ ¶

    COND_EQ :: u32(0x0)
     

    Condition code constants (cond field values).

    COND_GE ¶

    COND_GE :: u32(0xA)

    COND_GT ¶

    COND_GT :: u32(0xC)

    COND_HI ¶

    COND_HI :: u32(0x8)

    COND_LE ¶

    COND_LE :: u32(0xD)

    COND_LS ¶

    COND_LS :: u32(0x9)

    COND_LT ¶

    COND_LT :: u32(0xB)

    COND_MI ¶

    COND_MI :: u32(0x4)

    COND_NE ¶

    COND_NE :: u32(0x1)

    COND_NV ¶

    COND_NV :: u32(0xF)
     

    NV is "always" in encoding (also marks unconditional class)

    COND_PL ¶

    COND_PL :: u32(0x5)

    COND_VC ¶

    COND_VC :: u32(0x7)

    COND_VS ¶

    COND_VS :: u32(0x6)

    CPSR ¶

    CPSR :: Register(REG_SREG | 1)

    D0 ¶

    D0 :: Register(REG_DPR | 0)
     

    ---- VFP/NEON double-precision (D0..D31) ------------------------------------

    D1 ¶

    D1 :: Register(REG_DPR | 1)

    D10 ¶

    D10 :: Register(REG_DPR | 10)

    D11 ¶

    D11 :: Register(REG_DPR | 11)

    D12 ¶

    D12 :: Register(REG_DPR | 12)

    D13 ¶

    D13 :: Register(REG_DPR | 13)

    D14 ¶

    D14 :: Register(REG_DPR | 14)

    D15 ¶

    D15 :: Register(REG_DPR | 15)

    D16 ¶

    D16 :: Register(REG_DPR | 16)

    D17 ¶

    D17 :: Register(REG_DPR | 17)

    D18 ¶

    D18 :: Register(REG_DPR | 18)

    D19 ¶

    D19 :: Register(REG_DPR | 19)

    D2 ¶

    D2 :: Register(REG_DPR | 2)

    D20 ¶

    D20 :: Register(REG_DPR | 20)

    D21 ¶

    D21 :: Register(REG_DPR | 21)

    D22 ¶

    D22 :: Register(REG_DPR | 22)

    D23 ¶

    D23 :: Register(REG_DPR | 23)

    D24 ¶

    D24 :: Register(REG_DPR | 24)

    D25 ¶

    D25 :: Register(REG_DPR | 25)

    D26 ¶

    D26 :: Register(REG_DPR | 26)

    D27 ¶

    D27 :: Register(REG_DPR | 27)

    D28 ¶

    D28 :: Register(REG_DPR | 28)

    D29 ¶

    D29 :: Register(REG_DPR | 29)

    D3 ¶

    D3 :: Register(REG_DPR | 3)

    D30 ¶

    D30 :: Register(REG_DPR | 30)

    D31 ¶

    D31 :: Register(REG_DPR | 31)

    D4 ¶

    D4 :: Register(REG_DPR | 4)

    D5 ¶

    D5 :: Register(REG_DPR | 5)

    D6 ¶

    D6 :: Register(REG_DPR | 6)

    D7 ¶

    D7 :: Register(REG_DPR | 7)

    D8 ¶

    D8 :: Register(REG_DPR | 8)

    D9 ¶

    D9 :: Register(REG_DPR | 9)

    DECODE_T32_SUB_BUCKETS ¶

    DECODE_T32_SUB_BUCKETS :: 32

    DEFAULT_PRINT_OPTIONS ¶

    DEFAULT_PRINT_OPTIONS: rexcode_isa.Print_Options : isa.DEFAULT_PRINT_OPTIONS

    FP ¶

    FP: Register : R11
     

    frame pointer

    FPEXC ¶

    FPEXC :: Register(REG_FPSC | 8)

    FPSCR ¶

    FPSCR :: Register(REG_FPSC | 1)

    FPSID ¶

    FPSID :: Register(REG_FPSC | 0)
     

    FPSCR / FPSID and friends

    IP ¶

    IP: Register : R12
     

    intra-procedure scratch

    LABEL_UNDEFINED ¶

    LABEL_UNDEFINED: rexcode_isa.Label_Definition : isa.LABEL_UNDEFINED

    LR ¶

    LR: Register : R14
     

    link register

    MASK_COND ¶

    MASK_COND :: u32(0xF0000000)
     

    bits 31-28

    MASK_IMM12 ¶

    MASK_IMM12 :: u32(0x00000FFF)
     

    bits 11-0

    MASK_IMM24 ¶

    MASK_IMM24 :: u32(0x00FFFFFF)
     

    bits 23-0

    MASK_OPCODE_HI ¶

    MASK_OPCODE_HI :: u32(0x0FE00000)
     

    bits 27-25 (selects encoding class) + 24-21 (op)

    MASK_RD_A32 ¶

    MASK_RD_A32 :: u32(0x0000F000)
     

    bits 15-12

    MASK_RLIST ¶

    MASK_RLIST :: u32(0x0000FFFF)
     

    bits 15-0

    MASK_RM_A32 ¶

    MASK_RM_A32 :: u32(0x0000000F)
     

    bits 3-0

    MASK_RN_A32 ¶

    MASK_RN_A32 :: u32(0x000F0000)
     

    bits 19-16

    MASK_RS_A32 ¶

    MASK_RS_A32 :: u32(0x00000F00)
     

    bits 11-8

    MASK_SHIFT_IMM ¶

    MASK_SHIFT_IMM :: u32(0x00000F80)
     

    bits 11-7

    MASK_SHIFT_TYPE ¶

    MASK_SHIFT_TYPE :: u32(0x00000060)
     

    bits 6-5

    MASK_S_FLAG ¶

    MASK_S_FLAG :: u32(0x00100000)
     

    bit 20

    MAX_INST_SIZE ¶

    MAX_INST_SIZE :: 4

    MVFR0 ¶

    MVFR0 :: Register(REG_FPSC | 7)

    MVFR1 ¶

    MVFR1 :: Register(REG_FPSC | 6)

    MVFR2 ¶

    MVFR2 :: Register(REG_FPSC | 5)

    PC ¶

    PC: Register : R15
     

    program counter

    PSR_FIELD_ALL ¶

    PSR_FIELD_ALL: u8 : PSR_FIELD_F | PSR_FIELD_S | PSR_FIELD_X | PSR_FIELD_C

    PSR_FIELD_C ¶

    PSR_FIELD_C :: u8(1 << 0)

    PSR_FIELD_F ¶

    PSR_FIELD_F :: u8(1 << 3)

    PSR_FIELD_G ¶

    PSR_FIELD_G: u8 : PSR_FIELD_X

    PSR_FIELD_NZCVQ ¶

    PSR_FIELD_NZCVQ: u8 : PSR_FIELD_F
     

    _nzcvq = F bit (flags) _g = X bit (GE bits, ARMv6+) _nzcvqg = F | X _all (cpsr_all) = F | S | X | C

    PSR_FIELD_NZCVQG ¶

    PSR_FIELD_NZCVQG: u8 : PSR_FIELD_F | PSR_FIELD_X

    PSR_FIELD_S ¶

    PSR_FIELD_S :: u8(1 << 2)

    PSR_FIELD_X ¶

    PSR_FIELD_X :: u8(1 << 1)

    Q0 ¶

    Q0 :: Register(REG_QPR | 0)
     

    ---- NEON quad-word (Q0..Q15) -----------------------------------------------

    Q1 ¶

    Q1 :: Register(REG_QPR | 1)

    Q10 ¶

    Q10 :: Register(REG_QPR | 10)

    Q11 ¶

    Q11 :: Register(REG_QPR | 11)

    Q12 ¶

    Q12 :: Register(REG_QPR | 12)

    Q13 ¶

    Q13 :: Register(REG_QPR | 13)

    Q14 ¶

    Q14 :: Register(REG_QPR | 14)

    Q15 ¶

    Q15 :: Register(REG_QPR | 15)

    Q2 ¶

    Q2 :: Register(REG_QPR | 2)

    Q3 ¶

    Q3 :: Register(REG_QPR | 3)

    Q4 ¶

    Q4 :: Register(REG_QPR | 4)

    Q5 ¶

    Q5 :: Register(REG_QPR | 5)

    Q6 ¶

    Q6 :: Register(REG_QPR | 6)

    Q7 ¶

    Q7 :: Register(REG_QPR | 7)

    Q8 ¶

    Q8 :: Register(REG_QPR | 8)

    Q9 ¶

    Q9 :: Register(REG_QPR | 9)

    R0 ¶

    R0 :: Register(REG_GPR | 0)
     

    ---- GPR ---------------------------------------------------------------------

    R1 ¶

    R1 :: Register(REG_GPR | 1)

    R10 ¶

    R10 :: Register(REG_GPR | 10)

    R11 ¶

    R11 :: Register(REG_GPR | 11)

    R12 ¶

    R12 :: Register(REG_GPR | 12)

    R13 ¶

    R13 :: Register(REG_GPR | 13)

    R14 ¶

    R14 :: Register(REG_GPR | 14)

    R15 ¶

    R15 :: Register(REG_GPR | 15)

    R2 ¶

    R2 :: Register(REG_GPR | 2)

    R3 ¶

    R3 :: Register(REG_GPR | 3)

    R4 ¶

    R4 :: Register(REG_GPR | 4)

    R5 ¶

    R5 :: Register(REG_GPR | 5)

    R6 ¶

    R6 :: Register(REG_GPR | 6)

    R7 ¶

    R7 :: Register(REG_GPR | 7)

    R8 ¶

    R8 :: Register(REG_GPR | 8)

    R9 ¶

    R9 :: Register(REG_GPR | 9)

    REG_BANKED ¶

    REG_BANKED :: u16(0x7000)

    REG_CLASS_MASK ¶

    REG_CLASS_MASK :: u16(0xF000)

    REG_COPROC ¶

    REG_COPROC :: u16(0x8000)

    REG_DPR ¶

    REG_DPR :: u16(0x3000)

    REG_FPSC ¶

    REG_FPSC :: u16(0x6000)

    REG_GPR ¶

    REG_GPR :: u16(0x1000)

    REG_HW_MASK ¶

    REG_HW_MASK :: u16(0x0FFF)

    REG_NONE ¶

    REG_NONE :: u16(0x0000)

    REG_QPR ¶

    REG_QPR :: u16(0x4000)

    REG_SPR ¶

    REG_SPR :: u16(0x2000)

    REG_SREG ¶

    REG_SREG :: u16(0x5000)

    S0 ¶

    S0 :: Register(REG_SPR | 0)
     

    ---- VFP single-precision ---------------------------------------------------

    S1 ¶

    S1 :: Register(REG_SPR | 1)

    S10 ¶

    S10 :: Register(REG_SPR | 10)

    S11 ¶

    S11 :: Register(REG_SPR | 11)

    S12 ¶

    S12 :: Register(REG_SPR | 12)

    S13 ¶

    S13 :: Register(REG_SPR | 13)

    S14 ¶

    S14 :: Register(REG_SPR | 14)

    S15 ¶

    S15 :: Register(REG_SPR | 15)

    S16 ¶

    S16 :: Register(REG_SPR | 16)

    S17 ¶

    S17 :: Register(REG_SPR | 17)

    S18 ¶

    S18 :: Register(REG_SPR | 18)

    S19 ¶

    S19 :: Register(REG_SPR | 19)

    S2 ¶

    S2 :: Register(REG_SPR | 2)

    S20 ¶

    S20 :: Register(REG_SPR | 20)

    S21 ¶

    S21 :: Register(REG_SPR | 21)

    S22 ¶

    S22 :: Register(REG_SPR | 22)

    S23 ¶

    S23 :: Register(REG_SPR | 23)

    S24 ¶

    S24 :: Register(REG_SPR | 24)

    S25 ¶

    S25 :: Register(REG_SPR | 25)

    S26 ¶

    S26 :: Register(REG_SPR | 26)

    S27 ¶

    S27 :: Register(REG_SPR | 27)

    S28 ¶

    S28 :: Register(REG_SPR | 28)

    S29 ¶

    S29 :: Register(REG_SPR | 29)

    S3 ¶

    S3 :: Register(REG_SPR | 3)

    S30 ¶

    S30 :: Register(REG_SPR | 30)

    S31 ¶

    S31 :: Register(REG_SPR | 31)

    S4 ¶

    S4 :: Register(REG_SPR | 4)

    S5 ¶

    S5 :: Register(REG_SPR | 5)

    S6 ¶

    S6 :: Register(REG_SPR | 6)

    S7 ¶

    S7 :: Register(REG_SPR | 7)

    S8 ¶

    S8 :: Register(REG_SPR | 8)

    S9 ¶

    S9 :: Register(REG_SPR | 9)

    SB ¶

    SB: Register : R9
     

    Conventional aliases

    SHIFT_ASR ¶

    SHIFT_ASR :: u32(2)

    SHIFT_LSL ¶

    SHIFT_LSL :: u32(0)
     

    Shift type field values (A32 bits 6-5).

    SHIFT_LSR ¶

    SHIFT_LSR :: u32(1)

    SHIFT_ROR ¶

    SHIFT_ROR :: u32(3)

    SHIFT_RRX ¶

    SHIFT_RRX :: u32(3)
     

    encoded as ROR #0

    SL ¶

    SL: Register : R10
     

    stack limit

    SP ¶

    SP: Register : R13
     

    stack pointer

    SPSR ¶

    SPSR :: Register(REG_SREG | 2)

    Variables

    DECODE_BUCKET_LIST ¶

    @(rodata)
    DECODE_BUCKET_LIST: []u16 = …

    DECODE_ENTRIES ¶

    @(rodata)
    DECODE_ENTRIES: []Decode_Entry = …

    DECODE_FORM_IDX ¶

    @(rodata)
    DECODE_FORM_IDX: []u16 = …

    DECODE_INDEX_A32 ¶

    @(rodata)
    DECODE_INDEX_A32: []Decode_Index = …

    DECODE_INDEX_T16 ¶

    @(rodata)
    DECODE_INDEX_T16: []Decode_Index = …

    DECODE_INDEX_T32 ¶

    @(rodata)
    DECODE_INDEX_T32: []Decode_Index = …

    DECODE_INDEX_T32_SUB ¶

    @(rodata)
    DECODE_INDEX_T32_SUB: []Decode_Index = …

    ENCODE_FORMS ¶

    @(rodata)
    ENCODE_FORMS: []Encoding = …

    ENCODE_RUNS ¶

    @(rodata)
    ENCODE_RUNS: []Encode_Run = …

    Procedures

    a32_t32_neon_swap ¶

    a32_t32_neon_swap :: proc "contextless" (bits: u32) -> u32 {…}
     

    Transform an A32 NEON/VFP encoding word to its T32 equivalent (or vice versa) by toggling bit 28.

    aprint ¶

    aprint :: proc(
    	instructions: []Instruction, 
    	inst_info:    []Instruction_Info, 
    	label_defs:   []rexcode_isa.Label_Definition, 
    	tokens:       ^[dynamic]rexcode_isa.Token = nil, 
    	options:      ^rexcode_isa.Print_Options = nil, 
    	label_names:  ^map[u32]string = nil, 
    	allocator := context.allocator, 
    ) -> string {…}

    aprintln ¶

    aprintln :: proc(
    	instructions: []Instruction, 
    	inst_info:    []Instruction_Info, 
    	label_defs:   []rexcode_isa.Label_Definition, 
    	tokens:       ^[dynamic]rexcode_isa.Token = nil, 
    	options:      ^rexcode_isa.Print_Options = nil, 
    	label_names:  ^map[u32]string = nil, 
    	allocator := context.allocator, 
    ) -> string {…}

    bprint ¶

    bprint :: proc(
    	buf:          []u8, 
    	instructions: []Instruction, 
    	inst_info:    []Instruction_Info, 
    	label_defs:   []rexcode_isa.Label_Definition, 
    	tokens:       ^[dynamic]rexcode_isa.Token = nil, 
    	options:      ^rexcode_isa.Print_Options = nil, 
    	label_names:  ^map[u32]string = nil, 
    ) -> string {…}

    bprintln ¶

    bprintln :: proc(
    	buf:          []u8, 
    	instructions: []Instruction, 
    	inst_info:    []Instruction_Info, 
    	label_defs:   []rexcode_isa.Label_Definition, 
    	tokens:       ^[dynamic]rexcode_isa.Token = nil, 
    	options:      ^rexcode_isa.Print_Options = nil, 
    	label_names:  ^map[u32]string = nil, 
    ) -> string {…}

    decode ¶

    decode :: proc(
    	data:         []u8, 
    	relocs:       []Relocation, 
    	instructions: ^[dynamic]Instruction, 
    	inst_info:    ^[dynamic]Instruction_Info, 
    	label_defs:   ^[dynamic]rexcode_isa.Label_Definition, 
    	errors:       ^[dynamic]rexcode_isa.Error, 
    	mode:         Mode = .A32, 
    ) -> (byte_count: u32, ok: bool) {…}

    decode_a32_modimm ¶

    decode_a32_modimm :: proc "contextless" (imm12: u32) -> u32 {…}
     

    Decode an A32 modified-immediate field (12 bits) to its 32-bit value.

    decode_estimate_instruction_count ¶

    decode_estimate_instruction_count :: proc "contextless" (data: []u8) -> int {…}
     

    Typical-case estimate of the instruction count for data.

    decode_max_instruction_count ¶

    decode_max_instruction_count :: proc "contextless" (data: []u8) -> int {…}
     

    Instruction-count ceiling for data (A32 is 4 bytes, Thumb 2; minimum 2).

    decode_neon_modimm ¶

    decode_neon_modimm :: proc "contextless" (abcdefgh: u32, cmode: u32, op: u32) -> u32 {…}
     

    Decode the 8-bit abcdefgh + cmode + op back into a 32-bit constant.

    decode_psr_field ¶

    decode_psr_field :: proc "contextless" (word: u32) -> u8 {…}

    decode_reserve ¶

    decode_reserve :: proc(instructions: ^[dynamic]Instruction, inst_info: ^[dynamic]Instruction_Info, label_defs: ^[dynamic]rexcode_isa.Label_Definition, data: []u8, exact: bool = false) {…}
     

    Pre-size the caller's decode output arrays for data (reserves on top of any existing elements; nil to skip; exact=true for the ceiling, else the estimate).

    decode_t32_modimm ¶

    decode_t32_modimm :: proc "contextless" (field12: u32) -> u32 {…}
     

    Decode a 12-bit i:imm3:imm8 field to its 32-bit constant value.

    decode_vfp_imm8_f16 ¶

    decode_vfp_imm8_f16 :: proc "contextless" (abcdefgh: u32) -> u16 {…}

    decode_vfp_imm8_f32 ¶

    decode_vfp_imm8_f32 :: proc "contextless" (abcdefgh: u32) -> u32 {…}

    decode_vfp_imm8_f64 ¶

    decode_vfp_imm8_f64 :: proc "contextless" (abcdefgh: u32) -> u64 {…}

    emit_adc_r_r_immm ¶

    emit_adc_r_r_immm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}
    Related Procedure Groups

    emit_adc_r_r_rsh ¶

    emit_adc_r_r_rsh :: proc(
    	instructions: ^[dynamic]Instruction, 
    	dst:          Register, 
    	src:          Register, 
    	src2:         Register, 
    	shift:        Shift_Type, 
    	amount:       u8, 
    ) {…}
    Related Procedure Groups

    emit_adc_r_r_rsr ¶

    emit_adc_r_r_rsr :: proc(
    	instructions: ^[dynamic]Instruction, 
    	dst:          Register, 
    	src:          Register, 
    	src2:         Register, 
    	shift:        Shift_Type, 
    	rs:           Register, 
    ) {…}
    Related Procedure Groups

    emit_adc_rlo_rlo ¶

    emit_adc_rlo_rlo :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}
    Related Procedure Groups

    emit_add_r_r ¶

    emit_add_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}
    Related Procedure Groups

    emit_add_r_r_immm ¶

    emit_add_r_r_immm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}
    Related Procedure Groups

    emit_add_r_r_rsh ¶

    emit_add_r_r_rsh :: proc(
    	instructions: ^[dynamic]Instruction, 
    	dst:          Register, 
    	src:          Register, 
    	src2:         Register, 
    	shift:        Shift_Type, 
    	amount:       u8, 
    ) {…}
    Related Procedure Groups

    emit_add_r_r_rsr ¶

    emit_add_r_r_rsr :: proc(
    	instructions: ^[dynamic]Instruction, 
    	dst:          Register, 
    	src:          Register, 
    	src2:         Register, 
    	shift:        Shift_Type, 
    	rs:           Register, 
    ) {…}
    Related Procedure Groups

    emit_add_rlo_imm8 ¶

    emit_add_rlo_imm8 :: proc(instructions: ^[dynamic]Instruction, dst: Register, imm: i64) {…}
    Related Procedure Groups

    emit_add_rlo_rlo_rlo ¶

    emit_add_rlo_rlo_rlo :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}
    Related Procedure Groups

    emit_adr_rlo_rel ¶

    emit_adr_rlo_rel :: proc(instructions: ^[dynamic]Instruction, dst: Register, offset: i64) {…}

    emit_aesd_q_q ¶

    emit_aesd_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_aese_q_q ¶

    emit_aese_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_aesimc_q_q ¶

    emit_aesimc_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_aesmc_q_q ¶

    emit_aesmc_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_and_r_r_immm ¶

    emit_and_r_r_immm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}
    Related Procedure Groups

    emit_and_r_r_rsh ¶

    emit_and_r_r_rsh :: proc(
    	instructions: ^[dynamic]Instruction, 
    	dst:          Register, 
    	src:          Register, 
    	src2:         Register, 
    	shift:        Shift_Type, 
    	amount:       u8, 
    ) {…}
    Related Procedure Groups

    emit_and_r_r_rsr ¶

    emit_and_r_r_rsr :: proc(
    	instructions: ^[dynamic]Instruction, 
    	dst:          Register, 
    	src:          Register, 
    	src2:         Register, 
    	shift:        Shift_Type, 
    	rs:           Register, 
    ) {…}
    Related Procedure Groups

    emit_and_rlo_rlo ¶

    emit_and_rlo_rlo :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}
    Related Procedure Groups

    emit_asr_r_r_imm5 ¶

    emit_asr_r_r_imm5 :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}
    Related Procedure Groups

    emit_asr_r_r_r ¶

    emit_asr_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}
    Related Procedure Groups

    emit_asr_rlo_rlo ¶

    emit_asr_rlo_rlo :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}
    Related Procedure Groups

    emit_aut_none ¶

    emit_aut_none :: proc(instructions: ^[dynamic]Instruction) {…}

    emit_autg_r_r_r ¶

    emit_autg_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_b_rel ¶

    emit_b_rel :: proc(instructions: ^[dynamic]Instruction, offset: i64) {…}
    Related Procedure Groups

    emit_b_rel_cond ¶

    emit_b_rel_cond :: proc(instructions: ^[dynamic]Instruction, offset: i64, imm: i64) {…}
    Related Procedure Groups

    emit_bf_rel_rel ¶

    emit_bf_rel_rel :: proc(instructions: ^[dynamic]Instruction, offset: i64, offset2: i64) {…}

    emit_bfc_r_imm5_imm5w ¶

    emit_bfc_r_imm5_imm5w :: proc(instructions: ^[dynamic]Instruction, dst: Register, imm: i64, imm2: i64) {…}

    emit_bfcsel_rel_rel_imm4 ¶

    emit_bfcsel_rel_rel_imm4 :: proc(instructions: ^[dynamic]Instruction, offset: i64, offset2: i64, imm: i64) {…}

    emit_bfi_br_rel_r ¶

    emit_bfi_br_rel_r :: proc(instructions: ^[dynamic]Instruction, offset: i64, src: Register) {…}

    emit_bfi_r_r_imm5_imm5w ¶

    emit_bfi_r_r_imm5_imm5w :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64, imm2: i64) {…}

    emit_bfl_rel_rel ¶

    emit_bfl_rel_rel :: proc(instructions: ^[dynamic]Instruction, offset: i64, offset2: i64) {…}

    emit_bflx_rel_r ¶

    emit_bflx_rel_r :: proc(instructions: ^[dynamic]Instruction, offset: i64, src: Register) {…}

    emit_bic_r_r_immm ¶

    emit_bic_r_r_immm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}
    Related Procedure Groups

    emit_bic_r_r_rsh ¶

    emit_bic_r_r_rsh :: proc(
    	instructions: ^[dynamic]Instruction, 
    	dst:          Register, 
    	src:          Register, 
    	src2:         Register, 
    	shift:        Shift_Type, 
    	amount:       u8, 
    ) {…}
    Related Procedure Groups

    emit_bic_r_r_rsr ¶

    emit_bic_r_r_rsr :: proc(
    	instructions: ^[dynamic]Instruction, 
    	dst:          Register, 
    	src:          Register, 
    	src2:         Register, 
    	shift:        Shift_Type, 
    	rs:           Register, 
    ) {…}
    Related Procedure Groups

    emit_bic_rlo_rlo ¶

    emit_bic_rlo_rlo :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}
    Related Procedure Groups

    emit_bkpt_imm ¶

    emit_bkpt_imm :: proc(instructions: ^[dynamic]Instruction, imm: i64) {…}

    emit_bl_rel ¶

    emit_bl_rel :: proc(instructions: ^[dynamic]Instruction, offset: i64) {…}

    emit_blx_r ¶

    emit_blx_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}
    Related Procedure Groups

    emit_blx_rel ¶

    emit_blx_rel :: proc(instructions: ^[dynamic]Instruction, offset: i64) {…}
    Related Procedure Groups

    emit_blxns_r ¶

    emit_blxns_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_bti_none ¶

    emit_bti_none :: proc(instructions: ^[dynamic]Instruction) {…}

    emit_bx_r ¶

    emit_bx_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_bxj_r ¶

    emit_bxj_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_bxns_r ¶

    emit_bxns_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_cbnz_rlo_rel ¶

    emit_cbnz_rlo_rel :: proc(instructions: ^[dynamic]Instruction, dst: Register, offset: i64) {…}

    emit_cbz_rlo_rel ¶

    emit_cbz_rlo_rel :: proc(instructions: ^[dynamic]Instruction, dst: Register, offset: i64) {…}

    emit_cdp2_cpn_cpop_crd_crd ¶

    emit_cdp2_cpn_cpop_crd_crd :: proc(instructions: ^[dynamic]Instruction, dst: Register, imm: i64, src: Register, src2: Register) {…}

    emit_cdp_cpn_cpop_crd_crd ¶

    emit_cdp_cpn_cpop_crd_crd :: proc(instructions: ^[dynamic]Instruction, dst: Register, imm: i64, src: Register, src2: Register) {…}

    emit_clrex_none ¶

    emit_clrex_none :: proc(instructions: ^[dynamic]Instruction) {…}

    emit_clz_r_r ¶

    emit_clz_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_cmn_r_immm ¶

    emit_cmn_r_immm :: proc(instructions: ^[dynamic]Instruction, dst: Register, imm: i64) {…}
    Related Procedure Groups

    emit_cmn_r_rsh ¶

    emit_cmn_r_rsh :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, shift: Shift_Type, amount: u8) {…}
    Related Procedure Groups

    emit_cmn_r_rsr ¶

    emit_cmn_r_rsr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, shift: Shift_Type, rs: Register) {…}
    Related Procedure Groups

    emit_cmn_rlo_rlo ¶

    emit_cmn_rlo_rlo :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}
    Related Procedure Groups

    emit_cmp_r_immm ¶

    emit_cmp_r_immm :: proc(instructions: ^[dynamic]Instruction, dst: Register, imm: i64) {…}
    Related Procedure Groups

    emit_cmp_r_rsh ¶

    emit_cmp_r_rsh :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, shift: Shift_Type, amount: u8) {…}
    Related Procedure Groups

    emit_cmp_r_rsr ¶

    emit_cmp_r_rsr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, shift: Shift_Type, rs: Register) {…}
    Related Procedure Groups

    emit_cmp_rlo_rlo ¶

    emit_cmp_rlo_rlo :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}
    Related Procedure Groups

    emit_cps_ifl ¶

    emit_cps_ifl :: proc(instructions: ^[dynamic]Instruction, imm: i64) {…}

    emit_crc32b_r_r_r ¶

    emit_crc32b_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_crc32cb_r_r_r ¶

    emit_crc32cb_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_crc32ch_r_r_r ¶

    emit_crc32ch_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_crc32cw_r_r_r ¶

    emit_crc32cw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_crc32h_r_r_r ¶

    emit_crc32h_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_crc32w_r_r_r ¶

    emit_crc32w_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_csdb_none ¶

    emit_csdb_none :: proc(instructions: ^[dynamic]Instruction) {…}

    emit_cx1_cp_r_imm ¶

    emit_cx1_cp_r_imm :: proc(instructions: ^[dynamic]Instruction, imm: i64, src: Register, imm2: i64) {…}

    emit_cx1a_cp_r_imm ¶

    emit_cx1a_cp_r_imm :: proc(instructions: ^[dynamic]Instruction, imm: i64, src: Register, imm2: i64) {…}

    emit_cx1d_cp_r_imm ¶

    emit_cx1d_cp_r_imm :: proc(instructions: ^[dynamic]Instruction, imm: i64, src: Register, imm2: i64) {…}

    emit_cx1da_cp_r_imm ¶

    emit_cx1da_cp_r_imm :: proc(instructions: ^[dynamic]Instruction, imm: i64, src: Register, imm2: i64) {…}

    emit_cx2_cp_r_r_imm ¶

    emit_cx2_cp_r_r_imm :: proc(instructions: ^[dynamic]Instruction, imm: i64, src: Register, src2: Register, imm2: i64) {…}

    emit_cx2a_cp_r_r_imm ¶

    emit_cx2a_cp_r_r_imm :: proc(instructions: ^[dynamic]Instruction, imm: i64, src: Register, src2: Register, imm2: i64) {…}

    emit_cx2d_cp_r_r_imm ¶

    emit_cx2d_cp_r_r_imm :: proc(instructions: ^[dynamic]Instruction, imm: i64, src: Register, src2: Register, imm2: i64) {…}

    emit_cx2da_cp_r_r_imm ¶

    emit_cx2da_cp_r_r_imm :: proc(instructions: ^[dynamic]Instruction, imm: i64, src: Register, src2: Register, imm2: i64) {…}

    emit_cx3_cp_r_r_r ¶

    emit_cx3_cp_r_r_r :: proc(instructions: ^[dynamic]Instruction, imm: i64, src: Register, src2: Register, src3: Register) {…}

    emit_cx3a_cp_r_r_r ¶

    emit_cx3a_cp_r_r_r :: proc(instructions: ^[dynamic]Instruction, imm: i64, src: Register, src2: Register, src3: Register) {…}

    emit_cx3d_cp_r_r_r ¶

    emit_cx3d_cp_r_r_r :: proc(instructions: ^[dynamic]Instruction, imm: i64, src: Register, src2: Register, src3: Register) {…}

    emit_cx3da_cp_r_r_r ¶

    emit_cx3da_cp_r_r_r :: proc(instructions: ^[dynamic]Instruction, imm: i64, src: Register, src2: Register, src3: Register) {…}

    emit_dbg_hint ¶

    emit_dbg_hint :: proc(instructions: ^[dynamic]Instruction, imm: i64) {…}

    emit_dcps1_none ¶

    emit_dcps1_none :: proc(instructions: ^[dynamic]Instruction) {…}

    emit_dcps2_none ¶

    emit_dcps2_none :: proc(instructions: ^[dynamic]Instruction) {…}

    emit_dcps3_none ¶

    emit_dcps3_none :: proc(instructions: ^[dynamic]Instruction) {…}

    emit_dls_r ¶

    emit_dls_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_dlstp_r ¶

    emit_dlstp_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_dmb_barr ¶

    emit_dmb_barr :: proc(instructions: ^[dynamic]Instruction, imm: i64) {…}

    emit_dsb_barr ¶

    emit_dsb_barr :: proc(instructions: ^[dynamic]Instruction, imm: i64) {…}

    emit_eor_r_r_immm ¶

    emit_eor_r_r_immm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}
    Related Procedure Groups

    emit_eor_r_r_rsh ¶

    emit_eor_r_r_rsh :: proc(
    	instructions: ^[dynamic]Instruction, 
    	dst:          Register, 
    	src:          Register, 
    	src2:         Register, 
    	shift:        Shift_Type, 
    	amount:       u8, 
    ) {…}
    Related Procedure Groups

    emit_eor_r_r_rsr ¶

    emit_eor_r_r_rsr :: proc(
    	instructions: ^[dynamic]Instruction, 
    	dst:          Register, 
    	src:          Register, 
    	src2:         Register, 
    	shift:        Shift_Type, 
    	rs:           Register, 
    ) {…}
    Related Procedure Groups

    emit_eor_rlo_rlo ¶

    emit_eor_rlo_rlo :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}
    Related Procedure Groups

    emit_eret_none ¶

    emit_eret_none :: proc(instructions: ^[dynamic]Instruction) {…}

    emit_esb_none ¶

    emit_esb_none :: proc(instructions: ^[dynamic]Instruction) {…}

    emit_hint_hint ¶

    emit_hint_hint :: proc(instructions: ^[dynamic]Instruction, imm: i64) {…}

    emit_hlt_imm ¶

    emit_hlt_imm :: proc(instructions: ^[dynamic]Instruction, imm: i64) {…}

    emit_hvc_imm ¶

    emit_hvc_imm :: proc(instructions: ^[dynamic]Instruction, imm: i64) {…}

    emit_isb_barr ¶

    emit_isb_barr :: proc(instructions: ^[dynamic]Instruction, imm: i64) {…}

    emit_it_cond_imm4 ¶

    emit_it_cond_imm4 :: proc(instructions: ^[dynamic]Instruction, imm: i64, imm2: i64) {…}

    emit_lctp_none ¶

    emit_lctp_none :: proc(instructions: ^[dynamic]Instruction) {…}

    emit_lda_r_mem ¶

    emit_lda_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory) {…}

    emit_ldab_r_mem ¶

    emit_ldab_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory) {…}

    emit_ldaex_r_mem ¶

    emit_ldaex_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory) {…}

    emit_ldaexb_r_mem ¶

    emit_ldaexb_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory) {…}

    emit_ldaexd_r_mem ¶

    emit_ldaexd_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory) {…}

    emit_ldaexh_r_mem ¶

    emit_ldaexh_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory) {…}

    emit_ldah_r_mem ¶

    emit_ldah_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory) {…}

    emit_ldc2_cpn_crd_mem ¶

    emit_ldc2_cpn_crd_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Memory) {…}

    emit_ldc_cpn_crd_mem ¶

    emit_ldc_cpn_crd_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Memory) {…}

    emit_ldm_r_list ¶

    emit_ldm_r_list :: proc(instructions: ^[dynamic]Instruction, dst: Register, regs: u16) {…}

    emit_ldr_r_mem ¶

    emit_ldr_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory) {…}

    emit_ldrb_r_mem ¶

    emit_ldrb_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory) {…}

    emit_ldrbt_r_mem ¶

    emit_ldrbt_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory) {…}

    emit_ldrd_r_mem ¶

    emit_ldrd_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory) {…}
    Related Procedure Groups

    emit_ldrd_r_r_mem ¶

    emit_ldrd_r_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Memory) {…}
    Related Procedure Groups

    emit_ldrex_r_mem ¶

    emit_ldrex_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory) {…}

    emit_ldrexb_r_mem ¶

    emit_ldrexb_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory) {…}

    emit_ldrexd_r_mem ¶

    emit_ldrexd_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory) {…}
    Related Procedure Groups

    emit_ldrexd_r_r_mem ¶

    emit_ldrexd_r_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Memory) {…}
    Related Procedure Groups

    emit_ldrexh_r_mem ¶

    emit_ldrexh_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory) {…}

    emit_ldrh_r_mem ¶

    emit_ldrh_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory) {…}

    emit_ldrht_r_mem ¶

    emit_ldrht_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory) {…}

    emit_ldrsb_r_mem ¶

    emit_ldrsb_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory) {…}

    emit_ldrsbt_r_mem ¶

    emit_ldrsbt_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory) {…}

    emit_ldrsh_r_mem ¶

    emit_ldrsh_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory) {…}

    emit_ldrsht_r_mem ¶

    emit_ldrsht_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory) {…}

    emit_ldrt_r_mem ¶

    emit_ldrt_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory) {…}

    emit_le_rel ¶

    emit_le_rel :: proc(instructions: ^[dynamic]Instruction, offset: i64) {…}

    emit_letp_rel ¶

    emit_letp_rel :: proc(instructions: ^[dynamic]Instruction, offset: i64) {…}

    emit_lsl_r_r_imm5 ¶

    emit_lsl_r_r_imm5 :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}
    Related Procedure Groups

    emit_lsl_r_r_r ¶

    emit_lsl_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}
    Related Procedure Groups

    emit_lsl_rlo_rlo ¶

    emit_lsl_rlo_rlo :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}
    Related Procedure Groups

    emit_lsr_r_r_imm5 ¶

    emit_lsr_r_r_imm5 :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}
    Related Procedure Groups

    emit_lsr_r_r_r ¶

    emit_lsr_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}
    Related Procedure Groups

    emit_lsr_rlo_rlo ¶

    emit_lsr_rlo_rlo :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}
    Related Procedure Groups

    emit_mcr2_cpn_cpop_r_crd ¶

    emit_mcr2_cpn_cpop_r_crd :: proc(instructions: ^[dynamic]Instruction, dst: Register, imm: i64, src: Register, src2: Register) {…}

    emit_mcr_cpn_cpop_r_crd ¶

    emit_mcr_cpn_cpop_r_crd :: proc(instructions: ^[dynamic]Instruction, dst: Register, imm: i64, src: Register, src2: Register) {…}

    emit_mcrr2_cpn_cpop_r_r ¶

    emit_mcrr2_cpn_cpop_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, imm: i64, src: Register, src2: Register) {…}

    emit_mcrr_cpn_cpop_r_r ¶

    emit_mcrr_cpn_cpop_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, imm: i64, src: Register, src2: Register) {…}

    emit_mla_r_r_r_r ¶

    emit_mla_r_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_mls_r_r_r_r ¶

    emit_mls_r_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_mov_r_immm ¶

    emit_mov_r_immm :: proc(instructions: ^[dynamic]Instruction, dst: Register, imm: i64) {…}
    Related Procedure Groups

    emit_mov_r_r ¶

    emit_mov_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}
    Related Procedure Groups

    emit_mov_r_rsh ¶

    emit_mov_r_rsh :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, shift: Shift_Type, amount: u8) {…}
    Related Procedure Groups

    emit_mov_r_rsr ¶

    emit_mov_r_rsr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, shift: Shift_Type, rs: Register) {…}
    Related Procedure Groups

    emit_movt_r_imm16 ¶

    emit_movt_r_imm16 :: proc(instructions: ^[dynamic]Instruction, dst: Register, imm: i64) {…}

    emit_movw_r_imm16 ¶

    emit_movw_r_imm16 :: proc(instructions: ^[dynamic]Instruction, dst: Register, imm: i64) {…}

    emit_mrc2_cpn_cpop_r_crd ¶

    emit_mrc2_cpn_cpop_r_crd :: proc(instructions: ^[dynamic]Instruction, dst: Register, imm: i64, src: Register, src2: Register) {…}

    emit_mrc_cpn_cpop_r_crd ¶

    emit_mrc_cpn_cpop_r_crd :: proc(instructions: ^[dynamic]Instruction, dst: Register, imm: i64, src: Register, src2: Register) {…}

    emit_mrrc2_cpn_cpop_r_r ¶

    emit_mrrc2_cpn_cpop_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, imm: i64, src: Register, src2: Register) {…}

    emit_mrrc_cpn_cpop_r_r ¶

    emit_mrrc_cpn_cpop_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, imm: i64, src: Register, src2: Register) {…}

    emit_mrs_r_psr ¶

    emit_mrs_r_psr :: proc(instructions: ^[dynamic]Instruction, dst: Register, imm: i64) {…}

    emit_msr_psr_immm ¶

    emit_msr_psr_immm :: proc(instructions: ^[dynamic]Instruction, imm: i64, imm2: i64) {…}
    Related Procedure Groups

    emit_msr_psr_r ¶

    emit_msr_psr_r :: proc(instructions: ^[dynamic]Instruction, imm: i64, src: Register) {…}
    Related Procedure Groups

    emit_mul_r_r_r ¶

    emit_mul_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}
    Related Procedure Groups

    emit_mul_rlo_rlo ¶

    emit_mul_rlo_rlo :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}
    Related Procedure Groups

    emit_mvn_r_immm ¶

    emit_mvn_r_immm :: proc(instructions: ^[dynamic]Instruction, dst: Register, imm: i64) {…}
    Related Procedure Groups

    emit_mvn_r_rsh ¶

    emit_mvn_r_rsh :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, shift: Shift_Type, amount: u8) {…}
    Related Procedure Groups

    emit_mvn_r_rsr ¶

    emit_mvn_r_rsr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, shift: Shift_Type, rs: Register) {…}
    Related Procedure Groups

    emit_mvn_rlo_rlo ¶

    emit_mvn_rlo_rlo :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}
    Related Procedure Groups

    emit_neg_rlo_rlo ¶

    emit_neg_rlo_rlo :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_nop_none ¶

    emit_nop_none :: proc(instructions: ^[dynamic]Instruction) {…}

    emit_orr_r_r_immm ¶

    emit_orr_r_r_immm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}
    Related Procedure Groups

    emit_orr_r_r_rsh ¶

    emit_orr_r_r_rsh :: proc(
    	instructions: ^[dynamic]Instruction, 
    	dst:          Register, 
    	src:          Register, 
    	src2:         Register, 
    	shift:        Shift_Type, 
    	amount:       u8, 
    ) {…}
    Related Procedure Groups

    emit_orr_r_r_rsr ¶

    emit_orr_r_r_rsr :: proc(
    	instructions: ^[dynamic]Instruction, 
    	dst:          Register, 
    	src:          Register, 
    	src2:         Register, 
    	shift:        Shift_Type, 
    	rs:           Register, 
    ) {…}
    Related Procedure Groups

    emit_orr_rlo_rlo ¶

    emit_orr_rlo_rlo :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}
    Related Procedure Groups

    emit_pac_none ¶

    emit_pac_none :: proc(instructions: ^[dynamic]Instruction) {…}

    emit_pacbti_none ¶

    emit_pacbti_none :: proc(instructions: ^[dynamic]Instruction) {…}

    emit_pkhbt_r_r_rsh ¶

    emit_pkhbt_r_r_rsh :: proc(
    	instructions: ^[dynamic]Instruction, 
    	dst:          Register, 
    	src:          Register, 
    	src2:         Register, 
    	shift:        Shift_Type, 
    	amount:       u8, 
    ) {…}

    emit_pkhtb_r_r_rsh ¶

    emit_pkhtb_r_r_rsh :: proc(
    	instructions: ^[dynamic]Instruction, 
    	dst:          Register, 
    	src:          Register, 
    	src2:         Register, 
    	shift:        Shift_Type, 
    	amount:       u8, 
    ) {…}

    emit_pld_mem ¶

    emit_pld_mem :: proc(instructions: ^[dynamic]Instruction, dst: Memory) {…}

    emit_pldw_mem ¶

    emit_pldw_mem :: proc(instructions: ^[dynamic]Instruction, dst: Memory) {…}

    emit_pli_mem ¶

    emit_pli_mem :: proc(instructions: ^[dynamic]Instruction, dst: Memory) {…}

    emit_pop_list ¶

    emit_pop_list :: proc(instructions: ^[dynamic]Instruction, regs: u16) {…}

    emit_psb_csync_none ¶

    emit_psb_csync_none :: proc(instructions: ^[dynamic]Instruction) {…}

    emit_push_list ¶

    emit_push_list :: proc(instructions: ^[dynamic]Instruction, regs: u16) {…}

    emit_qadd16_r_r_r ¶

    emit_qadd16_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_qadd8_r_r_r ¶

    emit_qadd8_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_qadd_r_r_r ¶

    emit_qadd_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_qasx_r_r_r ¶

    emit_qasx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_qdadd_r_r_r ¶

    emit_qdadd_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_qdsub_r_r_r ¶

    emit_qdsub_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_qsax_r_r_r ¶

    emit_qsax_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_qsub16_r_r_r ¶

    emit_qsub16_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_qsub8_r_r_r ¶

    emit_qsub8_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_qsub_r_r_r ¶

    emit_qsub_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_rbit_r_r ¶

    emit_rbit_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_rev16_r_r ¶

    emit_rev16_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_rev_r_r ¶

    emit_rev_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_revsh_r_r ¶

    emit_revsh_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_rfe_r ¶

    emit_rfe_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_ror_r_r_imm5 ¶

    emit_ror_r_r_imm5 :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}
    Related Procedure Groups

    emit_ror_r_r_r ¶

    emit_ror_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}
    Related Procedure Groups

    emit_ror_rlo_rlo ¶

    emit_ror_rlo_rlo :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}
    Related Procedure Groups

    emit_rrx_r_r ¶

    emit_rrx_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_rsb_r_r_immm ¶

    emit_rsb_r_r_immm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}
    Related Procedure Groups

    emit_rsb_r_r_rsh ¶

    emit_rsb_r_r_rsh :: proc(
    	instructions: ^[dynamic]Instruction, 
    	dst:          Register, 
    	src:          Register, 
    	src2:         Register, 
    	shift:        Shift_Type, 
    	amount:       u8, 
    ) {…}
    Related Procedure Groups

    emit_rsb_r_r_rsr ¶

    emit_rsb_r_r_rsr :: proc(
    	instructions: ^[dynamic]Instruction, 
    	dst:          Register, 
    	src:          Register, 
    	src2:         Register, 
    	shift:        Shift_Type, 
    	rs:           Register, 
    ) {…}
    Related Procedure Groups

    emit_rsc_r_r_immm ¶

    emit_rsc_r_r_immm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}
    Related Procedure Groups

    emit_rsc_r_r_rsh ¶

    emit_rsc_r_r_rsh :: proc(
    	instructions: ^[dynamic]Instruction, 
    	dst:          Register, 
    	src:          Register, 
    	src2:         Register, 
    	shift:        Shift_Type, 
    	amount:       u8, 
    ) {…}
    Related Procedure Groups

    emit_rsc_r_r_rsr ¶

    emit_rsc_r_r_rsr :: proc(
    	instructions: ^[dynamic]Instruction, 
    	dst:          Register, 
    	src:          Register, 
    	src2:         Register, 
    	shift:        Shift_Type, 
    	rs:           Register, 
    ) {…}
    Related Procedure Groups

    emit_sadd16_r_r_r ¶

    emit_sadd16_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sadd8_r_r_r ¶

    emit_sadd8_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sasx_r_r_r ¶

    emit_sasx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sb_none ¶

    emit_sb_none :: proc(instructions: ^[dynamic]Instruction) {…}

    emit_sbc_r_r_immm ¶

    emit_sbc_r_r_immm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}
    Related Procedure Groups

    emit_sbc_r_r_rsh ¶

    emit_sbc_r_r_rsh :: proc(
    	instructions: ^[dynamic]Instruction, 
    	dst:          Register, 
    	src:          Register, 
    	src2:         Register, 
    	shift:        Shift_Type, 
    	amount:       u8, 
    ) {…}
    Related Procedure Groups

    emit_sbc_r_r_rsr ¶

    emit_sbc_r_r_rsr :: proc(
    	instructions: ^[dynamic]Instruction, 
    	dst:          Register, 
    	src:          Register, 
    	src2:         Register, 
    	shift:        Shift_Type, 
    	rs:           Register, 
    ) {…}
    Related Procedure Groups

    emit_sbc_rlo_rlo ¶

    emit_sbc_rlo_rlo :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}
    Related Procedure Groups

    emit_sbfx_r_r_imm5_imm5w ¶

    emit_sbfx_r_r_imm5_imm5w :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64, imm2: i64) {…}

    emit_sdiv_r_r_r ¶

    emit_sdiv_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sel_r_r_r ¶

    emit_sel_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_setend_end ¶

    emit_setend_end :: proc(instructions: ^[dynamic]Instruction, imm: i64) {…}

    emit_setpan_hint ¶

    emit_setpan_hint :: proc(instructions: ^[dynamic]Instruction, imm: i64) {…}

    emit_sev_none ¶

    emit_sev_none :: proc(instructions: ^[dynamic]Instruction) {…}

    emit_sevl_none ¶

    emit_sevl_none :: proc(instructions: ^[dynamic]Instruction) {…}

    emit_sg_none ¶

    emit_sg_none :: proc(instructions: ^[dynamic]Instruction) {…}

    emit_sha1c_q_q_q ¶

    emit_sha1c_q_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sha1h_q_q ¶

    emit_sha1h_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_sha1m_q_q_q ¶

    emit_sha1m_q_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sha1p_q_q_q ¶

    emit_sha1p_q_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sha1su0_q_q_q ¶

    emit_sha1su0_q_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sha1su1_q_q ¶

    emit_sha1su1_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_sha256h2_q_q_q ¶

    emit_sha256h2_q_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sha256h_q_q_q ¶

    emit_sha256h_q_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sha256su0_q_q ¶

    emit_sha256su0_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_sha256su1_q_q_q ¶

    emit_sha256su1_q_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_shadd16_r_r_r ¶

    emit_shadd16_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_shadd8_r_r_r ¶

    emit_shadd8_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_shasx_r_r_r ¶

    emit_shasx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_shsax_r_r_r ¶

    emit_shsax_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_shsub16_r_r_r ¶

    emit_shsub16_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_shsub8_r_r_r ¶

    emit_shsub8_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_smc_imm ¶

    emit_smc_imm :: proc(instructions: ^[dynamic]Instruction, imm: i64) {…}

    emit_smlabb_r_r_r_r ¶

    emit_smlabb_r_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_smlabt_r_r_r_r ¶

    emit_smlabt_r_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_smlad_r_r_r_r ¶

    emit_smlad_r_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_smladx_r_r_r_r ¶

    emit_smladx_r_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_smlal_r_r_r_r ¶

    emit_smlal_r_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_smlalbb_r_r_r_r ¶

    emit_smlalbb_r_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_smlalbt_r_r_r_r ¶

    emit_smlalbt_r_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_smlald_r_r_r_r ¶

    emit_smlald_r_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_smlaldx_r_r_r_r ¶

    emit_smlaldx_r_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_smlaltb_r_r_r_r ¶

    emit_smlaltb_r_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_smlaltt_r_r_r_r ¶

    emit_smlaltt_r_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_smlatb_r_r_r_r ¶

    emit_smlatb_r_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_smlatt_r_r_r_r ¶

    emit_smlatt_r_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_smlawb_r_r_r_r ¶

    emit_smlawb_r_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_smlawt_r_r_r_r ¶

    emit_smlawt_r_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_smlsd_r_r_r_r ¶

    emit_smlsd_r_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_smlsdx_r_r_r_r ¶

    emit_smlsdx_r_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_smlsld_r_r_r_r ¶

    emit_smlsld_r_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_smlsldx_r_r_r_r ¶

    emit_smlsldx_r_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_smmla_r_r_r_r ¶

    emit_smmla_r_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_smmlar_r_r_r_r ¶

    emit_smmlar_r_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_smmls_r_r_r_r ¶

    emit_smmls_r_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_smmlsr_r_r_r_r ¶

    emit_smmlsr_r_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_smmul_r_r_r ¶

    emit_smmul_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_smmulr_r_r_r ¶

    emit_smmulr_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_smuad_r_r_r ¶

    emit_smuad_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_smuadx_r_r_r ¶

    emit_smuadx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_smulbb_r_r_r ¶

    emit_smulbb_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_smulbt_r_r_r ¶

    emit_smulbt_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_smull_r_r_r_r ¶

    emit_smull_r_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_smultb_r_r_r ¶

    emit_smultb_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_smultt_r_r_r ¶

    emit_smultt_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_smulwb_r_r_r ¶

    emit_smulwb_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_smulwt_r_r_r ¶

    emit_smulwt_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_smusd_r_r_r ¶

    emit_smusd_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_smusdx_r_r_r ¶

    emit_smusdx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_srs_imm ¶

    emit_srs_imm :: proc(instructions: ^[dynamic]Instruction, imm: i64) {…}

    emit_ssat16_r_imm4s_r ¶

    emit_ssat16_r_imm4s_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, imm: i64, src: Register) {…}

    emit_ssat_r_imm4s_rsh ¶

    emit_ssat_r_imm4s_rsh :: proc(
    	instructions: ^[dynamic]Instruction, 
    	dst:          Register, 
    	imm:          i64, 
    	src:          Register, 
    	shift:        Shift_Type, 
    	amount:       u8, 
    ) {…}

    emit_ssax_r_r_r ¶

    emit_ssax_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_ssub16_r_r_r ¶

    emit_ssub16_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_ssub8_r_r_r ¶

    emit_ssub8_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stc2_cpn_crd_mem ¶

    emit_stc2_cpn_crd_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Memory) {…}

    emit_stc_cpn_crd_mem ¶

    emit_stc_cpn_crd_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Memory) {…}

    emit_stl_r_mem ¶

    emit_stl_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory) {…}

    emit_stlb_r_mem ¶

    emit_stlb_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory) {…}

    emit_stlex_r_r_mem ¶

    emit_stlex_r_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Memory) {…}

    emit_stlexb_r_r_mem ¶

    emit_stlexb_r_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Memory) {…}

    emit_stlexd_r_r_mem ¶

    emit_stlexd_r_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Memory) {…}

    emit_stlexh_r_r_mem ¶

    emit_stlexh_r_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Memory) {…}

    emit_stlh_r_mem ¶

    emit_stlh_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory) {…}

    emit_stm_r_list ¶

    emit_stm_r_list :: proc(instructions: ^[dynamic]Instruction, dst: Register, regs: u16) {…}

    emit_str_r_mem ¶

    emit_str_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory) {…}

    emit_strb_r_mem ¶

    emit_strb_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory) {…}

    emit_strbt_r_mem ¶

    emit_strbt_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory) {…}

    emit_strd_r_mem ¶

    emit_strd_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory) {…}
    Related Procedure Groups

    emit_strd_r_r_mem ¶

    emit_strd_r_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Memory) {…}
    Related Procedure Groups

    emit_strex_r_r_mem ¶

    emit_strex_r_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Memory) {…}

    emit_strexb_r_r_mem ¶

    emit_strexb_r_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Memory) {…}

    emit_strexd_r_r_mem ¶

    emit_strexd_r_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Memory) {…}
    Related Procedure Groups

    emit_strexd_r_r_r_mem ¶

    emit_strexd_r_r_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Memory) {…}
    Related Procedure Groups

    emit_strexh_r_r_mem ¶

    emit_strexh_r_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Memory) {…}

    emit_strh_r_mem ¶

    emit_strh_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory) {…}

    emit_strht_r_mem ¶

    emit_strht_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory) {…}

    emit_strt_r_mem ¶

    emit_strt_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory) {…}

    emit_sub_r_r_immm ¶

    emit_sub_r_r_immm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}
    Related Procedure Groups

    emit_sub_r_r_rsh ¶

    emit_sub_r_r_rsh :: proc(
    	instructions: ^[dynamic]Instruction, 
    	dst:          Register, 
    	src:          Register, 
    	src2:         Register, 
    	shift:        Shift_Type, 
    	amount:       u8, 
    ) {…}
    Related Procedure Groups

    emit_sub_r_r_rsr ¶

    emit_sub_r_r_rsr :: proc(
    	instructions: ^[dynamic]Instruction, 
    	dst:          Register, 
    	src:          Register, 
    	src2:         Register, 
    	shift:        Shift_Type, 
    	rs:           Register, 
    ) {…}
    Related Procedure Groups

    emit_sub_rlo_imm8 ¶

    emit_sub_rlo_imm8 :: proc(instructions: ^[dynamic]Instruction, dst: Register, imm: i64) {…}
    Related Procedure Groups

    emit_sub_rlo_rlo_rlo ¶

    emit_sub_rlo_rlo_rlo :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}
    Related Procedure Groups

    emit_svc_imm ¶

    emit_svc_imm :: proc(instructions: ^[dynamic]Instruction, imm: i64) {…}

    emit_swp_r_r_r ¶

    emit_swp_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_swpb_r_r_r ¶

    emit_swpb_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sxtab16_r_r_r ¶

    emit_sxtab16_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sxtab_r_r_r ¶

    emit_sxtab_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sxtah_r_r_r ¶

    emit_sxtah_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sxtb16_r_r ¶

    emit_sxtb16_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_sxtb_r_r ¶

    emit_sxtb_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_sxth_r_r ¶

    emit_sxth_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_tbb_r_r ¶

    emit_tbb_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_tbh_r_r ¶

    emit_tbh_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_teq_r_immm ¶

    emit_teq_r_immm :: proc(instructions: ^[dynamic]Instruction, dst: Register, imm: i64) {…}
    Related Procedure Groups

    emit_teq_r_rsh ¶

    emit_teq_r_rsh :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, shift: Shift_Type, amount: u8) {…}
    Related Procedure Groups

    emit_teq_r_rsr ¶

    emit_teq_r_rsr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, shift: Shift_Type, rs: Register) {…}
    Related Procedure Groups

    emit_tsb_csync_none ¶

    emit_tsb_csync_none :: proc(instructions: ^[dynamic]Instruction) {…}

    emit_tst_r_immm ¶

    emit_tst_r_immm :: proc(instructions: ^[dynamic]Instruction, dst: Register, imm: i64) {…}
    Related Procedure Groups

    emit_tst_r_rsh ¶

    emit_tst_r_rsh :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, shift: Shift_Type, amount: u8) {…}
    Related Procedure Groups

    emit_tst_r_rsr ¶

    emit_tst_r_rsr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, shift: Shift_Type, rs: Register) {…}
    Related Procedure Groups

    emit_tst_rlo_rlo ¶

    emit_tst_rlo_rlo :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}
    Related Procedure Groups

    emit_tt_r_r ¶

    emit_tt_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_tta_r_r ¶

    emit_tta_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_ttat_r_r ¶

    emit_ttat_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_ttt_r_r ¶

    emit_ttt_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_uadd16_r_r_r ¶

    emit_uadd16_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_uadd8_r_r_r ¶

    emit_uadd8_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_uasx_r_r_r ¶

    emit_uasx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_ubfx_r_r_imm5_imm5w ¶

    emit_ubfx_r_r_imm5_imm5w :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64, imm2: i64) {…}

    emit_udf_imm ¶

    emit_udf_imm :: proc(instructions: ^[dynamic]Instruction, imm: i64) {…}

    emit_udiv_r_r_r ¶

    emit_udiv_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_uhadd16_r_r_r ¶

    emit_uhadd16_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_uhadd8_r_r_r ¶

    emit_uhadd8_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_uhasx_r_r_r ¶

    emit_uhasx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_uhsax_r_r_r ¶

    emit_uhsax_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_uhsub16_r_r_r ¶

    emit_uhsub16_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_uhsub8_r_r_r ¶

    emit_uhsub8_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_umaal_r_r_r_r ¶

    emit_umaal_r_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_umlal_r_r_r_r ¶

    emit_umlal_r_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_umull_r_r_r_r ¶

    emit_umull_r_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_uqadd16_r_r_r ¶

    emit_uqadd16_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_uqadd8_r_r_r ¶

    emit_uqadd8_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_uqasx_r_r_r ¶

    emit_uqasx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_uqsax_r_r_r ¶

    emit_uqsax_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_uqsub16_r_r_r ¶

    emit_uqsub16_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_uqsub8_r_r_r ¶

    emit_uqsub8_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_usad8_r_r_r ¶

    emit_usad8_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_usada8_r_r_r_r ¶

    emit_usada8_r_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_usat16_r_imm4s_r ¶

    emit_usat16_r_imm4s_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, imm: i64, src: Register) {…}

    emit_usat_r_imm4s_rsh ¶

    emit_usat_r_imm4s_rsh :: proc(
    	instructions: ^[dynamic]Instruction, 
    	dst:          Register, 
    	imm:          i64, 
    	src:          Register, 
    	shift:        Shift_Type, 
    	amount:       u8, 
    ) {…}

    emit_usax_r_r_r ¶

    emit_usax_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_usub16_r_r_r ¶

    emit_usub16_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_usub8_r_r_r ¶

    emit_usub8_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_uxtab16_r_r_r ¶

    emit_uxtab16_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_uxtab_r_r_r ¶

    emit_uxtab_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_uxtah_r_r_r ¶

    emit_uxtah_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_uxtb16_r_r ¶

    emit_uxtb16_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_uxtb_r_r ¶

    emit_uxtb_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_uxth_r_r ¶

    emit_uxth_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vaba_d_d_d ¶

    emit_vaba_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vabal_q_d_d ¶

    emit_vabal_q_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vabav_r_q_q ¶

    emit_vabav_r_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vabd_d_d_d ¶

    emit_vabd_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vabdl_q_d_d ¶

    emit_vabdl_q_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vabs_s_s ¶

    emit_vabs_s_s :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vacge_d_d_d ¶

    emit_vacge_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vacgt_d_d_d ¶

    emit_vacgt_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vacle_d_d_d ¶

    emit_vacle_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vaclt_d_d_d ¶

    emit_vaclt_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vadd_s_s_s ¶

    emit_vadd_s_s_s :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vaddl_q_d_d ¶

    emit_vaddl_q_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vaddlv_r_r_q ¶

    emit_vaddlv_r_r_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vaddlva_r_r_q ¶

    emit_vaddlva_r_r_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vaddv_r_q ¶

    emit_vaddv_r_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vaddva_r_q ¶

    emit_vaddva_r_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vaddw_q_q_d ¶

    emit_vaddw_q_q_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vand_d_d_d ¶

    emit_vand_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vbic_d_d_d ¶

    emit_vbic_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vbif_d_d_d ¶

    emit_vbif_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vbit_d_d_d ¶

    emit_vbit_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vbrsr_q_q_r ¶

    emit_vbrsr_q_q_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vbsl_d_d_d ¶

    emit_vbsl_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vcadd_d_d_d_imm ¶

    emit_vcadd_d_d_d_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, imm: i64) {…}

    emit_vceq_d_d_d ¶

    emit_vceq_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vceq_z_d_d ¶

    emit_vceq_z_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vcge_d_d_d ¶

    emit_vcge_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vcge_z_d_d ¶

    emit_vcge_z_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vcgt_d_d_d ¶

    emit_vcgt_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vcgt_z_d_d ¶

    emit_vcgt_z_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vcle_d_d_d ¶

    emit_vcle_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vcle_z_d_d ¶

    emit_vcle_z_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vcls_d_d ¶

    emit_vcls_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vclt_d_d_d ¶

    emit_vclt_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vclt_z_d_d ¶

    emit_vclt_z_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vclz_d_d ¶

    emit_vclz_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vcmla_d_d_d_imm ¶

    emit_vcmla_d_d_d_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, imm: i64) {…}

    emit_vcmla_lane_d_d_dlane_imm ¶

    emit_vcmla_lane_d_d_dlane_imm :: proc(
    	instructions: ^[dynamic]Instruction, 
    	dst:          Register, 
    	src:          Register, 
    	src2:         Register, 
    	lane:         u8, 
    	imm:          i64, 
    ) {…}

    emit_vcmla_mve_q_q_q_imm ¶

    emit_vcmla_mve_q_q_q_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, imm: i64) {…}

    emit_vcmp_s ¶

    emit_vcmp_s :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}
    Related Procedure Groups

    emit_vcmp_s_s ¶

    emit_vcmp_s_s :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}
    Related Procedure Groups

    emit_vcmpe_s ¶

    emit_vcmpe_s :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}
    Related Procedure Groups

    emit_vcmpe_s_s ¶

    emit_vcmpe_s_s :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}
    Related Procedure Groups

    emit_vcmul_q_q_q ¶

    emit_vcmul_q_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vcnt_d_d ¶

    emit_vcnt_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vctp_r ¶

    emit_vctp_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_vcvt_bf16_d_q ¶

    emit_vcvt_bf16_d_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vcvt_d_s ¶

    emit_vcvt_d_s :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vcvt_fixed_s_s_imm ¶

    emit_vcvt_fixed_s_s_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_vcvta_s_s ¶

    emit_vcvta_s_s :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vcvtb_s_s ¶

    emit_vcvtb_s_s :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vcvtm_s_s ¶

    emit_vcvtm_s_s :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vcvtn_s_s ¶

    emit_vcvtn_s_s :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vcvtp_s_s ¶

    emit_vcvtp_s_s :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vcvtr_s_s ¶

    emit_vcvtr_s_s :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vcvtt_s_s ¶

    emit_vcvtt_s_s :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vcx1_cp_s_imm ¶

    emit_vcx1_cp_s_imm :: proc(instructions: ^[dynamic]Instruction, imm: i64, src: Register, imm2: i64) {…}

    emit_vcx1a_cp_s_imm ¶

    emit_vcx1a_cp_s_imm :: proc(instructions: ^[dynamic]Instruction, imm: i64, src: Register, imm2: i64) {…}

    emit_vcx2_cp_s_s_imm ¶

    emit_vcx2_cp_s_s_imm :: proc(instructions: ^[dynamic]Instruction, imm: i64, src: Register, src2: Register, imm2: i64) {…}

    emit_vcx2a_cp_s_s_imm ¶

    emit_vcx2a_cp_s_s_imm :: proc(instructions: ^[dynamic]Instruction, imm: i64, src: Register, src2: Register, imm2: i64) {…}

    emit_vcx3_cp_s_s_s ¶

    emit_vcx3_cp_s_s_s :: proc(instructions: ^[dynamic]Instruction, imm: i64, src: Register, src2: Register, src3: Register) {…}

    emit_vcx3a_cp_s_s_s ¶

    emit_vcx3a_cp_s_s_s :: proc(instructions: ^[dynamic]Instruction, imm: i64, src: Register, src2: Register, src3: Register) {…}

    emit_vddup_q_r_imm ¶

    emit_vddup_q_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_vdiv_s_s_s ¶

    emit_vdiv_s_s_s :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vdot_bf16_d_d_d ¶

    emit_vdot_bf16_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vdup_d_dlane ¶

    emit_vdup_d_dlane :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, lane: u8) {…}
    Related Procedure Groups

    emit_vdup_d_r ¶

    emit_vdup_d_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}
    Related Procedure Groups

    emit_vdwdup_q_r_r_imm ¶

    emit_vdwdup_q_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, imm: i64) {…}

    emit_veor_d_d_d ¶

    emit_veor_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vext_d_d_d_imm4 ¶

    emit_vext_d_d_d_imm4 :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, imm: i64) {…}

    emit_vfma_bf16_q_q_q ¶

    emit_vfma_bf16_q_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vfma_lane_d_d_dlane ¶

    emit_vfma_lane_d_d_dlane :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, lane: u8) {…}

    emit_vfma_s_s_s ¶

    emit_vfma_s_s_s :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vfmal_d_d_d ¶

    emit_vfmal_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vfms_lane_d_d_dlane ¶

    emit_vfms_lane_d_d_dlane :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, lane: u8) {…}

    emit_vfms_s_s_s ¶

    emit_vfms_s_s_s :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vfmsl_d_d_d ¶

    emit_vfmsl_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vfnma_s_s_s ¶

    emit_vfnma_s_s_s :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vfnms_s_s_s ¶

    emit_vfnms_s_s_s :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vhadd_d_d_d ¶

    emit_vhadd_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vhcadd_q_q_q ¶

    emit_vhcadd_q_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vhcadd_sat_q_q_q_imm ¶

    emit_vhcadd_sat_q_q_q_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, imm: i64) {…}

    emit_vhsub_d_d_d ¶

    emit_vhsub_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vidup_q_r_imm ¶

    emit_vidup_q_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_vins_s_s ¶

    emit_vins_s_s :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_viwdup_q_r_r_imm ¶

    emit_viwdup_q_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, imm: i64) {…}

    emit_vjcvt_s_d ¶

    emit_vjcvt_s_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vld1_dlane_mem ¶

    emit_vld1_dlane_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, lane: u8, src: Memory) {…}
    Related Procedure Groups

    emit_vld1_dlist_mem ¶

    emit_vld1_dlist_mem :: proc(instructions: ^[dynamic]Instruction, regs: u16, src: Memory) {…}
    Related Procedure Groups

    emit_vld1_lane_dlane_mem ¶

    emit_vld1_lane_dlane_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, lane: u8, src: Memory) {…}

    emit_vld20_qlist_mem ¶

    emit_vld20_qlist_mem :: proc(instructions: ^[dynamic]Instruction, regs: u16, src: Memory) {…}

    emit_vld21_qlist_mem ¶

    emit_vld21_qlist_mem :: proc(instructions: ^[dynamic]Instruction, regs: u16, src: Memory) {…}

    emit_vld2_dlist_mem ¶

    emit_vld2_dlist_mem :: proc(instructions: ^[dynamic]Instruction, regs: u16, src: Memory) {…}

    emit_vld2_lane_dlist_mem ¶

    emit_vld2_lane_dlist_mem :: proc(instructions: ^[dynamic]Instruction, regs: u16, src: Memory) {…}

    emit_vld2r_dlist_mem ¶

    emit_vld2r_dlist_mem :: proc(instructions: ^[dynamic]Instruction, regs: u16, src: Memory) {…}

    emit_vld3_dlist_mem ¶

    emit_vld3_dlist_mem :: proc(instructions: ^[dynamic]Instruction, regs: u16, src: Memory) {…}

    emit_vld3_lane_dlist_mem ¶

    emit_vld3_lane_dlist_mem :: proc(instructions: ^[dynamic]Instruction, regs: u16, src: Memory) {…}

    emit_vld3r_dlist_mem ¶

    emit_vld3r_dlist_mem :: proc(instructions: ^[dynamic]Instruction, regs: u16, src: Memory) {…}

    emit_vld40_qlist_mem ¶

    emit_vld40_qlist_mem :: proc(instructions: ^[dynamic]Instruction, regs: u16, src: Memory) {…}

    emit_vld41_qlist_mem ¶

    emit_vld41_qlist_mem :: proc(instructions: ^[dynamic]Instruction, regs: u16, src: Memory) {…}

    emit_vld42_qlist_mem ¶

    emit_vld42_qlist_mem :: proc(instructions: ^[dynamic]Instruction, regs: u16, src: Memory) {…}

    emit_vld43_qlist_mem ¶

    emit_vld43_qlist_mem :: proc(instructions: ^[dynamic]Instruction, regs: u16, src: Memory) {…}

    emit_vld4_dlist_mem ¶

    emit_vld4_dlist_mem :: proc(instructions: ^[dynamic]Instruction, regs: u16, src: Memory) {…}

    emit_vld4_lane_dlist_mem ¶

    emit_vld4_lane_dlist_mem :: proc(instructions: ^[dynamic]Instruction, regs: u16, src: Memory) {…}

    emit_vld4r_dlist_mem ¶

    emit_vld4r_dlist_mem :: proc(instructions: ^[dynamic]Instruction, regs: u16, src: Memory) {…}

    emit_vldm_r_slist ¶

    emit_vldm_r_slist :: proc(instructions: ^[dynamic]Instruction, dst: Register, regs: u16) {…}

    emit_vldr_s_mem ¶

    emit_vldr_s_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory) {…}

    emit_vldrb_gather_q_mem_q ¶

    emit_vldrb_gather_q_mem_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory, src2: Register) {…}

    emit_vldrb_q_mem ¶

    emit_vldrb_q_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory) {…}

    emit_vldrd_gather_q_mem_q ¶

    emit_vldrd_gather_q_mem_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory, src2: Register) {…}

    emit_vldrd_q_mem ¶

    emit_vldrd_q_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory) {…}

    emit_vldrh_gather_q_mem_q ¶

    emit_vldrh_gather_q_mem_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory, src2: Register) {…}

    emit_vldrh_q_mem ¶

    emit_vldrh_q_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory) {…}

    emit_vldrw_gather_q_mem_q ¶

    emit_vldrw_gather_q_mem_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory, src2: Register) {…}

    emit_vldrw_q_mem ¶

    emit_vldrw_q_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory) {…}

    emit_vmax_d_d_d ¶

    emit_vmax_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vmaxav_r_q ¶

    emit_vmaxav_r_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vmaxnm_s_s_s ¶

    emit_vmaxnm_s_s_s :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vmaxnmav_r_q ¶

    emit_vmaxnmav_r_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vmaxnmv_r_q ¶

    emit_vmaxnmv_r_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vmaxv_r_q ¶

    emit_vmaxv_r_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vmin_d_d_d ¶

    emit_vmin_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vminav_r_q ¶

    emit_vminav_r_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vminnm_s_s_s ¶

    emit_vminnm_s_s_s :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vminnmav_r_q ¶

    emit_vminnmav_r_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vminnmv_r_q ¶

    emit_vminnmv_r_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vminv_r_q ¶

    emit_vminv_r_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vmla_lane_d_d_dlane ¶

    emit_vmla_lane_d_d_dlane :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, lane: u8) {…}

    emit_vmla_s_s_s ¶

    emit_vmla_s_s_s :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vmladav_r_q_q ¶

    emit_vmladav_r_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vmladava_r_q_q ¶

    emit_vmladava_r_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vmladavax_r_q_q ¶

    emit_vmladavax_r_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vmladavx_r_q_q ¶

    emit_vmladavx_r_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vmlal_lane_q_d_dlane ¶

    emit_vmlal_lane_q_d_dlane :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, lane: u8) {…}

    emit_vmlal_q_d_d ¶

    emit_vmlal_q_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vmlalb_q_q_q ¶

    emit_vmlalb_q_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vmlaldav_r_r_q_q ¶

    emit_vmlaldav_r_r_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_vmlaldava_r_r_q_q ¶

    emit_vmlaldava_r_r_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_vmlaldavax_r_r_q_q ¶

    emit_vmlaldavax_r_r_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_vmlaldavx_r_r_q_q ¶

    emit_vmlaldavx_r_r_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_vmlalt_q_q_q ¶

    emit_vmlalt_q_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vmlav_r_q_q ¶

    emit_vmlav_r_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vmlava_r_q_q ¶

    emit_vmlava_r_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vmls_lane_d_d_dlane ¶

    emit_vmls_lane_d_d_dlane :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, lane: u8) {…}

    emit_vmls_s_s_s ¶

    emit_vmls_s_s_s :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vmlsdav_r_q_q ¶

    emit_vmlsdav_r_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vmlsdava_r_q_q ¶

    emit_vmlsdava_r_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vmlsdavax_r_q_q ¶

    emit_vmlsdavax_r_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vmlsdavx_r_q_q ¶

    emit_vmlsdavx_r_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vmlsl_lane_q_d_dlane ¶

    emit_vmlsl_lane_q_d_dlane :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, lane: u8) {…}

    emit_vmlsl_q_d_d ¶

    emit_vmlsl_q_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vmlslb_q_q_q ¶

    emit_vmlslb_q_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vmlsldav_r_r_q_q ¶

    emit_vmlsldav_r_r_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_vmlsldava_r_r_q_q ¶

    emit_vmlsldava_r_r_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_vmlsldavax_r_r_q_q ¶

    emit_vmlsldavax_r_r_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_vmlsldavx_r_r_q_q ¶

    emit_vmlsldavx_r_r_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_vmlslt_q_q_q ¶

    emit_vmlslt_q_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vmlsv_r_q_q ¶

    emit_vmlsv_r_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vmlsva_r_q_q ¶

    emit_vmlsva_r_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vmmla_bf16_q_q_q ¶

    emit_vmmla_bf16_q_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vmov_2gpr_q_qlane_qlane_r_r ¶

    emit_vmov_2gpr_q_qlane_qlane_r_r :: proc(
    	instructions: ^[dynamic]Instruction, 
    	dst:          Register, 
    	lane:         u8, 
    	src:          Register, 
    	lane2:        u8, 
    	src2:         Register, 
    	src3:         Register, 
    ) {…}

    emit_vmov_dlane_r ¶

    emit_vmov_dlane_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, lane: u8, src: Register) {…}
    Related Procedure Groups

    emit_vmov_lane_dlane_r ¶

    emit_vmov_lane_dlane_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, lane: u8, src: Register) {…}

    emit_vmov_q_r_qlane_r ¶

    emit_vmov_q_r_qlane_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, lane: u8, src: Register) {…}

    emit_vmov_r_dlane ¶

    emit_vmov_r_dlane :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, lane: u8) {…}
    Related Procedure Groups

    emit_vmov_r_q_r_qlane ¶

    emit_vmov_r_q_r_qlane :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, lane: u8) {…}

    emit_vmov_r_r_d ¶

    emit_vmov_r_r_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}
    Related Procedure Groups

    emit_vmov_r_r_s_s ¶

    emit_vmov_r_r_s_s :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}
    Related Procedure Groups

    emit_vmov_s_imm8 ¶

    emit_vmov_s_imm8 :: proc(instructions: ^[dynamic]Instruction, dst: Register, imm: i64) {…}
    Related Procedure Groups

    emit_vmov_s_s ¶

    emit_vmov_s_s :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}
    Related Procedure Groups

    emit_vmovl_q_d ¶

    emit_vmovl_q_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vmovn_d_q ¶

    emit_vmovn_d_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vmovnb_q_q ¶

    emit_vmovnb_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vmovnt_q_q ¶

    emit_vmovnt_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vmovx_s_s ¶

    emit_vmovx_s_s :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vmrs_r ¶

    emit_vmrs_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_vmsr_r ¶

    emit_vmsr_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_vmul_lane_d_d_dlane ¶

    emit_vmul_lane_d_d_dlane :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, lane: u8) {…}

    emit_vmul_s_s_s ¶

    emit_vmul_s_s_s :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vmull_lane_q_d_dlane ¶

    emit_vmull_lane_q_d_dlane :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, lane: u8) {…}

    emit_vmull_q_d_d ¶

    emit_vmull_q_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vmullb_q_q_q ¶

    emit_vmullb_q_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vmullt_q_q_q ¶

    emit_vmullt_q_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vmvn_d_d ¶

    emit_vmvn_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}
    Related Procedure Groups

    emit_vmvn_d_imm ¶

    emit_vmvn_d_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, imm: i64) {…}
    Related Procedure Groups

    emit_vneg_s_s ¶

    emit_vneg_s_s :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vnmla_s_s_s ¶

    emit_vnmla_s_s_s :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vnmls_s_s_s ¶

    emit_vnmls_s_s_s :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vnmul_s_s_s ¶

    emit_vnmul_s_s_s :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vorn_d_d_d ¶

    emit_vorn_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vorr_d_d_d ¶

    emit_vorr_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vpadal_d_d ¶

    emit_vpadal_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vpadd_d_d_d ¶

    emit_vpadd_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vpadd_f_d_d_d ¶

    emit_vpadd_f_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vpaddl_d_d ¶

    emit_vpaddl_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vpmax_d_d_d ¶

    emit_vpmax_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vpmin_d_d_d ¶

    emit_vpmin_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vpnot_none ¶

    emit_vpnot_none :: proc(instructions: ^[dynamic]Instruction) {…}

    emit_vpop_slist ¶

    emit_vpop_slist :: proc(instructions: ^[dynamic]Instruction, regs: u16) {…}

    emit_vpsel_q_q_q ¶

    emit_vpsel_q_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vpst_vpt ¶

    emit_vpst_vpt :: proc(instructions: ^[dynamic]Instruction, imm: i64) {…}

    emit_vpt_vpt_cond_q_q ¶

    emit_vpt_vpt_cond_q_q :: proc(instructions: ^[dynamic]Instruction, imm: i64, imm2: i64, src: Register, src2: Register) {…}

    emit_vpush_slist ¶

    emit_vpush_slist :: proc(instructions: ^[dynamic]Instruction, regs: u16) {…}

    emit_vqabs_q_q ¶

    emit_vqabs_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vqadd_d_d_d ¶

    emit_vqadd_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vqdmladh_q_q_q ¶

    emit_vqdmladh_q_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vqdmladhx_q_q_q ¶

    emit_vqdmladhx_q_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vqdmlal_lane_q_d_dlane ¶

    emit_vqdmlal_lane_q_d_dlane :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, lane: u8) {…}

    emit_vqdmlal_q_d_d ¶

    emit_vqdmlal_q_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vqdmlsdh_q_q_q ¶

    emit_vqdmlsdh_q_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vqdmlsdhx_q_q_q ¶

    emit_vqdmlsdhx_q_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vqdmlsl_lane_q_d_dlane ¶

    emit_vqdmlsl_lane_q_d_dlane :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, lane: u8) {…}

    emit_vqdmlsl_q_d_d ¶

    emit_vqdmlsl_q_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vqdmulh_d_d_d ¶

    emit_vqdmulh_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vqdmulh_lane_d_d_dlane ¶

    emit_vqdmulh_lane_d_d_dlane :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, lane: u8) {…}

    emit_vqdmull_lane_q_d_dlane ¶

    emit_vqdmull_lane_q_d_dlane :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, lane: u8) {…}

    emit_vqdmull_q_d_d ¶

    emit_vqdmull_q_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vqmovn_d_q ¶

    emit_vqmovn_d_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vqmovnb_q_q ¶

    emit_vqmovnb_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vqmovnt_q_q ¶

    emit_vqmovnt_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vqmovun_d_q ¶

    emit_vqmovun_d_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vqmovunb_q_q ¶

    emit_vqmovunb_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vqmovunt_q_q ¶

    emit_vqmovunt_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vqneg_q_q ¶

    emit_vqneg_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vqrdmladh_q_q_q ¶

    emit_vqrdmladh_q_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vqrdmladhx_q_q_q ¶

    emit_vqrdmladhx_q_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vqrdmlah_d_d_d ¶

    emit_vqrdmlah_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vqrdmlah_lane_d_d_dlane ¶

    emit_vqrdmlah_lane_d_d_dlane :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, lane: u8) {…}

    emit_vqrdmlsdh_q_q_q ¶

    emit_vqrdmlsdh_q_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vqrdmlsdhx_q_q_q ¶

    emit_vqrdmlsdhx_q_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vqrdmlsh_d_d_d ¶

    emit_vqrdmlsh_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vqrdmlsh_lane_d_d_dlane ¶

    emit_vqrdmlsh_lane_d_d_dlane :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, lane: u8) {…}

    emit_vqrdmulh_d_d_d ¶

    emit_vqrdmulh_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vqrdmulh_lane_d_d_dlane ¶

    emit_vqrdmulh_lane_d_d_dlane :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, lane: u8) {…}

    emit_vqrshl_d_d_d ¶

    emit_vqrshl_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vqrshrn_d_q_imm ¶

    emit_vqrshrn_d_q_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_vqrshrnb_q_q_imm5 ¶

    emit_vqrshrnb_q_q_imm5 :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_vqrshrnt_q_q_imm5 ¶

    emit_vqrshrnt_q_q_imm5 :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_vqrshrun_d_q_imm ¶

    emit_vqrshrun_d_q_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_vqrshrunb_q_q_imm5 ¶

    emit_vqrshrunb_q_q_imm5 :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_vqrshrunt_q_q_imm5 ¶

    emit_vqrshrunt_q_q_imm5 :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_vqshl_d_d_d ¶

    emit_vqshl_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}
    Related Procedure Groups

    emit_vqshl_d_d_imm ¶

    emit_vqshl_d_d_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}
    Related Procedure Groups

    emit_vqshrn_d_q_imm ¶

    emit_vqshrn_d_q_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_vqshrnb_q_q_imm5 ¶

    emit_vqshrnb_q_q_imm5 :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_vqshrnt_q_q_imm5 ¶

    emit_vqshrnt_q_q_imm5 :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_vqshrun_d_q_imm ¶

    emit_vqshrun_d_q_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_vqshrunb_q_q_imm5 ¶

    emit_vqshrunb_q_q_imm5 :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_vqshrunt_q_q_imm5 ¶

    emit_vqshrunt_q_q_imm5 :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_vqsub_d_d_d ¶

    emit_vqsub_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vrecpe_d_d ¶

    emit_vrecpe_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vrecpe_f_d_d ¶

    emit_vrecpe_f_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vrecps_d_d_d ¶

    emit_vrecps_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vrev16_d_d ¶

    emit_vrev16_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vrev32_d_d ¶

    emit_vrev32_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vrev64_d_d ¶

    emit_vrev64_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vrhadd_d_d_d ¶

    emit_vrhadd_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vrinta_s_s ¶

    emit_vrinta_s_s :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vrintm_s_s ¶

    emit_vrintm_s_s :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vrintn_s_s ¶

    emit_vrintn_s_s :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vrintp_s_s ¶

    emit_vrintp_s_s :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vrintr_s_s ¶

    emit_vrintr_s_s :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vrintx_s_s ¶

    emit_vrintx_s_s :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vrintz_s_s ¶

    emit_vrintz_s_s :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vrmlaldavh_r_r_q_q ¶

    emit_vrmlaldavh_r_r_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_vrmlaldavha_r_r_q_q ¶

    emit_vrmlaldavha_r_r_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_vrmlaldavhax_r_r_q_q ¶

    emit_vrmlaldavhax_r_r_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_vrmlaldavhx_r_r_q_q ¶

    emit_vrmlaldavhx_r_r_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_vrmlsldavh_r_r_q_q ¶

    emit_vrmlsldavh_r_r_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_vrmlsldavha_r_r_q_q ¶

    emit_vrmlsldavha_r_r_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_vrmlsldavhax_r_r_q_q ¶

    emit_vrmlsldavhax_r_r_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_vrmlsldavhx_r_r_q_q ¶

    emit_vrmlsldavhx_r_r_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_vrshl_d_d_d ¶

    emit_vrshl_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vrshr_d_d_imm ¶

    emit_vrshr_d_d_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_vrshrn_d_q_imm ¶

    emit_vrshrn_d_q_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_vrshrnb_q_q_imm5 ¶

    emit_vrshrnb_q_q_imm5 :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_vrshrnt_q_q_imm5 ¶

    emit_vrshrnt_q_q_imm5 :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_vrsqrte_d_d ¶

    emit_vrsqrte_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vrsqrte_f_d_d ¶

    emit_vrsqrte_f_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vrsqrts_d_d_d ¶

    emit_vrsqrts_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vrsra_d_d_imm ¶

    emit_vrsra_d_d_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_vsdot_d_d_d ¶

    emit_vsdot_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vsdot_lane_d_d_dlane ¶

    emit_vsdot_lane_d_d_dlane :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, lane: u8) {…}

    emit_vsel_s_s_s_cond ¶

    emit_vsel_s_s_s_cond :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, imm: i64) {…}

    emit_vshl_d_d_d ¶

    emit_vshl_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vshlc_q_r_imm5 ¶

    emit_vshlc_q_r_imm5 :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_vshll_q_d ¶

    emit_vshll_q_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}
    Related Procedure Groups

    emit_vshll_q_d_imm ¶

    emit_vshll_q_d_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}
    Related Procedure Groups

    emit_vshllb_q_q_imm5 ¶

    emit_vshllb_q_q_imm5 :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_vshllt_q_q_imm5 ¶

    emit_vshllt_q_q_imm5 :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_vshr_d_d_imm ¶

    emit_vshr_d_d_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_vshrn_d_q_imm ¶

    emit_vshrn_d_q_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_vshrnb_q_q_imm5 ¶

    emit_vshrnb_q_q_imm5 :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_vshrnt_q_q_imm5 ¶

    emit_vshrnt_q_q_imm5 :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_vsli_d_d_imm ¶

    emit_vsli_d_d_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_vsmmla_q_q_q ¶

    emit_vsmmla_q_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vsqrt_s_s ¶

    emit_vsqrt_s_s :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vsra_d_d_imm ¶

    emit_vsra_d_d_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_vsri_d_d_imm ¶

    emit_vsri_d_d_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_vst1_dlane_mem ¶

    emit_vst1_dlane_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, lane: u8, src: Memory) {…}
    Related Procedure Groups

    emit_vst1_dlist_mem ¶

    emit_vst1_dlist_mem :: proc(instructions: ^[dynamic]Instruction, regs: u16, src: Memory) {…}
    Related Procedure Groups

    emit_vst1_lane_dlane_mem ¶

    emit_vst1_lane_dlane_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, lane: u8, src: Memory) {…}

    emit_vst20_qlist_mem ¶

    emit_vst20_qlist_mem :: proc(instructions: ^[dynamic]Instruction, regs: u16, src: Memory) {…}

    emit_vst21_qlist_mem ¶

    emit_vst21_qlist_mem :: proc(instructions: ^[dynamic]Instruction, regs: u16, src: Memory) {…}

    emit_vst2_dlist_mem ¶

    emit_vst2_dlist_mem :: proc(instructions: ^[dynamic]Instruction, regs: u16, src: Memory) {…}

    emit_vst2_lane_dlist_mem ¶

    emit_vst2_lane_dlist_mem :: proc(instructions: ^[dynamic]Instruction, regs: u16, src: Memory) {…}

    emit_vst3_dlist_mem ¶

    emit_vst3_dlist_mem :: proc(instructions: ^[dynamic]Instruction, regs: u16, src: Memory) {…}

    emit_vst3_lane_dlist_mem ¶

    emit_vst3_lane_dlist_mem :: proc(instructions: ^[dynamic]Instruction, regs: u16, src: Memory) {…}

    emit_vst40_qlist_mem ¶

    emit_vst40_qlist_mem :: proc(instructions: ^[dynamic]Instruction, regs: u16, src: Memory) {…}

    emit_vst41_qlist_mem ¶

    emit_vst41_qlist_mem :: proc(instructions: ^[dynamic]Instruction, regs: u16, src: Memory) {…}

    emit_vst42_qlist_mem ¶

    emit_vst42_qlist_mem :: proc(instructions: ^[dynamic]Instruction, regs: u16, src: Memory) {…}

    emit_vst43_qlist_mem ¶

    emit_vst43_qlist_mem :: proc(instructions: ^[dynamic]Instruction, regs: u16, src: Memory) {…}

    emit_vst4_dlist_mem ¶

    emit_vst4_dlist_mem :: proc(instructions: ^[dynamic]Instruction, regs: u16, src: Memory) {…}

    emit_vst4_lane_dlist_mem ¶

    emit_vst4_lane_dlist_mem :: proc(instructions: ^[dynamic]Instruction, regs: u16, src: Memory) {…}

    emit_vstm_r_slist ¶

    emit_vstm_r_slist :: proc(instructions: ^[dynamic]Instruction, dst: Register, regs: u16) {…}

    emit_vstr_s_mem ¶

    emit_vstr_s_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory) {…}

    emit_vstrb_q_mem ¶

    emit_vstrb_q_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory) {…}

    emit_vstrb_scatter_q_mem_q ¶

    emit_vstrb_scatter_q_mem_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory, src2: Register) {…}

    emit_vstrd_q_mem ¶

    emit_vstrd_q_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory) {…}

    emit_vstrd_scatter_q_mem_q ¶

    emit_vstrd_scatter_q_mem_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory, src2: Register) {…}

    emit_vstrh_q_mem ¶

    emit_vstrh_q_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory) {…}

    emit_vstrh_scatter_q_mem_q ¶

    emit_vstrh_scatter_q_mem_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory, src2: Register) {…}

    emit_vstrw_q_mem ¶

    emit_vstrw_q_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory) {…}

    emit_vstrw_scatter_q_mem_q ¶

    emit_vstrw_scatter_q_mem_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Memory, src2: Register) {…}

    emit_vsub_s_s_s ¶

    emit_vsub_s_s_s :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vsubl_q_d_d ¶

    emit_vsubl_q_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vsubw_q_q_d ¶

    emit_vsubw_q_q_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vsudot_lane_q_q_dlane ¶

    emit_vsudot_lane_q_q_dlane :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, lane: u8) {…}

    emit_vsudot_q_q_q ¶

    emit_vsudot_q_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vswp_d_d ¶

    emit_vswp_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vtbl_d_d_d ¶

    emit_vtbl_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}
    Related Procedure Groups

    emit_vtbl_d_dlist_d ¶

    emit_vtbl_d_dlist_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, regs: u16, src: Register) {…}
    Related Procedure Groups

    emit_vtbx_d_d_d ¶

    emit_vtbx_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}
    Related Procedure Groups

    emit_vtbx_d_dlist_d ¶

    emit_vtbx_d_dlist_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, regs: u16, src: Register) {…}
    Related Procedure Groups

    emit_vtrn_d_d ¶

    emit_vtrn_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vtst_d_d_d ¶

    emit_vtst_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vudot_d_d_d ¶

    emit_vudot_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vudot_lane_d_d_dlane ¶

    emit_vudot_lane_d_d_dlane :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, lane: u8) {…}

    emit_vummla_q_q_q ¶

    emit_vummla_q_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vusdot_d_d_d ¶

    emit_vusdot_d_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vusdot_lane_d_d_dlane ¶

    emit_vusdot_lane_d_d_dlane :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, lane: u8) {…}

    emit_vusmmla_q_q_q ¶

    emit_vusmmla_q_q_q :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_vuzp_d_d ¶

    emit_vuzp_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_vzip_d_d ¶

    emit_vzip_d_d :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_wfe_none ¶

    emit_wfe_none :: proc(instructions: ^[dynamic]Instruction) {…}

    emit_wfi_none ¶

    emit_wfi_none :: proc(instructions: ^[dynamic]Instruction) {…}

    emit_wls_r_rel ¶

    emit_wls_r_rel :: proc(instructions: ^[dynamic]Instruction, dst: Register, offset: i64) {…}

    emit_wlstp_r_rel ¶

    emit_wlstp_r_rel :: proc(instructions: ^[dynamic]Instruction, dst: Register, offset: i64) {…}

    emit_yield_none ¶

    emit_yield_none :: proc(instructions: ^[dynamic]Instruction) {…}

    encode ¶

    encode :: proc(
    	instructions: []Instruction, 
    	label_defs:   []rexcode_isa.Label_Definition, 
    	code:         []u8, 
    	relocs:       ^[dynamic]Relocation, 
    	errors:       ^[dynamic]rexcode_isa.Error, 
    	resolve:      bool = true, 
    	base_address: u64 = 0, 
    ) -> (byte_count: u32, ok: bool) {…}

    encode_a32_modimm ¶

    encode_a32_modimm :: proc(value: u32) -> (u32, bool) {…}
     

    Encode an arbitrary 32-bit constant as an A32 modified-immediate. Returns the 12-bit field on success.

    encode_max_code_size ¶

    encode_max_code_size :: proc "contextless" (instructions: []Instruction) -> int {…}

    encode_max_relocation_count ¶

    encode_max_relocation_count :: proc "contextless" (instructions: []Instruction) -> int {…}

    encode_neon_modimm ¶

    encode_neon_modimm :: proc(value: u32) -> (form: NEON_Imm_Form, ok: bool) {…}
     

    Encode a (32-bit) constant for NEON immediate operations. On success, returns (cmode, op, abcdefgh) packed in the low bits as a single u32: bits 12:8 = cmode, bit 7 = op, bits 7:0 = abcdefgh... actually returns a struct.

    encode_psr_field ¶

    encode_psr_field :: proc "contextless" (sel: u8) -> u32 {…}

    encode_reserve ¶

    encode_reserve :: proc(code: ^[dynamic]u8, relocs: ^[dynamic]Relocation, instructions: []Instruction) {…}
     

    Pre-size the caller's encode outputs (code grown by length so code[:] is a valid emit target; relocs reserved by capacity) so the encode hot path never reallocates. Allocates no new buffers; pass nil to skip either array.

    encode_t32_modimm ¶

    encode_t32_modimm :: proc(value: u32) -> (u32, bool) {…}
     

    Encode an arbitrary 32-bit constant as a T32 modified-immediate. Returns 12 bits packed as i:imm3:imm8 on success.

    encode_vfp_imm8_f16 ¶

    encode_vfp_imm8_f16 :: proc(value: u16) -> (u8, bool) {…}

    encode_vfp_imm8_f32 ¶

    encode_vfp_imm8_f32 :: proc(value: u32) -> (u8, bool) {…}

    encode_vfp_imm8_f64 ¶

    encode_vfp_imm8_f64 :: proc(value: u64) -> (u8, bool) {…}

    encoding_flags ¶

    encoding_flags :: proc "contextless" (
    	sets_flags:  bool = false, 
    	cond_in_28:  bool = true, 
    	branch:      bool = false, 
    	cond_branch: bool = false, 
    	writes_pc:   bool = false, 
    	thumb32:     bool = false, 
    	deprecated:  bool = false, 
    ) -> Encoding_Flags {…}
     

    Convenience: build an Encoding_Flags with named fields.

    extract_neon_modimm_abcdefgh ¶

    extract_neon_modimm_abcdefgh :: proc "contextless" (word: u32) -> u32 {…}
     

    Reconstruct abcdefgh from the instruction word.

    fprint ¶

    fprint :: proc(
    	fd:           ^os.File, 
    	instructions: []Instruction, 
    	inst_info:    []Instruction_Info, 
    	label_defs:   []rexcode_isa.Label_Definition, 
    	tokens:       ^[dynamic]rexcode_isa.Token = nil, 
    	options:      ^rexcode_isa.Print_Options = nil, 
    	label_names:  ^map[u32]string = nil, 
    ) {…}

    fprintln ¶

    fprintln :: proc(
    	fd:           ^os.File, 
    	instructions: []Instruction, 
    	inst_info:    []Instruction_Info, 
    	label_defs:   []rexcode_isa.Label_Definition, 
    	tokens:       ^[dynamic]rexcode_isa.Token = nil, 
    	options:      ^rexcode_isa.Print_Options = nil, 
    	label_names:  ^map[u32]string = nil, 
    ) {…}

    inst_adc_r_r_immm ¶

    inst_adc_r_r_immm :: proc "contextless" (dst: Register, src: Register, imm: i64) -> Instruction {…}
    Related Procedure Groups

    inst_adc_r_r_rsh ¶

    inst_adc_r_r_rsh :: proc "contextless" (dst: Register, src: Register, src2: Register, shift: Shift_Type, amount: u8) -> Instruction {…}
    Related Procedure Groups

    inst_adc_r_r_rsr ¶

    inst_adc_r_r_rsr :: proc "contextless" (dst: Register, src: Register, src2: Register, shift: Shift_Type, rs: Register) -> Instruction {…}
    Related Procedure Groups

    inst_adc_rlo_rlo ¶

    inst_adc_rlo_rlo :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}
    Related Procedure Groups

    inst_add_r_r ¶

    inst_add_r_r :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}
    Related Procedure Groups

    inst_add_r_r_immm ¶

    inst_add_r_r_immm :: proc "contextless" (dst: Register, src: Register, imm: i64) -> Instruction {…}
    Related Procedure Groups

    inst_add_r_r_rsh ¶

    inst_add_r_r_rsh :: proc "contextless" (dst: Register, src: Register, src2: Register, shift: Shift_Type, amount: u8) -> Instruction {…}
    Related Procedure Groups

    inst_add_r_r_rsr ¶

    inst_add_r_r_rsr :: proc "contextless" (dst: Register, src: Register, src2: Register, shift: Shift_Type, rs: Register) -> Instruction {…}
    Related Procedure Groups

    inst_add_rlo_imm8 ¶

    inst_add_rlo_imm8 :: proc "contextless" (dst: Register, imm: i64) -> Instruction {…}
    Related Procedure Groups

    inst_add_rlo_rlo_rlo ¶

    inst_add_rlo_rlo_rlo :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}
    Related Procedure Groups

    inst_adr_rlo_rel ¶

    inst_adr_rlo_rel :: proc "contextless" (dst: Register, offset: i64) -> Instruction {…}

    inst_aesd_q_q ¶

    inst_aesd_q_q :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_aese_q_q ¶

    inst_aese_q_q :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_aesimc_q_q ¶

    inst_aesimc_q_q :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_aesmc_q_q ¶

    inst_aesmc_q_q :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_and_r_r_immm ¶

    inst_and_r_r_immm :: proc "contextless" (dst: Register, src: Register, imm: i64) -> Instruction {…}
    Related Procedure Groups

    inst_and_r_r_rsh ¶

    inst_and_r_r_rsh :: proc "contextless" (dst: Register, src: Register, src2: Register, shift: Shift_Type, amount: u8) -> Instruction {…}
    Related Procedure Groups

    inst_and_r_r_rsr ¶

    inst_and_r_r_rsr :: proc "contextless" (dst: Register, src: Register, src2: Register, shift: Shift_Type, rs: Register) -> Instruction {…}
    Related Procedure Groups

    inst_and_rlo_rlo ¶

    inst_and_rlo_rlo :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}
    Related Procedure Groups

    inst_asr_r_r_imm5 ¶

    inst_asr_r_r_imm5 :: proc "contextless" (dst: Register, src: Register, imm: i64) -> Instruction {…}
    Related Procedure Groups

    inst_asr_r_r_r ¶

    inst_asr_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}
    Related Procedure Groups

    inst_asr_rlo_rlo ¶

    inst_asr_rlo_rlo :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}
    Related Procedure Groups

    inst_aut_none ¶

    inst_aut_none :: proc "contextless" () -> Instruction {…}

    inst_autg_r_r_r ¶

    inst_autg_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_b_rel ¶

    inst_b_rel :: proc "contextless" (offset: i64) -> Instruction {…}
    Related Procedure Groups

    inst_b_rel_cond ¶

    inst_b_rel_cond :: proc "contextless" (offset: i64, imm: i64) -> Instruction {…}
    Related Procedure Groups

    inst_bf_rel_rel ¶

    inst_bf_rel_rel :: proc "contextless" (offset: i64, offset2: i64) -> Instruction {…}

    inst_bfc_r_imm5_imm5w ¶

    inst_bfc_r_imm5_imm5w :: proc "contextless" (dst: Register, imm: i64, imm2: i64) -> Instruction {…}

    inst_bfcsel_rel_rel_imm4 ¶

    inst_bfcsel_rel_rel_imm4 :: proc "contextless" (offset: i64, offset2: i64, imm: i64) -> Instruction {…}

    inst_bfi_br_rel_r ¶

    inst_bfi_br_rel_r :: proc "contextless" (offset: i64, src: Register) -> Instruction {…}

    inst_bfi_r_r_imm5_imm5w ¶

    inst_bfi_r_r_imm5_imm5w :: proc "contextless" (dst: Register, src: Register, imm: i64, imm2: i64) -> Instruction {…}

    inst_bfl_rel_rel ¶

    inst_bfl_rel_rel :: proc "contextless" (offset: i64, offset2: i64) -> Instruction {…}

    inst_bflx_rel_r ¶

    inst_bflx_rel_r :: proc "contextless" (offset: i64, src: Register) -> Instruction {…}

    inst_bic_r_r_immm ¶

    inst_bic_r_r_immm :: proc "contextless" (dst: Register, src: Register, imm: i64) -> Instruction {…}
    Related Procedure Groups

    inst_bic_r_r_rsh ¶

    inst_bic_r_r_rsh :: proc "contextless" (dst: Register, src: Register, src2: Register, shift: Shift_Type, amount: u8) -> Instruction {…}
    Related Procedure Groups

    inst_bic_r_r_rsr ¶

    inst_bic_r_r_rsr :: proc "contextless" (dst: Register, src: Register, src2: Register, shift: Shift_Type, rs: Register) -> Instruction {…}
    Related Procedure Groups

    inst_bic_rlo_rlo ¶

    inst_bic_rlo_rlo :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}
    Related Procedure Groups

    inst_bkpt_imm ¶

    inst_bkpt_imm :: proc "contextless" (imm: i64) -> Instruction {…}

    inst_bl_rel ¶

    inst_bl_rel :: proc "contextless" (offset: i64) -> Instruction {…}

    inst_block ¶

    inst_block :: proc "contextless" (m: Mnemonic, base: Register, mask: u16, mode: Mode = .A32) -> Instruction {…}
     

    LDM/STM/PUSH/POP block move

    inst_blx_r ¶

    inst_blx_r :: proc "contextless" (dst: Register) -> Instruction {…}
    Related Procedure Groups

    inst_blx_rel ¶

    inst_blx_rel :: proc "contextless" (offset: i64) -> Instruction {…}
    Related Procedure Groups

    inst_blxns_r ¶

    inst_blxns_r :: proc "contextless" (dst: Register) -> Instruction {…}

    inst_branch ¶

    inst_branch :: proc "contextless" (m: Mnemonic, label_id: u32, mode: Mode = .A32) -> Instruction {…}
     

    Branches with label

    inst_bti_none ¶

    inst_bti_none :: proc "contextless" () -> Instruction {…}

    inst_bx_r ¶

    inst_bx_r :: proc "contextless" (dst: Register) -> Instruction {…}

    inst_bxj_r ¶

    inst_bxj_r :: proc "contextless" (dst: Register) -> Instruction {…}

    inst_bxns_r ¶

    inst_bxns_r :: proc "contextless" (dst: Register) -> Instruction {…}

    inst_cbnz_rlo_rel ¶

    inst_cbnz_rlo_rel :: proc "contextless" (dst: Register, offset: i64) -> Instruction {…}

    inst_cbz_rlo_rel ¶

    inst_cbz_rlo_rel :: proc "contextless" (dst: Register, offset: i64) -> Instruction {…}

    inst_cdp2_cpn_cpop_crd_crd ¶

    inst_cdp2_cpn_cpop_crd_crd :: proc "contextless" (dst: Register, imm: i64, src: Register, src2: Register) -> Instruction {…}

    inst_cdp_cpn_cpop_crd_crd ¶

    inst_cdp_cpn_cpop_crd_crd :: proc "contextless" (dst: Register, imm: i64, src: Register, src2: Register) -> Instruction {…}

    inst_clrex_none ¶

    inst_clrex_none :: proc "contextless" () -> Instruction {…}

    inst_clz_r_r ¶

    inst_clz_r_r :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_cmn_r_immm ¶

    inst_cmn_r_immm :: proc "contextless" (dst: Register, imm: i64) -> Instruction {…}
    Related Procedure Groups

    inst_cmn_r_rsh ¶

    inst_cmn_r_rsh :: proc "contextless" (dst: Register, src: Register, shift: Shift_Type, amount: u8) -> Instruction {…}
    Related Procedure Groups

    inst_cmn_r_rsr ¶

    inst_cmn_r_rsr :: proc "contextless" (dst: Register, src: Register, shift: Shift_Type, rs: Register) -> Instruction {…}
    Related Procedure Groups

    inst_cmn_rlo_rlo ¶

    inst_cmn_rlo_rlo :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}
    Related Procedure Groups

    inst_cmp_r_immm ¶

    inst_cmp_r_immm :: proc "contextless" (dst: Register, imm: i64) -> Instruction {…}
    Related Procedure Groups

    inst_cmp_r_rsh ¶

    inst_cmp_r_rsh :: proc "contextless" (dst: Register, src: Register, shift: Shift_Type, amount: u8) -> Instruction {…}
    Related Procedure Groups

    inst_cmp_r_rsr ¶

    inst_cmp_r_rsr :: proc "contextless" (dst: Register, src: Register, shift: Shift_Type, rs: Register) -> Instruction {…}
    Related Procedure Groups

    inst_cmp_rlo_rlo ¶

    inst_cmp_rlo_rlo :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}
    Related Procedure Groups

    inst_cps_ifl ¶

    inst_cps_ifl :: proc "contextless" (imm: i64) -> Instruction {…}

    inst_crc32b_r_r_r ¶

    inst_crc32b_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_crc32cb_r_r_r ¶

    inst_crc32cb_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_crc32ch_r_r_r ¶

    inst_crc32ch_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_crc32cw_r_r_r ¶

    inst_crc32cw_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_crc32h_r_r_r ¶

    inst_crc32h_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_crc32w_r_r_r ¶

    inst_crc32w_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_csdb_none ¶

    inst_csdb_none :: proc "contextless" () -> Instruction {…}

    inst_cx1_cp_r_imm ¶

    inst_cx1_cp_r_imm :: proc "contextless" (imm: i64, src: Register, imm2: i64) -> Instruction {…}

    inst_cx1a_cp_r_imm ¶

    inst_cx1a_cp_r_imm :: proc "contextless" (imm: i64, src: Register, imm2: i64) -> Instruction {…}

    inst_cx1d_cp_r_imm ¶

    inst_cx1d_cp_r_imm :: proc "contextless" (imm: i64, src: Register, imm2: i64) -> Instruction {…}

    inst_cx1da_cp_r_imm ¶

    inst_cx1da_cp_r_imm :: proc "contextless" (imm: i64, src: Register, imm2: i64) -> Instruction {…}

    inst_cx2_cp_r_r_imm ¶

    inst_cx2_cp_r_r_imm :: proc "contextless" (imm: i64, src: Register, src2: Register, imm2: i64) -> Instruction {…}

    inst_cx2a_cp_r_r_imm ¶

    inst_cx2a_cp_r_r_imm :: proc "contextless" (imm: i64, src: Register, src2: Register, imm2: i64) -> Instruction {…}

    inst_cx2d_cp_r_r_imm ¶

    inst_cx2d_cp_r_r_imm :: proc "contextless" (imm: i64, src: Register, src2: Register, imm2: i64) -> Instruction {…}

    inst_cx2da_cp_r_r_imm ¶

    inst_cx2da_cp_r_r_imm :: proc "contextless" (imm: i64, src: Register, src2: Register, imm2: i64) -> Instruction {…}

    inst_cx3_cp_r_r_r ¶

    inst_cx3_cp_r_r_r :: proc "contextless" (imm: i64, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_cx3a_cp_r_r_r ¶

    inst_cx3a_cp_r_r_r :: proc "contextless" (imm: i64, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_cx3d_cp_r_r_r ¶

    inst_cx3d_cp_r_r_r :: proc "contextless" (imm: i64, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_cx3da_cp_r_r_r ¶

    inst_cx3da_cp_r_r_r :: proc "contextless" (imm: i64, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_dbg_hint ¶

    inst_dbg_hint :: proc "contextless" (imm: i64) -> Instruction {…}

    inst_dcps1_none ¶

    inst_dcps1_none :: proc "contextless" () -> Instruction {…}

    inst_dcps2_none ¶

    inst_dcps2_none :: proc "contextless" () -> Instruction {…}

    inst_dcps3_none ¶

    inst_dcps3_none :: proc "contextless" () -> Instruction {…}

    inst_dls_r ¶

    inst_dls_r :: proc "contextless" (dst: Register) -> Instruction {…}

    inst_dlstp_r ¶

    inst_dlstp_r :: proc "contextless" (dst: Register) -> Instruction {…}

    inst_dmb_barr ¶

    inst_dmb_barr :: proc "contextless" (imm: i64) -> Instruction {…}

    inst_dsb_barr ¶

    inst_dsb_barr :: proc "contextless" (imm: i64) -> Instruction {…}

    inst_eor_r_r_immm ¶

    inst_eor_r_r_immm :: proc "contextless" (dst: Register, src: Register, imm: i64) -> Instruction {…}
    Related Procedure Groups

    inst_eor_r_r_rsh ¶

    inst_eor_r_r_rsh :: proc "contextless" (dst: Register, src: Register, src2: Register, shift: Shift_Type, amount: u8) -> Instruction {…}
    Related Procedure Groups

    inst_eor_r_r_rsr ¶

    inst_eor_r_r_rsr :: proc "contextless" (dst: Register, src: Register, src2: Register, shift: Shift_Type, rs: Register) -> Instruction {…}
    Related Procedure Groups

    inst_eor_rlo_rlo ¶

    inst_eor_rlo_rlo :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}
    Related Procedure Groups

    inst_eret_none ¶

    inst_eret_none :: proc "contextless" () -> Instruction {…}

    inst_esb_none ¶

    inst_esb_none :: proc "contextless" () -> Instruction {…}

    inst_hint_hint ¶

    inst_hint_hint :: proc "contextless" (imm: i64) -> Instruction {…}

    inst_hlt_imm ¶

    inst_hlt_imm :: proc "contextless" (imm: i64) -> Instruction {…}

    inst_hvc_imm ¶

    inst_hvc_imm :: proc "contextless" (imm: i64) -> Instruction {…}

    inst_i ¶

    inst_i :: proc "contextless" (m: Mnemonic, v: i64, mode: Mode = .A32) -> Instruction {…}

    inst_isb_barr ¶

    inst_isb_barr :: proc "contextless" (imm: i64) -> Instruction {…}

    inst_it_cond_imm4 ¶

    inst_it_cond_imm4 :: proc "contextless" (imm: i64, imm2: i64) -> Instruction {…}

    inst_lctp_none ¶

    inst_lctp_none :: proc "contextless" () -> Instruction {…}

    inst_lda_r_mem ¶

    inst_lda_r_mem :: proc "contextless" (dst: Register, src: Memory) -> Instruction {…}

    inst_ldab_r_mem ¶

    inst_ldab_r_mem :: proc "contextless" (dst: Register, src: Memory) -> Instruction {…}

    inst_ldaex_r_mem ¶

    inst_ldaex_r_mem :: proc "contextless" (dst: Register, src: Memory) -> Instruction {…}

    inst_ldaexb_r_mem ¶

    inst_ldaexb_r_mem :: proc "contextless" (dst: Register, src: Memory) -> Instruction {…}

    inst_ldaexd_r_mem ¶

    inst_ldaexd_r_mem :: proc "contextless" (dst: Register, src: Memory) -> Instruction {…}

    inst_ldaexh_r_mem ¶

    inst_ldaexh_r_mem :: proc "contextless" (dst: Register, src: Memory) -> Instruction {…}

    inst_ldah_r_mem ¶

    inst_ldah_r_mem :: proc "contextless" (dst: Register, src: Memory) -> Instruction {…}

    inst_ldc2_cpn_crd_mem ¶

    inst_ldc2_cpn_crd_mem :: proc "contextless" (dst: Register, src: Register, src2: Memory) -> Instruction {…}

    inst_ldc_cpn_crd_mem ¶

    inst_ldc_cpn_crd_mem :: proc "contextless" (dst: Register, src: Register, src2: Memory) -> Instruction {…}

    inst_ldm_r_list ¶

    inst_ldm_r_list :: proc "contextless" (dst: Register, regs: u16) -> Instruction {…}

    inst_ldr_r_mem ¶

    inst_ldr_r_mem :: proc "contextless" (dst: Register, src: Memory) -> Instruction {…}

    inst_ldrb_r_mem ¶

    inst_ldrb_r_mem :: proc "contextless" (dst: Register, src: Memory) -> Instruction {…}

    inst_ldrbt_r_mem ¶

    inst_ldrbt_r_mem :: proc "contextless" (dst: Register, src: Memory) -> Instruction {…}

    inst_ldrd_r_mem ¶

    inst_ldrd_r_mem :: proc "contextless" (dst: Register, src: Memory) -> Instruction {…}
    Related Procedure Groups

    inst_ldrd_r_r_mem ¶

    inst_ldrd_r_r_mem :: proc "contextless" (dst: Register, src: Register, src2: Memory) -> Instruction {…}
    Related Procedure Groups

    inst_ldrex_r_mem ¶

    inst_ldrex_r_mem :: proc "contextless" (dst: Register, src: Memory) -> Instruction {…}

    inst_ldrexb_r_mem ¶

    inst_ldrexb_r_mem :: proc "contextless" (dst: Register, src: Memory) -> Instruction {…}

    inst_ldrexd_r_mem ¶

    inst_ldrexd_r_mem :: proc "contextless" (dst: Register, src: Memory) -> Instruction {…}
    Related Procedure Groups

    inst_ldrexd_r_r_mem ¶

    inst_ldrexd_r_r_mem :: proc "contextless" (dst: Register, src: Register, src2: Memory) -> Instruction {…}
    Related Procedure Groups

    inst_ldrexh_r_mem ¶

    inst_ldrexh_r_mem :: proc "contextless" (dst: Register, src: Memory) -> Instruction {…}

    inst_ldrh_r_mem ¶

    inst_ldrh_r_mem :: proc "contextless" (dst: Register, src: Memory) -> Instruction {…}

    inst_ldrht_r_mem ¶

    inst_ldrht_r_mem :: proc "contextless" (dst: Register, src: Memory) -> Instruction {…}

    inst_ldrsb_r_mem ¶

    inst_ldrsb_r_mem :: proc "contextless" (dst: Register, src: Memory) -> Instruction {…}

    inst_ldrsbt_r_mem ¶

    inst_ldrsbt_r_mem :: proc "contextless" (dst: Register, src: Memory) -> Instruction {…}

    inst_ldrsh_r_mem ¶

    inst_ldrsh_r_mem :: proc "contextless" (dst: Register, src: Memory) -> Instruction {…}

    inst_ldrsht_r_mem ¶

    inst_ldrsht_r_mem :: proc "contextless" (dst: Register, src: Memory) -> Instruction {…}

    inst_ldrt_r_mem ¶

    inst_ldrt_r_mem :: proc "contextless" (dst: Register, src: Memory) -> Instruction {…}

    inst_le_rel ¶

    inst_le_rel :: proc "contextless" (offset: i64) -> Instruction {…}

    inst_letp_rel ¶

    inst_letp_rel :: proc "contextless" (offset: i64) -> Instruction {…}

    inst_load ¶

    inst_load :: proc "contextless" (m: Mnemonic, rd: Register, mm: Memory, mode: Mode = .A32) -> Instruction {…}
     

    Memory load/store

    inst_lsl_r_r_imm5 ¶

    inst_lsl_r_r_imm5 :: proc "contextless" (dst: Register, src: Register, imm: i64) -> Instruction {…}
    Related Procedure Groups

    inst_lsl_r_r_r ¶

    inst_lsl_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}
    Related Procedure Groups

    inst_lsl_rlo_rlo ¶

    inst_lsl_rlo_rlo :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}
    Related Procedure Groups

    inst_lsr_r_r_imm5 ¶

    inst_lsr_r_r_imm5 :: proc "contextless" (dst: Register, src: Register, imm: i64) -> Instruction {…}
    Related Procedure Groups

    inst_lsr_r_r_r ¶

    inst_lsr_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}
    Related Procedure Groups

    inst_lsr_rlo_rlo ¶

    inst_lsr_rlo_rlo :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}
    Related Procedure Groups

    inst_mcr2_cpn_cpop_r_crd ¶

    inst_mcr2_cpn_cpop_r_crd :: proc "contextless" (dst: Register, imm: i64, src: Register, src2: Register) -> Instruction {…}

    inst_mcr_cpn_cpop_r_crd ¶

    inst_mcr_cpn_cpop_r_crd :: proc "contextless" (dst: Register, imm: i64, src: Register, src2: Register) -> Instruction {…}

    inst_mcrr2_cpn_cpop_r_r ¶

    inst_mcrr2_cpn_cpop_r_r :: proc "contextless" (dst: Register, imm: i64, src: Register, src2: Register) -> Instruction {…}

    inst_mcrr_cpn_cpop_r_r ¶

    inst_mcrr_cpn_cpop_r_r :: proc "contextless" (dst: Register, imm: i64, src: Register, src2: Register) -> Instruction {…}

    inst_mla_r_r_r_r ¶

    inst_mla_r_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_mls_r_r_r_r ¶

    inst_mls_r_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_mov_r_immm ¶

    inst_mov_r_immm :: proc "contextless" (dst: Register, imm: i64) -> Instruction {…}
    Related Procedure Groups

    inst_mov_r_r ¶

    inst_mov_r_r :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}
    Related Procedure Groups

    inst_mov_r_rsh ¶

    inst_mov_r_rsh :: proc "contextless" (dst: Register, src: Register, shift: Shift_Type, amount: u8) -> Instruction {…}
    Related Procedure Groups

    inst_mov_r_rsr ¶

    inst_mov_r_rsr :: proc "contextless" (dst: Register, src: Register, shift: Shift_Type, rs: Register) -> Instruction {…}
    Related Procedure Groups

    inst_movt_r_imm16 ¶

    inst_movt_r_imm16 :: proc "contextless" (dst: Register, imm: i64) -> Instruction {…}

    inst_movw_r_imm16 ¶

    inst_movw_r_imm16 :: proc "contextless" (dst: Register, imm: i64) -> Instruction {…}

    inst_mrc2_cpn_cpop_r_crd ¶

    inst_mrc2_cpn_cpop_r_crd :: proc "contextless" (dst: Register, imm: i64, src: Register, src2: Register) -> Instruction {…}

    inst_mrc_cpn_cpop_r_crd ¶

    inst_mrc_cpn_cpop_r_crd :: proc "contextless" (dst: Register, imm: i64, src: Register, src2: Register) -> Instruction {…}

    inst_mrrc2_cpn_cpop_r_r ¶

    inst_mrrc2_cpn_cpop_r_r :: proc "contextless" (dst: Register, imm: i64, src: Register, src2: Register) -> Instruction {…}

    inst_mrrc_cpn_cpop_r_r ¶

    inst_mrrc_cpn_cpop_r_r :: proc "contextless" (dst: Register, imm: i64, src: Register, src2: Register) -> Instruction {…}

    inst_mrs_r_psr ¶

    inst_mrs_r_psr :: proc "contextless" (dst: Register, imm: i64) -> Instruction {…}

    inst_msr_psr_immm ¶

    inst_msr_psr_immm :: proc "contextless" (imm: i64, imm2: i64) -> Instruction {…}
    Related Procedure Groups

    inst_msr_psr_r ¶

    inst_msr_psr_r :: proc "contextless" (imm: i64, src: Register) -> Instruction {…}
    Related Procedure Groups

    inst_mul_r_r_r ¶

    inst_mul_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}
    Related Procedure Groups

    inst_mul_rlo_rlo ¶

    inst_mul_rlo_rlo :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}
    Related Procedure Groups

    inst_mvn_r_immm ¶

    inst_mvn_r_immm :: proc "contextless" (dst: Register, imm: i64) -> Instruction {…}
    Related Procedure Groups

    inst_mvn_r_rsh ¶

    inst_mvn_r_rsh :: proc "contextless" (dst: Register, src: Register, shift: Shift_Type, amount: u8) -> Instruction {…}
    Related Procedure Groups

    inst_mvn_r_rsr ¶

    inst_mvn_r_rsr :: proc "contextless" (dst: Register, src: Register, shift: Shift_Type, rs: Register) -> Instruction {…}
    Related Procedure Groups

    inst_mvn_rlo_rlo ¶

    inst_mvn_rlo_rlo :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}
    Related Procedure Groups

    inst_neg_rlo_rlo ¶

    inst_neg_rlo_rlo :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_none ¶

    inst_none :: proc "contextless" (m: Mnemonic, mode: Mode = .A32) -> Instruction {…}

    inst_nop_none ¶

    inst_nop_none :: proc "contextless" () -> Instruction {…}

    inst_orr_r_r_immm ¶

    inst_orr_r_r_immm :: proc "contextless" (dst: Register, src: Register, imm: i64) -> Instruction {…}
    Related Procedure Groups

    inst_orr_r_r_rsh ¶

    inst_orr_r_r_rsh :: proc "contextless" (dst: Register, src: Register, src2: Register, shift: Shift_Type, amount: u8) -> Instruction {…}
    Related Procedure Groups

    inst_orr_r_r_rsr ¶

    inst_orr_r_r_rsr :: proc "contextless" (dst: Register, src: Register, src2: Register, shift: Shift_Type, rs: Register) -> Instruction {…}
    Related Procedure Groups

    inst_orr_rlo_rlo ¶

    inst_orr_rlo_rlo :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}
    Related Procedure Groups

    inst_pac_none ¶

    inst_pac_none :: proc "contextless" () -> Instruction {…}

    inst_pacbti_none ¶

    inst_pacbti_none :: proc "contextless" () -> Instruction {…}

    inst_pkhbt_r_r_rsh ¶

    inst_pkhbt_r_r_rsh :: proc "contextless" (dst: Register, src: Register, src2: Register, shift: Shift_Type, amount: u8) -> Instruction {…}

    inst_pkhtb_r_r_rsh ¶

    inst_pkhtb_r_r_rsh :: proc "contextless" (dst: Register, src: Register, src2: Register, shift: Shift_Type, amount: u8) -> Instruction {…}

    inst_pld_mem ¶

    inst_pld_mem :: proc "contextless" (dst: Memory) -> Instruction {…}

    inst_pldw_mem ¶

    inst_pldw_mem :: proc "contextless" (dst: Memory) -> Instruction {…}

    inst_pli_mem ¶

    inst_pli_mem :: proc "contextless" (dst: Memory) -> Instruction {…}

    inst_pop_list ¶

    inst_pop_list :: proc "contextless" (regs: u16) -> Instruction {…}

    inst_psb_csync_none ¶

    inst_psb_csync_none :: proc "contextless" () -> Instruction {…}

    inst_push_list ¶

    inst_push_list :: proc "contextless" (regs: u16) -> Instruction {…}

    inst_qadd16_r_r_r ¶

    inst_qadd16_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_qadd8_r_r_r ¶

    inst_qadd8_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_qadd_r_r_r ¶

    inst_qadd_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_qasx_r_r_r ¶

    inst_qasx_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_qdadd_r_r_r ¶

    inst_qdadd_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_qdsub_r_r_r ¶

    inst_qdsub_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_qsax_r_r_r ¶

    inst_qsax_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_qsub16_r_r_r ¶

    inst_qsub16_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_qsub8_r_r_r ¶

    inst_qsub8_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_qsub_r_r_r ¶

    inst_qsub_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_r ¶

    inst_r :: proc "contextless" (m: Mnemonic, r: Register, mode: Mode = .A32) -> Instruction {…}
     

    1-operand

    inst_r_i ¶

    inst_r_i :: proc "contextless" (m: Mnemonic, rd: Register, v: i64, mode: Mode = .A32) -> Instruction {…}

    inst_r_r ¶

    inst_r_r :: proc "contextless" (m: Mnemonic, rd, rm: Register, mode: Mode = .A32) -> Instruction {…}
     

    2-operand

    inst_r_r_i ¶

    inst_r_r_i :: proc "contextless" (m: Mnemonic, rd, rn: Register, v: i64, mode: Mode = .A32) -> Instruction {…}

    inst_r_r_r ¶

    inst_r_r_r :: proc "contextless" (m: Mnemonic, rd, rn, rm: Register, mode: Mode = .A32) -> Instruction {…}
     

    3-operand data-proc (ADD/SUB/AND/etc.)

    inst_r_r_r_r ¶

    inst_r_r_r_r :: proc "contextless" (
    	m:              Mnemonic, 
    	rd, rn, rm, ra: Register, 
    	mode:           Mode = .A32, 
    ) -> Instruction {…}
     

    4-operand MLA / MLS / SMLAL etc.

    inst_r_r_r_shifted ¶

    inst_r_r_r_shifted :: proc "contextless" (
    	m:          Mnemonic, 
    	rd, rn, rm: Register, 
    	st:         Shift_Type, 
    	amt:        u8, 
    	mode:       Mode = .A32, 
    ) -> Instruction {…}

    inst_rbit_r_r ¶

    inst_rbit_r_r :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_rev16_r_r ¶

    inst_rev16_r_r :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_rev_r_r ¶

    inst_rev_r_r :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_revsh_r_r ¶

    inst_revsh_r_r :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_rfe_r ¶

    inst_rfe_r :: proc "contextless" (dst: Register) -> Instruction {…}

    inst_ror_r_r_imm5 ¶

    inst_ror_r_r_imm5 :: proc "contextless" (dst: Register, src: Register, imm: i64) -> Instruction {…}
    Related Procedure Groups

    inst_ror_r_r_r ¶

    inst_ror_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}
    Related Procedure Groups

    inst_ror_rlo_rlo ¶

    inst_ror_rlo_rlo :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}
    Related Procedure Groups

    inst_rrx_r_r ¶

    inst_rrx_r_r :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_rsb_r_r_immm ¶

    inst_rsb_r_r_immm :: proc "contextless" (dst: Register, src: Register, imm: i64) -> Instruction {…}
    Related Procedure Groups

    inst_rsb_r_r_rsh ¶

    inst_rsb_r_r_rsh :: proc "contextless" (dst: Register, src: Register, src2: Register, shift: Shift_Type, amount: u8) -> Instruction {…}
    Related Procedure Groups

    inst_rsb_r_r_rsr ¶

    inst_rsb_r_r_rsr :: proc "contextless" (dst: Register, src: Register, src2: Register, shift: Shift_Type, rs: Register) -> Instruction {…}
    Related Procedure Groups

    inst_rsc_r_r_immm ¶

    inst_rsc_r_r_immm :: proc "contextless" (dst: Register, src: Register, imm: i64) -> Instruction {…}
    Related Procedure Groups

    inst_rsc_r_r_rsh ¶

    inst_rsc_r_r_rsh :: proc "contextless" (dst: Register, src: Register, src2: Register, shift: Shift_Type, amount: u8) -> Instruction {…}
    Related Procedure Groups

    inst_rsc_r_r_rsr ¶

    inst_rsc_r_r_rsr :: proc "contextless" (dst: Register, src: Register, src2: Register, shift: Shift_Type, rs: Register) -> Instruction {…}
    Related Procedure Groups

    inst_sadd16_r_r_r ¶

    inst_sadd16_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_sadd8_r_r_r ¶

    inst_sadd8_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_sasx_r_r_r ¶

    inst_sasx_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_sb_none ¶

    inst_sb_none :: proc "contextless" () -> Instruction {…}

    inst_sbc_r_r_immm ¶

    inst_sbc_r_r_immm :: proc "contextless" (dst: Register, src: Register, imm: i64) -> Instruction {…}
    Related Procedure Groups

    inst_sbc_r_r_rsh ¶

    inst_sbc_r_r_rsh :: proc "contextless" (dst: Register, src: Register, src2: Register, shift: Shift_Type, amount: u8) -> Instruction {…}
    Related Procedure Groups

    inst_sbc_r_r_rsr ¶

    inst_sbc_r_r_rsr :: proc "contextless" (dst: Register, src: Register, src2: Register, shift: Shift_Type, rs: Register) -> Instruction {…}
    Related Procedure Groups

    inst_sbc_rlo_rlo ¶

    inst_sbc_rlo_rlo :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}
    Related Procedure Groups

    inst_sbfx_r_r_imm5_imm5w ¶

    inst_sbfx_r_r_imm5_imm5w :: proc "contextless" (dst: Register, src: Register, imm: i64, imm2: i64) -> Instruction {…}

    inst_sdiv_r_r_r ¶

    inst_sdiv_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_sel_r_r_r ¶

    inst_sel_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_set_cond ¶

    inst_set_cond :: proc "contextless" (inst: Instruction, cond: u8) -> Instruction {…}
     

    Set condition code on any builder

    inst_set_flags ¶

    inst_set_flags :: proc "contextless" (inst: Instruction) -> Instruction {…}
     

    Set S flag (sets APSR.NZCV)

    inst_setend_end ¶

    inst_setend_end :: proc "contextless" (imm: i64) -> Instruction {…}

    inst_setpan_hint ¶

    inst_setpan_hint :: proc "contextless" (imm: i64) -> Instruction {…}

    inst_sev_none ¶

    inst_sev_none :: proc "contextless" () -> Instruction {…}

    inst_sevl_none ¶

    inst_sevl_none :: proc "contextless" () -> Instruction {…}

    inst_sg_none ¶

    inst_sg_none :: proc "contextless" () -> Instruction {…}

    inst_sha1c_q_q_q ¶

    inst_sha1c_q_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_sha1h_q_q ¶

    inst_sha1h_q_q :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_sha1m_q_q_q ¶

    inst_sha1m_q_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_sha1p_q_q_q ¶

    inst_sha1p_q_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_sha1su0_q_q_q ¶

    inst_sha1su0_q_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_sha1su1_q_q ¶

    inst_sha1su1_q_q :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_sha256h2_q_q_q ¶

    inst_sha256h2_q_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_sha256h_q_q_q ¶

    inst_sha256h_q_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_sha256su0_q_q ¶

    inst_sha256su0_q_q :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_sha256su1_q_q_q ¶

    inst_sha256su1_q_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_shadd16_r_r_r ¶

    inst_shadd16_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_shadd8_r_r_r ¶

    inst_shadd8_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_shasx_r_r_r ¶

    inst_shasx_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_shsax_r_r_r ¶

    inst_shsax_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_shsub16_r_r_r ¶

    inst_shsub16_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_shsub8_r_r_r ¶

    inst_shsub8_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_size_from_bits ¶

    inst_size_from_bits :: proc "contextless" (bits: u32, mode: Mode) -> u8 {…}

    inst_smc_imm ¶

    inst_smc_imm :: proc "contextless" (imm: i64) -> Instruction {…}

    inst_smlabb_r_r_r_r ¶

    inst_smlabb_r_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_smlabt_r_r_r_r ¶

    inst_smlabt_r_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_smlad_r_r_r_r ¶

    inst_smlad_r_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_smladx_r_r_r_r ¶

    inst_smladx_r_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_smlal_r_r_r_r ¶

    inst_smlal_r_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_smlalbb_r_r_r_r ¶

    inst_smlalbb_r_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_smlalbt_r_r_r_r ¶

    inst_smlalbt_r_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_smlald_r_r_r_r ¶

    inst_smlald_r_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_smlaldx_r_r_r_r ¶

    inst_smlaldx_r_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_smlaltb_r_r_r_r ¶

    inst_smlaltb_r_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_smlaltt_r_r_r_r ¶

    inst_smlaltt_r_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_smlatb_r_r_r_r ¶

    inst_smlatb_r_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_smlatt_r_r_r_r ¶

    inst_smlatt_r_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_smlawb_r_r_r_r ¶

    inst_smlawb_r_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_smlawt_r_r_r_r ¶

    inst_smlawt_r_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_smlsd_r_r_r_r ¶

    inst_smlsd_r_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_smlsdx_r_r_r_r ¶

    inst_smlsdx_r_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_smlsld_r_r_r_r ¶

    inst_smlsld_r_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_smlsldx_r_r_r_r ¶

    inst_smlsldx_r_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_smmla_r_r_r_r ¶

    inst_smmla_r_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_smmlar_r_r_r_r ¶

    inst_smmlar_r_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_smmls_r_r_r_r ¶

    inst_smmls_r_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_smmlsr_r_r_r_r ¶

    inst_smmlsr_r_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_smmul_r_r_r ¶

    inst_smmul_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_smmulr_r_r_r ¶

    inst_smmulr_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_smuad_r_r_r ¶

    inst_smuad_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_smuadx_r_r_r ¶

    inst_smuadx_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_smulbb_r_r_r ¶

    inst_smulbb_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_smulbt_r_r_r ¶

    inst_smulbt_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_smull_r_r_r_r ¶

    inst_smull_r_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_smultb_r_r_r ¶

    inst_smultb_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_smultt_r_r_r ¶

    inst_smultt_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_smulwb_r_r_r ¶

    inst_smulwb_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_smulwt_r_r_r ¶

    inst_smulwt_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_smusd_r_r_r ¶

    inst_smusd_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_smusdx_r_r_r ¶

    inst_smusdx_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_srs_imm ¶

    inst_srs_imm :: proc "contextless" (imm: i64) -> Instruction {…}

    inst_ssat16_r_imm4s_r ¶

    inst_ssat16_r_imm4s_r :: proc "contextless" (dst: Register, imm: i64, src: Register) -> Instruction {…}

    inst_ssat_r_imm4s_rsh ¶

    inst_ssat_r_imm4s_rsh :: proc "contextless" (dst: Register, imm: i64, src: Register, shift: Shift_Type, amount: u8) -> Instruction {…}

    inst_ssax_r_r_r ¶

    inst_ssax_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_ssub16_r_r_r ¶

    inst_ssub16_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_ssub8_r_r_r ¶

    inst_ssub8_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_stc2_cpn_crd_mem ¶

    inst_stc2_cpn_crd_mem :: proc "contextless" (dst: Register, src: Register, src2: Memory) -> Instruction {…}

    inst_stc_cpn_crd_mem ¶

    inst_stc_cpn_crd_mem :: proc "contextless" (dst: Register, src: Register, src2: Memory) -> Instruction {…}

    inst_stl_r_mem ¶

    inst_stl_r_mem :: proc "contextless" (dst: Register, src: Memory) -> Instruction {…}

    inst_stlb_r_mem ¶

    inst_stlb_r_mem :: proc "contextless" (dst: Register, src: Memory) -> Instruction {…}

    inst_stlex_r_r_mem ¶

    inst_stlex_r_r_mem :: proc "contextless" (dst: Register, src: Register, src2: Memory) -> Instruction {…}

    inst_stlexb_r_r_mem ¶

    inst_stlexb_r_r_mem :: proc "contextless" (dst: Register, src: Register, src2: Memory) -> Instruction {…}

    inst_stlexd_r_r_mem ¶

    inst_stlexd_r_r_mem :: proc "contextless" (dst: Register, src: Register, src2: Memory) -> Instruction {…}

    inst_stlexh_r_r_mem ¶

    inst_stlexh_r_r_mem :: proc "contextless" (dst: Register, src: Register, src2: Memory) -> Instruction {…}

    inst_stlh_r_mem ¶

    inst_stlh_r_mem :: proc "contextless" (dst: Register, src: Memory) -> Instruction {…}

    inst_stm_r_list ¶

    inst_stm_r_list :: proc "contextless" (dst: Register, regs: u16) -> Instruction {…}

    inst_store ¶

    inst_store :: proc "contextless" (m: Mnemonic, rd: Register, mm: Memory, mode: Mode = .A32) -> Instruction {…}

    inst_str_r_mem ¶

    inst_str_r_mem :: proc "contextless" (dst: Register, src: Memory) -> Instruction {…}

    inst_strb_r_mem ¶

    inst_strb_r_mem :: proc "contextless" (dst: Register, src: Memory) -> Instruction {…}

    inst_strbt_r_mem ¶

    inst_strbt_r_mem :: proc "contextless" (dst: Register, src: Memory) -> Instruction {…}

    inst_strd_r_mem ¶

    inst_strd_r_mem :: proc "contextless" (dst: Register, src: Memory) -> Instruction {…}
    Related Procedure Groups

    inst_strd_r_r_mem ¶

    inst_strd_r_r_mem :: proc "contextless" (dst: Register, src: Register, src2: Memory) -> Instruction {…}
    Related Procedure Groups

    inst_strex_r_r_mem ¶

    inst_strex_r_r_mem :: proc "contextless" (dst: Register, src: Register, src2: Memory) -> Instruction {…}

    inst_strexb_r_r_mem ¶

    inst_strexb_r_r_mem :: proc "contextless" (dst: Register, src: Register, src2: Memory) -> Instruction {…}

    inst_strexd_r_r_mem ¶

    inst_strexd_r_r_mem :: proc "contextless" (dst: Register, src: Register, src2: Memory) -> Instruction {…}
    Related Procedure Groups

    inst_strexd_r_r_r_mem ¶

    inst_strexd_r_r_r_mem :: proc "contextless" (dst: Register, src: Register, src2: Register, src3: Memory) -> Instruction {…}
    Related Procedure Groups

    inst_strexh_r_r_mem ¶

    inst_strexh_r_r_mem :: proc "contextless" (dst: Register, src: Register, src2: Memory) -> Instruction {…}

    inst_strh_r_mem ¶

    inst_strh_r_mem :: proc "contextless" (dst: Register, src: Memory) -> Instruction {…}

    inst_strht_r_mem ¶

    inst_strht_r_mem :: proc "contextless" (dst: Register, src: Memory) -> Instruction {…}

    inst_strt_r_mem ¶

    inst_strt_r_mem :: proc "contextless" (dst: Register, src: Memory) -> Instruction {…}

    inst_sub_r_r_immm ¶

    inst_sub_r_r_immm :: proc "contextless" (dst: Register, src: Register, imm: i64) -> Instruction {…}
    Related Procedure Groups

    inst_sub_r_r_rsh ¶

    inst_sub_r_r_rsh :: proc "contextless" (dst: Register, src: Register, src2: Register, shift: Shift_Type, amount: u8) -> Instruction {…}
    Related Procedure Groups

    inst_sub_r_r_rsr ¶

    inst_sub_r_r_rsr :: proc "contextless" (dst: Register, src: Register, src2: Register, shift: Shift_Type, rs: Register) -> Instruction {…}
    Related Procedure Groups

    inst_sub_rlo_imm8 ¶

    inst_sub_rlo_imm8 :: proc "contextless" (dst: Register, imm: i64) -> Instruction {…}
    Related Procedure Groups

    inst_sub_rlo_rlo_rlo ¶

    inst_sub_rlo_rlo_rlo :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}
    Related Procedure Groups

    inst_svc_imm ¶

    inst_svc_imm :: proc "contextless" (imm: i64) -> Instruction {…}

    inst_swp_r_r_r ¶

    inst_swp_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_swpb_r_r_r ¶

    inst_swpb_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_sxtab16_r_r_r ¶

    inst_sxtab16_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_sxtab_r_r_r ¶

    inst_sxtab_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_sxtah_r_r_r ¶

    inst_sxtah_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_sxtb16_r_r ¶

    inst_sxtb16_r_r :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_sxtb_r_r ¶

    inst_sxtb_r_r :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_sxth_r_r ¶

    inst_sxth_r_r :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_tbb_r_r ¶

    inst_tbb_r_r :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_tbh_r_r ¶

    inst_tbh_r_r :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_teq_r_immm ¶

    inst_teq_r_immm :: proc "contextless" (dst: Register, imm: i64) -> Instruction {…}
    Related Procedure Groups

    inst_teq_r_rsh ¶

    inst_teq_r_rsh :: proc "contextless" (dst: Register, src: Register, shift: Shift_Type, amount: u8) -> Instruction {…}
    Related Procedure Groups

    inst_teq_r_rsr ¶

    inst_teq_r_rsr :: proc "contextless" (dst: Register, src: Register, shift: Shift_Type, rs: Register) -> Instruction {…}
    Related Procedure Groups

    inst_tsb_csync_none ¶

    inst_tsb_csync_none :: proc "contextless" () -> Instruction {…}

    inst_tst_r_immm ¶

    inst_tst_r_immm :: proc "contextless" (dst: Register, imm: i64) -> Instruction {…}
    Related Procedure Groups

    inst_tst_r_rsh ¶

    inst_tst_r_rsh :: proc "contextless" (dst: Register, src: Register, shift: Shift_Type, amount: u8) -> Instruction {…}
    Related Procedure Groups

    inst_tst_r_rsr ¶

    inst_tst_r_rsr :: proc "contextless" (dst: Register, src: Register, shift: Shift_Type, rs: Register) -> Instruction {…}
    Related Procedure Groups

    inst_tst_rlo_rlo ¶

    inst_tst_rlo_rlo :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}
    Related Procedure Groups

    inst_tt_r_r ¶

    inst_tt_r_r :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_tta_r_r ¶

    inst_tta_r_r :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_ttat_r_r ¶

    inst_ttat_r_r :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_ttt_r_r ¶

    inst_ttt_r_r :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_uadd16_r_r_r ¶

    inst_uadd16_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_uadd8_r_r_r ¶

    inst_uadd8_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_uasx_r_r_r ¶

    inst_uasx_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_ubfx_r_r_imm5_imm5w ¶

    inst_ubfx_r_r_imm5_imm5w :: proc "contextless" (dst: Register, src: Register, imm: i64, imm2: i64) -> Instruction {…}

    inst_udf_imm ¶

    inst_udf_imm :: proc "contextless" (imm: i64) -> Instruction {…}

    inst_udiv_r_r_r ¶

    inst_udiv_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_uhadd16_r_r_r ¶

    inst_uhadd16_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_uhadd8_r_r_r ¶

    inst_uhadd8_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_uhasx_r_r_r ¶

    inst_uhasx_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_uhsax_r_r_r ¶

    inst_uhsax_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_uhsub16_r_r_r ¶

    inst_uhsub16_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_uhsub8_r_r_r ¶

    inst_uhsub8_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_umaal_r_r_r_r ¶

    inst_umaal_r_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_umlal_r_r_r_r ¶

    inst_umlal_r_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_umull_r_r_r_r ¶

    inst_umull_r_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_uqadd16_r_r_r ¶

    inst_uqadd16_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_uqadd8_r_r_r ¶

    inst_uqadd8_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_uqasx_r_r_r ¶

    inst_uqasx_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_uqsax_r_r_r ¶

    inst_uqsax_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_uqsub16_r_r_r ¶

    inst_uqsub16_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_uqsub8_r_r_r ¶

    inst_uqsub8_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_usad8_r_r_r ¶

    inst_usad8_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_usada8_r_r_r_r ¶

    inst_usada8_r_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_usat16_r_imm4s_r ¶

    inst_usat16_r_imm4s_r :: proc "contextless" (dst: Register, imm: i64, src: Register) -> Instruction {…}

    inst_usat_r_imm4s_rsh ¶

    inst_usat_r_imm4s_rsh :: proc "contextless" (dst: Register, imm: i64, src: Register, shift: Shift_Type, amount: u8) -> Instruction {…}

    inst_usax_r_r_r ¶

    inst_usax_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_usub16_r_r_r ¶

    inst_usub16_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_usub8_r_r_r ¶

    inst_usub8_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_uxtab16_r_r_r ¶

    inst_uxtab16_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_uxtab_r_r_r ¶

    inst_uxtab_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_uxtah_r_r_r ¶

    inst_uxtah_r_r_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_uxtb16_r_r ¶

    inst_uxtb16_r_r :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_uxtb_r_r ¶

    inst_uxtb_r_r :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_uxth_r_r ¶

    inst_uxth_r_r :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vaba_d_d_d ¶

    inst_vaba_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vabal_q_d_d ¶

    inst_vabal_q_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vabav_r_q_q ¶

    inst_vabav_r_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vabd_d_d_d ¶

    inst_vabd_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vabdl_q_d_d ¶

    inst_vabdl_q_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vabs_s_s ¶

    inst_vabs_s_s :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vacge_d_d_d ¶

    inst_vacge_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vacgt_d_d_d ¶

    inst_vacgt_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vacle_d_d_d ¶

    inst_vacle_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vaclt_d_d_d ¶

    inst_vaclt_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vadd_s_s_s ¶

    inst_vadd_s_s_s :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vaddl_q_d_d ¶

    inst_vaddl_q_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vaddlv_r_r_q ¶

    inst_vaddlv_r_r_q :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vaddlva_r_r_q ¶

    inst_vaddlva_r_r_q :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vaddv_r_q ¶

    inst_vaddv_r_q :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vaddva_r_q ¶

    inst_vaddva_r_q :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vaddw_q_q_d ¶

    inst_vaddw_q_q_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vand_d_d_d ¶

    inst_vand_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vbic_d_d_d ¶

    inst_vbic_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vbif_d_d_d ¶

    inst_vbif_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vbit_d_d_d ¶

    inst_vbit_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vbrsr_q_q_r ¶

    inst_vbrsr_q_q_r :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vbsl_d_d_d ¶

    inst_vbsl_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vcadd_d_d_d_imm ¶

    inst_vcadd_d_d_d_imm :: proc "contextless" (dst: Register, src: Register, src2: Register, imm: i64) -> Instruction {…}

    inst_vceq_d_d_d ¶

    inst_vceq_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vceq_z_d_d ¶

    inst_vceq_z_d_d :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vcge_d_d_d ¶

    inst_vcge_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vcge_z_d_d ¶

    inst_vcge_z_d_d :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vcgt_d_d_d ¶

    inst_vcgt_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vcgt_z_d_d ¶

    inst_vcgt_z_d_d :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vcle_d_d_d ¶

    inst_vcle_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vcle_z_d_d ¶

    inst_vcle_z_d_d :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vcls_d_d ¶

    inst_vcls_d_d :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vclt_d_d_d ¶

    inst_vclt_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vclt_z_d_d ¶

    inst_vclt_z_d_d :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vclz_d_d ¶

    inst_vclz_d_d :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vcmla_d_d_d_imm ¶

    inst_vcmla_d_d_d_imm :: proc "contextless" (dst: Register, src: Register, src2: Register, imm: i64) -> Instruction {…}

    inst_vcmla_lane_d_d_dlane_imm ¶

    inst_vcmla_lane_d_d_dlane_imm :: proc "contextless" (dst: Register, src: Register, src2: Register, lane: u8, imm: i64) -> Instruction {…}

    inst_vcmla_mve_q_q_q_imm ¶

    inst_vcmla_mve_q_q_q_imm :: proc "contextless" (dst: Register, src: Register, src2: Register, imm: i64) -> Instruction {…}

    inst_vcmp_s ¶

    inst_vcmp_s :: proc "contextless" (dst: Register) -> Instruction {…}
    Related Procedure Groups

    inst_vcmp_s_s ¶

    inst_vcmp_s_s :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}
    Related Procedure Groups

    inst_vcmpe_s ¶

    inst_vcmpe_s :: proc "contextless" (dst: Register) -> Instruction {…}
    Related Procedure Groups

    inst_vcmpe_s_s ¶

    inst_vcmpe_s_s :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}
    Related Procedure Groups

    inst_vcmul_q_q_q ¶

    inst_vcmul_q_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vcnt_d_d ¶

    inst_vcnt_d_d :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vctp_r ¶

    inst_vctp_r :: proc "contextless" (dst: Register) -> Instruction {…}

    inst_vcvt_bf16_d_q ¶

    inst_vcvt_bf16_d_q :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vcvt_d_s ¶

    inst_vcvt_d_s :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vcvt_fixed_s_s_imm ¶

    inst_vcvt_fixed_s_s_imm :: proc "contextless" (dst: Register, src: Register, imm: i64) -> Instruction {…}

    inst_vcvta_s_s ¶

    inst_vcvta_s_s :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vcvtb_s_s ¶

    inst_vcvtb_s_s :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vcvtm_s_s ¶

    inst_vcvtm_s_s :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vcvtn_s_s ¶

    inst_vcvtn_s_s :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vcvtp_s_s ¶

    inst_vcvtp_s_s :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vcvtr_s_s ¶

    inst_vcvtr_s_s :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vcvtt_s_s ¶

    inst_vcvtt_s_s :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vcx1_cp_s_imm ¶

    inst_vcx1_cp_s_imm :: proc "contextless" (imm: i64, src: Register, imm2: i64) -> Instruction {…}

    inst_vcx1a_cp_s_imm ¶

    inst_vcx1a_cp_s_imm :: proc "contextless" (imm: i64, src: Register, imm2: i64) -> Instruction {…}

    inst_vcx2_cp_s_s_imm ¶

    inst_vcx2_cp_s_s_imm :: proc "contextless" (imm: i64, src: Register, src2: Register, imm2: i64) -> Instruction {…}

    inst_vcx2a_cp_s_s_imm ¶

    inst_vcx2a_cp_s_s_imm :: proc "contextless" (imm: i64, src: Register, src2: Register, imm2: i64) -> Instruction {…}

    inst_vcx3_cp_s_s_s ¶

    inst_vcx3_cp_s_s_s :: proc "contextless" (imm: i64, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_vcx3a_cp_s_s_s ¶

    inst_vcx3a_cp_s_s_s :: proc "contextless" (imm: i64, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_vddup_q_r_imm ¶

    inst_vddup_q_r_imm :: proc "contextless" (dst: Register, src: Register, imm: i64) -> Instruction {…}

    inst_vdiv_s_s_s ¶

    inst_vdiv_s_s_s :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vdot_bf16_d_d_d ¶

    inst_vdot_bf16_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vdup_d_dlane ¶

    inst_vdup_d_dlane :: proc "contextless" (dst: Register, src: Register, lane: u8) -> Instruction {…}
    Related Procedure Groups

    inst_vdup_d_r ¶

    inst_vdup_d_r :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}
    Related Procedure Groups

    inst_vdwdup_q_r_r_imm ¶

    inst_vdwdup_q_r_r_imm :: proc "contextless" (dst: Register, src: Register, src2: Register, imm: i64) -> Instruction {…}

    inst_veor_d_d_d ¶

    inst_veor_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vext_d_d_d_imm4 ¶

    inst_vext_d_d_d_imm4 :: proc "contextless" (dst: Register, src: Register, src2: Register, imm: i64) -> Instruction {…}

    inst_vfma_bf16_q_q_q ¶

    inst_vfma_bf16_q_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vfma_lane_d_d_dlane ¶

    inst_vfma_lane_d_d_dlane :: proc "contextless" (dst: Register, src: Register, src2: Register, lane: u8) -> Instruction {…}

    inst_vfma_s_s_s ¶

    inst_vfma_s_s_s :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vfmal_d_d_d ¶

    inst_vfmal_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vfms_lane_d_d_dlane ¶

    inst_vfms_lane_d_d_dlane :: proc "contextless" (dst: Register, src: Register, src2: Register, lane: u8) -> Instruction {…}

    inst_vfms_s_s_s ¶

    inst_vfms_s_s_s :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vfmsl_d_d_d ¶

    inst_vfmsl_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vfnma_s_s_s ¶

    inst_vfnma_s_s_s :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vfnms_s_s_s ¶

    inst_vfnms_s_s_s :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vhadd_d_d_d ¶

    inst_vhadd_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vhcadd_q_q_q ¶

    inst_vhcadd_q_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vhcadd_sat_q_q_q_imm ¶

    inst_vhcadd_sat_q_q_q_imm :: proc "contextless" (dst: Register, src: Register, src2: Register, imm: i64) -> Instruction {…}

    inst_vhsub_d_d_d ¶

    inst_vhsub_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vidup_q_r_imm ¶

    inst_vidup_q_r_imm :: proc "contextless" (dst: Register, src: Register, imm: i64) -> Instruction {…}

    inst_vins_s_s ¶

    inst_vins_s_s :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_viwdup_q_r_r_imm ¶

    inst_viwdup_q_r_r_imm :: proc "contextless" (dst: Register, src: Register, src2: Register, imm: i64) -> Instruction {…}

    inst_vjcvt_s_d ¶

    inst_vjcvt_s_d :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vld1_dlane_mem ¶

    inst_vld1_dlane_mem :: proc "contextless" (dst: Register, lane: u8, src: Memory) -> Instruction {…}
    Related Procedure Groups

    inst_vld1_dlist_mem ¶

    inst_vld1_dlist_mem :: proc "contextless" (regs: u16, src: Memory) -> Instruction {…}
    Related Procedure Groups

    inst_vld1_lane_dlane_mem ¶

    inst_vld1_lane_dlane_mem :: proc "contextless" (dst: Register, lane: u8, src: Memory) -> Instruction {…}

    inst_vld20_qlist_mem ¶

    inst_vld20_qlist_mem :: proc "contextless" (regs: u16, src: Memory) -> Instruction {…}

    inst_vld21_qlist_mem ¶

    inst_vld21_qlist_mem :: proc "contextless" (regs: u16, src: Memory) -> Instruction {…}

    inst_vld2_dlist_mem ¶

    inst_vld2_dlist_mem :: proc "contextless" (regs: u16, src: Memory) -> Instruction {…}

    inst_vld2_lane_dlist_mem ¶

    inst_vld2_lane_dlist_mem :: proc "contextless" (regs: u16, src: Memory) -> Instruction {…}

    inst_vld2r_dlist_mem ¶

    inst_vld2r_dlist_mem :: proc "contextless" (regs: u16, src: Memory) -> Instruction {…}

    inst_vld3_dlist_mem ¶

    inst_vld3_dlist_mem :: proc "contextless" (regs: u16, src: Memory) -> Instruction {…}

    inst_vld3_lane_dlist_mem ¶

    inst_vld3_lane_dlist_mem :: proc "contextless" (regs: u16, src: Memory) -> Instruction {…}

    inst_vld3r_dlist_mem ¶

    inst_vld3r_dlist_mem :: proc "contextless" (regs: u16, src: Memory) -> Instruction {…}

    inst_vld40_qlist_mem ¶

    inst_vld40_qlist_mem :: proc "contextless" (regs: u16, src: Memory) -> Instruction {…}

    inst_vld41_qlist_mem ¶

    inst_vld41_qlist_mem :: proc "contextless" (regs: u16, src: Memory) -> Instruction {…}

    inst_vld42_qlist_mem ¶

    inst_vld42_qlist_mem :: proc "contextless" (regs: u16, src: Memory) -> Instruction {…}

    inst_vld43_qlist_mem ¶

    inst_vld43_qlist_mem :: proc "contextless" (regs: u16, src: Memory) -> Instruction {…}

    inst_vld4_dlist_mem ¶

    inst_vld4_dlist_mem :: proc "contextless" (regs: u16, src: Memory) -> Instruction {…}

    inst_vld4_lane_dlist_mem ¶

    inst_vld4_lane_dlist_mem :: proc "contextless" (regs: u16, src: Memory) -> Instruction {…}

    inst_vld4r_dlist_mem ¶

    inst_vld4r_dlist_mem :: proc "contextless" (regs: u16, src: Memory) -> Instruction {…}

    inst_vldm_r_slist ¶

    inst_vldm_r_slist :: proc "contextless" (dst: Register, regs: u16) -> Instruction {…}

    inst_vldr_s_mem ¶

    inst_vldr_s_mem :: proc "contextless" (dst: Register, src: Memory) -> Instruction {…}

    inst_vldrb_gather_q_mem_q ¶

    inst_vldrb_gather_q_mem_q :: proc "contextless" (dst: Register, src: Memory, src2: Register) -> Instruction {…}

    inst_vldrb_q_mem ¶

    inst_vldrb_q_mem :: proc "contextless" (dst: Register, src: Memory) -> Instruction {…}

    inst_vldrd_gather_q_mem_q ¶

    inst_vldrd_gather_q_mem_q :: proc "contextless" (dst: Register, src: Memory, src2: Register) -> Instruction {…}

    inst_vldrd_q_mem ¶

    inst_vldrd_q_mem :: proc "contextless" (dst: Register, src: Memory) -> Instruction {…}

    inst_vldrh_gather_q_mem_q ¶

    inst_vldrh_gather_q_mem_q :: proc "contextless" (dst: Register, src: Memory, src2: Register) -> Instruction {…}

    inst_vldrh_q_mem ¶

    inst_vldrh_q_mem :: proc "contextless" (dst: Register, src: Memory) -> Instruction {…}

    inst_vldrw_gather_q_mem_q ¶

    inst_vldrw_gather_q_mem_q :: proc "contextless" (dst: Register, src: Memory, src2: Register) -> Instruction {…}

    inst_vldrw_q_mem ¶

    inst_vldrw_q_mem :: proc "contextless" (dst: Register, src: Memory) -> Instruction {…}

    inst_vmax_d_d_d ¶

    inst_vmax_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vmaxav_r_q ¶

    inst_vmaxav_r_q :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vmaxnm_s_s_s ¶

    inst_vmaxnm_s_s_s :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vmaxnmav_r_q ¶

    inst_vmaxnmav_r_q :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vmaxnmv_r_q ¶

    inst_vmaxnmv_r_q :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vmaxv_r_q ¶

    inst_vmaxv_r_q :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vmin_d_d_d ¶

    inst_vmin_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vminav_r_q ¶

    inst_vminav_r_q :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vminnm_s_s_s ¶

    inst_vminnm_s_s_s :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vminnmav_r_q ¶

    inst_vminnmav_r_q :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vminnmv_r_q ¶

    inst_vminnmv_r_q :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vminv_r_q ¶

    inst_vminv_r_q :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vmla_lane_d_d_dlane ¶

    inst_vmla_lane_d_d_dlane :: proc "contextless" (dst: Register, src: Register, src2: Register, lane: u8) -> Instruction {…}

    inst_vmla_s_s_s ¶

    inst_vmla_s_s_s :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vmladav_r_q_q ¶

    inst_vmladav_r_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vmladava_r_q_q ¶

    inst_vmladava_r_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vmladavax_r_q_q ¶

    inst_vmladavax_r_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vmladavx_r_q_q ¶

    inst_vmladavx_r_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vmlal_lane_q_d_dlane ¶

    inst_vmlal_lane_q_d_dlane :: proc "contextless" (dst: Register, src: Register, src2: Register, lane: u8) -> Instruction {…}

    inst_vmlal_q_d_d ¶

    inst_vmlal_q_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vmlalb_q_q_q ¶

    inst_vmlalb_q_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vmlaldav_r_r_q_q ¶

    inst_vmlaldav_r_r_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_vmlaldava_r_r_q_q ¶

    inst_vmlaldava_r_r_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_vmlaldavax_r_r_q_q ¶

    inst_vmlaldavax_r_r_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_vmlaldavx_r_r_q_q ¶

    inst_vmlaldavx_r_r_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_vmlalt_q_q_q ¶

    inst_vmlalt_q_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vmlav_r_q_q ¶

    inst_vmlav_r_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vmlava_r_q_q ¶

    inst_vmlava_r_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vmls_lane_d_d_dlane ¶

    inst_vmls_lane_d_d_dlane :: proc "contextless" (dst: Register, src: Register, src2: Register, lane: u8) -> Instruction {…}

    inst_vmls_s_s_s ¶

    inst_vmls_s_s_s :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vmlsdav_r_q_q ¶

    inst_vmlsdav_r_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vmlsdava_r_q_q ¶

    inst_vmlsdava_r_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vmlsdavax_r_q_q ¶

    inst_vmlsdavax_r_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vmlsdavx_r_q_q ¶

    inst_vmlsdavx_r_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vmlsl_lane_q_d_dlane ¶

    inst_vmlsl_lane_q_d_dlane :: proc "contextless" (dst: Register, src: Register, src2: Register, lane: u8) -> Instruction {…}

    inst_vmlsl_q_d_d ¶

    inst_vmlsl_q_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vmlslb_q_q_q ¶

    inst_vmlslb_q_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vmlsldav_r_r_q_q ¶

    inst_vmlsldav_r_r_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_vmlsldava_r_r_q_q ¶

    inst_vmlsldava_r_r_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_vmlsldavax_r_r_q_q ¶

    inst_vmlsldavax_r_r_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_vmlsldavx_r_r_q_q ¶

    inst_vmlsldavx_r_r_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_vmlslt_q_q_q ¶

    inst_vmlslt_q_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vmlsv_r_q_q ¶

    inst_vmlsv_r_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vmlsva_r_q_q ¶

    inst_vmlsva_r_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vmmla_bf16_q_q_q ¶

    inst_vmmla_bf16_q_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vmov_2gpr_q_qlane_qlane_r_r ¶

    inst_vmov_2gpr_q_qlane_qlane_r_r :: proc "contextless" (
    	dst:   Register, 
    	lane:  u8, 
    	src:   Register, 
    	lane2: u8, 
    	src2:  Register, 
    	src3:  Register, 
    ) -> Instruction {…}

    inst_vmov_dlane_r ¶

    inst_vmov_dlane_r :: proc "contextless" (dst: Register, lane: u8, src: Register) -> Instruction {…}
    Related Procedure Groups

    inst_vmov_lane_dlane_r ¶

    inst_vmov_lane_dlane_r :: proc "contextless" (dst: Register, lane: u8, src: Register) -> Instruction {…}

    inst_vmov_q_r_qlane_r ¶

    inst_vmov_q_r_qlane_r :: proc "contextless" (dst: Register, lane: u8, src: Register) -> Instruction {…}

    inst_vmov_r_dlane ¶

    inst_vmov_r_dlane :: proc "contextless" (dst: Register, src: Register, lane: u8) -> Instruction {…}
    Related Procedure Groups

    inst_vmov_r_q_r_qlane ¶

    inst_vmov_r_q_r_qlane :: proc "contextless" (dst: Register, src: Register, lane: u8) -> Instruction {…}

    inst_vmov_r_r_d ¶

    inst_vmov_r_r_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}
    Related Procedure Groups

    inst_vmov_r_r_s_s ¶

    inst_vmov_r_r_s_s :: proc "contextless" (dst: Register, src: Register, src2: Register, src3: Register) -> Instruction {…}
    Related Procedure Groups

    inst_vmov_s_imm8 ¶

    inst_vmov_s_imm8 :: proc "contextless" (dst: Register, imm: i64) -> Instruction {…}
    Related Procedure Groups

    inst_vmov_s_s ¶

    inst_vmov_s_s :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}
    Related Procedure Groups

    inst_vmovl_q_d ¶

    inst_vmovl_q_d :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vmovn_d_q ¶

    inst_vmovn_d_q :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vmovnb_q_q ¶

    inst_vmovnb_q_q :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vmovnt_q_q ¶

    inst_vmovnt_q_q :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vmovx_s_s ¶

    inst_vmovx_s_s :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vmrs_r ¶

    inst_vmrs_r :: proc "contextless" (dst: Register) -> Instruction {…}

    inst_vmsr_r ¶

    inst_vmsr_r :: proc "contextless" (dst: Register) -> Instruction {…}

    inst_vmul_lane_d_d_dlane ¶

    inst_vmul_lane_d_d_dlane :: proc "contextless" (dst: Register, src: Register, src2: Register, lane: u8) -> Instruction {…}

    inst_vmul_s_s_s ¶

    inst_vmul_s_s_s :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vmull_lane_q_d_dlane ¶

    inst_vmull_lane_q_d_dlane :: proc "contextless" (dst: Register, src: Register, src2: Register, lane: u8) -> Instruction {…}

    inst_vmull_q_d_d ¶

    inst_vmull_q_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vmullb_q_q_q ¶

    inst_vmullb_q_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vmullt_q_q_q ¶

    inst_vmullt_q_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vmvn_d_d ¶

    inst_vmvn_d_d :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}
    Related Procedure Groups

    inst_vmvn_d_imm ¶

    inst_vmvn_d_imm :: proc "contextless" (dst: Register, imm: i64) -> Instruction {…}
    Related Procedure Groups

    inst_vneg_s_s ¶

    inst_vneg_s_s :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vnmla_s_s_s ¶

    inst_vnmla_s_s_s :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vnmls_s_s_s ¶

    inst_vnmls_s_s_s :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vnmul_s_s_s ¶

    inst_vnmul_s_s_s :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vorn_d_d_d ¶

    inst_vorn_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vorr_d_d_d ¶

    inst_vorr_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vpadal_d_d ¶

    inst_vpadal_d_d :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vpadd_d_d_d ¶

    inst_vpadd_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vpadd_f_d_d_d ¶

    inst_vpadd_f_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vpaddl_d_d ¶

    inst_vpaddl_d_d :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vpmax_d_d_d ¶

    inst_vpmax_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vpmin_d_d_d ¶

    inst_vpmin_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vpnot_none ¶

    inst_vpnot_none :: proc "contextless" () -> Instruction {…}

    inst_vpop_slist ¶

    inst_vpop_slist :: proc "contextless" (regs: u16) -> Instruction {…}

    inst_vpsel_q_q_q ¶

    inst_vpsel_q_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vpst_vpt ¶

    inst_vpst_vpt :: proc "contextless" (imm: i64) -> Instruction {…}

    inst_vpt_vpt_cond_q_q ¶

    inst_vpt_vpt_cond_q_q :: proc "contextless" (imm: i64, imm2: i64, src: Register, src2: Register) -> Instruction {…}

    inst_vpush_slist ¶

    inst_vpush_slist :: proc "contextless" (regs: u16) -> Instruction {…}

    inst_vqabs_q_q ¶

    inst_vqabs_q_q :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vqadd_d_d_d ¶

    inst_vqadd_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vqdmladh_q_q_q ¶

    inst_vqdmladh_q_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vqdmladhx_q_q_q ¶

    inst_vqdmladhx_q_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vqdmlal_lane_q_d_dlane ¶

    inst_vqdmlal_lane_q_d_dlane :: proc "contextless" (dst: Register, src: Register, src2: Register, lane: u8) -> Instruction {…}

    inst_vqdmlal_q_d_d ¶

    inst_vqdmlal_q_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vqdmlsdh_q_q_q ¶

    inst_vqdmlsdh_q_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vqdmlsdhx_q_q_q ¶

    inst_vqdmlsdhx_q_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vqdmlsl_lane_q_d_dlane ¶

    inst_vqdmlsl_lane_q_d_dlane :: proc "contextless" (dst: Register, src: Register, src2: Register, lane: u8) -> Instruction {…}

    inst_vqdmlsl_q_d_d ¶

    inst_vqdmlsl_q_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vqdmulh_d_d_d ¶

    inst_vqdmulh_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vqdmulh_lane_d_d_dlane ¶

    inst_vqdmulh_lane_d_d_dlane :: proc "contextless" (dst: Register, src: Register, src2: Register, lane: u8) -> Instruction {…}

    inst_vqdmull_lane_q_d_dlane ¶

    inst_vqdmull_lane_q_d_dlane :: proc "contextless" (dst: Register, src: Register, src2: Register, lane: u8) -> Instruction {…}

    inst_vqdmull_q_d_d ¶

    inst_vqdmull_q_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vqmovn_d_q ¶

    inst_vqmovn_d_q :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vqmovnb_q_q ¶

    inst_vqmovnb_q_q :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vqmovnt_q_q ¶

    inst_vqmovnt_q_q :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vqmovun_d_q ¶

    inst_vqmovun_d_q :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vqmovunb_q_q ¶

    inst_vqmovunb_q_q :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vqmovunt_q_q ¶

    inst_vqmovunt_q_q :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vqneg_q_q ¶

    inst_vqneg_q_q :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vqrdmladh_q_q_q ¶

    inst_vqrdmladh_q_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vqrdmladhx_q_q_q ¶

    inst_vqrdmladhx_q_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vqrdmlah_d_d_d ¶

    inst_vqrdmlah_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vqrdmlah_lane_d_d_dlane ¶

    inst_vqrdmlah_lane_d_d_dlane :: proc "contextless" (dst: Register, src: Register, src2: Register, lane: u8) -> Instruction {…}

    inst_vqrdmlsdh_q_q_q ¶

    inst_vqrdmlsdh_q_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vqrdmlsdhx_q_q_q ¶

    inst_vqrdmlsdhx_q_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vqrdmlsh_d_d_d ¶

    inst_vqrdmlsh_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vqrdmlsh_lane_d_d_dlane ¶

    inst_vqrdmlsh_lane_d_d_dlane :: proc "contextless" (dst: Register, src: Register, src2: Register, lane: u8) -> Instruction {…}

    inst_vqrdmulh_d_d_d ¶

    inst_vqrdmulh_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vqrdmulh_lane_d_d_dlane ¶

    inst_vqrdmulh_lane_d_d_dlane :: proc "contextless" (dst: Register, src: Register, src2: Register, lane: u8) -> Instruction {…}

    inst_vqrshl_d_d_d ¶

    inst_vqrshl_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vqrshrn_d_q_imm ¶

    inst_vqrshrn_d_q_imm :: proc "contextless" (dst: Register, src: Register, imm: i64) -> Instruction {…}

    inst_vqrshrnb_q_q_imm5 ¶

    inst_vqrshrnb_q_q_imm5 :: proc "contextless" (dst: Register, src: Register, imm: i64) -> Instruction {…}

    inst_vqrshrnt_q_q_imm5 ¶

    inst_vqrshrnt_q_q_imm5 :: proc "contextless" (dst: Register, src: Register, imm: i64) -> Instruction {…}

    inst_vqrshrun_d_q_imm ¶

    inst_vqrshrun_d_q_imm :: proc "contextless" (dst: Register, src: Register, imm: i64) -> Instruction {…}

    inst_vqrshrunb_q_q_imm5 ¶

    inst_vqrshrunb_q_q_imm5 :: proc "contextless" (dst: Register, src: Register, imm: i64) -> Instruction {…}

    inst_vqrshrunt_q_q_imm5 ¶

    inst_vqrshrunt_q_q_imm5 :: proc "contextless" (dst: Register, src: Register, imm: i64) -> Instruction {…}

    inst_vqshl_d_d_d ¶

    inst_vqshl_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}
    Related Procedure Groups

    inst_vqshl_d_d_imm ¶

    inst_vqshl_d_d_imm :: proc "contextless" (dst: Register, src: Register, imm: i64) -> Instruction {…}
    Related Procedure Groups

    inst_vqshrn_d_q_imm ¶

    inst_vqshrn_d_q_imm :: proc "contextless" (dst: Register, src: Register, imm: i64) -> Instruction {…}

    inst_vqshrnb_q_q_imm5 ¶

    inst_vqshrnb_q_q_imm5 :: proc "contextless" (dst: Register, src: Register, imm: i64) -> Instruction {…}

    inst_vqshrnt_q_q_imm5 ¶

    inst_vqshrnt_q_q_imm5 :: proc "contextless" (dst: Register, src: Register, imm: i64) -> Instruction {…}

    inst_vqshrun_d_q_imm ¶

    inst_vqshrun_d_q_imm :: proc "contextless" (dst: Register, src: Register, imm: i64) -> Instruction {…}

    inst_vqshrunb_q_q_imm5 ¶

    inst_vqshrunb_q_q_imm5 :: proc "contextless" (dst: Register, src: Register, imm: i64) -> Instruction {…}

    inst_vqshrunt_q_q_imm5 ¶

    inst_vqshrunt_q_q_imm5 :: proc "contextless" (dst: Register, src: Register, imm: i64) -> Instruction {…}

    inst_vqsub_d_d_d ¶

    inst_vqsub_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vrecpe_d_d ¶

    inst_vrecpe_d_d :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vrecpe_f_d_d ¶

    inst_vrecpe_f_d_d :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vrecps_d_d_d ¶

    inst_vrecps_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vrev16_d_d ¶

    inst_vrev16_d_d :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vrev32_d_d ¶

    inst_vrev32_d_d :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vrev64_d_d ¶

    inst_vrev64_d_d :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vrhadd_d_d_d ¶

    inst_vrhadd_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vrinta_s_s ¶

    inst_vrinta_s_s :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vrintm_s_s ¶

    inst_vrintm_s_s :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vrintn_s_s ¶

    inst_vrintn_s_s :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vrintp_s_s ¶

    inst_vrintp_s_s :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vrintr_s_s ¶

    inst_vrintr_s_s :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vrintx_s_s ¶

    inst_vrintx_s_s :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vrintz_s_s ¶

    inst_vrintz_s_s :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vrmlaldavh_r_r_q_q ¶

    inst_vrmlaldavh_r_r_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_vrmlaldavha_r_r_q_q ¶

    inst_vrmlaldavha_r_r_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_vrmlaldavhax_r_r_q_q ¶

    inst_vrmlaldavhax_r_r_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_vrmlaldavhx_r_r_q_q ¶

    inst_vrmlaldavhx_r_r_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_vrmlsldavh_r_r_q_q ¶

    inst_vrmlsldavh_r_r_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_vrmlsldavha_r_r_q_q ¶

    inst_vrmlsldavha_r_r_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_vrmlsldavhax_r_r_q_q ¶

    inst_vrmlsldavhax_r_r_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_vrmlsldavhx_r_r_q_q ¶

    inst_vrmlsldavhx_r_r_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register, src3: Register) -> Instruction {…}

    inst_vrshl_d_d_d ¶

    inst_vrshl_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vrshr_d_d_imm ¶

    inst_vrshr_d_d_imm :: proc "contextless" (dst: Register, src: Register, imm: i64) -> Instruction {…}

    inst_vrshrn_d_q_imm ¶

    inst_vrshrn_d_q_imm :: proc "contextless" (dst: Register, src: Register, imm: i64) -> Instruction {…}

    inst_vrshrnb_q_q_imm5 ¶

    inst_vrshrnb_q_q_imm5 :: proc "contextless" (dst: Register, src: Register, imm: i64) -> Instruction {…}

    inst_vrshrnt_q_q_imm5 ¶

    inst_vrshrnt_q_q_imm5 :: proc "contextless" (dst: Register, src: Register, imm: i64) -> Instruction {…}

    inst_vrsqrte_d_d ¶

    inst_vrsqrte_d_d :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vrsqrte_f_d_d ¶

    inst_vrsqrte_f_d_d :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vrsqrts_d_d_d ¶

    inst_vrsqrts_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vrsra_d_d_imm ¶

    inst_vrsra_d_d_imm :: proc "contextless" (dst: Register, src: Register, imm: i64) -> Instruction {…}

    inst_vsdot_d_d_d ¶

    inst_vsdot_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vsdot_lane_d_d_dlane ¶

    inst_vsdot_lane_d_d_dlane :: proc "contextless" (dst: Register, src: Register, src2: Register, lane: u8) -> Instruction {…}

    inst_vsel_s_s_s_cond ¶

    inst_vsel_s_s_s_cond :: proc "contextless" (dst: Register, src: Register, src2: Register, imm: i64) -> Instruction {…}

    inst_vshl_d_d_d ¶

    inst_vshl_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vshlc_q_r_imm5 ¶

    inst_vshlc_q_r_imm5 :: proc "contextless" (dst: Register, src: Register, imm: i64) -> Instruction {…}

    inst_vshll_q_d ¶

    inst_vshll_q_d :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}
    Related Procedure Groups

    inst_vshll_q_d_imm ¶

    inst_vshll_q_d_imm :: proc "contextless" (dst: Register, src: Register, imm: i64) -> Instruction {…}
    Related Procedure Groups

    inst_vshllb_q_q_imm5 ¶

    inst_vshllb_q_q_imm5 :: proc "contextless" (dst: Register, src: Register, imm: i64) -> Instruction {…}

    inst_vshllt_q_q_imm5 ¶

    inst_vshllt_q_q_imm5 :: proc "contextless" (dst: Register, src: Register, imm: i64) -> Instruction {…}

    inst_vshr_d_d_imm ¶

    inst_vshr_d_d_imm :: proc "contextless" (dst: Register, src: Register, imm: i64) -> Instruction {…}

    inst_vshrn_d_q_imm ¶

    inst_vshrn_d_q_imm :: proc "contextless" (dst: Register, src: Register, imm: i64) -> Instruction {…}

    inst_vshrnb_q_q_imm5 ¶

    inst_vshrnb_q_q_imm5 :: proc "contextless" (dst: Register, src: Register, imm: i64) -> Instruction {…}

    inst_vshrnt_q_q_imm5 ¶

    inst_vshrnt_q_q_imm5 :: proc "contextless" (dst: Register, src: Register, imm: i64) -> Instruction {…}

    inst_vsli_d_d_imm ¶

    inst_vsli_d_d_imm :: proc "contextless" (dst: Register, src: Register, imm: i64) -> Instruction {…}

    inst_vsmmla_q_q_q ¶

    inst_vsmmla_q_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vsqrt_s_s ¶

    inst_vsqrt_s_s :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vsra_d_d_imm ¶

    inst_vsra_d_d_imm :: proc "contextless" (dst: Register, src: Register, imm: i64) -> Instruction {…}

    inst_vsri_d_d_imm ¶

    inst_vsri_d_d_imm :: proc "contextless" (dst: Register, src: Register, imm: i64) -> Instruction {…}

    inst_vst1_dlane_mem ¶

    inst_vst1_dlane_mem :: proc "contextless" (dst: Register, lane: u8, src: Memory) -> Instruction {…}
    Related Procedure Groups

    inst_vst1_dlist_mem ¶

    inst_vst1_dlist_mem :: proc "contextless" (regs: u16, src: Memory) -> Instruction {…}
    Related Procedure Groups

    inst_vst1_lane_dlane_mem ¶

    inst_vst1_lane_dlane_mem :: proc "contextless" (dst: Register, lane: u8, src: Memory) -> Instruction {…}

    inst_vst20_qlist_mem ¶

    inst_vst20_qlist_mem :: proc "contextless" (regs: u16, src: Memory) -> Instruction {…}

    inst_vst21_qlist_mem ¶

    inst_vst21_qlist_mem :: proc "contextless" (regs: u16, src: Memory) -> Instruction {…}

    inst_vst2_dlist_mem ¶

    inst_vst2_dlist_mem :: proc "contextless" (regs: u16, src: Memory) -> Instruction {…}

    inst_vst2_lane_dlist_mem ¶

    inst_vst2_lane_dlist_mem :: proc "contextless" (regs: u16, src: Memory) -> Instruction {…}

    inst_vst3_dlist_mem ¶

    inst_vst3_dlist_mem :: proc "contextless" (regs: u16, src: Memory) -> Instruction {…}

    inst_vst3_lane_dlist_mem ¶

    inst_vst3_lane_dlist_mem :: proc "contextless" (regs: u16, src: Memory) -> Instruction {…}

    inst_vst40_qlist_mem ¶

    inst_vst40_qlist_mem :: proc "contextless" (regs: u16, src: Memory) -> Instruction {…}

    inst_vst41_qlist_mem ¶

    inst_vst41_qlist_mem :: proc "contextless" (regs: u16, src: Memory) -> Instruction {…}

    inst_vst42_qlist_mem ¶

    inst_vst42_qlist_mem :: proc "contextless" (regs: u16, src: Memory) -> Instruction {…}

    inst_vst43_qlist_mem ¶

    inst_vst43_qlist_mem :: proc "contextless" (regs: u16, src: Memory) -> Instruction {…}

    inst_vst4_dlist_mem ¶

    inst_vst4_dlist_mem :: proc "contextless" (regs: u16, src: Memory) -> Instruction {…}

    inst_vst4_lane_dlist_mem ¶

    inst_vst4_lane_dlist_mem :: proc "contextless" (regs: u16, src: Memory) -> Instruction {…}

    inst_vstm_r_slist ¶

    inst_vstm_r_slist :: proc "contextless" (dst: Register, regs: u16) -> Instruction {…}

    inst_vstr_s_mem ¶

    inst_vstr_s_mem :: proc "contextless" (dst: Register, src: Memory) -> Instruction {…}

    inst_vstrb_q_mem ¶

    inst_vstrb_q_mem :: proc "contextless" (dst: Register, src: Memory) -> Instruction {…}

    inst_vstrb_scatter_q_mem_q ¶

    inst_vstrb_scatter_q_mem_q :: proc "contextless" (dst: Register, src: Memory, src2: Register) -> Instruction {…}

    inst_vstrd_q_mem ¶

    inst_vstrd_q_mem :: proc "contextless" (dst: Register, src: Memory) -> Instruction {…}

    inst_vstrd_scatter_q_mem_q ¶

    inst_vstrd_scatter_q_mem_q :: proc "contextless" (dst: Register, src: Memory, src2: Register) -> Instruction {…}

    inst_vstrh_q_mem ¶

    inst_vstrh_q_mem :: proc "contextless" (dst: Register, src: Memory) -> Instruction {…}

    inst_vstrh_scatter_q_mem_q ¶

    inst_vstrh_scatter_q_mem_q :: proc "contextless" (dst: Register, src: Memory, src2: Register) -> Instruction {…}

    inst_vstrw_q_mem ¶

    inst_vstrw_q_mem :: proc "contextless" (dst: Register, src: Memory) -> Instruction {…}

    inst_vstrw_scatter_q_mem_q ¶

    inst_vstrw_scatter_q_mem_q :: proc "contextless" (dst: Register, src: Memory, src2: Register) -> Instruction {…}

    inst_vsub_s_s_s ¶

    inst_vsub_s_s_s :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vsubl_q_d_d ¶

    inst_vsubl_q_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vsubw_q_q_d ¶

    inst_vsubw_q_q_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vsudot_lane_q_q_dlane ¶

    inst_vsudot_lane_q_q_dlane :: proc "contextless" (dst: Register, src: Register, src2: Register, lane: u8) -> Instruction {…}

    inst_vsudot_q_q_q ¶

    inst_vsudot_q_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vswp_d_d ¶

    inst_vswp_d_d :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vtbl_d_d_d ¶

    inst_vtbl_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}
    Related Procedure Groups

    inst_vtbl_d_dlist_d ¶

    inst_vtbl_d_dlist_d :: proc "contextless" (dst: Register, regs: u16, src: Register) -> Instruction {…}
    Related Procedure Groups

    inst_vtbx_d_d_d ¶

    inst_vtbx_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}
    Related Procedure Groups

    inst_vtbx_d_dlist_d ¶

    inst_vtbx_d_dlist_d :: proc "contextless" (dst: Register, regs: u16, src: Register) -> Instruction {…}
    Related Procedure Groups

    inst_vtrn_d_d ¶

    inst_vtrn_d_d :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vtst_d_d_d ¶

    inst_vtst_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vudot_d_d_d ¶

    inst_vudot_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vudot_lane_d_d_dlane ¶

    inst_vudot_lane_d_d_dlane :: proc "contextless" (dst: Register, src: Register, src2: Register, lane: u8) -> Instruction {…}

    inst_vummla_q_q_q ¶

    inst_vummla_q_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vusdot_d_d_d ¶

    inst_vusdot_d_d_d :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vusdot_lane_d_d_dlane ¶

    inst_vusdot_lane_d_d_dlane :: proc "contextless" (dst: Register, src: Register, src2: Register, lane: u8) -> Instruction {…}

    inst_vusmmla_q_q_q ¶

    inst_vusmmla_q_q_q :: proc "contextless" (dst: Register, src: Register, src2: Register) -> Instruction {…}

    inst_vuzp_d_d ¶

    inst_vuzp_d_d :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_vzip_d_d ¶

    inst_vzip_d_d :: proc "contextless" (dst: Register, src: Register) -> Instruction {…}

    inst_wfe_none ¶

    inst_wfe_none :: proc "contextless" () -> Instruction {…}

    inst_wfi_none ¶

    inst_wfi_none :: proc "contextless" () -> Instruction {…}

    inst_wls_r_rel ¶

    inst_wls_r_rel :: proc "contextless" (dst: Register, offset: i64) -> Instruction {…}

    inst_wlstp_r_rel ¶

    inst_wlstp_r_rel :: proc "contextless" (dst: Register, offset: i64) -> Instruction {…}

    inst_yield_none ¶

    inst_yield_none :: proc "contextless" () -> Instruction {…}

    is_dpr ¶

    is_dpr :: proc "contextless" (r: Register) -> bool {…}

    is_fp_scalar ¶

    is_fp_scalar :: proc "contextless" (r: Register) -> bool {…}

    is_gpr ¶

    is_gpr :: proc "contextless" (r: Register) -> bool {…}

    is_neon_or_vfp_opcode ¶

    is_neon_or_vfp_opcode :: proc "contextless" (bits: u32) -> bool {…}

    is_qpr ¶

    is_qpr :: proc "contextless" (r: Register) -> bool {…}

    is_simd ¶

    is_simd :: proc "contextless" (r: Register) -> bool {…}

    is_spr ¶

    is_spr :: proc "contextless" (r: Register) -> bool {…}

    mem_imm ¶

    mem_imm :: proc "contextless" (base: Register, disp: i32) -> Memory {…}

    mem_imm_post ¶

    mem_imm_post :: proc "contextless" (base: Register, disp: i32) -> Memory {…}

    mem_imm_pre ¶

    mem_imm_pre :: proc "contextless" (base: Register, disp: i32) -> Memory {…}

    mem_reg ¶

    mem_reg :: proc "contextless" (base, index: Register, sign: i8 = 1) -> Memory {…}

    mem_reg_shift ¶

    mem_reg_shift :: proc "contextless" (base, index: Register, st: Shift_Type, amt: u8, sign: i8 = 1) -> Memory {…}

    mnemonic_to_string ¶

    mnemonic_to_string :: proc(m: Mnemonic, lowercase: bool = true, allocator := context.temp_allocator) -> string {…}

    op_dpr_lane ¶

    op_dpr_lane :: proc "contextless" (d: Register, idx: u8) -> Operand {…}

    op_imm ¶

    op_imm :: proc "contextless" (v: i64, size: u8 = 4) -> Operand {…}

    op_label ¶

    op_label :: proc "contextless" (label_id: u32, size: u8 = 4) -> Operand {…}

    op_mem ¶

    op_mem :: proc "contextless" (m: Memory) -> Operand {…}

    op_qpr_lane ¶

    op_qpr_lane :: proc "contextless" (q: Register, idx: u8) -> Operand {…}

    op_reg ¶

    op_reg :: proc "contextless" (r: Register) -> Operand {…}

    op_reg_list ¶

    op_reg_list :: proc "contextless" (mask: u16) -> Operand {…}

    op_reg_shifted ¶

    op_reg_shifted :: proc "contextless" (r: Register, st: Shift_Type, amt: u8) -> Operand {…}

    op_rel_offset ¶

    op_rel_offset :: proc "contextless" (off: i64) -> Operand {…}

    pack_neon_modimm_field ¶

    pack_neon_modimm_field :: proc "contextless" (f: NEON_Imm_Form) -> u32 {…}
     

    Pack the NEON_Imm_Form into the bits the encoder ORs into the instruction word: bits 18:16 = abc (high 3), bits 3:0 = defgh (low 4)... wait, abcdefgh is 8 bits split a:bcdefgh: actually it's (a)(bcd)(efgh) — 3 + 4? no. Standard NEON layout puts a at bit 24, bc at bits 18:17, d at bit 16, efgh at bits 3:0. Per ARM ARM: bits 24, 18:16, 3:0 = abcdefgh

    print ¶

    print :: proc(
    	instructions: []Instruction, 
    	inst_info:    []Instruction_Info, 
    	label_defs:   []rexcode_isa.Label_Definition, 
    	tokens:       ^[dynamic]rexcode_isa.Token = nil, 
    	options:      ^rexcode_isa.Print_Options = nil, 
    	label_names:  ^map[u32]string = nil, 
    ) {…}

    println ¶

    println :: proc(
    	instructions: []Instruction, 
    	inst_info:    []Instruction_Info, 
    	label_defs:   []rexcode_isa.Label_Definition, 
    	tokens:       ^[dynamic]rexcode_isa.Token = nil, 
    	options:      ^rexcode_isa.Print_Options = nil, 
    	label_names:  ^map[u32]string = nil, 
    ) {…}

    reg_class ¶

    reg_class :: proc "contextless" (r: Register) -> u16 {…}
     

    ---- Helpers ----------------------------------------------------------------

    reg_hw ¶

    reg_hw :: proc "contextless" (r: Register) -> u16 {…}

    register_name ¶

    register_name :: proc(r: Register, lowercase: bool = true, allocator := context.temp_allocator) -> string {…}

    rol32 ¶

    rol32 :: proc "contextless" (v: u32, n: u32) -> u32 {…}

    ror32 ¶

    ror32 :: proc "contextless" (v: u32, n: u32) -> u32 {…}

    sbprint ¶

    sbprint :: proc(
    	sb:           ^strings.Builder, 
    	instructions: []Instruction, 
    	inst_info:    []Instruction_Info, 
    	label_defs:   []rexcode_isa.Label_Definition, 
    	tokens:       ^[dynamic]rexcode_isa.Token = nil, 
    	options:      ^rexcode_isa.Print_Options = nil, 
    	label_names:  ^map[u32]string = nil, 
    ) {…}

    sbprintln ¶

    sbprintln :: proc(
    	sb:           ^strings.Builder, 
    	instructions: []Instruction, 
    	inst_info:    []Instruction_Info, 
    	label_defs:   []rexcode_isa.Label_Definition, 
    	tokens:       ^[dynamic]rexcode_isa.Token = nil, 
    	options:      ^rexcode_isa.Print_Options = nil, 
    	label_names:  ^map[u32]string = nil, 
    ) {…}

    tprint ¶

    tprint :: proc(
    	instructions: []Instruction, 
    	inst_info:    []Instruction_Info, 
    	label_defs:   []rexcode_isa.Label_Definition, 
    	tokens:       ^[dynamic]rexcode_isa.Token = nil, 
    	options:      ^rexcode_isa.Print_Options = nil, 
    	label_names:  ^map[u32]string = nil, 
    ) -> string {…}

    tprintln ¶

    tprintln :: proc(
    	instructions: []Instruction, 
    	inst_info:    []Instruction_Info, 
    	label_defs:   []rexcode_isa.Label_Definition, 
    	tokens:       ^[dynamic]rexcode_isa.Token = nil, 
    	options:      ^rexcode_isa.Print_Options = nil, 
    	label_names:  ^map[u32]string = nil, 
    ) -> string {…}

    wprint ¶

    wprint :: proc(
    	w:            io.Stream, 
    	instructions: []Instruction, 
    	inst_info:    []Instruction_Info, 
    	label_defs:   []rexcode_isa.Label_Definition, 
    	tokens:       ^[dynamic]rexcode_isa.Token = nil, 
    	options:      ^rexcode_isa.Print_Options = nil, 
    	label_names:  ^map[u32]string = nil, 
    ) {…}

    wprintln ¶

    wprintln :: proc(
    	w:            io.Stream, 
    	instructions: []Instruction, 
    	inst_info:    []Instruction_Info, 
    	label_defs:   []rexcode_isa.Label_Definition, 
    	tokens:       ^[dynamic]rexcode_isa.Token = nil, 
    	options:      ^rexcode_isa.Print_Options = nil, 
    	label_names:  ^map[u32]string = nil, 
    ) {…}

    Procedure Groups

    Source Files

    Generation Information

    Generated with odin version dev-2026-07 (vendor "odin") Windows_amd64 @ 2026-07-20 21:55:31.320897800 +0000 UTC