Move CodegenBackend out of Linker.

It can easily be passed in. And that removes the single clone of
`Compiler::codegen_backend`, which means it no longer needs to be `Lrc`.

Author: nnethercote

compiler/rustc_driver_impl/src/lib.rs

@@ -370,7 +370,7 @@ fn run_compiler(
                     }
                     let should_stop = print_crate_info(
                         &handler,
-                        &**compiler.codegen_backend(),
+                        compiler.codegen_backend(),
                         compiler.session(),
                         false,
                     );
@@ -394,12 +394,11 @@ fn run_compiler(
 
     interface::run_compiler(config, |compiler| {
         let sess = compiler.session();
+        let codegen_backend = compiler.codegen_backend();
         let handler = EarlyErrorHandler::new(sess.opts.error_format);
 
-        let should_stop = print_crate_info(&handler, &**compiler.codegen_backend(), sess, true)
-            .and_then(|| {
-                list_metadata(&handler, sess, &*compiler.codegen_backend().metadata_loader())
-            })
+        let should_stop = print_crate_info(&handler, codegen_backend, sess, true)
+            .and_then(|| list_metadata(&handler, sess, &*codegen_backend.metadata_loader()))
             .and_then(|| try_process_rlink(sess, compiler));
 
         if should_stop == Compilation::Stop {
@@ -493,7 +492,7 @@ fn run_compiler(
 
         if let Some(linker) = linker {
             let _timer = sess.timer("link");
-            linker.link(sess)?
+            linker.link(sess, codegen_backend)?
         }
 
         if sess.opts.unstable_opts.print_fuel.is_some() {

compiler/rustc_interface/src/interface.rs

@@ -6,7 +6,6 @@ use rustc_codegen_ssa::traits::CodegenBackend;
 use rustc_data_structures::defer;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_data_structures::stable_hasher::StableHasher;
-use rustc_data_structures::sync::Lrc;
 use rustc_errors::registry::Registry;
 use rustc_errors::{ErrorGuaranteed, Handler};
 use rustc_lint::LintStore;
@@ -39,7 +38,7 @@ pub type Result<T> = result::Result<T, ErrorGuaranteed>;
 /// Created by passing [`Config`] to [`run_compiler`].
 pub struct Compiler {
     pub(crate) sess: Session,
-    codegen_backend: Lrc<dyn CodegenBackend>,
+    codegen_backend: Box<dyn CodegenBackend>,
     pub(crate) register_lints: Option<Box<dyn Fn(&Session, &mut LintStore) + Send + Sync>>,
     pub(crate) override_queries: Option<fn(&Session, &mut Providers)>,
 }
@@ -48,8 +47,8 @@ impl Compiler {
     pub fn session(&self) -> &Session {
         &self.sess
     }
-    pub fn codegen_backend(&self) -> &Lrc<dyn CodegenBackend> {
-        &self.codegen_backend
+    pub fn codegen_backend(&self) -> &dyn CodegenBackend {
+        &*self.codegen_backend
     }
     pub fn register_lints(&self) -> &Option<Box<dyn Fn(&Session, &mut LintStore) + Send + Sync>> {
         &self.register_lints
@@ -475,7 +474,7 @@ pub fn run_compiler<R: Send>(config: Config, f: impl FnOnce(&Compiler) -> R + Se
 
             let compiler = Compiler {
                 sess,
-                codegen_backend: Lrc::from(codegen_backend),
+                codegen_backend,
                 register_lints: config.register_lints,
                 override_queries: config.override_queries,
             };

compiler/rustc_interface/src/queries.rs

@@ -105,7 +105,7 @@ impl<'tcx> Queries<'tcx> {
         &self.compiler.sess
     }
 
-    fn codegen_backend(&self) -> &Lrc<dyn CodegenBackend> {
+    fn codegen_backend(&self) -> &dyn CodegenBackend {
         self.compiler.codegen_backend()
     }
 
@@ -201,7 +201,7 @@ impl<'tcx> Queries<'tcx> {
             // Hook for UI tests.
             Self::check_for_rustc_errors_attr(tcx);
 
-            Ok(passes::start_codegen(&**self.codegen_backend(), tcx))
+            Ok(passes::start_codegen(self.codegen_backend(), tcx))
         })
     }
 
@@ -242,7 +242,6 @@ impl<'tcx> Queries<'tcx> {
     pub fn linker(&'tcx self, ongoing_codegen: Box<dyn Any>) -> Result<Linker> {
         self.global_ctxt()?.enter(|tcx| {
             Ok(Linker {
-                codegen_backend: self.codegen_backend().clone(),
                 dep_graph: tcx.dep_graph.clone(),
                 prepare_outputs: tcx.output_filenames(()).clone(),
                 crate_hash: if tcx.needs_crate_hash() {
@@ -257,10 +256,6 @@ impl<'tcx> Queries<'tcx> {
 }
 
 pub struct Linker {
-    // compilation inputs
-    codegen_backend: Lrc<dyn CodegenBackend>,
-
-    // compilation outputs
     dep_graph: DepGraph,
     prepare_outputs: Arc<OutputFilenames>,
     // Only present when incr. comp. is enabled.
@@ -269,9 +264,9 @@ pub struct Linker {
 }
 
 impl Linker {
-    pub fn link(self, sess: &Session) -> Result<()> {
+    pub fn link(self, sess: &Session, codegen_backend: &dyn CodegenBackend) -> Result<()> {
         let (codegen_results, work_products) =
-            self.codegen_backend.join_codegen(self.ongoing_codegen, sess, &self.prepare_outputs)?;
+            codegen_backend.join_codegen(self.ongoing_codegen, sess, &self.prepare_outputs)?;
 
         sess.compile_status()?;
 
@@ -304,7 +299,7 @@ impl Linker {
         }
 
         let _timer = sess.prof.verbose_generic_activity("link_crate");
-        self.codegen_backend.link(sess, codegen_results, &self.prepare_outputs)
+        codegen_backend.link(sess, codegen_results, &self.prepare_outputs)
     }
 }
 

tests/run-make-fulldeps/issue-19371/foo.rs

@@ -72,6 +72,6 @@ fn compile(code: String, output: PathBuf, sysroot: PathBuf) {
             let ongoing_codegen = queries.ongoing_codegen()?;
             queries.linker(ongoing_codegen)
         });
-        linker.unwrap().link(compiler.session()).unwrap();
+        linker.unwrap().link(compiler.session(), compiler.codegen_backend()).unwrap();
     });
 }