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")]`
21 extern crate rustc_front;
30 use self::rustc::middle::infer;
31 use self::rustc::middle::region::CodeExtentData;
32 use self::rustc::middle::ty::{self, Ty};
33 use self::rustc::util::common::ErrorReported;
34 use self::rustc::util::nodemap::NodeMap;
35 use self::rustc_front::hir;
36 use self::rustc_front::visit;
37 use self::syntax::ast;
38 use self::syntax::attr::AttrMetaMethods;
39 use self::syntax::codemap::Span;
41 pub type MirMap<'tcx> = NodeMap<Mir<'tcx>>;
43 pub fn build_mir_for_crate<'tcx>(tcx: &ty::ctxt<'tcx>) -> MirMap<'tcx> {
44 let mut map = NodeMap();
46 let mut dump = OuterDump {
50 visit::walk_crate(&mut dump, tcx.map.krate());
55 ///////////////////////////////////////////////////////////////////////////
56 // OuterDump -- walks a crate, looking for fn items and methods to build MIR from
58 struct OuterDump<'a, 'tcx: 'a> {
59 tcx: &'a ty::ctxt<'tcx>,
60 map: &'a mut MirMap<'tcx>,
63 impl<'a, 'tcx> OuterDump<'a, 'tcx> {
64 fn visit_mir<OP>(&mut self, attributes: &'a [ast::Attribute], mut walk_op: OP)
65 where OP: for<'m> FnMut(&mut InnerDump<'a, 'm, 'tcx>)
67 let mut closure_dump = InnerDump {
72 for attr in attributes {
73 if attr.check_name("rustc_mir") {
74 closure_dump.attr = Some(attr);
77 walk_op(&mut closure_dump);
82 impl<'a, 'tcx> visit::Visitor<'tcx> for OuterDump<'a, 'tcx> {
83 fn visit_item(&mut self, item: &'tcx hir::Item) {
84 self.visit_mir(&item.attrs, |c| visit::walk_item(c, item));
85 visit::walk_item(self, item);
88 fn visit_trait_item(&mut self, trait_item: &'tcx hir::TraitItem) {
89 match trait_item.node {
90 hir::MethodTraitItem(_, Some(_)) => {
91 self.visit_mir(&trait_item.attrs, |c| visit::walk_trait_item(c, trait_item));
93 hir::MethodTraitItem(_, None) |
94 hir::ConstTraitItem(..) |
95 hir::TypeTraitItem(..) => {}
97 visit::walk_trait_item(self, trait_item);
100 fn visit_impl_item(&mut self, impl_item: &'tcx hir::ImplItem) {
101 match impl_item.node {
102 hir::MethodImplItem(..) => {
103 self.visit_mir(&impl_item.attrs, |c| visit::walk_impl_item(c, impl_item));
105 hir::ConstImplItem(..) | hir::TypeImplItem(..) => {}
107 visit::walk_impl_item(self, impl_item);
111 ///////////////////////////////////////////////////////////////////////////
112 // InnerDump -- dumps MIR for a single fn and its contained closures
114 struct InnerDump<'a, 'm, 'tcx: 'a + 'm> {
115 tcx: &'a ty::ctxt<'tcx>,
116 map: &'m mut MirMap<'tcx>,
117 attr: Option<&'a ast::Attribute>,
120 impl<'a, 'm, 'tcx> visit::Visitor<'tcx> for InnerDump<'a,'m,'tcx> {
121 fn visit_item(&mut self, _: &'tcx hir::Item) {
122 // ignore nested items; they need their own graphviz annotation
125 fn visit_trait_item(&mut self, _: &'tcx hir::TraitItem) {
126 // ignore nested items; they need their own graphviz annotation
129 fn visit_impl_item(&mut self, _: &'tcx hir::ImplItem) {
130 // ignore nested items; they need their own graphviz annotation
133 fn visit_fn(&mut self,
134 fk: visit::FnKind<'tcx>,
135 decl: &'tcx hir::FnDecl,
136 body: &'tcx hir::Block,
139 let (prefix, implicit_arg_tys) = match fk {
140 visit::FnKind::Closure =>
141 (format!("{}-", id), vec![closure_self_ty(&self.tcx, id, body.id)]),
143 (format!(""), vec![]),
146 let param_env = ty::ParameterEnvironment::for_item(self.tcx, id);
148 let infcx = infer::new_infer_ctxt(self.tcx, &self.tcx.tables, Some(param_env), true);
150 match build_mir(Cx::new(&infcx), implicit_arg_tys, id, span, decl, body) {
152 simplify_cfg::SimplifyCfg::new().run_on_mir(&mut mir);
154 let meta_item_list = self.attr
156 .flat_map(|a| a.meta_item_list())
157 .flat_map(|l| l.iter());
158 for item in meta_item_list {
159 if item.check_name("graphviz") {
160 match item.value_str() {
163 File::create(format!("{}{}", prefix, s))
164 .and_then(|ref mut output| dot::render(&mir, output))
168 self.tcx.sess.span_fatal(
170 &format!("Error writing graphviz \
171 results to `{}`: {}",
177 self.tcx.sess.span_err(
179 "graphviz attribute requires a path");
185 let previous = self.map.insert(id, mir);
186 assert!(previous.is_none());
188 Err(ErrorReported) => {}
191 visit::walk_fn(self, fk, decl, body, span);
195 fn build_mir<'a,'tcx:'a>(cx: Cx<'a,'tcx>,
196 implicit_arg_tys: Vec<Ty<'tcx>>,
199 decl: &'tcx hir::FnDecl,
200 body: &'tcx hir::Block)
201 -> Result<Mir<'tcx>, ErrorReported> {
202 // fetch the fully liberated fn signature (that is, all bound
203 // types/lifetimes replaced)
204 let fn_sig = match cx.tcx().tables.borrow().liberated_fn_sigs.get(&fn_id) {
205 Some(f) => f.clone(),
207 cx.tcx().sess.span_bug(span,
208 &format!("no liberated fn sig for {:?}", fn_id));
216 .map(|(index, arg)| {
217 (fn_sig.inputs[index], &*arg.pat)
221 let parameter_scope =
222 cx.tcx().region_maps.lookup_code_extent(
223 CodeExtentData::ParameterScope { fn_id: fn_id, body_id: body.id });
224 Ok(build::construct(cx,
233 fn closure_self_ty<'a, 'tcx>(tcx: &ty::ctxt<'tcx>,
234 closure_expr_id: ast::NodeId,
235 body_id: ast::NodeId)
237 let closure_ty = tcx.node_id_to_type(closure_expr_id);
239 // We're just hard-coding the idea that the signature will be
240 // &self or &mut self and hence will have a bound region with
242 let region = ty::Region::ReFree(ty::FreeRegion {
243 scope: tcx.region_maps.item_extent(body_id),
244 bound_region: ty::BoundRegion::BrAnon(0),
246 let region = tcx.mk_region(region);
248 match tcx.closure_kind(tcx.map.local_def_id(closure_expr_id)) {
249 ty::ClosureKind::FnClosureKind =>
251 ty::TypeAndMut { ty: closure_ty,
252 mutbl: hir::MutImmutable }),
253 ty::ClosureKind::FnMutClosureKind =>
255 ty::TypeAndMut { ty: closure_ty,
256 mutbl: hir::MutMutable }),
257 ty::ClosureKind::FnOnceClosureKind =>