Skip to main content

rapx/util/
show_mir.rs

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
19// This trait is a wrapper towards std::Display or std::Debug, and is to resolve orphan restrictions.
20pub 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
190// #[inline(always)]
191pub 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}