From 0a8cfc2f8f1343fc99f18ca3cad8e2d11f60d7d2 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Thu, 26 Dec 2024 19:08:30 +0100
Subject: adjust GCC backend

---
 compiler/rustc_codegen_gcc/src/errors.rs   |   1 +
 compiler/rustc_codegen_gcc/src/gcc_util.rs | 196 +++++++++++++++++------------
 2 files changed, 116 insertions(+), 81 deletions(-)

(limited to 'compiler/rustc_codegen_gcc/src')

diff --git a/compiler/rustc_codegen_gcc/src/errors.rs b/compiler/rustc_codegen_gcc/src/errors.rs
index 56849cc8610..c896246866b 100644
--- a/compiler/rustc_codegen_gcc/src/errors.rs
+++ b/compiler/rustc_codegen_gcc/src/errors.rs
@@ -28,6 +28,7 @@ pub(crate) struct UnstableCTargetFeature<'a> {
 #[diag(codegen_gcc_forbidden_ctarget_feature)]
 pub(crate) struct ForbiddenCTargetFeature<'a> {
     pub feature: &'a str,
+    pub enabled: &'a str,
     pub reason: &'a str,
 }
 
diff --git a/compiler/rustc_codegen_gcc/src/gcc_util.rs b/compiler/rustc_codegen_gcc/src/gcc_util.rs
index 058a874501b..b0fd07827d6 100644
--- a/compiler/rustc_codegen_gcc/src/gcc_util.rs
+++ b/compiler/rustc_codegen_gcc/src/gcc_util.rs
@@ -1,9 +1,11 @@
+use std::iter::FromIterator;
+
 #[cfg(feature = "master")]
 use gccjit::Context;
 use rustc_codegen_ssa::codegen_attrs::check_tied_features;
 use rustc_codegen_ssa::errors::TargetFeatureDisableOrEnable;
-use rustc_data_structures::fx::FxHashMap;
-use rustc_middle::bug;
+use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_data_structures::unord::UnordSet;
 use rustc_session::Session;
 use rustc_target::target_features::RUSTC_SPECIFIC_FEATURES;
 use smallvec::{SmallVec, smallvec};
@@ -37,82 +39,128 @@ pub(crate) fn global_gcc_features(sess: &Session, diagnostics: bool) -> Vec<Stri
     let mut features = vec![];
 
     // Features implied by an implicit or explicit `--target`.
-    features.extend(
-        sess.target
-            .features
-            .split(',')
-            .filter(|v| !v.is_empty() && backend_feature_name(v).is_some())
-            .map(String::from),
-    );
+    features.extend(sess.target.features.split(',').filter(|v| !v.is_empty()).map(String::from));
 
     // -Ctarget-features
     let known_features = sess.target.rust_target_features();
     let mut featsmap = FxHashMap::default();
-    let feats = sess
-        .opts
-        .cg
-        .target_feature
-        .split(',')
-        .filter_map(|s| {
-            let enable_disable = match s.chars().next() {
-                None => return None,
-                Some(c @ ('+' | '-')) => c,
-                Some(_) => {
-                    if diagnostics {
-                        sess.dcx().emit_warn(UnknownCTargetFeaturePrefix { feature: s });
-                    }
-                    return None;
-                }
-            };
 
-            // Get the backend feature name, if any.
-            // This excludes rustc-specific features, that do not get passed down to GCC.
-            let feature = backend_feature_name(s)?;
-            // Warn against use of GCC specific feature names on the CLI.
+    // Ensure that all ABI-required features are enabled, and the ABI-forbidden ones
+    // are disabled.
+    let (abi_enable, abi_disable) = sess.target.abi_required_features();
+    let abi_enable_set = FxHashSet::from_iter(abi_enable.iter().copied());
+    let abi_disable_set = FxHashSet::from_iter(abi_disable.iter().copied());
+
+    // Compute implied features
+    let mut all_rust_features = vec![];
+    for feature in sess.opts.cg.target_feature.split(',') {
+        if let Some(feature) = feature.strip_prefix('+') {
+            all_rust_features.extend(
+                UnordSet::from(sess.target.implied_target_features(std::iter::once(feature)))
+                    .to_sorted_stable_ord()
+                    .iter()
+                    .map(|&&s| (true, s)),
+            )
+        } else if let Some(feature) = feature.strip_prefix('-') {
+            // FIXME: Why do we not remove implied features on "-" here?
+            // We do the equivalent above in `target_features_cfg`.
+            // See <https://github.com/rust-lang/rust/issues/134792>.
+            all_rust_features.push((false, feature));
+        } else if !feature.is_empty() {
             if diagnostics {
-                let feature_state = known_features.iter().find(|&&(v, _, _)| v == feature);
-                match feature_state {
-                    None => {
-                        let rust_feature =
-                            known_features.iter().find_map(|&(rust_feature, _, _)| {
-                                let gcc_features = to_gcc_features(sess, rust_feature);
-                                if gcc_features.contains(&feature)
-                                    && !gcc_features.contains(&rust_feature)
-                                {
-                                    Some(rust_feature)
-                                } else {
-                                    None
-                                }
-                            });
-                        let unknown_feature = if let Some(rust_feature) = rust_feature {
-                            UnknownCTargetFeature {
-                                feature,
-                                rust_feature: PossibleFeature::Some { rust_feature },
-                            }
-                        } else {
-                            UnknownCTargetFeature { feature, rust_feature: PossibleFeature::None }
-                        };
-                        sess.dcx().emit_warn(unknown_feature);
-                    }
-                    Some((_, stability, _)) => {
-                        if let Err(reason) =
-                            stability.toggle_allowed(&sess.target, enable_disable == '+')
+                sess.dcx().emit_warn(UnknownCTargetFeaturePrefix { feature });
+            }
+        }
+    }
+    // Remove features that are meant for rustc, not LLVM.
+    all_rust_features.retain(|(_, feature)| {
+        // Retain if it is not a rustc feature
+        !RUSTC_SPECIFIC_FEATURES.contains(feature)
+    });
+
+    // Check feature validity.
+    if diagnostics {
+        for &(enable, feature) in &all_rust_features {
+            let feature_state = known_features.iter().find(|&&(v, _, _)| v == feature);
+            match feature_state {
+                None => {
+                    let rust_feature = known_features.iter().find_map(|&(rust_feature, _, _)| {
+                        let gcc_features = to_gcc_features(sess, rust_feature);
+                        if gcc_features.contains(&feature) && !gcc_features.contains(&rust_feature)
                         {
-                            sess.dcx().emit_warn(ForbiddenCTargetFeature { feature, reason });
-                        } else if stability.requires_nightly().is_some() {
-                            // An unstable feature. Warn about using it. (It makes little sense
-                            // to hard-error here since we just warn about fully unknown
-                            // features above).
-                            sess.dcx().emit_warn(UnstableCTargetFeature { feature });
+                            Some(rust_feature)
+                        } else {
+                            None
                         }
+                    });
+                    let unknown_feature = if let Some(rust_feature) = rust_feature {
+                        UnknownCTargetFeature {
+                            feature,
+                            rust_feature: PossibleFeature::Some { rust_feature },
+                        }
+                    } else {
+                        UnknownCTargetFeature { feature, rust_feature: PossibleFeature::None }
+                    };
+                    sess.dcx().emit_warn(unknown_feature);
+                }
+                Some((_, stability, _)) => {
+                    if let Err(reason) = stability.toggle_allowed() {
+                        sess.dcx().emit_warn(ForbiddenCTargetFeature {
+                            feature,
+                            enabled: if enable { "enabled" } else { "disabled" },
+                            reason,
+                        });
+                    } else if stability.requires_nightly().is_some() {
+                        // An unstable feature. Warn about using it. (It makes little sense
+                        // to hard-error here since we just warn about fully unknown
+                        // features above).
+                        sess.dcx().emit_warn(UnstableCTargetFeature { feature });
                     }
                 }
+            }
 
-                // FIXME(nagisa): figure out how to not allocate a full hashset here.
-                featsmap.insert(feature, enable_disable == '+');
+            // Ensure that the features we enable/disable are compatible with the ABI.
+            if enable {
+                if abi_disable_set.contains(feature) {
+                    sess.dcx().emit_warn(ForbiddenCTargetFeature {
+                        feature,
+                        enabled: "enabled",
+                        reason: "this feature is incompatible with the target ABI",
+                    });
+                }
+            } else {
+                if abi_enable_set.contains(feature) {
+                    sess.dcx().emit_warn(ForbiddenCTargetFeature {
+                        feature,
+                        enabled: "disabled",
+                        reason: "this feature is required by the target ABI",
+                    });
+                }
             }
 
-            // ... otherwise though we run through `to_gcc_features` when
+            // FIXME(nagisa): figure out how to not allocate a full hashset here.
+            featsmap.insert(feature, enable);
+        }
+    }
+
+    // To be sure the ABI-relevant features are all in the right state, we explicitly
+    // (un)set them here. This means if the target spec sets those features wrong,
+    // we will silently correct them rather than silently producing wrong code.
+    // (The target sanity check tries to catch this, but we can't know which features are
+    // enabled in GCC by default so we can't be fully sure about that check.)
+    for feature in abi_enable {
+        all_rust_features.push((true, feature));
+    }
+    for feature in abi_disable {
+        all_rust_features.push((false, feature));
+    }
+
+    // Translate this into GCC features.
+    let feats = all_rust_features
+        .iter()
+        .filter_map(|&(enable, feature)| {
+            let enable_disable = if enable { '+' } else { '-' };
+            // We run through `to_gcc_features` when
             // passing requests down to GCC. This means that all in-language
             // features also work on the command line instead of having two
             // different names when the GCC name and the Rust name differ.
@@ -146,26 +194,12 @@ pub(crate) fn global_gcc_features(sess: &Session, diagnostics: bool) -> Vec<Stri
     features
 }
 
-/// Returns a feature name for the given `+feature` or `-feature` string.
-///
-/// Only allows features that are backend specific (i.e. not [`RUSTC_SPECIFIC_FEATURES`].)
-fn backend_feature_name(s: &str) -> Option<&str> {
-    // features must start with a `+` or `-`.
-    let feature = s.strip_prefix(&['+', '-'][..]).unwrap_or_else(|| {
-        bug!("target feature `{}` must begin with a `+` or `-`", s);
-    });
-    // Rustc-specific feature requests like `+crt-static` or `-crt-static`
-    // are not passed down to GCC.
-    if RUSTC_SPECIFIC_FEATURES.contains(&feature) {
-        return None;
-    }
-    Some(feature)
-}
-
 // To find a list of GCC's names, check https://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html
 pub fn to_gcc_features<'a>(sess: &Session, s: &'a str) -> SmallVec<[&'a str; 2]> {
     let arch = if sess.target.arch == "x86_64" { "x86" } else { &*sess.target.arch };
     match (arch, s) {
+        // FIXME: seems like x87 does not exist?
+        ("x86", "x87") => smallvec![],
         ("x86", "sse4.2") => smallvec!["sse4.2", "crc32"],
         ("x86", "pclmulqdq") => smallvec!["pclmul"],
         ("x86", "rdrand") => smallvec!["rdrnd"],
-- 
cgit 1.4.1-3-g733a5


From eb527424a5f0206a464d0968387d85636ac9d305 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Thu, 26 Dec 2024 19:47:41 +0100
Subject: x86-64 hardfloat actually requires sse2

---
 compiler/rustc_codegen_gcc/src/gcc_util.rs            | 18 ++++++++++++------
 compiler/rustc_codegen_llvm/src/llvm_util.rs          | 19 +++++++++++++------
 compiler/rustc_target/src/target_features.rs          | 11 ++++++++++-
 tests/codegen/target-feature-overrides.rs             |  4 ++--
 ...n-hardfloat-target-feature-flag-disable-implied.rs | 10 ++++++++++
 ...rdfloat-target-feature-flag-disable-implied.stderr |  7 +++++++
 6 files changed, 54 insertions(+), 15 deletions(-)
 create mode 100644 tests/ui/target-feature/forbidden-hardfloat-target-feature-flag-disable-implied.rs
 create mode 100644 tests/ui/target-feature/forbidden-hardfloat-target-feature-flag-disable-implied.stderr

(limited to 'compiler/rustc_codegen_gcc/src')

diff --git a/compiler/rustc_codegen_gcc/src/gcc_util.rs b/compiler/rustc_codegen_gcc/src/gcc_util.rs
index b0fd07827d6..3e579d75d86 100644
--- a/compiler/rustc_codegen_gcc/src/gcc_util.rs
+++ b/compiler/rustc_codegen_gcc/src/gcc_util.rs
@@ -129,12 +129,18 @@ pub(crate) fn global_gcc_features(sess: &Session, diagnostics: bool) -> Vec<Stri
                     });
                 }
             } else {
-                if abi_enable_set.contains(feature) {
-                    sess.dcx().emit_warn(ForbiddenCTargetFeature {
-                        feature,
-                        enabled: "disabled",
-                        reason: "this feature is required by the target ABI",
-                    });
+                // FIXME: we have to request implied features here since
+                // negative features do not handle implied features above.
+                #[allow(rustc::potential_query_instability)] // order does not matter
+                for &required in abi_enable_set.iter() {
+                    let implied = sess.target.implied_target_features(std::iter::once(required));
+                    if implied.contains(feature) {
+                        sess.dcx().emit_warn(ForbiddenCTargetFeature {
+                            feature,
+                            enabled: "disabled",
+                            reason: "this feature is required by the target ABI",
+                        });
+                    }
                 }
             }
 
diff --git a/compiler/rustc_codegen_llvm/src/llvm_util.rs b/compiler/rustc_codegen_llvm/src/llvm_util.rs
index d4b2260123b..7fe0624e166 100644
--- a/compiler/rustc_codegen_llvm/src/llvm_util.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm_util.rs
@@ -753,12 +753,19 @@ pub(crate) fn global_llvm_features(
                         });
                     }
                 } else {
-                    if abi_enable_set.contains(feature) {
-                        sess.dcx().emit_warn(ForbiddenCTargetFeature {
-                            feature,
-                            enabled: "disabled",
-                            reason: "this feature is required by the target ABI",
-                        });
+                    // FIXME: we have to request implied features here since
+                    // negative features do not handle implied features above.
+                    #[allow(rustc::potential_query_instability)] // order does not matter
+                    for &required in abi_enable_set.iter() {
+                        let implied =
+                            sess.target.implied_target_features(std::iter::once(required));
+                        if implied.contains(feature) {
+                            sess.dcx().emit_warn(ForbiddenCTargetFeature {
+                                feature,
+                                enabled: "disabled",
+                                reason: "this feature is required by the target ABI",
+                            });
+                        }
                     }
                 }
 
diff --git a/compiler/rustc_target/src/target_features.rs b/compiler/rustc_target/src/target_features.rs
index 31e2cabed62..75055144c8f 100644
--- a/compiler/rustc_target/src/target_features.rs
+++ b/compiler/rustc_target/src/target_features.rs
@@ -753,7 +753,7 @@ impl Target {
         // "forbidden" in the list above to ensure that there is a consistent answer to the
         // questions "which ABI is used".
         match &*self.arch {
-            "x86" | "x86_64" => {
+            "x86" => {
                 // We support 2 ABIs, hardfloat (default) and softfloat.
                 if self.has_feature("soft-float") {
                     NOTHING
@@ -762,6 +762,15 @@ impl Target {
                     (&["x87"], &[])
                 }
             }
+            "x86_64" => {
+                // We support 2 ABIs, hardfloat (default) and softfloat.
+                if self.has_feature("soft-float") {
+                    NOTHING
+                } else {
+                    // Hardfloat ABI. x87 and SSE2 must be enabled.
+                    (&["x87", "sse2"], &[])
+                }
+            }
             "arm" => {
                 // We support 2 ABIs, hardfloat (default) and softfloat.
                 if self.has_feature("soft-float") {
diff --git a/tests/codegen/target-feature-overrides.rs b/tests/codegen/target-feature-overrides.rs
index f38a1ae72de..c4f9a8898a1 100644
--- a/tests/codegen/target-feature-overrides.rs
+++ b/tests/codegen/target-feature-overrides.rs
@@ -40,7 +40,7 @@ pub unsafe fn banana() -> u32 {
 
 // CHECK: attributes [[APPLEATTRS]]
 // COMPAT-SAME: "target-features"="+avx,+avx2,{{.*}}"
-// INCOMPAT-SAME: "target-features"="-avx2,-avx,+avx,{{.*}}"
+// INCOMPAT-SAME: "target-features"="-avx2,-avx,+x87,+sse2,+avx,{{.*}}"
 // CHECK: attributes [[BANANAATTRS]]
 // COMPAT-SAME: "target-features"="+avx,+avx2,{{.*}}"
-// INCOMPAT-SAME: "target-features"="-avx2,-avx"
+// INCOMPAT-SAME: "target-features"="-avx2,-avx,+x87,+sse2"
diff --git a/tests/ui/target-feature/forbidden-hardfloat-target-feature-flag-disable-implied.rs b/tests/ui/target-feature/forbidden-hardfloat-target-feature-flag-disable-implied.rs
new file mode 100644
index 00000000000..3d09217327a
--- /dev/null
+++ b/tests/ui/target-feature/forbidden-hardfloat-target-feature-flag-disable-implied.rs
@@ -0,0 +1,10 @@
+//@ compile-flags: --target=x86_64-unknown-linux-gnu --crate-type=lib
+//@ needs-llvm-components: x86
+//@ compile-flags: -Ctarget-feature=-sse
+// For now this is just a warning.
+//@ build-pass
+#![feature(no_core, lang_items)]
+#![no_core]
+
+#[lang = "sized"]
+pub trait Sized {}
diff --git a/tests/ui/target-feature/forbidden-hardfloat-target-feature-flag-disable-implied.stderr b/tests/ui/target-feature/forbidden-hardfloat-target-feature-flag-disable-implied.stderr
new file mode 100644
index 00000000000..72b2d03fe20
--- /dev/null
+++ b/tests/ui/target-feature/forbidden-hardfloat-target-feature-flag-disable-implied.stderr
@@ -0,0 +1,7 @@
+warning: target feature `sse` cannot be disabled with `-Ctarget-feature`: this feature is required by the target ABI
+   |
+   = note: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #116344 <https://github.com/rust-lang/rust/issues/116344>
+
+warning: 1 warning emitted
+
-- 
cgit 1.4.1-3-g733a5


From 912b7291d0f8f477388282a04ccf085d1b3715b0 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Fri, 27 Dec 2024 22:19:55 +0100
Subject: add ABI target features *before* -Ctarget-features

---
 compiler/rustc_codegen_gcc/src/gcc_util.rs   | 12 ++++++------
 compiler/rustc_codegen_llvm/src/llvm_util.rs | 12 ++++++------
 compiler/rustc_target/src/target_features.rs |  3 +++
 tests/codegen/target-feature-overrides.rs    |  8 ++++----
 4 files changed, 19 insertions(+), 16 deletions(-)

(limited to 'compiler/rustc_codegen_gcc/src')

diff --git a/compiler/rustc_codegen_gcc/src/gcc_util.rs b/compiler/rustc_codegen_gcc/src/gcc_util.rs
index 3e579d75d86..e9dfb4e4cf4 100644
--- a/compiler/rustc_codegen_gcc/src/gcc_util.rs
+++ b/compiler/rustc_codegen_gcc/src/gcc_util.rs
@@ -154,12 +154,12 @@ pub(crate) fn global_gcc_features(sess: &Session, diagnostics: bool) -> Vec<Stri
     // we will silently correct them rather than silently producing wrong code.
     // (The target sanity check tries to catch this, but we can't know which features are
     // enabled in GCC by default so we can't be fully sure about that check.)
-    for feature in abi_enable {
-        all_rust_features.push((true, feature));
-    }
-    for feature in abi_disable {
-        all_rust_features.push((false, feature));
-    }
+    // We add these at the beginning of the list so that `-Ctarget-features` can
+    // still override it... that's unsound, but more compatible with past behavior.
+    all_rust_features.splice(
+        0..0,
+        abi_enable.iter().map(|&f| (true, f)).chain(abi_disable.iter().map(|&f| (false, f))),
+    );
 
     // Translate this into GCC features.
     let feats = all_rust_features
diff --git a/compiler/rustc_codegen_llvm/src/llvm_util.rs b/compiler/rustc_codegen_llvm/src/llvm_util.rs
index 7fe0624e166..6ec09b29649 100644
--- a/compiler/rustc_codegen_llvm/src/llvm_util.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm_util.rs
@@ -779,12 +779,12 @@ pub(crate) fn global_llvm_features(
         // we will silently correct them rather than silently producing wrong code.
         // (The target sanity check tries to catch this, but we can't know which features are
         // enabled in LLVM by default so we can't be fully sure about that check.)
-        for feature in abi_enable {
-            all_rust_features.push((true, feature));
-        }
-        for feature in abi_disable {
-            all_rust_features.push((false, feature));
-        }
+        // We add these at the beginning of the list so that `-Ctarget-features` can
+        // still override it... that's unsound, but more compatible with past behavior.
+        all_rust_features.splice(
+            0..0,
+            abi_enable.iter().map(|&f| (true, f)).chain(abi_disable.iter().map(|&f| (false, f))),
+        );
 
         // Translate this into LLVM features.
         let feats = all_rust_features
diff --git a/compiler/rustc_target/src/target_features.rs b/compiler/rustc_target/src/target_features.rs
index 75055144c8f..b5e30c4d5c9 100644
--- a/compiler/rustc_target/src/target_features.rs
+++ b/compiler/rustc_target/src/target_features.rs
@@ -743,6 +743,9 @@ impl Target {
     /// the first list contains target features that must be enabled for ABI reasons,
     /// and the second list contains target feature that must be disabled for ABI reasons.
     ///
+    /// These features are automatically appended to whatever the target spec sats as default
+    /// features for the target.
+    ///
     /// All features enabled/disabled via `-Ctarget-features` and `#[target_features]` are checked
     /// against this. We also check any implied features, based on the information above. If LLVM
     /// implicitly enables more implied features than we do, that could bypass this check!
diff --git a/tests/codegen/target-feature-overrides.rs b/tests/codegen/target-feature-overrides.rs
index c4f9a8898a1..e7f70a1e24a 100644
--- a/tests/codegen/target-feature-overrides.rs
+++ b/tests/codegen/target-feature-overrides.rs
@@ -39,8 +39,8 @@ pub unsafe fn banana() -> u32 {
 }
 
 // CHECK: attributes [[APPLEATTRS]]
-// COMPAT-SAME: "target-features"="+avx,+avx2,{{.*}}"
-// INCOMPAT-SAME: "target-features"="-avx2,-avx,+x87,+sse2,+avx,{{.*}}"
+// COMPAT-SAME: "target-features"="+x87,+sse2,+avx,+avx2,{{.*}}"
+// INCOMPAT-SAME: "target-features"="+x87,+sse2,-avx2,-avx,+avx,{{.*}}"
 // CHECK: attributes [[BANANAATTRS]]
-// COMPAT-SAME: "target-features"="+avx,+avx2,{{.*}}"
-// INCOMPAT-SAME: "target-features"="-avx2,-avx,+x87,+sse2"
+// COMPAT-SAME: "target-features"="+x87,+sse2,+avx,+avx2,{{.*}}"
+// INCOMPAT-SAME: "target-features"="+x87,+sse2,-avx2,-avx"
-- 
cgit 1.4.1-3-g733a5


From 2e64b5352be9ec8b2a7b956c2be108394b85f4b0 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sun, 5 Jan 2025 10:34:33 +0100
Subject: add dedicated type for ABI target feature constraints

---
 compiler/rustc_codegen_gcc/src/gcc_util.rs        | 19 ++++++++-------
 compiler/rustc_codegen_llvm/src/llvm_util.rs      | 17 ++++++++------
 compiler/rustc_codegen_ssa/src/target_features.rs |  4 ++--
 compiler/rustc_target/src/spec/mod.rs             |  8 +++----
 compiler/rustc_target/src/target_features.rs      | 28 +++++++++++++++--------
 5 files changed, 45 insertions(+), 31 deletions(-)

(limited to 'compiler/rustc_codegen_gcc/src')

diff --git a/compiler/rustc_codegen_gcc/src/gcc_util.rs b/compiler/rustc_codegen_gcc/src/gcc_util.rs
index e9dfb4e4cf4..1994a2a3c53 100644
--- a/compiler/rustc_codegen_gcc/src/gcc_util.rs
+++ b/compiler/rustc_codegen_gcc/src/gcc_util.rs
@@ -47,9 +47,9 @@ pub(crate) fn global_gcc_features(sess: &Session, diagnostics: bool) -> Vec<Stri
 
     // Ensure that all ABI-required features are enabled, and the ABI-forbidden ones
     // are disabled.
-    let (abi_enable, abi_disable) = sess.target.abi_required_features();
-    let abi_enable_set = FxHashSet::from_iter(abi_enable.iter().copied());
-    let abi_disable_set = FxHashSet::from_iter(abi_disable.iter().copied());
+    let abi_feature_constraints = sess.target.abi_required_features();
+    let abi_incompatible_set =
+        FxHashSet::from_iter(abi_feature_constraints.incompatible.iter().copied());
 
     // Compute implied features
     let mut all_rust_features = vec![];
@@ -72,7 +72,7 @@ pub(crate) fn global_gcc_features(sess: &Session, diagnostics: bool) -> Vec<Stri
             }
         }
     }
-    // Remove features that are meant for rustc, not LLVM.
+    // Remove features that are meant for rustc, not codegen.
     all_rust_features.retain(|(_, feature)| {
         // Retain if it is not a rustc feature
         !RUSTC_SPECIFIC_FEATURES.contains(feature)
@@ -121,7 +121,7 @@ pub(crate) fn global_gcc_features(sess: &Session, diagnostics: bool) -> Vec<Stri
 
             // Ensure that the features we enable/disable are compatible with the ABI.
             if enable {
-                if abi_disable_set.contains(feature) {
+                if abi_incompatible_set.contains(feature) {
                     sess.dcx().emit_warn(ForbiddenCTargetFeature {
                         feature,
                         enabled: "enabled",
@@ -131,8 +131,7 @@ pub(crate) fn global_gcc_features(sess: &Session, diagnostics: bool) -> Vec<Stri
             } else {
                 // FIXME: we have to request implied features here since
                 // negative features do not handle implied features above.
-                #[allow(rustc::potential_query_instability)] // order does not matter
-                for &required in abi_enable_set.iter() {
+                for &required in abi_feature_constraints.required.iter() {
                     let implied = sess.target.implied_target_features(std::iter::once(required));
                     if implied.contains(feature) {
                         sess.dcx().emit_warn(ForbiddenCTargetFeature {
@@ -158,7 +157,11 @@ pub(crate) fn global_gcc_features(sess: &Session, diagnostics: bool) -> Vec<Stri
     // still override it... that's unsound, but more compatible with past behavior.
     all_rust_features.splice(
         0..0,
-        abi_enable.iter().map(|&f| (true, f)).chain(abi_disable.iter().map(|&f| (false, f))),
+        abi_feature_constraints
+            .required
+            .iter()
+            .map(|&f| (true, f))
+            .chain(abi_feature_constraints.incompatible.iter().map(|&f| (false, f))),
     );
 
     // Translate this into GCC features.
diff --git a/compiler/rustc_codegen_llvm/src/llvm_util.rs b/compiler/rustc_codegen_llvm/src/llvm_util.rs
index 6ec09b29649..e18e91e569f 100644
--- a/compiler/rustc_codegen_llvm/src/llvm_util.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm_util.rs
@@ -669,9 +669,9 @@ pub(crate) fn global_llvm_features(
 
         // Ensure that all ABI-required features are enabled, and the ABI-forbidden ones
         // are disabled.
-        let (abi_enable, abi_disable) = sess.target.abi_required_features();
-        let abi_enable_set = FxHashSet::from_iter(abi_enable.iter().copied());
-        let abi_disable_set = FxHashSet::from_iter(abi_disable.iter().copied());
+        let abi_feature_constraints = sess.target.abi_required_features();
+        let abi_incompatible_set =
+            FxHashSet::from_iter(abi_feature_constraints.incompatible.iter().copied());
 
         // Compute implied features
         let mut all_rust_features = vec![];
@@ -745,7 +745,7 @@ pub(crate) fn global_llvm_features(
 
                 // Ensure that the features we enable/disable are compatible with the ABI.
                 if enable {
-                    if abi_disable_set.contains(feature) {
+                    if abi_incompatible_set.contains(feature) {
                         sess.dcx().emit_warn(ForbiddenCTargetFeature {
                             feature,
                             enabled: "enabled",
@@ -755,8 +755,7 @@ pub(crate) fn global_llvm_features(
                 } else {
                     // FIXME: we have to request implied features here since
                     // negative features do not handle implied features above.
-                    #[allow(rustc::potential_query_instability)] // order does not matter
-                    for &required in abi_enable_set.iter() {
+                    for &required in abi_feature_constraints.required.iter() {
                         let implied =
                             sess.target.implied_target_features(std::iter::once(required));
                         if implied.contains(feature) {
@@ -783,7 +782,11 @@ pub(crate) fn global_llvm_features(
         // still override it... that's unsound, but more compatible with past behavior.
         all_rust_features.splice(
             0..0,
-            abi_enable.iter().map(|&f| (true, f)).chain(abi_disable.iter().map(|&f| (false, f))),
+            abi_feature_constraints
+                .required
+                .iter()
+                .map(|&f| (true, f))
+                .chain(abi_feature_constraints.incompatible.iter().map(|&f| (false, f))),
         );
 
         // Translate this into LLVM features.
diff --git a/compiler/rustc_codegen_ssa/src/target_features.rs b/compiler/rustc_codegen_ssa/src/target_features.rs
index 61eeae630ed..d8b9bdb55da 100644
--- a/compiler/rustc_codegen_ssa/src/target_features.rs
+++ b/compiler/rustc_codegen_ssa/src/target_features.rs
@@ -32,7 +32,7 @@ pub(crate) fn from_target_feature_attr(
             .emit();
     };
     let rust_features = tcx.features();
-    let (_abi_enable, abi_disable) = tcx.sess.target.abi_required_features();
+    let abi_feature_constraints = tcx.sess.target.abi_required_features();
     for item in list {
         // Only `enable = ...` is accepted in the meta-item list.
         if !item.has_name(sym::enable) {
@@ -87,7 +87,7 @@ pub(crate) fn from_target_feature_attr(
                     // But ensure the ABI does not forbid enabling this.
                     // Here we do assume that LLVM doesn't add even more implied features
                     // we don't know about, at least no features that would have ABI effects!
-                    if abi_disable.contains(&name.as_str()) {
+                    if abi_feature_constraints.incompatible.contains(&name.as_str()) {
                         tcx.dcx().emit_err(errors::ForbiddenTargetFeatureAttr {
                             span: item.span(),
                             feature: name.as_str(),
diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs
index 28011f632b3..9d439b3d832 100644
--- a/compiler/rustc_target/src/spec/mod.rs
+++ b/compiler/rustc_target/src/spec/mod.rs
@@ -3242,8 +3242,8 @@ impl Target {
                 }
             }
             // Check that we don't mis-set any of the ABI-relevant features.
-            let (abi_enable, abi_disable) = self.abi_required_features();
-            for feat in abi_enable {
+            let abi_feature_constraints = self.abi_required_features();
+            for feat in abi_feature_constraints.required {
                 // The feature might be enabled by default so we can't *require* it to show up.
                 // But it must not be *disabled*.
                 if features_disabled.contains(feat) {
@@ -3252,8 +3252,8 @@ impl Target {
                     ));
                 }
             }
-            for feat in abi_disable {
-                // The feature might be disable by default so we can't *require* it to show up.
+            for feat in abi_feature_constraints.incompatible {
+                // The feature might be disabled by default so we can't *require* it to show up.
                 // But it must not be *enabled*.
                 if features_enabled.contains(feat) {
                     return Err(format!(
diff --git a/compiler/rustc_target/src/target_features.rs b/compiler/rustc_target/src/target_features.rs
index 142ac0ff3d3..f594d20f928 100644
--- a/compiler/rustc_target/src/target_features.rs
+++ b/compiler/rustc_target/src/target_features.rs
@@ -669,6 +669,14 @@ const CSKY_FEATURES_FOR_CORRECT_VECTOR_ABI: &'static [(u64, &'static str)] = &[(
 const LOONGARCH_FEATURES_FOR_CORRECT_VECTOR_ABI: &'static [(u64, &'static str)] =
     &[(128, "lsx"), (256, "lasx")];
 
+#[derive(Copy, Clone, Debug)]
+pub struct FeatureConstraints {
+    /// Features that must be enabled.
+    pub required: &'static [&'static str],
+    /// Features that must be disabled.
+    pub incompatible: &'static [&'static str],
+}
+
 impl Target {
     pub fn rust_target_features(&self) -> &'static [(&'static str, Stability, ImpliedFeatures)] {
         match &*self.arch {
@@ -749,8 +757,8 @@ impl Target {
     /// All features enabled/disabled via `-Ctarget-features` and `#[target_features]` are checked
     /// against this. We also check any implied features, based on the information above. If LLVM
     /// implicitly enables more implied features than we do, that could bypass this check!
-    pub fn abi_required_features(&self) -> (&'static [&'static str], &'static [&'static str]) {
-        const NOTHING: (&'static [&'static str], &'static [&'static str]) = (&[], &[]);
+    pub fn abi_required_features(&self) -> FeatureConstraints {
+        const NOTHING: FeatureConstraints = FeatureConstraints { required: &[], incompatible: &[] };
         // Some architectures don't have a clean explicit ABI designation; instead, the ABI is
         // defined by target features. When that is the case, those target features must be
         // "forbidden" in the list above to ensure that there is a consistent answer to the
@@ -763,7 +771,7 @@ impl Target {
                     NOTHING
                 } else {
                     // Hardfloat ABI. x87 must be enabled.
-                    (&["x87"], &[])
+                    FeatureConstraints { required: &["x87"], incompatible: &[] }
                 }
             }
             "x86_64" => {
@@ -773,7 +781,7 @@ impl Target {
                     NOTHING
                 } else {
                     // Hardfloat ABI. x87 and SSE2 must be enabled.
-                    (&["x87", "sse2"], &[])
+                    FeatureConstraints { required: &["x87", "sse2"], incompatible: &[] }
                 }
             }
             "arm" => {
@@ -786,7 +794,7 @@ impl Target {
                     }
                     FloatAbi::Hard => {
                         // Must have `fpregs` and must not have `soft-float`.
-                        (&["fpregs"], &["soft-float"])
+                        FeatureConstraints { required: &["fpregs"], incompatible: &["soft-float"] }
                     }
                 }
             }
@@ -803,7 +811,7 @@ impl Target {
                     _ => {
                         // Everything else is assumed to use a hardfloat ABI. neon and fp-armv8 must be enabled.
                         // These are Rust feature names and we use "neon" to control both of them.
-                        (&["neon"], &[])
+                        FeatureConstraints { required: &["neon"], incompatible: &[] }
                     }
                 }
             }
@@ -813,15 +821,15 @@ impl Target {
                 match &*self.llvm_abiname {
                     "ilp32d" | "lp64d" => {
                         // Requires d (which implies f), incompatible with e.
-                        (&["d"], &["e"])
+                        FeatureConstraints { required: &["d"], incompatible: &["e"] }
                     }
                     "ilp32f" | "lp64f" => {
                         // Requires f, incompatible with e.
-                        (&["f"], &["e"])
+                        FeatureConstraints { required: &["f"], incompatible: &["e"] }
                     }
                     "ilp32" | "lp64" => {
                         // Requires nothing, incompatible with e.
-                        (&[], &["e"])
+                        FeatureConstraints { required: &[], incompatible: &["e"] }
                     }
                     "ilp32e" => {
                         // ilp32e is documented to be incompatible with features that need aligned
@@ -832,7 +840,7 @@ impl Target {
                         // Note that the `e` feature is not required: the ABI treats the extra
                         // registers as caller-save, so it is safe to use them only in some parts of
                         // a program while the rest doesn't know they even exist.
-                        (&[], &["d"])
+                        FeatureConstraints { required: &[], incompatible: &["d"] }
                     }
                     "lp64e" => {
                         // As above, `e` is not required.
-- 
cgit 1.4.1-3-g733a5