Struct reth_revm::interpreter::Interpreter

pub struct Interpreter {

    pub instruction_pointer: *const u8,
    pub gas: Gas,
    pub contract: Contract,
    pub instruction_result: InstructionResult,
    pub bytecode: Bytes,
    pub is_eof: bool,
    pub is_eof_init: bool,
    pub shared_memory: SharedMemory,
    pub stack: Stack,
    pub function_stack: FunctionStack,
    pub return_data_buffer: Bytes,
    pub is_static: bool,
    pub next_action: InterpreterAction,
}

EVM bytecode interpreter.

Fields

instruction_pointer: *const u8

The current instruction pointer.

gas: Gas

The gas state.

contract: Contract

Contract information and invoking data

instruction_result: InstructionResult

The execution control flag. If this is not set to Continue, the interpreter will stop execution.

bytecode: Bytes

Currently run Bytecode that instruction result will point to. Bytecode is owned by the contract.

is_eof: bool

Whether we are Interpreting the Ethereum Object Format (EOF) bytecode. This is local field that is set from contract.is_eof().

is_eof_init: bool

Is init flag for eof create

shared_memory: SharedMemory

Shared memory.

Note: This field is only set while running the interpreter loop. Otherwise it is taken and replaced with empty shared memory.

stack: Stack

Stack.

function_stack: FunctionStack

EOF function stack.

return_data_buffer: Bytes

The return data buffer for internal calls. It has multi usage:

• It contains the output bytes of call sub call.
• When this interpreter finishes execution it contains the output bytes of this contract.

is_static: bool

Whether the interpreter is in “staticcall” mode, meaning no state changes can happen.

next_action: InterpreterAction

Actions that the EVM should do.

Set inside CALL or CREATE instructions and RETURN or REVERT instructions. Additionally those instructions will set InstructionResult to CallOrCreate/Return/Revert so we know the reason.

Implementations

impl Interpreter

pub fn new(contract: Contract, gas_limit: u64, is_static: bool) -> Interpreter

Create new interpreter

pub fn set_is_eof_init(&mut self)

Set is_eof_init to true, this is used to enable RETURNCONTRACT opcode.

pub fn eof(&self) -> Option<&Arc<Eof>>

pub fn insert_create_outcome(&mut self, create_outcome: CreateOutcome)

Inserts the output of a create call into the interpreter.

This function is used after a create call has been executed. It processes the outcome of that call and updates the state of the interpreter accordingly.

Arguments

• create_outcome - A CreateOutcome struct containing the results of the create call.

Behavior

The function updates the return_data_buffer with the data from create_outcome. Depending on the InstructionResult indicated by create_outcome, it performs one of the following:

• Ok: Pushes the address from create_outcome to the stack, updates gas costs, and records any gas refunds.
• Revert: Pushes U256::ZERO to the stack and updates gas costs.
• FatalExternalError: Sets the instruction_result to InstructionResult::FatalExternalError.
• Default: Pushes U256::ZERO to the stack.

Side Effects

• Updates return_data_buffer with the data from create_outcome.
• Modifies the stack by pushing values depending on the InstructionResult.
• Updates gas costs and records refunds in the interpreter’s gas field.
• May alter instruction_result in case of external errors.

pub fn insert_eofcreate_outcome(&mut self, create_outcome: CreateOutcome)

pub fn insert_call_outcome( &mut self, shared_memory: &mut SharedMemory, call_outcome: CallOutcome, )

Inserts the outcome of a call into the virtual machine’s state.

This function takes the result of a call, represented by CallOutcome, and updates the virtual machine’s state accordingly. It involves updating the return data buffer, handling gas accounting, and setting the memory in shared storage based on the outcome of the call.

Arguments

• shared_memory - A mutable reference to the shared memory used by the virtual machine.
• call_outcome - The outcome of the call to be processed, containing details such as instruction result, gas information, and output data.

Behavior

The function first copies the output data from the call outcome to the virtual machine’s return data buffer. It then checks the instruction result from the call outcome:

• return_ok!(): Processes successful execution, refunds gas, and updates shared memory.
• return_revert!(): Handles a revert by only updating the gas usage and shared memory.
• InstructionResult::FatalExternalError: Sets the instruction result to a fatal external error.
• Any other result: No specific action is taken.

pub fn current_opcode(&self) -> u8

Returns the opcode at the current instruction pointer.

pub fn contract(&self) -> &Contract

Returns a reference to the contract.

pub fn gas(&self) -> &Gas

Returns a reference to the interpreter’s gas state.

pub fn stack(&self) -> &Stack

Returns a reference to the interpreter’s stack.

pub fn stack_mut(&mut self) -> &mut Stack

Returns a mutable reference to the interpreter’s stack.

pub fn program_counter(&self) -> usize

Returns the current program counter.

pub fn take_memory(&mut self) -> SharedMemory

Take memory and replace it with empty memory.

pub fn run<FN, H>( &mut self, shared_memory: SharedMemory, instruction_table: &[FN; 256], host: &mut H, ) -> InterpreterAction

where H: Host + ?Sized, FN: Fn(&mut Interpreter, &mut H),

Executes the interpreter until it returns or stops.

pub fn resize_memory(&mut self, new_size: usize) -> bool

Resize the memory to the new size. Returns whether the gas was enough to resize the memory.

Trait Implementations

impl Debug for Interpreter

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

Formats the value using the given formatter.

impl Default for Interpreter

fn default() -> Interpreter

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Interpreter

fn deserialize<D>( deserializer: D, ) -> Result<Interpreter, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Interpreter

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 504 bytes