use rustc_hash::FxHashMap;
use super::{insn_cell, of, read_le, write_le};
use crate::{
elf::Rela64,
endian::{I64, U64},
error::{Error, Result},
reloc::{
Arch, Check, Field, Needs, RelExpr, Resolver, Spec, Write, WriteKind,
pc_value, plt_pc_value,
},
symbol::SymbolId,
};
pub const R_RISCV_NONE: u32 = 0;
pub const R_RISCV_32: u32 = 1;
pub const R_RISCV_64: u32 = 2;
pub const R_RISCV_BRANCH: u32 = 16;
pub const R_RISCV_JAL: u32 = 17;
pub const R_RISCV_CALL: u32 = 18;
pub const R_RISCV_CALL_PLT: u32 = 19;
pub const R_RISCV_GOT_HI20: u32 = 20;
pub const R_RISCV_PCREL_HI20: u32 = 23;
pub const R_RISCV_PCREL_LO12_I: u32 = 24;
pub const R_RISCV_PCREL_LO12_S: u32 = 25;
pub const R_RISCV_HI20: u32 = 26;
pub const R_RISCV_LO12_I: u32 = 27;
pub const R_RISCV_LO12_S: u32 = 28;
pub const R_RISCV_ADD8: u32 = 33;
pub const R_RISCV_ADD16: u32 = 34;
pub const R_RISCV_ADD32: u32 = 35;
pub const R_RISCV_ADD64: u32 = 36;
pub const R_RISCV_SUB8: u32 = 37;
pub const R_RISCV_SUB16: u32 = 38;
pub const R_RISCV_SUB32: u32 = 39;
pub const R_RISCV_SUB64: u32 = 40;
pub const R_RISCV_GOT32_PCREL: u32 = 41;
pub const R_RISCV_ALIGN: u32 = 43;
pub const R_RISCV_RVC_BRANCH: u32 = 44;
pub const R_RISCV_RVC_JUMP: u32 = 45;
pub const R_RISCV_RELAX: u32 = 51;
pub const R_RISCV_SET_ULEB128: u32 = 60;
pub const R_RISCV_SUB_ULEB128: u32 = 61;
pub const R_RISCV_SUB6: u32 = 52;
pub const R_RISCV_SET6: u32 = 53;
pub const R_RISCV_SET8: u32 = 54;
pub const R_RISCV_SET16: u32 = 55;
pub const R_RISCV_SET32: u32 = 56;
pub const R_RISCV_32_PCREL: u32 = 57;
pub const R_RISCV_PLT32: u32 = 59;
const EF_RISCV_RVC: u32 = 0x1;
const EF_RISCV_FLOAT_ABI: u32 = 0x6;
const EF_RISCV_RVE: u32 = 0x8;
pub(super) fn merge_eflags(
so_far: Option<u32>,
incoming: u32,
) -> core::result::Result<u32, &'static str> {
let Some(target) = so_far else {
return Ok(incoming);
};
if incoming & EF_RISCV_FLOAT_ABI != target & EF_RISCV_FLOAT_ABI {
return Err("floating-point ABI");
}
if incoming & EF_RISCV_RVE != target & EF_RISCV_RVE {
return Err("register set");
}
Ok(target | (incoming & EF_RISCV_RVC))
}
pub const R_RISCV_TLS_DTPMOD64: u32 = 7;
pub const R_RISCV_TLS_DTPREL64: u32 = 9;
pub const R_RISCV_TLS_TPREL64: u32 = 11;
pub const R_RISCV_RELATIVE: u32 = 3;
pub const R_RISCV_COPY: u32 = 4;
pub const R_RISCV_JUMP_SLOT: u32 = 5;
pub const R_RISCV_IRELATIVE: u32 = 58;
pub const R_RISCV_TLS_GD_HI20: u32 = 22;
pub const R_RISCV_TLS_GOT_HI20: u32 = 21;
pub const R_RISCV_TPREL_HI20: u32 = 29;
pub const R_RISCV_TPREL_ADD: u32 = 32;
pub const R_RISCV_TPREL_LO12_I: u32 = 30;
pub const R_RISCV_TPREL_LO12_S: u32 = 31;
pub const R_RISCV_TLSDESC_HI20: u32 = 62;
pub const R_RISCV_TLSDESC_LOAD_LO12: u32 = 63;
pub struct Riscv64;
impl Arch for Riscv64 {
fn spec(r_type: u32) -> Result<Spec> {
Ok(match r_type {
R_RISCV_SET_ULEB128 | R_RISCV_SUB_ULEB128 => {
of(RelExpr::Escape, Write::Bytes(WriteKind::W8))
}
R_RISCV_NONE | R_RISCV_RELAX | R_RISCV_ALIGN => {
of(RelExpr::None, Write::Bytes(WriteKind::W64))
}
R_RISCV_32 => of(RelExpr::Abs, Write::Bytes(WriteKind::W32SU)),
R_RISCV_64 => of(RelExpr::Abs, Write::Bytes(WriteKind::W64)),
R_RISCV_32_PCREL => of(RelExpr::Pc, Write::Bytes(WriteKind::W32S)),
R_RISCV_PLT32 => of(RelExpr::PltPc, Write::Bytes(WriteKind::W32S)),
R_RISCV_GOT32_PCREL => {
of(RelExpr::GotPc, Write::Bytes(WriteKind::W32S))
}
R_RISCV_LO12_I | R_RISCV_TPREL_LO12_I => {
of(RelExpr::Abs, Write::Field(itype_lo12()))
}
R_RISCV_TPREL_ADD => of(RelExpr::None, Write::Field(insn_cell(4))),
R_RISCV_HI20
| R_RISCV_LO12_S
| R_RISCV_GOT_HI20
| R_RISCV_PCREL_HI20
| R_RISCV_PCREL_LO12_I
| R_RISCV_PCREL_LO12_S
| R_RISCV_JAL
| R_RISCV_BRANCH
| R_RISCV_TLS_GD_HI20
| R_RISCV_TLS_GOT_HI20
| R_RISCV_TPREL_HI20
| R_RISCV_TPREL_LO12_S
| R_RISCV_TLSDESC_HI20
| R_RISCV_TLSDESC_LOAD_LO12 => {
of(RelExpr::Escape, Write::Field(insn_cell(4)))
}
R_RISCV_CALL | R_RISCV_CALL_PLT => {
of(RelExpr::Escape, Write::Field(insn_cell(8)))
}
R_RISCV_RVC_BRANCH | R_RISCV_RVC_JUMP => {
of(RelExpr::Escape, Write::Field(insn_cell(2)))
}
R_RISCV_ADD8 | R_RISCV_SUB8 | R_RISCV_SET6 | R_RISCV_SUB6
| R_RISCV_SET8 => of(RelExpr::Escape, Write::Bytes(WriteKind::W8)),
R_RISCV_ADD16 | R_RISCV_SUB16 | R_RISCV_SET16 => {
of(RelExpr::Escape, Write::Bytes(WriteKind::W16))
}
R_RISCV_ADD32 | R_RISCV_SUB32 | R_RISCV_SET32 => {
of(RelExpr::Escape, Write::Bytes(WriteKind::W32))
}
R_RISCV_ADD64 | R_RISCV_SUB64 => {
of(RelExpr::Escape, 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(match r_type {
R_RISCV_CALL | R_RISCV_CALL_PLT => Needs { plt: true, ..base },
R_RISCV_GOT_HI20 => Needs { got: true, ..base },
_ => base,
})
}
fn relax_covers(r_type: u32) -> bool {
r_type == R_RISCV_SET_ULEB128
|| matches!(
r_type,
R_RISCV_TLS_GD_HI20
| R_RISCV_TLSDESC_HI20
| R_RISCV_TLSDESC_LOAD_LO12
)
}
fn relax_required<R: Resolver>(
r_type: u32,
_sym: Option<SymbolId>,
_resolver: &R,
) -> bool {
r_type == R_RISCV_SET_ULEB128
}
fn relax_trail(r_type: u32, slot: &[u8], after: &[u8]) -> usize {
if r_type != R_RISCV_SET_ULEB128 {
return 0;
}
if slot.first().is_none_or(|b| b & 0x80 == 0) {
return 0;
}
let mut n = 0;
for &byte in after.iter().take(ULEB_MAX - 1) {
n += 1;
if byte & 0x80 == 0 {
break;
}
}
n
}
fn relax<R: Resolver>(
r_type: u32,
_sym: Option<SymbolId>,
addend: i64,
_place: u64,
_resolver: &R,
window: &mut [u8],
) -> Result<bool> {
if r_type != R_RISCV_SET_ULEB128 {
return Ok(false);
}
write_uleb_in_place(window, addend.cast_unsigned())?;
Ok(true)
}
fn escape<R: Resolver>(
r_type: u32,
sym: Option<SymbolId>,
addend: i64,
place: u64,
resolver: &R,
out: &mut [u8],
) -> Result<()> {
match r_type {
R_RISCV_HI20 | R_RISCV_TPREL_HI20 => {
let val = RelExpr::Abs.compute(sym, addend, 0, resolver)?;
write_hi20(out, val, r_type)
}
R_RISCV_LO12_S | R_RISCV_TPREL_LO12_S => {
let val = RelExpr::Abs.compute(sym, addend, 0, resolver)?;
write_lo12_s(out, val)
}
R_RISCV_PCREL_HI20 => {
let val =
pc_value::<Self, R>(r_type, sym, addend, place, resolver)?;
write_hi20(out, val, r_type)
}
R_RISCV_GOT_HI20 => {
let val =
RelExpr::GotPc.compute(sym, addend, place, resolver)?;
write_hi20(out, val, r_type)
}
R_RISCV_JAL => {
let val =
pc_value::<Self, R>(r_type, sym, addend, place, resolver)?;
write_jal(out, val, r_type)
}
R_RISCV_BRANCH => {
let val =
pc_value::<Self, R>(r_type, sym, addend, place, resolver)?;
write_branch(out, val, r_type)
}
R_RISCV_RVC_BRANCH => {
let val =
pc_value::<Self, R>(r_type, sym, addend, place, resolver)?;
write_cbtype(out, val, r_type)
}
R_RISCV_RVC_JUMP => {
let val =
pc_value::<Self, R>(r_type, sym, addend, place, resolver)?;
write_cjtype(out, val, r_type)
}
R_RISCV_CALL | R_RISCV_CALL_PLT => {
let val = plt_pc_value::<Self, R>(
r_type, sym, addend, place, resolver,
)?;
write_call(out, val, r_type)
}
R_RISCV_ADD8 | R_RISCV_ADD16 | R_RISCV_ADD32 | R_RISCV_ADD64
| R_RISCV_SUB8 | R_RISCV_SUB16 | R_RISCV_SUB32 | R_RISCV_SUB64
| R_RISCV_SET6 | R_RISCV_SUB6 | R_RISCV_SET8 | R_RISCV_SET16
| R_RISCV_SET32 => {
let val = RelExpr::Abs.compute(sym, addend, 0, resolver)?;
apply_rmw(r_type, out, val)
}
R_RISCV_PCREL_LO12_I => {
let val =
pc_value::<Self, R>(r_type, sym, addend, place, resolver)?;
write_lo12_i(out, val)
}
R_RISCV_PCREL_LO12_S => {
let val =
pc_value::<Self, R>(r_type, sym, addend, place, resolver)?;
write_lo12_s(out, val)
}
_ => Err(Error::UnsupportedReloc(r_type)),
}
}
fn undef_weak_pc(r_type: u32, addend: i64, place: u64) -> u64 {
let a = addend.cast_unsigned();
match r_type {
R_RISCV_BRANCH | R_RISCV_JAL | R_RISCV_CALL | R_RISCV_CALL_PLT
| R_RISCV_RVC_BRANCH | R_RISCV_RVC_JUMP | R_RISCV_PLT32 => a,
_ => a.wrapping_sub(place),
}
}
}
const fn itype_lo12() -> Field {
Field::new(4, 0, 20, 12, Check::None)
}
fn fits_signed(value: i64, bits: u8) -> bool {
super::fits_signed(value.cast_unsigned(), u32::from(bits))
}
fn write_hi20(out: &mut [u8], val: u64, r_type: u32) -> Result<()> {
if out.len() != 4 {
return Err(Error::OutOfRange("RISC-V hi20 relocation slot"));
}
let adjusted = val.wrapping_add(0x800);
let hi = adjusted.cast_signed() >> 12;
if !fits_signed(hi, 20) {
return Err(Error::RelocOverflow(r_type));
}
#[allow(clippy::cast_possible_truncation)]
let imm = (adjusted & 0xFFFF_F000) as u32;
patch32(out, 0x0FFF, imm)
}
fn write_lo12_s(out: &mut [u8], val: u64) -> Result<()> {
if out.len() != 4 {
return Err(Error::OutOfRange("RISC-V lo12_s relocation slot"));
}
let imm = val & 0xFFF;
let field = ((imm >> 5) << 25) | ((imm & 0x1F) << 7);
#[allow(clippy::cast_possible_truncation)]
patch32(out, 0x01FF_F07F, field as u32)
}
fn write_lo12_i(out: &mut [u8], val: u64) -> Result<()> {
if out.len() != 4 {
return Err(Error::OutOfRange("RISC-V lo12_i relocation slot"));
}
let field = (val & 0xFFF) << 20;
#[allow(clippy::cast_possible_truncation)]
patch32(out, 0x000F_FFFF, field as u32)
}
const fn check_even(val: u64, r_type: u32) -> Result<()> {
if val & 1 != 0 {
return Err(Error::RelocMisaligned(r_type));
}
Ok(())
}
fn write_jal(out: &mut [u8], val: u64, r_type: u32) -> Result<()> {
if out.len() != 4 {
return Err(Error::OutOfRange("RISC-V jal relocation slot"));
}
if !fits_signed(val.cast_signed(), 21) {
return Err(Error::RelocOverflow(r_type));
}
check_even(val, r_type)?;
let field = (((val >> 20) & 0x1) << 31)
| (((val >> 1) & 0x3FF) << 21)
| (((val >> 11) & 0x1) << 20)
| (((val >> 12) & 0xFF) << 12);
#[allow(clippy::cast_possible_truncation)]
patch32(out, 0x0FFF, field as u32)
}
fn write_branch(out: &mut [u8], val: u64, r_type: u32) -> Result<()> {
if out.len() != 4 {
return Err(Error::OutOfRange("RISC-V branch relocation slot"));
}
if !fits_signed(val.cast_signed(), 13) {
return Err(Error::RelocOverflow(r_type));
}
check_even(val, r_type)?;
let field = (((val >> 12) & 0x1) << 31)
| (((val >> 5) & 0x3F) << 25)
| (((val >> 1) & 0xF) << 8)
| (((val >> 11) & 0x1) << 7);
#[allow(clippy::cast_possible_truncation)]
patch32(out, 0x01FF_F07F, field as u32)
}
fn write_cbtype(out: &mut [u8], val: u64, r_type: u32) -> Result<()> {
if out.len() != 2 {
return Err(Error::OutOfRange("RISC-V c.b relocation slot"));
}
if !fits_signed(val.cast_signed(), 9) {
return Err(Error::RelocOverflow(r_type));
}
check_even(val, r_type)?;
let insn = u16::from_le_bytes([out[0], out[1]]);
let field = (((val >> 8) & 0x1) << 12)
| (((val >> 3) & 0x3) << 10)
| (((val >> 6) & 0x3) << 5)
| (((val >> 1) & 0x3) << 3)
| (((val >> 5) & 0x1) << 2);
#[allow(clippy::cast_possible_truncation)]
let patched = (insn & 0xE383) | (field as u16);
out.copy_from_slice(&patched.to_le_bytes());
Ok(())
}
fn write_cjtype(out: &mut [u8], val: u64, r_type: u32) -> Result<()> {
if out.len() != 2 {
return Err(Error::OutOfRange("RISC-V c.j relocation slot"));
}
if !fits_signed(val.cast_signed(), 12) {
return Err(Error::RelocOverflow(r_type));
}
check_even(val, r_type)?;
let insn = u16::from_le_bytes([out[0], out[1]]);
let field = (((val >> 11) & 0x1) << 12)
| (((val >> 4) & 0x1) << 11)
| (((val >> 8) & 0x3) << 9)
| (((val >> 10) & 0x1) << 8)
| (((val >> 6) & 0x1) << 7)
| (((val >> 7) & 0x1) << 6)
| (((val >> 1) & 0x7) << 3)
| (((val >> 5) & 0x1) << 2);
#[allow(clippy::cast_possible_truncation)]
let patched = (insn & 0xE003) | (field as u16);
out.copy_from_slice(&patched.to_le_bytes());
Ok(())
}
fn write_call(out: &mut [u8], val: u64, r_type: u32) -> Result<()> {
if out.len() != 8 {
return Err(Error::OutOfRange("RISC-V call relocation slot"));
}
write_hi20(&mut out[..4], val, r_type)?;
write_lo12_i(&mut out[4..], val)
}
fn apply_rmw(r_type: u32, out: &mut [u8], val: u64) -> Result<()> {
match r_type {
R_RISCV_ADD8 => add_sub_le(out, 1, val, false),
R_RISCV_ADD16 => add_sub_le(out, 2, val, false),
R_RISCV_ADD32 => add_sub_le(out, 4, val, false),
R_RISCV_ADD64 => add_sub_le(out, 8, val, false),
R_RISCV_SUB8 => add_sub_le(out, 1, val, true),
R_RISCV_SUB16 => add_sub_le(out, 2, val, true),
R_RISCV_SUB32 => add_sub_le(out, 4, val, true),
R_RISCV_SUB64 => add_sub_le(out, 8, val, true),
R_RISCV_SET6 => set_sub6(out, val, false),
R_RISCV_SUB6 => set_sub6(out, val, true),
R_RISCV_SET8 => set_le(out, 1, val),
R_RISCV_SET16 => set_le(out, 2, val),
R_RISCV_SET32 => {
if !fits_signed(val.cast_signed(), 32) {
return Err(Error::RelocOverflow(r_type));
}
set_le(out, 4, val)
}
other => Err(Error::UnsupportedReloc(other)),
}
}
fn add_sub_le(out: &mut [u8], n: usize, val: u64, sub: bool) -> Result<()> {
if out.len() != n {
return Err(Error::OutOfRange("RISC-V add/sub relocation slot"));
}
let cur = read_le(out, n);
let next = if sub {
cur.wrapping_sub(val)
} else {
cur.wrapping_add(val)
};
write_le(out, n, next);
Ok(())
}
fn set_le(out: &mut [u8], n: usize, val: u64) -> Result<()> {
if out.len() != n {
return Err(Error::OutOfRange("RISC-V set relocation slot"));
}
write_le(out, n, val);
Ok(())
}
fn set_sub6(out: &mut [u8], val: u64, sub: bool) -> Result<()> {
if out.len() != 1 {
return Err(Error::OutOfRange("RISC-V set6/sub6 relocation slot"));
}
let byte = u64::from(out[0]);
let low = if sub {
(byte & 0x3f).wrapping_sub(val) & 0x3f
} else {
val & 0x3f
};
#[allow(clippy::cast_possible_truncation)]
let merged = ((byte & 0xc0) | low) as u8;
out[0] = merged;
Ok(())
}
const fn is_hi20(r_type: u32) -> bool {
matches!(
r_type,
R_RISCV_PCREL_HI20
| R_RISCV_GOT_HI20
| R_RISCV_TLS_GD_HI20
| R_RISCV_TLS_GOT_HI20
)
}
pub fn rewrite_pcrel_pairs<R: Resolver>(
entries: &[Rela64],
section_base: u64,
resolver: &R,
) -> Result<Option<Vec<Rela64>>> {
let has_pcrel = entries.iter().any(|r| {
let t = r.r_type();
is_hi20(t)
|| t == R_RISCV_PCREL_LO12_I
|| t == R_RISCV_PCREL_LO12_S
|| t == R_RISCV_SET_ULEB128
|| t == R_RISCV_SUB_ULEB128
});
if !has_pcrel {
return Ok(None);
}
let mut out = Vec::from(entries);
let mut rewrote = fold_uleb_pairs(&mut out, resolver)?;
let mut hi20: FxHashMap<u64, (u32, i64)> = FxHashMap::default();
for r in &out {
if is_hi20(r.r_type()) {
hi20.insert(r.r_offset.get(), (r.sym(), r.r_addend.get()));
}
}
for r in &mut out {
let is_lo12 = r.r_type() == R_RISCV_PCREL_LO12_I
|| r.r_type() == R_RISCV_PCREL_LO12_S;
if !is_lo12 {
continue;
}
let sym = r.sym();
if sym == 0 {
return Err(Error::Format(
"R_RISCV_PCREL_LO12_* has no paired HI20 (null symbol)",
));
}
let sym_id = SymbolId(usize::try_from(sym).unwrap_or(0));
let hi_off = resolver
.symbol_addr(sym_id)
.wrapping_add_signed(r.r_addend.get())
.wrapping_sub(section_base);
let Some(&(hi_sym, hi_addend)) = hi20.get(&hi_off) else {
return Err(Error::Format(
"R_RISCV_PCREL_LO12_* has no paired HI20 at its label",
));
};
let adjusted = hi_addend
.wrapping_add(r.r_offset.get().cast_signed())
.wrapping_sub(hi_off.cast_signed());
r.r_info = U64::new(pack_info(hi_sym, r.r_type()));
r.r_addend = I64::new(adjusted);
rewrote = true;
}
Ok(rewrote.then_some(out))
}
const ULEB_MAX: usize = 10;
fn write_uleb_in_place(field: &mut [u8], value: u64) -> Result<()> {
let Some((last, rest)) = field.split_last_mut() else {
return Err(Error::OutOfRange("RISC-V ULEB128 field"));
};
let mut left = value;
for byte in rest {
#[allow(clippy::cast_possible_truncation)]
let seven = (left & 0x7f) as u8;
*byte = 0x80 | seven;
left >>= 7;
}
if left >= 0x80 {
return Err(Error::RelocOverflow(R_RISCV_SET_ULEB128));
}
#[allow(clippy::cast_possible_truncation)]
{
*last = left as u8;
}
Ok(())
}
fn fold_uleb_pairs<R: Resolver>(
entries: &mut [Rela64],
resolver: &R,
) -> Result<bool> {
let mut folded = false;
for i in 0..entries.len() {
let Some(set) = entries.get(i) else { break };
if set.r_type() != R_RISCV_SET_ULEB128 {
continue;
}
let at = set.r_offset.get();
let minuend = uleb_term(set, resolver);
let Some(j) = entries.iter().position(|r| {
r.r_type() == R_RISCV_SUB_ULEB128 && r.r_offset.get() == at
}) else {
return Err(Error::Format(
"R_RISCV_SET_ULEB128 without a paired R_RISCV_SUB_ULEB128",
));
};
let Some(sub) = entries.get(j) else { break };
let value = minuend.wrapping_sub(uleb_term(sub, resolver));
if let Some(slot) = entries.get_mut(i) {
slot.r_info = U64::new(pack_info(0, R_RISCV_SET_ULEB128));
slot.r_addend = I64::new(value.cast_signed());
}
if let Some(slot) = entries.get_mut(j) {
slot.r_info = U64::new(pack_info(0, R_RISCV_NONE));
slot.r_addend = I64::new(0);
}
folded = true;
}
Ok(folded)
}
fn uleb_term<R: Resolver>(r: &Rela64, resolver: &R) -> u64 {
let sym = SymbolId(usize::try_from(r.sym()).unwrap_or(0));
resolver
.symbol_addr(sym)
.wrapping_add_signed(r.r_addend.get())
}
#[allow(clippy::cast_possible_truncation)]
fn pack_info(sym: u32, r_type: u32) -> u64 {
(u64::from(sym) << 32) | u64::from(r_type)
}
fn patch32(cell: &mut [u8], keep: u32, field: u32) -> Result<()> {
let buf = cell
.get(..4)
.ok_or(Error::OutOfRange("RISC-V instruction cell"))?;
let insn = u32::from_le_bytes([buf[0], buf[1], buf[2], buf[3]]);
let patched = (insn & keep) | field;
cell[..4].copy_from_slice(&patched.to_le_bytes());
Ok(())
}