move -Ctarget-feature handling into shared code

compiler/rustc_codegen_gcc/messages.ftl

@@ -1,7 +1,3 @@
-codegen_gcc_unknown_ctarget_feature_prefix =
- unknown feature specified for `-Ctarget-feature`: `{$feature}`
- .note = features must begin with a `+` to enable or `-` to disable it
-
 codegen_gcc_unwinding_inline_asm =
  GCC backend does not support unwinding from inline asm
 
@@ -16,15 +12,3 @@ codegen_gcc_lto_disallowed = lto can only be run for executables, cdylibs and st
 codegen_gcc_lto_dylib = lto cannot be used for `dylib` crate type without `-Zdylib-lto`
 
 codegen_gcc_lto_bitcode_from_rlib = failed to get bitcode from object file for LTO ({$gcc_err})
-
-codegen_gcc_unknown_ctarget_feature =
- unknown and unstable feature specified for `-Ctarget-feature`: `{$feature}`
- .note = it is still passed through to the codegen backend, but use of this feature might be unsound and the behavior of this feature can change in the future
- .possible_feature = you might have meant: `{$rust_feature}`
- .consider_filing_feature_request = consider filing a feature request
-
-codegen_gcc_missing_features =
- add the missing features in a `target_feature` attribute
-
-codegen_gcc_target_feature_disable_or_enable =
- the target features {$features} must all be either enabled or disabled together

compiler/rustc_codegen_gcc/src/errors.rs

@@ -1,30 +1,6 @@
-use rustc_macros::{Diagnostic, Subdiagnostic};
+use rustc_macros::Diagnostic;
 use rustc_span::Span;
 
-#[derive(Diagnostic)]
-#[diag(codegen_gcc_unknown_ctarget_feature_prefix)]
-#[note]
-pub(crate) struct UnknownCTargetFeaturePrefix<'a> {
- pub feature: &'a str,
-}
-
-#[derive(Diagnostic)]
-#[diag(codegen_gcc_unknown_ctarget_feature)]
-#[note]
-pub(crate) struct UnknownCTargetFeature<'a> {
- pub feature: &'a str,
- #[subdiagnostic]
- pub rust_feature: PossibleFeature<'a>,
-}
-
-#[derive(Subdiagnostic)]
-pub(crate) enum PossibleFeature<'a> {
- #[help(codegen_gcc_possible_feature)]
- Some { rust_feature: &'a str },
- #[help(codegen_gcc_consider_filing_feature_request)]
- None,
-}
-
 #[derive(Diagnostic)]
 #[diag(codegen_gcc_unwinding_inline_asm)]
 pub(crate) struct UnwindingInlineAsm {

compiler/rustc_codegen_gcc/src/gcc_util.rs

@@ -1,20 +1,11 @@
 #[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_data_structures::unord::UnordSet;
+use rustc_codegen_ssa::target_features;
 use rustc_session::Session;
-use rustc_session::features::{StabilityExt, retpoline_features_by_flags};
-use rustc_target::target_features::RUSTC_SPECIFIC_FEATURES;
 use smallvec::{SmallVec, smallvec};
 
-use crate::errors::{PossibleFeature, UnknownCTargetFeature, UnknownCTargetFeaturePrefix};
-
-fn gcc_features_by_flags(sess: &Session) -> Vec<&str> {
- let mut features: Vec<&str> = Vec::new();
- retpoline_features_by_flags(sess, &mut features);
- features
+fn gcc_features_by_flags(sess: &Session, features: &mut Vec<String>) {
+ target_features::retpoline_features_by_flags(sess, features);
 }
 
 /// The list of GCC features computed from CLI flags (`-Ctarget-cpu`, `-Ctarget-feature`,
@@ -44,98 +35,31 @@ pub(crate) fn global_gcc_features(sess: &Session, diagnostics: bool) -> Vec<Stri
  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();
-
- // Compute implied features
- let mut all_rust_features = vec![];
- for feature in sess.opts.cg.target_feature.split(',').chain(gcc_features_by_flags(sess)) {
- if let Some(feature) = feature.strip_prefix('+') {
- all_rust_features.extend(
- UnordSet::from(sess.target.implied_target_features(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_config`.
- // See <https://github.com/rust-lang/rust/issues/134792>.
- all_rust_features.push((false, feature));
- } else if !feature.is_empty() && diagnostics {
- sess.dcx().emit_warn(UnknownCTargetFeaturePrefix { feature });
- }
- }
- // 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)
- });
-
- // 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)
- {
- 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, _)) => {
- stability.verify_feature_enabled_by_flag(sess, enable, feature);
- }
- }
-
- // FIXME(nagisa): figure out how to not allocate a full hashset here.
- featsmap.insert(feature, enable);
- }
- }
-
- // Translate this into GCC features.
- let feats =
- all_rust_features.iter().flat_map(|&(enable, feature)| {
- let enable_disable = if enable { '+' } else { '-' };
+ target_features::flag_to_backend_features(
+ sess,
+ diagnostics,
+ |feature| to_gcc_features(sess, feature),
+ |feature, enable| {
  // 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.
- to_gcc_features(sess, feature)
- .iter()
- .flat_map(|feat| to_gcc_features(sess, feat).into_iter())
- .map(|feature| {
- if enable_disable == '-' {
- format!("-{}", feature)
- } else {
- feature.to_string()
- }
- })
- .collect::<Vec<_>>()
- });
- features.extend(feats);
-
- if diagnostics && let Some(f) = check_tied_features(sess, &featsmap) {
- sess.dcx().emit_err(TargetFeatureDisableOrEnable {
- features: f,
- span: None,
- missing_features: None,
- });
- }
+ features.extend(
+ to_gcc_features(sess, feature)
+ .iter()
+ .flat_map(|feat| to_gcc_features(sess, feat).into_iter())
+ .map(
+ |feature| {
+ if !enable { format!("-{}", feature) } else { feature.to_string() }
+ },
+ ),
+ );
+ },
+ );
+
+ gcc_features_by_flags(sess, &mut features);
+
+ // FIXME: LLVM also sets +reserve-x18 here under some conditions.
 
  features
 }

compiler/rustc_codegen_llvm/messages.ftl

@@ -59,16 +59,6 @@ codegen_llvm_symbol_already_defined =
 codegen_llvm_target_machine = could not create LLVM TargetMachine for triple: {$triple}
 codegen_llvm_target_machine_with_llvm_err = could not create LLVM TargetMachine for triple: {$triple}: {$llvm_err}
 
-codegen_llvm_unknown_ctarget_feature =
- unknown and unstable feature specified for `-Ctarget-feature`: `{$feature}`
- .note = it is still passed through to the codegen backend, but use of this feature might be unsound and the behavior of this feature can change in the future
- .possible_feature = you might have meant: `{$rust_feature}`
- .consider_filing_feature_request = consider filing a feature request
-
-codegen_llvm_unknown_ctarget_feature_prefix =
- unknown feature specified for `-Ctarget-feature`: `{$feature}`
- .note = features must begin with a `+` to enable or `-` to disable it
-
 codegen_llvm_unknown_debuginfo_compression = unknown debuginfo compression algorithm {$algorithm} - will fall back to uncompressed debuginfo
 
 codegen_llvm_write_bytecode = failed to write bytecode to {$path}: {$err}

compiler/rustc_codegen_llvm/src/errors.rs

@@ -3,35 +3,11 @@ use std::path::Path;
 
 use rustc_data_structures::small_c_str::SmallCStr;
 use rustc_errors::{Diag, DiagCtxtHandle, Diagnostic, EmissionGuarantee, Level};
-use rustc_macros::{Diagnostic, Subdiagnostic};
+use rustc_macros::Diagnostic;
 use rustc_span::Span;
 
 use crate::fluent_generated as fluent;
 
-#[derive(Diagnostic)]
-#[diag(codegen_llvm_unknown_ctarget_feature_prefix)]
-#[note]
-pub(crate) struct UnknownCTargetFeaturePrefix<'a> {
- pub feature: &'a str,
-}
-
-#[derive(Diagnostic)]
-#[diag(codegen_llvm_unknown_ctarget_feature)]
-#[note]
-pub(crate) struct UnknownCTargetFeature<'a> {
- pub feature: &'a str,
- #[subdiagnostic]
- pub rust_feature: PossibleFeature<'a>,
-}
-
-#[derive(Subdiagnostic)]
-pub(crate) enum PossibleFeature<'a> {
- #[help(codegen_llvm_possible_feature)]
- Some { rust_feature: &'a str },
- #[help(codegen_llvm_consider_filing_feature_request)]
- None,
-}
-
 #[derive(Diagnostic)]
 #[diag(codegen_llvm_symbol_already_defined)]
 pub(crate) struct SymbolAlreadyDefined<'a> {