package core:rexcode/isa/mos65816

Source

Address_Mode :: enum u8 {
	DP, 
	DP_X, 
	DP_Y, 
	DP_IND, 
	DP_IND_X, 
	DP_IND_Y, 
	DP_IND_LONG, 
	DP_IND_LONG_Y, 
	ABS, 
	ABS_X, 
	ABS_Y, 
	ABS_IND, 
	ABS_IND_LONG, 
	ABS_IND_X, 
	LONG, 
	LONG_X, 
	SR, 
	SR_IND_Y, 
}

Assumed_State :: struct {
	m: bool,
	// M=1 (8-bit A/memory)         M=0 (16-bit A/memory)
	x: bool,
	// X=1 (8-bit X/Y)              X=0 (16-bit X/Y)
	e: bool,
}

Decode_Entry :: struct #packed {
	mnemonic: Mnemonic,
	// 2
	ops:      [2]Operand_Type,
	// 2
	enc:      [2]Operand_Encoding,
	// 2
	opcode:   u8,
	// 1
	length:   u8,
	// 1
	flags:    Encoding_Flags,
}

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

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

Encoding :: struct #packed {
	mnemonic: Mnemonic,
	// 2
	ops:      [4]Operand_Type,
	// 4
	enc:      [4]Operand_Encoding,
	// 4
	opcode:   u8,
	// 1
	length:   u8,
	// 1
	flags:    Encoding_Flags,
}

Encoding_Flags :: distinct bit_field u8 {
	branch:      bool | 1,
	cond_branch: bool | 1,
	page_cross:  bool | 1,
	_:           u8 | 5,
}

Error :: rexcode_isa.Error

Error_Code :: rexcode_isa.Error_Code

GP :: enum u8 {
	A = 0, 
	X = 1, 
	Y = 2, 
	S = 3, 
	D = 4, 
}

Instruction :: struct #packed {
	ops:           [2]Operand `fmt:"v,operand_count"`,
	// 20 bytes (only MVN/MVP use 2; rest use 0 or 1)
	mnemonic:      Mnemonic,
	// 2
	operand_count: u8,
	// 1
	flags:         Instruction_Flags,
	// 1
	length:        u8,
	// 1
	_:             [7]u8,
}

Instruction_Flags :: distinct bit_field u8 {
	_: u8 | 8,
}

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

Label_Definition :: rexcode_isa.Label_Definition

Label_Map :: rexcode_isa.Label_Map

Memory :: distinct bit_field u32 {
	address: u32 | 24,
	mode:    Address_Mode | 8,
}

Mnemonic :: enum u16 {
	INVALID = 0, 
	// 6502 core
	ADC, 
	AND, 
	ASL, 
	BIT, 
	CMP, 
	CPX, 
	CPY, 
	DEC, 
	DEX, 
	DEY, 
	EOR, 
	INC, 
	INX, 
	INY, 
	LSR, 
	ORA, 
	ROL, 
	ROR, 
	SBC, 
	LDA, 
	LDX, 
	LDY, 
	STA, 
	STX, 
	STY, 
	TAX, 
	TAY, 
	TSX, 
	TXA, 
	TXS, 
	TYA, 
	PHA, 
	PHP, 
	PLA, 
	PLP, 
	JMP, 
	JSR, 
	RTI, 
	RTS, 
	BRK, 
	NOP, 
	// Branches
	BCC, 
	BCS, 
	BEQ, 
	BMI, 
	BNE, 
	BPL, 
	BVC, 
	BVS, 
	// Flags
	CLC, 
	CLD, 
	CLI, 
	CLV, 
	SEC, 
	SED, 
	SEI, 
	// 65C02 additions (carry over to 65816)
	BRA, 
	STZ, 
	TRB, 
	TSB, 
	PHX, 
	PHY, 
	PLX, 
	PLY, 
	STP, 
	WAI, 
	// 65816 new
	BRL,         // 16-bit relative branch
	COP,         // co-processor enable (interrupt)
	JML,         // jump long (24-bit)
	JSL,         // jump-to-subroutine long (24-bit)
	MVN, 
	MVP,         // block move negative / positive
	PEA,         // push effective absolute address
	PEI,         // push effective indirect address
	PER,         // push effective PC-relative
	PHB, 
	PHD, 
	PHK,         // push DBR / D / PBR
	PLB, 
	PLD,         // pull  DBR / D
	REP, 
	SEP,         // reset / set status bits (immediate mask)
	RTL,         // return long
	TCD, 
	TDC,         // A <-> D
	TCS, 
	TSC,         // A <-> S
	TXY, 
	TYX,         // X <-> Y
	WDM,         // reserved (assembles as 2-byte no-op)
	XBA,         // exchange A halves (B <-> A)
	XCE,         // exchange Carry and Emulation flags
}

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

Operand_Encoding :: enum u8 {
	NONE, 
	IMPL, 
	BYTE_1_IMM,  // 8-bit at offset 1
	WORD_1_IMM,  // 16-bit LE at offset 1
	BYTE_1_ADDR, // 8-bit zero/direct page address at offset 1
	WORD_1_ADDR, // 16-bit LE absolute at offset 1
	LONG_1_ADDR, // 24-bit LE long at offset 1
	BYTE_1_REL,  // signed 8-bit PC-rel at offset 1
	WORD_1_REL,  // signed 16-bit PC-rel at offset 1
	BYTE_1_BANK, // dst bank byte at offset 1 (MVN/MVP)
	BYTE_2_BANK, // src bank byte at offset 2 (MVN/MVP)
}

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 :: enum u8 {
	NONE, 
	A_IMPL,            // accumulator -- no operand bytes
	// Immediates
	IMM_8,             // always 8-bit (COP, REP, SEP, WDM, BRK signature, ...)
	IMM_M8,            // 8-bit when M=1
	IMM_M16,           // 16-bit when M=0
	IMM_X8,            // 8-bit when X=1
	IMM_X16,           // 16-bit when X=0
	// Branches
	REL,               // signed 8-bit PC-rel
	REL_LONG,          // signed 16-bit PC-rel (BRL, PER)
	// Memory (one per addressing mode)
	MEM_DP, 
	MEM_DP_X, 
	MEM_DP_Y, 
	MEM_DP_IND, 
	MEM_DP_IND_X, 
	MEM_DP_IND_Y, 
	MEM_DP_IND_LONG, 
	MEM_DP_IND_LONG_Y, 
	MEM_ABS, 
	MEM_ABS_X, 
	MEM_ABS_Y, 
	MEM_ABS_IND, 
	MEM_ABS_IND_LONG, 
	MEM_ABS_IND_X, 
	MEM_LONG, 
	MEM_LONG_X, 
	MEM_SR, 
	MEM_SR_IND_Y, 
	// Block move: two 8-bit bank operands. Source order in the syntax
	// (MVN src, dst) is the REVERSE of the byte order in the encoding.
	BANK_SRC, 
	BANK_DST, 
}

Print_Options :: rexcode_isa.Print_Options

Print_Result :: rexcode_isa.Print_Result

Register :: distinct u16

Relocation :: struct #packed {
	offset:   u32,
	label_id: u32,
	addend:   i32,
	type:     Relocation_Type,
	size:     u8,
	inst_idx: u16,
}

Relocation_Type :: enum u8 {
	NONE  = 0, 
	ABS16, 
	ABS24, 
	REL8, 
	REL16, 
}

Token :: rexcode_isa.Token

Token_Kind :: rexcode_isa.Token_Kind

A :: Register(REG_GP | 0)

D :: Register(REG_GP | 4)

DBR :: Register(REG_SYS | 0)

DEFAULT_PRINT_OPTIONS: rexcode_isa.Print_Options : isa.DEFAULT_PRINT_OPTIONS

EMULATION :: Assumed_State{m = true, x = true, e = true}

LABEL_UNDEFINED: rexcode_isa.Label_Definition : isa.LABEL_UNDEFINED

MAX_INST_SIZE :: 4

NATIVE_16 :: Assumed_State{m = false, x = false, e = false}

NATIVE_8 :: Assumed_State{m = true, x = true, e = false}

NONE :: Register(0xFFFF)

P :: Register(REG_SYS | 2)

PBR :: Register(REG_SYS | 1)

PC :: Register(REG_SYS | 3)

REG_GP :: 0x0100

REG_NONE :: 0x0000

REG_SYS :: 0x0200

S :: Register(REG_GP | 3)

X :: Register(REG_GP | 1)

Y :: Register(REG_GP | 2)

@(rodata)
DECODE_ENTRIES: []Decode_Entry = …

@(rodata)
DECODE_INDEX_OPCODE: []Decode_Index = …

@(rodata)
ENCODE_FORMS: []Encoding = …

@(rodata)
ENCODE_RUNS: []Encode_Run = …

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

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

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

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

emit_adc_imm16 :: proc(instructions: ^[dynamic]Instruction, imm: i16) {…}

emit_adc_imm8 :: proc(instructions: ^[dynamic]Instruction, imm: i8) {…}

emit_adc_mem :: proc(instructions: ^[dynamic]Instruction, m: Memory) {…}

emit_and_imm16 :: proc(instructions: ^[dynamic]Instruction, imm: i16) {…}

emit_and_imm8 :: proc(instructions: ^[dynamic]Instruction, imm: i8) {…}

emit_and_mem :: proc(instructions: ^[dynamic]Instruction, m: Memory) {…}

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

emit_asl_mem :: proc(instructions: ^[dynamic]Instruction, m: Memory) {…}

emit_bcc :: emit_bcc_rel

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

emit_bcs :: emit_bcs_rel

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

emit_beq :: emit_beq_rel

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

emit_bit_imm16 :: proc(instructions: ^[dynamic]Instruction, imm: i16) {…}

emit_bit_imm8 :: proc(instructions: ^[dynamic]Instruction, imm: i8) {…}

emit_bit_mem :: proc(instructions: ^[dynamic]Instruction, m: Memory) {…}

emit_bmi :: emit_bmi_rel

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

emit_bne :: emit_bne_rel

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

emit_bpl :: emit_bpl_rel

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

emit_bra :: emit_bra_rel

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

emit_brk :: emit_brk_imm8

emit_brk_imm8 :: proc(instructions: ^[dynamic]Instruction, imm: i8) {…}

emit_brl :: emit_brl_rel_long

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

emit_bvc :: emit_bvc_rel

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

emit_bvs :: emit_bvs_rel

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

emit_clc :: emit_clc_none

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

emit_cld :: emit_cld_none

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

emit_cli :: emit_cli_none

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

emit_clv :: emit_clv_none

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

emit_cmp_imm16 :: proc(instructions: ^[dynamic]Instruction, imm: i16) {…}

emit_cmp_imm8 :: proc(instructions: ^[dynamic]Instruction, imm: i8) {…}

emit_cmp_mem :: proc(instructions: ^[dynamic]Instruction, m: Memory) {…}

emit_cop :: emit_cop_imm8

emit_cop_imm8 :: proc(instructions: ^[dynamic]Instruction, imm: i8) {…}

emit_cpx_imm16 :: proc(instructions: ^[dynamic]Instruction, imm: i16) {…}

emit_cpx_imm8 :: proc(instructions: ^[dynamic]Instruction, imm: i8) {…}

emit_cpx_mem :: proc(instructions: ^[dynamic]Instruction, m: Memory) {…}

emit_cpy_imm16 :: proc(instructions: ^[dynamic]Instruction, imm: i16) {…}

emit_cpy_imm8 :: proc(instructions: ^[dynamic]Instruction, imm: i8) {…}

emit_cpy_mem :: proc(instructions: ^[dynamic]Instruction, m: Memory) {…}

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

emit_dec_mem :: proc(instructions: ^[dynamic]Instruction, m: Memory) {…}

emit_dex :: emit_dex_none

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

emit_dey :: emit_dey_none

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

emit_eor_imm16 :: proc(instructions: ^[dynamic]Instruction, imm: i16) {…}

emit_eor_imm8 :: proc(instructions: ^[dynamic]Instruction, imm: i8) {…}

emit_eor_mem :: proc(instructions: ^[dynamic]Instruction, m: Memory) {…}

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

emit_inc_mem :: proc(instructions: ^[dynamic]Instruction, m: Memory) {…}

emit_inx :: emit_inx_none

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

emit_iny :: emit_iny_none

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

emit_jml :: emit_jml_mem

emit_jml_mem :: proc(instructions: ^[dynamic]Instruction, m: Memory) {…}

emit_jmp :: emit_jmp_mem

emit_jmp_mem :: proc(instructions: ^[dynamic]Instruction, m: Memory) {…}

emit_jsl :: emit_jsl_mem

emit_jsl_mem :: proc(instructions: ^[dynamic]Instruction, m: Memory) {…}

emit_jsr :: emit_jsr_mem

emit_jsr_mem :: proc(instructions: ^[dynamic]Instruction, m: Memory) {…}

emit_lda_imm16 :: proc(instructions: ^[dynamic]Instruction, imm: i16) {…}

emit_lda_imm8 :: proc(instructions: ^[dynamic]Instruction, imm: i8) {…}

emit_lda_mem :: proc(instructions: ^[dynamic]Instruction, m: Memory) {…}

emit_ldx_imm16 :: proc(instructions: ^[dynamic]Instruction, imm: i16) {…}

emit_ldx_imm8 :: proc(instructions: ^[dynamic]Instruction, imm: i8) {…}

emit_ldx_mem :: proc(instructions: ^[dynamic]Instruction, m: Memory) {…}

emit_ldy_imm16 :: proc(instructions: ^[dynamic]Instruction, imm: i16) {…}

emit_ldy_imm8 :: proc(instructions: ^[dynamic]Instruction, imm: i8) {…}

emit_ldy_mem :: proc(instructions: ^[dynamic]Instruction, m: Memory) {…}

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

emit_lsr_mem :: proc(instructions: ^[dynamic]Instruction, m: Memory) {…}

emit_mvn :: emit_mvn_banks

emit_mvn_banks :: proc(instructions: ^[dynamic]Instruction, src_bank, dst_bank: u8) {…}

emit_mvp :: emit_mvp_banks

emit_mvp_banks :: proc(instructions: ^[dynamic]Instruction, src_bank, dst_bank: u8) {…}

emit_nop :: emit_nop_none

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

emit_ora_imm16 :: proc(instructions: ^[dynamic]Instruction, imm: i16) {…}

emit_ora_imm8 :: proc(instructions: ^[dynamic]Instruction, imm: i8) {…}

emit_ora_mem :: proc(instructions: ^[dynamic]Instruction, m: Memory) {…}

emit_pea :: emit_pea_mem

emit_pea_mem :: proc(instructions: ^[dynamic]Instruction, m: Memory) {…}

emit_pei :: emit_pei_mem

emit_pei_mem :: proc(instructions: ^[dynamic]Instruction, m: Memory) {…}

emit_per :: emit_per_rel_long

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

emit_pha :: emit_pha_none

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

emit_phb :: emit_phb_none

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

emit_phd :: emit_phd_none

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

emit_phk :: emit_phk_none

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

emit_php :: emit_php_none

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

emit_phx :: emit_phx_none

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

emit_phy :: emit_phy_none

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

emit_pla :: emit_pla_none

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

emit_plb :: emit_plb_none

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

emit_pld :: emit_pld_none

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

emit_plp :: emit_plp_none

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

emit_plx :: emit_plx_none

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

emit_ply :: emit_ply_none

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

emit_rep :: emit_rep_imm8

emit_rep_imm8 :: proc(instructions: ^[dynamic]Instruction, imm: i8) {…}

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

emit_rol_mem :: proc(instructions: ^[dynamic]Instruction, m: Memory) {…}

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

emit_ror_mem :: proc(instructions: ^[dynamic]Instruction, m: Memory) {…}

emit_rti :: emit_rti_none

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

emit_rtl :: emit_rtl_none

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

emit_rts :: emit_rts_none

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

emit_sbc_imm16 :: proc(instructions: ^[dynamic]Instruction, imm: i16) {…}

emit_sbc_imm8 :: proc(instructions: ^[dynamic]Instruction, imm: i8) {…}

emit_sbc_mem :: proc(instructions: ^[dynamic]Instruction, m: Memory) {…}

emit_sec :: emit_sec_none

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

emit_sed :: emit_sed_none

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

emit_sei :: emit_sei_none

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

emit_sep :: emit_sep_imm8

emit_sep_imm8 :: proc(instructions: ^[dynamic]Instruction, imm: i8) {…}

emit_sta :: emit_sta_mem

emit_sta_mem :: proc(instructions: ^[dynamic]Instruction, m: Memory) {…}

emit_stp :: emit_stp_none

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

emit_stx :: emit_stx_mem

emit_stx_mem :: proc(instructions: ^[dynamic]Instruction, m: Memory) {…}

emit_sty :: emit_sty_mem

emit_sty_mem :: proc(instructions: ^[dynamic]Instruction, m: Memory) {…}

emit_stz :: emit_stz_mem

emit_stz_mem :: proc(instructions: ^[dynamic]Instruction, m: Memory) {…}

emit_tax :: emit_tax_none

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

emit_tay :: emit_tay_none

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

emit_tcd :: emit_tcd_none

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

emit_tcs :: emit_tcs_none

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

emit_tdc :: emit_tdc_none

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

emit_trb :: emit_trb_mem

emit_trb_mem :: proc(instructions: ^[dynamic]Instruction, m: Memory) {…}

emit_tsb :: emit_tsb_mem

emit_tsb_mem :: proc(instructions: ^[dynamic]Instruction, m: Memory) {…}

emit_tsc :: emit_tsc_none

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

emit_tsx :: emit_tsx_none

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

emit_txa :: emit_txa_none

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

emit_txs :: emit_txs_none

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

emit_txy :: emit_txy_none

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

emit_tya :: emit_tya_none

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

emit_tyx :: emit_tyx_none

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

emit_wai :: emit_wai_none

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

emit_wdm :: emit_wdm_imm8

emit_wdm_imm8 :: proc(instructions: ^[dynamic]Instruction, imm: i8) {…}

emit_xba :: emit_xba_none

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

emit_xce :: emit_xce_none

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

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 :: proc "contextless" (instructions: []Instruction) -> int {…}

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

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

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 :: 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_a :: proc "contextless" (m: Mnemonic) -> Instruction {…}

inst_adc_imm16 :: proc "contextless" (imm: i16) -> Instruction {…}

inst_adc_imm8 :: proc "contextless" (imm: i8) -> Instruction {…}

inst_adc_mem :: proc "contextless" (m: Memory) -> Instruction {…}

inst_and_imm16 :: proc "contextless" (imm: i16) -> Instruction {…}

inst_and_imm8 :: proc "contextless" (imm: i8) -> Instruction {…}

inst_and_mem :: proc "contextless" (m: Memory) -> Instruction {…}

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

inst_asl_mem :: proc "contextless" (m: Memory) -> Instruction {…}

inst_bcc :: inst_bcc_rel

inst_bcc_rel :: proc "contextless" (label: u32) -> Instruction {…}

inst_bcs :: inst_bcs_rel

inst_bcs_rel :: proc "contextless" (label: u32) -> Instruction {…}

inst_beq :: inst_beq_rel

inst_beq_rel :: proc "contextless" (label: u32) -> Instruction {…}

inst_bit_imm16 :: proc "contextless" (imm: i16) -> Instruction {…}

inst_bit_imm8 :: proc "contextless" (imm: i8) -> Instruction {…}

inst_bit_mem :: proc "contextless" (m: Memory) -> Instruction {…}

inst_block_move :: proc "contextless" (m: Mnemonic, src_bank, dst_bank: u8) -> Instruction {…}

inst_bmi :: inst_bmi_rel

inst_bmi_rel :: proc "contextless" (label: u32) -> Instruction {…}

inst_bne :: inst_bne_rel

inst_bne_rel :: proc "contextless" (label: u32) -> Instruction {…}

inst_bpl :: inst_bpl_rel

inst_bpl_rel :: proc "contextless" (label: u32) -> Instruction {…}

inst_bra :: inst_bra_rel

inst_bra_rel :: proc "contextless" (label: u32) -> Instruction {…}

inst_brk :: inst_brk_imm8

inst_brk_imm8 :: proc "contextless" (imm: i8) -> Instruction {…}

inst_brl :: inst_brl_rel_long

inst_brl_rel_long :: proc "contextless" (label: u32) -> Instruction {…}

inst_bvc :: inst_bvc_rel

inst_bvc_rel :: proc "contextless" (label: u32) -> Instruction {…}

inst_bvs :: inst_bvs_rel

inst_bvs_rel :: proc "contextless" (label: u32) -> Instruction {…}

inst_clc :: inst_clc_none

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

inst_cld :: inst_cld_none

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

inst_cli :: inst_cli_none

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

inst_clv :: inst_clv_none

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

inst_cmp_imm16 :: proc "contextless" (imm: i16) -> Instruction {…}

inst_cmp_imm8 :: proc "contextless" (imm: i8) -> Instruction {…}

inst_cmp_mem :: proc "contextless" (m: Memory) -> Instruction {…}

inst_cop :: inst_cop_imm8

inst_cop_imm8 :: proc "contextless" (imm: i8) -> Instruction {…}

inst_cpx_imm16 :: proc "contextless" (imm: i16) -> Instruction {…}

inst_cpx_imm8 :: proc "contextless" (imm: i8) -> Instruction {…}

inst_cpx_mem :: proc "contextless" (m: Memory) -> Instruction {…}

inst_cpy_imm16 :: proc "contextless" (imm: i16) -> Instruction {…}

inst_cpy_imm8 :: proc "contextless" (imm: i8) -> Instruction {…}

inst_cpy_mem :: proc "contextless" (m: Memory) -> Instruction {…}

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

inst_dec_mem :: proc "contextless" (m: Memory) -> Instruction {…}

inst_dex :: inst_dex_none

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

inst_dey :: inst_dey_none

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

inst_eor_imm16 :: proc "contextless" (imm: i16) -> Instruction {…}

inst_eor_imm8 :: proc "contextless" (imm: i8) -> Instruction {…}

inst_eor_mem :: proc "contextless" (m: Memory) -> Instruction {…}

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

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

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

inst_inc_mem :: proc "contextless" (m: Memory) -> Instruction {…}

inst_inx :: inst_inx_none

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

inst_iny :: inst_iny_none

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

inst_jml :: inst_jml_mem

inst_jml_mem :: proc "contextless" (m: Memory) -> Instruction {…}

inst_jmp :: inst_jmp_mem

inst_jmp_mem :: proc "contextless" (m: Memory) -> Instruction {…}

inst_jsl :: inst_jsl_mem

inst_jsl_mem :: proc "contextless" (m: Memory) -> Instruction {…}

inst_jsr :: inst_jsr_mem

inst_jsr_mem :: proc "contextless" (m: Memory) -> Instruction {…}

inst_lda_imm16 :: proc "contextless" (imm: i16) -> Instruction {…}

inst_lda_imm8 :: proc "contextless" (imm: i8) -> Instruction {…}

inst_lda_mem :: proc "contextless" (m: Memory) -> Instruction {…}

inst_ldx_imm16 :: proc "contextless" (imm: i16) -> Instruction {…}

inst_ldx_imm8 :: proc "contextless" (imm: i8) -> Instruction {…}

inst_ldx_mem :: proc "contextless" (m: Memory) -> Instruction {…}

inst_ldy_imm16 :: proc "contextless" (imm: i16) -> Instruction {…}

inst_ldy_imm8 :: proc "contextless" (imm: i8) -> Instruction {…}

inst_ldy_mem :: proc "contextless" (m: Memory) -> Instruction {…}

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

inst_lsr_mem :: proc "contextless" (m: Memory) -> Instruction {…}

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

inst_mvn :: inst_mvn_banks

inst_mvn_banks :: proc "contextless" (src_bank, dst_bank: u8) -> Instruction {…}

inst_mvp :: inst_mvp_banks

inst_mvp_banks :: proc "contextless" (src_bank, dst_bank: u8) -> Instruction {…}

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

inst_nop :: inst_nop_none

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

inst_ora_imm16 :: proc "contextless" (imm: i16) -> Instruction {…}

inst_ora_imm8 :: proc "contextless" (imm: i8) -> Instruction {…}

inst_ora_mem :: proc "contextless" (m: Memory) -> Instruction {…}

inst_pea :: inst_pea_mem

inst_pea_mem :: proc "contextless" (m: Memory) -> Instruction {…}

inst_pei :: inst_pei_mem

inst_pei_mem :: proc "contextless" (m: Memory) -> Instruction {…}

inst_per :: inst_per_rel_long

inst_per_rel_long :: proc "contextless" (label: u32) -> Instruction {…}

inst_pha :: inst_pha_none

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

inst_phb :: inst_phb_none

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

inst_phd :: inst_phd_none

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

inst_phk :: inst_phk_none

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

inst_php :: inst_php_none

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

inst_phx :: inst_phx_none

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

inst_phy :: inst_phy_none

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

inst_pla :: inst_pla_none

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

inst_plb :: inst_plb_none

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

inst_pld :: inst_pld_none

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

inst_plp :: inst_plp_none

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

inst_plx :: inst_plx_none

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

inst_ply :: inst_ply_none

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

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

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

inst_rep :: inst_rep_imm8

inst_rep_imm8 :: proc "contextless" (imm: i8) -> Instruction {…}

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

inst_rol_mem :: proc "contextless" (m: Memory) -> Instruction {…}

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

inst_ror_mem :: proc "contextless" (m: Memory) -> Instruction {…}

inst_rti :: inst_rti_none

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

inst_rtl :: inst_rtl_none

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

inst_rts :: inst_rts_none

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

inst_sbc_imm16 :: proc "contextless" (imm: i16) -> Instruction {…}

inst_sbc_imm8 :: proc "contextless" (imm: i8) -> Instruction {…}

inst_sbc_mem :: proc "contextless" (m: Memory) -> Instruction {…}