Add Pass manager for MIR

nagisa · nagisa · commit 811b87471621 · 2016-03-04T15:20:10.000+02:00
diff --git a/src/librustc/dep_graph/mod.rs b/src/librustc/dep_graph/mod.rs
@@ -70,6 +70,7 @@ pub enum DepNode {
     IntrinsicCheck(DefId),
     MatchCheck(DefId),
     MirMapConstruction(DefId),
+    MirPasses,
     BorrowCheck(DefId),
     RvalueCheck(DefId),
     Reachability,
diff --git a/src/librustc/mir/mir_map.rs b/src/librustc/mir/mir_map.rs
@@ -8,31 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use dep_graph::DepNode;
 use util::nodemap::NodeMap;
 use mir::repr::Mir;
-use mir::transform::MirPass;
-use middle::ty::{self, TyCtxt};
-use middle::infer;
 
 pub struct MirMap<'tcx> {
     pub map: NodeMap<Mir<'tcx>>,
 }
-
-impl<'tcx> MirMap<'tcx> {
-    pub fn run_passes(&mut self, passes: &mut [Box<MirPass>], tcx: &TyCtxt<'tcx>) {
-        if passes.is_empty() { return; }
-
-        for (&id, mir) in &mut self.map {
-            let did = tcx.map.local_def_id(id);
-            let _task = tcx.dep_graph.in_task(DepNode::MirMapConstruction(did));
-
-            let param_env = ty::ParameterEnvironment::for_item(tcx, id);
-            let infcx = infer::new_infer_ctxt(tcx, &tcx.tables, Some(param_env));
-
-            for pass in &mut *passes {
-                pass.run_on_mir(mir, &infcx)
-            }
-        }
-    }
-}
diff --git a/src/librustc/mir/repr.rs b/src/librustc/mir/repr.rs
@@ -207,7 +207,7 @@ impl Debug for BasicBlock {
 }
 
 ///////////////////////////////////////////////////////////////////////////
-// BasicBlock and Terminator
+// BasicBlockData and Terminator
 
 #[derive(Clone, Debug, RustcEncodable, RustcDecodable)]
 pub struct BasicBlockData<'tcx> {
diff --git a/src/librustc/mir/transform.rs b/src/librustc/mir/transform.rs
@@ -8,9 +8,66 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use mir::mir_map::MirMap;
 use mir::repr::Mir;
-use middle::infer::InferCtxt;
+use middle::ty::TyCtxt;
 
-pub trait MirPass {
-    fn run_on_mir<'a, 'tcx>(&mut self, mir: &mut Mir<'tcx>, infcx: &InferCtxt<'a, 'tcx>);
+/// Various information about pass.
+pub trait Pass {
+    // fn name() for printouts of various sorts?
+    // fn should_run(Session) to check if pass should run?
+}
+
+/// A pass which inspects the whole MirMap.
+pub trait MirMapPass<'tcx>: Pass {
+    fn run_pass(&mut self, cx: &TyCtxt<'tcx>, map: &mut MirMap<'tcx>);
+}
+
+pub trait MirPass<'tcx>: Pass {
+    fn run_pass(&mut self, cx: &TyCtxt<'tcx>, map: &mut Mir<'tcx>);
+}
+
+impl<'tcx, T: MirPass<'tcx>> MirMapPass<'tcx> for T {
+    fn run_pass(&mut self, tcx: &TyCtxt<'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<for<'tcx> MirMapPass<'tcx>>>,
+    plugin_passes: Vec<Box<for<'tcx> MirMapPass<'tcx>>>
+}
+
+impl Passes {
+    pub fn new() -> Passes {
+        let passes = Passes {
+            passes: Vec::new(),
+            plugin_passes: Vec::new()
+        };
+        passes
+    }
+
+    pub fn run_passes<'tcx>(&mut self, pcx: &TyCtxt<'tcx>, map: &mut MirMap<'tcx>) {
+        for pass in &mut self.plugin_passes {
+            pass.run_pass(pcx, map);
+        }
+        for pass in &mut self.passes {
+            pass.run_pass(pcx, map);
+        }
+    }
+
+    /// Pushes a built-in pass.
+    pub fn push_pass(&mut self, pass: Box<for<'a> MirMapPass<'a>>) {
+        self.passes.push(pass);
+    }
+}
+
+/// Copies the plugin passes.
+impl ::std::iter::Extend<Box<for<'a> MirMapPass<'a>>> for Passes {
+    fn extend<I: IntoIterator<Item=Box<for <'a> MirMapPass<'a>>>>(&mut self, it: I) {
+        self.plugin_passes.extend(it);
+    }
 }
diff --git a/src/librustc/session/mod.rs b/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::transform as mir_pass;
 
 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_pass::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_pass::Passes::new()),
         plugin_attributes: RefCell::new(Vec::new()),
         crate_types: RefCell::new(Vec::new()),
         dependency_formats: RefCell::new(FnvHashMap()),
diff --git a/src/librustc_driver/driver.rs b/src/librustc_driver/driver.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use rustc::dep_graph::DepGraph;
+use rustc::dep_graph::{DepGraph, DepNode};
 use rustc::front;
 use rustc::front::map as hir_map;
 use rustc_mir as mir;
@@ -561,7 +561,7 @@ 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.mir_passes.borrow_mut().extend(mir_passes);
         *sess.plugin_attributes.borrow_mut() = attributes.clone();
     }));
 
@@ -861,9 +861,20 @@ pub fn phase_3_run_analysis_passes<'tcx, F, R>(sess: &'tcx Session,
                  "MIR dump",
                  || 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 _task = tcx.dep_graph.in_task(DepNode::MirPasses);
+            let mut passes = sess.mir_passes.borrow_mut();
+            // Push all the built-in passes.
+            passes.push_pass(box mir::transform::remove_dead_blocks::RemoveDeadBlocks);
+            passes.push_pass(box mir::transform::type_check::TypeckMir);
+            passes.push_pass(box mir::transform::simplify_cfg::SimplifyCfg);
+            // Late passes
+            passes.push_pass(box mir::transform::no_landing_pads::NoLandingPads);
+            passes.push_pass(box mir::transform::remove_dead_blocks::RemoveDeadBlocks);
+            passes.push_pass(box mir::transform::erase_regions::EraseRegions);
+            // And run everything.
+            passes.run_passes(tcx, &mut mir_map);
+        });
 
         time(time_passes,
              "borrow checking",
@@ -912,9 +923,8 @@ 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.
 pub fn phase_4_translate_to_llvm<'tcx>(tcx: &TyCtxt<'tcx>,
-                                       mut mir_map: MirMap<'tcx>,
+                                       mir_map: MirMap<'tcx>,
                                        analysis: ty::CrateAnalysis)
                                        -> trans::CrateTranslation {
     let time_passes = tcx.sess.time_passes();
@@ -923,10 +933,6 @@ pub fn phase_4_translate_to_llvm<'tcx>(tcx: &TyCtxt<'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",
diff --git a/src/librustc_mir/mir_map.rs b/src/librustc_mir/mir_map.rs
@@ -20,16 +20,10 @@ extern crate syntax;
 extern crate rustc_front;
 
 use build;
-use graphviz;
-use pretty;
-use transform::{clear_dead_blocks, simplify_cfg, type_check};
-use transform::{no_landing_pads};
 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;
@@ -136,61 +130,16 @@ impl<'a, 'm, 'tcx> Visitor<'tcx> for InnerDump<'a,'m,'tcx> {
                 body: &'tcx hir::Block,
                 span: Span,
                 id: ast::NodeId) {
-        let (prefix, implicit_arg_tys) = match fk {
-            intravisit::FnKind::Closure =>
-                (format!("{}-", id), vec![closure_self_ty(&self.tcx, id, body.id)]),
-            _ =>
-                (format!(""), vec![]),
+        let implicit_arg_tys = if let intravisit::FnKind::Closure = fk {
+            vec![closure_self_ty(&self.tcx, id, body.id)]
+        } else {
+            vec![]
         };
 
         let param_env = ty::ParameterEnvironment::for_item(self.tcx, id);
-
         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) => {
-                clear_dead_blocks::ClearDeadBlocks::new().run_on_mir(&mut mir, &infcx);
-                type_check::TypeckMir::new().run_on_mir(&mut mir, &infcx);
-                no_landing_pads::NoLandingPads.run_on_mir(&mut mir, &infcx);
-                if self.tcx.sess.opts.mir_opt_level > 0 {
-                    simplify_cfg::SimplifyCfg::new().run_on_mir(&mut mir, &infcx);
-                }
-                let meta_item_list = self.attr
-                                         .iter()
-                                         .flat_map(|a| a.meta_item_list())
-                                         .flat_map(|l| l.iter());
-                for item in meta_item_list {
-                    if item.check_name("graphviz") || item.check_name("pretty") {
-                        match item.value_str() {
-                            Some(s) => {
-                                let filename = format!("{}{}", prefix, s);
-                                let result = File::create(&filename).and_then(|ref mut output| {
-                                    if item.check_name("graphviz") {
-                                        graphviz::write_mir_graphviz(&mir, output)
-                                    } else {
-                                        pretty::write_mir_pretty(&mir, output)
-                                    }
-                                });
-
-                                if let Err(e) = result {
-                                    self.tcx.sess.span_fatal(
-                                        item.span,
-                                        &format!("Error writing MIR {} results to `{}`: {}",
-                                                 item.name(), filename, e));
-                                }
-                            }
-                            None => {
-                                self.tcx.sess.span_err(
-                                    item.span,
-                                    &format!("{} attribute requires a path", item.name()));
-                            }
-                        }
-                    }
-                }
-
-                let previous = self.map.map.insert(id, mir);
-                assert!(previous.is_none());
-            }
+            Ok(mir) => assert!(self.map.map.insert(id, mir).is_none()),
             Err(ErrorReported) => {}
         }
 
diff --git a/src/librustc_mir/transform/erase_regions.rs b/src/librustc_mir/transform/erase_regions.rs
@@ -15,13 +15,7 @@
 use rustc::middle::ty::{self, TyCtxt};
 use rustc::mir::repr::*;
 use rustc::mir::visit::MutVisitor;
-use rustc::mir::mir_map::MirMap;
-
-pub fn erase_regions<'tcx>(tcx: &TyCtxt<'tcx>, mir_map: &mut MirMap<'tcx>) {
-    for (_, mir) in &mut mir_map.map {
-        EraseRegionsVisitor::new(tcx).visit_mir(mir);
-    }
-}
+use rustc::mir::transform::{MirPass, Pass};
 
 struct EraseRegionsVisitor<'a, 'tcx: 'a> {
     tcx: &'a TyCtxt<'tcx>,
@@ -123,3 +117,13 @@ impl<'a, 'tcx> MutVisitor<'tcx> for EraseRegionsVisitor<'a, 'tcx> {
         self.super_constant(constant);
     }
 }
+
+pub struct EraseRegions;
+
+impl Pass for EraseRegions {}
+
+impl<'tcx> MirPass<'tcx> for EraseRegions {
+    fn run_pass(&mut self, tcx: &TyCtxt<'tcx>, mir: &mut Mir<'tcx>) {
+        EraseRegionsVisitor::new(tcx).visit_mir(mir);
+    }
+}
diff --git a/src/librustc_mir/transform/mod.rs b/src/librustc_mir/transform/mod.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-pub mod clear_dead_blocks;
+pub mod remove_dead_blocks;
 pub mod simplify_cfg;
 pub mod erase_regions;
 pub mod no_landing_pads;
diff --git a/src/librustc_mir/transform/no_landing_pads.rs b/src/librustc_mir/transform/no_landing_pads.rs
@@ -11,10 +11,10 @@
 //! This pass removes the unwind branch of all the terminators when the no-landing-pads option is
 //! specified.
 
-use rustc::middle::infer;
+use rustc::middle::ty::TyCtxt;
 use rustc::mir::repr::*;
 use rustc::mir::visit::MutVisitor;
-use rustc::mir::transform::MirPass;
+use rustc::mir::transform::{Pass, MirPass};
 
 pub struct NoLandingPads;
 
@@ -40,11 +40,12 @@ impl<'tcx> MutVisitor<'tcx> for NoLandingPads {
     }
 }
 
-impl MirPass for NoLandingPads {
-    fn run_on_mir<'a, 'tcx>(&mut self, mir: &mut Mir<'tcx>,
-                            infcx: &infer::InferCtxt<'a, 'tcx>) {
-        if infcx.tcx.sess.no_landing_pads() {
+impl<'tcx> MirPass<'tcx> for NoLandingPads {
+    fn run_pass(&mut self, tcx: &TyCtxt<'tcx>, mir: &mut Mir<'tcx>) {
+        if tcx.sess.no_landing_pads() {
             self.visit_mir(mir);
         }
     }
 }
+
+impl Pass for NoLandingPads {}
diff --git a/src/librustc_mir/transform/remove_dead_blocks.rs b/src/librustc_mir/transform/remove_dead_blocks.rs
diff --git a/src/librustc_mir/transform/simplify_cfg.rs b/src/librustc_mir/transform/simplify_cfg.rs
diff --git a/src/librustc_mir/transform/type_check.rs b/src/librustc_mir/transform/type_check.rs
diff --git a/src/librustc_plugin/registry.rs b/src/librustc_plugin/registry.rs
diff --git a/src/test/auxiliary/dummy_mir_pass.rs b/src/test/auxiliary/dummy_mir_pass.rs

Original file line number	Diff line number	Diff line change
`@@ -207,7 +207,7 @@ impl Debug for BasicBlock {`
`207`	`207`	`}`
`208`	`208`
`209`	`209`	`///////////////////////////////////////////////////////////////////////////`
`210`		`-// BasicBlock and Terminator`
	`210`	`+// BasicBlockData and Terminator`
`211`	`211`
`212`	`212`	`#[derive(Clone, Debug, RustcEncodable, RustcDecodable)]`
`213`	`213`	`pub struct BasicBlockData<'tcx> {`
Original file line number	Diff line number	Diff line change
`@@ -11,10 +11,10 @@`
`11`	`11`	`//! This pass removes the unwind branch of all the terminators when the no-landing-pads option is`
`12`	`12`	`//! specified.`
`13`	`13`
`14`		`-use rustc::middle::infer;`
	`14`	`+use rustc::middle::ty::TyCtxt;`
`15`	`15`	`use rustc::mir::repr::*;`
`16`	`16`	`use rustc::mir::visit::MutVisitor;`
`17`		`-use rustc::mir::transform::MirPass;`
	`17`	`+use rustc::mir::transform::{Pass, MirPass};`
`18`	`18`
`19`	`19`	`pub struct NoLandingPads;`
`20`	`20`
`@@ -40,11 +40,12 @@ impl<'tcx> MutVisitor<'tcx> for NoLandingPads {`
`40`	`40`	`}`
`41`	`41`	`}`
`42`	`42`
`43`		`-impl MirPass for NoLandingPads {`
`44`		`- fn run_on_mir<'a, 'tcx>(&mut self, mir: &mut Mir<'tcx>,`
`45`		`- infcx: &infer::InferCtxt<'a, 'tcx>) {`
`46`		`- if infcx.tcx.sess.no_landing_pads() {`
	`43`	`+impl<'tcx> MirPass<'tcx> for NoLandingPads {`
	`44`	`+ fn run_pass(&mut self, tcx: &TyCtxt<'tcx>, mir: &mut Mir<'tcx>) {`
	`45`	`+ if tcx.sess.no_landing_pads() {`
`47`	`46`	`self.visit_mir(mir);`
`48`	`47`	`}`
`49`	`48`	`}`
`50`	`49`	`}`
	`50`	`+`
	`51`	`+impl Pass for NoLandingPads {}`