Enum ModelError 

#[non_exhaustive]
pub enum ModelError {
    Section {
        section: SectionId,
        problem: SectionProblem,
    },
    Symbol {
        symbol: SymbolId,
        problem: SymbolProblem,
    },
    Relocation {
        section: SectionId,
        index: usize,
        problem: RelocationProblem,
    },
    SectionsOverlap {
        first: SectionId,
        second: SectionId,
    },
    EntryNotExecutable {
        entry: u64,
    },
    UnknownSection {
        section: SectionId,
    },
    InvalidAlignment {
        align: u64,
    },
    AppendToBss,
    SizeOverflow,
    TooManyItems,
}

A rule of the object model that an Object breaks, from Object::validate, from the builders on Section, or from a reader whose input decodes to an invalid model.

The enum is #[non_exhaustive]: match it with a wildcard arm.

Examples

use object_lang::{Architecture, ModelError, Object, Symbol, SymbolProblem, Binding};

let mut obj = Object::relocatable(Architecture::X86_64);
let sym = obj.add_symbol(Symbol::undefined("x").with_binding(Binding::Local));
assert_eq!(
    obj.validate(),
    Err(ModelError::Symbol { symbol: sym, problem: SymbolProblem::LocalUndefined }),
);

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.

Section

A section breaks a rule.

Fields

section: SectionId

The section.

problem: SectionProblem

The rule it breaks.

Symbol

A symbol breaks a rule.

Fields

symbol: SymbolId

The symbol.

problem: SymbolProblem

The rule it breaks.

Relocation

A relocation breaks a rule.

Fields

section: SectionId

The section the relocation patches.

index: usize

The relocation’s position in that section’s relocations.

problem: RelocationProblem

The rule it breaks.

SectionsOverlap

Two loadable sections of an executable overlap in memory.

Fields

first: SectionId

The section at the lower address.

second: SectionId

The section that starts inside it.

EntryNotExecutable

An executable’s entry point is not inside an executable section.

Fields

entry: u64

The entry address.

UnknownSection

A section id that the object does not have, passed to Object::add_relocation.

Fields

section: SectionId

The id.

InvalidAlignment

An alignment that is zero or not a power of two, passed to Section::append or Section::reserve.

Fields

align: u64

The alignment.

AppendToBss

Section::append on a Bss section, which holds no bytes; use reserve.

SizeOverflow

A section would grow past the 64-bit size range or past available memory.

TooManyItems

The object holds more sections or symbols than ids can number (2³¹ − 1).

Trait Implementations

impl Clone for ModelError

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ModelError

impl Debug for ModelError

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

Formats the value using the given formatter.

impl Display for ModelError

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

Formats the value using the given formatter.

impl Eq for ModelError

impl Error for ModelError

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<ModelError> for WriteError

fn from(err: ModelError) -> Self

Converts to this type from the input type.

impl From<ModelError> for ReadError

fn from(err: ModelError) -> Self

Converts to this type from the input type.

impl Hash for ModelError

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ModelError

fn eq(&self, other: &Self) -> bool

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for ModelError