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,

examples/raw.rs

@@ -33,7 +33,7 @@ fn print() {
             }
             if let Some(file) = symbol.filename() {
                 if let Some(l) = symbol.lineno() {
-                    print!("\n{:13}{:4$}@ {}:{}", "", "", file.display(), l,
+                    print!("\n{:13}{:4$}@ {}:{}", "", "", file.into_path_buf().display(), l,
                            HEX_WIDTH);
                 }
             }

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;
+use types::c_void;
 
 /// Inspects the current call-stack, passing all active frames into the closure
 /// provided to calculate a stack trace.
@@ -37,10 +36,20 @@ use std::os::raw::c_void;
 /// }
 /// ```
 #[inline(never)]
+#[cfg(feature = "std")]
 pub fn trace<F: FnMut(&Frame) -> bool>(mut cb: F) {
     trace_imp(&mut cb)
 }
 
+/// Without std this function now does not have synchronization guarentees.
+/// Please refer to std documentation for examples and explaination.
+#[inline(never)]
+#[cfg(not(feature = "std"))]
+pub unsafe fn trace<F: FnMut(&Frame) -> bool>(mut cb: F) {
+    trace_imp(&mut cb)
+}
+
+
 /// A trait representing one frame of a backtrace, yielded to the `trace`
 /// function of this crate.
 ///

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

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 use std::mem;
-use std::os::raw::{c_void, c_int};
+use types::{c_void, c_int};
 
 pub struct Frame {
     addr: *mut c_void,

src/capture.rs

@@ -1,9 +1,9 @@
 use std::fmt;
 use std::mem;
-use std::os::raw::c_void;
 use std::path::{Path, PathBuf};
 
 use {trace, resolve, SymbolName};
+use types::c_void;
 
 /// Representation of an owned and self-contained backtrace.
 ///
@@ -144,7 +144,7 @@ impl Backtrace {
                 symbols.push(BacktraceSymbol {
                     name: symbol.name().map(|m| m.as_bytes().to_vec()),
                     addr: symbol.addr().map(|a| a as usize),
-                    filename: symbol.filename().map(|m| m.to_path_buf()),
+                    filename: symbol.filename().map(|m| m.into_path_buf()),
                     lineno: symbol.lineno(),
                 });
             });

src/lib.rs

@@ -46,6 +46,8 @@
 //! extern crate backtrace;
 //!
 //! fn main() {
+//! # // Unsafe here so test passes on no_std.
+//! # unsafe {
 //!     backtrace::trace(|frame| {
 //!         let ip = frame.ip();
 //!         let symbol_address = frame.symbol_address();
@@ -63,10 +65,15 @@
 //!         true // keep going to the next frame
 //!     });
 //! }
+//! # }
 //! ```
 
 #![doc(html_root_url = "https://docs.rs/backtrace")]
 #![deny(missing_docs)]
+#![cfg_attr(not(feature = "std"), no_std)]
+
+#[cfg(not(feature = "std"))]
+extern crate core as std;
 
 #[cfg(unix)]
 extern crate libc;
@@ -98,7 +105,7 @@ cfg_if! {
 }
 
 #[allow(dead_code)] // not used everywhere
-#[cfg(unix)]
+#[cfg(all(unix, feature = "std"))]
 #[macro_use]
 mod dylib;
 
@@ -108,9 +115,13 @@ mod backtrace;
 pub use symbolize::{resolve, Symbol, SymbolName};
 mod symbolize;
 
+#[cfg(feature = "std")]
 pub use capture::{Backtrace, BacktraceFrame, BacktraceSymbol};
+#[cfg(feature = "std")]
 mod capture;
 
+mod types;
+
 #[allow(dead_code)]
 struct Bomb {
     enabled: bool,
@@ -126,6 +137,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

@@ -10,11 +10,8 @@
 
 #![allow(bad_style)]
 
-use std::ffi::{CStr, OsStr};
+use std::ffi::CStr;
 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;
 use std::sync::atomic::ATOMIC_USIZE_INIT;
 
@@ -23,6 +20,7 @@ use libc::{self, Dl_info};
 use SymbolName;
 use dylib::Dylib;
 use dylib::Symbol as DylibSymbol;
+use types::{BytesOrWideString, c_void, c_char, c_int};
 
 #[repr(C)]
 #[derive(Copy, Clone, PartialEq)]
@@ -69,15 +67,15 @@ impl Symbol {
         }
     }
 
-    pub fn filename(&self) -> Option<&Path> {
+    pub fn filename(&self) -> Option<BytesOrWideString> {
         match *self {
             Symbol::Core { path, .. } => {
                 if path.is_null() {
                     None
                 } else {
-                    Some(Path::new(OsStr::from_bytes(unsafe {
+                    Some(BytesOrWideString::Bytes(unsafe {
                         CStr::from_ptr(path).to_bytes()
-                    })))
+                    }))
                 }
             }
             Symbol::Dladdr(_) => None,

src/symbolize/dbghelp.rs

@@ -10,10 +10,7 @@
 
 #![allow(bad_style)]
 
-use std::ffi::OsString;
 use std::mem;
-use std::path::Path;
-use std::os::windows::prelude::*;
 use std::slice;
 use winapi::ctypes::*;
 use winapi::shared::basetsd::*;
@@ -25,10 +22,10 @@ use winapi::um::dbghelp::*;
 use SymbolName;
 
 pub struct Symbol {
-    name: OsString,
+    name: BytesOrWideString,
     addr: *mut c_void,
     line: Option<u32>,
-    filename: Option<OsString>,
+    filename: Option<BytesOrWideString>,
 }
 
 impl Symbol {
@@ -40,8 +37,8 @@ impl Symbol {
         Some(self.addr as *mut _)
     }
 
-    pub fn filename(&self) -> Option<&Path> {
-        self.filename.as_ref().map(Path::new)
+    pub fn filename(&self) -> Option<BytesOrWideString> {
+        self.filename.clone()
     }
 
     pub fn lineno(&self) -> Option<u32> {
@@ -83,7 +80,7 @@ pub fn resolve(addr: *mut c_void, cb: &mut FnMut(&super::Symbol)) {
 
         let name = slice::from_raw_parts(info.Name.as_ptr() as *const u16,
                                          name_len);
-        let name = OsString::from_wide(name);
+        let name = BytesOrWideString::Wide(name);
 
         let mut line = mem::zeroed::<IMAGEHLP_LINEW64>();
         line.SizeOfStruct = mem::size_of::<IMAGEHLP_LINEW64>() as DWORD;
@@ -103,15 +100,15 @@ pub fn resolve(addr: *mut c_void, cb: &mut FnMut(&super::Symbol)) {
                 len += 1;
             }
             let name = slice::from_raw_parts(base, len as usize);
-            filename = Some(OsString::from_wide(name));
+            filename = Some(BytesOrWideString::Wide(name));
         }
 
         cb(&super::Symbol {
             inner: Symbol {
-                name: name,
+                name,
                 addr: info.Address as *mut _,
                 line: lineno,
-                filename: filename,
+                filename,
             },
         })
     }

src/symbolize/dladdr.rs

@@ -8,11 +8,9 @@
 // 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 std::{mem, slice};
 
+use types::{BytesOrWideString, c_void};
 use libc::{self, Dl_info};
 
 use SymbolName;
@@ -26,17 +24,19 @@ impl Symbol {
         if self.inner.dli_sname.is_null() {
             None
         } else {
-            Some(SymbolName::new(unsafe {
-                CStr::from_ptr(self.inner.dli_sname).to_bytes()
-            }))
+            let ptr = self.inner.dli_sname as *const u8;
+            unsafe {
+                let len = libc::strlen(self.inner.dli_sname);
+                Some(SymbolName::new(slice::from_raw_parts(ptr, len)))
+            }
         }
     }
 
     pub fn addr(&self) -> Option<*mut c_void> {
         Some(self.inner.dli_saddr as *mut _)
     }
 
-    pub fn filename(&self) -> Option<&Path> {
+    pub fn filename(&self) -> Option<BytesOrWideString> {
         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;
 
@@ -209,8 +209,8 @@ impl Symbol {
         Some(self.addr as *mut c_void)
     }
 
-    pub fn filename(&self) -> Option<&Path> {
-        self.file.as_ref().map(|f| f.as_ref())
+    pub fn filename(&self) -> Option<BytesOrWideString> {
+        self.file.as_ref().map(|f| BytesOrWideString::Bytes(f.as_bytes()))
     }
 
     pub fn lineno(&self) -> Option<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 {