Struct lc3_ensemble::sim::Simulator

pub struct Simulator {
    pub mem: Mem,
    pub reg_file: RegFile,
    pub pc: u16,
    pub strict: bool,
    pub breakpoints: Vec<Breakpoint>,
    /* private fields */
}

Executes assembled code.

Fields

mem: Mem

The simulator’s memory.

Note that this is held in the heap, as it is too large for the stack.

reg_file: RegFile

The simulator’s register file.

pc: u16

The program counter.

strict: bool

Whether strict mode is enabled.

Strict mode adds additional integrity checks to the simulator, such as verifying initialization state is normal for provided data.

breakpoints: Vec<Breakpoint>

Breakpoints for the simulator.

Implementations

impl Simulator

pub fn new(strat: WordCreateStrategy) -> Self

Creates a new simulator with the provided initializers and with the OS loaded, but without a loaded object file.

pub fn load_os(&mut self)

Loads and initializes the operating system.

Note that this is done automatically with Simulator::new.

This will initialize kernel space and create trap handlers, however it will not load working IO. This can cause IO traps such as GETC and PUTC to hang. The only trap that is assured to function without IO is HALT.

To initialize the IO, use Simulator::open_io.

pub fn reset(&mut self)

Resets the simulator.

This sets the simulator back to the state it was in when Simulator::new was called. Essentially, this resets all state fields back to their defaults, and the memory and register file back to their original initialization values (unless the creation strategy used to initialize this Simulator was WordCreateStrategy::Unseeded).

pub fn open_io<IO: Into<SimIO>>(&mut self, io: IO)

Sets and initializes the IO handler.

pub fn close_io(&mut self)

Closes the IO handler, waiting for it to close.

pub fn load_obj_file(&mut self, obj: &ObjectFile)

Loads an object file into this simulator.

pub fn psr(&self) -> &PSR

Gets a reference to the PSR.

pub fn mcr(&self) -> &Arc<AtomicBool>

Gets a reference to the MCR.

pub fn set_pc( &mut self, addr_word: Word, st_check_mem: bool ) -> Result<(), SimErr>

Sets the PC to the given address, raising any errors that occur.

The st_check_mem parameter indicates whether the data at the PC should be verified in strict mode. This should be enabled when it is absolutely known that the PC will read from the provided address on the next cycle.

This should be true when this function is used for instructions like BR and JSR and should be false when this function is used to increment PC during fetch.

pub fn offset_pc( &mut self, offset: i16, st_check_mem: bool ) -> Result<(), SimErr>

Adds an offset to the PC.

See Simulator::set_pc for details about st_check_mem.

pub fn prefetch_pc(&self) -> u16

Gets the value of the prefetch PC.

This function returns the value of PC before it is incremented druing fetch, which is also the location of the currently executing instruction in memory.

This is useful for pointing to a given memory location in error handling, as this computation always points to the memory location of the instruction.

pub fn hit_breakpoint(&self) -> bool

Indicates whether the last execution of the simulator hit a breakpoint.

pub fn default_mem_ctx(&self) -> MemAccessCtx

Computes the default memory access context, which are the default flags to use (see Mem::read and Mem::write).

pub fn run(&mut self) -> Result<(), SimErr>

Execute the program.

pub fn step_in(&mut self) -> Result<(), SimErr>

Simulate one step, executing one instruction.

pub fn step_over(&mut self) -> Result<(), SimErr>

Simulate one step, executing one instruction and running through entire subroutines as a single step.

pub fn step_out(&mut self) -> Result<(), SimErr>

Run through the simulator’s execution until the subroutine is exited.

Trait Implementations

impl Debug for Simulator

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

Formats the value using the given formatter.

impl Default for Simulator

fn default() -> Self

Returns the “default value” for a type.