Struct probe_rs::debug::debug_info::DebugInfo

pub struct DebugInfo { /* private fields */ }

Debug information which is parsed from DWARF debugging information.

Implementations

impl DebugInfo

pub fn from_file<P: AsRef<Path>>(path: P) -> Result<DebugInfo, DebugError>

Read debug info directly from a ELF file.

pub fn from_raw(data: &[u8]) -> Result<Self, DebugError>

Parse debug information directly from a buffer containing an ELF file.

pub fn function_name(
&self,
address: u64,
find_inlined: bool
) -> Result<Option<String>, DebugError>

Get the name of the function at the given address.

If no function is found, None will be returend.

Inlined functions

Multiple nested inline functions could exist at the given address. This function will currently return the innermost function in that case.

pub fn get_source_location(&self, address: u64) -> Option<SourceLocation>

Try get the SourceLocation for a given address.

pub fn cache_deferred_variables(
&self,
cache: &mut VariableCache,
core: &mut Core<'_>,
parent_variable: &mut Variable,
stack_frame_registers: &DebugRegisters,
frame_base: Option<u64>
) -> Result<(), DebugError>

This effects the on-demand expansion of lazy/deferred load of all the ‘child’ Variables for a given ‘parent’.

pub fn unwind(
&self,
core: &mut Core<'_>,
address: u64
) -> Result<Vec<StackFrame>, Error>

Performs the logical unwind of the stack and returns a Vec<StackFrame>

• The first ‘StackFrame’ represents the frame at the current PC (program counter), and …
• Each subsequent StackFrame represents the previous or calling StackFrame in the call stack.
• The majority of the work happens in the 'unwind: while loop, where each iteration will create a StackFrame where possible, and update the unwind_registers to prepare for the next iteration.

The unwind loop will continue until we meet one of the following conditions:

• We can no longer unwind a valid PC value to be used for the next frame.
• We encounter a LR register value of 0x0 or 0xFFFFFFFF(Arm ‘Reset’ value for that register).
• TODO: Catch the situation where the PC value indicates a hard-fault or other non-recoverable exception
• We can not intelligently calculate a valid LR register value from the other registers, or the gimli::RegisterRule result is a value of 0x0. Note: DWARF 6.4.4 - CIE defines the return register address used in the gimli::RegisterRule tables for unwind operations. Theoretically, if we encounter a function that has Undefined gimli::RegisterRule for the return register address, it means we have reached the bottom of the stack OR the function is a ‘no return’ type of function. I have found actual examples (e.g. local functions) where we get Undefined for register rule when we cannot apply this logic. Example 1: local functions in main.rs will have LR rule as Undefined. Example 2: main()-> ! that is called from a trampoline will have a valid LR rule.
• Similarly, certain error conditions encountered in StackFrameIterator will also break out of the unwind loop. Note: In addition to populating the StackFrames, this function will also populate the DebugInfo::VariableCache with Variables for available Registers as well as static and function variables. TODO: Separate logic for stackframe creation and cache population

pub fn get_breakpoint_location(
&self,
path: &Path,
line: u64,
column: Option<u64>
) -> Result<(Option<u64>, Option<SourceLocation>), DebugError>

Find the program counter where a breakpoint should be set, given a source file, a line and optionally a column.