Auto merge of rust-lang#136788 - FractalFir:prop_trivial_locals, r=<try>

[perf experiment]  A MIR pass removing unneded temporary locals

Experiment with early MIR optimization removing temporary locals

# Motivation

Currently, a lot of MIR contains unneded assigements to temporaries:
### Rust
```rust
fn add_points(lhs:(f32,f32,f32),rhs:(f32,f32,f32))->(f32,f32,f32){
    (lhs.0 + rhs.0, lhs.1 + rhs.1, lhs.2 + rhs.2)
}
```
### Orignal MIR
```mir
bb0: {
        StorageLive(_3);
        StorageLive(_4);
        // _4 and _5 are not needed!
        _4 = copy (_1.0: f32);
        StorageLive(_5);
        _5 = copy (_2.0: f32);
        _3 = Add(move _4, move _5);
        StorageDead(_5);
        StorageDead(_4);
        StorageLive(_6);
        StorageLive(_7);
        // _7 and _8 are not needed!
        _7 = copy (_1.1: f32);
        StorageLive(_8);
        _8 = copy (_2.1: f32);
        _6 = Add(move _7, move _8);
        StorageDead(_8);
        StorageDead(_7);
        StorageLive(_9);
        StorageLive(_10);
        // _10 and _9 are not needed!
        _10 = copy (_1.2: f32);
        StorageLive(_11);
        _11 = copy (_2.2: f32);
        _9 = Add(move _10, move _11);
        StorageDead(_11);
        StorageDead(_10);
        _0 = (move _3, move _6, move _9);
        StorageDead(_9);
        StorageDead(_6);
        StorageDead(_3);
        return;
    }
```
This pass tries to remove as such many temporaries as possible. This leads to reduced MIR sizes, which should hopefully speed the next passes up.
```mir
fn add_points(_1: (f32, f32, f32), _2: (f32, f32, f32)) -> (f32, f32, f32) {
    debug lhs => _1;
    debug rhs => _2;
    let mut _0: (f32, f32, f32);
    let mut _3: f32;
    let mut _4: f32;
    let mut _5: f32;

    bb0: {
        StorageLive(_3);
        _3 = Add(copy (_1.0: f32), copy (_2.0: f32));
        StorageLive(_4);
        _4 = Add(copy (_1.1: f32), copy (_2.1: f32));
        StorageLive(_5);
        _5 = Add(copy (_1.2: f32), copy (_2.2: f32));
        _0 = (move _3, move _4, move _5);
        StorageDead(_5);
        StorageDead(_4);
        StorageDead(_3);
        return;
    }
}
```
**This PR is not yet meant for merging!**
The current version is still a bit from being done: it does not optimize locals used in calls, and some parts may need tweaking.

Still, I belive it is at least worth timing at this point, which is why I am requesting a perf run.

Author: bors

compiler/rustc_mir_transform/src/lib.rs

@@ -125,7 +125,7 @@ declare_passes! {
     mod check_undefined_transmutes : CheckUndefinedTransmutes;
     // This pass is public to allow external drivers to perform MIR cleanup
     pub mod cleanup_post_borrowck : CleanupPostBorrowck;
-
+    mod prop_trivial_locals : PropTrivialLocals;
     mod copy_prop : CopyProp;
     mod coroutine : StateTransform;
     mod coverage : InstrumentCoverage;
@@ -654,6 +654,7 @@ fn run_optimization_passes<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
             // Perform instsimplify before inline to eliminate some trivial calls (like clone
             // shims).
             &instsimplify::InstSimplify::BeforeInline,
+            &prop_trivial_locals::PropTrivialLocals,
             // Perform inlining of `#[rustc_force_inline]`-annotated callees.
             &inline::ForceInline,
             // Perform inlining, which may add a lot of code.

compiler/rustc_mir_transform/src/prop_trivial_locals.rs

@@ -0,0 +1,168 @@
+#![allow(unused_imports, unused_variables, dead_code)]
+//! This pass removes unneded temporary locals.
+//! Eg. This:
+//! ```
+//! _3 = copy _1;
+//! _4 = Add(_3, _2);
+//! ```
+//! Will get turned into this:
+//! ```
+//! _4 = Add(_1,_2)
+//! ```
+use rustc_index::IndexVec;
+use rustc_middle::mir::*;
+use rustc_middle::ty::TyCtxt;
+use tracing::{debug, trace};
+
+pub(super) struct PropTrivialLocals;
+struct StatmentPos(BasicBlock, usize);
+impl StatmentPos {
+    fn nop_out(self, blocks: &mut IndexVec<BasicBlock, BasicBlockData<'_>>) {
+        blocks[self.0].statements[self.1].make_nop();
+    }
+}
+fn propagate_operand<'tcx>(
+    operand: &mut Operand<'tcx>,
+    local: Local,
+    local_replacement: &Operand<'tcx>,
+) -> bool {
+    let place = match operand {
+        Operand::Copy(place) | Operand::Move(place) => place,
+        _ => return false,
+    };
+    if place.local != local {
+        return false;
+    }
+    if place.projection.is_empty() {
+        *operand = local_replacement.clone();
+        return true;
+    }
+    return false;
+}
+impl<'tcx> crate::MirPass<'tcx> for PropTrivialLocals {
+    fn is_enabled(&self, sess: &rustc_session::Session) -> bool {
+        sess.mir_opt_level() > 1
+    }
+    fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
+        trace!("Running PropTrivialLocals on {:?}", body.source);
+        loop {
+            let mut dead_candidates = false;
+            for (bid, block) in body.basic_blocks.as_mut().iter_enumerated_mut() {
+                let mut iter = StatementPairIterator::new(bid, &mut block.statements);
+                while let Some(StatementPair((a_idx, a), (b_idx, b))) = iter.next() {
+                    let (StatementKind::Assign(tmp_a), StatementKind::Assign(tmp_b)) =
+                        (&a.kind, &mut b.kind)
+                    else {
+                        continue;
+                    };
+                    let Some(loc_a) = tmp_a.0.as_local() else {
+                        continue;
+                    };
+                    let Rvalue::Use(ref src_a) = tmp_a.1 else {
+                        continue;
+                    };
+                    match &mut tmp_b.1 {
+                        Rvalue::BinaryOp(_, args) => {
+                            dead_candidates |= propagate_operand(&mut args.0, loc_a, src_a)
+                                || propagate_operand(&mut args.1, loc_a, src_a);
+                        }
+                        // I could add a `| Rvalue::Use(arg)` here, but I have not encountered this pattern in compiler-generated MIR *ever*,
+                        // so it is likely not worth even checking for. Likevise, `Rvalue::Ref | Rvalue::RawPtr` also seems to never benfit from this opt.
+                        Rvalue::UnaryOp(_, arg)
+                        | Rvalue::Cast(_, arg, _)
+                        | Rvalue::Repeat(arg, _) => {
+                            dead_candidates |= propagate_operand(arg, loc_a, src_a);
+                        }
+                        Rvalue::Aggregate(_, args) => {
+                            dead_candidates |=
+                                args.iter_mut().any(|arg| propagate_operand(arg, loc_a, src_a))
+                        }
+                        _ => continue,
+                    }
+                }
+            }
+            if dead_candidates {
+                crate::simplify::remove_unused_definitions(body);
+            } else {
+                break;
+            }
+        }
+    }
+
+    fn is_required(&self) -> bool {
+        false
+    }
+}
+struct DeadLocalCandidates {
+    dead: Local,
+}
+struct StatementPair<'a, 'tcx>(
+    (StatmentPos, &'a mut Statement<'tcx>),
+    (StatmentPos, &'a mut Statement<'tcx>),
+);
+struct StatementPairIterator<'a, 'tcx> {
+    curr_block: BasicBlock,
+    curr_idx: usize,
+    statements: &'a mut [Statement<'tcx>],
+}
+impl<'a, 'tcx> StatementPairIterator<'a, 'tcx> {
+    fn new(curr_block: BasicBlock, statements: &'a mut [Statement<'tcx>]) -> Self {
+        Self { curr_block, statements, curr_idx: 0 }
+    }
+    fn get_at<'s>(&'s mut self, idx_a: usize, idx_b: usize) -> StatementPair<'s, 'tcx> {
+        // Some bounds checks
+        assert!(idx_a < idx_b);
+        assert!(idx_b < self.statements.len());
+        let (part_a, reminder) = self.statements.split_at_mut(idx_a + 1);
+        let (part_b, reminder) = reminder.split_at_mut((idx_b - part_a.len()) + 1);
+        let a = &mut part_a[part_a.len() - 1];
+        let b = &mut part_b[part_b.len() - 1];
+        StatementPair(
+            (StatmentPos(self.curr_block, idx_a), a),
+            (StatmentPos(self.curr_block, idx_b), b),
+        )
+    }
+    fn is_statement_irrelevant(statement: &Statement<'_>) -> bool {
+        match statement.kind {
+            StatementKind::Nop
+            | StatementKind::StorageLive(..)
+            | StatementKind::PlaceMention(..)
+            | StatementKind::Coverage(..)
+            | StatementKind::ConstEvalCounter => true,
+            StatementKind::Assign(..)
+            | StatementKind::FakeRead(..)
+            | StatementKind::SetDiscriminant { .. }
+            | StatementKind::Deinit(..)
+            | StatementKind::StorageDead(..)
+            | StatementKind::Retag(..)
+            | StatementKind::AscribeUserType(..)
+            | StatementKind::Intrinsic(..)
+            | StatementKind::BackwardIncompatibleDropHint { .. } => false,
+        }
+    }
+    fn next<'s>(&'s mut self) -> Option<StatementPair<'s, 'tcx>> {
+        // Skip irrelevant statements
+        if self.curr_idx >= self.statements.len() {
+            return None;
+        }
+        while Self::is_statement_irrelevant(&self.statements[self.curr_idx]) {
+            self.curr_idx += 1;
+            if self.curr_idx >= self.statements.len() {
+                return None;
+            }
+        }
+        let curr = self.curr_idx;
+        self.curr_idx += 1;
+        let mut next_idx = self.curr_idx;
+        if next_idx >= self.statements.len() {
+            return None;
+        }
+        while Self::is_statement_irrelevant(&self.statements[next_idx]) {
+            next_idx += 1;
+            if next_idx >= self.statements.len() {
+                return None;
+            }
+        }
+        Some(self.get_at(curr, next_idx))
+    }
+}

compiler/rustc_mir_transform/src/validate.rs

@@ -956,7 +956,7 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                             .tcx
                             .normalize_erasing_regions(self.typing_env, dest.ty(self.tcx, args));
                         if !self.mir_assign_valid_types(src.ty(self.body, self.tcx), dest_ty) {
-                            self.fail(location, "adt field has the wrong type");
+                            self.fail(location, &format!("adt field has the wrong type. src:{:?} dest_ty:{dest_ty:?} src:{src:?}",src.ty(self.body, self.tcx)));
                         }
                     }
                 }