package core:rexcode/isa/ppc_vle
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 (935)
    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
	mask:     u32,
	// 4
	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
	mask:     u32,
	// 4
	feature:  Feature,
	// 1
	mode:     Mode,
	// 1
	flags:    Encoding_Flags,
}

    Encoding_Flags ¶
    Source

    Encoding_Flags :: distinct bit_field u8 {
	short:       bool | 1,
	cond_branch: bool | 1,
	writes_lr:   bool | 1,
	sets_cr0:    bool | 1,
	_:           u8 | 4,
}

    Error ¶
    Source

    Error :: rexcode_isa.Error

    Error_Code ¶
    Source

    Error_Code :: rexcode_isa.Error_Code

    Feature ¶
    Source

    Feature :: enum u8 {
	BASE, 
	LSP, 
	SPE, 
}

    Instruction ¶
    Source

    Instruction :: struct #packed {
	ops:           [4]Operand `fmt:"v,operand_count"`,
	mnemonic:      Mnemonic,
	operand_count: u8,
	flags:         Instruction_Flags,
	mode:          Mode,
	length:        u8,
	// 2 or 4
	form_id:       u16,
}
    Related Procedures With Returns

    Instruction_Flags ¶
    Source

    Instruction_Flags :: distinct bit_field u8 {
	sets_cr0: bool | 1,
	has_oe:   bool | 1,
	lk:       bool | 1,
	aa:       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,
	index: Register,
	disp:  i64,
}
    Related Procedures With Parameters
    Related Procedures With Returns

    Mnemonic ¶
    Source

    Mnemonic :: enum u16 {
	INVALID      = 0, 
	// ---- 16-bit short (se_*) ----
	SE_ILLEGAL, 
	SE_ISYNC, 
	SE_SC, 
	SE_BLR, 
	SE_BLRL, 
	SE_BCTR, 
	SE_BCTRL, 
	SE_RFI, 
	SE_RFCI, 
	SE_RFDI, 
	SE_RFMCI, 
	SE_RFGI, 
	SE_NOT, 
	SE_NEG, 
	SE_MFLR, 
	SE_MTLR, 
	SE_MFCTR, 
	SE_MTCTR, 
	SE_EXTZB, 
	SE_EXTSB, 
	SE_EXTZH, 
	SE_EXTSH, 
	SE_MR, 
	SE_MTAR, 
	SE_MFAR, 
	SE_ADD, 
	SE_MULLW, 
	SE_SUB, 
	SE_SUBF, 
	SE_CMP, 
	SE_CMPL, 
	SE_CMPH, 
	SE_CMPHL, 
	SE_SRW, 
	SE_SRAW, 
	SE_SLW, 
	SE_OR, 
	SE_ANDC, 
	SE_AND, 
	SE_AND_DOT, 
	SE_ADDI, 
	SE_CMPLI, 
	SE_SUBI, 
	SE_SUBI_DOT, 
	SE_CMPI, 
	SE_BMASKI, 
	SE_ANDI, 
	SE_NOP, 
	SE_LI, 
	SE_BCLRI, 
	SE_BGENI, 
	SE_BSETI, 
	SE_BTSTI, 
	SE_SRWI, 
	SE_SRAWI, 
	SE_SLWI, 
	SE_LBZ, 
	SE_STB, 
	SE_LHZ, 
	SE_STH, 
	SE_LWZ, 
	SE_STW, 
	SE_BGE, 
	SE_BNL, 
	SE_BLE, 
	SE_BNG, 
	SE_BNE, 
	SE_BNS, 
	SE_BNU, 
	SE_BF, 
	SE_BLT, 
	SE_BGT, 
	SE_BEQ, 
	SE_BSO, 
	SE_BUN, 
	SE_BT, 
	SE_BC, 
	SE_B, 
	SE_BL, 
	// ---- 32-bit (e_*) ----
	E_LBZU, 
	E_LHAU, 
	E_LHZU, 
	E_LMW, 
	E_LWZU, 
	E_STBU, 
	E_STHU, 
	E_STWU, 
	E_STMW, 
	E_LMVGPRW, 
	E_LDMVGPRW, 
	E_STMVGPRW, 
	E_LMVSPRW, 
	E_LDMVSPRW, 
	E_STMVSPRW, 
	E_LMVSRRW, 
	E_LDMVSRRW, 
	E_STMVSRRW, 
	E_LMVCSRRW, 
	E_LDMVCSRRW, 
	E_STMVCSRRW, 
	E_LMVDSRRW, 
	E_LDMVDSRRW, 
	E_STMVDSRRW, 
	E_LMVMCSRRW, 
	E_STMVMCSRRW, 
	E_ADD16I, 
	E_LA, 
	E_SUB16I, 
	E_LBZ, 
	E_STB, 
	E_LHA, 
	E_LWZ, 
	E_STW, 
	E_LHZ, 
	E_STH, 
	E_RLWIMI, 
	E_INSLWI, 
	E_INSRWI, 
	E_ROTLWI, 
	E_ROTRWI, 
	E_CLRLWI, 
	E_CLRRWI, 
	E_RLWINM, 
	E_EXTLWI, 
	E_EXTRWI, 
	E_CLRLSLWI, 
	E_CMPH, 
	E_SC, 
	E_CMPHL, 
	E_CRANDC, 
	E_CRNAND, 
	E_CRNOT, 
	E_CRNOR, 
	E_CRCLR, 
	E_CRXOR, 
	E_MCRF, 
	E_SLWI, 
	E_SLWI_DOT, 
	E_CRAND, 
	E_RLW, 
	E_RLW_DOT, 
	E_CRSET, 
	E_CREQV, 
	E_RLWI, 
	E_RLWI_DOT, 
	E_CRORC, 
	E_CRMOVE, 
	E_CROR, 
	E_SRWI, 
	E_SRWI_DOT, 
	E_BDNZ, 
	E_BDNZL, 
	E_BDZ, 
	E_BDZL, 
	E_CMPI, 
	E_CMPWI, 
	E_CMPLI, 
	E_CMPLWI, 
	E_ADDI, 
	E_SUBI, 
	E_ADDI_DOT, 
	E_ADDIC, 
	E_SUBIC, 
	E_ADDIC_DOT, 
	E_SUBIC_DOT, 
	E_MULLI, 
	E_SUBFIC, 
	E_SUBFIC_DOT, 
	E_ANDI, 
	E_ANDI_DOT, 
	E_NOP, 
	E_ORI, 
	E_ORI_DOT, 
	E_XORI, 
	E_XORI_DOT, 
	E_LIS, 
	E_AND2IS_DOT, 
	E_OR2IS, 
	E_AND2I_DOT, 
	E_OR2I, 
	E_CMPHL16I, 
	E_CMPH16I, 
	E_CMPL16I, 
	E_MULL2I, 
	E_CMP16I, 
	E_SUB2IS, 
	E_ADD2IS, 
	E_SUB2I_DOT, 
	E_ADD2I_DOT, 
	E_LI, 
	E_B, 
	E_BL, 
	E_BGE, 
	E_BGEL, 
	E_BNL, 
	E_BNLL, 
	E_BLT, 
	E_BLTL, 
	E_BGT, 
	E_BGTL, 
	E_BLE, 
	E_BLEL, 
	E_BNG, 
	E_BNGL, 
	E_BNE, 
	E_BNEL, 
	E_BEQ, 
	E_BEQL, 
	E_BSO, 
	E_BSOL, 
	E_BUN, 
	E_BUNL, 
	E_BNS, 
	E_BNSL, 
	E_BNU, 
	E_BNUL, 
	E_BC, 
	E_BCL, 
	E_BF, 
	E_BFL, 
	E_BT, 
	E_BTL, 
}
    Related Procedures With Parameters

    Mode ¶
    Source

    Mode :: enum u8 {
	PPC32_VLE = 0, 
}

    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              = 0, 
	IMPL,                  // implicit / baked into bits
	// ---- 32-bit instructions (standard PPC slot positions) ----
	RT,                    // bits 21..25 (5-bit GPR destination)
	RA,                    // bits 16..20
	RB,                    // bits 11..15
	RS,                    // bits 21..25 (alias of RT used in store/X-form)
	UI16,                  // bits 0..15, unsigned 16-bit
	SI16,                  // bits 0..15, signed 16-bit
	LI20,                  // 20-bit immediate split: imm[19:16] at bits 17..20,
	//                          imm[15:11] at bits 11..15,
	//                          imm[10:0]  at bits  0..10
	SCI8,                  // 8-bit signed immediate with split scale + sign
	// ---- 32-bit branches ----
	B15,                   // bits 1..15, signed << 1 (15-bit displacement)
	B24,                   // bits 1..24, signed << 1 (24-bit displacement)
	BO32,                  // bits 20..21 (2-bit BO)
	BI32,                  // bits 16..19 (4-bit BI selecting CR bit)
	// ---- 16-bit register fields ----
	RX,                    // bits 0..3, 4-bit GPR_VLE16
	RY,                    // bits 4..7, 4-bit GPR_VLE16
	RZ,                    // alias of RY at bits 4..7
	// ---- 16-bit immediates ----
	UI5,                   // bits 4..8 (5-bit, SE_IM5 form)
	UI7,                   // bits 4..10 (7-bit, IM7 form — actually IM7 puts UI7 at bits 8..14 and RX at bits 4..7 — see encoder)
	// ---- 16-bit memory (SD4 form) ----
	SE_SD,                 // bits 8..11 unscaled (byte)
	SE_SDH,                // bits 8..11 scaled by 2 (halfword)
	SE_SDW,                // bits 8..11 scaled by 4 (word)
	// ---- 16-bit branches ----
	B8,                    // bits 0..7, signed << 1 (8-bit displacement)
	BO16,                  // bit 10 (1-bit BO in BD8IO form)
	BI16,                  // bits 8..9 (2-bit BI)
	// ---- Memory operand composites ----
	OFFSET_BASE_D,         // 32-bit D-form: RA + signed 16-bit D
	OFFSET_BASE_SD4,       // 16-bit SD4 byte memory: RX + SE_SD
	OFFSET_BASE_SD4_H,     // 16-bit SD4 halfword memory: RX + SE_SDH
	OFFSET_BASE_SD4_W,     // 16-bit SD4 word memory: RX + SE_SDW
}

    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        = 0, 
	GPR,             // standard 32-register GPR (5-bit field, used in 32-bit ops)
	GPR_VLE16,       // 16-register VLE subset (4-bit field) — r0..r7 + r24..r31
	GPR_OR_ZERO, 
	IMM, 
	SIMM, 
	UIMM, 
	REL, 
	MEM, 
	CR_FIELD, 
	CR_BIT, 
	SPR, 
	BO,              // branch-op selector immediate (BO16 = 1-bit, BO32 = 2-bit)
}
    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,
	label_id: u32,
	addend:   i32,
	type:     Relocation_Type,
	size:     u8,
	inst_idx: u16,
}

    Relocation_Type ¶
    Source

    Relocation_Type :: enum u8 {
	NONE                   = 0, 
	// Internal (encoder-resolved) branch relocations
	BRANCH_BD8,                 // 8-bit signed << 1 at bits 7..0 of halfword
	BRANCH_BD15,                // 15-bit signed << 1 at bits 1..15 of low halfword
	BRANCH_BD24,                // 24-bit signed << 1 at bits 1..24 of word
	// ELF-spec relocations (linker-bound — encoder emits them but doesn't
	// resolve them locally)
	R_PPC_VLE_REL8,             // 216 — like BRANCH_BD8 but ELF-emitted
	R_PPC_VLE_REL15,            // 217
	R_PPC_VLE_REL24,            // 218
	R_PPC_VLE_LO16A,            // 219 — low 16 bits, A-form imm (I16A bit positions)
	R_PPC_VLE_LO16D,            // 220 — low 16 bits, D-form imm
	R_PPC_VLE_HI16A,            // 221 — high 16 bits, A-form
	R_PPC_VLE_HI16D,            // 222 — high 16 bits, D-form
	R_PPC_VLE_HA16A,            // 223 — high-adjusted 16 bits, A-form
	R_PPC_VLE_HA16D,            // 224 — high-adjusted 16 bits, D-form
	R_PPC_VLE_SDA21,            // 225 — 21-bit small-data-area
	R_PPC_VLE_SDA21_LO,         // 226 — like SDA21 but no overflow check
	R_PPC_VLE_SDAREL_LO16A,     // 227
	R_PPC_VLE_SDAREL_LO16D,     // 228
	R_PPC_VLE_SDAREL_HI16A,     // 229
	R_PPC_VLE_SDAREL_HI16D,     // 230
	R_PPC_VLE_SDAREL_HA16A,     // 231
	R_PPC_VLE_SDAREL_HA16D,     // 232
	R_PPC_VLE_ADDR20,           // 233 — 20-bit absolute (LI20)
}
    Related Procedures With Parameters

    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)

    CSRR0 ¶
    Source

    CSRR0 :: Register(REG_SPR | 58)

    CSRR1 ¶
    Source

    CSRR1 :: Register(REG_SPR | 59)

    CTR ¶
    Source

    CTR :: Register(REG_SPR | 9)

    DAC1 ¶
    Source

    DAC1 :: Register(REG_SPR | 316)

    DAC2 ¶
    Source

    DAC2 :: Register(REG_SPR | 317)

    DBCR0 ¶
    Source

    DBCR0 :: Register(REG_SPR | 308)

    DBCR1 ¶
    Source

    DBCR1 :: Register(REG_SPR | 309)

    DBCR2 ¶
    Source

    DBCR2 :: Register(REG_SPR | 310)

    DBSR ¶
    Source

    DBSR :: Register(REG_SPR | 304)
     

    Debug

    DEAR ¶
    Source

    DEAR :: Register(REG_SPR | 61)

    DEC ¶
    Source

    DEC :: Register(REG_SPR | 22)

    DEFAULT_PRINT_OPTIONS ¶
    Source

    DEFAULT_PRINT_OPTIONS: rexcode_isa.Print_Options : isa.DEFAULT_PRINT_OPTIONS

    ESR ¶
    Source

    ESR :: Register(REG_SPR | 62)

    IAC1 ¶
    Source

    IAC1 :: Register(REG_SPR | 312)

    IAC2 ¶
    Source

    IAC2 :: Register(REG_SPR | 313)

    IAC3 ¶
    Source

    IAC3 :: Register(REG_SPR | 314)

    IAC4 ¶
    Source

    IAC4 :: Register(REG_SPR | 315)

    IVPR ¶
    Source

    IVPR :: Register(REG_SPR | 63)

    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 :: 4

    NONE ¶
    Source

    NONE :: Register(0xFFFF)

    PID ¶
    Source

    PID :: Register(REG_SPR | 48)

    PIR ¶
    Source

    PIR :: Register(REG_SPR | 286)

    PVR ¶
    Source

    PVR :: Register(REG_SPR | 287)

    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

    REG_GPR ¶
    Source

    REG_GPR :: 0x1000

    REG_NONE ¶
    Source

    REG_NONE :: 0x0000
     

    Class tag at top nibble (bits 12..15); 12-bit hardware index in low 12 bits. SPR space goes up to 1023, so we use 12-bit hw to avoid collisions.

    REG_SPR ¶
    Source

    REG_SPR :: 0x6000

    SPEFSCR ¶
    Source

    SPEFSCR :: Register(REG_SPR | 512)
     

    SPE FP control

    SPRG0 ¶
    Source

    SPRG0 :: Register(REG_SPR | 272)
     

    SPRGs 0..7

    SPRG1 ¶
    Source

    SPRG1 :: Register(REG_SPR | 273)

    SPRG2 ¶
    Source

    SPRG2 :: Register(REG_SPR | 274)

    SPRG3 ¶
    Source

    SPRG3 :: Register(REG_SPR | 275)

    SPRG4 ¶
    Source

    SPRG4 :: Register(REG_SPR | 276)

    SPRG5 ¶
    Source

    SPRG5 :: Register(REG_SPR | 277)

    SPRG6 ¶
    Source

    SPRG6 :: Register(REG_SPR | 278)

    SPRG7 ¶
    Source

    SPRG7 :: Register(REG_SPR | 279)

    SRR0 ¶
    Source

    SRR0 :: Register(REG_SPR | 26)

    SRR1 ¶
    Source

    SRR1 :: Register(REG_SPR | 27)

    TBL ¶
    Source

    TBL :: Register(REG_SPR | 284)

    TBU ¶
    Source

    TBU :: Register(REG_SPR | 285)

    XER ¶
    Source

    XER :: Register(REG_SPR | 1)
     

    Common SPRs

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

    @(rodata)
DECODE_INDEX_LONG: []Decode_Index = …

    DECODE_INDEX_SHORT ¶
    Source

    @(rodata)
DECODE_INDEX_SHORT: []Decode_Index = …

    ENCODE_FORMS ¶
    Source

    @(rodata)
ENCODE_FORMS: []Encoding = …

    ENCODE_RUNS ¶
    Source

    @(rodata)
ENCODE_RUNS: []Encode_Run = …

    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, 
) -> (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 (VLE is 2 or 4 bytes; minimum 2).

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

    elf_reloc_number ¶
    Source

    elf_reloc_number :: proc(t: Relocation_Type) -> u32 {…}
     

    Mapping table — each VLE reloc's official ELF number.

    emit_e_add16i ¶
    Source

    emit_e_add16i :: emit_e_add16i_r_r_imm

    emit_e_add16i_r_r_imm ¶
    Source

    emit_e_add16i_r_r_imm :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, imm: i64) {…}

    emit_e_add2i_dot ¶
    Source

    emit_e_add2i_dot :: emit_e_add2i_dot_r_r_imm

    emit_e_add2i_dot_r_r_imm ¶
    Source

    emit_e_add2i_dot_r_r_imm :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, imm: i64) {…}

    emit_e_add2is ¶
    Source

    emit_e_add2is :: emit_e_add2is_r_r_imm

    emit_e_add2is_r_r_imm ¶
    Source

    emit_e_add2is_r_r_imm :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, imm: i64) {…}

    emit_e_addi ¶
    Source

    emit_e_addi :: emit_e_addi_r_r_imm

    emit_e_addi_dot ¶
    Source

    emit_e_addi_dot :: emit_e_addi_dot_r_r_imm

    emit_e_addi_dot_r_r_imm ¶
    Source

    emit_e_addi_dot_r_r_imm :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, imm: i64) {…}

    emit_e_addi_r_r_imm ¶
    Source

    emit_e_addi_r_r_imm :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, imm: i64) {…}

    emit_e_addic ¶
    Source

    emit_e_addic :: emit_e_addic_r_r_imm

    emit_e_addic_dot ¶
    Source

    emit_e_addic_dot :: emit_e_addic_dot_r_r_imm

    emit_e_addic_dot_r_r_imm ¶
    Source

    emit_e_addic_dot_r_r_imm :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, imm: i64) {…}

    emit_e_addic_r_r_imm ¶
    Source

    emit_e_addic_r_r_imm :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, imm: i64) {…}

    emit_e_and2i_dot ¶
    Source

    emit_e_and2i_dot :: emit_e_and2i_dot_r_imm

    emit_e_and2i_dot_r_imm ¶
    Source

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

    emit_e_and2is_dot ¶
    Source

    emit_e_and2is_dot :: emit_e_and2is_dot_r_imm

    emit_e_and2is_dot_r_imm ¶
    Source

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

    emit_e_andi ¶
    Source

    emit_e_andi :: emit_e_andi_r_r_imm

    emit_e_andi_dot ¶
    Source

    emit_e_andi_dot :: emit_e_andi_dot_r_r_imm

    emit_e_andi_dot_r_r_imm ¶
    Source

    emit_e_andi_dot_r_r_imm :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, imm: i64) {…}

    emit_e_andi_r_r_imm ¶
    Source

    emit_e_andi_r_r_imm :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, imm: i64) {…}

    emit_e_b ¶
    Source

    emit_e_b :: emit_e_b_rel

    emit_e_b_rel ¶
    Source

    emit_e_b_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_e_bc ¶
    Source

    emit_e_bc :: emit_e_bc_bo_crb_rel

    emit_e_bc_bo_crb_rel ¶
    Source

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

    emit_e_bcl ¶
    Source

    emit_e_bcl :: emit_e_bcl_bo_crb_rel

    emit_e_bcl_bo_crb_rel ¶
    Source

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

    emit_e_bdnz ¶
    Source

    emit_e_bdnz :: emit_e_bdnz_rel

    emit_e_bdnz_rel ¶
    Source

    emit_e_bdnz_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_e_bdnzl ¶
    Source

    emit_e_bdnzl :: emit_e_bdnzl_rel

    emit_e_bdnzl_rel ¶
    Source

    emit_e_bdnzl_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_e_bdz ¶
    Source

    emit_e_bdz :: emit_e_bdz_rel

    emit_e_bdz_rel ¶
    Source

    emit_e_bdz_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_e_bdzl ¶
    Source

    emit_e_bdzl :: emit_e_bdzl_rel

    emit_e_bdzl_rel ¶
    Source

    emit_e_bdzl_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_e_beq ¶
    Source

    emit_e_beq :: emit_e_beq_rel

    emit_e_beq_rel ¶
    Source

    emit_e_beq_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_e_beql ¶
    Source

    emit_e_beql :: emit_e_beql_rel

    emit_e_beql_rel ¶
    Source

    emit_e_beql_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_e_bf ¶
    Source

    emit_e_bf :: emit_e_bf_rel

    emit_e_bf_rel ¶
    Source

    emit_e_bf_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_e_bfl ¶
    Source

    emit_e_bfl :: emit_e_bfl_rel

    emit_e_bfl_rel ¶
    Source

    emit_e_bfl_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_e_bge ¶
    Source

    emit_e_bge :: emit_e_bge_rel

    emit_e_bge_rel ¶
    Source

    emit_e_bge_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_e_bgel ¶
    Source

    emit_e_bgel :: emit_e_bgel_rel

    emit_e_bgel_rel ¶
    Source

    emit_e_bgel_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_e_bgt ¶
    Source

    emit_e_bgt :: emit_e_bgt_rel

    emit_e_bgt_rel ¶
    Source

    emit_e_bgt_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_e_bgtl ¶
    Source

    emit_e_bgtl :: emit_e_bgtl_rel

    emit_e_bgtl_rel ¶
    Source

    emit_e_bgtl_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_e_bl ¶
    Source

    emit_e_bl :: emit_e_bl_rel

    emit_e_bl_rel ¶
    Source

    emit_e_bl_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_e_ble ¶
    Source

    emit_e_ble :: emit_e_ble_rel

    emit_e_ble_rel ¶
    Source

    emit_e_ble_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_e_blel ¶
    Source

    emit_e_blel :: emit_e_blel_rel

    emit_e_blel_rel ¶
    Source

    emit_e_blel_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_e_blt ¶
    Source

    emit_e_blt :: emit_e_blt_rel

    emit_e_blt_rel ¶
    Source

    emit_e_blt_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_e_bltl ¶
    Source

    emit_e_bltl :: emit_e_bltl_rel

    emit_e_bltl_rel ¶
    Source

    emit_e_bltl_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_e_bne ¶
    Source

    emit_e_bne :: emit_e_bne_rel

    emit_e_bne_rel ¶
    Source

    emit_e_bne_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_e_bnel ¶
    Source

    emit_e_bnel :: emit_e_bnel_rel

    emit_e_bnel_rel ¶
    Source

    emit_e_bnel_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_e_bng ¶
    Source

    emit_e_bng :: emit_e_bng_rel

    emit_e_bng_rel ¶
    Source

    emit_e_bng_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_e_bngl ¶
    Source

    emit_e_bngl :: emit_e_bngl_rel

    emit_e_bngl_rel ¶
    Source

    emit_e_bngl_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_e_bnl ¶
    Source

    emit_e_bnl :: emit_e_bnl_rel

    emit_e_bnl_rel ¶
    Source

    emit_e_bnl_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_e_bnll ¶
    Source

    emit_e_bnll :: emit_e_bnll_rel

    emit_e_bnll_rel ¶
    Source

    emit_e_bnll_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_e_bns ¶
    Source

    emit_e_bns :: emit_e_bns_rel

    emit_e_bns_rel ¶
    Source

    emit_e_bns_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_e_bnsl ¶
    Source

    emit_e_bnsl :: emit_e_bnsl_rel

    emit_e_bnsl_rel ¶
    Source

    emit_e_bnsl_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_e_bnu ¶
    Source

    emit_e_bnu :: emit_e_bnu_rel

    emit_e_bnu_rel ¶
    Source

    emit_e_bnu_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_e_bnul ¶
    Source

    emit_e_bnul :: emit_e_bnul_rel

    emit_e_bnul_rel ¶
    Source

    emit_e_bnul_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_e_bso ¶
    Source

    emit_e_bso :: emit_e_bso_rel

    emit_e_bso_rel ¶
    Source

    emit_e_bso_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_e_bsol ¶
    Source

    emit_e_bsol :: emit_e_bsol_rel

    emit_e_bsol_rel ¶
    Source

    emit_e_bsol_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_e_bt ¶
    Source

    emit_e_bt :: emit_e_bt_rel

    emit_e_bt_rel ¶
    Source

    emit_e_bt_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_e_btl ¶
    Source

    emit_e_btl :: emit_e_btl_rel

    emit_e_btl_rel ¶
    Source

    emit_e_btl_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_e_bun ¶
    Source

    emit_e_bun :: emit_e_bun_rel

    emit_e_bun_rel ¶
    Source

    emit_e_bun_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_e_bunl ¶
    Source

    emit_e_bunl :: emit_e_bunl_rel

    emit_e_bunl_rel ¶
    Source

    emit_e_bunl_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_e_clrlslwi ¶
    Source

    emit_e_clrlslwi :: emit_e_clrlslwi_r_r_r

    emit_e_clrlslwi_r_r_r ¶
    Source

    emit_e_clrlslwi_r_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, r3: Register) {…}

    emit_e_clrlwi ¶
    Source

    emit_e_clrlwi :: emit_e_clrlwi_r_r_r

    emit_e_clrlwi_r_r_r ¶
    Source

    emit_e_clrlwi_r_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, r3: Register) {…}

    emit_e_clrrwi ¶
    Source

    emit_e_clrrwi :: emit_e_clrrwi_r_r_r

    emit_e_clrrwi_r_r_r ¶
    Source

    emit_e_clrrwi_r_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, r3: Register) {…}

    emit_e_cmp16i ¶
    Source

    emit_e_cmp16i :: emit_e_cmp16i_r_r_imm

    emit_e_cmp16i_r_r_imm ¶
    Source

    emit_e_cmp16i_r_r_imm :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, imm: i64) {…}

    emit_e_cmph ¶
    Source

    emit_e_cmph :: emit_e_cmph_r_r_r

    emit_e_cmph16i ¶
    Source

    emit_e_cmph16i :: emit_e_cmph16i_r_r_imm

    emit_e_cmph16i_r_r_imm ¶
    Source

    emit_e_cmph16i_r_r_imm :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, imm: i64) {…}

    emit_e_cmph_r_r_r ¶
    Source

    emit_e_cmph_r_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, r3: Register) {…}

    emit_e_cmphl ¶
    Source

    emit_e_cmphl :: emit_e_cmphl_r_r_r

    emit_e_cmphl16i ¶
    Source

    emit_e_cmphl16i :: emit_e_cmphl16i_r_r_imm

    emit_e_cmphl16i_r_r_imm ¶
    Source

    emit_e_cmphl16i_r_r_imm :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, imm: i64) {…}

    emit_e_cmphl_r_r_r ¶
    Source

    emit_e_cmphl_r_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, r3: Register) {…}

    emit_e_cmpi ¶
    Source

    emit_e_cmpi :: emit_e_cmpi_crf_r_imm

    emit_e_cmpi_crf_r_imm ¶
    Source

    emit_e_cmpi_crf_r_imm :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, imm: i64) {…}

    emit_e_cmpl16i ¶
    Source

    emit_e_cmpl16i :: emit_e_cmpl16i_r_r_imm

    emit_e_cmpl16i_r_r_imm ¶
    Source

    emit_e_cmpl16i_r_r_imm :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, imm: i64) {…}

    emit_e_cmpli ¶
    Source

    emit_e_cmpli :: emit_e_cmpli_crf_r_imm

    emit_e_cmpli_crf_r_imm ¶
    Source

    emit_e_cmpli_crf_r_imm :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, imm: i64) {…}

    emit_e_cmplwi ¶
    Source

    emit_e_cmplwi :: emit_e_cmplwi_crf_r_imm

    emit_e_cmplwi_crf_r_imm ¶
    Source

    emit_e_cmplwi_crf_r_imm :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, imm: i64) {…}

    emit_e_cmpwi ¶
    Source

    emit_e_cmpwi :: emit_e_cmpwi_crf_r_imm

    emit_e_cmpwi_crf_r_imm ¶
    Source

    emit_e_cmpwi_crf_r_imm :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, imm: i64) {…}

    emit_e_crand ¶
    Source

    emit_e_crand :: emit_e_crand_bo_crb

    emit_e_crand_bo_crb ¶
    Source

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

    emit_e_crandc ¶
    Source

    emit_e_crandc :: emit_e_crandc_bo_crb

    emit_e_crandc_bo_crb ¶
    Source

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

    emit_e_crclr ¶
    Source

    emit_e_crclr :: emit_e_crclr_bo_crb

    emit_e_crclr_bo_crb ¶
    Source

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

    emit_e_creqv ¶
    Source

    emit_e_creqv :: emit_e_creqv_bo_crb

    emit_e_creqv_bo_crb ¶
    Source

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

    emit_e_crmove ¶
    Source

    emit_e_crmove :: emit_e_crmove_bo_crb

    emit_e_crmove_bo_crb ¶
    Source

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

    emit_e_crnand ¶
    Source

    emit_e_crnand :: emit_e_crnand_bo_crb

    emit_e_crnand_bo_crb ¶
    Source

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

    emit_e_crnor ¶
    Source

    emit_e_crnor :: emit_e_crnor_bo_crb

    emit_e_crnor_bo_crb ¶
    Source

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

    emit_e_crnot ¶
    Source

    emit_e_crnot :: emit_e_crnot_bo_crb

    emit_e_crnot_bo_crb ¶
    Source

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

    emit_e_cror ¶
    Source

    emit_e_cror :: emit_e_cror_bo_crb

    emit_e_cror_bo_crb ¶
    Source

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

    emit_e_crorc ¶
    Source

    emit_e_crorc :: emit_e_crorc_bo_crb

    emit_e_crorc_bo_crb ¶
    Source

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

    emit_e_crset ¶
    Source

    emit_e_crset :: emit_e_crset_bo_crb

    emit_e_crset_bo_crb ¶
    Source

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

    emit_e_crxor ¶
    Source

    emit_e_crxor :: emit_e_crxor_bo_crb

    emit_e_crxor_bo_crb ¶
    Source

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

    emit_e_extlwi ¶
    Source

    emit_e_extlwi :: emit_e_extlwi_r_r_r

    emit_e_extlwi_r_r_r ¶
    Source

    emit_e_extlwi_r_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, r3: Register) {…}

    emit_e_extrwi ¶
    Source

    emit_e_extrwi :: emit_e_extrwi_r_r_r

    emit_e_extrwi_r_r_r ¶
    Source

    emit_e_extrwi_r_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, r3: Register) {…}

    emit_e_inslwi ¶
    Source

    emit_e_inslwi :: emit_e_inslwi_r_r_r

    emit_e_inslwi_r_r_r ¶
    Source

    emit_e_inslwi_r_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, r3: Register) {…}

    emit_e_insrwi ¶
    Source

    emit_e_insrwi :: emit_e_insrwi_r_r_r

    emit_e_insrwi_r_r_r ¶
    Source

    emit_e_insrwi_r_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, r3: Register) {…}

    emit_e_la ¶
    Source

    emit_e_la :: emit_e_la_r_mem

    emit_e_la_r_mem ¶
    Source

    emit_e_la_r_mem :: proc(instructions: ^[dynamic]Instruction, rd: Register, mem: Memory) {…}

    emit_e_lbz ¶
    Source

    emit_e_lbz :: emit_e_lbz_r_mem

    emit_e_lbz_r_mem ¶
    Source

    emit_e_lbz_r_mem :: proc(instructions: ^[dynamic]Instruction, rd: Register, mem: Memory) {…}

    emit_e_lbzu ¶
    Source

    emit_e_lbzu :: emit_e_lbzu_r_r

    emit_e_lbzu_r_r ¶
    Source

    emit_e_lbzu_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register) {…}

    emit_e_ldmvcsrrw ¶
    Source

    emit_e_ldmvcsrrw :: emit_e_ldmvcsrrw_r_r

    emit_e_ldmvcsrrw_r_r ¶
    Source

    emit_e_ldmvcsrrw_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register) {…}

    emit_e_ldmvdsrrw ¶
    Source

    emit_e_ldmvdsrrw :: emit_e_ldmvdsrrw_r_r

    emit_e_ldmvdsrrw_r_r ¶
    Source

    emit_e_ldmvdsrrw_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register) {…}

    emit_e_ldmvgprw ¶
    Source

    emit_e_ldmvgprw :: emit_e_ldmvgprw_r_r

    emit_e_ldmvgprw_r_r ¶
    Source

    emit_e_ldmvgprw_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register) {…}

    emit_e_ldmvsprw ¶
    Source

    emit_e_ldmvsprw :: emit_e_ldmvsprw_r_r

    emit_e_ldmvsprw_r_r ¶
    Source

    emit_e_ldmvsprw_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register) {…}

    emit_e_ldmvsrrw ¶
    Source

    emit_e_ldmvsrrw :: emit_e_ldmvsrrw_r_r

    emit_e_ldmvsrrw_r_r ¶
    Source

    emit_e_ldmvsrrw_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register) {…}

    emit_e_lha ¶
    Source

    emit_e_lha :: emit_e_lha_r_mem

    emit_e_lha_r_mem ¶
    Source

    emit_e_lha_r_mem :: proc(instructions: ^[dynamic]Instruction, rd: Register, mem: Memory) {…}

    emit_e_lhau ¶
    Source

    emit_e_lhau :: emit_e_lhau_r_r

    emit_e_lhau_r_r ¶
    Source

    emit_e_lhau_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register) {…}

    emit_e_lhz ¶
    Source

    emit_e_lhz :: emit_e_lhz_r_mem

    emit_e_lhz_r_mem ¶
    Source

    emit_e_lhz_r_mem :: proc(instructions: ^[dynamic]Instruction, rd: Register, mem: Memory) {…}

    emit_e_lhzu ¶
    Source

    emit_e_lhzu :: emit_e_lhzu_r_r

    emit_e_lhzu_r_r ¶
    Source

    emit_e_lhzu_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register) {…}

    emit_e_li ¶
    Source

    emit_e_li :: emit_e_li_r_imm

    emit_e_li_r_imm ¶
    Source

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

    emit_e_lis ¶
    Source

    emit_e_lis :: emit_e_lis_r_imm

    emit_e_lis_r_imm ¶
    Source

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

    emit_e_lmvcsrrw ¶
    Source

    emit_e_lmvcsrrw :: emit_e_lmvcsrrw_r_r

    emit_e_lmvcsrrw_r_r ¶
    Source

    emit_e_lmvcsrrw_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register) {…}

    emit_e_lmvdsrrw ¶
    Source

    emit_e_lmvdsrrw :: emit_e_lmvdsrrw_r_r

    emit_e_lmvdsrrw_r_r ¶
    Source

    emit_e_lmvdsrrw_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register) {…}

    emit_e_lmvgprw ¶
    Source

    emit_e_lmvgprw :: emit_e_lmvgprw_r_r

    emit_e_lmvgprw_r_r ¶
    Source

    emit_e_lmvgprw_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register) {…}

    emit_e_lmvmcsrrw ¶
    Source

    emit_e_lmvmcsrrw :: emit_e_lmvmcsrrw_r_r

    emit_e_lmvmcsrrw_r_r ¶
    Source

    emit_e_lmvmcsrrw_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register) {…}

    emit_e_lmvsprw ¶
    Source

    emit_e_lmvsprw :: emit_e_lmvsprw_r_r

    emit_e_lmvsprw_r_r ¶
    Source

    emit_e_lmvsprw_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register) {…}

    emit_e_lmvsrrw ¶
    Source

    emit_e_lmvsrrw :: emit_e_lmvsrrw_r_r

    emit_e_lmvsrrw_r_r ¶
    Source

    emit_e_lmvsrrw_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register) {…}

    emit_e_lmw ¶
    Source

    emit_e_lmw :: emit_e_lmw_r_r

    emit_e_lmw_r_r ¶
    Source

    emit_e_lmw_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register) {…}

    emit_e_lwz ¶
    Source

    emit_e_lwz :: emit_e_lwz_r_mem

    emit_e_lwz_r_mem ¶
    Source

    emit_e_lwz_r_mem :: proc(instructions: ^[dynamic]Instruction, rd: Register, mem: Memory) {…}

    emit_e_lwzu ¶
    Source

    emit_e_lwzu :: emit_e_lwzu_r_r

    emit_e_lwzu_r_r ¶
    Source

    emit_e_lwzu_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register) {…}

    emit_e_mcrf ¶
    Source

    emit_e_mcrf :: emit_e_mcrf_bo_crb

    emit_e_mcrf_bo_crb ¶
    Source

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

    emit_e_mull2i ¶
    Source

    emit_e_mull2i :: emit_e_mull2i_r_r_imm

    emit_e_mull2i_r_r_imm ¶
    Source

    emit_e_mull2i_r_r_imm :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, imm: i64) {…}

    emit_e_mulli ¶
    Source

    emit_e_mulli :: emit_e_mulli_r_r_imm

    emit_e_mulli_r_r_imm ¶
    Source

    emit_e_mulli_r_r_imm :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, imm: i64) {…}

    emit_e_nop ¶
    Source

    emit_e_nop :: emit_e_nop_r_r_imm

    emit_e_nop_r_r_imm ¶
    Source

    emit_e_nop_r_r_imm :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, imm: i64) {…}

    emit_e_or2i ¶
    Source

    emit_e_or2i :: emit_e_or2i_r_imm

    emit_e_or2i_r_imm ¶
    Source

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

    emit_e_or2is ¶
    Source

    emit_e_or2is :: emit_e_or2is_r_imm

    emit_e_or2is_r_imm ¶
    Source

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

    emit_e_ori ¶
    Source

    emit_e_ori :: emit_e_ori_r_r_imm

    emit_e_ori_dot ¶
    Source

    emit_e_ori_dot :: emit_e_ori_dot_r_r_imm

    emit_e_ori_dot_r_r_imm ¶
    Source

    emit_e_ori_dot_r_r_imm :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, imm: i64) {…}

    emit_e_ori_r_r_imm ¶
    Source

    emit_e_ori_r_r_imm :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, imm: i64) {…}

    emit_e_rlw ¶
    Source

    emit_e_rlw :: emit_e_rlw_r_r_r

    emit_e_rlw_dot ¶
    Source

    emit_e_rlw_dot :: emit_e_rlw_dot_r_r_r

    emit_e_rlw_dot_r_r_r ¶
    Source

    emit_e_rlw_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, r3: Register) {…}

    emit_e_rlw_r_r_r ¶
    Source

    emit_e_rlw_r_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, r3: Register) {…}

    emit_e_rlwi ¶
    Source

    emit_e_rlwi :: emit_e_rlwi_r_r_r

    emit_e_rlwi_dot ¶
    Source

    emit_e_rlwi_dot :: emit_e_rlwi_dot_r_r_r

    emit_e_rlwi_dot_r_r_r ¶
    Source

    emit_e_rlwi_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, r3: Register) {…}

    emit_e_rlwi_r_r_r ¶
    Source

    emit_e_rlwi_r_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, r3: Register) {…}

    emit_e_rlwimi ¶
    Source

    emit_e_rlwimi :: emit_e_rlwimi_r_r_r

    emit_e_rlwimi_r_r_r ¶
    Source

    emit_e_rlwimi_r_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, r3: Register) {…}

    emit_e_rlwinm ¶
    Source

    emit_e_rlwinm :: emit_e_rlwinm_r_r_r

    emit_e_rlwinm_r_r_r ¶
    Source

    emit_e_rlwinm_r_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, r3: Register) {…}

    emit_e_rotlwi ¶
    Source

    emit_e_rotlwi :: emit_e_rotlwi_r_r_r

    emit_e_rotlwi_r_r_r ¶
    Source

    emit_e_rotlwi_r_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, r3: Register) {…}

    emit_e_rotrwi ¶
    Source

    emit_e_rotrwi :: emit_e_rotrwi_r_r_r

    emit_e_rotrwi_r_r_r ¶
    Source

    emit_e_rotrwi_r_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, r3: Register) {…}

    emit_e_sc ¶
    Source

    emit_e_sc :: emit_e_sc_r_r_r

    emit_e_sc_r_r_r ¶
    Source

    emit_e_sc_r_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, r3: Register) {…}

    emit_e_slwi ¶
    Source

    emit_e_slwi :: emit_e_slwi_r_r_r

    emit_e_slwi_dot ¶
    Source

    emit_e_slwi_dot :: emit_e_slwi_dot_r_r_r

    emit_e_slwi_dot_r_r_r ¶
    Source

    emit_e_slwi_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, r3: Register) {…}

    emit_e_slwi_r_r_r ¶
    Source

    emit_e_slwi_r_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, r3: Register) {…}

    emit_e_srwi ¶
    Source

    emit_e_srwi :: emit_e_srwi_r_r_r

    emit_e_srwi_dot ¶
    Source

    emit_e_srwi_dot :: emit_e_srwi_dot_r_r_r

    emit_e_srwi_dot_r_r_r ¶
    Source

    emit_e_srwi_dot_r_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, r3: Register) {…}

    emit_e_srwi_r_r_r ¶
    Source

    emit_e_srwi_r_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, r3: Register) {…}

    emit_e_stb ¶
    Source

    emit_e_stb :: emit_e_stb_r_mem

    emit_e_stb_r_mem ¶
    Source

    emit_e_stb_r_mem :: proc(instructions: ^[dynamic]Instruction, rd: Register, mem: Memory) {…}

    emit_e_stbu ¶
    Source

    emit_e_stbu :: emit_e_stbu_r_r

    emit_e_stbu_r_r ¶
    Source

    emit_e_stbu_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register) {…}

    emit_e_sth ¶
    Source

    emit_e_sth :: emit_e_sth_r_mem

    emit_e_sth_r_mem ¶
    Source

    emit_e_sth_r_mem :: proc(instructions: ^[dynamic]Instruction, rd: Register, mem: Memory) {…}

    emit_e_sthu ¶
    Source

    emit_e_sthu :: emit_e_sthu_r_r

    emit_e_sthu_r_r ¶
    Source

    emit_e_sthu_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register) {…}

    emit_e_stmvcsrrw ¶
    Source

    emit_e_stmvcsrrw :: emit_e_stmvcsrrw_r_r

    emit_e_stmvcsrrw_r_r ¶
    Source

    emit_e_stmvcsrrw_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register) {…}

    emit_e_stmvdsrrw ¶
    Source

    emit_e_stmvdsrrw :: emit_e_stmvdsrrw_r_r

    emit_e_stmvdsrrw_r_r ¶
    Source

    emit_e_stmvdsrrw_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register) {…}

    emit_e_stmvgprw ¶
    Source

    emit_e_stmvgprw :: emit_e_stmvgprw_r_r

    emit_e_stmvgprw_r_r ¶
    Source

    emit_e_stmvgprw_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register) {…}

    emit_e_stmvmcsrrw ¶
    Source

    emit_e_stmvmcsrrw :: emit_e_stmvmcsrrw_r_r

    emit_e_stmvmcsrrw_r_r ¶
    Source

    emit_e_stmvmcsrrw_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register) {…}

    emit_e_stmvsprw ¶
    Source

    emit_e_stmvsprw :: emit_e_stmvsprw_r_r

    emit_e_stmvsprw_r_r ¶
    Source

    emit_e_stmvsprw_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register) {…}

    emit_e_stmvsrrw ¶
    Source

    emit_e_stmvsrrw :: emit_e_stmvsrrw_r_r

    emit_e_stmvsrrw_r_r ¶
    Source

    emit_e_stmvsrrw_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register) {…}

    emit_e_stmw ¶
    Source

    emit_e_stmw :: emit_e_stmw_r_r

    emit_e_stmw_r_r ¶
    Source

    emit_e_stmw_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register) {…}

    emit_e_stw ¶
    Source

    emit_e_stw :: emit_e_stw_r_mem

    emit_e_stw_r_mem ¶
    Source

    emit_e_stw_r_mem :: proc(instructions: ^[dynamic]Instruction, rd: Register, mem: Memory) {…}

    emit_e_stwu ¶
    Source

    emit_e_stwu :: emit_e_stwu_r_r

    emit_e_stwu_r_r ¶
    Source

    emit_e_stwu_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register) {…}

    emit_e_sub16i ¶
    Source

    emit_e_sub16i :: emit_e_sub16i_r_r_imm

    emit_e_sub16i_r_r_imm ¶
    Source

    emit_e_sub16i_r_r_imm :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, imm: i64) {…}

    emit_e_sub2i_dot ¶
    Source

    emit_e_sub2i_dot :: emit_e_sub2i_dot_r_r_imm

    emit_e_sub2i_dot_r_r_imm ¶
    Source

    emit_e_sub2i_dot_r_r_imm :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, imm: i64) {…}

    emit_e_sub2is ¶
    Source

    emit_e_sub2is :: emit_e_sub2is_r_r_imm

    emit_e_sub2is_r_r_imm ¶
    Source

    emit_e_sub2is_r_r_imm :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, imm: i64) {…}

    emit_e_subfic ¶
    Source

    emit_e_subfic :: emit_e_subfic_r_r_imm

    emit_e_subfic_dot ¶
    Source

    emit_e_subfic_dot :: emit_e_subfic_dot_r_r_imm

    emit_e_subfic_dot_r_r_imm ¶
    Source

    emit_e_subfic_dot_r_r_imm :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, imm: i64) {…}

    emit_e_subfic_r_r_imm ¶
    Source

    emit_e_subfic_r_r_imm :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, imm: i64) {…}

    emit_e_subi ¶
    Source

    emit_e_subi :: emit_e_subi_r_r_imm

    emit_e_subi_r_r_imm ¶
    Source

    emit_e_subi_r_r_imm :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, imm: i64) {…}

    emit_e_subic ¶
    Source

    emit_e_subic :: emit_e_subic_r_r_imm

    emit_e_subic_dot ¶
    Source

    emit_e_subic_dot :: emit_e_subic_dot_r_r_imm

    emit_e_subic_dot_r_r_imm ¶
    Source

    emit_e_subic_dot_r_r_imm :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, imm: i64) {…}

    emit_e_subic_r_r_imm ¶
    Source

    emit_e_subic_r_r_imm :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, imm: i64) {…}

    emit_e_xori ¶
    Source

    emit_e_xori :: emit_e_xori_r_r_imm

    emit_e_xori_dot ¶
    Source

    emit_e_xori_dot :: emit_e_xori_dot_r_r_imm

    emit_e_xori_dot_r_r_imm ¶
    Source

    emit_e_xori_dot_r_r_imm :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, imm: i64) {…}

    emit_e_xori_r_r_imm ¶
    Source

    emit_e_xori_r_r_imm :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register, imm: i64) {…}

    emit_se_add ¶
    Source

    emit_se_add :: emit_se_add_r_r

    emit_se_add_r_r ¶
    Source

    emit_se_add_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register) {…}

    emit_se_addi ¶
    Source

    emit_se_addi :: emit_se_addi_r_imm

    emit_se_addi_r_imm ¶
    Source

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

    emit_se_and ¶
    Source

    emit_se_and :: emit_se_and_r_r

    emit_se_and_dot ¶
    Source

    emit_se_and_dot :: emit_se_and_dot_r_r

    emit_se_and_dot_r_r ¶
    Source

    emit_se_and_dot_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register) {…}

    emit_se_and_r_r ¶
    Source

    emit_se_and_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register) {…}

    emit_se_andc ¶
    Source

    emit_se_andc :: emit_se_andc_r_r

    emit_se_andc_r_r ¶
    Source

    emit_se_andc_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register) {…}

    emit_se_andi ¶
    Source

    emit_se_andi :: emit_se_andi_r_imm

    emit_se_andi_r_imm ¶
    Source

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

    emit_se_b ¶
    Source

    emit_se_b :: emit_se_b_rel

    emit_se_b_rel ¶
    Source

    emit_se_b_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_se_bc ¶
    Source

    emit_se_bc :: emit_se_bc_bo_crb_rel

    emit_se_bc_bo_crb_rel ¶
    Source

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

    emit_se_bclri ¶
    Source

    emit_se_bclri :: emit_se_bclri_r_imm

    emit_se_bclri_r_imm ¶
    Source

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

    emit_se_bctr ¶
    Source

    emit_se_bctr :: emit_se_bctr_none

    emit_se_bctr_none ¶
    Source

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

    emit_se_bctrl ¶
    Source

    emit_se_bctrl :: emit_se_bctrl_none

    emit_se_bctrl_none ¶
    Source

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

    emit_se_beq ¶
    Source

    emit_se_beq :: emit_se_beq_rel

    emit_se_beq_rel ¶
    Source

    emit_se_beq_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_se_bf ¶
    Source

    emit_se_bf :: emit_se_bf_rel

    emit_se_bf_rel ¶
    Source

    emit_se_bf_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_se_bge ¶
    Source

    emit_se_bge :: emit_se_bge_rel

    emit_se_bge_rel ¶
    Source

    emit_se_bge_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_se_bgeni ¶
    Source

    emit_se_bgeni :: emit_se_bgeni_r_imm

    emit_se_bgeni_r_imm ¶
    Source

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

    emit_se_bgt ¶
    Source

    emit_se_bgt :: emit_se_bgt_rel

    emit_se_bgt_rel ¶
    Source

    emit_se_bgt_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_se_bl ¶
    Source

    emit_se_bl :: emit_se_bl_rel

    emit_se_bl_rel ¶
    Source

    emit_se_bl_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_se_ble ¶
    Source

    emit_se_ble :: emit_se_ble_rel

    emit_se_ble_rel ¶
    Source

    emit_se_ble_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_se_blr ¶
    Source

    emit_se_blr :: emit_se_blr_none

    emit_se_blr_none ¶
    Source

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

    emit_se_blrl ¶
    Source

    emit_se_blrl :: emit_se_blrl_none

    emit_se_blrl_none ¶
    Source

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

    emit_se_blt ¶
    Source

    emit_se_blt :: emit_se_blt_rel

    emit_se_blt_rel ¶
    Source

    emit_se_blt_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_se_bmaski ¶
    Source

    emit_se_bmaski :: emit_se_bmaski_r_imm

    emit_se_bmaski_r_imm ¶
    Source

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

    emit_se_bne ¶
    Source

    emit_se_bne :: emit_se_bne_rel

    emit_se_bne_rel ¶
    Source

    emit_se_bne_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_se_bng ¶
    Source

    emit_se_bng :: emit_se_bng_rel

    emit_se_bng_rel ¶
    Source

    emit_se_bng_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_se_bnl ¶
    Source

    emit_se_bnl :: emit_se_bnl_rel

    emit_se_bnl_rel ¶
    Source

    emit_se_bnl_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_se_bns ¶
    Source

    emit_se_bns :: emit_se_bns_rel

    emit_se_bns_rel ¶
    Source

    emit_se_bns_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_se_bnu ¶
    Source

    emit_se_bnu :: emit_se_bnu_rel

    emit_se_bnu_rel ¶
    Source

    emit_se_bnu_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_se_bseti ¶
    Source

    emit_se_bseti :: emit_se_bseti_r_imm

    emit_se_bseti_r_imm ¶
    Source

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

    emit_se_bso ¶
    Source

    emit_se_bso :: emit_se_bso_rel

    emit_se_bso_rel ¶
    Source

    emit_se_bso_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_se_bt ¶
    Source

    emit_se_bt :: emit_se_bt_rel

    emit_se_bt_rel ¶
    Source

    emit_se_bt_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_se_btsti ¶
    Source

    emit_se_btsti :: emit_se_btsti_r_imm

    emit_se_btsti_r_imm ¶
    Source

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

    emit_se_bun ¶
    Source

    emit_se_bun :: emit_se_bun_rel

    emit_se_bun_rel ¶
    Source

    emit_se_bun_rel :: proc(instructions: ^[dynamic]Instruction, target: u32) {…}

    emit_se_cmp ¶
    Source

    emit_se_cmp :: emit_se_cmp_r_r

    emit_se_cmp_r_r ¶
    Source

    emit_se_cmp_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register) {…}

    emit_se_cmph ¶
    Source

    emit_se_cmph :: emit_se_cmph_r_r

    emit_se_cmph_r_r ¶
    Source

    emit_se_cmph_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register) {…}

    emit_se_cmphl ¶
    Source

    emit_se_cmphl :: emit_se_cmphl_r_r

    emit_se_cmphl_r_r ¶
    Source

    emit_se_cmphl_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register) {…}

    emit_se_cmpi ¶
    Source

    emit_se_cmpi :: emit_se_cmpi_r_imm

    emit_se_cmpi_r_imm ¶
    Source

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

    emit_se_cmpl ¶
    Source

    emit_se_cmpl :: emit_se_cmpl_r_r

    emit_se_cmpl_r_r ¶
    Source

    emit_se_cmpl_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register) {…}

    emit_se_cmpli ¶
    Source

    emit_se_cmpli :: emit_se_cmpli_r_imm

    emit_se_cmpli_r_imm ¶
    Source

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

    emit_se_extsb ¶
    Source

    emit_se_extsb :: emit_se_extsb_r

    emit_se_extsb_r ¶
    Source

    emit_se_extsb_r :: proc(instructions: ^[dynamic]Instruction, rd: Register) {…}

    emit_se_extsh ¶
    Source

    emit_se_extsh :: emit_se_extsh_r

    emit_se_extsh_r ¶
    Source

    emit_se_extsh_r :: proc(instructions: ^[dynamic]Instruction, rd: Register) {…}

    emit_se_extzb ¶
    Source

    emit_se_extzb :: emit_se_extzb_r

    emit_se_extzb_r ¶
    Source

    emit_se_extzb_r :: proc(instructions: ^[dynamic]Instruction, rd: Register) {…}

    emit_se_extzh ¶
    Source

    emit_se_extzh :: emit_se_extzh_r

    emit_se_extzh_r ¶
    Source

    emit_se_extzh_r :: proc(instructions: ^[dynamic]Instruction, rd: Register) {…}

    emit_se_illegal ¶
    Source

    emit_se_illegal :: emit_se_illegal_none

    emit_se_illegal_none ¶
    Source

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

    emit_se_isync ¶
    Source

    emit_se_isync :: emit_se_isync_none

    emit_se_isync_none ¶
    Source

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

    emit_se_lbz ¶
    Source

    emit_se_lbz :: emit_se_lbz_r_mem

    emit_se_lbz_r_mem ¶
    Source

    emit_se_lbz_r_mem :: proc(instructions: ^[dynamic]Instruction, rd: Register, mem: Memory) {…}

    emit_se_lhz ¶
    Source

    emit_se_lhz :: emit_se_lhz_r_mem

    emit_se_lhz_r_mem ¶
    Source

    emit_se_lhz_r_mem :: proc(instructions: ^[dynamic]Instruction, rd: Register, mem: Memory) {…}

    emit_se_li ¶
    Source

    emit_se_li :: emit_se_li_r_imm

    emit_se_li_r_imm ¶
    Source

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

    emit_se_lwz ¶
    Source

    emit_se_lwz :: emit_se_lwz_r_mem

    emit_se_lwz_r_mem ¶
    Source

    emit_se_lwz_r_mem :: proc(instructions: ^[dynamic]Instruction, rd: Register, mem: Memory) {…}

    emit_se_mfar ¶
    Source

    emit_se_mfar :: emit_se_mfar_r_r

    emit_se_mfar_r_r ¶
    Source

    emit_se_mfar_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register) {…}

    emit_se_mfctr ¶
    Source

    emit_se_mfctr :: emit_se_mfctr_r

    emit_se_mfctr_r ¶
    Source

    emit_se_mfctr_r :: proc(instructions: ^[dynamic]Instruction, rd: Register) {…}

    emit_se_mflr ¶
    Source

    emit_se_mflr :: emit_se_mflr_r

    emit_se_mflr_r ¶
    Source

    emit_se_mflr_r :: proc(instructions: ^[dynamic]Instruction, rd: Register) {…}

    emit_se_mr ¶
    Source

    emit_se_mr :: emit_se_mr_r_r

    emit_se_mr_r_r ¶
    Source

    emit_se_mr_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register) {…}

    emit_se_mtar ¶
    Source

    emit_se_mtar :: emit_se_mtar_r_r

    emit_se_mtar_r_r ¶
    Source

    emit_se_mtar_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register) {…}

    emit_se_mtctr ¶
    Source

    emit_se_mtctr :: emit_se_mtctr_r

    emit_se_mtctr_r ¶
    Source

    emit_se_mtctr_r :: proc(instructions: ^[dynamic]Instruction, rd: Register) {…}

    emit_se_mtlr ¶
    Source

    emit_se_mtlr :: emit_se_mtlr_r

    emit_se_mtlr_r ¶
    Source

    emit_se_mtlr_r :: proc(instructions: ^[dynamic]Instruction, rd: Register) {…}

    emit_se_mullw ¶
    Source

    emit_se_mullw :: emit_se_mullw_r_r

    emit_se_mullw_r_r ¶
    Source

    emit_se_mullw_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register) {…}

    emit_se_neg ¶
    Source

    emit_se_neg :: emit_se_neg_r

    emit_se_neg_r ¶
    Source

    emit_se_neg_r :: proc(instructions: ^[dynamic]Instruction, rd: Register) {…}

    emit_se_nop ¶
    Source

    emit_se_nop :: emit_se_nop_r_r

    emit_se_nop_r_r ¶
    Source

    emit_se_nop_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register) {…}

    emit_se_not ¶
    Source

    emit_se_not :: emit_se_not_r

    emit_se_not_r ¶
    Source

    emit_se_not_r :: proc(instructions: ^[dynamic]Instruction, rd: Register) {…}

    emit_se_or ¶
    Source

    emit_se_or :: emit_se_or_r_r

    emit_se_or_r_r ¶
    Source

    emit_se_or_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register) {…}

    emit_se_rfci ¶
    Source

    emit_se_rfci :: emit_se_rfci_none

    emit_se_rfci_none ¶
    Source

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

    emit_se_rfdi ¶
    Source

    emit_se_rfdi :: emit_se_rfdi_none

    emit_se_rfdi_none ¶
    Source

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

    emit_se_rfgi ¶
    Source

    emit_se_rfgi :: emit_se_rfgi_none

    emit_se_rfgi_none ¶
    Source

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

    emit_se_rfi ¶
    Source

    emit_se_rfi :: emit_se_rfi_none

    emit_se_rfi_none ¶
    Source

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

    emit_se_rfmci ¶
    Source

    emit_se_rfmci :: emit_se_rfmci_none

    emit_se_rfmci_none ¶
    Source

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

    emit_se_sc ¶
    Source

    emit_se_sc :: emit_se_sc_none

    emit_se_sc_none ¶
    Source

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

    emit_se_slw ¶
    Source

    emit_se_slw :: emit_se_slw_r_r

    emit_se_slw_r_r ¶
    Source

    emit_se_slw_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register) {…}

    emit_se_slwi ¶
    Source

    emit_se_slwi :: emit_se_slwi_r_imm

    emit_se_slwi_r_imm ¶
    Source

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

    emit_se_sraw ¶
    Source

    emit_se_sraw :: emit_se_sraw_r_r

    emit_se_sraw_r_r ¶
    Source

    emit_se_sraw_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register) {…}

    emit_se_srawi ¶
    Source

    emit_se_srawi :: emit_se_srawi_r_imm

    emit_se_srawi_r_imm ¶
    Source

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

    emit_se_srw ¶
    Source

    emit_se_srw :: emit_se_srw_r_r

    emit_se_srw_r_r ¶
    Source

    emit_se_srw_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register) {…}

    emit_se_srwi ¶
    Source

    emit_se_srwi :: emit_se_srwi_r_imm

    emit_se_srwi_r_imm ¶
    Source

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

    emit_se_stb ¶
    Source

    emit_se_stb :: emit_se_stb_r_mem

    emit_se_stb_r_mem ¶
    Source

    emit_se_stb_r_mem :: proc(instructions: ^[dynamic]Instruction, rd: Register, mem: Memory) {…}

    emit_se_sth ¶
    Source

    emit_se_sth :: emit_se_sth_r_mem

    emit_se_sth_r_mem ¶
    Source

    emit_se_sth_r_mem :: proc(instructions: ^[dynamic]Instruction, rd: Register, mem: Memory) {…}

    emit_se_stw ¶
    Source

    emit_se_stw :: emit_se_stw_r_mem

    emit_se_stw_r_mem ¶
    Source

    emit_se_stw_r_mem :: proc(instructions: ^[dynamic]Instruction, rd: Register, mem: Memory) {…}

    emit_se_sub ¶
    Source

    emit_se_sub :: emit_se_sub_r_r

    emit_se_sub_r_r ¶
    Source

    emit_se_sub_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register) {…}

    emit_se_subf ¶
    Source

    emit_se_subf :: emit_se_subf_r_r

    emit_se_subf_r_r ¶
    Source

    emit_se_subf_r_r :: proc(instructions: ^[dynamic]Instruction, rd: Register, r2: Register) {…}

    emit_se_subi ¶
    Source

    emit_se_subi :: emit_se_subi_r_imm

    emit_se_subi_dot ¶
    Source

    emit_se_subi_dot :: emit_se_subi_dot_r_imm

    emit_se_subi_dot_r_imm ¶
    Source

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

    emit_se_subi_r_imm ¶
    Source

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

    encode ¶
    Source

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

    encode_max_code_size ¶
    Source

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

    encode_max_relocation_count ¶
    Source

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

    encode_reserve ¶
    Source

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

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

    fprint ¶
    Source

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

    fprintln ¶
    Source

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

    inst_branch ¶
    Source

    inst_branch :: proc "contextless" (m: Mnemonic, label_id: u32) -> Instruction {…}

    inst_e_add16i ¶
    Source

    inst_e_add16i :: inst_e_add16i_r_r_imm

    inst_e_add16i_r_r_imm ¶
    Source

    inst_e_add16i_r_r_imm :: proc "contextless" (rd: Register, r2: Register, imm: i64) -> Instruction {…}

    inst_e_add2i_dot ¶
    Source

    inst_e_add2i_dot :: inst_e_add2i_dot_r_r_imm

    inst_e_add2i_dot_r_r_imm ¶
    Source

    inst_e_add2i_dot_r_r_imm :: proc "contextless" (rd: Register, r2: Register, imm: i64) -> Instruction {…}

    inst_e_add2is ¶
    Source

    inst_e_add2is :: inst_e_add2is_r_r_imm

    inst_e_add2is_r_r_imm ¶
    Source

    inst_e_add2is_r_r_imm :: proc "contextless" (rd: Register, r2: Register, imm: i64) -> Instruction {…}

    inst_e_addi ¶
    Source

    inst_e_addi :: inst_e_addi_r_r_imm

    inst_e_addi_dot ¶
    Source

    inst_e_addi_dot :: inst_e_addi_dot_r_r_imm

    inst_e_addi_dot_r_r_imm ¶
    Source

    inst_e_addi_dot_r_r_imm :: proc "contextless" (rd: Register, r2: Register, imm: i64) -> Instruction {…}

    inst_e_addi_r_r_imm ¶
    Source

    inst_e_addi_r_r_imm :: proc "contextless" (rd: Register, r2: Register, imm: i64) -> Instruction {…}

    inst_e_addic ¶
    Source

    inst_e_addic :: inst_e_addic_r_r_imm

    inst_e_addic_dot ¶
    Source

    inst_e_addic_dot :: inst_e_addic_dot_r_r_imm

    inst_e_addic_dot_r_r_imm ¶
    Source

    inst_e_addic_dot_r_r_imm :: proc "contextless" (rd: Register, r2: Register, imm: i64) -> Instruction {…}

    inst_e_addic_r_r_imm ¶
    Source

    inst_e_addic_r_r_imm :: proc "contextless" (rd: Register, r2: Register, imm: i64) -> Instruction {…}

    inst_e_and2i_dot ¶
    Source

    inst_e_and2i_dot :: inst_e_and2i_dot_r_imm

    inst_e_and2i_dot_r_imm ¶
    Source

    inst_e_and2i_dot_r_imm :: proc "contextless" (rd: Register, imm: i64) -> Instruction {…}

    inst_e_and2is_dot ¶
    Source

    inst_e_and2is_dot :: inst_e_and2is_dot_r_imm

    inst_e_and2is_dot_r_imm ¶
    Source

    inst_e_and2is_dot_r_imm :: proc "contextless" (rd: Register, imm: i64) -> Instruction {…}

    inst_e_andi ¶
    Source

    inst_e_andi :: inst_e_andi_r_r_imm

    inst_e_andi_dot ¶
    Source

    inst_e_andi_dot :: inst_e_andi_dot_r_r_imm

    inst_e_andi_dot_r_r_imm ¶
    Source

    inst_e_andi_dot_r_r_imm :: proc "contextless" (rd: Register, r2: Register, imm: i64) -> Instruction {…}

    inst_e_andi_r_r_imm ¶
    Source

    inst_e_andi_r_r_imm :: proc "contextless" (rd: Register, r2: Register, imm: i64) -> Instruction {…}

    inst_e_b ¶
    Source

    inst_e_b :: inst_e_b_rel

    inst_e_b_rel ¶
    Source

    inst_e_b_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_e_bc ¶
    Source

    inst_e_bc :: inst_e_bc_bo_crb_rel

    inst_e_bc_bo_crb_rel ¶
    Source

    inst_e_bc_bo_crb_rel :: proc "contextless" (imm: i64, imm2: i64, target: u32) -> Instruction {…}

    inst_e_bcl ¶
    Source

    inst_e_bcl :: inst_e_bcl_bo_crb_rel

    inst_e_bcl_bo_crb_rel ¶
    Source

    inst_e_bcl_bo_crb_rel :: proc "contextless" (imm: i64, imm2: i64, target: u32) -> Instruction {…}

    inst_e_bdnz ¶
    Source

    inst_e_bdnz :: inst_e_bdnz_rel

    inst_e_bdnz_rel ¶
    Source

    inst_e_bdnz_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_e_bdnzl ¶
    Source

    inst_e_bdnzl :: inst_e_bdnzl_rel

    inst_e_bdnzl_rel ¶
    Source

    inst_e_bdnzl_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_e_bdz ¶
    Source

    inst_e_bdz :: inst_e_bdz_rel

    inst_e_bdz_rel ¶
    Source

    inst_e_bdz_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_e_bdzl ¶
    Source

    inst_e_bdzl :: inst_e_bdzl_rel

    inst_e_bdzl_rel ¶
    Source

    inst_e_bdzl_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_e_beq ¶
    Source

    inst_e_beq :: inst_e_beq_rel

    inst_e_beq_rel ¶
    Source

    inst_e_beq_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_e_beql ¶
    Source

    inst_e_beql :: inst_e_beql_rel

    inst_e_beql_rel ¶
    Source

    inst_e_beql_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_e_bf ¶
    Source

    inst_e_bf :: inst_e_bf_rel

    inst_e_bf_rel ¶
    Source

    inst_e_bf_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_e_bfl ¶
    Source

    inst_e_bfl :: inst_e_bfl_rel

    inst_e_bfl_rel ¶
    Source

    inst_e_bfl_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_e_bge ¶
    Source

    inst_e_bge :: inst_e_bge_rel

    inst_e_bge_rel ¶
    Source

    inst_e_bge_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_e_bgel ¶
    Source

    inst_e_bgel :: inst_e_bgel_rel

    inst_e_bgel_rel ¶
    Source

    inst_e_bgel_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_e_bgt ¶
    Source

    inst_e_bgt :: inst_e_bgt_rel

    inst_e_bgt_rel ¶
    Source

    inst_e_bgt_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_e_bgtl ¶
    Source

    inst_e_bgtl :: inst_e_bgtl_rel

    inst_e_bgtl_rel ¶
    Source

    inst_e_bgtl_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_e_bl ¶
    Source

    inst_e_bl :: inst_e_bl_rel

    inst_e_bl_rel ¶
    Source

    inst_e_bl_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_e_ble ¶
    Source

    inst_e_ble :: inst_e_ble_rel

    inst_e_ble_rel ¶
    Source

    inst_e_ble_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_e_blel ¶
    Source

    inst_e_blel :: inst_e_blel_rel

    inst_e_blel_rel ¶
    Source

    inst_e_blel_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_e_blt ¶
    Source

    inst_e_blt :: inst_e_blt_rel

    inst_e_blt_rel ¶
    Source

    inst_e_blt_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_e_bltl ¶
    Source

    inst_e_bltl :: inst_e_bltl_rel

    inst_e_bltl_rel ¶
    Source

    inst_e_bltl_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_e_bne ¶
    Source

    inst_e_bne :: inst_e_bne_rel

    inst_e_bne_rel ¶
    Source

    inst_e_bne_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_e_bnel ¶
    Source

    inst_e_bnel :: inst_e_bnel_rel

    inst_e_bnel_rel ¶
    Source

    inst_e_bnel_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_e_bng ¶
    Source

    inst_e_bng :: inst_e_bng_rel

    inst_e_bng_rel ¶
    Source

    inst_e_bng_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_e_bngl ¶
    Source

    inst_e_bngl :: inst_e_bngl_rel

    inst_e_bngl_rel ¶
    Source

    inst_e_bngl_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_e_bnl ¶
    Source

    inst_e_bnl :: inst_e_bnl_rel

    inst_e_bnl_rel ¶
    Source

    inst_e_bnl_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_e_bnll ¶
    Source

    inst_e_bnll :: inst_e_bnll_rel

    inst_e_bnll_rel ¶
    Source

    inst_e_bnll_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_e_bns ¶
    Source

    inst_e_bns :: inst_e_bns_rel

    inst_e_bns_rel ¶
    Source

    inst_e_bns_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_e_bnsl ¶
    Source

    inst_e_bnsl :: inst_e_bnsl_rel

    inst_e_bnsl_rel ¶
    Source

    inst_e_bnsl_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_e_bnu ¶
    Source

    inst_e_bnu :: inst_e_bnu_rel

    inst_e_bnu_rel ¶
    Source

    inst_e_bnu_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_e_bnul ¶
    Source

    inst_e_bnul :: inst_e_bnul_rel

    inst_e_bnul_rel ¶
    Source

    inst_e_bnul_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_e_bso ¶
    Source

    inst_e_bso :: inst_e_bso_rel

    inst_e_bso_rel ¶
    Source

    inst_e_bso_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_e_bsol ¶
    Source

    inst_e_bsol :: inst_e_bsol_rel

    inst_e_bsol_rel ¶
    Source

    inst_e_bsol_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_e_bt ¶
    Source

    inst_e_bt :: inst_e_bt_rel

    inst_e_bt_rel ¶
    Source

    inst_e_bt_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_e_btl ¶
    Source

    inst_e_btl :: inst_e_btl_rel

    inst_e_btl_rel ¶
    Source

    inst_e_btl_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_e_bun ¶
    Source

    inst_e_bun :: inst_e_bun_rel

    inst_e_bun_rel ¶
    Source

    inst_e_bun_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_e_bunl ¶
    Source

    inst_e_bunl :: inst_e_bunl_rel

    inst_e_bunl_rel ¶
    Source

    inst_e_bunl_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_e_clrlslwi ¶
    Source

    inst_e_clrlslwi :: inst_e_clrlslwi_r_r_r

    inst_e_clrlslwi_r_r_r ¶
    Source

    inst_e_clrlslwi_r_r_r :: proc "contextless" (rd: Register, r2: Register, r3: Register) -> Instruction {…}

    inst_e_clrlwi ¶
    Source

    inst_e_clrlwi :: inst_e_clrlwi_r_r_r

    inst_e_clrlwi_r_r_r ¶
    Source

    inst_e_clrlwi_r_r_r :: proc "contextless" (rd: Register, r2: Register, r3: Register) -> Instruction {…}

    inst_e_clrrwi ¶
    Source

    inst_e_clrrwi :: inst_e_clrrwi_r_r_r

    inst_e_clrrwi_r_r_r ¶
    Source

    inst_e_clrrwi_r_r_r :: proc "contextless" (rd: Register, r2: Register, r3: Register) -> Instruction {…}

    inst_e_cmp16i ¶
    Source

    inst_e_cmp16i :: inst_e_cmp16i_r_r_imm

    inst_e_cmp16i_r_r_imm ¶
    Source

    inst_e_cmp16i_r_r_imm :: proc "contextless" (rd: Register, r2: Register, imm: i64) -> Instruction {…}

    inst_e_cmph ¶
    Source

    inst_e_cmph :: inst_e_cmph_r_r_r

    inst_e_cmph16i ¶
    Source

    inst_e_cmph16i :: inst_e_cmph16i_r_r_imm

    inst_e_cmph16i_r_r_imm ¶
    Source

    inst_e_cmph16i_r_r_imm :: proc "contextless" (rd: Register, r2: Register, imm: i64) -> Instruction {…}

    inst_e_cmph_r_r_r ¶
    Source

    inst_e_cmph_r_r_r :: proc "contextless" (rd: Register, r2: Register, r3: Register) -> Instruction {…}

    inst_e_cmphl ¶
    Source

    inst_e_cmphl :: inst_e_cmphl_r_r_r

    inst_e_cmphl16i ¶
    Source

    inst_e_cmphl16i :: inst_e_cmphl16i_r_r_imm

    inst_e_cmphl16i_r_r_imm ¶
    Source

    inst_e_cmphl16i_r_r_imm :: proc "contextless" (rd: Register, r2: Register, imm: i64) -> Instruction {…}

    inst_e_cmphl_r_r_r ¶
    Source

    inst_e_cmphl_r_r_r :: proc "contextless" (rd: Register, r2: Register, r3: Register) -> Instruction {…}

    inst_e_cmpi ¶
    Source

    inst_e_cmpi :: inst_e_cmpi_crf_r_imm

    inst_e_cmpi_crf_r_imm ¶
    Source

    inst_e_cmpi_crf_r_imm :: proc "contextless" (rd: Register, r2: Register, imm: i64) -> Instruction {…}

    inst_e_cmpl16i ¶
    Source

    inst_e_cmpl16i :: inst_e_cmpl16i_r_r_imm

    inst_e_cmpl16i_r_r_imm ¶
    Source

    inst_e_cmpl16i_r_r_imm :: proc "contextless" (rd: Register, r2: Register, imm: i64) -> Instruction {…}

    inst_e_cmpli ¶
    Source

    inst_e_cmpli :: inst_e_cmpli_crf_r_imm

    inst_e_cmpli_crf_r_imm ¶
    Source

    inst_e_cmpli_crf_r_imm :: proc "contextless" (rd: Register, r2: Register, imm: i64) -> Instruction {…}

    inst_e_cmplwi ¶
    Source

    inst_e_cmplwi :: inst_e_cmplwi_crf_r_imm

    inst_e_cmplwi_crf_r_imm ¶
    Source

    inst_e_cmplwi_crf_r_imm :: proc "contextless" (rd: Register, r2: Register, imm: i64) -> Instruction {…}

    inst_e_cmpwi ¶
    Source

    inst_e_cmpwi :: inst_e_cmpwi_crf_r_imm

    inst_e_cmpwi_crf_r_imm ¶
    Source

    inst_e_cmpwi_crf_r_imm :: proc "contextless" (rd: Register, r2: Register, imm: i64) -> Instruction {…}

    inst_e_crand ¶
    Source

    inst_e_crand :: inst_e_crand_bo_crb

    inst_e_crand_bo_crb ¶
    Source

    inst_e_crand_bo_crb :: proc "contextless" (imm: i64, imm2: i64) -> Instruction {…}

    inst_e_crandc ¶
    Source

    inst_e_crandc :: inst_e_crandc_bo_crb

    inst_e_crandc_bo_crb ¶
    Source

    inst_e_crandc_bo_crb :: proc "contextless" (imm: i64, imm2: i64) -> Instruction {…}

    inst_e_crclr ¶
    Source

    inst_e_crclr :: inst_e_crclr_bo_crb

    inst_e_crclr_bo_crb ¶
    Source

    inst_e_crclr_bo_crb :: proc "contextless" (imm: i64, imm2: i64) -> Instruction {…}

    inst_e_creqv ¶
    Source

    inst_e_creqv :: inst_e_creqv_bo_crb

    inst_e_creqv_bo_crb ¶
    Source

    inst_e_creqv_bo_crb :: proc "contextless" (imm: i64, imm2: i64) -> Instruction {…}

    inst_e_crmove ¶
    Source

    inst_e_crmove :: inst_e_crmove_bo_crb

    inst_e_crmove_bo_crb ¶
    Source

    inst_e_crmove_bo_crb :: proc "contextless" (imm: i64, imm2: i64) -> Instruction {…}

    inst_e_crnand ¶
    Source

    inst_e_crnand :: inst_e_crnand_bo_crb

    inst_e_crnand_bo_crb ¶
    Source

    inst_e_crnand_bo_crb :: proc "contextless" (imm: i64, imm2: i64) -> Instruction {…}

    inst_e_crnor ¶
    Source

    inst_e_crnor :: inst_e_crnor_bo_crb

    inst_e_crnor_bo_crb ¶
    Source

    inst_e_crnor_bo_crb :: proc "contextless" (imm: i64, imm2: i64) -> Instruction {…}

    inst_e_crnot ¶
    Source

    inst_e_crnot :: inst_e_crnot_bo_crb

    inst_e_crnot_bo_crb ¶
    Source

    inst_e_crnot_bo_crb :: proc "contextless" (imm: i64, imm2: i64) -> Instruction {…}

    inst_e_cror ¶
    Source

    inst_e_cror :: inst_e_cror_bo_crb

    inst_e_cror_bo_crb ¶
    Source

    inst_e_cror_bo_crb :: proc "contextless" (imm: i64, imm2: i64) -> Instruction {…}

    inst_e_crorc ¶
    Source

    inst_e_crorc :: inst_e_crorc_bo_crb

    inst_e_crorc_bo_crb ¶
    Source

    inst_e_crorc_bo_crb :: proc "contextless" (imm: i64, imm2: i64) -> Instruction {…}

    inst_e_crset ¶
    Source

    inst_e_crset :: inst_e_crset_bo_crb

    inst_e_crset_bo_crb ¶
    Source

    inst_e_crset_bo_crb :: proc "contextless" (imm: i64, imm2: i64) -> Instruction {…}

    inst_e_crxor ¶
    Source

    inst_e_crxor :: inst_e_crxor_bo_crb

    inst_e_crxor_bo_crb ¶
    Source

    inst_e_crxor_bo_crb :: proc "contextless" (imm: i64, imm2: i64) -> Instruction {…}

    inst_e_extlwi ¶
    Source

    inst_e_extlwi :: inst_e_extlwi_r_r_r

    inst_e_extlwi_r_r_r ¶
    Source

    inst_e_extlwi_r_r_r :: proc "contextless" (rd: Register, r2: Register, r3: Register) -> Instruction {…}

    inst_e_extrwi ¶
    Source

    inst_e_extrwi :: inst_e_extrwi_r_r_r

    inst_e_extrwi_r_r_r ¶
    Source

    inst_e_extrwi_r_r_r :: proc "contextless" (rd: Register, r2: Register, r3: Register) -> Instruction {…}

    inst_e_inslwi ¶
    Source

    inst_e_inslwi :: inst_e_inslwi_r_r_r

    inst_e_inslwi_r_r_r ¶
    Source

    inst_e_inslwi_r_r_r :: proc "contextless" (rd: Register, r2: Register, r3: Register) -> Instruction {…}

    inst_e_insrwi ¶
    Source

    inst_e_insrwi :: inst_e_insrwi_r_r_r

    inst_e_insrwi_r_r_r ¶
    Source

    inst_e_insrwi_r_r_r :: proc "contextless" (rd: Register, r2: Register, r3: Register) -> Instruction {…}

    inst_e_la ¶
    Source

    inst_e_la :: inst_e_la_r_mem

    inst_e_la_r_mem ¶
    Source

    inst_e_la_r_mem :: proc "contextless" (rd: Register, mem: Memory) -> Instruction {…}

    inst_e_lbz ¶
    Source

    inst_e_lbz :: inst_e_lbz_r_mem

    inst_e_lbz_r_mem ¶
    Source

    inst_e_lbz_r_mem :: proc "contextless" (rd: Register, mem: Memory) -> Instruction {…}

    inst_e_lbzu ¶
    Source

    inst_e_lbzu :: inst_e_lbzu_r_r

    inst_e_lbzu_r_r ¶
    Source

    inst_e_lbzu_r_r :: proc "contextless" (rd: Register, r2: Register) -> Instruction {…}

    inst_e_ldmvcsrrw ¶
    Source

    inst_e_ldmvcsrrw :: inst_e_ldmvcsrrw_r_r

    inst_e_ldmvcsrrw_r_r ¶
    Source

    inst_e_ldmvcsrrw_r_r :: proc "contextless" (rd: Register, r2: Register) -> Instruction {…}

    inst_e_ldmvdsrrw ¶
    Source

    inst_e_ldmvdsrrw :: inst_e_ldmvdsrrw_r_r

    inst_e_ldmvdsrrw_r_r ¶
    Source

    inst_e_ldmvdsrrw_r_r :: proc "contextless" (rd: Register, r2: Register) -> Instruction {…}

    inst_e_ldmvgprw ¶
    Source

    inst_e_ldmvgprw :: inst_e_ldmvgprw_r_r

    inst_e_ldmvgprw_r_r ¶
    Source

    inst_e_ldmvgprw_r_r :: proc "contextless" (rd: Register, r2: Register) -> Instruction {…}

    inst_e_ldmvsprw ¶
    Source

    inst_e_ldmvsprw :: inst_e_ldmvsprw_r_r

    inst_e_ldmvsprw_r_r ¶
    Source

    inst_e_ldmvsprw_r_r :: proc "contextless" (rd: Register, r2: Register) -> Instruction {…}

    inst_e_ldmvsrrw ¶
    Source

    inst_e_ldmvsrrw :: inst_e_ldmvsrrw_r_r

    inst_e_ldmvsrrw_r_r ¶
    Source

    inst_e_ldmvsrrw_r_r :: proc "contextless" (rd: Register, r2: Register) -> Instruction {…}

    inst_e_lha ¶
    Source

    inst_e_lha :: inst_e_lha_r_mem

    inst_e_lha_r_mem ¶
    Source

    inst_e_lha_r_mem :: proc "contextless" (rd: Register, mem: Memory) -> Instruction {…}

    inst_e_lhau ¶
    Source

    inst_e_lhau :: inst_e_lhau_r_r

    inst_e_lhau_r_r ¶
    Source

    inst_e_lhau_r_r :: proc "contextless" (rd: Register, r2: Register) -> Instruction {…}

    inst_e_lhz ¶
    Source

    inst_e_lhz :: inst_e_lhz_r_mem

    inst_e_lhz_r_mem ¶
    Source

    inst_e_lhz_r_mem :: proc "contextless" (rd: Register, mem: Memory) -> Instruction {…}

    inst_e_lhzu ¶
    Source

    inst_e_lhzu :: inst_e_lhzu_r_r

    inst_e_lhzu_r_r ¶
    Source

    inst_e_lhzu_r_r :: proc "contextless" (rd: Register, r2: Register) -> Instruction {…}

    inst_e_li ¶
    Source

    inst_e_li :: inst_e_li_r_imm

    inst_e_li_r_imm ¶
    Source

    inst_e_li_r_imm :: proc "contextless" (rd: Register, imm: i64) -> Instruction {…}

    inst_e_lis ¶
    Source

    inst_e_lis :: inst_e_lis_r_imm

    inst_e_lis_r_imm ¶
    Source

    inst_e_lis_r_imm :: proc "contextless" (rd: Register, imm: i64) -> Instruction {…}

    inst_e_lmvcsrrw ¶
    Source

    inst_e_lmvcsrrw :: inst_e_lmvcsrrw_r_r

    inst_e_lmvcsrrw_r_r ¶
    Source

    inst_e_lmvcsrrw_r_r :: proc "contextless" (rd: Register, r2: Register) -> Instruction {…}

    inst_e_lmvdsrrw ¶
    Source

    inst_e_lmvdsrrw :: inst_e_lmvdsrrw_r_r

    inst_e_lmvdsrrw_r_r ¶
    Source

    inst_e_lmvdsrrw_r_r :: proc "contextless" (rd: Register, r2: Register) -> Instruction {…}

    inst_e_lmvgprw ¶
    Source

    inst_e_lmvgprw :: inst_e_lmvgprw_r_r

    inst_e_lmvgprw_r_r ¶
    Source

    inst_e_lmvgprw_r_r :: proc "contextless" (rd: Register, r2: Register) -> Instruction {…}

    inst_e_lmvmcsrrw ¶
    Source

    inst_e_lmvmcsrrw :: inst_e_lmvmcsrrw_r_r

    inst_e_lmvmcsrrw_r_r ¶
    Source

    inst_e_lmvmcsrrw_r_r :: proc "contextless" (rd: Register, r2: Register) -> Instruction {…}

    inst_e_lmvsprw ¶
    Source

    inst_e_lmvsprw :: inst_e_lmvsprw_r_r

    inst_e_lmvsprw_r_r ¶
    Source

    inst_e_lmvsprw_r_r :: proc "contextless" (rd: Register, r2: Register) -> Instruction {…}

    inst_e_lmvsrrw ¶
    Source

    inst_e_lmvsrrw :: inst_e_lmvsrrw_r_r

    inst_e_lmvsrrw_r_r ¶
    Source

    inst_e_lmvsrrw_r_r :: proc "contextless" (rd: Register, r2: Register) -> Instruction {…}

    inst_e_lmw ¶
    Source

    inst_e_lmw :: inst_e_lmw_r_r

    inst_e_lmw_r_r ¶
    Source

    inst_e_lmw_r_r :: proc "contextless" (rd: Register, r2: Register) -> Instruction {…}

    inst_e_lwz ¶
    Source

    inst_e_lwz :: inst_e_lwz_r_mem

    inst_e_lwz_r_mem ¶
    Source

    inst_e_lwz_r_mem :: proc "contextless" (rd: Register, mem: Memory) -> Instruction {…}

    inst_e_lwzu ¶
    Source

    inst_e_lwzu :: inst_e_lwzu_r_r

    inst_e_lwzu_r_r ¶
    Source

    inst_e_lwzu_r_r :: proc "contextless" (rd: Register, r2: Register) -> Instruction {…}

    inst_e_mcrf ¶
    Source

    inst_e_mcrf :: inst_e_mcrf_bo_crb

    inst_e_mcrf_bo_crb ¶
    Source

    inst_e_mcrf_bo_crb :: proc "contextless" (imm: i64, imm2: i64) -> Instruction {…}

    inst_e_mull2i ¶
    Source

    inst_e_mull2i :: inst_e_mull2i_r_r_imm

    inst_e_mull2i_r_r_imm ¶
    Source

    inst_e_mull2i_r_r_imm :: proc "contextless" (rd: Register, r2: Register, imm: i64) -> Instruction {…}

    inst_e_mulli ¶
    Source

    inst_e_mulli :: inst_e_mulli_r_r_imm

    inst_e_mulli_r_r_imm ¶
    Source

    inst_e_mulli_r_r_imm :: proc "contextless" (rd: Register, r2: Register, imm: i64) -> Instruction {…}

    inst_e_nop ¶
    Source

    inst_e_nop :: inst_e_nop_r_r_imm

    inst_e_nop_r_r_imm ¶
    Source

    inst_e_nop_r_r_imm :: proc "contextless" (rd: Register, r2: Register, imm: i64) -> Instruction {…}

    inst_e_or2i ¶
    Source

    inst_e_or2i :: inst_e_or2i_r_imm

    inst_e_or2i_r_imm ¶
    Source

    inst_e_or2i_r_imm :: proc "contextless" (rd: Register, imm: i64) -> Instruction {…}

    inst_e_or2is ¶
    Source

    inst_e_or2is :: inst_e_or2is_r_imm

    inst_e_or2is_r_imm ¶
    Source

    inst_e_or2is_r_imm :: proc "contextless" (rd: Register, imm: i64) -> Instruction {…}

    inst_e_ori ¶
    Source

    inst_e_ori :: inst_e_ori_r_r_imm

    inst_e_ori_dot ¶
    Source

    inst_e_ori_dot :: inst_e_ori_dot_r_r_imm

    inst_e_ori_dot_r_r_imm ¶
    Source

    inst_e_ori_dot_r_r_imm :: proc "contextless" (rd: Register, r2: Register, imm: i64) -> Instruction {…}

    inst_e_ori_r_r_imm ¶
    Source

    inst_e_ori_r_r_imm :: proc "contextless" (rd: Register, r2: Register, imm: i64) -> Instruction {…}

    inst_e_rlw ¶
    Source

    inst_e_rlw :: inst_e_rlw_r_r_r

    inst_e_rlw_dot ¶
    Source

    inst_e_rlw_dot :: inst_e_rlw_dot_r_r_r

    inst_e_rlw_dot_r_r_r ¶
    Source

    inst_e_rlw_dot_r_r_r :: proc "contextless" (rd: Register, r2: Register, r3: Register) -> Instruction {…}

    inst_e_rlw_r_r_r ¶
    Source

    inst_e_rlw_r_r_r :: proc "contextless" (rd: Register, r2: Register, r3: Register) -> Instruction {…}

    inst_e_rlwi ¶
    Source

    inst_e_rlwi :: inst_e_rlwi_r_r_r

    inst_e_rlwi_dot ¶
    Source

    inst_e_rlwi_dot :: inst_e_rlwi_dot_r_r_r

    inst_e_rlwi_dot_r_r_r ¶
    Source

    inst_e_rlwi_dot_r_r_r :: proc "contextless" (rd: Register, r2: Register, r3: Register) -> Instruction {…}

    inst_e_rlwi_r_r_r ¶
    Source

    inst_e_rlwi_r_r_r :: proc "contextless" (rd: Register, r2: Register, r3: Register) -> Instruction {…}

    inst_e_rlwimi ¶
    Source

    inst_e_rlwimi :: inst_e_rlwimi_r_r_r

    inst_e_rlwimi_r_r_r ¶
    Source

    inst_e_rlwimi_r_r_r :: proc "contextless" (rd: Register, r2: Register, r3: Register) -> Instruction {…}

    inst_e_rlwinm ¶
    Source

    inst_e_rlwinm :: inst_e_rlwinm_r_r_r

    inst_e_rlwinm_r_r_r ¶
    Source

    inst_e_rlwinm_r_r_r :: proc "contextless" (rd: Register, r2: Register, r3: Register) -> Instruction {…}

    inst_e_rotlwi ¶
    Source

    inst_e_rotlwi :: inst_e_rotlwi_r_r_r

    inst_e_rotlwi_r_r_r ¶
    Source

    inst_e_rotlwi_r_r_r :: proc "contextless" (rd: Register, r2: Register, r3: Register) -> Instruction {…}

    inst_e_rotrwi ¶
    Source

    inst_e_rotrwi :: inst_e_rotrwi_r_r_r

    inst_e_rotrwi_r_r_r ¶
    Source

    inst_e_rotrwi_r_r_r :: proc "contextless" (rd: Register, r2: Register, r3: Register) -> Instruction {…}

    inst_e_sc ¶
    Source

    inst_e_sc :: inst_e_sc_r_r_r

    inst_e_sc_r_r_r ¶
    Source

    inst_e_sc_r_r_r :: proc "contextless" (rd: Register, r2: Register, r3: Register) -> Instruction {…}

    inst_e_slwi ¶
    Source

    inst_e_slwi :: inst_e_slwi_r_r_r

    inst_e_slwi_dot ¶
    Source

    inst_e_slwi_dot :: inst_e_slwi_dot_r_r_r

    inst_e_slwi_dot_r_r_r ¶
    Source

    inst_e_slwi_dot_r_r_r :: proc "contextless" (rd: Register, r2: Register, r3: Register) -> Instruction {…}

    inst_e_slwi_r_r_r ¶
    Source

    inst_e_slwi_r_r_r :: proc "contextless" (rd: Register, r2: Register, r3: Register) -> Instruction {…}

    inst_e_srwi ¶
    Source

    inst_e_srwi :: inst_e_srwi_r_r_r

    inst_e_srwi_dot ¶
    Source

    inst_e_srwi_dot :: inst_e_srwi_dot_r_r_r

    inst_e_srwi_dot_r_r_r ¶
    Source

    inst_e_srwi_dot_r_r_r :: proc "contextless" (rd: Register, r2: Register, r3: Register) -> Instruction {…}

    inst_e_srwi_r_r_r ¶
    Source

    inst_e_srwi_r_r_r :: proc "contextless" (rd: Register, r2: Register, r3: Register) -> Instruction {…}

    inst_e_stb ¶
    Source

    inst_e_stb :: inst_e_stb_r_mem

    inst_e_stb_r_mem ¶
    Source

    inst_e_stb_r_mem :: proc "contextless" (rd: Register, mem: Memory) -> Instruction {…}

    inst_e_stbu ¶
    Source

    inst_e_stbu :: inst_e_stbu_r_r

    inst_e_stbu_r_r ¶
    Source

    inst_e_stbu_r_r :: proc "contextless" (rd: Register, r2: Register) -> Instruction {…}

    inst_e_sth ¶
    Source

    inst_e_sth :: inst_e_sth_r_mem

    inst_e_sth_r_mem ¶
    Source

    inst_e_sth_r_mem :: proc "contextless" (rd: Register, mem: Memory) -> Instruction {…}

    inst_e_sthu ¶
    Source

    inst_e_sthu :: inst_e_sthu_r_r

    inst_e_sthu_r_r ¶
    Source

    inst_e_sthu_r_r :: proc "contextless" (rd: Register, r2: Register) -> Instruction {…}

    inst_e_stmvcsrrw ¶
    Source

    inst_e_stmvcsrrw :: inst_e_stmvcsrrw_r_r

    inst_e_stmvcsrrw_r_r ¶
    Source

    inst_e_stmvcsrrw_r_r :: proc "contextless" (rd: Register, r2: Register) -> Instruction {…}

    inst_e_stmvdsrrw ¶
    Source

    inst_e_stmvdsrrw :: inst_e_stmvdsrrw_r_r

    inst_e_stmvdsrrw_r_r ¶
    Source

    inst_e_stmvdsrrw_r_r :: proc "contextless" (rd: Register, r2: Register) -> Instruction {…}

    inst_e_stmvgprw ¶
    Source

    inst_e_stmvgprw :: inst_e_stmvgprw_r_r

    inst_e_stmvgprw_r_r ¶
    Source

    inst_e_stmvgprw_r_r :: proc "contextless" (rd: Register, r2: Register) -> Instruction {…}

    inst_e_stmvmcsrrw ¶
    Source

    inst_e_stmvmcsrrw :: inst_e_stmvmcsrrw_r_r

    inst_e_stmvmcsrrw_r_r ¶
    Source

    inst_e_stmvmcsrrw_r_r :: proc "contextless" (rd: Register, r2: Register) -> Instruction {…}

    inst_e_stmvsprw ¶
    Source

    inst_e_stmvsprw :: inst_e_stmvsprw_r_r

    inst_e_stmvsprw_r_r ¶
    Source

    inst_e_stmvsprw_r_r :: proc "contextless" (rd: Register, r2: Register) -> Instruction {…}

    inst_e_stmvsrrw ¶
    Source

    inst_e_stmvsrrw :: inst_e_stmvsrrw_r_r

    inst_e_stmvsrrw_r_r ¶
    Source

    inst_e_stmvsrrw_r_r :: proc "contextless" (rd: Register, r2: Register) -> Instruction {…}

    inst_e_stmw ¶
    Source

    inst_e_stmw :: inst_e_stmw_r_r

    inst_e_stmw_r_r ¶
    Source

    inst_e_stmw_r_r :: proc "contextless" (rd: Register, r2: Register) -> Instruction {…}

    inst_e_stw ¶
    Source

    inst_e_stw :: inst_e_stw_r_mem

    inst_e_stw_r_mem ¶
    Source

    inst_e_stw_r_mem :: proc "contextless" (rd: Register, mem: Memory) -> Instruction {…}

    inst_e_stwu ¶
    Source

    inst_e_stwu :: inst_e_stwu_r_r

    inst_e_stwu_r_r ¶
    Source

    inst_e_stwu_r_r :: proc "contextless" (rd: Register, r2: Register) -> Instruction {…}

    inst_e_sub16i ¶
    Source

    inst_e_sub16i :: inst_e_sub16i_r_r_imm

    inst_e_sub16i_r_r_imm ¶
    Source

    inst_e_sub16i_r_r_imm :: proc "contextless" (rd: Register, r2: Register, imm: i64) -> Instruction {…}

    inst_e_sub2i_dot ¶
    Source

    inst_e_sub2i_dot :: inst_e_sub2i_dot_r_r_imm

    inst_e_sub2i_dot_r_r_imm ¶
    Source

    inst_e_sub2i_dot_r_r_imm :: proc "contextless" (rd: Register, r2: Register, imm: i64) -> Instruction {…}

    inst_e_sub2is ¶
    Source

    inst_e_sub2is :: inst_e_sub2is_r_r_imm

    inst_e_sub2is_r_r_imm ¶
    Source

    inst_e_sub2is_r_r_imm :: proc "contextless" (rd: Register, r2: Register, imm: i64) -> Instruction {…}

    inst_e_subfic ¶
    Source

    inst_e_subfic :: inst_e_subfic_r_r_imm

    inst_e_subfic_dot ¶
    Source

    inst_e_subfic_dot :: inst_e_subfic_dot_r_r_imm

    inst_e_subfic_dot_r_r_imm ¶
    Source

    inst_e_subfic_dot_r_r_imm :: proc "contextless" (rd: Register, r2: Register, imm: i64) -> Instruction {…}

    inst_e_subfic_r_r_imm ¶
    Source

    inst_e_subfic_r_r_imm :: proc "contextless" (rd: Register, r2: Register, imm: i64) -> Instruction {…}

    inst_e_subi ¶
    Source

    inst_e_subi :: inst_e_subi_r_r_imm

    inst_e_subi_r_r_imm ¶
    Source

    inst_e_subi_r_r_imm :: proc "contextless" (rd: Register, r2: Register, imm: i64) -> Instruction {…}

    inst_e_subic ¶
    Source

    inst_e_subic :: inst_e_subic_r_r_imm

    inst_e_subic_dot ¶
    Source

    inst_e_subic_dot :: inst_e_subic_dot_r_r_imm

    inst_e_subic_dot_r_r_imm ¶
    Source

    inst_e_subic_dot_r_r_imm :: proc "contextless" (rd: Register, r2: Register, imm: i64) -> Instruction {…}

    inst_e_subic_r_r_imm ¶
    Source

    inst_e_subic_r_r_imm :: proc "contextless" (rd: Register, r2: Register, imm: i64) -> Instruction {…}

    inst_e_xori ¶
    Source

    inst_e_xori :: inst_e_xori_r_r_imm

    inst_e_xori_dot ¶
    Source

    inst_e_xori_dot :: inst_e_xori_dot_r_r_imm

    inst_e_xori_dot_r_r_imm ¶
    Source

    inst_e_xori_dot_r_r_imm :: proc "contextless" (rd: Register, r2: Register, imm: i64) -> Instruction {…}

    inst_e_xori_r_r_imm ¶
    Source

    inst_e_xori_r_r_imm :: proc "contextless" (rd: Register, r2: Register, imm: i64) -> Instruction {…}

    inst_i ¶
    Source

    inst_i :: proc "contextless" (m: Mnemonic, v: i64) -> Instruction {…}

    inst_load ¶
    Source

    inst_load :: proc "contextless" (m: Mnemonic, rt: Register, mm: Memory) -> Instruction {…}

    inst_none ¶
    Source

    inst_none :: proc "contextless" (m: Mnemonic) -> Instruction {…}

    inst_r ¶
    Source

    inst_r :: proc "contextless" (m: Mnemonic, r: Register) -> Instruction {…}

    inst_r_r ¶
    Source

    inst_r_r :: proc "contextless" (m: Mnemonic, rd, ra: Register) -> Instruction {…}

    inst_r_r_i ¶
    Source

    inst_r_r_i :: proc "contextless" (m: Mnemonic, rd, ra: Register, v: i64) -> Instruction {…}

    inst_r_r_r ¶
    Source

    inst_r_r_r :: proc "contextless" (m: Mnemonic, rd, ra, rb: Register) -> Instruction {…}

    inst_se_add ¶
    Source

    inst_se_add :: inst_se_add_r_r

    inst_se_add_r_r ¶
    Source

    inst_se_add_r_r :: proc "contextless" (rd: Register, r2: Register) -> Instruction {…}

    inst_se_addi ¶
    Source

    inst_se_addi :: inst_se_addi_r_imm

    inst_se_addi_r_imm ¶
    Source

    inst_se_addi_r_imm :: proc "contextless" (rd: Register, imm: i64) -> Instruction {…}

    inst_se_and ¶
    Source

    inst_se_and :: inst_se_and_r_r

    inst_se_and_dot ¶
    Source

    inst_se_and_dot :: inst_se_and_dot_r_r

    inst_se_and_dot_r_r ¶
    Source

    inst_se_and_dot_r_r :: proc "contextless" (rd: Register, r2: Register) -> Instruction {…}

    inst_se_and_r_r ¶
    Source

    inst_se_and_r_r :: proc "contextless" (rd: Register, r2: Register) -> Instruction {…}

    inst_se_andc ¶
    Source

    inst_se_andc :: inst_se_andc_r_r

    inst_se_andc_r_r ¶
    Source

    inst_se_andc_r_r :: proc "contextless" (rd: Register, r2: Register) -> Instruction {…}

    inst_se_andi ¶
    Source

    inst_se_andi :: inst_se_andi_r_imm

    inst_se_andi_r_imm ¶
    Source

    inst_se_andi_r_imm :: proc "contextless" (rd: Register, imm: i64) -> Instruction {…}

    inst_se_b ¶
    Source

    inst_se_b :: inst_se_b_rel

    inst_se_b_rel ¶
    Source

    inst_se_b_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_se_bc ¶
    Source

    inst_se_bc :: inst_se_bc_bo_crb_rel

    inst_se_bc_bo_crb_rel ¶
    Source

    inst_se_bc_bo_crb_rel :: proc "contextless" (imm: i64, imm2: i64, target: u32) -> Instruction {…}

    inst_se_bclri ¶
    Source

    inst_se_bclri :: inst_se_bclri_r_imm

    inst_se_bclri_r_imm ¶
    Source

    inst_se_bclri_r_imm :: proc "contextless" (rd: Register, imm: i64) -> Instruction {…}

    inst_se_bctr ¶
    Source

    inst_se_bctr :: inst_se_bctr_none

    inst_se_bctr_none ¶
    Source

    inst_se_bctr_none :: proc "contextless" () -> Instruction {…}

    inst_se_bctrl ¶
    Source

    inst_se_bctrl :: inst_se_bctrl_none

    inst_se_bctrl_none ¶
    Source

    inst_se_bctrl_none :: proc "contextless" () -> Instruction {…}

    inst_se_beq ¶
    Source

    inst_se_beq :: inst_se_beq_rel

    inst_se_beq_rel ¶
    Source

    inst_se_beq_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_se_bf ¶
    Source

    inst_se_bf :: inst_se_bf_rel

    inst_se_bf_rel ¶
    Source

    inst_se_bf_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_se_bge ¶
    Source

    inst_se_bge :: inst_se_bge_rel

    inst_se_bge_rel ¶
    Source

    inst_se_bge_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_se_bgeni ¶
    Source

    inst_se_bgeni :: inst_se_bgeni_r_imm

    inst_se_bgeni_r_imm ¶
    Source

    inst_se_bgeni_r_imm :: proc "contextless" (rd: Register, imm: i64) -> Instruction {…}

    inst_se_bgt ¶
    Source

    inst_se_bgt :: inst_se_bgt_rel

    inst_se_bgt_rel ¶
    Source

    inst_se_bgt_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_se_bl ¶
    Source

    inst_se_bl :: inst_se_bl_rel

    inst_se_bl_rel ¶
    Source

    inst_se_bl_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_se_ble ¶
    Source

    inst_se_ble :: inst_se_ble_rel

    inst_se_ble_rel ¶
    Source

    inst_se_ble_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_se_blr ¶
    Source

    inst_se_blr :: inst_se_blr_none

    inst_se_blr_none ¶
    Source

    inst_se_blr_none :: proc "contextless" () -> Instruction {…}

    inst_se_blrl ¶
    Source

    inst_se_blrl :: inst_se_blrl_none

    inst_se_blrl_none ¶
    Source

    inst_se_blrl_none :: proc "contextless" () -> Instruction {…}

    inst_se_blt ¶
    Source

    inst_se_blt :: inst_se_blt_rel

    inst_se_blt_rel ¶
    Source

    inst_se_blt_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_se_bmaski ¶
    Source

    inst_se_bmaski :: inst_se_bmaski_r_imm

    inst_se_bmaski_r_imm ¶
    Source

    inst_se_bmaski_r_imm :: proc "contextless" (rd: Register, imm: i64) -> Instruction {…}

    inst_se_bne ¶
    Source

    inst_se_bne :: inst_se_bne_rel

    inst_se_bne_rel ¶
    Source

    inst_se_bne_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_se_bng ¶
    Source

    inst_se_bng :: inst_se_bng_rel

    inst_se_bng_rel ¶
    Source

    inst_se_bng_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_se_bnl ¶
    Source

    inst_se_bnl :: inst_se_bnl_rel

    inst_se_bnl_rel ¶
    Source

    inst_se_bnl_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_se_bns ¶
    Source

    inst_se_bns :: inst_se_bns_rel

    inst_se_bns_rel ¶
    Source

    inst_se_bns_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_se_bnu ¶
    Source

    inst_se_bnu :: inst_se_bnu_rel

    inst_se_bnu_rel ¶
    Source

    inst_se_bnu_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_se_bseti ¶
    Source

    inst_se_bseti :: inst_se_bseti_r_imm

    inst_se_bseti_r_imm ¶
    Source

    inst_se_bseti_r_imm :: proc "contextless" (rd: Register, imm: i64) -> Instruction {…}

    inst_se_bso ¶
    Source

    inst_se_bso :: inst_se_bso_rel

    inst_se_bso_rel ¶
    Source

    inst_se_bso_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_se_bt ¶
    Source

    inst_se_bt :: inst_se_bt_rel

    inst_se_bt_rel ¶
    Source

    inst_se_bt_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_se_btsti ¶
    Source

    inst_se_btsti :: inst_se_btsti_r_imm

    inst_se_btsti_r_imm ¶
    Source

    inst_se_btsti_r_imm :: proc "contextless" (rd: Register, imm: i64) -> Instruction {…}

    inst_se_bun ¶
    Source

    inst_se_bun :: inst_se_bun_rel

    inst_se_bun_rel ¶
    Source

    inst_se_bun_rel :: proc "contextless" (target: u32) -> Instruction {…}

    inst_se_cmp ¶
    Source

    inst_se_cmp :: inst_se_cmp_r_r

    inst_se_cmp_r_r ¶
    Source

    inst_se_cmp_r_r :: proc "contextless" (rd: Register, r2: Register) -> Instruction {…}

    inst_se_cmph ¶
    Source

    inst_se_cmph :: inst_se_cmph_r_r

    inst_se_cmph_r_r ¶
    Source

    inst_se_cmph_r_r :: proc "contextless" (rd: Register, r2: Register) -> Instruction {…}

    inst_se_cmphl ¶
    Source

    inst_se_cmphl :: inst_se_cmphl_r_r

    inst_se_cmphl_r_r ¶
    Source

    inst_se_cmphl_r_r :: proc "contextless" (rd: Register, r2: Register) -> Instruction {…}

    inst_se_cmpi ¶
    Source

    inst_se_cmpi :: inst_se_cmpi_r_imm

    inst_se_cmpi_r_imm ¶
    Source

    inst_se_cmpi_r_imm :: proc "contextless" (rd: Register, imm: i64) -> Instruction {…}

    inst_se_cmpl ¶
    Source

    inst_se_cmpl :: inst_se_cmpl_r_r

    inst_se_cmpl_r_r ¶
    Source

    inst_se_cmpl_r_r :: proc "contextless" (rd: Register, r2: Register) -> Instruction {…}

    inst_se_cmpli ¶
    Source

    inst_se_cmpli :: inst_se_cmpli_r_imm

    inst_se_cmpli_r_imm ¶
    Source

    inst_se_cmpli_r_imm :: proc "contextless" (rd: Register, imm: i64) -> Instruction {…}

    inst_se_extsb ¶
    Source

    inst_se_extsb :: inst_se_extsb_r

    inst_se_extsb_r ¶
    Source

    inst_se_extsb_r :: proc "contextless" (rd: Register) -> Instruction {…}

    inst_se_extsh ¶
    Source

    inst_se_extsh :: inst_se_extsh_r

    inst_se_extsh_r ¶
    Source

    inst_se_extsh_r :: proc "contextless" (rd: Register) -> Instruction {…}

    inst_se_extzb ¶
    Source

    inst_se_extzb :: inst_se_extzb_r

    inst_se_extzb_r ¶
    Source

    inst_se_extzb_r :: proc "contextless" (rd: Register) -> Instruction {…}

    inst_se_extzh ¶
    Source

    inst_se_extzh :: inst_se_extzh_r

    inst_se_extzh_r ¶
    Source

    inst_se_extzh_r :: proc "contextless" (rd: Register) -> Instruction {…}

    inst_se_illegal ¶
    Source

    inst_se_illegal :: inst_se_illegal_none

    inst_se_illegal_none ¶
    Source

    inst_se_illegal_none :: proc "contextless" () -> Instruction {…}

    inst_se_isync ¶
    Source

    inst_se_isync :: inst_se_isync_none

    inst_se_isync_none ¶
    Source

    inst_se_isync_none :: proc "contextless" () -> Instruction {…}

    inst_se_lbz ¶
    Source

    inst_se_lbz :: inst_se_lbz_r_mem

    inst_se_lbz_r_mem ¶
    Source

    inst_se_lbz_r_mem :: proc "contextless" (rd: Register, mem: Memory) -> Instruction {…}

    inst_se_lhz ¶
    Source

    inst_se_lhz :: inst_se_lhz_r_mem

    inst_se_lhz_r_mem ¶
    Source

    inst_se_lhz_r_mem :: proc "contextless" (rd: Register, mem: Memory) -> Instruction {…}

    inst_se_li ¶
    Source

    inst_se_li :: inst_se_li_r_imm

    inst_se_li_r_imm ¶
    Source

    inst_se_li_r_imm :: proc "contextless" (rd: Register, imm: i64) -> Instruction {…}

    inst_se_lwz ¶
    Source

    inst_se_lwz :: inst_se_lwz_r_mem

    inst_se_lwz_r_mem ¶
    Source

    inst_se_lwz_r_mem :: proc "contextless" (rd: Register, mem: Memory) -> Instruction {…}

    inst_se_mfar ¶
    Source

    inst_se_mfar :: inst_se_mfar_r_r

    inst_se_mfar_r_r ¶
    Source

    inst_se_mfar_r_r :: proc "contextless" (rd: Register, r2: Register) -> Instruction {…}

    inst_se_mfctr ¶
    Source

    inst_se_mfctr :: inst_se_mfctr_r

    inst_se_mfctr_r ¶
    Source

    inst_se_mfctr_r :: proc "contextless" (rd: Register) -> Instruction {…}

    inst_se_mflr ¶
    Source

    inst_se_mflr :: inst_se_mflr_r

    inst_se_mflr_r ¶
    Source

    inst_se_mflr_r :: proc "contextless" (rd: Register) -> Instruction {…}

    inst_se_mr ¶
    Source

    inst_se_mr :: inst_se_mr_r_r

    inst_se_mr_r_r ¶
    Source

    inst_se_mr_r_r :: proc "contextless" (rd: Register, r2: Register) -> Instruction {…}

    inst_se_mtar ¶
    Source

    inst_se_mtar :: inst_se_mtar_r_r

    inst_se_mtar_r_r ¶
    Source

    inst_se_mtar_r_r :: proc "contextless" (rd: Register, r2: Register) -> Instruction {…}

    inst_se_mtctr ¶
    Source

    inst_se_mtctr :: inst_se_mtctr_r

    inst_se_mtctr_r ¶
    Source

    inst_se_mtctr_r :: proc "contextless" (rd: Register) -> Instruction {…}

    inst_se_mtlr ¶
    Source

    inst_se_mtlr :: inst_se_mtlr_r

    inst_se_mtlr_r ¶
    Source

    inst_se_mtlr_r :: proc "contextless" (rd: Register) -> Instruction {…}

    inst_se_mullw ¶
    Source

    inst_se_mullw :: inst_se_mullw_r_r

    inst_se_mullw_r_r ¶
    Source

    inst_se_mullw_r_r :: proc "contextless" (rd: Register, r2: Register) -> Instruction {…}

    inst_se_neg ¶
    Source

    inst_se_neg :: inst_se_neg_r

    inst_se_neg_r ¶
    Source

    inst_se_neg_r :: proc "contextless" (rd: Register) -> Instruction {…}

    inst_se_nop ¶
    Source

    inst_se_nop :: inst_se_nop_r_r

    inst_se_nop_r_r ¶
    Source

    inst_se_nop_r_r :: proc "contextless" (rd: Register, r2: Register) -> Instruction {…}

    inst_se_not ¶
    Source

    inst_se_not :: inst_se_not_r

    inst_se_not_r ¶
    Source

    inst_se_not_r :: proc "contextless" (rd: Register) -> Instruction {…}

    inst_se_or ¶
    Source

    inst_se_or :: inst_se_or_r_r

    inst_se_or_r_r ¶
    Source

    inst_se_or_r_r :: proc "contextless" (rd: Register, r2: Register) -> Instruction {…}

    inst_se_rfci ¶
    Source

    inst_se_rfci :: inst_se_rfci_none

    inst_se_rfci_none ¶
    Source

    inst_se_rfci_none :: proc "contextless" () -> Instruction {…}

    inst_se_rfdi ¶
    Source

    inst_se_rfdi :: inst_se_rfdi_none

    inst_se_rfdi_none ¶
    Source

    inst_se_rfdi_none :: proc "contextless" () -> Instruction {…}

    inst_se_rfgi ¶
    Source

    inst_se_rfgi :: inst_se_rfgi_none

    inst_se_rfgi_none ¶
    Source

    inst_se_rfgi_none :: proc "contextless" () -> Instruction {…}

    inst_se_rfi ¶
    Source

    inst_se_rfi :: inst_se_rfi_none

    inst_se_rfi_none ¶
    Source

    inst_se_rfi_none :: proc "contextless" () -> Instruction {…}

    inst_se_rfmci ¶
    Source

    inst_se_rfmci :: inst_se_rfmci_none

    inst_se_rfmci_none ¶
    Source

    inst_se_rfmci_none :: proc "contextless" () -> Instruction {…}

    inst_se_sc ¶
    Source

    inst_se_sc :: inst_se_sc_none

    inst_se_sc_none ¶
    Source

    inst_se_sc_none :: proc "contextless" () -> Instruction {…}

    inst_se_slw ¶
    Source

    inst_se_slw :: inst_se_slw_r_r

    inst_se_slw_r_r ¶
    Source

    inst_se_slw_r_r :: proc "contextless" (rd: Register, r2: Register) -> Instruction {…}

    inst_se_slwi ¶
    Source

    inst_se_slwi :: inst_se_slwi_r_imm

    inst_se_slwi_r_imm ¶
    Source

    inst_se_slwi_r_imm :: proc "contextless" (rd: Register, imm: i64) -> Instruction {…}

    inst_se_sraw ¶
    Source

    inst_se_sraw :: inst_se_sraw_r_r

    inst_se_sraw_r_r ¶
    Source

    inst_se_sraw_r_r :: proc "contextless" (rd: Register, r2: Register) -> Instruction {…}

    inst_se_srawi ¶
    Source

    inst_se_srawi :: inst_se_srawi_r_imm

    inst_se_srawi_r_imm ¶
    Source

    inst_se_srawi_r_imm :: proc "contextless" (rd: Register, imm: i64) -> Instruction {…}

    inst_se_srw ¶
    Source

    inst_se_srw :: inst_se_srw_r_r

    inst_se_srw_r_r ¶
    Source

    inst_se_srw_r_r :: proc "contextless" (rd: Register, r2: Register) -> Instruction {…}

    inst_se_srwi ¶
    Source

    inst_se_srwi :: inst_se_srwi_r_imm

    inst_se_srwi_r_imm ¶
    Source

    inst_se_srwi_r_imm :: proc "contextless" (rd: Register, imm: i64) -> Instruction {…}

    inst_se_stb ¶
    Source

    inst_se_stb :: inst_se_stb_r_mem

    inst_se_stb_r_mem ¶
    Source

    inst_se_stb_r_mem :: proc "contextless" (rd: Register, mem: Memory) -> Instruction {…}

    inst_se_sth ¶
    Source

    inst_se_sth :: inst_se_sth_r_mem

    inst_se_sth_r_mem ¶
    Source

    inst_se_sth_r_mem :: proc "contextless" (rd: Register, mem: Memory) -> Instruction {…}

    inst_se_stw ¶
    Source

    inst_se_stw :: inst_se_stw_r_mem

    inst_se_stw_r_mem ¶
    Source

    inst_se_stw_r_mem :: proc "contextless" (rd: Register, mem: Memory) -> Instruction {…}

    inst_se_sub ¶
    Source

    inst_se_sub :: inst_se_sub_r_r

    inst_se_sub_r_r ¶
    Source

    inst_se_sub_r_r :: proc "contextless" (rd: Register, r2: Register) -> Instruction {…}

    inst_se_subf ¶
    Source

    inst_se_subf :: inst_se_subf_r_r

    inst_se_subf_r_r ¶
    Source

    inst_se_subf_r_r :: proc "contextless" (rd: Register, r2: Register) -> Instruction {…}

    inst_se_subi ¶
    Source

    inst_se_subi :: inst_se_subi_r_imm

    inst_se_subi_dot ¶
    Source

    inst_se_subi_dot :: inst_se_subi_dot_r_imm

    inst_se_subi_dot_r_imm ¶
    Source

    inst_se_subi_dot_r_imm :: proc "contextless" (rd: Register, imm: i64) -> Instruction {…}

    inst_se_subi_r_imm ¶
    Source

    inst_se_subi_r_imm :: proc "contextless" (rd: Register, imm: i64) -> Instruction {…}

    mem_d ¶
    Source

    mem_d :: proc "contextless" (base: Register, disp: i64) -> Memory {…}

    mem_x ¶
    Source

    mem_x :: proc "contextless" (base, index: Register) -> Memory {…}

    mnemonic_to_string ¶
    Source

    mnemonic_to_string :: proc(m: Mnemonic, lowercase: bool = true, allocator := context.temp_allocator) -> string {…}

    op_imm ¶
    Source

    op_imm :: proc "contextless" (v: i64) -> Operand {…}

    op_label ¶
    Source

    op_label :: proc "contextless" (label_id: u32) -> Operand {…}

    op_mem ¶
    Source

    op_mem :: proc "contextless" (m: Memory) -> Operand {…}

    op_reg ¶
    Source

    op_reg :: proc "contextless" (r: Register) -> Operand {…}

    op_rel_offset ¶
    Source

    op_rel_offset :: proc "contextless" (off: i64) -> Operand {…}

    print ¶
    Source

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

    println ¶
    Source

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

    reg_class ¶
    Source

    reg_class :: proc "contextless" (r: Register) -> u16 {…}

    reg_hw ¶
    Source

    reg_hw :: proc "contextless" (r: Register) -> u16 {…}

    reg_is_cr ¶
    Source

    reg_is_cr :: proc "contextless" (r: Register) -> bool {…}

    reg_is_gpr ¶
    Source

    reg_is_gpr :: proc "contextless" (r: Register) -> bool {…}

    reg_is_spr ¶
    Source

    reg_is_spr :: proc "contextless" (r: Register) -> bool {…}

    sbprint ¶
    Source

    sbprint :: proc(
	sb:           ^strings.Builder, 
	instructions: []Instruction, 
	inst_info:    []Instruction_Info, 
	label_defs:   []rexcode_isa.Label_Definition, 
	tokens:       ^[dynamic]rexcode_isa.Token = nil, 
	options:      ^rexcode_isa.Print_Options = nil, 
	label_names:  ^map[u32]string = nil, 
) {…}

    sbprintln ¶
    Source

    sbprintln :: proc(
	sb:           ^strings.Builder, 
	instructions: []Instruction, 
	inst_info:    []Instruction_Info, 
	label_defs:   []rexcode_isa.Label_Definition, 
	tokens:       ^[dynamic]rexcode_isa.Token = nil, 
	options:      ^rexcode_isa.Print_Options = nil, 
	label_names:  ^map[u32]string = nil, 
) {…}

    spr_reg ¶
    Source

    spr_reg :: proc "contextless" (n: u16) -> Register {…}

    tprint ¶
    Source

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

    tprintln ¶
    Source

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

    wprint ¶
    Source

    wprint :: proc(
	w:            io.Stream, 
	instructions: []Instruction, 
	inst_info:    []Instruction_Info, 
	label_defs:   []rexcode_isa.Label_Definition, 
	tokens:       ^[dynamic]rexcode_isa.Token = nil, 
	options:      ^rexcode_isa.Print_Options = nil, 
	label_names:  ^map[u32]string = nil, 
) {…}

    wprintln ¶
    Source

    wprintln :: proc(
	w:            io.Stream, 
	instructions: []Instruction, 
	inst_info:    []Instruction_Info, 
	label_defs:   []rexcode_isa.Label_Definition, 
	tokens:       ^[dynamic]rexcode_isa.Token = nil, 
	options:      ^rexcode_isa.Print_Options = nil, 
	label_names:  ^map[u32]string = nil, 
) {…}

    write_operand ¶
    Source

    write_operand :: proc(
	sb:              ^strings.Builder, 
	op:              ^Operand, 
	inst_offset:     u32, 
	offset_to_label: ^map[u32]u32, 
	label_names:     ^map[u32]string, 
	opts:            ^rexcode_isa.Print_Options, 
) {…}

    write_register ¶
    Source

    write_register :: proc(sb: ^strings.Builder, r: Register, uppercase: bool) {…}

    Procedure Groups

    This section is empty.

    Source Files

    Generation Information

    Generated with odin version dev-2026-07 (vendor "odin") Windows_amd64 @ 2026-07-20 21:55:41.416066500 +0000 UTC