pub mod api;
pub mod claim;
pub mod dynlib;
pub mod link;
pub mod plugin;
pub mod resolve;
pub mod session;
use std::path::{Path, PathBuf};
pub use claim::{Claimer, Offer};
pub use link::{Regular, resolve_claimed};
pub use plugin::{Hooks, Output, Plugin};
pub use resolve::{Facts, Winner, resolution};
use rustc_hash::FxHashSet;
use crate::{
error::{Error, Result},
input::Format,
lto::link as lto_link,
};
pub fn compile(job: &Job<'_>) -> Result<Compiled> {
let Some(path) = plugin::resolve(job.named_plugin) else {
return Err(Error::CommandLine(
"an input is LLVM IR bitcode, but no LTO plugin was found: pass \
-plugin /path/to/LLVMgold.so, or build with -fno-lto"
.to_string(),
));
};
let plugin = Plugin::load(&path, job.output, job.kind, job.options)?;
let claimer = Claimer::new(&plugin);
let mut regular = Regular::default();
for name in job.pinned {
regular.pin(name);
}
let mut claimed = 0usize;
let mut archives: Vec<(PathBuf, Vec<u8>)> = Vec::new();
for input in job.inputs {
let bytes = std::fs::read(input).map_err(Error::Io)?;
if crate::archive::Archive::is_archive(&bytes) {
archives.push((input.clone(), bytes));
continue;
}
match claimer.offer(input, bytes)? {
Offer::Claimed { .. } => claimed = claimed.saturating_add(1),
Offer::Declined => {
let bytes = std::fs::read(input).map_err(Error::Io)?;
regular.add_object(&bytes)?;
}
}
}
let searchable: Vec<(&Path, &[u8])> = archives
.iter()
.map(|(path, bytes)| (path.as_path(), bytes.as_slice()))
.collect();
claimed =
claimed.saturating_add(claim_group_members(&claimer, job.groups)?);
claimed = claimed.saturating_add(claim_archive_members(
&claimer,
®ular,
&searchable,
)?);
if claimed == 0 {
return Ok(Compiled {
plugin,
objects: Vec::new(),
});
}
resolve_claimed(®ular, job.export_all)?;
run_codegen(&plugin)?;
let objects = session::session()
.lock()
.map_err(|_| Error::Format("LTO session lock was poisoned"))
.map(|state| state.added.clone())?;
Ok(Compiled { plugin, objects })
}
pub struct Compiled {
plugin: Plugin,
pub objects: Vec<PathBuf>,
}
impl Compiled {
pub fn finish(self) -> Result<()> {
let Some(cleanup) = self.plugin.hooks().cleanup else {
return Ok(());
};
let status = unsafe { cleanup() };
if !plugin::ok(status) {
return Err(Error::CommandLine(format!(
"LTO plugin {} failed to clean up (status {status})",
self.plugin.path().display()
)));
}
Ok(())
}
}
pub struct Job<'a> {
pub named_plugin: Option<&'a Path>,
pub options: &'a [String],
pub output: &'a Path,
pub kind: Output,
pub inputs: &'a [PathBuf],
pub pinned: &'a [&'a [u8]],
pub groups: &'a [(&'a Path, &'a [u8])],
pub export_all: bool,
}
fn run_codegen(plugin: &Plugin) -> Result<()> {
let Some(all_read) = plugin.hooks().all_symbols_read else {
return Err(Error::CommandLine(format!(
"LTO plugin {} registered no all-symbols-read hook, so it can \
compile nothing",
plugin.path().display()
)));
};
let status = unsafe { all_read() };
if !plugin::ok(status) {
return Err(Error::CommandLine(format!(
"LTO plugin {} failed to compile the bitcode (status {status})",
plugin.path().display()
)));
}
Ok(())
}
fn claim_archive_members(
claimer: &Claimer<'_>,
regular: &Regular,
archives: &[(&Path, &[u8])],
) -> Result<usize> {
if archives.is_empty() {
return Ok(0);
}
let mut parsed = Vec::with_capacity(archives.len());
for (path, bytes) in archives {
parsed.push(crate::archive::Archive::parse(bytes, path)?);
}
let mut taken: FxHashSet<(usize, u64)> = FxHashSet::default();
let mut claimed = 0usize;
for round in 0..MAX_ARCHIVE_ROUNDS {
let mut wanted = regular.undefined()?;
if round > 0 {
wanted.extend(
lto_link::RUNTIME_LIBCALLS.iter().map(|name| name.to_vec()),
);
}
let mut progressed = false;
for (index, archive) in parsed.iter().enumerate() {
for name in &wanted {
let Some(offset) = archive.lookup(name) else {
continue;
};
if !taken.insert((index, offset)) {
continue;
}
let member = archive.member(offset)?;
if Format::detect(&member) != Some(Format::Bitcode) {
continue;
}
let label = archive
.member_name(offset)
.unwrap_or_else(|_| format!("0x{offset:x}"));
let named = archives.get(index).map_or_else(
|| PathBuf::from(&label),
|(path, _)| path.join(&label),
);
if let Offer::Claimed { .. } =
claimer.offer(&named, member.into_owned())?
{
claimed = claimed.saturating_add(1);
progressed = true;
}
}
}
if !progressed {
break;
}
}
Ok(claimed)
}
const MAX_ARCHIVE_ROUNDS: usize = 64;
fn claim_group_members(
claimer: &Claimer<'_>,
groups: &[(&Path, &[u8])],
) -> Result<usize> {
let mut claimed = 0usize;
for (name, bytes) in groups {
for (index, member) in
crate::archive::members(bytes)?.iter().enumerate()
{
if Format::detect(member) != Some(Format::Bitcode) {
continue;
}
let label = name.join(format!("member {index}"));
if let Offer::Claimed { .. } =
claimer.offer(&label, (*member).to_vec())?
{
claimed = claimed.saturating_add(1);
}
}
}
Ok(claimed)
}