Update the Wasmi differential fuzzing oracle to v1.0 (#12312)

* update the wasmi fuzzing oracle to v1.0.7

* make wasmi oracle impl compile again

* apply rustfmt

Author: Robbepop

Cargo.lock

@@ -34,7 +34,7 @@ wasm-smith = { workspace = true, features = ['serde'] }
 wasm-mutate = { workspace = true }
 wasm-compose = { workspace = true }
 wasm-spec-interpreter = { path = "./wasm-spec-interpreter", optional = true }
-wasmi = { version = "0.51.1", default-features = false, features = ["std", "simd"] }
+wasmi = { version = "1.0.7", default-features = false, features = ["std", "simd"] }
 futures = { workspace = true, features = ['async-await'] }
 wasmtime-test-util = { workspace = true, features = ['wast', 'component-fuzz', 'component'] }
 serde_json = { workspace = true }

crates/fuzzing/Cargo.toml

@@ -40,7 +40,7 @@ impl WasmiEngine {
         }
     }
 
-    fn trap_code(&self, err: &Error) -> Option<wasmi::core::TrapCode> {
+    fn trap_code(&self, err: &Error) -> Option<wasmi::TrapCode> {
         let err = err.downcast_ref::<wasmi::Error>()?;
         if let Some(code) = err.as_trap_code() {
             return Some(code);
@@ -49,12 +49,12 @@ impl WasmiEngine {
         match err.kind() {
             wasmi::errors::ErrorKind::Instantiation(
                 wasmi::errors::InstantiationError::ElementSegmentDoesNotFit { .. },
-            ) => Some(wasmi::core::TrapCode::TableOutOfBounds),
+            ) => Some(wasmi::TrapCode::TableOutOfBounds),
             wasmi::errors::ErrorKind::Memory(wasmi::errors::MemoryError::OutOfBoundsAccess) => {
-                Some(wasmi::core::TrapCode::MemoryOutOfBounds)
+                Some(wasmi::TrapCode::MemoryOutOfBounds)
             }
             wasmi::errors::ErrorKind::Table(wasmi::errors::TableError::CopyOutOfBounds) => {
-                Some(wasmi::core::TrapCode::TableOutOfBounds)
+                Some(wasmi::TrapCode::TableOutOfBounds)
             }
             _ => {
                 log::trace!("unknown wasmi error: {:?}", err.kind());
@@ -87,16 +87,13 @@ impl DiffEngine for WasmiEngine {
     }
 
     fn is_non_deterministic_error(&self, err: &Error) -> bool {
-        matches!(
-            self.trap_code(err),
-            Some(wasmi::core::TrapCode::StackOverflow)
-        )
+        matches!(self.trap_code(err), Some(wasmi::TrapCode::StackOverflow))
     }
 }
 
 /// Converts `wasmi` trap code to `wasmtime` trap code.
-fn wasmi_to_wasmtime_trap_code(trap: wasmi::core::TrapCode) -> Trap {
-    use wasmi::core::TrapCode;
+fn wasmi_to_wasmtime_trap_code(trap: wasmi::TrapCode) -> Trap {
+    use wasmi::TrapCode;
     match trap {
         TrapCode::UnreachableCodeReached => Trap::UnreachableCodeReached,
         TrapCode::MemoryOutOfBounds => Trap::MemoryOutOfBounds,
@@ -174,9 +171,9 @@ impl From<&DiffValue> for wasmi::Val {
         match *v {
             DiffValue::I32(n) => WasmiValue::I32(n),
             DiffValue::I64(n) => WasmiValue::I64(n),
-            DiffValue::F32(n) => WasmiValue::F32(wasmi::core::F32::from_bits(n)),
-            DiffValue::F64(n) => WasmiValue::F64(wasmi::core::F64::from_bits(n)),
-            DiffValue::V128(n) => WasmiValue::V128(wasmi::core::V128::from(n)),
+            DiffValue::F32(n) => WasmiValue::F32(wasmi::F32::from_bits(n)),
+            DiffValue::F64(n) => WasmiValue::F64(wasmi::F64::from_bits(n)),
+            DiffValue::V128(n) => WasmiValue::V128(wasmi::V128::from(n)),
             DiffValue::FuncRef { null } => {
                 assert!(null);
                 WasmiValue::default(wasmi::ValType::FuncRef)