Enum gimli::read::LineInstruction

pub enum LineInstruction<R, Offset = <R as Reader>::Offset>
where
    R: Reader<Offset = Offset>,
    Offset: ReaderOffset,
{
    Special(u8),
    Copy,
    AdvancePc(u64),
    AdvanceLine(i64),
    SetFile(u64),
    SetColumn(u64),
    NegateStatement,
    SetBasicBlock,
    ConstAddPc,
    FixedAddPc(u16),
    SetPrologueEnd,
    SetEpilogueBegin,
    SetIsa(u64),
    UnknownStandard0(DwLns),
    UnknownStandard1(DwLns, u64),
    UnknownStandardN(DwLns, R),
    EndSequence,
    SetAddress(u64),
    DefineFile(FileEntry<R, Offset>),
    SetDiscriminator(u64),
    UnknownExtended(DwLne, R),
}

A parsed line number program instruction.

Variants

Special(u8)

6.2.5.1 Special Opcodes

Each ubyte special opcode has the following effect on the state machine:

1. Add a signed integer to the line register.

2. Modify the operation pointer by incrementing the address and op_index registers as described below.

3. Append a row to the matrix using the current values of the state machine registers.

4. Set the basic_block register to “false.”

5. Set the prologue_end register to “false.”

6. Set the epilogue_begin register to “false.”

7. Set the discriminator register to 0.

All of the special opcodes do those same seven things; they differ from one another only in what values they add to the line, address and op_index registers.

Copy

“LineInstruction::Copy appends a row to the matrix using the current values of the state machine registers. Then it sets the discriminator register to 0, and sets the basic_block, prologue_end and epilogue_begin registers to “false.””

AdvancePc(u64)

“The DW_LNS_advance_pc opcode takes a single unsigned LEB128 operand as the operation advance and modifies the address and op_index registers [the same as LineInstruction::Special]”

AdvanceLine(i64)

“The DW_LNS_advance_line opcode takes a single signed LEB128 operand and adds that value to the line register of the state machine.”

SetFile(u64)

“The DW_LNS_set_file opcode takes a single unsigned LEB128 operand and stores it in the file register of the state machine.”

SetColumn(u64)

“The DW_LNS_set_column opcode takes a single unsigned LEB128 operand and stores it in the column register of the state machine.”

NegateStatement

“The DW_LNS_negate_stmt opcode takes no operands. It sets the is_stmt register of the state machine to the logical negation of its current value.”

SetBasicBlock

“The DW_LNS_set_basic_block opcode takes no operands. It sets the basic_block register of the state machine to “true.””

ConstAddPc

The DW_LNS_const_add_pc opcode takes no operands. It advances the address and op_index registers by the increments corresponding to special opcode 255.

When the line number program needs to advance the address by a small amount, it can use a single special opcode, which occupies a single byte. When it needs to advance the address by up to twice the range of the last special opcode, it can use DW_LNS_const_add_pc followed by a special opcode, for a total of two bytes. Only if it needs to advance the address by more than twice that range will it need to use both DW_LNS_advance_pc and a special opcode, requiring three or more bytes.

FixedAddPc(u16)

The DW_LNS_fixed_advance_pc opcode takes a single uhalf (unencoded) operand and adds it to the address register of the state machine and sets the op_index register to 0. This is the only standard opcode whose operand is not a variable length number. It also does not multiply the operand by the minimum_instruction_length field of the header.

SetPrologueEnd

“LineInstruction::SetPrologueEnd sets the prologue_end register to “true”.”

SetEpilogueBegin

“LineInstruction::SetEpilogueBegin sets the epilogue_begin register to “true”.”

SetIsa(u64)

“The DW_LNS_set_isa opcode takes a single unsigned LEB128 operand and stores that value in the isa register of the state machine.”

UnknownStandard0(DwLns)

An unknown standard opcode with zero operands.

UnknownStandard1(DwLns, u64)

An unknown standard opcode with one operand.

UnknownStandardN(DwLns, R)

An unknown standard opcode with multiple operands.

EndSequence

LineInstruction::EndSequence sets the end_sequence register of the state machine to “true” and appends a row to the matrix using the current values of the state-machine registers. Then it resets the registers to the initial values specified above (see Section 6.2.2). Every line number program sequence must end with a DW_LNE_end_sequence instruction which creates a row whose address is that of the byte after the last target machine instruction of the sequence.

SetAddress(u64)

The DW_LNE_set_address opcode takes a single relocatable address as an operand. The size of the operand is the size of an address on the target machine. It sets the address register to the value given by the relocatable address and sets the op_index register to 0.

All of the other line number program opcodes that affect the address register add a delta to it. This instruction stores a relocatable value into it instead.

DefineFile(FileEntry<R, Offset>)

Defines a new source file in the line number program and appends it to the line number program header’s list of source files.

SetDiscriminator(u64)

“The DW_LNE_set_discriminator opcode takes a single parameter, an unsigned LEB128 integer. It sets the discriminator register to the new value.”

UnknownExtended(DwLne, R)

An unknown extended opcode and the slice of its unparsed operands.

Implementations

impl<R, Offset> LineInstruction<R, Offset>

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

fn parse<'header>( header: &'header LineProgramHeader<R>, input: &mut R, ) -> Result<LineInstruction<R>>

where R: 'header,

Trait Implementations

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

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

fn clone(&self) -> LineInstruction<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 LineInstruction<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 LineInstruction<R, Offset>

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

fn eq(&self, other: &LineInstruction<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 LineInstruction<R, Offset>

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

impl<R, Offset> Eq for LineInstruction<R, Offset>

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

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

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