Struct ELF

pub struct ELF<T: SizeT> {
    pub ident: Ident,
    pub e_type: Type,
    pub machine: Machine,
    pub entry_point: T,
    pub segments: Vec<Segment<T>>,
    pub sections: Vec<Section<T>>,
    pub flags: u32,
    pub section_header_string_table_index: u16,
}

The ELF file itself. This what you will be using. Use Self::read() to read if from a file, Self::new() to construct it from scratch and Self::write() to write it to a file T generic can be u32 for ELF32 and u64 for ELF64

Fields

ident: Ident

An ident

e_type: Type

Identifies object file type

machine: Machine

Specifies target instruction set architecture

entry_point: T

This is the memory address of the entry point from where the process starts executing. Should be 0 if no entry point

segments: Vec<Segment<T>>

Segments/Program headers (Loaded when executed). Do not add them, offsets will probably mess up

sections: Vec<Section<T>>

Sections (When linking turned into segment). Do not add them, offsets will probably mess up

flags: u32

Flags, usually 0. Interpretation of this field depends on the target architecture

section_header_string_table_index: u16

Contains index of the section header table entry that contains the section names

Implementations

impl<T: SizeT> ELF<T>

pub fn new( ident: Ident, e_type: Type, machine: impl Into<Machine>, has_entry_point: bool, segments: Vec<SegmentTemplate<T>>, sections: Vec<Section<T>>, ) -> Result<Self>

Constructs a new ELF from scratch. To make an Ident you will need to call Ident::new() This is a simplified constructor:

• Assumes, that string table is the last section (if exists)
• Sets flags to 0
• If has_entry_point is true, entry point will be set to the start of the first segment
• Places segments continuously into memory, starting from address machine.text_region_address() + (T::ELF_HEADER_SIZE + T::SEGMENT_HEADER_SIZE * segments.len() + T::SECTION_HEADER_SIZE * sections.len()) % 0x1000 For more flexability you can do:

use orecc_elf::*;
dbg!(
    ELF::<u64> {
        ident: Ident::default(),
        e_type: Type::Exec,
        machine: Machine::X86_64,
        entry_point: 0xDEADBEEF,
        segments: Vec::new(),
        sections: Vec::new(),
        flags: 0,
        section_header_string_table_index: 0,
    }
);

pub fn write<W: Write + Seek>(&self, file: &mut W) -> Result<()>

Write an ELF to a file

pub fn read<R: Read + Seek>(file: &mut R) -> Result<Self>

Read an ELF from a file

pub fn read_remainder<R: Read>(file: &mut R, ident: Ident) -> Result<Self>

Read an ELF from a file when you already read Ident

Trait Implementations

impl<T: Clone + SizeT> Clone for ELF<T>

fn clone(&self) -> ELF<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + SizeT> Debug for ELF<T>

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

Formats the value using the given formatter.

impl<T: Hash + SizeT> Hash for ELF<T>

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<T: Ord + SizeT> Ord for ELF<T>

fn cmp(&self, other: &ELF<T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T: PartialEq + SizeT> PartialEq for ELF<T>

fn eq(&self, other: &ELF<T>) -> 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<T: PartialOrd + SizeT> PartialOrd for ELF<T>

fn partial_cmp(&self, other: &ELF<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: Eq + SizeT> Eq for ELF<T>

impl<T: SizeT> StructuralPartialEq for ELF<T>