compiler/rustc_middle/src/mir/pretty.rs

   1 use std::collections::BTreeSet;
   2 use std::fmt::Display;
   3 use std::fmt::Write as _;
   4 use std::fs;
   5 use std::io::{self, Write};
   6 use std::path::{Path, PathBuf};
   7
   8 use super::graphviz::write_mir_fn_graphviz;
   9 use super::spanview::write_mir_fn_spanview;
  10 use either::Either;
  11 use rustc_data_structures::fx::FxHashMap;
  12 use rustc_hir::def_id::DefId;
  13 use rustc_index::vec::Idx;
  14 use rustc_middle::mir::interpret::{
  15     read_target_uint, AllocId, Allocation, ConstValue, GlobalAlloc, Pointer, Provenance,
  16 };
  17 use rustc_middle::mir::visit::Visitor;
  18 use rustc_middle::mir::MirSource;
  19 use rustc_middle::mir::*;
  20 use rustc_middle::ty::{self, TyCtxt, TypeFoldable, TypeVisitor};
  21 use rustc_target::abi::Size;
  22 use std::ops::ControlFlow;
  23
  24 const INDENT: &str = "    ";
  25 /// Alignment for lining up comments following MIR statements
  26 pub(crate) const ALIGN: usize = 40;
  27
  28 /// An indication of where we are in the control flow graph. Used for printing
  29 /// extra information in `dump_mir`
  30 pub enum PassWhere {
  31     /// We have not started dumping the control flow graph, but we are about to.
  32     BeforeCFG,
  33
  34     /// We just finished dumping the control flow graph. This is right before EOF
  35     AfterCFG,
  36
  37     /// We are about to start dumping the given basic block.
  38     BeforeBlock(BasicBlock),
  39
  40     /// We are just about to dump the given statement or terminator.
  41     BeforeLocation(Location),
  42
  43     /// We just dumped the given statement or terminator.
  44     AfterLocation(Location),
  45
  46     /// We just dumped the terminator for a block but not the closing `}`.
  47     AfterTerminator(BasicBlock),
  48 }
  49
  50 /// If the session is properly configured, dumps a human-readable
  51 /// representation of the mir into:
  52 ///
  53 /// ```text
  54 /// rustc.node<node_id>.<pass_num>.<pass_name>.<disambiguator>
  55 /// ```
  56 ///
  57 /// Output from this function is controlled by passing `-Z dump-mir=<filter>`,
  58 /// where `<filter>` takes the following forms:
  59 ///
  60 /// - `all` -- dump MIR for all fns, all passes, all everything
  61 /// - a filter defined by a set of substrings combined with `&` and `|`
  62 ///   (`&` has higher precedence). At least one of the `|`-separated groups
  63 ///   must match; an `|`-separated group matches if all of its `&`-separated
  64 ///   substrings are matched.
  65 ///
  66 /// Example:
  67 ///
  68 /// - `nll` == match if `nll` appears in the name
  69 /// - `foo & nll` == match if `foo` and `nll` both appear in the name
  70 /// - `foo & nll | typeck` == match if `foo` and `nll` both appear in the name
  71 ///   or `typeck` appears in the name.
  72 /// - `foo & nll | bar & typeck` == match if `foo` and `nll` both appear in the name
  73 ///   or `typeck` and `bar` both appear in the name.
  74 #[inline]
  75 pub fn dump_mir<'tcx, F>(
  76     tcx: TyCtxt<'tcx>,
  77     pass_num: Option<&dyn Display>,
  78     pass_name: &str,
  79     disambiguator: &dyn Display,
  80     body: &Body<'tcx>,
  81     extra_data: F,
  82 ) where
  83     F: FnMut(PassWhere, &mut dyn Write) -> io::Result<()>,
  84 {
  85     if !dump_enabled(tcx, pass_name, body.source.def_id()) {
  86         return;
  87     }
  88
  89     dump_matched_mir_node(tcx, pass_num, pass_name, disambiguator, body, extra_data);
  90 }
  91
  92 pub fn dump_enabled<'tcx>(tcx: TyCtxt<'tcx>, pass_name: &str, def_id: DefId) -> bool {
  93     let filters = match tcx.sess.opts.debugging_opts.dump_mir {
  94         None => return false,
  95         Some(ref filters) => filters,
  96     };
  97     let node_path = ty::print::with_forced_impl_filename_line(|| {
  98         // see notes on #41697 below
  99         tcx.def_path_str(def_id)
 100     });
 101     filters.split('|').any(|or_filter| {
 102         or_filter.split('&').all(|and_filter| {
 103             let and_filter_trimmed = and_filter.trim();
 104             and_filter_trimmed == "all"
 105                 || pass_name.contains(and_filter_trimmed)
 106                 || node_path.contains(and_filter_trimmed)
 107         })
 108     })
 109 }
 110
 111 // #41697 -- we use `with_forced_impl_filename_line()` because
 112 // `def_path_str()` would otherwise trigger `type_of`, and this can
 113 // run while we are already attempting to evaluate `type_of`.
 114
 115 fn dump_matched_mir_node<'tcx, F>(
 116     tcx: TyCtxt<'tcx>,
 117     pass_num: Option<&dyn Display>,
 118     pass_name: &str,
 119     disambiguator: &dyn Display,
 120     body: &Body<'tcx>,
 121     mut extra_data: F,
 122 ) where
 123     F: FnMut(PassWhere, &mut dyn Write) -> io::Result<()>,
 124 {
 125     let _: io::Result<()> = try {
 126         let mut file =
 127             create_dump_file(tcx, "mir", pass_num, pass_name, disambiguator, body.source)?;
 128         let def_path = ty::print::with_forced_impl_filename_line(|| {
 129             // see notes on #41697 above
 130             tcx.def_path_str(body.source.def_id())
 131         });
 132         write!(file, "// MIR for `{}", def_path)?;
 133         match body.source.promoted {
 134             None => write!(file, "`")?,
 135             Some(promoted) => write!(file, "::{:?}`", promoted)?,
 136         }
 137         writeln!(file, " {} {}", disambiguator, pass_name)?;
 138         if let Some(ref layout) = body.generator_layout() {
 139             writeln!(file, "/* generator_layout = {:#?} */", layout)?;
 140         }
 141         writeln!(file)?;
 142         extra_data(PassWhere::BeforeCFG, &mut file)?;
 143         write_user_type_annotations(tcx, body, &mut file)?;
 144         write_mir_fn(tcx, body, &mut extra_data, &mut file)?;
 145         extra_data(PassWhere::AfterCFG, &mut file)?;
 146     };
 147
 148     if tcx.sess.opts.debugging_opts.dump_mir_graphviz {
 149         let _: io::Result<()> = try {
 150             let mut file =
 151                 create_dump_file(tcx, "dot", pass_num, pass_name, disambiguator, body.source)?;
 152             write_mir_fn_graphviz(tcx, body, false, &mut file)?;
 153         };
 154     }
 155
 156     if let Some(spanview) = tcx.sess.opts.debugging_opts.dump_mir_spanview {
 157         let _: io::Result<()> = try {
 158             let file_basename =
 159                 dump_file_basename(tcx, pass_num, pass_name, disambiguator, body.source);
 160             let mut file = create_dump_file_with_basename(tcx, &file_basename, "html")?;
 161             if body.source.def_id().is_local() {
 162                 write_mir_fn_spanview(tcx, body, spanview, &file_basename, &mut file)?;
 163             }
 164         };
 165     }
 166 }
 167
 168 /// Returns the file basename portion (without extension) of a filename path
 169 /// where we should dump a MIR representation output files.
 170 fn dump_file_basename<'tcx>(
 171     tcx: TyCtxt<'tcx>,
 172     pass_num: Option<&dyn Display>,
 173     pass_name: &str,
 174     disambiguator: &dyn Display,
 175     source: MirSource<'tcx>,
 176 ) -> String {
 177     let promotion_id = match source.promoted {
 178         Some(id) => format!("-{:?}", id),
 179         None => String::new(),
 180     };
 181
 182     let pass_num = if tcx.sess.opts.debugging_opts.dump_mir_exclude_pass_number {
 183         String::new()
 184     } else {
 185         match pass_num {
 186             None => ".-------".to_string(),
 187             Some(pass_num) => format!(".{}", pass_num),
 188         }
 189     };
 190
 191     let crate_name = tcx.crate_name(source.def_id().krate);
 192     let item_name = tcx.def_path(source.def_id()).to_filename_friendly_no_crate();
 193     // All drop shims have the same DefId, so we have to add the type
 194     // to get unique file names.
 195     let shim_disambiguator = match source.instance {
 196         ty::InstanceDef::DropGlue(_, Some(ty)) => {
 197             // Unfortunately, pretty-printed typed are not very filename-friendly.
 198             // We dome some filtering.
 199             let mut s = ".".to_owned();
 200             s.extend(ty.to_string().chars().filter_map(|c| match c {
 201                 ' ' => None,
 202                 ':' | '<' | '>' => Some('_'),
 203                 c => Some(c),
 204             }));
 205             s
 206         }
 207         _ => String::new(),
 208     };
 209
 210     format!(
 211         "{}.{}{}{}{}.{}.{}",
 212         crate_name, item_name, shim_disambiguator, promotion_id, pass_num, pass_name, disambiguator,
 213     )
 214 }
 215
 216 /// Returns the path to the filename where we should dump a given MIR.
 217 /// Also used by other bits of code (e.g., NLL inference) that dump
 218 /// graphviz data or other things.
 219 fn dump_path(tcx: TyCtxt<'_>, basename: &str, extension: &str) -> PathBuf {
 220     let mut file_path = PathBuf::new();
 221     file_path.push(Path::new(&tcx.sess.opts.debugging_opts.dump_mir_dir));
 222
 223     let file_name = format!("{}.{}", basename, extension,);
 224
 225     file_path.push(&file_name);
 226
 227     file_path
 228 }
 229
 230 /// Attempts to open the MIR dump file with the given name and extension.
 231 fn create_dump_file_with_basename(
 232     tcx: TyCtxt<'_>,
 233     file_basename: &str,
 234     extension: &str,
 235 ) -> io::Result<io::BufWriter<fs::File>> {
 236     let file_path = dump_path(tcx, file_basename, extension);
 237     if let Some(parent) = file_path.parent() {
 238         fs::create_dir_all(parent).map_err(|e| {
 239             io::Error::new(
 240                 e.kind(),
 241                 format!("IO error creating MIR dump directory: {:?}; {}", parent, e),
 242             )
 243         })?;
 244     }
 245     Ok(io::BufWriter::new(fs::File::create(&file_path).map_err(|e| {
 246         io::Error::new(e.kind(), format!("IO error creating MIR dump file: {:?}; {}", file_path, e))
 247     })?))
 248 }
 249
 250 /// Attempts to open a file where we should dump a given MIR or other
 251 /// bit of MIR-related data. Used by `mir-dump`, but also by other
 252 /// bits of code (e.g., NLL inference) that dump graphviz data or
 253 /// other things, and hence takes the extension as an argument.
 254 pub fn create_dump_file<'tcx>(
 255     tcx: TyCtxt<'tcx>,
 256     extension: &str,
 257     pass_num: Option<&dyn Display>,
 258     pass_name: &str,
 259     disambiguator: &dyn Display,
 260     source: MirSource<'tcx>,
 261 ) -> io::Result<io::BufWriter<fs::File>> {
 262     create_dump_file_with_basename(
 263         tcx,
 264         &dump_file_basename(tcx, pass_num, pass_name, disambiguator, source),
 265         extension,
 266     )
 267 }
 268
 269 /// Write out a human-readable textual representation for the given MIR.
 270 pub fn write_mir_pretty<'tcx>(
 271     tcx: TyCtxt<'tcx>,
 272     single: Option<DefId>,
 273     w: &mut dyn Write,
 274 ) -> io::Result<()> {
 275     writeln!(w, "// WARNING: This output format is intended for human consumers only")?;
 276     writeln!(w, "// and is subject to change without notice. Knock yourself out.")?;
 277
 278     let mut first = true;
 279     for def_id in dump_mir_def_ids(tcx, single) {
 280         if first {
 281             first = false;
 282         } else {
 283             // Put empty lines between all items
 284             writeln!(w)?;
 285         }
 286
 287         let render_body = |w: &mut dyn Write, body| -> io::Result<()> {
 288             write_mir_fn(tcx, body, &mut |_, _| Ok(()), w)?;
 289
 290             for body in tcx.promoted_mir(def_id) {
 291                 writeln!(w)?;
 292                 write_mir_fn(tcx, body, &mut |_, _| Ok(()), w)?;
 293             }
 294             Ok(())
 295         };
 296
 297         // For `const fn` we want to render both the optimized MIR and the MIR for ctfe.
 298         if tcx.is_const_fn_raw(def_id) {
 299             render_body(w, tcx.optimized_mir(def_id))?;
 300             writeln!(w)?;
 301             writeln!(w, "// MIR FOR CTFE")?;
 302             // Do not use `render_body`, as that would render the promoteds again, but these
 303             // are shared between mir_for_ctfe and optimized_mir
 304             write_mir_fn(tcx, tcx.mir_for_ctfe(def_id), &mut |_, _| Ok(()), w)?;
 305         } else {
 306             let instance_mir =
 307                 tcx.instance_mir(ty::InstanceDef::Item(ty::WithOptConstParam::unknown(def_id)));
 308             render_body(w, instance_mir)?;
 309         }
 310     }
 311     Ok(())
 312 }
 313
 314 /// Write out a human-readable textual representation for the given function.
 315 pub fn write_mir_fn<'tcx, F>(
 316     tcx: TyCtxt<'tcx>,
 317     body: &Body<'tcx>,
 318     extra_data: &mut F,
 319     w: &mut dyn Write,
 320 ) -> io::Result<()>
 321 where
 322     F: FnMut(PassWhere, &mut dyn Write) -> io::Result<()>,
 323 {
 324     write_mir_intro(tcx, body, w)?;
 325     for block in body.basic_blocks().indices() {
 326         extra_data(PassWhere::BeforeBlock(block), w)?;
 327         write_basic_block(tcx, block, body, extra_data, w)?;
 328         if block.index() + 1 != body.basic_blocks().len() {
 329             writeln!(w)?;
 330         }
 331     }
 332
 333     writeln!(w, "}}")?;
 334
 335     write_allocations(tcx, body, w)?;
 336
 337     Ok(())
 338 }
 339
 340 /// Write out a human-readable textual representation for the given basic block.
 341 pub fn write_basic_block<'tcx, F>(
 342     tcx: TyCtxt<'tcx>,
 343     block: BasicBlock,
 344     body: &Body<'tcx>,
 345     extra_data: &mut F,
 346     w: &mut dyn Write,
 347 ) -> io::Result<()>
 348 where
 349     F: FnMut(PassWhere, &mut dyn Write) -> io::Result<()>,
 350 {
 351     let data = &body[block];
 352
 353     // Basic block label at the top.
 354     let cleanup_text = if data.is_cleanup { " (cleanup)" } else { "" };
 355     writeln!(w, "{}{:?}{}: {{", INDENT, block, cleanup_text)?;
 356
 357     // List of statements in the middle.
 358     let mut current_location = Location { block, statement_index: 0 };
 359     for statement in &data.statements {
 360         extra_data(PassWhere::BeforeLocation(current_location), w)?;
 361         let indented_body = format!("{0}{0}{1:?};", INDENT, statement);
 362         writeln!(
 363             w,
 364             "{:A$} // {}{}",
 365             indented_body,
 366             if tcx.sess.verbose() { format!("{:?}: ", current_location) } else { String::new() },
 367             comment(tcx, statement.source_info),
 368             A = ALIGN,
 369         )?;
 370
 371         write_extra(tcx, w, |visitor| {
 372             visitor.visit_statement(statement, current_location);
 373         })?;
 374
 375         extra_data(PassWhere::AfterLocation(current_location), w)?;
 376
 377         current_location.statement_index += 1;
 378     }
 379
 380     // Terminator at the bottom.
 381     extra_data(PassWhere::BeforeLocation(current_location), w)?;
 382     let indented_terminator = format!("{0}{0}{1:?};", INDENT, data.terminator().kind);
 383     writeln!(
 384         w,
 385         "{:A$} // {}{}",
 386         indented_terminator,
 387         if tcx.sess.verbose() { format!("{:?}: ", current_location) } else { String::new() },
 388         comment(tcx, data.terminator().source_info),
 389         A = ALIGN,
 390     )?;
 391
 392     write_extra(tcx, w, |visitor| {
 393         visitor.visit_terminator(data.terminator(), current_location);
 394     })?;
 395
 396     extra_data(PassWhere::AfterLocation(current_location), w)?;
 397     extra_data(PassWhere::AfterTerminator(block), w)?;
 398
 399     writeln!(w, "{}}}", INDENT)
 400 }
 401
 402 /// After we print the main statement, we sometimes dump extra
 403 /// information. There's often a lot of little things "nuzzled up" in
 404 /// a statement.
 405 fn write_extra<'tcx, F>(tcx: TyCtxt<'tcx>, write: &mut dyn Write, mut visit_op: F) -> io::Result<()>
 406 where
 407     F: FnMut(&mut ExtraComments<'tcx>),
 408 {
 409     let mut extra_comments = ExtraComments { tcx, comments: vec![] };
 410     visit_op(&mut extra_comments);
 411     for comment in extra_comments.comments {
 412         writeln!(write, "{:A$} // {}", "", comment, A = ALIGN)?;
 413     }
 414     Ok(())
 415 }
 416
 417 struct ExtraComments<'tcx> {
 418     tcx: TyCtxt<'tcx>,
 419     comments: Vec<String>,
 420 }
 421
 422 impl<'tcx> ExtraComments<'tcx> {
 423     fn push(&mut self, lines: &str) {
 424         for line in lines.split('\n') {
 425             self.comments.push(line.to_string());
 426         }
 427     }
 428 }
 429
 430 fn use_verbose<'tcx>(ty: Ty<'tcx>, fn_def: bool) -> bool {
 431     match *ty.kind() {
 432         ty::Int(_) | ty::Uint(_) | ty::Bool | ty::Char | ty::Float(_) => false,
 433         // Unit type
 434         ty::Tuple(g_args) if g_args.is_empty() => false,
 435         ty::Tuple(g_args) => g_args.iter().any(|g_arg| use_verbose(g_arg.expect_ty(), fn_def)),
 436         ty::Array(ty, _) => use_verbose(ty, fn_def),
 437         ty::FnDef(..) => fn_def,
 438         _ => true,
 439     }
 440 }
 441
 442 impl<'tcx> Visitor<'tcx> for ExtraComments<'tcx> {
 443     fn visit_constant(&mut self, constant: &Constant<'tcx>, location: Location) {
 444         self.super_constant(constant, location);
 445         let Constant { span, user_ty, literal } = constant;
 446         if use_verbose(literal.ty(), true) {
 447             self.push("mir::Constant");
 448             self.push(&format!(
 449                 "+ span: {}",
 450                 self.tcx.sess.source_map().span_to_embeddable_string(*span)
 451             ));
 452             if let Some(user_ty) = user_ty {
 453                 self.push(&format!("+ user_ty: {:?}", user_ty));
 454             }
 455             match literal {
 456                 ConstantKind::Ty(literal) => self.push(&format!("+ literal: {:?}", literal)),
 457                 ConstantKind::Val(val, ty) => {
 458                     // To keep the diffs small, we render this almost like we render ty::Const
 459                     self.push(&format!("+ literal: Const {{ ty: {}, val: Value({:?}) }}", ty, val))
 460                 }
 461             }
 462         }
 463     }
 464
 465     fn visit_const(&mut self, constant: ty::Const<'tcx>, _: Location) {
 466         self.super_const(constant);
 467         let ty = constant.ty();
 468         let val = constant.val();
 469         if use_verbose(ty, false) {
 470             self.push("ty::Const");
 471             self.push(&format!("+ ty: {:?}", ty));
 472             let val = match val {
 473                 ty::ConstKind::Param(p) => format!("Param({})", p),
 474                 ty::ConstKind::Infer(infer) => format!("Infer({:?})", infer),
 475                 ty::ConstKind::Bound(idx, var) => format!("Bound({:?}, {:?})", idx, var),
 476                 ty::ConstKind::Placeholder(ph) => format!("PlaceHolder({:?})", ph),
 477                 ty::ConstKind::Unevaluated(uv) => format!(
 478                     "Unevaluated({}, {:?}, {:?})",
 479                     self.tcx.def_path_str(uv.def.did),
 480                     uv.substs,
 481                     uv.promoted,
 482                 ),
 483                 ty::ConstKind::Value(val) => format!("Value({:?})", val),
 484                 ty::ConstKind::Error(_) => "Error".to_string(),
 485             };
 486             self.push(&format!("+ val: {}", val));
 487         }
 488     }
 489
 490     fn visit_rvalue(&mut self, rvalue: &Rvalue<'tcx>, location: Location) {
 491         self.super_rvalue(rvalue, location);
 492         if let Rvalue::Aggregate(kind, _) = rvalue {
 493             match **kind {
 494                 AggregateKind::Closure(def_id, substs) => {
 495                     self.push("closure");
 496                     self.push(&format!("+ def_id: {:?}", def_id));
 497                     self.push(&format!("+ substs: {:#?}", substs));
 498                 }
 499
 500                 AggregateKind::Generator(def_id, substs, movability) => {
 501                     self.push("generator");
 502                     self.push(&format!("+ def_id: {:?}", def_id));
 503                     self.push(&format!("+ substs: {:#?}", substs));
 504                     self.push(&format!("+ movability: {:?}", movability));
 505                 }
 506
 507                 AggregateKind::Adt(_, _, _, Some(user_ty), _) => {
 508                     self.push("adt");
 509                     self.push(&format!("+ user_ty: {:?}", user_ty));
 510                 }
 511
 512                 _ => {}
 513             }
 514         }
 515     }
 516 }
 517
 518 fn comment(tcx: TyCtxt<'_>, SourceInfo { span, scope }: SourceInfo) -> String {
 519     format!("scope {} at {}", scope.index(), tcx.sess.source_map().span_to_embeddable_string(span))
 520 }
 521
 522 /// Prints local variables in a scope tree.
 523 fn write_scope_tree(
 524     tcx: TyCtxt<'_>,
 525     body: &Body<'_>,
 526     scope_tree: &FxHashMap<SourceScope, Vec<SourceScope>>,
 527     w: &mut dyn Write,
 528     parent: SourceScope,
 529     depth: usize,
 530 ) -> io::Result<()> {
 531     let indent = depth * INDENT.len();
 532
 533     // Local variable debuginfo.
 534     for var_debug_info in &body.var_debug_info {
 535         if var_debug_info.source_info.scope != parent {
 536             // Not declared in this scope.
 537             continue;
 538         }
 539
 540         let indented_debug_info = format!(
 541             "{0:1$}debug {2} => {3:?};",
 542             INDENT, indent, var_debug_info.name, var_debug_info.value,
 543         );
 544
 545         writeln!(
 546             w,
 547             "{0:1$} // in {2}",
 548             indented_debug_info,
 549             ALIGN,
 550             comment(tcx, var_debug_info.source_info),
 551         )?;
 552     }
 553
 554     // Local variable types.
 555     for (local, local_decl) in body.local_decls.iter_enumerated() {
 556         if (1..body.arg_count + 1).contains(&local.index()) {
 557             // Skip over argument locals, they're printed in the signature.
 558             continue;
 559         }
 560
 561         if local_decl.source_info.scope != parent {
 562             // Not declared in this scope.
 563             continue;
 564         }
 565
 566         let mut_str = if local_decl.mutability == Mutability::Mut { "mut " } else { "" };
 567
 568         let mut indented_decl =
 569             format!("{0:1$}let {2}{3:?}: {4:?}", INDENT, indent, mut_str, local, local_decl.ty);
 570         if let Some(user_ty) = &local_decl.user_ty {
 571             for user_ty in user_ty.projections() {
 572                 write!(indented_decl, " as {:?}", user_ty).unwrap();
 573             }
 574         }
 575         indented_decl.push(';');
 576
 577         let local_name =
 578             if local == RETURN_PLACE { " return place".to_string() } else { String::new() };
 579
 580         writeln!(
 581             w,
 582             "{0:1$} //{2} in {3}",
 583             indented_decl,
 584             ALIGN,
 585             local_name,
 586             comment(tcx, local_decl.source_info),
 587         )?;
 588     }
 589
 590     let children = match scope_tree.get(&parent) {
 591         Some(children) => children,
 592         None => return Ok(()),
 593     };
 594
 595     for &child in children {
 596         let child_data = &body.source_scopes[child];
 597         assert_eq!(child_data.parent_scope, Some(parent));
 598
 599         let (special, span) = if let Some((callee, callsite_span)) = child_data.inlined {
 600             (
 601                 format!(
 602                     " (inlined {}{})",
 603                     if callee.def.requires_caller_location(tcx) { "#[track_caller] " } else { "" },
 604                     callee
 605                 ),
 606                 Some(callsite_span),
 607             )
 608         } else {
 609             (String::new(), None)
 610         };
 611
 612         let indented_header = format!("{0:1$}scope {2}{3} {{", "", indent, child.index(), special);
 613
 614         if let Some(span) = span {
 615             writeln!(
 616                 w,
 617                 "{0:1$} // at {2}",
 618                 indented_header,
 619                 ALIGN,
 620                 tcx.sess.source_map().span_to_embeddable_string(span),
 621             )?;
 622         } else {
 623             writeln!(w, "{}", indented_header)?;
 624         }
 625
 626         write_scope_tree(tcx, body, scope_tree, w, child, depth + 1)?;
 627         writeln!(w, "{0:1$}}}", "", depth * INDENT.len())?;
 628     }
 629
 630     Ok(())
 631 }
 632
 633 /// Write out a human-readable textual representation of the MIR's `fn` type and the types of its
 634 /// local variables (both user-defined bindings and compiler temporaries).
 635 pub fn write_mir_intro<'tcx>(
 636     tcx: TyCtxt<'tcx>,
 637     body: &Body<'_>,
 638     w: &mut dyn Write,
 639 ) -> io::Result<()> {
 640     write_mir_sig(tcx, body, w)?;
 641     writeln!(w, "{{")?;
 642
 643     // construct a scope tree and write it out
 644     let mut scope_tree: FxHashMap<SourceScope, Vec<SourceScope>> = Default::default();
 645     for (index, scope_data) in body.source_scopes.iter().enumerate() {
 646         if let Some(parent) = scope_data.parent_scope {
 647             scope_tree.entry(parent).or_default().push(SourceScope::new(index));
 648         } else {
 649             // Only the argument scope has no parent, because it's the root.
 650             assert_eq!(index, OUTERMOST_SOURCE_SCOPE.index());
 651         }
 652     }
 653
 654     write_scope_tree(tcx, body, &scope_tree, w, OUTERMOST_SOURCE_SCOPE, 1)?;
 655
 656     // Add an empty line before the first block is printed.
 657     writeln!(w)?;
 658
 659     Ok(())
 660 }
 661
 662 /// Find all `AllocId`s mentioned (recursively) in the MIR body and print their corresponding
 663 /// allocations.
 664 pub fn write_allocations<'tcx>(
 665     tcx: TyCtxt<'tcx>,
 666     body: &Body<'_>,
 667     w: &mut dyn Write,
 668 ) -> io::Result<()> {
 669     fn alloc_ids_from_alloc(alloc: &Allocation) -> impl DoubleEndedIterator<Item = AllocId> + '_ {
 670         alloc.relocations().values().map(|id| *id)
 671     }
 672     fn alloc_ids_from_const(val: ConstValue<'_>) -> impl Iterator<Item = AllocId> + '_ {
 673         match val {
 674             ConstValue::Scalar(interpret::Scalar::Ptr(ptr, _size)) => {
 675                 Either::Left(Either::Left(std::iter::once(ptr.provenance)))
 676             }
 677             ConstValue::Scalar(interpret::Scalar::Int { .. }) => {
 678                 Either::Left(Either::Right(std::iter::empty()))
 679             }
 680             ConstValue::ByRef { alloc, .. } | ConstValue::Slice { data: alloc, .. } => {
 681                 Either::Right(alloc_ids_from_alloc(alloc))
 682             }
 683         }
 684     }
 685     struct CollectAllocIds(BTreeSet<AllocId>);
 686     impl<'tcx> TypeVisitor<'tcx> for CollectAllocIds {
 687         fn visit_const(&mut self, c: ty::Const<'tcx>) -> ControlFlow<Self::BreakTy> {
 688             if let ty::ConstKind::Value(val) = c.val() {
 689                 self.0.extend(alloc_ids_from_const(val));
 690             }
 691             c.super_visit_with(self)
 692         }
 693     }
 694     let mut visitor = CollectAllocIds(Default::default());
 695     body.visit_with(&mut visitor);
 696     // `seen` contains all seen allocations, including the ones we have *not* printed yet.
 697     // The protocol is to first `insert` into `seen`, and only if that returns `true`
 698     // then push to `todo`.
 699     let mut seen = visitor.0;
 700     let mut todo: Vec<_> = seen.iter().copied().collect();
 701     while let Some(id) = todo.pop() {
 702         let mut write_allocation_track_relocs =
 703             |w: &mut dyn Write, alloc: &Allocation| -> io::Result<()> {
 704                 // `.rev()` because we are popping them from the back of the `todo` vector.
 705                 for id in alloc_ids_from_alloc(alloc).rev() {
 706                     if seen.insert(id) {
 707                         todo.push(id);
 708                     }
 709                 }
 710                 write!(w, "{}", display_allocation(tcx, alloc))
 711             };
 712         write!(w, "\n{}", id)?;
 713         match tcx.get_global_alloc(id) {
 714             // This can't really happen unless there are bugs, but it doesn't cost us anything to
 715             // gracefully handle it and allow buggy rustc to be debugged via allocation printing.
 716             None => write!(w, " (deallocated)")?,
 717             Some(GlobalAlloc::Function(inst)) => write!(w, " (fn: {})", inst)?,
 718             Some(GlobalAlloc::Static(did)) if !tcx.is_foreign_item(did) => {
 719                 match tcx.eval_static_initializer(did) {
 720                     Ok(alloc) => {
 721                         write!(w, " (static: {}, ", tcx.def_path_str(did))?;
 722                         write_allocation_track_relocs(w, alloc)?;
 723                     }
 724                     Err(_) => write!(
 725                         w,
 726                         " (static: {}, error during initializer evaluation)",
 727                         tcx.def_path_str(did)
 728                     )?,
 729                 }
 730             }
 731             Some(GlobalAlloc::Static(did)) => {
 732                 write!(w, " (extern static: {})", tcx.def_path_str(did))?
 733             }
 734             Some(GlobalAlloc::Memory(alloc)) => {
 735                 write!(w, " (")?;
 736                 write_allocation_track_relocs(w, alloc)?
 737             }
 738         }
 739         writeln!(w)?;
 740     }
 741     Ok(())
 742 }
 743
 744 /// Dumps the size and metadata and content of an allocation to the given writer.
 745 /// The expectation is that the caller first prints other relevant metadata, so the exact
 746 /// format of this function is (*without* leading or trailing newline):
 747 ///
 748 /// ```text
 749 /// size: {}, align: {}) {
 750 ///     <bytes>
 751 /// }
 752 /// ```
 753 ///
 754 /// The byte format is similar to how hex editors print bytes. Each line starts with the address of
 755 /// the start of the line, followed by all bytes in hex format (space separated).
 756 /// If the allocation is small enough to fit into a single line, no start address is given.
 757 /// After the hex dump, an ascii dump follows, replacing all unprintable characters (control
 758 /// characters or characters whose value is larger than 127) with a `.`
 759 /// This also prints relocations adequately.
 760 pub fn display_allocation<'a, 'tcx, Tag, Extra>(
 761     tcx: TyCtxt<'tcx>,
 762     alloc: &'a Allocation<Tag, Extra>,
 763 ) -> RenderAllocation<'a, 'tcx, Tag, Extra> {
 764     RenderAllocation { tcx, alloc }
 765 }
 766
 767 #[doc(hidden)]
 768 pub struct RenderAllocation<'a, 'tcx, Tag, Extra> {
 769     tcx: TyCtxt<'tcx>,
 770     alloc: &'a Allocation<Tag, Extra>,
 771 }
 772
 773 impl<'a, 'tcx, Tag: Provenance, Extra> std::fmt::Display
 774     for RenderAllocation<'a, 'tcx, Tag, Extra>
 775 {
 776     fn fmt(&self, w: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 777         let RenderAllocation { tcx, alloc } = *self;
 778         write!(w, "size: {}, align: {})", alloc.size().bytes(), alloc.align.bytes())?;
 779         if alloc.size() == Size::ZERO {
 780             // We are done.
 781             return write!(w, " {{}}");
 782         }
 783         // Write allocation bytes.
 784         writeln!(w, " {{")?;
 785         write_allocation_bytes(tcx, alloc, w, "    ")?;
 786         write!(w, "}}")?;
 787         Ok(())
 788     }
 789 }
 790
 791 fn write_allocation_endline(w: &mut dyn std::fmt::Write, ascii: &str) -> std::fmt::Result {
 792     for _ in 0..(BYTES_PER_LINE - ascii.chars().count()) {
 793         write!(w, "   ")?;
 794     }
 795     writeln!(w, " │ {}", ascii)
 796 }
 797
 798 /// Number of bytes to print per allocation hex dump line.
 799 const BYTES_PER_LINE: usize = 16;
 800
 801 /// Prints the line start address and returns the new line start address.
 802 fn write_allocation_newline(
 803     w: &mut dyn std::fmt::Write,
 804     mut line_start: Size,
 805     ascii: &str,
 806     pos_width: usize,
 807     prefix: &str,
 808 ) -> Result<Size, std::fmt::Error> {
 809     write_allocation_endline(w, ascii)?;
 810     line_start += Size::from_bytes(BYTES_PER_LINE);
 811     write!(w, "{}0x{:02$x} │ ", prefix, line_start.bytes(), pos_width)?;
 812     Ok(line_start)
 813 }
 814
 815 /// The `prefix` argument allows callers to add an arbitrary prefix before each line (even if there
 816 /// is only one line). Note that your prefix should contain a trailing space as the lines are
 817 /// printed directly after it.
 818 fn write_allocation_bytes<'tcx, Tag: Provenance, Extra>(
 819     tcx: TyCtxt<'tcx>,
 820     alloc: &Allocation<Tag, Extra>,
 821     w: &mut dyn std::fmt::Write,
 822     prefix: &str,
 823 ) -> std::fmt::Result {
 824     let num_lines = alloc.size().bytes_usize().saturating_sub(BYTES_PER_LINE);
 825     // Number of chars needed to represent all line numbers.
 826     let pos_width = hex_number_length(alloc.size().bytes());
 827
 828     if num_lines > 0 {
 829         write!(w, "{}0x{:02$x} │ ", prefix, 0, pos_width)?;
 830     } else {
 831         write!(w, "{}", prefix)?;
 832     }
 833
 834     let mut i = Size::ZERO;
 835     let mut line_start = Size::ZERO;
 836
 837     let ptr_size = tcx.data_layout.pointer_size;
 838
 839     let mut ascii = String::new();
 840
 841     let oversized_ptr = |target: &mut String, width| {
 842         if target.len() > width {
 843             write!(target, " ({} ptr bytes)", ptr_size.bytes()).unwrap();
 844         }
 845     };
 846
 847     while i < alloc.size() {
 848         // The line start already has a space. While we could remove that space from the line start
 849         // printing and unconditionally print a space here, that would cause the single-line case
 850         // to have a single space before it, which looks weird.
 851         if i != line_start {
 852             write!(w, " ")?;
 853         }
 854         if let Some(&tag) = alloc.relocations().get(&i) {
 855             // Memory with a relocation must be defined
 856             let j = i.bytes_usize();
 857             let offset = alloc
 858                 .inspect_with_uninit_and_ptr_outside_interpreter(j..j + ptr_size.bytes_usize());
 859             let offset = read_target_uint(tcx.data_layout.endian, offset).unwrap();
 860             let offset = Size::from_bytes(offset);
 861             let relocation_width = |bytes| bytes * 3;
 862             let ptr = Pointer::new(tag, offset);
 863             let mut target = format!("{:?}", ptr);
 864             if target.len() > relocation_width(ptr_size.bytes_usize() - 1) {
 865                 // This is too long, try to save some space.
 866                 target = format!("{:#?}", ptr);
 867             }
 868             if ((i - line_start) + ptr_size).bytes_usize() > BYTES_PER_LINE {
 869                 // This branch handles the situation where a relocation starts in the current line
 870                 // but ends in the next one.
 871                 let remainder = Size::from_bytes(BYTES_PER_LINE) - (i - line_start);
 872                 let overflow = ptr_size - remainder;
 873                 let remainder_width = relocation_width(remainder.bytes_usize()) - 2;
 874                 let overflow_width = relocation_width(overflow.bytes_usize() - 1) + 1;
 875                 ascii.push('╾');
 876                 for _ in 0..remainder.bytes() - 1 {
 877                     ascii.push('─');
 878                 }
 879                 if overflow_width > remainder_width && overflow_width >= target.len() {
 880                     // The case where the relocation fits into the part in the next line
 881                     write!(w, "╾{0:─^1$}", "", remainder_width)?;
 882                     line_start =
 883                         write_allocation_newline(w, line_start, &ascii, pos_width, prefix)?;
 884                     ascii.clear();
 885                     write!(w, "{0:─^1$}╼", target, overflow_width)?;
 886                 } else {
 887                     oversized_ptr(&mut target, remainder_width);
 888                     write!(w, "╾{0:─^1$}", target, remainder_width)?;
 889                     line_start =
 890                         write_allocation_newline(w, line_start, &ascii, pos_width, prefix)?;
 891                     write!(w, "{0:─^1$}╼", "", overflow_width)?;
 892                     ascii.clear();
 893                 }
 894                 for _ in 0..overflow.bytes() - 1 {
 895                     ascii.push('─');
 896                 }
 897                 ascii.push('╼');
 898                 i += ptr_size;
 899                 continue;
 900             } else {
 901                 // This branch handles a relocation that starts and ends in the current line.
 902                 let relocation_width = relocation_width(ptr_size.bytes_usize() - 1);
 903                 oversized_ptr(&mut target, relocation_width);
 904                 ascii.push('╾');
 905                 write!(w, "╾{0:─^1$}╼", target, relocation_width)?;
 906                 for _ in 0..ptr_size.bytes() - 2 {
 907                     ascii.push('─');
 908                 }
 909                 ascii.push('╼');
 910                 i += ptr_size;
 911             }
 912         } else if alloc.init_mask().is_range_initialized(i, i + Size::from_bytes(1)).is_ok() {
 913             let j = i.bytes_usize();
 914
 915             // Checked definedness (and thus range) and relocations. This access also doesn't
 916             // influence interpreter execution but is only for debugging.
 917             let c = alloc.inspect_with_uninit_and_ptr_outside_interpreter(j..j + 1)[0];
 918             write!(w, "{:02x}", c)?;
 919             if c.is_ascii_control() || c >= 0x80 {
 920                 ascii.push('.');
 921             } else {
 922                 ascii.push(char::from(c));
 923             }
 924             i += Size::from_bytes(1);
 925         } else {
 926             write!(w, "__")?;
 927             ascii.push('░');
 928             i += Size::from_bytes(1);
 929         }
 930         // Print a new line header if the next line still has some bytes to print.
 931         if i == line_start + Size::from_bytes(BYTES_PER_LINE) && i != alloc.size() {
 932             line_start = write_allocation_newline(w, line_start, &ascii, pos_width, prefix)?;
 933             ascii.clear();
 934         }
 935     }
 936     write_allocation_endline(w, &ascii)?;
 937
 938     Ok(())
 939 }
 940
 941 fn write_mir_sig(tcx: TyCtxt<'_>, body: &Body<'_>, w: &mut dyn Write) -> io::Result<()> {
 942     use rustc_hir::def::DefKind;
 943
 944     trace!("write_mir_sig: {:?}", body.source.instance);
 945     let def_id = body.source.def_id();
 946     let kind = tcx.def_kind(def_id);
 947     let is_function = match kind {
 948         DefKind::Fn | DefKind::AssocFn | DefKind::Ctor(..) => true,
 949         _ => tcx.is_closure(def_id),
 950     };
 951     match (kind, body.source.promoted) {
 952         (_, Some(i)) => write!(w, "{:?} in ", i)?,
 953         (DefKind::Const | DefKind::AssocConst, _) => write!(w, "const ")?,
 954         (DefKind::Static, _) => {
 955             write!(w, "static {}", if tcx.is_mutable_static(def_id) { "mut " } else { "" })?
 956         }
 957         (_, _) if is_function => write!(w, "fn ")?,
 958         (DefKind::AnonConst | DefKind::InlineConst, _) => {} // things like anon const, not an item
 959         _ => bug!("Unexpected def kind {:?}", kind),
 960     }
 961
 962     ty::print::with_forced_impl_filename_line(|| {
 963         // see notes on #41697 elsewhere
 964         write!(w, "{}", tcx.def_path_str(def_id))
 965     })?;
 966
 967     if body.source.promoted.is_none() && is_function {
 968         write!(w, "(")?;
 969
 970         // fn argument types.
 971         for (i, arg) in body.args_iter().enumerate() {
 972             if i != 0 {
 973                 write!(w, ", ")?;
 974             }
 975             write!(w, "{:?}: {}", Place::from(arg), body.local_decls[arg].ty)?;
 976         }
 977
 978         write!(w, ") -> {}", body.return_ty())?;
 979     } else {
 980         assert_eq!(body.arg_count, 0);
 981         write!(w, ": {} =", body.return_ty())?;
 982     }
 983
 984     if let Some(yield_ty) = body.yield_ty() {
 985         writeln!(w)?;
 986         writeln!(w, "yields {}", yield_ty)?;
 987     }
 988
 989     write!(w, " ")?;
 990     // Next thing that gets printed is the opening {
 991
 992     Ok(())
 993 }
 994
 995 fn write_user_type_annotations(
 996     tcx: TyCtxt<'_>,
 997     body: &Body<'_>,
 998     w: &mut dyn Write,
 999 ) -> io::Result<()> {
1000     if !body.user_type_annotations.is_empty() {
1001         writeln!(w, "| User Type Annotations")?;
1002     }
1003     for (index, annotation) in body.user_type_annotations.iter_enumerated() {
1004         writeln!(
1005             w,
1006             "| {:?}: {:?} at {}",
1007             index.index(),
1008             annotation.user_ty,
1009             tcx.sess.source_map().span_to_embeddable_string(annotation.span)
1010         )?;
1011     }
1012     if !body.user_type_annotations.is_empty() {
1013         writeln!(w, "|")?;
1014     }
1015     Ok(())
1016 }
1017
1018 pub fn dump_mir_def_ids(tcx: TyCtxt<'_>, single: Option<DefId>) -> Vec<DefId> {
1019     if let Some(i) = single {
1020         vec![i]
1021     } else {
1022         tcx.mir_keys(()).iter().map(|def_id| def_id.to_def_id()).collect()
1023     }
1024 }
1025
1026 /// Calc converted u64 decimal into hex and return it's length in chars
1027 ///
1028 /// ```ignore (cannot-test-private-function)
1029 /// assert_eq!(1, hex_number_length(0));
1030 /// assert_eq!(1, hex_number_length(1));
1031 /// assert_eq!(2, hex_number_length(16));
1032 /// ```
1033 fn hex_number_length(x: u64) -> usize {
1034     if x == 0 {
1035         return 1;
1036     }
1037     let mut length = 0;
1038     let mut x_left = x;
1039     while x_left > 0 {
1040         x_left /= 16;
1041         length += 1;
1042     }
1043     length
1044 }