use rustc_hash::FxHashMap;
use super::{Layout, Sect, addr::definition_addr};
use crate::{
elf::constants::{
SHN_ABS, SHN_UNDEF, STT_FUNC, STT_GNU_IFUNC, STT_NOTYPE, STT_OBJECT,
STT_TLS,
},
linker::{Context, DepAddr},
symbol::{DefSource, Definition, Symbol, SymbolId, SymbolKind},
tls::TlsBlock,
};
#[derive(Clone, Copy, Debug)]
pub struct Export {
pub id: SymbolId,
pub addr: u64,
pub size: u64,
pub shndx: u16,
pub sym_type: u8,
pub visibility: u8,
pub weak: bool,
pub unique: bool,
}
#[derive(Clone, Debug)]
pub struct CopySlot {
pub id: SymbolId,
pub size: u64,
pub align: u64,
pub addr: u64,
pub origin: DepAddr,
pub names: Vec<CopyName>,
}
#[derive(Clone, Debug)]
pub struct CopyName {
pub name: Vec<u8>,
pub size: u64,
pub id: Option<SymbolId>,
}
pub(super) fn collect_exports(
ctx: &Context<'_>,
block: Option<TlsBlock>,
global_addr: &[u64],
defsym_shndx: &FxHashMap<SymbolId, u16>,
layout: &mut Layout,
) {
use rayon::prelude::*;
let ids: Vec<SymbolId> = ctx.symbols.ids().collect();
let rows: Vec<Option<Export>> = ids
.par_iter()
.map(|&id| {
export_for(ctx, block, global_addr, defsym_shndx, layout, id)
})
.collect();
layout.exports.reserve(ctx.symbols.len());
layout.exports.extend(rows.into_iter().flatten());
}
fn export_for(
ctx: &Context<'_>,
block: Option<TlsBlock>,
global_addr: &[u64],
defsym_shndx: &FxHashMap<SymbolId, u16>,
layout: &Layout,
id: SymbolId,
) -> Option<Export> {
let sym = ctx.symbols.symbol(id)?;
let SymbolKind::Defined(def) = &sym.kind else {
if let SymbolKind::Undefined { .. } = sym.kind {
return undefined_export(id, sym, layout);
}
return common_export(global_addr, layout, id, sym);
};
if ctx.gc
&& let DefSource::Section { index, .. } = def.source
&& layout.section_vaddr(def.file, index).is_none()
{
return None;
}
let addr = if def.sym_type == STT_TLS {
let base = block.map_or(0, |b| b.vaddr);
definition_addr(&ctx.merge, layout, def).wrapping_sub(base)
} else {
global_addr.get(id.0).copied().unwrap_or_default()
};
let mut export = Export {
id,
addr,
size: def.size,
shndx: export_shndx(layout, defsym_shndx, id, def),
sym_type: def.sym_type,
visibility: sym.visibility,
weak: def.weak,
unique: def.unique,
};
canonicalize_ifunc(layout, &mut export);
Some(export)
}
fn common_export(
global_addr: &[u64],
layout: &Layout,
id: SymbolId,
sym: &Symbol,
) -> Option<Export> {
let SymbolKind::Common { weak, size, .. } = sym.kind else {
return None;
};
Some(Export {
id,
addr: global_addr.get(id.0).copied().unwrap_or_default(),
size,
shndx: layout.shndx(Sect::Bss),
sym_type: STT_OBJECT,
visibility: sym.visibility,
weak,
unique: false,
})
}
fn undefined_export(
id: SymbolId,
sym: &Symbol,
layout: &Layout,
) -> Option<Export> {
let SymbolKind::Undefined { weak } = sym.kind else {
return None;
};
if !layout.referenced.contains(&id) {
return None;
}
Some(Export {
id,
addr: 0,
size: 0,
shndx: SHN_UNDEF,
sym_type: STT_NOTYPE,
visibility: sym.visibility,
weak,
unique: false,
})
}
fn canonicalize_ifunc(layout: &Layout, export: &mut Export) {
if export.sym_type != STT_GNU_IFUNC {
return;
}
let Some(stub) = layout.plt_entry_addr(export.id) else {
return;
};
export.addr = stub;
export.shndx = layout.shndx(Sect::Plt);
export.sym_type = STT_FUNC;
export.size = 0;
}
fn export_shndx(
layout: &Layout,
defsym_shndx: &FxHashMap<SymbolId, u16>,
id: SymbolId,
def: &Definition,
) -> u16 {
match def.source {
DefSource::Section { index, .. } => layout
.sec_shndx
.get(def.file)
.and_then(|f| f.get(usize::from(index)).copied())
.unwrap_or_default(),
DefSource::Absolute { .. } => {
defsym_shndx.get(&id).copied().unwrap_or(SHN_ABS)
}
}
}