use rayon::prelude::*;
use rustc_hash::FxHashSet;
use super::{
GotKey, GotKind, GotOwner, Layout, SymFlags, SymRows, UNPLACED,
collect_exports, fill_got, got_slot, plt_slot,
};
use crate::{
dynamic::LinkMode,
elf::{
Sym64,
constants::{SHN_ABS, SHN_COMMON, SHN_UNDEF, STB_LOCAL, STT_TLS},
},
error::Result,
input::InputFile,
linker::Context,
merge::MergePlan,
reloc::Target,
symbol::{DefSource, Definition, SymbolId, SymbolKind},
tls::{TlsBlock, tpoff},
};
pub(super) fn resolve_addresses(
ctx: &Context<'_>,
target: Target,
common_off: &[u64],
sym_id: &[Vec<Option<SymbolId>>],
layout: &mut Layout,
) -> Result<()> {
let tls = TlsCtx {
target,
block: layout.tls_block(),
};
let mut global_addr = resolve_globals(ctx, tls, layout, common_off);
let resolvers: Vec<u64> = layout
.ifunc
.iter()
.map(|id| global_addr.get(id.0).copied().unwrap_or_default())
.collect();
for &id in &layout.ifunc {
let stub = plt_slot(layout, GotKey::addr(id));
if stub != 0
&& let Some(slot) = global_addr.get_mut(id.0)
{
*slot = stub;
}
}
layout.ifunc_resolvers = resolvers;
let defsym_shndx = crate::defsym::resolve(ctx, layout, &mut global_addr);
let facts = global_facts(ctx, layout.mode());
let slots = slot_cache(layout, global_addr.len(), ctx.files.len());
let rc = ResolveCtx {
tls,
global_addr: &global_addr,
sym_id,
merge: &ctx.merge,
facts: &facts,
slots: &slots,
};
let mut rows = std::mem::take(&mut layout.sym);
let result = rows
.par_iter_mut()
.zip(ctx.files.par_iter())
.enumerate()
.try_for_each(|(file, (row, input))| {
resolve_file_symbols(rc, input, file, layout, row)
});
layout.sym = rows;
result?;
layout.tls_index = got_slot(layout, GotKey::MODULE);
fill_got(&global_addr, layout);
collect_exports(ctx, tls.block, &global_addr, &defsym_shndx, layout);
Ok(())
}
#[derive(Clone, Copy, Default)]
struct GlobalFacts {
preemptible: bool,
absolute: bool,
undef_weak: bool,
}
fn global_facts(ctx: &Context<'_>, mode: LinkMode) -> Vec<GlobalFacts> {
let shared = mode == LinkMode::Shared;
ctx.symbols
.ids()
.map(|id| {
let Some(sym) = ctx.symbols.symbol(id) else {
return GlobalFacts::default();
};
let dep_defined = || {
crate::symbol::exports_to_dynsym(sym.visibility)
&& ctx.dep_exports.get(ctx.symbols.name(id)).is_some()
};
GlobalFacts {
preemptible: sym.is_preemptible(shared),
absolute: sym.is_absolute_value(),
undef_weak: matches!(
sym.kind,
SymbolKind::Undefined { weak: true }
) && !dep_defined(),
}
})
.collect()
}
#[derive(Clone, Copy)]
struct TlsCtx {
target: Target,
block: Option<TlsBlock>,
}
#[derive(Clone, Copy)]
struct ResolveCtx<'a> {
tls: TlsCtx,
global_addr: &'a [u64],
sym_id: &'a [Vec<Option<SymbolId>>],
merge: &'a MergePlan,
facts: &'a [GlobalFacts],
slots: &'a SlotCache,
}
struct SlotCache {
got: Vec<u64>,
plt: Vec<u64>,
tls: Vec<u64>,
local: Vec<Vec<LocalSlot>>,
}
struct LocalSlot {
sym_idx: u32,
what: SlotUse,
addr: u64,
}
enum SlotUse {
Got,
Plt,
TlsOffset,
TlsModule,
}
fn slot_cache(layout: &Layout, globals: usize, files: usize) -> SlotCache {
let mut cache = SlotCache {
got: vec![0; globals],
plt: vec![0; globals],
tls: vec![0; globals],
local: (0..files).map(|_| Vec::new()).collect(),
};
if layout.got.size != 0 {
for key in layout.got_index.keys() {
let addr = got_slot(layout, *key);
let what = match key.kind {
GotKind::Addr => SlotUse::Got,
GotKind::TlsOffset => SlotUse::TlsOffset,
GotKind::TlsModule => SlotUse::TlsModule,
};
record_slot(&mut cache, key.owner, what, addr);
}
}
if layout.plt.size != 0 {
for key in layout.plt_index.keys() {
let addr = plt_slot(layout, *key);
record_slot(&mut cache, key.owner, SlotUse::Plt, addr);
}
}
cache
}
fn record_slot(
cache: &mut SlotCache,
owner: GotOwner,
what: SlotUse,
addr: u64,
) {
match owner {
GotOwner::Global(id) => {
let column = match what {
SlotUse::Got => &mut cache.got,
SlotUse::Plt => &mut cache.plt,
SlotUse::TlsOffset | SlotUse::TlsModule => &mut cache.tls,
};
if let Some(slot) = column.get_mut(id.0) {
if !matches!(what, SlotUse::TlsModule) || *slot == 0 {
*slot = addr;
}
}
}
GotOwner::Local(file, sym_idx) => {
if let Some(list) = cache.local.get_mut(file) {
list.push(LocalSlot {
sym_idx,
what,
addr,
});
}
}
GotOwner::Module => {}
}
}
fn tls_value(tls: TlsCtx, sym_vaddr: u64) -> u64 {
let Some(block) = tls.block else {
return sym_vaddr;
};
let sym_off = sym_vaddr.wrapping_sub(block.vaddr);
tpoff(tls.target, sym_off, &block)
}
fn resolve_globals(
ctx: &Context<'_>,
tls: TlsCtx,
layout: &Layout,
common_off: &[u64],
) -> Vec<u64> {
let mut out = vec![0u64; ctx.symbols.len()];
let mut copied: FxHashSet<SymbolId> = FxHashSet::default();
for (id, addr) in layout.copy_bindings() {
if id.0 < out.len() {
out[id.0] = addr;
}
copied.insert(id);
}
for id in ctx.symbols.ids() {
if copied.contains(&id) {
continue;
}
let Some(sym) = ctx.symbols.symbol(id) else {
continue;
};
let addr = match &sym.kind {
SymbolKind::Defined(def) => {
let vaddr = definition_addr(&ctx.merge, layout, def);
if def.sym_type == STT_TLS {
tls_value(tls, vaddr)
} else {
vaddr
}
}
SymbolKind::Common { .. } => layout.bss.vaddr.wrapping_add(
common_off.get(id.0).copied().unwrap_or_default(),
),
SymbolKind::Undefined { .. } => {
if layout.canonical_plt.contains(&id) {
plt_slot(layout, GotKey::addr(id))
} else {
0
}
}
};
out[id.0] = addr;
}
out
}
pub(super) fn definition_addr(
merge: &MergePlan,
layout: &Layout,
def: &Definition,
) -> u64 {
match def.source {
DefSource::Section { index, offset } => {
let base = placed_base(layout, def.file, index);
let moved = merge.remap(def.file, index, offset).unwrap_or(offset);
base.wrapping_add(moved)
}
DefSource::Absolute { value } => value,
}
}
#[derive(Clone, Copy)]
struct FileSyms<'a> {
file: usize,
sym_id: &'a [Option<SymbolId>],
sec_vaddr: Option<&'a [u64]>,
}
fn resolve_addr_row(
rc: ResolveCtx<'_>,
syms: FileSyms<'_>,
input_syms: &[Sym64],
addr: &mut [u64],
) {
for (i, (slot, sym)) in addr.iter_mut().zip(input_syms).enumerate() {
*slot = symbol_addr(rc, syms, i, sym);
}
}
fn symbol_addr(
rc: ResolveCtx<'_>,
syms: FileSyms<'_>,
i: usize,
sym: &Sym64,
) -> u64 {
if sym.bind() == STB_LOCAL {
let merged = merged(rc.merge, syms.file, sym);
local_addr(rc.tls, syms.sec_vaddr, sym, merged)
} else {
syms.sym_id
.get(i)
.copied()
.flatten()
.and_then(|id| rc.global_addr.get(id.0).copied())
.unwrap_or_default()
}
}
fn resolve_flags_row(
rc: ResolveCtx<'_>,
syms: FileSyms<'_>,
input_syms: &[Sym64],
flags: &mut [SymFlags],
) {
for (i, (slot, sym)) in flags.iter_mut().zip(input_syms).enumerate() {
let id = if sym.bind() == STB_LOCAL {
None
} else {
syms.sym_id.get(i).copied().flatten()
};
*slot = sym_flags(rc.facts, id, sym, false);
}
}
fn sym_flags(
facts: &[GlobalFacts],
id: Option<SymbolId>,
sym: &Sym64,
got_slot: bool,
) -> SymFlags {
let global = id.and_then(|id| facts.get(id.0).copied());
SymFlags {
preemptible: global.is_some_and(|f| f.preemptible),
absolute: global.map_or_else(|| local_is_absolute(sym), |f| f.absolute),
undef_weak: global.is_some_and(|f| f.undef_weak),
got_slot,
}
}
fn local_is_absolute(sym: &Sym64) -> bool {
matches!(sym.st_shndx.get(), SHN_ABS | SHN_UNDEF) || sym.type_() == STT_TLS
}
fn resolve_file_symbols(
rc: ResolveCtx<'_>,
input: &InputFile<'_>,
file: usize,
layout: &Layout,
row: &mut SymRows,
) -> Result<()> {
let ResolveCtx {
sym_id,
facts,
slots,
..
} = rc;
let Some(symtab) = input.symbol_table()? else {
return Ok(());
};
let syms = FileSyms {
file,
sym_id: sym_id.get(file).map(Vec::as_slice).unwrap_or_default(),
sec_vaddr: layout.sec_vaddr.get(file).map(Vec::as_slice),
};
let have_got = layout.got.size != 0;
let have_plt = layout.plt.size != 0;
if !have_got && !have_plt {
resolve_addr_row(rc, syms, symtab.syms, &mut row.addr);
resolve_flags_row(rc, syms, symtab.syms, &mut row.flags);
return Ok(());
}
for (i, sym) in symtab.syms.iter().enumerate() {
let id_opt = if sym.bind() == STB_LOCAL {
None
} else {
syms.sym_id.get(i).copied().flatten()
};
let addr = symbol_addr(rc, syms, i, sym);
if let Some(slot) = row.addr.get_mut(i) {
*slot = addr;
}
let got =
id_opt.map_or(0, |id| slots.got.get(id.0).copied().unwrap_or(0));
if have_got && let Some(slot) = row.got.get_mut(i) {
*slot = got;
}
if let Some(slot) = row.flags.get_mut(i) {
*slot = sym_flags(facts, id_opt, sym, got != 0);
}
if have_plt
&& let Some(id) = id_opt
&& let Some(slot) = row.plt.get_mut(i)
{
*slot = slots.plt.get(id.0).copied().unwrap_or(0);
}
if let Some(id) = id_opt
&& let Some(slot) = row.tls_got.get_mut(i)
{
*slot = slots.tls.get(id.0).copied().unwrap_or(0);
}
}
for s in slots.local.get(file).map_or(&[][..], Vec::as_slice) {
let i = s.sym_idx as usize;
match s.what {
SlotUse::Got => {
if let Some(slot) = row.got.get_mut(i) {
*slot = s.addr;
}
if let Some(flag) = row.flags.get_mut(i) {
flag.got_slot = true;
}
}
SlotUse::Plt => {
if let Some(slot) = row.plt.get_mut(i) {
*slot = s.addr;
}
}
SlotUse::TlsOffset => {
if let Some(slot) = row.tls_got.get_mut(i) {
*slot = s.addr;
}
}
SlotUse::TlsModule => {
if let Some(slot) = row.tls_got.get_mut(i)
&& *slot == 0
{
*slot = s.addr;
}
}
}
}
Ok(())
}
fn placed_base(layout: &Layout, file: usize, index: u16) -> u64 {
layout
.sec_vaddr
.get(file)
.and_then(|f| f.get(usize::from(index)))
.copied()
.filter(|v| *v != UNPLACED)
.unwrap_or_default()
}
fn merged(merge: &MergePlan, file: usize, sym: &Sym64) -> bool {
!merge.is_empty() && merge.is_merged(file, sym.st_shndx.get())
}
fn local_addr(
tls: TlsCtx,
sec_vaddr: Option<&[u64]>,
sym: &Sym64,
merged: bool,
) -> u64 {
match sym.st_shndx.get() {
SHN_UNDEF | SHN_COMMON => 0,
SHN_ABS => sym.st_value.get(),
shndx => {
let value = if merged { 0 } else { sym.st_value.get() };
let vaddr = sec_vaddr
.and_then(|f| f.get(usize::from(shndx)))
.copied()
.filter(|v| *v != UNPLACED)
.unwrap_or_default()
.wrapping_add(value);
if sym.type_() == STT_TLS {
tls_value(tls, vaddr)
} else {
vaddr
}
}
}
}