Enum object::RelocationKind

#[non_exhaustive]
pub enum RelocationKind {
    Absolute,
    Relative,
    Got,
    GotRelative,
    GotBaseRelative,
    GotBaseOffset,
    PltRelative,
    ImageOffset,
    SectionOffset,
    SectionIndex,
    Elf(u32),
    MachO {
        value: u8,
        relative: bool,
    },
    Coff(u16),
    Xcoff(u8),
}

The operation used to calculate the result of the relocation.

The relocation descriptions use the following definitions. Note that these definitions probably don’t match any ELF ABI.

• A - The value of the addend.
• G - The address of the symbol’s entry within the global offset table.
• L - The address of the symbol’s entry within the procedure linkage table.
• P - The address of the place of the relocation.
• S - The address of the symbol.
• GotBase - The address of the global offset table.
• Image - The base address of the image.
• Section - The address of the section containing the symbol.

‘XxxRelative’ means ‘Xxx + A - P’. ‘XxxOffset’ means ‘S + A - Xxx’.

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.

Absolute

S + A

Relative

S + A - P

Got

G + A - GotBase

GotRelative

G + A - P

GotBaseRelative

GotBase + A - P

GotBaseOffset

S + A - GotBase

PltRelative

L + A - P

ImageOffset

S + A - Image

SectionOffset

S + A - Section

SectionIndex

The index of the section containing the symbol.

Elf(u32)

Some other ELF relocation. The value is dependent on the architecture.

MachO

Fields

value: u8

The relocation type.

relative: bool

Whether the relocation is relative to the place.

Some other Mach-O relocation. The value is dependent on the architecture.

Coff(u16)

Some other COFF relocation. The value is dependent on the architecture.

Xcoff(u8)

Some other XCOFF relocation.

Trait Implementations

impl Clone for RelocationKind

fn clone(&self) -> RelocationKind

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RelocationKind

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

Formats the value using the given formatter.

impl Hash for RelocationKind

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 RelocationKind

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

impl Eq for RelocationKind

impl StructuralEq for RelocationKind

impl StructuralPartialEq for RelocationKind