initial EngineExecutor impls using WasmFuncCall

Lots of todos and unimplemented stuff. very WIP but works on some basic things already. there may be dragons. lots of dragons.

Author: Robbepop

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

@@ -1,9 +1,10 @@
 #![expect(dead_code)]
 
-pub(crate) use self::stack::Stack;
-use self::{instr_ptr::InstructionPtr, instrs::execute_instrs, stack::CallFrame};
+pub use self::handler::{op_code_to_handler, Stack};
+use super::{code_map::CodeMap, ResumableError};
 use crate::{
     engine::{
+        executor::handler::init_wasm_func_call,
         CallParams,
         CallResults,
         EngineInner,
@@ -12,22 +13,15 @@ use crate::{
         ResumableCallOutOfFuel,
     },
     func::HostFuncEntity,
-    ir::{Slot, SlotSpan},
-    CallHook,
+    ir::SlotSpan,
     Error,
     Func,
     FuncEntity,
     Store,
     StoreContextMut,
 };
 
-use super::{code_map::CodeMap, ResumableError};
-
-mod cache;
 mod handler;
-mod instr_ptr;
-mod instrs;
-mod stack;
 
 impl EngineInner {
     /// Executes the given [`Func`] with the given `params` and returns the `results`.
@@ -249,54 +243,21 @@ impl<'engine> EngineExecutor<'engine> {
         match store.inner.resolve_func(func) {
             FuncEntity::Wasm(wasm_func) => {
                 // We reserve space on the stack to write the results of the root function execution.
-                let len_results = results.len_results();
-                self.stack.values.extend_by(len_results, do_nothing)?;
                 let instance = *wasm_func.instance();
                 let engine_func = wasm_func.func_body();
-                let compiled_func = self
-                    .code_map
-                    .get(Some(store.inner.fuel_mut()), engine_func)?;
-                let (mut uninit_params, offsets) = self
-                    .stack
-                    .values
-                    .alloc_call_frame(compiled_func, do_nothing)?;
-                for value in params.call_params() {
-                    unsafe { uninit_params.init_next(value) };
-                }
-                uninit_params.init_zeroes();
-                self.stack.calls.push(
-                    CallFrame::new(
-                        InstructionPtr::new(compiled_func.ops().as_ptr()),
-                        offsets,
-                        SlotSpan::new(Slot::from(0)),
-                    ),
-                    Some(instance),
-                )?;
-                store.invoke_call_hook(CallHook::CallingWasm)?;
-                self.execute_func(store)?;
-                store.invoke_call_hook(CallHook::ReturningFromWasm)?;
+                let call =
+                    init_wasm_func_call(store, self.code_map, self.stack, engine_func, instance)?;
+                let results = call.write_params(params).execute()?.write_results(results);
+                Ok(results)
             }
-            FuncEntity::Host(host_func) => {
+            FuncEntity::Host(_host_func) => {
                 // The host function signature is required for properly
                 // adjusting, inspecting and manipulating the value stack.
                 // In case the host function returns more values than it takes
                 // we are required to extend the value stack.
-                let len_params = host_func.len_params();
-                let len_results = host_func.len_results();
-                let max_inout = len_params.max(len_results);
-                let uninit = self
-                    .stack
-                    .values
-                    .extend_by(usize::from(max_inout), do_nothing)?;
-                for (uninit, param) in uninit.iter_mut().zip(params.call_params()) {
-                    uninit.write(param);
-                }
-                let host_func = *host_func;
-                self.dispatch_host_func(store, host_func)?;
+                todo!()
             }
-        };
-        let results = self.write_results_back(results);
-        Ok(results)
+        }
     }
 
     /// Resumes the execution of the given [`Func`] using `params` after a host function trapped.
@@ -310,28 +271,29 @@ impl<'engine> EngineExecutor<'engine> {
     /// - When encountering a Wasm or host trap during the execution of `func`.
     fn resume_func_host_trap<T, Results>(
         &mut self,
-        store: &mut Store<T>,
-        params: impl CallParams,
-        caller_results: SlotSpan,
-        results: Results,
+        _store: &mut Store<T>,
+        _params: impl CallParams,
+        _caller_results: SlotSpan,
+        _results: Results,
     ) -> Result<<Results as CallResults>::Results, Error>
     where
         Results: CallResults,
     {
-        let caller = self
-            .stack
-            .calls
-            .peek()
-            .expect("must have caller call frame on stack upon function resumption");
-        let mut caller_sp = unsafe { self.stack.values.stack_ptr_at(caller.base_offset()) };
-        let call_params = params.call_params();
-        let len_params = call_params.len();
-        for (result, param) in caller_results.iter_sized(len_params).zip(call_params) {
-            unsafe { caller_sp.set(result, param) };
-        }
-        self.execute_func(store)?;
-        let results = self.write_results_back(results);
-        Ok(results)
+        // let caller = self
+        //     .stack
+        //     .calls
+        //     .peek()
+        //     .expect("must have caller call frame on stack upon function resumption");
+        // let mut caller_sp = unsafe { self.stack.values.stack_ptr_at(caller.base_offset()) };
+        // let call_params = params.call_params();
+        // let len_params = call_params.len();
+        // for (result, param) in caller_results.iter_sized(len_params).zip(call_params) {
+        //     unsafe { caller_sp.set(result, param) };
+        // }
+        // self.execute_func(store)?;
+        // let results = self.write_results_back(results);
+        // Ok(results)
+        todo!()
     }
 
     /// Resumes the execution of the given [`Func`] using `params` after running out of fuel.
@@ -344,25 +306,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, Error>
     where
         Results: CallResults,
     {
-        self.execute_func(store)?;
-        let results = self.write_results_back(results);
-        Ok(results)
-    }
-
-    /// Executes the top most Wasm function on the [`Stack`] until the [`Stack`] is empty.
-    ///
-    /// # Errors
-    ///
-    /// When encountering a Wasm or host trap during execution.
-    #[inline(always)]
-    fn execute_func<T>(&mut self, store: &mut Store<T>) -> Result<(), Error> {
-        execute_instrs(store.prune(), self.stack, self.code_map)
+        // self.execute_func(store)?;
+        // let results = self.write_results_back(results);
+        // Ok(results)
+        todo!()
     }
 
     /// Convenience forwarder to dispatch host functions.
@@ -382,22 +335,4 @@ impl<'engine> EngineExecutor<'engine> {
         // Ok(())
         todo!()
     }
-
-    /// Writes the results of the function execution back into the `results` buffer.
-    ///
-    /// # Note
-    ///
-    /// The value stack is empty after this operation.
-    ///
-    /// # Panics
-    ///
-    /// - If the `results` buffer length does not match the remaining amount of stack values.
-    #[inline(always)]
-    fn write_results_back<Results>(&mut self, results: Results) -> <Results as CallResults>::Results
-    where
-        Results: CallResults,
-    {
-        let len_results = results.len_results();
-        results.call_results(&self.stack.values.as_slice()[..len_results])
-    }
 }