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