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)
     }
 }