Fix panic=unwind for JIT

Author: bjorn3

example/mini_core.rs

@@ -521,10 +521,27 @@ fn panic_cannot_unwind() -> ! {
 }
 
 #[lang = "eh_personality"]
-fn eh_personality() -> ! {
+// FIXME personality signature depends on target
+fn eh_personality(
+    _version: i32,
+    _actions: i32,
+    _exception_class: u64,
+    _exception_object: *mut (),
+    _context: *mut (),
+) -> i32 {
     loop {}
 }
 
+#[lang = "panic_in_cleanup"]
+fn panic_in_cleanup() -> ! {
+    loop {}
+}
+
+#[link(name = "gcc_s")]
+extern "C" {
+    fn _Unwind_Resume(exc: *mut ()) -> !;
+}
+
 #[lang = "drop_in_place"]
 #[allow(unconditional_recursion)]
 pub unsafe fn drop_in_place<T: ?Sized>(to_drop: *mut T) {

scripts/test_rustc_tests.sh

@@ -182,5 +182,5 @@ index 073116933bd..c3e4578204d 100644
 EOF
 
 echo "[TEST] rustc test suite"
-COMPILETEST_FORCE_STAGE0=1 ./x.py test --stage 0 --test-args=--no-capture tests/{codegen-units,run-make,ui,incremental}
+COMPILETEST_FORCE_STAGE0=1 ./x.py test --stage 0 tests/{codegen-units,ui,incremental}
 popd

src/compiler_builtins.rs

@@ -67,5 +67,4 @@ builtin_functions! {
     fn malloc(size: size_t) -> *mut c_void;
     fn realloc(p: *mut c_void, size: size_t) -> *mut c_void;
     fn free(p: *mut c_void) -> ();
-
 }

src/debuginfo/emit.rs

@@ -81,13 +81,32 @@ impl WriterRelocate {
     /// Perform the collected relocations to be usable for JIT usage.
     #[cfg(all(feature = "jit", not(windows)))]
     pub(super) fn relocate_for_jit(mut self, jit_module: &cranelift_jit::JITModule) -> Vec<u8> {
+        use cranelift_module::Module;
+
         for reloc in self.relocs.drain(..) {
             match reloc.name {
                 super::DebugRelocName::Section(_) => unreachable!(),
                 super::DebugRelocName::Symbol(sym) => {
-                    let addr = jit_module.get_finalized_function(
-                        cranelift_module::FuncId::from_u32(sym.try_into().unwrap()),
-                    );
+                    let addr = if sym & 1 << 31 == 0 {
+                        let func_id = FuncId::from_u32(sym.try_into().unwrap());
+                        if jit_module.declarations().get_function_decl(func_id).name.as_deref()
+                            == Some("rust_eh_personality")
+                        {
+                            extern "C" {
+                                fn rust_eh_personality() -> !;
+                            }
+                            rust_eh_personality as *const u8
+                        } else {
+                            jit_module.get_finalized_function(func_id)
+                        }
+                    } else {
+                        jit_module
+                            .get_finalized_data(DataId::from_u32(
+                                u32::try_from(sym).unwrap() & !(1 << 31),
+                            ))
+                            .0
+                    };
+
                     let val = (addr as u64 as i64 + reloc.addend) as u64;
                     self.writer.write_udata_at(reloc.offset as usize, val, reloc.size).unwrap();
                 }
@@ -196,6 +215,16 @@ impl Writer for WriterRelocate {
                     });
                     self.write_udata(0, size)
                 }
+                gimli::DW_EH_PE_absptr => {
+                    self.relocs.push(DebugReloc {
+                        offset: self.len() as u32,
+                        size: size.into(),
+                        name: DebugRelocName::Symbol(symbol),
+                        addend,
+                        kind: object::RelocationKind::Absolute,
+                    });
+                    self.write_udata(0, size.into())
+                }
                 _ => Err(gimli::write::Error::UnsupportedPointerEncoding(eh_pe)),
             },
         }

src/debuginfo/unwind.rs

@@ -29,15 +29,36 @@ impl UnwindContext {
         let mut frame_table = FrameTable::default();
 
         let cie_id = if let Some(mut cie) = module.isa().create_systemv_cie() {
-            if pic_eh_frame {
-                cie.fde_address_encoding =
-                    gimli::DwEhPe(gimli::DW_EH_PE_pcrel.0 | gimli::DW_EH_PE_sdata4.0);
-                cie.lsda_encoding =
-                    Some(gimli::DwEhPe(gimli::DW_EH_PE_pcrel.0 | gimli::DW_EH_PE_sdata4.0));
+            let ptr_encoding = if pic_eh_frame {
+                gimli::DwEhPe(gimli::DW_EH_PE_pcrel.0 | gimli::DW_EH_PE_sdata4.0)
             } else {
-                cie.fde_address_encoding = gimli::DW_EH_PE_absptr;
-                cie.lsda_encoding = Some(gimli::DW_EH_PE_absptr);
-            }
+                gimli::DW_EH_PE_absptr
+            };
+            let code_ptr_encoding = if pic_eh_frame {
+                if module.isa().triple().architecture == target_lexicon::Architecture::X86_64 {
+                    gimli::DwEhPe(
+                        gimli::DW_EH_PE_indirect.0
+                            | gimli::DW_EH_PE_pcrel.0
+                            | gimli::DW_EH_PE_sdata4.0,
+                    )
+                } else if let target_lexicon::Architecture::Aarch64(_) =
+                    module.isa().triple().architecture
+                {
+                    gimli::DwEhPe(
+                        gimli::DW_EH_PE_indirect.0
+                            | gimli::DW_EH_PE_pcrel.0
+                            | gimli::DW_EH_PE_sdata8.0,
+                    )
+                } else {
+                    todo!()
+                }
+            } else {
+                gimli::DwEhPe(gimli::DW_EH_PE_indirect.0 | gimli::DW_EH_PE_absptr.0)
+            };
+
+            cie.fde_address_encoding = ptr_encoding;
+            cie.lsda_encoding = Some(ptr_encoding);
+
             // FIXME use eh_personality lang item instead
             let personality = module
                 .declare_function(
@@ -72,26 +93,7 @@ impl UnwindContext {
 
             module.define_data(personality_ref, &personality_ref_data).unwrap();
 
-            cie.personality = Some((
-                if module.isa().triple().architecture == target_lexicon::Architecture::X86_64 {
-                    gimli::DwEhPe(
-                        gimli::DW_EH_PE_indirect.0
-                            | gimli::DW_EH_PE_pcrel.0
-                            | gimli::DW_EH_PE_sdata4.0,
-                    )
-                } else if let target_lexicon::Architecture::Aarch64(_) =
-                    module.isa().triple().architecture
-                {
-                    gimli::DwEhPe(
-                        gimli::DW_EH_PE_indirect.0
-                            | gimli::DW_EH_PE_pcrel.0
-                            | gimli::DW_EH_PE_sdata8.0,
-                    )
-                } else {
-                    todo!()
-                },
-                address_for_data(personality_ref),
-            ));
+            cie.personality = Some((code_ptr_encoding, address_for_data(personality_ref)));
             Some(frame_table.add_cie(cie))
         } else {
             None
@@ -235,10 +237,10 @@ 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(&mut self, _jit_module: &cranelift_jit::JITModule) {}
 
     #[cfg(all(feature = "jit", not(windows)))]
-    pub(crate) unsafe fn register_jit(self, jit_module: &cranelift_jit::JITModule) {
+    pub(crate) unsafe fn register_jit(&mut self, jit_module: &cranelift_jit::JITModule) {
         use std::mem::ManuallyDrop;
 
         let mut eh_frame = EhFrame::from(super::emit::WriterRelocate::new(self.endian));

src/unwind_module.rs

@@ -35,11 +35,7 @@ impl UnwindModule<ObjectModule> {
 impl UnwindModule<cranelift_jit::JITModule> {
     pub(crate) fn finalize_definitions(&mut self) {
         self.module.finalize_definitions().unwrap();
-        let prev_unwind_context = std::mem::replace(
-            &mut self.unwind_context,
-            UnwindContext::new(&mut self.module, false),
-        );
-        unsafe { prev_unwind_context.register_jit(&self.module) };
+        unsafe { self.unwind_context.register_jit(&self.module) };
     }
 }