Struct EagerTestInstructions 

pub struct EagerTestInstructions { /* private fields */ }

Instructions decoded upfront, which EagerTestInstructionFetcher walks.

Ownership of the allocation lives here rather than in the fetcher because the fetcher is moved through tail-called instruction handlers by value. A destructor on it would make every handler that can fail (every load, store, branch and jump) responsible for dropping it on the way out, which costs a stack frame, callee-saved register spills and a reload in the hot path of each of them, even though the failing path is never taken.

Implementations

impl EagerTestInstructions

pub unsafe fn fetcher(&self, pc: u64) -> EagerTestInstructionFetcher<'_>

Create a fetcher positioned at the instruction that guest address pc corresponds to

Safety

pc must be a valid and aligned guest address of one of the decoded instructions.

pub unsafe fn decode( instructions: &[u8], return_trap_address: u64, base_addr: u64, ) -> Self

Decode instructions and create a new instance holding the result.

base_addr is the guest address of the first instruction, and return_trap_address is the address at which the interpreter will stop execution (gracefully).

Safety

The instructions processed must be valid and end with a jump instruction, and return_trap_address must not fall inside them. Instruction fetching does not compare against the return trap, so an address inside the instructions would stop execution when jumped to but not when reached by falling through.

Trait Implementations

impl Debug for EagerTestInstructions

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

Formats the value using the given formatter.

impl Drop for EagerTestInstructions

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.