use rayon::prelude::*;
use super::sections::{CopyItem, copy_member_into, split_member_slices};
use crate::{
error::Result,
layout::{Layout, Region},
linker::Context,
reloc::Target,
util::align_up,
};
pub(super) type DebugPlan = Vec<Region>;
pub(super) fn plan_debug(ctx: &Context<'_>, start: u64) -> DebugPlan {
let mut regions = Vec::with_capacity(ctx.debug.sections.len());
let mut cursor = start;
for sec in &ctx.debug.sections {
let align = sec.align.max(1);
cursor = align_up(cursor, align);
regions.push(Region {
offset: cursor,
vaddr: 0,
size: sec.size,
});
cursor = cursor.saturating_add(sec.size);
}
regions
}
pub(super) fn debug_end(plan: &DebugPlan, start: u64) -> u64 {
plan.iter().map(|r| r.end()).fold(start, u64::max)
}
pub(super) fn write_debug_bytes(
ctx: &Context<'_>,
target: Target,
layout: &Layout,
plan: &DebugPlan,
image: &mut [u8],
) -> Result<()> {
if ctx.debug.is_empty() {
return Ok(());
}
let mut items = Vec::new();
for (i, sec) in ctx.debug.sections.iter().enumerate() {
let Some(region) = plan.get(i) else {
continue;
};
let tombstone = Some(tombstone_for(&sec.name));
for m in &sec.members {
let len = usize::try_from(m.size).unwrap_or(0);
if len == 0 {
continue;
}
let start =
usize::try_from(region.offset.wrapping_add(m.out_offset))
.unwrap_or(usize::MAX);
items.push(CopyItem {
has_discarded: false,
file: m.file,
section: m.section,
start,
len,
vaddr: m.out_offset,
tombstone,
});
}
}
items.sort_by_key(|i| i.start);
let mut slices = split_member_slices(image, &items)?;
slices
.par_iter_mut()
.enumerate()
.map(|(i, slice)| {
copy_member_into(ctx, target, layout, false, items[i], slice)
})
.collect::<Result<Vec<()>>>()?;
Ok(())
}
fn tombstone_for(name: &[u8]) -> u64 {
match name {
b".debug_loc" | b".debug_ranges" => 1,
b".debug_names" => u64::MAX,
_ => 0,
}
}