use super::{EHDR_SIZE, GOT_ENTRY, PAGE, PHDR_SIZE, max_page_size};
use crate::{
dynamic::{DYNAMIC_ALIGN, DynConfig, LinkMode},
layout::{Context, Layout, OutKind, Region, Sect, sect},
startstop::Bounds,
symbol::SymbolKind,
util::align_up,
};
pub(super) fn stamp_debug_offsets(ctx: &Context<'_>, layout: &mut Layout) {
for sec in &ctx.debug.sections {
for m in &sec.members {
if ctx.merge.is_merged(m.file, m.section) {
continue;
}
if let Some(f) = layout.sec_vaddr.get_mut(m.file)
&& let Some(slot) = f.get_mut(usize::from(m.section))
{
*slot = m.out_offset;
}
}
}
}
pub(super) fn interp_bytes(config: &DynConfig<'_>, mode: LinkMode) -> Vec<u8> {
if mode != LinkMode::DynExec {
return Vec::new();
}
let Some(path) = config.interpreter else {
return Vec::new();
};
let mut bytes = Vec::with_capacity(path.len().saturating_add(1));
bytes.extend_from_slice(path);
bytes.push(0);
bytes
}
fn plt_section_size(layout: &Layout) -> u64 {
let spec = layout.target.plt_spec();
let entries = u64::try_from(layout.plt_keys.len()).unwrap_or(0);
spec.header_size
.wrapping_add(entries.wrapping_mul(spec.entry_size))
}
fn got_plt_section_size(layout: &Layout) -> u64 {
let spec = layout.target.plt_spec();
let entries = u64::try_from(layout.plt_keys.len()).unwrap_or(0);
spec.got_plt_reserved
.wrapping_mul(GOT_ENTRY)
.wrapping_add(entries.wrapping_mul(GOT_ENTRY))
}
fn rela_plt_section_size(layout: &Layout) -> u64 {
let entries = u64::try_from(layout.plt_keys.len()).unwrap_or(0);
entries.wrapping_mul(24)
}
pub(super) struct Relative {
member: Vec<Vec<u64>>,
size: [u64; OutKind::COUNT],
align: [u64; OutKind::COUNT],
}
impl Relative {
fn member_offset(&self, file: usize, section: u16) -> u64 {
self.member
.get(file)
.and_then(|f| f.get(usize::from(section)))
.copied()
.unwrap_or_default()
}
pub(super) fn size(&self, kind: OutKind) -> u64 {
self.size.get(kind.index()).copied().unwrap_or_default()
}
pub(super) fn align(&self, kind: OutKind) -> u64 {
self.align.get(kind.index()).copied().unwrap_or(1)
}
fn set(&mut self, kind: OutKind, size: u64, align: u64) {
if let Some(slot) = self.size.get_mut(kind.index()) {
*slot = size;
}
if let Some(slot) = self.align.get_mut(kind.index()) {
*slot = align;
}
}
}
pub(super) fn measure_sections(
ctx: &Context<'_>,
member: Vec<Vec<u64>>,
) -> (Relative, Vec<u64>) {
let mut rel = Relative {
member,
size: [0; OutKind::COUNT],
align: [1; OutKind::COUNT],
};
for out in ctx.outputs.iter() {
let mut cursor = 0u64;
let align = out.align.max(1);
let packed = out.kind == OutKind::EhFrame;
for m in &out.members {
if !packed {
cursor = align_up(cursor, m.align);
}
if let Some(f) = rel.member.get_mut(m.file)
&& let Some(slot) = f.get_mut(usize::from(m.section))
{
*slot = cursor;
}
cursor = cursor.saturating_add(m.size);
}
let size = if packed {
cursor
} else {
align_up(cursor, align)
};
rel.set(out.kind, size, align);
}
let common_off = measure_commons(ctx, &mut rel);
(rel, common_off)
}
fn measure_commons(ctx: &Context<'_>, rel: &mut Relative) -> Vec<u64> {
let mut off = vec![0u64; ctx.symbols.len()];
let mut cursor = rel.size(OutKind::Bss);
let mut align = rel.align(OutKind::Bss);
for id in ctx.symbols.ids() {
let Some(sym) = ctx.symbols.symbol(id) else {
continue;
};
if let SymbolKind::Common { size, align: a, .. } = &sym.kind {
let a = (*a).max(1);
align = align.max(a);
cursor = align_up(cursor, a);
off[id.0] = cursor;
cursor = cursor.saturating_add(*size);
}
}
rel.set(OutKind::Bss, align_up(cursor, 16), align);
off
}
#[derive(Clone, Copy)]
pub(super) struct Sizes {
pub eh_frame_hdr: u64,
pub build_id: u64,
}
pub(super) fn place_regions(
ctx: &Context<'_>,
rel: &Relative,
mode: LinkMode,
sizes: Sizes,
layout: &mut Layout,
) {
let eh_frame_hdr_size = sizes.eh_frame_hdr;
let dynamic = mode.is_dynamic();
let has_interp = !layout.interp.is_empty();
let has_plt = !layout.plt_keys.is_empty();
let has_eh_frame_hdr = eh_frame_hdr_size != 0;
let has_note = rel.size(OutKind::Note) != 0 || sizes.build_id != 0;
let rw = RW_ORDER
.iter()
.any(|&(_, src)| rw_present(rel, layout, src));
let relro = RW_ORDER
.iter()
.any(|&(s, src)| sect::relro(s) && rw_present(rel, layout, src));
let has_tls = rel.size(OutKind::Tdata) != 0 || rel.size(OutKind::Tbss) != 0;
let has_phdr = mode == LinkMode::DynExec && layout.pie;
layout.phdr_count = 1
+ u16::from(has_phdr)
+ u16::from(has_interp)
+ u16::from(rw)
+ 1
+ u16::from(has_tls)
+ u16::from(dynamic)
+ u16::from(relro)
+ u16::from(has_eh_frame_hdr)
+ u16::from(has_note);
let headers = EHDR_SIZE + u64::from(layout.phdr_count) * PHDR_SIZE;
let flags = RxFlags {
has_interp,
has_plt,
has_eh_frame_hdr,
dynamic,
};
let rx_end = place_rx_segment(ctx, rel, flags, sizes, headers, layout);
if rw {
place_rw_segment(ctx, rel, rx_end, layout);
}
}
#[derive(Clone, Copy)]
#[allow(clippy::struct_excessive_bools)]
struct RxFlags {
has_interp: bool,
has_plt: bool,
has_eh_frame_hdr: bool,
dynamic: bool,
}
fn place_rx_segment(
ctx: &Context<'_>,
rel: &Relative,
flags: RxFlags,
sizes: Sizes,
headers: u64,
layout: &mut Layout,
) -> u64 {
let eh_frame_hdr_size = sizes.eh_frame_hdr;
let mut cursor = headers;
if flags.has_interp {
let size = u64::try_from(layout.interp.len()).unwrap_or(0);
layout.interp_region = region_at(layout, cursor, size);
cursor = layout.interp_region.end();
}
if sizes.build_id != 0 {
let off = align_up(cursor, 4);
layout.build_id = region_at(layout, off, sizes.build_id);
cursor = layout.build_id.end();
}
cursor = place_output_after(ctx, rel, OutKind::Note, cursor, layout);
cursor = place_output_after(ctx, rel, OutKind::Init, cursor, layout);
cursor = place_output_after(ctx, rel, OutKind::Text, cursor, layout);
cursor = place_output_after(ctx, rel, OutKind::Fini, cursor, layout);
let plt_start = align_up(cursor, 16);
if flags.has_plt {
layout.plt = region_at(layout, plt_start, plt_section_size(layout));
}
cursor = place_output_after(
ctx,
rel,
OutKind::Rodata,
layout.plt.end().max(cursor),
layout,
);
let mut rx_end =
place_output_after(ctx, rel, OutKind::EhFrame, cursor, layout);
if flags.has_eh_frame_hdr {
let off = align_up(rx_end, 4);
layout.eh_frame_hdr = region_at(layout, off, eh_frame_hdr_size);
rx_end = layout.eh_frame_hdr.end();
}
if flags.dynamic {
rx_end = crate::dynamic::place_ro(layout, rx_end);
}
if flags.has_plt {
let off = align_up(rx_end, 8);
layout.rela_plt = region_at(layout, off, rela_plt_section_size(layout));
rx_end = layout.rela_plt.end();
}
rx_end
}
fn region_at(layout: &Layout, offset: u64, size: u64) -> Region {
Region {
offset,
vaddr: layout.base.wrapping_add(offset),
size,
}
}
fn place_output_after(
ctx: &Context<'_>,
rel: &Relative,
kind: OutKind,
cursor: u64,
layout: &mut Layout,
) -> u64 {
let align = rel.align(kind);
let start = align_up(cursor, align);
place_output(ctx, rel, kind, start, align, layout);
layout.region(region_sect(kind)).end().max(start)
}
#[derive(Copy, Clone, Eq, PartialEq)]
enum RwSource {
Dynamic,
Got,
GotPlt,
Out(OutKind),
}
const RW_ORDER: [(Sect, RwSource); 11] = [
(Sect::Dynamic, RwSource::Dynamic),
(Sect::Got, RwSource::Got),
(Sect::DataRelRo, RwSource::Out(OutKind::DataRelRo)),
(Sect::PreinitArray, RwSource::Out(OutKind::PreinitArray)),
(Sect::InitArray, RwSource::Out(OutKind::InitArray)),
(Sect::FiniArray, RwSource::Out(OutKind::FiniArray)),
(Sect::GotPlt, RwSource::GotPlt),
(Sect::Data, RwSource::Out(OutKind::Data)),
(Sect::Tdata, RwSource::Out(OutKind::Tdata)),
(Sect::Tbss, RwSource::Out(OutKind::Tbss)),
(Sect::Bss, RwSource::Out(OutKind::Bss)),
];
fn place_rw_segment(
ctx: &Context<'_>,
rel: &Relative,
rx_end: u64,
layout: &mut Layout,
) {
debug_assert!(
sect::TABLE
.iter()
.filter(|(_, spec)| sect::writable(spec))
.map(|(s, _)| *s)
.eq(RW_ORDER.iter().map(|&(s, _)| s)),
"read-write placement order matches the section table"
);
let mut cursor = align_up(rx_end, max_page_size(layout.target));
let mut in_relro = false;
layout.tls_align = tls_align(rel);
for (sect, source) in RW_ORDER {
if !rw_present(rel, layout, source) {
continue;
}
if in_relro && !sect::relro(sect) {
cursor = align_up(cursor, PAGE);
}
in_relro = sect::relro(sect);
let align = rw_align(rel, source);
let start = align_up(cursor, align);
cursor = place_rw_region(ctx, rel, source, start, align, layout);
}
place_copy_slots(layout);
}
fn rw_present(rel: &Relative, layout: &Layout, source: RwSource) -> bool {
if source == RwSource::Out(OutKind::Bss) && !layout.copy_slots.is_empty() {
return true;
}
rw_size(rel, layout, source) != 0
}
fn rw_size(rel: &Relative, layout: &Layout, source: RwSource) -> u64 {
match source {
RwSource::Dynamic => {
layout.dynamic.as_ref().map_or(0, |p| p.sizes.dynamic)
}
RwSource::Got => u64::try_from(layout.got_values.len())
.unwrap_or(0)
.saturating_mul(GOT_ENTRY),
RwSource::GotPlt => {
if layout.plt_keys.is_empty() {
0
} else {
got_plt_section_size(layout)
}
}
RwSource::Out(kind) => rel.size(kind),
}
}
fn tls_align(rel: &Relative) -> u64 {
rel.align(OutKind::Tdata).max(rel.align(OutKind::Tbss))
}
fn rw_align(rel: &Relative, source: RwSource) -> u64 {
match source {
RwSource::Dynamic => DYNAMIC_ALIGN,
RwSource::Got | RwSource::GotPlt => GOT_ENTRY,
RwSource::Out(OutKind::Bss) => rel.align(OutKind::Bss).max(16),
RwSource::Out(OutKind::Tdata | OutKind::Tbss) => tls_align(rel),
RwSource::Out(kind) => rel.align(kind),
}
}
fn place_rw_region(
ctx: &Context<'_>,
rel: &Relative,
source: RwSource,
start: u64,
align: u64,
layout: &mut Layout,
) -> u64 {
match source {
RwSource::Dynamic => crate::dynamic::place_rw(layout, start),
RwSource::Got => {
place_got(start, layout);
layout.got.end()
}
RwSource::GotPlt => {
let size = got_plt_section_size(layout);
layout.got_plt = region_at(layout, start, size);
layout.got_plt.end()
}
RwSource::Out(OutKind::Bss) => {
place_bss(ctx, rel, start, align, layout);
layout.bss.end()
}
RwSource::Out(OutKind::Tbss) => {
place_output(ctx, rel, OutKind::Tbss, start, align, layout);
start
}
RwSource::Out(kind) => {
place_output(ctx, rel, kind, start, align, layout);
start.wrapping_add(rel.size(kind))
}
}
}
fn place_output(
ctx: &Context<'_>,
rel: &Relative,
kind: OutKind,
start: u64,
align: u64,
layout: &mut Layout,
) {
let Some(out) = ctx.outputs.section(kind) else {
return;
};
let base_vaddr = layout.base.wrapping_add(start);
for m in &out.members {
let vaddr =
base_vaddr.wrapping_add(rel.member_offset(m.file, m.section));
set_section(layout, m.file, m.section, vaddr);
}
set_region(
layout,
kind,
align,
Region {
offset: start,
vaddr: base_vaddr,
size: rel.size(kind),
},
);
}
fn set_region(layout: &mut Layout, kind: OutKind, align: u64, region: Region) {
layout.set_measured_align(region_sect(kind), align);
match kind {
OutKind::Text => layout.text = region,
OutKind::Rodata => layout.rodata = region,
OutKind::Note => layout.note = region,
OutKind::EhFrame => layout.eh_frame = region,
OutKind::DataRelRo => layout.data_rel_ro = region,
OutKind::Data => layout.data = region,
OutKind::Bss => layout.bss = region,
OutKind::Tdata => layout.tdata = region,
OutKind::Tbss => layout.tbss = region,
OutKind::PreinitArray => layout.preinit_array = region,
OutKind::InitArray => layout.init_array = region,
OutKind::FiniArray => layout.fini_array = region,
OutKind::Init => layout.init = region,
OutKind::Fini => layout.fini = region,
}
}
const fn region_sect(kind: OutKind) -> Sect {
match kind {
OutKind::Text => Sect::Text,
OutKind::Rodata => Sect::Rodata,
OutKind::Note => Sect::Note,
OutKind::EhFrame => Sect::EhFrame,
OutKind::DataRelRo => Sect::DataRelRo,
OutKind::Data => Sect::Data,
OutKind::Bss => Sect::Bss,
OutKind::Tdata => Sect::Tdata,
OutKind::Tbss => Sect::Tbss,
OutKind::PreinitArray => Sect::PreinitArray,
OutKind::InitArray => Sect::InitArray,
OutKind::FiniArray => Sect::FiniArray,
OutKind::Init => Sect::Init,
OutKind::Fini => Sect::Fini,
}
}
fn place_got(start: u64, layout: &mut Layout) {
let size = u64::try_from(layout.got_values.len())
.unwrap_or(0)
.saturating_mul(GOT_ENTRY);
layout.got = region_at(layout, start, size);
}
fn place_bss(
ctx: &Context<'_>,
rel: &Relative,
start: u64,
align: u64,
layout: &mut Layout,
) {
let base_vaddr = layout.base.wrapping_add(start);
if let Some(out) = ctx.outputs.section(OutKind::Bss) {
for m in &out.members {
let vaddr =
base_vaddr.wrapping_add(rel.member_offset(m.file, m.section));
set_section(layout, m.file, m.section, vaddr);
}
}
layout.set_measured_align(Sect::Bss, align);
layout.bss = region_at(layout, start, rel.size(OutKind::Bss));
}
fn place_copy_slots(layout: &mut Layout) {
if layout.copy_slots.is_empty() {
return;
}
let start = layout.bss.end();
let mut cursor = start;
let mut max_align = 1u64;
for slot in &mut layout.copy_slots {
let align = slot.align.max(1);
cursor = align_up(cursor, align);
slot.addr = layout.base.wrapping_add(cursor);
cursor = cursor.saturating_add(slot.size);
if align > max_align {
max_align = align;
}
}
let grown = align_up(cursor, max_align.max(16));
layout.bss.size = grown.wrapping_sub(layout.bss.offset);
}
fn set_section(layout: &mut Layout, file: usize, section: u16, vaddr: u64) {
if let Some(f) = layout.sec_vaddr.get_mut(file)
&& let Some(slot) = f.get_mut(usize::from(section))
{
*slot = vaddr;
}
}
pub(super) fn measure_runs(ctx: &Context<'_>, layout: &mut Layout) {
let count = ctx.start_stop.len();
if count == 0 {
return;
}
let mut bounds = vec![Bounds::default(); count];
let mut home: Vec<Option<OutKind>> = vec![None; count];
for out in ctx.outputs.iter() {
for m in &out.members {
let Some(run) = ctx.start_stop.run_of_section(m.file, m.section)
else {
continue;
};
let (Some(slot), Some(seen)) =
(bounds.get_mut(run), home.get_mut(run))
else {
continue;
};
let Some(vaddr) = layout.section_vaddr(m.file, m.section) else {
continue;
};
let end = vaddr.wrapping_add(m.size);
match *seen {
None => {
*seen = Some(out.kind);
slot.start = vaddr;
slot.stop = end;
}
Some(kind) if kind == out.kind => {
slot.stop = slot.stop.max(end);
}
Some(_) => {}
}
}
}
layout.start_stop = bounds;
}
pub(super) fn assign_shndx(ctx: &Context<'_>, layout: &mut Layout) {
let mut next = 1u16;
for (sect, _spec) in sect::TABLE {
if layout.region(sect).size == 0 {
continue;
}
layout.set_shndx(sect, next);
next = next.saturating_add(1);
}
stamp_shndx(ctx, layout);
}
fn stamp_shndx(ctx: &Context<'_>, layout: &mut Layout) {
for out in ctx.outputs.iter() {
let shndx = layout.shndx(region_sect(out.kind));
for m in &out.members {
if let Some(f) = layout.sec_shndx.get_mut(m.file)
&& let Some(slot) = f.get_mut(usize::from(m.section))
{
*slot = shndx;
}
}
}
}