chore: cleanup simd stack code

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

Author: explodingcamera

crates/parser/Cargo.toml

@@ -16,4 +16,3 @@ tinywasm-types={version="0.7.0", path="../types", default-features=false}
 default=["std", "logging"]
 logging=["log"]
 std=["tinywasm-types/std", "wasmparser/std"]
-nightly=[]

crates/tinywasm/Cargo.toml

@@ -33,7 +33,7 @@ logging=["_log", "tinywasm-parser?/logging", "tinywasm-types/logging"]
 std=["tinywasm-parser?/std", "tinywasm-types/std"]
 parser=["tinywasm-parser"]
 archive=["tinywasm-types/archive"]
-nightly=[]
+simd=[]
 
 [[test]]
 name="test-mvp"

crates/tinywasm/src/func.rs

@@ -1,4 +1,4 @@
-use crate::runtime::{CallFrame, Stack, WasmValueRepr};
+use crate::runtime::{CallFrame, Stack};
 use crate::{log, runtime::RawWasmValue, unlikely, Function};
 use crate::{Error, FuncContext, Result, Store};
 use alloc::{boxed::Box, format, string::String, string::ToString, vec, vec::Vec};

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))]
+#![cfg_attr(nightly, feature(error_in_core, portable_simd))]
 #![forbid(unsafe_code)]
 
 //! A tiny WebAssembly Runtime written in Rust

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

@@ -3,8 +3,9 @@ use alloc::string::ToString;
 use core::ops::{BitAnd, BitOr, BitXor, Neg};
 use tinywasm_types::{BlockArgs, ElementKind, Instruction, ValType};
 
+use super::stack::{BlockFrame, BlockType};
 use super::{InterpreterRuntime, RawWasmValue, Stack};
-use crate::runtime::{BlockFrame, BlockType, CallFrame};
+use crate::runtime::CallFrame;
 use crate::{cold, unlikely};
 use crate::{Error, FuncContext, ModuleInstance, Result, Store, Trap};
 
@@ -724,7 +725,6 @@ impl<'store, 'stack> Executor<'store, 'stack> {
             instr_ptr,
             end_instr_offset,
             stack_ptr: self.stack.values.len() as u32 - params as u32,
-            large_stack_ptr: 0,
             results,
             params,
             ty,

crates/tinywasm/src/runtime/mod.rs

@@ -1,18 +1,24 @@
 mod interpreter;
 mod stack;
-mod value;
+
+mod raw;
+
+#[cfg(all(nightly, feature = "simd"))]
+mod raw_simd;
 
 use crate::Result;
-pub use stack::*;
-pub use value::{LargeRawWasmValue, RawWasmValue, WasmValueRepr};
+
+pub use raw::RawWasmValue;
+pub(crate) use stack::CallFrame;
+pub(crate) use stack::Stack;
 
 #[allow(rustdoc::private_intra_doc_links)]
 /// A WebAssembly runtime.
 ///
 /// See <https://webassembly.github.io/spec/core/exec/runtime.html>
 pub trait Runtime {
     /// Execute all call-frames on the stack until the stack is empty.
-    fn exec(&self, store: &mut crate::Store, stack: &mut crate::runtime::Stack) -> Result<()>;
+    fn exec(&self, store: &mut crate::Store, stack: &mut Stack) -> Result<()>;
 }
 
 /// The main TinyWasm runtime.

crates/tinywasm/src/runtime/value.rs renamed to crates/tinywasm/src/runtime/raw.rs

@@ -9,38 +9,28 @@ use tinywasm_types::{ValType, WasmValue};
 #[derive(Clone, Copy, Default, PartialEq, Eq)]
 pub struct RawWasmValue([u8; 8]);
 
-/// 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 LargeRawWasmValue([u8; 16]);
-
 impl Debug for RawWasmValue {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         write!(f, "RawWasmValue({})", 0)
     }
 }
 
-impl Debug for LargeRawWasmValue {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        write!(f, "LargeRawWasmValue({})", 0)
+impl RawWasmValue {
+    #[inline(always)]
+    /// Get the raw value
+    pub fn raw_value(&self) -> [u8; 8] {
+        self.0
     }
-}
-
-pub trait WasmValueRepr {
-    fn attach_type(self, ty: ValType) -> WasmValue;
-}
 
-impl WasmValueRepr for RawWasmValue {
     #[inline]
-    fn attach_type(self, ty: ValType) -> WasmValue {
+    /// Attach a type to the raw value (does not support simd values)
+    pub fn attach_type(self, ty: ValType) -> WasmValue {
         match ty {
             ValType::I32 => WasmValue::I32(self.into()),
             ValType::I64 => WasmValue::I64(self.into()),
             ValType::F32 => WasmValue::F32(f32::from_bits(self.into())),
             ValType::F64 => WasmValue::F64(f64::from_bits(self.into())),
+            ValType::V128 => panic!("RawWasmValue cannot be converted to V128"),
             ValType::RefExtern => match i64::from(self) {
                 v if v < 0 => WasmValue::RefNull(ValType::RefExtern),
                 addr => WasmValue::RefExtern(addr as u32),
@@ -53,13 +43,6 @@ impl WasmValueRepr for RawWasmValue {
     }
 }
 
-impl RawWasmValue {
-    #[inline(always)]
-    pub fn raw_value(&self) -> [u8; 8] {
-        self.0
-    }
-}
-
 impl From<WasmValue> for RawWasmValue {
     #[inline]
     fn from(v: WasmValue) -> Self {
@@ -68,6 +51,7 @@ impl From<WasmValue> for RawWasmValue {
             WasmValue::I64(i) => Self::from(i),
             WasmValue::F32(i) => Self::from(i),
             WasmValue::F64(i) => Self::from(i),
+            WasmValue::V128(_) => panic!("RawWasmValue cannot be converted to V128"),
             WasmValue::RefExtern(v) => Self::from(v as i64),
             WasmValue::RefFunc(v) => Self::from(v as i64),
             WasmValue::RefNull(_) => Self::from(-1i64),

crates/tinywasm/src/runtime/raw_simd.rs

@@ -0,0 +1,13 @@
+/// 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]);
+
+impl Debug for RawSimdWasmValue {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "LargeRawWasmValue({})", 0)
+    }
+}

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

@@ -55,8 +55,10 @@ pub(crate) struct BlockFrame {
     pub(crate) instr_ptr: usize, // position of the instruction pointer when the block was entered
     pub(crate) end_instr_offset: u32, // position of the end instruction of the block
 
-    pub(crate) stack_ptr: u32,       // position of the stack pointer when the block was entered
-    pub(crate) large_stack_ptr: u32, // position of the large stack pointer when the block was entered
+    pub(crate) stack_ptr: u32, // position of the stack pointer when the block was entered
+
+    #[cfg(all(nightly, feature = "simd"))]
+    pub(crate) simd_stack_ptr: u32, // position of the large stack pointer when the block was entered
 
     pub(crate) results: u8,
     pub(crate) params: u8,

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

@@ -1,9 +1,11 @@
-use crate::runtime::{BlockType, RawWasmValue};
+use crate::runtime::RawWasmValue;
 use crate::{cold, unlikely};
 use crate::{Error, Result, Trap};
 use alloc::{boxed::Box, rc::Rc, vec::Vec};
 use tinywasm_types::{Instruction, LocalAddr, ModuleInstanceAddr, WasmFunction};
 
+use super::BlockType;
+
 const CALL_STACK_SIZE: usize = 1024;
 
 #[derive(Debug)]
@@ -72,7 +74,7 @@ impl CallFrame {
     pub(crate) fn break_to(
         &mut self,
         break_to_relative: u32,
-        values: &mut super::ValueStack<RawWasmValue>,
+        values: &mut super::ValueStack,
         blocks: &mut super::BlockStack,
     ) -> Option<()> {
         let break_to = blocks.get_relative_to(break_to_relative, self.block_ptr)?;