use rustc_hash::{FxHashMap, FxHashSet};
use crate::util::align_up;
mod dynamic_section;
mod dynsym;
mod rela;
mod sizes;
mod version;
use dynamic_section::{
array_refs, build_dynamic, init_fini_refs, intern_needed, plt_refs,
};
use dynsym::{
DynSym, add_imports, build_dynstr, build_gnu_hash, build_hash, names_by_id,
};
use rela::{build_rela_dyn, count_relative};
use sizes::{Sizing, compute_sizes};
use crate::{
buildid::BuildId,
elf::{
Dyn64, Rela64, Sym64,
constants::{
DF_1_GLOBAL, DF_1_INITFIRST, DF_1_INTERPOSE, DF_1_NODELETE,
DF_1_NOOPEN, DF_1_NOW, DF_1_ORIGIN, DF_BIND_NOW, DF_ORIGIN,
SHN_UNDEF,
},
},
error::Result,
layout::{Layout, Region, Sect},
linker::Context,
reloc::{DynRelocs, Target},
symbol::{SymbolId, SymbolKind, exports_to_dynsym},
};
pub(super) const SYM_SIZE: u64 = core::mem::size_of::<Sym64>() as u64;
pub(super) const RELA_SIZE: usize = core::mem::size_of::<Rela64>();
const DYNAMIC_SIZE: u64 = core::mem::size_of::<Dyn64>() as u64;
pub const INIT_SYMBOL: &[u8] = b"_init";
pub const FINI_SYMBOL: &[u8] = b"_fini";
#[derive(Copy, Clone, Eq, PartialEq, Debug)]
pub enum LinkMode {
Static,
Shared,
DynExec,
}
impl LinkMode {
pub const fn is_dynamic(self) -> bool {
matches!(self, Self::Shared | Self::DynExec)
}
}
#[derive(Clone, Copy, Default)]
pub struct DynConfig<'a> {
pub soname: Option<&'a [u8]>,
pub interpreter: Option<&'a [u8]>,
pub needed: &'a [&'a [u8]],
pub z: ZOptions,
pub strip: Strip,
pub hash_style: HashStyle,
pub build_id: Option<&'a BuildId>,
pub rpath: &'a [u8],
pub pie: Option<bool>,
pub relax: bool,
}
#[derive(Clone, Copy, PartialEq, Eq, Default)]
pub enum HashStyle {
#[default]
Both,
Sysv,
Gnu,
}
impl HashStyle {
pub const fn sysv(self) -> bool {
matches!(self, Self::Both | Self::Sysv)
}
pub const fn gnu(self) -> bool {
matches!(self, Self::Both | Self::Gnu)
}
}
#[derive(Clone, Copy, PartialEq, Eq, Default)]
pub enum Strip {
#[default]
None,
Debug,
All,
}
#[allow(clippy::struct_excessive_bools)]
#[derive(Clone, Copy, Default)]
pub struct ZOptions {
pub now: bool,
pub origin: bool,
pub nodelete: bool,
pub nodlopen: bool,
pub initfirst: bool,
pub interpose: bool,
pub global: bool,
pub stack_size: Option<u64>,
}
impl ZOptions {
pub const fn new() -> Self {
Self {
now: false,
origin: false,
nodelete: false,
nodlopen: false,
initfirst: false,
interpose: false,
global: false,
stack_size: None,
}
}
pub const fn flags(self) -> u64 {
let mut bits = 0;
if self.now {
bits |= DF_BIND_NOW;
}
if self.origin {
bits |= DF_ORIGIN;
}
bits
}
pub const fn flags_1(self) -> u64 {
let mut bits = 0;
if self.now {
bits |= DF_1_NOW;
}
if self.origin {
bits |= DF_1_ORIGIN;
}
if self.nodelete {
bits |= DF_1_NODELETE;
}
if self.nodlopen {
bits |= DF_1_NOOPEN;
}
if self.initfirst {
bits |= DF_1_INITFIRST;
}
if self.interpose {
bits |= DF_1_INTERPOSE;
}
if self.global {
bits |= DF_1_GLOBAL;
}
bits
}
}
pub struct DynamicPlan {
pub dynsym: Vec<Sym64>,
pub dynstr: Vec<u8>,
pub hash: Vec<u8>,
pub gnu_hash: Vec<u8>,
pub versym: Vec<u8>,
pub verneed: Vec<u8>,
pub rela_dyn: Vec<Rela64>,
pub dynamic: Vec<Dyn64>,
pub soname_off: Option<u32>,
pub needed_off: Vec<u32>,
pub rpath_off: Option<u32>,
pub relative_count: u32,
pub has_versions: bool,
pub verneed_count: u32,
pub relocs: DynRelocs,
pub import_index: FxHashMap<SymbolId, u32>,
pub sizes: DynSizes,
data_imports: Vec<SymbolId>,
pub regions: DynRegions,
}
#[derive(Clone, Copy, Default)]
pub struct DynRegions {
pub gnu_hash: Region,
pub hash: Region,
pub dynsym: Region,
pub dynstr: Region,
pub versym: Region,
pub verneed: Region,
pub rela_dyn: Region,
pub dynamic: Region,
}
impl DynRegions {
pub fn get(&self, sect: Sect) -> Region {
match sect {
Sect::GnuHash => self.gnu_hash,
Sect::Hash => self.hash,
Sect::Dynsym => self.dynsym,
Sect::Dynstr => self.dynstr,
Sect::Versym => self.versym,
Sect::Verneed => self.verneed,
Sect::RelaDyn => self.rela_dyn,
Sect::Dynamic => self.dynamic,
_ => Region::default(),
}
}
}
impl DynamicPlan {
pub fn probe(
ctx: &Context<'_>,
layout: &Layout,
target: Target,
mode: LinkMode,
config: &DynConfig<'_>,
) -> Result<Self> {
let sizing = compute_sizes(ctx, layout, target, mode, config)?;
Ok(Self {
dynsym: Vec::new(),
dynstr: Vec::new(),
hash: Vec::new(),
gnu_hash: Vec::new(),
versym: Vec::new(),
verneed: Vec::new(),
rela_dyn: Vec::new(),
dynamic: Vec::new(),
soname_off: None,
needed_off: Vec::new(),
rpath_off: None,
relative_count: 0,
has_versions: false,
verneed_count: 0,
relocs: target.dyn_relocs(),
import_index: FxHashMap::default(),
sizes: sizing.sizes,
data_imports: sizing.data_imports,
regions: DynRegions::default(),
})
}
fn build(
ctx: &Context<'_>,
layout: &Layout,
target: Target,
mode: LinkMode,
config: &DynConfig<'_>,
sizing: Sizing,
) -> Result<Self> {
let relocs = target.dyn_relocs();
let sizes = sizing.sizes;
let names = names_by_id(ctx);
let mut table = DynSym::new();
let mut import_index: FxHashMap<SymbolId, u32> = FxHashMap::default();
for e in &layout.exports {
if e.shndx == SHN_UNDEF {
continue;
}
let name = ctx.symbols.name(e.id);
if !exports_definition(ctx, mode, e.visibility, name) {
continue;
}
let idx = table.add_export(e, name);
import_index.insert(e.id, idx);
}
import_index.extend(add_imports(
ctx,
layout,
&names,
&sizing.data_imports,
&mut table,
));
let mut dynstr = build_dynstr(&mut table, config.soname);
let needed_off = intern_needed(&mut dynstr, config.needed);
let rpath_off = (!config.rpath.is_empty())
.then(|| dynsym::intern(&mut dynstr, config.rpath));
let order = table.reorder_for_gnu_hash();
for idx in import_index.values_mut() {
if let Some(&new_idx) = order.remap.get(*idx as usize) {
*idx = new_idx;
}
}
let mut dep_names: Vec<Vec<u8>> = Vec::new();
version::dep_row_names(&table, layout, &mut dep_names);
let vplan = version::build(ctx, &dep_names);
let versym = if vplan.has_versions() {
version::build_versym(&table, &vplan)
} else {
Vec::new()
};
let verneed = if vplan.has_versions() {
version::build_verneed(&vplan, &mut dynstr)
} else {
Vec::new()
};
let has_versions = vplan.has_versions();
let verneed_count = vplan.verneed_count();
let hash = if config.hash_style.sysv() {
build_hash(&table)
} else {
Vec::new()
};
let gnu_hash = if config.hash_style.gnu() {
build_gnu_hash(&table, &order)
} else {
Vec::new()
};
let rela_dyn = build_rela_dyn(ctx, layout, target, &names, &table)?;
let relative_count = count_relative(&rela_dyn, relocs.relative);
let soname_off = table.soname_off;
Ok(Self {
dynsym: table.materialise(),
dynstr,
hash,
gnu_hash,
versym,
verneed,
rela_dyn,
dynamic: Vec::new(),
soname_off,
needed_off,
rpath_off,
relative_count,
has_versions,
verneed_count,
relocs,
import_index,
sizes,
data_imports: sizing.data_imports,
regions: DynRegions::default(),
})
}
pub fn finalize(
&mut self,
mode: LinkMode,
plt: Option<PltRefs>,
arrays: ArrayRefs,
funcs: InitFiniRefs,
) {
self.dynamic = build_dynamic(self, mode, plt, arrays, funcs);
}
pub fn import_index(&self, sym: SymbolId) -> Option<u32> {
self.import_index.get(&sym).copied()
}
}
#[derive(Clone, Copy)]
pub struct PltRefs {
pub got_plt: u64,
pub rela_plt: u64,
pub rela_plt_size: u64,
}
#[derive(Clone, Copy, Default)]
pub struct ArrayRefs {
pub preinit: Option<Region>,
pub init: Option<Region>,
pub fini: Option<Region>,
}
#[derive(Clone, Copy, Default)]
pub struct InitFiniRefs {
pub init: Option<u64>,
pub fini: Option<u64>,
}
#[derive(Clone, Copy)]
pub struct DynSizes {
pub dynsym: u64,
pub dynstr: u64,
pub hash: u64,
pub gnu_hash: u64,
pub versym: u64,
pub verneed: u64,
pub rela_dyn: u64,
pub dynamic: u64,
pub flags: u64,
pub flags_1: u64,
}
pub const DYNSTR_ALIGN: u64 = 1;
pub const HASH_ALIGN: u64 = 4;
pub const GNU_HASH_ALIGN: u64 = 8;
pub const DYNSYM_ALIGN: u64 = 8;
pub const VERSYM_ALIGN: u64 = 2;
pub const VERNEED_ALIGN: u64 = 4;
pub const RELA_ALIGN: u64 = 8;
pub const DYNAMIC_ALIGN: u64 = 8;
fn make_region(offset: u64, size: u64, base: u64) -> Region {
Region {
offset,
vaddr: base.wrapping_add(offset),
size,
}
}
pub fn place_ro(layout: &mut Layout, start: u64) -> u64 {
let base = layout.base();
let Some(plan) = layout.dynamic.as_mut() else {
return start;
};
let s = &plan.sizes;
let r = &mut plan.regions;
let mut cursor = start;
for (align, size, slot) in [
(GNU_HASH_ALIGN, s.gnu_hash, &mut r.gnu_hash),
(HASH_ALIGN, s.hash, &mut r.hash),
(DYNSYM_ALIGN, s.dynsym, &mut r.dynsym),
(DYNSTR_ALIGN, s.dynstr, &mut r.dynstr),
(VERSYM_ALIGN, s.versym, &mut r.versym),
(VERNEED_ALIGN, s.verneed, &mut r.verneed),
(RELA_ALIGN, s.rela_dyn, &mut r.rela_dyn),
] {
let off = align_up(cursor, align);
*slot = make_region(off, size, base);
cursor = off.wrapping_add(size);
}
cursor
}
pub fn place_rw(layout: &mut Layout, start: u64) -> u64 {
let base = layout.base();
let Some(plan) = layout.dynamic.as_mut() else {
return start;
};
let off = align_up(start, DYNAMIC_ALIGN);
plan.regions.dynamic = make_region(off, plan.sizes.dynamic, base);
off + plan.sizes.dynamic
}
pub fn build_plan_from(
ctx: &Context<'_>,
layout: &Layout,
target: Target,
mode: LinkMode,
config: &DynConfig<'_>,
) -> Result<DynamicPlan> {
let placed = layout
.dynamic
.as_ref()
.ok_or(crate::error::Error::Format("dynamic probe missing"))?;
let sizing = Sizing {
sizes: placed.sizes,
data_imports: placed.data_imports.clone(),
};
let mut plan =
DynamicPlan::build(ctx, layout, target, mode, config, sizing)?;
plan.regions = placed.regions;
let plt = plt_refs(layout);
let arrays = array_refs(ctx, layout);
let funcs = init_fini_refs(ctx, layout);
plan.finalize(mode, plt, arrays, funcs);
tighten_regions(&mut plan)?;
Ok(plan)
}
fn tighten_regions(plan: &mut DynamicPlan) -> Result<()> {
let lens = [
(
".dynamic",
u64::try_from(plan.dynamic.len()).unwrap_or(0) * DYNAMIC_SIZE,
),
(
".dynsym",
u64::try_from(plan.dynsym.len()).unwrap_or(0) * SYM_SIZE,
),
(".dynstr", u64::try_from(plan.dynstr.len()).unwrap_or(0)),
(".hash", u64::try_from(plan.hash.len()).unwrap_or(0)),
(".gnu.hash", u64::try_from(plan.gnu_hash.len()).unwrap_or(0)),
(
".gnu.version",
u64::try_from(plan.versym.len()).unwrap_or(0),
),
(
".gnu.version_r",
u64::try_from(plan.verneed.len()).unwrap_or(0),
),
(
".rela.dyn",
u64::try_from(plan.rela_dyn.len()).unwrap_or(0) * RELA_SIZE as u64,
),
];
let regions = [
&mut plan.regions.dynamic,
&mut plan.regions.dynsym,
&mut plan.regions.dynstr,
&mut plan.regions.hash,
&mut plan.regions.gnu_hash,
&mut plan.regions.versym,
&mut plan.regions.verneed,
&mut plan.regions.rela_dyn,
];
for (region, (name, len)) in regions.into_iter().zip(lens) {
if len > region.size {
debug_assert!(false, "{name} overran its reservation");
return Err(crate::error::Error::Format(
"a synthetic section serialised longer than it was reserved",
));
}
region.size = len;
}
Ok(())
}
pub(super) fn copy_id_set(layout: &Layout) -> FxHashSet<SymbolId> {
layout.copy_bindings().map(|(id, _addr)| id).collect()
}
pub(crate) fn exports_definition(
ctx: &Context<'_>,
mode: LinkMode,
visibility: u8,
name: &[u8],
) -> bool {
if !exports_to_dynsym(visibility) {
return false;
}
match mode {
LinkMode::Shared => true,
LinkMode::DynExec if ctx.export_dynamic => true,
LinkMode::DynExec => {
ctx.dep_undefs.contains(name) || ctx.dep_exports.get(name).is_some()
}
LinkMode::Static => false,
}
}
pub(super) fn is_runtime_import(ctx: &Context<'_>, id: SymbolId) -> bool {
ctx.symbols.symbol(id).is_some_and(|s| {
matches!(s.kind, SymbolKind::Undefined { .. })
&& exports_to_dynsym(s.visibility)
})
}