chore: improve simd

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

Author: explodingcamera

crates/parser/src/conversion.rs

@@ -225,8 +225,8 @@ pub(crate) fn convert_valtype(valtype: &wasmparser::ValType) -> ValType {
         wasmparser::ValType::I64 => ValType::I64,
         wasmparser::ValType::F32 => ValType::F32,
         wasmparser::ValType::F64 => ValType::F64,
+        wasmparser::ValType::V128 => ValType::V128,
         wasmparser::ValType::Ref(r) => convert_reftype(r),
-        wasmparser::ValType::V128 => unimplemented!("128-bit values are not supported yet"),
     }
 }
 

crates/parser/src/visit.rs

@@ -86,8 +86,8 @@ macro_rules! define_mem_operands {
     ($($name:ident, $instr:ident),*) => {
         $(
             #[inline(always)]
-            fn $name(&mut self, mem_arg: wasmparser::MemArg) -> Self::Output {
-                let arg = convert_memarg(mem_arg);
+            fn $name(&mut self, memarg: wasmparser::MemArg) -> Self::Output {
+                let arg = convert_memarg(memarg);
                 self.instructions.push(Instruction::$instr {
                     offset: arg.offset,
                     mem_addr: arg.mem_addr,

crates/tinywasm/Cargo.toml

@@ -28,12 +28,13 @@ serde={version="1.0", features=["derive"]}
 pretty_env_logger="0.5"
 
 [features]
-default=["std", "parser", "logging", "archive"]
+default=["std", "parser", "logging", "archive", "simd", "nightly"]
 logging=["_log", "tinywasm-parser?/logging", "tinywasm-types/logging"]
 std=["tinywasm-parser?/std", "tinywasm-types/std"]
 parser=["tinywasm-parser"]
 archive=["tinywasm-types/archive"]
 simd=[]
+nightly=[]
 
 [[test]]
 name="test-mvp"

crates/tinywasm/src/error.rs

@@ -237,7 +237,7 @@ impl Display for Trap {
     }
 }
 
-#[cfg(any(feature = "std", all(not(feature = "std"), nightly)))]
+#[cfg(any(feature = "std", all(not(feature = "std"), feature = "nightly")))]
 impl crate::std::error::Error for Error {}
 
 #[cfg(feature = "parser")]

crates/tinywasm/src/lib.rs

@@ -5,7 +5,7 @@
 ))]
 #![allow(unexpected_cfgs, clippy::reserve_after_initialization)]
 #![warn(missing_docs, missing_debug_implementations, rust_2018_idioms, unreachable_pub)]
-#![cfg_attr(nightly, feature(error_in_core, portable_simd))]
+#![cfg_attr(feature = "nightly", feature(error_in_core, portable_simd))]
 #![forbid(unsafe_code)]
 
 //! A tiny WebAssembly Runtime written in Rust

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

@@ -747,22 +747,56 @@ impl<'store, 'stack> Executor<'store, 'stack> {
 
     #[inline(always)]
     fn enter_block(&mut self, instr_ptr: usize, end_instr_offset: u32, ty: BlockType, args: BlockArgs) {
-        let (params, results) = match args {
-            BlockArgs::Empty => (0, 0),
-            BlockArgs::Type(_) => (0, 1),
-            BlockArgs::FuncType(t) => {
-                let ty = self.module.func_ty(t);
-                (ty.params.len() as u8, ty.results.len() as u8)
-            }
+        #[cfg(not(feature = "simd"))]
+        {
+            let (params, results) = match args {
+                BlockArgs::Empty => (0, 0),
+                BlockArgs::Type(_) => (0, 1),
+                BlockArgs::FuncType(t) => {
+                    let ty = self.module.func_ty(t);
+                    (ty.params.len() as u8, ty.results.len() as u8)
+                }
+            };
+
+            self.stack.blocks.push(BlockFrame {
+                instr_ptr,
+                end_instr_offset,
+                stack_ptr: self.stack.values.len() as u32 - params as u32,
+                results,
+                params,
+                ty,
+            });
         };
 
-        self.stack.blocks.push(BlockFrame {
-            instr_ptr,
-            end_instr_offset,
-            stack_ptr: self.stack.values.len() as u32 - params as u32,
-            results,
-            params,
-            ty,
-        });
+        #[cfg(feature = "simd")]
+        {
+            let (params, results, simd_params, simd_results) = match args {
+                BlockArgs::Empty => (0, 0, 0, 0),
+                BlockArgs::Type(t) => match t {
+                    ValType::V128 => (0, 0, 0, 1),
+                    _ => (0, 1, 0, 0),
+                },
+                BlockArgs::FuncType(t) => {
+                    let ty = self.module.func_ty(t);
+                    let simd_params = ty.params.iter().filter(|t| t.is_simd()).count() as u8;
+                    let params = ty.params.len() as u8 - simd_params;
+                    let simd_results = ty.results.iter().filter(|t| t.is_simd()).count() as u8;
+                    let results = ty.results.len() as u8 - simd_results;
+                    (params, results, simd_params, simd_results)
+                }
+            };
+
+            self.stack.blocks.push(BlockFrame {
+                instr_ptr,
+                end_instr_offset,
+                stack_ptr: self.stack.values.len() as u32 - params as u32,
+                simd_stack_ptr: self.stack.values.simd_len() as u32 - simd_params as u32,
+                results,
+                simd_params,
+                simd_results,
+                params,
+                ty,
+            });
+        };
     }
 }

crates/tinywasm/src/runtime/mod.rs

@@ -3,7 +3,7 @@ mod stack;
 
 mod raw;
 
-#[cfg(all(not(nightly), feature = "simd"))]
+#[cfg(all(not(feature = "nightly"), feature = "simd"))]
 compile_error!("`simd` feature requires nightly");
 
 #[cfg(feature = "simd")]

crates/tinywasm/src/runtime/raw_simd.rs

@@ -1,13 +1,27 @@
+use core::{fmt::Debug, simd::Simd};
+
 /// A large raw wasm value, used for 128-bit values.
 ///
 /// This is the internal representation of vector values.
 ///
 /// See [`WasmValue`] for the public representation.
 #[derive(Clone, Copy, Default, PartialEq, Eq)]
-pub struct RawSimdWasmValue([u8; 16]);
+pub struct RawSimdWasmValue(Simd<u8, 16>); // wasm has up to 16 8 bit lanes
 
 impl Debug for RawSimdWasmValue {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         write!(f, "LargeRawWasmValue({})", 0)
     }
 }
+
+impl From<u128> for RawSimdWasmValue {
+    fn from(value: u128) -> Self {
+        Self(value.to_le_bytes().into())
+    }
+}
+
+impl From<RawSimdWasmValue> for u128 {
+    fn from(value: RawSimdWasmValue) -> Self {
+        u128::from_le_bytes(value.0.into())
+    }
+}

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

@@ -84,7 +84,7 @@ impl CallFrame {
                 self.instr_ptr = break_to.instr_ptr;
 
                 // We also want to push the params to the stack
-                values.break_to_params(&break_to);
+                values.break_to_params(break_to);
 
                 // check if we're breaking to the loop
                 if break_to_relative != 0 {
@@ -97,7 +97,7 @@ impl CallFrame {
             BlockType::Block | BlockType::If | BlockType::Else => {
                 // this is a block, so we want to jump to the next instruction after the block ends
                 // We also want to push the block's results to the stack
-                values.break_to_results(&break_to);
+                values.break_to_results(break_to);
 
                 // (the inst_ptr will be incremented by 1 before the next instruction is executed)
                 self.instr_ptr = break_to.instr_ptr + break_to.end_instr_offset as usize;

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

@@ -2,9 +2,6 @@ mod block_stack;
 mod call_stack;
 mod value_stack;
 
-#[cfg(nightly)]
-mod simd_value_stack;
-
 pub(crate) use block_stack::{BlockFrame, BlockStack, BlockType};
 pub(crate) use call_stack::{CallFrame, CallStack};
 pub(crate) use value_stack::ValueStack;