1 /*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 *
16 * Implementation file of the dex layout visualization.
17 *
18 * This is a tool to read dex files into an internal representation,
19 * reorganize the representation, and emit dex files with a better
20 * file layout.
21 */
22
23 #include "dex_visualize.h"
24
25 #include <inttypes.h>
26 #include <stdio.h>
27
28 #include <functional>
29 #include <memory>
30 #include <vector>
31
32 #include "dex_ir.h"
33 #include "dexlayout.h"
34 #include "jit/profile_compilation_info.h"
35
36 namespace art {
37
MultidexName(const std::string & prefix,size_t dex_file_index,const std::string & suffix)38 static std::string MultidexName(const std::string& prefix,
39 size_t dex_file_index,
40 const std::string& suffix) {
41 return prefix + ((dex_file_index > 0) ? std::to_string(dex_file_index + 1) : "") + suffix;
42 }
43
44 class Dumper {
45 public:
46 // Colors are based on the type of the section in MapList.
Dumper(dex_ir::Header * header)47 explicit Dumper(dex_ir::Header* header)
48 : out_file_(nullptr),
49 sorted_sections_(
50 dex_ir::GetSortedDexFileSections(header, dex_ir::SortDirection::kSortDescending)) { }
51
OpenAndPrintHeader(size_t dex_index)52 bool OpenAndPrintHeader(size_t dex_index) {
53 // Open the file and emit the gnuplot prologue.
54 out_file_ = fopen(MultidexName("layout", dex_index, ".gnuplot").c_str(), "w");
55 if (out_file_ == nullptr) {
56 return false;
57 }
58 fprintf(out_file_, "set terminal png size 1920,1080\n");
59 fprintf(out_file_, "set output \"%s\"\n", MultidexName("layout", dex_index, ".png").c_str());
60 fprintf(out_file_, "set title \"%s\"\n", MultidexName("classes", dex_index, ".dex").c_str());
61 fprintf(out_file_, "set xlabel \"Page offset into dex\"\n");
62 fprintf(out_file_, "set ylabel \"ClassDef index\"\n");
63 fprintf(out_file_, "set xtics rotate out (");
64 bool printed_one = false;
65
66 for (const dex_ir::DexFileSection& s : sorted_sections_) {
67 if (s.size > 0) {
68 if (printed_one) {
69 fprintf(out_file_, ", ");
70 }
71 fprintf(out_file_, "\"%s\" %d", s.name.c_str(), s.offset / kPageSize);
72 printed_one = true;
73 }
74 }
75 fprintf(out_file_, ")\n");
76 fprintf(out_file_,
77 "plot \"-\" using 1:2:3:4:5 with vector nohead linewidth 1 lc variable notitle\n");
78 return true;
79 }
80
GetColor(uint32_t offset) const81 int GetColor(uint32_t offset) const {
82 // The dread linear search to find the right section for the reference.
83 uint16_t section = 0;
84 for (const dex_ir::DexFileSection& file_section : sorted_sections_) {
85 if (file_section.offset < offset) {
86 section = file_section.type;
87 break;
88 }
89 }
90 // And a lookup table from type to color.
91 ColorMapType::const_iterator iter = kColorMap.find(section);
92 if (iter != kColorMap.end()) {
93 return iter->second;
94 }
95 return 0;
96 }
97
DumpAddressRange(uint32_t from,uint32_t size,int class_index)98 void DumpAddressRange(uint32_t from, uint32_t size, int class_index) {
99 const uint32_t low_page = from / kPageSize;
100 const uint32_t high_page = (size > 0) ? (from + size - 1) / kPageSize : low_page;
101 const uint32_t size_delta = high_page - low_page;
102 fprintf(out_file_, "%d %d %d 0 %d\n", low_page, class_index, size_delta, GetColor(from));
103 }
104
DumpAddressRange(const dex_ir::Item * item,int class_index)105 void DumpAddressRange(const dex_ir::Item* item, int class_index) {
106 if (item != nullptr) {
107 DumpAddressRange(item->GetOffset(), item->GetSize(), class_index);
108 }
109 }
110
DumpStringData(const dex_ir::StringData * string_data,int class_index)111 void DumpStringData(const dex_ir::StringData* string_data, int class_index) {
112 DumpAddressRange(string_data, class_index);
113 }
114
DumpStringId(const dex_ir::StringId * string_id,int class_index)115 void DumpStringId(const dex_ir::StringId* string_id, int class_index) {
116 DumpAddressRange(string_id, class_index);
117 if (string_id == nullptr) {
118 return;
119 }
120 DumpStringData(string_id->DataItem(), class_index);
121 }
122
DumpTypeId(const dex_ir::TypeId * type_id,int class_index)123 void DumpTypeId(const dex_ir::TypeId* type_id, int class_index) {
124 DumpAddressRange(type_id, class_index);
125 DumpStringId(type_id->GetStringId(), class_index);
126 }
127
DumpFieldId(const dex_ir::FieldId * field_id,int class_index)128 void DumpFieldId(const dex_ir::FieldId* field_id, int class_index) {
129 DumpAddressRange(field_id, class_index);
130 if (field_id == nullptr) {
131 return;
132 }
133 DumpTypeId(field_id->Class(), class_index);
134 DumpTypeId(field_id->Type(), class_index);
135 DumpStringId(field_id->Name(), class_index);
136 }
137
DumpFieldItem(const dex_ir::FieldItem * field,int class_index)138 void DumpFieldItem(const dex_ir::FieldItem* field, int class_index) {
139 DumpAddressRange(field, class_index);
140 if (field == nullptr) {
141 return;
142 }
143 DumpFieldId(field->GetFieldId(), class_index);
144 }
145
DumpProtoId(const dex_ir::ProtoId * proto_id,int class_index)146 void DumpProtoId(const dex_ir::ProtoId* proto_id, int class_index) {
147 DumpAddressRange(proto_id, class_index);
148 if (proto_id == nullptr) {
149 return;
150 }
151 DumpStringId(proto_id->Shorty(), class_index);
152 const dex_ir::TypeList* type_list = proto_id->Parameters();
153 if (type_list != nullptr) {
154 for (const dex_ir::TypeId* t : *type_list->GetTypeList()) {
155 DumpTypeId(t, class_index);
156 }
157 }
158 DumpTypeId(proto_id->ReturnType(), class_index);
159 }
160
DumpMethodId(const dex_ir::MethodId * method_id,int class_index)161 void DumpMethodId(const dex_ir::MethodId* method_id, int class_index) {
162 DumpAddressRange(method_id, class_index);
163 if (method_id == nullptr) {
164 return;
165 }
166 DumpTypeId(method_id->Class(), class_index);
167 DumpProtoId(method_id->Proto(), class_index);
168 DumpStringId(method_id->Name(), class_index);
169 }
170
DumpMethodItem(dex_ir::MethodItem * method,const DexFile * dex_file,int class_index,ProfileCompilationInfo * profile_info)171 void DumpMethodItem(dex_ir::MethodItem* method,
172 const DexFile* dex_file,
173 int class_index,
174 ProfileCompilationInfo* profile_info) {
175 if (profile_info != nullptr) {
176 uint32_t method_idx = method->GetMethodId()->GetIndex();
177 if (!profile_info->GetMethodHotness(MethodReference(dex_file, method_idx)).IsHot()) {
178 return;
179 }
180 }
181 DumpAddressRange(method, class_index);
182 if (method == nullptr) {
183 return;
184 }
185 DumpMethodId(method->GetMethodId(), class_index);
186 const dex_ir::CodeItem* code_item = method->GetCodeItem();
187 if (code_item != nullptr) {
188 DumpAddressRange(code_item, class_index);
189 const dex_ir::CodeFixups* fixups = code_item->GetCodeFixups();
190 if (fixups != nullptr) {
191 std::vector<dex_ir::TypeId*>* type_ids = fixups->TypeIds();
192 for (dex_ir::TypeId* type_id : *type_ids) {
193 DumpTypeId(type_id, class_index);
194 }
195 std::vector<dex_ir::StringId*>* string_ids = fixups->StringIds();
196 for (dex_ir::StringId* string_id : *string_ids) {
197 DumpStringId(string_id, class_index);
198 }
199 std::vector<dex_ir::MethodId*>* method_ids = fixups->MethodIds();
200 for (dex_ir::MethodId* method_id : *method_ids) {
201 DumpMethodId(method_id, class_index);
202 }
203 std::vector<dex_ir::FieldId*>* field_ids = fixups->FieldIds();
204 for (dex_ir::FieldId* field_id : *field_ids) {
205 DumpFieldId(field_id, class_index);
206 }
207 }
208 }
209 }
210
~Dumper()211 ~Dumper() {
212 fclose(out_file_);
213 }
214
215 private:
216 using ColorMapType = std::map<uint16_t, int>;
217 const ColorMapType kColorMap = {
218 { DexFile::kDexTypeHeaderItem, 1 },
219 { DexFile::kDexTypeStringIdItem, 2 },
220 { DexFile::kDexTypeTypeIdItem, 3 },
221 { DexFile::kDexTypeProtoIdItem, 4 },
222 { DexFile::kDexTypeFieldIdItem, 5 },
223 { DexFile::kDexTypeMethodIdItem, 6 },
224 { DexFile::kDexTypeClassDefItem, 7 },
225 { DexFile::kDexTypeTypeList, 8 },
226 { DexFile::kDexTypeAnnotationSetRefList, 9 },
227 { DexFile::kDexTypeAnnotationSetItem, 10 },
228 { DexFile::kDexTypeClassDataItem, 11 },
229 { DexFile::kDexTypeCodeItem, 12 },
230 { DexFile::kDexTypeStringDataItem, 13 },
231 { DexFile::kDexTypeDebugInfoItem, 14 },
232 { DexFile::kDexTypeAnnotationItem, 15 },
233 { DexFile::kDexTypeEncodedArrayItem, 16 },
234 { DexFile::kDexTypeAnnotationsDirectoryItem, 16 }
235 };
236
237 FILE* out_file_;
238 std::vector<dex_ir::DexFileSection> sorted_sections_;
239
240 DISALLOW_COPY_AND_ASSIGN(Dumper);
241 };
242
243 /*
244 * Dumps a gnuplot data file showing the parts of the dex_file that belong to each class.
245 * If profiling information is present, it dumps only those classes that are marked as hot.
246 */
VisualizeDexLayout(dex_ir::Header * header,const DexFile * dex_file,size_t dex_file_index,ProfileCompilationInfo * profile_info)247 void VisualizeDexLayout(dex_ir::Header* header,
248 const DexFile* dex_file,
249 size_t dex_file_index,
250 ProfileCompilationInfo* profile_info) {
251 std::unique_ptr<Dumper> dumper(new Dumper(header));
252 if (!dumper->OpenAndPrintHeader(dex_file_index)) {
253 fprintf(stderr, "Could not open output file.\n");
254 return;
255 }
256
257 const uint32_t class_defs_size = header->GetCollections().ClassDefsSize();
258 for (uint32_t class_index = 0; class_index < class_defs_size; class_index++) {
259 dex_ir::ClassDef* class_def = header->GetCollections().GetClassDef(class_index);
260 dex::TypeIndex type_idx(class_def->ClassType()->GetIndex());
261 if (profile_info != nullptr && !profile_info->ContainsClass(*dex_file, type_idx)) {
262 continue;
263 }
264 dumper->DumpAddressRange(class_def, class_index);
265 // Type id.
266 dumper->DumpTypeId(class_def->ClassType(), class_index);
267 // Superclass type id.
268 dumper->DumpTypeId(class_def->Superclass(), class_index);
269 // Interfaces.
270 // TODO(jeffhao): get TypeList from class_def to use Item interface.
271 static constexpr uint32_t kInterfaceSizeKludge = 8;
272 dumper->DumpAddressRange(class_def->InterfacesOffset(), kInterfaceSizeKludge, class_index);
273 // Source file info.
274 dumper->DumpStringId(class_def->SourceFile(), class_index);
275 // Annotations.
276 dumper->DumpAddressRange(class_def->Annotations(), class_index);
277 // TODO(sehr): walk the annotations and dump them.
278 // Class data.
279 dex_ir::ClassData* class_data = class_def->GetClassData();
280 if (class_data != nullptr) {
281 dumper->DumpAddressRange(class_data, class_index);
282 if (class_data->StaticFields()) {
283 for (auto& field_item : *class_data->StaticFields()) {
284 dumper->DumpFieldItem(field_item.get(), class_index);
285 }
286 }
287 if (class_data->InstanceFields()) {
288 for (auto& field_item : *class_data->InstanceFields()) {
289 dumper->DumpFieldItem(field_item.get(), class_index);
290 }
291 }
292 if (class_data->DirectMethods()) {
293 for (auto& method_item : *class_data->DirectMethods()) {
294 dumper->DumpMethodItem(method_item.get(), dex_file, class_index, profile_info);
295 }
296 }
297 if (class_data->VirtualMethods()) {
298 for (auto& method_item : *class_data->VirtualMethods()) {
299 dumper->DumpMethodItem(method_item.get(), dex_file, class_index, profile_info);
300 }
301 }
302 }
303 } // for
304 }
305
FindNextByteAfterSection(dex_ir::Header * header,const std::vector<dex_ir::DexFileSection> & sorted_sections,size_t section_index)306 static uint32_t FindNextByteAfterSection(dex_ir::Header* header,
307 const std::vector<dex_ir::DexFileSection>& sorted_sections,
308 size_t section_index) {
309 for (size_t i = section_index + 1; i < sorted_sections.size(); ++i) {
310 const dex_ir::DexFileSection& section = sorted_sections.at(i);
311 if (section.size != 0) {
312 return section.offset;
313 }
314 }
315 return header->FileSize();
316 }
317
318 /*
319 * Dumps the offset and size of sections within the file.
320 */
ShowDexSectionStatistics(dex_ir::Header * header,size_t dex_file_index)321 void ShowDexSectionStatistics(dex_ir::Header* header, size_t dex_file_index) {
322 // Compute the (multidex) class file name).
323 fprintf(stdout, "%s (%d bytes)\n",
324 MultidexName("classes", dex_file_index, ".dex").c_str(),
325 header->FileSize());
326 fprintf(stdout, "section offset items bytes pages pct\n");
327 std::vector<dex_ir::DexFileSection> sorted_sections =
328 GetSortedDexFileSections(header, dex_ir::SortDirection::kSortAscending);
329 for (size_t i = 0; i < sorted_sections.size(); ++i) {
330 const dex_ir::DexFileSection& file_section = sorted_sections[i];
331 uint32_t bytes = 0;
332 if (file_section.size > 0) {
333 bytes = FindNextByteAfterSection(header, sorted_sections, i) - file_section.offset;
334 }
335 fprintf(stdout,
336 "%-10s %8d %8d %8d %8d %%%02d\n",
337 file_section.name.c_str(),
338 file_section.offset,
339 file_section.size,
340 bytes,
341 RoundUp(bytes, kPageSize) / kPageSize,
342 100 * bytes / header->FileSize());
343 }
344 fprintf(stdout, "\n");
345 }
346
347 } // namespace art
348