Enum gimli::read::op::Location

pub enum Location<R, Offset = <R as Reader>::Offset>
where
    R: Reader<Offset = Offset>,
    Offset: ReaderOffset,
{
    Empty,
    Register {
        register: Register,
    },
    Address {
        address: u64,
    },
    Value {
        value: Value,
    },
    Bytes {
        value: R,
    },
    ImplicitPointer {
        value: DebugInfoOffset<Offset>,
        byte_offset: i64,
    },
}

A single location of a piece of the result of a DWARF expression.

Variants

Empty

The piece is empty. Ordinarily this means the piece has been optimized away.

Register

The piece is found in a register.

Fields

register: Register

The register number.

Address

The piece is found in memory.

Fields

address: u64

The address.

Value

The piece has no location but its value is known.

Fields

value: Value

The value.

Bytes

The piece is represented by some constant bytes.

Fields

value: R

The value.

ImplicitPointer

The piece is a pointer to a value which has no actual location.

Fields

value: DebugInfoOffset<Offset>

The .debug_info offset of the value that this is an implicit pointer into.

byte_offset: i64

The byte offset into the value that the implicit pointer points to.

Implementations

impl<R, Offset> Location<R, Offset>

where R: Reader<Offset = Offset>, Offset: ReaderOffset,

pub fn is_empty(&self) -> bool

Return true if the piece is empty.

Trait Implementations

impl<R, Offset> Clone for Location<R, Offset>

where R: Reader<Offset = Offset> + Clone, Offset: ReaderOffset + Clone,

fn clone(&self) -> Location<R, Offset>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<R, Offset> Debug for Location<R, Offset>

where R: Reader<Offset = Offset> + Debug, Offset: ReaderOffset + Debug,

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

Formats the value using the given formatter.

impl<R, Offset> PartialEq for Location<R, Offset>

where R: Reader<Offset = Offset> + PartialEq, Offset: ReaderOffset + PartialEq,

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

where R: Reader<Offset = Offset> + Copy, Offset: ReaderOffset + Copy,

impl<R, Offset> StructuralPartialEq for Location<R, Offset>

where R: Reader<Offset = Offset>, Offset: ReaderOffset,