Ability to make target features target modifiers

daxpedda · daxpedda · commit 247c6cf86e1a · 2025-11-03T07:08:26.000+01:00
diff --git a/compiler/rustc_codegen_llvm/src/llvm_util.rs b/compiler/rustc_codegen_llvm/src/llvm_util.rs
@@ -515,7 +515,7 @@ fn print_target_features(sess: &Session, tm: &llvm::TargetMachine, out: &mut Str
         .target
         .rust_target_features()
         .iter()
-        .filter_map(|(feature, gate, _implied)| {
+        .filter_map(|(feature, gate, _implied, _)| {
             if !gate.in_cfg() {
                 // Only list (experimentally) supported features.
                 return None;
diff --git a/compiler/rustc_codegen_ssa/src/target_features.rs b/compiler/rustc_codegen_ssa/src/target_features.rs
@@ -173,7 +173,7 @@ fn parse_rust_feature_flag<'a>(
 
             let inverse_implied_features = inverse_implied_features.get_or_insert_with(|| {
                 let mut set: FxHashMap<&str, FxHashSet<&str>> = FxHashMap::default();
-                for (f, _, is) in sess.target.rust_target_features() {
+                for (f, _, is, _) in sess.target.rust_target_features() {
                     for i in is.iter() {
                         set.entry(i).or_default().insert(f);
                     }
@@ -222,8 +222,8 @@ pub fn cfg_target_feature(
         .target
         .rust_target_features()
         .iter()
-        .filter(|(feature, _, _)| target_base_has_feature(feature))
-        .flat_map(|(base_feature, _, _)| {
+        .filter(|(feature, _, _, _)| target_base_has_feature(feature))
+        .flat_map(|(base_feature, _, _, _)| {
             // Expand the direct base feature into all transitively-implied features. Note that we
             // cannot simply use the `implied` field of the tuple since that only contains
             // directly-implied features.
@@ -260,7 +260,7 @@ pub fn cfg_target_feature(
         sess.target
             .rust_target_features()
             .iter()
-            .filter_map(|(feature, gate, _)| {
+            .filter_map(|(feature, gate, _, _)| {
                 // The `allow_unstable` set is used by rustc internally to determine which target
                 // features are truly available, so we want to return even perma-unstable
                 // "forbidden" features.
@@ -330,13 +330,13 @@ pub fn flag_to_backend_features<'a, const N: usize>(
             );
             // Check feature validity.
             if diagnostics {
-                let feature_state = known_features.iter().find(|&&(v, _, _)| v == base_feature);
+                let feature_state = known_features.iter().find(|&&(v, _, _, _)| v == base_feature);
                 match feature_state {
                     None => {
                         // This is definitely not a valid Rust feature name. Maybe it is a backend
                         // feature name? If so, give a better error message.
                         let rust_feature =
-                            known_features.iter().find_map(|&(rust_feature, _, _)| {
+                            known_features.iter().find_map(|&(rust_feature, _, _, _)| {
                                 let backend_features = to_backend_features(rust_feature);
                                 if backend_features.contains(&base_feature)
                                     && !backend_features.contains(&rust_feature)
@@ -359,7 +359,7 @@ pub fn flag_to_backend_features<'a, const N: usize>(
                         };
                         sess.dcx().emit_warn(unknown_feature);
                     }
-                    Some((_, stability, _)) => {
+                    Some((_, stability, _, _)) => {
                         if let Err(reason) = stability.toggle_allowed() {
                             sess.dcx().emit_warn(errors::ForbiddenCTargetFeature {
                                 feature: base_feature,
@@ -463,7 +463,7 @@ pub(crate) fn provide(providers: &mut Providers) {
                     .target
                     .rust_target_features()
                     .iter()
-                    .map(|(a, b, _)| (a.to_string(), *b))
+                    .map(|(a, b, _, _)| (a.to_string(), *b))
                     .collect()
             }
         },
diff --git a/compiler/rustc_metadata/src/creader.rs b/compiler/rustc_metadata/src/creader.rs
@@ -412,7 +412,7 @@ impl CStore {
             match (&left_name_val, &right_name_val) {
                 (Some(l), Some(r)) => match l.1.opt.cmp(&r.1.opt) {
                     cmp::Ordering::Equal => {
-                        if !l.1.consistent(&tcx.sess.opts, Some(&r.1)) {
+                        if !l.1.consistent(&tcx.sess, Some(&r.1)) {
                             report_diff(
                                 &l.0.prefix,
                                 &l.0.name,
@@ -424,26 +424,26 @@ impl CStore {
                         right_name_val = None;
                     }
                     cmp::Ordering::Greater => {
-                        if !r.1.consistent(&tcx.sess.opts, None) {
+                        if !r.1.consistent(&tcx.sess, None) {
                             report_diff(&r.0.prefix, &r.0.name, None, Some(&r.1.value_name));
                         }
                         right_name_val = None;
                     }
                     cmp::Ordering::Less => {
-                        if !l.1.consistent(&tcx.sess.opts, None) {
+                        if !l.1.consistent(&tcx.sess, None) {
                             report_diff(&l.0.prefix, &l.0.name, Some(&l.1.value_name), None);
                         }
                         left_name_val = None;
                     }
                 },
                 (Some(l), None) => {
-                    if !l.1.consistent(&tcx.sess.opts, None) {
+                    if !l.1.consistent(&tcx.sess, None) {
                         report_diff(&l.0.prefix, &l.0.name, Some(&l.1.value_name), None);
                     }
                     left_name_val = None;
                 }
                 (None, Some(r)) => {
-                    if !r.1.consistent(&tcx.sess.opts, None) {
+                    if !r.1.consistent(&tcx.sess, None) {
                         report_diff(&r.0.prefix, &r.0.name, None, Some(&r.1.value_name));
                     }
                     right_name_val = None;
diff --git a/compiler/rustc_session/src/options.rs b/compiler/rustc_session/src/options.rs
@@ -22,7 +22,7 @@ use rustc_target::spec::{
 use crate::config::*;
 use crate::search_paths::SearchPath;
 use crate::utils::NativeLib;
-use crate::{EarlyDiagCtxt, lint};
+use crate::{EarlyDiagCtxt, Session, lint};
 
 macro_rules! insert {
     ($opt_name:ident, $opt_expr:expr, $sub_hashes:expr) => {
@@ -85,6 +85,53 @@ pub struct TargetModifier {
 
 mod target_modifier_consistency_check {
     use super::*;
+    pub(super) fn target_feature(
+        sess: &Session,
+        l: &TargetModifier,
+        r: Option<&TargetModifier>,
+    ) -> bool {
+        fn parse<'a>(session: &'a Session, val: &'a TargetModifier) -> Vec<&'a str> {
+            let mut target_features = Vec::new();
+
+            for feature in session
+                .target_features
+                .iter()
+                .map(|symbol| symbol.as_str())
+                .chain(val.value_name.split(','))
+            {
+                if let Some(feature) = feature.strip_prefix('+') {
+                    if session
+                        .target
+                        .rust_target_features()
+                        .iter()
+                        .any(|(name, _, _, target_modifier)| feature == *name && *target_modifier)
+                    {
+                        target_features.push(feature);
+                    }
+                } else if let Some(feature) = feature.strip_prefix('-') {
+                    if session
+                        .target
+                        .rust_target_features()
+                        .iter()
+                        .any(|(name, _, _, target_modifier)| feature == *name && *target_modifier)
+                    {
+                        for (index, target_feature) in target_features.iter().enumerate() {
+                            if *target_feature == feature {
+                                target_features.remove(index);
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+
+            target_features
+        }
+
+        let l = parse(sess, l);
+
+        if let Some(r) = r { l == parse(sess, r) } else { l.is_empty() }
+    }
     pub(super) fn sanitizer(l: &TargetModifier, r: Option<&TargetModifier>) -> bool {
         let mut lparsed: SanitizerSet = Default::default();
         let lval = if l.value_name.is_empty() { None } else { Some(l.value_name.as_str()) };
@@ -133,21 +180,25 @@ impl TargetModifier {
     }
     // Custom consistency check for target modifiers (or default `l.tech_value == r.tech_value`)
     // When other is None, consistency with default value is checked
-    pub fn consistent(&self, opts: &Options, other: Option<&TargetModifier>) -> bool {
+    pub fn consistent(&self, sess: &Session, other: Option<&TargetModifier>) -> bool {
         assert!(other.is_none() || self.opt == other.unwrap().opt);
         match self.opt {
+            OptionsTargetModifiers::CodegenOptions(
+                CodegenOptionsTargetModifiers::target_feature,
+            ) => {
+                return target_modifier_consistency_check::target_feature(sess, self, other);
+            }
             OptionsTargetModifiers::UnstableOptions(unstable) => match unstable {
                 UnstableOptionsTargetModifiers::sanitizer => {
                     return target_modifier_consistency_check::sanitizer(self, other);
                 }
                 UnstableOptionsTargetModifiers::sanitizer_cfi_normalize_integers => {
                     return target_modifier_consistency_check::sanitizer_cfi_normalize_integers(
-                        opts, self, other,
+                        &sess.opts, self, other,
                     );
                 }
                 _ => {}
             },
-            _ => {}
         };
         match other {
             Some(other) => self.extend().tech_value == other.extend().tech_value,
@@ -2172,7 +2223,7 @@ options! {
         "which mangling version to use for symbol names ('legacy' (default), 'v0', or 'hashed')"),
     target_cpu: Option<String> = (None, parse_opt_string, [TRACKED],
         "select target processor (`rustc --print target-cpus` for details)"),
-    target_feature: String = (String::new(), parse_target_feature, [TRACKED],
+    target_feature: String = (String::new(), parse_target_feature, [TRACKED TARGET_MODIFIER],
         "target specific attributes. (`rustc --print target-features` for details). \
         This feature is unsafe."),
     unsafe_allow_abi_mismatch: Vec<String> = (Vec::new(), parse_comma_list, [UNTRACKED],
diff --git a/compiler/rustc_target/src/target_features.rs b/compiler/rustc_target/src/target_features.rs
diff --git a/src/librustdoc/json/mod.rs b/src/librustdoc/json/mod.rs

Original file line number	Diff line number	Diff line change
`@@ -412,7 +412,7 @@ impl CStore {`
`412`	`412`	`match (&left_name_val, &right_name_val) {`
`413`	`413`	`(Some(l), Some(r)) => match l.1.opt.cmp(&r.1.opt) {`
`414`	`414`	`cmp::Ordering::Equal => {`
`415`		`- if !l.1.consistent(&tcx.sess.opts, Some(&r.1)) {`
	`415`	`+ if !l.1.consistent(&tcx.sess, Some(&r.1)) {`
`416`	`416`	`report_diff(`
`417`	`417`	`&l.0.prefix,`
`418`	`418`	`&l.0.name,`
`@@ -424,26 +424,26 @@ impl CStore {`
`424`	`424`	`right_name_val = None;`
`425`	`425`	`}`
`426`	`426`	`cmp::Ordering::Greater => {`
`427`		`- if !r.1.consistent(&tcx.sess.opts, None) {`
	`427`	`+ if !r.1.consistent(&tcx.sess, None) {`
`428`	`428`	`report_diff(&r.0.prefix, &r.0.name, None, Some(&r.1.value_name));`
`429`	`429`	`}`
`430`	`430`	`right_name_val = None;`
`431`	`431`	`}`
`432`	`432`	`cmp::Ordering::Less => {`
`433`		`- if !l.1.consistent(&tcx.sess.opts, None) {`
	`433`	`+ if !l.1.consistent(&tcx.sess, None) {`
`434`	`434`	`report_diff(&l.0.prefix, &l.0.name, Some(&l.1.value_name), None);`
`435`	`435`	`}`
`436`	`436`	`left_name_val = None;`
`437`	`437`	`}`
`438`	`438`	`},`
`439`	`439`	`(Some(l), None) => {`
`440`		`- if !l.1.consistent(&tcx.sess.opts, None) {`
	`440`	`+ if !l.1.consistent(&tcx.sess, None) {`
`441`	`441`	`report_diff(&l.0.prefix, &l.0.name, Some(&l.1.value_name), None);`
`442`	`442`	`}`
`443`	`443`	`left_name_val = None;`
`444`	`444`	`}`
`445`	`445`	`(None, Some(r)) => {`
`446`		`- if !r.1.consistent(&tcx.sess.opts, None) {`
	`446`	`+ if !r.1.consistent(&tcx.sess, None) {`
`447`	`447`	`report_diff(&r.0.prefix, &r.0.name, None, Some(&r.1.value_name));`
`448`	`448`	`}`
`449`	`449`	`right_name_val = None;`