Add tests for unprefixed

- A test that checks that jemalloc's malloc and libc's free are
  interoperable when unprefixed.
- A test that checks that using unprefixed with a shared library still
  overrides the symbols in the shared library.

Author: madsmtm

Cargo.toml

@@ -1,2 +1,8 @@
 [workspace]
-members = ["jemallocator", "jemallocator-global", "jemalloc-ctl", "jemalloc-sys"]
+members = [
+    "jemallocator",
+    "jemallocator-global",
+    "jemalloc-ctl",
+    "jemalloc-sys",
+    "test-dylib",
+]

ci/run.sh

@@ -77,3 +77,14 @@ cargo test --target "${TARGET}" \
 #     # The Alloc trait is unstable:
 #     ${CARGO_CMD} test --target "${TARGET}" --features alloc_trait
 # fi
+
+# Test that unprefixed_malloc_on_supported_platforms works in dylibs.
+case "$TARGET" in
+  *gnu*)
+    cargo run --target "${TARGET}" \
+        -p test-dylib \
+        --features unprefixed_malloc_on_supported_platforms
+    ;;
+  *)
+    ;;
+esac

jemalloc-sys/tests/unprefixed_malloc.rs

@@ -9,3 +9,16 @@ fn malloc_is_prefixed() {
 fn malloc_is_overridden() {
     assert_eq!(tikv_jemalloc_sys::malloc as usize, libc::malloc as usize)
 }
+
+#[cfg(any(
+    not(prefixed),
+    all(
+        feature = "unprefixed_malloc_on_supported_platforms",
+        target_vendor = "apple"
+    ),
+))]
+#[test]
+fn malloc_and_libc_are_interoperable_when_overridden() {
+    let ptr = unsafe { tikv_jemalloc_sys::malloc(42) };
+    unsafe { libc::free(ptr) };
+}

test-dylib/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "test-dylib"
+version = "0.0.0"
+license = "MIT OR Apache-2.0"
+description = "A test helper for jemalloc-sys"
+edition = "2018"
+publish = false
+
+[dependencies]
+libc = { version = "^0.2.8", default-features = false }
+tikv-jemalloc-sys = { path = "../jemalloc-sys" }
+
+[build-dependencies]
+cc = "^1.0.13"
+
+[features]
+unprefixed_malloc_on_supported_platforms = [
+    "tikv-jemalloc-sys/unprefixed_malloc_on_supported_platforms",
+]
+
+[[bin]]
+name = "test-dylib"
+test = false

test-dylib/build.rs

@@ -0,0 +1,29 @@
+//! Build shared library `dep.c`.
+use std::{env, path::PathBuf};
+
+fn main() {
+    println!("cargo:rerun-if-changed=src/dep.c");
+
+    let out_dir = PathBuf::from(std::env::var_os("OUT_DIR").unwrap());
+
+    // NOTE: Only for testing, extension is wrong when cross-compiling.
+    let dylib = out_dir.join(format!(
+        "{}dep{}",
+        env::consts::DLL_PREFIX,
+        env::consts::DLL_SUFFIX
+    ));
+
+    let status = cc::Build::new()
+        .get_compiler()
+        .to_command()
+        .arg("src/dep.c")
+        .arg("-shared")
+        .arg("-o")
+        .arg(&dylib)
+        .status()
+        .unwrap();
+    assert!(status.success());
+
+    println!("cargo:rustc-link-lib=dylib=dep");
+    println!("cargo:rustc-link-search=native={}", out_dir.display());
+}

test-dylib/src/dep.c

@@ -0,0 +1,13 @@
+#define _GNU_SOURCE
+#include <stdlib.h>
+#include <stdio.h>
+#include <dlfcn.h>
+
+const char* lookup_malloc_address(void) {
+    Dl_info info;
+    if (!dladdr((void *)malloc, &info)) {
+        printf("failed finding `malloc`\n");
+        abort();
+    }
+    return info.dli_fname;
+}

test-dylib/src/main.rs

@@ -0,0 +1,39 @@
+//! Test that the symbol address of `malloc` in shared libraries come from
+//! the place we'd expect it to.
+use core::ffi::{c_char, CStr};
+use std::{env, path::Path};
+
+use tikv_jemalloc_sys as _;
+
+extern "C-unwind" {
+    fn lookup_malloc_address() -> *const c_char;
+}
+
+fn main() {
+    let actual = unsafe { CStr::from_ptr(lookup_malloc_address()).to_str().unwrap() };
+
+    if cfg!(target_vendor = "apple") {
+        // macOS / Mach-O symbols are not overriden, they are hooked into with
+        // `zone_register`.
+        assert_eq!(actual, "/usr/lib/system/libsystem_malloc.dylib");
+    } else if cfg!(all(target_os = "linux", target_env = "gnu")) {
+        if cfg!(feature = "unprefixed_malloc_on_supported_platforms") {
+            // When unprefixed, `malloc` is loaded from the current exe.
+            // `target/*/debug/test-dylib`
+            let dir = env::current_dir().unwrap();
+            let exe = env::current_exe().unwrap();
+            assert_eq!(Path::new(actual), exe.strip_prefix(dir).unwrap());
+        } else if cfg!(target_arch = "x86_64") {
+            // Otherwise, the system `libc` contains `malloc`.
+            assert_eq!(actual, "/lib/x86_64-linux-gnu/libc.so.6");
+        } else if cfg!(target_arch = "x86") {
+            assert_eq!(actual, "/lib/i386-linux-gnu/libc.so.6");
+        } else if cfg!(target_arch = "aarch64") {
+            assert_eq!(actual, "/lib/aarch64-linux-gnu/libc.so.6");
+        } else {
+            panic!("unknown architecture. {:?}", actual);
+        }
+    } else {
+        panic!("unsupported platform for this test. {:?}", actual);
+    };
+}