summaryrefslogtreecommitdiffstats
path: root/vendor/gimli/src/write/cfi.rs
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/gimli/src/write/cfi.rs')
-rw-r--r--vendor/gimli/src/write/cfi.rs1012
1 files changed, 1012 insertions, 0 deletions
diff --git a/vendor/gimli/src/write/cfi.rs b/vendor/gimli/src/write/cfi.rs
new file mode 100644
index 000000000..c58eb1b1d
--- /dev/null
+++ b/vendor/gimli/src/write/cfi.rs
@@ -0,0 +1,1012 @@
+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, constants::DW_EH_PE_absptr, 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)]
+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),
+}
+
+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())?;
+ }
+ }
+ 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::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;
+
+ #[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());
+
+ // 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)),
+ ];
+
+ 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 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);
+
+ 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 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);
+ }
+ }
+ }
+ }
+}