Struct pir_8_emu::binutils::pir_8_emu::Vm

pub struct Vm {
    pub memory: Memory,
    pub ports: Ports,
    pub registers: GeneralPurposeRegisterBank,
    pub pc: SpecialPurposeRegister<u16>,
    pub sp: SpecialPurposeRegister<u16>,
    pub adr: SpecialPurposeRegister<u16>,
    pub ins: SpecialPurposeRegister<u8>,
    pub ops: (MicroOpBlock, usize),
    pub curr_op: usize,
    pub instruction: Instruction,
    pub instruction_valid: bool,
    pub execution_finished: bool,
    pub stack: Vec<u8>,
    pub instruction_history: ArrayDeque<[(u16, Instruction, u16); 10], ArrayDequeBehaviourWrapping>,
    pub breakpoints: BTreeSet<u16>,
    pub active_breakpoint: Option<u16>,
}

Container for all data needed and/or useful for running a pir-8-emu virtual machine

Examples

let mut vm = Vm::new("FSXYABCD").unwrap();
vm.reset("FSXYABCD", &[
    Instruction::Halt.into(),
    Instruction::LoadImmediateWide { rr: InstructionLoadImmediateWideRegisterPair::Adr }.into(),
    0x04,
    0x20,
    Instruction::LoadImmediateByte { rrr: 0b000 }.into(),
    0x69,
    Instruction::Save { rrr: 0b000 }.into(),
    Instruction::Halt.into(),
]);

vm.jump_to_addr(0x0001).unwrap();
while !vm.execution_finished {
    vm.ins.reset_rw();
    vm.perform_next_op().unwrap();
}

assert_eq!(vm.memory[0x0420], 0x69);

Fields

memory: Memory

ports: Ports

registers: GeneralPurposeRegisterBank

pc: SpecialPurposeRegister<u16>

sp: SpecialPurposeRegister<u16>

adr: SpecialPurposeRegister<u16>

ins: SpecialPurposeRegister<u8>

ops: (MicroOpBlock, usize)

curr_op: usize

instruction: Instruction

instruction_valid: bool

If this is set, instruction contains the current instruction and ops contains the μOps corresponding thereto

execution_finished: bool

stack: Vec<u8>

instruction_history: ArrayDeque<[(u16, Instruction, u16); 10], ArrayDequeBehaviourWrapping>

Any instruction successfully loaded will be added to the front of this queue

breakpoints: BTreeSet<u16>

Pause execution when PC is contained herein until the flag is cleared

active_breakpoint: Option<u16>

Methods

impl Vm

pub fn new(gp_reg_ltrs: &str) -> Result<Vm, i8>

Create a new, zero-initialised VM with the specified general-purpose register letters

pub fn reset(&mut self, gp_reg_ltrs: &str, memory: &[u8]) -> Result<(), i8>

Reset this VM to a default state but with the specified memory buffer

pub fn jump_to_addr(&mut self, to_addr: u16) -> Result<(), MicroOpPerformError>

Safely jump to the specified address

The current μOp set will be executed, then PC updated to the specified address, and μOps set to NEXT_INSTRUCTION

pub fn perform_next_op(&mut self) -> Result<bool, MicroOpPerformError>

Perform next μOp

If execution has finished, do nothing

Otherwise, perform the current μOp and bump the μOp counter

If the last μOp of the set has been performed:

• if INS was written to, load the instruction therein
• otherwise, load NEXT_INSTRUCTION

The returned value represents whether new μOps are present

Trait Implementations

impl Debug for Vm

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.