pub struct DebuggingInformationEntry<'abbrev, 'unit, R, Offset = <R as Reader>::Offset> where
    R: Reader<Offset = Offset>,
    Offset: ReaderOffset
{ /* private fields */ }
Expand description

A Debugging Information Entry (DIE).

DIEs have a set of attributes and optionally have children DIEs as well.

Implementations

Construct a new DebuggingInformationEntry.

Get this entry’s code.

Get this entry’s offset.

Get this entry’s DW_TAG_whatever tag.

let entry = get_some_entry();

match entry.tag() {
    gimli::DW_TAG_subprogram =>
        println!("this entry contains debug info about a function"),
    gimli::DW_TAG_inlined_subroutine =>
        println!("this entry contains debug info about a particular instance of inlining"),
    gimli::DW_TAG_variable =>
        println!("this entry contains debug info about a local variable"),
    gimli::DW_TAG_formal_parameter =>
        println!("this entry contains debug info about a function parameter"),
    otherwise =>
        println!("this entry is some other kind of data: {:?}", otherwise),
};

Return true if this entry’s type can have children, false otherwise.

Iterate over this entry’s set of attributes.

use gimli::{DebugAbbrev, DebugInfo, LittleEndian};

// Read the `.debug_info` section.

let debug_info = DebugInfo::new(read_debug_info_section_somehow(), LittleEndian);

// Get the data about the first compilation unit out of the `.debug_info`.

let unit = debug_info.units().next()
    .expect("Should have at least one compilation unit")
    .expect("and it should parse ok");

// Read the `.debug_abbrev` section and parse the
// abbreviations for our compilation unit.

let debug_abbrev = DebugAbbrev::new(read_debug_abbrev_section_somehow(), LittleEndian);
let abbrevs = unit.abbreviations(&debug_abbrev).unwrap();

// Get the first entry from that compilation unit.

let mut cursor = unit.entries(&abbrevs);
let (_, entry) = cursor.next_dfs()
    .expect("Should parse next entry")
    .expect("Should have at least one entry");

// Finally, print the first entry's attributes.

let mut attrs = entry.attrs();
while let Some(attr) = attrs.next().unwrap() {
    println!("Attribute name = {:?}", attr.name());
    println!("Attribute value = {:?}", attr.value());
}

Can be used with FallibleIterator.

Find the first attribute in this entry which has the given name, and return it. Returns Ok(None) if no attribute is found.

Find the first attribute in this entry which has the given name, and return its raw value. Returns Ok(None) if no attribute is found.

Find the first attribute in this entry which has the given name, and return its normalized value. Returns Ok(None) if no attribute is found.

Trait Implementations

Returns a copy of the value. Read more

Performs copy-assignment from source. Read more

Formats the value using the given formatter. Read more

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

Immutably borrows from an owned value. Read more

Mutably borrows from an owned value. Read more

Returns the argument unchanged.

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

The resulting type after obtaining ownership.

Creates owned data from borrowed data, usually by cloning. Read more

🔬 This is a nightly-only experimental API. (toowned_clone_into)

Uses borrowed data to replace owned data, usually by cloning. Read more

The type returned in the event of a conversion error.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.