use super::{branch26, insn_cell, of, page};
use crate::{
error::{Error, Result},
reloc::{Arch, Needs, RelExpr, Resolver, Spec, Write, WriteKind},
symbol::SymbolId,
};
pub const ARM64_RELOC_UNSIGNED: u32 = 0;
pub const ARM64_RELOC_UNSIGNED_4: u32 = 0x100;
pub const ARM64_RELOC_SUBTRACTOR: u32 = 1;
pub const ARM64_RELOC_BRANCH26: u32 = 2;
pub const ARM64_RELOC_PAGE21: u32 = 3;
pub const ARM64_RELOC_PAGEOFF12: u32 = 4;
pub const ARM64_RELOC_GOT_LOAD_PAGE21: u32 = 5;
pub const ARM64_RELOC_GOT_LOAD_PAGEOFF12: u32 = 6;
pub const ARM64_RELOC_POINTER_TO_GOT: u32 = 7;
pub const ARM64_RELOC_TLVP_LOAD_PAGE21: u32 = 8;
pub const ARM64_RELOC_TLVP_LOAD_PAGEOFF12: u32 = 9;
pub const ARM64_RELOC_ADDEND: u32 = 10;
pub struct MachoArm64;
impl Arch for MachoArm64 {
fn spec(r_type: u32) -> Result<Spec> {
Ok(match r_type {
ARM64_RELOC_UNSIGNED => {
of(RelExpr::Abs, Write::Bytes(WriteKind::W64))
}
ARM64_RELOC_UNSIGNED_4 => {
of(RelExpr::Abs, Write::Bytes(WriteKind::W32SU))
}
ARM64_RELOC_BRANCH26 => {
of(RelExpr::PltPc, Write::Field(branch26()))
}
ARM64_RELOC_POINTER_TO_GOT => {
of(RelExpr::GotPc, Write::Bytes(WriteKind::W32S))
}
ARM64_RELOC_PAGE21
| ARM64_RELOC_PAGEOFF12
| ARM64_RELOC_GOT_LOAD_PAGE21
| ARM64_RELOC_GOT_LOAD_PAGEOFF12
| ARM64_RELOC_TLVP_LOAD_PAGE21
| ARM64_RELOC_TLVP_LOAD_PAGEOFF12
| ARM64_RELOC_SUBTRACTOR => {
of(RelExpr::Escape, Write::Field(insn_cell(4)))
}
ARM64_RELOC_ADDEND => {
of(RelExpr::None, Write::Bytes(WriteKind::W64))
}
other => return Err(Error::UnsupportedReloc(other)),
})
}
fn scan_needs(r_type: u32) -> Result<Needs> {
let base = Self::spec(r_type)?.expr.needs();
Ok(
if matches!(
r_type,
ARM64_RELOC_GOT_LOAD_PAGE21 | ARM64_RELOC_GOT_LOAD_PAGEOFF12
) {
Needs { got: true, ..base }
} else {
base
},
)
}
fn escape<R: Resolver>(
r_type: u32,
sym: Option<SymbolId>,
addend: i64,
place: u64,
resolver: &R,
out: &mut [u8],
) -> Result<()> {
match r_type {
ARM64_RELOC_PAGE21 => {
let s_a = RelExpr::Abs.compute(sym, addend, 0, resolver)?;
write_adr(out, page_delta(s_a, place))
}
ARM64_RELOC_GOT_LOAD_PAGE21 => {
let got = RelExpr::Got.compute(sym, addend, 0, resolver)?;
write_adr(out, page_delta(got, place))
}
ARM64_RELOC_PAGEOFF12 => {
let s_a = RelExpr::Abs.compute(sym, addend, 0, resolver)?;
write_pageoff12(out, s_a)
}
ARM64_RELOC_GOT_LOAD_PAGEOFF12 => {
let got = RelExpr::Got.compute(sym, addend, 0, resolver)?;
write_pageoff12(out, got)
}
ARM64_RELOC_TLVP_LOAD_PAGE21 => {
let descriptor =
RelExpr::Abs.compute(sym, addend, 0, resolver)?;
write_adr(out, page_delta(descriptor, place))
}
ARM64_RELOC_TLVP_LOAD_PAGEOFF12 => {
let descriptor =
RelExpr::Abs.compute(sym, addend, 0, resolver)?;
write_tlvp_pageoff12(out, descriptor)
}
_ => Err(Error::UnsupportedReloc(r_type)),
}
}
}
fn write_tlvp_pageoff12(out: &mut [u8], va: u64) -> Result<()> {
if out.len() != 4 {
return Err(Error::OutOfRange("TLVP PAGEOFF12 relocation slot"));
}
let cell = u32::from_le_bytes([out[0], out[1], out[2], out[3]]);
let registers = cell & 0x3ff;
let imm = u32::try_from(va & 0xfff).unwrap_or(0);
let patched = 0x9100_0000 | registers | (imm << 10);
out.copy_from_slice(&patched.to_le_bytes());
Ok(())
}
fn page_delta(target: u64, place: u64) -> i64 {
page(target)
.cast_signed()
.wrapping_sub(page(place).cast_signed())
}
fn write_pageoff12(out: &mut [u8], va: u64) -> Result<()> {
if out.len() != 4 {
return Err(Error::OutOfRange("PAGEOFF12 relocation slot"));
}
let base = u32::from_le_bytes([out[0], out[1], out[2], out[3]]);
let scale = ldst_scale(base);
let size = 1u64 << scale;
if va & (size - 1) != 0 {
return Err(Error::OutOfRange("unaligned PAGEOFF12 access"));
}
#[allow(clippy::cast_possible_truncation)]
let imm = ((va & 0xfff) >> scale) as u32;
let patched = (base & !(0xfff << 10)) | ((imm & 0xfff) << 10);
out.copy_from_slice(&patched.to_le_bytes());
Ok(())
}
fn ldst_scale(base: u32) -> u32 {
if base & 0x3b00_0000 != 0x3900_0000 {
return 0;
}
let scale = base >> 30;
if scale == 0 && base & 0x0480_0000 == 0x0480_0000 {
return 4;
}
scale
}
fn write_adr(out: &mut [u8], delta: i64) -> Result<()> {
if out.len() != 4 {
return Err(Error::OutOfRange("ADR relocation slot"));
}
if !(-(1i64 << 32)..(1i64 << 32)).contains(&delta) {
return Err(Error::OutOfRange("ADRP page distance"));
}
let cell = u32::from_le_bytes([out[0], out[1], out[2], out[3]]);
#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
let imm = (delta >> 12) as u32;
let imm_lo = (imm & 0x3) << 29;
let imm_hi = (imm & 0x001F_FFFC) << 3;
let mask: u32 = (0x3 << 29) | (0x001F_FFFC << 3);
let patched = (cell & !mask) | imm_lo | imm_hi;
out.copy_from_slice(&patched.to_le_bytes());
Ok(())
}