9c462b84c8
Currently the minimum supported Android version of the standard library is API level 18 (android-18). Back in those days [1] the `signal` function was just an inline wrapper around `bsd_signal`, but starting in API level android-20 the `signal` symbols was introduced [2]. Finally, in android-21 the API `bsd_signal` was removed [3]. Basically this means that if we want to be binary compatible with multiple Android releases (oldest being 18 and newest being 21) then we need to check for both symbols and not actually link against either. This was first discovered in rust-lang/libc#236 with a fix proposed in rust-lang/libc#237. I suspect that we'll want to accept rust-lang/libc#237 so Rust crates at large continue to be compatible with newer releases of Android and crates, like the standard library, that want to opt into older support can continue to do so via similar means. Closes rust-lang/libc#236 [1]: https://chromium.googlesource.com/android_tools/+/20ee6d20/ndk/platforms/android-18/arch-arm/usr/include/signal.h [2]: https://chromium.googlesource.com/android_tools/+/fbd420/ndk_experimental/platforms/android-20/arch-arm/usr/include/signal.h [3]: https://chromium.googlesource.com/android_tools/+/20ee6d/ndk/platforms/android-21/arch-arm/usr/include/signal.h
80 lines
2.6 KiB
Rust
80 lines
2.6 KiB
Rust
// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
|
|
// file at the top-level directory of this distribution and at
|
|
// http://rust-lang.org/COPYRIGHT.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
// option. This file may not be copied, modified, or distributed
|
|
// except according to those terms.
|
|
|
|
//! Support for "weak linkage" to symbols on Unix
|
|
//!
|
|
//! Some I/O operations we do in libstd require newer versions of OSes but we
|
|
//! need to maintain binary compatibility with older releases for now. In order
|
|
//! to use the new functionality when available we use this module for
|
|
//! detection.
|
|
//!
|
|
//! One option to use here is weak linkage, but that is unfortunately only
|
|
//! really workable on Linux. Hence, use dlsym to get the symbol value at
|
|
//! runtime. This is also done for compatibility with older versions of glibc,
|
|
//! and to avoid creating dependencies on GLIBC_PRIVATE symbols. It assumes that
|
|
//! we've been dynamically linked to the library the symbol comes from, but that
|
|
//! is currently always the case for things like libpthread/libc.
|
|
//!
|
|
//! A long time ago this used weak linkage for the __pthread_get_minstack
|
|
//! symbol, but that caused Debian to detect an unnecessarily strict versioned
|
|
//! dependency on libc6 (#23628).
|
|
|
|
use libc;
|
|
|
|
use ffi::CString;
|
|
use marker;
|
|
use mem;
|
|
use sync::atomic::{AtomicUsize, Ordering};
|
|
|
|
macro_rules! weak {
|
|
(fn $name:ident($($t:ty),*) -> $ret:ty) => (
|
|
static $name: ::sys::weak::Weak<unsafe extern fn($($t),*) -> $ret> =
|
|
::sys::weak::Weak::new(stringify!($name));
|
|
)
|
|
}
|
|
|
|
pub struct Weak<F> {
|
|
name: &'static str,
|
|
addr: AtomicUsize,
|
|
_marker: marker::PhantomData<F>,
|
|
}
|
|
|
|
impl<F> Weak<F> {
|
|
pub const fn new(name: &'static str) -> Weak<F> {
|
|
Weak {
|
|
name: name,
|
|
addr: AtomicUsize::new(1),
|
|
_marker: marker::PhantomData,
|
|
}
|
|
}
|
|
|
|
pub fn get(&self) -> Option<&F> {
|
|
assert_eq!(mem::size_of::<F>(), mem::size_of::<usize>());
|
|
unsafe {
|
|
if self.addr.load(Ordering::SeqCst) == 1 {
|
|
self.addr.store(fetch(self.name), Ordering::SeqCst);
|
|
}
|
|
if self.addr.load(Ordering::SeqCst) == 0 {
|
|
None
|
|
} else {
|
|
mem::transmute::<&AtomicUsize, Option<&F>>(&self.addr)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
unsafe fn fetch(name: &str) -> usize {
|
|
let name = match CString::new(name) {
|
|
Ok(cstr) => cstr,
|
|
Err(..) => return 0,
|
|
};
|
|
libc::dlsym(libc::RTLD_DEFAULT, name.as_ptr()) as usize
|
|
}
|