use rayon::prelude::*;
use rustc_hash::FxHashMap;
use super::{
Context,
deps::{DepTables, shared_soname},
in_input_order, is_shared_object,
};
use crate::{
archive::Archive,
dynamic::LinkMode,
elf::{Group, ObjectFile},
error::{Error, Result},
input::{Input, InputFile, InputSymbol},
symbol::SymbolKind,
};
pub(super) struct SharedDep {
soname: Vec<u8>,
machine: u16,
as_needed: bool,
}
pub(super) fn needed_sonames<'a>(
ctx: &Context<'_>,
deps: &'a [SharedDep],
mode: LinkMode,
out: &mut Vec<&'a [u8]>,
) {
out.clear();
if !mode.is_dynamic() {
return;
}
let mut used = vec![false; deps.len()];
mark_used_deps(ctx, &mut used);
for (i, dep) in deps.iter().enumerate() {
if !dep.as_needed || used.get(i).copied().unwrap_or(true) {
out.push(dep.soname.as_slice());
}
}
}
fn mark_used_deps(ctx: &Context<'_>, used: &mut [bool]) {
for (name, sym) in ctx.symbols.entries() {
if !matches!(sym.kind, SymbolKind::Undefined { .. }) {
continue;
}
let Some(exp) = ctx.dep_exports.get(name) else {
continue;
};
if let Ok(dep) = usize::try_from(exp.at.dep)
&& let Some(slot) = used.get_mut(dep)
{
*slot = true;
}
}
}
pub(super) fn check_dep_machines(
deps: &[SharedDep],
target: crate::reloc::Target,
) -> Result<()> {
for dep in deps {
let ok = crate::reloc::Target::from_machine(dep.machine)
.is_ok_and(|m| m == target);
if !ok {
return Err(Error::incompatible_input(
String::from_utf8_lossy(&dep.soname).into_owned(),
"architecture",
));
}
}
Ok(())
}
pub(super) fn derive_target(ctx: &Context<'_>) -> Result<crate::reloc::Target> {
let mut target: Option<crate::reloc::Target> = None;
for input in &ctx.files {
let obj = input.object()?;
let current = crate::reloc::Target::from_machine(obj.machine())?;
match target {
None => target = Some(current),
Some(existing) if existing == current => {}
Some(_) => {
return Err(Error::Format("inputs disagree on e_machine"));
}
}
}
target.ok_or(Error::Format("no input objects to derive a machine"))
}
pub(super) fn assemble_full<'a>(
inputs: &[Input<'_>],
bytes: &'a [&'a [u8]],
) -> Result<(Context<'a>, Vec<Archive<'a>>, Vec<SharedDep>)> {
let parsed: Vec<Result<ParsedDirect<'a>>> = inputs
.par_iter()
.zip(bytes.par_iter().copied())
.map(|(input, data)| parse_direct(*input, data))
.collect::<Vec<Result<ParsedDirect<'a>>>>();
let parsed = in_input_order(parsed)?;
let mut ctx = Context::new();
let mut archives: Vec<Archive> = Vec::new();
let mut deps: Vec<SharedDep> = Vec::new();
let mut seen_sonames: FxHashMap<Vec<u8>, usize> = FxHashMap::default();
for (input_pos, item) in parsed.into_iter().enumerate() {
let input_pos = u32::try_from(input_pos).unwrap_or(u32::MAX);
match item {
ParsedDirect::Archive(mut archive) => {
archive.set_pos(input_pos);
archives.push(archive);
}
ParsedDirect::Shared {
soname,
machine,
tables,
as_needed,
} => {
if let Some(&first) = seen_sonames.get(&soname) {
if !as_needed && let Some(dep) = deps.get_mut(first) {
dep.as_needed = false;
}
continue;
}
seen_sonames.insert(soname.clone(), deps.len());
let dep = u32::try_from(deps.len()).unwrap_or(u32::MAX);
tables.merge_into(
&mut ctx.dep_exports,
&mut ctx.dep_versions,
&mut ctx.dep_undefs,
dep,
);
ctx.dep_order.push(input_pos);
deps.push(SharedDep {
soname,
machine,
as_needed,
});
}
ParsedDirect::Object {
file,
symbols,
bins,
groups,
} => {
ctx.files.push(file);
ctx.extracted.push(Some(symbols));
ctx.bins.push(bins);
ctx.group_lists.push(groups);
ctx.sym_id.push(Vec::new());
}
}
}
Ok((ctx, archives, deps))
}
enum ParsedDirect<'data> {
Archive(Archive<'data>),
Shared {
soname: Vec<u8>,
machine: u16,
tables: DepTables<'data>,
as_needed: bool,
},
Object {
file: InputFile<'data>,
symbols: Vec<InputSymbol<'data>>,
bins: Vec<(u32, u32)>,
groups: Vec<Group<'data>>,
},
}
fn parse_direct<'d>(
input: Input<'_>,
data: &'d [u8],
) -> Result<ParsedDirect<'d>> {
let path = input.name();
if Archive::is_archive(data) {
return Ok(ParsedDirect::Archive(Archive::parse(data, path)?));
}
if is_shared_object(data) {
let soname = shared_soname(path, data, input.is_library_search());
let machine = ObjectFile::parse(data).map_or(0, |o| o.machine());
let tables = DepTables::read(data, &soname);
return Ok(ParsedDirect::Shared {
soname,
machine,
tables,
as_needed: input.is_as_needed(),
});
}
let (file, mut symbols, groups) = InputFile::open_with_symbols(path, data)?;
let bins = crate::symbol::partition_file(&mut symbols);
Ok(ParsedDirect::Object {
file,
symbols,
bins,
groups,
})
}