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_controls",
+    reason = "to control abbreviation of backtraces",
+    issue = "none"
+)]
+#[doc(hidden)]
+pub use crate::sys::backtrace::{
+    __rust_begin_short_backtrace as resume_short_backtrace,
+    __rust_end_short_backtrace as pause_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,60 @@ 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_controls {
+    ($($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.
+        ///
+        /// It is guaranteed that `f` will be called exactly once, and `unsafe` code may
+        /// rely on this to be the case.
+        #[cfg_attr(feature = "backtrace", inline(never))]
+        fn $marker(f: &mut dyn FnMut()) {
+            f();
+
+            // (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);
+        }
 
-    // prevent this frame from being tail-call optimised away
-    crate::hint::black_box(());
+        /// Invokes `$marker` with an adaptation of `f`, returning its result.
+        /// This is a more ergonomic interface for placing the marker frame on the stack than
+        /// the `$marker` function itself. It can be inlined without problem.
+        #[doc(hidden)]
+        #[unstable(
+            feature = "short_backtrace_controls",
+            reason = "to control abbreviation of backtraces",
+            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);
 
-    result
-}
+            let mut adapted = || {
+                // SAFETY: `adapted` is called exactly once, by `$marker`;
+                //         and the `ManuallyDrop` is not otherwise used again.
+                let f = unsafe { ManuallyDrop::take(&mut f) };
+                result.write(f());
+            };
 
-/// 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();
+            $marker(&mut adapted);
 
-    // prevent this frame from being tail-call optimised away
-    crate::hint::black_box(());
+            // SAFETY: `$marker` guaranteed that it would call `adapted`, which
+            //         initialized `result`.
+            unsafe { result.assume_init() }
+        }
+    )*};
+}
 
-    result
+short_backtrace_controls! {
+    __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.