Auto merge of #155022 - tmandry:remove-dead-drops, r=<try>

Remove redundant drop terminators ahead of mir_coroutine_witnesses

Author: bors

compiler/rustc_middle/src/queries.rs

@@ -672,6 +672,11 @@ rustc_queries! {
         desc { "promoting constants in MIR for `{}`", tcx.def_path_str(key) }
     }
 
+    query mir_post_borrowck_cleanup(key: LocalDefId) -> &'tcx Steal<mir::Body<'tcx>> {
+        no_hash
+        desc { "post borrowck cleanup of MIR for `{}`", tcx.def_path_str(key) }
+    }
+
     query closure_typeinfo(key: LocalDefId) -> ty::ClosureTypeInfo<'tcx> {
         desc {
             "finding symbols for captures of closure `{}`",

compiler/rustc_mir_transform/src/coroutine.rs

@@ -1392,7 +1392,7 @@ pub(crate) fn mir_coroutine_witnesses<'tcx>(
     tcx: TyCtxt<'tcx>,
     def_id: LocalDefId,
 ) -> Option<CoroutineLayout<'tcx>> {
-    let (body, _) = tcx.mir_promoted(def_id);
+    let body = tcx.mir_post_borrowck_cleanup(def_id);
     let body = body.borrow();
     let body = &*body;
 

compiler/rustc_mir_transform/src/lib.rs

@@ -171,6 +171,7 @@ declare_passes! {
     mod promote_consts : PromoteTemps;
     mod ref_prop : ReferencePropagation;
     mod remove_noop_landing_pads : RemoveNoopLandingPads;
+    mod remove_dead_drops : RemoveDeadDrops;
     mod remove_place_mention : RemovePlaceMention;
     mod remove_storage_markers : RemoveStorageMarkers;
     mod remove_uninit_drops : RemoveUninitDrops;
@@ -221,6 +222,7 @@ pub fn provide(providers: &mut Providers) {
         mir_built,
         mir_const_qualif,
         mir_promoted,
+        mir_post_borrowck_cleanup,
         mir_drops_elaborated_and_const_checked,
         mir_for_ctfe,
         mir_coroutine_witnesses: coroutine::mir_coroutine_witnesses,
@@ -485,6 +487,19 @@ fn mir_promoted(
     (tcx.alloc_steal_mir(body), tcx.alloc_steal_promoted(promoted))
 }
 
+fn mir_post_borrowck_cleanup(tcx: TyCtxt<'_>, def: LocalDefId) -> &Steal<Body<'_>> {
+    let (body, _) = tcx.mir_promoted(def);
+    let mut body = body.borrow().clone();
+    pm::run_passes(
+        tcx,
+        &mut body,
+        &[&remove_dead_drops::RemoveDeadDrops],
+        None,
+        pm::Optimizations::Allowed,
+    );
+    tcx.alloc_steal_mir(body)
+}
+
 /// Compute the MIR that is used during CTFE (and thus has no optimizations run on it)
 fn mir_for_ctfe(tcx: TyCtxt<'_>, def_id: LocalDefId) -> &Body<'_> {
     debug_assert!(!tcx.is_trivial_const(def_id), "Tried to get mir_for_ctfe of a trivial const");
@@ -543,7 +558,7 @@ fn mir_drops_elaborated_and_const_checked(tcx: TyCtxt<'_>, def: LocalDefId) -> &
 
     tcx.ensure_done().check_liveness(def);
 
-    let (body, _) = tcx.mir_promoted(def);
+    let body = tcx.mir_post_borrowck_cleanup(def);
     let mut body = body.steal();
 
     if let Some(error_reported) = tainted_by_errors {

compiler/rustc_mir_transform/src/remove_dead_drops.rs

@@ -0,0 +1,58 @@
+use rustc_middle::mir::*;
+use rustc_middle::ty::TyCtxt;
+use rustc_mir_dataflow::impls::MaybeInitializedPlaces;
+use rustc_mir_dataflow::move_paths::{LookupResult, MoveData};
+use rustc_mir_dataflow::{Analysis, MaybeReachable};
+
+use super::simplify::simplify_cfg;
+
+pub(crate) struct RemoveDeadDrops;
+
+impl<'tcx> crate::MirPass<'tcx> for RemoveDeadDrops {
+    fn is_required(&self) -> bool {
+        true
+    }
+
+    fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
+        let move_data = MoveData::gather_moves(body, tcx, |_| true);
+
+        let mut maybe_init_cursor = MaybeInitializedPlaces::new(tcx, body, &move_data)
+            .iterate_to_fixpoint(tcx, body, None)
+            .into_results_cursor(body);
+
+        let mut dead_drops = Vec::new();
+
+        for (block, data) in body.basic_blocks.iter_enumerated() {
+            if let Some(terminator) = &data.terminator
+                && let TerminatorKind::Drop { place, target, .. } = &terminator.kind
+            {
+                let LookupResult::Exact(path) = move_data.rev_lookup.find(place.as_ref()) else {
+                    continue;
+                };
+
+                let term_location = Location { block, statement_index: data.statements.len() };
+                maybe_init_cursor.seek_before_primary_effect(term_location);
+
+                let is_dead = match maybe_init_cursor.get() {
+                    MaybeReachable::Unreachable => true,
+                    MaybeReachable::Reachable(maybe_init) => !maybe_init.contains(path),
+                };
+
+                if is_dead {
+                    dead_drops.push((block, *target));
+                }
+            }
+        }
+
+        if !dead_drops.is_empty() {
+            for (block, target) in dead_drops {
+                if let Some(terminator) = &mut body.basic_blocks.as_mut()[block].terminator {
+                    terminator.kind = TerminatorKind::Goto { target };
+                }
+            }
+
+            // Removing drop terminators may simplify the CFG, so run cleanup.
+            simplify_cfg(tcx, body);
+        }
+    }
+}

tests/mir-opt/basic_assignment.main.ElaborateDrops.diff

@@ -35,53 +35,23 @@
           StorageLive(_5);
           StorageLive(_6);
           _6 = move _4;
--         drop(_5) -> [return: bb1, unwind: bb2];
-+         goto -> bb1;
-      }
-  
-      bb1: {
           _5 = move _6;
--         drop(_6) -> [return: bb3, unwind: bb6];
-+         goto -> bb3;
-      }
-  
-      bb2 (cleanup): {
-          _5 = move _6;
--         drop(_6) -> [return: bb6, unwind terminate(cleanup)];
-+         goto -> bb6;
-      }
-  
-      bb3: {
           StorageDead(_6);
           _0 = const ();
-          drop(_5) -> [return: bb4, unwind: bb7];
+-         drop(_5) -> [return: bb1, unwind continue];
++         drop(_5) -> [return: bb1, unwind: bb2];
       }
 
-      bb4: {
+      bb1: {
           StorageDead(_5);
--         drop(_4) -> [return: bb5, unwind continue];
-+         goto -> bb5;
-      }
-  
-      bb5: {
           StorageDead(_4);
           StorageDead(_2);
           StorageDead(_1);
           return;
-      }
-  
-      bb6 (cleanup): {
--         drop(_5) -> [return: bb7, unwind terminate(cleanup)];
-+         goto -> bb7;
-      }
-  
-      bb7 (cleanup): {
--         drop(_4) -> [return: bb8, unwind terminate(cleanup)];
-+         goto -> bb8;
-      }
-  
-      bb8 (cleanup): {
-          resume;
++     }
++ 
++     bb2 (cleanup): {
++         resume;
       }
   }
 

tests/mir-opt/box_conditional_drop_allocator.main.ElaborateDrops.diff

@@ -31,11 +31,11 @@
           _2 = HasDrop;
           StorageLive(_3);
           _3 = DropAllocator;
-          _1 = Box::<HasDrop, DropAllocator>::new_in(move _2, move _3) -> [return: bb1, unwind: bb11];
++         _9 = const true;
+          _1 = Box::<HasDrop, DropAllocator>::new_in(move _2, move _3) -> [return: bb1, unwind continue];
       }
 
       bb1: {
-+         _9 = const true;
           StorageDead(_3);
           StorageDead(_2);
           StorageLive(_4);
@@ -47,7 +47,7 @@
           StorageLive(_5);
           StorageLive(_6);
           _6 = move (*_1);
-          _5 = std::mem::drop::<HasDrop>(move _6) -> [return: bb3, unwind: bb9];
+          _5 = std::mem::drop::<HasDrop>(move _6) -> [return: bb3, unwind: bb8];
       }
 
       bb3: {
@@ -75,7 +75,7 @@
       bb6: {
           StorageDead(_4);
 -         drop(_1) -> [return: bb7, unwind continue];
-+         goto -> bb23;
++         goto -> bb19;
       }
 
       bb7: {
@@ -85,102 +85,82 @@
       }
 
       bb8 (cleanup): {
--         drop(_8) -> [return: bb10, unwind terminate(cleanup)];
-+         goto -> bb10;
+-         drop(_1) -> [return: bb9, unwind terminate(cleanup)];
++         goto -> bb25;
       }
 
       bb9 (cleanup): {
--         drop(_6) -> [return: bb10, unwind terminate(cleanup)];
-+         goto -> bb10;
-      }
-  
-      bb10 (cleanup): {
--         drop(_1) -> [return: bb13, unwind terminate(cleanup)];
-+         goto -> bb29;
-      }
-  
-      bb11 (cleanup): {
--         drop(_3) -> [return: bb12, unwind terminate(cleanup)];
-+         goto -> bb12;
-      }
-  
-      bb12 (cleanup): {
--         drop(_2) -> [return: bb13, unwind terminate(cleanup)];
-+         goto -> bb13;
-      }
-  
-      bb13 (cleanup): {
           resume;
 +     }
 + 
-+     bb14: {
++     bb10: {
 +         _9 = const false;
 +         goto -> bb7;
 +     }
 + 
-+     bb15 (cleanup): {
-+         drop((_1.1: DropAllocator)) -> [return: bb13, unwind terminate(cleanup)];
++     bb11 (cleanup): {
++         drop((_1.1: DropAllocator)) -> [return: bb9, unwind terminate(cleanup)];
 +     }
 + 
-+     bb16 (cleanup): {
-+         switchInt(copy _9) -> [0: bb13, otherwise: bb15];
++     bb12 (cleanup): {
++         switchInt(copy _9) -> [0: bb9, otherwise: bb11];
 +     }
 + 
-+     bb17: {
-+         drop((_1.1: DropAllocator)) -> [return: bb14, unwind: bb13];
++     bb13: {
++         drop((_1.1: DropAllocator)) -> [return: bb10, unwind: bb9];
 +     }
 + 
-+     bb18: {
-+         switchInt(copy _9) -> [0: bb14, otherwise: bb17];
++     bb14: {
++         switchInt(copy _9) -> [0: bb10, otherwise: bb13];
 +     }
 + 
-+     bb19: {
++     bb15: {
 +         _10 = &mut _1;
-+         _11 = <Box<HasDrop, DropAllocator> as Drop>::drop(move _10) -> [return: bb18, unwind: bb16];
++         _11 = <Box<HasDrop, DropAllocator> as Drop>::drop(move _10) -> [return: bb14, unwind: bb12];
 +     }
 + 
-+     bb20 (cleanup): {
++     bb16 (cleanup): {
 +         _12 = &mut _1;
-+         _13 = <Box<HasDrop, DropAllocator> as Drop>::drop(move _12) -> [return: bb16, unwind terminate(cleanup)];
++         _13 = <Box<HasDrop, DropAllocator> as Drop>::drop(move _12) -> [return: bb12, unwind terminate(cleanup)];
 +     }
 + 
-+     bb21: {
-+         goto -> bb19;
++     bb17: {
++         goto -> bb15;
 +     }
 + 
-+     bb22: {
++     bb18: {
 +         _14 = copy ((_1.0: std::ptr::Unique<HasDrop>).0: std::ptr::NonNull<HasDrop>) as *const HasDrop (Transmute);
-+         goto -> bb21;
++         goto -> bb17;
 +     }
 + 
-+     bb23: {
-+         switchInt(copy _9) -> [0: bb18, otherwise: bb22];
++     bb19: {
++         switchInt(copy _9) -> [0: bb14, otherwise: bb18];
 +     }
 + 
-+     bb24 (cleanup): {
-+         drop((_1.1: DropAllocator)) -> [return: bb13, unwind terminate(cleanup)];
++     bb20 (cleanup): {
++         drop((_1.1: DropAllocator)) -> [return: bb9, unwind terminate(cleanup)];
 +     }
 + 
-+     bb25 (cleanup): {
-+         switchInt(copy _9) -> [0: bb13, otherwise: bb24];
++     bb21 (cleanup): {
++         switchInt(copy _9) -> [0: bb9, otherwise: bb20];
 +     }
 + 
-+     bb26 (cleanup): {
++     bb22 (cleanup): {
 +         _15 = &mut _1;
-+         _16 = <Box<HasDrop, DropAllocator> as Drop>::drop(move _15) -> [return: bb25, unwind terminate(cleanup)];
++         _16 = <Box<HasDrop, DropAllocator> as Drop>::drop(move _15) -> [return: bb21, unwind terminate(cleanup)];
 +     }
 + 
-+     bb27 (cleanup): {
-+         goto -> bb26;
++     bb23 (cleanup): {
++         goto -> bb22;
 +     }
 + 
-+     bb28 (cleanup): {
++     bb24 (cleanup): {
 +         _17 = copy ((_1.0: std::ptr::Unique<HasDrop>).0: std::ptr::NonNull<HasDrop>) as *const HasDrop (Transmute);
-+         goto -> bb27;
++         goto -> bb23;
 +     }
 + 
-+     bb29 (cleanup): {
-+         switchInt(copy _9) -> [0: bb25, otherwise: bb28];
++     bb25 (cleanup): {
++         switchInt(copy _9) -> [0: bb21, otherwise: bb24];
       }
   }