Rollup merge of #64772 - Mark-Simulacrum:no-tyctxt-tx, r=eddyb

Remove tx_to_llvm_workers from TyCtxt

This can be kept within the codegen backend crates entirely -- there's no reason for us to create it outside and attempt to hold it in the (global) context.

Changes here aren't really too easily reviewable I suspect -- not sure if they can be cleaned up by splitting into more commits though, it's just hard to reason about `Box<Any>` in general. If there are thoughts though I'd be happy to hear them.

The primary goal of this PR is to get rid of the field on `rustc_interface::Queries`.

10 files changed, 42 insertions, 70 deletions

diff --git a/src/librustc/ty/context.rs b/src/librustc/ty/context.rs
index 8a466567319..1cfbd1734a8 100644
--- a/src/librustc/ty/context.rs
+++ b/src/librustc/ty/context.rs
@@ -64,7 +64,6 @@ use std::fmt;
 use std::mem;
 use std::ops::{Deref, Bound};
 use std::iter;
-use std::sync::mpsc;
 use std::sync::Arc;
 use rustc_target::spec::abi;
 use rustc_macros::HashStable;
@@ -1064,14 +1063,6 @@ pub struct GlobalCtxt<'tcx> {
 
     layout_interner: ShardedHashMap<&'tcx LayoutDetails, ()>,
 
-    /// A general purpose channel to throw data out the back towards LLVM worker
-    /// threads.
-    ///
-    /// This is intended to only get used during the codegen phase of the compiler
-    /// when satisfying the query for a particular codegen unit. Internally in
-    /// the query it'll send data along this channel to get processed later.
-    pub tx_to_llvm_workers: Lock<mpsc::Sender<Box<dyn Any + Send>>>,
-
     output_filenames: Arc<OutputFilenames>,
 }
 
@@ -1184,7 +1175,6 @@ impl<'tcx> TyCtxt<'tcx> {
         hir: hir_map::Map<'tcx>,
         on_disk_query_result_cache: query::OnDiskCache<'tcx>,
         crate_name: &str,
-        tx: mpsc::Sender<Box<dyn Any + Send>>,
         output_filenames: &OutputFilenames,
     ) -> GlobalCtxt<'tcx> {
         let data_layout = TargetDataLayout::parse(&s.target.target).unwrap_or_else(|err| {
@@ -1291,7 +1281,6 @@ impl<'tcx> TyCtxt<'tcx> {
             stability_interner: Default::default(),
             allocation_interner: Default::default(),
             alloc_map: Lock::new(interpret::AllocMap::new()),
-            tx_to_llvm_workers: Lock::new(tx),
             output_filenames: Arc::new(output_filenames.clone()),
         }
     }
diff --git a/src/librustc_codegen_llvm/base.rs b/src/librustc_codegen_llvm/base.rs
index 21c19e167cf..5758cdbebf7 100644
--- a/src/librustc_codegen_llvm/base.rs
+++ b/src/librustc_codegen_llvm/base.rs
@@ -103,7 +103,11 @@ pub fn iter_globals(llmod: &'ll llvm::Module) -> ValueIter<'ll> {
     }
 }
 
-pub fn compile_codegen_unit(tcx: TyCtxt<'tcx>, cgu_name: InternedString) {
+pub fn compile_codegen_unit(
+    tcx: TyCtxt<'tcx>,
+    cgu_name: InternedString,
+    tx_to_llvm_workers: &std::sync::mpsc::Sender<Box<dyn std::any::Any + Send>>,
+) {
     let start_time = Instant::now();
 
     let dep_node = tcx.codegen_unit(cgu_name).codegen_dep_node(tcx);
@@ -121,7 +125,7 @@ pub fn compile_codegen_unit(tcx: TyCtxt<'tcx>, cgu_name: InternedString) {
     let cost = time_to_codegen.as_secs() * 1_000_000_000 +
                time_to_codegen.subsec_nanos() as u64;
 
-    submit_codegened_module_to_llvm(&LlvmCodegenBackend(()), tcx, module, cost);
+    submit_codegened_module_to_llvm(&LlvmCodegenBackend(()), tx_to_llvm_workers, module, cost);
 
     fn module_codegen(
         tcx: TyCtxt<'_>,
diff --git a/src/librustc_codegen_llvm/lib.rs b/src/librustc_codegen_llvm/lib.rs
index 34e39af3c39..2a63011c2f5 100644
--- a/src/librustc_codegen_llvm/lib.rs
+++ b/src/librustc_codegen_llvm/lib.rs
@@ -52,7 +52,7 @@ use syntax::ext::allocator::AllocatorKind;
 use syntax_pos::symbol::InternedString;
 pub use llvm_util::target_features;
 use std::any::Any;
-use std::sync::{mpsc, Arc};
+use std::sync::Arc;
 use std::ffi::CStr;
 
 use rustc::dep_graph::DepGraph;
@@ -122,8 +122,12 @@ impl ExtraBackendMethods for LlvmCodegenBackend {
     ) {
         unsafe { allocator::codegen(tcx, mods, kind) }
     }
-    fn compile_codegen_unit(&self, tcx: TyCtxt<'_>, cgu_name: InternedString) {
-        base::compile_codegen_unit(tcx, cgu_name);
+    fn compile_codegen_unit(
+        &self, tcx: TyCtxt<'_>,
+        cgu_name: InternedString,
+        tx: &std::sync::mpsc::Sender<Box<dyn Any + Send>>,
+    ) {
+        base::compile_codegen_unit(tcx, cgu_name, tx);
     }
     fn target_machine_factory(
         &self,
@@ -284,10 +288,9 @@ impl CodegenBackend for LlvmCodegenBackend {
         tcx: TyCtxt<'tcx>,
         metadata: EncodedMetadata,
         need_metadata_module: bool,
-        rx: mpsc::Receiver<Box<dyn Any + Send>>,
     ) -> Box<dyn Any> {
         box rustc_codegen_ssa::base::codegen_crate(
-            LlvmCodegenBackend(()), tcx, metadata, need_metadata_module, rx)
+            LlvmCodegenBackend(()), tcx, metadata, need_metadata_module)
     }
 
     fn join_codegen_and_link(
diff --git a/src/librustc_codegen_ssa/back/write.rs b/src/librustc_codegen_ssa/back/write.rs
index 1a2c23ae0d4..3c5fbfd0f86 100644
--- a/src/librustc_codegen_ssa/back/write.rs
+++ b/src/librustc_codegen_ssa/back/write.rs
@@ -376,9 +376,9 @@ pub fn start_async_codegen<B: ExtraBackendMethods>(
     backend: B,
     tcx: TyCtxt<'_>,
     metadata: EncodedMetadata,
-    coordinator_receive: Receiver<Box<dyn Any + Send>>,
     total_cgus: usize,
 ) -> OngoingCodegen<B> {
+    let (coordinator_send, coordinator_receive) = channel();
     let sess = tcx.sess;
     let crate_name = tcx.crate_name(LOCAL_CRATE);
     let crate_hash = tcx.crate_hash(LOCAL_CRATE);
@@ -500,7 +500,8 @@ pub fn start_async_codegen<B: ExtraBackendMethods>(
                                                   sess.jobserver.clone(),
                                                   Arc::new(modules_config),
                                                   Arc::new(metadata_config),
-                                                  Arc::new(allocator_config));
+                                                  Arc::new(allocator_config),
+                                                  coordinator_send.clone());
 
     OngoingCodegen {
         backend,
@@ -511,7 +512,7 @@ pub fn start_async_codegen<B: ExtraBackendMethods>(
         linker_info,
         crate_info,
 
-        coordinator_send: tcx.tx_to_llvm_workers.lock().clone(),
+        coordinator_send,
         codegen_worker_receive,
         shared_emitter_main,
         future: coordinator_thread,
@@ -1005,8 +1006,9 @@ fn start_executing_work<B: ExtraBackendMethods>(
     modules_config: Arc<ModuleConfig>,
     metadata_config: Arc<ModuleConfig>,
     allocator_config: Arc<ModuleConfig>,
+    tx_to_llvm_workers: Sender<Box<dyn Any + Send>>,
 ) -> thread::JoinHandle<Result<CompiledModules, ()>> {
-    let coordinator_send = tcx.tx_to_llvm_workers.lock().clone();
+    let coordinator_send = tx_to_llvm_workers;
     let sess = tcx.sess;
 
     // Compute the set of symbols we need to retain when doing LTO (if we need to)
@@ -1857,7 +1859,7 @@ impl<B: ExtraBackendMethods> OngoingCodegen<B> {
 
         // These are generally cheap and won't throw off scheduling.
         let cost = 0;
-        submit_codegened_module_to_llvm(&self.backend, tcx, module, cost);
+        submit_codegened_module_to_llvm(&self.backend, &self.coordinator_send, module, cost);
     }
 
     pub fn codegen_finished(&self, tcx: TyCtxt<'_>) {
@@ -1899,12 +1901,12 @@ impl<B: ExtraBackendMethods> OngoingCodegen<B> {
 
 pub fn submit_codegened_module_to_llvm<B: ExtraBackendMethods>(
     _backend: &B,
-    tcx: TyCtxt<'_>,
+    tx_to_llvm_workers: &Sender<Box<dyn Any + Send>>,
     module: ModuleCodegen<B::Module>,
     cost: u64,
 ) {
     let llvm_work_item = WorkItem::Optimize(module);
-    drop(tcx.tx_to_llvm_workers.lock().send(Box::new(Message::CodegenDone::<B> {
+    drop(tx_to_llvm_workers.send(Box::new(Message::CodegenDone::<B> {
         llvm_work_item,
         cost,
     })));
@@ -1912,11 +1914,11 @@ pub fn submit_codegened_module_to_llvm<B: ExtraBackendMethods>(
 
 pub fn submit_post_lto_module_to_llvm<B: ExtraBackendMethods>(
     _backend: &B,
-    tcx: TyCtxt<'_>,
+    tx_to_llvm_workers: &Sender<Box<dyn Any + Send>>,
     module: CachedModuleCodegen,
 ) {
     let llvm_work_item = WorkItem::CopyPostLtoArtifacts(module);
-    drop(tcx.tx_to_llvm_workers.lock().send(Box::new(Message::CodegenDone::<B> {
+    drop(tx_to_llvm_workers.send(Box::new(Message::CodegenDone::<B> {
         llvm_work_item,
         cost: 0,
     })));
@@ -1925,6 +1927,7 @@ pub fn submit_post_lto_module_to_llvm<B: ExtraBackendMethods>(
 pub fn submit_pre_lto_module_to_llvm<B: ExtraBackendMethods>(
     _backend: &B,
     tcx: TyCtxt<'_>,
+    tx_to_llvm_workers: &Sender<Box<dyn Any + Send>>,
     module: CachedModuleCodegen,
 ) {
     let filename = pre_lto_bitcode_filename(&module.name);
@@ -1939,7 +1942,7 @@ pub fn submit_pre_lto_module_to_llvm<B: ExtraBackendMethods>(
         })
     };
     // Schedule the module to be loaded
-    drop(tcx.tx_to_llvm_workers.lock().send(Box::new(Message::AddImportOnlyModule::<B> {
+    drop(tx_to_llvm_workers.send(Box::new(Message::AddImportOnlyModule::<B> {
         module_data: SerializedModule::FromUncompressedFile(mmap),
         work_product: module.source,
     })));
diff --git a/src/librustc_codegen_ssa/base.rs b/src/librustc_codegen_ssa/base.rs
index 8f7f769f6b9..90ed629bbc6 100644
--- a/src/librustc_codegen_ssa/base.rs
+++ b/src/librustc_codegen_ssa/base.rs
@@ -43,11 +43,9 @@ use crate::mir;
 
 use crate::traits::*;
 
-use std::any::Any;
 use std::cmp;
 use std::ops::{Deref, DerefMut};
 use std::time::{Instant, Duration};
-use std::sync::mpsc;
 use syntax_pos::Span;
 use syntax::attr;
 use rustc::hir;
@@ -482,19 +480,13 @@ pub fn codegen_crate<B: ExtraBackendMethods>(
     tcx: TyCtxt<'tcx>,
     metadata: EncodedMetadata,
     need_metadata_module: bool,
-    rx: mpsc::Receiver<Box<dyn Any + Send>>,
 ) -> OngoingCodegen<B> {
     check_for_rustc_errors_attr(tcx);
 
     // Skip crate items and just output metadata in -Z no-codegen mode.
     if tcx.sess.opts.debugging_opts.no_codegen ||
        !tcx.sess.opts.output_types.should_codegen() {
-        let ongoing_codegen = start_async_codegen(
-            backend,
-            tcx,
-            metadata,
-            rx,
-            1);
+        let ongoing_codegen = start_async_codegen(backend, tcx, metadata, 1);
 
         ongoing_codegen.codegen_finished(tcx);
 
@@ -523,12 +515,7 @@ pub fn codegen_crate<B: ExtraBackendMethods>(
         }
     }
 
-    let ongoing_codegen = start_async_codegen(
-        backend.clone(),
-        tcx,
-        metadata,
-        rx,
-        codegen_units.len());
+    let ongoing_codegen = start_async_codegen(backend.clone(), tcx, metadata, codegen_units.len());
     let ongoing_codegen = AbortCodegenOnDrop::<B>(Some(ongoing_codegen));
 
     // Codegen an allocator shim, if necessary.
@@ -614,20 +601,22 @@ pub fn codegen_crate<B: ExtraBackendMethods>(
             CguReuse::No => {
                 tcx.sess.profiler(|p| p.start_activity(format!("codegen {}", cgu.name())));
                 let start_time = Instant::now();
-                backend.compile_codegen_unit(tcx, *cgu.name());
+                backend.compile_codegen_unit(tcx, *cgu.name(), &ongoing_codegen.coordinator_send);
                 total_codegen_time += start_time.elapsed();
                 tcx.sess.profiler(|p| p.end_activity(format!("codegen {}", cgu.name())));
                 false
             }
             CguReuse::PreLto => {
-                submit_pre_lto_module_to_llvm(&backend, tcx, CachedModuleCodegen {
+                submit_pre_lto_module_to_llvm(&backend, tcx, &ongoing_codegen.coordinator_send,
+                CachedModuleCodegen {
                     name: cgu.name().to_string(),
                     source: cgu.work_product(tcx),
                 });
                 true
             }
             CguReuse::PostLto => {
-                submit_post_lto_module_to_llvm(&backend, tcx, CachedModuleCodegen {
+                submit_post_lto_module_to_llvm(&backend, &ongoing_codegen.coordinator_send,
+                CachedModuleCodegen {
                     name: cgu.name().to_string(),
                     source: cgu.work_product(tcx),
                 });
diff --git a/src/librustc_codegen_ssa/traits/backend.rs b/src/librustc_codegen_ssa/traits/backend.rs
index 9fbb44dcc99..cb197f51460 100644
--- a/src/librustc_codegen_ssa/traits/backend.rs
+++ b/src/librustc_codegen_ssa/traits/backend.rs
@@ -8,6 +8,7 @@ use rustc::session::{Session, config};
 use rustc::ty::TyCtxt;
 use rustc_codegen_utils::codegen_backend::CodegenBackend;
 use std::sync::Arc;
+use std::sync::mpsc;
 use syntax::ext::allocator::AllocatorKind;
 use syntax_pos::symbol::InternedString;
 
@@ -44,7 +45,12 @@ pub trait ExtraBackendMethods: CodegenBackend + WriteBackendMethods + Sized + Se
         mods: &mut Self::Module,
         kind: AllocatorKind,
     );
-    fn compile_codegen_unit(&self, tcx: TyCtxt<'_>, cgu_name: InternedString);
+    fn compile_codegen_unit(
+        &self,
+        tcx: TyCtxt<'_>,
+        cgu_name: InternedString,
+        tx_to_llvm_workers: &mpsc::Sender<Box<dyn std::any::Any + Send>>,
+    );
     // If find_features is true this won't access `sess.crate_types` by assuming
     // that `is_pie_binary` is false. When we discover LLVM target features
     // `sess.crate_types` is uninitialized so we cannot access it.
diff --git a/src/librustc_codegen_utils/codegen_backend.rs b/src/librustc_codegen_utils/codegen_backend.rs
index 262cfb1658e..2e3af8431ee 100644
--- a/src/librustc_codegen_utils/codegen_backend.rs
+++ b/src/librustc_codegen_utils/codegen_backend.rs
@@ -7,7 +7,6 @@
 #![doc(html_root_url = "https://doc.rust-lang.org/nightly/")]
 
 use std::any::Any;
-use std::sync::mpsc;
 
 use syntax::symbol::Symbol;
 use rustc::session::Session;
@@ -36,7 +35,6 @@ pub trait CodegenBackend {
         tcx: TyCtxt<'tcx>,
         metadata: EncodedMetadata,
         need_metadata_module: bool,
-        rx: mpsc::Receiver<Box<dyn Any + Send>>,
     ) -> Box<dyn Any>;
 
     /// This is called on the returned `Box<dyn Any>` from `codegen_backend`
diff --git a/src/librustc_interface/passes.rs b/src/librustc_interface/passes.rs
index 37b33466d70..6abc6e32d24 100644
--- a/src/librustc_interface/passes.rs
+++ b/src/librustc_interface/passes.rs
@@ -54,7 +54,6 @@ use std::fs;
 use std::io::{self, Write};
 use std::iter;
 use std::path::PathBuf;
-use std::sync::mpsc;
 use std::cell::RefCell;
 use std::rc::Rc;
 
@@ -816,7 +815,6 @@ pub fn create_global_ctxt(
     defs: hir::map::Definitions,
     resolutions: Resolutions,
     outputs: OutputFilenames,
-    tx: mpsc::Sender<Box<dyn Any + Send>>,
     crate_name: &str,
 ) -> BoxedGlobalCtxt {
     let sess = compiler.session().clone();
@@ -858,7 +856,6 @@ pub fn create_global_ctxt(
             hir_map,
             query_result_on_disk_cache,
             &crate_name,
-            tx,
             &outputs
         );
 
@@ -1068,7 +1065,6 @@ fn encode_and_write_metadata(
 pub fn start_codegen<'tcx>(
     codegen_backend: &dyn CodegenBackend,
     tcx: TyCtxt<'tcx>,
-    rx: mpsc::Receiver<Box<dyn Any + Send>>,
     outputs: &OutputFilenames,
 ) -> Box<dyn Any> {
     if log_enabled!(::log::Level::Info) {
@@ -1082,7 +1078,7 @@ pub fn start_codegen<'tcx>(
 
     tcx.sess.profiler(|p| p.start_activity("codegen crate"));
     let codegen = time(tcx.sess, "codegen", move || {
-        codegen_backend.codegen_crate(tcx, metadata, need_metadata_module, rx)
+        codegen_backend.codegen_crate(tcx, metadata, need_metadata_module)
     });
     tcx.sess.profiler(|p| p.end_activity("codegen crate"));
 
diff --git a/src/librustc_interface/queries.rs b/src/librustc_interface/queries.rs
index ff5cd8b8c69..cd72dc9453c 100644
--- a/src/librustc_interface/queries.rs
+++ b/src/librustc_interface/queries.rs
@@ -10,7 +10,6 @@ use rustc::ty::steal::Steal;
 use rustc::dep_graph::DepGraph;
 use std::cell::{Ref, RefMut, RefCell};
 use std::rc::Rc;
-use std::sync::mpsc;
 use std::any::Any;
 use std::mem;
 use syntax::{self, ast};
@@ -80,8 +79,6 @@ pub(crate) struct Queries {
     dep_graph: Query<DepGraph>,
     lower_to_hir: Query<(Steal<hir::map::Forest>, ExpansionResult)>,
     prepare_outputs: Query<OutputFilenames>,
-    codegen_channel: Query<(Steal<mpsc::Sender<Box<dyn Any + Send>>>,
-                            Steal<mpsc::Receiver<Box<dyn Any + Send>>>)>,
     global_ctxt: Query<BoxedGlobalCtxt>,
     ongoing_codegen: Query<Box<dyn Any>>,
     link: Query<()>,
@@ -211,14 +208,6 @@ impl Compiler {
         })
     }
 
-    pub fn codegen_channel(&self) -> Result<&Query<(Steal<mpsc::Sender<Box<dyn Any + Send>>>,
-                                                    Steal<mpsc::Receiver<Box<dyn Any + Send>>>)>> {
-        self.queries.codegen_channel.compute(|| {
-            let (tx, rx) = mpsc::channel();
-            Ok((Steal::new(tx), Steal::new(rx)))
-        })
-    }
-
     pub fn global_ctxt(&self) -> Result<&Query<BoxedGlobalCtxt>> {
         self.queries.global_ctxt.compute(|| {
             let crate_name = self.crate_name()?.peek().clone();
@@ -226,21 +215,18 @@ impl Compiler {
             let hir = self.lower_to_hir()?;
             let hir = hir.peek();
             let (ref hir_forest, ref expansion) = *hir;
-            let tx = self.codegen_channel()?.peek().0.steal();
             Ok(passes::create_global_ctxt(
                 self,
                 hir_forest.steal(),
                 expansion.defs.steal(),
                 expansion.resolutions.steal(),
                 outputs,
-                tx,
                 &crate_name))
         })
     }
 
     pub fn ongoing_codegen(&self) -> Result<&Query<Box<dyn Any>>> {
         self.queries.ongoing_codegen.compute(|| {
-            let rx = self.codegen_channel()?.peek().1.steal();
             let outputs = self.prepare_outputs()?;
             self.global_ctxt()?.peek_mut().enter(|tcx| {
                 tcx.analysis(LOCAL_CRATE).ok();
@@ -251,7 +237,6 @@ impl Compiler {
                 Ok(passes::start_codegen(
                     &***self.codegen_backend(),
                     tcx,
-                    rx,
                     &*outputs.peek()
                 ))
             })
diff --git a/src/test/run-make-fulldeps/hotplug_codegen_backend/the_backend.rs b/src/test/run-make-fulldeps/hotplug_codegen_backend/the_backend.rs
index ec1868f32d4..c1bcb8a1aa2 100644
--- a/src/test/run-make-fulldeps/hotplug_codegen_backend/the_backend.rs
+++ b/src/test/run-make-fulldeps/hotplug_codegen_backend/the_backend.rs
@@ -64,7 +64,6 @@ impl CodegenBackend for TheBackend {
         tcx: TyCtxt<'tcx>,
         _metadata: EncodedMetadata,
         _need_metadata_module: bool,
-        _rx: mpsc::Receiver<Box<Any + Send>>
     ) -> Box<Any> {
         use rustc::hir::def_id::LOCAL_CRATE;