mod.rs.html -- source
Description: Source to the Rust file `libstd/../stdsimd/stdsimd/arch/detect/mod.rs`.
Keywords: rust, rustlang, rust-lang

     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

    //! This module implements run-time feature detection.
    //!
    //! The `is_{arch}_feature_detected!("feature-name")` macros take the name of a
    //! feature as a string-literal, and return a boolean indicating whether the
    //! feature is enabled at run-time or not.
    //!
    //! These macros do two things:
    //! * map the string-literal into an integer stored as a `Feature` enum,
    //! * call a `os::check_for(x: Feature)` function that returns `true` if the
    //! feature is enabled.
    //!
    //! The `Feature` enums are also implemented in the `arch/{target_arch}.rs`
    //! modules.
    //!
    //! The `check_for` functions are, in general, Operating System dependent. Most
    //! architectures do not allow user-space programs to query the feature bits
    //! due to security concerns (x86 is the big exception). These functions are
    //! implemented in the `os/{target_os}.rs` modules.

    #[macro_use]
    mod error_macros;

    cfg_if! {
        if #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] {
            #[path = "arch/x86.rs"]
            #[macro_use]
            mod arch;
        } else if #[cfg(target_arch = "arm")] {
            #[path = "arch/arm.rs"]
            #[macro_use]
            mod arch;
        } else if #[cfg(target_arch = "aarch64")] {
            #[path = "arch/aarch64.rs"]
            #[macro_use]
            mod arch;
        } else if #[cfg(target_arch = "powerpc")] {
            #[path = "arch/powerpc.rs"]
            #[macro_use]
            mod arch;
        } else if #[cfg(target_arch = "powerpc64")] {
            #[path = "arch/powerpc64.rs"]
            #[macro_use]
            mod arch;
        } else if #[cfg(target_arch = "mips")] {
            #[path = "arch/mips.rs"]
            #[macro_use]
            mod arch;
        } else if #[cfg(target_arch = "mips64")] {
            #[path = "arch/mips64.rs"]
            #[macro_use]
            mod arch;
        } else {
            // Unimplemented architecture:
            mod arch {
                pub enum Feature {
                    Null
                }
            }
        }
    }
    pub use self::arch::Feature;

    mod bit;
    mod cache;

    cfg_if! {
        if #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] {
            // On x86/x86_64 no OS specific functionality is required.
            #[path = "os/x86.rs"]
            mod os;
        } else if #[cfg(target_os = "linux")] {
            #[path = "os/linux/mod.rs"]
            mod os;
        } else {
            #[path = "os/other.rs"]
            mod os;
        }
    }
    pub use self::os::check_for;

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