chore: cleanup

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

Author: explodingcamera

Cargo.lock

@@ -5,10 +5,6 @@ use types::TinyWasmModule;
 
 const WASM: &[u8] = include_bytes!("../../../examples/rust/out/argon2id.opt.wasm");
 
-fn init_log() {
-    let _ = pretty_env_logger::formatted_timed_builder().filter_level(log::LevelFilter::Off).try_init();
-}
-
 fn argon2id_parse() -> Result<TinyWasmModule> {
     let parser = tinywasm_parser::Parser::new();
     let data = parser.parse_module_bytes(WASM)?;
@@ -34,7 +30,6 @@ fn argon2id_run(module: TinyWasmModule) -> Result<()> {
 }
 
 fn criterion_benchmark(c: &mut Criterion) {
-    init_log();
     let module = argon2id_parse().expect("argon2id_parse");
     let twasm = argon2id_to_twasm(&module).expect("argon2id_to_twasm");
 

crates/tinywasm/benches/argon2id.rs

@@ -35,9 +35,9 @@ fn criterion_benchmark(c: &mut Criterion) {
     let module = tinywasm_parse().expect("tinywasm_parse");
     let twasm = tinywasm_to_twasm(&module).expect("tinywasm_to_twasm");
 
-    // c.bench_function("tinywasm_parse", |b| b.iter(tinywasm_parse));
-    // c.bench_function("tinywasm_to_twasm", |b| b.iter(|| tinywasm_to_twasm(&module)));
-    // c.bench_function("tinywasm_from_twasm", |b| b.iter(|| tinywasm_from_twasm(&twasm)));
+    c.bench_function("tinywasm_parse", |b| b.iter(tinywasm_parse));
+    c.bench_function("tinywasm_to_twasm", |b| b.iter(|| tinywasm_to_twasm(&module)));
+    c.bench_function("tinywasm_from_twasm", |b| b.iter(|| tinywasm_from_twasm(&twasm)));
     c.bench_function("tinywasm", |b| b.iter(|| tinywasm_run(module.clone())));
 }
 

crates/tinywasm/benches/tinywasm.rs

@@ -17,7 +17,6 @@ use crate::*;
 
 pub(crate) struct Executor<'store> {
     cf: CallFrame,
-    instructions: ArcSlice<Instruction>,
     func: Rc<WasmFunction>,
     module: Rc<ModuleInstanceInner>,
     store: &'store mut Store,
@@ -27,8 +26,7 @@ impl<'store> Executor<'store> {
     pub(crate) fn new(store: &'store mut Store, cf: CallFrame) -> Result<Self> {
         let module = store.get_module_instance_raw(cf.module_addr).clone();
         let func = store.state.get_wasm_func(cf.func_addr).clone();
-        let instructions = func.instructions.clone();
-        Ok(Self { module, store, cf, func, instructions })
+        Ok(Self { module, store, cf, func })
     }
 
     pub(crate) fn run_to_completion(&mut self) -> Result<()> {
@@ -76,12 +74,12 @@ impl<'store> Executor<'store> {
             };
         }
 
-        let next = match self.instructions.0.get(self.cf.instr_ptr) {
+        let next = match self.func.instructions.0.get(self.cf.instr_ptr) {
             Some(instr) => instr,
             None => unreachable!(
                 "Instruction pointer out of bounds: {} ({} instructions)",
                 self.cf.instr_ptr,
-                self.instructions.0.len()
+                self.func.instructions.0.len()
             ),
         };
 
@@ -116,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 as usize + *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 as usize + *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 as usize + *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 as usize + *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 as usize + *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 as usize + *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 as usize + *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 as usize + *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);
             }
@@ -154,7 +152,7 @@ impl<'store> Executor<'store> {
                 let start = self.cf.instr_ptr + 1;
 
                 let target_ip = if idx >= 0 && (idx as u32) < *len {
-                    match self.instructions.0.get(start + idx as usize) {
+                    match self.func.instructions.0.get(start + idx as usize) {
                         Some(Instruction::BranchTableTarget(ip)) => *ip,
                         _ => *default_ip,
                     }
@@ -629,9 +627,8 @@ impl<'store> Executor<'store> {
         func_addr: FuncAddr,
         owner: ModuleInstanceAddr,
     ) -> ControlFlow<Option<Error>> {
-        if self.func != wasm_func {
+        if !Rc::ptr_eq(&self.func, &wasm_func) {
             self.func = wasm_func.clone();
-            self.instructions = wasm_func.instructions.clone();
         }
 
         if IS_RETURN_CALL {
@@ -716,7 +713,6 @@ impl<'store> Executor<'store> {
 
         if cf.func_addr != self.cf.func_addr {
             self.func = self.store.state.get_wasm_func(cf.func_addr).clone();
-            self.instructions = self.func.instructions.clone();
 
             if cf.module_addr != self.module.idx {
                 self.module = self.store.get_module_instance_raw(cf.module_addr).clone();
@@ -751,14 +747,14 @@ impl<'store> Executor<'store> {
     }
     fn exec_memory_grow(&mut self, addr: u32) -> Result<()> {
         let mem = self.store.state.get_mem_mut(self.module.resolve_mem_addr(addr));
-        let prev_size = mem.page_count;
-        let pages_delta = match mem.is_64bit() {
+        let is_64bit = mem.is_64bit();
+        let pages_delta = match is_64bit {
             true => self.store.stack.values.pop::<i64>(),
             false => i64::from(self.store.stack.values.pop::<i32>()),
         };
 
-        let size = mem.grow(pages_delta).map(|_| prev_size as i64).unwrap_or(-1);
-        match mem.is_64bit() {
+        let size = mem.grow(pages_delta).unwrap_or(-1);
+        match is_64bit {
             true => self.store.stack.values.push::<i64>(size)?,
             false => self.store.stack.values.push::<i32>(size as i32)?,
         };

crates/tinywasm/src/interpreter/executor.rs

@@ -44,10 +44,10 @@ pub(crate) struct CallFrame {
 
 #[derive(Debug, Clone, Copy, Default)]
 pub(crate) struct StackBase {
-    pub(crate) s32: u32,
-    pub(crate) s64: u32,
-    pub(crate) s128: u32,
-    pub(crate) sref: u32,
+    pub(crate) s32: usize,
+    pub(crate) s64: usize,
+    pub(crate) s128: usize,
+    pub(crate) sref: usize,
 }
 
 #[derive(Debug)]

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

@@ -86,6 +86,11 @@ impl<T: Copy + Default> Stack<T> {
     }
 
     pub(crate) fn pop_to_locals(&mut self, param_count: usize, local_count: usize) -> Box<[T]> {
+        if local_count == 0 {
+            debug_assert!(param_count == 0, "param count exceeds local count");
+            return Box::new([]);
+        }
+
         let mut locals = alloc::vec![T::default(); local_count].into_boxed_slice();
         let start =
             self.len.checked_sub(param_count).unwrap_or_else(|| unreachable!("value stack underflow, this is a bug"));
@@ -120,10 +125,10 @@ impl ValueStack {
 
     pub(crate) fn height(&self) -> StackBase {
         StackBase {
-            s32: u32::try_from(self.stack_32.len()).expect("stack32 height overflow"),
-            s64: u32::try_from(self.stack_64.len()).expect("stack64 height overflow"),
-            s128: u32::try_from(self.stack_128.len()).expect("stack128 height overflow"),
-            sref: u32::try_from(self.stack_ref.len()).expect("stack_ref height overflow"),
+            s32: self.stack_32.len(),
+            s64: self.stack_64.len(),
+            s128: self.stack_128.len(),
+            sref: self.stack_ref.len(),
         }
     }
 

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

@@ -54,10 +54,6 @@ impl MemoryInstance {
         Ok(())
     }
 
-    pub(crate) fn max_pages(&self) -> usize {
-        self.kind.page_count_max().try_into().unwrap_or(usize::MAX)
-    }
-
     pub(crate) fn load(&self, addr: usize, len: usize) -> Result<&[u8]> {
         let Some(end) = addr.checked_add(len) else {
             cold();
@@ -133,9 +129,10 @@ impl MemoryInstance {
         let current_pages = self.page_count;
         let pages_delta = usize::try_from(pages_delta).ok()?;
         let new_pages = current_pages.checked_add(pages_delta)?;
+        let max_pages = self.kind.page_count_max().try_into().unwrap_or(usize::MAX);
 
-        if new_pages > self.max_pages() {
-            log::debug!("memory.grow failed: new_pages={}, max_pages={}", new_pages, self.max_pages());
+        if new_pages > max_pages {
+            log::debug!("memory.grow failed: new_pages={}, max_pages={}", new_pages, max_pages);
             return None;
         }
 
@@ -145,7 +142,12 @@ impl MemoryInstance {
             return None;
         }
 
-        self.data.resize(usize::try_from(new_size).ok()?, 0);
+        let new_size = usize::try_from(new_size).ok()?;
+        if new_size == self.data.len() {
+            return i64::try_from(current_pages).ok();
+        }
+
+        self.data.resize(new_size, 0);
         self.page_count = new_pages;
         i64::try_from(current_pages).ok()
     }

crates/tinywasm/src/store/memory.rs

@@ -1,2 +1,2 @@
 0.8.0,57,0,[{"name":"custom-page-sizes-invalid.wast","passed":22,"failed":0},{"name":"custom-page-sizes.wast","passed":35,"failed":0}]
-0.9.0-alpha.0,80,0,[{"name":"custom-page-sizes-invalid.wast","passed":23,"failed":0},{"name":"custom-page-sizes.wast","passed":45,"failed":0},{"name":"memory_max.wast","passed":6,"failed":0},{"name":"memory_max_i64.wast","passed":6,"failed":0}]
+0.9.0-alpha.0,211,0,[{"name":"binary.wast","passed":127,"failed":0},{"name":"custom-page-sizes-invalid.wast","passed":23,"failed":0},{"name":"custom-page-sizes.wast","passed":45,"failed":0},{"name":"memory_max.wast","passed":8,"failed":0},{"name":"memory_max_i64.wast","passed":8,"failed":0}]

crates/tinywasm/tests/generated/wasm-custom-page-sizes.csv

@@ -59,14 +59,14 @@ pub enum Instruction {
     DropKeep64(u16, u16),
     DropKeep128(u16, u16),
     DropKeepRef(u16, u16),
-    BranchTable(u32, u32),       // (default_landing_pad_ip, target_count) — followed by BranchTableTarget entries
+    BranchTable(u32, u32),       // (default_landing_pad_ip, target_count) - followed by BranchTableTarget entries
     BranchTableTarget(u32),      // (landing_pad_ip)
     Return,
     Call(FuncAddr),
     CallIndirect(TypeAddr, TableAddr),
     ReturnCall(FuncAddr),
     ReturnCallIndirect(TypeAddr, TableAddr),
- 
+
     // > Parametric Instructions
     // See <https://webassembly.github.io/spec/core/binary/instructions.html#parametric-instructions>
     Drop32, Select32,