Struct revm_interpreter::Interpreter

pub struct Interpreter {
    pub contract: Box<Contract>,
    pub instruction_pointer: *const u8,
    pub instruction_result: InstructionResult,
    pub gas: Gas,
    pub shared_memory: SharedMemory,
    pub stack: Stack,
    pub return_data_buffer: Bytes,
    pub is_static: bool,
    pub next_action: InterpreterAction,
}

Fields

contract: Box<Contract>

Contract information and invoking data

instruction_pointer: *const u8

The current instruction pointer.

instruction_result: InstructionResult

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

gas: Gas

The gas state.

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.

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: Box<Contract>, gas_limit: u64, is_static: bool) -> Self

Create new interpreter

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_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 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: Host>( &mut self, shared_memory: SharedMemory, instruction_table: &[FN; 256], host: &mut H ) -> InterpreterAction

where FN: Fn(&mut Interpreter, &mut H),

Executes the interpreter until it returns or stops.

Trait Implementations

impl Debug for Interpreter

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

Formats the value using the given formatter.