Move personality functions to std

These were previously in the panic_unwind crate with dummy stubs in the
panic_abort crate. However it turns out that this is insufficient: we
still need a proper personality function even with -C panic=abort to
handle the following cases:

1) `extern "C-unwind"` still needs to catch foreign exceptions with -C
panic=abort to turn them into aborts. This requires landing pads and a
personality function.

2) ARM EHABI uses the personality function when creating backtraces.
The dummy personality function in panic_abort was causing backtrace
generation to get stuck in a loop since the personality function is
responsible for advancing the unwind state to the next frame.

library/panic_abort/src/lib.rs

@@ -113,26 +113,6 @@ pub unsafe fn __rust_start_panic(_payload: *mut &mut dyn BoxMeUp) -> u32 {
 // binaries, but it should never be called as we don't link in an unwinding
 // runtime at all.
 pub mod personalities {
-    #[rustc_std_internal_symbol]
-    #[cfg(not(any(
-        all(target_family = "wasm", not(target_os = "emscripten")),
-        all(target_os = "windows", target_env = "gnu", target_arch = "x86_64",),
-    )))]
-    pub extern "C" fn rust_eh_personality() {}
-
-    // On x86_64-pc-windows-gnu we use our own personality function that needs
-    // to return `ExceptionContinueSearch` as we're passing on all our frames.
-    #[rustc_std_internal_symbol]
-    #[cfg(all(target_os = "windows", target_env = "gnu", target_arch = "x86_64"))]
-    pub extern "C" fn rust_eh_personality(
-        _record: usize,
-        _frame: usize,
-        _context: usize,
-        _dispatcher: usize,
-    ) -> u32 {
-        1 // `ExceptionContinueSearch`
-    }
-
     // Similar to above, this corresponds to the `eh_catch_typeinfo` lang item
     // that's only used on Emscripten currently.
     //

library/panic_unwind/src/emcc.rs

@@ -12,7 +12,6 @@ use core::intrinsics;
 use core::mem;
 use core::ptr;
 use core::sync::atomic::{AtomicBool, Ordering};
-use libc::{self, c_int};
 use unwind as uw;
 
 // This matches the layout of std::type_info in C++
@@ -105,21 +104,6 @@ extern "C" fn exception_cleanup(ptr: *mut libc::c_void) -> *mut libc::c_void {
     }
 }
 
-// This is required by the compiler to exist (e.g., it's a lang item), but it's
-// never actually called by the compiler.  Emscripten EH doesn't use a
-// personality function at all, it instead uses __cxa_find_matching_catch.
-// Wasm error handling would use __gxx_personality_wasm0.
-#[lang = "eh_personality"]
-unsafe extern "C" fn rust_eh_personality(
-    _version: c_int,
-    _actions: uw::_Unwind_Action,
-    _exception_class: uw::_Unwind_Exception_Class,
-    _exception_object: *mut uw::_Unwind_Exception,
-    _context: *mut uw::_Unwind_Context,
-) -> uw::_Unwind_Reason_Code {
-    core::intrinsics::abort()
-}
-
 extern "C" {
     fn __cxa_allocate_exception(thrown_size: libc::size_t) -> *mut libc::c_void;
     fn __cxa_begin_catch(thrown_exception: *mut libc::c_void) -> *mut libc::c_void;

library/panic_unwind/src/gcc.rs

@@ -39,8 +39,6 @@
 use alloc::boxed::Box;
 use core::any::Any;
 
-use crate::dwarf::eh::{self, EHAction, EHContext};
-use libc::{c_int, uintptr_t};
 use unwind as uw;
 
 #[repr(C)]
@@ -90,232 +88,6 @@ fn rust_exception_class() -> uw::_Unwind_Exception_Class {
     0x4d4f5a_00_52555354
 }
 
-// Register ids were lifted from LLVM's TargetLowering::getExceptionPointerRegister()
-// and TargetLowering::getExceptionSelectorRegister() for each architecture,
-// then mapped to DWARF register numbers via register definition tables
-// (typically <arch>RegisterInfo.td, search for "DwarfRegNum").
-// See also https://llvm.org/docs/WritingAnLLVMBackend.html#defining-a-register.
-
-#[cfg(target_arch = "x86")]
-const UNWIND_DATA_REG: (i32, i32) = (0, 2); // EAX, EDX
-
-#[cfg(target_arch = "x86_64")]
-const UNWIND_DATA_REG: (i32, i32) = (0, 1); // RAX, RDX
-
-#[cfg(any(target_arch = "arm", target_arch = "aarch64"))]
-const UNWIND_DATA_REG: (i32, i32) = (0, 1); // R0, R1 / X0, X1
-
-#[cfg(target_arch = "m68k")]
-const UNWIND_DATA_REG: (i32, i32) = (0, 1); // D0, D1
-
-#[cfg(any(target_arch = "mips", target_arch = "mips64"))]
-const UNWIND_DATA_REG: (i32, i32) = (4, 5); // A0, A1
-
-#[cfg(any(target_arch = "powerpc", target_arch = "powerpc64"))]
-const UNWIND_DATA_REG: (i32, i32) = (3, 4); // R3, R4 / X3, X4
-
-#[cfg(target_arch = "s390x")]
-const UNWIND_DATA_REG: (i32, i32) = (6, 7); // R6, R7
-
-#[cfg(any(target_arch = "sparc", target_arch = "sparc64"))]
-const UNWIND_DATA_REG: (i32, i32) = (24, 25); // I0, I1
-
-#[cfg(target_arch = "hexagon")]
-const UNWIND_DATA_REG: (i32, i32) = (0, 1); // R0, R1
-
-#[cfg(any(target_arch = "riscv64", target_arch = "riscv32"))]
-const UNWIND_DATA_REG: (i32, i32) = (10, 11); // x10, x11
-
-// 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
-
-cfg_if::cfg_if! {
-    if #[cfg(all(target_arch = "arm", not(target_os = "ios"), not(target_os = "watchos"), not(target_os = "netbsd")))] {
-        // ARM EHABI personality routine.
-        // https://infocenter.arm.com/help/topic/com.arm.doc.ihi0038b/IHI0038B_ehabi.pdf
-        //
-        // iOS uses the default routine instead since it uses SjLj unwinding.
-        #[lang = "eh_personality"]
-        unsafe extern "C" fn rust_eh_personality(state: uw::_Unwind_State,
-                                                 exception_object: *mut uw::_Unwind_Exception,
-                                                 context: *mut uw::_Unwind_Context)
-                                                 -> uw::_Unwind_Reason_Code {
-            let state = state as c_int;
-            let action = state & uw::_US_ACTION_MASK as c_int;
-            let search_phase = if action == uw::_US_VIRTUAL_UNWIND_FRAME as c_int {
-                // 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_FAILURE,
-            };
-            if search_phase {
-                match eh_action {
-                    EHAction::None |
-                    EHAction::Cleanup(_) => return continue_unwind(exception_object, context),
-                    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 continue_unwind(exception_object, context),
-                    EHAction::Cleanup(lpad) |
-                    EHAction::Catch(lpad) => {
-                        uw::_Unwind_SetGR(context, UNWIND_DATA_REG.0,
-                                          exception_object as uintptr_t);
-                        uw::_Unwind_SetGR(context, UNWIND_DATA_REG.1, 0);
-                        uw::_Unwind_SetIP(context, lpad);
-                        return uw::_URC_INSTALL_CONTEXT;
-                    }
-                    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;
-            }
-        }
-    } else {
-        // Default personality routine, which is used directly on most targets
-        // and indirectly on Windows x86_64 via SEH.
-        unsafe extern "C" fn rust_eh_personality_impl(version: c_int,
-                                                      actions: uw::_Unwind_Action,
-                                                      _exception_class: uw::_Unwind_Exception_Class,
-                                                      exception_object: *mut uw::_Unwind_Exception,
-                                                      context: *mut uw::_Unwind_Context)
-                                                      -> uw::_Unwind_Reason_Code {
-            if version != 1 {
-                return uw::_URC_FATAL_PHASE1_ERROR;
-            }
-            let eh_action = match find_eh_action(context) {
-                Ok(action) => action,
-                Err(_) => return uw::_URC_FATAL_PHASE1_ERROR,
-            };
-            if actions as i32 & uw::_UA_SEARCH_PHASE as i32 != 0 {
-                match eh_action {
-                    EHAction::None |
-                    EHAction::Cleanup(_) => uw::_URC_CONTINUE_UNWIND,
-                    EHAction::Catch(_) => uw::_URC_HANDLER_FOUND,
-                    EHAction::Terminate => uw::_URC_FATAL_PHASE1_ERROR,
-                }
-            } else {
-                match eh_action {
-                    EHAction::None => uw::_URC_CONTINUE_UNWIND,
-                    EHAction::Cleanup(lpad) |
-                    EHAction::Catch(lpad) => {
-                        uw::_Unwind_SetGR(context, UNWIND_DATA_REG.0,
-                            exception_object as uintptr_t);
-                        uw::_Unwind_SetGR(context, UNWIND_DATA_REG.1, 0);
-                        uw::_Unwind_SetIP(context, lpad);
-                        uw::_URC_INSTALL_CONTEXT
-                    }
-                    EHAction::Terminate => uw::_URC_FATAL_PHASE2_ERROR,
-                }
-            }
-        }
-
-        cfg_if::cfg_if! {
-            if #[cfg(all(windows, target_arch = "x86_64", target_env = "gnu"))] {
-                // On x86_64 MinGW targets, the unwinding mechanism is SEH however the unwind
-                // handler data (aka LSDA) uses GCC-compatible encoding.
-                #[lang = "eh_personality"]
-                #[allow(nonstandard_style)]
-                unsafe extern "C" fn rust_eh_personality(exceptionRecord: *mut uw::EXCEPTION_RECORD,
-                        establisherFrame: uw::LPVOID,
-                        contextRecord: *mut uw::CONTEXT,
-                        dispatcherContext: *mut uw::DISPATCHER_CONTEXT)
-                        -> uw::EXCEPTION_DISPOSITION {
-                    uw::_GCC_specific_handler(exceptionRecord,
-                                             establisherFrame,
-                                             contextRecord,
-                                             dispatcherContext,
-                                             rust_eh_personality_impl)
-                }
-            } else {
-                // The personality routine for most of our targets.
-                #[lang = "eh_personality"]
-                unsafe extern "C" fn rust_eh_personality(version: c_int,
-                        actions: uw::_Unwind_Action,
-                        exception_class: uw::_Unwind_Exception_Class,
-                        exception_object: *mut uw::_Unwind_Exception,
-                        context: *mut uw::_Unwind_Context)
-                        -> uw::_Unwind_Reason_Code {
-                    rust_eh_personality_impl(version,
-                                             actions,
-                                             exception_class,
-                                             exception_object,
-                                             context)
-                }
-            }
-        }
-    }
-}
-
-unsafe fn find_eh_action(context: *mut uw::_Unwind_Context) -> Result<EHAction, ()> {
-    let lsda = uw::_Unwind_GetLanguageSpecificData(context) as *const u8;
-    let mut ip_before_instr: c_int = 0;
-    let ip = uw::_Unwind_GetIPInfo(context, &mut ip_before_instr);
-    let eh_context = EHContext {
-        // The return address points 1 byte past the call instruction,
-        // which could be in the next IP range in LSDA range table.
-        //
-        // `ip = -1` has special meaning, so use wrapping sub to allow for that
-        ip: if ip_before_instr != 0 { ip } else { ip.wrapping_sub(1) },
-        func_start: uw::_Unwind_GetRegionStart(context),
-        get_text_start: &|| uw::_Unwind_GetTextRelBase(context),
-        get_data_start: &|| uw::_Unwind_GetDataRelBase(context),
-    };
-    eh::find_eh_action(lsda, &eh_context)
-}
-
 // Frame unwind info registration
 //
 // Each module's image contains a frame unwind info section (usually

library/panic_unwind/src/lib.rs

@@ -92,8 +92,6 @@ extern "C" {
     fn __rust_foreign_exception() -> !;
 }
 
-mod dwarf;
-
 #[rustc_std_internal_symbol]
 #[allow(improper_ctypes_definitions)]
 pub unsafe extern "C" fn __rust_panic_cleanup(payload: *mut u8) -> *mut (dyn Any + Send + 'static) {

library/panic_unwind/src/seh.rs

@@ -323,13 +323,3 @@ pub unsafe fn cleanup(payload: *mut u8) -> Box<dyn Any + Send> {
         exception.data.take().unwrap()
     }
 }
-
-// This is required by the compiler to exist (e.g., it's a lang item), but
-// it's never actually called by the compiler because _CxxFrameHandler3
-// is the personality function that is always used.
-// Hence this is just an aborting stub.
-#[lang = "eh_personality"]
-#[cfg(not(test))]
-fn rust_eh_personality() {
-    core::intrinsics::abort()
-}

library/std/src/lib.rs

@@ -591,6 +591,7 @@ pub mod alloc;
 
 // Private support modules
 mod panicking;
+mod personality;
 
 #[path = "../../backtrace/src/lib.rs"]
 #[allow(dead_code, unused_attributes)]

library/std/src/personality.rs

@@ -0,0 +1,46 @@
+//! This module contains the implementation of the `eh_personality` lang item.
+//!
+//! The actual implementation is heavily dependent on the target since Rust
+//! tries to use the native stack unwinding mechanism whenever possible.
+//!
+//! This personality function is still required with `-C panic=abort` because
+//! it is used to catch foreign exceptions from `extern "C-unwind"` and turn
+//! them into aborts.
+//!
+//! Additionally, ARM EHABI uses the personality function when generating
+//! backtraces.
+
+mod dwarf;
+
+#[cfg(not(test))]
+cfg_if::cfg_if! {
+    if #[cfg(target_os = "emscripten")] {
+        mod emcc;
+    } else if #[cfg(target_env = "msvc")] {
+        // This is required by the compiler to exist (e.g., it's a lang item),
+        // but it's never actually called by the compiler because
+        // _CxxFrameHandler3 is the personality function that is always used.
+        // Hence this is just an aborting stub.
+        #[lang = "eh_personality"]
+        fn rust_eh_personality() {
+            core::intrinsics::abort()
+        }
+    } else if #[cfg(any(
+        all(target_family = "windows", target_env = "gnu"),
+        target_os = "psp",
+        target_os = "solid_asp3",
+        all(target_family = "unix", not(target_os = "espidf")),
+        all(target_vendor = "fortanix", target_env = "sgx"),
+    ))] {
+        mod gcc;
+    } else {
+        // Targets that don't support unwinding.
+        // - family=wasm
+        // - os=none ("bare metal" targets)
+        // - os=uefi
+        // - os=espidf
+        // - os=hermit
+        // - nvptx64-nvidia-cuda
+        // - arch=avr
+    }
+}

library/panic_unwind/src/dwarf/eh.rs → library/std/src/personality/dwarf/eh.rs

@@ -11,7 +11,7 @@
 #![allow(non_upper_case_globals)]
 #![allow(unused)]
 
-use crate::dwarf::DwarfReader;
+use super::DwarfReader;
 use core::mem;
 
 pub const DW_EH_PE_omit: u8 = 0xFF;