🏗️ Move wasm-smith's non-trapping mode logic to CodeBuilder

crates/fuzz-stats/src/bin/failed-instantiations.rs

@@ -118,7 +118,7 @@ impl State {
         let module = Module::new(&self.engine, &wasm).expect("failed to compile module");
         let mut store = Store::new(
             &self.engine,
-            StoreLimits {
+            fuzz_stats::limits::StoreLimits {
                 remaining_memory: 1 << 30,
                 oom: false,
             },
@@ -181,34 +181,3 @@ impl State {
         println!();
     }
 }
-
-struct StoreLimits {
-    remaining_memory: usize,
-    oom: bool,
-}
-
-impl StoreLimits {
-    fn alloc(&mut self, amt: usize) -> bool {
-        match self.remaining_memory.checked_sub(amt) {
-            Some(mem) => {
-                self.remaining_memory = mem;
-                true
-            }
-            None => {
-                self.oom = true;
-                false
-            }
-        }
-    }
-}
-
-impl ResourceLimiter for StoreLimits {
-    fn memory_growing(&mut self, current: usize, desired: usize, _maximum: Option<usize>) -> bool {
-        self.alloc(desired - current)
-    }
-
-    fn table_growing(&mut self, current: u32, desired: u32, _maximum: Option<u32>) -> bool {
-        let delta = (desired - current) as usize * std::mem::size_of::<usize>();
-        self.alloc(delta)
-    }
-}

crates/fuzz-stats/src/lib.rs

@@ -1 +1,2 @@
 pub mod dummy;
+pub mod limits;

crates/fuzz-stats/src/limits.rs

@@ -0,0 +1,31 @@
+use wasmtime::*;
+pub struct StoreLimits {
+    pub remaining_memory: usize,
+    pub oom: bool,
+}
+
+impl StoreLimits {
+    fn alloc(&mut self, amt: usize) -> bool {
+        match self.remaining_memory.checked_sub(amt) {
+            Some(mem) => {
+                self.remaining_memory = mem;
+                true
+            }
+            None => {
+                self.oom = true;
+                false
+            }
+        }
+    }
+}
+
+impl ResourceLimiter for StoreLimits {
+    fn memory_growing(&mut self, current: usize, desired: usize, _maximum: Option<usize>) -> bool {
+        self.alloc(desired - current)
+    }
+
+    fn table_growing(&mut self, current: u32, desired: u32, _maximum: Option<u32>) -> bool {
+        let delta = (desired - current) as usize * std::mem::size_of::<usize>();
+        self.alloc(delta)
+    }
+}

crates/wasm-smith/src/config.rs

@@ -449,6 +449,25 @@ pub trait Config: 'static + std::fmt::Debug {
     fn threads_enabled(&self) -> bool {
         false
     }
+
+    /// Returns whether we should avoid generating code that will possibly trap.
+    ///
+    /// For some trapping instructions, this will emit extra instructions to
+    /// ensure they don't trap, while some instructions will simply be excluded.
+    /// In cases where we would run into a trap, we instead choose some
+    /// arbitrary non-trapping behavior. For example, if we detect that a Load
+    /// instruction would attempt to access out-of-bounds memory, we instead
+    /// pretend the load succeeded and push 0 onto the stack.
+    ///
+    /// One type of trap that we can't currently avoid is StackOverflow. Even
+    /// when `disallow_traps` is set to true, wasm-smith will eventually
+    /// generate a program that infinitely recurses, causing the call stack to
+    /// be exhausted.
+    ///
+    /// Defaults to `false`.
+    fn disallow_traps(&self) -> bool {
+        false
+    }
 }
 
 /// The default configuration.
@@ -476,6 +495,7 @@ pub struct SwarmConfig {
     pub available_imports: Option<Vec<u8>>,
     pub bulk_memory_enabled: bool,
     pub canonicalize_nans: bool,
+    pub disallow_traps: bool,
     pub exceptions_enabled: bool,
     pub export_everything: bool,
     pub max_aliases: usize,
@@ -597,6 +617,7 @@ impl<'a> Arbitrary<'a> for SwarmConfig {
             available_imports: None,
             threads_enabled: false,
             export_everything: false,
+            disallow_traps: false,
         })
     }
 }
@@ -795,4 +816,8 @@ impl Config for SwarmConfig {
     fn table_max_size_required(&self) -> bool {
         self.table_max_size_required
     }
+
+    fn disallow_traps(&self) -> bool {
+        self.disallow_traps
+    }
 }