Properly link the library

Author: gnzlbg

Cargo.toml

@@ -26,8 +26,8 @@ checked = []
 [workspace]
 members = [
   "crates/compiler-builtins-smoke-test",
-  "crates/libm-cdylib",
   "crates/libm-bench",
+  "crates/libm-cdylib",
 ]
 
 [dev-dependencies]

azure-pipelines.yml

@@ -37,8 +37,11 @@ jobs:
           TARGET: powerpc64-unknown-linux-gnu
         powerpc64le:
           TARGET: powerpc64le-unknown-linux-gnu
-        x86_64:
+        x86_64_stable:
           TARGET: x86_64-unknown-linux-gnu
+        x86_64_nightly:
+          TARGET: x86_64-unknown-linux-gnu
+          TOOLCHAIN: nightly
 
   - job: OSX
     pool:

ci/run.sh

@@ -24,10 +24,12 @@ fi
 $CMD --features "stable checked"
 $CMD --release --features  "stable checked ${TEST_MUSL}"
 
-if [ "$TARGET" = "x86_64-unknown-linux-gnu" ] || [ "${TARGET}" = "x86_64-apple-darwin" ]; then
-    (
-        cd crates/libm-cdylib
-        cargo test
-        cargo test --release
-    )
+if rustc --version | grep "nightly" ; then
+    if [ "$TARGET" = "x86_64-unknown-linux-gnu" ] || [ "${TARGET}" = "x86_64-apple-darwin" ]; then
+        (
+            cd crates/libm-cdylib
+            cargo test
+            cargo test --release
+        )
+    fi
 fi

crates/libm-cdylib/build.rs

@@ -5,4 +5,13 @@ fn main() {
     if profile == "release" {
         println!("cargo:rustc-cfg=release_profile");
     }
+    let nightly = {
+        let mut cmd = std::process::Command::new("rustc");
+        cmd.arg("--version");
+        let output = String::from_utf8(cmd.output().unwrap().stdout).unwrap();
+        output.contains("nightly")
+    };
+    if nightly {
+        println!("cargo:rustc-cfg=unstable_rust");
+    }
 }

crates/libm-cdylib/src/lib.rs

@@ -1,3 +1,10 @@
+#![cfg(
+    // The tests are only enabled on x86 32/64-bit linux/macos:
+    all(unstable_rust,
+        any(target_os = "linux", target_os = "macos"),
+        any(target_arch = "x86", target_arch = "x86_64")
+    )
+)]
 #![allow(dead_code)]
 #![cfg_attr(not(test), feature(core_intrinsics, lang_items))]
 #![cfg_attr(not(test), no_std)]

crates/libm-cdylib/src/macros.rs

@@ -25,6 +25,9 @@ macro_rules! export {
             fn [<$id _link_test>]() {
                 use crate::test_utils::*;
 
+                // This re-compiles the dynamic library:
+                compile_cdylib();
+
                 // Generate a small C program that calls the C API from
                 // <math.h>. This program prints the result into an appropriate
                 // type, that is then printed to stdout.
@@ -55,10 +58,9 @@ macro_rules! export {
 
                 // We now compile the C program into an executable, make sure
                 // that the libm-cdylib has been generated (and generate it if
-                // it isn't), and then we run the program, override the libm
-                // dynamically, and verify the result.
+                // it isn't), and then we run the program, override the libm,
+                // and verify the result.
                 compile_file(&src_path, &bin_path);
-                compile_cdylib();
                 check(&bin_path, $test_ret as $ret_ty)
             }
         }

crates/libm-cdylib/src/test_utils.rs

@@ -45,6 +45,21 @@ pub(crate) fn compile_file(src_path: &Path, bin_path: &Path) {
         .arg("-o")
         .arg(bin_path)
         .arg(src_path);
+
+    // Link our libm
+    let lib_path = cdylib_dir();
+    {
+        let mut ls = process::Command::new("ls");
+        ls.arg(lib_path.clone());
+        let output = ls.output().unwrap();
+        let output = String::from_utf8(output.stdout).unwrap();
+        println!("ls\n{}]n", output);
+    }
+    cmd.arg(format!("-L{}", lib_path.display()));
+    cmd.arg("-llibm");
+
+    eprintln!("compile cmd: {:?}", cmd);
+
     handle_err(
         &format!("compile file: {}", src_path.display()),
         &cmd.output().unwrap(),
@@ -59,25 +74,12 @@ where
 {
     let mut cmd = process::Command::new(path);
 
-    // Find the cdylib - we just support standard locations for now.
-    let libm_path = target_dir().join(if cfg!(release_profile) {
-        "release"
-    } else {
-        "debug"
-    });
-
-    // Replace libm at runtime
-    if cfg!(target_os = "macos") {
-        let lib_path = libm_path.join("liblibm.dylib");
-        // for debugging:
-        // cmd.env("DYLD_PRINT_LIBRARIES", "1");
-        // cmd.env("X", "1");
-        cmd.env("DYLD_FORCE_FLAT_NAMESPACE", "1");
-        cmd.env("DYLD_INSERT_LIBRARIES", lib_path.display().to_string());
-    } else if cfg!(target_os = "linux") {
-        let lib_path = libm_path.join("liblibm.so");
-        cmd.env("LD_PRELOAD", lib_path.display().to_string());
+    if cfg!(target_os = "linux") {
+        let ld_library_path = std::env::var("LD_LIBRARY_PATH").unwrap_or_default();
+        let ld_library_path = format!("{}:{}", cdylib_dir().display(), ld_library_path);
+        cmd.env("LD_LIBRARY_PATH", ld_library_path);
     }
+
     // Run the binary:
     let output = cmd.output().unwrap();
     handle_err(&format!("run file: {}", path.display()), &output);
@@ -150,3 +152,22 @@ pub(crate) fn target_dir() -> std::path::PathBuf {
         Path::new("../../target").into()
     }
 }
+
+pub(crate) fn cdylib_dir() -> std::path::PathBuf {
+    target_dir().join(if cfg!(release_profile) {
+        "release"
+    } else {
+        "debug"
+    })
+}
+
+pub(crate) fn cdylib_path() -> std::path::PathBuf {
+    let libm_path = cdylib_dir();
+    if cfg!(target_os = "macos") {
+        libm_path.join("liblibm.dylib")
+    } else if cfg!(target_os = "linux") {
+        libm_path.join("liblibm.so")
+    } else {
+        panic!("unsupported target_os")
+    }
+}