implement call resumption after running out of fuel

Author: Robbepop

crates/wasmi/src/engine/executor/handler/dispatch.rs

@@ -154,6 +154,23 @@ pub fn init_wasm_func_call<'a, T>(
     })
 }
 
+pub fn resume_wasm_func_call<'a, T>(
+    store: &'a mut Store<T>,
+    code: &'a CodeMap,
+    stack: &'a mut Stack,
+) -> Result<WasmFuncCall<'a, T, state::Init>, Error> {
+    let (callee_ip, callee_sp, instance) = stack.restore_frame();
+    Ok(WasmFuncCall {
+        store,
+        stack,
+        code,
+        callee_ip,
+        callee_sp,
+        instance,
+        state: PhantomData,
+    })
+}
+
 #[cfg(feature = "trampolines")]
 pub fn execute_until_done(
     mut state: VmState,

crates/wasmi/src/engine/executor/handler/mod.rs

@@ -9,7 +9,7 @@ mod state;
 #[cfg(feature = "trampolines")]
 use self::dispatch::ControlContinue;
 pub use self::{
-    dispatch::{init_wasm_func_call, op_code_to_handler, ExecutionOutcome},
+    dispatch::{init_wasm_func_call, op_code_to_handler, resume_wasm_func_call, ExecutionOutcome},
     state::{Inst, Stack},
 };
 use self::{

crates/wasmi/src/engine/executor/handler/state.rs

@@ -285,6 +285,14 @@ impl Stack {
         self.frames.sync_ip(ip);
     }
 
+    pub fn restore_frame(&mut self) -> (Ip, Sp, Inst) {
+        let Some((ip, start, instance)) = self.frames.restore_frame() else {
+            panic!("restore_frame: missing top-frame")
+        };
+        let sp = self.values.sp(start);
+        (ip, sp, instance)
+    }
+
     pub fn return_prepare_host_frame<'a>(
         &'a mut self,
         callee_params: BoundedSlotSpan,
@@ -568,6 +576,12 @@ impl CallStack {
         top.ip = ip;
     }
 
+    fn restore_frame(&self) -> Option<(Ip, usize, Inst)> {
+        let instance = self.instance?;
+        let top = self.top()?;
+        Some((top.ip, top.start, instance))
+    }
+
     fn prepare_host_frame(&mut self, caller_ip: Option<Ip>) -> usize {
         if let Some(caller_ip) = caller_ip {
             self.sync_ip(caller_ip);

crates/wasmi/src/engine/executor/mod.rs

@@ -2,7 +2,7 @@ pub use self::handler::{op_code_to_handler, Inst, Stack};
 use super::code_map::CodeMap;
 use crate::{
     engine::{
-        executor::handler::{init_wasm_func_call, ExecutionOutcome},
+        executor::handler::{init_wasm_func_call, resume_wasm_func_call, ExecutionOutcome},
         CallParams,
         CallResults,
         EngineInner,
@@ -284,16 +284,16 @@ impl<'engine> EngineExecutor<'engine> {
     /// - When encountering a Wasm or host trap during the execution of `func`.
     fn resume_func_out_of_fuel<T, Results>(
         &mut self,
-        _store: &mut Store<T>,
-        _results: Results,
+        store: &mut Store<T>,
+        results: Results,
     ) -> Result<<Results as CallResults>::Results, ExecutionOutcome>
     where
         Results: CallResults,
     {
-        // self.execute_func(store)?;
-        // let results = self.write_results_back(results);
-        // Ok(results)
-        todo!()
+        let results = resume_wasm_func_call(store, self.code_map, self.stack)?
+            .execute()?
+            .write_results(results);
+        Ok(results)
     }
 
     /// Convenience forwarder to dispatch host functions.