compiler/rustc_query_system/src/query/plumbing.rs

   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.
   4
   5 use crate::dep_graph::{DepContext, DepKind, DepNode, DepNodeIndex};
   6 use crate::ich::StableHashingContext;
   7 use crate::query::caches::QueryCache;
   8 use crate::query::job::{report_cycle, QueryInfo, QueryJob, QueryJobId, QueryJobInfo};
   9 use crate::query::{QueryContext, QueryMap, QuerySideEffects, QueryStackFrame};
  10 use crate::values::Value;
  11 use crate::HandleCycleError;
  12 use rustc_data_structures::fingerprint::Fingerprint;
  13 use rustc_data_structures::fx::FxHashMap;
  14 #[cfg(parallel_compiler)]
  15 use rustc_data_structures::profiling::TimingGuard;
  16 #[cfg(parallel_compiler)]
  17 use rustc_data_structures::sharded::Sharded;
  18 use rustc_data_structures::sync::Lock;
  19 use rustc_errors::{DiagnosticBuilder, ErrorGuaranteed, FatalError};
  20 use rustc_session::Session;
  21 use rustc_span::{Span, DUMMY_SP};
  22 use std::borrow::Borrow;
  23 use std::cell::Cell;
  24 use std::collections::hash_map::Entry;
  25 use std::fmt::Debug;
  26 use std::hash::Hash;
  27 use std::mem;
  28 use std::ptr;
  29 use thin_vec::ThinVec;
  30
  31 use super::QueryConfig;
  32
  33 pub struct QueryState<K, D: DepKind> {
  34     #[cfg(parallel_compiler)]
  35     active: Sharded<FxHashMap<K, QueryResult<D>>>,
  36     #[cfg(not(parallel_compiler))]
  37     active: Lock<FxHashMap<K, QueryResult<D>>>,
  38 }
  39
  40 /// Indicates the state of a query for a given key in a query map.
  41 enum QueryResult<D: DepKind> {
  42     /// An already executing query. The query job can be used to await for its completion.
  43     Started(QueryJob<D>),
  44
  45     /// The query panicked. Queries trying to wait on this will raise a fatal error which will
  46     /// silently panic.
  47     Poisoned,
  48 }
  49
  50 impl<K, D> QueryState<K, D>
  51 where
  52     K: Eq + Hash + Clone + Debug,
  53     D: DepKind,
  54 {
  55     pub fn all_inactive(&self) -> bool {
  56         #[cfg(parallel_compiler)]
  57         {
  58             let shards = self.active.lock_shards();
  59             shards.iter().all(|shard| shard.is_empty())
  60         }
  61         #[cfg(not(parallel_compiler))]
  62         {
  63             self.active.lock().is_empty()
  64         }
  65     }
  66
  67     pub fn try_collect_active_jobs<Qcx: Copy>(
  68         &self,
  69         qcx: Qcx,
  70         make_query: fn(Qcx, K) -> QueryStackFrame<D>,
  71         jobs: &mut QueryMap<D>,
  72     ) -> Option<()> {
  73         #[cfg(parallel_compiler)]
  74         {
  75             // We use try_lock_shards here since we are called from the
  76             // deadlock handler, and this shouldn't be locked.
  77             let shards = self.active.try_lock_shards()?;
  78             for shard in shards.iter() {
  79                 for (k, v) in shard.iter() {
  80                     if let QueryResult::Started(ref job) = *v {
  81                         let query = make_query(qcx, k.clone());
  82                         jobs.insert(job.id, QueryJobInfo { query, job: job.clone() });
  83                     }
  84                 }
  85             }
  86         }
  87         #[cfg(not(parallel_compiler))]
  88         {
  89             // We use try_lock here since we are called from the
  90             // deadlock handler, and this shouldn't be locked.
  91             // (FIXME: Is this relevant for non-parallel compilers? It doesn't
  92             // really hurt much.)
  93             for (k, v) in self.active.try_lock()?.iter() {
  94                 if let QueryResult::Started(ref job) = *v {
  95                     let query = make_query(qcx, k.clone());
  96                     jobs.insert(job.id, QueryJobInfo { query, job: job.clone() });
  97                 }
  98             }
  99         }
 100
 101         Some(())
 102     }
 103 }
 104
 105 impl<K, D: DepKind> Default for QueryState<K, D> {
 106     fn default() -> QueryState<K, D> {
 107         QueryState { active: Default::default() }
 108     }
 109 }
 110
 111 /// A type representing the responsibility to execute the job in the `job` field.
 112 /// This will poison the relevant query if dropped.
 113 struct JobOwner<'tcx, K, D: DepKind>
 114 where
 115     K: Eq + Hash + Clone,
 116 {
 117     state: &'tcx QueryState<K, D>,
 118     key: K,
 119     id: QueryJobId,
 120 }
 121
 122 #[cold]
 123 #[inline(never)]
 124 fn mk_cycle<Qcx, R, D: DepKind>(
 125     qcx: Qcx,
 126     cycle_error: CycleError<D>,
 127     handler: HandleCycleError,
 128 ) -> R
 129 where
 130     Qcx: QueryContext + crate::query::HasDepContext<DepKind = D>,
 131     R: std::fmt::Debug + Value<Qcx::DepContext, Qcx::DepKind>,
 132 {
 133     let error = report_cycle(qcx.dep_context().sess(), &cycle_error);
 134     handle_cycle_error(*qcx.dep_context(), &cycle_error, error, handler)
 135 }
 136
 137 fn handle_cycle_error<Tcx, V>(
 138     tcx: Tcx,
 139     cycle_error: &CycleError<Tcx::DepKind>,
 140     mut error: DiagnosticBuilder<'_, ErrorGuaranteed>,
 141     handler: HandleCycleError,
 142 ) -> V
 143 where
 144     Tcx: DepContext,
 145     V: Value<Tcx, Tcx::DepKind>,
 146 {
 147     use HandleCycleError::*;
 148     match handler {
 149         Error => {
 150             error.emit();
 151             Value::from_cycle_error(tcx, &cycle_error.cycle)
 152         }
 153         Fatal => {
 154             error.emit();
 155             tcx.sess().abort_if_errors();
 156             unreachable!()
 157         }
 158         DelayBug => {
 159             error.delay_as_bug();
 160             Value::from_cycle_error(tcx, &cycle_error.cycle)
 161         }
 162     }
 163 }
 164
 165 impl<'tcx, K, D: DepKind> JobOwner<'tcx, K, D>
 166 where
 167     K: Eq + Hash + Clone,
 168 {
 169     /// Either gets a `JobOwner` corresponding the query, allowing us to
 170     /// start executing the query, or returns with the result of the query.
 171     /// This function assumes that `try_get_cached` is already called and returned `lookup`.
 172     /// If the query is executing elsewhere, this will wait for it and return the result.
 173     /// If the query panicked, this will silently panic.
 174     ///
 175     /// This function is inlined because that results in a noticeable speed-up
 176     /// for some compile-time benchmarks.
 177     #[inline(always)]
 178     fn try_start<'b, Qcx>(
 179         qcx: &'b Qcx,
 180         state: &'b QueryState<K, Qcx::DepKind>,
 181         span: Span,
 182         key: K,
 183     ) -> TryGetJob<'b, K, D>
 184     where
 185         Qcx: QueryContext + crate::query::HasDepContext<DepKind = D>,
 186     {
 187         #[cfg(parallel_compiler)]
 188         let mut state_lock = state.active.get_shard_by_value(&key).lock();
 189         #[cfg(not(parallel_compiler))]
 190         let mut state_lock = state.active.lock();
 191         let lock = &mut *state_lock;
 192
 193         match lock.entry(key) {
 194             Entry::Vacant(entry) => {
 195                 let id = qcx.next_job_id();
 196                 let job = qcx.current_query_job();
 197                 let job = QueryJob::new(id, span, job);
 198
 199                 let key = entry.key().clone();
 200                 entry.insert(QueryResult::Started(job));
 201
 202                 let owner = JobOwner { state, id, key };
 203                 return TryGetJob::NotYetStarted(owner);
 204             }
 205             Entry::Occupied(mut entry) => {
 206                 match entry.get_mut() {
 207                     #[cfg(not(parallel_compiler))]
 208                     QueryResult::Started(job) => {
 209                         let id = job.id;
 210                         drop(state_lock);
 211
 212                         // If we are single-threaded we know that we have cycle error,
 213                         // so we just return the error.
 214                         return TryGetJob::Cycle(id.find_cycle_in_stack(
 215                             qcx.try_collect_active_jobs().unwrap(),
 216                             &qcx.current_query_job(),
 217                             span,
 218                         ));
 219                     }
 220                     #[cfg(parallel_compiler)]
 221                     QueryResult::Started(job) => {
 222                         // For parallel queries, we'll block and wait until the query running
 223                         // in another thread has completed. Record how long we wait in the
 224                         // self-profiler.
 225                         let query_blocked_prof_timer = qcx.dep_context().profiler().query_blocked();
 226
 227                         // Get the latch out
 228                         let latch = job.latch();
 229
 230                         drop(state_lock);
 231
 232                         // With parallel queries we might just have to wait on some other
 233                         // thread.
 234                         let result = latch.wait_on(qcx.current_query_job(), span);
 235
 236                         match result {
 237                             Ok(()) => TryGetJob::JobCompleted(query_blocked_prof_timer),
 238                             Err(cycle) => TryGetJob::Cycle(cycle),
 239                         }
 240                     }
 241                     QueryResult::Poisoned => FatalError.raise(),
 242                 }
 243             }
 244         }
 245     }
 246
 247     /// Completes the query by updating the query cache with the `result`,
 248     /// signals the waiter and forgets the JobOwner, so it won't poison the query
 249     fn complete<C>(self, cache: &C, result: C::Value, dep_node_index: DepNodeIndex) -> C::Stored
 250     where
 251         C: QueryCache<Key = K>,
 252     {
 253         // We can move out of `self` here because we `mem::forget` it below
 254         let key = unsafe { ptr::read(&self.key) };
 255         let state = self.state;
 256
 257         // Forget ourself so our destructor won't poison the query
 258         mem::forget(self);
 259
 260         let (job, result) = {
 261             let job = {
 262                 #[cfg(parallel_compiler)]
 263                 let mut lock = state.active.get_shard_by_value(&key).lock();
 264                 #[cfg(not(parallel_compiler))]
 265                 let mut lock = state.active.lock();
 266                 match lock.remove(&key).unwrap() {
 267                     QueryResult::Started(job) => job,
 268                     QueryResult::Poisoned => panic!(),
 269                 }
 270             };
 271             let result = cache.complete(key, result, dep_node_index);
 272             (job, result)
 273         };
 274
 275         job.signal_complete();
 276         result
 277     }
 278 }
 279
 280 impl<'tcx, K, D> Drop for JobOwner<'tcx, K, D>
 281 where
 282     K: Eq + Hash + Clone,
 283     D: DepKind,
 284 {
 285     #[inline(never)]
 286     #[cold]
 287     fn drop(&mut self) {
 288         // Poison the query so jobs waiting on it panic.
 289         let state = self.state;
 290         let job = {
 291             #[cfg(parallel_compiler)]
 292             let mut shard = state.active.get_shard_by_value(&self.key).lock();
 293             #[cfg(not(parallel_compiler))]
 294             let mut shard = state.active.lock();
 295             let job = match shard.remove(&self.key).unwrap() {
 296                 QueryResult::Started(job) => job,
 297                 QueryResult::Poisoned => panic!(),
 298             };
 299             shard.insert(self.key.clone(), QueryResult::Poisoned);
 300             job
 301         };
 302         // Also signal the completion of the job, so waiters
 303         // will continue execution.
 304         job.signal_complete();
 305     }
 306 }
 307
 308 #[derive(Clone)]
 309 pub(crate) struct CycleError<D: DepKind> {
 310     /// The query and related span that uses the cycle.
 311     pub usage: Option<(Span, QueryStackFrame<D>)>,
 312     pub cycle: Vec<QueryInfo<D>>,
 313 }
 314
 315 /// The result of `try_start`.
 316 enum TryGetJob<'tcx, K, D>
 317 where
 318     K: Eq + Hash + Clone,
 319     D: DepKind,
 320 {
 321     /// The query is not yet started. Contains a guard to the cache eventually used to start it.
 322     NotYetStarted(JobOwner<'tcx, K, D>),
 323
 324     /// The query was already completed.
 325     /// Returns the result of the query and its dep-node index
 326     /// if it succeeded or a cycle error if it failed.
 327     #[cfg(parallel_compiler)]
 328     JobCompleted(TimingGuard<'tcx>),
 329
 330     /// Trying to execute the query resulted in a cycle.
 331     Cycle(CycleError<D>),
 332 }
 333
 334 /// Checks if the query is already computed and in the cache.
 335 /// It returns the shard index and a lock guard to the shard,
 336 /// which will be used if the query is not in the cache and we need
 337 /// to compute it.
 338 #[inline]
 339 pub fn try_get_cached<Tcx, C>(tcx: Tcx, cache: &C, key: &C::Key) -> Option<C::Stored>
 340 where
 341     C: QueryCache,
 342     Tcx: DepContext,
 343 {
 344     match cache.lookup(&key) {
 345         Some((value, index)) => {
 346             if std::intrinsics::unlikely(tcx.profiler().enabled()) {
 347                 tcx.profiler().query_cache_hit(index.into());
 348             }
 349             tcx.dep_graph().read_index(index);
 350             Some(value)
 351         }
 352         None => None,
 353     }
 354 }
 355
 356 fn try_execute_query<Q, Qcx>(
 357     qcx: Qcx,
 358     state: &QueryState<Q::Key, Qcx::DepKind>,
 359     cache: &Q::Cache,
 360     span: Span,
 361     key: Q::Key,
 362     dep_node: Option<DepNode<Qcx::DepKind>>,
 363 ) -> (Q::Stored, Option<DepNodeIndex>)
 364 where
 365     Q: QueryConfig<Qcx>,
 366     Qcx: QueryContext,
 367 {
 368     match JobOwner::<'_, Q::Key, Qcx::DepKind>::try_start(&qcx, state, span, key.clone()) {
 369         TryGetJob::NotYetStarted(job) => {
 370             let (result, dep_node_index) =
 371                 execute_job::<Q, Qcx>(qcx, key.clone(), dep_node, job.id);
 372             if Q::FEEDABLE {
 373                 // We may have put a value inside the cache from inside the execution.
 374                 // Verify that it has the same hash as what we have now, to ensure consistency.
 375                 if let Some((cached_result, _)) = cache.lookup(&key) {
 376                     let hasher = Q::HASH_RESULT.expect("feedable forbids no_hash");
 377
 378                     let old_hash = qcx.dep_context().with_stable_hashing_context(|mut hcx| {
 379                         hasher(&mut hcx, cached_result.borrow())
 380                     });
 381                     let new_hash = qcx
 382                         .dep_context()
 383                         .with_stable_hashing_context(|mut hcx| hasher(&mut hcx, &result));
 384                     debug_assert_eq!(
 385                         old_hash,
 386                         new_hash,
 387                         "Computed query value for {:?}({:?}) is inconsistent with fed value,\ncomputed={:#?}\nfed={:#?}",
 388                         Q::DEP_KIND,
 389                         key,
 390                         result,
 391                         cached_result,
 392                     );
 393                 }
 394             }
 395             let result = job.complete(cache, result, dep_node_index);
 396             (result, Some(dep_node_index))
 397         }
 398         TryGetJob::Cycle(error) => {
 399             let result = mk_cycle(qcx, error, Q::HANDLE_CYCLE_ERROR);
 400             (result, None)
 401         }
 402         #[cfg(parallel_compiler)]
 403         TryGetJob::JobCompleted(query_blocked_prof_timer) => {
 404             let Some((v, index)) = cache.lookup(&key) else {
 405                 panic!("value must be in cache after waiting")
 406             };
 407
 408             if std::intrinsics::unlikely(qcx.dep_context().profiler().enabled()) {
 409                 qcx.dep_context().profiler().query_cache_hit(index.into());
 410             }
 411             query_blocked_prof_timer.finish_with_query_invocation_id(index.into());
 412
 413             (v, Some(index))
 414         }
 415     }
 416 }
 417
 418 fn execute_job<Q, Qcx>(
 419     qcx: Qcx,
 420     key: Q::Key,
 421     mut dep_node_opt: Option<DepNode<Qcx::DepKind>>,
 422     job_id: QueryJobId,
 423 ) -> (Q::Value, DepNodeIndex)
 424 where
 425     Q: QueryConfig<Qcx>,
 426     Qcx: QueryContext,
 427 {
 428     let dep_graph = qcx.dep_context().dep_graph();
 429
 430     // Fast path for when incr. comp. is off.
 431     if !dep_graph.is_fully_enabled() {
 432         let prof_timer = qcx.dep_context().profiler().query_provider();
 433         let result = qcx.start_query(job_id, Q::DEPTH_LIMIT, None, || {
 434             Q::compute(qcx, &key)(*qcx.dep_context(), key)
 435         });
 436         let dep_node_index = dep_graph.next_virtual_depnode_index();
 437         prof_timer.finish_with_query_invocation_id(dep_node_index.into());
 438         return (result, dep_node_index);
 439     }
 440
 441     if !Q::ANON && !Q::EVAL_ALWAYS {
 442         // `to_dep_node` is expensive for some `DepKind`s.
 443         let dep_node =
 444             dep_node_opt.get_or_insert_with(|| Q::construct_dep_node(*qcx.dep_context(), &key));
 445
 446         // The diagnostics for this query will be promoted to the current session during
 447         // `try_mark_green()`, so we can ignore them here.
 448         if let Some(ret) = qcx.start_query(job_id, false, None, || {
 449             try_load_from_disk_and_cache_in_memory::<Q, Qcx>(qcx, &key, &dep_node)
 450         }) {
 451             return ret;
 452         }
 453     }
 454
 455     let prof_timer = qcx.dep_context().profiler().query_provider();
 456     let diagnostics = Lock::new(ThinVec::new());
 457
 458     let (result, dep_node_index) =
 459         qcx.start_query(job_id, Q::DEPTH_LIMIT, Some(&diagnostics), || {
 460             if Q::ANON {
 461                 return dep_graph.with_anon_task(*qcx.dep_context(), Q::DEP_KIND, || {
 462                     Q::compute(qcx, &key)(*qcx.dep_context(), key)
 463                 });
 464             }
 465
 466             // `to_dep_node` is expensive for some `DepKind`s.
 467             let dep_node =
 468                 dep_node_opt.unwrap_or_else(|| Q::construct_dep_node(*qcx.dep_context(), &key));
 469
 470             let task = Q::compute(qcx, &key);
 471             dep_graph.with_task(dep_node, *qcx.dep_context(), key, task, Q::HASH_RESULT)
 472         });
 473
 474     prof_timer.finish_with_query_invocation_id(dep_node_index.into());
 475
 476     let diagnostics = diagnostics.into_inner();
 477     let side_effects = QuerySideEffects { diagnostics };
 478
 479     if std::intrinsics::unlikely(!side_effects.is_empty()) {
 480         if Q::ANON {
 481             qcx.store_side_effects_for_anon_node(dep_node_index, side_effects);
 482         } else {
 483             qcx.store_side_effects(dep_node_index, side_effects);
 484         }
 485     }
 486
 487     (result, dep_node_index)
 488 }
 489
 490 fn try_load_from_disk_and_cache_in_memory<Q, Qcx>(
 491     qcx: Qcx,
 492     key: &Q::Key,
 493     dep_node: &DepNode<Qcx::DepKind>,
 494 ) -> Option<(Q::Value, DepNodeIndex)>
 495 where
 496     Q: QueryConfig<Qcx>,
 497     Qcx: QueryContext,
 498 {
 499     // Note this function can be called concurrently from the same query
 500     // We must ensure that this is handled correctly.
 501
 502     let dep_graph = qcx.dep_context().dep_graph();
 503     let (prev_dep_node_index, dep_node_index) = dep_graph.try_mark_green(qcx, &dep_node)?;
 504
 505     debug_assert!(dep_graph.is_green(dep_node));
 506
 507     // First we try to load the result from the on-disk cache.
 508     // Some things are never cached on disk.
 509     if let Some(try_load_from_disk) = Q::try_load_from_disk(qcx, &key) {
 510         let prof_timer = qcx.dep_context().profiler().incr_cache_loading();
 511
 512         // The call to `with_query_deserialization` enforces that no new `DepNodes`
 513         // are created during deserialization. See the docs of that method for more
 514         // details.
 515         let result =
 516             dep_graph.with_query_deserialization(|| try_load_from_disk(qcx, prev_dep_node_index));
 517
 518         prof_timer.finish_with_query_invocation_id(dep_node_index.into());
 519
 520         if let Some(result) = result {
 521             if std::intrinsics::unlikely(
 522                 qcx.dep_context().sess().opts.unstable_opts.query_dep_graph,
 523             ) {
 524                 dep_graph.mark_debug_loaded_from_disk(*dep_node)
 525             }
 526
 527             let prev_fingerprint = qcx
 528                 .dep_context()
 529                 .dep_graph()
 530                 .prev_fingerprint_of(dep_node)
 531                 .unwrap_or(Fingerprint::ZERO);
 532             // If `-Zincremental-verify-ich` is specified, re-hash results from
 533             // the cache and make sure that they have the expected fingerprint.
 534             //
 535             // If not, we still seek to verify a subset of fingerprints loaded
 536             // from disk. Re-hashing results is fairly expensive, so we can't
 537             // currently afford to verify every hash. This subset should still
 538             // give us some coverage of potential bugs though.
 539             let try_verify = prev_fingerprint.as_value().1 % 32 == 0;
 540             if std::intrinsics::unlikely(
 541                 try_verify || qcx.dep_context().sess().opts.unstable_opts.incremental_verify_ich,
 542             ) {
 543                 incremental_verify_ich(*qcx.dep_context(), &result, dep_node, Q::HASH_RESULT);
 544             }
 545
 546             return Some((result, dep_node_index));
 547         }
 548
 549         // We always expect to find a cached result for things that
 550         // can be forced from `DepNode`.
 551         debug_assert!(
 552             !qcx.dep_context().fingerprint_style(dep_node.kind).reconstructible(),
 553             "missing on-disk cache entry for {dep_node:?}"
 554         );
 555     }
 556
 557     // We could not load a result from the on-disk cache, so
 558     // recompute.
 559     let prof_timer = qcx.dep_context().profiler().query_provider();
 560
 561     // The dep-graph for this computation is already in-place.
 562     let result = dep_graph.with_ignore(|| Q::compute(qcx, key)(*qcx.dep_context(), key.clone()));
 563
 564     prof_timer.finish_with_query_invocation_id(dep_node_index.into());
 565
 566     // Verify that re-running the query produced a result with the expected hash
 567     // This catches bugs in query implementations, turning them into ICEs.
 568     // For example, a query might sort its result by `DefId` - since `DefId`s are
 569     // not stable across compilation sessions, the result could get up getting sorted
 570     // in a different order when the query is re-run, even though all of the inputs
 571     // (e.g. `DefPathHash` values) were green.
 572     //
 573     // See issue #82920 for an example of a miscompilation that would get turned into
 574     // an ICE by this check
 575     incremental_verify_ich(*qcx.dep_context(), &result, dep_node, Q::HASH_RESULT);
 576
 577     Some((result, dep_node_index))
 578 }
 579
 580 #[instrument(skip(tcx, result, hash_result), level = "debug")]
 581 pub(crate) fn incremental_verify_ich<Tcx, V: Debug>(
 582     tcx: Tcx,
 583     result: &V,
 584     dep_node: &DepNode<Tcx::DepKind>,
 585     hash_result: Option<fn(&mut StableHashingContext<'_>, &V) -> Fingerprint>,
 586 ) -> Fingerprint
 587 where
 588     Tcx: DepContext,
 589 {
 590     assert!(
 591         tcx.dep_graph().is_green(dep_node),
 592         "fingerprint for green query instance not loaded from cache: {dep_node:?}",
 593     );
 594
 595     let new_hash = hash_result.map_or(Fingerprint::ZERO, |f| {
 596         tcx.with_stable_hashing_context(|mut hcx| f(&mut hcx, result))
 597     });
 598
 599     let old_hash = tcx.dep_graph().prev_fingerprint_of(dep_node);
 600
 601     if Some(new_hash) != old_hash {
 602         incremental_verify_ich_failed(
 603             tcx.sess(),
 604             DebugArg::from(&dep_node),
 605             DebugArg::from(&result),
 606         );
 607     }
 608
 609     new_hash
 610 }
 611
 612 // This DebugArg business is largely a mirror of std::fmt::ArgumentV1, which is
 613 // currently not exposed publicly.
 614 //
 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
 619 // should be.
 620 extern "C" {
 621     type Opaque;
 622 }
 623
 624 struct DebugArg<'a> {
 625     value: &'a Opaque,
 626     fmt: fn(&Opaque, &mut std::fmt::Formatter<'_>) -> std::fmt::Result,
 627 }
 628
 629 impl<'a, T> From<&'a T> for DebugArg<'a>
 630 where
 631     T: std::fmt::Debug,
 632 {
 633     fn from(value: &'a T) -> DebugArg<'a> {
 634         DebugArg {
 635             value: unsafe { std::mem::transmute(value) },
 636             fmt: unsafe {
 637                 std::mem::transmute(<T as std::fmt::Debug>::fmt as fn(_, _) -> std::fmt::Result)
 638             },
 639         }
 640     }
 641 }
 642
 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)
 646     }
 647 }
 648
 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
 652 // binary, too).
 653 #[cold]
 654 fn incremental_verify_ich_failed(sess: &Session, dep_node: DebugArg<'_>, result: DebugArg<'_>) {
 655     // When we emit an error message and panic, we try to debug-print the `DepNode`
 656     // and query result. Unfortunately, this can cause us to run additional queries,
 657     // which may result in another fingerprint mismatch while we're in the middle
 658     // of processing this one. To avoid a double-panic (which kills the process
 659     // before we can print out the query static), we print out a terse
 660     // but 'safe' message if we detect a re-entrant call to this method.
 661     thread_local! {
 662         static INSIDE_VERIFY_PANIC: Cell<bool> = const { Cell::new(false) };
 663     };
 664
 665     let old_in_panic = INSIDE_VERIFY_PANIC.with(|in_panic| in_panic.replace(true));
 666
 667     if old_in_panic {
 668         sess.emit_err(crate::error::Reentrant);
 669     } else {
 670         let run_cmd = if let Some(crate_name) = &sess.opts.crate_name {
 671             format!("`cargo clean -p {crate_name}` or `cargo clean`")
 672         } else {
 673             "`cargo clean`".to_string()
 674         };
 675
 676         sess.emit_err(crate::error::IncrementCompilation {
 677             run_cmd,
 678             dep_node: format!("{dep_node:?}"),
 679         });
 680         panic!("Found unstable fingerprints for {dep_node:?}: {result:?}");
 681     }
 682
 683     INSIDE_VERIFY_PANIC.with(|in_panic| in_panic.set(old_in_panic));
 684 }
 685
 686 /// Ensure that either this query has all green inputs or been executed.
 687 /// Executing `query::ensure(D)` is considered a read of the dep-node `D`.
 688 /// Returns true if the query should still run.
 689 ///
 690 /// This function is particularly useful when executing passes for their
 691 /// side-effects -- e.g., in order to report errors for erroneous programs.
 692 ///
 693 /// Note: The optimization is only available during incr. comp.
 694 #[inline(never)]
 695 fn ensure_must_run<Q, Qcx>(qcx: Qcx, key: &Q::Key) -> (bool, Option<DepNode<Qcx::DepKind>>)
 696 where
 697     Q: QueryConfig<Qcx>,
 698     Qcx: QueryContext,
 699 {
 700     if Q::EVAL_ALWAYS {
 701         return (true, None);
 702     }
 703
 704     // Ensuring an anonymous query makes no sense
 705     assert!(!Q::ANON);
 706
 707     let dep_node = Q::construct_dep_node(*qcx.dep_context(), key);
 708
 709     let dep_graph = qcx.dep_context().dep_graph();
 710     match dep_graph.try_mark_green(qcx, &dep_node) {
 711         None => {
 712             // A None return from `try_mark_green` means that this is either
 713             // a new dep node or that the dep node has already been marked red.
 714             // Either way, we can't call `dep_graph.read()` as we don't have the
 715             // DepNodeIndex. We must invoke the query itself. The performance cost
 716             // this introduces should be negligible as we'll immediately hit the
 717             // in-memory cache, or another query down the line will.
 718             (true, Some(dep_node))
 719         }
 720         Some((_, dep_node_index)) => {
 721             dep_graph.read_index(dep_node_index);
 722             qcx.dep_context().profiler().query_cache_hit(dep_node_index.into());
 723             (false, None)
 724         }
 725     }
 726 }
 727
 728 #[derive(Debug)]
 729 pub enum QueryMode {
 730     Get,
 731     Ensure,
 732 }
 733
 734 pub fn get_query<Q, Qcx, D>(qcx: Qcx, span: Span, key: Q::Key, mode: QueryMode) -> Option<Q::Stored>
 735 where
 736     D: DepKind,
 737     Q: QueryConfig<Qcx>,
 738     Q::Value: Value<Qcx::DepContext, D>,
 739     Qcx: QueryContext,
 740 {
 741     let dep_node = if let QueryMode::Ensure = mode {
 742         let (must_run, dep_node) = ensure_must_run::<Q, _>(qcx, &key);
 743         if !must_run {
 744             return None;
 745         }
 746         dep_node
 747     } else {
 748         None
 749     };
 750
 751     let (result, dep_node_index) = try_execute_query::<Q, Qcx>(
 752         qcx,
 753         Q::query_state(qcx),
 754         Q::query_cache(qcx),
 755         span,
 756         key,
 757         dep_node,
 758     );
 759     if let Some(dep_node_index) = dep_node_index {
 760         qcx.dep_context().dep_graph().read_index(dep_node_index)
 761     }
 762     Some(result)
 763 }
 764
 765 pub fn force_query<Q, Qcx, D>(qcx: Qcx, key: Q::Key, dep_node: DepNode<Qcx::DepKind>)
 766 where
 767     D: DepKind,
 768     Q: QueryConfig<Qcx>,
 769     Q::Value: Value<Qcx::DepContext, D>,
 770     Qcx: QueryContext,
 771 {
 772     // We may be concurrently trying both execute and force a query.
 773     // Ensure that only one of them runs the query.
 774     let cache = Q::query_cache(qcx);
 775     if let Some((_, index)) = cache.lookup(&key) {
 776         if std::intrinsics::unlikely(qcx.dep_context().profiler().enabled()) {
 777             qcx.dep_context().profiler().query_cache_hit(index.into());
 778         }
 779         return;
 780     }
 781
 782     let state = Q::query_state(qcx);
 783     debug_assert!(!Q::ANON);
 784
 785     try_execute_query::<Q, _>(qcx, state, cache, DUMMY_SP, key, Some(dep_node));
 786 }