Struct Stack 

pub struct Stack {
    pub values: Box<[U256; 1024]>,
    pub offset: usize,
}

The EVM uses a stack-based architecture and does not use registers like some other VMs.

The specification says the stack is limited to 1024 items, aka. 32KiB, which is reasonable enough for allocating it all at once to make sense. Every time an item is pushed into the stack, its bounds have to be checked; by making the stack grow downwards, the underflow detection of the offset update operation can also be reused to check for stack overflow.

A few opcodes require pushing and/or popping multiple elements. The push and pop methods support working with multiple elements instead of a single one, reducing the number of checks performed on the stack.

Fields

values: Box<[U256; 1024]>

offset: usize

Implementations

impl Stack

pub fn pop<const N: usize>(&mut self) -> Result<&[U256; N], ExceptionalHalt>

pub fn pop1(&mut self) -> Result<U256, ExceptionalHalt>

pub fn top_mut(&mut self) -> Result<&mut U256, ExceptionalHalt>

Mutable reference to the top item without changing depth (one underflow check, no offset write). For stack-neutral unary ops (ISZERO, NOT, CLZ), replacing pop1 + push with *top_mut() = f(*top) avoids the read-modify-write of the shared offset, which is the per-opcode serial dependency that pins dispatch IPC.

pub fn pop1_and_top_mut(&mut self) -> Result<(U256, &mut U256), ExceptionalHalt>

Pop the top value and return it together with a mutable reference to the new top. For binary ops: let (a, b) = pop1_and_top_mut()?; *b = f(a, *b) writes the result in place (one offset write instead of pop::<2> + push’s two), where a is the original top and *b the original second operand.

pub fn push(&mut self, value: U256) -> Result<(), ExceptionalHalt>

Push a single U256 value to the stack, faster than the generic push.

pub fn push_zero(&mut self) -> Result<(), ExceptionalHalt>

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn swap<const N: usize>(&mut self) -> Result<(), ExceptionalHalt>

pub fn clear(&mut self)

pub fn dup<const N: usize>(&mut self) -> Result<(), ExceptionalHalt>

Pushes a copy of the value at depth N

Trait Implementations

impl Clone for Stack

fn clone(&self) -> Stack

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Stack

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

Formats the value using the given formatter.

impl Default for Stack

fn default() -> Self

Returns the “default value” for a type.

impl Eq for Stack

impl Hash for Stack

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Stack

fn eq(&self, other: &Stack) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Stack