Add a smoke test for capturing a backtrace with C++ symbols and demangling them

Author: fitzgen

Cargo.toml

@@ -35,6 +35,7 @@ backtrace-sys = { path = "backtrace-sys", version = "0.1.3", optional = true }
 
 [build-dependencies]
 serde_codegen = { version = "0.8", optional = true }
+gcc = { version = "0.3.43", optional = true }
 
 # Each feature controls the two phases of finding a backtrace: getting a
 # backtrace and then resolving instruction pointers to symbols. The default
@@ -45,7 +46,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", "cpp_demangle"]
+default = ["libunwind", "libbacktrace", "coresymbolication", "dladdr", "dbghelp", "demangle_cpp"]
 
     #=======================================
     # Methods of acquiring a backtrace
@@ -79,9 +80,12 @@ default = ["libunwind", "libbacktrace", "coresymbolication", "dladdr", "dbghelp"
     #   enough on OSX.
     # - coresymbolication: this feature uses the undocumented core symbolication
     #   framework on OS X to symbolize.
+    # - demangle_cpp: this feature enables demangling C++ symbols from C++
+    #   frames.
     libbacktrace = ["backtrace-sys"]
     dladdr = []
     coresymbolication = []
+    demangle_cpp = ["cpp_demangle", "gcc"]
 
     #=======================================
     # Methods of serialization

build.rs

@@ -25,6 +25,9 @@ fn main() {
 
     expand_serde(out_dir);
     println!("cargo:rerun-if-changed=src/capture.rs");
+
+    compile_cpp();
+    println!("cargo:rerun-if-changed=cpp/trampoline.cpp");
 }
 
 #[cfg(not(feature = "serialize-serde"))]
@@ -49,3 +52,23 @@ fn expand_serde(out_dir: &Path) {
         serde_codegen::expand(&out_dir.join("tmp.rs"), &dst).unwrap();
     }).unwrap().join().unwrap();
 }
+
+// TODO: how to only do this for tests? I tried to do:
+//
+// > #[cfg(all(test, feature = "demangle_cpp"))]
+//
+// but it did not work...
+#[cfg(feature = "demangle_cpp")]
+fn compile_cpp() {
+    extern crate gcc;
+
+    gcc::Config::new()
+        .cpp(true)
+        .debug(true)
+        .opt_level(0)
+        .file("cpp/trampoline.cpp")
+        .compile("libcpptrampoline.a");
+}
+
+#[cfg(not(feature = "demangle_cpp"))]
+fn compile_cpp() {}

cpp/trampoline.cpp

@@ -0,0 +1,14 @@
+#include <stdio.h>
+
+namespace space {
+    template <typename FuncT>
+    void templated_trampoline(FuncT func) {
+        func();
+    }
+}
+
+typedef void (*FuncPtr)();
+
+extern "C" void cpp_trampoline(FuncPtr func) {
+    space::templated_trampoline(func);
+}

tests/smoke.rs

@@ -165,3 +165,58 @@ fn is_serde() {
     is_serialize::<backtrace::Backtrace>();
     is_deserialize::<backtrace::Backtrace>();
 }
+
+#[test]
+#[inline(never)]
+#[cfg(all(not(target_os = "windows"), feature = "demangle_cpp"))]
+fn smoke_test_cpp() {
+    use std::sync::atomic::{ATOMIC_BOOL_INIT, AtomicBool, Ordering};
+
+    extern "C" {
+        fn cpp_trampoline(func: extern "C" fn()) -> ();
+    }
+
+    static RAN_ASSERTS: AtomicBool = ATOMIC_BOOL_INIT;
+
+    extern "C" fn assert_cpp_frames() {
+        let mut frames = Vec::new();
+        backtrace::trace(|cx| {
+            frames.push(cx.ip());
+
+            // Only capture this closure's frame, assert_cpp_frames,
+            // space::templated_trampoline, cpp_trampoline, and
+            // smoke_test_cpp. They should all be physical frames, and none
+            // should be inlined.
+            frames.len() < 5
+        });
+
+        let names: Vec<_> = frames.iter()
+            .map(|ip| {
+                let mut name = None;
+                backtrace::resolve(*ip, |sym| {
+                    assert!(name.is_none(), "Shouldn't have any inlined frames");
+                    name = Some(sym.name().unwrap().to_string());
+                });
+                name.unwrap()
+            })
+            .collect();
+
+        println!("FITZGEN: names = {:?}", names);
+
+        assert_eq!(names, [
+            "backtrace::backtrace::trace<closure>",
+            "smoke::smoke_test_cpp::assert_cpp_frames",
+            "void space::templated_trampoline<void (*)()>(void (*)())",
+            "cpp_trampoline",
+            "smoke::smoke_test_cpp"
+        ]);
+
+        RAN_ASSERTS.store(true, Ordering::SeqCst);
+    }
+
+    assert!(!RAN_ASSERTS.load(Ordering::SeqCst));
+    unsafe {
+        cpp_trampoline(assert_cpp_frames);
+    }
+    assert!(RAN_ASSERTS.load(Ordering::SeqCst));
+}