1use crate::rap_info;
2use colorful::{Color, Colorful};
3use rustc_hir::def_id::DefId;
4use rustc_middle::mir::{
5 BasicBlockData, BasicBlocks, Body, LocalDecl, LocalDecls, Operand, Rvalue, Statement,
6 StatementKind, Terminator, TerminatorKind,
7};
8use rustc_middle::ty::{self, TyCtxt, TyKind};
9
10const NEXT_LINE: &str = "\n";
11const PADDING: &str = " ";
12const EXPLAIN: &str = " @ ";
13
14pub trait Display {
16 fn display(&self) -> String;
17}
18
19impl<'tcx> Display for Terminator<'tcx> {
20 fn display(&self) -> String {
21 let mut s = String::new();
22 s += &format!("{}{:?}{}", PADDING, self.kind, self.kind.display());
23 s
24 }
25}
26
27impl<'tcx> Display for TerminatorKind<'tcx> {
28 fn display(&self) -> String {
29 let mut s = String::new();
30 s += EXPLAIN;
31 match &self {
32 TerminatorKind::Goto { .. } => s += "Goto",
33 TerminatorKind::SwitchInt { .. } => s += "SwitchInt",
34 TerminatorKind::Return => s += "Return",
35 TerminatorKind::Unreachable => s += "Unreachable",
36 TerminatorKind::Drop { .. } => s += "Drop",
37 TerminatorKind::Assert { .. } => s += "Assert",
38 TerminatorKind::Yield { .. } => s += "Yield",
39 TerminatorKind::FalseEdge { .. } => s += "FalseEdge",
40 TerminatorKind::FalseUnwind { .. } => s += "FalseUnwind",
41 TerminatorKind::InlineAsm { .. } => s += "InlineAsm",
42 TerminatorKind::UnwindResume => s += "UnwindResume",
43 TerminatorKind::UnwindTerminate(..) => s += "UnwindTerminate",
44 TerminatorKind::CoroutineDrop => s += "CoroutineDrop",
45 TerminatorKind::Call { func, .. } => match func {
46 Operand::Constant(constant) => match constant.ty().kind() {
47 ty::FnDef(id, ..) => {
48 s += &format!("Call: FnDid: {}", id.index.as_usize()).as_str()
49 }
50 _ => (),
51 },
52 _ => (),
53 },
54 TerminatorKind::TailCall { .. } => todo!(),
55 };
56 s
57 }
58}
59
60impl<'tcx> Display for Statement<'tcx> {
61 fn display(&self) -> String {
62 let mut s = String::new();
63 s += &format!("{}{:?}{}", PADDING, self.kind, self.kind.display());
64 s
65 }
66}
67
68impl<'tcx> Display for StatementKind<'tcx> {
69 fn display(&self) -> String {
70 let mut s = String::new();
71 s += EXPLAIN;
72 match &self {
73 StatementKind::Assign(assign) => {
74 s += &format!("{:?}={:?}{}", assign.0, assign.1, assign.1.display());
75 }
76 StatementKind::FakeRead(..) => s += "FakeRead",
77 StatementKind::SetDiscriminant { .. } => s += "SetDiscriminant",
78 StatementKind::Deinit(..) => s += "Deinit",
79 StatementKind::StorageLive(..) => s += "StorageLive",
80 StatementKind::StorageDead(..) => s += "StorageDead",
81 StatementKind::Retag(..) => s += "Retag",
82 StatementKind::AscribeUserType(..) => s += "AscribeUserType",
83 StatementKind::Coverage(..) => s += "Coverage",
84 StatementKind::Nop => s += "Nop",
85 StatementKind::PlaceMention(..) => s += "PlaceMention",
86 StatementKind::Intrinsic(..) => s += "Intrinsic",
87 StatementKind::ConstEvalCounter => s += "ConstEvalCounter",
88 _ => todo!(),
89 }
90 s
91 }
92}
93
94impl<'tcx> Display for Rvalue<'tcx> {
95 fn display(&self) -> String {
96 let mut s = String::new();
97 s += EXPLAIN;
98 match self {
99 Rvalue::Use(..) => s += "Use",
100 Rvalue::Repeat(..) => s += "Repeat",
101 Rvalue::Ref(..) => s += "Ref",
102 Rvalue::ThreadLocalRef(..) => s += "ThreadLocalRef",
103 Rvalue::Len(..) => s += "Len",
104 Rvalue::Cast(..) => s += "Cast",
105 Rvalue::BinaryOp(..) => s += "BinaryOp",
106 Rvalue::NullaryOp(..) => s += "NullaryOp",
107 Rvalue::UnaryOp(..) => s += "UnaryOp",
108 Rvalue::Discriminant(..) => s += "Discriminant",
109 Rvalue::Aggregate(..) => s += "Aggregate",
110 Rvalue::ShallowInitBox(..) => s += "ShallowInitBox",
111 Rvalue::CopyForDeref(..) => s += "CopyForDeref",
112 Rvalue::RawPtr(_, _) => s += "RawPtr",
113 _ => todo!(),
114 }
115 s
116 }
117}
118
119impl<'tcx> Display for BasicBlocks<'tcx> {
120 fn display(&self) -> String {
121 let mut s = String::new();
122 for (index, bb) in self.iter().enumerate() {
123 s += &format!(
124 "bb {} {{{}{}}}{}",
125 index,
126 NEXT_LINE,
127 bb.display(),
128 NEXT_LINE
129 );
130 }
131 s
132 }
133}
134
135impl<'tcx> Display for BasicBlockData<'tcx> {
136 fn display(&self) -> String {
137 let mut s = String::new();
138 s += &format!("CleanUp: {}{}", self.is_cleanup, NEXT_LINE);
139 for stmt in self.statements.iter() {
140 s += &format!("{}{}", stmt.display(), NEXT_LINE);
141 }
142 s += &format!(
143 "{}{}",
144 self.terminator.clone().unwrap().display(),
145 NEXT_LINE
146 );
147 s
148 }
149}
150
151impl<'tcx> Display for LocalDecls<'tcx> {
152 fn display(&self) -> String {
153 let mut s = String::new();
154 for (index, ld) in self.iter().enumerate() {
155 s += &format!("_{}: {} {}", index, ld.display(), NEXT_LINE);
156 }
157 s
158 }
159}
160
161impl<'tcx> Display for LocalDecl<'tcx> {
162 fn display(&self) -> String {
163 let mut s = String::new();
164 s += &format!("{}{}", EXPLAIN, self.ty.kind().display());
165 s
166 }
167}
168
169impl<'tcx> Display for Body<'tcx> {
170 fn display(&self) -> String {
171 let mut s = String::new();
172 s += &self.local_decls.display();
173 s += &self.basic_blocks.display();
174 s
175 }
176}
177
178impl<'tcx> Display for TyKind<'tcx> {
179 fn display(&self) -> String {
180 let mut s = String::new();
181 s += &format!("{:?}", self);
182 s
183 }
184}
185
186impl Display for DefId {
187 fn display(&self) -> String {
188 format!("{:?}", self)
189 }
190}
191
192pub struct ShowMir<'tcx> {
193 pub tcx: TyCtxt<'tcx>,
194}
195
196pub fn display_mir(did: DefId, body: &Body) {
198 rap_info!("{}", did.display().color(Color::LightRed));
199 rap_info!("{}", body.local_decls.display().color(Color::Green));
200 rap_info!(
201 "{}",
202 body.basic_blocks.display().color(Color::LightGoldenrod2a)
203 );
204}
205
206impl<'tcx> ShowMir<'tcx> {
207 pub fn new(tcx: TyCtxt<'tcx>) -> Self {
208 Self { tcx }
209 }
210
211 pub fn start(&mut self) {
212 rap_info!("Show MIR");
213 let mir_keys = self.tcx.mir_keys(());
214 for each_mir in mir_keys {
215 let def_id = each_mir.to_def_id();
216 let body = self.tcx.instance_mir(ty::InstanceKind::Item(def_id));
217 display_mir(def_id, body);
218 }
219 }
220}