1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79
// 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, 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 }