1 // Copyright 2016 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
11 // The visitors in this module collect sizes and counts of the most important
12 // pieces of MIR. The resulting numbers are good approximations but not
13 // completely accurate (some things might be counted twice, others missed).
15 use rustc_const_math::{ConstUsize};
16 use rustc::mir::{AggregateKind, AssertMessage, BasicBlock, BasicBlockData};
17 use rustc::mir::{Constant, Literal, Location, Local, LocalDecl};
18 use rustc::mir::{Place, PlaceElem, PlaceProjection};
19 use rustc::mir::{Mir, Operand, ProjectionElem};
20 use rustc::mir::{Rvalue, SourceInfo, Statement, StatementKind};
21 use rustc::mir::{Terminator, TerminatorKind, VisibilityScope, VisibilityScopeData};
22 use rustc::mir::visit as mir_visit;
23 use rustc::ty::{self, ClosureSubsts, TyCtxt};
24 use rustc::util::nodemap::{FxHashMap};
31 struct StatCollector<'a, 'tcx: 'a> {
32 _tcx: TyCtxt<'a, 'tcx, 'tcx>,
33 data: FxHashMap<&'static str, NodeData>,
36 impl<'a, 'tcx> StatCollector<'a, 'tcx> {
38 fn record_with_size(&mut self, label: &'static str, node_size: usize) {
39 let entry = self.data.entry(label).or_insert(NodeData {
45 entry.size = node_size;
48 fn record<T>(&mut self, label: &'static str, node: &T) {
49 self.record_with_size(label, ::std::mem::size_of_val(node));
53 impl<'a, 'tcx> mir_visit::Visitor<'tcx> for StatCollector<'a, 'tcx> {
54 fn visit_mir(&mut self, mir: &Mir<'tcx>) {
55 self.record("Mir", mir);
57 // since the `super_mir` method does not traverse the MIR of
58 // promoted rvalues, (but we still want to gather statistics
59 // on the structures represented there) we manually traverse
60 // the promoted rvalues here.
61 for promoted_mir in &mir.promoted {
62 self.visit_mir(promoted_mir);
68 fn visit_basic_block_data(&mut self,
70 data: &BasicBlockData<'tcx>) {
71 self.record("BasicBlockData", data);
72 self.super_basic_block_data(block, data);
75 fn visit_visibility_scope_data(&mut self,
76 scope_data: &VisibilityScopeData) {
77 self.record("VisibilityScopeData", scope_data);
78 self.super_visibility_scope_data(scope_data);
81 fn visit_statement(&mut self,
83 statement: &Statement<'tcx>,
85 self.record("Statement", statement);
86 self.record(match statement.kind {
87 StatementKind::Assign(..) => "StatementKind::Assign",
88 StatementKind::EndRegion(..) => "StatementKind::EndRegion",
89 StatementKind::Validate(..) => "StatementKind::Validate",
90 StatementKind::SetDiscriminant { .. } => "StatementKind::SetDiscriminant",
91 StatementKind::StorageLive(..) => "StatementKind::StorageLive",
92 StatementKind::StorageDead(..) => "StatementKind::StorageDead",
93 StatementKind::InlineAsm { .. } => "StatementKind::InlineAsm",
94 StatementKind::Nop => "StatementKind::Nop",
96 self.super_statement(block, statement, location);
99 fn visit_terminator(&mut self,
101 terminator: &Terminator<'tcx>,
102 location: Location) {
103 self.record("Terminator", terminator);
104 self.super_terminator(block, terminator, location);
107 fn visit_terminator_kind(&mut self,
109 kind: &TerminatorKind<'tcx>,
110 location: Location) {
111 self.record("TerminatorKind", kind);
112 self.record(match *kind {
113 TerminatorKind::Goto { .. } => "TerminatorKind::Goto",
114 TerminatorKind::SwitchInt { .. } => "TerminatorKind::SwitchInt",
115 TerminatorKind::Resume => "TerminatorKind::Resume",
116 TerminatorKind::Abort => "TerminatorKind::Abort",
117 TerminatorKind::Return => "TerminatorKind::Return",
118 TerminatorKind::Unreachable => "TerminatorKind::Unreachable",
119 TerminatorKind::Drop { .. } => "TerminatorKind::Drop",
120 TerminatorKind::DropAndReplace { .. } => "TerminatorKind::DropAndReplace",
121 TerminatorKind::Call { .. } => "TerminatorKind::Call",
122 TerminatorKind::Assert { .. } => "TerminatorKind::Assert",
123 TerminatorKind::GeneratorDrop => "TerminatorKind::GeneratorDrop",
124 TerminatorKind::Yield { .. } => "TerminatorKind::Yield",
125 TerminatorKind::FalseEdges { .. } => "TerminatorKind::FalseEdges",
126 TerminatorKind::FalseUnwind { .. } => "TerminatorKind::FalseUnwind",
128 self.super_terminator_kind(block, kind, location);
131 fn visit_assert_message(&mut self,
132 msg: &AssertMessage<'tcx>,
133 location: Location) {
134 self.record("AssertMessage", msg);
135 self.record(match *msg {
136 AssertMessage::BoundsCheck { .. } => "AssertMessage::BoundsCheck",
137 AssertMessage::Math(..) => "AssertMessage::Math",
138 AssertMessage::GeneratorResumedAfterReturn => {
139 "AssertMessage::GeneratorResumedAfterReturn"
141 AssertMessage::GeneratorResumedAfterPanic => {
142 "AssertMessage::GeneratorResumedAfterPanic"
145 self.super_assert_message(msg, location);
148 fn visit_rvalue(&mut self,
149 rvalue: &Rvalue<'tcx>,
150 location: Location) {
151 self.record("Rvalue", rvalue);
152 let rvalue_kind = match *rvalue {
153 Rvalue::Use(..) => "Rvalue::Use",
154 Rvalue::Repeat(..) => "Rvalue::Repeat",
155 Rvalue::Ref(..) => "Rvalue::Ref",
156 Rvalue::Len(..) => "Rvalue::Len",
157 Rvalue::Cast(..) => "Rvalue::Cast",
158 Rvalue::BinaryOp(..) => "Rvalue::BinaryOp",
159 Rvalue::CheckedBinaryOp(..) => "Rvalue::CheckedBinaryOp",
160 Rvalue::UnaryOp(..) => "Rvalue::UnaryOp",
161 Rvalue::Discriminant(..) => "Rvalue::Discriminant",
162 Rvalue::NullaryOp(..) => "Rvalue::NullaryOp",
163 Rvalue::Aggregate(ref kind, ref _operands) => {
164 // AggregateKind is not distinguished by visit API, so
165 // record it. (`super_rvalue` handles `_operands`.)
166 self.record(match **kind {
167 AggregateKind::Array(_) => "AggregateKind::Array",
168 AggregateKind::Tuple => "AggregateKind::Tuple",
169 AggregateKind::Adt(..) => "AggregateKind::Adt",
170 AggregateKind::Closure(..) => "AggregateKind::Closure",
171 AggregateKind::Generator(..) => "AggregateKind::Generator",
177 self.record(rvalue_kind, rvalue);
178 self.super_rvalue(rvalue, location);
181 fn visit_operand(&mut self,
182 operand: &Operand<'tcx>,
183 location: Location) {
184 self.record("Operand", operand);
185 self.record(match *operand {
186 Operand::Copy(..) => "Operand::Copy",
187 Operand::Move(..) => "Operand::Move",
188 Operand::Constant(..) => "Operand::Constant",
190 self.super_operand(operand, location);
193 fn visit_place(&mut self,
195 context: mir_visit::PlaceContext<'tcx>,
196 location: Location) {
197 self.record("Place", place);
198 self.record(match *place {
199 Place::Local(..) => "Place::Local",
200 Place::Static(..) => "Place::Static",
201 Place::Projection(..) => "Place::Projection",
203 self.super_place(place, context, location);
206 fn visit_projection(&mut self,
207 place: &PlaceProjection<'tcx>,
208 context: mir_visit::PlaceContext<'tcx>,
209 location: Location) {
210 self.record("PlaceProjection", place);
211 self.super_projection(place, context, location);
214 fn visit_projection_elem(&mut self,
215 place: &PlaceElem<'tcx>,
216 context: mir_visit::PlaceContext<'tcx>,
217 location: Location) {
218 self.record("PlaceElem", place);
219 self.record(match *place {
220 ProjectionElem::Deref => "PlaceElem::Deref",
221 ProjectionElem::Subslice { .. } => "PlaceElem::Subslice",
222 ProjectionElem::Field(..) => "PlaceElem::Field",
223 ProjectionElem::Index(..) => "PlaceElem::Index",
224 ProjectionElem::ConstantIndex { .. } => "PlaceElem::ConstantIndex",
225 ProjectionElem::Downcast(..) => "PlaceElem::Downcast",
227 self.super_projection_elem(place, context, location);
230 fn visit_constant(&mut self,
231 constant: &Constant<'tcx>,
232 location: Location) {
233 self.record("Constant", constant);
234 self.super_constant(constant, location);
237 fn visit_literal(&mut self,
238 literal: &Literal<'tcx>,
239 location: Location) {
240 self.record("Literal", literal);
241 self.record(match *literal {
242 Literal::Value { .. } => "Literal::Value",
243 Literal::Promoted { .. } => "Literal::Promoted",
245 self.super_literal(literal, location);
248 fn visit_source_info(&mut self,
249 source_info: &SourceInfo) {
250 self.record("SourceInfo", source_info);
251 self.super_source_info(source_info);
254 fn visit_closure_substs(&mut self,
255 substs: &ClosureSubsts<'tcx>,
257 self.record("ClosureSubsts", substs);
258 self.super_closure_substs(substs);
261 fn visit_const(&mut self,
262 constant: &&'tcx ty::Const<'tcx>,
264 self.record("Const", constant);
265 self.super_const(constant);
268 fn visit_const_usize(&mut self,
269 const_usize: &ConstUsize,
271 self.record("ConstUsize", const_usize);
272 self.super_const_usize(const_usize);
275 fn visit_local_decl(&mut self,
277 local_decl: &LocalDecl<'tcx>) {
278 self.record("LocalDecl", local_decl);
279 self.super_local_decl(local, local_decl);
282 fn visit_visibility_scope(&mut self,
283 scope: &VisibilityScope) {
284 self.record("VisiblityScope", scope);
285 self.super_visibility_scope(scope);