use crate::{
error::{Error, Result},
macho::MachReloc,
reloc::{
Needs, Resolver, apply,
macho_arm64::{
ARM64_RELOC_ADDEND, ARM64_RELOC_UNSIGNED, ARM64_RELOC_UNSIGNED_4,
MachoArm64,
},
macho_x86_64::{
MachoX86_64, X86_64_RELOC_UNSIGNED, X86_64_RELOC_UNSIGNED_4,
},
scan,
},
symbol::SymbolId,
};
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum MachoTarget {
X86_64,
Arm64,
}
impl MachoTarget {
pub fn from_cpu(cpu: u32) -> Result<Self> {
match cpu {
crate::macho::constants::CPU_TYPE_X86_64 => Ok(Self::X86_64),
crate::macho::constants::CPU_TYPE_ARM64 => Ok(Self::Arm64),
_ => Err(Error::Format("unsupported Mach-O cputype")),
}
}
}
pub fn apply_reloc<R: Resolver>(
target: MachoTarget,
r_type: u32,
sym: Option<SymbolId>,
addend: i64,
place: u64,
resolver: &R,
out: &mut [u8],
) -> Result<()> {
match target {
MachoTarget::X86_64 => {
apply::<MachoX86_64, R>(r_type, sym, addend, place, resolver, out)
}
MachoTarget::Arm64 => {
apply::<MachoArm64, R>(r_type, sym, addend, place, resolver, out)
}
}
}
pub fn scan_needs(target: MachoTarget, r_type: u32) -> Result<Needs> {
match target {
MachoTarget::X86_64 => scan::<MachoX86_64>(r_type),
MachoTarget::Arm64 => scan::<MachoArm64>(r_type),
}
}
pub fn table_type(target: MachoTarget, reloc: &MachReloc) -> u32 {
let r_type = u32::from(reloc.r_type);
let unsigned = match target {
MachoTarget::X86_64 => X86_64_RELOC_UNSIGNED,
MachoTarget::Arm64 => ARM64_RELOC_UNSIGNED,
};
if r_type != unsigned || reloc.r_length == 3 {
return r_type;
}
match target {
MachoTarget::X86_64 => X86_64_RELOC_UNSIGNED_4,
MachoTarget::Arm64 => ARM64_RELOC_UNSIGNED_4,
}
}
pub fn addend_for(
target: MachoTarget,
reloc: &MachReloc,
slot: &[u8],
pending: i64,
) -> i64 {
match target {
MachoTarget::X86_64 => x86_addend(reloc, slot),
MachoTarget::Arm64 => arm64_addend(reloc, slot, pending),
}
}
pub fn arm64_embedded(reloc: &MachReloc, slot: &[u8]) -> i64 {
if u32::from(reloc.r_type) != ARM64_RELOC_UNSIGNED {
return 0;
}
read_signed_le(slot, reloc.width())
}
fn arm64_addend(reloc: &MachReloc, slot: &[u8], pending: i64) -> i64 {
arm64_embedded(reloc, slot) + pending
}
fn x86_addend(reloc: &MachReloc, slot: &[u8]) -> i64 {
let raw = read_signed_le(slot, reloc.width());
if reloc.r_pcrel {
return raw - (1i64 << reloc.r_length);
}
raw
}
fn read_signed_le(slot: &[u8], len: usize) -> i64 {
let n = len.min(slot.len()).min(8);
let buf = slot.get(..n).unwrap_or_default();
match n {
1 => <&[u8; 1]>::try_from(buf)
.map_or(0, |a| i64::from(i8::from_le_bytes(*a))),
2 => <&[u8; 2]>::try_from(buf)
.map_or(0, |a| i64::from(i16::from_le_bytes(*a))),
4 => <&[u8; 4]>::try_from(buf)
.map_or(0, |a| i64::from(i32::from_le_bytes(*a))),
_ => {
let mut wide = [0u8; 8];
if let Some(take) = buf.get(..n.min(8)) {
wide[..n.min(8)].copy_from_slice(take);
}
i64::from_le_bytes(wide)
}
}
}
pub fn is_arm64_addend(reloc: &MachReloc) -> bool {
u32::from(reloc.r_type) == ARM64_RELOC_ADDEND
}
pub fn arm64_pending_addend(reloc: &MachReloc) -> i64 {
let raw = i64::from(reloc.r_symbolnum & 0x00ff_ffff);
(raw << 40) >> 40
}
pub struct MachResolver<'a> {
addr: &'a [u64],
got: &'a [u64],
}
impl<'a> MachResolver<'a> {
pub fn new(addr: &'a [u64], got: &'a [u64]) -> Self {
Self { addr, got }
}
}
impl Resolver for MachResolver<'_> {
fn symbol_addr(&self, sym: SymbolId) -> u64 {
self.addr.get(sym.0).copied().unwrap_or_default()
}
fn got_addr(&self, sym: SymbolId) -> u64 {
self.got.get(sym.0).copied().unwrap_or_default()
}
fn got_base(&self) -> u64 {
0
}
fn plt_addr(&self, sym: SymbolId) -> u64 {
self.symbol_addr(sym)
}
}
pub struct SectionResolver {
pub vaddr: u64,
}
impl Resolver for SectionResolver {
fn symbol_addr(&self, _sym: SymbolId) -> u64 {
self.vaddr
}
fn got_addr(&self, _sym: SymbolId) -> u64 {
self.vaddr
}
fn got_base(&self) -> u64 {
0
}
fn plt_addr(&self, _sym: SymbolId) -> u64 {
self.vaddr
}
}