macro_rules! elf_dyn {
($size:ty) => {
// XXX: Do not import scroll traits here.
// See:
https://github.com/rust-lang/rust/issues/65090#issuecomment-538668155
#[repr(C)]
#[derive(Copy, Clone, PartialEq, Default)]
#[cfg_attr(
feature = "alloc",
derive(scroll::Pread, scroll::Pwrite, scroll::SizeWith)
)]
/// An entry in the dynamic array
pub struct Dyn {
/// Dynamic entry type
pub d_tag: $size,
/// Integer value
pub d_val: $size,
}
use plain;
unsafe impl plain::Plain for Dyn {}
};
}
// TODO: figure out what's the best, most friendly + safe API choice here - u32s or u64s
// remember that DT_TAG is "pointer sized"/used as address sometimes Original rationale: I
// decided to use u64 instead of u32 due to pattern matching use case seems safer to cast the
// elf32's d_tag from u32 -> u64 at runtime instead of casting the elf64's d_tag from u64 ->
// u32 at runtime
/// Marks end of dynamic section
pub const DT_NULL: u64 = 0;
/// Name of needed library
pub const DT_NEEDED: u64 = 1;
/// Size in bytes of PLT relocs
pub const DT_PLTRELSZ: u64 = 2;
/// Processor defined value
pub const DT_PLTGOT: u64 = 3;
/// Address of symbol hash table
pub const DT_HASH: u64 = 4;
/// Address of string table
pub const DT_STRTAB: u64 = 5;
/// Address of symbol table
pub const DT_SYMTAB: u64 = 6;
/// Address of Rela relocs
pub const DT_RELA: u64 = 7;
/// Total size of Rela relocs
pub const DT_RELASZ: u64 = 8;
/// Size of one Rela reloc
pub const DT_RELAENT: u64 = 9;
/// Size of string table
pub const DT_STRSZ: u64 = 10;
/// Size of one symbol table entry
pub const DT_SYMENT: u64 = 11;
/// Address of init function
pub const DT_INIT: u64 = 12;
/// Address of termination function
pub const DT_FINI: u64 = 13;
/// Name of shared object
pub const DT_SONAME: u64 = 14;
/// Library search path (deprecated)
pub const DT_RPATH: u64 = 15;
/// Start symbol search here
pub const DT_SYMBOLIC: u64 = 16;
/// Address of Rel relocs
pub const DT_REL: u64 = 17;
/// Total size of Rel relocs
pub const DT_RELSZ: u64 = 18;
/// Size of one Rel reloc
pub const DT_RELENT: u64 = 19;
/// Type of reloc in PLT
pub const DT_PLTREL: u64 = 20;
/// For debugging; unspecified
pub const DT_DEBUG: u64 = 21;
/// Reloc might modify .text
pub const DT_TEXTREL: u64 = 22;
/// Address of PLT relocs
pub const DT_JMPREL: u64 = 23;
/// Process relocations of object
pub const DT_BIND_NOW: u64 = 24;
/// Array with addresses of init fct
pub const DT_INIT_ARRAY: u64 = 25;
/// Array with addresses of fini fct
pub const DT_FINI_ARRAY: u64 = 26;
/// Size in bytes of DT_INIT_ARRAY
pub const DT_INIT_ARRAYSZ: u64 = 27;
/// Size in bytes of DT_FINI_ARRAY
pub const DT_FINI_ARRAYSZ: u64 = 28;
/// Library search path
pub const DT_RUNPATH: u64 = 29;
/// Flags for the object being loaded
pub const DT_FLAGS: u64 = 30;
/// Start of encoded range
pub const DT_ENCODING: u64 = 32;
/// Array with addresses of preinit fct
pub const DT_PREINIT_ARRAY: u64 = 32;
/// size in bytes of DT_PREINIT_ARRAY
pub const DT_PREINIT_ARRAYSZ: u64 = 33;
/// Number used
pub const DT_NUM: u64 = 34;
/// Start of OS-specific
pub const DT_LOOS: u64 = 0x6000_000d;
/// End of OS-specific
pub const DT_HIOS: u64 = 0x6fff_f000;
/// Start of processor-specific
pub const DT_LOPROC: u64 = 0x7000_0000;
/// End of processor-specific
pub const DT_HIPROC: u64 = 0x7fff_ffff;
// Most used by any processor
// pub const DT_PROCNUM: u64 = DT_MIPS_NUM;
/// DT_* entries which fall between DT_ADDRRNGHI & DT_ADDRRNGLO use the
/// Dyn.d_un.d_ptr field of the Elf*_Dyn structure.
///
/// If any adjustment is made to the ELF object after it has been
/// built these entries will need to be adjusted.
pub const DT_ADDRRNGLO: u64 = 0x6fff_fe00;
/// GNU-style hash table
pub const DT_GNU_HASH: u64 = 0x6fff_fef5;
///
pub const DT_TLSDESC_PLT: u64 = 0x6fff_fef6;
///
pub const DT_TLSDESC_GOT: u64 = 0x6fff_fef7;
/// Start of conflict section
pub const DT_GNU_CONFLICT: u64 = 0x6fff_fef8;
/// Library list
pub const DT_GNU_LIBLIST: u64 = 0x6fff_fef9;
/// Configuration information
pub const DT_CONFIG: u64 = 0x6fff_fefa;
/// Dependency auditing
pub const DT_DEPAUDIT: u64 = 0x6fff_fefb;
/// Object auditing
pub const DT_AUDIT: u64 = 0x6fff_fefc;
/// PLT padding
pub const DT_PLTPAD: u64 = 0x6fff_fefd;
/// Move table
pub const DT_MOVETAB: u64 = 0x6fff_fefe;
/// Syminfo table
pub const DT_SYMINFO: u64 = 0x6fff_feff;
///
pub const DT_ADDRRNGHI: u64 = 0x6fff_feff;
//DT_ADDRTAGIDX(tag) (DT_ADDRRNGHI - (tag)) /* Reverse order! */
pub const DT_ADDRNUM: u64 = 11;
/// The versioning entry types. The next are defined as part of the GNU extension
pub const DT_VERSYM: u64 = 0x6fff_fff0;
pub const DT_RELACOUNT: u64 = 0x6fff_fff9;
pub const DT_RELCOUNT: u64 = 0x6fff_fffa;
/// State flags, see DF_1_* below
pub const DT_FLAGS_1: u64 = 0x6fff_fffb;
/// Address of version definition table
pub const DT_VERDEF: u64 = 0x6fff_fffc;
/// Number of version definitions
pub const DT_VERDEFNUM: u64 = 0x6fff_fffd;
/// Address of table with needed versions
pub const DT_VERNEED: u64 = 0x6fff_fffe;
/// Number of needed versions
pub const DT_VERNEEDNUM: u64 = 0x6fff_ffff;
/// Converts a tag to its string representation.
#[inline]
pub fn tag_to_str(tag: u64) -> &'static str {
match tag {
DT_NULL => "DT_NULL",
DT_NEEDED => "DT_NEEDED",
DT_PLTRELSZ => "DT_PLTRELSZ",
DT_PLTGOT => "DT_PLTGOT",
DT_HASH => "DT_HASH",
DT_STRTAB => "DT_STRTAB",
DT_SYMTAB => "DT_SYMTAB",
DT_RELA => "DT_RELA",
DT_RELASZ => "DT_RELASZ",
DT_RELAENT => "DT_RELAENT",
DT_STRSZ => "DT_STRSZ",
DT_SYMENT => "DT_SYMENT",
DT_INIT => "DT_INIT",
DT_FINI => "DT_FINI",
DT_SONAME => "DT_SONAME",
DT_RPATH => "DT_RPATH",
DT_SYMBOLIC => "DT_SYMBOLIC",
DT_REL => "DT_REL",
DT_RELSZ => "DT_RELSZ",
DT_RELENT => "DT_RELENT",
DT_PLTREL => "DT_PLTREL",
DT_DEBUG => "DT_DEBUG",
DT_TEXTREL => "DT_TEXTREL",
DT_JMPREL => "DT_JMPREL",
DT_BIND_NOW => "DT_BIND_NOW",
DT_INIT_ARRAY => "DT_INIT_ARRAY",
DT_FINI_ARRAY => "DT_FINI_ARRAY",
DT_INIT_ARRAYSZ => "DT_INIT_ARRAYSZ",
DT_FINI_ARRAYSZ => "DT_FINI_ARRAYSZ",
DT_RUNPATH => "DT_RUNPATH",
DT_FLAGS => "DT_FLAGS",
DT_PREINIT_ARRAY => "DT_PREINIT_ARRAY",
DT_PREINIT_ARRAYSZ => "DT_PREINIT_ARRAYSZ",
DT_NUM => "DT_NUM",
DT_LOOS => "DT_LOOS",
DT_HIOS => "DT_HIOS",
DT_LOPROC => "DT_LOPROC",
DT_HIPROC => "DT_HIPROC",
DT_VERSYM => "DT_VERSYM",
DT_RELACOUNT => "DT_RELACOUNT",
DT_RELCOUNT => "DT_RELCOUNT",
DT_GNU_HASH => "DT_GNU_HASH",
DT_VERDEF => "DT_VERDEF",
DT_VERDEFNUM => "DT_VERDEFNUM",
DT_VERNEED => "DT_VERNEED",
DT_VERNEEDNUM => "DT_VERNEEDNUM",
DT_FLAGS_1 => "DT_FLAGS_1",
_ => "UNKNOWN_TAG",
}
}
// Values of `d_un.d_val` in the DT_FLAGS entry
/// Object may use DF_ORIGIN.
pub const DF_ORIGIN: u64 = 0x0000_0001;
/// Symbol resolutions starts here.
pub const DF_SYMBOLIC: u64 = 0x0000_0002;
/// Object contains text relocations.
pub const DF_TEXTREL: u64 = 0x0000_0004;
/// No lazy binding for this object.
pub const DF_BIND_NOW: u64 = 0x0000_0008;
/// Module uses the static TLS model.
pub const DF_STATIC_TLS: u64 = 0x0000_0010;
pub fn df_tag_to_str(tag: u64) -> &'static str {
match tag {
DF_ORIGIN => "DF_ORIGIN",
DF_SYMBOLIC => "DF_SYMBOLIC",
DF_TEXTREL => "DF_TEXTREL",
DF_BIND_NOW => "DF_BIND_NOW",
DF_STATIC_TLS => "DF_STATIC_TLS",
_ => "UNKNOWN_TAG",
}
}
/// === State flags ===
/// selectable in the `d_un.d_val` element of the DT_FLAGS_1 entry in the dynamic section.
///
/// Set RTLD_NOW for this object.
pub const DF_1_NOW: u64 = 0x0000_0001;
/// Set RTLD_GLOBAL for this object.
pub const DF_1_GLOBAL: u64 = 0x0000_0002;
/// Set RTLD_GROUP for this object.
pub const DF_1_GROUP: u64 = 0x0000_0004;
/// Set RTLD_NODELETE for this object.
pub const DF_1_NODELETE: u64 = 0x0000_0008;
/// Trigger filtee loading at runtime.
pub const DF_1_LOADFLTR: u64 = 0x0000_0010;
/// Set RTLD_INITFIRST for this object.
pub const DF_1_INITFIRST: u64 = 0x0000_0020;
/// Set RTLD_NOOPEN for this object.
pub const DF_1_NOOPEN: u64 = 0x0000_0040;
/// $ORIGIN must be handled.
pub const DF_1_ORIGIN: u64 = 0x0000_0080;
/// Direct binding enabled.
pub const DF_1_DIRECT: u64 = 0x0000_0100;
pub const DF_1_TRANS: u64 = 0x0000_0200;
/// Object is used to interpose.
pub const DF_1_INTERPOSE: u64 = 0x0000_0400;
/// Ignore default lib search path.
pub const DF_1_NODEFLIB: u64 = 0x0000_0800;
/// Object can't be dldump'ed.
pub const DF_1_NODUMP: u64 = 0x0000_1000;
/// Configuration alternative created.
pub const DF_1_CONFALT: u64 = 0x0000_2000;
/// Filtee terminates filters search.
pub const DF_1_ENDFILTEE: u64 = 0x0000_4000;
/// Disp reloc applied at build time.
pub const DF_1_DISPRELDNE: u64 = 0x0000_8000;
/// Disp reloc applied at run-time.
pub const DF_1_DISPRELPND: u64 = 0x0001_0000;
/// Object has no-direct binding.
pub const DF_1_NODIRECT: u64 = 0x0002_0000;
pub const DF_1_IGNMULDEF: u64 = 0x0004_0000;
pub const DF_1_NOKSYMS: u64 = 0x0008_0000;
pub const DF_1_NOHDR: u64 = 0x0010_0000;
/// Object is modified after built.
pub const DF_1_EDITED: u64 = 0x0020_0000;
pub const DF_1_NORELOC: u64 = 0x0040_0000;
/// Object has individual interposers.
pub const DF_1_SYMINTPOSE: u64 = 0x0080_0000;
/// Global auditing required.
pub const DF_1_GLOBAUDIT: u64 = 0x0100_0000;
/// Singleton dyn are used.
pub const DF_1_SINGLETON: u64 = 0x0200_0000;
/// Object is a Position Independent Executable (PIE).
pub const DF_1_PIE: u64 = 0x0800_0000;
pub fn df_1_tag_to_str(tag: u64) -> &'static str {
match tag {
DF_1_NOW => "DF_1_NOW",
DF_1_GLOBAL => "DF_1_GLOBAL",
DF_1_GROUP => "DF_1_GROUP",
DF_1_NODELETE => "DF_1_NODELETE",
DF_1_LOADFLTR => "DF_1_LOADFLTR",
DF_1_INITFIRST => "DF_1_INITFIRST",
DF_1_NOOPEN => "DF_1_NOOPEN",
DF_1_ORIGIN => "DF_1_ORIGIN",
DF_1_DIRECT => "DF_1_DIRECT",
DF_1_TRANS => "DF_1_TRANS",
DF_1_INTERPOSE => "DF_1_INTERPOSE",
DF_1_NODEFLIB => "DF_1_NODEFLIB",
DF_1_NODUMP => "DF_1_NODUMP",
DF_1_CONFALT => "DF_1_CONFALT",
DF_1_ENDFILTEE => "DF_1_ENDFILTEE",
DF_1_DISPRELDNE => "DF_1_DISPRELDNE",
DF_1_DISPRELPND => "DF_1_DISPRELPND",
DF_1_NODIRECT => "DF_1_NODIRECT",
DF_1_IGNMULDEF => "DF_1_IGNMULDEF",
DF_1_NOKSYMS => "DF_1_NOKSYMS",
DF_1_NOHDR => "DF_1_NOHDR",
DF_1_EDITED => "DF_1_EDITED",
DF_1_NORELOC => "DF_1_NORELOC",
DF_1_SYMINTPOSE => "DF_1_SYMINTPOSE",
DF_1_GLOBAUDIT => "DF_1_GLOBAUDIT",
DF_1_SINGLETON => "DF_1_SINGLETON",
DF_1_PIE => "DF_1_PIE",
_ => "UNKNOWN_TAG",
}
}
if_alloc! {
use core::fmt;
use scroll::ctx;
use core::result;
use crate::container::{Ctx, Container};
use crate::strtab::Strtab;
use alloc::vec::Vec;
#[derive(Default, PartialEq, Clone)]
pub struct Dyn {
pub d_tag: u64,
pub d_val: u64,
}
impl Dyn {
#[inline]
pub fn size(container: Container) -> usize {
use scroll::ctx::SizeWith;
Self::size_with(&Ctx::from(container))
}
}
impl fmt::Debug for Dyn {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_struct("Dyn")
.field("d_tag", &tag_to_str(self.d_tag))
.field("d_val", &format_args!("0x{:x}", self.d_val))
.finish()
}
}
impl ctx::SizeWith<Ctx> for Dyn {
fn size_with(&Ctx { container, .. }: &Ctx) -> usize {
match container {
Container::Little => {
dyn32::SIZEOF_DYN
},
Container::Big => {
dyn64::SIZEOF_DYN
},
}
}
}
impl<'a> ctx::TryFromCtx<'a, Ctx> for Dyn {
type Error = crate::error::Error;
fn try_from_ctx(bytes: &'a [u8], Ctx { container, le}: Ctx) -> result::Result<(Self, usize)
, Self::Error> {
use scroll::Pread;
let dynamic = match container {
Container::Little => {
(bytes.pread_with::<dyn32::Dyn>(0, le)?.into(), dyn32::SIZEOF_DYN)
},
Container::Big => {
(bytes.pread_with::<dyn64::Dyn>(0, le)?.into(), dyn64::SIZEOF_DYN)
}
};
Ok(dynamic)
}
}
impl ctx::TryIntoCtx<Ctx> for Dyn {
type Error = crate::error::Error;
fn try_into_ctx(self, bytes: &mut [u8], Ctx { container, le}: Ctx) -> result::Result<usize, Self::Error> {
use scroll::Pwrite;
match container {
Container::Little => {
let dynamic: dyn32::Dyn = self.into();
Ok(bytes.pwrite_with(dynamic, 0, le)?)
},
Container::Big => {
let dynamic: dyn64::Dyn = self.into();
Ok(bytes.pwrite_with(dynamic, 0, le)?)
}
}
}
}
#[derive(Debug)]
pub struct Dynamic {
pub dyns: Vec<Dyn>,
pub info: DynamicInfo,
}
impl Dynamic {
#[cfg(feature = "endian_fd")]
/// Returns a vector of dynamic entries from the underlying byte `bytes`, with `endianness`, using the provided `phdrs`
pub fn parse(bytes: &[u8], phdrs: &[crate::elf::program_header::ProgramHeader], ctx: Ctx) -> crate::error::Result<Option<Self>> {
use scroll::ctx::SizeWith;
use scroll::Pread;
use crate::elf::program_header;
for phdr in phdrs {
if phdr.p_type == program_header::PT_DYNAMIC {
let offset = phdr.p_offset as usize;
let filesz = phdr.p_filesz as usize;
// Ensure offset and filesz are valid.
let bytes = if filesz > 0 {
bytes
.pread_with::<&[u8]>(offset, filesz)
.map_err(|_| crate::error::Error::Malformed(format!("Invalid PT_DYNAMIC size (offset {:#x}, filesz {:#x})",
offset, filesz)))?
} else {
&[]
};
let size = Dyn::size_with(&ctx);
// the validity of `count` was implicitly checked by reading `bytes`.
let count = filesz / size;
let mut dyns = Vec::with_capacity(count);
let mut offset = 0;
for _ in 0..count {
let dynamic = bytes.gread_with::<Dyn>(&mut offset, ctx)?;
let tag = dynamic.d_tag;
dyns.push(dynamic);
if tag == DT_NULL { break }
}
let mut info = DynamicInfo::default();
for dynamic in &dyns {
info.update(phdrs, dynamic);
}
return Ok(Some(Dynamic { dyns: dyns, info: info, }));
}
}
Ok(None)
}
pub fn get_libraries<'a>(&self, strtab: &Strtab<'a>) -> Vec<&'a str> {
use log::warn;
let count = self.info.needed_count.min(self.dyns.len());
let mut needed = Vec::with_capacity(count);
for dynamic in &self.dyns {
if dynamic.d_tag as u64 == DT_NEEDED {
if let Some(lib) = strtab.get_at(dynamic.d_val as usize) {
needed.push(lib)
} else {
warn!("Invalid DT_NEEDED {}", dynamic.d_val)
}
}
}
needed
}
}
}
macro_rules! elf_dyn_std_impl {
($size:ident, $phdr:ty) => {
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn size_of() {
assert_eq!(::std::mem::size_of::<Dyn>(), SIZEOF_DYN);
}
}
if_alloc! {
use core::fmt;
use core::slice;
use alloc::vec::Vec;
use crate::elf::program_header::{PT_DYNAMIC};
use crate::strtab::Strtab;
use crate::elf::dynamic::Dyn as ElfDyn;
if_std! {
use std::fs::File;
use std::io::{Read, Seek};
use std::io::SeekFrom::Start;
use crate::error::Result;
}
impl From<ElfDyn> for Dyn {
fn from(dynamic: ElfDyn) -> Self {
Dyn {
d_tag: dynamic.d_tag as $size,
d_val: dynamic.d_val as $size,
}
}
}
impl From<Dyn> for ElfDyn {
fn from(dynamic: Dyn) -> Self {
ElfDyn {
d_tag: u64::from(dynamic.d_tag),
d_val: u64::from(dynamic.d_val),
}
}
}
impl fmt::Debug for Dyn {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_struct("Dyn")
.field("d_tag", &tag_to_str(u64::from(self.d_tag)))
.field("d_val", &format_args!("0x{:x}", self.d_val))
.finish()
}
}
/// Returns a vector of dynamic entries from the given fd and program headers
#[cfg(feature = "std")]
pub fn from_fd(mut fd: &File, phdrs: &[$phdr]) -> Result<Option<Vec<Dyn>>> {
for phdr in phdrs {
if phdr.p_type == PT_DYNAMIC {
// FIXME: validate filesz before allocating
let filesz = phdr.p_filesz as usize;
let dync = filesz / SIZEOF_DYN;
let mut dyns = vec![Dyn::default(); dync];
fd.seek(Start(u64::from(phdr.p_offset)))?;
unsafe {
fd.read_exact(plain::as_mut_bytes(&mut *dyns))?;
}
dyns.dedup();
return Ok(Some(dyns));
}
}
Ok(None)
}
/// Given a bias and a memory address (typically for a _correctly_ mmap'd binary in memory), returns the `_DYNAMIC` array as a slice of that memory
pub unsafe fn from_raw<'a>(bias: usize, vaddr: usize) -> &'a [Dyn] {
let dynp = vaddr.wrapping_add(bias) as *const Dyn;
let mut idx = 0;
while u64::from((*dynp.offset(idx)).d_tag) != DT_NULL {
idx += 1;
}
slice::from_raw_parts(dynp, idx as usize)
}
// TODO: these bare functions have always seemed awkward, but not sure where they should go...
/// Maybe gets and returns the dynamic array with the same lifetime as the `phdrs`, using the provided bias with wrapping addition.
/// If the bias is wrong, it will either segfault or give you incorrect values, beware
pub unsafe fn from_phdrs(bias: usize, phdrs: &[$phdr]) -> Option<&[Dyn]> {
for phdr in phdrs {
// FIXME: change to casting to u64 similar to DT_*?
if phdr.p_type as u32 == PT_DYNAMIC {
return Some(from_raw(bias, phdr.p_vaddr as usize));
}
}
None
}
/// Gets the needed libraries from the `_DYNAMIC` array, with the str slices lifetime tied to the dynamic array/strtab's lifetime(s)
pub unsafe fn get_needed<'a>(dyns: &[Dyn], strtab: *const Strtab<'a>, count: usize) -> Vec<&'a str> {
let mut needed = Vec::with_capacity(count.min(dyns.len()));
for dynamic in dyns {
if u64::from(dynamic.d_tag) == DT_NEEDED {
let lib = &(*strtab)[dynamic.d_val as usize];
needed.push(lib);
}
}
needed
}
}
};
}
macro_rules! elf_dynamic_info_std_impl {
($size:ident, $phdr:ty) => {
/// Convert a virtual memory address to a file offset
fn vm_to_offset(phdrs: &[$phdr], address: $size) -> Option<$size> {
for ph in phdrs {
if ph.p_type == crate::elf::program_header::PT_LOAD && address >= ph.p_vaddr {
let offset = address - ph.p_vaddr;
if offset < ph.p_memsz {
return ph.p_offset.checked_add(offset);
}
}
}
None
}
/// Important dynamic linking info generated via a single pass through the `_DYNAMIC` array
#[derive(Default, PartialEq)]
pub struct DynamicInfo {
pub rela: usize,
pub relasz: usize,
pub relaent: $size,
pub relacount: usize,
pub rel: usize,
pub relsz: usize,
pub relent: $size,
pub relcount: usize,
pub gnu_hash: Option<$size>,
pub hash: Option<$size>,
pub strtab: usize,
pub strsz: usize,
pub symtab: usize,
pub syment: usize,
pub pltgot: Option<$size>,
pub pltrelsz: usize,
pub pltrel: $size,
pub jmprel: usize,
pub verdef: $size,
pub verdefnum: $size,
pub verneed: $size,
pub verneednum: $size,
pub versym: $size,
pub init: $size,
pub fini: $size,
pub init_array: $size,
pub init_arraysz: usize,
pub fini_array: $size,
pub fini_arraysz: usize,
pub needed_count: usize,
pub flags: $size,
pub flags_1: $size,
pub soname: usize,
pub textrel: bool,
}
impl DynamicInfo {
#[inline]
pub fn update(&mut self, phdrs: &[$phdr], dynamic: &Dyn) {
match u64::from(dynamic.d_tag) {
DT_RELA => self.rela = vm_to_offset(phdrs, dynamic.d_val).unwrap_or(0) as usize, // .rela.dyn
DT_RELASZ => self.relasz = dynamic.d_val as usize,
DT_RELAENT => self.relaent = dynamic.d_val as _,
DT_RELACOUNT => self.relacount = dynamic.d_val as usize,
DT_REL => self.rel = vm_to_offset(phdrs, dynamic.d_val).unwrap_or(0) as usize, // .rel.dyn
DT_RELSZ => self.relsz = dynamic.d_val as usize,
DT_RELENT => self.relent = dynamic.d_val as _,
DT_RELCOUNT => self.relcount = dynamic.d_val as usize,
DT_GNU_HASH => self.gnu_hash = vm_to_offset(phdrs, dynamic.d_val),
DT_HASH => self.hash = vm_to_offset(phdrs, dynamic.d_val),
DT_STRTAB => {
self.strtab = vm_to_offset(phdrs, dynamic.d_val).unwrap_or(0) as usize
}
DT_STRSZ => self.strsz = dynamic.d_val as usize,
DT_SYMTAB => {
self.symtab = vm_to_offset(phdrs, dynamic.d_val).unwrap_or(0) as usize
}
DT_SYMENT => self.syment = dynamic.d_val as usize,
DT_PLTGOT => self.pltgot = vm_to_offset(phdrs, dynamic.d_val),
DT_PLTRELSZ => self.pltrelsz = dynamic.d_val as usize,
DT_PLTREL => self.pltrel = dynamic.d_val as _,
DT_JMPREL => {
self.jmprel = vm_to_offset(phdrs, dynamic.d_val).unwrap_or(0) as usize
} // .rela.plt
DT_VERDEF => self.verdef = vm_to_offset(phdrs, dynamic.d_val).unwrap_or(0),
DT_VERDEFNUM => self.verdefnum = vm_to_offset(phdrs, dynamic.d_val).unwrap_or(0),
DT_VERNEED => self.verneed = vm_to_offset(phdrs, dynamic.d_val).unwrap_or(0),
DT_VERNEEDNUM => self.verneednum = dynamic.d_val as _,
DT_VERSYM => self.versym = vm_to_offset(phdrs, dynamic.d_val).unwrap_or(0),
DT_INIT => self.init = vm_to_offset(phdrs, dynamic.d_val).unwrap_or(0),
DT_FINI => self.fini = vm_to_offset(phdrs, dynamic.d_val).unwrap_or(0),
DT_INIT_ARRAY => {
self.init_array = vm_to_offset(phdrs, dynamic.d_val).unwrap_or(0)
}
DT_INIT_ARRAYSZ => self.init_arraysz = dynamic.d_val as _,
DT_FINI_ARRAY => {
self.fini_array = vm_to_offset(phdrs, dynamic.d_val).unwrap_or(0)
}
DT_FINI_ARRAYSZ => self.fini_arraysz = dynamic.d_val as _,
DT_NEEDED => self.needed_count += 1,
DT_FLAGS => self.flags = dynamic.d_val as _,
DT_FLAGS_1 => self.flags_1 = dynamic.d_val as _,
DT_SONAME => self.soname = dynamic.d_val as _,
DT_TEXTREL => self.textrel = true,
_ => (),
}
}
pub fn new(dynamic: &[Dyn], phdrs: &[$phdr]) -> DynamicInfo {
let mut info = DynamicInfo::default();
for dyna in dynamic {
info.update(phdrs, &dyna);
}
info
}
}
if_alloc! {
impl fmt::Debug for DynamicInfo {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let gnu_hash = self.gnu_hash.unwrap_or(0);
let hash = self.hash.unwrap_or(0);
let pltgot = self.pltgot.unwrap_or(0);
let flags: Vec<&'static str> = [DF_ORIGIN, DF_SYMBOLIC, DF_TEXTREL, DF_BIND_NOW, DF_STATIC_TLS,][..]
.iter()
.filter(|f| (self.flags as u64 & *f) != 0)
.map(|f| df_tag_to_str(*f))
.collect();
let flags_1: Vec<&'static str> = [
DF_1_NOW,
DF_1_GLOBAL,
DF_1_GROUP,
DF_1_NODELETE,
DF_1_LOADFLTR,
DF_1_INITFIRST,
DF_1_NOOPEN,
DF_1_ORIGIN,
DF_1_DIRECT,
DF_1_TRANS,
DF_1_INTERPOSE,
DF_1_NODEFLIB,
DF_1_NODUMP,
DF_1_CONFALT,
DF_1_ENDFILTEE,
DF_1_DISPRELDNE,
DF_1_DISPRELPND,
DF_1_NODIRECT,
DF_1_IGNMULDEF,
DF_1_NOKSYMS,
DF_1_NOHDR,
DF_1_EDITED,
DF_1_NORELOC,
DF_1_SYMINTPOSE,
DF_1_GLOBAUDIT,
DF_1_SINGLETON,
DF_1_PIE,
][..]
.iter()
.filter(|f| (self.flags_1 as u64 & *f) != 0)
.map(|f| df_1_tag_to_str(*f))
.collect();
f.debug_struct("DynamicInfo")
.field("rela", &format_args!("0x{:x}", self.rela))
.field("relasz", &self.relasz)
.field("relaent", &self.relaent)
.field("relacount", &self.relacount)
.field("gnu_hash", &format_args!("0x{:x}", gnu_hash))
.field("hash", &format_args!("0x{:x}", hash))
.field("strtab", &format_args!("0x{:x}", self.strtab))
.field("strsz", &self.strsz)
.field("symtab", &format_args!("0x{:x}", self.symtab))
.field("syment", &self.syment)
.field("pltgot", &format_args!("0x{:x}", pltgot))
.field("pltrelsz", &self.pltrelsz)
.field("pltrel", &self.pltrel)
.field("jmprel", &format_args!("0x{:x}", self.jmprel))
.field("verdef", &format_args!("0x{:x}", self.verdef))
.field("verdefnum", &self.verdefnum)
.field("verneed", &format_args!("0x{:x}", self.verneed))
.field("verneednum", &self.verneednum)
.field("versym", &format_args!("0x{:x}", self.versym))
.field("init", &format_args!("0x{:x}", self.init))
.field("fini", &format_args!("0x{:x}", self.fini))
.field("init_array", &format_args!("{:#x}", self.init_array))
.field("init_arraysz", &self.init_arraysz)
.field("needed_count", &self.needed_count)
.field("flags", &format_args!("{:#0width$x} {:?}", self.flags, flags, width = core::mem::size_of_val(&self.flags)))
.field("flags_1", &format_args!("{:#0width$x} {:?}", self.flags_1, flags_1, width = core::mem::size_of_val(&self.flags_1)))
.field("soname", &self.soname)
.field("textrel", &self.textrel)
.finish()
}
}
}
};
}
if_alloc! {
elf_dynamic_info_std_impl!(u64, crate::elf::program_header::ProgramHeader);
}
pub mod dyn32 {
pub use crate::elf::dynamic::*;
elf_dyn!(u32);
pub const SIZEOF_DYN: usize = 8;
elf_dyn_std_impl!(u32, crate::elf32::program_header::ProgramHeader);
elf_dynamic_info_std_impl!(
u32,
crate::elf::program_header::program_header32::ProgramHeader
);
}
pub mod dyn64 {
pub use crate::elf::dynamic::*;
elf_dyn!(u64);
pub const SIZEOF_DYN: usize = 16;
elf_dyn_std_impl!(u64, crate::elf64::program_header::ProgramHeader);
elf_dynamic_info_std_impl!(
u64,
crate::elf::program_header::program_header64::ProgramHeader
);
}
