mod build;
mod edit;
mod inspect;
mod parse;
mod validate;
pub use parse::Layout;
use alloc::vec::Vec;
use crate::header::ElfHeader;
use crate::ident::ElfIdent;
use crate::program::Segment;
use crate::section::Section;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ElfImage {
pub(crate) ident: ElfIdent,
pub(crate) header: ElfHeader,
pub(crate) segments: Vec<Segment>,
pub(crate) sections: Vec<Section>,
pub(crate) runtime_base: u64,
}
impl ElfImage {
#[must_use]
pub const fn ident(&self) -> ElfIdent {
self.ident
}
#[must_use]
pub const fn header(&self) -> &ElfHeader {
&self.header
}
pub fn header_mut(&mut self) -> &mut ElfHeader {
&mut self.header
}
#[must_use]
pub fn segments(&self) -> &[Segment] {
&self.segments
}
pub fn segments_mut(&mut self) -> &mut Vec<Segment> {
&mut self.segments
}
#[must_use]
pub fn sections(&self) -> &[Section] {
&self.sections
}
pub fn sections_mut(&mut self) -> &mut Vec<Section> {
&mut self.sections
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) struct ImageGeometry {
pub base: u64,
pub page: u64,
pub span: u64,
}
pub(crate) fn geometry(loads: impl Iterator<Item = (u64, u64, u64)>) -> ImageGeometry {
let mut page: u64 = 0x1000;
let mut min_vaddr: Option<u64> = None;
let mut max_end: u64 = 0;
for (vaddr, memsz, align) in loads {
if memsz == 0 {
continue;
}
min_vaddr = Some(min_vaddr.map_or(vaddr, |current| current.min(vaddr)));
max_end = max_end.max(vaddr.saturating_add(memsz));
if align > 1 {
page = page.max(align);
}
}
let Some(min_vaddr) = min_vaddr else {
return ImageGeometry {
base: 0,
page,
span: 0,
};
};
let base = min_vaddr - (min_vaddr % page);
let span = align_up(max_end, page).saturating_sub(base);
ImageGeometry { base, page, span }
}
pub(crate) const fn align_up(value: u64, alignment: u64) -> u64 {
if alignment <= 1 {
return value;
}
let remainder = value % alignment;
if remainder == 0 {
value
} else {
value.saturating_add(alignment - remainder)
}
}