[go: up one dir, main page]

Enum gimli::Operation[−][src]

pub enum Operation<R, Offset = usize> where
    R: Reader<Offset = Offset>,
    Offset: ReaderOffset,  {
    Deref {
        base_type: UnitOffset<Offset>,
        size: u8,
        space: bool,
    },
    Drop,
    Pick {
        index: u8,
    },
    Swap,
    Rot,
    Abs,
    And,
    Div,
    Minus,
    Mod,
    Mul,
    Neg,
    Not,
    Or,
    Plus,
    PlusConstant {
        value: u64,
    },
    Shl,
    Shr,
    Shra,
    Xor,
    Bra {
        target: R,
    },
    Eq,
    Ge,
    Gt,
    Le,
    Lt,
    Ne,
    Skip {
        target: R,
    },
    Literal {
        value: u64,
    },
    Register {
        register: u64,
    },
    RegisterOffset {
        register: u64,
        offset: i64,
        base_type: UnitOffset<Offset>,
    },
    FrameOffset {
        offset: i64,
    },
    Nop,
    PushObjectAddress,
    Call {
        offset: DieReference<Offset>,
    },
    TLS,
    CallFrameCFA,
    Piece {
        size_in_bits: u64,
        bit_offset: Option<u64>,
    },
    ImplicitValue {
        data: R,
    },
    StackValue,
    ImplicitPointer {
        value: DebugInfoOffset<Offset>,
        byte_offset: i64,
    },
    EntryValue {
        expression: R,
    },
    ParameterRef {
        offset: UnitOffset<Offset>,
    },
    TextRelativeOffset {
        offset: u64,
    },
    TypedLiteral {
        base_type: UnitOffset<Offset>,
        value: R,
    },
    Convert {
        base_type: UnitOffset<Offset>,
    },
    Reinterpret {
        base_type: UnitOffset<Offset>,
    },
}

A single decoded DWARF expression operation.

DWARF expression evaluation is done in two parts: first the raw bytes of the next part of the expression are decoded; and then the decoded operation is evaluated. This approach lets other consumers inspect the DWARF expression without reimplementing the decoding operation.

Multiple DWARF opcodes may decode into a single Operation. For example, both DW_OP_deref and DW_OP_xderef are represented using Operation::Deref.

Variants

A dereference operation.

Fields of Deref

The DIE of the base type or 0 to indicate the generic type

The size of the data to dereference.

True if the dereference operation takes an address space argument; false otherwise.

Drop an item from the stack.

Pick an item from the stack and push it on top of the stack. This operation handles DW_OP_pick, DW_OP_dup, and DW_OP_over.

Fields of Pick

The index, from the top of the stack, of the item to copy.

Swap the top two stack items.

Rotate the top three stack items.

Take the absolute value of the top of the stack.

Bitwise and of the top two values on the stack.

Divide the top two values on the stack.

Subtract the top two values on the stack.

Modulus of the top two values on the stack.

Multiply the top two values on the stack.

Negate the top of the stack.

Bitwise not of the top of the stack.

Bitwise or of the top two values on the stack.

Add the top two values on the stack.

Add a constant to the topmost value on the stack.

Fields of PlusConstant

The value to add.

Logical left shift of the 2nd value on the stack by the number of bits given by the topmost value on the stack.

Right shift of the 2nd value on the stack by the number of bits given by the topmost value on the stack.

Arithmetic left shift of the 2nd value on the stack by the number of bits given by the topmost value on the stack.

Bitwise xor of the top two values on the stack.

Branch to the target location if the top of stack is nonzero.

Fields of Bra

The target bytecode.

Compare the top two stack values for equality.

Compare the top two stack values using >=.

Compare the top two stack values using >.

Compare the top two stack values using <=.

Compare the top two stack values using <.

Compare the top two stack values using !=.

Unconditional branch to the target location.

Fields of Skip

The target bytecode.

Push a constant value on the stack. This handles multiple DWARF opcodes.

Fields of Literal

The value to push.

Indicate that this piece's location is in the given register.

Fields of Register

The register number.

Find the value of the given register, add the offset, and then push the resulting sum on the stack.

Fields of RegisterOffset

The register number.

The offset to add.

The DIE of the base type or 0 to indicate the generic type

Compute the frame base (using DW_AT_frame_base), add the given offset, and then push the resulting sum on the stack.

Fields of FrameOffset

The offset to add.

No operation.

Push the object address on the stack.

Evaluate a DWARF expression as a subroutine. The expression comes from the DW_AT_location attribute of the indicated DIE.

Fields of Call

The DIE to use.

Compute the address of a thread-local variable and push it on the stack.

Compute the call frame CFA and push it on the stack.

Terminate a piece.

Fields of Piece

The size of this piece in bits.

The bit offset of this piece. If None, then this piece was specified using DW_OP_piece and should start at the next byte boundary.

Represents DW_OP_implicit_value.

Fields of ImplicitValue

The implicit value to use.

Represents DW_OP_stack_value.

Represents DW_OP_implicit_pointer. The object is a pointer to a value which has no actual location, such as an implicit value or a stack value.

Fields of ImplicitPointer

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

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

Represents DW_OP_entry_value. Evaluate an expression at the entry to the current subprogram, and push it on the stack.

Fields of EntryValue

The expression to be evaluated.

Represents DW_OP_GNU_parameter_ref. This represents a parameter that was optimized out. The offset points to the definition of the parameter, and is matched to the DW_TAG_GNU_call_site_parameter in the caller that also points to the same definition of the parameter.

Fields of ParameterRef

The DIE to use.

An offset relative to the base of the .text section of the binary. e.g. for DW_OP_addr.

Fields of TextRelativeOffset

The offfset to add.

Represents DW_OP_const_type.

Fields of TypedLiteral

The DIE of the base type

The value

Represents DW_OP_convert

Fields of Convert

The DIE of the base type

Represents DW_OP_reinterpret

Fields of Reinterpret

The DIE of the base type

Methods

impl<R, Offset> Operation<R, Offset> where
    R: Reader<Offset = Offset>,
    Offset: ReaderOffset, 
[src]

Parse a single DWARF expression operation.

This is useful when examining a DWARF expression for reasons other than direct evaluation.

bytes points to a the operation to decode. It should point into the same array as bytecode, which should be the entire expression.

Trait Implementations

impl<R: Debug, Offset: Debug> Debug for Operation<R, Offset> where
    R: Reader<Offset = Offset>,
    Offset: ReaderOffset, 
[src]

Formats the value using the given formatter. Read more

impl<R: Clone, Offset: Clone> Clone for Operation<R, Offset> where
    R: Reader<Offset = Offset>,
    Offset: ReaderOffset, 
[src]

Returns a copy of the value. Read more

Performs copy-assignment from source. Read more

impl<R: Copy, Offset: Copy> Copy for Operation<R, Offset> where
    R: Reader<Offset = Offset>,
    Offset: ReaderOffset, 
[src]

impl<R: PartialEq, Offset: PartialEq> PartialEq for Operation<R, Offset> where
    R: Reader<Offset = Offset>,
    Offset: ReaderOffset, 
[src]

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

This method tests for !=.

impl<R: Eq, Offset: Eq> Eq for Operation<R, Offset> where
    R: Reader<Offset = Offset>,
    Offset: ReaderOffset, 
[src]

Auto Trait Implementations

impl<R, Offset> Send for Operation<R, Offset> where
    Offset: Send,
    R: Send, 

impl<R, Offset> Sync for Operation<R, Offset> where
    Offset: Sync,
    R: Sync,