use super::{SYM_SIZE, dwarf::DebugPlan, symtab::StrTab};
use crate::{
debug::DebugSection,
elf::{
Shdr64,
constants::{SHT_STRTAB, SHT_SYMTAB},
},
endian::{U32, U64},
layout::{
Layout,
sect::{self, Info, Link, Sect, Spec},
},
};
#[derive(Default)]
pub(super) struct PlanShdr {
pub(super) name_off: u32,
pub(super) type_: u32,
pub(super) flags: u64,
pub(super) addr: u64,
pub(super) offset: u64,
pub(super) size: u64,
pub(super) align: u64,
pub(super) link: u32,
pub(super) info: u32,
pub(super) entsize: u64,
}
pub(super) struct TableOffsets {
pub(super) symtab_off: u64,
pub(super) symtab_size: u64,
pub(super) symtab_first_global: u32,
pub(super) strtab_off: u64,
pub(super) strtab_size: u64,
pub(super) shstrtab_off: u64,
}
pub(super) fn build_shdrs(
layout: &Layout,
shstrtab: &mut StrTab,
off: &TableOffsets,
debug_plan: &DebugPlan,
debug_sections: &[DebugSection],
symbols: bool,
) -> Vec<PlanShdr> {
let mut out = Vec::with_capacity(sect::TABLE.len().saturating_add(12));
out.push(PlanShdr::default());
for (sect, spec) in §::TABLE {
if layout.shndx(*sect) == 0 {
continue;
}
let region = layout.region(*sect);
let align = layout.sect_align(*sect, spec);
debug_assert!(
region.vaddr.is_multiple_of(align),
"a region's address is a multiple of the alignment it reports"
);
out.push(PlanShdr {
name_off: shstrtab.intern(spec.name),
type_: spec.sh_type,
flags: spec.flags,
addr: region.vaddr,
offset: region.offset,
size: region.size,
align,
link: sh_link(layout, spec),
info: sh_info(layout, spec),
entsize: spec.entsize,
});
}
push_debug_shdrs(debug_sections, debug_plan, shstrtab, &mut out);
push_trailing_shdrs(&mut out, shstrtab, off, symbols);
out
}
fn sh_link(layout: &Layout, spec: &Spec) -> u32 {
match spec.link {
Link::None => 0,
Link::Dynsym => u32::from(layout.shndx(Sect::Dynsym)),
Link::Dynstr => u32::from(layout.shndx(Sect::Dynstr)),
}
}
fn sh_info(layout: &Layout, spec: &Spec) -> u32 {
match spec.info {
Info::Zero => 0,
Info::FirstGlobal => 1,
Info::VerneedCount => {
layout.dynamic.as_ref().map_or(0, |p| p.verneed_count)
}
Info::GotPlt => u32::from(layout.shndx(Sect::GotPlt)),
}
}
fn push_trailing_shdrs(
out: &mut Vec<PlanShdr>,
shstrtab: &mut StrTab,
off: &TableOffsets,
symbols: bool,
) {
if symbols {
let strtab_idx = u32::try_from(out.len() + 1).unwrap_or(0);
out.push(PlanShdr {
name_off: shstrtab.intern(b".symtab"),
type_: SHT_SYMTAB,
offset: off.symtab_off,
size: off.symtab_size,
align: 8,
link: strtab_idx,
info: off.symtab_first_global,
entsize: SYM_SIZE,
..PlanShdr::default()
});
let strtab_name = shstrtab.intern(b".strtab");
out.push(strtab_shdr(strtab_name, off.strtab_off, off.strtab_size));
}
let shstrtab_name = shstrtab.intern(b".shstrtab");
let size = u64::try_from(shstrtab.bytes.len()).unwrap_or(0);
out.push(strtab_shdr(shstrtab_name, off.shstrtab_off, size));
}
fn strtab_shdr(name_off: u32, offset: u64, size: u64) -> PlanShdr {
PlanShdr {
name_off,
type_: SHT_STRTAB,
offset,
size,
align: 1,
..PlanShdr::default()
}
}
fn push_debug_shdrs(
debug_sections: &[DebugSection],
plan: &DebugPlan,
shstrtab: &mut StrTab,
out: &mut Vec<PlanShdr>,
) {
for (i, sec) in debug_sections.iter().enumerate() {
let Some(region) = plan.get(i) else {
continue;
};
out.push(PlanShdr {
name_off: shstrtab.intern(&sec.name),
type_: sec.sh_type,
flags: sec.sh_flags,
offset: region.offset,
size: region.size,
align: sec.align.max(1),
entsize: sec.entsize,
..PlanShdr::default()
});
}
}
pub(super) fn materialise(p: &PlanShdr) -> Shdr64 {
Shdr64 {
sh_name: U32::new(p.name_off),
sh_type: U32::new(p.type_),
sh_flags: U64::new(p.flags),
sh_addr: U64::new(p.addr),
sh_offset: U64::new(p.offset),
sh_size: U64::new(p.size),
sh_link: U32::new(p.link),
sh_info: U32::new(p.info),
sh_addralign: U64::new(p.align),
sh_entsize: U64::new(p.entsize),
}
}