]> git.lizzy.rs Git - rust.git/blob - src/libpanic_unwind/lib.rs
Auto merge of #43648 - RalfJung:jemalloc-debug, r=alexcrichton
[rust.git] / src / libpanic_unwind / lib.rs
1 // Copyright 2016 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
4 //
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
10
11 //! Implementation of panics via stack unwinding
12 //!
13 //! This crate is an implementation of panics in Rust using "most native" stack
14 //! unwinding mechanism of the platform this is being compiled for. This
15 //! essentially gets categorized into three buckets currently:
16 //!
17 //! 1. MSVC targets use SEH in the `seh.rs` file.
18 //! 2. The 64-bit MinGW target half-uses SEH and half-use gcc-like information
19 //!    in the `seh64_gnu.rs` module.
20 //! 3. All other targets use libunwind/libgcc in the `gcc/mod.rs` module.
21 //!
22 //! More documentation about each implementation can be found in the respective
23 //! module.
24
25 #![no_std]
26 #![unstable(feature = "panic_unwind", issue = "32837")]
27 #![doc(html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
28        html_favicon_url = "https://doc.rust-lang.org/favicon.ico",
29        html_root_url = "https://doc.rust-lang.org/nightly/",
30        issue_tracker_base_url = "https://github.com/rust-lang/rust/issues/")]
31 #![deny(warnings)]
32
33 #![feature(alloc)]
34 #![feature(core_intrinsics)]
35 #![feature(lang_items)]
36 #![feature(libc)]
37 #![cfg_attr(not(any(target_env = "msvc",
38                     all(windows, target_arch = "x86_64", target_env = "gnu"))),
39             feature(panic_unwind))]
40 #![feature(raw)]
41 #![feature(staged_api)]
42 #![feature(unwind_attributes)]
43 #![cfg_attr(target_env = "msvc", feature(raw))]
44
45 #![panic_runtime]
46 #![feature(panic_runtime)]
47
48 extern crate alloc;
49 extern crate libc;
50 #[cfg(not(any(target_env = "msvc", all(windows, target_arch = "x86_64", target_env = "gnu"))))]
51 extern crate unwind;
52
53 use core::intrinsics;
54 use core::mem;
55 use core::raw;
56
57 // Rust runtime's startup objects depend on these symbols, so make them public.
58 #[cfg(all(target_os="windows", target_arch = "x86", target_env="gnu"))]
59 pub use imp::eh_frame_registry::*;
60
61 // *-pc-windows-msvc
62 #[cfg(target_env = "msvc")]
63 #[path = "seh.rs"]
64 mod imp;
65
66 // x86_64-pc-windows-gnu
67 #[cfg(all(windows, target_arch = "x86_64", target_env = "gnu"))]
68 #[path = "seh64_gnu.rs"]
69 mod imp;
70
71 // i686-pc-windows-gnu and all others
72 #[cfg(any(all(unix, not(target_os = "emscripten")),
73           target_os = "redox",
74           all(windows, target_arch = "x86", target_env = "gnu")))]
75 #[path = "gcc.rs"]
76 mod imp;
77
78 // emscripten
79 #[cfg(target_os = "emscripten")]
80 #[path = "emcc.rs"]
81 mod imp;
82
83 mod dwarf;
84 mod windows;
85
86 // Entry point for catching an exception, implemented using the `try` intrinsic
87 // in the compiler.
88 //
89 // The interaction between the `payload` function and the compiler is pretty
90 // hairy and tightly coupled, for more information see the compiler's
91 // implementation of this.
92 #[no_mangle]
93 pub unsafe extern "C" fn __rust_maybe_catch_panic(f: fn(*mut u8),
94                                                   data: *mut u8,
95                                                   data_ptr: *mut usize,
96                                                   vtable_ptr: *mut usize)
97                                                   -> u32 {
98     let mut payload = imp::payload();
99     if intrinsics::try(f, data, &mut payload as *mut _ as *mut _) == 0 {
100         0
101     } else {
102         let obj = mem::transmute::<_, raw::TraitObject>(imp::cleanup(payload));
103         *data_ptr = obj.data as usize;
104         *vtable_ptr = obj.vtable as usize;
105         1
106     }
107 }
108
109 // Entry point for raising an exception, just delegates to the platform-specific
110 // implementation.
111 #[no_mangle]
112 #[unwind]
113 pub unsafe extern "C" fn __rust_start_panic(data: usize, vtable: usize) -> u32 {
114     imp::panic(mem::transmute(raw::TraitObject {
115         data: data as *mut (),
116         vtable: vtable as *mut (),
117     }))
118 }