Struct minidump_processor::symbols::Symbolizer

pub struct Symbolizer { /* private fields */ }

Implementations

impl Symbolizer

pub fn new<T>(supplier: T) -> Symbolizer where
    T: 'static + SymbolSupplier + Send + Sync, 

Create a Symbolizer that uses supplier to locate symbols.

pub async fn get_symbol_at_address(
    &self,
    debug_file: &str,
    debug_id: DebugId,
    address: u64
) -> Option<String>

Helper method for non-minidump-using callers.

Pass debug_file and debug_id describing a specific module, and address, a module-relative address, and get back a symbol in that module that covers that address, or None.

See the module-level documentation for an example.

pub async fn fill_symbol(
    &self,
    module: &(dyn Module + Sync),
    frame: &mut (dyn FrameSymbolizer + Send)
) -> Result<(), FillSymbolError>

Fill symbol information in frame using the instruction address from frame, and the module information from module. If you’re not using a minidump module, you can use SimpleModule and SimpleFrame.

An Error indicates that no symbols could be found for the relevant module.

Examples

use std::str::FromStr;
use debugid::DebugId;
use breakpad_symbols::{SimpleSymbolSupplier,Symbolizer,SimpleFrame,SimpleModule};

#[tokio::main]
async fn main() {
    use std::path::PathBuf;
    let paths = vec!(PathBuf::from("../testdata/symbols/"));
    let supplier = SimpleSymbolSupplier::new(paths);
    let symbolizer = Symbolizer::new(supplier);
    let debug_id = DebugId::from_str("5A9832E5287241C1838ED98914E9B7FF1").unwrap();
    let m = SimpleModule::new("test_app.pdb", debug_id);
    let mut f = SimpleFrame::with_instruction(0x1010);
    let _ = symbolizer.fill_symbol(&m, &mut f).await;
    assert_eq!(f.function.unwrap(), "vswprintf");
    assert_eq!(f.source_file.unwrap(),
        r"c:\program files\microsoft visual studio 8\vc\include\swprintf.inl");
    assert_eq!(f.source_line.unwrap(), 51);
}

pub fn stats(&self) -> HashMap<String, SymbolStats, RandomState>

Collect various statistics on the symbols.

Keys are the file name of the module (code_file’s file name).

pub async fn walk_frame(
    &self,
    module: &(dyn Module + Sync),
    walker: &mut (dyn FrameWalker + Send)
) -> Option<()>

Tries to use CFI to walk the stack frame of the FrameWalker using the symbols of the given Module. Output will be written using the FrameWalker’s set_caller_* APIs.

pub async fn get_file_path(
    &self,
    module: &(dyn Module + Sync),
    file_kind: FileKind
) -> Result<PathBuf, FileError>

Gets the path to a file for a given module (or an Error).

This returns a CachedOperation which is guaranteed to already be resolved (lifetime stuff).

Trait Implementations

impl SymbolProvider for Symbolizer

fn fill_symbol<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    module: &'life1 (dyn Module + Sync),
    frame: &'life2 mut (dyn FrameSymbolizer + Send)
) -> Pin<Box<dyn Future<Output = Result<(), FillSymbolError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

fn walk_frame<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    module: &'life1 (dyn Module + Sync),
    walker: &'life2 mut (dyn FrameWalker + Send)
) -> Pin<Box<dyn Future<Output = Option<()>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

fn get_file_path<'life0, 'life1, 'async_trait>(
    &'life0 self,
    module: &'life1 (dyn Module + Sync),
    file_kind: FileKind
) -> Pin<Box<dyn Future<Output = Result<PathBuf, FileError>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

fn stats(&self) -> HashMap<String, SymbolStats>