chore: general cleanup, fix performance regressions

Signed-off-by: Henry <mail@henrygressmann.de>

Author: explodingcamera

crates/tinywasm/benches/tinywasm.rs

@@ -23,7 +23,7 @@ fn tinywasm_from_twasm(twasm: &[u8]) -> Result<Module> {
 }
 
 fn tinywasm_run(module: &Module) -> Result<()> {
-    let engine = Engine::new(Config::default().with_memory_backend(MemoryBackend::paged(64 * 1024)));
+    let engine = Engine::new(Config::default());
     let mut store = Store::new(engine);
     let mut imports = Imports::default();
     imports.define("env", "printi32", HostFunction::from(&mut store, |_: FuncContext<'_>, _: i32| Ok(())));

crates/tinywasm/src/func.rs

@@ -278,6 +278,7 @@ impl FuncContext<'_> {
         self.store
             .get_module_instance(self.module_id)
             .unwrap_or_else(|| unreachable!("invalid module instance id in host function context: {}", self.module_id))
+            .clone()
     }
 
     /// Get a memory export.
@@ -566,13 +567,11 @@ fn collect_call_results(
     func_ty: &FuncType,
 ) -> Result<Vec<WasmValue>> {
     debug_assert!(value_stack.len() >= func_ty.results().len()); // m values are on the top of the stack (Ensured by validation)
-    let mut res: Vec<_> = func_ty
-        .results()
-        .iter()
-        .rev()
-        .map(|&ty| state.attach_value(value_stack.pop_tinyvalue(ty), ty).expect("validated function result"))
-        .collect();
-    res.reverse(); // reverse to get the original order
+    let results = func_ty.results();
+    let mut res = vec![WasmValue::I32(0); results.len()];
+    for (i, &ty) in results.iter().enumerate().rev() {
+        res[i] = value_stack.pop_wasmvalue(state, ty);
+    }
     Ok(res)
 }
 

crates/tinywasm/src/interpreter/executor.rs

@@ -46,7 +46,10 @@ impl<'store, const BUDGETED: bool> Executor<'store, BUDGETED> {
 
     pub(crate) fn new(store: &'store mut Store, cf: CallFrame, call_stack_base: u32) -> Self {
         let wasm_func = store.state.get_wasm_func(cf.func_addr);
-        let module = store.get_module_instance_internal(wasm_func.owner);
+        let module = store
+            .get_module_instance(wasm_func.owner)
+            .unwrap_or_else(|| unreachable!("invalid module instance"))
+            .clone();
         Self { module, cf, func: wasm_func.func.clone(), store, call_stack_base }
     }
 
@@ -1004,7 +1007,11 @@ impl<'store, const BUDGETED: bool> Executor<'store, BUDGETED> {
         self.store.call_stack.push(self.cf)?;
         self.cf = CallFrame::new(func_addr, locals_base, wasm_func.func.locals);
         if wasm_func.owner != self.module.id() {
-            self.module = self.store.get_module_instance_internal(wasm_func.owner);
+            self.module = self
+                .store
+                .get_module_instance(wasm_func.owner)
+                .unwrap_or_else(|| unreachable!("invalid module instance"))
+                .clone();
         }
 
         Ok(())
@@ -1023,7 +1030,11 @@ impl<'store, const BUDGETED: bool> Executor<'store, BUDGETED> {
         };
         self.cf = CallFrame::new(func_addr, locals_base, wasm_func.func.locals);
         if wasm_func.owner != self.module.id() {
-            self.module = self.store.get_module_instance_internal(wasm_func.owner);
+            self.module = self
+                .store
+                .get_module_instance(wasm_func.owner)
+                .unwrap_or_else(|| unreachable!("invalid module instance"))
+                .clone();
         }
 
         Ok(())
@@ -1039,8 +1050,7 @@ impl<'store, const BUDGETED: bool> Executor<'store, BUDGETED> {
         let mut params = Vec::new();
         params.try_reserve_exact(param_types.len()).map_err(|_| Trap::OutOfMemory)?;
         for &ty in param_types.iter().rev() {
-            let value = self.store.value_stack.pop_tinyvalue(ty);
-            params.push(self.store.state.attach_value(value, ty).expect("validated host argument"));
+            params.push(self.store.value_stack.pop_wasmvalue(&self.store.state, ty));
         }
         params.reverse();
         if params_may_gc {
@@ -1094,13 +1104,12 @@ impl<'store, const BUDGETED: bool> Executor<'store, BUDGETED> {
 
     fn exec_call_self(&mut self) -> Result<(), Trap> {
         self.charge_call_fuel(FUEL_COST_CALL_TOTAL);
-
-        self.store.call_stack.push(self.cf)?;
         let Ok(locals_base) = self.store.value_stack.enter_locals(&self.func.params, &self.func.locals) else {
             cold_path();
             return Err(Trap::CallStackOverflow);
         };
-        self.cf = CallFrame::new(self.cf.func_addr, locals_base, self.func.locals);
+        let new = CallFrame::new(self.cf.func_addr, locals_base, self.func.locals);
+        self.store.call_stack.push(core::mem::replace(&mut self.cf, new))?;
 
         Ok(())
     }
@@ -1195,7 +1204,11 @@ impl<'store, const BUDGETED: bool> Executor<'store, BUDGETED> {
         let wasm_func = self.store.state.get_wasm_func(caller.func_addr);
         self.func = wasm_func.func.clone();
         if wasm_func.owner != self.module.id() {
-            self.module = self.store.get_module_instance_internal(wasm_func.owner);
+            self.module = self
+                .store
+                .get_module_instance(wasm_func.owner)
+                .unwrap_or_else(|| unreachable!("invalid module instance"))
+                .clone();
         }
         self.cf = caller;
         false

crates/tinywasm/src/interpreter/simd/mod.rs

@@ -13,8 +13,9 @@ use core::arch::wasm32 as wasm;
 use core::arch::wasm64 as wasm;
 
 #[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
+#[repr(transparent)]
 /// A 128-bit SIMD value
-pub struct Value128(pub(super) [u8; 16]);
+pub struct Value128(pub(crate) [u8; 16]);
 
 impl From<[u8; 16]> for Value128 {
     fn from(bytes: [u8; 16]) -> Self {
@@ -24,12 +25,12 @@ impl From<[u8; 16]> for Value128 {
 
 impl Value128 {
     #[inline(always)]
-    pub fn from_le_bytes(bytes: [u8; 16]) -> Self {
+    pub const fn from_le_bytes(bytes: [u8; 16]) -> Self {
         Self(bytes)
     }
 
     #[inline(always)]
-    pub fn to_le_bytes(self) -> [u8; 16] {
+    pub const fn to_le_bytes(self) -> [u8; 16] {
         self.0
     }
 }

crates/tinywasm/src/interpreter/stack/value_stack.rs

@@ -244,20 +244,21 @@ impl ValueStack {
 
     pub(crate) fn push_dyn(&mut self, value: TinyWasmValue) -> Result<(), Trap> {
         match value {
-            TinyWasmValue::Value32(v) => self.stack_32.push(v)?,
-            TinyWasmValue::Value64(v) => self.stack_64.push(v)?,
-            TinyWasmValue::Value128(v) => self.stack_128.push(v)?,
-            TinyWasmValue::ValueRef(v) => self.stack_32.push(v.raw())?,
+            TinyWasmValue::Value32(v) => self.stack_32.push(v),
+            TinyWasmValue::Value64(v) => self.stack_64.push(v),
+            TinyWasmValue::Value128(v) => self.stack_128.push(v),
+            TinyWasmValue::ValueRef(v) => self.stack_32.push(v.raw()),
         }
-        Ok(())
     }
 
-    pub(crate) fn pop_tinyvalue(&mut self, val_type: WasmType) -> TinyWasmValue {
+    pub(crate) fn pop_wasmvalue(&mut self, state: &crate::store::State, val_type: WasmType) -> WasmValue {
         match val_type {
-            WasmType::I32 | WasmType::F32 => TinyWasmValue::Value32(Value32::stack_pop(self)),
-            WasmType::I64 | WasmType::F64 => TinyWasmValue::Value64(Value64::stack_pop(self)),
-            WasmType::Ref(_) => TinyWasmValue::ValueRef(ValueRef::stack_pop(self)),
-            WasmType::V128 => TinyWasmValue::Value128(Value128::stack_pop(self)),
+            WasmType::I32 => WasmValue::I32(self.stack_32.pop() as i32),
+            WasmType::I64 => WasmValue::I64(self.stack_64.pop() as i64),
+            WasmType::F32 => WasmValue::F32(f32::from_bits(self.stack_32.pop())),
+            WasmType::F64 => WasmValue::F64(f64::from_bits(self.stack_64.pop())),
+            WasmType::Ref(ty) => WasmValue::Ref(state.to_ref_value(ValueRef::from_raw(self.stack_32.pop()), ty)),
+            WasmType::V128 => WasmValue::V128(self.stack_128.pop().0),
         }
     }
 

crates/tinywasm/src/interpreter/values.rs

@@ -1,12 +1,16 @@
 use super::stack::{CallFrame, ValueStack};
 use crate::store::Globals;
 use crate::{Result, interpreter::simd::Value128};
-use tinywasm_types::{AnyRef, ExnRef, ExternRef, FuncRef, GlobalAddr, LocalAddr, RefValue, WasmType, WasmValue};
+use tinywasm_types::{GlobalAddr, LocalAddr, RefValue, WasmValue};
 
 pub(crate) type Value32 = u32;
 pub(crate) type Value64 = u64;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+/// Packed internal representation of a WebAssembly reference.
+///
+/// Unlike the public [`RefValue`], this stores no explicit reference category.
+/// Converting it back therefore requires the value's canonical reference type.
 pub(crate) struct ValueRef(u32);
 
 impl Default for ValueRef {
@@ -71,6 +75,18 @@ impl ValueRef {
     }
 }
 
+impl From<RefValue> for ValueRef {
+    fn from(value: RefValue) -> Self {
+        match value {
+            RefValue::Null => Self::NULL,
+            RefValue::Func(value) => Self::from_category_addr(value.addr()),
+            RefValue::Extern(value) => Self::from_raw(value.raw()),
+            RefValue::Exn(value) => Self::from_category_addr(value.addr()),
+            RefValue::Any(value) => Self::from_raw(value.raw()),
+        }
+    }
+}
+
 #[allow(private_interfaces)]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 /// A untyped WebAssembly value
@@ -118,32 +134,6 @@ impl TinyWasmValue {
             _ => None,
         }
     }
-
-    /// Converts this internal value to the requested public WebAssembly type.
-    pub fn attach_type(self, ty: WasmType) -> Option<WasmValue> {
-        match (self, ty) {
-            (Self::Value32(v), WasmType::I32) => Some(WasmValue::I32(v as i32)),
-            (Self::Value64(v), WasmType::I64) => Some(WasmValue::I64(v as i64)),
-            (Self::Value32(v), WasmType::F32) => Some(WasmValue::F32(f32::from_bits(v))),
-            (Self::Value64(v), WasmType::F64) => Some(WasmValue::F64(f64::from_bits(v))),
-            (Self::ValueRef(v), WasmType::Ref(_)) if v.is_null() => Some(RefValue::Null.into()),
-            (Self::ValueRef(v), WasmType::Ref(ty)) if ty.is_func() => {
-                Some(WasmValue::Ref(RefValue::Func(FuncRef::new(v.addr()?))))
-            }
-            (Self::ValueRef(v), WasmType::Ref(ty)) if ty.is_extern() => {
-                Some(WasmValue::Ref(RefValue::Extern(ExternRef::from_raw(v.raw()))))
-            }
-            (Self::ValueRef(v), WasmType::Ref(ty)) if ty.is_exn() => {
-                Some(WasmValue::Ref(RefValue::Exn(ExnRef::new(v.addr()?))))
-            }
-            (Self::ValueRef(v), WasmType::Ref(_)) => Some(WasmValue::Ref(RefValue::Any(AnyRef::from_raw(v.raw())))),
-            (Self::Value128(v), WasmType::V128) => Some(WasmValue::V128(v.0)),
-            (_, WasmType::I32 | WasmType::F32) => None,
-            (_, WasmType::I64 | WasmType::F64) => None,
-            (_, WasmType::Ref(_)) => None,
-            (_, WasmType::V128) => None,
-        }
-    }
 }
 
 impl From<&WasmValue> for TinyWasmValue {
@@ -153,11 +143,7 @@ impl From<&WasmValue> for TinyWasmValue {
             WasmValue::I64(v) => Self::Value64(*v as u64),
             WasmValue::F32(v) => Self::Value32(v.to_bits()),
             WasmValue::F64(v) => Self::Value64(v.to_bits()),
-            WasmValue::Ref(RefValue::Null) => Self::ValueRef(ValueRef::NULL),
-            WasmValue::Ref(RefValue::Func(value)) => Self::ValueRef(ValueRef::from_category_addr(value.addr())),
-            WasmValue::Ref(RefValue::Extern(value)) => Self::ValueRef(ValueRef::from_raw(value.raw())),
-            WasmValue::Ref(RefValue::Exn(value)) => Self::ValueRef(ValueRef::from_category_addr(value.addr())),
-            WasmValue::Ref(RefValue::Any(value)) => Self::ValueRef(ValueRef::from_raw(value.raw())),
+            WasmValue::Ref(value) => Self::ValueRef((*value).into()),
             WasmValue::V128(v) => Self::Value128((*v).into()),
         }
     }
@@ -190,9 +176,7 @@ pub(crate) trait InternalValue: sealed::Sealed + Copy + Default {
     fn local_set(stack: &mut ValueStack, frame: &CallFrame, index: LocalAddr, value: Self);
     fn local_update(stack: &mut ValueStack, frame: &CallFrame, index: LocalAddr, f: impl FnOnce(Self) -> Self);
     fn local_copy(stack: &mut ValueStack, frame: &CallFrame, from: LocalAddr, to: LocalAddr);
-    /// Gets a value from its physical global lane.
     fn global_get(globals: &Globals, addr: GlobalAddr) -> Self;
-    /// Sets a value in its physical global lane.
     fn global_set(globals: &mut Globals, addr: GlobalAddr, value: Self);
 }
 

crates/tinywasm/src/reference.rs

@@ -5,7 +5,7 @@ use alloc::format;
 use alloc::string::{String, ToString};
 use alloc::vec::Vec;
 
-use crate::interpreter::TinyWasmValue;
+use crate::interpreter::ValueRef;
 use crate::store::TableInstance;
 use crate::{Error, MemoryInstance, Result, Store, Trap};
 use tinywasm_types::{Addr, GlobalType, MemAddr, MemoryType, TableAddr, TableType, WasmType, WasmValue};
@@ -347,13 +347,14 @@ fn table_value_to_element(
     state: &crate::store::State,
     element_type: tinywasm_types::RefType,
     value: WasmValue,
-) -> Result<crate::interpreter::ValueRef, Trap> {
-    if !state.value_matches_type(value, WasmType::Ref(element_type)) {
+) -> Result<ValueRef, Trap> {
+    let WasmValue::Ref(value) = value else {
+        return Err(Trap::Other("invalid table value type"));
+    };
+    if !state.value_matches_type(WasmValue::Ref(value), WasmType::Ref(element_type)) {
         return Err(Trap::Other("invalid table value type"));
     }
-    let WasmValue::Ref(value) = value else { unreachable!() };
-    let TinyWasmValue::ValueRef(value) = TinyWasmValue::from(WasmValue::Ref(value)) else { unreachable!() };
-    Ok(value)
+    Ok(value.into())
 }
 
 impl Table {
@@ -393,14 +394,9 @@ impl Table {
     /// Get a table element as a wasm reference value.
     pub fn get(&self, store: &Store, index: TableAddr) -> Result<WasmValue> {
         let table = self.instance(store)?;
-        let value = store
-            .state
-            .attach_value(TinyWasmValue::ValueRef(*table.get(index as usize)?), WasmType::Ref(table.kind.element_type))
-            .expect("table value matches its element type");
-        if let WasmValue::Ref(value) = value {
-            store.state.pin_host_ref(value);
-        }
-        Ok(value)
+        let value = store.state.to_ref_value(*table.get(index as usize)?, table.kind.element_type);
+        store.state.pin_host_ref(value);
+        Ok(WasmValue::Ref(value))
     }
 
     /// Load a range of table elements and iterate over wasm reference values.
@@ -413,15 +409,12 @@ impl Table {
         let table = self.instance(store)?;
         let element_type = table.kind.element_type;
         let elements = table.load(offset, len)?;
-        let may_contain_gc = store.state.type_may_contain_gc(WasmType::Ref(element_type));
+        let may_contain_gc = store.state.type_may_contain_gc(&WasmType::Ref(element_type));
         Ok(elements.iter().copied().map(move |value| {
             if may_contain_gc {
                 store.state.gc.pin(value);
             }
-            store
-                .state
-                .attach_value(TinyWasmValue::ValueRef(value), WasmType::Ref(element_type))
-                .expect("table value matches its element type")
+            WasmValue::Ref(store.state.to_ref_value(value, element_type))
         }))
     }
 
@@ -473,7 +466,7 @@ impl Global {
     /// Get the current value of the global.
     pub fn get(&self, store: &Store) -> Result<WasmValue> {
         self.0.validate_store(store)?;
-        let value = store.state.global_wasm_value(self.0.addr);
+        let value = store.state.get_global_wasmvalue(self.0.addr);
         if let WasmValue::Ref(value) = value {
             store.state.pin_host_ref(value);
         }
@@ -483,6 +476,6 @@ impl Global {
     /// Set the current value of the global.
     pub fn set(&self, store: &mut Store, value: WasmValue) -> Result<()> {
         self.0.validate_store(store)?;
-        store.state.set_global_wasm_value(self.0.addr, value)
+        store.state.set_global_wasmvalue(self.0.addr, value)
     }
 }