Adding upstream version 86.0.1.upstream/86.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

4 files changed, 714 insertions, 0 deletions

diff --git a/third_party/rust/libloading-0.5.2/src/os/mod.rs b/third_party/rust/libloading-0.5.2/src/os/mod.rs
new file mode 100644
index 0000000000..ccbc8e9778
--- /dev/null
+++ b/third_party/rust/libloading-0.5.2/src/os/mod.rs
@@ -0,0 +1,45 @@
+//! Unsafe, platform specific bindings to dynamic library loading facilities.
+//!
+//! These modules expose more extensive, powerful, less principled bindings to the dynamic
+//! library loading facilities. Use of these bindings come at the cost of less (in most cases,
+//! none at all) safety guarantees, which are provided by the top-level bindings.
+//!
+//! # Examples
+//!
+//! Using these modules will likely involve conditional compilation:
+//!
+//! ```ignore
+//! # extern crate libloading;
+//! #[cfg(unix)]
+//! use libloading::os::unix::*;
+//! #[cfg(windows)]
+//! use libloading::os::windows::*;
+//! ```
+
+macro_rules! unix {
+    ($item: item) => {
+        /// UNIX implementation of dynamic library loading.
+        ///
+        /// This module should be expanded with more UNIX-specific functionality in the future.
+        $item
+    }
+}
+
+macro_rules! windows {
+    ($item: item) => {
+        /// Windows implementation of dynamic library loading.
+        ///
+        /// This module should be expanded with more Windows-specific functionality in the future.
+        $item
+    }
+}
+
+#[cfg(unix)]
+unix!(pub mod unix;);
+#[cfg(unix)]
+windows!(pub mod windows {});
+
+#[cfg(windows)]
+windows!(pub mod windows;);
+#[cfg(windows)]
+unix!(pub mod unix {});
diff --git a/third_party/rust/libloading-0.5.2/src/os/unix/global_static.c b/third_party/rust/libloading-0.5.2/src/os/unix/global_static.c
new file mode 100644
index 0000000000..a905780865
--- /dev/null
+++ b/third_party/rust/libloading-0.5.2/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();
+    }
+}
diff --git a/third_party/rust/libloading-0.5.2/src/os/unix/mod.rs b/third_party/rust/libloading-0.5.2/src/os/unix/mod.rs
new file mode 100644
index 0000000000..d0456dd55a
--- /dev/null
+++ b/third_party/rust/libloading-0.5.2/src/os/unix/mod.rs
@@ -0,0 +1,336 @@
+use util::{ensure_compatible_types, cstr_cow_from_bytes};
+
+use std::ffi::{CStr, OsStr};
+use std::{fmt, io, marker, mem, ptr};
+use std::os::raw;
+use std::os::unix::ffi::OsStrExt;
+
+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.
+//
+// First of all, whole error handling scheme in libdl is done via setting and querying some global
+// state, therefore it is not safe to use libdl in MT-capable environment at all. Only in POSIX
+// 2008+TC1 a thread-local state was allowed, which for our purposes is way too late.
+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 = 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.
+    //
+    // In all the other cases, clearing the error here will only be hiding misuse of these bindings
+    // or the libdl.
+    closure().ok_or_else(|| unsafe {
+        // This code will only get executed if the `closure` returns `None`.
+        let error = dlerror();
+        if error.is_null() {
+            // In non-dlsym case this may happen when there’re bugs in our bindings or there’s
+            // non-libloading user of libdl; possibly in another thread.
+            None
+        } else {
+            // You can’t even rely on error string being static here; call to subsequent dlerror
+            // may invalidate or overwrite the error message. Why couldn’t they simply give up the
+            // ownership over the message?
+            // TODO: should do locale-aware conversion here. OTOH Rust doesn’t seem to work well in
+            // any system that uses non-utf8 locale, so I doubt there’s a problem here.
+            let message = CStr::from_ptr(error).to_string_lossy().into_owned();
+            Some(io::Error::new(io::ErrorKind::Other, message))
+            // Since we do a copy of the error string above, maybe we should call dlerror again to
+            // let libdl know it may free its copy of the string now?
+        }
+    })
+}
+
+/// A platform-specific equivalent of the cross-platform `Library`.
+pub struct Library {
+    handle: *mut raw::c_void
+}
+
+unsafe impl Send for Library {}
+
+// That being said... this section in the volume 2 of POSIX.1-2008 states:
+//
+// > All functions defined by this volume of POSIX.1-2008 shall be thread-safe, except that the
+// > following functions need not be thread-safe.
+//
+// With notable absence of any dl* function other than dlerror in the list. By “this volume”
+// I suppose they refer precisely to the “volume 2”. dl* family of functions are specified
+// by this same volume, so the conclusion is indeed that dl* functions are required by POSIX
+// to be thread-safe. Great!
+//
+// See for more details:
+//
+//  * https://github.com/nagisa/rust_libloading/pull/17
+//  * http://pubs.opengroup.org/onlinepubs/9699919799/functions/V2_chap02.html#tag_15_09_01
+unsafe impl Sync for Library {}
+
+impl Library {
+    /// Find and load a shared library (module).
+    ///
+    /// Locations where library is searched for is platform specific and can’t be adjusted
+    /// portably.
+    ///
+    /// Corresponds to `dlopen(filename, RTLD_NOW)`.
+    #[inline]
+    pub fn new<P: AsRef<OsStr>>(filename: P) -> ::Result<Library> {
+        Library::open(Some(filename), RTLD_NOW)
+    }
+
+    /// Load the dynamic libraries linked into main program.
+    ///
+    /// This allows retrieving symbols from any **dynamic** library linked into the program,
+    /// without specifying the exact library.
+    ///
+    /// Corresponds to `dlopen(NULL, RTLD_NOW)`.
+    #[inline]
+    pub fn this() -> Library {
+        Library::open(None::<&OsStr>, RTLD_NOW).unwrap()
+    }
+
+    /// Find and load a shared library (module).
+    ///
+    /// Locations where library is searched for is platform specific and can’t be adjusted
+    /// portably.
+    ///
+    /// If the `filename` is None, null pointer is passed to `dlopen`.
+    ///
+    /// Corresponds to `dlopen(filename, flags)`.
+    pub fn open<P>(filename: Option<P>, flags: raw::c_int) -> ::Result<Library>
+    where P: AsRef<OsStr> {
+        let filename = match filename {
+            None => None,
+            Some(ref f) => Some(try!(cstr_cow_from_bytes(f.as_ref().as_bytes()))),
+        };
+        with_dlerror(move || {
+            let result = unsafe {
+                let r = dlopen(match filename {
+                    None => ptr::null(),
+                    Some(ref f) => f.as_ptr()
+                }, flags);
+                // ensure filename lives until dlopen completes
+                drop(filename);
+                r
+            };
+            if result.is_null() {
+                None
+            } else {
+                Some(Library {
+                    handle: result
+                })
+            }
+        }).map_err(|e| e.unwrap_or_else(||
+            panic!("dlopen failed but dlerror did not report anything")
+        ))
+    }
+
+    /// Get a pointer to function or static variable by symbol name.
+    ///
+    /// The `symbol` may not contain any null bytes, with an exception of last byte. A null
+    /// terminated `symbol` may avoid a string allocation in some cases.
+    ///
+    /// Symbol is interpreted as-is; no mangling is done. This means that symbols like `x::y` are
+    /// most likely invalid.
+    ///
+    /// ## Unsafety
+    ///
+    /// Pointer to a value of arbitrary type is returned. Using a value with wrong type is
+    /// undefined.
+    ///
+    /// ## Platform-specific behaviour
+    ///
+    /// OS X uses some sort of lazy initialization scheme, which makes loading TLS variables
+    /// impossible. Using a TLS variable loaded this way on OS X is undefined behaviour.
+    pub unsafe fn get<T>(&self, symbol: &[u8]) -> ::Result<Symbol<T>> {
+        ensure_compatible_types::<T, *mut raw::c_void>();
+        let symbol = try!(cstr_cow_from_bytes(symbol));
+        // `dlsym` may return nullptr in two cases: when a symbol genuinely points to a null
+        // pointer or the symbol cannot be found. In order to detect this case a double dlerror
+        // pattern must be used, which is, sadly, a little bit racy.
+        //
+        // We try to leave as little space as possible for this to occur, but we can’t exactly
+        // fully prevent it.
+        match with_dlerror(|| {
+            dlerror();
+            let symbol = dlsym(self.handle, symbol.as_ptr());
+            if symbol.is_null() {
+                None
+            } else {
+                Some(Symbol {
+                    pointer: symbol,
+                    pd: marker::PhantomData
+                })
+            }
+        }) {
+            Err(None) => Ok(Symbol {
+                pointer: ptr::null_mut(),
+                pd: marker::PhantomData
+            }),
+            Err(Some(e)) => Err(e),
+            Ok(x) => Ok(x)
+        }
+    }
+
+    /// Convert the `Library` to a raw handle.
+    ///
+    /// The handle returned by this function shall be usable with APIs which accept handles
+    /// as returned by `dlopen`.
+    pub fn into_raw(self) -> *mut raw::c_void {
+        let handle = self.handle;
+        mem::forget(self);
+        handle
+    }
+
+    /// Convert a raw handle returned by `dlopen`-family of calls to a `Library`.
+    ///
+    /// ## Unsafety
+    ///
+    /// The pointer shall be a result of a successful call of the `dlopen`-family of functions or a
+    /// pointer previously returned by `Library::into_raw` call. It must be valid to call `dlclose`
+    /// with this pointer as an argument.
+    pub unsafe fn from_raw(handle: *mut raw::c_void) -> Library {
+        Library {
+            handle: handle
+        }
+    }
+}
+
+impl Drop for Library {
+    fn drop(&mut self) {
+        with_dlerror(|| if unsafe { dlclose(self.handle) } == 0 {
+            Some(())
+        } else {
+            None
+        }).unwrap();
+    }
+}
+
+impl fmt::Debug for Library {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str(&format!("Library@{:p}", self.handle))
+    }
+}
+
+/// Symbol from a library.
+///
+/// A major difference compared to the cross-platform `Symbol` is that this does not ensure the
+/// `Symbol` does not outlive `Library` it comes from.
+pub struct Symbol<T> {
+    pointer: *mut raw::c_void,
+    pd: marker::PhantomData<T>
+}
+
+impl<T> Symbol<T> {
+    /// Convert the loaded Symbol into a raw pointer.
+    pub fn into_raw(self) -> *mut raw::c_void {
+        let pointer = self.pointer;
+        mem::forget(self);
+        pointer
+    }
+}
+
+impl<T> Symbol<Option<T>> {
+    /// Lift Option out of the symbol.
+    pub fn lift_option(self) -> Option<Symbol<T>> {
+        if self.pointer.is_null() {
+            None
+        } else {
+            Some(Symbol {
+                pointer: self.pointer,
+                pd: marker::PhantomData,
+            })
+        }
+    }
+}
+
+unsafe impl<T: Send> Send for Symbol<T> {}
+unsafe impl<T: Sync> Sync for Symbol<T> {}
+
+impl<T> Clone for Symbol<T> {
+    fn clone(&self) -> Symbol<T> {
+        Symbol { ..*self }
+    }
+}
+
+impl<T> ::std::ops::Deref for Symbol<T> {
+    type Target = T;
+    fn deref(&self) -> &T {
+        unsafe {
+            // Additional reference level for a dereference on `deref` return value.
+            mem::transmute(&self.pointer)
+        }
+    }
+}
+
+impl<T> fmt::Debug for Symbol<T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        unsafe {
+            let mut info: DlInfo = mem::uninitialized();
+            if dladdr(self.pointer, &mut info) != 0 {
+                if info.dli_sname.is_null() {
+                    f.write_str(&format!("Symbol@{:p} from {:?}",
+                                         self.pointer,
+                                         CStr::from_ptr(info.dli_fname)))
+                } else {
+                    f.write_str(&format!("Symbol {:?}@{:p} from {:?}",
+                                         CStr::from_ptr(info.dli_sname), self.pointer,
+                                         CStr::from_ptr(info.dli_fname)))
+                }
+            } else {
+                f.write_str(&format!("Symbol@{:p}", self.pointer))
+            }
+        }
+    }
+}
+
+// Platform specific things
+
+extern {
+    fn dlopen(filename: *const raw::c_char, flags: raw::c_int) -> *mut raw::c_void;
+    fn dlclose(handle: *mut raw::c_void) -> raw::c_int;
+    fn dlsym(handle: *mut raw::c_void, symbol: *const raw::c_char) -> *mut raw::c_void;
+    fn dlerror() -> *mut raw::c_char;
+    fn dladdr(addr: *mut raw::c_void, info: *mut DlInfo) -> raw::c_int;
+}
+
+#[cfg(not(target_os="android"))]
+const RTLD_NOW: raw::c_int = 2;
+#[cfg(target_os="android")]
+const RTLD_NOW: raw::c_int = 0;
+
+#[repr(C)]
+struct DlInfo {
+  dli_fname: *const raw::c_char,
+  dli_fbase: *mut raw::c_void,
+  dli_sname: *const raw::c_char,
+  dli_saddr: *mut raw::c_void
+}
+
+#[test]
+fn this() {
+    Library::this();
+}
diff --git a/third_party/rust/libloading-0.5.2/src/os/windows/mod.rs b/third_party/rust/libloading-0.5.2/src/os/windows/mod.rs
new file mode 100644
index 0000000000..8157eaba1d
--- /dev/null
+++ b/third_party/rust/libloading-0.5.2/src/os/windows/mod.rs
@@ -0,0 +1,313 @@
+extern crate winapi;
+use self::winapi::shared::minwindef::{WORD, DWORD, HMODULE, FARPROC};
+use self::winapi::shared::ntdef::WCHAR;
+use self::winapi::shared::winerror;
+use self::winapi::um::{errhandlingapi, libloaderapi};
+
+use util::{ensure_compatible_types, cstr_cow_from_bytes};
+
+use std::ffi::{OsStr, OsString};
+use std::{fmt, io, marker, mem, ptr};
+use std::os::windows::ffi::{OsStrExt, OsStringExt};
+use std::sync::atomic::{AtomicBool, ATOMIC_BOOL_INIT, Ordering};
+
+
+/// A platform-specific equivalent of the cross-platform `Library`.
+pub struct Library(HMODULE);
+
+unsafe impl Send for Library {}
+// Now, this is sort-of-tricky. MSDN documentation does not really make any claims as to safety of
+// the Win32 APIs. Sadly, whomever I asked, even current and former Microsoft employees, couldn’t
+// say for sure, whether the Win32 APIs used to implement `Library` are thread-safe or not.
+//
+// My investigation ended up with a question about thread-safety properties of the API involved
+// being sent to an internal (to MS) general question mailing-list. The conclusion of the mail is
+// as such:
+//
+// * Nobody inside MS (at least out of all the people who have seen the question) knows for
+//   sure either;
+// * However, the general consensus between MS developers is that one can rely on the API being
+//   thread-safe. In case it is not thread-safe it should be considered a bug on the Windows
+//   part. (NB: bugs filled at https://connect.microsoft.com/ against Windows Server)
+unsafe impl Sync for Library {}
+
+impl Library {
+    /// Find and load a shared library (module).
+    ///
+    /// Corresponds to `LoadLibraryW(filename)`.
+    #[inline]
+    pub fn new<P: AsRef<OsStr>>(filename: P) -> ::Result<Library> {
+        let wide_filename: Vec<u16> = filename.as_ref().encode_wide().chain(Some(0)).collect();
+        let _guard = ErrorModeGuard::new();
+
+        let ret = with_get_last_error(|| {
+            // Make sure no winapi calls as a result of drop happen inside this closure, because
+            // otherwise that might change the return value of the GetLastError.
+            let handle = unsafe { libloaderapi::LoadLibraryW(wide_filename.as_ptr()) };
+            if handle.is_null()  {
+                None
+            } else {
+                Some(Library(handle))
+            }
+        }).map_err(|e| e.unwrap_or_else(||
+            panic!("LoadLibraryW failed but GetLastError did not report the error")
+        ));
+
+        drop(wide_filename); // Drop wide_filename here to ensure it doesn’t get moved and dropped
+                             // inside the closure by mistake. See comment inside the closure.
+        ret
+    }
+
+    /// Get a pointer to function or static variable by symbol name.
+    ///
+    /// The `symbol` may not contain any null bytes, with an exception of last byte. A null
+    /// terminated `symbol` may avoid a string allocation in some cases.
+    ///
+    /// Symbol is interpreted as-is; no mangling is done. This means that symbols like `x::y` are
+    /// most likely invalid.
+    ///
+    /// ## Unsafety
+    ///
+    /// Pointer to a value of arbitrary type is returned. Using a value with wrong type is
+    /// undefined.
+    pub unsafe fn get<T>(&self, symbol: &[u8]) -> ::Result<Symbol<T>> {
+        ensure_compatible_types::<T, FARPROC>();
+        let symbol = try!(cstr_cow_from_bytes(symbol));
+        with_get_last_error(|| {
+            let symbol = libloaderapi::GetProcAddress(self.0, symbol.as_ptr());
+            if symbol.is_null() {
+                None
+            } else {
+                Some(Symbol {
+                    pointer: symbol,
+                    pd: marker::PhantomData
+                })
+            }
+        }).map_err(|e| e.unwrap_or_else(||
+            panic!("GetProcAddress failed but GetLastError did not report the error")
+        ))
+    }
+
+    /// Get a pointer to function or static variable by ordinal number.
+    ///
+    /// ## Unsafety
+    ///
+    /// Pointer to a value of arbitrary type is returned. Using a value with wrong type is
+    /// undefined.
+    pub unsafe fn get_ordinal<T>(&self, ordinal: WORD) -> ::Result<Symbol<T>> {
+        ensure_compatible_types::<T, FARPROC>();
+        with_get_last_error(|| {
+            let ordinal = ordinal as usize as *mut _;
+            let symbol = libloaderapi::GetProcAddress(self.0, ordinal);
+            if symbol.is_null() {
+                None
+            } else {
+                Some(Symbol {
+                    pointer: symbol,
+                    pd: marker::PhantomData
+                })
+            }
+        }).map_err(|e| e.unwrap_or_else(||
+            panic!("GetProcAddress failed but GetLastError did not report the error")
+        ))
+    }
+
+    /// Convert the `Library` to a raw handle.
+    pub fn into_raw(self) -> HMODULE {
+        let handle = self.0;
+        mem::forget(self);
+        handle
+    }
+
+    /// Convert a raw handle to a `Library`.
+    ///
+    /// ## Unsafety
+    ///
+    /// The handle shall be a result of a successful call of `LoadLibraryW` or a
+    /// handle previously returned by the `Library::into_raw` call.
+    pub unsafe fn from_raw(handle: HMODULE) -> Library {
+        Library(handle)
+    }
+}
+
+impl Drop for Library {
+    fn drop(&mut self) {
+        with_get_last_error(|| {
+            if unsafe { libloaderapi::FreeLibrary(self.0) == 0 } {
+                None
+            } else {
+                Some(())
+            }
+        }).unwrap()
+    }
+}
+
+impl fmt::Debug for Library {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        unsafe {
+            let mut buf: [WCHAR; 1024] = mem::uninitialized();
+            let len = libloaderapi::GetModuleFileNameW(self.0,
+                                                   (&mut buf[..]).as_mut_ptr(), 1024) as usize;
+            if len == 0 {
+                f.write_str(&format!("Library@{:p}", self.0))
+            } else {
+                let string: OsString = OsString::from_wide(&buf[..len]);
+                f.write_str(&format!("Library@{:p} from {:?}", self.0, string))
+            }
+        }
+    }
+}
+
+/// Symbol from a library.
+///
+/// A major difference compared to the cross-platform `Symbol` is that this does not ensure the
+/// `Symbol` does not outlive `Library` it comes from.
+pub struct Symbol<T> {
+    pointer: FARPROC,
+    pd: marker::PhantomData<T>
+}
+
+impl<T> Symbol<T> {
+    /// Convert the loaded Symbol into a handle.
+    pub fn into_raw(self) -> FARPROC {
+        let pointer = self.pointer;
+        mem::forget(self);
+        pointer
+    }
+}
+
+impl<T> Symbol<Option<T>> {
+    /// Lift Option out of the symbol.
+    pub fn lift_option(self) -> Option<Symbol<T>> {
+        if self.pointer.is_null() {
+            None
+        } else {
+            Some(Symbol {
+                pointer: self.pointer,
+                pd: marker::PhantomData,
+            })
+        }
+    }
+}
+
+unsafe impl<T: Send> Send for Symbol<T> {}
+unsafe impl<T: Sync> Sync for Symbol<T> {}
+
+impl<T> Clone for Symbol<T> {
+    fn clone(&self) -> Symbol<T> {
+        Symbol { ..*self }
+    }
+}
+
+impl<T> ::std::ops::Deref for Symbol<T> {
+    type Target = T;
+    fn deref(&self) -> &T {
+        unsafe {
+            // Additional reference level for a dereference on `deref` return value.
+            mem::transmute(&self.pointer)
+        }
+    }
+}
+
+impl<T> fmt::Debug for Symbol<T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str(&format!("Symbol@{:p}", self.pointer))
+    }
+}
+
+
+static USE_ERRORMODE: AtomicBool = ATOMIC_BOOL_INIT;
+struct ErrorModeGuard(DWORD);
+
+impl ErrorModeGuard {
+    fn new() -> Option<ErrorModeGuard> {
+        const SEM_FAILCE: DWORD = 1;
+        unsafe {
+            if !USE_ERRORMODE.load(Ordering::Acquire) {
+                let mut previous_mode = 0;
+                let success = errhandlingapi::SetThreadErrorMode(SEM_FAILCE, &mut previous_mode) != 0;
+                if !success && errhandlingapi::GetLastError() == winerror::ERROR_CALL_NOT_IMPLEMENTED {
+                    USE_ERRORMODE.store(true, Ordering::Release);
+                } else if !success {
+                    // SetThreadErrorMode failed with some other error? How in the world is it
+                    // possible for what is essentially a simple variable swap to fail?
+                    // For now we just ignore the error -- the worst that can happen here is
+                    // the previous mode staying on and user seeing a dialog error on older Windows
+                    // machines.
+                    return None;
+                } else if previous_mode == SEM_FAILCE {
+                    return None;
+                } else {
+                    return Some(ErrorModeGuard(previous_mode));
+                }
+            }
+            match errhandlingapi::SetErrorMode(SEM_FAILCE) {
+                SEM_FAILCE => {
+                    // This is important to reduce racy-ness when this library is used on multiple
+                    // threads. In particular this helps with following race condition:
+                    //
+                    // T1: SetErrorMode(SEM_FAILCE)
+                    // T2: SetErrorMode(SEM_FAILCE)
+                    // T1: SetErrorMode(old_mode) # not SEM_FAILCE
+                    // T2: SetErrorMode(SEM_FAILCE) # restores to SEM_FAILCE on drop
+                    //
+                    // This is still somewhat racy in a sense that T1 might restore the error
+                    // mode before T2 finishes loading the library, but that is less of a
+                    // concern – it will only end up in end user seeing a dialog.
+                    //
+                    // Also, SetErrorMode itself is probably not an atomic operation.
+                    None
+                }
+                a => Some(ErrorModeGuard(a))
+            }
+        }
+    }
+}
+
+impl Drop for ErrorModeGuard {
+    fn drop(&mut self) {
+        unsafe {
+            if !USE_ERRORMODE.load(Ordering::Relaxed) {
+                errhandlingapi::SetThreadErrorMode(self.0, ptr::null_mut());
+            } else {
+                errhandlingapi::SetErrorMode(self.0);
+            }
+        }
+    }
+}
+
+fn with_get_last_error<T, F>(closure: F) -> Result<T, Option<io::Error>>
+where F: FnOnce() -> Option<T> {
+    closure().ok_or_else(|| {
+        let error = unsafe { errhandlingapi::GetLastError() };
+        if error == 0 {
+            None
+        } else {
+            Some(io::Error::from_raw_os_error(error as i32))
+        }
+    })
+}
+
+#[test]
+fn works_getlasterror() {
+    let lib = Library::new("kernel32.dll").unwrap();
+    let gle: Symbol<unsafe extern "system" fn() -> DWORD> = unsafe {
+        lib.get(b"GetLastError").unwrap()
+    };
+    unsafe {
+        errhandlingapi::SetLastError(42);
+        assert_eq!(errhandlingapi::GetLastError(), gle())
+    }
+}
+
+#[test]
+fn works_getlasterror0() {
+    let lib = Library::new("kernel32.dll").unwrap();
+    let gle: Symbol<unsafe extern "system" fn() -> DWORD> = unsafe {
+        lib.get(b"GetLastError\0").unwrap()
+    };
+    unsafe {
+        errhandlingapi::SetLastError(42);
+        assert_eq!(errhandlingapi::GetLastError(), gle())
+    }
+}