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_end_short_backtrace_marker` means we are done hiding symbols
+                // for now. Print until we see `call_with_begin_short_backtrace_marker`.
+                if print_fmt == PrintFmt::Short {
+                    let sym = frame.symbol_address();
+                    if sym == call_with_end_short_backtrace_marker as _ {
+                        print = true;
+                        return true;
+                    } else if print && sym == call_with_begin_short_backtrace_marker 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") {
@@ -155,36 +170,43 @@ unsafe fn _print_fmt(fmt: &mut fmt::Formatter<'_>, print_fmt: PrintFmt) -> fmt::
     Ok(())
 }
 
-/// 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_begin_short_backtrace<F, T>(f: F) -> T
-where
-    F: FnOnce() -> T,
-{
-    let result = f();
+macro_rules! short_backtrace_termini {
+    ($($adapter:ident => $marker:ident($unique:literal)),* $(,)?) => {$(
+        /// 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))]
+        fn $marker(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 different
+            // 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($unique);
+        }
 
-    result
+        /// A function that adapts the non-generic `$marker` to be more ergonomically
+        /// called with a returning-value callback rather than one that writes to its
+        /// captured environment.
+        #[doc(hidden)]
+        #[unstable(feature = "short_backtrace_termini", reason = "for rustc to have ICE backtraces abbreviated", issue = "none")]
+        #[inline(always)]
+        pub fn $adapter<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) }()); };
+            $marker(&mut f);
+            unsafe { result.assume_init() }
+        }
+    )*};
 }
 
-/// 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();
-
-    // prevent this frame from being tail-call optimised away
-    crate::hint::black_box(());
-
-    result
+short_backtrace_termini! {
+    __rust_begin_short_backtrace => call_with_begin_short_backtrace_marker(0),
+    __rust_end_short_backtrace => call_with_end_short_backtrace_marker(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.