package core:rexcode/isa/ppc
Source

⌘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

    Index

    Procedures (13370)
    Procedure Groups (0)

    This section is empty.

    Types

    Decode_Entry ¶
    Source

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

    Decode_Index ¶
    Source

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

    Encode_Run ¶
    Source

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

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

    Encoding ¶
    Source

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

    One instruction-encoding form within a mnemonic.

    For prefixed (8-byte) Power ISA 3.1 instructions, bits holds the SUFFIX word and mask covers only the suffix's fixed bits. The PREFIX word is looked up in PREFIX_BITS_TABLE[mnemonic] (see encoding_table.odin). flags.prefixed=true is the signal to consult that table.

    Encoding_Flags ¶
    Source

    Encoding_Flags :: distinct bit_field u16 {
	branch:      bool | 1,
	cond_branch: bool | 1,
	writes_lr:   bool | 1,
	sets_cr0:    bool | 1,
	sets_cr1:    bool | 1,
	abs_branch:  bool | 1,
	has_oe:      bool | 1,
	prefixed:    bool | 1,
	vle:         bool | 1,
	vle_short:   bool | 1,
	_:           u16 | 6,
}

    Endianness ¶
    Source

    Endianness :: enum u8 {
	BIG    = 0, 
	LITTLE = 1, 
}
     

    Instruction storage endianness. Power was big-endian historically; ppc64le (POWER8+ Linux) stores instructions LE.

    Error ¶
    Source

    Error :: rexcode_isa.Error

    Error_Code ¶
    Source

    Error_Code :: rexcode_isa.Error_Code

    Feature ¶
    Source

    Feature :: enum u8 {
	BASE,    // POWER ISA Book I/II base 32-bit
	P64,     // 64-bit only ops (ld/std/mulld/rldicl-family)
	FP,      // floating-point unit (Book I §4 FPU)
	FP_R,    // FP rounding-mode-related (FRSP, FCTID, ...)
	ALTIVEC, // AltiVec / VMX (vector unit, 128-bit V regs)
	VSX,     // Vector-Scalar Extension (POWER7; 64 vs regs)
	VSX_P9,  // VSX additions in POWER9 (ISA 3.0)
	VSX_P10, // VSX additions in POWER10 (ISA 3.1)
	POWER8,  // POWER8 additions (ISA 2.07)
	POWER9,  // POWER9 additions (ISA 3.0)
	POWER10, // POWER10 additions (ISA 3.1 incl prefixed ops)
	DFP,     // Decimal Floating-Point
	HTM,     // Hardware Transactional Memory
	CACHE,   // cache-management (dcb*, icbi, ...)
	HV,      // hypervisor-only
	SUPV,    // supervisor (kernel) — mfmsr/mtmsr/rfi/...
	BOOKE,   // Book E embedded variant (rare in modern table; keep slot)
	SPE,     // Signal-Processing Engine (Freescale e500/e500v2 — evX/efs/efd/evmX)
	PS,      // Paired Singles (Gekko/Broadway — GameCube/Wii)
	VMX128,  // VMX128 (Xenon — Xbox 360 vector ext with 128 VR registers)
}
     

    Architectural extension this entry needs. Used for filtering and decode disambiguation (some entries collide unless the right feature is enabled).

    Instruction ¶
    Source

    Instruction :: struct #packed {
	ops:           [4]Operand `fmt:"v,operand_count"`,
	// 4 * 14 = 56
	mnemonic:      Mnemonic,
	// 2
	operand_count: u8,
	// 0..4
	flags:         Instruction_Flags,
	// 1
	mode:          Mode,
	// 1 (PPC32 / PPC64)
	length:        u8,
	// 4 or 8 (prefixed)
	form_id:       u16,
}
    Related Procedures With Parameters
    Related Procedures With Returns

    Instruction_Flags ¶
    Source

    Instruction_Flags :: distinct bit_field u8 {
	sets_cr0: bool | 1,
	has_oe:   bool | 1,
	aa:       bool | 1,
	lk:       bool | 1,
	_:        u8 | 4,
}

    Instruction_Info ¶
    Source

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

    Label_Definition ¶
    Source

    Label_Definition :: rexcode_isa.Label_Definition
    Related Constants

    Label_Map ¶
    Source

    Label_Map :: rexcode_isa.Label_Map

    Memory ¶
    Source

    Memory :: struct #packed {
	base:  Register,
	// RA — base register (R0 may be literal zero in D-form)
	index: Register,
	// RB for X-form indexed; NONE for D/DS/DQ-form
	disp:  i64,
}
     

    PowerPC memory operand. Covers all D / DS / DQ / X / prefixed forms.

    Related Procedures With Parameters
    Related Procedures With Returns

    Mnemonic ¶
    Source

    Mnemonic :: enum u16 {
	INVALID            = 0, 
	// -------------------------------------------------------------------------
	// §1 Branch (I/B/XL-form)
	// -------------------------------------------------------------------------
	B, 
	BL, 
	BA, 
	BLA, 
	BC, 
	BCL, 
	BCA, 
	BCLA, 
	BCLR, 
	BCLRL, 
	BCCTR, 
	BCCTRL, 
	BCTAR, 
	BCTARL,                 // ISA 2.07 (POWER8)
	SC,                     // system call
	// -------------------------------------------------------------------------
	// §2 Condition register logical (XL-form)
	// -------------------------------------------------------------------------
	CRAND, 
	CRNAND, 
	CROR, 
	CRNOR, 
	CRXOR, 
	CREQV, 
	CRANDC, 
	CRORC, 
	MCRF,                   // Move CR field
	// -------------------------------------------------------------------------
	// §3 Fixed-point load (D / DS / X / DQ-form)
	// -------------------------------------------------------------------------
	LBZ, 
	LBZU, 
	LBZX, 
	LBZUX, 
	LHZ, 
	LHZU, 
	LHZX, 
	LHZUX, 
	LHA, 
	LHAU, 
	LHAX, 
	LHAUX, 
	LWZ, 
	LWZU, 
	LWZX, 
	LWZUX, 
	LWA, 
	LWAX, 
	LWAUX,                  // PPC64
	LD, 
	LDU, 
	LDX, 
	LDUX,                   // PPC64
	LQ,                     // 128-bit pair load (POWER8)
	LHBRX, 
	LWBRX, 
	LDBRX, 
	LMW,                    // load multiple word (rare)
	LSWI, 
	LSWX,                   // load string
	// -------------------------------------------------------------------------
	// §4 Fixed-point store (D / DS / X / DQ-form)
	// -------------------------------------------------------------------------
	STB, 
	STBU, 
	STBX, 
	STBUX, 
	STH, 
	STHU, 
	STHX, 
	STHUX, 
	STW, 
	STWU, 
	STWX, 
	STWUX, 
	STD, 
	STDU, 
	STDX, 
	STDUX,                  // PPC64
	STQ,                    // POWER8
	STHBRX, 
	STWBRX, 
	STDBRX, 
	STMW, 
	STSWI, 
	STSWX, 
	// -------------------------------------------------------------------------
	// §5 Load/Store with reservation (atomic primitives)
	// -------------------------------------------------------------------------
	LBARX, 
	LHARX, 
	LWARX, 
	LDARX, 
	LQARX,                  // POWER8 quad-word reservation
	STBCX_DOT, 
	STHCX_DOT, 
	STWCX_DOT, 
	STDCX_DOT, 
	STQCX_DOT,              // POWER8
	// -------------------------------------------------------------------------
	// §6 Fixed-point arithmetic (D / XO-form)
	// -------------------------------------------------------------------------
	ADDI, 
	ADDIS, 
	ADDIC, 
	ADDIC_DOT,              // addic.
	SUBFIC, 
	ADDPCIS,                // ISA 3.0
	ADD, 
	ADD_DOT, 
	ADD_O, 
	ADD_O_DOT, 
	ADDC, 
	ADDC_DOT, 
	ADDC_O, 
	ADDC_O_DOT, 
	ADDE, 
	ADDE_DOT, 
	ADDE_O, 
	ADDE_O_DOT, 
	ADDME, 
	ADDME_DOT, 
	ADDME_O, 
	ADDME_O_DOT, 
	ADDZE, 
	ADDZE_DOT, 
	ADDZE_O, 
	ADDZE_O_DOT, 
	ADDEX,                  // POWER9
	SUBF, 
	SUBF_DOT, 
	SUBF_O, 
	SUBF_O_DOT, 
	SUBFC, 
	SUBFC_DOT, 
	SUBFC_O, 
	SUBFC_O_DOT, 
	SUBFE, 
	SUBFE_DOT, 
	SUBFE_O, 
	SUBFE_O_DOT, 
	SUBFME, 
	SUBFME_DOT, 
	SUBFME_O, 
	SUBFME_O_DOT, 
	SUBFZE, 
	SUBFZE_DOT, 
	SUBFZE_O, 
	SUBFZE_O_DOT, 
	NEG, 
	NEG_DOT, 
	NEG_O, 
	NEG_O_DOT, 
	MULLI, 
	MULHW, 
	MULHW_DOT, 
	MULHWU, 
	MULHWU_DOT, 
	MULLW, 
	MULLW_DOT, 
	MULLW_O, 
	MULLW_O_DOT, 
	MULLD, 
	MULLD_DOT, 
	MULLD_O, 
	MULLD_O_DOT,            // PPC64
	MULHD, 
	MULHD_DOT, 
	MULHDU, 
	MULHDU_DOT,             // PPC64
	MADDLD,                 // POWER9 (mul-add)
	MADDHD, 
	MADDHDU,                // POWER9
	DIVW, 
	DIVW_DOT, 
	DIVW_O, 
	DIVW_O_DOT, 
	DIVWU, 
	DIVWU_DOT, 
	DIVWU_O, 
	DIVWU_O_DOT, 
	DIVD, 
	DIVD_DOT, 
	DIVD_O, 
	DIVD_O_DOT,             // PPC64
	DIVDU, 
	DIVDU_DOT, 
	DIVDU_O, 
	DIVDU_O_DOT,            // PPC64
	DIVWE, 
	DIVWE_DOT, 
	DIVWE_O, 
	DIVWE_O_DOT,            // POWER7 extended
	DIVWEU, 
	DIVWEU_DOT, 
	DIVWEU_O, 
	DIVWEU_O_DOT, 
	DIVDE, 
	DIVDE_DOT, 
	DIVDE_O, 
	DIVDE_O_DOT, 
	DIVDEU, 
	DIVDEU_DOT, 
	DIVDEU_O, 
	DIVDEU_O_DOT, 
	MODSW, 
	MODUW,                  // POWER9
	MODSD, 
	MODUD,                  // POWER9
	// Trap
	TWI, 
	TW, 
	TDI, 
	TD,                     // PPC64
	// -------------------------------------------------------------------------
	// §7 Fixed-point logical / shift / rotate (X / M / MD / MDS-form)
	// -------------------------------------------------------------------------
	ANDI_DOT, 
	ANDIS_DOT, 
	ORI, 
	ORIS, 
	XORI, 
	XORIS, 
	AND, 
	AND_DOT, 
	OR, 
	OR_DOT, 
	XOR, 
	XOR_DOT, 
	NAND, 
	NAND_DOT, 
	NOR, 
	NOR_DOT, 
	EQV, 
	EQV_DOT, 
	ANDC, 
	ANDC_DOT, 
	ORC, 
	ORC_DOT, 
	EXTSB, 
	EXTSB_DOT, 
	EXTSH, 
	EXTSH_DOT, 
	EXTSW, 
	EXTSW_DOT,              // PPC64
	CNTLZW, 
	CNTLZW_DOT, 
	CNTLZD, 
	CNTLZD_DOT,             // PPC64
	CNTTZW, 
	CNTTZW_DOT,             // POWER9
	CNTTZD, 
	CNTTZD_DOT,             // POWER9
	POPCNTB,                // ISA 2.02
	POPCNTW,                // POWER7
	POPCNTD,                // POWER7
	PRTYW, 
	PRTYD,                  // POWER7 parity
	BPERMD,                 // POWER7
	CMPB,                   // POWER6
	SLW, 
	SLW_DOT, 
	SRW, 
	SRW_DOT, 
	SRAW, 
	SRAW_DOT, 
	SRAWI, 
	SRAWI_DOT, 
	SLD, 
	SLD_DOT,                // PPC64
	SRD, 
	SRD_DOT,                // PPC64
	SRAD, 
	SRAD_DOT,               // PPC64
	SRADI, 
	SRADI_DOT,              // PPC64
	RLWINM, 
	RLWINM_DOT, 
	RLWNM, 
	RLWNM_DOT, 
	RLWIMI, 
	RLWIMI_DOT, 
	RLDICL, 
	RLDICL_DOT,             // PPC64
	RLDICR, 
	RLDICR_DOT,             // PPC64
	RLDIC, 
	RLDIC_DOT,              // PPC64
	RLDIMI, 
	RLDIMI_DOT,             // PPC64
	RLDCL, 
	RLDCL_DOT,              // PPC64
	RLDCR, 
	RLDCR_DOT,              // PPC64
	// -------------------------------------------------------------------------
	// §8 Compare
	// -------------------------------------------------------------------------
	CMPI, 
	CMPLI, 
	CMP, 
	CMPL, 
	CMPRB,                  // ISA 3.0
	CMPEQB,                 // ISA 3.0
	// -------------------------------------------------------------------------
	// §9 Floating-point arithmetic (A / X-form)
	// -------------------------------------------------------------------------
	FADD, 
	FADD_DOT, 
	FADDS, 
	FADDS_DOT, 
	FSUB, 
	FSUB_DOT, 
	FSUBS, 
	FSUBS_DOT, 
	FMUL, 
	FMUL_DOT, 
	FMULS, 
	FMULS_DOT, 
	FDIV, 
	FDIV_DOT, 
	FDIVS, 
	FDIVS_DOT, 
	FSQRT, 
	FSQRT_DOT, 
	FSQRTS, 
	FSQRTS_DOT, 
	FRE, 
	FRE_DOT, 
	FRES, 
	FRES_DOT, 
	FRSQRTE, 
	FRSQRTE_DOT, 
	FRSQRTES, 
	FRSQRTES_DOT, 
	FMADD, 
	FMADD_DOT, 
	FMADDS, 
	FMADDS_DOT, 
	FMSUB, 
	FMSUB_DOT, 
	FMSUBS, 
	FMSUBS_DOT, 
	FNMADD, 
	FNMADD_DOT, 
	FNMADDS, 
	FNMADDS_DOT, 
	FNMSUB, 
	FNMSUB_DOT, 
	FNMSUBS, 
	FNMSUBS_DOT, 
	FSEL, 
	FSEL_DOT, 
	FCPSGN, 
	FCPSGN_DOT, 
	FNEG, 
	FNEG_DOT, 
	FABS, 
	FABS_DOT, 
	FNABS, 
	FNABS_DOT, 
	FMR, 
	FMR_DOT, 
	FRSP, 
	FRSP_DOT, 
	FCTID, 
	FCTID_DOT, 
	FCTIDU, 
	FCTIDU_DOT, 
	FCTIDZ, 
	FCTIDZ_DOT, 
	FCTIDUZ, 
	FCTIDUZ_DOT, 
	FCTIW, 
	FCTIW_DOT, 
	FCTIWU, 
	FCTIWU_DOT, 
	FCTIWZ, 
	FCTIWZ_DOT, 
	FCTIWUZ, 
	FCTIWUZ_DOT, 
	FCFID, 
	FCFID_DOT, 
	FCFIDU, 
	FCFIDU_DOT, 
	FCFIDS, 
	FCFIDS_DOT, 
	FCFIDUS, 
	FCFIDUS_DOT, 
	FRIN, 
	FRIN_DOT, 
	FRIZ, 
	FRIZ_DOT, 
	FRIP, 
	FRIP_DOT, 
	FRIM, 
	FRIM_DOT, 
	FCMPU, 
	FCMPO, 
	FTDIV, 
	FTSQRT,                 // POWER7
	FMRGEW, 
	FMRGOW,                 // POWER8
	LFS, 
	LFSU, 
	LFSX, 
	LFSUX, 
	LFD, 
	LFDU, 
	LFDX, 
	LFDUX, 
	LFIWAX, 
	LFIWZX, 
	LFDP, 
	LFDPX,                  // ISA 2.05 quad-word
	STFS, 
	STFSU, 
	STFSX, 
	STFSUX, 
	STFD, 
	STFDU, 
	STFDX, 
	STFDUX, 
	STFIWX, 
	STFDP, 
	STFDPX, 
	MFFS, 
	MFFS_DOT, 
	MCRFS, 
	MTFSB0, 
	MTFSB0_DOT, 
	MTFSB1, 
	MTFSB1_DOT, 
	MTFSFI, 
	MTFSFI_DOT, 
	MTFSF, 
	MTFSF_DOT, 
	// -------------------------------------------------------------------------
	// §10 SPR / system / cache
	// -------------------------------------------------------------------------
	MFSPR, 
	MTSPR, 
	MFTB,                   // deprecated by ISA 2.06 (use mfspr 268/269)
	MFCR, 
	MTCRF, 
	MTOCRF, 
	MFOCRF, 
	MTMSR, 
	MFMSR, 
	MTMSRD,                 // supervisor / hypervisor
	SC_HV,                  // hypervisor sc level
	RFI, 
	RFID, 
	HRFID, 
	SYNC, 
	LWSYNC, 
	PTESYNC, 
	EIEIO, 
	ISYNC, 
	DCBT, 
	DCBTST, 
	DCBA, 
	DCBF, 
	DCBZ, 
	DCBZL,                  // POWER6 large-line dcbz
	ICBI, 
	ICBT,                   // ISA 2.06+
	NAP,                    // power management hints
	WAIT,                   // POWER9
	MSYNC,                  // alias for sync L=2 (POWER8)
	TLBIE, 
	TLBIEL, 
	TLBSYNC,                // supervisor TLB
	SLBIE, 
	SLBIA, 
	SLBMTE, 
	SLBMFEE,                // segment lookaside buffer
	SLBMFEV, 
	SLBSYNC, 
	SLBIEG,                 // POWER8/9
	DARN,                   // POWER9 random number
	// -------------------------------------------------------------------------
	// §11 AltiVec (VMX) — see Power ISA Book I §6
	// -------------------------------------------------------------------------
	VAND, 
	VANDC, 
	VOR, 
	VORC, 
	VNOR, 
	VXOR, 
	VEQV, 
	VNAND,                  // VEQV/VNAND ISA 2.07
	VSEL, 
	VADDUBM, 
	VADDUHM, 
	VADDUWM, 
	VADDUDM, 
	VADDFP,                 // single-precision FP vector
	VSUBUBM, 
	VSUBUHM, 
	VSUBUWM, 
	VSUBUDM, 
	VSUBFP, 
	VADDCUW, 
	VADDCUQ,                // POWER8 carry-out add
	VADDECUQ, 
	VADDEUQM,               // POWER8 ext carry-in 128-bit
	VSUBCUW, 
	VSUBCUQ, 
	VSUBECUQ, 
	VSUBEUQM, 
	VADDUBS, 
	VADDUHS, 
	VADDUWS,                // saturating unsigned add
	VADDSBS, 
	VADDSHS, 
	VADDSWS,                // saturating signed add
	VSUBUBS, 
	VSUBUHS, 
	VSUBUWS, 
	VSUBSBS, 
	VSUBSHS, 
	VSUBSWS, 
	VMULESB, 
	VMULESH, 
	VMULESW,                // even/odd multiply
	VMULEUB, 
	VMULEUH, 
	VMULEUW, 
	VMULOSB, 
	VMULOSH, 
	VMULOSW, 
	VMULOUB, 
	VMULOUH, 
	VMULOUW, 
	VMULUWM,                // POWER8 mul lo
	VMSUMUBM, 
	VMSUMMBM, 
	VMSUMUHM, 
	VMSUMSHM, 
	VMSUMUHS, 
	VMSUMSHS, 
	VMSUMUDM,               // POWER8
	VCMPEQUB, 
	VCMPEQUB_DOT, 
	VCMPEQUH, 
	VCMPEQUH_DOT, 
	VCMPEQUW, 
	VCMPEQUW_DOT, 
	VCMPEQUD, 
	VCMPEQUD_DOT, 
	VCMPNEB, 
	VCMPNEB_DOT,            // POWER9
	VCMPNEH, 
	VCMPNEH_DOT, 
	VCMPNEW, 
	VCMPNEW_DOT, 
	VCMPGTSB, 
	VCMPGTSB_DOT, 
	VCMPGTSH, 
	VCMPGTSH_DOT, 
	VCMPGTSW, 
	VCMPGTSW_DOT, 
	VCMPGTSD, 
	VCMPGTSD_DOT, 
	VCMPGTUB, 
	VCMPGTUB_DOT, 
	VCMPGTUH, 
	VCMPGTUH_DOT, 
	VCMPGTUW, 
	VCMPGTUW_DOT, 
	VCMPGTUD, 
	VCMPGTUD_DOT, 
	VCMPEQFP, 
	VCMPEQFP_DOT, 
	VCMPGEFP, 
	VCMPGEFP_DOT, 
	VCMPGTFP, 
	VCMPGTFP_DOT, 
	VCMPBFP, 
	VCMPBFP_DOT, 
	VMAXSB, 
	VMAXSH, 
	VMAXSW, 
	VMAXSD, 
	VMAXUB, 
	VMAXUH, 
	VMAXUW, 
	VMAXUD, 
	VMAXFP, 
	VMINSB, 
	VMINSH, 
	VMINSW, 
	VMINSD, 
	VMINUB, 
	VMINUH, 
	VMINUW, 
	VMINUD, 
	VMINFP, 
	VAVGSB, 
	VAVGSH, 
	VAVGSW, 
	VAVGUB, 
	VAVGUH, 
	VAVGUW, 
	VSL, 
	VSR, 
	VSLO, 
	VSRO, 
	VSLB, 
	VSLH, 
	VSLW, 
	VSLD, 
	VSRB, 
	VSRH, 
	VSRW, 
	VSRD, 
	VSRAB, 
	VSRAH, 
	VSRAW, 
	VSRAD, 
	VRLB, 
	VRLH, 
	VRLW, 
	VRLD, 
	VPERM, 
	VPERMR,                 // POWER9
	VSLDOI, 
	VBPERMQ,                // POWER8 bit permute
	VBPERMD,                // POWER9
	VMRGHB, 
	VMRGHH, 
	VMRGHW, 
	VMRGLB, 
	VMRGLH, 
	VMRGLW, 
	VMRGEW, 
	VMRGOW,                 // POWER8 merge even/odd word
	VSPLTB, 
	VSPLTH, 
	VSPLTW, 
	VSPLTISB, 
	VSPLTISH, 
	VSPLTISW, 
	VPKPX, 
	VPKUHUM, 
	VPKUWUM, 
	VPKUDUM, 
	VPKUHUS, 
	VPKUWUS, 
	VPKUDUS, 
	VPKSHUS, 
	VPKSWUS, 
	VPKSDUS, 
	VPKSHSS, 
	VPKSWSS, 
	VPKSDSS, 
	VUPKHSB, 
	VUPKHSH, 
	VUPKHSW, 
	VUPKLSB, 
	VUPKLSH, 
	VUPKLSW, 
	VUPKHPX, 
	VUPKLPX, 
	VCIPHER, 
	VCIPHERLAST,            // POWER8 AES
	VNCIPHER, 
	VNCIPHERLAST, 
	VSBOX, 
	VSHASIGMAW, 
	VSHASIGMAD,             // POWER8 SHA
	VPMSUMB, 
	VPMSUMH, 
	VPMSUMW, 
	VPMSUMD,                // POWER8 polynomial multiply
	VRFIM, 
	VRFIN, 
	VRFIP, 
	VRFIZ,                  // round-to-int FP
	VEXPTEFP, 
	VLOGEFP, 
	VREFP, 
	VRSQRTEFP, 
	VMADDFP, 
	VNMSUBFP, 
	VCFSX, 
	VCFUX, 
	VCTSXS, 
	VCTUXS, 
	LVX, 
	LVXL,                   // load vector
	LVEBX, 
	LVEHX, 
	LVEWX, 
	LVSL, 
	LVSR, 
	STVX, 
	STVXL, 
	STVEBX, 
	STVEHX, 
	STVEWX, 
	MFVSCR, 
	MTVSCR, 
	// ISA 3.0 vector additions
	VABSDUB, 
	VABSDUH, 
	VABSDUW,                // unsigned absolute difference
	VEXTSB2W, 
	VEXTSH2W,               // sign-extend within vector
	VEXTSB2D, 
	VEXTSH2D, 
	VEXTSW2D, 
	VPRTYBW, 
	VPRTYBD, 
	VPRTYBQ,                // parity byte by word/dword/qword
	VRLWNM, 
	VRLDNM,                 // vector rotate
	VRLWMI, 
	VRLDMI, 
	VCMPNEZB, 
	VCMPNEZB_DOT, 
	VCMPNEZH, 
	VCMPNEZH_DOT, 
	VCMPNEZW, 
	VCMPNEZW_DOT, 
	VCLZB, 
	VCLZH, 
	VCLZW, 
	VCLZD, 
	VCTZB, 
	VCTZH, 
	VCTZW, 
	VCTZD, 
	VPOPCNTB, 
	VPOPCNTH, 
	VPOPCNTW, 
	VPOPCNTD, 
	VEXTRACTUB, 
	VEXTRACTUH, 
	VEXTRACTUW, 
	VEXTRACTD, 
	VINSERTB, 
	VINSERTH, 
	VINSERTW, 
	VINSERTD, 
	VSLV, 
	VSRV,                   // POWER9 variable shift
	VMUL10UQ, 
	VMUL10CUQ,              // POWER9 decimal-multiply helpers
	VMUL10EUQ, 
	VMUL10ECUQ, 
	// -------------------------------------------------------------------------
	// §12 VSX (POWER7+) — see Power ISA Book I §7
	// -------------------------------------------------------------------------
	LXSDX, 
	LXSIWAX, 
	LXSIWZX, 
	LXVD2X, 
	LXVDSX, 
	LXVW4X, 
	STXSDX, 
	STXSIWX, 
	STXVD2X, 
	STXVW4X, 
	// ISA 2.07 BE/LE byte-mirroring loads
	LXSSPX, 
	STXSSPX,                // single-precision via VSX
	// ISA 3.0 (POWER9) VSX additions
	LXV, 
	STXV,                   // D-form 16-byte vsx
	LXVH8X, 
	LXVB16X, 
	LXVL, 
	LXVLL,                  // length-controlled loads
	STXVH8X, 
	STXVB16X, 
	STXVL, 
	STXVLL, 
	LXVX, 
	STXVX,                  // X-form vsx vector
	LXSIBZX, 
	LXSIHZX, 
	STXSIBX, 
	STXSIHX, 
	LXSD, 
	STXSD,                  // DS-form scalar VSX
	LXSSP, 
	STXSSP,                 // DS-form single VSX
	// XX2 / XX3 arithmetic — POWER7+
	XSADDSP, 
	XSADDDP, 
	XSSUBSP, 
	XSSUBDP, 
	XSMULSP, 
	XSMULDP, 
	XSDIVSP, 
	XSDIVDP, 
	XSSQRTSP, 
	XSSQRTDP, 
	XSRESP, 
	XSREDP, 
	XSRSQRTESP, 
	XSRSQRTEDP, 
	XSMADDASP, 
	XSMADDADP, 
	XSMADDMSP, 
	XSMADDMDP, 
	XSMSUBASP, 
	XSMSUBADP, 
	XSMSUBMSP, 
	XSMSUBMDP, 
	XSNMADDASP, 
	XSNMADDADP, 
	XSNMADDMSP, 
	XSNMADDMDP, 
	XSNMSUBASP, 
	XSNMSUBADP, 
	XSNMSUBMSP, 
	XSNMSUBMDP, 
	XSMAXDP, 
	XSMINDP, 
	XSMAXCDP, 
	XSMINCDP,               // POWER9
	XSMAXJDP, 
	XSMINJDP,               // POWER9
	XSCMPODP, 
	XSCMPUDP, 
	XSCMPEQDP, 
	XSCMPGTDP, 
	XSCMPGEDP,              // POWER9 compare
	XSCPSGNDP, 
	XSABSDP, 
	XSNABSDP, 
	XSNEGDP, 
	XSCVDPSP, 
	XSCVSPDP, 
	XSCVDPSXDS, 
	XSCVDPUXDS, 
	XSCVSXDDP, 
	XSCVUXDDP, 
	XSCVDPSXWS, 
	XSCVDPUXWS, 
	XSCVDPHP, 
	XSCVHPDP, 
	XSCVSPDPN, 
	XSCVDPSPN, 
	XSRDPI, 
	XSRDPIM, 
	XSRDPIP, 
	XSRDPIZ, 
	XSRDPIC, 
	XSRSP, 
	XSIEXPDP, 
	XSXEXPDP, 
	XSXSIGDP,               // POWER9
	XVADDSP, 
	XVADDDP, 
	XVSUBSP, 
	XVSUBDP, 
	XVMULSP, 
	XVMULDP, 
	XVDIVSP, 
	XVDIVDP, 
	XVSQRTSP, 
	XVSQRTDP, 
	XVRESP, 
	XVREDP, 
	XVRSQRTESP, 
	XVRSQRTEDP, 
	XVMADDASP, 
	XVMADDADP, 
	XVMADDMSP, 
	XVMADDMDP, 
	XVMSUBASP, 
	XVMSUBADP, 
	XVMSUBMSP, 
	XVMSUBMDP, 
	XVNMADDASP, 
	XVNMADDADP, 
	XVNMADDMSP, 
	XVNMADDMDP, 
	XVNMSUBASP, 
	XVNMSUBADP, 
	XVNMSUBMSP, 
	XVNMSUBMDP, 
	XVMAXSP, 
	XVMAXDP, 
	XVMINSP, 
	XVMINDP, 
	XVCMPEQSP, 
	XVCMPEQSP_DOT, 
	XVCMPEQDP, 
	XVCMPEQDP_DOT, 
	XVCMPGTSP, 
	XVCMPGTSP_DOT, 
	XVCMPGTDP, 
	XVCMPGTDP_DOT, 
	XVCMPGESP, 
	XVCMPGESP_DOT, 
	XVCMPGEDP, 
	XVCMPGEDP_DOT, 
	XVCPSGNSP, 
	XVCPSGNDP, 
	XVABSSP, 
	XVABSDP, 
	XVNABSSP, 
	XVNABSDP, 
	XVNEGSP, 
	XVNEGDP, 
	XVCVSPDP, 
	XVCVDPSP, 
	XVCVSPSXDS, 
	XVCVSPUXDS, 
	XVCVDPSXDS, 
	XVCVDPUXDS, 
	XVCVSPSXWS, 
	XVCVSPUXWS, 
	XVCVDPSXWS, 
	XVCVDPUXWS, 
	XVCVSXDSP, 
	XVCVUXDSP, 
	XVCVSXDDP, 
	XVCVUXDDP, 
	XVCVSXWSP, 
	XVCVUXWSP, 
	XVCVSXWDP, 
	XVCVUXWDP, 
	XVRSPI, 
	XVRSPIM, 
	XVRSPIP, 
	XVRSPIZ, 
	XVRSPIC, 
	XVRDPI, 
	XVRDPIM, 
	XVRDPIP, 
	XVRDPIZ, 
	XVRDPIC, 
	XVIEXPSP, 
	XVIEXPDP,               // POWER9
	XVXEXPSP, 
	XVXEXPDP, 
	XVXSIGSP, 
	XVXSIGDP, 
	XVTSTDCSP, 
	XVTSTDCDP,              // POWER9 test
	XSTSTDCSP, 
	XSTSTDCDP,              // POWER9
	XSTSQRTDP, 
	XVTSQRTSP, 
	XVTSQRTDP, 
	XSTDIVDP, 
	XVTDIVSP, 
	XVTDIVDP, 
	XXLAND, 
	XXLANDC, 
	XXLOR, 
	XXLXOR, 
	XXLNOR, 
	XXLEQV, 
	XXLNAND, 
	XXLORC, 
	XXSEL, 
	XXSPLTW, 
	XXSPLTIB,               // POWER9
	XXSLDWI, 
	XXPERMDI, 
	XXMRGHW, 
	XXMRGLW, 
	XXEXTRACTUW, 
	XXINSERTW,              // POWER9
	XXSPLTIW, 
	XXSPLTIDP, 
	XXSPLTI32DX,            // POWER10 (8RR-form prefixed)
	XSCMPEQQP, 
	XSCMPGTQP, 
	XSCMPGEQP,              // POWER10 quad
	// POWER9 binary128 (quad-precision FP) — see Power ISA Book I §7
	XSADDQP, 
	XSADDQPO, 
	XSSUBQP, 
	XSSUBQPO, 
	XSMULQP, 
	XSMULQPO, 
	XSDIVQP, 
	XSDIVQPO, 
	XSSQRTQP, 
	XSSQRTQPO, 
	XSMADDQP, 
	XSMADDQPO, 
	XSMSUBQP, 
	XSMSUBQPO, 
	XSNMADDQP, 
	XSNMADDQPO, 
	XSNMSUBQP, 
	XSNMSUBQPO, 
	XSABSQP, 
	XSNABSQP, 
	XSNEGQP, 
	XSCPSGNQP, 
	XSCMPOQP, 
	XSCMPUQP, 
	XSTSTDCQP, 
	XSRQPI, 
	XSRQPIX, 
	XSRQPXP, 
	XSXEXPQP, 
	XSXSIGQP, 
	XSIEXPQP, 
	// QP conversions
	XSCVQPDP, 
	XSCVQPDPO, 
	XSCVDPQP, 
	XSCVQPSDZ, 
	XSCVQPSWZ, 
	XSCVQPUDZ, 
	XSCVQPUWZ, 
	XSCVSDQP, 
	XSCVUDQP, 
	// Decimal Floating Point (DFP, POWER6+) — see Power ISA Book I §5
	DADD, 
	DADD_DOT, 
	DSUB, 
	DSUB_DOT, 
	DMUL, 
	DMUL_DOT, 
	DDIV, 
	DDIV_DOT, 
	DCMPU, 
	DCMPO, 
	DRSP, 
	DRSP_DOT, 
	DCTDP, 
	DCTDP_DOT, 
	DXEX, 
	DXEX_DOT, 
	DIEX, 
	DIEX_DOT, 
	DRRND, 
	DRRND_DOT, 
	DRINTX, 
	DRINTX_DOT, 
	DRINTN, 
	DRINTN_DOT, 
	DQUA, 
	DQUA_DOT, 
	DQUAI, 
	DQUAI_DOT, 
	DSCLI, 
	DSCLI_DOT, 
	DSCRI, 
	DSCRI_DOT, 
	DCFFIX, 
	DCFFIX_DOT, 
	DCTFIX, 
	DCTFIX_DOT, 
	DTSTDC, 
	DTSTDG, 
	DTSTEX, 
	DTSTSF, 
	DENBCD, 
	DENBCD_DOT, 
	DDEDPD, 
	DDEDPD_DOT, 
	// DFPQ (128-bit decimal) — POWER6+
	DADDQ, 
	DADDQ_DOT, 
	DSUBQ, 
	DSUBQ_DOT, 
	DMULQ, 
	DMULQ_DOT, 
	DDIVQ, 
	DDIVQ_DOT, 
	DCMPUQ, 
	DCMPOQ, 
	DCTFIXQ, 
	DCTFIXQ_DOT, 
	// MMA accelerator non-prefixed (POWER10) — see Power ISA Book I §8
	XXMTACC, 
	XXMFACC, 
	XXSETACCZ, 
	XVF16GER2, 
	XVF16GER2PP, 
	XVF16GER2PN, 
	XVF16GER2NP, 
	XVF16GER2NN, 
	XVF32GER, 
	XVF32GERPP, 
	XVF32GERPN, 
	XVF32GERNP, 
	XVF32GERNN, 
	XVF64GER, 
	XVF64GERPP, 
	XVF64GERPN, 
	XVF64GERNP, 
	XVF64GERNN, 
	XVBF16GER2, 
	XVBF16GER2PP, 
	XVBF16GER2PN, 
	XVBF16GER2NP, 
	XVBF16GER2NN, 
	XVI4GER8, 
	XVI4GER8PP, 
	XVI8GER4, 
	XVI8GER4PP, 
	XVI8GER4SPP, 
	XVI16GER2, 
	XVI16GER2PP, 
	XVI16GER2S, 
	XVI16GER2SPP, 
	// POWER10 additional vector AltiVec / VSX
	VSTRIBL, 
	VSTRIBR, 
	VSTRIBL_DOT, 
	VSTRIBR_DOT, 
	VSTRIHL, 
	VSTRIHR, 
	VSTRIHL_DOT, 
	VSTRIHR_DOT, 
	VMSUMCUD,               // POWER10 carry-sum
	VCFUGED,                // POWER10 centrifuge
	VPDEPD, 
	VPEXTD,                 // POWER10 deposit/extract
	VGNB,                   // POWER10 gather-nybble
	VSLDBI, 
	VSRDBI,                 // POWER10 double-bit shift
	VCLZDM, 
	VCTZDM,                 // POWER10 count zeros under mask
	VCLRLB, 
	VCLRRB,                 // POWER10 vector clear left/right byte
	VEXPANDBM, 
	VEXPANDHM, 
	VEXPANDWM, 
	VEXPANDDM, 
	VEXPANDQM,              // POWER10 expand
	VEXTRACTBM, 
	VEXTRACTHM, 
	VEXTRACTWM, 
	VEXTRACTDM, 
	VEXTRACTQM,             // POWER10 extract mask
	VCNTMBB, 
	VCNTMBH, 
	VCNTMBW, 
	VCNTMBD,                // POWER10 count mask bits
	MTVSRBM, 
	MTVSRHM, 
	MTVSRWM, 
	MTVSRDM, 
	MTVSRQM,                // POWER10 move-mask to VSR
	// POWER10 paste / copy
	COPY, 
	PASTE_DOT, 
	// Hypervisor-priv cache-inhibited X-form loads/stores
	LBZCIX, 
	LHZCIX, 
	LWZCIX, 
	LDCIX, 
	STBCIX, 
	STHCIX, 
	STWCIX, 
	STDCIX, 
	// HTM (Hardware Transactional Memory, POWER8)
	TBEGIN_DOT, 
	TEND_DOT, 
	TABORT_DOT, 
	TABORTWC_DOT, 
	TABORTWCI_DOT, 
	TABORTDC_DOT, 
	TABORTDCI_DOT, 
	TRECLAIM_DOT, 
	TRECHKPT_DOT, 
	TSUSPEND_DOT, 
	TRESUME_DOT, 
	TCHECK, 
	// BCD conversion (POWER6/7)
	ADDG6S, 
	CBCDTD, 
	CDTBCD, 
	// Event-based branch / debug return
	RFEBB, 
	RFDI, 
	// Inter-processor messaging (sync only — msgsnd/msgclr/p variants need
	// booke or server-specific feature support that LLVM 22 doesn't expose
	// via a single mattr flag — deferred).
	MSGSYNC, 
	// Integer-Select (POWER7) and TH=16 cache hints (POWER8)
	ISEL, 
	DCBTT, 
	DCBTSTT, 
	// POWER10 vector insert / extract with right/left-justification
	VEXTUBLX, 
	VEXTUHLX, 
	VEXTUWLX, 
	VEXTUBRX, 
	VEXTUHRX, 
	VEXTUWRX, 
	VINSBVLX, 
	VINSHVLX, 
	VINSWVLX, 
	VINSBVRX, 
	VINSHVRX, 
	VINSWVRX, 
	VINSBLX, 
	VINSHLX, 
	VINSWLX, 
	VINSDLX, 
	VINSBRX, 
	VINSHRX, 
	VINSWRX, 
	VINSDRX, 
	VINSW, 
	VINSD, 
	VEXTDUBVLX, 
	VEXTDUHVLX, 
	VEXTDUWVLX, 
	VEXTDDVLX, 
	VEXTDUBVRX, 
	VEXTDUHVRX, 
	VEXTDUWVRX, 
	VEXTDDVRX, 
	// POWER10 VSX byte/half/word/doubleword load right-justified
	LXVRBX, 
	LXVRHX, 
	LXVRWX, 
	LXVRDX, 
	STXVRBX, 
	STXVRHX, 
	STXVRWX, 
	STXVRDX, 
	LXVKQ,                  // load known quad
	XSMAXCQP, 
	XSMINCQP,               // POWER10 QP max/min
	// POWER10 vector quad rotate / shift / divide / modulo / multiply
	VRLQ, 
	VRLQMI, 
	VRLQNM, 
	VSLQ, 
	VSRQ, 
	VSRAQ, 
	VMULESD, 
	VMULEUD, 
	VMULOSD, 
	VMULOUD, 
	VMULLD, 
	VMULHSW, 
	VMULHSD, 
	VMULHUW, 
	VMULHUD, 
	VDIVSW, 
	VDIVUW, 
	VDIVSD, 
	VDIVUD, 
	VDIVSQ, 
	VDIVUQ, 
	VDIVESW, 
	VDIVEUW, 
	VDIVESD, 
	VDIVEUD, 
	VDIVESQ, 
	VDIVEUQ, 
	VMODSW, 
	VMODUW, 
	VMODSD, 
	VMODUD, 
	VMODSQ, 
	VMODUQ, 
	// POWER9/POWER10 misc
	SETB, 
	MCRXRX, 
	XVCVBF16SPN, 
	XVCVSPBF16, 
	XXGENPCVBM, 
	XXGENPCVHM, 
	XXGENPCVWM, 
	XXGENPCVDM, 
	XXBLENDVB, 
	XXBLENDVH, 
	XXBLENDVW, 
	XXBLENDVD, 
	XXPERMX, 
	XXEVAL, 
	XXPERM,                 // POWER9 byte permute
	// -------------------------------------------------------------------------
	// §13 Power ISA 3.1 prefixed (POWER10) — 8-byte instructions
	// -------------------------------------------------------------------------
	PLD, 
	PSTD,                   // prefixed load/store doubleword
	PLWZ, 
	PSTW, 
	PLBZ, 
	PSTB, 
	PLHZ, 
	PSTH, 
	PLHA, 
	PLWA, 
	PLFD, 
	PSTFD, 
	PLFS, 
	PSTFS, 
	PLXV, 
	PSTXV,                  // prefixed VSX
	PLXSD, 
	PSTXSD, 
	PLXSSP, 
	PSTXSSP, 
	PADDI, 
	PLI,                    // 34-bit imm add / load-immediate
	PSUBI,                  // alias-style
	PMXVF32GER, 
	PMXVF64GER,             // MMA accelerator (sketch)
	PMXVI4GER8, 
	PMXVI8GER4, 
	PMXVI16GER2,            // MMA integer
	// POWER10 MMA full prefix variants (pp/pn/np/nn + s/spp)
	PMXVF16GER2, 
	PMXVF16GER2PP, 
	PMXVF16GER2PN, 
	PMXVF16GER2NP, 
	PMXVF16GER2NN, 
	PMXVF32GERPP, 
	PMXVF32GERPN, 
	PMXVF32GERNP, 
	PMXVF32GERNN, 
	PMXVF64GERPP, 
	PMXVF64GERPN, 
	PMXVF64GERNP, 
	PMXVF64GERNN, 
	PMXVBF16GER2, 
	PMXVBF16GER2PP, 
	PMXVBF16GER2PN, 
	PMXVBF16GER2NP, 
	PMXVBF16GER2NN, 
	PMXVI4GER8PP, 
	PMXVI8GER4PP, 
	PMXVI8GER4SPP, 
	PMXVI16GER2PP, 
	PMXVI16GER2S, 
	PMXVI16GER2SPP, 
	// POWER10 paired VSX load/store
	LXVP, 
	STXVP,                  // DQ-form 32-byte VSX pair
	LXVPX, 
	STXVPX,                 // X-form indexed
	// BookE / Embedded-EP cache management and effective-physical loads
	DCBI, 
	ICBIEP, 
	DCBTEP, 
	DCBTSTEP, 
	LBEPX, 
	LHEPX, 
	LWEPX, 
	STBEPX, 
	STHEPX, 
	STWEPX, 
	LFDEPX, 
	STFDEPX, 
	TLBSX, 
	DCCCI, 
	ICCCI, 
	WRTEE, 
	WRTEEI, 
	// BookE / Embedded TLB and other extended
	TLBRE, 
	TLBWE, 
	TLBIVAX, 
	TLBILX, 
	TLBLD, 
	TLBLI,                  // 601-specific
	MFPMR, 
	MTPMR,                  // Performance Monitor Reg
	// 32-bit segment-register move (Book III-S 32-bit only)
	MFSR, 
	MTSR, 
	MFSRIN, 
	MTSRIN, 
	// AltiVec data-stream touch / cancel (deprecated but in ISA)
	DST, 
	DSTT, 
	DSTST, 
	DSTSTT, 
	DSS, 
	DSSALL, 
	// AltiVec sum-across (legacy)
	VSUMSWS, 
	VSUM2SWS, 
	VSUM4SBS, 
	VSUM4SHS, 
	VSUM4UBS, 
	// POWER9 FPSCR moves
	MFFSCE, 
	MFFSCDRN, 
	MFFSCDRNI, 
	MFFSCRN, 
	MFFSCRNI, 
	MFFSL, 
	// POWER9/10 misc system
	STOP,                   // POWER9 idle
	CPABORT,                // POWER10 copy abort
	ATTN,                   // server attention
	// POWER8 GPR ↔ FPR/VSR moves (LLVM-canonical mt/mf-fpr* spellings).
	// Note: mtvsrd / mfvsrd are spec mnemonics that LLVM 22 prints as
	// mtfprd / mffprd when the target register is in the FPR-aliased half.
	MTFPRD, 
	MFFPRD, 
	MTFPRWA, 
	MTFPRWZ, 
	MFFPRWZ, 
	// POWER9 GPR ↔ VSR moves
	MFVSRLD, 
	MTVSRDD, 
	MTVSRWS, 
	// POWER9 sign-extend-shift-left immediate
	EXTSWSLI, 
	EXTSWSLI_DOT, 
	// ISEL canonical-condition aliases
	ISELLT, 
	ISELGT, 
	ISELEQ, 
	// Trap aliases (specific TO values)
	TWEQ, 
	TWNE, 
	TWGT, 
	TWLT, 
	TWGTI, 
	TWLTI, 
	TWEQI, 
	TWNEI, 
	TWUI, 
	TDEQ, 
	TDNE, 
	TDGT, 
	TDLT, 
	TDGTI, 
	TDLTI, 
	TDEQI, 
	TDNEI, 
	TDUI, 
	// POWER8/9 BCD arithmetic and conversion (Vector BCD)
	BCDADD_DOT, 
	BCDSUB_DOT, 
	BCDS_DOT, 
	BCDUS_DOT, 
	BCDSR_DOT, 
	BCDCFN_DOT, 
	BCDCTN_DOT, 
	BCDCFZ_DOT, 
	BCDCTZ_DOT, 
	BCDCPSGN_DOT, 
	BCDTRUNC_DOT, 
	BCDUTRUNC_DOT, 
	BCDCFSQ_DOT, 
	BCDCTSQ_DOT, 
	// POWER9 SCV (System Call Vectored)
	SCV, 
	// Counter+CR+LK branch aliases
	BDNZTL, 
	BDZTL, 
	BDNZFL, 
	BDZFL, 
	// Counter+CR+LR aliases
	BDNZTLR, 
	BDZTLR, 
	BDNZFLR, 
	BDZFLR, 
	BDNZTLRL, 
	BDZTLRL, 
	BDNZFLRL, 
	BDZFLRL, 
	// SPR-specific move aliases (LLVM treats these as distinct mnemonics)
	MTCR,                   // = mtcrf 255, RS
	MFDSCR, 
	MTDSCR,                 // POWER8 Data Stream Control
	MFCFAR, 
	MTCFAR,                 // POWER6+ Come-From Addr Reg
	MFPPR, 
	MTPPR,                  // POWER7+ Process Priority Reg
	MFDEC, 
	MTDEC, 
	MFSRR0, 
	MTSRR0, 
	MFSRR1, 
	MTSRR1, 
	MFDAR, 
	MTDAR, 
	MFDSISR, 
	MTDSISR, 
	MFASR, 
	MTASR,                  // 32-bit MSR/SR
	MFAMR, 
	MTAMR,                  // ISA 2.05 AMR
	MFTCR, 
	MTTCR,                  // BookE Timer Control
	MFESR, 
	MTESR,                  // BookE Exception Syndrome
	MFDCCR, 
	MTDCCR,                 // BookE Data Cache Control
	MTBR0, 
	MTBR1,                  // BookE Branch BR
	MTTBL, 
	MTTBU,                  // Time Base writes
	// POWER9 atomic memory operations
	LWAT, 
	LDAT, 
	STWAT, 
	STDAT, 
	// POWER10 vector extend sign double → quad
	VEXTSD2Q, 
	// POWER10 paired length-controlled VSX
	LXVPRL, 
	LXVPRLL, 
	STXVPRL, 
	STXVPRLL, 
	LXVRL, 
	LXVRLL, 
	STXVRL, 
	STXVRLL, 
	// BookE machine check return
	RFMCI, 
	// -------------------------------------------------------------------------
	// §14 Common assembler aliases (the printer emits these for legibility;
	// the encoder builds them via their underlying form)
	// -------------------------------------------------------------------------
	NOP,                    // ori 0,0,0
	XNOP,                   // xori 0,0,0
	LI,                     // addi rD, 0, value
	LIS,                    // addis rD, 0, value
	LA,                     // addi rD, rA, disp
	MR,                     // or rD, rS, rS
	MR_DOT,                 // or. rD, rS, rS
	NOT,                    // nor rD, rS, rS
	NOT_DOT, 
	BLR,                    // bclr 20, 0  (return)
	BLRL, 
	BCTR,                   // bcctr 20, 0
	BCTRL, 
	BEQ, 
	BNE, 
	BLT, 
	BLE, 
	BGT, 
	BGE, 
	BSO, 
	BNS, 
	BEQL, 
	BNEL, 
	BLTL, 
	BLEL, 
	BGTL, 
	BGEL, 
	BSOL, 
	BNSL, 
	BEQLR, 
	BNELR, 
	BLTLR, 
	BLELR, 
	BGTLR, 
	BGELR, 
	BSOLR, 
	BNSLR, 
	BEQCTR, 
	BNECTR, 
	BLTCTR, 
	BLECTR, 
	BGTCTR, 
	BGECTR, 
	BSOCTR, 
	BNSCTR, 
	BDZ, 
	BDNZ, 
	BDZL, 
	BDNZL, 
	BDZLR, 
	BDNZLR, 
	BDZLRL, 
	BDNZLRL, 
	BDZF, 
	BDZT, 
	BDNZF, 
	BDNZT, 
	TRAP,                   // trap unconditional / always
	MFLR,                   // mfspr rD, 8
	MTLR,                   // mtspr 8, rS
	MFCTR,                  // mfspr rD, 9
	MTCTR,                  // mtspr 9, rS
	MFXER,                  // mfspr rD, 1
	MTXER,                  // mtspr 1, rS
	SLWI,                   // rlwinm Rx, Ry, n, 0, 31-n
	SRWI,                   // rlwinm Rx, Ry, 32-n, n, 31
	SLDI,                   // rldicr Rx, Ry, n, 63-n
	SRDI,                   // rldicl Rx, Ry, 64-n, n
	CLRRWI, 
	CLRLWI, 
	CLRRDI, 
	CLRLDI, 
	EXTLDI, 
	EXTRDI,                 // rldicl extractions
	EXTLWI, 
	EXTRWI, 
	INSLWI, 
	INSRWI, 
	ROTLW, 
	ROTLWI, 
	ROTRW, 
	ROTLD, 
	ROTLDI,                 // rldcl alias
	ROTRDI, 
	SUB, 
	SUB_DOT,                // subf alias (operand-reverse)
	SUB_O, 
	SUB_O_DOT, 
	SUBC, 
	SUBC_DOT, 
	SUBC_O, 
	SUBC_O_DOT, 
	CMPW, 
	CMPLW,                  // cmp/cmpl L=0
	CMPD, 
	CMPLD,                  // cmp/cmpl L=1
	CMPWI, 
	CMPLWI, 
	CMPDI, 
	CMPLDI, 
	// -------------------------------------------------------------------------
	// §33 SPE / EFS / EFD (Freescale e500/e500v2 Signal Processing Engine)
	// -------------------------------------------------------------------------
	// SPE core integer/logical/shift/compare/memory
	EVADDW, 
	EVADDIW, 
	EVSUBFW, 
	EVSUBIFW, 
	EVABS, 
	EVEXTSH, 
	EVEXTSB, 
	EVCNTLZW, 
	EVCNTLSW, 
	EVRLW, 
	EVRLWI, 
	EVSLW, 
	EVSLWI, 
	EVSPLATI, 
	EVSPLATFI, 
	EVSRWU, 
	EVSRWS, 
	EVSRWIU, 
	EVSRWIS, 
	EVAND, 
	EVOR, 
	EVXOR, 
	EVNAND, 
	EVNOR, 
	EVANDC, 
	EVORC, 
	EVEQV, 
	EVCMPGTS, 
	EVCMPGTU, 
	EVCMPLTS, 
	EVCMPLTU, 
	EVCMPEQ, 
	EVSEL, 
	EVMERGEHI, 
	EVMERGELO, 
	EVMERGEHILO, 
	EVMERGELOHI, 
	EVDIVWS, 
	EVDIVWU, 
	EVMRA, 
	// SPE memory (D/X-form)
	EVLDD, 
	EVLDDX, 
	EVLDW, 
	EVLDWX, 
	EVLDH, 
	EVLDHX, 
	EVSTDD, 
	EVSTDDX, 
	EVSTDW, 
	EVSTDWX, 
	EVSTDH, 
	EVSTDHX, 
	EVLWWSPLAT, 
	EVLWHSPLAT, 
	EVLHHESPLAT, 
	EVLHHOSSPLAT, 
	EVLHHOUSPLAT, 
	EVLWHE, 
	EVLWHOU, 
	EVLWHOS, 
	EVLWHEX, 
	EVSTWWE, 
	EVSTWWO, 
	EVSTWHE, 
	EVSTWHO, 
	EVSTWHEX, 
	// SPE-FP (single, vector — evfs*)
	EVFSADD, 
	EVFSSUB, 
	EVFSABS, 
	EVFSNABS, 
	EVFSNEG, 
	EVFSMUL, 
	EVFSDIV, 
	EVFSCMPGT, 
	EVFSCMPLT, 
	EVFSCMPEQ, 
	EVFSTSTGT, 
	EVFSTSTLT, 
	EVFSTSTEQ, 
	EVFSCFUI, 
	EVFSCFSI, 
	EVFSCFUF, 
	EVFSCFSF, 
	EVFSCTUI, 
	EVFSCTSI, 
	EVFSCTUF, 
	EVFSCTSF, 
	EVFSCTUIZ, 
	EVFSCTSIZ, 
	// EFS — single-precision scalar SPE FP
	EFSADD, 
	EFSSUB, 
	EFSABS, 
	EFSNABS, 
	EFSNEG, 
	EFSMUL, 
	EFSDIV, 
	EFSCMPGT, 
	EFSCMPLT, 
	EFSCMPEQ, 
	EFSTSTGT, 
	EFSTSTLT, 
	EFSTSTEQ, 
	EFSCFUI, 
	EFSCFSI, 
	EFSCFUF, 
	EFSCFSF, 
	EFSCTUI, 
	EFSCTSI, 
	EFSCTUF, 
	EFSCTSF, 
	EFSCTUIZ, 
	EFSCTSIZ, 
	EFSCFD, 
	// EFD — double-precision scalar SPE FP
	EFDADD, 
	EFDSUB, 
	EFDABS, 
	EFDNABS, 
	EFDNEG, 
	EFDMUL, 
	EFDDIV, 
	EFDCMPGT, 
	EFDCMPLT, 
	EFDCMPEQ, 
	EFDTSTGT, 
	EFDTSTLT, 
	EFDTSTEQ, 
	EFDCFUI, 
	EFDCFSI, 
	EFDCFUF, 
	EFDCFSF, 
	EFDCTUI, 
	EFDCTSI, 
	EFDCTUF, 
	EFDCTSF, 
	EFDCTUIZ, 
	EFDCTSIZ, 
	EFDCFS, 
	EFDCFSID, 
	EFDCFUID, 
	EFDCTSIDZ, 
	EFDCTUIDZ, 
	// SPE multiply / multiply-accumulate (evm*)
	EVMHOSSF, 
	EVMHOSSFA, 
	EVMHOSSFAAW, 
	EVMHOSSFANW, 
	EVMHOSSIAAW, 
	EVMHOSSIANW, 
	EVMHOSMF, 
	EVMHOSMFA, 
	EVMHOSMFAAW, 
	EVMHOSMFANW, 
	EVMHOSMI, 
	EVMHOSMIA, 
	EVMHOSMIAAW, 
	EVMHOSMIANW, 
	EVMHESMF, 
	EVMHESMFA, 
	EVMHESMFAAW, 
	EVMHESMFANW, 
	EVMHESMI, 
	EVMHESMIA, 
	EVMHESMIAAW, 
	EVMHESMIANW, 
	EVMHESSF, 
	EVMHESSFA, 
	EVMHESSFAAW, 
	EVMHESSFANW, 
	EVMHESSIAAW, 
	EVMHESSIANW, 
	EVMHEUMI, 
	EVMHEUMIA, 
	EVMHEUMIAAW, 
	EVMHEUMIANW, 
	EVMHEUSIAAW, 
	EVMHEUSIANW, 
	EVMHOUMI, 
	EVMHOUMIA, 
	EVMHOUMIAAW, 
	EVMHOUMIANW, 
	EVMHOUSIAAW, 
	EVMHOUSIANW, 
	EVMHOGSMFAA, 
	EVMHOGSMFAN, 
	EVMHOGSMIAA, 
	EVMHOGSMIAN, 
	EVMHOGUMIAA, 
	EVMHOGUMIAN, 
	EVMHEGSMFAA, 
	EVMHEGSMFAN, 
	EVMHEGSMIAA, 
	EVMHEGSMIAN, 
	EVMHEGUMIAA, 
	EVMHEGUMIAN, 
	EVMWHSSF, 
	EVMWHSSFA, 
	EVMWLSSIAAW, 
	EVMWLSSIANW, 
	EVMWHSMF, 
	EVMWHSMFA, 
	EVMWHSMI, 
	EVMWHSMIA, 
	EVMWHUMI, 
	EVMWHUMIA, 
	EVMWLSMIAAW, 
	EVMWLSMIANW, 
	EVMWLUMI, 
	EVMWLUMIA, 
	EVMWLUMIAAW, 
	EVMWLUMIANW, 
	EVMWLUSIAAW, 
	EVMWLUSIANW, 
	EVMWSMF, 
	EVMWSMFA, 
	EVMWSMFAA, 
	EVMWSMFAN, 
	EVMWSMI, 
	EVMWSMIA, 
	EVMWSMIAA, 
	EVMWSMIAN, 
	EVMWSSF, 
	EVMWSSFA, 
	EVMWSSFAA, 
	EVMWSSFAN, 
	EVMWUMI, 
	EVMWUMIA, 
	EVMWUMIAA, 
	EVMWUMIAN, 
	BRINC,                  // SPE bit-reverse increment
	// SPE X-form indexed memory (additional)
	EVLWHSPLATX, 
	EVLWWSPLATX, 
	EVLHHESPLATX, 
	EVLHHOSSPLATX, 
	EVLHHOUSPLATX, 
	EVLWHOUX, 
	EVLWHOSX, 
	EVSTWWEX, 
	EVSTWWOX, 
	EVSTWHOX, 
	// -------------------------------------------------------------------------
	// §34 BookE / embedded - additions found via LLVM probing
	// -------------------------------------------------------------------------
	ICBTLS, 
	ICBLC,                  // I-cache hint+lock
	DCBST, 
	MBAR,                   // cache / barrier
	MTDCR, 
	MFDCR,                  // Device Control Register
	TLBILXVA,               // TLB invalidate local (va variant)
	// -------------------------------------------------------------------------
	// §35 POWER9 VSX additions found via LLVM probing
	// -------------------------------------------------------------------------
	XSCVSXDSP, 
	XSCVUXDSP,              // VSX scalar conversion to single
	XXBRH, 
	XXBRW, 
	XXBRD, 
	XXBRQ,                  // VSX byte-reverse (POWER9)
	// -------------------------------------------------------------------------
	// §36 POWER10 scalar bit-manipulation additions
	// -------------------------------------------------------------------------
	PDEPD, 
	PEXTD,                  // parallel bit deposit/extract
	CNTLZDM, 
	CNTTZDM,                // count leading/trailing zeros (masked)
	CFUGED,                 // center-from-ungate doubleword
	BRH, 
	BRW, 
	BRD,                    // byte-reverse half/word/doubleword
	// -------------------------------------------------------------------------
	// §37 Extended-divide OE-variants (POWER7+)
	// -------------------------------------------------------------------------
	DIVWEO, 
	DIVWEUO, 
	DIVDEO, 
	DIVDEUO, 
	// -------------------------------------------------------------------------
	// §38 POWER10 VSX small additions
	// -------------------------------------------------------------------------
	XVTLSBB, 
	XVCVHPSP, 
	XVCVSPHP, 
	XXPERMR, 
	// -------------------------------------------------------------------------
	// §39 SPE/EFS2 FP MADD/MSUB + scalar extensions
	// -------------------------------------------------------------------------
	// From binutils PPCSPE/PPCEFS2 sets. LLVM 22 lacks these mnemonics, so
	// they will be marked expected_unknown like bctar/lswx/prtyw. Bit patterns
	// are derived from binutils opcodes/ppc-opc.c.
	EVFSMADD, 
	EVFSMSUB, 
	EVFSNMADD, 
	EVFSNMSUB,              // SPE vector single MADD
	EFSMADD, 
	EFSMSUB, 
	EFSNMADD, 
	EFSNMSUB,               // EFS2 scalar single MADD
	EFDMADD, 
	EFDMSUB, 
	EFDNMADD, 
	EFDNMSUB,               // EFS2 scalar double MADD
	// EFS2 max/min/sqrt/half-precision conversion (scalar+vector)
	EVFSSQRT, 
	EVFSMAX, 
	EVFSMIN, 
	EVFSCFH, 
	EVFSCTH, 
	EVFSADDSUB, 
	EVFSSUBADD, 
	EVFSSUM, 
	EVFSDIFF, 
	EVFSSUMDIFF, 
	EVFSDIFFSUM, 
	EVFSADDX, 
	EVFSSUBX, 
	EVFSADDSUBX, 
	EVFSSUBADDX, 
	EVFSMULX, 
	EVFSMULE, 
	EVFSMULO, 
	EFSSQRT, 
	EFSMAX, 
	EFSMIN, 
	EFSCFH, 
	EFSCTH, 
	EFDSQRT, 
	EFDMAX, 
	EFDMIN, 
	EFDCFH, 
	EFDCTH, 
	// -------------------------------------------------------------------------
	// §40 Full SPE2 / EFS2 vector family (Freescale e6500/e500z extension)
	// -------------------------------------------------------------------------
	// 838 entries derived from binutils ppc-opc.c PPCSPE2 set. None of these
	// are in LLVM 22's tablegen — they're all expected_unknown in the verifier.
	EVSUBW, 
	EVSUBIW, 
	EVNEG, 
	EVRNDW, 
	EVMR, 
	EVNOT, 
	EVSADD, 
	EVSSUB, 
	EVSABS, 
	EVSNABS, 
	EVSNEG, 
	EVSMUL, 
	EVSDIV, 
	EVSCMPGT, 
	EVSGMPLT, 
	EVSGMPEQ, 
	EVSCFUI, 
	EVSCFSI, 
	EVSCFUF, 
	EVSCFSF, 
	EVSCTUI, 
	EVSCTSI, 
	EVSCTUF, 
	EVSCTSF, 
	EVSCTUIZ, 
	EVSCTSIZ, 
	EVSTSTGT, 
	EVSTSTLT, 
	EVSTSTEQ, 
	EVMWLSSF, 
	EVMWLSMF, 
	EVMWLSSFA, 
	EVMWLSMFA, 
	EVADDUSIAAW, 
	EVADDSSIAAW, 
	EVSUBFUSIAAW, 
	EVSUBFSSIAAW, 
	EVADDUMIAAW, 
	EVADDSMIAAW, 
	EVSUBFUMIAAW, 
	EVSUBFSMIAAW, 
	EVMWLSSFAAW, 
	EVMWHUSIAA, 
	EVMWHSSMAA, 
	EVMWHSSFAA, 
	EVMWLSMFAAW, 
	EVMWHUMIAA, 
	EVMWHSMIAA, 
	EVMWHSMFAA, 
	EVMWHGUMIAA, 
	EVMWHGSMIAA, 
	EVMWHGSSFAA, 
	EVMWHGSMFAA, 
	EVMWLSSFANW, 
	EVMWHUSIAN, 
	EVMWHSSIAN, 
	EVMWHSSFAN, 
	EVMWLSMFANW, 
	EVMWHUMIAN, 
	EVMWHSMIAN, 
	EVMWHSMFAN, 
	EVMWHGUMIAN, 
	EVMWHGSMIAN, 
	EVMWHGSSFAN, 
	EVMWHGSMFAN, 
	EVDOTPWCSSI, 
	EVDOTPWCSMI, 
	EVDOTPWCSSFR, 
	EVDOTPWCSSF, 
	EVDOTPWGASMF, 
	EVDOTPWXGASMF, 
	EVDOTPWGASMFR, 
	EVDOTPWXGASMFR, 
	EVDOTPWGSSMF, 
	EVDOTPWXGSSMF, 
	EVDOTPWGSSMFR, 
	EVDOTPWXGSSMFR, 
	EVDOTPWCSSIAAW3, 
	EVDOTPWCSMIAAW3, 
	EVDOTPWCSSFRAAW3, 
	EVDOTPWCSSFAAW3, 
	EVDOTPWGASMFAA3, 
	EVDOTPWXGASMFAA3, 
	EVDOTPWGASMFRAA3, 
	EVDOTPWXGASMFRAA3, 
	EVDOTPWGSSMFAA3, 
	EVDOTPWXGSSMFAA3, 
	EVDOTPWGSSMFRAA3, 
	EVDOTPWXGSSMFRAA3, 
	EVDOTPWCSSIA, 
	EVDOTPWCSMIA, 
	EVDOTPWCSSFRA, 
	EVDOTPWCSSFA, 
	EVDOTPWGASMFA, 
	EVDOTPWXGASMFA, 
	EVDOTPWGASMFRA, 
	EVDOTPWXGASMFRA, 
	EVDOTPWGSSMFA, 
	EVDOTPWXGSSMFA, 
	EVDOTPWGSSMFRA, 
	EVDOTPWXGSSMFRA, 
	EVDOTPWCSSIAAW, 
	EVDOTPWCSMIAAW, 
	EVDOTPWCSSFRAAW, 
	EVDOTPWCSSFAAW, 
	EVDOTPWGASMFAA, 
	EVDOTPWXGASMFAA, 
	EVDOTPWGASMFRAA, 
	EVDOTPWXGASMFRAA, 
	EVDOTPWGSSMFAA, 
	EVDOTPWXGSSMFAA, 
	EVDOTPWGSSMFRAA, 
	EVDOTPWXGSSMFRAA, 
	EVDOTPHIHCSSI, 
	EVDOTPLOHCSSI, 
	EVDOTPHIHCSSF, 
	EVDOTPLOHCSSF, 
	EVDOTPHIHCSMI, 
	EVDOTPLOHCSMI, 
	EVDOTPHIHCSSFR, 
	EVDOTPLOHCSSFR, 
	EVDOTPHIHCSSIAAW3, 
	EVDOTPLOHCSSIAAW3, 
	EVDOTPHIHCSSFAAW3, 
	EVDOTPLOHCSSFAAW3, 
	EVDOTPHIHCSMIAAW3, 
	EVDOTPLOHCSMIAAW3, 
	EVDOTPHIHCSSFRAAW3, 
	EVDOTPLOHCSSFRAAW3, 
	EVDOTPHIHCSSIA, 
	EVDOTPLOHCSSIA, 
	EVDOTPHIHCSSFA, 
	EVDOTPLOHCSSFA, 
	EVDOTPHIHCSMIA, 
	EVDOTPLOHCSMIA, 
	EVDOTPHIHCSSFRA, 
	EVDOTPLOHCSSFRA, 
	EVDOTPHIHCSSIAAW, 
	EVDOTPLOHCSSIAAW, 
	EVDOTPHIHCSSFAAW, 
	EVDOTPLOHCSSFAAW, 
	EVDOTPHIHCSMIAAW, 
	EVDOTPLOHCSMIAAW, 
	EVDOTPHIHCSSFRAAW, 
	EVDOTPLOHCSSFRAAW, 
	EVDOTPHAUSI, 
	EVDOTPHASSI, 
	EVDOTPHASUSI, 
	EVDOTPHASSF, 
	EVDOTPHSSSF, 
	EVDOTPHAUMI, 
	EVDOTPHASMI, 
	EVDOTPHASUMI, 
	EVDOTPHASSFR, 
	EVDOTPHSSMI, 
	EVDOTPHSSSI, 
	EVDOTPHSSSFR, 
	EVDOTPHAUSIAAW3, 
	EVDOTPHASSIAAW3, 
	EVDOTPHASUSIAAW3, 
	EVDOTPHASSFAAW3, 
	EVDOTPHSSSIAAW3, 
	EVDOTPHSSSFAAW3, 
	EVDOTPHAUMIAAW3, 
	EVDOTPHASMIAAW3, 
	EVDOTPHASUMIAAW3, 
	EVDOTPHASSFRAAW3, 
	EVDOTPHSSMIAAW3, 
	EVDOTPHSSSFRAAW3, 
	EVDOTPHAUSIA, 
	EVDOTPHASSIA, 
	EVDOTPHASUSIA, 
	EVDOTPHASSFA, 
	EVDOTPHSSSFA, 
	EVDOTPHAUMIA, 
	EVDOTPHASMIA, 
	EVDOTPHASUMIA, 
	EVDOTPHASSFRA, 
	EVDOTPHSSMIA, 
	EVDOTPHSSSIA, 
	EVDOTPHSSSFRA, 
	EVDOTPHAUSIAAW, 
	EVDOTPHASSIAAW, 
	EVDOTPHASUSIAAW, 
	EVDOTPHASSFAAW, 
	EVDOTPHSSSIAAW, 
	EVDOTPHSSSFAAW, 
	EVDOTPHAUMIAAW, 
	EVDOTPHASMIAAW, 
	EVDOTPHASUMIAAW, 
	EVDOTPHASSFRAAW, 
	EVDOTPHSSMIAAW, 
	EVDOTPHSSSFRAAW, 
	EVDOTP4HGAUMI, 
	EVDOTP4HGASMI, 
	EVDOTP4HGASUMI, 
	EVDOTP4HGASMF, 
	EVDOTP4HGSSMI, 
	EVDOTP4HGSSMF, 
	EVDOTP4HXGASMI, 
	EVDOTP4HXGASMF, 
	EVDOTPBAUMI, 
	EVDOTPBASMI, 
	EVDOTPBASUMI, 
	EVDOTP4HXGSSMI, 
	EVDOTP4HXGSSMF, 
	EVDOTP4HGAUMIAA3, 
	EVDOTP4HGASMIAA3, 
	EVDOTP4HGASUMIAA3, 
	EVDOTP4HGASMFAA3, 
	EVDOTP4HGSSMIAA3, 
	EVDOTP4HGSSMFAA3, 
	EVDOTP4HXGASMIAA3, 
	EVDOTP4HXGASMFAA3, 
	EVDOTPBAUMIAAW3, 
	EVDOTPBASMIAAW3, 
	EVDOTPBASUMIAAW3, 
	EVDOTP4HXGSSMIAA3, 
	EVDOTP4HXGSSMFAA3, 
	EVDOTP4HGAUMIA, 
	EVDOTP4HGASMIA, 
	EVDOTP4HGASUMIA, 
	EVDOTP4HGASMFA, 
	EVDOTP4HGSSMIA, 
	EVDOTP4HGSSMFA, 
	EVDOTP4HXGASMIA, 
	EVDOTP4HXGASMFA, 
	EVDOTPBAUMIA, 
	EVDOTPBASMIA, 
	EVDOTPBASUMIA, 
	EVDOTP4HXGSSMIA, 
	EVDOTP4HXGSSMFA, 
	EVDOTP4HGAUMIAA, 
	EVDOTP4HGASMIAA, 
	EVDOTP4HGASUMIAA, 
	EVDOTP4HGASMFAA, 
	EVDOTP4HGSSMIAA, 
	EVDOTP4HGSSMFAA, 
	EVDOTP4HXGASMIAA, 
	EVDOTP4HXGASMFAA, 
	EVDOTPBAUMIAAW, 
	EVDOTPBASMIAAW, 
	EVDOTPBASUMIAAW, 
	EVDOTP4HXGSSMIAA, 
	EVDOTP4HXGSSMFAA, 
	EVDOTPWAUSI, 
	EVDOTPWASSI, 
	EVDOTPWASUSI, 
	EVDOTPWAUMI, 
	EVDOTPWASMI, 
	EVDOTPWASUMI, 
	EVDOTPWSSMI, 
	EVDOTPWSSSI, 
	EVDOTPWAUSIAA3, 
	EVDOTPWASSIAA3, 
	EVDOTPWASUSIAA3, 
	EVDOTPWSSSIAA3, 
	EVDOTPWAUMIAA3, 
	EVDOTPWASMIAA3, 
	EVDOTPWASUMIAA3, 
	EVDOTPWSSMIAA3, 
	EVDOTPWAUSIA, 
	EVDOTPWASSIA, 
	EVDOTPWASUSIA, 
	EVDOTPWAUMIA, 
	EVDOTPWASMIA, 
	EVDOTPWASUMIA, 
	EVDOTPWSSMIA, 
	EVDOTPWSSSIA, 
	EVDOTPWAUSIAA, 
	EVDOTPWASSIAA, 
	EVDOTPWASUSIAA, 
	EVDOTPWSSSIAA, 
	EVDOTPWAUMIAA, 
	EVDOTPWASMIAA, 
	EVDOTPWASUMIAA, 
	EVDOTPWSSMIAA, 
	EVADDIB, 
	EVADDIH, 
	EVSUBIFH, 
	EVSUBIFB, 
	EVABSB, 
	EVABSH, 
	EVABSD, 
	EVABSS, 
	EVABSBS, 
	EVABSHS, 
	EVABSDS, 
	EVNEGWO, 
	EVNEGB, 
	EVNEGBO, 
	EVNEGH, 
	EVNEGHO, 
	EVNEGD, 
	EVNEGS, 
	EVNEGWOS, 
	EVNEGBS, 
	EVNEGBOS, 
	EVNEGHS, 
	EVNEGHOS, 
	EVNEGDS, 
	EVEXTZB, 
	EVEXTSBH, 
	EVEXTSW, 
	EVRNDWH, 
	EVRNDHB, 
	EVRNDDW, 
	EVRNDWHUS, 
	EVRNDWHSS, 
	EVRNDHBUS, 
	EVRNDHBSS, 
	EVRNDDWUS, 
	EVRNDDWSS, 
	EVRNDWNH, 
	EVRNDHNB, 
	EVRNDDNW, 
	EVRNDWNHUS, 
	EVRNDWNHSS, 
	EVRNDHNBUS, 
	EVRNDHNBSS, 
	EVRNDDNWUS, 
	EVRNDDNWSS, 
	EVCNTLZH, 
	EVCNTLSH, 
	EVPOPCNTB, 
	CIRCINC, 
	EVUNPKHIBUI, 
	EVUNPKHIBSI, 
	EVUNPKHIHUI, 
	EVUNPKHIHSI, 
	EVUNPKLOBUI, 
	EVUNPKLOBSI, 
	EVUNPKLOHUI, 
	EVUNPKLOHSI, 
	EVUNPKLOHF, 
	EVUNPKHIHF, 
	EVUNPKLOWGSF, 
	EVUNPKHIWGSF, 
	EVSATSDUW, 
	EVSATSDSW, 
	EVSATSHUB, 
	EVSATSHSB, 
	EVSATUWUH, 
	EVSATSWSH, 
	EVSATSWUH, 
	EVSATUHUB, 
	EVSATUDUW, 
	EVSATUWSW, 
	EVSATSHUH, 
	EVSATUHSH, 
	EVSATSWUW, 
	EVSATSWGSDF, 
	EVSATSBUB, 
	EVSATUBSB, 
	EVMAXHPUW, 
	EVMAXHPSW, 
	EVMAXBPUH, 
	EVMAXBPSH, 
	EVMAXWPUD, 
	EVMAXWPSD, 
	EVMINHPUW, 
	EVMINHPSW, 
	EVMINBPUH, 
	EVMINBPSH, 
	EVMINWPUD, 
	EVMINWPSD, 
	EVMAXMAGWS, 
	EVSL, 
	EVSLI, 
	EVSPLATIE, 
	EVSPLATIB, 
	EVSPLATIBE, 
	EVSPLATIH, 
	EVSPLATIHE, 
	EVSPLATID, 
	EVSPLATIA, 
	EVSPLATIEA, 
	EVSPLATIBA, 
	EVSPLATIBEA, 
	EVSPLATIHA, 
	EVSPLATIHEA, 
	EVSPLATIDA, 
	EVSPLATFIO, 
	EVSPLATFIB, 
	EVSPLATFIBO, 
	EVSPLATFIH, 
	EVSPLATFIHO, 
	EVSPLATFID, 
	EVSPLATFIA, 
	EVSPLATFIOA, 
	EVSPLATFIBA, 
	EVSPLATFIBOA, 
	EVSPLATFIHA, 
	EVSPLATFIHOA, 
	EVSPLATFIDA, 
	EVCMPGTDU, 
	EVCMPGTDS, 
	EVCMPLTDU, 
	EVCMPLTDS, 
	EVCMPEQD, 
	EVSWAPBHILO, 
	EVSWAPBLOHI, 
	EVSWAPHHILO, 
	EVSWAPHLOHI, 
	EVSWAPHE, 
	EVSWAPHHI, 
	EVSWAPHLO, 
	EVSWAPHO, 
	EVINSB, 
	EVXTRB, 
	EVSPLATH, 
	EVSPLATB, 
	EVINSH, 
	EVCLRBE, 
	EVCLRBO, 
	EVCLRH, 
	EVXTRH, 
	EVSELBITM0, 
	EVSELBITM1, 
	EVSELBIT, 
	EVPERM, 
	EVPERM2, 
	EVPERM3, 
	EVXTRD, 
	EVSRBU, 
	EVSRBS, 
	EVSRBIU, 
	EVSRBIS, 
	EVSLB, 
	EVRLB, 
	EVSLBI, 
	EVRLBI, 
	EVSRHU, 
	EVSRHS, 
	EVSRHIU, 
	EVSRHIS, 
	EVSLH, 
	EVRLH, 
	EVSLHI, 
	EVRLHI, 
	EVSRU, 
	EVSRS, 
	EVSRIU, 
	EVSRIS, 
	EVLVSL, 
	EVLVSR, 
	EVSROIU, 
	EVSROIS, 
	EVSLOI, 
	EVLDBX, 
	EVLDB, 
	EVLHHSPLATHX, 
	EVLHHSPLATH, 
	EVLWBSPLATWX, 
	EVLWBSPLATW, 
	EVLWHSPLATWX, 
	EVLWHSPLATW, 
	EVLBBSPLATBX, 
	EVLBBSPLATB, 
	EVSTDBX, 
	EVSTDB, 
	EVLWBEX, 
	EVLWBE, 
	EVLWBOUX, 
	EVLWBOU, 
	EVLWBOSX, 
	EVLWBOS, 
	EVSTWBEX, 
	EVSTWBE, 
	EVSTWBOX, 
	EVSTWBO, 
	EVSTWBX, 
	EVSTWB, 
	EVSTHBX, 
	EVSTHB, 
	EVLDDMX, 
	EVLDDU, 
	EVLDWMX, 
	EVLDWU, 
	EVLDHMX, 
	EVLDHU, 
	EVLDBMX, 
	EVLDBU, 
	EVLHHESPLATMX, 
	EVLHHESPLATU, 
	EVLHHSPLATHMX, 
	EVLHHSPLATHU, 
	EVLHHOUSPLATMX, 
	EVLHHOUSPLATU, 
	EVLHHOSSPLATMX, 
	EVLHHOSSPLATU, 
	EVLWHEMX, 
	EVLWHEU, 
	EVLWBSPLATWMX, 
	EVLWBSPLATWU, 
	EVLWHOUMX, 
	EVLWHOUU, 
	EVLWHOSMX, 
	EVLWHOSU, 
	EVLWWSPLATMX, 
	EVLWWSPLATU, 
	EVLWHSPLATWMX, 
	EVLWHSPLATWU, 
	EVLWHSPLATMX, 
	EVLWHSPLATU, 
	EVLBBSPLATBMX, 
	EVLBBSPLATBU, 
	EVSTDDMX, 
	EVSTDDU, 
	EVSTDWMX, 
	EVSTDWU, 
	EVSTDHMX, 
	EVSTDHU, 
	EVSTDBMX, 
	EVSTDBU, 
	EVLWBEMX, 
	EVLWBEU, 
	EVLWBOUMX, 
	EVLWBOUU, 
	EVLWBOSMX, 
	EVLWBOSU, 
	EVSTWHEMX, 
	EVSTWHEU, 
	EVSTWBEMX, 
	EVSTWBEU, 
	EVSTWHOMX, 
	EVSTWHOU, 
	EVSTWBOMX, 
	EVSTWBOU, 
	EVSTWWEMX, 
	EVSTWWEU, 
	EVSTWBMX, 
	EVSTWBU, 
	EVSTWWOMX, 
	EVSTWWOU, 
	EVSTHBMX, 
	EVSTHBU, 
	EVMHUSI, 
	EVMHSSI, 
	EVMHSUSI, 
	EVMHSSF, 
	EVMHUMI, 
	EVMHSSFR, 
	EVMHESUMI, 
	EVMHOSUMI, 
	EVMBEUMI, 
	EVMBESMI, 
	EVMBESUMI, 
	EVMBOUMI, 
	EVMBOSMI, 
	EVMBOSUMI, 
	EVMHESUMIA, 
	EVMHOSUMIA, 
	EVMBEUMIA, 
	EVMBESMIA, 
	EVMBESUMIA, 
	EVMBOUMIA, 
	EVMBOSMIA, 
	EVMBOSUMIA, 
	EVMWUSIW, 
	EVMWSSIW, 
	EVMWHSSFR, 
	EVMWEHGSMFR, 
	EVMWEHGSMF, 
	EVMWOHGSMFR, 
	EVMWOHGSMF, 
	EVMWHSSFRA, 
	EVMWEHGSMFRA, 
	EVMWEHGSMFA, 
	EVMWOHGSMFRA, 
	EVMWOHGSMFA, 
	EVADDUSIAA, 
	EVADDSSIAA, 
	EVSUBFUSIAA, 
	EVSUBFSSIAA, 
	EVADDSMIAA, 
	EVSUBFSMIAA, 
	EVADDH, 
	EVADDHSS, 
	EVSUBFH, 
	EVSUBFHSS, 
	EVADDHX, 
	EVADDHXSS, 
	EVSUBFHX, 
	EVSUBFHXSS, 
	EVADDD, 
	EVADDDSS, 
	EVSUBFD, 
	EVSUBFDSS, 
	EVADDB, 
	EVADDBSS, 
	EVSUBFB, 
	EVSUBFBSS, 
	EVADDSUBFH, 
	EVADDSUBFHSS, 
	EVSUBFADDH, 
	EVSUBFADDHSS, 
	EVADDSUBFHX, 
	EVADDSUBFHXSS, 
	EVSUBFADDHX, 
	EVSUBFADDHXSS, 
	EVADDDUS, 
	EVADDBUS, 
	EVSUBFDUS, 
	EVSUBFBUS, 
	EVADDWUS, 
	EVADDWXUS, 
	EVSUBFWUS, 
	EVSUBFWXUS, 
	EVADD2SUBF2H, 
	EVADD2SUBF2HSS, 
	EVSUBF2ADD2H, 
	EVSUBF2ADD2HSS, 
	EVADDHUS, 
	EVADDHXUS, 
	EVSUBFHUS, 
	EVSUBFHXUS, 
	EVADDWSS, 
	EVSUBFWSS, 
	EVADDWX, 
	EVADDWXSS, 
	EVSUBFWX, 
	EVSUBFWXSS, 
	EVADDSUBFW, 
	EVADDSUBFWSS, 
	EVSUBFADDW, 
	EVSUBFADDWSS, 
	EVADDSUBFWX, 
	EVADDSUBFWXSS, 
	EVSUBFADDWX, 
	EVSUBFADDWXSS, 
	EVMAR, 
	EVSUMWU, 
	EVSUMWS, 
	EVSUM4BU, 
	EVSUM4BS, 
	EVSUM2HU, 
	EVSUM2HS, 
	EVDIFF2HIS, 
	EVSUM2HIS, 
	EVSUMWUA, 
	EVSUMWSA, 
	EVSUM4BUA, 
	EVSUM4BSA, 
	EVSUM2HUA, 
	EVSUM2HSA, 
	EVDIFF2HISA, 
	EVSUM2HISA, 
	EVSUMWUAA, 
	EVSUMWSAA, 
	EVSUM4BUAAW, 
	EVSUM4BSAAW, 
	EVSUM2HUAAW, 
	EVSUM2HSAAW, 
	EVDIFF2HISAAW, 
	EVSUM2HISAAW, 
	EVDIVWSF, 
	EVDIVWUF, 
	EVDIVS, 
	EVDIVU, 
	EVADDWEGSI, 
	EVADDWEGSF, 
	EVSUBFWEGSI, 
	EVSUBFWEGSF, 
	EVADDWOGSI, 
	EVADDWOGSF, 
	EVSUBFWOGSI, 
	EVSUBFWOGSF, 
	EVADDHHIUW, 
	EVADDHHISW, 
	EVSUBFHHIUW, 
	EVSUBFHHISW, 
	EVADDHLOUW, 
	EVADDHLOSW, 
	EVSUBFHLOUW, 
	EVSUBFHLOSW, 
	EVMHESUSIAAW, 
	EVMHOSUSIAAW, 
	EVMHESUMIAAW, 
	EVMHOSUMIAAW, 
	EVMBEUSIAAH, 
	EVMBESSIAAH, 
	EVMBESUSIAAH, 
	EVMBOUSIAAH, 
	EVMBOSSIAAH, 
	EVMBOSUSIAAH, 
	EVMBEUMIAAH, 
	EVMBESMIAAH, 
	EVMBESUMIAAH, 
	EVMBOUMIAAH, 
	EVMBOSMIAAH, 
	EVMBOSUMIAAH, 
	EVMWLUSIAAW3, 
	EVMWLSSIAAW3, 
	EVMWHSSFRAAW3, 
	EVMWHSSFAAW3, 
	EVMWHSSFRAAW, 
	EVMWHSSFAAW, 
	EVMWLUMIAAW3, 
	EVMWLSMIAAW3, 
	EVMWUSIAA, 
	EVMWSSIAA, 
	EVMWEHGSMFRAA, 
	EVMWEHGSMFAA, 
	EVMWOHGSMFRAA, 
	EVMWOHGSMFAA, 
	EVMHESUSIANW, 
	EVMHOSUSIANW, 
	EVMHESUMIANW, 
	EVMHOSUMIANW, 
	EVMBEUSIANH, 
	EVMBESSIANH, 
	EVMBESUSIANH, 
	EVMBOUSIANH, 
	EVMBOSSIANH, 
	EVMBOSUSIANH, 
	EVMBEUMIANH, 
	EVMBESMIANH, 
	EVMBESUMIANH, 
	EVMBOUMIANH, 
	EVMBOSMIANH, 
	EVMBOSUMIANH, 
	EVMWLUSIANW3, 
	EVMWLSSIANW3, 
	EVMWHSSFRANW3, 
	EVMWHSSFANW3, 
	EVMWHSSFRANW, 
	EVMWHSSFANW, 
	EVMWLUMIANW3, 
	EVMWLSMIANW3, 
	EVMWUSIAN, 
	EVMWSSIAN, 
	EVMWEHGSMFRAN, 
	EVMWEHGSMFAN, 
	EVMWOHGSMFRAN, 
	EVMWOHGSMFAN, 
	EVSETEQB, 
	EVSETEQH, 
	EVSETEQW, 
	EVSETGTHU, 
	EVSETGTHS, 
	EVSETGTWU, 
	EVSETGTWS, 
	EVSETGTBU, 
	EVSETGTBS, 
	EVSETLTBU, 
	EVSETLTBS, 
	EVSETLTHU, 
	EVSETLTHS, 
	EVSETLTWU, 
	EVSETLTWS, 
	EVSADUW, 
	EVSADSW, 
	EVSAD4UB, 
	EVSAD4SB, 
	EVSAD2UH, 
	EVSAD2SH, 
	EVSADUWA, 
	EVSADSWA, 
	EVSAD4UBA, 
	EVSAD4SBA, 
	EVSAD2UHA, 
	EVSAD2SHA, 
	EVABSDIFUW, 
	EVABSDIFSW, 
	EVABSDIFUB, 
	EVABSDIFSB, 
	EVABSDIFUH, 
	EVABSDIFSH, 
	EVSADUWAA, 
	EVSADSWAA, 
	EVSAD4UBAAW, 
	EVSAD4SBAAW, 
	EVSAD2UHAAW, 
	EVSAD2SHAAW, 
	EVPKSHUBS, 
	EVPKSHSBS, 
	EVPKSWUHS, 
	EVPKSWSHS, 
	EVPKUHUBS, 
	EVPKUWUHS, 
	EVPKSWSHILVS, 
	EVPKSWGSHEFRS, 
	EVPKSWSHFRS, 
	EVPKSWSHILVFRS, 
	EVPKSDSWFRS, 
	EVPKSDSHEFRS, 
	EVPKUDUWS, 
	EVPKSDSWS, 
	EVPKSWGSWFRS, 
	EVILVEH, 
	EVILVEOH, 
	EVILVHIH, 
	EVILVHILOH, 
	EVILVLOH, 
	EVILVLOHIH, 
	EVILVOEH, 
	EVILVOH, 
	EVDLVEB, 
	EVDLVEH, 
	EVDLVEOB, 
	EVDLVEOH, 
	EVDLVOB, 
	EVDLVOH, 
	EVDLVOEB, 
	EVDLVOEH, 
	EVMAXBU, 
	EVMAXBS, 
	EVMAXHU, 
	EVMAXHS, 
	EVMAXWU, 
	EVMAXWS, 
	EVMAXDU, 
	EVMAXDS, 
	EVMINBU, 
	EVMINBS, 
	EVMINHU, 
	EVMINHS, 
	EVMINWU, 
	EVMINWS, 
	EVMINDU, 
	EVMINDS, 
	EVAVGWU, 
	EVAVGWS, 
	EVAVGBU, 
	EVAVGBS, 
	EVAVGHU, 
	EVAVGHS, 
	EVAVGDU, 
	EVAVGDS, 
	EVAVGWUR, 
	EVAVGWSR, 
	EVAVGBUR, 
	EVAVGBSR, 
	EVAVGHUR, 
	EVAVGHSR, 
	EVAVGDUR, 
	EVAVGDSR, 
	// -------------------------------------------------------------------------
	// §41 Paired Singles (Gekko/Broadway — GameCube + Wii)
	// -------------------------------------------------------------------------
	// 62 entries from binutils PPCPS set. LLVM 22 lacks all of these.
	// Bit patterns from Gekko/Broadway User's Manual §1.2.4 (A/X/XOPS/XW forms,
	// primary opcode 4 sharing space with AltiVec/SPE — disambiguated by XO).
	PS_DIV, 
	PS_DIV_DOT, 
	PS_SUB, 
	PS_SUB_DOT, 
	PS_ADD, 
	PS_ADD_DOT, 
	PS_SEL, 
	PS_SEL_DOT, 
	PS_RES, 
	PS_RES_DOT, 
	PS_MUL, 
	PS_MUL_DOT, 
	PS_RSQRTE, 
	PS_RSQRTE_DOT, 
	PS_MSUB, 
	PS_MSUB_DOT, 
	PS_MADD, 
	PS_MADD_DOT, 
	PS_NMSUB, 
	PS_NMSUB_DOT, 
	PS_NMADD, 
	PS_NMADD_DOT, 
	PS_SUM0, 
	PS_SUM0_DOT, 
	PS_SUM1, 
	PS_SUM1_DOT, 
	PS_MULS0, 
	PS_MULS0_DOT, 
	PS_MULS1, 
	PS_MULS1_DOT, 
	PS_MADDS0, 
	PS_MADDS0_DOT, 
	PS_MADDS1, 
	PS_MADDS1_DOT, 
	PS_NEG, 
	PS_NEG_DOT, 
	PS_MR, 
	PS_MR_DOT, 
	PS_NABS, 
	PS_NABS_DOT, 
	PS_ABS, 
	PS_ABS_DOT, 
	PS_CMPU0, 
	PS_CMPU1, 
	PS_CMPO0, 
	PS_CMPO1, 
	PS_MERGE00, 
	PS_MERGE00_DOT, 
	PS_MERGE01, 
	PS_MERGE01_DOT, 
	PS_MERGE10, 
	PS_MERGE10_DOT, 
	PS_MERGE11, 
	PS_MERGE11_DOT, 
	// Paired single quantized loads/stores (use GQR0..GQR7 SPRs for format)
	PSQ_LX, 
	PSQ_LUX, 
	PSQ_STX, 
	PSQ_STUX, 
	PSQ_L, 
	PSQ_LU, 
	PSQ_ST, 
	PSQ_STU, 
	// ---- Arithmetic / FP ----
	VADDFP128, 
	VSUBFP128, 
	VMULFP128, 
	VMADDFP128, 
	VMADDCFP128, 
	VNMSUBFP128, 
	VMSUM3FP128, 
	VMSUM4FP128, 
	VMAXFP128, 
	VMINFP128, 
	VREFP128, 
	VRSQRTEFP128, 
	VEXPTEFP128, 
	VLOGEFP128, 
	// ---- Logical ----
	VAND128, 
	VANDC128, 
	VOR128, 
	VXOR128, 
	VNOR128, 
	VSEL128, 
	// ---- Compare ----
	VCMPEQFP128, 
	VCMPEQFP128_DOT, 
	VCMPGEFP128, 
	VCMPGEFP128_DOT, 
	VCMPGTFP128, 
	VCMPGTFP128_DOT, 
	VCMPBFP128, 
	VCMPBFP128_DOT, 
	VCMPEQUW128, 
	VCMPEQUW128_DOT, 
	// ---- Rounding ----
	VRFIM128, 
	VRFIN128, 
	VRFIP128, 
	VRFIZ128, 
	// ---- Convert ----
	VCFPSXWS128, 
	VCFPUXWS128, 
	VCSXWFP128, 
	VCUXWFP128, 
	// ---- Splat / merge / permute ----
	VSPLTW128, 
	VSPLTISW128, 
	VMRGHW128, 
	VMRGLW128, 
	VPKD3D128, 
	VUPKD3D128, 
	VPERM128, 
	VPERMWI128, 
	VRLIMI128, 
	VSLDOI128, 
	// ---- Shift / rotate ----
	VRLW128, 
	VSLW128, 
	VSRW128, 
	VSRAW128, 
	// ---- Memory (load/store indexed) ----
	LVEBX128, 
	LVEHX128, 
	LVEWX128, 
	LVX128, 
	LVXL128, 
	LVLX128, 
	LVRX128, 
	LVLXL128, 
	LVRXL128, 
	STVEBX128, 
	STVEHX128, 
	STVEWX128, 
	STVX128, 
	STVXL128, 
	STVLX128, 
	STVRX128, 
	STVLXL128, 
	STVRXL128, 
	// -------------------------------------------------------------------------
	// §43 Remaining binutils PPC categories (MULHW/M601/PWRCOM/PPCCOM/PPCA2/
	//     E6500/PPC403/405/440/476/TITAN/CELL/etc.) — 518 entries.
	// -------------------------------------------------------------------------
	// LLVM 22 lacks most of these; all classified as expected_unknown.
	TI, 
	MULHHWU, 
	MULHHWU_DOT, 
	MACHHWU, 
	MACHHWU_DOT, 
	MULHHW, 
	MULHHW_DOT, 
	MACHHW, 
	MACHHW_DOT, 
	NMACHHW, 
	NMACHHW_DOT, 
	MACHHWSU, 
	MACHHWSU_DOT, 
	MACHHWS, 
	MACHHWS_DOT, 
	NMACHHWS, 
	NMACHHWS_DOT, 
	VADDUQM, 
	VCMPUQ, 
	MULCHWU, 
	MULCHWU_DOT, 
	MACCHWU, 
	MACCHWU_DOT, 
	VCMPSQ, 
	MULCHW, 
	MULCHW_DOT, 
	MACCHW, 
	MACCHW_DOT, 
	NMACCHW, 
	NMACCHW_DOT, 
	MACCHWSU, 
	MACCHWSU_DOT, 
	VCMPEQUQ, 
	MACCHWS, 
	MACCHWS_DOT, 
	NMACCHWS, 
	NMACCHWS_DOT, 
	VCMPGTUQ, 
	VCUXWFP, 
	MULLHWU, 
	MULLHWU_DOT, 
	MACLHWU, 
	MACLHWU_DOT, 
	VCSXWFP, 
	MULLHW, 
	MULLHW_DOT, 
	MACLHW, 
	MACLHW_DOT, 
	NMACLHW, 
	NMACLHW_DOT, 
	VCMPGTSQ, 
	VCFPUXWS, 
	MACLHWSU, 
	MACLHWSU_DOT, 
	VCFPSXWS, 
	MACLHWS, 
	MACLHWS_DOT, 
	NMACLHWS, 
	NMACLHWS_DOT, 
	MACHHWUO, 
	MACHHWUO_DOT, 
	MACHHWO, 
	MACHHWO_DOT, 
	NMACHHWO, 
	NMACHHWO_DOT, 
	VMR, 
	MACHHWSUO, 
	MACHHWSUO_DOT, 
	MACHHWSO, 
	MACHHWSO_DOT, 
	NMACHHWSO, 
	NMACHHWSO_DOT, 
	VSUBUQM, 
	VNOT, 
	VGBBD, 
	MACCHWUO, 
	MACCHWUO_DOT, 
	MACCHWO, 
	MACCHWO_DOT, 
	NMACCHWO, 
	NMACCHWO_DOT, 
	MACCHWSUO, 
	MACCHWSUO_DOT, 
	VCMPEQUQ_DOT, 
	MACCHWSO, 
	MACCHWSO_DOT, 
	NMACCHWSO, 
	NMACCHWSO_DOT, 
	VCMPGTUQ_DOT, 
	MACLHWUO, 
	MACLHWUO_DOT, 
	MACLHWO, 
	MACLHWO_DOT, 
	NMACLHWO, 
	NMACLHWO_DOT, 
	VCMPGTSQ_DOT, 
	MACLHWSUO, 
	MACLHWSUO_DOT, 
	MACLHWSO, 
	MACLHWSO_DOT, 
	NMACLHWSO, 
	NMACLHWSO_DOT, 
	DCBZ_L, 
	MULI, 
	SFI, 
	DOZI, 
	AI, 
	SUBIC, 
	AI_DOT, 
	SUBIC_DOT, 
	LIL, 
	CAL, 
	SUBI, 
	LIU, 
	CAU, 
	SUBIS, 
	CRNOT, 
	RFCI, 
	RFSCV, 
	RFSVC, 
	RFGI, 
	ICS, 
	CRCLR, 
	DNH, 
	CRSET, 
	URFID, 
	DOZE, 
	CRMOVE, 
	SLEEP, 
	RVWINKLE, 
	ORIL, 
	ORIU, 
	XORIL, 
	XORIU, 
	ANDIL_DOT, 
	ANDIU_DOT, 
	ROTLDI_DOT, 
	ROTRDI_DOT, 
	CLRLDI_DOT, 
	SRDI_DOT, 
	EXTRDI_DOT, 
	CLRRDI_DOT, 
	SLDI_DOT, 
	EXTLDI_DOT, 
	CLRLSLDI, 
	CLRLSLDI_DOT, 
	INSRDI, 
	INSRDI_DOT, 
	ROTLD_DOT, 
	T, 
	SF, 
	SF_DOT, 
	A_DOT, 
	LX, 
	SL, 
	SL_DOT, 
	CNTLZ, 
	CNTLZ_DOT, 
	MASKG, 
	MASKG_DOT, 
	LDEPX, 
	WAITASEC, 
	MVIWSPLT, 
	MFVSRD, 
	ERATILX, 
	LUX, 
	SUBWUS, 
	SUBWUS_DOT, 
	SUBDUS, 
	SUBDUS_DOT, 
	SUBFUS, 
	SUBFUS_DOT, 
	DLMZB, 
	DLMZB_DOT, 
	DNI, 
	MUL, 
	MUL_DOT, 
	MVIDSPLT, 
	MTSRDIN, 
	MFVSRWZ, 
	CLF, 
	DCBTSTLS, 
	SFE, 
	SFE_DOT, 
	AE, 
	AE_DOT, 
	DCBTSTLSE, 
	MTSLE, 
	ERATSX, 
	ERATSX_DOT, 
	STX, 
	SLQ, 
	SLQ_DOT, 
	SLE, 
	SLE_DOT, 
	STDEPX, 
	DCBTLS, 
	DCBTLSE, 
	MTVSRD, 
	ERATRE, 
	WCHKALL, 
	STUX, 
	SLIQ, 
	SLIQ_DOT, 
	ICBLQ_DOT, 
	SFZE, 
	SFZE_DOT, 
	AZE, 
	AZE_DOT, 
	MTVSRWA, 
	ERATWE, 
	LDAWX_DOT, 
	SLLQ, 
	SLLQ_DOT, 
	SLEQ, 
	SLEQ_DOT, 
	SFME, 
	SFME_DOT, 
	AME, 
	AME_DOT, 
	MULS, 
	MULS_DOT, 
	ICBLCE, 
	MTSRI, 
	MTVSRWZ, 
	DCBTSTCT, 
	DCBTSTDS, 
	SLLIQ, 
	SLLIQ_DOT, 
	MFDCRX, 
	MFDCRX_DOT, 
	LVEXBX, 
	LVEPXL, 
	DOZ, 
	DOZ_DOT, 
	CAX, 
	CAX_DOT, 
	EHPRIV, 
	MFAPIDI, 
	LSCBX, 
	LSCBX_DOT, 
	DCBTCT, 
	DCBTDS, 
	MFDCRUX, 
	LVEXHX, 
	LVEPX, 
	MFBHRBE, 
	TLBI, 
	ECIWX, 
	MFDCR_DOT, 
	LVEXWX, 
	DCREAD, 
	DIV, 
	DIV_DOT, 
	MFTMR, 
	ABS, 
	ABS_DOT, 
	DIVS, 
	DIVS_DOT, 
	LXVWSX, 
	TLBIA, 
	SETBC, 
	MTDCRX, 
	MTDCRX_DOT, 
	STVEXBX, 
	DCBLC, 
	DCBLCE, 
	PBT_DOT, 
	ICSWX, 
	ICSWX_DOT, 
	SETBCR, 
	MTDCRUX, 
	STVEXHX, 
	DCBLQ_DOT, 
	CLRBHRB, 
	ECOWX, 
	SETNBC, 
	MTDCR_DOT, 
	STVEXWX, 
	DCI, 
	MTTMR, 
	SETNBCR, 
	DSN, 
	NABS, 
	NABS_DOT, 
	ICBTLSE, 
	CLI, 
	MCRXR, 
	LBDCBX, 
	LBDX, 
	BBLELS, 
	LVLX, 
	SUBFCO, 
	SFO, 
	SUBCO, 
	SUBFCO_DOT, 
	SFO_DOT, 
	SUBCO_DOT, 
	ADDCO, 
	AO, 
	ADDCO_DOT, 
	AO_DOT, 
	CLCS, 
	LSX, 
	LBRX, 
	SR_DOT, 
	RRIB, 
	RRIB_DOT, 
	MASKIR, 
	MASKIR_DOT, 
	LHDCBX, 
	LHDX, 
	LVTRX, 
	BBELR, 
	LVRX, 
	SUBFO, 
	SUBO, 
	SUBFO_DOT, 
	SUBO_DOT, 
	LWDCBX, 
	LWDX, 
	LVTLX, 
	LSI, 
	DCS, 
	MFFGPR, 
	LDDX, 
	LVSWX, 
	NEGO, 
	NEGO_DOT, 
	MULO, 
	MULO_DOT, 
	MFSRI, 
	DCLST, 
	STBDCBX, 
	STBDX, 
	STVLX, 
	SUBFEO, 
	SFEO, 
	SUBFEO_DOT, 
	SFEO_DOT, 
	ADDEO, 
	AEO, 
	ADDEO_DOT, 
	AEO_DOT, 
	HASHSTP, 
	STSX, 
	STBRX, 
	SRQ, 
	SRQ_DOT, 
	SRE, 
	SRE_DOT, 
	STHDCBX, 
	STHDX, 
	STVFRX, 
	STVRX, 
	HASHCHKP, 
	SRIQ, 
	SRIQ_DOT, 
	STWDCBX, 
	STWDX, 
	STVFLX, 
	SUBFZEO, 
	SFZEO, 
	SUBFZEO_DOT, 
	SFZEO_DOT, 
	ADDZEO, 
	AZEO, 
	ADDZEO_DOT, 
	AZEO_DOT, 
	HASHST, 
	STSI, 
	SRLQ, 
	SRLQ_DOT, 
	SREQ, 
	SREQ_DOT, 
	MFTGPR, 
	STDDX, 
	STVSWX, 
	SUBFMEO, 
	SFMEO, 
	SUBFMEO_DOT, 
	SFMEO_DOT, 
	MULLDO, 
	MULLDO_DOT, 
	ADDMEO, 
	AMEO, 
	ADDMEO_DOT, 
	AMEO_DOT, 
	MULLWO, 
	MULSO, 
	MULLWO_DOT, 
	MULSO_DOT, 
	TSR_DOT, 
	HASHCHK, 
	SRLIQ, 
	SRLIQ_DOT, 
	LVSM, 
	STVEPXL, 
	LVLXL, 
	DOZO, 
	DOZO_DOT, 
	ADDO, 
	CAXO, 
	ADDO_DOT, 
	CAXO_DOT, 
	LFQX, 
	SRA, 
	SRA_DOT, 
	EVLDDEPX, 
	LFDDX, 
	LVTRXL, 
	STVEPX, 
	LVRXL, 
	RAC, 
	ERATIVAX, 
	LFQUX, 
	SRAI, 
	SRAI_DOT, 
	LVTLXL, 
	DIVO, 
	DIVO_DOT, 
	TLBSRX_DOT, 
	SLBIAG, 
	LVSWXL, 
	ABSO, 
	ABSO_DOT, 
	DIVSO, 
	DIVSO_DOT, 
	RMIEG, 
	STVLXL, 
	DIVDEUO_DOT, 
	DIVWEUO_DOT, 
	TLBSX_DOT, 
	STFQX, 
	SRAQ, 
	SRAQ_DOT, 
	SREA, 
	SREA_DOT, 
	EXTS, 
	EXTS_DOT, 
	EVSTDDEPX, 
	STFDDX, 
	STVFRXL, 
	WCLRALL, 
	WCLR, 
	STVRXL, 
	DIVDEO_DOT, 
	DIVWEO_DOT, 
	ICSWEPX, 
	ICSWEPX_DOT, 
	STFQUX, 
	SRAIQ, 
	SRAIQ_DOT, 
	STVFLXL, 
	ICI, 
	DIVDUO, 
	DIVDUO_DOT, 
	DIVWUO, 
	DIVWUO_DOT, 
	SLBFEE_DOT, 
	STVSWXL, 
	ICREAD, 
	NABSO, 
	NABSO_DOT, 
	DIVDO, 
	DIVDO_DOT, 
	DIVWO, 
	DIVWO_DOT, 
	DCLZ, 
	LU, 
	ST, 
	STU, 
	LM, 
	STM, 
	LFQ, 
	LFQU, 
	STFQ, 
	STFQU, 
	FCIR, 
	FCIR_DOT, 
	FCIRZ, 
	FCIRZ_DOT, 
	FD, 
	FD_DOT, 
	FS, 
	FS_DOT, 
	FA, 
	FA_DOT, 
	FM, 
	FM_DOT, 
	FMS, 
	FMS_DOT, 
	FMA, 
	FMA_DOT, 
	FNMS, 
	FNMS_DOT, 
	FNMA, 
	FNMA_DOT, 
	DTSTEXQ, 
	XSCMPEXPQP, 
	DXEXQ, 
	DXEXQ_DOT, 
	DTSTSFQ, 
	EVSETEQB_DOT, 
	EVSETEQH_DOT, 
	EVSETEQW_DOT, 
	EVSETGTHU_DOT, 
	EVSETGTHS_DOT, 
	EVSETGTWU_DOT, 
	EVSETGTWS_DOT, 
	EVSETGTBU_DOT, 
	EVSETGTBS_DOT, 
	EVSETLTBU_DOT, 
	EVSETLTBS_DOT, 
	EVSETLTHU_DOT, 
	EVSETLTHS_DOT, 
	EVSETLTWU_DOT, 
	EVSETLTWS_DOT, 
}
    Related Procedures With Parameters

    Mode ¶
    Source

    Mode :: enum u8 {
	PPC32 = 0, 
	PPC64 = 1, 
}
     

    Execution mode. PPC32 chips ignore the high half of 64-bit GPRs and lack 64-bit instructions (ld/std/mulld/rldicl/etc.). PPC64 implies PPC32.

    Related Procedures With Parameters

    Operand ¶
    Source

    Operand :: struct #packed {
	using _: struct #packed #raw_union {
		reg:       Register,
		mem:       Memory,
		immediate: i64,
		relative:  i64,
	},
	kind: Operand_Kind,
	size: u8,
}
    Related Procedures With Parameters
    Related Procedures With Returns

    Operand_Encoding ¶
    Source

    Operand_Encoding :: enum u8 {
	NONE, 
	IMPL, 
	// ---- Register slot fields ----
	RT,              // bits 21-25  (destination)
	RA,              // bits 16-20  (source 2 / base / Rd in MD-form)
	RB,              // bits 11-15  (source 3 / Rb)
	RC,              // bits  6-10  (A-form 4th source)
	RS,              // bits 21-25  (alias of RT used in store/X-form)
	// ---- Floating-point ----
	FRT,             // bits 21-25
	FRA,             // bits 16-20
	FRB,             // bits 11-15
	FRC,             // bits  6-10
	// ---- AltiVec vector ----
	VRT,             // bits 21-25
	VRA,             // bits 16-20
	VRB,             // bits 11-15
	VRC,             // bits  6-10
	// ---- VSX (split 5+1 bit register fields) ----
	XT,              // VSX dest:  bits 21-25 are XT[4:0], bit  0 is XT[5] (TX)
	XA,              // VSX src1:  bits 16-20 are XA[4:0], bit  2 is XA[5] (AX)
	XB,              // VSX src2:  bits 11-15 are XB[4:0], bit  1 is XB[5] (BX)
	XC,              // VSX 4-op:  bits  6-10 are XC[4:0], bit  3 is XC[5] (CX)
	// ---- VMX128 (Xbox 360 Xenon — split 7-bit register fields) ----
	// VMX128 extends the AltiVec 32-register file to 128 registers, encoding
	// the extra 2 bits in scattered positions per the VMX128 ISA leak. The
	// exact bit placement varies by form — these are the most common splits
	// used in xenia's disassembler (vaddfp128 / vsubfp128 / vor128 etc.).
	VRT128,          // 7-bit: low 5 at bits 21-25, high 2 at bits 5-6 (.h[1:0])
	VRA128,          // 7-bit: low 5 at bits 16-20, high 1 at bit  6, plus bit 3
	VRB128,          // 7-bit: low 5 at bits 11-15, high 2 at bits 2-3
	VRC128,          // 7-bit: low 3 at bits  6-8,  high 2 at bits 9-10
	// ---- Condition register fields ----
	BF,              // bits 23-25  (CR field, 3-bit, for cmp etc.)
	BFA,             // bits 18-20  (source CR field, 3-bit)
	BT,              // bits 21-25  (CR bit destination, 5-bit; XL-form)
	BA,              // bits 16-20  (CR bit source 1, 5-bit)
	BB,              // bits 11-15  (CR bit source 2, 5-bit)
	BO_FIELD,        // bits 21-25  (branch op, 5-bit)
	BI_FIELD,        // bits 16-20  (CR bit tested, 5-bit)
	BH_FIELD,        // bits 11-12  (branch hint, 2-bit; bclr/bcctr)
	// ---- SPR (10-bit split into two 5-bit halves at 11-15 and 16-20) ----
	SPR_FIELD,       // SPR encoded with halves swapped per PPC convention
	// ---- Immediates (positional) ----
	D16,             // bits  0-15  (D-form, signed 16)
	UI16,            // bits  0-15  (D-form, unsigned 16: ori/andi/oris/andis)
	DS14,            // bits  2-15  (DS-form, signed; scaled by 4)
	DQ12,            // bits  4-15  (DQ-form, signed; scaled by 16)
	SH5,             // bits 11-15  (M-form shift amount)
	SH6,             // bits 11-15 + bit 1 (MD/MDS-form shift, 6-bit split)
	MB5,             // bits  6-10  (M-form mask begin)
	ME5,             // bits  1-5   (M-form mask end)
	MB6,             // bits  5-10  (MD/MDS-form 6-bit mask begin/end)
	SIMM_5,          // bits 16-20  (AltiVec UIM5 / vspltisb-style signed)
	UIMM_5,          // bits 16-20  (AltiVec UIM5 unsigned)
	UIMM_4,          // bits 16-19  (AltiVec UIM4)
	UIMM_2,          // bits 16-17  (AltiVec UIM2)
	FXM,             // bits 12-19  (mtcrf field mask, 8 bits)
	L_FIELD,         // bit  21     (cmp L bit: 0=32-bit, 1=64-bit)
	TO_FIELD,        // bits 21-25  (tw/twi/td/tdi trap condition)
	NB_FIELD,        // bits 11-15  (lswi/stswi byte count)
	SR_FIELD,        // bits 16-19  (mfsr/mtsr segment register)
	CRM,             // bits 12-19  (mfcr/mtcr field mask)
	DCMX,            // bits 16-22  (VSX DCMX immediate)
	// ---- PC-relative ----
	BRANCH_LI,       // bits  2-25  (I-form, 24-bit signed << 2)
	BRANCH_BD,       // bits  2-15  (B-form, 14-bit signed << 2)
	AA_FLAG,         // bit  1      (absolute branch flag, 1 bit)
	LK_FLAG,         // bit  0      (link bit, 1 bit)
	RC_FLAG,         // bit  0      (record bit, 1 bit) — co-located with LK
	OE_FLAG,         // bit 10      (overflow-enable XO-form)
	// ---- Memory addressing composites ----
	OFFSET_BASE_D,   // [RA, #D16]        D-form
	OFFSET_BASE_DS,  // [RA, #DS14*4]     DS-form
	OFFSET_BASE_DQ,  // [RA, #DQ12*16]    DQ-form
	OFFSET_BASE_X,   // [RA, RB]          X-form indexed
	OFFSET_VSX_X,    // [RA, RB] for VSX  (uses RB encoding at 11-15)
	// ---- Prefixed (8-byte) instruction immediates ----
	// The Power ISA 3.1 prefix carries an additional 18 bits of immediate
	// (R: bit 20 + IMM18: bits 0-17 of the prefix word) appended above the
	// suffix's 16-bit field.
	PFX_IMM34_SI,    // signed 34-bit immediate, prefix R=0 (PLI, PADDI)
	PFX_IMM34_REL,   // 34-bit pc-relative when prefix R=1
	PFX_OFFSET_BASE, // prefixed memory operand: 34-bit signed offset + RA
	// ---- Miscellaneous fields ----
	EH_FIELD,        // bit 0 of lwarx/ldarx: external hint
	L_LFIELD,        // bit 10 of mtmsr / sync (variant selector)
	LEV_FIELD,       // bits 20-26 of sc (level)
	PS_FIELD,        // bit 15 of mtmsr (problem state)
	SXL_FIELD,       // bit 15 of rfi (rfi64 variant)
}
     

    Bit-level positions on the 32-bit instruction word (LSB-first).

    Operand_Kind ¶
    Source

    Operand_Kind :: enum u8 {
	NONE, 
	REGISTER,  // mostly used for `A` in `ROL A` (implicit; rarely needed)
	IMMEDIATE, 
	MEMORY, 
	RELATIVE,  // PC-relative target (label or raw byte offset)
}

    Operand_Type ¶
    Source

    Operand_Type :: enum u8 {
	NONE, 
	// ---- Integer registers ----
	GPR,         // r0..r31
	GPR_OR_ZERO, // r0..r31 where r0 is interpreted as literal 0 (RA in
	// ---- Floating-point ----
	FPR,         // f0..f31 (scalar FP)
	// ---- AltiVec vector ----
	VR,          // v0..v31 (128-bit AltiVec)
	// ---- VSX scalar / vector (64 regs) ----
	VSR,         // vs0..vs63 (unified — vs0..31 alias FPRs, vs32..63 alias VRs)
	// ---- VMX128 (Xbox 360 Xenon — 128 vector regs) ----
	VR128,       // vr0..vr127
	// ---- Condition register ----
	CR_FIELD,    // cr0..cr7 (3-bit field selector)
	CR_BIT,      // single bit within CR (5-bit; for mt/mfcr forms)
	// ---- Special-purpose register ----
	SPR,         // 10-bit SPR number (split as two 5-bit halves on wire)
	// ---- Immediates ----
	IMM,         // generic — width determined by Operand_Encoding
	SIMM,        // signed immediate (D-form, addi-style)
	UIMM,        // unsigned immediate (ori, andi, ...)
	// ---- PC-relative (label-resolving) ----
	REL,         // signed PC-relative branch displacement
	// ---- Memory ----
	MEM,         // memory operand (D-form, DS-form, X-form indexed)
	// ---- Branch helpers ----
	BO,          // 5-bit branch operation (bc family)
	BH,          // 2-bit branch hint (bcctr, bclr)
}
     

    What the user passes in (high-level operand type).

    Print_Options :: rexcode_isa.Print_Options
    Related Procedures With Parameters
    Related Constants
    Print_Result :: rexcode_isa.Print_Result

    Register ¶
    Source

    Register :: distinct u16
    Related Procedures With Parameters
    Related Procedures With Returns
    Related Constants

    Relocation ¶
    Source

    Relocation :: struct #packed {
	offset:   u32,
	// byte offset into code buffer
	label_id: u32,
	addend:   i32,
	type:     Relocation_Type,
	size:     u8,
	// 4 (base) or 8 (prefixed)
	inst_idx: u16,
}

    Relocation_Type ¶
    Source

    Relocation_Type :: enum u8 {
	NONE        = 0, 
	BRANCH_I_24,     // I-form: LI (24-bit signed << 2 at bits 2..25 LSB)
	BRANCH_B_14,     // B-form: BD (14-bit signed << 2 at bits 2..15 LSB)
	PREFIXED_34,     // Power ISA 3.1: 34-bit signed at IMM18(prefix)||D(suffix)
}

    Token ¶
    Source

    Token :: rexcode_isa.Token

    Token_Kind ¶
    Source

    Token_Kind :: rexcode_isa.Token_Kind

    Constants

    CR0 ¶
    Source

    CR0 :: Register(REG_CR | 0)

    CR1 ¶
    Source

    CR1 :: Register(REG_CR | 1)

    CR2 ¶
    Source

    CR2 :: Register(REG_CR | 2)

    CR3 ¶
    Source

    CR3 :: Register(REG_CR | 3)

    CR4 ¶
    Source

    CR4 :: Register(REG_CR | 4)

    CR5 ¶
    Source

    CR5 :: Register(REG_CR | 5)

    CR6 ¶
    Source

    CR6 :: Register(REG_CR | 6)

    CR7 ¶
    Source

    CR7 :: Register(REG_CR | 7)

    CTR ¶
    Source

    CTR :: Register(REG_SPR | 9)

    DAR ¶
    Source

    DAR :: Register(REG_SPR | 19)

    DEC ¶
    Source

    DEC :: Register(REG_SPR | 22)

    DECODE_SUB_BUCKETS ¶
    Source

    DECODE_SUB_BUCKETS :: 256
     

    per primary

    DEFAULT_PRINT_OPTIONS ¶
    Source

    DEFAULT_PRINT_OPTIONS: rexcode_isa.Print_Options : isa.DEFAULT_PRINT_OPTIONS

    DSCR ¶
    Source

    DSCR :: Register(REG_SPR | 17)
     

    ISA 2.06

    DSISR ¶
    Source

    DSISR :: Register(REG_SPR | 18)

    F0 ¶
    Source

    F0 :: Register(REG_FPR | 0)

    F1 ¶
    Source

    F1 :: Register(REG_FPR | 1)

    F10 ¶
    Source

    F10 :: Register(REG_FPR | 10)

    F11 ¶
    Source

    F11 :: Register(REG_FPR | 11)

    F12 ¶
    Source

    F12 :: Register(REG_FPR | 12)

    F13 ¶
    Source

    F13 :: Register(REG_FPR | 13)

    F14 ¶
    Source

    F14 :: Register(REG_FPR | 14)

    F15 ¶
    Source

    F15 :: Register(REG_FPR | 15)

    F16 ¶
    Source

    F16 :: Register(REG_FPR | 16)

    F17 ¶
    Source

    F17 :: Register(REG_FPR | 17)

    F18 ¶
    Source

    F18 :: Register(REG_FPR | 18)

    F19 ¶
    Source

    F19 :: Register(REG_FPR | 19)

    F2 ¶
    Source

    F2 :: Register(REG_FPR | 2)

    F20 ¶
    Source

    F20 :: Register(REG_FPR | 20)

    F21 ¶
    Source

    F21 :: Register(REG_FPR | 21)

    F22 ¶
    Source

    F22 :: Register(REG_FPR | 22)

    F23 ¶
    Source

    F23 :: Register(REG_FPR | 23)

    F24 ¶
    Source

    F24 :: Register(REG_FPR | 24)

    F25 ¶
    Source

    F25 :: Register(REG_FPR | 25)

    F26 ¶
    Source

    F26 :: Register(REG_FPR | 26)

    F27 ¶
    Source

    F27 :: Register(REG_FPR | 27)

    F28 ¶
    Source

    F28 :: Register(REG_FPR | 28)

    F29 ¶
    Source

    F29 :: Register(REG_FPR | 29)

    F3 ¶
    Source

    F3 :: Register(REG_FPR | 3)

    F30 ¶
    Source

    F30 :: Register(REG_FPR | 30)

    F31 ¶
    Source

    F31 :: Register(REG_FPR | 31)

    F4 ¶
    Source

    F4 :: Register(REG_FPR | 4)

    F5 ¶
    Source

    F5 :: Register(REG_FPR | 5)

    F6 ¶
    Source

    F6 :: Register(REG_FPR | 6)

    F7 ¶
    Source

    F7 :: Register(REG_FPR | 7)

    F8 ¶
    Source

    F8 :: Register(REG_FPR | 8)

    F9 ¶
    Source

    F9 :: Register(REG_FPR | 9)

    LABEL_UNDEFINED ¶
    Source

    LABEL_UNDEFINED: rexcode_isa.Label_Definition : isa.LABEL_UNDEFINED

    LR ¶
    Source

    LR :: Register(REG_SPR | 8)

    MAX_INST_SIZE ¶
    Source

    MAX_INST_SIZE :: 8
     

    prefixed instructions

    NONE ¶
    Source

    NONE :: Register(0xFFFF)

    R0 ¶
    Source

    R0 :: Register(REG_GPR | 0)

    R1 ¶
    Source

    R1 :: Register(REG_GPR | 1)

    R10 ¶
    Source

    R10 :: Register(REG_GPR | 10)

    R11 ¶
    Source

    R11 :: Register(REG_GPR | 11)

    R12 ¶
    Source

    R12 :: Register(REG_GPR | 12)

    R13 ¶
    Source

    R13 :: Register(REG_GPR | 13)

    R14 ¶
    Source

    R14 :: Register(REG_GPR | 14)

    R15 ¶
    Source

    R15 :: Register(REG_GPR | 15)

    R16 ¶
    Source

    R16 :: Register(REG_GPR | 16)

    R17 ¶
    Source

    R17 :: Register(REG_GPR | 17)

    R18 ¶
    Source

    R18 :: Register(REG_GPR | 18)

    R19 ¶
    Source

    R19 :: Register(REG_GPR | 19)

    R2 ¶
    Source

    R2 :: Register(REG_GPR | 2)

    R20 ¶
    Source

    R20 :: Register(REG_GPR | 20)

    R21 ¶
    Source

    R21 :: Register(REG_GPR | 21)

    R22 ¶
    Source

    R22 :: Register(REG_GPR | 22)

    R23 ¶
    Source

    R23 :: Register(REG_GPR | 23)

    R24 ¶
    Source

    R24 :: Register(REG_GPR | 24)

    R25 ¶
    Source

    R25 :: Register(REG_GPR | 25)

    R26 ¶
    Source

    R26 :: Register(REG_GPR | 26)

    R27 ¶
    Source

    R27 :: Register(REG_GPR | 27)

    R28 ¶
    Source

    R28 :: Register(REG_GPR | 28)

    R29 ¶
    Source

    R29 :: Register(REG_GPR | 29)

    R3 ¶
    Source

    R3 :: Register(REG_GPR | 3)

    R30 ¶
    Source

    R30 :: Register(REG_GPR | 30)

    R31 ¶
    Source

    R31 :: Register(REG_GPR | 31)

    R4 ¶
    Source

    R4 :: Register(REG_GPR | 4)

    R5 ¶
    Source

    R5 :: Register(REG_GPR | 5)

    R6 ¶
    Source

    R6 :: Register(REG_GPR | 6)

    R7 ¶
    Source

    R7 :: Register(REG_GPR | 7)

    R8 ¶
    Source

    R8 :: Register(REG_GPR | 8)

    R9 ¶
    Source

    R9 :: Register(REG_GPR | 9)

    REG_CR ¶
    Source

    REG_CR :: 0x5000
     

    CRF: cr0..cr7 in low 3 bits

    REG_FPR ¶
    Source

    REG_FPR :: 0x2000

    REG_GPR ¶
    Source

    REG_GPR :: 0x1000

    REG_NONE ¶
    Source

    REG_NONE :: 0x0000

    REG_SPR ¶
    Source

    REG_SPR :: 0x6000
     

    SPR number in low 10 bits (0..1023)

    REG_VR ¶
    Source

    REG_VR :: 0x3000

    REG_VR128 ¶
    Source

    REG_VR128 :: 0x7000
     

    VMX128 vector register (vr0..vr127, 7-bit hw index)

    REG_VSR ¶
    Source

    REG_VSR :: 0x4000

    SP_PPC ¶
    Source

    SP_PPC: Register : R1
     

    ABI conventions (System V / PowerOpen / ELFv2): r1 = stack pointer r2 = TOC pointer (ELFv2) / system reserved (Linux) r3..r10 = arg/return regs r13 = TLS pointer (Linux) / small data anchor (eabi)

    SRR0 ¶
    Source

    SRR0 :: Register(REG_SPR | 26)

    SRR1 ¶
    Source

    SRR1 :: Register(REG_SPR | 27)

    TBL ¶
    Source

    TBL :: Register(REG_SPR | 268)

    TBU ¶
    Source

    TBU :: Register(REG_SPR | 269)

    V0 ¶
    Source

    V0 :: Register(REG_VR | 0)

    V1 ¶
    Source

    V1 :: Register(REG_VR | 1)

    V10 ¶
    Source

    V10 :: Register(REG_VR | 10)

    V11 ¶
    Source

    V11 :: Register(REG_VR | 11)

    V12 ¶
    Source

    V12 :: Register(REG_VR | 12)

    V13 ¶
    Source

    V13 :: Register(REG_VR | 13)

    V14 ¶
    Source

    V14 :: Register(REG_VR | 14)

    V15 ¶
    Source

    V15 :: Register(REG_VR | 15)

    V16 ¶
    Source

    V16 :: Register(REG_VR | 16)

    V17 ¶
    Source

    V17 :: Register(REG_VR | 17)

    V18 ¶
    Source

    V18 :: Register(REG_VR | 18)

    V19 ¶
    Source

    V19 :: Register(REG_VR | 19)

    V2 ¶
    Source

    V2 :: Register(REG_VR | 2)

    V20 ¶
    Source

    V20 :: Register(REG_VR | 20)

    V21 ¶
    Source

    V21 :: Register(REG_VR | 21)

    V22 ¶
    Source

    V22 :: Register(REG_VR | 22)

    V23 ¶
    Source

    V23 :: Register(REG_VR | 23)

    V24 ¶
    Source

    V24 :: Register(REG_VR | 24)

    V25 ¶
    Source

    V25 :: Register(REG_VR | 25)

    V26 ¶
    Source

    V26 :: Register(REG_VR | 26)

    V27 ¶
    Source

    V27 :: Register(REG_VR | 27)

    V28 ¶
    Source

    V28 :: Register(REG_VR | 28)

    V29 ¶
    Source

    V29 :: Register(REG_VR | 29)

    V3 ¶
    Source

    V3 :: Register(REG_VR | 3)

    V30 ¶
    Source

    V30 :: Register(REG_VR | 30)

    V31 ¶
    Source

    V31 :: Register(REG_VR | 31)

    V4 ¶
    Source

    V4 :: Register(REG_VR | 4)

    V5 ¶
    Source

    V5 :: Register(REG_VR | 5)

    V6 ¶
    Source

    V6 :: Register(REG_VR | 6)

    V7 ¶
    Source

    V7 :: Register(REG_VR | 7)

    V8 ¶
    Source

    V8 :: Register(REG_VR | 8)

    V9 ¶
    Source

    V9 :: Register(REG_VR | 9)

    VRSAVE ¶
    Source

    VRSAVE :: Register(REG_SPR | 256)

    XER ¶
    Source

    XER :: Register(REG_SPR | 1)

    Variables

    DECODE_BUCKET_LIST ¶
    Source

    @(rodata)
DECODE_BUCKET_LIST: []u16 = …

    DECODE_ENTRIES ¶
    Source

    @(rodata)
DECODE_ENTRIES: []Decode_Entry = …

    DECODE_FORM_IDX ¶
    Source

    @(rodata)
DECODE_FORM_IDX: []u16 = …

    DECODE_INDEX_PRIMARY ¶
    Source

    @(rodata)
DECODE_INDEX_PRIMARY: []Decode_Index = …

    DECODE_INDEX_SUB ¶
    Source

    @(rodata)
DECODE_INDEX_SUB: []Decode_Index = …

    ENCODE_FORMS ¶
    Source

    @(rodata)
ENCODE_FORMS: []Encoding = …

    ENCODE_RUNS ¶
    Source

    @(rodata)
ENCODE_RUNS: []Encode_Run = …

    PREFIX_BITS_TABLE ¶
    Source

    @(rodata)
PREFIX_BITS_TABLE: []u32 = …

    Procedures

    aprint ¶
    Source

    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 ¶
    Source

    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 ¶
    Source

    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 ¶
    Source

    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 ¶
    Source

    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 = .PPC32, 
) -> (byte_count: u32, ok: bool) {…}

    decode_estimate_instruction_count ¶
    Source

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

    Typical-case estimate of the instruction count for data.

    decode_max_instruction_count ¶
    Source

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

    Instruction-count ceiling for data (PowerPC instructions are 4 bytes (prefixed 8); minimum 4).

    decode_reserve ¶
    Source

    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).

    emit_a_dot ¶
    Source

    emit_a_dot :: emit_a_dot_r_r_r

    emit_a_dot_r_r_r ¶
    Source

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

    emit_abs ¶
    Source

    emit_abs :: emit_abs_r_r_r

    emit_abs_dot ¶
    Source

    emit_abs_dot :: emit_abs_dot_r_r_r

    emit_abs_dot_r_r_r ¶
    Source

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

    emit_abs_r_r_r ¶
    Source

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

    emit_abso ¶
    Source

    emit_abso :: emit_abso_r_r_r

    emit_abso_dot ¶
    Source

    emit_abso_dot :: emit_abso_dot_r_r_r

    emit_abso_dot_r_r_r ¶
    Source

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

    emit_abso_r_r_r ¶
    Source

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

    emit_add ¶
    Source

    emit_add :: emit_add_r_r_r

    emit_add_dot ¶
    Source

    emit_add_dot :: emit_add_dot_r_r_r

    emit_add_dot_r_r_r ¶
    Source

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

    emit_add_o ¶
    Source

    emit_add_o :: emit_add_o_r_r_r

    emit_add_o_dot ¶
    Source

    emit_add_o_dot :: emit_add_o_dot_r_r_r

    emit_add_o_dot_r_r_r ¶
    Source

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

    emit_add_o_r_r_r ¶
    Source

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

    emit_add_r_r_r ¶
    Source

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

    emit_addc ¶
    Source

    emit_addc :: emit_addc_r_r_r

    emit_addc_dot ¶
    Source

    emit_addc_dot :: emit_addc_dot_r_r_r

    emit_addc_dot_r_r_r ¶
    Source

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

    emit_addc_o ¶
    Source

    emit_addc_o :: emit_addc_o_r_r_r

    emit_addc_o_dot ¶
    Source

    emit_addc_o_dot :: emit_addc_o_dot_r_r_r

    emit_addc_o_dot_r_r_r ¶
    Source

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

    emit_addc_o_r_r_r ¶
    Source

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

    emit_addc_r_r_r ¶
    Source

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

    emit_addco ¶
    Source

    emit_addco :: emit_addco_r_r_r

    emit_addco_dot ¶
    Source

    emit_addco_dot :: emit_addco_dot_r_r_r

    emit_addco_dot_r_r_r ¶
    Source

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

    emit_addco_r_r_r ¶
    Source

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

    emit_adde ¶
    Source

    emit_adde :: emit_adde_r_r_r

    emit_adde_dot ¶
    Source

    emit_adde_dot :: emit_adde_dot_r_r_r

    emit_adde_dot_r_r_r ¶
    Source

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

    emit_adde_o ¶
    Source

    emit_adde_o :: emit_adde_o_r_r_r

    emit_adde_o_dot ¶
    Source

    emit_adde_o_dot :: emit_adde_o_dot_r_r_r

    emit_adde_o_dot_r_r_r ¶
    Source

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

    emit_adde_o_r_r_r ¶
    Source

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

    emit_adde_r_r_r ¶
    Source

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

    emit_addeo ¶
    Source

    emit_addeo :: emit_addeo_r_r_r

    emit_addeo_dot ¶
    Source

    emit_addeo_dot :: emit_addeo_dot_r_r_r

    emit_addeo_dot_r_r_r ¶
    Source

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

    emit_addeo_r_r_r ¶
    Source

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

    emit_addex ¶
    Source

    emit_addex :: emit_addex_r_r_r

    emit_addex_r_r_r ¶
    Source

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

    emit_addg6s ¶
    Source

    emit_addg6s :: emit_addg6s_r_r_r

    emit_addg6s_r_r_r ¶
    Source

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

    emit_addi ¶
    Source

    emit_addi :: emit_addi_r_rz_simm

    emit_addi_r_rz_simm ¶
    Source

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

    emit_addic ¶
    Source

    emit_addic :: emit_addic_r_r_simm

    emit_addic_dot ¶
    Source

    emit_addic_dot :: emit_addic_dot_r_r_simm

    emit_addic_dot_r_r_simm ¶
    Source

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

    emit_addic_r_r_simm ¶
    Source

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

    emit_addis ¶
    Source

    emit_addis :: emit_addis_r_rz_simm

    emit_addis_r_rz_simm ¶
    Source

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

    emit_addme ¶
    Source

    emit_addme :: emit_addme_r_r

    emit_addme_dot ¶
    Source

    emit_addme_dot :: emit_addme_dot_r_r

    emit_addme_dot_r_r ¶
    Source

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

    emit_addme_o ¶
    Source

    emit_addme_o :: emit_addme_o_r_r

    emit_addme_o_dot ¶
    Source

    emit_addme_o_dot :: emit_addme_o_dot_r_r

    emit_addme_o_dot_r_r ¶
    Source

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

    emit_addme_o_r_r ¶
    Source

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

    emit_addme_r_r ¶
    Source

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

    emit_addmeo ¶
    Source

    emit_addmeo :: emit_addmeo_r_r_r

    emit_addmeo_dot ¶
    Source

    emit_addmeo_dot :: emit_addmeo_dot_r_r_r

    emit_addmeo_dot_r_r_r ¶
    Source

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

    emit_addmeo_r_r_r ¶
    Source

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

    emit_addo ¶
    Source

    emit_addo :: emit_addo_r_r_r

    emit_addo_dot ¶
    Source

    emit_addo_dot :: emit_addo_dot_r_r_r

    emit_addo_dot_r_r_r ¶
    Source

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

    emit_addo_r_r_r ¶
    Source

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

    emit_addpcis ¶
    Source

    emit_addpcis :: emit_addpcis_r_simm

    emit_addpcis_r_simm ¶
    Source

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

    emit_addze ¶
    Source

    emit_addze :: emit_addze_r_r

    emit_addze_dot ¶
    Source

    emit_addze_dot :: emit_addze_dot_r_r

    emit_addze_dot_r_r ¶
    Source

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

    emit_addze_o ¶
    Source

    emit_addze_o :: emit_addze_o_r_r

    emit_addze_o_dot ¶
    Source

    emit_addze_o_dot :: emit_addze_o_dot_r_r

    emit_addze_o_dot_r_r ¶
    Source

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

    emit_addze_o_r_r ¶
    Source

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

    emit_addze_r_r ¶
    Source

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

    emit_addzeo ¶
    Source

    emit_addzeo :: emit_addzeo_r_r_r

    emit_addzeo_dot ¶
    Source

    emit_addzeo_dot :: emit_addzeo_dot_r_r_r

    emit_addzeo_dot_r_r_r ¶
    Source

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

    emit_addzeo_r_r_r ¶
    Source

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

    emit_ae ¶
    Source

    emit_ae :: emit_ae_r_r_r

    emit_ae_dot ¶
    Source

    emit_ae_dot :: emit_ae_dot_r_r_r

    emit_ae_dot_r_r_r ¶
    Source

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

    emit_ae_r_r_r ¶
    Source

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

    emit_aeo ¶
    Source

    emit_aeo :: emit_aeo_r_r_r

    emit_aeo_dot ¶
    Source

    emit_aeo_dot :: emit_aeo_dot_r_r_r

    emit_aeo_dot_r_r_r ¶
    Source

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

    emit_aeo_r_r_r ¶
    Source

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

    emit_ai ¶
    Source

    emit_ai :: emit_ai_r_r_imm

    emit_ai_dot ¶
    Source

    emit_ai_dot :: emit_ai_dot_r_r_imm

    emit_ai_dot_r_r_imm ¶
    Source

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

    emit_ai_r_r_imm ¶
    Source

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

    emit_ame ¶
    Source

    emit_ame :: emit_ame_r_r_r

    emit_ame_dot ¶
    Source

    emit_ame_dot :: emit_ame_dot_r_r_r

    emit_ame_dot_r_r_r ¶
    Source

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

    emit_ame_r_r_r ¶
    Source

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

    emit_ameo ¶
    Source

    emit_ameo :: emit_ameo_r_r_r

    emit_ameo_dot ¶
    Source

    emit_ameo_dot :: emit_ameo_dot_r_r_r

    emit_ameo_dot_r_r_r ¶
    Source

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

    emit_ameo_r_r_r ¶
    Source

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

    emit_and ¶
    Source

    emit_and :: emit_and_r_r_r

    emit_and_dot ¶
    Source

    emit_and_dot :: emit_and_dot_r_r_r

    emit_and_dot_r_r_r ¶
    Source

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

    emit_and_r_r_r ¶
    Source

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

    emit_andc ¶
    Source

    emit_andc :: emit_andc_r_r_r

    emit_andc_dot ¶
    Source

    emit_andc_dot :: emit_andc_dot_r_r_r

    emit_andc_dot_r_r_r ¶
    Source

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

    emit_andc_r_r_r ¶
    Source

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

    emit_andi_dot ¶
    Source

    emit_andi_dot :: emit_andi_dot_r_r_uimm

    emit_andi_dot_r_r_uimm ¶
    Source

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

    emit_andil_dot ¶
    Source

    emit_andil_dot :: emit_andil_dot_r_r_imm

    emit_andil_dot_r_r_imm ¶
    Source

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

    emit_andis_dot ¶
    Source

    emit_andis_dot :: emit_andis_dot_r_r_uimm

    emit_andis_dot_r_r_uimm ¶
    Source

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

    emit_andiu_dot ¶
    Source

    emit_andiu_dot :: emit_andiu_dot_r_r_imm

    emit_andiu_dot_r_r_imm ¶
    Source

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

    emit_ao ¶
    Source

    emit_ao :: emit_ao_r_r_r

    emit_ao_dot ¶
    Source

    emit_ao_dot :: emit_ao_dot_r_r_r

    emit_ao_dot_r_r_r ¶
    Source

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

    emit_ao_r_r_r ¶
    Source

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

    emit_attn ¶
    Source

    emit_attn :: emit_attn_none

    emit_attn_none ¶
    Source

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

    emit_aze ¶
    Source

    emit_aze :: emit_aze_r_r_r

    emit_aze_dot ¶
    Source

    emit_aze_dot :: emit_aze_dot_r_r_r

    emit_aze_dot_r_r_r ¶
    Source

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

    emit_aze_r_r_r ¶
    Source

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

    emit_azeo ¶
    Source

    emit_azeo :: emit_azeo_r_r_r

    emit_azeo_dot ¶
    Source

    emit_azeo_dot :: emit_azeo_dot_r_r_r

    emit_azeo_dot_r_r_r ¶
    Source

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

    emit_azeo_r_r_r ¶
    Source

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

    emit_b ¶
    Source

    emit_b :: emit_b_rel

    emit_b_rel ¶
    Source

    emit_b_rel :: proc(instructions: ^[dynamic]Instruction, label: u32) {…}

    emit_ba ¶
    Source

    emit_ba :: emit_ba_rel

    emit_ba_rel ¶
    Source

    emit_ba_rel :: proc(instructions: ^[dynamic]Instruction, label: u32) {…}

    emit_bbelr ¶
    Source

    emit_bbelr :: emit_bbelr_r_r_r

    emit_bbelr_r_r_r ¶
    Source

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

    emit_bblels ¶
    Source

    emit_bblels :: emit_bblels_r_r_r

    emit_bblels_r_r_r ¶
    Source

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

    emit_bc ¶
    Source

    emit_bc :: emit_bc_bo_crb_rel

    emit_bc_bo_crb_rel ¶
    Source

    emit_bc_bo_crb_rel :: proc(instructions: ^[dynamic]Instruction, bo: i64, dst: Register, label: u32) {…}

    emit_bca ¶
    Source

    emit_bca :: emit_bca_bo_crb_rel

    emit_bca_bo_crb_rel ¶
    Source

    emit_bca_bo_crb_rel :: proc(instructions: ^[dynamic]Instruction, bo: i64, dst: Register, label: u32) {…}

    emit_bcctr ¶
    Source

    emit_bcctr :: emit_bcctr_bo_crb_bh

    emit_bcctr_bo_crb_bh ¶
    Source

    emit_bcctr_bo_crb_bh :: proc(instructions: ^[dynamic]Instruction, bo: i64, dst: Register, bh: i64) {…}

    emit_bcctrl ¶
    Source

    emit_bcctrl :: emit_bcctrl_bo_crb_bh

    emit_bcctrl_bo_crb_bh ¶
    Source

    emit_bcctrl_bo_crb_bh :: proc(instructions: ^[dynamic]Instruction, bo: i64, dst: Register, bh: i64) {…}

    emit_bcdadd_dot ¶
    Source

    emit_bcdadd_dot :: emit_bcdadd_dot_v_v_v_imm

    emit_bcdadd_dot_v_v_v_imm ¶
    Source

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

    emit_bcdcfn_dot ¶
    Source

    emit_bcdcfn_dot :: emit_bcdcfn_dot_v_v_imm

    emit_bcdcfn_dot_v_v_imm ¶
    Source

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

    emit_bcdcfsq_dot ¶
    Source

    emit_bcdcfsq_dot :: emit_bcdcfsq_dot_v_v_imm

    emit_bcdcfsq_dot_v_v_imm ¶
    Source

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

    emit_bcdcfz_dot ¶
    Source

    emit_bcdcfz_dot :: emit_bcdcfz_dot_v_v_imm

    emit_bcdcfz_dot_v_v_imm ¶
    Source

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

    emit_bcdcpsgn_dot ¶
    Source

    emit_bcdcpsgn_dot :: emit_bcdcpsgn_dot_v_v_v

    emit_bcdcpsgn_dot_v_v_v ¶
    Source

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

    emit_bcdctn_dot ¶
    Source

    emit_bcdctn_dot :: emit_bcdctn_dot_v_v

    emit_bcdctn_dot_v_v ¶
    Source

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

    emit_bcdctsq_dot ¶
    Source

    emit_bcdctsq_dot :: emit_bcdctsq_dot_v_v

    emit_bcdctsq_dot_v_v ¶
    Source

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

    emit_bcdctz_dot ¶
    Source

    emit_bcdctz_dot :: emit_bcdctz_dot_v_v_imm

    emit_bcdctz_dot_v_v_imm ¶
    Source

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

    emit_bcds_dot ¶
    Source

    emit_bcds_dot :: emit_bcds_dot_v_v_v_imm

    emit_bcds_dot_v_v_v_imm ¶
    Source

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

    emit_bcdsr_dot ¶
    Source

    emit_bcdsr_dot :: emit_bcdsr_dot_v_v_v_imm

    emit_bcdsr_dot_v_v_v_imm ¶
    Source

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

    emit_bcdsub_dot ¶
    Source

    emit_bcdsub_dot :: emit_bcdsub_dot_v_v_v_imm

    emit_bcdsub_dot_v_v_v_imm ¶
    Source

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

    emit_bcdtrunc_dot ¶
    Source

    emit_bcdtrunc_dot :: emit_bcdtrunc_dot_v_v_v_imm

    emit_bcdtrunc_dot_v_v_v_imm ¶
    Source

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

    emit_bcdus_dot ¶
    Source

    emit_bcdus_dot :: emit_bcdus_dot_v_v_v

    emit_bcdus_dot_v_v_v ¶
    Source

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

    emit_bcdutrunc_dot ¶
    Source

    emit_bcdutrunc_dot :: emit_bcdutrunc_dot_v_v_v

    emit_bcdutrunc_dot_v_v_v ¶
    Source

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

    emit_bcl ¶
    Source

    emit_bcl :: emit_bcl_bo_crb_rel

    emit_bcl_bo_crb_rel ¶
    Source

    emit_bcl_bo_crb_rel :: proc(instructions: ^[dynamic]Instruction, bo: i64, dst: Register, label: u32) {…}

    emit_bcla ¶
    Source

    emit_bcla :: emit_bcla_bo_crb_rel

    emit_bcla_bo_crb_rel ¶
    Source

    emit_bcla_bo_crb_rel :: proc(instructions: ^[dynamic]Instruction, bo: i64, dst: Register, label: u32) {…}

    emit_bclr ¶
    Source

    emit_bclr :: emit_bclr_bo_crb_bh

    emit_bclr_bo_crb_bh ¶
    Source

    emit_bclr_bo_crb_bh :: proc(instructions: ^[dynamic]Instruction, bo: i64, dst: Register, bh: i64) {…}

    emit_bclrl ¶
    Source

    emit_bclrl :: emit_bclrl_bo_crb_bh

    emit_bclrl_bo_crb_bh ¶
    Source

    emit_bclrl_bo_crb_bh :: proc(instructions: ^[dynamic]Instruction, bo: i64, dst: Register, bh: i64) {…}

    emit_bctar ¶
    Source

    emit_bctar :: emit_bctar_bo_crb_bh

    emit_bctar_bo_crb_bh ¶
    Source

    emit_bctar_bo_crb_bh :: proc(instructions: ^[dynamic]Instruction, bo: i64, dst: Register, bh: i64) {…}

    emit_bctarl ¶
    Source

    emit_bctarl :: emit_bctarl_bo_crb_bh

    emit_bctarl_bo_crb_bh ¶
    Source

    emit_bctarl_bo_crb_bh :: proc(instructions: ^[dynamic]Instruction, bo: i64, dst: Register, bh: i64) {…}

    emit_bctr ¶
    Source

    emit_bctr :: emit_bctr_none

    emit_bctr_none ¶
    Source

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

    emit_bctrl ¶
    Source

    emit_bctrl :: emit_bctrl_none

    emit_bctrl_none ¶
    Source

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

    emit_bdnz ¶
    Source

    emit_bdnz :: emit_bdnz_rel

    emit_bdnz_rel ¶
    Source

    emit_bdnz_rel :: proc(instructions: ^[dynamic]Instruction, label: u32) {…}

    emit_bdnzf ¶
    Source

    emit_bdnzf :: emit_bdnzf_crb_rel

    emit_bdnzf_crb_rel ¶
    Source

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

    emit_bdnzfl ¶
    Source

    emit_bdnzfl :: emit_bdnzfl_crb_rel

    emit_bdnzfl_crb_rel ¶
    Source

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

    emit_bdnzflr ¶
    Source

    emit_bdnzflr :: emit_bdnzflr_crb

    emit_bdnzflr_crb ¶
    Source

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

    emit_bdnzflrl ¶
    Source

    emit_bdnzflrl :: emit_bdnzflrl_crb

    emit_bdnzflrl_crb ¶
    Source

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

    emit_bdnzl ¶
    Source

    emit_bdnzl :: emit_bdnzl_rel

    emit_bdnzl_rel ¶
    Source

    emit_bdnzl_rel :: proc(instructions: ^[dynamic]Instruction, label: u32) {…}

    emit_bdnzlr ¶
    Source

    emit_bdnzlr :: emit_bdnzlr_none

    emit_bdnzlr_none ¶
    Source

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

    emit_bdnzlrl ¶
    Source

    emit_bdnzlrl :: emit_bdnzlrl_none

    emit_bdnzlrl_none ¶
    Source

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

    emit_bdnzt ¶
    Source

    emit_bdnzt :: emit_bdnzt_crb_rel

    emit_bdnzt_crb_rel ¶
    Source

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

    emit_bdnztl ¶
    Source

    emit_bdnztl :: emit_bdnztl_crb_rel

    emit_bdnztl_crb_rel ¶
    Source

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

    emit_bdnztlr ¶
    Source

    emit_bdnztlr :: emit_bdnztlr_crb

    emit_bdnztlr_crb ¶
    Source

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

    emit_bdnztlrl ¶
    Source

    emit_bdnztlrl :: emit_bdnztlrl_crb

    emit_bdnztlrl_crb ¶
    Source

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

    emit_bdz ¶
    Source

    emit_bdz :: emit_bdz_rel

    emit_bdz_rel ¶
    Source

    emit_bdz_rel :: proc(instructions: ^[dynamic]Instruction, label: u32) {…}

    emit_bdzf ¶
    Source

    emit_bdzf :: emit_bdzf_crb_rel

    emit_bdzf_crb_rel ¶
    Source

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

    emit_bdzfl ¶
    Source

    emit_bdzfl :: emit_bdzfl_crb_rel

    emit_bdzfl_crb_rel ¶
    Source

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

    emit_bdzflr ¶
    Source

    emit_bdzflr :: emit_bdzflr_crb

    emit_bdzflr_crb ¶
    Source

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

    emit_bdzflrl ¶
    Source

    emit_bdzflrl :: emit_bdzflrl_crb

    emit_bdzflrl_crb ¶
    Source

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

    emit_bdzl ¶
    Source

    emit_bdzl :: emit_bdzl_rel

    emit_bdzl_rel ¶
    Source

    emit_bdzl_rel :: proc(instructions: ^[dynamic]Instruction, label: u32) {…}

    emit_bdzlr ¶
    Source

    emit_bdzlr :: emit_bdzlr_none

    emit_bdzlr_none ¶
    Source

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

    emit_bdzlrl ¶
    Source

    emit_bdzlrl :: emit_bdzlrl_none

    emit_bdzlrl_none ¶
    Source

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

    emit_bdzt ¶
    Source

    emit_bdzt :: emit_bdzt_crb_rel

    emit_bdzt_crb_rel ¶
    Source

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

    emit_bdztl ¶
    Source

    emit_bdztl :: emit_bdztl_crb_rel

    emit_bdztl_crb_rel ¶
    Source

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

    emit_bdztlr ¶
    Source

    emit_bdztlr :: emit_bdztlr_crb

    emit_bdztlr_crb ¶
    Source

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

    emit_bdztlrl ¶
    Source

    emit_bdztlrl :: emit_bdztlrl_crb

    emit_bdztlrl_crb ¶
    Source

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

    emit_beq ¶
    Source

    emit_beq :: emit_beq_rel

    emit_beq_rel ¶
    Source

    emit_beq_rel :: proc(instructions: ^[dynamic]Instruction, label: u32) {…}

    emit_beqctr ¶
    Source

    emit_beqctr :: emit_beqctr_none

    emit_beqctr_none ¶
    Source

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

    emit_beql ¶
    Source

    emit_beql :: emit_beql_rel

    emit_beql_rel ¶
    Source

    emit_beql_rel :: proc(instructions: ^[dynamic]Instruction, label: u32) {…}

    emit_beqlr ¶
    Source

    emit_beqlr :: emit_beqlr_none

    emit_beqlr_none ¶
    Source

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

    emit_bge ¶
    Source

    emit_bge :: emit_bge_rel

    emit_bge_rel ¶
    Source

    emit_bge_rel :: proc(instructions: ^[dynamic]Instruction, label: u32) {…}

    emit_bgectr ¶
    Source

    emit_bgectr :: emit_bgectr_none

    emit_bgectr_none ¶
    Source

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

    emit_bgel ¶
    Source

    emit_bgel :: emit_bgel_rel

    emit_bgel_rel ¶
    Source

    emit_bgel_rel :: proc(instructions: ^[dynamic]Instruction, label: u32) {…}

    emit_bgelr ¶
    Source

    emit_bgelr :: emit_bgelr_none

    emit_bgelr_none ¶
    Source

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

    emit_bgt ¶
    Source

    emit_bgt :: emit_bgt_rel

    emit_bgt_rel ¶
    Source

    emit_bgt_rel :: proc(instructions: ^[dynamic]Instruction, label: u32) {…}

    emit_bgtctr ¶
    Source

    emit_bgtctr :: emit_bgtctr_none

    emit_bgtctr_none ¶
    Source

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

    emit_bgtl ¶
    Source

    emit_bgtl :: emit_bgtl_rel

    emit_bgtl_rel ¶
    Source

    emit_bgtl_rel :: proc(instructions: ^[dynamic]Instruction, label: u32) {…}

    emit_bgtlr ¶
    Source

    emit_bgtlr :: emit_bgtlr_none

    emit_bgtlr_none ¶
    Source

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

    emit_bl ¶
    Source

    emit_bl :: emit_bl_rel

    emit_bl_rel ¶
    Source

    emit_bl_rel :: proc(instructions: ^[dynamic]Instruction, label: u32) {…}

    emit_bla ¶
    Source

    emit_bla :: emit_bla_rel

    emit_bla_rel ¶
    Source

    emit_bla_rel :: proc(instructions: ^[dynamic]Instruction, label: u32) {…}

    emit_ble ¶
    Source

    emit_ble :: emit_ble_rel

    emit_ble_rel ¶
    Source

    emit_ble_rel :: proc(instructions: ^[dynamic]Instruction, label: u32) {…}

    emit_blectr ¶
    Source

    emit_blectr :: emit_blectr_none

    emit_blectr_none ¶
    Source

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

    emit_blel ¶
    Source

    emit_blel :: emit_blel_rel

    emit_blel_rel ¶
    Source

    emit_blel_rel :: proc(instructions: ^[dynamic]Instruction, label: u32) {…}

    emit_blelr ¶
    Source

    emit_blelr :: emit_blelr_none

    emit_blelr_none ¶
    Source

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

    emit_blr ¶
    Source

    emit_blr :: emit_blr_none

    emit_blr_none ¶
    Source

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

    emit_blrl ¶
    Source

    emit_blrl :: emit_blrl_none

    emit_blrl_none ¶
    Source

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

    emit_blt ¶
    Source

    emit_blt :: emit_blt_rel

    emit_blt_rel ¶
    Source

    emit_blt_rel :: proc(instructions: ^[dynamic]Instruction, label: u32) {…}

    emit_bltctr ¶
    Source

    emit_bltctr :: emit_bltctr_none

    emit_bltctr_none ¶
    Source

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

    emit_bltl ¶
    Source

    emit_bltl :: emit_bltl_rel

    emit_bltl_rel ¶
    Source

    emit_bltl_rel :: proc(instructions: ^[dynamic]Instruction, label: u32) {…}

    emit_bltlr ¶
    Source

    emit_bltlr :: emit_bltlr_none

    emit_bltlr_none ¶
    Source

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

    emit_bne ¶
    Source

    emit_bne :: emit_bne_rel

    emit_bne_rel ¶
    Source

    emit_bne_rel :: proc(instructions: ^[dynamic]Instruction, label: u32) {…}

    emit_bnectr ¶
    Source

    emit_bnectr :: emit_bnectr_none

    emit_bnectr_none ¶
    Source

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

    emit_bnel ¶
    Source

    emit_bnel :: emit_bnel_rel

    emit_bnel_rel ¶
    Source

    emit_bnel_rel :: proc(instructions: ^[dynamic]Instruction, label: u32) {…}

    emit_bnelr ¶
    Source

    emit_bnelr :: emit_bnelr_none

    emit_bnelr_none ¶
    Source

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

    emit_bns ¶
    Source

    emit_bns :: emit_bns_rel

    emit_bns_rel ¶
    Source

    emit_bns_rel :: proc(instructions: ^[dynamic]Instruction, label: u32) {…}

    emit_bnsctr ¶
    Source

    emit_bnsctr :: emit_bnsctr_none

    emit_bnsctr_none ¶
    Source

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

    emit_bnsl ¶
    Source

    emit_bnsl :: emit_bnsl_rel

    emit_bnsl_rel ¶
    Source

    emit_bnsl_rel :: proc(instructions: ^[dynamic]Instruction, label: u32) {…}

    emit_bnslr ¶
    Source

    emit_bnslr :: emit_bnslr_none

    emit_bnslr_none ¶
    Source

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

    emit_bpermd ¶
    Source

    emit_bpermd :: emit_bpermd_r_r_r

    emit_bpermd_r_r_r ¶
    Source

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

    emit_brd ¶
    Source

    emit_brd :: emit_brd_r_r

    emit_brd_r_r ¶
    Source

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

    emit_brh ¶
    Source

    emit_brh :: emit_brh_r_r

    emit_brh_r_r ¶
    Source

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

    emit_brinc ¶
    Source

    emit_brinc :: emit_brinc_r_r_r

    emit_brinc_r_r_r ¶
    Source

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

    emit_brw ¶
    Source

    emit_brw :: emit_brw_r_r

    emit_brw_r_r ¶
    Source

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

    emit_bso ¶
    Source

    emit_bso :: emit_bso_rel

    emit_bso_rel ¶
    Source

    emit_bso_rel :: proc(instructions: ^[dynamic]Instruction, label: u32) {…}

    emit_bsoctr ¶
    Source

    emit_bsoctr :: emit_bsoctr_none

    emit_bsoctr_none ¶
    Source

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

    emit_bsol ¶
    Source

    emit_bsol :: emit_bsol_rel

    emit_bsol_rel ¶
    Source

    emit_bsol_rel :: proc(instructions: ^[dynamic]Instruction, label: u32) {…}

    emit_bsolr ¶
    Source

    emit_bsolr :: emit_bsolr_none

    emit_bsolr_none ¶
    Source

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

    emit_cal ¶
    Source

    emit_cal :: emit_cal_r_r_imm

    emit_cal_r_r_imm ¶
    Source

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

    emit_cau ¶
    Source

    emit_cau :: emit_cau_r_r_imm

    emit_cau_r_r_imm ¶
    Source

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

    emit_cax ¶
    Source

    emit_cax :: emit_cax_r_r_r

    emit_cax_dot ¶
    Source

    emit_cax_dot :: emit_cax_dot_r_r_r

    emit_cax_dot_r_r_r ¶
    Source

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

    emit_cax_r_r_r ¶
    Source

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

    emit_caxo ¶
    Source

    emit_caxo :: emit_caxo_r_r_r

    emit_caxo_dot ¶
    Source

    emit_caxo_dot :: emit_caxo_dot_r_r_r

    emit_caxo_dot_r_r_r ¶
    Source

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

    emit_caxo_r_r_r ¶
    Source

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

    emit_cbcdtd ¶
    Source

    emit_cbcdtd :: emit_cbcdtd_r_r

    emit_cbcdtd_r_r ¶
    Source

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

    emit_cdtbcd ¶
    Source

    emit_cdtbcd :: emit_cdtbcd_r_r

    emit_cdtbcd_r_r ¶
    Source

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

    emit_cfuged ¶
    Source

    emit_cfuged :: emit_cfuged_r_r_r

    emit_cfuged_r_r_r ¶
    Source

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

    emit_circinc ¶
    Source

    emit_circinc :: emit_circinc_r_r_r

    emit_circinc_r_r_r ¶
    Source

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

    emit_clcs ¶
    Source

    emit_clcs :: emit_clcs_r_r_r

    emit_clcs_r_r_r ¶
    Source

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

    emit_clf ¶
    Source

    emit_clf :: emit_clf_r_r_r

    emit_clf_r_r_r ¶
    Source

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

    emit_cli ¶
    Source

    emit_cli :: emit_cli_r_r_r

    emit_cli_r_r_r ¶
    Source

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

    emit_clrbhrb ¶
    Source

    emit_clrbhrb :: emit_clrbhrb_r_r_r

    emit_clrbhrb_r_r_r ¶
    Source

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

    emit_clrldi ¶
    Source

    emit_clrldi :: emit_clrldi_r_r_imm

    emit_clrldi_dot ¶
    Source

    emit_clrldi_dot :: emit_clrldi_dot_r_r_r

    emit_clrldi_dot_r_r_r ¶
    Source

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

    emit_clrldi_r_r_imm ¶
    Source

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

    emit_clrlsldi ¶
    Source

    emit_clrlsldi :: emit_clrlsldi_r_r_r

    emit_clrlsldi_dot ¶
    Source

    emit_clrlsldi_dot :: emit_clrlsldi_dot_r_r_r

    emit_clrlsldi_dot_r_r_r ¶
    Source

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

    emit_clrlsldi_r_r_r ¶
    Source

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

    emit_clrlwi ¶
    Source

    emit_clrlwi :: emit_clrlwi_r_r_imm

    emit_clrlwi_r_r_imm ¶
    Source

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

    emit_clrrdi ¶
    Source

    emit_clrrdi :: emit_clrrdi_r_r_imm

    emit_clrrdi_dot ¶
    Source

    emit_clrrdi_dot :: emit_clrrdi_dot_r_r_r

    emit_clrrdi_dot_r_r_r ¶
    Source

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

    emit_clrrdi_r_r_imm ¶
    Source

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

    emit_clrrwi ¶
    Source

    emit_clrrwi :: emit_clrrwi_r_r_imm

    emit_clrrwi_r_r_imm ¶
    Source

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

    emit_cmp ¶
    Source

    emit_cmp :: emit_cmp_crf_imm_r_r

    emit_cmp_crf_imm_r_r ¶
    Source

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

    emit_cmpb ¶
    Source

    emit_cmpb :: emit_cmpb_r_r_r

    emit_cmpb_r_r_r ¶
    Source

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

    emit_cmpd ¶
    Source

    emit_cmpd :: emit_cmpd_crf_r_r

    emit_cmpd_crf_r_r ¶
    Source

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

    emit_cmpdi ¶
    Source

    emit_cmpdi :: emit_cmpdi_crf_r_simm

    emit_cmpdi_crf_r_simm ¶
    Source

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

    emit_cmpeqb ¶
    Source

    emit_cmpeqb :: emit_cmpeqb_crf_r_r

    emit_cmpeqb_crf_r_r ¶
    Source

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

    emit_cmpi ¶
    Source

    emit_cmpi_crf_imm_r_simm ¶
    Source

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

    emit_cmpl ¶
    Source

    emit_cmpl :: emit_cmpl_crf_imm_r_r

    emit_cmpl_crf_imm_r_r ¶
    Source

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

    emit_cmpld ¶
    Source

    emit_cmpld :: emit_cmpld_crf_r_r

    emit_cmpld_crf_r_r ¶
    Source

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

    emit_cmpldi ¶
    Source

    emit_cmpldi :: emit_cmpldi_crf_r_uimm

    emit_cmpldi_crf_r_uimm ¶
    Source

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

    emit_cmpli ¶
    Source

    emit_cmpli_crf_imm_r_uimm ¶
    Source

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

    emit_cmplw ¶
    Source

    emit_cmplw :: emit_cmplw_crf_r_r

    emit_cmplw_crf_r_r ¶
    Source

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

    emit_cmplwi ¶
    Source

    emit_cmplwi :: emit_cmplwi_crf_r_uimm

    emit_cmplwi_crf_r_uimm ¶
    Source

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

    emit_cmprb ¶
    Source

    emit_cmprb :: emit_cmprb_crf_imm_r_r

    emit_cmprb_crf_imm_r_r ¶
    Source

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

    emit_cmpw ¶
    Source

    emit_cmpw :: emit_cmpw_crf_r_r

    emit_cmpw_crf_r_r ¶
    Source

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

    emit_cmpwi ¶
    Source

    emit_cmpwi :: emit_cmpwi_crf_r_simm

    emit_cmpwi_crf_r_simm ¶
    Source

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

    emit_cntlz ¶
    Source

    emit_cntlz :: emit_cntlz_r_r_r

    emit_cntlz_dot ¶
    Source

    emit_cntlz_dot :: emit_cntlz_dot_r_r_r

    emit_cntlz_dot_r_r_r ¶
    Source

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

    emit_cntlz_r_r_r ¶
    Source

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

    emit_cntlzd ¶
    Source

    emit_cntlzd :: emit_cntlzd_r_r

    emit_cntlzd_dot ¶
    Source

    emit_cntlzd_dot :: emit_cntlzd_dot_r_r

    emit_cntlzd_dot_r_r ¶
    Source

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

    emit_cntlzd_r_r ¶
    Source

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

    emit_cntlzdm ¶
    Source

    emit_cntlzdm :: emit_cntlzdm_r_r_r

    emit_cntlzdm_r_r_r ¶
    Source

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

    emit_cntlzw ¶
    Source

    emit_cntlzw :: emit_cntlzw_r_r

    emit_cntlzw_dot ¶
    Source

    emit_cntlzw_dot :: emit_cntlzw_dot_r_r

    emit_cntlzw_dot_r_r ¶
    Source

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

    emit_cntlzw_r_r ¶
    Source

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

    emit_cnttzd ¶
    Source

    emit_cnttzd :: emit_cnttzd_r_r

    emit_cnttzd_dot ¶
    Source

    emit_cnttzd_dot :: emit_cnttzd_dot_r_r

    emit_cnttzd_dot_r_r ¶
    Source

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

    emit_cnttzd_r_r ¶
    Source

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

    emit_cnttzdm ¶
    Source

    emit_cnttzdm :: emit_cnttzdm_r_r_r

    emit_cnttzdm_r_r_r ¶
    Source

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

    emit_cnttzw ¶
    Source

    emit_cnttzw :: emit_cnttzw_r_r

    emit_cnttzw_dot ¶
    Source

    emit_cnttzw_dot :: emit_cnttzw_dot_r_r

    emit_cnttzw_dot_r_r ¶
    Source

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

    emit_cnttzw_r_r ¶
    Source

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

    emit_copy ¶
    Source

    emit_copy :: emit_copy_r_r

    emit_copy_r_r ¶
    Source

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

    emit_cpabort ¶
    Source

    emit_cpabort :: emit_cpabort_none

    emit_cpabort_none ¶
    Source

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

    emit_crand ¶
    Source

    emit_crand :: emit_crand_crb_crb_crb

    emit_crand_crb_crb_crb ¶
    Source

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

    emit_crandc ¶
    Source

    emit_crandc :: emit_crandc_crb_crb_crb

    emit_crandc_crb_crb_crb ¶
    Source

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

    emit_crclr ¶
    Source

    emit_crclr :: emit_crclr_r_r_imm

    emit_crclr_r_r_imm ¶
    Source

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

    emit_creqv ¶
    Source

    emit_creqv :: emit_creqv_crb_crb_crb

    emit_creqv_crb_crb_crb ¶
    Source

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

    emit_crmove ¶
    Source

    emit_crmove :: emit_crmove_r_r_imm

    emit_crmove_r_r_imm ¶
    Source

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

    emit_crnand ¶
    Source

    emit_crnand :: emit_crnand_crb_crb_crb

    emit_crnand_crb_crb_crb ¶
    Source

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

    emit_crnor ¶
    Source

    emit_crnor :: emit_crnor_crb_crb_crb

    emit_crnor_crb_crb_crb ¶
    Source

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

    emit_crnot ¶
    Source

    emit_crnot :: emit_crnot_r_r_imm

    emit_crnot_r_r_imm ¶
    Source

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

    emit_cror ¶
    Source

    emit_cror :: emit_cror_crb_crb_crb

    emit_cror_crb_crb_crb ¶
    Source

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

    emit_crorc ¶
    Source

    emit_crorc :: emit_crorc_crb_crb_crb

    emit_crorc_crb_crb_crb ¶
    Source

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

    emit_crset ¶
    Source

    emit_crset :: emit_crset_r_r_imm

    emit_crset_r_r_imm ¶
    Source

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

    emit_crxor ¶
    Source

    emit_crxor :: emit_crxor_crb_crb_crb

    emit_crxor_crb_crb_crb ¶
    Source

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

    emit_dadd ¶
    Source

    emit_dadd :: emit_dadd_fr_fr_fr

    emit_dadd_dot ¶
    Source

    emit_dadd_dot :: emit_dadd_dot_fr_fr_fr

    emit_dadd_dot_fr_fr_fr ¶
    Source

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

    emit_dadd_fr_fr_fr ¶
    Source

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

    emit_daddq ¶
    Source

    emit_daddq :: emit_daddq_fr_fr_fr

    emit_daddq_dot ¶
    Source

    emit_daddq_dot :: emit_daddq_dot_fr_fr_fr

    emit_daddq_dot_fr_fr_fr ¶
    Source

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

    emit_daddq_fr_fr_fr ¶
    Source

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

    emit_darn ¶
    Source

    emit_darn :: emit_darn_r_imm

    emit_darn_r_imm ¶
    Source

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

    emit_dcba ¶
    Source

    emit_dcba :: emit_dcba_mem

    emit_dcba_mem ¶
    Source

    emit_dcba_mem :: proc(instructions: ^[dynamic]Instruction, addr: Memory) {…}

    emit_dcbf ¶
    Source

    emit_dcbf :: emit_dcbf_mem

    emit_dcbf_mem ¶
    Source

    emit_dcbf_mem :: proc(instructions: ^[dynamic]Instruction, addr: Memory) {…}

    emit_dcbi ¶
    Source

    emit_dcbi :: emit_dcbi_r_r

    emit_dcbi_r_r ¶
    Source

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

    emit_dcblc ¶
    Source

    emit_dcblc :: emit_dcblc_r_r_r

    emit_dcblc_r_r_r ¶
    Source

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

    emit_dcblce ¶
    Source

    emit_dcblce :: emit_dcblce_r_r_r

    emit_dcblce_r_r_r ¶
    Source

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

    emit_dcblq_dot ¶
    Source

    emit_dcblq_dot :: emit_dcblq_dot_r_r_r

    emit_dcblq_dot_r_r_r ¶
    Source

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

    emit_dcbst ¶
    Source

    emit_dcbst :: emit_dcbst_r_r

    emit_dcbst_r_r ¶
    Source

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

    emit_dcbt ¶
    Source

    emit_dcbt :: emit_dcbt_mem

    emit_dcbt_mem ¶
    Source

    emit_dcbt_mem :: proc(instructions: ^[dynamic]Instruction, addr: Memory) {…}

    emit_dcbtct ¶
    Source

    emit_dcbtct :: emit_dcbtct_r_r_r

    emit_dcbtct_r_r_r ¶
    Source

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

    emit_dcbtds ¶
    Source

    emit_dcbtds :: emit_dcbtds_r_r_r

    emit_dcbtds_r_r_r ¶
    Source

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

    emit_dcbtep ¶
    Source

    emit_dcbtep :: emit_dcbtep_imm_r_r

    emit_dcbtep_imm_r_r ¶
    Source

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

    emit_dcbtls ¶
    Source

    emit_dcbtls :: emit_dcbtls_r_r_r

    emit_dcbtls_r_r_r ¶
    Source

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

    emit_dcbtlse ¶
    Source

    emit_dcbtlse :: emit_dcbtlse_r_r_r

    emit_dcbtlse_r_r_r ¶
    Source

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

    emit_dcbtst ¶
    Source

    emit_dcbtst :: emit_dcbtst_mem

    emit_dcbtst_mem ¶
    Source

    emit_dcbtst_mem :: proc(instructions: ^[dynamic]Instruction, addr: Memory) {…}

    emit_dcbtstct ¶
    Source

    emit_dcbtstct :: emit_dcbtstct_r_r_r

    emit_dcbtstct_r_r_r ¶
    Source

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

    emit_dcbtstds ¶
    Source

    emit_dcbtstds :: emit_dcbtstds_r_r_r

    emit_dcbtstds_r_r_r ¶
    Source

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

    emit_dcbtstep ¶
    Source

    emit_dcbtstep :: emit_dcbtstep_imm_r_r

    emit_dcbtstep_imm_r_r ¶
    Source

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

    emit_dcbtstls ¶
    Source

    emit_dcbtstls :: emit_dcbtstls_r_r_r

    emit_dcbtstls_r_r_r ¶
    Source

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

    emit_dcbtstlse ¶
    Source

    emit_dcbtstlse :: emit_dcbtstlse_r_r_r

    emit_dcbtstlse_r_r_r ¶
    Source

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

    emit_dcbtstt ¶
    Source

    emit_dcbtstt :: emit_dcbtstt_mem

    emit_dcbtstt_mem ¶
    Source

    emit_dcbtstt_mem :: proc(instructions: ^[dynamic]Instruction, addr: Memory) {…}

    emit_dcbtt ¶
    Source

    emit_dcbtt :: emit_dcbtt_mem

    emit_dcbtt_mem ¶
    Source

    emit_dcbtt_mem :: proc(instructions: ^[dynamic]Instruction, addr: Memory) {…}

    emit_dcbz ¶
    Source

    emit_dcbz :: emit_dcbz_mem

    emit_dcbz_l ¶
    Source

    emit_dcbz_l :: emit_dcbz_l_r_r_r

    emit_dcbz_l_r_r_r ¶
    Source

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

    emit_dcbz_mem ¶
    Source

    emit_dcbz_mem :: proc(instructions: ^[dynamic]Instruction, addr: Memory) {…}

    emit_dcbzl ¶
    Source

    emit_dcbzl :: emit_dcbzl_mem

    emit_dcbzl_mem ¶
    Source

    emit_dcbzl_mem :: proc(instructions: ^[dynamic]Instruction, addr: Memory) {…}

    emit_dccci ¶
    Source

    emit_dccci :: emit_dccci_r_r

    emit_dccci_r_r ¶
    Source

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

    emit_dcffix ¶
    Source

    emit_dcffix :: emit_dcffix_fr_fr

    emit_dcffix_dot ¶
    Source

    emit_dcffix_dot :: emit_dcffix_dot_fr_fr

    emit_dcffix_dot_fr_fr ¶
    Source

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

    emit_dcffix_fr_fr ¶
    Source

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

    emit_dci ¶
    Source

    emit_dci :: emit_dci_r_r_r

    emit_dci_r_r_r ¶
    Source

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

    emit_dclst ¶
    Source

    emit_dclst :: emit_dclst_r_r_r

    emit_dclst_r_r_r ¶
    Source

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

    emit_dclz ¶
    Source

    emit_dclz :: emit_dclz_r_r_r

    emit_dclz_r_r_r ¶
    Source

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

    emit_dcmpo ¶
    Source

    emit_dcmpo :: emit_dcmpo_crf_fr_fr

    emit_dcmpo_crf_fr_fr ¶
    Source

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

    emit_dcmpoq ¶
    Source

    emit_dcmpoq :: emit_dcmpoq_crf_fr_fr

    emit_dcmpoq_crf_fr_fr ¶
    Source

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

    emit_dcmpu ¶
    Source

    emit_dcmpu :: emit_dcmpu_crf_fr_fr

    emit_dcmpu_crf_fr_fr ¶
    Source

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

    emit_dcmpuq ¶
    Source

    emit_dcmpuq :: emit_dcmpuq_crf_fr_fr

    emit_dcmpuq_crf_fr_fr ¶
    Source

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

    emit_dcread ¶
    Source

    emit_dcread :: emit_dcread_r_r_r

    emit_dcread_r_r_r ¶
    Source

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

    emit_dcs ¶
    Source

    emit_dcs :: emit_dcs_r_r_r

    emit_dcs_r_r_r ¶
    Source

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

    emit_dctdp ¶
    Source

    emit_dctdp :: emit_dctdp_fr_fr

    emit_dctdp_dot ¶
    Source

    emit_dctdp_dot :: emit_dctdp_dot_fr_fr

    emit_dctdp_dot_fr_fr ¶
    Source

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

    emit_dctdp_fr_fr ¶
    Source

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

    emit_dctfix ¶
    Source

    emit_dctfix :: emit_dctfix_fr_fr

    emit_dctfix_dot ¶
    Source

    emit_dctfix_dot :: emit_dctfix_dot_fr_fr

    emit_dctfix_dot_fr_fr ¶
    Source

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

    emit_dctfix_fr_fr ¶
    Source

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

    emit_dctfixq ¶
    Source

    emit_dctfixq :: emit_dctfixq_fr_fr

    emit_dctfixq_dot ¶
    Source

    emit_dctfixq_dot :: emit_dctfixq_dot_fr_fr

    emit_dctfixq_dot_fr_fr ¶
    Source

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

    emit_dctfixq_fr_fr ¶
    Source

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

    emit_ddedpd ¶
    Source

    emit_ddedpd :: emit_ddedpd_imm_fr_fr

    emit_ddedpd_dot ¶
    Source

    emit_ddedpd_dot :: emit_ddedpd_dot_imm_fr_fr

    emit_ddedpd_dot_imm_fr_fr ¶
    Source

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

    emit_ddedpd_imm_fr_fr ¶
    Source

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

    emit_ddiv ¶
    Source

    emit_ddiv :: emit_ddiv_fr_fr_fr

    emit_ddiv_dot ¶
    Source

    emit_ddiv_dot :: emit_ddiv_dot_fr_fr_fr

    emit_ddiv_dot_fr_fr_fr ¶
    Source

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

    emit_ddiv_fr_fr_fr ¶
    Source

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

    emit_ddivq ¶
    Source

    emit_ddivq :: emit_ddivq_fr_fr_fr

    emit_ddivq_dot ¶
    Source

    emit_ddivq_dot :: emit_ddivq_dot_fr_fr_fr

    emit_ddivq_dot_fr_fr_fr ¶
    Source

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

    emit_ddivq_fr_fr_fr ¶
    Source

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

    emit_denbcd ¶
    Source

    emit_denbcd :: emit_denbcd_imm_fr_fr

    emit_denbcd_dot ¶
    Source

    emit_denbcd_dot :: emit_denbcd_dot_imm_fr_fr

    emit_denbcd_dot_imm_fr_fr ¶
    Source

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

    emit_denbcd_imm_fr_fr ¶
    Source

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

    emit_diex ¶
    Source

    emit_diex :: emit_diex_fr_fr_fr

    emit_diex_dot ¶
    Source

    emit_diex_dot :: emit_diex_dot_fr_fr_fr

    emit_diex_dot_fr_fr_fr ¶
    Source

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

    emit_diex_fr_fr_fr ¶
    Source

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

    emit_div ¶
    Source

    emit_div :: emit_div_r_r_r

    emit_div_dot ¶
    Source

    emit_div_dot :: emit_div_dot_r_r_r

    emit_div_dot_r_r_r ¶
    Source

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

    emit_div_r_r_r ¶
    Source

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

    emit_divd ¶
    Source

    emit_divd :: emit_divd_r_r_r

    emit_divd_dot ¶
    Source

    emit_divd_dot :: emit_divd_dot_r_r_r

    emit_divd_dot_r_r_r ¶
    Source

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

    emit_divd_o ¶
    Source

    emit_divd_o :: emit_divd_o_r_r_r

    emit_divd_o_dot ¶
    Source

    emit_divd_o_dot :: emit_divd_o_dot_r_r_r

    emit_divd_o_dot_r_r_r ¶
    Source

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

    emit_divd_o_r_r_r ¶
    Source

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

    emit_divd_r_r_r ¶
    Source

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

    emit_divde ¶
    Source

    emit_divde :: emit_divde_r_r_r

    emit_divde_dot ¶
    Source

    emit_divde_dot :: emit_divde_dot_r_r_r

    emit_divde_dot_r_r_r ¶
    Source

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

    emit_divde_o ¶
    Source

    emit_divde_o :: emit_divde_o_r_r_r

    emit_divde_o_dot ¶
    Source

    emit_divde_o_dot :: emit_divde_o_dot_r_r_r

    emit_divde_o_dot_r_r_r ¶
    Source

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

    emit_divde_o_r_r_r ¶
    Source

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

    emit_divde_r_r_r ¶
    Source

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

    emit_divdeo ¶
    Source

    emit_divdeo :: emit_divdeo_r_r_r

    emit_divdeo_dot ¶
    Source

    emit_divdeo_dot :: emit_divdeo_dot_r_r_r

    emit_divdeo_dot_r_r_r ¶
    Source

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

    emit_divdeo_r_r_r ¶
    Source

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

    emit_divdeu ¶
    Source

    emit_divdeu :: emit_divdeu_r_r_r

    emit_divdeu_dot ¶
    Source

    emit_divdeu_dot :: emit_divdeu_dot_r_r_r

    emit_divdeu_dot_r_r_r ¶
    Source

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

    emit_divdeu_o ¶
    Source

    emit_divdeu_o :: emit_divdeu_o_r_r_r

    emit_divdeu_o_dot ¶
    Source

    emit_divdeu_o_dot :: emit_divdeu_o_dot_r_r_r

    emit_divdeu_o_dot_r_r_r ¶
    Source

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

    emit_divdeu_o_r_r_r ¶
    Source

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

    emit_divdeu_r_r_r ¶
    Source

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

    emit_divdeuo ¶
    Source

    emit_divdeuo :: emit_divdeuo_r_r_r

    emit_divdeuo_dot ¶
    Source

    emit_divdeuo_dot :: emit_divdeuo_dot_r_r_r

    emit_divdeuo_dot_r_r_r ¶
    Source

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

    emit_divdeuo_r_r_r ¶
    Source

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

    emit_divdo ¶
    Source

    emit_divdo :: emit_divdo_r_r_r

    emit_divdo_dot ¶
    Source

    emit_divdo_dot :: emit_divdo_dot_r_r_r

    emit_divdo_dot_r_r_r ¶
    Source

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

    emit_divdo_r_r_r ¶
    Source

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

    emit_divdu ¶
    Source

    emit_divdu :: emit_divdu_r_r_r

    emit_divdu_dot ¶
    Source

    emit_divdu_dot :: emit_divdu_dot_r_r_r

    emit_divdu_dot_r_r_r ¶
    Source

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

    emit_divdu_o ¶
    Source

    emit_divdu_o :: emit_divdu_o_r_r_r

    emit_divdu_o_dot ¶
    Source

    emit_divdu_o_dot :: emit_divdu_o_dot_r_r_r

    emit_divdu_o_dot_r_r_r ¶
    Source

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

    emit_divdu_o_r_r_r ¶
    Source

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

    emit_divdu_r_r_r ¶
    Source

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

    emit_divduo ¶
    Source

    emit_divduo :: emit_divduo_r_r_r

    emit_divduo_dot ¶
    Source

    emit_divduo_dot :: emit_divduo_dot_r_r_r

    emit_divduo_dot_r_r_r ¶
    Source

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

    emit_divduo_r_r_r ¶
    Source

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

    emit_divo ¶
    Source

    emit_divo :: emit_divo_r_r_r

    emit_divo_dot ¶
    Source

    emit_divo_dot :: emit_divo_dot_r_r_r

    emit_divo_dot_r_r_r ¶
    Source

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

    emit_divo_r_r_r ¶
    Source

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

    emit_divs ¶
    Source

    emit_divs :: emit_divs_r_r_r

    emit_divs_dot ¶
    Source

    emit_divs_dot :: emit_divs_dot_r_r_r

    emit_divs_dot_r_r_r ¶
    Source

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

    emit_divs_r_r_r ¶
    Source

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

    emit_divso ¶
    Source

    emit_divso :: emit_divso_r_r_r

    emit_divso_dot ¶
    Source

    emit_divso_dot :: emit_divso_dot_r_r_r

    emit_divso_dot_r_r_r ¶
    Source

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

    emit_divso_r_r_r ¶
    Source

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

    emit_divw ¶
    Source

    emit_divw :: emit_divw_r_r_r

    emit_divw_dot ¶
    Source

    emit_divw_dot :: emit_divw_dot_r_r_r

    emit_divw_dot_r_r_r ¶
    Source

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

    emit_divw_o ¶
    Source

    emit_divw_o :: emit_divw_o_r_r_r

    emit_divw_o_dot ¶
    Source

    emit_divw_o_dot :: emit_divw_o_dot_r_r_r

    emit_divw_o_dot_r_r_r ¶
    Source

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

    emit_divw_o_r_r_r ¶
    Source

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

    emit_divw_r_r_r ¶
    Source

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

    emit_divwe ¶
    Source

    emit_divwe :: emit_divwe_r_r_r

    emit_divwe_dot ¶
    Source

    emit_divwe_dot :: emit_divwe_dot_r_r_r

    emit_divwe_dot_r_r_r ¶
    Source

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

    emit_divwe_o ¶
    Source

    emit_divwe_o :: emit_divwe_o_r_r_r

    emit_divwe_o_dot ¶
    Source

    emit_divwe_o_dot :: emit_divwe_o_dot_r_r_r

    emit_divwe_o_dot_r_r_r ¶
    Source

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

    emit_divwe_o_r_r_r ¶
    Source

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

    emit_divwe_r_r_r ¶
    Source

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

    emit_divweo ¶
    Source

    emit_divweo :: emit_divweo_r_r_r

    emit_divweo_dot ¶
    Source

    emit_divweo_dot :: emit_divweo_dot_r_r_r

    emit_divweo_dot_r_r_r ¶
    Source

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

    emit_divweo_r_r_r ¶
    Source

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

    emit_divweu ¶
    Source

    emit_divweu :: emit_divweu_r_r_r

    emit_divweu_dot ¶
    Source

    emit_divweu_dot :: emit_divweu_dot_r_r_r

    emit_divweu_dot_r_r_r ¶
    Source

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

    emit_divweu_o ¶
    Source

    emit_divweu_o :: emit_divweu_o_r_r_r

    emit_divweu_o_dot ¶
    Source

    emit_divweu_o_dot :: emit_divweu_o_dot_r_r_r

    emit_divweu_o_dot_r_r_r ¶
    Source

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

    emit_divweu_o_r_r_r ¶
    Source

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

    emit_divweu_r_r_r ¶
    Source

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

    emit_divweuo ¶
    Source

    emit_divweuo :: emit_divweuo_r_r_r

    emit_divweuo_dot ¶
    Source

    emit_divweuo_dot :: emit_divweuo_dot_r_r_r

    emit_divweuo_dot_r_r_r ¶
    Source

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

    emit_divweuo_r_r_r ¶
    Source

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

    emit_divwo ¶
    Source

    emit_divwo :: emit_divwo_r_r_r

    emit_divwo_dot ¶
    Source

    emit_divwo_dot :: emit_divwo_dot_r_r_r

    emit_divwo_dot_r_r_r ¶
    Source

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

    emit_divwo_r_r_r ¶
    Source

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

    emit_divwu ¶
    Source

    emit_divwu :: emit_divwu_r_r_r

    emit_divwu_dot ¶
    Source

    emit_divwu_dot :: emit_divwu_dot_r_r_r

    emit_divwu_dot_r_r_r ¶
    Source

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

    emit_divwu_o ¶
    Source

    emit_divwu_o :: emit_divwu_o_r_r_r

    emit_divwu_o_dot ¶
    Source

    emit_divwu_o_dot :: emit_divwu_o_dot_r_r_r

    emit_divwu_o_dot_r_r_r ¶
    Source

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

    emit_divwu_o_r_r_r ¶
    Source

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

    emit_divwu_r_r_r ¶
    Source

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

    emit_divwuo ¶
    Source

    emit_divwuo :: emit_divwuo_r_r_r

    emit_divwuo_dot ¶
    Source

    emit_divwuo_dot :: emit_divwuo_dot_r_r_r

    emit_divwuo_dot_r_r_r ¶
    Source

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

    emit_divwuo_r_r_r ¶
    Source

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

    emit_dlmzb ¶
    Source

    emit_dlmzb :: emit_dlmzb_r_r_r

    emit_dlmzb_dot ¶
    Source

    emit_dlmzb_dot :: emit_dlmzb_dot_r_r_r

    emit_dlmzb_dot_r_r_r ¶
    Source

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

    emit_dlmzb_r_r_r ¶
    Source

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

    emit_dmul ¶
    Source

    emit_dmul :: emit_dmul_fr_fr_fr

    emit_dmul_dot ¶
    Source

    emit_dmul_dot :: emit_dmul_dot_fr_fr_fr

    emit_dmul_dot_fr_fr_fr ¶
    Source

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

    emit_dmul_fr_fr_fr ¶
    Source

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

    emit_dmulq ¶
    Source

    emit_dmulq :: emit_dmulq_fr_fr_fr

    emit_dmulq_dot ¶
    Source

    emit_dmulq_dot :: emit_dmulq_dot_fr_fr_fr

    emit_dmulq_dot_fr_fr_fr ¶
    Source

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

    emit_dmulq_fr_fr_fr ¶
    Source

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

    emit_dnh ¶
    Source

    emit_dnh :: emit_dnh_r_r_imm

    emit_dnh_r_r_imm ¶
    Source

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

    emit_dni ¶
    Source

    emit_dni :: emit_dni_r_r_r

    emit_dni_r_r_r ¶
    Source

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

    emit_doz ¶
    Source

    emit_doz :: emit_doz_r_r_r

    emit_doz_dot ¶
    Source

    emit_doz_dot :: emit_doz_dot_r_r_r

    emit_doz_dot_r_r_r ¶
    Source

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

    emit_doz_r_r_r ¶
    Source

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

    emit_doze ¶
    Source

    emit_doze :: emit_doze_r_r_imm

    emit_doze_r_r_imm ¶
    Source

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

    emit_dozi ¶
    Source

    emit_dozi :: emit_dozi_r_r_imm

    emit_dozi_r_r_imm ¶
    Source

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

    emit_dozo ¶
    Source

    emit_dozo :: emit_dozo_r_r_r

    emit_dozo_dot ¶
    Source

    emit_dozo_dot :: emit_dozo_dot_r_r_r

    emit_dozo_dot_r_r_r ¶
    Source

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

    emit_dozo_r_r_r ¶
    Source

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

    emit_dqua ¶
    Source

    emit_dqua :: emit_dqua_fr_fr_fr_imm

    emit_dqua_dot ¶
    Source

    emit_dqua_dot :: emit_dqua_dot_fr_fr_fr_imm

    emit_dqua_dot_fr_fr_fr_imm ¶
    Source

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

    emit_dqua_fr_fr_fr_imm ¶
    Source

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

    emit_dquai ¶
    Source

    emit_dquai :: emit_dquai_imm_fr_fr_imm

    emit_dquai_dot ¶
    Source

    emit_dquai_dot :: emit_dquai_dot_imm_fr_fr_imm

    emit_dquai_dot_imm_fr_fr_imm ¶
    Source

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

    emit_dquai_imm_fr_fr_imm ¶
    Source

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

    emit_drintn ¶
    Source

    emit_drintn :: emit_drintn_imm_fr_fr_imm

    emit_drintn_dot ¶
    Source

    emit_drintn_dot :: emit_drintn_dot_imm_fr_fr_imm

    emit_drintn_dot_imm_fr_fr_imm ¶
    Source

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

    emit_drintn_imm_fr_fr_imm ¶
    Source

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

    emit_drintx ¶
    Source

    emit_drintx :: emit_drintx_imm_fr_fr_imm

    emit_drintx_dot ¶
    Source

    emit_drintx_dot :: emit_drintx_dot_imm_fr_fr_imm

    emit_drintx_dot_imm_fr_fr_imm ¶
    Source

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

    emit_drintx_imm_fr_fr_imm ¶
    Source

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

    emit_drrnd ¶
    Source

    emit_drrnd :: emit_drrnd_fr_fr_fr_imm

    emit_drrnd_dot ¶
    Source

    emit_drrnd_dot :: emit_drrnd_dot_fr_fr_fr_imm

    emit_drrnd_dot_fr_fr_fr_imm ¶
    Source

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

    emit_drrnd_fr_fr_fr_imm ¶
    Source

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

    emit_drsp ¶
    Source

    emit_drsp :: emit_drsp_fr_fr

    emit_drsp_dot ¶
    Source

    emit_drsp_dot :: emit_drsp_dot_fr_fr

    emit_drsp_dot_fr_fr ¶
    Source

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

    emit_drsp_fr_fr ¶
    Source

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

    emit_dscli ¶
    Source

    emit_dscli :: emit_dscli_fr_fr_imm

    emit_dscli_dot ¶
    Source

    emit_dscli_dot :: emit_dscli_dot_fr_fr_imm

    emit_dscli_dot_fr_fr_imm ¶
    Source

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

    emit_dscli_fr_fr_imm ¶
    Source

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

    emit_dscri ¶
    Source

    emit_dscri :: emit_dscri_fr_fr_imm

    emit_dscri_dot ¶
    Source

    emit_dscri_dot :: emit_dscri_dot_fr_fr_imm

    emit_dscri_dot_fr_fr_imm ¶
    Source

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

    emit_dscri_fr_fr_imm ¶
    Source

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

    emit_dsn ¶
    Source

    emit_dsn :: emit_dsn_r_r_r

    emit_dsn_r_r_r ¶
    Source

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

    emit_dss ¶
    Source

    emit_dss :: emit_dss_imm

    emit_dss_imm ¶
    Source

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

    emit_dssall ¶
    Source

    emit_dssall :: emit_dssall_none

    emit_dssall_none ¶
    Source

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

    emit_dst ¶
    Source

    emit_dst :: emit_dst_r_r_imm

    emit_dst_r_r_imm ¶
    Source

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

    emit_dstst ¶
    Source

    emit_dstst :: emit_dstst_r_r_imm

    emit_dstst_r_r_imm ¶
    Source

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

    emit_dststt ¶
    Source

    emit_dststt :: emit_dststt_r_r_imm

    emit_dststt_r_r_imm ¶
    Source

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

    emit_dstt ¶
    Source

    emit_dstt :: emit_dstt_r_r_imm

    emit_dstt_r_r_imm ¶
    Source

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

    emit_dsub ¶
    Source

    emit_dsub :: emit_dsub_fr_fr_fr

    emit_dsub_dot ¶
    Source

    emit_dsub_dot :: emit_dsub_dot_fr_fr_fr

    emit_dsub_dot_fr_fr_fr ¶
    Source

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

    emit_dsub_fr_fr_fr ¶
    Source

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

    emit_dsubq ¶
    Source

    emit_dsubq :: emit_dsubq_fr_fr_fr

    emit_dsubq_dot ¶
    Source

    emit_dsubq_dot :: emit_dsubq_dot_fr_fr_fr

    emit_dsubq_dot_fr_fr_fr ¶
    Source

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

    emit_dsubq_fr_fr_fr ¶
    Source

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

    emit_dtstdc ¶
    Source

    emit_dtstdc :: emit_dtstdc_crf_fr_imm

    emit_dtstdc_crf_fr_imm ¶
    Source

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

    emit_dtstdg ¶
    Source

    emit_dtstdg :: emit_dtstdg_crf_fr_imm

    emit_dtstdg_crf_fr_imm ¶
    Source

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

    emit_dtstex ¶
    Source

    emit_dtstex :: emit_dtstex_crf_fr_fr

    emit_dtstex_crf_fr_fr ¶
    Source

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

    emit_dtstexq ¶
    Source

    emit_dtstexq :: emit_dtstexq_fr_mem

    emit_dtstexq_fr_mem ¶
    Source

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

    emit_dtstsf ¶
    Source

    emit_dtstsf :: emit_dtstsf_crf_fr_fr

    emit_dtstsf_crf_fr_fr ¶
    Source

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

    emit_dtstsfq ¶
    Source

    emit_dtstsfq :: emit_dtstsfq_fr_mem

    emit_dtstsfq_fr_mem ¶
    Source

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

    emit_dxex ¶
    Source

    emit_dxex :: emit_dxex_fr_fr

    emit_dxex_dot ¶
    Source

    emit_dxex_dot :: emit_dxex_dot_fr_fr

    emit_dxex_dot_fr_fr ¶
    Source

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

    emit_dxex_fr_fr ¶
    Source

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

    emit_dxexq ¶
    Source

    emit_dxexq :: emit_dxexq_fr_mem

    emit_dxexq_dot ¶
    Source

    emit_dxexq_dot :: emit_dxexq_dot_fr_mem

    emit_dxexq_dot_fr_mem ¶
    Source

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

    emit_dxexq_fr_mem ¶
    Source

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

    emit_eciwx ¶
    Source

    emit_eciwx :: emit_eciwx_r_r_r

    emit_eciwx_r_r_r ¶
    Source

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

    emit_ecowx ¶
    Source

    emit_ecowx :: emit_ecowx_r_r_r

    emit_ecowx_r_r_r ¶
    Source

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

    emit_efdabs ¶
    Source

    emit_efdabs :: emit_efdabs_r_r

    emit_efdabs_r_r ¶
    Source

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

    emit_efdadd ¶
    Source

    emit_efdadd :: emit_efdadd_r_r_r

    emit_efdadd_r_r_r ¶
    Source

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

    emit_efdcfh ¶
    Source

    emit_efdcfh :: emit_efdcfh_r_r

    emit_efdcfh_r_r ¶
    Source

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

    emit_efdcfs ¶
    Source

    emit_efdcfs :: emit_efdcfs_r_r

    emit_efdcfs_r_r ¶
    Source

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

    emit_efdcfsf ¶
    Source

    emit_efdcfsf :: emit_efdcfsf_r_r

    emit_efdcfsf_r_r ¶
    Source

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

    emit_efdcfsi ¶
    Source

    emit_efdcfsi :: emit_efdcfsi_r_r

    emit_efdcfsi_r_r ¶
    Source

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

    emit_efdcfsid ¶
    Source

    emit_efdcfsid :: emit_efdcfsid_r_r

    emit_efdcfsid_r_r ¶
    Source

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

    emit_efdcfuf ¶
    Source

    emit_efdcfuf :: emit_efdcfuf_r_r

    emit_efdcfuf_r_r ¶
    Source

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

    emit_efdcfui ¶
    Source

    emit_efdcfui :: emit_efdcfui_r_r

    emit_efdcfui_r_r ¶
    Source

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

    emit_efdcfuid ¶
    Source

    emit_efdcfuid :: emit_efdcfuid_r_r

    emit_efdcfuid_r_r ¶
    Source

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

    emit_efdcmpeq ¶
    Source

    emit_efdcmpeq :: emit_efdcmpeq_crf_r_r

    emit_efdcmpeq_crf_r_r ¶
    Source

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

    emit_efdcmpgt ¶
    Source

    emit_efdcmpgt :: emit_efdcmpgt_crf_r_r

    emit_efdcmpgt_crf_r_r ¶
    Source

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

    emit_efdcmplt ¶
    Source

    emit_efdcmplt :: emit_efdcmplt_crf_r_r

    emit_efdcmplt_crf_r_r ¶
    Source

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

    emit_efdcth ¶
    Source

    emit_efdcth :: emit_efdcth_r_r

    emit_efdcth_r_r ¶
    Source

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

    emit_efdctsf ¶
    Source

    emit_efdctsf :: emit_efdctsf_r_r

    emit_efdctsf_r_r ¶
    Source

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

    emit_efdctsi ¶
    Source

    emit_efdctsi :: emit_efdctsi_r_r

    emit_efdctsi_r_r ¶
    Source

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

    emit_efdctsidz ¶
    Source

    emit_efdctsidz :: emit_efdctsidz_r_r

    emit_efdctsidz_r_r ¶
    Source

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

    emit_efdctsiz ¶
    Source

    emit_efdctsiz :: emit_efdctsiz_r_r

    emit_efdctsiz_r_r ¶
    Source

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

    emit_efdctuf ¶
    Source

    emit_efdctuf :: emit_efdctuf_r_r

    emit_efdctuf_r_r ¶
    Source

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

    emit_efdctui ¶
    Source

    emit_efdctui :: emit_efdctui_r_r

    emit_efdctui_r_r ¶
    Source

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

    emit_efdctuidz ¶
    Source

    emit_efdctuidz :: emit_efdctuidz_r_r

    emit_efdctuidz_r_r ¶
    Source

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

    emit_efdctuiz ¶
    Source

    emit_efdctuiz :: emit_efdctuiz_r_r

    emit_efdctuiz_r_r ¶
    Source

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

    emit_efddiv ¶
    Source

    emit_efddiv :: emit_efddiv_r_r_r

    emit_efddiv_r_r_r ¶
    Source

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

    emit_efdmadd ¶
    Source

    emit_efdmadd :: emit_efdmadd_r_r_r

    emit_efdmadd_r_r_r ¶
    Source

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

    emit_efdmax ¶
    Source

    emit_efdmax :: emit_efdmax_r_r_r

    emit_efdmax_r_r_r ¶
    Source

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

    emit_efdmin ¶
    Source

    emit_efdmin :: emit_efdmin_r_r_r

    emit_efdmin_r_r_r ¶
    Source

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

    emit_efdmsub ¶
    Source

    emit_efdmsub :: emit_efdmsub_r_r_r

    emit_efdmsub_r_r_r ¶
    Source

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

    emit_efdmul ¶
    Source

    emit_efdmul :: emit_efdmul_r_r_r

    emit_efdmul_r_r_r ¶
    Source

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

    emit_efdnabs ¶
    Source

    emit_efdnabs :: emit_efdnabs_r_r

    emit_efdnabs_r_r ¶
    Source

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

    emit_efdneg ¶
    Source

    emit_efdneg :: emit_efdneg_r_r

    emit_efdneg_r_r ¶
    Source

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

    emit_efdnmadd ¶
    Source

    emit_efdnmadd :: emit_efdnmadd_r_r_r

    emit_efdnmadd_r_r_r ¶
    Source

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

    emit_efdnmsub ¶
    Source

    emit_efdnmsub :: emit_efdnmsub_r_r_r

    emit_efdnmsub_r_r_r ¶
    Source

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

    emit_efdsqrt ¶
    Source

    emit_efdsqrt :: emit_efdsqrt_r_r

    emit_efdsqrt_r_r ¶
    Source

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

    emit_efdsub ¶
    Source

    emit_efdsub :: emit_efdsub_r_r_r

    emit_efdsub_r_r_r ¶
    Source

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

    emit_efdtsteq ¶
    Source

    emit_efdtsteq :: emit_efdtsteq_crf_r_r

    emit_efdtsteq_crf_r_r ¶
    Source

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

    emit_efdtstgt ¶
    Source

    emit_efdtstgt :: emit_efdtstgt_crf_r_r

    emit_efdtstgt_crf_r_r ¶
    Source

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

    emit_efdtstlt ¶
    Source

    emit_efdtstlt :: emit_efdtstlt_crf_r_r

    emit_efdtstlt_crf_r_r ¶
    Source

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

    emit_efsabs ¶
    Source

    emit_efsabs :: emit_efsabs_r_r

    emit_efsabs_r_r ¶
    Source

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

    emit_efsadd ¶
    Source

    emit_efsadd :: emit_efsadd_r_r_r

    emit_efsadd_r_r_r ¶
    Source

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

    emit_efscfd ¶
    Source

    emit_efscfd :: emit_efscfd_r_r

    emit_efscfd_r_r ¶
    Source

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

    emit_efscfh ¶
    Source

    emit_efscfh :: emit_efscfh_r_r

    emit_efscfh_r_r ¶
    Source

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

    emit_efscfsf ¶
    Source

    emit_efscfsf :: emit_efscfsf_r_r

    emit_efscfsf_r_r ¶
    Source

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

    emit_efscfsi ¶
    Source

    emit_efscfsi :: emit_efscfsi_r_r

    emit_efscfsi_r_r ¶
    Source

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

    emit_efscfuf ¶
    Source

    emit_efscfuf :: emit_efscfuf_r_r

    emit_efscfuf_r_r ¶
    Source

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

    emit_efscfui ¶
    Source

    emit_efscfui :: emit_efscfui_r_r

    emit_efscfui_r_r ¶
    Source

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

    emit_efscmpeq ¶
    Source

    emit_efscmpeq :: emit_efscmpeq_crf_r_r

    emit_efscmpeq_crf_r_r ¶
    Source

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

    emit_efscmpgt ¶
    Source

    emit_efscmpgt :: emit_efscmpgt_crf_r_r

    emit_efscmpgt_crf_r_r ¶
    Source

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

    emit_efscmplt ¶
    Source

    emit_efscmplt :: emit_efscmplt_crf_r_r

    emit_efscmplt_crf_r_r ¶
    Source

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

    emit_efscth ¶
    Source

    emit_efscth :: emit_efscth_r_r

    emit_efscth_r_r ¶
    Source

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

    emit_efsctsf ¶
    Source

    emit_efsctsf :: emit_efsctsf_r_r

    emit_efsctsf_r_r ¶
    Source

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

    emit_efsctsi ¶
    Source

    emit_efsctsi :: emit_efsctsi_r_r

    emit_efsctsi_r_r ¶
    Source

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

    emit_efsctsiz ¶
    Source

    emit_efsctsiz :: emit_efsctsiz_r_r

    emit_efsctsiz_r_r ¶
    Source

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

    emit_efsctuf ¶
    Source

    emit_efsctuf :: emit_efsctuf_r_r

    emit_efsctuf_r_r ¶
    Source

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

    emit_efsctui ¶
    Source

    emit_efsctui :: emit_efsctui_r_r

    emit_efsctui_r_r ¶
    Source

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

    emit_efsctuiz ¶
    Source

    emit_efsctuiz :: emit_efsctuiz_r_r

    emit_efsctuiz_r_r ¶
    Source

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

    emit_efsdiv ¶
    Source

    emit_efsdiv :: emit_efsdiv_r_r_r

    emit_efsdiv_r_r_r ¶
    Source

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

    emit_efsmadd ¶
    Source

    emit_efsmadd :: emit_efsmadd_r_r_r

    emit_efsmadd_r_r_r ¶
    Source

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

    emit_efsmax ¶
    Source

    emit_efsmax :: emit_efsmax_r_r_r

    emit_efsmax_r_r_r ¶
    Source

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

    emit_efsmin ¶
    Source

    emit_efsmin :: emit_efsmin_r_r_r

    emit_efsmin_r_r_r ¶
    Source

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

    emit_efsmsub ¶
    Source

    emit_efsmsub :: emit_efsmsub_r_r_r

    emit_efsmsub_r_r_r ¶
    Source

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

    emit_efsmul ¶
    Source

    emit_efsmul :: emit_efsmul_r_r_r

    emit_efsmul_r_r_r ¶
    Source

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

    emit_efsnabs ¶
    Source

    emit_efsnabs :: emit_efsnabs_r_r

    emit_efsnabs_r_r ¶
    Source

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

    emit_efsneg ¶
    Source

    emit_efsneg :: emit_efsneg_r_r

    emit_efsneg_r_r ¶
    Source

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

    emit_efsnmadd ¶
    Source

    emit_efsnmadd :: emit_efsnmadd_r_r_r

    emit_efsnmadd_r_r_r ¶
    Source

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

    emit_efsnmsub ¶
    Source

    emit_efsnmsub :: emit_efsnmsub_r_r_r

    emit_efsnmsub_r_r_r ¶
    Source

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

    emit_efssqrt ¶
    Source

    emit_efssqrt :: emit_efssqrt_r_r

    emit_efssqrt_r_r ¶
    Source

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

    emit_efssub ¶
    Source

    emit_efssub :: emit_efssub_r_r_r

    emit_efssub_r_r_r ¶
    Source

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

    emit_efststeq ¶
    Source

    emit_efststeq :: emit_efststeq_crf_r_r

    emit_efststeq_crf_r_r ¶
    Source

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

    emit_efststgt ¶
    Source

    emit_efststgt :: emit_efststgt_crf_r_r

    emit_efststgt_crf_r_r ¶
    Source

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

    emit_efststlt ¶
    Source

    emit_efststlt :: emit_efststlt_crf_r_r

    emit_efststlt_crf_r_r ¶
    Source

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

    emit_ehpriv ¶
    Source

    emit_ehpriv :: emit_ehpriv_r_r_r

    emit_ehpriv_r_r_r ¶
    Source

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

    emit_eieio ¶
    Source

    emit_eieio :: emit_eieio_none

    emit_eieio_none ¶
    Source

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

    emit_eqv ¶
    Source

    emit_eqv :: emit_eqv_r_r_r

    emit_eqv_dot ¶
    Source

    emit_eqv_dot :: emit_eqv_dot_r_r_r

    emit_eqv_dot_r_r_r ¶
    Source

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

    emit_eqv_r_r_r ¶
    Source

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

    emit_eratilx ¶
    Source

    emit_eratilx :: emit_eratilx_r_r_r

    emit_eratilx_r_r_r ¶
    Source

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

    emit_erativax ¶
    Source

    emit_erativax :: emit_erativax_r_r_r

    emit_erativax_r_r_r ¶
    Source

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

    emit_eratre ¶
    Source

    emit_eratre :: emit_eratre_r_r_r

    emit_eratre_r_r_r ¶
    Source

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

    emit_eratsx ¶
    Source

    emit_eratsx :: emit_eratsx_r_r_r

    emit_eratsx_dot ¶
    Source

    emit_eratsx_dot :: emit_eratsx_dot_r_r_r

    emit_eratsx_dot_r_r_r ¶
    Source

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

    emit_eratsx_r_r_r ¶
    Source

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

    emit_eratwe ¶
    Source

    emit_eratwe :: emit_eratwe_r_r_r

    emit_eratwe_r_r_r ¶
    Source

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

    emit_evabs ¶
    Source

    emit_evabs :: emit_evabs_r_r

    emit_evabs_r_r ¶
    Source

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

    emit_evabsb ¶
    Source

    emit_evabsb :: emit_evabsb_r_r_r

    emit_evabsb_r_r_r ¶
    Source

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

    emit_evabsbs ¶
    Source

    emit_evabsbs :: emit_evabsbs_r_r_r

    emit_evabsbs_r_r_r ¶
    Source

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

    emit_evabsd ¶
    Source

    emit_evabsd :: emit_evabsd_r_r_r

    emit_evabsd_r_r_r ¶
    Source

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

    emit_evabsdifsb ¶
    Source

    emit_evabsdifsb :: emit_evabsdifsb_r_r_r

    emit_evabsdifsb_r_r_r ¶
    Source

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

    emit_evabsdifsh ¶
    Source

    emit_evabsdifsh :: emit_evabsdifsh_r_r_r

    emit_evabsdifsh_r_r_r ¶
    Source

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

    emit_evabsdifsw ¶
    Source

    emit_evabsdifsw :: emit_evabsdifsw_r_r_r

    emit_evabsdifsw_r_r_r ¶
    Source

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

    emit_evabsdifub ¶
    Source

    emit_evabsdifub :: emit_evabsdifub_r_r_r

    emit_evabsdifub_r_r_r ¶
    Source

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

    emit_evabsdifuh ¶
    Source

    emit_evabsdifuh :: emit_evabsdifuh_r_r_r

    emit_evabsdifuh_r_r_r ¶
    Source

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

    emit_evabsdifuw ¶
    Source

    emit_evabsdifuw :: emit_evabsdifuw_r_r_r

    emit_evabsdifuw_r_r_r ¶
    Source

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

    emit_evabsds ¶
    Source

    emit_evabsds :: emit_evabsds_r_r_r

    emit_evabsds_r_r_r ¶
    Source

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

    emit_evabsh ¶
    Source

    emit_evabsh :: emit_evabsh_r_r_r

    emit_evabsh_r_r_r ¶
    Source

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

    emit_evabshs ¶
    Source

    emit_evabshs :: emit_evabshs_r_r_r

    emit_evabshs_r_r_r ¶
    Source

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

    emit_evabss ¶
    Source

    emit_evabss :: emit_evabss_r_r_r

    emit_evabss_r_r_r ¶
    Source

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

    emit_evadd2subf2h ¶
    Source

    emit_evadd2subf2h :: emit_evadd2subf2h_r_r_r

    emit_evadd2subf2h_r_r_r ¶
    Source

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

    emit_evadd2subf2hss ¶
    Source

    emit_evadd2subf2hss :: emit_evadd2subf2hss_r_r_r

    emit_evadd2subf2hss_r_r_r ¶
    Source

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

    emit_evaddb ¶
    Source

    emit_evaddb :: emit_evaddb_r_r_r

    emit_evaddb_r_r_r ¶
    Source

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

    emit_evaddbss ¶
    Source

    emit_evaddbss :: emit_evaddbss_r_r_r

    emit_evaddbss_r_r_r ¶
    Source

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

    emit_evaddbus ¶
    Source

    emit_evaddbus :: emit_evaddbus_r_r_r

    emit_evaddbus_r_r_r ¶
    Source

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

    emit_evaddd ¶
    Source

    emit_evaddd :: emit_evaddd_r_r_r

    emit_evaddd_r_r_r ¶
    Source

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

    emit_evadddss ¶
    Source

    emit_evadddss :: emit_evadddss_r_r_r

    emit_evadddss_r_r_r ¶
    Source

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

    emit_evadddus ¶
    Source

    emit_evadddus :: emit_evadddus_r_r_r

    emit_evadddus_r_r_r ¶
    Source

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

    emit_evaddh ¶
    Source

    emit_evaddh :: emit_evaddh_r_r_r

    emit_evaddh_r_r_r ¶
    Source

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

    emit_evaddhhisw ¶
    Source

    emit_evaddhhisw :: emit_evaddhhisw_r_r_r

    emit_evaddhhisw_r_r_r ¶
    Source

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

    emit_evaddhhiuw ¶
    Source

    emit_evaddhhiuw :: emit_evaddhhiuw_r_r_r

    emit_evaddhhiuw_r_r_r ¶
    Source

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

    emit_evaddhlosw ¶
    Source

    emit_evaddhlosw :: emit_evaddhlosw_r_r_r

    emit_evaddhlosw_r_r_r ¶
    Source

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

    emit_evaddhlouw ¶
    Source

    emit_evaddhlouw :: emit_evaddhlouw_r_r_r

    emit_evaddhlouw_r_r_r ¶
    Source

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

    emit_evaddhss ¶
    Source

    emit_evaddhss :: emit_evaddhss_r_r_r

    emit_evaddhss_r_r_r ¶
    Source

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

    emit_evaddhus ¶
    Source

    emit_evaddhus :: emit_evaddhus_r_r_r

    emit_evaddhus_r_r_r ¶
    Source

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

    emit_evaddhx ¶
    Source

    emit_evaddhx :: emit_evaddhx_r_r_r

    emit_evaddhx_r_r_r ¶
    Source

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

    emit_evaddhxss ¶
    Source

    emit_evaddhxss :: emit_evaddhxss_r_r_r

    emit_evaddhxss_r_r_r ¶
    Source

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

    emit_evaddhxus ¶
    Source

    emit_evaddhxus :: emit_evaddhxus_r_r_r

    emit_evaddhxus_r_r_r ¶
    Source

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

    emit_evaddib ¶
    Source

    emit_evaddib :: emit_evaddib_r_r_r

    emit_evaddib_r_r_r ¶
    Source

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

    emit_evaddih ¶
    Source

    emit_evaddih :: emit_evaddih_r_r_r

    emit_evaddih_r_r_r ¶
    Source

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

    emit_evaddiw ¶
    Source

    emit_evaddiw :: emit_evaddiw_r_r_imm

    emit_evaddiw_r_r_imm ¶
    Source

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

    emit_evaddsmiaa ¶
    Source

    emit_evaddsmiaa :: emit_evaddsmiaa_r_r_r

    emit_evaddsmiaa_r_r_r ¶
    Source

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

    emit_evaddsmiaaw ¶
    Source

    emit_evaddsmiaaw :: emit_evaddsmiaaw_r_r_r

    emit_evaddsmiaaw_r_r_r ¶
    Source

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

    emit_evaddssiaa ¶
    Source

    emit_evaddssiaa :: emit_evaddssiaa_r_r_r

    emit_evaddssiaa_r_r_r ¶
    Source

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

    emit_evaddssiaaw ¶
    Source

    emit_evaddssiaaw :: emit_evaddssiaaw_r_r_r

    emit_evaddssiaaw_r_r_r ¶
    Source

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

    emit_evaddsubfh ¶
    Source

    emit_evaddsubfh :: emit_evaddsubfh_r_r_r

    emit_evaddsubfh_r_r_r ¶
    Source

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

    emit_evaddsubfhss ¶
    Source

    emit_evaddsubfhss :: emit_evaddsubfhss_r_r_r

    emit_evaddsubfhss_r_r_r ¶
    Source

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

    emit_evaddsubfhx ¶
    Source

    emit_evaddsubfhx :: emit_evaddsubfhx_r_r_r

    emit_evaddsubfhx_r_r_r ¶
    Source

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

    emit_evaddsubfhxss ¶
    Source

    emit_evaddsubfhxss :: emit_evaddsubfhxss_r_r_r

    emit_evaddsubfhxss_r_r_r ¶
    Source

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

    emit_evaddsubfw ¶
    Source

    emit_evaddsubfw :: emit_evaddsubfw_r_r_r

    emit_evaddsubfw_r_r_r ¶
    Source

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

    emit_evaddsubfwss ¶
    Source

    emit_evaddsubfwss :: emit_evaddsubfwss_r_r_r

    emit_evaddsubfwss_r_r_r ¶
    Source

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

    emit_evaddsubfwx ¶
    Source

    emit_evaddsubfwx :: emit_evaddsubfwx_r_r_r

    emit_evaddsubfwx_r_r_r ¶
    Source

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

    emit_evaddsubfwxss ¶
    Source

    emit_evaddsubfwxss :: emit_evaddsubfwxss_r_r_r

    emit_evaddsubfwxss_r_r_r ¶
    Source

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

    emit_evaddumiaaw ¶
    Source

    emit_evaddumiaaw :: emit_evaddumiaaw_r_r_r

    emit_evaddumiaaw_r_r_r ¶
    Source

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

    emit_evaddusiaa ¶
    Source

    emit_evaddusiaa :: emit_evaddusiaa_r_r_r

    emit_evaddusiaa_r_r_r ¶
    Source

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

    emit_evaddusiaaw ¶
    Source

    emit_evaddusiaaw :: emit_evaddusiaaw_r_r_r

    emit_evaddusiaaw_r_r_r ¶
    Source

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

    emit_evaddw ¶
    Source

    emit_evaddw :: emit_evaddw_r_r_r

    emit_evaddw_r_r_r ¶
    Source

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

    emit_evaddwegsf ¶
    Source

    emit_evaddwegsf :: emit_evaddwegsf_r_r_r

    emit_evaddwegsf_r_r_r ¶
    Source

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

    emit_evaddwegsi ¶
    Source

    emit_evaddwegsi :: emit_evaddwegsi_r_r_r

    emit_evaddwegsi_r_r_r ¶
    Source

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

    emit_evaddwogsf ¶
    Source

    emit_evaddwogsf :: emit_evaddwogsf_r_r_r

    emit_evaddwogsf_r_r_r ¶
    Source

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

    emit_evaddwogsi ¶
    Source

    emit_evaddwogsi :: emit_evaddwogsi_r_r_r

    emit_evaddwogsi_r_r_r ¶
    Source

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

    emit_evaddwss ¶
    Source

    emit_evaddwss :: emit_evaddwss_r_r_r

    emit_evaddwss_r_r_r ¶
    Source

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

    emit_evaddwus ¶
    Source

    emit_evaddwus :: emit_evaddwus_r_r_r

    emit_evaddwus_r_r_r ¶
    Source

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

    emit_evaddwx ¶
    Source

    emit_evaddwx :: emit_evaddwx_r_r_r

    emit_evaddwx_r_r_r ¶
    Source

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

    emit_evaddwxss ¶
    Source

    emit_evaddwxss :: emit_evaddwxss_r_r_r

    emit_evaddwxss_r_r_r ¶
    Source

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

    emit_evaddwxus ¶
    Source

    emit_evaddwxus :: emit_evaddwxus_r_r_r

    emit_evaddwxus_r_r_r ¶
    Source

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

    emit_evand ¶
    Source

    emit_evand :: emit_evand_r_r_r

    emit_evand_r_r_r ¶
    Source

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

    emit_evandc ¶
    Source

    emit_evandc :: emit_evandc_r_r_r

    emit_evandc_r_r_r ¶
    Source

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

    emit_evavgbs ¶
    Source

    emit_evavgbs :: emit_evavgbs_r_r_r

    emit_evavgbs_r_r_r ¶
    Source

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

    emit_evavgbsr ¶
    Source

    emit_evavgbsr :: emit_evavgbsr_r_r_r

    emit_evavgbsr_r_r_r ¶
    Source

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

    emit_evavgbu ¶
    Source

    emit_evavgbu :: emit_evavgbu_r_r_r

    emit_evavgbu_r_r_r ¶
    Source

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

    emit_evavgbur ¶
    Source

    emit_evavgbur :: emit_evavgbur_r_r_r

    emit_evavgbur_r_r_r ¶
    Source

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

    emit_evavgds ¶
    Source

    emit_evavgds :: emit_evavgds_r_r_r

    emit_evavgds_r_r_r ¶
    Source

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

    emit_evavgdsr ¶
    Source

    emit_evavgdsr :: emit_evavgdsr_r_r_r

    emit_evavgdsr_r_r_r ¶
    Source

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

    emit_evavgdu ¶
    Source

    emit_evavgdu :: emit_evavgdu_r_r_r

    emit_evavgdu_r_r_r ¶
    Source

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

    emit_evavgdur ¶
    Source

    emit_evavgdur :: emit_evavgdur_r_r_r

    emit_evavgdur_r_r_r ¶
    Source

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

    emit_evavghs ¶
    Source

    emit_evavghs :: emit_evavghs_r_r_r

    emit_evavghs_r_r_r ¶
    Source

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

    emit_evavghsr ¶
    Source

    emit_evavghsr :: emit_evavghsr_r_r_r

    emit_evavghsr_r_r_r ¶
    Source

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

    emit_evavghu ¶
    Source

    emit_evavghu :: emit_evavghu_r_r_r

    emit_evavghu_r_r_r ¶
    Source

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

    emit_evavghur ¶
    Source

    emit_evavghur :: emit_evavghur_r_r_r

    emit_evavghur_r_r_r ¶
    Source

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

    emit_evavgws ¶
    Source

    emit_evavgws :: emit_evavgws_r_r_r

    emit_evavgws_r_r_r ¶
    Source

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

    emit_evavgwsr ¶
    Source

    emit_evavgwsr :: emit_evavgwsr_r_r_r

    emit_evavgwsr_r_r_r ¶
    Source

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

    emit_evavgwu ¶
    Source

    emit_evavgwu :: emit_evavgwu_r_r_r

    emit_evavgwu_r_r_r ¶
    Source

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

    emit_evavgwur ¶
    Source

    emit_evavgwur :: emit_evavgwur_r_r_r

    emit_evavgwur_r_r_r ¶
    Source

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

    emit_evclrbe ¶
    Source

    emit_evclrbe :: emit_evclrbe_r_r_r

    emit_evclrbe_r_r_r ¶
    Source

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

    emit_evclrbo ¶
    Source

    emit_evclrbo :: emit_evclrbo_r_r_r

    emit_evclrbo_r_r_r ¶
    Source

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

    emit_evclrh ¶
    Source

    emit_evclrh :: emit_evclrh_r_r_r

    emit_evclrh_r_r_r ¶
    Source

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

    emit_evcmpeq ¶
    Source

    emit_evcmpeq :: emit_evcmpeq_crf_r_r

    emit_evcmpeq_crf_r_r ¶
    Source

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

    emit_evcmpeqd ¶
    Source

    emit_evcmpeqd :: emit_evcmpeqd_r_r_r

    emit_evcmpeqd_r_r_r ¶
    Source

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

    emit_evcmpgtds ¶
    Source

    emit_evcmpgtds :: emit_evcmpgtds_r_r_r

    emit_evcmpgtds_r_r_r ¶
    Source

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

    emit_evcmpgtdu ¶
    Source

    emit_evcmpgtdu :: emit_evcmpgtdu_r_r_r

    emit_evcmpgtdu_r_r_r ¶
    Source

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

    emit_evcmpgts ¶
    Source

    emit_evcmpgts :: emit_evcmpgts_crf_r_r

    emit_evcmpgts_crf_r_r ¶
    Source

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

    emit_evcmpgtu ¶
    Source

    emit_evcmpgtu :: emit_evcmpgtu_crf_r_r

    emit_evcmpgtu_crf_r_r ¶
    Source

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

    emit_evcmpltds ¶
    Source

    emit_evcmpltds :: emit_evcmpltds_r_r_r

    emit_evcmpltds_r_r_r ¶
    Source

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

    emit_evcmpltdu ¶
    Source

    emit_evcmpltdu :: emit_evcmpltdu_r_r_r

    emit_evcmpltdu_r_r_r ¶
    Source

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

    emit_evcmplts ¶
    Source

    emit_evcmplts :: emit_evcmplts_crf_r_r

    emit_evcmplts_crf_r_r ¶
    Source

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

    emit_evcmpltu ¶
    Source

    emit_evcmpltu :: emit_evcmpltu_crf_r_r

    emit_evcmpltu_crf_r_r ¶
    Source

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

    emit_evcntlsh ¶
    Source

    emit_evcntlsh :: emit_evcntlsh_r_r_r

    emit_evcntlsh_r_r_r ¶
    Source

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

    emit_evcntlsw ¶
    Source

    emit_evcntlsw :: emit_evcntlsw_r_r

    emit_evcntlsw_r_r ¶
    Source

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

    emit_evcntlzh ¶
    Source

    emit_evcntlzh :: emit_evcntlzh_r_r_r

    emit_evcntlzh_r_r_r ¶
    Source

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

    emit_evcntlzw ¶
    Source

    emit_evcntlzw :: emit_evcntlzw_r_r

    emit_evcntlzw_r_r ¶
    Source

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

    emit_evdiff2his ¶
    Source

    emit_evdiff2his :: emit_evdiff2his_r_r_r

    emit_evdiff2his_r_r_r ¶
    Source

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

    emit_evdiff2hisa ¶
    Source

    emit_evdiff2hisa :: emit_evdiff2hisa_r_r_r

    emit_evdiff2hisa_r_r_r ¶
    Source

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

    emit_evdiff2hisaaw ¶
    Source

    emit_evdiff2hisaaw :: emit_evdiff2hisaaw_r_r_r

    emit_evdiff2hisaaw_r_r_r ¶
    Source

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

    emit_evdivs ¶
    Source

    emit_evdivs :: emit_evdivs_r_r_r

    emit_evdivs_r_r_r ¶
    Source

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

    emit_evdivu ¶
    Source

    emit_evdivu :: emit_evdivu_r_r_r

    emit_evdivu_r_r_r ¶
    Source

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

    emit_evdivws ¶
    Source

    emit_evdivws :: emit_evdivws_r_r_r

    emit_evdivws_r_r_r ¶
    Source

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

    emit_evdivwsf ¶
    Source

    emit_evdivwsf :: emit_evdivwsf_r_r_r

    emit_evdivwsf_r_r_r ¶
    Source

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

    emit_evdivwu ¶
    Source

    emit_evdivwu :: emit_evdivwu_r_r_r

    emit_evdivwu_r_r_r ¶
    Source

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

    emit_evdivwuf ¶
    Source

    emit_evdivwuf :: emit_evdivwuf_r_r_r

    emit_evdivwuf_r_r_r ¶
    Source

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

    emit_evdlveb ¶
    Source

    emit_evdlveb :: emit_evdlveb_r_r_r

    emit_evdlveb_r_r_r ¶
    Source

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

    emit_evdlveh ¶
    Source

    emit_evdlveh :: emit_evdlveh_r_r_r

    emit_evdlveh_r_r_r ¶
    Source

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

    emit_evdlveob ¶
    Source

    emit_evdlveob :: emit_evdlveob_r_r_r

    emit_evdlveob_r_r_r ¶
    Source

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

    emit_evdlveoh ¶
    Source

    emit_evdlveoh :: emit_evdlveoh_r_r_r

    emit_evdlveoh_r_r_r ¶
    Source

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

    emit_evdlvob ¶
    Source

    emit_evdlvob :: emit_evdlvob_r_r_r

    emit_evdlvob_r_r_r ¶
    Source

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

    emit_evdlvoeb ¶
    Source

    emit_evdlvoeb :: emit_evdlvoeb_r_r_r

    emit_evdlvoeb_r_r_r ¶
    Source

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

    emit_evdlvoeh ¶
    Source

    emit_evdlvoeh :: emit_evdlvoeh_r_r_r

    emit_evdlvoeh_r_r_r ¶
    Source

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

    emit_evdlvoh ¶
    Source

    emit_evdlvoh :: emit_evdlvoh_r_r_r

    emit_evdlvoh_r_r_r ¶
    Source

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

    emit_evdotp4hgasmf ¶
    Source

    emit_evdotp4hgasmf :: emit_evdotp4hgasmf_r_r_r

    emit_evdotp4hgasmf_r_r_r ¶
    Source

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

    emit_evdotp4hgasmfa ¶
    Source

    emit_evdotp4hgasmfa :: emit_evdotp4hgasmfa_r_r_r

    emit_evdotp4hgasmfa_r_r_r ¶
    Source

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

    emit_evdotp4hgasmfaa ¶
    Source

    emit_evdotp4hgasmfaa :: emit_evdotp4hgasmfaa_r_r_r

    emit_evdotp4hgasmfaa3 ¶
    Source

    emit_evdotp4hgasmfaa3 :: emit_evdotp4hgasmfaa3_r_r_r

    emit_evdotp4hgasmfaa3_r_r_r ¶
    Source

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

    emit_evdotp4hgasmfaa_r_r_r ¶
    Source

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

    emit_evdotp4hgasmi ¶
    Source

    emit_evdotp4hgasmi :: emit_evdotp4hgasmi_r_r_r

    emit_evdotp4hgasmi_r_r_r ¶
    Source

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

    emit_evdotp4hgasmia ¶
    Source

    emit_evdotp4hgasmia :: emit_evdotp4hgasmia_r_r_r

    emit_evdotp4hgasmia_r_r_r ¶
    Source

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

    emit_evdotp4hgasmiaa ¶
    Source

    emit_evdotp4hgasmiaa :: emit_evdotp4hgasmiaa_r_r_r

    emit_evdotp4hgasmiaa3 ¶
    Source

    emit_evdotp4hgasmiaa3 :: emit_evdotp4hgasmiaa3_r_r_r

    emit_evdotp4hgasmiaa3_r_r_r ¶
    Source

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

    emit_evdotp4hgasmiaa_r_r_r ¶
    Source

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

    emit_evdotp4hgasumi ¶
    Source

    emit_evdotp4hgasumi :: emit_evdotp4hgasumi_r_r_r

    emit_evdotp4hgasumi_r_r_r ¶
    Source

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

    emit_evdotp4hgasumia ¶
    Source

    emit_evdotp4hgasumia :: emit_evdotp4hgasumia_r_r_r

    emit_evdotp4hgasumia_r_r_r ¶
    Source

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

    emit_evdotp4hgasumiaa ¶
    Source

    emit_evdotp4hgasumiaa :: emit_evdotp4hgasumiaa_r_r_r

    emit_evdotp4hgasumiaa3 ¶
    Source

    emit_evdotp4hgasumiaa3 :: emit_evdotp4hgasumiaa3_r_r_r

    emit_evdotp4hgasumiaa3_r_r_r ¶
    Source

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

    emit_evdotp4hgasumiaa_r_r_r ¶
    Source

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

    emit_evdotp4hgaumi ¶
    Source

    emit_evdotp4hgaumi :: emit_evdotp4hgaumi_r_r_r

    emit_evdotp4hgaumi_r_r_r ¶
    Source

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

    emit_evdotp4hgaumia ¶
    Source

    emit_evdotp4hgaumia :: emit_evdotp4hgaumia_r_r_r

    emit_evdotp4hgaumia_r_r_r ¶
    Source

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

    emit_evdotp4hgaumiaa ¶
    Source

    emit_evdotp4hgaumiaa :: emit_evdotp4hgaumiaa_r_r_r

    emit_evdotp4hgaumiaa3 ¶
    Source

    emit_evdotp4hgaumiaa3 :: emit_evdotp4hgaumiaa3_r_r_r

    emit_evdotp4hgaumiaa3_r_r_r ¶
    Source

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

    emit_evdotp4hgaumiaa_r_r_r ¶
    Source

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

    emit_evdotp4hgssmf ¶
    Source

    emit_evdotp4hgssmf :: emit_evdotp4hgssmf_r_r_r

    emit_evdotp4hgssmf_r_r_r ¶
    Source

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

    emit_evdotp4hgssmfa ¶
    Source

    emit_evdotp4hgssmfa :: emit_evdotp4hgssmfa_r_r_r

    emit_evdotp4hgssmfa_r_r_r ¶
    Source

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

    emit_evdotp4hgssmfaa ¶
    Source

    emit_evdotp4hgssmfaa :: emit_evdotp4hgssmfaa_r_r_r

    emit_evdotp4hgssmfaa3 ¶
    Source

    emit_evdotp4hgssmfaa3 :: emit_evdotp4hgssmfaa3_r_r_r

    emit_evdotp4hgssmfaa3_r_r_r ¶
    Source

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

    emit_evdotp4hgssmfaa_r_r_r ¶
    Source

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

    emit_evdotp4hgssmi ¶
    Source

    emit_evdotp4hgssmi :: emit_evdotp4hgssmi_r_r_r

    emit_evdotp4hgssmi_r_r_r ¶
    Source

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

    emit_evdotp4hgssmia ¶
    Source

    emit_evdotp4hgssmia :: emit_evdotp4hgssmia_r_r_r

    emit_evdotp4hgssmia_r_r_r ¶
    Source

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

    emit_evdotp4hgssmiaa ¶
    Source

    emit_evdotp4hgssmiaa :: emit_evdotp4hgssmiaa_r_r_r

    emit_evdotp4hgssmiaa3 ¶
    Source

    emit_evdotp4hgssmiaa3 :: emit_evdotp4hgssmiaa3_r_r_r

    emit_evdotp4hgssmiaa3_r_r_r ¶
    Source

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

    emit_evdotp4hgssmiaa_r_r_r ¶
    Source

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

    emit_evdotp4hxgasmf ¶
    Source

    emit_evdotp4hxgasmf :: emit_evdotp4hxgasmf_r_r_r

    emit_evdotp4hxgasmf_r_r_r ¶
    Source

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

    emit_evdotp4hxgasmfa ¶
    Source

    emit_evdotp4hxgasmfa :: emit_evdotp4hxgasmfa_r_r_r

    emit_evdotp4hxgasmfa_r_r_r ¶
    Source

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

    emit_evdotp4hxgasmfaa ¶
    Source

    emit_evdotp4hxgasmfaa :: emit_evdotp4hxgasmfaa_r_r_r

    emit_evdotp4hxgasmfaa3 ¶
    Source

    emit_evdotp4hxgasmfaa3 :: emit_evdotp4hxgasmfaa3_r_r_r

    emit_evdotp4hxgasmfaa3_r_r_r ¶
    Source

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

    emit_evdotp4hxgasmfaa_r_r_r ¶
    Source

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

    emit_evdotp4hxgasmi ¶
    Source

    emit_evdotp4hxgasmi :: emit_evdotp4hxgasmi_r_r_r

    emit_evdotp4hxgasmi_r_r_r ¶
    Source

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

    emit_evdotp4hxgasmia ¶
    Source

    emit_evdotp4hxgasmia :: emit_evdotp4hxgasmia_r_r_r

    emit_evdotp4hxgasmia_r_r_r ¶
    Source

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

    emit_evdotp4hxgasmiaa ¶
    Source

    emit_evdotp4hxgasmiaa :: emit_evdotp4hxgasmiaa_r_r_r

    emit_evdotp4hxgasmiaa3 ¶
    Source

    emit_evdotp4hxgasmiaa3 :: emit_evdotp4hxgasmiaa3_r_r_r

    emit_evdotp4hxgasmiaa3_r_r_r ¶
    Source

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

    emit_evdotp4hxgasmiaa_r_r_r ¶
    Source

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

    emit_evdotp4hxgssmf ¶
    Source

    emit_evdotp4hxgssmf :: emit_evdotp4hxgssmf_r_r_r

    emit_evdotp4hxgssmf_r_r_r ¶
    Source

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

    emit_evdotp4hxgssmfa ¶
    Source

    emit_evdotp4hxgssmfa :: emit_evdotp4hxgssmfa_r_r_r

    emit_evdotp4hxgssmfa_r_r_r ¶
    Source

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

    emit_evdotp4hxgssmfaa ¶
    Source

    emit_evdotp4hxgssmfaa :: emit_evdotp4hxgssmfaa_r_r_r

    emit_evdotp4hxgssmfaa3 ¶
    Source

    emit_evdotp4hxgssmfaa3 :: emit_evdotp4hxgssmfaa3_r_r_r

    emit_evdotp4hxgssmfaa3_r_r_r ¶
    Source

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

    emit_evdotp4hxgssmfaa_r_r_r ¶
    Source

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

    emit_evdotp4hxgssmi ¶
    Source

    emit_evdotp4hxgssmi :: emit_evdotp4hxgssmi_r_r_r

    emit_evdotp4hxgssmi_r_r_r ¶
    Source

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

    emit_evdotp4hxgssmia ¶
    Source

    emit_evdotp4hxgssmia :: emit_evdotp4hxgssmia_r_r_r

    emit_evdotp4hxgssmia_r_r_r ¶
    Source

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

    emit_evdotp4hxgssmiaa ¶
    Source

    emit_evdotp4hxgssmiaa :: emit_evdotp4hxgssmiaa_r_r_r

    emit_evdotp4hxgssmiaa3 ¶
    Source

    emit_evdotp4hxgssmiaa3 :: emit_evdotp4hxgssmiaa3_r_r_r

    emit_evdotp4hxgssmiaa3_r_r_r ¶
    Source

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

    emit_evdotp4hxgssmiaa_r_r_r ¶
    Source

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

    emit_evdotpbasmi ¶
    Source

    emit_evdotpbasmi :: emit_evdotpbasmi_r_r_r

    emit_evdotpbasmi_r_r_r ¶
    Source

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

    emit_evdotpbasmia ¶
    Source

    emit_evdotpbasmia :: emit_evdotpbasmia_r_r_r

    emit_evdotpbasmia_r_r_r ¶
    Source

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

    emit_evdotpbasmiaaw ¶
    Source

    emit_evdotpbasmiaaw :: emit_evdotpbasmiaaw_r_r_r

    emit_evdotpbasmiaaw3 ¶
    Source

    emit_evdotpbasmiaaw3 :: emit_evdotpbasmiaaw3_r_r_r

    emit_evdotpbasmiaaw3_r_r_r ¶
    Source

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

    emit_evdotpbasmiaaw_r_r_r ¶
    Source

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

    emit_evdotpbasumi ¶
    Source

    emit_evdotpbasumi :: emit_evdotpbasumi_r_r_r

    emit_evdotpbasumi_r_r_r ¶
    Source

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

    emit_evdotpbasumia ¶
    Source

    emit_evdotpbasumia :: emit_evdotpbasumia_r_r_r

    emit_evdotpbasumia_r_r_r ¶
    Source

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

    emit_evdotpbasumiaaw ¶
    Source

    emit_evdotpbasumiaaw :: emit_evdotpbasumiaaw_r_r_r

    emit_evdotpbasumiaaw3 ¶
    Source

    emit_evdotpbasumiaaw3 :: emit_evdotpbasumiaaw3_r_r_r

    emit_evdotpbasumiaaw3_r_r_r ¶
    Source

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

    emit_evdotpbasumiaaw_r_r_r ¶
    Source

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

    emit_evdotpbaumi ¶
    Source

    emit_evdotpbaumi :: emit_evdotpbaumi_r_r_r

    emit_evdotpbaumi_r_r_r ¶
    Source

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

    emit_evdotpbaumia ¶
    Source

    emit_evdotpbaumia :: emit_evdotpbaumia_r_r_r

    emit_evdotpbaumia_r_r_r ¶
    Source

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

    emit_evdotpbaumiaaw ¶
    Source

    emit_evdotpbaumiaaw :: emit_evdotpbaumiaaw_r_r_r

    emit_evdotpbaumiaaw3 ¶
    Source

    emit_evdotpbaumiaaw3 :: emit_evdotpbaumiaaw3_r_r_r

    emit_evdotpbaumiaaw3_r_r_r ¶
    Source

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

    emit_evdotpbaumiaaw_r_r_r ¶
    Source

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

    emit_evdotphasmi ¶
    Source

    emit_evdotphasmi :: emit_evdotphasmi_r_r_r

    emit_evdotphasmi_r_r_r ¶
    Source

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

    emit_evdotphasmia ¶
    Source

    emit_evdotphasmia :: emit_evdotphasmia_r_r_r

    emit_evdotphasmia_r_r_r ¶
    Source

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

    emit_evdotphasmiaaw ¶
    Source

    emit_evdotphasmiaaw :: emit_evdotphasmiaaw_r_r_r

    emit_evdotphasmiaaw3 ¶
    Source

    emit_evdotphasmiaaw3 :: emit_evdotphasmiaaw3_r_r_r

    emit_evdotphasmiaaw3_r_r_r ¶
    Source

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

    emit_evdotphasmiaaw_r_r_r ¶
    Source

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

    emit_evdotphassf ¶
    Source

    emit_evdotphassf :: emit_evdotphassf_r_r_r

    emit_evdotphassf_r_r_r ¶
    Source

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

    emit_evdotphassfa ¶
    Source

    emit_evdotphassfa :: emit_evdotphassfa_r_r_r

    emit_evdotphassfa_r_r_r ¶
    Source

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

    emit_evdotphassfaaw ¶
    Source

    emit_evdotphassfaaw :: emit_evdotphassfaaw_r_r_r

    emit_evdotphassfaaw3 ¶
    Source

    emit_evdotphassfaaw3 :: emit_evdotphassfaaw3_r_r_r

    emit_evdotphassfaaw3_r_r_r ¶
    Source

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

    emit_evdotphassfaaw_r_r_r ¶
    Source

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

    emit_evdotphassfr ¶
    Source

    emit_evdotphassfr :: emit_evdotphassfr_r_r_r

    emit_evdotphassfr_r_r_r ¶
    Source

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

    emit_evdotphassfra ¶
    Source

    emit_evdotphassfra :: emit_evdotphassfra_r_r_r

    emit_evdotphassfra_r_r_r ¶
    Source

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

    emit_evdotphassfraaw ¶
    Source

    emit_evdotphassfraaw :: emit_evdotphassfraaw_r_r_r

    emit_evdotphassfraaw3 ¶
    Source

    emit_evdotphassfraaw3 :: emit_evdotphassfraaw3_r_r_r

    emit_evdotphassfraaw3_r_r_r ¶
    Source

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

    emit_evdotphassfraaw_r_r_r ¶
    Source

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

    emit_evdotphassi ¶
    Source

    emit_evdotphassi :: emit_evdotphassi_r_r_r

    emit_evdotphassi_r_r_r ¶
    Source

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

    emit_evdotphassia ¶
    Source

    emit_evdotphassia :: emit_evdotphassia_r_r_r

    emit_evdotphassia_r_r_r ¶
    Source

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

    emit_evdotphassiaaw ¶
    Source

    emit_evdotphassiaaw :: emit_evdotphassiaaw_r_r_r

    emit_evdotphassiaaw3 ¶
    Source

    emit_evdotphassiaaw3 :: emit_evdotphassiaaw3_r_r_r

    emit_evdotphassiaaw3_r_r_r ¶
    Source

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

    emit_evdotphassiaaw_r_r_r ¶
    Source

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

    emit_evdotphasumi ¶
    Source

    emit_evdotphasumi :: emit_evdotphasumi_r_r_r

    emit_evdotphasumi_r_r_r ¶
    Source

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

    emit_evdotphasumia ¶
    Source

    emit_evdotphasumia :: emit_evdotphasumia_r_r_r

    emit_evdotphasumia_r_r_r ¶
    Source

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

    emit_evdotphasumiaaw ¶
    Source

    emit_evdotphasumiaaw :: emit_evdotphasumiaaw_r_r_r

    emit_evdotphasumiaaw3 ¶
    Source

    emit_evdotphasumiaaw3 :: emit_evdotphasumiaaw3_r_r_r

    emit_evdotphasumiaaw3_r_r_r ¶
    Source

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

    emit_evdotphasumiaaw_r_r_r ¶
    Source

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

    emit_evdotphasusi ¶
    Source

    emit_evdotphasusi :: emit_evdotphasusi_r_r_r

    emit_evdotphasusi_r_r_r ¶
    Source

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

    emit_evdotphasusia ¶
    Source

    emit_evdotphasusia :: emit_evdotphasusia_r_r_r

    emit_evdotphasusia_r_r_r ¶
    Source

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

    emit_evdotphasusiaaw ¶
    Source

    emit_evdotphasusiaaw :: emit_evdotphasusiaaw_r_r_r

    emit_evdotphasusiaaw3 ¶
    Source

    emit_evdotphasusiaaw3 :: emit_evdotphasusiaaw3_r_r_r

    emit_evdotphasusiaaw3_r_r_r ¶
    Source

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

    emit_evdotphasusiaaw_r_r_r ¶
    Source

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

    emit_evdotphaumi ¶
    Source

    emit_evdotphaumi :: emit_evdotphaumi_r_r_r

    emit_evdotphaumi_r_r_r ¶
    Source

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

    emit_evdotphaumia ¶
    Source

    emit_evdotphaumia :: emit_evdotphaumia_r_r_r

    emit_evdotphaumia_r_r_r ¶
    Source

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

    emit_evdotphaumiaaw ¶
    Source

    emit_evdotphaumiaaw :: emit_evdotphaumiaaw_r_r_r

    emit_evdotphaumiaaw3 ¶
    Source

    emit_evdotphaumiaaw3 :: emit_evdotphaumiaaw3_r_r_r

    emit_evdotphaumiaaw3_r_r_r ¶
    Source

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

    emit_evdotphaumiaaw_r_r_r ¶
    Source

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

    emit_evdotphausi ¶
    Source

    emit_evdotphausi :: emit_evdotphausi_r_r_r

    emit_evdotphausi_r_r_r ¶
    Source

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

    emit_evdotphausia ¶
    Source

    emit_evdotphausia :: emit_evdotphausia_r_r_r

    emit_evdotphausia_r_r_r ¶
    Source

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

    emit_evdotphausiaaw ¶
    Source

    emit_evdotphausiaaw :: emit_evdotphausiaaw_r_r_r

    emit_evdotphausiaaw3 ¶
    Source

    emit_evdotphausiaaw3 :: emit_evdotphausiaaw3_r_r_r

    emit_evdotphausiaaw3_r_r_r ¶
    Source

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

    emit_evdotphausiaaw_r_r_r ¶
    Source

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

    emit_evdotphihcsmi ¶
    Source

    emit_evdotphihcsmi :: emit_evdotphihcsmi_r_r_r

    emit_evdotphihcsmi_r_r_r ¶
    Source

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

    emit_evdotphihcsmia ¶
    Source

    emit_evdotphihcsmia :: emit_evdotphihcsmia_r_r_r

    emit_evdotphihcsmia_r_r_r ¶
    Source

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

    emit_evdotphihcsmiaaw ¶
    Source

    emit_evdotphihcsmiaaw :: emit_evdotphihcsmiaaw_r_r_r

    emit_evdotphihcsmiaaw3 ¶
    Source

    emit_evdotphihcsmiaaw3 :: emit_evdotphihcsmiaaw3_r_r_r

    emit_evdotphihcsmiaaw3_r_r_r ¶
    Source

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

    emit_evdotphihcsmiaaw_r_r_r ¶
    Source

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

    emit_evdotphihcssf ¶
    Source

    emit_evdotphihcssf :: emit_evdotphihcssf_r_r_r

    emit_evdotphihcssf_r_r_r ¶
    Source

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

    emit_evdotphihcssfa ¶
    Source

    emit_evdotphihcssfa :: emit_evdotphihcssfa_r_r_r

    emit_evdotphihcssfa_r_r_r ¶
    Source

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

    emit_evdotphihcssfaaw ¶
    Source

    emit_evdotphihcssfaaw :: emit_evdotphihcssfaaw_r_r_r

    emit_evdotphihcssfaaw3 ¶
    Source

    emit_evdotphihcssfaaw3 :: emit_evdotphihcssfaaw3_r_r_r

    emit_evdotphihcssfaaw3_r_r_r ¶
    Source

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

    emit_evdotphihcssfaaw_r_r_r ¶
    Source

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

    emit_evdotphihcssfr ¶
    Source

    emit_evdotphihcssfr :: emit_evdotphihcssfr_r_r_r

    emit_evdotphihcssfr_r_r_r ¶
    Source

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

    emit_evdotphihcssfra ¶
    Source

    emit_evdotphihcssfra :: emit_evdotphihcssfra_r_r_r

    emit_evdotphihcssfra_r_r_r ¶
    Source

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

    emit_evdotphihcssfraaw ¶
    Source

    emit_evdotphihcssfraaw :: emit_evdotphihcssfraaw_r_r_r

    emit_evdotphihcssfraaw3 ¶
    Source

    emit_evdotphihcssfraaw3 :: emit_evdotphihcssfraaw3_r_r_r

    emit_evdotphihcssfraaw3_r_r_r ¶
    Source

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

    emit_evdotphihcssfraaw_r_r_r ¶
    Source

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

    emit_evdotphihcssi ¶
    Source

    emit_evdotphihcssi :: emit_evdotphihcssi_r_r_r

    emit_evdotphihcssi_r_r_r ¶
    Source

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

    emit_evdotphihcssia ¶
    Source

    emit_evdotphihcssia :: emit_evdotphihcssia_r_r_r

    emit_evdotphihcssia_r_r_r ¶
    Source

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

    emit_evdotphihcssiaaw ¶
    Source

    emit_evdotphihcssiaaw :: emit_evdotphihcssiaaw_r_r_r

    emit_evdotphihcssiaaw3 ¶
    Source

    emit_evdotphihcssiaaw3 :: emit_evdotphihcssiaaw3_r_r_r

    emit_evdotphihcssiaaw3_r_r_r ¶
    Source

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

    emit_evdotphihcssiaaw_r_r_r ¶
    Source

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

    emit_evdotphssmi ¶
    Source

    emit_evdotphssmi :: emit_evdotphssmi_r_r_r

    emit_evdotphssmi_r_r_r ¶
    Source

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

    emit_evdotphssmia ¶
    Source

    emit_evdotphssmia :: emit_evdotphssmia_r_r_r

    emit_evdotphssmia_r_r_r ¶
    Source

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

    emit_evdotphssmiaaw ¶
    Source

    emit_evdotphssmiaaw :: emit_evdotphssmiaaw_r_r_r

    emit_evdotphssmiaaw3 ¶
    Source

    emit_evdotphssmiaaw3 :: emit_evdotphssmiaaw3_r_r_r

    emit_evdotphssmiaaw3_r_r_r ¶
    Source

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

    emit_evdotphssmiaaw_r_r_r ¶
    Source

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

    emit_evdotphsssf ¶
    Source

    emit_evdotphsssf :: emit_evdotphsssf_r_r_r

    emit_evdotphsssf_r_r_r ¶
    Source

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

    emit_evdotphsssfa ¶
    Source

    emit_evdotphsssfa :: emit_evdotphsssfa_r_r_r

    emit_evdotphsssfa_r_r_r ¶
    Source

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

    emit_evdotphsssfaaw ¶
    Source

    emit_evdotphsssfaaw :: emit_evdotphsssfaaw_r_r_r

    emit_evdotphsssfaaw3 ¶
    Source

    emit_evdotphsssfaaw3 :: emit_evdotphsssfaaw3_r_r_r

    emit_evdotphsssfaaw3_r_r_r ¶
    Source

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

    emit_evdotphsssfaaw_r_r_r ¶
    Source

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

    emit_evdotphsssfr ¶
    Source

    emit_evdotphsssfr :: emit_evdotphsssfr_r_r_r

    emit_evdotphsssfr_r_r_r ¶
    Source

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

    emit_evdotphsssfra ¶
    Source

    emit_evdotphsssfra :: emit_evdotphsssfra_r_r_r

    emit_evdotphsssfra_r_r_r ¶
    Source

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

    emit_evdotphsssfraaw ¶
    Source

    emit_evdotphsssfraaw :: emit_evdotphsssfraaw_r_r_r

    emit_evdotphsssfraaw3 ¶
    Source

    emit_evdotphsssfraaw3 :: emit_evdotphsssfraaw3_r_r_r

    emit_evdotphsssfraaw3_r_r_r ¶
    Source

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

    emit_evdotphsssfraaw_r_r_r ¶
    Source

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

    emit_evdotphsssi ¶
    Source

    emit_evdotphsssi :: emit_evdotphsssi_r_r_r

    emit_evdotphsssi_r_r_r ¶
    Source

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

    emit_evdotphsssia ¶
    Source

    emit_evdotphsssia :: emit_evdotphsssia_r_r_r

    emit_evdotphsssia_r_r_r ¶
    Source

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

    emit_evdotphsssiaaw ¶
    Source

    emit_evdotphsssiaaw :: emit_evdotphsssiaaw_r_r_r

    emit_evdotphsssiaaw3 ¶
    Source

    emit_evdotphsssiaaw3 :: emit_evdotphsssiaaw3_r_r_r

    emit_evdotphsssiaaw3_r_r_r ¶
    Source

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

    emit_evdotphsssiaaw_r_r_r ¶
    Source

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

    emit_evdotplohcsmi ¶
    Source

    emit_evdotplohcsmi :: emit_evdotplohcsmi_r_r_r

    emit_evdotplohcsmi_r_r_r ¶
    Source

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

    emit_evdotplohcsmia ¶
    Source

    emit_evdotplohcsmia :: emit_evdotplohcsmia_r_r_r

    emit_evdotplohcsmia_r_r_r ¶
    Source

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

    emit_evdotplohcsmiaaw ¶
    Source

    emit_evdotplohcsmiaaw :: emit_evdotplohcsmiaaw_r_r_r

    emit_evdotplohcsmiaaw3 ¶
    Source

    emit_evdotplohcsmiaaw3 :: emit_evdotplohcsmiaaw3_r_r_r

    emit_evdotplohcsmiaaw3_r_r_r ¶
    Source

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

    emit_evdotplohcsmiaaw_r_r_r ¶
    Source

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

    emit_evdotplohcssf ¶
    Source

    emit_evdotplohcssf :: emit_evdotplohcssf_r_r_r

    emit_evdotplohcssf_r_r_r ¶
    Source

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

    emit_evdotplohcssfa ¶
    Source

    emit_evdotplohcssfa :: emit_evdotplohcssfa_r_r_r

    emit_evdotplohcssfa_r_r_r ¶
    Source

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

    emit_evdotplohcssfaaw ¶
    Source

    emit_evdotplohcssfaaw :: emit_evdotplohcssfaaw_r_r_r

    emit_evdotplohcssfaaw3 ¶
    Source

    emit_evdotplohcssfaaw3 :: emit_evdotplohcssfaaw3_r_r_r

    emit_evdotplohcssfaaw3_r_r_r ¶
    Source

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

    emit_evdotplohcssfaaw_r_r_r ¶
    Source

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

    emit_evdotplohcssfr ¶
    Source

    emit_evdotplohcssfr :: emit_evdotplohcssfr_r_r_r

    emit_evdotplohcssfr_r_r_r ¶
    Source

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

    emit_evdotplohcssfra ¶
    Source

    emit_evdotplohcssfra :: emit_evdotplohcssfra_r_r_r

    emit_evdotplohcssfra_r_r_r ¶
    Source

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

    emit_evdotplohcssfraaw ¶
    Source

    emit_evdotplohcssfraaw :: emit_evdotplohcssfraaw_r_r_r

    emit_evdotplohcssfraaw3 ¶
    Source

    emit_evdotplohcssfraaw3 :: emit_evdotplohcssfraaw3_r_r_r

    emit_evdotplohcssfraaw3_r_r_r ¶
    Source

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

    emit_evdotplohcssfraaw_r_r_r ¶
    Source

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

    emit_evdotplohcssi ¶
    Source

    emit_evdotplohcssi :: emit_evdotplohcssi_r_r_r

    emit_evdotplohcssi_r_r_r ¶
    Source

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

    emit_evdotplohcssia ¶
    Source

    emit_evdotplohcssia :: emit_evdotplohcssia_r_r_r

    emit_evdotplohcssia_r_r_r ¶
    Source

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

    emit_evdotplohcssiaaw ¶
    Source

    emit_evdotplohcssiaaw :: emit_evdotplohcssiaaw_r_r_r

    emit_evdotplohcssiaaw3 ¶
    Source

    emit_evdotplohcssiaaw3 :: emit_evdotplohcssiaaw3_r_r_r

    emit_evdotplohcssiaaw3_r_r_r ¶
    Source

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

    emit_evdotplohcssiaaw_r_r_r ¶
    Source

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

    emit_evdotpwasmi ¶
    Source

    emit_evdotpwasmi :: emit_evdotpwasmi_r_r_r

    emit_evdotpwasmi_r_r_r ¶
    Source

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

    emit_evdotpwasmia ¶
    Source

    emit_evdotpwasmia :: emit_evdotpwasmia_r_r_r

    emit_evdotpwasmia_r_r_r ¶
    Source

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

    emit_evdotpwasmiaa ¶
    Source

    emit_evdotpwasmiaa :: emit_evdotpwasmiaa_r_r_r

    emit_evdotpwasmiaa3 ¶
    Source

    emit_evdotpwasmiaa3 :: emit_evdotpwasmiaa3_r_r_r

    emit_evdotpwasmiaa3_r_r_r ¶
    Source

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

    emit_evdotpwasmiaa_r_r_r ¶
    Source

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

    emit_evdotpwassi ¶
    Source

    emit_evdotpwassi :: emit_evdotpwassi_r_r_r

    emit_evdotpwassi_r_r_r ¶
    Source

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

    emit_evdotpwassia ¶
    Source

    emit_evdotpwassia :: emit_evdotpwassia_r_r_r

    emit_evdotpwassia_r_r_r ¶
    Source

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

    emit_evdotpwassiaa ¶
    Source

    emit_evdotpwassiaa :: emit_evdotpwassiaa_r_r_r

    emit_evdotpwassiaa3 ¶
    Source

    emit_evdotpwassiaa3 :: emit_evdotpwassiaa3_r_r_r

    emit_evdotpwassiaa3_r_r_r ¶
    Source

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

    emit_evdotpwassiaa_r_r_r ¶
    Source

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

    emit_evdotpwasumi ¶
    Source

    emit_evdotpwasumi :: emit_evdotpwasumi_r_r_r

    emit_evdotpwasumi_r_r_r ¶
    Source

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

    emit_evdotpwasumia ¶
    Source

    emit_evdotpwasumia :: emit_evdotpwasumia_r_r_r

    emit_evdotpwasumia_r_r_r ¶
    Source

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

    emit_evdotpwasumiaa ¶
    Source

    emit_evdotpwasumiaa :: emit_evdotpwasumiaa_r_r_r

    emit_evdotpwasumiaa3 ¶
    Source

    emit_evdotpwasumiaa3 :: emit_evdotpwasumiaa3_r_r_r

    emit_evdotpwasumiaa3_r_r_r ¶
    Source

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

    emit_evdotpwasumiaa_r_r_r ¶
    Source

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

    emit_evdotpwasusi ¶
    Source

    emit_evdotpwasusi :: emit_evdotpwasusi_r_r_r

    emit_evdotpwasusi_r_r_r ¶
    Source

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

    emit_evdotpwasusia ¶
    Source

    emit_evdotpwasusia :: emit_evdotpwasusia_r_r_r

    emit_evdotpwasusia_r_r_r ¶
    Source

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

    emit_evdotpwasusiaa ¶
    Source

    emit_evdotpwasusiaa :: emit_evdotpwasusiaa_r_r_r

    emit_evdotpwasusiaa3 ¶
    Source

    emit_evdotpwasusiaa3 :: emit_evdotpwasusiaa3_r_r_r

    emit_evdotpwasusiaa3_r_r_r ¶
    Source

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

    emit_evdotpwasusiaa_r_r_r ¶
    Source

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

    emit_evdotpwaumi ¶
    Source

    emit_evdotpwaumi :: emit_evdotpwaumi_r_r_r

    emit_evdotpwaumi_r_r_r ¶
    Source

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

    emit_evdotpwaumia ¶
    Source

    emit_evdotpwaumia :: emit_evdotpwaumia_r_r_r

    emit_evdotpwaumia_r_r_r ¶
    Source

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

    emit_evdotpwaumiaa ¶
    Source

    emit_evdotpwaumiaa :: emit_evdotpwaumiaa_r_r_r

    emit_evdotpwaumiaa3 ¶
    Source

    emit_evdotpwaumiaa3 :: emit_evdotpwaumiaa3_r_r_r

    emit_evdotpwaumiaa3_r_r_r ¶
    Source

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

    emit_evdotpwaumiaa_r_r_r ¶
    Source

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

    emit_evdotpwausi ¶
    Source

    emit_evdotpwausi :: emit_evdotpwausi_r_r_r

    emit_evdotpwausi_r_r_r ¶
    Source

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

    emit_evdotpwausia ¶
    Source

    emit_evdotpwausia :: emit_evdotpwausia_r_r_r

    emit_evdotpwausia_r_r_r ¶
    Source

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

    emit_evdotpwausiaa ¶
    Source

    emit_evdotpwausiaa :: emit_evdotpwausiaa_r_r_r

    emit_evdotpwausiaa3 ¶
    Source

    emit_evdotpwausiaa3 :: emit_evdotpwausiaa3_r_r_r

    emit_evdotpwausiaa3_r_r_r ¶
    Source

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

    emit_evdotpwausiaa_r_r_r ¶
    Source

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

    emit_evdotpwcsmi ¶
    Source

    emit_evdotpwcsmi :: emit_evdotpwcsmi_r_r_r

    emit_evdotpwcsmi_r_r_r ¶
    Source

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

    emit_evdotpwcsmia ¶
    Source

    emit_evdotpwcsmia :: emit_evdotpwcsmia_r_r_r

    emit_evdotpwcsmia_r_r_r ¶
    Source

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

    emit_evdotpwcsmiaaw ¶
    Source

    emit_evdotpwcsmiaaw :: emit_evdotpwcsmiaaw_r_r_r

    emit_evdotpwcsmiaaw3 ¶
    Source

    emit_evdotpwcsmiaaw3 :: emit_evdotpwcsmiaaw3_r_r_r

    emit_evdotpwcsmiaaw3_r_r_r ¶
    Source

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

    emit_evdotpwcsmiaaw_r_r_r ¶
    Source

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

    emit_evdotpwcssf ¶
    Source

    emit_evdotpwcssf :: emit_evdotpwcssf_r_r_r

    emit_evdotpwcssf_r_r_r ¶
    Source

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

    emit_evdotpwcssfa ¶
    Source

    emit_evdotpwcssfa :: emit_evdotpwcssfa_r_r_r

    emit_evdotpwcssfa_r_r_r ¶
    Source

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

    emit_evdotpwcssfaaw ¶
    Source

    emit_evdotpwcssfaaw :: emit_evdotpwcssfaaw_r_r_r

    emit_evdotpwcssfaaw3 ¶
    Source

    emit_evdotpwcssfaaw3 :: emit_evdotpwcssfaaw3_r_r_r

    emit_evdotpwcssfaaw3_r_r_r ¶
    Source

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

    emit_evdotpwcssfaaw_r_r_r ¶
    Source

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

    emit_evdotpwcssfr ¶
    Source

    emit_evdotpwcssfr :: emit_evdotpwcssfr_r_r_r

    emit_evdotpwcssfr_r_r_r ¶
    Source

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

    emit_evdotpwcssfra ¶
    Source

    emit_evdotpwcssfra :: emit_evdotpwcssfra_r_r_r

    emit_evdotpwcssfra_r_r_r ¶
    Source

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

    emit_evdotpwcssfraaw ¶
    Source

    emit_evdotpwcssfraaw :: emit_evdotpwcssfraaw_r_r_r

    emit_evdotpwcssfraaw3 ¶
    Source

    emit_evdotpwcssfraaw3 :: emit_evdotpwcssfraaw3_r_r_r

    emit_evdotpwcssfraaw3_r_r_r ¶
    Source

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

    emit_evdotpwcssfraaw_r_r_r ¶
    Source

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

    emit_evdotpwcssi ¶
    Source

    emit_evdotpwcssi :: emit_evdotpwcssi_r_r_r

    emit_evdotpwcssi_r_r_r ¶
    Source

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

    emit_evdotpwcssia ¶
    Source

    emit_evdotpwcssia :: emit_evdotpwcssia_r_r_r

    emit_evdotpwcssia_r_r_r ¶
    Source

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

    emit_evdotpwcssiaaw ¶
    Source

    emit_evdotpwcssiaaw :: emit_evdotpwcssiaaw_r_r_r

    emit_evdotpwcssiaaw3 ¶
    Source

    emit_evdotpwcssiaaw3 :: emit_evdotpwcssiaaw3_r_r_r

    emit_evdotpwcssiaaw3_r_r_r ¶
    Source

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

    emit_evdotpwcssiaaw_r_r_r ¶
    Source

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

    emit_evdotpwgasmf ¶
    Source

    emit_evdotpwgasmf :: emit_evdotpwgasmf_r_r_r

    emit_evdotpwgasmf_r_r_r ¶
    Source

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

    emit_evdotpwgasmfa ¶
    Source

    emit_evdotpwgasmfa :: emit_evdotpwgasmfa_r_r_r

    emit_evdotpwgasmfa_r_r_r ¶
    Source

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

    emit_evdotpwgasmfaa ¶
    Source

    emit_evdotpwgasmfaa :: emit_evdotpwgasmfaa_r_r_r

    emit_evdotpwgasmfaa3 ¶
    Source

    emit_evdotpwgasmfaa3 :: emit_evdotpwgasmfaa3_r_r_r

    emit_evdotpwgasmfaa3_r_r_r ¶
    Source

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

    emit_evdotpwgasmfaa_r_r_r ¶
    Source

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

    emit_evdotpwgasmfr ¶
    Source

    emit_evdotpwgasmfr :: emit_evdotpwgasmfr_r_r_r

    emit_evdotpwgasmfr_r_r_r ¶
    Source

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

    emit_evdotpwgasmfra ¶
    Source

    emit_evdotpwgasmfra :: emit_evdotpwgasmfra_r_r_r

    emit_evdotpwgasmfra_r_r_r ¶
    Source

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

    emit_evdotpwgasmfraa ¶
    Source

    emit_evdotpwgasmfraa :: emit_evdotpwgasmfraa_r_r_r

    emit_evdotpwgasmfraa3 ¶
    Source

    emit_evdotpwgasmfraa3 :: emit_evdotpwgasmfraa3_r_r_r

    emit_evdotpwgasmfraa3_r_r_r ¶
    Source

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

    emit_evdotpwgasmfraa_r_r_r ¶
    Source

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

    emit_evdotpwgssmf ¶
    Source

    emit_evdotpwgssmf :: emit_evdotpwgssmf_r_r_r

    emit_evdotpwgssmf_r_r_r ¶
    Source

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

    emit_evdotpwgssmfa ¶
    Source

    emit_evdotpwgssmfa :: emit_evdotpwgssmfa_r_r_r

    emit_evdotpwgssmfa_r_r_r ¶
    Source

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

    emit_evdotpwgssmfaa ¶
    Source

    emit_evdotpwgssmfaa :: emit_evdotpwgssmfaa_r_r_r

    emit_evdotpwgssmfaa3 ¶
    Source

    emit_evdotpwgssmfaa3 :: emit_evdotpwgssmfaa3_r_r_r

    emit_evdotpwgssmfaa3_r_r_r ¶
    Source

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

    emit_evdotpwgssmfaa_r_r_r ¶
    Source

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

    emit_evdotpwgssmfr ¶
    Source

    emit_evdotpwgssmfr :: emit_evdotpwgssmfr_r_r_r

    emit_evdotpwgssmfr_r_r_r ¶
    Source

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

    emit_evdotpwgssmfra ¶
    Source

    emit_evdotpwgssmfra :: emit_evdotpwgssmfra_r_r_r

    emit_evdotpwgssmfra_r_r_r ¶
    Source

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

    emit_evdotpwgssmfraa ¶
    Source

    emit_evdotpwgssmfraa :: emit_evdotpwgssmfraa_r_r_r

    emit_evdotpwgssmfraa3 ¶
    Source

    emit_evdotpwgssmfraa3 :: emit_evdotpwgssmfraa3_r_r_r

    emit_evdotpwgssmfraa3_r_r_r ¶
    Source

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

    emit_evdotpwgssmfraa_r_r_r ¶
    Source

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

    emit_evdotpwssmi ¶
    Source

    emit_evdotpwssmi :: emit_evdotpwssmi_r_r_r

    emit_evdotpwssmi_r_r_r ¶
    Source

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

    emit_evdotpwssmia ¶
    Source

    emit_evdotpwssmia :: emit_evdotpwssmia_r_r_r

    emit_evdotpwssmia_r_r_r ¶
    Source

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

    emit_evdotpwssmiaa ¶
    Source

    emit_evdotpwssmiaa :: emit_evdotpwssmiaa_r_r_r

    emit_evdotpwssmiaa3 ¶
    Source

    emit_evdotpwssmiaa3 :: emit_evdotpwssmiaa3_r_r_r

    emit_evdotpwssmiaa3_r_r_r ¶
    Source

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

    emit_evdotpwssmiaa_r_r_r ¶
    Source

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

    emit_evdotpwsssi ¶
    Source

    emit_evdotpwsssi :: emit_evdotpwsssi_r_r_r

    emit_evdotpwsssi_r_r_r ¶
    Source

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

    emit_evdotpwsssia ¶
    Source

    emit_evdotpwsssia :: emit_evdotpwsssia_r_r_r

    emit_evdotpwsssia_r_r_r ¶
    Source

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

    emit_evdotpwsssiaa ¶
    Source

    emit_evdotpwsssiaa :: emit_evdotpwsssiaa_r_r_r

    emit_evdotpwsssiaa3 ¶
    Source

    emit_evdotpwsssiaa3 :: emit_evdotpwsssiaa3_r_r_r

    emit_evdotpwsssiaa3_r_r_r ¶
    Source

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

    emit_evdotpwsssiaa_r_r_r ¶
    Source

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

    emit_evdotpwxgasmf ¶
    Source

    emit_evdotpwxgasmf :: emit_evdotpwxgasmf_r_r_r

    emit_evdotpwxgasmf_r_r_r ¶
    Source

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

    emit_evdotpwxgasmfa ¶
    Source

    emit_evdotpwxgasmfa :: emit_evdotpwxgasmfa_r_r_r

    emit_evdotpwxgasmfa_r_r_r ¶
    Source

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

    emit_evdotpwxgasmfaa ¶
    Source

    emit_evdotpwxgasmfaa :: emit_evdotpwxgasmfaa_r_r_r

    emit_evdotpwxgasmfaa3 ¶
    Source

    emit_evdotpwxgasmfaa3 :: emit_evdotpwxgasmfaa3_r_r_r

    emit_evdotpwxgasmfaa3_r_r_r ¶
    Source

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

    emit_evdotpwxgasmfaa_r_r_r ¶
    Source

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

    emit_evdotpwxgasmfr ¶
    Source

    emit_evdotpwxgasmfr :: emit_evdotpwxgasmfr_r_r_r

    emit_evdotpwxgasmfr_r_r_r ¶
    Source

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

    emit_evdotpwxgasmfra ¶
    Source

    emit_evdotpwxgasmfra :: emit_evdotpwxgasmfra_r_r_r

    emit_evdotpwxgasmfra_r_r_r ¶
    Source

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

    emit_evdotpwxgasmfraa ¶
    Source

    emit_evdotpwxgasmfraa :: emit_evdotpwxgasmfraa_r_r_r

    emit_evdotpwxgasmfraa3 ¶
    Source

    emit_evdotpwxgasmfraa3 :: emit_evdotpwxgasmfraa3_r_r_r

    emit_evdotpwxgasmfraa3_r_r_r ¶
    Source

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

    emit_evdotpwxgasmfraa_r_r_r ¶
    Source

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

    emit_evdotpwxgssmf ¶
    Source

    emit_evdotpwxgssmf :: emit_evdotpwxgssmf_r_r_r

    emit_evdotpwxgssmf_r_r_r ¶
    Source

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

    emit_evdotpwxgssmfa ¶
    Source

    emit_evdotpwxgssmfa :: emit_evdotpwxgssmfa_r_r_r

    emit_evdotpwxgssmfa_r_r_r ¶
    Source

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

    emit_evdotpwxgssmfaa ¶
    Source

    emit_evdotpwxgssmfaa :: emit_evdotpwxgssmfaa_r_r_r

    emit_evdotpwxgssmfaa3 ¶
    Source

    emit_evdotpwxgssmfaa3 :: emit_evdotpwxgssmfaa3_r_r_r

    emit_evdotpwxgssmfaa3_r_r_r ¶
    Source

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

    emit_evdotpwxgssmfaa_r_r_r ¶
    Source

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

    emit_evdotpwxgssmfr ¶
    Source

    emit_evdotpwxgssmfr :: emit_evdotpwxgssmfr_r_r_r

    emit_evdotpwxgssmfr_r_r_r ¶
    Source

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

    emit_evdotpwxgssmfra ¶
    Source

    emit_evdotpwxgssmfra :: emit_evdotpwxgssmfra_r_r_r

    emit_evdotpwxgssmfra_r_r_r ¶
    Source

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

    emit_evdotpwxgssmfraa ¶
    Source

    emit_evdotpwxgssmfraa :: emit_evdotpwxgssmfraa_r_r_r

    emit_evdotpwxgssmfraa3 ¶
    Source

    emit_evdotpwxgssmfraa3 :: emit_evdotpwxgssmfraa3_r_r_r

    emit_evdotpwxgssmfraa3_r_r_r ¶
    Source

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

    emit_evdotpwxgssmfraa_r_r_r ¶
    Source

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

    emit_eveqv ¶
    Source

    emit_eveqv :: emit_eveqv_r_r_r

    emit_eveqv_r_r_r ¶
    Source

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

    emit_evextsb ¶
    Source

    emit_evextsb :: emit_evextsb_r_r

    emit_evextsb_r_r ¶
    Source

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

    emit_evextsbh ¶
    Source

    emit_evextsbh :: emit_evextsbh_r_r_r

    emit_evextsbh_r_r_r ¶
    Source

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

    emit_evextsh ¶
    Source

    emit_evextsh :: emit_evextsh_r_r

    emit_evextsh_r_r ¶
    Source

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

    emit_evextsw ¶
    Source

    emit_evextsw :: emit_evextsw_r_r_r

    emit_evextsw_r_r_r ¶
    Source

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

    emit_evextzb ¶
    Source

    emit_evextzb :: emit_evextzb_r_r_r

    emit_evextzb_r_r_r ¶
    Source

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

    emit_evfsabs ¶
    Source

    emit_evfsabs :: emit_evfsabs_r_r

    emit_evfsabs_r_r ¶
    Source

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

    emit_evfsadd ¶
    Source

    emit_evfsadd :: emit_evfsadd_r_r_r

    emit_evfsadd_r_r_r ¶
    Source

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

    emit_evfsaddsub ¶
    Source

    emit_evfsaddsub :: emit_evfsaddsub_r_r_r

    emit_evfsaddsub_r_r_r ¶
    Source

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

    emit_evfsaddsubx ¶
    Source

    emit_evfsaddsubx :: emit_evfsaddsubx_r_r_r

    emit_evfsaddsubx_r_r_r ¶
    Source

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

    emit_evfsaddx ¶
    Source

    emit_evfsaddx :: emit_evfsaddx_r_r_r

    emit_evfsaddx_r_r_r ¶
    Source

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

    emit_evfscfh ¶
    Source

    emit_evfscfh :: emit_evfscfh_r_r

    emit_evfscfh_r_r ¶
    Source

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

    emit_evfscfsf ¶
    Source

    emit_evfscfsf :: emit_evfscfsf_r_r

    emit_evfscfsf_r_r ¶
    Source

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

    emit_evfscfsi ¶
    Source

    emit_evfscfsi :: emit_evfscfsi_r_r

    emit_evfscfsi_r_r ¶
    Source

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

    emit_evfscfuf ¶
    Source

    emit_evfscfuf :: emit_evfscfuf_r_r

    emit_evfscfuf_r_r ¶
    Source

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

    emit_evfscfui ¶
    Source

    emit_evfscfui :: emit_evfscfui_r_r

    emit_evfscfui_r_r ¶
    Source

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

    emit_evfscmpeq ¶
    Source

    emit_evfscmpeq :: emit_evfscmpeq_crf_r_r

    emit_evfscmpeq_crf_r_r ¶
    Source

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

    emit_evfscmpgt ¶
    Source

    emit_evfscmpgt :: emit_evfscmpgt_crf_r_r

    emit_evfscmpgt_crf_r_r ¶
    Source

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

    emit_evfscmplt ¶
    Source

    emit_evfscmplt :: emit_evfscmplt_crf_r_r

    emit_evfscmplt_crf_r_r ¶
    Source

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

    emit_evfscth ¶
    Source

    emit_evfscth :: emit_evfscth_r_r

    emit_evfscth_r_r ¶
    Source

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

    emit_evfsctsf ¶
    Source

    emit_evfsctsf :: emit_evfsctsf_r_r

    emit_evfsctsf_r_r ¶
    Source

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

    emit_evfsctsi ¶
    Source

    emit_evfsctsi :: emit_evfsctsi_r_r

    emit_evfsctsi_r_r ¶
    Source

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

    emit_evfsctsiz ¶
    Source

    emit_evfsctsiz :: emit_evfsctsiz_r_r

    emit_evfsctsiz_r_r ¶
    Source

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

    emit_evfsctuf ¶
    Source

    emit_evfsctuf :: emit_evfsctuf_r_r

    emit_evfsctuf_r_r ¶
    Source

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

    emit_evfsctui ¶
    Source

    emit_evfsctui :: emit_evfsctui_r_r

    emit_evfsctui_r_r ¶
    Source

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

    emit_evfsctuiz ¶
    Source

    emit_evfsctuiz :: emit_evfsctuiz_r_r

    emit_evfsctuiz_r_r ¶
    Source

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

    emit_evfsdiff ¶
    Source

    emit_evfsdiff :: emit_evfsdiff_r_r_r

    emit_evfsdiff_r_r_r ¶
    Source

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

    emit_evfsdiffsum ¶
    Source

    emit_evfsdiffsum :: emit_evfsdiffsum_r_r_r

    emit_evfsdiffsum_r_r_r ¶
    Source

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

    emit_evfsdiv ¶
    Source

    emit_evfsdiv :: emit_evfsdiv_r_r_r

    emit_evfsdiv_r_r_r ¶
    Source

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

    emit_evfsmadd ¶
    Source

    emit_evfsmadd :: emit_evfsmadd_r_r_r

    emit_evfsmadd_r_r_r ¶
    Source

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

    emit_evfsmax ¶
    Source

    emit_evfsmax :: emit_evfsmax_r_r_r

    emit_evfsmax_r_r_r ¶
    Source

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

    emit_evfsmin ¶
    Source

    emit_evfsmin :: emit_evfsmin_r_r_r

    emit_evfsmin_r_r_r ¶
    Source

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

    emit_evfsmsub ¶
    Source

    emit_evfsmsub :: emit_evfsmsub_r_r_r

    emit_evfsmsub_r_r_r ¶
    Source

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

    emit_evfsmul ¶
    Source

    emit_evfsmul :: emit_evfsmul_r_r_r

    emit_evfsmul_r_r_r ¶
    Source

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

    emit_evfsmule ¶
    Source

    emit_evfsmule :: emit_evfsmule_r_r_r

    emit_evfsmule_r_r_r ¶
    Source

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

    emit_evfsmulo ¶
    Source

    emit_evfsmulo :: emit_evfsmulo_r_r_r

    emit_evfsmulo_r_r_r ¶
    Source

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

    emit_evfsmulx ¶
    Source

    emit_evfsmulx :: emit_evfsmulx_r_r_r

    emit_evfsmulx_r_r_r ¶
    Source

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

    emit_evfsnabs ¶
    Source

    emit_evfsnabs :: emit_evfsnabs_r_r

    emit_evfsnabs_r_r ¶
    Source

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

    emit_evfsneg ¶
    Source

    emit_evfsneg :: emit_evfsneg_r_r

    emit_evfsneg_r_r ¶
    Source

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

    emit_evfsnmadd ¶
    Source

    emit_evfsnmadd :: emit_evfsnmadd_r_r_r

    emit_evfsnmadd_r_r_r ¶
    Source

    emit_evfsnmadd_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evfsnmsub ¶
    Source

    emit_evfsnmsub :: emit_evfsnmsub_r_r_r

    emit_evfsnmsub_r_r_r ¶
    Source

    emit_evfsnmsub_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evfssqrt ¶
    Source

    emit_evfssqrt :: emit_evfssqrt_r_r

    emit_evfssqrt_r_r ¶
    Source

    emit_evfssqrt_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_evfssub ¶
    Source

    emit_evfssub :: emit_evfssub_r_r_r

    emit_evfssub_r_r_r ¶
    Source

    emit_evfssub_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evfssubadd ¶
    Source

    emit_evfssubadd :: emit_evfssubadd_r_r_r

    emit_evfssubadd_r_r_r ¶
    Source

    emit_evfssubadd_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evfssubaddx ¶
    Source

    emit_evfssubaddx :: emit_evfssubaddx_r_r_r

    emit_evfssubaddx_r_r_r ¶
    Source

    emit_evfssubaddx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evfssubx ¶
    Source

    emit_evfssubx :: emit_evfssubx_r_r_r

    emit_evfssubx_r_r_r ¶
    Source

    emit_evfssubx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evfssum ¶
    Source

    emit_evfssum :: emit_evfssum_r_r_r

    emit_evfssum_r_r_r ¶
    Source

    emit_evfssum_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evfssumdiff ¶
    Source

    emit_evfssumdiff :: emit_evfssumdiff_r_r_r

    emit_evfssumdiff_r_r_r ¶
    Source

    emit_evfssumdiff_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evfststeq ¶
    Source

    emit_evfststeq :: emit_evfststeq_crf_r_r

    emit_evfststeq_crf_r_r ¶
    Source

    emit_evfststeq_crf_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evfststgt ¶
    Source

    emit_evfststgt :: emit_evfststgt_crf_r_r

    emit_evfststgt_crf_r_r ¶
    Source

    emit_evfststgt_crf_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evfststlt ¶
    Source

    emit_evfststlt :: emit_evfststlt_crf_r_r

    emit_evfststlt_crf_r_r ¶
    Source

    emit_evfststlt_crf_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evilveh ¶
    Source

    emit_evilveh :: emit_evilveh_r_r_r

    emit_evilveh_r_r_r ¶
    Source

    emit_evilveh_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evilveoh ¶
    Source

    emit_evilveoh :: emit_evilveoh_r_r_r

    emit_evilveoh_r_r_r ¶
    Source

    emit_evilveoh_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evilvhih ¶
    Source

    emit_evilvhih :: emit_evilvhih_r_r_r

    emit_evilvhih_r_r_r ¶
    Source

    emit_evilvhih_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evilvhiloh ¶
    Source

    emit_evilvhiloh :: emit_evilvhiloh_r_r_r

    emit_evilvhiloh_r_r_r ¶
    Source

    emit_evilvhiloh_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evilvloh ¶
    Source

    emit_evilvloh :: emit_evilvloh_r_r_r

    emit_evilvloh_r_r_r ¶
    Source

    emit_evilvloh_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evilvlohih ¶
    Source

    emit_evilvlohih :: emit_evilvlohih_r_r_r

    emit_evilvlohih_r_r_r ¶
    Source

    emit_evilvlohih_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evilvoeh ¶
    Source

    emit_evilvoeh :: emit_evilvoeh_r_r_r

    emit_evilvoeh_r_r_r ¶
    Source

    emit_evilvoeh_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evilvoh ¶
    Source

    emit_evilvoh :: emit_evilvoh_r_r_r

    emit_evilvoh_r_r_r ¶
    Source

    emit_evilvoh_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evinsb ¶
    Source

    emit_evinsb :: emit_evinsb_r_r_r

    emit_evinsb_r_r_r ¶
    Source

    emit_evinsb_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evinsh ¶
    Source

    emit_evinsh :: emit_evinsh_r_r_r

    emit_evinsh_r_r_r ¶
    Source

    emit_evinsh_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlbbsplatb ¶
    Source

    emit_evlbbsplatb :: emit_evlbbsplatb_r_r_r

    emit_evlbbsplatb_r_r_r ¶
    Source

    emit_evlbbsplatb_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlbbsplatbmx ¶
    Source

    emit_evlbbsplatbmx :: emit_evlbbsplatbmx_r_r_r

    emit_evlbbsplatbmx_r_r_r ¶
    Source

    emit_evlbbsplatbmx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlbbsplatbu ¶
    Source

    emit_evlbbsplatbu :: emit_evlbbsplatbu_r_r_r

    emit_evlbbsplatbu_r_r_r ¶
    Source

    emit_evlbbsplatbu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlbbsplatbx ¶
    Source

    emit_evlbbsplatbx :: emit_evlbbsplatbx_r_r_r

    emit_evlbbsplatbx_r_r_r ¶
    Source

    emit_evlbbsplatbx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evldb ¶
    Source

    emit_evldb :: emit_evldb_r_r_r

    emit_evldb_r_r_r ¶
    Source

    emit_evldb_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evldbmx ¶
    Source

    emit_evldbmx :: emit_evldbmx_r_r_r

    emit_evldbmx_r_r_r ¶
    Source

    emit_evldbmx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evldbu ¶
    Source

    emit_evldbu :: emit_evldbu_r_r_r

    emit_evldbu_r_r_r ¶
    Source

    emit_evldbu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evldbx ¶
    Source

    emit_evldbx :: emit_evldbx_r_r_r

    emit_evldbx_r_r_r ¶
    Source

    emit_evldbx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evldd ¶
    Source

    emit_evldd :: emit_evldd_r_mem

    emit_evldd_r_mem ¶
    Source

    emit_evldd_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_evlddepx ¶
    Source

    emit_evlddepx :: emit_evlddepx_r_r_r

    emit_evlddepx_r_r_r ¶
    Source

    emit_evlddepx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlddmx ¶
    Source

    emit_evlddmx :: emit_evlddmx_r_r_r

    emit_evlddmx_r_r_r ¶
    Source

    emit_evlddmx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlddu ¶
    Source

    emit_evlddu :: emit_evlddu_r_r_r

    emit_evlddu_r_r_r ¶
    Source

    emit_evlddu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlddx ¶
    Source

    emit_evlddx :: emit_evlddx_r_r_r

    emit_evlddx_r_r_r ¶
    Source

    emit_evlddx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evldh ¶
    Source

    emit_evldh :: emit_evldh_r_mem

    emit_evldh_r_mem ¶
    Source

    emit_evldh_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_evldhmx ¶
    Source

    emit_evldhmx :: emit_evldhmx_r_r_r

    emit_evldhmx_r_r_r ¶
    Source

    emit_evldhmx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evldhu ¶
    Source

    emit_evldhu :: emit_evldhu_r_r_r

    emit_evldhu_r_r_r ¶
    Source

    emit_evldhu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evldhx ¶
    Source

    emit_evldhx :: emit_evldhx_r_r_r

    emit_evldhx_r_r_r ¶
    Source

    emit_evldhx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evldw ¶
    Source

    emit_evldw :: emit_evldw_r_mem

    emit_evldw_r_mem ¶
    Source

    emit_evldw_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_evldwmx ¶
    Source

    emit_evldwmx :: emit_evldwmx_r_r_r

    emit_evldwmx_r_r_r ¶
    Source

    emit_evldwmx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evldwu ¶
    Source

    emit_evldwu :: emit_evldwu_r_r_r

    emit_evldwu_r_r_r ¶
    Source

    emit_evldwu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evldwx ¶
    Source

    emit_evldwx :: emit_evldwx_r_r_r

    emit_evldwx_r_r_r ¶
    Source

    emit_evldwx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlhhesplat ¶
    Source

    emit_evlhhesplat :: emit_evlhhesplat_r_mem

    emit_evlhhesplat_r_mem ¶
    Source

    emit_evlhhesplat_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_evlhhesplatmx ¶
    Source

    emit_evlhhesplatmx :: emit_evlhhesplatmx_r_r_r

    emit_evlhhesplatmx_r_r_r ¶
    Source

    emit_evlhhesplatmx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlhhesplatu ¶
    Source

    emit_evlhhesplatu :: emit_evlhhesplatu_r_r_r

    emit_evlhhesplatu_r_r_r ¶
    Source

    emit_evlhhesplatu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlhhesplatx ¶
    Source

    emit_evlhhesplatx :: emit_evlhhesplatx_r_r_r

    emit_evlhhesplatx_r_r_r ¶
    Source

    emit_evlhhesplatx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlhhossplat ¶
    Source

    emit_evlhhossplat :: emit_evlhhossplat_r_mem

    emit_evlhhossplat_r_mem ¶
    Source

    emit_evlhhossplat_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_evlhhossplatmx ¶
    Source

    emit_evlhhossplatmx :: emit_evlhhossplatmx_r_r_r

    emit_evlhhossplatmx_r_r_r ¶
    Source

    emit_evlhhossplatmx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlhhossplatu ¶
    Source

    emit_evlhhossplatu :: emit_evlhhossplatu_r_r_r

    emit_evlhhossplatu_r_r_r ¶
    Source

    emit_evlhhossplatu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlhhossplatx ¶
    Source

    emit_evlhhossplatx :: emit_evlhhossplatx_r_r_r

    emit_evlhhossplatx_r_r_r ¶
    Source

    emit_evlhhossplatx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlhhousplat ¶
    Source

    emit_evlhhousplat :: emit_evlhhousplat_r_mem

    emit_evlhhousplat_r_mem ¶
    Source

    emit_evlhhousplat_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_evlhhousplatmx ¶
    Source

    emit_evlhhousplatmx :: emit_evlhhousplatmx_r_r_r

    emit_evlhhousplatmx_r_r_r ¶
    Source

    emit_evlhhousplatmx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlhhousplatu ¶
    Source

    emit_evlhhousplatu :: emit_evlhhousplatu_r_r_r

    emit_evlhhousplatu_r_r_r ¶
    Source

    emit_evlhhousplatu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlhhousplatx ¶
    Source

    emit_evlhhousplatx :: emit_evlhhousplatx_r_r_r

    emit_evlhhousplatx_r_r_r ¶
    Source

    emit_evlhhousplatx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlhhsplath ¶
    Source

    emit_evlhhsplath :: emit_evlhhsplath_r_r_r

    emit_evlhhsplath_r_r_r ¶
    Source

    emit_evlhhsplath_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlhhsplathmx ¶
    Source

    emit_evlhhsplathmx :: emit_evlhhsplathmx_r_r_r

    emit_evlhhsplathmx_r_r_r ¶
    Source

    emit_evlhhsplathmx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlhhsplathu ¶
    Source

    emit_evlhhsplathu :: emit_evlhhsplathu_r_r_r

    emit_evlhhsplathu_r_r_r ¶
    Source

    emit_evlhhsplathu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlhhsplathx ¶
    Source

    emit_evlhhsplathx :: emit_evlhhsplathx_r_r_r

    emit_evlhhsplathx_r_r_r ¶
    Source

    emit_evlhhsplathx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlvsl ¶
    Source

    emit_evlvsl :: emit_evlvsl_r_r_r

    emit_evlvsl_r_r_r ¶
    Source

    emit_evlvsl_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlvsr ¶
    Source

    emit_evlvsr :: emit_evlvsr_r_r_r

    emit_evlvsr_r_r_r ¶
    Source

    emit_evlvsr_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlwbe ¶
    Source

    emit_evlwbe :: emit_evlwbe_r_r_r

    emit_evlwbe_r_r_r ¶
    Source

    emit_evlwbe_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlwbemx ¶
    Source

    emit_evlwbemx :: emit_evlwbemx_r_r_r

    emit_evlwbemx_r_r_r ¶
    Source

    emit_evlwbemx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlwbeu ¶
    Source

    emit_evlwbeu :: emit_evlwbeu_r_r_r

    emit_evlwbeu_r_r_r ¶
    Source

    emit_evlwbeu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlwbex ¶
    Source

    emit_evlwbex :: emit_evlwbex_r_r_r

    emit_evlwbex_r_r_r ¶
    Source

    emit_evlwbex_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlwbos ¶
    Source

    emit_evlwbos :: emit_evlwbos_r_r_r

    emit_evlwbos_r_r_r ¶
    Source

    emit_evlwbos_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlwbosmx ¶
    Source

    emit_evlwbosmx :: emit_evlwbosmx_r_r_r

    emit_evlwbosmx_r_r_r ¶
    Source

    emit_evlwbosmx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlwbosu ¶
    Source

    emit_evlwbosu :: emit_evlwbosu_r_r_r

    emit_evlwbosu_r_r_r ¶
    Source

    emit_evlwbosu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlwbosx ¶
    Source

    emit_evlwbosx :: emit_evlwbosx_r_r_r

    emit_evlwbosx_r_r_r ¶
    Source

    emit_evlwbosx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlwbou ¶
    Source

    emit_evlwbou :: emit_evlwbou_r_r_r

    emit_evlwbou_r_r_r ¶
    Source

    emit_evlwbou_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlwboumx ¶
    Source

    emit_evlwboumx :: emit_evlwboumx_r_r_r

    emit_evlwboumx_r_r_r ¶
    Source

    emit_evlwboumx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlwbouu ¶
    Source

    emit_evlwbouu :: emit_evlwbouu_r_r_r

    emit_evlwbouu_r_r_r ¶
    Source

    emit_evlwbouu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlwboux ¶
    Source

    emit_evlwboux :: emit_evlwboux_r_r_r

    emit_evlwboux_r_r_r ¶
    Source

    emit_evlwboux_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlwbsplatw ¶
    Source

    emit_evlwbsplatw :: emit_evlwbsplatw_r_r_r

    emit_evlwbsplatw_r_r_r ¶
    Source

    emit_evlwbsplatw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlwbsplatwmx ¶
    Source

    emit_evlwbsplatwmx :: emit_evlwbsplatwmx_r_r_r

    emit_evlwbsplatwmx_r_r_r ¶
    Source

    emit_evlwbsplatwmx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlwbsplatwu ¶
    Source

    emit_evlwbsplatwu :: emit_evlwbsplatwu_r_r_r

    emit_evlwbsplatwu_r_r_r ¶
    Source

    emit_evlwbsplatwu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlwbsplatwx ¶
    Source

    emit_evlwbsplatwx :: emit_evlwbsplatwx_r_r_r

    emit_evlwbsplatwx_r_r_r ¶
    Source

    emit_evlwbsplatwx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlwhe ¶
    Source

    emit_evlwhe :: emit_evlwhe_r_mem

    emit_evlwhe_r_mem ¶
    Source

    emit_evlwhe_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_evlwhemx ¶
    Source

    emit_evlwhemx :: emit_evlwhemx_r_r_r

    emit_evlwhemx_r_r_r ¶
    Source

    emit_evlwhemx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlwheu ¶
    Source

    emit_evlwheu :: emit_evlwheu_r_r_r

    emit_evlwheu_r_r_r ¶
    Source

    emit_evlwheu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlwhex ¶
    Source

    emit_evlwhex :: emit_evlwhex_r_r_r

    emit_evlwhex_r_r_r ¶
    Source

    emit_evlwhex_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlwhos ¶
    Source

    emit_evlwhos :: emit_evlwhos_r_mem

    emit_evlwhos_r_mem ¶
    Source

    emit_evlwhos_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_evlwhosmx ¶
    Source

    emit_evlwhosmx :: emit_evlwhosmx_r_r_r

    emit_evlwhosmx_r_r_r ¶
    Source

    emit_evlwhosmx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlwhosu ¶
    Source

    emit_evlwhosu :: emit_evlwhosu_r_r_r

    emit_evlwhosu_r_r_r ¶
    Source

    emit_evlwhosu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlwhosx ¶
    Source

    emit_evlwhosx :: emit_evlwhosx_r_r_r

    emit_evlwhosx_r_r_r ¶
    Source

    emit_evlwhosx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlwhou ¶
    Source

    emit_evlwhou :: emit_evlwhou_r_mem

    emit_evlwhou_r_mem ¶
    Source

    emit_evlwhou_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_evlwhoumx ¶
    Source

    emit_evlwhoumx :: emit_evlwhoumx_r_r_r

    emit_evlwhoumx_r_r_r ¶
    Source

    emit_evlwhoumx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlwhouu ¶
    Source

    emit_evlwhouu :: emit_evlwhouu_r_r_r

    emit_evlwhouu_r_r_r ¶
    Source

    emit_evlwhouu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlwhoux ¶
    Source

    emit_evlwhoux :: emit_evlwhoux_r_r_r

    emit_evlwhoux_r_r_r ¶
    Source

    emit_evlwhoux_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlwhsplat ¶
    Source

    emit_evlwhsplat :: emit_evlwhsplat_r_mem

    emit_evlwhsplat_r_mem ¶
    Source

    emit_evlwhsplat_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_evlwhsplatmx ¶
    Source

    emit_evlwhsplatmx :: emit_evlwhsplatmx_r_r_r

    emit_evlwhsplatmx_r_r_r ¶
    Source

    emit_evlwhsplatmx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlwhsplatu ¶
    Source

    emit_evlwhsplatu :: emit_evlwhsplatu_r_r_r

    emit_evlwhsplatu_r_r_r ¶
    Source

    emit_evlwhsplatu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlwhsplatw ¶
    Source

    emit_evlwhsplatw :: emit_evlwhsplatw_r_r_r

    emit_evlwhsplatw_r_r_r ¶
    Source

    emit_evlwhsplatw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlwhsplatwmx ¶
    Source

    emit_evlwhsplatwmx :: emit_evlwhsplatwmx_r_r_r

    emit_evlwhsplatwmx_r_r_r ¶
    Source

    emit_evlwhsplatwmx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlwhsplatwu ¶
    Source

    emit_evlwhsplatwu :: emit_evlwhsplatwu_r_r_r

    emit_evlwhsplatwu_r_r_r ¶
    Source

    emit_evlwhsplatwu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlwhsplatwx ¶
    Source

    emit_evlwhsplatwx :: emit_evlwhsplatwx_r_r_r

    emit_evlwhsplatwx_r_r_r ¶
    Source

    emit_evlwhsplatwx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlwhsplatx ¶
    Source

    emit_evlwhsplatx :: emit_evlwhsplatx_r_r_r

    emit_evlwhsplatx_r_r_r ¶
    Source

    emit_evlwhsplatx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlwwsplat ¶
    Source

    emit_evlwwsplat :: emit_evlwwsplat_r_mem

    emit_evlwwsplat_r_mem ¶
    Source

    emit_evlwwsplat_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_evlwwsplatmx ¶
    Source

    emit_evlwwsplatmx :: emit_evlwwsplatmx_r_r_r

    emit_evlwwsplatmx_r_r_r ¶
    Source

    emit_evlwwsplatmx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlwwsplatu ¶
    Source

    emit_evlwwsplatu :: emit_evlwwsplatu_r_r_r

    emit_evlwwsplatu_r_r_r ¶
    Source

    emit_evlwwsplatu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evlwwsplatx ¶
    Source

    emit_evlwwsplatx :: emit_evlwwsplatx_r_r_r

    emit_evlwwsplatx_r_r_r ¶
    Source

    emit_evlwwsplatx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmar ¶
    Source

    emit_evmar :: emit_evmar_r_r_r

    emit_evmar_r_r_r ¶
    Source

    emit_evmar_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmaxbpsh ¶
    Source

    emit_evmaxbpsh :: emit_evmaxbpsh_r_r_r

    emit_evmaxbpsh_r_r_r ¶
    Source

    emit_evmaxbpsh_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmaxbpuh ¶
    Source

    emit_evmaxbpuh :: emit_evmaxbpuh_r_r_r

    emit_evmaxbpuh_r_r_r ¶
    Source

    emit_evmaxbpuh_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmaxbs ¶
    Source

    emit_evmaxbs :: emit_evmaxbs_r_r_r

    emit_evmaxbs_r_r_r ¶
    Source

    emit_evmaxbs_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmaxbu ¶
    Source

    emit_evmaxbu :: emit_evmaxbu_r_r_r

    emit_evmaxbu_r_r_r ¶
    Source

    emit_evmaxbu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmaxds ¶
    Source

    emit_evmaxds :: emit_evmaxds_r_r_r

    emit_evmaxds_r_r_r ¶
    Source

    emit_evmaxds_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmaxdu ¶
    Source

    emit_evmaxdu :: emit_evmaxdu_r_r_r

    emit_evmaxdu_r_r_r ¶
    Source

    emit_evmaxdu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmaxhpsw ¶
    Source

    emit_evmaxhpsw :: emit_evmaxhpsw_r_r_r

    emit_evmaxhpsw_r_r_r ¶
    Source

    emit_evmaxhpsw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmaxhpuw ¶
    Source

    emit_evmaxhpuw :: emit_evmaxhpuw_r_r_r

    emit_evmaxhpuw_r_r_r ¶
    Source

    emit_evmaxhpuw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmaxhs ¶
    Source

    emit_evmaxhs :: emit_evmaxhs_r_r_r

    emit_evmaxhs_r_r_r ¶
    Source

    emit_evmaxhs_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmaxhu ¶
    Source

    emit_evmaxhu :: emit_evmaxhu_r_r_r

    emit_evmaxhu_r_r_r ¶
    Source

    emit_evmaxhu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmaxmagws ¶
    Source

    emit_evmaxmagws :: emit_evmaxmagws_r_r_r

    emit_evmaxmagws_r_r_r ¶
    Source

    emit_evmaxmagws_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmaxwpsd ¶
    Source

    emit_evmaxwpsd :: emit_evmaxwpsd_r_r_r

    emit_evmaxwpsd_r_r_r ¶
    Source

    emit_evmaxwpsd_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmaxwpud ¶
    Source

    emit_evmaxwpud :: emit_evmaxwpud_r_r_r

    emit_evmaxwpud_r_r_r ¶
    Source

    emit_evmaxwpud_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmaxws ¶
    Source

    emit_evmaxws :: emit_evmaxws_r_r_r

    emit_evmaxws_r_r_r ¶
    Source

    emit_evmaxws_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmaxwu ¶
    Source

    emit_evmaxwu :: emit_evmaxwu_r_r_r

    emit_evmaxwu_r_r_r ¶
    Source

    emit_evmaxwu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmbesmi ¶
    Source

    emit_evmbesmi :: emit_evmbesmi_r_r_r

    emit_evmbesmi_r_r_r ¶
    Source

    emit_evmbesmi_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmbesmia ¶
    Source

    emit_evmbesmia :: emit_evmbesmia_r_r_r

    emit_evmbesmia_r_r_r ¶
    Source

    emit_evmbesmia_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmbesmiaah ¶
    Source

    emit_evmbesmiaah :: emit_evmbesmiaah_r_r_r

    emit_evmbesmiaah_r_r_r ¶
    Source

    emit_evmbesmiaah_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmbesmianh ¶
    Source

    emit_evmbesmianh :: emit_evmbesmianh_r_r_r

    emit_evmbesmianh_r_r_r ¶
    Source

    emit_evmbesmianh_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmbessiaah ¶
    Source

    emit_evmbessiaah :: emit_evmbessiaah_r_r_r

    emit_evmbessiaah_r_r_r ¶
    Source

    emit_evmbessiaah_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmbessianh ¶
    Source

    emit_evmbessianh :: emit_evmbessianh_r_r_r

    emit_evmbessianh_r_r_r ¶
    Source

    emit_evmbessianh_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmbesumi ¶
    Source

    emit_evmbesumi :: emit_evmbesumi_r_r_r

    emit_evmbesumi_r_r_r ¶
    Source

    emit_evmbesumi_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmbesumia ¶
    Source

    emit_evmbesumia :: emit_evmbesumia_r_r_r

    emit_evmbesumia_r_r_r ¶
    Source

    emit_evmbesumia_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmbesumiaah ¶
    Source

    emit_evmbesumiaah :: emit_evmbesumiaah_r_r_r

    emit_evmbesumiaah_r_r_r ¶
    Source

    emit_evmbesumiaah_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmbesumianh ¶
    Source

    emit_evmbesumianh :: emit_evmbesumianh_r_r_r

    emit_evmbesumianh_r_r_r ¶
    Source

    emit_evmbesumianh_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmbesusiaah ¶
    Source

    emit_evmbesusiaah :: emit_evmbesusiaah_r_r_r

    emit_evmbesusiaah_r_r_r ¶
    Source

    emit_evmbesusiaah_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmbesusianh ¶
    Source

    emit_evmbesusianh :: emit_evmbesusianh_r_r_r

    emit_evmbesusianh_r_r_r ¶
    Source

    emit_evmbesusianh_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmbeumi ¶
    Source

    emit_evmbeumi :: emit_evmbeumi_r_r_r

    emit_evmbeumi_r_r_r ¶
    Source

    emit_evmbeumi_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmbeumia ¶
    Source

    emit_evmbeumia :: emit_evmbeumia_r_r_r

    emit_evmbeumia_r_r_r ¶
    Source

    emit_evmbeumia_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmbeumiaah ¶
    Source

    emit_evmbeumiaah :: emit_evmbeumiaah_r_r_r

    emit_evmbeumiaah_r_r_r ¶
    Source

    emit_evmbeumiaah_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmbeumianh ¶
    Source

    emit_evmbeumianh :: emit_evmbeumianh_r_r_r

    emit_evmbeumianh_r_r_r ¶
    Source

    emit_evmbeumianh_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmbeusiaah ¶
    Source

    emit_evmbeusiaah :: emit_evmbeusiaah_r_r_r

    emit_evmbeusiaah_r_r_r ¶
    Source

    emit_evmbeusiaah_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmbeusianh ¶
    Source

    emit_evmbeusianh :: emit_evmbeusianh_r_r_r

    emit_evmbeusianh_r_r_r ¶
    Source

    emit_evmbeusianh_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmbosmi ¶
    Source

    emit_evmbosmi :: emit_evmbosmi_r_r_r

    emit_evmbosmi_r_r_r ¶
    Source

    emit_evmbosmi_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmbosmia ¶
    Source

    emit_evmbosmia :: emit_evmbosmia_r_r_r

    emit_evmbosmia_r_r_r ¶
    Source

    emit_evmbosmia_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmbosmiaah ¶
    Source

    emit_evmbosmiaah :: emit_evmbosmiaah_r_r_r

    emit_evmbosmiaah_r_r_r ¶
    Source

    emit_evmbosmiaah_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmbosmianh ¶
    Source

    emit_evmbosmianh :: emit_evmbosmianh_r_r_r

    emit_evmbosmianh_r_r_r ¶
    Source

    emit_evmbosmianh_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmbossiaah ¶
    Source

    emit_evmbossiaah :: emit_evmbossiaah_r_r_r

    emit_evmbossiaah_r_r_r ¶
    Source

    emit_evmbossiaah_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmbossianh ¶
    Source

    emit_evmbossianh :: emit_evmbossianh_r_r_r

    emit_evmbossianh_r_r_r ¶
    Source

    emit_evmbossianh_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmbosumi ¶
    Source

    emit_evmbosumi :: emit_evmbosumi_r_r_r

    emit_evmbosumi_r_r_r ¶
    Source

    emit_evmbosumi_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmbosumia ¶
    Source

    emit_evmbosumia :: emit_evmbosumia_r_r_r

    emit_evmbosumia_r_r_r ¶
    Source

    emit_evmbosumia_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmbosumiaah ¶
    Source

    emit_evmbosumiaah :: emit_evmbosumiaah_r_r_r

    emit_evmbosumiaah_r_r_r ¶
    Source

    emit_evmbosumiaah_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmbosumianh ¶
    Source

    emit_evmbosumianh :: emit_evmbosumianh_r_r_r

    emit_evmbosumianh_r_r_r ¶
    Source

    emit_evmbosumianh_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmbosusiaah ¶
    Source

    emit_evmbosusiaah :: emit_evmbosusiaah_r_r_r

    emit_evmbosusiaah_r_r_r ¶
    Source

    emit_evmbosusiaah_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmbosusianh ¶
    Source

    emit_evmbosusianh :: emit_evmbosusianh_r_r_r

    emit_evmbosusianh_r_r_r ¶
    Source

    emit_evmbosusianh_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmboumi ¶
    Source

    emit_evmboumi :: emit_evmboumi_r_r_r

    emit_evmboumi_r_r_r ¶
    Source

    emit_evmboumi_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmboumia ¶
    Source

    emit_evmboumia :: emit_evmboumia_r_r_r

    emit_evmboumia_r_r_r ¶
    Source

    emit_evmboumia_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmboumiaah ¶
    Source

    emit_evmboumiaah :: emit_evmboumiaah_r_r_r

    emit_evmboumiaah_r_r_r ¶
    Source

    emit_evmboumiaah_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmboumianh ¶
    Source

    emit_evmboumianh :: emit_evmboumianh_r_r_r

    emit_evmboumianh_r_r_r ¶
    Source

    emit_evmboumianh_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmbousiaah ¶
    Source

    emit_evmbousiaah :: emit_evmbousiaah_r_r_r

    emit_evmbousiaah_r_r_r ¶
    Source

    emit_evmbousiaah_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmbousianh ¶
    Source

    emit_evmbousianh :: emit_evmbousianh_r_r_r

    emit_evmbousianh_r_r_r ¶
    Source

    emit_evmbousianh_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmergehi ¶
    Source

    emit_evmergehi :: emit_evmergehi_r_r_r

    emit_evmergehi_r_r_r ¶
    Source

    emit_evmergehi_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmergehilo ¶
    Source

    emit_evmergehilo :: emit_evmergehilo_r_r_r

    emit_evmergehilo_r_r_r ¶
    Source

    emit_evmergehilo_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmergelo ¶
    Source

    emit_evmergelo :: emit_evmergelo_r_r_r

    emit_evmergelo_r_r_r ¶
    Source

    emit_evmergelo_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmergelohi ¶
    Source

    emit_evmergelohi :: emit_evmergelohi_r_r_r

    emit_evmergelohi_r_r_r ¶
    Source

    emit_evmergelohi_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhegsmfaa ¶
    Source

    emit_evmhegsmfaa :: emit_evmhegsmfaa_r_r_r

    emit_evmhegsmfaa_r_r_r ¶
    Source

    emit_evmhegsmfaa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhegsmfan ¶
    Source

    emit_evmhegsmfan :: emit_evmhegsmfan_r_r_r

    emit_evmhegsmfan_r_r_r ¶
    Source

    emit_evmhegsmfan_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhegsmiaa ¶
    Source

    emit_evmhegsmiaa :: emit_evmhegsmiaa_r_r_r

    emit_evmhegsmiaa_r_r_r ¶
    Source

    emit_evmhegsmiaa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhegsmian ¶
    Source

    emit_evmhegsmian :: emit_evmhegsmian_r_r_r

    emit_evmhegsmian_r_r_r ¶
    Source

    emit_evmhegsmian_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhegumiaa ¶
    Source

    emit_evmhegumiaa :: emit_evmhegumiaa_r_r_r

    emit_evmhegumiaa_r_r_r ¶
    Source

    emit_evmhegumiaa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhegumian ¶
    Source

    emit_evmhegumian :: emit_evmhegumian_r_r_r

    emit_evmhegumian_r_r_r ¶
    Source

    emit_evmhegumian_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhesmf ¶
    Source

    emit_evmhesmf :: emit_evmhesmf_r_r_r

    emit_evmhesmf_r_r_r ¶
    Source

    emit_evmhesmf_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhesmfa ¶
    Source

    emit_evmhesmfa :: emit_evmhesmfa_r_r_r

    emit_evmhesmfa_r_r_r ¶
    Source

    emit_evmhesmfa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhesmfaaw ¶
    Source

    emit_evmhesmfaaw :: emit_evmhesmfaaw_r_r_r

    emit_evmhesmfaaw_r_r_r ¶
    Source

    emit_evmhesmfaaw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhesmfanw ¶
    Source

    emit_evmhesmfanw :: emit_evmhesmfanw_r_r_r

    emit_evmhesmfanw_r_r_r ¶
    Source

    emit_evmhesmfanw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhesmi ¶
    Source

    emit_evmhesmi :: emit_evmhesmi_r_r_r

    emit_evmhesmi_r_r_r ¶
    Source

    emit_evmhesmi_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhesmia ¶
    Source

    emit_evmhesmia :: emit_evmhesmia_r_r_r

    emit_evmhesmia_r_r_r ¶
    Source

    emit_evmhesmia_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhesmiaaw ¶
    Source

    emit_evmhesmiaaw :: emit_evmhesmiaaw_r_r_r

    emit_evmhesmiaaw_r_r_r ¶
    Source

    emit_evmhesmiaaw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhesmianw ¶
    Source

    emit_evmhesmianw :: emit_evmhesmianw_r_r_r

    emit_evmhesmianw_r_r_r ¶
    Source

    emit_evmhesmianw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhessf ¶
    Source

    emit_evmhessf :: emit_evmhessf_r_r_r

    emit_evmhessf_r_r_r ¶
    Source

    emit_evmhessf_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhessfa ¶
    Source

    emit_evmhessfa :: emit_evmhessfa_r_r_r

    emit_evmhessfa_r_r_r ¶
    Source

    emit_evmhessfa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhessfaaw ¶
    Source

    emit_evmhessfaaw :: emit_evmhessfaaw_r_r_r

    emit_evmhessfaaw_r_r_r ¶
    Source

    emit_evmhessfaaw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhessfanw ¶
    Source

    emit_evmhessfanw :: emit_evmhessfanw_r_r_r

    emit_evmhessfanw_r_r_r ¶
    Source

    emit_evmhessfanw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhessiaaw ¶
    Source

    emit_evmhessiaaw :: emit_evmhessiaaw_r_r_r

    emit_evmhessiaaw_r_r_r ¶
    Source

    emit_evmhessiaaw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhessianw ¶
    Source

    emit_evmhessianw :: emit_evmhessianw_r_r_r

    emit_evmhessianw_r_r_r ¶
    Source

    emit_evmhessianw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhesumi ¶
    Source

    emit_evmhesumi :: emit_evmhesumi_r_r_r

    emit_evmhesumi_r_r_r ¶
    Source

    emit_evmhesumi_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhesumia ¶
    Source

    emit_evmhesumia :: emit_evmhesumia_r_r_r

    emit_evmhesumia_r_r_r ¶
    Source

    emit_evmhesumia_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhesumiaaw ¶
    Source

    emit_evmhesumiaaw :: emit_evmhesumiaaw_r_r_r

    emit_evmhesumiaaw_r_r_r ¶
    Source

    emit_evmhesumiaaw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhesumianw ¶
    Source

    emit_evmhesumianw :: emit_evmhesumianw_r_r_r

    emit_evmhesumianw_r_r_r ¶
    Source

    emit_evmhesumianw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhesusiaaw ¶
    Source

    emit_evmhesusiaaw :: emit_evmhesusiaaw_r_r_r

    emit_evmhesusiaaw_r_r_r ¶
    Source

    emit_evmhesusiaaw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhesusianw ¶
    Source

    emit_evmhesusianw :: emit_evmhesusianw_r_r_r

    emit_evmhesusianw_r_r_r ¶
    Source

    emit_evmhesusianw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmheumi ¶
    Source

    emit_evmheumi :: emit_evmheumi_r_r_r

    emit_evmheumi_r_r_r ¶
    Source

    emit_evmheumi_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmheumia ¶
    Source

    emit_evmheumia :: emit_evmheumia_r_r_r

    emit_evmheumia_r_r_r ¶
    Source

    emit_evmheumia_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmheumiaaw ¶
    Source

    emit_evmheumiaaw :: emit_evmheumiaaw_r_r_r

    emit_evmheumiaaw_r_r_r ¶
    Source

    emit_evmheumiaaw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmheumianw ¶
    Source

    emit_evmheumianw :: emit_evmheumianw_r_r_r

    emit_evmheumianw_r_r_r ¶
    Source

    emit_evmheumianw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmheusiaaw ¶
    Source

    emit_evmheusiaaw :: emit_evmheusiaaw_r_r_r

    emit_evmheusiaaw_r_r_r ¶
    Source

    emit_evmheusiaaw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmheusianw ¶
    Source

    emit_evmheusianw :: emit_evmheusianw_r_r_r

    emit_evmheusianw_r_r_r ¶
    Source

    emit_evmheusianw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhogsmfaa ¶
    Source

    emit_evmhogsmfaa :: emit_evmhogsmfaa_r_r_r

    emit_evmhogsmfaa_r_r_r ¶
    Source

    emit_evmhogsmfaa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhogsmfan ¶
    Source

    emit_evmhogsmfan :: emit_evmhogsmfan_r_r_r

    emit_evmhogsmfan_r_r_r ¶
    Source

    emit_evmhogsmfan_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhogsmiaa ¶
    Source

    emit_evmhogsmiaa :: emit_evmhogsmiaa_r_r_r

    emit_evmhogsmiaa_r_r_r ¶
    Source

    emit_evmhogsmiaa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhogsmian ¶
    Source

    emit_evmhogsmian :: emit_evmhogsmian_r_r_r

    emit_evmhogsmian_r_r_r ¶
    Source

    emit_evmhogsmian_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhogumiaa ¶
    Source

    emit_evmhogumiaa :: emit_evmhogumiaa_r_r_r

    emit_evmhogumiaa_r_r_r ¶
    Source

    emit_evmhogumiaa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhogumian ¶
    Source

    emit_evmhogumian :: emit_evmhogumian_r_r_r

    emit_evmhogumian_r_r_r ¶
    Source

    emit_evmhogumian_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhosmf ¶
    Source

    emit_evmhosmf :: emit_evmhosmf_r_r_r

    emit_evmhosmf_r_r_r ¶
    Source

    emit_evmhosmf_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhosmfa ¶
    Source

    emit_evmhosmfa :: emit_evmhosmfa_r_r_r

    emit_evmhosmfa_r_r_r ¶
    Source

    emit_evmhosmfa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhosmfaaw ¶
    Source

    emit_evmhosmfaaw :: emit_evmhosmfaaw_r_r_r

    emit_evmhosmfaaw_r_r_r ¶
    Source

    emit_evmhosmfaaw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhosmfanw ¶
    Source

    emit_evmhosmfanw :: emit_evmhosmfanw_r_r_r

    emit_evmhosmfanw_r_r_r ¶
    Source

    emit_evmhosmfanw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhosmi ¶
    Source

    emit_evmhosmi :: emit_evmhosmi_r_r_r

    emit_evmhosmi_r_r_r ¶
    Source

    emit_evmhosmi_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhosmia ¶
    Source

    emit_evmhosmia :: emit_evmhosmia_r_r_r

    emit_evmhosmia_r_r_r ¶
    Source

    emit_evmhosmia_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhosmiaaw ¶
    Source

    emit_evmhosmiaaw :: emit_evmhosmiaaw_r_r_r

    emit_evmhosmiaaw_r_r_r ¶
    Source

    emit_evmhosmiaaw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhosmianw ¶
    Source

    emit_evmhosmianw :: emit_evmhosmianw_r_r_r

    emit_evmhosmianw_r_r_r ¶
    Source

    emit_evmhosmianw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhossf ¶
    Source

    emit_evmhossf :: emit_evmhossf_r_r_r

    emit_evmhossf_r_r_r ¶
    Source

    emit_evmhossf_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhossfa ¶
    Source

    emit_evmhossfa :: emit_evmhossfa_r_r_r

    emit_evmhossfa_r_r_r ¶
    Source

    emit_evmhossfa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhossfaaw ¶
    Source

    emit_evmhossfaaw :: emit_evmhossfaaw_r_r_r

    emit_evmhossfaaw_r_r_r ¶
    Source

    emit_evmhossfaaw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhossfanw ¶
    Source

    emit_evmhossfanw :: emit_evmhossfanw_r_r_r

    emit_evmhossfanw_r_r_r ¶
    Source

    emit_evmhossfanw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhossiaaw ¶
    Source

    emit_evmhossiaaw :: emit_evmhossiaaw_r_r_r

    emit_evmhossiaaw_r_r_r ¶
    Source

    emit_evmhossiaaw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhossianw ¶
    Source

    emit_evmhossianw :: emit_evmhossianw_r_r_r

    emit_evmhossianw_r_r_r ¶
    Source

    emit_evmhossianw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhosumi ¶
    Source

    emit_evmhosumi :: emit_evmhosumi_r_r_r

    emit_evmhosumi_r_r_r ¶
    Source

    emit_evmhosumi_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhosumia ¶
    Source

    emit_evmhosumia :: emit_evmhosumia_r_r_r

    emit_evmhosumia_r_r_r ¶
    Source

    emit_evmhosumia_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhosumiaaw ¶
    Source

    emit_evmhosumiaaw :: emit_evmhosumiaaw_r_r_r

    emit_evmhosumiaaw_r_r_r ¶
    Source

    emit_evmhosumiaaw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhosumianw ¶
    Source

    emit_evmhosumianw :: emit_evmhosumianw_r_r_r

    emit_evmhosumianw_r_r_r ¶
    Source

    emit_evmhosumianw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhosusiaaw ¶
    Source

    emit_evmhosusiaaw :: emit_evmhosusiaaw_r_r_r

    emit_evmhosusiaaw_r_r_r ¶
    Source

    emit_evmhosusiaaw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhosusianw ¶
    Source

    emit_evmhosusianw :: emit_evmhosusianw_r_r_r

    emit_evmhosusianw_r_r_r ¶
    Source

    emit_evmhosusianw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhoumi ¶
    Source

    emit_evmhoumi :: emit_evmhoumi_r_r_r

    emit_evmhoumi_r_r_r ¶
    Source

    emit_evmhoumi_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhoumia ¶
    Source

    emit_evmhoumia :: emit_evmhoumia_r_r_r

    emit_evmhoumia_r_r_r ¶
    Source

    emit_evmhoumia_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhoumiaaw ¶
    Source

    emit_evmhoumiaaw :: emit_evmhoumiaaw_r_r_r

    emit_evmhoumiaaw_r_r_r ¶
    Source

    emit_evmhoumiaaw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhoumianw ¶
    Source

    emit_evmhoumianw :: emit_evmhoumianw_r_r_r

    emit_evmhoumianw_r_r_r ¶
    Source

    emit_evmhoumianw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhousiaaw ¶
    Source

    emit_evmhousiaaw :: emit_evmhousiaaw_r_r_r

    emit_evmhousiaaw_r_r_r ¶
    Source

    emit_evmhousiaaw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhousianw ¶
    Source

    emit_evmhousianw :: emit_evmhousianw_r_r_r

    emit_evmhousianw_r_r_r ¶
    Source

    emit_evmhousianw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhssf ¶
    Source

    emit_evmhssf :: emit_evmhssf_r_r_r

    emit_evmhssf_r_r_r ¶
    Source

    emit_evmhssf_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhssfr ¶
    Source

    emit_evmhssfr :: emit_evmhssfr_r_r_r

    emit_evmhssfr_r_r_r ¶
    Source

    emit_evmhssfr_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhssi ¶
    Source

    emit_evmhssi :: emit_evmhssi_r_r_r

    emit_evmhssi_r_r_r ¶
    Source

    emit_evmhssi_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhsusi ¶
    Source

    emit_evmhsusi :: emit_evmhsusi_r_r_r

    emit_evmhsusi_r_r_r ¶
    Source

    emit_evmhsusi_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhumi ¶
    Source

    emit_evmhumi :: emit_evmhumi_r_r_r

    emit_evmhumi_r_r_r ¶
    Source

    emit_evmhumi_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmhusi ¶
    Source

    emit_evmhusi :: emit_evmhusi_r_r_r

    emit_evmhusi_r_r_r ¶
    Source

    emit_evmhusi_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evminbpsh ¶
    Source

    emit_evminbpsh :: emit_evminbpsh_r_r_r

    emit_evminbpsh_r_r_r ¶
    Source

    emit_evminbpsh_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evminbpuh ¶
    Source

    emit_evminbpuh :: emit_evminbpuh_r_r_r

    emit_evminbpuh_r_r_r ¶
    Source

    emit_evminbpuh_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evminbs ¶
    Source

    emit_evminbs :: emit_evminbs_r_r_r

    emit_evminbs_r_r_r ¶
    Source

    emit_evminbs_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evminbu ¶
    Source

    emit_evminbu :: emit_evminbu_r_r_r

    emit_evminbu_r_r_r ¶
    Source

    emit_evminbu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evminds ¶
    Source

    emit_evminds :: emit_evminds_r_r_r

    emit_evminds_r_r_r ¶
    Source

    emit_evminds_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmindu ¶
    Source

    emit_evmindu :: emit_evmindu_r_r_r

    emit_evmindu_r_r_r ¶
    Source

    emit_evmindu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evminhpsw ¶
    Source

    emit_evminhpsw :: emit_evminhpsw_r_r_r

    emit_evminhpsw_r_r_r ¶
    Source

    emit_evminhpsw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evminhpuw ¶
    Source

    emit_evminhpuw :: emit_evminhpuw_r_r_r

    emit_evminhpuw_r_r_r ¶
    Source

    emit_evminhpuw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evminhs ¶
    Source

    emit_evminhs :: emit_evminhs_r_r_r

    emit_evminhs_r_r_r ¶
    Source

    emit_evminhs_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evminhu ¶
    Source

    emit_evminhu :: emit_evminhu_r_r_r

    emit_evminhu_r_r_r ¶
    Source

    emit_evminhu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evminwpsd ¶
    Source

    emit_evminwpsd :: emit_evminwpsd_r_r_r

    emit_evminwpsd_r_r_r ¶
    Source

    emit_evminwpsd_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evminwpud ¶
    Source

    emit_evminwpud :: emit_evminwpud_r_r_r

    emit_evminwpud_r_r_r ¶
    Source

    emit_evminwpud_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evminws ¶
    Source

    emit_evminws :: emit_evminws_r_r_r

    emit_evminws_r_r_r ¶
    Source

    emit_evminws_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evminwu ¶
    Source

    emit_evminwu :: emit_evminwu_r_r_r

    emit_evminwu_r_r_r ¶
    Source

    emit_evminwu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmr ¶
    Source

    emit_evmr :: emit_evmr_r_r_r

    emit_evmr_r_r_r ¶
    Source

    emit_evmr_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmra ¶
    Source

    emit_evmra :: emit_evmra_r_r

    emit_evmra_r_r ¶
    Source

    emit_evmra_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_evmwehgsmf ¶
    Source

    emit_evmwehgsmf :: emit_evmwehgsmf_r_r_r

    emit_evmwehgsmf_r_r_r ¶
    Source

    emit_evmwehgsmf_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwehgsmfa ¶
    Source

    emit_evmwehgsmfa :: emit_evmwehgsmfa_r_r_r

    emit_evmwehgsmfa_r_r_r ¶
    Source

    emit_evmwehgsmfa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwehgsmfaa ¶
    Source

    emit_evmwehgsmfaa :: emit_evmwehgsmfaa_r_r_r

    emit_evmwehgsmfaa_r_r_r ¶
    Source

    emit_evmwehgsmfaa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwehgsmfan ¶
    Source

    emit_evmwehgsmfan :: emit_evmwehgsmfan_r_r_r

    emit_evmwehgsmfan_r_r_r ¶
    Source

    emit_evmwehgsmfan_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwehgsmfr ¶
    Source

    emit_evmwehgsmfr :: emit_evmwehgsmfr_r_r_r

    emit_evmwehgsmfr_r_r_r ¶
    Source

    emit_evmwehgsmfr_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwehgsmfra ¶
    Source

    emit_evmwehgsmfra :: emit_evmwehgsmfra_r_r_r

    emit_evmwehgsmfra_r_r_r ¶
    Source

    emit_evmwehgsmfra_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwehgsmfraa ¶
    Source

    emit_evmwehgsmfraa :: emit_evmwehgsmfraa_r_r_r

    emit_evmwehgsmfraa_r_r_r ¶
    Source

    emit_evmwehgsmfraa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwehgsmfran ¶
    Source

    emit_evmwehgsmfran :: emit_evmwehgsmfran_r_r_r

    emit_evmwehgsmfran_r_r_r ¶
    Source

    emit_evmwehgsmfran_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwhgsmfaa ¶
    Source

    emit_evmwhgsmfaa :: emit_evmwhgsmfaa_r_r_r

    emit_evmwhgsmfaa_r_r_r ¶
    Source

    emit_evmwhgsmfaa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwhgsmfan ¶
    Source

    emit_evmwhgsmfan :: emit_evmwhgsmfan_r_r_r

    emit_evmwhgsmfan_r_r_r ¶
    Source

    emit_evmwhgsmfan_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwhgsmiaa ¶
    Source

    emit_evmwhgsmiaa :: emit_evmwhgsmiaa_r_r_r

    emit_evmwhgsmiaa_r_r_r ¶
    Source

    emit_evmwhgsmiaa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwhgsmian ¶
    Source

    emit_evmwhgsmian :: emit_evmwhgsmian_r_r_r

    emit_evmwhgsmian_r_r_r ¶
    Source

    emit_evmwhgsmian_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwhgssfaa ¶
    Source

    emit_evmwhgssfaa :: emit_evmwhgssfaa_r_r_r

    emit_evmwhgssfaa_r_r_r ¶
    Source

    emit_evmwhgssfaa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwhgssfan ¶
    Source

    emit_evmwhgssfan :: emit_evmwhgssfan_r_r_r

    emit_evmwhgssfan_r_r_r ¶
    Source

    emit_evmwhgssfan_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwhgumiaa ¶
    Source

    emit_evmwhgumiaa :: emit_evmwhgumiaa_r_r_r

    emit_evmwhgumiaa_r_r_r ¶
    Source

    emit_evmwhgumiaa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwhgumian ¶
    Source

    emit_evmwhgumian :: emit_evmwhgumian_r_r_r

    emit_evmwhgumian_r_r_r ¶
    Source

    emit_evmwhgumian_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwhsmf ¶
    Source

    emit_evmwhsmf :: emit_evmwhsmf_r_r_r

    emit_evmwhsmf_r_r_r ¶
    Source

    emit_evmwhsmf_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwhsmfa ¶
    Source

    emit_evmwhsmfa :: emit_evmwhsmfa_r_r_r

    emit_evmwhsmfa_r_r_r ¶
    Source

    emit_evmwhsmfa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwhsmfaa ¶
    Source

    emit_evmwhsmfaa :: emit_evmwhsmfaa_r_r_r

    emit_evmwhsmfaa_r_r_r ¶
    Source

    emit_evmwhsmfaa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwhsmfan ¶
    Source

    emit_evmwhsmfan :: emit_evmwhsmfan_r_r_r

    emit_evmwhsmfan_r_r_r ¶
    Source

    emit_evmwhsmfan_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwhsmi ¶
    Source

    emit_evmwhsmi :: emit_evmwhsmi_r_r_r

    emit_evmwhsmi_r_r_r ¶
    Source

    emit_evmwhsmi_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwhsmia ¶
    Source

    emit_evmwhsmia :: emit_evmwhsmia_r_r_r

    emit_evmwhsmia_r_r_r ¶
    Source

    emit_evmwhsmia_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwhsmiaa ¶
    Source

    emit_evmwhsmiaa :: emit_evmwhsmiaa_r_r_r

    emit_evmwhsmiaa_r_r_r ¶
    Source

    emit_evmwhsmiaa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwhsmian ¶
    Source

    emit_evmwhsmian :: emit_evmwhsmian_r_r_r

    emit_evmwhsmian_r_r_r ¶
    Source

    emit_evmwhsmian_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwhssf ¶
    Source

    emit_evmwhssf :: emit_evmwhssf_r_r_r

    emit_evmwhssf_r_r_r ¶
    Source

    emit_evmwhssf_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwhssfa ¶
    Source

    emit_evmwhssfa :: emit_evmwhssfa_r_r_r

    emit_evmwhssfa_r_r_r ¶
    Source

    emit_evmwhssfa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwhssfaa ¶
    Source

    emit_evmwhssfaa :: emit_evmwhssfaa_r_r_r

    emit_evmwhssfaa_r_r_r ¶
    Source

    emit_evmwhssfaa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwhssfaaw ¶
    Source

    emit_evmwhssfaaw :: emit_evmwhssfaaw_r_r_r

    emit_evmwhssfaaw3 ¶
    Source

    emit_evmwhssfaaw3 :: emit_evmwhssfaaw3_r_r_r

    emit_evmwhssfaaw3_r_r_r ¶
    Source

    emit_evmwhssfaaw3_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwhssfaaw_r_r_r ¶
    Source

    emit_evmwhssfaaw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwhssfan ¶
    Source

    emit_evmwhssfan :: emit_evmwhssfan_r_r_r

    emit_evmwhssfan_r_r_r ¶
    Source

    emit_evmwhssfan_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwhssfanw ¶
    Source

    emit_evmwhssfanw :: emit_evmwhssfanw_r_r_r

    emit_evmwhssfanw3 ¶
    Source

    emit_evmwhssfanw3 :: emit_evmwhssfanw3_r_r_r

    emit_evmwhssfanw3_r_r_r ¶
    Source

    emit_evmwhssfanw3_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwhssfanw_r_r_r ¶
    Source

    emit_evmwhssfanw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwhssfr ¶
    Source

    emit_evmwhssfr :: emit_evmwhssfr_r_r_r

    emit_evmwhssfr_r_r_r ¶
    Source

    emit_evmwhssfr_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwhssfra ¶
    Source

    emit_evmwhssfra :: emit_evmwhssfra_r_r_r

    emit_evmwhssfra_r_r_r ¶
    Source

    emit_evmwhssfra_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwhssfraaw ¶
    Source

    emit_evmwhssfraaw :: emit_evmwhssfraaw_r_r_r

    emit_evmwhssfraaw3 ¶
    Source

    emit_evmwhssfraaw3 :: emit_evmwhssfraaw3_r_r_r

    emit_evmwhssfraaw3_r_r_r ¶
    Source

    emit_evmwhssfraaw3_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwhssfraaw_r_r_r ¶
    Source

    emit_evmwhssfraaw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwhssfranw ¶
    Source

    emit_evmwhssfranw :: emit_evmwhssfranw_r_r_r

    emit_evmwhssfranw3 ¶
    Source

    emit_evmwhssfranw3 :: emit_evmwhssfranw3_r_r_r

    emit_evmwhssfranw3_r_r_r ¶
    Source

    emit_evmwhssfranw3_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwhssfranw_r_r_r ¶
    Source

    emit_evmwhssfranw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwhssian ¶
    Source

    emit_evmwhssian :: emit_evmwhssian_r_r_r

    emit_evmwhssian_r_r_r ¶
    Source

    emit_evmwhssian_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwhssmaa ¶
    Source

    emit_evmwhssmaa :: emit_evmwhssmaa_r_r_r

    emit_evmwhssmaa_r_r_r ¶
    Source

    emit_evmwhssmaa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwhumi ¶
    Source

    emit_evmwhumi :: emit_evmwhumi_r_r_r

    emit_evmwhumi_r_r_r ¶
    Source

    emit_evmwhumi_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwhumia ¶
    Source

    emit_evmwhumia :: emit_evmwhumia_r_r_r

    emit_evmwhumia_r_r_r ¶
    Source

    emit_evmwhumia_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwhumiaa ¶
    Source

    emit_evmwhumiaa :: emit_evmwhumiaa_r_r_r

    emit_evmwhumiaa_r_r_r ¶
    Source

    emit_evmwhumiaa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwhumian ¶
    Source

    emit_evmwhumian :: emit_evmwhumian_r_r_r

    emit_evmwhumian_r_r_r ¶
    Source

    emit_evmwhumian_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwhusiaa ¶
    Source

    emit_evmwhusiaa :: emit_evmwhusiaa_r_r_r

    emit_evmwhusiaa_r_r_r ¶
    Source

    emit_evmwhusiaa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwhusian ¶
    Source

    emit_evmwhusian :: emit_evmwhusian_r_r_r

    emit_evmwhusian_r_r_r ¶
    Source

    emit_evmwhusian_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwlsmf ¶
    Source

    emit_evmwlsmf :: emit_evmwlsmf_r_r_r

    emit_evmwlsmf_r_r_r ¶
    Source

    emit_evmwlsmf_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwlsmfa ¶
    Source

    emit_evmwlsmfa :: emit_evmwlsmfa_r_r_r

    emit_evmwlsmfa_r_r_r ¶
    Source

    emit_evmwlsmfa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwlsmfaaw ¶
    Source

    emit_evmwlsmfaaw :: emit_evmwlsmfaaw_r_r_r

    emit_evmwlsmfaaw_r_r_r ¶
    Source

    emit_evmwlsmfaaw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwlsmfanw ¶
    Source

    emit_evmwlsmfanw :: emit_evmwlsmfanw_r_r_r

    emit_evmwlsmfanw_r_r_r ¶
    Source

    emit_evmwlsmfanw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwlsmiaaw ¶
    Source

    emit_evmwlsmiaaw :: emit_evmwlsmiaaw_r_r_r

    emit_evmwlsmiaaw3 ¶
    Source

    emit_evmwlsmiaaw3 :: emit_evmwlsmiaaw3_r_r_r

    emit_evmwlsmiaaw3_r_r_r ¶
    Source

    emit_evmwlsmiaaw3_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwlsmiaaw_r_r_r ¶
    Source

    emit_evmwlsmiaaw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwlsmianw ¶
    Source

    emit_evmwlsmianw :: emit_evmwlsmianw_r_r_r

    emit_evmwlsmianw3 ¶
    Source

    emit_evmwlsmianw3 :: emit_evmwlsmianw3_r_r_r

    emit_evmwlsmianw3_r_r_r ¶
    Source

    emit_evmwlsmianw3_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwlsmianw_r_r_r ¶
    Source

    emit_evmwlsmianw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwlssf ¶
    Source

    emit_evmwlssf :: emit_evmwlssf_r_r_r

    emit_evmwlssf_r_r_r ¶
    Source

    emit_evmwlssf_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwlssfa ¶
    Source

    emit_evmwlssfa :: emit_evmwlssfa_r_r_r

    emit_evmwlssfa_r_r_r ¶
    Source

    emit_evmwlssfa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwlssfaaw ¶
    Source

    emit_evmwlssfaaw :: emit_evmwlssfaaw_r_r_r

    emit_evmwlssfaaw_r_r_r ¶
    Source

    emit_evmwlssfaaw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwlssfanw ¶
    Source

    emit_evmwlssfanw :: emit_evmwlssfanw_r_r_r

    emit_evmwlssfanw_r_r_r ¶
    Source

    emit_evmwlssfanw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwlssiaaw ¶
    Source

    emit_evmwlssiaaw :: emit_evmwlssiaaw_r_r_r

    emit_evmwlssiaaw3 ¶
    Source

    emit_evmwlssiaaw3 :: emit_evmwlssiaaw3_r_r_r

    emit_evmwlssiaaw3_r_r_r ¶
    Source

    emit_evmwlssiaaw3_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwlssiaaw_r_r_r ¶
    Source

    emit_evmwlssiaaw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwlssianw ¶
    Source

    emit_evmwlssianw :: emit_evmwlssianw_r_r_r

    emit_evmwlssianw3 ¶
    Source

    emit_evmwlssianw3 :: emit_evmwlssianw3_r_r_r

    emit_evmwlssianw3_r_r_r ¶
    Source

    emit_evmwlssianw3_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwlssianw_r_r_r ¶
    Source

    emit_evmwlssianw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwlumi ¶
    Source

    emit_evmwlumi :: emit_evmwlumi_r_r_r

    emit_evmwlumi_r_r_r ¶
    Source

    emit_evmwlumi_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwlumia ¶
    Source

    emit_evmwlumia :: emit_evmwlumia_r_r_r

    emit_evmwlumia_r_r_r ¶
    Source

    emit_evmwlumia_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwlumiaaw ¶
    Source

    emit_evmwlumiaaw :: emit_evmwlumiaaw_r_r_r

    emit_evmwlumiaaw3 ¶
    Source

    emit_evmwlumiaaw3 :: emit_evmwlumiaaw3_r_r_r

    emit_evmwlumiaaw3_r_r_r ¶
    Source

    emit_evmwlumiaaw3_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwlumiaaw_r_r_r ¶
    Source

    emit_evmwlumiaaw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwlumianw ¶
    Source

    emit_evmwlumianw :: emit_evmwlumianw_r_r_r

    emit_evmwlumianw3 ¶
    Source

    emit_evmwlumianw3 :: emit_evmwlumianw3_r_r_r

    emit_evmwlumianw3_r_r_r ¶
    Source

    emit_evmwlumianw3_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwlumianw_r_r_r ¶
    Source

    emit_evmwlumianw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwlusiaaw ¶
    Source

    emit_evmwlusiaaw :: emit_evmwlusiaaw_r_r_r

    emit_evmwlusiaaw3 ¶
    Source

    emit_evmwlusiaaw3 :: emit_evmwlusiaaw3_r_r_r

    emit_evmwlusiaaw3_r_r_r ¶
    Source

    emit_evmwlusiaaw3_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwlusiaaw_r_r_r ¶
    Source

    emit_evmwlusiaaw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwlusianw ¶
    Source

    emit_evmwlusianw :: emit_evmwlusianw_r_r_r

    emit_evmwlusianw3 ¶
    Source

    emit_evmwlusianw3 :: emit_evmwlusianw3_r_r_r

    emit_evmwlusianw3_r_r_r ¶
    Source

    emit_evmwlusianw3_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwlusianw_r_r_r ¶
    Source

    emit_evmwlusianw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwohgsmf ¶
    Source

    emit_evmwohgsmf :: emit_evmwohgsmf_r_r_r

    emit_evmwohgsmf_r_r_r ¶
    Source

    emit_evmwohgsmf_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwohgsmfa ¶
    Source

    emit_evmwohgsmfa :: emit_evmwohgsmfa_r_r_r

    emit_evmwohgsmfa_r_r_r ¶
    Source

    emit_evmwohgsmfa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwohgsmfaa ¶
    Source

    emit_evmwohgsmfaa :: emit_evmwohgsmfaa_r_r_r

    emit_evmwohgsmfaa_r_r_r ¶
    Source

    emit_evmwohgsmfaa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwohgsmfan ¶
    Source

    emit_evmwohgsmfan :: emit_evmwohgsmfan_r_r_r

    emit_evmwohgsmfan_r_r_r ¶
    Source

    emit_evmwohgsmfan_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwohgsmfr ¶
    Source

    emit_evmwohgsmfr :: emit_evmwohgsmfr_r_r_r

    emit_evmwohgsmfr_r_r_r ¶
    Source

    emit_evmwohgsmfr_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwohgsmfra ¶
    Source

    emit_evmwohgsmfra :: emit_evmwohgsmfra_r_r_r

    emit_evmwohgsmfra_r_r_r ¶
    Source

    emit_evmwohgsmfra_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwohgsmfraa ¶
    Source

    emit_evmwohgsmfraa :: emit_evmwohgsmfraa_r_r_r

    emit_evmwohgsmfraa_r_r_r ¶
    Source

    emit_evmwohgsmfraa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwohgsmfran ¶
    Source

    emit_evmwohgsmfran :: emit_evmwohgsmfran_r_r_r

    emit_evmwohgsmfran_r_r_r ¶
    Source

    emit_evmwohgsmfran_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwsmf ¶
    Source

    emit_evmwsmf :: emit_evmwsmf_r_r_r

    emit_evmwsmf_r_r_r ¶
    Source

    emit_evmwsmf_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwsmfa ¶
    Source

    emit_evmwsmfa :: emit_evmwsmfa_r_r_r

    emit_evmwsmfa_r_r_r ¶
    Source

    emit_evmwsmfa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwsmfaa ¶
    Source

    emit_evmwsmfaa :: emit_evmwsmfaa_r_r_r

    emit_evmwsmfaa_r_r_r ¶
    Source

    emit_evmwsmfaa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwsmfan ¶
    Source

    emit_evmwsmfan :: emit_evmwsmfan_r_r_r

    emit_evmwsmfan_r_r_r ¶
    Source

    emit_evmwsmfan_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwsmi ¶
    Source

    emit_evmwsmi :: emit_evmwsmi_r_r_r

    emit_evmwsmi_r_r_r ¶
    Source

    emit_evmwsmi_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwsmia ¶
    Source

    emit_evmwsmia :: emit_evmwsmia_r_r_r

    emit_evmwsmia_r_r_r ¶
    Source

    emit_evmwsmia_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwsmiaa ¶
    Source

    emit_evmwsmiaa :: emit_evmwsmiaa_r_r_r

    emit_evmwsmiaa_r_r_r ¶
    Source

    emit_evmwsmiaa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwsmian ¶
    Source

    emit_evmwsmian :: emit_evmwsmian_r_r_r

    emit_evmwsmian_r_r_r ¶
    Source

    emit_evmwsmian_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwssf ¶
    Source

    emit_evmwssf :: emit_evmwssf_r_r_r

    emit_evmwssf_r_r_r ¶
    Source

    emit_evmwssf_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwssfa ¶
    Source

    emit_evmwssfa :: emit_evmwssfa_r_r_r

    emit_evmwssfa_r_r_r ¶
    Source

    emit_evmwssfa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwssfaa ¶
    Source

    emit_evmwssfaa :: emit_evmwssfaa_r_r_r

    emit_evmwssfaa_r_r_r ¶
    Source

    emit_evmwssfaa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwssfan ¶
    Source

    emit_evmwssfan :: emit_evmwssfan_r_r_r

    emit_evmwssfan_r_r_r ¶
    Source

    emit_evmwssfan_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwssiaa ¶
    Source

    emit_evmwssiaa :: emit_evmwssiaa_r_r_r

    emit_evmwssiaa_r_r_r ¶
    Source

    emit_evmwssiaa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwssian ¶
    Source

    emit_evmwssian :: emit_evmwssian_r_r_r

    emit_evmwssian_r_r_r ¶
    Source

    emit_evmwssian_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwssiw ¶
    Source

    emit_evmwssiw :: emit_evmwssiw_r_r_r

    emit_evmwssiw_r_r_r ¶
    Source

    emit_evmwssiw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwumi ¶
    Source

    emit_evmwumi :: emit_evmwumi_r_r_r

    emit_evmwumi_r_r_r ¶
    Source

    emit_evmwumi_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwumia ¶
    Source

    emit_evmwumia :: emit_evmwumia_r_r_r

    emit_evmwumia_r_r_r ¶
    Source

    emit_evmwumia_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwumiaa ¶
    Source

    emit_evmwumiaa :: emit_evmwumiaa_r_r_r

    emit_evmwumiaa_r_r_r ¶
    Source

    emit_evmwumiaa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwumian ¶
    Source

    emit_evmwumian :: emit_evmwumian_r_r_r

    emit_evmwumian_r_r_r ¶
    Source

    emit_evmwumian_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwusiaa ¶
    Source

    emit_evmwusiaa :: emit_evmwusiaa_r_r_r

    emit_evmwusiaa_r_r_r ¶
    Source

    emit_evmwusiaa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwusian ¶
    Source

    emit_evmwusian :: emit_evmwusian_r_r_r

    emit_evmwusian_r_r_r ¶
    Source

    emit_evmwusian_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evmwusiw ¶
    Source

    emit_evmwusiw :: emit_evmwusiw_r_r_r

    emit_evmwusiw_r_r_r ¶
    Source

    emit_evmwusiw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evnand ¶
    Source

    emit_evnand :: emit_evnand_r_r_r

    emit_evnand_r_r_r ¶
    Source

    emit_evnand_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evneg ¶
    Source

    emit_evneg :: emit_evneg_r_r_r

    emit_evneg_r_r_r ¶
    Source

    emit_evneg_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evnegb ¶
    Source

    emit_evnegb :: emit_evnegb_r_r_r

    emit_evnegb_r_r_r ¶
    Source

    emit_evnegb_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evnegbo ¶
    Source

    emit_evnegbo :: emit_evnegbo_r_r_r

    emit_evnegbo_r_r_r ¶
    Source

    emit_evnegbo_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evnegbos ¶
    Source

    emit_evnegbos :: emit_evnegbos_r_r_r

    emit_evnegbos_r_r_r ¶
    Source

    emit_evnegbos_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evnegbs ¶
    Source

    emit_evnegbs :: emit_evnegbs_r_r_r

    emit_evnegbs_r_r_r ¶
    Source

    emit_evnegbs_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evnegd ¶
    Source

    emit_evnegd :: emit_evnegd_r_r_r

    emit_evnegd_r_r_r ¶
    Source

    emit_evnegd_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evnegds ¶
    Source

    emit_evnegds :: emit_evnegds_r_r_r

    emit_evnegds_r_r_r ¶
    Source

    emit_evnegds_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evnegh ¶
    Source

    emit_evnegh :: emit_evnegh_r_r_r

    emit_evnegh_r_r_r ¶
    Source

    emit_evnegh_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evnegho ¶
    Source

    emit_evnegho :: emit_evnegho_r_r_r

    emit_evnegho_r_r_r ¶
    Source

    emit_evnegho_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evneghos ¶
    Source

    emit_evneghos :: emit_evneghos_r_r_r

    emit_evneghos_r_r_r ¶
    Source

    emit_evneghos_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evneghs ¶
    Source

    emit_evneghs :: emit_evneghs_r_r_r

    emit_evneghs_r_r_r ¶
    Source

    emit_evneghs_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evnegs ¶
    Source

    emit_evnegs :: emit_evnegs_r_r_r

    emit_evnegs_r_r_r ¶
    Source

    emit_evnegs_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evnegwo ¶
    Source

    emit_evnegwo :: emit_evnegwo_r_r_r

    emit_evnegwo_r_r_r ¶
    Source

    emit_evnegwo_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evnegwos ¶
    Source

    emit_evnegwos :: emit_evnegwos_r_r_r

    emit_evnegwos_r_r_r ¶
    Source

    emit_evnegwos_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evnor ¶
    Source

    emit_evnor :: emit_evnor_r_r_r

    emit_evnor_r_r_r ¶
    Source

    emit_evnor_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evnot ¶
    Source

    emit_evnot :: emit_evnot_r_r_r

    emit_evnot_r_r_r ¶
    Source

    emit_evnot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evor ¶
    Source

    emit_evor :: emit_evor_r_r_r

    emit_evor_r_r_r ¶
    Source

    emit_evor_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evorc ¶
    Source

    emit_evorc :: emit_evorc_r_r_r

    emit_evorc_r_r_r ¶
    Source

    emit_evorc_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evperm ¶
    Source

    emit_evperm :: emit_evperm_r_r_r

    emit_evperm2 ¶
    Source

    emit_evperm2 :: emit_evperm2_r_r_r

    emit_evperm2_r_r_r ¶
    Source

    emit_evperm2_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evperm3 ¶
    Source

    emit_evperm3 :: emit_evperm3_r_r_r

    emit_evperm3_r_r_r ¶
    Source

    emit_evperm3_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evperm_r_r_r ¶
    Source

    emit_evperm_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evpksdshefrs ¶
    Source

    emit_evpksdshefrs :: emit_evpksdshefrs_r_r_r

    emit_evpksdshefrs_r_r_r ¶
    Source

    emit_evpksdshefrs_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evpksdswfrs ¶
    Source

    emit_evpksdswfrs :: emit_evpksdswfrs_r_r_r

    emit_evpksdswfrs_r_r_r ¶
    Source

    emit_evpksdswfrs_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evpksdsws ¶
    Source

    emit_evpksdsws :: emit_evpksdsws_r_r_r

    emit_evpksdsws_r_r_r ¶
    Source

    emit_evpksdsws_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evpkshsbs ¶
    Source

    emit_evpkshsbs :: emit_evpkshsbs_r_r_r

    emit_evpkshsbs_r_r_r ¶
    Source

    emit_evpkshsbs_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evpkshubs ¶
    Source

    emit_evpkshubs :: emit_evpkshubs_r_r_r

    emit_evpkshubs_r_r_r ¶
    Source

    emit_evpkshubs_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evpkswgshefrs ¶
    Source

    emit_evpkswgshefrs :: emit_evpkswgshefrs_r_r_r

    emit_evpkswgshefrs_r_r_r ¶
    Source

    emit_evpkswgshefrs_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evpkswgswfrs ¶
    Source

    emit_evpkswgswfrs :: emit_evpkswgswfrs_r_r_r

    emit_evpkswgswfrs_r_r_r ¶
    Source

    emit_evpkswgswfrs_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evpkswshfrs ¶
    Source

    emit_evpkswshfrs :: emit_evpkswshfrs_r_r_r

    emit_evpkswshfrs_r_r_r ¶
    Source

    emit_evpkswshfrs_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evpkswshilvfrs ¶
    Source

    emit_evpkswshilvfrs :: emit_evpkswshilvfrs_r_r_r

    emit_evpkswshilvfrs_r_r_r ¶
    Source

    emit_evpkswshilvfrs_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evpkswshilvs ¶
    Source

    emit_evpkswshilvs :: emit_evpkswshilvs_r_r_r

    emit_evpkswshilvs_r_r_r ¶
    Source

    emit_evpkswshilvs_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evpkswshs ¶
    Source

    emit_evpkswshs :: emit_evpkswshs_r_r_r

    emit_evpkswshs_r_r_r ¶
    Source

    emit_evpkswshs_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evpkswuhs ¶
    Source

    emit_evpkswuhs :: emit_evpkswuhs_r_r_r

    emit_evpkswuhs_r_r_r ¶
    Source

    emit_evpkswuhs_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evpkuduws ¶
    Source

    emit_evpkuduws :: emit_evpkuduws_r_r_r

    emit_evpkuduws_r_r_r ¶
    Source

    emit_evpkuduws_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evpkuhubs ¶
    Source

    emit_evpkuhubs :: emit_evpkuhubs_r_r_r

    emit_evpkuhubs_r_r_r ¶
    Source

    emit_evpkuhubs_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evpkuwuhs ¶
    Source

    emit_evpkuwuhs :: emit_evpkuwuhs_r_r_r

    emit_evpkuwuhs_r_r_r ¶
    Source

    emit_evpkuwuhs_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evpopcntb ¶
    Source

    emit_evpopcntb :: emit_evpopcntb_r_r_r

    emit_evpopcntb_r_r_r ¶
    Source

    emit_evpopcntb_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evrlb ¶
    Source

    emit_evrlb :: emit_evrlb_r_r_r

    emit_evrlb_r_r_r ¶
    Source

    emit_evrlb_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evrlbi ¶
    Source

    emit_evrlbi :: emit_evrlbi_r_r_r

    emit_evrlbi_r_r_r ¶
    Source

    emit_evrlbi_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evrlh ¶
    Source

    emit_evrlh :: emit_evrlh_r_r_r

    emit_evrlh_r_r_r ¶
    Source

    emit_evrlh_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evrlhi ¶
    Source

    emit_evrlhi :: emit_evrlhi_r_r_r

    emit_evrlhi_r_r_r ¶
    Source

    emit_evrlhi_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evrlw ¶
    Source

    emit_evrlw :: emit_evrlw_r_r_r

    emit_evrlw_r_r_r ¶
    Source

    emit_evrlw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evrlwi ¶
    Source

    emit_evrlwi :: emit_evrlwi_r_r_imm

    emit_evrlwi_r_r_imm ¶
    Source

    emit_evrlwi_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_evrnddnw ¶
    Source

    emit_evrnddnw :: emit_evrnddnw_r_r_r

    emit_evrnddnw_r_r_r ¶
    Source

    emit_evrnddnw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evrnddnwss ¶
    Source

    emit_evrnddnwss :: emit_evrnddnwss_r_r_r

    emit_evrnddnwss_r_r_r ¶
    Source

    emit_evrnddnwss_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evrnddnwus ¶
    Source

    emit_evrnddnwus :: emit_evrnddnwus_r_r_r

    emit_evrnddnwus_r_r_r ¶
    Source

    emit_evrnddnwus_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evrnddw ¶
    Source

    emit_evrnddw :: emit_evrnddw_r_r_r

    emit_evrnddw_r_r_r ¶
    Source

    emit_evrnddw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evrnddwss ¶
    Source

    emit_evrnddwss :: emit_evrnddwss_r_r_r

    emit_evrnddwss_r_r_r ¶
    Source

    emit_evrnddwss_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evrnddwus ¶
    Source

    emit_evrnddwus :: emit_evrnddwus_r_r_r

    emit_evrnddwus_r_r_r ¶
    Source

    emit_evrnddwus_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evrndhb ¶
    Source

    emit_evrndhb :: emit_evrndhb_r_r_r

    emit_evrndhb_r_r_r ¶
    Source

    emit_evrndhb_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evrndhbss ¶
    Source

    emit_evrndhbss :: emit_evrndhbss_r_r_r

    emit_evrndhbss_r_r_r ¶
    Source

    emit_evrndhbss_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evrndhbus ¶
    Source

    emit_evrndhbus :: emit_evrndhbus_r_r_r

    emit_evrndhbus_r_r_r ¶
    Source

    emit_evrndhbus_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evrndhnb ¶
    Source

    emit_evrndhnb :: emit_evrndhnb_r_r_r

    emit_evrndhnb_r_r_r ¶
    Source

    emit_evrndhnb_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evrndhnbss ¶
    Source

    emit_evrndhnbss :: emit_evrndhnbss_r_r_r

    emit_evrndhnbss_r_r_r ¶
    Source

    emit_evrndhnbss_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evrndhnbus ¶
    Source

    emit_evrndhnbus :: emit_evrndhnbus_r_r_r

    emit_evrndhnbus_r_r_r ¶
    Source

    emit_evrndhnbus_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evrndw ¶
    Source

    emit_evrndw :: emit_evrndw_r_r_r

    emit_evrndw_r_r_r ¶
    Source

    emit_evrndw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evrndwh ¶
    Source

    emit_evrndwh :: emit_evrndwh_r_r_r

    emit_evrndwh_r_r_r ¶
    Source

    emit_evrndwh_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evrndwhss ¶
    Source

    emit_evrndwhss :: emit_evrndwhss_r_r_r

    emit_evrndwhss_r_r_r ¶
    Source

    emit_evrndwhss_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evrndwhus ¶
    Source

    emit_evrndwhus :: emit_evrndwhus_r_r_r

    emit_evrndwhus_r_r_r ¶
    Source

    emit_evrndwhus_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evrndwnh ¶
    Source

    emit_evrndwnh :: emit_evrndwnh_r_r_r

    emit_evrndwnh_r_r_r ¶
    Source

    emit_evrndwnh_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evrndwnhss ¶
    Source

    emit_evrndwnhss :: emit_evrndwnhss_r_r_r

    emit_evrndwnhss_r_r_r ¶
    Source

    emit_evrndwnhss_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evrndwnhus ¶
    Source

    emit_evrndwnhus :: emit_evrndwnhus_r_r_r

    emit_evrndwnhus_r_r_r ¶
    Source

    emit_evrndwnhus_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsabs ¶
    Source

    emit_evsabs :: emit_evsabs_r_r_r

    emit_evsabs_r_r_r ¶
    Source

    emit_evsabs_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsad2sh ¶
    Source

    emit_evsad2sh :: emit_evsad2sh_r_r_r

    emit_evsad2sh_r_r_r ¶
    Source

    emit_evsad2sh_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsad2sha ¶
    Source

    emit_evsad2sha :: emit_evsad2sha_r_r_r

    emit_evsad2sha_r_r_r ¶
    Source

    emit_evsad2sha_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsad2shaaw ¶
    Source

    emit_evsad2shaaw :: emit_evsad2shaaw_r_r_r

    emit_evsad2shaaw_r_r_r ¶
    Source

    emit_evsad2shaaw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsad2uh ¶
    Source

    emit_evsad2uh :: emit_evsad2uh_r_r_r

    emit_evsad2uh_r_r_r ¶
    Source

    emit_evsad2uh_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsad2uha ¶
    Source

    emit_evsad2uha :: emit_evsad2uha_r_r_r

    emit_evsad2uha_r_r_r ¶
    Source

    emit_evsad2uha_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsad2uhaaw ¶
    Source

    emit_evsad2uhaaw :: emit_evsad2uhaaw_r_r_r

    emit_evsad2uhaaw_r_r_r ¶
    Source

    emit_evsad2uhaaw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsad4sb ¶
    Source

    emit_evsad4sb :: emit_evsad4sb_r_r_r

    emit_evsad4sb_r_r_r ¶
    Source

    emit_evsad4sb_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsad4sba ¶
    Source

    emit_evsad4sba :: emit_evsad4sba_r_r_r

    emit_evsad4sba_r_r_r ¶
    Source

    emit_evsad4sba_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsad4sbaaw ¶
    Source

    emit_evsad4sbaaw :: emit_evsad4sbaaw_r_r_r

    emit_evsad4sbaaw_r_r_r ¶
    Source

    emit_evsad4sbaaw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsad4ub ¶
    Source

    emit_evsad4ub :: emit_evsad4ub_r_r_r

    emit_evsad4ub_r_r_r ¶
    Source

    emit_evsad4ub_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsad4uba ¶
    Source

    emit_evsad4uba :: emit_evsad4uba_r_r_r

    emit_evsad4uba_r_r_r ¶
    Source

    emit_evsad4uba_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsad4ubaaw ¶
    Source

    emit_evsad4ubaaw :: emit_evsad4ubaaw_r_r_r

    emit_evsad4ubaaw_r_r_r ¶
    Source

    emit_evsad4ubaaw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsadd ¶
    Source

    emit_evsadd :: emit_evsadd_r_r_r

    emit_evsadd_r_r_r ¶
    Source

    emit_evsadd_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsadsw ¶
    Source

    emit_evsadsw :: emit_evsadsw_r_r_r

    emit_evsadsw_r_r_r ¶
    Source

    emit_evsadsw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsadswa ¶
    Source

    emit_evsadswa :: emit_evsadswa_r_r_r

    emit_evsadswa_r_r_r ¶
    Source

    emit_evsadswa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsadswaa ¶
    Source

    emit_evsadswaa :: emit_evsadswaa_r_r_r

    emit_evsadswaa_r_r_r ¶
    Source

    emit_evsadswaa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsaduw ¶
    Source

    emit_evsaduw :: emit_evsaduw_r_r_r

    emit_evsaduw_r_r_r ¶
    Source

    emit_evsaduw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsaduwa ¶
    Source

    emit_evsaduwa :: emit_evsaduwa_r_r_r

    emit_evsaduwa_r_r_r ¶
    Source

    emit_evsaduwa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsaduwaa ¶
    Source

    emit_evsaduwaa :: emit_evsaduwaa_r_r_r

    emit_evsaduwaa_r_r_r ¶
    Source

    emit_evsaduwaa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsatsbub ¶
    Source

    emit_evsatsbub :: emit_evsatsbub_r_r_r

    emit_evsatsbub_r_r_r ¶
    Source

    emit_evsatsbub_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsatsdsw ¶
    Source

    emit_evsatsdsw :: emit_evsatsdsw_r_r_r

    emit_evsatsdsw_r_r_r ¶
    Source

    emit_evsatsdsw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsatsduw ¶
    Source

    emit_evsatsduw :: emit_evsatsduw_r_r_r

    emit_evsatsduw_r_r_r ¶
    Source

    emit_evsatsduw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsatshsb ¶
    Source

    emit_evsatshsb :: emit_evsatshsb_r_r_r

    emit_evsatshsb_r_r_r ¶
    Source

    emit_evsatshsb_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsatshub ¶
    Source

    emit_evsatshub :: emit_evsatshub_r_r_r

    emit_evsatshub_r_r_r ¶
    Source

    emit_evsatshub_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsatshuh ¶
    Source

    emit_evsatshuh :: emit_evsatshuh_r_r_r

    emit_evsatshuh_r_r_r ¶
    Source

    emit_evsatshuh_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsatswgsdf ¶
    Source

    emit_evsatswgsdf :: emit_evsatswgsdf_r_r_r

    emit_evsatswgsdf_r_r_r ¶
    Source

    emit_evsatswgsdf_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsatswsh ¶
    Source

    emit_evsatswsh :: emit_evsatswsh_r_r_r

    emit_evsatswsh_r_r_r ¶
    Source

    emit_evsatswsh_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsatswuh ¶
    Source

    emit_evsatswuh :: emit_evsatswuh_r_r_r

    emit_evsatswuh_r_r_r ¶
    Source

    emit_evsatswuh_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsatswuw ¶
    Source

    emit_evsatswuw :: emit_evsatswuw_r_r_r

    emit_evsatswuw_r_r_r ¶
    Source

    emit_evsatswuw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsatubsb ¶
    Source

    emit_evsatubsb :: emit_evsatubsb_r_r_r

    emit_evsatubsb_r_r_r ¶
    Source

    emit_evsatubsb_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsatuduw ¶
    Source

    emit_evsatuduw :: emit_evsatuduw_r_r_r

    emit_evsatuduw_r_r_r ¶
    Source

    emit_evsatuduw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsatuhsh ¶
    Source

    emit_evsatuhsh :: emit_evsatuhsh_r_r_r

    emit_evsatuhsh_r_r_r ¶
    Source

    emit_evsatuhsh_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsatuhub ¶
    Source

    emit_evsatuhub :: emit_evsatuhub_r_r_r

    emit_evsatuhub_r_r_r ¶
    Source

    emit_evsatuhub_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsatuwsw ¶
    Source

    emit_evsatuwsw :: emit_evsatuwsw_r_r_r

    emit_evsatuwsw_r_r_r ¶
    Source

    emit_evsatuwsw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsatuwuh ¶
    Source

    emit_evsatuwuh :: emit_evsatuwuh_r_r_r

    emit_evsatuwuh_r_r_r ¶
    Source

    emit_evsatuwuh_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evscfsf ¶
    Source

    emit_evscfsf :: emit_evscfsf_r_r_r

    emit_evscfsf_r_r_r ¶
    Source

    emit_evscfsf_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evscfsi ¶
    Source

    emit_evscfsi :: emit_evscfsi_r_r_r

    emit_evscfsi_r_r_r ¶
    Source

    emit_evscfsi_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evscfuf ¶
    Source

    emit_evscfuf :: emit_evscfuf_r_r_r

    emit_evscfuf_r_r_r ¶
    Source

    emit_evscfuf_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evscfui ¶
    Source

    emit_evscfui :: emit_evscfui_r_r_r

    emit_evscfui_r_r_r ¶
    Source

    emit_evscfui_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evscmpgt ¶
    Source

    emit_evscmpgt :: emit_evscmpgt_r_r_r

    emit_evscmpgt_r_r_r ¶
    Source

    emit_evscmpgt_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsctsf ¶
    Source

    emit_evsctsf :: emit_evsctsf_r_r_r

    emit_evsctsf_r_r_r ¶
    Source

    emit_evsctsf_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsctsi ¶
    Source

    emit_evsctsi :: emit_evsctsi_r_r_r

    emit_evsctsi_r_r_r ¶
    Source

    emit_evsctsi_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsctsiz ¶
    Source

    emit_evsctsiz :: emit_evsctsiz_r_r_r

    emit_evsctsiz_r_r_r ¶
    Source

    emit_evsctsiz_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsctuf ¶
    Source

    emit_evsctuf :: emit_evsctuf_r_r_r

    emit_evsctuf_r_r_r ¶
    Source

    emit_evsctuf_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsctui ¶
    Source

    emit_evsctui :: emit_evsctui_r_r_r

    emit_evsctui_r_r_r ¶
    Source

    emit_evsctui_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsctuiz ¶
    Source

    emit_evsctuiz :: emit_evsctuiz_r_r_r

    emit_evsctuiz_r_r_r ¶
    Source

    emit_evsctuiz_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsdiv ¶
    Source

    emit_evsdiv :: emit_evsdiv_r_r_r

    emit_evsdiv_r_r_r ¶
    Source

    emit_evsdiv_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsel ¶
    Source

    emit_evsel :: emit_evsel_r_r_r_crf

    emit_evsel_r_r_r_crf ¶
    Source

    emit_evsel_r_r_r_crf :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_evselbit ¶
    Source

    emit_evselbit :: emit_evselbit_r_r_r

    emit_evselbit_r_r_r ¶
    Source

    emit_evselbit_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evselbitm0 ¶
    Source

    emit_evselbitm0 :: emit_evselbitm0_r_r_r

    emit_evselbitm0_r_r_r ¶
    Source

    emit_evselbitm0_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evselbitm1 ¶
    Source

    emit_evselbitm1 :: emit_evselbitm1_r_r_r

    emit_evselbitm1_r_r_r ¶
    Source

    emit_evselbitm1_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evseteqb ¶
    Source

    emit_evseteqb :: emit_evseteqb_r_r_r

    emit_evseteqb_dot ¶
    Source

    emit_evseteqb_dot :: emit_evseteqb_dot_r_r_r

    emit_evseteqb_dot_r_r_r ¶
    Source

    emit_evseteqb_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evseteqb_r_r_r ¶
    Source

    emit_evseteqb_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evseteqh ¶
    Source

    emit_evseteqh :: emit_evseteqh_r_r_r

    emit_evseteqh_dot ¶
    Source

    emit_evseteqh_dot :: emit_evseteqh_dot_r_r_r

    emit_evseteqh_dot_r_r_r ¶
    Source

    emit_evseteqh_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evseteqh_r_r_r ¶
    Source

    emit_evseteqh_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evseteqw ¶
    Source

    emit_evseteqw :: emit_evseteqw_r_r_r

    emit_evseteqw_dot ¶
    Source

    emit_evseteqw_dot :: emit_evseteqw_dot_r_r_r

    emit_evseteqw_dot_r_r_r ¶
    Source

    emit_evseteqw_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evseteqw_r_r_r ¶
    Source

    emit_evseteqw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsetgtbs ¶
    Source

    emit_evsetgtbs :: emit_evsetgtbs_r_r_r

    emit_evsetgtbs_dot ¶
    Source

    emit_evsetgtbs_dot :: emit_evsetgtbs_dot_r_r_r

    emit_evsetgtbs_dot_r_r_r ¶
    Source

    emit_evsetgtbs_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsetgtbs_r_r_r ¶
    Source

    emit_evsetgtbs_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsetgtbu ¶
    Source

    emit_evsetgtbu :: emit_evsetgtbu_r_r_r

    emit_evsetgtbu_dot ¶
    Source

    emit_evsetgtbu_dot :: emit_evsetgtbu_dot_r_r_r

    emit_evsetgtbu_dot_r_r_r ¶
    Source

    emit_evsetgtbu_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsetgtbu_r_r_r ¶
    Source

    emit_evsetgtbu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsetgths ¶
    Source

    emit_evsetgths :: emit_evsetgths_r_r_r

    emit_evsetgths_dot ¶
    Source

    emit_evsetgths_dot :: emit_evsetgths_dot_r_r_r

    emit_evsetgths_dot_r_r_r ¶
    Source

    emit_evsetgths_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsetgths_r_r_r ¶
    Source

    emit_evsetgths_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsetgthu ¶
    Source

    emit_evsetgthu :: emit_evsetgthu_r_r_r

    emit_evsetgthu_dot ¶
    Source

    emit_evsetgthu_dot :: emit_evsetgthu_dot_r_r_r

    emit_evsetgthu_dot_r_r_r ¶
    Source

    emit_evsetgthu_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsetgthu_r_r_r ¶
    Source

    emit_evsetgthu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsetgtws ¶
    Source

    emit_evsetgtws :: emit_evsetgtws_r_r_r

    emit_evsetgtws_dot ¶
    Source

    emit_evsetgtws_dot :: emit_evsetgtws_dot_r_r_r

    emit_evsetgtws_dot_r_r_r ¶
    Source

    emit_evsetgtws_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsetgtws_r_r_r ¶
    Source

    emit_evsetgtws_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsetgtwu ¶
    Source

    emit_evsetgtwu :: emit_evsetgtwu_r_r_r

    emit_evsetgtwu_dot ¶
    Source

    emit_evsetgtwu_dot :: emit_evsetgtwu_dot_r_r_r

    emit_evsetgtwu_dot_r_r_r ¶
    Source

    emit_evsetgtwu_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsetgtwu_r_r_r ¶
    Source

    emit_evsetgtwu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsetltbs ¶
    Source

    emit_evsetltbs :: emit_evsetltbs_r_r_r

    emit_evsetltbs_dot ¶
    Source

    emit_evsetltbs_dot :: emit_evsetltbs_dot_r_r_r

    emit_evsetltbs_dot_r_r_r ¶
    Source

    emit_evsetltbs_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsetltbs_r_r_r ¶
    Source

    emit_evsetltbs_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsetltbu ¶
    Source

    emit_evsetltbu :: emit_evsetltbu_r_r_r

    emit_evsetltbu_dot ¶
    Source

    emit_evsetltbu_dot :: emit_evsetltbu_dot_r_r_r

    emit_evsetltbu_dot_r_r_r ¶
    Source

    emit_evsetltbu_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsetltbu_r_r_r ¶
    Source

    emit_evsetltbu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsetlths ¶
    Source

    emit_evsetlths :: emit_evsetlths_r_r_r

    emit_evsetlths_dot ¶
    Source

    emit_evsetlths_dot :: emit_evsetlths_dot_r_r_r

    emit_evsetlths_dot_r_r_r ¶
    Source

    emit_evsetlths_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsetlths_r_r_r ¶
    Source

    emit_evsetlths_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsetlthu ¶
    Source

    emit_evsetlthu :: emit_evsetlthu_r_r_r

    emit_evsetlthu_dot ¶
    Source

    emit_evsetlthu_dot :: emit_evsetlthu_dot_r_r_r

    emit_evsetlthu_dot_r_r_r ¶
    Source

    emit_evsetlthu_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsetlthu_r_r_r ¶
    Source

    emit_evsetlthu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsetltws ¶
    Source

    emit_evsetltws :: emit_evsetltws_r_r_r

    emit_evsetltws_dot ¶
    Source

    emit_evsetltws_dot :: emit_evsetltws_dot_r_r_r

    emit_evsetltws_dot_r_r_r ¶
    Source

    emit_evsetltws_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsetltws_r_r_r ¶
    Source

    emit_evsetltws_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsetltwu ¶
    Source

    emit_evsetltwu :: emit_evsetltwu_r_r_r

    emit_evsetltwu_dot ¶
    Source

    emit_evsetltwu_dot :: emit_evsetltwu_dot_r_r_r

    emit_evsetltwu_dot_r_r_r ¶
    Source

    emit_evsetltwu_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsetltwu_r_r_r ¶
    Source

    emit_evsetltwu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsgmpeq ¶
    Source

    emit_evsgmpeq :: emit_evsgmpeq_r_r_r

    emit_evsgmpeq_r_r_r ¶
    Source

    emit_evsgmpeq_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsgmplt ¶
    Source

    emit_evsgmplt :: emit_evsgmplt_r_r_r

    emit_evsgmplt_r_r_r ¶
    Source

    emit_evsgmplt_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsl ¶
    Source

    emit_evsl :: emit_evsl_r_r_r

    emit_evsl_r_r_r ¶
    Source

    emit_evsl_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evslb ¶
    Source

    emit_evslb :: emit_evslb_r_r_r

    emit_evslb_r_r_r ¶
    Source

    emit_evslb_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evslbi ¶
    Source

    emit_evslbi :: emit_evslbi_r_r_r

    emit_evslbi_r_r_r ¶
    Source

    emit_evslbi_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evslh ¶
    Source

    emit_evslh :: emit_evslh_r_r_r

    emit_evslh_r_r_r ¶
    Source

    emit_evslh_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evslhi ¶
    Source

    emit_evslhi :: emit_evslhi_r_r_r

    emit_evslhi_r_r_r ¶
    Source

    emit_evslhi_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsli ¶
    Source

    emit_evsli :: emit_evsli_r_r_r

    emit_evsli_r_r_r ¶
    Source

    emit_evsli_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsloi ¶
    Source

    emit_evsloi :: emit_evsloi_r_r_r

    emit_evsloi_r_r_r ¶
    Source

    emit_evsloi_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evslw ¶
    Source

    emit_evslw :: emit_evslw_r_r_r

    emit_evslw_r_r_r ¶
    Source

    emit_evslw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evslwi ¶
    Source

    emit_evslwi :: emit_evslwi_r_r_imm

    emit_evslwi_r_r_imm ¶
    Source

    emit_evslwi_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_evsmul ¶
    Source

    emit_evsmul :: emit_evsmul_r_r_r

    emit_evsmul_r_r_r ¶
    Source

    emit_evsmul_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsnabs ¶
    Source

    emit_evsnabs :: emit_evsnabs_r_r_r

    emit_evsnabs_r_r_r ¶
    Source

    emit_evsnabs_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsneg ¶
    Source

    emit_evsneg :: emit_evsneg_r_r_r

    emit_evsneg_r_r_r ¶
    Source

    emit_evsneg_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsplatb ¶
    Source

    emit_evsplatb :: emit_evsplatb_r_r_r

    emit_evsplatb_r_r_r ¶
    Source

    emit_evsplatb_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsplatfi ¶
    Source

    emit_evsplatfi :: emit_evsplatfi_r_imm

    emit_evsplatfi_r_imm ¶
    Source

    emit_evsplatfi_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, imm: i64) {…}

    emit_evsplatfia ¶
    Source

    emit_evsplatfia :: emit_evsplatfia_r_r_r

    emit_evsplatfia_r_r_r ¶
    Source

    emit_evsplatfia_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsplatfib ¶
    Source

    emit_evsplatfib :: emit_evsplatfib_r_r_r

    emit_evsplatfib_r_r_r ¶
    Source

    emit_evsplatfib_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsplatfiba ¶
    Source

    emit_evsplatfiba :: emit_evsplatfiba_r_r_r

    emit_evsplatfiba_r_r_r ¶
    Source

    emit_evsplatfiba_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsplatfibo ¶
    Source

    emit_evsplatfibo :: emit_evsplatfibo_r_r_r

    emit_evsplatfibo_r_r_r ¶
    Source

    emit_evsplatfibo_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsplatfiboa ¶
    Source

    emit_evsplatfiboa :: emit_evsplatfiboa_r_r_r

    emit_evsplatfiboa_r_r_r ¶
    Source

    emit_evsplatfiboa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsplatfid ¶
    Source

    emit_evsplatfid :: emit_evsplatfid_r_r_r

    emit_evsplatfid_r_r_r ¶
    Source

    emit_evsplatfid_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsplatfida ¶
    Source

    emit_evsplatfida :: emit_evsplatfida_r_r_r

    emit_evsplatfida_r_r_r ¶
    Source

    emit_evsplatfida_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsplatfih ¶
    Source

    emit_evsplatfih :: emit_evsplatfih_r_r_r

    emit_evsplatfih_r_r_r ¶
    Source

    emit_evsplatfih_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsplatfiha ¶
    Source

    emit_evsplatfiha :: emit_evsplatfiha_r_r_r

    emit_evsplatfiha_r_r_r ¶
    Source

    emit_evsplatfiha_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsplatfiho ¶
    Source

    emit_evsplatfiho :: emit_evsplatfiho_r_r_r

    emit_evsplatfiho_r_r_r ¶
    Source

    emit_evsplatfiho_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsplatfihoa ¶
    Source

    emit_evsplatfihoa :: emit_evsplatfihoa_r_r_r

    emit_evsplatfihoa_r_r_r ¶
    Source

    emit_evsplatfihoa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsplatfio ¶
    Source

    emit_evsplatfio :: emit_evsplatfio_r_r_r

    emit_evsplatfio_r_r_r ¶
    Source

    emit_evsplatfio_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsplatfioa ¶
    Source

    emit_evsplatfioa :: emit_evsplatfioa_r_r_r

    emit_evsplatfioa_r_r_r ¶
    Source

    emit_evsplatfioa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsplath ¶
    Source

    emit_evsplath :: emit_evsplath_r_r_r

    emit_evsplath_r_r_r ¶
    Source

    emit_evsplath_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsplati ¶
    Source

    emit_evsplati :: emit_evsplati_r_imm

    emit_evsplati_r_imm ¶
    Source

    emit_evsplati_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, imm: i64) {…}

    emit_evsplatia ¶
    Source

    emit_evsplatia :: emit_evsplatia_r_r_r

    emit_evsplatia_r_r_r ¶
    Source

    emit_evsplatia_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsplatib ¶
    Source

    emit_evsplatib :: emit_evsplatib_r_r_r

    emit_evsplatib_r_r_r ¶
    Source

    emit_evsplatib_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsplatiba ¶
    Source

    emit_evsplatiba :: emit_evsplatiba_r_r_r

    emit_evsplatiba_r_r_r ¶
    Source

    emit_evsplatiba_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsplatibe ¶
    Source

    emit_evsplatibe :: emit_evsplatibe_r_r_r

    emit_evsplatibe_r_r_r ¶
    Source

    emit_evsplatibe_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsplatibea ¶
    Source

    emit_evsplatibea :: emit_evsplatibea_r_r_r

    emit_evsplatibea_r_r_r ¶
    Source

    emit_evsplatibea_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsplatid ¶
    Source

    emit_evsplatid :: emit_evsplatid_r_r_r

    emit_evsplatid_r_r_r ¶
    Source

    emit_evsplatid_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsplatida ¶
    Source

    emit_evsplatida :: emit_evsplatida_r_r_r

    emit_evsplatida_r_r_r ¶
    Source

    emit_evsplatida_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsplatie ¶
    Source

    emit_evsplatie :: emit_evsplatie_r_r_r

    emit_evsplatie_r_r_r ¶
    Source

    emit_evsplatie_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsplatiea ¶
    Source

    emit_evsplatiea :: emit_evsplatiea_r_r_r

    emit_evsplatiea_r_r_r ¶
    Source

    emit_evsplatiea_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsplatih ¶
    Source

    emit_evsplatih :: emit_evsplatih_r_r_r

    emit_evsplatih_r_r_r ¶
    Source

    emit_evsplatih_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsplatiha ¶
    Source

    emit_evsplatiha :: emit_evsplatiha_r_r_r

    emit_evsplatiha_r_r_r ¶
    Source

    emit_evsplatiha_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsplatihe ¶
    Source

    emit_evsplatihe :: emit_evsplatihe_r_r_r

    emit_evsplatihe_r_r_r ¶
    Source

    emit_evsplatihe_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsplatihea ¶
    Source

    emit_evsplatihea :: emit_evsplatihea_r_r_r

    emit_evsplatihea_r_r_r ¶
    Source

    emit_evsplatihea_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsrbis ¶
    Source

    emit_evsrbis :: emit_evsrbis_r_r_r

    emit_evsrbis_r_r_r ¶
    Source

    emit_evsrbis_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsrbiu ¶
    Source

    emit_evsrbiu :: emit_evsrbiu_r_r_r

    emit_evsrbiu_r_r_r ¶
    Source

    emit_evsrbiu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsrbs ¶
    Source

    emit_evsrbs :: emit_evsrbs_r_r_r

    emit_evsrbs_r_r_r ¶
    Source

    emit_evsrbs_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsrbu ¶
    Source

    emit_evsrbu :: emit_evsrbu_r_r_r

    emit_evsrbu_r_r_r ¶
    Source

    emit_evsrbu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsrhis ¶
    Source

    emit_evsrhis :: emit_evsrhis_r_r_r

    emit_evsrhis_r_r_r ¶
    Source

    emit_evsrhis_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsrhiu ¶
    Source

    emit_evsrhiu :: emit_evsrhiu_r_r_r

    emit_evsrhiu_r_r_r ¶
    Source

    emit_evsrhiu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsrhs ¶
    Source

    emit_evsrhs :: emit_evsrhs_r_r_r

    emit_evsrhs_r_r_r ¶
    Source

    emit_evsrhs_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsrhu ¶
    Source

    emit_evsrhu :: emit_evsrhu_r_r_r

    emit_evsrhu_r_r_r ¶
    Source

    emit_evsrhu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsris ¶
    Source

    emit_evsris :: emit_evsris_r_r_r

    emit_evsris_r_r_r ¶
    Source

    emit_evsris_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsriu ¶
    Source

    emit_evsriu :: emit_evsriu_r_r_r

    emit_evsriu_r_r_r ¶
    Source

    emit_evsriu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsrois ¶
    Source

    emit_evsrois :: emit_evsrois_r_r_r

    emit_evsrois_r_r_r ¶
    Source

    emit_evsrois_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsroiu ¶
    Source

    emit_evsroiu :: emit_evsroiu_r_r_r

    emit_evsroiu_r_r_r ¶
    Source

    emit_evsroiu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsrs ¶
    Source

    emit_evsrs :: emit_evsrs_r_r_r

    emit_evsrs_r_r_r ¶
    Source

    emit_evsrs_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsru ¶
    Source

    emit_evsru :: emit_evsru_r_r_r

    emit_evsru_r_r_r ¶
    Source

    emit_evsru_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsrwis ¶
    Source

    emit_evsrwis :: emit_evsrwis_r_r_imm

    emit_evsrwis_r_r_imm ¶
    Source

    emit_evsrwis_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_evsrwiu ¶
    Source

    emit_evsrwiu :: emit_evsrwiu_r_r_imm

    emit_evsrwiu_r_r_imm ¶
    Source

    emit_evsrwiu_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_evsrws ¶
    Source

    emit_evsrws :: emit_evsrws_r_r_r

    emit_evsrws_r_r_r ¶
    Source

    emit_evsrws_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsrwu ¶
    Source

    emit_evsrwu :: emit_evsrwu_r_r_r

    emit_evsrwu_r_r_r ¶
    Source

    emit_evsrwu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evssub ¶
    Source

    emit_evssub :: emit_evssub_r_r_r

    emit_evssub_r_r_r ¶
    Source

    emit_evssub_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evstdb ¶
    Source

    emit_evstdb :: emit_evstdb_r_r_r

    emit_evstdb_r_r_r ¶
    Source

    emit_evstdb_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evstdbmx ¶
    Source

    emit_evstdbmx :: emit_evstdbmx_r_r_r

    emit_evstdbmx_r_r_r ¶
    Source

    emit_evstdbmx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evstdbu ¶
    Source

    emit_evstdbu :: emit_evstdbu_r_r_r

    emit_evstdbu_r_r_r ¶
    Source

    emit_evstdbu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evstdbx ¶
    Source

    emit_evstdbx :: emit_evstdbx_r_r_r

    emit_evstdbx_r_r_r ¶
    Source

    emit_evstdbx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evstdd ¶
    Source

    emit_evstdd :: emit_evstdd_r_mem

    emit_evstdd_r_mem ¶
    Source

    emit_evstdd_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_evstddepx ¶
    Source

    emit_evstddepx :: emit_evstddepx_r_r_r

    emit_evstddepx_r_r_r ¶
    Source

    emit_evstddepx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evstddmx ¶
    Source

    emit_evstddmx :: emit_evstddmx_r_r_r

    emit_evstddmx_r_r_r ¶
    Source

    emit_evstddmx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evstddu ¶
    Source

    emit_evstddu :: emit_evstddu_r_r_r

    emit_evstddu_r_r_r ¶
    Source

    emit_evstddu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evstddx ¶
    Source

    emit_evstddx :: emit_evstddx_r_r_r

    emit_evstddx_r_r_r ¶
    Source

    emit_evstddx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evstdh ¶
    Source

    emit_evstdh :: emit_evstdh_r_mem

    emit_evstdh_r_mem ¶
    Source

    emit_evstdh_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_evstdhmx ¶
    Source

    emit_evstdhmx :: emit_evstdhmx_r_r_r

    emit_evstdhmx_r_r_r ¶
    Source

    emit_evstdhmx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evstdhu ¶
    Source

    emit_evstdhu :: emit_evstdhu_r_r_r

    emit_evstdhu_r_r_r ¶
    Source

    emit_evstdhu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evstdhx ¶
    Source

    emit_evstdhx :: emit_evstdhx_r_r_r

    emit_evstdhx_r_r_r ¶
    Source

    emit_evstdhx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evstdw ¶
    Source

    emit_evstdw :: emit_evstdw_r_mem

    emit_evstdw_r_mem ¶
    Source

    emit_evstdw_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_evstdwmx ¶
    Source

    emit_evstdwmx :: emit_evstdwmx_r_r_r

    emit_evstdwmx_r_r_r ¶
    Source

    emit_evstdwmx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evstdwu ¶
    Source

    emit_evstdwu :: emit_evstdwu_r_r_r

    emit_evstdwu_r_r_r ¶
    Source

    emit_evstdwu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evstdwx ¶
    Source

    emit_evstdwx :: emit_evstdwx_r_r_r

    emit_evstdwx_r_r_r ¶
    Source

    emit_evstdwx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsthb ¶
    Source

    emit_evsthb :: emit_evsthb_r_r_r

    emit_evsthb_r_r_r ¶
    Source

    emit_evsthb_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsthbmx ¶
    Source

    emit_evsthbmx :: emit_evsthbmx_r_r_r

    emit_evsthbmx_r_r_r ¶
    Source

    emit_evsthbmx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsthbu ¶
    Source

    emit_evsthbu :: emit_evsthbu_r_r_r

    emit_evsthbu_r_r_r ¶
    Source

    emit_evsthbu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsthbx ¶
    Source

    emit_evsthbx :: emit_evsthbx_r_r_r

    emit_evsthbx_r_r_r ¶
    Source

    emit_evsthbx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evststeq ¶
    Source

    emit_evststeq :: emit_evststeq_r_r_r

    emit_evststeq_r_r_r ¶
    Source

    emit_evststeq_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evststgt ¶
    Source

    emit_evststgt :: emit_evststgt_r_r_r

    emit_evststgt_r_r_r ¶
    Source

    emit_evststgt_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evststlt ¶
    Source

    emit_evststlt :: emit_evststlt_r_r_r

    emit_evststlt_r_r_r ¶
    Source

    emit_evststlt_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evstwb ¶
    Source

    emit_evstwb :: emit_evstwb_r_r_r

    emit_evstwb_r_r_r ¶
    Source

    emit_evstwb_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evstwbe ¶
    Source

    emit_evstwbe :: emit_evstwbe_r_r_r

    emit_evstwbe_r_r_r ¶
    Source

    emit_evstwbe_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evstwbemx ¶
    Source

    emit_evstwbemx :: emit_evstwbemx_r_r_r

    emit_evstwbemx_r_r_r ¶
    Source

    emit_evstwbemx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evstwbeu ¶
    Source

    emit_evstwbeu :: emit_evstwbeu_r_r_r

    emit_evstwbeu_r_r_r ¶
    Source

    emit_evstwbeu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evstwbex ¶
    Source

    emit_evstwbex :: emit_evstwbex_r_r_r

    emit_evstwbex_r_r_r ¶
    Source

    emit_evstwbex_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evstwbmx ¶
    Source

    emit_evstwbmx :: emit_evstwbmx_r_r_r

    emit_evstwbmx_r_r_r ¶
    Source

    emit_evstwbmx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evstwbo ¶
    Source

    emit_evstwbo :: emit_evstwbo_r_r_r

    emit_evstwbo_r_r_r ¶
    Source

    emit_evstwbo_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evstwbomx ¶
    Source

    emit_evstwbomx :: emit_evstwbomx_r_r_r

    emit_evstwbomx_r_r_r ¶
    Source

    emit_evstwbomx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evstwbou ¶
    Source

    emit_evstwbou :: emit_evstwbou_r_r_r

    emit_evstwbou_r_r_r ¶
    Source

    emit_evstwbou_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evstwbox ¶
    Source

    emit_evstwbox :: emit_evstwbox_r_r_r

    emit_evstwbox_r_r_r ¶
    Source

    emit_evstwbox_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evstwbu ¶
    Source

    emit_evstwbu :: emit_evstwbu_r_r_r

    emit_evstwbu_r_r_r ¶
    Source

    emit_evstwbu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evstwbx ¶
    Source

    emit_evstwbx :: emit_evstwbx_r_r_r

    emit_evstwbx_r_r_r ¶
    Source

    emit_evstwbx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evstwhe ¶
    Source

    emit_evstwhe :: emit_evstwhe_r_mem

    emit_evstwhe_r_mem ¶
    Source

    emit_evstwhe_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_evstwhemx ¶
    Source

    emit_evstwhemx :: emit_evstwhemx_r_r_r

    emit_evstwhemx_r_r_r ¶
    Source

    emit_evstwhemx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evstwheu ¶
    Source

    emit_evstwheu :: emit_evstwheu_r_r_r

    emit_evstwheu_r_r_r ¶
    Source

    emit_evstwheu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evstwhex ¶
    Source

    emit_evstwhex :: emit_evstwhex_r_r_r

    emit_evstwhex_r_r_r ¶
    Source

    emit_evstwhex_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evstwho ¶
    Source

    emit_evstwho :: emit_evstwho_r_mem

    emit_evstwho_r_mem ¶
    Source

    emit_evstwho_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_evstwhomx ¶
    Source

    emit_evstwhomx :: emit_evstwhomx_r_r_r

    emit_evstwhomx_r_r_r ¶
    Source

    emit_evstwhomx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evstwhou ¶
    Source

    emit_evstwhou :: emit_evstwhou_r_r_r

    emit_evstwhou_r_r_r ¶
    Source

    emit_evstwhou_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evstwhox ¶
    Source

    emit_evstwhox :: emit_evstwhox_r_r_r

    emit_evstwhox_r_r_r ¶
    Source

    emit_evstwhox_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evstwwe ¶
    Source

    emit_evstwwe :: emit_evstwwe_r_mem

    emit_evstwwe_r_mem ¶
    Source

    emit_evstwwe_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_evstwwemx ¶
    Source

    emit_evstwwemx :: emit_evstwwemx_r_r_r

    emit_evstwwemx_r_r_r ¶
    Source

    emit_evstwwemx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evstwweu ¶
    Source

    emit_evstwweu :: emit_evstwweu_r_r_r

    emit_evstwweu_r_r_r ¶
    Source

    emit_evstwweu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evstwwex ¶
    Source

    emit_evstwwex :: emit_evstwwex_r_r_r

    emit_evstwwex_r_r_r ¶
    Source

    emit_evstwwex_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evstwwo ¶
    Source

    emit_evstwwo :: emit_evstwwo_r_mem

    emit_evstwwo_r_mem ¶
    Source

    emit_evstwwo_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_evstwwomx ¶
    Source

    emit_evstwwomx :: emit_evstwwomx_r_r_r

    emit_evstwwomx_r_r_r ¶
    Source

    emit_evstwwomx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evstwwou ¶
    Source

    emit_evstwwou :: emit_evstwwou_r_r_r

    emit_evstwwou_r_r_r ¶
    Source

    emit_evstwwou_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evstwwox ¶
    Source

    emit_evstwwox :: emit_evstwwox_r_r_r

    emit_evstwwox_r_r_r ¶
    Source

    emit_evstwwox_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsubf2add2h ¶
    Source

    emit_evsubf2add2h :: emit_evsubf2add2h_r_r_r

    emit_evsubf2add2h_r_r_r ¶
    Source

    emit_evsubf2add2h_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsubf2add2hss ¶
    Source

    emit_evsubf2add2hss :: emit_evsubf2add2hss_r_r_r

    emit_evsubf2add2hss_r_r_r ¶
    Source

    emit_evsubf2add2hss_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsubfaddh ¶
    Source

    emit_evsubfaddh :: emit_evsubfaddh_r_r_r

    emit_evsubfaddh_r_r_r ¶
    Source

    emit_evsubfaddh_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsubfaddhss ¶
    Source

    emit_evsubfaddhss :: emit_evsubfaddhss_r_r_r

    emit_evsubfaddhss_r_r_r ¶
    Source

    emit_evsubfaddhss_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsubfaddhx ¶
    Source

    emit_evsubfaddhx :: emit_evsubfaddhx_r_r_r

    emit_evsubfaddhx_r_r_r ¶
    Source

    emit_evsubfaddhx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsubfaddhxss ¶
    Source

    emit_evsubfaddhxss :: emit_evsubfaddhxss_r_r_r

    emit_evsubfaddhxss_r_r_r ¶
    Source

    emit_evsubfaddhxss_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsubfaddw ¶
    Source

    emit_evsubfaddw :: emit_evsubfaddw_r_r_r

    emit_evsubfaddw_r_r_r ¶
    Source

    emit_evsubfaddw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsubfaddwss ¶
    Source

    emit_evsubfaddwss :: emit_evsubfaddwss_r_r_r

    emit_evsubfaddwss_r_r_r ¶
    Source

    emit_evsubfaddwss_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsubfaddwx ¶
    Source

    emit_evsubfaddwx :: emit_evsubfaddwx_r_r_r

    emit_evsubfaddwx_r_r_r ¶
    Source

    emit_evsubfaddwx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsubfaddwxss ¶
    Source

    emit_evsubfaddwxss :: emit_evsubfaddwxss_r_r_r

    emit_evsubfaddwxss_r_r_r ¶
    Source

    emit_evsubfaddwxss_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsubfb ¶
    Source

    emit_evsubfb :: emit_evsubfb_r_r_r

    emit_evsubfb_r_r_r ¶
    Source

    emit_evsubfb_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsubfbss ¶
    Source

    emit_evsubfbss :: emit_evsubfbss_r_r_r

    emit_evsubfbss_r_r_r ¶
    Source

    emit_evsubfbss_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsubfbus ¶
    Source

    emit_evsubfbus :: emit_evsubfbus_r_r_r

    emit_evsubfbus_r_r_r ¶
    Source

    emit_evsubfbus_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsubfd ¶
    Source

    emit_evsubfd :: emit_evsubfd_r_r_r

    emit_evsubfd_r_r_r ¶
    Source

    emit_evsubfd_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsubfdss ¶
    Source

    emit_evsubfdss :: emit_evsubfdss_r_r_r

    emit_evsubfdss_r_r_r ¶
    Source

    emit_evsubfdss_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsubfdus ¶
    Source

    emit_evsubfdus :: emit_evsubfdus_r_r_r

    emit_evsubfdus_r_r_r ¶
    Source

    emit_evsubfdus_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsubfh ¶
    Source

    emit_evsubfh :: emit_evsubfh_r_r_r

    emit_evsubfh_r_r_r ¶
    Source

    emit_evsubfh_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsubfhhisw ¶
    Source

    emit_evsubfhhisw :: emit_evsubfhhisw_r_r_r

    emit_evsubfhhisw_r_r_r ¶
    Source

    emit_evsubfhhisw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsubfhhiuw ¶
    Source

    emit_evsubfhhiuw :: emit_evsubfhhiuw_r_r_r

    emit_evsubfhhiuw_r_r_r ¶
    Source

    emit_evsubfhhiuw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsubfhlosw ¶
    Source

    emit_evsubfhlosw :: emit_evsubfhlosw_r_r_r

    emit_evsubfhlosw_r_r_r ¶
    Source

    emit_evsubfhlosw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsubfhlouw ¶
    Source

    emit_evsubfhlouw :: emit_evsubfhlouw_r_r_r

    emit_evsubfhlouw_r_r_r ¶
    Source

    emit_evsubfhlouw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsubfhss ¶
    Source

    emit_evsubfhss :: emit_evsubfhss_r_r_r

    emit_evsubfhss_r_r_r ¶
    Source

    emit_evsubfhss_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsubfhus ¶
    Source

    emit_evsubfhus :: emit_evsubfhus_r_r_r

    emit_evsubfhus_r_r_r ¶
    Source

    emit_evsubfhus_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsubfhx ¶
    Source

    emit_evsubfhx :: emit_evsubfhx_r_r_r

    emit_evsubfhx_r_r_r ¶
    Source

    emit_evsubfhx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsubfhxss ¶
    Source

    emit_evsubfhxss :: emit_evsubfhxss_r_r_r

    emit_evsubfhxss_r_r_r ¶
    Source

    emit_evsubfhxss_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsubfhxus ¶
    Source

    emit_evsubfhxus :: emit_evsubfhxus_r_r_r

    emit_evsubfhxus_r_r_r ¶
    Source

    emit_evsubfhxus_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsubfsmiaa ¶
    Source

    emit_evsubfsmiaa :: emit_evsubfsmiaa_r_r_r

    emit_evsubfsmiaa_r_r_r ¶
    Source

    emit_evsubfsmiaa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsubfsmiaaw ¶
    Source

    emit_evsubfsmiaaw :: emit_evsubfsmiaaw_r_r_r

    emit_evsubfsmiaaw_r_r_r ¶
    Source

    emit_evsubfsmiaaw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsubfssiaa ¶
    Source

    emit_evsubfssiaa :: emit_evsubfssiaa_r_r_r

    emit_evsubfssiaa_r_r_r ¶
    Source

    emit_evsubfssiaa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsubfssiaaw ¶
    Source

    emit_evsubfssiaaw :: emit_evsubfssiaaw_r_r_r

    emit_evsubfssiaaw_r_r_r ¶
    Source

    emit_evsubfssiaaw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsubfumiaaw ¶
    Source

    emit_evsubfumiaaw :: emit_evsubfumiaaw_r_r_r

    emit_evsubfumiaaw_r_r_r ¶
    Source

    emit_evsubfumiaaw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsubfusiaa ¶
    Source

    emit_evsubfusiaa :: emit_evsubfusiaa_r_r_r

    emit_evsubfusiaa_r_r_r ¶
    Source

    emit_evsubfusiaa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsubfusiaaw ¶
    Source

    emit_evsubfusiaaw :: emit_evsubfusiaaw_r_r_r

    emit_evsubfusiaaw_r_r_r ¶
    Source

    emit_evsubfusiaaw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsubfw ¶
    Source

    emit_evsubfw :: emit_evsubfw_r_r_r

    emit_evsubfw_r_r_r ¶
    Source

    emit_evsubfw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsubfwegsf ¶
    Source

    emit_evsubfwegsf :: emit_evsubfwegsf_r_r_r

    emit_evsubfwegsf_r_r_r ¶
    Source

    emit_evsubfwegsf_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsubfwegsi ¶
    Source

    emit_evsubfwegsi :: emit_evsubfwegsi_r_r_r

    emit_evsubfwegsi_r_r_r ¶
    Source

    emit_evsubfwegsi_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsubfwogsf ¶
    Source

    emit_evsubfwogsf :: emit_evsubfwogsf_r_r_r

    emit_evsubfwogsf_r_r_r ¶
    Source

    emit_evsubfwogsf_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsubfwogsi ¶
    Source

    emit_evsubfwogsi :: emit_evsubfwogsi_r_r_r

    emit_evsubfwogsi_r_r_r ¶
    Source

    emit_evsubfwogsi_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsubfwss ¶
    Source

    emit_evsubfwss :: emit_evsubfwss_r_r_r

    emit_evsubfwss_r_r_r ¶
    Source

    emit_evsubfwss_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsubfwus ¶
    Source

    emit_evsubfwus :: emit_evsubfwus_r_r_r

    emit_evsubfwus_r_r_r ¶
    Source

    emit_evsubfwus_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsubfwx ¶
    Source

    emit_evsubfwx :: emit_evsubfwx_r_r_r

    emit_evsubfwx_r_r_r ¶
    Source

    emit_evsubfwx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsubfwxss ¶
    Source

    emit_evsubfwxss :: emit_evsubfwxss_r_r_r

    emit_evsubfwxss_r_r_r ¶
    Source

    emit_evsubfwxss_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsubfwxus ¶
    Source

    emit_evsubfwxus :: emit_evsubfwxus_r_r_r

    emit_evsubfwxus_r_r_r ¶
    Source

    emit_evsubfwxus_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsubifb ¶
    Source

    emit_evsubifb :: emit_evsubifb_r_r_r

    emit_evsubifb_r_r_r ¶
    Source

    emit_evsubifb_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsubifh ¶
    Source

    emit_evsubifh :: emit_evsubifh_r_r_r

    emit_evsubifh_r_r_r ¶
    Source

    emit_evsubifh_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsubifw ¶
    Source

    emit_evsubifw :: emit_evsubifw_r_r_imm

    emit_evsubifw_r_r_imm ¶
    Source

    emit_evsubifw_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_evsubiw ¶
    Source

    emit_evsubiw :: emit_evsubiw_r_r_r

    emit_evsubiw_r_r_r ¶
    Source

    emit_evsubiw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsubw ¶
    Source

    emit_evsubw :: emit_evsubw_r_r_r

    emit_evsubw_r_r_r ¶
    Source

    emit_evsubw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsum2his ¶
    Source

    emit_evsum2his :: emit_evsum2his_r_r_r

    emit_evsum2his_r_r_r ¶
    Source

    emit_evsum2his_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsum2hisa ¶
    Source

    emit_evsum2hisa :: emit_evsum2hisa_r_r_r

    emit_evsum2hisa_r_r_r ¶
    Source

    emit_evsum2hisa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsum2hisaaw ¶
    Source

    emit_evsum2hisaaw :: emit_evsum2hisaaw_r_r_r

    emit_evsum2hisaaw_r_r_r ¶
    Source

    emit_evsum2hisaaw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsum2hs ¶
    Source

    emit_evsum2hs :: emit_evsum2hs_r_r_r

    emit_evsum2hs_r_r_r ¶
    Source

    emit_evsum2hs_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsum2hsa ¶
    Source

    emit_evsum2hsa :: emit_evsum2hsa_r_r_r

    emit_evsum2hsa_r_r_r ¶
    Source

    emit_evsum2hsa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsum2hsaaw ¶
    Source

    emit_evsum2hsaaw :: emit_evsum2hsaaw_r_r_r

    emit_evsum2hsaaw_r_r_r ¶
    Source

    emit_evsum2hsaaw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsum2hu ¶
    Source

    emit_evsum2hu :: emit_evsum2hu_r_r_r

    emit_evsum2hu_r_r_r ¶
    Source

    emit_evsum2hu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsum2hua ¶
    Source

    emit_evsum2hua :: emit_evsum2hua_r_r_r

    emit_evsum2hua_r_r_r ¶
    Source

    emit_evsum2hua_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsum2huaaw ¶
    Source

    emit_evsum2huaaw :: emit_evsum2huaaw_r_r_r

    emit_evsum2huaaw_r_r_r ¶
    Source

    emit_evsum2huaaw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsum4bs ¶
    Source

    emit_evsum4bs :: emit_evsum4bs_r_r_r

    emit_evsum4bs_r_r_r ¶
    Source

    emit_evsum4bs_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsum4bsa ¶
    Source

    emit_evsum4bsa :: emit_evsum4bsa_r_r_r

    emit_evsum4bsa_r_r_r ¶
    Source

    emit_evsum4bsa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsum4bsaaw ¶
    Source

    emit_evsum4bsaaw :: emit_evsum4bsaaw_r_r_r

    emit_evsum4bsaaw_r_r_r ¶
    Source

    emit_evsum4bsaaw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsum4bu ¶
    Source

    emit_evsum4bu :: emit_evsum4bu_r_r_r

    emit_evsum4bu_r_r_r ¶
    Source

    emit_evsum4bu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsum4bua ¶
    Source

    emit_evsum4bua :: emit_evsum4bua_r_r_r

    emit_evsum4bua_r_r_r ¶
    Source

    emit_evsum4bua_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsum4buaaw ¶
    Source

    emit_evsum4buaaw :: emit_evsum4buaaw_r_r_r

    emit_evsum4buaaw_r_r_r ¶
    Source

    emit_evsum4buaaw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsumws ¶
    Source

    emit_evsumws :: emit_evsumws_r_r_r

    emit_evsumws_r_r_r ¶
    Source

    emit_evsumws_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsumwsa ¶
    Source

    emit_evsumwsa :: emit_evsumwsa_r_r_r

    emit_evsumwsa_r_r_r ¶
    Source

    emit_evsumwsa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsumwsaa ¶
    Source

    emit_evsumwsaa :: emit_evsumwsaa_r_r_r

    emit_evsumwsaa_r_r_r ¶
    Source

    emit_evsumwsaa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsumwu ¶
    Source

    emit_evsumwu :: emit_evsumwu_r_r_r

    emit_evsumwu_r_r_r ¶
    Source

    emit_evsumwu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsumwua ¶
    Source

    emit_evsumwua :: emit_evsumwua_r_r_r

    emit_evsumwua_r_r_r ¶
    Source

    emit_evsumwua_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evsumwuaa ¶
    Source

    emit_evsumwuaa :: emit_evsumwuaa_r_r_r

    emit_evsumwuaa_r_r_r ¶
    Source

    emit_evsumwuaa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evswapbhilo ¶
    Source

    emit_evswapbhilo :: emit_evswapbhilo_r_r_r

    emit_evswapbhilo_r_r_r ¶
    Source

    emit_evswapbhilo_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evswapblohi ¶
    Source

    emit_evswapblohi :: emit_evswapblohi_r_r_r

    emit_evswapblohi_r_r_r ¶
    Source

    emit_evswapblohi_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evswaphe ¶
    Source

    emit_evswaphe :: emit_evswaphe_r_r_r

    emit_evswaphe_r_r_r ¶
    Source

    emit_evswaphe_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evswaphhi ¶
    Source

    emit_evswaphhi :: emit_evswaphhi_r_r_r

    emit_evswaphhi_r_r_r ¶
    Source

    emit_evswaphhi_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evswaphhilo ¶
    Source

    emit_evswaphhilo :: emit_evswaphhilo_r_r_r

    emit_evswaphhilo_r_r_r ¶
    Source

    emit_evswaphhilo_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evswaphlo ¶
    Source

    emit_evswaphlo :: emit_evswaphlo_r_r_r

    emit_evswaphlo_r_r_r ¶
    Source

    emit_evswaphlo_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evswaphlohi ¶
    Source

    emit_evswaphlohi :: emit_evswaphlohi_r_r_r

    emit_evswaphlohi_r_r_r ¶
    Source

    emit_evswaphlohi_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evswapho ¶
    Source

    emit_evswapho :: emit_evswapho_r_r_r

    emit_evswapho_r_r_r ¶
    Source

    emit_evswapho_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evunpkhibsi ¶
    Source

    emit_evunpkhibsi :: emit_evunpkhibsi_r_r_r

    emit_evunpkhibsi_r_r_r ¶
    Source

    emit_evunpkhibsi_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evunpkhibui ¶
    Source

    emit_evunpkhibui :: emit_evunpkhibui_r_r_r

    emit_evunpkhibui_r_r_r ¶
    Source

    emit_evunpkhibui_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evunpkhihf ¶
    Source

    emit_evunpkhihf :: emit_evunpkhihf_r_r_r

    emit_evunpkhihf_r_r_r ¶
    Source

    emit_evunpkhihf_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evunpkhihsi ¶
    Source

    emit_evunpkhihsi :: emit_evunpkhihsi_r_r_r

    emit_evunpkhihsi_r_r_r ¶
    Source

    emit_evunpkhihsi_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evunpkhihui ¶
    Source

    emit_evunpkhihui :: emit_evunpkhihui_r_r_r

    emit_evunpkhihui_r_r_r ¶
    Source

    emit_evunpkhihui_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evunpkhiwgsf ¶
    Source

    emit_evunpkhiwgsf :: emit_evunpkhiwgsf_r_r_r

    emit_evunpkhiwgsf_r_r_r ¶
    Source

    emit_evunpkhiwgsf_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evunpklobsi ¶
    Source

    emit_evunpklobsi :: emit_evunpklobsi_r_r_r

    emit_evunpklobsi_r_r_r ¶
    Source

    emit_evunpklobsi_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evunpklobui ¶
    Source

    emit_evunpklobui :: emit_evunpklobui_r_r_r

    emit_evunpklobui_r_r_r ¶
    Source

    emit_evunpklobui_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evunpklohf ¶
    Source

    emit_evunpklohf :: emit_evunpklohf_r_r_r

    emit_evunpklohf_r_r_r ¶
    Source

    emit_evunpklohf_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evunpklohsi ¶
    Source

    emit_evunpklohsi :: emit_evunpklohsi_r_r_r

    emit_evunpklohsi_r_r_r ¶
    Source

    emit_evunpklohsi_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evunpklohui ¶
    Source

    emit_evunpklohui :: emit_evunpklohui_r_r_r

    emit_evunpklohui_r_r_r ¶
    Source

    emit_evunpklohui_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evunpklowgsf ¶
    Source

    emit_evunpklowgsf :: emit_evunpklowgsf_r_r_r

    emit_evunpklowgsf_r_r_r ¶
    Source

    emit_evunpklowgsf_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evxor ¶
    Source

    emit_evxor :: emit_evxor_r_r_r

    emit_evxor_r_r_r ¶
    Source

    emit_evxor_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evxtrb ¶
    Source

    emit_evxtrb :: emit_evxtrb_r_r_r

    emit_evxtrb_r_r_r ¶
    Source

    emit_evxtrb_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evxtrd ¶
    Source

    emit_evxtrd :: emit_evxtrd_r_r_r

    emit_evxtrd_r_r_r ¶
    Source

    emit_evxtrd_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_evxtrh ¶
    Source

    emit_evxtrh :: emit_evxtrh_r_r_r

    emit_evxtrh_r_r_r ¶
    Source

    emit_evxtrh_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_extldi ¶
    Source

    emit_extldi :: emit_extldi_r_r_imm_imm

    emit_extldi_dot ¶
    Source

    emit_extldi_dot :: emit_extldi_dot_r_r_r

    emit_extldi_dot_r_r_r ¶
    Source

    emit_extldi_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_extldi_r_r_imm_imm ¶
    Source

    emit_extldi_r_r_imm_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64, imm2: i64) {…}

    emit_extlwi ¶
    Source

    emit_extlwi :: emit_extlwi_r_r_imm_imm

    emit_extlwi_r_r_imm_imm ¶
    Source

    emit_extlwi_r_r_imm_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64, imm2: i64) {…}

    emit_extrdi ¶
    Source

    emit_extrdi :: emit_extrdi_r_r_imm_imm

    emit_extrdi_dot ¶
    Source

    emit_extrdi_dot :: emit_extrdi_dot_r_r_r

    emit_extrdi_dot_r_r_r ¶
    Source

    emit_extrdi_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_extrdi_r_r_imm_imm ¶
    Source

    emit_extrdi_r_r_imm_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64, imm2: i64) {…}

    emit_extrwi ¶
    Source

    emit_extrwi :: emit_extrwi_r_r_imm_imm

    emit_extrwi_r_r_imm_imm ¶
    Source

    emit_extrwi_r_r_imm_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64, imm2: i64) {…}

    emit_exts ¶
    Source

    emit_exts :: emit_exts_r_r_r

    emit_exts_dot ¶
    Source

    emit_exts_dot :: emit_exts_dot_r_r_r

    emit_exts_dot_r_r_r ¶
    Source

    emit_exts_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_exts_r_r_r ¶
    Source

    emit_exts_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_extsb ¶
    Source

    emit_extsb :: emit_extsb_r_r

    emit_extsb_dot ¶
    Source

    emit_extsb_dot :: emit_extsb_dot_r_r

    emit_extsb_dot_r_r ¶
    Source

    emit_extsb_dot_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_extsb_r_r ¶
    Source

    emit_extsb_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_extsh ¶
    Source

    emit_extsh :: emit_extsh_r_r

    emit_extsh_dot ¶
    Source

    emit_extsh_dot :: emit_extsh_dot_r_r

    emit_extsh_dot_r_r ¶
    Source

    emit_extsh_dot_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_extsh_r_r ¶
    Source

    emit_extsh_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_extsw ¶
    Source

    emit_extsw :: emit_extsw_r_r

    emit_extsw_dot ¶
    Source

    emit_extsw_dot :: emit_extsw_dot_r_r

    emit_extsw_dot_r_r ¶
    Source

    emit_extsw_dot_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_extsw_r_r ¶
    Source

    emit_extsw_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_extswsli ¶
    Source

    emit_extswsli :: emit_extswsli_r_r_imm

    emit_extswsli_dot ¶
    Source

    emit_extswsli_dot :: emit_extswsli_dot_r_r_imm

    emit_extswsli_dot_r_r_imm ¶
    Source

    emit_extswsli_dot_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_extswsli_r_r_imm ¶
    Source

    emit_extswsli_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_fa ¶
    Source

    emit_fa :: emit_fa_fr_mem

    emit_fa_dot ¶
    Source

    emit_fa_dot :: emit_fa_dot_fr_mem

    emit_fa_dot_fr_mem ¶
    Source

    emit_fa_dot_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_fa_fr_mem ¶
    Source

    emit_fa_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_fabs ¶
    Source

    emit_fabs :: emit_fabs_fr_fr

    emit_fabs_dot ¶
    Source

    emit_fabs_dot :: emit_fabs_dot_fr_fr

    emit_fabs_dot_fr_fr ¶
    Source

    emit_fabs_dot_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_fabs_fr_fr ¶
    Source

    emit_fabs_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_fadd ¶
    Source

    emit_fadd :: emit_fadd_fr_fr_fr

    emit_fadd_dot ¶
    Source

    emit_fadd_dot :: emit_fadd_dot_fr_fr_fr

    emit_fadd_dot_fr_fr_fr ¶
    Source

    emit_fadd_dot_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_fadd_fr_fr_fr ¶
    Source

    emit_fadd_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_fadds ¶
    Source

    emit_fadds :: emit_fadds_fr_fr_fr

    emit_fadds_dot ¶
    Source

    emit_fadds_dot :: emit_fadds_dot_fr_fr_fr

    emit_fadds_dot_fr_fr_fr ¶
    Source

    emit_fadds_dot_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_fadds_fr_fr_fr ¶
    Source

    emit_fadds_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_fcfid ¶
    Source

    emit_fcfid :: emit_fcfid_fr_fr

    emit_fcfid_dot ¶
    Source

    emit_fcfid_dot :: emit_fcfid_dot_fr_fr

    emit_fcfid_dot_fr_fr ¶
    Source

    emit_fcfid_dot_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_fcfid_fr_fr ¶
    Source

    emit_fcfid_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_fcfids ¶
    Source

    emit_fcfids :: emit_fcfids_fr_fr

    emit_fcfids_dot ¶
    Source

    emit_fcfids_dot :: emit_fcfids_dot_fr_fr

    emit_fcfids_dot_fr_fr ¶
    Source

    emit_fcfids_dot_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_fcfids_fr_fr ¶
    Source

    emit_fcfids_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_fcfidu ¶
    Source

    emit_fcfidu :: emit_fcfidu_fr_fr

    emit_fcfidu_dot ¶
    Source

    emit_fcfidu_dot :: emit_fcfidu_dot_fr_fr

    emit_fcfidu_dot_fr_fr ¶
    Source

    emit_fcfidu_dot_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_fcfidu_fr_fr ¶
    Source

    emit_fcfidu_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_fcfidus ¶
    Source

    emit_fcfidus :: emit_fcfidus_fr_fr

    emit_fcfidus_dot ¶
    Source

    emit_fcfidus_dot :: emit_fcfidus_dot_fr_fr

    emit_fcfidus_dot_fr_fr ¶
    Source

    emit_fcfidus_dot_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_fcfidus_fr_fr ¶
    Source

    emit_fcfidus_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_fcir ¶
    Source

    emit_fcir :: emit_fcir_fr_mem

    emit_fcir_dot ¶
    Source

    emit_fcir_dot :: emit_fcir_dot_fr_mem

    emit_fcir_dot_fr_mem ¶
    Source

    emit_fcir_dot_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_fcir_fr_mem ¶
    Source

    emit_fcir_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_fcirz ¶
    Source

    emit_fcirz :: emit_fcirz_fr_mem

    emit_fcirz_dot ¶
    Source

    emit_fcirz_dot :: emit_fcirz_dot_fr_mem

    emit_fcirz_dot_fr_mem ¶
    Source

    emit_fcirz_dot_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_fcirz_fr_mem ¶
    Source

    emit_fcirz_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_fcmpo ¶
    Source

    emit_fcmpo :: emit_fcmpo_crf_fr_fr

    emit_fcmpo_crf_fr_fr ¶
    Source

    emit_fcmpo_crf_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_fcmpu ¶
    Source

    emit_fcmpu :: emit_fcmpu_crf_fr_fr

    emit_fcmpu_crf_fr_fr ¶
    Source

    emit_fcmpu_crf_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_fcpsgn ¶
    Source

    emit_fcpsgn :: emit_fcpsgn_fr_fr_fr

    emit_fcpsgn_dot ¶
    Source

    emit_fcpsgn_dot :: emit_fcpsgn_dot_fr_fr_fr

    emit_fcpsgn_dot_fr_fr_fr ¶
    Source

    emit_fcpsgn_dot_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_fcpsgn_fr_fr_fr ¶
    Source

    emit_fcpsgn_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_fctid ¶
    Source

    emit_fctid :: emit_fctid_fr_fr

    emit_fctid_dot ¶
    Source

    emit_fctid_dot :: emit_fctid_dot_fr_fr

    emit_fctid_dot_fr_fr ¶
    Source

    emit_fctid_dot_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_fctid_fr_fr ¶
    Source

    emit_fctid_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_fctidu ¶
    Source

    emit_fctidu :: emit_fctidu_fr_fr

    emit_fctidu_dot ¶
    Source

    emit_fctidu_dot :: emit_fctidu_dot_fr_fr

    emit_fctidu_dot_fr_fr ¶
    Source

    emit_fctidu_dot_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_fctidu_fr_fr ¶
    Source

    emit_fctidu_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_fctiduz ¶
    Source

    emit_fctiduz :: emit_fctiduz_fr_fr

    emit_fctiduz_dot ¶
    Source

    emit_fctiduz_dot :: emit_fctiduz_dot_fr_fr

    emit_fctiduz_dot_fr_fr ¶
    Source

    emit_fctiduz_dot_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_fctiduz_fr_fr ¶
    Source

    emit_fctiduz_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_fctidz ¶
    Source

    emit_fctidz :: emit_fctidz_fr_fr

    emit_fctidz_dot ¶
    Source

    emit_fctidz_dot :: emit_fctidz_dot_fr_fr

    emit_fctidz_dot_fr_fr ¶
    Source

    emit_fctidz_dot_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_fctidz_fr_fr ¶
    Source

    emit_fctidz_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_fctiw ¶
    Source

    emit_fctiw :: emit_fctiw_fr_fr

    emit_fctiw_dot ¶
    Source

    emit_fctiw_dot :: emit_fctiw_dot_fr_fr

    emit_fctiw_dot_fr_fr ¶
    Source

    emit_fctiw_dot_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_fctiw_fr_fr ¶
    Source

    emit_fctiw_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_fctiwu ¶
    Source

    emit_fctiwu :: emit_fctiwu_fr_fr

    emit_fctiwu_dot ¶
    Source

    emit_fctiwu_dot :: emit_fctiwu_dot_fr_fr

    emit_fctiwu_dot_fr_fr ¶
    Source

    emit_fctiwu_dot_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_fctiwu_fr_fr ¶
    Source

    emit_fctiwu_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_fctiwuz ¶
    Source

    emit_fctiwuz :: emit_fctiwuz_fr_fr

    emit_fctiwuz_dot ¶
    Source

    emit_fctiwuz_dot :: emit_fctiwuz_dot_fr_fr

    emit_fctiwuz_dot_fr_fr ¶
    Source

    emit_fctiwuz_dot_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_fctiwuz_fr_fr ¶
    Source

    emit_fctiwuz_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_fctiwz ¶
    Source

    emit_fctiwz :: emit_fctiwz_fr_fr

    emit_fctiwz_dot ¶
    Source

    emit_fctiwz_dot :: emit_fctiwz_dot_fr_fr

    emit_fctiwz_dot_fr_fr ¶
    Source

    emit_fctiwz_dot_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_fctiwz_fr_fr ¶
    Source

    emit_fctiwz_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_fd ¶
    Source

    emit_fd :: emit_fd_fr_mem

    emit_fd_dot ¶
    Source

    emit_fd_dot :: emit_fd_dot_fr_mem

    emit_fd_dot_fr_mem ¶
    Source

    emit_fd_dot_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_fd_fr_mem ¶
    Source

    emit_fd_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_fdiv ¶
    Source

    emit_fdiv :: emit_fdiv_fr_fr_fr

    emit_fdiv_dot ¶
    Source

    emit_fdiv_dot :: emit_fdiv_dot_fr_fr_fr

    emit_fdiv_dot_fr_fr_fr ¶
    Source

    emit_fdiv_dot_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_fdiv_fr_fr_fr ¶
    Source

    emit_fdiv_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_fdivs ¶
    Source

    emit_fdivs :: emit_fdivs_fr_fr_fr

    emit_fdivs_dot ¶
    Source

    emit_fdivs_dot :: emit_fdivs_dot_fr_fr_fr

    emit_fdivs_dot_fr_fr_fr ¶
    Source

    emit_fdivs_dot_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_fdivs_fr_fr_fr ¶
    Source

    emit_fdivs_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_fm ¶
    Source

    emit_fm :: emit_fm_fr_mem

    emit_fm_dot ¶
    Source

    emit_fm_dot :: emit_fm_dot_fr_mem

    emit_fm_dot_fr_mem ¶
    Source

    emit_fm_dot_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_fm_fr_mem ¶
    Source

    emit_fm_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_fma ¶
    Source

    emit_fma :: emit_fma_fr_mem

    emit_fma_dot ¶
    Source

    emit_fma_dot :: emit_fma_dot_fr_mem

    emit_fma_dot_fr_mem ¶
    Source

    emit_fma_dot_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_fma_fr_mem ¶
    Source

    emit_fma_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_fmadd ¶
    Source

    emit_fmadd :: emit_fmadd_fr_fr_fr_fr

    emit_fmadd_dot ¶
    Source

    emit_fmadd_dot :: emit_fmadd_dot_fr_fr_fr_fr

    emit_fmadd_dot_fr_fr_fr_fr ¶
    Source

    emit_fmadd_dot_fr_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_fmadd_fr_fr_fr_fr ¶
    Source

    emit_fmadd_fr_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_fmadds ¶
    Source

    emit_fmadds :: emit_fmadds_fr_fr_fr_fr

    emit_fmadds_dot ¶
    Source

    emit_fmadds_dot :: emit_fmadds_dot_fr_fr_fr_fr

    emit_fmadds_dot_fr_fr_fr_fr ¶
    Source

    emit_fmadds_dot_fr_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_fmadds_fr_fr_fr_fr ¶
    Source

    emit_fmadds_fr_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_fmr ¶
    Source

    emit_fmr :: emit_fmr_fr_fr

    emit_fmr_dot ¶
    Source

    emit_fmr_dot :: emit_fmr_dot_fr_fr

    emit_fmr_dot_fr_fr ¶
    Source

    emit_fmr_dot_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_fmr_fr_fr ¶
    Source

    emit_fmr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_fmrgew ¶
    Source

    emit_fmrgew :: emit_fmrgew_fr_fr_fr

    emit_fmrgew_fr_fr_fr ¶
    Source

    emit_fmrgew_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_fmrgow ¶
    Source

    emit_fmrgow :: emit_fmrgow_fr_fr_fr

    emit_fmrgow_fr_fr_fr ¶
    Source

    emit_fmrgow_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_fms ¶
    Source

    emit_fms :: emit_fms_fr_mem

    emit_fms_dot ¶
    Source

    emit_fms_dot :: emit_fms_dot_fr_mem

    emit_fms_dot_fr_mem ¶
    Source

    emit_fms_dot_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_fms_fr_mem ¶
    Source

    emit_fms_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_fmsub ¶
    Source

    emit_fmsub :: emit_fmsub_fr_fr_fr_fr

    emit_fmsub_dot ¶
    Source

    emit_fmsub_dot :: emit_fmsub_dot_fr_fr_fr_fr

    emit_fmsub_dot_fr_fr_fr_fr ¶
    Source

    emit_fmsub_dot_fr_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_fmsub_fr_fr_fr_fr ¶
    Source

    emit_fmsub_fr_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_fmsubs ¶
    Source

    emit_fmsubs :: emit_fmsubs_fr_fr_fr_fr

    emit_fmsubs_dot ¶
    Source

    emit_fmsubs_dot :: emit_fmsubs_dot_fr_fr_fr_fr

    emit_fmsubs_dot_fr_fr_fr_fr ¶
    Source

    emit_fmsubs_dot_fr_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_fmsubs_fr_fr_fr_fr ¶
    Source

    emit_fmsubs_fr_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_fmul ¶
    Source

    emit_fmul :: emit_fmul_fr_fr_fr

    emit_fmul_dot ¶
    Source

    emit_fmul_dot :: emit_fmul_dot_fr_fr_fr

    emit_fmul_dot_fr_fr_fr ¶
    Source

    emit_fmul_dot_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_fmul_fr_fr_fr ¶
    Source

    emit_fmul_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_fmuls ¶
    Source

    emit_fmuls :: emit_fmuls_fr_fr_fr

    emit_fmuls_dot ¶
    Source

    emit_fmuls_dot :: emit_fmuls_dot_fr_fr_fr

    emit_fmuls_dot_fr_fr_fr ¶
    Source

    emit_fmuls_dot_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_fmuls_fr_fr_fr ¶
    Source

    emit_fmuls_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_fnabs ¶
    Source

    emit_fnabs :: emit_fnabs_fr_fr

    emit_fnabs_dot ¶
    Source

    emit_fnabs_dot :: emit_fnabs_dot_fr_fr

    emit_fnabs_dot_fr_fr ¶
    Source

    emit_fnabs_dot_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_fnabs_fr_fr ¶
    Source

    emit_fnabs_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_fneg ¶
    Source

    emit_fneg :: emit_fneg_fr_fr

    emit_fneg_dot ¶
    Source

    emit_fneg_dot :: emit_fneg_dot_fr_fr

    emit_fneg_dot_fr_fr ¶
    Source

    emit_fneg_dot_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_fneg_fr_fr ¶
    Source

    emit_fneg_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_fnma ¶
    Source

    emit_fnma :: emit_fnma_fr_mem

    emit_fnma_dot ¶
    Source

    emit_fnma_dot :: emit_fnma_dot_fr_mem

    emit_fnma_dot_fr_mem ¶
    Source

    emit_fnma_dot_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_fnma_fr_mem ¶
    Source

    emit_fnma_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_fnmadd ¶
    Source

    emit_fnmadd :: emit_fnmadd_fr_fr_fr_fr

    emit_fnmadd_dot ¶
    Source

    emit_fnmadd_dot :: emit_fnmadd_dot_fr_fr_fr_fr

    emit_fnmadd_dot_fr_fr_fr_fr ¶
    Source

    emit_fnmadd_dot_fr_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_fnmadd_fr_fr_fr_fr ¶
    Source

    emit_fnmadd_fr_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_fnmadds ¶
    Source

    emit_fnmadds :: emit_fnmadds_fr_fr_fr_fr

    emit_fnmadds_dot ¶
    Source

    emit_fnmadds_dot :: emit_fnmadds_dot_fr_fr_fr_fr

    emit_fnmadds_dot_fr_fr_fr_fr ¶
    Source

    emit_fnmadds_dot_fr_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_fnmadds_fr_fr_fr_fr ¶
    Source

    emit_fnmadds_fr_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_fnms ¶
    Source

    emit_fnms :: emit_fnms_fr_mem

    emit_fnms_dot ¶
    Source

    emit_fnms_dot :: emit_fnms_dot_fr_mem

    emit_fnms_dot_fr_mem ¶
    Source

    emit_fnms_dot_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_fnms_fr_mem ¶
    Source

    emit_fnms_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_fnmsub ¶
    Source

    emit_fnmsub :: emit_fnmsub_fr_fr_fr_fr

    emit_fnmsub_dot ¶
    Source

    emit_fnmsub_dot :: emit_fnmsub_dot_fr_fr_fr_fr

    emit_fnmsub_dot_fr_fr_fr_fr ¶
    Source

    emit_fnmsub_dot_fr_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_fnmsub_fr_fr_fr_fr ¶
    Source

    emit_fnmsub_fr_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_fnmsubs ¶
    Source

    emit_fnmsubs :: emit_fnmsubs_fr_fr_fr_fr

    emit_fnmsubs_dot ¶
    Source

    emit_fnmsubs_dot :: emit_fnmsubs_dot_fr_fr_fr_fr

    emit_fnmsubs_dot_fr_fr_fr_fr ¶
    Source

    emit_fnmsubs_dot_fr_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_fnmsubs_fr_fr_fr_fr ¶
    Source

    emit_fnmsubs_fr_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_fre ¶
    Source

    emit_fre :: emit_fre_fr_fr

    emit_fre_dot ¶
    Source

    emit_fre_dot :: emit_fre_dot_fr_fr

    emit_fre_dot_fr_fr ¶
    Source

    emit_fre_dot_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_fre_fr_fr ¶
    Source

    emit_fre_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_fres ¶
    Source

    emit_fres :: emit_fres_fr_fr

    emit_fres_dot ¶
    Source

    emit_fres_dot :: emit_fres_dot_fr_fr

    emit_fres_dot_fr_fr ¶
    Source

    emit_fres_dot_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_fres_fr_fr ¶
    Source

    emit_fres_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_frim ¶
    Source

    emit_frim :: emit_frim_fr_fr

    emit_frim_dot ¶
    Source

    emit_frim_dot :: emit_frim_dot_fr_fr

    emit_frim_dot_fr_fr ¶
    Source

    emit_frim_dot_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_frim_fr_fr ¶
    Source

    emit_frim_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_frin ¶
    Source

    emit_frin :: emit_frin_fr_fr

    emit_frin_dot ¶
    Source

    emit_frin_dot :: emit_frin_dot_fr_fr

    emit_frin_dot_fr_fr ¶
    Source

    emit_frin_dot_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_frin_fr_fr ¶
    Source

    emit_frin_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_frip ¶
    Source

    emit_frip :: emit_frip_fr_fr

    emit_frip_dot ¶
    Source

    emit_frip_dot :: emit_frip_dot_fr_fr

    emit_frip_dot_fr_fr ¶
    Source

    emit_frip_dot_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_frip_fr_fr ¶
    Source

    emit_frip_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_friz ¶
    Source

    emit_friz :: emit_friz_fr_fr

    emit_friz_dot ¶
    Source

    emit_friz_dot :: emit_friz_dot_fr_fr

    emit_friz_dot_fr_fr ¶
    Source

    emit_friz_dot_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_friz_fr_fr ¶
    Source

    emit_friz_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_frsp ¶
    Source

    emit_frsp :: emit_frsp_fr_fr

    emit_frsp_dot ¶
    Source

    emit_frsp_dot :: emit_frsp_dot_fr_fr

    emit_frsp_dot_fr_fr ¶
    Source

    emit_frsp_dot_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_frsp_fr_fr ¶
    Source

    emit_frsp_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_frsqrte ¶
    Source

    emit_frsqrte :: emit_frsqrte_fr_fr

    emit_frsqrte_dot ¶
    Source

    emit_frsqrte_dot :: emit_frsqrte_dot_fr_fr

    emit_frsqrte_dot_fr_fr ¶
    Source

    emit_frsqrte_dot_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_frsqrte_fr_fr ¶
    Source

    emit_frsqrte_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_frsqrtes ¶
    Source

    emit_frsqrtes :: emit_frsqrtes_fr_fr

    emit_frsqrtes_dot ¶
    Source

    emit_frsqrtes_dot :: emit_frsqrtes_dot_fr_fr

    emit_frsqrtes_dot_fr_fr ¶
    Source

    emit_frsqrtes_dot_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_frsqrtes_fr_fr ¶
    Source

    emit_frsqrtes_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_fs ¶
    Source

    emit_fs :: emit_fs_fr_mem

    emit_fs_dot ¶
    Source

    emit_fs_dot :: emit_fs_dot_fr_mem

    emit_fs_dot_fr_mem ¶
    Source

    emit_fs_dot_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_fs_fr_mem ¶
    Source

    emit_fs_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_fsel ¶
    Source

    emit_fsel :: emit_fsel_fr_fr_fr_fr

    emit_fsel_dot ¶
    Source

    emit_fsel_dot :: emit_fsel_dot_fr_fr_fr_fr

    emit_fsel_dot_fr_fr_fr_fr ¶
    Source

    emit_fsel_dot_fr_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_fsel_fr_fr_fr_fr ¶
    Source

    emit_fsel_fr_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_fsqrt ¶
    Source

    emit_fsqrt :: emit_fsqrt_fr_fr

    emit_fsqrt_dot ¶
    Source

    emit_fsqrt_dot :: emit_fsqrt_dot_fr_fr

    emit_fsqrt_dot_fr_fr ¶
    Source

    emit_fsqrt_dot_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_fsqrt_fr_fr ¶
    Source

    emit_fsqrt_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_fsqrts ¶
    Source

    emit_fsqrts :: emit_fsqrts_fr_fr

    emit_fsqrts_dot ¶
    Source

    emit_fsqrts_dot :: emit_fsqrts_dot_fr_fr

    emit_fsqrts_dot_fr_fr ¶
    Source

    emit_fsqrts_dot_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_fsqrts_fr_fr ¶
    Source

    emit_fsqrts_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_fsub ¶
    Source

    emit_fsub :: emit_fsub_fr_fr_fr

    emit_fsub_dot ¶
    Source

    emit_fsub_dot :: emit_fsub_dot_fr_fr_fr

    emit_fsub_dot_fr_fr_fr ¶
    Source

    emit_fsub_dot_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_fsub_fr_fr_fr ¶
    Source

    emit_fsub_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_fsubs ¶
    Source

    emit_fsubs :: emit_fsubs_fr_fr_fr

    emit_fsubs_dot ¶
    Source

    emit_fsubs_dot :: emit_fsubs_dot_fr_fr_fr

    emit_fsubs_dot_fr_fr_fr ¶
    Source

    emit_fsubs_dot_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_fsubs_fr_fr_fr ¶
    Source

    emit_fsubs_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_ftdiv ¶
    Source

    emit_ftdiv :: emit_ftdiv_crf_fr_fr

    emit_ftdiv_crf_fr_fr ¶
    Source

    emit_ftdiv_crf_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_ftsqrt ¶
    Source

    emit_ftsqrt :: emit_ftsqrt_crf_fr

    emit_ftsqrt_crf_fr ¶
    Source

    emit_ftsqrt_crf_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_hashchk ¶
    Source

    emit_hashchk :: emit_hashchk_r_r_r

    emit_hashchk_r_r_r ¶
    Source

    emit_hashchk_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_hashchkp ¶
    Source

    emit_hashchkp :: emit_hashchkp_r_r_r

    emit_hashchkp_r_r_r ¶
    Source

    emit_hashchkp_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_hashst ¶
    Source

    emit_hashst :: emit_hashst_r_r_r

    emit_hashst_r_r_r ¶
    Source

    emit_hashst_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_hashstp ¶
    Source

    emit_hashstp :: emit_hashstp_r_r_r

    emit_hashstp_r_r_r ¶
    Source

    emit_hashstp_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_hrfid ¶
    Source

    emit_hrfid :: emit_hrfid_none

    emit_hrfid_none ¶
    Source

    emit_hrfid_none :: proc(instructions: ^[dynamic]Instruction) {…}

    emit_icbi ¶
    Source

    emit_icbi :: emit_icbi_mem

    emit_icbi_mem ¶
    Source

    emit_icbi_mem :: proc(instructions: ^[dynamic]Instruction, addr: Memory) {…}

    emit_icbiep ¶
    Source

    emit_icbiep :: emit_icbiep_r_r

    emit_icbiep_r_r ¶
    Source

    emit_icbiep_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_icblc ¶
    Source

    emit_icblc :: emit_icblc_imm_r_r

    emit_icblc_imm_r_r ¶
    Source

    emit_icblc_imm_r_r :: proc(instructions: ^[dynamic]Instruction, imm: i64, dst: Register, src: Register) {…}

    emit_icblce ¶
    Source

    emit_icblce :: emit_icblce_r_r_r

    emit_icblce_r_r_r ¶
    Source

    emit_icblce_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_icblq_dot ¶
    Source

    emit_icblq_dot :: emit_icblq_dot_r_r_r

    emit_icblq_dot_r_r_r ¶
    Source

    emit_icblq_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_icbt ¶
    Source

    emit_icbt :: emit_icbt_mem

    emit_icbt_mem ¶
    Source

    emit_icbt_mem :: proc(instructions: ^[dynamic]Instruction, addr: Memory) {…}

    emit_icbtls ¶
    Source

    emit_icbtls :: emit_icbtls_imm_r_r

    emit_icbtls_imm_r_r ¶
    Source

    emit_icbtls_imm_r_r :: proc(instructions: ^[dynamic]Instruction, imm: i64, dst: Register, src: Register) {…}

    emit_icbtlse ¶
    Source

    emit_icbtlse :: emit_icbtlse_r_r_r

    emit_icbtlse_r_r_r ¶
    Source

    emit_icbtlse_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_iccci ¶
    Source

    emit_iccci :: emit_iccci_r_r

    emit_iccci_r_r ¶
    Source

    emit_iccci_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_ici ¶
    Source

    emit_ici :: emit_ici_r_r_r

    emit_ici_r_r_r ¶
    Source

    emit_ici_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_icread ¶
    Source

    emit_icread :: emit_icread_r_r_r

    emit_icread_r_r_r ¶
    Source

    emit_icread_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_ics ¶
    Source

    emit_ics :: emit_ics_r_r_imm

    emit_ics_r_r_imm ¶
    Source

    emit_ics_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_icswepx ¶
    Source

    emit_icswepx :: emit_icswepx_r_r_r

    emit_icswepx_dot ¶
    Source

    emit_icswepx_dot :: emit_icswepx_dot_r_r_r

    emit_icswepx_dot_r_r_r ¶
    Source

    emit_icswepx_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_icswepx_r_r_r ¶
    Source

    emit_icswepx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_icswx ¶
    Source

    emit_icswx :: emit_icswx_r_r_r

    emit_icswx_dot ¶
    Source

    emit_icswx_dot :: emit_icswx_dot_r_r_r

    emit_icswx_dot_r_r_r ¶
    Source

    emit_icswx_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_icswx_r_r_r ¶
    Source

    emit_icswx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_inslwi ¶
    Source

    emit_inslwi :: emit_inslwi_r_r_imm_imm

    emit_inslwi_r_r_imm_imm ¶
    Source

    emit_inslwi_r_r_imm_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64, imm2: i64) {…}

    emit_insrdi ¶
    Source

    emit_insrdi :: emit_insrdi_r_r_r

    emit_insrdi_dot ¶
    Source

    emit_insrdi_dot :: emit_insrdi_dot_r_r_r

    emit_insrdi_dot_r_r_r ¶
    Source

    emit_insrdi_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_insrdi_r_r_r ¶
    Source

    emit_insrdi_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_insrwi ¶
    Source

    emit_insrwi :: emit_insrwi_r_r_imm_imm

    emit_insrwi_r_r_imm_imm ¶
    Source

    emit_insrwi_r_r_imm_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64, imm2: i64) {…}

    emit_isel ¶
    Source

    emit_isel :: emit_isel_r_rz_r_crb

    emit_isel_r_rz_r_crb ¶
    Source

    emit_isel_r_rz_r_crb :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_iseleq ¶
    Source

    emit_iseleq :: emit_iseleq_r_r_r

    emit_iseleq_r_r_r ¶
    Source

    emit_iseleq_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_iselgt ¶
    Source

    emit_iselgt :: emit_iselgt_r_r_r

    emit_iselgt_r_r_r ¶
    Source

    emit_iselgt_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_isellt ¶
    Source

    emit_isellt :: emit_isellt_r_r_r

    emit_isellt_r_r_r ¶
    Source

    emit_isellt_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_isync ¶
    Source

    emit_isync :: emit_isync_none

    emit_isync_none ¶
    Source

    emit_isync_none :: proc(instructions: ^[dynamic]Instruction) {…}

    emit_la ¶
    Source

    emit_la :: emit_la_r_mem

    emit_la_r_mem ¶
    Source

    emit_la_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lbarx ¶
    Source

    emit_lbarx :: emit_lbarx_r_mem

    emit_lbarx_r_mem ¶
    Source

    emit_lbarx_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lbdcbx ¶
    Source

    emit_lbdcbx :: emit_lbdcbx_r_r_r

    emit_lbdcbx_r_r_r ¶
    Source

    emit_lbdcbx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lbdx ¶
    Source

    emit_lbdx :: emit_lbdx_r_r_r

    emit_lbdx_r_r_r ¶
    Source

    emit_lbdx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lbepx ¶
    Source

    emit_lbepx :: emit_lbepx_r_r_r

    emit_lbepx_r_r_r ¶
    Source

    emit_lbepx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lbrx ¶
    Source

    emit_lbrx :: emit_lbrx_r_r_r

    emit_lbrx_r_r_r ¶
    Source

    emit_lbrx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lbz ¶
    Source

    emit_lbz :: emit_lbz_r_mem

    emit_lbz_r_mem ¶
    Source

    emit_lbz_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lbzcix ¶
    Source

    emit_lbzcix :: emit_lbzcix_r_r_r

    emit_lbzcix_r_r_r ¶
    Source

    emit_lbzcix_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lbzu ¶
    Source

    emit_lbzu :: emit_lbzu_r_mem

    emit_lbzu_r_mem ¶
    Source

    emit_lbzu_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lbzux ¶
    Source

    emit_lbzux :: emit_lbzux_r_mem

    emit_lbzux_r_mem ¶
    Source

    emit_lbzux_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lbzx ¶
    Source

    emit_lbzx :: emit_lbzx_r_mem

    emit_lbzx_r_mem ¶
    Source

    emit_lbzx_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_ld ¶
    Source

    emit_ld :: emit_ld_r_mem

    emit_ld_r_mem ¶
    Source

    emit_ld_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_ldarx ¶
    Source

    emit_ldarx :: emit_ldarx_r_mem

    emit_ldarx_r_mem ¶
    Source

    emit_ldarx_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_ldat ¶
    Source

    emit_ldat :: emit_ldat_r_r_imm

    emit_ldat_r_r_imm ¶
    Source

    emit_ldat_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_ldawx_dot ¶
    Source

    emit_ldawx_dot :: emit_ldawx_dot_r_r_r

    emit_ldawx_dot_r_r_r ¶
    Source

    emit_ldawx_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_ldbrx ¶
    Source

    emit_ldbrx :: emit_ldbrx_r_mem

    emit_ldbrx_r_mem ¶
    Source

    emit_ldbrx_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_ldcix ¶
    Source

    emit_ldcix :: emit_ldcix_r_r_r

    emit_ldcix_r_r_r ¶
    Source

    emit_ldcix_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lddx ¶
    Source

    emit_lddx :: emit_lddx_r_r_r

    emit_lddx_r_r_r ¶
    Source

    emit_lddx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_ldepx ¶
    Source

    emit_ldepx :: emit_ldepx_r_r_r

    emit_ldepx_r_r_r ¶
    Source

    emit_ldepx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_ldu ¶
    Source

    emit_ldu :: emit_ldu_r_mem

    emit_ldu_r_mem ¶
    Source

    emit_ldu_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_ldux ¶
    Source

    emit_ldux :: emit_ldux_r_mem

    emit_ldux_r_mem ¶
    Source

    emit_ldux_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_ldx ¶
    Source

    emit_ldx :: emit_ldx_r_mem

    emit_ldx_r_mem ¶
    Source

    emit_ldx_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lfd ¶
    Source

    emit_lfd :: emit_lfd_fr_mem

    emit_lfd_fr_mem ¶
    Source

    emit_lfd_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lfddx ¶
    Source

    emit_lfddx :: emit_lfddx_r_r_r

    emit_lfddx_r_r_r ¶
    Source

    emit_lfddx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lfdepx ¶
    Source

    emit_lfdepx :: emit_lfdepx_fr_r_r

    emit_lfdepx_fr_r_r ¶
    Source

    emit_lfdepx_fr_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lfdp ¶
    Source

    emit_lfdp :: emit_lfdp_fr_mem

    emit_lfdp_fr_mem ¶
    Source

    emit_lfdp_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lfdpx ¶
    Source

    emit_lfdpx :: emit_lfdpx_fr_mem

    emit_lfdpx_fr_mem ¶
    Source

    emit_lfdpx_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lfdu ¶
    Source

    emit_lfdu :: emit_lfdu_fr_mem

    emit_lfdu_fr_mem ¶
    Source

    emit_lfdu_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lfdux ¶
    Source

    emit_lfdux :: emit_lfdux_fr_mem

    emit_lfdux_fr_mem ¶
    Source

    emit_lfdux_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lfdx ¶
    Source

    emit_lfdx :: emit_lfdx_fr_mem

    emit_lfdx_fr_mem ¶
    Source

    emit_lfdx_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lfiwax ¶
    Source

    emit_lfiwax :: emit_lfiwax_fr_mem

    emit_lfiwax_fr_mem ¶
    Source

    emit_lfiwax_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lfiwzx ¶
    Source

    emit_lfiwzx :: emit_lfiwzx_fr_mem

    emit_lfiwzx_fr_mem ¶
    Source

    emit_lfiwzx_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lfq ¶
    Source

    emit_lfq :: emit_lfq_fr_mem

    emit_lfq_fr_mem ¶
    Source

    emit_lfq_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lfqu ¶
    Source

    emit_lfqu :: emit_lfqu_fr_mem

    emit_lfqu_fr_mem ¶
    Source

    emit_lfqu_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lfqux ¶
    Source

    emit_lfqux :: emit_lfqux_r_r_r

    emit_lfqux_r_r_r ¶
    Source

    emit_lfqux_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lfqx ¶
    Source

    emit_lfqx :: emit_lfqx_r_r_r

    emit_lfqx_r_r_r ¶
    Source

    emit_lfqx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lfs ¶
    Source

    emit_lfs :: emit_lfs_fr_mem

    emit_lfs_fr_mem ¶
    Source

    emit_lfs_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lfsu ¶
    Source

    emit_lfsu :: emit_lfsu_fr_mem

    emit_lfsu_fr_mem ¶
    Source

    emit_lfsu_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lfsux ¶
    Source

    emit_lfsux :: emit_lfsux_fr_mem

    emit_lfsux_fr_mem ¶
    Source

    emit_lfsux_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lfsx ¶
    Source

    emit_lfsx :: emit_lfsx_fr_mem

    emit_lfsx_fr_mem ¶
    Source

    emit_lfsx_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lha ¶
    Source

    emit_lha :: emit_lha_r_mem

    emit_lha_r_mem ¶
    Source

    emit_lha_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lharx ¶
    Source

    emit_lharx :: emit_lharx_r_mem

    emit_lharx_r_mem ¶
    Source

    emit_lharx_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lhau ¶
    Source

    emit_lhau :: emit_lhau_r_mem

    emit_lhau_r_mem ¶
    Source

    emit_lhau_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lhaux ¶
    Source

    emit_lhaux :: emit_lhaux_r_mem

    emit_lhaux_r_mem ¶
    Source

    emit_lhaux_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lhax ¶
    Source

    emit_lhax :: emit_lhax_r_mem

    emit_lhax_r_mem ¶
    Source

    emit_lhax_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lhbrx ¶
    Source

    emit_lhbrx :: emit_lhbrx_r_mem

    emit_lhbrx_r_mem ¶
    Source

    emit_lhbrx_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lhdcbx ¶
    Source

    emit_lhdcbx :: emit_lhdcbx_r_r_r

    emit_lhdcbx_r_r_r ¶
    Source

    emit_lhdcbx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lhdx ¶
    Source

    emit_lhdx :: emit_lhdx_r_r_r

    emit_lhdx_r_r_r ¶
    Source

    emit_lhdx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lhepx ¶
    Source

    emit_lhepx :: emit_lhepx_r_r_r

    emit_lhepx_r_r_r ¶
    Source

    emit_lhepx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lhz ¶
    Source

    emit_lhz :: emit_lhz_r_mem

    emit_lhz_r_mem ¶
    Source

    emit_lhz_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lhzcix ¶
    Source

    emit_lhzcix :: emit_lhzcix_r_r_r

    emit_lhzcix_r_r_r ¶
    Source

    emit_lhzcix_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lhzu ¶
    Source

    emit_lhzu :: emit_lhzu_r_mem

    emit_lhzu_r_mem ¶
    Source

    emit_lhzu_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lhzux ¶
    Source

    emit_lhzux :: emit_lhzux_r_mem

    emit_lhzux_r_mem ¶
    Source

    emit_lhzux_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lhzx ¶
    Source

    emit_lhzx :: emit_lhzx_r_mem

    emit_lhzx_r_mem ¶
    Source

    emit_lhzx_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_li ¶
    Source

    emit_li :: emit_li_r_simm

    emit_li_r_simm ¶
    Source

    emit_li_r_simm :: proc(instructions: ^[dynamic]Instruction, dst: Register, imm: i64) {…}

    emit_lil ¶
    Source

    emit_lil :: emit_lil_r_r_imm

    emit_lil_r_r_imm ¶
    Source

    emit_lil_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_lis ¶
    Source

    emit_lis :: emit_lis_r_simm

    emit_lis_r_simm ¶
    Source

    emit_lis_r_simm :: proc(instructions: ^[dynamic]Instruction, dst: Register, imm: i64) {…}

    emit_liu ¶
    Source

    emit_liu :: emit_liu_r_r_imm

    emit_liu_r_r_imm ¶
    Source

    emit_liu_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_lm ¶
    Source

    emit_lm :: emit_lm_r_mem

    emit_lm_r_mem ¶
    Source

    emit_lm_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lmw ¶
    Source

    emit_lmw :: emit_lmw_r_mem

    emit_lmw_r_mem ¶
    Source

    emit_lmw_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lq ¶
    Source

    emit_lq :: emit_lq_r_mem

    emit_lq_r_mem ¶
    Source

    emit_lq_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lqarx ¶
    Source

    emit_lqarx :: emit_lqarx_r_mem

    emit_lqarx_r_mem ¶
    Source

    emit_lqarx_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lscbx ¶
    Source

    emit_lscbx :: emit_lscbx_r_r_r

    emit_lscbx_dot ¶
    Source

    emit_lscbx_dot :: emit_lscbx_dot_r_r_r

    emit_lscbx_dot_r_r_r ¶
    Source

    emit_lscbx_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lscbx_r_r_r ¶
    Source

    emit_lscbx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lsi ¶
    Source

    emit_lsi :: emit_lsi_r_r_r

    emit_lsi_r_r_r ¶
    Source

    emit_lsi_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lswi ¶
    Source

    emit_lswi :: emit_lswi_r_r_imm

    emit_lswi_r_r_imm ¶
    Source

    emit_lswi_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_lswx ¶
    Source

    emit_lswx :: emit_lswx_r_mem

    emit_lswx_r_mem ¶
    Source

    emit_lswx_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lsx ¶
    Source

    emit_lsx :: emit_lsx_r_r_r

    emit_lsx_r_r_r ¶
    Source

    emit_lsx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lu ¶
    Source

    emit_lu :: emit_lu_r_mem

    emit_lu_r_mem ¶
    Source

    emit_lu_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lux ¶
    Source

    emit_lux :: emit_lux_r_r_r

    emit_lux_r_r_r ¶
    Source

    emit_lux_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lvebx ¶
    Source

    emit_lvebx :: emit_lvebx_v_mem

    emit_lvebx128 ¶
    Source

    emit_lvebx128 :: emit_lvebx128_vr128_r_r

    emit_lvebx128_vr128_r_r ¶
    Source

    emit_lvebx128_vr128_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lvebx_v_mem ¶
    Source

    emit_lvebx_v_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lvehx ¶
    Source

    emit_lvehx :: emit_lvehx_v_mem

    emit_lvehx128 ¶
    Source

    emit_lvehx128 :: emit_lvehx128_vr128_r_r

    emit_lvehx128_vr128_r_r ¶
    Source

    emit_lvehx128_vr128_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lvehx_v_mem ¶
    Source

    emit_lvehx_v_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lvepx ¶
    Source

    emit_lvepx :: emit_lvepx_r_r_r

    emit_lvepx_r_r_r ¶
    Source

    emit_lvepx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lvepxl ¶
    Source

    emit_lvepxl :: emit_lvepxl_r_r_r

    emit_lvepxl_r_r_r ¶
    Source

    emit_lvepxl_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lvewx ¶
    Source

    emit_lvewx :: emit_lvewx_v_mem

    emit_lvewx128 ¶
    Source

    emit_lvewx128 :: emit_lvewx128_vr128_r_r

    emit_lvewx128_vr128_r_r ¶
    Source

    emit_lvewx128_vr128_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lvewx_v_mem ¶
    Source

    emit_lvewx_v_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lvexbx ¶
    Source

    emit_lvexbx :: emit_lvexbx_r_r_r

    emit_lvexbx_r_r_r ¶
    Source

    emit_lvexbx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lvexhx ¶
    Source

    emit_lvexhx :: emit_lvexhx_r_r_r

    emit_lvexhx_r_r_r ¶
    Source

    emit_lvexhx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lvexwx ¶
    Source

    emit_lvexwx :: emit_lvexwx_r_r_r

    emit_lvexwx_r_r_r ¶
    Source

    emit_lvexwx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lvlx ¶
    Source

    emit_lvlx :: emit_lvlx_r_r_r

    emit_lvlx128 ¶
    Source

    emit_lvlx128 :: emit_lvlx128_vr128_r_r

    emit_lvlx128_vr128_r_r ¶
    Source

    emit_lvlx128_vr128_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lvlx_r_r_r ¶
    Source

    emit_lvlx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lvlxl ¶
    Source

    emit_lvlxl :: emit_lvlxl_r_r_r

    emit_lvlxl128 ¶
    Source

    emit_lvlxl128 :: emit_lvlxl128_vr128_r_r

    emit_lvlxl128_vr128_r_r ¶
    Source

    emit_lvlxl128_vr128_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lvlxl_r_r_r ¶
    Source

    emit_lvlxl_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lvrx ¶
    Source

    emit_lvrx :: emit_lvrx_r_r_r

    emit_lvrx128 ¶
    Source

    emit_lvrx128 :: emit_lvrx128_vr128_r_r

    emit_lvrx128_vr128_r_r ¶
    Source

    emit_lvrx128_vr128_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lvrx_r_r_r ¶
    Source

    emit_lvrx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lvrxl ¶
    Source

    emit_lvrxl :: emit_lvrxl_r_r_r

    emit_lvrxl128 ¶
    Source

    emit_lvrxl128 :: emit_lvrxl128_vr128_r_r

    emit_lvrxl128_vr128_r_r ¶
    Source

    emit_lvrxl128_vr128_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lvrxl_r_r_r ¶
    Source

    emit_lvrxl_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lvsl ¶
    Source

    emit_lvsl :: emit_lvsl_v_mem

    emit_lvsl_v_mem ¶
    Source

    emit_lvsl_v_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lvsm ¶
    Source

    emit_lvsm :: emit_lvsm_r_r_r

    emit_lvsm_r_r_r ¶
    Source

    emit_lvsm_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lvsr ¶
    Source

    emit_lvsr :: emit_lvsr_v_mem

    emit_lvsr_v_mem ¶
    Source

    emit_lvsr_v_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lvswx ¶
    Source

    emit_lvswx :: emit_lvswx_r_r_r

    emit_lvswx_r_r_r ¶
    Source

    emit_lvswx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lvswxl ¶
    Source

    emit_lvswxl :: emit_lvswxl_r_r_r

    emit_lvswxl_r_r_r ¶
    Source

    emit_lvswxl_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lvtlx ¶
    Source

    emit_lvtlx :: emit_lvtlx_r_r_r

    emit_lvtlx_r_r_r ¶
    Source

    emit_lvtlx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lvtlxl ¶
    Source

    emit_lvtlxl :: emit_lvtlxl_r_r_r

    emit_lvtlxl_r_r_r ¶
    Source

    emit_lvtlxl_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lvtrx ¶
    Source

    emit_lvtrx :: emit_lvtrx_r_r_r

    emit_lvtrx_r_r_r ¶
    Source

    emit_lvtrx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lvtrxl ¶
    Source

    emit_lvtrxl :: emit_lvtrxl_r_r_r

    emit_lvtrxl_r_r_r ¶
    Source

    emit_lvtrxl_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lvx ¶
    Source

    emit_lvx :: emit_lvx_v_mem

    emit_lvx128 ¶
    Source

    emit_lvx128 :: emit_lvx128_vr128_r_r

    emit_lvx128_vr128_r_r ¶
    Source

    emit_lvx128_vr128_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lvx_v_mem ¶
    Source

    emit_lvx_v_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lvxl ¶
    Source

    emit_lvxl :: emit_lvxl_v_mem

    emit_lvxl128 ¶
    Source

    emit_lvxl128 :: emit_lvxl128_vr128_r_r

    emit_lvxl128_vr128_r_r ¶
    Source

    emit_lvxl128_vr128_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lvxl_v_mem ¶
    Source

    emit_lvxl_v_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lwa ¶
    Source

    emit_lwa :: emit_lwa_r_mem

    emit_lwa_r_mem ¶
    Source

    emit_lwa_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lwarx ¶
    Source

    emit_lwarx :: emit_lwarx_r_mem

    emit_lwarx_r_mem ¶
    Source

    emit_lwarx_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lwat ¶
    Source

    emit_lwat :: emit_lwat_r_r_imm

    emit_lwat_r_r_imm ¶
    Source

    emit_lwat_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_lwaux ¶
    Source

    emit_lwaux :: emit_lwaux_r_mem

    emit_lwaux_r_mem ¶
    Source

    emit_lwaux_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lwax ¶
    Source

    emit_lwax :: emit_lwax_r_mem

    emit_lwax_r_mem ¶
    Source

    emit_lwax_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lwbrx ¶
    Source

    emit_lwbrx :: emit_lwbrx_r_mem

    emit_lwbrx_r_mem ¶
    Source

    emit_lwbrx_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lwdcbx ¶
    Source

    emit_lwdcbx :: emit_lwdcbx_r_r_r

    emit_lwdcbx_r_r_r ¶
    Source

    emit_lwdcbx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lwdx ¶
    Source

    emit_lwdx :: emit_lwdx_r_r_r

    emit_lwdx_r_r_r ¶
    Source

    emit_lwdx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lwepx ¶
    Source

    emit_lwepx :: emit_lwepx_r_r_r

    emit_lwepx_r_r_r ¶
    Source

    emit_lwepx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lwsync ¶
    Source

    emit_lwsync :: emit_lwsync_none

    emit_lwsync_none ¶
    Source

    emit_lwsync_none :: proc(instructions: ^[dynamic]Instruction) {…}

    emit_lwz ¶
    Source

    emit_lwz :: emit_lwz_r_mem

    emit_lwz_r_mem ¶
    Source

    emit_lwz_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lwzcix ¶
    Source

    emit_lwzcix :: emit_lwzcix_r_r_r

    emit_lwzcix_r_r_r ¶
    Source

    emit_lwzcix_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lwzu ¶
    Source

    emit_lwzu :: emit_lwzu_r_mem

    emit_lwzu_r_mem ¶
    Source

    emit_lwzu_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lwzux ¶
    Source

    emit_lwzux :: emit_lwzux_r_mem

    emit_lwzux_r_mem ¶
    Source

    emit_lwzux_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lwzx ¶
    Source

    emit_lwzx :: emit_lwzx_r_mem

    emit_lwzx_r_mem ¶
    Source

    emit_lwzx_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lx ¶
    Source

    emit_lx :: emit_lx_r_r_r

    emit_lx_r_r_r ¶
    Source

    emit_lx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lxsd ¶
    Source

    emit_lxsd :: emit_lxsd_v_mem

    emit_lxsd_v_mem ¶
    Source

    emit_lxsd_v_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lxsdx ¶
    Source

    emit_lxsdx :: emit_lxsdx_vs_mem

    emit_lxsdx_vs_mem ¶
    Source

    emit_lxsdx_vs_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lxsibzx ¶
    Source

    emit_lxsibzx :: emit_lxsibzx_vs_mem

    emit_lxsibzx_vs_mem ¶
    Source

    emit_lxsibzx_vs_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lxsihzx ¶
    Source

    emit_lxsihzx :: emit_lxsihzx_vs_mem

    emit_lxsihzx_vs_mem ¶
    Source

    emit_lxsihzx_vs_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lxsiwax ¶
    Source

    emit_lxsiwax :: emit_lxsiwax_vs_mem

    emit_lxsiwax_vs_mem ¶
    Source

    emit_lxsiwax_vs_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lxsiwzx ¶
    Source

    emit_lxsiwzx :: emit_lxsiwzx_vs_mem

    emit_lxsiwzx_vs_mem ¶
    Source

    emit_lxsiwzx_vs_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lxssp ¶
    Source

    emit_lxssp :: emit_lxssp_v_mem

    emit_lxssp_v_mem ¶
    Source

    emit_lxssp_v_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lxsspx ¶
    Source

    emit_lxsspx :: emit_lxsspx_vs_mem

    emit_lxsspx_vs_mem ¶
    Source

    emit_lxsspx_vs_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lxv ¶
    Source

    emit_lxv :: emit_lxv_vs_mem

    emit_lxv_vs_mem ¶
    Source

    emit_lxv_vs_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lxvb16x ¶
    Source

    emit_lxvb16x :: emit_lxvb16x_vs_mem

    emit_lxvb16x_vs_mem ¶
    Source

    emit_lxvb16x_vs_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lxvd2x ¶
    Source

    emit_lxvd2x :: emit_lxvd2x_vs_mem

    emit_lxvd2x_vs_mem ¶
    Source

    emit_lxvd2x_vs_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lxvdsx ¶
    Source

    emit_lxvdsx :: emit_lxvdsx_vs_mem

    emit_lxvdsx_vs_mem ¶
    Source

    emit_lxvdsx_vs_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lxvh8x ¶
    Source

    emit_lxvh8x :: emit_lxvh8x_vs_mem

    emit_lxvh8x_vs_mem ¶
    Source

    emit_lxvh8x_vs_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lxvkq ¶
    Source

    emit_lxvkq :: emit_lxvkq_vs_imm

    emit_lxvkq_vs_imm ¶
    Source

    emit_lxvkq_vs_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, imm: i64) {…}

    emit_lxvl ¶
    Source

    emit_lxvl :: emit_lxvl_vs_r_r

    emit_lxvl_vs_r_r ¶
    Source

    emit_lxvl_vs_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lxvll ¶
    Source

    emit_lxvll :: emit_lxvll_vs_r_r

    emit_lxvll_vs_r_r ¶
    Source

    emit_lxvll_vs_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lxvp ¶
    Source

    emit_lxvp :: emit_lxvp_vs_mem

    emit_lxvp_vs_mem ¶
    Source

    emit_lxvp_vs_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lxvprl ¶
    Source

    emit_lxvprl :: emit_lxvprl_vs_r_r

    emit_lxvprl_vs_r_r ¶
    Source

    emit_lxvprl_vs_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lxvprll ¶
    Source

    emit_lxvprll :: emit_lxvprll_vs_r_r

    emit_lxvprll_vs_r_r ¶
    Source

    emit_lxvprll_vs_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lxvpx ¶
    Source

    emit_lxvpx :: emit_lxvpx_vs_r_r

    emit_lxvpx_vs_r_r ¶
    Source

    emit_lxvpx_vs_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lxvrbx ¶
    Source

    emit_lxvrbx :: emit_lxvrbx_vs_r_r

    emit_lxvrbx_vs_r_r ¶
    Source

    emit_lxvrbx_vs_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lxvrdx ¶
    Source

    emit_lxvrdx :: emit_lxvrdx_vs_r_r

    emit_lxvrdx_vs_r_r ¶
    Source

    emit_lxvrdx_vs_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lxvrhx ¶
    Source

    emit_lxvrhx :: emit_lxvrhx_vs_r_r

    emit_lxvrhx_vs_r_r ¶
    Source

    emit_lxvrhx_vs_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lxvrl ¶
    Source

    emit_lxvrl :: emit_lxvrl_vs_r_r

    emit_lxvrl_vs_r_r ¶
    Source

    emit_lxvrl_vs_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lxvrll ¶
    Source

    emit_lxvrll :: emit_lxvrll_vs_r_r

    emit_lxvrll_vs_r_r ¶
    Source

    emit_lxvrll_vs_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lxvrwx ¶
    Source

    emit_lxvrwx :: emit_lxvrwx_vs_r_r

    emit_lxvrwx_vs_r_r ¶
    Source

    emit_lxvrwx_vs_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lxvw4x ¶
    Source

    emit_lxvw4x :: emit_lxvw4x_vs_mem

    emit_lxvw4x_vs_mem ¶
    Source

    emit_lxvw4x_vs_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_lxvwsx ¶
    Source

    emit_lxvwsx :: emit_lxvwsx_r_r_r

    emit_lxvwsx_r_r_r ¶
    Source

    emit_lxvwsx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_lxvx ¶
    Source

    emit_lxvx :: emit_lxvx_vs_mem

    emit_lxvx_vs_mem ¶
    Source

    emit_lxvx_vs_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_macchw ¶
    Source

    emit_macchw :: emit_macchw_r_r_r

    emit_macchw_dot ¶
    Source

    emit_macchw_dot :: emit_macchw_dot_r_r_r

    emit_macchw_dot_r_r_r ¶
    Source

    emit_macchw_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_macchw_r_r_r ¶
    Source

    emit_macchw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_macchwo ¶
    Source

    emit_macchwo :: emit_macchwo_r_r_r

    emit_macchwo_dot ¶
    Source

    emit_macchwo_dot :: emit_macchwo_dot_r_r_r

    emit_macchwo_dot_r_r_r ¶
    Source

    emit_macchwo_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_macchwo_r_r_r ¶
    Source

    emit_macchwo_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_macchws ¶
    Source

    emit_macchws :: emit_macchws_r_r_r

    emit_macchws_dot ¶
    Source

    emit_macchws_dot :: emit_macchws_dot_r_r_r

    emit_macchws_dot_r_r_r ¶
    Source

    emit_macchws_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_macchws_r_r_r ¶
    Source

    emit_macchws_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_macchwso ¶
    Source

    emit_macchwso :: emit_macchwso_r_r_r

    emit_macchwso_dot ¶
    Source

    emit_macchwso_dot :: emit_macchwso_dot_r_r_r

    emit_macchwso_dot_r_r_r ¶
    Source

    emit_macchwso_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_macchwso_r_r_r ¶
    Source

    emit_macchwso_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_macchwsu ¶
    Source

    emit_macchwsu :: emit_macchwsu_r_r_r

    emit_macchwsu_dot ¶
    Source

    emit_macchwsu_dot :: emit_macchwsu_dot_r_r_r

    emit_macchwsu_dot_r_r_r ¶
    Source

    emit_macchwsu_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_macchwsu_r_r_r ¶
    Source

    emit_macchwsu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_macchwsuo ¶
    Source

    emit_macchwsuo :: emit_macchwsuo_r_r_r

    emit_macchwsuo_dot ¶
    Source

    emit_macchwsuo_dot :: emit_macchwsuo_dot_r_r_r

    emit_macchwsuo_dot_r_r_r ¶
    Source

    emit_macchwsuo_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_macchwsuo_r_r_r ¶
    Source

    emit_macchwsuo_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_macchwu ¶
    Source

    emit_macchwu :: emit_macchwu_r_r_r

    emit_macchwu_dot ¶
    Source

    emit_macchwu_dot :: emit_macchwu_dot_r_r_r

    emit_macchwu_dot_r_r_r ¶
    Source

    emit_macchwu_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_macchwu_r_r_r ¶
    Source

    emit_macchwu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_macchwuo ¶
    Source

    emit_macchwuo :: emit_macchwuo_r_r_r

    emit_macchwuo_dot ¶
    Source

    emit_macchwuo_dot :: emit_macchwuo_dot_r_r_r

    emit_macchwuo_dot_r_r_r ¶
    Source

    emit_macchwuo_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_macchwuo_r_r_r ¶
    Source

    emit_macchwuo_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_machhw ¶
    Source

    emit_machhw :: emit_machhw_r_r_r

    emit_machhw_dot ¶
    Source

    emit_machhw_dot :: emit_machhw_dot_r_r_r

    emit_machhw_dot_r_r_r ¶
    Source

    emit_machhw_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_machhw_r_r_r ¶
    Source

    emit_machhw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_machhwo ¶
    Source

    emit_machhwo :: emit_machhwo_r_r_r

    emit_machhwo_dot ¶
    Source

    emit_machhwo_dot :: emit_machhwo_dot_r_r_r

    emit_machhwo_dot_r_r_r ¶
    Source

    emit_machhwo_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_machhwo_r_r_r ¶
    Source

    emit_machhwo_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_machhws ¶
    Source

    emit_machhws :: emit_machhws_r_r_r

    emit_machhws_dot ¶
    Source

    emit_machhws_dot :: emit_machhws_dot_r_r_r

    emit_machhws_dot_r_r_r ¶
    Source

    emit_machhws_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_machhws_r_r_r ¶
    Source

    emit_machhws_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_machhwso ¶
    Source

    emit_machhwso :: emit_machhwso_r_r_r

    emit_machhwso_dot ¶
    Source

    emit_machhwso_dot :: emit_machhwso_dot_r_r_r

    emit_machhwso_dot_r_r_r ¶
    Source

    emit_machhwso_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_machhwso_r_r_r ¶
    Source

    emit_machhwso_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_machhwsu ¶
    Source

    emit_machhwsu :: emit_machhwsu_r_r_r

    emit_machhwsu_dot ¶
    Source

    emit_machhwsu_dot :: emit_machhwsu_dot_r_r_r

    emit_machhwsu_dot_r_r_r ¶
    Source

    emit_machhwsu_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_machhwsu_r_r_r ¶
    Source

    emit_machhwsu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_machhwsuo ¶
    Source

    emit_machhwsuo :: emit_machhwsuo_r_r_r

    emit_machhwsuo_dot ¶
    Source

    emit_machhwsuo_dot :: emit_machhwsuo_dot_r_r_r

    emit_machhwsuo_dot_r_r_r ¶
    Source

    emit_machhwsuo_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_machhwsuo_r_r_r ¶
    Source

    emit_machhwsuo_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_machhwu ¶
    Source

    emit_machhwu :: emit_machhwu_r_r_r

    emit_machhwu_dot ¶
    Source

    emit_machhwu_dot :: emit_machhwu_dot_r_r_r

    emit_machhwu_dot_r_r_r ¶
    Source

    emit_machhwu_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_machhwu_r_r_r ¶
    Source

    emit_machhwu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_machhwuo ¶
    Source

    emit_machhwuo :: emit_machhwuo_r_r_r

    emit_machhwuo_dot ¶
    Source

    emit_machhwuo_dot :: emit_machhwuo_dot_r_r_r

    emit_machhwuo_dot_r_r_r ¶
    Source

    emit_machhwuo_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_machhwuo_r_r_r ¶
    Source

    emit_machhwuo_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_maclhw ¶
    Source

    emit_maclhw :: emit_maclhw_r_r_r

    emit_maclhw_dot ¶
    Source

    emit_maclhw_dot :: emit_maclhw_dot_r_r_r

    emit_maclhw_dot_r_r_r ¶
    Source

    emit_maclhw_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_maclhw_r_r_r ¶
    Source

    emit_maclhw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_maclhwo ¶
    Source

    emit_maclhwo :: emit_maclhwo_r_r_r

    emit_maclhwo_dot ¶
    Source

    emit_maclhwo_dot :: emit_maclhwo_dot_r_r_r

    emit_maclhwo_dot_r_r_r ¶
    Source

    emit_maclhwo_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_maclhwo_r_r_r ¶
    Source

    emit_maclhwo_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_maclhws ¶
    Source

    emit_maclhws :: emit_maclhws_r_r_r

    emit_maclhws_dot ¶
    Source

    emit_maclhws_dot :: emit_maclhws_dot_r_r_r

    emit_maclhws_dot_r_r_r ¶
    Source

    emit_maclhws_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_maclhws_r_r_r ¶
    Source

    emit_maclhws_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_maclhwso ¶
    Source

    emit_maclhwso :: emit_maclhwso_r_r_r

    emit_maclhwso_dot ¶
    Source

    emit_maclhwso_dot :: emit_maclhwso_dot_r_r_r

    emit_maclhwso_dot_r_r_r ¶
    Source

    emit_maclhwso_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_maclhwso_r_r_r ¶
    Source

    emit_maclhwso_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_maclhwsu ¶
    Source

    emit_maclhwsu :: emit_maclhwsu_r_r_r

    emit_maclhwsu_dot ¶
    Source

    emit_maclhwsu_dot :: emit_maclhwsu_dot_r_r_r

    emit_maclhwsu_dot_r_r_r ¶
    Source

    emit_maclhwsu_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_maclhwsu_r_r_r ¶
    Source

    emit_maclhwsu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_maclhwsuo ¶
    Source

    emit_maclhwsuo :: emit_maclhwsuo_r_r_r

    emit_maclhwsuo_dot ¶
    Source

    emit_maclhwsuo_dot :: emit_maclhwsuo_dot_r_r_r

    emit_maclhwsuo_dot_r_r_r ¶
    Source

    emit_maclhwsuo_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_maclhwsuo_r_r_r ¶
    Source

    emit_maclhwsuo_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_maclhwu ¶
    Source

    emit_maclhwu :: emit_maclhwu_r_r_r

    emit_maclhwu_dot ¶
    Source

    emit_maclhwu_dot :: emit_maclhwu_dot_r_r_r

    emit_maclhwu_dot_r_r_r ¶
    Source

    emit_maclhwu_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_maclhwu_r_r_r ¶
    Source

    emit_maclhwu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_maclhwuo ¶
    Source

    emit_maclhwuo :: emit_maclhwuo_r_r_r

    emit_maclhwuo_dot ¶
    Source

    emit_maclhwuo_dot :: emit_maclhwuo_dot_r_r_r

    emit_maclhwuo_dot_r_r_r ¶
    Source

    emit_maclhwuo_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_maclhwuo_r_r_r ¶
    Source

    emit_maclhwuo_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_maddhd ¶
    Source

    emit_maddhd :: emit_maddhd_r_r_r_r

    emit_maddhd_r_r_r_r ¶
    Source

    emit_maddhd_r_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_maddhdu ¶
    Source

    emit_maddhdu :: emit_maddhdu_r_r_r_r

    emit_maddhdu_r_r_r_r ¶
    Source

    emit_maddhdu_r_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_maddld ¶
    Source

    emit_maddld :: emit_maddld_r_r_r_r

    emit_maddld_r_r_r_r ¶
    Source

    emit_maddld_r_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_maskg ¶
    Source

    emit_maskg :: emit_maskg_r_r_r

    emit_maskg_dot ¶
    Source

    emit_maskg_dot :: emit_maskg_dot_r_r_r

    emit_maskg_dot_r_r_r ¶
    Source

    emit_maskg_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_maskg_r_r_r ¶
    Source

    emit_maskg_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_maskir ¶
    Source

    emit_maskir :: emit_maskir_r_r_r

    emit_maskir_dot ¶
    Source

    emit_maskir_dot :: emit_maskir_dot_r_r_r

    emit_maskir_dot_r_r_r ¶
    Source

    emit_maskir_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_maskir_r_r_r ¶
    Source

    emit_maskir_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mbar ¶
    Source

    emit_mbar :: emit_mbar_imm

    emit_mbar_imm ¶
    Source

    emit_mbar_imm :: proc(instructions: ^[dynamic]Instruction, imm: i64) {…}

    emit_mcrf ¶
    Source

    emit_mcrf :: emit_mcrf_crf_crf

    emit_mcrf_crf_crf ¶
    Source

    emit_mcrf_crf_crf :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_mcrfs ¶
    Source

    emit_mcrfs :: emit_mcrfs_crf_crf

    emit_mcrfs_crf_crf ¶
    Source

    emit_mcrfs_crf_crf :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_mcrxr ¶
    Source

    emit_mcrxr :: emit_mcrxr_r_r_r

    emit_mcrxr_r_r_r ¶
    Source

    emit_mcrxr_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mcrxrx ¶
    Source

    emit_mcrxrx :: emit_mcrxrx_crf

    emit_mcrxrx_crf ¶
    Source

    emit_mcrxrx_crf :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mfamr ¶
    Source

    emit_mfamr :: emit_mfamr_r

    emit_mfamr_r ¶
    Source

    emit_mfamr_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mfapidi ¶
    Source

    emit_mfapidi :: emit_mfapidi_r_r_r

    emit_mfapidi_r_r_r ¶
    Source

    emit_mfapidi_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mfasr ¶
    Source

    emit_mfasr :: emit_mfasr_r

    emit_mfasr_r ¶
    Source

    emit_mfasr_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mfbhrbe ¶
    Source

    emit_mfbhrbe :: emit_mfbhrbe_r_r_r

    emit_mfbhrbe_r_r_r ¶
    Source

    emit_mfbhrbe_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mfcfar ¶
    Source

    emit_mfcfar :: emit_mfcfar_r

    emit_mfcfar_r ¶
    Source

    emit_mfcfar_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mfcr ¶
    Source

    emit_mfcr :: emit_mfcr_r

    emit_mfcr_r ¶
    Source

    emit_mfcr_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mfctr ¶
    Source

    emit_mfctr :: emit_mfctr_r

    emit_mfctr_r ¶
    Source

    emit_mfctr_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mfdar ¶
    Source

    emit_mfdar :: emit_mfdar_r

    emit_mfdar_r ¶
    Source

    emit_mfdar_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mfdccr ¶
    Source

    emit_mfdccr :: emit_mfdccr_r

    emit_mfdccr_r ¶
    Source

    emit_mfdccr_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mfdcr ¶
    Source

    emit_mfdcr :: emit_mfdcr_r_r

    emit_mfdcr_dot ¶
    Source

    emit_mfdcr_dot :: emit_mfdcr_dot_r_r_r

    emit_mfdcr_dot_r_r_r ¶
    Source

    emit_mfdcr_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mfdcr_r_r ¶
    Source

    emit_mfdcr_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_mfdcrux ¶
    Source

    emit_mfdcrux :: emit_mfdcrux_r_r_r

    emit_mfdcrux_r_r_r ¶
    Source

    emit_mfdcrux_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mfdcrx ¶
    Source

    emit_mfdcrx :: emit_mfdcrx_r_r_r

    emit_mfdcrx_dot ¶
    Source

    emit_mfdcrx_dot :: emit_mfdcrx_dot_r_r_r

    emit_mfdcrx_dot_r_r_r ¶
    Source

    emit_mfdcrx_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mfdcrx_r_r_r ¶
    Source

    emit_mfdcrx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mfdec ¶
    Source

    emit_mfdec :: emit_mfdec_r

    emit_mfdec_r ¶
    Source

    emit_mfdec_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mfdscr ¶
    Source

    emit_mfdscr :: emit_mfdscr_r

    emit_mfdscr_r ¶
    Source

    emit_mfdscr_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mfdsisr ¶
    Source

    emit_mfdsisr :: emit_mfdsisr_r

    emit_mfdsisr_r ¶
    Source

    emit_mfdsisr_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mfesr ¶
    Source

    emit_mfesr :: emit_mfesr_r

    emit_mfesr_r ¶
    Source

    emit_mfesr_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mffgpr ¶
    Source

    emit_mffgpr :: emit_mffgpr_r_r_r

    emit_mffgpr_r_r_r ¶
    Source

    emit_mffgpr_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mffprd ¶
    Source

    emit_mffprd :: emit_mffprd_r_fr

    emit_mffprd_r_fr ¶
    Source

    emit_mffprd_r_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_mffprwz ¶
    Source

    emit_mffprwz :: emit_mffprwz_r_fr

    emit_mffprwz_r_fr ¶
    Source

    emit_mffprwz_r_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_mffs ¶
    Source

    emit_mffs :: emit_mffs_fr

    emit_mffs_dot ¶
    Source

    emit_mffs_dot :: emit_mffs_dot_fr

    emit_mffs_dot_fr ¶
    Source

    emit_mffs_dot_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mffs_fr ¶
    Source

    emit_mffs_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mffscdrn ¶
    Source

    emit_mffscdrn :: emit_mffscdrn_fr_fr

    emit_mffscdrn_fr_fr ¶
    Source

    emit_mffscdrn_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_mffscdrni ¶
    Source

    emit_mffscdrni :: emit_mffscdrni_fr_imm

    emit_mffscdrni_fr_imm ¶
    Source

    emit_mffscdrni_fr_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, imm: i64) {…}

    emit_mffsce ¶
    Source

    emit_mffsce :: emit_mffsce_fr

    emit_mffsce_fr ¶
    Source

    emit_mffsce_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mffscrn ¶
    Source

    emit_mffscrn :: emit_mffscrn_fr_fr

    emit_mffscrn_fr_fr ¶
    Source

    emit_mffscrn_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_mffscrni ¶
    Source

    emit_mffscrni :: emit_mffscrni_fr_imm

    emit_mffscrni_fr_imm ¶
    Source

    emit_mffscrni_fr_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, imm: i64) {…}

    emit_mffsl ¶
    Source

    emit_mffsl :: emit_mffsl_fr

    emit_mffsl_fr ¶
    Source

    emit_mffsl_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mflr ¶
    Source

    emit_mflr :: emit_mflr_r

    emit_mflr_r ¶
    Source

    emit_mflr_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mfmsr ¶
    Source

    emit_mfmsr :: emit_mfmsr_r

    emit_mfmsr_r ¶
    Source

    emit_mfmsr_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mfocrf ¶
    Source

    emit_mfocrf :: emit_mfocrf_r_imm

    emit_mfocrf_r_imm ¶
    Source

    emit_mfocrf_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, imm: i64) {…}

    emit_mfpmr ¶
    Source

    emit_mfpmr :: emit_mfpmr_r_spr

    emit_mfpmr_r_spr ¶
    Source

    emit_mfpmr_r_spr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_mfppr ¶
    Source

    emit_mfppr :: emit_mfppr_r

    emit_mfppr_r ¶
    Source

    emit_mfppr_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mfspr ¶
    Source

    emit_mfspr :: emit_mfspr_r_spr

    emit_mfspr_r_spr ¶
    Source

    emit_mfspr_r_spr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_mfsr ¶
    Source

    emit_mfsr :: emit_mfsr_r_imm

    emit_mfsr_r_imm ¶
    Source

    emit_mfsr_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, imm: i64) {…}

    emit_mfsri ¶
    Source

    emit_mfsri :: emit_mfsri_r_r_r

    emit_mfsri_r_r_r ¶
    Source

    emit_mfsri_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mfsrin ¶
    Source

    emit_mfsrin :: emit_mfsrin_r_r

    emit_mfsrin_r_r ¶
    Source

    emit_mfsrin_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_mfsrr0 ¶
    Source

    emit_mfsrr0 :: emit_mfsrr0_r

    emit_mfsrr0_r ¶
    Source

    emit_mfsrr0_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mfsrr1 ¶
    Source

    emit_mfsrr1 :: emit_mfsrr1_r

    emit_mfsrr1_r ¶
    Source

    emit_mfsrr1_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mftb ¶
    Source

    emit_mftb :: emit_mftb_r_spr

    emit_mftb_r_spr ¶
    Source

    emit_mftb_r_spr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_mftcr ¶
    Source

    emit_mftcr :: emit_mftcr_r

    emit_mftcr_r ¶
    Source

    emit_mftcr_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mftgpr ¶
    Source

    emit_mftgpr :: emit_mftgpr_r_r_r

    emit_mftgpr_r_r_r ¶
    Source

    emit_mftgpr_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mftmr ¶
    Source

    emit_mftmr :: emit_mftmr_r_r_r

    emit_mftmr_r_r_r ¶
    Source

    emit_mftmr_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mfvscr ¶
    Source

    emit_mfvscr :: emit_mfvscr_v

    emit_mfvscr_v ¶
    Source

    emit_mfvscr_v :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mfvsrd ¶
    Source

    emit_mfvsrd :: emit_mfvsrd_r_r_r

    emit_mfvsrd_r_r_r ¶
    Source

    emit_mfvsrd_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mfvsrld ¶
    Source

    emit_mfvsrld :: emit_mfvsrld_r_vs

    emit_mfvsrld_r_vs ¶
    Source

    emit_mfvsrld_r_vs :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_mfvsrwz ¶
    Source

    emit_mfvsrwz :: emit_mfvsrwz_r_r_r

    emit_mfvsrwz_r_r_r ¶
    Source

    emit_mfvsrwz_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mfxer ¶
    Source

    emit_mfxer :: emit_mfxer_r

    emit_mfxer_r ¶
    Source

    emit_mfxer_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_modsd ¶
    Source

    emit_modsd :: emit_modsd_r_r_r

    emit_modsd_r_r_r ¶
    Source

    emit_modsd_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_modsw ¶
    Source

    emit_modsw :: emit_modsw_r_r_r

    emit_modsw_r_r_r ¶
    Source

    emit_modsw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_modud ¶
    Source

    emit_modud :: emit_modud_r_r_r

    emit_modud_r_r_r ¶
    Source

    emit_modud_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_moduw ¶
    Source

    emit_moduw :: emit_moduw_r_r_r

    emit_moduw_r_r_r ¶
    Source

    emit_moduw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mr ¶
    Source

    emit_mr :: emit_mr_r_r

    emit_mr_dot ¶
    Source

    emit_mr_dot :: emit_mr_dot_r_r

    emit_mr_dot_r_r ¶
    Source

    emit_mr_dot_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_mr_r_r ¶
    Source

    emit_mr_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_msgsync ¶
    Source

    emit_msgsync :: emit_msgsync_none

    emit_msgsync_none ¶
    Source

    emit_msgsync_none :: proc(instructions: ^[dynamic]Instruction) {…}

    emit_msync ¶
    Source

    emit_msync :: emit_msync_none

    emit_msync_none ¶
    Source

    emit_msync_none :: proc(instructions: ^[dynamic]Instruction) {…}

    emit_mtamr ¶
    Source

    emit_mtamr :: emit_mtamr_r

    emit_mtamr_r ¶
    Source

    emit_mtamr_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mtasr ¶
    Source

    emit_mtasr :: emit_mtasr_r

    emit_mtasr_r ¶
    Source

    emit_mtasr_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mtbr0 ¶
    Source

    emit_mtbr0 :: emit_mtbr0_r

    emit_mtbr0_r ¶
    Source

    emit_mtbr0_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mtbr1 ¶
    Source

    emit_mtbr1 :: emit_mtbr1_r

    emit_mtbr1_r ¶
    Source

    emit_mtbr1_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mtcfar ¶
    Source

    emit_mtcfar :: emit_mtcfar_r

    emit_mtcfar_r ¶
    Source

    emit_mtcfar_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mtcr ¶
    Source

    emit_mtcr :: emit_mtcr_r

    emit_mtcr_r ¶
    Source

    emit_mtcr_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mtcrf ¶
    Source

    emit_mtcrf :: emit_mtcrf_imm_r

    emit_mtcrf_imm_r ¶
    Source

    emit_mtcrf_imm_r :: proc(instructions: ^[dynamic]Instruction, imm: i64, dst: Register) {…}

    emit_mtctr ¶
    Source

    emit_mtctr :: emit_mtctr_r

    emit_mtctr_r ¶
    Source

    emit_mtctr_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mtdar ¶
    Source

    emit_mtdar :: emit_mtdar_r

    emit_mtdar_r ¶
    Source

    emit_mtdar_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mtdccr ¶
    Source

    emit_mtdccr :: emit_mtdccr_r

    emit_mtdccr_r ¶
    Source

    emit_mtdccr_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mtdcr ¶
    Source

    emit_mtdcr :: emit_mtdcr_r_r

    emit_mtdcr_dot ¶
    Source

    emit_mtdcr_dot :: emit_mtdcr_dot_r_r_r

    emit_mtdcr_dot_r_r_r ¶
    Source

    emit_mtdcr_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mtdcr_r_r ¶
    Source

    emit_mtdcr_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_mtdcrux ¶
    Source

    emit_mtdcrux :: emit_mtdcrux_r_r_r

    emit_mtdcrux_r_r_r ¶
    Source

    emit_mtdcrux_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mtdcrx ¶
    Source

    emit_mtdcrx :: emit_mtdcrx_r_r_r

    emit_mtdcrx_dot ¶
    Source

    emit_mtdcrx_dot :: emit_mtdcrx_dot_r_r_r

    emit_mtdcrx_dot_r_r_r ¶
    Source

    emit_mtdcrx_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mtdcrx_r_r_r ¶
    Source

    emit_mtdcrx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mtdec ¶
    Source

    emit_mtdec :: emit_mtdec_r

    emit_mtdec_r ¶
    Source

    emit_mtdec_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mtdscr ¶
    Source

    emit_mtdscr :: emit_mtdscr_r

    emit_mtdscr_r ¶
    Source

    emit_mtdscr_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mtdsisr ¶
    Source

    emit_mtdsisr :: emit_mtdsisr_r

    emit_mtdsisr_r ¶
    Source

    emit_mtdsisr_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mtesr ¶
    Source

    emit_mtesr :: emit_mtesr_r

    emit_mtesr_r ¶
    Source

    emit_mtesr_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mtfprd ¶
    Source

    emit_mtfprd :: emit_mtfprd_fr_r

    emit_mtfprd_fr_r ¶
    Source

    emit_mtfprd_fr_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_mtfprwa ¶
    Source

    emit_mtfprwa :: emit_mtfprwa_fr_r

    emit_mtfprwa_fr_r ¶
    Source

    emit_mtfprwa_fr_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_mtfprwz ¶
    Source

    emit_mtfprwz :: emit_mtfprwz_fr_r

    emit_mtfprwz_fr_r ¶
    Source

    emit_mtfprwz_fr_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_mtfsb0 ¶
    Source

    emit_mtfsb0 :: emit_mtfsb0_crb

    emit_mtfsb0_crb ¶
    Source

    emit_mtfsb0_crb :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mtfsb0_dot ¶
    Source

    emit_mtfsb0_dot :: emit_mtfsb0_dot_crb

    emit_mtfsb0_dot_crb ¶
    Source

    emit_mtfsb0_dot_crb :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mtfsb1 ¶
    Source

    emit_mtfsb1 :: emit_mtfsb1_crb

    emit_mtfsb1_crb ¶
    Source

    emit_mtfsb1_crb :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mtfsb1_dot ¶
    Source

    emit_mtfsb1_dot :: emit_mtfsb1_dot_crb

    emit_mtfsb1_dot_crb ¶
    Source

    emit_mtfsb1_dot_crb :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mtfsf ¶
    Source

    emit_mtfsf :: emit_mtfsf_imm_fr

    emit_mtfsf_dot ¶
    Source

    emit_mtfsf_dot :: emit_mtfsf_dot_imm_fr

    emit_mtfsf_dot_imm_fr ¶
    Source

    emit_mtfsf_dot_imm_fr :: proc(instructions: ^[dynamic]Instruction, imm: i64, dst: Register) {…}

    emit_mtfsf_imm_fr ¶
    Source

    emit_mtfsf_imm_fr :: proc(instructions: ^[dynamic]Instruction, imm: i64, dst: Register) {…}

    emit_mtfsfi ¶
    Source

    emit_mtfsfi :: emit_mtfsfi_crf_imm

    emit_mtfsfi_crf_imm ¶
    Source

    emit_mtfsfi_crf_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, imm: i64) {…}

    emit_mtfsfi_dot ¶
    Source

    emit_mtfsfi_dot :: emit_mtfsfi_dot_crf_imm

    emit_mtfsfi_dot_crf_imm ¶
    Source

    emit_mtfsfi_dot_crf_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, imm: i64) {…}

    emit_mtlr ¶
    Source

    emit_mtlr :: emit_mtlr_r

    emit_mtlr_r ¶
    Source

    emit_mtlr_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mtmsr ¶
    Source

    emit_mtmsr :: emit_mtmsr_r

    emit_mtmsr_r ¶
    Source

    emit_mtmsr_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mtmsrd ¶
    Source

    emit_mtmsrd :: emit_mtmsrd_r

    emit_mtmsrd_r ¶
    Source

    emit_mtmsrd_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mtocrf ¶
    Source

    emit_mtocrf :: emit_mtocrf_imm_r

    emit_mtocrf_imm_r ¶
    Source

    emit_mtocrf_imm_r :: proc(instructions: ^[dynamic]Instruction, imm: i64, dst: Register) {…}

    emit_mtpmr ¶
    Source

    emit_mtpmr :: emit_mtpmr_spr_r

    emit_mtpmr_spr_r ¶
    Source

    emit_mtpmr_spr_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_mtppr ¶
    Source

    emit_mtppr :: emit_mtppr_r

    emit_mtppr_r ¶
    Source

    emit_mtppr_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mtsle ¶
    Source

    emit_mtsle :: emit_mtsle_r_r_r

    emit_mtsle_r_r_r ¶
    Source

    emit_mtsle_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mtspr ¶
    Source

    emit_mtspr :: emit_mtspr_spr_r

    emit_mtspr_spr_r ¶
    Source

    emit_mtspr_spr_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_mtsr ¶
    Source

    emit_mtsr :: emit_mtsr_imm_r

    emit_mtsr_imm_r ¶
    Source

    emit_mtsr_imm_r :: proc(instructions: ^[dynamic]Instruction, imm: i64, dst: Register) {…}

    emit_mtsrdin ¶
    Source

    emit_mtsrdin :: emit_mtsrdin_r_r_r

    emit_mtsrdin_r_r_r ¶
    Source

    emit_mtsrdin_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mtsri ¶
    Source

    emit_mtsri :: emit_mtsri_r_r_r

    emit_mtsri_r_r_r ¶
    Source

    emit_mtsri_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mtsrin ¶
    Source

    emit_mtsrin :: emit_mtsrin_r_r

    emit_mtsrin_r_r ¶
    Source

    emit_mtsrin_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_mtsrr0 ¶
    Source

    emit_mtsrr0 :: emit_mtsrr0_r

    emit_mtsrr0_r ¶
    Source

    emit_mtsrr0_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mtsrr1 ¶
    Source

    emit_mtsrr1 :: emit_mtsrr1_r

    emit_mtsrr1_r ¶
    Source

    emit_mtsrr1_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mttbl ¶
    Source

    emit_mttbl :: emit_mttbl_r

    emit_mttbl_r ¶
    Source

    emit_mttbl_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mttbu ¶
    Source

    emit_mttbu :: emit_mttbu_r

    emit_mttbu_r ¶
    Source

    emit_mttbu_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mttcr ¶
    Source

    emit_mttcr :: emit_mttcr_r

    emit_mttcr_r ¶
    Source

    emit_mttcr_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mttmr ¶
    Source

    emit_mttmr :: emit_mttmr_r_r_r

    emit_mttmr_r_r_r ¶
    Source

    emit_mttmr_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mtvscr ¶
    Source

    emit_mtvscr :: emit_mtvscr_v

    emit_mtvscr_v ¶
    Source

    emit_mtvscr_v :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mtvsrbm ¶
    Source

    emit_mtvsrbm :: emit_mtvsrbm_vs_r

    emit_mtvsrbm_vs_r ¶
    Source

    emit_mtvsrbm_vs_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_mtvsrd ¶
    Source

    emit_mtvsrd :: emit_mtvsrd_r_r_r

    emit_mtvsrd_r_r_r ¶
    Source

    emit_mtvsrd_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mtvsrdd ¶
    Source

    emit_mtvsrdd :: emit_mtvsrdd_vs_r_r

    emit_mtvsrdd_vs_r_r ¶
    Source

    emit_mtvsrdd_vs_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mtvsrdm ¶
    Source

    emit_mtvsrdm :: emit_mtvsrdm_vs_r

    emit_mtvsrdm_vs_r ¶
    Source

    emit_mtvsrdm_vs_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_mtvsrhm ¶
    Source

    emit_mtvsrhm :: emit_mtvsrhm_vs_r

    emit_mtvsrhm_vs_r ¶
    Source

    emit_mtvsrhm_vs_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_mtvsrqm ¶
    Source

    emit_mtvsrqm :: emit_mtvsrqm_vs_r

    emit_mtvsrqm_vs_r ¶
    Source

    emit_mtvsrqm_vs_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_mtvsrwa ¶
    Source

    emit_mtvsrwa :: emit_mtvsrwa_r_r_r

    emit_mtvsrwa_r_r_r ¶
    Source

    emit_mtvsrwa_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mtvsrwm ¶
    Source

    emit_mtvsrwm :: emit_mtvsrwm_vs_r

    emit_mtvsrwm_vs_r ¶
    Source

    emit_mtvsrwm_vs_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_mtvsrws ¶
    Source

    emit_mtvsrws :: emit_mtvsrws_vs_r

    emit_mtvsrws_vs_r ¶
    Source

    emit_mtvsrws_vs_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_mtvsrwz ¶
    Source

    emit_mtvsrwz :: emit_mtvsrwz_r_r_r

    emit_mtvsrwz_r_r_r ¶
    Source

    emit_mtvsrwz_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mtxer ¶
    Source

    emit_mtxer :: emit_mtxer_r

    emit_mtxer_r ¶
    Source

    emit_mtxer_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_mul ¶
    Source

    emit_mul :: emit_mul_r_r_r

    emit_mul_dot ¶
    Source

    emit_mul_dot :: emit_mul_dot_r_r_r

    emit_mul_dot_r_r_r ¶
    Source

    emit_mul_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mul_r_r_r ¶
    Source

    emit_mul_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mulchw ¶
    Source

    emit_mulchw :: emit_mulchw_r_r_r

    emit_mulchw_dot ¶
    Source

    emit_mulchw_dot :: emit_mulchw_dot_r_r_r

    emit_mulchw_dot_r_r_r ¶
    Source

    emit_mulchw_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mulchw_r_r_r ¶
    Source

    emit_mulchw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mulchwu ¶
    Source

    emit_mulchwu :: emit_mulchwu_r_r_r

    emit_mulchwu_dot ¶
    Source

    emit_mulchwu_dot :: emit_mulchwu_dot_r_r_r

    emit_mulchwu_dot_r_r_r ¶
    Source

    emit_mulchwu_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mulchwu_r_r_r ¶
    Source

    emit_mulchwu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mulhd ¶
    Source

    emit_mulhd :: emit_mulhd_r_r_r

    emit_mulhd_dot ¶
    Source

    emit_mulhd_dot :: emit_mulhd_dot_r_r_r

    emit_mulhd_dot_r_r_r ¶
    Source

    emit_mulhd_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mulhd_r_r_r ¶
    Source

    emit_mulhd_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mulhdu ¶
    Source

    emit_mulhdu :: emit_mulhdu_r_r_r

    emit_mulhdu_dot ¶
    Source

    emit_mulhdu_dot :: emit_mulhdu_dot_r_r_r

    emit_mulhdu_dot_r_r_r ¶
    Source

    emit_mulhdu_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mulhdu_r_r_r ¶
    Source

    emit_mulhdu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mulhhw ¶
    Source

    emit_mulhhw :: emit_mulhhw_r_r_r

    emit_mulhhw_dot ¶
    Source

    emit_mulhhw_dot :: emit_mulhhw_dot_r_r_r

    emit_mulhhw_dot_r_r_r ¶
    Source

    emit_mulhhw_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mulhhw_r_r_r ¶
    Source

    emit_mulhhw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mulhhwu ¶
    Source

    emit_mulhhwu :: emit_mulhhwu_r_r_r

    emit_mulhhwu_dot ¶
    Source

    emit_mulhhwu_dot :: emit_mulhhwu_dot_r_r_r

    emit_mulhhwu_dot_r_r_r ¶
    Source

    emit_mulhhwu_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mulhhwu_r_r_r ¶
    Source

    emit_mulhhwu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mulhw ¶
    Source

    emit_mulhw :: emit_mulhw_r_r_r

    emit_mulhw_dot ¶
    Source

    emit_mulhw_dot :: emit_mulhw_dot_r_r_r

    emit_mulhw_dot_r_r_r ¶
    Source

    emit_mulhw_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mulhw_r_r_r ¶
    Source

    emit_mulhw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mulhwu ¶
    Source

    emit_mulhwu :: emit_mulhwu_r_r_r

    emit_mulhwu_dot ¶
    Source

    emit_mulhwu_dot :: emit_mulhwu_dot_r_r_r

    emit_mulhwu_dot_r_r_r ¶
    Source

    emit_mulhwu_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mulhwu_r_r_r ¶
    Source

    emit_mulhwu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_muli ¶
    Source

    emit_muli :: emit_muli_r_r_imm

    emit_muli_r_r_imm ¶
    Source

    emit_muli_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_mulld ¶
    Source

    emit_mulld :: emit_mulld_r_r_r

    emit_mulld_dot ¶
    Source

    emit_mulld_dot :: emit_mulld_dot_r_r_r

    emit_mulld_dot_r_r_r ¶
    Source

    emit_mulld_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mulld_o ¶
    Source

    emit_mulld_o :: emit_mulld_o_r_r_r

    emit_mulld_o_dot ¶
    Source

    emit_mulld_o_dot :: emit_mulld_o_dot_r_r_r

    emit_mulld_o_dot_r_r_r ¶
    Source

    emit_mulld_o_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mulld_o_r_r_r ¶
    Source

    emit_mulld_o_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mulld_r_r_r ¶
    Source

    emit_mulld_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mulldo ¶
    Source

    emit_mulldo :: emit_mulldo_r_r_r

    emit_mulldo_dot ¶
    Source

    emit_mulldo_dot :: emit_mulldo_dot_r_r_r

    emit_mulldo_dot_r_r_r ¶
    Source

    emit_mulldo_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mulldo_r_r_r ¶
    Source

    emit_mulldo_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mullhw ¶
    Source

    emit_mullhw :: emit_mullhw_r_r_r

    emit_mullhw_dot ¶
    Source

    emit_mullhw_dot :: emit_mullhw_dot_r_r_r

    emit_mullhw_dot_r_r_r ¶
    Source

    emit_mullhw_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mullhw_r_r_r ¶
    Source

    emit_mullhw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mullhwu ¶
    Source

    emit_mullhwu :: emit_mullhwu_r_r_r

    emit_mullhwu_dot ¶
    Source

    emit_mullhwu_dot :: emit_mullhwu_dot_r_r_r

    emit_mullhwu_dot_r_r_r ¶
    Source

    emit_mullhwu_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mullhwu_r_r_r ¶
    Source

    emit_mullhwu_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mulli ¶
    Source

    emit_mulli :: emit_mulli_r_rz_simm

    emit_mulli_r_rz_simm ¶
    Source

    emit_mulli_r_rz_simm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_mullw ¶
    Source

    emit_mullw :: emit_mullw_r_r_r

    emit_mullw_dot ¶
    Source

    emit_mullw_dot :: emit_mullw_dot_r_r_r

    emit_mullw_dot_r_r_r ¶
    Source

    emit_mullw_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mullw_o ¶
    Source

    emit_mullw_o :: emit_mullw_o_r_r_r

    emit_mullw_o_dot ¶
    Source

    emit_mullw_o_dot :: emit_mullw_o_dot_r_r_r

    emit_mullw_o_dot_r_r_r ¶
    Source

    emit_mullw_o_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mullw_o_r_r_r ¶
    Source

    emit_mullw_o_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mullw_r_r_r ¶
    Source

    emit_mullw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mullwo ¶
    Source

    emit_mullwo :: emit_mullwo_r_r_r

    emit_mullwo_dot ¶
    Source

    emit_mullwo_dot :: emit_mullwo_dot_r_r_r

    emit_mullwo_dot_r_r_r ¶
    Source

    emit_mullwo_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mullwo_r_r_r ¶
    Source

    emit_mullwo_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mulo ¶
    Source

    emit_mulo :: emit_mulo_r_r_r

    emit_mulo_dot ¶
    Source

    emit_mulo_dot :: emit_mulo_dot_r_r_r

    emit_mulo_dot_r_r_r ¶
    Source

    emit_mulo_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mulo_r_r_r ¶
    Source

    emit_mulo_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_muls ¶
    Source

    emit_muls :: emit_muls_r_r_r

    emit_muls_dot ¶
    Source

    emit_muls_dot :: emit_muls_dot_r_r_r

    emit_muls_dot_r_r_r ¶
    Source

    emit_muls_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_muls_r_r_r ¶
    Source

    emit_muls_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mulso ¶
    Source

    emit_mulso :: emit_mulso_r_r_r

    emit_mulso_dot ¶
    Source

    emit_mulso_dot :: emit_mulso_dot_r_r_r

    emit_mulso_dot_r_r_r ¶
    Source

    emit_mulso_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mulso_r_r_r ¶
    Source

    emit_mulso_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mvidsplt ¶
    Source

    emit_mvidsplt :: emit_mvidsplt_r_r_r

    emit_mvidsplt_r_r_r ¶
    Source

    emit_mvidsplt_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_mviwsplt ¶
    Source

    emit_mviwsplt :: emit_mviwsplt_r_r_r

    emit_mviwsplt_r_r_r ¶
    Source

    emit_mviwsplt_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_nabs ¶
    Source

    emit_nabs :: emit_nabs_r_r_r

    emit_nabs_dot ¶
    Source

    emit_nabs_dot :: emit_nabs_dot_r_r_r

    emit_nabs_dot_r_r_r ¶
    Source

    emit_nabs_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_nabs_r_r_r ¶
    Source

    emit_nabs_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_nabso ¶
    Source

    emit_nabso :: emit_nabso_r_r_r

    emit_nabso_dot ¶
    Source

    emit_nabso_dot :: emit_nabso_dot_r_r_r

    emit_nabso_dot_r_r_r ¶
    Source

    emit_nabso_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_nabso_r_r_r ¶
    Source

    emit_nabso_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_nand ¶
    Source

    emit_nand :: emit_nand_r_r_r

    emit_nand_dot ¶
    Source

    emit_nand_dot :: emit_nand_dot_r_r_r

    emit_nand_dot_r_r_r ¶
    Source

    emit_nand_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_nand_r_r_r ¶
    Source

    emit_nand_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_nap ¶
    Source

    emit_nap :: emit_nap_none

    emit_nap_none ¶
    Source

    emit_nap_none :: proc(instructions: ^[dynamic]Instruction) {…}

    emit_neg ¶
    Source

    emit_neg :: emit_neg_r_r

    emit_neg_dot ¶
    Source

    emit_neg_dot :: emit_neg_dot_r_r

    emit_neg_dot_r_r ¶
    Source

    emit_neg_dot_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_neg_o ¶
    Source

    emit_neg_o :: emit_neg_o_r_r

    emit_neg_o_dot ¶
    Source

    emit_neg_o_dot :: emit_neg_o_dot_r_r

    emit_neg_o_dot_r_r ¶
    Source

    emit_neg_o_dot_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_neg_o_r_r ¶
    Source

    emit_neg_o_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_neg_r_r ¶
    Source

    emit_neg_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_nego ¶
    Source

    emit_nego :: emit_nego_r_r_r

    emit_nego_dot ¶
    Source

    emit_nego_dot :: emit_nego_dot_r_r_r

    emit_nego_dot_r_r_r ¶
    Source

    emit_nego_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_nego_r_r_r ¶
    Source

    emit_nego_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_nmacchw ¶
    Source

    emit_nmacchw :: emit_nmacchw_r_r_r

    emit_nmacchw_dot ¶
    Source

    emit_nmacchw_dot :: emit_nmacchw_dot_r_r_r

    emit_nmacchw_dot_r_r_r ¶
    Source

    emit_nmacchw_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_nmacchw_r_r_r ¶
    Source

    emit_nmacchw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_nmacchwo ¶
    Source

    emit_nmacchwo :: emit_nmacchwo_r_r_r

    emit_nmacchwo_dot ¶
    Source

    emit_nmacchwo_dot :: emit_nmacchwo_dot_r_r_r

    emit_nmacchwo_dot_r_r_r ¶
    Source

    emit_nmacchwo_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_nmacchwo_r_r_r ¶
    Source

    emit_nmacchwo_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_nmacchws ¶
    Source

    emit_nmacchws :: emit_nmacchws_r_r_r

    emit_nmacchws_dot ¶
    Source

    emit_nmacchws_dot :: emit_nmacchws_dot_r_r_r

    emit_nmacchws_dot_r_r_r ¶
    Source

    emit_nmacchws_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_nmacchws_r_r_r ¶
    Source

    emit_nmacchws_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_nmacchwso ¶
    Source

    emit_nmacchwso :: emit_nmacchwso_r_r_r

    emit_nmacchwso_dot ¶
    Source

    emit_nmacchwso_dot :: emit_nmacchwso_dot_r_r_r

    emit_nmacchwso_dot_r_r_r ¶
    Source

    emit_nmacchwso_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_nmacchwso_r_r_r ¶
    Source

    emit_nmacchwso_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_nmachhw ¶
    Source

    emit_nmachhw :: emit_nmachhw_r_r_r

    emit_nmachhw_dot ¶
    Source

    emit_nmachhw_dot :: emit_nmachhw_dot_r_r_r

    emit_nmachhw_dot_r_r_r ¶
    Source

    emit_nmachhw_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_nmachhw_r_r_r ¶
    Source

    emit_nmachhw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_nmachhwo ¶
    Source

    emit_nmachhwo :: emit_nmachhwo_r_r_r

    emit_nmachhwo_dot ¶
    Source

    emit_nmachhwo_dot :: emit_nmachhwo_dot_r_r_r

    emit_nmachhwo_dot_r_r_r ¶
    Source

    emit_nmachhwo_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_nmachhwo_r_r_r ¶
    Source

    emit_nmachhwo_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_nmachhws ¶
    Source

    emit_nmachhws :: emit_nmachhws_r_r_r

    emit_nmachhws_dot ¶
    Source

    emit_nmachhws_dot :: emit_nmachhws_dot_r_r_r

    emit_nmachhws_dot_r_r_r ¶
    Source

    emit_nmachhws_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_nmachhws_r_r_r ¶
    Source

    emit_nmachhws_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_nmachhwso ¶
    Source

    emit_nmachhwso :: emit_nmachhwso_r_r_r

    emit_nmachhwso_dot ¶
    Source

    emit_nmachhwso_dot :: emit_nmachhwso_dot_r_r_r

    emit_nmachhwso_dot_r_r_r ¶
    Source

    emit_nmachhwso_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_nmachhwso_r_r_r ¶
    Source

    emit_nmachhwso_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_nmaclhw ¶
    Source

    emit_nmaclhw :: emit_nmaclhw_r_r_r

    emit_nmaclhw_dot ¶
    Source

    emit_nmaclhw_dot :: emit_nmaclhw_dot_r_r_r

    emit_nmaclhw_dot_r_r_r ¶
    Source

    emit_nmaclhw_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_nmaclhw_r_r_r ¶
    Source

    emit_nmaclhw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_nmaclhwo ¶
    Source

    emit_nmaclhwo :: emit_nmaclhwo_r_r_r

    emit_nmaclhwo_dot ¶
    Source

    emit_nmaclhwo_dot :: emit_nmaclhwo_dot_r_r_r

    emit_nmaclhwo_dot_r_r_r ¶
    Source

    emit_nmaclhwo_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_nmaclhwo_r_r_r ¶
    Source

    emit_nmaclhwo_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_nmaclhws ¶
    Source

    emit_nmaclhws :: emit_nmaclhws_r_r_r

    emit_nmaclhws_dot ¶
    Source

    emit_nmaclhws_dot :: emit_nmaclhws_dot_r_r_r

    emit_nmaclhws_dot_r_r_r ¶
    Source

    emit_nmaclhws_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_nmaclhws_r_r_r ¶
    Source

    emit_nmaclhws_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_nmaclhwso ¶
    Source

    emit_nmaclhwso :: emit_nmaclhwso_r_r_r

    emit_nmaclhwso_dot ¶
    Source

    emit_nmaclhwso_dot :: emit_nmaclhwso_dot_r_r_r

    emit_nmaclhwso_dot_r_r_r ¶
    Source

    emit_nmaclhwso_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_nmaclhwso_r_r_r ¶
    Source

    emit_nmaclhwso_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_nop ¶
    Source

    emit_nop :: emit_nop_none

    emit_nop_none ¶
    Source

    emit_nop_none :: proc(instructions: ^[dynamic]Instruction) {…}

    emit_nor ¶
    Source

    emit_nor :: emit_nor_r_r_r

    emit_nor_dot ¶
    Source

    emit_nor_dot :: emit_nor_dot_r_r_r

    emit_nor_dot_r_r_r ¶
    Source

    emit_nor_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_nor_r_r_r ¶
    Source

    emit_nor_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_not ¶
    Source

    emit_not :: emit_not_r_r

    emit_not_dot ¶
    Source

    emit_not_dot :: emit_not_dot_r_r

    emit_not_dot_r_r ¶
    Source

    emit_not_dot_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_not_r_r ¶
    Source

    emit_not_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_or ¶
    Source

    emit_or :: emit_or_r_r_r

    emit_or_dot ¶
    Source

    emit_or_dot :: emit_or_dot_r_r_r

    emit_or_dot_r_r_r ¶
    Source

    emit_or_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_or_r_r_r ¶
    Source

    emit_or_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_orc ¶
    Source

    emit_orc :: emit_orc_r_r_r

    emit_orc_dot ¶
    Source

    emit_orc_dot :: emit_orc_dot_r_r_r

    emit_orc_dot_r_r_r ¶
    Source

    emit_orc_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_orc_r_r_r ¶
    Source

    emit_orc_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_ori ¶
    Source

    emit_ori :: emit_ori_r_r_uimm

    emit_ori_r_r_uimm ¶
    Source

    emit_ori_r_r_uimm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_oril ¶
    Source

    emit_oril :: emit_oril_r_r_imm

    emit_oril_r_r_imm ¶
    Source

    emit_oril_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_oris ¶
    Source

    emit_oris :: emit_oris_r_r_uimm

    emit_oris_r_r_uimm ¶
    Source

    emit_oris_r_r_uimm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_oriu ¶
    Source

    emit_oriu :: emit_oriu_r_r_imm

    emit_oriu_r_r_imm ¶
    Source

    emit_oriu_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_paddi ¶
    Source

    emit_paddi :: emit_paddi_r_rz_simm

    emit_paddi_r_rz_simm ¶
    Source

    emit_paddi_r_rz_simm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_paste_dot ¶
    Source

    emit_paste_dot :: emit_paste_dot_r_r

    emit_paste_dot_r_r ¶
    Source

    emit_paste_dot_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_pbt_dot ¶
    Source

    emit_pbt_dot :: emit_pbt_dot_r_r_r

    emit_pbt_dot_r_r_r ¶
    Source

    emit_pbt_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_pdepd ¶
    Source

    emit_pdepd :: emit_pdepd_r_r_r

    emit_pdepd_r_r_r ¶
    Source

    emit_pdepd_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_pextd ¶
    Source

    emit_pextd :: emit_pextd_r_r_r

    emit_pextd_r_r_r ¶
    Source

    emit_pextd_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_plbz ¶
    Source

    emit_plbz :: emit_plbz_r_mem

    emit_plbz_r_mem ¶
    Source

    emit_plbz_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_pld ¶
    Source

    emit_pld :: emit_pld_r_mem

    emit_pld_r_mem ¶
    Source

    emit_pld_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_plfd ¶
    Source

    emit_plfd :: emit_plfd_fr_mem

    emit_plfd_fr_mem ¶
    Source

    emit_plfd_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_plfs ¶
    Source

    emit_plfs :: emit_plfs_fr_mem

    emit_plfs_fr_mem ¶
    Source

    emit_plfs_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_plha ¶
    Source

    emit_plha :: emit_plha_r_mem

    emit_plha_r_mem ¶
    Source

    emit_plha_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_plhz ¶
    Source

    emit_plhz :: emit_plhz_r_mem

    emit_plhz_r_mem ¶
    Source

    emit_plhz_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_pli ¶
    Source

    emit_pli :: emit_pli_r_simm

    emit_pli_r_simm ¶
    Source

    emit_pli_r_simm :: proc(instructions: ^[dynamic]Instruction, dst: Register, imm: i64) {…}

    emit_plwa ¶
    Source

    emit_plwa :: emit_plwa_r_mem

    emit_plwa_r_mem ¶
    Source

    emit_plwa_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_plwz ¶
    Source

    emit_plwz :: emit_plwz_r_mem

    emit_plwz_r_mem ¶
    Source

    emit_plwz_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_plxsd ¶
    Source

    emit_plxsd :: emit_plxsd_v_mem

    emit_plxsd_v_mem ¶
    Source

    emit_plxsd_v_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_plxssp ¶
    Source

    emit_plxssp :: emit_plxssp_v_mem

    emit_plxssp_v_mem ¶
    Source

    emit_plxssp_v_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_plxv ¶
    Source

    emit_plxv :: emit_plxv_vs_mem

    emit_plxv_vs_mem ¶
    Source

    emit_plxv_vs_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_pmxvbf16ger2 ¶
    Source

    emit_pmxvbf16ger2 :: emit_pmxvbf16ger2_imm_vs_vs

    emit_pmxvbf16ger2_imm_vs_vs ¶
    Source

    emit_pmxvbf16ger2_imm_vs_vs :: proc(instructions: ^[dynamic]Instruction, imm: i64, dst: Register, src: Register) {…}

    emit_pmxvbf16ger2nn ¶
    Source

    emit_pmxvbf16ger2nn :: emit_pmxvbf16ger2nn_imm_vs_vs

    emit_pmxvbf16ger2nn_imm_vs_vs ¶
    Source

    emit_pmxvbf16ger2nn_imm_vs_vs :: proc(instructions: ^[dynamic]Instruction, imm: i64, dst: Register, src: Register) {…}

    emit_pmxvbf16ger2np ¶
    Source

    emit_pmxvbf16ger2np :: emit_pmxvbf16ger2np_imm_vs_vs

    emit_pmxvbf16ger2np_imm_vs_vs ¶
    Source

    emit_pmxvbf16ger2np_imm_vs_vs :: proc(instructions: ^[dynamic]Instruction, imm: i64, dst: Register, src: Register) {…}

    emit_pmxvbf16ger2pn ¶
    Source

    emit_pmxvbf16ger2pn :: emit_pmxvbf16ger2pn_imm_vs_vs

    emit_pmxvbf16ger2pn_imm_vs_vs ¶
    Source

    emit_pmxvbf16ger2pn_imm_vs_vs :: proc(instructions: ^[dynamic]Instruction, imm: i64, dst: Register, src: Register) {…}

    emit_pmxvbf16ger2pp ¶
    Source

    emit_pmxvbf16ger2pp :: emit_pmxvbf16ger2pp_imm_vs_vs

    emit_pmxvbf16ger2pp_imm_vs_vs ¶
    Source

    emit_pmxvbf16ger2pp_imm_vs_vs :: proc(instructions: ^[dynamic]Instruction, imm: i64, dst: Register, src: Register) {…}

    emit_pmxvf16ger2 ¶
    Source

    emit_pmxvf16ger2 :: emit_pmxvf16ger2_imm_vs_vs

    emit_pmxvf16ger2_imm_vs_vs ¶
    Source

    emit_pmxvf16ger2_imm_vs_vs :: proc(instructions: ^[dynamic]Instruction, imm: i64, dst: Register, src: Register) {…}

    emit_pmxvf16ger2nn ¶
    Source

    emit_pmxvf16ger2nn :: emit_pmxvf16ger2nn_imm_vs_vs

    emit_pmxvf16ger2nn_imm_vs_vs ¶
    Source

    emit_pmxvf16ger2nn_imm_vs_vs :: proc(instructions: ^[dynamic]Instruction, imm: i64, dst: Register, src: Register) {…}

    emit_pmxvf16ger2np ¶
    Source

    emit_pmxvf16ger2np :: emit_pmxvf16ger2np_imm_vs_vs

    emit_pmxvf16ger2np_imm_vs_vs ¶
    Source

    emit_pmxvf16ger2np_imm_vs_vs :: proc(instructions: ^[dynamic]Instruction, imm: i64, dst: Register, src: Register) {…}

    emit_pmxvf16ger2pn ¶
    Source

    emit_pmxvf16ger2pn :: emit_pmxvf16ger2pn_imm_vs_vs

    emit_pmxvf16ger2pn_imm_vs_vs ¶
    Source

    emit_pmxvf16ger2pn_imm_vs_vs :: proc(instructions: ^[dynamic]Instruction, imm: i64, dst: Register, src: Register) {…}

    emit_pmxvf16ger2pp ¶
    Source

    emit_pmxvf16ger2pp :: emit_pmxvf16ger2pp_imm_vs_vs

    emit_pmxvf16ger2pp_imm_vs_vs ¶
    Source

    emit_pmxvf16ger2pp_imm_vs_vs :: proc(instructions: ^[dynamic]Instruction, imm: i64, dst: Register, src: Register) {…}

    emit_pmxvf32ger ¶
    Source

    emit_pmxvf32ger :: emit_pmxvf32ger_imm_vs_vs

    emit_pmxvf32ger_imm_vs_vs ¶
    Source

    emit_pmxvf32ger_imm_vs_vs :: proc(instructions: ^[dynamic]Instruction, imm: i64, dst: Register, src: Register) {…}

    emit_pmxvf32gernn ¶
    Source

    emit_pmxvf32gernn :: emit_pmxvf32gernn_imm_vs_vs

    emit_pmxvf32gernn_imm_vs_vs ¶
    Source

    emit_pmxvf32gernn_imm_vs_vs :: proc(instructions: ^[dynamic]Instruction, imm: i64, dst: Register, src: Register) {…}

    emit_pmxvf32gernp ¶
    Source

    emit_pmxvf32gernp :: emit_pmxvf32gernp_imm_vs_vs

    emit_pmxvf32gernp_imm_vs_vs ¶
    Source

    emit_pmxvf32gernp_imm_vs_vs :: proc(instructions: ^[dynamic]Instruction, imm: i64, dst: Register, src: Register) {…}

    emit_pmxvf32gerpn ¶
    Source

    emit_pmxvf32gerpn :: emit_pmxvf32gerpn_imm_vs_vs

    emit_pmxvf32gerpn_imm_vs_vs ¶
    Source

    emit_pmxvf32gerpn_imm_vs_vs :: proc(instructions: ^[dynamic]Instruction, imm: i64, dst: Register, src: Register) {…}

    emit_pmxvf32gerpp ¶
    Source

    emit_pmxvf32gerpp :: emit_pmxvf32gerpp_imm_vs_vs

    emit_pmxvf32gerpp_imm_vs_vs ¶
    Source

    emit_pmxvf32gerpp_imm_vs_vs :: proc(instructions: ^[dynamic]Instruction, imm: i64, dst: Register, src: Register) {…}

    emit_pmxvf64ger ¶
    Source

    emit_pmxvf64ger :: emit_pmxvf64ger_imm_vs_vs

    emit_pmxvf64ger_imm_vs_vs ¶
    Source

    emit_pmxvf64ger_imm_vs_vs :: proc(instructions: ^[dynamic]Instruction, imm: i64, dst: Register, src: Register) {…}

    emit_pmxvf64gernn ¶
    Source

    emit_pmxvf64gernn :: emit_pmxvf64gernn_imm_vs_vs

    emit_pmxvf64gernn_imm_vs_vs ¶
    Source

    emit_pmxvf64gernn_imm_vs_vs :: proc(instructions: ^[dynamic]Instruction, imm: i64, dst: Register, src: Register) {…}

    emit_pmxvf64gernp ¶
    Source

    emit_pmxvf64gernp :: emit_pmxvf64gernp_imm_vs_vs

    emit_pmxvf64gernp_imm_vs_vs ¶
    Source

    emit_pmxvf64gernp_imm_vs_vs :: proc(instructions: ^[dynamic]Instruction, imm: i64, dst: Register, src: Register) {…}

    emit_pmxvf64gerpn ¶
    Source

    emit_pmxvf64gerpn :: emit_pmxvf64gerpn_imm_vs_vs

    emit_pmxvf64gerpn_imm_vs_vs ¶
    Source

    emit_pmxvf64gerpn_imm_vs_vs :: proc(instructions: ^[dynamic]Instruction, imm: i64, dst: Register, src: Register) {…}

    emit_pmxvf64gerpp ¶
    Source

    emit_pmxvf64gerpp :: emit_pmxvf64gerpp_imm_vs_vs

    emit_pmxvf64gerpp_imm_vs_vs ¶
    Source

    emit_pmxvf64gerpp_imm_vs_vs :: proc(instructions: ^[dynamic]Instruction, imm: i64, dst: Register, src: Register) {…}

    emit_pmxvi16ger2 ¶
    Source

    emit_pmxvi16ger2 :: emit_pmxvi16ger2_imm_vs_vs

    emit_pmxvi16ger2_imm_vs_vs ¶
    Source

    emit_pmxvi16ger2_imm_vs_vs :: proc(instructions: ^[dynamic]Instruction, imm: i64, dst: Register, src: Register) {…}

    emit_pmxvi16ger2pp ¶
    Source

    emit_pmxvi16ger2pp :: emit_pmxvi16ger2pp_imm_vs_vs

    emit_pmxvi16ger2pp_imm_vs_vs ¶
    Source

    emit_pmxvi16ger2pp_imm_vs_vs :: proc(instructions: ^[dynamic]Instruction, imm: i64, dst: Register, src: Register) {…}

    emit_pmxvi16ger2s ¶
    Source

    emit_pmxvi16ger2s :: emit_pmxvi16ger2s_imm_vs_vs

    emit_pmxvi16ger2s_imm_vs_vs ¶
    Source

    emit_pmxvi16ger2s_imm_vs_vs :: proc(instructions: ^[dynamic]Instruction, imm: i64, dst: Register, src: Register) {…}

    emit_pmxvi16ger2spp ¶
    Source

    emit_pmxvi16ger2spp :: emit_pmxvi16ger2spp_imm_vs_vs

    emit_pmxvi16ger2spp_imm_vs_vs ¶
    Source

    emit_pmxvi16ger2spp_imm_vs_vs :: proc(instructions: ^[dynamic]Instruction, imm: i64, dst: Register, src: Register) {…}

    emit_pmxvi4ger8 ¶
    Source

    emit_pmxvi4ger8 :: emit_pmxvi4ger8_imm_vs_vs

    emit_pmxvi4ger8_imm_vs_vs ¶
    Source

    emit_pmxvi4ger8_imm_vs_vs :: proc(instructions: ^[dynamic]Instruction, imm: i64, dst: Register, src: Register) {…}

    emit_pmxvi4ger8pp ¶
    Source

    emit_pmxvi4ger8pp :: emit_pmxvi4ger8pp_imm_vs_vs

    emit_pmxvi4ger8pp_imm_vs_vs ¶
    Source

    emit_pmxvi4ger8pp_imm_vs_vs :: proc(instructions: ^[dynamic]Instruction, imm: i64, dst: Register, src: Register) {…}

    emit_pmxvi8ger4 ¶
    Source

    emit_pmxvi8ger4 :: emit_pmxvi8ger4_imm_vs_vs

    emit_pmxvi8ger4_imm_vs_vs ¶
    Source

    emit_pmxvi8ger4_imm_vs_vs :: proc(instructions: ^[dynamic]Instruction, imm: i64, dst: Register, src: Register) {…}

    emit_pmxvi8ger4pp ¶
    Source

    emit_pmxvi8ger4pp :: emit_pmxvi8ger4pp_imm_vs_vs

    emit_pmxvi8ger4pp_imm_vs_vs ¶
    Source

    emit_pmxvi8ger4pp_imm_vs_vs :: proc(instructions: ^[dynamic]Instruction, imm: i64, dst: Register, src: Register) {…}

    emit_pmxvi8ger4spp ¶
    Source

    emit_pmxvi8ger4spp :: emit_pmxvi8ger4spp_imm_vs_vs

    emit_pmxvi8ger4spp_imm_vs_vs ¶
    Source

    emit_pmxvi8ger4spp_imm_vs_vs :: proc(instructions: ^[dynamic]Instruction, imm: i64, dst: Register, src: Register) {…}

    emit_popcntb ¶
    Source

    emit_popcntb :: emit_popcntb_r_r

    emit_popcntb_r_r ¶
    Source

    emit_popcntb_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_popcntd ¶
    Source

    emit_popcntd :: emit_popcntd_r_r

    emit_popcntd_r_r ¶
    Source

    emit_popcntd_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_popcntw ¶
    Source

    emit_popcntw :: emit_popcntw_r_r

    emit_popcntw_r_r ¶
    Source

    emit_popcntw_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_prtyd ¶
    Source

    emit_prtyd :: emit_prtyd_r_r

    emit_prtyd_r_r ¶
    Source

    emit_prtyd_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_prtyw ¶
    Source

    emit_prtyw :: emit_prtyw_r_r

    emit_prtyw_r_r ¶
    Source

    emit_prtyw_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_ps_abs ¶
    Source

    emit_ps_abs :: emit_ps_abs_fr_fr

    emit_ps_abs_dot ¶
    Source

    emit_ps_abs_dot :: emit_ps_abs_dot_fr_fr

    emit_ps_abs_dot_fr_fr ¶
    Source

    emit_ps_abs_dot_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_ps_abs_fr_fr ¶
    Source

    emit_ps_abs_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_ps_add ¶
    Source

    emit_ps_add :: emit_ps_add_fr_fr_fr

    emit_ps_add_dot ¶
    Source

    emit_ps_add_dot :: emit_ps_add_dot_fr_fr_fr

    emit_ps_add_dot_fr_fr_fr ¶
    Source

    emit_ps_add_dot_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_ps_add_fr_fr_fr ¶
    Source

    emit_ps_add_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_ps_cmpo0 ¶
    Source

    emit_ps_cmpo0 :: emit_ps_cmpo0_crf_fr_fr

    emit_ps_cmpo0_crf_fr_fr ¶
    Source

    emit_ps_cmpo0_crf_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_ps_cmpo1 ¶
    Source

    emit_ps_cmpo1 :: emit_ps_cmpo1_crf_fr_fr

    emit_ps_cmpo1_crf_fr_fr ¶
    Source

    emit_ps_cmpo1_crf_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_ps_cmpu0 ¶
    Source

    emit_ps_cmpu0 :: emit_ps_cmpu0_crf_fr_fr

    emit_ps_cmpu0_crf_fr_fr ¶
    Source

    emit_ps_cmpu0_crf_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_ps_cmpu1 ¶
    Source

    emit_ps_cmpu1 :: emit_ps_cmpu1_crf_fr_fr

    emit_ps_cmpu1_crf_fr_fr ¶
    Source

    emit_ps_cmpu1_crf_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_ps_div ¶
    Source

    emit_ps_div :: emit_ps_div_fr_fr_fr

    emit_ps_div_dot ¶
    Source

    emit_ps_div_dot :: emit_ps_div_dot_fr_fr_fr

    emit_ps_div_dot_fr_fr_fr ¶
    Source

    emit_ps_div_dot_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_ps_div_fr_fr_fr ¶
    Source

    emit_ps_div_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_ps_madd ¶
    Source

    emit_ps_madd :: emit_ps_madd_fr_fr_fr_fr

    emit_ps_madd_dot ¶
    Source

    emit_ps_madd_dot :: emit_ps_madd_dot_fr_fr_fr_fr

    emit_ps_madd_dot_fr_fr_fr_fr ¶
    Source

    emit_ps_madd_dot_fr_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_ps_madd_fr_fr_fr_fr ¶
    Source

    emit_ps_madd_fr_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_ps_madds0 ¶
    Source

    emit_ps_madds0 :: emit_ps_madds0_fr_fr_fr_fr

    emit_ps_madds0_dot ¶
    Source

    emit_ps_madds0_dot :: emit_ps_madds0_dot_fr_fr_fr_fr

    emit_ps_madds0_dot_fr_fr_fr_fr ¶
    Source

    emit_ps_madds0_dot_fr_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_ps_madds0_fr_fr_fr_fr ¶
    Source

    emit_ps_madds0_fr_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_ps_madds1 ¶
    Source

    emit_ps_madds1 :: emit_ps_madds1_fr_fr_fr_fr

    emit_ps_madds1_dot ¶
    Source

    emit_ps_madds1_dot :: emit_ps_madds1_dot_fr_fr_fr_fr

    emit_ps_madds1_dot_fr_fr_fr_fr ¶
    Source

    emit_ps_madds1_dot_fr_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_ps_madds1_fr_fr_fr_fr ¶
    Source

    emit_ps_madds1_fr_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_ps_merge00 ¶
    Source

    emit_ps_merge00 :: emit_ps_merge00_fr_fr_fr

    emit_ps_merge00_dot ¶
    Source

    emit_ps_merge00_dot :: emit_ps_merge00_dot_fr_fr_fr

    emit_ps_merge00_dot_fr_fr_fr ¶
    Source

    emit_ps_merge00_dot_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_ps_merge00_fr_fr_fr ¶
    Source

    emit_ps_merge00_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_ps_merge01 ¶
    Source

    emit_ps_merge01 :: emit_ps_merge01_fr_fr_fr

    emit_ps_merge01_dot ¶
    Source

    emit_ps_merge01_dot :: emit_ps_merge01_dot_fr_fr_fr

    emit_ps_merge01_dot_fr_fr_fr ¶
    Source

    emit_ps_merge01_dot_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_ps_merge01_fr_fr_fr ¶
    Source

    emit_ps_merge01_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_ps_merge10 ¶
    Source

    emit_ps_merge10 :: emit_ps_merge10_fr_fr_fr

    emit_ps_merge10_dot ¶
    Source

    emit_ps_merge10_dot :: emit_ps_merge10_dot_fr_fr_fr

    emit_ps_merge10_dot_fr_fr_fr ¶
    Source

    emit_ps_merge10_dot_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_ps_merge10_fr_fr_fr ¶
    Source

    emit_ps_merge10_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_ps_merge11 ¶
    Source

    emit_ps_merge11 :: emit_ps_merge11_fr_fr_fr

    emit_ps_merge11_dot ¶
    Source

    emit_ps_merge11_dot :: emit_ps_merge11_dot_fr_fr_fr

    emit_ps_merge11_dot_fr_fr_fr ¶
    Source

    emit_ps_merge11_dot_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_ps_merge11_fr_fr_fr ¶
    Source

    emit_ps_merge11_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_ps_mr ¶
    Source

    emit_ps_mr :: emit_ps_mr_fr_fr

    emit_ps_mr_dot ¶
    Source

    emit_ps_mr_dot :: emit_ps_mr_dot_fr_fr

    emit_ps_mr_dot_fr_fr ¶
    Source

    emit_ps_mr_dot_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_ps_mr_fr_fr ¶
    Source

    emit_ps_mr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_ps_msub ¶
    Source

    emit_ps_msub :: emit_ps_msub_fr_fr_fr_fr

    emit_ps_msub_dot ¶
    Source

    emit_ps_msub_dot :: emit_ps_msub_dot_fr_fr_fr_fr

    emit_ps_msub_dot_fr_fr_fr_fr ¶
    Source

    emit_ps_msub_dot_fr_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_ps_msub_fr_fr_fr_fr ¶
    Source

    emit_ps_msub_fr_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_ps_mul ¶
    Source

    emit_ps_mul :: emit_ps_mul_fr_fr_fr

    emit_ps_mul_dot ¶
    Source

    emit_ps_mul_dot :: emit_ps_mul_dot_fr_fr_fr

    emit_ps_mul_dot_fr_fr_fr ¶
    Source

    emit_ps_mul_dot_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_ps_mul_fr_fr_fr ¶
    Source

    emit_ps_mul_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_ps_muls0 ¶
    Source

    emit_ps_muls0 :: emit_ps_muls0_fr_fr_fr

    emit_ps_muls0_dot ¶
    Source

    emit_ps_muls0_dot :: emit_ps_muls0_dot_fr_fr_fr

    emit_ps_muls0_dot_fr_fr_fr ¶
    Source

    emit_ps_muls0_dot_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_ps_muls0_fr_fr_fr ¶
    Source

    emit_ps_muls0_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_ps_muls1 ¶
    Source

    emit_ps_muls1 :: emit_ps_muls1_fr_fr_fr

    emit_ps_muls1_dot ¶
    Source

    emit_ps_muls1_dot :: emit_ps_muls1_dot_fr_fr_fr

    emit_ps_muls1_dot_fr_fr_fr ¶
    Source

    emit_ps_muls1_dot_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_ps_muls1_fr_fr_fr ¶
    Source

    emit_ps_muls1_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_ps_nabs ¶
    Source

    emit_ps_nabs :: emit_ps_nabs_fr_fr

    emit_ps_nabs_dot ¶
    Source

    emit_ps_nabs_dot :: emit_ps_nabs_dot_fr_fr

    emit_ps_nabs_dot_fr_fr ¶
    Source

    emit_ps_nabs_dot_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_ps_nabs_fr_fr ¶
    Source

    emit_ps_nabs_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_ps_neg ¶
    Source

    emit_ps_neg :: emit_ps_neg_fr_fr

    emit_ps_neg_dot ¶
    Source

    emit_ps_neg_dot :: emit_ps_neg_dot_fr_fr

    emit_ps_neg_dot_fr_fr ¶
    Source

    emit_ps_neg_dot_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_ps_neg_fr_fr ¶
    Source

    emit_ps_neg_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_ps_nmadd ¶
    Source

    emit_ps_nmadd :: emit_ps_nmadd_fr_fr_fr_fr

    emit_ps_nmadd_dot ¶
    Source

    emit_ps_nmadd_dot :: emit_ps_nmadd_dot_fr_fr_fr_fr

    emit_ps_nmadd_dot_fr_fr_fr_fr ¶
    Source

    emit_ps_nmadd_dot_fr_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_ps_nmadd_fr_fr_fr_fr ¶
    Source

    emit_ps_nmadd_fr_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_ps_nmsub ¶
    Source

    emit_ps_nmsub :: emit_ps_nmsub_fr_fr_fr_fr

    emit_ps_nmsub_dot ¶
    Source

    emit_ps_nmsub_dot :: emit_ps_nmsub_dot_fr_fr_fr_fr

    emit_ps_nmsub_dot_fr_fr_fr_fr ¶
    Source

    emit_ps_nmsub_dot_fr_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_ps_nmsub_fr_fr_fr_fr ¶
    Source

    emit_ps_nmsub_fr_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_ps_res ¶
    Source

    emit_ps_res :: emit_ps_res_fr_fr

    emit_ps_res_dot ¶
    Source

    emit_ps_res_dot :: emit_ps_res_dot_fr_fr

    emit_ps_res_dot_fr_fr ¶
    Source

    emit_ps_res_dot_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_ps_res_fr_fr ¶
    Source

    emit_ps_res_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_ps_rsqrte ¶
    Source

    emit_ps_rsqrte :: emit_ps_rsqrte_fr_fr

    emit_ps_rsqrte_dot ¶
    Source

    emit_ps_rsqrte_dot :: emit_ps_rsqrte_dot_fr_fr

    emit_ps_rsqrte_dot_fr_fr ¶
    Source

    emit_ps_rsqrte_dot_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_ps_rsqrte_fr_fr ¶
    Source

    emit_ps_rsqrte_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_ps_sel ¶
    Source

    emit_ps_sel :: emit_ps_sel_fr_fr_fr_fr

    emit_ps_sel_dot ¶
    Source

    emit_ps_sel_dot :: emit_ps_sel_dot_fr_fr_fr_fr

    emit_ps_sel_dot_fr_fr_fr_fr ¶
    Source

    emit_ps_sel_dot_fr_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_ps_sel_fr_fr_fr_fr ¶
    Source

    emit_ps_sel_fr_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_ps_sub ¶
    Source

    emit_ps_sub :: emit_ps_sub_fr_fr_fr

    emit_ps_sub_dot ¶
    Source

    emit_ps_sub_dot :: emit_ps_sub_dot_fr_fr_fr

    emit_ps_sub_dot_fr_fr_fr ¶
    Source

    emit_ps_sub_dot_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_ps_sub_fr_fr_fr ¶
    Source

    emit_ps_sub_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_ps_sum0 ¶
    Source

    emit_ps_sum0 :: emit_ps_sum0_fr_fr_fr_fr

    emit_ps_sum0_dot ¶
    Source

    emit_ps_sum0_dot :: emit_ps_sum0_dot_fr_fr_fr_fr

    emit_ps_sum0_dot_fr_fr_fr_fr ¶
    Source

    emit_ps_sum0_dot_fr_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_ps_sum0_fr_fr_fr_fr ¶
    Source

    emit_ps_sum0_fr_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_ps_sum1 ¶
    Source

    emit_ps_sum1 :: emit_ps_sum1_fr_fr_fr_fr

    emit_ps_sum1_dot ¶
    Source

    emit_ps_sum1_dot :: emit_ps_sum1_dot_fr_fr_fr_fr

    emit_ps_sum1_dot_fr_fr_fr_fr ¶
    Source

    emit_ps_sum1_dot_fr_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_ps_sum1_fr_fr_fr_fr ¶
    Source

    emit_ps_sum1_fr_fr_fr_fr :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, src3: Register) {…}

    emit_psq_l ¶
    Source

    emit_psq_l :: emit_psq_l_fr_mem

    emit_psq_l_fr_mem ¶
    Source

    emit_psq_l_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_psq_lu ¶
    Source

    emit_psq_lu :: emit_psq_lu_fr_mem

    emit_psq_lu_fr_mem ¶
    Source

    emit_psq_lu_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_psq_lux ¶
    Source

    emit_psq_lux :: emit_psq_lux_fr_mem

    emit_psq_lux_fr_mem ¶
    Source

    emit_psq_lux_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_psq_lx ¶
    Source

    emit_psq_lx :: emit_psq_lx_fr_mem

    emit_psq_lx_fr_mem ¶
    Source

    emit_psq_lx_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_psq_st ¶
    Source

    emit_psq_st :: emit_psq_st_fr_mem

    emit_psq_st_fr_mem ¶
    Source

    emit_psq_st_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_psq_stu ¶
    Source

    emit_psq_stu :: emit_psq_stu_fr_mem

    emit_psq_stu_fr_mem ¶
    Source

    emit_psq_stu_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_psq_stux ¶
    Source

    emit_psq_stux :: emit_psq_stux_fr_mem

    emit_psq_stux_fr_mem ¶
    Source

    emit_psq_stux_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_psq_stx ¶
    Source

    emit_psq_stx :: emit_psq_stx_fr_mem

    emit_psq_stx_fr_mem ¶
    Source

    emit_psq_stx_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_pstb ¶
    Source

    emit_pstb :: emit_pstb_r_mem

    emit_pstb_r_mem ¶
    Source

    emit_pstb_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_pstd ¶
    Source

    emit_pstd :: emit_pstd_r_mem

    emit_pstd_r_mem ¶
    Source

    emit_pstd_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_pstfd ¶
    Source

    emit_pstfd :: emit_pstfd_fr_mem

    emit_pstfd_fr_mem ¶
    Source

    emit_pstfd_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_pstfs ¶
    Source

    emit_pstfs :: emit_pstfs_fr_mem

    emit_pstfs_fr_mem ¶
    Source

    emit_pstfs_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_psth ¶
    Source

    emit_psth :: emit_psth_r_mem

    emit_psth_r_mem ¶
    Source

    emit_psth_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_pstw ¶
    Source

    emit_pstw :: emit_pstw_r_mem

    emit_pstw_r_mem ¶
    Source

    emit_pstw_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_pstxsd ¶
    Source

    emit_pstxsd :: emit_pstxsd_v_mem

    emit_pstxsd_v_mem ¶
    Source

    emit_pstxsd_v_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_pstxssp ¶
    Source

    emit_pstxssp :: emit_pstxssp_v_mem

    emit_pstxssp_v_mem ¶
    Source

    emit_pstxssp_v_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_pstxv ¶
    Source

    emit_pstxv :: emit_pstxv_vs_mem

    emit_pstxv_vs_mem ¶
    Source

    emit_pstxv_vs_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_psubi ¶
    Source

    emit_psubi :: emit_psubi_r_r_simm

    emit_psubi_r_r_simm ¶
    Source

    emit_psubi_r_r_simm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_ptesync ¶
    Source

    emit_ptesync :: emit_ptesync_none

    emit_ptesync_none ¶
    Source

    emit_ptesync_none :: proc(instructions: ^[dynamic]Instruction) {…}

    emit_rac ¶
    Source

    emit_rac :: emit_rac_r_r_r

    emit_rac_r_r_r ¶
    Source

    emit_rac_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_rfci ¶
    Source

    emit_rfci :: emit_rfci_r_r_imm

    emit_rfci_r_r_imm ¶
    Source

    emit_rfci_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_rfdi ¶
    Source

    emit_rfdi :: emit_rfdi_none

    emit_rfdi_none ¶
    Source

    emit_rfdi_none :: proc(instructions: ^[dynamic]Instruction) {…}

    emit_rfebb ¶
    Source

    emit_rfebb :: emit_rfebb_imm

    emit_rfebb_imm ¶
    Source

    emit_rfebb_imm :: proc(instructions: ^[dynamic]Instruction, imm: i64) {…}

    emit_rfgi ¶
    Source

    emit_rfgi :: emit_rfgi_r_r_imm

    emit_rfgi_r_r_imm ¶
    Source

    emit_rfgi_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_rfi ¶
    Source

    emit_rfi :: emit_rfi_none

    emit_rfi_none ¶
    Source

    emit_rfi_none :: proc(instructions: ^[dynamic]Instruction) {…}

    emit_rfid ¶
    Source

    emit_rfid :: emit_rfid_none

    emit_rfid_none ¶
    Source

    emit_rfid_none :: proc(instructions: ^[dynamic]Instruction) {…}

    emit_rfmci ¶
    Source

    emit_rfmci :: emit_rfmci_none

    emit_rfmci_none ¶
    Source

    emit_rfmci_none :: proc(instructions: ^[dynamic]Instruction) {…}

    emit_rfscv ¶
    Source

    emit_rfscv :: emit_rfscv_r_r_imm

    emit_rfscv_r_r_imm ¶
    Source

    emit_rfscv_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_rfsvc ¶
    Source

    emit_rfsvc :: emit_rfsvc_r_r_imm

    emit_rfsvc_r_r_imm ¶
    Source

    emit_rfsvc_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_rldcl ¶
    Source

    emit_rldcl :: emit_rldcl_r_r_r_imm

    emit_rldcl_dot ¶
    Source

    emit_rldcl_dot :: emit_rldcl_dot_r_r_r_imm

    emit_rldcl_dot_r_r_r_imm ¶
    Source

    emit_rldcl_dot_r_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, imm: i64) {…}

    emit_rldcl_r_r_r_imm ¶
    Source

    emit_rldcl_r_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, imm: i64) {…}

    emit_rldcr ¶
    Source

    emit_rldcr :: emit_rldcr_r_r_r_imm

    emit_rldcr_dot ¶
    Source

    emit_rldcr_dot :: emit_rldcr_dot_r_r_r_imm

    emit_rldcr_dot_r_r_r_imm ¶
    Source

    emit_rldcr_dot_r_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, imm: i64) {…}

    emit_rldcr_r_r_r_imm ¶
    Source

    emit_rldcr_r_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, imm: i64) {…}

    emit_rldic ¶
    Source

    emit_rldic :: emit_rldic_r_r_imm_imm

    emit_rldic_dot ¶
    Source

    emit_rldic_dot :: emit_rldic_dot_r_r_imm_imm

    emit_rldic_dot_r_r_imm_imm ¶
    Source

    emit_rldic_dot_r_r_imm_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64, imm2: i64) {…}

    emit_rldic_r_r_imm_imm ¶
    Source

    emit_rldic_r_r_imm_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64, imm2: i64) {…}

    emit_rldicl ¶
    Source

    emit_rldicl :: emit_rldicl_r_r_imm_imm

    emit_rldicl_dot ¶
    Source

    emit_rldicl_dot :: emit_rldicl_dot_r_r_imm_imm

    emit_rldicl_dot_r_r_imm_imm ¶
    Source

    emit_rldicl_dot_r_r_imm_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64, imm2: i64) {…}

    emit_rldicl_r_r_imm_imm ¶
    Source

    emit_rldicl_r_r_imm_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64, imm2: i64) {…}

    emit_rldicr ¶
    Source

    emit_rldicr :: emit_rldicr_r_r_imm_imm

    emit_rldicr_dot ¶
    Source

    emit_rldicr_dot :: emit_rldicr_dot_r_r_imm_imm

    emit_rldicr_dot_r_r_imm_imm ¶
    Source

    emit_rldicr_dot_r_r_imm_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64, imm2: i64) {…}

    emit_rldicr_r_r_imm_imm ¶
    Source

    emit_rldicr_r_r_imm_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64, imm2: i64) {…}

    emit_rldimi ¶
    Source

    emit_rldimi :: emit_rldimi_r_r_imm_imm

    emit_rldimi_dot ¶
    Source

    emit_rldimi_dot :: emit_rldimi_dot_r_r_imm_imm

    emit_rldimi_dot_r_r_imm_imm ¶
    Source

    emit_rldimi_dot_r_r_imm_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64, imm2: i64) {…}

    emit_rldimi_r_r_imm_imm ¶
    Source

    emit_rldimi_r_r_imm_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64, imm2: i64) {…}

    emit_rlwimi ¶
    Source

    emit_rlwimi :: emit_rlwimi_r_r_imm_imm

    emit_rlwimi_dot ¶
    Source

    emit_rlwimi_dot :: emit_rlwimi_dot_r_r_imm_imm

    emit_rlwimi_dot_r_r_imm_imm ¶
    Source

    emit_rlwimi_dot_r_r_imm_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64, imm2: i64) {…}

    emit_rlwimi_r_r_imm_imm ¶
    Source

    emit_rlwimi_r_r_imm_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64, imm2: i64) {…}

    emit_rlwinm ¶
    Source

    emit_rlwinm :: emit_rlwinm_r_r_imm_imm

    emit_rlwinm_dot ¶
    Source

    emit_rlwinm_dot :: emit_rlwinm_dot_r_r_imm_imm

    emit_rlwinm_dot_r_r_imm_imm ¶
    Source

    emit_rlwinm_dot_r_r_imm_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64, imm2: i64) {…}

    emit_rlwinm_r_r_imm_imm ¶
    Source

    emit_rlwinm_r_r_imm_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64, imm2: i64) {…}

    emit_rlwnm ¶
    Source

    emit_rlwnm :: emit_rlwnm_r_r_r_imm

    emit_rlwnm_dot ¶
    Source

    emit_rlwnm_dot :: emit_rlwnm_dot_r_r_r_imm

    emit_rlwnm_dot_r_r_r_imm ¶
    Source

    emit_rlwnm_dot_r_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, imm: i64) {…}

    emit_rlwnm_r_r_r_imm ¶
    Source

    emit_rlwnm_r_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register, imm: i64) {…}

    emit_rmieg ¶
    Source

    emit_rmieg :: emit_rmieg_r_r_r

    emit_rmieg_r_r_r ¶
    Source

    emit_rmieg_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_rotld ¶
    Source

    emit_rotld :: emit_rotld_r_r_r

    emit_rotld_dot ¶
    Source

    emit_rotld_dot :: emit_rotld_dot_r_r_r

    emit_rotld_dot_r_r_r ¶
    Source

    emit_rotld_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_rotld_r_r_r ¶
    Source

    emit_rotld_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_rotldi ¶
    Source

    emit_rotldi :: emit_rotldi_r_r_imm

    emit_rotldi_dot ¶
    Source

    emit_rotldi_dot :: emit_rotldi_dot_r_r_r

    emit_rotldi_dot_r_r_r ¶
    Source

    emit_rotldi_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_rotldi_r_r_imm ¶
    Source

    emit_rotldi_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_rotlw ¶
    Source

    emit_rotlw :: emit_rotlw_r_r_r

    emit_rotlw_r_r_r ¶
    Source

    emit_rotlw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_rotlwi ¶
    Source

    emit_rotlwi :: emit_rotlwi_r_r_imm

    emit_rotlwi_r_r_imm ¶
    Source

    emit_rotlwi_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_rotrdi ¶
    Source

    emit_rotrdi :: emit_rotrdi_r_r_imm

    emit_rotrdi_dot ¶
    Source

    emit_rotrdi_dot :: emit_rotrdi_dot_r_r_r

    emit_rotrdi_dot_r_r_r ¶
    Source

    emit_rotrdi_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_rotrdi_r_r_imm ¶
    Source

    emit_rotrdi_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_rotrw ¶
    Source

    emit_rotrw :: emit_rotrw_r_r_r

    emit_rotrw_r_r_r ¶
    Source

    emit_rotrw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_rrib ¶
    Source

    emit_rrib :: emit_rrib_r_r_r

    emit_rrib_dot ¶
    Source

    emit_rrib_dot :: emit_rrib_dot_r_r_r

    emit_rrib_dot_r_r_r ¶
    Source

    emit_rrib_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_rrib_r_r_r ¶
    Source

    emit_rrib_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_rvwinkle ¶
    Source

    emit_rvwinkle :: emit_rvwinkle_r_r_imm

    emit_rvwinkle_r_r_imm ¶
    Source

    emit_rvwinkle_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_sc ¶
    Source

    emit_sc :: emit_sc_imm

    emit_sc_hv ¶
    Source

    emit_sc_hv :: emit_sc_hv_imm

    emit_sc_hv_imm ¶
    Source

    emit_sc_hv_imm :: proc(instructions: ^[dynamic]Instruction, imm: i64) {…}

    emit_sc_imm ¶
    Source

    emit_sc_imm :: proc(instructions: ^[dynamic]Instruction, imm: i64) {…}

    emit_scv ¶
    Source

    emit_scv :: emit_scv_imm

    emit_scv_imm ¶
    Source

    emit_scv_imm :: proc(instructions: ^[dynamic]Instruction, imm: i64) {…}

    emit_setb ¶
    Source

    emit_setb :: emit_setb_r_crf

    emit_setb_r_crf ¶
    Source

    emit_setb_r_crf :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_setbc ¶
    Source

    emit_setbc :: emit_setbc_r_r_r

    emit_setbc_r_r_r ¶
    Source

    emit_setbc_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_setbcr ¶
    Source

    emit_setbcr :: emit_setbcr_r_r_r

    emit_setbcr_r_r_r ¶
    Source

    emit_setbcr_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_setnbc ¶
    Source

    emit_setnbc :: emit_setnbc_r_r_r

    emit_setnbc_r_r_r ¶
    Source

    emit_setnbc_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_setnbcr ¶
    Source

    emit_setnbcr :: emit_setnbcr_r_r_r

    emit_setnbcr_r_r_r ¶
    Source

    emit_setnbcr_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sf ¶
    Source

    emit_sf :: emit_sf_r_r_r

    emit_sf_dot ¶
    Source

    emit_sf_dot :: emit_sf_dot_r_r_r

    emit_sf_dot_r_r_r ¶
    Source

    emit_sf_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sf_r_r_r ¶
    Source

    emit_sf_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sfe ¶
    Source

    emit_sfe :: emit_sfe_r_r_r

    emit_sfe_dot ¶
    Source

    emit_sfe_dot :: emit_sfe_dot_r_r_r

    emit_sfe_dot_r_r_r ¶
    Source

    emit_sfe_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sfe_r_r_r ¶
    Source

    emit_sfe_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sfeo ¶
    Source

    emit_sfeo :: emit_sfeo_r_r_r

    emit_sfeo_dot ¶
    Source

    emit_sfeo_dot :: emit_sfeo_dot_r_r_r

    emit_sfeo_dot_r_r_r ¶
    Source

    emit_sfeo_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sfeo_r_r_r ¶
    Source

    emit_sfeo_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sfi ¶
    Source

    emit_sfi :: emit_sfi_r_r_imm

    emit_sfi_r_r_imm ¶
    Source

    emit_sfi_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_sfme ¶
    Source

    emit_sfme :: emit_sfme_r_r_r

    emit_sfme_dot ¶
    Source

    emit_sfme_dot :: emit_sfme_dot_r_r_r

    emit_sfme_dot_r_r_r ¶
    Source

    emit_sfme_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sfme_r_r_r ¶
    Source

    emit_sfme_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sfmeo ¶
    Source

    emit_sfmeo :: emit_sfmeo_r_r_r

    emit_sfmeo_dot ¶
    Source

    emit_sfmeo_dot :: emit_sfmeo_dot_r_r_r

    emit_sfmeo_dot_r_r_r ¶
    Source

    emit_sfmeo_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sfmeo_r_r_r ¶
    Source

    emit_sfmeo_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sfo ¶
    Source

    emit_sfo :: emit_sfo_r_r_r

    emit_sfo_dot ¶
    Source

    emit_sfo_dot :: emit_sfo_dot_r_r_r

    emit_sfo_dot_r_r_r ¶
    Source

    emit_sfo_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sfo_r_r_r ¶
    Source

    emit_sfo_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sfze ¶
    Source

    emit_sfze :: emit_sfze_r_r_r

    emit_sfze_dot ¶
    Source

    emit_sfze_dot :: emit_sfze_dot_r_r_r

    emit_sfze_dot_r_r_r ¶
    Source

    emit_sfze_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sfze_r_r_r ¶
    Source

    emit_sfze_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sfzeo ¶
    Source

    emit_sfzeo :: emit_sfzeo_r_r_r

    emit_sfzeo_dot ¶
    Source

    emit_sfzeo_dot :: emit_sfzeo_dot_r_r_r

    emit_sfzeo_dot_r_r_r ¶
    Source

    emit_sfzeo_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sfzeo_r_r_r ¶
    Source

    emit_sfzeo_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sl ¶
    Source

    emit_sl :: emit_sl_r_r_r

    emit_sl_dot ¶
    Source

    emit_sl_dot :: emit_sl_dot_r_r_r

    emit_sl_dot_r_r_r ¶
    Source

    emit_sl_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sl_r_r_r ¶
    Source

    emit_sl_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_slbfee_dot ¶
    Source

    emit_slbfee_dot :: emit_slbfee_dot_r_r_r

    emit_slbfee_dot_r_r_r ¶
    Source

    emit_slbfee_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_slbia ¶
    Source

    emit_slbia :: emit_slbia_none

    emit_slbia_none ¶
    Source

    emit_slbia_none :: proc(instructions: ^[dynamic]Instruction) {…}

    emit_slbiag ¶
    Source

    emit_slbiag :: emit_slbiag_r_r_r

    emit_slbiag_r_r_r ¶
    Source

    emit_slbiag_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_slbie ¶
    Source

    emit_slbie :: emit_slbie_r

    emit_slbie_r ¶
    Source

    emit_slbie_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_slbieg ¶
    Source

    emit_slbieg :: emit_slbieg_r_r

    emit_slbieg_r_r ¶
    Source

    emit_slbieg_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_slbmfee ¶
    Source

    emit_slbmfee :: emit_slbmfee_r_r

    emit_slbmfee_r_r ¶
    Source

    emit_slbmfee_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_slbmfev ¶
    Source

    emit_slbmfev :: emit_slbmfev_r_r

    emit_slbmfev_r_r ¶
    Source

    emit_slbmfev_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_slbmte ¶
    Source

    emit_slbmte :: emit_slbmte_r_r

    emit_slbmte_r_r ¶
    Source

    emit_slbmte_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_slbsync ¶
    Source

    emit_slbsync :: emit_slbsync_none

    emit_slbsync_none ¶
    Source

    emit_slbsync_none :: proc(instructions: ^[dynamic]Instruction) {…}

    emit_sld ¶
    Source

    emit_sld :: emit_sld_r_r_r

    emit_sld_dot ¶
    Source

    emit_sld_dot :: emit_sld_dot_r_r_r

    emit_sld_dot_r_r_r ¶
    Source

    emit_sld_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sld_r_r_r ¶
    Source

    emit_sld_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sldi ¶
    Source

    emit_sldi :: emit_sldi_r_r_imm

    emit_sldi_dot ¶
    Source

    emit_sldi_dot :: emit_sldi_dot_r_r_r

    emit_sldi_dot_r_r_r ¶
    Source

    emit_sldi_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sldi_r_r_imm ¶
    Source

    emit_sldi_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_sle ¶
    Source

    emit_sle :: emit_sle_r_r_r

    emit_sle_dot ¶
    Source

    emit_sle_dot :: emit_sle_dot_r_r_r

    emit_sle_dot_r_r_r ¶
    Source

    emit_sle_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sle_r_r_r ¶
    Source

    emit_sle_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sleep ¶
    Source

    emit_sleep :: emit_sleep_r_r_imm

    emit_sleep_r_r_imm ¶
    Source

    emit_sleep_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_sleq ¶
    Source

    emit_sleq :: emit_sleq_r_r_r

    emit_sleq_dot ¶
    Source

    emit_sleq_dot :: emit_sleq_dot_r_r_r

    emit_sleq_dot_r_r_r ¶
    Source

    emit_sleq_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sleq_r_r_r ¶
    Source

    emit_sleq_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sliq ¶
    Source

    emit_sliq :: emit_sliq_r_r_r

    emit_sliq_dot ¶
    Source

    emit_sliq_dot :: emit_sliq_dot_r_r_r

    emit_sliq_dot_r_r_r ¶
    Source

    emit_sliq_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sliq_r_r_r ¶
    Source

    emit_sliq_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_slliq ¶
    Source

    emit_slliq :: emit_slliq_r_r_r

    emit_slliq_dot ¶
    Source

    emit_slliq_dot :: emit_slliq_dot_r_r_r

    emit_slliq_dot_r_r_r ¶
    Source

    emit_slliq_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_slliq_r_r_r ¶
    Source

    emit_slliq_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sllq ¶
    Source

    emit_sllq :: emit_sllq_r_r_r

    emit_sllq_dot ¶
    Source

    emit_sllq_dot :: emit_sllq_dot_r_r_r

    emit_sllq_dot_r_r_r ¶
    Source

    emit_sllq_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sllq_r_r_r ¶
    Source

    emit_sllq_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_slq ¶
    Source

    emit_slq :: emit_slq_r_r_r

    emit_slq_dot ¶
    Source

    emit_slq_dot :: emit_slq_dot_r_r_r

    emit_slq_dot_r_r_r ¶
    Source

    emit_slq_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_slq_r_r_r ¶
    Source

    emit_slq_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_slw ¶
    Source

    emit_slw :: emit_slw_r_r_r

    emit_slw_dot ¶
    Source

    emit_slw_dot :: emit_slw_dot_r_r_r

    emit_slw_dot_r_r_r ¶
    Source

    emit_slw_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_slw_r_r_r ¶
    Source

    emit_slw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_slwi ¶
    Source

    emit_slwi :: emit_slwi_r_r_imm

    emit_slwi_r_r_imm ¶
    Source

    emit_slwi_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_sr_dot ¶
    Source

    emit_sr_dot :: emit_sr_dot_r_r_r

    emit_sr_dot_r_r_r ¶
    Source

    emit_sr_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sra ¶
    Source

    emit_sra :: emit_sra_r_r_r

    emit_sra_dot ¶
    Source

    emit_sra_dot :: emit_sra_dot_r_r_r

    emit_sra_dot_r_r_r ¶
    Source

    emit_sra_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sra_r_r_r ¶
    Source

    emit_sra_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_srad ¶
    Source

    emit_srad :: emit_srad_r_r_r

    emit_srad_dot ¶
    Source

    emit_srad_dot :: emit_srad_dot_r_r_r

    emit_srad_dot_r_r_r ¶
    Source

    emit_srad_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_srad_r_r_r ¶
    Source

    emit_srad_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sradi ¶
    Source

    emit_sradi :: emit_sradi_r_r_imm

    emit_sradi_dot ¶
    Source

    emit_sradi_dot :: emit_sradi_dot_r_r_imm

    emit_sradi_dot_r_r_imm ¶
    Source

    emit_sradi_dot_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_sradi_r_r_imm ¶
    Source

    emit_sradi_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_srai ¶
    Source

    emit_srai :: emit_srai_r_r_r

    emit_srai_dot ¶
    Source

    emit_srai_dot :: emit_srai_dot_r_r_r

    emit_srai_dot_r_r_r ¶
    Source

    emit_srai_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_srai_r_r_r ¶
    Source

    emit_srai_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sraiq ¶
    Source

    emit_sraiq :: emit_sraiq_r_r_r

    emit_sraiq_dot ¶
    Source

    emit_sraiq_dot :: emit_sraiq_dot_r_r_r

    emit_sraiq_dot_r_r_r ¶
    Source

    emit_sraiq_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sraiq_r_r_r ¶
    Source

    emit_sraiq_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sraq ¶
    Source

    emit_sraq :: emit_sraq_r_r_r

    emit_sraq_dot ¶
    Source

    emit_sraq_dot :: emit_sraq_dot_r_r_r

    emit_sraq_dot_r_r_r ¶
    Source

    emit_sraq_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sraq_r_r_r ¶
    Source

    emit_sraq_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sraw ¶
    Source

    emit_sraw :: emit_sraw_r_r_r

    emit_sraw_dot ¶
    Source

    emit_sraw_dot :: emit_sraw_dot_r_r_r

    emit_sraw_dot_r_r_r ¶
    Source

    emit_sraw_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sraw_r_r_r ¶
    Source

    emit_sraw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_srawi ¶
    Source

    emit_srawi :: emit_srawi_r_r_imm

    emit_srawi_dot ¶
    Source

    emit_srawi_dot :: emit_srawi_dot_r_r_imm

    emit_srawi_dot_r_r_imm ¶
    Source

    emit_srawi_dot_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_srawi_r_r_imm ¶
    Source

    emit_srawi_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_srd ¶
    Source

    emit_srd :: emit_srd_r_r_r

    emit_srd_dot ¶
    Source

    emit_srd_dot :: emit_srd_dot_r_r_r

    emit_srd_dot_r_r_r ¶
    Source

    emit_srd_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_srd_r_r_r ¶
    Source

    emit_srd_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_srdi ¶
    Source

    emit_srdi :: emit_srdi_r_r_imm

    emit_srdi_dot ¶
    Source

    emit_srdi_dot :: emit_srdi_dot_r_r_r

    emit_srdi_dot_r_r_r ¶
    Source

    emit_srdi_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_srdi_r_r_imm ¶
    Source

    emit_srdi_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_sre ¶
    Source

    emit_sre :: emit_sre_r_r_r

    emit_sre_dot ¶
    Source

    emit_sre_dot :: emit_sre_dot_r_r_r

    emit_sre_dot_r_r_r ¶
    Source

    emit_sre_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sre_r_r_r ¶
    Source

    emit_sre_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_srea ¶
    Source

    emit_srea :: emit_srea_r_r_r

    emit_srea_dot ¶
    Source

    emit_srea_dot :: emit_srea_dot_r_r_r

    emit_srea_dot_r_r_r ¶
    Source

    emit_srea_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_srea_r_r_r ¶
    Source

    emit_srea_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sreq ¶
    Source

    emit_sreq :: emit_sreq_r_r_r

    emit_sreq_dot ¶
    Source

    emit_sreq_dot :: emit_sreq_dot_r_r_r

    emit_sreq_dot_r_r_r ¶
    Source

    emit_sreq_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sreq_r_r_r ¶
    Source

    emit_sreq_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sriq ¶
    Source

    emit_sriq :: emit_sriq_r_r_r

    emit_sriq_dot ¶
    Source

    emit_sriq_dot :: emit_sriq_dot_r_r_r

    emit_sriq_dot_r_r_r ¶
    Source

    emit_sriq_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sriq_r_r_r ¶
    Source

    emit_sriq_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_srliq ¶
    Source

    emit_srliq :: emit_srliq_r_r_r

    emit_srliq_dot ¶
    Source

    emit_srliq_dot :: emit_srliq_dot_r_r_r

    emit_srliq_dot_r_r_r ¶
    Source

    emit_srliq_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_srliq_r_r_r ¶
    Source

    emit_srliq_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_srlq ¶
    Source

    emit_srlq :: emit_srlq_r_r_r

    emit_srlq_dot ¶
    Source

    emit_srlq_dot :: emit_srlq_dot_r_r_r

    emit_srlq_dot_r_r_r ¶
    Source

    emit_srlq_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_srlq_r_r_r ¶
    Source

    emit_srlq_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_srq ¶
    Source

    emit_srq :: emit_srq_r_r_r

    emit_srq_dot ¶
    Source

    emit_srq_dot :: emit_srq_dot_r_r_r

    emit_srq_dot_r_r_r ¶
    Source

    emit_srq_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_srq_r_r_r ¶
    Source

    emit_srq_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_srw ¶
    Source

    emit_srw :: emit_srw_r_r_r

    emit_srw_dot ¶
    Source

    emit_srw_dot :: emit_srw_dot_r_r_r

    emit_srw_dot_r_r_r ¶
    Source

    emit_srw_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_srw_r_r_r ¶
    Source

    emit_srw_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_srwi ¶
    Source

    emit_srwi :: emit_srwi_r_r_imm

    emit_srwi_r_r_imm ¶
    Source

    emit_srwi_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_st ¶
    Source

    emit_st :: emit_st_r_mem

    emit_st_r_mem ¶
    Source

    emit_st_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stb ¶
    Source

    emit_stb :: emit_stb_r_mem

    emit_stb_r_mem ¶
    Source

    emit_stb_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stbcix ¶
    Source

    emit_stbcix :: emit_stbcix_r_r_r

    emit_stbcix_r_r_r ¶
    Source

    emit_stbcix_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stbcx_dot ¶
    Source

    emit_stbcx_dot :: emit_stbcx_dot_r_mem

    emit_stbcx_dot_r_mem ¶
    Source

    emit_stbcx_dot_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stbdcbx ¶
    Source

    emit_stbdcbx :: emit_stbdcbx_r_r_r

    emit_stbdcbx_r_r_r ¶
    Source

    emit_stbdcbx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stbdx ¶
    Source

    emit_stbdx :: emit_stbdx_r_r_r

    emit_stbdx_r_r_r ¶
    Source

    emit_stbdx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stbepx ¶
    Source

    emit_stbepx :: emit_stbepx_r_r_r

    emit_stbepx_r_r_r ¶
    Source

    emit_stbepx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stbrx ¶
    Source

    emit_stbrx :: emit_stbrx_r_r_r

    emit_stbrx_r_r_r ¶
    Source

    emit_stbrx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stbu ¶
    Source

    emit_stbu :: emit_stbu_r_mem

    emit_stbu_r_mem ¶
    Source

    emit_stbu_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stbux ¶
    Source

    emit_stbux :: emit_stbux_r_mem

    emit_stbux_r_mem ¶
    Source

    emit_stbux_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stbx ¶
    Source

    emit_stbx :: emit_stbx_r_mem

    emit_stbx_r_mem ¶
    Source

    emit_stbx_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_std ¶
    Source

    emit_std :: emit_std_r_mem

    emit_std_r_mem ¶
    Source

    emit_std_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stdat ¶
    Source

    emit_stdat :: emit_stdat_r_r_imm

    emit_stdat_r_r_imm ¶
    Source

    emit_stdat_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_stdbrx ¶
    Source

    emit_stdbrx :: emit_stdbrx_r_mem

    emit_stdbrx_r_mem ¶
    Source

    emit_stdbrx_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stdcix ¶
    Source

    emit_stdcix :: emit_stdcix_r_r_r

    emit_stdcix_r_r_r ¶
    Source

    emit_stdcix_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stdcx_dot ¶
    Source

    emit_stdcx_dot :: emit_stdcx_dot_r_mem

    emit_stdcx_dot_r_mem ¶
    Source

    emit_stdcx_dot_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stddx ¶
    Source

    emit_stddx :: emit_stddx_r_r_r

    emit_stddx_r_r_r ¶
    Source

    emit_stddx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stdepx ¶
    Source

    emit_stdepx :: emit_stdepx_r_r_r

    emit_stdepx_r_r_r ¶
    Source

    emit_stdepx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stdu ¶
    Source

    emit_stdu :: emit_stdu_r_mem

    emit_stdu_r_mem ¶
    Source

    emit_stdu_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stdux ¶
    Source

    emit_stdux :: emit_stdux_r_mem

    emit_stdux_r_mem ¶
    Source

    emit_stdux_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stdx ¶
    Source

    emit_stdx :: emit_stdx_r_mem

    emit_stdx_r_mem ¶
    Source

    emit_stdx_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stfd ¶
    Source

    emit_stfd :: emit_stfd_fr_mem

    emit_stfd_fr_mem ¶
    Source

    emit_stfd_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stfddx ¶
    Source

    emit_stfddx :: emit_stfddx_r_r_r

    emit_stfddx_r_r_r ¶
    Source

    emit_stfddx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stfdepx ¶
    Source

    emit_stfdepx :: emit_stfdepx_fr_r_r

    emit_stfdepx_fr_r_r ¶
    Source

    emit_stfdepx_fr_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stfdp ¶
    Source

    emit_stfdp :: emit_stfdp_fr_mem

    emit_stfdp_fr_mem ¶
    Source

    emit_stfdp_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stfdpx ¶
    Source

    emit_stfdpx :: emit_stfdpx_fr_mem

    emit_stfdpx_fr_mem ¶
    Source

    emit_stfdpx_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stfdu ¶
    Source

    emit_stfdu :: emit_stfdu_fr_mem

    emit_stfdu_fr_mem ¶
    Source

    emit_stfdu_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stfdux ¶
    Source

    emit_stfdux :: emit_stfdux_fr_mem

    emit_stfdux_fr_mem ¶
    Source

    emit_stfdux_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stfdx ¶
    Source

    emit_stfdx :: emit_stfdx_fr_mem

    emit_stfdx_fr_mem ¶
    Source

    emit_stfdx_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stfiwx ¶
    Source

    emit_stfiwx :: emit_stfiwx_fr_mem

    emit_stfiwx_fr_mem ¶
    Source

    emit_stfiwx_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stfq ¶
    Source

    emit_stfq :: emit_stfq_fr_mem

    emit_stfq_fr_mem ¶
    Source

    emit_stfq_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stfqu ¶
    Source

    emit_stfqu :: emit_stfqu_fr_mem

    emit_stfqu_fr_mem ¶
    Source

    emit_stfqu_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stfqux ¶
    Source

    emit_stfqux :: emit_stfqux_r_r_r

    emit_stfqux_r_r_r ¶
    Source

    emit_stfqux_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stfqx ¶
    Source

    emit_stfqx :: emit_stfqx_r_r_r

    emit_stfqx_r_r_r ¶
    Source

    emit_stfqx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stfs ¶
    Source

    emit_stfs :: emit_stfs_fr_mem

    emit_stfs_fr_mem ¶
    Source

    emit_stfs_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stfsu ¶
    Source

    emit_stfsu :: emit_stfsu_fr_mem

    emit_stfsu_fr_mem ¶
    Source

    emit_stfsu_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stfsux ¶
    Source

    emit_stfsux :: emit_stfsux_fr_mem

    emit_stfsux_fr_mem ¶
    Source

    emit_stfsux_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stfsx ¶
    Source

    emit_stfsx :: emit_stfsx_fr_mem

    emit_stfsx_fr_mem ¶
    Source

    emit_stfsx_fr_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_sth ¶
    Source

    emit_sth :: emit_sth_r_mem

    emit_sth_r_mem ¶
    Source

    emit_sth_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_sthbrx ¶
    Source

    emit_sthbrx :: emit_sthbrx_r_mem

    emit_sthbrx_r_mem ¶
    Source

    emit_sthbrx_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_sthcix ¶
    Source

    emit_sthcix :: emit_sthcix_r_r_r

    emit_sthcix_r_r_r ¶
    Source

    emit_sthcix_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sthcx_dot ¶
    Source

    emit_sthcx_dot :: emit_sthcx_dot_r_mem

    emit_sthcx_dot_r_mem ¶
    Source

    emit_sthcx_dot_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_sthdcbx ¶
    Source

    emit_sthdcbx :: emit_sthdcbx_r_r_r

    emit_sthdcbx_r_r_r ¶
    Source

    emit_sthdcbx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sthdx ¶
    Source

    emit_sthdx :: emit_sthdx_r_r_r

    emit_sthdx_r_r_r ¶
    Source

    emit_sthdx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sthepx ¶
    Source

    emit_sthepx :: emit_sthepx_r_r_r

    emit_sthepx_r_r_r ¶
    Source

    emit_sthepx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sthu ¶
    Source

    emit_sthu :: emit_sthu_r_mem

    emit_sthu_r_mem ¶
    Source

    emit_sthu_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_sthux ¶
    Source

    emit_sthux :: emit_sthux_r_mem

    emit_sthux_r_mem ¶
    Source

    emit_sthux_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_sthx ¶
    Source

    emit_sthx :: emit_sthx_r_mem

    emit_sthx_r_mem ¶
    Source

    emit_sthx_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stm ¶
    Source

    emit_stm :: emit_stm_r_mem

    emit_stm_r_mem ¶
    Source

    emit_stm_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stmw ¶
    Source

    emit_stmw :: emit_stmw_r_mem

    emit_stmw_r_mem ¶
    Source

    emit_stmw_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stop ¶
    Source

    emit_stop :: emit_stop_none

    emit_stop_none ¶
    Source

    emit_stop_none :: proc(instructions: ^[dynamic]Instruction) {…}

    emit_stq ¶
    Source

    emit_stq :: emit_stq_r_mem

    emit_stq_r_mem ¶
    Source

    emit_stq_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stqcx_dot ¶
    Source

    emit_stqcx_dot :: emit_stqcx_dot_r_mem

    emit_stqcx_dot_r_mem ¶
    Source

    emit_stqcx_dot_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stsi ¶
    Source

    emit_stsi :: emit_stsi_r_r_r

    emit_stsi_r_r_r ¶
    Source

    emit_stsi_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stswi ¶
    Source

    emit_stswi :: emit_stswi_r_r_imm

    emit_stswi_r_r_imm ¶
    Source

    emit_stswi_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_stswx ¶
    Source

    emit_stswx :: emit_stswx_r_mem

    emit_stswx_r_mem ¶
    Source

    emit_stswx_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stsx ¶
    Source

    emit_stsx :: emit_stsx_r_r_r

    emit_stsx_r_r_r ¶
    Source

    emit_stsx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stu ¶
    Source

    emit_stu :: emit_stu_r_mem

    emit_stu_r_mem ¶
    Source

    emit_stu_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stux ¶
    Source

    emit_stux :: emit_stux_r_r_r

    emit_stux_r_r_r ¶
    Source

    emit_stux_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stvebx ¶
    Source

    emit_stvebx :: emit_stvebx_v_mem

    emit_stvebx128 ¶
    Source

    emit_stvebx128 :: emit_stvebx128_vr128_r_r

    emit_stvebx128_vr128_r_r ¶
    Source

    emit_stvebx128_vr128_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stvebx_v_mem ¶
    Source

    emit_stvebx_v_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stvehx ¶
    Source

    emit_stvehx :: emit_stvehx_v_mem

    emit_stvehx128 ¶
    Source

    emit_stvehx128 :: emit_stvehx128_vr128_r_r

    emit_stvehx128_vr128_r_r ¶
    Source

    emit_stvehx128_vr128_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stvehx_v_mem ¶
    Source

    emit_stvehx_v_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stvepx ¶
    Source

    emit_stvepx :: emit_stvepx_r_r_r

    emit_stvepx_r_r_r ¶
    Source

    emit_stvepx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stvepxl ¶
    Source

    emit_stvepxl :: emit_stvepxl_r_r_r

    emit_stvepxl_r_r_r ¶
    Source

    emit_stvepxl_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stvewx ¶
    Source

    emit_stvewx :: emit_stvewx_v_mem

    emit_stvewx128 ¶
    Source

    emit_stvewx128 :: emit_stvewx128_vr128_r_r

    emit_stvewx128_vr128_r_r ¶
    Source

    emit_stvewx128_vr128_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stvewx_v_mem ¶
    Source

    emit_stvewx_v_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stvexbx ¶
    Source

    emit_stvexbx :: emit_stvexbx_r_r_r

    emit_stvexbx_r_r_r ¶
    Source

    emit_stvexbx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stvexhx ¶
    Source

    emit_stvexhx :: emit_stvexhx_r_r_r

    emit_stvexhx_r_r_r ¶
    Source

    emit_stvexhx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stvexwx ¶
    Source

    emit_stvexwx :: emit_stvexwx_r_r_r

    emit_stvexwx_r_r_r ¶
    Source

    emit_stvexwx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stvflx ¶
    Source

    emit_stvflx :: emit_stvflx_r_r_r

    emit_stvflx_r_r_r ¶
    Source

    emit_stvflx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stvflxl ¶
    Source

    emit_stvflxl :: emit_stvflxl_r_r_r

    emit_stvflxl_r_r_r ¶
    Source

    emit_stvflxl_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stvfrx ¶
    Source

    emit_stvfrx :: emit_stvfrx_r_r_r

    emit_stvfrx_r_r_r ¶
    Source

    emit_stvfrx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stvfrxl ¶
    Source

    emit_stvfrxl :: emit_stvfrxl_r_r_r

    emit_stvfrxl_r_r_r ¶
    Source

    emit_stvfrxl_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stvlx ¶
    Source

    emit_stvlx :: emit_stvlx_r_r_r

    emit_stvlx128 ¶
    Source

    emit_stvlx128 :: emit_stvlx128_vr128_r_r

    emit_stvlx128_vr128_r_r ¶
    Source

    emit_stvlx128_vr128_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stvlx_r_r_r ¶
    Source

    emit_stvlx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stvlxl ¶
    Source

    emit_stvlxl :: emit_stvlxl_r_r_r

    emit_stvlxl128 ¶
    Source

    emit_stvlxl128 :: emit_stvlxl128_vr128_r_r

    emit_stvlxl128_vr128_r_r ¶
    Source

    emit_stvlxl128_vr128_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stvlxl_r_r_r ¶
    Source

    emit_stvlxl_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stvrx ¶
    Source

    emit_stvrx :: emit_stvrx_r_r_r

    emit_stvrx128 ¶
    Source

    emit_stvrx128 :: emit_stvrx128_vr128_r_r

    emit_stvrx128_vr128_r_r ¶
    Source

    emit_stvrx128_vr128_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stvrx_r_r_r ¶
    Source

    emit_stvrx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stvrxl ¶
    Source

    emit_stvrxl :: emit_stvrxl_r_r_r

    emit_stvrxl128 ¶
    Source

    emit_stvrxl128 :: emit_stvrxl128_vr128_r_r

    emit_stvrxl128_vr128_r_r ¶
    Source

    emit_stvrxl128_vr128_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stvrxl_r_r_r ¶
    Source

    emit_stvrxl_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stvswx ¶
    Source

    emit_stvswx :: emit_stvswx_r_r_r

    emit_stvswx_r_r_r ¶
    Source

    emit_stvswx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stvswxl ¶
    Source

    emit_stvswxl :: emit_stvswxl_r_r_r

    emit_stvswxl_r_r_r ¶
    Source

    emit_stvswxl_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stvx ¶
    Source

    emit_stvx :: emit_stvx_v_mem

    emit_stvx128 ¶
    Source

    emit_stvx128 :: emit_stvx128_vr128_r_r

    emit_stvx128_vr128_r_r ¶
    Source

    emit_stvx128_vr128_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stvx_v_mem ¶
    Source

    emit_stvx_v_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stvxl ¶
    Source

    emit_stvxl :: emit_stvxl_v_mem

    emit_stvxl128 ¶
    Source

    emit_stvxl128 :: emit_stvxl128_vr128_r_r

    emit_stvxl128_vr128_r_r ¶
    Source

    emit_stvxl128_vr128_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stvxl_v_mem ¶
    Source

    emit_stvxl_v_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stw ¶
    Source

    emit_stw :: emit_stw_r_mem

    emit_stw_r_mem ¶
    Source

    emit_stw_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stwat ¶
    Source

    emit_stwat :: emit_stwat_r_r_imm

    emit_stwat_r_r_imm ¶
    Source

    emit_stwat_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_stwbrx ¶
    Source

    emit_stwbrx :: emit_stwbrx_r_mem

    emit_stwbrx_r_mem ¶
    Source

    emit_stwbrx_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stwcix ¶
    Source

    emit_stwcix :: emit_stwcix_r_r_r

    emit_stwcix_r_r_r ¶
    Source

    emit_stwcix_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stwcx_dot ¶
    Source

    emit_stwcx_dot :: emit_stwcx_dot_r_mem

    emit_stwcx_dot_r_mem ¶
    Source

    emit_stwcx_dot_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stwdcbx ¶
    Source

    emit_stwdcbx :: emit_stwdcbx_r_r_r

    emit_stwdcbx_r_r_r ¶
    Source

    emit_stwdcbx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stwdx ¶
    Source

    emit_stwdx :: emit_stwdx_r_r_r

    emit_stwdx_r_r_r ¶
    Source

    emit_stwdx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stwepx ¶
    Source

    emit_stwepx :: emit_stwepx_r_r_r

    emit_stwepx_r_r_r ¶
    Source

    emit_stwepx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stwu ¶
    Source

    emit_stwu :: emit_stwu_r_mem

    emit_stwu_r_mem ¶
    Source

    emit_stwu_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stwux ¶
    Source

    emit_stwux :: emit_stwux_r_mem

    emit_stwux_r_mem ¶
    Source

    emit_stwux_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stwx ¶
    Source

    emit_stwx :: emit_stwx_r_mem

    emit_stwx_r_mem ¶
    Source

    emit_stwx_r_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stx ¶
    Source

    emit_stx :: emit_stx_r_r_r

    emit_stx_r_r_r ¶
    Source

    emit_stx_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stxsd ¶
    Source

    emit_stxsd :: emit_stxsd_v_mem

    emit_stxsd_v_mem ¶
    Source

    emit_stxsd_v_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stxsdx ¶
    Source

    emit_stxsdx :: emit_stxsdx_vs_mem

    emit_stxsdx_vs_mem ¶
    Source

    emit_stxsdx_vs_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stxsibx ¶
    Source

    emit_stxsibx :: emit_stxsibx_vs_mem

    emit_stxsibx_vs_mem ¶
    Source

    emit_stxsibx_vs_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stxsihx ¶
    Source

    emit_stxsihx :: emit_stxsihx_vs_mem

    emit_stxsihx_vs_mem ¶
    Source

    emit_stxsihx_vs_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stxsiwx ¶
    Source

    emit_stxsiwx :: emit_stxsiwx_vs_mem

    emit_stxsiwx_vs_mem ¶
    Source

    emit_stxsiwx_vs_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stxssp ¶
    Source

    emit_stxssp :: emit_stxssp_v_mem

    emit_stxssp_v_mem ¶
    Source

    emit_stxssp_v_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stxsspx ¶
    Source

    emit_stxsspx :: emit_stxsspx_vs_mem

    emit_stxsspx_vs_mem ¶
    Source

    emit_stxsspx_vs_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stxv ¶
    Source

    emit_stxv :: emit_stxv_vs_mem

    emit_stxv_vs_mem ¶
    Source

    emit_stxv_vs_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stxvb16x ¶
    Source

    emit_stxvb16x :: emit_stxvb16x_vs_mem

    emit_stxvb16x_vs_mem ¶
    Source

    emit_stxvb16x_vs_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stxvd2x ¶
    Source

    emit_stxvd2x :: emit_stxvd2x_vs_mem

    emit_stxvd2x_vs_mem ¶
    Source

    emit_stxvd2x_vs_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stxvh8x ¶
    Source

    emit_stxvh8x :: emit_stxvh8x_vs_mem

    emit_stxvh8x_vs_mem ¶
    Source

    emit_stxvh8x_vs_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stxvl ¶
    Source

    emit_stxvl :: emit_stxvl_vs_r_r

    emit_stxvl_vs_r_r ¶
    Source

    emit_stxvl_vs_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stxvll ¶
    Source

    emit_stxvll :: emit_stxvll_vs_r_r

    emit_stxvll_vs_r_r ¶
    Source

    emit_stxvll_vs_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stxvp ¶
    Source

    emit_stxvp :: emit_stxvp_vs_mem

    emit_stxvp_vs_mem ¶
    Source

    emit_stxvp_vs_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stxvprl ¶
    Source

    emit_stxvprl :: emit_stxvprl_vs_r_r

    emit_stxvprl_vs_r_r ¶
    Source

    emit_stxvprl_vs_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stxvprll ¶
    Source

    emit_stxvprll :: emit_stxvprll_vs_r_r

    emit_stxvprll_vs_r_r ¶
    Source

    emit_stxvprll_vs_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stxvpx ¶
    Source

    emit_stxvpx :: emit_stxvpx_vs_r_r

    emit_stxvpx_vs_r_r ¶
    Source

    emit_stxvpx_vs_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stxvrbx ¶
    Source

    emit_stxvrbx :: emit_stxvrbx_vs_r_r

    emit_stxvrbx_vs_r_r ¶
    Source

    emit_stxvrbx_vs_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stxvrdx ¶
    Source

    emit_stxvrdx :: emit_stxvrdx_vs_r_r

    emit_stxvrdx_vs_r_r ¶
    Source

    emit_stxvrdx_vs_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stxvrhx ¶
    Source

    emit_stxvrhx :: emit_stxvrhx_vs_r_r

    emit_stxvrhx_vs_r_r ¶
    Source

    emit_stxvrhx_vs_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stxvrl ¶
    Source

    emit_stxvrl :: emit_stxvrl_vs_r_r

    emit_stxvrl_vs_r_r ¶
    Source

    emit_stxvrl_vs_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stxvrll ¶
    Source

    emit_stxvrll :: emit_stxvrll_vs_r_r

    emit_stxvrll_vs_r_r ¶
    Source

    emit_stxvrll_vs_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stxvrwx ¶
    Source

    emit_stxvrwx :: emit_stxvrwx_vs_r_r

    emit_stxvrwx_vs_r_r ¶
    Source

    emit_stxvrwx_vs_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_stxvw4x ¶
    Source

    emit_stxvw4x :: emit_stxvw4x_vs_mem

    emit_stxvw4x_vs_mem ¶
    Source

    emit_stxvw4x_vs_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_stxvx ¶
    Source

    emit_stxvx :: emit_stxvx_vs_mem

    emit_stxvx_vs_mem ¶
    Source

    emit_stxvx_vs_mem :: proc(instructions: ^[dynamic]Instruction, dst: Register, addr: Memory) {…}

    emit_sub ¶
    Source

    emit_sub :: emit_sub_r_r_r

    emit_sub_dot ¶
    Source

    emit_sub_dot :: emit_sub_dot_r_r_r

    emit_sub_dot_r_r_r ¶
    Source

    emit_sub_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sub_o ¶
    Source

    emit_sub_o :: emit_sub_o_r_r_r

    emit_sub_o_dot ¶
    Source

    emit_sub_o_dot :: emit_sub_o_dot_r_r_r

    emit_sub_o_dot_r_r_r ¶
    Source

    emit_sub_o_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sub_o_r_r_r ¶
    Source

    emit_sub_o_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sub_r_r_r ¶
    Source

    emit_sub_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_subc ¶
    Source

    emit_subc :: emit_subc_r_r_r

    emit_subc_dot ¶
    Source

    emit_subc_dot :: emit_subc_dot_r_r_r

    emit_subc_dot_r_r_r ¶
    Source

    emit_subc_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_subc_o ¶
    Source

    emit_subc_o :: emit_subc_o_r_r_r

    emit_subc_o_dot ¶
    Source

    emit_subc_o_dot :: emit_subc_o_dot_r_r_r

    emit_subc_o_dot_r_r_r ¶
    Source

    emit_subc_o_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_subc_o_r_r_r ¶
    Source

    emit_subc_o_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_subc_r_r_r ¶
    Source

    emit_subc_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_subco ¶
    Source

    emit_subco :: emit_subco_r_r_r

    emit_subco_dot ¶
    Source

    emit_subco_dot :: emit_subco_dot_r_r_r

    emit_subco_dot_r_r_r ¶
    Source

    emit_subco_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_subco_r_r_r ¶
    Source

    emit_subco_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_subdus ¶
    Source

    emit_subdus :: emit_subdus_r_r_r

    emit_subdus_dot ¶
    Source

    emit_subdus_dot :: emit_subdus_dot_r_r_r

    emit_subdus_dot_r_r_r ¶
    Source

    emit_subdus_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_subdus_r_r_r ¶
    Source

    emit_subdus_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_subf ¶
    Source

    emit_subf :: emit_subf_r_r_r

    emit_subf_dot ¶
    Source

    emit_subf_dot :: emit_subf_dot_r_r_r

    emit_subf_dot_r_r_r ¶
    Source

    emit_subf_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_subf_o ¶
    Source

    emit_subf_o :: emit_subf_o_r_r_r

    emit_subf_o_dot ¶
    Source

    emit_subf_o_dot :: emit_subf_o_dot_r_r_r

    emit_subf_o_dot_r_r_r ¶
    Source

    emit_subf_o_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_subf_o_r_r_r ¶
    Source

    emit_subf_o_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_subf_r_r_r ¶
    Source

    emit_subf_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_subfc ¶
    Source

    emit_subfc :: emit_subfc_r_r_r

    emit_subfc_dot ¶
    Source

    emit_subfc_dot :: emit_subfc_dot_r_r_r

    emit_subfc_dot_r_r_r ¶
    Source

    emit_subfc_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_subfc_o ¶
    Source

    emit_subfc_o :: emit_subfc_o_r_r_r

    emit_subfc_o_dot ¶
    Source

    emit_subfc_o_dot :: emit_subfc_o_dot_r_r_r

    emit_subfc_o_dot_r_r_r ¶
    Source

    emit_subfc_o_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_subfc_o_r_r_r ¶
    Source

    emit_subfc_o_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_subfc_r_r_r ¶
    Source

    emit_subfc_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_subfco ¶
    Source

    emit_subfco :: emit_subfco_r_r_r

    emit_subfco_dot ¶
    Source

    emit_subfco_dot :: emit_subfco_dot_r_r_r

    emit_subfco_dot_r_r_r ¶
    Source

    emit_subfco_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_subfco_r_r_r ¶
    Source

    emit_subfco_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_subfe ¶
    Source

    emit_subfe :: emit_subfe_r_r_r

    emit_subfe_dot ¶
    Source

    emit_subfe_dot :: emit_subfe_dot_r_r_r

    emit_subfe_dot_r_r_r ¶
    Source

    emit_subfe_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_subfe_o ¶
    Source

    emit_subfe_o :: emit_subfe_o_r_r_r

    emit_subfe_o_dot ¶
    Source

    emit_subfe_o_dot :: emit_subfe_o_dot_r_r_r

    emit_subfe_o_dot_r_r_r ¶
    Source

    emit_subfe_o_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_subfe_o_r_r_r ¶
    Source

    emit_subfe_o_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_subfe_r_r_r ¶
    Source

    emit_subfe_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_subfeo ¶
    Source

    emit_subfeo :: emit_subfeo_r_r_r

    emit_subfeo_dot ¶
    Source

    emit_subfeo_dot :: emit_subfeo_dot_r_r_r

    emit_subfeo_dot_r_r_r ¶
    Source

    emit_subfeo_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_subfeo_r_r_r ¶
    Source

    emit_subfeo_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_subfic ¶
    Source

    emit_subfic :: emit_subfic_r_r_simm

    emit_subfic_r_r_simm ¶
    Source

    emit_subfic_r_r_simm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_subfme ¶
    Source

    emit_subfme :: emit_subfme_r_r

    emit_subfme_dot ¶
    Source

    emit_subfme_dot :: emit_subfme_dot_r_r

    emit_subfme_dot_r_r ¶
    Source

    emit_subfme_dot_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_subfme_o ¶
    Source

    emit_subfme_o :: emit_subfme_o_r_r

    emit_subfme_o_dot ¶
    Source

    emit_subfme_o_dot :: emit_subfme_o_dot_r_r

    emit_subfme_o_dot_r_r ¶
    Source

    emit_subfme_o_dot_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_subfme_o_r_r ¶
    Source

    emit_subfme_o_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_subfme_r_r ¶
    Source

    emit_subfme_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_subfmeo ¶
    Source

    emit_subfmeo :: emit_subfmeo_r_r_r

    emit_subfmeo_dot ¶
    Source

    emit_subfmeo_dot :: emit_subfmeo_dot_r_r_r

    emit_subfmeo_dot_r_r_r ¶
    Source

    emit_subfmeo_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_subfmeo_r_r_r ¶
    Source

    emit_subfmeo_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_subfo ¶
    Source

    emit_subfo :: emit_subfo_r_r_r

    emit_subfo_dot ¶
    Source

    emit_subfo_dot :: emit_subfo_dot_r_r_r

    emit_subfo_dot_r_r_r ¶
    Source

    emit_subfo_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_subfo_r_r_r ¶
    Source

    emit_subfo_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_subfus ¶
    Source

    emit_subfus :: emit_subfus_r_r_r

    emit_subfus_dot ¶
    Source

    emit_subfus_dot :: emit_subfus_dot_r_r_r

    emit_subfus_dot_r_r_r ¶
    Source

    emit_subfus_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_subfus_r_r_r ¶
    Source

    emit_subfus_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_subfze ¶
    Source

    emit_subfze :: emit_subfze_r_r

    emit_subfze_dot ¶
    Source

    emit_subfze_dot :: emit_subfze_dot_r_r

    emit_subfze_dot_r_r ¶
    Source

    emit_subfze_dot_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_subfze_o ¶
    Source

    emit_subfze_o :: emit_subfze_o_r_r

    emit_subfze_o_dot ¶
    Source

    emit_subfze_o_dot :: emit_subfze_o_dot_r_r

    emit_subfze_o_dot_r_r ¶
    Source

    emit_subfze_o_dot_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_subfze_o_r_r ¶
    Source

    emit_subfze_o_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_subfze_r_r ¶
    Source

    emit_subfze_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_subfzeo ¶
    Source

    emit_subfzeo :: emit_subfzeo_r_r_r

    emit_subfzeo_dot ¶
    Source

    emit_subfzeo_dot :: emit_subfzeo_dot_r_r_r

    emit_subfzeo_dot_r_r_r ¶
    Source

    emit_subfzeo_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_subfzeo_r_r_r ¶
    Source

    emit_subfzeo_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_subi ¶
    Source

    emit_subi :: emit_subi_r_r_imm

    emit_subi_r_r_imm ¶
    Source

    emit_subi_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_subic ¶
    Source

    emit_subic :: emit_subic_r_r_imm

    emit_subic_dot ¶
    Source

    emit_subic_dot :: emit_subic_dot_r_r_imm

    emit_subic_dot_r_r_imm ¶
    Source

    emit_subic_dot_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_subic_r_r_imm ¶
    Source

    emit_subic_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_subis ¶
    Source

    emit_subis :: emit_subis_r_r_imm

    emit_subis_r_r_imm ¶
    Source

    emit_subis_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_subo ¶
    Source

    emit_subo :: emit_subo_r_r_r

    emit_subo_dot ¶
    Source

    emit_subo_dot :: emit_subo_dot_r_r_r

    emit_subo_dot_r_r_r ¶
    Source

    emit_subo_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_subo_r_r_r ¶
    Source

    emit_subo_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_subwus ¶
    Source

    emit_subwus :: emit_subwus_r_r_r

    emit_subwus_dot ¶
    Source

    emit_subwus_dot :: emit_subwus_dot_r_r_r

    emit_subwus_dot_r_r_r ¶
    Source

    emit_subwus_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_subwus_r_r_r ¶
    Source

    emit_subwus_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_sync ¶
    Source

    emit_sync :: emit_sync_none

    emit_sync_none ¶
    Source

    emit_sync_none :: proc(instructions: ^[dynamic]Instruction) {…}

    emit_t ¶
    Source

    emit_t :: emit_t_r_r_r

    emit_t_r_r_r ¶
    Source

    emit_t_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_tabort_dot ¶
    Source

    emit_tabort_dot :: emit_tabort_dot_r

    emit_tabort_dot_r ¶
    Source

    emit_tabort_dot_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_tabortdc_dot ¶
    Source

    emit_tabortdc_dot :: emit_tabortdc_dot_imm_r_r

    emit_tabortdc_dot_imm_r_r ¶
    Source

    emit_tabortdc_dot_imm_r_r :: proc(instructions: ^[dynamic]Instruction, imm: i64, dst: Register, src: Register) {…}

    emit_tabortdci_dot ¶
    Source

    emit_tabortdci_dot :: emit_tabortdci_dot_imm_r_imm

    emit_tabortdci_dot_imm_r_imm ¶
    Source

    emit_tabortdci_dot_imm_r_imm :: proc(instructions: ^[dynamic]Instruction, imm: i64, dst: Register, imm2: i64) {…}

    emit_tabortwc_dot ¶
    Source

    emit_tabortwc_dot :: emit_tabortwc_dot_imm_r_r

    emit_tabortwc_dot_imm_r_r ¶
    Source

    emit_tabortwc_dot_imm_r_r :: proc(instructions: ^[dynamic]Instruction, imm: i64, dst: Register, src: Register) {…}

    emit_tabortwci_dot ¶
    Source

    emit_tabortwci_dot :: emit_tabortwci_dot_imm_r_imm

    emit_tabortwci_dot_imm_r_imm ¶
    Source

    emit_tabortwci_dot_imm_r_imm :: proc(instructions: ^[dynamic]Instruction, imm: i64, dst: Register, imm2: i64) {…}

    emit_tbegin_dot ¶
    Source

    emit_tbegin_dot :: emit_tbegin_dot_imm

    emit_tbegin_dot_imm ¶
    Source

    emit_tbegin_dot_imm :: proc(instructions: ^[dynamic]Instruction, imm: i64) {…}

    emit_tcheck ¶
    Source

    emit_tcheck :: emit_tcheck_crf

    emit_tcheck_crf ¶
    Source

    emit_tcheck_crf :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_td ¶
    Source

    emit_td :: emit_td_imm_r_r

    emit_td_imm_r_r ¶
    Source

    emit_td_imm_r_r :: proc(instructions: ^[dynamic]Instruction, imm: i64, dst: Register, src: Register) {…}

    emit_tdeq ¶
    Source

    emit_tdeq :: emit_tdeq_r_r

    emit_tdeq_r_r ¶
    Source

    emit_tdeq_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_tdeqi ¶
    Source

    emit_tdeqi :: emit_tdeqi_r_simm

    emit_tdeqi_r_simm ¶
    Source

    emit_tdeqi_r_simm :: proc(instructions: ^[dynamic]Instruction, dst: Register, imm: i64) {…}

    emit_tdgt ¶
    Source

    emit_tdgt :: emit_tdgt_r_r

    emit_tdgt_r_r ¶
    Source

    emit_tdgt_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_tdgti ¶
    Source

    emit_tdgti :: emit_tdgti_r_simm

    emit_tdgti_r_simm ¶
    Source

    emit_tdgti_r_simm :: proc(instructions: ^[dynamic]Instruction, dst: Register, imm: i64) {…}

    emit_tdi ¶
    Source

    emit_tdi :: emit_tdi_imm_r_simm

    emit_tdi_imm_r_simm ¶
    Source

    emit_tdi_imm_r_simm :: proc(instructions: ^[dynamic]Instruction, imm: i64, dst: Register, imm2: i64) {…}

    emit_tdlt ¶
    Source

    emit_tdlt :: emit_tdlt_r_r

    emit_tdlt_r_r ¶
    Source

    emit_tdlt_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_tdlti ¶
    Source

    emit_tdlti :: emit_tdlti_r_simm

    emit_tdlti_r_simm ¶
    Source

    emit_tdlti_r_simm :: proc(instructions: ^[dynamic]Instruction, dst: Register, imm: i64) {…}

    emit_tdne ¶
    Source

    emit_tdne :: emit_tdne_r_r

    emit_tdne_r_r ¶
    Source

    emit_tdne_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_tdnei ¶
    Source

    emit_tdnei :: emit_tdnei_r_simm

    emit_tdnei_r_simm ¶
    Source

    emit_tdnei_r_simm :: proc(instructions: ^[dynamic]Instruction, dst: Register, imm: i64) {…}

    emit_tdui ¶
    Source

    emit_tdui :: emit_tdui_r_simm

    emit_tdui_r_simm ¶
    Source

    emit_tdui_r_simm :: proc(instructions: ^[dynamic]Instruction, dst: Register, imm: i64) {…}

    emit_tend_dot ¶
    Source

    emit_tend_dot :: emit_tend_dot_none

    emit_tend_dot_none ¶
    Source

    emit_tend_dot_none :: proc(instructions: ^[dynamic]Instruction) {…}

    emit_ti ¶
    Source

    emit_ti :: emit_ti_r_r_imm

    emit_ti_r_r_imm ¶
    Source

    emit_ti_r_r_imm :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, imm: i64) {…}

    emit_tlbi ¶
    Source

    emit_tlbi :: emit_tlbi_r_r_r

    emit_tlbi_r_r_r ¶
    Source

    emit_tlbi_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_tlbia ¶
    Source

    emit_tlbia :: emit_tlbia_r_r_r

    emit_tlbia_r_r_r ¶
    Source

    emit_tlbia_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_tlbie ¶
    Source

    emit_tlbie :: emit_tlbie_r_r

    emit_tlbie_r_r ¶
    Source

    emit_tlbie_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_tlbiel ¶
    Source

    emit_tlbiel :: emit_tlbiel_r

    emit_tlbiel_r ¶
    Source

    emit_tlbiel_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_tlbilx ¶
    Source

    emit_tlbilx :: emit_tlbilx_imm_r_r

    emit_tlbilx_imm_r_r ¶
    Source

    emit_tlbilx_imm_r_r :: proc(instructions: ^[dynamic]Instruction, imm: i64, dst: Register, src: Register) {…}

    emit_tlbilxva ¶
    Source

    emit_tlbilxva :: emit_tlbilxva_r_r

    emit_tlbilxva_r_r ¶
    Source

    emit_tlbilxva_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_tlbivax ¶
    Source

    emit_tlbivax :: emit_tlbivax_r_r

    emit_tlbivax_r_r ¶
    Source

    emit_tlbivax_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register) {…}

    emit_tlbld ¶
    Source

    emit_tlbld :: emit_tlbld_r

    emit_tlbld_r ¶
    Source

    emit_tlbld_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_tlbli ¶
    Source

    emit_tlbli :: emit_tlbli_r

    emit_tlbli_r ¶
    Source

    emit_tlbli_r :: proc(instructions: ^[dynamic]Instruction, dst: Register) {…}

    emit_tlbre ¶
    Source

    emit_tlbre :: emit_tlbre_none

    emit_tlbre_none ¶
    Source

    emit_tlbre_none :: proc(instructions: ^[dynamic]Instruction) {…}

    emit_tlbsrx_dot ¶
    Source

    emit_tlbsrx_dot :: emit_tlbsrx_dot_r_r_r

    emit_tlbsrx_dot_r_r_r ¶
    Source

    emit_tlbsrx_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_tlbsx ¶
    Source

    emit_tlbsx :: emit_tlbsx_r_r

    emit_tlbsx_dot ¶
    Source

    emit_tlbsx_dot :: emit_tlbsx_dot_r_r_r

    emit_tlbsx_dot_r_r_r ¶
    Source

    emit_tlbsx_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, dst: Register, src: Register, src2: Register) {…}

    emit_tlbsx_r_r ¶
    Source

    emit_tlbsx_r_r :: proc(instructions: ^[dynamic]