use rustc_hash::FxHashMap;
use crate::{
coff::CoffFile,
elf::{
ObjectFile,
constants::{SHN_COMMON, SHN_UNDEF, STB_WEAK},
},
error::{Error, Result},
input::{Format, InputFile},
lto::{
api::{
LDPK_COMMON, LDPK_DEF, LDPK_WEAKDEF, LDPK_WEAKUNDEF, LDPV_DEFAULT,
LDPV_PROTECTED,
},
resolve::{Facts, Winner, resolution},
session,
},
macho::{
MachOFile,
constants::{N_EXT, N_TYPE, N_UNDF, N_WEAK_DEF},
},
};
pub const RUNTIME_LIBCALLS: [&[u8]; 4] =
[b"memcpy", b"memmove", b"memset", b"memcmp"];
#[derive(Clone, Copy, Default)]
struct Use {
used: bool,
def_rank: Option<u8>,
shared: bool,
}
#[derive(Default)]
pub struct Regular {
names: FxHashMap<Vec<u8>, Use>,
}
impl Regular {
pub fn add_object(&mut self, bytes: &[u8]) -> Result<()> {
match Format::detect(bytes) {
Some(Format::Elf) => self.add_elf(bytes),
Some(Format::Coff) => self.add_coff(bytes),
Some(Format::MachO) => self.add_macho(bytes),
_ => Ok(()),
}
}
fn add_elf(&mut self, bytes: &[u8]) -> Result<()> {
let obj = ObjectFile::parse(bytes)?;
if obj.is_relocatable() {
return self.add_relocatable(bytes);
}
for name in exported_names(&obj) {
self.entry(&name).shared = true;
}
Ok(())
}
fn add_coff(&mut self, bytes: &[u8]) -> Result<()> {
let obj = CoffFile::parse(bytes)?;
for sym in obj.symbols() {
if !sym.is_external() && !sym.is_weak() {
continue;
}
let slot = self.entry(sym.name);
slot.used = true;
if sym.is_undefined() {
continue;
}
let rank = if sym.is_weak() {
3
} else if sym.is_common() {
2
} else {
1
};
slot.def_rank =
Some(slot.def_rank.map_or(rank, |best| best.min(rank)));
}
Ok(())
}
fn add_macho(&mut self, bytes: &[u8]) -> Result<()> {
let obj = MachOFile::parse(bytes)?;
for sym in &obj.symbols() {
if sym.is_stab() || sym.n_type & N_EXT == 0 {
continue;
}
let slot = self.entry(sym.name);
slot.used = true;
let undefined = sym.n_type & N_TYPE == N_UNDF;
if undefined && sym.n_value == 0 {
continue;
}
let rank = if sym.n_desc & N_WEAK_DEF != 0 {
3
} else if undefined {
2
} else {
1
};
slot.def_rank =
Some(slot.def_rank.map_or(rank, |best| best.min(rank)));
}
Ok(())
}
fn add_relocatable(&mut self, bytes: &[u8]) -> Result<()> {
let file =
InputFile::from_member(std::path::Path::new("(lto)"), bytes)?;
for sym in file.global_symbols()? {
let rank = regular_rank(sym.binding, sym.shndx);
let slot = self.entry(sym.name);
slot.used = true;
if sym.shndx != SHN_UNDEF {
slot.def_rank =
Some(slot.def_rank.map_or(rank, |best| best.min(rank)));
}
}
Ok(())
}
pub fn pin(&mut self, name: &[u8]) {
self.entry(name).used = true;
}
fn entry(&mut self, name: &[u8]) -> &mut Use {
self.names.entry(name.to_vec()).or_default()
}
fn get(&self, name: &[u8]) -> Use {
self.names.get(name).copied().unwrap_or_default()
}
pub fn undefined(&self) -> Result<Vec<Vec<u8>>> {
let state = session::session()
.lock()
.map_err(|_| Error::Format("LTO session lock was poisoned"))?;
let mut out: FxHashMap<Vec<u8>, bool> = FxHashMap::default();
for (name, seen) in &self.names {
if seen.used {
out.insert(name.clone(), seen.def_rank.is_some());
}
}
for file in &state.claimed {
for sym in &file.symbols {
if is_definition(sym.kind) {
out.insert(sym.name.clone(), true);
} else if sym.kind != LDPK_WEAKUNDEF {
out.entry(sym.name.clone()).or_insert(false);
}
}
}
Ok(out
.into_iter()
.filter_map(|(name, defined)| (!defined).then_some(name))
.collect())
}
}
fn exported_names(obj: &ObjectFile<'_>) -> Vec<Vec<u8>> {
let Ok(Some(dynsym)) = obj.dynamic_symbols() else {
return Vec::new();
};
dynsym
.iter()
.filter(|sym| sym.st_shndx.get() != SHN_UNDEF)
.map(|sym| dynsym.name(sym).to_vec())
.collect()
}
const fn rank(kind: std::ffi::c_uint) -> u8 {
match kind {
LDPK_DEF => 1,
LDPK_COMMON => 2,
LDPK_WEAKDEF => 3,
LDPK_WEAKUNDEF => 5,
_ => 4,
}
}
const fn regular_rank(binding: u8, shndx: u16) -> u8 {
if shndx == SHN_COMMON {
2
} else if binding == STB_WEAK {
3
} else {
1
}
}
const fn is_definition(kind: std::ffi::c_uint) -> bool {
matches!(kind, LDPK_DEF | LDPK_WEAKDEF | LDPK_COMMON)
}
pub fn resolve_claimed(regular: &Regular, export_all: bool) -> Result<()> {
let mut state = session::session()
.lock()
.map_err(|_| Error::Format("LTO session lock was poisoned"))?;
let mut winner: FxHashMap<Vec<u8>, (u8, usize)> = FxHashMap::default();
for file in &state.claimed {
for sym in &file.symbols {
if !is_definition(sym.kind) {
continue;
}
let mine = rank(sym.kind);
match winner.get(&sym.name) {
Some((best, _)) if *best <= mine => {}
_ => {
winner.insert(sym.name.clone(), (mine, file.handle));
}
}
}
}
for file in &mut state.claimed {
for sym in &mut file.symbols {
let seen = regular.get(&sym.name);
let defined = is_definition(sym.kind);
let owner = winner.get(&sym.name).map(|(_, handle)| *handle);
let outranked =
seen.def_rank.is_some_and(|best| best <= rank(sym.kind));
let where_ = if outranked {
Winner::Regular
} else if owner.is_some() {
Winner::Bitcode
} else if seen.shared {
Winner::Shared
} else {
Winner::Nowhere
};
let facts = Facts {
defined,
prevailing: defined && !outranked && owner == Some(file.handle),
winner: where_,
used_in_regular_obj: seen.used,
exported: export_all
&& matches!(sym.visibility, LDPV_DEFAULT | LDPV_PROTECTED),
};
sym.resolution = resolution(&facts).cast_signed();
}
}
Ok(())
}