Struct gimli::read::EntriesRaw

pub struct EntriesRaw<'abbrev, 'unit, R> where
    R: Reader,  { /* private fields */ }

A raw reader of the data that defines the Debugging Information Entries.

EntriesRaw provides primitives to read the components of Debugging Information Entries (DIEs). A DIE consists of an abbreviation code (read with read_abbreviation) followed by a number of attributes (read with read_attribute). The user must provide the control flow to read these correctly. In particular, all attributes must always be read before reading another abbreviation code.

EntriesRaw lacks some features of EntriesCursor, such as the ability to skip to the next sibling DIE. However, this also allows it to optimize better, since it does not need to perform the extra bookkeeping required to support these features, and thus it is suitable for cases where performance is important.

Example Usage

let unit = get_some_unit();
let abbrevs = get_abbrevs_for_unit(&unit);

let mut entries = unit.entries_raw(&abbrevs, None)?;
while !entries.is_empty() {
    let abbrev = if let Some(abbrev) = entries.read_abbreviation()? {
        abbrev
    } else {
        // Null entry with no attributes.
        continue
    };
    match abbrev.tag() {
        gimli::DW_TAG_subprogram => {
            // Loop over attributes for DIEs we care about.
            for spec in abbrev.attributes() {
                let attr = entries.read_attribute(*spec)?;
                match attr.name() {
                    // Handle attributes.
                    _ => {}
                }
            }
        }
        _ => {
            // Skip attributes for DIEs we don't care about.
            for spec in abbrev.attributes() {
                entries.read_attribute(*spec)?;
            }
        }
    }
}

Implementations

impl<'abbrev, 'unit, R: Reader> EntriesRaw<'abbrev, 'unit, R>

pub fn is_empty(&self) -> bool

Return true if there is no more input.

pub fn next_offset(&self) -> UnitOffset<R::Offset>

Return the unit offset at which the reader will read next.

If you want the offset of the next entry, then this must be called prior to reading the next entry.

pub fn next_depth(&self) -> isize

Return the depth of the next entry.

This depth is updated when read_abbreviation is called, and is updated based on null entries and the has_children field in the abbreviation.

pub fn read_abbreviation(&mut self) -> Result<Option<&'abbrev Abbreviation>>

Read an abbreviation code and lookup the corresponding Abbreviation.

Returns Ok(None) for null entries.

pub fn read_attribute(
    &mut self,
    spec: AttributeSpecification
) -> Result<Attribute<R>>

Read an attribute.

Trait Implementations

impl<'abbrev, 'unit, R: Clone> Clone for EntriesRaw<'abbrev, 'unit, R> where
    R: Reader, 

fn clone(&self) -> EntriesRaw<'abbrev, 'unit, R>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'abbrev, 'unit, R: Debug> Debug for EntriesRaw<'abbrev, 'unit, R> where
    R: Reader, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.