use std::ops::Range;
use super::bytes_of as of;
use crate::{
error::Result,
reloc::{Arch, Needs, RelExpr, RelaxSite, Resolver, Spec, WriteKind},
symbol::SymbolId,
};
pub const R_X86_64_NONE: u32 = 0;
pub const R_X86_64_64: u32 = 1;
pub const R_X86_64_PC32: u32 = 2;
pub const R_X86_64_PLT32: u32 = 4;
pub const R_X86_64_GOT32: u32 = 3;
pub const R_X86_64_GOTPCREL: u32 = 9;
pub const R_X86_64_32: u32 = 10;
pub const R_X86_64_32S: u32 = 11;
pub const R_X86_64_16: u32 = 12;
pub const R_X86_64_PC16: u32 = 13;
pub const R_X86_64_8: u32 = 14;
pub const R_X86_64_PC8: u32 = 15;
pub const R_X86_64_PC64: u32 = 24;
pub const R_X86_64_GOT64: u32 = 27;
pub const R_X86_64_GOTPCREL64: u32 = 28;
pub const R_X86_64_GOTPC64: u32 = 29;
pub const R_X86_64_PLTOFF64: u32 = 31;
pub const R_X86_64_SIZE32: u32 = 32;
pub const R_X86_64_SIZE64: u32 = 33;
pub const R_X86_64_CODE_4_GOTPCRELX: u32 = 43;
pub const R_X86_64_CODE_4_GOTTPOFF: u32 = 44;
pub const R_X86_64_CODE_4_GOTPC32_TLSDESC: u32 = 45;
pub const R_X86_64_CODE_6_GOTTPOFF: u32 = 46;
pub const R_X86_64_CODE_6_GOTPC32_TLSDESC: u32 = 47;
pub const R_X86_64_GOTOFF64: u32 = 25;
pub const R_X86_64_GOTPC32: u32 = 26;
pub const R_X86_64_GOTPCRELX: u32 = 41;
pub const R_X86_64_REX_GOTPCRELX: u32 = 42;
pub const R_X86_64_DTPMOD64: u32 = 16;
pub const R_X86_64_DTPOFF64: u32 = 17;
pub const R_X86_64_TPOFF64: u32 = 18;
pub const R_X86_64_TLSGD: u32 = 19;
pub const R_X86_64_TLSLD: u32 = 20;
pub const R_X86_64_DTPOFF32: u32 = 21;
pub const R_X86_64_GOTTPOFF: u32 = 22;
pub const R_X86_64_TPOFF32: u32 = 23;
pub const R_X86_64_GOTPC32_TLSDESC: u32 = 34;
pub const R_X86_64_TLSDESC_CALL: u32 = 35;
pub const R_X86_64_TLSDESC: u32 = 36;
pub const R_X86_64_RELATIVE: u32 = 8;
pub const R_X86_64_GLOB_DAT: u32 = 6;
pub const R_X86_64_JUMP_SLOT: u32 = 7;
pub const R_X86_64_COPY: u32 = 5;
pub const R_X86_64_IRELATIVE: u32 = 37;
pub struct X86_64;
impl Arch for X86_64 {
fn spec(r_type: u32) -> Result<Spec> {
Ok(match r_type {
R_X86_64_NONE => of(RelExpr::None, WriteKind::W64),
R_X86_64_64 | R_X86_64_TPOFF64 => of(RelExpr::Abs, WriteKind::W64),
R_X86_64_PC32 => of(RelExpr::Pc, WriteKind::W32S),
R_X86_64_PLT32 => of(RelExpr::PltPc, WriteKind::W32S),
R_X86_64_GOTPCREL | R_X86_64_GOTPCRELX | R_X86_64_REX_GOTPCRELX => {
of(RelExpr::GotPc, WriteKind::W32S)
}
R_X86_64_32 => of(RelExpr::Abs, WriteKind::W32),
R_X86_64_32S | R_X86_64_TPOFF32 => {
of(RelExpr::Abs, WriteKind::W32S)
}
R_X86_64_16 => of(RelExpr::Abs, WriteKind::W16SU),
R_X86_64_8 => of(RelExpr::Abs, WriteKind::W8),
R_X86_64_PC8 => of(RelExpr::Pc, WriteKind::W8),
R_X86_64_PC16 => of(RelExpr::Pc, WriteKind::W16SU),
R_X86_64_SIZE32 => of(RelExpr::Size, WriteKind::W32),
R_X86_64_SIZE64 => of(RelExpr::Size, WriteKind::W64),
R_X86_64_CODE_4_GOTPCRELX => of(RelExpr::GotPc, WriteKind::W32S),
R_X86_64_CODE_4_GOTTPOFF | R_X86_64_CODE_6_GOTTPOFF => {
of(RelExpr::TlsGotPc, WriteKind::W32S)
}
R_X86_64_CODE_4_GOTPC32_TLSDESC
| R_X86_64_CODE_6_GOTPC32_TLSDESC => {
of(RelExpr::Escape, WriteKind::W32S)
}
R_X86_64_GOT32 => of(RelExpr::GotOffset, WriteKind::W32),
R_X86_64_GOT64 => of(RelExpr::GotOffset, WriteKind::W64),
R_X86_64_GOTPCREL64 => of(RelExpr::GotPc, WriteKind::W64),
R_X86_64_GOTPC64 => of(RelExpr::GotBase, WriteKind::W64),
R_X86_64_PC64 => of(RelExpr::Pc, WriteKind::W64),
R_X86_64_GOTOFF64 => of(RelExpr::GotOff, WriteKind::W64),
R_X86_64_GOTPC32 => of(RelExpr::GotBase, WriteKind::W32S),
R_X86_64_TLSGD
| R_X86_64_GOTTPOFF
| R_X86_64_GOTPC32_TLSDESC => of(RelExpr::TlsGotPc, WriteKind::W32S),
R_X86_64_TLSDESC_CALL => of(RelExpr::Escape, WriteKind::W16),
R_X86_64_TLSDESC | R_X86_64_DTPMOD64 => {
of(RelExpr::Escape, WriteKind::W64)
}
R_X86_64_TLSLD => of(RelExpr::TlsIndexPc, WriteKind::W32S),
R_X86_64_DTPOFF32 => of(RelExpr::DtpOff, WriteKind::W32S),
R_X86_64_DTPOFF64 => of(RelExpr::DtpOff, WriteKind::W64),
other => return Err(crate::error::Error::UnsupportedReloc(other)),
})
}
#[inline]
fn scan_needs(r_type: u32) -> Result<Needs> {
if matches!(
r_type,
R_X86_64_TLSGD
| R_X86_64_TLSLD
| R_X86_64_GOTPC32_TLSDESC
| R_X86_64_TLSDESC_CALL
) {
return Ok(Needs::NONE);
}
Ok(Self::spec(r_type)?.expr.needs())
}
fn relax_lead(r_type: u32) -> usize {
match r_type {
R_X86_64_GOTPCRELX | R_X86_64_REX_GOTPCRELX => 2,
R_X86_64_TLSGD => TLS_GD_LEAD.len(),
R_X86_64_TLSLD => TLS_LD_LEAD.len(),
R_X86_64_GOTPC32_TLSDESC => TLS_DESC_LEAD,
_ => 0,
}
}
fn relax_covers(r_type: u32) -> bool {
r_type == R_X86_64_TLSDESC_CALL || Self::relax_lead(r_type) != 0
}
fn relax_drops_got(r_type: u32, addend: i64, lead: &[u8]) -> bool {
if !matches!(r_type, R_X86_64_GOTPCRELX | R_X86_64_REX_GOTPCRELX) {
return false;
}
if addend != -4 {
return false;
}
let (Some(&op), Some(&modrm)) = (lead.first(), lead.get(1)) else {
return false;
};
op == 0x8b || (op == 0xff && (modrm == 0x15 || modrm == 0x25))
}
fn relax_required<R: Resolver>(
r_type: u32,
sym: Option<SymbolId>,
resolver: &R,
) -> bool {
match r_type {
R_X86_64_TLSGD
| R_X86_64_TLSLD
| R_X86_64_GOTPC32_TLSDESC
| R_X86_64_TLSDESC_CALL => resolver.is_exec(),
R_X86_64_GOTPCRELX | R_X86_64_REX_GOTPCRELX => {
sym.is_some_and(|id| !resolver.has_got_slot(id))
}
_ => false,
}
}
fn spans_type(r_type: u32) -> bool {
matches!(r_type, R_X86_64_TLSGD | R_X86_64_TLSLD)
}
fn relax_span<R: Resolver>(
site: RelaxSite<'_>,
resolver: &R,
) -> Option<Range<u64>> {
if !Self::spans_type(site.r_type) {
return None;
}
let lead = Self::relax_lead(site.r_type);
let width = Self::spec(site.r_type).ok()?.write.width();
let slot_end = usize::try_from(site.slot).ok()?.checked_add(width)?;
let after = site.data.get(slot_end..).unwrap_or(&[]);
let span = lead.checked_add(width)?.checked_add(Self::relax_trail(
site.r_type,
&[],
after,
))?;
let start = site.slot.checked_sub(u64::try_from(lead).ok()?)?;
let end = start.checked_add(u64::try_from(span).ok()?)?;
let window = site
.data
.get(usize::try_from(start).ok()?..usize::try_from(end).ok()?)?;
let lowered = if site.r_type == R_X86_64_TLSGD {
tls_gd_lowering(site.sym, site.addend, site.place, resolver, window)
.is_some()
} else {
is_tls_ld_sequence(resolver, window)
};
lowered.then_some(start..end)
}
fn relax_trail(r_type: u32, _slot: &[u8], after: &[u8]) -> usize {
match r_type {
R_X86_64_TLSGD => TLS_GD_CALL.len() + DISP32,
R_X86_64_TLSLD => {
if after.get(..2) == Some(&TLS_LD_CALL_INDIRECT[..]) {
TLS_LD_CALL_INDIRECT.len() + DISP32
} else {
TLS_LD_CALL.len() + DISP32
}
}
_ => 0,
}
}
fn relax<R: Resolver>(
r_type: u32,
sym: Option<SymbolId>,
addend: i64,
place: u64,
resolver: &R,
window: &mut [u8],
) -> Result<bool> {
match r_type {
R_X86_64_TLSGD => {
Ok(relax_tls_gd(sym, addend, place, resolver, window))
}
R_X86_64_TLSLD => Ok(relax_tls_ld(resolver, window)),
R_X86_64_GOTPC32_TLSDESC => {
Ok(relax_tls_desc(sym, addend, place, resolver, window))
}
R_X86_64_TLSDESC_CALL => Ok(relax_tls_desc_call(resolver, window)),
_ => Ok(relax_gotpcrelx(
r_type, sym, addend, place, resolver, window,
)),
}
}
}
const DISP32: usize = 4;
const TLS_GD_PAIR: usize = 16;
const TLS_GD_LEAD: [u8; 4] = [0x66, 0x48, 0x8d, 0x3d];
const TLS_GD_CALL: [u8; 4] = [0x66, 0x66, 0x48, 0xe8];
const TLS_GD_CALL_INDIRECT: [u8; 4] = [0x66, 0x48, 0xff, 0x15];
const TLS_LD_LEAD: [u8; 3] = [0x48, 0x8d, 0x3d];
const TLS_LD_CALL: [u8; 1] = [0xe8];
const TLS_LD_CALL_INDIRECT: [u8; 2] = [0xff, 0x15];
const TLS_LD_LE: [u8; 12] = [
0x66, 0x66, 0x66, 0x64, 0x48, 0x8b, 0x04, 0x25, 0x00, 0x00, 0x00, 0x00,
];
const TLS_LD_LE_INDIRECT: [u8; 13] = [
0x66, 0x66, 0x66, 0x66, 0x64, 0x48, 0x8b, 0x04, 0x25, 0x00, 0x00, 0x00,
0x00,
];
const TLS_IE_PREFIX: [u8; 12] = [
0x64, 0x48, 0x8b, 0x04, 0x25, 0x00, 0x00, 0x00, 0x00, 0x48, 0x03, 0x05,
];
const TLS_LE_PREFIX: [u8; 12] = [
0x64, 0x48, 0x8b, 0x04, 0x25, 0x00, 0x00, 0x00, 0x00, 0x48, 0x8d, 0x80,
];
fn relax_tls_gd<R: Resolver>(
sym: Option<SymbolId>,
addend: i64,
place: u64,
resolver: &R,
window: &mut [u8],
) -> bool {
let Some((prefix, value)) =
tls_gd_lowering(sym, addend, place, resolver, window)
else {
return false;
};
let head = prefix.len();
window[..head].copy_from_slice(prefix);
window[head..].copy_from_slice(&value.to_le_bytes());
true
}
fn tls_gd_lowering<R: Resolver>(
sym: Option<SymbolId>,
addend: i64,
place: u64,
resolver: &R,
window: &[u8],
) -> Option<(&'static [u8; 12], i32)> {
if !resolver.is_exec() {
return None;
}
if addend != -4 {
return None;
}
let (Some(sym), TLS_GD_PAIR) = (sym, window.len()) else {
return None;
};
if window[..4] != TLS_GD_LEAD
|| (window[8..12] != TLS_GD_CALL
&& window[8..12] != TLS_GD_CALL_INDIRECT)
{
return None;
}
let got = resolver.tls_got_addr(sym);
let (prefix, value) = if got == 0 {
(&TLS_LE_PREFIX, resolver.symbol_addr(sym).cast_signed())
} else {
(
&TLS_IE_PREFIX,
got.wrapping_sub(place.wrapping_add(12)).cast_signed(),
)
};
i32::try_from(value).ok().map(|value| (prefix, value))
}
const TLS_DESC_LEAD: usize = 3;
const TLS_DESC_CALL: [u8; 2] = [0xff, 0x10];
const TLS_DESC_NOP: [u8; 2] = [0x66, 0x90];
fn relax_tls_desc<R: Resolver>(
sym: Option<SymbolId>,
addend: i64,
place: u64,
resolver: &R,
window: &mut [u8],
) -> bool {
let (Some(sym), true) = (sym, resolver.is_exec()) else {
return false;
};
if addend != -4 || window.len() != TLS_DESC_LEAD + DISP32 {
return false;
}
if window[0] & 0xfb != 0x48 || window[1] != 0x8d || window[2] & 0xc7 != 0x05
{
return false;
}
let got = resolver.tls_got_addr(sym);
let value = if got == 0 {
resolver.symbol_addr(sym).cast_signed()
} else {
got.wrapping_add(addend.cast_unsigned())
.wrapping_sub(place)
.cast_signed()
};
let Ok(value) = i32::try_from(value) else {
return false;
};
if got == 0 {
window[0] = 0x48 | ((window[0] >> 2) & 1);
window[1] = 0xc7;
window[2] = 0xc0 | ((window[2] >> 3) & 7);
} else {
window[1] = 0x8b;
}
window[TLS_DESC_LEAD..].copy_from_slice(&value.to_le_bytes());
true
}
fn relax_tls_desc_call<R: Resolver>(resolver: &R, window: &mut [u8]) -> bool {
if !resolver.is_exec() || window != TLS_DESC_CALL {
return false;
}
window.copy_from_slice(&TLS_DESC_NOP);
true
}
fn relax_tls_ld<R: Resolver>(resolver: &R, window: &mut [u8]) -> bool {
if !is_tls_ld_sequence(resolver, window) {
return false;
}
if window.len() == TLS_LD_LE_INDIRECT.len() {
window.copy_from_slice(&TLS_LD_LE_INDIRECT);
} else {
window.copy_from_slice(&TLS_LD_LE);
}
true
}
fn is_tls_ld_sequence<R: Resolver>(resolver: &R, window: &[u8]) -> bool {
if !resolver.is_exec() || window.get(..3) != Some(&TLS_LD_LEAD[..]) {
return false;
}
match window.len() {
n if n == TLS_LD_LE.len() => window.get(7..8) == Some(&TLS_LD_CALL[..]),
n if n == TLS_LD_LE_INDIRECT.len() => {
window.get(7..9) == Some(&TLS_LD_CALL_INDIRECT[..])
}
_ => false,
}
}
fn relax_gotpcrelx<R: Resolver>(
r_type: u32,
sym: Option<SymbolId>,
addend: i64,
place: u64,
resolver: &R,
window: &mut [u8],
) -> bool {
if !matches!(r_type, R_X86_64_GOTPCRELX | R_X86_64_REX_GOTPCRELX) {
return false;
}
if addend != -4 {
return false;
}
let lead = X86_64::relax_lead(r_type);
if window.len() < lead + DISP32 {
return false;
}
let Some(sym) = sym else {
return false;
};
if resolver.is_preemptible(sym) {
return false;
}
if resolver.is_absolute(sym) {
return false;
}
let sym_addr = resolver.symbol_addr(sym);
let val = sym_addr
.wrapping_add(addend.cast_unsigned())
.wrapping_sub(place);
let op = window[0];
let modrm = window[1];
if op == 0x8b {
if !WriteKind::W32S.fits(val) {
return false;
}
window[0] = 0x8d;
write_disp32(window, lead, val);
return true;
}
if op == 0xff && (modrm == 0x15 || modrm == 0x25) {
return relax_indirect_call(window, modrm, val);
}
false
}
fn relax_indirect_call(window: &mut [u8], modrm: u8, val: u64) -> bool {
let is_call = modrm == 0x15;
let disp_val = if is_call { val } else { val.wrapping_add(1) };
if !WriteKind::W32S.fits(disp_val) {
return false;
}
if is_call {
window[0] = 0x67; window[1] = 0xe8; write_disp32(window, 2, disp_val);
} else {
window[0] = 0xe9; write_disp32(window, 1, disp_val);
window[5] = 0x90;
}
true
}
fn write_disp32(window: &mut [u8], at: usize, value: u64) {
#[allow(clippy::cast_possible_truncation)]
let bytes = (value as i32).to_le_bytes();
window[at..at + DISP32].copy_from_slice(&bytes);
}