Struct probe_rs::debug::variable::Variable

pub struct Variable {

    pub variable_key: i64,
    pub parent_key: Option<i64>,
    pub name: VariableName,
    pub source_location: Option<SourceLocation>,
    pub type_name: VariableType,
    pub unit_header_offset: Option<DebugInfoOffset>,
    pub variable_unit_offset: Option<UnitOffset>,
    pub variable_node_type: VariableNodeType,
    pub memory_location: VariableLocation,
    pub byte_size: Option<u64>,
    pub member_index: Option<i64>,
    pub range_lower_bound: i64,
    pub range_upper_bound: i64,
    pub role: VariantRole,
    /* private fields */
}

The Variable struct is used in conjunction with VariableCache to cache data about variables.

Any modifications to the Variable value will be transient (lost when it goes out of scope), unless it is updated through one of the available methods on VariableCache.

Fields

variable_key: i64

Every variable must have a unique key value assigned to it. The value will be zero until it is stored in VariableCache, at which time its value will be set to the same as the VariableCache::variable_cache_key

parent_key: Option<i64>

Every variable must have a unique parent assigned to it when stored in the VariableCache. A parent_key of None in the cache simply implies that this variable doesn’t have a parent, i.e. it is the root of a tree.

name: VariableName

The variable name refers to the name of any of the types of values described in the VariableCache

source_location: Option<SourceLocation>

The source location of the declaration of this variable, if available.

type_name: VariableType

The name of the type of this variable.

unit_header_offset: Option<DebugInfoOffset>

The unit_header_offset and variable_unit_offset are cached to allow on-demand access to the variable’s gimli::Unit, through functions like: gimli::Read::DebugInfo.header_from_offset(), and
gimli::Read::UnitHeader.entries_tree()

variable_unit_offset: Option<UnitOffset>

The offset of this variable into the compilation unit debug information.

variable_node_type: VariableNodeType

For ‘lazy loading’ of certain variable types we have to determine if the variable recursion should be deferred, and if so, how to resolve it when the request for further recursion happens. See VariableNodeType for more information.

memory_location: VariableLocation

The starting location/address in memory where this Variable’s value is stored.

byte_size: Option<u64>

The size of this variable in bytes.

member_index: Option<i64>

If this is a subrange (array, vector, etc.), is the ordinal position of this variable in that range

range_lower_bound: i64

If this is a subrange (array, vector, etc.), we need to temporarily store the lower bound.

range_upper_bound: i64

If this is a subrange (array, vector, etc.), we need to temporarily store the the upper bound of the range.

role: VariantRole

The role of this variable.

Implementations

impl Variable

pub fn new(
header_offset: Option<DebugInfoOffset>,
entries_offset: Option<UnitOffset>
) -> Variable

In most cases, Variables will be initialized with their ELF references so that we resolve their data types and values on demand.

pub fn set_value(&mut self, new_value: VariableValue)

Implementing set_value(), because the library passes errors into the value of the variable. This ensures debug front ends can see the errors, but doesn’t fail because of a single variable not being able to decode correctly.

pub fn update_value(
&self,
core: &mut Core<'_>,
variable_cache: &mut VariableCache,
new_value: String
) -> Result<String, DebugError>

Convert the String value into the appropriate memory format and update the target memory with the new value. Currently this only works for base data types. There is no provision in the MS DAP API to catch this client side, so we can only respond with a ‘gentle’ error message if the user attemtps unsupported data types.

pub fn get_value(&self, variable_cache: &VariableCache) -> String

Implementing get_value(), because Variable.value has to be private (a requirement of updating the value without overriding earlier values … see set_value()).

pub fn extract_value(
&mut self,
core: &mut Core<'_>,
variable_cache: &VariableCache
)

Evaluate the variable’s result if possible and set self.value, or else set self.value as the error String.

pub fn is_indexed(&self) -> bool

The variable is considered to be an ‘indexed’ variable if the name starts with two underscores followed by a number. e.g. “__1”. TODO: Consider replacing this logic with std::str::pattern::Pattern when that API stabilizes

pub fn is_valid(&self) -> bool

true if the Variable has a valid value, or an empty value. false if the Variable has a VariableValue::Error(_)value

Trait Implementations

impl Clone for Variable

fn clone(&self) -> Variable

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Variable

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

Formats the value using the given formatter.

impl Default for Variable

fn default() -> Variable

Returns the “default value” for a type.

impl PartialEq<Variable> for Variable

fn eq(&self, other: &Variable) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Variable

impl StructuralEq for Variable

impl StructuralPartialEq for Variable