Auto merge of #120689 - clubby789:copy-prop-consts, r=<try>

CopyProp: Propagate moves of constants

Yet another try of #120650 - this time, keep track of SSA locals with a constant value and propagate it. Then, re-run `SimplifyConstCondition` to take advantage of it (simply reordering the pass regressed some tests).

r? `@ghost`

Author: bors

compiler/rustc_mir_transform/src/copy_prop.rs

@@ -1,3 +1,4 @@
+use rustc_data_structures::fx::FxIndexMap;
 use rustc_index::bit_set::BitSet;
 use rustc_index::IndexSlice;
 use rustc_middle::mir::visit::*;
@@ -37,6 +38,8 @@ fn propagate_ssa<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
 
     let fully_moved = fully_moved_locals(&ssa, body);
     debug!(?fully_moved);
+    let const_locals = const_locals(&ssa, body);
+    debug!(?const_locals);
 
     let mut storage_to_remove = BitSet::new_empty(fully_moved.domain_size());
     for (local, &head) in ssa.copy_classes().iter_enumerated() {
@@ -51,6 +54,7 @@ fn propagate_ssa<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
         tcx,
         copy_classes: ssa.copy_classes(),
         fully_moved,
+        const_locals,
         borrowed_locals,
         storage_to_remove,
     }
@@ -96,10 +100,28 @@ fn fully_moved_locals(ssa: &SsaLocals, body: &Body<'_>) -> BitSet<Local> {
     fully_moved
 }
 
+/// Finds all locals that are only assigned to once with a deterministic constant
+#[instrument(level = "trace", skip(ssa, body))]
+fn const_locals<'body, 'tcx>(
+    ssa: &'body SsaLocals,
+    body: &'body Body<'tcx>,
+) -> FxIndexMap<Local, ConstOperand<'tcx>> {
+    let mut const_locals = FxIndexMap::default();
+    for (local, rvalue, _) in ssa.assignments(body) {
+        let Rvalue::Use(Operand::Constant(val)) = rvalue else { continue };
+        if !val.const_.is_deterministic() {
+            continue;
+        }
+        const_locals.insert(local, **val);
+    }
+    const_locals
+}
+
 /// Utility to help performing substitution of `*pattern` by `target`.
 struct Replacer<'a, 'tcx> {
     tcx: TyCtxt<'tcx>,
     fully_moved: BitSet<Local>,
+    const_locals: FxIndexMap<Local, ConstOperand<'tcx>>,
     storage_to_remove: BitSet<Local>,
     borrowed_locals: BitSet<Local>,
     copy_classes: &'a IndexSlice<Local, Local>,
@@ -154,9 +176,14 @@ impl<'tcx> MutVisitor<'tcx> for Replacer<'_, 'tcx> {
         if let Operand::Move(place) = *operand
             // A move out of a projection of a copy is equivalent to a copy of the original projection.
             && !place.is_indirect_first_projection()
-            && !self.fully_moved.contains(place.local)
         {
-            *operand = Operand::Copy(place);
+            if !self.fully_moved.contains(place.local) {
+                *operand = Operand::Copy(place);
+            } else if let Some(local) = place.as_local()
+                && let Some(val) = self.const_locals.get(&local)
+            {
+                *operand = Operand::Constant(Box::new(*val))
+            }
         }
         self.super_operand(operand, loc);
     }

tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.PreCodegen.after.panic-abort.mir

@@ -4,59 +4,58 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
     debug slice => _1;
     debug f => _2;
     let mut _0: ();
-    let mut _13: std::slice::Iter<'_, T>;
+    let mut _12: std::slice::Iter<'_, T>;
+    let mut _13: std::iter::Enumerate<std::slice::Iter<'_, T>>;
     let mut _14: std::iter::Enumerate<std::slice::Iter<'_, T>>;
-    let mut _15: std::iter::Enumerate<std::slice::Iter<'_, T>>;
-    let mut _16: &mut std::iter::Enumerate<std::slice::Iter<'_, T>>;
-    let mut _17: std::option::Option<(usize, &T)>;
-    let mut _18: isize;
-    let mut _21: &impl Fn(usize, &T);
-    let mut _22: (usize, &T);
-    let _23: ();
+    let mut _15: &mut std::iter::Enumerate<std::slice::Iter<'_, T>>;
+    let mut _16: std::option::Option<(usize, &T)>;
+    let mut _17: isize;
+    let mut _20: &impl Fn(usize, &T);
+    let mut _21: (usize, &T);
+    let _22: ();
     scope 1 {
-        debug iter => _15;
-        let _19: usize;
-        let _20: &T;
+        debug iter => _14;
+        let _18: usize;
+        let _19: &T;
         scope 2 {
-            debug i => _19;
-            debug x => _20;
+            debug i => _18;
+            debug x => _19;
         }
     }
     scope 3 (inlined core::slice::<impl [T]>::iter) {
         debug self => _1;
         scope 4 (inlined std::slice::Iter::<'_, T>::new) {
             debug slice => _1;
             let _4: *const T;
-            let mut _5: bool;
-            let mut _6: usize;
-            let mut _8: usize;
-            let mut _9: *mut T;
-            let mut _11: std::ptr::NonNull<T>;
-            let mut _12: *const T;
+            let mut _5: usize;
+            let mut _7: usize;
+            let mut _8: *mut T;
+            let mut _10: std::ptr::NonNull<T>;
+            let mut _11: *const T;
             scope 5 {
                 debug ptr => _4;
                 scope 6 {
-                    let _7: *const T;
+                    let _6: *const T;
                     scope 7 {
-                        debug end_or_len => _7;
+                        debug end_or_len => _6;
                         scope 13 (inlined NonNull::<T>::new_unchecked) {
-                            debug ptr => _9;
-                            let mut _10: *const T;
-                            let mut _24: *mut T;
+                            debug ptr => _8;
+                            let mut _9: *const T;
+                            let mut _23: *mut T;
                             scope 14 {
                                 scope 15 (inlined NonNull::<T>::new_unchecked::runtime::<T>) {
-                                    debug ptr => _24;
+                                    debug ptr => _23;
                                     scope 16 (inlined std::ptr::mut_ptr::<impl *mut T>::is_null) {
-                                        debug self => _24;
-                                        let mut _25: *mut u8;
+                                        debug self => _23;
+                                        let mut _24: *mut u8;
                                         scope 17 {
                                             scope 18 (inlined std::ptr::mut_ptr::<impl *mut T>::is_null::runtime_impl) {
-                                                debug ptr => _25;
+                                                debug ptr => _24;
                                                 scope 19 (inlined std::ptr::mut_ptr::<impl *mut u8>::addr) {
-                                                    debug self => _25;
+                                                    debug self => _24;
                                                     scope 20 {
                                                         scope 21 (inlined std::ptr::mut_ptr::<impl *mut u8>::cast::<()>) {
-                                                            debug self => _25;
+                                                            debug self => _24;
                                                         }
                                                     }
                                                 }
@@ -68,13 +67,13 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
                         }
                     }
                     scope 9 (inlined invalid::<T>) {
-                        debug addr => _8;
+                        debug addr => _7;
                         scope 10 {
                         }
                     }
                     scope 11 (inlined std::ptr::const_ptr::<impl *const T>::add) {
                         debug self => _4;
-                        debug count => _6;
+                        debug count => _5;
                         scope 12 {
                         }
                     }
@@ -87,88 +86,85 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
         }
     }
     scope 22 (inlined <std::slice::Iter<'_, T> as Iterator>::enumerate) {
-        debug self => _13;
+        debug self => _12;
         scope 23 (inlined Enumerate::<std::slice::Iter<'_, T>>::new) {
-            debug iter => _13;
+            debug iter => _12;
         }
     }
     scope 24 (inlined <Enumerate<std::slice::Iter<'_, T>> as IntoIterator>::into_iter) {
-        debug self => _14;
+        debug self => _13;
     }
 
     bb0: {
-        StorageLive(_13);
+        StorageLive(_12);
         StorageLive(_4);
         StorageLive(_3);
         _3 = &raw const (*_1);
         _4 = move _3 as *const T (PtrToPtr);
         StorageDead(_3);
-        StorageLive(_7);
-        StorageLive(_5);
-        _5 = const _;
-        switchInt(move _5) -> [0: bb1, otherwise: bb2];
+        StorageLive(_6);
+        switchInt(const _) -> [0: bb1, otherwise: bb2];
     }
 
     bb1: {
-        StorageLive(_6);
-        _6 = Len((*_1));
-        _7 = Offset(_4, _6);
-        StorageDead(_6);
+        StorageLive(_5);
+        _5 = Len((*_1));
+        _6 = Offset(_4, _5);
+        StorageDead(_5);
         goto -> bb3;
     }
 
     bb2: {
-        StorageLive(_8);
-        _8 = Len((*_1));
-        _7 = _8 as *const T (Transmute);
-        StorageDead(_8);
+        StorageLive(_7);
+        _7 = Len((*_1));
+        _6 = _7 as *const T (Transmute);
+        StorageDead(_7);
         goto -> bb3;
     }
 
     bb3: {
-        StorageDead(_5);
-        StorageLive(_11);
-        StorageLive(_9);
-        _9 = _4 as *mut T (PtrToPtr);
         StorageLive(_10);
+        StorageLive(_8);
+        _8 = _4 as *mut T (PtrToPtr);
+        StorageLive(_9);
+        StorageLive(_23);
         StorageLive(_24);
-        StorageLive(_25);
-        _10 = _9 as *const T (PointerCoercion(MutToConstPointer));
-        _11 = NonNull::<T> { pointer: _10 };
-        StorageDead(_25);
+        _9 = _8 as *const T (PointerCoercion(MutToConstPointer));
+        _10 = NonNull::<T> { pointer: _9 };
         StorageDead(_24);
-        StorageDead(_10);
+        StorageDead(_23);
         StorageDead(_9);
-        StorageLive(_12);
-        _12 = _7;
-        _13 = std::slice::Iter::<'_, T> { ptr: move _11, end_or_len: move _12, _marker: const ZeroSized: PhantomData<&T> };
-        StorageDead(_12);
+        StorageDead(_8);
+        StorageLive(_11);
+        _11 = _6;
+        _12 = std::slice::Iter::<'_, T> { ptr: move _10, end_or_len: move _11, _marker: const ZeroSized: PhantomData<&T> };
         StorageDead(_11);
-        StorageDead(_7);
+        StorageDead(_10);
+        StorageDead(_6);
         StorageDead(_4);
-        _14 = Enumerate::<std::slice::Iter<'_, T>> { iter: _13, count: const 0_usize };
-        StorageDead(_13);
-        StorageLive(_15);
-        _15 = _14;
+        _13 = Enumerate::<std::slice::Iter<'_, T>> { iter: _12, count: const 0_usize };
+        StorageDead(_12);
+        StorageLive(_14);
+        _14 = _13;
         goto -> bb4;
     }
 
     bb4: {
-        StorageLive(_17);
         StorageLive(_16);
-        _16 = &mut _15;
-        _17 = <Enumerate<std::slice::Iter<'_, T>> as Iterator>::next(move _16) -> [return: bb5, unwind unreachable];
+        StorageLive(_15);
+        _15 = &mut _14;
+        _16 = <Enumerate<std::slice::Iter<'_, T>> as Iterator>::next(move _15) -> [return: bb5, unwind unreachable];
     }
 
     bb5: {
-        StorageDead(_16);
-        _18 = discriminant(_17);
-        switchInt(move _18) -> [0: bb6, 1: bb8, otherwise: bb10];
+        StorageDead(_15);
+        _17 = discriminant(_16);
+        switchInt(move _17) -> [0: bb6, 1: bb8, otherwise: bb10];
     }
 
     bb6: {
-        StorageDead(_17);
-        StorageDead(_15);
+        StorageDead(_16);
+        StorageDead(_14);
         drop(_2) -> [return: bb7, unwind unreachable];
     }
 
@@ -177,19 +173,19 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
     }
 
     bb8: {
-        _19 = (((_17 as Some).0: (usize, &T)).0: usize);
-        _20 = (((_17 as Some).0: (usize, &T)).1: &T);
+        _18 = (((_16 as Some).0: (usize, &T)).0: usize);
+        _19 = (((_16 as Some).0: (usize, &T)).1: &T);
+        StorageLive(_20);
+        _20 = &_2;
         StorageLive(_21);
-        _21 = &_2;
-        StorageLive(_22);
-        _22 = (_19, _20);
-        _23 = <impl Fn(usize, &T) as Fn<(usize, &T)>>::call(move _21, move _22) -> [return: bb9, unwind unreachable];
+        _21 = (_18, _19);
+        _22 = <impl Fn(usize, &T) as Fn<(usize, &T)>>::call(move _20, move _21) -> [return: bb9, unwind unreachable];
     }
 
     bb9: {
-        StorageDead(_22);
         StorageDead(_21);
-        StorageDead(_17);
+        StorageDead(_20);
+        StorageDead(_16);
         goto -> bb4;
     }