summaryrefslogtreecommitdiffstats
path: root/library/panic_unwind/src
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-17 12:02:58 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-17 12:02:58 +0000
commit698f8c2f01ea549d77d7dc3338a12e04c11057b9 (patch)
tree173a775858bd501c378080a10dca74132f05bc50 /library/panic_unwind/src
parentInitial commit. (diff)
downloadrustc-698f8c2f01ea549d77d7dc3338a12e04c11057b9.tar.xz
rustc-698f8c2f01ea549d77d7dc3338a12e04c11057b9.zip
Adding upstream version 1.64.0+dfsg1.upstream/1.64.0+dfsg1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'library/panic_unwind/src')
-rw-r--r--library/panic_unwind/src/dummy.rs15
-rw-r--r--library/panic_unwind/src/dwarf/eh.rs192
-rw-r--r--library/panic_unwind/src/dwarf/mod.rs73
-rw-r--r--library/panic_unwind/src/dwarf/tests.rs19
-rw-r--r--library/panic_unwind/src/emcc.rs132
-rw-r--r--library/panic_unwind/src/gcc.rs351
-rw-r--r--library/panic_unwind/src/hermit.rs20
-rw-r--r--library/panic_unwind/src/lib.rs110
-rw-r--r--library/panic_unwind/src/miri.rs25
-rw-r--r--library/panic_unwind/src/seh.rs335
10 files changed, 1272 insertions, 0 deletions
diff --git a/library/panic_unwind/src/dummy.rs b/library/panic_unwind/src/dummy.rs
new file mode 100644
index 000000000..a4bcd216c
--- /dev/null
+++ b/library/panic_unwind/src/dummy.rs
@@ -0,0 +1,15 @@
+//! Unwinding for unsupported target.
+//!
+//! Stubs that simply abort for targets that don't support unwinding otherwise.
+
+use alloc::boxed::Box;
+use core::any::Any;
+use core::intrinsics;
+
+pub unsafe fn cleanup(_ptr: *mut u8) -> Box<dyn Any + Send> {
+ intrinsics::abort()
+}
+
+pub unsafe fn panic(_data: Box<dyn Any + Send>) -> u32 {
+ intrinsics::abort()
+}
diff --git a/library/panic_unwind/src/dwarf/eh.rs b/library/panic_unwind/src/dwarf/eh.rs
new file mode 100644
index 000000000..7394feab8
--- /dev/null
+++ b/library/panic_unwind/src/dwarf/eh.rs
@@ -0,0 +1,192 @@
+//! Parsing of GCC-style Language-Specific Data Area (LSDA)
+//! For details see:
+//! * <https://refspecs.linuxfoundation.org/LSB_3.0.0/LSB-PDA/LSB-PDA/ehframechpt.html>
+//! * <https://itanium-cxx-abi.github.io/cxx-abi/exceptions.pdf>
+//! * <https://www.airs.com/blog/archives/460>
+//! * <https://www.airs.com/blog/archives/464>
+//!
+//! A reference implementation may be found in the GCC source tree
+//! (`<root>/libgcc/unwind-c.c` as of this writing).
+
+#![allow(non_upper_case_globals)]
+#![allow(unused)]
+
+use crate::dwarf::DwarfReader;
+use core::mem;
+
+pub const DW_EH_PE_omit: u8 = 0xFF;
+pub const DW_EH_PE_absptr: u8 = 0x00;
+
+pub const DW_EH_PE_uleb128: u8 = 0x01;
+pub const DW_EH_PE_udata2: u8 = 0x02;
+pub const DW_EH_PE_udata4: u8 = 0x03;
+pub const DW_EH_PE_udata8: u8 = 0x04;
+pub const DW_EH_PE_sleb128: u8 = 0x09;
+pub const DW_EH_PE_sdata2: u8 = 0x0A;
+pub const DW_EH_PE_sdata4: u8 = 0x0B;
+pub const DW_EH_PE_sdata8: u8 = 0x0C;
+
+pub const DW_EH_PE_pcrel: u8 = 0x10;
+pub const DW_EH_PE_textrel: u8 = 0x20;
+pub const DW_EH_PE_datarel: u8 = 0x30;
+pub const DW_EH_PE_funcrel: u8 = 0x40;
+pub const DW_EH_PE_aligned: u8 = 0x50;
+
+pub const DW_EH_PE_indirect: u8 = 0x80;
+
+#[derive(Copy, Clone)]
+pub struct EHContext<'a> {
+ pub ip: usize, // Current instruction pointer
+ pub func_start: usize, // Address of the current function
+ pub get_text_start: &'a dyn Fn() -> usize, // Get address of the code section
+ pub get_data_start: &'a dyn Fn() -> usize, // Get address of the data section
+}
+
+pub enum EHAction {
+ None,
+ Cleanup(usize),
+ Catch(usize),
+ Terminate,
+}
+
+pub const USING_SJLJ_EXCEPTIONS: bool = cfg!(all(target_os = "ios", target_arch = "arm"));
+
+pub unsafe fn find_eh_action(lsda: *const u8, context: &EHContext<'_>) -> Result<EHAction, ()> {
+ if lsda.is_null() {
+ return Ok(EHAction::None);
+ }
+
+ let func_start = context.func_start;
+ let mut reader = DwarfReader::new(lsda);
+
+ let start_encoding = reader.read::<u8>();
+ // base address for landing pad offsets
+ let lpad_base = if start_encoding != DW_EH_PE_omit {
+ read_encoded_pointer(&mut reader, context, start_encoding)?
+ } else {
+ func_start
+ };
+
+ let ttype_encoding = reader.read::<u8>();
+ if ttype_encoding != DW_EH_PE_omit {
+ // Rust doesn't analyze exception types, so we don't care about the type table
+ reader.read_uleb128();
+ }
+
+ let call_site_encoding = reader.read::<u8>();
+ let call_site_table_length = reader.read_uleb128();
+ let action_table = reader.ptr.offset(call_site_table_length as isize);
+ let ip = context.ip;
+
+ if !USING_SJLJ_EXCEPTIONS {
+ while reader.ptr < action_table {
+ let cs_start = read_encoded_pointer(&mut reader, context, call_site_encoding)?;
+ let cs_len = read_encoded_pointer(&mut reader, context, call_site_encoding)?;
+ let cs_lpad = read_encoded_pointer(&mut reader, context, call_site_encoding)?;
+ let cs_action = reader.read_uleb128();
+ // Callsite table is sorted by cs_start, so if we've passed the ip, we
+ // may stop searching.
+ if ip < func_start + cs_start {
+ break;
+ }
+ if ip < func_start + cs_start + cs_len {
+ if cs_lpad == 0 {
+ return Ok(EHAction::None);
+ } else {
+ let lpad = lpad_base + cs_lpad;
+ return Ok(interpret_cs_action(cs_action, lpad));
+ }
+ }
+ }
+ // Ip is not present in the table. This should not happen... but it does: issue #35011.
+ // So rather than returning EHAction::Terminate, we do this.
+ Ok(EHAction::None)
+ } else {
+ // SjLj version:
+ // The "IP" is an index into the call-site table, with two exceptions:
+ // -1 means 'no-action', and 0 means 'terminate'.
+ match ip as isize {
+ -1 => return Ok(EHAction::None),
+ 0 => return Ok(EHAction::Terminate),
+ _ => (),
+ }
+ let mut idx = ip;
+ loop {
+ let cs_lpad = reader.read_uleb128();
+ let cs_action = reader.read_uleb128();
+ idx -= 1;
+ if idx == 0 {
+ // Can never have null landing pad for sjlj -- that would have
+ // been indicated by a -1 call site index.
+ let lpad = (cs_lpad + 1) as usize;
+ return Ok(interpret_cs_action(cs_action, lpad));
+ }
+ }
+ }
+}
+
+fn interpret_cs_action(cs_action: u64, lpad: usize) -> EHAction {
+ if cs_action == 0 {
+ // If cs_action is 0 then this is a cleanup (Drop::drop). We run these
+ // for both Rust panics and foreign exceptions.
+ EHAction::Cleanup(lpad)
+ } else {
+ // Stop unwinding Rust panics at catch_unwind.
+ EHAction::Catch(lpad)
+ }
+}
+
+#[inline]
+fn round_up(unrounded: usize, align: usize) -> Result<usize, ()> {
+ if align.is_power_of_two() { Ok((unrounded + align - 1) & !(align - 1)) } else { Err(()) }
+}
+
+unsafe fn read_encoded_pointer(
+ reader: &mut DwarfReader,
+ context: &EHContext<'_>,
+ encoding: u8,
+) -> Result<usize, ()> {
+ if encoding == DW_EH_PE_omit {
+ return Err(());
+ }
+
+ // DW_EH_PE_aligned implies it's an absolute pointer value
+ if encoding == DW_EH_PE_aligned {
+ reader.ptr = round_up(reader.ptr as usize, mem::size_of::<usize>())? as *const u8;
+ return Ok(reader.read::<usize>());
+ }
+
+ let mut result = match encoding & 0x0F {
+ DW_EH_PE_absptr => reader.read::<usize>(),
+ DW_EH_PE_uleb128 => reader.read_uleb128() as usize,
+ DW_EH_PE_udata2 => reader.read::<u16>() as usize,
+ DW_EH_PE_udata4 => reader.read::<u32>() as usize,
+ DW_EH_PE_udata8 => reader.read::<u64>() as usize,
+ DW_EH_PE_sleb128 => reader.read_sleb128() as usize,
+ DW_EH_PE_sdata2 => reader.read::<i16>() as usize,
+ DW_EH_PE_sdata4 => reader.read::<i32>() as usize,
+ DW_EH_PE_sdata8 => reader.read::<i64>() as usize,
+ _ => return Err(()),
+ };
+
+ result += match encoding & 0x70 {
+ DW_EH_PE_absptr => 0,
+ // relative to address of the encoded value, despite the name
+ DW_EH_PE_pcrel => reader.ptr as usize,
+ DW_EH_PE_funcrel => {
+ if context.func_start == 0 {
+ return Err(());
+ }
+ context.func_start
+ }
+ DW_EH_PE_textrel => (*context.get_text_start)(),
+ DW_EH_PE_datarel => (*context.get_data_start)(),
+ _ => return Err(()),
+ };
+
+ if encoding & DW_EH_PE_indirect != 0 {
+ result = *(result as *const usize);
+ }
+
+ Ok(result)
+}
diff --git a/library/panic_unwind/src/dwarf/mod.rs b/library/panic_unwind/src/dwarf/mod.rs
new file mode 100644
index 000000000..652fbe95a
--- /dev/null
+++ b/library/panic_unwind/src/dwarf/mod.rs
@@ -0,0 +1,73 @@
+//! Utilities for parsing DWARF-encoded data streams.
+//! See <http://www.dwarfstd.org>,
+//! DWARF-4 standard, Section 7 - "Data Representation"
+
+// This module is used only by x86_64-pc-windows-gnu for now, but we
+// are compiling it everywhere to avoid regressions.
+#![allow(unused)]
+
+#[cfg(test)]
+mod tests;
+
+pub mod eh;
+
+use core::mem;
+
+pub struct DwarfReader {
+ pub ptr: *const u8,
+}
+
+#[repr(C, packed)]
+struct Unaligned<T>(T);
+
+impl DwarfReader {
+ pub fn new(ptr: *const u8) -> DwarfReader {
+ DwarfReader { ptr }
+ }
+
+ // DWARF streams are packed, so e.g., a u32 would not necessarily be aligned
+ // on a 4-byte boundary. This may cause problems on platforms with strict
+ // alignment requirements. By wrapping data in a "packed" struct, we are
+ // telling the backend to generate "misalignment-safe" code.
+ pub unsafe fn read<T: Copy>(&mut self) -> T {
+ let Unaligned(result) = *(self.ptr as *const Unaligned<T>);
+ self.ptr = self.ptr.add(mem::size_of::<T>());
+ result
+ }
+
+ // ULEB128 and SLEB128 encodings are defined in Section 7.6 - "Variable
+ // Length Data".
+ pub unsafe fn read_uleb128(&mut self) -> u64 {
+ let mut shift: usize = 0;
+ let mut result: u64 = 0;
+ let mut byte: u8;
+ loop {
+ byte = self.read::<u8>();
+ result |= ((byte & 0x7F) as u64) << shift;
+ shift += 7;
+ if byte & 0x80 == 0 {
+ break;
+ }
+ }
+ result
+ }
+
+ pub unsafe fn read_sleb128(&mut self) -> i64 {
+ let mut shift: u32 = 0;
+ let mut result: u64 = 0;
+ let mut byte: u8;
+ loop {
+ byte = self.read::<u8>();
+ result |= ((byte & 0x7F) as u64) << shift;
+ shift += 7;
+ if byte & 0x80 == 0 {
+ break;
+ }
+ }
+ // sign-extend
+ if shift < u64::BITS && (byte & 0x40) != 0 {
+ result |= (!0 as u64) << shift;
+ }
+ result as i64
+ }
+}
diff --git a/library/panic_unwind/src/dwarf/tests.rs b/library/panic_unwind/src/dwarf/tests.rs
new file mode 100644
index 000000000..1644f3708
--- /dev/null
+++ b/library/panic_unwind/src/dwarf/tests.rs
@@ -0,0 +1,19 @@
+use super::*;
+
+#[test]
+fn dwarf_reader() {
+ let encoded: &[u8] = &[1, 2, 3, 4, 5, 6, 7, 0xE5, 0x8E, 0x26, 0x9B, 0xF1, 0x59, 0xFF, 0xFF];
+
+ let mut reader = DwarfReader::new(encoded.as_ptr());
+
+ unsafe {
+ assert!(reader.read::<u8>() == u8::to_be(1u8));
+ assert!(reader.read::<u16>() == u16::to_be(0x0203));
+ assert!(reader.read::<u32>() == u32::to_be(0x04050607));
+
+ assert!(reader.read_uleb128() == 624485);
+ assert!(reader.read_sleb128() == -624485);
+
+ assert!(reader.read::<i8>() == i8::to_be(-1));
+ }
+}
diff --git a/library/panic_unwind/src/emcc.rs b/library/panic_unwind/src/emcc.rs
new file mode 100644
index 000000000..1ee69ff9c
--- /dev/null
+++ b/library/panic_unwind/src/emcc.rs
@@ -0,0 +1,132 @@
+//! Unwinding for *emscripten* target.
+//!
+//! Whereas Rust's usual unwinding implementation for Unix platforms
+//! calls into the libunwind APIs directly, on Emscripten we instead
+//! call into the C++ unwinding APIs. This is just an expedience since
+//! Emscripten's runtime always implements those APIs and does not
+//! implement libunwind.
+
+use alloc::boxed::Box;
+use core::any::Any;
+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++
+#[repr(C)]
+struct TypeInfo {
+ vtable: *const usize,
+ name: *const u8,
+}
+unsafe impl Sync for TypeInfo {}
+
+extern "C" {
+ // The leading `\x01` byte here is actually a magical signal to LLVM to
+ // *not* apply any other mangling like prefixing with a `_` character.
+ //
+ // This symbol is the vtable used by C++'s `std::type_info`. Objects of type
+ // `std::type_info`, type descriptors, have a pointer to this table. Type
+ // descriptors are referenced by the C++ EH structures defined above and
+ // that we construct below.
+ //
+ // Note that the real size is larger than 3 usize, but we only need our
+ // vtable to point to the third element.
+ #[link_name = "\x01_ZTVN10__cxxabiv117__class_type_infoE"]
+ static CLASS_TYPE_INFO_VTABLE: [usize; 3];
+}
+
+// std::type_info for a rust_panic class
+#[lang = "eh_catch_typeinfo"]
+static EXCEPTION_TYPE_INFO: TypeInfo = TypeInfo {
+ // Normally we would use .as_ptr().add(2) but this doesn't work in a const context.
+ vtable: unsafe { &CLASS_TYPE_INFO_VTABLE[2] },
+ // This intentionally doesn't use the normal name mangling scheme because
+ // we don't want C++ to be able to produce or catch Rust panics.
+ name: b"rust_panic\0".as_ptr(),
+};
+
+struct Exception {
+ // This is necessary because C++ code can capture our exception with
+ // std::exception_ptr and rethrow it multiple times, possibly even in
+ // another thread.
+ caught: AtomicBool,
+
+ // This needs to be an Option because the object's lifetime follows C++
+ // semantics: when catch_unwind moves the Box out of the exception it must
+ // still leave the exception object in a valid state because its destructor
+ // is still going to be called by __cxa_end_catch.
+ data: Option<Box<dyn Any + Send>>,
+}
+
+pub unsafe fn cleanup(ptr: *mut u8) -> Box<dyn Any + Send> {
+ // intrinsics::try actually gives us a pointer to this structure.
+ #[repr(C)]
+ struct CatchData {
+ ptr: *mut u8,
+ is_rust_panic: bool,
+ }
+ let catch_data = &*(ptr as *mut CatchData);
+
+ let adjusted_ptr = __cxa_begin_catch(catch_data.ptr as *mut libc::c_void) as *mut Exception;
+ let out = if catch_data.is_rust_panic {
+ let was_caught = (*adjusted_ptr).caught.swap(true, Ordering::SeqCst);
+ if was_caught {
+ // Since cleanup() isn't allowed to panic, we just abort instead.
+ intrinsics::abort();
+ }
+ (*adjusted_ptr).data.take().unwrap()
+ } else {
+ super::__rust_foreign_exception();
+ };
+ __cxa_end_catch();
+ out
+}
+
+pub unsafe fn panic(data: Box<dyn Any + Send>) -> u32 {
+ let sz = mem::size_of_val(&data);
+ let exception = __cxa_allocate_exception(sz) as *mut Exception;
+ if exception.is_null() {
+ return uw::_URC_FATAL_PHASE1_ERROR as u32;
+ }
+ ptr::write(exception, Exception { caught: AtomicBool::new(false), data: Some(data) });
+ __cxa_throw(exception as *mut _, &EXCEPTION_TYPE_INFO, exception_cleanup);
+}
+
+extern "C" fn exception_cleanup(ptr: *mut libc::c_void) -> *mut libc::c_void {
+ unsafe {
+ if let Some(b) = (ptr as *mut Exception).read().data {
+ drop(b);
+ super::__rust_drop_panic();
+ }
+ ptr
+ }
+}
+
+// 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;
+ fn __cxa_end_catch();
+ fn __cxa_throw(
+ thrown_exception: *mut libc::c_void,
+ tinfo: *const TypeInfo,
+ dest: extern "C" fn(*mut libc::c_void) -> *mut libc::c_void,
+ ) -> !;
+}
diff --git a/library/panic_unwind/src/gcc.rs b/library/panic_unwind/src/gcc.rs
new file mode 100644
index 000000000..a59659231
--- /dev/null
+++ b/library/panic_unwind/src/gcc.rs
@@ -0,0 +1,351 @@
+//! Implementation of panics backed by libgcc/libunwind (in some form).
+//!
+//! For background on exception handling and stack unwinding please see
+//! "Exception Handling in LLVM" (llvm.org/docs/ExceptionHandling.html) and
+//! documents linked from it.
+//! These are also good reads:
+//! * <https://itanium-cxx-abi.github.io/cxx-abi/abi-eh.html>
+//! * <https://monoinfinito.wordpress.com/series/exception-handling-in-c/>
+//! * <https://www.airs.com/blog/index.php?s=exception+frames>
+//!
+//! ## A brief summary
+//!
+//! Exception handling happens in two phases: a search phase and a cleanup
+//! phase.
+//!
+//! In both phases the unwinder walks stack frames from top to bottom using
+//! information from the stack frame unwind sections of the current process's
+//! modules ("module" here refers to an OS module, i.e., an executable or a
+//! dynamic library).
+//!
+//! For each stack frame, it invokes the associated "personality routine", whose
+//! address is also stored in the unwind info section.
+//!
+//! In the search phase, the job of a personality routine is to examine
+//! exception object being thrown, and to decide whether it should be caught at
+//! that stack frame. Once the handler frame has been identified, cleanup phase
+//! begins.
+//!
+//! In the cleanup phase, the unwinder invokes each personality routine again.
+//! This time it decides which (if any) cleanup code needs to be run for
+//! the current stack frame. If so, the control is transferred to a special
+//! branch in the function body, the "landing pad", which invokes destructors,
+//! frees memory, etc. At the end of the landing pad, control is transferred
+//! back to the unwinder and unwinding resumes.
+//!
+//! Once stack has been unwound down to the handler frame level, unwinding stops
+//! and the last personality routine transfers control to the catch block.
+
+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)]
+struct Exception {
+ _uwe: uw::_Unwind_Exception,
+ cause: Box<dyn Any + Send>,
+}
+
+pub unsafe fn panic(data: Box<dyn Any + Send>) -> u32 {
+ let exception = Box::new(Exception {
+ _uwe: uw::_Unwind_Exception {
+ exception_class: rust_exception_class(),
+ exception_cleanup,
+ private: [0; uw::unwinder_private_data_size],
+ },
+ cause: data,
+ });
+ let exception_param = Box::into_raw(exception) as *mut uw::_Unwind_Exception;
+ return uw::_Unwind_RaiseException(exception_param) as u32;
+
+ extern "C" fn exception_cleanup(
+ _unwind_code: uw::_Unwind_Reason_Code,
+ exception: *mut uw::_Unwind_Exception,
+ ) {
+ unsafe {
+ let _: Box<Exception> = Box::from_raw(exception as *mut Exception);
+ super::__rust_drop_panic();
+ }
+ }
+}
+
+pub unsafe fn cleanup(ptr: *mut u8) -> Box<dyn Any + Send> {
+ let exception = ptr as *mut uw::_Unwind_Exception;
+ if (*exception).exception_class != rust_exception_class() {
+ uw::_Unwind_DeleteException(exception);
+ super::__rust_foreign_exception();
+ } else {
+ let exception = Box::from_raw(exception as *mut Exception);
+ exception.cause
+ }
+}
+
+// Rust's exception class identifier. This is used by personality routines to
+// determine whether the exception was thrown by their own runtime.
+fn rust_exception_class() -> uw::_Unwind_Exception_Class {
+ // M O Z \0 R U S T -- vendor, language
+ 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
+// ".eh_frame"). When a module is loaded/unloaded into the process, the
+// unwinder must be informed about the location of this section in memory. The
+// methods of achieving that vary by the platform. On some (e.g., Linux), the
+// unwinder can discover unwind info sections on its own (by dynamically
+// enumerating currently loaded modules via the dl_iterate_phdr() API and
+// finding their ".eh_frame" sections); Others, like Windows, require modules
+// to actively register their unwind info sections via unwinder API.
+//
+// This module defines two symbols which are referenced and called from
+// rsbegin.rs to register our information with the GCC runtime. The
+// implementation of stack unwinding is (for now) deferred to libgcc_eh, however
+// Rust crates use these Rust-specific entry points to avoid potential clashes
+// with any GCC runtime.
+#[cfg(all(target_os = "windows", target_arch = "x86", target_env = "gnu"))]
+pub mod eh_frame_registry {
+ extern "C" {
+ fn __register_frame_info(eh_frame_begin: *const u8, object: *mut u8);
+ fn __deregister_frame_info(eh_frame_begin: *const u8, object: *mut u8);
+ }
+
+ #[rustc_std_internal_symbol]
+ pub unsafe extern "C" fn rust_eh_register_frames(eh_frame_begin: *const u8, object: *mut u8) {
+ __register_frame_info(eh_frame_begin, object);
+ }
+
+ #[rustc_std_internal_symbol]
+ pub unsafe extern "C" fn rust_eh_unregister_frames(eh_frame_begin: *const u8, object: *mut u8) {
+ __deregister_frame_info(eh_frame_begin, object);
+ }
+}
diff --git a/library/panic_unwind/src/hermit.rs b/library/panic_unwind/src/hermit.rs
new file mode 100644
index 000000000..69b9edb77
--- /dev/null
+++ b/library/panic_unwind/src/hermit.rs
@@ -0,0 +1,20 @@
+//! Unwinding for *hermit* target.
+//!
+//! Right now we don't support this, so this is just stubs.
+
+use alloc::boxed::Box;
+use core::any::Any;
+
+pub unsafe fn cleanup(_ptr: *mut u8) -> Box<dyn Any + Send> {
+ extern "C" {
+ pub fn __rust_abort() -> !;
+ }
+ __rust_abort();
+}
+
+pub unsafe fn panic(_data: Box<dyn Any + Send>) -> u32 {
+ extern "C" {
+ pub fn __rust_abort() -> !;
+ }
+ __rust_abort();
+}
diff --git a/library/panic_unwind/src/lib.rs b/library/panic_unwind/src/lib.rs
new file mode 100644
index 000000000..f9acb42c4
--- /dev/null
+++ b/library/panic_unwind/src/lib.rs
@@ -0,0 +1,110 @@
+//! Implementation of panics via stack unwinding
+//!
+//! This crate is an implementation of panics in Rust using "most native" stack
+//! unwinding mechanism of the platform this is being compiled for. This
+//! essentially gets categorized into three buckets currently:
+//!
+//! 1. MSVC targets use SEH in the `seh.rs` file.
+//! 2. Emscripten uses C++ exceptions in the `emcc.rs` file.
+//! 3. All other targets use libunwind/libgcc in the `gcc.rs` file.
+//!
+//! More documentation about each implementation can be found in the respective
+//! module.
+
+#![no_std]
+#![unstable(feature = "panic_unwind", issue = "32837")]
+#![doc(issue_tracker_base_url = "https://github.com/rust-lang/rust/issues/")]
+#![feature(core_intrinsics)]
+#![feature(lang_items)]
+#![feature(panic_unwind)]
+#![feature(staged_api)]
+#![feature(std_internals)]
+#![feature(abi_thiscall)]
+#![feature(rustc_attrs)]
+#![panic_runtime]
+#![feature(panic_runtime)]
+#![feature(c_unwind)]
+// `real_imp` is unused with Miri, so silence warnings.
+#![cfg_attr(miri, allow(dead_code))]
+
+use alloc::boxed::Box;
+use core::any::Any;
+use core::panic::BoxMeUp;
+
+cfg_if::cfg_if! {
+ if #[cfg(target_os = "emscripten")] {
+ #[path = "emcc.rs"]
+ mod real_imp;
+ } else if #[cfg(target_os = "hermit")] {
+ #[path = "hermit.rs"]
+ mod real_imp;
+ } else if #[cfg(target_os = "l4re")] {
+ // L4Re is unix family but does not yet support unwinding.
+ #[path = "dummy.rs"]
+ mod real_imp;
+ } else if #[cfg(target_env = "msvc")] {
+ #[path = "seh.rs"]
+ mod real_imp;
+ } 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"),
+ ))] {
+ // Rust runtime's startup objects depend on these symbols, so make them public.
+ #[cfg(all(target_os="windows", target_arch = "x86", target_env="gnu"))]
+ pub use real_imp::eh_frame_registry::*;
+ #[path = "gcc.rs"]
+ mod real_imp;
+ } else {
+ // Targets that don't support unwinding.
+ // - family=wasm
+ // - os=none ("bare metal" targets)
+ // - os=uefi
+ // - os=espidf
+ // - nvptx64-nvidia-cuda
+ // - arch=avr
+ #[path = "dummy.rs"]
+ mod real_imp;
+ }
+}
+
+cfg_if::cfg_if! {
+ if #[cfg(miri)] {
+ // Use the Miri runtime.
+ // We still need to also load the normal runtime above, as rustc expects certain lang
+ // items from there to be defined.
+ #[path = "miri.rs"]
+ mod imp;
+ } else {
+ // Use the real runtime.
+ use real_imp as imp;
+ }
+}
+
+extern "C" {
+ /// Handler in libstd called when a panic object is dropped outside of
+ /// `catch_unwind`.
+ fn __rust_drop_panic() -> !;
+
+ /// Handler in libstd called when a foreign exception is caught.
+ 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) {
+ Box::into_raw(imp::cleanup(payload))
+}
+
+// Entry point for raising an exception, just delegates to the platform-specific
+// implementation.
+#[rustc_std_internal_symbol]
+pub unsafe fn __rust_start_panic(payload: *mut &mut dyn BoxMeUp) -> u32 {
+ let payload = Box::from_raw((*payload).take_box());
+
+ imp::panic(payload)
+}
diff --git a/library/panic_unwind/src/miri.rs b/library/panic_unwind/src/miri.rs
new file mode 100644
index 000000000..d941b73b5
--- /dev/null
+++ b/library/panic_unwind/src/miri.rs
@@ -0,0 +1,25 @@
+//! Unwinding panics for Miri.
+use alloc::boxed::Box;
+use core::any::Any;
+
+// The type of the payload that the Miri engine propagates through unwinding for us.
+// Must be pointer-sized.
+type Payload = Box<Box<dyn Any + Send>>;
+
+extern "Rust" {
+ /// Miri-provided extern function to begin unwinding.
+ fn miri_start_panic(payload: *mut u8) -> !;
+}
+
+pub unsafe fn panic(payload: Box<dyn Any + Send>) -> u32 {
+ // The payload we pass to `miri_start_panic` will be exactly the argument we get
+ // in `cleanup` below. So we just box it up once, to get something pointer-sized.
+ let payload_box: Payload = Box::new(payload);
+ miri_start_panic(Box::into_raw(payload_box) as *mut u8)
+}
+
+pub unsafe fn cleanup(payload_box: *mut u8) -> Box<dyn Any + Send> {
+ // Recover the underlying `Box`.
+ let payload_box: Payload = Box::from_raw(payload_box as *mut _);
+ *payload_box
+}
diff --git a/library/panic_unwind/src/seh.rs b/library/panic_unwind/src/seh.rs
new file mode 100644
index 000000000..9f1eb411f
--- /dev/null
+++ b/library/panic_unwind/src/seh.rs
@@ -0,0 +1,335 @@
+//! Windows SEH
+//!
+//! On Windows (currently only on MSVC), the default exception handling
+//! mechanism is Structured Exception Handling (SEH). This is quite different
+//! than Dwarf-based exception handling (e.g., what other unix platforms use) in
+//! terms of compiler internals, so LLVM is required to have a good deal of
+//! extra support for SEH.
+//!
+//! In a nutshell, what happens here is:
+//!
+//! 1. The `panic` function calls the standard Windows function
+//! `_CxxThrowException` to throw a C++-like exception, triggering the
+//! unwinding process.
+//! 2. All landing pads generated by the compiler use the personality function
+//! `__CxxFrameHandler3`, a function in the CRT, and the unwinding code in
+//! Windows will use this personality function to execute all cleanup code on
+//! the stack.
+//! 3. All compiler-generated calls to `invoke` have a landing pad set as a
+//! `cleanuppad` LLVM instruction, which indicates the start of the cleanup
+//! routine. The personality (in step 2, defined in the CRT) is responsible
+//! for running the cleanup routines.
+//! 4. Eventually the "catch" code in the `try` intrinsic (generated by the
+//! compiler) is executed and indicates that control should come back to
+//! Rust. This is done via a `catchswitch` plus a `catchpad` instruction in
+//! LLVM IR terms, finally returning normal control to the program with a
+//! `catchret` instruction.
+//!
+//! Some specific differences from the gcc-based exception handling are:
+//!
+//! * Rust has no custom personality function, it is instead *always*
+//! `__CxxFrameHandler3`. Additionally, no extra filtering is performed, so we
+//! end up catching any C++ exceptions that happen to look like the kind we're
+//! throwing. Note that throwing an exception into Rust is undefined behavior
+//! anyway, so this should be fine.
+//! * We've got some data to transmit across the unwinding boundary,
+//! specifically a `Box<dyn Any + Send>`. Like with Dwarf exceptions
+//! these two pointers are stored as a payload in the exception itself. On
+//! MSVC, however, there's no need for an extra heap allocation because the
+//! call stack is preserved while filter functions are being executed. This
+//! means that the pointers are passed directly to `_CxxThrowException` which
+//! are then recovered in the filter function to be written to the stack frame
+//! of the `try` intrinsic.
+//!
+//! [win64]: https://docs.microsoft.com/en-us/cpp/build/exception-handling-x64
+//! [llvm]: https://llvm.org/docs/ExceptionHandling.html#background-on-windows-exceptions
+
+#![allow(nonstandard_style)]
+
+use alloc::boxed::Box;
+use core::any::Any;
+use core::mem::{self, ManuallyDrop};
+use libc::{c_int, c_uint, c_void};
+
+struct Exception {
+ // This needs to be an Option because we catch the exception by reference
+ // and its destructor is executed by the C++ runtime. When we take the Box
+ // out of the exception, we need to leave the exception in a valid state
+ // for its destructor to run without double-dropping the Box.
+ data: Option<Box<dyn Any + Send>>,
+}
+
+// First up, a whole bunch of type definitions. There's a few platform-specific
+// oddities here, and a lot that's just blatantly copied from LLVM. The purpose
+// of all this is to implement the `panic` function below through a call to
+// `_CxxThrowException`.
+//
+// This function takes two arguments. The first is a pointer to the data we're
+// passing in, which in this case is our trait object. Pretty easy to find! The
+// next, however, is more complicated. This is a pointer to a `_ThrowInfo`
+// structure, and it generally is just intended to just describe the exception
+// being thrown.
+//
+// Currently the definition of this type [1] is a little hairy, and the main
+// oddity (and difference from the online article) is that on 32-bit the
+// pointers are pointers but on 64-bit the pointers are expressed as 32-bit
+// offsets from the `__ImageBase` symbol. The `ptr_t` and `ptr!` macro in the
+// modules below are used to express this.
+//
+// The maze of type definitions also closely follows what LLVM emits for this
+// sort of operation. For example, if you compile this C++ code on MSVC and emit
+// the LLVM IR:
+//
+// #include <stdint.h>
+//
+// struct rust_panic {
+// rust_panic(const rust_panic&);
+// ~rust_panic();
+//
+// uint64_t x[2];
+// };
+//
+// void foo() {
+// rust_panic a = {0, 1};
+// throw a;
+// }
+//
+// That's essentially what we're trying to emulate. Most of the constant values
+// below were just copied from LLVM,
+//
+// In any case, these structures are all constructed in a similar manner, and
+// it's just somewhat verbose for us.
+//
+// [1]: https://www.geoffchappell.com/studies/msvc/language/predefined/
+
+#[cfg(target_arch = "x86")]
+#[macro_use]
+mod imp {
+ pub type ptr_t = *mut u8;
+
+ macro_rules! ptr {
+ (0) => {
+ core::ptr::null_mut()
+ };
+ ($e:expr) => {
+ $e as *mut u8
+ };
+ }
+}
+
+#[cfg(not(target_arch = "x86"))]
+#[macro_use]
+mod imp {
+ pub type ptr_t = u32;
+
+ extern "C" {
+ pub static __ImageBase: u8;
+ }
+
+ macro_rules! ptr {
+ (0) => (0);
+ ($e:expr) => {
+ (($e as usize) - (&imp::__ImageBase as *const _ as usize)) as u32
+ }
+ }
+}
+
+#[repr(C)]
+pub struct _ThrowInfo {
+ pub attributes: c_uint,
+ pub pmfnUnwind: imp::ptr_t,
+ pub pForwardCompat: imp::ptr_t,
+ pub pCatchableTypeArray: imp::ptr_t,
+}
+
+#[repr(C)]
+pub struct _CatchableTypeArray {
+ pub nCatchableTypes: c_int,
+ pub arrayOfCatchableTypes: [imp::ptr_t; 1],
+}
+
+#[repr(C)]
+pub struct _CatchableType {
+ pub properties: c_uint,
+ pub pType: imp::ptr_t,
+ pub thisDisplacement: _PMD,
+ pub sizeOrOffset: c_int,
+ pub copyFunction: imp::ptr_t,
+}
+
+#[repr(C)]
+pub struct _PMD {
+ pub mdisp: c_int,
+ pub pdisp: c_int,
+ pub vdisp: c_int,
+}
+
+#[repr(C)]
+pub struct _TypeDescriptor {
+ pub pVFTable: *const u8,
+ pub spare: *mut u8,
+ pub name: [u8; 11],
+}
+
+// Note that we intentionally ignore name mangling rules here: we don't want C++
+// to be able to catch Rust panics by simply declaring a `struct rust_panic`.
+//
+// When modifying, make sure that the type name string exactly matches
+// the one used in `compiler/rustc_codegen_llvm/src/intrinsic.rs`.
+const TYPE_NAME: [u8; 11] = *b"rust_panic\0";
+
+static mut THROW_INFO: _ThrowInfo = _ThrowInfo {
+ attributes: 0,
+ pmfnUnwind: ptr!(0),
+ pForwardCompat: ptr!(0),
+ pCatchableTypeArray: ptr!(0),
+};
+
+static mut CATCHABLE_TYPE_ARRAY: _CatchableTypeArray =
+ _CatchableTypeArray { nCatchableTypes: 1, arrayOfCatchableTypes: [ptr!(0)] };
+
+static mut CATCHABLE_TYPE: _CatchableType = _CatchableType {
+ properties: 0,
+ pType: ptr!(0),
+ thisDisplacement: _PMD { mdisp: 0, pdisp: -1, vdisp: 0 },
+ sizeOrOffset: mem::size_of::<Exception>() as c_int,
+ copyFunction: ptr!(0),
+};
+
+extern "C" {
+ // The leading `\x01` byte here is actually a magical signal to LLVM to
+ // *not* apply any other mangling like prefixing with a `_` character.
+ //
+ // This symbol is the vtable used by C++'s `std::type_info`. Objects of type
+ // `std::type_info`, type descriptors, have a pointer to this table. Type
+ // descriptors are referenced by the C++ EH structures defined above and
+ // that we construct below.
+ #[link_name = "\x01??_7type_info@@6B@"]
+ static TYPE_INFO_VTABLE: *const u8;
+}
+
+// This type descriptor is only used when throwing an exception. The catch part
+// is handled by the try intrinsic, which generates its own TypeDescriptor.
+//
+// This is fine since the MSVC runtime uses string comparison on the type name
+// to match TypeDescriptors rather than pointer equality.
+static mut TYPE_DESCRIPTOR: _TypeDescriptor = _TypeDescriptor {
+ pVFTable: unsafe { &TYPE_INFO_VTABLE } as *const _ as *const _,
+ spare: core::ptr::null_mut(),
+ name: TYPE_NAME,
+};
+
+// Destructor used if the C++ code decides to capture the exception and drop it
+// without propagating it. The catch part of the try intrinsic will set the
+// first word of the exception object to 0 so that it is skipped by the
+// destructor.
+//
+// Note that x86 Windows uses the "thiscall" calling convention for C++ member
+// functions instead of the default "C" calling convention.
+//
+// The exception_copy function is a bit special here: it is invoked by the MSVC
+// runtime under a try/catch block and the panic that we generate here will be
+// used as the result of the exception copy. This is used by the C++ runtime to
+// support capturing exceptions with std::exception_ptr, which we can't support
+// because Box<dyn Any> isn't clonable.
+macro_rules! define_cleanup {
+ ($abi:tt $abi2:tt) => {
+ unsafe extern $abi fn exception_cleanup(e: *mut Exception) {
+ if let Exception { data: Some(b) } = e.read() {
+ drop(b);
+ super::__rust_drop_panic();
+ }
+ }
+ unsafe extern $abi2 fn exception_copy(_dest: *mut Exception,
+ _src: *mut Exception)
+ -> *mut Exception {
+ panic!("Rust panics cannot be copied");
+ }
+ }
+}
+cfg_if::cfg_if! {
+ if #[cfg(target_arch = "x86")] {
+ define_cleanup!("thiscall" "thiscall-unwind");
+ } else {
+ define_cleanup!("C" "C-unwind");
+ }
+}
+
+pub unsafe fn panic(data: Box<dyn Any + Send>) -> u32 {
+ use core::intrinsics::atomic_store;
+
+ // _CxxThrowException executes entirely on this stack frame, so there's no
+ // need to otherwise transfer `data` to the heap. We just pass a stack
+ // pointer to this function.
+ //
+ // The ManuallyDrop is needed here since we don't want Exception to be
+ // dropped when unwinding. Instead it will be dropped by exception_cleanup
+ // which is invoked by the C++ runtime.
+ let mut exception = ManuallyDrop::new(Exception { data: Some(data) });
+ let throw_ptr = &mut exception as *mut _ as *mut _;
+
+ // This... may seems surprising, and justifiably so. On 32-bit MSVC the
+ // pointers between these structure are just that, pointers. On 64-bit MSVC,
+ // however, the pointers between structures are rather expressed as 32-bit
+ // offsets from `__ImageBase`.
+ //
+ // Consequently, on 32-bit MSVC we can declare all these pointers in the
+ // `static`s above. On 64-bit MSVC, we would have to express subtraction of
+ // pointers in statics, which Rust does not currently allow, so we can't
+ // actually do that.
+ //
+ // The next best thing, then is to fill in these structures at runtime
+ // (panicking is already the "slow path" anyway). So here we reinterpret all
+ // of these pointer fields as 32-bit integers and then store the
+ // relevant value into it (atomically, as concurrent panics may be
+ // happening). Technically the runtime will probably do a nonatomic read of
+ // these fields, but in theory they never read the *wrong* value so it
+ // shouldn't be too bad...
+ //
+ // In any case, we basically need to do something like this until we can
+ // express more operations in statics (and we may never be able to).
+ atomic_store(&mut THROW_INFO.pmfnUnwind as *mut _ as *mut u32, ptr!(exception_cleanup) as u32);
+ atomic_store(
+ &mut THROW_INFO.pCatchableTypeArray as *mut _ as *mut u32,
+ ptr!(&CATCHABLE_TYPE_ARRAY as *const _) as u32,
+ );
+ atomic_store(
+ &mut CATCHABLE_TYPE_ARRAY.arrayOfCatchableTypes[0] as *mut _ as *mut u32,
+ ptr!(&CATCHABLE_TYPE as *const _) as u32,
+ );
+ atomic_store(
+ &mut CATCHABLE_TYPE.pType as *mut _ as *mut u32,
+ ptr!(&TYPE_DESCRIPTOR as *const _) as u32,
+ );
+ atomic_store(
+ &mut CATCHABLE_TYPE.copyFunction as *mut _ as *mut u32,
+ ptr!(exception_copy) as u32,
+ );
+
+ extern "system-unwind" {
+ fn _CxxThrowException(pExceptionObject: *mut c_void, pThrowInfo: *mut u8) -> !;
+ }
+
+ _CxxThrowException(throw_ptr, &mut THROW_INFO as *mut _ as *mut _);
+}
+
+pub unsafe fn cleanup(payload: *mut u8) -> Box<dyn Any + Send> {
+ // A null payload here means that we got here from the catch (...) of
+ // __rust_try. This happens when a non-Rust foreign exception is caught.
+ if payload.is_null() {
+ super::__rust_foreign_exception();
+ } else {
+ let exception = &mut *(payload as *mut Exception);
+ 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 __C_specific_handler
+// or _except_handler3 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()
+}