make dispatching host functions use Inst instead of &Instance

Author: Robbepop

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

@@ -155,8 +155,8 @@ fn handle_reason(reason: Option<DoneReason>) -> Result<Sp, Error> {
     };
     match reason {
         DoneReason::Trap(trap_code) => Err(Error::from(trap_code)),
-        DoneReason::OutOfFuel { required_fuel: _ } => todo!(),
-        DoneReason::Host(_host_error) => todo!(),
+        DoneReason::OutOfFuel(_error) => todo!(),
+        DoneReason::Host(_error) => todo!(),
         DoneReason::CompileError(_error) => todo!(),
         DoneReason::Return(sp) => Ok(sp),
     }

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

@@ -27,6 +27,8 @@ use crate::{
             },
         },
         EngineFunc,
+        ResumableHostTrapError,
+        ResumableOutOfFuelError,
     },
     errors::{FuelError, MemoryError},
     func::FuncEntity,
@@ -75,7 +77,10 @@ pub fn consume_fuel(
         .fuel_mut()
         .consume_fuel_unchecked(u64::from(fuel));
     if let Err(FuelError::OutOfFuel { required_fuel }) = consumption_result {
-        done!(state, DoneReason::OutOfFuel { required_fuel });
+        done!(
+            state,
+            DoneReason::OutOfFuel(ResumableOutOfFuelError::new(required_fuel))
+        );
     }
     dispatch!(state, ip, sp, mem0, mem0_len, instance)
 }
@@ -509,7 +514,10 @@ pub fn memory_grow(
             }
         }
         Err(StoreError::External(MemoryError::OutOfFuel { required_fuel })) => {
-            done!(state, DoneReason::OutOfFuel { required_fuel });
+            done!(
+                state,
+                DoneReason::OutOfFuel(ResumableOutOfFuelError::new(required_fuel))
+            );
         }
         Err(StoreError::External(MemoryError::ResourceLimiterDeniedAllocation)) => {
             done!(state, TrapCode::GrowthOperationLimited);

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

@@ -9,5 +9,5 @@ mod state;
 use self::{dispatch::Done, state::DoneReason};
 pub use self::{
     dispatch::{init_wasm_func_call, op_code_to_handler},
-    state::Stack,
+    state::{Inst, Stack},
 };

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

@@ -3,6 +3,8 @@ use crate::{
     engine::{
         executor::{handler::utils::extract_mem0, CodeMap},
         utils::unreachable_unchecked,
+        ResumableHostTrapError,
+        ResumableOutOfFuelError,
         StackConfig,
     },
     errors::HostError,
@@ -12,7 +14,7 @@ use crate::{
     Error,
     TrapCode,
 };
-use alloc::{boxed::Box, vec::Vec};
+use alloc::vec::Vec;
 use core::{
     ptr::{self, NonNull},
     slice,
@@ -53,8 +55,8 @@ impl<'vm> VmState<'vm> {
 pub enum DoneReason {
     Return(Sp),
     Trap(TrapCode),
-    OutOfFuel { required_fuel: u64 },
-    Host(Box<dyn HostError>),
+    Host(ResumableHostTrapError),
+    OutOfFuel(ResumableOutOfFuelError),
     CompileError(Error),
 }
 

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

@@ -1,6 +1,6 @@
 #![expect(dead_code)]
 
-pub use self::handler::{op_code_to_handler, Stack};
+pub use self::handler::{op_code_to_handler, Inst, Stack};
 use super::{code_map::CodeMap, ResumableError};
 use crate::{
     engine::{

crates/wasmi/src/engine/mod.rs

@@ -13,7 +13,7 @@ mod utils;
 
 pub(crate) use self::{
     block_type::BlockType,
-    executor::Stack,
+    executor::{Inst, Stack},
     func_types::DedupFuncType,
     translator::{
         FuncTranslationDriver,

crates/wasmi/src/engine/resumable.rs

@@ -71,7 +71,6 @@ impl fmt::Display for ResumableHostTrapError {
 impl ResumableHostTrapError {
     /// Creates a new [`ResumableHostTrapError`].
     #[cold]
-    #[expect(unused)]
     pub(crate) fn new(host_error: Error, host_func: Func, caller_results: SlotSpan) -> Self {
         Self {
             host_error,

crates/wasmi/src/func/caller.rs

@@ -1,5 +1,5 @@
 use super::super::{AsContext, AsContextMut, StoreContext, StoreContextMut};
-use crate::{Engine, Error, Extern, Instance};
+use crate::{engine::Inst, Engine, Error, Extern};
 
 /// Represents the caller’s context when creating a host function via [`Func::wrap`].
 ///
@@ -10,18 +10,18 @@ pub struct Caller<'a, T> {
     /// This is `Some` if the host function was called from a Wasm function
     /// since all Wasm function are associated to a module instance.
     /// This usually is `None` if the host function was called from the host side.
-    instance: Option<Instance>,
+    instance: Option<Inst>,
 }
 
 impl<'a, T> Caller<'a, T> {
     /// Creates a new [`Caller`] from the given store context and [`Instance`] handle.
-    pub(crate) fn new<C>(ctx: &'a mut C, instance: Option<&Instance>) -> Self
+    pub(crate) fn new<C>(ctx: &'a mut C, instance: Option<Inst>) -> Self
     where
         C: AsContextMut<Data = T>,
     {
         Self {
             ctx: ctx.as_context_mut(),
-            instance: instance.copied(),
+            instance,
         }
     }
 
@@ -30,8 +30,11 @@ impl<'a, T> Caller<'a, T> {
     /// Returns `None` if there is no associated [`Instance`] of the caller
     /// or if the caller does not provide an export under the name `name`.
     pub fn get_export(&self, name: &str) -> Option<Extern> {
-        self.instance
-            .and_then(|instance| instance.get_export(self, name))
+        let Some(instance) = &self.instance else {
+            return None;
+        };
+        let instance = unsafe { instance.as_ref() };
+        instance.get_export(name)
     }
 
     /// Returns a shared reference to the user provided host data.

crates/wasmi/src/func/mod.rs

@@ -23,7 +23,13 @@ use super::{
     StoreContext,
     Stored,
 };
-use crate::{collections::arena::ArenaIndex, engine::ResumableCall, Engine, Error, Val};
+use crate::{
+    collections::arena::ArenaIndex,
+    engine::{Inst, ResumableCall},
+    Engine,
+    Error,
+    Val,
+};
 use alloc::{boxed::Box, sync::Arc};
 use core::{fmt, fmt::Debug, num::NonZeroU32};
 
@@ -294,7 +300,7 @@ impl<T> TrampolineEntity<T> {
     pub fn call(
         &self,
         mut ctx: impl AsContextMut<Data = T>,
-        instance: Option<&Instance>,
+        instance: Option<Inst>,
         params: FuncInOut,
     ) -> Result<FuncFinished, Error> {
         let caller = <Caller<T>>::new(&mut ctx, instance);

crates/wasmi/src/store/mod.rs

@@ -14,10 +14,10 @@ pub use self::{
 use crate::{
     collections::arena::Arena,
     core::{CoreMemory, ResourceLimiterRef},
-    func::{FuncInOut, HostFuncEntity, Trampoline, TrampolineEntity, TrampolineIdx},
+    engine::Inst,
+    func::{FuncInOut, Trampoline, TrampolineEntity, TrampolineIdx},
     Engine,
     Error,
-    Instance,
     Memory,
     ResourceLimiter,
 };
@@ -108,11 +108,11 @@ impl<T> Store<T> {
     /// If the called host function returned an error.
     fn call_host_func(
         &mut self,
-        func: &HostFuncEntity,
-        instance: Option<&Instance>,
+        trampoline: Trampoline,
+        instance: Option<Inst>,
         params_results: FuncInOut,
     ) -> Result<(), StoreError<Error>> {
-        let trampoline = self.resolve_trampoline(func.trampoline())?.clone();
+        let trampoline = self.resolve_trampoline(&trampoline)?.clone();
         trampoline
             .call(self, instance, params_results)
             .map_err(StoreError::external)?;