Struct BasicInstructionFetcher 

pub struct BasicInstructionFetcher<I>
where
    I: Instruction,
{ /* private fields */ }

Basic instruction fetcher implementation.

This implementation is intentionally basic and correct, but not the most performant. It is possible to have a more efficient implementation that skips certain checks by placing additional constraints on the constructor.

Note that it loads instructions from anywhere in memory. This works, but it is likely that you want to restrict this to a specific executable region of memory.

Implementations

impl<I> BasicInstructionFetcher<I>

where I: Instruction,

pub const fn new( return_trap_address: <<I as Instruction>::Reg as Register>::Type, pc: <<I as Instruction>::Reg as Register>::Type, ) -> Self

Create a new instance.

return_trap_address is the address at which the interpreter will stop execution (gracefully).

Trait Implementations

impl<I> Clone for BasicInstructionFetcher<I>

where I: Instruction + Clone,

fn clone(&self) -> BasicInstructionFetcher<I>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<I> Copy for BasicInstructionFetcher<I>

where I: Instruction + Copy,

impl<I> Debug for BasicInstructionFetcher<I>

where I: Instruction + Debug,

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

Formats the value using the given formatter.

impl<I, Memory> InstructionFetcher<I, Memory> for BasicInstructionFetcher<I>

where I: Instruction, Memory: VirtualMemory,

fn peek_instruction(&mut self, memory: &Memory) -> FetchInstructionResult<I>

Read the instruction at the current position, leaving the program counter on it.

unsafe fn advance(&mut self, instruction_size: u8)

Move the program counter past an instruction of instruction_size bytes that Self::peek_instruction() has just returned.

fn fetch_instruction(&mut self, memory: &Memory) -> FetchInstructionResult<I>

Fetch a single instruction at a specified address and advance the program counter on successful fetch.

impl<I, Memory> ProgramCounter<<<I as Instruction>::Reg as Register>::Type, Memory> for BasicInstructionFetcher<I>

where I: Instruction, Memory: VirtualMemory,

fn get_pc(&self) -> <<I as Instruction>::Reg as Register>::Type

Get the current value of the program counter

unsafe fn try_set_pc_relative( &mut self, instruction_size: u8, offset: i32, ) -> bool

Move offset bytes from the instruction being executed for targets this can resolve.

unsafe fn failed_branch( &mut self, memory: &Memory, ) -> Result<ControlFlow<()>, ExecutionError<<<I as Instruction>::Reg as Register>::Type>>

Say what is wrong with the target Self::try_set_pc_relative() refused.

fn set_pc( &mut self, _memory: &Memory, pc: <<I as Instruction>::Reg as Register>::Type, ) -> Result<ControlFlow<()>, ExecutionError<<<I as Instruction>::Reg as Register>::Type>>

Set the current value of the program counter

fn old_pc(&self, instruction_size: u8) -> Address

where Address: From<u8> + Sub<Output = Address>,

Get the previous value of the program counter before executing an instruction.

fn set_pc_relative( &mut self, memory: &Memory, instruction_size: u8, offset: i32, ) -> Result<ControlFlow<()>, ExecutionError<Address>>

where Self: ProgramCounter<Address, Memory>,

Apply ExecutionResult::Branch, continuing offset bytes from the instruction being executed.