mirror of
https://github.com/rust-lang/rust.git
synced 2025-11-01 21:45:15 +00:00
9c9a0da132
Guard against panic payloads panicking within entrypoints, where it is UB to do so. Note that there are a number of implementation approaches to consider. Some simpler, some more complicated. This particular solution is nice in that it also guards against accidental implementation issues in various pieces of runtime code, something we cannot prevent statically right now. Fixes #86030
69 lines
2.6 KiB
Rust
69 lines
2.6 KiB
Rust
//! Runtime services
|
|
//!
|
|
//! The `rt` module provides a narrow set of runtime services,
|
|
//! including the global heap (exported in `heap`) and unwinding and
|
|
//! backtrace support. The APIs in this module are highly unstable,
|
|
//! and should be considered as private implementation details for the
|
|
//! time being.
|
|
|
|
#![unstable(
|
|
feature = "rt",
|
|
reason = "this public module should not exist and is highly likely \
|
|
to disappear",
|
|
issue = "none"
|
|
)]
|
|
#![doc(hidden)]
|
|
|
|
// Re-export some of our utilities which are expected by other crates.
|
|
pub use crate::panicking::{begin_panic, begin_panic_fmt, panic_count};
|
|
|
|
// To reduce the generated code of the new `lang_start`, this function is doing
|
|
// the real work.
|
|
#[cfg(not(test))]
|
|
fn lang_start_internal(
|
|
main: &(dyn Fn() -> i32 + Sync + crate::panic::RefUnwindSafe),
|
|
argc: isize,
|
|
argv: *const *const u8,
|
|
) -> Result<isize, !> {
|
|
use crate::{mem, panic, sys, sys_common};
|
|
let rt_abort = move |e| {
|
|
mem::forget(e);
|
|
rtabort!("initialization or cleanup bug");
|
|
};
|
|
// Guard against the code called by this function from unwinding outside of the Rust-controlled
|
|
// code, which is UB. This is a requirement imposed by a combination of how the
|
|
// `#[lang="start"]` attribute is implemented as well as by the implementation of the panicking
|
|
// mechanism itself.
|
|
//
|
|
// There are a couple of instances where unwinding can begin. First is inside of the
|
|
// `rt::init`, `rt::cleanup` and similar functions controlled by libstd. In those instances a
|
|
// panic is a libstd implementation bug. A quite likely one too, as there isn't any way to
|
|
// prevent libstd from accidentally introducing a panic to these functions. Another is from
|
|
// user code from `main` or, more nefariously, as described in e.g. issue #86030.
|
|
// SAFETY: Only called once during runtime initialization.
|
|
panic::catch_unwind(move || unsafe { sys_common::rt::init(argc, argv) }).map_err(rt_abort)?;
|
|
let ret_code = panic::catch_unwind(move || panic::catch_unwind(main).unwrap_or(101) as isize)
|
|
.map_err(move |e| {
|
|
mem::forget(e);
|
|
rtprintpanic!("drop of the panic payload panicked");
|
|
sys::abort_internal()
|
|
});
|
|
panic::catch_unwind(sys_common::rt::cleanup).map_err(rt_abort)?;
|
|
ret_code
|
|
}
|
|
|
|
#[cfg(not(test))]
|
|
#[lang = "start"]
|
|
fn lang_start<T: crate::process::Termination + 'static>(
|
|
main: fn() -> T,
|
|
argc: isize,
|
|
argv: *const *const u8,
|
|
) -> isize {
|
|
lang_start_internal(
|
|
&move || crate::sys_common::backtrace::__rust_begin_short_backtrace(main).report(),
|
|
argc,
|
|
argv,
|
|
)
|
|
.into_ok()
|
|
}
|