Add support for demangling C++ frames' symbols

This adds a new optional (but on-by-default) dependency on the `cpp_demangle`
crate. When this feature is enabled, if demangling a frame's symbol as a Rust
symbol fails, then we attempt to demangle it as a C++ symbol.

Author: fitzgen

Cargo.toml

@@ -22,6 +22,9 @@ rustc-demangle = "0.1"
 serde = { version = "0.8", optional = true }
 rustc-serialize = { version = "0.3", optional = true }
 
+# Optionally demangle C++ frames' symbols in backtraces.
+cpp_demangle = { version = "0.2", optional = true }
+
 [target.'cfg(windows)'.dependencies]
 dbghelp-sys = { version = "0.2", optional = true }
 kernel32-sys = { version = "0.2", optional = true }
@@ -42,7 +45,7 @@ serde_codegen = { version = "0.8", 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 = ["libunwind", "libbacktrace", "coresymbolication", "dladdr", "dbghelp", "cpp_demangle"]
 
     #=======================================
     # Methods of acquiring a backtrace

src/lib.rs

@@ -85,6 +85,9 @@ extern crate cfg_if;
 
 extern crate rustc_demangle;
 
+#[cfg(feature = "cpp_demangle")]
+extern crate cpp_demangle;
+
 #[allow(dead_code)] // not used everywhere
 #[cfg(unix)]
 #[macro_use]

src/symbolize/mod.rs

@@ -1,4 +1,7 @@
+use std::borrow::Cow;
 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;
@@ -108,26 +111,82 @@ impl fmt::Debug for Symbol {
     }
 }
 
+// Maybe a parsed C++ symbol, if parsing the mangled symbol as Rust failed.
+#[cfg(feature = "cpp_demangle")]
+struct OptionCppSymbol<'a>(Option<::cpp_demangle::BorrowedSymbol<'a>>);
+
+#[cfg(feature = "cpp_demangle")]
+impl<'a> OptionCppSymbol<'a> {
+    fn parse(input: &'a [u8]) -> OptionCppSymbol<'a> {
+        OptionCppSymbol(::cpp_demangle::BorrowedSymbol::with_tail(input)
+                            .ok()
+                            .map(|(sym, _tail)| sym))
+    }
+
+    fn none() -> OptionCppSymbol<'a> {
+        OptionCppSymbol(None)
+    }
+
+    fn as_str(&self) -> Option<Cow<'a, str>> {
+        self.0.as_ref().map(|cpp| Cow::from(format!("{}", cpp)))
+    }
+}
+
+// Make sure to keep this zero-sized, so that the `cpp_demangle` feature has no
+// cost when disabled.
+#[cfg(not(feature = "cpp_demangle"))]
+struct OptionCppSymbol<'a>(PhantomData<&'a ()>);
+
+#[cfg(not(feature = "cpp_demangle"))]
+impl<'a> OptionCppSymbol<'a> {
+    fn parse(_: &'a [u8]) -> OptionCppSymbol<'a> {
+        OptionCppSymbol(PhantomData)
+    }
+
+    fn none() -> OptionCppSymbol<'a> {
+        OptionCppSymbol(PhantomData)
+    }
+
+    fn as_str(&self) -> Option<Cow<'a, str>> {
+        None
+    }
+}
+
 /// A wrapper around a symbol name to provide ergonomic accessors to the
 /// demangled name, the raw bytes, the raw string, etc.
 pub struct SymbolName<'a> {
     bytes: &'a [u8],
     demangled: Option<Demangle<'a>>,
+    cpp_demangled: OptionCppSymbol<'a>,
 }
 
 impl<'a> SymbolName<'a> {
     /// Creates a new symbol name from the raw underlying bytes.
     pub fn new(bytes: &'a [u8]) -> SymbolName<'a> {
         let demangled = str::from_utf8(bytes).ok().map(demangle);
+
+        // Only try and parse a C++ symbol if we didn't parse a Rust symbol.
+        let cpp = if demangled.is_none() {
+            OptionCppSymbol::parse(bytes)
+        } else {
+            OptionCppSymbol::none()
+        };
+
         SymbolName {
             bytes: bytes,
             demangled: demangled,
+            cpp_demangled: cpp,
         }
     }
 
-    /// Returns the raw symbol name as `&str` if the symbols is valid utf-8.
-    pub fn as_str(&self) -> Option<&'a str> {
-        self.demangled.as_ref().map(|s| s.as_str())
+    /// Returns the raw symbol name as a `str` if the symbols is valid utf-8.
+    pub fn as_str(&self) -> Option<Cow<'a, str>> {
+        self.demangled
+            .as_ref()
+            .map(|s| Cow::from(s.as_str()))
+            .or_else(|| {
+                self.cpp_demangled.as_str()
+            })
     }
 
     /// Returns the raw symbol name as a list of bytes
@@ -137,6 +196,18 @@ impl<'a> SymbolName<'a> {
 }
 
 impl<'a> fmt::Display for SymbolName<'a> {
+    #[cfg(feature = "cpp_demangle")]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        if let Some(ref s) = self.demangled {
+            s.fmt(f)
+        } else if let Some(ref cpp) = self.cpp_demangled.0 {
+            cpp.fmt(f)
+        } else {
+            String::from_utf8_lossy(self.bytes).fmt(f)
+        }
+    }
+
+    #[cfg(not(feature = "cpp_demangle"))]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         if let Some(ref s) = self.demangled {
             s.fmt(f)
@@ -147,6 +218,18 @@ impl<'a> fmt::Display for SymbolName<'a> {
 }
 
 impl<'a> fmt::Debug for SymbolName<'a> {
+    #[cfg(feature = "cpp_demangle")]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        if let Some(ref s) = self.demangled {
+            s.fmt(f)
+        } else if let Some(ref cpp) = self.cpp_demangled.0 {
+            cpp.fmt(f)
+        } else {
+            String::from_utf8_lossy(self.bytes).fmt(f)
+        }
+    }
+
+    #[cfg(not(feature = "cpp_demangle"))]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         if let Some(ref s) = self.demangled {
             s.fmt(f)
@@ -185,4 +268,3 @@ cfg_if! {
         use self::noop::Symbol as SymbolImp;
     }
 }
-