      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
     80
     81
     82
     83
     84
     85
     86
     87
     88
     89
     90
     91
     92
     93
     94
     95
     96
     97
     98
     99
    100
    101
    102
    103
    104

    //! 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
    }

    #[cfg(not(target_os = "linux"))]
    macro_rules! syscall {
        (fn $name:ident($($arg_name:ident: $t:ty),*) -> $ret:ty) => (
            unsafe fn $name($($arg_name: $t),*) -> $ret {
                use libc;
                use super::os;

                weak! { fn $name($($t),*) -> $ret }

                if let Some(fun) = $name.get() {
                    fun($($arg_name),*)
                } else {
                    os::set_errno(libc::ENOSYS);
                    -1
                }
            }
        )
    }

    #[cfg(target_os = "linux")]
    macro_rules! syscall {
        (fn $name:ident($($arg_name:ident: $t:ty),*) -> $ret:ty) => (
            unsafe fn $name($($arg_name:$t),*) -> $ret {
                // This looks like a hack, but concat_idents only accepts idents
                // (not paths).
                use libc::*;

                syscall(
                    concat_idents!(SYS_, $name),
                    $($arg_name as c_long),*
                ) as $ret
            }
        )
    }

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## 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`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)