1 //! Implementation of various bits and pieces of the `panic!` macro and
2 //! associated runtime pieces.
4 //! Specifically, this module contains the implementation of:
7 //! * Executing a panic up to doing the actual implementation
8 //! * Shims around "try"
10 use core::panic::{BoxMeUp, PanicInfo, Location};
14 use crate::intrinsics;
15 use crate::mem::{self, ManuallyDrop};
17 use crate::sync::atomic::{AtomicBool, Ordering};
18 use crate::sys::stdio::panic_output;
19 use crate::sys_common::rwlock::RWLock;
20 use crate::sys_common::{thread_info, util};
21 use crate::sys_common::backtrace::{self, RustBacktrace};
26 use crate::io::set_panic;
27 // make sure to use the stderr output configured
28 // by libtest in the real copy of std
30 use realstd::io::set_panic;
32 // Binary interface to the panic runtime that the standard library depends on.
34 // The standard library is tagged with `#![needs_panic_runtime]` (introduced in
35 // RFC 1513) to indicate that it requires some other crate tagged with
36 // `#![panic_runtime]` to exist somewhere. Each panic runtime is intended to
37 // implement these symbols (with the same signatures) so we can get matched up
40 // One day this may look a little less ad-hoc with the compiler helping out to
41 // hook up these functions, but it is not this day!
42 #[allow(improper_ctypes)]
44 fn __rust_maybe_catch_panic(f: fn(*mut u8),
47 vtable_ptr: *mut usize) -> u32;
49 /// `payload` is actually a `*mut &mut dyn BoxMeUp` but that would cause FFI warnings.
50 /// It cannot be `Box<dyn BoxMeUp>` because the other end of this call does not depend
51 /// on liballoc, and thus cannot use `Box`.
53 fn __rust_start_panic(payload: usize) -> u32;
56 #[derive(Copy, Clone)]
59 Custom(*mut (dyn Fn(&PanicInfo<'_>) + 'static + Sync + Send)),
62 static HOOK_LOCK: RWLock = RWLock::new();
63 static mut HOOK: Hook = Hook::Default;
65 /// Registers a custom panic hook, replacing any that was previously registered.
67 /// The panic hook is invoked when a thread panics, but before the panic runtime
68 /// is invoked. As such, the hook will run with both the aborting and unwinding
69 /// runtimes. The default hook prints a message to standard error and generates
70 /// a backtrace if requested, but this behavior can be customized with the
71 /// `set_hook` and [`take_hook`] functions.
73 /// [`take_hook`]: ./fn.take_hook.html
75 /// The hook is provided with a `PanicInfo` struct which contains information
76 /// about the origin of the panic, including the payload passed to `panic!` and
77 /// the source code location from which the panic originated.
79 /// The panic hook is a global resource.
83 /// Panics if called from a panicking thread.
87 /// The following will print "Custom panic hook":
92 /// panic::set_hook(Box::new(|_| {
93 /// println!("Custom panic hook");
96 /// panic!("Normal panic");
98 #[stable(feature = "panic_hooks", since = "1.10.0")]
99 pub fn set_hook(hook: Box<dyn Fn(&PanicInfo<'_>) + 'static + Sync + Send>) {
100 if thread::panicking() {
101 panic!("cannot modify the panic hook from a panicking thread");
107 HOOK = Hook::Custom(Box::into_raw(hook));
108 HOOK_LOCK.write_unlock();
110 if let Hook::Custom(ptr) = old_hook {
111 #[allow(unused_must_use)] {
118 /// Unregisters the current panic hook, returning it.
120 /// *See also the function [`set_hook`].*
122 /// [`set_hook`]: ./fn.set_hook.html
124 /// If no custom hook is registered, the default hook will be returned.
128 /// Panics if called from a panicking thread.
132 /// The following will print "Normal panic":
137 /// panic::set_hook(Box::new(|_| {
138 /// println!("Custom panic hook");
141 /// let _ = panic::take_hook();
143 /// panic!("Normal panic");
145 #[stable(feature = "panic_hooks", since = "1.10.0")]
146 pub fn take_hook() -> Box<dyn Fn(&PanicInfo<'_>) + 'static + Sync + Send> {
147 if thread::panicking() {
148 panic!("cannot modify the panic hook from a panicking thread");
154 HOOK = Hook::Default;
155 HOOK_LOCK.write_unlock();
158 Hook::Default => Box::new(default_hook),
159 Hook::Custom(ptr) => Box::from_raw(ptr),
164 fn default_hook(info: &PanicInfo<'_>) {
165 // If this is a double panic, make sure that we print a backtrace
166 // for this panic. Otherwise only print it if logging is enabled.
167 let backtrace_env = if update_panic_count(0) >= 2 {
168 RustBacktrace::Print(backtrace_rs::PrintFmt::Full)
170 backtrace::rust_backtrace_env()
173 // The current implementation always returns `Some`.
174 let location = info.location().unwrap();
176 let msg = match info.payload().downcast_ref::<&'static str>() {
178 None => match info.payload().downcast_ref::<String>() {
183 let thread = thread_info::current_thread();
184 let name = thread.as_ref().and_then(|t| t.name()).unwrap_or("<unnamed>");
186 let write = |err: &mut dyn crate::io::Write| {
187 let _ = writeln!(err, "thread '{}' panicked at '{}', {}",
188 name, msg, location);
190 static FIRST_PANIC: AtomicBool = AtomicBool::new(true);
192 match backtrace_env {
193 RustBacktrace::Print(format) => drop(backtrace::print(err, format)),
194 RustBacktrace::Disabled => {}
195 RustBacktrace::RuntimeDisabled => {
196 if FIRST_PANIC.swap(false, Ordering::SeqCst) {
197 let _ = writeln!(err, "note: run with `RUST_BACKTRACE=1` \
198 environment variable to display a backtrace.");
204 if let Some(mut local) = set_panic(None) {
205 // NB. In `cfg(test)` this uses the forwarding impl
206 // for `Box<dyn (::realstd::io::Write) + Send>`.
208 set_panic(Some(local));
209 } else if let Some(mut out) = panic_output() {
217 #[unstable(feature = "update_panic_count", issue = "none")]
218 pub fn update_panic_count(amt: isize) -> usize {
219 use crate::cell::Cell;
220 thread_local! { static PANIC_COUNT: Cell<usize> = Cell::new(0) }
222 PANIC_COUNT.with(|c| {
223 let next = (c.get() as isize + amt) as usize;
230 pub use realstd::rt::update_panic_count;
232 /// Invoke a closure, capturing the cause of an unwinding panic if one occurs.
233 pub unsafe fn r#try<R, F: FnOnce() -> R>(f: F) -> Result<R, Box<dyn Any + Send>> {
239 // We do some sketchy operations with ownership here for the sake of
240 // performance. We can only pass pointers down to
241 // `__rust_maybe_catch_panic` (can't pass objects by value), so we do all
242 // the ownership tracking here manually using a union.
244 // We go through a transition where:
246 // * First, we set the data to be the closure that we're going to call.
247 // * When we make the function call, the `do_call` function below, we take
248 // ownership of the function pointer. At this point the `Data` union is
249 // entirely uninitialized.
250 // * If the closure successfully returns, we write the return value into the
251 // data's return slot. Note that `ptr::write` is used as it's overwriting
252 // uninitialized data.
253 // * Finally, when we come back out of the `__rust_maybe_catch_panic` we're
254 // in one of two states:
256 // 1. The closure didn't panic, in which case the return value was
257 // filled in. We move it out of `data` and return it.
258 // 2. The closure panicked, in which case the return value wasn't
259 // filled in. In this case the entire `data` union is invalid, so
260 // there is no need to drop anything.
262 // Once we stack all that together we should have the "most efficient'
263 // method of calling a catch panic whilst juggling ownership.
264 let mut any_data = 0;
265 let mut any_vtable = 0;
266 let mut data = Data {
267 f: ManuallyDrop::new(f)
270 let r = __rust_maybe_catch_panic(do_call::<F, R>,
271 &mut data as *mut _ as *mut u8,
276 debug_assert!(update_panic_count(0) == 0);
277 Ok(ManuallyDrop::into_inner(data.r))
279 update_panic_count(-1);
280 debug_assert!(update_panic_count(0) == 0);
281 Err(mem::transmute(raw::TraitObject {
282 data: any_data as *mut _,
283 vtable: any_vtable as *mut _,
287 fn do_call<F: FnOnce() -> R, R>(data: *mut u8) {
289 let data = data as *mut Data<F, R>;
290 let data = &mut (*data);
291 let f = ManuallyDrop::take(&mut data.f);
292 data.r = ManuallyDrop::new(f());
297 /// Determines whether the current thread is unwinding because of panic.
298 pub fn panicking() -> bool {
299 update_panic_count(0) != 0
302 /// The entry point for panicking with a formatted message.
304 /// This is designed to reduce the amount of code required at the call
305 /// site as much as possible (so that `panic!()` has as low an impact
306 /// on (e.g.) the inlining of other functions as possible), by moving
307 /// the actual formatting into this shared place.
308 #[unstable(feature = "libstd_sys_internals",
309 reason = "used by the panic! macro",
312 // If panic_immediate_abort, inline the abort call,
313 // otherwise avoid inlining because of it is cold path.
314 #[cfg_attr(not(feature="panic_immediate_abort"),inline(never))]
315 #[cfg_attr( feature="panic_immediate_abort" ,inline)]
316 pub fn begin_panic_fmt(msg: &fmt::Arguments<'_>,
317 file_line_col: &(&'static str, u32, u32)) -> ! {
318 if cfg!(feature = "panic_immediate_abort") {
319 unsafe { intrinsics::abort() }
322 // Just package everything into a `PanicInfo` and continue like libcore panics.
323 let (file, line, col) = *file_line_col;
324 let location = Location::internal_constructor(file, line, col);
325 let info = PanicInfo::internal_constructor(Some(msg), &location);
326 begin_panic_handler(&info)
329 /// Entry point of panics from the libcore crate (`panic_impl` lang item).
330 #[cfg_attr(not(test), panic_handler)]
332 pub fn begin_panic_handler(info: &PanicInfo<'_>) -> ! {
333 struct PanicPayload<'a> {
334 inner: &'a fmt::Arguments<'a>,
335 string: Option<String>,
338 impl<'a> PanicPayload<'a> {
339 fn new(inner: &'a fmt::Arguments<'a>) -> PanicPayload<'a> {
340 PanicPayload { inner, string: None }
343 fn fill(&mut self) -> &mut String {
344 use crate::fmt::Write;
346 let inner = self.inner;
347 // Lazily, the first time this gets called, run the actual string formatting.
348 self.string.get_or_insert_with(|| {
349 let mut s = String::new();
350 drop(s.write_fmt(*inner));
356 unsafe impl<'a> BoxMeUp for PanicPayload<'a> {
357 fn take_box(&mut self) -> *mut (dyn Any + Send) {
358 let contents = mem::take(self.fill());
359 Box::into_raw(Box::new(contents))
362 fn get(&mut self) -> &(dyn Any + Send) {
367 // We do two allocations here, unfortunately. But (a) they're
368 // required with the current scheme, and (b) we don't handle
369 // panic + OOM properly anyway (see comment in begin_panic
372 let loc = info.location().unwrap(); // The current implementation always returns Some
373 let msg = info.message().unwrap(); // The current implementation always returns Some
374 let file_line_col = (loc.file(), loc.line(), loc.column());
375 rust_panic_with_hook(
376 &mut PanicPayload::new(msg),
381 /// This is the entry point of panicking for the non-format-string variants of
382 /// panic!() and assert!(). In particular, this is the only entry point that supports
383 /// arbitrary payloads, not just format strings.
384 #[unstable(feature = "libstd_sys_internals",
385 reason = "used by the panic! macro",
387 #[cfg_attr(not(test), lang = "begin_panic")] // lang item for CTFE panic support
388 // never inline unless panic_immediate_abort to avoid code
389 // bloat at the call sites as much as possible
390 #[cfg_attr(not(feature="panic_immediate_abort"),inline(never))]
392 pub fn begin_panic<M: Any + Send>(msg: M, file_line_col: &(&'static str, u32, u32)) -> ! {
393 if cfg!(feature = "panic_immediate_abort") {
394 unsafe { intrinsics::abort() }
397 // Note that this should be the only allocation performed in this code path.
398 // Currently this means that panic!() on OOM will invoke this code path,
399 // but then again we're not really ready for panic on OOM anyway. If
400 // we do start doing this, then we should propagate this allocation to
401 // be performed in the parent of this thread instead of the thread that's
404 rust_panic_with_hook(&mut PanicPayload::new(msg), None, file_line_col);
406 struct PanicPayload<A> {
410 impl<A: Send + 'static> PanicPayload<A> {
411 fn new(inner: A) -> PanicPayload<A> {
412 PanicPayload { inner: Some(inner) }
416 unsafe impl<A: Send + 'static> BoxMeUp for PanicPayload<A> {
417 fn take_box(&mut self) -> *mut (dyn Any + Send) {
418 let data = match self.inner.take() {
419 Some(a) => Box::new(a) as Box<dyn Any + Send>,
420 None => process::abort(),
425 fn get(&mut self) -> &(dyn Any + Send) {
428 None => process::abort(),
434 /// Central point for dispatching panics.
436 /// Executes the primary logic for a panic, including checking for recursive
437 /// panics, panic hooks, and finally dispatching to the panic runtime to either
439 fn rust_panic_with_hook(payload: &mut dyn BoxMeUp,
440 message: Option<&fmt::Arguments<'_>>,
441 file_line_col: &(&str, u32, u32)) -> ! {
442 let (file, line, col) = *file_line_col;
444 let panics = update_panic_count(1);
446 // If this is the third nested call (e.g., panics == 2, this is 0-indexed),
447 // the panic hook probably triggered the last panic, otherwise the
448 // double-panic check would have aborted the process. In this case abort the
449 // process real quickly as we don't want to try calling it again as it'll
450 // probably just panic again.
452 util::dumb_print(format_args!("thread panicked while processing \
453 panic. aborting.\n"));
454 unsafe { intrinsics::abort() }
458 let location = Location::internal_constructor(file, line, col);
459 let mut info = PanicInfo::internal_constructor(message, &location);
462 // Some platforms (like wasm) know that printing to stderr won't ever actually
463 // print anything, and if that's the case we can skip the default
464 // hook. Since string formatting happens lazily when calling `payload`
465 // methods, this means we avoid formatting the string at all!
466 // (The panic runtime might still call `payload.take_box()` though and trigger
468 Hook::Default if panic_output().is_none() => {}
470 info.set_payload(payload.get());
473 Hook::Custom(ptr) => {
474 info.set_payload(payload.get());
478 HOOK_LOCK.read_unlock();
482 // If a thread panics while it's already unwinding then we
483 // have limited options. Currently our preference is to
484 // just abort. In the future we may consider resuming
485 // unwinding or otherwise exiting the thread cleanly.
486 util::dumb_print(format_args!("thread panicked while panicking. \
488 unsafe { intrinsics::abort() }
494 /// This is the entry point for `resume_unwind`.
495 /// It just forwards the payload to the panic runtime.
496 pub fn rust_panic_without_hook(payload: Box<dyn Any + Send>) -> ! {
497 update_panic_count(1);
499 struct RewrapBox(Box<dyn Any + Send>);
501 unsafe impl BoxMeUp for RewrapBox {
502 fn take_box(&mut self) -> *mut (dyn Any + Send) {
503 Box::into_raw(mem::replace(&mut self.0, Box::new(())))
506 fn get(&mut self) -> &(dyn Any + Send) {
511 rust_panic(&mut RewrapBox(payload))
514 /// An unmangled function (through `rustc_std_internal_symbol`) on which to slap
517 #[cfg_attr(not(test), rustc_std_internal_symbol)]
518 fn rust_panic(mut msg: &mut dyn BoxMeUp) -> ! {
520 let obj = &mut msg as *mut &mut dyn BoxMeUp;
521 __rust_start_panic(obj as usize)
523 rtabort!("failed to initiate panic, error {}", code)