1 use std::collections::BTreeSet;
3 use std::fmt::Write as _;
5 use std::io::{self, Write};
6 use std::path::{Path, PathBuf};
8 use super::graphviz::write_mir_fn_graphviz;
9 use super::spanview::write_mir_fn_spanview;
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, ConstAllocation, ConstValue, GlobalAlloc, Pointer,
18 use rustc_middle::mir::visit::Visitor;
19 use rustc_middle::mir::MirSource;
20 use rustc_middle::mir::*;
21 use rustc_middle::ty::{self, TyCtxt};
22 use rustc_target::abi::Size;
24 const INDENT: &str = " ";
25 /// Alignment for lining up comments following MIR statements
26 pub(crate) const ALIGN: usize = 40;
28 /// An indication of where we are in the control flow graph. Used for printing
29 /// extra information in `dump_mir`
31 /// We have not started dumping the control flow graph, but we are about to.
34 /// We just finished dumping the control flow graph. This is right before EOF
37 /// We are about to start dumping the given basic block.
38 BeforeBlock(BasicBlock),
40 /// We are just about to dump the given statement or terminator.
41 BeforeLocation(Location),
43 /// We just dumped the given statement or terminator.
44 AfterLocation(Location),
46 /// We just dumped the terminator for a block but not the closing `}`.
47 AfterTerminator(BasicBlock),
50 /// If the session is properly configured, dumps a human-readable
51 /// representation of the mir into:
54 /// rustc.node<node_id>.<pass_num>.<pass_name>.<disambiguator>
57 /// Output from this function is controlled by passing `-Z dump-mir=<filter>`,
58 /// where `<filter>` takes the following forms:
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.
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.
75 pub fn dump_mir<'tcx, F>(
77 pass_num: Option<&dyn Display>,
79 disambiguator: &dyn Display,
83 F: FnMut(PassWhere, &mut dyn Write) -> io::Result<()>,
85 if !dump_enabled(tcx, pass_name, body.source.def_id()) {
89 dump_matched_mir_node(tcx, pass_num, pass_name, disambiguator, body, extra_data);
92 pub fn dump_enabled<'tcx>(tcx: TyCtxt<'tcx>, pass_name: &str, def_id: DefId) -> bool {
93 let Some(ref filters) = tcx.sess.opts.debugging_opts.dump_mir else {
96 // see notes on #41697 below
97 let node_path = ty::print::with_forced_impl_filename_line!(tcx.def_path_str(def_id));
98 filters.split('|').any(|or_filter| {
99 or_filter.split('&').all(|and_filter| {
100 let and_filter_trimmed = and_filter.trim();
101 and_filter_trimmed == "all"
102 || pass_name.contains(and_filter_trimmed)
103 || node_path.contains(and_filter_trimmed)
108 // #41697 -- we use `with_forced_impl_filename_line()` because
109 // `def_path_str()` would otherwise trigger `type_of`, and this can
110 // run while we are already attempting to evaluate `type_of`.
112 fn dump_matched_mir_node<'tcx, F>(
114 pass_num: Option<&dyn Display>,
116 disambiguator: &dyn Display,
120 F: FnMut(PassWhere, &mut dyn Write) -> io::Result<()>,
122 let _: io::Result<()> = try {
124 create_dump_file(tcx, "mir", pass_num, pass_name, disambiguator, body.source)?;
125 // see notes on #41697 above
127 ty::print::with_forced_impl_filename_line!(tcx.def_path_str(body.source.def_id()));
128 write!(file, "// MIR for `{}", def_path)?;
129 match body.source.promoted {
130 None => write!(file, "`")?,
131 Some(promoted) => write!(file, "::{:?}`", promoted)?,
133 writeln!(file, " {} {}", disambiguator, pass_name)?;
134 if let Some(ref layout) = body.generator_layout() {
135 writeln!(file, "/* generator_layout = {:#?} */", layout)?;
138 extra_data(PassWhere::BeforeCFG, &mut file)?;
139 write_user_type_annotations(tcx, body, &mut file)?;
140 write_mir_fn(tcx, body, &mut extra_data, &mut file)?;
141 extra_data(PassWhere::AfterCFG, &mut file)?;
144 if tcx.sess.opts.debugging_opts.dump_mir_graphviz {
145 let _: io::Result<()> = try {
147 create_dump_file(tcx, "dot", pass_num, pass_name, disambiguator, body.source)?;
148 write_mir_fn_graphviz(tcx, body, false, &mut file)?;
152 if let Some(spanview) = tcx.sess.opts.debugging_opts.dump_mir_spanview {
153 let _: io::Result<()> = try {
155 dump_file_basename(tcx, pass_num, pass_name, disambiguator, body.source);
156 let mut file = create_dump_file_with_basename(tcx, &file_basename, "html")?;
157 if body.source.def_id().is_local() {
158 write_mir_fn_spanview(tcx, body, spanview, &file_basename, &mut file)?;
164 /// Returns the file basename portion (without extension) of a filename path
165 /// where we should dump a MIR representation output files.
166 fn dump_file_basename<'tcx>(
168 pass_num: Option<&dyn Display>,
170 disambiguator: &dyn Display,
171 source: MirSource<'tcx>,
173 let promotion_id = match source.promoted {
174 Some(id) => format!("-{:?}", id),
175 None => String::new(),
178 let pass_num = if tcx.sess.opts.debugging_opts.dump_mir_exclude_pass_number {
182 None => ".-------".to_string(),
183 Some(pass_num) => format!(".{}", pass_num),
187 let crate_name = tcx.crate_name(source.def_id().krate);
188 let item_name = tcx.def_path(source.def_id()).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().chars().filter_map(|c| match c {
198 ':' | '<' | '>' => Some('_'),
208 crate_name, item_name, shim_disambiguator, promotion_id, pass_num, pass_name, disambiguator,
212 /// Returns the path to the filename where we should dump a given MIR.
213 /// Also used by other bits of code (e.g., NLL inference) that dump
214 /// graphviz data or other things.
215 fn dump_path(tcx: TyCtxt<'_>, basename: &str, extension: &str) -> PathBuf {
216 let mut file_path = PathBuf::new();
217 file_path.push(Path::new(&tcx.sess.opts.debugging_opts.dump_mir_dir));
219 let file_name = format!("{}.{}", basename, extension,);
221 file_path.push(&file_name);
226 /// Attempts to open the MIR dump file with the given name and extension.
227 fn create_dump_file_with_basename(
231 ) -> io::Result<io::BufWriter<fs::File>> {
232 let file_path = dump_path(tcx, file_basename, extension);
233 if let Some(parent) = file_path.parent() {
234 fs::create_dir_all(parent).map_err(|e| {
237 format!("IO error creating MIR dump directory: {:?}; {}", parent, e),
241 Ok(io::BufWriter::new(fs::File::create(&file_path).map_err(|e| {
242 io::Error::new(e.kind(), format!("IO error creating MIR dump file: {:?}; {}", file_path, e))
246 /// Attempts to open a file where we should dump a given MIR or other
247 /// bit of MIR-related data. Used by `mir-dump`, but also by other
248 /// bits of code (e.g., NLL inference) that dump graphviz data or
249 /// other things, and hence takes the extension as an argument.
250 pub fn create_dump_file<'tcx>(
253 pass_num: Option<&dyn Display>,
255 disambiguator: &dyn Display,
256 source: MirSource<'tcx>,
257 ) -> io::Result<io::BufWriter<fs::File>> {
258 create_dump_file_with_basename(
260 &dump_file_basename(tcx, pass_num, pass_name, disambiguator, source),
265 /// Write out a human-readable textual representation for the given MIR.
266 pub fn write_mir_pretty<'tcx>(
268 single: Option<DefId>,
270 ) -> io::Result<()> {
271 writeln!(w, "// WARNING: This output format is intended for human consumers only")?;
272 writeln!(w, "// and is subject to change without notice. Knock yourself out.")?;
274 let mut first = true;
275 for def_id in dump_mir_def_ids(tcx, single) {
279 // Put empty lines between all items
283 let render_body = |w: &mut dyn Write, body| -> io::Result<()> {
284 write_mir_fn(tcx, body, &mut |_, _| Ok(()), w)?;
286 for body in tcx.promoted_mir(def_id) {
288 write_mir_fn(tcx, body, &mut |_, _| Ok(()), w)?;
293 // For `const fn` we want to render both the optimized MIR and the MIR for ctfe.
294 if tcx.is_const_fn_raw(def_id) {
295 render_body(w, tcx.optimized_mir(def_id))?;
297 writeln!(w, "// MIR FOR CTFE")?;
298 // Do not use `render_body`, as that would render the promoteds again, but these
299 // are shared between mir_for_ctfe and optimized_mir
300 write_mir_fn(tcx, tcx.mir_for_ctfe(def_id), &mut |_, _| Ok(()), w)?;
303 tcx.instance_mir(ty::InstanceDef::Item(ty::WithOptConstParam::unknown(def_id)));
304 render_body(w, instance_mir)?;
310 /// Write out a human-readable textual representation for the given function.
311 pub fn write_mir_fn<'tcx, F>(
318 F: FnMut(PassWhere, &mut dyn Write) -> io::Result<()>,
320 write_mir_intro(tcx, body, w)?;
321 for block in body.basic_blocks().indices() {
322 extra_data(PassWhere::BeforeBlock(block), w)?;
323 write_basic_block(tcx, block, body, extra_data, w)?;
324 if block.index() + 1 != body.basic_blocks().len() {
331 write_allocations(tcx, body, w)?;
336 /// Write out a human-readable textual representation for the given basic block.
337 pub fn write_basic_block<'tcx, F>(
345 F: FnMut(PassWhere, &mut dyn Write) -> io::Result<()>,
347 let data = &body[block];
349 // Basic block label at the top.
350 let cleanup_text = if data.is_cleanup { " (cleanup)" } else { "" };
351 writeln!(w, "{}{:?}{}: {{", INDENT, block, cleanup_text)?;
353 // List of statements in the middle.
354 let mut current_location = Location { block, statement_index: 0 };
355 for statement in &data.statements {
356 extra_data(PassWhere::BeforeLocation(current_location), w)?;
357 let indented_body = format!("{0}{0}{1:?};", INDENT, statement);
362 if tcx.sess.verbose() { format!("{:?}: ", current_location) } else { String::new() },
363 comment(tcx, statement.source_info),
367 write_extra(tcx, w, |visitor| {
368 visitor.visit_statement(statement, current_location);
371 extra_data(PassWhere::AfterLocation(current_location), w)?;
373 current_location.statement_index += 1;
376 // Terminator at the bottom.
377 extra_data(PassWhere::BeforeLocation(current_location), w)?;
378 let indented_terminator = format!("{0}{0}{1:?};", INDENT, data.terminator().kind);
383 if tcx.sess.verbose() { format!("{:?}: ", current_location) } else { String::new() },
384 comment(tcx, data.terminator().source_info),
388 write_extra(tcx, w, |visitor| {
389 visitor.visit_terminator(data.terminator(), current_location);
392 extra_data(PassWhere::AfterLocation(current_location), w)?;
393 extra_data(PassWhere::AfterTerminator(block), w)?;
395 writeln!(w, "{}}}", INDENT)
398 /// After we print the main statement, we sometimes dump extra
399 /// information. There's often a lot of little things "nuzzled up" in
401 fn write_extra<'tcx, F>(tcx: TyCtxt<'tcx>, write: &mut dyn Write, mut visit_op: F) -> io::Result<()>
403 F: FnMut(&mut ExtraComments<'tcx>),
405 let mut extra_comments = ExtraComments { tcx, comments: vec![] };
406 visit_op(&mut extra_comments);
407 for comment in extra_comments.comments {
408 writeln!(write, "{:A$} // {}", "", comment, A = ALIGN)?;
413 struct ExtraComments<'tcx> {
415 comments: Vec<String>,
418 impl<'tcx> ExtraComments<'tcx> {
419 fn push(&mut self, lines: &str) {
420 for line in lines.split('\n') {
421 self.comments.push(line.to_string());
426 fn use_verbose<'tcx>(ty: Ty<'tcx>, fn_def: bool) -> bool {
428 ty::Int(_) | ty::Uint(_) | ty::Bool | ty::Char | ty::Float(_) => false,
430 ty::Tuple(g_args) if g_args.is_empty() => false,
431 ty::Tuple(g_args) => g_args.iter().any(|g_arg| use_verbose(g_arg, fn_def)),
432 ty::Array(ty, _) => use_verbose(ty, fn_def),
433 ty::FnDef(..) => fn_def,
438 impl<'tcx> Visitor<'tcx> for ExtraComments<'tcx> {
439 fn visit_constant(&mut self, constant: &Constant<'tcx>, _location: Location) {
440 let Constant { span, user_ty, literal } = constant;
441 if use_verbose(literal.ty(), true) {
442 self.push("mir::Constant");
445 self.tcx.sess.source_map().span_to_embeddable_string(*span)
447 if let Some(user_ty) = user_ty {
448 self.push(&format!("+ user_ty: {:?}", user_ty));
451 let fmt_val = |val: &ConstValue<'tcx>| match val {
452 ConstValue::Scalar(s) => format!("Scalar({:?})", s),
453 ConstValue::Slice { .. } => format!("Slice(..)"),
454 ConstValue::ByRef { .. } => format!("ByRef(..)"),
457 let val = match literal {
458 ConstantKind::Ty(ct) => match ct.val() {
459 ty::ConstKind::Param(p) => format!("Param({})", p),
460 ty::ConstKind::Unevaluated(uv) => format!(
461 "Unevaluated({}, {:?}, {:?})",
462 self.tcx.def_path_str(uv.def.did),
466 ty::ConstKind::Value(val) => format!("Value({})", fmt_val(&val)),
467 ty::ConstKind::Error(_) => "Error".to_string(),
468 // These variants shouldn't exist in the MIR.
469 ty::ConstKind::Placeholder(_)
470 | ty::ConstKind::Infer(_)
471 | ty::ConstKind::Bound(..) => bug!("unexpected MIR constant: {:?}", literal),
473 // To keep the diffs small, we render this like we render `ty::Const::Value`.
475 // This changes once `ty::Const::Value` is represented using valtrees.
476 ConstantKind::Val(val, _) => format!("Value({})", fmt_val(&val)),
479 self.push(&format!("+ literal: Const {{ ty: {}, val: {} }}", literal.ty(), val));
483 fn visit_rvalue(&mut self, rvalue: &Rvalue<'tcx>, location: Location) {
484 self.super_rvalue(rvalue, location);
485 if let Rvalue::Aggregate(kind, _) = rvalue {
487 AggregateKind::Closure(def_id, substs) => {
488 self.push("closure");
489 self.push(&format!("+ def_id: {:?}", def_id));
490 self.push(&format!("+ substs: {:#?}", substs));
493 AggregateKind::Generator(def_id, substs, movability) => {
494 self.push("generator");
495 self.push(&format!("+ def_id: {:?}", def_id));
496 self.push(&format!("+ substs: {:#?}", substs));
497 self.push(&format!("+ movability: {:?}", movability));
500 AggregateKind::Adt(_, _, _, Some(user_ty), _) => {
502 self.push(&format!("+ user_ty: {:?}", user_ty));
511 fn comment(tcx: TyCtxt<'_>, SourceInfo { span, scope }: SourceInfo) -> String {
512 format!("scope {} at {}", scope.index(), tcx.sess.source_map().span_to_embeddable_string(span))
515 /// Prints local variables in a scope tree.
519 scope_tree: &FxHashMap<SourceScope, Vec<SourceScope>>,
523 ) -> io::Result<()> {
524 let indent = depth * INDENT.len();
526 // Local variable debuginfo.
527 for var_debug_info in &body.var_debug_info {
528 if var_debug_info.source_info.scope != parent {
529 // Not declared in this scope.
533 let indented_debug_info = format!(
534 "{0:1$}debug {2} => {3:?};",
535 INDENT, indent, var_debug_info.name, var_debug_info.value,
543 comment(tcx, var_debug_info.source_info),
547 // Local variable types.
548 for (local, local_decl) in body.local_decls.iter_enumerated() {
549 if (1..body.arg_count + 1).contains(&local.index()) {
550 // Skip over argument locals, they're printed in the signature.
554 if local_decl.source_info.scope != parent {
555 // Not declared in this scope.
559 let mut_str = if local_decl.mutability == Mutability::Mut { "mut " } else { "" };
561 let mut indented_decl =
562 format!("{0:1$}let {2}{3:?}: {4:?}", INDENT, indent, mut_str, local, local_decl.ty);
563 if let Some(user_ty) = &local_decl.user_ty {
564 for user_ty in user_ty.projections() {
565 write!(indented_decl, " as {:?}", user_ty).unwrap();
568 indented_decl.push(';');
570 let local_name = if local == RETURN_PLACE { " return place" } else { "" };
574 "{0:1$} //{2} in {3}",
578 comment(tcx, local_decl.source_info),
582 let Some(children) = scope_tree.get(&parent) else {
586 for &child in children {
587 let child_data = &body.source_scopes[child];
588 assert_eq!(child_data.parent_scope, Some(parent));
590 let (special, span) = if let Some((callee, callsite_span)) = child_data.inlined {
594 if callee.def.requires_caller_location(tcx) { "#[track_caller] " } else { "" },
600 (String::new(), None)
603 let indented_header = format!("{0:1$}scope {2}{3} {{", "", indent, child.index(), special);
605 if let Some(span) = span {
611 tcx.sess.source_map().span_to_embeddable_string(span),
614 writeln!(w, "{}", indented_header)?;
617 write_scope_tree(tcx, body, scope_tree, w, child, depth + 1)?;
618 writeln!(w, "{0:1$}}}", "", depth * INDENT.len())?;
624 /// Write out a human-readable textual representation of the MIR's `fn` type and the types of its
625 /// local variables (both user-defined bindings and compiler temporaries).
626 pub fn write_mir_intro<'tcx>(
630 ) -> io::Result<()> {
631 write_mir_sig(tcx, body, w)?;
634 // construct a scope tree and write it out
635 let mut scope_tree: FxHashMap<SourceScope, Vec<SourceScope>> = Default::default();
636 for (index, scope_data) in body.source_scopes.iter().enumerate() {
637 if let Some(parent) = scope_data.parent_scope {
638 scope_tree.entry(parent).or_default().push(SourceScope::new(index));
640 // Only the argument scope has no parent, because it's the root.
641 assert_eq!(index, OUTERMOST_SOURCE_SCOPE.index());
645 write_scope_tree(tcx, body, &scope_tree, w, OUTERMOST_SOURCE_SCOPE, 1)?;
647 // Add an empty line before the first block is printed.
653 /// Find all `AllocId`s mentioned (recursively) in the MIR body and print their corresponding
655 pub fn write_allocations<'tcx>(
659 ) -> io::Result<()> {
660 fn alloc_ids_from_alloc(
661 alloc: ConstAllocation<'_>,
662 ) -> impl DoubleEndedIterator<Item = AllocId> + '_ {
663 alloc.inner().relocations().values().map(|id| *id)
665 fn alloc_ids_from_const(val: ConstValue<'_>) -> impl Iterator<Item = AllocId> + '_ {
667 ConstValue::Scalar(interpret::Scalar::Ptr(ptr, _)) => {
668 Either::Left(Either::Left(std::iter::once(ptr.provenance)))
670 ConstValue::Scalar(interpret::Scalar::Int { .. }) => {
671 Either::Left(Either::Right(std::iter::empty()))
673 ConstValue::ByRef { alloc, .. } | ConstValue::Slice { data: alloc, .. } => {
674 Either::Right(alloc_ids_from_alloc(alloc))
678 struct CollectAllocIds(BTreeSet<AllocId>);
680 impl<'tcx> Visitor<'tcx> for CollectAllocIds {
681 fn visit_const(&mut self, c: ty::Const<'tcx>, _loc: Location) {
682 if let ty::ConstKind::Value(val) = c.val() {
683 self.0.extend(alloc_ids_from_const(val));
687 fn visit_constant(&mut self, c: &Constant<'tcx>, loc: Location) {
689 ConstantKind::Ty(c) => self.visit_const(c, loc),
690 ConstantKind::Val(val, _) => {
691 self.0.extend(alloc_ids_from_const(val));
697 let mut visitor = CollectAllocIds(Default::default());
698 visitor.visit_body(body);
700 // `seen` contains all seen allocations, including the ones we have *not* printed yet.
701 // The protocol is to first `insert` into `seen`, and only if that returns `true`
702 // then push to `todo`.
703 let mut seen = visitor.0;
704 let mut todo: Vec<_> = seen.iter().copied().collect();
705 while let Some(id) = todo.pop() {
706 let mut write_allocation_track_relocs =
707 |w: &mut dyn Write, alloc: ConstAllocation<'tcx>| -> io::Result<()> {
708 // `.rev()` because we are popping them from the back of the `todo` vector.
709 for id in alloc_ids_from_alloc(alloc).rev() {
714 write!(w, "{}", display_allocation(tcx, alloc.inner()))
716 write!(w, "\n{}", id)?;
717 match tcx.get_global_alloc(id) {
718 // This can't really happen unless there are bugs, but it doesn't cost us anything to
719 // gracefully handle it and allow buggy rustc to be debugged via allocation printing.
720 None => write!(w, " (deallocated)")?,
721 Some(GlobalAlloc::Function(inst)) => write!(w, " (fn: {})", inst)?,
722 Some(GlobalAlloc::Static(did)) if !tcx.is_foreign_item(did) => {
723 match tcx.eval_static_initializer(did) {
725 write!(w, " (static: {}, ", tcx.def_path_str(did))?;
726 write_allocation_track_relocs(w, alloc)?;
730 " (static: {}, error during initializer evaluation)",
731 tcx.def_path_str(did)
735 Some(GlobalAlloc::Static(did)) => {
736 write!(w, " (extern static: {})", tcx.def_path_str(did))?
738 Some(GlobalAlloc::Memory(alloc)) => {
740 write_allocation_track_relocs(w, alloc)?
748 /// Dumps the size and metadata and content of an allocation to the given writer.
749 /// The expectation is that the caller first prints other relevant metadata, so the exact
750 /// format of this function is (*without* leading or trailing newline):
753 /// size: {}, align: {}) {
758 /// The byte format is similar to how hex editors print bytes. Each line starts with the address of
759 /// the start of the line, followed by all bytes in hex format (space separated).
760 /// If the allocation is small enough to fit into a single line, no start address is given.
761 /// After the hex dump, an ascii dump follows, replacing all unprintable characters (control
762 /// characters or characters whose value is larger than 127) with a `.`
763 /// This also prints relocations adequately.
764 pub fn display_allocation<'a, 'tcx, Tag, Extra>(
766 alloc: &'a Allocation<Tag, Extra>,
767 ) -> RenderAllocation<'a, 'tcx, Tag, Extra> {
768 RenderAllocation { tcx, alloc }
772 pub struct RenderAllocation<'a, 'tcx, Tag, Extra> {
774 alloc: &'a Allocation<Tag, Extra>,
777 impl<'a, 'tcx, Tag: Provenance, Extra> std::fmt::Display
778 for RenderAllocation<'a, 'tcx, Tag, Extra>
780 fn fmt(&self, w: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
781 let RenderAllocation { tcx, alloc } = *self;
782 write!(w, "size: {}, align: {})", alloc.size().bytes(), alloc.align.bytes())?;
783 if alloc.size() == Size::ZERO {
785 return write!(w, " {{}}");
787 // Write allocation bytes.
789 write_allocation_bytes(tcx, alloc, w, " ")?;
795 fn write_allocation_endline(w: &mut dyn std::fmt::Write, ascii: &str) -> std::fmt::Result {
796 for _ in 0..(BYTES_PER_LINE - ascii.chars().count()) {
799 writeln!(w, " │ {}", ascii)
802 /// Number of bytes to print per allocation hex dump line.
803 const BYTES_PER_LINE: usize = 16;
805 /// Prints the line start address and returns the new line start address.
806 fn write_allocation_newline(
807 w: &mut dyn std::fmt::Write,
808 mut line_start: Size,
812 ) -> Result<Size, std::fmt::Error> {
813 write_allocation_endline(w, ascii)?;
814 line_start += Size::from_bytes(BYTES_PER_LINE);
815 write!(w, "{}0x{:02$x} │ ", prefix, line_start.bytes(), pos_width)?;
819 /// The `prefix` argument allows callers to add an arbitrary prefix before each line (even if there
820 /// is only one line). Note that your prefix should contain a trailing space as the lines are
821 /// printed directly after it.
822 fn write_allocation_bytes<'tcx, Tag: Provenance, Extra>(
824 alloc: &Allocation<Tag, Extra>,
825 w: &mut dyn std::fmt::Write,
827 ) -> std::fmt::Result {
828 let num_lines = alloc.size().bytes_usize().saturating_sub(BYTES_PER_LINE);
829 // Number of chars needed to represent all line numbers.
830 let pos_width = hex_number_length(alloc.size().bytes());
833 write!(w, "{}0x{:02$x} │ ", prefix, 0, pos_width)?;
835 write!(w, "{}", prefix)?;
838 let mut i = Size::ZERO;
839 let mut line_start = Size::ZERO;
841 let ptr_size = tcx.data_layout.pointer_size;
843 let mut ascii = String::new();
845 let oversized_ptr = |target: &mut String, width| {
846 if target.len() > width {
847 write!(target, " ({} ptr bytes)", ptr_size.bytes()).unwrap();
851 while i < alloc.size() {
852 // The line start already has a space. While we could remove that space from the line start
853 // printing and unconditionally print a space here, that would cause the single-line case
854 // to have a single space before it, which looks weird.
858 if let Some(&tag) = alloc.relocations().get(&i) {
859 // Memory with a relocation must be defined
860 assert!(alloc.init_mask().is_range_initialized(i, i + ptr_size).is_ok());
861 let j = i.bytes_usize();
863 .inspect_with_uninit_and_ptr_outside_interpreter(j..j + ptr_size.bytes_usize());
864 let offset = read_target_uint(tcx.data_layout.endian, offset).unwrap();
865 let offset = Size::from_bytes(offset);
866 let relocation_width = |bytes| bytes * 3;
867 let ptr = Pointer::new(tag, offset);
868 let mut target = format!("{:?}", ptr);
869 if target.len() > relocation_width(ptr_size.bytes_usize() - 1) {
870 // This is too long, try to save some space.
871 target = format!("{:#?}", ptr);
873 if ((i - line_start) + ptr_size).bytes_usize() > BYTES_PER_LINE {
874 // This branch handles the situation where a relocation starts in the current line
875 // but ends in the next one.
876 let remainder = Size::from_bytes(BYTES_PER_LINE) - (i - line_start);
877 let overflow = ptr_size - remainder;
878 let remainder_width = relocation_width(remainder.bytes_usize()) - 2;
879 let overflow_width = relocation_width(overflow.bytes_usize() - 1) + 1;
881 for _ in 0..remainder.bytes() - 1 {
884 if overflow_width > remainder_width && overflow_width >= target.len() {
885 // The case where the relocation fits into the part in the next line
886 write!(w, "╾{0:─^1$}", "", remainder_width)?;
888 write_allocation_newline(w, line_start, &ascii, pos_width, prefix)?;
890 write!(w, "{0:─^1$}╼", target, overflow_width)?;
892 oversized_ptr(&mut target, remainder_width);
893 write!(w, "╾{0:─^1$}", target, remainder_width)?;
895 write_allocation_newline(w, line_start, &ascii, pos_width, prefix)?;
896 write!(w, "{0:─^1$}╼", "", overflow_width)?;
899 for _ in 0..overflow.bytes() - 1 {
906 // This branch handles a relocation that starts and ends in the current line.
907 let relocation_width = relocation_width(ptr_size.bytes_usize() - 1);
908 oversized_ptr(&mut target, relocation_width);
910 write!(w, "╾{0:─^1$}╼", target, relocation_width)?;
911 for _ in 0..ptr_size.bytes() - 2 {
917 } else if alloc.init_mask().is_range_initialized(i, i + Size::from_bytes(1)).is_ok() {
918 let j = i.bytes_usize();
920 // Checked definedness (and thus range) and relocations. This access also doesn't
921 // influence interpreter execution but is only for debugging.
922 let c = alloc.inspect_with_uninit_and_ptr_outside_interpreter(j..j + 1)[0];
923 write!(w, "{:02x}", c)?;
924 if c.is_ascii_control() || c >= 0x80 {
927 ascii.push(char::from(c));
929 i += Size::from_bytes(1);
933 i += Size::from_bytes(1);
935 // Print a new line header if the next line still has some bytes to print.
936 if i == line_start + Size::from_bytes(BYTES_PER_LINE) && i != alloc.size() {
937 line_start = write_allocation_newline(w, line_start, &ascii, pos_width, prefix)?;
941 write_allocation_endline(w, &ascii)?;
946 fn write_mir_sig(tcx: TyCtxt<'_>, body: &Body<'_>, w: &mut dyn Write) -> io::Result<()> {
947 use rustc_hir::def::DefKind;
949 trace!("write_mir_sig: {:?}", body.source.instance);
950 let def_id = body.source.def_id();
951 let kind = tcx.def_kind(def_id);
952 let is_function = match kind {
953 DefKind::Fn | DefKind::AssocFn | DefKind::Ctor(..) => true,
954 _ => tcx.is_closure(def_id),
956 match (kind, body.source.promoted) {
957 (_, Some(i)) => write!(w, "{:?} in ", i)?,
958 (DefKind::Const | DefKind::AssocConst, _) => write!(w, "const ")?,
959 (DefKind::Static(hir::Mutability::Not), _) => write!(w, "static ")?,
960 (DefKind::Static(hir::Mutability::Mut), _) => write!(w, "static mut ")?,
961 (_, _) if is_function => write!(w, "fn ")?,
962 (DefKind::AnonConst | DefKind::InlineConst, _) => {} // things like anon const, not an item
963 _ => bug!("Unexpected def kind {:?}", kind),
966 ty::print::with_forced_impl_filename_line! {
967 // see notes on #41697 elsewhere
968 write!(w, "{}", tcx.def_path_str(def_id))?
971 if body.source.promoted.is_none() && is_function {
974 // fn argument types.
975 for (i, arg) in body.args_iter().enumerate() {
979 write!(w, "{:?}: {}", Place::from(arg), body.local_decls[arg].ty)?;
982 write!(w, ") -> {}", body.return_ty())?;
984 assert_eq!(body.arg_count, 0);
985 write!(w, ": {} =", body.return_ty())?;
988 if let Some(yield_ty) = body.yield_ty() {
990 writeln!(w, "yields {}", yield_ty)?;
994 // Next thing that gets printed is the opening {
999 fn write_user_type_annotations(
1003 ) -> io::Result<()> {
1004 if !body.user_type_annotations.is_empty() {
1005 writeln!(w, "| User Type Annotations")?;
1007 for (index, annotation) in body.user_type_annotations.iter_enumerated() {
1010 "| {:?}: {:?} at {}",
1013 tcx.sess.source_map().span_to_embeddable_string(annotation.span)
1016 if !body.user_type_annotations.is_empty() {
1022 pub fn dump_mir_def_ids(tcx: TyCtxt<'_>, single: Option<DefId>) -> Vec<DefId> {
1023 if let Some(i) = single {
1026 tcx.mir_keys(()).iter().map(|def_id| def_id.to_def_id()).collect()
1030 /// Calc converted u64 decimal into hex and return it's length in chars
1032 /// ```ignore (cannot-test-private-function)
1033 /// assert_eq!(1, hex_number_length(0));
1034 /// assert_eq!(1, hex_number_length(1));
1035 /// assert_eq!(2, hex_number_length(16));
1037 fn hex_number_length(x: u64) -> usize {