Struct BasicEagerInstructionFetcher 

pub struct BasicEagerInstructionFetcher<'a, I>
where
    I: Instruction,
{ /* private fields */ }

Eager instruction fetcher walks instructions that BasicEagerInstructions decoded upfront.

This is a plain Copy cursor without a destructor, see BasicEagerInstructions for why.

The fallback instruction after the decoded stream has no address of its own, so ProgramCounter::set_pc() refuses the address right after the decoded stream as out of bounds, unless the return trap is there. Execution that starts again at that address therefore fails with ExecutionError::OutOfBoundsRead or stops at the trap, instead of running the fallback instruction.

Trait Implementations

impl<'a, I> Clone for BasicEagerInstructionFetcher<'a, I>

where I: Instruction + Clone,

fn clone(&self) -> BasicEagerInstructionFetcher<'a, I>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, I> Copy for BasicEagerInstructionFetcher<'a, I>

where I: Instruction + Copy,

impl<I> Debug for BasicEagerInstructionFetcher<'_, I>

where I: Instruction,

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

Formats the value using the given formatter.

impl<I, Memory> InstructionFetcher<I, Memory> for BasicEagerInstructionFetcher<'_, I>

where I: Instruction, Memory: VirtualMemory,

type Peeked = ()

Nothing, the decoded stream is where the instruction stays and the position is the fetcher’s own, so a threaded handler loads each operand it uses straight from there

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 peeked_instruction<'a>(&'a self, (): &'a ()) -> &'a I

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

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 BasicEagerInstructionFetcher<'_, I>

where I: Instruction, Memory: VirtualMemory,

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

Moves within the decoded stream instead of resolving an address and converting it back, which is what going through Self::set_pc() would do.

One comparison and one test are all this needs to recognize every target it cannot resolve: one past the end of the decoded stream, a backwards branch that ran off its start, and an unaligned one. BasicEagerInstructions::decode() refuses a return trap inside the code, so a branch to the trap fails the bounds check here too and is answered by Self::failed_branch() like any other target this refuses.

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

Turns the refused target back into an address and hands it to Self::set_pc(), which is where the rules about what is and is not an instruction address live.

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

Get the current value of the program counter

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.