chore: cleanup

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

Author: explodingcamera

Cargo.lock

@@ -84,7 +84,7 @@ fn main() -> Result<()> {
         TinyWasmSubcommand::Run(Run { wasm_file, engine, args, func }) => {
             debug!("args: {args:?}");
 
-            let path = cwd.join(wasm_file.clone());
+            let path = cwd.join(&wasm_file);
             let module = match wasm_file.ends_with(".wat") {
                 #[cfg(feature = "wat")]
                 true => {

crates/cli/src/bin.rs

@@ -116,7 +116,7 @@ impl Parser {
     /// Parse a [`TinyWasmModule`] from a file. Requires `std` feature.
     pub fn parse_module_file(&self, path: impl AsRef<crate::std::path::Path> + Clone) -> Result<TinyWasmModule> {
         use alloc::format;
-        let f = crate::std::fs::File::open(path.clone())
+        let f = crate::std::fs::File::open(&path)
             .map_err(|e| ParseError::Other(format!("Error opening file {:?}: {}", path.as_ref(), e)))?;
 
         let mut reader = crate::std::io::BufReader::new(f);

crates/parser/src/lib.rs

@@ -20,7 +20,6 @@ log={workspace=true, optional=true}
 tinywasm-parser={version="0.9.0-alpha.0", path="../parser", default-features=false, optional=true}
 tinywasm-types={version="0.9.0-alpha.0", path="../types", default-features=false}
 libm={version="0.2", default-features=false}
-allocator-api2={version="0.4", optional=true}
 
 [dev-dependencies]
 wasm-testsuite.workspace=true
@@ -49,9 +48,6 @@ archive=["tinywasm-types/archive"]
 # canonicalize all NaN values to a single representation
 canonicalize_nans=[]
 
-# support for the allocator-api2 crate
-allocator-api2=["dep:allocator-api2"]
-
 [[test]]
 name="test-wasm-1"
 harness=false

crates/tinywasm/Cargo.toml

@@ -70,7 +70,8 @@ impl FuncHandle {
         debug_assert!(store.stack.values.len() >= func_ty.results.len());
 
         // 2. Pop m values from the stack
-        let res = store.stack.values.pop_results(&func_ty.results);
+        let mut res: Vec<_> = store.stack.values.pop_types(func_ty.results.iter().rev()).collect(); // pop in reverse order since the stack is LIFO
+        res.reverse(); // reverse to get the original order
 
         // The values are returned as the results of the invocation.
         Ok(res)

crates/tinywasm/src/func.rs

@@ -176,14 +176,10 @@ impl CallFrame {
         block_ptr: u32,
     ) -> Self {
         let locals = {
-            let mut locals_32 = Vec::new();
-            locals_32.reserve_exact(wasm_func_inst.locals.c32 as usize);
-            let mut locals_64 = Vec::new();
-            locals_64.reserve_exact(wasm_func_inst.locals.c64 as usize);
-            let mut locals_128 = Vec::new();
-            locals_128.reserve_exact(wasm_func_inst.locals.c128 as usize);
-            let mut locals_ref = Vec::new();
-            locals_ref.reserve_exact(wasm_func_inst.locals.cref as usize);
+            let mut locals_32 = Vec::with_capacity(wasm_func_inst.locals.c32 as usize);
+            let mut locals_64 = Vec::with_capacity(wasm_func_inst.locals.c64 as usize);
+            let mut locals_128 = Vec::with_capacity(wasm_func_inst.locals.c128 as usize);
+            let mut locals_ref = Vec::with_capacity(wasm_func_inst.locals.cref as usize);
 
             for p in params {
                 match p.into() {

crates/tinywasm/src/interpreter/executor.rs

@@ -23,8 +23,8 @@ impl Stack {
 
     /// Initialize the stack with the given call frame (used for starting execution)
     pub(crate) fn initialize(&mut self, callframe: CallFrame) {
-        self.blocks.clear();
         self.values.clear();
+        self.blocks.clear();
         self.call_stack.reset(callframe);
     }
 }

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

@@ -122,14 +122,12 @@ impl ValueStack {
         T::replace_top(self, func)
     }
 
-    pub(crate) fn pop_params(&mut self, val_types: &[ValType]) -> Vec<WasmValue> {
-        val_types.iter().map(|val_type| self.pop_wasmvalue(*val_type)).collect::<Vec<_>>()
-    }
-
-    pub(crate) fn pop_results(&mut self, val_types: &[ValType]) -> Vec<WasmValue> {
-        let mut results = val_types.iter().rev().map(|val_type| self.pop_wasmvalue(*val_type)).collect::<Vec<_>>();
-        results.reverse();
-        results
+    #[inline]
+    pub(crate) fn pop_types<'a>(
+        &'a mut self,
+        val_types: impl IntoIterator<Item = &'a ValType>,
+    ) -> impl core::iter::Iterator<Item = WasmValue> {
+        val_types.into_iter().map(|val_type| self.pop_wasmvalue(*val_type))
     }
 
     #[inline]
@@ -168,7 +166,7 @@ impl ValueStack {
 
     pub(crate) fn truncate_keep(&mut self, to: StackLocation, keep: StackHeight) {
         #[inline(always)]
-        fn truncate_keep<T: Copy + Default>(data: &mut Vec<T>, n: u32, end_keep: u32) {
+        fn truncate_keep<T>(data: &mut Vec<T>, n: u32, end_keep: u32) {
             let len = data.len() as u32;
             if len <= n {
                 return; // No need to truncate if the current size is already less than or equal to total_to_keep
@@ -205,7 +203,15 @@ impl ValueStack {
 
     pub(crate) fn extend_from_wasmvalues(&mut self, values: &[WasmValue]) {
         for value in values {
-            self.push_dyn(value.into());
+            match value {
+                WasmValue::I32(v) => self.stack_32.push(*v as u32),
+                WasmValue::I64(v) => self.stack_64.push(*v as u64),
+                WasmValue::F32(v) => self.stack_32.push(v.to_bits()),
+                WasmValue::F64(v) => self.stack_64.push(v.to_bits()),
+                WasmValue::RefExtern(v) => self.stack_ref.push(v.addr()),
+                WasmValue::RefFunc(v) => self.stack_ref.push(v.addr()),
+                WasmValue::V128(v) => self.stack_128.push((*v).into()),
+            }
         }
     }
 }

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

@@ -70,31 +70,31 @@ impl TinyWasmValue {
     pub fn unwrap_32(&self) -> Value32 {
         match self {
             Self::Value32(v) => *v,
-            _ => unreachable!("Expected Value32"),
+            _ => panic!("Expected Value32"),
         }
     }
 
     /// Asserts that the value is a 64-bit value and returns it (panics if the value is the wrong size)
     pub fn unwrap_64(&self) -> Value64 {
         match self {
             Self::Value64(v) => *v,
-            _ => unreachable!("Expected Value64"),
+            _ => panic!("Expected Value64"),
         }
     }
 
     /// Asserts that the value is a 128-bit value and returns it (panics if the value is the wrong size)
     pub fn unwrap_128(&self) -> Value128 {
         match self {
             Self::Value128(v) => *v,
-            _ => unreachable!("Expected Value128"),
+            _ => panic!("Expected Value128"),
         }
     }
 
     /// Asserts that the value is a reference value and returns it (panics if the value is the wrong size)
     pub fn unwrap_ref(&self) -> ValueRef {
         match self {
             Self::ValueRef(v) => *v,
-            _ => unreachable!("Expected ValueRef"),
+            _ => panic!("Expected ValueRef"),
         }
     }