Rollup merge of #155026 - nnethercote:mv-maybe_loop_headers, r=dianqk

Move `maybe_loop_headers` out of `rustc_middle`.

`rustc_middle` is enormous and it's always good to move things out of it where possible. `maybe_loop_headers` is easy to move because it has a single use in `jump_threading.rs`.

r? @WaffleLapkin

Author: jhpratt

compiler/rustc_middle/src/mir/loops.rs

@@ -48,8 +48,6 @@ mod query;
 mod statement;
 mod syntax;
 mod terminator;
-
-pub mod loops;
 pub mod traversal;
 pub mod visit;
 

compiler/rustc_middle/src/mir/mod.rs

@@ -97,7 +97,7 @@ impl<'tcx> crate::MirPass<'tcx> for JumpThreading {
             ecx: InterpCx::new(tcx, DUMMY_SP, typing_env, DummyMachine),
             body,
             map: Map::new(tcx, body, PlaceCollectionMode::OnDemand),
-            maybe_loop_headers: loops::maybe_loop_headers(body),
+            maybe_loop_headers: maybe_loop_headers(body),
             entry_states: IndexVec::from_elem(ConditionSet::default(), &body.basic_blocks),
         };
 
@@ -1100,3 +1100,29 @@ impl<'a, 'tcx> OpportunitySet<'a, 'tcx> {
         Some(new_target)
     }
 }
+
+/// Compute the set of loop headers in the given body. A loop header is usually defined as a block
+/// which dominates one of its predecessors. This definition is only correct for reducible CFGs.
+/// However, computing dominators is expensive, so we approximate according to the post-order
+/// traversal order. A loop header for us is a block which is visited after its predecessor in
+/// post-order. This is ok as we mostly need a heuristic.
+fn maybe_loop_headers(body: &Body<'_>) -> DenseBitSet<BasicBlock> {
+    let mut maybe_loop_headers = DenseBitSet::new_empty(body.basic_blocks.len());
+    let mut visited = DenseBitSet::new_empty(body.basic_blocks.len());
+    for (bb, bbdata) in traversal::postorder(body) {
+        // Post-order means we visit successors before the block for acyclic CFGs.
+        // If the successor is not visited yet, consider it a loop header.
+        for succ in bbdata.terminator().successors() {
+            if !visited.contains(succ) {
+                maybe_loop_headers.insert(succ);
+            }
+        }
+
+        // Only mark `bb` as visited after we checked the successors, in case we have a self-loop.
+        //     bb1: goto -> bb1;
+        let _new = visited.insert(bb);
+        debug_assert!(_new);
+    }
+
+    maybe_loop_headers
+}