src/debuginfo/unwind.rs

   1 use crate::prelude::*;
   2
   3 use cranelift_codegen::isa::{TargetIsa, unwind::UnwindInfo};
   4
   5 use gimli::write::{Address, CieId, EhFrame, FrameTable, Section};
   6
   7 use crate::backend::WriteDebugInfo;
   8
   9 pub(crate) struct UnwindContext<'tcx> {
  10     tcx: TyCtxt<'tcx>,
  11     frame_table: FrameTable,
  12     cie_id: Option<CieId>,
  13 }
  14
  15 impl<'tcx> UnwindContext<'tcx> {
  16     pub(crate) fn new(
  17         tcx: TyCtxt<'tcx>,
  18         isa: &dyn TargetIsa,
  19     ) -> Self {
  20         let mut frame_table = FrameTable::default();
  21
  22
  23         let cie_id = if let Some(cie) = isa.create_systemv_cie() {
  24             Some(frame_table.add_cie(cie))
  25         } else {
  26             None
  27         };
  28
  29         UnwindContext {
  30             tcx,
  31             frame_table,
  32             cie_id,
  33         }
  34     }
  35
  36     pub(crate) fn add_function(&mut self, func_id: FuncId, context: &Context, isa: &dyn TargetIsa) {
  37         let unwind_info = if let Some(unwind_info) = context.create_unwind_info(isa).unwrap() {
  38             unwind_info
  39         } else {
  40             return;
  41         };
  42
  43         match unwind_info {
  44             UnwindInfo::SystemV(unwind_info) => {
  45                 self.frame_table.add_fde(self.cie_id.unwrap(), unwind_info.to_fde(Address::Symbol {
  46                     symbol: func_id.as_u32() as usize,
  47                     addend: 0,
  48                 }));
  49             },
  50             UnwindInfo::WindowsX64(_) => {
  51                 // FIXME implement this
  52             }
  53         }
  54     }
  55
  56     pub(crate) fn emit<P: WriteDebugInfo>(self, product: &mut P) {
  57         let mut eh_frame = EhFrame::from(super::emit::WriterRelocate::new(super::target_endian(self.tcx)));
  58         self.frame_table.write_eh_frame(&mut eh_frame).unwrap();
  59
  60         if !eh_frame.0.writer.slice().is_empty() {
  61             let id = eh_frame.id();
  62             let section_id = product.add_debug_section(id, eh_frame.0.writer.into_vec());
  63             let mut section_map = FxHashMap::default();
  64             section_map.insert(id, section_id);
  65
  66             for reloc in &eh_frame.0.relocs {
  67                 product.add_debug_reloc(&section_map, &section_id, reloc);
  68             }
  69         }
  70     }
  71
  72     pub(crate) unsafe fn register_jit(
  73         self,
  74         jit_module: &mut Module<cranelift_simplejit::SimpleJITBackend>,
  75     ) -> Option<UnwindRegistry> {
  76         let mut eh_frame = EhFrame::from(super::emit::WriterRelocate::new(super::target_endian(self.tcx)));
  77         self.frame_table.write_eh_frame(&mut eh_frame).unwrap();
  78
  79         if eh_frame.0.writer.slice().is_empty() {
  80             return None;
  81         }
  82
  83         let mut eh_frame = eh_frame.0.relocate_for_jit(jit_module);
  84
  85         // GCC expects a terminating "empty" length, so write a 0 length at the end of the table.
  86         eh_frame.extend(&[0, 0, 0, 0]);
  87
  88         let mut registrations = Vec::new();
  89
  90         // =======================================================================
  91         // Everything after this line up to the end of the file is loosly based on
  92         // https://github.com/bytecodealliance/wasmtime/blob/4471a82b0c540ff48960eca6757ccce5b1b5c3e4/crates/jit/src/unwind/systemv.rs
  93         cfg_if::cfg_if! {
  94             if #[cfg(target_os = "macos")] {
  95                 // On macOS, `__register_frame` takes a pointer to a single FDE
  96                 let start = eh_frame.as_ptr();
  97                 let end = start.add(eh_frame.len());
  98                 let mut current = start;
  99
 100                 // Walk all of the entries in the frame table and register them
 101                 while current < end {
 102                     let len = std::ptr::read::<u32>(current as *const u32) as usize;
 103
 104                     // Skip over the CIE
 105                     if current != start {
 106                         __register_frame(current);
 107                         registrations.push(current as usize);
 108                     }
 109
 110                     // Move to the next table entry (+4 because the length itself is not inclusive)
 111                     current = current.add(len + 4);
 112                 }
 113             } else {
 114                 // On other platforms, `__register_frame` will walk the FDEs until an entry of length 0
 115                 let ptr = eh_frame.as_ptr();
 116                 __register_frame(ptr);
 117                 registrations.push(ptr as usize);
 118             }
 119         }
 120
 121         Some(UnwindRegistry {
 122             _frame_table: eh_frame,
 123             registrations,
 124         })
 125     }
 126 }
 127
 128 /// Represents a registry of function unwind information for System V ABI.
 129 pub(crate) struct UnwindRegistry {
 130     _frame_table: Vec<u8>,
 131     registrations: Vec<usize>,
 132 }
 133
 134 extern "C" {
 135     // libunwind import
 136     fn __register_frame(fde: *const u8);
 137     fn __deregister_frame(fde: *const u8);
 138 }
 139
 140 impl Drop for UnwindRegistry {
 141     fn drop(&mut self) {
 142         unsafe {
 143             // libgcc stores the frame entries as a linked list in decreasing sort order
 144             // based on the PC value of the registered entry.
 145             //
 146             // As we store the registrations in increasing order, it would be O(N^2) to
 147             // deregister in that order.
 148             //
 149             // To ensure that we just pop off the first element in the list upon every
 150             // deregistration, walk our list of registrations backwards.
 151             for fde in self.registrations.iter().rev() {
 152                 __deregister_frame(*fde as *const _);
 153             }
 154         }
 155     }
 156 }