Clean up TODOs in baby_fuzzers

fuzzers/baby/baby_fuzzer/src/main.rs

@@ -15,18 +15,19 @@ use libafl::{
     generators::RandPrintablesGenerator,
     inputs::{BytesInput, HasTargetBytes},
     mutators::{havoc_mutations::havoc_mutations, scheduled::HavocScheduledMutator},
-    observers::StdMapObserver,
+    observers::ConstMapObserver,
     schedulers::QueueScheduler,
     stages::mutational::StdMutationalStage,
     state::StdState,
 };
-use libafl_bolts::{current_nanos, nonzero, rands::StdRand, tuples::tuple_list, AsSlice};
+use libafl_bolts::{
+    current_nanos, nonnull_raw_mut, nonzero, rands::StdRand, tuples::tuple_list, AsSlice,
+};
 
 /// Coverage map with explicit assignments due to the lack of instrumentation
-static mut SIGNALS: [u8; 16] = [0; 16];
-// TODO: This will break soon, fix me! See https://github.com/AFLplusplus/LibAFL/issues/2786
-#[allow(static_mut_refs)] // only a problem in nightly
-static mut SIGNALS_PTR: *mut u8 = unsafe { SIGNALS.as_mut_ptr() };
+const SIGNALS_LEN: usize = 16;
+static mut SIGNALS: [u8; SIGNALS_LEN] = [0; SIGNALS_LEN];
+static mut SIGNALS_PTR: *mut u8 = &raw mut SIGNALS as _;
 
 /// Assign a signal to the signals map
 fn signals_set(idx: usize) {
@@ -64,9 +65,7 @@ pub fn main() {
     };
 
     // Create an observation channel using the signals map
-    // TODO: This will break soon, fix me! See https://github.com/AFLplusplus/LibAFL/issues/2786
-    #[allow(static_mut_refs)] // only a problem in nightly
-    let observer = unsafe { StdMapObserver::from_mut_ptr("signals", SIGNALS_PTR, SIGNALS.len()) };
+    let observer = unsafe { ConstMapObserver::from_mut_ptr("signals", nonnull_raw_mut!(SIGNALS)) };
 
     // Feedback to rate the interestingness of an input
     let mut feedback = MaxMapFeedback::new(&observer);

fuzzers/baby/baby_fuzzer_custom_executor/src/main.rs

@@ -16,18 +16,18 @@ use libafl::{
     generators::RandPrintablesGenerator,
     inputs::HasTargetBytes,
     mutators::{havoc_mutations::havoc_mutations, scheduled::HavocScheduledMutator},
-    observers::StdMapObserver,
+    observers::ConstMapObserver,
     schedulers::QueueScheduler,
     stages::{mutational::StdMutationalStage, AflStatsStage, CalibrationStage},
     state::{HasCorpus, HasExecutions, StdState},
 };
-use libafl_bolts::{current_nanos, nonzero, rands::StdRand, tuples::tuple_list, AsSlice};
+use libafl_bolts::{
+    current_nanos, nonnull_raw_mut, nonzero, rands::StdRand, tuples::tuple_list, AsSlice,
+};
 /// Coverage map with explicit assignments due to the lack of instrumentation
-static mut SIGNALS: [u8; 16] = [0; 16];
+const SIGNALS_LEN: usize = 16;
+static mut SIGNALS: [u8; SIGNALS_LEN] = [0; SIGNALS_LEN];
 static mut SIGNALS_PTR: *mut u8 = &raw mut SIGNALS as _;
-// TODO: This will break soon, fix me! See https://github.com/AFLplusplus/LibAFL/issues/2786
-#[allow(static_mut_refs)] // only a problem in nightly
-static SIGNALS_LEN: usize = unsafe { SIGNALS.len() };
 
 /// Assign a signal to the signals map
 fn signals_set(idx: usize) {
@@ -79,7 +79,7 @@ where
 
 pub fn main() {
     // Create an observation channel using the signals map
-    let observer = unsafe { StdMapObserver::from_mut_ptr("signals", SIGNALS_PTR, SIGNALS_LEN) };
+    let observer = unsafe { ConstMapObserver::from_mut_ptr("signals", nonnull_raw_mut!(SIGNALS)) };
 
     // Feedback to rate the interestingness of an input
     let mut feedback = MaxMapFeedback::new(&observer);

fuzzers/baby/baby_fuzzer_minimizing/src/main.rs

@@ -6,10 +6,9 @@ use libafl::prelude::*;
 use libafl_bolts::prelude::*;
 
 /// Coverage map with explicit assignments due to the lack of instrumentation
-static mut SIGNALS: [u8; 16] = [0; 16];
-// TODO: This will break soon, fix me! See https://github.com/AFLplusplus/LibAFL/issues/2786
-#[allow(static_mut_refs)] // only a problem in nightly
-static mut SIGNALS_PTR: *mut u8 = unsafe { SIGNALS.as_mut_ptr() };
+const SIGNALS_LEN: usize = 16;
+static mut SIGNALS: [u8; SIGNALS_LEN] = [0; SIGNALS_LEN];
+static mut SIGNALS_PTR: *mut u8 = &raw mut SIGNALS as _;
 
 /// Assign a signal to the signals map
 fn signals_set(idx: usize) {
@@ -35,9 +34,7 @@ pub fn main() -> Result<(), Error> {
     };
 
     // Create an observation channel using the signals map
-    // TODO: This will break soon, fix me! See https://github.com/AFLplusplus/LibAFL/issues/2786
-    #[allow(static_mut_refs)] // only a problem in nightly
-    let observer = unsafe { StdMapObserver::from_mut_ptr("signals", SIGNALS_PTR, SIGNALS.len()) };
+    let observer = unsafe { ConstMapObserver::from_mut_ptr("signals", nonnull_raw_mut!(SIGNALS)) };
 
     let factory = ObserverEqualityFactory::new(&observer);
 

fuzzers/baby/baby_fuzzer_swap_differential/src/main.rs

@@ -108,6 +108,7 @@ pub fn main() {
         };
 
         // create the base maps used to observe the different executors from two independent maps
+        // TODO: Replace with ConstMapObserver
         let mut first_map_observer =
             unsafe { StdMapObserver::from_mut_ptr("first-edges", first_edges.0, first_edges.1) };
         let mut second_map_observer =
@@ -143,11 +144,10 @@ pub fn main() {
             EDGES = core::slice::from_raw_parts_mut(alloc_zeroed(layout), num_edges * 2);
         }
 
-        // TODO: This will break soon, fix me! See https://github.com/AFLplusplus/LibAFL/issues/2786
-        #[allow(static_mut_refs)] // only a problem on nightly
-        let edges_ptr = unsafe { EDGES.as_mut_ptr() };
+        let edges_ptr: *mut u8 = &raw mut EDGES as _;
 
         // create the base maps used to observe the different executors by splitting a slice
+        // TODO: Replace with ConstMapObserver
         let mut first_map_observer =
             unsafe { StdMapObserver::from_mut_ptr("first-edges", edges_ptr, num_edges) };
         let mut second_map_observer = unsafe {

fuzzers/baby/baby_fuzzer_unicode/src/main.rs

@@ -17,20 +17,18 @@ use libafl::{
         HavocScheduledMutator, UnicodeCategoryRandMutator, UnicodeInput,
         UnicodeSubcategoryRandMutator,
     },
-    observers::StdMapObserver,
+    observers::ConstMapObserver,
     schedulers::QueueScheduler,
     stages::{mutational::StdMutationalStage, UnicodeIdentificationStage},
     state::StdState,
     Evaluator,
 };
-use libafl_bolts::{rands::StdRand, tuples::tuple_list, AsSlice};
+use libafl_bolts::{nonnull_raw_mut, rands::StdRand, tuples::tuple_list, AsSlice};
 
 /// Coverage map with explicit assignments due to the lack of instrumentation
-static mut SIGNALS: [u8; 64] = [0; 64];
-static mut SIGNALS_PTR: *mut u8 = (&raw mut SIGNALS).cast();
-// TODO: This will break soon, fix me! See https://github.com/AFLplusplus/LibAFL/issues/2786
-#[allow(static_mut_refs)] // only a problem in nightly
-static mut SIGNALS_LEN: usize = unsafe { SIGNALS.len() };
+const SIGNALS_LEN: usize = 64;
+static mut SIGNALS: [u8; SIGNALS_LEN] = [0; SIGNALS_LEN];
+static mut SIGNALS_PTR: *mut u8 = &raw mut SIGNALS as _;
 
 /// Assign a signal to the signals map
 fn signals_set(idx: usize) {
@@ -62,7 +60,7 @@ pub fn main() {
     };
 
     // Create an observation channel using the signals map
-    let observer = unsafe { StdMapObserver::from_mut_ptr("signals", SIGNALS_PTR, SIGNALS_LEN) };
+    let observer = unsafe { ConstMapObserver::from_mut_ptr("signals", nonnull_raw_mut!(SIGNALS)) };
 
     // Feedback to rate the interestingness of an input
     let mut feedback = MaxMapFeedback::new(&observer);

fuzzers/baby/backtrace_baby_fuzzers/rust_code_with_inprocess_executor/.cargo/config.toml

@@ -0,0 +1,2 @@
+[build]
+rustflags = ["-Cforce-unwind-tables=y"]

fuzzers/baby/backtrace_baby_fuzzers/rust_code_with_inprocess_executor/src/main.rs

@@ -13,18 +13,17 @@ use libafl::{
     inputs::{BytesInput, HasTargetBytes},
     monitors::SimpleMonitor,
     mutators::{havoc_mutations::havoc_mutations, scheduled::HavocScheduledMutator},
-    observers::{BacktraceObserver, StdMapObserver},
+    observers::{BacktraceObserver, ConstMapObserver},
     schedulers::QueueScheduler,
     stages::mutational::StdMutationalStage,
     state::StdState,
 };
-use libafl_bolts::{nonzero, rands::StdRand, tuples::tuple_list, AsSlice};
+use libafl_bolts::{nonnull_raw_mut, nonzero, rands::StdRand, tuples::tuple_list, AsSlice};
 
 /// Coverage map with explicit assignments due to the lack of instrumentation
-static mut SIGNALS: [u8; 16] = [0; 16];
-// TODO: This will break soon, fix me! See https://github.com/AFLplusplus/LibAFL/issues/2786
-#[allow(static_mut_refs)] // only a problem in nightly
-static mut SIGNALS_PTR: *mut u8 = unsafe { SIGNALS.as_mut_ptr() };
+const SIGNALS_LEN: usize = 16;
+static mut SIGNALS: [u8; SIGNALS_LEN] = [0; SIGNALS_LEN];
+static mut SIGNALS_PTR: *mut u8 = &raw mut SIGNALS as _;
 
 /// Assign a signal to the signals map
 fn signals_set(idx: usize) {
@@ -60,9 +59,7 @@ pub fn main() {
     };
 
     // Create an observation channel using the signals map
-    // TODO: This will break soon, fix me! See https://github.com/AFLplusplus/LibAFL/issues/2786
-    #[allow(static_mut_refs)] // only a problem in nightly
-    let observer = unsafe { StdMapObserver::from_mut_ptr("signals", SIGNALS_PTR, SIGNALS.len()) };
+    let observer = unsafe { ConstMapObserver::from_mut_ptr("signals", nonnull_raw_mut!(SIGNALS)) };
     // Create a stacktrace observer to add the observers tuple
     let bt_observer = BacktraceObserver::owned(
         "BacktraceObserver",