Corpus refactoring

crates/libafl/Cargo.toml

@@ -230,7 +230,7 @@ hashbrown = { workspace = true, features = [
   "ahash",
 ], default-features = false } # A faster hashmap, nostd compatible
 num-traits = { workspace = true, default-features = false }
-serde = { workspace = true, features = ["alloc"] } # serialization lib
+serde = { workspace = true, features = ["alloc", "rc"] } # serialization lib
 postcard = { workspace = true } # no_std compatible serde serialization format
 bincode = { version = "2.0.1", optional = true, features = ["serde"] }
 bitbybit = { workspace = true }

crates/libafl/src/common/mod.rs

@@ -3,17 +3,42 @@
 use alloc::boxed::Box;
 use core::any::type_name;
 
-#[cfg(feature = "nautilus")]
-pub mod nautilus;
-
 use libafl_bolts::{
     Error,
     serdeany::{NamedSerdeAnyMap, SerdeAny, SerdeAnyMap},
 };
+
+#[cfg(feature = "nautilus")]
+pub mod nautilus;
+
 /// Trait for elements offering metadata
 pub trait HasMetadata {
     /// A map, storing all metadata
     fn metadata_map(&self) -> &SerdeAnyMap;
+
+    /// Check for a metadata
+    ///
+    /// # Note
+    /// For performance reasons, you likely want to use [`Self::metadata_or_insert_with`] instead
+    #[inline]
+    fn has_metadata<M>(&self) -> bool
+    where
+        M: SerdeAny,
+    {
+        self.metadata_map().get::<M>().is_some()
+    }
+
+    /// To get metadata
+    #[inline]
+    fn metadata<M>(&self) -> Result<&M, Error>
+    where
+        M: SerdeAny,
+    {
+        self.metadata_map()
+            .get::<M>()
+            .ok_or_else(|| Error::key_not_found(format!("{} not found", type_name::<M>())))
+    }
+
     /// A map, storing all metadata (mutable)
     fn metadata_map_mut(&mut self) -> &mut SerdeAnyMap;
 
@@ -53,45 +78,46 @@ pub trait HasMetadata {
         self.metadata_map_mut().remove::<M>()
     }
 
-    /// Check for a metadata
-    ///
-    /// # Note
-    /// For performance reasons, you likely want to use [`Self::metadata_or_insert_with`] instead
+    /// To get mutable metadata
     #[inline]
-    fn has_metadata<M>(&self) -> bool
+    fn metadata_mut<M>(&mut self) -> Result<&mut M, Error>
     where
         M: SerdeAny,
     {
-        self.metadata_map().get::<M>().is_some()
+        self.metadata_map_mut()
+            .get_mut::<M>()
+            .ok_or_else(|| Error::key_not_found(format!("{} not found", type_name::<M>())))
     }
+}
 
-    /// To get metadata
+/// Trait for elements offering named metadata
+pub trait HasNamedMetadata {
+    /// A map, storing all metadata
+    fn named_metadata_map(&self) -> &NamedSerdeAnyMap;
+
+    /// Check for a metadata
+    ///
+    /// # Note
+    /// You likely want to use [`Self::named_metadata_or_insert_with`] for performance reasons.
     #[inline]
-    fn metadata<M>(&self) -> Result<&M, Error>
+    fn has_named_metadata<M>(&self, name: &str) -> bool
     where
         M: SerdeAny,
     {
-        self.metadata_map()
-            .get::<M>()
-            .ok_or_else(|| Error::key_not_found(format!("{} not found", type_name::<M>())))
+        self.named_metadata_map().contains::<M>(name)
     }
 
-    /// To get mutable metadata
+    /// To get named metadata
     #[inline]
-    fn metadata_mut<M>(&mut self) -> Result<&mut M, Error>
+    fn named_metadata<M>(&self, name: &str) -> Result<&M, Error>
     where
         M: SerdeAny,
     {
-        self.metadata_map_mut()
-            .get_mut::<M>()
+        self.named_metadata_map()
+            .get::<M>(name)
             .ok_or_else(|| Error::key_not_found(format!("{} not found", type_name::<M>())))
     }
-}
 
-/// Trait for elements offering named metadata
-pub trait HasNamedMetadata {
-    /// A map, storing all metadata
-    fn named_metadata_map(&self) -> &NamedSerdeAnyMap;
     /// A map, storing all metadata (mutable)
     fn named_metadata_map_mut(&mut self) -> &mut NamedSerdeAnyMap;
 
@@ -136,29 +162,6 @@ pub trait HasNamedMetadata {
             .get_or_insert_with::<M>(name, default)
     }
 
-    /// Check for a metadata
-    ///
-    /// # Note
-    /// You likely want to use [`Self::named_metadata_or_insert_with`] for performance reasons.
-    #[inline]
-    fn has_named_metadata<M>(&self, name: &str) -> bool
-    where
-        M: SerdeAny,
-    {
-        self.named_metadata_map().contains::<M>(name)
-    }
-
-    /// To get named metadata
-    #[inline]
-    fn named_metadata<M>(&self, name: &str) -> Result<&M, Error>
-    where
-        M: SerdeAny,
-    {
-        self.named_metadata_map()
-            .get::<M>(name)
-            .ok_or_else(|| Error::key_not_found(format!("{} not found", type_name::<M>())))
-    }
-
     /// To get mutable named metadata
     #[inline]
     fn named_metadata_mut<M>(&mut self, name: &str) -> Result<&mut M, Error>

crates/libafl/src/common/nautilus/grammartec/chunkstore.rs

@@ -49,7 +49,7 @@ impl ChunkStore {
         }
     }
 
-    pub fn add_tree(&mut self, tree: Tree, ctx: &Context) {
+    pub fn add_tree(&mut self, tree: &Tree, ctx: &Context) {
         let mut buffer = vec![];
         let id = self.trees.len();
         let mut contains_new_chunk = false;
@@ -76,8 +76,9 @@ impl ChunkStore {
                 contains_new_chunk = true;
             }
         }
+
         if contains_new_chunk {
-            self.trees.push(tree);
+            self.trees.push(tree.clone());
         }
     }
 
@@ -129,7 +130,7 @@ mod tests {
         let tree = ctx.generate_tree_from_rule(&mut rand, r1, random_size);
         fs::create_dir_all("/tmp/outputs/chunks").expect("40234068");
         let mut cks = ChunkStore::new("/tmp/".to_string());
-        cks.add_tree(tree, &ctx);
+        cks.add_tree(&tree, &ctx);
         // assert!(cks.seen_outputs.contains("a b c".as_bytes()));
         // assert!(cks.seen_outputs.contains("b c".as_bytes()));
         // assert!(cks.seen_outputs.contains("c".as_bytes()));
@@ -139,7 +140,7 @@ mod tests {
 
         let random_size = ctx.get_random_len_for_ruleid(&r2);
         let tree = ctx.generate_tree_from_rule(&mut rand, r2, random_size);
-        cks.add_tree(tree, &ctx);
+        cks.add_tree(&tree, &ctx);
         // assert_eq!(cks.seen_outputs.len(), 3);
         // assert_eq!(cks.nts_to_chunks[&ctx.nt_id("B")].len(), 1);
         let (tree_id, node_id) = cks.nts_to_chunks[&ctx.nt_id("B")][0];

crates/libafl/src/common/nautilus/grammartec/mutator.rs

@@ -538,7 +538,7 @@ mod tests {
         let _ = ctx.add_rule("A", b"a");
         ctx.initialize(101);
         let tree = ctx.generate_tree_from_rule(&mut rand, r3, 100);
-        cks.add_tree(tree, &ctx);
+        cks.add_tree(&tree, &ctx);
         for _ in 0..100 {
             let tree = ctx.generate_tree_from_rule(&mut rand, r1, 100);
             let mut mutator = Mutator::new(&ctx);