Mirrors/rust
1
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2026-04-27 18:57:42 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
316a79f4320bbdfd7fd1eead13ea45f71bc66d5b
rust/library/std_detect
T
History
Tsukasa OI 316a79f432 Stabilize 29 RISC-V target features (riscv_ratified_v2) 
This commit stabilizes RISC-V target features with following constraints:

*   Describes a ratified extension.
*   Implemented on Rust 1.88.0 or before.
    Waiting for four+ version cycles seems sufficient.
*   Does not disrupt current rustc's target feature + ABI handling.
    It excludes "E" and all floating point-arithmetic extensions.
    "Zfinx" family does not involve floating point registers but
    not stabilizing for now to avoid possible confusion between
    the "F" extension family.
*   Not vector-related (floating point and integer).
    While integer vector subsets should not cause any ABI issues
    (as they don't use ABI-dependent floating point registers),
    we need to discuss before stabilizing them.
*   Supported by the lowest LLVM version supported by rustc (LLVM 20).

List of target features to be stabilized:

1.  "b"
2.  "za64rs"   (no-RT)
3.  "za128rs"  (no-RT)
4.  "zaamo"
5.  "zabha"
6.  "zacas"
7.  "zalrsc"
8.  "zama16b"  (no-RT)
9.  "zawrs"
10. "zca"
11. "zcb"
12. "zcmop"
13. "zic64b"   (no-RT)
14. "zicbom"
15. "zicbop"   (no-RT)
16. "zicboz"
17. "ziccamoa" (no-RT)
18. "ziccif"   (no-RT)
19. "zicclsm"  (no-RT)
20. "ziccrse"  (no-RT)
21. "zicntr"
22. "zicond"
23. "zicsr"
24. "zifencei"
25. "zihintntl"
26. "zihintpause"
27. "zihpm"
28. "zimop"
29. "ztso"

Of which, 20 of them (29 minus 9 "no-RT" target features) support
runtime detection through `std::arch::is_riscv_feature_detected!()`.
2025-09-17 10:54:02 +00:00
..
src
Stabilize 29 RISC-V target features (riscv_ratified_v2)
2025-09-17 10:54:02 +00:00
tests
rustc_target: Add the 32s target feature for LoongArch
2025-08-09 13:54:09 +08:00
Cargo.toml
std_detect: Use rustc-std-workspace-* to pull in compiler-builtins
2025-08-19 11:17:35 -07:00
README.md
Move std_detect from library/stdarch to library
2025-07-22 20:17:06 +02:00

README.md

std::detect - Rust's standard library run-time CPU feature detection

The private std::detect module implements run-time feature detection in Rust's standard library. This allows detecting whether the CPU the binary runs on supports certain features, like SIMD instructions.

Usage

std::detect APIs are available as part of libstd. Prefer using it via the standard library than through this crate. Unstable features of std::detect are available on nightly Rust behind various feature-gates.

If you need run-time feature detection in #[no_std] environments, Rust core library cannot help you. By design, Rust core is platform independent, but performing run-time feature detection requires a certain level of cooperation from the platform.

You can then manually include std_detect as a dependency to get similar run-time feature detection support than the one offered by Rust's standard library. We intend to make std_detect more flexible and configurable in this regard to better serve the needs of #[no_std] targets.

Features

  • std_detect_dlsym_getauxval (enabled by default, requires libc): Enable to use libc::dlsym to query whether getauxval is linked into the binary. When this is not the case, this feature allows other fallback methods to perform run-time feature detection. When this feature is disabled, std_detect assumes that getauxval is linked to the binary. If that is not the case the behavior is undefined.

    Note: This feature is ignored on *-linux-{gnu,musl,ohos}* and *-android* targets because we can safely assume getauxval is linked to the binary.

  • std_detect_file_io (enabled by default, requires std): Enable to perform run-time feature detection using file APIs (e.g. /proc/self/auxv, etc.) if other more performant methods fail. This feature requires libstd as a dependency, preventing the crate from working on applications in which std is not available.

Platform support

  • All x86/x86_64 targets are supported on all platforms by querying the cpuid instruction directly for the features supported by the hardware and the operating system. std_detect assumes that the binary is an user-space application.

  • Linux/Android:

    • arm{32, 64}, mips{32,64}{,el}, powerpc{32,64}{,le}, loongarch{32,64}, s390x: std_detect supports these on Linux by querying ELF auxiliary vectors (using getauxval when available), and if that fails, by querying /proc/self/auxv.
    • arm64: partial support for doing run-time feature detection by directly querying mrs is implemented for Linux >= 4.11, but not enabled by default.
    • riscv{32,64}: std_detect supports these on Linux by querying riscv_hwprobe, and by querying ELF auxiliary vectors (using getauxval when available).

  • FreeBSD:

    • arm32, powerpc64: std_detect supports these on FreeBSD by querying ELF auxiliary vectors using sysctl.
    • arm64: run-time feature detection is implemented by directly querying mrs.

  • OpenBSD:

    • arm64: run-time feature detection is implemented by querying sysctl.

  • Windows:

    • arm64: run-time feature detection is implemented by querying IsProcessorFeaturePresent.

License

This project is licensed under either of

at your option.

Contribution

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in std_detect by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.

Reference in New Issue View Git Blame Copy Permalink