use rustc_hash::{FxHashMap, FxHashSet};
use crate::{
error::{Error, Result},
macho::{
MachOFile, MachSymbol,
constants::{
N_ABS, N_EXT, N_SECT, N_TYPE, N_UNDF, N_WEAK_DEF, N_WEAK_REF,
},
},
util::show,
};
#[derive(Clone, Copy)]
pub struct GlobalDef {
pub file: usize,
pub sym: u32,
pub weak: bool,
pub common: bool,
}
pub struct CommonSym<'data> {
pub name: &'data [u8],
pub size: u64,
pub align: u32,
}
pub struct Globals<'d> {
by_name: FxHashMap<&'d [u8], GlobalDef>,
pub commons: Vec<CommonSym<'d>>,
}
impl<'d> Globals<'d> {
pub fn build(inputs: &'d [MachOFile<'d>]) -> Result<Self> {
let mut by_name: FxHashMap<&'d [u8], GlobalDef> = FxHashMap::default();
let mut commons: Vec<CommonSym<'d>> = Vec::new();
let mut common_at: FxHashMap<&'d [u8], usize> = FxHashMap::default();
for (file, input) in inputs.iter().enumerate() {
let syms = input.symbols();
for (i, sym) in syms.iter().enumerate() {
if !is_global_definition(&sym) {
continue;
}
if sym.name.is_empty() {
continue;
}
let sym_idx = u32::try_from(i)
.map_err(|_| Error::OutOfRange("symbol index"))?;
let typ = sym.n_type & N_TYPE;
let common = typ == N_UNDF;
let def = GlobalDef {
file,
sym: sym_idx,
weak: sym.n_desc & N_WEAK_DEF != 0,
common,
};
by_name
.entry(sym.name)
.and_modify(|slot| {
if outranks(&def, slot) {
*slot = def;
}
})
.or_insert(def);
if common {
merge_common(&mut commons, &mut common_at, &sym);
}
}
}
let mut table = Self { by_name, commons };
table.retain_won_commons();
Ok(table)
}
pub fn get(&self, name: &[u8]) -> Option<GlobalDef> {
self.by_name.get(name).copied()
}
fn retain_won_commons(&mut self) {
let won: FxHashSet<&'d [u8]> = self
.by_name
.iter()
.filter(|(_, def)| def.common)
.map(|(name, _)| *name)
.collect();
self.commons.retain(|c| won.contains(c.name));
}
}
fn outranks(incoming: &GlobalDef, current: &GlobalDef) -> bool {
fn rank(def: &GlobalDef) -> u8 {
match (def.common, def.weak) {
(false, false) => 2,
(true, _) => 1,
(false, true) => 0,
}
}
rank(incoming) > rank(current)
}
fn merge_common<'d>(
commons: &mut Vec<CommonSym<'d>>,
common_at: &mut FxHashMap<&'d [u8], usize>,
sym: &MachSymbol<'d>,
) {
let align = u32::from((sym.n_desc >> 8) & 0x0f);
let Some(&at) = common_at.get(sym.name) else {
common_at.insert(sym.name, commons.len());
commons.push(CommonSym {
name: sym.name,
size: sym.n_value,
align,
});
return;
};
if let Some(slot) = commons.get_mut(at) {
slot.size = slot.size.max(sym.n_value);
slot.align = slot.align.max(align);
}
}
fn is_global_definition(sym: &MachSymbol<'_>) -> bool {
if sym.is_stab() {
return false;
}
if sym.n_type & N_EXT == 0 {
return false;
}
let typ = sym.n_type & N_TYPE;
if typ == N_UNDF {
return sym.n_value > 0;
}
typ == N_SECT || typ == N_ABS
}
#[allow(clippy::implicit_hasher)]
pub fn symbol_addr(
inputs: &[MachOFile<'_>],
globals: &Globals<'_>,
common_addr: &FxHashMap<&[u8], u64>,
sec_vaddr: &[Vec<u64>],
file: usize,
sym_idx: usize,
) -> Result<u64> {
let input = inputs.get(file).ok_or(Error::OutOfRange("input file"))?;
let sym = input
.symbols()
.nth(sym_idx)
.ok_or(Error::OutOfRange("symbol index in file"))?;
let typ = sym.n_type & N_TYPE;
match typ {
N_SECT => {
let frame = input
.section_addr(sym.n_sect)
.ok_or(Error::OutOfRange("symbol section ordinal"))?;
let offset = sym.n_value.wrapping_sub(frame);
section_relative_addr(sec_vaddr, file, sym.n_sect, offset)
}
N_ABS => Ok(sym.n_value),
N_UNDF => {
if sym.n_value > 0
&& let Some(addr) = common_addr.get(sym.name)
{
return Ok(*addr);
}
if sym.n_desc & N_WEAK_REF != 0 && globals.get(sym.name).is_none() {
return Ok(0);
}
resolve_undefined(inputs, globals, common_addr, sec_vaddr, sym.name)
}
_ => Ok(0),
}
}
fn section_relative_addr(
sec_vaddr: &[Vec<u64>],
file: usize,
n_sect: u8,
offset: u64,
) -> Result<u64> {
let zero_based = usize::from(n_sect).saturating_sub(1);
let base = sec_vaddr
.get(file)
.and_then(|f| f.get(zero_based))
.copied()
.ok_or(Error::OutOfRange("symbol section ordinal"))?;
Ok(base.wrapping_add(offset))
}
fn resolve_undefined(
inputs: &[MachOFile<'_>],
globals: &Globals<'_>,
common_addr: &FxHashMap<&[u8], u64>,
sec_vaddr: &[Vec<u64>],
name: &[u8],
) -> Result<u64> {
let Some(def) = globals.get(name) else {
return Err(Error::UndefinedReference(show(name)));
};
let usize_sym = usize::try_from(def.sym)
.map_err(|_| Error::OutOfRange("global sym idx"))?;
symbol_addr(inputs, globals, common_addr, sec_vaddr, def.file, usize_sym)
}