rust-lang/rust
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

mir: Use the new method for BasicBlockData

Browse Source
This commit is contained in:
dianqk
2025-06-16 22:31:25 +08:00
parent 9f9cd5e283
commit 24e553e6bc
13 changed files with 180 additions and 209 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
compiler/rustc_middle/src/mir/mod.rs
View File

@@ -1359,7 +1359,15 @@ pub struct BasicBlockData<'tcx> {
impl<'tcx> BasicBlockData<'tcx> { impl<'tcx> BasicBlockData<'tcx> {
pub fn new(terminator: Option<Terminator<'tcx>>, is_cleanup: bool) -> BasicBlockData<'tcx> { pub fn new(terminator: Option<Terminator<'tcx>>, is_cleanup: bool) -> BasicBlockData<'tcx> {
BasicBlockData { statements: vec![], terminator, is_cleanup } BasicBlockData::new_stmts(Vec::new(), terminator, is_cleanup)
}
pub fn new_stmts(
statements: Vec<Statement<'tcx>>,
terminator: Option<Terminator<'tcx>>,
is_cleanup: bool,
) -> BasicBlockData<'tcx> {
BasicBlockData { statements, terminator, is_cleanup }
} }
/// Accessor for terminator. /// Accessor for terminator.

10
compiler/rustc_mir_dataflow/src/framework/tests.rs
View File

@@ -19,11 +19,11 @@ fn mock_body<'tcx>() -> mir::Body<'tcx> {
let mut block = |n, kind| { let mut block = |n, kind| {
let nop = mir::Statement::new(source_info, mir::StatementKind::Nop); let nop = mir::Statement::new(source_info, mir::StatementKind::Nop);
blocks.push(mir::BasicBlockData { blocks.push(mir::BasicBlockData::new_stmts(
statements: std::iter::repeat(&nop).cloned().take(n).collect(), std::iter::repeat(&nop).cloned().take(n).collect(),
terminator: Some(mir::Terminator { source_info, kind }), Some(mir::Terminator { source_info, kind }),
is_cleanup: false, false,
}) ))
}; };
let dummy_place = mir::Place { local: mir::RETURN_PLACE, projection: ty::List::empty() }; let dummy_place = mir::Place { local: mir::RETURN_PLACE, projection: ty::List::empty() };

7
compiler/rustc_mir_transform/src/add_call_guards.rs
View File

@@ -44,11 +44,10 @@ impl<'tcx> crate::MirPass<'tcx> for AddCallGuards {
let cur_len = body.basic_blocks.len(); let cur_len = body.basic_blocks.len();
let mut new_block = |source_info: SourceInfo, is_cleanup: bool, target: BasicBlock| { let mut new_block = |source_info: SourceInfo, is_cleanup: bool, target: BasicBlock| {
let block = BasicBlockData { let block = BasicBlockData::new(
statements: vec![], Some(Terminator { source_info, kind: TerminatorKind::Goto { target } }),
is_cleanup, is_cleanup,
terminator: Some(Terminator { source_info, kind: TerminatorKind::Goto { target } }), );
};
let idx = cur_len + new_blocks.len(); let idx = cur_len + new_blocks.len();
new_blocks.push(block); new_blocks.push(block);
BasicBlock::new(idx) BasicBlock::new(idx)

8
compiler/rustc_mir_transform/src/add_moves_for_packed_drops.rs
View File

@@ -93,11 +93,11 @@ fn add_move_for_packed_drop<'tcx>(
let ty = place.ty(body, tcx).ty; let ty = place.ty(body, tcx).ty;
let temp = patch.new_temp(ty, source_info.span); let temp = patch.new_temp(ty, source_info.span);
let storage_dead_block = patch.new_block(BasicBlockData { let storage_dead_block = patch.new_block(BasicBlockData::new_stmts(
statements: vec![Statement::new(source_info, StatementKind::StorageDead(temp))], vec![Statement::new(source_info, StatementKind::StorageDead(temp))],
terminator: Some(Terminator { source_info, kind: TerminatorKind::Goto { target } }), Some(Terminator { source_info, kind: TerminatorKind::Goto { target } }),
is_cleanup, is_cleanup,
}); ));
patch.add_statement(loc, StatementKind::StorageLive(temp)); patch.add_statement(loc, StatementKind::StorageLive(temp));
patch.add_assign(loc, Place::from(temp), Rvalue::Use(Operand::Move(*place))); patch.add_assign(loc, Place::from(temp), Rvalue::Use(Operand::Move(*place)));

10
compiler/rustc_mir_transform/src/check_pointers.rs
View File

@@ -235,11 +235,11 @@ fn split_block(
let block_data = &mut basic_blocks[location.block]; let block_data = &mut basic_blocks[location.block];
// Drain every statement after this one and move the current terminator to a new basic block. // Drain every statement after this one and move the current terminator to a new basic block.
let new_block = BasicBlockData { let new_block = BasicBlockData::new_stmts(
statements: block_data.statements.split_off(location.statement_index), block_data.statements.split_off(location.statement_index),
terminator: block_data.terminator.take(), block_data.terminator.take(),
is_cleanup: block_data.is_cleanup, block_data.is_cleanup,
}; );
basic_blocks.push(new_block) basic_blocks.push(new_block)
} }

57
compiler/rustc_mir_transform/src/coroutine.rs
View File

@@ -257,11 +257,11 @@ impl<'tcx> TransformVisitor<'tcx> {
StatementKind::Assign(Box::new((Place::return_place(), none_value))), StatementKind::Assign(Box::new((Place::return_place(), none_value))),
)]; )];
body.basic_blocks_mut().push(BasicBlockData { body.basic_blocks_mut().push(BasicBlockData::new_stmts(
statements, statements,
terminator: Some(Terminator { source_info, kind: TerminatorKind::Return }), Some(Terminator { source_info, kind: TerminatorKind::Return }),
is_cleanup: false, false,
}); ));
block block
} }
@@ -1073,11 +1073,11 @@ fn insert_switch<'tcx>(
let source_info = SourceInfo::outermost(body.span); let source_info = SourceInfo::outermost(body.span);
body.basic_blocks_mut().raw.insert( body.basic_blocks_mut().raw.insert(
0, 0,
BasicBlockData { BasicBlockData::new_stmts(
statements: vec![assign], vec![assign],
terminator: Some(Terminator { source_info, kind: switch }), Some(Terminator { source_info, kind: switch }),
is_cleanup: false, false,
}, ),
); );
for b in body.basic_blocks_mut().iter_mut() { for b in body.basic_blocks_mut().iter_mut() {
@@ -1087,11 +1087,7 @@ fn insert_switch<'tcx>(
fn insert_term_block<'tcx>(body: &mut Body<'tcx>, kind: TerminatorKind<'tcx>) -> BasicBlock { fn insert_term_block<'tcx>(body: &mut Body<'tcx>, kind: TerminatorKind<'tcx>) -> BasicBlock {
let source_info = SourceInfo::outermost(body.span); let source_info = SourceInfo::outermost(body.span);
body.basic_blocks_mut().push(BasicBlockData { body.basic_blocks_mut().push(BasicBlockData::new(Some(Terminator { source_info, kind }), false))
statements: Vec::new(),
terminator: Some(Terminator { source_info, kind }),
is_cleanup: false,
})
} }
fn return_poll_ready_assign<'tcx>(tcx: TyCtxt<'tcx>, source_info: SourceInfo) -> Statement<'tcx> { fn return_poll_ready_assign<'tcx>(tcx: TyCtxt<'tcx>, source_info: SourceInfo) -> Statement<'tcx> {
@@ -1112,11 +1108,11 @@ fn return_poll_ready_assign<'tcx>(tcx: TyCtxt<'tcx>, source_info: SourceInfo) ->
fn insert_poll_ready_block<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) -> BasicBlock { fn insert_poll_ready_block<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) -> BasicBlock {
let source_info = SourceInfo::outermost(body.span); let source_info = SourceInfo::outermost(body.span);
body.basic_blocks_mut().push(BasicBlockData { body.basic_blocks_mut().push(BasicBlockData::new_stmts(
statements: [return_poll_ready_assign(tcx, source_info)].to_vec(), [return_poll_ready_assign(tcx, source_info)].to_vec(),
terminator: Some(Terminator { source_info, kind: TerminatorKind::Return }), Some(Terminator { source_info, kind: TerminatorKind::Return }),
is_cleanup: false, false,
}) ))
} }
fn insert_panic_block<'tcx>( fn insert_panic_block<'tcx>(
@@ -1200,13 +1196,11 @@ fn generate_poison_block_and_redirect_unwinds_there<'tcx>(
body: &mut Body<'tcx>, body: &mut Body<'tcx>,
) { ) {
let source_info = SourceInfo::outermost(body.span); let source_info = SourceInfo::outermost(body.span);
let poison_block = body.basic_blocks_mut().push(BasicBlockData { let poison_block = body.basic_blocks_mut().push(BasicBlockData::new_stmts(
statements: vec![ vec![transform.set_discr(VariantIdx::new(CoroutineArgs::POISONED), source_info)],
transform.set_discr(VariantIdx::new(CoroutineArgs::POISONED), source_info), Some(Terminator { source_info, kind: TerminatorKind::UnwindResume }),
], true,
terminator: Some(Terminator { source_info, kind: TerminatorKind::UnwindResume }), ));
is_cleanup: true,
});
for (idx, block) in body.basic_blocks_mut().iter_enumerated_mut() { for (idx, block) in body.basic_blocks_mut().iter_enumerated_mut() {
let source_info = block.terminator().source_info; let source_info = block.terminator().source_info;
@@ -1357,14 +1351,11 @@ fn create_cases<'tcx>(
} }
// Then jump to the real target // Then jump to the real target
let block = body.basic_blocks_mut().push(BasicBlockData { let block = body.basic_blocks_mut().push(BasicBlockData::new_stmts(
statements, statements,
terminator: Some(Terminator { Some(Terminator { source_info, kind: TerminatorKind::Goto { target } }),
source_info, false,
kind: TerminatorKind::Goto { target }, ));
}),
is_cleanup: false,
});
(point.state, block) (point.state, block)
}) })

33
compiler/rustc_mir_transform/src/coroutine/drop.rs
View File

@@ -102,9 +102,9 @@ fn build_pin_fut<'tcx>(
); );
// call Pin<FutTy>::new_unchecked(&mut fut) // call Pin<FutTy>::new_unchecked(&mut fut)
let pin_fut_bb = body.basic_blocks_mut().push(BasicBlockData { let pin_fut_bb = body.basic_blocks_mut().push(BasicBlockData::new_stmts(
statements: [storage_live, fut_ref_assign].to_vec(), [storage_live, fut_ref_assign].to_vec(),
terminator: Some(Terminator { Some(Terminator {
source_info, source_info,
kind: TerminatorKind::Call { kind: TerminatorKind::Call {
func: pin_fut_new_unchecked_fn, func: pin_fut_new_unchecked_fn,
@@ -116,8 +116,8 @@ fn build_pin_fut<'tcx>(
fn_span: span, fn_span: span,
}, },
}), }),
is_cleanup: false, false,
}); ));
(pin_fut_bb, fut_pin_place) (pin_fut_bb, fut_pin_place)
} }
@@ -161,9 +161,9 @@ fn build_poll_switch<'tcx>(
); );
let storage_dead = Statement::new(source_info, StatementKind::StorageDead(fut_pin_place.local)); let storage_dead = Statement::new(source_info, StatementKind::StorageDead(fut_pin_place.local));
let unreachable_block = insert_term_block(body, TerminatorKind::Unreachable); let unreachable_block = insert_term_block(body, TerminatorKind::Unreachable);
body.basic_blocks_mut().push(BasicBlockData { body.basic_blocks_mut().push(BasicBlockData::new_stmts(
statements: [storage_dead, discr_assign].to_vec(), [storage_dead, discr_assign].to_vec(),
terminator: Some(Terminator { Some(Terminator {
source_info, source_info,
kind: TerminatorKind::SwitchInt { kind: TerminatorKind::SwitchInt {
discr: Operand::Move(poll_discr_place), discr: Operand::Move(poll_discr_place),
@@ -174,8 +174,8 @@ fn build_poll_switch<'tcx>(
), ),
}, },
}), }),
is_cleanup: false, false,
}) ))
} }
// Gather blocks, reachable through 'drop' targets of Yield and Drop terminators (chained) // Gather blocks, reachable through 'drop' targets of Yield and Drop terminators (chained)
@@ -546,11 +546,8 @@ pub(super) fn insert_clean_drop<'tcx>(
}; };
// Create a block to destroy an unresumed coroutines. This can only destroy upvars. // Create a block to destroy an unresumed coroutines. This can only destroy upvars.
body.basic_blocks_mut().push(BasicBlockData { body.basic_blocks_mut()
statements: Vec::new(), .push(BasicBlockData::new(Some(Terminator { source_info, kind: term }), false))
terminator: Some(Terminator { source_info, kind: term }),
is_cleanup: false,
})
} }
pub(super) fn create_coroutine_drop_shim<'tcx>( pub(super) fn create_coroutine_drop_shim<'tcx>(
@@ -729,11 +726,7 @@ pub(super) fn create_coroutine_drop_shim_proxy_async<'tcx>(
body.local_decls[RETURN_PLACE] = LocalDecl::with_source_info(poll_enum, source_info); body.local_decls[RETURN_PLACE] = LocalDecl::with_source_info(poll_enum, source_info);
// call coroutine_drop() // call coroutine_drop()
let call_bb = body.basic_blocks_mut().push(BasicBlockData { let call_bb = body.basic_blocks_mut().push(BasicBlockData::new(None, false));
statements: Vec::new(),
terminator: None,
is_cleanup: false,
});
// return Poll::Ready() // return Poll::Ready()
let ret_bb = insert_poll_ready_block(tcx, &mut body); let ret_bb = insert_poll_ready_block(tcx, &mut body);

9
compiler/rustc_mir_transform/src/coverage/tests.rs
View File

@@ -68,14 +68,13 @@ impl<'tcx> MockBlocks<'tcx> {
BytePos(1) BytePos(1)
}; };
let next_hi = next_lo + BytePos(1); let next_hi = next_lo + BytePos(1);
self.blocks.push(BasicBlockData { self.blocks.push(BasicBlockData::new(
statements: vec![], Some(Terminator {
terminator: Some(Terminator {
source_info: SourceInfo::outermost(Span::with_root_ctxt(next_lo, next_hi)), source_info: SourceInfo::outermost(Span::with_root_ctxt(next_lo, next_hi)),
kind, kind,
}), }),
is_cleanup: false, false,
}) ))
} }
fn link(&mut self, from_block: BasicBlock, to_block: BasicBlock) { fn link(&mut self, from_block: BasicBlock, to_block: BasicBlock) {

114
compiler/rustc_mir_transform/src/elaborate_drop.rs
View File

@@ -222,15 +222,14 @@ where
let span = self.source_info.span; let span = self.source_info.span;
let pin_obj_bb = bb.unwrap_or_else(|| { let pin_obj_bb = bb.unwrap_or_else(|| {
self.elaborator.patch().new_block(BasicBlockData { self.elaborator.patch().new_block(BasicBlockData::new(
statements: vec![], Some(Terminator {
terminator: Some(Terminator {
// Temporary terminator, will be replaced by patch // Temporary terminator, will be replaced by patch
source_info: self.source_info, source_info: self.source_info,
kind: TerminatorKind::Return, kind: TerminatorKind::Return,
}), }),
is_cleanup: false, false,
}) ))
}); });
let (fut_ty, drop_fn_def_id, trait_args) = if call_destructor_only { let (fut_ty, drop_fn_def_id, trait_args) = if call_destructor_only {
@@ -730,17 +729,17 @@ where
let do_drop_bb = self.drop_subpath(interior, interior_path, succ, unwind, dropline); let do_drop_bb = self.drop_subpath(interior, interior_path, succ, unwind, dropline);
let setup_bbd = BasicBlockData { let setup_bbd = BasicBlockData::new_stmts(
statements: vec![self.assign( vec![self.assign(
Place::from(ptr_local), Place::from(ptr_local),
Rvalue::Cast(CastKind::Transmute, Operand::Copy(nonnull_place), ptr_ty), Rvalue::Cast(CastKind::Transmute, Operand::Copy(nonnull_place), ptr_ty),
)], )],
terminator: Some(Terminator { Some(Terminator {
kind: TerminatorKind::Goto { target: do_drop_bb }, kind: TerminatorKind::Goto { target: do_drop_bb },
source_info: self.source_info, source_info: self.source_info,
}), }),
is_cleanup: unwind.is_cleanup(), unwind.is_cleanup(),
}; );
self.elaborator.patch().new_block(setup_bbd) self.elaborator.patch().new_block(setup_bbd)
} }
@@ -751,14 +750,13 @@ where
args: GenericArgsRef<'tcx>, args: GenericArgsRef<'tcx>,
) -> BasicBlock { ) -> BasicBlock {
if adt.variants().is_empty() { if adt.variants().is_empty() {
return self.elaborator.patch().new_block(BasicBlockData { return self.elaborator.patch().new_block(BasicBlockData::new(
statements: vec![], Some(Terminator {
terminator: Some(Terminator {
source_info: self.source_info, source_info: self.source_info,
kind: TerminatorKind::Unreachable, kind: TerminatorKind::Unreachable,
}), }),
is_cleanup: self.unwind.is_cleanup(), self.unwind.is_cleanup(),
}); ));
} }
let skip_contents = adt.is_union() || adt.is_manually_drop(); let skip_contents = adt.is_union() || adt.is_manually_drop();
@@ -925,9 +923,9 @@ where
let discr_ty = adt.repr().discr_type().to_ty(self.tcx()); let discr_ty = adt.repr().discr_type().to_ty(self.tcx());
let discr = Place::from(self.new_temp(discr_ty)); let discr = Place::from(self.new_temp(discr_ty));
let discr_rv = Rvalue::Discriminant(self.place); let discr_rv = Rvalue::Discriminant(self.place);
let switch_block = BasicBlockData { let switch_block = BasicBlockData::new_stmts(
statements: vec![self.assign(discr, discr_rv)], vec![self.assign(discr, discr_rv)],
terminator: Some(Terminator { Some(Terminator {
source_info: self.source_info, source_info: self.source_info,
kind: TerminatorKind::SwitchInt { kind: TerminatorKind::SwitchInt {
discr: Operand::Move(discr), discr: Operand::Move(discr),
@@ -937,8 +935,8 @@ where
), ),
}, },
}), }),
is_cleanup: unwind.is_cleanup(), unwind.is_cleanup(),
}; );
let switch_block = self.elaborator.patch().new_block(switch_block); let switch_block = self.elaborator.patch().new_block(switch_block);
self.drop_flag_test_block(switch_block, succ, unwind) self.drop_flag_test_block(switch_block, succ, unwind)
} }
@@ -954,8 +952,8 @@ where
let ref_place = self.new_temp(ref_ty); let ref_place = self.new_temp(ref_ty);
let unit_temp = Place::from(self.new_temp(tcx.types.unit)); let unit_temp = Place::from(self.new_temp(tcx.types.unit));
let result = BasicBlockData { let result = BasicBlockData::new_stmts(
statements: vec![self.assign( vec![self.assign(
Place::from(ref_place), Place::from(ref_place),
Rvalue::Ref( Rvalue::Ref(
tcx.lifetimes.re_erased, tcx.lifetimes.re_erased,
@@ -963,7 +961,7 @@ where
self.place, self.place,
), ),
)], )],
terminator: Some(Terminator { Some(Terminator {
kind: TerminatorKind::Call { kind: TerminatorKind::Call {
func: Operand::function_handle( func: Operand::function_handle(
tcx, tcx,
@@ -981,8 +979,8 @@ where
}, },
source_info: self.source_info, source_info: self.source_info,
}), }),
is_cleanup: unwind.is_cleanup(), unwind.is_cleanup(),
}; );
let destructor_block = self.elaborator.patch().new_block(result); let destructor_block = self.elaborator.patch().new_block(result);
@@ -1045,8 +1043,8 @@ where
let can_go = Place::from(self.new_temp(tcx.types.bool)); let can_go = Place::from(self.new_temp(tcx.types.bool));
let one = self.constant_usize(1); let one = self.constant_usize(1);
let drop_block = BasicBlockData { let drop_block = BasicBlockData::new_stmts(
statements: vec![ vec![
self.assign( self.assign(
ptr, ptr,
Rvalue::RawPtr(RawPtrKind::Mut, tcx.mk_place_index(self.place, cur)), Rvalue::RawPtr(RawPtrKind::Mut, tcx.mk_place_index(self.place, cur)),
@@ -1056,26 +1054,26 @@ where
Rvalue::BinaryOp(BinOp::Add, Box::new((move_(cur.into()), one))), Rvalue::BinaryOp(BinOp::Add, Box::new((move_(cur.into()), one))),
), ),
], ],
is_cleanup: unwind.is_cleanup(), Some(Terminator {
terminator: Some(Terminator {
source_info: self.source_info, source_info: self.source_info,
// this gets overwritten by drop elaboration. // this gets overwritten by drop elaboration.
kind: TerminatorKind::Unreachable, kind: TerminatorKind::Unreachable,
}), }),
}; unwind.is_cleanup(),
);
let drop_block = self.elaborator.patch().new_block(drop_block); let drop_block = self.elaborator.patch().new_block(drop_block);
let loop_block = BasicBlockData { let loop_block = BasicBlockData::new_stmts(
statements: vec![self.assign( vec![self.assign(
can_go, can_go,
Rvalue::BinaryOp(BinOp::Eq, Box::new((copy(Place::from(cur)), copy(len.into())))), Rvalue::BinaryOp(BinOp::Eq, Box::new((copy(Place::from(cur)), copy(len.into())))),
)], )],
is_cleanup: unwind.is_cleanup(), Some(Terminator {
terminator: Some(Terminator {
source_info: self.source_info, source_info: self.source_info,
kind: TerminatorKind::if_(move_(can_go), succ, drop_block), kind: TerminatorKind::if_(move_(can_go), succ, drop_block),
}), }),
}; unwind.is_cleanup(),
);
let loop_block = self.elaborator.patch().new_block(loop_block); let loop_block = self.elaborator.patch().new_block(loop_block);
let place = tcx.mk_place_deref(ptr); let place = tcx.mk_place_deref(ptr);
@@ -1185,8 +1183,8 @@ where
let slice_ptr_ty = Ty::new_mut_ptr(tcx, slice_ty); let slice_ptr_ty = Ty::new_mut_ptr(tcx, slice_ty);
let slice_ptr = self.new_temp(slice_ptr_ty); let slice_ptr = self.new_temp(slice_ptr_ty);
let mut delegate_block = BasicBlockData { let mut delegate_block = BasicBlockData::new_stmts(
statements: vec![ vec![
self.assign(Place::from(array_ptr), Rvalue::RawPtr(RawPtrKind::Mut, self.place)), self.assign(Place::from(array_ptr), Rvalue::RawPtr(RawPtrKind::Mut, self.place)),
self.assign( self.assign(
Place::from(slice_ptr), Place::from(slice_ptr),
@@ -1200,9 +1198,9 @@ where
), ),
), ),
], ],
is_cleanup: self.unwind.is_cleanup(), None,
terminator: None, self.unwind.is_cleanup(),
}; );
let array_place = mem::replace( let array_place = mem::replace(
&mut self.place, &mut self.place,
@@ -1244,8 +1242,8 @@ where
}; };
let zero = self.constant_usize(0); let zero = self.constant_usize(0);
let block = BasicBlockData { let block = BasicBlockData::new_stmts(
statements: vec![ vec![
self.assign( self.assign(
len.into(), len.into(),
Rvalue::UnaryOp( Rvalue::UnaryOp(
@@ -1255,12 +1253,12 @@ where
), ),
self.assign(cur.into(), Rvalue::Use(zero)), self.assign(cur.into(), Rvalue::Use(zero)),
], ],
is_cleanup: unwind.is_cleanup(), Some(Terminator {
terminator: Some(Terminator {
source_info: self.source_info, source_info: self.source_info,
kind: TerminatorKind::Goto { target: loop_block }, kind: TerminatorKind::Goto { target: loop_block },
}), }),
}; unwind.is_cleanup(),
);
let drop_block = self.elaborator.patch().new_block(block); let drop_block = self.elaborator.patch().new_block(block);
// FIXME(#34708): handle partially-dropped array/slice elements. // FIXME(#34708): handle partially-dropped array/slice elements.
@@ -1306,14 +1304,13 @@ where
self.source_info.span, self.source_info.span,
"open drop for unsafe binder shouldn't be encountered", "open drop for unsafe binder shouldn't be encountered",
); );
self.elaborator.patch().new_block(BasicBlockData { self.elaborator.patch().new_block(BasicBlockData::new(
statements: vec![], Some(Terminator {
terminator: Some(Terminator {
source_info: self.source_info, source_info: self.source_info,
kind: TerminatorKind::Unreachable, kind: TerminatorKind::Unreachable,
}), }),
is_cleanup: self.unwind.is_cleanup(), self.unwind.is_cleanup(),
}) ))
} }
_ => span_bug!(self.source_info.span, "open drop from non-ADT `{:?}`", ty), _ => span_bug!(self.source_info.span, "open drop from non-ADT `{:?}`", ty),
@@ -1432,11 +1429,10 @@ where
} }
fn new_block(&mut self, unwind: Unwind, k: TerminatorKind<'tcx>) -> BasicBlock { fn new_block(&mut self, unwind: Unwind, k: TerminatorKind<'tcx>) -> BasicBlock {
self.elaborator.patch().new_block(BasicBlockData { self.elaborator.patch().new_block(BasicBlockData::new(
statements: vec![], Some(Terminator { source_info: self.source_info, kind: k }),
terminator: Some(Terminator { source_info: self.source_info, kind: k }), unwind.is_cleanup(),
is_cleanup: unwind.is_cleanup(), ))
})
} }
fn new_block_with_statements( fn new_block_with_statements(
@@ -1445,11 +1441,11 @@ where
statements: Vec<Statement<'tcx>>, statements: Vec<Statement<'tcx>>,
k: TerminatorKind<'tcx>, k: TerminatorKind<'tcx>,
) -> BasicBlock { ) -> BasicBlock {
self.elaborator.patch().new_block(BasicBlockData { self.elaborator.patch().new_block(BasicBlockData::new_stmts(
statements, statements,
terminator: Some(Terminator { source_info: self.source_info, kind: k }), Some(Terminator { source_info: self.source_info, kind: k }),
is_cleanup: unwind.is_cleanup(), unwind.is_cleanup(),
}) ))
} }
fn new_temp(&mut self, ty: Ty<'tcx>) -> Local { fn new_temp(&mut self, ty: Ty<'tcx>) -> Local {

36
compiler/rustc_mir_transform/src/patch.rs
View File

@@ -78,14 +78,13 @@ impl<'tcx> MirPatch<'tcx> {
return bb; return bb;
} }
let bb = self.new_block(BasicBlockData { let bb = self.new_block(BasicBlockData::new(
statements: vec![], Some(Terminator {
terminator: Some(Terminator {
source_info: SourceInfo::outermost(self.body_span), source_info: SourceInfo::outermost(self.body_span),
kind: TerminatorKind::UnwindResume, kind: TerminatorKind::UnwindResume,
}), }),
is_cleanup: true, true,
}); ));
self.resume_block = Some(bb); self.resume_block = Some(bb);
bb bb
} }
@@ -95,14 +94,13 @@ impl<'tcx> MirPatch<'tcx> {
return bb; return bb;
} }
let bb = self.new_block(BasicBlockData { let bb = self.new_block(BasicBlockData::new(
statements: vec![], Some(Terminator {
terminator: Some(Terminator {
source_info: SourceInfo::outermost(self.body_span), source_info: SourceInfo::outermost(self.body_span),
kind: TerminatorKind::Unreachable, kind: TerminatorKind::Unreachable,
}), }),
is_cleanup: true, true,
}); ));
self.unreachable_cleanup_block = Some(bb); self.unreachable_cleanup_block = Some(bb);
bb bb
} }
@@ -112,14 +110,13 @@ impl<'tcx> MirPatch<'tcx> {
return bb; return bb;
} }
let bb = self.new_block(BasicBlockData { let bb = self.new_block(BasicBlockData::new(
statements: vec![], Some(Terminator {
terminator: Some(Terminator {
source_info: SourceInfo::outermost(self.body_span), source_info: SourceInfo::outermost(self.body_span),
kind: TerminatorKind::Unreachable, kind: TerminatorKind::Unreachable,
}), }),
is_cleanup: false, false,
}); ));
self.unreachable_no_cleanup_block = Some(bb); self.unreachable_no_cleanup_block = Some(bb);
bb bb
} }
@@ -131,14 +128,13 @@ impl<'tcx> MirPatch<'tcx> {
return cached_bb; return cached_bb;
} }
let bb = self.new_block(BasicBlockData { let bb = self.new_block(BasicBlockData::new(
statements: vec![], Some(Terminator {
terminator: Some(Terminator {
source_info: SourceInfo::outermost(self.body_span), source_info: SourceInfo::outermost(self.body_span),
kind: TerminatorKind::UnwindTerminate(reason), kind: TerminatorKind::UnwindTerminate(reason),
}), }),
is_cleanup: true, true,
}); ));
self.terminate_block = Some((bb, reason)); self.terminate_block = Some((bb, reason));
bb bb
} }

9
compiler/rustc_mir_transform/src/promote_consts.rs
View File

@@ -731,14 +731,13 @@ struct Promoter<'a, 'tcx> {
impl<'a, 'tcx> Promoter<'a, 'tcx> { impl<'a, 'tcx> Promoter<'a, 'tcx> {
fn new_block(&mut self) -> BasicBlock { fn new_block(&mut self) -> BasicBlock {
let span = self.promoted.span; let span = self.promoted.span;
self.promoted.basic_blocks_mut().push(BasicBlockData { self.promoted.basic_blocks_mut().push(BasicBlockData::new(
statements: vec![], Some(Terminator {
terminator: Some(Terminator {
source_info: SourceInfo::outermost(span), source_info: SourceInfo::outermost(span),
kind: TerminatorKind::Return, kind: TerminatorKind::Return,
}), }),
is_cleanup: false, false,
}) ))
} }
fn assign(&mut self, dest: Local, rvalue: Rvalue<'tcx>, span: Span) { fn assign(&mut self, dest: Local, rvalue: Rvalue<'tcx>, span: Span) {

54
compiler/rustc_mir_transform/src/shim.rs
View File

@@ -348,11 +348,7 @@ fn build_drop_shim<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, ty: Option<Ty<'tcx>>)
let return_block = BasicBlock::new(1); let return_block = BasicBlock::new(1);
let mut blocks = IndexVec::with_capacity(2); let mut blocks = IndexVec::with_capacity(2);
let block = |blocks: &mut IndexVec<_, _>, kind| { let block = |blocks: &mut IndexVec<_, _>, kind| {
blocks.push(BasicBlockData { blocks.push(BasicBlockData::new(Some(Terminator { source_info, kind }), false))
statements: vec![],
terminator: Some(Terminator { source_info, kind }),
is_cleanup: false,
})
}; };
block(&mut blocks, TerminatorKind::Goto { target: return_block }); block(&mut blocks, TerminatorKind::Goto { target: return_block });
block(&mut blocks, TerminatorKind::Return); block(&mut blocks, TerminatorKind::Return);
@@ -513,17 +509,17 @@ fn build_thread_local_shim<'tcx>(
let span = tcx.def_span(def_id); let span = tcx.def_span(def_id);
let source_info = SourceInfo::outermost(span); let source_info = SourceInfo::outermost(span);
let blocks = IndexVec::from_raw(vec![BasicBlockData { let blocks = IndexVec::from_raw(vec![BasicBlockData::new_stmts(
statements: vec![Statement::new( vec![Statement::new(
source_info, source_info,
StatementKind::Assign(Box::new(( StatementKind::Assign(Box::new((
Place::return_place(), Place::return_place(),
Rvalue::ThreadLocalRef(def_id), Rvalue::ThreadLocalRef(def_id),
))), ))),
)], )],
terminator: Some(Terminator { source_info, kind: TerminatorKind::Return }), Some(Terminator { source_info, kind: TerminatorKind::Return }),
is_cleanup: false, false,
}]); )]);
new_body( new_body(
MirSource::from_instance(instance), MirSource::from_instance(instance),
@@ -607,11 +603,11 @@ impl<'tcx> CloneShimBuilder<'tcx> {
is_cleanup: bool, is_cleanup: bool,
) -> BasicBlock { ) -> BasicBlock {
let source_info = self.source_info(); let source_info = self.source_info();
self.blocks.push(BasicBlockData { self.blocks.push(BasicBlockData::new_stmts(
statements, statements,
terminator: Some(Terminator { source_info, kind }), Some(Terminator { source_info, kind }),
is_cleanup, is_cleanup,
}) ))
} }
/// Gives the index of an upcoming BasicBlock, with an offset. /// Gives the index of an upcoming BasicBlock, with an offset.
@@ -954,11 +950,11 @@ fn build_call_shim<'tcx>(
let n_blocks = if let Some(Adjustment::RefMut) = rcvr_adjustment { 5 } else { 2 }; let n_blocks = if let Some(Adjustment::RefMut) = rcvr_adjustment { 5 } else { 2 };
let mut blocks = IndexVec::with_capacity(n_blocks); let mut blocks = IndexVec::with_capacity(n_blocks);
let block = |blocks: &mut IndexVec<_, _>, statements, kind, is_cleanup| { let block = |blocks: &mut IndexVec<_, _>, statements, kind, is_cleanup| {
blocks.push(BasicBlockData { blocks.push(BasicBlockData::new_stmts(
statements, statements,
terminator: Some(Terminator { source_info, kind }), Some(Terminator { source_info, kind }),
is_cleanup, is_cleanup,
}) ))
}; };
// BB #0 // BB #0
@@ -1082,11 +1078,11 @@ pub(super) fn build_adt_ctor(tcx: TyCtxt<'_>, ctor_id: DefId) -> Body<'_> {
))), ))),
); );
let start_block = BasicBlockData { let start_block = BasicBlockData::new_stmts(
statements: vec![statement], vec![statement],
terminator: Some(Terminator { source_info, kind: TerminatorKind::Return }), Some(Terminator { source_info, kind: TerminatorKind::Return }),
is_cleanup: false, false,
}; );
let source = MirSource::item(ctor_id); let source = MirSource::item(ctor_id);
let mut body = new_body( let mut body = new_body(
@@ -1133,11 +1129,11 @@ fn build_fn_ptr_addr_shim<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, self_ty: Ty<'t
StatementKind::Assign(Box::new((Place::return_place(), rvalue))), StatementKind::Assign(Box::new((Place::return_place(), rvalue))),
); );
let statements = vec![stmt]; let statements = vec![stmt];
let start_block = BasicBlockData { let start_block = BasicBlockData::new_stmts(
statements, statements,
terminator: Some(Terminator { source_info, kind: TerminatorKind::Return }), Some(Terminator { source_info, kind: TerminatorKind::Return }),
is_cleanup: false, false,
}; );
let source = MirSource::from_instance(ty::InstanceKind::FnPtrAddrShim(def_id, self_ty)); let source = MirSource::from_instance(ty::InstanceKind::FnPtrAddrShim(def_id, self_ty));
new_body(source, IndexVec::from_elem_n(start_block, 1), locals, sig.inputs().len(), span) new_body(source, IndexVec::from_elem_n(start_block, 1), locals, sig.inputs().len(), span)
} }
@@ -1233,11 +1229,11 @@ fn build_construct_coroutine_by_move_shim<'tcx>(
StatementKind::Assign(Box::new((Place::return_place(), rvalue))), StatementKind::Assign(Box::new((Place::return_place(), rvalue))),
); );
let statements = vec![stmt]; let statements = vec![stmt];
let start_block = BasicBlockData { let start_block = BasicBlockData::new_stmts(
statements, statements,
terminator: Some(Terminator { source_info, kind: TerminatorKind::Return }), Some(Terminator { source_info, kind: TerminatorKind::Return }),
is_cleanup: false, false,
}; );
let source = MirSource::from_instance(ty::InstanceKind::ConstructCoroutineInClosureShim { let source = MirSource::from_instance(ty::InstanceKind::ConstructCoroutineInClosureShim {
coroutine_closure_def_id, coroutine_closure_def_id,

32
compiler/rustc_mir_transform/src/shim/async_destructor_ctor.rs
View File

@@ -88,11 +88,7 @@ pub(super) fn build_async_drop_shim<'tcx>(
let return_block = BasicBlock::new(1); let return_block = BasicBlock::new(1);
let mut blocks = IndexVec::with_capacity(2); let mut blocks = IndexVec::with_capacity(2);
let block = |blocks: &mut IndexVec<_, _>, kind| { let block = |blocks: &mut IndexVec<_, _>, kind| {
blocks.push(BasicBlockData { blocks.push(BasicBlockData::new(Some(Terminator { source_info, kind }), false))
statements: vec![],
terminator: Some(Terminator { source_info, kind }),
is_cleanup: false,
})
}; };
block( block(
&mut blocks, &mut blocks,
@@ -378,9 +374,9 @@ fn build_adrop_for_adrop_shim<'tcx>(
let pin_fn = tcx.require_lang_item(LangItem::PinNewUnchecked, span); let pin_fn = tcx.require_lang_item(LangItem::PinNewUnchecked, span);
// call Pin<FutTy>::new_unchecked(&mut impl_cor) // call Pin<FutTy>::new_unchecked(&mut impl_cor)
blocks.push(BasicBlockData { blocks.push(BasicBlockData::new_stmts(
statements, statements,
terminator: Some(Terminator { Some(Terminator {
source_info, source_info,
kind: TerminatorKind::Call { kind: TerminatorKind::Call {
func: Operand::function_handle(tcx, pin_fn, [cor_ref.into()], span), func: Operand::function_handle(tcx, pin_fn, [cor_ref.into()], span),
@@ -392,15 +388,14 @@ fn build_adrop_for_adrop_shim<'tcx>(
fn_span: span, fn_span: span,
}, },
}), }),
is_cleanup: false, false,
}); ));
// When dropping async drop coroutine, we continue its execution: // When dropping async drop coroutine, we continue its execution:
// we call impl::poll (impl_layout, ctx) // we call impl::poll (impl_layout, ctx)
let poll_fn = tcx.require_lang_item(LangItem::FuturePoll, span); let poll_fn = tcx.require_lang_item(LangItem::FuturePoll, span);
let resume_ctx = Place::from(Local::new(2)); let resume_ctx = Place::from(Local::new(2));
blocks.push(BasicBlockData { blocks.push(BasicBlockData::new(
statements: vec![], Some(Terminator {
terminator: Some(Terminator {
source_info, source_info,
kind: TerminatorKind::Call { kind: TerminatorKind::Call {
func: Operand::function_handle(tcx, poll_fn, [impl_ty.into()], span), func: Operand::function_handle(tcx, poll_fn, [impl_ty.into()], span),
@@ -416,13 +411,12 @@ fn build_adrop_for_adrop_shim<'tcx>(
fn_span: span, fn_span: span,
}, },
}), }),
is_cleanup: false, false,
}); ));
blocks.push(BasicBlockData { blocks.push(BasicBlockData::new(
statements: vec![], Some(Terminator { source_info, kind: TerminatorKind::Return }),
terminator: Some(Terminator { source_info, kind: TerminatorKind::Return }), false,
is_cleanup: false, ));
});
let source = MirSource::from_instance(instance); let source = MirSource::from_instance(instance);
let mut body = new_body(source, blocks, locals, sig.inputs().len(), span); let mut body = new_body(source, blocks, locals, sig.inputs().len(), span);