refactor: move interop to separate crate

Signed-off-by: Florian Hartung <florian.hartung@dlr.de>

Author: florianhartung

Cargo.lock

@@ -4,13 +4,15 @@ members = [
   "crates/benchmark",
   "crates/checked",
   "crates/compare-testsuite-rs",
+  "crates/interop",
   "crates/linker",
   "crates/log_wrapper",
 ]
 resolver = "2"
 
 [workspace.dependencies]
 checked = { path = "crates/checked" }
+interop = { path = "crates/interop" }
 linker = { path = "crates/linker" }
 wasm-interpreter = { path = "." }
 
@@ -46,7 +48,8 @@ libm = "=0.2.8"
 log_wrapper.path = "crates/log_wrapper"
 
 [dev-dependencies]
-checked = { workspace = true, features = ["linker"] }
+checked = { workspace = true, features = ["linker", "interop"] }
+interop.workspace = true
 
 bumpalo = "3.17.0"
 env_logger = { workspace = true }

Cargo.toml

@@ -9,6 +9,7 @@ criterion = { version = "0.5.1", default-features = false, features = [
   "cargo_bench_support",
   "plotters",
 ] }
+interop.workspace = true
 wasm-interpreter = { path = "../..", default-features = false }
 wasmi = "0.40.0"
 wasmtime = { version = "27.0.0", default-features = false, features = [

crates/benchmark/Cargo.toml

@@ -5,6 +5,7 @@ use criterion::{
     Throughput,
 };
 
+use interop::StoreTypedInvocationExt;
 use wasm::{validate, Store};
 
 macro_rules! bench_wasm {

crates/benchmark/benches/general_purpose.rs

@@ -6,8 +6,9 @@ rust-version = "1.87.0" # Keep this in sync with the requirements!
 
 [dependencies]
 wasm-interpreter.workspace = true
+interop = { workspace = true, optional = true }
 linker = { workspace = true, optional = true }
 
 [features]
 # linker
-# TODO: interop
+# interop

crates/checked/Cargo.toml

@@ -1,12 +1,13 @@
 use alloc::{fmt::Debug, vec, vec::Vec};
+use interop::{InteropValueList, RefExtern, StoreTypedInvocationExt};
 use wasm::{
     addrs::FuncAddr,
-    interop::RefExtern,
+    config::Config,
     value::{ValueTypeMismatchError, F32, F64},
-    NumType, RefType, ValType,
+    HaltExecutionError, NumType, RefType, RuntimeError, ValType, Value,
 };
 
-use crate::{stored_types::Stored, StoredRef, StoredValue};
+use crate::{stored_types::Stored, AbstractStored, Store, StoredRef, StoredValue};
 
 /// A stored variant of [`InteropValue`](crate::execution::interop::InteropValue)
 pub trait StoredInteropValue
@@ -251,3 +252,63 @@ where
         ))
     }
 }
+
+impl<T: Config> Store<'_, T> {
+    /// This is a safer variant of [`Store::func_alloc_typed_unchecked`](crate::Store::func_alloc_typed_unchecked). It is
+    /// functionally equal, with the only difference being that this function
+    /// returns a [`Stored<FuncAddr>`].
+    ///
+    /// # Safety
+    ///
+    /// The caller has to guarantee that if the [`Value`]s returned from the
+    /// given host function are references, their addresses came either from the
+    /// host function arguments or from the current [`Store`] object.
+    ///
+    /// See: [`Store::func_alloc_typed_unchecked`](crate::Store::func_alloc_typed_unchecked) for more information.
+    #[allow(clippy::let_and_return)] // reason = "to follow the 1234 structure"
+    pub unsafe fn func_alloc_typed<Params: InteropValueList, Returns: InteropValueList>(
+        &mut self,
+        host_func: fn(&mut T, Vec<Value>) -> Result<Vec<Value>, HaltExecutionError>,
+    ) -> Stored<FuncAddr> {
+        // 1. try unwrap
+        // no stored parameters
+        // 2. call
+        // SAFETY: The caller ensures that if the host function returns
+        // references, they originate either from the arguments or the current
+        // store.
+        let func_addr = unsafe {
+            self.inner
+                .func_alloc_typed_unchecked::<Params, Returns>(host_func)
+        };
+        // 3. rewrap
+        // 4. return
+        // SAFETY: The function address just came from the current store.
+        unsafe { Stored::from_bare(func_addr, self.id) }
+    }
+
+    /// This is a safe variant of [`Store::invoke_typed_without_fuel_unchecked`](crate::Store::invoke_typed_without_fuel_unchecked).
+    pub fn invoke_typed_without_fuel<
+        Params: StoredInteropValueList,
+        Returns: StoredInteropValueList,
+    >(
+        &mut self,
+        function: Stored<FuncAddr>,
+        params: Params,
+    ) -> Result<Returns, RuntimeError> {
+        // 1. try unwrap
+        let function = function.try_unwrap_into_bare(self.id);
+        let params = params.into_values().try_unwrap_into_bare(self.id);
+        // 2. call
+        // SAFETY: It was just checked that the `FuncAddr` and any addresses
+        // contained in the parameters came from the current store through their
+        // store ids.
+        let returns = unsafe { self.inner.invoke_without_fuel_unchecked(function, params) }?;
+        // 3. rewrap
+        // SAFETY: All `Value`s just came from the current store.
+        let stored_returns = unsafe { Vec::from_bare(returns, self.id) };
+        // 4. return
+        let stored_returns = Returns::try_from_values(stored_returns.into_iter())
+            .map_err(|_| RuntimeError::FunctionInvocationSignatureMismatch)?;
+        Ok(stored_returns)
+    }
+}

crates/checked/src/interop.rs

@@ -32,16 +32,19 @@ use core::sync::atomic::{AtomicU64, Ordering};
 
 use alloc::vec::Vec;
 
-mod interop;
 mod store;
 mod stored_types;
 mod value;
 
-pub use interop::*;
 pub use store::*;
 pub use stored_types::*;
 pub use value::*;
 
+#[cfg(feature = "interop")]
+mod interop;
+#[cfg(feature = "interop")]
+pub use interop::*;
+
 #[cfg(feature = "linker")]
 mod linker;
 #[cfg(feature = "linker")]

crates/checked/src/lib.rs

@@ -2,15 +2,14 @@ use alloc::{string::String, vec::Vec};
 use wasm::{
     addrs::{FuncAddr, GlobalAddr, MemAddr, ModuleAddr, TableAddr},
     config::Config,
-    interop::InteropValueList,
     resumable::Resumable,
     FuncType, GlobalType, HaltExecutionError, MemType, RuntimeError, TableType, ValidationInfo,
     Value,
 };
 
 use crate::{
     stored_types::{Stored, StoredExternVal, StoredInstantiationOutcome, StoredRunState},
-    AbstractStored, StoreId, StoredInteropValueList, StoredRef, StoredValue,
+    AbstractStored, StoreId, StoredRef, StoredValue,
 };
 
 pub struct Store<'b, T: Config> {
@@ -442,38 +441,6 @@ impl<'b, T: Config> Store<'b, T> {
         Ok(stored_run_state)
     }
 
-    /// This is a safer variant of [`Store::func_alloc_typed_unchecked`](crate::Store::func_alloc_typed_unchecked). It is
-    /// functionally equal, with the only difference being that this function
-    /// returns a [`Stored<FuncAddr>`].
-    ///
-    /// # Safety
-    ///
-    /// The caller has to guarantee that if the [`Value`]s returned from the
-    /// given host function are references, their addresses came either from the
-    /// host function arguments or from the current [`Store`] object.
-    ///
-    /// See: [`Store::func_alloc_typed_unchecked`](crate::Store::func_alloc_typed_unchecked) for more information.
-    #[allow(clippy::let_and_return)] // reason = "to follow the 1234 structure"
-    pub unsafe fn func_alloc_typed<Params: InteropValueList, Returns: InteropValueList>(
-        &mut self,
-        host_func: fn(&mut T, Vec<Value>) -> Result<Vec<Value>, HaltExecutionError>,
-    ) -> Stored<FuncAddr> {
-        // 1. try unwrap
-        // no stored parameters
-        // 2. call
-        // SAFETY: The caller ensures that if the host function returns
-        // references, they originate either from the arguments or the current
-        // store.
-        let func_addr = unsafe {
-            self.inner
-                .func_alloc_typed_unchecked::<Params, Returns>(host_func)
-        };
-        // 3. rewrap
-        // 4. return
-        // SAFETY: The function address just came from the current store.
-        unsafe { Stored::from_bare(func_addr, self.id) }
-    }
-
     /// This is a safe variant of [`Store::invoke_without_fuel_unchecked`](crate::Store::invoke_without_fuel_unchecked).
     pub fn invoke_without_fuel(
         &mut self,
@@ -495,32 +462,6 @@ impl<'b, T: Config> Store<'b, T> {
         Ok(returns)
     }
 
-    /// This is a safe variant of [`Store::invoke_typed_without_fuel_unchecked`](crate::Store::invoke_typed_without_fuel_unchecked).
-    pub fn invoke_typed_without_fuel<
-        Params: StoredInteropValueList,
-        Returns: StoredInteropValueList,
-    >(
-        &mut self,
-        function: Stored<FuncAddr>,
-        params: Params,
-    ) -> Result<Returns, RuntimeError> {
-        // 1. try unwrap
-        let function = function.try_unwrap_into_bare(self.id);
-        let params = params.into_values().try_unwrap_into_bare(self.id);
-        // 2. call
-        // SAFETY: It was just checked that the `FuncAddr` and any addresses
-        // contained in the parameters came from the current store through their
-        // store ids.
-        let returns = unsafe { self.inner.invoke_without_fuel_unchecked(function, params) }?;
-        // 3. rewrap
-        // SAFETY: All `Value`s just came from the current store.
-        let stored_returns = unsafe { Vec::from_bare(returns, self.id) };
-        // 4. return
-        let stored_returns = Returns::try_from_values(stored_returns.into_iter())
-            .map_err(|_| RuntimeError::FunctionInvocationSignatureMismatch)?;
-        Ok(stored_returns)
-    }
-
     /// This is a safe variant of [`Store::mem_access_mut_slice_unchecked`](crate::Store::mem_access_mut_slice_unchecked).
     pub fn mem_access_mut_slice<R>(
         &self,

crates/checked/src/store.rs

@@ -0,0 +1,7 @@
+[package]
+name = "interop"
+version = "0.2.0"
+edition = "2024"
+
+[dependencies]
+wasm-interpreter.workspace = true

crates/interop/Cargo.toml

@@ -0,0 +1 @@
+# Interoperation between Rust and Wasm types