Struct Loader 

pub struct Loader<M = DefaultMmap, H = (), D = (), Tls = DefaultTlsResolver>
where
    M: Mmap,
    H: LoadHook,
    Tls: TlsResolver,
{ /* private fields */ }

The ELF object loader.

Loader is responsible for orchestrating the loading of ELF objects into memory. It supports customization through various with_* methods for memory mapping, hooks, user data, and TLS resolution.

Examples

use elf_loader::{Loader, input::ElfBinary};

let mut loader = Loader::new();
let bytes = std::fs::read("liba.so").unwrap();
let lib = loader.load_dylib(ElfBinary::new("liba.so", &bytes)).unwrap();

Implementations

impl<M, H, D, Tls> Loader<M, H, D, Tls>

where M: Mmap, H: LoadHook, D: Default, Tls: TlsResolver,

pub fn load_dylib<'a, I>(&mut self, input: I) -> Result<RawDylib<D>>

where I: IntoElfReader<'a>,

Loads a dynamic library into memory and prepares it for relocation.

Examples

use elf_loader::{Loader, input::ElfBinary};

let mut loader = Loader::new();
let bytes = &[]; // ELF file bytes
let lib = loader.load_dylib(ElfBinary::new("liba.so", bytes)).unwrap();

impl<M, H, D, Tls> Loader<M, H, D, Tls>

where M: Mmap, H: LoadHook, D: Default, Tls: TlsResolver,

pub fn load_exec<'a, I>(&mut self, input: I) -> Result<RawExec<D>>

where I: IntoElfReader<'a>,

Loads an executable file into memory and prepares it for relocation.

Examples

use elf_loader::{Loader, input::ElfBinary};

let mut loader = Loader::new();
let bytes = &[]; // ELF executable bytes
let exec = loader.load_exec(ElfBinary::new("my_exec", bytes)).unwrap();

impl<M, H, D, Tls> Loader<M, H, D, Tls>

where M: Mmap, H: LoadHook, D: Default + 'static, Tls: TlsResolver,

pub fn load_object<'a, I>(&mut self, input: I) -> Result<RawObject<D>>

where I: IntoElfReader<'a>,

Loads a relocatable object file into memory and prepares it for relocation.

Examples

use elf_loader::{Loader, input::ElfBinary};

let mut loader = Loader::new();
let bytes = &[]; // Relocatable ELF bytes
let rel = loader.load_object(ElfBinary::new("liba.o", bytes)).unwrap();

impl<M: Mmap, H: LoadHook, D: Default + 'static> Loader<M, H, D>

pub fn load<'a, I>(&mut self, input: I) -> Result<RawElf<D>>

where I: IntoElfReader<'a>,

Load an ELF file into memory

Arguments

• object - The ELF object to load

Returns

• Ok(Elf) - The loaded ELF file
• Err(Error) - If loading fails

impl Loader<DefaultMmap, (), (), ()>

pub fn new() -> Self

Creates a new Loader with default settings.

impl<M, H, D, Tls> Loader<M, H, D, Tls>

where H: LoadHook, M: Mmap, D: 'static, Tls: TlsResolver,

pub fn with_init<F>(self, init_fn: F) -> Self

where F: LifecycleHandler + 'static,

Sets the initialization function handler.

This handler is responsible for calling the initialization functions (e.g., .init and .init_array) of the loaded ELF object.

Note: glibc passes argc, argv, and envp to functions in .init_array as a non-standard extension.

pub fn with_fini<F>(self, fini_fn: F) -> Self

where F: LifecycleHandler + 'static,

Sets the finalization function handler.

This handler is responsible for calling the finalization functions (e.g., .fini and .fini_array) of the loaded ELF object.

pub fn with_context<NewD>(self) -> Loader<M, H, NewD, Tls>

where NewD: Default + 'static,

Consumes the current loader and returns a new one with the specified context data type.

pub fn with_context_loader<NewD>( self, loader: impl Fn(&UserDataLoaderContext<'_>) -> NewD + 'static, ) -> Loader<M, H, NewD, Tls>

where NewD: 'static,

Consumes the current loader and returns a new one with the specified user data generator.

pub fn with_hook<NewHook>(self, hook: NewHook) -> Loader<M, NewHook, D, Tls>

where NewHook: LoadHook,

Consumes the current loader and returns a new one with the specified hook.

pub fn with_mmap<NewMmap: Mmap>(self) -> Loader<NewMmap, H, D, Tls>

Returns a new loader with a custom Mmap implementation.

pub fn with_tls_resolver<NewTls>(self) -> Loader<M, H, D, NewTls>

where NewTls: TlsResolver,

Consumes the current loader and returns a new one with the specified TLS resolver.

pub fn with_default_tls_resolver(self) -> Loader<M, H, D, DefaultTlsResolver>

Consumes the current loader and returns a new one with the default TLS resolver.

pub fn with_static_tls(self, enabled: bool) -> Self

Sets whether to force static TLS for all loaded modules.

pub fn read_ehdr(&mut self, object: &mut impl ElfReader) -> Result<ElfHeader>

Reads the ELF header.

pub fn read_phdr( &mut self, object: &mut impl ElfReader, ehdr: &ElfHeader, ) -> Result<Option<&[ElfPhdr]>>

Reads the program header table.