Struct VariableCache

pub struct VariableCache { /* private fields */ }

Available on crate feature debug only.

VariableCache stores available Variables, and provides methods to create and navigate the parent-child relationships of the Variables.

Implementations

impl VariableCache

pub fn new_dwarf_cache( entries_offset: UnitOffset, name: VariableName, unit_info: &UnitInfo, ) -> Result<Self, DebugError>

Create a variable cache based on DWARF debug information

The entries_offset and unit_info values are used to extract the variable information from the debug information.

The entries form a tree, only entries below the entry at entries_offset are considered when filling the cache.

pub fn new_static_cache() -> Self

Create a cache for static variables.

This will be filled with static variables when cache_deferred_variables is called.

pub fn root_variable(&self) -> &Variable

Get the root variable of the cache

pub fn len(&self) -> usize

Returns the number of Variables in the cache.

pub fn is_empty(&self) -> bool

Returns true if the cache is empty.

pub fn create_variable( &mut self, parent_key: ObjectRef, unit_info: Option<&UnitInfo>, ) -> Result<Variable, DebugError>

Create a new variable in the cache

pub fn add_variable( &mut self, parent_key: ObjectRef, cache_variable: &mut Variable, ) -> Result<(), DebugError>

Add a variable to the cache

The parent key must exist in the cache, and the variable must not have a key assigned yet.

pub fn update_variable( &mut self, cache_variable: &Variable, ) -> Result<(), DebugError>

Update a variable in the cache

This function does not update the value of the variable.

pub fn get_variable_by_key(&self, variable_key: ObjectRef) -> Option<Variable>

Retrieve a clone of a specific Variable, using the variable_key.

pub fn get_variable_by_name_and_parent( &self, variable_name: &VariableName, parent_key: ObjectRef, ) -> Option<Variable>

Retrieve a clone of a specific Variable, using the name and parent_key. If there is more than one, it will be logged (tracing::error!), and only the last will be returned.

pub fn get_variable_by_name( &self, variable_name: &VariableName, ) -> Option<Variable>

Retrieve a clone of a specific Variable, using the name. If there is more than one, it will be logged (tracing::warn!), and only the first will be returned. It is possible for a hierarchy of variables in a cache to have duplicate names under different parents.

pub fn get_children( &self, parent_key: ObjectRef, ) -> impl Iterator<Item = &Variable> + Clone

Retrieve cloned version of all the children of a Variable. If parent_key == None, it will return all the top level variables (no parents) in this cache.

pub fn has_children(&self, parent_variable: &Variable) -> bool

Check if variable has children. If the variable doesn’t exist, it will return false.

pub fn adopt_grand_children( &mut self, parent_variable: &Variable, obsolete_child_variable: &Variable, ) -> Result<(), Error>

Sometimes DWARF uses intermediate nodes that are not part of the coded variable structure. When we encounter them, the children of such intermediate nodes are assigned to the parent of the intermediate node, and we discard the intermediate nodes from the DebugInfo::VariableCache

Similarly, while resolving VariableNodeType::is_deferred(), i.e. ‘lazy load’ of variables, we need to create intermediate variables that are eliminated here.

NOTE: For all other situations, this function will silently do nothing.

pub fn remove_cache_entry_children( &mut self, parent_variable_key: ObjectRef, ) -> Result<(), Error>

Removing an entry’s children from the VariableCache will recursively remove all their children

pub fn remove_cache_entry( &mut self, variable_key: ObjectRef, ) -> Result<(), Error>

Removing an entry from the VariableCache will recursively remove all its children

pub fn recurse_deferred_variables( &mut self, debug_info: &DebugInfo, memory: &mut dyn MemoryInterface, max_recursion_depth: usize, frame_info: StackFrameInfo<'_>, )

Recursively process the deferred variables in the variable cache, and add their children to the cache. Enforce a max level, so that we don’t recurse infinitely on circular references.

pub fn get_discrete_memory_ranges(&self) -> Vec<Range<u64>>

Traverse the VariableCache and return a Vec of all the memory ranges that are referenced by the variables. This is used to determine which memory ranges to read from the target when creating a ‘default’ crate::CoreDump.

Trait Implementations

impl Clone for VariableCache

fn clone(&self) -> VariableCache

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for VariableCache

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

Formats the value using the given formatter.

impl PartialEq for VariableCache

fn eq(&self, other: &VariableCache) -> 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 Serialize for VariableCache

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for VariableCache