use crate::{
dynamic::DynamicPlan,
elf::Rela64,
endian::{I64, U64},
error::{Error, Result},
layout::{Layout, Sect},
reloc::Target,
symbol::SymbolId,
util::push_rel32,
};
const GOT_ENTRY: u64 = 8;
pub struct PltPlan {
pub plt: Vec<u8>,
pub got_plt: Vec<u8>,
pub rela_plt: Vec<Rela64>,
}
pub fn build_plan(
layout: &Layout,
dynamic: Option<&DynamicPlan>,
) -> Result<PltPlan> {
let plt = build_plt_bytes(layout);
let got_plt = build_got_plt_bytes(layout);
let rela_plt = build_rela_plt(layout, dynamic)?;
Ok(PltPlan {
plt,
got_plt,
rela_plt,
})
}
fn build_plt_bytes(layout: &Layout) -> Vec<u8> {
match layout.target {
Target::X86_64 => build_plt_bytes_x86_64(layout),
Target::AArch64 => build_plt_bytes_aarch64(layout),
Target::Riscv64 => build_plt_bytes_riscv(layout),
}
}
fn build_got_plt_bytes(layout: &Layout) -> Vec<u8> {
match layout.target {
Target::X86_64 | Target::AArch64 => build_got_plt_bytes_3hdr(layout),
Target::Riscv64 => build_got_plt_bytes_2hdr(layout),
}
}
fn build_rela_plt(
layout: &Layout,
dyn_plan: Option<&DynamicPlan>,
) -> Result<Vec<Rela64>> {
let got_plt = layout.region(Sect::GotPlt).vaddr;
let reserved = layout.target.plt_spec().got_plt_reserved;
let mut out = Vec::with_capacity(layout.plt_keys.len());
for (i, key) in layout.plt_keys.iter().enumerate() {
let sym = key
.global_id()
.ok_or(Error::Format("PLT entry is not a global symbol"))?;
let slot = got_plt
.wrapping_add(reserved * GOT_ENTRY)
.wrapping_add(u64::try_from(i).unwrap_or(0) * GOT_ENTRY);
out.push(if layout.is_ifunc(sym) {
irelative(layout, slot, sym)
} else {
jump_slot(dyn_plan, slot, sym)?
});
}
Ok(out)
}
fn irelative(layout: &Layout, slot: u64, sym: SymbolId) -> Rela64 {
Rela64 {
r_offset: U64::new(slot),
r_info: U64::new(u64::from(layout.target.dyn_relocs().irelative)),
r_addend: I64::new(layout.ifunc_resolver(sym).cast_signed()),
}
}
fn jump_slot(
dyn_plan: Option<&DynamicPlan>,
slot: u64,
sym: SymbolId,
) -> Result<Rela64> {
let plan = dyn_plan
.ok_or(Error::Format("PLT entry for an import in a static image"))?;
let sym_idx = plan.import_index(sym).ok_or(Error::Format(
"PLT symbol has no dynamic symbol table entry",
))?;
Ok(Rela64 {
r_offset: U64::new(slot),
r_info: U64::new(
(u64::from(sym_idx) << 32) | u64::from(plan.relocs.jump_slot),
),
r_addend: I64::new(0),
})
}
const X86_64_PLT: u64 = 16;
fn build_plt_bytes_x86_64(layout: &Layout) -> Vec<u8> {
let p0 = layout.region(Sect::Plt).vaddr;
let got_plt = layout.region(Sect::GotPlt).vaddr;
let got1 = got_plt.wrapping_add(GOT_ENTRY);
let got2 = got_plt.wrapping_add(2 * GOT_ENTRY);
let mut out = Vec::with_capacity(plt_capacity(layout));
out.extend_from_slice(&[0xff, 0x35]);
push_rel32(&mut out, got1.wrapping_sub(p0.wrapping_add(6)));
out.extend_from_slice(&[0xff, 0x25]);
push_rel32(&mut out, got2.wrapping_sub(p0.wrapping_add(12)));
out.extend_from_slice(&[0x0f, 0x1f, 0x40, 0x00]);
for (i, _key) in layout.plt_keys.iter().enumerate() {
let i64 = u64::try_from(i).unwrap_or(0);
let pn = p0.wrapping_add(X86_64_PLT).wrapping_add(i64 * X86_64_PLT);
let slot = got_plt
.wrapping_add(3 * GOT_ENTRY)
.wrapping_add(i64 * GOT_ENTRY);
out.extend_from_slice(&[0xff, 0x25]);
push_rel32(&mut out, slot.wrapping_sub(pn.wrapping_add(6)));
out.extend_from_slice(&[0x68]);
push_rel32(&mut out, i64);
out.extend_from_slice(&[0xe9]);
push_rel32(&mut out, p0.wrapping_sub(pn.wrapping_add(16)));
}
out
}
fn build_got_plt_bytes_3hdr(layout: &Layout) -> Vec<u8> {
let mut out = Vec::with_capacity(got_plt_capacity(layout));
let dynamic_addr = layout
.dynamic
.as_ref()
.map_or(0, |p| p.regions.dynamic.vaddr);
let got0 = if layout.target == Target::X86_64 {
dynamic_addr
} else {
0
};
push_u64(&mut out, got0);
push_u64(&mut out, 0); push_u64(&mut out, 0); let p0 = layout.region(Sect::Plt).vaddr;
for (i, _key) in layout.plt_keys.iter().enumerate() {
let i64 = u64::try_from(i).unwrap_or(0);
let initial = match layout.target {
Target::X86_64 => p0
.wrapping_add(X86_64_PLT)
.wrapping_add(i64 * X86_64_PLT)
.wrapping_add(6),
_ => p0,
};
push_u64(&mut out, initial);
}
out
}
fn build_plt_bytes_aarch64(layout: &Layout) -> Vec<u8> {
let p0 = layout.region(Sect::Plt).vaddr;
let got_plt = layout.region(Sect::GotPlt).vaddr;
let resolver_slot = got_plt.wrapping_add(2 * GOT_ENTRY);
let mut out = Vec::with_capacity(plt_capacity(layout));
out.extend_from_slice(&[0xf0, 0x7b, 0xbf, 0xa9]);
write_adrp(&mut out, p0.wrapping_add(4), resolver_slot);
write_ldr_imm12(&mut out, resolver_slot);
write_add_imm12(&mut out, resolver_slot);
out.extend_from_slice(&[0x20, 0x02, 0x1f, 0xd6]);
out.extend_from_slice(&[0x1f, 0x20, 0x03, 0xd5]);
out.extend_from_slice(&[0x1f, 0x20, 0x03, 0xd5]);
out.extend_from_slice(&[0x1f, 0x20, 0x03, 0xd5]);
for (i, _key) in layout.plt_keys.iter().enumerate() {
let i64 = u64::try_from(i).unwrap_or(0);
let entry_addr = p0.wrapping_add(32).wrapping_add(i64 * 16);
let slot = got_plt
.wrapping_add(3 * GOT_ENTRY)
.wrapping_add(i64 * GOT_ENTRY);
write_adrp(&mut out, entry_addr, slot);
write_ldr_imm12(&mut out, slot);
write_add_imm12(&mut out, slot);
out.extend_from_slice(&[0x20, 0x02, 0x1f, 0xd6]);
}
out
}
fn write_adrp(out: &mut Vec<u8>, place: u64, sym: u64) {
let page_diff = (sym & !0xFFF).wrapping_sub(place & !0xFFF) >> 12;
#[allow(clippy::cast_possible_truncation)]
let imm = page_diff as u32 & 0x1F_FFFF;
let imm_lo = (imm & 0x3) << 29;
let imm_hi = (imm & 0x001F_FFFC) << 3;
let insn: u32 = 0x9000_0010 | imm_lo | imm_hi;
out.extend_from_slice(&insn.to_le_bytes());
}
fn write_ldr_imm12(out: &mut Vec<u8>, sym: u64) {
let disp = ((sym & 0xFFF) >> 3) as u32;
let insn: u32 = 0xF940_0211 | ((disp & 0xFFF) << 10);
out.extend_from_slice(&insn.to_le_bytes());
}
fn write_add_imm12(out: &mut Vec<u8>, sym: u64) {
let imm12 = (sym & 0xFFF) as u32;
let insn: u32 = 0x9100_0210 | (imm12 << 10);
out.extend_from_slice(&insn.to_le_bytes());
}
fn build_plt_bytes_riscv(layout: &Layout) -> Vec<u8> {
let p0 = layout.region(Sect::Plt).vaddr;
let got_plt = layout.region(Sect::GotPlt).vaddr;
let mut out = Vec::with_capacity(plt_capacity(layout));
let off = got_plt.wrapping_sub(p0);
write_auipc(&mut out, XReg::T2, hi20_signed(off));
write_rtype(&mut out, 0x33, 0, XReg::T1, XReg::T1, XReg::T3, 0x20);
write_itype(&mut out, 0x03, 0x3, XReg::T3, XReg::T2, lo12_signed(off));
write_itype(&mut out, 0x13, 0x0, XReg::T1, XReg::T1, -44);
write_itype(&mut out, 0x13, 0x0, XReg::T0, XReg::T2, lo12_signed(off));
write_itype_shift(&mut out, 0x13, 0x5, XReg::T1, XReg::T1, 1);
write_itype(&mut out, 0x03, 0x3, XReg::T0, XReg::T0, 8);
write_itype_jalr(&mut out, XReg::T3, XReg::Zero);
for (i, _key) in layout.plt_keys.iter().enumerate() {
let i64 = u64::try_from(i).unwrap_or(0);
let entry_addr = p0.wrapping_add(32).wrapping_add(i64 * 16);
let slot = got_plt
.wrapping_add(2 * GOT_ENTRY)
.wrapping_add(i64 * GOT_ENTRY);
let off = slot.wrapping_sub(entry_addr);
write_auipc(&mut out, XReg::T3, hi20_signed(off));
write_itype(&mut out, 0x03, 0x3, XReg::T3, XReg::T3, lo12_signed(off));
write_itype_jalr(&mut out, XReg::T3, XReg::T1);
write_itype(&mut out, 0x13, 0x0, XReg::Zero, XReg::Zero, 0);
}
out
}
fn build_got_plt_bytes_2hdr(layout: &Layout) -> Vec<u8> {
let mut out = Vec::with_capacity(got_plt_capacity(layout));
let p0 = layout.region(Sect::Plt).vaddr;
push_u64(&mut out, 0); push_u64(&mut out, 0); for _ in &layout.plt_keys {
push_u64(&mut out, p0);
}
out
}
#[derive(Copy, Clone)]
#[allow(non_camel_case_types, reason = "matches the ABI register names")]
enum XReg {
Zero = 0,
T0 = 5,
T1 = 6,
T2 = 7,
T3 = 28,
}
#[allow(
clippy::cast_possible_truncation,
clippy::cast_sign_loss,
reason = "intentional bit-pattern reinterpret"
)]
fn write_auipc(out: &mut Vec<u8>, rd: XReg, imm20: i32) {
let imm = (imm20 as u32 & 0xFFFFF) << 12;
let opcode = 0x17; let insn = imm | (u32::from(rd as u8) << 7) | opcode;
out.extend_from_slice(&insn.to_le_bytes());
}
#[allow(
clippy::cast_possible_truncation,
clippy::cast_sign_loss,
reason = "intentional bit-pattern reinterpret"
)]
fn write_itype(
out: &mut Vec<u8>,
opcode: u32,
funct3: u32,
rd: XReg,
rs1: XReg,
imm12: i32,
) {
let imm = imm12 as u32 & 0xFFF;
let insn = imm << 20
| (u32::from(rs1 as u8) << 15)
| (funct3 << 12)
| (u32::from(rd as u8) << 7)
| opcode;
out.extend_from_slice(&insn.to_le_bytes());
}
fn write_itype_jalr(out: &mut Vec<u8>, rs1: XReg, rd: XReg) {
write_itype(out, 0x67, 0x0, rd, rs1, 0);
}
#[allow(clippy::cast_possible_truncation)]
fn write_itype_shift(
out: &mut Vec<u8>,
opcode: u32,
funct3: u32,
rd: XReg,
rs1: XReg,
shamt: u32,
) {
let insn = ((shamt & 0x3F) << 20)
| (u32::from(rs1 as u8) << 15)
| (funct3 << 12)
| (u32::from(rd as u8) << 7)
| opcode;
out.extend_from_slice(&insn.to_le_bytes());
}
#[allow(clippy::cast_possible_truncation)]
fn write_rtype(
out: &mut Vec<u8>,
opcode: u32,
funct3: u32,
rd: XReg,
rs1: XReg,
rs2: XReg,
funct7: u32,
) {
let insn = (funct7 << 25)
| (u32::from(rs2 as u8) << 20)
| (u32::from(rs1 as u8) << 15)
| (funct3 << 12)
| (u32::from(rd as u8) << 7)
| opcode;
out.extend_from_slice(&insn.to_le_bytes());
}
#[allow(
clippy::cast_possible_truncation,
clippy::cast_possible_wrap,
reason = "intentional bit-pattern reinterpret"
)]
fn hi20_signed(value: u64) -> i32 {
let adjusted = value.wrapping_add(0x800);
((adjusted.cast_signed()) >> 12) as i32
}
#[allow(
clippy::cast_possible_truncation,
clippy::cast_possible_wrap,
reason = "intentional bit-pattern reinterpret"
)]
fn lo12_signed(value: u64) -> i32 {
(value.cast_signed() & 0xFFF) as i32
}
fn plt_capacity(layout: &Layout) -> usize {
usize::try_from(layout.region(Sect::Plt).size).unwrap_or(0)
}
fn got_plt_capacity(layout: &Layout) -> usize {
usize::try_from(layout.region(Sect::GotPlt).size).unwrap_or(0)
}
fn push_u64(out: &mut Vec<u8>, value: u64) {
out.extend_from_slice(&value.to_le_bytes());
}