chore: cleanup + add wasm intrinsics

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

Author: explodingcamera

.cargo/config.toml

@@ -5,3 +5,6 @@ test-wasm-2="test --package tinywasm --test test-wasm-2 --release"
 test-wasm-3="test --package tinywasm --test test-wasm-3 --release"
 test-wast="test --package tinywasm --test test-wast"
 test-wasm-custom="test --package tinywasm --test test-wasm-custom --release"
+
+[target.x86_64-unknown-linux-gnu]
+rustflags=["-C", "target-cpu=x86-64-v3"]

crates/parser/src/visit.rs

@@ -657,6 +657,9 @@ impl<'a, R: WasmModuleResources> wasmparser::VisitOperator<'a> for FunctionBuild
     }
 
     fn visit_loop(&mut self, _ty: wasmparser::BlockType) -> Self::Output {
+        if !matches!(self.instructions.last(), Some(Instruction::Nop)) {
+            self.instructions.push(Instruction::Nop); // add nop to ensure that no superinstruction can be merged across block boundaries
+        }
         let start_ip = self.instructions.len();
         self.ctx_stack.push(LoweringCtx { kind: BlockKind::Loop, has_else: false, start_ip, branch_jumps: Vec::new() });
     }
@@ -683,7 +686,7 @@ impl<'a, R: WasmModuleResources> wasmparser::VisitOperator<'a> for FunctionBuild
                 ctx.branch_jumps.push(jump_ip);
                 self.patch_jump_if_zero(cond_jump_ip, self.instructions.len());
                 if !matches!(self.instructions.last(), Some(Instruction::Nop)) {
-                    self.instructions.push(Instruction::Nop);
+                    self.instructions.push(Instruction::Nop); // add nop to ensure that no superinstruction can be merged across block boundaries
                 }
             };
         };
@@ -693,7 +696,7 @@ impl<'a, R: WasmModuleResources> wasmparser::VisitOperator<'a> for FunctionBuild
         if let Some(ctx) = self.ctx_stack.pop() {
             self.patch_end_jumps(ctx, self.instructions.len());
             if !matches!(self.instructions.last(), Some(Instruction::Nop)) {
-                self.instructions.push(Instruction::Nop);
+                self.instructions.push(Instruction::Nop); // add nop to ensure that no superinstruction can be merged across block boundaries
             }
         } else {
             self.instructions.push(Instruction::Return);

crates/tinywasm/benches/argon2id.rs

@@ -3,7 +3,7 @@ use eyre::Result;
 use tinywasm::{ModuleInstance, Store, types};
 use types::TinyWasmModule;
 
-const WASM: &[u8] = include_bytes!("../../../examples/rust/out/argon2id.opt.wasm");
+const WASM: &[u8] = include_bytes!("../../../examples/rust/out/argon2id.wasm");
 
 fn argon2id_parse() -> Result<TinyWasmModule> {
     let parser = tinywasm_parser::Parser::new();

crates/tinywasm/benches/fibonacci.rs

@@ -3,7 +3,7 @@ use eyre::Result;
 use tinywasm::{ModuleInstance, Store, types};
 use types::TinyWasmModule;
 
-const WASM: &[u8] = include_bytes!("../../../examples/rust/out/fibonacci.opt.wasm");
+const WASM: &[u8] = include_bytes!("../../../examples/rust/out/fibonacci.wasm");
 
 fn fibonacci_parse() -> Result<TinyWasmModule> {
     let parser = tinywasm_parser::Parser::new();

crates/tinywasm/benches/tinywasm.rs

@@ -3,7 +3,7 @@ use eyre::Result;
 use tinywasm::{Extern, FuncContext, Imports, ModuleInstance, Store, types};
 use types::TinyWasmModule;
 
-const WASM: &[u8] = include_bytes!("../../../examples/rust/out/tinywasm.opt.wasm");
+const WASM: &[u8] = include_bytes!("../../../examples/rust/out/tinywasm.wasm");
 
 fn tinywasm_parse() -> Result<TinyWasmModule> {
     let parser = tinywasm_parser::Parser::new();

crates/tinywasm/src/func.rs

@@ -1,6 +1,6 @@
 use crate::interpreter::stack::CallFrame;
 use crate::{Error, FuncContext, InterpreterRuntime, Result, Store};
-use crate::{Function, log, unlikely};
+use crate::{Function, unlikely};
 use alloc::{boxed::Box, format, string::ToString, vec, vec::Vec};
 use tinywasm_types::{ExternRef, FuncRef, FuncType, ModuleInstanceAddr, ValType, WasmValue};
 
@@ -34,23 +34,14 @@ impl FuncHandle {
         }
 
         // 5. For each value type and the corresponding value, check if types match
-        if !(func_ty.params.iter().zip(params).enumerate().all(|(_i, (ty, param))| {
-            if ty == &param.val_type() {
-                true
-            } else {
-                log::error!("param type mismatch at index {_i}: expected {ty:?}, got {param:?}");
-                false
-            }
-        })) {
+        if !(func_ty.params.iter().zip(params).all(|(ty, param)| ty == &param.val_type())) {
             return Err(Error::Other("Type mismatch".into()));
         }
 
         let func_inst = store.state.get_func(self.addr);
         let wasm_func = match &func_inst.func {
             Function::Host(host_func) => {
-                let host_func = host_func.clone();
-                let ctx = FuncContext { store, module_addr: self.module_addr };
-                return host_func.call(ctx, params);
+                return host_func.clone().call(FuncContext { store, module_addr: self.module_addr }, params);
             }
             Function::Wasm(wasm_func) => wasm_func.clone(),
         };

crates/tinywasm/src/interpreter/executor.rs

@@ -3,7 +3,7 @@
 use super::no_std_floats::NoStdFloatExt;
 
 use alloc::boxed::Box;
-use alloc::{format, rc::Rc, string::ToString};
+use alloc::{rc::Rc, string::ToString};
 use core::ops::ControlFlow;
 
 use interpreter::stack::CallFrame;
@@ -78,7 +78,7 @@ impl<'store> Executor<'store> {
             }};
         }
 
-        let next = match self.func.instructions.0.get(self.cf.instr_ptr) {
+        let next = match self.func.instructions.0.get(self.cf.instr_ptr as usize) {
             Some(instr) => instr,
             None => unreachable!(
                 "Instruction pointer out of bounds: {} ({} instructions)",
@@ -89,7 +89,7 @@ impl<'store> Executor<'store> {
 
         #[rustfmt::skip]
         match next {
-            Nop | I32ReinterpretF32 | I64ReinterpretF64 | F32ReinterpretI32 | F64ReinterpretI64 => {}
+            Nop | I32ReinterpretF32 | I64ReinterpretF64 | F32ReinterpretI32 | F64ReinterpretI64 | BranchTableTarget {..} => {}
             Unreachable => return ControlFlow::Break(Some(Trap::Unreachable.into())),
             Drop32 => self.store.stack.values.drop::<Value32>(),
             Drop64 => self.store.stack.values.drop::<Value64>(),
@@ -107,66 +107,66 @@ impl<'store> Executor<'store> {
             ReturnCallSelf => return self.exec_call_self::<true>(),
             ReturnCallIndirect(ty, table) => return self.exec_call_indirect::<true>(*ty, *table),
             Jump(ip) => {
-                self.cf.instr_ptr = *ip as usize;
+                self.cf.instr_ptr = *ip;
                 return ControlFlow::Continue(());
             }
             JumpIfZero(ip) => {
                 let cond = self.store.stack.values.pop::<i32>();
 
                 if cond == 0 {
-                    self.cf.instr_ptr = *ip as usize;
+                    self.cf.instr_ptr = *ip;
                 } else {
                     self.cf.incr_instr_ptr();
                 }
                 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 u32;
                 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;
+                self.store.stack.values.stack_32.truncate_keep(b32 as usize, k32);
+                let b64 = self.cf.stack_base().s64 + *base64 as u32;
                 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;
+                self.store.stack.values.stack_64.truncate_keep(b64 as usize, k64);
+                let b128 = self.cf.stack_base().s128 + *base128 as u32;
                 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;
+                self.store.stack.values.stack_128.truncate_keep(b128 as usize, k128);
+                let bref = self.cf.stack_base().sref + *base_ref as u32;
                 let kref = *keep_ref as usize;
-                self.store.stack.values.stack_ref.truncate_keep(bref, kref);
+                self.store.stack.values.stack_ref.truncate_keep(bref as usize, kref);
             }
             DropKeep32(base, keep) => {
-                let b = self.cf.stack_base().s32 + *base as usize;
+                let b = self.cf.stack_base().s32 + *base as u32;
                 let k = *keep as usize;
-                self.store.stack.values.stack_32.truncate_keep(b, k);
+                self.store.stack.values.stack_32.truncate_keep(b as usize, k);
             }
             DropKeep64(base, keep) => {
-                let b = self.cf.stack_base().s64 + *base as usize;
+                let b = self.cf.stack_base().s64 + *base as u32;
                 let k = *keep as usize;
-                self.store.stack.values.stack_64.truncate_keep(b, k);
+                self.store.stack.values.stack_64.truncate_keep(b as usize, k);
             }
             DropKeep128(base, keep) => {
-                let b = self.cf.stack_base().s128 + *base as usize;
+                let b = self.cf.stack_base().s128 + *base as u32;
                 let k = *keep as usize;
-                self.store.stack.values.stack_128.truncate_keep(b, k);
+                self.store.stack.values.stack_128.truncate_keep(b as usize, k);
             }
             DropKeepRef(base, keep) => {
-                let b = self.cf.stack_base().sref + *base as usize;
+                let b = self.cf.stack_base().sref + *base as u32;
                 let k = *keep as usize;
-                self.store.stack.values.stack_ref.truncate_keep(b, k);
+                self.store.stack.values.stack_ref.truncate_keep(b as usize, k);
             }
             BranchTable(default_ip, len) => {
                 let idx = self.store.stack.values.pop::<i32>();
                 let start = self.cf.instr_ptr + 1;
 
                 let target_ip = if idx >= 0 && (idx as u32) < *len {
-                    match self.func.instructions.0.get(start + idx as usize) {
+                    match self.func.instructions.0.get((start + idx as u32) as usize) {
                         Some(Instruction::BranchTableTarget(ip)) => *ip,
                         _ => *default_ip,
                     }
                 } else {
                     *default_ip
                 };
-                self.cf.instr_ptr = target_ip as usize;
+                self.cf.instr_ptr = target_ip;
                 return ControlFlow::Continue(());
             }
             Return => return self.exec_return(),
@@ -434,10 +434,10 @@ impl<'store> Executor<'store> {
             V128Load16x4U(arg) => self.exec_mem_load::<u64, 8, Value128>(arg.mem_addr(), arg.offset(), |v| Value128::v128_load16x4_u(v.to_le_bytes()))?,
             V128Load32x2S(arg) => self.exec_mem_load::<u64, 8, Value128>(arg.mem_addr(), arg.offset(), |v| Value128::v128_load32x2_s(v.to_le_bytes()))?,
             V128Load32x2U(arg) => self.exec_mem_load::<u64, 8, Value128>(arg.mem_addr(), arg.offset(), |v| Value128::v128_load32x2_u(v.to_le_bytes()))?,
-            V128Load8Splat(_arg) => self.exec_mem_load::<i8, 1, Value128>(_arg.mem_addr(), _arg.offset(), Value128::splat_i8)?,
-            V128Load16Splat(_arg) => self.exec_mem_load::<i16, 2, Value128>(_arg.mem_addr(), _arg.offset(), Value128::splat_i16)?,
-            V128Load32Splat(_arg) => self.exec_mem_load::<i32, 4, Value128>(_arg.mem_addr(), _arg.offset(), Value128::splat_i32)?,
-            V128Load64Splat(_arg) => self.exec_mem_load::<i64, 8, Value128>(_arg.mem_addr(), _arg.offset(), Value128::splat_i64)?,
+            V128Load8Splat(arg) => self.exec_mem_load::<i8, 1, Value128>(arg.mem_addr(), arg.offset(), Value128::splat_i8)?,
+            V128Load16Splat(arg) => self.exec_mem_load::<i16, 2, Value128>(arg.mem_addr(), arg.offset(), Value128::splat_i16)?,
+            V128Load32Splat(arg) => self.exec_mem_load::<i32, 4, Value128>(arg.mem_addr(), arg.offset(), Value128::splat_i32)?,
+            V128Load64Splat(arg) => self.exec_mem_load::<i64, 8, Value128>(arg.mem_addr(), arg.offset(), Value128::splat_i64)?,
             V128Store(arg) => self.exec_mem_store::<Value128, Value128, 16>(arg.mem_addr(), arg.offset(), |v| v)?,
             V128Store8Lane(arg, lane) => self.exec_mem_store_lane::<i8, 1>(arg.mem_addr(), arg.offset(), *lane)?,
             V128Store16Lane(arg, lane) => self.exec_mem_store_lane::<i16, 2>(arg.mem_addr(), arg.offset(), *lane)?,
@@ -655,9 +655,6 @@ impl<'store> Executor<'store> {
             F64x2PromoteLowF32x4 => stack_op!(unary Value128, |v| v.f64x2_promote_low_f32x4()),
             I32x4TruncSatF64x2SZero => stack_op!(unary Value128, |v| v.i32x4_trunc_sat_f64x2_s_zero()),
             I32x4TruncSatF64x2UZero => stack_op!(unary Value128, |v| v.i32x4_trunc_sat_f64x2_u_zero()),
-
-            #[allow(unreachable_patterns)]
-            i => return ControlFlow::Break(Some(Error::UnsupportedFeature(format!("unimplemented opcode: {i:?}")))),
         };
 
         self.cf.incr_instr_ptr();
@@ -670,10 +667,6 @@ 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();
         }
@@ -726,10 +719,6 @@ impl<'store> Executor<'store> {
     }
 
     fn exec_call_self<const IS_RETURN_CALL: bool>(&mut self) -> ControlFlow<Option<Error>> {
-        if !IS_RETURN_CALL && self.store.stack.call_stack.is_full() {
-            return ControlFlow::Break(Some(Trap::CallStackOverflow.into()));
-        }
-
         let params = self.func.params;
         let locals = self.func.locals;
 

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

@@ -6,47 +6,35 @@ use tinywasm_types::{FuncAddr, ModuleInstanceAddr, ValueCountsSmall};
 #[derive(Debug)]
 pub(crate) struct CallStack {
     stack: Vec<CallFrame>,
-    len: usize,
 }
 
 impl CallStack {
     pub(crate) fn new(config: &crate::engine::Config) -> Self {
-        let mut stack = Vec::with_capacity(config.call_stack_size);
-        stack.resize_with(config.call_stack_size, CallFrame::default);
-        Self { stack, len: 0 }
+        Self { stack: Vec::with_capacity(config.call_stack_size) }
     }
 
     pub(crate) fn clear(&mut self) {
-        self.len = 0;
+        self.stack.clear();
     }
 
+    #[inline(always)]
     pub(crate) fn pop(&mut self) -> Option<CallFrame> {
-        if self.len == 0 {
-            return None;
-        }
-
-        self.len -= 1;
-        Some(self.stack[self.len])
-    }
-
-    pub(crate) fn is_full(&self) -> bool {
-        self.len >= self.stack.len()
+        self.stack.pop()
     }
 
+    #[inline(always)]
     pub(crate) fn push(&mut self, call_frame: CallFrame) -> Result<()> {
-        if unlikely(self.is_full()) {
+        if unlikely(self.stack.len() == self.stack.capacity()) {
             return Err(Trap::CallStackOverflow.into());
         }
-
-        self.stack[self.len] = call_frame;
-        self.len += 1;
+        self.stack.push(call_frame);
         Ok(())
     }
 }
 
 #[derive(Debug, Clone, Copy, Default)]
 pub(crate) struct CallFrame {
-    pub(crate) instr_ptr: usize,
+    pub(crate) instr_ptr: u32,
     pub(crate) module_addr: ModuleInstanceAddr,
     pub(crate) func_addr: FuncAddr,
     pub(crate) locals_base: StackBase,
@@ -55,10 +43,10 @@ pub(crate) struct CallFrame {
 
 #[derive(Debug, Clone, Copy, Default)]
 pub(crate) struct StackBase {
-    pub(crate) s32: usize,
-    pub(crate) s64: usize,
-    pub(crate) s128: usize,
-    pub(crate) sref: usize,
+    pub(crate) s32: u32,
+    pub(crate) s64: u32,
+    pub(crate) s128: u32,
+    pub(crate) sref: u32,
 }
 
 impl CallFrame {
@@ -74,10 +62,10 @@ impl CallFrame {
     #[inline]
     pub(crate) fn stack_base(&self) -> StackBase {
         StackBase {
-            s32: self.locals_base.s32 + self.stack_offset.c32 as usize,
-            s64: self.locals_base.s64 + self.stack_offset.c64 as usize,
-            s128: self.locals_base.s128 + self.stack_offset.c128 as usize,
-            sref: self.locals_base.sref + self.stack_offset.cref as usize,
+            s32: self.locals_base.s32 + self.stack_offset.c32 as u32,
+            s64: self.locals_base.s64 + self.stack_offset.c64 as u32,
+            s128: self.locals_base.s128 + self.stack_offset.c128 as u32,
+            sref: self.locals_base.sref + self.stack_offset.cref as u32,
         }
     }