1use crate::compat::FxHashSet;
2use crate::def_ids::other_api::is_drop_fn;
3use crate::util::draw_dot::render_dot_string;
4use crate::util::name::get_cleaned_def_path_name;
5use colorful::{Color, Colorful};
6use rustc_hir::def_id::DefId;
7use rustc_middle::{
8 mir::{
9 BasicBlockData, BasicBlocks, Body, LocalDecl, LocalDecls, Operand, Rvalue, Statement,
10 StatementKind, Terminator, TerminatorKind,
11 },
12 ty::{self, TyCtxt, TyKind},
13};
14
15const NEXT_LINE: &str = "\n";
16const PADDING: &str = " ";
17const EXPLAIN: &str = " @ ";
18
19pub trait MirDisplay {
21 fn display(&self) -> String;
22}
23
24impl<'tcx> MirDisplay for Terminator<'tcx> {
25 fn display(&self) -> String {
26 let mut s = String::new();
27 s += &format!("{}{:?}{}", PADDING, self.kind, self.kind.display());
28 s
29 }
30}
31
32impl<'tcx> MirDisplay for TerminatorKind<'tcx> {
33 fn display(&self) -> String {
34 let mut s = String::new();
35 s += EXPLAIN;
36 match &self {
37 TerminatorKind::Goto { .. } => s += "Goto",
38 TerminatorKind::SwitchInt { .. } => s += "SwitchInt",
39 TerminatorKind::Return => s += "Return",
40 TerminatorKind::Unreachable => s += "Unreachable",
41 TerminatorKind::Drop { .. } => s += "Drop",
42 TerminatorKind::Assert { .. } => s += "Assert",
43 TerminatorKind::Yield { .. } => s += "Yield",
44 TerminatorKind::FalseEdge { .. } => s += "FalseEdge",
45 TerminatorKind::FalseUnwind { .. } => s += "FalseUnwind",
46 TerminatorKind::InlineAsm { .. } => s += "InlineAsm",
47 TerminatorKind::UnwindResume => s += "UnwindResume",
48 TerminatorKind::UnwindTerminate(..) => s += "UnwindTerminate",
49 TerminatorKind::CoroutineDrop => s += "CoroutineDrop",
50 TerminatorKind::Call { func, .. } => if let Operand::Constant(constant) = func && let ty::FnDef(id, ..) = constant.ty().kind() {
51 s += format!("Call: FnDid: {}", id.index.as_usize()).as_str()
52 },
53 TerminatorKind::TailCall { .. } => todo!(),
54 };
55 s
56 }
57}
58
59impl<'tcx> MirDisplay for Statement<'tcx> {
60 fn display(&self) -> String {
61 let mut s = String::new();
62 s += &format!("{}{:?}{}", PADDING, self.kind, self.kind.display());
63 s
64 }
65}
66
67impl<'tcx> MirDisplay for StatementKind<'tcx> {
68 fn display(&self) -> String {
69 let mut s = String::new();
70 s += EXPLAIN;
71 match &self {
72 StatementKind::Assign(assign) => {
73 s += &format!("{:?}={:?}{}", assign.0, assign.1, assign.1.display());
74 }
75 StatementKind::FakeRead(..) => s += "FakeRead",
76 StatementKind::SetDiscriminant { .. } => s += "SetDiscriminant",
77 StatementKind::StorageLive(..) => s += "StorageLive",
78 StatementKind::StorageDead(..) => s += "StorageDead",
79 StatementKind::AscribeUserType(..) => s += "AscribeUserType",
80 StatementKind::Coverage(..) => s += "Coverage",
81 StatementKind::Nop => s += "Nop",
82 StatementKind::PlaceMention(..) => s += "PlaceMention",
83 StatementKind::Intrinsic(..) => s += "Intrinsic",
84 StatementKind::ConstEvalCounter => s += "ConstEvalCounter",
85 _ => todo!(),
86 }
87 s
88 }
89}
90
91impl<'tcx> MirDisplay for Rvalue<'tcx> {
92 fn display(&self) -> String {
93 let mut s = String::new();
94 s += EXPLAIN;
95 match self {
96 Rvalue::Use(..) => s += "Use",
97 Rvalue::Repeat(..) => s += "Repeat",
98 Rvalue::Ref(..) => s += "Ref",
99 Rvalue::ThreadLocalRef(..) => s += "ThreadLocalRef",
100 Rvalue::Cast(..) => s += "Cast",
101 Rvalue::BinaryOp(..) => s += "BinaryOp",
102 Rvalue::UnaryOp(..) => s += "UnaryOp",
103 Rvalue::Discriminant(..) => s += "Discriminant",
104 Rvalue::Aggregate(..) => s += "Aggregate",
105 Rvalue::CopyForDeref(..) => s += "CopyForDeref",
106 Rvalue::RawPtr(_, _) => s += "RawPtr",
107 _ => todo!(),
108 }
109 s
110 }
111}
112
113impl<'tcx> MirDisplay for BasicBlocks<'tcx> {
114 fn display(&self) -> String {
115 let mut s = String::new();
116 for (index, bb) in self.iter().enumerate() {
117 s += &format!(
118 "bb {} {{{}{}}}{}",
119 index,
120 NEXT_LINE,
121 bb.display(),
122 NEXT_LINE
123 );
124 }
125 s
126 }
127}
128
129impl<'tcx> MirDisplay for BasicBlockData<'tcx> {
130 fn display(&self) -> String {
131 let mut s = String::new();
132 s += &format!("CleanUp: {}{}", self.is_cleanup, NEXT_LINE);
133 for stmt in self.statements.iter() {
134 s += &format!("{}{}", stmt.display(), NEXT_LINE);
135 }
136 s += &format!(
137 "{}{}",
138 self.terminator.clone().unwrap().display(),
139 NEXT_LINE
140 );
141 s
142 }
143}
144
145impl<'tcx> MirDisplay for LocalDecls<'tcx> {
146 fn display(&self) -> String {
147 let mut s = String::new();
148 for (index, ld) in self.iter().enumerate() {
149 s += &format!("_{}: {} {}", index, ld.display(), NEXT_LINE);
150 }
151 s
152 }
153}
154
155impl<'tcx> MirDisplay for LocalDecl<'tcx> {
156 fn display(&self) -> String {
157 let mut s = String::new();
158 s += &format!("{}{}", EXPLAIN, self.ty.kind().display());
159 s
160 }
161}
162
163impl<'tcx> MirDisplay for Body<'tcx> {
164 fn display(&self) -> String {
165 let mut s = String::new();
166 s += &self.local_decls.display();
167 s += &self.basic_blocks.display();
168 s
169 }
170}
171
172impl<'tcx> MirDisplay for TyKind<'tcx> {
173 fn display(&self) -> String {
174 let mut s = String::new();
175 s += &format!("{:?}", self);
176 s
177 }
178}
179
180impl MirDisplay for DefId {
181 fn display(&self) -> String {
182 format!("{:?}", self)
183 }
184}
185
186pub struct ShowMir<'tcx> {
187 pub tcx: TyCtxt<'tcx>,
188}
189
190pub fn display_mir(did: DefId, body: &Body) {
192 rap_info!("{}", did.display().color(Color::LightRed));
193 rap_info!("{}", body.local_decls.display().color(Color::Green));
194 rap_info!(
195 "{}",
196 body.basic_blocks.display().color(Color::LightGoldenrod2a)
197 );
198}
199
200impl<'tcx> ShowMir<'tcx> {
201 pub fn new(tcx: TyCtxt<'tcx>) -> Self {
202 Self { tcx }
203 }
204
205 pub fn start(&mut self) {
206 rap_info!("Show MIR");
207 let mir_keys = self.tcx.mir_keys(());
208 for each_mir in mir_keys {
209 let def_id = each_mir.to_def_id();
210 let body = self.tcx.instance_mir(ty::InstanceKind::Item(def_id));
211 display_mir(def_id, body);
212 }
213 }
214
215 pub fn start_generate_dot(&mut self) {
216 rap_info!("Generate MIR DOT");
217 std::process::Command::new("mkdir")
218 .args(["MIR_dot_graph"])
219 .output()
220 .expect("Failed to create directory");
221
222 let mir_keys = self.tcx.mir_keys(());
223 for each_mir in mir_keys {
224 let def_id = each_mir.to_def_id();
225 let _ = generate_mir_cfg_dot(self.tcx, def_id, &Vec::new());
226 }
227 }
228}
229
230fn generate_mir_cfg_dot<'tcx>(
231 tcx: TyCtxt<'tcx>,
232 def_id: DefId,
233 alias_sets: &Vec<FxHashSet<usize>>,
234) -> Result<(), std::io::Error> {
235 let mir = tcx.optimized_mir(def_id);
236 let mut dot_content = String::new();
237 let alias_info_str = format!("Alias Sets: {:?}", alias_sets);
238
239 dot_content.push_str(&format!(
240 "digraph mir_cfg_{} {{\n",
241 get_cleaned_def_path_name(tcx, def_id)
242 ));
243 dot_content.push_str(&format!(
244 " label = \"MIR CFG for {}\\n{}\\n\";\n",
245 tcx.def_path_str(def_id),
246 alias_info_str.replace("\"", "\\\"")
247 ));
248 dot_content.push_str(" labelloc = \"t\";\n");
249 dot_content.push_str(" node [shape=box, fontname=\"Courier\", align=\"left\"];\n\n");
250
251 for (bb_index, bb_data) in mir.basic_blocks.iter_enumerated() {
252 let mut lines: Vec<String> = bb_data
253 .statements
254 .iter()
255 .map(|stmt| format!("{:?}", stmt))
256 .collect();
257 let mut node_style = String::new();
258
259 if let Some(terminator) = &bb_data.terminator {
260 let mut is_drop_related = false;
261 match &terminator.kind {
262 TerminatorKind::Drop { .. } => is_drop_related = true,
263 TerminatorKind::Call { func, .. } => {
264 if let Operand::Constant(c) = func
265 && let ty::FnDef(def_id, _) = *c.ty().kind()
266 && is_drop_fn(tcx, def_id)
267 {
268 is_drop_related = true;
269 }
270 }
271 _ => {}
272 }
273 if is_drop_related {
274 node_style = ", style=\"filled\", fillcolor=\"#ffdddd\", color=\"red\"".to_string();
275 }
276 lines.push(format!("{:?}", terminator.kind));
277 } else {
278 lines.push("(no terminator)".to_string());
279 }
280
281 let label_content = lines.join("\\l");
282 let node_label = format!("BB{}:\\l{}\\l", bb_index.index(), label_content);
283 dot_content.push_str(&format!(
284 " BB{} [label=\"{}\"{}];\n",
285 bb_index.index(),
286 node_label.replace("\"", "\\\""),
287 node_style
288 ));
289
290 if let Some(terminator) = &bb_data.terminator {
291 for target in terminator.successors() {
292 dot_content.push_str(&format!(
293 " BB{} -> BB{} [label=\"\"];\n",
294 bb_index.index(),
295 target.index(),
296 ));
297 }
298 }
299 }
300 dot_content.push_str("}\n");
301 let name = get_cleaned_def_path_name(tcx, def_id);
302 render_dot_string(name, dot_content);
303 Ok(())
304}