Move from intervalltree to meminterval dep (#1456)

* Move from intervalltree to meminterval dep

* fixes

libafl/Cargo.toml

@@ -144,7 +144,7 @@ postcard = { version = "1.0", features = ["alloc"], default-features = false } #
 bincode = {version = "1.3", optional = true }
 c2rust-bitfields = { version = "0.17", features = ["no_std"] }
 ahash = { version = "0.8", default-features=false } # The hash function already used in hashbrown
-intervaltree = { version = "0.2.7", default-features = false, features = ["serde"] }
+meminterval = { version = "0.4", features = ["serde"] }
 backtrace = {version = "0.3", optional = true} # Used to get the stacktrace in StacktraceObserver
 typed-builder = { version = "0.15.2", optional = true } # Implement the builder pattern at compiletime
 

libafl/src/observers/map.rs

@@ -13,11 +13,11 @@ use core::{
 };
 
 use ahash::RandomState;
-use intervaltree::IntervalTree;
 use libafl_bolts::{
     ownedref::{OwnedMutPtr, OwnedMutSlice},
     AsIter, AsIterMut, AsMutSlice, AsSlice, HasLen, Named, Truncate,
 };
+use meminterval::IntervalTree;
 use num_traits::Bounded;
 use serde::{Deserialize, Serialize};
 
@@ -1739,17 +1739,17 @@ where
 
     #[inline]
     fn get(&self, idx: usize) -> &T {
-        let elem = self.intervals.query_point(idx).next().unwrap();
+        let elem = self.intervals.query(idx..=idx).next().unwrap();
-        let i = elem.value;
+        let i = *elem.value;
-        let j = idx - elem.range.start;
+        let j = idx - elem.interval.start;
         &self.maps[i].as_slice()[j]
     }
 
     #[inline]
     fn get_mut(&mut self, idx: usize) -> &mut T {
-        let elem = self.intervals.query_point(idx).next().unwrap();
+        let elem = self.intervals.query(idx..=idx).next().unwrap();
-        let i = elem.value;
+        let i = *elem.value;
-        let j = idx - elem.range.start;
+        let j = idx - elem.interval.start;
         &mut self.maps[i].as_mut_slice()[j]
     }
 
@@ -1829,16 +1829,15 @@ where
     #[must_use]
     fn maybe_differential(name: &'static str, maps: Vec<OwnedMutSlice<'a, T>>) -> Self {
         let mut idx = 0;
-        let mut builder = vec![];
+        let mut intervals = IntervalTree::new();
         for (v, x) in maps.iter().enumerate() {
             let l = x.as_slice().len();
-            let r = (idx..(idx + l), v);
+            intervals.insert(idx..(idx + l), v);
             idx += l;
-            builder.push(r);
         }
         Self {
             maps,
-            intervals: builder.into_iter().collect::<IntervalTree<usize, usize>>(),
+            intervals,
             len: idx,
             name: name.to_string(),
             initial: T::default(),
@@ -1873,21 +1872,20 @@ where
     pub fn owned(name: &'static str, maps: Vec<Vec<T>>) -> Self {
         let mut idx = 0;
         let mut v = 0;
-        let mut builder = vec![];
+        let mut intervals = IntervalTree::new();
         let maps: Vec<_> = maps
             .into_iter()
             .map(|x| {
                 let l = x.len();
-                let r = (idx..(idx + l), v);
+                intervals.insert(idx..(idx + l), v);
                 idx += l;
-                builder.push(r);
                 v += 1;
                 OwnedMutSlice::from(x)
             })
             .collect();
         Self {
             maps,
-            intervals: builder.into_iter().collect::<IntervalTree<usize, usize>>(),
+            intervals,
             len: idx,
             name: name.to_string(),
             initial: T::default(),

libafl_qemu/Cargo.toml

@@ -56,7 +56,7 @@ libc = "0.2"
 strum = "0.25"
 strum_macros = "0.25"
 syscall-numbers = "3.0"
-meminterval = "0.3"
+meminterval = "0.4"
 thread_local = "1.1.4"
 capstone = "0.11.0"
 pyo3 = { version = "0.18.3", optional = true }

libafl_targets/Cargo.toml

@@ -32,7 +32,7 @@ sancov_cmplog = []
 sancov_pcguard = ["sancov_pcguard_hitcounts"]
 sanitizer_interfaces = []
 clippy = [] # Ignore compiler warnings during clippy
-observers = ["intervaltree", "ahash"]
+observers = ["meminterval", "ahash"]
 
 [build-dependencies]
 bindgen = "0.64.0"
@@ -46,6 +46,6 @@ log = "0.4.20"
 
 rangemap = "1.3"
 serde = { version = "1.0", default-features = false, features = ["alloc"] } # serialization lib
-intervaltree = { version = "0.2.7", default-features = false, features = ["serde"], optional = true }
+meminterval = {version = "0.4", features = ["serde"], optional = true }
 ahash = { version = "0.8.3", default-features = false, optional = true }
 # serde-big-array = "0.3.2"

libafl_targets/src/sancov_8bit.rs

@@ -70,7 +70,6 @@ mod observers {
     };
 
     use ahash::RandomState;
-    use intervaltree::IntervalTree;
     use libafl::{
         inputs::UsesInput,
         observers::{DifferentialObserver, MapObserver, Observer, ObserversTuple},
@@ -79,6 +78,7 @@ mod observers {
     use libafl_bolts::{
         ownedref::OwnedMutSlice, AsIter, AsIterMut, AsMutSlice, AsSlice, HasLen, Named,
     };
+    use meminterval::IntervalTree;
     use serde::{Deserialize, Serialize};
 
     use super::COUNTERS_MAPS;
@@ -162,18 +162,18 @@ mod observers {
 
         #[inline]
         fn get(&self, idx: usize) -> &u8 {
-            let elem = self.intervals.query_point(idx).next().unwrap();
+            let elem = self.intervals.query(idx..=idx).next().unwrap();
             let i = elem.value;
-            let j = idx - elem.range.start;
+            let j = idx - elem.interval.start;
-            unsafe { &COUNTERS_MAPS[i].as_slice()[j] }
+            unsafe { &COUNTERS_MAPS[*i].as_slice()[j] }
         }
 
         #[inline]
         fn get_mut(&mut self, idx: usize) -> &mut u8 {
-            let elem = self.intervals.query_point(idx).next().unwrap();
+            let elem = self.intervals.query_mut(idx..=idx).next().unwrap();
             let i = elem.value;
-            let j = idx - elem.range.start;
+            let j = idx - elem.interval.start;
-            unsafe { &mut COUNTERS_MAPS[i].as_mut_slice()[j] }
+            unsafe { &mut COUNTERS_MAPS[*i].as_mut_slice()[j] }
         }
 
         #[inline]
@@ -249,15 +249,14 @@ mod observers {
         #[must_use]
         fn maybe_differential(name: &'static str) -> Self {
             let mut idx = 0;
-            let mut builder = vec![];
+            let mut intervals = IntervalTree::new();
             for (v, x) in unsafe { &COUNTERS_MAPS }.iter().enumerate() {
                 let l = x.as_slice().len();
-                let r = (idx..(idx + l), v);
+                intervals.insert(idx..(idx + l), v);
                 idx += l;
-                builder.push(r);
             }
             Self {
-                intervals: builder.into_iter().collect::<IntervalTree<usize, usize>>(),
+                intervals,
                 len: idx,
                 name: name.to_string(),
                 initial: u8::default(),
@@ -286,16 +285,15 @@ mod observers {
         pub fn owned(name: &'static str) -> Self {
             let mut idx = 0;
             let mut v = 0;
-            let mut builder = vec![];
+            let mut intervals = IntervalTree::new();
             unsafe { &mut COUNTERS_MAPS }.iter_mut().for_each(|m| {
                 let l = m.as_mut_slice().len();
-                let r = (idx..(idx + l), v);
+                intervals.insert(idx..(idx + l), v);
                 idx += l;
-                builder.push(r);
                 v += 1;
             });
             Self {
-                intervals: builder.into_iter().collect::<IntervalTree<usize, usize>>(),
+                intervals,
                 len: idx,
                 name: name.to_string(),
                 initial: u8::default(),