Move from lazy_static to a weak static in C lib

Sadly, a C library is necessary for this, as `#[linkage="weak"]` is still
unstable in Rust.

Sadly, much like with the lazy-static mutex implementation, it is a
wide-hitting hammer and will also hit platforms which aren’t affected by
this (by virtue of using thread-local dlerrors).

This will require a "major" version bump.

Fixes #32

Cargo.toml

@@ -9,8 +9,8 @@ license = "ISC"
 repository = "https://github.com/nagisa/rust_libloading/"
 documentation = "https://docs.rs/libloading/"
 
-[dependencies]
-lazy_static = "1"
+[build-dependencies.cc]
+version = "1.0"
 
 [target.'cfg(windows)'.dependencies.winapi]
 version = "0.3"

build.rs

@@ -1,8 +1,11 @@
+extern crate cc;
+
 use std::io::Write;
 use std::env;
 
 fn main(){
     let target_os = env::var("CARGO_CFG_TARGET_OS");
+    let is_unix = env::var_os("CARGO_CFG_UNIX").is_some();
     match target_os.as_ref().map(|x| &**x) {
         Ok("linux") | Ok("android") => println!("cargo:rustc-link-lib=dl"),
         Ok("freebsd") | Ok("dragonfly") => println!("cargo:rustc-link-lib=c"),
@@ -20,4 +23,9 @@ fn main(){
             ::std::process::exit(0xfc);
         }
     }
+    if is_unix {
+        cc::Build::new()
+            .file("src/os/unix/global_static.c")
+            .compile("global_static");
+    }
 }

src/lib.rs

@@ -41,10 +41,6 @@ use std::fmt;
 use std::ops;
 use std::marker;
 
-#[cfg(unix)]
-#[macro_use]
-extern crate lazy_static;
-
 #[cfg(unix)]
 use self::os::unix as imp;
 #[cfg(windows)]

src/os/unix/global_static.c

@@ -0,0 +1,20 @@
+#include <pthread.h>
+#include <stdlib.h>
+
+pthread_mutex_t __attribute__((weak)) rust_libloading_dlerror_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+void __attribute__((weak))
+rust_libloading_dlerror_mutex_lock(void)
+{
+    if (pthread_mutex_lock(&rust_libloading_dlerror_mutex) != 0) {
+        abort();
+    }
+}
+
+void __attribute__((weak))
+rust_libloading_dlerror_mutex_unlock(void)
+{
+    if (pthread_mutex_unlock(&rust_libloading_dlerror_mutex) != 0) {
+        abort();
+    }
+}

src/os/unix/mod.rs

@@ -4,10 +4,29 @@ use std::ffi::{CStr, OsStr};
 use std::{fmt, io, marker, mem, ptr};
 use std::os::raw;
 use std::os::unix::ffi::OsStrExt;
-use std::sync::Mutex;
 
-lazy_static! {
-    static ref DLERROR_MUTEX: Mutex<()> = Mutex::new(());
+extern "C" {
+    fn rust_libloading_dlerror_mutex_lock();
+    fn rust_libloading_dlerror_mutex_unlock();
+}
+
+struct DlerrorMutexGuard(());
+
+impl DlerrorMutexGuard {
+    fn new() -> DlerrorMutexGuard {
+        unsafe {
+            rust_libloading_dlerror_mutex_lock();
+        }
+        DlerrorMutexGuard(())
+    }
+}
+
+impl Drop for DlerrorMutexGuard {
+    fn drop(&mut self) {
+        unsafe {
+            rust_libloading_dlerror_mutex_unlock();
+        }
+    }
 }
 
 // libdl is crazy.
@@ -19,7 +38,7 @@ fn with_dlerror<T, F>(closure: F) -> Result<T, Option<io::Error>>
 where F: FnOnce() -> Option<T> {
     // We will guard all uses of libdl library with our own mutex. This makes libdl
     // safe to use in MT programs provided the only way a program uses libdl is via this library.
-    let _lock = DLERROR_MUTEX.lock();
+    let _lock = DlerrorMutexGuard::new();
     // While we could could call libdl here to clear the previous error value, only the dlsym
     // depends on it being cleared beforehand and only in some cases too. We will instead clear the
     // error inside the dlsym binding instead.