diff --git a/compiler/rustc_hir/src/lang_items.rs b/compiler/rustc_hir/src/lang_items.rs index 26ce30cb51177..738c79bce1afd 100644 --- a/compiler/rustc_hir/src/lang_items.rs +++ b/compiler/rustc_hir/src/lang_items.rs @@ -271,6 +271,10 @@ language_item_table! { // libstd panic entry point. Necessary for const eval to be able to catch it BeginPanic, sym::begin_panic, begin_panic_fn, Target::Fn; + BacktraceEnabled, sym::backtrace_enabled, backtrace_enabled, Target::Fn; + BacktraceCreate, sym::backtrace_create, backtrace_create, Target::Fn; + BacktraceStatus, sym::backtrace_status, backtrace_status, Target::Fn; + ExchangeMalloc, sym::exchange_malloc, exchange_malloc_fn, Target::Fn; BoxFree, sym::box_free, box_free_fn, Target::Fn; DropInPlace, sym::drop_in_place, drop_in_place_fn, Target::Fn; diff --git a/compiler/rustc_hir/src/weak_lang_items.rs b/compiler/rustc_hir/src/weak_lang_items.rs index b8cd15e7f00d6..d9529a32790e6 100644 --- a/compiler/rustc_hir/src/weak_lang_items.rs +++ b/compiler/rustc_hir/src/weak_lang_items.rs @@ -48,4 +48,7 @@ weak_lang_items! { eh_personality, EhPersonality, rust_eh_personality; eh_catch_typeinfo, EhCatchTypeinfo, rust_eh_catch_typeinfo; oom, Oom, rust_oom; + backtrace_create, BacktraceCreate, rust_backtrace_create; + backtrace_enabled, BacktraceEnabled, rust_backtrace_enabled; + backtrace_status, BacktraceStatus, rust_backtrace_status; } diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs index f2f975c0cf9e5..fbc4e15703c79 100644 --- a/compiler/rustc_span/src/symbol.rs +++ b/compiler/rustc_span/src/symbol.rs @@ -289,6 +289,9 @@ symbols! { automatically_derived, avx512_target_feature, await_macro, + backtrace_create, + backtrace_enabled, + backtrace_status, bang, begin_panic, bench, @@ -931,6 +934,9 @@ symbols! { rust_2015_preview, rust_2018_preview, rust_2021_preview, + rust_backtrace_create, + rust_backtrace_enabled, + rust_backtrace_status, rust_begin_unwind, rust_eh_catch_typeinfo, rust_eh_personality, diff --git a/library/core/src/backtrace.rs b/library/core/src/backtrace.rs new file mode 100644 index 0000000000000..8e27ea23c54ce --- /dev/null +++ b/library/core/src/backtrace.rs @@ -0,0 +1,218 @@ +//! hi +#![unstable(feature = "backtrace", issue = "53487")] +use crate::{fmt, ptr}; + +/// The current status of a backtrace, indicating whether it was captured or +/// whether it is empty for some other reason. +#[non_exhaustive] +#[derive(Debug, PartialEq, Eq)] +pub enum BacktraceStatus { + /// Capturing a backtrace is not supported, likely because it's not + /// implemented for the current platform. + Unsupported, + /// Capturing a backtrace has been disabled through either the + /// `RUST_LIB_BACKTRACE` or `RUST_BACKTRACE` environment variables. + Disabled, + /// A backtrace has been captured and the `Backtrace` should print + /// reasonable information when rendered. + Captured, +} + +// perma(?)-unstable +#[unstable(feature = "backtrace", issue = "53487")] +/// +pub trait RawBacktrace: fmt::Debug + fmt::Display + 'static { + /// + unsafe fn drop_and_free(self: *mut Self); +} + +struct UnsupportedBacktrace; + +impl UnsupportedBacktrace { + #[allow(dead_code)] + const fn create() -> Backtrace { + // don't add members to Self + let _ = Self {}; + + Backtrace { inner: ptr::NonNull::::dangling().as_ptr() } + } +} + +impl RawBacktrace for UnsupportedBacktrace { + unsafe fn drop_and_free(self: *mut Self) {} +} + +impl fmt::Display for UnsupportedBacktrace { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { + fmt.write_str("unsupported backtrace") + } +} + +impl fmt::Debug for UnsupportedBacktrace { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { + fmt.write_str("") + } +} +struct DisabledBacktrace; + +impl DisabledBacktrace { + const fn create() -> Backtrace { + // don't add members to Self + let _ = Self {}; + + Backtrace { inner: ptr::NonNull::::dangling().as_ptr() } + } +} + +impl RawBacktrace for DisabledBacktrace { + unsafe fn drop_and_free(self: *mut Self) {} +} + +impl fmt::Display for DisabledBacktrace { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { + fmt.write_str("disabled backtrace") + } +} + +impl fmt::Debug for DisabledBacktrace { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { + fmt.write_str("") + } +} + +#[unstable(feature = "backtrace", issue = "53487")] +/// +pub struct Backtrace { + /// + inner: *mut dyn RawBacktrace, +} + +/// Global implementation of backtrace functionality. Called to create +/// `RawBacktrace` trait objects. +#[cfg(not(bootstrap))] +extern "Rust" { + #[lang = "backtrace_create"] + fn backtrace_create(ip: usize) -> *mut dyn RawBacktrace; + + #[lang = "backtrace_enabled"] + fn backtrace_enabled() -> bool; + + #[lang = "backtrace_status"] + fn backtrace_status(raw: *mut dyn RawBacktrace) -> BacktraceStatus; +} + +#[cfg(bootstrap)] +unsafe fn backtrace_create(_ip: usize) -> *mut dyn RawBacktrace { + UnsupportedBacktrace::create().inner +} + +#[cfg(bootstrap)] +unsafe fn backtrace_enabled() -> bool { + false +} + +#[cfg(bootstrap)] +unsafe fn backtrace_status(_raw: *mut dyn RawBacktrace) -> BacktraceStatus { + BacktraceStatus::Unsupported +} + +impl Backtrace { + fn create(ip: usize) -> Backtrace { + // SAFETY: trust me + let inner = unsafe { backtrace_create(ip) }; + Backtrace { inner } + } + + /// Returns whether backtrace captures are enabled through environment + /// variables. + fn enabled() -> bool { + // SAFETY: trust me + unsafe { backtrace_enabled() } + } + + /// Capture a stack backtrace of the current thread. + /// + /// This function will capture a stack backtrace of the current OS thread of + /// execution, returning a `Backtrace` type which can be later used to print + /// the entire stack trace or render it to a string. + /// + /// This function will be a noop if the `RUST_BACKTRACE` or + /// `RUST_LIB_BACKTRACE` backtrace variables are both not set. If either + /// environment variable is set and enabled then this function will actually + /// capture a backtrace. Capturing a backtrace can be both memory intensive + /// and slow, so these environment variables allow liberally using + /// `Backtrace::capture` and only incurring a slowdown when the environment + /// variables are set. + /// + /// To forcibly capture a backtrace regardless of environment variables, use + /// the `Backtrace::force_capture` function. + #[inline(never)] // want to make sure there's a frame here to remove + pub fn capture() -> Backtrace { + if !Backtrace::enabled() { + return Backtrace::disabled(); + } + + Self::create(Backtrace::capture as usize) + } + + /// Forcibly captures a full backtrace, regardless of environment variable + /// configuration. + /// + /// This function behaves the same as `capture` except that it ignores the + /// values of the `RUST_BACKTRACE` and `RUST_LIB_BACKTRACE` environment + /// variables, always capturing a backtrace. + /// + /// Note that capturing a backtrace can be an expensive operation on some + /// platforms, so this should be used with caution in performance-sensitive + /// parts of code. + #[inline(never)] // want to make sure there's a frame here to remove + pub fn force_capture() -> Backtrace { + Self::create(Backtrace::force_capture as usize) + } + + /// Forcibly captures a disabled backtrace, regardless of environment + /// variable configuration. + pub const fn disabled() -> Backtrace { + DisabledBacktrace::create() + } + + /// Returns the status of this backtrace, indicating whether this backtrace + /// request was unsupported, disabled, or a stack trace was actually + /// captured. + pub fn status(&self) -> BacktraceStatus { + // SAFETY: trust me + unsafe { backtrace_status(self.inner) } + } +} + +#[unstable(feature = "backtrace", issue = "53487")] +unsafe impl Send for Backtrace {} + +#[unstable(feature = "backtrace", issue = "53487")] +unsafe impl Sync for Backtrace {} + +#[unstable(feature = "backtrace", issue = "53487")] +impl Drop for Backtrace { + fn drop(&mut self) { + // SAFETY: trust me + unsafe { RawBacktrace::drop_and_free(self.inner) } + } +} + +#[unstable(feature = "backtrace", issue = "53487")] +impl fmt::Debug for Backtrace { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { + // SAFETY: trust me + let imp: &dyn RawBacktrace = unsafe { &*self.inner }; + fmt::Debug::fmt(imp, fmt) + } +} + +#[unstable(feature = "backtrace", issue = "53487")] +impl fmt::Display for Backtrace { + fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { + // SAFETY: trust me + let imp: &dyn RawBacktrace = unsafe { &*self.inner }; + fmt::Display::fmt(imp, fmt) + } +} diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs index a69b840e4bf14..54ec5aee7503b 100644 --- a/library/core/src/lib.rs +++ b/library/core/src/lib.rs @@ -116,6 +116,7 @@ #![feature(fundamental)] #![feature(intrinsics)] #![feature(lang_items)] +#![feature(linkage)] #![feature(link_llvm_intrinsics)] #![feature(llvm_asm)] #![feature(negative_impls)] @@ -241,6 +242,7 @@ pub mod ops; pub mod any; pub mod array; pub mod ascii; +pub mod backtrace; pub mod cell; pub mod char; pub mod ffi; diff --git a/library/std/src/backtrace.rs b/library/std/src/backtrace.rs index 0aae4674b2942..76f8d2683d308 100644 --- a/library/std/src/backtrace.rs +++ b/library/std/src/backtrace.rs @@ -104,35 +104,103 @@ use crate::sync::Once; use crate::sys_common::backtrace::{lock, output_filename}; use crate::vec::Vec; +pub use core::backtrace::Backtrace; +pub use core::backtrace::BacktraceStatus; +use core::backtrace::RawBacktrace; + +/// Returns whether backtrace captures are enabled through environment +/// variables. +#[cfg_attr(not(bootstrap), lang = "backtrace_enabled")] +pub fn enabled() -> bool { + // Cache the result of reading the environment variables to make + // backtrace captures speedy, because otherwise reading environment + // variables every time can be somewhat slow. + static ENABLED: AtomicUsize = AtomicUsize::new(0); + match ENABLED.load(SeqCst) { + 0 => {} + 1 => return false, + _ => return true, + } + let enabled = match env::var("RUST_LIB_BACKTRACE") { + Ok(s) => s != "0", + Err(_) => match env::var("RUST_BACKTRACE") { + Ok(s) => s != "0", + Err(_) => false, + }, + }; + ENABLED.store(enabled as usize + 1, SeqCst); + enabled +} + +// Capture a backtrace which start just before the function addressed by +// `ip` +#[cfg_attr(not(bootstrap), lang = "backtrace_create")] +/// +pub fn create(ip: usize) -> *mut dyn RawBacktrace { + // SAFETY: We don't attempt to lock this reentrantly. + let _lock = unsafe { lock() }; + let mut frames = Vec::new(); + let mut actual_start = None; + unsafe { + backtrace_rs::trace_unsynchronized(|frame| { + frames.push(BacktraceFrame { + frame: RawFrame::Actual(frame.clone()), + symbols: Vec::new(), + }); + if frame.symbol_address() as usize == ip && actual_start.is_none() { + actual_start = Some(frames.len()); + } + true + }); + } + + // If no frames came out assume that this is an unsupported platform + // since `backtrace` doesn't provide a way of learning this right now, + // and this should be a good enough approximation. + let inner = if frames.is_empty() { + Inner::Unsupported + } else { + Inner::Captured(LazilyResolvedCapture::new(Capture { + actual_start: actual_start.unwrap_or(0), + frames, + resolved: false, + })) + }; + + let bt: Box = Box::new(StdBacktrace { inner }); + Box::into_raw(bt) +} + +/// Returns the status of this backtrace, indicating whether this backtrace +/// request was unsupported, disabled, or a stack trace was actually +/// captured. +#[cfg_attr(not(bootstrap), lang = "backtrace_status")] +pub fn status(_backtrace: *mut dyn RawBacktrace) -> BacktraceStatus { + todo!() + // match backtrace.inner { + // Inner::Unsupported => BacktraceStatus::Unsupported, + // Inner::Captured(_) => BacktraceStatus::Captured, + // } +} + /// A captured OS thread stack backtrace. /// /// This type represents a stack backtrace for an OS thread captured at a /// previous point in time. In some instances the `Backtrace` type may /// internally be empty due to configuration. For more information see /// `Backtrace::capture`. -pub struct Backtrace { +struct StdBacktrace { inner: Inner, } -/// The current status of a backtrace, indicating whether it was captured or -/// whether it is empty for some other reason. -#[non_exhaustive] -#[derive(Debug, PartialEq, Eq)] -pub enum BacktraceStatus { - /// Capturing a backtrace is not supported, likely because it's not - /// implemented for the current platform. - Unsupported, - /// Capturing a backtrace has been disabled through either the - /// `RUST_LIB_BACKTRACE` or `RUST_BACKTRACE` environment variables. - Disabled, - /// A backtrace has been captured and the `Backtrace` should print - /// reasonable information when rendered. - Captured, +impl RawBacktrace for StdBacktrace { + unsafe fn drop_and_free(self: *mut Self) { + let _ = Box::from_raw(self); + } } enum Inner { Unsupported, - Disabled, Captured(LazilyResolvedCapture), } @@ -144,7 +212,7 @@ struct Capture { fn _assert_send_sync() { fn _assert() {} - _assert::(); + _assert::(); } /// A single frame of a backtrace. @@ -173,11 +241,10 @@ enum BytesOrWide { Wide(Vec), } -impl fmt::Debug for Backtrace { +impl fmt::Debug for StdBacktrace { fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { let capture = match &self.inner { Inner::Unsupported => return fmt.write_str(""), - Inner::Disabled => return fmt.write_str(""), Inner::Captured(c) => c.force(), }; @@ -247,136 +314,18 @@ impl fmt::Debug for BytesOrWide { } } -impl Backtrace { - /// Returns whether backtrace captures are enabled through environment - /// variables. - fn enabled() -> bool { - // Cache the result of reading the environment variables to make - // backtrace captures speedy, because otherwise reading environment - // variables every time can be somewhat slow. - static ENABLED: AtomicUsize = AtomicUsize::new(0); - match ENABLED.load(SeqCst) { - 0 => {} - 1 => return false, - _ => return true, - } - let enabled = match env::var("RUST_LIB_BACKTRACE") { - Ok(s) => s != "0", - Err(_) => match env::var("RUST_BACKTRACE") { - Ok(s) => s != "0", - Err(_) => false, - }, - }; - ENABLED.store(enabled as usize + 1, SeqCst); - enabled - } - - /// Capture a stack backtrace of the current thread. - /// - /// This function will capture a stack backtrace of the current OS thread of - /// execution, returning a `Backtrace` type which can be later used to print - /// the entire stack trace or render it to a string. - /// - /// This function will be a noop if the `RUST_BACKTRACE` or - /// `RUST_LIB_BACKTRACE` backtrace variables are both not set. If either - /// environment variable is set and enabled then this function will actually - /// capture a backtrace. Capturing a backtrace can be both memory intensive - /// and slow, so these environment variables allow liberally using - /// `Backtrace::capture` and only incurring a slowdown when the environment - /// variables are set. - /// - /// To forcibly capture a backtrace regardless of environment variables, use - /// the `Backtrace::force_capture` function. - #[inline(never)] // want to make sure there's a frame here to remove - pub fn capture() -> Backtrace { - if !Backtrace::enabled() { - return Backtrace { inner: Inner::Disabled }; - } - Backtrace::create(Backtrace::capture as usize) - } - - /// Forcibly captures a full backtrace, regardless of environment variable - /// configuration. - /// - /// This function behaves the same as `capture` except that it ignores the - /// values of the `RUST_BACKTRACE` and `RUST_LIB_BACKTRACE` environment - /// variables, always capturing a backtrace. - /// - /// Note that capturing a backtrace can be an expensive operation on some - /// platforms, so this should be used with caution in performance-sensitive - /// parts of code. - #[inline(never)] // want to make sure there's a frame here to remove - pub fn force_capture() -> Backtrace { - Backtrace::create(Backtrace::force_capture as usize) - } - - /// Forcibly captures a disabled backtrace, regardless of environment - /// variable configuration. - pub const fn disabled() -> Backtrace { - Backtrace { inner: Inner::Disabled } - } - - // Capture a backtrace which start just before the function addressed by - // `ip` - fn create(ip: usize) -> Backtrace { - // SAFETY: We don't attempt to lock this reentrantly. - let _lock = unsafe { lock() }; - let mut frames = Vec::new(); - let mut actual_start = None; - unsafe { - backtrace_rs::trace_unsynchronized(|frame| { - frames.push(BacktraceFrame { - frame: RawFrame::Actual(frame.clone()), - symbols: Vec::new(), - }); - if frame.symbol_address() as usize == ip && actual_start.is_none() { - actual_start = Some(frames.len()); - } - true - }); - } - - // If no frames came out assume that this is an unsupported platform - // since `backtrace` doesn't provide a way of learning this right now, - // and this should be a good enough approximation. - let inner = if frames.is_empty() { - Inner::Unsupported - } else { - Inner::Captured(LazilyResolvedCapture::new(Capture { - actual_start: actual_start.unwrap_or(0), - frames, - resolved: false, - })) - }; - - Backtrace { inner } - } - - /// Returns the status of this backtrace, indicating whether this backtrace - /// request was unsupported, disabled, or a stack trace was actually - /// captured. - pub fn status(&self) -> BacktraceStatus { - match self.inner { - Inner::Unsupported => BacktraceStatus::Unsupported, - Inner::Disabled => BacktraceStatus::Disabled, - Inner::Captured(_) => BacktraceStatus::Captured, - } - } -} - -impl<'a> Backtrace { - /// Returns an iterator over the backtrace frames. - #[unstable(feature = "backtrace_frames", issue = "79676")] - pub fn frames(&'a self) -> &'a [BacktraceFrame] { - if let Inner::Captured(c) = &self.inner { &c.force().frames } else { &[] } - } -} +// impl<'a> StdBacktrace { +// /// Returns an iterator over the backtrace frames. +// #[unstable(feature = "backtrace_frames", issue = "79676")] +// pub fn frames(&'a self) -> &'a [BacktraceFrame] { +// if let Inner::Captured(c) = &self.inner { &c.force().frames } else { &[] } +// } +// } -impl fmt::Display for Backtrace { +impl fmt::Display for StdBacktrace { fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { let capture = match &self.inner { Inner::Unsupported => return fmt.write_str("unsupported backtrace"), - Inner::Disabled => return fmt.write_str("disabled backtrace"), Inner::Captured(c) => c.force(), }; diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs index b6929f5939576..d81bebfeb173d 100644 --- a/library/std/src/lib.rs +++ b/library/std/src/lib.rs @@ -230,6 +230,7 @@ #![feature(asm)] #![feature(associated_type_bounds)] #![feature(atomic_mut_ptr)] +#![feature(backtrace)] #![feature(box_syntax)] #![feature(c_variadic)] #![feature(cfg_accessible)]