mv std libs to library/

11 files changed, 0 insertions, 1279 deletions

diff --git a/src/libpanic_unwind/Cargo.toml b/src/libpanic_unwind/Cargo.toml
deleted file mode 100644
index 47cd09f1b05..00000000000
--- a/src/libpanic_unwind/Cargo.toml
+++ /dev/null
@@ -1,19 +0,0 @@
-[package]
-authors = ["The Rust Project Developers"]
-name = "panic_unwind"
-version = "0.0.0"
-edition = "2018"
-
-[lib]
-path = "lib.rs"
-test = false
-bench = false
-doc = false
-
-[dependencies]
-alloc = { path = "../liballoc" }
-core = { path = "../libcore" }
-libc = { version = "0.2", default-features = false }
-unwind = { path = "../libunwind" }
-compiler_builtins = "0.1.0"
-cfg-if = "0.1.8"
diff --git a/src/libpanic_unwind/dummy.rs b/src/libpanic_unwind/dummy.rs
deleted file mode 100644
index 4667ede2baa..00000000000
--- a/src/libpanic_unwind/dummy.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-//! Unwinding for *wasm32* target.
-//!
-//! Right now we don't support this, so this is just stubs.
-
-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/src/libpanic_unwind/dwarf/eh.rs b/src/libpanic_unwind/dwarf/eh.rs
deleted file mode 100644
index 302478cfac8..00000000000
--- a/src/libpanic_unwind/dwarf/eh.rs
+++ /dev/null
@@ -1,200 +0,0 @@
-//! Parsing of GCC-style Language-Specific Data Area (LSDA)
-//! For details see:
-//!   http://refspecs.linuxfoundation.org/LSB_3.0.0/LSB-PDA/LSB-PDA/ehframechpt.html
-//!   http://mentorembedded.github.io/cxx-abi/exceptions.pdf
-//!   http://www.airs.com/blog/archives/460
-//!   http://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<'_>,
-    foreign_exception: bool,
-) -> 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, foreign_exception));
-                }
-            }
-        }
-        // 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, foreign_exception));
-            }
-        }
-    }
-}
-
-fn interpret_cs_action(cs_action: u64, lpad: usize, foreign_exception: bool) -> 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 if foreign_exception {
-        // catch_unwind should not catch foreign exceptions, only Rust panics.
-        // Instead just continue unwinding.
-        EHAction::None
-    } 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/src/libpanic_unwind/dwarf/mod.rs b/src/libpanic_unwind/dwarf/mod.rs
deleted file mode 100644
index 649bbce52a3..00000000000
--- a/src/libpanic_unwind/dwarf/mod.rs
+++ /dev/null
@@ -1,73 +0,0 @@
-//! 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: 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;
-            }
-        }
-        // sign-extend
-        if shift < 8 * mem::size_of::<u64>() && (byte & 0x40) != 0 {
-            result |= (!0 as u64) << shift;
-        }
-        result as i64
-    }
-}
diff --git a/src/libpanic_unwind/dwarf/tests.rs b/src/libpanic_unwind/dwarf/tests.rs
deleted file mode 100644
index 1644f37083a..00000000000
--- a/src/libpanic_unwind/dwarf/tests.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-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/src/libpanic_unwind/emcc.rs b/src/libpanic_unwind/emcc.rs
deleted file mode 100644
index a0bdb1481c6..00000000000
--- a/src/libpanic_unwind/emcc.rs
+++ /dev/null
@@ -1,121 +0,0 @@
-//! 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::mem;
-use core::ptr;
-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 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> {
-    assert!(!ptr.is_null());
-    let adjusted_ptr = __cxa_begin_catch(ptr as *mut libc::c_void) as *mut Exception;
-    let ex = (*adjusted_ptr).data.take();
-    __cxa_end_catch();
-    ex.unwrap()
-}
-
-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 { data: Some(data) });
-    __cxa_throw(exception as *mut _, &EXCEPTION_TYPE_INFO, exception_cleanup);
-}
-
-// On WASM and ARM, the destructor returns the pointer to the object.
-cfg_if::cfg_if! {
-    if #[cfg(any(target_arch = "arm", target_arch = "wasm32"))] {
-        type DestructorRet = *mut libc::c_void;
-    } else {
-        type DestructorRet = ();
-    }
-}
-extern "C" fn exception_cleanup(ptr: *mut libc::c_void) -> DestructorRet {
-    unsafe {
-        if let Some(b) = (ptr as *mut Exception).read().data {
-            drop(b);
-            super::__rust_drop_panic();
-        }
-        #[cfg(any(target_arch = "arm", target_arch = "wasm32"))]
-        ptr
-    }
-}
-
-#[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 {
-    __gxx_personality_v0(version, actions, exception_class, exception_object, context)
-}
-
-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) -> DestructorRet,
-    ) -> !;
-    fn __gxx_personality_v0(
-        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;
-}
diff --git a/src/libpanic_unwind/gcc.rs b/src/libpanic_unwind/gcc.rs
deleted file mode 100644
index f5d83c21da0..00000000000
--- a/src/libpanic_unwind/gcc.rs
+++ /dev/null
@@ -1,346 +0,0 @@
-//! 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
-//!     http://monoinfinito.wordpress.com/series/exception-handling-in-c/
-//!     http://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 = Box::from_raw(ptr 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 http://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(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(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(target_arch = "riscv64")]
-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 = "netbsd")))] {
-        // ARM EHABI personality routine.
-        // http://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 exception_class = (*exception_object).exception_class;
-            let foreign_exception = exception_class != rust_exception_class();
-            let eh_action = match find_eh_action(context, foreign_exception) {
-                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 foreign_exception = exception_class != rust_exception_class();
-            let eh_action = match find_eh_action(context, foreign_exception) {
-                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,
-    foreign_exception: bool,
-) -> 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: if ip_before_instr != 0 { ip } else { ip - 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, foreign_exception)
-}
-
-// 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/src/libpanic_unwind/hermit.rs b/src/libpanic_unwind/hermit.rs
deleted file mode 100644
index 69b9edb77c5..00000000000
--- a/src/libpanic_unwind/hermit.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-//! 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/src/libpanic_unwind/lib.rs b/src/libpanic_unwind/lib.rs
deleted file mode 100644
index 72eab0763d8..00000000000
--- a/src/libpanic_unwind/lib.rs
+++ /dev/null
@@ -1,110 +0,0 @@
-//! 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(
-    html_root_url = "https://doc.rust-lang.org/nightly/",
-    issue_tracker_base_url = "https://github.com/rust-lang/rust/issues/"
-)]
-#![feature(core_intrinsics)]
-#![feature(lang_items)]
-#![feature(libc)]
-#![feature(nll)]
-#![feature(panic_unwind)]
-#![feature(staged_api)]
-#![feature(std_internals)]
-#![feature(unwind_attributes)]
-#![feature(abi_thiscall)]
-#![feature(rustc_attrs)]
-#![feature(raw)]
-#![panic_runtime]
-#![feature(panic_runtime)]
-// `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_env = "msvc")] {
-        #[path = "seh.rs"]
-        mod real_imp;
-    } else if #[cfg(any(
-        all(target_family = "windows", target_env = "gnu"),
-        target_os = "cloudabi",
-        target_family = "unix",
-        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.
-        // - arch=wasm32
-        // - os=none ("bare metal" targets)
-        // - os=uefi
-        // - nvptx64-nvidia-cuda
-        // - avr-unknown-unknown
-        // - mipsel-sony-psp
-        #[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() -> !;
-}
-
-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]
-#[unwind(allowed)]
-pub unsafe extern "C" fn __rust_start_panic(payload: usize) -> u32 {
-    let payload = payload as *mut &mut dyn BoxMeUp;
-    let payload = (*payload).take_box();
-
-    imp::panic(Box::from_raw(payload))
-}
diff --git a/src/libpanic_unwind/miri.rs b/src/libpanic_unwind/miri.rs
deleted file mode 100644
index d941b73b5fa..00000000000
--- a/src/libpanic_unwind/miri.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-//! 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/src/libpanic_unwind/seh.rs b/src/libpanic_unwind/seh.rs
deleted file mode 100644
index 1f812f8df61..00000000000
--- a/src/libpanic_unwind/seh.rs
+++ /dev/null
@@ -1,331 +0,0 @@
-//! 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]: http://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]: http://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 src/librustc_codegen_llvm/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) => {
-        unsafe extern $abi fn exception_cleanup(e: *mut Exception) {
-            if let Exception { data: Some(b) } = e.read() {
-                drop(b);
-                super::__rust_drop_panic();
-            }
-        }
-        #[unwind(allowed)]
-        unsafe extern $abi 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");
-   } else {
-       define_cleanup!("C");
-   }
-}
-
-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(allowed)]
-        pub 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> {
-    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()
-}