Struct CompilationUnit

pub struct CompilationUnit<'a> {
    pub offset: usize,
    pub endian: Endian,
    pub version: u16,
    pub address_size: u8,
    pub offset_size: u8,
    pub abbrev_offset: u64,
    pub data: Cow<'a, [u8]>,
}

Fields

offset: usize

endian: Endian

version: u16

address_size: u8

offset_size: u8

abbrev_offset: u64

data: Cow<'a, [u8]>

Implementations

impl<'a> CompilationUnit<'a>

pub fn read( r: &mut &'a [u8], offset: usize, endian: Endian, ) -> Result<CompilationUnit<'a>, ReadError>

pub fn abbrev(&self, debug_abbrev: &[u8]) -> Result<AbbrevHash, ReadError>

pub fn entries(&'a self, abbrev: &'a AbbrevHash) -> DieCursor<'a, 'a, 'a>

Examples found in repository

examples/display.rs (line 19)

fn display(path: &Path) -> Result<(), dwarf::ReadError> {
    let sections = try!(dwarf::elf::load(path));
    let mut units = sections.compilation_units();
    let mut stdout = std::io::stdout();
    let mut f = dwarf::display::DefaultFormatter::new(&mut stdout, 4);
    while let Some(unit) = try!(units.next()) {
        let abbrev = try!(sections.abbrev(&unit));
        try!(unit.entries(&abbrev).display_depth(&mut f, 3));
    }
    Ok(())
}

pub fn entry( &'a self, offset: usize, abbrev: &'a AbbrevHash, ) -> Option<DieCursor<'a, 'a, 'a>>

impl<'a> CompilationUnit<'a>

pub fn write<W: Write>(&self, w: &mut W) -> Result<(), WriteError>

impl<'a> CompilationUnit<'a>

pub fn data(&'a self) -> &'a [u8]

pub fn data_offset(&self) -> usize

Trait Implementations

impl<'a> Debug for CompilationUnit<'a>

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

Formats the value using the given formatter.

impl<'a> Default for CompilationUnit<'a>

fn default() -> Self

Returns the “default value” for a type.

impl<'a> PartialEq for CompilationUnit<'a>

fn eq(&self, other: &CompilationUnit<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Eq for CompilationUnit<'a>

impl<'a> StructuralPartialEq for CompilationUnit<'a>