Remove global_backend_features query

It's now possible to get the backend features (a `Vec<String>`) when the
codegen backend is started, pass it back through `CodegenBackendInit`,
and just store it in the `Session`. This removes the need for the query.

Also:

- `WriteBackendMethods::target_machine_factory` no longer needs the
  `target_features` parameter, because it's now available through the
  `sess` parameter.

- `CodegenContext` no longer needs the `backend_features` field because
  we can use `sess.global_backend_features` instead.

- `CodegenBackend::provide` is now a no-op for all the in-tree backends.
  I haven't removed it because out-of-tree backends still rely on it.

Author: nnethercote

compiler/rustc_codegen_cranelift/src/driver/aot.rs

@@ -319,7 +319,6 @@ impl WriteBackendMethods for AotDriver {
         &self,
         _sess: &Session,
         _opt_level: OptLevel,
-        _target_features: &[String],
     ) -> TargetMachineFactoryFn<Self> {
         Arc::new(|_, _| ())
     }

compiler/rustc_codegen_cranelift/src/lib.rs

@@ -153,6 +153,7 @@ impl CodegenBackend for CraneliftCodegenBackend {
         }
 
         CodegenBackendInit {
+            global_backend_features: vec![],
             replaced_intrinsics: vec![],
             fallback_intrinsics: vec![sym::type_id_eq],
             thin_lto_supported: false,

compiler/rustc_codegen_gcc/src/attributes.rs

@@ -133,7 +133,7 @@ pub fn from_fn_attrs<'gcc, 'tcx>(
 
     // FIXME(antoyo): cg_llvm adds global features to each function so that LTO keep them.
     // Check if GCC requires the same.
-    let mut global_features = cx.tcx.global_backend_features(()).iter().map(|s| s.as_str());
+    let mut global_features = cx.tcx.sess.global_backend_features.iter().map(|s| s.as_str());
     function_features.extend(&mut global_features);
     let target_features = function_features
         .iter()

compiler/rustc_codegen_gcc/src/lib.rs

@@ -91,7 +91,6 @@ use rustc_data_structures::sync::IntoDynSyncSend;
 use rustc_errors::{DiagCtxt, DiagCtxtHandle};
 use rustc_middle::dep_graph::{WorkProduct, WorkProductMap};
 use rustc_middle::ty::TyCtxt;
-use rustc_middle::util::Providers;
 use rustc_session::config::{OptLevel, OutputFilenames};
 use rustc_session::{CodegenBackendInit, EarlySession, IncrCompSession, Session};
 use rustc_span::{Symbol, sym};
@@ -188,6 +187,8 @@ impl CodegenBackend for GccCodegenBackend {
                 .join("libgccjit.so")
         }
 
+        let global_backend_features = gcc_util::global_gcc_features(sess);
+
         // We use all_paths() instead of only path() in case the path specified by --sysroot is
         // invalid.
         // This is the case for instance in Rust for Linux where they specify --sysroot=/dev/null.
@@ -250,17 +251,13 @@ impl CodegenBackend for GccCodegenBackend {
         }
 
         CodegenBackendInit {
+            global_backend_features,
             replaced_intrinsics: vec![],
             fallback_intrinsics: vec![sym::type_id_eq],
             thin_lto_supported: false,
         }
     }
 
-    fn provide(&self, providers: &mut Providers) {
-        providers.queries.global_backend_features =
-            |tcx, ()| gcc_util::global_gcc_features(tcx.sess)
-    }
-
     fn target_cpu(&self, sess: &Session) -> String {
         target_cpu(sess).to_owned()
     }
@@ -397,7 +394,6 @@ impl WriteBackendMethods for GccCodegenBackend {
         &self,
         _sess: &Session,
         _opt_level: OptLevel,
-        _features: &[String],
     ) -> TargetMachineFactoryFn<Self> {
         // FIXME(antoyo): set opt level.
         Arc::new(|_, _| ())

compiler/rustc_codegen_llvm/src/asm.rs

@@ -502,7 +502,7 @@ impl<'tcx> AsmCodegenMethods<'tcx> for CodegenCx<'_, 'tcx> {
         }
 
         // Globally-enabled features that are already in the backend format.
-        let global_features = self.tcx.global_backend_features(()).iter().map(String::as_str);
+        let global_features = self.tcx.sess.global_backend_features.iter().map(String::as_str);
 
         // Features enabled on a particular instance, in the rust format.
         // These need to be translated to the LLVM format.

compiler/rustc_codegen_llvm/src/attributes.rs

@@ -174,7 +174,7 @@ pub(crate) fn sanitize_attrs<'ll, 'tcx>(
     }
     if enabled.contains(SanitizerSet::MEMTAG) {
         // Check to make sure the mte target feature is actually enabled.
-        let features = tcx.global_backend_features(());
+        let features = &tcx.sess.global_backend_features;
         let mte_feature =
             features.iter().map(|s| &s[..]).rfind(|n| ["+mte", "-mte"].contains(&&n[..]));
         if let None | Some("-mte") = mte_feature {
@@ -441,7 +441,7 @@ pub(crate) fn target_features_attr<'ll, 'tcx>(
     tcx: TyCtxt<'tcx>,
     function_features: Vec<String>,
 ) -> Option<&'ll Attribute> {
-    let global_features = tcx.global_backend_features(()).iter().map(String::as_str);
+    let global_features = tcx.sess.global_backend_features.iter().map(String::as_str);
     let function_features = function_features.iter().map(String::as_str);
     let target_features =
         global_features.chain(function_features).intersperse(",").collect::<String>();

compiler/rustc_codegen_llvm/src/back/write.rs

@@ -102,11 +102,7 @@ fn write_output_file<'ll>(
 
 pub(crate) fn create_informational_target_machine(sess: &Session) -> OwnedTargetMachine {
     let config = TargetMachineFactoryConfig { split_dwarf_file: None, output_obj_file: None };
-    // Can't use query system here quite yet because this function is invoked before the query
-    // system/tcx is set up.
-    let features = llvm_util::global_llvm_features(sess, /* for_cfg */ false);
-
-    target_machine_factory(sess, config::OptLevel::No, &features)(sess.dcx(), config)
+    target_machine_factory(sess, config::OptLevel::No)(sess.dcx(), config)
 }
 
 pub(crate) fn create_target_machine(tcx: TyCtxt<'_>, mod_name: &str) -> OwnedTargetMachine {
@@ -124,11 +120,7 @@ pub(crate) fn create_target_machine(tcx: TyCtxt<'_>, mod_name: &str) -> OwnedTar
         Some(tcx.output_filenames(()).temp_path_for_cgu(OutputType::Object, mod_name));
     let config = TargetMachineFactoryConfig { split_dwarf_file, output_obj_file };
 
-    target_machine_factory(
-        tcx.sess,
-        tcx.backend_optimization_level(()),
-        tcx.global_backend_features(()),
-    )(tcx.dcx(), config)
+    target_machine_factory(tcx.sess, tcx.backend_optimization_level(()))(tcx.dcx(), config)
 }
 
 fn to_llvm_opt_settings(cfg: config::OptLevel) -> (llvm::CodeGenOptLevel, llvm::CodeGenOptSize) {
@@ -190,7 +182,6 @@ fn to_llvm_float_abi(float_abi: Option<FloatAbi>) -> llvm::FloatAbi {
 pub(crate) fn target_machine_factory(
     sess: &Session,
     optlvl: config::OptLevel,
-    target_features: &[String],
 ) -> TargetMachineFactoryFn<LlvmCodegenBackend> {
     // Self-profile timer for creating a _factory_.
     let _prof_timer = sess.prof.generic_activity("target_machine_factory");
@@ -211,7 +202,7 @@ pub(crate) fn target_machine_factory(
 
     let triple = SmallCStr::new(&versioned_llvm_target(sess));
     let cpu = SmallCStr::new(llvm_util::target_cpu(sess));
-    let features = CString::new(target_features.join(",")).unwrap();
+    let features = CString::new(sess.global_backend_features.join(",")).unwrap();
     let abi = SmallCStr::new(sess.target.llvm_abiname.desc());
     let trap_unreachable =
         sess.opts.unstable_opts.trap_unreachable.unwrap_or(sess.target.trap_unreachable);

compiler/rustc_codegen_llvm/src/lib.rs

@@ -37,7 +37,6 @@ use rustc_errors::{DiagCtxt, DiagCtxtHandle};
 use rustc_metadata::EncodedMetadata;
 use rustc_middle::dep_graph::{WorkProduct, WorkProductMap};
 use rustc_middle::ty::TyCtxt;
-use rustc_middle::util::Providers;
 use rustc_session::config::{OptLevel, OutputFilenames, PrintKind, PrintRequest};
 use rustc_session::{CodegenBackendInit, EarlySession, IncrCompSession, Session};
 use rustc_span::{Symbol, sym};
@@ -131,9 +130,8 @@ impl WriteBackendMethods for LlvmCodegenBackend {
         &self,
         sess: &Session,
         optlvl: OptLevel,
-        target_features: &[String],
     ) -> TargetMachineFactoryFn<Self> {
-        back::write::target_machine_factory(sess, optlvl, target_features)
+        back::write::target_machine_factory(sess, optlvl)
     }
     fn optimize_and_codegen_fat_lto(
         sess: &Session,
@@ -223,6 +221,9 @@ impl CodegenBackend for LlvmCodegenBackend {
     fn init(&mut self, sess: &EarlySession) -> CodegenBackendInit {
         llvm_util::init(sess); // Make sure llvm is inited
 
+        let global_backend_features =
+            llvm_util::global_llvm_features(sess, /* for_cfg */ false);
+
         // autodiff is based on Enzyme, a library which we might not have available, when it was
         // neither build, nor downloaded via rustup. If autodiff is used, but not available we emit
         // an early error here and abort compilation.
@@ -289,12 +290,12 @@ impl CodegenBackend for LlvmCodegenBackend {
         // cranelift/GCC even if they have dedicated implementations.
         let fallback_intrinsics = vec![sym::type_id_eq];
 
-        CodegenBackendInit { replaced_intrinsics, fallback_intrinsics, thin_lto_supported: true }
-    }
-
-    fn provide(&self, providers: &mut Providers) {
-        providers.queries.global_backend_features =
-            |tcx, ()| llvm_util::global_llvm_features(tcx.sess, /* for_cfg */ false)
+        CodegenBackendInit {
+            global_backend_features,
+            replaced_intrinsics,
+            fallback_intrinsics,
+            thin_lto_supported: true,
+        }
     }
 
     fn print(&self, req: &PrintRequest, out: &mut String, sess: &Session) {

compiler/rustc_codegen_ssa/src/back/write.rs

@@ -335,7 +335,6 @@ pub struct CodegenContext {
     pub output_filenames: Arc<OutputFilenames>,
     pub module_config: Arc<ModuleConfig>,
     pub opt_level: OptLevel,
-    pub backend_features: Vec<String>,
     pub msvc_imps_needed: bool,
     pub is_pe_coff: bool,
     pub target_can_use_split_dwarf: bool,
@@ -1272,8 +1271,7 @@ fn start_executing_work<B: WriteBackendMethods>(
     });
 
     let opt_level = tcx.backend_optimization_level(());
-    let backend_features = tcx.global_backend_features(()).clone();
-    let tm_factory = backend.target_machine_factory(tcx.sess, opt_level, &backend_features);
+    let tm_factory = backend.target_machine_factory(tcx.sess, opt_level);
 
     let remark_dir = if let Some(ref dir) = sess.opts.unstable_opts.remark_dir {
         let result = fs::create_dir_all(dir).and_then(|_| dir.canonicalize());
@@ -1303,7 +1301,6 @@ fn start_executing_work<B: WriteBackendMethods>(
         output_filenames: Arc::clone(tcx.output_filenames(())),
         module_config: regular_config,
         opt_level,
-        backend_features,
         msvc_imps_needed: msvc_imps_needed(tcx),
         is_pe_coff: tcx.sess.target.is_like_windows,
         target_can_use_split_dwarf: tcx.sess.target_can_use_split_dwarf(),
@@ -2164,11 +2161,7 @@ impl<B: WriteBackendMethods> OngoingCodegen<B> {
                 compiled_modules
             }
             MaybeLtoModules::FatLto { cgcx, needs_fat_lto } => {
-                let tm_factory = self.backend.target_machine_factory(
-                    sess,
-                    cgcx.opt_level,
-                    &cgcx.backend_features,
-                );
+                let tm_factory = self.backend.target_machine_factory(sess, cgcx.opt_level);
 
                 CompiledModules {
                     modules: vec![do_fat_lto(
@@ -2184,11 +2177,7 @@ impl<B: WriteBackendMethods> OngoingCodegen<B> {
                 }
             }
             MaybeLtoModules::ThinLto { cgcx, needs_thin_lto } => {
-                let tm_factory = self.backend.target_machine_factory(
-                    sess,
-                    cgcx.opt_level,
-                    &cgcx.backend_features,
-                );
+                let tm_factory = self.backend.target_machine_factory(sess, cgcx.opt_level);
 
                 CompiledModules {
                     modules: do_thin_lto::<B>(

compiler/rustc_codegen_ssa/src/base.rs

@@ -1058,7 +1058,7 @@ impl CrateInfo {
         let n_crates = crates.len();
         let mut info = CrateInfo {
             target_cpu,
-            target_features: tcx.global_backend_features(()).clone(),
+            target_features: tcx.sess.global_backend_features.clone(),
             crate_types,
             exported_symbols,
             linked_symbols,