use super::{
ArrayRefs, DynamicPlan, FINI_SYMBOL, INIT_SYMBOL, InitFiniRefs, LinkMode,
PltRefs, RELA_SIZE, SYM_SIZE, dynsym::intern,
};
use crate::{
elf::{
Dyn64,
constants::{
DT_DEBUG, DT_FINI, DT_FINI_ARRAY, DT_FINI_ARRAYSZ, DT_FLAGS,
DT_FLAGS_1, DT_GNU_HASH, DT_HASH, DT_INIT, DT_INIT_ARRAY,
DT_INIT_ARRAYSZ, DT_JMPREL, DT_NEEDED, DT_NULL, DT_PLTGOT,
DT_PLTREL, DT_PLTRELSZ, DT_PREINIT_ARRAY, DT_PREINIT_ARRAYSZ,
DT_RELA, DT_RELA_VAL, DT_RELACOUNT, DT_RELAENT, DT_RELASZ,
DT_RUNPATH, DT_SONAME, DT_STRSZ, DT_STRTAB, DT_SYMENT, DT_SYMTAB,
DT_VERNEED, DT_VERNEEDNUM, DT_VERSYM,
},
},
endian::{I64, U64},
layout::{Layout, Region, Sect},
linker::Context,
output::OutKind,
symbol::{SymbolId, SymbolKind},
};
pub(super) fn build_dynamic(
plan: &DynamicPlan,
mode: LinkMode,
plt: Option<PltRefs>,
arrays: ArrayRefs,
funcs: InitFiniRefs,
) -> Vec<Dyn64> {
let mut out = Vec::with_capacity(16);
for off in &plan.needed_off {
out.push(entry(DT_NEEDED, u64::from(*off)));
}
if let Some(off) = plan.soname_off {
out.push(entry(DT_SONAME, u64::from(off)));
}
if let Some(off) = plan.rpath_off {
out.push(entry(DT_RUNPATH, u64::from(off)));
}
if !plan.hash.is_empty() {
out.push(entry(DT_HASH, plan.regions.hash.vaddr));
}
if !plan.gnu_hash.is_empty() {
out.push(entry(DT_GNU_HASH, plan.regions.gnu_hash.vaddr));
}
out.push(entry(DT_SYMTAB, plan.regions.dynsym.vaddr));
out.push(entry(DT_STRTAB, plan.regions.dynstr.vaddr));
out.push(entry(
DT_STRSZ,
u64::try_from(plan.dynstr.len()).unwrap_or(u64::MAX),
));
out.push(entry(DT_SYMENT, SYM_SIZE));
if !plan.rela_dyn.is_empty() {
out.push(entry(DT_RELA, plan.regions.rela_dyn.vaddr));
out.push(entry(
DT_RELASZ,
u64::try_from(plan.rela_dyn.len() * RELA_SIZE).unwrap_or(u64::MAX),
));
out.push(entry(DT_RELAENT, RELA_SIZE as u64));
}
if plan.relative_count > 0 {
out.push(entry(DT_RELACOUNT, u64::from(plan.relative_count)));
}
if let Some(r) = arrays.preinit {
out.push(entry(DT_PREINIT_ARRAY, r.vaddr));
out.push(entry(DT_PREINIT_ARRAYSZ, r.size));
}
if let Some(r) = arrays.init {
out.push(entry(DT_INIT_ARRAY, r.vaddr));
out.push(entry(DT_INIT_ARRAYSZ, r.size));
}
if let Some(r) = arrays.fini {
out.push(entry(DT_FINI_ARRAY, r.vaddr));
out.push(entry(DT_FINI_ARRAYSZ, r.size));
}
if let Some(addr) = funcs.init {
out.push(entry(DT_INIT, addr));
}
if let Some(addr) = funcs.fini {
out.push(entry(DT_FINI, addr));
}
if let Some(plt) = plt {
out.push(entry(DT_PLTGOT, plt.got_plt));
out.push(entry(DT_JMPREL, plt.rela_plt));
out.push(entry(DT_PLTRELSZ, plt.rela_plt_size));
out.push(entry(DT_PLTREL, DT_RELA_VAL));
}
if plan.has_versions {
out.push(entry(DT_VERSYM, plan.regions.versym.vaddr));
out.push(entry(DT_VERNEED, plan.regions.verneed.vaddr));
out.push(entry(DT_VERNEEDNUM, u64::from(plan.verneed_count)));
}
if mode == LinkMode::DynExec {
out.push(entry(DT_DEBUG, 0));
}
if plan.sizes.flags != 0 {
out.push(entry(DT_FLAGS, plan.sizes.flags));
}
if plan.sizes.flags_1 != 0 {
out.push(entry(DT_FLAGS_1, plan.sizes.flags_1));
}
out.push(entry(DT_NULL, 0));
out
}
fn entry(tag: i64, value: u64) -> Dyn64 {
Dyn64 {
d_tag: I64::new(tag),
d_un: U64::new(value),
}
}
#[allow(clippy::struct_excessive_bools)]
#[derive(Clone, Copy)]
pub(super) struct DynFeatures {
pub has_soname: bool,
pub has_rpath: bool,
pub has_plt: bool,
pub has_preinit_array: bool,
pub has_init_array: bool,
pub has_fini_array: bool,
pub has_init_func: bool,
pub has_fini_func: bool,
pub has_versions: bool,
pub has_hash: bool,
pub has_gnu_hash: bool,
pub flags: u64,
pub flags_1: u64,
}
pub(super) fn dyn_tag_count(
mode: LinkMode,
features: DynFeatures,
needed: usize,
relative_count: u64,
rela_total: u64,
) -> u64 {
let mut n = 5u64;
if features.has_hash {
n += 1;
}
if features.has_gnu_hash {
n += 1;
}
if rela_total > 0 {
n += 3;
}
if features.has_soname {
n += 1;
}
if features.has_rpath {
n += 1;
}
if relative_count > 0 {
n += 1; }
n += u64::try_from(needed).unwrap_or(0);
if features.has_preinit_array {
n += 2; }
if features.has_init_array {
n += 2; }
if features.has_fini_array {
n += 2; }
if features.has_init_func {
n += 1; }
if features.has_fini_func {
n += 1; }
if features.has_plt {
n += 4;
}
if features.has_versions {
n += 3;
}
if mode == LinkMode::DynExec {
n += 1; }
if features.flags != 0 {
n += 1; }
if features.flags_1 != 0 {
n += 1; }
n
}
pub(super) fn intern_needed(
dynstr: &mut Vec<u8>,
needed: &[&[u8]],
) -> Vec<u32> {
let mut out = Vec::with_capacity(needed.len());
for name in needed {
out.push(intern(dynstr, name));
}
out
}
pub(super) fn plt_refs(layout: &Layout) -> Option<PltRefs> {
if layout.region(Sect::GotPlt).size == 0 {
return None;
}
Some(PltRefs {
got_plt: layout.region(Sect::GotPlt).vaddr,
rela_plt: layout.region(Sect::RelaPlt).vaddr,
rela_plt_size: layout.region(Sect::RelaPlt).size,
})
}
pub(super) fn has_array(ctx: &Context<'_>, kind: OutKind) -> bool {
ctx.outputs.section(kind).is_some()
}
pub(super) fn array_refs(ctx: &Context<'_>, layout: &Layout) -> ArrayRefs {
let of = |kind, sect| array_region(ctx, layout, kind, sect);
ArrayRefs {
preinit: of(OutKind::PreinitArray, Sect::PreinitArray),
init: of(OutKind::InitArray, Sect::InitArray),
fini: of(OutKind::FiniArray, Sect::FiniArray),
}
}
fn array_region(
ctx: &Context<'_>,
layout: &Layout,
kind: OutKind,
sect: Sect,
) -> Option<Region> {
has_array(ctx, kind).then(|| layout.region(sect))
}
pub(super) fn defined_function(
ctx: &Context<'_>,
name: &[u8],
) -> Option<SymbolId> {
let id = ctx.symbols.find(name)?;
let sym = ctx.symbols.symbol(id)?;
matches!(sym.kind, SymbolKind::Defined(_)).then_some(id)
}
pub(super) fn init_fini_refs(
ctx: &Context<'_>,
layout: &Layout,
) -> InitFiniRefs {
let init = defined_function(ctx, INIT_SYMBOL);
let fini = defined_function(ctx, FINI_SYMBOL);
let mut refs = InitFiniRefs {
init: init.map(|_| 0),
fini: fini.map(|_| 0),
};
for e in &layout.exports {
if init == Some(e.id) {
refs.init = Some(e.addr);
}
if fini == Some(e.id) {
refs.fini = Some(e.addr);
}
}
refs
}