     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

    //! 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(miri)] {
            // When running under miri all target-features that are not enabled at
            // compile-time are reported as disabled at run-time.
            //
            // For features for which `cfg(target_feature)` returns true,
            // this run-time detection logic is never called.
            #[path = "os/other.rs"]
            mod os;
        } else 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(all(target_os = "linux", feature = "use_std"))] {
            #[path = "os/linux/mod.rs"]
            mod os;
        } else if #[cfg(target_os = "freebsd")] {
            #[cfg(target_arch = "aarch64")]
            #[path = "os/aarch64.rs"]
            mod aarch64;
            #[path = "os/freebsd/mod.rs"]
            mod os;
        } else {
            #[path = "os/other.rs"]
            mod os;
        }
    }
    pub use self::os::check_for;