2016-08-15 20:59:50 -05:00
|
|
|
//! A number of passes which remove various redundancies in the CFG.
|
2016-06-06 14:58:28 -05:00
|
|
|
//!
|
2016-08-15 20:59:50 -05:00
|
|
|
//! The `SimplifyCfg` pass gets rid of unnecessary blocks in the CFG, whereas the `SimplifyLocals`
|
|
|
|
//! gets rid of all the unnecessary local variable declarations.
|
2016-06-06 14:58:28 -05:00
|
|
|
//!
|
2016-08-15 20:59:50 -05:00
|
|
|
//! The `SimplifyLocals` pass is kinda expensive and therefore not very suitable to be run often.
|
|
|
|
//! Most of the passes should not care or be impacted in meaningful ways due to extra locals
|
2018-05-08 08:10:16 -05:00
|
|
|
//! either, so running the pass once, right before codegen, should suffice.
|
2016-08-15 20:59:50 -05:00
|
|
|
//!
|
|
|
|
//! On the other side of the spectrum, the `SimplifyCfg` pass is considerably cheap to run, thus
|
|
|
|
//! one should run it after every pass which may modify CFG in significant ways. This pass must
|
|
|
|
//! also be run before any analysis passes because it removes dead blocks, and some of these can be
|
|
|
|
//! ill-typed.
|
|
|
|
//!
|
|
|
|
//! The cause of this typing issue is typeck allowing most blocks whose end is not reachable have
|
|
|
|
//! an arbitrary return type, rather than having the usual () return type (as a note, typeck's
|
|
|
|
//! notion of reachability is in fact slightly weaker than MIR CFG reachability - see #31617). A
|
|
|
|
//! standard example of the situation is:
|
2016-06-06 14:58:28 -05:00
|
|
|
//!
|
|
|
|
//! ```rust
|
|
|
|
//! fn example() {
|
|
|
|
//! let _a: char = { return; };
|
|
|
|
//! }
|
|
|
|
//! ```
|
|
|
|
//!
|
2016-08-15 20:59:50 -05:00
|
|
|
//! Here the block (`{ return; }`) has the return type `char`, rather than `()`, but the MIR we
|
|
|
|
//! naively generate still contains the `_a = ()` write in the unreachable block "after" the
|
|
|
|
//! return.
|
2016-06-06 14:58:28 -05:00
|
|
|
|
2020-12-31 18:53:25 -06:00
|
|
|
use crate::MirPass;
|
2022-07-21 10:51:40 -05:00
|
|
|
use rustc_data_structures::fx::FxHashSet;
|
2020-03-29 10:19:48 -05:00
|
|
|
use rustc_index::vec::{Idx, IndexVec};
|
2021-05-01 16:56:48 -05:00
|
|
|
use rustc_middle::mir::coverage::*;
|
2020-03-29 09:41:09 -05:00
|
|
|
use rustc_middle::mir::visit::{MutVisitor, MutatingUseContext, PlaceContext, Visitor};
|
|
|
|
use rustc_middle::mir::*;
|
2020-04-17 16:31:21 -05:00
|
|
|
use rustc_middle::ty::TyCtxt;
|
2020-07-31 11:40:25 -05:00
|
|
|
use smallvec::SmallVec;
|
2021-03-15 19:18:03 -05:00
|
|
|
use std::borrow::Cow;
|
|
|
|
use std::convert::TryInto;
|
2016-02-26 10:05:50 -06:00
|
|
|
|
2017-04-25 17:23:33 -05:00
|
|
|
pub struct SimplifyCfg {
|
|
|
|
label: String,
|
|
|
|
}
|
2015-11-10 14:38:36 -06:00
|
|
|
|
2017-04-25 17:23:33 -05:00
|
|
|
impl SimplifyCfg {
|
|
|
|
pub fn new(label: &str) -> Self {
|
|
|
|
SimplifyCfg { label: format!("SimplifyCfg-{}", label) }
|
2015-11-10 14:38:36 -06:00
|
|
|
}
|
2015-11-14 16:52:17 -06:00
|
|
|
}
|
|
|
|
|
2021-12-06 02:48:37 -06:00
|
|
|
pub fn simplify_cfg<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
|
2019-11-06 11:00:46 -06:00
|
|
|
CfgSimplifier::new(body).simplify();
|
2021-05-01 16:56:48 -05:00
|
|
|
remove_dead_blocks(tcx, body);
|
2017-03-09 12:36:01 -06:00
|
|
|
|
|
|
|
// FIXME: Should probably be moved into some kind of pass manager
|
2019-11-06 11:00:46 -06:00
|
|
|
body.basic_blocks_mut().raw.shrink_to_fit();
|
2017-03-09 12:36:01 -06:00
|
|
|
}
|
|
|
|
|
2019-08-04 15:20:00 -05:00
|
|
|
impl<'tcx> MirPass<'tcx> for SimplifyCfg {
|
2019-06-21 11:12:39 -05:00
|
|
|
fn name(&self) -> Cow<'_, str> {
|
2017-04-25 17:23:33 -05:00
|
|
|
Cow::Borrowed(&self.label)
|
2015-11-14 16:52:17 -06:00
|
|
|
}
|
|
|
|
|
2021-05-01 16:56:48 -05:00
|
|
|
fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
|
2021-01-16 18:00:00 -06:00
|
|
|
debug!("SimplifyCfg({:?}) - simplifying {:?}", self.label, body.source);
|
2021-05-01 16:56:48 -05:00
|
|
|
simplify_cfg(tcx, body);
|
2016-06-08 13:03:06 -05:00
|
|
|
}
|
|
|
|
}
|
2015-11-14 16:52:17 -06:00
|
|
|
|
2019-06-14 11:39:39 -05:00
|
|
|
pub struct CfgSimplifier<'a, 'tcx> {
|
2019-10-03 23:55:28 -05:00
|
|
|
basic_blocks: &'a mut IndexVec<BasicBlock, BasicBlockData<'tcx>>,
|
2016-06-08 16:10:15 -05:00
|
|
|
pred_count: IndexVec<BasicBlock, u32>,
|
|
|
|
}
|
2015-11-10 14:38:36 -06:00
|
|
|
|
2019-06-14 11:39:39 -05:00
|
|
|
impl<'a, 'tcx> CfgSimplifier<'a, 'tcx> {
|
2020-04-12 12:31:00 -05:00
|
|
|
pub fn new(body: &'a mut Body<'tcx>) -> Self {
|
2019-11-06 11:00:46 -06:00
|
|
|
let mut pred_count = IndexVec::from_elem(0u32, body.basic_blocks());
|
2015-11-14 16:52:17 -06:00
|
|
|
|
2016-06-08 16:10:15 -05:00
|
|
|
// we can't use mir.predecessors() here because that counts
|
|
|
|
// dead blocks, which we don't want to.
|
2016-10-04 08:23:01 -05:00
|
|
|
pred_count[START_BLOCK] = 1;
|
|
|
|
|
2019-11-06 11:00:46 -06:00
|
|
|
for (_, data) in traversal::preorder(body) {
|
2019-10-03 23:55:28 -05:00
|
|
|
if let Some(ref term) = data.terminator {
|
2022-05-16 19:41:01 -05:00
|
|
|
for tgt in term.successors() {
|
2016-06-08 16:10:15 -05:00
|
|
|
pred_count[tgt] += 1;
|
2015-11-14 16:52:17 -06:00
|
|
|
}
|
|
|
|
}
|
2015-11-10 14:38:36 -06:00
|
|
|
}
|
|
|
|
|
2019-11-06 11:00:46 -06:00
|
|
|
let basic_blocks = body.basic_blocks_mut();
|
2019-10-03 23:55:28 -05:00
|
|
|
|
2016-06-08 16:10:15 -05:00
|
|
|
CfgSimplifier { basic_blocks, pred_count }
|
2015-11-14 16:52:17 -06:00
|
|
|
}
|
|
|
|
|
2017-02-08 03:24:49 -06:00
|
|
|
pub fn simplify(mut self) {
|
2017-07-31 16:10:46 -05:00
|
|
|
self.strip_nops();
|
|
|
|
|
2020-02-16 16:23:44 -06:00
|
|
|
// Vec of the blocks that should be merged. We store the indices here, instead of the
|
|
|
|
// statements itself to avoid moving the (relatively) large statements twice.
|
|
|
|
// We do not push the statements directly into the target block (`bb`) as that is slower
|
|
|
|
// due to additional reallocations
|
2020-02-13 04:44:12 -06:00
|
|
|
let mut merged_blocks = Vec::new();
|
2016-06-08 16:10:15 -05:00
|
|
|
loop {
|
|
|
|
let mut changed = false;
|
|
|
|
|
2019-10-03 23:55:28 -05:00
|
|
|
for bb in self.basic_blocks.indices() {
|
2016-06-08 16:10:15 -05:00
|
|
|
if self.pred_count[bb] == 0 {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
debug!("simplifying {:?}", bb);
|
|
|
|
|
2019-10-03 23:55:28 -05:00
|
|
|
let mut terminator =
|
|
|
|
self.basic_blocks[bb].terminator.take().expect("invalid terminator state");
|
2016-06-08 16:10:15 -05:00
|
|
|
|
|
|
|
for successor in terminator.successors_mut() {
|
|
|
|
self.collapse_goto_chain(successor, &mut changed);
|
2015-11-14 16:52:17 -06:00
|
|
|
}
|
2016-06-08 16:10:15 -05:00
|
|
|
|
|
|
|
let mut inner_changed = true;
|
2020-02-16 16:23:44 -06:00
|
|
|
merged_blocks.clear();
|
2016-06-08 16:10:15 -05:00
|
|
|
while inner_changed {
|
|
|
|
inner_changed = false;
|
|
|
|
inner_changed |= self.simplify_branch(&mut terminator);
|
2020-02-13 04:44:12 -06:00
|
|
|
inner_changed |= self.merge_successor(&mut merged_blocks, &mut terminator);
|
2016-06-08 16:10:15 -05:00
|
|
|
changed |= inner_changed;
|
|
|
|
}
|
2019-10-03 23:55:28 -05:00
|
|
|
|
2020-03-02 13:08:21 -06:00
|
|
|
let statements_to_merge =
|
2020-02-13 04:44:12 -06:00
|
|
|
merged_blocks.iter().map(|&i| self.basic_blocks[i].statements.len()).sum();
|
|
|
|
|
2020-03-02 13:08:21 -06:00
|
|
|
if statements_to_merge > 0 {
|
2020-02-13 04:44:12 -06:00
|
|
|
let mut statements = std::mem::take(&mut self.basic_blocks[bb].statements);
|
2020-03-02 13:08:21 -06:00
|
|
|
statements.reserve(statements_to_merge);
|
2020-02-13 04:44:12 -06:00
|
|
|
for &from in &merged_blocks {
|
|
|
|
statements.append(&mut self.basic_blocks[from].statements);
|
|
|
|
}
|
|
|
|
self.basic_blocks[bb].statements = statements;
|
|
|
|
}
|
|
|
|
|
2020-01-30 03:35:50 -06:00
|
|
|
self.basic_blocks[bb].terminator = Some(terminator);
|
2015-11-10 14:38:36 -06:00
|
|
|
}
|
2016-06-08 16:10:15 -05:00
|
|
|
|
|
|
|
if !changed {
|
|
|
|
break;
|
|
|
|
}
|
2015-11-10 14:38:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-07-31 11:40:25 -05:00
|
|
|
/// This function will return `None` if
|
|
|
|
/// * the block has statements
|
|
|
|
/// * the block has a terminator other than `goto`
|
|
|
|
/// * the block has no terminator (meaning some other part of the current optimization stole it)
|
|
|
|
fn take_terminator_if_simple_goto(&mut self, bb: BasicBlock) -> Option<Terminator<'tcx>> {
|
|
|
|
match self.basic_blocks[bb] {
|
2016-06-08 16:10:15 -05:00
|
|
|
BasicBlockData {
|
|
|
|
ref statements,
|
|
|
|
terminator:
|
|
|
|
ref mut terminator @ Some(Terminator { kind: TerminatorKind::Goto { .. }, .. }),
|
|
|
|
..
|
|
|
|
} if statements.is_empty() => terminator.take(),
|
|
|
|
// if `terminator` is None, this means we are in a loop. In that
|
|
|
|
// case, let all the loop collapse to its entry.
|
2020-07-31 11:40:25 -05:00
|
|
|
_ => None,
|
|
|
|
}
|
|
|
|
}
|
2016-06-08 16:10:15 -05:00
|
|
|
|
2020-07-31 11:40:25 -05:00
|
|
|
/// Collapse a goto chain starting from `start`
|
|
|
|
fn collapse_goto_chain(&mut self, start: &mut BasicBlock, changed: &mut bool) {
|
|
|
|
// Using `SmallVec` here, because in some logs on libcore oli-obk saw many single-element
|
|
|
|
// goto chains. We should probably benchmark different sizes.
|
|
|
|
let mut terminators: SmallVec<[_; 1]> = Default::default();
|
|
|
|
let mut current = *start;
|
|
|
|
while let Some(terminator) = self.take_terminator_if_simple_goto(current) {
|
2022-02-18 17:48:49 -06:00
|
|
|
let Terminator { kind: TerminatorKind::Goto { target }, .. } = terminator else {
|
|
|
|
unreachable!();
|
2020-07-31 11:40:25 -05:00
|
|
|
};
|
|
|
|
terminators.push((current, terminator));
|
|
|
|
current = target;
|
|
|
|
}
|
|
|
|
let last = current;
|
|
|
|
*start = last;
|
|
|
|
while let Some((current, mut terminator)) = terminators.pop() {
|
2022-02-18 17:48:49 -06:00
|
|
|
let Terminator { kind: TerminatorKind::Goto { ref mut target }, .. } = terminator else {
|
|
|
|
unreachable!();
|
2020-07-31 11:40:25 -05:00
|
|
|
};
|
2020-08-02 19:00:00 -05:00
|
|
|
*changed |= *target != last;
|
2020-07-31 11:40:25 -05:00
|
|
|
*target = last;
|
|
|
|
debug!("collapsing goto chain from {:?} to {:?}", current, target);
|
|
|
|
|
|
|
|
if self.pred_count[current] == 1 {
|
|
|
|
// This is the last reference to current, so the pred-count to
|
|
|
|
// to target is moved into the current block.
|
|
|
|
self.pred_count[current] = 0;
|
|
|
|
} else {
|
|
|
|
self.pred_count[*target] += 1;
|
|
|
|
self.pred_count[current] -= 1;
|
2016-06-08 16:10:15 -05:00
|
|
|
}
|
2020-07-31 11:40:25 -05:00
|
|
|
self.basic_blocks[current].terminator = Some(terminator);
|
2016-10-04 08:27:27 -05:00
|
|
|
}
|
2016-06-08 16:10:15 -05:00
|
|
|
}
|
2016-01-31 11:17:15 -06:00
|
|
|
|
2016-06-08 16:10:15 -05:00
|
|
|
// merge a block with 1 `goto` predecessor to its parent
|
|
|
|
fn merge_successor(
|
|
|
|
&mut self,
|
2020-02-13 04:44:12 -06:00
|
|
|
merged_blocks: &mut Vec<BasicBlock>,
|
2016-06-08 16:10:15 -05:00
|
|
|
terminator: &mut Terminator<'tcx>,
|
|
|
|
) -> bool {
|
|
|
|
let target = match terminator.kind {
|
|
|
|
TerminatorKind::Goto { target } if self.pred_count[target] == 1 => target,
|
|
|
|
_ => return false,
|
|
|
|
};
|
|
|
|
|
|
|
|
debug!("merging block {:?} into {:?}", target, terminator);
|
2019-10-03 23:55:28 -05:00
|
|
|
*terminator = match self.basic_blocks[target].terminator.take() {
|
2016-06-08 16:10:15 -05:00
|
|
|
Some(terminator) => terminator,
|
|
|
|
None => {
|
|
|
|
// unreachable loop - this should not be possible, as we
|
|
|
|
// don't strand blocks, but handle it correctly.
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
};
|
2020-01-30 03:35:50 -06:00
|
|
|
|
2020-02-13 04:44:12 -06:00
|
|
|
merged_blocks.push(target);
|
2016-06-08 16:10:15 -05:00
|
|
|
self.pred_count[target] = 0;
|
2016-01-31 11:17:15 -06:00
|
|
|
|
2016-06-08 16:10:15 -05:00
|
|
|
true
|
|
|
|
}
|
2016-05-25 00:39:32 -05:00
|
|
|
|
2016-06-08 16:10:15 -05:00
|
|
|
// turn a branch with all successors identical to a goto
|
|
|
|
fn simplify_branch(&mut self, terminator: &mut Terminator<'tcx>) -> bool {
|
|
|
|
match terminator.kind {
|
|
|
|
TerminatorKind::SwitchInt { .. } => {}
|
|
|
|
_ => return false,
|
|
|
|
};
|
|
|
|
|
|
|
|
let first_succ = {
|
2022-05-16 19:41:01 -05:00
|
|
|
if let Some(first_succ) = terminator.successors().next() {
|
|
|
|
if terminator.successors().all(|s| s == first_succ) {
|
2018-04-27 06:02:09 -05:00
|
|
|
let count = terminator.successors().count();
|
|
|
|
self.pred_count[first_succ] -= (count - 1) as u32;
|
2016-06-08 16:10:15 -05:00
|
|
|
first_succ
|
|
|
|
} else {
|
|
|
|
return false;
|
2015-11-10 14:38:36 -06:00
|
|
|
}
|
2016-06-08 16:10:15 -05:00
|
|
|
} else {
|
|
|
|
return false;
|
2015-11-10 14:38:36 -06:00
|
|
|
}
|
2016-06-08 16:10:15 -05:00
|
|
|
};
|
2015-11-10 14:38:36 -06:00
|
|
|
|
2016-06-08 16:10:15 -05:00
|
|
|
debug!("simplifying branch {:?}", terminator);
|
|
|
|
terminator.kind = TerminatorKind::Goto { target: first_succ };
|
|
|
|
true
|
2015-11-10 14:38:36 -06:00
|
|
|
}
|
2017-02-08 03:24:49 -06:00
|
|
|
|
|
|
|
fn strip_nops(&mut self) {
|
2019-10-03 23:55:28 -05:00
|
|
|
for blk in self.basic_blocks.iter_mut() {
|
2020-09-18 12:11:06 -05:00
|
|
|
blk.statements.retain(|stmt| !matches!(stmt.kind, StatementKind::Nop))
|
2017-02-08 03:24:49 -06:00
|
|
|
}
|
|
|
|
}
|
2015-11-10 14:38:36 -06:00
|
|
|
}
|
2016-06-06 14:58:28 -05:00
|
|
|
|
2021-12-06 02:48:37 -06:00
|
|
|
pub fn remove_dead_blocks<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
|
2021-01-27 18:00:00 -06:00
|
|
|
let reachable = traversal::reachable_as_bitset(body);
|
|
|
|
let num_blocks = body.basic_blocks().len();
|
|
|
|
if num_blocks == reachable.count() {
|
|
|
|
return;
|
2016-06-06 14:58:28 -05:00
|
|
|
}
|
|
|
|
|
2022-07-02 19:00:00 -05:00
|
|
|
let basic_blocks = body.basic_blocks.as_mut();
|
|
|
|
let source_scopes = &body.source_scopes;
|
2019-10-03 23:55:28 -05:00
|
|
|
let mut replacements: Vec<_> = (0..num_blocks).map(BasicBlock::new).collect();
|
|
|
|
let mut used_blocks = 0;
|
2021-01-27 18:00:00 -06:00
|
|
|
for alive_index in reachable.iter() {
|
|
|
|
let alive_index = alive_index.index();
|
2019-10-03 23:55:28 -05:00
|
|
|
replacements[alive_index] = BasicBlock::new(used_blocks);
|
|
|
|
if alive_index != used_blocks {
|
|
|
|
// Swap the next alive block data with the current available slot. Since
|
|
|
|
// alive_index is non-decreasing this is a valid operation.
|
|
|
|
basic_blocks.raw.swap(alive_index, used_blocks);
|
2016-06-06 14:58:28 -05:00
|
|
|
}
|
2019-10-03 23:55:28 -05:00
|
|
|
used_blocks += 1;
|
2016-06-06 14:58:28 -05:00
|
|
|
}
|
2021-05-01 16:56:48 -05:00
|
|
|
|
|
|
|
if tcx.sess.instrument_coverage() {
|
2022-07-02 19:00:00 -05:00
|
|
|
save_unreachable_coverage(basic_blocks, source_scopes, used_blocks);
|
2021-05-01 16:56:48 -05:00
|
|
|
}
|
|
|
|
|
2019-10-03 23:55:28 -05:00
|
|
|
basic_blocks.raw.truncate(used_blocks);
|
2016-06-06 14:58:28 -05:00
|
|
|
|
2019-10-03 23:55:28 -05:00
|
|
|
for block in basic_blocks {
|
|
|
|
for target in block.terminator_mut().successors_mut() {
|
2016-06-06 14:58:28 -05:00
|
|
|
*target = replacements[target.index()];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-08-15 20:59:50 -05:00
|
|
|
|
2021-05-01 16:56:48 -05:00
|
|
|
/// Some MIR transforms can determine at compile time that a sequences of
|
|
|
|
/// statements will never be executed, so they can be dropped from the MIR.
|
|
|
|
/// For example, an `if` or `else` block that is guaranteed to never be executed
|
|
|
|
/// because its condition can be evaluated at compile time, such as by const
|
|
|
|
/// evaluation: `if false { ... }`.
|
|
|
|
///
|
|
|
|
/// Those statements are bypassed by redirecting paths in the CFG around the
|
2021-10-21 09:04:22 -05:00
|
|
|
/// `dead blocks`; but with `-C instrument-coverage`, the dead blocks usually
|
2021-05-01 16:56:48 -05:00
|
|
|
/// include `Coverage` statements representing the Rust source code regions to
|
|
|
|
/// be counted at runtime. Without these `Coverage` statements, the regions are
|
|
|
|
/// lost, and the Rust source code will show no coverage information.
|
|
|
|
///
|
|
|
|
/// What we want to show in a coverage report is the dead code with coverage
|
|
|
|
/// counts of `0`. To do this, we need to save the code regions, by injecting
|
|
|
|
/// `Unreachable` coverage statements. These are non-executable statements whose
|
|
|
|
/// code regions are still recorded in the coverage map, representing regions
|
|
|
|
/// with `0` executions.
|
2022-07-02 19:00:00 -05:00
|
|
|
///
|
|
|
|
/// If there are no live `Counter` `Coverage` statements remaining, we remove
|
2022-07-24 19:00:00 -05:00
|
|
|
/// `Coverage` statements along with the dead blocks. Since at least one
|
2022-07-02 19:00:00 -05:00
|
|
|
/// counter per function is required by LLVM (and necessary, to add the
|
|
|
|
/// `function_hash` to the counter's call to the LLVM intrinsic
|
|
|
|
/// `instrprof.increment()`).
|
|
|
|
///
|
|
|
|
/// The `generator::StateTransform` MIR pass and MIR inlining can create
|
|
|
|
/// atypical conditions, where all live `Counter`s are dropped from the MIR.
|
|
|
|
///
|
|
|
|
/// With MIR inlining we can have coverage counters belonging to different
|
|
|
|
/// instances in a single body, so the strategy described above is applied to
|
|
|
|
/// coverage counters from each instance individually.
|
2021-05-01 16:56:48 -05:00
|
|
|
fn save_unreachable_coverage(
|
|
|
|
basic_blocks: &mut IndexVec<BasicBlock, BasicBlockData<'_>>,
|
2022-07-02 19:00:00 -05:00
|
|
|
source_scopes: &IndexVec<SourceScope, SourceScopeData<'_>>,
|
2021-05-01 16:56:48 -05:00
|
|
|
first_dead_block: usize,
|
|
|
|
) {
|
2022-07-02 19:00:00 -05:00
|
|
|
// Identify instances that still have some live coverage counters left.
|
|
|
|
let mut live = FxHashSet::default();
|
|
|
|
for basic_block in &basic_blocks.raw[0..first_dead_block] {
|
|
|
|
for statement in &basic_block.statements {
|
|
|
|
let StatementKind::Coverage(coverage) = &statement.kind else { continue };
|
|
|
|
let CoverageKind::Counter { .. } = coverage.kind else { continue };
|
|
|
|
let instance = statement.source_info.scope.inlined_instance(source_scopes);
|
|
|
|
live.insert(instance);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-07-24 19:00:00 -05:00
|
|
|
for block in &mut basic_blocks.raw[..first_dead_block] {
|
|
|
|
for statement in &mut block.statements {
|
|
|
|
let StatementKind::Coverage(_) = &statement.kind else { continue };
|
|
|
|
let instance = statement.source_info.scope.inlined_instance(source_scopes);
|
|
|
|
if !live.contains(&instance) {
|
|
|
|
statement.make_nop();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-07-02 19:00:00 -05:00
|
|
|
if live.is_empty() {
|
2021-05-01 16:56:48 -05:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2022-07-02 19:00:00 -05:00
|
|
|
// Retain coverage for instances that still have some live counters left.
|
|
|
|
let mut retained_coverage = Vec::new();
|
|
|
|
for dead_block in &basic_blocks.raw[first_dead_block..] {
|
|
|
|
for statement in &dead_block.statements {
|
|
|
|
let StatementKind::Coverage(coverage) = &statement.kind else { continue };
|
|
|
|
let Some(code_region) = &coverage.code_region else { continue };
|
|
|
|
let instance = statement.source_info.scope.inlined_instance(source_scopes);
|
|
|
|
if live.contains(&instance) {
|
|
|
|
retained_coverage.push((statement.source_info, code_region.clone()));
|
2021-05-01 16:56:48 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
let start_block = &mut basic_blocks[START_BLOCK];
|
2022-07-02 19:00:00 -05:00
|
|
|
start_block.statements.extend(retained_coverage.into_iter().map(
|
2022-07-02 19:00:00 -05:00
|
|
|
|(source_info, code_region)| Statement {
|
2021-05-01 16:56:48 -05:00
|
|
|
source_info,
|
2021-08-04 22:36:38 -05:00
|
|
|
kind: StatementKind::Coverage(Box::new(Coverage {
|
2021-05-01 16:56:48 -05:00
|
|
|
kind: CoverageKind::Unreachable,
|
|
|
|
code_region: Some(code_region),
|
2021-08-04 22:36:38 -05:00
|
|
|
})),
|
2022-07-02 19:00:00 -05:00
|
|
|
},
|
|
|
|
));
|
2021-05-01 16:56:48 -05:00
|
|
|
}
|
|
|
|
|
2016-08-15 20:59:50 -05:00
|
|
|
pub struct SimplifyLocals;
|
|
|
|
|
2019-08-04 15:20:00 -05:00
|
|
|
impl<'tcx> MirPass<'tcx> for SimplifyLocals {
|
2021-12-02 11:17:32 -06:00
|
|
|
fn is_enabled(&self, sess: &rustc_session::Session) -> bool {
|
|
|
|
sess.mir_opt_level() > 0
|
|
|
|
}
|
|
|
|
|
2020-10-04 13:01:38 -05:00
|
|
|
fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
|
|
|
|
trace!("running SimplifyLocals on {:?}", body.source);
|
2020-10-03 04:18:24 -05:00
|
|
|
simplify_locals(body, tcx);
|
|
|
|
}
|
|
|
|
}
|
2020-04-03 19:28:07 -05:00
|
|
|
|
2020-10-03 04:18:24 -05:00
|
|
|
pub fn simplify_locals<'tcx>(body: &mut Body<'tcx>, tcx: TyCtxt<'tcx>) {
|
|
|
|
// First, we're going to get a count of *actual* uses for every `Local`.
|
2021-03-15 19:18:03 -05:00
|
|
|
let mut used_locals = UsedLocals::new(body);
|
2020-04-03 19:28:07 -05:00
|
|
|
|
2020-10-03 04:18:24 -05:00
|
|
|
// Next, we're going to remove any `Local` with zero actual uses. When we remove those
|
|
|
|
// `Locals`, we're also going to subtract any uses of other `Locals` from the `used_locals`
|
|
|
|
// count. For example, if we removed `_2 = discriminant(_1)`, then we'll subtract one from
|
|
|
|
// `use_counts[_1]`. That in turn might make `_1` unused, so we loop until we hit a
|
|
|
|
// fixedpoint where there are no more unused locals.
|
2021-01-03 07:51:24 -06:00
|
|
|
remove_unused_definitions(&mut used_locals, body);
|
2020-04-03 19:28:07 -05:00
|
|
|
|
2020-10-03 04:18:24 -05:00
|
|
|
// Finally, we'll actually do the work of shrinking `body.local_decls` and remapping the `Local`s.
|
2021-03-15 19:18:03 -05:00
|
|
|
let map = make_local_map(&mut body.local_decls, &used_locals);
|
2020-04-03 19:28:07 -05:00
|
|
|
|
2020-10-03 04:18:24 -05:00
|
|
|
// Only bother running the `LocalUpdater` if we actually found locals to remove.
|
|
|
|
if map.iter().any(Option::is_none) {
|
|
|
|
// Update references to all vars and tmps now
|
|
|
|
let mut updater = LocalUpdater { map, tcx };
|
2022-08-02 22:06:16 -05:00
|
|
|
updater.visit_body_preserves_cfg(body);
|
2020-04-03 19:28:07 -05:00
|
|
|
|
2020-10-03 04:18:24 -05:00
|
|
|
body.local_decls.shrink_to_fit();
|
2016-08-15 20:59:50 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Construct the mapping while swapping out unused stuff out from the `vec`.
|
2021-03-15 19:18:03 -05:00
|
|
|
fn make_local_map<V>(
|
2020-04-03 19:28:07 -05:00
|
|
|
local_decls: &mut IndexVec<Local, V>,
|
2021-03-15 19:18:03 -05:00
|
|
|
used_locals: &UsedLocals,
|
2018-07-22 11:23:39 -05:00
|
|
|
) -> IndexVec<Local, Option<Local>> {
|
2021-03-15 19:18:03 -05:00
|
|
|
let mut map: IndexVec<Local, Option<Local>> = IndexVec::from_elem(None, &*local_decls);
|
2018-07-22 11:23:39 -05:00
|
|
|
let mut used = Local::new(0);
|
2020-10-21 19:00:00 -05:00
|
|
|
|
|
|
|
for alive_index in local_decls.indices() {
|
2021-03-15 19:18:03 -05:00
|
|
|
// `is_used` treats the `RETURN_PLACE` and arguments as used.
|
|
|
|
if !used_locals.is_used(alive_index) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
map[alive_index] = Some(used);
|
|
|
|
if alive_index != used {
|
|
|
|
local_decls.swap(alive_index, used);
|
2016-08-15 20:59:50 -05:00
|
|
|
}
|
2021-03-15 19:18:03 -05:00
|
|
|
used.increment_by(1);
|
2016-08-15 20:59:50 -05:00
|
|
|
}
|
2020-04-03 19:28:07 -05:00
|
|
|
local_decls.truncate(used.index());
|
2016-08-15 20:59:50 -05:00
|
|
|
map
|
|
|
|
}
|
|
|
|
|
2020-10-21 19:00:00 -05:00
|
|
|
/// Keeps track of used & unused locals.
|
2021-03-15 19:18:03 -05:00
|
|
|
struct UsedLocals {
|
2020-10-21 19:00:00 -05:00
|
|
|
increment: bool,
|
2021-03-15 19:18:03 -05:00
|
|
|
arg_count: u32,
|
2020-10-21 19:00:00 -05:00
|
|
|
use_count: IndexVec<Local, u32>,
|
2016-08-15 20:59:50 -05:00
|
|
|
}
|
|
|
|
|
2021-03-15 19:18:03 -05:00
|
|
|
impl UsedLocals {
|
2020-10-21 19:00:00 -05:00
|
|
|
/// Determines which locals are used & unused in the given body.
|
2021-03-15 19:18:03 -05:00
|
|
|
fn new(body: &Body<'_>) -> Self {
|
2020-10-21 19:00:00 -05:00
|
|
|
let mut this = Self {
|
|
|
|
increment: true,
|
2021-03-15 19:18:03 -05:00
|
|
|
arg_count: body.arg_count.try_into().unwrap(),
|
2020-10-21 19:00:00 -05:00
|
|
|
use_count: IndexVec::from_elem(0, &body.local_decls),
|
|
|
|
};
|
|
|
|
this.visit_body(body);
|
|
|
|
this
|
2020-04-03 19:28:07 -05:00
|
|
|
}
|
|
|
|
|
2020-10-21 19:00:00 -05:00
|
|
|
/// Checks if local is used.
|
2021-03-15 19:18:03 -05:00
|
|
|
///
|
|
|
|
/// Return place and arguments are always considered used.
|
2020-10-21 19:00:00 -05:00
|
|
|
fn is_used(&self, local: Local) -> bool {
|
|
|
|
trace!("is_used({:?}): use_count: {:?}", local, self.use_count[local]);
|
2021-03-15 19:18:03 -05:00
|
|
|
local.as_u32() <= self.arg_count || self.use_count[local] != 0
|
2020-10-21 19:00:00 -05:00
|
|
|
}
|
2019-10-17 05:46:51 -05:00
|
|
|
|
2020-10-21 19:00:00 -05:00
|
|
|
/// Updates the use counts to reflect the removal of given statement.
|
2021-12-06 02:48:37 -06:00
|
|
|
fn statement_removed(&mut self, statement: &Statement<'_>) {
|
2020-10-21 19:00:00 -05:00
|
|
|
self.increment = false;
|
2019-10-17 05:46:51 -05:00
|
|
|
|
2020-10-21 19:00:00 -05:00
|
|
|
// The location of the statement is irrelevant.
|
|
|
|
let location = Location { block: START_BLOCK, statement_index: 0 };
|
|
|
|
self.visit_statement(statement, location);
|
2016-08-15 20:59:50 -05:00
|
|
|
}
|
2020-04-03 19:28:07 -05:00
|
|
|
|
2020-10-21 19:00:00 -05:00
|
|
|
/// Visits a left-hand side of an assignment.
|
2021-12-06 02:48:37 -06:00
|
|
|
fn visit_lhs(&mut self, place: &Place<'_>, location: Location) {
|
2020-10-21 19:00:00 -05:00
|
|
|
if place.is_indirect() {
|
|
|
|
// A use, not a definition.
|
|
|
|
self.visit_place(place, PlaceContext::MutatingUse(MutatingUseContext::Store), location);
|
|
|
|
} else {
|
2021-03-19 19:00:00 -05:00
|
|
|
// A definition. The base local itself is not visited, so this occurrence is not counted
|
|
|
|
// toward its use count. There might be other locals still, used in an indexing
|
|
|
|
// projection.
|
2020-10-21 19:00:00 -05:00
|
|
|
self.super_projection(
|
2021-02-20 05:16:05 -06:00
|
|
|
place.as_ref(),
|
2020-10-21 19:00:00 -05:00
|
|
|
PlaceContext::MutatingUse(MutatingUseContext::Projection),
|
|
|
|
location,
|
|
|
|
);
|
|
|
|
}
|
2020-04-03 19:28:07 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-12-06 02:48:37 -06:00
|
|
|
impl<'tcx> Visitor<'tcx> for UsedLocals {
|
2020-10-21 19:00:00 -05:00
|
|
|
fn visit_statement(&mut self, statement: &Statement<'tcx>, location: Location) {
|
|
|
|
match statement.kind {
|
2022-01-11 18:00:00 -06:00
|
|
|
StatementKind::CopyNonOverlapping(..)
|
2020-10-21 19:00:00 -05:00
|
|
|
| StatementKind::Retag(..)
|
|
|
|
| StatementKind::Coverage(..)
|
|
|
|
| StatementKind::FakeRead(..)
|
|
|
|
| StatementKind::AscribeUserType(..) => {
|
|
|
|
self.super_statement(statement, location);
|
|
|
|
}
|
|
|
|
|
|
|
|
StatementKind::Nop => {}
|
|
|
|
|
|
|
|
StatementKind::StorageLive(_local) | StatementKind::StorageDead(_local) => {}
|
|
|
|
|
|
|
|
StatementKind::Assign(box (ref place, ref rvalue)) => {
|
2022-05-31 19:00:00 -05:00
|
|
|
if rvalue.is_safe_to_remove() {
|
|
|
|
self.visit_lhs(place, location);
|
|
|
|
self.visit_rvalue(rvalue, location);
|
|
|
|
} else {
|
|
|
|
self.super_statement(statement, location);
|
|
|
|
}
|
2020-04-03 19:28:07 -05:00
|
|
|
}
|
2020-10-16 19:00:00 -05:00
|
|
|
|
2022-04-05 16:14:59 -05:00
|
|
|
StatementKind::SetDiscriminant { ref place, variant_index: _ }
|
|
|
|
| StatementKind::Deinit(ref place) => {
|
2020-10-16 19:00:00 -05:00
|
|
|
self.visit_lhs(place, location);
|
|
|
|
}
|
2020-04-03 19:28:07 -05:00
|
|
|
}
|
2020-10-21 19:00:00 -05:00
|
|
|
}
|
2020-04-03 19:28:07 -05:00
|
|
|
|
2022-07-01 09:21:21 -05:00
|
|
|
fn visit_local(&mut self, local: Local, _ctx: PlaceContext, _location: Location) {
|
2020-10-21 19:00:00 -05:00
|
|
|
if self.increment {
|
2022-07-01 09:21:21 -05:00
|
|
|
self.use_count[local] += 1;
|
2020-10-21 19:00:00 -05:00
|
|
|
} else {
|
2022-07-01 09:21:21 -05:00
|
|
|
assert_ne!(self.use_count[local], 0);
|
|
|
|
self.use_count[local] -= 1;
|
2020-04-13 20:02:03 -05:00
|
|
|
}
|
2020-04-03 19:28:07 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-10-21 19:00:00 -05:00
|
|
|
/// Removes unused definitions. Updates the used locals to reflect the changes made.
|
2021-12-06 02:48:37 -06:00
|
|
|
fn remove_unused_definitions(used_locals: &mut UsedLocals, body: &mut Body<'_>) {
|
2020-10-21 19:00:00 -05:00
|
|
|
// The use counts are updated as we remove the statements. A local might become unused
|
|
|
|
// during the retain operation, leading to a temporary inconsistency (storage statements or
|
|
|
|
// definitions referencing the local might remain). For correctness it is crucial that this
|
|
|
|
// computation reaches a fixed point.
|
|
|
|
|
|
|
|
let mut modified = true;
|
|
|
|
while modified {
|
|
|
|
modified = false;
|
|
|
|
|
2022-08-02 22:06:16 -05:00
|
|
|
for data in body.basic_blocks.as_mut_preserves_cfg() {
|
2020-10-21 19:00:00 -05:00
|
|
|
// Remove unnecessary StorageLive and StorageDead annotations.
|
|
|
|
data.statements.retain(|statement| {
|
|
|
|
let keep = match &statement.kind {
|
|
|
|
StatementKind::StorageLive(local) | StatementKind::StorageDead(local) => {
|
|
|
|
used_locals.is_used(*local)
|
|
|
|
}
|
2021-01-03 07:51:24 -06:00
|
|
|
StatementKind::Assign(box (place, _)) => used_locals.is_used(place.local),
|
2020-10-16 19:00:00 -05:00
|
|
|
|
2022-04-05 16:14:59 -05:00
|
|
|
StatementKind::SetDiscriminant { ref place, .. }
|
|
|
|
| StatementKind::Deinit(ref place) => used_locals.is_used(place.local),
|
2020-10-21 19:00:00 -05:00
|
|
|
_ => true,
|
|
|
|
};
|
2019-10-20 15:11:04 -05:00
|
|
|
|
2020-10-21 19:00:00 -05:00
|
|
|
if !keep {
|
|
|
|
trace!("removing statement {:?}", statement);
|
|
|
|
modified = true;
|
|
|
|
used_locals.statement_removed(statement);
|
2020-04-03 19:28:07 -05:00
|
|
|
}
|
|
|
|
|
2020-10-21 19:00:00 -05:00
|
|
|
keep
|
|
|
|
});
|
|
|
|
}
|
2016-08-15 20:59:50 -05:00
|
|
|
}
|
2020-04-03 19:28:07 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
struct LocalUpdater<'tcx> {
|
|
|
|
map: IndexVec<Local, Option<Local>>,
|
|
|
|
tcx: TyCtxt<'tcx>,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<'tcx> MutVisitor<'tcx> for LocalUpdater<'tcx> {
|
|
|
|
fn tcx(&self) -> TyCtxt<'tcx> {
|
|
|
|
self.tcx
|
|
|
|
}
|
2019-10-07 15:58:28 -05:00
|
|
|
|
2019-04-24 13:41:43 -05:00
|
|
|
fn visit_local(&mut self, l: &mut Local, _: PlaceContext, _: Location) {
|
2018-07-22 11:23:39 -05:00
|
|
|
*l = self.map[*l].unwrap();
|
2016-08-15 20:59:50 -05:00
|
|
|
}
|
|
|
|
}
|