use rustc_hash::FxHashMap;
use crate::{
elf::{ObjectFile, constants::SHN_UNDEF},
error::{Error, Result},
input::{Format, InputFile},
lto::{
api::{
LDPK_COMMON, LDPK_DEF, LDPK_WEAKDEF, LDPK_WEAKUNDEF, LDPV_DEFAULT,
},
resolve::{Facts, Winner, resolution},
session,
},
};
pub const RUNTIME_LIBCALLS: [&[u8]; 4] =
[b"memcpy", b"memmove", b"memset", b"memcmp"];
#[derive(Clone, Copy, Default)]
struct Use {
used: bool,
defined: bool,
shared: bool,
}
#[derive(Default)]
pub struct Regular {
names: FxHashMap<Vec<u8>, Use>,
}
impl Regular {
pub fn add_object(&mut self, bytes: &[u8]) -> Result<()> {
if Format::detect(bytes) != Some(Format::Elf) {
return Ok(());
}
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_relocatable(&mut self, bytes: &[u8]) -> Result<()> {
let file =
InputFile::from_member(std::path::Path::new("(lto)"), bytes)?;
for sym in file.global_symbols()? {
let slot = self.entry(sym.name);
slot.used = true;
if sym.shndx != SHN_UNDEF {
slot.defined = true;
}
}
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.defined);
}
}
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 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 where_ = if seen.defined {
Winner::Regular
} else if owner.is_some() {
Winner::Bitcode
} else if seen.shared {
Winner::Shared
} else {
Winner::Nowhere
};
let facts = Facts {
defined,
prevailing: defined
&& !seen.defined
&& owner == Some(file.handle),
winner: where_,
used_in_regular_obj: seen.used,
exported: export_all && sym.visibility == LDPV_DEFAULT,
};
sym.resolution = resolution(&facts).cast_signed();
}
}
Ok(())
}