aboutsummaryrefslogtreecommitdiff
path: root/ctr-std/src/panicking.rs
diff options
context:
space:
mode:
Diffstat (limited to 'ctr-std/src/panicking.rs')
-rw-r--r--ctr-std/src/panicking.rs132
1 files changed, 48 insertions, 84 deletions
diff --git a/ctr-std/src/panicking.rs b/ctr-std/src/panicking.rs
index 321d634..4cdde2b 100644
--- a/ctr-std/src/panicking.rs
+++ b/ctr-std/src/panicking.rs
@@ -36,7 +36,7 @@ use sys_common::util;
use thread;
thread_local! {
- pub static LOCAL_STDERR: RefCell<Option<Box<Write + Send>>> = {
+ pub static LOCAL_STDERR: RefCell<Option<Box<dyn Write + Send>>> = {
RefCell::new(None)
}
}
@@ -64,7 +64,7 @@ extern {
#[derive(Copy, Clone)]
enum Hook {
Default,
- Custom(*mut (Fn(&PanicInfo) + 'static + Sync + Send)),
+ Custom(*mut (dyn Fn(&PanicInfo) + 'static + Sync + Send)),
}
static HOOK_LOCK: RWLock = RWLock::new();
@@ -104,7 +104,7 @@ static mut HOOK: Hook = Hook::Default;
/// panic!("Normal panic");
/// ```
#[stable(feature = "panic_hooks", since = "1.10.0")]
-pub fn set_hook(hook: Box<Fn(&PanicInfo) + 'static + Sync + Send>) {
+pub fn set_hook(hook: Box<dyn Fn(&PanicInfo) + 'static + Sync + Send>) {
if thread::panicking() {
panic!("cannot modify the panic hook from a panicking thread");
}
@@ -149,7 +149,7 @@ pub fn set_hook(hook: Box<Fn(&PanicInfo) + 'static + Sync + Send>) {
/// panic!("Normal panic");
/// ```
#[stable(feature = "panic_hooks", since = "1.10.0")]
-pub fn take_hook() -> Box<Fn(&PanicInfo) + 'static + Sync + Send> {
+pub fn take_hook() -> Box<dyn Fn(&PanicInfo) + 'static + Sync + Send> {
if thread::panicking() {
panic!("cannot modify the panic hook from a panicking thread");
}
@@ -222,7 +222,7 @@ fn default_hook(info: &PanicInfo) {
consoleDebugInit(debugDevice_SVC);
}
- let write = |err: &mut ::io::Write| {
+ let write = |err: &mut dyn (::io::Write)| {
let _ = writeln!(err, "thread '{}' panicked at '{}', {}",
name, msg, location);
@@ -273,7 +273,7 @@ pub fn update_panic_count(amt: isize) -> usize {
pub use realstd::rt::update_panic_count;
/// Invoke a closure, capturing the cause of an unwinding panic if one occurs.
-pub unsafe fn try<R, F: FnOnce() -> R>(f: F) -> Result<R, Box<Any + Send>> {
+pub unsafe fn try<R, F: FnOnce() -> R>(f: F) -> Result<R, Box<dyn Any + Send>> {
#[allow(unions_with_drop_fields)]
union Data<F, R> {
f: F,
@@ -344,18 +344,6 @@ pub fn panicking() -> bool {
/// Entry point of panic from the libcore crate.
#[cfg(not(test))]
-#[cfg(stage0)]
-#[lang = "panic_fmt"]
-pub extern fn rust_begin_panic(msg: fmt::Arguments,
- file: &'static str,
- line: u32,
- col: u32) -> ! {
- begin_panic_fmt(&msg, &(file, line, col))
-}
-
-/// Entry point of panic from the libcore crate.
-#[cfg(not(test))]
-#[cfg(not(stage0))]
#[panic_implementation]
#[unwind(allowed)]
pub fn rust_begin_panic(info: &PanicInfo) -> ! {
@@ -368,78 +356,54 @@ pub fn rust_begin_panic(info: &PanicInfo) -> ! {
/// site as much as possible (so that `panic!()` has as low an impact
/// on (e.g.) the inlining of other functions as possible), by moving
/// the actual formatting into this shared place.
-#[cfg(stage0)]
#[unstable(feature = "libstd_sys_internals",
reason = "used by the panic! macro",
issue = "0")]
#[inline(never)] #[cold]
pub fn begin_panic_fmt(msg: &fmt::Arguments,
file_line_col: &(&'static str, u32, u32)) -> ! {
- // 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 begin_panic
- // below).
-
- rust_panic_with_hook(&mut PanicPayload::new(msg), Some(msg), file_line_col);
-}
-
-// NOTE(stage0) move into `continue_panic_fmt` on next stage0 update
-struct PanicPayload<'a> {
- inner: &'a fmt::Arguments<'a>,
- string: Option<String>,
+ let (file, line, col) = *file_line_col;
+ let info = PanicInfo::internal_constructor(
+ Some(msg),
+ Location::internal_constructor(file, line, col),
+ );
+ continue_panic_fmt(&info)
}
-impl<'a> PanicPayload<'a> {
- fn new(inner: &'a fmt::Arguments<'a>) -> PanicPayload<'a> {
- PanicPayload { inner, string: None }
+fn continue_panic_fmt(info: &PanicInfo) -> ! {
+ struct PanicPayload<'a> {
+ inner: &'a fmt::Arguments<'a>,
+ string: Option<String>,
}
- fn fill(&mut self) -> &mut String {
- use fmt::Write;
+ impl<'a> PanicPayload<'a> {
+ fn new(inner: &'a fmt::Arguments<'a>) -> PanicPayload<'a> {
+ PanicPayload { inner, string: None }
+ }
- let inner = self.inner;
- self.string.get_or_insert_with(|| {
- let mut s = String::new();
- drop(s.write_fmt(*inner));
- s
- })
- }
-}
+ fn fill(&mut self) -> &mut String {
+ use fmt::Write;
-unsafe impl<'a> BoxMeUp for PanicPayload<'a> {
- fn box_me_up(&mut self) -> *mut (Any + Send) {
- let contents = mem::replace(self.fill(), String::new());
- Box::into_raw(Box::new(contents))
+ let inner = self.inner;
+ self.string.get_or_insert_with(|| {
+ let mut s = String::new();
+ drop(s.write_fmt(*inner));
+ s
+ })
+ }
}
- fn get(&mut self) -> &(Any + Send) {
- self.fill()
- }
-}
+ unsafe impl<'a> BoxMeUp for PanicPayload<'a> {
+ fn box_me_up(&mut self) -> *mut (dyn Any + Send) {
+ let contents = mem::replace(self.fill(), String::new());
+ Box::into_raw(Box::new(contents))
+ }
-/// The entry point for panicking with a formatted message.
-///
-/// This is designed to reduce the amount of code required at the call
-/// site as much as possible (so that `panic!()` has as low an impact
-/// on (e.g.) the inlining of other functions as possible), by moving
-/// the actual formatting into this shared place.
-#[cfg(not(stage0))]
-#[unstable(feature = "libstd_sys_internals",
- reason = "used by the panic! macro",
- issue = "0")]
-#[inline(never)] #[cold]
-pub fn begin_panic_fmt(msg: &fmt::Arguments,
- file_line_col: &(&'static str, u32, u32)) -> ! {
- let (file, line, col) = *file_line_col;
- let info = PanicInfo::internal_constructor(
- Some(msg),
- Location::internal_constructor(file, line, col),
- );
- continue_panic_fmt(&info)
-}
+ fn get(&mut self) -> &(dyn Any + Send) {
+ self.fill()
+ }
+ }
-#[cfg(not(stage0))]
-fn continue_panic_fmt(info: &PanicInfo) -> ! {
// 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 begin_panic
@@ -480,15 +444,15 @@ pub fn begin_panic<M: Any + Send>(msg: M, file_line_col: &(&'static str, u32, u3
}
unsafe impl<A: Send + 'static> BoxMeUp for PanicPayload<A> {
- fn box_me_up(&mut self) -> *mut (Any + Send) {
+ fn box_me_up(&mut self) -> *mut (dyn Any + Send) {
let data = match self.inner.take() {
- Some(a) => Box::new(a) as Box<Any + Send>,
+ Some(a) => Box::new(a) as Box<dyn Any + Send>,
None => Box::new(()),
};
Box::into_raw(data)
}
- fn get(&mut self) -> &(Any + Send) {
+ fn get(&mut self) -> &(dyn Any + Send) {
match self.inner {
Some(ref a) => a,
None => &(),
@@ -502,7 +466,7 @@ pub fn begin_panic<M: Any + Send>(msg: M, file_line_col: &(&'static str, u32, u3
/// Executes the primary logic for a panic, including checking for recursive
/// panics, panic hooks, and finally dispatching to the panic runtime to either
/// abort or unwind.
-fn rust_panic_with_hook(payload: &mut BoxMeUp,
+fn rust_panic_with_hook(payload: &mut dyn BoxMeUp,
message: Option<&fmt::Arguments>,
file_line_col: &(&str, u32, u32)) -> ! {
let (file, line, col) = *file_line_col;
@@ -557,17 +521,17 @@ fn rust_panic_with_hook(payload: &mut BoxMeUp,
}
/// Shim around rust_panic. Called by resume_unwind.
-pub fn update_count_then_panic(msg: Box<Any + Send>) -> ! {
+pub fn update_count_then_panic(msg: Box<dyn Any + Send>) -> ! {
update_panic_count(1);
- struct RewrapBox(Box<Any + Send>);
+ struct RewrapBox(Box<dyn Any + Send>);
unsafe impl BoxMeUp for RewrapBox {
- fn box_me_up(&mut self) -> *mut (Any + Send) {
+ fn box_me_up(&mut self) -> *mut (dyn Any + Send) {
Box::into_raw(mem::replace(&mut self.0, Box::new(())))
}
- fn get(&mut self) -> &(Any + Send) {
+ fn get(&mut self) -> &(dyn Any + Send) {
&*self.0
}
}
@@ -578,9 +542,9 @@ pub fn update_count_then_panic(msg: Box<Any + Send>) -> ! {
/// A private no-mangle function on which to slap yer breakpoints.
#[no_mangle]
#[allow(private_no_mangle_fns)] // yes we get it, but we like breakpoints
-pub fn rust_panic(mut msg: &mut BoxMeUp) -> ! {
+pub fn rust_panic(mut msg: &mut dyn BoxMeUp) -> ! {
let code = unsafe {
- let obj = &mut msg as *mut &mut BoxMeUp;
+ let obj = &mut msg as *mut &mut dyn BoxMeUp;
__rust_start_panic(obj as usize)
};
rtabort!("failed to initiate panic, error {}", code)
generated by cgit v1.2.3 (git 2.25.1) at 2026-06-06 11:37:13 +0000