use crate::{
coff::{
CoffFile, CoffReloc,
constants::{
IMAGE_FILE_MACHINE_AMD64, IMAGE_FILE_MACHINE_I386,
IMAGE_SYM_CLASS_EXTERNAL,
},
},
error::{Error, Result},
reloc::{
Resolver, apply,
coff_i386::CoffI386,
coff_x86_64::{
CoffX86_64, IMAGE_REL_AMD64_ADDR64, IMAGE_REL_AMD64_REL32,
IMAGE_REL_AMD64_REL32_1, IMAGE_REL_AMD64_REL32_2,
IMAGE_REL_AMD64_REL32_3, IMAGE_REL_AMD64_REL32_4,
IMAGE_REL_AMD64_REL32_5,
},
},
symbol::SymbolId,
};
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum CoffTarget {
X86_64,
I386,
}
impl CoffTarget {
pub fn from_machine(machine: u16) -> Result<Self> {
match machine {
IMAGE_FILE_MACHINE_AMD64 => Ok(Self::X86_64),
IMAGE_FILE_MACHINE_I386 => Ok(Self::I386),
_ => Err(Error::Format("unsupported COFF machine type")),
}
}
pub const fn is_writable(self) -> bool {
matches!(self, Self::X86_64)
}
}
pub fn apply_reloc<R: Resolver>(
target: CoffTarget,
r_type: u32,
sym: Option<SymbolId>,
addend: i64,
place: u64,
resolver: &R,
out: &mut [u8],
) -> Result<()> {
match target {
CoffTarget::X86_64 => {
apply::<CoffX86_64, R>(r_type, sym, addend, place, resolver, out)
}
CoffTarget::I386 => {
apply::<CoffI386, R>(r_type, sym, addend, place, resolver, out)
}
}
}
pub fn reloc_width(reloc: &CoffReloc) -> usize {
match u32::from(reloc.typ) {
IMAGE_REL_AMD64_ADDR64 => 8,
_ => 4,
}
}
pub fn addend_for(reloc: &CoffReloc, slot: &[u8]) -> i64 {
let raw = read_signed_le(slot, reloc_width(reloc));
match u32::from(reloc.typ) {
IMAGE_REL_AMD64_REL32 => raw - 4,
IMAGE_REL_AMD64_REL32_1 => raw - 5,
IMAGE_REL_AMD64_REL32_2 => raw - 6,
IMAGE_REL_AMD64_REL32_3 => raw - 7,
IMAGE_REL_AMD64_REL32_4 => raw - 8,
IMAGE_REL_AMD64_REL32_5 => raw - 9,
_ => 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 struct CoffResolver<'a> {
addr: &'a [u64],
sec_rva: &'a [u32],
image_base: u64,
}
impl<'a> CoffResolver<'a> {
pub fn new(addr: &'a [u64], sec_rva: &'a [u32], image_base: u64) -> Self {
Self {
addr,
sec_rva,
image_base,
}
}
pub fn section_rva(&self, sym: SymbolId) -> u32 {
self.sec_rva.get(sym.0).copied().unwrap_or_default()
}
pub const fn image_base(&self) -> u64 {
self.image_base
}
}
impl Resolver for CoffResolver<'_> {
fn symbol_addr(&self, sym: SymbolId) -> u64 {
self.addr.get(sym.0).copied().unwrap_or_default()
}
fn got_addr(&self, sym: SymbolId) -> u64 {
self.symbol_addr(sym)
}
fn got_base(&self) -> u64 {
0
}
fn plt_addr(&self, sym: SymbolId) -> u64 {
self.symbol_addr(sym)
}
}
pub fn global_symbol_addr(
inputs: &[CoffFile<'_>],
sym_addr: &[Vec<u64>],
name: &[u8],
) -> Option<u64> {
for (file, input) in inputs.iter().enumerate() {
for sym in input.symbols().iter() {
if sym.name != name
|| sym.storage_class != IMAGE_SYM_CLASS_EXTERNAL
|| sym.section_number <= 0
{
continue;
}
return sym_addr
.get(file)
.and_then(|f| f.get(sym.index as usize))
.copied();
}
}
None
}