1
Fork 0

Rollup merge of #116008 - m-ou-se:boxmeup, r=oli-obk

Rename BoxMeUp to PanicPayload.

"BoxMeUp" is not very clear. Let's rename that to a description of what it actually represents: a panic payload.

This PR also renames the structs that implement this trait to have more descriptive names.

Part of https://github.com/rust-lang/rust/issues/116005

r? `@oli-obk`
This commit is contained in:
Matthias Krüger 2023-09-21 00:11:37 +02:00 committed by GitHub
commit 6bcae4c93e
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
5 changed files with 29 additions and 29 deletions

View file

@ -99,7 +99,7 @@ pub macro unreachable_2021 {
/// use. /// use.
#[unstable(feature = "std_internals", issue = "none")] #[unstable(feature = "std_internals", issue = "none")]
#[doc(hidden)] #[doc(hidden)]
pub unsafe trait BoxMeUp { pub unsafe trait PanicPayload {
/// Take full ownership of the contents. /// Take full ownership of the contents.
/// The return type is actually `Box<dyn Any + Send>`, but we cannot use `Box` in core. /// The return type is actually `Box<dyn Any + Send>`, but we cannot use `Box` in core.
/// ///
@ -107,7 +107,7 @@ pub unsafe trait BoxMeUp {
/// Calling this method twice, or calling `get` after calling this method, is an error. /// Calling this method twice, or calling `get` after calling this method, is an error.
/// ///
/// The argument is borrowed because the panic runtime (`__rust_start_panic`) only /// The argument is borrowed because the panic runtime (`__rust_start_panic`) only
/// gets a borrowed `dyn BoxMeUp`. /// gets a borrowed `dyn PanicPayload`.
fn take_box(&mut self) -> *mut (dyn Any + Send); fn take_box(&mut self) -> *mut (dyn Any + Send);
/// Just borrow the contents. /// Just borrow the contents.

View file

@ -1,6 +1,6 @@
use alloc::string::String; use alloc::string::String;
use core::mem::transmute; use core::mem::transmute;
use core::panic::BoxMeUp; use core::panic::PanicPayload;
use core::ptr::copy_nonoverlapping; use core::ptr::copy_nonoverlapping;
const ANDROID_SET_ABORT_MESSAGE: &[u8] = b"android_set_abort_message\0"; const ANDROID_SET_ABORT_MESSAGE: &[u8] = b"android_set_abort_message\0";
@ -15,7 +15,7 @@ type SetAbortMessageType = unsafe extern "C" fn(*const libc::c_char) -> ();
// //
// Weakly resolve the symbol for android_set_abort_message. This function is only available // Weakly resolve the symbol for android_set_abort_message. This function is only available
// for API >= 21. // for API >= 21.
pub(crate) unsafe fn android_set_abort_message(payload: &mut dyn BoxMeUp) { pub(crate) unsafe fn android_set_abort_message(payload: &mut dyn PanicPayload) {
let func_addr = let func_addr =
libc::dlsym(libc::RTLD_DEFAULT, ANDROID_SET_ABORT_MESSAGE.as_ptr() as *const libc::c_char) libc::dlsym(libc::RTLD_DEFAULT, ANDROID_SET_ABORT_MESSAGE.as_ptr() as *const libc::c_char)
as usize; as usize;

View file

@ -20,7 +20,7 @@
mod android; mod android;
use core::any::Any; use core::any::Any;
use core::panic::BoxMeUp; use core::panic::PanicPayload;
#[rustc_std_internal_symbol] #[rustc_std_internal_symbol]
#[allow(improper_ctypes_definitions)] #[allow(improper_ctypes_definitions)]
@ -30,7 +30,7 @@ pub unsafe extern "C" fn __rust_panic_cleanup(_: *mut u8) -> *mut (dyn Any + Sen
// "Leak" the payload and shim to the relevant abort on the platform in question. // "Leak" the payload and shim to the relevant abort on the platform in question.
#[rustc_std_internal_symbol] #[rustc_std_internal_symbol]
pub unsafe fn __rust_start_panic(_payload: &mut dyn BoxMeUp) -> u32 { pub unsafe fn __rust_start_panic(_payload: &mut dyn PanicPayload) -> u32 {
// Android has the ability to attach a message as part of the abort. // Android has the ability to attach a message as part of the abort.
#[cfg(target_os = "android")] #[cfg(target_os = "android")]
android::android_set_abort_message(_payload); android::android_set_abort_message(_payload);

View file

@ -29,7 +29,7 @@
use alloc::boxed::Box; use alloc::boxed::Box;
use core::any::Any; use core::any::Any;
use core::panic::BoxMeUp; use core::panic::PanicPayload;
cfg_if::cfg_if! { cfg_if::cfg_if! {
if #[cfg(target_os = "emscripten")] { if #[cfg(target_os = "emscripten")] {
@ -99,7 +99,7 @@ pub unsafe extern "C" fn __rust_panic_cleanup(payload: *mut u8) -> *mut (dyn Any
// Entry point for raising an exception, just delegates to the platform-specific // Entry point for raising an exception, just delegates to the platform-specific
// implementation. // implementation.
#[rustc_std_internal_symbol] #[rustc_std_internal_symbol]
pub unsafe fn __rust_start_panic(payload: &mut dyn BoxMeUp) -> u32 { pub unsafe fn __rust_start_panic(payload: &mut dyn PanicPayload) -> u32 {
let payload = Box::from_raw(payload.take_box()); let payload = Box::from_raw(payload.take_box());
imp::panic(payload) imp::panic(payload)

View file

@ -10,7 +10,7 @@
#![deny(unsafe_op_in_unsafe_fn)] #![deny(unsafe_op_in_unsafe_fn)]
use crate::panic::BacktraceStyle; use crate::panic::BacktraceStyle;
use core::panic::{BoxMeUp, Location, PanicInfo}; use core::panic::{Location, PanicInfo, PanicPayload};
use crate::any::Any; use crate::any::Any;
use crate::fmt; use crate::fmt;
@ -47,9 +47,9 @@ extern "C" {
} }
extern "Rust" { extern "Rust" {
/// `BoxMeUp` lazily performs allocation only when needed (this avoids /// `PanicPayload` lazily performs allocation only when needed (this avoids
/// allocations when using the "abort" panic runtime). /// allocations when using the "abort" panic runtime).
fn __rust_start_panic(payload: &mut dyn BoxMeUp) -> u32; fn __rust_start_panic(payload: &mut dyn PanicPayload) -> u32;
} }
/// This function is called by the panic runtime if FFI code catches a Rust /// This function is called by the panic runtime if FFI code catches a Rust
@ -543,14 +543,14 @@ pub fn panicking() -> bool {
#[cfg(not(test))] #[cfg(not(test))]
#[panic_handler] #[panic_handler]
pub fn begin_panic_handler(info: &PanicInfo<'_>) -> ! { pub fn begin_panic_handler(info: &PanicInfo<'_>) -> ! {
struct PanicPayload<'a> { struct FormatStringPayload<'a> {
inner: &'a fmt::Arguments<'a>, inner: &'a fmt::Arguments<'a>,
string: Option<String>, string: Option<String>,
} }
impl<'a> PanicPayload<'a> { impl<'a> FormatStringPayload<'a> {
fn new(inner: &'a fmt::Arguments<'a>) -> PanicPayload<'a> { fn new(inner: &'a fmt::Arguments<'a>) -> Self {
PanicPayload { inner, string: None } Self { inner, string: None }
} }
fn fill(&mut self) -> &mut String { fn fill(&mut self) -> &mut String {
@ -566,7 +566,7 @@ pub fn begin_panic_handler(info: &PanicInfo<'_>) -> ! {
} }
} }
unsafe impl<'a> BoxMeUp for PanicPayload<'a> { unsafe impl<'a> PanicPayload for FormatStringPayload<'a> {
fn take_box(&mut self) -> *mut (dyn Any + Send) { fn take_box(&mut self) -> *mut (dyn Any + Send) {
// We do two allocations here, unfortunately. But (a) they're required with the current // We do two allocations here, unfortunately. But (a) they're required with the current
// scheme, and (b) we don't handle panic + OOM properly anyway (see comment in // scheme, and (b) we don't handle panic + OOM properly anyway (see comment in
@ -580,9 +580,9 @@ pub fn begin_panic_handler(info: &PanicInfo<'_>) -> ! {
} }
} }
struct StrPanicPayload(&'static str); struct StaticStrPayload(&'static str);
unsafe impl BoxMeUp for StrPanicPayload { unsafe impl PanicPayload for StaticStrPayload {
fn take_box(&mut self) -> *mut (dyn Any + Send) { fn take_box(&mut self) -> *mut (dyn Any + Send) {
Box::into_raw(Box::new(self.0)) Box::into_raw(Box::new(self.0))
} }
@ -599,7 +599,7 @@ pub fn begin_panic_handler(info: &PanicInfo<'_>) -> ! {
// `rust_panic_with_hook` construct a new `PanicInfo`? // `rust_panic_with_hook` construct a new `PanicInfo`?
if let Some(msg) = msg.as_str() { if let Some(msg) = msg.as_str() {
rust_panic_with_hook( rust_panic_with_hook(
&mut StrPanicPayload(msg), &mut StaticStrPayload(msg),
info.message(), info.message(),
loc, loc,
info.can_unwind(), info.can_unwind(),
@ -607,7 +607,7 @@ pub fn begin_panic_handler(info: &PanicInfo<'_>) -> ! {
); );
} else { } else {
rust_panic_with_hook( rust_panic_with_hook(
&mut PanicPayload::new(msg), &mut FormatStringPayload::new(msg),
info.message(), info.message(),
loc, loc,
info.can_unwind(), info.can_unwind(),
@ -637,7 +637,7 @@ pub const fn begin_panic<M: Any + Send>(msg: M) -> ! {
let loc = Location::caller(); let loc = Location::caller();
return crate::sys_common::backtrace::__rust_end_short_backtrace(move || { return crate::sys_common::backtrace::__rust_end_short_backtrace(move || {
rust_panic_with_hook( rust_panic_with_hook(
&mut PanicPayload::new(msg), &mut Payload::new(msg),
None, None,
loc, loc,
/* can_unwind */ true, /* can_unwind */ true,
@ -645,17 +645,17 @@ pub const fn begin_panic<M: Any + Send>(msg: M) -> ! {
) )
}); });
struct PanicPayload<A> { struct Payload<A> {
inner: Option<A>, inner: Option<A>,
} }
impl<A: Send + 'static> PanicPayload<A> { impl<A: Send + 'static> Payload<A> {
fn new(inner: A) -> PanicPayload<A> { fn new(inner: A) -> Payload<A> {
PanicPayload { inner: Some(inner) } Payload { inner: Some(inner) }
} }
} }
unsafe impl<A: Send + 'static> BoxMeUp for PanicPayload<A> { unsafe impl<A: Send + 'static> PanicPayload for Payload<A> {
fn take_box(&mut self) -> *mut (dyn Any + Send) { fn take_box(&mut self) -> *mut (dyn Any + Send) {
// Note that this should be the only allocation performed in this code path. Currently // Note that this should be the only allocation performed in this code path. Currently
// this means that panic!() on OOM will invoke this code path, but then again we're not // this means that panic!() on OOM will invoke this code path, but then again we're not
@ -684,7 +684,7 @@ pub const fn begin_panic<M: Any + Send>(msg: M) -> ! {
/// panics, panic hooks, and finally dispatching to the panic runtime to either /// panics, panic hooks, and finally dispatching to the panic runtime to either
/// abort or unwind. /// abort or unwind.
fn rust_panic_with_hook( fn rust_panic_with_hook(
payload: &mut dyn BoxMeUp, payload: &mut dyn PanicPayload,
message: Option<&fmt::Arguments<'_>>, message: Option<&fmt::Arguments<'_>>,
location: &Location<'_>, location: &Location<'_>,
can_unwind: bool, can_unwind: bool,
@ -760,7 +760,7 @@ pub fn rust_panic_without_hook(payload: Box<dyn Any + Send>) -> ! {
struct RewrapBox(Box<dyn Any + Send>); struct RewrapBox(Box<dyn Any + Send>);
unsafe impl BoxMeUp for RewrapBox { unsafe impl PanicPayload for RewrapBox {
fn take_box(&mut self) -> *mut (dyn Any + Send) { fn take_box(&mut self) -> *mut (dyn Any + Send) {
Box::into_raw(mem::replace(&mut self.0, Box::new(()))) Box::into_raw(mem::replace(&mut self.0, Box::new(())))
} }
@ -777,7 +777,7 @@ pub fn rust_panic_without_hook(payload: Box<dyn Any + Send>) -> ! {
/// yer breakpoints. /// yer breakpoints.
#[inline(never)] #[inline(never)]
#[cfg_attr(not(test), rustc_std_internal_symbol)] #[cfg_attr(not(test), rustc_std_internal_symbol)]
fn rust_panic(msg: &mut dyn BoxMeUp) -> ! { fn rust_panic(msg: &mut dyn PanicPayload) -> ! {
let code = unsafe { __rust_start_panic(msg) }; let code = unsafe { __rust_start_panic(msg) };
rtabort!("failed to initiate panic, error {code}") rtabort!("failed to initiate panic, error {code}")
} }