Struct EagerTestInstructionFetcher 

pub struct EagerTestInstructionFetcher<'a> { /* private fields */ }

Eager instruction fetcher walks instructions that EagerTestInstructions decoded upfront.

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

Trait Implementations

impl<'a> Clone for EagerTestInstructionFetcher<'a>

fn clone(&self) -> EagerTestInstructionFetcher<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Copy for EagerTestInstructionFetcher<'a>

impl Debug for EagerTestInstructionFetcher<'_>

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

Formats the value using the given formatter.

impl<Memory> InstructionFetcher<ContractInstruction, Memory> for EagerTestInstructionFetcher<'_>

where Memory: VirtualMemory,

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

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<ContractInstruction>

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

impl<Memory> ProgramCounter<u64, Memory> for EagerTestInstructionFetcher<'_>

where 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<u64>>

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) -> u64

Get the current value of the program counter

fn set_pc( &mut self, _memory: &Memory, pc: u64, ) -> Result<ControlFlow<()>, ExecutionError<u64>>

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.