use crate::{
coff::{
CoffFile, CoffSection,
comdat::ComdatPlan,
constants::{
FILE_ALIGNMENT, IMAGE_SCN_ALIGN_MASK, IMAGE_SCN_CNT_CODE,
IMAGE_SCN_CNT_INITIALIZED_DATA, IMAGE_SCN_CNT_UNINITIALIZED_DATA,
IMAGE_SCN_MEM_DISCARDABLE, IMAGE_SCN_MEM_EXECUTE,
IMAGE_SCN_MEM_READ, IMAGE_SCN_MEM_WRITE, SECTION_ALIGNMENT,
},
},
error::{Error, Result},
util::{align_up_u32, pad_name, trim_nul},
};
pub const TLS_DIR_SIZE: u32 = 52;
pub const ENTRY_STUB_SIZE: u32 = 19;
const COMMON_BLOCK_ALIGN: u32 = 32;
const STUB_ALIGN: u64 = 16;
#[derive(Clone, Copy)]
pub struct Member {
pub file: usize,
pub section: u32,
pub size: u64,
pub offset: u64,
pub align: u64,
}
pub struct OutSection {
pub name: [u8; 8],
pub members: Vec<Member>,
pub characteristics: u32,
pub virtual_address: u32,
pub virtual_size: u32,
pub pointer_to_raw_data: u32,
pub size_of_raw_data: u32,
pub zerofill: bool,
}
impl OutSection {
pub const fn has_file_data(&self) -> bool {
!self.zerofill
}
}
pub struct PeLayout {
pub sections: Vec<OutSection>,
pub size_of_headers: u32,
pub size_of_image: u32,
pub address_of_entry_point: u32,
pub base_of_code: u32,
pub image_base: u64,
pub entry_stub_size: u32,
pub commons_off: u32,
pub is_dll: bool,
}
#[allow(clippy::too_many_arguments)]
pub fn build(
inputs: &[CoffFile<'_>],
entry_stub_size: u32,
import_size: u32,
export_size: u32,
reloc_size: u32,
tls_meta_size: u32,
commons_size: u32,
comdats: &ComdatPlan,
image_base: u64,
is_dll: bool,
) -> Result<PeLayout> {
let mut groups: Vec<OutSection> = Vec::new();
gather_input_sections(inputs, comdats, &mut groups)?;
sort_members_by_name(inputs, &mut groups);
add_synthetic_sections(
&mut groups,
import_size,
export_size,
reloc_size,
tls_meta_size,
);
groups.sort_by_key(section_rank);
layout_members(&mut groups, entry_stub_size);
let commons_off = reserve_commons(&mut groups, commons_size);
place(&mut groups)?;
let text_rva = groups
.iter()
.find(|s| s.name == *b".text\0\0\0")
.map(|s| s.virtual_address)
.ok_or(Error::Format("no .text section in inputs"))?;
let size_of_headers = align_up_u32(
headers_extent(u32::try_from(groups.len()).unwrap_or(0)),
FILE_ALIGNMENT,
);
let last = groups
.last()
.ok_or(Error::Format("no sections to lay out"))?;
let image_end = align_up_u32(
last.virtual_address.wrapping_add(last.virtual_size),
SECTION_ALIGNMENT,
);
Ok(PeLayout {
sections: groups,
size_of_headers,
size_of_image: image_end,
address_of_entry_point: if is_dll { 0 } else { text_rva },
base_of_code: text_rva,
image_base,
entry_stub_size,
commons_off,
is_dll,
})
}
fn gather_input_sections(
inputs: &[CoffFile<'_>],
comdats: &ComdatPlan,
groups: &mut Vec<OutSection>,
) -> Result<()> {
let mut rsrc_file: Option<usize> = None;
for (file, input) in inputs.iter().enumerate() {
for section in input.sections() {
if comdats.is_dropped(file, section.index) {
continue;
}
let Some(kind) = classify(section) else {
continue;
};
if matches!(kind, Kind::Tls)
&& member_size(kind, section) == 0
&& section.virtual_size > 0
{
return Err(Error::Format(
"a .tls section with no raw data (BSS-style thread storage) is not supported",
));
}
if member_size(kind, section) == 0 {
continue;
}
if matches!(kind, Kind::Rsrc)
&& rsrc_file.is_some_and(|first| first != file)
{
return Err(Error::Format(
"multiple objects carry .rsrc resource trees; merge them \
into one before linking",
));
}
if matches!(kind, Kind::Rsrc) {
rsrc_file = Some(file);
}
add_member(groups, file, section, kind);
}
}
Ok(())
}
fn add_synthetic_sections(
groups: &mut Vec<OutSection>,
import_size: u32,
export_size: u32,
reloc_size: u32,
tls_meta_size: u32,
) {
const INIT_READ: u32 = IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ;
const READ_WRITE: u32 = INIT_READ | IMAGE_SCN_MEM_WRITE;
const DISCARDABLE: u32 = INIT_READ | IMAGE_SCN_MEM_DISCARDABLE;
let reserved: [(&[u8], u32, u32); 4] = [
(b".idata", import_size, INIT_READ),
(b".tlsdir", tls_meta_size, READ_WRITE),
(b".edata", export_size, INIT_READ),
(b".reloc", reloc_size, DISCARDABLE),
];
for (name, size, characteristics) in reserved {
if size > 0 {
groups.push(synthetic(name, size, characteristics));
}
}
}
fn reserve_commons(groups: &mut Vec<OutSection>, size: u32) -> u32 {
if size == 0 {
return 0;
}
if groups.iter().all(|s| s.name != *b".bss\0\0\0\0") {
let mut bss = synthetic(b".bss", 0, output_chars(Kind::Bss));
bss.zerofill = true;
groups.push(bss);
groups.sort_by_key(section_rank);
}
let Some(bss) = groups.iter_mut().find(|s| s.name == *b".bss\0\0\0\0")
else {
return 0;
};
let off = align_up_u32(bss.virtual_size, COMMON_BLOCK_ALIGN);
bss.virtual_size = off.saturating_add(size);
off
}
fn synthetic(name: &[u8], size: u32, characteristics: u32) -> OutSection {
OutSection {
name: pad_name(name),
members: Vec::new(),
characteristics,
virtual_address: 0,
virtual_size: size,
pointer_to_raw_data: 0,
size_of_raw_data: 0,
zerofill: false,
}
}
#[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
enum Kind {
Code,
RData,
Data,
Bss,
Tls,
Rsrc,
}
fn classify(section: &CoffSection<'_>) -> Option<Kind> {
let ch = section.characteristics;
if ch & IMAGE_SCN_CNT_CODE != 0 && ch & IMAGE_SCN_MEM_EXECUTE != 0 {
return Some(Kind::Code);
}
if is_tls_section(section.name) {
return Some(Kind::Tls);
}
if is_rsrc_section(section.name) {
return Some(Kind::Rsrc);
}
if is_deferred(section.name) {
return None;
}
if ch & IMAGE_SCN_CNT_UNINITIALIZED_DATA != 0 {
return Some(Kind::Bss);
}
let writable = ch & IMAGE_SCN_MEM_WRITE != 0;
if ch & IMAGE_SCN_CNT_INITIALIZED_DATA != 0 {
return Some(if writable { Kind::Data } else { Kind::RData });
}
None
}
fn is_tls_section(name: &[u8]) -> bool {
trim_nul(name).starts_with(b".tls$")
}
fn is_rsrc_section(name: &[u8]) -> bool {
trim_nul(name).starts_with(b".rsrc")
}
fn is_deferred(name: &[u8]) -> bool {
let trim = trim_nul(name);
trim.starts_with(b".debug")
|| matches!(
trim,
b".pdata" | b".xdata" | b".llvm_addrsig" | b".drectve"
)
}
fn section_rank(s: &OutSection) -> u8 {
match &s.name {
b".text\0\0\0" => 0,
b".rdata\0\0" => 1,
b".data\0\0\0" => 2,
b".bss\0\0\0\0" => 3,
b".tls\0\0\0\0" => 4,
b".tlsdir\0" => 5,
b".edata\0\0" => 7,
b".rsrc\0\0\0" => 8,
b".reloc\0\0" => 9,
_ => 6,
}
}
fn member_size(kind: Kind, section: &CoffSection<'_>) -> u64 {
match kind {
Kind::Bss => u64::from(section.virtual_size),
_ => u64::from(section.size_of_raw_data).max(section.data.len() as u64),
}
}
fn member_align(section: &CoffSection<'_>) -> u64 {
const DEFAULT: u64 = 16;
let field = (section.characteristics & IMAGE_SCN_ALIGN_MASK) >> 20;
if field == 0 {
return DEFAULT;
}
1u64 << (field - 1).min(13)
}
fn sort_members_by_name(inputs: &[CoffFile<'_>], groups: &mut [OutSection]) {
for s in groups.iter_mut() {
s.members.sort_by_key(|m| member_name(inputs, m));
}
}
fn member_name<'a>(inputs: &[CoffFile<'a>], m: &Member) -> &'a [u8] {
inputs
.get(m.file)
.and_then(|f| f.section_at(m.section))
.map_or(&[][..], |s| trim_nul(s.name))
}
fn add_member(
groups: &mut Vec<OutSection>,
file: usize,
section: &CoffSection<'_>,
kind: Kind,
) {
let name: &[u8] = match kind {
Kind::Code => b".text",
Kind::RData => b".rdata",
Kind::Data => b".data",
Kind::Bss => b".bss",
Kind::Tls => b".tls",
Kind::Rsrc => b".rsrc",
};
let out_name: [u8; 8] = pad_name(name);
let member = Member {
file,
section: section.index,
size: member_size(kind, section),
offset: 0,
align: member_align(section),
};
if let Some(out) = groups.iter_mut().find(|s| s.name == out_name) {
out.members.push(member);
out.characteristics |= output_chars(kind);
return;
}
groups.push(OutSection {
name: out_name,
members: vec![member],
characteristics: output_chars(kind),
virtual_address: 0,
virtual_size: 0,
pointer_to_raw_data: 0,
size_of_raw_data: 0,
zerofill: matches!(kind, Kind::Bss),
});
}
const fn output_chars(kind: Kind) -> u32 {
match kind {
Kind::Code => {
IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ
}
Kind::RData | Kind::Rsrc => {
IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ
}
Kind::Data | Kind::Tls => {
IMAGE_SCN_CNT_INITIALIZED_DATA
| IMAGE_SCN_MEM_READ
| IMAGE_SCN_MEM_WRITE
}
Kind::Bss => {
IMAGE_SCN_CNT_UNINITIALIZED_DATA
| IMAGE_SCN_MEM_READ
| IMAGE_SCN_MEM_WRITE
}
}
}
fn layout_members(groups: &mut [OutSection], entry_stub_size: u32) {
for s in groups.iter_mut() {
let base = u64::from(s.virtual_size);
let mut cursor = if s.name == *b".text\0\0\0" {
base.max(u64::from(entry_stub_size))
.next_multiple_of(STUB_ALIGN)
} else {
base
};
for m in &mut s.members {
cursor = cursor.next_multiple_of(m.align.max(1));
m.offset = cursor;
cursor = cursor.wrapping_add(m.size);
}
s.virtual_size = u32::try_from(cursor).unwrap_or(u32::MAX);
}
}
fn place(groups: &mut [OutSection]) -> Result<()> {
let mut rva = SECTION_ALIGNMENT;
let mut file_off = align_up_u32(
headers_extent(u32::try_from(groups.len()).unwrap_or(0)),
FILE_ALIGNMENT,
);
for s in groups.iter_mut() {
rva = align_up_u32(rva, SECTION_ALIGNMENT);
s.virtual_address = rva;
if s.zerofill {
s.pointer_to_raw_data = 0;
s.size_of_raw_data = 0;
} else {
s.pointer_to_raw_data = file_off;
let raw = align_up_u32(s.virtual_size, FILE_ALIGNMENT);
s.size_of_raw_data = raw;
file_off = file_off
.checked_add(raw)
.ok_or(Error::OutOfRange("section file offset"))?;
}
rva = rva
.checked_add(align_up_u32(s.virtual_size, SECTION_ALIGNMENT))
.ok_or(Error::OutOfRange("section virtual address"))?;
}
Ok(())
}
fn headers_extent(num_sections: u32) -> u32 {
use crate::coff::constants::{
IMAGE_NUMBEROF_DIRECTORY_ENTRIES, IMAGE_SIZEOF_DOS_HEADER,
IMAGE_SIZEOF_FILE_HEADER_PE, IMAGE_SIZEOF_OPTIONAL_HEADER64,
IMAGE_SIZEOF_SECTION_HEADER,
};
let data_dirs =
u32::try_from(IMAGE_NUMBEROF_DIRECTORY_ENTRIES).unwrap_or(0) * 8;
let nt = 4
+ u32::try_from(IMAGE_SIZEOF_FILE_HEADER_PE).unwrap_or(0)
+ u32::try_from(IMAGE_SIZEOF_OPTIONAL_HEADER64).unwrap_or(0)
+ data_dirs;
u32::try_from(IMAGE_SIZEOF_DOS_HEADER).unwrap_or(0)
+ nt
+ num_sections * u32::try_from(IMAGE_SIZEOF_SECTION_HEADER).unwrap_or(0)
}
pub fn section_rva(layout: &PeLayout, name: &[u8]) -> Option<(u32, u32)> {
layout
.sections
.iter()
.find(|s| trim_nul(&s.name) == name)
.map(|s| (s.virtual_address, s.virtual_size))
}