use rustc_hash::FxHashSet;
use super::{
DynConfig, DynSizes, FINI_SYMBOL, INIT_SYMBOL, LinkMode, RELA_SIZE,
SYM_SIZE, copy_id_set,
dynamic_section::{
DynFeatures, defined_function, dyn_tag_count, has_array,
},
dynsym::{copy_rows, gnu_hash_size, names_by_id},
exports_definition, is_runtime_import,
rela::{
FixedImports, SlotReloc, classify_slot, relative_applies,
survey_data_relocs,
},
version::{self, VersionPlan},
};
use crate::{
elf::{
Dyn64,
constants::{DF_1_PIE, DF_STATIC_TLS},
},
error::Result,
layout::{GotKind, GotOwner, Layout},
linker::Context,
output::OutKind,
reloc::Target,
symbol::{SymbolId, SymbolKind},
};
pub(super) struct Sizing {
pub(super) sizes: DynSizes,
pub(super) data_imports: Vec<SymbolId>,
}
pub(super) fn compute_sizes(
ctx: &Context<'_>,
layout: &Layout,
target: Target,
mode: LinkMode,
config: &DynConfig<'_>,
) -> Result<Sizing> {
let relocs = target.dyn_relocs();
let names = names_by_id(ctx);
let copy_ids = copy_id_set(layout);
let fixed = FixedImports::new(layout, ©_ids);
let DefinedCounts {
mut nsyms,
n_defined,
mut dynstr,
} = count_defined(ctx, layout, mode);
let mut relative_count = 0u64;
let mut glob_count = 0u64;
let mut import_seen: FxHashSet<SymbolId> = FxHashSet::default();
count_got_plt_imports(
ctx,
layout,
&names,
fixed,
&mut nsyms,
&mut dynstr,
&mut import_seen,
&mut relative_count,
&mut glob_count,
);
let survey = survey_data_relocs(ctx, layout, fixed, relocs.abs64)?;
let data_ids = survey.imports;
count_data_imports(
&names,
&data_ids,
&mut import_seen,
&mut nsyms,
&mut dynstr,
);
if let Some(s) = config.soname {
dynstr = dynstr.saturating_add(s.len() as u64 + 1);
}
for n in config.needed {
dynstr = dynstr.saturating_add(n.len() as u64 + 1);
}
if !config.rpath.is_empty() {
dynstr = dynstr.saturating_add(config.rpath.len() as u64 + 1);
}
let import_names =
collect_import_names(ctx, layout, &names, ©_ids, &data_ids);
let vplan = version::size_for(ctx, &import_names);
let versym = if vplan.has_versions() {
VersionPlan::versym_size(nsyms)
} else {
0
};
let verneed = vplan.verneed_size();
dynstr = dynstr.saturating_add(vplan.dynstr_size());
relative_count = relative_count.saturating_add(survey.relative);
let glob_total = glob_count.saturating_add(survey.glob);
let copy_count = u64::try_from(layout.copy_slots.len()).unwrap_or(0);
let nbucket = nsyms.max(1);
let sysv_hash = (2 + nbucket + nsyms) * core::mem::size_of::<u32>() as u64;
let hash = if config.hash_style.sysv() {
sysv_hash
} else {
0
};
let gnu_hash = if config.hash_style.gnu() {
gnu_hash_size(n_defined)
} else {
0
};
let rela_total = relative_count
.saturating_add(glob_total)
.saturating_add(copy_count);
let rela_dyn = rela_total * RELA_SIZE as u64;
let dynsym = nsyms * SYM_SIZE;
let features =
dyn_features(ctx, layout, config, mode, vplan.has_versions());
let dyn_entries = dyn_tag_count(
mode,
features,
config.needed.len(),
relative_count,
rela_total,
);
let dynamic = dyn_entries * core::mem::size_of::<Dyn64>() as u64;
Ok(Sizing {
sizes: DynSizes {
dynsym,
dynstr,
hash,
gnu_hash,
versym,
verneed,
rela_dyn,
dynamic,
flags: features.flags,
flags_1: features.flags_1,
},
data_imports: data_ids,
})
}
struct DefinedCounts {
nsyms: u64,
n_defined: u64,
dynstr: u64,
}
fn count_defined(
ctx: &Context<'_>,
layout: &Layout,
mode: LinkMode,
) -> DefinedCounts {
let mut out = DefinedCounts {
nsyms: 1, n_defined: 0,
dynstr: 1, };
for (name, sym) in ctx.symbols.entries() {
if matches!(
sym.kind,
SymbolKind::Defined(_) | SymbolKind::Common { .. }
) && exports_definition(ctx, mode, sym.visibility, name)
{
out.nsyms = out.nsyms.saturating_add(1);
out.n_defined = out.n_defined.saturating_add(1);
out.dynstr = out.dynstr.saturating_add(name.len() as u64 + 1);
}
}
for (_slot, name) in copy_rows(layout) {
out.nsyms = out.nsyms.saturating_add(1);
out.n_defined = out.n_defined.saturating_add(1);
out.dynstr = out.dynstr.saturating_add(name.name.len() as u64 + 1);
}
out.n_defined = out
.n_defined
.saturating_add(layout.canonical_plt.len() as u64);
out
}
fn dyn_features(
ctx: &Context<'_>,
layout: &Layout,
config: &DynConfig<'_>,
mode: LinkMode,
has_versions: bool,
) -> DynFeatures {
DynFeatures {
has_soname: config.soname.is_some(),
has_plt: !layout.plt_keys.is_empty(),
has_preinit_array: has_array(ctx, OutKind::PreinitArray),
has_init_array: has_array(ctx, OutKind::InitArray),
has_fini_array: has_array(ctx, OutKind::FiniArray),
has_init_func: defined_function(ctx, INIT_SYMBOL).is_some(),
has_fini_func: defined_function(ctx, FINI_SYMBOL).is_some(),
has_versions,
flags: flag_words(layout, config, mode).0,
flags_1: flag_words(layout, config, mode).1,
has_rpath: !config.rpath.is_empty(),
has_hash: config.hash_style.sysv(),
has_gnu_hash: config.hash_style.gnu(),
}
}
fn flag_words(
layout: &Layout,
config: &DynConfig<'_>,
mode: LinkMode,
) -> (u64, u64) {
let static_tls = mode == LinkMode::Shared
&& layout.got_keys.iter().any(|k| k.kind == GotKind::TlsOffset);
let mut flags = config.z.flags();
if static_tls {
flags |= DF_STATIC_TLS;
}
let mut flags_1 = config.z.flags_1();
if mode == LinkMode::DynExec && layout.is_pie() {
flags_1 |= DF_1_PIE;
}
(flags, flags_1)
}
fn collect_import_names(
ctx: &Context<'_>,
layout: &Layout,
names: &[&[u8]],
copy_ids: &FxHashSet<SymbolId>,
data_ids: &[SymbolId],
) -> Vec<Vec<u8>> {
let mut out: Vec<Vec<u8>> = Vec::new();
let mut seen: FxHashSet<SymbolId> = FxHashSet::default();
for (_slot, name) in copy_rows(layout) {
out.push(name.name.clone());
if let Some(id) = name.id {
seen.insert(id);
}
}
for keys in [&layout.got_keys, &layout.plt_keys] {
for key in keys {
let Some(id) = key.global_id() else {
continue;
};
if copy_ids.contains(&id) || seen.contains(&id) {
continue;
}
if !is_runtime_import(ctx, id) {
continue;
}
let Some(name) = names.get(id.0) else {
continue;
};
if name.is_empty() {
continue;
}
out.push(name.to_vec());
seen.insert(id);
}
}
for_each_new_data_import(names, data_ids, &mut seen, |name| {
out.push(name.to_vec());
});
out
}
fn for_each_new_data_import(
names: &[&[u8]],
data_ids: &[SymbolId],
seen: &mut FxHashSet<SymbolId>,
mut visit: impl FnMut(&[u8]),
) {
for &id in data_ids {
let Some(name) = names.get(id.0) else {
continue;
};
if name.is_empty() || !seen.insert(id) {
continue;
}
visit(name);
}
}
fn count_data_imports(
names: &[&[u8]],
data_ids: &[SymbolId],
seen: &mut FxHashSet<SymbolId>,
nsyms: &mut u64,
dynstr: &mut u64,
) {
for_each_new_data_import(names, data_ids, seen, |name| {
*nsyms = nsyms.saturating_add(1);
*dynstr = dynstr.saturating_add(name.len() as u64 + 1);
});
}
#[allow(clippy::too_many_arguments)]
fn count_got_plt_imports(
ctx: &Context<'_>,
layout: &Layout,
names: &[&[u8]],
fixed: FixedImports<'_>,
nsyms: &mut u64,
dynstr: &mut u64,
seen: &mut FxHashSet<SymbolId>,
relative_count: &mut u64,
glob_count: &mut u64,
) {
let shared = layout.mode() == LinkMode::Shared;
let mut count_import = |id: SymbolId| {
let is_import = is_runtime_import(ctx, id)
&& names.get(id.0).is_some_and(|n| !n.is_empty());
if is_import && seen.insert(id) {
*nsyms = nsyms.saturating_add(1);
if let Some(n) = names.get(id.0) {
*dynstr = dynstr.saturating_add(n.len() as u64 + 1);
}
}
is_import
};
for key in &layout.got_keys {
let global = key.global_id();
match key.kind {
GotKind::Addr if global.is_none() => {
if relative_applies(layout.pie) {
*relative_count = relative_count.saturating_add(1);
}
}
GotKind::Addr => {
let Some(id) = global else { continue };
match classify_slot(ctx, shared, fixed, id) {
Some(SlotReloc::ByName(_)) => {
count_import(id);
*glob_count = glob_count.saturating_add(1);
}
Some(SlotReloc::Relative)
if relative_applies(layout.pie) =>
{
*relative_count = relative_count.saturating_add(1);
}
Some(SlotReloc::Relative) | None => {}
}
}
GotKind::TlsOffset => {
if let Some(id) = global
&& (layout.mode() == LinkMode::Shared
|| is_runtime_import(ctx, id))
{
count_import(id);
*glob_count = glob_count.saturating_add(1);
}
}
GotKind::TlsModule => {
*glob_count = glob_count.saturating_add(1);
if let Some(id) = global {
count_import(id);
*glob_count = glob_count.saturating_add(1);
}
}
}
}
for key in &layout.plt_keys {
if let GotOwner::Global(id) = key.owner
&& !fixed.is_copy(id)
{
count_import(id);
}
}
}