Add read::EntriesRaw::read_attributes

Author: philipc

benches/bench.rs

@@ -135,6 +135,7 @@ fn bench_read() {
         "read::EntriesRaw::read_attribute_inline",
         bench_entries_raw_inline,
     );
+    c.bench_function("read::EntriesRaw::read_attributes", bench_entries_raw_bulk);
 
     let mut c = Criterion::default().configure_from_args();
     c.bench_function("parse .debug_abbrev", bench_parsing_debug_abbrev);
@@ -378,6 +379,44 @@ fn bench_entries_raw_inline(b: &mut Bencher) {
     });
 }
 
+fn bench_entries_raw_bulk(b: &mut Bencher) {
+    let debug_abbrev = read_section("debug_abbrev");
+    let debug_abbrev = DebugAbbrev::new(&debug_abbrev, LittleEndian);
+
+    let debug_info = read_section("debug_info");
+
+    b.iter(|| {
+        let debug_info = DebugInfo::new(&debug_info, LittleEndian);
+
+        let mut attrs = Vec::new();
+        let mut iter = debug_info.units();
+        while let Some(unit) = iter.next().expect("Should parse compilation unit") {
+            let abbrevs = unit
+                .abbreviations(&debug_abbrev)
+                .expect("Should parse abbreviations");
+
+            let mut raw = unit
+                .entries_raw(&abbrevs, None)
+                .expect("Should have entries");
+            while !raw.is_empty() {
+                if let Some(abbrev) = raw
+                    .read_abbreviation()
+                    .expect("Should parse abbreviation code")
+                {
+                    raw.read_attributes(abbrev.attributes(), &mut attrs)
+                        .expect("Should parse attributes");
+                    for attr in &attrs {
+                        let name = attr.name();
+                        black_box(name);
+                        let value = attr.raw_value();
+                        black_box(value);
+                    }
+                }
+            }
+        }
+    });
+}
+
 fn bench_parsing_debug_aranges(b: &mut Bencher) {
     let debug_aranges = read_section("debug_aranges");
     let debug_aranges = DebugAranges::new(&debug_aranges, LittleEndian);

src/read/unit.rs

@@ -1,5 +1,6 @@
 //! Functions for parsing DWARF `.debug_info` and `.debug_types` sections.
 
+use alloc::vec::Vec;
 use core::cell::Cell;
 use core::ops::{Range, RangeFrom, RangeTo};
 
@@ -2587,6 +2588,28 @@ impl<'abbrev, 'unit, R: Reader> EntriesRaw<'abbrev, 'unit, R> {
         parse_attribute(&mut self.input, self.unit.encoding(), spec)
     }
 
+    /// Read all attributes into a `Vec`.
+    ///
+    /// This will clear `attrs` before reading.
+    ///
+    /// It is recommended to reuse the same `Vec` for multiple calls to avoid allocations.
+    pub fn read_attributes(
+        &mut self,
+        specs: &[AttributeSpecification],
+        attrs: &mut Vec<Attribute<R>>,
+    ) -> Result<()> {
+        attrs.clear();
+        attrs.reserve(specs.len());
+        for spec in specs {
+            attrs.push(parse_attribute(
+                &mut self.input,
+                self.unit.encoding(),
+                *spec,
+            )?);
+        }
+        Ok(())
+    }
+
     /// Skip all the attributes of an abbreviation.
     #[inline]
     pub fn skip_attributes(&mut self, specs: &[AttributeSpecification]) -> Result<()> {