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.

Every fetch is a bounds-checked memory read, so fetching is allowed at any program counter, whatever moved it there.

Implementations

impl<I> BasicInstructionFetcher<I>

where I: Instruction,

pub const fn new( return_trap_address: <<<I as Instruction>::Hart as HartConfig>::Reg as Register>::Type, pc: <<<I as Instruction>::Hart as HartConfig>::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,

type Peeked = I

What Self::peek_instruction() returns an instruction as, which is whatever Self::peeked_instruction() needs besides the fetcher to get back to the instruction.

unsafe fn peeked_instruction<'a>(&'a self, peeked: &'a I) -> &'a I

The instruction that Self::peek_instruction() returned peeked for.

unsafe 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.

unsafe 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>::Hart as HartConfig>::Reg as Register>::Type, Memory> for BasicInstructionFetcher<I>

where I: Instruction, Memory: VirtualMemory,

fn get_pc( &self, ) -> <<<I as Instruction>::Hart as HartConfig>::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>::Hart as HartConfig>::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>::Hart as HartConfig>::Reg as Register>::Type, ) -> Result<ControlFlow<()>, ExecutionError<<<<I as Instruction>::Hart as HartConfig>::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.