Enum VariableNodeType

pub enum VariableNodeType {
    TypeOffset(DebugInfoOffset, UnitOffset),
    DirectLookup(DebugInfoOffset, UnitOffset),
    UnitsLookup,
    DoNotRecurse,
    RecurseToBaseType,
}

Available on crate feature debug only.

Encode the nature of the Debug Information Entry in a way that we can resolve child nodes of a Variable.

The rules for ‘lazy loading’/deferred recursion of Variable children are described under each of the enum values.

Variants

TypeOffset(DebugInfoOffset, UnitOffset)

Use the header_offset and type_offset as direct references for recursing the variable children. With the current implementation, the type_offset will point to a DIE with a tag of DW_TAG_structure_type.

• Rule: For structured variables, we WILL NOT automatically expand their children, but we have enough information to expand it on demand. Except if they fall into one of the special cases handled by VariableNodeType::RecurseToBaseType

DirectLookup(DebugInfoOffset, UnitOffset)

Use the header_offset and entries_offset as direct references for recursing the variable children.

• Rule: All top level variables in a StackFrame are automatically deferred, i.e VariableName::LocalScopeRoot, VariableName::RegistersRoot.

UnitsLookup

Look up information from all compilation units. This is used to resolve static variables, so when VariableName::StaticScopeRoot is used.

DoNotRecurse

Sometimes it doesn’t make sense to recurse the children of a specific node type

• Rule: Pointers to unit datatypes WILL NOT BE resolved, because it doesn’t make sense.
• Rule: Once we determine that a variable can not be recursed further, we update the variable_node_type to indicate that no further recursion is possible/required. This can be because the variable is a ‘base’ data type, or because there was some kind of error in processing the current node, so we don’t want to incur cascading errors.

RecurseToBaseType

Unless otherwise specified, always recurse the children of every node until we get to the base data type.

• Rule: (Default) Unless it is prevented by any of the other rules, we always recurse the children of these variables.
• Rule: Certain structured variables (e.g. &str, Some, Ok, Err, etc.) are set to VariableNodeType::RecurseToBaseType to improve the debugger UX.
• Rule: Pointers to const variables WILL ALWAYS BE recursed, because they provide essential information, for example about the length of strings, or the size of arrays.
• Rule: Enumerated types WILL ALWAYS BE recursed, because we only ever want to see the ‘active’ child as the value.
• Rule: For now, Array types WILL ALWAYS BE recursed. TODO: Evaluate if it is beneficial to defer these.
• Rule: For now, Union types WILL ALWAYS BE recursed. TODO: Evaluate if it is beneficial to defer these.

Implementations

impl VariableNodeType

pub fn is_deferred(&self) -> bool

Will return true if the variable_node_type value implies that the variable will be ‘lazy’ resolved.

Trait Implementations

impl Clone for VariableNodeType

fn clone(&self) -> VariableNodeType

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for VariableNodeType

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

Formats the value using the given formatter.

impl Default for VariableNodeType

fn default() -> VariableNodeType

Returns the “default value” for a type.

impl PartialEq for VariableNodeType

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

impl StructuralPartialEq for VariableNodeType