Files
Odin/core/rexcode/isa/mos6502/instructions.odin
Brendan Punsky 95df04fbe1 rexcode: re-house ISA packages under core:rexcode/isa/<arch>
Move all ten ISA packages (x86, arm32, arm64, mips, riscv, ppc, ppc_vle,
rsp, mos6502, mos65816) from core/rexcode/<arch> to core/rexcode/isa/<arch>,
so the import pattern is now `import "core:rexcode/isa/x86"`. The shared
core stays at core:rexcode/isa.

Mechanical: relative `import "../isa"` / "../../isa" -> absolute
"core:rexcode/isa" (the only path that survives the move; the "../" and
"../.." self/generated imports move with their packages). build.lua now
builds paths as <root>/isa/<name>; stale `cd <arch>` hints in the verify
tools and the doc.odin paths updated.

WASM stays at core/rexcode/wasm for now -- it is an IR, not an ISA, and
will move under the forthcoming core:rexcode/ir once that layer lands.

All 10 arches gen/builders/check/test green; import core:rexcode/isa/x86
verified working; wasm still compiles.
2026-06-18 19:03:27 -04:00

90 lines
3.0 KiB
Odin

// rexcode · Brendan Punsky (dotbmp@github), original author
package rexcode_mos6502
// =============================================================================
// INSTRUCTION
// =============================================================================
//
// Up to 3 operands per instruction (only the HuC6280 block-transfer ops
// actually use all three; the rest top out at two).
Instruction_Flags :: bit_field u8 {
_: u8 | 8,
}
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, // 1
}
#assert(size_of(Instruction) == 36)
// =============================================================================
// Builders (mirror the contract: shape spelled out, comma-separated)
// =============================================================================
@(require_results)
inst_none :: #force_inline proc "contextless" (m: Mnemonic) -> Instruction {
return Instruction{mnemonic = m, operand_count = 0, length = 1}
}
@(require_results)
inst_a :: #force_inline proc "contextless" (m: Mnemonic) -> Instruction {
// Explicit accumulator (e.g. `ROL A`). Encodes to 1 byte (opcode only)
// and counts as 1 operand for the matcher.
return Instruction{
mnemonic = m, operand_count = 1, length = 1,
ops = {op_reg(A), {}, {}},
}
}
@(require_results)
inst_i :: #force_inline proc "contextless" (m: Mnemonic, imm: i64) -> Instruction {
return Instruction{
mnemonic = m, operand_count = 1, length = 2,
ops = {op_imm8(imm), {}, {}},
}
}
@(require_results)
inst_m :: #force_inline proc "contextless" (m: Mnemonic, mm: Memory) -> Instruction {
return Instruction{
mnemonic = m, operand_count = 1, length = 0, // filled by encoder
ops = {op_mem(mm), {}, {}},
}
}
@(require_results)
inst_rel :: #force_inline proc "contextless" (m: Mnemonic, label_id: u32) -> Instruction {
return Instruction{
mnemonic = m, operand_count = 1, length = 2,
ops = {op_label(label_id, 1), {}, {}},
}
}
// BBR/BBS: zero-page byte + relative branch (3-byte encoding).
@(require_results)
inst_zp_rel :: #force_inline proc "contextless" (m: Mnemonic, zp: u8, label_id: u32) -> Instruction {
return Instruction{
mnemonic = m, operand_count = 2, length = 3,
ops = {op_zp(zp), op_label(label_id, 1), {}},
}
}
// HuC6280 block transfer: src, dst, length (7-byte encoding).
@(require_results)
inst_block :: #force_inline proc "contextless" (m: Mnemonic, src, dst, length_val: u16) -> Instruction {
return Instruction{
mnemonic = m, operand_count = 3, length = 7,
ops = {
Operand{immediate = i64(src), kind = .IMMEDIATE, size = 2},
Operand{immediate = i64(dst), kind = .IMMEDIATE, size = 2},
Operand{immediate = i64(length_val), kind = .IMMEDIATE, size = 2},
},
}
}