Revive GCX_PTR

Cargo.lock

@@ -4033,6 +4033,7 @@ dependencies = [
  "rustc_span",
  "rustc_target",
  "rustc_type_ir",
+ "scoped-tls",
  "smallvec",
  "thin-vec",
  "tracing",

compiler/rustc_interface/src/util.rs

@@ -185,7 +185,7 @@ pub(crate) fn run_in_thread_pool_with_globals<F: FnOnce() -> R + Send, R: Send>(
  f: F,
 ) -> R {
  use rustc_data_structures::{jobserver, sync::FromDyn};
- use rustc_middle::ty::tls;
+ use rustc_middle::ty::tls::{self, GcxPtr};
  use rustc_query_impl::QueryCtxt;
  use rustc_query_system::query::{deadlock, QueryContext};
 
@@ -208,18 +208,34 @@ pub(crate) fn run_in_thread_pool_with_globals<F: FnOnce() -> R + Send, R: Send>(
  .deadlock_handler(|| {
  // On deadlock, creates a new thread and forwards information in thread
  // locals to it. The new thread runs the deadlock handler.
- let query_map = FromDyn::from(tls::with(|tcx| {
- QueryCtxt::new(tcx)
- .try_collect_active_jobs()
- .expect("active jobs shouldn't be locked in deadlock handler")
- }));
+ let query_map = FromDyn::from({
+ // Get a GlobalCtxt reference from GCX_PTR as we cannot rely on having a TyCtxt TLS
+ // reference here.
+ // SAFETY: No thread will end the lifetime of `GlobalCtxt` as they're deadlocked
+ // and won't resume until the `deadlock` call.
+ unsafe {
+ tls::GCX_PTR.with(|gcx_ptr| {
+ gcx_ptr.access(|gcx| {
+ tls::enter_context(&tls::ImplicitCtxt::new(gcx), || {
+ tls::with(|tcx| {
+ QueryCtxt::new(tcx).try_collect_active_jobs().expect(
+ "active jobs shouldn't be locked in deadlock handler",
+ )
+ })
+ })
+ })
+ })
+ }
+ });
  let registry = rayon_core::Registry::current();
  thread::spawn(move || deadlock(query_map.into_inner(), &registry));
  });
  if let Some(size) = get_stack_size() {
  builder = builder.stack_size(size);
  }
 
+ let gcx_ptr = GcxPtr::new();
+
  // We create the session globals on the main thread, then create the thread
  // pool. Upon creation, each worker thread created gets a copy of the
  // session globals in TLS. This is possible because `SessionGlobals` impls
@@ -235,7 +251,7 @@ pub(crate) fn run_in_thread_pool_with_globals<F: FnOnce() -> R + Send, R: Send>(
  registry.register();
 
  rustc_span::set_session_globals_then(session_globals.into_inner(), || {
- thread.run()
+ tls::GCX_PTR.set(&gcx_ptr, || thread.run())
  })
  },
  // Run `f` on the first thread in the thread pool.

compiler/rustc_middle/Cargo.toml

@@ -35,6 +35,7 @@ rustc_session = { path = "../rustc_session" }
 rustc_span = { path = "../rustc_span" }
 rustc_target = { path = "../rustc_target" }
 rustc_type_ir = { path = "../rustc_type_ir" }
+scoped-tls = "1.0"
 smallvec = { version = "1.8.1", features = ["union", "may_dangle"] }
 thin-vec = "0.2.12"
 tracing = "0.1"

compiler/rustc_middle/src/ty/context.rs

@@ -590,7 +590,7 @@ impl<'tcx> GlobalCtxt<'tcx> {
  F: FnOnce(TyCtxt<'tcx>) -> R,
  {
  let icx = tls::ImplicitCtxt::new(self);
- tls::enter_context(&icx, || f(icx.tcx))
+ tls::enter_global_context(&icx, || f(icx.tcx))
  }
 }
 

compiler/rustc_middle/src/ty/context/tls.rs

@@ -2,6 +2,7 @@ use super::{GlobalCtxt, TyCtxt};
 
 use crate::dep_graph::TaskDepsRef;
 use crate::query::plumbing::QueryJobId;
+use rustc_data_structures::defer;
 use rustc_data_structures::sync::{self, Lock};
 use rustc_errors::Diagnostic;
 #[cfg(not(parallel_compiler))]
@@ -153,3 +154,51 @@ where
 {
  with_context_opt(|opt_context| f(opt_context.map(|context| context.tcx)))
 }
+
+/// Enters `GlobalCtxt` by setting up the `GCX_PTR` pointer.
+pub fn enter_global_context<'tcx, F, R>(context: &ImplicitCtxt<'_, 'tcx>, f: F) -> R
+where
+ F: FnOnce() -> R,
+{
+ if cfg!(parallel_compiler) && GCX_PTR.is_set() {
+ // Update `GCX_PTR` to indicate there's a `GlobalCtxt` available.
+ GCX_PTR.with(|gcx_ptr| {
+ let mut lock = gcx_ptr.value.lock();
+ assert!(lock.is_none());
+ *lock = Some(context.tcx.gcx as *const _ as *const ());
+ });
+ // Set `GCX_PTR` back to 0 when we exit.
+ let _on_drop = defer(move || {
+ GCX_PTR.with(|gcx_ptr| *gcx_ptr.value.lock() = None);
+ });
+ enter_context(context, f)
+ } else {
+ enter_context(context, f)
+ }
+}
+
+pub struct GcxPtr {
+ /// Stores a pointer to the `GlobalCtxt` if one is available.
+ /// This is used to access the `GlobalCtxt` in the deadlock handler given to Rayon.
+ value: Lock<Option<*const ()>>,
+}
+
+impl GcxPtr {
+ pub fn new() -> Self {
+ GcxPtr { value: Lock::new(None) }
+ }
+
+ /// This accesses the GlobalCtxt.
+ ///
+ /// Safety: The caller must ensure that the GlobalCtxt is live during `f`.
+ pub unsafe fn access<R>(&self, f: impl for<'tcx> FnOnce(&'tcx GlobalCtxt<'tcx>) -> R) -> R {
+ let gcx_ptr: *const GlobalCtxt<'_> = self.value.lock().unwrap() as *const _;
+ f(unsafe { &*gcx_ptr })
+ }
+}
+
+unsafe impl Sync for GcxPtr {}
+
+scoped_tls::scoped_thread_local! {
+ pub static GCX_PTR: GcxPtr
+}