Importing rustc-1.49.0
Bug: 176888219
Change-Id: Ib0805d37e7b485cd420bbff8a8b000cf87e7ede0
diff --git a/compiler/rustc_query_system/src/dep_graph/dep_node.rs b/compiler/rustc_query_system/src/dep_graph/dep_node.rs
index e302784..7808a28 100644
--- a/compiler/rustc_query_system/src/dep_graph/dep_node.rs
+++ b/compiler/rustc_query_system/src/dep_graph/dep_node.rs
@@ -165,10 +165,6 @@
cgu_name.hash(&mut hasher);
WorkProductId { hash: hasher.finish() }
}
-
- pub fn from_fingerprint(fingerprint: Fingerprint) -> WorkProductId {
- WorkProductId { hash: fingerprint }
- }
}
impl<HCX> HashStable<HCX> for WorkProductId {
diff --git a/compiler/rustc_query_system/src/dep_graph/graph.rs b/compiler/rustc_query_system/src/dep_graph/graph.rs
index d70306b..d9b687c 100644
--- a/compiler/rustc_query_system/src/dep_graph/graph.rs
+++ b/compiler/rustc_query_system/src/dep_graph/graph.rs
@@ -292,10 +292,8 @@
);
data.colors.insert(prev_index, color);
- } else {
- if print_status {
- eprintln!("[task::new] {:?}", key);
- }
+ } else if print_status {
+ eprintln!("[task::new] {:?}", key);
}
(result, dep_node_index)
@@ -402,11 +400,6 @@
self.data.as_ref().unwrap().previous.fingerprint_of(dep_node)
}
- #[inline]
- pub fn prev_dep_node_index_of(&self, dep_node: &DepNode<K>) -> SerializedDepNodeIndex {
- self.data.as_ref().unwrap().previous.node_to_index(dep_node)
- }
-
/// Checks whether a previous work product exists for `v` and, if
/// so, return the path that leads to it. Used to skip doing work.
pub fn previous_work_product(&self, v: &WorkProductId) -> Option<WorkProduct> {
diff --git a/compiler/rustc_query_system/src/dep_graph/query.rs b/compiler/rustc_query_system/src/dep_graph/query.rs
index fb313d2..a27b716 100644
--- a/compiler/rustc_query_system/src/dep_graph/query.rs
+++ b/compiler/rustc_query_system/src/dep_graph/query.rs
@@ -1,7 +1,5 @@
use rustc_data_structures::fx::FxHashMap;
-use rustc_data_structures::graph::implementation::{
- Direction, Graph, NodeIndex, INCOMING, OUTGOING,
-};
+use rustc_data_structures::graph::implementation::{Direction, Graph, NodeIndex, INCOMING};
use super::{DepKind, DepNode};
@@ -52,23 +50,8 @@
}
}
- /// All nodes reachable from `node`. In other words, things that
- /// will have to be recomputed if `node` changes.
- pub fn transitive_successors(&self, node: &DepNode<K>) -> Vec<&DepNode<K>> {
- self.reachable_nodes(node, OUTGOING)
- }
-
/// All nodes that can reach `node`.
pub fn transitive_predecessors(&self, node: &DepNode<K>) -> Vec<&DepNode<K>> {
self.reachable_nodes(node, INCOMING)
}
-
- /// Just the outgoing edges from `node`.
- pub fn immediate_successors(&self, node: &DepNode<K>) -> Vec<&DepNode<K>> {
- if let Some(&index) = self.indices.get(&node) {
- self.graph.successor_nodes(index).map(|s| self.graph.node_data(s)).collect()
- } else {
- vec![]
- }
- }
}
diff --git a/compiler/rustc_query_system/src/query/caches.rs b/compiler/rustc_query_system/src/query/caches.rs
index 1839e1a..7bc6ae1 100644
--- a/compiler/rustc_query_system/src/query/caches.rs
+++ b/compiler/rustc_query_system/src/query/caches.rs
@@ -1,12 +1,12 @@
use crate::dep_graph::DepNodeIndex;
use crate::query::plumbing::{QueryLookup, QueryState};
-use crate::query::QueryContext;
use rustc_arena::TypedArena;
use rustc_data_structures::fx::FxHashMap;
use rustc_data_structures::sharded::Sharded;
use rustc_data_structures::sync::WorkerLocal;
use std::default::Default;
+use std::fmt::Debug;
use std::hash::Hash;
use std::marker::PhantomData;
@@ -24,16 +24,16 @@
}
pub trait QueryCache: QueryStorage {
- type Key: Hash;
+ type Key: Hash + Eq + Clone + Debug;
type Sharded: Default;
/// Checks if the query is already computed and in the cache.
/// It returns the shard index and a lock guard to the shard,
/// which will be used if the query is not in the cache and we need
/// to compute it.
- fn lookup<CTX: QueryContext, R, OnHit, OnMiss>(
+ fn lookup<D, Q, R, OnHit, OnMiss>(
&self,
- state: &QueryState<CTX, Self>,
+ state: &QueryState<D, Q, Self>,
key: Self::Key,
// `on_hit` can be called while holding a lock to the query state shard.
on_hit: OnHit,
@@ -41,7 +41,7 @@
) -> R
where
OnHit: FnOnce(&Self::Stored, DepNodeIndex) -> R,
- OnMiss: FnOnce(Self::Key, QueryLookup<'_, CTX, Self::Key, Self::Sharded>) -> R;
+ OnMiss: FnOnce(Self::Key, QueryLookup<'_, D, Q, Self::Key, Self::Sharded>) -> R;
fn complete(
&self,
@@ -86,21 +86,25 @@
}
}
-impl<K: Eq + Hash, V: Clone> QueryCache for DefaultCache<K, V> {
+impl<K, V> QueryCache for DefaultCache<K, V>
+where
+ K: Eq + Hash + Clone + Debug,
+ V: Clone,
+{
type Key = K;
type Sharded = FxHashMap<K, (V, DepNodeIndex)>;
#[inline(always)]
- fn lookup<CTX: QueryContext, R, OnHit, OnMiss>(
+ fn lookup<D, Q, R, OnHit, OnMiss>(
&self,
- state: &QueryState<CTX, Self>,
+ state: &QueryState<D, Q, Self>,
key: K,
on_hit: OnHit,
on_miss: OnMiss,
) -> R
where
OnHit: FnOnce(&V, DepNodeIndex) -> R,
- OnMiss: FnOnce(K, QueryLookup<'_, CTX, K, Self::Sharded>) -> R,
+ OnMiss: FnOnce(K, QueryLookup<'_, D, Q, K, Self::Sharded>) -> R,
{
let mut lookup = state.get_lookup(&key);
let lock = &mut *lookup.lock;
@@ -164,21 +168,24 @@
}
}
-impl<'tcx, K: Eq + Hash, V: 'tcx> QueryCache for ArenaCache<'tcx, K, V> {
+impl<'tcx, K, V: 'tcx> QueryCache for ArenaCache<'tcx, K, V>
+where
+ K: Eq + Hash + Clone + Debug,
+{
type Key = K;
type Sharded = FxHashMap<K, &'tcx (V, DepNodeIndex)>;
#[inline(always)]
- fn lookup<CTX: QueryContext, R, OnHit, OnMiss>(
+ fn lookup<D, Q, R, OnHit, OnMiss>(
&self,
- state: &QueryState<CTX, Self>,
+ state: &QueryState<D, Q, Self>,
key: K,
on_hit: OnHit,
on_miss: OnMiss,
) -> R
where
OnHit: FnOnce(&&'tcx V, DepNodeIndex) -> R,
- OnMiss: FnOnce(K, QueryLookup<'_, CTX, K, Self::Sharded>) -> R,
+ OnMiss: FnOnce(K, QueryLookup<'_, D, Q, K, Self::Sharded>) -> R,
{
let mut lookup = state.get_lookup(&key);
let lock = &mut *lookup.lock;
diff --git a/compiler/rustc_query_system/src/query/config.rs b/compiler/rustc_query_system/src/query/config.rs
index 5490565..0f0684b 100644
--- a/compiler/rustc_query_system/src/query/config.rs
+++ b/compiler/rustc_query_system/src/query/config.rs
@@ -5,18 +5,14 @@
use crate::query::caches::QueryCache;
use crate::query::plumbing::CycleError;
use crate::query::{QueryContext, QueryState};
-use rustc_data_structures::profiling::ProfileCategory;
use rustc_data_structures::fingerprint::Fingerprint;
use std::borrow::Cow;
use std::fmt::Debug;
use std::hash::Hash;
-// The parameter `CTX` is required in librustc_middle:
-// implementations may need to access the `'tcx` lifetime in `CTX = TyCtxt<'tcx>`.
-pub trait QueryConfig<CTX> {
+pub trait QueryConfig {
const NAME: &'static str;
- const CATEGORY: ProfileCategory;
type Key: Eq + Hash + Clone + Debug;
type Value;
@@ -70,7 +66,7 @@
}
}
-pub trait QueryAccessors<CTX: QueryContext>: QueryConfig<CTX> {
+pub trait QueryAccessors<CTX: QueryContext>: QueryConfig {
const ANON: bool;
const EVAL_ALWAYS: bool;
const DEP_KIND: CTX::DepKind;
@@ -78,7 +74,7 @@
type Cache: QueryCache<Key = Self::Key, Stored = Self::Stored, Value = Self::Value>;
// Don't use this method to access query results, instead use the methods on TyCtxt
- fn query_state<'a>(tcx: CTX) -> &'a QueryState<CTX, Self::Cache>;
+ fn query_state<'a>(tcx: CTX) -> &'a QueryState<CTX::DepKind, CTX::Query, Self::Cache>;
fn to_dep_node(tcx: CTX, key: &Self::Key) -> DepNode<CTX::DepKind>
where
diff --git a/compiler/rustc_query_system/src/query/job.rs b/compiler/rustc_query_system/src/query/job.rs
index 190312b..c1d3210 100644
--- a/compiler/rustc_query_system/src/query/job.rs
+++ b/compiler/rustc_query_system/src/query/job.rs
@@ -1,16 +1,16 @@
-use crate::dep_graph::{DepContext, DepKind};
use crate::query::plumbing::CycleError;
-use crate::query::QueryContext;
use rustc_data_structures::fx::FxHashMap;
use rustc_span::Span;
use std::convert::TryFrom;
+use std::hash::Hash;
use std::marker::PhantomData;
use std::num::NonZeroU32;
#[cfg(parallel_compiler)]
use {
+ super::QueryContext,
parking_lot::{Condvar, Mutex},
rustc_data_structures::fx::FxHashSet,
rustc_data_structures::stable_hasher::{HashStable, StableHasher},
@@ -31,7 +31,7 @@
pub query: Q,
}
-type QueryMap<CTX> = FxHashMap<QueryJobId<<CTX as DepContext>::DepKind>, QueryJobInfo<CTX>>;
+pub(crate) type QueryMap<D, Q> = FxHashMap<QueryJobId<D>, QueryJobInfo<D, Q>>;
/// A value uniquely identifiying an active query job within a shard in the query cache.
#[derive(Copy, Clone, Eq, PartialEq, Hash)]
@@ -39,71 +39,75 @@
/// A value uniquely identifiying an active query job.
#[derive(Copy, Clone, Eq, PartialEq, Hash)]
-pub struct QueryJobId<K> {
+pub struct QueryJobId<D> {
/// Which job within a shard is this
pub job: QueryShardJobId,
/// In which shard is this job
pub shard: u16,
- /// What kind of query this job is
- pub kind: K,
+ /// What kind of query this job is.
+ pub kind: D,
}
-impl<K: DepKind> QueryJobId<K> {
- pub fn new(job: QueryShardJobId, shard: usize, kind: K) -> Self {
+impl<D> QueryJobId<D>
+where
+ D: Copy + Clone + Eq + Hash,
+{
+ pub fn new(job: QueryShardJobId, shard: usize, kind: D) -> Self {
QueryJobId { job, shard: u16::try_from(shard).unwrap(), kind }
}
- fn query<CTX: QueryContext<DepKind = K>>(self, map: &QueryMap<CTX>) -> CTX::Query {
+ fn query<Q: Clone>(self, map: &QueryMap<D, Q>) -> Q {
map.get(&self).unwrap().info.query.clone()
}
#[cfg(parallel_compiler)]
- fn span<CTX: QueryContext<DepKind = K>>(self, map: &QueryMap<CTX>) -> Span {
+ fn span<Q: Clone>(self, map: &QueryMap<D, Q>) -> Span {
map.get(&self).unwrap().job.span
}
#[cfg(parallel_compiler)]
- fn parent<CTX: QueryContext<DepKind = K>>(self, map: &QueryMap<CTX>) -> Option<QueryJobId<K>> {
+ fn parent<Q: Clone>(self, map: &QueryMap<D, Q>) -> Option<QueryJobId<D>> {
map.get(&self).unwrap().job.parent
}
#[cfg(parallel_compiler)]
- fn latch<'a, CTX: QueryContext<DepKind = K>>(
- self,
- map: &'a QueryMap<CTX>,
- ) -> Option<&'a QueryLatch<CTX>> {
+ fn latch<'a, Q: Clone>(self, map: &'a QueryMap<D, Q>) -> Option<&'a QueryLatch<D, Q>> {
map.get(&self).unwrap().job.latch.as_ref()
}
}
-pub struct QueryJobInfo<CTX: QueryContext> {
- pub info: QueryInfo<CTX::Query>,
- pub job: QueryJob<CTX>,
+pub struct QueryJobInfo<D, Q> {
+ pub info: QueryInfo<Q>,
+ pub job: QueryJob<D, Q>,
}
/// Represents an active query job.
#[derive(Clone)]
-pub struct QueryJob<CTX: QueryContext> {
+pub struct QueryJob<D, Q> {
pub id: QueryShardJobId,
/// The span corresponding to the reason for which this query was required.
pub span: Span,
/// The parent query job which created this job and is implicitly waiting on it.
- pub parent: Option<QueryJobId<CTX::DepKind>>,
+ pub parent: Option<QueryJobId<D>>,
/// The latch that is used to wait on this job.
#[cfg(parallel_compiler)]
- latch: Option<QueryLatch<CTX>>,
+ latch: Option<QueryLatch<D, Q>>,
- dummy: PhantomData<QueryLatch<CTX>>,
+ dummy: PhantomData<QueryLatch<D, Q>>,
}
-impl<CTX: QueryContext> QueryJob<CTX> {
+impl<D, Q> QueryJob<D, Q>
+where
+ D: Copy + Clone + Eq + Hash,
+ Q: Clone,
+{
/// Creates a new query job.
- pub fn new(id: QueryShardJobId, span: Span, parent: Option<QueryJobId<CTX::DepKind>>) -> Self {
+ pub fn new(id: QueryShardJobId, span: Span, parent: Option<QueryJobId<D>>) -> Self {
QueryJob {
id,
span,
@@ -115,7 +119,7 @@
}
#[cfg(parallel_compiler)]
- pub(super) fn latch(&mut self, _id: QueryJobId<CTX::DepKind>) -> QueryLatch<CTX> {
+ pub(super) fn latch(&mut self, _id: QueryJobId<D>) -> QueryLatch<D, Q> {
if self.latch.is_none() {
self.latch = Some(QueryLatch::new());
}
@@ -123,7 +127,7 @@
}
#[cfg(not(parallel_compiler))]
- pub(super) fn latch(&mut self, id: QueryJobId<CTX::DepKind>) -> QueryLatch<CTX> {
+ pub(super) fn latch(&mut self, id: QueryJobId<D>) -> QueryLatch<D, Q> {
QueryLatch { id, dummy: PhantomData }
}
@@ -143,19 +147,26 @@
#[cfg(not(parallel_compiler))]
#[derive(Clone)]
-pub(super) struct QueryLatch<CTX: QueryContext> {
- id: QueryJobId<CTX::DepKind>,
- dummy: PhantomData<CTX>,
+pub(super) struct QueryLatch<D, Q> {
+ id: QueryJobId<D>,
+ dummy: PhantomData<Q>,
}
#[cfg(not(parallel_compiler))]
-impl<CTX: QueryContext> QueryLatch<CTX> {
- pub(super) fn find_cycle_in_stack(&self, tcx: CTX, span: Span) -> CycleError<CTX::Query> {
- let query_map = tcx.try_collect_active_jobs().unwrap();
-
- // Get the current executing query (waiter) and find the waitee amongst its parents
- let mut current_job = tcx.current_query_job();
+impl<D, Q> QueryLatch<D, Q>
+where
+ D: Copy + Clone + Eq + Hash,
+ Q: Clone,
+{
+ pub(super) fn find_cycle_in_stack(
+ &self,
+ query_map: QueryMap<D, Q>,
+ current_job: &Option<QueryJobId<D>>,
+ span: Span,
+ ) -> CycleError<Q> {
+ // Find the waitee amongst `current_job` parents
let mut cycle = Vec::new();
+ let mut current_job = Option::clone(current_job);
while let Some(job) = current_job {
let info = query_map.get(&job).unwrap();
@@ -186,15 +197,15 @@
}
#[cfg(parallel_compiler)]
-struct QueryWaiter<CTX: QueryContext> {
- query: Option<QueryJobId<CTX::DepKind>>,
+struct QueryWaiter<D, Q> {
+ query: Option<QueryJobId<D>>,
condvar: Condvar,
span: Span,
- cycle: Lock<Option<CycleError<CTX::Query>>>,
+ cycle: Lock<Option<CycleError<Q>>>,
}
#[cfg(parallel_compiler)]
-impl<CTX: QueryContext> QueryWaiter<CTX> {
+impl<D, Q> QueryWaiter<D, Q> {
fn notify(&self, registry: &rayon_core::Registry) {
rayon_core::mark_unblocked(registry);
self.condvar.notify_one();
@@ -202,19 +213,19 @@
}
#[cfg(parallel_compiler)]
-struct QueryLatchInfo<CTX: QueryContext> {
+struct QueryLatchInfo<D, Q> {
complete: bool,
- waiters: Vec<Lrc<QueryWaiter<CTX>>>,
+ waiters: Vec<Lrc<QueryWaiter<D, Q>>>,
}
#[cfg(parallel_compiler)]
#[derive(Clone)]
-pub(super) struct QueryLatch<CTX: QueryContext> {
- info: Lrc<Mutex<QueryLatchInfo<CTX>>>,
+pub(super) struct QueryLatch<D, Q> {
+ info: Lrc<Mutex<QueryLatchInfo<D, Q>>>,
}
#[cfg(parallel_compiler)]
-impl<CTX: QueryContext> QueryLatch<CTX> {
+impl<D: Eq + Hash, Q: Clone> QueryLatch<D, Q> {
fn new() -> Self {
QueryLatch {
info: Lrc::new(Mutex::new(QueryLatchInfo { complete: false, waiters: Vec::new() })),
@@ -223,10 +234,13 @@
}
#[cfg(parallel_compiler)]
-impl<CTX: QueryContext> QueryLatch<CTX> {
+impl<D, Q> QueryLatch<D, Q> {
/// Awaits for the query job to complete.
- pub(super) fn wait_on(&self, tcx: CTX, span: Span) -> Result<(), CycleError<CTX::Query>> {
- let query = tcx.current_query_job();
+ pub(super) fn wait_on(
+ &self,
+ query: Option<QueryJobId<D>>,
+ span: Span,
+ ) -> Result<(), CycleError<Q>> {
let waiter =
Lrc::new(QueryWaiter { query, span, cycle: Lock::new(None), condvar: Condvar::new() });
self.wait_on_inner(&waiter);
@@ -239,12 +253,9 @@
Some(cycle) => Err(cycle),
}
}
-}
-#[cfg(parallel_compiler)]
-impl<CTX: QueryContext> QueryLatch<CTX> {
/// Awaits the caller on this latch by blocking the current thread.
- fn wait_on_inner(&self, waiter: &Lrc<QueryWaiter<CTX>>) {
+ fn wait_on_inner(&self, waiter: &Lrc<QueryWaiter<D, Q>>) {
let mut info = self.info.lock();
if !info.complete {
// We push the waiter on to the `waiters` list. It can be accessed inside
@@ -278,7 +289,7 @@
/// Removes a single waiter from the list of waiters.
/// This is used to break query cycles.
- fn extract_waiter(&self, waiter: usize) -> Lrc<QueryWaiter<CTX>> {
+ fn extract_waiter(&self, waiter: usize) -> Lrc<QueryWaiter<D, Q>> {
let mut info = self.info.lock();
debug_assert!(!info.complete);
// Remove the waiter from the list of waiters
@@ -288,7 +299,7 @@
/// A resumable waiter of a query. The usize is the index into waiters in the query's latch
#[cfg(parallel_compiler)]
-type Waiter<K> = (QueryJobId<K>, usize);
+type Waiter<D> = (QueryJobId<D>, usize);
/// Visits all the non-resumable and resumable waiters of a query.
/// Only waiters in a query are visited.
@@ -300,13 +311,15 @@
/// required information to resume the waiter.
/// If all `visit` calls returns None, this function also returns None.
#[cfg(parallel_compiler)]
-fn visit_waiters<CTX: QueryContext, F>(
- query_map: &QueryMap<CTX>,
- query: QueryJobId<CTX::DepKind>,
+fn visit_waiters<D, Q, F>(
+ query_map: &QueryMap<D, Q>,
+ query: QueryJobId<D>,
mut visit: F,
-) -> Option<Option<Waiter<CTX::DepKind>>>
+) -> Option<Option<Waiter<D>>>
where
- F: FnMut(Span, QueryJobId<CTX::DepKind>) -> Option<Option<Waiter<CTX::DepKind>>>,
+ D: Copy + Clone + Eq + Hash,
+ Q: Clone,
+ F: FnMut(Span, QueryJobId<D>) -> Option<Option<Waiter<D>>>,
{
// Visit the parent query which is a non-resumable waiter since it's on the same stack
if let Some(parent) = query.parent(query_map) {
@@ -335,13 +348,17 @@
/// If a cycle is detected, this initial value is replaced with the span causing
/// the cycle.
#[cfg(parallel_compiler)]
-fn cycle_check<CTX: QueryContext>(
- query_map: &QueryMap<CTX>,
- query: QueryJobId<CTX::DepKind>,
+fn cycle_check<D, Q>(
+ query_map: &QueryMap<D, Q>,
+ query: QueryJobId<D>,
span: Span,
- stack: &mut Vec<(Span, QueryJobId<CTX::DepKind>)>,
- visited: &mut FxHashSet<QueryJobId<CTX::DepKind>>,
-) -> Option<Option<Waiter<CTX::DepKind>>> {
+ stack: &mut Vec<(Span, QueryJobId<D>)>,
+ visited: &mut FxHashSet<QueryJobId<D>>,
+) -> Option<Option<Waiter<D>>>
+where
+ D: Copy + Clone + Eq + Hash,
+ Q: Clone,
+{
if !visited.insert(query) {
return if let Some(p) = stack.iter().position(|q| q.1 == query) {
// We detected a query cycle, fix up the initial span and return Some
@@ -376,11 +393,15 @@
/// from `query` without going through any of the queries in `visited`.
/// This is achieved with a depth first search.
#[cfg(parallel_compiler)]
-fn connected_to_root<CTX: QueryContext>(
- query_map: &QueryMap<CTX>,
- query: QueryJobId<CTX::DepKind>,
- visited: &mut FxHashSet<QueryJobId<CTX::DepKind>>,
-) -> bool {
+fn connected_to_root<D, Q>(
+ query_map: &QueryMap<D, Q>,
+ query: QueryJobId<D>,
+ visited: &mut FxHashSet<QueryJobId<D>>,
+) -> bool
+where
+ D: Copy + Clone + Eq + Hash,
+ Q: Clone,
+{
// We already visited this or we're deliberately ignoring it
if !visited.insert(query) {
return false;
@@ -399,7 +420,12 @@
// Deterministically pick an query from a list
#[cfg(parallel_compiler)]
-fn pick_query<'a, CTX, T, F>(query_map: &QueryMap<CTX>, tcx: CTX, queries: &'a [T], f: F) -> &'a T
+fn pick_query<'a, CTX, T, F>(
+ query_map: &QueryMap<CTX::DepKind, CTX::Query>,
+ tcx: CTX,
+ queries: &'a [T],
+ f: F,
+) -> &'a T
where
CTX: QueryContext,
F: Fn(&T) -> (Span, QueryJobId<CTX::DepKind>),
@@ -429,9 +455,9 @@
/// the function returns false.
#[cfg(parallel_compiler)]
fn remove_cycle<CTX: QueryContext>(
- query_map: &QueryMap<CTX>,
+ query_map: &QueryMap<CTX::DepKind, CTX::Query>,
jobs: &mut Vec<QueryJobId<CTX::DepKind>>,
- wakelist: &mut Vec<Lrc<QueryWaiter<CTX>>>,
+ wakelist: &mut Vec<Lrc<QueryWaiter<CTX::DepKind, CTX::Query>>>,
tcx: CTX,
) -> bool {
let mut visited = FxHashSet::default();
diff --git a/compiler/rustc_query_system/src/query/mod.rs b/compiler/rustc_query_system/src/query/mod.rs
index 4909772..da45565 100644
--- a/compiler/rustc_query_system/src/query/mod.rs
+++ b/compiler/rustc_query_system/src/query/mod.rs
@@ -15,8 +15,8 @@
pub use self::config::{QueryAccessors, QueryConfig, QueryDescription};
use crate::dep_graph::{DepContext, DepGraph};
+use crate::query::job::QueryMap;
-use rustc_data_structures::fx::FxHashMap;
use rustc_data_structures::stable_hasher::HashStable;
use rustc_data_structures::sync::Lock;
use rustc_data_structures::thin_vec::ThinVec;
@@ -38,9 +38,7 @@
/// Get the query information from the TLS context.
fn current_query_job(&self) -> Option<QueryJobId<Self::DepKind>>;
- fn try_collect_active_jobs(
- &self,
- ) -> Option<FxHashMap<QueryJobId<Self::DepKind>, QueryJobInfo<Self>>>;
+ fn try_collect_active_jobs(&self) -> Option<QueryMap<Self::DepKind, Self::Query>>;
/// Executes a job by changing the `ImplicitCtxt` to point to the
/// new query job while it executes. It returns the diagnostics
diff --git a/compiler/rustc_query_system/src/query/plumbing.rs b/compiler/rustc_query_system/src/query/plumbing.rs
index ae042cc..426f5bb 100644
--- a/compiler/rustc_query_system/src/query/plumbing.rs
+++ b/compiler/rustc_query_system/src/query/plumbing.rs
@@ -7,7 +7,7 @@
use crate::query::caches::QueryCache;
use crate::query::config::{QueryDescription, QueryVtable, QueryVtableExt};
use crate::query::job::{QueryInfo, QueryJob, QueryJobId, QueryJobInfo, QueryShardJobId};
-use crate::query::QueryContext;
+use crate::query::{QueryContext, QueryMap};
#[cfg(not(parallel_compiler))]
use rustc_data_structures::cold_path;
@@ -20,8 +20,6 @@
use rustc_span::source_map::DUMMY_SP;
use rustc_span::Span;
use std::collections::hash_map::Entry;
-use std::convert::TryFrom;
-use std::fmt::Debug;
use std::hash::{Hash, Hasher};
use std::mem;
use std::num::NonZeroU32;
@@ -29,33 +27,33 @@
#[cfg(debug_assertions)]
use std::sync::atomic::{AtomicUsize, Ordering};
-pub(super) struct QueryStateShard<CTX: QueryContext, K, C> {
+pub(super) struct QueryStateShard<D, Q, K, C> {
pub(super) cache: C,
- active: FxHashMap<K, QueryResult<CTX>>,
+ active: FxHashMap<K, QueryResult<D, Q>>,
/// Used to generate unique ids for active jobs.
jobs: u32,
}
-impl<CTX: QueryContext, K, C: Default> Default for QueryStateShard<CTX, K, C> {
- fn default() -> QueryStateShard<CTX, K, C> {
+impl<D, Q, K, C: Default> Default for QueryStateShard<D, Q, K, C> {
+ fn default() -> QueryStateShard<D, Q, K, C> {
QueryStateShard { cache: Default::default(), active: Default::default(), jobs: 0 }
}
}
-pub struct QueryState<CTX: QueryContext, C: QueryCache> {
+pub struct QueryState<D, Q, C: QueryCache> {
cache: C,
- shards: Sharded<QueryStateShard<CTX, C::Key, C::Sharded>>,
+ shards: Sharded<QueryStateShard<D, Q, C::Key, C::Sharded>>,
#[cfg(debug_assertions)]
pub cache_hits: AtomicUsize,
}
-impl<CTX: QueryContext, C: QueryCache> QueryState<CTX, C> {
+impl<D, Q, C: QueryCache> QueryState<D, Q, C> {
#[inline]
pub(super) fn get_lookup<'tcx>(
&'tcx self,
key: &C::Key,
- ) -> QueryLookup<'tcx, CTX, C::Key, C::Sharded> {
+ ) -> QueryLookup<'tcx, D, Q, C::Key, C::Sharded> {
// We compute the key's hash once and then use it for both the
// shard lookup and the hashmap lookup. This relies on the fact
// that both of them use `FxHasher`.
@@ -70,16 +68,21 @@
}
/// Indicates the state of a query for a given key in a query map.
-enum QueryResult<CTX: QueryContext> {
+enum QueryResult<D, Q> {
/// An already executing query. The query job can be used to await for its completion.
- Started(QueryJob<CTX>),
+ Started(QueryJob<D, Q>),
/// The query panicked. Queries trying to wait on this will raise a fatal error which will
/// silently panic.
Poisoned,
}
-impl<CTX: QueryContext, C: QueryCache> QueryState<CTX, C> {
+impl<D, Q, C> QueryState<D, Q, C>
+where
+ D: Copy + Clone + Eq + Hash,
+ Q: Clone,
+ C: QueryCache,
+{
#[inline(always)]
pub fn iter_results<R>(
&self,
@@ -98,13 +101,10 @@
pub fn try_collect_active_jobs(
&self,
- kind: CTX::DepKind,
- make_query: fn(C::Key) -> CTX::Query,
- jobs: &mut FxHashMap<QueryJobId<CTX::DepKind>, QueryJobInfo<CTX>>,
- ) -> Option<()>
- where
- C::Key: Clone,
- {
+ kind: D,
+ make_query: fn(C::Key) -> Q,
+ jobs: &mut QueryMap<D, Q>,
+ ) -> Option<()> {
// We use try_lock_shards here since we are called from the
// deadlock handler, and this shouldn't be locked.
let shards = self.shards.try_lock_shards()?;
@@ -112,8 +112,7 @@
jobs.extend(shards.flat_map(|(shard_id, shard)| {
shard.active.iter().filter_map(move |(k, v)| {
if let QueryResult::Started(ref job) = *v {
- let id =
- QueryJobId { job: job.id, shard: u16::try_from(shard_id).unwrap(), kind };
+ let id = QueryJobId::new(job.id, shard_id, kind);
let info = QueryInfo { span: job.span, query: make_query(k.clone()) };
Some((id, QueryJobInfo { info, job: job.clone() }))
} else {
@@ -126,8 +125,8 @@
}
}
-impl<CTX: QueryContext, C: QueryCache> Default for QueryState<CTX, C> {
- fn default() -> QueryState<CTX, C> {
+impl<D, Q, C: QueryCache> Default for QueryState<D, Q, C> {
+ fn default() -> QueryState<D, Q, C> {
QueryState {
cache: C::default(),
shards: Default::default(),
@@ -138,28 +137,30 @@
}
/// Values used when checking a query cache which can be reused on a cache-miss to execute the query.
-pub struct QueryLookup<'tcx, CTX: QueryContext, K, C> {
+pub struct QueryLookup<'tcx, D, Q, K, C> {
pub(super) key_hash: u64,
shard: usize,
- pub(super) lock: LockGuard<'tcx, QueryStateShard<CTX, K, C>>,
+ pub(super) lock: LockGuard<'tcx, QueryStateShard<D, Q, K, C>>,
}
/// A type representing the responsibility to execute the job in the `job` field.
/// This will poison the relevant query if dropped.
-struct JobOwner<'tcx, CTX: QueryContext, C>
+struct JobOwner<'tcx, D, Q, C>
where
+ D: Copy + Clone + Eq + Hash,
+ Q: Clone,
C: QueryCache,
- C::Key: Eq + Hash + Clone + Debug,
{
- state: &'tcx QueryState<CTX, C>,
+ state: &'tcx QueryState<D, Q, C>,
key: C::Key,
- id: QueryJobId<CTX::DepKind>,
+ id: QueryJobId<D>,
}
-impl<'tcx, CTX: QueryContext, C> JobOwner<'tcx, CTX, C>
+impl<'tcx, D, Q, C> JobOwner<'tcx, D, Q, C>
where
+ D: Copy + Clone + Eq + Hash,
+ Q: Clone,
C: QueryCache,
- C::Key: Eq + Hash + Clone + Debug,
{
/// Either gets a `JobOwner` corresponding the query, allowing us to
/// start executing the query, or returns with the result of the query.
@@ -170,14 +171,14 @@
/// This function is inlined because that results in a noticeable speed-up
/// for some compile-time benchmarks.
#[inline(always)]
- fn try_start<'a, 'b>(
+ fn try_start<'a, 'b, CTX>(
tcx: CTX,
- state: &'b QueryState<CTX, C>,
+ state: &'b QueryState<CTX::DepKind, CTX::Query, C>,
span: Span,
key: &C::Key,
- mut lookup: QueryLookup<'a, CTX, C::Key, C::Sharded>,
+ mut lookup: QueryLookup<'a, CTX::DepKind, CTX::Query, C::Key, C::Sharded>,
query: &QueryVtable<CTX, C::Key, C::Value>,
- ) -> TryGetJob<'b, CTX, C>
+ ) -> TryGetJob<'b, CTX::DepKind, CTX::Query, C>
where
CTX: QueryContext,
{
@@ -229,7 +230,12 @@
// so we just return the error.
#[cfg(not(parallel_compiler))]
return TryGetJob::Cycle(cold_path(|| {
- let value = query.handle_cycle_error(tcx, latch.find_cycle_in_stack(tcx, span));
+ let error: CycleError<CTX::Query> = latch.find_cycle_in_stack(
+ tcx.try_collect_active_jobs().unwrap(),
+ &tcx.current_query_job(),
+ span,
+ );
+ let value = query.handle_cycle_error(tcx, error);
state.cache.store_nocache(value)
}));
@@ -237,7 +243,7 @@
// thread.
#[cfg(parallel_compiler)]
{
- let result = latch.wait_on(tcx, span);
+ let result = latch.wait_on(tcx.current_query_job(), span);
if let Err(cycle) = result {
let value = query.handle_cycle_error(tcx, cycle);
@@ -297,9 +303,11 @@
(result, diagnostics.into_inner())
}
-impl<'tcx, CTX: QueryContext, C: QueryCache> Drop for JobOwner<'tcx, CTX, C>
+impl<'tcx, D, Q, C> Drop for JobOwner<'tcx, D, Q, C>
where
- C::Key: Eq + Hash + Clone + Debug,
+ D: Copy + Clone + Eq + Hash,
+ Q: Clone,
+ C: QueryCache,
{
#[inline(never)]
#[cold]
@@ -330,12 +338,14 @@
}
/// The result of `try_start`.
-enum TryGetJob<'tcx, CTX: QueryContext, C: QueryCache>
+enum TryGetJob<'tcx, D, Q, C>
where
- C::Key: Eq + Hash + Clone + Debug,
+ D: Copy + Clone + Eq + Hash,
+ Q: Clone,
+ C: QueryCache,
{
/// The query is not yet started. Contains a guard to the cache eventually used to start it.
- NotYetStarted(JobOwner<'tcx, CTX, C>),
+ NotYetStarted(JobOwner<'tcx, D, Q, C>),
/// The query was already completed.
/// Returns the result of the query and its dep-node index
@@ -354,7 +364,7 @@
#[inline(always)]
fn try_get_cached<CTX, C, R, OnHit, OnMiss>(
tcx: CTX,
- state: &QueryState<CTX, C>,
+ state: &QueryState<CTX::DepKind, CTX::Query, C>,
key: C::Key,
// `on_hit` can be called while holding a lock to the query cache
on_hit: OnHit,
@@ -364,7 +374,7 @@
C: QueryCache,
CTX: QueryContext,
OnHit: FnOnce(&C::Stored, DepNodeIndex) -> R,
- OnMiss: FnOnce(C::Key, QueryLookup<'_, CTX, C::Key, C::Sharded>) -> R,
+ OnMiss: FnOnce(C::Key, QueryLookup<'_, CTX::DepKind, CTX::Query, C::Key, C::Sharded>) -> R,
{
state.cache.lookup(
state,
@@ -386,19 +396,20 @@
#[inline(always)]
fn try_execute_query<CTX, C>(
tcx: CTX,
- state: &QueryState<CTX, C>,
+ state: &QueryState<CTX::DepKind, CTX::Query, C>,
span: Span,
key: C::Key,
- lookup: QueryLookup<'_, CTX, C::Key, C::Sharded>,
+ lookup: QueryLookup<'_, CTX::DepKind, CTX::Query, C::Key, C::Sharded>,
query: &QueryVtable<CTX, C::Key, C::Value>,
) -> C::Stored
where
C: QueryCache,
- C::Key: Eq + Clone + Debug + crate::dep_graph::DepNodeParams<CTX>,
- C::Stored: Clone,
+ C::Key: crate::dep_graph::DepNodeParams<CTX>,
CTX: QueryContext,
{
- let job = match JobOwner::try_start(tcx, state, span, &key, lookup, query) {
+ let job = match JobOwner::<'_, CTX::DepKind, CTX::Query, C>::try_start(
+ tcx, state, span, &key, lookup, query,
+ ) {
TryGetJob::NotYetStarted(job) => job,
TryGetJob::Cycle(result) => return result,
#[cfg(parallel_compiler)]
@@ -559,14 +570,12 @@
fn force_query_with_job<C, CTX>(
tcx: CTX,
key: C::Key,
- job: JobOwner<'_, CTX, C>,
+ job: JobOwner<'_, CTX::DepKind, CTX::Query, C>,
dep_node: DepNode<CTX::DepKind>,
query: &QueryVtable<CTX, C::Key, C::Value>,
) -> (C::Stored, DepNodeIndex)
where
C: QueryCache,
- C::Key: Eq + Clone + Debug,
- C::Stored: Clone,
CTX: QueryContext,
{
// If the following assertion triggers, it can have two reasons:
@@ -603,10 +612,8 @@
prof_timer.finish_with_query_invocation_id(dep_node_index.into());
- if unlikely!(!diagnostics.is_empty()) {
- if dep_node.kind != DepKind::NULL {
- tcx.store_diagnostics(dep_node_index, diagnostics);
- }
+ if unlikely!(!diagnostics.is_empty()) && dep_node.kind != DepKind::NULL {
+ tcx.store_diagnostics(dep_node_index, diagnostics);
}
let result = job.complete(result, dep_node_index);
@@ -617,7 +624,7 @@
#[inline(never)]
fn get_query_impl<CTX, C>(
tcx: CTX,
- state: &QueryState<CTX, C>,
+ state: &QueryState<CTX::DepKind, CTX::Query, C>,
span: Span,
key: C::Key,
query: &QueryVtable<CTX, C::Key, C::Value>,
@@ -625,8 +632,7 @@
where
CTX: QueryContext,
C: QueryCache,
- C::Key: Eq + Clone + crate::dep_graph::DepNodeParams<CTX>,
- C::Stored: Clone,
+ C::Key: crate::dep_graph::DepNodeParams<CTX>,
{
try_get_cached(
tcx,
@@ -650,12 +656,12 @@
#[inline(never)]
fn ensure_query_impl<CTX, C>(
tcx: CTX,
- state: &QueryState<CTX, C>,
+ state: &QueryState<CTX::DepKind, CTX::Query, C>,
key: C::Key,
query: &QueryVtable<CTX, C::Key, C::Value>,
) where
C: QueryCache,
- C::Key: Eq + Clone + crate::dep_graph::DepNodeParams<CTX>,
+ C::Key: crate::dep_graph::DepNodeParams<CTX>,
CTX: QueryContext,
{
if query.eval_always {
@@ -687,14 +693,14 @@
#[inline(never)]
fn force_query_impl<CTX, C>(
tcx: CTX,
- state: &QueryState<CTX, C>,
+ state: &QueryState<CTX::DepKind, CTX::Query, C>,
key: C::Key,
span: Span,
dep_node: DepNode<CTX::DepKind>,
query: &QueryVtable<CTX, C::Key, C::Value>,
) where
C: QueryCache,
- C::Key: Eq + Clone + crate::dep_graph::DepNodeParams<CTX>,
+ C::Key: crate::dep_graph::DepNodeParams<CTX>,
CTX: QueryContext,
{
// We may be concurrently trying both execute and force a query.
@@ -708,7 +714,9 @@
// Cache hit, do nothing
},
|key, lookup| {
- let job = match JobOwner::try_start(tcx, state, span, &key, lookup, query) {
+ let job = match JobOwner::<'_, CTX::DepKind, CTX::Query, C>::try_start(
+ tcx, state, span, &key, lookup, query,
+ ) {
TryGetJob::NotYetStarted(job) => job,
TryGetJob::Cycle(_) => return,
#[cfg(parallel_compiler)]
