chore: move locals to stack

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

Author: explodingcamera

crates/tinywasm/src/func.rs

@@ -56,11 +56,14 @@ impl FuncHandle {
         };
 
         // 6. Let f be the dummy frame
-        let callframe = CallFrame::new_with_params(wasm_func.locals, self.addr, func_inst.owner, params);
-
         // 7. Push the frame f to the call stack
         // & 8. Push the values to the stack
         store.stack.clear();
+        store.stack.values.extend_from_wasmvalues(params)?;
+        let (locals_base, _stack_base, stack_offset) =
+            store.stack.values.enter_locals(wasm_func.params, wasm_func.locals)?;
+        let callframe = CallFrame::new(self.addr, func_inst.owner, locals_base, stack_offset);
+
         // 9. Invoke the function instance
         InterpreterRuntime::exec(store, callframe)?;
 

crates/tinywasm/src/imports.rs

@@ -122,17 +122,17 @@ pub enum Extern {
 
 impl Extern {
     /// Create a new global import
-    pub fn global(val: WasmValue, mutable: bool) -> Self {
+    pub const fn global(val: WasmValue, mutable: bool) -> Self {
         Self::Global { ty: GlobalType { ty: val.val_type(), mutable }, val }
     }
 
     /// Create a new table import
-    pub fn table(ty: TableType, init: WasmValue) -> Self {
+    pub const fn table(ty: TableType, init: WasmValue) -> Self {
         Self::Table { ty, init }
     }
 
     /// Create a new memory import
-    pub fn memory(ty: MemoryType) -> Self {
+    pub const fn memory(ty: MemoryType) -> Self {
         Self::Memory { ty }
     }
 
@@ -180,7 +180,7 @@ impl Extern {
     }
 
     /// Get the kind of the external value
-    pub fn kind(&self) -> ExternalKind {
+    pub const fn kind(&self) -> ExternalKind {
         match self {
             Self::Global { .. } => ExternalKind::Global,
             Self::Table { .. } => ExternalKind::Table,
@@ -257,14 +257,14 @@ pub(crate) struct ResolvedImports {
 }
 
 impl ResolvedImports {
-    pub(crate) fn new() -> Self {
+    pub(crate) const fn new() -> Self {
         Self { globals: Vec::new(), tables: Vec::new(), memories: Vec::new(), funcs: Vec::new() }
     }
 }
 
 impl Imports {
     /// Create a new empty import set
-    pub fn new() -> Self {
+    pub const fn new() -> Self {
         Self { values: BTreeMap::new(), modules: BTreeMap::new() }
     }
 

crates/tinywasm/src/instance.rs

@@ -36,18 +36,21 @@ pub(crate) struct ModuleInstanceInner {
 }
 
 impl ModuleInstanceInner {
+    #[inline]
     pub(crate) fn func_ty(&self, addr: FuncAddr) -> &FuncType {
         match self.types.get(addr as usize) {
             Some(ty) => ty,
             None => unreachable!("invalid function address: {addr}"),
         }
     }
 
+    #[inline]
     pub(crate) fn func_addrs(&self) -> &[FuncAddr] {
         &self.func_addrs
     }
 
     // resolve a function address to the global store address
+    #[inline]
     pub(crate) fn resolve_func_addr(&self, addr: FuncAddr) -> FuncAddr {
         match self.func_addrs.get(addr as usize) {
             Some(addr) => *addr,
@@ -56,6 +59,7 @@ impl ModuleInstanceInner {
     }
 
     // resolve a table address to the global store address
+    #[inline]
     pub(crate) fn resolve_table_addr(&self, addr: TableAddr) -> TableAddr {
         match self.table_addrs.get(addr as usize) {
             Some(addr) => *addr,
@@ -64,6 +68,7 @@ impl ModuleInstanceInner {
     }
 
     // resolve a memory address to the global store address
+    #[inline]
     pub(crate) fn resolve_mem_addr(&self, addr: MemAddr) -> MemAddr {
         match self.mem_addrs.get(addr as usize) {
             Some(addr) => *addr,
@@ -72,6 +77,7 @@ impl ModuleInstanceInner {
     }
 
     // resolve a data address to the global store address
+    #[inline]
     pub(crate) fn resolve_data_addr(&self, addr: DataAddr) -> DataAddr {
         match self.data_addrs.get(addr as usize) {
             Some(addr) => *addr,
@@ -80,6 +86,7 @@ impl ModuleInstanceInner {
     }
 
     // resolve a memory address to the global store address
+    #[inline]
     pub(crate) fn resolve_elem_addr(&self, addr: ElemAddr) -> ElemAddr {
         match self.elem_addrs.get(addr as usize) {
             Some(addr) => *addr,
@@ -88,6 +95,7 @@ impl ModuleInstanceInner {
     }
 
     // resolve a global address to the global store address
+    #[inline]
     pub(crate) fn resolve_global_addr(&self, addr: GlobalAddr) -> GlobalAddr {
         match self.global_addrs.get(addr as usize) {
             Some(addr) => *addr,

crates/tinywasm/src/interpreter/executor.rs

@@ -114,36 +114,36 @@ impl<'store> Executor<'store> {
                 return ControlFlow::Continue(());
             }
             DropKeepSmall { base32, keep32, base64, keep64, base128, keep128, base_ref, keep_ref } => {
-                let b32 = self.cf.stack_base.s32 + *base32 as usize;
+                let b32 = self.cf.stack_base().s32 + *base32 as usize;
                 let k32 = *keep32 as usize;
                 self.store.stack.values.stack_32.truncate_keep(b32, k32);
-                let b64 = self.cf.stack_base.s64 + *base64 as usize;
+                let b64 = self.cf.stack_base().s64 + *base64 as usize;
                 let k64 = *keep64 as usize;
                 self.store.stack.values.stack_64.truncate_keep(b64, k64);
-                let b128 = self.cf.stack_base.s128 + *base128 as usize;
+                let b128 = self.cf.stack_base().s128 + *base128 as usize;
                 let k128 = *keep128 as usize;
                 self.store.stack.values.stack_128.truncate_keep(b128, k128);
-                let bref = self.cf.stack_base.sref + *base_ref as usize;
+                let bref = self.cf.stack_base().sref + *base_ref as usize;
                 let kref = *keep_ref as usize;
                 self.store.stack.values.stack_ref.truncate_keep(bref, kref);
             }
             DropKeep32(base, keep) => {
-                let b = self.cf.stack_base.s32 + *base as usize;
+                let b = self.cf.stack_base().s32 + *base as usize;
                 let k = *keep as usize;
                 self.store.stack.values.stack_32.truncate_keep(b, k);
             }
             DropKeep64(base, keep) => {
-                let b = self.cf.stack_base.s64 + *base as usize;
+                let b = self.cf.stack_base().s64 + *base as usize;
                 let k = *keep as usize;
                 self.store.stack.values.stack_64.truncate_keep(b, k);
             }
             DropKeep128(base, keep) => {
-                let b = self.cf.stack_base.s128 + *base as usize;
+                let b = self.cf.stack_base().s128 + *base as usize;
                 let k = *keep as usize;
                 self.store.stack.values.stack_128.truncate_keep(b, k);
             }
             DropKeepRef(base, keep) => {
-                let b = self.cf.stack_base.sref + *base as usize;
+                let b = self.cf.stack_base().sref + *base as usize;
                 let k = *keep as usize;
                 self.store.stack.values.stack_ref.truncate_keep(b, k);
             }
@@ -163,22 +163,58 @@ impl<'store> Executor<'store> {
                 return ControlFlow::Continue(());
             }
             Return => return self.exec_return(),
-            LocalGet32(local_index) => self.store.stack.values.push(self.cf.locals.get::<Value32>(*local_index)).to_cf()?,
-            LocalGet64(local_index) => self.store.stack.values.push(self.cf.locals.get::<Value64>(*local_index)).to_cf()?,
-            LocalGet128(local_index) => self.store.stack.values.push(self.cf.locals.get::<Value128>(*local_index)).to_cf()?,
-            LocalGetRef(local_index) => self.store.stack.values.push(self.cf.locals.get::<ValueRef>(*local_index)).to_cf()?,
-            LocalSet32(local_index) => self.cf.locals.set(*local_index, self.store.stack.values.pop::<Value32>()),
-            LocalSet64(local_index) => self.cf.locals.set(*local_index, self.store.stack.values.pop::<Value64>()),
-            LocalSet128(local_index) => self.cf.locals.set(*local_index, self.store.stack.values.pop::<Value128>()),
-            LocalSetRef(local_index) => self.cf.locals.set(*local_index, self.store.stack.values.pop::<ValueRef>()),
-            LocalCopy32(from, to) => self.cf.locals.set(*to, self.cf.locals.get::<Value32>(*from)),
-            LocalCopy64(from, to) => self.cf.locals.set(*to, self.cf.locals.get::<Value64>(*from)),
-            LocalCopy128(from, to) => self.cf.locals.set(*to, self.cf.locals.get::<Value128>(*from)),
-            LocalCopyRef(from, to) => self.cf.locals.set(*to, self.cf.locals.get::<ValueRef>(*from)),
-            LocalTee32(local_index) => self.cf.locals.set(*local_index, self.store.stack.values.peek::<Value32>()),
-            LocalTee64(local_index) => self.cf.locals.set(*local_index, self.store.stack.values.peek::<Value64>()),
-            LocalTee128(local_index) => self.cf.locals.set(*local_index, self.store.stack.values.peek::<Value128>()),
-            LocalTeeRef(local_index) => self.cf.locals.set(*local_index, self.store.stack.values.peek::<ValueRef>()),
+            LocalGet32(local_index) => self.store.stack.values.push(self.store.stack.values.local_get_32(&self.cf, *local_index)).to_cf()?,
+            LocalGet64(local_index) => self.store.stack.values.push(self.store.stack.values.local_get_64(&self.cf, *local_index)).to_cf()?,
+            LocalGet128(local_index) => self.store.stack.values.push(self.store.stack.values.local_get_128(&self.cf, *local_index)).to_cf()?,
+            LocalGetRef(local_index) => self.store.stack.values.push(self.store.stack.values.local_get_ref(&self.cf, *local_index)).to_cf()?,
+            LocalSet32(local_index) => {
+                let val = self.store.stack.values.pop::<Value32>();
+                self.store.stack.values.local_set_32(&self.cf, *local_index, val);
+            }
+            LocalSet64(local_index) => {
+                let val = self.store.stack.values.pop::<Value64>();
+                self.store.stack.values.local_set_64(&self.cf, *local_index, val);
+            }
+            LocalSet128(local_index) => {
+                let val = self.store.stack.values.pop::<Value128>();
+                self.store.stack.values.local_set_128(&self.cf, *local_index, val);
+            }
+            LocalSetRef(local_index) => {
+                let val = self.store.stack.values.pop::<ValueRef>();
+                self.store.stack.values.local_set_ref(&self.cf, *local_index, val);
+            }
+            LocalCopy32(from, to) => {
+                let val = self.store.stack.values.local_get_32(&self.cf, *from);
+                self.store.stack.values.local_set_32(&self.cf, *to, val);
+            }
+            LocalCopy64(from, to) => {
+                let val = self.store.stack.values.local_get_64(&self.cf, *from);
+                self.store.stack.values.local_set_64(&self.cf, *to, val);
+            }
+            LocalCopy128(from, to) => {
+                let val = self.store.stack.values.local_get_128(&self.cf, *from);
+                self.store.stack.values.local_set_128(&self.cf, *to, val);
+            }
+            LocalCopyRef(from, to) => {
+                let val = self.store.stack.values.local_get_ref(&self.cf, *from);
+                self.store.stack.values.local_set_ref(&self.cf, *to, val);
+            }
+            LocalTee32(local_index) => {
+                let val = self.store.stack.values.peek::<Value32>();
+                self.store.stack.values.local_set_32(&self.cf, *local_index, val);
+            }
+            LocalTee64(local_index) => {
+                let val = self.store.stack.values.peek::<Value64>();
+                self.store.stack.values.local_set_64(&self.cf, *local_index, val);
+            }
+            LocalTee128(local_index) => {
+                let val = self.store.stack.values.peek::<Value128>();
+                self.store.stack.values.local_set_128(&self.cf, *local_index, val);
+            }
+            LocalTeeRef(local_index) => {
+                let val = self.store.stack.values.peek::<ValueRef>();
+                self.store.stack.values.local_set_ref(&self.cf, *local_index, val);
+            }
             GlobalGet(global_index) => self.exec_global_get(*global_index).to_cf()?,
             GlobalSet32(global_index) => self.exec_global_set::<Value32>(*global_index),
             GlobalSet64(global_index) => self.exec_global_set::<Value64>(*global_index),
@@ -627,20 +663,35 @@ impl<'store> Executor<'store> {
         func_addr: FuncAddr,
         owner: ModuleInstanceAddr,
     ) -> ControlFlow<Option<Error>> {
+        if !IS_RETURN_CALL && self.store.stack.call_stack.is_full() {
+            return ControlFlow::Break(Some(Trap::CallStackOverflow.into()));
+        }
+
         if !Rc::ptr_eq(&self.func, &wasm_func) {
             self.func = wasm_func.clone();
         }
 
         if IS_RETURN_CALL {
-            let locals = self.store.stack.values.pop_locals(wasm_func.params, wasm_func.locals);
-            let stack_base = self.store.stack.values.height();
-            self.cf.reuse_for(func_addr, locals, owner, stack_base);
+            self.store.stack.values.truncate_keep_counts(self.cf.locals_base, wasm_func.params);
+        }
+
+        let (locals_base, _stack_base, stack_offset) =
+            match self.store.stack.values.enter_locals(wasm_func.params, wasm_func.locals) {
+                Ok(v) => v,
+                Err(Error::Trap(Trap::ValueStackOverflow)) if !IS_RETURN_CALL => {
+                    return ControlFlow::Break(Some(Trap::CallStackOverflow.into()));
+                }
+                Err(err) => return ControlFlow::Break(Some(err)),
+            };
+
+        let new_call_frame = CallFrame::new(func_addr, owner, locals_base, stack_offset);
+
+        if IS_RETURN_CALL {
+            self.cf = new_call_frame;
         } else {
-            let locals = self.store.stack.values.pop_locals(wasm_func.params, wasm_func.locals);
-            let stack_base = self.store.stack.values.height();
-            let new_call_frame = CallFrame::new(func_addr, owner, locals, stack_base);
             self.cf.incr_instr_ptr(); // skip the call instruction
-            self.store.stack.call_stack.push(core::mem::replace(&mut self.cf, new_call_frame)).to_cf()?;
+            self.store.stack.call_stack.push(self.cf).to_cf()?;
+            self.cf = new_call_frame;
         }
 
         if self.cf.module_addr != self.module.idx {
@@ -709,6 +760,9 @@ impl<'store> Executor<'store> {
     }
 
     fn exec_return(&mut self) -> ControlFlow<Option<Error>> {
+        let result_counts = ValueCountsSmall::from(self.func.ty.results.iter());
+        self.store.stack.values.truncate_keep_counts(self.cf.locals_base, result_counts);
+
         let Some(cf) = self.store.stack.call_stack.pop() else { return ControlFlow::Break(None) };
 
         if cf.func_addr != self.cf.func_addr {
@@ -718,7 +772,6 @@ impl<'store> Executor<'store> {
                 self.module = self.store.get_module_instance_raw(cf.module_addr).clone();
             }
         }
-
         self.cf = cf;
         ControlFlow::Continue(())
     }

crates/tinywasm/src/interpreter/no_std_floats.rs

@@ -9,18 +9,18 @@ pub(super) trait NoStdFloatExt {
 
 #[rustfmt::skip]
 impl NoStdFloatExt for f64 {
-    fn round(self) -> Self { libm::round(self) }
-    fn ceil(self) -> Self { libm::ceil(self) }
-    fn floor(self) -> Self { libm::floor(self) }
-    fn trunc(self) -> Self { libm::trunc(self) }
-    fn sqrt(self) -> Self { libm::sqrt(self) }
+    #[inline] fn round(self) -> Self { libm::round(self) }
+    #[inline] fn ceil(self) -> Self { libm::ceil(self) }
+    #[inline] fn floor(self) -> Self { libm::floor(self) }
+    #[inline] fn trunc(self) -> Self { libm::trunc(self) }
+    #[inline] fn sqrt(self) -> Self { libm::sqrt(self) }
 }
 
 #[rustfmt::skip]
 impl NoStdFloatExt for f32 {
-    fn round(self) -> Self { libm::roundf(self) }
-    fn ceil(self) -> Self { libm::ceilf(self) }
-    fn floor(self) -> Self { libm::floorf(self) }
-    fn trunc(self) -> Self { libm::truncf(self) }
-    fn sqrt(self) -> Self { libm::sqrtf(self) }
+    #[inline] fn round(self) -> Self { libm::roundf(self) }
+    #[inline] fn ceil(self) -> Self { libm::ceilf(self) }
+    #[inline] fn floor(self) -> Self { libm::floorf(self) }
+    #[inline] fn trunc(self) -> Self { libm::truncf(self) }
+    #[inline] fn sqrt(self) -> Self { libm::sqrtf(self) }
 }

crates/tinywasm/src/interpreter/num_helpers.rs

@@ -70,6 +70,7 @@ macro_rules! impl_wasm_float_ops {
     ($($t:ty)*) => ($(
         impl TinywasmFloatExt for $t {
             // https://webassembly.github.io/spec/core/exec/numerics.html#op-fnearest
+            #[inline]
             fn tw_nearest(self) -> Self {
                 match self {
                     #[cfg(not(feature = "canonicalize_nans"))]
@@ -94,6 +95,7 @@ macro_rules! impl_wasm_float_ops {
 
             // https://webassembly.github.io/spec/core/exec/numerics.html#op-fmin
             // Based on f32::minimum (which is not yet stable)
+            #[inline]
             fn tw_minimum(self, other: Self) -> Self {
                 match self.partial_cmp(&other) {
                     Some(core::cmp::Ordering::Less) => self,
@@ -108,6 +110,7 @@ macro_rules! impl_wasm_float_ops {
 
             // https://webassembly.github.io/spec/core/exec/numerics.html#op-fmax
             // Based on f32::maximum (which is not yet stable)
+            #[inline]
             fn tw_maximum(self, other: Self) -> Self {
                 match self.partial_cmp(&other) {
                     Some(core::cmp::Ordering::Greater) => self,
@@ -135,18 +138,22 @@ pub(crate) trait WasmIntOps {
 macro_rules! impl_wrapping_self_sh {
     ($($t:ty)*) => ($(
         impl WasmIntOps for $t {
+            #[inline]
             fn wasm_shl(self, rhs: Self) -> Self {
                 self.wrapping_shl(rhs as u32)
             }
 
+            #[inline]
             fn wasm_shr(self, rhs: Self) -> Self {
                 self.wrapping_shr(rhs as u32)
             }
 
+            #[inline]
             fn wasm_rotl(self, rhs: Self) -> Self {
                 self.rotate_left(rhs as u32)
             }
 
+            #[inline]
             fn wasm_rotr(self, rhs: Self) -> Self {
                 self.rotate_right(rhs as u32)
             }