Enum rust_debug::evaluate::evaluate::EvaluatorValue

pub enum EvaluatorValue<R: Reader<Offset = usize>> {
    Value(BaseTypeValue, ValueInformation),
    PointerTypeValue(Box<PointerTypeValue<R>>),
    VariantValue(Box<VariantValue<R>>),
    VariantPartValue(Box<VariantPartValue<R>>),
    SubrangeTypeValue(SubrangeTypeValue),
    Bytes(R),
    Array(Box<ArrayTypeValue<R>>),
    Struct(Box<StructureTypeValue<R>>),
    Enum(Box<EnumerationTypeValue<R>>),
    Union(Box<UnionTypeValue<R>>),
    Member(Box<MemberValue<R>>),
    OptimizedOut,
    LocationOutOfRange,
    ZeroSize,
}

Describes all the different Rust types values in the form of a tree structure.

Variants

Value(BaseTypeValue, ValueInformation)

A base_type type and value with location information.

Tuple Fields of Value

0: BaseTypeValue1: ValueInformation

PointerTypeValue(Box<PointerTypeValue<R>>)

A pointer_type type and value.

Tuple Fields of PointerTypeValue

0: Box<PointerTypeValue<R>>

VariantValue(Box<VariantValue<R>>)

A variant type and value.

Tuple Fields of VariantValue

0: Box<VariantValue<R>>

VariantPartValue(Box<VariantPartValue<R>>)

A variant_part type and value.

Tuple Fields of VariantPartValue

0: Box<VariantPartValue<R>>

SubrangeTypeValue(SubrangeTypeValue)

A subrange_type type and value.

Tuple Fields of SubrangeTypeValue

0: SubrangeTypeValue

Bytes(R)

gimli-rs bytes value.

Tuple Fields of Bytes

0: R

Array(Box<ArrayTypeValue<R>>)

A array type value.

Tuple Fields of Array

0: Box<ArrayTypeValue<R>>

Struct(Box<StructureTypeValue<R>>)

A struct type value.

Tuple Fields of Struct

0: Box<StructureTypeValue<R>>

Enum(Box<EnumerationTypeValue<R>>)

A enum type value.

Tuple Fields of Enum

0: Box<EnumerationTypeValue<R>>

Union(Box<UnionTypeValue<R>>)

A union type value.

Tuple Fields of Union

0: Box<UnionTypeValue<R>>

Member(Box<MemberValue<R>>)

A attribute type value.

Tuple Fields of Member

0: Box<MemberValue<R>>

OptimizedOut

The value is optimized away.

LocationOutOfRange

The variable has no location currently but had or will have one. Note that the location can be a constant stored in the DWARF stack.

ZeroSize

The value is size 0 bits.

Implementations

impl<R: Reader<Offset = usize>> EvaluatorValue<R>

pub fn to_value(self) -> Option<BaseTypeValue>

Will return this value as a BaseTypeValue struct if possible.

pub fn get_type(&self) -> String

Will return the type of this value as a String.

pub fn get_variable_information(self) -> Vec<ValueInformation>

Will return a Vec of location and unparsed value infromation about the value.

pub fn evaluate_variable_with_type<M: MemoryAccess>(
    dwarf: &Dwarf<R>,
    registers: &Registers,
    mem: &mut M,
    pieces: &Vec<Piece<R>>,
    unit_offset: UnitSectionOffset,
    die_offset: UnitOffset
) -> Result<EvaluatorValue<R>>

Evaluate a list of Pieces into a value and parse it to the given type.

Description:

• dwarf - A reference to gimli-rs Dwarf struct.
• registers - A register struct for accessing the register values.
• mem - A struct for accessing the memory of the debug target.
• pieces - A list of gimli-rs pieces containing the location information..
• unit_offset - A offset to the Unit which contains the given type DIE.
• die_offset - A offset to the DIE that contains the type of the value.

This function will use the location information in the pieces parameter to read the values and parse it to the given type.

pub fn evaluate_variable<M: MemoryAccess>(
    registers: &Registers,
    mem: &mut M,
    pieces: &Vec<Piece<R>>
) -> Result<EvaluatorValue<R>>

This function will evaluate the given pieces into a unsigned 32 bit integer.

Description:

• registers - A register struct for accessing the register values.
• mem - A struct for accessing the memory of the debug target.
• pieces - A list of gimli-rs pieces containing the location information..

Trait Implementations

impl<R: Clone + Reader<Offset = usize>> Clone for EvaluatorValue<R>

fn clone(&self) -> EvaluatorValue<R>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<R: Debug + Reader<Offset = usize>> Debug for EvaluatorValue<R>

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

Formats the value using the given formatter.

impl<R: Reader<Offset = usize>> Display for EvaluatorValue<R>

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

Formats the value using the given formatter.