Source code
Revision control
Copy as Markdown
Other Tools
use alloc::borrow::Cow;
use alloc::vec::Vec;
use crate::endian::Endianness;
use crate::read::{
self, Architecture, CodeView, ComdatKind, CompressedData, CompressedFileRange, Export,
FileFlags, Import, ObjectKind, ObjectMap, Relocation, RelocationMap, Result, SectionFlags,
SectionIndex, SectionKind, SegmentFlags, SubArchitecture, SymbolFlags, SymbolIndex, SymbolKind,
SymbolMap, SymbolMapName, SymbolScope, SymbolSection,
};
/// An object file.
///
/// This is the primary trait for the unified read API.
pub trait Object<'data>: read::private::Sealed {
/// A loadable segment in the object file.
type Segment<'file>: ObjectSegment<'data>
where
Self: 'file,
'data: 'file;
/// An iterator for the loadable segments in the object file.
type SegmentIterator<'file>: Iterator<Item = Self::Segment<'file>>
where
Self: 'file,
'data: 'file;
/// A section in the object file.
type Section<'file>: ObjectSection<'data>
where
Self: 'file,
'data: 'file;
/// An iterator for the sections in the object file.
type SectionIterator<'file>: Iterator<Item = Self::Section<'file>>
where
Self: 'file,
'data: 'file;
/// A COMDAT section group in the object file.
type Comdat<'file>: ObjectComdat<'data>
where
Self: 'file,
'data: 'file;
/// An iterator for the COMDAT section groups in the object file.
type ComdatIterator<'file>: Iterator<Item = Self::Comdat<'file>>
where
Self: 'file,
'data: 'file;
/// A symbol in the object file.
type Symbol<'file>: ObjectSymbol<'data>
where
Self: 'file,
'data: 'file;
/// An iterator for symbols in the object file.
type SymbolIterator<'file>: Iterator<Item = Self::Symbol<'file>>
where
Self: 'file,
'data: 'file;
/// A symbol table in the object file.
type SymbolTable<'file>: ObjectSymbolTable<
'data,
Symbol = Self::Symbol<'file>,
SymbolIterator = Self::SymbolIterator<'file>,
>
where
Self: 'file,
'data: 'file;
/// An iterator for the dynamic relocations in the file.
///
/// The first field in the item tuple is the address
/// that the relocation applies to.
type DynamicRelocationIterator<'file>: Iterator<Item = (u64, Relocation)>
where
Self: 'file,
'data: 'file;
/// Get the architecture type of the file.
fn architecture(&self) -> Architecture;
/// Get the sub-architecture type of the file if known.
///
/// A value of `None` has a range of meanings: the file supports all
/// sub-architectures, the file does not explicitly specify a
/// sub-architecture, or the sub-architecture is currently unrecognized.
fn sub_architecture(&self) -> Option<SubArchitecture> {
None
}
/// Get the endianness of the file.
#[inline]
fn endianness(&self) -> Endianness {
if self.is_little_endian() {
Endianness::Little
} else {
Endianness::Big
}
}
/// Return true if the file is little endian, false if it is big endian.
fn is_little_endian(&self) -> bool;
/// Return true if the file can contain 64-bit addresses.
fn is_64(&self) -> bool;
/// Return the kind of this object.
fn kind(&self) -> ObjectKind;
/// Get an iterator for the loadable segments in the file.
///
/// For ELF, this is program headers with type [`PT_LOAD`](crate::elf::PT_LOAD).
/// For Mach-O, this is load commands with type [`LC_SEGMENT`](crate::macho::LC_SEGMENT)
/// or [`LC_SEGMENT_64`](crate::macho::LC_SEGMENT_64).
/// For PE, this is all sections.
fn segments(&self) -> Self::SegmentIterator<'_>;
/// Get the section named `section_name`, if such a section exists.
///
/// If `section_name` starts with a '.' then it is treated as a system
/// section name, and is compared using the conventions specific to the
/// object file format. This includes:
/// - if ".debug_str_offsets" is requested for a Mach-O object file, then
/// the actual section name that is searched for is "__debug_str_offs".
/// - if ".debug_info" is requested for an ELF object file, then
/// ".zdebug_info" may be returned (and similarly for other debug
/// sections). Similarly, if ".debug_info" is requested for a Mach-O
/// object file, then "__zdebug_info" may be returned.
///
/// For some object files, multiple segments may contain sections with the
/// same name. In this case, the first matching section will be used.
///
/// This method skips over sections with invalid names.
fn section_by_name(&self, section_name: &str) -> Option<Self::Section<'_>> {
self.section_by_name_bytes(section_name.as_bytes())
}
/// Like [`Self::section_by_name`], but allows names that are not UTF-8.
fn section_by_name_bytes<'file>(
&'file self,
section_name: &[u8],
) -> Option<Self::Section<'file>>;
/// Get the section at the given index.
///
/// The meaning of the index depends on the object file.
///
/// For some object files, this requires iterating through all sections.
///
/// Returns an error if the index is invalid.
fn section_by_index(&self, index: SectionIndex) -> Result<Self::Section<'_>>;
/// Get an iterator for the sections in the file.
fn sections(&self) -> Self::SectionIterator<'_>;
/// Get an iterator for the COMDAT section groups in the file.
fn comdats(&self) -> Self::ComdatIterator<'_>;
/// Get the debugging symbol table, if any.
fn symbol_table(&self) -> Option<Self::SymbolTable<'_>>;
/// Get the debugging symbol at the given index.
///
/// The meaning of the index depends on the object file.
///
/// Returns an error if the index is invalid.
fn symbol_by_index(&self, index: SymbolIndex) -> Result<Self::Symbol<'_>>;
/// Get an iterator for the debugging symbols in the file.
///
/// This may skip over symbols that are malformed or unsupported.
///
/// For Mach-O files, this does not include STAB entries.
fn symbols(&self) -> Self::SymbolIterator<'_>;
/// Get the symbol named `symbol_name`, if the symbol exists.
fn symbol_by_name<'file>(&'file self, symbol_name: &str) -> Option<Self::Symbol<'file>> {
self.symbol_by_name_bytes(symbol_name.as_bytes())
}
/// Like [`Self::symbol_by_name`], but allows names that are not UTF-8.
fn symbol_by_name_bytes<'file>(&'file self, symbol_name: &[u8]) -> Option<Self::Symbol<'file>> {
self.symbols()
.find(|sym| sym.name_bytes() == Ok(symbol_name))
}
/// Get the dynamic linking symbol table, if any.
///
/// Only ELF has a separate dynamic linking symbol table.
/// Consider using [`Self::exports`] or [`Self::imports`] instead.
fn dynamic_symbol_table(&self) -> Option<Self::SymbolTable<'_>>;
/// Get an iterator for the dynamic linking symbols in the file.
///
/// This may skip over symbols that are malformed or unsupported.
///
/// Only ELF has dynamic linking symbols.
/// Other file formats will return an empty iterator.
/// Consider using [`Self::exports`] or [`Self::imports`] instead.
fn dynamic_symbols(&self) -> Self::SymbolIterator<'_>;
/// Get the dynamic relocations for this file.
///
/// Symbol indices in these relocations refer to the dynamic symbol table.
///
/// Only ELF has dynamic relocations.
fn dynamic_relocations(&self) -> Option<Self::DynamicRelocationIterator<'_>>;
/// Construct a map from addresses to symbol names.
///
/// The map will only contain defined text and data symbols.
/// The dynamic symbol table will only be used if there are no debugging symbols.
fn symbol_map(&self) -> SymbolMap<SymbolMapName<'data>> {
let mut symbols = Vec::new();
if let Some(table) = self.symbol_table().or_else(|| self.dynamic_symbol_table()) {
// Sometimes symbols share addresses. Collect them all then choose the "best".
let mut all_symbols = Vec::new();
for symbol in table.symbols() {
// Must have an address.
if !symbol.is_definition() {
continue;
}
// Must have a name.
let name = match symbol.name() {
Ok(name) => name,
_ => continue,
};
if name.is_empty() {
continue;
}
// Lower is better.
let mut priority = 0u32;
// Prefer known kind.
match symbol.kind() {
SymbolKind::Text | SymbolKind::Data => {}
SymbolKind::Unknown => priority += 1,
_ => continue,
}
priority *= 2;
// Prefer global visibility.
priority += match symbol.scope() {
SymbolScope::Unknown => 3,
SymbolScope::Compilation => 2,
SymbolScope::Linkage => 1,
SymbolScope::Dynamic => 0,
};
priority *= 4;
// Prefer later entries (earlier symbol is likely to be less specific).
let index = !0 - symbol.index().0;
// Tuple is ordered for sort.
all_symbols.push((symbol.address(), priority, index, name));
}
// Unstable sort is okay because tuple includes index.
all_symbols.sort_unstable();
let mut previous_address = !0;
for (address, _priority, _index, name) in all_symbols {
if address != previous_address {
symbols.push(SymbolMapName::new(address, name));
previous_address = address;
}
}
}
SymbolMap::new(symbols)
}
/// Construct a map from addresses to symbol names and object file names.
///
/// This is derived from Mach-O STAB entries.
fn object_map(&self) -> ObjectMap<'data> {
ObjectMap::default()
}
/// Get the imported symbols.
fn imports(&self) -> Result<Vec<Import<'data>>>;
/// Get the exported symbols that expose both a name and an address.
///
/// Some file formats may provide other kinds of symbols that can be retrieved using
/// the low level API.
fn exports(&self) -> Result<Vec<Export<'data>>>;
/// Return true if the file contains DWARF debug information sections, false if not.
fn has_debug_symbols(&self) -> bool;
/// The UUID from a Mach-O [`LC_UUID`](crate::macho::LC_UUID) load command.
#[inline]
fn mach_uuid(&self) -> Result<Option<[u8; 16]>> {
Ok(None)
}
/// The build ID from an ELF [`NT_GNU_BUILD_ID`](crate::elf::NT_GNU_BUILD_ID) note.
#[inline]
fn build_id(&self) -> Result<Option<&'data [u8]>> {
Ok(None)
}
/// The filename and CRC from a `.gnu_debuglink` section.
#[inline]
fn gnu_debuglink(&self) -> Result<Option<(&'data [u8], u32)>> {
Ok(None)
}
/// The filename and build ID from a `.gnu_debugaltlink` section.
#[inline]
fn gnu_debugaltlink(&self) -> Result<Option<(&'data [u8], &'data [u8])>> {
Ok(None)
}
/// The filename and GUID from the PE CodeView section.
#[inline]
fn pdb_info(&self) -> Result<Option<CodeView<'_>>> {
Ok(None)
}
/// Get the base address used for relative virtual addresses.
///
/// Currently this is only non-zero for PE.
fn relative_address_base(&self) -> u64;
/// Get the virtual address of the entry point of the binary.
fn entry(&self) -> u64;
/// File flags that are specific to each file format.
fn flags(&self) -> FileFlags;
}
/// A loadable segment in an [`Object`].
///
/// This trait is part of the unified read API.
pub trait ObjectSegment<'data>: read::private::Sealed {
/// Returns the virtual address of the segment.
fn address(&self) -> u64;
/// Returns the size of the segment in memory.
fn size(&self) -> u64;
/// Returns the alignment of the segment in memory.
fn align(&self) -> u64;
/// Returns the offset and size of the segment in the file.
fn file_range(&self) -> (u64, u64);
/// Returns a reference to the file contents of the segment.
///
/// The length of this data may be different from the size of the
/// segment in memory.
fn data(&self) -> Result<&'data [u8]>;
/// Return the segment data in the given range.
///
/// Returns `Ok(None)` if the segment does not contain the given range.
fn data_range(&self, address: u64, size: u64) -> Result<Option<&'data [u8]>>;
/// Returns the name of the segment.
fn name_bytes(&self) -> Result<Option<&[u8]>>;
/// Returns the name of the segment.
///
/// Returns an error if the name is not UTF-8.
fn name(&self) -> Result<Option<&str>>;
/// Return the flags of segment.
fn flags(&self) -> SegmentFlags;
}
/// A section in an [`Object`].
///
/// This trait is part of the unified read API.
pub trait ObjectSection<'data>: read::private::Sealed {
/// An iterator for the relocations for a section.
///
/// The first field in the item tuple is the section offset
/// that the relocation applies to.
type RelocationIterator: Iterator<Item = (u64, Relocation)>;
/// Returns the section index.
fn index(&self) -> SectionIndex;
/// Returns the address of the section.
fn address(&self) -> u64;
/// Returns the size of the section in memory.
fn size(&self) -> u64;
/// Returns the alignment of the section in memory.
fn align(&self) -> u64;
/// Returns offset and size of on-disk segment (if any).
fn file_range(&self) -> Option<(u64, u64)>;
/// Returns the raw contents of the section.
///
/// The length of this data may be different from the size of the
/// section in memory.
///
/// This does not do any decompression.
fn data(&self) -> Result<&'data [u8]>;
/// Return the raw contents of the section data in the given range.
///
/// This does not do any decompression.
///
/// Returns `Ok(None)` if the section does not contain the given range.
fn data_range(&self, address: u64, size: u64) -> Result<Option<&'data [u8]>>;
/// Returns the potentially compressed file range of the section,
/// along with information about the compression.
fn compressed_file_range(&self) -> Result<CompressedFileRange>;
/// Returns the potentially compressed contents of the section,
/// along with information about the compression.
fn compressed_data(&self) -> Result<CompressedData<'data>>;
/// Returns the uncompressed contents of the section.
///
/// The length of this data may be different from the size of the
/// section in memory.
///
/// If no compression is detected, then returns the data unchanged.
/// Returns `Err` if decompression fails.
fn uncompressed_data(&self) -> Result<Cow<'data, [u8]>> {
self.compressed_data()?.decompress()
}
/// Returns the name of the section.
fn name_bytes(&self) -> Result<&'data [u8]>;
/// Returns the name of the section.
///
/// Returns an error if the name is not UTF-8.
fn name(&self) -> Result<&'data str>;
/// Returns the name of the segment for this section.
fn segment_name_bytes(&self) -> Result<Option<&[u8]>>;
/// Returns the name of the segment for this section.
///
/// Returns an error if the name is not UTF-8.
fn segment_name(&self) -> Result<Option<&str>>;
/// Return the kind of this section.
fn kind(&self) -> SectionKind;
/// Get the relocations for this section.
fn relocations(&self) -> Self::RelocationIterator;
/// Construct a relocation map for this section.
fn relocation_map(&self) -> Result<RelocationMap>;
/// Section flags that are specific to each file format.
fn flags(&self) -> SectionFlags;
}
/// A COMDAT section group in an [`Object`].
///
/// This trait is part of the unified read API.
pub trait ObjectComdat<'data>: read::private::Sealed {
/// An iterator for the sections in the section group.
type SectionIterator: Iterator<Item = SectionIndex>;
/// Returns the COMDAT selection kind.
fn kind(&self) -> ComdatKind;
/// Returns the index of the symbol used for the name of COMDAT section group.
fn symbol(&self) -> SymbolIndex;
/// Returns the name of the COMDAT section group.
fn name_bytes(&self) -> Result<&'data [u8]>;
/// Returns the name of the COMDAT section group.
///
/// Returns an error if the name is not UTF-8.
fn name(&self) -> Result<&'data str>;
/// Get the sections in this section group.
fn sections(&self) -> Self::SectionIterator;
}
/// A symbol table in an [`Object`].
///
/// This trait is part of the unified read API.
pub trait ObjectSymbolTable<'data>: read::private::Sealed {
/// A symbol table entry.
type Symbol: ObjectSymbol<'data>;
/// An iterator for the symbols in a symbol table.
type SymbolIterator: Iterator<Item = Self::Symbol>;
/// Get an iterator for the symbols in the table.
///
/// This may skip over symbols that are malformed or unsupported.
fn symbols(&self) -> Self::SymbolIterator;
/// Get the symbol at the given index.
///
/// The meaning of the index depends on the object file.
///
/// Returns an error if the index is invalid.
fn symbol_by_index(&self, index: SymbolIndex) -> Result<Self::Symbol>;
}
/// A symbol table entry in an [`Object`].
///
/// This trait is part of the unified read API.
pub trait ObjectSymbol<'data>: read::private::Sealed {
/// The index of the symbol.
fn index(&self) -> SymbolIndex;
/// The name of the symbol.
fn name_bytes(&self) -> Result<&'data [u8]>;
/// The name of the symbol.
///
/// Returns an error if the name is not UTF-8.
fn name(&self) -> Result<&'data str>;
/// The address of the symbol. May be zero if the address is unknown.
fn address(&self) -> u64;
/// The size of the symbol. May be zero if the size is unknown.
fn size(&self) -> u64;
/// Return the kind of this symbol.
fn kind(&self) -> SymbolKind;
/// Returns the section where the symbol is defined.
fn section(&self) -> SymbolSection;
/// Returns the section index for the section containing this symbol.
///
/// May return `None` if the symbol is not defined in a section.
fn section_index(&self) -> Option<SectionIndex> {
self.section().index()
}
/// Return true if the symbol is undefined.
fn is_undefined(&self) -> bool;
/// Return true if the symbol is a definition of a function or data object
/// that has a known address.
///
/// This is primarily used to implement [`Object::symbol_map`].
fn is_definition(&self) -> bool;
/// Return true if the symbol is common data.
///
/// Note: does not check for [`SymbolSection::Section`] with [`SectionKind::Common`].
fn is_common(&self) -> bool;
/// Return true if the symbol is weak.
fn is_weak(&self) -> bool;
/// Returns the symbol scope.
fn scope(&self) -> SymbolScope;
/// Return true if the symbol visible outside of the compilation unit.
///
/// This treats [`SymbolScope::Unknown`] as global.
fn is_global(&self) -> bool;
/// Return true if the symbol is only visible within the compilation unit.
fn is_local(&self) -> bool;
/// Symbol flags that are specific to each file format.
fn flags(&self) -> SymbolFlags<SectionIndex, SymbolIndex>;
}
/// An iterator for files that don't have dynamic relocations.
#[derive(Debug)]
pub struct NoDynamicRelocationIterator;
impl Iterator for NoDynamicRelocationIterator {
type Item = (u64, Relocation);
#[inline]
fn next(&mut self) -> Option<Self::Item> {
None
}
}