Struct vm6502::vm::VirtualMachine

pub struct VirtualMachine {
    pub registers: Registers,
    pub flatmap: BytesMut,
    pub zero_bounds: (usize, usize),
    pub stack_bounds: (usize, usize),
    pub heap_bounds: (usize, usize),
    pub vheap_bounds: (usize, usize),
    pub interrupt_bounds: (usize, usize),
    pub reset_bounds: (usize, usize),
    pub irq_bounds: (usize, usize),
    pub addr_mode: Mode,
    pub cycles: u64,
    pub halted: bool,
}

The virtual machine implementation

This module provides VirtualMachine, a 6502 cpu vm. It’s API is intended to closely adhere to the 6502 specs.

See Masswerk’s 6502 Instruction Set for more info on the spec.

Fields

registers: Registers

Machine registers struct.

flatmap: BytesMut

The machine memory in a linear layout. We set the size to 64k+1 to allow easy indexing.

zero_bounds: (usize, usize)

Machine zero page bounds. This is a tuple of (start, end) addresses.

stack_bounds: (usize, usize)

Machine stack page bounds. The stack grows downwards from 0x01FF to 0x0100.

heap_bounds: (usize, usize)

Machine heap(dynamic memory) bounds. This is the only memory that can be dynamically allocated. Accessing memory outside of these bounds is undefined behavior.

vheap_bounds: (usize, usize)

interrupt_bounds: (usize, usize)

Interrupt vector table bounds. Placed at end of heap.

Three vectors are used: reset, irq, nmi. Each vector is 2 bytes.

reset_bounds: (usize, usize)

irq_bounds: (usize, usize)

addr_mode: Mode

Current mode state, this is generally set internally by step.

cycles: u64

The current cycle count of the vm. This is incremented by step.

halted: bool

Implementations

impl VirtualMachine

pub fn new() -> Self

Trait Implementations

impl Debug for VirtualMachine

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

Formats the value using the given formatter.

impl Default for VirtualMachine

fn default() -> Self

Returns the “default value” for a type.

impl HeapInterface for VirtualMachine

fn get_page_offset(&self) -> u8

Returns the page offset for the current PC.

fn set_page_offset(&mut self, virt_addr: u8)

Sets the PC to the given page offset.

fn bounds_check(&self, virt_addr: usize) -> bool

Checks if the given address is within the heap bounds. TODO: Reimplement.

fn get_heap(&self, virt_addr: u16) -> u8

Returns the value at the heap address given.

fn set_heap(&mut self, virt_addr: u16, byte: u8)

Sets the value at the heap address given.

impl InstructionController for VirtualMachine

Virtual machine core control functionality.

This provides three main internal functions, step, mode, and fetch.

Examples

step

use vm6502::prelude::*;
let mut vm = VirtualMachine::new();

vm.insert_program(0x00, "69FFFF");
vm.registers.pc = 0x00;

vm.step();

assert_eq!(vm.flatmap[vm.registers.pc as usize + vm.heap_bounds.0], 0xFF);

mode

use vm6502::prelude::*;

let mut vm = VirtualMachine::new();
let mode = vm.mode(0x69);

assert_eq!(mode, Mode::Immediate);

fetch

// TODO: Unignore this later.

use vm6502::prelude::*;

let mut vm = VirtualMachine::new();
let byte = 0x01;

// 0x200 is heap start. See `VirtualMachine::heap_bounds`.
vm.set_heap(0x0000, 0x69);
vm.set_heap(0x0001, byte);

assert_ne!(vm.flatmap[0x0001], byte, "Byte {} was not set to 0x0201", byte);
assert_eq!(byte, vm.flatmap[0x0201], "Byte {} was not set at 0x0201", byte);

// Should PC be 0x01 or two here?
vm.registers.pc = 0x01;
vm.addr_mode = Mode::Immediate;
let fetched = vm.fetch();
assert_eq!(vm.registers.pc, 0x02, "PC should be incremented by 1 after fetch");

assert_eq!(fetched, byte, "Fetched byte {} does not match expected byte {}", fetched, byte);

fn fetch(&mut self) -> u8

Fetch the next byte from the program counter.

fn mode(&mut self, op: u8) -> Mode

Check the opcode and return the addressing mode.

fn step(&mut self) -> u64

Execute the an arbitrary op. It returns the vm’s current cycle count.

fn apply(&mut self, address: u16, operation: fn(_: u8) -> u8) -> u8

fn fetch_byte(&mut self) -> u8

fn relative_jump(&mut self, fetched: u8, cond: bool)

impl Instructions for VirtualMachine

fn lda(&mut self)

Load Instructions;

fn abs_zp_acc_op(&mut self, operation: fn(_: u8) -> u8) -> u8

Accumulator <-> ZeroPage, Absolute, ZeroPageX and AbsoluteX

fn brk(&mut self)

Break

fn adc(&mut self)

Add with carry

fn sbc(&mut self)

Subtract with carry

fn and(&mut self)

Logical AND

fn eor(&mut self)

Exclusive OR

fn ora(&mut self)

Logical inclusive OR

fn bcc(&mut self, offset: u8)

Branch on carry clear

fn bcs(&mut self, offset: u8)

Branch on carry set

fn beq(&mut self, offset: u8)

Branch on equal (zero set)

fn bne(&mut self, offset: u8)

Branch on minus (negative set)

fn bpl(&mut self, offset: u8)

Branch on plus (negative clear)

fn bvc(&mut self, offset: u8)

Branch on overflow clear

fn bvs(&mut self, offset: u8)

Branch on overflow set

fn bmi(&mut self, offset: u8)

fn dec(&mut self)

Decrement memory

fn inc(&mut self)

Increment memory

fn dex(&mut self)

Decrement X register

fn dey(&mut self)

Decrement Y register

fn inx(&mut self)

Increment X register

fn iny(&mut self)

Increment Y register

fn ldx(&mut self)

Load X register

fn ldy(&mut self)

Load Y register

fn bit(&mut self)

Bit test

fn cmp(&mut self)

Compare

fn cpx(&mut self)

Compare X register

fn cpy(&mut self)

Compare Y register

fn lsr(&mut self)

Logical shift right

fn asl(&mut self)

Arithmetic shift left

fn rol(&mut self)

Rotate left

fn ror(&mut self)

Rotate right

fn jmp(&mut self)

Jump

fn jsr(&mut self)

Jump to subroutine

fn rti(&mut self)

Return from interrupt

fn rts(&mut self)

Return from subroutine

fn clc(&mut self)

Clear carry flag

fn cld(&mut self)

Clear decimal mode

fn cli(&mut self)

Clear interrupt disable bit

fn clv(&mut self)

Clear overflow flag

fn sec(&mut self)

Set carry flag

fn sed(&mut self)

Set decimal mode

fn sei(&mut self)

Set interrupt disable status

fn sta(&mut self)

Store accumulator

fn stx(&mut self)

Store X register

fn sty(&mut self)

Store Y register

fn tax(&mut self)

Transfer accumulator to X

fn txa(&mut self)

Transfer X to accumulator

fn tay(&mut self)

Transfer accumulator to Y

fn tya(&mut self)

Transfer Y to accumulator

fn tsx(&mut self)

Transfer stack pointer to X

fn txs(&mut self)

Transfer X to stack pointer

fn pha(&mut self)

Push accumulator

fn php(&mut self)

Push processor status (SR)

fn pla(&mut self)

Pull accumulator

fn plp(&mut self)

Pull processor status (SR)

fn nop(&mut self)

No operation

impl ProgramController for VirtualMachine

fn insert_program(&mut self, offset: u16, prog: &str)

Insert a hex encoded string prog at heap offset offset.s

fn set_program(&mut self, offset: u16, prog: &str)

Replaces and runs the program at offset.

fn execute(&mut self) -> u64

Run the internally set program. Intended API for running programs.

fn run(&mut self, duration: Duration) -> (u64, Duration)

Run the internally set program for duration time, returning the number of cycles executed.

fn reset(&mut self)

Resets the total machine state.

fn fill_stack(&mut self, ops: Vec<u8>)

Fill the stack with ops.

fn set_interrupt_vectors(&mut self, nmi: u16, irq: u16, brk: u16)

Set the interrupt vectors to the given values.

fn default_interrupt_vectors(&mut self)

Set the interrupt vectors to the values: (0xFFFA, 0xFFFB), (0xFFFC, 0xFFFD), (0xFFFE, 0xFFFF)

impl StackInterface for VirtualMachine

fn pop(&mut self) -> u8

fn peek(&mut self) -> u8

fn push(&mut self, value: u8)

impl StatusInterface for VirtualMachine

Implements a high level interface for accessing the status register.

This is the intended API access for frontends to use the VM.

fn flip_status(&mut self, flag: Status)

fn set_status(&mut self, flag: Status, value: bool)

fn get_status(&self, flag: Status) -> bool

fn reset_status(&mut self)