use new store internal errors in executor

Robbepop · Robbepop · commit 20a19379ba41 · 2025-11-01T15:51:09.000+01:00
diff --git a/crates/wasmi/src/engine/executor/handler/dispatch.rs b/crates/wasmi/src/engine/executor/handler/dispatch.rs
@@ -1,7 +1,7 @@
 use super::{
     exec,
     state::{DoneReason, Ip, Mem0Len, Mem0Ptr, Sp, Stack, VmState},
-    utils::set_value,
+    utils::{resolve_instance, set_value},
 };
 use crate::{
     engine::{executor::handler::utils, CallParams, CallResults, CodeMap, EngineFunc},
@@ -95,7 +95,7 @@ impl<'a, T> WasmFuncCall<'a, T, state::Init> {
     }
 
     fn execute_until_done(&mut self) -> Option<DoneReason> {
-        let instance = self.store.inner.resolve_instance(&self.instance).into();
+        let instance = resolve_instance(self.store.prune(), &self.instance).into();
         let store = self.store.prune();
         let (mem0, mem0_len) = utils::extract_mem0(store, instance);
         let state = VmState::new(store, self.stack, self.code);
@@ -130,7 +130,7 @@ pub fn init_wasm_func_call<'a, T>(
     let callee_ip = Ip::from(compiled_func.ops());
     let frame_size = compiled_func.len_stack_slots();
     let callee_params = BoundedSlotSpan::new(SlotSpan::new(Slot::from(0)), frame_size);
-    let instance_ref = store.inner.resolve_instance(&instance);
+    let instance_ref = resolve_instance(store.prune(), &instance);
     let callee_sp = stack.push_frame(
         None,
         callee_ip,
diff --git a/crates/wasmi/src/engine/executor/handler/exec.rs b/crates/wasmi/src/engine/executor/handler/exec.rs
@@ -2,7 +2,7 @@ use super::{
     dispatch::Done,
     eval,
     state::{mem0_bytes, Ip, Mem0Len, Mem0Ptr, Sp, VmState},
-    utils::{get_value, memory_bytes, offset_ip, resolve_func, set_value, IntoTrapResult as _},
+    utils::{fetch_func, get_value, memory_bytes, offset_ip, set_value, IntoTrapResult as _},
 };
 use crate::{
     core::{wasm, UntypedVal},
@@ -14,8 +14,12 @@ use crate::{
                 exec_copy_span_asc,
                 exec_copy_span_des,
                 extract_mem0,
+                fetch_global,
+                fetch_memory,
+                resolve_func,
                 resolve_global,
                 resolve_indirect_func,
+                resolve_instance,
                 resolve_memory,
                 set_global,
                 update_instance,
@@ -26,8 +30,8 @@ use crate::{
     errors::{FuelError, MemoryError},
     func::FuncEntity,
     instance::InstanceEntity,
-    ir,
-    ir::{Slot, SlotSpan},
+    ir::{self, Slot, SlotSpan},
+    store::StoreError,
     TrapCode,
 };
 use core::{cmp, ptr::NonNull};
@@ -139,8 +143,9 @@ pub fn global_get(
     instance: NonNull<InstanceEntity>,
 ) -> Done {
     let (ip, crate::ir::decode::GlobalGet { result, global }) = unsafe { decode_op(ip) };
-    let global = resolve_global(instance, global);
-    let value = *state.store.inner().resolve_global(&global).get_untyped();
+    let global = fetch_global(instance, global);
+    let global = resolve_global(state.store, &global);
+    let value = *global.get_untyped();
     set_value(sp, result, value);
     dispatch!(state, ip, sp, mem0, mem0_len, instance)
 }
@@ -217,19 +222,15 @@ pub fn call_imported(
     instance: NonNull<InstanceEntity>,
 ) -> Done {
     let (caller_ip, crate::ir::decode::CallImported { params, func }) = unsafe { decode_op(ip) };
-    let func = resolve_func(instance, func);
-    let func = state.store.inner().resolve_func(&func);
+    let func = fetch_func(instance, func);
+    let func = resolve_func(state.store, &func);
     let (callee_ip, sp, mem0, mem0_len, instance) = match func {
         FuncEntity::Wasm(func) => {
             let engine_func = func.func_body();
             let callee_instance = *func.instance();
             let (callee_ip, size) =
                 compile_or_get_func!(state, ip, sp, mem0, mem0_len, instance, engine_func);
-            let callee_instance: NonNull<InstanceEntity> = state
-                .store
-                .inner()
-                .resolve_instance(&callee_instance)
-                .into();
+            let callee_instance = resolve_instance(state.store, &callee_instance).into();
             let callee_sp = match state.stack.push_frame(
                 Some(caller_ip),
                 callee_ip,
@@ -272,18 +273,15 @@ pub fn call_indirect(
         Ok(func) => func,
         Err(trap) => break_with_trap!(trap, state, ip, sp, mem0, mem0_len, instance),
     };
-    let func = state.store.inner().resolve_func(&func);
+    let func = resolve_func(state.store, &func);
     let (callee_ip, sp, mem0, mem0_len, instance) = match func {
         FuncEntity::Wasm(func) => {
             let engine_func = func.func_body();
             let callee_instance = *func.instance();
             let (callee_ip, size) =
                 compile_or_get_func!(state, ip, sp, mem0, mem0_len, instance, engine_func);
-            let callee_instance: NonNull<InstanceEntity> = state
-                .store
-                .inner()
-                .resolve_instance(&callee_instance)
-                .into();
+            let callee_instance: NonNull<InstanceEntity> =
+                resolve_instance(state.store, &callee_instance).into();
             let callee_sp = match state.stack.push_frame(
                 Some(caller_ip),
                 callee_ip,
@@ -366,8 +364,8 @@ pub fn memory_size(
     instance: NonNull<InstanceEntity>,
 ) -> Done {
     let (ip, crate::ir::decode::MemorySize { memory, result }) = unsafe { decode_op(ip) };
-    let memory = resolve_memory(instance, memory);
-    let size = state.store.inner().resolve_memory(&memory).size();
+    let memory = fetch_memory(instance, memory);
+    let size = resolve_memory(state.store, &memory).size();
     set_value(sp, result, size);
     dispatch!(state, ip, sp, mem0, mem0_len, instance)
 }
@@ -389,7 +387,7 @@ pub fn memory_grow(
         },
     ) = unsafe { decode_op(ip) };
     let delta: u64 = get_value(delta, sp);
-    let memref = resolve_memory(instance, memory);
+    let memref = fetch_memory(instance, memory);
     let mut mem0 = mem0;
     let mut mem0_len = mem0_len;
     let return_value = match state.store.grow_memory(&memref, delta) {
@@ -402,18 +400,20 @@ pub fn memory_grow(
             }
             return_value
         }
-        Err(MemoryError::OutOfBoundsGrowth | MemoryError::OutOfSystemMemory) => {
-            let memory_ty = state.store.inner().resolve_memory(&memref).ty();
+        Err(StoreError::External(
+            MemoryError::OutOfBoundsAccess | MemoryError::OutOfSystemMemory,
+        )) => {
+            let memory_ty = resolve_memory(state.store, &memref).ty();
             match memory_ty.is_64() {
                 true => u64::MAX,
                 false => u64::from(u32::MAX),
             }
         }
-        Err(MemoryError::OutOfFuel { required_fuel }) => {
+        Err(StoreError::External(MemoryError::OutOfFuel { required_fuel })) => {
             state.done(DoneReason::OutOfFuel { required_fuel });
             return exec_break!(ip, sp, mem0, mem0_len, instance);
         }
-        Err(MemoryError::ResourceLimiterDeniedAllocation) => {
+        Err(StoreError::External(MemoryError::ResourceLimiterDeniedAllocation)) => {
             break_with_trap!(
                 TrapCode::GrowthOperationLimited,
                 state,
@@ -424,7 +424,16 @@ pub fn memory_grow(
                 instance
             )
         }
-        Err(error) => panic!("encountered an unexpected error: {error}"),
+        Err(StoreError::Internal(_error)) => {
+            // TODO: we do not want to panic in the executor handlers so we somehow
+            //       want to establish a way to signal to the executor that a panic
+            //       occurred, instead.
+            todo!()
+        }
+        Err(error) => {
+            // TODO: see above
+            panic!("encountered an unexpected error: {error}")
+        }
     };
     set_value(sp, result, return_value);
     dispatch!(state, ip, sp, mem0, mem0_len, instance)
diff --git a/crates/wasmi/src/engine/executor/handler/utils.rs b/crates/wasmi/src/engine/executor/handler/utils.rs
@@ -1,13 +1,17 @@
 use super::state::{mem0_bytes, Ip, Mem0Len, Mem0Ptr, Sp, VmState};
 use crate::{
-    core::{ReadAs, UntypedVal, WriteAs},
+    core::{CoreElementSegment, CoreGlobal, CoreMemory, CoreTable, ReadAs, UntypedVal, WriteAs},
     engine::{DedupFuncType, EngineFunc},
+    func::FuncEntity,
     instance::InstanceEntity,
     ir::{index, Address, BranchOffset, Offset16, Sign, Slot, SlotSpan},
-    store::PrunedStore,
+    memory::DataSegment,
+    store::{PrunedStore, StoreInner},
+    table::ElementSegment,
     Error,
     Func,
     Global,
+    Instance,
     Memory,
     Ref,
     Table,
@@ -178,7 +182,7 @@ pub fn extract_mem0(
     let Some(memory) = instance.get_memory(0) else {
         return (Mem0Ptr::from([].as_mut_ptr()), Mem0Len::from(0));
     };
-    let mem0 = store.inner_mut().resolve_memory_mut(&memory).data_mut();
+    let mem0 = resolve_memory_mut(store, &memory).data_mut();
     let mem0_ptr = mem0.as_mut_ptr();
     let mem0_len = mem0.len();
     (Mem0Ptr::from(mem0_ptr), Mem0Len::from(mem0_len))
@@ -198,11 +202,7 @@ pub fn memory_bytes<'a>(
             let Some(memory) = instance.get_memory(u32::from(u16::from(memory))) else {
                 return &mut [];
             };
-            state
-                .store
-                .inner_mut()
-                .resolve_memory_mut(&memory)
-                .data_mut()
+            resolve_memory_mut(state.store, &memory).data_mut()
         }
     }
 }
@@ -211,7 +211,7 @@ pub fn offset_ip(ip: Ip, offset: BranchOffset) -> Ip {
     unsafe { ip.offset(i32::from(offset) as isize) }
 }
 
-macro_rules! impl_resolve_entity {
+macro_rules! impl_fetch_from_instance {
     (
         $( fn $fn:ident($param:ident: $ty:ty) -> $ret:ty = $getter:expr );* $(;)?
     ) => {
@@ -232,16 +232,52 @@ macro_rules! impl_resolve_entity {
         )*
     };
 }
-impl_resolve_entity! {
-    fn resolve_func(func: index::Func) -> Func = InstanceEntity::get_func;
-    fn resolve_global(global: index::Global) -> Global = InstanceEntity::get_global;
-    fn resolve_memory(memory: index::Memory) -> Memory = InstanceEntity::get_memory;
-    fn resolve_table(table: index::Table) -> Table = InstanceEntity::get_table;
-    fn resolve_func_type_dedup(func_type: index::FuncType) -> DedupFuncType = {
+impl_fetch_from_instance! {
+    fn fetch_data(func: index::Data) -> DataSegment = InstanceEntity::get_data_segment;
+    fn fetch_elem(func: index::Elem) -> ElementSegment = InstanceEntity::get_element_segment;
+    fn fetch_func(func: index::Func) -> Func = InstanceEntity::get_func;
+    fn fetch_global(global: index::Global) -> Global = InstanceEntity::get_global;
+    fn fetch_memory(memory: index::Memory) -> Memory = InstanceEntity::get_memory;
+    fn fetch_table(table: index::Table) -> Table = InstanceEntity::get_table;
+    fn fetch_func_type(func_type: index::FuncType) -> DedupFuncType = {
         |instance: &InstanceEntity, index: u32| instance.get_signature(index).copied()
     };
 }
 
+macro_rules! impl_resolve_from_store {
+    (
+        $( fn $fn:ident($param:ident: $ty:ty) -> $ret:ty = $getter:expr );* $(;)?
+    ) => {
+        $(
+            pub fn $fn<'a>(store: &'a mut PrunedStore, $param: $ty) -> $ret {
+                match $getter(store.inner_mut(), $param) {
+                    ::core::result::Result::Ok($param) => $param,
+                    ::core::result::Result::Err(error) => unsafe {
+                        $crate::engine::utils::unreachable_unchecked!(
+                            ::core::concat!("could not resolve stored ", ::core::stringify!($param), ": {:?}"),
+                            error,
+                        )
+                    },
+                }
+            }
+        )*
+    };
+}
+impl_resolve_from_store! {
+    fn resolve_elem(elem: &ElementSegment) -> &'a CoreElementSegment = StoreInner::try_resolve_element;
+    fn resolve_func(func: &Func) -> &'a FuncEntity = StoreInner::try_resolve_func;
+    fn resolve_global(global: &Global) -> &'a CoreGlobal = StoreInner::try_resolve_global;
+    fn resolve_memory(memory: &Memory) -> &'a CoreMemory = StoreInner::try_resolve_memory;
+    fn resolve_table(table: &Table) -> &'a CoreTable = StoreInner::try_resolve_table;
+    fn resolve_instance(func: &Instance) -> &'a InstanceEntity = StoreInner::try_resolve_instance;
+    // fn resolve_func_type(func_type: DedupFuncType) -> DedupFuncType = StoreInner::resolve_func_type;
+
+    fn resolve_elem_mut(elem: &ElementSegment) -> &'a mut CoreElementSegment = StoreInner::try_resolve_element_mut;
+    fn resolve_global_mut(global: &Global) -> &'a mut CoreGlobal = StoreInner::try_resolve_global_mut;
+    fn resolve_memory_mut(memory: &Memory) -> &'a mut CoreMemory = StoreInner::try_resolve_memory_mut;
+    fn resolve_table_mut(table: &Table) -> &'a mut CoreTable = StoreInner::try_resolve_table_mut;
+}
+
 pub fn resolve_indirect_func(
     index: Slot,
     table: index::Table,
@@ -250,19 +286,17 @@ pub fn resolve_indirect_func(
     sp: Sp,
     instance: NonNull<InstanceEntity>,
 ) -> Result<Func, TrapCode> {
-    let table = resolve_table(instance, table);
     let index = get_value(index, sp);
-    let funcref = state
-        .store
-        .inner()
-        .resolve_table(&table)
+    let table = fetch_table(instance, table);
+    let table = resolve_table(state.store, &table);
+    let funcref = table
         .get_untyped(index)
         .map(<Ref<Func>>::from)
         .ok_or(TrapCode::TableOutOfBounds)?;
     let func = funcref.val().ok_or(TrapCode::IndirectCallToNull)?;
-    let actual_signature = state.store.inner().resolve_func(func).ty_dedup();
-    let expected_signature = resolve_func_type_dedup(instance, func_type);
-    if expected_signature.ne(actual_signature) {
+    let actual_fnty = resolve_func(state.store, func).ty_dedup();
+    let expected_fnty = fetch_func_type(instance, func_type);
+    if expected_fnty.ne(actual_fnty) {
         return Err(TrapCode::BadSignature);
     }
     Ok(*func)
@@ -274,13 +308,10 @@ pub fn set_global(
     state: &mut VmState,
     instance: NonNull<InstanceEntity>,
 ) {
-    let global = resolve_global(instance, global);
-    let mut global_ptr = state
-        .store
-        .inner_mut()
-        .resolve_global_mut(&global)
-        .get_untyped_ptr();
-    let global_ref = unsafe { global_ptr.as_mut() };
+    let global = fetch_global(instance, global);
+    let global = resolve_global_mut(state.store, &global);
+    let mut value_ptr = global.get_untyped_ptr();
+    let global_ref = unsafe { value_ptr.as_mut() };
     *global_ref = value;
 }
 
