target_features: control separately whether enabling and disabling a target feature is allowed

Author: RalfJung

compiler/rustc_codegen_gcc/src/gcc_util.rs

@@ -95,7 +95,9 @@ pub(crate) fn global_gcc_features(sess: &Session, diagnostics: bool) -> Vec<Stri
                         sess.dcx().emit_warn(unknown_feature);
                     }
                     Some((_, stability, _)) => {
-                        if let Err(reason) = stability.compute(&sess.target).allow_toggle() {
+                        if let Err(reason) =
+                            stability.allow_toggle(&sess.target, enable_disable == '+')
+                        {
                             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

compiler/rustc_codegen_gcc/src/lib.rs

@@ -483,9 +483,9 @@ fn target_features_cfg(
         .rust_target_features()
         .iter()
         .filter(|(_, gate, _)| gate.in_cfg())
-        .filter_map(|&(feature, gate, _)| {
+        .filter_map(|(feature, gate, _)| {
             if sess.is_nightly_build() || allow_unstable || gate.requires_nightly().is_none() {
-                Some(feature)
+                Some(*feature)
             } else {
                 None
             }

compiler/rustc_codegen_llvm/src/llvm_util.rs

@@ -370,9 +370,9 @@ pub fn target_features_cfg(sess: &Session, allow_unstable: bool) -> Vec<Symbol>
         .rust_target_features()
         .iter()
         .filter(|(_, gate, _)| gate.in_cfg())
-        .filter_map(|&(feature, gate, _)| {
+        .filter_map(|(feature, gate, _)| {
             if sess.is_nightly_build() || allow_unstable || gate.requires_nightly().is_none() {
-                Some(feature)
+                Some(*feature)
             } else {
                 None
             }
@@ -714,7 +714,9 @@ pub(crate) fn global_llvm_features(
                             sess.dcx().emit_warn(unknown_feature);
                         }
                         Some((_, stability, _)) => {
-                            if let Err(reason) = stability.compute(&sess.target).allow_toggle() {
+                            if let Err(reason) =
+                                stability.allow_toggle(&sess.target, enable_disable == '+')
+                            {
                                 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

compiler/rustc_codegen_ssa/src/target_features.rs

@@ -65,7 +65,7 @@ pub(crate) fn from_target_feature_attr(
 
             // Only allow target features whose feature gates have been enabled
             // and which are permitted to be toggled.
-            if let Err(reason) = stability.allow_toggle() {
+            if let Err(reason) = stability.allow_toggle(/*enable*/ true) {
                 tcx.dcx().emit_err(errors::ForbiddenTargetFeatureAttr {
                     span: item.span(),
                     feature,
@@ -160,7 +160,7 @@ pub(crate) fn provide(providers: &mut Providers) {
                     .target
                     .rust_target_features()
                     .iter()
-                    .map(|&(a, b, _)| (a.to_string(), b.compute(target)))
+                    .map(|(a, b, _)| (a.to_string(), b.compute(target)))
                     .collect()
             }
         },

compiler/rustc_target/src/target_features.rs

@@ -20,7 +20,7 @@ pub const RUSTC_SPECIAL_FEATURES: &[&str] = &["backchain"];
 /// `AllowToggle` is the type storing whether (un)stable features can be toggled:
 /// this is initially a function since it can depend on `Target`, but for stable hashing
 /// it needs to be something hashable to we have to make the type generic.
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone)]
 pub enum Stability<AllowToggle> {
     /// This target feature is stable, it can be used in `#[target_feature]` and
     /// `#[cfg(target_feature)]`.
@@ -44,11 +44,21 @@ pub enum Stability<AllowToggle> {
     Forbidden { reason: &'static str },
 }
 
-/// `Stability` where `allow_toggle` has not been computed yet.
 /// Returns `Ok` if the toggle is allowed, `Err` with an explanation of not.
-pub type StabilityUncomputed = Stability<fn(&Target) -> Result<(), &'static str>>;
+/// The `bool` indicates whether the feature is being enabled (`true`) or disabled.
+pub type AllowToggleUncomputed = fn(&Target, bool) -> Result<(), &'static str>;
+
+/// The computed result of whether a feature can be enabled/disabled on the current target.
+#[derive(Debug, Clone)]
+pub struct AllowToggleComputed {
+    enable: Result<(), &'static str>,
+    disable: Result<(), &'static str>,
+}
+
+/// `Stability` where `allow_toggle` has not been computed yet.
+pub type StabilityUncomputed = Stability<AllowToggleUncomputed>;
 /// `Stability` where `allow_toggle` has already been computed.
-pub type StabilityComputed = Stability<Result<(), &'static str>>;
+pub type StabilityComputed = Stability<AllowToggleComputed>;
 
 impl<CTX, AllowToggle: HashStable<CTX>> HashStable<CTX> for Stability<AllowToggle> {
     #[inline]
@@ -69,51 +79,74 @@ impl<CTX, AllowToggle: HashStable<CTX>> HashStable<CTX> for Stability<AllowToggl
     }
 }
 
+impl<CTX> HashStable<CTX> for AllowToggleComputed {
+    #[inline]
+    fn hash_stable(&self, hcx: &mut CTX, hasher: &mut StableHasher) {
+        let AllowToggleComputed { enable, disable } = self;
+        enable.hash_stable(hcx, hasher);
+        disable.hash_stable(hcx, hasher);
+    }
+}
+
 impl<AllowToggle> Stability<AllowToggle> {
     /// Returns whether the feature can be queried in `cfg` ever.
     /// (It might still be nightly-only even if this returns `true`).
-    pub fn in_cfg(self) -> bool {
+    pub fn in_cfg(&self) -> bool {
         !matches!(self, Stability::Forbidden { .. })
     }
 
     /// Returns the nightly feature that is required to toggle or query this target feature. Ensure
     /// to also check `allow_toggle()` before allowing to toggle!
-    pub fn requires_nightly(self) -> Option<Symbol> {
+    pub fn requires_nightly(&self) -> Option<Symbol> {
         match self {
-            Stability::Unstable { nightly_feature, .. } => Some(nightly_feature),
-            Stability::Stable { .. } => None,
-            Stability::Forbidden { .. } => panic!("forbidden features should not reach this far"),
+            &Stability::Unstable { nightly_feature, .. } => Some(nightly_feature),
+            &Stability::Stable { .. } => None,
+            &Stability::Forbidden { .. } => panic!("forbidden features should not reach this far"),
         }
     }
 }
 
 impl StabilityUncomputed {
-    pub fn compute(self, target: &Target) -> StabilityComputed {
+    pub fn compute(&self, target: &Target) -> StabilityComputed {
         use Stability::*;
+        let compute = |f: AllowToggleUncomputed| AllowToggleComputed {
+            enable: f(target, true),
+            disable: f(target, false),
+        };
         match self {
-            Stable { allow_toggle } => Stable { allow_toggle: allow_toggle(target) },
-            Unstable { nightly_feature, allow_toggle } => {
-                Unstable { nightly_feature, allow_toggle: allow_toggle(target) }
+            &Stable { allow_toggle } => Stable { allow_toggle: compute(allow_toggle) },
+            &Unstable { nightly_feature, allow_toggle } => {
+                Unstable { nightly_feature, allow_toggle: compute(allow_toggle) }
             }
-            Forbidden { reason } => Forbidden { reason },
+            &Forbidden { reason } => Forbidden { reason },
+        }
+    }
+
+    pub fn allow_toggle(&self, target: &Target, enable: bool) -> Result<(), &'static str> {
+        use Stability::*;
+        match self {
+            &Stable { allow_toggle } => allow_toggle(target, enable),
+            &Unstable { allow_toggle, .. } => allow_toggle(target, enable),
+            &Forbidden { reason } => Err(reason),
         }
     }
 }
 
 impl StabilityComputed {
-    pub fn allow_toggle(self) -> Result<(), &'static str> {
-        match self {
+    pub fn allow_toggle(&self, enable: bool) -> Result<(), &'static str> {
+        let allow_toggle = match self {
             Stability::Stable { allow_toggle } => allow_toggle,
             Stability::Unstable { allow_toggle, .. } => allow_toggle,
-            Stability::Forbidden { reason } => Err(reason),
-        }
+            Stability::Forbidden { reason } => return Err(reason),
+        };
+        if enable { allow_toggle.enable } else { allow_toggle.disable }
     }
 }
 
 // Constructors for the list below, defaulting to "always allow toggle".
-const STABLE: StabilityUncomputed = Stability::Stable { allow_toggle: |_target| Ok(()) };
+const STABLE: StabilityUncomputed = Stability::Stable { allow_toggle: |_target, _enable| Ok(()) };
 const fn unstable(nightly_feature: Symbol) -> StabilityUncomputed {
-    Stability::Unstable { nightly_feature, allow_toggle: |_target| Ok(()) }
+    Stability::Unstable { nightly_feature, allow_toggle: |_target, _enable| Ok(()) }
 }
 
 // Here we list target features that rustc "understands": they can be used in `#[target_feature]`
@@ -174,7 +207,7 @@ const ARM_FEATURES: &[(&str, StabilityUncomputed, ImpliedFeatures)] = &[
         "fpregs",
         Stability::Unstable {
             nightly_feature: sym::arm_target_feature,
-            allow_toggle: |target: &Target| {
+            allow_toggle: |target: &Target, _enable| {
                 // Only allow toggling this if the target has `soft-float` set. With `soft-float`,
                 // `fpregs` isn't needed so changing it cannot affect the ABI.
                 if target.has_feature("soft-float") {
@@ -471,7 +504,7 @@ const X86_FEATURES: &[(&str, StabilityUncomputed, ImpliedFeatures)] = &[
         "x87",
         Stability::Unstable {
             nightly_feature: sym::x87_target_feature,
-            allow_toggle: |target: &Target| {
+            allow_toggle: |target: &Target, _enable| {
                 // Only allow toggling this if the target has `soft-float` set. With `soft-float`,
                 // `fpregs` isn't needed so changing it cannot affect the ABI.
                 if target.has_feature("soft-float") {