Struct csx64::exec::Emulator

pub struct Emulator {
    pub memory: Memory,
    pub cpu: CPU,
    pub vpu: VPU,
    pub fpu: FPU,
    pub flags: Flags,
    pub files: Files,
    // some fields omitted
}

Processor emulator which runs a compiled program.

Fields

memory: Memory

cpu: CPU

vpu: VPU

fpu: FPU

flags: Flags

files: Files

Implementations

impl Emulator

pub fn new() -> Emulator

Creates a new emulator in the uninitialized state.

pub fn init(&mut self, exe: &Executable, args: &EmulatorArgs)

Initializes the emulator to run the provided executable. stack_size, if provided, specifies the amount of stack memory to provide; if this is None then DEFAULT_STACK_SIZE is used. args denotes the command line arguments to provide to the program. These will be copied into the emulator’s memory as null-terminated binary arrays (presumably C-style strings) for it to access.

Note: as a safety precaution, this function also clears all privileged flags from the flags register. This includes disabling filesystem syscalls, among other things. If these features are needed, they must be set enabled again after initialization is completed. To avoid errors in the emulated program, this should be done prior to running the program and ideally not be revoked mid-execution.

pub fn get_state(&self) -> State

Gets the current state of the emulator.

pub fn execute_cycles(&mut self, cycles: u64) -> (u64, StopReason)

Resumes execution of the emulator for up to the given number of cycles. Returns the number of cycles executed and the reason for stopping.

pub fn push_mem(&mut self, value: &[u8]) -> Result<(), ExecError>

Pushes a binary value onto the stack. Similar to using set_mem except that it also checks for stack overflow. On failur, the internal state is unmodified.

pub fn pop_mem(&mut self, len: u64) -> Result<&[u8], ExecError>

Pops a binary value from the stack. Returns a reference to the (logically) removed block of memory.

pub fn push_mem_u8(&mut self, val: u8) -> Result<(), ExecError>

pub fn pop_mem_u8(&mut self) -> Result<u8, ExecError>

pub fn push_mem_u16(&mut self, val: u16) -> Result<(), ExecError>

pub fn pop_mem_u16(&mut self) -> Result<u16, ExecError>

pub fn push_mem_u32(&mut self, val: u32) -> Result<(), ExecError>

pub fn pop_mem_u32(&mut self) -> Result<u32, ExecError>

pub fn push_mem_u64(&mut self, val: u64) -> Result<(), ExecError>

pub fn pop_mem_u64(&mut self) -> Result<u64, ExecError>

pub fn push_mem_i8(&mut self, val: i8) -> Result<(), ExecError>

pub fn pop_mem_i8(&mut self) -> Result<i8, ExecError>

pub fn push_mem_i16(&mut self, val: i16) -> Result<(), ExecError>

pub fn pop_mem_i16(&mut self) -> Result<i16, ExecError>

pub fn push_mem_i32(&mut self, val: i32) -> Result<(), ExecError>

pub fn pop_mem_i32(&mut self) -> Result<i32, ExecError>

pub fn push_mem_i64(&mut self, val: i64) -> Result<(), ExecError>

pub fn pop_mem_i64(&mut self) -> Result<i64, ExecError>

pub fn push_mem_f32(&mut self, val: f32) -> Result<(), ExecError>

pub fn pop_mem_f32(&mut self) -> Result<f32, ExecError>

pub fn push_mem_f64(&mut self, val: f64) -> Result<(), ExecError>

pub fn pop_mem_f64(&mut self) -> Result<f64, ExecError>

pub fn push_mem_f80(&mut self, val: F80) -> Result<(), ExecError>

pub fn pop_mem_f80(&mut self) -> Result<F80, ExecError>

Trait Implementations

impl Default for Emulator

fn default() -> Self

Returns the “default value” for a type.