[WIP] Produce symbol file for gdb in the jit

Author: bjorn3

src/debuginfo/unwind.rs

@@ -257,17 +257,19 @@ impl UnwindContext {
     }
 
     #[cfg(all(feature = "jit", windows))]
-    pub(crate) unsafe fn register_jit(self, _jit_module: &cranelift_jit::JITModule) {}
+    pub(crate) unsafe fn register_jit(self, _jit_module: &cranelift_jit::JITModule) -> Vec<u8> {
+        vec![]
+    }
 
     #[cfg(all(feature = "jit", not(windows)))]
-    pub(crate) unsafe fn register_jit(self, jit_module: &cranelift_jit::JITModule) {
+    pub(crate) unsafe fn register_jit(self, jit_module: &cranelift_jit::JITModule) -> Vec<u8> {
         use std::mem::ManuallyDrop;
 
         let mut eh_frame = EhFrame::from(super::emit::WriterRelocate::new(self.endian));
         self.frame_table.write_eh_frame(&mut eh_frame).unwrap();
 
         if eh_frame.0.writer.slice().is_empty() {
-            return;
+            return vec![];
         }
 
         let mut eh_frame = eh_frame.0.relocate_for_jit(jit_module);
@@ -307,6 +309,8 @@ impl UnwindContext {
             // On other platforms, `__register_frame` will walk the FDEs until an entry of length 0
             unsafe { __register_frame(eh_frame.as_ptr()) };
         }
+
+        (*eh_frame).clone()
     }
 }
 

src/driver/jit.rs

@@ -213,3 +213,8 @@ fn dep_symbol_lookup_fn(
         None
     })
 }
+
+#[unsafe(no_mangle)]
+extern "C" fn print_backtrace() {
+    println!("{:#}", std::backtrace::Backtrace::force_capture());
+}

src/unwind_module.rs

@@ -35,11 +35,121 @@ impl UnwindModule<ObjectModule> {
 impl UnwindModule<cranelift_jit::JITModule> {
     pub(crate) fn finalize_definitions(mut self) -> cranelift_jit::JITModule {
         self.module.finalize_definitions().unwrap();
-        unsafe { self.unwind_context.register_jit(&self.module) };
+        let eh_frame = unsafe { self.unwind_context.register_jit(&self.module) };
+
+        let mut symbol_obj = object::write::Object::new(
+            object::BinaryFormat::Elf,
+            object::Architecture::Aarch64,
+            object::Endianness::Little,
+        );
+        let eh_frame_section = symbol_obj.add_section(
+            vec![],
+            b".eh_frame".to_vec(),
+            object::SectionKind::ReadOnlyData,
+        );
+        symbol_obj.append_section_data(eh_frame_section, &eh_frame, 1);
+
+        let mut lowest_symbol = u64::MAX;
+        let mut highest_symbol = u64::MIN;
+        for (func_id, func_decl) in self.module.declarations().get_functions() {
+            if !func_decl.linkage.is_final() {
+                continue;
+            }
+            let name = func_decl.linkage_name(func_id).into_owned().into_bytes();
+            let addr = self.module.get_finalized_function(func_id).addr() as u64;
+            if addr < lowest_symbol {
+                lowest_symbol = addr;
+            }
+            if addr + 1 > highest_symbol {
+                highest_symbol = addr + 1;
+            }
+            symbol_obj.add_symbol(object::write::Symbol {
+                name,
+                value: addr,
+                size: 1,
+                kind: object::write::SymbolKind::Text,
+                scope: object::write::SymbolScope::Dynamic,
+                weak: false,
+                section: object::write::SymbolSection::Absolute,
+                flags: object::write::SymbolFlags::None,
+            });
+        }
+
+        let mut symbol_obj = symbol_obj.write().unwrap();
+
+        convert_object_elf_to_loadable_file::<object::LittleEndian>(
+            &mut symbol_obj,
+            (lowest_symbol as *const u8, (highest_symbol - lowest_symbol) as usize),
+        );
+
+        std::fs::write("symbols.elf", symbol_obj).unwrap();
+
+        /*#[unsafe(no_mangle)]
+        static mut SYMBOL_OBJECT: *mut u8 = std::ptr::null_mut();
+        unsafe {
+            SYMBOL_OBJECT = Vec::leak(symbol_obj).as_mut_ptr();
+        }*/
+
         self.module
     }
 }
 
+#[cfg(feature = "jit")]
+fn convert_object_elf_to_loadable_file<E: object::Endian>(
+    bytes: &mut Vec<u8>,
+    code_region: (*const u8, usize),
+) {
+    use object::elf::{ET_DYN, ET_EXEC, FileHeader64, ProgramHeader64, SectionHeader64};
+    use object::read::elf::{FileHeader, SectionHeader};
+
+    let e = E::default();
+
+    let header = FileHeader64::<E>::parse(&bytes[..]).unwrap();
+    let sections = header.sections(e, &bytes[..]).unwrap();
+    let text_range = match sections.section_by_name(e, b".text") {
+        Some((i, text)) => {
+            let range = text.file_range(e);
+            let e_shoff = usize::try_from(header.e_shoff.get(e)).unwrap();
+            let off = e_shoff + i.0 * header.e_shentsize.get(e) as usize;
+
+            let section: &mut SectionHeader64<E> =
+                object::from_bytes_mut(&mut bytes[off..]).unwrap().0;
+            // Patch vaddr, and save file location and its size.
+            section.sh_addr.set(e, code_region.0 as u64);
+            range
+        }
+        None => None,
+    };
+
+    // LLDB wants segment with virtual address set, placing them at the end of ELF.
+    let ph_off = bytes.len();
+    let e_phentsize = size_of::<ProgramHeader64<E>>();
+    let mut e_phnum = 1;
+    bytes.resize(ph_off + e_phentsize * e_phnum, 0);
+    //if let Some((sh_offset, sh_size)) = text_range {
+    use object::elf::PT_LOAD;
+
+    let (v_offset, size) = code_region;
+    let program: &mut ProgramHeader64<E> = object::from_bytes_mut(&mut bytes[ph_off..]).unwrap().0;
+    program.p_type.set(e, PT_LOAD);
+    program.p_offset.set(e, /*sh_offset*/ 0);
+    program.p_vaddr.set(e, v_offset as u64);
+    program.p_paddr.set(e, v_offset as u64);
+    program.p_filesz.set(e, /*sh_size*/ 0);
+    program.p_memsz.set(e, size as u64);
+    /*} else {
+        //unreachable!();
+        e_phnum = 0;
+    }*/
+
+    // It is somewhat loadable ELF file at this moment.
+    let header: &mut FileHeader64<E> = object::from_bytes_mut(bytes).unwrap().0;
+    header.e_type.set(e, ET_EXEC);
+    header.e_phoff.set(e, ph_off as u64);
+    header.e_phentsize.set(e, u16::try_from(e_phentsize).unwrap());
+    header.e_phnum.set(e, u16::try_from(e_phnum).unwrap());
+}
+
 impl<T: Module> Module for UnwindModule<T> {
     fn isa(&self) -> &dyn TargetIsa {
         self.module.isa()