Use builder method to set dead_unwinds

`dead_unwinds` is an empty bitset in most places. This saves us from
having to construct that empty bitset for every dataflow analysis.

Author: ecstatic-morse

src/librustc_mir/borrow_check/mod.rs

@@ -167,12 +167,10 @@ fn do_mir_borrowck<'a, 'tcx>(
         param_env,
     };
 
-    let dead_unwinds = BitSet::new_empty(body.basic_blocks().len());
     let flow_inits = MaybeInitializedPlaces::new(tcx, body, &mdpe);
-    let mut flow_inits =
-        dataflow::generic::Engine::new_gen_kill(tcx, body, def_id, &dead_unwinds, flow_inits)
-            .iterate_to_fixpoint()
-            .into_cursor(body);
+    let mut flow_inits = dataflow::generic::Engine::new_gen_kill(tcx, body, def_id, flow_inits)
+        .iterate_to_fixpoint()
+        .into_cursor(body);
 
     let locals_are_invalidated_at_exit = tcx.hir().body_owner_kind(id).is_fn_or_closure();
     let borrow_set = Rc::new(BorrowSet::build(
@@ -201,6 +199,7 @@ fn do_mir_borrowck<'a, 'tcx>(
 
     let regioncx = Rc::new(regioncx);
 
+    let dead_unwinds = BitSet::new_empty(body.basic_blocks().len());
     let flow_borrows = FlowAtLocation::new(do_dataflow(
         tcx,
         body,

src/librustc_mir/dataflow/generic/engine.rs

@@ -25,7 +25,7 @@ where
     tcx: TyCtxt<'tcx>,
     body: &'a mir::Body<'tcx>,
     def_id: DefId,
-    dead_unwinds: &'a BitSet<BasicBlock>,
+    dead_unwinds: Option<&'a BitSet<BasicBlock>>,
     entry_sets: IndexVec<BasicBlock, BitSet<A::Idx>>,
     analysis: A,
 
@@ -42,7 +42,6 @@ where
         tcx: TyCtxt<'tcx>,
         body: &'a mir::Body<'tcx>,
         def_id: DefId,
-        dead_unwinds: &'a BitSet<BasicBlock>,
         analysis: A,
     ) -> Self {
         let bits_per_block = analysis.bits_per_block(body);
@@ -70,7 +69,7 @@ where
             }
         }
 
-        Self::new(tcx, body, def_id, dead_unwinds, analysis, Some(trans_for_block))
+        Self::new(tcx, body, def_id, analysis, Some(trans_for_block))
     }
 }
 
@@ -87,17 +86,15 @@ where
         tcx: TyCtxt<'tcx>,
         body: &'a mir::Body<'tcx>,
         def_id: DefId,
-        dead_unwinds: &'a BitSet<BasicBlock>,
         analysis: A,
     ) -> Self {
-        Self::new(tcx, body, def_id, dead_unwinds, analysis, None)
+        Self::new(tcx, body, def_id, analysis, None)
     }
 
     fn new(
         tcx: TyCtxt<'tcx>,
         body: &'a mir::Body<'tcx>,
         def_id: DefId,
-        dead_unwinds: &'a BitSet<BasicBlock>,
         analysis: A,
         trans_for_block: Option<IndexVec<BasicBlock, GenKillSet<A::Idx>>>,
     ) -> Self {
@@ -118,12 +115,17 @@ where
             tcx,
             body,
             def_id,
-            dead_unwinds,
+            dead_unwinds: None,
             entry_sets,
             trans_for_block,
         }
     }
 
+    pub fn dead_unwinds(mut self, dead_unwinds: &'a BitSet<BasicBlock>) -> Self {
+        self.dead_unwinds = Some(dead_unwinds);
+        self
+    }
+
     pub fn iterate_to_fixpoint(mut self) -> Results<'tcx, A> {
         let mut temp_state = BitSet::new_empty(self.bits_per_block);
 
@@ -229,7 +231,7 @@ where
             | DropAndReplace { target, value: _, location: _, unwind: Some(unwind) }
             => {
                 self.propagate_bits_into_entry_set_for(in_out, target, dirty_list);
-                if !self.dead_unwinds.contains(bb) {
+                if self.dead_unwinds.map_or(true, |bbs| !bbs.contains(bb)) {
                     self.propagate_bits_into_entry_set_for(in_out, unwind, dirty_list);
                 }
             }
@@ -242,7 +244,7 @@ where
 
             Call { cleanup, ref destination, ref func, ref args, .. } => {
                 if let Some(unwind) = cleanup {
-                    if !self.dead_unwinds.contains(bb) {
+                    if self.dead_unwinds.map_or(true, |bbs| !bbs.contains(bb)) {
                         self.propagate_bits_into_entry_set_for(in_out, unwind, dirty_list);
                     }
                 }
@@ -263,7 +265,7 @@ where
             FalseUnwind { real_target, unwind } => {
                 self.propagate_bits_into_entry_set_for(in_out, real_target, dirty_list);
                 if let Some(unwind) = unwind {
-                    if !self.dead_unwinds.contains(bb) {
+                    if self.dead_unwinds.map_or(true, |bbs| !bbs.contains(bb)) {
                         self.propagate_bits_into_entry_set_for(in_out, unwind, dirty_list);
                     }
                 }

src/librustc_mir/transform/check_consts/validation.rs

@@ -38,11 +38,10 @@ impl<Q: Qualif> QualifCursor<'a, 'mir, 'tcx, Q> {
     pub fn new(
         q: Q,
         item: &'a Item<'mir, 'tcx>,
-        dead_unwinds: &BitSet<BasicBlock>,
     ) -> Self {
         let analysis = FlowSensitiveAnalysis::new(q, item);
         let results =
-            dataflow::Engine::new_generic(item.tcx, item.body, item.def_id, dead_unwinds, analysis)
+            dataflow::Engine::new_generic(item.tcx, item.body, item.def_id, analysis)
                 .iterate_to_fixpoint();
         let cursor = dataflow::ResultsCursor::new(item.body, results);
 
@@ -133,20 +132,17 @@ impl Validator<'a, 'mir, 'tcx> {
     pub fn new(
         item: &'a Item<'mir, 'tcx>,
     ) -> Self {
-        let dead_unwinds = BitSet::new_empty(item.body.basic_blocks().len());
-
         let needs_drop = QualifCursor::new(
             NeedsDrop,
             item,
-            &dead_unwinds,
         );
 
         let has_mut_interior = QualifCursor::new(
             HasMutInterior,
             item,
-            &dead_unwinds,
         );
 
+        let dead_unwinds = BitSet::new_empty(item.body.basic_blocks().len());
         let indirectly_mutable = old_dataflow::do_dataflow(
             item.tcx,
             item.body,

src/librustc_mir/transform/elaborate_drops.rs

@@ -38,10 +38,10 @@ impl<'tcx> MirPass<'tcx> for ElaborateDrops {
                 param_env,
             };
             let dead_unwinds = find_dead_unwinds(tcx, body, def_id, &env);
-            let flow_inits = dataflow::generic::Engine::new_gen_kill(
-                tcx, body, def_id, &dead_unwinds,
-                MaybeInitializedPlaces::new(tcx, body, &env),
-            ).iterate_to_fixpoint();
+            let flow_inits = MaybeInitializedPlaces::new(tcx, body, &env);
+            let flow_inits = dataflow::generic::Engine::new_gen_kill(tcx, body, def_id, flow_inits)
+                .dead_unwinds(&dead_unwinds)
+                .iterate_to_fixpoint();
             let flow_uninits =
                 do_dataflow(tcx, body, def_id, &[], &dead_unwinds,
                             MaybeUninitializedPlaces::new(tcx, body, &env),
@@ -74,10 +74,11 @@ fn find_dead_unwinds<'tcx>(
     // We only need to do this pass once, because unwind edges can only
     // reach cleanup blocks, which can't have unwind edges themselves.
     let mut dead_unwinds = BitSet::new_empty(body.basic_blocks().len());
+
     let flow_inits = MaybeInitializedPlaces::new(tcx, body, &env);
-    let flow_inits =
-        dataflow::generic::Engine::new_gen_kill(tcx, body, def_id, &dead_unwinds, flow_inits)
-            .iterate_to_fixpoint();
+    let flow_inits = dataflow::generic::Engine::new_gen_kill(tcx, body, def_id, flow_inits)
+        .iterate_to_fixpoint();
+
     for (bb, bb_data) in body.basic_blocks().iter_enumerated() {
         let location = match bb_data.terminator().kind {
             TerminatorKind::Drop { ref location, unwind: Some(_), .. } |

src/librustc_mir/transform/rustc_peek.rs

@@ -42,7 +42,7 @@ impl<'tcx> MirPass<'tcx> for SanityCheck {
         let dead_unwinds = BitSet::new_empty(body.basic_blocks().len());
 
         let flow_inits = Engine::new_gen_kill(
-            tcx, body, def_id, &dead_unwinds,
+            tcx, body, def_id,
             MaybeInitializedPlaces::new(tcx, body, &mdpe),
         ).iterate_to_fixpoint();
         let flow_uninits =