Enum gimli::read::Error

#[non_exhaustive]
pub enum Error {
    Io,
    PcRelativePointerButSectionBaseIsUndefined,
    TextRelativePointerButTextBaseIsUndefined,
    DataRelativePointerButDataBaseIsUndefined,
    FuncRelativePointerInBadContext,
    CannotParseOmitPointerEncoding,
    BadUnsignedLeb128,
    BadSignedLeb128,
    AbbreviationTagZero,
    AttributeFormZero,
    BadHasChildren,
    BadLength,
    UnknownForm(DwForm),
    ExpectedZero,
    DuplicateAbbreviationCode,
    DuplicateArange,
    UnknownReservedLength,
    UnknownVersion(u64),
    UnknownAbbreviation(u64),
    UnexpectedEof(ReaderOffsetId),
    UnexpectedNull,
    UnknownStandardOpcode(DwLns),
    UnknownExtendedOpcode(DwLne),
    UnknownLocListsEntry(DwLle),
    UnknownRangeListsEntry(DwRle),
    UnsupportedAddressSize(u8),
    UnsupportedOffsetSize(u8),
    UnsupportedFieldSize(u8),
    MinimumInstructionLengthZero,
    MaximumOperationsPerInstructionZero,
    LineRangeZero,
    OpcodeBaseZero,
    BadUtf8,
    NotCieId,
    NotCiePointer,
    NotFdePointer,
    BadBranchTarget(u64),
    InvalidPushObjectAddress,
    NotEnoughStackItems,
    TooManyIterations,
    InvalidExpression(DwOp),
    UnsupportedEvaluation,
    InvalidPiece,
    InvalidExpressionTerminator(u64),
    DivisionByZero,
    TypeMismatch,
    IntegralTypeRequired,
    UnsupportedTypeOperation,
    InvalidShiftExpression,
    InvalidDerefSize(u8),
    UnknownCallFrameInstruction(DwCfa),
    InvalidAddressRange,
    AddressOverflow,
    CfiInstructionInInvalidContext,
    PopWithEmptyStack,
    NoUnwindInfoForAddress,
    UnsupportedOffset,
    UnknownPointerEncoding(DwEhPe),
    NoEntryAtGivenOffset,
    OffsetOutOfBounds,
    UnknownAugmentation,
    UnsupportedPointerEncoding,
    UnsupportedRegister(u64),
    TooManyRegisterRules,
    StackFull,
    VariableLengthSearchTable,
    UnsupportedUnitType,
    UnsupportedAddressIndex,
    UnsupportedSegmentSize,
    MissingUnitDie,
    UnsupportedAttributeForm,
    MissingFileEntryFormatPath,
    ExpectedStringAttributeValue,
    InvalidImplicitConst,
    InvalidIndexSectionCount,
    InvalidIndexSlotCount,
    InvalidIndexRow,
    UnknownIndexSection(DwSect),
    UnknownIndexSectionV2(DwSectV2),
}

An error that occurred when parsing.

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.

Io

An I/O error occurred while reading.

PcRelativePointerButSectionBaseIsUndefined

Found a PC relative pointer, but the section base is undefined.

TextRelativePointerButTextBaseIsUndefined

Found a .text relative pointer, but the .text base is undefined.

DataRelativePointerButDataBaseIsUndefined

Found a data relative pointer, but the data base is undefined.

FuncRelativePointerInBadContext

Found a function relative pointer in a context that does not have a function base.

CannotParseOmitPointerEncoding

Cannot parse a pointer with a DW_EH_PE_omit encoding.

BadUnsignedLeb128

An error parsing an unsigned LEB128 value.

BadSignedLeb128

An error parsing a signed LEB128 value.

AbbreviationTagZero

An abbreviation declared that its tag is zero, but zero is reserved for null records.

AttributeFormZero

An attribute specification declared that its form is zero, but zero is reserved for null records.

BadHasChildren

The abbreviation’s has-children byte was not one of DW_CHILDREN_{yes,no}.

BadLength

The specified length is impossible.

UnknownForm(DwForm)

Found an unknown DW_FORM_* type.

ExpectedZero

Expected a zero, found something else.

DuplicateAbbreviationCode

Found an abbreviation code that has already been used.

DuplicateArange

Found a duplicate arange.

UnknownReservedLength

Found an unknown reserved length value.

UnknownVersion(u64)

Found an unknown DWARF version.

UnknownAbbreviation(u64)

Found a record with an unknown abbreviation code.

UnexpectedEof(ReaderOffsetId)

Hit the end of input before it was expected.

UnexpectedNull

Read a null entry before it was expected.

UnknownStandardOpcode(DwLns)

Found an unknown standard opcode.

UnknownExtendedOpcode(DwLne)

Found an unknown extended opcode.

UnknownLocListsEntry(DwLle)

Found an unknown location-lists format.

UnknownRangeListsEntry(DwRle)

Found an unknown range-lists format.

UnsupportedAddressSize(u8)

The specified address size is not supported.

UnsupportedOffsetSize(u8)

The specified offset size is not supported.

UnsupportedFieldSize(u8)

The specified field size is not supported.

MinimumInstructionLengthZero

The minimum instruction length must not be zero.

MaximumOperationsPerInstructionZero

The maximum operations per instruction must not be zero.

LineRangeZero

The line range must not be zero.

OpcodeBaseZero

The opcode base must not be zero.

BadUtf8

Found an invalid UTF-8 string.

NotCieId

Expected to find the CIE ID, but found something else.

NotCiePointer

Expected to find a pointer to a CIE, but found the CIE ID instead.

NotFdePointer

Expected to find a pointer to an FDE, but found a CIE instead.

BadBranchTarget(u64)

Invalid branch target for a DW_OP_bra or DW_OP_skip.

InvalidPushObjectAddress

DW_OP_push_object_address used but no address passed in.

NotEnoughStackItems

Not enough items on the stack when evaluating an expression.

TooManyIterations

Too many iterations to compute the expression.

InvalidExpression(DwOp)

An unrecognized operation was found while parsing a DWARF expression.

UnsupportedEvaluation

An unsupported operation was found while evaluating a DWARF expression.

InvalidPiece

The expression had a piece followed by an expression terminator without a piece.

InvalidExpressionTerminator(u64)

An expression-terminating operation was followed by something other than the end of the expression or a piece operation.

DivisionByZero

Division or modulus by zero when evaluating an expression.

TypeMismatch

An expression operation used mismatching types.

IntegralTypeRequired

An expression operation required an integral type but saw a floating point type.

UnsupportedTypeOperation

An expression operation used types that are not supported.

InvalidShiftExpression

The shift value in an expression must be a non-negative integer.

InvalidDerefSize(u8)

The size of a deref expression must not be larger than the size of an address.

UnknownCallFrameInstruction(DwCfa)

An unknown DW_CFA_* instruction.

InvalidAddressRange

The end of an address range was before the beginning.

AddressOverflow

An address calculation overflowed.

This is returned in cases where the address is expected to be larger than a previous address, but the calculation overflowed.

CfiInstructionInInvalidContext

Encountered a call frame instruction in a context in which it is not valid.

PopWithEmptyStack

When evaluating call frame instructions, found a DW_CFA_restore_state stack pop instruction, but the stack was empty, and had nothing to pop.

NoUnwindInfoForAddress

Do not have unwind info for the given address.

UnsupportedOffset

An offset value was larger than the maximum supported value.

UnknownPointerEncoding(DwEhPe)

The given pointer encoding is either unknown or invalid.

NoEntryAtGivenOffset

Did not find an entry at the given offset.

OffsetOutOfBounds

The given offset is out of bounds.

UnknownAugmentation

Found an unknown CFI augmentation.

UnsupportedPointerEncoding

We do not support the given pointer encoding yet.

UnsupportedRegister(u64)

Registers larger than u16 are not supported.

TooManyRegisterRules

The CFI program defined more register rules than we have storage for.

StackFull

Attempted to push onto the CFI or evaluation stack, but it was already at full capacity.

VariableLengthSearchTable

The .eh_frame_hdr binary search table claims to be variable-length encoded, which makes binary search impossible.

UnsupportedUnitType

The DW_UT_* value for this unit is not supported yet.

UnsupportedAddressIndex

Ranges using AddressIndex are not supported yet.

UnsupportedSegmentSize

Nonzero segment selector sizes aren’t supported yet.

MissingUnitDie

A compilation unit or type unit is missing its top level DIE.

UnsupportedAttributeForm

A DIE attribute used an unsupported form.

MissingFileEntryFormatPath

Missing DW_LNCT_path in file entry format.

ExpectedStringAttributeValue

Expected an attribute value to be a string form.

InvalidImplicitConst

DW_FORM_implicit_const used in an invalid context.

InvalidIndexSectionCount

Invalid section count in .dwp index.

InvalidIndexSlotCount

Invalid slot count in .dwp index.

InvalidIndexRow

Invalid hash row in .dwp index.

UnknownIndexSection(DwSect)

Unknown section type in .dwp index.

UnknownIndexSectionV2(DwSectV2)

Unknown section type in version 2 .dwp index.

Implementations

impl Error

pub fn description(&self) -> &str

A short description of the error.

Trait Implementations

impl Clone for Error

fn clone(&self) -> Error

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Error

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

Formats the value using the given formatter.

impl Display for Error

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

Formats the value using the given formatter.

impl Error for Error

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<Error> for ConvertError

fn from(e: Error) -> Self

Converts to this type from the input type.

impl From<Error> for Error

fn from(_: Error) -> Self

Converts to this type from the input type.

impl PartialEq for Error

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

impl Eq for Error

impl StructuralPartialEq for Error