Revert "std: Switch from libbacktrace to gimli"

This reverts commit 13db3cc1e8d2fd4b8e7c74d91002274d7b62801b.

6 files changed, 23 insertions, 32 deletions

diff --git a/src/libstd/Cargo.toml b/src/libstd/Cargo.toml
index 136db6d5d32..29893bd12f1 100644
--- a/src/libstd/Cargo.toml
+++ b/src/libstd/Cargo.toml
@@ -25,15 +25,11 @@ profiler_builtins = { path = "../libprofiler_builtins", optional = true }
 unwind = { path = "../libunwind" }
 hashbrown = { version = "0.6.2", default-features = false, features = ['rustc-dep-of-std'] }
 
-# Dependencies of the `backtrace` crate
-addr2line = { version = "0.13.0", optional = true, default-features = false }
-rustc-demangle = { version = "0.1.4", optional = true }
-miniz_oxide = { version = "0.4.0", optional = true, default-features = false }
-[dependencies.object]
-version = "0.20"
-optional = true
-default-features = false
-features = ['read_core', 'elf', 'macho', 'pe']
+[dependencies.backtrace_rs]
+package = "backtrace"
+version = "0.3.46"
+default-features = false # without the libstd `backtrace` feature, stub out everything
+features = [ "rustc-dep-of-std" ] # enable build support for integrating into libstd
 
 [dev-dependencies]
 rand = "0.7"
@@ -52,13 +48,11 @@ wasi = { version = "0.9.0", features = ['rustc-dep-of-std'], default-features =
 
 [features]
 backtrace = [
-  "gimli-symbolize",
-  'addr2line/rustc-dep-of-std',
-  'object/rustc-dep-of-std',
-  'rustc-demangle/rustc-dep-of-std',
-  'miniz_oxide/rustc-dep-of-std',
+  "backtrace_rs/dbghelp",          # backtrace/symbolize on MSVC
+  "backtrace_rs/libbacktrace",     # symbolize on most platforms
+  "backtrace_rs/libunwind",        # backtrace on most platforms
+  "backtrace_rs/dladdr",           # symbolize on platforms w/o libbacktrace
 ]
-gimli-symbolize = []
 
 panic-unwind = ["panic_unwind"]
 profiler = ["profiler_builtins"]
diff --git a/src/libstd/backtrace.rs b/src/libstd/backtrace.rs
index e65775c1ced..e10d466030f 100644
--- a/src/libstd/backtrace.rs
+++ b/src/libstd/backtrace.rs
@@ -91,7 +91,6 @@
 // `Backtrace`, but that's a relatively small price to pay relative to capturing
 // a backtrace or actually symbolizing it.
 
-use crate::backtrace_rs::{self, BytesOrWideString};
 use crate::env;
 use crate::ffi::c_void;
 use crate::fmt;
@@ -99,6 +98,8 @@ use crate::sync::atomic::{AtomicUsize, Ordering::SeqCst};
 use crate::sync::Mutex;
 use crate::sys_common::backtrace::{lock, output_filename};
 use crate::vec::Vec;
+use backtrace::BytesOrWideString;
+use backtrace_rs as backtrace;
 
 /// A captured OS thread stack backtrace.
 ///
@@ -149,7 +150,7 @@ struct BacktraceFrame {
 }
 
 enum RawFrame {
-    Actual(backtrace_rs::Frame),
+    Actual(backtrace::Frame),
     #[cfg(test)]
     Fake,
 }
@@ -196,7 +197,7 @@ impl fmt::Debug for BacktraceSymbol {
     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(fmt, "{{ ")?;
 
-        if let Some(fn_name) = self.name.as_ref().map(|b| backtrace_rs::SymbolName::new(b)) {
+        if let Some(fn_name) = self.name.as_ref().map(|b| backtrace::SymbolName::new(b)) {
             write!(fmt, "fn: \"{:#}\"", fn_name)?;
         } else {
             write!(fmt, "fn: <unknown>")?;
@@ -222,7 +223,7 @@ impl fmt::Debug for BytesOrWide {
                 BytesOrWide::Bytes(w) => BytesOrWideString::Bytes(w),
                 BytesOrWide::Wide(w) => BytesOrWideString::Wide(w),
             },
-            backtrace_rs::PrintFmt::Short,
+            backtrace::PrintFmt::Short,
             crate::env::current_dir().as_ref().ok(),
         )
     }
@@ -298,7 +299,7 @@ impl Backtrace {
         let mut frames = Vec::new();
         let mut actual_start = None;
         unsafe {
-            backtrace_rs::trace_unsynchronized(|frame| {
+            backtrace::trace_unsynchronized(|frame| {
                 frames.push(BacktraceFrame {
                     frame: RawFrame::Actual(frame.clone()),
                     symbols: Vec::new(),
@@ -349,9 +350,9 @@ impl fmt::Display for Backtrace {
 
         let full = fmt.alternate();
         let (frames, style) = if full {
-            (&capture.frames[..], backtrace_rs::PrintFmt::Full)
+            (&capture.frames[..], backtrace::PrintFmt::Full)
         } else {
-            (&capture.frames[capture.actual_start..], backtrace_rs::PrintFmt::Short)
+            (&capture.frames[capture.actual_start..], backtrace::PrintFmt::Short)
         };
 
         // When printing paths we try to strip the cwd if it exists, otherwise
@@ -363,7 +364,7 @@ impl fmt::Display for Backtrace {
             output_filename(fmt, path, style, cwd.as_ref().ok())
         };
 
-        let mut f = backtrace_rs::BacktraceFmt::new(fmt, style, &mut print_path);
+        let mut f = backtrace::BacktraceFmt::new(fmt, style, &mut print_path);
         f.add_context()?;
         for frame in frames {
             let mut f = f.frame();
@@ -373,7 +374,7 @@ impl fmt::Display for Backtrace {
                 for symbol in frame.symbols.iter() {
                     f.print_raw(
                         frame.frame.ip(),
-                        symbol.name.as_ref().map(|b| backtrace_rs::SymbolName::new(b)),
+                        symbol.name.as_ref().map(|b| backtrace::SymbolName::new(b)),
                         symbol.filename.as_ref().map(|b| match b {
                             BytesOrWide::Bytes(w) => BytesOrWideString::Bytes(w),
                             BytesOrWide::Wide(w) => BytesOrWideString::Wide(w),
@@ -408,7 +409,7 @@ impl Capture {
                 RawFrame::Fake => unimplemented!(),
             };
             unsafe {
-                backtrace_rs::resolve_frame_unsynchronized(frame, |symbol| {
+                backtrace::resolve_frame_unsynchronized(frame, |symbol| {
                     symbols.push(BacktraceSymbol {
                         name: symbol.name().map(|m| m.as_bytes().to_vec()),
                         filename: symbol.filename_raw().map(|b| match b {
diff --git a/src/libstd/build.rs b/src/libstd/build.rs
index 58fb6fda19a..eb2753d6245 100644
--- a/src/libstd/build.rs
+++ b/src/libstd/build.rs
@@ -87,5 +87,4 @@ fn main() {
         println!("cargo:rustc-cfg=feature=\"restricted-std\"");
     }
     println!("cargo:rustc-env=STD_ENV_ARCH={}", env::var("CARGO_CFG_TARGET_ARCH").unwrap());
-    println!("cargo:rustc-cfg=backtrace_in_libstd");
 }
diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs
index 02de3fff29f..00f2fff94c9 100644
--- a/src/libstd/lib.rs
+++ b/src/libstd/lib.rs
@@ -511,10 +511,6 @@ mod panicking;
 // compiler
 pub mod rt;
 
-#[path = "../backtrace/src/lib.rs"]
-#[allow(dead_code, unused_attributes)]
-mod backtrace_rs;
-
 // Pull in the `std_detect` crate directly into libstd. The contents of
 // `std_detect` are in a different repository: rust-lang/stdarch.
 //
diff --git a/src/libstd/panicking.rs b/src/libstd/panicking.rs
index ab2a6010306..9542e7209b4 100644
--- a/src/libstd/panicking.rs
+++ b/src/libstd/panicking.rs
@@ -171,7 +171,7 @@ fn default_hook(info: &PanicInfo<'_>) {
     // If this is a double panic, make sure that we print a backtrace
     // for this panic. Otherwise only print it if logging is enabled.
     let backtrace_env = if panic_count::get() >= 2 {
-        RustBacktrace::Print(crate::backtrace_rs::PrintFmt::Full)
+        RustBacktrace::Print(backtrace_rs::PrintFmt::Full)
     } else {
         backtrace::rust_backtrace_env()
     };
diff --git a/src/libstd/sys_common/backtrace.rs b/src/libstd/sys_common/backtrace.rs
index d386a656e4f..e9b1e86d7ae 100644
--- a/src/libstd/sys_common/backtrace.rs
+++ b/src/libstd/sys_common/backtrace.rs
@@ -1,4 +1,3 @@
-use crate::backtrace_rs::{self, BacktraceFmt, BytesOrWideString, PrintFmt};
 use crate::borrow::Cow;
 /// Common code for printing the backtrace in the same way across the different
 /// supported platforms.
@@ -10,6 +9,8 @@ use crate::path::{self, Path, PathBuf};
 use crate::sync::atomic::{self, Ordering};
 use crate::sys::mutex::Mutex;
 
+use backtrace_rs::{BacktraceFmt, BytesOrWideString, PrintFmt};
+
 /// Max number of frames to print.
 const MAX_NB_FRAMES: usize = 100;