use bytemuck::Pod;
use rustc_hash::{FxHashMap, FxHashSet};
use super::dynsym::{DynSym, copy_rows, intern};
use crate::{
elf::constants::{SHN_UNDEF, VER_NDX_GLOBAL, VER_NDX_LOCAL},
endian::{U16, U32},
layout::Layout,
linker::Context,
util::cstr_at,
};
#[derive(Clone)]
pub(super) struct VerneedEntry {
pub soname: Vec<u8>,
pub versions: Vec<VerneedVersion>,
}
#[derive(Clone)]
pub(super) struct VerneedVersion {
pub name: Vec<u8>,
pub hash: u32,
pub out_index: u16,
}
#[derive(Clone, Default)]
pub(super) struct VersionPlan {
pub needs: Vec<VerneedEntry>,
pub versym_by_name: FxHashMap<Vec<u8>, u16>,
}
impl VersionPlan {
pub fn has_versions(&self) -> bool {
!self.needs.is_empty()
}
pub fn versym_size(dynsym_count: u64) -> u64 {
dynsym_count.saturating_mul(2)
}
pub fn verneed_size(&self) -> u64 {
let records = u64::try_from(self.needs.len()).unwrap_or(0);
let auxes = self
.needs
.iter()
.map(|n| u64::try_from(n.versions.len()).unwrap_or(0))
.sum::<u64>();
(records.saturating_add(auxes)).saturating_mul(16)
}
pub fn verneed_count(&self) -> u32 {
u32::try_from(self.needs.len()).unwrap_or(0)
}
pub fn dynstr_size(&self) -> u64 {
let mut total = 0u64;
for n in &self.needs {
total = total
.saturating_add(u64::try_from(n.soname.len()).unwrap_or(0))
.saturating_add(1);
for v in &n.versions {
total = total
.saturating_add(u64::try_from(v.name.len()).unwrap_or(0))
.saturating_add(1);
}
}
total
}
}
fn collect_requirements(
ctx: &Context<'_>,
import_names: &[Vec<u8>],
) -> Vec<(Vec<u8>, Vec<u8>, u32)> {
let mut needs: Vec<(Vec<u8>, Vec<u8>, u32)> = Vec::new();
for name in import_names {
if name.is_empty() {
continue;
}
let Some(ver) = ctx.dep_versions.get(name) else {
continue;
};
if needs
.iter()
.any(|(s, n, _)| *s == ver.soname && *n == ver.name)
{
continue;
}
needs.push((ver.soname.clone(), ver.name.clone(), ver.hash));
}
needs
}
fn build_needs(
reqs: Vec<(Vec<u8>, Vec<u8>, u32)>,
) -> (Vec<VerneedEntry>, FxHashMap<Vec<u8>, usize>) {
let mut needs: Vec<VerneedEntry> = Vec::new();
let mut soname_pos: FxHashMap<Vec<u8>, usize> = FxHashMap::default();
let mut next_index: u16 = VER_NDX_GLOBAL.checked_add(1).unwrap_or(2);
for (soname, vname, vhash) in reqs {
let pos = *soname_pos.entry(soname.clone()).or_insert_with(|| {
let p = needs.len();
needs.push(VerneedEntry {
soname,
versions: Vec::new(),
});
p
});
let Some(entry) = needs.get_mut(pos) else {
continue;
};
let idx = next_index;
next_index = next_index.saturating_add(1);
entry.versions.push(VerneedVersion {
name: vname,
hash: vhash,
out_index: idx,
});
}
(needs, soname_pos)
}
pub(super) fn dep_row_names(
table: &DynSym,
layout: &Layout,
out: &mut Vec<Vec<u8>>,
) {
let copies: FxHashSet<&[u8]> =
copy_rows(layout).map(|(_, n)| n.name.as_slice()).collect();
out.clear();
for e in &table.entries {
let name = cstr_at(&table.strtab, e.name_off);
if e.shndx == SHN_UNDEF || copies.contains(name) {
out.push(name.to_vec());
}
}
}
pub(super) fn build(
ctx: &Context<'_>,
import_names: &[Vec<u8>],
) -> VersionPlan {
let (needs, soname_pos) =
build_needs(collect_requirements(ctx, import_names));
let mut versym_by_name: FxHashMap<Vec<u8>, u16> = FxHashMap::default();
for name in import_names {
if name.is_empty() {
continue;
}
let Some(ver) = ctx.dep_versions.get(name) else {
continue;
};
let Some(&pos) = soname_pos.get(&ver.soname) else {
continue;
};
let Some(entry) = needs.get(pos) else {
continue;
};
let Some(v) = entry.versions.iter().find(|v| v.name == ver.name) else {
continue;
};
versym_by_name.insert(name.clone(), v.out_index);
}
VersionPlan {
needs,
versym_by_name,
}
}
pub(super) fn size_for(
ctx: &Context<'_>,
import_names: &[Vec<u8>],
) -> VersionPlan {
let (needs, _soname_pos) =
build_needs(collect_requirements(ctx, import_names));
VersionPlan {
needs,
versym_by_name: FxHashMap::default(),
}
}
pub(super) fn build_versym(table: &DynSym, plan: &VersionPlan) -> Vec<u8> {
let mut bytes = Vec::with_capacity(
table.entries.len().saturating_add(1).saturating_mul(2),
);
push_u16(&mut bytes, VER_NDX_LOCAL);
for e in &table.entries {
let name = cstr_at(&table.strtab, e.name_off);
let v = plan
.versym_by_name
.get(name)
.copied()
.unwrap_or(VER_NDX_GLOBAL);
push_u16(&mut bytes, v);
}
bytes
}
pub(super) fn build_verneed(
plan: &VersionPlan,
dynstr: &mut Vec<u8>,
) -> Vec<u8> {
use crate::elf::{Vernaux64, Verneed64};
let n = plan.needs.len();
if n == 0 {
return Vec::new();
}
let mut soname_off = Vec::with_capacity(n);
for need in &plan.needs {
soname_off.push(intern(dynstr, &need.soname));
}
let mut aux_off: Vec<Vec<(u32, u32)>> = Vec::with_capacity(n);
for need in &plan.needs {
let mut row = Vec::with_capacity(need.versions.len());
for v in &need.versions {
row.push((v.hash, intern(dynstr, &v.name)));
}
aux_off.push(row);
}
let mut vernext_off = Vec::with_capacity(n);
let mut cursor = 0usize;
for need in &plan.needs {
vernext_off.push(cursor);
cursor += core::mem::size_of::<Verneed64>();
cursor += need.versions.len() * core::mem::size_of::<Vernaux64>();
}
let mut bytes =
Vec::with_capacity(usize::try_from(plan.verneed_size()).unwrap_or(0));
for (i, need) in plan.needs.iter().enumerate() {
let base = vernext_off[i];
let next_verneed_off = if i + 1 < n {
vernext_off[i + 1].saturating_sub(base)
} else {
0
};
let rec = Verneed64 {
vn_version: U16::new(1),
vn_cnt: U16::new(
u16::try_from(need.versions.len()).unwrap_or(u16::MAX),
),
vn_file: U32::new(soname_off[i]),
vn_aux: U32::new(
u32::try_from(core::mem::size_of::<Verneed64>()).unwrap_or(0),
),
vn_next: U32::new(u32::try_from(next_verneed_off).unwrap_or(0)),
};
push_pod(&mut bytes, &rec);
for (j, v) in need.versions.iter().enumerate() {
let (hash, name_off) = aux_off[i][j];
let next_vernaux_off = if j + 1 < need.versions.len() {
u32::try_from(core::mem::size_of::<Vernaux64>()).unwrap_or(0)
} else {
0
};
let aux = Vernaux64 {
vna_hash: U32::new(hash),
vna_flags: U16::new(0),
vna_other: U16::new(v.out_index),
vna_name: U32::new(name_off),
vna_next: U32::new(next_vernaux_off),
};
push_pod(&mut bytes, &aux);
}
}
bytes
}
fn push_u16(out: &mut Vec<u8>, value: u16) {
out.extend_from_slice(&value.to_le_bytes());
}
fn push_pod<T: Pod>(out: &mut Vec<u8>, value: &T) {
out.extend_from_slice(bytemuck::bytes_of(value));
}