Enum VariableValue 

pub enum VariableValue {
    Bytes(Vec<u8>),
    Other(Word),
    Numeric(Value),
}

Represents a variable value in one of several forms

VariableValue encapsulates the various ways a variable’s value might be represented, such as raw bytes, numeric values, or machine words. This allows the debugger to work with variables of different types and sizes.

Examples

use coreminer::variable::VariableValue;
use gimli::Value;

// Create a variable value from raw bytes
let bytes_value = VariableValue::Bytes(vec![0x01, 0x02, 0x03, 0x04]);

// Create a variable value from a machine word
let word_value = VariableValue::Other(0x123456789);

// Create a variable value from a DWARF numeric value
let numeric_value = VariableValue::Numeric(Value::U32(42));

// Convert a variable value to a u64
let value_as_u64 = bytes_value.to_u64();

Variants

Bytes(Vec<u8>)

Raw byte representation of a value

Other(Word)

Machine word representation of a value

Numeric(Value)

DWARF numeric value

Implementations

impl VariableValue

pub fn byte_size(&self) -> usize

Returns the size of the variable value in bytes

Returns

The size of the variable value in bytes

Examples

use coreminer::variable::VariableValue;
use gimli::Value;

let bytes_value = VariableValue::Bytes(vec![0x01, 0x02, 0x03, 0x04]);
assert_eq!(bytes_value.byte_size(), 4);

let word_value = VariableValue::Other(0x123456789);
assert_eq!(word_value.byte_size(), 8); // Assuming 64-bit (8-byte) words

let numeric_value = VariableValue::Numeric(Value::U32(42));
assert_eq!(numeric_value.byte_size(), 4);

pub fn to_u64(&self) -> u64

Converts the variable value to a u64

Returns

The variable value as a u64

Panics

This method will panic if self is a VariableValue::Bytes which has more bytes than a u64 can hold.

Examples

use coreminer::variable::VariableValue;
use gimli::Value;

let bytes_value = VariableValue::Bytes(vec![0x42, 0x00, 0x00, 0x00]);
assert_eq!(bytes_value.to_u64(), 0x42);

let word_value = VariableValue::Other(0x123456789);
assert_eq!(word_value.to_u64(), 0x123456789);

let numeric_value = VariableValue::Numeric(Value::U32(42));
assert_eq!(numeric_value.to_u64(), 42);

pub fn resize_to_bytes(&self, target_size: usize) -> Vec<u8>

Resizes a value to the specified number of bytes

Parameters

• target_size - The target size in bytes

Returns

A vector of bytes with the specified size

Panics

This method will panic if self is a VariableValue::Bytes which has more bytes than a u64 can hold.

Examples

use coreminer::variable::VariableValue;
use gimli::Value;

let value = VariableValue::Other(0x123456789);

// Resize to 4 bytes
let bytes = value.resize_to_bytes(4);
assert_eq!(bytes, vec![0x89, 0x67, 0x45, 0x23]);

// Resize to 2 bytes
let bytes = value.resize_to_bytes(2);
assert_eq!(bytes, vec![0x89, 0x67]);

Trait Implementations

impl Clone for VariableValue

fn clone(&self) -> VariableValue

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for VariableValue

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

Formats the value using the given formatter.

impl From<Value> for VariableValue

fn from(value: Value) -> Self

Converts to this type from the input type.

impl From<usize> for VariableValue

fn from(value: usize) -> Self

Converts to this type from the input type.

impl Serialize for VariableValue

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.