package core:rexcode/isa/mos6502

Source

Address_Mode :: enum u8 {
	ZP,        // $nn
	ZP_X,      // $nn,X
	ZP_Y,      // $nn,Y
	ABS,       // $nnnn
	ABS_X,     // $nnnn,X
	ABS_Y,     // $nnnn,Y
	IND,       // ($nnnn) -- JMP only
	IND_X,     // ($nn,X)
	IND_Y,     // ($nn),Y
	IND_ZP,    // ($nn) -- 65C02
	IND_ABS_X, // ($nnnn,X) -- 65C02 JMP only
}

CPU :: enum u8 {
	NMOS, 
	NMOS_UNDOC, 
	CMOS_65C02, 
	HUC6280, 
}

Decode_Entry :: struct #packed {
	mnemonic: Mnemonic,
	// 2
	ops:      [3]Operand_Type,
	// 3
	enc:      [3]Operand_Encoding,
	// 3
	opcode:   u8,
	// 1
	length:   u8,
	// 1
	cpu:      CPU,
	// 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
	cpu:      CPU,
	// 1
	flags:    Encoding_Flags,
}

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

Error :: rexcode_isa.Error

Error_Code :: rexcode_isa.Error_Code

GP :: enum u8 {
	A = 0, 
	X = 1, 
	Y = 2, 
}

Instruction :: struct #packed {
	ops:           [3]Operand `fmt:"v,operand_count"`,
	// 30 bytes
	mnemonic:      Mnemonic,
	// 2
	operand_count: u8,
	// 1
	flags:         Instruction_Flags,
	// 1
	length:        u8,
	// 1 (filled by decoder; 1..7)
	_:             [1]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 :: struct #packed {
	address: u16,
	mode:    Address_Mode,
	_:       u8,
}

Mnemonic :: enum u16 {
	INVALID  = 0, 
	// Arithmetic / logical
	ADC, 
	AND, 
	ASL, 
	BIT, 
	CMP, 
	CPX, 
	CPY, 
	DEC, 
	DEX, 
	DEY, 
	EOR, 
	INC, 
	INX, 
	INY, 
	LSR, 
	ORA, 
	ROL, 
	ROR, 
	SBC, 
	// Branches
	BCC, 
	BCS, 
	BEQ, 
	BMI, 
	BNE, 
	BPL, 
	BVC, 
	BVS, 
	// Jumps / subroutines / interrupts
	JMP, 
	JSR, 
	RTI, 
	RTS, 
	BRK, 
	// Flag ops
	CLC, 
	CLD, 
	CLI, 
	CLV, 
	SEC, 
	SED, 
	SEI, 
	// Loads / stores
	LDA, 
	LDX, 
	LDY, 
	STA, 
	STX, 
	STY, 
	// Stack / transfer
	PHA, 
	PHP, 
	PLA, 
	PLP, 
	TAX, 
	TAY, 
	TSX, 
	TXA, 
	TXS, 
	TYA, 
	// NOP
	NOP, 
	LAX,          // LDA + LDX (load A and X from memory)
	SAX_NMOS,     // store A AND X to memory (also called AAX / AXS-undoc)
	DCP,          // DEC + CMP (memory)
	ISC,          // INC + SBC (also ISB)
	RLA,          // ROL + AND
	RRA,          // ROR + ADC
	SLO,          // ASL + ORA
	SRE,          // LSR + EOR
	ALR,          // AND #imm + LSR A
	ANC,          // AND #imm with carry from N
	ARR,          // AND #imm + ROR A
	AXS,          // X = (A AND X) - imm  (also SBX)
	LAS,          // LDA / TSX / AND with stack pointer
	ANE,          // A = (A | $EE) AND X AND imm  -- unstable (also XAA)
	LXA,          // A = X = (A | $EE) AND imm    -- unstable
	SHA,          // store A AND X AND high+1
	SHX,          // store X AND high+1
	SHY,          // store Y AND high+1
	TAS,          // S = A AND X; store S AND high+1
	JAM,          // halt the CPU (also KIL / HLT)
	USBC,         // same as SBC #imm but at $EB (an undocumented alias)
	DOP,          // double NOP (skips one operand byte)
	TOP,          // triple NOP (skips two operand bytes)
	BRA,          // branch always
	INA,          // INC A
	DEA,          // DEC A
	PHX, 
	PHY, 
	PLX, 
	PLY, 
	STZ,          // store zero
	TRB, 
	TSB,          // test-and-reset / test-and-set bits
	STP, 
	WAI,          // WDC: stop, wait-for-interrupt
	// 65C02 Rockwell bit ops -- 32 distinct opcodes
	RMB0, 
	RMB1, 
	RMB2, 
	RMB3, 
	RMB4, 
	RMB5, 
	RMB6, 
	RMB7, 
	SMB0, 
	SMB1, 
	SMB2, 
	SMB3, 
	SMB4, 
	SMB5, 
	SMB6, 
	SMB7, 
	BBR0, 
	BBR1, 
	BBR2, 
	BBR3, 
	BBR4, 
	BBR5, 
	BBR6, 
	BBR7, 
	BBS0, 
	BBS1, 
	BBS2, 
	BBS3, 
	BBS4, 
	BBS5, 
	BBS6, 
	BBS7, 
	SXY,          // swap X, Y
	SAX,          // swap A, X   (NB: distinct from undocumented NMOS SAX_NMOS)
	SAY,          // swap A, Y
	CLA, 
	CLX, 
	CLY,          // clear A / X / Y
	CSH, 
	CSL,          // CPU speed high / low (7.16 MHz vs 1.79 MHz)
	SET,          // set T flag (next op uses zp address as accumulator)
	ST0, 
	ST1, 
	ST2,          // store immediate to MMR0/1/2
	TAM, 
	TMA,          // transfer A to/from MMR (immediate-selected)
	TST,          // bit test of immediate against memory
	BSR,          // branch to subroutine (PC-relative)
	// HuC6280 block transfer instructions (7-byte encoding)
	//   src(2) -> dst(2), len(2) bytes
	TII,          // transfer increment-increment   (memcpy ascending)
	TDD,          // transfer decrement-decrement   (memcpy descending)
	TIN,          // transfer increment-no-change   (fill from src)
	TIA,          // transfer increment-alternate   (interleaved)
	TAI,          // transfer alternate-increment   (interleaved)
}

Operand :: struct #packed {
	using _: struct #raw_union {
		reg:       Register,
		// 2 bytes
		mem:       Memory,
		// 4 bytes
		immediate: i64,
		// 8 bytes
		relative:  i64,
	},
	kind: Operand_Kind,
	// 1
	size: u8,
}

Operand_Encoding :: enum u8 {
	NONE, 
	IMPL,        // implicit / accumulator -- no bytes emitted
	BYTE_1_IMM,  // 8-bit immediate at offset 1
	BYTE_1_ADDR, // 8-bit zero-page address at offset 1
	BYTE_1_REL,  // signed 8-bit PC-rel at offset 1
	WORD_1_ADDR, // 16-bit little-endian absolute at offset 1
	BYTE_2_REL,  // signed 8-bit PC-rel at offset 2 (BBR/BBS)
	WORD_1,      // 16-bit LE at offset 1 (HuC block xfer src)
	WORD_3,      // 16-bit LE at offset 3 (HuC block xfer dst)
	WORD_5,      // 16-bit LE at offset 5 (HuC block xfer len)
	BYTE_2_ADDR, // 8-bit zero-page address at offset 2 (HuC TST # zp)
	WORD_2_ADDR, // 16-bit LE absolute at offset 2 (HuC TST # abs)
}

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 (e.g. ROL A) -- no operand bytes encoded
	IMM_8,         // #$nn
	REL,           // signed byte PC-rel branch target
	MEM_ZP,        // $nn
	MEM_ZP_X,      // $nn,X
	MEM_ZP_Y,      // $nn,Y
	MEM_ABS,       // $nnnn
	MEM_ABS_X,     // $nnnn,X
	MEM_ABS_Y,     // $nnnn,Y
	MEM_IND,       // ($nnnn) -- NMOS/65C02 JMP only
	MEM_IND_X,     // ($nn,X)
	MEM_IND_Y,     // ($nn),Y
	MEM_IND_ZP,    // ($nn) -- 65C02
	MEM_IND_ABS_X, // ($nnnn,X) -- 65C02 JMP only
	IMM_16,        // unsigned 16-bit literal (HuC6280 block xfer operands)
}

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, 
	REL8, 
}

Token :: rexcode_isa.Token

Token_Kind :: rexcode_isa.Token_Kind

A :: Register(REG_GP | 0)

DEFAULT_PRINT_OPTIONS: rexcode_isa.Print_Options : isa.DEFAULT_PRINT_OPTIONS

LABEL_UNDEFINED: rexcode_isa.Label_Definition : isa.LABEL_UNDEFINED

MAX_INST_SIZE :: 7

NONE :: Register(0xFFFF)

P :: Register(REG_SYS | 1)

PC :: Register(REG_SYS | 2)

REG_GP :: 0x0100

REG_NONE :: 0x0000

REG_SYS :: 0x0200

S :: Register(REG_SYS | 0)

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, 
	cpu:          CPU = .NMOS, 
) -> (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_imm8 :: proc(instructions: ^[dynamic]Instruction, imm: i64) {…}

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

emit_alr :: emit_alr_imm8

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

emit_anc :: emit_anc_imm8

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

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

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

emit_ane :: emit_ane_imm8

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

emit_arr :: emit_arr_imm8

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

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

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

emit_axs :: emit_axs_imm8

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

emit_bbr0 :: emit_bbr0_zp_rel

emit_bbr0_zp_rel :: proc(instructions: ^[dynamic]Instruction, zp: u8, label_id: u32) {…}

emit_bbr1 :: emit_bbr1_zp_rel

emit_bbr1_zp_rel :: proc(instructions: ^[dynamic]Instruction, zp: u8, label_id: u32) {…}

emit_bbr2 :: emit_bbr2_zp_rel

emit_bbr2_zp_rel :: proc(instructions: ^[dynamic]Instruction, zp: u8, label_id: u32) {…}

emit_bbr3 :: emit_bbr3_zp_rel

emit_bbr3_zp_rel :: proc(instructions: ^[dynamic]Instruction, zp: u8, label_id: u32) {…}

emit_bbr4 :: emit_bbr4_zp_rel

emit_bbr4_zp_rel :: proc(instructions: ^[dynamic]Instruction, zp: u8, label_id: u32) {…}

emit_bbr5 :: emit_bbr5_zp_rel

emit_bbr5_zp_rel :: proc(instructions: ^[dynamic]Instruction, zp: u8, label_id: u32) {…}

emit_bbr6 :: emit_bbr6_zp_rel

emit_bbr6_zp_rel :: proc(instructions: ^[dynamic]Instruction, zp: u8, label_id: u32) {…}

emit_bbr7 :: emit_bbr7_zp_rel

emit_bbr7_zp_rel :: proc(instructions: ^[dynamic]Instruction, zp: u8, label_id: u32) {…}

emit_bbs0 :: emit_bbs0_zp_rel

emit_bbs0_zp_rel :: proc(instructions: ^[dynamic]Instruction, zp: u8, label_id: u32) {…}

emit_bbs1 :: emit_bbs1_zp_rel

emit_bbs1_zp_rel :: proc(instructions: ^[dynamic]Instruction, zp: u8, label_id: u32) {…}

emit_bbs2 :: emit_bbs2_zp_rel

emit_bbs2_zp_rel :: proc(instructions: ^[dynamic]Instruction, zp: u8, label_id: u32) {…}

emit_bbs3 :: emit_bbs3_zp_rel

emit_bbs3_zp_rel :: proc(instructions: ^[dynamic]Instruction, zp: u8, label_id: u32) {…}

emit_bbs4 :: emit_bbs4_zp_rel

emit_bbs4_zp_rel :: proc(instructions: ^[dynamic]Instruction, zp: u8, label_id: u32) {…}

emit_bbs5 :: emit_bbs5_zp_rel

emit_bbs5_zp_rel :: proc(instructions: ^[dynamic]Instruction, zp: u8, label_id: u32) {…}

emit_bbs6 :: emit_bbs6_zp_rel

emit_bbs6_zp_rel :: proc(instructions: ^[dynamic]Instruction, zp: u8, label_id: u32) {…}

emit_bbs7 :: emit_bbs7_zp_rel

emit_bbs7_zp_rel :: proc(instructions: ^[dynamic]Instruction, zp: u8, label_id: u32) {…}

emit_bcc :: emit_bcc_rel

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

emit_bcs :: emit_bcs_rel

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

emit_beq :: emit_beq_rel

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

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

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

emit_bmi :: emit_bmi_rel

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

emit_bne :: emit_bne_rel

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

emit_bpl :: emit_bpl_rel

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

emit_bra :: emit_bra_rel

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

emit_brk :: emit_brk_none

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

emit_bsr :: emit_bsr_rel

emit_bsr_rel :: proc(instructions: ^[dynamic]Instruction, label_id: u32) {…}

emit_bvc :: emit_bvc_rel

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

emit_bvs :: emit_bvs_rel

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

emit_cla :: emit_cla_none

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

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_clx :: emit_clx_none

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

emit_cly :: emit_cly_none

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

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

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

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

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

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

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

emit_csh :: emit_csh_none

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

emit_csl :: emit_csl_none

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

emit_dcp :: emit_dcp_m

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

emit_dea :: emit_dea_a

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

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

emit_dec_m :: 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_dop_imm8 :: proc(instructions: ^[dynamic]Instruction, imm: i64) {…}

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

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

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

emit_ina :: emit_ina_a

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

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

emit_inc_m :: 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_isc :: emit_isc_m

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

emit_jam :: emit_jam_none

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

emit_jmp :: emit_jmp_m

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

emit_jsr :: emit_jsr_m

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

emit_las :: emit_las_m

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

emit_lax :: emit_lax_m

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

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

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

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

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

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

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

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

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

emit_lxa :: emit_lxa_imm8

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

emit_nop :: emit_nop_none

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

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

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

emit_pha :: emit_pha_none

emit_pha_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_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_rla :: emit_rla_m

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

emit_rmb0 :: emit_rmb0_m

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

emit_rmb1 :: emit_rmb1_m

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

emit_rmb2 :: emit_rmb2_m

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

emit_rmb3 :: emit_rmb3_m

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

emit_rmb4 :: emit_rmb4_m

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

emit_rmb5 :: emit_rmb5_m

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

emit_rmb6 :: emit_rmb6_m

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

emit_rmb7 :: emit_rmb7_m

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

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

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

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

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

emit_rra :: emit_rra_m

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

emit_rti :: emit_rti_none

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

emit_rts :: emit_rts_none

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

emit_sax :: emit_sax_none

emit_sax_nmos :: emit_sax_nmos_m

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

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

emit_say :: emit_say_none

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

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

emit_sbc_m :: 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_set :: emit_set_none

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

emit_sha :: emit_sha_m

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

emit_shx :: emit_shx_m

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

emit_shy :: emit_shy_m

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

emit_slo :: emit_slo_m

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

emit_smb0 :: emit_smb0_m

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

emit_smb1 :: emit_smb1_m

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

emit_smb2 :: emit_smb2_m

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

emit_smb3 :: emit_smb3_m

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

emit_smb4 :: emit_smb4_m

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

emit_smb5 :: emit_smb5_m

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

emit_smb6 :: emit_smb6_m

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

emit_smb7 :: emit_smb7_m

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

emit_sre :: emit_sre_m

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

emit_st0 :: emit_st0_imm8

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

emit_st1 :: emit_st1_imm8

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

emit_st2 :: emit_st2_imm8

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

emit_sta :: emit_sta_m

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

emit_stp :: emit_stp_none

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

emit_stx :: emit_stx_m

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

emit_sty :: emit_sty_m

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

emit_stz :: emit_stz_m

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

emit_sxy :: emit_sxy_none

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

emit_tai :: emit_tai_block

emit_tai_block :: proc(instructions: ^[dynamic]Instruction, src, dst, length_val: u16) {…}

emit_tam :: emit_tam_imm8

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

emit_tas :: emit_tas_m

emit_tas_m :: 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_tdd :: emit_tdd_block

emit_tdd_block :: proc(instructions: ^[dynamic]Instruction, src, dst, length_val: u16) {…}

emit_tia :: emit_tia_block

emit_tia_block :: proc(instructions: ^[dynamic]Instruction, src, dst, length_val: u16) {…}

emit_tii :: emit_tii_block

emit_tii_block :: proc(instructions: ^[dynamic]Instruction, src, dst, length_val: u16) {…}

emit_tin :: emit_tin_block

emit_tin_block :: proc(instructions: ^[dynamic]Instruction, src, dst, length_val: u16) {…}

emit_tma :: emit_tma_imm8

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

emit_top :: emit_top_m

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

emit_trb :: emit_trb_m

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

emit_tsb :: emit_tsb_m

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

emit_tst :: emit_tst_tst

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

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_tya :: emit_tya_none

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

emit_usbc :: emit_usbc_imm8

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

emit_wai :: emit_wai_none

emit_wai_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_imm8 :: proc "contextless" (imm: i64) -> Instruction {…}

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

inst_alr :: inst_alr_imm8

inst_alr_imm8 :: proc "contextless" (imm: i64) -> Instruction {…}

inst_anc :: inst_anc_imm8

inst_anc_imm8 :: proc "contextless" (imm: i64) -> Instruction {…}

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

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

inst_ane :: inst_ane_imm8

inst_ane_imm8 :: proc "contextless" (imm: i64) -> Instruction {…}

inst_arr :: inst_arr_imm8

inst_arr_imm8 :: proc "contextless" (imm: i64) -> Instruction {…}

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

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

inst_axs :: inst_axs_imm8

inst_axs_imm8 :: proc "contextless" (imm: i64) -> Instruction {…}

inst_bbr0 :: inst_bbr0_zp_rel

inst_bbr0_zp_rel :: proc "contextless" (zp: u8, label_id: u32) -> Instruction {…}

inst_bbr1 :: inst_bbr1_zp_rel

inst_bbr1_zp_rel :: proc "contextless" (zp: u8, label_id: u32) -> Instruction {…}

inst_bbr2 :: inst_bbr2_zp_rel

inst_bbr2_zp_rel :: proc "contextless" (zp: u8, label_id: u32) -> Instruction {…}

inst_bbr3 :: inst_bbr3_zp_rel

inst_bbr3_zp_rel :: proc "contextless" (zp: u8, label_id: u32) -> Instruction {…}

inst_bbr4 :: inst_bbr4_zp_rel

inst_bbr4_zp_rel :: proc "contextless" (zp: u8, label_id: u32) -> Instruction {…}

inst_bbr5 :: inst_bbr5_zp_rel

inst_bbr5_zp_rel :: proc "contextless" (zp: u8, label_id: u32) -> Instruction {…}

inst_bbr6 :: inst_bbr6_zp_rel

inst_bbr6_zp_rel :: proc "contextless" (zp: u8, label_id: u32) -> Instruction {…}

inst_bbr7 :: inst_bbr7_zp_rel

inst_bbr7_zp_rel :: proc "contextless" (zp: u8, label_id: u32) -> Instruction {…}

inst_bbs0 :: inst_bbs0_zp_rel

inst_bbs0_zp_rel :: proc "contextless" (zp: u8, label_id: u32) -> Instruction {…}

inst_bbs1 :: inst_bbs1_zp_rel

inst_bbs1_zp_rel :: proc "contextless" (zp: u8, label_id: u32) -> Instruction {…}

inst_bbs2 :: inst_bbs2_zp_rel

inst_bbs2_zp_rel :: proc "contextless" (zp: u8, label_id: u32) -> Instruction {…}

inst_bbs3 :: inst_bbs3_zp_rel