Struct `Cache`

pub(in ::backtrace_rs::symbolize::gimli) struct Cache { pub(in ::backtrace_rs::symbolize::gimli) libraries: Vec<Library>, pub(in ::backtrace_rs::symbolize::gimli) mappings: Lru<(usize, Mapping), MAPPINGS_CACHE_SIZE> }

Fields

libraries: Vec<Library>

All known shared libraries that have been loaded.

mappings: Lru<(usize, Mapping), MAPPINGS_CACHE_SIZE>

Mappings cache where we retain parsed dwarf information.

This list has a fixed capacity for its entire lifetime which never increases. The usize element of each pair is an index into libraries above where usize::max_value() represents the current executable. The Mapping is corresponding parsed dwarf information.

Note that this is basically an LRU cache and we'll be shifting things around in here as we symbolize addresses.

Implementations

`impl Cache`

fn new() -> Cache
unsafe fn with_global(f: impl FnOnce(&mut Self))
fn avma_to_svma(&self, addr: *const u8) -> Option<(usize, *const u8)>
fn mapping_for_lib<'a>(&'a mut self, lib: usize) -> Option<(&'a mut Context<'a>, &'a Stash)>

Trait Implementations

`impl Default for Cache`

fn default() -> Cache

Auto Trait Implementations

`impl !Freeze for Cache`

`impl !RefUnwindSafe for Cache`

`impl !Send for Cache`

`impl !Sync for Cache`

`impl Unpin for Cache`

`impl UnsafeUnpin for Cache`

`impl UnwindSafe for Cache`

Blanket Implementations

`impl<T> Any for Cache where T: 'static + ?Sized,`

fn type_id(&self) -> TypeId

`impl<T> Borrow<T> for Cache where T: ?Sized,`

fn borrow(&self) -> &T

`impl<T> BorrowMut<T> for Cache where T: ?Sized,`

fn borrow_mut(&mut self) -> &mut T

`impl<T> From<T> for Cache`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> SizeHint for Cache where T: ?Sized,`

fn lower_bound(&self) -> usize
fn upper_bound(&self) -> Option<usize>

`impl<T> SizedTypeProperties for Cache`

`impl<T, U> Into for Cache where U: From<T>,`

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom for Cache where U: Into<T>,`

type Error = Infallible;
fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

`impl<T, U> TryInto for Cache where U: TryFrom<T>,`

type Error = >::Error;
fn try_into(self) -> Result<U, >::Error>