compiler/rustc_query_impl/src/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::{on_disk_cache, Queries};
   6 use rustc_middle::dep_graph::{DepNodeIndex, SerializedDepNodeIndex};
   7 use rustc_middle::ty::tls::{self, ImplicitCtxt};
   8 use rustc_middle::ty::TyCtxt;
   9 use rustc_query_system::dep_graph::HasDepContext;
  10 use rustc_query_system::query::{QueryContext, QueryJobId, QueryMap, QuerySideEffects};
  11
  12 use rustc_data_structures::sync::Lock;
  13 use rustc_data_structures::thin_vec::ThinVec;
  14 use rustc_errors::{Diagnostic, Handler};
  15 use rustc_serialize::opaque;
  16
  17 use std::any::Any;
  18 use std::num::NonZeroU64;
  19
  20 #[derive(Copy, Clone)]
  21 pub struct QueryCtxt<'tcx> {
  22     pub tcx: TyCtxt<'tcx>,
  23     pub queries: &'tcx Queries<'tcx>,
  24 }
  25
  26 impl<'tcx> std::ops::Deref for QueryCtxt<'tcx> {
  27     type Target = TyCtxt<'tcx>;
  28
  29     #[inline]
  30     fn deref(&self) -> &Self::Target {
  31         &self.tcx
  32     }
  33 }
  34
  35 impl<'tcx> HasDepContext for QueryCtxt<'tcx> {
  36     type DepKind = rustc_middle::dep_graph::DepKind;
  37     type DepContext = TyCtxt<'tcx>;
  38
  39     #[inline]
  40     fn dep_context(&self) -> &Self::DepContext {
  41         &self.tcx
  42     }
  43 }
  44
  45 impl QueryContext for QueryCtxt<'_> {
  46     fn next_job_id(&self) -> QueryJobId {
  47         QueryJobId(
  48             NonZeroU64::new(
  49                 self.queries.jobs.fetch_add(1, rustc_data_structures::sync::Ordering::Relaxed),
  50             )
  51             .unwrap(),
  52         )
  53     }
  54
  55     fn current_query_job(&self) -> Option<QueryJobId> {
  56         tls::with_related_context(**self, |icx| icx.query)
  57     }
  58
  59     fn try_collect_active_jobs(&self) -> Option<QueryMap> {
  60         self.queries.try_collect_active_jobs(**self)
  61     }
  62
  63     // Interactions with on_disk_cache
  64     fn load_side_effects(&self, prev_dep_node_index: SerializedDepNodeIndex) -> QuerySideEffects {
  65         self.queries
  66             .on_disk_cache
  67             .as_ref()
  68             .map(|c| c.load_side_effects(**self, prev_dep_node_index))
  69             .unwrap_or_default()
  70     }
  71
  72     fn store_side_effects(&self, dep_node_index: DepNodeIndex, side_effects: QuerySideEffects) {
  73         if let Some(c) = self.queries.on_disk_cache.as_ref() {
  74             c.store_side_effects(dep_node_index, side_effects)
  75         }
  76     }
  77
  78     fn store_side_effects_for_anon_node(
  79         &self,
  80         dep_node_index: DepNodeIndex,
  81         side_effects: QuerySideEffects,
  82     ) {
  83         if let Some(c) = self.queries.on_disk_cache.as_ref() {
  84             c.store_side_effects_for_anon_node(dep_node_index, side_effects)
  85         }
  86     }
  87
  88     /// Executes a job by changing the `ImplicitCtxt` to point to the
  89     /// new query job while it executes. It returns the diagnostics
  90     /// captured during execution and the actual result.
  91     #[inline(always)]
  92     fn start_query<R>(
  93         &self,
  94         token: QueryJobId,
  95         diagnostics: Option<&Lock<ThinVec<Diagnostic>>>,
  96         compute: impl FnOnce() -> R,
  97     ) -> R {
  98         // The `TyCtxt` stored in TLS has the same global interner lifetime
  99         // as `self`, so we use `with_related_context` to relate the 'tcx lifetimes
 100         // when accessing the `ImplicitCtxt`.
 101         tls::with_related_context(**self, move |current_icx| {
 102             // Update the `ImplicitCtxt` to point to our new query job.
 103             let new_icx = ImplicitCtxt {
 104                 tcx: **self,
 105                 query: Some(token),
 106                 diagnostics,
 107                 layout_depth: current_icx.layout_depth,
 108                 task_deps: current_icx.task_deps,
 109             };
 110
 111             // Use the `ImplicitCtxt` while we execute the query.
 112             tls::enter_context(&new_icx, |_| {
 113                 rustc_data_structures::stack::ensure_sufficient_stack(compute)
 114             })
 115         })
 116     }
 117 }
 118
 119 impl<'tcx> QueryCtxt<'tcx> {
 120     #[inline]
 121     pub fn from_tcx(tcx: TyCtxt<'tcx>) -> Self {
 122         let queries = tcx.queries.as_any();
 123         let queries = unsafe {
 124             let queries = std::mem::transmute::<&dyn Any, &dyn Any>(queries);
 125             let queries = queries.downcast_ref().unwrap();
 126             let queries = std::mem::transmute::<&Queries<'_>, &Queries<'_>>(queries);
 127             queries
 128         };
 129         QueryCtxt { tcx, queries }
 130     }
 131
 132     crate fn on_disk_cache(self) -> Option<&'tcx on_disk_cache::OnDiskCache<'tcx>> {
 133         self.queries.on_disk_cache.as_ref()
 134     }
 135
 136     #[cfg(parallel_compiler)]
 137     pub unsafe fn deadlock(self, registry: &rustc_rayon_core::Registry) {
 138         rustc_query_system::query::deadlock(self, registry)
 139     }
 140
 141     pub(super) fn encode_query_results(
 142         self,
 143         encoder: &mut on_disk_cache::CacheEncoder<'_, 'tcx, opaque::FileEncoder>,
 144         query_result_index: &mut on_disk_cache::EncodedDepNodeIndex,
 145     ) -> opaque::FileEncodeResult {
 146         macro_rules! encode_queries {
 147             ($($query:ident,)*) => {
 148                 $(
 149                     on_disk_cache::encode_query_results::<_, super::queries::$query<'_>>(
 150                         self,
 151                         encoder,
 152                         query_result_index
 153                     )?;
 154                 )*
 155             }
 156         }
 157
 158         rustc_cached_queries!(encode_queries!);
 159
 160         Ok(())
 161     }
 162
 163     pub fn try_print_query_stack(
 164         self,
 165         query: Option<QueryJobId>,
 166         handler: &Handler,
 167         num_frames: Option<usize>,
 168     ) -> usize {
 169         rustc_query_system::query::print_query_stack(self, query, handler, num_frames)
 170     }
 171 }
 172
 173 macro_rules! handle_cycle_error {
 174     ([][$tcx: expr, $error:expr]) => {{
 175         $error.emit();
 176         Value::from_cycle_error($tcx)
 177     }};
 178     ([(fatal_cycle) $($rest:tt)*][$tcx:expr, $error:expr]) => {{
 179         $error.emit();
 180         $tcx.sess.abort_if_errors();
 181         unreachable!()
 182     }};
 183     ([(cycle_delay_bug) $($rest:tt)*][$tcx:expr, $error:expr]) => {{
 184         $error.delay_as_bug();
 185         Value::from_cycle_error($tcx)
 186     }};
 187     ([$other:tt $($modifiers:tt)*][$($args:tt)*]) => {
 188         handle_cycle_error!([$($modifiers)*][$($args)*])
 189     };
 190 }
 191
 192 macro_rules! is_anon {
 193     ([]) => {{
 194         false
 195     }};
 196     ([(anon) $($rest:tt)*]) => {{
 197         true
 198     }};
 199     ([$other:tt $($modifiers:tt)*]) => {
 200         is_anon!([$($modifiers)*])
 201     };
 202 }
 203
 204 macro_rules! is_eval_always {
 205     ([]) => {{
 206         false
 207     }};
 208     ([(eval_always) $($rest:tt)*]) => {{
 209         true
 210     }};
 211     ([$other:tt $($modifiers:tt)*]) => {
 212         is_eval_always!([$($modifiers)*])
 213     };
 214 }
 215
 216 macro_rules! hash_result {
 217     ([]) => {{
 218         Some(dep_graph::hash_result)
 219     }};
 220     ([(no_hash) $($rest:tt)*]) => {{
 221         None
 222     }};
 223     ([$other:tt $($modifiers:tt)*]) => {
 224         hash_result!([$($modifiers)*])
 225     };
 226 }
 227
 228 macro_rules! get_provider {
 229     ([][$tcx:expr, $name:ident, $key:expr]) => {{
 230         $tcx.queries.local_providers.$name
 231     }};
 232     ([(separate_provide_extern) $($rest:tt)*][$tcx:expr, $name:ident, $key:expr]) => {{
 233         if $key.query_crate_is_local() {
 234             $tcx.queries.local_providers.$name
 235         } else {
 236             $tcx.queries.extern_providers.$name
 237         }
 238     }};
 239     ([$other:tt $($modifiers:tt)*][$($args:tt)*]) => {
 240         get_provider!([$($modifiers)*][$($args)*])
 241     };
 242 }
 243
 244 macro_rules! opt_remap_env_constness {
 245     ([][$name:ident]) => {};
 246     ([(remap_env_constness) $($rest:tt)*][$name:ident]) => {
 247         let $name = $name.without_const();
 248     };
 249     ([$other:tt $($modifiers:tt)*][$name:ident]) => {
 250         opt_remap_env_constness!([$($modifiers)*][$name])
 251     };
 252 }
 253
 254 macro_rules! define_queries {
 255     (<$tcx:tt>
 256      $($(#[$attr:meta])*
 257         [$($modifiers:tt)*] fn $name:ident($($K:tt)*) -> $V:ty,)*) => {
 258
 259         define_queries_struct! {
 260             tcx: $tcx,
 261             input: ($(([$($modifiers)*] [$($attr)*] [$name]))*)
 262         }
 263
 264         mod make_query {
 265             use super::*;
 266
 267             // Create an eponymous constructor for each query.
 268             $(#[allow(nonstandard_style)] $(#[$attr])*
 269             pub fn $name<$tcx>(tcx: QueryCtxt<$tcx>, key: query_keys::$name<$tcx>) -> QueryStackFrame {
 270                 opt_remap_env_constness!([$($modifiers)*][key]);
 271                 let kind = dep_graph::DepKind::$name;
 272                 let name = stringify!($name);
 273                 // Disable visible paths printing for performance reasons.
 274                 // Showing visible path instead of any path is not that important in production.
 275                 let description = ty::print::with_no_visible_paths!(
 276                     // Force filename-line mode to avoid invoking `type_of` query.
 277                     ty::print::with_forced_impl_filename_line!(
 278                         queries::$name::describe(tcx, key)
 279                     )
 280                 );
 281                 let description = if tcx.sess.verbose() {
 282                     format!("{} [{}]", description, name)
 283                 } else {
 284                     description
 285                 };
 286                 let span = if kind == dep_graph::DepKind::def_span {
 287                     // The `def_span` query is used to calculate `default_span`,
 288                     // so exit to avoid infinite recursion.
 289                     None
 290                 } else {
 291                     Some(key.default_span(*tcx))
 292                 };
 293                 let def_id = key.key_as_def_id();
 294                 let def_kind = def_id
 295                     .and_then(|def_id| def_id.as_local())
 296                     // Use `tcx.hir().opt_def_kind()` to reduce the chance of
 297                     // accidentally triggering an infinite query loop.
 298                     .and_then(|def_id| tcx.hir().opt_def_kind(def_id))
 299                     .map(|def_kind| $crate::util::def_kind_to_simple_def_kind(def_kind));
 300                 let hash = || {
 301                     let mut hcx = tcx.create_stable_hashing_context();
 302                     let mut hasher = StableHasher::new();
 303                     std::mem::discriminant(&kind).hash_stable(&mut hcx, &mut hasher);
 304                     key.hash_stable(&mut hcx, &mut hasher);
 305                     hasher.finish::<u64>()
 306                 };
 307
 308                 QueryStackFrame::new(name, description, span, def_kind, hash)
 309             })*
 310         }
 311
 312         #[allow(nonstandard_style)]
 313         mod queries {
 314             use std::marker::PhantomData;
 315
 316             $(pub struct $name<$tcx> {
 317                 data: PhantomData<&$tcx ()>
 318             })*
 319         }
 320
 321         $(impl<$tcx> QueryConfig for queries::$name<$tcx> {
 322             type Key = query_keys::$name<$tcx>;
 323             type Value = query_values::$name<$tcx>;
 324             type Stored = query_stored::$name<$tcx>;
 325             const NAME: &'static str = stringify!($name);
 326         }
 327
 328         impl<$tcx> QueryDescription<QueryCtxt<$tcx>> for queries::$name<$tcx> {
 329             rustc_query_description! { $name<$tcx> }
 330
 331             type Cache = query_storage::$name<$tcx>;
 332
 333             #[inline(always)]
 334             fn query_state<'a>(tcx: QueryCtxt<$tcx>) -> &'a QueryState<Self::Key>
 335                 where QueryCtxt<$tcx>: 'a
 336             {
 337                 &tcx.queries.$name
 338             }
 339
 340             #[inline(always)]
 341             fn query_cache<'a>(tcx: QueryCtxt<$tcx>) -> &'a QueryCacheStore<Self::Cache>
 342                 where 'tcx:'a
 343             {
 344                 &tcx.query_caches.$name
 345             }
 346
 347             #[inline]
 348             fn make_vtable(tcx: QueryCtxt<'tcx>, key: &Self::Key) ->
 349                 QueryVtable<QueryCtxt<$tcx>, Self::Key, Self::Value>
 350             {
 351                 let compute = get_provider!([$($modifiers)*][tcx, $name, key]);
 352                 let cache_on_disk = Self::cache_on_disk(tcx.tcx, key);
 353                 QueryVtable {
 354                     anon: is_anon!([$($modifiers)*]),
 355                     eval_always: is_eval_always!([$($modifiers)*]),
 356                     dep_kind: dep_graph::DepKind::$name,
 357                     hash_result: hash_result!([$($modifiers)*]),
 358                     handle_cycle_error: |tcx, mut error| handle_cycle_error!([$($modifiers)*][tcx, error]),
 359                     compute,
 360                     cache_on_disk,
 361                     try_load_from_disk: Self::TRY_LOAD_FROM_DISK,
 362                 }
 363             }
 364         })*
 365
 366         #[allow(nonstandard_style)]
 367         mod query_callbacks {
 368             use super::*;
 369             use rustc_middle::dep_graph::DepNode;
 370             use rustc_middle::ty::query::query_keys;
 371             use rustc_query_system::dep_graph::DepNodeParams;
 372             use rustc_query_system::query::{force_query, QueryDescription};
 373             use rustc_query_system::dep_graph::FingerprintStyle;
 374
 375             // We use this for most things when incr. comp. is turned off.
 376             pub fn Null() -> DepKindStruct {
 377                 DepKindStruct {
 378                     is_anon: false,
 379                     is_eval_always: false,
 380                     fingerprint_style: FingerprintStyle::Unit,
 381                     force_from_dep_node: Some(|_, dep_node| bug!("force_from_dep_node: encountered {:?}", dep_node)),
 382                     try_load_from_on_disk_cache: None,
 383                 }
 384             }
 385
 386             pub fn TraitSelect() -> DepKindStruct {
 387                 DepKindStruct {
 388                     is_anon: true,
 389                     is_eval_always: false,
 390                     fingerprint_style: FingerprintStyle::Unit,
 391                     force_from_dep_node: None,
 392                     try_load_from_on_disk_cache: None,
 393                 }
 394             }
 395
 396             pub fn CompileCodegenUnit() -> DepKindStruct {
 397                 DepKindStruct {
 398                     is_anon: false,
 399                     is_eval_always: false,
 400                     fingerprint_style: FingerprintStyle::Opaque,
 401                     force_from_dep_node: None,
 402                     try_load_from_on_disk_cache: None,
 403                 }
 404             }
 405
 406             pub fn CompileMonoItem() -> DepKindStruct {
 407                 DepKindStruct {
 408                     is_anon: false,
 409                     is_eval_always: false,
 410                     fingerprint_style: FingerprintStyle::Opaque,
 411                     force_from_dep_node: None,
 412                     try_load_from_on_disk_cache: None,
 413                 }
 414             }
 415
 416             $(pub(crate) fn $name()-> DepKindStruct {
 417                 let is_anon = is_anon!([$($modifiers)*]);
 418                 let is_eval_always = is_eval_always!([$($modifiers)*]);
 419
 420                 let fingerprint_style =
 421                     <query_keys::$name<'_> as DepNodeParams<TyCtxt<'_>>>::fingerprint_style();
 422
 423                 if is_anon || !fingerprint_style.reconstructible() {
 424                     return DepKindStruct {
 425                         is_anon,
 426                         is_eval_always,
 427                         fingerprint_style,
 428                         force_from_dep_node: None,
 429                         try_load_from_on_disk_cache: None,
 430                     }
 431                 }
 432
 433                 #[inline(always)]
 434                 fn recover<'tcx>(tcx: TyCtxt<'tcx>, dep_node: DepNode) -> Option<query_keys::$name<'tcx>> {
 435                     <query_keys::$name<'_> as DepNodeParams<TyCtxt<'_>>>::recover(tcx, &dep_node)
 436                 }
 437
 438                 fn force_from_dep_node(tcx: TyCtxt<'_>, dep_node: DepNode) -> bool {
 439                     if let Some(key) = recover(tcx, dep_node) {
 440                         let tcx = QueryCtxt::from_tcx(tcx);
 441                         force_query::<queries::$name<'_>, _>(tcx, key, dep_node);
 442                         true
 443                     } else {
 444                         false
 445                     }
 446                 }
 447
 448                 fn try_load_from_on_disk_cache(tcx: TyCtxt<'_>, dep_node: DepNode) {
 449                     debug_assert!(tcx.dep_graph.is_green(&dep_node));
 450
 451                     let key = recover(tcx, dep_node).unwrap_or_else(|| panic!("Failed to recover key for {:?} with hash {}", dep_node, dep_node.hash));
 452                     if queries::$name::cache_on_disk(tcx, &key) {
 453                         let _ = tcx.$name(key);
 454                     }
 455                 }
 456
 457                 DepKindStruct {
 458                     is_anon,
 459                     is_eval_always,
 460                     fingerprint_style,
 461                     force_from_dep_node: Some(force_from_dep_node),
 462                     try_load_from_on_disk_cache: Some(try_load_from_on_disk_cache),
 463                 }
 464             })*
 465         }
 466
 467         pub fn query_callbacks<'tcx>(arena: &'tcx Arena<'tcx>) -> &'tcx [DepKindStruct] {
 468             arena.alloc_from_iter(make_dep_kind_array!(query_callbacks))
 469         }
 470     }
 471 }
 472
 473 // FIXME(eddyb) this macro (and others?) use `$tcx` and `'tcx` interchangeably.
 474 // We should either not take `$tcx` at all and use `'tcx` everywhere, or use
 475 // `$tcx` everywhere (even if that isn't necessary due to lack of hygiene).
 476 macro_rules! define_queries_struct {
 477     (tcx: $tcx:tt,
 478      input: ($(([$($modifiers:tt)*] [$($attr:tt)*] [$name:ident]))*)) => {
 479         pub struct Queries<$tcx> {
 480             local_providers: Box<Providers>,
 481             extern_providers: Box<ExternProviders>,
 482
 483             pub on_disk_cache: Option<OnDiskCache<$tcx>>,
 484
 485             jobs: AtomicU64,
 486
 487             $($(#[$attr])*  $name: QueryState<query_keys::$name<$tcx>>,)*
 488         }
 489
 490         impl<$tcx> Queries<$tcx> {
 491             pub fn new(
 492                 local_providers: Providers,
 493                 extern_providers: ExternProviders,
 494                 on_disk_cache: Option<OnDiskCache<$tcx>>,
 495             ) -> Self {
 496                 Queries {
 497                     local_providers: Box::new(local_providers),
 498                     extern_providers: Box::new(extern_providers),
 499                     on_disk_cache,
 500                     jobs: AtomicU64::new(1),
 501                     $($name: Default::default()),*
 502                 }
 503             }
 504
 505             pub(crate) fn try_collect_active_jobs(
 506                 &$tcx self,
 507                 tcx: TyCtxt<$tcx>,
 508             ) -> Option<QueryMap> {
 509                 let tcx = QueryCtxt { tcx, queries: self };
 510                 let mut jobs = QueryMap::default();
 511
 512                 $(
 513                     self.$name.try_collect_active_jobs(
 514                         tcx,
 515                         make_query::$name,
 516                         &mut jobs,
 517                     )?;
 518                 )*
 519
 520                 Some(jobs)
 521             }
 522         }
 523
 524         impl<'tcx> QueryEngine<'tcx> for Queries<'tcx> {
 525             fn as_any(&'tcx self) -> &'tcx dyn std::any::Any {
 526                 let this = unsafe { std::mem::transmute::<&Queries<'_>, &Queries<'_>>(self) };
 527                 this as _
 528             }
 529
 530             fn try_mark_green(&'tcx self, tcx: TyCtxt<'tcx>, dep_node: &dep_graph::DepNode) -> bool {
 531                 let qcx = QueryCtxt { tcx, queries: self };
 532                 tcx.dep_graph.try_mark_green(qcx, dep_node).is_some()
 533             }
 534
 535             $($(#[$attr])*
 536             #[inline(always)]
 537             fn $name(
 538                 &'tcx self,
 539                 tcx: TyCtxt<$tcx>,
 540                 span: Span,
 541                 key: query_keys::$name<$tcx>,
 542                 lookup: QueryLookup,
 543                 mode: QueryMode,
 544             ) -> Option<query_stored::$name<$tcx>> {
 545                 opt_remap_env_constness!([$($modifiers)*][key]);
 546                 let qcx = QueryCtxt { tcx, queries: self };
 547                 get_query::<queries::$name<$tcx>, _>(qcx, span, key, lookup, mode)
 548             })*
 549         }
 550     };
 551 }