use crate::{
error::{Error, Result},
macho::{
MachOFile, MachReloc, MachSection,
layout::{MachLayout, Member, OutSection, OutSegment},
reloc::{
MachResolver, MachoTarget, SectionResolver, addend_for,
apply_reloc, arm64_embedded, arm64_pending_addend, is_arm64_addend,
table_type,
},
},
reloc::{
Resolver,
macho_arm64::{ARM64_RELOC_SUBTRACTOR, ARM64_RELOC_UNSIGNED},
macho_x86_64::{X86_64_RELOC_SUBTRACTOR, X86_64_RELOC_UNSIGNED},
},
symbol::SymbolId,
};
pub struct AddrTables<'a> {
pub sym_addr: &'a [Vec<u64>],
pub got_addr: &'a [Vec<u64>],
pub sec_vaddr: &'a [Vec<u64>],
pub in_addr: &'a [Vec<u64>],
}
pub fn write(
image: &mut [u8],
inputs: &[MachOFile<'_>],
target: MachoTarget,
layout: &MachLayout,
tables: &AddrTables<'_>,
) -> Result<()> {
for segment in [Some(&layout.text), layout.data.as_ref()]
.into_iter()
.flatten()
{
write_segment(image, inputs, target, segment, tables)?;
}
Ok(())
}
fn write_segment(
image: &mut [u8],
inputs: &[MachOFile<'_>],
target: MachoTarget,
segment: &OutSegment,
tables: &AddrTables<'_>,
) -> Result<()> {
for section in &segment.sections {
if section.zerofill {
continue;
}
for member in §ion.members {
copy_member(image, inputs, target, section, member, tables)?;
}
}
Ok(())
}
fn copy_member(
image: &mut [u8],
inputs: &[MachOFile<'_>],
target: MachoTarget,
section: &OutSection,
member: &Member,
tables: &AddrTables<'_>,
) -> Result<()> {
let input = inputs
.get(member.file)
.ok_or(Error::OutOfRange("member file index"))?;
let sections = input.sections();
let zero_based = usize::try_from(member.section)
.unwrap_or(0)
.saturating_sub(1);
let src = sections
.get(zero_based)
.ok_or(Error::OutOfRange("member section ordinal"))?;
let data = src.data;
let dst_off =
usize::try_from(section.offset + member.offset).unwrap_or(usize::MAX);
let end = dst_off
.checked_add(data.len())
.ok_or(Error::OutOfRange("section copy"))?;
let slot = image
.get_mut(dst_off..end)
.ok_or(Error::OutOfRange("section image slot"))?;
slot.copy_from_slice(data);
let member_vaddr = section.addr.wrapping_add(member.offset);
let resolver = MachResolver::new(
file_table(tables.sym_addr, member.file),
file_table(tables.got_addr, member.file),
);
let ctx = RelocCtx {
target,
file: member.file,
sec_vaddr: tables.sec_vaddr,
in_addr: file_table(tables.in_addr, member.file),
site_in_addr: src.addr,
};
apply_relocations(image, dst_off, member_vaddr, src, &ctx, &resolver)
}
fn file_table(tables: &[Vec<u64>], file: usize) -> &[u64] {
tables.get(file).map(Vec::as_slice).unwrap_or_default()
}
struct RelocCtx<'a> {
target: MachoTarget,
file: usize,
sec_vaddr: &'a [Vec<u64>],
in_addr: &'a [u64],
site_in_addr: u64,
}
fn apply_relocations<R: Resolver>(
image: &mut [u8],
image_off: usize,
place_base: u64,
section: &MachSection<'_>,
ctx: &RelocCtx<'_>,
resolver: &R,
) -> Result<()> {
let relocs = §ion.relocations;
let mut i = 0;
while i < relocs.len() {
let reloc = &relocs[i];
if is_subtractor(ctx.target, reloc) {
let Some(next) = relocs.get(i.saturating_add(1)) else {
return Err(Error::Format(
"Mach-O SUBTRACTOR has no paired UNSIGNED relocation",
));
};
apply_subtractor_pair(
image, image_off, reloc, next, ctx, resolver,
)?;
i = i.saturating_add(2);
continue;
}
if ctx.target == MachoTarget::Arm64 && is_arm64_addend(reloc) {
let pending = arm64_pending_addend(reloc);
i = i.saturating_add(1);
if i >= relocs.len() {
break;
}
let next = &relocs[i];
let slot_off = slot_offset(image_off, next.r_address);
apply_one(
image, slot_off, place_base, next, pending, ctx, resolver,
)?;
} else {
let slot_off = slot_offset(image_off, reloc.r_address);
apply_one(image, slot_off, place_base, reloc, 0, ctx, resolver)?;
}
i = i.saturating_add(1);
}
Ok(())
}
fn apply_subtractor_pair<R: Resolver>(
image: &mut [u8],
image_off: usize,
subtractor: &MachReloc,
unsigned: &MachReloc,
ctx: &RelocCtx<'_>,
resolver: &R,
) -> Result<()> {
if !is_unsigned(ctx.target, unsigned)
|| subtractor.r_address != unsigned.r_address
|| subtractor.r_length != unsigned.r_length
|| !subtractor.r_extern
|| !unsigned.r_extern
{
return Err(Error::Format(
"malformed Mach-O SUBTRACTOR/UNSIGNED relocation pair",
));
}
let width = unsigned.width();
if width > 8 {
return Err(Error::OutOfRange("Mach-O SUBTRACTOR width"));
}
let slot_off = slot_offset(image_off, unsigned.r_address);
let end = slot_off
.checked_add(width)
.ok_or(Error::OutOfRange("Mach-O SUBTRACTOR slot"))?;
let slot = image
.get_mut(slot_off..end)
.ok_or(Error::OutOfRange("Mach-O SUBTRACTOR slot"))?;
let minuend = resolver.symbol_addr(SymbolId(
usize::try_from(unsigned.r_symbolnum).unwrap_or(0),
));
let subtrahend = resolver.symbol_addr(SymbolId(
usize::try_from(subtractor.r_symbolnum).unwrap_or(0),
));
let value = minuend
.wrapping_add_signed(raw_addend(unsigned, slot))
.wrapping_sub(subtrahend)
.to_le_bytes();
slot.copy_from_slice(&value[..width]);
Ok(())
}
fn is_subtractor(target: MachoTarget, reloc: &MachReloc) -> bool {
u32::from(reloc.r_type)
== match target {
MachoTarget::X86_64 => X86_64_RELOC_SUBTRACTOR,
MachoTarget::Arm64 => ARM64_RELOC_SUBTRACTOR,
}
}
fn is_unsigned(target: MachoTarget, reloc: &MachReloc) -> bool {
u32::from(reloc.r_type)
== match target {
MachoTarget::X86_64 => X86_64_RELOC_UNSIGNED,
MachoTarget::Arm64 => ARM64_RELOC_UNSIGNED,
}
}
fn slot_offset(image_off: usize, r_address: u32) -> usize {
image_off.wrapping_add(usize::try_from(r_address).unwrap_or(usize::MAX))
}
fn apply_one<R: Resolver>(
image: &mut [u8],
slot_off: usize,
place_base: u64,
reloc: &MachReloc,
pending: i64,
ctx: &RelocCtx<'_>,
resolver: &R,
) -> Result<()> {
let width = reloc.width();
let end = slot_off
.checked_add(width)
.ok_or(Error::OutOfRange("reloc slot"))?;
let slot = image
.get_mut(slot_off..end)
.ok_or(Error::OutOfRange("reloc image slot"))?;
let place = place_base.wrapping_add(u64::from(reloc.r_address));
let addend = if reloc.r_extern {
addend_for(ctx.target, reloc, slot, pending)
} else {
section_addend(ctx, reloc, slot, pending)
};
let r_type = table_type(ctx.target, reloc);
if reloc.r_extern {
let sym = SymbolId(usize::try_from(reloc.r_symbolnum).unwrap_or(0));
apply_reloc(
ctx.target,
r_type,
Some(sym),
addend,
place,
resolver,
slot,
)
} else {
let vaddr = section_vaddr(ctx.sec_vaddr, ctx.file, reloc.r_symbolnum);
let sec_resolver = SectionResolver { vaddr };
apply_reloc(
ctx.target,
r_type,
Some(SymbolId(0)),
addend,
place,
&sec_resolver,
slot,
)
}
}
fn raw_addend(reloc: &MachReloc, slot: &[u8]) -> i64 {
let n = reloc.width().min(slot.len()).min(8);
let mut wide = [0u8; 8];
let Some(take) = slot.get(..n) else {
return 0;
};
wide[..n].copy_from_slice(take);
let value = i64::from_le_bytes(wide);
let bits = 64 - 8 * u32::try_from(n).unwrap_or(8);
if bits == 0 || bits >= 64 {
return value;
}
(value << bits) >> bits
}
fn section_addend(
ctx: &RelocCtx<'_>,
reloc: &MachReloc,
slot: &[u8],
pending: i64,
) -> i64 {
let referent = section_in_addr(ctx.in_addr, reloc.r_symbolnum);
let raw = match ctx.target {
MachoTarget::X86_64 => raw_addend(reloc, slot),
MachoTarget::Arm64 => arm64_embedded(reloc, slot) + pending,
};
let site = if reloc.r_pcrel {
ctx.site_in_addr
.wrapping_add(u64::from(reloc.r_address))
.cast_signed()
} else {
0
};
site.wrapping_add(raw).wrapping_sub(referent.cast_signed())
}
fn section_in_addr(in_addr: &[u64], ordinal: u32) -> u64 {
let zero_based = usize::try_from(ordinal).unwrap_or(0).saturating_sub(1);
in_addr.get(zero_based).copied().unwrap_or(0)
}
fn section_vaddr(sec_vaddr: &[Vec<u64>], file: usize, ordinal: u32) -> u64 {
let zero_based = usize::try_from(ordinal).unwrap_or(0).saturating_sub(1);
sec_vaddr
.get(file)
.and_then(|f| f.get(zero_based))
.copied()
.unwrap_or(0)
}