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,13 @@ 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, __rust_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};
@@ -68,6 +69,7 @@ unsafe fn _print_fmt(fmt: &mut fmt::Formatter<'_>, print_fmt: PrintFmt) -> fmt::
     let mut first_omit = true;
     // If we're using a short backtrace, ignore all frames until we're told to start printing.
     let mut print = print_fmt != PrintFmt::Short;
+    let mut skip = false;
     set_image_base();
     // SAFETY: we roll our own locking in this town
     unsafe {
@@ -81,12 +83,30 @@ 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 _ {
+                        skip = true;
+                        print = true;
+                    } else if print && sym == call_with_short_backtrace_marker::<Begin> as _ {
+                        skip = true;
+                        print = false;
+                    }
+                }
+
                 let mut hit = false;
                 backtrace_rs::resolve_frame_unsynchronized(frame, |symbol| {
                     hit = true;
+                    if skip {
+                        skip = false;
+                        return;
+                    }
 
-                    // `__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") {
@@ -97,6 +117,7 @@ unsafe fn _print_fmt(fmt: &mut fmt::Formatter<'_>, print_fmt: PrintFmt) -> fmt::
                                 print = false;
                                 return;
                             }
+
                             if !print {
                                 omitted_count += 1;
                             }
@@ -159,32 +180,39 @@ 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<Terminus>(f: &mut dyn FnMut()) {
+    f();
 
-    // prevent this frame from being tail-call optimised away
-    crate::hint::black_box(());
+    // Prevent this function from being polymorphized
+    let m = format_args!("{:p}", call_with_short_backtrace_marker::<Terminus> as *const ());
 
-    result
+    // Prevent this frame from being tail-call optimized away
+    crate::hint::black_box(m);
 }
 
-/// 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),* $(,)?) => {$(
+        struct $t;
 
-    // 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,
+    __rust_end_short_backtrace => End,
 }
 
 /// Prints the filename of the backtrace frame.

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

@@ -0,0 +1,8 @@
+//! 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
+
+fn main() { panic!(); }

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

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