     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: 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
    }

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)