Fix short backtraces from stripped executables

Locate the beginning and ending frames for short backtraces by address
in addition to symbol name, so that they work even when symbols have
been stripped from the executable.

We need to retain matching by symbol name for the time being, because
rustc (and some associated ui tests) rely upon it to have ICE backtraces
abbreviated.  They can be updated once this commit lands in beta/stage0.

Author: eggyal

library/std/src/backtrace.rs

@@ -94,6 +94,16 @@ use crate::panic::UnwindSafe;
 use crate::sync::LazyLock;
 use crate::sync::atomic::Ordering::Relaxed;
 use crate::sync::atomic::{Atomic, AtomicU8};
+#[unstable(
+    feature = "short_backtrace_termini",
+    reason = "for rustc to have ICE backtraces abbreviated",
+    issue = "none"
+)]
+#[doc(hidden)]
+pub use crate::sys::backtrace::{
+    __rust_begin_short_backtrace as begin_short_backtrace,
+    __rust_end_short_backtrace as end_short_backtrace,
+};
 use crate::sys::backtrace::{lock, output_filename, set_image_base};
 use crate::{env, fmt};
 

library/std/src/sys/backtrace.rs

@@ -4,6 +4,7 @@
 use crate::backtrace_rs::{self, BacktraceFmt, BytesOrWideString, PrintFmt};
 use crate::borrow::Cow;
 use crate::io::prelude::*;
+use crate::mem::{ManuallyDrop, MaybeUninit};
 use crate::path::{self, Path, PathBuf};
 use crate::sync::{Mutex, MutexGuard, PoisonError};
 use crate::{env, fmt, io};
@@ -81,12 +82,26 @@ unsafe fn _print_fmt(fmt: &mut fmt::Formatter<'_>, print_fmt: PrintFmt) -> fmt::
                 let frame_ip = frame.ip();
                 res = writeln!(bt_fmt.formatter(), "{idx:4}: {frame_ip:HEX_WIDTH$?}");
             } else {
+                // `call_with_short_backtrace_marker::<End>` means we are done hiding symbols
+                // for now. Print until we see `call_with_short_backtrace_marker::<Begin>`.
+                if print_fmt == PrintFmt::Short {
+                    let sym = frame.symbol_address();
+                    if sym == call_with_short_backtrace_marker::<End> as _ {
+                        print = true;
+                        return true;
+                    } else if print && sym == call_with_short_backtrace_marker::<Begin> as _ {
+                        print = false;
+                        return true;
+                    }
+                }
+
                 let mut hit = false;
                 backtrace_rs::resolve_frame_unsynchronized(frame, |symbol| {
                     hit = true;
 
-                    // `__rust_end_short_backtrace` means we are done hiding symbols
-                    // for now. Print until we see `__rust_begin_short_backtrace`.
+                    // Hide `__rust_[begin|end]_short_backtrace` frames from short backtraces.
+                    // Unfortunately these generic functions have to be matched by name, as we do
+                    // not know their generic parameters.
                     if print_fmt == PrintFmt::Short {
                         if let Some(sym) = symbol.name().and_then(|s| s.as_str()) {
                             if sym.contains("__rust_end_short_backtrace") {
@@ -159,32 +174,45 @@ unsafe fn _print_fmt(fmt: &mut fmt::Formatter<'_>, print_fmt: PrintFmt) -> fmt::
 /// this is only inline(never) when backtraces in std are enabled, otherwise
 /// it's fine to optimize away.
 #[cfg_attr(feature = "backtrace", inline(never))]
-pub fn __rust_begin_short_backtrace<F, T>(f: F) -> T
-where
-    F: FnOnce() -> T,
-{
-    let result = f();
+fn call_with_short_backtrace_marker<T: Terminus>(f: &mut dyn FnMut()) {
+    f();
 
-    // prevent this frame from being tail-call optimised away
-    crate::hint::black_box(());
+    // (Try to) prevent both Identical Code Folding (which might merge the `Begin` and `End`
+    // versions of this function, giving them the same address) and Tail Call Optimisation (which
+    // could remove their frames from the call stack).
+    crate::hint::black_box(T::ID);
+}
 
-    result
+trait Terminus {
+    const ID: u32;
 }
 
-/// Fixed frame used to clean the backtrace with `RUST_BACKTRACE=1`. Note that
-/// this is only inline(never) when backtraces in std are enabled, otherwise
-/// it's fine to optimize away.
-#[cfg_attr(feature = "backtrace", inline(never))]
-pub fn __rust_end_short_backtrace<F, T>(f: F) -> T
-where
-    F: FnOnce() -> T,
-{
-    let result = f();
+macro_rules! short_backtrace_termini {
+    ($($f:ident => $t:ident($id:literal)),* $(,)?) => {$(
+        struct $t;
+        impl Terminus for $t {
+            const ID: u32 = $id;
+        }
 
-    // prevent this frame from being tail-call optimised away
-    crate::hint::black_box(());
+        #[doc(hidden)]
+        #[unstable(feature = "short_backtrace_termini", reason = "for rustc to have ICE backtraces abbreviated", issue = "none")]
+        #[inline(always)]
+        pub fn $f<F, T>(f: F) -> T
+        where
+            F: FnOnce() -> T,
+        {
+            let mut result = MaybeUninit::<T>::uninit();
+            let mut f = ManuallyDrop::new(f);
+            let mut f = || { result.write(unsafe { ManuallyDrop::take(&mut f) }()); };
+            call_with_short_backtrace_marker::<$t>(&mut f);
+            unsafe { result.assume_init() }
+        }
+    )*};
+}
 
-    result
+short_backtrace_termini! {
+    __rust_begin_short_backtrace => Begin(0),
+    __rust_end_short_backtrace => End(1),
 }
 
 /// Prints the filename of the backtrace frame.

tests/ui/panics/short-backtrace-in-stripped.rs

@@ -0,0 +1,18 @@
+//! Short backtraces should still be emitted from stripped binaries.
+//! Regression test for https://github.com/rust-lang/rust/issues/147846
+//
+//@ compile-flags: -Cstrip=symbols
+//@ exec-env: RUST_BACKTRACE=1
+//@ run-fail
+//@ check-run-results
+//
+//  Name mangling scheme differences
+//@ normalize-stderr: "begin_panic::<&str>" -> "begin_panic"
+//
+//  macOS with `rust.debuginfo-level = "line-tables-only"` (#133997)
+//@ normalize-stderr: " begin_panic<&str>" -> " std::panicking::begin_panic"
+//
+//  debuginfo
+//@ normalize-stderr: "\n +at [^\n]+" -> ""
+
+fn main() { panic!(); }

tests/ui/panics/short-backtrace-in-stripped.run.stderr

@@ -0,0 +1,9 @@
+
+thread 'main' ($TID) panicked at $DIR/short-backtrace-in-stripped.rs:18:13:
+explicit panic
+stack backtrace:
+   0: std::panicking::begin_panic
+   1: <unknown>
+   2: <unknown>
+   3: <unknown>
+note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.