Add Val[Type]::V128 to Wasmi crates (#1418)

* re-design V128 constructors

The V128 type now mirrors wasmtime's V128 type with respect to conversions from and to Rust primitives. Mainly this supports conversions between V128 and Rust's u128 primitive.

* remove From<[u8;16]> impl for V128

As wasmtime's V128 type does not have this constructor, we shouldn't have it either. It is trivially replaceable with From<u128> impl for V128.

* add V128 conversions with UntypedVal and TypedVal

* add V128 variant to wasmi_core::ValType

* adjust wasmi crate for ValType changes

* add simd crate feature to wasmi_cli

* adjust wasmi_cli for ValType changes with simd

* add simd support for wasmi_fuzz and fuzz crates

While simd is supported by Wasmi fuzzing it still is disabled. So no actual Wasm simd fuzzing will take place. This is because the wasmi crate does not yet fully support the Wasm simd proposal.

* adjust Wasmi's C-API crates

* make Val[Type] always include V128 variants

This makes it a lot simpler to maintain dependencies to wasmi_core and also fixes some compilation problem with feature resolution in the workspace. Also this forces fewer `cfg` annotations across dependencies and the codebase as a whole.

* make V128 From and {Read,Write}As impls conditional

This is necessary to make `UntypedVal` 64-bit when `simd` is not enabled. We cannot really have those impls with just 64-bit wide `UntypedVal`s. This seems to be the least disruptive design since `ValType` and `Val` always have the same set of variants and `V128` always exists in `wasmi_core`'s crate root.

* fix imports when building docs for wasmi_ir

* apply rustfmt

Author: Robbepop

crates/c_api/Cargo.toml

@@ -27,3 +27,4 @@ doctest = false
 default = ["std"]
 std = []
 prefix-symbols = []
+simd = ["wasmi/simd"]

crates/c_api/artifact/Cargo.toml

@@ -28,3 +28,4 @@ wasmi_c_api_impl = { workspace = true }
 [features]
 default = ["std"]
 std = ["wasmi_c_api_impl/std"]
+simd = ["wasmi_c_api_impl/simd"]

crates/c_api/src/func.rs

@@ -7,9 +7,12 @@ use crate::{
     wasm_val_vec_t,
 };
 use alloc::{boxed::Box, string::String, vec, vec::Vec};
-use core::{any::Any, ffi::c_void, hint, iter, panic::AssertUnwindSafe, ptr, str};
+use core::{any::Any, ffi::c_void, hint, iter, ptr, str};
 use wasmi::{Error, Extern, Func, FuncRef, Val};
 
+#[cfg(feature = "std")]
+use core::panic::AssertUnwindSafe;
+
 /// A Wasm function.
 ///
 /// Wraps [`Func`].

crates/c_api/src/types/val.rs

@@ -34,6 +34,10 @@ pub enum wasm_valkind_t {
     ///
     /// Wraps [`ValType::F64`].
     WASM_F64 = 3,
+    /// A Wasm `v128` value type.
+    ///
+    /// Wraps [`ValType::V128`].
+    WASM_V128 = 4,
     /// A Wasm external reference type.
     ///
     /// Wraps [`ValType::ExternRef`].
@@ -67,6 +71,7 @@ pub(crate) fn into_valtype(kind: wasm_valkind_t) -> ValType {
         wasm_valkind_t::WASM_I64 => ValType::I64,
         wasm_valkind_t::WASM_F32 => ValType::F32,
         wasm_valkind_t::WASM_F64 => ValType::F64,
+        wasm_valkind_t::WASM_V128 => ValType::V128,
         wasm_valkind_t::WASM_EXTERNREF => ValType::ExternRef,
         wasm_valkind_t::WASM_FUNCREF => ValType::FuncRef,
     }
@@ -79,6 +84,7 @@ pub(crate) fn from_valtype(ty: &ValType) -> wasm_valkind_t {
         ValType::I64 => wasm_valkind_t::WASM_I64,
         ValType::F32 => wasm_valkind_t::WASM_F32,
         ValType::F64 => wasm_valkind_t::WASM_F64,
+        ValType::V128 => wasm_valkind_t::WASM_V128,
         ValType::ExternRef => wasm_valkind_t::WASM_EXTERNREF,
         ValType::FuncRef => wasm_valkind_t::WASM_FUNCREF,
     }

crates/c_api/src/val.rs

@@ -10,7 +10,7 @@ use crate::{
 use alloc::boxed::Box;
 use core::{mem::MaybeUninit, ptr};
 use wasmi::{
-    core::{ValType, F32, F64},
+    core::{ValType, F32, F64, V128},
     FuncRef,
     Val,
 };
@@ -42,6 +42,8 @@ pub union wasm_val_union {
     pub f32: f32,
     /// A Wasm 64-bit float.
     pub f64: f64,
+    /// A Wasm `v128` value.
+    pub v128: u128,
     /// A Wasm referenced object.
     pub ref_: *mut wasm_ref_t,
 }
@@ -101,6 +103,12 @@ impl From<Val> for wasm_val_t {
                     u64: value.to_bits(),
                 },
             },
+            Val::V128(value) => Self {
+                kind: from_valtype(&ValType::V128),
+                of: wasm_val_union {
+                    v128: value.as_u128(),
+                },
+            },
             Val::FuncRef(funcref) => Self {
                 kind: from_valtype(&ValType::FuncRef),
                 of: wasm_val_union {
@@ -133,6 +141,7 @@ impl wasm_val_t {
             ValType::I64 => Val::from(unsafe { self.of.i64 }),
             ValType::F32 => Val::from(F32::from(unsafe { self.of.f32 })),
             ValType::F64 => Val::from(F64::from(unsafe { self.of.f64 })),
+            ValType::V128 => Val::from(V128::from(unsafe { self.of.v128 })),
             ValType::FuncRef => match unsafe { self.of.ref_ }.is_null() {
                 true => Val::FuncRef(FuncRef::null()),
                 false => ref_to_val(unsafe { &*self.of.ref_ }),

crates/cli/Cargo.toml

@@ -26,6 +26,7 @@ assert_cmd = "2.0.7"
 default = []
 hash-collections = ["wasmi/hash-collections"]
 prefer-btree-collections = ["wasmi/prefer-btree-collections"]
+simd = ["wasmi/simd"]
 
 # We need to put this [profile.release] section due to this bug in Cargo:
 # https://github.com/rust-lang/cargo/issues/8264

crates/cli/src/display.rs

@@ -18,6 +18,7 @@ impl Display for DisplayValueType<'_> {
             ValType::I64 => write!(f, "i64"),
             ValType::F32 => write!(f, "f32"),
             ValType::F64 => write!(f, "f64"),
+            ValType::V128 => write!(f, "v128"),
             ValType::FuncRef => write!(f, "funcref"),
             ValType::ExternRef => write!(f, "externref"),
         }
@@ -40,6 +41,7 @@ impl fmt::Display for DisplayValue<'_> {
             Val::I64(value) => write!(f, "{value}"),
             Val::F32(value) => write!(f, "{value}"),
             Val::F64(value) => write!(f, "{value}"),
+            Val::V128(value) => write!(f, "0x{:032X}", value.as_u128()),
             Val::FuncRef(value) => panic!("cannot display funcref values but found {value:?}"),
             Val::ExternRef(value) => {
                 panic!("cannot display externref values but found {value:?}")

crates/cli/src/utils.rs

@@ -1,7 +1,7 @@
 use crate::display::DisplayValueType;
 use anyhow::{anyhow, bail, Error};
 use wasmi::{
-    core::{ValType, F32, F64},
+    core::{ValType, F32, F64, V128},
     FuncType,
     Val,
 };
@@ -56,6 +56,11 @@ pub fn decode_func_args(ty: &FuncType, args: &[String]) -> Result<Box<[Val]>, Er
                     .map(F64::from)
                     .map(Val::from)
                     .map_err(make_err!()),
+                ValType::V128 => arg
+                    .parse::<u128>()
+                    .map(V128::from)
+                    .map(Val::from)
+                    .map_err(make_err!()),
                 ValType::FuncRef => {
                     bail!("the wasmi CLI cannot take arguments of type funcref")
                 }

crates/core/src/lib.rs

@@ -35,5 +35,5 @@ pub use self::{
     trap::{Trap, TrapCode},
     typed::{Typed, TypedVal},
     untyped::{DecodeUntypedSlice, EncodeUntypedSlice, ReadAs, UntypedError, UntypedVal, WriteAs},
-    value::ValType,
+    value::{ValType, V128},
 };

crates/core/src/simd.rs

@@ -1,4 +1,12 @@
-use crate::{memory, memory::ExtendInto, simd, wasm, ReadAs, TrapCode, UntypedVal, WriteAs};
+//! Defines the entire Wasm `simd` proposal API.
+
+use crate::{
+    memory::{self, ExtendInto},
+    simd,
+    wasm,
+    TrapCode,
+    V128,
+};
 use core::{
     array,
     ops::{BitAnd, BitOr, BitXor, Neg, Not},
@@ -10,60 +18,6 @@ macro_rules! op {
     }};
 }
 
-/// The Wasm `simd` proposal's `v128` type.
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-#[repr(transparent)]
-pub struct V128([u8; 16]);
-
-impl From<[u8; 16]> for V128 {
-    fn from(bytes: [u8; 16]) -> Self {
-        Self(bytes)
-    }
-}
-
-impl From<i128> for V128 {
-    fn from(value: i128) -> Self {
-        Self(value.to_le_bytes())
-    }
-}
-
-impl V128 {
-    /// Creates an `i128` value from the bytes of `self`.
-    pub(crate) fn to_i128(self) -> i128 {
-        i128::from_le_bytes(self.0)
-    }
-}
-
-impl From<UntypedVal> for V128 {
-    fn from(value: UntypedVal) -> Self {
-        let u128 = (u128::from(value.hi64) << 64) | (u128::from(value.lo64));
-        Self(u128.to_le_bytes())
-    }
-}
-
-impl From<V128> for UntypedVal {
-    fn from(value: V128) -> Self {
-        let u128 = u128::from_le_bytes(value.0);
-        let lo64 = u128 as u64;
-        let hi64 = (u128 >> 64) as u64;
-        Self { lo64, hi64 }
-    }
-}
-
-impl ReadAs<V128> for UntypedVal {
-    fn read_as(&self) -> V128 {
-        // Note: we can re-use the `From` impl since both types are of equal size.
-        V128::from(*self)
-    }
-}
-
-impl WriteAs<V128> for UntypedVal {
-    fn write_as(&mut self, value: V128) {
-        // Note: we can re-use the `From` impl since both types are of equal size.
-        *self = UntypedVal::from(value);
-    }
-}
-
 /// An error that may occur when constructing an out of bounds lane index.
 pub struct OutOfBoundsLaneIdx;
 
@@ -1287,7 +1241,7 @@ impl_bitmask_ops! {
 
 /// Executes a Wasm `v128.any_true` instruction.
 pub fn v128_any_true(v128: V128) -> bool {
-    v128.to_i128() != 0
+    v128.as_u128() != 0
 }
 
 /// Executes a Wasm `i32x4.dot_i16x8_s` instruction.
@@ -1314,7 +1268,7 @@ pub fn v128_bitselect(v1: V128, v2: V128, c: V128) -> V128 {
 /// - If `ptr + offset` overflows.
 /// - If `ptr + offset` stores out of bounds from `memory`.
 pub fn v128_store(memory: &mut [u8], ptr: u64, offset: u64, value: V128) -> Result<(), TrapCode> {
-    memory::store(memory, ptr, offset, value.to_i128())
+    memory::store(memory, ptr, offset, value.as_u128())
 }
 
 /// Executes a Wasm `v128.store` instruction.
@@ -1323,7 +1277,7 @@ pub fn v128_store(memory: &mut [u8], ptr: u64, offset: u64, value: V128) -> Resu
 ///
 /// If `address` stores out of bounds from `memory`.
 pub fn v128_store_at(memory: &mut [u8], address: usize, value: V128) -> Result<(), TrapCode> {
-    memory::store_at(memory, address, value.to_i128())
+    memory::store_at(memory, address, value.as_u128())
 }
 
 macro_rules! impl_v128_storeN_lane {
@@ -1424,7 +1378,7 @@ impl_v128_storeN_lane_at! {
 /// - If `ptr + offset` overflows.
 /// - If `ptr + offset` loads out of bounds from `memory`.
 pub fn v128_load(memory: &[u8], ptr: u64, offset: u64) -> Result<V128, TrapCode> {
-    memory::load::<i128>(memory, ptr, offset).map(V128::from)
+    memory::load::<u128>(memory, ptr, offset).map(V128::from)
 }
 
 /// Executes a Wasmi `v128.load` instruction.
@@ -1433,7 +1387,7 @@ pub fn v128_load(memory: &[u8], ptr: u64, offset: u64) -> Result<V128, TrapCode>
 ///
 /// If `address` loads out of bounds from `memory`.
 pub fn v128_load_at(memory: &[u8], address: usize) -> Result<V128, TrapCode> {
-    memory::load_at::<i128>(memory, address).map(V128::from)
+    memory::load_at::<u128>(memory, address).map(V128::from)
 }
 
 macro_rules! impl_v128_loadN_zero_for {