2015-11-10 14:38:36 -06:00
|
|
|
// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
|
|
|
|
// file at the top-level directory of this distribution and at
|
|
|
|
// http://rust-lang.org/COPYRIGHT.
|
|
|
|
//
|
|
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
|
|
// option. This file may not be copied, modified, or distributed
|
|
|
|
// except according to those terms.
|
|
|
|
|
2016-06-06 14:58:28 -05:00
|
|
|
//! A pass that removes various redundancies in the CFG. It should be
|
|
|
|
//! called after every significant CFG modification to tidy things
|
|
|
|
//! up.
|
|
|
|
//!
|
|
|
|
//! 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 that is that typeck lets 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:
|
|
|
|
//! ```rust
|
|
|
|
//! fn example() {
|
|
|
|
//! let _a: char = { return; };
|
|
|
|
//! }
|
|
|
|
//! ```
|
|
|
|
//!
|
|
|
|
//! 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.
|
|
|
|
|
|
|
|
|
2015-11-14 16:52:17 -06:00
|
|
|
use rustc_data_structures::bitvec::BitVector;
|
2016-06-07 09:28:36 -05:00
|
|
|
use rustc_data_structures::indexed_vec::{Idx, IndexVec};
|
2016-03-22 10:30:57 -05:00
|
|
|
use rustc::ty::TyCtxt;
|
2016-09-19 15:50:00 -05:00
|
|
|
use rustc::mir::*;
|
2016-05-02 16:26:41 -05:00
|
|
|
use rustc::mir::transform::{MirPass, MirSource, Pass};
|
2016-06-08 13:03:06 -05:00
|
|
|
use std::fmt;
|
2016-02-26 10:05:50 -06:00
|
|
|
|
2016-06-06 14:58:28 -05:00
|
|
|
pub struct SimplifyCfg<'a> { label: &'a str }
|
2015-11-10 14:38:36 -06:00
|
|
|
|
2016-06-06 14:58:28 -05:00
|
|
|
impl<'a> SimplifyCfg<'a> {
|
|
|
|
pub fn new(label: &'a str) -> Self {
|
|
|
|
SimplifyCfg { label: label }
|
2015-11-10 14:38:36 -06:00
|
|
|
}
|
2015-11-14 16:52:17 -06:00
|
|
|
}
|
|
|
|
|
2016-06-06 14:58:28 -05:00
|
|
|
impl<'l, 'tcx> MirPass<'tcx> for SimplifyCfg<'l> {
|
2016-06-08 13:03:06 -05:00
|
|
|
fn run_pass<'a>(&mut self, _tcx: TyCtxt<'a, 'tcx, 'tcx>, _src: MirSource, mir: &mut Mir<'tcx>) {
|
2016-10-04 08:23:01 -05:00
|
|
|
debug!("SimplifyCfg({:?}) - simplifying {:?}", self.label, mir);
|
2016-06-08 16:10:15 -05:00
|
|
|
CfgSimplifier::new(mir).simplify();
|
2016-06-06 14:58:28 -05:00
|
|
|
remove_dead_blocks(mir);
|
2015-11-14 16:52:17 -06:00
|
|
|
|
|
|
|
// FIXME: Should probably be moved into some kind of pass manager
|
2016-06-07 13:20:50 -05:00
|
|
|
mir.basic_blocks_mut().raw.shrink_to_fit();
|
2015-11-14 16:52:17 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-06-08 13:03:06 -05:00
|
|
|
impl<'l> Pass for SimplifyCfg<'l> {
|
|
|
|
fn disambiguator<'a>(&'a self) -> Option<Box<fmt::Display+'a>> {
|
|
|
|
Some(Box::new(self.label))
|
|
|
|
}
|
2016-06-16 08:52:37 -05:00
|
|
|
|
|
|
|
// avoid calling `type_name` - it contains `<'static>`
|
2016-08-07 17:04:51 -05:00
|
|
|
fn name(&self) -> ::std::borrow::Cow<'static, str> { "SimplifyCfg".into() }
|
2016-06-08 13:03:06 -05:00
|
|
|
}
|
2015-11-14 16:52:17 -06:00
|
|
|
|
2016-06-08 16:10:15 -05:00
|
|
|
pub struct CfgSimplifier<'a, 'tcx: 'a> {
|
|
|
|
basic_blocks: &'a mut IndexVec<BasicBlock, BasicBlockData<'tcx>>,
|
|
|
|
pred_count: IndexVec<BasicBlock, u32>
|
|
|
|
}
|
2015-11-10 14:38:36 -06:00
|
|
|
|
2016-06-08 16:10:15 -05:00
|
|
|
impl<'a, 'tcx: 'a> CfgSimplifier<'a, 'tcx> {
|
|
|
|
fn new(mir: &'a mut Mir<'tcx>) -> Self {
|
|
|
|
let mut pred_count = IndexVec::from_elem(0u32, mir.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;
|
|
|
|
|
2016-06-08 16:10:15 -05:00
|
|
|
for (_, data) in traversal::preorder(mir) {
|
|
|
|
if let Some(ref term) = data.terminator {
|
|
|
|
for &tgt in term.successors().iter() {
|
|
|
|
pred_count[tgt] += 1;
|
2015-11-14 16:52:17 -06:00
|
|
|
}
|
|
|
|
}
|
2015-11-10 14:38:36 -06:00
|
|
|
}
|
|
|
|
|
2016-06-08 16:10:15 -05:00
|
|
|
let basic_blocks = mir.basic_blocks_mut();
|
|
|
|
|
|
|
|
CfgSimplifier {
|
|
|
|
basic_blocks: basic_blocks,
|
|
|
|
pred_count: pred_count
|
2015-11-14 16:52:17 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-06-08 16:10:15 -05:00
|
|
|
fn simplify(mut self) {
|
|
|
|
loop {
|
|
|
|
let mut changed = false;
|
|
|
|
|
|
|
|
for bb in (0..self.basic_blocks.len()).map(BasicBlock::new) {
|
|
|
|
if self.pred_count[bb] == 0 {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
debug!("simplifying {:?}", bb);
|
|
|
|
|
|
|
|
let mut terminator = self.basic_blocks[bb].terminator.take()
|
|
|
|
.expect("invalid terminator state");
|
|
|
|
|
|
|
|
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 new_stmts = vec![];
|
|
|
|
let mut inner_changed = true;
|
|
|
|
while inner_changed {
|
|
|
|
inner_changed = false;
|
|
|
|
inner_changed |= self.simplify_branch(&mut terminator);
|
|
|
|
inner_changed |= self.merge_successor(&mut new_stmts, &mut terminator);
|
|
|
|
changed |= inner_changed;
|
|
|
|
}
|
|
|
|
|
|
|
|
self.basic_blocks[bb].statements.extend(new_stmts);
|
|
|
|
self.basic_blocks[bb].terminator = Some(terminator);
|
|
|
|
|
|
|
|
changed |= inner_changed;
|
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
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-06-08 16:10:15 -05:00
|
|
|
// Collapse a goto chain starting from `start`
|
|
|
|
fn collapse_goto_chain(&mut self, start: &mut BasicBlock, changed: &mut bool) {
|
|
|
|
let mut terminator = match self.basic_blocks[*start] {
|
|
|
|
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.
|
|
|
|
_ => return
|
|
|
|
};
|
|
|
|
|
|
|
|
let target = match terminator {
|
|
|
|
Some(Terminator { kind: TerminatorKind::Goto { ref mut target }, .. }) => {
|
|
|
|
self.collapse_goto_chain(target, changed);
|
|
|
|
*target
|
|
|
|
}
|
|
|
|
_ => unreachable!()
|
|
|
|
};
|
|
|
|
self.basic_blocks[*start].terminator = terminator;
|
2015-11-14 16:52:17 -06:00
|
|
|
|
2016-06-08 16:10:15 -05:00
|
|
|
debug!("collapsing goto chain from {:?} to {:?}", *start, target);
|
2015-11-10 14:38:36 -06:00
|
|
|
|
2016-06-08 16:10:15 -05:00
|
|
|
*changed |= *start != target;
|
2016-10-04 08:27:27 -05:00
|
|
|
|
|
|
|
if self.pred_count[*start] == 1 {
|
|
|
|
// This is the last reference to *start, so the pred-count to
|
|
|
|
// to target is moved into the current block.
|
|
|
|
self.pred_count[*start] = 0;
|
|
|
|
} else {
|
|
|
|
self.pred_count[target] += 1;
|
|
|
|
self.pred_count[*start] -= 1;
|
|
|
|
}
|
|
|
|
|
2016-06-08 16:10:15 -05:00
|
|
|
*start = target;
|
|
|
|
}
|
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,
|
|
|
|
new_stmts: &mut Vec<Statement<'tcx>>,
|
|
|
|
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);
|
|
|
|
*terminator = match self.basic_blocks[target].terminator.take() {
|
|
|
|
Some(terminator) => terminator,
|
|
|
|
None => {
|
|
|
|
// unreachable loop - this should not be possible, as we
|
|
|
|
// don't strand blocks, but handle it correctly.
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
};
|
|
|
|
new_stmts.extend(self.basic_blocks[target].statements.drain(..));
|
|
|
|
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::If { .. } |
|
|
|
|
TerminatorKind::Switch { .. } |
|
|
|
|
TerminatorKind::SwitchInt { .. } => {},
|
|
|
|
_ => return false
|
|
|
|
};
|
|
|
|
|
|
|
|
let first_succ = {
|
|
|
|
let successors = terminator.successors();
|
|
|
|
if let Some(&first_succ) = terminator.successors().get(0) {
|
|
|
|
if successors.iter().all(|s| *s == first_succ) {
|
|
|
|
self.pred_count[first_succ] -= (successors.len()-1) as u32;
|
|
|
|
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
|
|
|
}
|
|
|
|
}
|
2016-06-06 14:58:28 -05:00
|
|
|
|
|
|
|
fn remove_dead_blocks(mir: &mut Mir) {
|
2016-06-07 13:20:50 -05:00
|
|
|
let mut seen = BitVector::new(mir.basic_blocks().len());
|
2016-06-06 14:58:28 -05:00
|
|
|
for (bb, _) in traversal::preorder(mir) {
|
|
|
|
seen.insert(bb.index());
|
|
|
|
}
|
|
|
|
|
2016-06-07 13:20:50 -05:00
|
|
|
let basic_blocks = mir.basic_blocks_mut();
|
2016-06-06 14:58:28 -05:00
|
|
|
|
2016-06-07 13:20:50 -05:00
|
|
|
let num_blocks = basic_blocks.len();
|
2016-06-07 09:28:36 -05:00
|
|
|
let mut replacements : Vec<_> = (0..num_blocks).map(BasicBlock::new).collect();
|
2016-06-06 14:58:28 -05:00
|
|
|
let mut used_blocks = 0;
|
|
|
|
for alive_index in seen.iter() {
|
|
|
|
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.
|
2016-06-07 13:20:50 -05:00
|
|
|
basic_blocks.raw.swap(alive_index, used_blocks);
|
2016-06-06 14:58:28 -05:00
|
|
|
}
|
|
|
|
used_blocks += 1;
|
|
|
|
}
|
2016-06-07 13:20:50 -05:00
|
|
|
basic_blocks.raw.truncate(used_blocks);
|
2016-06-06 14:58:28 -05:00
|
|
|
|
2016-06-07 13:20:50 -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()];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|