use rayon::slice::ParallelSliceMut;
use rustc_hash::FxHashMap;
use crate::{
elf::Rela64,
error::{Error, Result},
layout::{Layout, Region, Sect, sect},
util::{push_rel32, push_u32},
};
const DW_EH_PE_ABSPTR: u8 = 0x00;
const DW_EH_PE_UDATA2: u8 = 0x02;
const DW_EH_PE_UDATA4: u8 = 0x03;
const DW_EH_PE_UDATA8: u8 = 0x04;
const DW_EH_PE_SDATA2: u8 = 0x0a;
const DW_EH_PE_SDATA4: u8 = 0x0b;
const DW_EH_PE_SDATA8: u8 = 0x0c;
const DW_EH_PE_PCREL: u8 = 0x10;
const DW_EH_PE_BASE_MASK: u8 = 0x70;
const DW_EH_PE_DATAREL: u8 = 0x30;
const DW_EH_PE_ALIGNED: u8 = 0x50;
const HDR_FIXED: u64 = 12;
const ENTRY_SIZE: u64 = 8;
mod cie;
mod lsda;
mod split;
pub use lsda::sections_with_lsda;
pub use split::{EhFramePlan, EhMember, Piece, build as build_plan};
pub fn is_eh_frame_name(name: &[u8]) -> bool {
name == b".eh_frame"
}
fn cie_offset_of(data: &[u8], piece: Piece) -> Option<u64> {
if !piece.fde {
return None;
}
let field = usize::try_from(piece.in_off).ok()?.checked_add(4)?;
let cie_ptr = u64::from(read_u32(data, field).ok()?);
u64::try_from(field).ok()?.checked_sub(cie_ptr)
}
fn record_at(pieces: &[Piece], offset: u64) -> Option<usize> {
let idx = pieces.partition_point(|p| p.in_off <= offset);
let i = idx.checked_sub(1)?;
pieces.get(i).filter(|p| p.covers(offset)).map(|_| i)
}
fn first_reloc_syms(pieces: &[Piece], entries: &[Rela64]) -> Vec<Option<u32>> {
let mut first: Vec<Option<(u64, u32)>> = vec![None; pieces.len()];
for r in entries {
let at = r.r_offset.get();
let Some(i) = record_at(pieces, at) else {
continue;
};
if let Some(slot) = first.get_mut(i)
&& slot.is_none_or(|(prev, _)| at < prev)
{
*slot = Some((at, r.sym()));
}
}
first.into_iter().map(|s| s.map(|(_, sym)| sym)).collect()
}
pub fn records(
data: &[u8],
pieces: &mut Vec<Piece>,
fde: &mut Vec<bool>,
) -> usize {
pieces.clear();
fde.clear();
let mut cursor = 0usize;
while cursor + 4 <= data.len() {
let Ok(len) = read_u32(data, cursor) else {
break;
};
if len == 0 || len == 0xffff_ffff {
break;
}
let Ok(len_usize) = usize::try_from(len) else {
break;
};
let Some(next) =
cursor.checked_add(4).and_then(|x| x.checked_add(len_usize))
else {
break;
};
if next > data.len() {
break;
}
let Ok(cie_ptr) = read_u32(data, cursor + 4) else {
break;
};
pieces.push(Piece {
in_off: u64::try_from(cursor).unwrap_or(u64::MAX),
len: u64::try_from(next.saturating_sub(cursor)).unwrap_or(0),
out_off: None,
fde: cie_ptr != 0,
});
fde.push(cie_ptr != 0);
cursor = next;
}
cursor
}
pub fn hdr_size(fde_count: u64) -> u64 {
HDR_FIXED.saturating_add(fde_count.saturating_mul(ENTRY_SIZE))
}
pub fn is_fde_offset(pieces: &[Piece], fde: &[bool], offset: u64) -> bool {
record_at(pieces, offset)
.and_then(|i| fde.get(i).copied())
.unwrap_or(false)
}
pub fn build_hdr(image: &[u8], layout: &Layout) -> Result<Vec<u8>> {
let eh = layout.region(Sect::EhFrame);
let hdr = layout.region(Sect::EhFrameHdr);
let start = usize::try_from(eh.offset)
.map_err(|_| Error::OutOfRange("eh_frame off"))?;
let size = usize::try_from(eh.size)
.map_err(|_| Error::OutOfRange("eh_frame size"))?;
let bytes = image
.get(start..start.saturating_add(size))
.ok_or(Error::OutOfRange("eh_frame slice"))?;
let mut entries = collect_entries(bytes, eh.vaddr)?;
let mut code = [Region::default(); sect::CONTENT.len()];
let n = collect_code(layout, &mut code);
let placed = &code[..n];
entries.retain(|e| {
placed
.iter()
.any(|r| e.pc >= r.vaddr && e.pc < r.vaddr.wrapping_add(r.size))
});
entries.par_sort_by_key(|e| e.pc);
entries.dedup_by_key(|e| e.pc);
Ok(serialize_hdr(&entries, eh.vaddr, hdr.vaddr))
}
fn collect_code(layout: &Layout, out: &mut [Region]) -> usize {
let mut n = 0usize;
for sect in sect::code() {
let region = layout.region(sect);
if region.size == 0 {
continue;
}
let Some(slot) = out.get_mut(n) else {
break;
};
*slot = region;
n += 1;
}
n
}
#[derive(Clone, Copy)]
struct Entry {
pc: u64,
fde_addr: u64,
}
fn collect_entries(bytes: &[u8], eh_vaddr: u64) -> Result<Vec<Entry>> {
let mut cies: FxHashMap<usize, u8> = FxHashMap::default();
let mut out = Vec::new();
let mut cursor = 0usize;
while cursor + 4 <= bytes.len() {
let len = read_u32(bytes, cursor)?;
if len == 0 {
break;
}
if len == 0xffff_ffff {
return Err(Error::Format("64-bit .eh_frame length"));
}
let len_usize =
usize::try_from(len).map_err(|_| Error::Format("eh_frame len"))?;
let next = cursor
.checked_add(4)
.and_then(|x| x.checked_add(len_usize))
.ok_or(Error::Format("eh_frame length overflow"))?;
if next > bytes.len() {
return Err(Error::Format("truncated .eh_frame"));
}
let cie_ptr = read_u32(bytes, cursor + 4)?;
if cie_ptr == 0 {
let enc = cie_augmentation(bytes, cursor, next)?.fde_encoding;
cies.insert(cursor, enc);
} else {
let field_at = cursor.saturating_add(4);
let cie_off = field_at
.checked_sub(
usize::try_from(cie_ptr)
.map_err(|_| Error::Format("cie ptr"))?,
)
.ok_or(Error::Format("FDE CIE pointer"))?;
let enc = cies.get(&cie_off).copied().ok_or(Error::Format(
"FDE points at a CIE this section does not contain",
))?;
let pc = fde_pc(bytes, cursor, enc, eh_vaddr)?;
out.push(Entry {
pc,
fde_addr: eh_vaddr
.wrapping_add(u64::try_from(cursor).unwrap_or(0)),
});
}
cursor = next;
}
Ok(out)
}
fn fde_pc(bytes: &[u8], fde_off: usize, enc: u8, eh_vaddr: u64) -> Result<u64> {
let field_at = fde_off.saturating_add(8);
let raw = read_encoded(bytes, field_at, enc & 0x0f)?;
let field_va = eh_vaddr.wrapping_add(u64::try_from(field_at).unwrap_or(0));
match enc & DW_EH_PE_BASE_MASK {
DW_EH_PE_ABSPTR => Ok(raw),
DW_EH_PE_PCREL => Ok(raw.wrapping_add(field_va)),
_ => Err(Error::Format("unknown FDE initial_location base encoding")),
}
}
#[derive(Copy, Clone, Debug, Default)]
struct Augmentation {
fde_encoding: u8,
has_lsda: bool,
}
fn cie_augmentation(
bytes: &[u8],
cie_off: usize,
end: usize,
) -> Result<Augmentation> {
let mut cur = Cursor::new(bytes, cie_off, end);
cur.skip(8)?; let version = cur.read_byte()?;
let aug = cur.read_cstr()?;
cur.skip_leb128()?; cur.skip_leb128()?; if version >= 3 {
cur.skip_leb128()?;
} else {
cur.skip(1)?;
}
let mut out = Augmentation::default();
for ch in aug {
match ch {
b'z' => cur.skip_leb128()?,
b'L' => {
out.has_lsda = true;
cur.skip(1)?;
}
b'P' => cur.skip_aug_p()?,
b'R' => out.fde_encoding = cur.read_byte()?,
b'B' | b'S' | b'G' => {}
_ => {
out.has_lsda = true;
break;
}
}
}
Ok(out)
}
struct Cursor<'a> {
bytes: &'a [u8],
pos: usize,
end: usize,
}
impl<'a> Cursor<'a> {
fn new(bytes: &'a [u8], pos: usize, end: usize) -> Self {
Self { bytes, pos, end }
}
fn read_byte(&mut self) -> Result<u8> {
if self.pos >= self.end {
return Err(Error::Format("CIE truncated"));
}
let b = self.bytes[self.pos];
self.pos += 1;
Ok(b)
}
fn skip(&mut self, n: usize) -> Result<()> {
let new = self
.pos
.checked_add(n)
.filter(|&x| x <= self.end)
.ok_or(Error::Format("CIE truncated"))?;
self.pos = new;
Ok(())
}
fn read_cstr(&mut self) -> Result<&'a [u8]> {
let end = self.bytes[self.pos..self.end]
.iter()
.position(|&b| b == 0)
.ok_or(Error::Format("CIE augmentation not terminated"))?;
let s = &self.bytes[self.pos..self.pos + end];
self.pos += end + 1;
Ok(s)
}
fn skip_leb128(&mut self) -> Result<()> {
while self.pos < self.end {
let b = self.bytes[self.pos];
self.pos += 1;
if b & 0x80 == 0 {
return Ok(());
}
}
Err(Error::Format("CIE truncated LEB128"))
}
fn skip_aug_p(&mut self) -> Result<()> {
let enc = self.read_byte()?;
if enc & DW_EH_PE_BASE_MASK == DW_EH_PE_ALIGNED {
return Err(Error::Format(
"DW_EH_PE_aligned personality encoding is not supported",
));
}
let n = aug_value_size(enc)?;
self.skip(n)
}
}
fn aug_value_size(enc: u8) -> Result<usize> {
Ok(match enc & 0x0f {
DW_EH_PE_ABSPTR | DW_EH_PE_UDATA8 | DW_EH_PE_SDATA8 => 8,
DW_EH_PE_UDATA2 | DW_EH_PE_SDATA2 => 2,
DW_EH_PE_UDATA4 | DW_EH_PE_SDATA4 => 4,
_ => return Err(Error::Format("unknown DW_EH_PE format")),
})
}
fn read_encoded(bytes: &[u8], offset: usize, format: u8) -> Result<u64> {
match format {
DW_EH_PE_UDATA2 => Ok(u64::from(read_u16(bytes, offset)?)),
DW_EH_PE_SDATA2 => {
Ok(sign_extend(u64::from(read_u16(bytes, offset)?), 16))
}
DW_EH_PE_UDATA4 => Ok(u64::from(read_u32(bytes, offset)?)),
DW_EH_PE_SDATA4 => {
Ok(sign_extend(u64::from(read_u32(bytes, offset)?), 32))
}
DW_EH_PE_UDATA8 | DW_EH_PE_SDATA8 | DW_EH_PE_ABSPTR => {
read_u64(bytes, offset)
}
_ => Err(Error::Format("unknown FDE value format")),
}
}
fn sign_extend(v: u64, bits: u32) -> u64 {
if bits >= 64 || v & (1u64 << (bits - 1)) == 0 {
v
} else {
v | (!0u64 << bits)
}
}
fn serialize_hdr(entries: &[Entry], eh_vaddr: u64, hdr_vaddr: u64) -> Vec<u8> {
let mut out = Vec::with_capacity(
usize::try_from(HDR_FIXED).unwrap_or(0) + entries.len() * 8,
);
out.push(1); out.push(DW_EH_PE_PCREL | DW_EH_PE_SDATA4); out.push(DW_EH_PE_UDATA4); out.push(DW_EH_PE_DATAREL | DW_EH_PE_SDATA4); push_rel32(&mut out, eh_vaddr.wrapping_sub(hdr_vaddr + 4));
push_u32(&mut out, u32::try_from(entries.len()).unwrap_or(0));
for e in entries {
push_rel32(&mut out, e.pc.wrapping_sub(hdr_vaddr));
push_rel32(&mut out, e.fde_addr.wrapping_sub(hdr_vaddr));
}
out
}
fn read_u32(bytes: &[u8], offset: usize) -> Result<u32> {
let slot = bytes
.get(offset..offset + 4)
.ok_or(Error::Format("u32 bounds"))?;
Ok(u32::from_le_bytes(
slot.try_into().map_err(|_| Error::Format("u32 slice"))?,
))
}
fn read_u16(bytes: &[u8], offset: usize) -> Result<u16> {
let slot = bytes
.get(offset..offset + 2)
.ok_or(Error::Format("u16 bounds"))?;
Ok(u16::from_le_bytes(
slot.try_into().map_err(|_| Error::Format("u16 slice"))?,
))
}
fn read_u64(bytes: &[u8], offset: usize) -> Result<u64> {
let slot = bytes
.get(offset..offset + 8)
.ok_or(Error::Format("u64 bounds"))?;
Ok(u64::from_le_bytes(
slot.try_into().map_err(|_| Error::Format("u64 slice"))?,
))
}