1 //! The implementation of the query system itself. This defines the macros that
2 //! generate the actual methods on tcx which find and execute the provider,
3 //! manage the caches, and so forth.
5 use crate::dep_graph::{DepContext, DepNode, DepNodeIndex, DepNodeParams};
6 use crate::query::caches::QueryCache;
7 use crate::query::config::{QueryDescription, QueryVtable};
8 use crate::query::job::{
9 report_cycle, QueryInfo, QueryJob, QueryJobId, QueryJobInfo, QueryShardJobId,
11 use crate::query::{QueryContext, QueryMap, QuerySideEffects, QueryStackFrame};
12 use rustc_data_structures::fingerprint::Fingerprint;
13 use rustc_data_structures::fx::{FxHashMap, FxHasher};
14 #[cfg(parallel_compiler)]
15 use rustc_data_structures::profiling::TimingGuard;
16 use rustc_data_structures::sharded::{get_shard_index_by_hash, Sharded};
17 use rustc_data_structures::sync::{Lock, LockGuard};
18 use rustc_data_structures::thin_vec::ThinVec;
19 use rustc_errors::{DiagnosticBuilder, FatalError};
20 use rustc_session::Session;
21 use rustc_span::{Span, DUMMY_SP};
23 use std::collections::hash_map::Entry;
25 use std::hash::{Hash, Hasher};
27 use std::num::NonZeroU32;
30 pub struct QueryCacheStore<C: QueryCache> {
32 shards: Sharded<C::Sharded>,
35 impl<C: QueryCache + Default> Default for QueryCacheStore<C> {
36 fn default() -> Self {
37 Self { cache: C::default(), shards: Default::default() }
41 /// Values used when checking a query cache which can be reused on a cache-miss to execute the query.
42 pub struct QueryLookup {
43 pub(super) key_hash: u64,
47 // We compute the key's hash once and then use it for both the
48 // shard lookup and the hashmap lookup. This relies on the fact
49 // that both of them use `FxHasher`.
50 fn hash_for_shard<K: Hash>(key: &K) -> u64 {
51 let mut hasher = FxHasher::default();
52 key.hash(&mut hasher);
56 impl<C: QueryCache> QueryCacheStore<C> {
57 pub(super) fn get_lookup<'tcx>(
60 ) -> (QueryLookup, LockGuard<'tcx, C::Sharded>) {
61 let key_hash = hash_for_shard(key);
62 let shard = get_shard_index_by_hash(key_hash);
63 let lock = self.shards.get_shard_by_index(shard).lock();
64 (QueryLookup { key_hash, shard }, lock)
67 pub fn iter_results(&self, f: &mut dyn FnMut(&C::Key, &C::Value, DepNodeIndex)) {
68 self.cache.iter(&self.shards, f)
72 struct QueryStateShard<D, K> {
73 active: FxHashMap<K, QueryResult<D>>,
75 /// Used to generate unique ids for active jobs.
79 impl<D, K> Default for QueryStateShard<D, K> {
80 fn default() -> QueryStateShard<D, K> {
81 QueryStateShard { active: Default::default(), jobs: 0 }
85 pub struct QueryState<D, K> {
86 shards: Sharded<QueryStateShard<D, K>>,
89 /// Indicates the state of a query for a given key in a query map.
91 /// An already executing query. The query job can be used to await for its completion.
94 /// The query panicked. Queries trying to wait on this will raise a fatal error which will
99 impl<D, K> QueryState<D, K>
101 D: Copy + Clone + Eq + Hash,
102 K: Eq + Hash + Clone + Debug,
104 pub fn all_inactive(&self) -> bool {
105 let shards = self.shards.lock_shards();
106 shards.iter().all(|shard| shard.active.is_empty())
109 pub fn try_collect_active_jobs<CTX: Copy>(
113 make_query: fn(CTX, K) -> QueryStackFrame,
114 jobs: &mut QueryMap<D>,
116 // We use try_lock_shards here since we are called from the
117 // deadlock handler, and this shouldn't be locked.
118 let shards = self.shards.try_lock_shards()?;
119 for (shard_id, shard) in shards.iter().enumerate() {
120 for (k, v) in shard.active.iter() {
121 if let QueryResult::Started(ref job) = *v {
122 let id = QueryJobId::new(job.id, shard_id, kind);
123 let query = make_query(tcx, k.clone());
124 jobs.insert(id, QueryJobInfo { query, job: job.clone() });
133 impl<D, K> Default for QueryState<D, K> {
134 fn default() -> QueryState<D, K> {
135 QueryState { shards: Default::default() }
139 /// A type representing the responsibility to execute the job in the `job` field.
140 /// This will poison the relevant query if dropped.
141 struct JobOwner<'tcx, D, K>
143 D: Copy + Clone + Eq + Hash,
144 K: Eq + Hash + Clone,
146 state: &'tcx QueryState<D, K>,
153 fn mk_cycle<CTX, V, R>(
156 handle_cycle_error: fn(CTX, DiagnosticBuilder<'_>) -> V,
157 cache: &dyn crate::query::QueryStorage<Value = V, Stored = R>,
164 let error = report_cycle(tcx.dep_context().sess(), error);
165 let value = handle_cycle_error(tcx, error);
166 cache.store_nocache(value)
169 impl<'tcx, D, K> JobOwner<'tcx, D, K>
171 D: Copy + Clone + Eq + Hash,
172 K: Eq + Hash + Clone,
174 /// Either gets a `JobOwner` corresponding the query, allowing us to
175 /// start executing the query, or returns with the result of the query.
176 /// This function assumes that `try_get_cached` is already called and returned `lookup`.
177 /// If the query is executing elsewhere, this will wait for it and return the result.
178 /// If the query panicked, this will silently panic.
180 /// This function is inlined because that results in a noticeable speed-up
181 /// for some compile-time benchmarks.
183 fn try_start<'b, CTX>(
185 state: &'b QueryState<CTX::DepKind, K>,
189 dep_kind: CTX::DepKind,
190 ) -> TryGetJob<'b, CTX::DepKind, K>
194 let shard = lookup.shard;
195 let mut state_lock = state.shards.get_shard_by_index(shard).lock();
196 let lock = &mut *state_lock;
198 match lock.active.entry(key) {
199 Entry::Vacant(entry) => {
200 // Generate an id unique within this shard.
201 let id = lock.jobs.checked_add(1).unwrap();
203 let id = QueryShardJobId(NonZeroU32::new(id).unwrap());
205 let job = tcx.current_query_job();
206 let job = QueryJob::new(id, span, job);
208 let key = entry.key().clone();
209 entry.insert(QueryResult::Started(job));
211 let global_id = QueryJobId::new(id, shard, dep_kind);
212 let owner = JobOwner { state, id: global_id, key };
213 return TryGetJob::NotYetStarted(owner);
215 Entry::Occupied(mut entry) => {
216 match entry.get_mut() {
217 #[cfg(not(parallel_compiler))]
218 QueryResult::Started(job) => {
219 let id = QueryJobId::new(job.id, shard, dep_kind);
223 // If we are single-threaded we know that we have cycle error,
224 // so we just return the error.
225 return TryGetJob::Cycle(id.find_cycle_in_stack(
226 tcx.try_collect_active_jobs().unwrap(),
227 &tcx.current_query_job(),
231 #[cfg(parallel_compiler)]
232 QueryResult::Started(job) => {
233 // For parallel queries, we'll block and wait until the query running
234 // in another thread has completed. Record how long we wait in the
236 let query_blocked_prof_timer = tcx.dep_context().profiler().query_blocked();
239 let latch = job.latch();
243 // With parallel queries we might just have to wait on some other
245 let result = latch.wait_on(tcx.current_query_job(), span);
248 Ok(()) => TryGetJob::JobCompleted(query_blocked_prof_timer),
249 Err(cycle) => TryGetJob::Cycle(cycle),
252 QueryResult::Poisoned => FatalError.raise(),
258 /// Completes the query by updating the query cache with the `result`,
259 /// signals the waiter and forgets the JobOwner, so it won't poison the query
262 cache: &QueryCacheStore<C>,
264 dep_node_index: DepNodeIndex,
267 C: QueryCache<Key = K>,
269 // We can move out of `self` here because we `mem::forget` it below
270 let key = unsafe { ptr::read(&self.key) };
271 let state = self.state;
273 // Forget ourself so our destructor won't poison the query
276 let (job, result) = {
277 let key_hash = hash_for_shard(&key);
278 let shard = get_shard_index_by_hash(key_hash);
280 let mut lock = state.shards.get_shard_by_index(shard).lock();
281 match lock.active.remove(&key).unwrap() {
282 QueryResult::Started(job) => job,
283 QueryResult::Poisoned => panic!(),
287 let mut lock = cache.shards.get_shard_by_index(shard).lock();
288 cache.cache.complete(&mut lock, key, result, dep_node_index)
293 job.signal_complete();
298 impl<'tcx, D, K> Drop for JobOwner<'tcx, D, K>
300 D: Copy + Clone + Eq + Hash,
301 K: Eq + Hash + Clone,
306 // Poison the query so jobs waiting on it panic.
307 let state = self.state;
308 let shard = state.shards.get_shard_by_value(&self.key);
310 let mut shard = shard.lock();
311 let job = match shard.active.remove(&self.key).unwrap() {
312 QueryResult::Started(job) => job,
313 QueryResult::Poisoned => panic!(),
315 shard.active.insert(self.key.clone(), QueryResult::Poisoned);
318 // Also signal the completion of the job, so waiters
319 // will continue execution.
320 job.signal_complete();
325 pub(crate) struct CycleError {
326 /// The query and related span that uses the cycle.
327 pub usage: Option<(Span, QueryStackFrame)>,
328 pub cycle: Vec<QueryInfo>,
331 /// The result of `try_start`.
332 enum TryGetJob<'tcx, D, K>
334 D: Copy + Clone + Eq + Hash,
335 K: Eq + Hash + Clone,
337 /// The query is not yet started. Contains a guard to the cache eventually used to start it.
338 NotYetStarted(JobOwner<'tcx, D, K>),
340 /// The query was already completed.
341 /// Returns the result of the query and its dep-node index
342 /// if it succeeded or a cycle error if it failed.
343 #[cfg(parallel_compiler)]
344 JobCompleted(TimingGuard<'tcx>),
346 /// Trying to execute the query resulted in a cycle.
350 /// Checks if the query is already computed and in the cache.
351 /// It returns the shard index and a lock guard to the shard,
352 /// which will be used if the query is not in the cache and we need
355 pub fn try_get_cached<'a, CTX, C, R, OnHit>(
357 cache: &'a QueryCacheStore<C>,
359 // `on_hit` can be called while holding a lock to the query cache
361 ) -> Result<R, QueryLookup>
365 OnHit: FnOnce(&C::Stored) -> R,
367 cache.cache.lookup(cache, &key, |value, index| {
368 if unlikely!(tcx.profiler().enabled()) {
369 tcx.profiler().query_cache_hit(index.into());
371 tcx.dep_graph().read_index(index);
376 fn try_execute_query<CTX, C>(
378 state: &QueryState<CTX::DepKind, C::Key>,
379 cache: &QueryCacheStore<C>,
383 dep_node: Option<DepNode<CTX::DepKind>>,
384 query: &QueryVtable<CTX, C::Key, C::Value>,
385 ) -> (C::Stored, Option<DepNodeIndex>)
388 C::Key: Clone + DepNodeParams<CTX::DepContext>,
391 match JobOwner::<'_, CTX::DepKind, C::Key>::try_start(
399 TryGetJob::NotYetStarted(job) => {
400 let (result, dep_node_index) = execute_job(tcx, key, dep_node, query, job.id);
401 let result = job.complete(cache, result, dep_node_index);
402 (result, Some(dep_node_index))
404 TryGetJob::Cycle(error) => {
405 let result = mk_cycle(tcx, error, query.handle_cycle_error, &cache.cache);
408 #[cfg(parallel_compiler)]
409 TryGetJob::JobCompleted(query_blocked_prof_timer) => {
410 let (v, index) = cache
412 .lookup(cache, &key, |value, index| (value.clone(), index))
413 .unwrap_or_else(|_| panic!("value must be in cache after waiting"));
415 if unlikely!(tcx.dep_context().profiler().enabled()) {
416 tcx.dep_context().profiler().query_cache_hit(index.into());
418 query_blocked_prof_timer.finish_with_query_invocation_id(index.into());
425 fn execute_job<CTX, K, V>(
428 mut dep_node_opt: Option<DepNode<CTX::DepKind>>,
429 query: &QueryVtable<CTX, K, V>,
430 job_id: QueryJobId<CTX::DepKind>,
431 ) -> (V, DepNodeIndex)
433 K: Clone + DepNodeParams<CTX::DepContext>,
437 let dep_graph = tcx.dep_context().dep_graph();
439 // Fast path for when incr. comp. is off.
440 if !dep_graph.is_fully_enabled() {
441 let prof_timer = tcx.dep_context().profiler().query_provider();
442 let result = tcx.start_query(job_id, None, || query.compute(*tcx.dep_context(), key));
443 let dep_node_index = dep_graph.next_virtual_depnode_index();
444 prof_timer.finish_with_query_invocation_id(dep_node_index.into());
445 return (result, dep_node_index);
448 if !query.anon && !query.eval_always {
449 // `to_dep_node` is expensive for some `DepKind`s.
451 dep_node_opt.get_or_insert_with(|| query.to_dep_node(*tcx.dep_context(), &key));
453 // The diagnostics for this query will be promoted to the current session during
454 // `try_mark_green()`, so we can ignore them here.
455 if let Some(ret) = tcx.start_query(job_id, None, || {
456 try_load_from_disk_and_cache_in_memory(tcx, &key, &dep_node, query)
462 let prof_timer = tcx.dep_context().profiler().query_provider();
463 let diagnostics = Lock::new(ThinVec::new());
465 let (result, dep_node_index) = tcx.start_query(job_id, Some(&diagnostics), || {
467 return dep_graph.with_anon_task(*tcx.dep_context(), query.dep_kind, || {
468 query.compute(*tcx.dep_context(), key)
472 // `to_dep_node` is expensive for some `DepKind`s.
473 let dep_node = dep_node_opt.unwrap_or_else(|| query.to_dep_node(*tcx.dep_context(), &key));
475 dep_graph.with_task(dep_node, *tcx.dep_context(), key, query.compute, query.hash_result)
478 prof_timer.finish_with_query_invocation_id(dep_node_index.into());
480 let diagnostics = diagnostics.into_inner();
481 let side_effects = QuerySideEffects { diagnostics };
483 if unlikely!(!side_effects.is_empty()) {
485 tcx.store_side_effects_for_anon_node(dep_node_index, side_effects);
487 tcx.store_side_effects(dep_node_index, side_effects);
491 (result, dep_node_index)
494 fn try_load_from_disk_and_cache_in_memory<CTX, K, V>(
497 dep_node: &DepNode<CTX::DepKind>,
498 query: &QueryVtable<CTX, K, V>,
499 ) -> Option<(V, DepNodeIndex)>
505 // Note this function can be called concurrently from the same query
506 // We must ensure that this is handled correctly.
508 let dep_graph = tcx.dep_context().dep_graph();
509 let (prev_dep_node_index, dep_node_index) = dep_graph.try_mark_green(tcx, &dep_node)?;
511 debug_assert!(dep_graph.is_green(dep_node));
513 // First we try to load the result from the on-disk cache.
514 // Some things are never cached on disk.
515 if query.cache_on_disk {
516 let prof_timer = tcx.dep_context().profiler().incr_cache_loading();
518 // The call to `with_query_deserialization` enforces that no new `DepNodes`
519 // are created during deserialization. See the docs of that method for more
521 let result = dep_graph
522 .with_query_deserialization(|| query.try_load_from_disk(tcx, prev_dep_node_index));
524 prof_timer.finish_with_query_invocation_id(dep_node_index.into());
526 if let Some(result) = result {
527 if unlikely!(tcx.dep_context().sess().opts.debugging_opts.query_dep_graph) {
528 dep_graph.mark_debug_loaded_from_disk(*dep_node)
531 let prev_fingerprint = tcx
534 .prev_fingerprint_of(dep_node)
535 .unwrap_or(Fingerprint::ZERO);
536 // If `-Zincremental-verify-ich` is specified, re-hash results from
537 // the cache and make sure that they have the expected fingerprint.
539 // If not, we still seek to verify a subset of fingerprints loaded
540 // from disk. Re-hashing results is fairly expensive, so we can't
541 // currently afford to verify every hash. This subset should still
542 // give us some coverage of potential bugs though.
543 let try_verify = prev_fingerprint.as_value().1 % 32 == 0;
545 try_verify || tcx.dep_context().sess().opts.debugging_opts.incremental_verify_ich
547 incremental_verify_ich(*tcx.dep_context(), &result, dep_node, query);
550 return Some((result, dep_node_index));
553 // We always expect to find a cached result for things that
554 // can be forced from `DepNode`.
556 !tcx.dep_context().fingerprint_style(dep_node.kind).reconstructible(),
557 "missing on-disk cache entry for {:?}",
562 // We could not load a result from the on-disk cache, so
564 let prof_timer = tcx.dep_context().profiler().query_provider();
566 // The dep-graph for this computation is already in-place.
567 let result = dep_graph.with_ignore(|| query.compute(*tcx.dep_context(), key.clone()));
569 prof_timer.finish_with_query_invocation_id(dep_node_index.into());
571 // Verify that re-running the query produced a result with the expected hash
572 // This catches bugs in query implementations, turning them into ICEs.
573 // For example, a query might sort its result by `DefId` - since `DefId`s are
574 // not stable across compilation sessions, the result could get up getting sorted
575 // in a different order when the query is re-run, even though all of the inputs
576 // (e.g. `DefPathHash` values) were green.
578 // See issue #82920 for an example of a miscompilation that would get turned into
579 // an ICE by this check
580 incremental_verify_ich(*tcx.dep_context(), &result, dep_node, query);
582 Some((result, dep_node_index))
585 fn incremental_verify_ich<CTX, K, V: Debug>(
586 tcx: CTX::DepContext,
588 dep_node: &DepNode<CTX::DepKind>,
589 query: &QueryVtable<CTX, K, V>,
594 tcx.dep_graph().is_green(dep_node),
595 "fingerprint for green query instance not loaded from cache: {:?}",
599 debug!("BEGIN verify_ich({:?})", dep_node);
600 let new_hash = query.hash_result.map_or(Fingerprint::ZERO, |f| {
601 let mut hcx = tcx.create_stable_hashing_context();
604 let old_hash = tcx.dep_graph().prev_fingerprint_of(dep_node);
605 debug!("END verify_ich({:?})", dep_node);
607 if Some(new_hash) != old_hash {
608 incremental_verify_ich_cold(tcx.sess(), DebugArg::from(&dep_node), DebugArg::from(&result));
612 // This DebugArg business is largely a mirror of std::fmt::ArgumentV1, which is
613 // currently not exposed publicly.
615 // The PR which added this attempted to use `&dyn Debug` instead, but that
616 // showed statistically significant worse compiler performance. It's not
617 // actually clear what the cause there was -- the code should be cold. If this
618 // can be replaced with `&dyn Debug` with on perf impact, then it probably
624 struct DebugArg<'a> {
626 fmt: fn(&Opaque, &mut std::fmt::Formatter<'_>) -> std::fmt::Result,
629 impl<'a, T> From<&'a T> for DebugArg<'a>
633 fn from(value: &'a T) -> DebugArg<'a> {
635 value: unsafe { std::mem::transmute(value) },
637 std::mem::transmute(<T as std::fmt::Debug>::fmt as fn(_, _) -> std::fmt::Result)
643 impl std::fmt::Debug for DebugArg<'_> {
644 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
645 (self.fmt)(self.value, f)
649 // Note that this is marked #[cold] and intentionally takes the equivalent of
650 // `dyn Debug` for its arguments, as we want to avoid generating a bunch of
651 // different implementations for LLVM to chew on (and filling up the final
654 fn incremental_verify_ich_cold(sess: &Session, dep_node: DebugArg<'_>, result: DebugArg<'_>) {
655 let run_cmd = if let Some(crate_name) = &sess.opts.crate_name {
656 format!("`cargo clean -p {}` or `cargo clean`", crate_name)
658 "`cargo clean`".to_string()
661 // When we emit an error message and panic, we try to debug-print the `DepNode`
662 // and query result. Unfortunately, this can cause us to run additional queries,
663 // which may result in another fingerprint mismatch while we're in the middle
664 // of processing this one. To avoid a double-panic (which kills the process
665 // before we can print out the query static), we print out a terse
666 // but 'safe' message if we detect a re-entrant call to this method.
668 static INSIDE_VERIFY_PANIC: Cell<bool> = const { Cell::new(false) };
671 let old_in_panic = INSIDE_VERIFY_PANIC.with(|in_panic| in_panic.replace(true));
675 "internal compiler error: re-entrant incremental verify failure, suppressing message",
679 sess.struct_err(&format!("internal compiler error: encountered incremental compilation error with {:?}", dep_node))
680 .help(&format!("This is a known issue with the compiler. Run {} to allow your project to compile", run_cmd))
681 .note(&"Please follow the instructions below to create a bug report with the provided information")
682 .note(&"See <https://github.com/rust-lang/rust/issues/84970> for more information")
684 panic!("Found unstable fingerprints for {:?}: {:?}", dep_node, result);
687 INSIDE_VERIFY_PANIC.with(|in_panic| in_panic.set(old_in_panic));
690 /// Ensure that either this query has all green inputs or been executed.
691 /// Executing `query::ensure(D)` is considered a read of the dep-node `D`.
692 /// Returns true if the query should still run.
694 /// This function is particularly useful when executing passes for their
695 /// side-effects -- e.g., in order to report errors for erroneous programs.
697 /// Note: The optimization is only available during incr. comp.
699 fn ensure_must_run<CTX, K, V>(
702 query: &QueryVtable<CTX, K, V>,
703 ) -> (bool, Option<DepNode<CTX::DepKind>>)
705 K: crate::dep_graph::DepNodeParams<CTX::DepContext>,
708 if query.eval_always {
712 // Ensuring an anonymous query makes no sense
713 assert!(!query.anon);
715 let dep_node = query.to_dep_node(*tcx.dep_context(), key);
717 let dep_graph = tcx.dep_context().dep_graph();
718 match dep_graph.try_mark_green(tcx, &dep_node) {
720 // A None return from `try_mark_green` means that this is either
721 // a new dep node or that the dep node has already been marked red.
722 // Either way, we can't call `dep_graph.read()` as we don't have the
723 // DepNodeIndex. We must invoke the query itself. The performance cost
724 // this introduces should be negligible as we'll immediately hit the
725 // in-memory cache, or another query down the line will.
726 (true, Some(dep_node))
728 Some((_, dep_node_index)) => {
729 dep_graph.read_index(dep_node_index);
730 tcx.dep_context().profiler().query_cache_hit(dep_node_index.into());
741 pub fn get_query<Q, CTX>(
747 ) -> Option<Q::Stored>
749 Q: QueryDescription<CTX>,
750 Q::Key: DepNodeParams<CTX::DepContext>,
753 let query = Q::make_vtable(tcx, &key);
754 let dep_node = if let QueryMode::Ensure = mode {
755 let (must_run, dep_node) = ensure_must_run(tcx, &key, &query);
764 debug!("ty::query::get_query<{}>(key={:?}, span={:?})", Q::NAME, key, span);
765 let (result, dep_node_index) = try_execute_query(
775 if let Some(dep_node_index) = dep_node_index {
776 tcx.dep_context().dep_graph().read_index(dep_node_index)
781 pub fn force_query<Q, CTX>(tcx: CTX, key: Q::Key, dep_node: DepNode<CTX::DepKind>)
783 Q: QueryDescription<CTX>,
784 Q::Key: DepNodeParams<CTX::DepContext>,
787 // We may be concurrently trying both execute and force a query.
788 // Ensure that only one of them runs the query.
789 let cache = Q::query_cache(tcx);
790 let cached = cache.cache.lookup(cache, &key, |_, index| {
791 if unlikely!(tcx.dep_context().profiler().enabled()) {
792 tcx.dep_context().profiler().query_cache_hit(index.into());
796 let lookup = match cached {
798 Err(lookup) => lookup,
801 let query = Q::make_vtable(tcx, &key);
802 let state = Q::query_state(tcx);
803 debug_assert!(!query.anon);
805 try_execute_query(tcx, state, cache, DUMMY_SP, key, lookup, Some(dep_node), &query);