rustc_mir_transform/
copy_prop.rs

1use rustc_index::IndexSlice;
2use rustc_index::bit_set::DenseBitSet;
3use rustc_middle::mir::visit::*;
4use rustc_middle::mir::*;
5use rustc_middle::ty::TyCtxt;
6use tracing::{debug, instrument};
7
8use crate::ssa::SsaLocals;
9
10/// Unify locals that copy each other.
11///
12/// We consider patterns of the form
13///   _a = rvalue
14///   _b = move? _a
15///   _c = move? _a
16///   _d = move? _c
17/// where each of the locals is only assigned once.
18///
19/// We want to replace all those locals by `_a`, either copied or moved.
20pub(super) struct CopyProp;
21
22impl<'tcx> crate::MirPass<'tcx> for CopyProp {
23    fn is_enabled(&self, sess: &rustc_session::Session) -> bool {
24        sess.mir_opt_level() >= 1
25    }
26
27    #[instrument(level = "trace", skip(self, tcx, body))]
28    fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
29        debug!(def_id = ?body.source.def_id());
30
31        let typing_env = body.typing_env(tcx);
32        let ssa = SsaLocals::new(tcx, body, typing_env);
33        debug!(borrowed_locals = ?ssa.borrowed_locals());
34        debug!(copy_classes = ?ssa.copy_classes());
35
36        let fully_moved = fully_moved_locals(&ssa, body);
37        debug!(?fully_moved);
38
39        let mut storage_to_remove = DenseBitSet::new_empty(fully_moved.domain_size());
40        for (local, &head) in ssa.copy_classes().iter_enumerated() {
41            if local != head {
42                storage_to_remove.insert(head);
43            }
44        }
45
46        let any_replacement = ssa.copy_classes().iter_enumerated().any(|(l, &h)| l != h);
47
48        Replacer { tcx, copy_classes: ssa.copy_classes(), fully_moved, storage_to_remove }
49            .visit_body_preserves_cfg(body);
50
51        if any_replacement {
52            crate::simplify::remove_unused_definitions(body);
53        }
54    }
55
56    fn is_required(&self) -> bool {
57        false
58    }
59}
60
61/// `SsaLocals` computed equivalence classes between locals considering copy/move assignments.
62///
63/// This function also returns whether all the `move?` in the pattern are `move` and not copies.
64/// A local which is in the bitset can be replaced by `move _a`. Otherwise, it must be
65/// replaced by `copy _a`, as we cannot move multiple times from `_a`.
66///
67/// If an operand copies `_c`, it must happen before the assignment `_d = _c`, otherwise it is UB.
68/// This means that replacing it by a copy of `_a` if ok, since this copy happens before `_c` is
69/// moved, and therefore that `_d` is moved.
70#[instrument(level = "trace", skip(ssa, body))]
71fn fully_moved_locals(ssa: &SsaLocals, body: &Body<'_>) -> DenseBitSet<Local> {
72    let mut fully_moved = DenseBitSet::new_filled(body.local_decls.len());
73
74    for (_, rvalue, _) in ssa.assignments(body) {
75        let (Rvalue::Use(Operand::Copy(place) | Operand::Move(place))
76        | Rvalue::CopyForDeref(place)) = rvalue
77        else {
78            continue;
79        };
80
81        let Some(rhs) = place.as_local() else { continue };
82        if !ssa.is_ssa(rhs) {
83            continue;
84        }
85
86        if let Rvalue::Use(Operand::Copy(_)) | Rvalue::CopyForDeref(_) = rvalue {
87            fully_moved.remove(rhs);
88        }
89    }
90
91    ssa.meet_copy_equivalence(&mut fully_moved);
92
93    fully_moved
94}
95
96/// Utility to help performing substitution of `*pattern` by `target`.
97struct Replacer<'a, 'tcx> {
98    tcx: TyCtxt<'tcx>,
99    fully_moved: DenseBitSet<Local>,
100    storage_to_remove: DenseBitSet<Local>,
101    copy_classes: &'a IndexSlice<Local, Local>,
102}
103
104impl<'tcx> MutVisitor<'tcx> for Replacer<'_, 'tcx> {
105    fn tcx(&self) -> TyCtxt<'tcx> {
106        self.tcx
107    }
108
109    #[tracing::instrument(level = "trace", skip(self))]
110    fn visit_local(&mut self, local: &mut Local, ctxt: PlaceContext, _: Location) {
111        let new_local = self.copy_classes[*local];
112        match ctxt {
113            // Do not modify the local in storage statements.
114            PlaceContext::NonUse(NonUseContext::StorageLive | NonUseContext::StorageDead) => {}
115            // We access the value.
116            _ => *local = new_local,
117        }
118    }
119
120    #[tracing::instrument(level = "trace", skip(self))]
121    fn visit_operand(&mut self, operand: &mut Operand<'tcx>, loc: Location) {
122        if let Operand::Move(place) = *operand
123            // A move out of a projection of a copy is equivalent to a copy of the original
124            // projection.
125            && !place.is_indirect_first_projection()
126            && !self.fully_moved.contains(place.local)
127        {
128            *operand = Operand::Copy(place);
129        }
130        self.super_operand(operand, loc);
131    }
132
133    #[tracing::instrument(level = "trace", skip(self))]
134    fn visit_statement(&mut self, stmt: &mut Statement<'tcx>, loc: Location) {
135        // When removing storage statements, we need to remove both (#107511).
136        if let StatementKind::StorageLive(l) | StatementKind::StorageDead(l) = stmt.kind
137            && self.storage_to_remove.contains(l)
138        {
139            stmt.make_nop();
140            return;
141        }
142
143        self.super_statement(stmt, loc);
144
145        // Do not leave tautological assignments around.
146        if let StatementKind::Assign(box (lhs, ref rhs)) = stmt.kind
147            && let Rvalue::Use(Operand::Copy(rhs) | Operand::Move(rhs)) | Rvalue::CopyForDeref(rhs) =
148                *rhs
149            && lhs == rhs
150        {
151            stmt.make_nop();
152        }
153    }
154}
rustc_mir_transform/copy_prop.rs

rustc_mir_transform/
copy_prop.rs
