Trait solana_rbpf::elf_parser_glue::ElfParser

pub trait ElfParser<'a>: Sized {
    type ProgramHeader: ElfProgramHeader + 'a;
    type ProgramHeaders: Iterator<Item = &'a Self::ProgramHeader>;
    type SectionHeader: ElfSectionHeader + 'a;
    type SectionHeaders: Iterator<Item = &'a Self::SectionHeader>;
    type Symbol: ElfSymbol + 'a;
    type Symbols: Iterator<Item = Cow<'a, Self::Symbol>>;
    type Relocation: ElfRelocation + 'a;
    type Relocations: Iterator<Item = Cow<'a, Self::Relocation>>;

    // Required methods
    fn parse(data: &'a [u8]) -> Result<Self, ElfError>;
    fn header(&self) -> &Elf64Ehdr;
    fn program_headers(&'a self) -> Self::ProgramHeaders;
    fn section_headers(&'a self) -> Self::SectionHeaders;
    fn section(&self, name: &[u8]) -> Result<Self::SectionHeader, ElfError>;
    fn section_name(&self, sh_name: Elf64Word) -> Option<&[u8]>;
    fn symbols(&'a self) -> Self::Symbols;
    fn symbol_name(&self, st_name: Elf64Word) -> Option<&[u8]>;
    fn dynamic_symbol(&self, index: Elf64Word) -> Option<Self::Symbol>;
    fn dynamic_symbol_name(&self, st_name: Elf64Word) -> Option<&[u8]>;
    fn dynamic_relocations(&'a self) -> Self::Relocations;
}

The common trait implemented by LegacyParser and NewParser.

This is an internal interface used to isolate the ELF parsing bits and to be able to plug the old goblin parser or the new parser depending on config.

The interface is pretty straightforward. The associated types are the types used to represent ELF data. Some return values are Cow<T> since goblin returns some data by value, while the new parser always borrows from the underlying file slice.

Required Associated Types

type ProgramHeader: ElfProgramHeader + 'a

Program header type.

type ProgramHeaders: Iterator<Item = &'a Self::ProgramHeader>

Iterator of program headers.

type SectionHeader: ElfSectionHeader + 'a

Section header type.

type SectionHeaders: Iterator<Item = &'a Self::SectionHeader>

Iterator of section headers

type Symbol: ElfSymbol + 'a

Symbol type.

type Symbols: Iterator<Item = Cow<'a, Self::Symbol>>

Iterator of symbols.

type Relocation: ElfRelocation + 'a

Relocation type.

type Relocations: Iterator<Item = Cow<'a, Self::Relocation>>

Iterator of relocations.

Required Methods

fn parse(data: &'a [u8]) -> Result<Self, ElfError>

Parses the ELF data included in the buffer.

fn header(&self) -> &Elf64Ehdr

Returns the file header.

fn program_headers(&'a self) -> Self::ProgramHeaders

Returns the program headers.

fn section_headers(&'a self) -> Self::SectionHeaders

Returns the section headers.

fn section(&self, name: &[u8]) -> Result<Self::SectionHeader, ElfError>

Returns the section with the given name.

fn section_name(&self, sh_name: Elf64Word) -> Option<&[u8]>

Returns the section name at the given sh_name offset.

fn symbols(&'a self) -> Self::Symbols

Returns the symbols included in the symbol table.

fn symbol_name(&self, st_name: Elf64Word) -> Option<&[u8]>

Returns the symbol name at the given st_name offset.

fn dynamic_symbol(&self, index: Elf64Word) -> Option<Self::Symbol>

Returns the symbols included in the dynamic symbol table.

fn dynamic_symbol_name(&self, st_name: Elf64Word) -> Option<&[u8]>

Returns the dynamic symbol name at the given st_name offset.

fn dynamic_relocations(&'a self) -> Self::Relocations

Returns the dynamic relocations.

Object Safety

This trait is not object safe.

Implementors

impl<'a> ElfParser<'a> for GoblinParser<'a>

type ProgramHeader = ProgramHeader

type ProgramHeaders = Iter<'a, ProgramHeader>

type SectionHeader = SectionHeader

type SectionHeaders = Iter<'a, SectionHeader>

type Symbol = Sym

type Symbols = Map<SymIterator<'a>, fn(_: <GoblinParser<'a> as ElfParser<'a>>::Symbol) -> Cow<'a, <GoblinParser<'a> as ElfParser<'a>>::Symbol>>

type Relocation = Reloc

type Relocations = Map<RelocIterator<'a>, fn(_: <GoblinParser<'a> as ElfParser<'a>>::Relocation) -> Cow<'a, <GoblinParser<'a> as ElfParser<'a>>::Relocation>>

impl<'a> ElfParser<'a> for NewParser<'a>

type ProgramHeader = Elf64Phdr

type ProgramHeaders = Iter<'a, <NewParser<'a> as ElfParser<'a>>::ProgramHeader>

type SectionHeader = Elf64Shdr

type SectionHeaders = Iter<'a, <NewParser<'a> as ElfParser<'a>>::SectionHeader>

type Symbol = Elf64Sym

type Symbols = Map<Iter<'a, <NewParser<'a> as ElfParser<'a>>::Symbol>, fn(_: &'a <NewParser<'a> as ElfParser<'a>>::Symbol) -> Cow<'a, <NewParser<'a> as ElfParser<'a>>::Symbol>>

type Relocation = Elf64Rel

type Relocations = Map<Iter<'a, <NewParser<'a> as ElfParser<'a>>::Relocation>, fn(_: &'a <NewParser<'a> as ElfParser<'a>>::Relocation) -> Cow<'a, <NewParser<'a> as ElfParser<'a>>::Relocation>>