Enable Wasm simd fuzzing (#1428)

* enable Wasm `simd` fuzzing

* add missing FuzzVal -> V128 conversion for Wasmtime

* add missing comparison in PartialEq for FuzzVal

Author: Robbepop

crates/fuzz/src/config.rs

@@ -105,7 +105,7 @@ impl Arbitrary<'_> for FuzzSmithConfig {
             custom_page_sizes_enabled: true,
             bulk_memory_enabled: true,
             reference_types_enabled: false, // TODO: re-enable reference-types for differential fuzzing
-            simd_enabled: false,
+            simd_enabled: true,
             multi_value_enabled: true,
             memory64_enabled: true,
             saturating_float_to_int_enabled: true,
@@ -171,6 +171,13 @@ impl FuzzSmithConfig {
     pub fn disable_memory64(&mut self) {
         self.inner.memory64_enabled = false;
     }
+
+    /// Disable the Wasm `simd` proposal.
+    ///
+    /// This is required by some supported Wasm runtime oracles.
+    pub fn disable_simd(&mut self) {
+        self.inner.simd_enabled = false;
+    }
 }
 
 impl From<FuzzSmithConfig> for wasm_smith::Config {

crates/fuzz/src/oracle/wasmi_stack.rs

@@ -34,6 +34,7 @@ impl DifferentialOracleMeta for WasmiStackOracle {
         config.disable_custom_page_sizes();
         config.disable_memory64();
         config.disable_wide_arithmetic();
+        config.disable_simd();
     }
 
     fn setup(wasm: &[u8]) -> Option<Self>

crates/fuzz/src/oracle/wasmtime.rs

@@ -106,6 +106,7 @@ impl From<Val> for FuzzVal {
             Val::I64(value) => Self::I64(value),
             Val::F32(value) => Self::F32(f32::from_bits(value)),
             Val::F64(value) => Self::F64(f64::from_bits(value)),
+            Val::V128(value) => Self::V128(value.as_u128()),
             Val::FuncRef(value) => Self::FuncRef {
                 is_null: value.is_none(),
             },

crates/fuzz/src/value.rs

@@ -53,6 +53,7 @@ impl PartialEq for FuzzVal {
             (Self::I64(l), Self::I64(r)) => l == r,
             (Self::F32(l), Self::F32(r)) => l.to_bits() == r.to_bits(),
             (Self::F64(l), Self::F64(r)) => l.to_bits() == r.to_bits(),
+            (Self::V128(l), Self::V128(r)) => l == r,
             (Self::FuncRef { is_null: l }, Self::FuncRef { is_null: r }) => l == r,
             (Self::ExternRef { is_null: l }, Self::ExternRef { is_null: r }) => l == r,
             _ => false,