rustc_target/
target_features.rs

1//! Declares Rust's target feature names for each target.
2//! Note that these are similar to but not always identical to LLVM's feature names,
3//! and Rust adds some features that do not correspond to LLVM features at all.
4use rustc_data_structures::fx::{FxHashMap, FxHashSet};
5use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
6use rustc_span::{Symbol, sym};
7
8use crate::spec::{Abi, Arch, FloatAbi, RustcAbi, Target};
9
10/// Features that control behaviour of rustc, rather than the codegen.
11/// These exist globally and are not in the target-specific lists below.
12pub const RUSTC_SPECIFIC_FEATURES: &[&str] = &["crt-static"];
13
14/// Stability information for target features.
15#[derive(#[automatically_derived]
impl ::core::fmt::Debug for Stability {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        match self {
            Stability::Stable =>
                ::core::fmt::Formatter::write_str(f, "Stable"),
            Stability::Unstable(__self_0) =>
                ::core::fmt::Formatter::debug_tuple_field1_finish(f,
                    "Unstable", &__self_0),
            Stability::Forbidden { reason: __self_0 } =>
                ::core::fmt::Formatter::debug_struct_field1_finish(f,
                    "Forbidden", "reason", &__self_0),
        }
    }
}Debug, #[automatically_derived]
impl ::core::marker::Copy for Stability { }Copy, #[automatically_derived]
impl ::core::clone::Clone for Stability {
    #[inline]
    fn clone(&self) -> Stability {
        let _: ::core::clone::AssertParamIsClone<Symbol>;
        let _: ::core::clone::AssertParamIsClone<&'static str>;
        *self
    }
}Clone)]
16pub enum Stability {
17    /// This target feature is stable, it can be used in `#[target_feature]` and
18    /// `#[cfg(target_feature)]`.
19    Stable,
20    /// This target feature is unstable. It is only present in `#[cfg(target_feature)]` on
21    /// nightly and using it in `#[target_feature]` requires enabling the given nightly feature.
22    Unstable(
23        /// This must be a *language* feature, or else rustc will ICE when reporting a missing
24        /// feature gate!
25        Symbol,
26    ),
27    /// This feature can not be set via `-Ctarget-feature` or `#[target_feature]`, it can only be
28    /// set in the target spec. It is never set in `cfg(target_feature)`. Used in
29    /// particular for features are actually ABI configuration flags (not all targets are as nice as
30    /// RISC-V and have an explicit way to set the ABI separate from target features).
31    Forbidden { reason: &'static str },
32}
33use Stability::*;
34
35impl<CTX> HashStable<CTX> for Stability {
36    #[inline]
37    fn hash_stable(&self, hcx: &mut CTX, hasher: &mut StableHasher) {
38        std::mem::discriminant(self).hash_stable(hcx, hasher);
39        match self {
40            Stability::Stable => {}
41            Stability::Unstable(nightly_feature) => {
42                nightly_feature.hash_stable(hcx, hasher);
43            }
44            Stability::Forbidden { reason } => {
45                reason.hash_stable(hcx, hasher);
46            }
47        }
48    }
49}
50
51impl Stability {
52    /// Returns whether the feature can be used in `cfg(target_feature)` ever.
53    /// (It might still be nightly-only even if this returns `true`, so make sure to also check
54    /// `requires_nightly`.)
55    pub fn in_cfg(&self) -> bool {
56        #[allow(non_exhaustive_omitted_patterns)] match self {
    Stability::Stable | Stability::Unstable { .. } => true,
    _ => false,
}matches!(self, Stability::Stable | Stability::Unstable { .. })
57    }
58
59    /// Returns the nightly feature that is required to toggle this target feature via
60    /// `#[target_feature]`/`-Ctarget-feature` or to test it via `cfg(target_feature)`.
61    /// (For `cfg` we only care whether the feature is nightly or not, we don't require
62    /// the feature gate to actually be enabled when using a nightly compiler.)
63    ///
64    /// Before calling this, ensure the feature is even permitted for this use:
65    /// - for `#[target_feature]`/`-Ctarget-feature`, check `toggle_allowed()`
66    /// - for `cfg(target_feature)`, check `in_cfg()`
67    pub fn requires_nightly(&self) -> Option<Symbol> {
68        match *self {
69            Stability::Unstable(nightly_feature) => Some(nightly_feature),
70            Stability::Stable { .. } => None,
71            Stability::Forbidden { .. } => {
    ::core::panicking::panic_fmt(format_args!("forbidden features should not reach this far"));
}panic!("forbidden features should not reach this far"),
72        }
73    }
74
75    /// Returns whether the feature may be toggled via `#[target_feature]` or `-Ctarget-feature`.
76    /// (It might still be nightly-only even if this returns `true`, so make sure to also check
77    /// `requires_nightly`.)
78    pub fn toggle_allowed(&self) -> Result<(), &'static str> {
79        match self {
80            Stability::Unstable(_) | Stability::Stable { .. } => Ok(()),
81            Stability::Forbidden { reason } => Err(reason),
82        }
83    }
84}
85
86// Here we list target features that rustc "understands": they can be used in `#[target_feature]`
87// and `#[cfg(target_feature)]`. They also do not trigger any warnings when used with
88// `-Ctarget-feature`.
89//
90// Note that even unstable (and even entirely unlisted) features can be used with `-Ctarget-feature`
91// on stable. Using a feature not on the list of Rust target features only emits a warning.
92// Only `cfg(target_feature)` and `#[target_feature]` actually do any stability gating.
93// `cfg(target_feature)` for unstable features just works on nightly without any feature gate.
94// `#[target_feature]` requires a feature gate.
95//
96// When adding features to the below lists
97// check whether they're named already elsewhere in rust
98// e.g. in stdarch and whether the given name matches LLVM's
99// if it doesn't, to_llvm_feature in llvm_util in rustc_codegen_llvm needs to be adapted.
100// Additionally, if the feature is not available in older version of LLVM supported by the current
101// rust, the same function must be updated to filter out these features to avoid triggering
102// warnings.
103//
104// Also note that all target features listed here must be purely additive: for target_feature 1.1 to
105// be sound, we can never allow features like `+soft-float` (on x86) to be controlled on a
106// per-function level, since we would then allow safe calls from functions with `+soft-float` to
107// functions without that feature!
108//
109// It is important for soundness to consider the interaction of targets features and the function
110// call ABI. For example, disabling the `x87` feature on x86 changes how scalar floats are passed as
111// arguments, so letting people toggle that feature would be unsound. To this end, the
112// `abi_required_features` function computes which target features must and must not be enabled for
113// any given target, and individual features can also be marked as `Forbidden`.
114// See https://github.com/rust-lang/rust/issues/116344 for some more context.
115//
116// The one exception to features that change the ABI is features that enable larger vector
117// registers. Those are permitted to be listed here. The `*_FOR_CORRECT_VECTOR_ABI` arrays store
118// information about which target feature is ABI-required for which vector size; this is used to
119// ensure that vectors can only be passed via `extern "C"` when the right feature is enabled. (For
120// the "Rust" ABI we generally pass vectors by-ref exactly to avoid these issues.)
121// Also see https://github.com/rust-lang/rust/issues/116558.
122//
123// Stabilizing a target feature requires t-lang approval.
124
125// If feature A "implies" feature B, then:
126// - when A gets enabled (via `-Ctarget-feature` or `#[target_feature]`), we also enable B
127// - when B gets disabled (via `-Ctarget-feature`), we also disable A
128//
129// Both of these are also applied transitively.
130type ImpliedFeatures = &'static [&'static str];
131
132static ARM_FEATURES: &[(&str, Stability, ImpliedFeatures)] = &[
133    // tidy-alphabetical-start
134    ("aclass", Unstable(sym::arm_target_feature), &[]),
135    ("aes", Unstable(sym::arm_target_feature), &["neon"]),
136    (
137        "atomics-32",
138        Stability::Forbidden { reason: "unsound because it changes the ABI of atomic operations" },
139        &[],
140    ),
141    ("crc", Unstable(sym::arm_target_feature), &[]),
142    ("d32", Unstable(sym::arm_target_feature), &[]),
143    ("dotprod", Unstable(sym::arm_target_feature), &["neon"]),
144    ("dsp", Unstable(sym::arm_target_feature), &[]),
145    ("fp-armv8", Unstable(sym::arm_target_feature), &["vfp4"]),
146    ("fp16", Unstable(sym::arm_target_feature), &["neon"]),
147    ("fpregs", Unstable(sym::arm_target_feature), &[]),
148    ("i8mm", Unstable(sym::arm_target_feature), &["neon"]),
149    ("mclass", Unstable(sym::arm_target_feature), &[]),
150    ("neon", Unstable(sym::arm_target_feature), &["vfp3"]),
151    ("rclass", Unstable(sym::arm_target_feature), &[]),
152    ("sha2", Unstable(sym::arm_target_feature), &["neon"]),
153    // This can be *disabled* on non-`hf` targets to enable the use
154    // of hardfloats while keeping the softfloat ABI.
155    // FIXME before stabilization: Should we expose this as a `hard-float` target feature instead of
156    // matching the odd negative feature LLVM uses?
157    ("soft-float", Unstable(sym::arm_target_feature), &[]),
158    // This is needed for inline assembly, but shouldn't be stabilized as-is
159    // since it should be enabled per-function using #[instruction_set], not
160    // #[target_feature].
161    ("thumb-mode", Unstable(sym::arm_target_feature), &[]),
162    ("thumb2", Unstable(sym::arm_target_feature), &[]),
163    ("trustzone", Unstable(sym::arm_target_feature), &[]),
164    ("v5te", Unstable(sym::arm_target_feature), &[]),
165    ("v6", Unstable(sym::arm_target_feature), &["v5te"]),
166    ("v6k", Unstable(sym::arm_target_feature), &["v6"]),
167    ("v6t2", Unstable(sym::arm_target_feature), &["v6k", "thumb2"]),
168    ("v7", Unstable(sym::arm_target_feature), &["v6t2"]),
169    ("v8", Unstable(sym::arm_target_feature), &["v7"]),
170    ("vfp2", Unstable(sym::arm_target_feature), &[]),
171    ("vfp3", Unstable(sym::arm_target_feature), &["vfp2", "d32"]),
172    ("vfp4", Unstable(sym::arm_target_feature), &["vfp3"]),
173    ("virtualization", Unstable(sym::arm_target_feature), &[]),
174    // tidy-alphabetical-end
175];
176
177static AARCH64_FEATURES: &[(&str, Stability, ImpliedFeatures)] = &[
178    // tidy-alphabetical-start
179    // FEAT_AES & FEAT_PMULL
180    ("aes", Stable, &["neon"]),
181    // FEAT_BF16
182    ("bf16", Stable, &[]),
183    // FEAT_BTI
184    ("bti", Stable, &[]),
185    // FEAT_CRC
186    ("crc", Stable, &[]),
187    // FEAT_CSSC
188    ("cssc", Unstable(sym::aarch64_unstable_target_feature), &[]),
189    // FEAT_DIT
190    ("dit", Stable, &[]),
191    // FEAT_DotProd
192    ("dotprod", Stable, &["neon"]),
193    // FEAT_DPB
194    ("dpb", Stable, &[]),
195    // FEAT_DPB2
196    ("dpb2", Stable, &["dpb"]),
197    // FEAT_ECV
198    ("ecv", Unstable(sym::aarch64_unstable_target_feature), &[]),
199    // FEAT_F32MM
200    ("f32mm", Stable, &["sve"]),
201    // FEAT_F64MM
202    ("f64mm", Stable, &["sve"]),
203    // FEAT_FAMINMAX
204    ("faminmax", Unstable(sym::aarch64_unstable_target_feature), &[]),
205    // FEAT_FCMA
206    ("fcma", Stable, &["neon"]),
207    // FEAT_FHM
208    ("fhm", Stable, &["fp16"]),
209    // FEAT_FLAGM
210    ("flagm", Stable, &[]),
211    // FEAT_FLAGM2
212    ("flagm2", Unstable(sym::aarch64_unstable_target_feature), &[]),
213    // We forbid directly toggling just `fp-armv8`; it must be toggled with `neon`.
214    ("fp-armv8", Stability::Forbidden { reason: "Rust ties `fp-armv8` to `neon`" }, &[]),
215    // FEAT_FP8
216    ("fp8", Unstable(sym::aarch64_unstable_target_feature), &["faminmax", "lut", "bf16"]),
217    // FEAT_FP8DOT2
218    ("fp8dot2", Unstable(sym::aarch64_unstable_target_feature), &["fp8dot4"]),
219    // FEAT_FP8DOT4
220    ("fp8dot4", Unstable(sym::aarch64_unstable_target_feature), &["fp8fma"]),
221    // FEAT_FP8FMA
222    ("fp8fma", Unstable(sym::aarch64_unstable_target_feature), &["fp8"]),
223    // FEAT_FP16
224    // Rust ties FP and Neon: https://github.com/rust-lang/rust/pull/91608
225    ("fp16", Stable, &["neon"]),
226    // FEAT_FRINTTS
227    ("frintts", Stable, &[]),
228    // FEAT_HBC
229    ("hbc", Unstable(sym::aarch64_unstable_target_feature), &[]),
230    // FEAT_I8MM
231    ("i8mm", Stable, &[]),
232    // FEAT_JSCVT
233    // Rust ties FP and Neon: https://github.com/rust-lang/rust/pull/91608
234    ("jsconv", Stable, &["neon"]),
235    // FEAT_LOR
236    ("lor", Stable, &[]),
237    // FEAT_LSE
238    ("lse", Stable, &[]),
239    // FEAT_LSE2
240    ("lse2", Unstable(sym::aarch64_unstable_target_feature), &[]),
241    // FEAT_LSE128
242    ("lse128", Unstable(sym::aarch64_unstable_target_feature), &["lse"]),
243    // FEAT_LUT
244    ("lut", Unstable(sym::aarch64_unstable_target_feature), &[]),
245    // FEAT_MOPS
246    ("mops", Unstable(sym::aarch64_unstable_target_feature), &[]),
247    // FEAT_MTE & FEAT_MTE2
248    ("mte", Stable, &[]),
249    // FEAT_AdvSimd & FEAT_FP
250    ("neon", Stable, &[]),
251    // Backend option to turn atomic operations into an intrinsic call when `lse` is not known to be
252    // available, so the intrinsic can do runtime LSE feature detection rather than unconditionally
253    // using slower non-LSE operations. Unstable since it doesn't need to user-togglable.
254    ("outline-atomics", Unstable(sym::aarch64_unstable_target_feature), &[]),
255    // FEAT_PAUTH (address authentication)
256    ("paca", Stable, &[]),
257    // FEAT_PAUTH (generic authentication)
258    ("pacg", Stable, &[]),
259    // FEAT_PAN
260    ("pan", Stable, &[]),
261    // FEAT_PAuth_LR
262    ("pauth-lr", Unstable(sym::aarch64_unstable_target_feature), &[]),
263    // FEAT_PMUv3
264    ("pmuv3", Stable, &[]),
265    // FEAT_RNG
266    ("rand", Stable, &[]),
267    // FEAT_RAS & FEAT_RASv1p1
268    ("ras", Stable, &[]),
269    // FEAT_LRCPC
270    ("rcpc", Stable, &[]),
271    // FEAT_LRCPC2
272    ("rcpc2", Stable, &["rcpc"]),
273    // FEAT_LRCPC3
274    ("rcpc3", Unstable(sym::aarch64_unstable_target_feature), &["rcpc2"]),
275    // FEAT_RDM
276    ("rdm", Stable, &["neon"]),
277    ("reserve-x18", Forbidden { reason: "use `-Zfixed-x18` compiler flag instead" }, &[]),
278    // FEAT_SB
279    ("sb", Stable, &[]),
280    // FEAT_SHA1 & FEAT_SHA256
281    ("sha2", Stable, &["neon"]),
282    // FEAT_SHA512 & FEAT_SHA3
283    ("sha3", Stable, &["sha2"]),
284    // FEAT_SM3 & FEAT_SM4
285    ("sm4", Stable, &["neon"]),
286    // FEAT_SME
287    ("sme", Unstable(sym::aarch64_unstable_target_feature), &["bf16"]),
288    // FEAT_SME_B16B16
289    ("sme-b16b16", Unstable(sym::aarch64_unstable_target_feature), &["bf16", "sme2", "sve-b16b16"]),
290    // FEAT_SME_F8F16
291    ("sme-f8f16", Unstable(sym::aarch64_unstable_target_feature), &["sme-f8f32"]),
292    // FEAT_SME_F8F32
293    ("sme-f8f32", Unstable(sym::aarch64_unstable_target_feature), &["sme2", "fp8"]),
294    // FEAT_SME_F16F16
295    ("sme-f16f16", Unstable(sym::aarch64_unstable_target_feature), &["sme2"]),
296    // FEAT_SME_F64F64
297    ("sme-f64f64", Unstable(sym::aarch64_unstable_target_feature), &["sme"]),
298    // FEAT_SME_FA64
299    ("sme-fa64", Unstable(sym::aarch64_unstable_target_feature), &["sme", "sve2"]),
300    // FEAT_SME_I16I64
301    ("sme-i16i64", Unstable(sym::aarch64_unstable_target_feature), &["sme"]),
302    // FEAT_SME_LUTv2
303    ("sme-lutv2", Unstable(sym::aarch64_unstable_target_feature), &[]),
304    // FEAT_SME2
305    ("sme2", Unstable(sym::aarch64_unstable_target_feature), &["sme"]),
306    // FEAT_SME2p1
307    ("sme2p1", Unstable(sym::aarch64_unstable_target_feature), &["sme2"]),
308    // FEAT_SPE
309    ("spe", Stable, &[]),
310    // FEAT_SSBS & FEAT_SSBS2
311    ("ssbs", Stable, &[]),
312    // FEAT_SSVE_FP8FDOT2
313    ("ssve-fp8dot2", Unstable(sym::aarch64_unstable_target_feature), &["ssve-fp8dot4"]),
314    // FEAT_SSVE_FP8FDOT4
315    ("ssve-fp8dot4", Unstable(sym::aarch64_unstable_target_feature), &["ssve-fp8fma"]),
316    // FEAT_SSVE_FP8FMA
317    ("ssve-fp8fma", Unstable(sym::aarch64_unstable_target_feature), &["sme2", "fp8"]),
318    // FEAT_SVE
319    // It was decided that SVE requires Neon: https://github.com/rust-lang/rust/pull/91608
320    //
321    // LLVM doesn't enable Neon for SVE. ARM indicates that they're separate, but probably always
322    // exist together: https://developer.arm.com/documentation/102340/0100/New-features-in-SVE2
323    //
324    // "For backwards compatibility, Neon and VFP are required in the latest architectures."
325    ("sve", Stable, &["neon"]),
326    // FEAT_SVE_B16B16 (SVE or SME Z-targeting instructions)
327    ("sve-b16b16", Unstable(sym::aarch64_unstable_target_feature), &["bf16"]),
328    // FEAT_SVE2
329    ("sve2", Stable, &["sve"]),
330    // FEAT_SVE_AES & FEAT_SVE_PMULL128
331    ("sve2-aes", Stable, &["sve2", "aes"]),
332    // FEAT_SVE2_BitPerm
333    ("sve2-bitperm", Stable, &["sve2"]),
334    // FEAT_SVE2_SHA3
335    ("sve2-sha3", Stable, &["sve2", "sha3"]),
336    // FEAT_SVE2_SM4
337    ("sve2-sm4", Stable, &["sve2", "sm4"]),
338    // FEAT_SVE2p1
339    ("sve2p1", Unstable(sym::aarch64_unstable_target_feature), &["sve2"]),
340    // FEAT_TME
341    ("tme", Stable, &[]),
342    (
343        "v8.1a",
344        Unstable(sym::aarch64_ver_target_feature),
345        &["crc", "lse", "rdm", "pan", "lor", "vh"],
346    ),
347    ("v8.2a", Unstable(sym::aarch64_ver_target_feature), &["v8.1a", "ras", "dpb"]),
348    (
349        "v8.3a",
350        Unstable(sym::aarch64_ver_target_feature),
351        &["v8.2a", "rcpc", "paca", "pacg", "jsconv"],
352    ),
353    ("v8.4a", Unstable(sym::aarch64_ver_target_feature), &["v8.3a", "dotprod", "dit", "flagm"]),
354    ("v8.5a", Unstable(sym::aarch64_ver_target_feature), &["v8.4a", "ssbs", "sb", "dpb2", "bti"]),
355    ("v8.6a", Unstable(sym::aarch64_ver_target_feature), &["v8.5a", "bf16", "i8mm"]),
356    ("v8.7a", Unstable(sym::aarch64_ver_target_feature), &["v8.6a", "wfxt"]),
357    ("v8.8a", Unstable(sym::aarch64_ver_target_feature), &["v8.7a", "hbc", "mops"]),
358    ("v8.9a", Unstable(sym::aarch64_ver_target_feature), &["v8.8a", "cssc"]),
359    ("v9.1a", Unstable(sym::aarch64_ver_target_feature), &["v9a", "v8.6a"]),
360    ("v9.2a", Unstable(sym::aarch64_ver_target_feature), &["v9.1a", "v8.7a"]),
361    ("v9.3a", Unstable(sym::aarch64_ver_target_feature), &["v9.2a", "v8.8a"]),
362    ("v9.4a", Unstable(sym::aarch64_ver_target_feature), &["v9.3a", "v8.9a"]),
363    ("v9.5a", Unstable(sym::aarch64_ver_target_feature), &["v9.4a"]),
364    ("v9a", Unstable(sym::aarch64_ver_target_feature), &["v8.5a", "sve2"]),
365    // FEAT_VHE
366    ("vh", Stable, &[]),
367    // FEAT_WFxT
368    ("wfxt", Unstable(sym::aarch64_unstable_target_feature), &[]),
369    // tidy-alphabetical-end
370];
371
372const AARCH64_TIED_FEATURES: &[&[&str]] = &[
373    &["paca", "pacg"], // Together these represent `pauth` in LLVM
374];
375
376static X86_FEATURES: &[(&str, Stability, ImpliedFeatures)] = &[
377    // tidy-alphabetical-start
378    ("adx", Stable, &[]),
379    ("aes", Stable, &["sse2"]),
380    ("amx-avx512", Unstable(sym::x86_amx_intrinsics), &["amx-tile"]),
381    ("amx-bf16", Unstable(sym::x86_amx_intrinsics), &["amx-tile"]),
382    ("amx-complex", Unstable(sym::x86_amx_intrinsics), &["amx-tile"]),
383    ("amx-fp8", Unstable(sym::x86_amx_intrinsics), &["amx-tile"]),
384    ("amx-fp16", Unstable(sym::x86_amx_intrinsics), &["amx-tile"]),
385    ("amx-int8", Unstable(sym::x86_amx_intrinsics), &["amx-tile"]),
386    ("amx-movrs", Unstable(sym::x86_amx_intrinsics), &["amx-tile"]),
387    ("amx-tf32", Unstable(sym::x86_amx_intrinsics), &["amx-tile"]),
388    ("amx-tile", Unstable(sym::x86_amx_intrinsics), &[]),
389    ("apxf", Unstable(sym::apx_target_feature), &[]),
390    ("avx", Stable, &["sse4.2"]),
391    ("avx2", Stable, &["avx"]),
392    (
393        "avx10.1",
394        Unstable(sym::avx10_target_feature),
395        &[
396            "avx512bf16",
397            "avx512bitalg",
398            "avx512bw",
399            "avx512cd",
400            "avx512dq",
401            "avx512f",
402            "avx512fp16",
403            "avx512ifma",
404            "avx512vbmi",
405            "avx512vbmi2",
406            "avx512vl",
407            "avx512vnni",
408            "avx512vpopcntdq",
409        ],
410    ),
411    ("avx10.2", Unstable(sym::avx10_target_feature), &["avx10.1"]),
412    ("avx512bf16", Stable, &["avx512bw"]),
413    ("avx512bitalg", Stable, &["avx512bw"]),
414    ("avx512bw", Stable, &["avx512f"]),
415    ("avx512cd", Stable, &["avx512f"]),
416    ("avx512dq", Stable, &["avx512f"]),
417    ("avx512f", Stable, &["avx2", "fma", "f16c"]),
418    ("avx512fp16", Stable, &["avx512bw"]),
419    ("avx512ifma", Stable, &["avx512f"]),
420    ("avx512vbmi", Stable, &["avx512bw"]),
421    ("avx512vbmi2", Stable, &["avx512bw"]),
422    ("avx512vl", Stable, &["avx512f"]),
423    ("avx512vnni", Stable, &["avx512f"]),
424    ("avx512vp2intersect", Stable, &["avx512f"]),
425    ("avx512vpopcntdq", Stable, &["avx512f"]),
426    ("avxifma", Stable, &["avx2"]),
427    ("avxneconvert", Stable, &["avx2"]),
428    ("avxvnni", Stable, &["avx2"]),
429    ("avxvnniint8", Stable, &["avx2"]),
430    ("avxvnniint16", Stable, &["avx2"]),
431    ("bmi1", Stable, &[]),
432    ("bmi2", Stable, &[]),
433    ("cmpxchg16b", Stable, &[]),
434    ("ermsb", Unstable(sym::ermsb_target_feature), &[]),
435    ("f16c", Stable, &["avx"]),
436    ("fma", Stable, &["avx"]),
437    ("fxsr", Stable, &[]),
438    ("gfni", Stable, &["sse2"]),
439    ("kl", Stable, &["sse2"]),
440    ("lahfsahf", Unstable(sym::lahfsahf_target_feature), &[]),
441    ("lzcnt", Stable, &[]),
442    ("movbe", Stable, &[]),
443    ("movrs", Unstable(sym::movrs_target_feature), &[]),
444    ("pclmulqdq", Stable, &["sse2"]),
445    ("popcnt", Stable, &[]),
446    ("prfchw", Unstable(sym::prfchw_target_feature), &[]),
447    ("rdrand", Stable, &[]),
448    ("rdseed", Stable, &[]),
449    (
450        "retpoline-external-thunk",
451        Stability::Forbidden { reason: "use `-Zretpoline-external-thunk` compiler flag instead" },
452        &[],
453    ),
454    (
455        "retpoline-indirect-branches",
456        Stability::Forbidden { reason: "use `-Zretpoline` compiler flag instead" },
457        &[],
458    ),
459    (
460        "retpoline-indirect-calls",
461        Stability::Forbidden { reason: "use `-Zretpoline` compiler flag instead" },
462        &[],
463    ),
464    ("rtm", Unstable(sym::rtm_target_feature), &[]),
465    ("sha", Stable, &["sse2"]),
466    ("sha512", Stable, &["avx2"]),
467    ("sm3", Stable, &["avx"]),
468    ("sm4", Stable, &["avx2"]),
469    // This cannot actually be toggled, the ABI always fixes it, so it'd make little sense to
470    // stabilize. It must be in this list for the ABI check to be able to use it.
471    ("soft-float", Stability::Unstable(sym::x87_target_feature), &[]),
472    ("sse", Stable, &[]),
473    ("sse2", Stable, &["sse"]),
474    ("sse3", Stable, &["sse2"]),
475    ("sse4.1", Stable, &["ssse3"]),
476    ("sse4.2", Stable, &["sse4.1"]),
477    ("sse4a", Stable, &["sse3"]),
478    ("ssse3", Stable, &["sse3"]),
479    ("tbm", Stable, &[]),
480    ("vaes", Stable, &["avx2", "aes"]),
481    ("vpclmulqdq", Stable, &["avx", "pclmulqdq"]),
482    ("widekl", Stable, &["kl"]),
483    ("x87", Unstable(sym::x87_target_feature), &[]),
484    ("xop", Unstable(sym::xop_target_feature), &[/*"fma4", */ "avx", "sse4a"]),
485    ("xsave", Stable, &[]),
486    ("xsavec", Stable, &["xsave"]),
487    ("xsaveopt", Stable, &["xsave"]),
488    ("xsaves", Stable, &["xsave"]),
489    // tidy-alphabetical-end
490];
491
492const HEXAGON_FEATURES: &[(&str, Stability, ImpliedFeatures)] = &[
493    // tidy-alphabetical-start
494    ("hvx", Unstable(sym::hexagon_target_feature), &[]),
495    ("hvx-length128b", Unstable(sym::hexagon_target_feature), &["hvx"]),
496    // tidy-alphabetical-end
497];
498
499static POWERPC_FEATURES: &[(&str, Stability, ImpliedFeatures)] = &[
500    // tidy-alphabetical-start
501    ("altivec", Unstable(sym::powerpc_target_feature), &[]),
502    ("msync", Unstable(sym::powerpc_target_feature), &[]),
503    ("partword-atomics", Unstable(sym::powerpc_target_feature), &[]),
504    ("power8-altivec", Unstable(sym::powerpc_target_feature), &["altivec"]),
505    ("power8-crypto", Unstable(sym::powerpc_target_feature), &["power8-altivec"]),
506    ("power8-vector", Unstable(sym::powerpc_target_feature), &["vsx", "power8-altivec"]),
507    ("power9-altivec", Unstable(sym::powerpc_target_feature), &["power8-altivec"]),
508    ("power9-vector", Unstable(sym::powerpc_target_feature), &["power8-vector", "power9-altivec"]),
509    ("power10-vector", Unstable(sym::powerpc_target_feature), &["power9-vector"]),
510    ("quadword-atomics", Unstable(sym::powerpc_target_feature), &[]),
511    ("vsx", Unstable(sym::powerpc_target_feature), &["altivec"]),
512    // tidy-alphabetical-end
513];
514
515const MIPS_FEATURES: &[(&str, Stability, ImpliedFeatures)] = &[
516    // tidy-alphabetical-start
517    ("fp64", Unstable(sym::mips_target_feature), &[]),
518    ("msa", Unstable(sym::mips_target_feature), &[]),
519    ("virt", Unstable(sym::mips_target_feature), &[]),
520    // tidy-alphabetical-end
521];
522
523const NVPTX_FEATURES: &[(&str, Stability, ImpliedFeatures)] = &[
524    // tidy-alphabetical-start
525    ("sm_20", Unstable(sym::nvptx_target_feature), &[]),
526    ("sm_21", Unstable(sym::nvptx_target_feature), &["sm_20"]),
527    ("sm_30", Unstable(sym::nvptx_target_feature), &["sm_21"]),
528    ("sm_32", Unstable(sym::nvptx_target_feature), &["sm_30"]),
529    ("sm_35", Unstable(sym::nvptx_target_feature), &["sm_32"]),
530    ("sm_37", Unstable(sym::nvptx_target_feature), &["sm_35"]),
531    ("sm_50", Unstable(sym::nvptx_target_feature), &["sm_37"]),
532    ("sm_52", Unstable(sym::nvptx_target_feature), &["sm_50"]),
533    ("sm_53", Unstable(sym::nvptx_target_feature), &["sm_52"]),
534    ("sm_60", Unstable(sym::nvptx_target_feature), &["sm_53"]),
535    ("sm_61", Unstable(sym::nvptx_target_feature), &["sm_60"]),
536    ("sm_62", Unstable(sym::nvptx_target_feature), &["sm_61"]),
537    ("sm_70", Unstable(sym::nvptx_target_feature), &["sm_62"]),
538    ("sm_72", Unstable(sym::nvptx_target_feature), &["sm_70"]),
539    ("sm_75", Unstable(sym::nvptx_target_feature), &["sm_72"]),
540    ("sm_80", Unstable(sym::nvptx_target_feature), &["sm_75"]),
541    ("sm_86", Unstable(sym::nvptx_target_feature), &["sm_80"]),
542    ("sm_87", Unstable(sym::nvptx_target_feature), &["sm_86"]),
543    ("sm_89", Unstable(sym::nvptx_target_feature), &["sm_87"]),
544    ("sm_90", Unstable(sym::nvptx_target_feature), &["sm_89"]),
545    ("sm_90a", Unstable(sym::nvptx_target_feature), &["sm_90"]),
546    // tidy-alphabetical-end
547    // tidy-alphabetical-start
548    ("sm_100", Unstable(sym::nvptx_target_feature), &["sm_90"]),
549    ("sm_100a", Unstable(sym::nvptx_target_feature), &["sm_100"]),
550    ("sm_101", Unstable(sym::nvptx_target_feature), &["sm_100"]),
551    ("sm_101a", Unstable(sym::nvptx_target_feature), &["sm_101"]),
552    ("sm_120", Unstable(sym::nvptx_target_feature), &["sm_101"]),
553    ("sm_120a", Unstable(sym::nvptx_target_feature), &["sm_120"]),
554    // tidy-alphabetical-end
555    // tidy-alphabetical-start
556    ("ptx32", Unstable(sym::nvptx_target_feature), &[]),
557    ("ptx40", Unstable(sym::nvptx_target_feature), &["ptx32"]),
558    ("ptx41", Unstable(sym::nvptx_target_feature), &["ptx40"]),
559    ("ptx42", Unstable(sym::nvptx_target_feature), &["ptx41"]),
560    ("ptx43", Unstable(sym::nvptx_target_feature), &["ptx42"]),
561    ("ptx50", Unstable(sym::nvptx_target_feature), &["ptx43"]),
562    ("ptx60", Unstable(sym::nvptx_target_feature), &["ptx50"]),
563    ("ptx61", Unstable(sym::nvptx_target_feature), &["ptx60"]),
564    ("ptx62", Unstable(sym::nvptx_target_feature), &["ptx61"]),
565    ("ptx63", Unstable(sym::nvptx_target_feature), &["ptx62"]),
566    ("ptx64", Unstable(sym::nvptx_target_feature), &["ptx63"]),
567    ("ptx65", Unstable(sym::nvptx_target_feature), &["ptx64"]),
568    ("ptx70", Unstable(sym::nvptx_target_feature), &["ptx65"]),
569    ("ptx71", Unstable(sym::nvptx_target_feature), &["ptx70"]),
570    ("ptx72", Unstable(sym::nvptx_target_feature), &["ptx71"]),
571    ("ptx73", Unstable(sym::nvptx_target_feature), &["ptx72"]),
572    ("ptx74", Unstable(sym::nvptx_target_feature), &["ptx73"]),
573    ("ptx75", Unstable(sym::nvptx_target_feature), &["ptx74"]),
574    ("ptx76", Unstable(sym::nvptx_target_feature), &["ptx75"]),
575    ("ptx77", Unstable(sym::nvptx_target_feature), &["ptx76"]),
576    ("ptx78", Unstable(sym::nvptx_target_feature), &["ptx77"]),
577    ("ptx80", Unstable(sym::nvptx_target_feature), &["ptx78"]),
578    ("ptx81", Unstable(sym::nvptx_target_feature), &["ptx80"]),
579    ("ptx82", Unstable(sym::nvptx_target_feature), &["ptx81"]),
580    ("ptx83", Unstable(sym::nvptx_target_feature), &["ptx82"]),
581    ("ptx84", Unstable(sym::nvptx_target_feature), &["ptx83"]),
582    ("ptx85", Unstable(sym::nvptx_target_feature), &["ptx84"]),
583    ("ptx86", Unstable(sym::nvptx_target_feature), &["ptx85"]),
584    ("ptx87", Unstable(sym::nvptx_target_feature), &["ptx86"]),
585    // tidy-alphabetical-end
586];
587
588static RISCV_FEATURES: &[(&str, Stability, ImpliedFeatures)] = &[
589    // tidy-alphabetical-start
590    ("a", Stable, &["zaamo", "zalrsc"]),
591    ("b", Stable, &["zba", "zbb", "zbs"]),
592    ("c", Stable, &["zca"]),
593    ("d", Unstable(sym::riscv_target_feature), &["f"]),
594    ("e", Unstable(sym::riscv_target_feature), &[]),
595    ("f", Unstable(sym::riscv_target_feature), &["zicsr"]),
596    (
597        "forced-atomics",
598        Stability::Forbidden { reason: "unsound because it changes the ABI of atomic operations" },
599        &[],
600    ),
601    ("m", Stable, &[]),
602    ("relax", Unstable(sym::riscv_target_feature), &[]),
603    (
604        "rva23u64",
605        Unstable(sym::riscv_target_feature),
606        &[
607            "m",
608            "a",
609            "f",
610            "d",
611            "c",
612            "b",
613            "v",
614            "zicsr",
615            "zicntr",
616            "zihpm",
617            "ziccif",
618            "ziccrse",
619            "ziccamoa",
620            "zicclsm",
621            "zic64b",
622            "za64rs",
623            "zihintpause",
624            "zba",
625            "zbb",
626            "zbs",
627            "zicbom",
628            "zicbop",
629            "zicboz",
630            "zfhmin",
631            "zkt",
632            "zvfhmin",
633            "zvbb",
634            "zvkt",
635            "zihintntl",
636            "zicond",
637            "zimop",
638            "zcmop",
639            "zcb",
640            "zfa",
641            "zawrs",
642            "supm",
643        ],
644    ),
645    ("supm", Unstable(sym::riscv_target_feature), &[]),
646    ("unaligned-scalar-mem", Unstable(sym::riscv_target_feature), &[]),
647    ("unaligned-vector-mem", Unstable(sym::riscv_target_feature), &[]),
648    ("v", Unstable(sym::riscv_target_feature), &["zvl128b", "zve64d"]),
649    ("za64rs", Stable, &["za128rs"]), // Za64rs ⊃ Za128rs
650    ("za128rs", Stable, &[]),
651    ("zaamo", Stable, &[]),
652    ("zabha", Stable, &["zaamo"]),
653    ("zacas", Stable, &["zaamo"]),
654    ("zalrsc", Stable, &[]),
655    ("zama16b", Stable, &[]),
656    ("zawrs", Stable, &[]),
657    ("zba", Stable, &[]),
658    ("zbb", Stable, &[]),
659    ("zbc", Stable, &["zbkc"]), // Zbc ⊃ Zbkc
660    ("zbkb", Stable, &[]),
661    ("zbkc", Stable, &[]),
662    ("zbkx", Stable, &[]),
663    ("zbs", Stable, &[]),
664    ("zca", Stable, &[]),
665    ("zcb", Stable, &["zca"]),
666    ("zcmop", Stable, &["zca"]),
667    ("zdinx", Unstable(sym::riscv_target_feature), &["zfinx"]),
668    ("zfa", Unstable(sym::riscv_target_feature), &["f"]),
669    ("zfbfmin", Unstable(sym::riscv_target_feature), &["f"]), // and a subset of Zfhmin
670    ("zfh", Unstable(sym::riscv_target_feature), &["zfhmin"]),
671    ("zfhmin", Unstable(sym::riscv_target_feature), &["f"]),
672    ("zfinx", Unstable(sym::riscv_target_feature), &["zicsr"]),
673    ("zhinx", Unstable(sym::riscv_target_feature), &["zhinxmin"]),
674    ("zhinxmin", Unstable(sym::riscv_target_feature), &["zfinx"]),
675    ("zic64b", Stable, &[]),
676    ("zicbom", Stable, &[]),
677    ("zicbop", Stable, &[]),
678    ("zicboz", Stable, &[]),
679    ("ziccamoa", Stable, &[]),
680    ("ziccif", Stable, &[]),
681    ("zicclsm", Stable, &[]),
682    ("ziccrse", Stable, &[]),
683    ("zicntr", Stable, &["zicsr"]),
684    ("zicond", Stable, &[]),
685    ("zicsr", Stable, &[]),
686    ("zifencei", Stable, &[]),
687    ("zihintntl", Stable, &[]),
688    ("zihintpause", Stable, &[]),
689    ("zihpm", Stable, &["zicsr"]),
690    ("zimop", Stable, &[]),
691    ("zk", Stable, &["zkn", "zkr", "zkt"]),
692    ("zkn", Stable, &["zbkb", "zbkc", "zbkx", "zkne", "zknd", "zknh"]),
693    ("zknd", Stable, &["zkne_or_zknd"]),
694    ("zkne", Stable, &["zkne_or_zknd"]),
695    ("zkne_or_zknd", Unstable(sym::riscv_target_feature), &[]), // Not an extension
696    ("zknh", Stable, &[]),
697    ("zkr", Stable, &[]),
698    ("zks", Stable, &["zbkb", "zbkc", "zbkx", "zksed", "zksh"]),
699    ("zksed", Stable, &[]),
700    ("zksh", Stable, &[]),
701    ("zkt", Stable, &[]),
702    ("ztso", Stable, &[]),
703    ("zvbb", Unstable(sym::riscv_target_feature), &["zvkb"]), // Zvbb ⊃ Zvkb
704    ("zvbc", Unstable(sym::riscv_target_feature), &["zve64x"]),
705    ("zve32f", Unstable(sym::riscv_target_feature), &["zve32x", "f"]),
706    ("zve32x", Unstable(sym::riscv_target_feature), &["zvl32b", "zicsr"]),
707    ("zve64d", Unstable(sym::riscv_target_feature), &["zve64f", "d"]),
708    ("zve64f", Unstable(sym::riscv_target_feature), &["zve32f", "zve64x"]),
709    ("zve64x", Unstable(sym::riscv_target_feature), &["zve32x", "zvl64b"]),
710    ("zvfbfmin", Unstable(sym::riscv_target_feature), &["zve32f"]),
711    ("zvfbfwma", Unstable(sym::riscv_target_feature), &["zfbfmin", "zvfbfmin"]),
712    ("zvfh", Unstable(sym::riscv_target_feature), &["zvfhmin", "zve32f", "zfhmin"]), // Zvfh ⊃ Zvfhmin
713    ("zvfhmin", Unstable(sym::riscv_target_feature), &["zve32f"]),
714    ("zvkb", Unstable(sym::riscv_target_feature), &["zve32x"]),
715    ("zvkg", Unstable(sym::riscv_target_feature), &["zve32x"]),
716    ("zvkn", Unstable(sym::riscv_target_feature), &["zvkned", "zvknhb", "zvkb", "zvkt"]),
717    ("zvknc", Unstable(sym::riscv_target_feature), &["zvkn", "zvbc"]),
718    ("zvkned", Unstable(sym::riscv_target_feature), &["zve32x"]),
719    ("zvkng", Unstable(sym::riscv_target_feature), &["zvkn", "zvkg"]),
720    ("zvknha", Unstable(sym::riscv_target_feature), &["zve32x"]),
721    ("zvknhb", Unstable(sym::riscv_target_feature), &["zvknha", "zve64x"]), // Zvknhb ⊃ Zvknha
722    ("zvks", Unstable(sym::riscv_target_feature), &["zvksed", "zvksh", "zvkb", "zvkt"]),
723    ("zvksc", Unstable(sym::riscv_target_feature), &["zvks", "zvbc"]),
724    ("zvksed", Unstable(sym::riscv_target_feature), &["zve32x"]),
725    ("zvksg", Unstable(sym::riscv_target_feature), &["zvks", "zvkg"]),
726    ("zvksh", Unstable(sym::riscv_target_feature), &["zve32x"]),
727    ("zvkt", Unstable(sym::riscv_target_feature), &[]),
728    ("zvl32b", Unstable(sym::riscv_target_feature), &[]),
729    ("zvl64b", Unstable(sym::riscv_target_feature), &["zvl32b"]),
730    ("zvl128b", Unstable(sym::riscv_target_feature), &["zvl64b"]),
731    ("zvl256b", Unstable(sym::riscv_target_feature), &["zvl128b"]),
732    ("zvl512b", Unstable(sym::riscv_target_feature), &["zvl256b"]),
733    ("zvl1024b", Unstable(sym::riscv_target_feature), &["zvl512b"]),
734    ("zvl2048b", Unstable(sym::riscv_target_feature), &["zvl1024b"]),
735    ("zvl4096b", Unstable(sym::riscv_target_feature), &["zvl2048b"]),
736    ("zvl8192b", Unstable(sym::riscv_target_feature), &["zvl4096b"]),
737    ("zvl16384b", Unstable(sym::riscv_target_feature), &["zvl8192b"]),
738    ("zvl32768b", Unstable(sym::riscv_target_feature), &["zvl16384b"]),
739    ("zvl65536b", Unstable(sym::riscv_target_feature), &["zvl32768b"]),
740    // tidy-alphabetical-end
741];
742
743static WASM_FEATURES: &[(&str, Stability, ImpliedFeatures)] = &[
744    // tidy-alphabetical-start
745    ("atomics", Unstable(sym::wasm_target_feature), &[]),
746    ("bulk-memory", Stable, &[]),
747    ("exception-handling", Unstable(sym::wasm_target_feature), &[]),
748    ("extended-const", Stable, &[]),
749    ("gc", Unstable(sym::wasm_target_feature), &["reference-types"]),
750    ("multivalue", Stable, &[]),
751    ("mutable-globals", Stable, &[]),
752    ("nontrapping-fptoint", Stable, &[]),
753    ("reference-types", Stable, &[]),
754    ("relaxed-simd", Stable, &["simd128"]),
755    ("sign-ext", Stable, &[]),
756    ("simd128", Stable, &[]),
757    ("tail-call", Stable, &[]),
758    ("wide-arithmetic", Unstable(sym::wasm_target_feature), &[]),
759    // tidy-alphabetical-end
760];
761
762const BPF_FEATURES: &[(&str, Stability, ImpliedFeatures)] =
763    &[("alu32", Unstable(sym::bpf_target_feature), &[])];
764
765static CSKY_FEATURES: &[(&str, Stability, ImpliedFeatures)] = &[
766    // tidy-alphabetical-start
767    ("2e3", Unstable(sym::csky_target_feature), &["e2"]),
768    ("3e3r1", Unstable(sym::csky_target_feature), &[]),
769    ("3e3r2", Unstable(sym::csky_target_feature), &["3e3r1", "doloop"]),
770    ("3e3r3", Unstable(sym::csky_target_feature), &["doloop"]),
771    ("3e7", Unstable(sym::csky_target_feature), &["2e3"]),
772    ("7e10", Unstable(sym::csky_target_feature), &["3e7"]),
773    ("10e60", Unstable(sym::csky_target_feature), &["7e10"]),
774    ("cache", Unstable(sym::csky_target_feature), &[]),
775    ("doloop", Unstable(sym::csky_target_feature), &[]),
776    ("dsp1e2", Unstable(sym::csky_target_feature), &[]),
777    ("dspe60", Unstable(sym::csky_target_feature), &[]),
778    ("e1", Unstable(sym::csky_target_feature), &["elrw"]),
779    ("e2", Unstable(sym::csky_target_feature), &["e2"]),
780    ("edsp", Unstable(sym::csky_target_feature), &[]),
781    ("elrw", Unstable(sym::csky_target_feature), &[]),
782    ("float1e2", Unstable(sym::csky_target_feature), &[]),
783    ("float1e3", Unstable(sym::csky_target_feature), &[]),
784    ("float3e4", Unstable(sym::csky_target_feature), &[]),
785    ("float7e60", Unstable(sym::csky_target_feature), &[]),
786    ("floate1", Unstable(sym::csky_target_feature), &[]),
787    ("hard-tp", Unstable(sym::csky_target_feature), &[]),
788    ("high-registers", Unstable(sym::csky_target_feature), &[]),
789    ("hwdiv", Unstable(sym::csky_target_feature), &[]),
790    ("mp", Unstable(sym::csky_target_feature), &["2e3"]),
791    ("mp1e2", Unstable(sym::csky_target_feature), &["3e7"]),
792    ("nvic", Unstable(sym::csky_target_feature), &[]),
793    ("trust", Unstable(sym::csky_target_feature), &[]),
794    ("vdsp2e60f", Unstable(sym::csky_target_feature), &[]),
795    ("vdspv1", Unstable(sym::csky_target_feature), &[]),
796    ("vdspv2", Unstable(sym::csky_target_feature), &[]),
797    // tidy-alphabetical-end
798    //fpu
799    // tidy-alphabetical-start
800    ("fdivdu", Unstable(sym::csky_target_feature), &[]),
801    ("fpuv2_df", Unstable(sym::csky_target_feature), &[]),
802    ("fpuv2_sf", Unstable(sym::csky_target_feature), &[]),
803    ("fpuv3_df", Unstable(sym::csky_target_feature), &[]),
804    ("fpuv3_hf", Unstable(sym::csky_target_feature), &[]),
805    ("fpuv3_hi", Unstable(sym::csky_target_feature), &[]),
806    ("fpuv3_sf", Unstable(sym::csky_target_feature), &[]),
807    ("hard-float", Unstable(sym::csky_target_feature), &[]),
808    ("hard-float-abi", Unstable(sym::csky_target_feature), &[]),
809    // tidy-alphabetical-end
810];
811
812static LOONGARCH_FEATURES: &[(&str, Stability, ImpliedFeatures)] = &[
813    // tidy-alphabetical-start
814    ("32s", Unstable(sym::loongarch_target_feature), &[]),
815    ("d", Stable, &["f"]),
816    ("div32", Unstable(sym::loongarch_target_feature), &[]),
817    ("f", Stable, &[]),
818    ("frecipe", Stable, &[]),
819    ("lam-bh", Unstable(sym::loongarch_target_feature), &[]),
820    ("lamcas", Unstable(sym::loongarch_target_feature), &[]),
821    ("lasx", Stable, &["lsx"]),
822    ("lbt", Stable, &[]),
823    ("ld-seq-sa", Unstable(sym::loongarch_target_feature), &[]),
824    ("lsx", Stable, &["d"]),
825    ("lvz", Stable, &[]),
826    ("relax", Unstable(sym::loongarch_target_feature), &[]),
827    ("scq", Unstable(sym::loongarch_target_feature), &[]),
828    ("ual", Unstable(sym::loongarch_target_feature), &[]),
829    // tidy-alphabetical-end
830];
831
832#[rustfmt::skip]
833const IBMZ_FEATURES: &[(&str, Stability, ImpliedFeatures)] = &[
834    // tidy-alphabetical-start
835    // For "backchain", https://github.com/rust-lang/rust/issues/142412 is a stabilization blocker
836    ("backchain", Unstable(sym::s390x_target_feature), &[]),
837    ("concurrent-functions", Unstable(sym::s390x_target_feature), &[]),
838    ("deflate-conversion", Unstable(sym::s390x_target_feature), &[]),
839    ("enhanced-sort", Unstable(sym::s390x_target_feature), &[]),
840    ("guarded-storage", Unstable(sym::s390x_target_feature), &[]),
841    ("high-word", Unstable(sym::s390x_target_feature), &[]),
842    // LLVM does not define message-security-assist-extension versions 1, 2, 6, 10 and 11.
843    ("message-security-assist-extension3", Unstable(sym::s390x_target_feature), &[]),
844    ("message-security-assist-extension4", Unstable(sym::s390x_target_feature), &[]),
845    ("message-security-assist-extension5", Unstable(sym::s390x_target_feature), &[]),
846    ("message-security-assist-extension8", Unstable(sym::s390x_target_feature), &["message-security-assist-extension3"]),
847    ("message-security-assist-extension9", Unstable(sym::s390x_target_feature), &["message-security-assist-extension3", "message-security-assist-extension4"]),
848    ("message-security-assist-extension12", Unstable(sym::s390x_target_feature), &[]),
849    ("miscellaneous-extensions-2", Stable, &[]),
850    ("miscellaneous-extensions-3", Stable, &[]),
851    ("miscellaneous-extensions-4", Stable, &[]),
852    ("nnp-assist", Stable, &["vector"]),
853    ("soft-float", Forbidden { reason: "currently unsupported ABI-configuration feature" }, &[]),
854    ("transactional-execution", Unstable(sym::s390x_target_feature), &[]),
855    ("vector", Stable, &[]),
856    ("vector-enhancements-1", Stable, &["vector"]),
857    ("vector-enhancements-2", Stable, &["vector-enhancements-1"]),
858    ("vector-enhancements-3", Stable, &["vector-enhancements-2"]),
859    ("vector-packed-decimal", Stable, &["vector"]),
860    ("vector-packed-decimal-enhancement", Stable, &["vector-packed-decimal"]),
861    ("vector-packed-decimal-enhancement-2", Stable, &["vector-packed-decimal-enhancement"]),
862    ("vector-packed-decimal-enhancement-3", Stable, &["vector-packed-decimal-enhancement-2"]),
863    // tidy-alphabetical-end
864];
865
866const SPARC_FEATURES: &[(&str, Stability, ImpliedFeatures)] = &[
867    // tidy-alphabetical-start
868    ("leoncasa", Unstable(sym::sparc_target_feature), &[]),
869    ("v8plus", Unstable(sym::sparc_target_feature), &[]),
870    ("v9", Unstable(sym::sparc_target_feature), &[]),
871    // tidy-alphabetical-end
872];
873
874static M68K_FEATURES: &[(&str, Stability, ImpliedFeatures)] = &[
875    // tidy-alphabetical-start
876    ("isa-68000", Unstable(sym::m68k_target_feature), &[]),
877    ("isa-68010", Unstable(sym::m68k_target_feature), &["isa-68000"]),
878    ("isa-68020", Unstable(sym::m68k_target_feature), &["isa-68010"]),
879    ("isa-68030", Unstable(sym::m68k_target_feature), &["isa-68020"]),
880    ("isa-68040", Unstable(sym::m68k_target_feature), &["isa-68030", "isa-68882"]),
881    ("isa-68060", Unstable(sym::m68k_target_feature), &["isa-68040"]),
882    // FPU
883    ("isa-68881", Unstable(sym::m68k_target_feature), &[]),
884    ("isa-68882", Unstable(sym::m68k_target_feature), &["isa-68881"]),
885    // tidy-alphabetical-end
886];
887
888/// When rustdoc is running, provide a list of all known features so that all their respective
889/// primitives may be documented.
890///
891/// IMPORTANT: If you're adding another feature list above, make sure to add it to this iterator!
892pub fn all_rust_features() -> impl Iterator<Item = (&'static str, Stability)> {
893    std::iter::empty()
894        .chain(ARM_FEATURES.iter())
895        .chain(AARCH64_FEATURES.iter())
896        .chain(X86_FEATURES.iter())
897        .chain(HEXAGON_FEATURES.iter())
898        .chain(POWERPC_FEATURES.iter())
899        .chain(MIPS_FEATURES.iter())
900        .chain(NVPTX_FEATURES.iter())
901        .chain(RISCV_FEATURES.iter())
902        .chain(WASM_FEATURES.iter())
903        .chain(BPF_FEATURES.iter())
904        .chain(CSKY_FEATURES)
905        .chain(LOONGARCH_FEATURES)
906        .chain(IBMZ_FEATURES)
907        .chain(SPARC_FEATURES)
908        .chain(M68K_FEATURES)
909        .cloned()
910        .map(|(f, s, _)| (f, s))
911}
912
913// These arrays represent the least-constraining feature that is required for vector types up to a
914// certain size to have their "proper" ABI on each architecture.
915// Note that they must be kept sorted by vector size.
916const X86_FEATURES_FOR_CORRECT_FIXED_LENGTH_VECTOR_ABI: &'static [(u64, &'static str)] =
917    &[(128, "sse"), (256, "avx"), (512, "avx512f")]; // FIXME: might need changes for AVX10.
918const AARCH64_FEATURES_FOR_CORRECT_FIXED_LENGTH_VECTOR_ABI: &'static [(u64, &'static str)] =
919    &[(128, "neon")];
920
921// We might want to add "helium" too.
922const ARM_FEATURES_FOR_CORRECT_FIXED_LENGTH_VECTOR_ABI: &'static [(u64, &'static str)] =
923    &[(128, "neon")];
924
925const AMDGPU_FEATURES_FOR_CORRECT_FIXED_LENGTH_VECTOR_ABI: &'static [(u64, &'static str)] =
926    &[(1024, "")];
927const POWERPC_FEATURES_FOR_CORRECT_FIXED_LENGTH_VECTOR_ABI: &'static [(u64, &'static str)] =
928    &[(128, "altivec")];
929const WASM_FEATURES_FOR_CORRECT_FIXED_LENGTH_VECTOR_ABI: &'static [(u64, &'static str)] =
930    &[(128, "simd128")];
931const S390X_FEATURES_FOR_CORRECT_FIXED_LENGTH_VECTOR_ABI: &'static [(u64, &'static str)] =
932    &[(128, "vector")];
933const RISCV_FEATURES_FOR_CORRECT_FIXED_LENGTH_VECTOR_ABI: &'static [(u64, &'static str)] = &[
934    (32, "zvl32b"),
935    (64, "zvl64b"),
936    (128, "zvl128b"),
937    (256, "zvl256b"),
938    (512, "zvl512b"),
939    (1024, "zvl1024b"),
940    (2048, "zvl2048b"),
941    (4096, "zvl4096b"),
942    (8192, "zvl8192b"),
943    (16384, "zvl16384b"),
944    (32768, "zvl32768b"),
945    (65536, "zvl65536b"),
946];
947// Always error on SPARC, as the necessary target features cannot be enabled in Rust at the moment.
948const SPARC_FEATURES_FOR_CORRECT_FIXED_LENGTH_VECTOR_ABI: &'static [(u64, &'static str)] =
949    &[/*(64, "vis")*/];
950
951const HEXAGON_FEATURES_FOR_CORRECT_FIXED_LENGTH_VECTOR_ABI: &'static [(u64, &'static str)] =
952    &[/*(512, "hvx-length64b"),*/ (1024, "hvx-length128b")];
953const MIPS_FEATURES_FOR_CORRECT_FIXED_LENGTH_VECTOR_ABI: &'static [(u64, &'static str)] =
954    &[(128, "msa")];
955const CSKY_FEATURES_FOR_CORRECT_FIXED_LENGTH_VECTOR_ABI: &'static [(u64, &'static str)] =
956    &[(128, "vdspv1")];
957const LOONGARCH_FEATURES_FOR_CORRECT_FIXED_LENGTH_VECTOR_ABI: &'static [(u64, &'static str)] =
958    &[(128, "lsx"), (256, "lasx")];
959
960#[derive(#[automatically_derived]
impl ::core::marker::Copy for FeatureConstraints { }Copy, #[automatically_derived]
impl ::core::clone::Clone for FeatureConstraints {
    #[inline]
    fn clone(&self) -> FeatureConstraints {
        let _: ::core::clone::AssertParamIsClone<&'static [&'static str]>;
        let _: ::core::clone::AssertParamIsClone<&'static [&'static str]>;
        *self
    }
}Clone, #[automatically_derived]
impl ::core::fmt::Debug for FeatureConstraints {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::debug_struct_field2_finish(f,
            "FeatureConstraints", "required", &self.required, "incompatible",
            &&self.incompatible)
    }
}Debug)]
961pub struct FeatureConstraints {
962    /// Features that must be enabled.
963    pub required: &'static [&'static str],
964    /// Features that must be disabled.
965    pub incompatible: &'static [&'static str],
966}
967
968impl Target {
969    pub fn rust_target_features(&self) -> &'static [(&'static str, Stability, ImpliedFeatures)] {
970        match &self.arch {
971            Arch::Arm => ARM_FEATURES,
972            Arch::AArch64 | Arch::Arm64EC => AARCH64_FEATURES,
973            Arch::X86 | Arch::X86_64 => X86_FEATURES,
974            Arch::Hexagon => HEXAGON_FEATURES,
975            Arch::Mips | Arch::Mips32r6 | Arch::Mips64 | Arch::Mips64r6 => MIPS_FEATURES,
976            Arch::Nvptx64 => NVPTX_FEATURES,
977            Arch::PowerPC | Arch::PowerPC64 => POWERPC_FEATURES,
978            Arch::RiscV32 | Arch::RiscV64 => RISCV_FEATURES,
979            Arch::Wasm32 | Arch::Wasm64 => WASM_FEATURES,
980            Arch::Bpf => BPF_FEATURES,
981            Arch::CSky => CSKY_FEATURES,
982            Arch::LoongArch32 | Arch::LoongArch64 => LOONGARCH_FEATURES,
983            Arch::S390x => IBMZ_FEATURES,
984            Arch::Sparc | Arch::Sparc64 => SPARC_FEATURES,
985            Arch::M68k => M68K_FEATURES,
986            Arch::AmdGpu
987            | Arch::Avr
988            | Arch::Msp430
989            | Arch::SpirV
990            | Arch::Xtensa
991            | Arch::Other(_) => &[],
992        }
993    }
994
995    pub fn features_for_correct_fixed_length_vector_abi(&self) -> &'static [(u64, &'static str)] {
996        match &self.arch {
997            Arch::X86 | Arch::X86_64 => X86_FEATURES_FOR_CORRECT_FIXED_LENGTH_VECTOR_ABI,
998            Arch::AArch64 | Arch::Arm64EC => AARCH64_FEATURES_FOR_CORRECT_FIXED_LENGTH_VECTOR_ABI,
999            Arch::Arm => ARM_FEATURES_FOR_CORRECT_FIXED_LENGTH_VECTOR_ABI,
1000            Arch::PowerPC | Arch::PowerPC64 => POWERPC_FEATURES_FOR_CORRECT_FIXED_LENGTH_VECTOR_ABI,
1001            Arch::LoongArch32 | Arch::LoongArch64 => {
1002                LOONGARCH_FEATURES_FOR_CORRECT_FIXED_LENGTH_VECTOR_ABI
1003            }
1004            Arch::RiscV32 | Arch::RiscV64 => RISCV_FEATURES_FOR_CORRECT_FIXED_LENGTH_VECTOR_ABI,
1005            Arch::Wasm32 | Arch::Wasm64 => WASM_FEATURES_FOR_CORRECT_FIXED_LENGTH_VECTOR_ABI,
1006            Arch::S390x => S390X_FEATURES_FOR_CORRECT_FIXED_LENGTH_VECTOR_ABI,
1007            Arch::Sparc | Arch::Sparc64 => SPARC_FEATURES_FOR_CORRECT_FIXED_LENGTH_VECTOR_ABI,
1008            Arch::Hexagon => HEXAGON_FEATURES_FOR_CORRECT_FIXED_LENGTH_VECTOR_ABI,
1009            Arch::Mips | Arch::Mips32r6 | Arch::Mips64 | Arch::Mips64r6 => {
1010                MIPS_FEATURES_FOR_CORRECT_FIXED_LENGTH_VECTOR_ABI
1011            }
1012            Arch::AmdGpu => AMDGPU_FEATURES_FOR_CORRECT_FIXED_LENGTH_VECTOR_ABI,
1013            Arch::Nvptx64 | Arch::Bpf | Arch::M68k => &[], // no vector ABI
1014            Arch::CSky => CSKY_FEATURES_FOR_CORRECT_FIXED_LENGTH_VECTOR_ABI,
1015            // FIXME: for some tier3 targets, we are overly cautious and always give warnings
1016            // when passing args in vector registers.
1017            Arch::Avr | Arch::Msp430 | Arch::SpirV | Arch::Xtensa | Arch::Other(_) => &[],
1018        }
1019    }
1020
1021    pub fn features_for_correct_scalable_vector_abi(&self) -> Option<&'static str> {
1022        match &self.arch {
1023            Arch::AArch64 | Arch::Arm64EC => Some("sve"),
1024            // Other targets have no scalable vectors or they are unimplemented.
1025            _ => None,
1026        }
1027    }
1028
1029    pub fn tied_target_features(&self) -> &'static [&'static [&'static str]] {
1030        match &self.arch {
1031            Arch::AArch64 | Arch::Arm64EC => AARCH64_TIED_FEATURES,
1032            _ => &[],
1033        }
1034    }
1035
1036    // Note: the returned set includes `base_feature`.
1037    pub fn implied_target_features<'a>(&self, base_feature: &'a str) -> FxHashSet<&'a str> {
1038        let implied_features =
1039            self.rust_target_features().iter().map(|(f, _, i)| (f, i)).collect::<FxHashMap<_, _>>();
1040
1041        // Implied target features have their own implied target features, so we traverse the
1042        // map until there are no more features to add.
1043        let mut features = FxHashSet::default();
1044        let mut new_features = <[_]>::into_vec(::alloc::boxed::box_new([base_feature]))vec![base_feature];
1045        while let Some(new_feature) = new_features.pop() {
1046            if features.insert(new_feature) {
1047                if let Some(implied_features) = implied_features.get(&new_feature) {
1048                    new_features.extend(implied_features.iter().copied())
1049                }
1050            }
1051        }
1052        features
1053    }
1054
1055    /// Returns two lists of features:
1056    /// the first list contains target features that must be enabled for ABI reasons,
1057    /// and the second list contains target feature that must be disabled for ABI reasons.
1058    ///
1059    /// These features are automatically appended to whatever the target spec sets as default
1060    /// features for the target.
1061    ///
1062    /// All features enabled/disabled via `-Ctarget-features` and `#[target_features]` are checked
1063    /// against this. We also check any implied features, based on the information above. If LLVM
1064    /// implicitly enables more implied features than we do, that could bypass this check!
1065    pub fn abi_required_features(&self) -> FeatureConstraints {
1066        const NOTHING: FeatureConstraints = FeatureConstraints { required: &[], incompatible: &[] };
1067        // Some architectures don't have a clean explicit ABI designation; instead, the ABI is
1068        // defined by target features. When that is the case, those target features must be
1069        // "forbidden" in the list above to ensure that there is a consistent answer to the
1070        // questions "which ABI is used".
1071        match &self.arch {
1072            Arch::X86 => {
1073                // We use our own ABI indicator here; LLVM does not have anything native.
1074                // Every case should require or forbid `soft-float`!
1075                match self.rustc_abi {
1076                    None => {
1077                        // Default hardfloat ABI.
1078                        // x87 must be enabled, soft-float must be disabled.
1079                        FeatureConstraints { required: &["x87"], incompatible: &["soft-float"] }
1080                    }
1081                    Some(RustcAbi::X86Sse2) => {
1082                        // Extended hardfloat ABI. x87 and SSE2 must be enabled, soft-float must be disabled.
1083                        FeatureConstraints {
1084                            required: &["x87", "sse2"],
1085                            incompatible: &["soft-float"],
1086                        }
1087                    }
1088                    Some(RustcAbi::X86Softfloat) => {
1089                        // Softfloat ABI, requires corresponding target feature. That feature trumps
1090                        // `x87` and all other FPU features so those do not matter.
1091                        // Note that this one requirement is the entire implementation of the ABI!
1092                        // LLVM handles the rest.
1093                        FeatureConstraints { required: &["soft-float"], incompatible: &[] }
1094                    }
1095                }
1096            }
1097            Arch::X86_64 => {
1098                // We use our own ABI indicator here; LLVM does not have anything native.
1099                // Every case should require or forbid `soft-float`!
1100                match self.rustc_abi {
1101                    None => {
1102                        // Default hardfloat ABI. On x86-64, this always includes SSE2.
1103                        FeatureConstraints {
1104                            required: &["x87", "sse2"],
1105                            incompatible: &["soft-float"],
1106                        }
1107                    }
1108                    Some(RustcAbi::X86Softfloat) => {
1109                        // Softfloat ABI, requires corresponding target feature. That feature trumps
1110                        // `x87` and all other FPU features so those do not matter.
1111                        // Note that this one requirement is the entire implementation of the ABI!
1112                        // LLVM handles the rest.
1113                        FeatureConstraints { required: &["soft-float"], incompatible: &[] }
1114                    }
1115                    Some(r) => {
    ::core::panicking::panic_fmt(format_args!("invalid Rust ABI for x86_64: {0:?}",
            r));
}panic!("invalid Rust ABI for x86_64: {r:?}"),
1116                }
1117            }
1118            Arch::Arm => {
1119                // On ARM, ABI handling is reasonably sane; we use `llvm_floatabi` to indicate
1120                // to LLVM which ABI we are going for.
1121                match self.llvm_floatabi.unwrap() {
1122                    FloatAbi::Soft => {
1123                        // Nothing special required, will use soft-float ABI throughout.
1124                        // We can even allow `-soft-float` here; in fact that is useful as it lets
1125                        // people use FPU instructions with a softfloat ABI (corresponds to
1126                        // `-mfloat-abi=softfp` in GCC/clang).
1127                        NOTHING
1128                    }
1129                    FloatAbi::Hard => {
1130                        // Must have `fpregs` and must not have `soft-float`.
1131                        FeatureConstraints { required: &["fpregs"], incompatible: &["soft-float"] }
1132                    }
1133                }
1134            }
1135            Arch::AArch64 | Arch::Arm64EC => {
1136                // Aarch64 has no sane ABI specifier, and LLVM doesn't even have a way to force
1137                // the use of soft-float, so all we can do here is some crude hacks.
1138                if self.abi == Abi::SoftFloat {
1139                    // LLVM will use float registers when `fp-armv8` is available, e.g. for
1140                    // calls to built-ins. The only way to ensure a consistent softfloat ABI
1141                    // on aarch64 is to never enable `fp-armv8`, so we enforce that.
1142                    // In Rust we tie `neon` and `fp-armv8` together, therefore `neon` is the
1143                    // feature we have to mark as incompatible.
1144                    FeatureConstraints { required: &[], incompatible: &["neon"] }
1145                } else {
1146                    // Everything else is assumed to use a hardfloat ABI. neon and fp-armv8 must be enabled.
1147                    // `FeatureConstraints` uses Rust feature names, hence only "neon" shows up.
1148                    FeatureConstraints { required: &["neon"], incompatible: &[] }
1149                }
1150            }
1151            Arch::RiscV32 | Arch::RiscV64 => {
1152                // RISC-V handles ABI in a very sane way, being fully explicit via `llvm_abiname`
1153                // about what the intended ABI is.
1154                match &*self.llvm_abiname {
1155                    "ilp32d" | "lp64d" => {
1156                        // Requires d (which implies f), incompatible with e and zfinx.
1157                        FeatureConstraints { required: &["d"], incompatible: &["e", "zfinx"] }
1158                    }
1159                    "ilp32f" | "lp64f" => {
1160                        // Requires f, incompatible with e and zfinx.
1161                        FeatureConstraints { required: &["f"], incompatible: &["e", "zfinx"] }
1162                    }
1163                    "ilp32" | "lp64" => {
1164                        // Requires nothing, incompatible with e.
1165                        FeatureConstraints { required: &[], incompatible: &["e"] }
1166                    }
1167                    "ilp32e" => {
1168                        // ilp32e is documented to be incompatible with features that need aligned
1169                        // load/stores > 32 bits, like `d`. (One could also just generate more
1170                        // complicated code to align the stack when needed, but the RISCV
1171                        // architecture manual just explicitly rules out this combination so we
1172                        // might as well.)
1173                        // Note that the `e` feature is not required: the ABI treats the extra
1174                        // registers as caller-save, so it is safe to use them only in some parts of
1175                        // a program while the rest doesn't know they even exist.
1176                        FeatureConstraints { required: &[], incompatible: &["d"] }
1177                    }
1178                    "lp64e" => {
1179                        // As above, `e` is not required.
1180                        NOTHING
1181                    }
1182                    _ => ::core::panicking::panic("internal error: entered unreachable code")unreachable!(),
1183                }
1184            }
1185            Arch::LoongArch32 | Arch::LoongArch64 => {
1186                // LoongArch handles ABI in a very sane way, being fully explicit via `llvm_abiname`
1187                // about what the intended ABI is.
1188                match &*self.llvm_abiname {
1189                    "ilp32d" | "lp64d" => {
1190                        // Requires d (which implies f), incompatible with nothing.
1191                        FeatureConstraints { required: &["d"], incompatible: &[] }
1192                    }
1193                    "ilp32f" | "lp64f" => {
1194                        // Requires f, incompatible with nothing.
1195                        FeatureConstraints { required: &["f"], incompatible: &[] }
1196                    }
1197                    "ilp32s" | "lp64s" => {
1198                        // The soft-float ABI does not require any features and is also not
1199                        // incompatible with any features. Rust targets explicitly specify the
1200                        // LLVM ABI names, which allows for enabling hard-float support even on
1201                        // soft-float targets, and ensures that the ABI behavior is as expected.
1202                        NOTHING
1203                    }
1204                    _ => ::core::panicking::panic("internal error: entered unreachable code")unreachable!(),
1205                }
1206            }
1207            Arch::S390x => {
1208                // We don't currently support a softfloat target on this architecture.
1209                // As usual, we have to reject swapping the `soft-float` target feature.
1210                // The "vector" target feature does not affect the ABI for floats
1211                // because the vector and float registers overlap.
1212                FeatureConstraints { required: &[], incompatible: &["soft-float"] }
1213            }
1214            _ => NOTHING,
1215        }
1216    }
1217}
rustc_target/target_features.rs

rustc_target/
target_features.rs
