use alloc::vec::Vec;
use indexmap::IndexSet;
use std::ops::{Deref, DerefMut};
use crate::common::{DebugFrameOffset, EhFrameOffset, Encoding, Format, Register, SectionId};
use crate::constants;
use crate::write::{Address, BaseId, Error, Expression, Result, Section, Writer};
define_section!(
DebugFrame,
DebugFrameOffset,
"A writable `.debug_frame` section."
);
define_section!(EhFrame, EhFrameOffset, "A writable `.eh_frame` section.");
define_id!(CieId, "An identifier for a CIE in a `FrameTable`.");
/// A table of frame description entries.
#[derive(Debug, Default)]
pub struct FrameTable {
/// Base id for CIEs.
base_id: BaseId,
/// The common information entries.
cies: IndexSet<CommonInformationEntry>,
/// The frame description entries.
fdes: Vec<(CieId, FrameDescriptionEntry)>,
}
impl FrameTable {
/// Add a CIE and return its id.
///
/// If the CIE already exists, then return the id of the existing CIE.
pub fn add_cie(&mut self, cie: CommonInformationEntry) -> CieId {
let (index, _) = self.cies.insert_full(cie);
CieId::new(self.base_id, index)
}
/// The number of CIEs.
pub fn cie_count(&self) -> usize {
self.cies.len()
}
/// Add a FDE.
///
/// Does not check for duplicates.
///
/// # Panics
///
/// Panics if the CIE id is invalid.
pub fn add_fde(&mut self, cie: CieId, fde: FrameDescriptionEntry) {
debug_assert_eq!(self.base_id, cie.base_id);
self.fdes.push((cie, fde));
}
/// The number of FDEs.
pub fn fde_count(&self) -> usize {
self.fdes.len()
}
/// Write the frame table entries to the given `.debug_frame` section.
pub fn write_debug_frame<W: Writer>(&self, w: &mut DebugFrame<W>) -> Result<()> {
self.write(&mut w.0, false)
}
/// Write the frame table entries to the given `.eh_frame` section.
pub fn write_eh_frame<W: Writer>(&self, w: &mut EhFrame<W>) -> Result<()> {
self.write(&mut w.0, true)
}
fn write<W: Writer>(&self, w: &mut W, eh_frame: bool) -> Result<()> {
let mut cie_offsets = vec![None; self.cies.len()];
for (cie_id, fde) in &self.fdes {
let cie_index = cie_id.index;
let cie = self.cies.get_index(cie_index).unwrap();
let cie_offset = match cie_offsets[cie_index] {
Some(offset) => offset,
None => {
// Only write CIEs as they are referenced.
let offset = cie.write(w, eh_frame)?;
cie_offsets[cie_index] = Some(offset);
offset
}
};
fde.write(w, eh_frame, cie_offset, cie)?;
}
// TODO: write length 0 terminator for eh_frame?
Ok(())
}
}
/// A common information entry. This contains information that is shared between FDEs.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct CommonInformationEntry {
encoding: Encoding,
/// A constant that is factored out of code offsets.
///
/// This should be set to the minimum instruction length.
/// Writing a code offset that is not a multiple of this factor will generate an error.
code_alignment_factor: u8,
/// A constant that is factored out of data offsets.
///
/// This should be set to the minimum data alignment for the frame.
/// Writing a data offset that is not a multiple of this factor will generate an error.
data_alignment_factor: i8,
/// The return address register. This might not correspond to an actual machine register.
return_address_register: Register,
/// The address of the personality function and its encoding.
pub personality: Option<(constants::DwEhPe, Address)>,
/// The encoding to use for the LSDA address in FDEs.
///
/// If set then all FDEs which use this CIE must have a LSDA address.
pub lsda_encoding: Option<constants::DwEhPe>,
/// The encoding to use for addresses in FDEs.
pub fde_address_encoding: constants::DwEhPe,
/// True for signal trampolines.
pub signal_trampoline: bool,
/// The initial instructions upon entry to this function.
instructions: Vec<CallFrameInstruction>,
}
impl CommonInformationEntry {
/// Create a new common information entry.
///
/// The encoding version must be a CFI version, not a DWARF version.
pub fn new(
encoding: Encoding,
code_alignment_factor: u8,
data_alignment_factor: i8,
return_address_register: Register,
) -> Self {
CommonInformationEntry {
encoding,
code_alignment_factor,
data_alignment_factor,
return_address_register,
personality: None,
lsda_encoding: None,
fde_address_encoding: constants::DW_EH_PE_absptr,
signal_trampoline: false,
instructions: Vec::new(),
}
}
/// Add an initial instruction.
pub fn add_instruction(&mut self, instruction: CallFrameInstruction) {
self.instructions.push(instruction);
}
fn has_augmentation(&self) -> bool {
self.personality.is_some()
|| self.lsda_encoding.is_some()
|| self.signal_trampoline
|| self.fde_address_encoding != constants::DW_EH_PE_absptr
}
/// Returns the section offset of the CIE.
fn write<W: Writer>(&self, w: &mut W, eh_frame: bool) -> Result<usize> {
let encoding = self.encoding;
let offset = w.len();
let length_offset = w.write_initial_length(encoding.format)?;
let length_base = w.len();
if eh_frame {
w.write_u32(0)?;
} else {
match encoding.format {
Format::Dwarf32 => w.write_u32(0xffff_ffff)?,
Format::Dwarf64 => w.write_u64(0xffff_ffff_ffff_ffff)?,
}
}
if eh_frame {
if encoding.version != 1 {
return Err(Error::UnsupportedVersion(encoding.version));
};
} else {
match encoding.version {
1 | 3 | 4 => {}
_ => return Err(Error::UnsupportedVersion(encoding.version)),
};
}
w.write_u8(encoding.version as u8)?;
let augmentation = self.has_augmentation();
if augmentation {
w.write_u8(b'z')?;
if self.lsda_encoding.is_some() {
w.write_u8(b'L')?;
}
if self.personality.is_some() {
w.write_u8(b'P')?;
}
if self.fde_address_encoding != constants::DW_EH_PE_absptr {
w.write_u8(b'R')?;
}
if self.signal_trampoline {
w.write_u8(b'S')?;
}
}
w.write_u8(0)?;
if encoding.version >= 4 {
w.write_u8(encoding.address_size)?;
// TODO: segment_selector_size
w.write_u8(0)?;
}
w.write_uleb128(self.code_alignment_factor.into())?;
w.write_sleb128(self.data_alignment_factor.into())?;
if !eh_frame && encoding.version == 1 {
let register = self.return_address_register.0 as u8;
if u16::from(register) != self.return_address_register.0 {
return Err(Error::ValueTooLarge);
}
w.write_u8(register)?;
} else {
w.write_uleb128(self.return_address_register.0.into())?;
}
if augmentation {
let augmentation_length_offset = w.len();
w.write_u8(0)?;
let augmentation_length_base = w.len();
if let Some(eh_pe) = self.lsda_encoding {
w.write_u8(eh_pe.0)?;
}
if let Some((eh_pe, address)) = self.personality {
w.write_u8(eh_pe.0)?;
w.write_eh_pointer(address, eh_pe, encoding.address_size)?;
}
if self.fde_address_encoding != constants::DW_EH_PE_absptr {
w.write_u8(self.fde_address_encoding.0)?;
}
let augmentation_length = (w.len() - augmentation_length_base) as u64;
debug_assert!(augmentation_length < 0x80);
w.write_udata_at(augmentation_length_offset, augmentation_length, 1)?;
}
for instruction in &self.instructions {
instruction.write(w, encoding, self)?;
}
write_nop(
w,
encoding.format.word_size() as usize + w.len() - length_base,
encoding.address_size,
)?;
let length = (w.len() - length_base) as u64;
w.write_initial_length_at(length_offset, length, encoding.format)?;
Ok(offset)
}
}
/// A frame description entry. There should be one FDE per function.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct FrameDescriptionEntry {
/// The initial address of the function.
address: Address,
/// The length in bytes of the function.
length: u32,
/// The address of the LSDA.
pub lsda: Option<Address>,
/// The instructions for this function, ordered by offset.
instructions: Vec<(u32, CallFrameInstruction)>,
}
impl FrameDescriptionEntry {
/// Create a new frame description entry for a function.
pub fn new(address: Address, length: u32) -> Self {
FrameDescriptionEntry {
address,
length,
lsda: None,
instructions: Vec::new(),
}
}
/// Add an instruction.
///
/// Instructions must be added in increasing order of offset, or writing will fail.
pub fn add_instruction(&mut self, offset: u32, instruction: CallFrameInstruction) {
debug_assert!(self.instructions.last().map(|x| x.0).unwrap_or(0) <= offset);
self.instructions.push((offset, instruction));
}
fn write<W: Writer>(
&self,
w: &mut W,
eh_frame: bool,
cie_offset: usize,
cie: &CommonInformationEntry,
) -> Result<()> {
let encoding = cie.encoding;
let length_offset = w.write_initial_length(encoding.format)?;
let length_base = w.len();
if eh_frame {
// .eh_frame uses a relative offset which doesn't need relocation.
w.write_udata((w.len() - cie_offset) as u64, 4)?;
} else {
w.write_offset(
cie_offset,
SectionId::DebugFrame,
encoding.format.word_size(),
)?;
}
if cie.fde_address_encoding != constants::DW_EH_PE_absptr {
w.write_eh_pointer(
self.address,
cie.fde_address_encoding,
encoding.address_size,
)?;
w.write_eh_pointer_data(
self.length.into(),
cie.fde_address_encoding.format(),
encoding.address_size,
)?;
} else {
w.write_address(self.address, encoding.address_size)?;
w.write_udata(self.length.into(), encoding.address_size)?;
}
if cie.has_augmentation() {
let mut augmentation_length = 0u64;
if self.lsda.is_some() {
augmentation_length += u64::from(encoding.address_size);
}
w.write_uleb128(augmentation_length)?;
debug_assert_eq!(self.lsda.is_some(), cie.lsda_encoding.is_some());
if let (Some(lsda), Some(lsda_encoding)) = (self.lsda, cie.lsda_encoding) {
w.write_eh_pointer(lsda, lsda_encoding, encoding.address_size)?;
}
}
let mut prev_offset = 0;
for (offset, instruction) in &self.instructions {
write_advance_loc(w, cie.code_alignment_factor, prev_offset, *offset)?;
prev_offset = *offset;
instruction.write(w, encoding, cie)?;
}
write_nop(
w,
encoding.format.word_size() as usize + w.len() - length_base,
encoding.address_size,
)?;
let length = (w.len() - length_base) as u64;
w.write_initial_length_at(length_offset, length, encoding.format)?;
Ok(())
}
}
/// An instruction in a frame description entry.
///
/// This may be a CFA definition, a register rule, or some other directive.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum CallFrameInstruction {
/// Define the CFA rule to use the provided register and offset.
Cfa(Register, i32),
/// Update the CFA rule to use the provided register. The offset is unchanged.
CfaRegister(Register),
/// Update the CFA rule to use the provided offset. The register is unchanged.
CfaOffset(i32),
/// Define the CFA rule to use the provided expression.
CfaExpression(Expression),
/// Restore the initial rule for the register.
Restore(Register),
/// The previous value of the register is not recoverable.
Undefined(Register),
/// The register has not been modified.
SameValue(Register),
/// The previous value of the register is saved at address CFA + offset.
Offset(Register, i32),
/// The previous value of the register is CFA + offset.
ValOffset(Register, i32),
/// The previous value of the register is stored in another register.
Register(Register, Register),
/// The previous value of the register is saved at address given by the expression.
Expression(Register, Expression),
/// The previous value of the register is given by the expression.
ValExpression(Register, Expression),
/// Push all register rules onto a stack.
RememberState,
/// Pop all register rules off the stack.
RestoreState,
/// The size of the arguments that have been pushed onto the stack.
ArgsSize(u32),
/// AAarch64 extension: negate the `RA_SIGN_STATE` pseudo-register.
NegateRaState,
}
impl CallFrameInstruction {
fn write<W: Writer>(
&self,
w: &mut W,
encoding: Encoding,
cie: &CommonInformationEntry,
) -> Result<()> {
match *self {
CallFrameInstruction::Cfa(register, offset) => {
if offset < 0 {
let offset = factored_data_offset(offset, cie.data_alignment_factor)?;
w.write_u8(constants::DW_CFA_def_cfa_sf.0)?;
w.write_uleb128(register.0.into())?;
w.write_sleb128(offset.into())?;
} else {
// Unfactored offset.
w.write_u8(constants::DW_CFA_def_cfa.0)?;
w.write_uleb128(register.0.into())?;
w.write_uleb128(offset as u64)?;
}
}
CallFrameInstruction::CfaRegister(register) => {
w.write_u8(constants::DW_CFA_def_cfa_register.0)?;
w.write_uleb128(register.0.into())?;
}
CallFrameInstruction::CfaOffset(offset) => {
if offset < 0 {
let offset = factored_data_offset(offset, cie.data_alignment_factor)?;
w.write_u8(constants::DW_CFA_def_cfa_offset_sf.0)?;
w.write_sleb128(offset.into())?;
} else {
// Unfactored offset.
w.write_u8(constants::DW_CFA_def_cfa_offset.0)?;
w.write_uleb128(offset as u64)?;
}
}
CallFrameInstruction::CfaExpression(ref expression) => {
w.write_u8(constants::DW_CFA_def_cfa_expression.0)?;
w.write_uleb128(expression.size(encoding, None) as u64)?;
expression.write(w, None, encoding, None)?;
}
CallFrameInstruction::Restore(register) => {
if register.0 < 0x40 {
w.write_u8(constants::DW_CFA_restore.0 | register.0 as u8)?;
} else {
w.write_u8(constants::DW_CFA_restore_extended.0)?;
w.write_uleb128(register.0.into())?;
}
}
CallFrameInstruction::Undefined(register) => {
w.write_u8(constants::DW_CFA_undefined.0)?;
w.write_uleb128(register.0.into())?;
}
CallFrameInstruction::SameValue(register) => {
w.write_u8(constants::DW_CFA_same_value.0)?;
w.write_uleb128(register.0.into())?;
}
CallFrameInstruction::Offset(register, offset) => {
let offset = factored_data_offset(offset, cie.data_alignment_factor)?;
if offset < 0 {
w.write_u8(constants::DW_CFA_offset_extended_sf.0)?;
w.write_uleb128(register.0.into())?;
w.write_sleb128(offset.into())?;
} else if register.0 < 0x40 {
w.write_u8(constants::DW_CFA_offset.0 | register.0 as u8)?;
w.write_uleb128(offset as u64)?;
} else {
w.write_u8(constants::DW_CFA_offset_extended.0)?;
w.write_uleb128(register.0.into())?;
w.write_uleb128(offset as u64)?;
}
}
CallFrameInstruction::ValOffset(register, offset) => {
let offset = factored_data_offset(offset, cie.data_alignment_factor)?;
if offset < 0 {
w.write_u8(constants::DW_CFA_val_offset_sf.0)?;
w.write_uleb128(register.0.into())?;
w.write_sleb128(offset.into())?;
} else {
w.write_u8(constants::DW_CFA_val_offset.0)?;
w.write_uleb128(register.0.into())?;
w.write_uleb128(offset as u64)?;
}
}
CallFrameInstruction::Register(register1, register2) => {
w.write_u8(constants::DW_CFA_register.0)?;
w.write_uleb128(register1.0.into())?;
w.write_uleb128(register2.0.into())?;
}
CallFrameInstruction::Expression(register, ref expression) => {
w.write_u8(constants::DW_CFA_expression.0)?;
w.write_uleb128(register.0.into())?;
w.write_uleb128(expression.size(encoding, None) as u64)?;
expression.write(w, None, encoding, None)?;
}
CallFrameInstruction::ValExpression(register, ref expression) => {
w.write_u8(constants::DW_CFA_val_expression.0)?;
w.write_uleb128(register.0.into())?;
w.write_uleb128(expression.size(encoding, None) as u64)?;
expression.write(w, None, encoding, None)?;
}
CallFrameInstruction::RememberState => {
w.write_u8(constants::DW_CFA_remember_state.0)?;
}
CallFrameInstruction::RestoreState => {
w.write_u8(constants::DW_CFA_restore_state.0)?;
}
CallFrameInstruction::ArgsSize(size) => {
w.write_u8(constants::DW_CFA_GNU_args_size.0)?;
w.write_uleb128(size.into())?;
}
CallFrameInstruction::NegateRaState => {
w.write_u8(constants::DW_CFA_AARCH64_negate_ra_state.0)?;
}
}
Ok(())
}
}
fn write_advance_loc<W: Writer>(
w: &mut W,
code_alignment_factor: u8,
prev_offset: u32,
offset: u32,
) -> Result<()> {
if offset == prev_offset {
return Ok(());
}
let delta = factored_code_delta(prev_offset, offset, code_alignment_factor)?;
if delta < 0x40 {
w.write_u8(constants::DW_CFA_advance_loc.0 | delta as u8)?;
} else if delta < 0x100 {
w.write_u8(constants::DW_CFA_advance_loc1.0)?;
w.write_u8(delta as u8)?;
} else if delta < 0x10000 {
w.write_u8(constants::DW_CFA_advance_loc2.0)?;
w.write_u16(delta as u16)?;
} else {
w.write_u8(constants::DW_CFA_advance_loc4.0)?;
w.write_u32(delta)?;
}
Ok(())
}
fn write_nop<W: Writer>(w: &mut W, len: usize, align: u8) -> Result<()> {
debug_assert_eq!(align & (align - 1), 0);
let tail_len = (!len + 1) & (align as usize - 1);
for _ in 0..tail_len {
w.write_u8(constants::DW_CFA_nop.0)?;
}
Ok(())
}
fn factored_code_delta(prev_offset: u32, offset: u32, factor: u8) -> Result<u32> {
if offset < prev_offset {
return Err(Error::InvalidFrameCodeOffset(offset));
}
let delta = offset - prev_offset;
let factor = u32::from(factor);
let factored_delta = delta / factor;
if delta != factored_delta * factor {
return Err(Error::InvalidFrameCodeOffset(offset));
}
Ok(factored_delta)
}
fn factored_data_offset(offset: i32, factor: i8) -> Result<i32> {
let factor = i32::from(factor);
let factored_offset = offset / factor;
if offset != factored_offset * factor {
return Err(Error::InvalidFrameDataOffset(offset));
}
Ok(factored_offset)
}
#[cfg(feature = "read")]
pub(crate) mod convert {
use super::*;
use crate::read::{self, Reader};
use crate::write::{ConvertError, ConvertResult};
use std::collections::{hash_map, HashMap};
impl FrameTable {
/// Create a frame table by reading the data in the given section.
///
/// `convert_address` is a function to convert read addresses into the `Address`
/// type. For non-relocatable addresses, this function may simply return
/// `Address::Constant(address)`. For relocatable addresses, it is the caller's
/// responsibility to determine the symbol and addend corresponding to the address
/// and return `Address::Symbol { symbol, addend }`.
pub fn from<R, Section>(
frame: &Section,
convert_address: &dyn Fn(u64) -> Option<Address>,
) -> ConvertResult<FrameTable>
where
R: Reader<Offset = usize>,
Section: read::UnwindSection<R>,
Section::Offset: read::UnwindOffset<usize>,
{
let bases = read::BaseAddresses::default().set_eh_frame(0);
let mut frame_table = FrameTable::default();
let mut cie_ids = HashMap::new();
let mut entries = frame.entries(&bases);
while let Some(entry) = entries.next()? {
let partial = match entry {
read::CieOrFde::Cie(_) => continue,
read::CieOrFde::Fde(partial) => partial,
};
// TODO: is it worth caching the parsed CIEs? It would be better if FDEs only
// stored a reference.
let from_fde = partial.parse(Section::cie_from_offset)?;
let from_cie = from_fde.cie();
let cie_id = match cie_ids.entry(from_cie.offset()) {
hash_map::Entry::Occupied(o) => *o.get(),
hash_map::Entry::Vacant(e) => {
let cie =
CommonInformationEntry::from(from_cie, frame, &bases, convert_address)?;
let cie_id = frame_table.add_cie(cie);
e.insert(cie_id);
cie_id
}
};
let fde = FrameDescriptionEntry::from(&from_fde, frame, &bases, convert_address)?;
frame_table.add_fde(cie_id, fde);
}
Ok(frame_table)
}
}
impl CommonInformationEntry {
fn from<R, Section>(
from_cie: &read::CommonInformationEntry<R>,
frame: &Section,
bases: &read::BaseAddresses,
convert_address: &dyn Fn(u64) -> Option<Address>,
) -> ConvertResult<CommonInformationEntry>
where
R: Reader<Offset = usize>,
Section: read::UnwindSection<R>,
Section::Offset: read::UnwindOffset<usize>,
{
let mut cie = CommonInformationEntry::new(
from_cie.encoding(),
from_cie.code_alignment_factor() as u8,
from_cie.data_alignment_factor() as i8,
from_cie.return_address_register(),
);
cie.personality = match from_cie.personality_with_encoding() {
// We treat these the same because the encoding already determines
// whether it is indirect.
Some((eh_pe, read::Pointer::Direct(p)))
| Some((eh_pe, read::Pointer::Indirect(p))) => {
let address = convert_address(p).ok_or(ConvertError::InvalidAddress)?;
Some((eh_pe, address))
}
_ => None,
};
cie.lsda_encoding = from_cie.lsda_encoding();
cie.fde_address_encoding = from_cie
.fde_address_encoding()
.unwrap_or(constants::DW_EH_PE_absptr);
cie.signal_trampoline = from_cie.is_signal_trampoline();
let mut offset = 0;
let mut from_instructions = from_cie.instructions(frame, bases);
while let Some(from_instruction) = from_instructions.next()? {
if let Some(instruction) = CallFrameInstruction::from(
from_instruction,
from_cie,
convert_address,
&mut offset,
)? {
cie.instructions.push(instruction);
}
}
Ok(cie)
}
}
impl FrameDescriptionEntry {
fn from<R, Section>(
from_fde: &read::FrameDescriptionEntry<R>,
frame: &Section,
bases: &read::BaseAddresses,
convert_address: &dyn Fn(u64) -> Option<Address>,
) -> ConvertResult<FrameDescriptionEntry>
where
R: Reader<Offset = usize>,
Section: read::UnwindSection<R>,
Section::Offset: read::UnwindOffset<usize>,
{
let address =
convert_address(from_fde.initial_address()).ok_or(ConvertError::InvalidAddress)?;
let length = from_fde.len() as u32;
let mut fde = FrameDescriptionEntry::new(address, length);
match from_fde.lsda() {
// We treat these the same because the encoding already determines
// whether it is indirect.
Some(read::Pointer::Direct(p)) | Some(read::Pointer::Indirect(p)) => {
let address = convert_address(p).ok_or(ConvertError::InvalidAddress)?;
fde.lsda = Some(address);
}
None => {}
}
let from_cie = from_fde.cie();
let mut offset = 0;
let mut from_instructions = from_fde.instructions(frame, bases);
while let Some(from_instruction) = from_instructions.next()? {
if let Some(instruction) = CallFrameInstruction::from(
from_instruction,
from_cie,
convert_address,
&mut offset,
)? {
fde.instructions.push((offset, instruction));
}
}
Ok(fde)
}
}
impl CallFrameInstruction {
fn from<R: Reader<Offset = usize>>(
from_instruction: read::CallFrameInstruction<R>,
from_cie: &read::CommonInformationEntry<R>,
convert_address: &dyn Fn(u64) -> Option<Address>,
offset: &mut u32,
) -> ConvertResult<Option<CallFrameInstruction>> {
let convert_expression =
|x| Expression::from(x, from_cie.encoding(), None, None, None, convert_address);
// TODO: validate integer type conversions
Ok(Some(match from_instruction {
read::CallFrameInstruction::SetLoc { .. } => {
return Err(ConvertError::UnsupportedCfiInstruction);
}
read::CallFrameInstruction::AdvanceLoc { delta } => {
*offset += delta * from_cie.code_alignment_factor() as u32;
return Ok(None);
}
read::CallFrameInstruction::DefCfa { register, offset } => {
CallFrameInstruction::Cfa(register, offset as i32)
}
read::CallFrameInstruction::DefCfaSf {
register,
factored_offset,
} => {
let offset = factored_offset * from_cie.data_alignment_factor();
CallFrameInstruction::Cfa(register, offset as i32)
}
read::CallFrameInstruction::DefCfaRegister { register } => {
CallFrameInstruction::CfaRegister(register)
}
read::CallFrameInstruction::DefCfaOffset { offset } => {
CallFrameInstruction::CfaOffset(offset as i32)
}
read::CallFrameInstruction::DefCfaOffsetSf { factored_offset } => {
let offset = factored_offset * from_cie.data_alignment_factor();
CallFrameInstruction::CfaOffset(offset as i32)
}
read::CallFrameInstruction::DefCfaExpression { expression } => {
CallFrameInstruction::CfaExpression(convert_expression(expression)?)
}
read::CallFrameInstruction::Undefined { register } => {
CallFrameInstruction::Undefined(register)
}
read::CallFrameInstruction::SameValue { register } => {
CallFrameInstruction::SameValue(register)
}
read::CallFrameInstruction::Offset {
register,
factored_offset,
} => {
let offset = factored_offset as i64 * from_cie.data_alignment_factor();
CallFrameInstruction::Offset(register, offset as i32)
}
read::CallFrameInstruction::OffsetExtendedSf {
register,
factored_offset,
} => {
let offset = factored_offset * from_cie.data_alignment_factor();
CallFrameInstruction::Offset(register, offset as i32)
}
read::CallFrameInstruction::ValOffset {
register,
factored_offset,
} => {
let offset = factored_offset as i64 * from_cie.data_alignment_factor();
CallFrameInstruction::ValOffset(register, offset as i32)
}
read::CallFrameInstruction::ValOffsetSf {
register,
factored_offset,
} => {
let offset = factored_offset * from_cie.data_alignment_factor();
CallFrameInstruction::ValOffset(register, offset as i32)
}
read::CallFrameInstruction::Register {
dest_register,
src_register,
} => CallFrameInstruction::Register(dest_register, src_register),
read::CallFrameInstruction::Expression {
register,
expression,
} => CallFrameInstruction::Expression(register, convert_expression(expression)?),
read::CallFrameInstruction::ValExpression {
register,
expression,
} => CallFrameInstruction::ValExpression(register, convert_expression(expression)?),
read::CallFrameInstruction::Restore { register } => {
CallFrameInstruction::Restore(register)
}
read::CallFrameInstruction::RememberState => CallFrameInstruction::RememberState,
read::CallFrameInstruction::RestoreState => CallFrameInstruction::RestoreState,
read::CallFrameInstruction::ArgsSize { size } => {
CallFrameInstruction::ArgsSize(size as u32)
}
read::CallFrameInstruction::NegateRaState => CallFrameInstruction::NegateRaState,
read::CallFrameInstruction::Nop => return Ok(None),
}))
}
}
}
#[cfg(test)]
#[cfg(feature = "read")]
mod tests {
use super::*;
use crate::arch::X86_64;
use crate::read;
use crate::write::EndianVec;
use crate::{LittleEndian, Vendor};
#[test]
fn test_frame_table() {
for &version in &[1, 3, 4] {
for &address_size in &[4, 8] {
for &format in &[Format::Dwarf32, Format::Dwarf64] {
let encoding = Encoding {
format,
version,
address_size,
};
let mut frames = FrameTable::default();
let cie1 = CommonInformationEntry::new(encoding, 1, 8, X86_64::RA);
let cie1_id = frames.add_cie(cie1.clone());
assert_eq!(cie1_id, frames.add_cie(cie1.clone()));
let mut cie2 = CommonInformationEntry::new(encoding, 1, 8, X86_64::RA);
cie2.lsda_encoding = Some(constants::DW_EH_PE_absptr);
cie2.personality =
Some((constants::DW_EH_PE_absptr, Address::Constant(0x1234)));
cie2.signal_trampoline = true;
let cie2_id = frames.add_cie(cie2.clone());
assert_ne!(cie1_id, cie2_id);
assert_eq!(cie2_id, frames.add_cie(cie2.clone()));
let fde1 = FrameDescriptionEntry::new(Address::Constant(0x1000), 0x10);
frames.add_fde(cie1_id, fde1.clone());
let fde2 = FrameDescriptionEntry::new(Address::Constant(0x2000), 0x20);
frames.add_fde(cie1_id, fde2.clone());
let mut fde3 = FrameDescriptionEntry::new(Address::Constant(0x3000), 0x30);
fde3.lsda = Some(Address::Constant(0x3300));
frames.add_fde(cie2_id, fde3.clone());
let mut fde4 = FrameDescriptionEntry::new(Address::Constant(0x4000), 0x40);
fde4.lsda = Some(Address::Constant(0x4400));
frames.add_fde(cie2_id, fde4.clone());
let mut cie3 = CommonInformationEntry::new(encoding, 1, 8, X86_64::RA);
cie3.fde_address_encoding = constants::DW_EH_PE_pcrel;
cie3.lsda_encoding = Some(constants::DW_EH_PE_pcrel);
cie3.personality = Some((constants::DW_EH_PE_pcrel, Address::Constant(0x1235)));
cie3.signal_trampoline = true;
let cie3_id = frames.add_cie(cie3.clone());
assert_ne!(cie2_id, cie3_id);
assert_eq!(cie3_id, frames.add_cie(cie3.clone()));
let mut fde5 = FrameDescriptionEntry::new(Address::Constant(0x5000), 0x50);
fde5.lsda = Some(Address::Constant(0x5500));
frames.add_fde(cie3_id, fde5.clone());
// Test writing `.debug_frame`.
let mut debug_frame = DebugFrame::from(EndianVec::new(LittleEndian));
frames.write_debug_frame(&mut debug_frame).unwrap();
let mut read_debug_frame =
read::DebugFrame::new(debug_frame.slice(), LittleEndian);
read_debug_frame.set_address_size(address_size);
let convert_frames = FrameTable::from(&read_debug_frame, &|address| {
Some(Address::Constant(address))
})
.unwrap();
assert_eq!(frames.cies, convert_frames.cies);
assert_eq!(frames.fdes.len(), convert_frames.fdes.len());
for (a, b) in frames.fdes.iter().zip(convert_frames.fdes.iter()) {
assert_eq!(a.1, b.1);
}
if version == 1 {
// Test writing `.eh_frame`.
let mut eh_frame = EhFrame::from(EndianVec::new(LittleEndian));
frames.write_eh_frame(&mut eh_frame).unwrap();
let mut read_eh_frame = read::EhFrame::new(eh_frame.slice(), LittleEndian);
read_eh_frame.set_address_size(address_size);
let convert_frames = FrameTable::from(&read_eh_frame, &|address| {
Some(Address::Constant(address))
})
.unwrap();
assert_eq!(frames.cies, convert_frames.cies);
assert_eq!(frames.fdes.len(), convert_frames.fdes.len());
for (a, b) in frames.fdes.iter().zip(convert_frames.fdes.iter()) {
assert_eq!(a.1, b.1);
}
}
}
}
}
}
#[test]
fn test_frame_instruction() {
let mut expression = Expression::new();
expression.op_constu(0);
let cie_instructions = [
CallFrameInstruction::Cfa(X86_64::RSP, 8),
CallFrameInstruction::Offset(X86_64::RA, -8),
];
let fde_instructions = [
(0, CallFrameInstruction::Cfa(X86_64::RSP, 0)),
(0, CallFrameInstruction::Cfa(X86_64::RSP, -8)),
(2, CallFrameInstruction::CfaRegister(X86_64::RBP)),
(4, CallFrameInstruction::CfaOffset(8)),
(4, CallFrameInstruction::CfaOffset(0)),
(4, CallFrameInstruction::CfaOffset(-8)),
(6, CallFrameInstruction::CfaExpression(expression.clone())),
(8, CallFrameInstruction::Restore(Register(1))),
(8, CallFrameInstruction::Restore(Register(101))),
(10, CallFrameInstruction::Undefined(Register(2))),
(12, CallFrameInstruction::SameValue(Register(3))),
(14, CallFrameInstruction::Offset(Register(4), 16)),
(14, CallFrameInstruction::Offset(Register(104), 16)),
(16, CallFrameInstruction::ValOffset(Register(5), -24)),
(16, CallFrameInstruction::ValOffset(Register(5), 24)),
(18, CallFrameInstruction::Register(Register(6), Register(7))),
(
20,
CallFrameInstruction::Expression(Register(8), expression.clone()),
),
(
22,
CallFrameInstruction::ValExpression(Register(9), expression.clone()),
),
(24 + 0x80, CallFrameInstruction::RememberState),
(26 + 0x280, CallFrameInstruction::RestoreState),
(28 + 0x20280, CallFrameInstruction::ArgsSize(23)),
];
let fde_instructions_aarch64 = [(0, CallFrameInstruction::NegateRaState)];
for &version in &[1, 3, 4] {
for &address_size in &[4, 8] {
for &vendor in &[Vendor::Default, Vendor::AArch64] {
for &format in &[Format::Dwarf32, Format::Dwarf64] {
let encoding = Encoding {
format,
version,
address_size,
};
let mut frames = FrameTable::default();
let mut cie = CommonInformationEntry::new(encoding, 2, 8, X86_64::RA);
for i in &cie_instructions {
cie.add_instruction(i.clone());
}
let cie_id = frames.add_cie(cie);
let mut fde = FrameDescriptionEntry::new(Address::Constant(0x1000), 0x10);
for (o, i) in &fde_instructions {
fde.add_instruction(*o, i.clone());
}
frames.add_fde(cie_id, fde);
if vendor == Vendor::AArch64 {
let mut fde =
FrameDescriptionEntry::new(Address::Constant(0x2000), 0x10);
for (o, i) in &fde_instructions_aarch64 {
fde.add_instruction(*o, i.clone());
}
frames.add_fde(cie_id, fde);
}
let mut debug_frame = DebugFrame::from(EndianVec::new(LittleEndian));
frames.write_debug_frame(&mut debug_frame).unwrap();
let mut read_debug_frame =
read::DebugFrame::new(debug_frame.slice(), LittleEndian);
read_debug_frame.set_address_size(address_size);
read_debug_frame.set_vendor(vendor);
let frames = FrameTable::from(&read_debug_frame, &|address| {
Some(Address::Constant(address))
})
.unwrap();
assert_eq!(
&frames.cies.get_index(0).unwrap().instructions,
&cie_instructions
);
assert_eq!(&frames.fdes[0].1.instructions, &fde_instructions);
if vendor == Vendor::AArch64 {
assert_eq!(&frames.fdes[1].1.instructions, &fde_instructions_aarch64);
}
}
}
}
}
}
}