nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-22 06:44:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

Stop using MoveDataParamEnv for places that don't need a param-env

Browse Source
This commit is contained in:
Michael Goulet 2024-07-24 15:58:34 -04:00
parent 4db3d12e6f
commit f990239b34
6 changed files with 53 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
compiler/rustc_borrowck/src/lib.rs
View File

@ -45,7 +45,7 @@ use rustc_mir_dataflow::impls::{
use rustc_mir_dataflow::move_paths::{ use rustc_mir_dataflow::move_paths::{
InitIndex, InitLocation, LookupResult, MoveData, MoveOutIndex, MovePathIndex, InitIndex, InitLocation, LookupResult, MoveData, MoveOutIndex, MovePathIndex,
}; };
use rustc_mir_dataflow::{Analysis, MoveDataParamEnv}; use rustc_mir_dataflow::Analysis;
use rustc_session::lint::builtin::UNUSED_MUT; use rustc_session::lint::builtin::UNUSED_MUT;
use rustc_span::{Span, Symbol}; use rustc_span::{Span, Symbol};
use rustc_target::abi::FieldIdx; use rustc_target::abi::FieldIdx;
@ -194,9 +194,7 @@ fn do_mir_borrowck<'tcx>(
.iter_enumerated() .iter_enumerated()
.map(|(idx, body)| (idx, MoveData::gather_moves(body, tcx, param_env, |_| true))); .map(|(idx, body)| (idx, MoveData::gather_moves(body, tcx, param_env, |_| true)));
let mdpe = MoveDataParamEnv { move_data, param_env }; let mut flow_inits = MaybeInitializedPlaces::new(tcx, body, &move_data)
let mut flow_inits = MaybeInitializedPlaces::new(tcx, body, &mdpe)
.into_engine(tcx, body) .into_engine(tcx, body)
.pass_name("borrowck") .pass_name("borrowck")
.iterate_to_fixpoint() .iterate_to_fixpoint()
@ -204,7 +202,7 @@ fn do_mir_borrowck<'tcx>(
let locals_are_invalidated_at_exit = tcx.hir().body_owner_kind(def).is_fn_or_closure(); let locals_are_invalidated_at_exit = tcx.hir().body_owner_kind(def).is_fn_or_closure();
let borrow_set = let borrow_set =
Rc::new(BorrowSet::build(tcx, body, locals_are_invalidated_at_exit, &mdpe.move_data)); Rc::new(BorrowSet::build(tcx, body, locals_are_invalidated_at_exit, &move_data));
// Compute non-lexical lifetimes. // Compute non-lexical lifetimes.
let nll::NllOutput { let nll::NllOutput {
@ -222,7 +220,7 @@ fn do_mir_borrowck<'tcx>(
&location_table, &location_table,
param_env, param_env,
&mut flow_inits, &mut flow_inits,
&mdpe.move_data, &move_data,
&borrow_set, &borrow_set,
tcx.closure_captures(def), tcx.closure_captures(def),
consumer_options, consumer_options,
@ -254,11 +252,11 @@ fn do_mir_borrowck<'tcx>(
.into_engine(tcx, body) .into_engine(tcx, body)
.pass_name("borrowck") .pass_name("borrowck")
.iterate_to_fixpoint(); .iterate_to_fixpoint();
let flow_uninits = MaybeUninitializedPlaces::new(tcx, body, &mdpe) let flow_uninits = MaybeUninitializedPlaces::new(tcx, body, &move_data)
.into_engine(tcx, body) .into_engine(tcx, body)
.pass_name("borrowck") .pass_name("borrowck")
.iterate_to_fixpoint(); .iterate_to_fixpoint();
let flow_ever_inits = EverInitializedPlaces::new(body, &mdpe) let flow_ever_inits = EverInitializedPlaces::new(body, &move_data)
.into_engine(tcx, body) .into_engine(tcx, body)
.pass_name("borrowck") .pass_name("borrowck")
.iterate_to_fixpoint(); .iterate_to_fixpoint();
@ -324,7 +322,7 @@ fn do_mir_borrowck<'tcx>(
infcx: &infcx, infcx: &infcx,
param_env, param_env,
body, body,
move_data: &mdpe.move_data, move_data: &move_data,
location_table: &location_table, location_table: &location_table,
movable_coroutine, movable_coroutine,
locals_are_invalidated_at_exit, locals_are_invalidated_at_exit,

7
compiler/rustc_mir_dataflow/src/drop_flag_effects.rs
View File

@ -3,7 +3,6 @@ use rustc_target::abi::VariantIdx;
use tracing::debug; use tracing::debug;
use super::move_paths::{InitKind, LookupResult, MoveData, MovePathIndex}; use super::move_paths::{InitKind, LookupResult, MoveData, MovePathIndex};
use super::MoveDataParamEnv;
use crate::elaborate_drops::DropFlagState; use crate::elaborate_drops::DropFlagState;
pub fn move_path_children_matching<'tcx, F>( pub fn move_path_children_matching<'tcx, F>(
@ -70,12 +69,11 @@ pub fn on_all_children_bits<'tcx, F>(
pub fn drop_flag_effects_for_function_entry<'tcx, F>( pub fn drop_flag_effects_for_function_entry<'tcx, F>(
body: &Body<'tcx>, body: &Body<'tcx>,
ctxt: &MoveDataParamEnv<'tcx>, move_data: &MoveData<'tcx>,
mut callback: F, mut callback: F,
) where ) where
F: FnMut(MovePathIndex, DropFlagState), F: FnMut(MovePathIndex, DropFlagState),
{ {
let move_data = &ctxt.move_data;
for arg in body.args_iter() { for arg in body.args_iter() {
let place = mir::Place::from(arg); let place = mir::Place::from(arg);
let lookup_result = move_data.rev_lookup.find(place.as_ref()); let lookup_result = move_data.rev_lookup.find(place.as_ref());
@ -87,13 +85,12 @@ pub fn drop_flag_effects_for_function_entry<'tcx, F>(
pub fn drop_flag_effects_for_location<'tcx, F>( pub fn drop_flag_effects_for_location<'tcx, F>(
body: &Body<'tcx>, body: &Body<'tcx>,
ctxt: &MoveDataParamEnv<'tcx>, move_data: &MoveData<'tcx>,
loc: Location, loc: Location,
mut callback: F, mut callback: F,
) where ) where
F: FnMut(MovePathIndex, DropFlagState), F: FnMut(MovePathIndex, DropFlagState),
{ {
let move_data = &ctxt.move_data;
debug!("drop_flag_effects_for_location({:?})", loc); debug!("drop_flag_effects_for_location({:?})", loc);
// first, move out of the RHS // first, move out of the RHS

60
compiler/rustc_mir_dataflow/src/impls/initialized.rs
View File

@ -11,7 +11,7 @@ use crate::move_paths::{HasMoveData, InitIndex, InitKind, LookupResult, MoveData
use crate::{ use crate::{
drop_flag_effects, drop_flag_effects_for_function_entry, drop_flag_effects_for_location, drop_flag_effects, drop_flag_effects_for_function_entry, drop_flag_effects_for_location,
lattice, on_all_children_bits, on_lookup_result_bits, AnalysisDomain, GenKill, GenKillAnalysis, lattice, on_all_children_bits, on_lookup_result_bits, AnalysisDomain, GenKill, GenKillAnalysis,
MaybeReachable, MoveDataParamEnv, MaybeReachable,
}; };
/// `MaybeInitializedPlaces` tracks all places that might be /// `MaybeInitializedPlaces` tracks all places that might be
@ -52,17 +52,13 @@ use crate::{
pub struct MaybeInitializedPlaces<'a, 'mir, 'tcx> { pub struct MaybeInitializedPlaces<'a, 'mir, 'tcx> {
tcx: TyCtxt<'tcx>, tcx: TyCtxt<'tcx>,
body: &'mir Body<'tcx>, body: &'mir Body<'tcx>,
mdpe: &'a MoveDataParamEnv<'tcx>, move_data: &'a MoveData<'tcx>,
skip_unreachable_unwind: bool, skip_unreachable_unwind: bool,
} }
impl<'a, 'mir, 'tcx> MaybeInitializedPlaces<'a, 'mir, 'tcx> { impl<'a, 'mir, 'tcx> MaybeInitializedPlaces<'a, 'mir, 'tcx> {
pub fn new( pub fn new(tcx: TyCtxt<'tcx>, body: &'mir Body<'tcx>, move_data: &'a MoveData<'tcx>) -> Self {
tcx: TyCtxt<'tcx>, MaybeInitializedPlaces { tcx, body, move_data, skip_unreachable_unwind: false }
body: &'mir Body<'tcx>,
mdpe: &'a MoveDataParamEnv<'tcx>,
) -> Self {
MaybeInitializedPlaces { tcx, body, mdpe, skip_unreachable_unwind: false }
} }
pub fn skipping_unreachable_unwind(mut self) -> Self { pub fn skipping_unreachable_unwind(mut self) -> Self {
@ -89,7 +85,7 @@ impl<'a, 'mir, 'tcx> MaybeInitializedPlaces<'a, 'mir, 'tcx> {
impl<'a, 'mir, 'tcx> HasMoveData<'tcx> for MaybeInitializedPlaces<'a, 'mir, 'tcx> { impl<'a, 'mir, 'tcx> HasMoveData<'tcx> for MaybeInitializedPlaces<'a, 'mir, 'tcx> {
fn move_data(&self) -> &MoveData<'tcx> { fn move_data(&self) -> &MoveData<'tcx> {
&self.mdpe.move_data self.move_data
} }
} }
@ -131,22 +127,18 @@ impl<'a, 'mir, 'tcx> HasMoveData<'tcx> for MaybeInitializedPlaces<'a, 'mir, 'tcx
pub struct MaybeUninitializedPlaces<'a, 'mir, 'tcx> { pub struct MaybeUninitializedPlaces<'a, 'mir, 'tcx> {
tcx: TyCtxt<'tcx>, tcx: TyCtxt<'tcx>,
body: &'mir Body<'tcx>, body: &'mir Body<'tcx>,
mdpe: &'a MoveDataParamEnv<'tcx>, move_data: &'a MoveData<'tcx>,
mark_inactive_variants_as_uninit: bool, mark_inactive_variants_as_uninit: bool,
skip_unreachable_unwind: BitSet<mir::BasicBlock>, skip_unreachable_unwind: BitSet<mir::BasicBlock>,
} }
impl<'a, 'mir, 'tcx> MaybeUninitializedPlaces<'a, 'mir, 'tcx> { impl<'a, 'mir, 'tcx> MaybeUninitializedPlaces<'a, 'mir, 'tcx> {
pub fn new( pub fn new(tcx: TyCtxt<'tcx>, body: &'mir Body<'tcx>, move_data: &'a MoveData<'tcx>) -> Self {
tcx: TyCtxt<'tcx>,
body: &'mir Body<'tcx>,
mdpe: &'a MoveDataParamEnv<'tcx>,
) -> Self {
MaybeUninitializedPlaces { MaybeUninitializedPlaces {
tcx, tcx,
body, body,
mdpe, move_data,
mark_inactive_variants_as_uninit: false, mark_inactive_variants_as_uninit: false,
skip_unreachable_unwind: BitSet::new_empty(body.basic_blocks.len()), skip_unreachable_unwind: BitSet::new_empty(body.basic_blocks.len()),
} }
@ -173,7 +165,7 @@ impl<'a, 'mir, 'tcx> MaybeUninitializedPlaces<'a, 'mir, 'tcx> {
impl<'a, 'tcx> HasMoveData<'tcx> for MaybeUninitializedPlaces<'a, '_, 'tcx> { impl<'a, 'tcx> HasMoveData<'tcx> for MaybeUninitializedPlaces<'a, '_, 'tcx> {
fn move_data(&self) -> &MoveData<'tcx> { fn move_data(&self) -> &MoveData<'tcx> {
&self.mdpe.move_data self.move_data
} }
} }
@ -213,18 +205,18 @@ impl<'a, 'tcx> HasMoveData<'tcx> for MaybeUninitializedPlaces<'a, '_, 'tcx> {
/// that would require a dynamic drop-flag at that statement. /// that would require a dynamic drop-flag at that statement.
pub struct DefinitelyInitializedPlaces<'a, 'tcx> { pub struct DefinitelyInitializedPlaces<'a, 'tcx> {
body: &'a Body<'tcx>, body: &'a Body<'tcx>,
mdpe: &'a MoveDataParamEnv<'tcx>, move_data: &'a MoveData<'tcx>,
} }
impl<'a, 'tcx> DefinitelyInitializedPlaces<'a, 'tcx> { impl<'a, 'tcx> DefinitelyInitializedPlaces<'a, 'tcx> {
pub fn new(body: &'a Body<'tcx>, mdpe: &'a MoveDataParamEnv<'tcx>) -> Self { pub fn new(body: &'a Body<'tcx>, move_data: &'a MoveData<'tcx>) -> Self {
DefinitelyInitializedPlaces { body, mdpe } DefinitelyInitializedPlaces { body, move_data }
} }
} }
impl<'a, 'tcx> HasMoveData<'tcx> for DefinitelyInitializedPlaces<'a, 'tcx> { impl<'a, 'tcx> HasMoveData<'tcx> for DefinitelyInitializedPlaces<'a, 'tcx> {
fn move_data(&self) -> &MoveData<'tcx> { fn move_data(&self) -> &MoveData<'tcx> {
&self.mdpe.move_data self.move_data
} }
} }
@ -259,18 +251,18 @@ impl<'a, 'tcx> HasMoveData<'tcx> for DefinitelyInitializedPlaces<'a, 'tcx> {
/// ``` /// ```
pub struct EverInitializedPlaces<'a, 'mir, 'tcx> { pub struct EverInitializedPlaces<'a, 'mir, 'tcx> {
body: &'mir Body<'tcx>, body: &'mir Body<'tcx>,
mdpe: &'a MoveDataParamEnv<'tcx>, move_data: &'a MoveData<'tcx>,
} }
impl<'a, 'mir, 'tcx> EverInitializedPlaces<'a, 'mir, 'tcx> { impl<'a, 'mir, 'tcx> EverInitializedPlaces<'a, 'mir, 'tcx> {
pub fn new(body: &'mir Body<'tcx>, mdpe: &'a MoveDataParamEnv<'tcx>) -> Self { pub fn new(body: &'mir Body<'tcx>, move_data: &'a MoveData<'tcx>) -> Self {
EverInitializedPlaces { body, mdpe } EverInitializedPlaces { body, move_data }
} }
} }
impl<'a, 'tcx> HasMoveData<'tcx> for EverInitializedPlaces<'a, '_, 'tcx> { impl<'a, 'tcx> HasMoveData<'tcx> for EverInitializedPlaces<'a, '_, 'tcx> {
fn move_data(&self) -> &MoveData<'tcx> { fn move_data(&self) -> &MoveData<'tcx> {
&self.mdpe.move_data self.move_data
} }
} }
@ -328,7 +320,7 @@ impl<'tcx> AnalysisDomain<'tcx> for MaybeInitializedPlaces<'_, '_, 'tcx> {
fn initialize_start_block(&self, _: &mir::Body<'tcx>, state: &mut Self::Domain) { fn initialize_start_block(&self, _: &mir::Body<'tcx>, state: &mut Self::Domain) {
*state = *state =
MaybeReachable::Reachable(ChunkedBitSet::new_empty(self.move_data().move_paths.len())); MaybeReachable::Reachable(ChunkedBitSet::new_empty(self.move_data().move_paths.len()));
drop_flag_effects_for_function_entry(self.body, self.mdpe, |path, s| { drop_flag_effects_for_function_entry(self.body, self.move_data, |path, s| {
assert!(s == DropFlagState::Present); assert!(s == DropFlagState::Present);
state.gen_(path); state.gen_(path);
}); });
@ -348,7 +340,7 @@ impl<'tcx> GenKillAnalysis<'tcx> for MaybeInitializedPlaces<'_, '_, 'tcx> {
statement: &mir::Statement<'tcx>, statement: &mir::Statement<'tcx>,
location: Location, location: Location,
) { ) {
drop_flag_effects_for_location(self.body, self.mdpe, location, |path, s| { drop_flag_effects_for_location(self.body, self.move_data, location, |path, s| {
Self::update_bits(trans, path, s) Self::update_bits(trans, path, s)
}); });
@ -380,7 +372,7 @@ impl<'tcx> GenKillAnalysis<'tcx> for MaybeInitializedPlaces<'_, '_, 'tcx> {
{ {
edges = TerminatorEdges::Single(target); edges = TerminatorEdges::Single(target);
} }
drop_flag_effects_for_location(self.body, self.mdpe, location, |path, s| { drop_flag_effects_for_location(self.body, self.move_data, location, |path, s| {
Self::update_bits(state, path, s) Self::update_bits(state, path, s)
}); });
edges edges
@ -465,7 +457,7 @@ impl<'tcx> AnalysisDomain<'tcx> for MaybeUninitializedPlaces<'_, '_, 'tcx> {
// set all bits to 1 (uninit) before gathering counter-evidence // set all bits to 1 (uninit) before gathering counter-evidence
state.insert_all(); state.insert_all();
drop_flag_effects_for_function_entry(self.body, self.mdpe, |path, s| { drop_flag_effects_for_function_entry(self.body, self.move_data, |path, s| {
assert!(s == DropFlagState::Present); assert!(s == DropFlagState::Present);
state.remove(path); state.remove(path);
}); });
@ -485,7 +477,7 @@ impl<'tcx> GenKillAnalysis<'tcx> for MaybeUninitializedPlaces<'_, '_, 'tcx> {
_statement: &mir::Statement<'tcx>, _statement: &mir::Statement<'tcx>,
location: Location, location: Location,
) { ) {
drop_flag_effects_for_location(self.body, self.mdpe, location, |path, s| { drop_flag_effects_for_location(self.body, self.move_data, location, |path, s| {
Self::update_bits(trans, path, s) Self::update_bits(trans, path, s)
}); });
@ -499,7 +491,7 @@ impl<'tcx> GenKillAnalysis<'tcx> for MaybeUninitializedPlaces<'_, '_, 'tcx> {
terminator: &'mir mir::Terminator<'tcx>, terminator: &'mir mir::Terminator<'tcx>,
location: Location, location: Location,
) -> TerminatorEdges<'mir, 'tcx> { ) -> TerminatorEdges<'mir, 'tcx> {
drop_flag_effects_for_location(self.body, self.mdpe, location, |path, s| { drop_flag_effects_for_location(self.body, self.move_data, location, |path, s| {
Self::update_bits(trans, path, s) Self::update_bits(trans, path, s)
}); });
if self.skip_unreachable_unwind.contains(location.block) { if self.skip_unreachable_unwind.contains(location.block) {
@ -592,7 +584,7 @@ impl<'a, 'tcx> AnalysisDomain<'tcx> for DefinitelyInitializedPlaces<'a, 'tcx> {
fn initialize_start_block(&self, _: &mir::Body<'tcx>, state: &mut Self::Domain) { fn initialize_start_block(&self, _: &mir::Body<'tcx>, state: &mut Self::Domain) {
state.0.clear(); state.0.clear();
drop_flag_effects_for_function_entry(self.body, self.mdpe, |path, s| { drop_flag_effects_for_function_entry(self.body, self.move_data, |path, s| {
assert!(s == DropFlagState::Present); assert!(s == DropFlagState::Present);
state.0.insert(path); state.0.insert(path);
}); });
@ -612,7 +604,7 @@ impl<'tcx> GenKillAnalysis<'tcx> for DefinitelyInitializedPlaces<'_, 'tcx> {
_statement: &mir::Statement<'tcx>, _statement: &mir::Statement<'tcx>,
location: Location, location: Location,
) { ) {
drop_flag_effects_for_location(self.body, self.mdpe, location, |path, s| { drop_flag_effects_for_location(self.body, self.move_data, location, |path, s| {
Self::update_bits(trans, path, s) Self::update_bits(trans, path, s)
}) })
} }
@ -623,7 +615,7 @@ impl<'tcx> GenKillAnalysis<'tcx> for DefinitelyInitializedPlaces<'_, 'tcx> {
terminator: &'mir mir::Terminator<'tcx>, terminator: &'mir mir::Terminator<'tcx>,
location: Location, location: Location,
) -> TerminatorEdges<'mir, 'tcx> { ) -> TerminatorEdges<'mir, 'tcx> {
drop_flag_effects_for_location(self.body, self.mdpe, location, |path, s| { drop_flag_effects_for_location(self.body, self.move_data, location, |path, s| {
Self::update_bits(trans, path, s) Self::update_bits(trans, path, s)
}); });
terminator.edges() terminator.edges()

9
compiler/rustc_mir_dataflow/src/rustc_peek.rs
View File

@ -16,7 +16,7 @@ use crate::impls::{
DefinitelyInitializedPlaces, MaybeInitializedPlaces, MaybeLiveLocals, MaybeUninitializedPlaces, DefinitelyInitializedPlaces, MaybeInitializedPlaces, MaybeLiveLocals, MaybeUninitializedPlaces,
}; };
use crate::move_paths::{HasMoveData, LookupResult, MoveData, MovePathIndex}; use crate::move_paths::{HasMoveData, LookupResult, MoveData, MovePathIndex};
use crate::{Analysis, JoinSemiLattice, MoveDataParamEnv, ResultsCursor}; use crate::{Analysis, JoinSemiLattice, ResultsCursor};
pub struct SanityCheck; pub struct SanityCheck;
@ -46,10 +46,9 @@ impl<'tcx> MirPass<'tcx> for SanityCheck {
let param_env = tcx.param_env(def_id); let param_env = tcx.param_env(def_id);
let move_data = MoveData::gather_moves(body, tcx, param_env, |_| true); let move_data = MoveData::gather_moves(body, tcx, param_env, |_| true);
let mdpe = MoveDataParamEnv { move_data, param_env };
if has_rustc_mir_with(tcx, def_id, sym::rustc_peek_maybe_init).is_some() { if has_rustc_mir_with(tcx, def_id, sym::rustc_peek_maybe_init).is_some() {
let flow_inits = MaybeInitializedPlaces::new(tcx, body, &mdpe) let flow_inits = MaybeInitializedPlaces::new(tcx, body, &move_data)
.into_engine(tcx, body) .into_engine(tcx, body)
.iterate_to_fixpoint(); .iterate_to_fixpoint();
@ -57,7 +56,7 @@ impl<'tcx> MirPass<'tcx> for SanityCheck {
} }
if has_rustc_mir_with(tcx, def_id, sym::rustc_peek_maybe_uninit).is_some() { if has_rustc_mir_with(tcx, def_id, sym::rustc_peek_maybe_uninit).is_some() {
let flow_uninits = MaybeUninitializedPlaces::new(tcx, body, &mdpe) let flow_uninits = MaybeUninitializedPlaces::new(tcx, body, &move_data)
.into_engine(tcx, body) .into_engine(tcx, body)
.iterate_to_fixpoint(); .iterate_to_fixpoint();
@ -65,7 +64,7 @@ impl<'tcx> MirPass<'tcx> for SanityCheck {
} }
if has_rustc_mir_with(tcx, def_id, sym::rustc_peek_definite_init).is_some() { if has_rustc_mir_with(tcx, def_id, sym::rustc_peek_definite_init).is_some() {
let flow_def_inits = DefinitelyInitializedPlaces::new(body, &mdpe) let flow_def_inits = DefinitelyInitializedPlaces::new(body, &move_data)
.into_engine(tcx, body) .into_engine(tcx, body)
.iterate_to_fixpoint(); .iterate_to_fixpoint();

16
compiler/rustc_mir_transform/src/elaborate_drops.rs
View File

@ -62,7 +62,7 @@ impl<'tcx> MirPass<'tcx> for ElaborateDrops {
let elaborate_patch = { let elaborate_patch = {
let env = MoveDataParamEnv { move_data, param_env }; let env = MoveDataParamEnv { move_data, param_env };
let mut inits = MaybeInitializedPlaces::new(tcx, body, &env) let mut inits = MaybeInitializedPlaces::new(tcx, body, &env.move_data)
.skipping_unreachable_unwind() .skipping_unreachable_unwind()
.into_engine(tcx, body) .into_engine(tcx, body)
.pass_name("elaborate_drops") .pass_name("elaborate_drops")
@ -70,7 +70,7 @@ impl<'tcx> MirPass<'tcx> for ElaborateDrops {
.into_results_cursor(body); .into_results_cursor(body);
let dead_unwinds = compute_dead_unwinds(body, &mut inits); let dead_unwinds = compute_dead_unwinds(body, &mut inits);
let uninits = MaybeUninitializedPlaces::new(tcx, body, &env) let uninits = MaybeUninitializedPlaces::new(tcx, body, &env.move_data)
.mark_inactive_variants_as_uninit() .mark_inactive_variants_as_uninit()
.skipping_unreachable_unwind(dead_unwinds) .skipping_unreachable_unwind(dead_unwinds)
.into_engine(tcx, body) .into_engine(tcx, body)
@ -443,9 +443,13 @@ impl<'b, 'mir, 'tcx> ElaborateDropsCtxt<'b, 'mir, 'tcx> {
fn drop_flags_for_args(&mut self) { fn drop_flags_for_args(&mut self) {
let loc = Location::START; let loc = Location::START;
rustc_mir_dataflow::drop_flag_effects_for_function_entry(self.body, self.env, |path, ds| { rustc_mir_dataflow::drop_flag_effects_for_function_entry(
self.set_drop_flag(loc, path, ds); self.body,
}) &self.env.move_data,
|path, ds| {
self.set_drop_flag(loc, path, ds);
},
)
} }
fn drop_flags_for_locs(&mut self) { fn drop_flags_for_locs(&mut self) {
@ -478,7 +482,7 @@ impl<'b, 'mir, 'tcx> ElaborateDropsCtxt<'b, 'mir, 'tcx> {
let loc = Location { block: bb, statement_index: i }; let loc = Location { block: bb, statement_index: i };
rustc_mir_dataflow::drop_flag_effects_for_location( rustc_mir_dataflow::drop_flag_effects_for_location(
self.body, self.body,
self.env, &self.env.move_data,
loc, loc,
|path, ds| self.set_drop_flag(loc, path, ds), |path, ds| self.set_drop_flag(loc, path, ds),
) )

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

@ -3,7 +3,7 @@ use rustc_middle::mir::{Body, TerminatorKind};
use rustc_middle::ty::{self, GenericArgsRef, ParamEnv, Ty, TyCtxt, VariantDef}; use rustc_middle::ty::{self, GenericArgsRef, ParamEnv, Ty, TyCtxt, VariantDef};
use rustc_mir_dataflow::impls::MaybeInitializedPlaces; use rustc_mir_dataflow::impls::MaybeInitializedPlaces;
use rustc_mir_dataflow::move_paths::{LookupResult, MoveData, MovePathIndex}; use rustc_mir_dataflow::move_paths::{LookupResult, MoveData, MovePathIndex};
use rustc_mir_dataflow::{move_path_children_matching, Analysis, MaybeReachable, MoveDataParamEnv}; use rustc_mir_dataflow::{move_path_children_matching, Analysis, MaybeReachable};
use rustc_target::abi::FieldIdx; use rustc_target::abi::FieldIdx;
use crate::MirPass; use crate::MirPass;
@ -24,8 +24,7 @@ impl<'tcx> MirPass<'tcx> for RemoveUninitDrops {
let move_data = let move_data =
MoveData::gather_moves(body, tcx, param_env, |ty| ty.needs_drop(tcx, param_env)); MoveData::gather_moves(body, tcx, param_env, |ty| ty.needs_drop(tcx, param_env));
let mdpe = MoveDataParamEnv { move_data, param_env }; let mut maybe_inits = MaybeInitializedPlaces::new(tcx, body, &move_data)
let mut maybe_inits = MaybeInitializedPlaces::new(tcx, body, &mdpe)
.into_engine(tcx, body) .into_engine(tcx, body)
.pass_name("remove_uninit_drops") .pass_name("remove_uninit_drops")
.iterate_to_fixpoint() .iterate_to_fixpoint()
@ -40,7 +39,7 @@ impl<'tcx> MirPass<'tcx> for RemoveUninitDrops {
let MaybeReachable::Reachable(maybe_inits) = maybe_inits.get() else { continue }; let MaybeReachable::Reachable(maybe_inits) = maybe_inits.get() else { continue };
// If there's no move path for the dropped place, it's probably a `Deref`. Let it alone. // If there's no move path for the dropped place, it's probably a `Deref`. Let it alone.
let LookupResult::Exact(mpi) = mdpe.move_data.rev_lookup.find(place.as_ref()) else { let LookupResult::Exact(mpi) = move_data.rev_lookup.find(place.as_ref()) else {
continue; continue;
}; };
@ -48,7 +47,7 @@ impl<'tcx> MirPass<'tcx> for RemoveUninitDrops {
tcx, tcx,
param_env, param_env,
maybe_inits, maybe_inits,
&mdpe.move_data, &move_data,
place.ty(body, tcx).ty, place.ty(body, tcx).ty,
mpi, mpi,
); );