Merge #2202

2202: Include fuzzers in fmt and clippy. r=nlewycky a=nlewycky



Co-authored-by: Nick Lewycky <[email protected]>

Author: bors[bot]

Makefile

@@ -515,6 +515,7 @@ test-packages:
 	cargo test -p wasmer-cache --release
 	cargo test -p wasmer-engine --release
 	cargo test -p wasmer-derive --release
+	cargo check --manifest-path fuzz/Cargo.toml $(compiler_features) --release
 
 
 # We want to run all the tests for all available compilers. The C API
@@ -739,9 +740,11 @@ lint-packages:
 	RUSTFLAGS=${RUSTFLAGS} cargo clippy --manifest-path lib/cli/Cargo.toml $(compiler_features)
 	RUSTFLAGS=${RUSTFLAGS} cargo clippy -p wasmer-cache
 	RUSTFLAGS=${RUSTFLAGS} cargo clippy -p wasmer-engine
+	RUSTFLAGS=${RUSTFLAGS} cargo clippy --manifest-path fuzz/Cargo.toml $(compiler_features)
 
 lint-formatting:
 	cargo fmt --all -- --check
+	cargo fmt --manifest-path fuzz/Cargo.toml -- --check
 
 lint: lint-formatting lint-packages
 

fuzz/Cargo.lock

@@ -12,20 +12,20 @@ cargo-fuzz = true
 anyhow = "1"
 wasm-smith = { git = "https://github.com/bytecodealliance/wasm-tools" }
 libfuzzer-sys = "0.4.0"
-[dependencies.wasmer]
-path = "../lib/api"
-[dependencies.wasmer-compiler-cranelift]
-path = "../lib/compiler-cranelift"
-[dependencies.wasmer-compiler-llvm]
-path = "../lib/compiler-llvm"
-[dependencies.wasmer-compiler-singlepass]
-path = "../lib/compiler-singlepass"
-[dependencies.wasmer-engine-jit]
-path = "../lib/engine-jit"
-[dependencies.wasmer-engine-native]
-path = "../lib/engine-native"
-[dependencies.wasmer-middlewares]
-path = "../lib/middlewares"
+wasmer = { path = "../lib/api" }
+wasmer-compiler-cranelift = { path = "../lib/compiler-cranelift", optional = true }
+wasmer-compiler-llvm = { path = "../lib/compiler-llvm", optional = true }
+wasmer-compiler-singlepass = { path = "../lib/compiler-singlepass", optional = true }
+wasmer-engine-jit = { path = "../lib/engine-jit", optional = true }
+wasmer-engine-native = { path = "../lib/engine-native", optional = true }
+wasmer-middlewares = { path = "../lib/middlewares" }
+
+[features]
+cranelift = [ "wasmer-compiler-cranelift" ]
+llvm = [ "wasmer-compiler-llvm" ]
+singlepass = [ "wasmer-compiler-singlepass" ]
+jit = [ "wasmer-engine-jit" ]
+native = [ "wasmer-engine-native" ]
 
 # Prevent this from interfering with workspaces
 [workspace]
@@ -34,27 +34,34 @@ members = ["."]
 [[bin]]
 name = "equivalence_jit"
 path = "fuzz_targets/equivalence_jit.rs"
+required-features = ["jit"]
 
 [[bin]]
 name = "jit_cranelift"
 path = "fuzz_targets/jit_cranelift.rs"
+required-features = ["jit", "cranelift"]
 
 [[bin]]
 name = "jit_llvm"
 path = "fuzz_targets/jit_llvm.rs"
+required-features = ["jit", "llvm"]
 
 [[bin]]
 name = "jit_singlepass"
 path = "fuzz_targets/jit_singlepass.rs"
+required-features = ["jit", "singlepass"]
 
 [[bin]]
 name = "metering"
 path = "fuzz_targets/metering.rs"
+required-features = ["jit", "cranelift"]
 
 [[bin]]
 name = "native_cranelift"
 path = "fuzz_targets/native_cranelift.rs"
+required-features = ["native", "cranelift"]
 
 [[bin]]
 name = "validate"
 path = "fuzz_targets/validate.rs"
+required-features = ["jit", "cranelift"]

fuzz/Cargo.toml

@@ -1,11 +1,15 @@
 #![no_main]
+#![deny(unused_variables)]
 
 use anyhow::Result;
 use libfuzzer_sys::{arbitrary, arbitrary::Arbitrary, fuzz_target};
 use wasm_smith::{Config, ConfiguredModule};
 use wasmer::{imports, CompilerConfig, Instance, Module, Store, Val};
+#[cfg(feature = "cranelift")]
 use wasmer_compiler_cranelift::Cranelift;
+#[cfg(feature = "llvm")]
 use wasmer_compiler_llvm::LLVM;
+#[cfg(feature = "singlepass")]
 use wasmer_compiler_singlepass::Singlepass;
 use wasmer_engine_jit::JIT;
 
@@ -27,6 +31,7 @@ impl Config for ExportedFunctionConfig {
     }
 }
 
+#[cfg(feature = "singlepass")]
 fn maybe_instantiate_singlepass(wasm_bytes: &[u8]) -> Result<Option<Instance>> {
     let compiler = Singlepass::default();
     let store = Store::new(&JIT::new(compiler).engine());
@@ -45,6 +50,7 @@ fn maybe_instantiate_singlepass(wasm_bytes: &[u8]) -> Result<Option<Instance>> {
     Ok(Some(instance))
 }
 
+#[cfg(feature = "cranelift")]
 fn maybe_instantiate_cranelift(wasm_bytes: &[u8]) -> Result<Option<Instance>> {
     let mut compiler = Cranelift::default();
     compiler.canonicalize_nans(true);
@@ -55,6 +61,7 @@ fn maybe_instantiate_cranelift(wasm_bytes: &[u8]) -> Result<Option<Instance>> {
     Ok(Some(instance))
 }
 
+#[cfg(feature = "llvm")]
 fn maybe_instantiate_llvm(wasm_bytes: &[u8]) -> Result<Option<Instance>> {
     let mut compiler = LLVM::default();
     compiler.canonicalize_nans(true);
@@ -78,15 +85,14 @@ impl PartialEq for InstanceResult {
                 if let InstanceResult::Error(other_message) = other {
                     return self_message == other_message;
                 }
-                return false;
             }
             InstanceResult::Values(self_values) => {
                 if let InstanceResult::Values(other_values) = other {
                     return self_values == other_values;
                 }
-                return false;
             }
         }
+        false
     }
 }
 
@@ -109,8 +115,7 @@ fn evaluate_instance(instance: Result<Instance>) -> Vec<InstanceResult> {
             // TODO: support functions which take params.
             if f.ty().params().is_empty() {
                 let result = f.call(&[]);
-                let result = if result.is_ok() {
-                    let values = result.unwrap();
+                let result = if let Ok(values) = result {
                     InstanceResult::Values(values.into())
                 } else {
                     let err = result.unwrap_err();
@@ -129,16 +134,28 @@ fuzz_target!(|module: ConfiguredModule<ExportedFunctionConfig>| {
     module.ensure_termination(100000);
     let wasm_bytes = module.to_bytes();
 
-    let singlepass = maybe_instantiate_singlepass(&wasm_bytes).transpose().map(evaluate_instance);
-    let cranelift = maybe_instantiate_cranelift(&wasm_bytes).transpose().map(evaluate_instance);
-    let llvm = maybe_instantiate_llvm(&wasm_bytes).transpose().map(evaluate_instance);
+    #[cfg(feature = "singlepass")]
+    let singlepass = maybe_instantiate_singlepass(&wasm_bytes)
+        .transpose()
+        .map(evaluate_instance);
+    #[cfg(feature = "cranelift")]
+    let cranelift = maybe_instantiate_cranelift(&wasm_bytes)
+        .transpose()
+        .map(evaluate_instance);
+    #[cfg(feature = "llvm")]
+    let llvm = maybe_instantiate_llvm(&wasm_bytes)
+        .transpose()
+        .map(evaluate_instance);
 
+    #[cfg(all(feature = "singlepass", feature = "cranelift"))]
     if singlepass.is_some() && cranelift.is_some() {
         assert_eq!(singlepass.as_ref().unwrap(), cranelift.as_ref().unwrap());
     }
+    #[cfg(all(feature = "singlepass", feature = "llvm"))]
     if singlepass.is_some() && llvm.is_some() {
         assert_eq!(singlepass.as_ref().unwrap(), llvm.as_ref().unwrap());
     }
+    #[cfg(all(feature = "cranelift", feature = "llvm"))]
     if cranelift.is_some() && llvm.is_some() {
         assert_eq!(cranelift.as_ref().unwrap(), llvm.as_ref().unwrap());
     }

fuzz/fuzz_targets/equivalence_jit.rs

@@ -40,8 +40,7 @@ fuzz_target!(|module: ConfiguredModule<NoImportsConfig>| {
         Ok(_) => {}
         Err(e) => {
             let error_message = format!("{}", e);
-            if 
-                error_message
+            if error_message
                 .contains("RuntimeError: memory out of bounds: data segment does not fit")
                 || error_message
                     .contains("RuntimeError: table out of bounds: elements segment does not fit")

fuzz/fuzz_targets/jit_singlepass.rs

@@ -3,8 +3,8 @@
 use libfuzzer_sys::{arbitrary, arbitrary::Arbitrary, fuzz_target};
 use std::sync::Arc;
 use wasm_smith::{Config, ConfiguredModule};
-use wasmer::{imports, CompilerConfig, Instance, Module, Store};
 use wasmer::wasmparser::Operator;
+use wasmer::{imports, CompilerConfig, Instance, Module, Store};
 use wasmer_compiler_cranelift::Cranelift;
 use wasmer_engine_jit::JIT;
 use wasmer_middlewares::Metering;