Struct SectionHeader

pub struct SectionHeader { /* private fields */ }

Represents a section in the section table.

Implementations

impl Header

pub const SIZE_IN_BYTES: u16 = 40u16

Size of a section header entry

pub const SHT_NULL: u32 = 0u32

Section header table entry unused

pub const SHT_PROGBITS: u32 = 1u32

Program data

pub const SHT_SYMTAB: u32 = 2u32

Symbol table

pub const SHT_STRTAB: u32 = 3u32

String table

pub const SHT_RELA: u32 = 4u32

Relocation entries with addends

pub const SHT_HASH: u32 = 5u32

Symbol hash table

pub const SHT_DYNAMIC: u32 = 6u32

Dynamic linking information

pub const SHT_NOTE: u32 = 7u32

Notes

pub const SHT_NOBITS: u32 = 8u32

Program space with no data (bss)

pub const SHT_REL: u32 = 9u32

Relocation data, no addends

pub const SHT_DYNSYM: u32 = 11u32

Dynamic linker symbol table

pub const SHT_INIT_ARRAY: u32 = 14u32

Array of constructors

pub const SHT_FINI_ARRAY: u32 = 15u32

Array of destructors

pub const SHT_PREINIT_ARRAY: u32 = 16u32

Array of pre-constructors

pub const SHT_GROUP: u32 = 17u32

Section group

pub const SHT_SYMTAB_SHNDX: u32 = 18u32

Extended section indicies

pub fn new<DS>(loader: &Loader<DS>, idx: u16) -> Result<Self, Error<DS::Error>>

where DS: Source,

Create a new section header.

pub fn sh_name_offset(&self) -> u32

Return the sh_name_offset field

pub fn sh_name<'a, DS: Source>( &self, loader: &Loader<DS>, buffer: &'a mut [u8], ) -> Result<&'a str, Error<DS::Error>>

Get the string name for this section.

Examples found in repository

examples/load.rs (line 91)

fn main() -> Result<(), Error> {
    let mut args = std::env::args_os();
    let _example_name = args.next();
    let filename = args.next().ok_or(Error::MissingArgument)?;
    let data = std::fs::read(&filename)?;
    let loader = ldr::Loader::new(&data[..])?;

    println!("Loaded ELF {}", filename.to_string_lossy());
    println!("Entry Point: 0x{:08x}", loader.e_entry());

    let segment_start_addr = loader.segment_start_offset();
    let mut total_ram_used = 0;
    for (idx, ph) in loader.iter_program_headers().enumerate() {
        let ph = ph.expect("PH loaded OK");
        let p_type = match ph.p_type() {
            ldr::ProgramHeader::PT_NULL => "PT_NULL",
            ldr::ProgramHeader::PT_LOAD => "PT_LOAD",
            ldr::ProgramHeader::PT_DYNAMIC => "PT_DYNAMIC",
            ldr::ProgramHeader::PT_INTERP => "PT_INTERP",
            ldr::ProgramHeader::PT_NOTE => "PT_NOTE",
            ldr::ProgramHeader::PT_SHLIB => "PT_SHLIB",
            ldr::ProgramHeader::PT_PHDR => "PT_PHDR",
            ldr::ProgramHeader::PT_TLS => "PT_TLS",
            ldr::ProgramHeader::PT_GNU_STACK => "PT_GNU_STACK",
            _ => "PT_???",
        };

        let ignored = if ph.p_offset() >= segment_start_addr {
            "OK"
        } else {
            "Ignored"
        };

        let data_bytes = ph.p_filesz();
        let zero_bytes = ph.p_memsz() - data_bytes;
        let load_addr = ph.p_paddr();

        total_ram_used += ph.p_memsz();

        println!("PH {idx:02}: p_type = {p_type:12}, data_bytes=0x{data_bytes:04x}, zero_bytes=0x{zero_bytes:04x}, load_addr=0x{load_addr:08x} ({ignored})");
    }

    println!("Total RAM used: {total_ram_used} bytes");

    for (idx, sh) in loader.iter_section_headers().enumerate() {
        let sh = sh.expect("SH loaded OK");
        let sh_type = match sh.sh_type() {
            ldr::SectionHeader::SHT_NULL => "SHT_NULL",
            ldr::SectionHeader::SHT_PROGBITS => "SHT_PROGBITS",
            ldr::SectionHeader::SHT_SYMTAB => "SHT_SYMTAB",
            ldr::SectionHeader::SHT_STRTAB => "SHT_STRTAB",
            ldr::SectionHeader::SHT_RELA => "SHT_RELA",
            ldr::SectionHeader::SHT_HASH => "SHT_HASH",
            ldr::SectionHeader::SHT_DYNAMIC => "SHT_DYNAMIC",
            ldr::SectionHeader::SHT_NOTE => "SHT_NOTE",
            ldr::SectionHeader::SHT_NOBITS => "SHT_NOBITS",
            ldr::SectionHeader::SHT_REL => "SHT_REL",
            ldr::SectionHeader::SHT_DYNSYM => "SHT_DYNSYM",
            ldr::SectionHeader::SHT_INIT_ARRAY => "SHT_INIT_ARRAY",
            ldr::SectionHeader::SHT_FINI_ARRAY => "SHT_FINI_ARRAY",
            ldr::SectionHeader::SHT_PREINIT_ARRAY => "SHT_PREINIT_ARRAY",
            ldr::SectionHeader::SHT_GROUP => "SHT_GROUP",
            ldr::SectionHeader::SHT_SYMTAB_SHNDX => "SHT_SYMTAB_SHNDX",
            _ => "???",
        };

        let mut buffer = [0u8; 64];
        let name = sh.sh_name(&loader, &mut buffer).unwrap_or("E_TOO_LONG");
        println!("SH {idx:02}: {sh:08x?} ({sh_type}, {name:?})");
    }

    Ok(())
}

pub fn sh_type(&self) -> u32

Return the sh_type field

Examples found in repository

examples/load.rs (line 70)

fn main() -> Result<(), Error> {
    let mut args = std::env::args_os();
    let _example_name = args.next();
    let filename = args.next().ok_or(Error::MissingArgument)?;
    let data = std::fs::read(&filename)?;
    let loader = ldr::Loader::new(&data[..])?;

    println!("Loaded ELF {}", filename.to_string_lossy());
    println!("Entry Point: 0x{:08x}", loader.e_entry());

    let segment_start_addr = loader.segment_start_offset();
    let mut total_ram_used = 0;
    for (idx, ph) in loader.iter_program_headers().enumerate() {
        let ph = ph.expect("PH loaded OK");
        let p_type = match ph.p_type() {
            ldr::ProgramHeader::PT_NULL => "PT_NULL",
            ldr::ProgramHeader::PT_LOAD => "PT_LOAD",
            ldr::ProgramHeader::PT_DYNAMIC => "PT_DYNAMIC",
            ldr::ProgramHeader::PT_INTERP => "PT_INTERP",
            ldr::ProgramHeader::PT_NOTE => "PT_NOTE",
            ldr::ProgramHeader::PT_SHLIB => "PT_SHLIB",
            ldr::ProgramHeader::PT_PHDR => "PT_PHDR",
            ldr::ProgramHeader::PT_TLS => "PT_TLS",
            ldr::ProgramHeader::PT_GNU_STACK => "PT_GNU_STACK",
            _ => "PT_???",
        };

        let ignored = if ph.p_offset() >= segment_start_addr {
            "OK"
        } else {
            "Ignored"
        };

        let data_bytes = ph.p_filesz();
        let zero_bytes = ph.p_memsz() - data_bytes;
        let load_addr = ph.p_paddr();

        total_ram_used += ph.p_memsz();

        println!("PH {idx:02}: p_type = {p_type:12}, data_bytes=0x{data_bytes:04x}, zero_bytes=0x{zero_bytes:04x}, load_addr=0x{load_addr:08x} ({ignored})");
    }

    println!("Total RAM used: {total_ram_used} bytes");

    for (idx, sh) in loader.iter_section_headers().enumerate() {
        let sh = sh.expect("SH loaded OK");
        let sh_type = match sh.sh_type() {
            ldr::SectionHeader::SHT_NULL => "SHT_NULL",
            ldr::SectionHeader::SHT_PROGBITS => "SHT_PROGBITS",
            ldr::SectionHeader::SHT_SYMTAB => "SHT_SYMTAB",
            ldr::SectionHeader::SHT_STRTAB => "SHT_STRTAB",
            ldr::SectionHeader::SHT_RELA => "SHT_RELA",
            ldr::SectionHeader::SHT_HASH => "SHT_HASH",
            ldr::SectionHeader::SHT_DYNAMIC => "SHT_DYNAMIC",
            ldr::SectionHeader::SHT_NOTE => "SHT_NOTE",
            ldr::SectionHeader::SHT_NOBITS => "SHT_NOBITS",
            ldr::SectionHeader::SHT_REL => "SHT_REL",
            ldr::SectionHeader::SHT_DYNSYM => "SHT_DYNSYM",
            ldr::SectionHeader::SHT_INIT_ARRAY => "SHT_INIT_ARRAY",
            ldr::SectionHeader::SHT_FINI_ARRAY => "SHT_FINI_ARRAY",
            ldr::SectionHeader::SHT_PREINIT_ARRAY => "SHT_PREINIT_ARRAY",
            ldr::SectionHeader::SHT_GROUP => "SHT_GROUP",
            ldr::SectionHeader::SHT_SYMTAB_SHNDX => "SHT_SYMTAB_SHNDX",
            _ => "???",
        };

        let mut buffer = [0u8; 64];
        let name = sh.sh_name(&loader, &mut buffer).unwrap_or("E_TOO_LONG");
        println!("SH {idx:02}: {sh:08x?} ({sh_type}, {name:?})");
    }

    Ok(())
}

pub fn sh_flags(&self) -> u32

Return the sh_flags field

pub fn sh_addr(&self) -> u32

Return the sh_addr field

pub fn sh_offset(&self) -> u32

Return the sh_offset field

pub fn sh_size(&self) -> u32

Return the sh_size field

pub fn sh_link(&self) -> u32

Return the sh_link field

pub fn sh_info(&self) -> u32

Return the sh_info field

pub fn sh_addralign(&self) -> u32

Return the sh_addralign field

pub fn sh_entsize(&self) -> u32

Return the sh_entsize field

Trait Implementations

impl Clone for Header

fn clone(&self) -> Header

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Header

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

Formats the value using the given formatter.