Enum gimli::read::CallFrameInstruction

#[non_exhaustive]
pub enum CallFrameInstruction<R: Reader> {
    SetLoc {
        address: u64,
    },
    AdvanceLoc {
        delta: u32,
    },
    DefCfa {
        register: Register,
        offset: u64,
    },
    DefCfaSf {
        register: Register,
        factored_offset: i64,
    },
    DefCfaRegister {
        register: Register,
    },
    DefCfaOffset {
        offset: u64,
    },
    DefCfaOffsetSf {
        factored_offset: i64,
    },
    DefCfaExpression {
        expression: Expression<R>,
    },
    Undefined {
        register: Register,
    },
    SameValue {
        register: Register,
    },
    Offset {
        register: Register,
        factored_offset: u64,
    },
    OffsetExtendedSf {
        register: Register,
        factored_offset: i64,
    },
    ValOffset {
        register: Register,
        factored_offset: u64,
    },
    ValOffsetSf {
        register: Register,
        factored_offset: i64,
    },
    Register {
        dest_register: Register,
        src_register: Register,
    },
    Expression {
        register: Register,
        expression: Expression<R>,
    },
    ValExpression {
        register: Register,
        expression: Expression<R>,
    },
    Restore {
        register: Register,
    },
    RememberState,
    RestoreState,
    ArgsSize {
        size: u64,
    },
    NegateRaState,
    Nop,
}

A parsed call frame instruction.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

SetLoc

1. DW_CFA_set_loc

The DW_CFA_set_loc instruction takes a single operand that represents a target address. The required action is to create a new table row using the specified address as the location. All other values in the new row are initially identical to the current row. The new location value is always greater than the current one. If the segment_size field of this FDE’s CIE is non- zero, the initial location is preceded by a segment selector of the given length.

Fields

address: u64

The target address.

AdvanceLoc

The AdvanceLoc instruction is used for all of DW_CFA_advance_loc and DW_CFA_advance_loc{1,2,4}.

2. DW_CFA_advance_loc

The DW_CFA_advance instruction takes a single operand (encoded with the opcode) that represents a constant delta. The required action is to create a new table row with a location value that is computed by taking the current entry’s location value and adding the value of delta * code_alignment_factor. All other values in the new row are initially identical to the current row.

Fields

delta: u32

The delta to be added to the current address.

DefCfa

1. DW_CFA_def_cfa

The DW_CFA_def_cfa instruction takes two unsigned LEB128 operands representing a register number and a (non-factored) offset. The required action is to define the current CFA rule to use the provided register and offset.

Fields

register: Register

The target register’s number.

offset: u64

The non-factored offset.

DefCfaSf

2. DW_CFA_def_cfa_sf

The DW_CFA_def_cfa_sf instruction takes two operands: an unsigned LEB128 value representing a register number and a signed LEB128 factored offset. This instruction is identical to DW_CFA_def_cfa except that the second operand is signed and factored. The resulting offset is factored_offset * data_alignment_factor.

Fields

register: Register

The target register’s number.

factored_offset: i64

The factored offset.

DefCfaRegister

3. DW_CFA_def_cfa_register

The DW_CFA_def_cfa_register instruction takes a single unsigned LEB128 operand representing a register number. The required action is to define the current CFA rule to use the provided register (but to keep the old offset). This operation is valid only if the current CFA rule is defined to use a register and offset.

Fields

register: Register

The target register’s number.

DefCfaOffset

4. DW_CFA_def_cfa_offset

The DW_CFA_def_cfa_offset instruction takes a single unsigned LEB128 operand representing a (non-factored) offset. The required action is to define the current CFA rule to use the provided offset (but to keep the old register). This operation is valid only if the current CFA rule is defined to use a register and offset.

Fields

offset: u64

The non-factored offset.

DefCfaOffsetSf

5. DW_CFA_def_cfa_offset_sf

The DW_CFA_def_cfa_offset_sf instruction takes a signed LEB128 operand representing a factored offset. This instruction is identical to DW_CFA_def_cfa_offset except that the operand is signed and factored. The resulting offset is factored_offset * data_alignment_factor. This operation is valid only if the current CFA rule is defined to use a register and offset.

Fields

factored_offset: i64

The factored offset.

DefCfaExpression

6. DW_CFA_def_cfa_expression

The DW_CFA_def_cfa_expression instruction takes a single operand encoded as a DW_FORM_exprloc value representing a DWARF expression. The required action is to establish that expression as the means by which the current CFA is computed.

Fields

expression: Expression<R>

The DWARF expression.

Undefined

1. DW_CFA_undefined

The DW_CFA_undefined instruction takes a single unsigned LEB128 operand that represents a register number. The required action is to set the rule for the specified register to “undefined.”

Fields

register: Register

The target register’s number.

SameValue

2. DW_CFA_same_value

The DW_CFA_same_value instruction takes a single unsigned LEB128 operand that represents a register number. The required action is to set the rule for the specified register to “same value.”

Fields

register: Register

The target register’s number.

Offset

The Offset instruction represents both DW_CFA_offset and DW_CFA_offset_extended.

3. DW_CFA_offset

The DW_CFA_offset instruction takes two operands: a register number (encoded with the opcode) and an unsigned LEB128 constant representing a factored offset. The required action is to change the rule for the register indicated by the register number to be an offset(N) rule where the value of N is factored offset * data_alignment_factor.

Fields

register: Register

The target register’s number.

factored_offset: u64

The factored offset.

OffsetExtendedSf

5. DW_CFA_offset_extended_sf

The DW_CFA_offset_extended_sf instruction takes two operands: an unsigned LEB128 value representing a register number and a signed LEB128 factored offset. This instruction is identical to DW_CFA_offset_extended except that the second operand is signed and factored. The resulting offset is factored_offset * data_alignment_factor.

Fields

register: Register

The target register’s number.

factored_offset: i64

The factored offset.

ValOffset

6. DW_CFA_val_offset

The DW_CFA_val_offset instruction takes two unsigned LEB128 operands representing a register number and a factored offset. The required action is to change the rule for the register indicated by the register number to be a val_offset(N) rule where the value of N is factored_offset * data_alignment_factor.

Fields

register: Register

The target register’s number.

factored_offset: u64

The factored offset.

ValOffsetSf

7. DW_CFA_val_offset_sf

The DW_CFA_val_offset_sf instruction takes two operands: an unsigned LEB128 value representing a register number and a signed LEB128 factored offset. This instruction is identical to DW_CFA_val_offset except that the second operand is signed and factored. The resulting offset is factored_offset * data_alignment_factor.

Fields

register: Register

The target register’s number.

factored_offset: i64

The factored offset.

Register

8. DW_CFA_register

The DW_CFA_register instruction takes two unsigned LEB128 operands representing register numbers. The required action is to set the rule for the first register to be register(R) where R is the second register.

Fields

dest_register: Register

The number of the register whose rule is being changed.

src_register: Register

The number of the register where the other register’s value can be found.

Expression

9. DW_CFA_expression

The DW_CFA_expression instruction takes two operands: an unsigned LEB128 value representing a register number, and a DW_FORM_block value representing a DWARF expression. The required action is to change the rule for the register indicated by the register number to be an expression(E) rule where E is the DWARF expression. That is, the DWARF expression computes the address. The value of the CFA is pushed on the DWARF evaluation stack prior to execution of the DWARF expression.

Fields

register: Register

The target register’s number.

expression: Expression<R>

The DWARF expression.

ValExpression

10. DW_CFA_val_expression

The DW_CFA_val_expression instruction takes two operands: an unsigned LEB128 value representing a register number, and a DW_FORM_block value representing a DWARF expression. The required action is to change the rule for the register indicated by the register number to be a val_expression(E) rule where E is the DWARF expression. That is, the DWARF expression computes the value of the given register. The value of the CFA is pushed on the DWARF evaluation stack prior to execution of the DWARF expression.

Fields

register: Register

The target register’s number.

expression: Expression<R>

The DWARF expression.

Restore

The Restore instruction represents both DW_CFA_restore and DW_CFA_restore_extended.

11. DW_CFA_restore

The DW_CFA_restore instruction takes a single operand (encoded with the opcode) that represents a register number. The required action is to change the rule for the indicated register to the rule assigned it by the initial_instructions in the CIE.

Fields

register: Register

The register to be reset.

RememberState

1. DW_CFA_remember_state

The DW_CFA_remember_state instruction takes no operands. The required action is to push the set of rules for every register onto an implicit stack.

RestoreState

2. DW_CFA_restore_state

The DW_CFA_restore_state instruction takes no operands. The required action is to pop the set of rules off the implicit stack and place them in the current row.

ArgsSize

DW_CFA_GNU_args_size

GNU Extension

The DW_CFA_GNU_args_size instruction takes an unsigned LEB128 operand representing an argument size. This instruction specifies the total of the size of the arguments which have been pushed onto the stack.

Fields

size: u64

The size of the arguments which have been pushed onto the stack

NegateRaState

DW_CFA_AARCH64_negate_ra_state

AArch64 Extension

The DW_CFA_AARCH64_negate_ra_state operation negates bit[0] of the RA_SIGN_STATE pseudo-register. It does not take any operands. The DW_CFA_AARCH64_negate_ra_state must not be mixed with other DWARF Register Rule Instructions on the RA_SIGN_STATE pseudo-register in one Common Information Entry (CIE) and Frame Descriptor Entry (FDE) program sequence.

Nop

1. DW_CFA_nop

The DW_CFA_nop instruction has no operands and no required actions. It is used as padding to make a CIE or FDE an appropriate size.

Trait Implementations

impl<R: Clone + Reader> Clone for CallFrameInstruction<R>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<R: Debug + Reader> Debug for CallFrameInstruction<R>

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

Formats the value using the given formatter.

impl<R: PartialEq + Reader> PartialEq for CallFrameInstruction<R>

fn eq(&self, other: &CallFrameInstruction<R>) -> bool

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<R: Eq + Reader> Eq for CallFrameInstruction<R>

impl<R: Reader> StructuralPartialEq for CallFrameInstruction<R>