1 use rustc::hir::def_id::{DefId, LOCAL_CRATE};
2 use rustc::hir::def::CtorKind;
4 use rustc::mir::visit::Visitor;
5 use rustc::ty::{self, TyCtxt};
6 use rustc_data_structures::fx::FxHashMap;
7 use rustc_data_structures::indexed_vec::Idx;
9 use std::fmt::Write as _;
11 use std::io::{self, Write};
12 use std::path::{Path, PathBuf};
13 use super::graphviz::write_mir_fn_graphviz;
14 use crate::transform::MirSource;
16 const INDENT: &str = " ";
17 /// Alignment for lining up comments following MIR statements
18 pub(crate) const ALIGN: usize = 40;
20 /// An indication of where we are in the control flow graph. Used for printing
21 /// extra information in `dump_mir`
23 /// We have not started dumping the control flow graph, but we are about to.
26 /// We just finished dumping the control flow graph. This is right before EOF
29 /// We are about to start dumping the given basic block.
30 BeforeBlock(BasicBlock),
32 /// We are just about to dump the given statement or terminator.
33 BeforeLocation(Location),
35 /// We just dumped the given statement or terminator.
36 AfterLocation(Location),
38 /// We just dumped the terminator for a block but not the closing `}`.
39 AfterTerminator(BasicBlock),
42 /// If the session is properly configured, dumps a human-readable
43 /// representation of the mir into:
46 /// rustc.node<node_id>.<pass_num>.<pass_name>.<disambiguator>
49 /// Output from this function is controlled by passing `-Z dump-mir=<filter>`,
50 /// where `<filter>` takes the following forms:
52 /// - `all` -- dump MIR for all fns, all passes, all everything
53 /// - a filter defined by a set of substrings combined with `&` and `|`
54 /// (`&` has higher precedence). At least one of the `|`-separated groups
55 /// must match; an `|`-separated group matches if all of its `&`-separated
56 /// substrings are matched.
60 /// - `nll` == match if `nll` appears in the name
61 /// - `foo & nll` == match if `foo` and `nll` both appear in the name
62 /// - `foo & nll | typeck` == match if `foo` and `nll` both appear in the name
63 /// or `typeck` appears in the name.
64 /// - `foo & nll | bar & typeck` == match if `foo` and `nll` both appear in the name
65 /// or `typeck` and `bar` both appear in the name.
66 pub fn dump_mir<'a, 'gcx, 'tcx, F>(
67 tcx: TyCtxt<'a, 'gcx, 'tcx>,
68 pass_num: Option<&dyn Display>,
70 disambiguator: &dyn Display,
71 source: MirSource<'tcx>,
75 F: FnMut(PassWhere, &mut dyn Write) -> io::Result<()>,
77 if !dump_enabled(tcx, pass_name, source) {
81 let node_path = ty::print::with_forced_impl_filename_line(|| {
82 // see notes on #41697 below
83 tcx.def_path_str(source.def_id())
85 dump_matched_mir_node(
97 pub fn dump_enabled<'a, 'gcx, 'tcx>(
98 tcx: TyCtxt<'a, 'gcx, 'tcx>,
100 source: MirSource<'tcx>,
102 let filters = match tcx.sess.opts.debugging_opts.dump_mir {
103 None => return false,
104 Some(ref filters) => filters,
106 let node_path = ty::print::with_forced_impl_filename_line(|| {
107 // see notes on #41697 below
108 tcx.def_path_str(source.def_id())
110 filters.split('|').any(|or_filter| {
111 or_filter.split('&').all(|and_filter| {
112 and_filter == "all" || pass_name.contains(and_filter) || node_path.contains(and_filter)
117 // #41697 -- we use `with_forced_impl_filename_line()` because
118 // `def_path_str()` would otherwise trigger `type_of`, and this can
119 // run while we are already attempting to evaluate `type_of`.
121 fn dump_matched_mir_node<'a, 'gcx, 'tcx, F>(
122 tcx: TyCtxt<'a, 'gcx, 'tcx>,
123 pass_num: Option<&dyn Display>,
126 disambiguator: &dyn Display,
127 source: MirSource<'tcx>,
131 F: FnMut(PassWhere, &mut dyn Write) -> io::Result<()>,
133 let _: io::Result<()> = try {
134 let mut file = create_dump_file(tcx, "mir", pass_num, pass_name, disambiguator, source)?;
135 writeln!(file, "// MIR for `{}`", node_path)?;
136 writeln!(file, "// source = {:?}", source)?;
137 writeln!(file, "// pass_name = {}", pass_name)?;
138 writeln!(file, "// disambiguator = {}", disambiguator)?;
139 if let Some(ref layout) = mir.generator_layout {
140 writeln!(file, "// generator_layout = {:?}", layout)?;
143 extra_data(PassWhere::BeforeCFG, &mut file)?;
144 write_user_type_annotations(mir, &mut file)?;
145 write_mir_fn(tcx, source, mir, &mut extra_data, &mut file)?;
146 extra_data(PassWhere::AfterCFG, &mut file)?;
149 if tcx.sess.opts.debugging_opts.dump_mir_graphviz {
150 let _: io::Result<()> = try {
152 create_dump_file(tcx, "dot", pass_num, pass_name, disambiguator, source)?;
153 write_mir_fn_graphviz(tcx, source.def_id(), mir, &mut file)?;
158 /// Returns the path to the filename where we should dump a given MIR.
159 /// Also used by other bits of code (e.g., NLL inference) that dump
160 /// graphviz data or other things.
162 tcx: TyCtxt<'_, '_, '_>,
164 pass_num: Option<&dyn Display>,
166 disambiguator: &dyn Display,
167 source: MirSource<'tcx>,
169 let promotion_id = match source.promoted {
170 Some(id) => format!("-{:?}", id),
171 None => String::new(),
174 let pass_num = if tcx.sess.opts.debugging_opts.dump_mir_exclude_pass_number {
178 None => ".-------".to_string(),
179 Some(pass_num) => format!(".{}", pass_num),
183 let mut file_path = PathBuf::new();
184 file_path.push(Path::new(&tcx.sess.opts.debugging_opts.dump_mir_dir));
187 .def_path(source.def_id())
188 .to_filename_friendly_no_crate();
189 // All drop shims have the same DefId, so we have to add the type
190 // to get unique file names.
191 let shim_disambiguator = match source.instance {
192 ty::InstanceDef::DropGlue(_, Some(ty)) => {
193 // Unfortunately, pretty-printed typed are not very filename-friendly.
194 // We dome some filtering.
195 let mut s = ".".to_owned();
196 s.extend(ty.to_string()
198 .filter_map(|c| match c {
200 ':' | '<' | '>' => Some('_'),
208 let file_name = format!(
209 "rustc.{}{}{}{}.{}.{}.{}",
219 file_path.push(&file_name);
224 /// Attempts to open a file where we should dump a given MIR or other
225 /// bit of MIR-related data. Used by `mir-dump`, but also by other
226 /// bits of code (e.g., NLL inference) that dump graphviz data or
227 /// other things, and hence takes the extension as an argument.
228 pub(crate) fn create_dump_file(
229 tcx: TyCtxt<'_, '_, '_>,
231 pass_num: Option<&dyn Display>,
233 disambiguator: &dyn Display,
234 source: MirSource<'tcx>,
235 ) -> io::Result<fs::File> {
236 let file_path = dump_path(tcx, extension, pass_num, pass_name, disambiguator, source);
237 if let Some(parent) = file_path.parent() {
238 fs::create_dir_all(parent)?;
240 fs::File::create(&file_path)
243 /// Write out a human-readable textual representation for the given MIR.
244 pub fn write_mir_pretty<'a, 'gcx, 'tcx>(
245 tcx: TyCtxt<'a, 'gcx, 'tcx>,
246 single: Option<DefId>,
248 ) -> io::Result<()> {
251 "// WARNING: This output format is intended for human consumers only"
255 "// and is subject to change without notice. Knock yourself out."
258 let mut first = true;
259 for def_id in dump_mir_def_ids(tcx, single) {
260 let mir = &tcx.optimized_mir(def_id);
265 // Put empty lines between all items
269 write_mir_fn(tcx, MirSource::item(def_id), mir, &mut |_, _| Ok(()), w)?;
271 for (i, mir) in mir.promoted.iter_enumerated() {
273 let src = MirSource {
274 instance: ty::InstanceDef::Item(def_id),
277 write_mir_fn(tcx, src, mir, &mut |_, _| Ok(()), w)?;
283 pub fn write_mir_fn<'a, 'gcx, 'tcx, F>(
284 tcx: TyCtxt<'a, 'gcx, 'tcx>,
285 src: MirSource<'tcx>,
291 F: FnMut(PassWhere, &mut dyn Write) -> io::Result<()>,
293 write_mir_intro(tcx, src, mir, w)?;
294 for block in mir.basic_blocks().indices() {
295 extra_data(PassWhere::BeforeBlock(block), w)?;
296 write_basic_block(tcx, block, mir, extra_data, w)?;
297 if block.index() + 1 != mir.basic_blocks().len() {
306 /// Write out a human-readable textual representation for the given basic block.
307 pub fn write_basic_block<'cx, 'gcx, 'tcx, F>(
308 tcx: TyCtxt<'cx, 'gcx, 'tcx>,
315 F: FnMut(PassWhere, &mut dyn Write) -> io::Result<()>,
317 let data = &mir[block];
319 // Basic block label at the top.
320 let cleanup_text = if data.is_cleanup { " (cleanup)" } else { "" };
321 writeln!(w, "{}{:?}{}: {{", INDENT, block, cleanup_text)?;
323 // List of statements in the middle.
324 let mut current_location = Location {
328 for statement in &data.statements {
329 extra_data(PassWhere::BeforeLocation(current_location), w)?;
330 let indented_mir = format!("{0}{0}{1:?};", INDENT, statement);
336 comment(tcx, statement.source_info),
340 write_extra(tcx, w, |visitor| {
341 visitor.visit_statement(current_location.block, statement, current_location);
344 extra_data(PassWhere::AfterLocation(current_location), w)?;
346 current_location.statement_index += 1;
349 // Terminator at the bottom.
350 extra_data(PassWhere::BeforeLocation(current_location), w)?;
351 let indented_terminator = format!("{0}{0}{1:?};", INDENT, data.terminator().kind);
357 comment(tcx, data.terminator().source_info),
361 write_extra(tcx, w, |visitor| {
362 visitor.visit_terminator(current_location.block, data.terminator(), current_location);
365 extra_data(PassWhere::AfterLocation(current_location), w)?;
366 extra_data(PassWhere::AfterTerminator(block), w)?;
368 writeln!(w, "{}}}", INDENT)
371 /// After we print the main statement, we sometimes dump extra
372 /// information. There's often a lot of little things "nuzzled up" in
374 fn write_extra<'cx, 'gcx, 'tcx, F>(
375 tcx: TyCtxt<'cx, 'gcx, 'tcx>,
376 write: &mut dyn Write,
380 F: FnMut(&mut ExtraComments<'cx, 'gcx, 'tcx>),
382 let mut extra_comments = ExtraComments {
386 visit_op(&mut extra_comments);
387 for comment in extra_comments.comments {
388 writeln!(write, "{:A$} // {}", "", comment, A = ALIGN)?;
393 struct ExtraComments<'cx, 'gcx: 'tcx, 'tcx: 'cx> {
394 _tcx: TyCtxt<'cx, 'gcx, 'tcx>, // don't need it now, but bet we will soon
395 comments: Vec<String>,
398 impl<'cx, 'gcx, 'tcx> ExtraComments<'cx, 'gcx, 'tcx> {
399 fn push(&mut self, lines: &str) {
400 for line in lines.split('\n') {
401 self.comments.push(line.to_string());
406 impl<'cx, 'gcx, 'tcx> Visitor<'tcx> for ExtraComments<'cx, 'gcx, 'tcx> {
407 fn visit_constant(&mut self, constant: &Constant<'tcx>, location: Location) {
408 self.super_constant(constant, location);
409 let Constant { span, ty, user_ty, literal } = constant;
410 self.push("mir::Constant");
411 self.push(&format!("+ span: {:?}", span));
412 self.push(&format!("+ ty: {:?}", ty));
413 if let Some(user_ty) = user_ty {
414 self.push(&format!("+ user_ty: {:?}", user_ty));
416 self.push(&format!("+ literal: {:?}", literal));
419 fn visit_const(&mut self, constant: &&'tcx ty::Const<'tcx>, _: Location) {
420 self.super_const(constant);
421 let ty::Const { ty, val, .. } = constant;
422 self.push("ty::Const");
423 self.push(&format!("+ ty: {:?}", ty));
424 self.push(&format!("+ val: {:?}", val));
427 fn visit_rvalue(&mut self, rvalue: &Rvalue<'tcx>, location: Location) {
428 self.super_rvalue(rvalue, location);
430 Rvalue::Aggregate(kind, _) => match **kind {
431 AggregateKind::Closure(def_id, substs) => {
432 self.push("closure");
433 self.push(&format!("+ def_id: {:?}", def_id));
434 self.push(&format!("+ substs: {:#?}", substs));
437 AggregateKind::Generator(def_id, substs, movability) => {
438 self.push("generator");
439 self.push(&format!("+ def_id: {:?}", def_id));
440 self.push(&format!("+ substs: {:#?}", substs));
441 self.push(&format!("+ movability: {:?}", movability));
444 AggregateKind::Adt(_, _, _, Some(user_ty), _) => {
446 self.push(&format!("+ user_ty: {:?}", user_ty));
457 fn comment(tcx: TyCtxt<'_, '_, '_>, SourceInfo { span, scope }: SourceInfo) -> String {
461 tcx.sess.source_map().span_to_string(span)
465 /// Prints user-defined variables in a scope tree.
467 /// Returns the total number of variables printed.
469 tcx: TyCtxt<'_, '_, '_>,
471 scope_tree: &FxHashMap<SourceScope, Vec<SourceScope>>,
475 ) -> io::Result<()> {
476 let indent = depth * INDENT.len();
478 let children = match scope_tree.get(&parent) {
479 Some(children) => children,
480 None => return Ok(()),
483 for &child in children {
484 let data = &mir.source_scopes[child];
485 assert_eq!(data.parent_scope, Some(parent));
486 writeln!(w, "{0:1$}scope {2} {{", "", indent, child.index())?;
488 // User variable types (including the user's name in a comment).
489 for local in mir.vars_iter() {
490 let var = &mir.local_decls[local];
491 let (name, source_info) = if var.source_info.scope == child {
492 (var.name.unwrap(), var.source_info)
494 // Not a variable or not declared in this scope.
498 let mut_str = if var.mutability == Mutability::Mut {
504 let indent = indent + INDENT.len();
505 let mut indented_var = format!(
506 "{0:1$}let {2}{3:?}: {4:?}",
513 for user_ty in var.user_ty.projections() {
514 write!(indented_var, " as {:?}", user_ty).unwrap();
516 indented_var.push_str(";");
519 "{0:1$} // \"{2}\" in {3}",
523 comment(tcx, source_info)
527 write_scope_tree(tcx, mir, scope_tree, w, child, depth + 1)?;
529 writeln!(w, "{0:1$}}}", "", depth * INDENT.len())?;
535 /// Write out a human-readable textual representation of the MIR's `fn` type and the types of its
536 /// local variables (both user-defined bindings and compiler temporaries).
537 pub fn write_mir_intro<'a, 'gcx, 'tcx>(
538 tcx: TyCtxt<'a, 'gcx, 'tcx>,
539 src: MirSource<'tcx>,
542 ) -> io::Result<()> {
543 write_mir_sig(tcx, src, mir, w)?;
546 // construct a scope tree and write it out
547 let mut scope_tree: FxHashMap<SourceScope, Vec<SourceScope>> = Default::default();
548 for (index, scope_data) in mir.source_scopes.iter().enumerate() {
549 if let Some(parent) = scope_data.parent_scope {
553 .push(SourceScope::new(index));
555 // Only the argument scope has no parent, because it's the root.
556 assert_eq!(index, OUTERMOST_SOURCE_SCOPE.index());
560 // Print return place
561 let indented_retptr = format!("{}let mut {:?}: {};",
564 mir.local_decls[RETURN_PLACE].ty);
565 writeln!(w, "{0:1$} // return place",
569 write_scope_tree(tcx, mir, &scope_tree, w, OUTERMOST_SOURCE_SCOPE, 1)?;
571 write_temp_decls(mir, w)?;
573 // Add an empty line before the first block is printed.
580 tcx: TyCtxt<'_, '_, '_>,
581 src: MirSource<'tcx>,
584 ) -> io::Result<()> {
585 use rustc::hir::def::Def;
587 trace!("write_mir_sig: {:?}", src.instance);
588 let descr = tcx.describe_def(src.def_id());
589 let is_function = match descr {
590 Some(Def::Fn(_)) | Some(Def::Method(_)) | Some(Def::Variant(..)) |
591 Some(Def::StructCtor(_, CtorKind::Fn)) => true,
592 _ => tcx.is_closure(src.def_id()),
594 match (descr, src.promoted) {
595 (_, Some(i)) => write!(w, "{:?} in ", i)?,
596 (Some(Def::StructCtor(..)), _) => write!(w, "struct ")?,
597 (Some(Def::Const(_)), _)
598 | (Some(Def::AssociatedConst(_)), _) => write!(w, "const ")?,
599 (Some(Def::Static(_, /*is_mutbl*/false)), _) => write!(w, "static ")?,
600 (Some(Def::Static(_, /*is_mutbl*/true)), _) => write!(w, "static mut ")?,
601 (_, _) if is_function => write!(w, "fn ")?,
602 (None, _) => {}, // things like anon const, not an item
603 _ => bug!("Unexpected def description {:?}", descr),
606 ty::print::with_forced_impl_filename_line(|| {
607 // see notes on #41697 elsewhere
608 write!(w, " {}", tcx.def_path_str(src.def_id()))
611 if src.promoted.is_none() && is_function {
614 // fn argument types.
615 for (i, arg) in mir.args_iter().enumerate() {
619 write!(w, "{:?}: {}", Place::Base(PlaceBase::Local(arg)), mir.local_decls[arg].ty)?;
622 write!(w, ") -> {}", mir.return_ty())?;
624 assert_eq!(mir.arg_count, 0);
625 write!(w, ": {} =", mir.return_ty())?;
628 if let Some(yield_ty) = mir.yield_ty {
630 writeln!(w, "yields {}", yield_ty)?;
634 // Next thing that gets printed is the opening {
639 fn write_temp_decls(mir: &Mir<'_>, w: &mut dyn Write) -> io::Result<()> {
640 // Compiler-introduced temporary types.
641 for temp in mir.temps_iter() {
646 if mir.local_decls[temp].mutability == Mutability::Mut {"mut "} else {""},
648 mir.local_decls[temp].ty
655 fn write_user_type_annotations(mir: &Mir<'_>, w: &mut dyn Write) -> io::Result<()> {
656 if !mir.user_type_annotations.is_empty() {
657 writeln!(w, "| User Type Annotations")?;
659 for (index, annotation) in mir.user_type_annotations.iter_enumerated() {
660 writeln!(w, "| {:?}: {:?} at {:?}", index.index(), annotation.user_ty, annotation.span)?;
662 if !mir.user_type_annotations.is_empty() {
668 pub fn dump_mir_def_ids(tcx: TyCtxt<'_, '_, '_>, single: Option<DefId>) -> Vec<DefId> {
669 if let Some(i) = single {
672 tcx.mir_keys(LOCAL_CRATE).iter().cloned().collect()