f7931c8050
I left a few, like
```rust
let result: Result<_, ModError<'_>> = try {
```
where it felt like seeing it might still be useful for the reader.
Feel free to push back on any of these changes if you think seeing the type would be better.
2024 lines
77 KiB
Rust
2024 lines
77 KiB
Rust
use std::collections::BTreeSet;
|
|
use std::fmt::{Display, Write as _};
|
|
use std::path::{Path, PathBuf};
|
|
use std::{fs, io};
|
|
|
|
use rustc_abi::Size;
|
|
use rustc_ast::InlineAsmTemplatePiece;
|
|
use tracing::trace;
|
|
use ty::print::PrettyPrinter;
|
|
|
|
use super::graphviz::write_mir_fn_graphviz;
|
|
use crate::mir::interpret::{
|
|
AllocBytes, AllocId, Allocation, ConstAllocation, GlobalAlloc, Pointer, Provenance,
|
|
alloc_range, read_target_uint,
|
|
};
|
|
use crate::mir::visit::Visitor;
|
|
use crate::mir::*;
|
|
|
|
const INDENT: &str = " ";
|
|
/// Alignment for lining up comments following MIR statements
|
|
pub(crate) const ALIGN: usize = 40;
|
|
|
|
/// An indication of where we are in the control flow graph. Used for printing
|
|
/// extra information in `dump_mir`
|
|
#[derive(Clone, Copy)]
|
|
pub enum PassWhere {
|
|
/// We have not started dumping the control flow graph, but we are about to.
|
|
BeforeCFG,
|
|
|
|
/// We just finished dumping the control flow graph. This is right before EOF
|
|
AfterCFG,
|
|
|
|
/// We are about to start dumping the given basic block.
|
|
BeforeBlock(BasicBlock),
|
|
|
|
/// We are just about to dump the given statement or terminator.
|
|
BeforeLocation(Location),
|
|
|
|
/// We just dumped the given statement or terminator.
|
|
AfterLocation(Location),
|
|
|
|
/// We just dumped the terminator for a block but not the closing `}`.
|
|
AfterTerminator(BasicBlock),
|
|
}
|
|
|
|
/// Cosmetic options for pretty-printing the MIR contents, gathered from the CLI. Each pass can
|
|
/// override these when dumping its own specific MIR information with `dump_mir`.
|
|
#[derive(Copy, Clone)]
|
|
pub struct PrettyPrintMirOptions {
|
|
/// Whether to include extra comments, like span info. From `-Z mir-include-spans`.
|
|
pub include_extra_comments: bool,
|
|
}
|
|
|
|
impl PrettyPrintMirOptions {
|
|
/// Create the default set of MIR pretty-printing options from the CLI flags.
|
|
pub fn from_cli(tcx: TyCtxt<'_>) -> Self {
|
|
Self { include_extra_comments: tcx.sess.opts.unstable_opts.mir_include_spans.is_enabled() }
|
|
}
|
|
}
|
|
|
|
/// Manages MIR dumping, which is MIR writing done to a file with a specific name. In particular,
|
|
/// it makes it impossible to dump MIR to one of these files when it hasn't been requested from the
|
|
/// command line. Layered on top of `MirWriter`, which does the actual writing.
|
|
pub struct MirDumper<'dis, 'de, 'tcx> {
|
|
show_pass_num: bool,
|
|
pass_name: &'static str,
|
|
disambiguator: &'dis dyn Display,
|
|
writer: MirWriter<'de, 'tcx>,
|
|
}
|
|
|
|
impl<'dis, 'de, 'tcx> MirDumper<'dis, 'de, 'tcx> {
|
|
// If dumping should be performed (e.g. because it was requested on the
|
|
// CLI), returns a `MirDumper` with default values for the following fields:
|
|
// - `show_pass_num`: `false`
|
|
// - `disambiguator`: `&0`
|
|
// - `writer.extra_data`: a no-op
|
|
// - `writer.options`: default options derived from CLI flags
|
|
pub fn new(tcx: TyCtxt<'tcx>, pass_name: &'static str, body: &Body<'tcx>) -> Option<Self> {
|
|
let dump_enabled = if let Some(ref filters) = tcx.sess.opts.unstable_opts.dump_mir {
|
|
// see notes on #41697 below
|
|
let node_path = ty::print::with_no_trimmed_paths!(
|
|
ty::print::with_forced_impl_filename_line!(tcx.def_path_str(body.source.def_id()))
|
|
);
|
|
filters.split('|').any(|or_filter| {
|
|
or_filter.split('&').all(|and_filter| {
|
|
let and_filter_trimmed = and_filter.trim();
|
|
and_filter_trimmed == "all"
|
|
|| pass_name.contains(and_filter_trimmed)
|
|
|| node_path.contains(and_filter_trimmed)
|
|
})
|
|
})
|
|
} else {
|
|
false
|
|
};
|
|
|
|
dump_enabled.then_some(MirDumper {
|
|
show_pass_num: false,
|
|
pass_name,
|
|
disambiguator: &0,
|
|
writer: MirWriter::new(tcx),
|
|
})
|
|
}
|
|
|
|
pub fn tcx(&self) -> TyCtxt<'tcx> {
|
|
self.writer.tcx
|
|
}
|
|
|
|
#[must_use]
|
|
pub fn set_show_pass_num(mut self) -> Self {
|
|
self.show_pass_num = true;
|
|
self
|
|
}
|
|
|
|
#[must_use]
|
|
pub fn set_disambiguator(mut self, disambiguator: &'dis dyn Display) -> Self {
|
|
self.disambiguator = disambiguator;
|
|
self
|
|
}
|
|
|
|
#[must_use]
|
|
pub fn set_extra_data(
|
|
mut self,
|
|
extra_data: &'de dyn Fn(PassWhere, &mut dyn io::Write) -> io::Result<()>,
|
|
) -> Self {
|
|
self.writer.extra_data = extra_data;
|
|
self
|
|
}
|
|
|
|
#[must_use]
|
|
pub fn set_options(mut self, options: PrettyPrintMirOptions) -> Self {
|
|
self.writer.options = options;
|
|
self
|
|
}
|
|
|
|
/// If the session is properly configured, dumps a human-readable representation of the MIR
|
|
/// (with default pretty-printing options) into:
|
|
///
|
|
/// ```text
|
|
/// rustc.node<node_id>.<pass_num>.<pass_name>.<disambiguator>
|
|
/// ```
|
|
///
|
|
/// Output from this function is controlled by passing `-Z dump-mir=<filter>`,
|
|
/// where `<filter>` takes the following forms:
|
|
///
|
|
/// - `all` -- dump MIR for all fns, all passes, all everything
|
|
/// - a filter defined by a set of substrings combined with `&` and `|`
|
|
/// (`&` has higher precedence). At least one of the `|`-separated groups
|
|
/// must match; an `|`-separated group matches if all of its `&`-separated
|
|
/// substrings are matched.
|
|
///
|
|
/// Example:
|
|
///
|
|
/// - `nll` == match if `nll` appears in the name
|
|
/// - `foo & nll` == match if `foo` and `nll` both appear in the name
|
|
/// - `foo & nll | typeck` == match if `foo` and `nll` both appear in the name
|
|
/// or `typeck` appears in the name.
|
|
/// - `foo & nll | bar & typeck` == match if `foo` and `nll` both appear in the name
|
|
/// or `typeck` and `bar` both appear in the name.
|
|
pub fn dump_mir(&self, body: &Body<'tcx>) {
|
|
let _ = try {
|
|
let mut file = self.create_dump_file("mir", body)?;
|
|
self.dump_mir_to_writer(body, &mut file)?;
|
|
};
|
|
|
|
if self.tcx().sess.opts.unstable_opts.dump_mir_graphviz {
|
|
let _ = try {
|
|
let mut file = self.create_dump_file("dot", body)?;
|
|
write_mir_fn_graphviz(self.tcx(), body, false, &mut file)?;
|
|
};
|
|
}
|
|
}
|
|
|
|
// #41697 -- we use `with_forced_impl_filename_line()` because `def_path_str()` would otherwise
|
|
// trigger `type_of`, and this can run while we are already attempting to evaluate `type_of`.
|
|
pub fn dump_mir_to_writer(&self, body: &Body<'tcx>, w: &mut dyn io::Write) -> io::Result<()> {
|
|
// see notes on #41697 above
|
|
let def_path =
|
|
ty::print::with_no_trimmed_paths!(ty::print::with_forced_impl_filename_line!(
|
|
self.tcx().def_path_str(body.source.def_id())
|
|
));
|
|
// ignore-tidy-odd-backticks the literal below is fine
|
|
write!(w, "// MIR for `{def_path}")?;
|
|
match body.source.promoted {
|
|
None => write!(w, "`")?,
|
|
Some(promoted) => write!(w, "::{promoted:?}`")?,
|
|
}
|
|
writeln!(w, " {} {}", self.disambiguator, self.pass_name)?;
|
|
if let Some(ref layout) = body.coroutine_layout_raw() {
|
|
writeln!(w, "/* coroutine_layout = {layout:#?} */")?;
|
|
}
|
|
writeln!(w)?;
|
|
(self.writer.extra_data)(PassWhere::BeforeCFG, w)?;
|
|
write_user_type_annotations(self.tcx(), body, w)?;
|
|
self.writer.write_mir_fn(body, w)?;
|
|
(self.writer.extra_data)(PassWhere::AfterCFG, w)
|
|
}
|
|
|
|
/// Returns the path to the filename where we should dump a given MIR.
|
|
/// Also used by other bits of code (e.g., NLL inference) that dump
|
|
/// graphviz data or other things.
|
|
fn dump_path(&self, extension: &str, body: &Body<'tcx>) -> PathBuf {
|
|
let tcx = self.tcx();
|
|
let source = body.source;
|
|
let promotion_id = match source.promoted {
|
|
Some(id) => format!("-{id:?}"),
|
|
None => String::new(),
|
|
};
|
|
|
|
let pass_num = if tcx.sess.opts.unstable_opts.dump_mir_exclude_pass_number {
|
|
String::new()
|
|
} else if self.show_pass_num {
|
|
let (dialect_index, phase_index) = body.phase.index();
|
|
format!(".{}-{}-{:03}", dialect_index, phase_index, body.pass_count)
|
|
} else {
|
|
".-------".to_string()
|
|
};
|
|
|
|
let crate_name = tcx.crate_name(source.def_id().krate);
|
|
let item_name = tcx.def_path(source.def_id()).to_filename_friendly_no_crate();
|
|
// All drop shims have the same DefId, so we have to add the type
|
|
// to get unique file names.
|
|
let shim_disambiguator = match source.instance {
|
|
ty::InstanceKind::DropGlue(_, Some(ty)) => {
|
|
// Unfortunately, pretty-printed types are not very filename-friendly.
|
|
// We do some filtering.
|
|
let mut s = ".".to_owned();
|
|
s.extend(ty.to_string().chars().filter_map(|c| match c {
|
|
' ' => None,
|
|
':' | '<' | '>' => Some('_'),
|
|
c => Some(c),
|
|
}));
|
|
s
|
|
}
|
|
ty::InstanceKind::AsyncDropGlueCtorShim(_, ty) => {
|
|
let mut s = ".".to_owned();
|
|
s.extend(ty.to_string().chars().filter_map(|c| match c {
|
|
' ' => None,
|
|
':' | '<' | '>' => Some('_'),
|
|
c => Some(c),
|
|
}));
|
|
s
|
|
}
|
|
ty::InstanceKind::AsyncDropGlue(_, ty) => {
|
|
let ty::Coroutine(_, args) = ty.kind() else {
|
|
bug!();
|
|
};
|
|
let ty = args.first().unwrap().expect_ty();
|
|
let mut s = ".".to_owned();
|
|
s.extend(ty.to_string().chars().filter_map(|c| match c {
|
|
' ' => None,
|
|
':' | '<' | '>' => Some('_'),
|
|
c => Some(c),
|
|
}));
|
|
s
|
|
}
|
|
ty::InstanceKind::FutureDropPollShim(_, proxy_cor, impl_cor) => {
|
|
let mut s = ".".to_owned();
|
|
s.extend(proxy_cor.to_string().chars().filter_map(|c| match c {
|
|
' ' => None,
|
|
':' | '<' | '>' => Some('_'),
|
|
c => Some(c),
|
|
}));
|
|
s.push('.');
|
|
s.extend(impl_cor.to_string().chars().filter_map(|c| match c {
|
|
' ' => None,
|
|
':' | '<' | '>' => Some('_'),
|
|
c => Some(c),
|
|
}));
|
|
s
|
|
}
|
|
_ => String::new(),
|
|
};
|
|
|
|
let mut file_path = PathBuf::new();
|
|
file_path.push(Path::new(&tcx.sess.opts.unstable_opts.dump_mir_dir));
|
|
|
|
let pass_name = self.pass_name;
|
|
let disambiguator = self.disambiguator;
|
|
let file_name = format!(
|
|
"{crate_name}.{item_name}{shim_disambiguator}{promotion_id}{pass_num}.{pass_name}.{disambiguator}.{extension}",
|
|
);
|
|
|
|
file_path.push(&file_name);
|
|
|
|
file_path
|
|
}
|
|
|
|
/// Attempts to open a file where we should dump a given MIR or other
|
|
/// bit of MIR-related data. Used by `mir-dump`, but also by other
|
|
/// bits of code (e.g., NLL inference) that dump graphviz data or
|
|
/// other things, and hence takes the extension as an argument.
|
|
pub fn create_dump_file(
|
|
&self,
|
|
extension: &str,
|
|
body: &Body<'tcx>,
|
|
) -> io::Result<io::BufWriter<fs::File>> {
|
|
let file_path = self.dump_path(extension, body);
|
|
if let Some(parent) = file_path.parent() {
|
|
fs::create_dir_all(parent).map_err(|e| {
|
|
io::Error::new(
|
|
e.kind(),
|
|
format!("IO error creating MIR dump directory: {parent:?}; {e}"),
|
|
)
|
|
})?;
|
|
}
|
|
fs::File::create_buffered(&file_path).map_err(|e| {
|
|
io::Error::new(e.kind(), format!("IO error creating MIR dump file: {file_path:?}; {e}"))
|
|
})
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
// Whole MIR bodies
|
|
|
|
/// Write out a human-readable textual representation for the given MIR, with the default
|
|
/// [PrettyPrintMirOptions].
|
|
pub fn write_mir_pretty<'tcx>(
|
|
tcx: TyCtxt<'tcx>,
|
|
single: Option<DefId>,
|
|
w: &mut dyn io::Write,
|
|
) -> io::Result<()> {
|
|
let writer = MirWriter::new(tcx);
|
|
|
|
writeln!(w, "// WARNING: This output format is intended for human consumers only")?;
|
|
writeln!(w, "// and is subject to change without notice. Knock yourself out.")?;
|
|
writeln!(w, "// HINT: See also -Z dump-mir for MIR at specific points during compilation.")?;
|
|
|
|
let mut first = true;
|
|
for def_id in dump_mir_def_ids(tcx, single) {
|
|
if first {
|
|
first = false;
|
|
} else {
|
|
// Put empty lines between all items
|
|
writeln!(w)?;
|
|
}
|
|
|
|
let render_body = |w: &mut dyn io::Write, body| -> io::Result<()> {
|
|
writer.write_mir_fn(body, w)?;
|
|
|
|
for body in tcx.promoted_mir(def_id) {
|
|
writeln!(w)?;
|
|
writer.write_mir_fn(body, w)?;
|
|
}
|
|
Ok(())
|
|
};
|
|
|
|
// For `const fn` we want to render both the optimized MIR and the MIR for ctfe.
|
|
if tcx.is_const_fn(def_id) {
|
|
render_body(w, tcx.optimized_mir(def_id))?;
|
|
writeln!(w)?;
|
|
writeln!(w, "// MIR FOR CTFE")?;
|
|
// Do not use `render_body`, as that would render the promoteds again, but these
|
|
// are shared between mir_for_ctfe and optimized_mir
|
|
writer.write_mir_fn(tcx.mir_for_ctfe(def_id), w)?;
|
|
} else {
|
|
if let Some((val, ty)) = tcx.trivial_const(def_id) {
|
|
ty::print::with_forced_impl_filename_line! {
|
|
// see notes on #41697 elsewhere
|
|
write!(w, "const {}", tcx.def_path_str(def_id))?
|
|
}
|
|
writeln!(w, ": {} = const {};", ty, Const::Val(val, ty))?;
|
|
} else {
|
|
let instance_mir = tcx.instance_mir(ty::InstanceKind::Item(def_id));
|
|
render_body(w, instance_mir)?;
|
|
}
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// Does the writing of MIR to output, e.g. a file.
|
|
pub struct MirWriter<'de, 'tcx> {
|
|
tcx: TyCtxt<'tcx>,
|
|
extra_data: &'de dyn Fn(PassWhere, &mut dyn io::Write) -> io::Result<()>,
|
|
options: PrettyPrintMirOptions,
|
|
}
|
|
|
|
impl<'de, 'tcx> MirWriter<'de, 'tcx> {
|
|
pub fn new(tcx: TyCtxt<'tcx>) -> Self {
|
|
MirWriter { tcx, extra_data: &|_, _| Ok(()), options: PrettyPrintMirOptions::from_cli(tcx) }
|
|
}
|
|
|
|
/// Write out a human-readable textual representation for the given function.
|
|
pub fn write_mir_fn(&self, body: &Body<'tcx>, w: &mut dyn io::Write) -> io::Result<()> {
|
|
write_mir_intro(self.tcx, body, w, self.options)?;
|
|
for block in body.basic_blocks.indices() {
|
|
(self.extra_data)(PassWhere::BeforeBlock(block), w)?;
|
|
self.write_basic_block(block, body, w)?;
|
|
if block.index() + 1 != body.basic_blocks.len() {
|
|
writeln!(w)?;
|
|
}
|
|
}
|
|
|
|
writeln!(w, "}}")?;
|
|
|
|
write_allocations(self.tcx, body, w)?;
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
/// Prints local variables in a scope tree.
|
|
fn write_scope_tree(
|
|
tcx: TyCtxt<'_>,
|
|
body: &Body<'_>,
|
|
scope_tree: &FxHashMap<SourceScope, Vec<SourceScope>>,
|
|
w: &mut dyn io::Write,
|
|
parent: SourceScope,
|
|
depth: usize,
|
|
options: PrettyPrintMirOptions,
|
|
) -> io::Result<()> {
|
|
let indent = depth * INDENT.len();
|
|
|
|
// Local variable debuginfo.
|
|
for var_debug_info in &body.var_debug_info {
|
|
if var_debug_info.source_info.scope != parent {
|
|
// Not declared in this scope.
|
|
continue;
|
|
}
|
|
|
|
let indented_debug_info = format!("{0:1$}debug {2:?};", INDENT, indent, var_debug_info);
|
|
|
|
if options.include_extra_comments {
|
|
writeln!(
|
|
w,
|
|
"{0:1$} // in {2}",
|
|
indented_debug_info,
|
|
ALIGN,
|
|
comment(tcx, var_debug_info.source_info),
|
|
)?;
|
|
} else {
|
|
writeln!(w, "{indented_debug_info}")?;
|
|
}
|
|
}
|
|
|
|
// Local variable types.
|
|
for (local, local_decl) in body.local_decls.iter_enumerated() {
|
|
if (1..body.arg_count + 1).contains(&local.index()) {
|
|
// Skip over argument locals, they're printed in the signature.
|
|
continue;
|
|
}
|
|
|
|
if local_decl.source_info.scope != parent {
|
|
// Not declared in this scope.
|
|
continue;
|
|
}
|
|
|
|
let mut_str = local_decl.mutability.prefix_str();
|
|
|
|
let mut indented_decl = ty::print::with_no_trimmed_paths!(format!(
|
|
"{0:1$}let {2}{3:?}: {4}",
|
|
INDENT, indent, mut_str, local, local_decl.ty
|
|
));
|
|
if let Some(user_ty) = &local_decl.user_ty {
|
|
for user_ty in user_ty.projections() {
|
|
write!(indented_decl, " as {user_ty:?}").unwrap();
|
|
}
|
|
}
|
|
indented_decl.push(';');
|
|
|
|
let local_name = if local == RETURN_PLACE { " return place" } else { "" };
|
|
|
|
if options.include_extra_comments {
|
|
writeln!(
|
|
w,
|
|
"{0:1$} //{2} in {3}",
|
|
indented_decl,
|
|
ALIGN,
|
|
local_name,
|
|
comment(tcx, local_decl.source_info),
|
|
)?;
|
|
} else {
|
|
writeln!(w, "{indented_decl}",)?;
|
|
}
|
|
}
|
|
|
|
let Some(children) = scope_tree.get(&parent) else {
|
|
return Ok(());
|
|
};
|
|
|
|
for &child in children {
|
|
let child_data = &body.source_scopes[child];
|
|
assert_eq!(child_data.parent_scope, Some(parent));
|
|
|
|
let (special, span) = if let Some((callee, callsite_span)) = child_data.inlined {
|
|
(
|
|
format!(
|
|
" (inlined {}{})",
|
|
if callee.def.requires_caller_location(tcx) { "#[track_caller] " } else { "" },
|
|
callee
|
|
),
|
|
Some(callsite_span),
|
|
)
|
|
} else {
|
|
(String::new(), None)
|
|
};
|
|
|
|
let indented_header = format!("{0:1$}scope {2}{3} {{", "", indent, child.index(), special);
|
|
|
|
if options.include_extra_comments {
|
|
if let Some(span) = span {
|
|
writeln!(
|
|
w,
|
|
"{0:1$} // at {2}",
|
|
indented_header,
|
|
ALIGN,
|
|
tcx.sess.source_map().span_to_diagnostic_string(span),
|
|
)?;
|
|
} else {
|
|
writeln!(w, "{indented_header}")?;
|
|
}
|
|
} else {
|
|
writeln!(w, "{indented_header}")?;
|
|
}
|
|
|
|
write_scope_tree(tcx, body, scope_tree, w, child, depth + 1, options)?;
|
|
writeln!(w, "{0:1$}}}", "", depth * INDENT.len())?;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
impl Debug for VarDebugInfo<'_> {
|
|
fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
|
|
if let Some(box VarDebugInfoFragment { ty, ref projection }) = self.composite {
|
|
pre_fmt_projection(&projection[..], fmt)?;
|
|
write!(fmt, "({}: {})", self.name, ty)?;
|
|
post_fmt_projection(&projection[..], fmt)?;
|
|
} else {
|
|
write!(fmt, "{}", self.name)?;
|
|
}
|
|
|
|
write!(fmt, " => {:?}", self.value)
|
|
}
|
|
}
|
|
|
|
/// Write out a human-readable textual representation of the MIR's `fn` type and the types of its
|
|
/// local variables (both user-defined bindings and compiler temporaries).
|
|
fn write_mir_intro<'tcx>(
|
|
tcx: TyCtxt<'tcx>,
|
|
body: &Body<'_>,
|
|
w: &mut dyn io::Write,
|
|
options: PrettyPrintMirOptions,
|
|
) -> io::Result<()> {
|
|
write_mir_sig(tcx, body, w)?;
|
|
writeln!(w, "{{")?;
|
|
|
|
// construct a scope tree and write it out
|
|
let mut scope_tree: FxHashMap<SourceScope, Vec<SourceScope>> = Default::default();
|
|
for (index, scope_data) in body.source_scopes.iter_enumerated() {
|
|
if let Some(parent) = scope_data.parent_scope {
|
|
scope_tree.entry(parent).or_default().push(index);
|
|
} else {
|
|
// Only the argument scope has no parent, because it's the root.
|
|
assert_eq!(index, OUTERMOST_SOURCE_SCOPE);
|
|
}
|
|
}
|
|
|
|
write_scope_tree(tcx, body, &scope_tree, w, OUTERMOST_SOURCE_SCOPE, 1, options)?;
|
|
|
|
// Add an empty line before the first block is printed.
|
|
writeln!(w)?;
|
|
|
|
if let Some(coverage_info_hi) = &body.coverage_info_hi {
|
|
write_coverage_info_hi(coverage_info_hi, w)?;
|
|
}
|
|
if let Some(function_coverage_info) = &body.function_coverage_info {
|
|
write_function_coverage_info(function_coverage_info, w)?;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn write_coverage_info_hi(
|
|
coverage_info_hi: &coverage::CoverageInfoHi,
|
|
w: &mut dyn io::Write,
|
|
) -> io::Result<()> {
|
|
let coverage::CoverageInfoHi { num_block_markers: _, branch_spans } = coverage_info_hi;
|
|
|
|
// Only add an extra trailing newline if we printed at least one thing.
|
|
let mut did_print = false;
|
|
|
|
for coverage::BranchSpan { span, true_marker, false_marker } in branch_spans {
|
|
writeln!(
|
|
w,
|
|
"{INDENT}coverage branch {{ true: {true_marker:?}, false: {false_marker:?} }} => {span:?}",
|
|
)?;
|
|
did_print = true;
|
|
}
|
|
|
|
if did_print {
|
|
writeln!(w)?;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn write_function_coverage_info(
|
|
function_coverage_info: &coverage::FunctionCoverageInfo,
|
|
w: &mut dyn io::Write,
|
|
) -> io::Result<()> {
|
|
let coverage::FunctionCoverageInfo { mappings, .. } = function_coverage_info;
|
|
|
|
for coverage::Mapping { kind, span } in mappings {
|
|
writeln!(w, "{INDENT}coverage {kind:?} => {span:?};")?;
|
|
}
|
|
writeln!(w)?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn write_mir_sig(tcx: TyCtxt<'_>, body: &Body<'_>, w: &mut dyn io::Write) -> io::Result<()> {
|
|
use rustc_hir::def::DefKind;
|
|
|
|
trace!("write_mir_sig: {:?}", body.source.instance);
|
|
let def_id = body.source.def_id();
|
|
let kind = tcx.def_kind(def_id);
|
|
let is_function = match kind {
|
|
DefKind::Fn | DefKind::AssocFn | DefKind::Ctor(..) | DefKind::SyntheticCoroutineBody => {
|
|
true
|
|
}
|
|
_ => tcx.is_closure_like(def_id),
|
|
};
|
|
match (kind, body.source.promoted) {
|
|
(_, Some(_)) => write!(w, "const ")?, // promoteds are the closest to consts
|
|
(DefKind::Const | DefKind::AssocConst, _) => write!(w, "const ")?,
|
|
(DefKind::Static { safety: _, mutability: hir::Mutability::Not, nested: false }, _) => {
|
|
write!(w, "static ")?
|
|
}
|
|
(DefKind::Static { safety: _, mutability: hir::Mutability::Mut, nested: false }, _) => {
|
|
write!(w, "static mut ")?
|
|
}
|
|
(_, _) if is_function => write!(w, "fn ")?,
|
|
// things like anon const, not an item
|
|
(DefKind::AnonConst | DefKind::InlineConst, _) => {}
|
|
// `global_asm!` have fake bodies, which we may dump after mir-build
|
|
(DefKind::GlobalAsm, _) => {}
|
|
_ => bug!("Unexpected def kind {:?}", kind),
|
|
}
|
|
|
|
ty::print::with_forced_impl_filename_line! {
|
|
// see notes on #41697 elsewhere
|
|
write!(w, "{}", tcx.def_path_str(def_id))?
|
|
}
|
|
if let Some(p) = body.source.promoted {
|
|
write!(w, "::{p:?}")?;
|
|
}
|
|
|
|
if body.source.promoted.is_none() && is_function {
|
|
write!(w, "(")?;
|
|
|
|
// fn argument types.
|
|
for (i, arg) in body.args_iter().enumerate() {
|
|
if i != 0 {
|
|
write!(w, ", ")?;
|
|
}
|
|
write!(w, "{:?}: {}", Place::from(arg), body.local_decls[arg].ty)?;
|
|
}
|
|
|
|
write!(w, ") -> {}", body.return_ty())?;
|
|
} else {
|
|
assert_eq!(body.arg_count, 0);
|
|
write!(w, ": {} =", body.return_ty())?;
|
|
}
|
|
|
|
if let Some(yield_ty) = body.yield_ty() {
|
|
writeln!(w)?;
|
|
writeln!(w, "yields {yield_ty}")?;
|
|
}
|
|
|
|
write!(w, " ")?;
|
|
// Next thing that gets printed is the opening {
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn write_user_type_annotations(
|
|
tcx: TyCtxt<'_>,
|
|
body: &Body<'_>,
|
|
w: &mut dyn io::Write,
|
|
) -> io::Result<()> {
|
|
if !body.user_type_annotations.is_empty() {
|
|
writeln!(w, "| User Type Annotations")?;
|
|
}
|
|
for (index, annotation) in body.user_type_annotations.iter_enumerated() {
|
|
writeln!(
|
|
w,
|
|
"| {:?}: user_ty: {}, span: {}, inferred_ty: {}",
|
|
index.index(),
|
|
annotation.user_ty,
|
|
tcx.sess.source_map().span_to_diagnostic_string(annotation.span),
|
|
with_no_trimmed_paths!(format!("{}", annotation.inferred_ty)),
|
|
)?;
|
|
}
|
|
if !body.user_type_annotations.is_empty() {
|
|
writeln!(w, "|")?;
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
pub fn dump_mir_def_ids(tcx: TyCtxt<'_>, single: Option<DefId>) -> Vec<DefId> {
|
|
if let Some(i) = single {
|
|
vec![i]
|
|
} else {
|
|
tcx.mir_keys(()).iter().map(|def_id| def_id.to_def_id()).collect()
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
// Basic blocks and their parts (statements, terminators, ...)
|
|
|
|
impl<'de, 'tcx> MirWriter<'de, 'tcx> {
|
|
/// Write out a human-readable textual representation for the given basic block.
|
|
fn write_basic_block(
|
|
&self,
|
|
block: BasicBlock,
|
|
body: &Body<'tcx>,
|
|
w: &mut dyn io::Write,
|
|
) -> io::Result<()> {
|
|
let data = &body[block];
|
|
|
|
// Basic block label at the top.
|
|
let cleanup_text = if data.is_cleanup { " (cleanup)" } else { "" };
|
|
writeln!(w, "{INDENT}{block:?}{cleanup_text}: {{")?;
|
|
|
|
// List of statements in the middle.
|
|
let mut current_location = Location { block, statement_index: 0 };
|
|
for statement in &data.statements {
|
|
(self.extra_data)(PassWhere::BeforeLocation(current_location), w)?;
|
|
|
|
for debuginfo in statement.debuginfos.iter() {
|
|
writeln!(w, "{INDENT}{INDENT}// DBG: {debuginfo:?};")?;
|
|
}
|
|
|
|
let indented_body = format!("{INDENT}{INDENT}{statement:?};");
|
|
if self.options.include_extra_comments {
|
|
writeln!(
|
|
w,
|
|
"{:A$} // {}{}",
|
|
indented_body,
|
|
if self.tcx.sess.verbose_internals() {
|
|
format!("{current_location:?}: ")
|
|
} else {
|
|
String::new()
|
|
},
|
|
comment(self.tcx, statement.source_info),
|
|
A = ALIGN,
|
|
)?;
|
|
} else {
|
|
writeln!(w, "{indented_body}")?;
|
|
}
|
|
|
|
write_extra(
|
|
self.tcx,
|
|
w,
|
|
&|visitor| visitor.visit_statement(statement, current_location),
|
|
self.options,
|
|
)?;
|
|
|
|
(self.extra_data)(PassWhere::AfterLocation(current_location), w)?;
|
|
|
|
current_location.statement_index += 1;
|
|
}
|
|
|
|
for debuginfo in data.after_last_stmt_debuginfos.iter() {
|
|
writeln!(w, "{INDENT}{INDENT}// DBG: {debuginfo:?};")?;
|
|
}
|
|
|
|
// Terminator at the bottom.
|
|
(self.extra_data)(PassWhere::BeforeLocation(current_location), w)?;
|
|
if data.terminator.is_some() {
|
|
let indented_terminator = format!("{0}{0}{1:?};", INDENT, data.terminator().kind);
|
|
if self.options.include_extra_comments {
|
|
writeln!(
|
|
w,
|
|
"{:A$} // {}{}",
|
|
indented_terminator,
|
|
if self.tcx.sess.verbose_internals() {
|
|
format!("{current_location:?}: ")
|
|
} else {
|
|
String::new()
|
|
},
|
|
comment(self.tcx, data.terminator().source_info),
|
|
A = ALIGN,
|
|
)?;
|
|
} else {
|
|
writeln!(w, "{indented_terminator}")?;
|
|
}
|
|
|
|
write_extra(
|
|
self.tcx,
|
|
w,
|
|
&|visitor| visitor.visit_terminator(data.terminator(), current_location),
|
|
self.options,
|
|
)?;
|
|
}
|
|
|
|
(self.extra_data)(PassWhere::AfterLocation(current_location), w)?;
|
|
(self.extra_data)(PassWhere::AfterTerminator(block), w)?;
|
|
|
|
writeln!(w, "{INDENT}}}")
|
|
}
|
|
}
|
|
|
|
impl Debug for Statement<'_> {
|
|
fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
|
|
use self::StatementKind::*;
|
|
match self.kind {
|
|
Assign(box (ref place, ref rv)) => write!(fmt, "{place:?} = {rv:?}"),
|
|
FakeRead(box (ref cause, ref place)) => {
|
|
write!(fmt, "FakeRead({cause:?}, {place:?})")
|
|
}
|
|
Retag(ref kind, ref place) => write!(
|
|
fmt,
|
|
"Retag({}{:?})",
|
|
match kind {
|
|
RetagKind::FnEntry => "[fn entry] ",
|
|
RetagKind::TwoPhase => "[2phase] ",
|
|
RetagKind::Raw => "[raw] ",
|
|
RetagKind::Default => "",
|
|
},
|
|
place,
|
|
),
|
|
StorageLive(ref place) => write!(fmt, "StorageLive({place:?})"),
|
|
StorageDead(ref place) => write!(fmt, "StorageDead({place:?})"),
|
|
SetDiscriminant { ref place, variant_index } => {
|
|
write!(fmt, "discriminant({place:?}) = {variant_index:?}")
|
|
}
|
|
PlaceMention(ref place) => {
|
|
write!(fmt, "PlaceMention({place:?})")
|
|
}
|
|
AscribeUserType(box (ref place, ref c_ty), ref variance) => {
|
|
write!(fmt, "AscribeUserType({place:?}, {variance:?}, {c_ty:?})")
|
|
}
|
|
Coverage(ref kind) => write!(fmt, "Coverage::{kind:?}"),
|
|
Intrinsic(box ref intrinsic) => write!(fmt, "{intrinsic}"),
|
|
ConstEvalCounter => write!(fmt, "ConstEvalCounter"),
|
|
Nop => write!(fmt, "nop"),
|
|
BackwardIncompatibleDropHint { ref place, reason: _ } => {
|
|
// For now, we don't record the reason because there is only one use case,
|
|
// which is to report breaking change in drop order by Edition 2024
|
|
write!(fmt, "BackwardIncompatibleDropHint({place:?})")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Debug for StmtDebugInfo<'_> {
|
|
fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
|
|
match self {
|
|
StmtDebugInfo::AssignRef(local, place) => {
|
|
write!(fmt, "{local:?} = &{place:?}")
|
|
}
|
|
StmtDebugInfo::InvalidAssign(local) => {
|
|
write!(fmt, "{local:?} = &?")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Display for NonDivergingIntrinsic<'_> {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
match self {
|
|
Self::Assume(op) => write!(f, "assume({op:?})"),
|
|
Self::CopyNonOverlapping(CopyNonOverlapping { src, dst, count }) => {
|
|
write!(f, "copy_nonoverlapping(dst = {dst:?}, src = {src:?}, count = {count:?})")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'tcx> Debug for TerminatorKind<'tcx> {
|
|
fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
|
|
self.fmt_head(fmt)?;
|
|
let successor_count = self.successors().count();
|
|
let labels = self.fmt_successor_labels();
|
|
assert_eq!(successor_count, labels.len());
|
|
|
|
// `Cleanup` is already included in successors
|
|
let show_unwind = !matches!(self.unwind(), None | Some(UnwindAction::Cleanup(_)));
|
|
let fmt_unwind = |fmt: &mut Formatter<'_>| -> fmt::Result {
|
|
write!(fmt, "unwind ")?;
|
|
match self.unwind() {
|
|
// Not needed or included in successors
|
|
None | Some(UnwindAction::Cleanup(_)) => unreachable!(),
|
|
Some(UnwindAction::Continue) => write!(fmt, "continue"),
|
|
Some(UnwindAction::Unreachable) => write!(fmt, "unreachable"),
|
|
Some(UnwindAction::Terminate(reason)) => {
|
|
write!(fmt, "terminate({})", reason.as_short_str())
|
|
}
|
|
}
|
|
};
|
|
|
|
match (successor_count, show_unwind) {
|
|
(0, false) => Ok(()),
|
|
(0, true) => {
|
|
write!(fmt, " -> ")?;
|
|
fmt_unwind(fmt)
|
|
}
|
|
(1, false) => write!(fmt, " -> {:?}", self.successors().next().unwrap()),
|
|
_ => {
|
|
write!(fmt, " -> [")?;
|
|
for (i, target) in self.successors().enumerate() {
|
|
if i > 0 {
|
|
write!(fmt, ", ")?;
|
|
}
|
|
write!(fmt, "{}: {:?}", labels[i], target)?;
|
|
}
|
|
if show_unwind {
|
|
write!(fmt, ", ")?;
|
|
fmt_unwind(fmt)?;
|
|
}
|
|
write!(fmt, "]")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'tcx> TerminatorKind<'tcx> {
|
|
/// Writes the "head" part of the terminator; that is, its name and the data it uses to pick the
|
|
/// successor basic block, if any. The only information not included is the list of possible
|
|
/// successors, which may be rendered differently between the text and the graphviz format.
|
|
pub fn fmt_head<W: fmt::Write>(&self, fmt: &mut W) -> fmt::Result {
|
|
use self::TerminatorKind::*;
|
|
match self {
|
|
Goto { .. } => write!(fmt, "goto"),
|
|
SwitchInt { discr, .. } => write!(fmt, "switchInt({discr:?})"),
|
|
Return => write!(fmt, "return"),
|
|
CoroutineDrop => write!(fmt, "coroutine_drop"),
|
|
UnwindResume => write!(fmt, "resume"),
|
|
UnwindTerminate(reason) => {
|
|
write!(fmt, "terminate({})", reason.as_short_str())
|
|
}
|
|
Yield { value, resume_arg, .. } => write!(fmt, "{resume_arg:?} = yield({value:?})"),
|
|
Unreachable => write!(fmt, "unreachable"),
|
|
Drop { place, async_fut: None, .. } => write!(fmt, "drop({place:?})"),
|
|
Drop { place, async_fut: Some(async_fut), .. } => {
|
|
write!(fmt, "async drop({place:?}; poll={async_fut:?})")
|
|
}
|
|
Call { func, args, destination, .. } => {
|
|
write!(fmt, "{destination:?} = ")?;
|
|
write!(fmt, "{func:?}(")?;
|
|
for (index, arg) in args.iter().enumerate() {
|
|
if index > 0 {
|
|
write!(fmt, ", ")?;
|
|
}
|
|
write!(fmt, "{:?}", arg.node)?;
|
|
}
|
|
write!(fmt, ")")
|
|
}
|
|
TailCall { func, args, .. } => {
|
|
write!(fmt, "tailcall {func:?}(")?;
|
|
for (index, arg) in args.iter().enumerate() {
|
|
if index > 0 {
|
|
write!(fmt, ", ")?;
|
|
}
|
|
write!(fmt, "{:?}", arg.node)?;
|
|
}
|
|
write!(fmt, ")")
|
|
}
|
|
Assert { cond, expected, msg, .. } => {
|
|
write!(fmt, "assert(")?;
|
|
if !expected {
|
|
write!(fmt, "!")?;
|
|
}
|
|
write!(fmt, "{cond:?}, ")?;
|
|
msg.fmt_assert_args(fmt)?;
|
|
write!(fmt, ")")
|
|
}
|
|
FalseEdge { .. } => write!(fmt, "falseEdge"),
|
|
FalseUnwind { .. } => write!(fmt, "falseUnwind"),
|
|
InlineAsm { template, operands, options, .. } => {
|
|
write!(fmt, "asm!(\"{}\"", InlineAsmTemplatePiece::to_string(template))?;
|
|
for op in operands {
|
|
write!(fmt, ", ")?;
|
|
let print_late = |&late| if late { "late" } else { "" };
|
|
match op {
|
|
InlineAsmOperand::In { reg, value } => {
|
|
write!(fmt, "in({reg}) {value:?}")?;
|
|
}
|
|
InlineAsmOperand::Out { reg, late, place: Some(place) } => {
|
|
write!(fmt, "{}out({}) {:?}", print_late(late), reg, place)?;
|
|
}
|
|
InlineAsmOperand::Out { reg, late, place: None } => {
|
|
write!(fmt, "{}out({}) _", print_late(late), reg)?;
|
|
}
|
|
InlineAsmOperand::InOut {
|
|
reg,
|
|
late,
|
|
in_value,
|
|
out_place: Some(out_place),
|
|
} => {
|
|
write!(
|
|
fmt,
|
|
"in{}out({}) {:?} => {:?}",
|
|
print_late(late),
|
|
reg,
|
|
in_value,
|
|
out_place
|
|
)?;
|
|
}
|
|
InlineAsmOperand::InOut { reg, late, in_value, out_place: None } => {
|
|
write!(fmt, "in{}out({}) {:?} => _", print_late(late), reg, in_value)?;
|
|
}
|
|
InlineAsmOperand::Const { value } => {
|
|
write!(fmt, "const {value:?}")?;
|
|
}
|
|
InlineAsmOperand::SymFn { value } => {
|
|
write!(fmt, "sym_fn {value:?}")?;
|
|
}
|
|
InlineAsmOperand::SymStatic { def_id } => {
|
|
write!(fmt, "sym_static {def_id:?}")?;
|
|
}
|
|
InlineAsmOperand::Label { target_index } => {
|
|
write!(fmt, "label {target_index}")?;
|
|
}
|
|
}
|
|
}
|
|
write!(fmt, ", options({options:?}))")
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Returns the list of labels for the edges to the successor basic blocks.
|
|
pub fn fmt_successor_labels(&self) -> Vec<Cow<'static, str>> {
|
|
use self::TerminatorKind::*;
|
|
match *self {
|
|
Return
|
|
| TailCall { .. }
|
|
| UnwindResume
|
|
| UnwindTerminate(_)
|
|
| Unreachable
|
|
| CoroutineDrop => vec![],
|
|
Goto { .. } => vec!["".into()],
|
|
SwitchInt { ref targets, .. } => targets
|
|
.values
|
|
.iter()
|
|
.map(|&u| Cow::Owned(u.to_string()))
|
|
.chain(iter::once("otherwise".into()))
|
|
.collect(),
|
|
Call { target: Some(_), unwind: UnwindAction::Cleanup(_), .. } => {
|
|
vec!["return".into(), "unwind".into()]
|
|
}
|
|
Call { target: Some(_), unwind: _, .. } => vec!["return".into()],
|
|
Call { target: None, unwind: UnwindAction::Cleanup(_), .. } => vec!["unwind".into()],
|
|
Call { target: None, unwind: _, .. } => vec![],
|
|
Yield { drop: Some(_), .. } => vec!["resume".into(), "drop".into()],
|
|
Yield { drop: None, .. } => vec!["resume".into()],
|
|
Drop { unwind: UnwindAction::Cleanup(_), drop: Some(_), .. } => {
|
|
vec!["return".into(), "unwind".into(), "drop".into()]
|
|
}
|
|
Drop { unwind: UnwindAction::Cleanup(_), drop: None, .. } => {
|
|
vec!["return".into(), "unwind".into()]
|
|
}
|
|
Drop { unwind: _, drop: Some(_), .. } => vec!["return".into(), "drop".into()],
|
|
Drop { unwind: _, .. } => vec!["return".into()],
|
|
Assert { unwind: UnwindAction::Cleanup(_), .. } => {
|
|
vec!["success".into(), "unwind".into()]
|
|
}
|
|
Assert { unwind: _, .. } => vec!["success".into()],
|
|
FalseEdge { .. } => vec!["real".into(), "imaginary".into()],
|
|
FalseUnwind { unwind: UnwindAction::Cleanup(_), .. } => {
|
|
vec!["real".into(), "unwind".into()]
|
|
}
|
|
FalseUnwind { unwind: _, .. } => vec!["real".into()],
|
|
InlineAsm { asm_macro, options, ref targets, unwind, .. } => {
|
|
let mut vec = Vec::with_capacity(targets.len() + 1);
|
|
if !asm_macro.diverges(options) {
|
|
vec.push("return".into());
|
|
}
|
|
vec.resize(targets.len(), "label".into());
|
|
|
|
if let UnwindAction::Cleanup(_) = unwind {
|
|
vec.push("unwind".into());
|
|
}
|
|
|
|
vec
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'tcx> Debug for Rvalue<'tcx> {
|
|
fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
|
|
use self::Rvalue::*;
|
|
|
|
match *self {
|
|
Use(ref place) => write!(fmt, "{place:?}"),
|
|
Repeat(ref a, b) => {
|
|
write!(fmt, "[{a:?}; ")?;
|
|
pretty_print_const(b, fmt, false)?;
|
|
write!(fmt, "]")
|
|
}
|
|
Cast(ref kind, ref place, ref ty) => {
|
|
with_no_trimmed_paths!(write!(fmt, "{place:?} as {ty} ({kind:?})"))
|
|
}
|
|
BinaryOp(ref op, box (ref a, ref b)) => write!(fmt, "{op:?}({a:?}, {b:?})"),
|
|
UnaryOp(ref op, ref a) => write!(fmt, "{op:?}({a:?})"),
|
|
Discriminant(ref place) => write!(fmt, "discriminant({place:?})"),
|
|
ThreadLocalRef(did) => ty::tls::with(|tcx| {
|
|
let muta = tcx.static_mutability(did).unwrap().prefix_str();
|
|
write!(fmt, "&/*tls*/ {}{}", muta, tcx.def_path_str(did))
|
|
}),
|
|
Ref(region, borrow_kind, ref place) => {
|
|
let kind_str = match borrow_kind {
|
|
BorrowKind::Shared => "",
|
|
BorrowKind::Fake(FakeBorrowKind::Deep) => "fake ",
|
|
BorrowKind::Fake(FakeBorrowKind::Shallow) => "fake shallow ",
|
|
BorrowKind::Mut { .. } => "mut ",
|
|
};
|
|
|
|
// When printing regions, add trailing space if necessary.
|
|
let print_region = ty::tls::with(|tcx| {
|
|
tcx.sess.verbose_internals() || tcx.sess.opts.unstable_opts.identify_regions
|
|
});
|
|
let region = if print_region {
|
|
let mut region = region.to_string();
|
|
if !region.is_empty() {
|
|
region.push(' ');
|
|
}
|
|
region
|
|
} else {
|
|
// Do not even print 'static
|
|
String::new()
|
|
};
|
|
write!(fmt, "&{region}{kind_str}{place:?}")
|
|
}
|
|
|
|
CopyForDeref(ref place) => write!(fmt, "deref_copy {place:#?}"),
|
|
|
|
RawPtr(mutability, ref place) => {
|
|
write!(fmt, "&raw {mut_str} {place:?}", mut_str = mutability.ptr_str())
|
|
}
|
|
|
|
Aggregate(ref kind, ref places) => {
|
|
let fmt_tuple = |fmt: &mut Formatter<'_>, name: &str| {
|
|
let mut tuple_fmt = fmt.debug_tuple(name);
|
|
for place in places {
|
|
tuple_fmt.field(place);
|
|
}
|
|
tuple_fmt.finish()
|
|
};
|
|
|
|
match **kind {
|
|
AggregateKind::Array(_) => write!(fmt, "{places:?}"),
|
|
|
|
AggregateKind::Tuple => {
|
|
if places.is_empty() {
|
|
write!(fmt, "()")
|
|
} else {
|
|
fmt_tuple(fmt, "")
|
|
}
|
|
}
|
|
|
|
AggregateKind::Adt(adt_did, variant, args, _user_ty, _) => {
|
|
ty::tls::with(|tcx| {
|
|
let variant_def = &tcx.adt_def(adt_did).variant(variant);
|
|
let args = tcx.lift(args).expect("could not lift for printing");
|
|
let name = FmtPrinter::print_string(tcx, Namespace::ValueNS, |p| {
|
|
p.print_def_path(variant_def.def_id, args)
|
|
})?;
|
|
|
|
match variant_def.ctor_kind() {
|
|
Some(CtorKind::Const) => fmt.write_str(&name),
|
|
Some(CtorKind::Fn) => fmt_tuple(fmt, &name),
|
|
None => {
|
|
let mut struct_fmt = fmt.debug_struct(&name);
|
|
for (field, place) in iter::zip(&variant_def.fields, places) {
|
|
struct_fmt.field(field.name.as_str(), place);
|
|
}
|
|
struct_fmt.finish()
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
AggregateKind::Closure(def_id, args)
|
|
| AggregateKind::CoroutineClosure(def_id, args) => ty::tls::with(|tcx| {
|
|
let name = if tcx.sess.opts.unstable_opts.span_free_formats {
|
|
let args = tcx.lift(args).unwrap();
|
|
format!("{{closure@{}}}", tcx.def_path_str_with_args(def_id, args),)
|
|
} else {
|
|
let span = tcx.def_span(def_id);
|
|
format!(
|
|
"{{closure@{}}}",
|
|
tcx.sess.source_map().span_to_diagnostic_string(span)
|
|
)
|
|
};
|
|
let mut struct_fmt = fmt.debug_struct(&name);
|
|
|
|
// FIXME(project-rfc-2229#48): This should be a list of capture names/places
|
|
if let Some(def_id) = def_id.as_local()
|
|
&& let Some(upvars) = tcx.upvars_mentioned(def_id)
|
|
{
|
|
for (&var_id, place) in iter::zip(upvars.keys(), places) {
|
|
let var_name = tcx.hir_name(var_id);
|
|
struct_fmt.field(var_name.as_str(), place);
|
|
}
|
|
} else {
|
|
for (index, place) in places.iter().enumerate() {
|
|
struct_fmt.field(&format!("{index}"), place);
|
|
}
|
|
}
|
|
|
|
struct_fmt.finish()
|
|
}),
|
|
|
|
AggregateKind::Coroutine(def_id, _) => ty::tls::with(|tcx| {
|
|
let name = format!("{{coroutine@{:?}}}", tcx.def_span(def_id));
|
|
let mut struct_fmt = fmt.debug_struct(&name);
|
|
|
|
// FIXME(project-rfc-2229#48): This should be a list of capture names/places
|
|
if let Some(def_id) = def_id.as_local()
|
|
&& let Some(upvars) = tcx.upvars_mentioned(def_id)
|
|
{
|
|
for (&var_id, place) in iter::zip(upvars.keys(), places) {
|
|
let var_name = tcx.hir_name(var_id);
|
|
struct_fmt.field(var_name.as_str(), place);
|
|
}
|
|
} else {
|
|
for (index, place) in places.iter().enumerate() {
|
|
struct_fmt.field(&format!("{index}"), place);
|
|
}
|
|
}
|
|
|
|
struct_fmt.finish()
|
|
}),
|
|
|
|
AggregateKind::RawPtr(pointee_ty, mutability) => {
|
|
let kind_str = match mutability {
|
|
Mutability::Mut => "mut",
|
|
Mutability::Not => "const",
|
|
};
|
|
with_no_trimmed_paths!(write!(fmt, "*{kind_str} {pointee_ty} from "))?;
|
|
fmt_tuple(fmt, "")
|
|
}
|
|
}
|
|
}
|
|
|
|
ShallowInitBox(ref place, ref ty) => {
|
|
with_no_trimmed_paths!(write!(fmt, "ShallowInitBox({place:?}, {ty})"))
|
|
}
|
|
|
|
WrapUnsafeBinder(ref op, ty) => {
|
|
with_no_trimmed_paths!(write!(fmt, "wrap_binder!({op:?}; {ty})"))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'tcx> Debug for Operand<'tcx> {
|
|
fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
|
|
use self::Operand::*;
|
|
match *self {
|
|
Constant(ref a) => write!(fmt, "{a:?}"),
|
|
Copy(ref place) => write!(fmt, "copy {place:?}"),
|
|
Move(ref place) => write!(fmt, "move {place:?}"),
|
|
RuntimeChecks(checks) => write!(fmt, "{checks:?}"),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'tcx> Debug for ConstOperand<'tcx> {
|
|
fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
|
|
write!(fmt, "{self}")
|
|
}
|
|
}
|
|
|
|
impl<'tcx> Display for ConstOperand<'tcx> {
|
|
fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
|
|
match self.ty().kind() {
|
|
ty::FnDef(..) => {}
|
|
_ => write!(fmt, "const ")?,
|
|
}
|
|
Display::fmt(&self.const_, fmt)
|
|
}
|
|
}
|
|
|
|
impl Debug for Place<'_> {
|
|
fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
|
|
self.as_ref().fmt(fmt)
|
|
}
|
|
}
|
|
|
|
impl Debug for PlaceRef<'_> {
|
|
fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
|
|
pre_fmt_projection(self.projection, fmt)?;
|
|
write!(fmt, "{:?}", self.local)?;
|
|
post_fmt_projection(self.projection, fmt)
|
|
}
|
|
}
|
|
|
|
fn pre_fmt_projection(projection: &[PlaceElem<'_>], fmt: &mut Formatter<'_>) -> fmt::Result {
|
|
for &elem in projection.iter().rev() {
|
|
match elem {
|
|
ProjectionElem::OpaqueCast(_)
|
|
| ProjectionElem::Downcast(_, _)
|
|
| ProjectionElem::Field(_, _) => {
|
|
write!(fmt, "(")?;
|
|
}
|
|
ProjectionElem::Deref => {
|
|
write!(fmt, "(*")?;
|
|
}
|
|
ProjectionElem::Index(_)
|
|
| ProjectionElem::ConstantIndex { .. }
|
|
| ProjectionElem::Subslice { .. } => {}
|
|
ProjectionElem::UnwrapUnsafeBinder(_) => {
|
|
write!(fmt, "unwrap_binder!(")?;
|
|
}
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn post_fmt_projection(projection: &[PlaceElem<'_>], fmt: &mut Formatter<'_>) -> fmt::Result {
|
|
for &elem in projection.iter() {
|
|
match elem {
|
|
ProjectionElem::OpaqueCast(ty) => {
|
|
write!(fmt, " as {ty})")?;
|
|
}
|
|
ProjectionElem::Downcast(Some(name), _index) => {
|
|
write!(fmt, " as {name})")?;
|
|
}
|
|
ProjectionElem::Downcast(None, index) => {
|
|
write!(fmt, " as variant#{index:?})")?;
|
|
}
|
|
ProjectionElem::Deref => {
|
|
write!(fmt, ")")?;
|
|
}
|
|
ProjectionElem::Field(field, ty) => {
|
|
with_no_trimmed_paths!(write!(fmt, ".{:?}: {})", field.index(), ty)?);
|
|
}
|
|
ProjectionElem::Index(ref index) => {
|
|
write!(fmt, "[{index:?}]")?;
|
|
}
|
|
ProjectionElem::ConstantIndex { offset, min_length, from_end: false } => {
|
|
write!(fmt, "[{offset:?} of {min_length:?}]")?;
|
|
}
|
|
ProjectionElem::ConstantIndex { offset, min_length, from_end: true } => {
|
|
write!(fmt, "[-{offset:?} of {min_length:?}]")?;
|
|
}
|
|
ProjectionElem::Subslice { from, to: 0, from_end: true } => {
|
|
write!(fmt, "[{from:?}:]")?;
|
|
}
|
|
ProjectionElem::Subslice { from: 0, to, from_end: true } => {
|
|
write!(fmt, "[:-{to:?}]")?;
|
|
}
|
|
ProjectionElem::Subslice { from, to, from_end: true } => {
|
|
write!(fmt, "[{from:?}:-{to:?}]")?;
|
|
}
|
|
ProjectionElem::Subslice { from, to, from_end: false } => {
|
|
write!(fmt, "[{from:?}..{to:?}]")?;
|
|
}
|
|
ProjectionElem::UnwrapUnsafeBinder(ty) => {
|
|
write!(fmt, "; {ty})")?;
|
|
}
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// After we print the main statement, we sometimes dump extra
|
|
/// information. There's often a lot of little things "nuzzled up" in
|
|
/// a statement.
|
|
fn write_extra<'tcx>(
|
|
tcx: TyCtxt<'tcx>,
|
|
write: &mut dyn io::Write,
|
|
visit_op: &dyn Fn(&mut ExtraComments<'tcx>),
|
|
options: PrettyPrintMirOptions,
|
|
) -> io::Result<()> {
|
|
if options.include_extra_comments {
|
|
let mut extra_comments = ExtraComments { tcx, comments: vec![] };
|
|
visit_op(&mut extra_comments);
|
|
for comment in extra_comments.comments {
|
|
writeln!(write, "{:A$} // {}", "", comment, A = ALIGN)?;
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
struct ExtraComments<'tcx> {
|
|
tcx: TyCtxt<'tcx>,
|
|
comments: Vec<String>,
|
|
}
|
|
|
|
impl<'tcx> ExtraComments<'tcx> {
|
|
fn push(&mut self, lines: &str) {
|
|
for line in lines.split('\n') {
|
|
self.comments.push(line.to_string());
|
|
}
|
|
}
|
|
}
|
|
|
|
fn use_verbose(ty: Ty<'_>, fn_def: bool) -> bool {
|
|
match *ty.kind() {
|
|
ty::Int(_) | ty::Uint(_) | ty::Bool | ty::Char | ty::Float(_) => false,
|
|
// Unit type
|
|
ty::Tuple(g_args) if g_args.is_empty() => false,
|
|
ty::Tuple(g_args) => g_args.iter().any(|g_arg| use_verbose(g_arg, fn_def)),
|
|
ty::Array(ty, _) => use_verbose(ty, fn_def),
|
|
ty::FnDef(..) => fn_def,
|
|
_ => true,
|
|
}
|
|
}
|
|
|
|
impl<'tcx> Visitor<'tcx> for ExtraComments<'tcx> {
|
|
fn visit_const_operand(&mut self, constant: &ConstOperand<'tcx>, _location: Location) {
|
|
let ConstOperand { span, user_ty, const_ } = constant;
|
|
if use_verbose(const_.ty(), true) {
|
|
self.push("mir::ConstOperand");
|
|
self.push(&format!(
|
|
"+ span: {}",
|
|
self.tcx.sess.source_map().span_to_diagnostic_string(*span)
|
|
));
|
|
if let Some(user_ty) = user_ty {
|
|
self.push(&format!("+ user_ty: {user_ty:?}"));
|
|
}
|
|
|
|
let fmt_val = |val: ConstValue, ty: Ty<'tcx>| {
|
|
let tcx = self.tcx;
|
|
rustc_data_structures::make_display(move |fmt| {
|
|
pretty_print_const_value_tcx(tcx, val, ty, fmt)
|
|
})
|
|
};
|
|
|
|
let fmt_valtree = |cv: &ty::Value<'tcx>| {
|
|
let mut p = FmtPrinter::new(self.tcx, Namespace::ValueNS);
|
|
p.pretty_print_const_valtree(*cv, /*print_ty*/ true).unwrap();
|
|
p.into_buffer()
|
|
};
|
|
|
|
let val = match const_ {
|
|
Const::Ty(_, ct) => match ct.kind() {
|
|
ty::ConstKind::Param(p) => format!("ty::Param({p})"),
|
|
ty::ConstKind::Unevaluated(uv) => {
|
|
format!("ty::Unevaluated({}, {:?})", self.tcx.def_path_str(uv.def), uv.args,)
|
|
}
|
|
ty::ConstKind::Value(cv) => {
|
|
format!("ty::Valtree({})", fmt_valtree(&cv))
|
|
}
|
|
// No `ty::` prefix since we also use this to represent errors from `mir::Unevaluated`.
|
|
ty::ConstKind::Error(_) => "Error".to_string(),
|
|
// These variants shouldn't exist in the MIR.
|
|
ty::ConstKind::Placeholder(_)
|
|
| ty::ConstKind::Infer(_)
|
|
| ty::ConstKind::Expr(_)
|
|
| ty::ConstKind::Bound(..) => bug!("unexpected MIR constant: {:?}", const_),
|
|
},
|
|
Const::Unevaluated(uv, _) => {
|
|
format!(
|
|
"Unevaluated({}, {:?}, {:?})",
|
|
self.tcx.def_path_str(uv.def),
|
|
uv.args,
|
|
uv.promoted,
|
|
)
|
|
}
|
|
Const::Val(val, ty) => format!("Value({})", fmt_val(*val, *ty)),
|
|
};
|
|
|
|
// This reflects what `Const` looked liked before `val` was renamed
|
|
// as `kind`. We print it like this to avoid having to update
|
|
// expected output in a lot of tests.
|
|
self.push(&format!("+ const_: Const {{ ty: {}, val: {} }}", const_.ty(), val));
|
|
}
|
|
}
|
|
|
|
fn visit_rvalue(&mut self, rvalue: &Rvalue<'tcx>, location: Location) {
|
|
self.super_rvalue(rvalue, location);
|
|
if let Rvalue::Aggregate(kind, _) = rvalue {
|
|
match **kind {
|
|
AggregateKind::Closure(def_id, args) => {
|
|
self.push("closure");
|
|
self.push(&format!("+ def_id: {def_id:?}"));
|
|
self.push(&format!("+ args: {args:#?}"));
|
|
}
|
|
|
|
AggregateKind::Coroutine(def_id, args) => {
|
|
self.push("coroutine");
|
|
self.push(&format!("+ def_id: {def_id:?}"));
|
|
self.push(&format!("+ args: {args:#?}"));
|
|
self.push(&format!("+ kind: {:?}", self.tcx.coroutine_kind(def_id)));
|
|
}
|
|
|
|
AggregateKind::Adt(_, _, _, Some(user_ty), _) => {
|
|
self.push("adt");
|
|
self.push(&format!("+ user_ty: {user_ty:?}"));
|
|
}
|
|
|
|
_ => {}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn comment(tcx: TyCtxt<'_>, SourceInfo { span, scope }: SourceInfo) -> String {
|
|
let location = tcx.sess.source_map().span_to_diagnostic_string(span);
|
|
format!("scope {} at {}", scope.index(), location,)
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
// Allocations
|
|
|
|
/// Find all `AllocId`s mentioned (recursively) in the MIR body and print their corresponding
|
|
/// allocations.
|
|
pub fn write_allocations<'tcx>(
|
|
tcx: TyCtxt<'tcx>,
|
|
body: &Body<'_>,
|
|
w: &mut dyn io::Write,
|
|
) -> io::Result<()> {
|
|
fn alloc_ids_from_alloc(
|
|
alloc: ConstAllocation<'_>,
|
|
) -> impl DoubleEndedIterator<Item = AllocId> {
|
|
alloc.inner().provenance().ptrs().values().map(|p| p.alloc_id())
|
|
}
|
|
|
|
fn alloc_id_from_const_val(val: ConstValue) -> Option<AllocId> {
|
|
match val {
|
|
ConstValue::Scalar(interpret::Scalar::Ptr(ptr, _)) => Some(ptr.provenance.alloc_id()),
|
|
ConstValue::Scalar(interpret::Scalar::Int { .. }) => None,
|
|
ConstValue::ZeroSized => None,
|
|
ConstValue::Slice { alloc_id, .. } | ConstValue::Indirect { alloc_id, .. } => {
|
|
// FIXME: we don't actually want to print all of these, since some are printed nicely directly as values inline in MIR.
|
|
// Really we'd want `pretty_print_const_value` to decide which allocations to print, instead of having a separate visitor.
|
|
Some(alloc_id)
|
|
}
|
|
}
|
|
}
|
|
struct CollectAllocIds(BTreeSet<AllocId>);
|
|
|
|
impl<'tcx> Visitor<'tcx> for CollectAllocIds {
|
|
fn visit_const_operand(&mut self, c: &ConstOperand<'tcx>, _: Location) {
|
|
match c.const_ {
|
|
Const::Ty(_, _) | Const::Unevaluated(..) => {}
|
|
Const::Val(val, _) => {
|
|
if let Some(id) = alloc_id_from_const_val(val) {
|
|
self.0.insert(id);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
let mut visitor = CollectAllocIds(Default::default());
|
|
visitor.visit_body(body);
|
|
|
|
// `seen` contains all seen allocations, including the ones we have *not* printed yet.
|
|
// The protocol is to first `insert` into `seen`, and only if that returns `true`
|
|
// then push to `todo`.
|
|
let mut seen = visitor.0;
|
|
let mut todo: Vec<_> = seen.iter().copied().collect();
|
|
while let Some(id) = todo.pop() {
|
|
let mut write_allocation_track_relocs =
|
|
|w: &mut dyn io::Write, alloc: ConstAllocation<'tcx>| -> io::Result<()> {
|
|
// `.rev()` because we are popping them from the back of the `todo` vector.
|
|
for id in alloc_ids_from_alloc(alloc).rev() {
|
|
if seen.insert(id) {
|
|
todo.push(id);
|
|
}
|
|
}
|
|
write!(w, "{}", display_allocation(tcx, alloc.inner()))
|
|
};
|
|
write!(w, "\n{id:?}")?;
|
|
match tcx.try_get_global_alloc(id) {
|
|
// This can't really happen unless there are bugs, but it doesn't cost us anything to
|
|
// gracefully handle it and allow buggy rustc to be debugged via allocation printing.
|
|
None => write!(w, " (deallocated)")?,
|
|
Some(GlobalAlloc::Function { instance, .. }) => write!(w, " (fn: {instance})")?,
|
|
Some(GlobalAlloc::VTable(ty, dyn_ty)) => {
|
|
write!(w, " (vtable: impl {dyn_ty} for {ty})")?
|
|
}
|
|
Some(GlobalAlloc::TypeId { ty }) => write!(w, " (typeid for {ty})")?,
|
|
Some(GlobalAlloc::Static(did)) if !tcx.is_foreign_item(did) => {
|
|
write!(w, " (static: {}", tcx.def_path_str(did))?;
|
|
if body.phase <= MirPhase::Runtime(RuntimePhase::PostCleanup)
|
|
&& body
|
|
.source
|
|
.def_id()
|
|
.as_local()
|
|
.is_some_and(|def_id| tcx.hir_body_const_context(def_id).is_some())
|
|
{
|
|
// Statics may be cyclic and evaluating them too early
|
|
// in the MIR pipeline may cause cycle errors even though
|
|
// normal compilation is fine.
|
|
write!(w, ")")?;
|
|
} else {
|
|
match tcx.eval_static_initializer(did) {
|
|
Ok(alloc) => {
|
|
write!(w, ", ")?;
|
|
write_allocation_track_relocs(w, alloc)?;
|
|
}
|
|
Err(_) => write!(w, ", error during initializer evaluation)")?,
|
|
}
|
|
}
|
|
}
|
|
Some(GlobalAlloc::Static(did)) => {
|
|
write!(w, " (extern static: {})", tcx.def_path_str(did))?
|
|
}
|
|
Some(GlobalAlloc::Memory(alloc)) => {
|
|
write!(w, " (")?;
|
|
write_allocation_track_relocs(w, alloc)?
|
|
}
|
|
}
|
|
writeln!(w)?;
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// Dumps the size and metadata and content of an allocation to the given writer.
|
|
/// The expectation is that the caller first prints other relevant metadata, so the exact
|
|
/// format of this function is (*without* leading or trailing newline):
|
|
///
|
|
/// ```text
|
|
/// size: {}, align: {}) {
|
|
/// <bytes>
|
|
/// }
|
|
/// ```
|
|
///
|
|
/// The byte format is similar to how hex editors print bytes. Each line starts with the address of
|
|
/// the start of the line, followed by all bytes in hex format (space separated).
|
|
/// If the allocation is small enough to fit into a single line, no start address is given.
|
|
/// After the hex dump, an ascii dump follows, replacing all unprintable characters (control
|
|
/// characters or characters whose value is larger than 127) with a `.`
|
|
/// This also prints provenance adequately.
|
|
pub fn display_allocation<'a, 'tcx, Prov: Provenance, Extra, Bytes: AllocBytes>(
|
|
tcx: TyCtxt<'tcx>,
|
|
alloc: &'a Allocation<Prov, Extra, Bytes>,
|
|
) -> RenderAllocation<'a, 'tcx, Prov, Extra, Bytes> {
|
|
RenderAllocation { tcx, alloc }
|
|
}
|
|
|
|
#[doc(hidden)]
|
|
pub struct RenderAllocation<'a, 'tcx, Prov: Provenance, Extra, Bytes: AllocBytes> {
|
|
tcx: TyCtxt<'tcx>,
|
|
alloc: &'a Allocation<Prov, Extra, Bytes>,
|
|
}
|
|
|
|
impl<'a, 'tcx, Prov: Provenance, Extra, Bytes: AllocBytes> std::fmt::Display
|
|
for RenderAllocation<'a, 'tcx, Prov, Extra, Bytes>
|
|
{
|
|
fn fmt(&self, w: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
let RenderAllocation { tcx, alloc } = *self;
|
|
write!(w, "size: {}, align: {})", alloc.size().bytes(), alloc.align.bytes())?;
|
|
if alloc.size() == Size::ZERO {
|
|
// We are done.
|
|
return write!(w, " {{}}");
|
|
}
|
|
if tcx.sess.opts.unstable_opts.dump_mir_exclude_alloc_bytes {
|
|
return write!(w, " {{ .. }}");
|
|
}
|
|
// Write allocation bytes.
|
|
writeln!(w, " {{")?;
|
|
write_allocation_bytes(tcx, alloc, w, " ")?;
|
|
write!(w, "}}")?;
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
fn write_allocation_endline(w: &mut dyn std::fmt::Write, ascii: &str) -> std::fmt::Result {
|
|
for _ in 0..(BYTES_PER_LINE - ascii.chars().count()) {
|
|
write!(w, " ")?;
|
|
}
|
|
writeln!(w, " │ {ascii}")
|
|
}
|
|
|
|
/// Number of bytes to print per allocation hex dump line.
|
|
const BYTES_PER_LINE: usize = 16;
|
|
|
|
/// Prints the line start address and returns the new line start address.
|
|
fn write_allocation_newline(
|
|
w: &mut dyn std::fmt::Write,
|
|
mut line_start: Size,
|
|
ascii: &str,
|
|
pos_width: usize,
|
|
prefix: &str,
|
|
) -> Result<Size, std::fmt::Error> {
|
|
write_allocation_endline(w, ascii)?;
|
|
line_start += Size::from_bytes(BYTES_PER_LINE);
|
|
write!(w, "{}0x{:02$x} │ ", prefix, line_start.bytes(), pos_width)?;
|
|
Ok(line_start)
|
|
}
|
|
|
|
/// The `prefix` argument allows callers to add an arbitrary prefix before each line (even if there
|
|
/// is only one line). Note that your prefix should contain a trailing space as the lines are
|
|
/// printed directly after it.
|
|
pub fn write_allocation_bytes<'tcx, Prov: Provenance, Extra, Bytes: AllocBytes>(
|
|
tcx: TyCtxt<'tcx>,
|
|
alloc: &Allocation<Prov, Extra, Bytes>,
|
|
w: &mut dyn std::fmt::Write,
|
|
prefix: &str,
|
|
) -> std::fmt::Result {
|
|
let num_lines = alloc.size().bytes_usize().saturating_sub(BYTES_PER_LINE);
|
|
// Number of chars needed to represent all line numbers.
|
|
let pos_width = hex_number_length(alloc.size().bytes());
|
|
|
|
if num_lines > 0 {
|
|
write!(w, "{}0x{:02$x} │ ", prefix, 0, pos_width)?;
|
|
} else {
|
|
write!(w, "{prefix}")?;
|
|
}
|
|
|
|
let mut i = Size::ZERO;
|
|
let mut line_start = Size::ZERO;
|
|
|
|
let ptr_size = tcx.data_layout.pointer_size();
|
|
|
|
let mut ascii = String::new();
|
|
|
|
let oversized_ptr = |target: &mut String, width| {
|
|
if target.len() > width {
|
|
write!(target, " ({} ptr bytes)", ptr_size.bytes()).unwrap();
|
|
}
|
|
};
|
|
|
|
while i < alloc.size() {
|
|
// The line start already has a space. While we could remove that space from the line start
|
|
// printing and unconditionally print a space here, that would cause the single-line case
|
|
// to have a single space before it, which looks weird.
|
|
if i != line_start {
|
|
write!(w, " ")?;
|
|
}
|
|
if let Some(prov) = alloc.provenance().get_ptr(i) {
|
|
// Memory with provenance must be defined
|
|
assert!(alloc.init_mask().is_range_initialized(alloc_range(i, ptr_size)).is_ok());
|
|
let j = i.bytes_usize();
|
|
let offset = alloc
|
|
.inspect_with_uninit_and_ptr_outside_interpreter(j..j + ptr_size.bytes_usize());
|
|
let offset = read_target_uint(tcx.data_layout.endian, offset).unwrap();
|
|
let offset = Size::from_bytes(offset);
|
|
let provenance_width = |bytes| bytes * 3;
|
|
let ptr = Pointer::new(prov, offset);
|
|
let mut target = format!("{ptr:?}");
|
|
if target.len() > provenance_width(ptr_size.bytes_usize() - 1) {
|
|
// This is too long, try to save some space.
|
|
target = format!("{ptr:#?}");
|
|
}
|
|
if ((i - line_start) + ptr_size).bytes_usize() > BYTES_PER_LINE {
|
|
// This branch handles the situation where a provenance starts in the current line
|
|
// but ends in the next one.
|
|
let remainder = Size::from_bytes(BYTES_PER_LINE) - (i - line_start);
|
|
let overflow = ptr_size - remainder;
|
|
let remainder_width = provenance_width(remainder.bytes_usize()) - 2;
|
|
let overflow_width = provenance_width(overflow.bytes_usize() - 1) + 1;
|
|
ascii.push('╾'); // HEAVY LEFT AND LIGHT RIGHT
|
|
for _ in 1..remainder.bytes() {
|
|
ascii.push('─'); // LIGHT HORIZONTAL
|
|
}
|
|
if overflow_width > remainder_width && overflow_width >= target.len() {
|
|
// The case where the provenance fits into the part in the next line
|
|
write!(w, "╾{0:─^1$}", "", remainder_width)?;
|
|
line_start =
|
|
write_allocation_newline(w, line_start, &ascii, pos_width, prefix)?;
|
|
ascii.clear();
|
|
write!(w, "{target:─^overflow_width$}╼")?;
|
|
} else {
|
|
oversized_ptr(&mut target, remainder_width);
|
|
write!(w, "╾{target:─^remainder_width$}")?;
|
|
line_start =
|
|
write_allocation_newline(w, line_start, &ascii, pos_width, prefix)?;
|
|
write!(w, "{0:─^1$}╼", "", overflow_width)?;
|
|
ascii.clear();
|
|
}
|
|
for _ in 0..overflow.bytes() - 1 {
|
|
ascii.push('─');
|
|
}
|
|
ascii.push('╼'); // LIGHT LEFT AND HEAVY RIGHT
|
|
i += ptr_size;
|
|
continue;
|
|
} else {
|
|
// This branch handles a provenance that starts and ends in the current line.
|
|
let provenance_width = provenance_width(ptr_size.bytes_usize() - 1);
|
|
oversized_ptr(&mut target, provenance_width);
|
|
ascii.push('╾');
|
|
write!(w, "╾{target:─^provenance_width$}╼")?;
|
|
for _ in 0..ptr_size.bytes() - 2 {
|
|
ascii.push('─');
|
|
}
|
|
ascii.push('╼');
|
|
i += ptr_size;
|
|
}
|
|
} else if let Some(frag) = alloc.provenance().get_byte(i, &tcx) {
|
|
// Memory with provenance must be defined
|
|
assert!(
|
|
alloc.init_mask().is_range_initialized(alloc_range(i, Size::from_bytes(1))).is_ok()
|
|
);
|
|
ascii.push('━'); // HEAVY HORIZONTAL
|
|
// We have two characters to display this, which is obviously not enough.
|
|
// Format is similar to "oversized" above.
|
|
let j = i.bytes_usize();
|
|
let c = alloc.inspect_with_uninit_and_ptr_outside_interpreter(j..j + 1)[0];
|
|
// FIXME: Find a way to print `frag.offset` that does not look terrible...
|
|
write!(w, "╾{c:02x}{prov:#?} (ptr fragment {idx})╼", prov = frag.prov, idx = frag.idx)?;
|
|
i += Size::from_bytes(1);
|
|
} else if alloc
|
|
.init_mask()
|
|
.is_range_initialized(alloc_range(i, Size::from_bytes(1)))
|
|
.is_ok()
|
|
{
|
|
let j = i.bytes_usize();
|
|
|
|
// Checked definedness (and thus range) and provenance. This access also doesn't
|
|
// influence interpreter execution but is only for debugging.
|
|
let c = alloc.inspect_with_uninit_and_ptr_outside_interpreter(j..j + 1)[0];
|
|
write!(w, "{c:02x}")?;
|
|
if c.is_ascii_control() || c >= 0x80 {
|
|
ascii.push('.');
|
|
} else {
|
|
ascii.push(char::from(c));
|
|
}
|
|
i += Size::from_bytes(1);
|
|
} else {
|
|
write!(w, "__")?;
|
|
ascii.push('░');
|
|
i += Size::from_bytes(1);
|
|
}
|
|
// Print a new line header if the next line still has some bytes to print.
|
|
if i == line_start + Size::from_bytes(BYTES_PER_LINE) && i != alloc.size() {
|
|
line_start = write_allocation_newline(w, line_start, &ascii, pos_width, prefix)?;
|
|
ascii.clear();
|
|
}
|
|
}
|
|
write_allocation_endline(w, &ascii)?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
// Constants
|
|
|
|
fn pretty_print_byte_str(fmt: &mut Formatter<'_>, byte_str: &[u8]) -> fmt::Result {
|
|
write!(fmt, "b\"{}\"", byte_str.escape_ascii())
|
|
}
|
|
|
|
fn comma_sep<'tcx>(
|
|
tcx: TyCtxt<'tcx>,
|
|
fmt: &mut Formatter<'_>,
|
|
elems: Vec<(ConstValue, Ty<'tcx>)>,
|
|
) -> fmt::Result {
|
|
let mut first = true;
|
|
for (ct, ty) in elems {
|
|
if !first {
|
|
fmt.write_str(", ")?;
|
|
}
|
|
pretty_print_const_value_tcx(tcx, ct, ty, fmt)?;
|
|
first = false;
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn pretty_print_const_value_tcx<'tcx>(
|
|
tcx: TyCtxt<'tcx>,
|
|
ct: ConstValue,
|
|
ty: Ty<'tcx>,
|
|
fmt: &mut Formatter<'_>,
|
|
) -> fmt::Result {
|
|
use crate::ty::print::PrettyPrinter;
|
|
|
|
if tcx.sess.verbose_internals() {
|
|
fmt.write_str(&format!("ConstValue({ct:?}: {ty})"))?;
|
|
return Ok(());
|
|
}
|
|
|
|
// Printing [MaybeUninit<u8>::uninit(); N] or any other aggregate where all fields are uninit
|
|
// becomes very verbose. This special case makes the dump terse and clear.
|
|
if ct.all_bytes_uninit(tcx) {
|
|
fmt.write_str("<uninit>")?;
|
|
return Ok(());
|
|
}
|
|
|
|
let u8_type = tcx.types.u8;
|
|
match (ct, ty.kind()) {
|
|
// Byte/string slices, printed as (byte) string literals.
|
|
(_, ty::Ref(_, inner_ty, _)) if let ty::Str = inner_ty.kind() => {
|
|
if let Some(data) = ct.try_get_slice_bytes_for_diagnostics(tcx) {
|
|
fmt.write_str(&format!("{:?}", String::from_utf8_lossy(data)))?;
|
|
return Ok(());
|
|
}
|
|
}
|
|
(_, ty::Ref(_, inner_ty, _))
|
|
if let ty::Slice(t) = inner_ty.kind()
|
|
&& *t == u8_type =>
|
|
{
|
|
if let Some(data) = ct.try_get_slice_bytes_for_diagnostics(tcx) {
|
|
pretty_print_byte_str(fmt, data)?;
|
|
return Ok(());
|
|
}
|
|
}
|
|
(ConstValue::Indirect { alloc_id, offset }, ty::Array(t, n)) if *t == u8_type => {
|
|
let n = n.try_to_target_usize(tcx).unwrap();
|
|
let alloc = tcx.global_alloc(alloc_id).unwrap_memory();
|
|
// cast is ok because we already checked for pointer size (32 or 64 bit) above
|
|
let range = AllocRange { start: offset, size: Size::from_bytes(n) };
|
|
let byte_str = alloc.inner().get_bytes_strip_provenance(&tcx, range).unwrap();
|
|
fmt.write_str("*")?;
|
|
pretty_print_byte_str(fmt, byte_str)?;
|
|
return Ok(());
|
|
}
|
|
// Aggregates, printed as array/tuple/struct/variant construction syntax.
|
|
//
|
|
// NB: the `has_non_region_param` check ensures that we can use
|
|
// the `try_destructure_mir_constant_for_user_output ` query with
|
|
// an empty `TypingEnv::fully_monomorphized` without
|
|
// introducing ICEs (e.g. via `layout_of`) from missing bounds.
|
|
// E.g. `transmute([0usize; 2]): (u8, *mut T)` needs to know `T: Sized`
|
|
// to be able to destructure the tuple into `(0u8, *mut T)`
|
|
(_, ty::Array(..) | ty::Tuple(..) | ty::Adt(..)) if !ty.has_non_region_param() => {
|
|
let ct = tcx.lift(ct).unwrap();
|
|
let ty = tcx.lift(ty).unwrap();
|
|
if let Some(contents) = tcx.try_destructure_mir_constant_for_user_output(ct, ty) {
|
|
let fields: Vec<(ConstValue, Ty<'_>)> = contents.fields.to_vec();
|
|
match *ty.kind() {
|
|
ty::Array(..) => {
|
|
fmt.write_str("[")?;
|
|
comma_sep(tcx, fmt, fields)?;
|
|
fmt.write_str("]")?;
|
|
}
|
|
ty::Tuple(..) => {
|
|
fmt.write_str("(")?;
|
|
comma_sep(tcx, fmt, fields)?;
|
|
if contents.fields.len() == 1 {
|
|
fmt.write_str(",")?;
|
|
}
|
|
fmt.write_str(")")?;
|
|
}
|
|
ty::Adt(def, _) if def.variants().is_empty() => {
|
|
fmt.write_str(&format!("{{unreachable(): {ty}}}"))?;
|
|
}
|
|
ty::Adt(def, args) => {
|
|
let variant_idx = contents
|
|
.variant
|
|
.expect("destructed mir constant of adt without variant idx");
|
|
let variant_def = &def.variant(variant_idx);
|
|
let args = tcx.lift(args).unwrap();
|
|
let mut p = FmtPrinter::new(tcx, Namespace::ValueNS);
|
|
p.print_alloc_ids = true;
|
|
p.pretty_print_value_path(variant_def.def_id, args)?;
|
|
fmt.write_str(&p.into_buffer())?;
|
|
|
|
match variant_def.ctor_kind() {
|
|
Some(CtorKind::Const) => {}
|
|
Some(CtorKind::Fn) => {
|
|
fmt.write_str("(")?;
|
|
comma_sep(tcx, fmt, fields)?;
|
|
fmt.write_str(")")?;
|
|
}
|
|
None => {
|
|
fmt.write_str(" {{ ")?;
|
|
let mut first = true;
|
|
for (field_def, (ct, ty)) in iter::zip(&variant_def.fields, fields)
|
|
{
|
|
if !first {
|
|
fmt.write_str(", ")?;
|
|
}
|
|
write!(fmt, "{}: ", field_def.name)?;
|
|
pretty_print_const_value_tcx(tcx, ct, ty, fmt)?;
|
|
first = false;
|
|
}
|
|
fmt.write_str(" }}")?;
|
|
}
|
|
}
|
|
}
|
|
_ => unreachable!(),
|
|
}
|
|
return Ok(());
|
|
}
|
|
}
|
|
(ConstValue::Scalar(scalar), _) => {
|
|
let mut p = FmtPrinter::new(tcx, Namespace::ValueNS);
|
|
p.print_alloc_ids = true;
|
|
let ty = tcx.lift(ty).unwrap();
|
|
p.pretty_print_const_scalar(scalar, ty)?;
|
|
fmt.write_str(&p.into_buffer())?;
|
|
return Ok(());
|
|
}
|
|
(ConstValue::ZeroSized, ty::FnDef(d, s)) => {
|
|
let mut p = FmtPrinter::new(tcx, Namespace::ValueNS);
|
|
p.print_alloc_ids = true;
|
|
p.pretty_print_value_path(*d, s)?;
|
|
fmt.write_str(&p.into_buffer())?;
|
|
return Ok(());
|
|
}
|
|
// FIXME(oli-obk): also pretty print arrays and other aggregate constants by reading
|
|
// their fields instead of just dumping the memory.
|
|
_ => {}
|
|
}
|
|
// Fall back to debug pretty printing for invalid constants.
|
|
write!(fmt, "{ct:?}: {ty}")
|
|
}
|
|
|
|
pub(crate) fn pretty_print_const_value<'tcx>(
|
|
ct: ConstValue,
|
|
ty: Ty<'tcx>,
|
|
fmt: &mut Formatter<'_>,
|
|
) -> fmt::Result {
|
|
ty::tls::with(|tcx| {
|
|
let ct = tcx.lift(ct).unwrap();
|
|
let ty = tcx.lift(ty).unwrap();
|
|
pretty_print_const_value_tcx(tcx, ct, ty, fmt)
|
|
})
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
// Miscellaneous
|
|
|
|
/// Calc converted u64 decimal into hex and return its length in chars.
|
|
///
|
|
/// ```ignore (cannot-test-private-function)
|
|
/// assert_eq!(1, hex_number_length(0));
|
|
/// assert_eq!(1, hex_number_length(1));
|
|
/// assert_eq!(2, hex_number_length(16));
|
|
/// ```
|
|
fn hex_number_length(x: u64) -> usize {
|
|
if x == 0 {
|
|
return 1;
|
|
}
|
|
let mut length = 0;
|
|
let mut x_left = x;
|
|
while x_left > 0 {
|
|
x_left /= 16;
|
|
length += 1;
|
|
}
|
|
length
|
|
}
|