1 // Copyright 2015 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
11 //! An experimental pass that scources for `#[rustc_mir]` attributes,
12 //! builds the resulting MIR, and dumps it out into a file for inspection.
14 //! The attribute formats that are currently accepted are:
16 //! - `#[rustc_mir(graphviz="file.gv")]`
17 //! - `#[rustc_mir(pretty="file.mir")]`
20 extern crate rustc_front;
23 use rustc::dep_graph::DepNode;
24 use rustc::mir::repr::Mir;
28 use rustc::mir::mir_map::MirMap;
29 use rustc::middle::infer;
30 use rustc::middle::region::CodeExtentData;
31 use rustc::middle::traits::ProjectionMode;
32 use rustc::middle::ty::{self, Ty, TyCtxt};
33 use rustc::util::common::ErrorReported;
34 use rustc::util::nodemap::NodeMap;
36 use rustc_front::intravisit::{self, Visitor};
39 use syntax::attr::AttrMetaMethods;
40 use syntax::codemap::Span;
42 pub fn build_mir_for_crate<'tcx>(tcx: &TyCtxt<'tcx>) -> MirMap<'tcx> {
43 let mut map = MirMap {
47 let mut dump = OuterDump {
51 tcx.visit_all_items_in_krate(DepNode::MirMapConstruction, &mut dump);
56 ///////////////////////////////////////////////////////////////////////////
57 // OuterDump -- walks a crate, looking for fn items and methods to build MIR from
59 struct OuterDump<'a, 'tcx: 'a> {
60 tcx: &'a TyCtxt<'tcx>,
61 map: &'a mut MirMap<'tcx>,
64 impl<'a, 'tcx> OuterDump<'a, 'tcx> {
65 fn visit_mir<OP>(&mut self, attributes: &'a [ast::Attribute], mut walk_op: OP)
66 where OP: for<'m> FnMut(&mut InnerDump<'a, 'm, 'tcx>)
68 let mut closure_dump = InnerDump {
73 for attr in attributes {
74 if attr.check_name("rustc_mir") {
75 closure_dump.attr = Some(attr);
78 walk_op(&mut closure_dump);
83 impl<'a, 'tcx> Visitor<'tcx> for OuterDump<'a, 'tcx> {
84 fn visit_item(&mut self, item: &'tcx hir::Item) {
85 self.visit_mir(&item.attrs, |c| intravisit::walk_item(c, item));
86 intravisit::walk_item(self, item);
89 fn visit_trait_item(&mut self, trait_item: &'tcx hir::TraitItem) {
90 match trait_item.node {
91 hir::MethodTraitItem(_, Some(_)) => {
92 self.visit_mir(&trait_item.attrs, |c| intravisit::walk_trait_item(c, trait_item));
94 hir::MethodTraitItem(_, None) |
95 hir::ConstTraitItem(..) |
96 hir::TypeTraitItem(..) => {}
98 intravisit::walk_trait_item(self, trait_item);
101 fn visit_impl_item(&mut self, impl_item: &'tcx hir::ImplItem) {
102 match impl_item.node {
103 hir::ImplItemKind::Method(..) => {
104 self.visit_mir(&impl_item.attrs, |c| intravisit::walk_impl_item(c, impl_item));
106 hir::ImplItemKind::Const(..) | hir::ImplItemKind::Type(..) => {}
108 intravisit::walk_impl_item(self, impl_item);
112 ///////////////////////////////////////////////////////////////////////////
113 // InnerDump -- dumps MIR for a single fn and its contained closures
115 struct InnerDump<'a, 'm, 'tcx: 'a + 'm> {
116 tcx: &'a TyCtxt<'tcx>,
117 map: &'m mut MirMap<'tcx>,
118 attr: Option<&'a ast::Attribute>,
121 impl<'a, 'm, 'tcx> Visitor<'tcx> for InnerDump<'a,'m,'tcx> {
122 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem) {
123 // ignore methods; the outer dump will call us for them independently
126 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem) {
127 // ignore methods; the outer dump will call us for them independently
130 fn visit_fn(&mut self,
131 fk: intravisit::FnKind<'tcx>,
132 decl: &'tcx hir::FnDecl,
133 body: &'tcx hir::Block,
136 let implicit_arg_tys = if let intravisit::FnKind::Closure(..) = fk {
137 vec![closure_self_ty(&self.tcx, id, body.id)]
142 let param_env = ty::ParameterEnvironment::for_item(self.tcx, id);
143 let infcx = infer::new_infer_ctxt(self.tcx,
146 ProjectionMode::AnyFinal);
148 match build_mir(Cx::new(&infcx), implicit_arg_tys, id, span, decl, body) {
149 Ok(mir) => assert!(self.map.map.insert(id, mir).is_none()),
150 Err(ErrorReported) => {}
153 intravisit::walk_fn(self, fk, decl, body, span);
157 fn build_mir<'a,'tcx:'a>(cx: Cx<'a,'tcx>,
158 implicit_arg_tys: Vec<Ty<'tcx>>,
161 decl: &'tcx hir::FnDecl,
162 body: &'tcx hir::Block)
163 -> Result<Mir<'tcx>, ErrorReported> {
164 // fetch the fully liberated fn signature (that is, all bound
165 // types/lifetimes replaced)
166 let fn_sig = match cx.tcx().tables.borrow().liberated_fn_sigs.get(&fn_id) {
167 Some(f) => f.clone(),
169 cx.tcx().sess.span_bug(span,
170 &format!("no liberated fn sig for {:?}", fn_id));
178 .map(|(index, arg)| {
179 (fn_sig.inputs[index], &*arg.pat)
183 let parameter_scope =
184 cx.tcx().region_maps.lookup_code_extent(
185 CodeExtentData::ParameterScope { fn_id: fn_id, body_id: body.id });
186 let (mut mir, scope_auxiliary) =
195 match cx.tcx().node_id_to_type(fn_id).sty {
196 ty::TyFnDef(_, _, f) if f.abi == Abi::RustCall => {
197 // RustCall pseudo-ABI untuples the last argument.
198 if let Some(arg_decl) = mir.arg_decls.last_mut() {
199 arg_decl.spread = true;
205 pretty::dump_mir(cx.tcx(),
210 Some(&scope_auxiliary));
215 fn closure_self_ty<'a, 'tcx>(tcx: &TyCtxt<'tcx>,
216 closure_expr_id: ast::NodeId,
217 body_id: ast::NodeId)
219 let closure_ty = tcx.node_id_to_type(closure_expr_id);
221 // We're just hard-coding the idea that the signature will be
222 // &self or &mut self and hence will have a bound region with
224 let region = ty::Region::ReFree(ty::FreeRegion {
225 scope: tcx.region_maps.item_extent(body_id),
226 bound_region: ty::BoundRegion::BrAnon(0),
228 let region = tcx.mk_region(region);
230 match tcx.closure_kind(tcx.map.local_def_id(closure_expr_id)) {
231 ty::ClosureKind::Fn =>
233 ty::TypeAndMut { ty: closure_ty,
234 mutbl: hir::MutImmutable }),
235 ty::ClosureKind::FnMut =>
237 ty::TypeAndMut { ty: closure_ty,
238 mutbl: hir::MutMutable }),
239 ty::ClosureKind::FnOnce =>