optimize stack usage for recursive call and create programs

Cargo.toml

@@ -13,4 +13,4 @@ codegen-units = 1
 
 [profile.ethtests]
 inherits = "test"
-opt-level = 3
+opt-level = 3

bins/revm-test/src/bin/snailtracer.rs

@@ -48,7 +48,7 @@ pub fn simple_example() {
 
     let mut host = DummyHost::new(env);
     microbench::bench(&bench_options, "Snailtracer Interpreter benchmark", || {
-        let mut interpreter = Interpreter::new(contract.clone(), u64::MAX, false);
+        let mut interpreter = Interpreter::new(Box::new(contract.clone()), u64::MAX, false);
         interpreter.run::<_, BerlinSpec>(&mut host);
         host.clear()
     });

bins/revme/src/statetest/runner.rs

@@ -355,9 +355,15 @@ pub fn run(
         let console_bar = console_bar.clone();
         let elapsed = elapsed.clone();
 
+        let mut thread = std::thread::Builder::new();
+
+        // Allow bigger stack in debug mode to prevent stack overflow errors
+        if cfg!(debug_assertions) {
+            thread = thread.stack_size(3 * 1024 * 1024);
+        }
+
         joins.push(
-            std::thread::Builder::new()
-                .stack_size(50 * 1024 * 1024)
+            thread
                 .spawn(move || loop {
                     let (index, test_path) = {
                         let mut queue = queue.lock().unwrap();

crates/interpreter/src/instructions/host.rs

@@ -1,12 +1,12 @@
 use crate::primitives::{Bytes, Spec, SpecId::*, B160, B256, U256};
-use crate::MAX_INITCODE_SIZE;
 use crate::{
     alloc::vec::Vec,
     gas::{self, COLD_ACCOUNT_ACCESS_COST, WARM_STORAGE_READ_COST},
     interpreter::Interpreter,
     return_ok, return_revert, CallContext, CallInputs, CallScheme, CreateInputs, CreateScheme,
     Host, InstructionResult, Transfer,
 };
+use crate::{Gas, MAX_INITCODE_SIZE};
 use core::cmp::min;
 
 pub fn balance<SPEC: Spec>(interpreter: &mut Interpreter, host: &mut dyn Host) {
@@ -229,9 +229,9 @@ pub fn selfdestruct<SPEC: Spec>(interpreter: &mut Interpreter, host: &mut dyn Ho
     interpreter.instruction_result = InstructionResult::SelfDestruct;
 }
 
-pub fn create<const IS_CREATE2: bool, SPEC: Spec>(
+pub fn prepare_create_inputs<const IS_CREATE2: bool, SPEC: Spec>(
     interpreter: &mut Interpreter,
-    host: &mut dyn Host,
+    create_inputs: &mut Option<Box<CreateInputs>>,
 ) {
     check_staticcall!(interpreter);
     if IS_CREATE2 {
@@ -282,15 +282,21 @@ pub fn create<const IS_CREATE2: bool, SPEC: Spec>(
     }
     gas!(interpreter, gas_limit);
 
-    let mut create_input = CreateInputs {
+    *create_inputs = Some(Box::new(CreateInputs {
         caller: interpreter.contract.address,
         scheme,
         value,
         init_code: code,
         gas_limit,
-    };
+    }));
+}
+
+pub fn handle_create_result(
+    interpreter: &mut Interpreter,
+    result: (InstructionResult, Option<B160>, Gas, Bytes),
+) {
+    let (return_reason, address, gas, return_data) = result;
 
-    let (return_reason, address, gas, return_data) = host.create(&mut create_input);
     interpreter.return_data_buffer = match return_reason {
         // Save data to return data buffer if the create reverted
         return_revert!() => return_data,
@@ -321,6 +327,24 @@ pub fn create<const IS_CREATE2: bool, SPEC: Spec>(
     }
 }
 
+pub fn create<const IS_CREATE2: bool, SPEC: Spec>(
+    interpreter: &mut Interpreter,
+    host: &mut dyn Host,
+) {
+    let mut create_input: Option<Box<CreateInputs>> = None;
+    prepare_create_inputs::<IS_CREATE2, SPEC>(interpreter, &mut create_input);
+
+    if create_input.is_none() {
+        return;
+    }
+
+    let mut create_input = create_input.unwrap();
+
+    let ret = host.create(&mut create_input);
+
+    handle_create_result(interpreter, ret);
+}
+
 pub fn call<SPEC: Spec>(interpreter: &mut Interpreter, host: &mut dyn Host) {
     call_inner::<SPEC>(interpreter, CallScheme::Call, host);
 }
@@ -337,18 +361,14 @@ pub fn static_call<SPEC: Spec>(interpreter: &mut Interpreter, host: &mut dyn Hos
     call_inner::<SPEC>(interpreter, CallScheme::StaticCall, host);
 }
 
-pub fn call_inner<SPEC: Spec>(
+fn prepare_call_inputs<SPEC: Spec>(
     interpreter: &mut Interpreter,
     scheme: CallScheme,
     host: &mut dyn Host,
+    result_len: &mut usize,
+    result_offset: &mut usize,
+    result_call_inputs: &mut Option<Box<CallInputs>>,
 ) {
-    match scheme {
-        CallScheme::DelegateCall => check!(interpreter, SPEC::enabled(HOMESTEAD)), // EIP-7: DELEGATECALL
-        CallScheme::StaticCall => check!(interpreter, SPEC::enabled(BYZANTIUM)), // EIP-214: New opcode STATICCALL
-        _ => (),
-    }
-    interpreter.return_data_buffer = Bytes::new();
-
     pop!(interpreter, local_gas_limit);
     pop_address!(interpreter, to);
     let local_gas_limit = u64::try_from(local_gas_limit).unwrap_or(u64::MAX);
@@ -381,14 +401,14 @@ pub fn call_inner<SPEC: Spec>(
         Bytes::new()
     };
 
-    let out_len = as_usize_or_fail!(interpreter, out_len, InstructionResult::InvalidOperandOOG);
-    let out_offset = if out_len != 0 {
+    *result_len = as_usize_or_fail!(interpreter, out_len, InstructionResult::InvalidOperandOOG);
+    *result_offset = if *result_len != 0 {
         let out_offset = as_usize_or_fail!(
             interpreter,
             out_offset,
             InstructionResult::InvalidOperandOOG
         );
-        memory_resize!(interpreter, out_offset, out_len);
+        memory_resize!(interpreter, out_offset, *result_len);
         out_offset
     } else {
         usize::MAX //unrealistic value so we are sure it is not used
@@ -476,19 +496,25 @@ pub fn call_inner<SPEC: Spec>(
     }
     let is_static = matches!(scheme, CallScheme::StaticCall) || interpreter.is_static;
 
-    let mut call_input = CallInputs {
+    *result_call_inputs = Some(Box::new(CallInputs {
         contract: to,
         transfer,
         input,
         gas_limit,
         context,
         is_static,
-    };
-
-    // Call host to interuct with target contract
-    let (reason, gas, return_data) = host.call(&mut call_input);
+    }));
+}
 
-    interpreter.return_data_buffer = return_data;
+fn handle_call_result(
+    interpreter: &mut Interpreter,
+    out_offset: usize,
+    out_len: usize,
+    reason: &InstructionResult,
+    gas: &Gas,
+    return_data: &Bytes,
+) {
+    interpreter.return_data_buffer = return_data.clone();
 
     let target_len = min(out_len, interpreter.return_data_buffer.len());
 
@@ -521,3 +547,47 @@ pub fn call_inner<SPEC: Spec>(
         }
     }
 }
+
+pub fn call_inner<SPEC: Spec>(
+    interpreter: &mut Interpreter,
+    scheme: CallScheme,
+    host: &mut dyn Host,
+) {
+    match scheme {
+        CallScheme::DelegateCall => check!(interpreter, SPEC::enabled(HOMESTEAD)), // EIP-7: DELEGATECALL
+        CallScheme::StaticCall => check!(interpreter, SPEC::enabled(BYZANTIUM)), // EIP-214: New opcode STATICCALL
+        _ => (),
+    }
+    interpreter.return_data_buffer = Bytes::new();
+
+    let mut out_offset: usize = 0;
+    let mut out_len: usize = 0;
+    let mut call_input: Option<Box<CallInputs>> = None;
+    prepare_call_inputs::<SPEC>(
+        interpreter,
+        scheme,
+        host,
+        &mut out_len,
+        &mut out_offset,
+        &mut call_input,
+    );
+
+    if call_input.is_none() {
+        return;
+    }
+
+    // The Option is not needed form this point
+    let mut call_input = call_input.unwrap();
+
+    // Call host to interact with target contract
+    let (reason, gas, return_data) = host.call(&mut call_input);
+
+    handle_call_result(
+        interpreter,
+        out_offset,
+        out_len,
+        &reason,
+        &gas,
+        &return_data,
+    );
+}

crates/interpreter/src/interpreter.rs

@@ -42,7 +42,7 @@ pub struct Interpreter {
     /// Is interpreter call static.
     pub is_static: bool,
     /// Contract information and invoking data
-    pub contract: Contract,
+    pub contract: Box<Contract>,
     /// Memory limit. See [`crate::CfgEnv`].
     #[cfg(feature = "memory_limit")]
     pub memory_limit: u64,
@@ -55,7 +55,7 @@ impl Interpreter {
     }
 
     /// Create new interpreter
-    pub fn new(contract: Contract, gas_limit: u64, is_static: bool) -> Self {
+    pub fn new(contract: Box<Contract>, gas_limit: u64, is_static: bool) -> Self {
         #[cfg(not(feature = "memory_limit"))]
         {
             Self {
@@ -79,7 +79,7 @@ impl Interpreter {
 
     #[cfg(feature = "memory_limit")]
     pub fn new_with_memory_limit(
-        contract: Contract,
+        contract: Box<Contract>,
         gas_limit: u64,
         is_static: bool,
         memory_limit: u64,

crates/interpreter/src/interpreter/contract.rs

@@ -19,8 +19,16 @@ pub struct Contract {
 }
 
 impl Contract {
-    pub fn new(input: Bytes, bytecode: Bytecode, address: B160, caller: B160, value: U256) -> Self {
-        let bytecode = to_analysed(bytecode).try_into().expect("it is analyzed");
+    pub fn new(
+        input: Bytes,
+        bytecode: &Bytecode,
+        address: B160,
+        caller: B160,
+        value: U256,
+    ) -> Self {
+        let bytecode = to_analysed(bytecode.clone())
+            .try_into()
+            .expect("it is analyzed");
 
         Self {
             input,
@@ -39,7 +47,7 @@ impl Contract {
         };
         Self::new(
             env.tx.data.clone(),
-            bytecode,
+            &bytecode,
             contract_address,
             env.tx.caller,
             env.tx.value,
@@ -50,7 +58,7 @@ impl Contract {
         self.bytecode.jump_map().is_valid(possition)
     }
 
-    pub fn new_with_context(input: Bytes, bytecode: Bytecode, call_context: &CallContext) -> Self {
+    pub fn new_with_context(input: Bytes, bytecode: &Bytecode, call_context: &CallContext) -> Self {
         Self::new(
             input,
             bytecode,