Move query TLS to rustc_query_system.

Author: cjgillot

Cargo.lock

@@ -3883,6 +3883,7 @@ dependencies = [
  "rustc_plugin_impl",
  "rustc_privacy",
  "rustc_query_impl",
+ "rustc_query_system",
  "rustc_resolve",
  "rustc_serialize",
  "rustc_session",

compiler/rustc_interface/Cargo.toml

@@ -43,6 +43,7 @@ rustc_lint = { path = "../rustc_lint" }
 rustc_errors = { path = "../rustc_errors" }
 rustc_plugin_impl = { path = "../rustc_plugin_impl" }
 rustc_privacy = { path = "../rustc_privacy" }
+rustc_query_system = { path = "../rustc_query_system" }
 rustc_query_impl = { path = "../rustc_query_impl" }
 rustc_resolve = { path = "../rustc_resolve" }
 rustc_trait_selection = { path = "../rustc_trait_selection" }

compiler/rustc_interface/src/callbacks.rs

@@ -9,7 +9,6 @@
 //! The functions in this file should fall back to the default set in their
 //! origin crate when the `TyCtxt` is not present in TLS.
 
-use rustc_errors::{Diagnostic, TRACK_DIAGNOSTICS};
 use rustc_middle::ty::tls;
 use std::fmt;
 
@@ -23,20 +22,6 @@ fn track_span_parent(def_id: rustc_span::def_id::LocalDefId) {
  })
 }
 
-/// This is a callback from `rustc_ast` as it cannot access the implicit state
-/// in `rustc_middle` otherwise. It is used to when diagnostic messages are
-/// emitted and stores them in the current query, if there is one.
-fn track_diagnostic(diagnostic: &Diagnostic) {
- tls::with_context_opt(|icx| {
- if let Some(icx) = icx {
- if let Some(diagnostics) = icx.diagnostics {
- let mut diagnostics = diagnostics.lock();
- diagnostics.extend(Some(diagnostic.clone()));
- }
- }
- })
-}
-
 /// This is a callback from `rustc_hir` as it cannot access the implicit state
 /// in `rustc_middle` otherwise.
 fn def_id_debug(def_id: rustc_hir::def_id::DefId, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -55,5 +40,5 @@ fn def_id_debug(def_id: rustc_hir::def_id::DefId, f: &mut fmt::Formatter<'_>) ->
 pub fn setup_callbacks() {
  rustc_span::SPAN_TRACK.swap(&(track_span_parent as fn(_)));
  rustc_hir::def_id::DEF_ID_DEBUG.swap(&(def_id_debug as fn(_, &mut fmt::Formatter<'_>) -> _));
- TRACK_DIAGNOSTICS.swap(&(track_diagnostic as fn(&_)));
+ rustc_errors::TRACK_DIAGNOSTICS.swap(&(rustc_query_system::tls::track_diagnostic as fn(&_)));
 }

compiler/rustc_interface/src/interface.rs

@@ -344,9 +344,9 @@ pub fn try_print_query_stack(handler: &Handler, num_frames: Option<usize>) {
  // Be careful relying on global state here: this code is called from
  // a panic hook, which means that the global `Handler` may be in a weird
  // state if it was responsible for triggering the panic.
- let i = ty::tls::with_context_opt(|icx| {
- if let Some(icx) = icx {
- QueryCtxt::from_tcx(icx.tcx).try_print_query_stack(icx.query, handler, num_frames)
+ let i = ty::tls::with_opt(|tcx| {
+ if let Some(tcx) = tcx {
+ QueryCtxt::from_tcx(tcx).try_print_query_stack(handler, num_frames)
  } else {
  0
  }

compiler/rustc_interface/src/passes.rs

@@ -806,13 +806,12 @@ pub struct QueryContext<'tcx> {
  gcx: &'tcx GlobalCtxt<'tcx>,
 }
 
-impl<'tcx> QueryContext<'tcx> {
+impl<'gcx> QueryContext<'gcx> {
  pub fn enter<F, R>(&mut self, f: F) -> R
  where
- F: FnOnce(TyCtxt<'tcx>) -> R,
+ F: for<'tcx> FnOnce(TyCtxt<'tcx>) -> R,
  {
- let icx = ty::tls::ImplicitCtxt::new(self.gcx);
- ty::tls::enter_context(&icx, |_| f(icx.tcx))
+ ty::tls::enter_context(self.gcx, f)
  }
 }
 

compiler/rustc_interface/src/util.rs

@@ -7,7 +7,7 @@ use rustc_data_structures::jobserver;
 use rustc_data_structures::sync::Lrc;
 use rustc_errors::registry::Registry;
 #[cfg(parallel_compiler)]
-use rustc_middle::ty::tls;
+use rustc_middle::ty::{tls, GlobalCtxt};
 use rustc_parse::validate_attr;
 #[cfg(parallel_compiler)]
 use rustc_query_impl::QueryCtxt;
@@ -166,19 +166,21 @@ pub fn run_in_thread_pool_with_globals<F: FnOnce() -> R + Send, R: Send>(
 unsafe fn handle_deadlock() {
  let registry = rustc_rayon_core::Registry::current();
 
- let context = tls::get_tlv();
- assert!(context != 0);
- rustc_data_structures::sync::assert_sync::<tls::ImplicitCtxt<'_, '_>>();
- let icx: &tls::ImplicitCtxt<'_, '_> = &*(context as *const tls::ImplicitCtxt<'_, '_>);
+ // We do not need to copy the query ImplicitCtxt since this deadlock handler is not part of a
+ // normal query invocation.
 
  let session_globals = rustc_span::with_session_globals(|sg| sg as *const _);
  let session_globals = &*session_globals;
+
+ // Extend the lifetime of the GlobalCtxt so the new thread can know of it.
+ // The current thread will not free it, it is deadlocked.
+ let tcx: &'static GlobalCtxt<'static> =
+ tls::with(|tcx| &*(*tcx as *const GlobalCtxt<'_>).cast());
+
  thread::spawn(move || {
- tls::enter_context(icx, |_| {
- rustc_span::set_session_globals_then(session_globals, || {
- tls::with(|tcx| QueryCtxt::from_tcx(tcx).deadlock(&registry))
- })
- });
+ rustc_span::set_session_globals_then(session_globals, || {
+ tls::enter_context(tcx, |tcx| QueryCtxt::from_tcx(tcx).deadlock(&registry))
+ })
  });
 }
 

compiler/rustc_middle/src/dep_graph/dep_node.rs

@@ -216,6 +216,8 @@ static_assert_size!(DepNode, 18);
 #[cfg(not(any(target_arch = "x86", target_arch = "x86_64")))]
 static_assert_size!(DepNode, 24);
 
+static_assert_size!(DepKind, 2);
+
 pub trait DepNodeExt: Sized {
  /// Construct a DepNode from the given DepKind and DefPathHash. This
  /// method will assert that the given DepKind actually requires a

compiler/rustc_middle/src/dep_graph/mod.rs

@@ -44,27 +44,6 @@ impl rustc_query_system::dep_graph::DepKind for DepKind {
 
  write!(f, ")")
  }
-
- fn with_deps<OP, R>(task_deps: TaskDepsRef<'_>, op: OP) -> R
- where
- OP: FnOnce() -> R,
- {
- ty::tls::with_context(|icx| {
- let icx = ty::tls::ImplicitCtxt { task_deps, ..icx.clone() };
-
- ty::tls::enter_context(&icx, |_| op())
- })
- }
-
- fn read_deps<OP>(op: OP)
- where
- OP: for<'a> FnOnce(TaskDepsRef<'a>),
- {
- ty::tls::with_context_opt(|icx| {
- let Some(icx) = icx else { return };
- op(icx.task_deps)
- })
- }
 }
 
 impl<'tcx> DepContext for TyCtxt<'tcx> {

compiler/rustc_middle/src/hir/map/mod.rs

@@ -1156,18 +1156,8 @@ fn hir_id_to_string(map: Map<'_>, id: HirId) -> String {
  let id_str = format!(" (hir_id={})", id);
 
  let path_str = || {
- // This functionality is used for debugging, try to use `TyCtxt` to get
- // the user-friendly path, otherwise fall back to stringifying `DefPath`.
- crate::ty::tls::with_opt(|tcx| {
- if let Some(tcx) = tcx {
- let def_id = map.local_def_id(id);
- tcx.def_path_str(def_id.to_def_id())
- } else if let Some(path) = map.def_path_from_hir_id(id) {
- path.data.into_iter().map(|elem| elem.to_string()).collect::<Vec<_>>().join("::")
- } else {
- String::from("<missing path>")
- }
- })
+ let def_id = map.local_def_id(id);
+ map.tcx.def_path_str(def_id.to_def_id())
  };
 
  let span_str = || map.tcx.sess.source_map().span_to_snippet(map.span(id)).unwrap_or_default();

compiler/rustc_middle/src/ty/context.rs

@@ -1682,155 +1682,61 @@ CloneLiftImpls! { for<'tcx> { Constness, traits::WellFormedLoc, } }
 
 pub mod tls {
  use super::{GlobalCtxt, TyCtxt};
-
- use crate::dep_graph::TaskDepsRef;
- use crate::ty::query;
- use rustc_data_structures::sync::{self, Lock};
- use rustc_data_structures::thin_vec::ThinVec;
- use rustc_errors::Diagnostic;
-
- #[cfg(not(parallel_compiler))]
+ use rustc_data_structures::sync;
  use std::cell::Cell;
 
- #[cfg(parallel_compiler)]
- use rustc_rayon_core as rayon_core;
-
- /// This is the implicit state of rustc. It contains the current
- /// `TyCtxt` and query. It is updated when creating a local interner or
- /// executing a new query. Whenever there's a `TyCtxt` value available
- /// you should also have access to an `ImplicitCtxt` through the functions
- /// in this module.
- #[derive(Clone)]
- pub struct ImplicitCtxt<'a, 'tcx> {
- /// The current `TyCtxt`.
- pub tcx: TyCtxt<'tcx>,
-
- /// The current query job, if any. This is updated by `JobOwner::start` in
- /// `ty::query::plumbing` when executing a query.
- pub query: Option<query::QueryJobId>,
-
- /// Where to store diagnostics for the current query job, if any.
- /// This is updated by `JobOwner::start` in `ty::query::plumbing` when executing a query.
- pub diagnostics: Option<&'a Lock<ThinVec<Diagnostic>>>,
-
- /// Used to prevent layout from recursing too deeply.
- pub layout_depth: usize,
-
- /// The current dep graph task. This is used to add dependencies to queries
- /// when executing them.
- pub task_deps: TaskDepsRef<'a>,
- }
-
- impl<'a, 'tcx> ImplicitCtxt<'a, 'tcx> {
- pub fn new(gcx: &'tcx GlobalCtxt<'tcx>) -> Self {
- let tcx = TyCtxt { gcx };
- ImplicitCtxt {
- tcx,
- query: None,
- diagnostics: None,
- layout_depth: 0,
- task_deps: TaskDepsRef::Ignore,
- }
- }
- }
-
- /// Sets Rayon's thread-local variable, which is preserved for Rayon jobs
- /// to `value` during the call to `f`. It is restored to its previous value after.
- /// This is used to set the pointer to the new `ImplicitCtxt`.
- #[cfg(parallel_compiler)]
- #[inline]
- fn set_tlv<F: FnOnce() -> R, R>(value: usize, f: F) -> R {
- rayon_core::tlv::with(value, f)
- }
-
- /// Gets Rayon's thread-local variable, which is preserved for Rayon jobs.
- /// This is used to get the pointer to the current `ImplicitCtxt`.
- #[cfg(parallel_compiler)]
- #[inline]
- pub fn get_tlv() -> usize {
- rayon_core::tlv::get()
- }
-
- #[cfg(not(parallel_compiler))]
  thread_local! {
- /// A thread local variable that stores a pointer to the current `ImplicitCtxt`.
- static TLV: Cell<usize> = const { Cell::new(0) };
- }
-
- /// Sets TLV to `value` during the call to `f`.
- /// It is restored to its previous value after.
- /// This is used to set the pointer to the new `ImplicitCtxt`.
- #[cfg(not(parallel_compiler))]
- #[inline]
- fn set_tlv<F: FnOnce() -> R, R>(value: usize, f: F) -> R {
- let old = get_tlv();
- let _reset = rustc_data_structures::OnDrop(move || TLV.with(|tlv| tlv.set(old)));
- TLV.with(|tlv| tlv.set(value));
- f()
- }
-
- /// Gets the pointer to the current `ImplicitCtxt`.
- #[cfg(not(parallel_compiler))]
- #[inline]
- fn get_tlv() -> usize {
- TLV.with(|tlv| tlv.get())
+ /// This is the implicit state of rustc. It contains the `TyCtxt`. Whenever there's a
+ /// `TyCtxt` value available you should also have access to it through the functions in this
+ /// module.
+ static TLV: Cell<*const GlobalCtxt<'static>> = const { Cell::new(std::ptr::null()) };
  }
 
- /// Sets `context` as the new current `ImplicitCtxt` for the duration of the function `f`.
+ /// Sets `context` as the new current `TyCtxt` for the duration of the function `f`.
  #[inline]
- pub fn enter_context<'a, 'tcx, F, R>(context: &ImplicitCtxt<'a, 'tcx>, f: F) -> R
+ pub fn enter_context<'gcx, F, R>(gcx: &'gcx GlobalCtxt<'gcx>, f: F) -> R
  where
- F: FnOnce(&ImplicitCtxt<'a, 'tcx>) -> R,
- {
- set_tlv(context as *const _ as usize, || f(&context))
- }
-
- /// Allows access to the current `ImplicitCtxt` in a closure if one is available.
- #[inline]
- pub fn with_context_opt<F, R>(f: F) -> R
- where
- F: for<'a, 'tcx> FnOnce(Option<&ImplicitCtxt<'a, 'tcx>>) -> R,
+ F: for<'tcx> FnOnce(TyCtxt<'tcx>) -> R,
  {
- let context = get_tlv();
- if context == 0 {
- f(None)
- } else {
- // We could get an `ImplicitCtxt` pointer from another thread.
- // Ensure that `ImplicitCtxt` is `Sync`.
- sync::assert_sync::<ImplicitCtxt<'_, '_>>();
-
- unsafe { f(Some(&*(context as *const ImplicitCtxt<'_, '_>))) }
- }
- }
+ // We are storing `GlobalCtxt` as a global.
+ // Ensure that it is `Sync`.
+ sync::assert_sync::<GlobalCtxt<'_>>();
 
- /// Allows access to the current `ImplicitCtxt`.
- /// Panics if there is no `ImplicitCtxt` available.
- #[inline]
- pub fn with_context<F, R>(f: F) -> R
- where
- F: for<'a, 'tcx> FnOnce(&ImplicitCtxt<'a, 'tcx>) -> R,
- {
- with_context_opt(|opt_context| f(opt_context.expect("no ImplicitCtxt stored in tls")))
+  let address = (gcx as *const GlobalCtxt<'_>).cast();
+  let old = TLV.with(|tlv| tlv.replace(address));
+  let _reset = rustc_data_structures::OnDrop(move || TLV.with(|tlv| tlv.set(old)));
+  debug_assert!(
+  old == address || old == std::ptr::null(),
+  "There can only be one GlobalCtxt."
+  );
+ f(TyCtxt { gcx })
  }
 
- /// Allows access to the `TyCtxt` in the current `ImplicitCtxt`.
- /// Panics if there is no `ImplicitCtxt` available.
+ /// Allows access to the current `TyCtxt`.
+ /// Panics if there is no `TyCtxt` available.
  #[inline]
  pub fn with<F, R>(f: F) -> R
  where
  F: for<'tcx> FnOnce(TyCtxt<'tcx>) -> R,
  {
- with_context(|context| f(context.tcx))
+ with_opt(|opt_tcx| f(opt_tcx.expect("no TyCtxt stored in tls")))
  }
 
- /// Allows access to the `TyCtxt` in the current `ImplicitCtxt`.
- /// The closure is passed None if there is no `ImplicitCtxt` available.
+ /// Allows access to the current `TyCtxt`.
+ /// The closure is passed None if there is no `TyCtxt` available.
  #[inline]
  pub fn with_opt<F, R>(f: F) -> R
  where
  F: for<'tcx> FnOnce(Option<TyCtxt<'tcx>>) -> R,
  {
- with_context_opt(|opt_context| f(opt_context.map(|context| context.tcx)))
+ let context = TLV.with(|tlv| tlv.get());
+ let tcx = if context == std::ptr::null() {
+ None
+ } else {
+ let gcx = unsafe { &*context.cast::<GlobalCtxt<'_>>() };
+ Some(TyCtxt { gcx })
+ };
+ f(tcx)
  }
 }