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::on_disk_cache
::{CacheDecoder, CacheEncoder, EncodedDepNodeIndex}
;
6 use crate::profiling_support
::QueryKeyStringCache
;
7 use crate::{on_disk_cache, Queries}
;
8 use rustc_data_structures
::stable_hasher
::{HashStable, StableHasher}
;
9 use rustc_data_structures
::sync
::{AtomicU64, Lock}
;
10 use rustc_errors
::{Diagnostic, Handler}
;
11 use rustc_middle
::dep_graph
::{
12 self, DepKind
, DepKindStruct
, DepNode
, DepNodeIndex
, SerializedDepNodeIndex
,
14 use rustc_middle
::query
::Key
;
15 use rustc_middle
::ty
::tls
::{self, ImplicitCtxt}
;
16 use rustc_middle
::ty
::{self, TyCtxt}
;
17 use rustc_query_system
::dep_graph
::{DepNodeParams, HasDepContext}
;
18 use rustc_query_system
::ich
::StableHashingContext
;
19 use rustc_query_system
::query
::{
20 force_query
, QueryConfig
, QueryContext
, QueryJobId
, QueryMap
, QuerySideEffects
, QueryStackFrame
,
22 use rustc_query_system
::{LayoutOfDepth, QueryOverflow, Value}
;
23 use rustc_serialize
::Decodable
;
24 use rustc_session
::Limit
;
25 use rustc_span
::def_id
::LOCAL_CRATE
;
27 use std
::num
::NonZeroU64
;
28 use thin_vec
::ThinVec
;
30 #[derive(Copy, Clone)]
31 pub struct QueryCtxt
<'tcx
> {
32 pub tcx
: TyCtxt
<'tcx
>,
33 pub queries
: &'tcx Queries
<'tcx
>,
36 impl<'tcx
> std
::ops
::Deref
for QueryCtxt
<'tcx
> {
37 type Target
= TyCtxt
<'tcx
>;
40 fn deref(&self) -> &Self::Target
{
45 impl<'tcx
> HasDepContext
for QueryCtxt
<'tcx
> {
46 type DepKind
= rustc_middle
::dep_graph
::DepKind
;
47 type DepContext
= TyCtxt
<'tcx
>;
50 fn dep_context(&self) -> &Self::DepContext
{
55 impl QueryContext
for QueryCtxt
<'_
> {
56 fn next_job_id(&self) -> QueryJobId
{
59 self.queries
.jobs
.fetch_add(1, rustc_data_structures
::sync
::Ordering
::Relaxed
),
65 fn current_query_job(&self) -> Option
<QueryJobId
> {
66 tls
::with_related_context(**self, |icx
| icx
.query
)
69 fn try_collect_active_jobs(&self) -> Option
<QueryMap
> {
70 self.queries
.try_collect_active_jobs(**self)
73 // Interactions with on_disk_cache
74 fn load_side_effects(&self, prev_dep_node_index
: SerializedDepNodeIndex
) -> QuerySideEffects
{
78 .map(|c
| c
.load_side_effects(**self, prev_dep_node_index
))
82 fn store_side_effects(&self, dep_node_index
: DepNodeIndex
, side_effects
: QuerySideEffects
) {
83 if let Some(c
) = self.queries
.on_disk_cache
.as_ref() {
84 c
.store_side_effects(dep_node_index
, side_effects
)
88 fn store_side_effects_for_anon_node(
90 dep_node_index
: DepNodeIndex
,
91 side_effects
: QuerySideEffects
,
93 if let Some(c
) = self.queries
.on_disk_cache
.as_ref() {
94 c
.store_side_effects_for_anon_node(dep_node_index
, side_effects
)
98 /// Executes a job by changing the `ImplicitCtxt` to point to the
99 /// new query job while it executes. It returns the diagnostics
100 /// captured during execution and the actual result.
106 diagnostics
: Option
<&Lock
<ThinVec
<Diagnostic
>>>,
107 compute
: impl FnOnce() -> R
,
109 // The `TyCtxt` stored in TLS has the same global interner lifetime
110 // as `self`, so we use `with_related_context` to relate the 'tcx lifetimes
111 // when accessing the `ImplicitCtxt`.
112 tls
::with_related_context(**self, move |current_icx
| {
113 if depth_limit
&& !self.recursion_limit().value_within_limit(current_icx
.query_depth
) {
114 self.depth_limit_error(token
);
117 // Update the `ImplicitCtxt` to point to our new query job.
118 let new_icx
= ImplicitCtxt
{
122 query_depth
: current_icx
.query_depth
+ depth_limit
as usize,
123 task_deps
: current_icx
.task_deps
,
126 // Use the `ImplicitCtxt` while we execute the query.
127 tls
::enter_context(&new_icx
, |_
| {
128 rustc_data_structures
::stack
::ensure_sufficient_stack(compute
)
133 fn depth_limit_error(&self, job
: QueryJobId
) {
135 let mut layout_of_depth
= None
;
136 if let Some(map
) = self.try_collect_active_jobs() {
137 if let Some((info
, depth
)) = job
.try_find_layout_root(map
) {
138 span
= Some(info
.job
.span
);
139 layout_of_depth
= Some(LayoutOfDepth { desc: info.query.description, depth }
);
143 let suggested_limit
= match self.recursion_limit() {
144 Limit(0) => Limit(2),
148 self.sess
.emit_fatal(QueryOverflow
{
152 crate_name
: self.crate_name(LOCAL_CRATE
),
157 impl<'tcx
> QueryCtxt
<'tcx
> {
159 pub fn from_tcx(tcx
: TyCtxt
<'tcx
>) -> Self {
160 let queries
= tcx
.queries
.as_any();
161 let queries
= unsafe {
162 let queries
= std
::mem
::transmute
::<&dyn Any
, &dyn Any
>(queries
);
163 let queries
= queries
.downcast_ref().unwrap();
164 let queries
= std
::mem
::transmute
::<&Queries
<'_
>, &Queries
<'_
>>(queries
);
167 QueryCtxt { tcx, queries }
170 pub(crate) fn on_disk_cache(self) -> Option
<&'tcx on_disk_cache
::OnDiskCache
<'tcx
>> {
171 self.queries
.on_disk_cache
.as_ref()
174 pub(super) fn encode_query_results(
176 encoder
: &mut CacheEncoder
<'_
, 'tcx
>,
177 query_result_index
: &mut EncodedDepNodeIndex
,
179 for query
in &self.queries
.query_structs
{
180 if let Some(encode
) = query
.encode_query_results
{
181 encode(self, encoder
, query_result_index
);
186 pub fn try_print_query_stack(
188 query
: Option
<QueryJobId
>,
190 num_frames
: Option
<usize>,
192 rustc_query_system
::query
::print_query_stack(self, query
, handler
, num_frames
)
196 #[derive(Clone, Copy)]
197 pub(crate) struct QueryStruct
<'tcx
> {
198 pub try_collect_active_jobs
: fn(QueryCtxt
<'tcx
>, &mut QueryMap
) -> Option
<()>,
199 pub alloc_self_profile_query_strings
: fn(TyCtxt
<'tcx
>, &mut QueryKeyStringCache
),
200 pub encode_query_results
:
201 Option
<fn(QueryCtxt
<'tcx
>, &mut CacheEncoder
<'_
, 'tcx
>, &mut EncodedDepNodeIndex
)>,
204 macro_rules
! handle_cycle_error
{
206 rustc_query_system
::HandleCycleError
::Error
208 ([(fatal_cycle
) $
($rest
:tt
)*]) => {{
209 rustc_query_system
::HandleCycleError
::Fatal
211 ([(cycle_delay_bug
) $
($rest
:tt
)*]) => {{
212 rustc_query_system
::HandleCycleError
::DelayBug
214 ([$other
:tt $
($modifiers
:tt
)*]) => {
215 handle_cycle_error
!([$
($modifiers
)*])
219 macro_rules
! is_anon
{
223 ([(anon
) $
($rest
:tt
)*]) => {{
226 ([$other
:tt $
($modifiers
:tt
)*]) => {
227 is_anon
!([$
($modifiers
)*])
231 macro_rules
! is_eval_always
{
235 ([(eval_always
) $
($rest
:tt
)*]) => {{
238 ([$other
:tt $
($modifiers
:tt
)*]) => {
239 is_eval_always
!([$
($modifiers
)*])
243 macro_rules
! depth_limit
{
247 ([(depth_limit
) $
($rest
:tt
)*]) => {{
250 ([$other
:tt $
($modifiers
:tt
)*]) => {
251 depth_limit
!([$
($modifiers
)*])
255 macro_rules
! feedable
{
259 ([(feedable
) $
($rest
:tt
)*]) => {{
262 ([$other
:tt $
($modifiers
:tt
)*]) => {
263 feedable
!([$
($modifiers
)*])
267 macro_rules
! hash_result
{
269 Some(dep_graph
::hash_result
)
271 ([(no_hash
) $
($rest
:tt
)*]) => {{
274 ([$other
:tt $
($modifiers
:tt
)*]) => {
275 hash_result
!([$
($modifiers
)*])
279 macro_rules
! get_provider
{
280 ([][$tcx
:expr
, $name
:ident
, $key
:expr
]) => {{
281 $tcx
.queries
.local_providers
.$name
283 ([(separate_provide_extern
) $
($rest
:tt
)*][$tcx
:expr
, $name
:ident
, $key
:expr
]) => {{
284 if $key
.query_crate_is_local() {
285 $tcx
.queries
.local_providers
.$name
287 $tcx
.queries
.extern_providers
.$name
290 ([$other
:tt $
($modifiers
:tt
)*][$
($args
:tt
)*]) => {
291 get_provider
!([$
($modifiers
)*][$
($args
)*])
295 macro_rules
! should_ever_cache_on_disk
{
299 ([(cache
) $
($rest
:tt
)*]) => {{
300 Some($
crate::plumbing
::try_load_from_disk
::<Self::Value
>)
302 ([$other
:tt $
($modifiers
:tt
)*]) => {
303 should_ever_cache_on_disk
!([$
($modifiers
)*])
307 pub(crate) fn create_query_frame
<
309 K
: Copy
+ Key
+ for<'a
> HashStable
<StableHashingContext
<'a
>>,
311 tcx
: QueryCtxt
<'tcx
>,
312 do_describe
: fn(TyCtxt
<'tcx
>, K
) -> String
,
316 ) -> QueryStackFrame
{
317 // Disable visible paths printing for performance reasons.
318 // Showing visible path instead of any path is not that important in production.
319 let description
= ty
::print
::with_no_visible_paths
!(
320 // Force filename-line mode to avoid invoking `type_of` query.
321 ty
::print
::with_forced_impl_filename_line
!(do_describe(tcx
.tcx
, key
))
324 if tcx
.sess
.verbose() { format!("{}
[{:?}
]", description, name) } else { description };
325 let span = if kind == dep_graph::DepKind::def_span {
326 // The `def_span` query is used to calculate `default_span`,
327 // so exit to avoid infinite recursion.
330 Some(key.default_span(*tcx))
332 let def_id = key.key_as_def_id();
333 let def_kind = if kind == dep_graph::DepKind::opt_def_kind {
334 // Try to avoid infinite recursion.
337 def_id.and_then(|def_id| def_id.as_local()).and_then(|def_id| tcx.opt_def_kind(def_id))
340 tcx.with_stable_hashing_context(|mut hcx| {
341 let mut hasher = StableHasher::new();
342 std::mem::discriminant(&kind).hash_stable(&mut hcx, &mut hasher);
343 key.hash_stable(&mut hcx, &mut hasher);
344 hasher.finish::<u64>()
347 let ty_adt_id = key.ty_adt_id();
349 QueryStackFrame::new(name, description, span, def_id, def_kind, ty_adt_id, hash)
352 fn try_load_from_on_disk_cache<'tcx, Q>(tcx: TyCtxt<'tcx>, dep_node: DepNode)
354 Q: QueryConfig<QueryCtxt<'tcx>>,
355 Q::Key: DepNodeParams<TyCtxt<'tcx>>,
357 debug_assert!(tcx.dep_graph.is_green(&dep_node));
359 let key = Q::Key::recover(tcx, &dep_node).unwrap_or_else(|| {
360 panic!("Failed to recover key
for {:?} with hash {}
", dep_node, dep_node.hash)
362 if Q::cache_on_disk(tcx, &key) {
363 let _ = Q::execute_query(tcx, key);
367 pub(crate) fn try_load_from_disk<'tcx, V>(
368 tcx: QueryCtxt<'tcx>,
369 id: SerializedDepNodeIndex,
372 V: for<'a> Decodable<CacheDecoder<'a, 'tcx>>,
374 tcx.on_disk_cache().as_ref()?.try_load_query_result(*tcx, id)
377 fn force_from_dep_node<'tcx, Q>(tcx: TyCtxt<'tcx>, dep_node: DepNode) -> bool
379 Q: QueryConfig<QueryCtxt<'tcx>>,
380 Q::Key: DepNodeParams<TyCtxt<'tcx>>,
381 Q::Value: Value<TyCtxt<'tcx>>,
383 // We must avoid ever having to call `force_from_dep_node()` for a
384 // `DepNode::codegen_unit`:
385 // Since we cannot reconstruct the query key of a `DepNode::codegen_unit`, we
386 // would always end up having to evaluate the first caller of the
387 // `codegen_unit` query that *is* reconstructible. This might very well be
388 // the `compile_codegen_unit` query, thus re-codegenning the whole CGU just
389 // to re-trigger calling the `codegen_unit` query with the right key. At
390 // that point we would already have re-done all the work we are trying to
391 // avoid doing in the first place.
392 // The solution is simple: Just explicitly call the `codegen_unit` query for
393 // each CGU, right after partitioning. This way `try_mark_green` will always
394 // hit the cache instead of having to go through `force_from_dep_node`.
395 // This assertion makes sure, we actually keep applying the solution above.
397 dep_node.kind != DepKind::codegen_unit,
398 "calling
force_from_dep_node() on DepKind
::codegen_unit
"
401 if let Some(key) = Q::Key::recover(tcx, &dep_node) {
402 #[cfg(debug_assertions)]
403 let _guard = tracing::span!(tracing::Level::TRACE, stringify!($name), ?key).entered();
404 let tcx = QueryCtxt::from_tcx(tcx);
405 force_query::<Q, _>(tcx, key, dep_node);
412 pub(crate) fn query_callback<'tcx, Q>(is_anon: bool, is_eval_always: bool) -> DepKindStruct<'tcx>
414 Q: QueryConfig<QueryCtxt<'tcx>>,
415 Q::Key: DepNodeParams<TyCtxt<'tcx>>,
417 let fingerprint_style = Q::Key::fingerprint_style();
419 if is_anon || !fingerprint_style.reconstructible() {
420 return DepKindStruct {
424 force_from_dep_node: None,
425 try_load_from_on_disk_cache: None,
433 force_from_dep_node: Some(force_from_dep_node::<Q>),
434 try_load_from_on_disk_cache: Some(try_load_from_on_disk_cache::<Q>),
438 macro_rules! expand_if_cached {
439 ([], $tokens:expr) => {{
442 ([(cache) $($rest:tt)*], $tokens:expr) => {{
445 ([$other:tt $($modifiers:tt)*], $tokens:expr) => {
446 expand_if_cached!([$($modifiers)*], $tokens)
450 // NOTE: `$V` isn't used here, but we still need to match on it so it can be passed to other macros
451 // invoked by `rustc_query_append`.
452 macro_rules! define_queries {
455 [$($modifiers:tt)*] fn $name:ident($($K:tt)*) -> $V:ty,)*) => {
456 define_queries_struct! {
457 input: ($(([$($modifiers)*] [$($attr)*] [$name]))*)
460 #[allow(nonstandard_style)]
462 use std::marker::PhantomData;
464 $(pub struct $name<'tcx> {
465 data: PhantomData<&'tcx ()>
469 $(impl<'tcx> QueryConfig<QueryCtxt<'tcx>> for queries::$name<'tcx> {
470 type Key = query_keys::$name<'tcx>;
471 type Value = query_values::$name<'tcx>;
472 type Stored = query_stored::$name<'tcx>;
473 const NAME: &'static str = stringify!($name);
476 fn cache_on_disk(tcx: TyCtxt<'tcx>, key: &Self::Key) -> bool {
477 ::rustc_middle::query::cached::$name(tcx, key)
480 type Cache = query_storage::$name<'tcx>;
483 fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>
484 where QueryCtxt<'tcx>: 'a
490 fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cache
493 &tcx.query_caches.$name
497 fn make_vtable(tcx: QueryCtxt<'tcx>, key: &Self::Key) ->
498 QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>
500 let compute = get_provider!([$($modifiers)*][tcx, $name, key]);
501 let cache_on_disk = Self::cache_on_disk(tcx.tcx, key);
503 anon: is_anon!([$($modifiers)*]),
504 eval_always: is_eval_always!([$($modifiers)*]),
505 depth_limit: depth_limit!([$($modifiers)*]),
506 feedable: feedable!([$($modifiers)*]),
507 dep_kind: dep_graph::DepKind::$name,
508 hash_result: hash_result!([$($modifiers)*]),
509 handle_cycle_error: handle_cycle_error!([$($modifiers)*]),
511 try_load_from_disk: if cache_on_disk { should_ever_cache_on_disk!([$($modifiers)*]) } else { None },
515 fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored {
520 #[allow(nonstandard_style)]
521 mod query_callbacks {
523 use rustc_query_system::dep_graph::FingerprintStyle;
525 // We use this for most things when incr. comp. is turned off.
526 pub fn Null<'tcx>() -> DepKindStruct<'tcx> {
529 is_eval_always: false,
530 fingerprint_style: FingerprintStyle::Unit,
531 force_from_dep_node: Some(|_, dep_node| bug!("force_from_dep_node
: encountered {:?}
", dep_node)),
532 try_load_from_on_disk_cache: None,
536 // We use this for the forever-red node.
537 pub fn Red<'tcx>() -> DepKindStruct<'tcx> {
540 is_eval_always: false,
541 fingerprint_style: FingerprintStyle::Unit,
542 force_from_dep_node: Some(|_, dep_node| bug!("force_from_dep_node
: encountered {:?}
", dep_node)),
543 try_load_from_on_disk_cache: None,
547 pub fn TraitSelect<'tcx>() -> DepKindStruct<'tcx> {
550 is_eval_always: false,
551 fingerprint_style: FingerprintStyle::Unit,
552 force_from_dep_node: None,
553 try_load_from_on_disk_cache: None,
557 pub fn CompileCodegenUnit<'tcx>() -> DepKindStruct<'tcx> {
560 is_eval_always: false,
561 fingerprint_style: FingerprintStyle::Opaque,
562 force_from_dep_node: None,
563 try_load_from_on_disk_cache: None,
567 pub fn CompileMonoItem<'tcx>() -> DepKindStruct<'tcx> {
570 is_eval_always: false,
571 fingerprint_style: FingerprintStyle::Opaque,
572 force_from_dep_node: None,
573 try_load_from_on_disk_cache: None,
577 $(pub(crate) fn $name<'tcx>()-> DepKindStruct<'tcx> {
578 $crate::plumbing::query_callback::<queries::$name<'tcx>>(
579 is_anon!([$($modifiers)*]),
580 is_eval_always!([$($modifiers)*]),
586 use rustc_middle::ty::TyCtxt;
587 use $crate::plumbing::{QueryStruct, QueryCtxt};
588 use $crate::profiling_support::QueryKeyStringCache;
589 use rustc_query_system::query::QueryMap;
591 pub(super) const fn dummy_query_struct<'tcx>() -> QueryStruct<'tcx> {
592 fn noop_try_collect_active_jobs(_: QueryCtxt<'_>, _: &mut QueryMap) -> Option<()> {
595 fn noop_alloc_self_profile_query_strings(_: TyCtxt<'_>, _: &mut QueryKeyStringCache) {}
598 try_collect_active_jobs: noop_try_collect_active_jobs,
599 alloc_self_profile_query_strings: noop_alloc_self_profile_query_strings,
600 encode_query_results: None,
604 pub(super) use dummy_query_struct as Null;
605 pub(super) use dummy_query_struct as Red;
606 pub(super) use dummy_query_struct as TraitSelect;
607 pub(super) use dummy_query_struct as CompileCodegenUnit;
608 pub(super) use dummy_query_struct as CompileMonoItem;
611 pub(super) const fn $name<'tcx>() -> QueryStruct<'tcx> { QueryStruct {
612 try_collect_active_jobs: |tcx, qmap| {
613 let make_query = |tcx, key| {
614 let kind = rustc_middle::dep_graph::DepKind::$name;
615 let name = stringify!($name);
616 $crate::plumbing::create_query_frame(tcx, rustc_middle::query::descs::$name, key, kind, name)
618 tcx.queries.$name.try_collect_active_jobs(
624 alloc_self_profile_query_strings: |tcx, string_cache| {
625 $crate::profiling_support::alloc_self_profile_query_strings_for_query_cache(
628 &tcx.query_caches.$name,
632 encode_query_results: expand_if_cached!([$($modifiers)*], |tcx, encoder, query_result_index|
633 $crate::on_disk_cache::encode_query_results::<_, super::queries::$name<'_>>(tcx, encoder, query_result_index)
638 pub fn query_callbacks<'tcx>(arena: &'tcx Arena<'tcx>) -> &'tcx [DepKindStruct<'tcx>] {
639 arena.alloc_from_iter(make_dep_kind_array!(query_callbacks))
644 use crate::{ExternProviders, OnDiskCache, Providers};
646 impl<'tcx> Queries<'tcx> {
648 local_providers: Providers,
649 extern_providers: ExternProviders,
650 on_disk_cache: Option<OnDiskCache<'tcx>>,
652 use crate::query_structs;
654 local_providers: Box::new(local_providers),
655 extern_providers: Box::new(extern_providers),
656 query_structs: make_dep_kind_array!(query_structs).to_vec(),
658 jobs: AtomicU64::new(1),
664 macro_rules! define_queries_struct {
666 input: ($(([$($modifiers:tt)*] [$($attr:tt)*] [$name:ident]))*)) => {
668 pub struct Queries<'tcx> {
669 local_providers: Box<Providers>,
670 extern_providers: Box<ExternProviders>,
671 query_structs: Vec<$crate::plumbing::QueryStruct<'tcx>>,
672 pub on_disk_cache: Option<OnDiskCache<'tcx>>,
678 <queries::$name<'tcx> as QueryConfig<QueryCtxt<'tcx>>>::Key
683 impl<'tcx> Queries<'tcx> {
684 pub(crate) fn try_collect_active_jobs(
687 ) -> Option<QueryMap> {
688 let tcx = QueryCtxt { tcx, queries: self };
689 let mut jobs = QueryMap::default();
691 for query in &self.query_structs {
692 (query.try_collect_active_jobs)(tcx, &mut jobs);
699 impl<'tcx> QueryEngine<'tcx> for Queries<'tcx> {
700 fn as_any(&'tcx self) -> &'tcx dyn std::any::Any {
701 let this = unsafe { std::mem::transmute::<&Queries<'_>, &Queries<'_>>(self) };
705 fn try_mark_green(&'tcx self, tcx: TyCtxt<'tcx>, dep_node: &dep_graph::DepNode) -> bool {
706 let qcx = QueryCtxt { tcx, queries: self };
707 tcx.dep_graph.try_mark_green(qcx, dep_node).is_some()
712 #[tracing::instrument(level = "trace
", skip(self, tcx), ret)]
717 key: <queries::$name<'tcx> as QueryConfig<QueryCtxt<'tcx>>>::Key,
719 ) -> Option<query_stored::$name<'tcx>> {
720 let qcx = QueryCtxt { tcx, queries: self };
721 get_query::<queries::$name<'tcx>, _>(qcx, span, key, mode)