no_std support

Author: Aaron Power

Cargo.toml

@@ -11,6 +11,9 @@ documentation = "https://docs.rs/backtrace"
 description = """
 A library to acquire a stack trace (backtrace) at runtime in a Rust program.
 """
+autoexamples = true
+autotests = true
+
 [dependencies]
 cfg-if = "0.1"
 rustc-demangle = "0.1.4"
@@ -47,7 +50,10 @@ backtrace-sys = { path = "backtrace-sys", version = "0.1.17", optional = true }
 # Note that not all features are available on all platforms, so even though a
 # feature is enabled some other feature may be used instead.
 [features]
-default = ["libunwind", "libbacktrace", "coresymbolication", "dladdr", "dbghelp"]
+default = ["std", "libunwind", "libbacktrace", "coresymbolication", "dladdr", "dbghelp"]
+
+# Include std support.
+std = []
 
 #=======================================
 # Methods of acquiring a backtrace
@@ -86,7 +92,7 @@ kernel32 = []
 #   the moment, this is only possible when targetting Linux, since macOS
 #   splits DWARF out into a separate object file. Enabling this feature
 #   means one less C dependency.
-libbacktrace = ["backtrace-sys"]
+libbacktrace = ["backtrace-sys", "std"]
 dladdr = []
 coresymbolication = []
 gimli-symbolize = ["addr2line", "findshlibs", "gimli", "memmap", "object" ]
@@ -97,3 +103,23 @@ gimli-symbolize = ["addr2line", "findshlibs", "gimli", "memmap", "object" ]
 # Various features used for enabling rustc-serialize or syntex codegen.
 serialize-rustc = ["rustc-serialize"]
 serialize-serde = ["serde", "serde_derive"]
+
+[[example]]
+name = "backtrace"
+required-features = ["std"]
+
+[[example]]
+name = "raw"
+required-features = ["std"]
+
+[[test]]
+name = "skip_inner_frames"
+required-features = ["std"]
+
+[[test]]
+name = "long_fn_name"
+required-features = ["std"]
+
+[[test]]
+name = "smoke"
+required-features = ["std"]

backtrace-sys/src/lib.rs

@@ -2,8 +2,7 @@
 
 extern crate libc;
 
-use libc::uintptr_t;
-use std::os::raw::{c_void, c_char, c_int};
+use libc::{c_void, c_char, c_int, uintptr_t};
 
 pub type backtrace_syminfo_callback =
     extern fn(data: *mut c_void,

src/backtrace/libunwind.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::os::raw::c_void;
+use types::c_void;
 
 pub struct Frame {
     ctx: *mut uw::_Unwind_Context,
@@ -84,7 +84,7 @@ mod uw {
     pub use self::_Unwind_Reason_Code::*;
 
     use libc;
-    use std::os::raw::{c_int, c_void};
+    use types::{c_int, c_void};
 
     #[repr(C)]
     pub enum _Unwind_Reason_Code {

src/backtrace/mod.rs

@@ -1,6 +1,5 @@
-use std::fmt;
-
-use std::os::raw::c_void;
+#[cfg(feature = "std")] use std::fmt;
+use types::c_void;
 
 /// Inspects the current call-stack, passing all active frames into the closure
 /// provided to calculate a stack trace.
@@ -77,6 +76,7 @@ impl Frame {
     }
 }
 
+#[cfg(feature = "std")]
 impl fmt::Debug for Frame {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.debug_struct("Frame")

src/backtrace/noop.rs

@@ -1,4 +1,4 @@
-use std::os::raw::c_void;
+use types::c_void;
 
 #[inline(always)]
 pub fn trace(_cb: &mut FnMut(&super::Frame) -> bool) {}

src/backtrace/unix_backtrace.rs

@@ -8,8 +8,14 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::mem;
-use std::os::raw::{c_void, c_int};
+cfg_if! {
+    if #[cfg(feature = "std")] {
+        use std::mem;
+    } else {
+        use core::mem;
+    }
+}
+use types::{c_void, c_int};
 
 pub struct Frame {
     addr: *mut c_void,

src/capture.rs

@@ -1,9 +1,14 @@
-use std::fmt;
-use std::mem;
-use std::os::raw::c_void;
-use std::path::{Path, PathBuf};
+cfg_if! {
+    if #[cfg(feature = "std")] {
+        use std::fmt;
+        use std::mem;
+        use std::path::{Path, PathBuf};
 
-use {trace, resolve, SymbolName};
+        use {trace, resolve, SymbolName};
+    }
+}
+
+use types::c_void;
 
 /// Representation of an owned and self-contained backtrace.
 ///
@@ -12,6 +17,7 @@ use {trace, resolve, SymbolName};
 #[derive(Clone)]
 #[cfg_attr(feature = "serialize-rustc", derive(RustcDecodable, RustcEncodable))]
 #[cfg_attr(feature = "serialize-serde", derive(Deserialize, Serialize))]
+#[cfg(feature = "std")]
 pub struct Backtrace {
     // Frames here are listed from top-to-bottom of the stack
     frames: Vec<BacktraceFrame>,
@@ -30,6 +36,7 @@ pub struct Backtrace {
 pub struct BacktraceFrame {
     ip: usize,
     symbol_address: usize,
+    #[cfg(feature = "std")]
     symbols: Option<Vec<BacktraceSymbol>>,
 }
 
@@ -41,12 +48,15 @@ pub struct BacktraceFrame {
 #[cfg_attr(feature = "serialize-rustc", derive(RustcDecodable, RustcEncodable))]
 #[cfg_attr(feature = "serialize-serde", derive(Deserialize, Serialize))]
 pub struct BacktraceSymbol {
+    #[cfg(feature = "std")]
     name: Option<Vec<u8>>,
     addr: Option<usize>,
+    #[cfg(feature = "std")]
     filename: Option<PathBuf>,
     lineno: Option<u32>,
 }
 
+#[cfg(feature = "std")]
 impl Backtrace {
     /// Captures a backtrace at the callsite of this function, returning an
     /// owned representation.
@@ -153,6 +163,7 @@ impl Backtrace {
     }
 }
 
+#[cfg(feature = "std")]
 impl From<Vec<BacktraceFrame>> for Backtrace {
     fn from(frames: Vec<BacktraceFrame>) -> Self {
         Backtrace {
@@ -162,6 +173,7 @@ impl From<Vec<BacktraceFrame>> for Backtrace {
     }
 }
 
+#[cfg(feature = "std")]
 impl Into<Vec<BacktraceFrame>> for Backtrace {
     fn into(self) -> Vec<BacktraceFrame> {
         self.frames
@@ -188,13 +200,15 @@ impl BacktraceFrame {
     ///
     /// Note that if this frame came from an unresolved backtrace then this will
     /// return an empty list.
+    #[cfg(feature = "std")]
     pub fn symbols(&self) -> &[BacktraceSymbol] {
         self.symbols.as_ref().map(|s| &s[..]).unwrap_or(&[])
     }
 }
 
 impl BacktraceSymbol {
     /// Same as `Symbol::name`
+    #[cfg(feature = "std")]
     pub fn name(&self) -> Option<SymbolName> {
         self.name.as_ref().map(|s| SymbolName::new(s))
     }
@@ -205,6 +219,7 @@ impl BacktraceSymbol {
     }
 
     /// Same as `Symbol::filename`
+    #[cfg(feature = "std")]
     pub fn filename(&self) -> Option<&Path> {
         self.filename.as_ref().map(|p| &**p)
     }
@@ -215,6 +230,7 @@ impl BacktraceSymbol {
     }
 }
 
+#[cfg(feature = "std")]
 impl fmt::Debug for Backtrace {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         let hex_width = mem::size_of::<usize>() * 2 + 2;
@@ -263,6 +279,7 @@ impl fmt::Debug for Backtrace {
     }
 }
 
+#[cfg(feature = "std")]
 impl Default for Backtrace {
     fn default() -> Backtrace {
         Backtrace::new()

src/lib.rs

@@ -46,6 +46,7 @@
 //! extern crate backtrace;
 //!
 //! fn main() {
+//! #   #[cfg(feature = "std")]
 //!     backtrace::trace(|frame| {
 //!         let ip = frame.ip();
 //!         let symbol_address = frame.symbol_address();
@@ -67,6 +68,7 @@
 
 #![doc(html_root_url = "https://docs.rs/backtrace")]
 #![deny(missing_docs)]
+#![cfg_attr(not(feature = "std"), no_std)]
 
 #[cfg(unix)]
 extern crate libc;
@@ -98,7 +100,7 @@ cfg_if! {
 }
 
 #[allow(dead_code)] // not used everywhere
-#[cfg(unix)]
+#[cfg(all(unix, feature = "std"))]
 #[macro_use]
 mod dylib;
 
@@ -108,9 +110,13 @@ mod backtrace;
 pub use symbolize::{resolve, Symbol, SymbolName};
 mod symbolize;
 
-pub use capture::{Backtrace, BacktraceFrame, BacktraceSymbol};
+#[cfg(feature = "std")]
+pub use capture::Backtrace;
+pub use capture::{BacktraceFrame, BacktraceSymbol};
 mod capture;
 
+mod types;
+
 #[allow(dead_code)]
 struct Bomb {
     enabled: bool,
@@ -126,6 +132,7 @@ impl Drop for Bomb {
 }
 
 #[allow(dead_code)]
+#[cfg(feature = "std")]
 mod lock {
     use std::cell::Cell;
     use std::sync::{Once, Mutex, MutexGuard, ONCE_INIT};

src/symbolize/coresymbolication.rs

@@ -12,7 +12,6 @@
 
 use std::ffi::{CStr, OsStr};
 use std::mem;
-use std::os::raw::{c_void, c_char, c_int};
 use std::os::unix::prelude::*;
 use std::path::Path;
 use std::ptr;
@@ -23,6 +22,7 @@ use libc::{self, Dl_info};
 use SymbolName;
 use dylib::Dylib;
 use dylib::Symbol as DylibSymbol;
+use types::{c_void, c_char, c_int};
 
 #[repr(C)]
 #[derive(Copy, Clone, PartialEq)]

src/symbolize/dladdr.rs

@@ -8,20 +8,22 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::ffi::CStr;
-use std::mem;
-use std::os::raw::c_void;
-use std::path::Path;
+use core::mem;
 
+#[cfg(feature = "std")] use std::ffi::CStr;
+#[cfg(feature = "std")] use std::path::Path;
+
+use types::c_void;
 use libc::{self, Dl_info};
 
-use SymbolName;
+#[cfg(feature = "std")] use SymbolName;
 
 pub struct Symbol {
     inner: Dl_info,
 }
 
 impl Symbol {
+    #[cfg(feature = "std")]
     pub fn name(&self) -> Option<SymbolName> {
         if self.inner.dli_sname.is_null() {
             None
@@ -36,6 +38,7 @@ impl Symbol {
         Some(self.inner.dli_saddr as *mut _)
     }
 
+    #[cfg(feature = "std")]
     pub fn filename(&self) -> Option<&Path> {
         None
     }

src/symbolize/gimli.rs

@@ -7,7 +7,7 @@ use std::cell::RefCell;
 use std::env;
 use std::fs::File;
 use std::mem;
-use std::os::raw::c_void;
+use libc::c_void;
 use std::path::{Path, PathBuf};
 use std::u32;
 

src/symbolize/libbacktrace.rs

@@ -12,14 +12,14 @@
 
 extern crate backtrace_sys as bt;
 
-use libc::uintptr_t;
 use std::ffi::{CStr, OsStr};
-use std::os::raw::{c_void, c_char, c_int};
 use std::os::unix::prelude::*;
 use std::path::Path;
 use std::ptr;
 use std::sync::{ONCE_INIT, Once};
 
+use libc::{c_char, c_int, c_void, uintptr_t};
+
 use SymbolName;
 
 pub enum Symbol {
@@ -169,11 +169,11 @@ pub fn resolve(symaddr: *mut c_void, mut cb: &mut FnMut(&super::Symbol)) {
         }
 
         let ret = bt::backtrace_pcinfo(state, symaddr as uintptr_t,
-                                       pcinfo_cb, error_cb,
+                                       pcinfo_cb as *mut _, error_cb as *mut _,
                                        &mut cb as *mut _ as *mut _);
         if ret != 0 {
             bt::backtrace_syminfo(state, symaddr as uintptr_t,
-                                  syminfo_cb, error_cb,
+                                  syminfo_cb as *mut _, error_cb as *mut _,
                                   &mut cb as *mut _ as *mut _);
         }
     }

src/symbolize/mod.rs

@@ -1,9 +1,27 @@
-use std::fmt;
-#[cfg(not(feature = "cpp_demangle"))]
-use std::marker::PhantomData;
-use std::os::raw::c_void;
-use std::path::Path;
-use std::str;
+cfg_if! {
+    if #[cfg(feature = "std")] {
+        use std::fmt;
+        use std::path::Path;
+    }
+}
+
+cfg_if! {
+    if #[cfg(all(feature = "std", not(feature = "cpp_demangle")))] {
+        use std::marker::PhantomData;
+    } else if #[cfg(not(feature = "cpp_demangle"))] {
+        use core::marker::PhantomData;
+    }
+}
+
+cfg_if! {
+    if #[cfg(feature = "std")] {
+        use std::str;
+    } else {
+        use core::str;
+    }
+}
+
+use types::c_void;
 use rustc_demangle::{try_demangle, Demangle};
 
 /// Resolve an address to a symbol, passing the symbol to the specified
@@ -37,7 +55,7 @@ use rustc_demangle::{try_demangle, Demangle};
 /// }
 /// ```
 pub fn resolve<F: FnMut(&Symbol)>(addr: *mut c_void, mut cb: F) {
-    resolve_imp(addr, &mut cb)
+    resolve_imp(addr as *mut _, &mut cb)
 }
 
 /// A trait representing the resolution of a symbol in a file.
@@ -63,13 +81,14 @@ impl Symbol {
     /// * The raw `str` value of the symbol can be accessed (if it's valid
     ///   utf-8).
     /// * The raw bytes for the symbol name can be accessed.
+    #[cfg(not(all(not(feature = "std"), feature = "dladdr")))]
     pub fn name(&self) -> Option<SymbolName> {
         self.inner.name()
     }
 
     /// Returns the starting address of this function.
     pub fn addr(&self) -> Option<*mut c_void> {
-        self.inner.addr()
+        self.inner.addr().map(|p| p as *mut _)
     }
 
     /// Returns the file name where this function was defined.
@@ -78,6 +97,7 @@ impl Symbol {
     /// unix platforms other than OSX) and when a binary is compiled with
     /// debuginfo. If neither of these conditions is met then this will likely
     /// return `None`.
+    #[cfg(feature = "std")]
     pub fn filename(&self) -> Option<&Path> {
         self.inner.filename()
     }
@@ -91,6 +111,7 @@ impl Symbol {
     }
 }
 
+#[cfg(feature = "std")]
 impl fmt::Debug for Symbol {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let mut d = f.debug_struct("Symbol");
@@ -189,7 +210,7 @@ impl<'a> SymbolName<'a> {
 }
 
 cfg_if! {
-    if #[cfg(feature = "cpp_demangle")] {
+    if #[cfg(all(feature = "cpp_demangle", feature = "std"))] {
         impl<'a> fmt::Display for SymbolName<'a> {
             fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
                 if let Some(ref s) = self.demangled {
@@ -201,7 +222,7 @@ cfg_if! {
                 }
             }
         }
-    } else {
+    } else if #[cfg(feature = "std")] {
         impl<'a> fmt::Display for SymbolName<'a> {
             fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
                 if let Some(ref s) = self.demangled {
@@ -215,7 +236,7 @@ cfg_if! {
 }
 
 cfg_if! {
-    if #[cfg(feature = "cpp_demangle")] {
+    if #[cfg(all(feature = "cpp_demangle", feature = "std"))] {
         impl<'a> fmt::Debug for SymbolName<'a> {
             fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
                 use std::fmt::Write;
@@ -237,7 +258,7 @@ cfg_if! {
                 String::from_utf8_lossy(self.bytes).fmt(f)
             }
         }
-    } else {
+    } else if #[cfg(feature = "std")] {
         impl<'a> fmt::Debug for SymbolName<'a> {
             fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
                 if let Some(ref s) = self.demangled {
@@ -255,7 +276,8 @@ cfg_if! {
         mod dbghelp;
         use self::dbghelp::resolve as resolve_imp;
         use self::dbghelp::Symbol as SymbolImp;
-    } else if #[cfg(all(feature = "gimli-symbolize",
+    } else if #[cfg(all(feature = "std",
+                        feature = "gimli-symbolize",
                         unix,
                         target_os = "linux"))] {
         mod gimli;

src/symbolize/noop.rs

@@ -1,6 +1,6 @@
-use std::path::Path;
-use std::os::raw::c_void;
+#[cfg(feature = "std")] use std::path::Path;
 
+use types::c_void;
 use SymbolName;
 
 pub fn resolve(_addr: *mut c_void, _cb: &mut FnMut(&super::Symbol)) {
@@ -17,6 +17,7 @@ impl Symbol {
         None
     }
 
+    #[cfg(feature = "std")]
     pub fn filename(&self) -> Option<&Path> {
         None
     }

src/types.rs

@@ -0,0 +1,10 @@
+cfg_if! {
+    if #[cfg(feature = "std")] {
+        pub use std::os::raw::*;
+    } else if #[cfg(all(windows, feature = "winapi"))] {
+        pub use winapi::ctypes::*;
+    } else {
+        pub use libc::*;
+    }
+}
+