[SOL] Enable the std backtrace API

Author: Aimeedeer

library/std/src/backtrace.rs

@@ -88,13 +88,15 @@ mod tests;
 // `Backtrace`, but that's a relatively small price to pay relative to capturing
 // a backtrace or actually symbolizing it.
 
+#[cfg(not(any(target_arch = "bpf", target_arch = "sbf")))]
 use crate::backtrace_rs::{self, BytesOrWideString};
 use crate::env;
 use crate::ffi::c_void;
 use crate::fmt;
 use crate::panic::UnwindSafe;
 use crate::sync::atomic::{AtomicU8, Ordering::Relaxed};
 use crate::sync::LazyLock;
+#[cfg(not(any(target_arch = "bpf", target_arch = "sbf")))]
 use crate::sys_common::backtrace::{lock, output_filename, set_image_base};
 
 /// A captured OS thread stack backtrace.
@@ -154,6 +156,7 @@ pub struct BacktraceFrame {
 
 #[derive(Debug)]
 enum RawFrame {
+    #[cfg(not(any(target_arch = "bpf", target_arch = "sbf")))]
     Actual(backtrace_rs::Frame),
     #[cfg(test)]
     Fake,
@@ -173,6 +176,7 @@ enum BytesOrWide {
 
 #[stable(feature = "backtrace", since = "1.65.0")]
 impl fmt::Debug for Backtrace {
+    #[cfg(not(any(target_arch = "bpf", target_arch = "sbf")))]
     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         let capture = match &self.inner {
             Inner::Unsupported => return fmt.write_str("<unsupported>"),
@@ -196,17 +200,29 @@ impl fmt::Debug for Backtrace {
 
         dbg.finish()
     }
+
+    #[cfg(any(target_arch = "bpf", target_arch = "sbf"))]
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(fmt, "<unsupported>")
+    }
 }
 
 #[unstable(feature = "backtrace_frames", issue = "79676")]
 impl fmt::Debug for BacktraceFrame {
+    #[cfg(not(any(target_arch = "bpf", target_arch = "sbf")))]
     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         let mut dbg = fmt.debug_list();
         dbg.entries(&self.symbols);
         dbg.finish()
     }
+
+    #[cfg(any(target_arch = "bpf", target_arch = "sbf"))]
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(fmt, "<unsupported>")
+    }
 }
 
+#[cfg(not(any(target_arch = "bpf", target_arch = "sbf")))]
 impl fmt::Debug for BacktraceSymbol {
     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         // FIXME: improve formatting: https://github.com/rust-lang/rust/issues/65280
@@ -233,6 +249,7 @@ impl fmt::Debug for BacktraceSymbol {
     }
 }
 
+#[cfg(not(any(target_arch = "bpf", target_arch = "sbf")))]
 impl fmt::Debug for BytesOrWide {
     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         output_filename(
@@ -250,6 +267,7 @@ impl fmt::Debug for BytesOrWide {
 impl Backtrace {
     /// Returns whether backtrace captures are enabled through environment
     /// variables.
+    #[cfg(not(any(target_arch = "bpf", target_arch = "sbf")))]
     fn enabled() -> bool {
         // Cache the result of reading the environment variables to make
         // backtrace captures speedy, because otherwise reading environment
@@ -271,6 +289,11 @@ impl Backtrace {
         enabled
     }
 
+    #[cfg(any(target_arch = "bpf", target_arch = "sbf"))]
+    fn enabled() -> bool {
+        false
+    }
+
     /// Capture a stack backtrace of the current thread.
     ///
     /// This function will capture a stack backtrace of the current OS thread of
@@ -322,6 +345,7 @@ impl Backtrace {
 
     // Capture a backtrace which start just before the function addressed by
     // `ip`
+    #[cfg(not(any(target_arch = "bpf", target_arch = "sbf")))]
     fn create(ip: usize) -> Backtrace {
         let _lock = lock();
         let mut frames = Vec::new();
@@ -355,6 +379,13 @@ impl Backtrace {
         Backtrace { inner }
     }
 
+    #[cfg(any(target_arch = "bpf", target_arch = "sbf"))]
+    fn create(ip: usize) -> Backtrace {
+        Backtrace {
+            inner: Inner::Unsupported
+        }
+    }
+
     /// Returns the status of this backtrace, indicating whether this backtrace
     /// request was unsupported, disabled, or a stack trace was actually
     /// captured.
@@ -380,6 +411,7 @@ impl<'a> Backtrace {
 
 #[stable(feature = "backtrace", since = "1.65.0")]
 impl fmt::Display for Backtrace {
+    #[cfg(not(any(target_arch = "bpf", target_arch = "sbf")))]
     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         let capture = match &self.inner {
             Inner::Unsupported => return fmt.write_str("unsupported backtrace"),
@@ -426,6 +458,11 @@ impl fmt::Display for Backtrace {
         f.finish()?;
         Ok(())
     }
+
+    #[cfg(any(target_arch = "bpf", target_arch = "sbf"))]
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(fmt, "<unsupported>")
+    }
 }
 
 type LazyResolve = impl (FnOnce() -> Capture) + Send + Sync + UnwindSafe;
@@ -460,8 +497,18 @@ fn lazy_resolve(mut capture: Capture) -> LazyResolve {
 
         capture
     }
+
+    #[cfg(any(target_arch = "bpf", target_arch = "sbf"))]
+    fn resolve(&mut self) {
+        // If we're already resolved, nothing to do!
+        if self.resolved {
+            return;
+        }
+        self.resolved = true;
+    }
 }
 
+#[cfg(not(any(target_arch = "bpf", target_arch = "sbf")))]
 impl RawFrame {
     fn ip(&self) -> *mut c_void {
         match self {

library/std/src/lib.rs

@@ -579,7 +579,6 @@ pub mod f64;
 #[macro_use]
 pub mod thread;
 pub mod ascii;
-#[cfg(all(not(target_arch = "bpf"), not(target_arch = "sbf")))]
 pub mod backtrace;
 pub mod collections;
 pub mod env;