Struct gimli::read::FrameDescriptionEntry

pub struct FrameDescriptionEntry<R, Offset = <R as Reader>::Offset>
where
    R: Reader<Offset = Offset>,
    Offset: ReaderOffset,
{
    offset: Offset,
    length: Offset,
    format: Format,
    cie: CommonInformationEntry<R, Offset>,
    initial_address: u64,
    address_range: u64,
    augmentation: Option<AugmentationData>,
    instructions: R,
}

A FrameDescriptionEntry is a set of CFA instructions for an address range.

Fields

offset: Offset

The start of this entry within its containing section.

length: Offset

A constant that gives the number of bytes of the header and instruction stream for this function, not including the length field itself (see Section 7.2.2). The size of the length field plus the value of length must be an integral multiple of the address size.

format: Format

cie: CommonInformationEntry<R, Offset>

“A constant offset into the .debug_frame section that denotes the CIE that is associated with this FDE.”

This is the CIE at that offset.

initial_address: u64

The address of the first location associated with this table entry. If the segment_size field of this FDE’s CIE is non-zero, the initial location is preceded by a segment selector of the given length.

address_range: u64

“The number of bytes of program instructions described by this entry.”

augmentation: Option<AugmentationData>

The parsed augmentation data, if we have any.

instructions: R

“A sequence of table defining instructions that are described below.”

This is followed by DW_CFA_nop padding until length bytes of the input are consumed.

Implementations

impl<R: Reader> FrameDescriptionEntry<R>

fn parse_rest<Section, F>( offset: R::Offset, length: R::Offset, format: Format, cie_pointer: Section::Offset, rest: R, section: &Section, bases: &BaseAddresses, get_cie: F, ) -> Result<FrameDescriptionEntry<R>>

where Section: UnwindSection<R>, F: FnMut(&Section, &BaseAddresses, Section::Offset) -> Result<CommonInformationEntry<R>>,

fn parse_addresses( input: &mut R, cie: &CommonInformationEntry<R>, parameters: &PointerEncodingParameters<'_, R>, ) -> Result<(u64, u64)>

pub fn rows<'a, 'ctx, Section, S>( &self, section: &'a Section, bases: &'a BaseAddresses, ctx: &'ctx mut UnwindContext<R::Offset, S>, ) -> Result<UnwindTable<'a, 'ctx, R, S>>

where Section: UnwindSection<R>, S: UnwindContextStorage<R::Offset>,

Return the table of unwind information for this FDE.

pub fn unwind_info_for_address<'ctx, Section, S>( &self, section: &Section, bases: &BaseAddresses, ctx: &'ctx mut UnwindContext<R::Offset, S>, address: u64, ) -> Result<&'ctx UnwindTableRow<R::Offset, S>>

where Section: UnwindSection<R>, S: UnwindContextStorage<R::Offset>,

Find the frame unwind information for the given address.

If found, the unwind information is returned along with the reset context in the form Ok((unwind_info, context)). If not found, Err(gimli::Error::NoUnwindInfoForAddress) is returned. If parsing or CFI evaluation fails, the error is returned.

impl<R: Reader> FrameDescriptionEntry<R>

Signal Safe Methods

These methods are guaranteed not to allocate, acquire locks, or perform any other signal-unsafe operations.

pub fn offset(&self) -> R::Offset

Get the offset of this entry from the start of its containing section.

pub fn cie(&self) -> &CommonInformationEntry<R>

Get a reference to this FDE’s CIE.

pub fn entry_len(&self) -> R::Offset

A constant that gives the number of bytes of the header and instruction stream for this function, not including the length field itself (see Section 7.2.2). The size of the length field plus the value of length must be an integral multiple of the address size.

pub fn instructions<'a, Section>( &self, section: &'a Section, bases: &'a BaseAddresses, ) -> CallFrameInstructionIter<'a, R>

where Section: UnwindSection<R>,

Iterate over this FDE’s instructions.

Will not include the CIE’s initial instructions, if you want those do fde.cie().instructions() first.

Can be used with FallibleIterator.

pub fn initial_address(&self) -> u64

The first address for which this entry has unwind information for.

pub fn end_address(&self) -> u64

One more than the last address that this entry has unwind information for.

This uses wrapping arithmetic, so the result may be less than initial_address.

pub fn len(&self) -> u64

The number of bytes of instructions that this entry has unwind information for.

pub fn contains(&self, address: u64) -> bool

Return true if the given address is within this FDE, false otherwise.

This is equivalent to entry.initial_address() <= address < entry.initial_address() + entry.len().

pub fn lsda(&self) -> Option<Pointer>

The address of this FDE’s language-specific data area (LSDA), if it has any.

pub fn is_signal_trampoline(&self) -> bool

Return true if this FDE’s function is a trampoline for a signal handler.

pub fn personality(&self) -> Option<Pointer>

Return the address of the FDE’s function’s personality routine handler. The personality routine does language-specific clean up when unwinding the stack frames with the intent to not run them again.

Trait Implementations

impl<R, Offset> Clone for FrameDescriptionEntry<R, Offset>

where R: Reader<Offset = Offset> + Clone, Offset: ReaderOffset + Clone,

fn clone(&self) -> FrameDescriptionEntry<R, Offset>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<R, Offset> Debug for FrameDescriptionEntry<R, Offset>

where R: Reader<Offset = Offset> + Debug, Offset: ReaderOffset + Debug,

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

Formats the value using the given formatter.

impl<R, Offset> PartialEq for FrameDescriptionEntry<R, Offset>

where R: Reader<Offset = Offset> + PartialEq, Offset: ReaderOffset + PartialEq,

fn eq(&self, other: &FrameDescriptionEntry<R, Offset>) -> 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<R, Offset> Eq for FrameDescriptionEntry<R, Offset>

where R: Reader<Offset = Offset> + Eq, Offset: ReaderOffset + Eq,

impl<R, Offset> StructuralPartialEq for FrameDescriptionEntry<R, Offset>

where R: Reader<Offset = Offset>, Offset: ReaderOffset,