tests: port backtrace's cpp_smoke_test as a run-make test

This test exercises the `backtrace` submodule included under the
`library/` tree, which should be the `backtrace` that is used and thus
transitively shipped with the standard library.

The `cpp_smoke_test` was disabled in the `backtrace` repo many years
ago. This is seemingly because the test failed years ago due to C++
symbol demangling troubles in `cpp_demangle` (which are now fixed; see
<gimli-rs/cpp_demangle#73>).

Note that this test is disabled on Windows MSVC because I couldn't get
it to work locally:

- At MSVC `-O1`, the test fails because there are no backtrace symbols.
- At MSVC `-O0`, the test fails because both the C++ templated
  trampolined symbol has a different signature (w/ a `__cdecl`) and also
  `cpp_trampoline` is missing.

Co-authored-by: Pyrode <[email protected]>

Author: jieyouxu

tests/run-make/cpp-smoke-test/cpp_smoke_test.rs

@@ -0,0 +1,72 @@
+extern crate backtrace;
+
+use std::sync::atomic::{AtomicBool, Ordering};
+
+unsafe extern "C" {
+    unsafe fn cpp_trampoline(func: extern "C" fn());
+}
+
+fn main() {
+    static RAN_ASSERTS: AtomicBool = AtomicBool::new(false);
+
+    extern "C" fn assert_cpp_frames() {
+        let mut physical_frames = Vec::new();
+        backtrace::trace(|cx| {
+            physical_frames.push(cx.ip());
+
+            // We only want to capture:
+            //
+            // 1. this closure's frame
+            // 2. `assert_cpp_frames`,
+            // 3. `space::templated_trampoline`, and
+            // 4. `cpp_trampoline`.
+            //
+            // Those are logical frames, which might be inlined into fewer physical frames, so we
+            // may end up with extra logical frames after resolving these.
+            physical_frames.len() < 4
+        });
+
+        let names: Vec<_> = physical_frames
+            .into_iter()
+            .flat_map(|ip| {
+                let mut logical_frame_names = vec![];
+
+                backtrace::resolve(ip, |sym| {
+                    let sym_name = sym.name().expect("Should have a symbol name");
+                    let demangled = sym_name.to_string();
+                    logical_frame_names.push(demangled);
+                });
+
+                assert!(
+                    !logical_frame_names.is_empty(),
+                    "Should have resolved at least one symbol for the physical frame"
+                );
+
+                logical_frame_names
+            })
+            // Skip the backtrace::trace closure and assert_cpp_frames, and then
+            // take the two C++ frame names.
+            .skip_while(|name| !name.contains("trampoline"))
+            .take(2)
+            .collect();
+
+        println!("actual names = {names:#?}");
+
+        let expected =
+            ["void space::templated_trampoline<void (*)()>(void (*)())", "cpp_trampoline"];
+        println!("expected names = {expected:#?}");
+
+        assert_eq!(names.len(), expected.len());
+        for (actual, expected) in names.iter().zip(expected.iter()) {
+            assert_eq!(actual, expected);
+        }
+
+        RAN_ASSERTS.store(true, Ordering::SeqCst);
+    }
+
+    assert!(!RAN_ASSERTS.load(Ordering::SeqCst));
+    unsafe {
+        cpp_trampoline(assert_cpp_frames);
+    }
+    assert!(RAN_ASSERTS.load(Ordering::SeqCst));
+}

tests/run-make/cpp-smoke-test/rmake.rs

@@ -0,0 +1,65 @@
+//! `backtrace`'s `cpp_smoke_test` ported to rust-lang/rust.
+//!
+//! A basic smoke test that exercises `backtrace` to see if it can resolve basic C++ templated +
+//! trampolined symbol names.
+
+//@ ignore-cross-compile (binary needs to run)
+//@ only-nightly
+
+//@ ignore-windows-msvc (test fails due to backtrace symbol mismatches)
+// FIXME: on MSVC, at `-O1`, there are no symbols available. At `-O0`, the test fails looking like:
+// ```
+// actual names = [
+//     "space::templated_trampoline<void (__cdecl*)(void)>",
+// ]
+// expected names = [
+//     "void space::templated_trampoline<void (*)()>(void (*)())",
+//     "cpp_trampoline",
+// ]
+// ```
+
+use run_make_support::rustc::sysroot;
+use run_make_support::{
+    build_native_static_lib_cxx_optimized, cargo, crate_cc, cwd, path, rfs, run, rustc,
+    source_root, target,
+};
+
+fn main() {
+    let target_dir = path("target");
+    let src_root = source_root();
+    let backtrace_submodule = src_root.join("library").join("backtrace");
+    let backtrace_toml = backtrace_submodule.join("Cargo.toml");
+
+    // Build the `backtrace` package (the `library/backtrace` submodule to make sure we exercise the
+    // same `backtrace` as shipped with std).
+    cargo()
+        // NOTE: needed to skip trying to link in `windows.0.52.0.lib` which is pre-built but not
+        // available in *this* scenario.
+        .env("RUSTFLAGS", "--cfg=windows_raw_dylib")
+        .arg("build")
+        .args(&["--manifest-path", &backtrace_toml.to_str().unwrap()])
+        .args(&["--target", &target()])
+        .arg("--features=cpp_demangle")
+        .env("CARGO_TARGET_DIR", &target_dir)
+        // Visual Studio 2022 requires that the LIB env var be set so it can
+        // find the Windows SDK.
+        .env("LIB", std::env::var("LIB").unwrap_or_default())
+        .run();
+
+    let rlibs_path = target_dir.join(target()).join("debug").join("deps");
+
+    // FIXME: this test is *really* fragile. Even on `x86_64-unknown-linux-gnu`, this fails if a
+    // different opt-level is passed. On `-O2` this test fails due to no symbols found. On `-O0`
+    // this test fails because it's missing one of the expected symbols.
+    build_native_static_lib_cxx_optimized("trampoline", "-O1");
+
+    rustc()
+        .input("cpp_smoke_test.rs")
+        .library_search_path(&rlibs_path)
+        .library_search_path(cwd())
+        .debuginfo("2")
+        .arg("-ltrampoline")
+        .run();
+
+    run("cpp_smoke_test");
+}

tests/run-make/cpp-smoke-test/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);
+}