summaryrefslogtreecommitdiffstats
path: root/third_party/rust/libloading-0.5.2/src
diff options
context:
space:
mode:
Diffstat (limited to 'third_party/rust/libloading-0.5.2/src')
-rw-r--r--third_party/rust/libloading-0.5.2/src/changelog.rs103
-rw-r--r--third_party/rust/libloading-0.5.2/src/lib.rs310
-rw-r--r--third_party/rust/libloading-0.5.2/src/os/mod.rs45
-rw-r--r--third_party/rust/libloading-0.5.2/src/os/unix/global_static.c20
-rw-r--r--third_party/rust/libloading-0.5.2/src/os/unix/mod.rs336
-rw-r--r--third_party/rust/libloading-0.5.2/src/os/windows/mod.rs313
-rw-r--r--third_party/rust/libloading-0.5.2/src/test_helpers.rs49
-rw-r--r--third_party/rust/libloading-0.5.2/src/util.rs61
8 files changed, 1237 insertions, 0 deletions
diff --git a/third_party/rust/libloading-0.5.2/src/changelog.rs b/third_party/rust/libloading-0.5.2/src/changelog.rs
new file mode 100644
index 0000000000..215ea89f74
--- /dev/null
+++ b/third_party/rust/libloading-0.5.2/src/changelog.rs
@@ -0,0 +1,103 @@
+//! Project changelog
+
+/// Release 0.5.2 (2019-07-07)
+///
+/// * Added API to convert OS-specific `Library` and `Symbol` conversion to underlying resources.
+pub mod r0_5_2 {}
+
+/// Release 0.5.1 (2019-06-01)
+///
+/// * Build on Haiku targets.
+pub mod r0_5_1 {}
+
+/// Release 0.5.0 (2018-01-11)
+///
+/// * Update to `winapi = ^0.3`;
+///
+/// ## Breaking changes
+///
+/// * libloading now requires a C compiler to build on UNIX;
+/// * This is a temporary measure until the [`linkage`] attribute is stabilised;
+/// * Necessary to resolve [#32].
+///
+/// [`linkage`]: https://github.com/rust-lang/rust/issues/29603
+/// [#32]: https://github.com/nagisa/rust_libloading/issues/32
+pub mod r0_5_0 {}
+
+/// Release 0.4.3 (2017-12-07)
+///
+/// * Bump lazy-static dependency to `^1.0`;
+/// * `cargo test --release` now works when testing libloading.
+pub mod r0_4_3 {}
+
+
+/// Release 0.4.2 (2017-09-24)
+///
+/// * Improved error and race-condition handling on Windows;
+/// * Improved documentation about thread-safety of Library;
+/// * Added `Symbol::<Option<T>::lift_option() -> Option<Symbol<T>>` convenience method.
+pub mod r0_4_2 {}
+
+
+/// Release 0.4.1 (2017-08-29)
+///
+/// * Solaris support
+pub mod r0_4_1 {}
+
+/// Release 0.4.0 (2017-05-01)
+///
+/// * Remove build-time dependency on target_build_utils (and by extension serde/phf);
+/// * Require at least version 1.14.0 of rustc to build;
+/// * Actually, it is cargo which has to be more recent here. The one shipped with rustc 1.14.0
+/// is what’s being required from now on.
+pub mod r0_4_0 {}
+
+/// Release 0.3.4 (2017-03-25)
+///
+/// * Remove rogue println!
+pub mod r0_3_4 {}
+
+/// Release 0.3.3 (2017-03-25)
+///
+/// * Panics when `Library::get` is called for incompatibly sized type such as named function
+/// types (which are zero-sized).
+pub mod r0_3_3 {}
+
+/// Release 0.3.2 (2017-02-10)
+///
+/// * Minimum version required is now rustc 1.12.0;
+/// * Updated dependency versions (most notably target_build_utils to 0.3.0)
+pub mod r0_3_2 {}
+
+/// Release 0.3.1 (2016-10-01)
+///
+/// * `Symbol<T>` and `os::*::Symbol<T>` now implement `Send` where `T: Send`;
+/// * `Symbol<T>` and `os::*::Symbol<T>` now implement `Sync` where `T: Sync`;
+/// * `Library` and `os::*::Library` now implement `Sync` (they were `Send` in 0.3.0 already).
+pub mod r0_3_1 {}
+
+/// Release 0.3.0 (2016-07-27)
+///
+/// * Greatly improved documentation, especially around platform-specific behaviours;
+/// * Improved test suite by building our own library to test against;
+/// * All `Library`-ies now implement `Send`.
+/// * Added `impl From<os::platform::Library> for Library` and `impl From<Library> for
+/// os::platform::Library` allowing wrapping and extracting the platform-specific library handle;
+/// * Added methods to wrap (`Symbol::from_raw`) and unwrap (`Symbol::into_raw`) the safe `Symbol`
+/// wrapper into unsafe `os::platform::Symbol`.
+///
+/// The last two additions focus on not restricting potential usecases of this library, allowing
+/// users of the library to circumvent safety checks if need be.
+///
+/// ## Breaking Changes
+///
+/// `Library::new` defaults to `RTLD_NOW` instead of `RTLD_LAZY` on UNIX for more consistent
+/// cross-platform behaviour. If a library loaded with `Library::new` had any linking errors, but
+/// unresolved references weren’t forced to be resolved, the library would’ve “just worked”,
+/// whereas now the call to `Library::new` will return an error signifying presence of such error.
+///
+/// ## os::platform
+/// * Added `os::unix::Library::open` which allows specifying arbitrary flags (e.g. `RTLD_LAZY`);
+/// * Added `os::windows::Library::get_ordinal` which allows finding a function or variable by its
+/// ordinal number;
+pub mod r0_3_0 {}
diff --git a/third_party/rust/libloading-0.5.2/src/lib.rs b/third_party/rust/libloading-0.5.2/src/lib.rs
new file mode 100644
index 0000000000..a3bfe10286
--- /dev/null
+++ b/third_party/rust/libloading-0.5.2/src/lib.rs
@@ -0,0 +1,310 @@
+//! A memory-safer wrapper around system dynamic library loading primitives.
+//!
+//! Using this library allows loading [dynamic libraries](struct.Library.html) (also known as
+//! shared libraries) as well as use functions and static variables these libraries contain.
+//!
+//! While the library does expose a cross-platform interface to load a library and find stuff
+//! inside it, little is done to paper over the platform differences, especially where library
+//! loading is involved. The documentation for each function will attempt to document such
+//! differences on the best-effort basis.
+//!
+//! Less safe, platform specific bindings are also available. See the
+//! [`os::platform`](os/index.html) module for details.
+//!
+//! # Usage
+//!
+//! Add a dependency on this library to your `Cargo.toml`:
+//!
+//! ```toml
+//! [dependencies]
+//! libloading = "0.5"
+//! ```
+//!
+//! Then inside your project
+//!
+//! ```no_run
+//! extern crate libloading as lib;
+//!
+//! fn call_dynamic() -> lib::Result<u32> {
+//! let lib = lib::Library::new("/path/to/liblibrary.so")?;
+//! unsafe {
+//! let func: lib::Symbol<unsafe extern fn() -> u32> = lib.get(b"my_func")?;
+//! Ok(func())
+//! }
+//! }
+//! ```
+//!
+//! The compiler will ensure that the loaded `function` will not outlive the `Library` it comes
+//! from, preventing a common cause of undefined behaviour and memory safety problems.
+use std::ffi::OsStr;
+use std::fmt;
+use std::ops;
+use std::marker;
+
+#[cfg(unix)]
+use self::os::unix as imp;
+#[cfg(windows)]
+use self::os::windows as imp;
+
+pub mod os;
+pub mod changelog;
+mod util;
+
+pub type Result<T> = ::std::io::Result<T>;
+
+/// A loaded dynamic library.
+pub struct Library(imp::Library);
+
+impl Library {
+ /// Find and load a dynamic library.
+ ///
+ /// The `filename` argument may be any of:
+ ///
+ /// * A library filename;
+ /// * Absolute path to the library;
+ /// * Relative (to the current working directory) path to the library.
+ ///
+ /// ## Thread-safety
+ ///
+ /// The implementation strives to be as MT-safe as sanely possible, however due to certain
+ /// error-handling related resources not always being safe, this library is not MT-safe either.
+ ///
+ /// * On Windows Vista and earlier error handling falls back to [`SetErrorMode`], which is not
+ /// MT-safe. MT-scenarios involving this function may cause a traditional data race;
+ /// * On some UNIX targets `dlerror` might not be MT-safe, resulting in garbage error messages
+ /// in certain MT-scenarios.
+ ///
+ /// [`SetErrorMode`]: https://msdn.microsoft.com/en-us/library/windows/desktop/ms680621(v=vs.85).aspx
+ ///
+ /// Calling this function from multiple threads is not safe if used in conjunction with
+ /// path-less filename and library search path is modified (`SetDllDirectory` function on
+ /// Windows, `{DY,}LD_LIBRARY_PATH` environment variable on UNIX).
+ ///
+ /// ## Platform-specific behaviour
+ ///
+ /// When a plain library filename is supplied, locations where library is searched for is
+ /// platform specific and cannot be adjusted in a portable manner.
+ ///
+ /// ### Windows
+ ///
+ /// If the `filename` specifies a library filename without path and with extension omitted,
+ /// `.dll` extension is implicitly added. This behaviour may be suppressed by appending a
+ /// trailing `.` to the `filename`.
+ ///
+ /// If the library contains thread local variables (MSVC’s `_declspec(thread)`, Rust’s
+ /// `#[thread_local]` attributes), loading the library will fail on versions prior to Windows
+ /// Vista.
+ ///
+ /// ## Tips
+ ///
+ /// Distributing your dynamic libraries under a filename common to all platforms (e.g.
+ /// `awesome.module`) allows to avoid code which has to account for platform’s conventional
+ /// library filenames.
+ ///
+ /// Strive to specify absolute or relative path to your library, unless system-wide libraries
+ /// are being loaded. Platform-dependent library search locations combined with various quirks
+ /// related to path-less filenames may cause flaky code.
+ ///
+ /// ## Examples
+ ///
+ /// ```no_run
+ /// # use ::libloading::Library;
+ /// // Any of the following are valid.
+ /// let _ = Library::new("/path/to/awesome.module").unwrap();
+ /// let _ = Library::new("../awesome.module").unwrap();
+ /// let _ = Library::new("libsomelib.so.1").unwrap();
+ /// ```
+ pub fn new<P: AsRef<OsStr>>(filename: P) -> Result<Library> {
+ imp::Library::new(filename).map(From::from)
+ }
+
+ /// 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
+ ///
+ /// On Linux and Windows, a TLS variable acts just like any regular static variable. OS X uses
+ /// some sort of lazy initialization scheme, which makes loading TLS variables this way
+ /// impossible. Using a TLS variable loaded this way on OS X is undefined behaviour.
+ ///
+ /// ## Examples
+ ///
+ /// Given a loaded library:
+ ///
+ /// ```no_run
+ /// # use ::libloading::Library;
+ /// let lib = Library::new("/path/to/awesome.module").unwrap();
+ /// ```
+ ///
+ /// Loading and using a function looks like this:
+ ///
+ /// ```no_run
+ /// # use ::libloading::{Library, Symbol};
+ /// # let lib = Library::new("/path/to/awesome.module").unwrap();
+ /// unsafe {
+ /// let awesome_function: Symbol<unsafe extern fn(f64) -> f64> =
+ /// lib.get(b"awesome_function\0").unwrap();
+ /// awesome_function(0.42);
+ /// }
+ /// ```
+ ///
+ /// A static variable may also be loaded and inspected:
+ ///
+ /// ```no_run
+ /// # use ::libloading::{Library, Symbol};
+ /// # let lib = Library::new("/path/to/awesome.module").unwrap();
+ /// unsafe {
+ /// let awesome_variable: Symbol<*mut f64> = lib.get(b"awesome_variable\0").unwrap();
+ /// **awesome_variable = 42.0;
+ /// };
+ /// ```
+ pub unsafe fn get<'lib, T>(&'lib self, symbol: &[u8]) -> Result<Symbol<'lib, T>> {
+ self.0.get(symbol).map(|from| Symbol::from_raw(from, self))
+ }
+}
+
+impl fmt::Debug for Library {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ self.0.fmt(f)
+ }
+}
+
+impl From<imp::Library> for Library {
+ fn from(lib: imp::Library) -> Library {
+ Library(lib)
+ }
+}
+
+impl From<Library> for imp::Library {
+ fn from(lib: Library) -> imp::Library {
+ lib.0
+ }
+}
+
+unsafe impl Send for Library {}
+unsafe impl Sync for Library {}
+
+/// Symbol from a library.
+///
+/// This type is a safeguard against using dynamically loaded symbols after a `Library` is
+/// unloaded. Primary method to create an instance of a `Symbol` is via `Library::get`.
+///
+/// Due to implementation of the `Deref` trait, an instance of `Symbol` may be used as if it was a
+/// function or variable directly, without taking care to “extract” function or variable manually
+/// most of the time.
+///
+/// See [`Library::get`] for details.
+///
+/// [`Library::get`]: ./struct.Library.html#method.get
+pub struct Symbol<'lib, T: 'lib> {
+ inner: imp::Symbol<T>,
+ pd: marker::PhantomData<&'lib T>
+}
+
+impl<'lib, T> Symbol<'lib, T> {
+ /// Extract the wrapped `os::platform::Symbol`.
+ ///
+ /// ## Unsafety
+ /// Using this function relinquishes all the lifetime guarantees. It is up to programmer to
+ /// ensure the resulting `Symbol` is not used past the lifetime of the `Library` this symbol
+ /// was loaded from.
+ ///
+ /// ## Examples
+ ///
+ /// ```no_run
+ /// # use ::libloading::{Library, Symbol};
+ /// let lib = Library::new("/path/to/awesome.module").unwrap();
+ /// unsafe {
+ /// let symbol: Symbol<*mut u32> = lib.get(b"symbol\0").unwrap();
+ /// let symbol = symbol.into_raw();
+ /// }
+ /// ```
+ pub unsafe fn into_raw(self) -> imp::Symbol<T> {
+ self.inner
+ }
+
+ /// Wrap the `os::platform::Symbol` into this safe wrapper.
+ ///
+ /// Note that, in order to create association between the symbol and the library this symbol
+ /// came from, this function requires reference to the library provided.
+ ///
+ /// ## Unsafety
+ ///
+ /// It is invalid to provide a reference to any other value other than the library the `sym`
+ /// was loaded from. Doing so invalidates any lifetime guarantees.
+ ///
+ /// ## Examples
+ ///
+ /// ```no_run
+ /// # use ::libloading::{Library, Symbol};
+ /// let lib = Library::new("/path/to/awesome.module").unwrap();
+ /// unsafe {
+ /// let symbol: Symbol<*mut u32> = lib.get(b"symbol\0").unwrap();
+ /// let symbol = symbol.into_raw();
+ /// let symbol = Symbol::from_raw(symbol, &lib);
+ /// }
+ /// ```
+ pub unsafe fn from_raw<L>(sym: imp::Symbol<T>, _: &'lib L) -> Symbol<'lib, T> {
+ Symbol {
+ inner: sym,
+ pd: marker::PhantomData
+ }
+ }
+}
+
+impl<'lib, T> Symbol<'lib, Option<T>> {
+ /// Lift Option out of the symbol.
+ ///
+ /// ## Examples
+ ///
+ /// ```no_run
+ /// # use ::libloading::{Library, Symbol};
+ /// let lib = Library::new("/path/to/awesome.module").unwrap();
+ /// unsafe {
+ /// let symbol: Symbol<Option<*mut u32>> = lib.get(b"symbol\0").unwrap();
+ /// let symbol: Symbol<*mut u32> = symbol.lift_option().expect("static is not null");
+ /// }
+ /// ```
+ pub fn lift_option(self) -> Option<Symbol<'lib, T>> {
+ self.inner.lift_option().map(|is| Symbol {
+ inner: is,
+ pd: marker::PhantomData,
+ })
+ }
+}
+
+impl<'lib, T> Clone for Symbol<'lib, T> {
+ fn clone(&self) -> Symbol<'lib, T> {
+ Symbol {
+ inner: self.inner.clone(),
+ pd: marker::PhantomData
+ }
+ }
+}
+
+// FIXME: implement FnOnce for callable stuff instead.
+impl<'lib, T> ops::Deref for Symbol<'lib, T> {
+ type Target = T;
+ fn deref(&self) -> &T {
+ ops::Deref::deref(&self.inner)
+ }
+}
+
+impl<'lib, T> fmt::Debug for Symbol<'lib, T> {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ self.inner.fmt(f)
+ }
+}
+
+unsafe impl<'lib, T: Send> Send for Symbol<'lib, T> {}
+unsafe impl<'lib, T: Sync> Sync for Symbol<'lib, T> {}
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())
+ }
+}
diff --git a/third_party/rust/libloading-0.5.2/src/test_helpers.rs b/third_party/rust/libloading-0.5.2/src/test_helpers.rs
new file mode 100644
index 0000000000..32f7023188
--- /dev/null
+++ b/third_party/rust/libloading-0.5.2/src/test_helpers.rs
@@ -0,0 +1,49 @@
+//! This is a separate file containing helpers for tests of this library. It is built into a
+//! dynamic library by the build.rs script.
+#![crate_type="dylib"] // FIXME: should become a cdylib in due time
+#![cfg_attr(test_nightly, feature(thread_local))]
+
+#[no_mangle]
+pub static mut TEST_STATIC_U32: u32 = 0;
+
+#[no_mangle]
+pub static mut TEST_STATIC_PTR: *mut () = 0 as *mut _;
+
+#[cfg(test_nightly)]
+#[thread_local]
+#[no_mangle]
+pub static mut TEST_THREAD_LOCAL: u32 = 0;
+
+#[no_mangle]
+pub extern "C" fn test_identity_u32(x: u32) -> u32 {
+ x
+}
+
+#[repr(C)]
+pub struct S {
+ a: u64,
+ b: u32,
+ c: u16,
+ d: u8
+}
+
+#[no_mangle]
+pub extern "C" fn test_identity_struct(x: S) -> S {
+ x
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn test_get_static_u32() -> u32 {
+ TEST_STATIC_U32
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn test_check_static_ptr() -> bool {
+ TEST_STATIC_PTR == (&mut TEST_STATIC_PTR as *mut *mut _ as *mut _)
+}
+
+#[cfg(test_nightly)]
+#[no_mangle]
+pub unsafe extern "C" fn test_get_thread_local() -> u32 {
+ TEST_THREAD_LOCAL
+}
diff --git a/third_party/rust/libloading-0.5.2/src/util.rs b/third_party/rust/libloading-0.5.2/src/util.rs
new file mode 100644
index 0000000000..650266e1df
--- /dev/null
+++ b/third_party/rust/libloading-0.5.2/src/util.rs
@@ -0,0 +1,61 @@
+use std::ffi::{CStr, CString, NulError, FromBytesWithNulError};
+use std::borrow::Cow;
+use std::os::raw;
+
+#[derive(Debug)]
+pub struct NullError;
+
+impl From<NulError> for NullError {
+ fn from(_: NulError) -> NullError {
+ NullError
+ }
+}
+
+impl From<FromBytesWithNulError> for NullError {
+ fn from(_: FromBytesWithNulError) -> NullError {
+ NullError
+ }
+}
+
+impl From<NullError> for ::std::io::Error {
+ fn from(e: NullError) -> ::std::io::Error {
+ ::std::io::Error::new(::std::io::ErrorKind::Other, format!("{}", e))
+ }
+}
+
+impl ::std::error::Error for NullError {
+ fn description(&self) -> &str { "non-final null byte found" }
+}
+
+impl ::std::fmt::Display for NullError {
+ fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+ write!(f, "non-final null byte found")
+ }
+}
+
+/// Checks for last byte and avoids allocating if it is zero.
+///
+/// Non-last null bytes still result in an error.
+pub fn cstr_cow_from_bytes<'a>(slice: &'a [u8]) -> Result<Cow<'a, CStr>, NullError> {
+ static ZERO: raw::c_char = 0;
+ Ok(match slice.last() {
+ // Slice out of 0 elements
+ None => unsafe { Cow::Borrowed(CStr::from_ptr(&ZERO)) },
+ // Slice with trailing 0
+ Some(&0) => Cow::Borrowed(try!(CStr::from_bytes_with_nul(slice))),
+ // Slice with no trailing 0
+ Some(_) => Cow::Owned(try!(CString::new(slice))),
+ })
+}
+
+#[inline]
+pub fn ensure_compatible_types<T, E>() {
+ #[cold]
+ #[inline(never)]
+ fn dopanic() {
+ panic!("value of requested type cannot be dynamically loaded");
+ }
+ if ::std::mem::size_of::<T>() != ::std::mem::size_of::<E>() {
+ dopanic()
+ }
+}
generated by cgit v1.2.3 (git 2.39.1) at 2025-02-05 11:17:09 +0000