rustc_mir_transform/
nrvo.rs1use rustc_hir::Mutability;
4use rustc_index::bit_set::DenseBitSet;
5use rustc_middle::bug;
6use rustc_middle::mir::visit::{MutVisitor, NonUseContext, PlaceContext, Visitor};
7use rustc_middle::mir::{self, BasicBlock, Local, Location};
8use rustc_middle::ty::TyCtxt;
9use tracing::{debug, trace};
10
11pub(super) struct RenameReturnPlace;
34
35impl<'tcx> crate::MirPass<'tcx> for RenameReturnPlace {
36 fn is_enabled(&self, sess: &rustc_session::Session) -> bool {
37 sess.mir_opt_level() > 0 && sess.opts.unstable_opts.unsound_mir_opts
39 }
40
41 fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut mir::Body<'tcx>) {
42 let def_id = body.source.def_id();
43 let Some(returned_local) = local_eligible_for_nrvo(body) else {
44 debug!("`{:?}` was ineligible for NRVO", def_id);
45 return;
46 };
47
48 debug!(
49 "`{:?}` was eligible for NRVO, making {:?} the return place",
50 def_id, returned_local
51 );
52
53 RenameToReturnPlace { tcx, to_rename: returned_local }.visit_body_preserves_cfg(body);
54
55 for block_data in body.basic_blocks.as_mut_preserves_cfg() {
57 block_data.statements.retain(|stmt| stmt.kind != mir::StatementKind::Nop);
58 }
59
60 let (renamed_decl, ret_decl) =
62 body.local_decls.pick2_mut(returned_local, mir::RETURN_PLACE);
63
64 debug!("_0: {:?} = {:?}: {:?}", ret_decl.ty, returned_local, renamed_decl.ty);
69 ret_decl.clone_from(renamed_decl);
70
71 ret_decl.mutability = Mutability::Mut;
73 }
74
75 fn is_required(&self) -> bool {
76 false
77 }
78}
79
80fn local_eligible_for_nrvo(body: &mir::Body<'_>) -> Option<Local> {
88 if IsReturnPlaceRead::run(body) {
89 return None;
90 }
91
92 let mut copied_to_return_place = None;
93 for block in body.basic_blocks.indices() {
94 if !matches!(body[block].terminator().kind, mir::TerminatorKind::Return) {
96 continue;
97 }
98
99 let returned_local = find_local_assigned_to_return_place(block, body)?;
101 match body.local_kind(returned_local) {
102 mir::LocalKind::Arg => return None,
104
105 mir::LocalKind::ReturnPointer => bug!("Return place was assigned to itself?"),
106 mir::LocalKind::Temp => {}
107 }
108
109 if copied_to_return_place.is_some_and(|old| old != returned_local) {
112 return None;
113 }
114
115 copied_to_return_place = Some(returned_local);
116 }
117
118 copied_to_return_place
119}
120
121fn find_local_assigned_to_return_place(start: BasicBlock, body: &mir::Body<'_>) -> Option<Local> {
122 let mut block = start;
123 let mut seen = DenseBitSet::new_empty(body.basic_blocks.len());
124
125 while seen.insert(block) {
127 trace!("Looking for assignments to `_0` in {:?}", block);
128
129 let local = body[block].statements.iter().rev().find_map(as_local_assigned_to_return_place);
130 if local.is_some() {
131 return local;
132 }
133
134 match body.basic_blocks.predecessors()[block].as_slice() {
135 &[pred] => block = pred,
136 _ => return None,
137 }
138 }
139
140 None
141}
142
143fn as_local_assigned_to_return_place(stmt: &mir::Statement<'_>) -> Option<Local> {
146 if let mir::StatementKind::Assign(box (lhs, rhs)) = &stmt.kind {
147 if lhs.as_local() == Some(mir::RETURN_PLACE) {
148 if let mir::Rvalue::Use(mir::Operand::Copy(rhs) | mir::Operand::Move(rhs)) = rhs {
149 return rhs.as_local();
150 }
151 }
152 }
153
154 None
155}
156
157struct RenameToReturnPlace<'tcx> {
158 to_rename: Local,
159 tcx: TyCtxt<'tcx>,
160}
161
162impl<'tcx> MutVisitor<'tcx> for RenameToReturnPlace<'tcx> {
164 fn tcx(&self) -> TyCtxt<'tcx> {
165 self.tcx
166 }
167
168 fn visit_statement(&mut self, stmt: &mut mir::Statement<'tcx>, loc: Location) {
169 if as_local_assigned_to_return_place(stmt) == Some(self.to_rename) {
173 stmt.kind = mir::StatementKind::Nop;
174 return;
175 }
176
177 if let mir::StatementKind::StorageLive(local) | mir::StatementKind::StorageDead(local) =
180 stmt.kind
181 {
182 if local == self.to_rename {
183 stmt.kind = mir::StatementKind::Nop;
184 return;
185 }
186 }
187
188 self.super_statement(stmt, loc)
189 }
190
191 fn visit_terminator(&mut self, terminator: &mut mir::Terminator<'tcx>, loc: Location) {
192 if let mir::TerminatorKind::Return = terminator.kind {
194 return;
195 }
196
197 self.super_terminator(terminator, loc);
198 }
199
200 fn visit_local(&mut self, l: &mut Local, ctxt: PlaceContext, _: Location) {
201 if *l == mir::RETURN_PLACE {
202 assert_eq!(ctxt, PlaceContext::NonUse(NonUseContext::VarDebugInfo));
203 } else if *l == self.to_rename {
204 *l = mir::RETURN_PLACE;
205 }
206 }
207}
208
209struct IsReturnPlaceRead(bool);
210
211impl IsReturnPlaceRead {
212 fn run(body: &mir::Body<'_>) -> bool {
213 let mut vis = IsReturnPlaceRead(false);
214 vis.visit_body(body);
215 vis.0
216 }
217}
218
219impl<'tcx> Visitor<'tcx> for IsReturnPlaceRead {
220 fn visit_local(&mut self, l: Local, ctxt: PlaceContext, _: Location) {
221 if l == mir::RETURN_PLACE && ctxt.is_use() && !ctxt.is_place_assignment() {
222 self.0 = true;
223 }
224 }
225
226 fn visit_terminator(&mut self, terminator: &mir::Terminator<'tcx>, loc: Location) {
227 if let mir::TerminatorKind::Return = terminator.kind {
229 return;
230 }
231
232 self.super_terminator(terminator, loc);
233 }
234}