Enum gimli::read::value::Value

pub enum Value {
    Generic(u64),
    I8(i8),
    U8(u8),
    I16(i16),
    U16(u16),
    I32(i32),
    U32(u32),
    I64(i64),
    U64(u64),
    F32(f32),
    F64(f64),
}

The value of an entry on the DWARF stack.

Variants

Generic(u64)

A generic value, which is address-sized and of unspecified sign.

I8(i8)

A signed 8-bit integer value.

U8(u8)

An unsigned 8-bit integer value.

I16(i16)

A signed 16-bit integer value.

U16(u16)

An unsigned 16-bit integer value.

I32(i32)

A signed 32-bit integer value.

U32(u32)

An unsigned 32-bit integer value.

I64(i64)

A signed 64-bit integer value.

U64(u64)

An unsigned 64-bit integer value.

F32(f32)

A 32-bit floating point value.

F64(f64)

A 64-bit floating point value.

Implementations

impl Value

pub fn value_type(&self) -> ValueType

Return the ValueType corresponding to this Value.

pub fn parse<R: Reader>(value_type: ValueType, bytes: R) -> Result<Value>

Read a Value with the given value_type from a Reader.

pub fn to_u64(self, addr_mask: u64) -> Result<u64>

Convert a Value to a u64.

The ValueType of self must be integral. Values are sign extended if the source value is signed.

pub fn from_u64(value_type: ValueType, value: u64) -> Result<Value>

Create a Value with the given value_type from a u64 value.

The value_type may be integral or floating point. The result is truncated if the u64 value does not fit the bounds of the value_type.

fn from_f32(value_type: ValueType, value: f32) -> Result<Value>

Create a Value with the given value_type from a f32 value.

The value_type may be integral or floating point. The result is not defined if the f32 value does not fit the bounds of the value_type.

fn from_f64(value_type: ValueType, value: f64) -> Result<Value>

Create a Value with the given value_type from a f64 value.

The value_type may be integral or floating point. The result is not defined if the f64 value does not fit the bounds of the value_type.

pub fn convert(self, value_type: ValueType, addr_mask: u64) -> Result<Value>

Convert a Value to the given value_type.

When converting between integral types, the result is truncated if the source value does not fit the bounds of the value_type. When converting from floating point types, the result is not defined if the source value does not fit the bounds of the value_type.

This corresponds to the DWARF DW_OP_convert operation.

pub fn reinterpret(self, value_type: ValueType, addr_mask: u64) -> Result<Value>

Reinterpret the bits in a Value as the given value_type.

The source and result value types must have equal sizes.

This corresponds to the DWARF DW_OP_reinterpret operation.

pub fn abs(self, addr_mask: u64) -> Result<Value>

Perform an absolute value operation.

If the value type is Generic, then it is interpreted as a signed value.

This corresponds to the DWARF DW_OP_abs operation.

pub fn neg(self, addr_mask: u64) -> Result<Value>

Perform a negation operation.

If the value type is Generic, then it is interpreted as a signed value.

This corresponds to the DWARF DW_OP_neg operation.

pub fn add(self, rhs: Value, addr_mask: u64) -> Result<Value>

Perform an addition operation.

This operation requires matching types.

This corresponds to the DWARF DW_OP_plus operation.

pub fn sub(self, rhs: Value, addr_mask: u64) -> Result<Value>

Perform a subtraction operation.

This operation requires matching types.

This corresponds to the DWARF DW_OP_minus operation.

pub fn mul(self, rhs: Value, addr_mask: u64) -> Result<Value>

Perform a multiplication operation.

This operation requires matching types.

This corresponds to the DWARF DW_OP_mul operation.

pub fn div(self, rhs: Value, addr_mask: u64) -> Result<Value>

Perform a division operation.

This operation requires matching types. If the value type is Generic, then it is interpreted as a signed value.

This corresponds to the DWARF DW_OP_div operation.

pub fn rem(self, rhs: Value, addr_mask: u64) -> Result<Value>

Perform a remainder operation.

This operation requires matching integral types. If the value type is Generic, then it is interpreted as an unsigned value.

This corresponds to the DWARF DW_OP_mod operation.

pub fn not(self, addr_mask: u64) -> Result<Value>

Perform a bitwise not operation.

This operation requires matching integral types.

This corresponds to the DWARF DW_OP_not operation.

pub fn and(self, rhs: Value, addr_mask: u64) -> Result<Value>

Perform a bitwise and operation.

This operation requires matching integral types.

This corresponds to the DWARF DW_OP_and operation.

pub fn or(self, rhs: Value, addr_mask: u64) -> Result<Value>

Perform a bitwise or operation.

This operation requires matching integral types.

This corresponds to the DWARF DW_OP_or operation.

pub fn xor(self, rhs: Value, addr_mask: u64) -> Result<Value>

Perform a bitwise exclusive-or operation.

This operation requires matching integral types.

This corresponds to the DWARF DW_OP_xor operation.

fn shift_length(self) -> Result<u64>

Convert value to bit length suitable for a shift operation.

If the value is negative then an error is returned.

pub fn shl(self, rhs: Value, addr_mask: u64) -> Result<Value>

Perform a shift left operation.

This operation requires integral types. If the shift length exceeds the type size, then 0 is returned. If the shift length is negative then an error is returned.

This corresponds to the DWARF DW_OP_shl operation.

pub fn shr(self, rhs: Value, addr_mask: u64) -> Result<Value>

Perform a logical shift right operation.

This operation requires an unsigned integral type for the value. If the value type is Generic, then it is interpreted as an unsigned value.

This operation requires an integral type for the shift length. If the shift length exceeds the type size, then 0 is returned. If the shift length is negative then an error is returned.

This corresponds to the DWARF DW_OP_shr operation.

pub fn shra(self, rhs: Value, addr_mask: u64) -> Result<Value>

Perform an arithmetic shift right operation.

This operation requires a signed integral type for the value. If the value type is Generic, then it is interpreted as a signed value.

This operation requires an integral type for the shift length. If the shift length exceeds the type size, then 0 is returned for positive values, and -1 is returned for negative values. If the shift length is negative then an error is returned.

This corresponds to the DWARF DW_OP_shra operation.

pub fn eq(self, rhs: Value, addr_mask: u64) -> Result<Value>

Perform the == relational operation.

This operation requires matching integral types. If the value type is Generic, then it is interpreted as a signed value.

This corresponds to the DWARF DW_OP_eq operation.

pub fn ge(self, rhs: Value, addr_mask: u64) -> Result<Value>

Perform the >= relational operation.

This operation requires matching integral types. If the value type is Generic, then it is interpreted as a signed value.

This corresponds to the DWARF DW_OP_ge operation.

pub fn gt(self, rhs: Value, addr_mask: u64) -> Result<Value>

Perform the > relational operation.

This operation requires matching integral types. If the value type is Generic, then it is interpreted as a signed value.

This corresponds to the DWARF DW_OP_gt operation.

pub fn le(self, rhs: Value, addr_mask: u64) -> Result<Value>

Perform the `<= relational operation.

This operation requires matching integral types. If the value type is Generic, then it is interpreted as a signed value.

This corresponds to the DWARF DW_OP_le operation.

pub fn lt(self, rhs: Value, addr_mask: u64) -> Result<Value>

Perform the `< relational operation.

This operation requires matching integral types. If the value type is Generic, then it is interpreted as a signed value.

This corresponds to the DWARF DW_OP_lt operation.

pub fn ne(self, rhs: Value, addr_mask: u64) -> Result<Value>

Perform the `!= relational operation.

This operation requires matching integral types. If the value type is Generic, then it is interpreted as a signed value.

This corresponds to the DWARF DW_OP_ne operation.

Trait Implementations

impl Clone for Value

fn clone(&self) -> Value

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Value

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

Formats the value using the given formatter.

impl PartialEq for Value

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

impl StructuralPartialEq for Value