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.

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

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

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

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.

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 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. The return trap sits outside the decoded stream, so a branch to it 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>::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>::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<()>, 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.