1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141
use crate::common::{DebugInfoOffset, SectionId};
use crate::endianity::Endianity;
use crate::read::lookup::{DebugLookup, LookupEntryIter, PubStuffEntry, PubStuffParser};
use crate::read::{EndianSlice, Reader, Result, Section, UnitOffset};
/// A single parsed pubname.
#[derive(Debug, Clone)]
pub struct PubNamesEntry<R: Reader> {
unit_header_offset: DebugInfoOffset<R::Offset>,
die_offset: UnitOffset<R::Offset>,
name: R,
}
impl<R: Reader> PubNamesEntry<R> {
/// Returns the name this entry refers to.
pub fn name(&self) -> &R {
&self.name
}
/// Returns the offset into the .debug_info section for the header of the compilation unit
/// which contains this name.
pub fn unit_header_offset(&self) -> DebugInfoOffset<R::Offset> {
self.unit_header_offset
}
/// Returns the offset into the compilation unit for the debugging information entry which
/// has this name.
pub fn die_offset(&self) -> UnitOffset<R::Offset> {
self.die_offset
}
}
impl<R: Reader> PubStuffEntry<R> for PubNamesEntry<R> {
fn new(
die_offset: UnitOffset<R::Offset>,
name: R,
unit_header_offset: DebugInfoOffset<R::Offset>,
) -> Self {
PubNamesEntry {
unit_header_offset,
die_offset,
name,
}
}
}
/// The `DebugPubNames` struct represents the DWARF public names information
/// found in the `.debug_pubnames` section.
#[derive(Debug, Clone)]
pub struct DebugPubNames<R: Reader>(DebugLookup<R, PubStuffParser<R, PubNamesEntry<R>>>);
impl<'input, Endian> DebugPubNames<EndianSlice<'input, Endian>>
where
Endian: Endianity,
{
/// Construct a new `DebugPubNames` instance from the data in the `.debug_pubnames`
/// section.
///
/// It is the caller's responsibility to read the `.debug_pubnames` section and
/// present it as a `&[u8]` slice. That means using some ELF loader on
/// Linux, a Mach-O loader on macOS, etc.
///
/// ```
/// use gimli::{DebugPubNames, LittleEndian};
///
/// # let buf = [];
/// # let read_debug_pubnames_section_somehow = || &buf;
/// let debug_pubnames =
/// DebugPubNames::new(read_debug_pubnames_section_somehow(), LittleEndian);
/// ```
pub fn new(debug_pubnames_section: &'input [u8], endian: Endian) -> Self {
Self::from(EndianSlice::new(debug_pubnames_section, endian))
}
}
impl<R: Reader> DebugPubNames<R> {
/// Iterate the pubnames in the `.debug_pubnames` section.
///
/// ```
/// use gimli::{DebugPubNames, EndianSlice, LittleEndian};
///
/// # let buf = [];
/// # let read_debug_pubnames_section_somehow = || &buf;
/// let debug_pubnames =
/// DebugPubNames::new(read_debug_pubnames_section_somehow(), LittleEndian);
///
/// let mut iter = debug_pubnames.items();
/// while let Some(pubname) = iter.next().unwrap() {
/// println!("pubname {} found!", pubname.name().to_string_lossy());
/// }
/// ```
pub fn items(&self) -> PubNamesEntryIter<R> {
PubNamesEntryIter(self.0.items())
}
}
impl<R: Reader> Section<R> for DebugPubNames<R> {
fn id() -> SectionId {
SectionId::DebugPubNames
}
fn reader(&self) -> &R {
self.0.reader()
}
}
impl<R: Reader> From<R> for DebugPubNames<R> {
fn from(debug_pubnames_section: R) -> Self {
DebugPubNames(DebugLookup::from(debug_pubnames_section))
}
}
/// An iterator over the pubnames from a `.debug_pubnames` section.
///
/// Can be [used with
/// `FallibleIterator`](./index.html#using-with-fallibleiterator).
#[derive(Debug, Clone)]
pub struct PubNamesEntryIter<R: Reader>(LookupEntryIter<R, PubStuffParser<R, PubNamesEntry<R>>>);
impl<R: Reader> PubNamesEntryIter<R> {
/// Advance the iterator and return the next pubname.
///
/// Returns the newly parsed pubname as `Ok(Some(pubname))`. Returns
/// `Ok(None)` when iteration is complete and all pubnames have already been
/// parsed and yielded. If an error occurs while parsing the next pubname,
/// then this error is returned as `Err(e)`, and all subsequent calls return
/// `Ok(None)`.
pub fn next(&mut self) -> Result<Option<PubNamesEntry<R>>> {
self.0.next()
}
}
#[cfg(feature = "fallible-iterator")]
impl<R: Reader> fallible_iterator::FallibleIterator for PubNamesEntryIter<R> {
type Item = PubNamesEntry<R>;
type Error = crate::read::Error;
fn next(&mut self) -> ::core::result::Result<Option<Self::Item>, Self::Error> {
self.0.next()
}
}