chore: preperations for simd support

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

Author: explodingcamera

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

@@ -32,7 +32,7 @@ macro_rules! mem_load {
         let mem = $store.get_mem(mem_idx as usize)?;
         let mem_ref = mem.borrow_mut();
 
-        let addr = $stack.values.pop()?.raw_value();
+        let addr: u64 = $stack.values.pop()?.into();
         let addr = $arg.offset.checked_add(addr).ok_or_else(|| {
             cold();
             Error::Trap(crate::Trap::MemoryOutOfBounds {
@@ -71,7 +71,7 @@ macro_rules! mem_store {
         let mem = $store.get_mem(mem_idx as usize)?;
 
         let val = $stack.values.pop_t::<$store_type>()?;
-        let addr = $stack.values.pop()?.raw_value();
+        let addr: u64 = $stack.values.pop()?.into();
 
         let val = val as $store_type;
         let val = val.to_le_bytes();

crates/tinywasm/src/runtime/value.rs

@@ -8,39 +8,42 @@ use tinywasm_types::{ValType, WasmValue};
 /// See [`WasmValue`] for the public representation.
 #[derive(Clone, Copy, Default, PartialEq, Eq)]
 #[repr(transparent)]
-pub struct RawWasmValue(u64);
+pub struct RawWasmValue([u8; 16]);
 
 impl Debug for RawWasmValue {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        write!(f, "RawWasmValue({})", self.0 as i64) // cast to i64 so at least negative numbers for i32 and i64 are printed correctly
+        write!(f, "RawWasmValue({})", 0)
     }
 }
 
 impl RawWasmValue {
     #[inline(always)]
-    pub fn raw_value(&self) -> u64 {
+    pub fn raw_value(&self) -> [u8; 16] {
         self.0
     }
 
     #[inline]
     pub fn attach_type(self, ty: ValType) -> WasmValue {
         match ty {
-            ValType::I32 => WasmValue::I32(self.0 as i32),
-            ValType::I64 => WasmValue::I64(self.0 as i64),
-            ValType::F32 => WasmValue::F32(f32::from_bits(self.0 as u32)),
-            ValType::F64 => WasmValue::F64(f64::from_bits(self.0)),
+            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 => WasmValue::V128(self.into()),
             ValType::RefExtern => {
-                if self.0 == -1i64 as u64 {
+                let val: i64 = self.into();
+                if val < 0 {
                     WasmValue::RefNull(ValType::RefExtern)
                 } else {
-                    WasmValue::RefExtern(self.0 as u32)
+                    WasmValue::RefExtern(val as u32)
                 }
             }
             ValType::RefFunc => {
-                if self.0 == -1i64 as u64 {
+                let val: i64 = self.into();
+                if val < 0 {
                     WasmValue::RefNull(ValType::RefFunc)
                 } else {
-                    WasmValue::RefFunc(self.0 as u32)
+                    WasmValue::RefFunc(val as u32)
                 }
             }
         }
@@ -51,13 +54,14 @@ impl From<WasmValue> for RawWasmValue {
     #[inline]
     fn from(v: WasmValue) -> Self {
         match v {
-            WasmValue::I32(i) => Self(i as u64),
-            WasmValue::I64(i) => Self(i as u64),
-            WasmValue::F32(i) => Self(i.to_bits() as u64),
-            WasmValue::F64(i) => Self(i.to_bits()),
-            WasmValue::RefExtern(v) => Self(v as i64 as u64),
-            WasmValue::RefFunc(v) => Self(v as i64 as u64),
-            WasmValue::RefNull(_) => Self(-1i64 as u64),
+            WasmValue::I32(i) => Self::from(i),
+            WasmValue::I64(i) => Self::from(i),
+            WasmValue::F32(i) => Self::from(i),
+            WasmValue::F64(i) => Self::from(i),
+            WasmValue::V128(i) => Self::from(i),
+            WasmValue::RefExtern(v) => Self::from(v as i64),
+            WasmValue::RefFunc(v) => Self::from(v as i64),
+            WasmValue::RefNull(_) => Self::from(-1i64),
         }
     }
 }
@@ -69,7 +73,7 @@ macro_rules! impl_from_raw_wasm_value {
             #[inline]
             fn from(value: $type) -> Self {
                 #[allow(clippy::redundant_closure_call)] // the comiler will figure it out :)
-                Self($to_raw(value))
+                Self(u128::to_ne_bytes($to_raw(value)))
             }
         }
 
@@ -84,13 +88,22 @@ macro_rules! impl_from_raw_wasm_value {
     };
 }
 
-impl_from_raw_wasm_value!(i32, |x| x as u64, |x| x as i32);
-impl_from_raw_wasm_value!(i64, |x| x as u64, |x| x as i64);
-impl_from_raw_wasm_value!(f32, |x| f32::to_bits(x) as u64, |x| f32::from_bits(x as u32));
-impl_from_raw_wasm_value!(f64, f64::to_bits, f64::from_bits);
+// This all looks like a lot of extra steps, but the compiler will optimize it all away.
+// The u128 just makes it a bit easier to write.
+impl_from_raw_wasm_value!(i32, |x| x as u128, |x: [u8; 16]| i32::from_ne_bytes(x[0..4].try_into().unwrap()));
+impl_from_raw_wasm_value!(i64, |x| x as u128, |x: [u8; 16]| i64::from_ne_bytes(x[0..8].try_into().unwrap()));
+impl_from_raw_wasm_value!(f32, |x| f32::to_bits(x) as u128, |x: [u8; 16]| f32::from_bits(u32::from_ne_bytes(
+    x[0..4].try_into().unwrap()
+)));
+impl_from_raw_wasm_value!(f64, |x| f64::to_bits(x) as u128, |x: [u8; 16]| f64::from_bits(u64::from_ne_bytes(
+    x[0..8].try_into().unwrap()
+)));
 
-// used for memory load/store
-impl_from_raw_wasm_value!(i8, |x| x as u64, |x| x as i8);
-impl_from_raw_wasm_value!(i16, |x| x as u64, |x| x as i16);
-impl_from_raw_wasm_value!(u32, |x| x as u64, |x| x as u32);
-impl_from_raw_wasm_value!(u64, |x| x, |x| x);
+impl_from_raw_wasm_value!(u8, |x| x as u128, |x: [u8; 16]| u8::from_ne_bytes(x[0..1].try_into().unwrap()));
+impl_from_raw_wasm_value!(u16, |x| x as u128, |x: [u8; 16]| u16::from_ne_bytes(x[0..2].try_into().unwrap()));
+impl_from_raw_wasm_value!(u32, |x| x as u128, |x: [u8; 16]| u32::from_ne_bytes(x[0..4].try_into().unwrap()));
+impl_from_raw_wasm_value!(u64, |x| x as u128, |x: [u8; 16]| u64::from_ne_bytes(x[0..8].try_into().unwrap()));
+impl_from_raw_wasm_value!(u128, |x| x, |x: [u8; 16]| u128::from_ne_bytes(x.try_into().unwrap()));
+
+impl_from_raw_wasm_value!(i8, |x| x as u128, |x: [u8; 16]| i8::from_ne_bytes(x[0..1].try_into().unwrap()));
+impl_from_raw_wasm_value!(i16, |x| x as u128, |x: [u8; 16]| i16::from_ne_bytes(x[0..2].try_into().unwrap()));