Add MIR pass manager and tier-ed passes.

Tiered passes allow to avoid some of the introspection of MIR map for passes which do not need it
and perhaps improve performance of the more-restricted passes (i.e. BlockPasses could be run in
parallel regardless of function for which the block belongs). It also could allow to e.g. run dead
block removal only after passes which modify the CFG graph and not after those which only change
blocks.

Author: nagisa

src/librustc/mir/mir_map.rs

@@ -10,19 +10,7 @@
 
 use util::nodemap::NodeMap;
 use mir::repr::Mir;
-use mir::transform::MirPass;
-use middle::ty;
 
 pub struct MirMap<'tcx> {
     pub map: NodeMap<Mir<'tcx>>,
 }
-
-impl<'tcx> MirMap<'tcx> {
-    pub fn run_passes(&mut self, passes: &mut [Box<MirPass>], tcx: &ty::ctxt<'tcx>) {
-        for (_, ref mut mir) in &mut self.map {
-            for pass in &mut *passes {
-                pass.run_on_mir(mir, tcx)
-            }
-        }
-    }
-}

src/librustc/mir/transform.rs

@@ -8,9 +8,79 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use mir::repr::Mir;
+use mir::repr::{Mir, BasicBlockData, BasicBlock};
+use mir::mir_map::MirMap;
 use middle::ty::ctxt;
 
-pub trait MirPass {
-    fn run_on_mir<'tcx>(&mut self, mir: &mut Mir<'tcx>, tcx: &ctxt<'tcx>);
+/// Contains various metadata about the pass.
+pub trait Pass {
+    /// Ordering of the pass. Lower value runs the pass earlier.
+    fn priority(&self) -> usize;
+    // Possibly also `fn name()` and `fn should_run(Session)` etc.
+}
+
+/// Pass which inspects the whole MirMap.
+pub trait MirMapPass: Pass {
+    fn run_pass<'tcx>(&mut self, tcx: &ctxt<'tcx>, map: &mut MirMap<'tcx>);
+}
+
+/// Pass which only inspects MIR of distinct functions.
+pub trait MirPass: Pass {
+    fn run_pass<'tcx>(&mut self, tcx: &ctxt<'tcx>, mir: &mut Mir<'tcx>);
+}
+
+/// Pass which only inspects basic blocks in MIR.
+///
+/// Invariant: The blocks are considered to be fully self-contained for the purposes of this pass –
+/// the pass may not change the list of successors of the block or apply any transformations to
+/// blocks based on the information collected during earlier runs of the pass.
+pub trait MirBlockPass: Pass {
+    fn run_pass<'tcx>(&mut self, tcx: &ctxt<'tcx>, bb: BasicBlock, data: &mut BasicBlockData<'tcx>);
+}
+
+impl<T: MirBlockPass> MirPass for T {
+    fn run_pass<'tcx>(&mut self, tcx: &ctxt<'tcx>, mir: &mut Mir<'tcx>) {
+        for (i, basic_block) in mir.basic_blocks.iter_mut().enumerate() {
+            MirBlockPass::run_pass(self, tcx, BasicBlock::new(i), basic_block);
+        }
+    }
+}
+
+impl<T: MirPass> MirMapPass for T {
+    fn run_pass<'tcx>(&mut self, tcx: &ctxt<'tcx>, map: &mut MirMap<'tcx>) {
+        for (_, mir) in &mut map.map {
+            MirPass::run_pass(self, tcx, mir);
+        }
+    }
+}
+
+/// A manager for MIR passes.
+pub struct Passes {
+    passes: Vec<Box<MirMapPass>>
+}
+
+impl Passes {
+    pub fn new() -> Passes {
+        let passes = Passes {
+            passes: Vec::new()
+        };
+        passes
+    }
+
+    pub fn run_passes<'tcx>(&mut self, tcx: &ctxt<'tcx>, map: &mut MirMap<'tcx>) {
+        self.passes.sort_by_key(|e| e.priority());
+        for pass in &mut self.passes {
+            pass.run_pass(tcx, map);
+        }
+    }
+
+    pub fn push_pass(&mut self, pass: Box<MirMapPass>) {
+        self.passes.push(pass);
+    }
+}
+
+impl ::std::iter::Extend<Box<MirMapPass>> for Passes {
+    fn extend<I: IntoIterator<Item=Box<MirMapPass>>>(&mut self, it: I) {
+        self.passes.extend(it);
+    }
 }

src/librustc/session/mod.rs

@@ -13,7 +13,7 @@ use middle::cstore::CrateStore;
 use middle::dependency_format;
 use session::search_paths::PathKind;
 use util::nodemap::{NodeMap, FnvHashMap};
-use mir::transform::MirPass;
+use mir;
 
 use syntax::ast::{NodeId, NodeIdAssigner, Name};
 use syntax::codemap::{Span, MultiSpan};
@@ -60,7 +60,7 @@ pub struct Session {
     pub lint_store: RefCell<lint::LintStore>,
     pub lints: RefCell<NodeMap<Vec<(lint::LintId, Span, String)>>>,
     pub plugin_llvm_passes: RefCell<Vec<String>>,
-    pub plugin_mir_passes: RefCell<Vec<Box<MirPass>>>,
+    pub mir_passes: RefCell<mir::transform::Passes>,
     pub plugin_attributes: RefCell<Vec<(String, AttributeType)>>,
     pub crate_types: RefCell<Vec<config::CrateType>>,
     pub dependency_formats: RefCell<dependency_format::Dependencies>,
@@ -477,7 +477,7 @@ pub fn build_session_(sopts: config::Options,
         lint_store: RefCell::new(lint::LintStore::new()),
         lints: RefCell::new(NodeMap()),
         plugin_llvm_passes: RefCell::new(Vec::new()),
-        plugin_mir_passes: RefCell::new(Vec::new()),
+        mir_passes: RefCell::new(mir::transform::Passes::new()),
         plugin_attributes: RefCell::new(Vec::new()),
         crate_types: RefCell::new(Vec::new()),
         dependency_formats: RefCell::new(FnvHashMap()),

src/librustc_driver/driver.rs

@@ -23,6 +23,7 @@ use rustc::middle;
 use rustc::util::common::time;
 use rustc::util::nodemap::NodeSet;
 use rustc_borrowck as borrowck;
+use rustc_mir::transform;
 use rustc_resolve as resolve;
 use rustc_metadata::macro_import;
 use rustc_metadata::creader::LocalCrateReader;
@@ -561,8 +562,8 @@ pub fn phase_2_configure_and_expand(sess: &Session,
         }
 
         *sess.plugin_llvm_passes.borrow_mut() = llvm_passes;
-        *sess.plugin_mir_passes.borrow_mut() = mir_passes;
         *sess.plugin_attributes.borrow_mut() = attributes.clone();
+        sess.mir_passes.borrow_mut().extend(mir_passes);
     }));
 
     // Lint plugins are registered; now we can process command line flags.
@@ -846,12 +847,18 @@ pub fn phase_3_run_analysis_passes<'tcx, F, R>(sess: &'tcx Session,
 
         let mut mir_map =
             time(time_passes,
-                 "MIR dump",
+                 "MIR build",
                  || mir::mir_map::build_mir_for_crate(tcx));
 
-        time(time_passes,
-             "MIR passes",
-             || mir_map.run_passes(&mut sess.plugin_mir_passes.borrow_mut(), tcx));
+
+        time(time_passes, "MIR passes", || {
+            let mut passes = sess.mir_passes.borrow_mut();
+            // Push all the built-in passes.
+            passes.push_pass(box transform::simplify_cfg::SimplifyCfg);
+            passes.push_pass(box transform::erase_regions::EraseRegions);
+            // And run everything.
+            passes.run_passes(tcx, &mut mir_map);
+        });
 
         time(time_passes,
              "liveness checking",
@@ -907,10 +914,9 @@ pub fn phase_3_run_analysis_passes<'tcx, F, R>(sess: &'tcx Session,
     })
 }
 
-/// Run the translation phase to LLVM, after which the AST and analysis can
-/// be discarded.
+/// Run the translation phase to LLVM, after which the MIR and analysis can be discarded.
 pub fn phase_4_translate_to_llvm<'tcx>(tcx: &ty::ctxt<'tcx>,
-                                       mut mir_map: MirMap<'tcx>,
+                                       mir_map: MirMap<'tcx>,
                                        analysis: ty::CrateAnalysis)
                                        -> trans::CrateTranslation {
     let time_passes = tcx.sess.time_passes();
@@ -919,11 +925,6 @@ pub fn phase_4_translate_to_llvm<'tcx>(tcx: &ty::ctxt<'tcx>,
          "resolving dependency formats",
          || dependency_format::calculate(&tcx.sess));
 
-    time(time_passes,
-         "erasing regions from MIR",
-         || mir::transform::erase_regions::erase_regions(tcx, &mut mir_map));
-
-    // Option dance to work around the lack of stack once closures.
     time(time_passes,
          "translation",
          move || trans::trans_crate(tcx, &mir_map, analysis))

src/librustc_mir/mir_map.rs

@@ -22,13 +22,11 @@ extern crate rustc_front;
 use build;
 use graphviz;
 use pretty;
-use transform::{simplify_cfg, MirPass};
 use rustc::dep_graph::DepNode;
 use rustc::mir::repr::Mir;
 use hair::cx::Cx;
 use std::fs::File;
 
-use rustc::mir::transform::MirPass;
 use rustc::mir::mir_map::MirMap;
 use rustc::middle::infer;
 use rustc::middle::region::CodeExtentData;
@@ -147,9 +145,7 @@ impl<'a, 'm, 'tcx> Visitor<'tcx> for InnerDump<'a,'m,'tcx> {
         let infcx = infer::new_infer_ctxt(self.tcx, &self.tcx.tables, Some(param_env));
 
         match build_mir(Cx::new(&infcx), implicit_arg_tys, id, span, decl, body) {
-            Ok(mut mir) => {
-                simplify_cfg::SimplifyCfg::new().run_on_mir(&mut mir, self.tcx);
-
+            Ok(mir) => {
                 let meta_item_list = self.attr
                                          .iter()
                                          .flat_map(|a| a.meta_item_list())

src/librustc_mir/transform/erase_regions.rs

@@ -16,18 +16,33 @@ use rustc::middle::ty;
 use rustc::mir::repr::*;
 use rustc::mir::visit::MutVisitor;
 use rustc::mir::mir_map::MirMap;
-use rustc::mir::transform::MirPass;
+use rustc::mir::transform::{MirPass, Pass};
 
 pub fn erase_regions<'tcx>(tcx: &ty::ctxt<'tcx>, mir_map: &mut MirMap<'tcx>) {
     let mut eraser = EraseRegions;
 
     for (_, mir) in &mut mir_map.map {
-        eraser.run_on_mir(mir, tcx);
+        eraser.run_pass(tcx, mir);
     }
 }
 
 pub struct EraseRegions;
 
+impl MirPass for EraseRegions {
+    fn run_pass<'tcx>(&mut self, tcx: &ty::ctxt<'tcx>, mir: &mut Mir<'tcx>) {
+        EraseRegionsVisitor::new(tcx).visit_mir(mir);
+    }
+
+}
+
+impl Pass for EraseRegions {
+    fn priority(&self) -> usize {
+        // We want this pass to run as late as possible in transformation chain, so we give it a
+        // very high priority number.
+        !50
+    }
+}
+
 struct EraseRegionsVisitor<'a, 'tcx: 'a> {
     tcx: &'a ty::ctxt<'tcx>,
 }
@@ -58,13 +73,7 @@ impl<'a, 'tcx> EraseRegionsVisitor<'a, 'tcx> {
     }
 }
 
-impl<'a, 'tcx> MirPass<'tcx> for EraseRegions<'a, 'tcx> {
-    fn run_on_mir(&mut self, mir: &mut Mir<'tcx>) {
-        self.visit_mir(mir);
-    }
-}
-
-impl<'a, 'tcx> MutVisitor<'tcx> for EraseRegions<'a, 'tcx> {
+impl<'a, 'tcx> MutVisitor<'tcx> for EraseRegionsVisitor<'a, 'tcx> {
     fn visit_mir(&mut self, mir: &mut Mir<'tcx>) {
         self.erase_regions_return_ty(&mut mir.return_ty);
         self.erase_regions_tys(mir.var_decls.iter_mut().map(|d| &mut d.ty));

src/librustc_mir/transform/simplify_cfg.rs

@@ -9,17 +9,14 @@
 // except according to those terms.
 
 use rustc::middle::const_eval::ConstVal;
+use rustc::middle::ty;
 use rustc::mir::repr::*;
 use transform::util;
-use rustc::mir::transform::MirPass;
+use rustc::mir::transform::{MirPass, Pass};
 
 pub struct SimplifyCfg;
 
 impl SimplifyCfg {
-    pub fn new() -> SimplifyCfg {
-        SimplifyCfg
-    }
-
     fn remove_dead_blocks(&self, mir: &mut Mir) {
         let mut seen = vec![false; mir.basic_blocks.len()];
 
@@ -83,6 +80,7 @@ impl SimplifyCfg {
         changed
     }
 
+    // FIXME: This transformation should be interleaved with the constant-propagation pass.
     fn simplify_branches(&self, mir: &mut Mir) -> bool {
         let mut changed = false;
 
@@ -119,7 +117,7 @@ impl SimplifyCfg {
 }
 
 impl MirPass for SimplifyCfg {
-    fn run_on_mir<'tcx>(&mut self, mir: &mut Mir<'tcx>, _: &::rustc::middle::ty::ctxt<'tcx>) {
+    fn run_pass<'tcx>(&mut self, _: &ty::ctxt<'tcx>, mir: &mut Mir<'tcx>) {
         let mut changed = true;
         while changed {
             changed = self.simplify_branches(mir);
@@ -130,3 +128,9 @@ impl MirPass for SimplifyCfg {
         mir.basic_blocks.shrink_to_fit();
     }
 }
+
+impl Pass for SimplifyCfg {
+    fn priority(&self) -> usize {
+        50
+    }
+}

src/librustc_plugin/registry.rs

@@ -13,7 +13,7 @@
 use rustc::lint::{EarlyLintPassObject, LateLintPassObject, LintId, Lint};
 use rustc::session::Session;
 
-use rustc::mir::transform::MirPass;
+use rustc::mir;
 
 use syntax::ext::base::{SyntaxExtension, NamedSyntaxExtension, NormalTT};
 use syntax::ext::base::{IdentTT, MultiModifier, MultiDecorator};
@@ -56,7 +56,7 @@ pub struct Registry<'a> {
     pub late_lint_passes: Vec<LateLintPassObject>,
 
     #[doc(hidden)]
-    pub mir_passes: Vec<Box<MirPass>>,
+    pub mir_passes: Vec<Box<mir::transform::MirMapPass>>,
 
     #[doc(hidden)]
     pub lint_groups: HashMap<&'static str, Vec<LintId>>,
@@ -141,7 +141,7 @@ impl<'a> Registry<'a> {
     }
 
     /// Register a MIR pass
-    pub fn register_mir_pass(&mut self, pass: Box<MirPass>) {
+    pub fn register_mir_pass(&mut self, pass: Box<mir::transform::MirMapPass>) {
         self.mir_passes.push(pass);
     }
 

src/test/auxiliary/dummy_mir_pass.rs

@@ -18,8 +18,8 @@ extern crate rustc_front;
 extern crate rustc_plugin;
 extern crate syntax;
 
-use rustc::mir::transform::MirPass;
-use rustc::mir::repr::{Mir, Literal};
+use rustc::mir::transform::{self, MirBlockPass};
+use rustc::mir::repr::{BasicBlock, BasicBlockData, Literal};
 use rustc::mir::visit::MutVisitor;
 use rustc::middle::ty;
 use rustc::middle::const_eval::ConstVal;
@@ -30,9 +30,15 @@ use syntax::attr;
 
 struct Pass;
 
-impl MirPass for Pass {
-    fn run_on_mir<'tcx>(&mut self, mir: &mut Mir<'tcx>, tcx: &ty::ctxt<'tcx>) {
-        Visitor.visit_mir(mir)
+impl transform::Pass for Pass {
+    fn priority(&self) -> usize {
+        1000
+    }
+}
+
+impl MirBlockPass for Pass {
+    fn run_pass<'tcx>(&mut self, tcx: &ty::ctxt<'tcx>, bb: BasicBlock, bbd: &mut BasicBlockData) {
+        Visitor.visit_basic_block_data(bb, bbd)
     }
 }