Querify

Author: saethlin

compiler/rustc_codegen_ssa/src/mir/mod.rs

@@ -257,11 +257,11 @@ pub fn codegen_mir<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
     // Apply debuginfo to the newly allocated locals.
     fx.debug_introduce_locals(&mut start_bx);
 
-    let reachable_blocks = traversal::reachable_blocks_in_mono(mir, cx.tcx(), instance);
-
     // The builders will be created separately for each basic block at `codegen_block`.
     // So drop the builder of `start_llbb` to avoid having two at the same time.
     drop(start_bx);
+    
+    let reachable_blocks = cx.tcx().reachable_blocks(instance);
 
     // Codegen the body of each block using reverse postorder
     for (bb, _) in traversal::reverse_postorder(mir) {

compiler/rustc_interface/src/passes.rs

@@ -631,6 +631,7 @@ pub static DEFAULT_QUERY_PROVIDERS: LazyLock<Providers> = LazyLock::new(|| {
     rustc_lint::provide(providers);
     rustc_symbol_mangling::provide(providers);
     rustc_codegen_ssa::provide(providers);
+    rustc_middle::mir::traversal::provide(providers);
     *providers
 });
 

compiler/rustc_middle/src/mir/traversal.rs

@@ -1,7 +1,8 @@
+use crate::query::Providers;
+
 use super::*;
 
 /// Preorder traversal of a graph.
-///
 /// Preorder traversal is when each node is visited after at least one of its predecessors. If you
 /// are familiar with some basic graph theory, then this performs a depth first search and returns
 /// nodes in order of discovery time.
@@ -280,8 +281,7 @@ pub fn reverse_postorder<'a, 'tcx>(
     body.basic_blocks.reverse_postorder().iter().map(|&bb| (bb, &body.basic_blocks[bb]))
 }
 
-/// Finds which basic blocks are actually reachable for a specific
-/// monomorphization of this body.
+/// Finds which basic blocks are actually reachable for a monomorphized [`Instance`].
 ///
 /// This is allowed to have false positives; just because this says a block
 /// is reachable doesn't mean that's necessarily true. It's thus always
@@ -292,12 +292,12 @@ pub fn reverse_postorder<'a, 'tcx>(
 /// checks can be done without worrying about panicking.
 ///
 /// This is mostly useful because it lets us skip lowering the `false` side
-/// of `if <T as Trait>::CONST`, as well as `intrinsics::debug_assertions`.
-pub fn reachable_blocks_in_mono<'tcx>(
-    body: &Body<'tcx>,
+/// of `if <T as Trait>::CONST`, as well as [`intrinsics::ub_checks`].
+fn reachable_blocks<'tcx>(
     tcx: TyCtxt<'tcx>,
     instance: Instance<'tcx>,
 ) -> BitSet<BasicBlock> {
+    let body = tcx.instance_mir(instance.def);
     let mut visitor = MonoReachable {
         body,
         tcx,
@@ -348,3 +348,7 @@ impl<'a, 'tcx> MonoReachable<'a, 'tcx> {
         }
     }
 }
+
+pub fn provide(providers: &mut Providers) {
+    providers.reachable_blocks = reachable_blocks;
+}

compiler/rustc_middle/src/query/keys.rs

@@ -87,6 +87,15 @@ impl<'tcx> Key for ty::Instance<'tcx> {
     }
 }
 
+impl<'tcx> AsLocalKey for ty::Instance<'tcx> {
+    type LocalKey = Self;
+
+    #[inline(always)]
+    fn as_local_key(&self) -> Option<Self::LocalKey> {
+        self.def_id().is_local().then(|| *self)
+    }
+}
+
 impl<'tcx> Key for mir::interpret::GlobalId<'tcx> {
     type Cache<V> = DefaultCache<Self, V>;
 
@@ -534,6 +543,14 @@ impl<'tcx> Key for (ty::Instance<'tcx>, &'tcx ty::List<Ty<'tcx>>) {
     }
 }
 
+impl<'tcx> Key for (ty::Instance<'tcx>, &'tcx mir::Body<'tcx>) {
+    type Cache<V> = DefaultCache<Self, V>;
+
+    fn default_span(&self, tcx: TyCtxt<'_>) -> Span {
+        self.0.default_span(tcx)
+    }
+}
+
 impl<'tcx> Key for (Ty<'tcx>, ty::ValTree<'tcx>) {
     type Cache<V> = DefaultCache<Self, V>;
 

compiler/rustc_middle/src/query/mod.rs

@@ -71,6 +71,7 @@ use rustc_hir::def_id::{
 };
 use rustc_hir::lang_items::{LangItem, LanguageItems};
 use rustc_hir::{Crate, ItemLocalId, ItemLocalMap, TraitCandidate};
+use rustc_index::bit_set::BitSet;
 use rustc_index::IndexVec;
 use rustc_query_system::ich::StableHashingContext;
 use rustc_query_system::query::{try_get_cached, QueryCache, QueryMode, QueryState};
@@ -270,7 +271,7 @@ rustc_queries! {
         feedable
     }
 
-    query unsizing_params_for_adt(key: DefId) -> &'tcx rustc_index::bit_set::BitSet<u32>
+    query unsizing_params_for_adt(key: DefId) -> &'tcx BitSet<u32>
     {
         arena_cache
         desc { |tcx|
@@ -460,7 +461,7 @@ rustc_queries! {
     }
 
     /// Set of param indexes for type params that are in the type's representation
-    query params_in_repr(key: DefId) -> &'tcx rustc_index::bit_set::BitSet<u32> {
+    query params_in_repr(key: DefId) -> &'tcx BitSet<u32> {
         desc { "finding type parameters in the representation" }
         arena_cache
         no_hash
@@ -2251,6 +2252,11 @@ rustc_queries! {
     query find_field((def_id, ident): (DefId, rustc_span::symbol::Ident)) -> Option<rustc_target::abi::FieldIdx> {
         desc { |tcx| "find the index of maybe nested field `{ident}` in `{}`", tcx.def_path_str(def_id) }
     }
+
+    query reachable_blocks(instance: ty::Instance<'tcx>) -> &'tcx BitSet<mir::BasicBlock> {
+        arena_cache
+        desc { |tcx| "determining reachable blocks in `{}`", tcx.def_path_str(instance.def_id()) }
+    }
 }
 
 rustc_query_append! { define_callbacks! }

compiler/rustc_monomorphize/src/collector.rs

@@ -672,7 +672,7 @@ struct MirUsedCollector<'a, 'tcx> {
     visiting_call_terminator: bool,
     /// Set of functions for which it is OK to move large data into.
     skip_move_check_fns: Option<Vec<DefId>>,
-    reachable_blocks: BitSet<mir::BasicBlock>,
+    reachable_blocks: Option<&'tcx BitSet<mir::BasicBlock>>,
 }
 
 impl<'a, 'tcx> MirUsedCollector<'a, 'tcx> {
@@ -834,7 +834,11 @@ impl<'a, 'tcx> MirUsedCollector<'a, 'tcx> {
 
 impl<'a, 'tcx> MirVisitor<'tcx> for MirUsedCollector<'a, 'tcx> {
     fn visit_basic_block_data(&mut self, block: mir::BasicBlock, data: &mir::BasicBlockData<'tcx>) {
-        if self.reachable_blocks.contains(block) {
+        if self
+            .reachable_blocks
+            .expect("we should only walk blocks with CollectionMode::UsedItems")
+            .contains(block)
+        {
             self.super_basic_block_data(block, data)
         }
     }
@@ -1420,9 +1424,9 @@ fn collect_items_of_instance<'tcx>(
         visiting_call_terminator: false,
         skip_move_check_fns: None,
         reachable_blocks: if mode == CollectionMode::UsedItems {
-            mir::traversal::reachable_blocks_in_mono(body, tcx, instance)
+            Some(tcx.reachable_blocks(instance))
         } else {
-            BitSet::new_filled(body.basic_blocks.len())
+            None
         },
     };