mod bytes;
mod dwarf;
mod ehdr;
mod got;
mod phdrs;
mod sections;
mod shdrs;
mod symtab;
use std::path::Path;
use bytes::{write_dynamic_bytes, write_plt_bytes};
use dwarf::{DebugPlan, debug_end, plan_debug, write_debug_bytes};
use ehdr::write_ehdr;
use got::fill_got;
use sections::copy_sections;
use shdrs::{TableOffsets, build_shdrs, materialise};
use symtab::{StrTab, SymtabPlan, build_symtab};
use crate::{
dynamic::{DynConfig, DynamicPlan, LinkMode, Strip},
elf::{Shdr64, Sym64},
error::{Error, Result},
layout::{Layout, Region, Sect, sect},
linker::Context,
mmap_file::OutputFile,
plt::PltPlan,
reloc::Target,
util::align_up,
};
const SHDR_SIZE: u64 = 64;
const EHDR_SIZE: u64 = 64;
const PHDR_SIZE: u64 = 56;
const SYM_SIZE: u64 = 24;
const DYNAMIC_ENTRY_SIZE: u64 = 16;
const EV_CURRENT: u32 = 1;
struct ImagePlan {
debug: DebugPlan,
syms: Vec<Sym64>,
strtab: StrTab,
shdr_count: usize,
shstrtab: StrTab,
off: TableOffsets,
shdr_off: u64,
total: u64,
}
pub fn write(
ctx: &Context<'_>,
target: Target,
layout: &mut Layout,
mode: LinkMode,
config: &DynConfig<'_>,
output: &Path,
) -> Result<()> {
let plan = plan_image(ctx, layout, config.strip)?;
let mut file = OutputFile::create(output, plan.total)?;
fill_image(ctx, target, layout, mode, config, &plan, file.bytes())?;
file.finish()
}
fn plan_image(
ctx: &Context<'_>,
layout: &Layout,
strip: Strip,
) -> Result<ImagePlan> {
let loaded = loaded_extent(layout);
let debug = if strip == Strip::None {
plan_debug(ctx, loaded)
} else {
DebugPlan::new()
};
let mut strtab = StrTab::new();
let symtab = if strip == Strip::All {
SymtabPlan::default()
} else {
build_symtab(ctx, layout, &mut strtab)?
};
let syms = symtab.syms;
let symtab_size =
u64::try_from(syms.len()).unwrap_or(0xffff_ffff) * SYM_SIZE;
let strtab_size = u64::try_from(strtab.bytes.len()).unwrap_or(0);
let symtab_off = align_up(debug_end(&debug, loaded), 8);
let strtab_off = symtab_off.saturating_add(symtab_size);
let shstrtab_off = strtab_off.saturating_add(strtab_size);
let off = TableOffsets {
symtab_off,
symtab_size,
symtab_first_global: symtab.first_global,
strtab_off,
strtab_size,
shstrtab_off,
};
let mut shstrtab = StrTab::new();
let shdrs = build_shdrs(
layout,
&mut shstrtab,
&off,
&debug,
debug_sections(ctx, strip),
strip != Strip::All,
);
let shstrtab_size = u64::try_from(shstrtab.bytes.len()).unwrap_or(0);
let shdr_off = align_up(shstrtab_off.saturating_add(shstrtab_size), 8);
let total = shdr_off
.saturating_add(u64::try_from(shdrs.len()).unwrap_or(0) * SHDR_SIZE);
Ok(ImagePlan {
debug,
syms,
strtab,
shdr_count: shdrs.len(),
shstrtab,
off,
shdr_off,
total,
})
}
fn write_build_id(config: &DynConfig<'_>, layout: &Layout, image: &mut [u8]) {
let Some(build_id) = config.build_id else {
return;
};
let at = layout.region(Sect::BuildId).offset;
if layout.region(Sect::BuildId).size == 0 {
return;
}
build_id.write_header(image, at);
build_id.fill(image, at);
}
fn debug_sections<'a>(
ctx: &'a Context<'_>,
strip: Strip,
) -> &'a [crate::debug::DebugSection] {
if strip == Strip::None {
&ctx.debug.sections
} else {
&[]
}
}
fn loaded_extent(layout: &Layout) -> u64 {
let headers = EHDR_SIZE + u64::from(layout.phdr_count()) * PHDR_SIZE;
sect::TABLE
.iter()
.filter(|(s, _)| sect::file_backed(*s))
.map(|(s, _)| layout.region(*s).end())
.fold(headers, u64::max)
}
fn fill_image(
ctx: &Context<'_>,
target: Target,
layout: &mut Layout,
mode: LinkMode,
config: &DynConfig<'_>,
plan: &ImagePlan,
image: &mut [u8],
) -> Result<()> {
let base = layout.base();
let relax = config.relax;
let shared: &Layout = layout;
let (copied, plans) = rayon::join(
|| write_loaded(ctx, target, shared, base, relax, image),
|| build_plans(ctx, shared, target, mode, config),
);
copied?;
let (dyn_plan, plt_plan) = plans?;
if let Some(p) = dyn_plan {
layout.dynamic = Some(p);
}
if let Some(p) = plt_plan {
layout.plt_plan = Some(p);
}
let mut shstrtab = StrTab::new();
let shdrs = build_shdrs(
layout,
&mut shstrtab,
&plan.off,
&plan.debug,
debug_sections(ctx, config.strip),
config.strip != Strip::All,
);
debug_assert_eq!(shstrtab.bytes, plan.shstrtab.bytes);
debug_assert_eq!(shdrs.len(), plan.shdr_count);
if let Some(dyn_plan) = layout.dynamic.as_ref() {
write_dynamic_bytes(dyn_plan, image)?;
}
if let Some(plt_plan) = layout.plt_plan.as_ref() {
write_plt_bytes(plt_plan, layout, image)?;
}
write_debug_bytes(ctx, target, layout, &plan.debug, image)?;
write_slice_at_par(
image,
plan.off.symtab_off,
bytemuck::cast_slice(&plan.syms),
);
write_slice_at_par(image, plan.off.strtab_off, &plan.strtab.bytes);
write_slice_at(image, plan.off.shstrtab_off, &plan.shstrtab.bytes);
let table: Vec<Shdr64> = shdrs.iter().map(materialise).collect();
write_slice_at(image, plan.shdr_off, bytemuck::cast_slice(&table));
let shstrtab_shndx =
u16::try_from(shdrs.len().saturating_sub(1)).unwrap_or(0);
write_ehdr(
image,
target,
layout,
plan.shdr_off,
shdrs.len(),
shstrtab_shndx,
)?;
phdrs::write_phdrs(image, layout, base);
write_build_id(config, layout, image);
crate::util::check_truncated_write()?;
Ok(())
}
fn build_plans(
ctx: &Context<'_>,
layout: &Layout,
target: Target,
mode: LinkMode,
config: &DynConfig<'_>,
) -> Result<(Option<DynamicPlan>, Option<PltPlan>)> {
let dyn_plan = if mode.is_dynamic() {
Some(crate::dynamic::build_plan_from(
ctx, layout, target, mode, config,
)?)
} else {
None
};
let plt_plan = if layout.plt_keys.is_empty() {
None
} else {
Some(crate::plt::build_plan(layout, dyn_plan.as_ref())?)
};
Ok((dyn_plan, plt_plan))
}
fn write_loaded(
ctx: &Context<'_>,
target: Target,
layout: &Layout,
base: u64,
relax: bool,
image: &mut [u8],
) -> Result<()> {
let end = usize::try_from(loaded_extent(layout)).unwrap_or(usize::MAX);
let loaded = image.get_mut(..end).ok_or(Error::OutOfRange("image"))?;
copy_sections(ctx, target, layout, base, relax, loaded)?;
fill_got(layout, loaded);
if layout.has_interp() {
write_region(
image,
layout.region(Sect::Interp),
&layout.interp,
".interp",
)?;
}
if layout.region(Sect::EhFrameHdr).size != 0 {
let hdr = crate::ehframe::build_hdr(image, layout)?;
write_region(
image,
layout.region(Sect::EhFrameHdr),
&hdr,
".eh_frame_hdr",
)?;
}
Ok(())
}
fn write_slice_at(image: &mut [u8], offset: u64, bytes: &[u8]) {
let start = usize::try_from(offset).unwrap_or(usize::MAX);
let end = start.saturating_add(bytes.len());
if let Some(slot) = image.get_mut(start..end) {
slot.copy_from_slice(bytes);
}
}
fn write_slice_at_par(image: &mut [u8], offset: u64, bytes: &[u8]) {
use rayon::prelude::*;
const CHUNK: usize = 1 << 20;
let start = usize::try_from(offset).unwrap_or(usize::MAX);
let end = start.saturating_add(bytes.len());
if let Some(slot) = image.get_mut(start..end) {
slot.par_chunks_mut(CHUNK)
.zip(bytes.par_chunks(CHUNK))
.for_each(|(dst, src)| dst.copy_from_slice(src));
}
}
fn write_region(
image: &mut [u8],
region: Region,
bytes: &[u8],
what: &'static str,
) -> Result<()> {
if u64::try_from(bytes.len()).unwrap_or(u64::MAX) > region.size {
return Err(Error::OutOfRange(what));
}
let start =
usize::try_from(region.offset).map_err(|_| Error::OutOfRange(what))?;
let end = start
.checked_add(bytes.len())
.ok_or(Error::OutOfRange(what))?;
let slot = image.get_mut(start..end).ok_or(Error::OutOfRange(what))?;
slot.copy_from_slice(bytes);
Ok(())
}