Struct BasicInstructionFetcher 

pub struct BasicInstructionFetcher<I, CustomError = CustomErrorPlaceholder>
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, CustomError> BasicInstructionFetcher<I, CustomError>

where I: Instruction,

pub 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, CustomError: Clone> Clone for BasicInstructionFetcher<I, CustomError>

where I: Instruction + Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I, CustomError: Debug> Debug for BasicInstructionFetcher<I, CustomError>

where I: Instruction + Debug,

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

Formats the value using the given formatter.

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

where I: Instruction, Memory: VirtualMemory,

fn fetch_instruction( &mut self, memory: &Memory, ) -> Result<FetchInstructionResult<I>, ExecutionError<<<I as Instruction>::Reg as Register>::Type, CustomError>>

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

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

where I: Instruction, Memory: VirtualMemory,

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

Get the current value of the program counter

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

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.

impl<I, CustomError: Copy> Copy for BasicInstructionFetcher<I, CustomError>

where I: Instruction + Copy,