Merge pull request #56 from teymour-aldridge/2024

teymour-aldridge · web-flow · commit c24c44931c78 · 2025-07-06T02:20:21.000+01:00
2024
diff --git a/cargo-fuzzcheck/Cargo.toml b/cargo-fuzzcheck/Cargo.toml
@@ -2,7 +2,7 @@
 name = "cargo-fuzzcheck"
 version = "0.13.0"
 authors = ["Loïc Lecrenier <loic.lecrenier@me.com>"]
-edition = "2021"
+edition = "2024"
 description = "Command line tool to use fuzzcheck-rs"
 homepage = "https://fuzzcheck.neocities.org"
 repository = "https://github.com/loiclec/fuzzcheck-rs"
@@ -20,4 +20,4 @@ version = "0.13"
 
 [[bin]]
 name = "cargo-fuzzcheck"
-path = "src/main.rs"
+path = "src/main.rs"
diff --git a/fuzzcheck/Cargo.toml b/fuzzcheck/Cargo.toml
@@ -2,7 +2,7 @@
 name = "fuzzcheck"
 version = "0.13.0"
 authors = ["Loïc Lecrenier <loic.lecrenier@me.com>"]
-edition = "2021"
+edition = "2024"
 description = "A modular, structure-aware, and feedback-driven fuzzing engine for Rust functions"
 homepage = "https://fuzzcheck.neocities.org"
 repository = "https://github.com/loiclec/fuzzcheck-rs"
diff --git a/fuzzcheck/src/bitset.rs b/fuzzcheck/src/bitset.rs
@@ -199,7 +199,7 @@ impl FixedBitSet {
     /// Iterator element is the index of the `1` bit, type `usize`.
     #[inline]
     #[coverage(off)]
-    pub fn ones(&self) -> Ones {
+    pub fn ones(&self) -> Ones<'_> {
         match self.as_slice().split_first() {
             Some((&block, rem)) => Ones {
                 bitset: block,
diff --git a/fuzzcheck/src/builder.rs b/fuzzcheck/src/builder.rs
@@ -65,22 +65,22 @@ use std::result::Result;
 use std::time::Duration;
 
 use fuzzcheck_common::arg::{
-    options_parser, Arguments, ArgumentsError, FuzzerCommand, COMMAND_FUZZ, COMMAND_MINIFY_INPUT, INPUT_FILE_FLAG,
+    Arguments, ArgumentsError, COMMAND_FUZZ, COMMAND_MINIFY_INPUT, FuzzerCommand, INPUT_FILE_FLAG, options_parser,
 };
 
+#[cfg(feature = "serde_ron_serializer")]
+use crate::SerdeRonSerializer;
+#[cfg(feature = "serde_json_serializer")]
+use crate::SerdeSerializer;
 use crate::code_coverage_sensor::CodeCoverageSensor;
 use crate::fuzzer::{Fuzzer, FuzzingResult};
 use crate::sensors_and_pools::{
     AndPool, DifferentObservations, MaximiseEachCounterPool, MaximiseObservationPool, MostNDiversePool,
     SameObservations, SimplestToActivateCounterPool, WrapperSensor,
 };
-#[cfg(feature = "serde_ron_serializer")]
-use crate::SerdeRonSerializer;
-#[cfg(feature = "serde_json_serializer")]
-use crate::SerdeSerializer;
 use crate::{
-    split_string_by_whitespace, CompatibleWithObservations, DefaultMutator, Mutator, PoolExt, Sensor, SensorExt,
-    Serializer,
+    CompatibleWithObservations, DefaultMutator, Mutator, PoolExt, Sensor, SensorExt, Serializer,
+    split_string_by_whitespace,
 };
 
 /** A function that can be fuzz-tested.
@@ -693,18 +693,9 @@ where
 }
 
 pub type BasicSensor = CodeCoverageSensor;
-pub type DiverseSensor = impl WrapperSensor<
-    Wrapped = CodeCoverageSensor,
-    Observations = (<CodeCoverageSensor as Sensor>::Observations, usize),
->;
-pub type MaxHitsSensor = impl WrapperSensor<
-    Wrapped = CodeCoverageSensor,
-    Observations = (<CodeCoverageSensor as Sensor>::Observations, u64),
->;
-pub type BasicAndMaxHitsSensor = impl WrapperSensor<
-    Wrapped = CodeCoverageSensor,
-    Observations = (<CodeCoverageSensor as Sensor>::Observations, u64),
->;
+pub type DiverseSensor = impl WrapperSensor<Wrapped = CodeCoverageSensor, Observations = (<CodeCoverageSensor as Sensor>::Observations, usize)>;
+pub type MaxHitsSensor = impl WrapperSensor<Wrapped = CodeCoverageSensor, Observations = (<CodeCoverageSensor as Sensor>::Observations, u64)>;
+pub type BasicAndMaxHitsSensor = impl WrapperSensor<Wrapped = CodeCoverageSensor, Observations = (<CodeCoverageSensor as Sensor>::Observations, u64)>;
 
 pub type BasicPool = SimplestToActivateCounterPool;
 pub type DiversePool = AndPool<MostNDiversePool, MaximiseObservationPool<u64>, DifferentObservations>;
@@ -919,9 +910,9 @@ impl SensorAndPoolBuilder<BasicSensor, BasicPool> {
 impl<T> SensorAndPoolBuilder<T, BasicAndDiversePool>
 where
     T: WrapperSensor<
-        Wrapped = CodeCoverageSensor,
-        Observations = (<CodeCoverageSensor as Sensor>::Observations, usize),
-    >,
+            Wrapped = CodeCoverageSensor,
+            Observations = (<CodeCoverageSensor as Sensor>::Observations, usize),
+        >,
 {
     /// Augment the current pool such that it also tries to find test cases repeatedly hitting the same regions of code.
     #[coverage(off)]
diff --git a/fuzzcheck/src/code_coverage_sensor/llvm_coverage.rs b/fuzzcheck/src/code_coverage_sensor/llvm_coverage.rs
@@ -9,7 +9,7 @@ use super::leb128;
 
 type CovMap = HashMap<[u8; 8], Vec<String>>;
 
-extern "C" {
+unsafe extern "C" {
     pub(crate) fn get_start_instrumentation_counters() -> *mut u64;
     pub(crate) fn get_end_instrumentation_counters() -> *mut u64;
     pub(crate) fn get_start_prf_data() -> *const u8;
@@ -20,24 +20,30 @@ extern "C" {
 
 #[coverage(off)]
 pub unsafe fn get_counters() -> &'static mut [u64] {
-    let start = get_start_instrumentation_counters();
-    let end = get_end_instrumentation_counters();
-    let len = end.offset_from(start) as usize;
-    std::slice::from_raw_parts_mut(start, len)
+    unsafe {
+        let start = get_start_instrumentation_counters();
+        let end = get_end_instrumentation_counters();
+        let len = end.offset_from(start) as usize;
+        std::slice::from_raw_parts_mut(start, len)
+    }
 }
 #[coverage(off)]
 pub unsafe fn get_prf_data() -> &'static [u8] {
-    let start = get_start_prf_data();
-    let end = get_end_prf_data();
-    let len = end.offset_from(start) as usize;
-    std::slice::from_raw_parts(start, len)
+    unsafe {
+        let start = get_start_prf_data();
+        let end = get_end_prf_data();
+        let len = end.offset_from(start) as usize;
+        std::slice::from_raw_parts(start, len)
+    }
 }
 #[coverage(off)]
 pub unsafe fn get_prf_names() -> &'static [u8] {
-    let start = get_start_prf_names();
-    let end = get_end_prf_names();
-    let len = end.offset_from(start) as usize;
-    std::slice::from_raw_parts(start, len)
+    unsafe {
+        let start = get_start_prf_names();
+        let end = get_end_prf_names();
+        let len = end.offset_from(start) as usize;
+        std::slice::from_raw_parts(start, len)
+    }
 }
 
 pub struct LLVMCovSections {
diff --git a/fuzzcheck/src/code_coverage_sensor/mod.rs b/fuzzcheck/src/code_coverage_sensor/mod.rs
@@ -9,7 +9,7 @@ use std::collections::{BTreeSet, HashMap};
 use std::convert::TryFrom;
 use std::path::{Path, PathBuf};
 
-use self::llvm_coverage::{get_counters, get_prf_data, read_covmap, Coverage, LLVMCovSections};
+use self::llvm_coverage::{Coverage, LLVMCovSections, get_counters, get_prf_data, read_covmap};
 use crate::traits::{SaveToStatsFolder, Sensor};
 
 /// A sensor that automatically records the code coverage of the program through an array of counters.
@@ -92,14 +92,16 @@ impl CodeCoverageSensor {
 
     #[coverage(off)]
     unsafe fn clear(&mut self) {
-        for &coverage_idx in &self.needs_clearing {
-            let coverage = &self.coverage[coverage_idx];
-            let slice = std::slice::from_raw_parts_mut(coverage.start_counters, coverage.counters_len);
-            for c in slice.iter_mut() {
-                *c = 0;
+        unsafe {
+            for &coverage_idx in &self.needs_clearing {
+                let coverage = &self.coverage[coverage_idx];
+                let slice = std::slice::from_raw_parts_mut(coverage.start_counters, coverage.counters_len);
+                for c in slice.iter_mut() {
+                    *c = 0;
+                }
             }
+            self.needs_clearing.clear();
         }
-        self.needs_clearing.clear();
     }
 }
 
diff --git a/fuzzcheck/src/fuzzer.rs b/fuzzcheck/src/fuzzer.rs
@@ -273,14 +273,14 @@ where
         }
     }
     #[coverage(off)]
-    unsafe fn set_up_signal_handler(&mut self) {
+    unsafe fn set_up_signal_handler(&mut self) { unsafe {
         let ptr = self as *mut Self;
         let (stack_ptr, stack_size) = set_signal_handlers(
             #[coverage(off)]
             move |sig| (*ptr).receive_signal(sig),
         );
         self.signal_handler_alt_stack = Some((stack_ptr, stack_size));
-    }
+    }}
 }
 
 pub struct Fuzzer<T, M>
diff --git a/fuzzcheck/src/lib.rs b/fuzzcheck/src/lib.rs
@@ -28,9 +28,6 @@
 #![feature(stmt_expr_attributes)]
 // very very nice to use, but I guess not essential?
 #![feature(type_alias_impl_trait, impl_trait_in_assoc_type)]
-// should be stabilised very soon
-#![feature(let_chains)]
-//
 // end nightly features
 //
 #![allow(clippy::nonstandard_macro_braces)]
@@ -220,11 +217,11 @@ pub use fuzzer::FuzzingResult;
 pub use fuzzer::PoolStorageIndex;
 #[doc(inline)]
 pub use fuzzer::ReasonForStopping;
+pub(crate) use mutators::CROSSOVER_RATE;
 #[doc(inline)]
 pub use mutators::DefaultMutator;
 #[doc(inline)]
 pub use mutators::MutatorExt;
-pub(crate) use mutators::CROSSOVER_RATE;
 #[doc(inline)]
 pub use sensors_and_pools::PoolExt;
 #[doc(inline)]
diff --git a/fuzzcheck/src/sensors_and_pools/allocations_sensor.rs b/fuzzcheck/src/sensors_and_pools/allocations_sensor.rs
@@ -188,18 +188,18 @@ where
     A: GlobalAlloc,
 {
     #[coverage(off)]
-    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+    unsafe fn alloc(&self, layout: Layout) -> *mut u8 { unsafe {
         let ptr = self.0.alloc(layout);
         if ptr.is_null() {
             return ptr;
         }
         let size = layout.size();
-        ALLOC_STATS.alloc(size);
+        (*&raw mut ALLOC_STATS).alloc(size);
         ptr
-    }
+    }}
 
     #[coverage(off)]
-    unsafe fn realloc(&self, old_ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
+    unsafe fn realloc(&self, old_ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 { unsafe {
         let new_ptr = self.0.realloc(old_ptr, layout, new_size);
         if new_ptr.is_null() {
             return new_ptr;
@@ -210,15 +210,15 @@ where
         } else {
             (false, new_size - old_size)
         };
-        ALLOC_STATS.realloc(new_size, shrink, delta);
+        (*&raw mut ALLOC_STATS).realloc(new_size, shrink, delta);
         new_ptr
-    }
+    }}
     #[coverage(off)]
     unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
-        self.0.dealloc(ptr, layout);
+        unsafe { self.0.dealloc(ptr, layout) };
 
         let size = layout.size();
-        ALLOC_STATS.dealloc(size);
+        unsafe { (&raw mut ALLOC_STATS).as_mut() }.unwrap().dealloc(size);
     }
 }
 
@@ -238,8 +238,8 @@ struct AllocationsStats {
 fn get_allocation_stats() -> AllocationsStats {
     unsafe {
         AllocationsStats {
-            total_blocks: ALLOC_STATS.total_blocks.load(Ordering::SeqCst),
-            total_bytes: ALLOC_STATS.total_bytes.load(Ordering::SeqCst),
+            total_blocks: (*&raw mut ALLOC_STATS).total_blocks.load(Ordering::SeqCst),
+            total_bytes: (*&raw mut ALLOC_STATS).total_bytes.load(Ordering::SeqCst),
             // curr_blocks: ALLOC_STATS.curr_blocks.load(Ordering::SeqCst),
             // curr_bytes: ALLOC_STATS.curr_bytes.load(Ordering::SeqCst),
         }
diff --git a/fuzzcheck/src/sensors_and_pools/mod.rs b/fuzzcheck/src/sensors_and_pools/mod.rs
@@ -35,13 +35,13 @@ pub use noop_sensor::NoopSensor;
 pub use simplest_to_activate_counter_pool::SimplestToActivateCounterPool;
 #[doc(inline)]
 pub use static_value_sensor::StaticValueSensor;
+pub(crate) use test_failure_pool::TEST_FAILURE;
 #[doc(inline)]
 pub use test_failure_pool::TestFailure;
 #[doc(inline)]
 pub use test_failure_pool::TestFailurePool;
 #[doc(inline)]
 pub use test_failure_pool::TestFailureSensor;
-pub(crate) use test_failure_pool::TEST_FAILURE;
 #[doc(inline)]
 pub use unique_values_pool::UniqueValuesPool;
 #[doc(inline)]
@@ -86,7 +86,7 @@ pub trait SensorExt: Sensor {
     /// # use fuzzcheck::sensors_and_pools::StaticValueSensor;
     /// # static mut COUNTERS: [u64; 2] = [0; 2];
     /// # // inside the fuzz test, you can create the sensor as follows
-    /// # let sensor = unsafe { StaticValueSensor::new(&mut COUNTERS, [0, 0]) };
+    /// # let sensor = unsafe { StaticValueSensor::new(&mut *&raw mut COUNTERS, [0, 0]) };
     /// let sensor = sensor.map(|observations| {
     ///    let sum = observations.iter().sum::<u64>();
     ///    (observations, sum)
diff --git a/fuzzcheck/src/sensors_and_pools/static_value_sensor.rs b/fuzzcheck/src/sensors_and_pools/static_value_sensor.rs
@@ -34,7 +34,7 @@ use crate::{SaveToStatsFolder, Sensor};
 /// // After each run of the test function, the sensor resets `COUNT`
 /// // to the second argument (here: 0). It is best if you don't access
 /// // `COUNT` outside of the test function.
-/// let sensor = unsafe { StaticValueSensor::new(&mut COUNT, 0) };
+/// let sensor = unsafe { StaticValueSensor::new(&mut *&raw mut COUNT, 0) };
 ///
 /// // The sensor can be paired with any pool which is compatible with
 /// // observations of type `usize`. For example, we can use:
diff --git a/fuzzcheck/src/sensors_and_pools/test_failure_pool.rs b/fuzzcheck/src/sensors_and_pools/test_failure_pool.rs
@@ -39,7 +39,7 @@ impl Sensor for TestFailureSensor {
     #[coverage(off)]
     fn stop_recording(&mut self) {
         unsafe {
-            self.error = TEST_FAILURE.clone();
+            self.error = (*(&raw mut TEST_FAILURE)).clone();
         }
     }
 
diff --git a/fuzzcheck/src/signals_handler.rs b/fuzzcheck/src/signals_handler.rs
@@ -4,8 +4,8 @@
 use std::ptr;
 
 use libc::{
-    sigaction, sigemptyset, SA_NODEFER, SA_ONSTACK, SA_SIGINFO, SIGABRT, SIGALRM, SIGBUS, SIGFPE, SIGINT, SIGSEGV,
-    SIGTERM, SIGTRAP, SIG_DFL,
+    SA_NODEFER, SA_ONSTACK, SA_SIGINFO, SIG_DFL, SIGABRT, SIGALRM, SIGBUS, SIGFPE, SIGINT, SIGSEGV, SIGTERM, SIGTRAP,
+    sigaction, sigemptyset,
 };
 
 static mut SIGNAL_HANDLER: Option<Box<dyn Fn(libc::c_int) -> !>> = None;
@@ -15,7 +15,8 @@ extern "C" fn os_handler(signal: libc::c_int, _: *mut libc::siginfo_t, _: *mut l
     // Assuming this always succeeds. Can't really handle errors in any meaningful way.
     unsafe {
         reset_signal_handlers();
-        if let Some(h) = SIGNAL_HANDLER.as_mut() {
+        let ptr = (&raw mut SIGNAL_HANDLER);
+        if let Some(h) = &*ptr {
             (*h)(signal);
         } else {
             std::process::exit(1);
@@ -29,7 +30,7 @@ extern "C" fn os_handler(signal: libc::c_int, _: *mut libc::siginfo_t, _: *mut l
 pub unsafe fn set_signal_handlers<F: 'static>(f: F) -> (*mut u8, std::alloc::Layout)
 where
     F: Fn(libc::c_int) -> !,
-{
+{ unsafe {
     SIGNAL_HANDLER = Some(Box::new(f));
 
     // Make sure the alternative stack is big enough. ~65_000 bytes should be okay.
@@ -64,18 +65,20 @@ where
     }
 
     (stack_pointer, stack_layout)
-}
+}}
 
 #[coverage(off)]
 pub(crate) unsafe fn reset_signal_handlers() {
-    let mut sa: sigaction = std::mem::zeroed();
-    sigemptyset(&mut sa.sa_mask as *mut libc::sigset_t);
+    let mut sa: sigaction = unsafe { std::mem::zeroed() };
+    unsafe {
+        sigemptyset(&mut sa.sa_mask as *mut libc::sigset_t);
+    }
     sa.sa_sigaction = SIG_DFL;
 
     for &signal in &[
         SIGALRM, SIGINT, SIGTERM, SIGSEGV, SIGBUS, SIGABRT, SIGFPE, SIGABRT, SIGTRAP,
     ] {
-        if sigaction(signal, &mut sa as *mut sigaction, ptr::null_mut()) < 0 {
+        if unsafe { sigaction(signal, &mut sa as *mut sigaction, ptr::null_mut()) < 0 } {
             panic!("Could not set up signal handler");
         }
     }
diff --git a/fuzzcheck_common/Cargo.toml b/fuzzcheck_common/Cargo.toml
@@ -2,7 +2,7 @@
 name = "fuzzcheck_common"
 version = "0.13.0"
 authors = ["Loïc Lecrenier <loic.lecrenier@me.com>"]
-edition = "2021"
+edition = "2024"
 description = "Common components for both cargo-fuzzcheck and fuzzcheck"
 homepage = "https://fuzzcheck.neocities.org"
 license = "MIT"
@@ -14,4 +14,4 @@ categories = ["development-tools::testing"]
 getopts = "0.2.21"
 
 [lib]
-name = "fuzzcheck_common"
+name = "fuzzcheck_common"
diff --git a/fuzzcheck_mutators_derive/Cargo.toml b/fuzzcheck_mutators_derive/Cargo.toml
@@ -2,7 +2,7 @@
 name = "fuzzcheck_mutators_derive"
 version = "0.13.0"
 authors = ["Loïc Lecrenier <loic.lecrenier@me.com>"]
-edition = "2021"
+edition = "2024"
 description = "Procedural macros to generate fuzzcheck mutators"
 homepage = "https://fuzzcheck.neocities.org"
 repository = "https://github.com/loiclec/fuzzcheck-rs"
diff --git a/fuzzcheck_mutators_derive/src/lib.rs b/fuzzcheck_mutators_derive/src/lib.rs
diff --git a/rust-toolchain b/rust-toolchain
diff --git a/usage_tests/basic_crate/Cargo.toml b/usage_tests/basic_crate/Cargo.toml

Original file line number	Diff line number	Diff line change
`@@ -273,14 +273,14 @@ where`
`273`	`273`	`}`
`274`	`274`	`}`
`275`	`275`	`#[coverage(off)]`
`276`		`- unsafe fn set_up_signal_handler(&mut self) {`
	`276`	`+ unsafe fn set_up_signal_handler(&mut self) { unsafe {`
`277`	`277`	`let ptr = self as *mut Self;`
`278`	`278`	`let (stack_ptr, stack_size) = set_signal_handlers(`
`279`	`279`	`#[coverage(off)]`
`280`	`280`	`move \|sig\| (*ptr).receive_signal(sig),`
`281`	`281`	`);`
`282`	`282`	`self.signal_handler_alt_stack = Some((stack_ptr, stack_size));`
`283`		`- }`
	`283`	`+ }}`
`284`	`284`	`}`
`285`	`285`
`286`	`286`	`pub struct Fuzzer<T, M>`