fix rust_eh_personality

src/libksupport/src/eh_rust.rs

@@ -17,7 +17,7 @@
 use unwind as uw;
 use libc::{c_int, uintptr_t};
 
-use dwarf::{self, EHAction, EHContext};
+use dwarf::eh::{self, EHAction, EHContext};
 
 // Register ids were lifted from LLVM's TargetLowering::getExceptionPointerRegister()
 // and TargetLowering::getExceptionSelectorRegister() for each architecture,
@@ -34,45 +34,103 @@ const UNWIND_DATA_REG: (i32, i32) = (0, 1); // RAX, RDX
 #[cfg(any(target_arch = "riscv32"))]
 const UNWIND_DATA_REG: (i32, i32) = (10, 11); // X10, X11
 
+#[cfg(any(target_arch = "arm", target_arch = "aarch64"))]
+const UNWIND_DATA_REG: (i32, i32) = (0, 1); // R0, R1 / X0, X1
+
 // The following code is based on GCC's C and C++ personality routines.  For reference, see:
 // https://github.com/gcc-mirror/gcc/blob/master/libstdc++-v3/libsupc++/eh_personality.cc
 // https://github.com/gcc-mirror/gcc/blob/trunk/libgcc/unwind-c.c
 #[lang = "eh_personality"]
 #[no_mangle]
-#[allow(unused)]
+unsafe extern "C" fn rust_eh_personality(
-unsafe extern "C" fn rust_eh_personality(version: c_int,
+    state: uw::_Unwind_State,
-                                         actions: uw::_Unwind_Action,
+    exception_object: *mut uw::_Unwind_Exception,
-                                         exception_class: uw::_Unwind_Exception_Class,
+    context: *mut uw::_Unwind_Context,
-                                         exception_object: *mut uw::_Unwind_Exception,
+) -> uw::_Unwind_Reason_Code {
-                                         context: *mut uw::_Unwind_Context)
+    let state = state as c_int;
-                                         -> uw::_Unwind_Reason_Code {
+    let action = state & uw::_US_ACTION_MASK as c_int;
-    if version != 1 {
+    let search_phase = if action == uw::_US_VIRTUAL_UNWIND_FRAME as c_int {
-        return uw::_URC_FATAL_PHASE1_ERROR;
+        // Backtraces on ARM will call the personality routine with
-    }
+        // state == _US_VIRTUAL_UNWIND_FRAME | _US_FORCE_UNWIND. In those cases
+        // we want to continue unwinding the stack, otherwise all our backtraces
+        // would end at __rust_try
+        if state & uw::_US_FORCE_UNWIND as c_int != 0 {
+            return continue_unwind(exception_object, context);
+        }
+        true
+    } else if action == uw::_US_UNWIND_FRAME_STARTING as c_int {
+        false
+    } else if action == uw::_US_UNWIND_FRAME_RESUME as c_int {
+        return continue_unwind(exception_object, context);
+    } else {
+        return uw::_URC_FAILURE;
+    };
+
+    // The DWARF unwinder assumes that _Unwind_Context holds things like the function
+    // and LSDA pointers, however ARM EHABI places them into the exception object.
+    // To preserve signatures of functions like _Unwind_GetLanguageSpecificData(), which
+    // take only the context pointer, GCC personality routines stash a pointer to
+    // exception_object in the context, using location reserved for ARM's
+    // "scratch register" (r12).
+    uw::_Unwind_SetGR(context, uw::UNWIND_POINTER_REG, exception_object as uw::_Unwind_Ptr);
+    // ...A more principled approach would be to provide the full definition of ARM's
+    // _Unwind_Context in our libunwind bindings and fetch the required data from there
+    // directly, bypassing DWARF compatibility functions.
+
     let eh_action = match find_eh_action(context) {
         Ok(action) => action,
-        Err(_) => return uw::_URC_FATAL_PHASE1_ERROR,
+        Err(_) => return uw::_URC_FAILURE,
     };
-    if actions as i32 & uw::_UA_SEARCH_PHASE as i32 != 0 {
+    if search_phase {
         match eh_action {
-            EHAction::None |
+            EHAction::None | EHAction::Cleanup(_) => {
-            EHAction::Cleanup(_) => return uw::_URC_CONTINUE_UNWIND,
+                return continue_unwind(exception_object, context);
-            EHAction::Catch(_) => return uw::_URC_HANDLER_FOUND,
+            }
-            EHAction::Terminate => return uw::_URC_FATAL_PHASE1_ERROR,
+            EHAction::Catch(_) => {
+                // EHABI requires the personality routine to update the
+                // SP value in the barrier cache of the exception object.
+                (*exception_object).private[5] =
+                    uw::_Unwind_GetGR(context, uw::UNWIND_SP_REG);
+                return uw::_URC_HANDLER_FOUND;
+            }
+            EHAction::Terminate => return uw::_URC_FAILURE,
         }
     } else {
         match eh_action {
-            EHAction::None => return uw::_URC_CONTINUE_UNWIND,
+            EHAction::None => return continue_unwind(exception_object, context),
-            EHAction::Cleanup(lpad) |
+            EHAction::Cleanup(lpad) | EHAction::Catch(lpad) => {
-            EHAction::Catch(lpad) => {
+                uw::_Unwind_SetGR(
-                uw::_Unwind_SetGR(context, UNWIND_DATA_REG.0, exception_object as uintptr_t);
+                    context,
+                    UNWIND_DATA_REG.0,
+                    exception_object as uw::_Unwind_Ptr,
+                );
                 uw::_Unwind_SetGR(context, UNWIND_DATA_REG.1, 0);
                 uw::_Unwind_SetIP(context, lpad);
                 return uw::_URC_INSTALL_CONTEXT;
             }
-            EHAction::Terminate => return uw::_URC_FATAL_PHASE2_ERROR,
+            EHAction::Terminate => return uw::_URC_FAILURE,
         }
     }
+
+    // On ARM EHABI the personality routine is responsible for actually
+    // unwinding a single stack frame before returning (ARM EHABI Sec. 6.1).
+    unsafe fn continue_unwind(
+        exception_object: *mut uw::_Unwind_Exception,
+        context: *mut uw::_Unwind_Context,
+    ) -> uw::_Unwind_Reason_Code {
+        if __gnu_unwind_frame(exception_object, context) == uw::_URC_NO_REASON {
+            uw::_URC_CONTINUE_UNWIND
+        } else {
+            uw::_URC_FAILURE
+        }
+    }
+    // defined in libgcc
+    extern "C" {
+        fn __gnu_unwind_frame(
+            exception_object: *mut uw::_Unwind_Exception,
+            context: *mut uw::_Unwind_Context,
+        ) -> uw::_Unwind_Reason_Code;
+    }
 }
 
 unsafe fn find_eh_action(context: *mut uw::_Unwind_Context) -> Result<EHAction, ()> {
@@ -87,5 +145,5 @@ unsafe fn find_eh_action(context: *mut uw::_Unwind_Context) -> Result<EHAction,
         get_text_start: &|| uw::_Unwind_GetTextRelBase(context),
         get_data_start: &|| uw::_Unwind_GetDataRelBase(context),
     };
-    dwarf::find_eh_action(lsda, &eh_context, 0)
+    dwarf::eh::find_eh_action(lsda, &eh_context, false,0)
 }

src/libksupport/src/lib.rs

@@ -1,6 +1,7 @@
 #![no_std]
 #![feature(c_variadic)]
 #![feature(const_btree_len)]
+#![feature(lang_items)]
 #![feature(generic_const_exprs)]
 #![feature(naked_functions)]
 #![feature(asm)]