use super::{RelocSite, ScanWork, UndefFlags, cached_global_id, push_plt};
use crate::{
elf::{
Shdr64,
constants::{SHF_TLS, STT_FUNC, STT_OBJECT, STT_TLS, STV_DEFAULT},
},
error::{Error, Result},
layout::{CopyName, CopySlot, GotKey},
linker::{Context, DepAddr},
reloc::{RelExpr, Target, Write, WriteKind, spec_target},
symbol::{SymbolId, SymbolKind, version_stem},
};
pub(super) fn classify_absolute(
ctx: &Context<'_>,
target: Target,
site: &RelocSite<'_>,
undef: &UndefFlags,
r: &crate::elf::Rela64,
work: &mut ScanWork<'_>,
) -> Result<()> {
let sym_idx = r.sym();
let id_opt = cached_global_id(site.sym_id_row, sym_idx);
let bound = if carries_dyn_reloc(target, site.writable, r.r_type()) {
false
} else {
bind_shared_import(ctx, site, sym_idx, id_opt, work)?
};
if absolute_forces_exec(
target,
r.r_type(),
site.writable,
is_tls_ref(site.symtab, site.sections, sym_idx),
) && (bound || !undef.is_undefined(id_opt))
{
*work.has_abs = true;
}
Ok(())
}
fn carries_dyn_reloc(target: Target, writable: bool, r_type: u32) -> bool {
writable && r_type == target.dyn_relocs().abs64
}
fn bind_shared_import(
ctx: &Context<'_>,
site: &RelocSite<'_>,
sym_idx: u32,
id_opt: Option<SymbolId>,
work: &mut ScanWork<'_>,
) -> Result<bool> {
let symtab = site.symtab;
if let Some(id) = id_opt
&& !work.seen_copy.contains(&id)
&& let Some(slot) = copy_candidate(ctx, symtab, sym_idx, id)?
{
for name in &slot.names {
if let Some(alias) = name.id {
work.seen_copy.insert(alias);
}
}
work.copy.push(slot);
}
if let Some(id) = canonical_plt_candidate(ctx, symtab, sym_idx, id_opt)
&& work.seen_canonical.insert(id)
{
work.canonical_plt.push(id);
push_plt(work, GotKey::addr(id));
}
Ok(id_opt.is_some_and(|id| {
work.seen_copy.contains(&id) || work.seen_canonical.contains(&id)
}))
}
fn absolute_forces_exec(
target: Target,
r_type: u32,
writable: bool,
tls: bool,
) -> bool {
if tls {
return false;
}
let Ok(spec) = spec_target(target, r_type) else {
return false;
};
if spec.expr != RelExpr::Abs {
return false;
}
match spec.write {
Write::Bytes(WriteKind::W64) => !writable,
Write::Bytes(_) => true,
Write::Field(f) => {
u32::from(f.right_shift).saturating_add(u32::from(f.width))
> PAGE_BITS
}
}
}
const PAGE_BITS: u32 = 12;
fn is_tls_ref(
symtab: &crate::elf::SymbolTable<'_>,
sections: &[Shdr64],
sym_idx: u32,
) -> bool {
symtab.syms.get(sym_idx as usize).is_some_and(|sym| {
sym.type_() == STT_TLS
|| sections
.get(usize::from(sym.st_shndx.get()))
.is_some_and(|sh| sh.sh_flags.get() & SHF_TLS != 0)
})
}
fn copy_candidate(
ctx: &Context<'_>,
symtab: &crate::elf::SymbolTable<'_>,
sym_idx: u32,
id: SymbolId,
) -> Result<Option<CopySlot>> {
let Some(sym) = symtab.syms.get(sym_idx as usize) else {
return Ok(None);
};
let name = version_stem(symtab.name(sym));
let Some(s) = ctx.symbols.symbol(id) else {
return Ok(None);
};
if !matches!(s.kind, SymbolKind::Undefined { .. }) {
return Ok(None);
}
let Some(exp) = ctx.dep_exports.get(name) else {
return Ok(None);
};
if exp.sym_type == STT_OBJECT
&& exp.storage
&& exp.visibility != STV_DEFAULT
{
return Err(Error::UnpreemptableSymbol(
String::from_utf8_lossy(name).into_owned(),
));
}
if exp.sym_type == STT_OBJECT && exp.storage && exp.size == 0 {
return Err(Error::CopyZeroSized(
String::from_utf8_lossy(name).into_owned(),
));
}
if exp.sym_type != STT_OBJECT || !exp.placed {
return Ok(None);
}
let mut names = Vec::new();
match ctx.dep_exports.aliases_at(exp.at) {
Some(group) => copy_names(ctx, exp.at, group, &mut names),
None => names.push(CopyName {
name: name.to_vec(),
size: exp.size,
id: Some(id),
}),
}
debug_assert!(names.iter().any(|n| n.id == Some(id)));
Ok(Some(CopySlot {
id,
size: exp.size,
align: exp.align,
addr: 0,
origin: exp.at,
names,
}))
}
fn copy_names(
ctx: &Context<'_>,
at: DepAddr,
group: &[&[u8]],
out: &mut Vec<CopyName>,
) {
for &name in group {
let Some(exp) =
ctx.dep_exports.get(name).filter(|e| e.placed && e.at == at)
else {
continue;
};
let id = ctx.symbols.find(name);
if id.is_some_and(|i| !is_import(ctx, i)) {
continue;
}
out.push(CopyName {
name: name.to_vec(),
size: exp.size,
id,
});
}
}
fn is_import(ctx: &Context<'_>, id: SymbolId) -> bool {
ctx.symbols
.symbol(id)
.is_some_and(|s| matches!(s.kind, SymbolKind::Undefined { .. }))
}
fn canonical_plt_candidate(
ctx: &Context<'_>,
symtab: &crate::elf::SymbolTable<'_>,
sym_idx: u32,
id_opt: Option<SymbolId>,
) -> Option<SymbolId> {
let id = id_opt?;
let sym = symtab.syms.get(sym_idx as usize)?;
let name = version_stem(symtab.name(sym));
let s = ctx.symbols.symbol(id)?;
if !matches!(s.kind, SymbolKind::Undefined { .. }) {
return None;
}
let exp = ctx.dep_exports.get(name)?;
if exp.sym_type != STT_FUNC {
return None;
}
Some(id)
}