use std::path::{Path, PathBuf};
use rustc_hash::FxHashSet;
use crate::{
elf::{
ObjectFile,
constants::{SHN_UNDEF, STB_LOCAL},
},
error::{Error, Result},
};
const ARCHIVE_MAGIC: &[u8] = b"!<arch>\n";
const HEADER_SIZE: usize = 60;
const NAME_FIELD: usize = 16;
const SHORT_NAME_MAX: usize = NAME_FIELD - 1;
pub fn archive(members: &[(PathBuf, Vec<u8>)]) -> Result<Vec<u8>> {
let index = symbol_index(members)?;
let names: Vec<String> =
members.iter().map(|(path, _)| member_name(path)).collect();
let long_table = long_name_table(&names);
let mut at = ARCHIVE_MAGIC.len();
let index_size = index_size(&index);
at = next_member(at, index_size);
if let Some(table) = &long_table {
at = next_member(at, table.len());
}
let mut member_at = Vec::with_capacity(members.len());
for (_, bytes) in members {
member_at.push(at);
at = next_member(at, bytes.len());
}
let member_at: Vec<u32> = member_at
.into_iter()
.map(u32::try_from)
.collect::<std::result::Result<_, _>>()
.map_err(|_| Error::OutOfRange("archive member offset"))?;
let mut out = Vec::with_capacity(at);
out.extend_from_slice(ARCHIVE_MAGIC);
push_header(&mut out, "/", index_size)?;
push_index(&mut out, &index, &member_at)?;
pad(&mut out, index_size);
if let Some(table) = &long_table {
push_header(&mut out, "//", table.len())?;
out.extend_from_slice(table);
pad(&mut out, table.len());
}
for (name, (_, bytes)) in names.iter().zip(members) {
match long_at_filter(long_table.as_deref(), name) {
Some(offset) => push_long_ref(&mut out, offset, bytes.len())?,
None => push_header(&mut out, name, bytes.len())?,
}
out.extend_from_slice(bytes);
pad(&mut out, bytes.len());
}
Ok(out)
}
fn symbol_index(members: &[(PathBuf, Vec<u8>)]) -> Result<Vec<(&[u8], usize)>> {
let mut index: Vec<(&[u8], usize)> = Vec::new();
let mut seen: FxHashSet<&[u8]> = FxHashSet::default();
for (i, (_, bytes)) in members.iter().enumerate() {
if crate::input::Format::detect(bytes)
== Some(crate::input::Format::Bitcode)
{
continue;
}
let obj = ObjectFile::parse(bytes)?;
if !obj.is_relocatable() {
return Err(Error::Format(
"a --start-lib member is not a relocatable object",
));
}
let Some(symtab) = obj.symbol_table()? else {
continue;
};
for sym in symtab.iter() {
if sym.bind() == STB_LOCAL || sym.st_shndx.get() == SHN_UNDEF {
continue;
}
let name = crate::symbol::version_stem(symtab.name(sym));
if name.is_empty() || !seen.insert(name) {
continue;
}
index.push((name, i));
}
}
Ok(index)
}
fn member_name(path: &Path) -> String {
path.file_name().map_or_else(
|| path.to_string_lossy().into_owned(),
|n| n.to_string_lossy().into_owned(),
)
}
fn long_name_table(names: &[String]) -> Option<Vec<u8>> {
let mut table = Vec::new();
for name in names.iter().filter(|n| n.len() > SHORT_NAME_MAX) {
table.extend_from_slice(name.as_bytes());
table.extend_from_slice(b"/\n");
}
table.is_empty().then_some(table)
}
fn long_at_filter(table: Option<&[u8]>, name: &str) -> Option<usize> {
let table = table?;
if name.len() <= SHORT_NAME_MAX {
return None;
}
let mut at = 0;
for entry in table.split(|&b| b == b'\n') {
let entry = entry.strip_suffix(b"/").unwrap_or(entry);
if entry == name.as_bytes() {
return Some(at);
}
at += entry.len().saturating_add(2);
}
None
}
fn index_size(index: &[(&[u8], usize)]) -> usize {
4 + index.len() * 4 + index.iter().map(|(n, _)| n.len() + 1).sum::<usize>()
}
fn next_member(at: usize, size: usize) -> usize {
at.saturating_add(HEADER_SIZE)
.saturating_add(size)
.saturating_add(1)
& !1
}
fn push_header(out: &mut Vec<u8>, name: &str, size: usize) -> Result<()> {
let mut field = [b' '; NAME_FIELD];
let bytes = name.as_bytes();
let written = bytes
.len()
.saturating_add(usize::from(!name.ends_with('/')));
if written > NAME_FIELD || bytes.contains(&b' ') {
return Err(Error::Format("archive member name"));
}
field[..bytes.len()].copy_from_slice(bytes);
if !name.ends_with('/') {
field[bytes.len()] = b'/';
}
push_field(out, &field, size);
Ok(())
}
fn push_long_ref(out: &mut Vec<u8>, at: usize, size: usize) -> Result<()> {
let name = format!("/{at}");
let mut field = [b' '; NAME_FIELD];
let bytes = name.as_bytes();
if bytes.len() > NAME_FIELD {
return Err(Error::Format("archive member name"));
}
field[..bytes.len()].copy_from_slice(bytes);
push_field(out, &field, size);
Ok(())
}
fn push_field(out: &mut Vec<u8>, name: &[u8], size: usize) {
out.extend_from_slice(name);
out.extend_from_slice(b"0 ");
out.extend_from_slice(b"0 ");
out.extend_from_slice(b"0 ");
out.extend_from_slice(b"644 ");
let size = format!("{size:>10}");
out.extend_from_slice(size.as_bytes());
out.extend_from_slice(b"`\n");
}
fn push_index(
out: &mut Vec<u8>,
index: &[(&[u8], usize)],
at: &[u32],
) -> Result<()> {
let count = u32::try_from(index.len())
.map_err(|_| Error::OutOfRange("archive symbol index"))?;
out.extend_from_slice(&count.to_be_bytes());
for &(_, member) in index {
let at = at.get(member).copied().unwrap_or(0);
out.extend_from_slice(&at.to_be_bytes());
}
for (name, _) in index {
out.extend_from_slice(name);
out.push(0);
}
Ok(())
}
fn pad(out: &mut Vec<u8>, size: usize) {
if !size.is_multiple_of(2) {
out.push(b'\n');
}
}