blob: c7bf231e037baad1da716d3271573dff2c115ecb [file] [log] [blame]
Elliott Hughes2faa5f12012-01-30 14:42:07 -08001/*
2 * Copyright (C) 2011 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 */
Brian Carlstrom78128a62011-09-15 17:21:19 -070016
17#include <stdio.h>
18#include <stdlib.h>
19
Brian Carlstrom27ec9612011-09-19 20:20:38 -070020#include <fstream>
21#include <iostream>
Igor Murashkin37743352014-11-13 14:38:00 -080022#include <map>
23#include <set>
Brian Carlstrom78128a62011-09-15 17:21:19 -070024#include <string>
Andreas Gampe54fc26c2014-09-04 21:47:42 -070025#include <unordered_map>
Andreas Gampe9fded872016-09-25 16:08:35 -070026#include <unordered_set>
Brian Carlstrom78128a62011-09-15 17:21:19 -070027#include <vector>
28
Ian Rogersd582fa42014-11-05 23:46:43 -080029#include "arch/instruction_set_features.h"
Mathieu Chartierc7853442015-03-27 14:35:38 -070030#include "art_field-inl.h"
Mathieu Chartiere401d142015-04-22 13:56:20 -070031#include "art_method-inl.h"
Vladimir Marko10c13562015-11-25 14:33:36 +000032#include "base/stl_util.h"
Elliott Hughes76160052012-12-12 16:31:20 -080033#include "base/unix_file/fd_file.h"
Brian Carlstrom78128a62011-09-15 17:21:19 -070034#include "class_linker.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080035#include "class_linker-inl.h"
David Srbecky5d950762016-03-07 20:47:29 +000036#include "debug/elf_debug_writer.h"
37#include "debug/method_debug_info.h"
Ian Rogers4f6ad8a2013-03-18 15:27:28 -070038#include "dex_file-inl.h"
Christina Wadsworthbc233ac2016-06-20 15:01:32 -070039#include "dex_instruction-inl.h"
Ian Rogers3a5c1ce2012-02-29 10:06:46 -080040#include "disassembler.h"
Andreas Gampe54fc26c2014-09-04 21:47:42 -070041#include "elf_builder.h"
Ian Rogers1d54e732013-05-02 21:10:01 -070042#include "gc/space/image_space.h"
43#include "gc/space/large_object_space.h"
44#include "gc/space/space-inl.h"
Mathieu Chartier4a26f172016-01-26 14:26:18 -080045#include "image-inl.h"
Andreas Gampe9fded872016-09-25 16:08:35 -070046#include "imtable-inl.h"
Ian Rogers2bcb4a42012-11-08 10:39:18 -080047#include "indenter.h"
Andreas Gampeebfc1ac2016-09-29 19:50:27 -070048#include "interpreter/unstarted_runtime.h"
Vladimir Marko131980f2015-12-03 18:29:23 +000049#include "linker/buffered_output_stream.h"
50#include "linker/file_output_stream.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080051#include "mirror/array-inl.h"
52#include "mirror/class-inl.h"
Vladimir Marko05792b92015-08-03 11:56:49 +010053#include "mirror/dex_cache-inl.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080054#include "mirror/object-inl.h"
55#include "mirror/object_array-inl.h"
Brian Carlstrom700c8d32012-11-05 10:42:02 -080056#include "oat.h"
Vladimir Marko8a630572014-04-09 18:45:35 +010057#include "oat_file-inl.h"
Mathieu Chartierf9c6fc62015-10-07 11:44:05 -070058#include "oat_file_manager.h"
Elliott Hughese5448b52012-01-18 16:44:06 -080059#include "os.h"
Elliott Hughesa0e18062012-04-13 15:59:59 -070060#include "safe_map.h"
Mathieu Chartier0795f232016-09-27 18:43:30 -070061#include "scoped_thread_state_change-inl.h"
Nicolas Geoffray9c055782016-07-14 09:24:30 +000062#include "ScopedLocalRef.h"
Mathieu Chartierdc00f182016-07-14 10:10:44 -070063#include "stack_map.h"
64#include "string_reference.h"
Mathieu Chartierc22c59e2014-02-24 15:16:06 -080065#include "thread_list.h"
Andreas Gampe2ba88952016-04-29 17:52:07 -070066#include "type_lookup_table.h"
Ian Rogers2bcb4a42012-11-08 10:39:18 -080067#include "verifier/method_verifier.h"
Andreas Gampe00b25f32014-09-17 21:49:05 -070068#include "well_known_classes.h"
Brian Carlstrom78128a62011-09-15 17:21:19 -070069
Igor Murashkin37743352014-11-13 14:38:00 -080070#include <sys/stat.h>
71#include "cmdline.h"
Brian Carlstrom78128a62011-09-15 17:21:19 -070072
Igor Murashkin37743352014-11-13 14:38:00 -080073namespace art {
Brian Carlstrom78128a62011-09-15 17:21:19 -070074
Mathieu Chartiere401d142015-04-22 13:56:20 -070075const char* image_methods_descriptions_[] = {
Ian Rogers19846512012-02-24 11:42:47 -080076 "kResolutionMethod",
Jeff Hao88474b42013-10-23 16:24:40 -070077 "kImtConflictMethod",
Mathieu Chartier2d2621a2014-10-23 16:48:06 -070078 "kImtUnimplementedMethod",
Vladimir Markofd36f1f2016-08-03 18:49:58 +010079 "kSaveAllCalleeSavesMethod",
80 "kSaveRefsOnlyMethod",
81 "kSaveRefsAndArgsMethod",
Vladimir Marko952dbb12016-07-28 12:01:51 +010082 "kSaveEverythingMethod",
Mathieu Chartiere401d142015-04-22 13:56:20 -070083};
84
85const char* image_roots_descriptions_[] = {
Brian Carlstrom58ae9412011-10-04 00:56:06 -070086 "kDexCaches",
Brian Carlstrom34f426c2011-10-04 12:58:02 -070087 "kClassRoots",
Brian Carlstrom78128a62011-09-15 17:21:19 -070088};
89
Mathieu Chartierac8f4392015-08-27 13:54:20 -070090// Map is so that we don't allocate multiple dex files for the same OatDexFile.
91static std::map<const OatFile::OatDexFile*,
92 std::unique_ptr<const DexFile>> opened_dex_files;
93
94const DexFile* OpenDexFile(const OatFile::OatDexFile* oat_dex_file, std::string* error_msg) {
95 DCHECK(oat_dex_file != nullptr);
96 auto it = opened_dex_files.find(oat_dex_file);
97 if (it != opened_dex_files.end()) {
98 return it->second.get();
99 }
100 const DexFile* ret = oat_dex_file->OpenDexFile(error_msg).release();
101 opened_dex_files.emplace(oat_dex_file, std::unique_ptr<const DexFile>(ret));
102 return ret;
103}
104
Andreas Gampe2d8614b2016-03-07 16:31:34 -0800105template <typename ElfTypes>
David Srbeckybc90fd02015-04-22 19:40:27 +0100106class OatSymbolizer FINAL {
Andreas Gampe54fc26c2014-09-04 21:47:42 -0700107 public:
David Srbecky2fdd03c2016-03-10 15:32:37 +0000108 OatSymbolizer(const OatFile* oat_file, const std::string& output_name, bool no_bits) :
109 oat_file_(oat_file),
110 builder_(nullptr),
111 output_name_(output_name.empty() ? "symbolized.oat" : output_name),
112 no_bits_(no_bits) {
Andreas Gampe54fc26c2014-09-04 21:47:42 -0700113 }
114
Andreas Gampe54fc26c2014-09-04 21:47:42 -0700115 bool Symbolize() {
David Srbecky6d8c8f02015-10-26 10:57:09 +0000116 const InstructionSet isa = oat_file_->GetOatHeader().GetInstructionSet();
David Srbecky5d811202016-03-08 13:21:22 +0000117 const InstructionSetFeatures* features = InstructionSetFeatures::FromBitmap(
118 isa, oat_file_->GetOatHeader().GetInstructionSetFeaturesBitmap());
David Srbecky6d8c8f02015-10-26 10:57:09 +0000119
120 File* elf_file = OS::CreateEmptyFile(output_name_.c_str());
121 std::unique_ptr<BufferedOutputStream> output_stream(
Vladimir Marko10c13562015-11-25 14:33:36 +0000122 MakeUnique<BufferedOutputStream>(MakeUnique<FileOutputStream>(elf_file)));
Andreas Gampe2d8614b2016-03-07 16:31:34 -0800123 builder_.reset(new ElfBuilder<ElfTypes>(isa, features, output_stream.get()));
David Srbecky6d8c8f02015-10-26 10:57:09 +0000124
125 builder_->Start();
126
127 auto* rodata = builder_->GetRoData();
128 auto* text = builder_->GetText();
129 auto* bss = builder_->GetBss();
David Srbecky6d8c8f02015-10-26 10:57:09 +0000130
David Srbecky6d8c8f02015-10-26 10:57:09 +0000131 const uint8_t* rodata_begin = oat_file_->Begin();
132 const size_t rodata_size = oat_file_->GetOatHeader().GetExecutableOffset();
David Srbecky2fdd03c2016-03-10 15:32:37 +0000133 if (no_bits_) {
134 rodata->WriteNoBitsSection(rodata_size);
135 } else {
136 rodata->Start();
137 rodata->WriteFully(rodata_begin, rodata_size);
138 rodata->End();
139 }
David Srbecky6d8c8f02015-10-26 10:57:09 +0000140
David Srbecky6d8c8f02015-10-26 10:57:09 +0000141 const uint8_t* text_begin = oat_file_->Begin() + rodata_size;
142 const size_t text_size = oat_file_->End() - text_begin;
David Srbecky2fdd03c2016-03-10 15:32:37 +0000143 if (no_bits_) {
144 text->WriteNoBitsSection(text_size);
145 } else {
146 text->Start();
147 text->WriteFully(text_begin, text_size);
148 text->End();
149 }
David Srbecky6d8c8f02015-10-26 10:57:09 +0000150
151 if (oat_file_->BssSize() != 0) {
David Srbecky5b1c2ca2016-01-25 17:32:41 +0000152 bss->WriteNoBitsSection(oat_file_->BssSize());
David Srbecky6d8c8f02015-10-26 10:57:09 +0000153 }
154
Douglas Leung316a2182015-09-17 15:26:25 -0700155 if (isa == kMips || isa == kMips64) {
156 builder_->WriteMIPSabiflagsSection();
157 }
Vladimir Markoaad75c62016-10-03 08:46:48 +0000158 builder_->PrepareDynamicSection(elf_file->GetPath(),
159 rodata_size,
160 text_size,
161 oat_file_->BssSize(),
162 oat_file_->BssRootsOffset());
Vladimir Marko944da602016-02-19 12:27:55 +0000163 builder_->WriteDynamicSection();
Andreas Gampe54fc26c2014-09-04 21:47:42 -0700164
David Srbecky5d950762016-03-07 20:47:29 +0000165 Walk();
166 for (const auto& trampoline : debug::MakeTrampolineInfos(oat_file_->GetOatHeader())) {
167 method_debug_infos_.push_back(trampoline);
168 }
Andreas Gampe54fc26c2014-09-04 21:47:42 -0700169
David Srbecky5d950762016-03-07 20:47:29 +0000170 debug::WriteDebugInfo(builder_.get(),
171 ArrayRef<const debug::MethodDebugInfo>(method_debug_infos_),
172 dwarf::DW_DEBUG_FRAME_FORMAT,
173 true /* write_oat_patches */);
Andreas Gampe54fc26c2014-09-04 21:47:42 -0700174
David Srbecky6d8c8f02015-10-26 10:57:09 +0000175 builder_->End();
Andreas Gampe54fc26c2014-09-04 21:47:42 -0700176
Vladimir Marko10c13562015-11-25 14:33:36 +0000177 return builder_->Good();
Andreas Gampe54fc26c2014-09-04 21:47:42 -0700178 }
179
David Srbecky5d950762016-03-07 20:47:29 +0000180 void Walk() {
Andreas Gampe54fc26c2014-09-04 21:47:42 -0700181 std::vector<const OatFile::OatDexFile*> oat_dex_files = oat_file_->GetOatDexFiles();
182 for (size_t i = 0; i < oat_dex_files.size(); i++) {
183 const OatFile::OatDexFile* oat_dex_file = oat_dex_files[i];
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700184 CHECK(oat_dex_file != nullptr);
David Srbecky5d950762016-03-07 20:47:29 +0000185 WalkOatDexFile(oat_dex_file);
Andreas Gampe54fc26c2014-09-04 21:47:42 -0700186 }
187 }
188
David Srbecky5d950762016-03-07 20:47:29 +0000189 void WalkOatDexFile(const OatFile::OatDexFile* oat_dex_file) {
Andreas Gampe54fc26c2014-09-04 21:47:42 -0700190 std::string error_msg;
Mathieu Chartierac8f4392015-08-27 13:54:20 -0700191 const DexFile* const dex_file = OpenDexFile(oat_dex_file, &error_msg);
192 if (dex_file == nullptr) {
Andreas Gampe54fc26c2014-09-04 21:47:42 -0700193 return;
194 }
195 for (size_t class_def_index = 0;
196 class_def_index < dex_file->NumClassDefs();
197 class_def_index++) {
Andreas Gampe54fc26c2014-09-04 21:47:42 -0700198 const OatFile::OatClass oat_class = oat_dex_file->GetOatClass(class_def_index);
199 OatClassType type = oat_class.GetType();
200 switch (type) {
201 case kOatClassAllCompiled:
202 case kOatClassSomeCompiled:
David Srbecky5d950762016-03-07 20:47:29 +0000203 WalkOatClass(oat_class, *dex_file, class_def_index);
Andreas Gampe54fc26c2014-09-04 21:47:42 -0700204 break;
205
206 case kOatClassNoneCompiled:
207 case kOatClassMax:
208 // Ignore.
209 break;
210 }
211 }
212 }
213
David Srbecky5d950762016-03-07 20:47:29 +0000214 void WalkOatClass(const OatFile::OatClass& oat_class,
215 const DexFile& dex_file,
216 uint32_t class_def_index) {
217 const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
Ian Rogers13735952014-10-08 12:43:28 -0700218 const uint8_t* class_data = dex_file.GetClassData(class_def);
Andreas Gampe54fc26c2014-09-04 21:47:42 -0700219 if (class_data == nullptr) { // empty class such as a marker interface?
220 return;
221 }
222 // Note: even if this is an interface or a native class, we still have to walk it, as there
223 // might be a static initializer.
224 ClassDataItemIterator it(dex_file, class_data);
Andreas Gampe54fc26c2014-09-04 21:47:42 -0700225 uint32_t class_method_idx = 0;
David Srbecky5d950762016-03-07 20:47:29 +0000226 for (; it.HasNextStaticField(); it.Next()) { /* skip */ }
227 for (; it.HasNextInstanceField(); it.Next()) { /* skip */ }
228 for (; it.HasNextDirectMethod() || it.HasNextVirtualMethod(); it.Next()) {
229 WalkOatMethod(oat_class.GetOatMethod(class_method_idx++),
230 dex_file,
231 class_def_index,
232 it.GetMemberIndex(),
233 it.GetMethodCodeItem(),
234 it.GetMethodAccessFlags());
Andreas Gampe54fc26c2014-09-04 21:47:42 -0700235 }
236 DCHECK(!it.HasNext());
237 }
238
David Srbecky5d950762016-03-07 20:47:29 +0000239 void WalkOatMethod(const OatFile::OatMethod& oat_method,
240 const DexFile& dex_file,
241 uint32_t class_def_index,
242 uint32_t dex_method_index,
243 const DexFile::CodeItem* code_item,
244 uint32_t method_access_flags) {
Andreas Gampe54fc26c2014-09-04 21:47:42 -0700245 if ((method_access_flags & kAccAbstract) != 0) {
246 // Abstract method, no code.
247 return;
248 }
David Srbecky5d950762016-03-07 20:47:29 +0000249 const OatHeader& oat_header = oat_file_->GetOatHeader();
250 const OatQuickMethodHeader* method_header = oat_method.GetOatQuickMethodHeader();
251 if (method_header == nullptr || method_header->GetCodeSize() == 0) {
Andreas Gampe54fc26c2014-09-04 21:47:42 -0700252 // No code.
253 return;
254 }
255
David Srbeckya1b4c5f2016-03-31 18:17:59 +0100256 uint32_t entry_point = oat_method.GetCodeOffset() - oat_header.GetExecutableOffset();
257 // Clear Thumb2 bit.
258 const void* code_address = EntryPointToCodePointer(reinterpret_cast<void*>(entry_point));
259
David Srbecky5d950762016-03-07 20:47:29 +0000260 debug::MethodDebugInfo info = debug::MethodDebugInfo();
261 info.trampoline_name = nullptr;
262 info.dex_file = &dex_file;
263 info.class_def_index = class_def_index;
264 info.dex_method_index = dex_method_index;
265 info.access_flags = method_access_flags;
266 info.code_item = code_item;
267 info.isa = oat_header.GetInstructionSet();
268 info.deduped = !seen_offsets_.insert(oat_method.GetCodeOffset()).second;
269 info.is_native_debuggable = oat_header.IsNativeDebuggable();
270 info.is_optimized = method_header->IsOptimized();
271 info.is_code_address_text_relative = true;
David Srbeckya1b4c5f2016-03-31 18:17:59 +0100272 info.code_address = reinterpret_cast<uintptr_t>(code_address);
David Srbecky5d950762016-03-07 20:47:29 +0000273 info.code_size = method_header->GetCodeSize();
274 info.frame_size_in_bytes = method_header->GetFrameSizeInBytes();
275 info.code_info = info.is_optimized ? method_header->GetOptimizedCodeInfoPtr() : nullptr;
276 info.cfi = ArrayRef<uint8_t>();
277 method_debug_infos_.push_back(info);
Andreas Gampe54fc26c2014-09-04 21:47:42 -0700278 }
279
Andreas Gampe54fc26c2014-09-04 21:47:42 -0700280 private:
Andreas Gampe54fc26c2014-09-04 21:47:42 -0700281 const OatFile* oat_file_;
Andreas Gampe2d8614b2016-03-07 16:31:34 -0800282 std::unique_ptr<ElfBuilder<ElfTypes> > builder_;
David Srbecky5d950762016-03-07 20:47:29 +0000283 std::vector<debug::MethodDebugInfo> method_debug_infos_;
284 std::unordered_set<uint32_t> seen_offsets_;
Ian Rogers0279ebb2014-10-08 17:27:48 -0700285 const std::string output_name_;
David Srbecky2fdd03c2016-03-10 15:32:37 +0000286 bool no_bits_;
Andreas Gampe54fc26c2014-09-04 21:47:42 -0700287};
288
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700289class OatDumperOptions {
290 public:
Vladimir Marko9d07e3d2016-03-31 12:02:28 +0100291 OatDumperOptions(bool dump_vmap,
Roland Levillainf2650d12015-05-28 14:53:28 +0100292 bool dump_code_info_stack_maps,
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700293 bool disassemble_code,
Andreas Gampe00b25f32014-09-17 21:49:05 -0700294 bool absolute_addresses,
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -0800295 const char* class_filter,
296 const char* method_filter,
297 bool list_classes,
298 bool list_methods,
David Brazdilc03d7b62016-03-02 12:18:03 +0000299 bool dump_header_only,
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -0800300 const char* export_dex_location,
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -0800301 const char* app_image,
302 const char* app_oat,
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -0800303 uint32_t addr2instr)
Vladimir Marko9d07e3d2016-03-31 12:02:28 +0100304 : dump_vmap_(dump_vmap),
Roland Levillainf2650d12015-05-28 14:53:28 +0100305 dump_code_info_stack_maps_(dump_code_info_stack_maps),
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700306 disassemble_code_(disassemble_code),
Andreas Gampe00b25f32014-09-17 21:49:05 -0700307 absolute_addresses_(absolute_addresses),
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -0800308 class_filter_(class_filter),
Nicolas Geoffray3fcd2202014-11-12 18:02:36 +0000309 method_filter_(method_filter),
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -0800310 list_classes_(list_classes),
311 list_methods_(list_methods),
David Brazdilc03d7b62016-03-02 12:18:03 +0000312 dump_header_only_(dump_header_only),
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -0800313 export_dex_location_(export_dex_location),
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -0800314 app_image_(app_image),
315 app_oat_(app_oat),
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -0800316 addr2instr_(addr2instr),
Igor Murashkin37743352014-11-13 14:38:00 -0800317 class_loader_(nullptr) {}
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700318
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700319 const bool dump_vmap_;
Roland Levillainf2650d12015-05-28 14:53:28 +0100320 const bool dump_code_info_stack_maps_;
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700321 const bool disassemble_code_;
322 const bool absolute_addresses_;
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -0800323 const char* const class_filter_;
Nicolas Geoffray3fcd2202014-11-12 18:02:36 +0000324 const char* const method_filter_;
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -0800325 const bool list_classes_;
326 const bool list_methods_;
David Brazdilc03d7b62016-03-02 12:18:03 +0000327 const bool dump_header_only_;
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -0800328 const char* const export_dex_location_;
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -0800329 const char* const app_image_;
330 const char* const app_oat_;
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -0800331 uint32_t addr2instr_;
Andreas Gampe00b25f32014-09-17 21:49:05 -0700332 Handle<mirror::ClassLoader>* class_loader_;
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700333};
334
Elliott Hughese3c845c2012-02-28 17:23:01 -0800335class OatDumper {
Brian Carlstromaded5f72011-10-07 17:15:04 -0700336 public:
Roland Levillain3887c462015-08-12 18:15:42 +0100337 OatDumper(const OatFile& oat_file, const OatDumperOptions& options)
Nicolas Geoffray9583fbc2014-02-28 15:21:07 +0000338 : oat_file_(oat_file),
Elliott Hughesa72ec822012-03-05 17:12:22 -0800339 oat_dex_files_(oat_file.GetOatDexFiles()),
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700340 options_(options),
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -0800341 resolved_addr2instr_(0),
Mathieu Chartiera7dd0382014-11-20 17:08:58 -0800342 instruction_set_(oat_file_.GetOatHeader().GetInstructionSet()),
343 disassembler_(Disassembler::Create(instruction_set_,
Andreas Gampe372f3a32016-08-19 10:49:06 -0700344 new DisassemblerOptions(
345 options_.absolute_addresses_,
346 oat_file.Begin(),
347 oat_file.End(),
348 true /* can_read_literals_ */,
349 Is64BitInstructionSet(instruction_set_)
350 ? &Thread::DumpThreadOffset<PointerSize::k64>
351 : &Thread::DumpThreadOffset<PointerSize::k32>))) {
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -0800352 CHECK(options_.class_loader_ != nullptr);
353 CHECK(options_.class_filter_ != nullptr);
354 CHECK(options_.method_filter_ != nullptr);
Ian Rogers3a5c1ce2012-02-29 10:06:46 -0800355 AddAllOffsets();
356 }
357
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700358 ~OatDumper() {
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700359 delete disassembler_;
360 }
361
Mathieu Chartiera7dd0382014-11-20 17:08:58 -0800362 InstructionSet GetInstructionSet() {
363 return instruction_set_;
364 }
365
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700366 bool Dump(std::ostream& os) {
367 bool success = true;
Ian Rogers3a5c1ce2012-02-29 10:06:46 -0800368 const OatHeader& oat_header = oat_file_.GetOatHeader();
Brian Carlstromaded5f72011-10-07 17:15:04 -0700369
370 os << "MAGIC:\n";
371 os << oat_header.GetMagic() << "\n\n";
372
Jeff Hao4b07a6e2016-01-15 12:50:44 -0800373 os << "LOCATION:\n";
374 os << oat_file_.GetLocation() << "\n\n";
375
Brian Carlstromaded5f72011-10-07 17:15:04 -0700376 os << "CHECKSUM:\n";
Elliott Hughesed2adb62012-02-29 14:41:01 -0800377 os << StringPrintf("0x%08x\n\n", oat_header.GetChecksum());
Brian Carlstromaded5f72011-10-07 17:15:04 -0700378
Elliott Hughesa72ec822012-03-05 17:12:22 -0800379 os << "INSTRUCTION SET:\n";
380 os << oat_header.GetInstructionSet() << "\n\n";
381
Ian Rogers6f3dbba2014-10-14 17:41:57 -0700382 {
383 std::unique_ptr<const InstructionSetFeatures> features(
384 InstructionSetFeatures::FromBitmap(oat_header.GetInstructionSet(),
385 oat_header.GetInstructionSetFeaturesBitmap()));
386 os << "INSTRUCTION SET FEATURES:\n";
387 os << features->GetFeatureString() << "\n\n";
388 }
Dave Allison70202782013-10-22 17:52:19 -0700389
Brian Carlstromaded5f72011-10-07 17:15:04 -0700390 os << "DEX FILE COUNT:\n";
391 os << oat_header.GetDexFileCount() << "\n\n";
392
Brian Carlstrom2ec65202014-03-03 15:16:37 -0800393#define DUMP_OAT_HEADER_OFFSET(label, offset) \
394 os << label " OFFSET:\n"; \
395 os << StringPrintf("0x%08x", oat_header.offset()); \
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -0800396 if (oat_header.offset() != 0 && options_.absolute_addresses_) { \
Brian Carlstrom2ec65202014-03-03 15:16:37 -0800397 os << StringPrintf(" (%p)", oat_file_.Begin() + oat_header.offset()); \
398 } \
399 os << StringPrintf("\n\n");
400
401 DUMP_OAT_HEADER_OFFSET("EXECUTABLE", GetExecutableOffset);
402 DUMP_OAT_HEADER_OFFSET("INTERPRETER TO INTERPRETER BRIDGE",
403 GetInterpreterToInterpreterBridgeOffset);
404 DUMP_OAT_HEADER_OFFSET("INTERPRETER TO COMPILED CODE BRIDGE",
405 GetInterpreterToCompiledCodeBridgeOffset);
406 DUMP_OAT_HEADER_OFFSET("JNI DLSYM LOOKUP",
407 GetJniDlsymLookupOffset);
Brian Carlstrom2ec65202014-03-03 15:16:37 -0800408 DUMP_OAT_HEADER_OFFSET("QUICK GENERIC JNI TRAMPOLINE",
409 GetQuickGenericJniTrampolineOffset);
410 DUMP_OAT_HEADER_OFFSET("QUICK IMT CONFLICT TRAMPOLINE",
411 GetQuickImtConflictTrampolineOffset);
412 DUMP_OAT_HEADER_OFFSET("QUICK RESOLUTION TRAMPOLINE",
413 GetQuickResolutionTrampolineOffset);
414 DUMP_OAT_HEADER_OFFSET("QUICK TO INTERPRETER BRIDGE",
415 GetQuickToInterpreterBridgeOffset);
416#undef DUMP_OAT_HEADER_OFFSET
Brian Carlstromaded5f72011-10-07 17:15:04 -0700417
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700418 os << "IMAGE PATCH DELTA:\n";
419 os << StringPrintf("%d (0x%08x)\n\n",
420 oat_header.GetImagePatchDelta(),
421 oat_header.GetImagePatchDelta());
Alex Lighta59dd802014-07-02 16:28:08 -0700422
Brian Carlstrom28db0122012-10-18 16:20:41 -0700423 os << "IMAGE FILE LOCATION OAT CHECKSUM:\n";
424 os << StringPrintf("0x%08x\n\n", oat_header.GetImageFileLocationOatChecksum());
425
426 os << "IMAGE FILE LOCATION OAT BEGIN:\n";
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800427 os << StringPrintf("0x%08x\n\n", oat_header.GetImageFileLocationOatDataBegin());
Brian Carlstrom81f3ca12012-03-17 00:27:35 -0700428
Andreas Gampe22f8e5c2014-07-09 11:38:21 -0700429 // Print the key-value store.
430 {
431 os << "KEY VALUE STORE:\n";
432 size_t index = 0;
433 const char* key;
434 const char* value;
435 while (oat_header.GetStoreKeyValuePairByIndex(index, &key, &value)) {
436 os << key << " = " << value << "\n";
437 index++;
438 }
439 os << "\n";
440 }
Brian Carlstrom81f3ca12012-03-17 00:27:35 -0700441
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -0800442 if (options_.absolute_addresses_) {
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700443 os << "BEGIN:\n";
444 os << reinterpret_cast<const void*>(oat_file_.Begin()) << "\n\n";
Brian Carlstromaded5f72011-10-07 17:15:04 -0700445
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700446 os << "END:\n";
447 os << reinterpret_cast<const void*>(oat_file_.End()) << "\n\n";
448 }
449
450 os << "SIZE:\n";
451 os << oat_file_.Size() << "\n\n";
Brian Carlstromaded5f72011-10-07 17:15:04 -0700452
453 os << std::flush;
454
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -0800455 // If set, adjust relative address to be searched
456 if (options_.addr2instr_ != 0) {
457 resolved_addr2instr_ = options_.addr2instr_ + oat_header.GetExecutableOffset();
458 os << "SEARCH ADDRESS (executable offset + input):\n";
459 os << StringPrintf("0x%08x\n\n", resolved_addr2instr_);
460 }
461
Mathieu Chartierdc00f182016-07-14 10:10:44 -0700462 // Dumping the dex file overview is compact enough to do even if header only.
463 DexFileData cumulative;
464 for (size_t i = 0; i < oat_dex_files_.size(); i++) {
465 const OatFile::OatDexFile* oat_dex_file = oat_dex_files_[i];
466 CHECK(oat_dex_file != nullptr);
467 std::string error_msg;
468 const DexFile* const dex_file = OpenDexFile(oat_dex_file, &error_msg);
469 if (dex_file == nullptr) {
470 os << "Failed to open dex file '" << oat_dex_file->GetDexFileLocation() << "': "
471 << error_msg;
472 continue;
473 }
474 DexFileData data(*dex_file);
475 os << "Dex file data for " << dex_file->GetLocation() << "\n";
476 data.Dump(os);
477 os << "\n";
478 cumulative.Add(data);
479 }
480 os << "Cumulative dex file data\n";
481 cumulative.Dump(os);
482 os << "\n";
483
David Brazdilc03d7b62016-03-02 12:18:03 +0000484 if (!options_.dump_header_only_) {
485 for (size_t i = 0; i < oat_dex_files_.size(); i++) {
486 const OatFile::OatDexFile* oat_dex_file = oat_dex_files_[i];
487 CHECK(oat_dex_file != nullptr);
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -0800488
David Brazdilc03d7b62016-03-02 12:18:03 +0000489 // If file export selected skip file analysis
490 if (options_.export_dex_location_) {
491 if (!ExportDexFile(os, *oat_dex_file)) {
492 success = false;
493 }
494 } else {
495 if (!DumpOatDexFile(os, *oat_dex_file)) {
496 success = false;
497 }
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -0800498 }
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700499 }
Brian Carlstromaded5f72011-10-07 17:15:04 -0700500 }
David Brazdilc03d7b62016-03-02 12:18:03 +0000501
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700502 os << std::flush;
503 return success;
Brian Carlstromaded5f72011-10-07 17:15:04 -0700504 }
505
Ian Rogers3a5c1ce2012-02-29 10:06:46 -0800506 size_t ComputeSize(const void* oat_data) {
Ian Rogers13735952014-10-08 12:43:28 -0700507 if (reinterpret_cast<const uint8_t*>(oat_data) < oat_file_.Begin() ||
508 reinterpret_cast<const uint8_t*>(oat_data) > oat_file_.End()) {
Ian Rogers3a5c1ce2012-02-29 10:06:46 -0800509 return 0; // Address not in oat file
510 }
Ian Rogersef7d42f2014-01-06 12:55:46 -0800511 uintptr_t begin_offset = reinterpret_cast<uintptr_t>(oat_data) -
512 reinterpret_cast<uintptr_t>(oat_file_.Begin());
513 auto it = offsets_.upper_bound(begin_offset);
Ian Rogers3a5c1ce2012-02-29 10:06:46 -0800514 CHECK(it != offsets_.end());
Ian Rogersef7d42f2014-01-06 12:55:46 -0800515 uintptr_t end_offset = *it;
Ian Rogers3a5c1ce2012-02-29 10:06:46 -0800516 return end_offset - begin_offset;
517 }
518
Mathieu Chartiera7dd0382014-11-20 17:08:58 -0800519 InstructionSet GetOatInstructionSet() {
Brian Carlstromf8bbb842012-03-14 03:01:42 -0700520 return oat_file_.GetOatHeader().GetInstructionSet();
521 }
522
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700523 const void* GetQuickOatCode(ArtMethod* m) REQUIRES_SHARED(Locks::mutator_lock_) {
Ian Rogers3a5c1ce2012-02-29 10:06:46 -0800524 for (size_t i = 0; i < oat_dex_files_.size(); i++) {
525 const OatFile::OatDexFile* oat_dex_file = oat_dex_files_[i];
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700526 CHECK(oat_dex_file != nullptr);
527 std::string error_msg;
Mathieu Chartierac8f4392015-08-27 13:54:20 -0700528 const DexFile* const dex_file = OpenDexFile(oat_dex_file, &error_msg);
529 if (dex_file == nullptr) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700530 LOG(WARNING) << "Failed to open dex file '" << oat_dex_file->GetDexFileLocation()
531 << "': " << error_msg;
532 } else {
Mathieu Chartiere7c9a8c2014-11-06 16:35:45 -0800533 const char* descriptor = m->GetDeclaringClassDescriptor();
Ian Rogers8b2c0b92013-09-19 02:56:49 -0700534 const DexFile::ClassDef* class_def =
David Sehr9aa352e2016-09-15 18:13:52 -0700535 OatDexFile::FindClassDef(*dex_file, descriptor, ComputeModifiedUtf8Hash(descriptor));
Andreas Gampe2ed8def2014-08-28 14:41:02 -0700536 if (class_def != nullptr) {
Ian Rogers8b2c0b92013-09-19 02:56:49 -0700537 uint16_t class_def_index = dex_file->GetIndexForClassDef(*class_def);
Vladimir Markod3c5beb2014-04-11 16:32:51 +0100538 const OatFile::OatClass oat_class = oat_dex_file->GetOatClass(class_def_index);
Ian Rogers3a5c1ce2012-02-29 10:06:46 -0800539 size_t method_index = m->GetMethodIndex();
Vladimir Markod3c5beb2014-04-11 16:32:51 +0100540 return oat_class.GetOatMethod(method_index).GetQuickCode();
Ian Rogers3a5c1ce2012-02-29 10:06:46 -0800541 }
542 }
543 }
Andreas Gampe2ed8def2014-08-28 14:41:02 -0700544 return nullptr;
Ian Rogers3a5c1ce2012-02-29 10:06:46 -0800545 }
546
Brian Carlstromaded5f72011-10-07 17:15:04 -0700547 private:
Ian Rogers3a5c1ce2012-02-29 10:06:46 -0800548 void AddAllOffsets() {
Elliott Hughese3c845c2012-02-28 17:23:01 -0800549 // We don't know the length of the code for each method, but we need to know where to stop
550 // when disassembling. What we do know is that a region of code will be followed by some other
551 // region, so if we keep a sorted sequence of the start of each region, we can infer the length
552 // of a piece of code by using upper_bound to find the start of the next region.
Ian Rogers3a5c1ce2012-02-29 10:06:46 -0800553 for (size_t i = 0; i < oat_dex_files_.size(); i++) {
554 const OatFile::OatDexFile* oat_dex_file = oat_dex_files_[i];
Andreas Gampe2ed8def2014-08-28 14:41:02 -0700555 CHECK(oat_dex_file != nullptr);
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700556 std::string error_msg;
Mathieu Chartierac8f4392015-08-27 13:54:20 -0700557 const DexFile* const dex_file = OpenDexFile(oat_dex_file, &error_msg);
558 if (dex_file == nullptr) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700559 LOG(WARNING) << "Failed to open dex file '" << oat_dex_file->GetDexFileLocation()
560 << "': " << error_msg;
Ian Rogers3a5c1ce2012-02-29 10:06:46 -0800561 continue;
Elliott Hughese3c845c2012-02-28 17:23:01 -0800562 }
Ian Rogersef7d42f2014-01-06 12:55:46 -0800563 offsets_.insert(reinterpret_cast<uintptr_t>(&dex_file->GetHeader()));
Brian Carlstrom2ec65202014-03-03 15:16:37 -0800564 for (size_t class_def_index = 0;
565 class_def_index < dex_file->NumClassDefs();
566 class_def_index++) {
Elliott Hughese3c845c2012-02-28 17:23:01 -0800567 const DexFile::ClassDef& class_def = dex_file->GetClassDef(class_def_index);
Vladimir Markod3c5beb2014-04-11 16:32:51 +0100568 const OatFile::OatClass oat_class = oat_dex_file->GetOatClass(class_def_index);
Ian Rogers13735952014-10-08 12:43:28 -0700569 const uint8_t* class_data = dex_file->GetClassData(class_def);
Andreas Gampe2ed8def2014-08-28 14:41:02 -0700570 if (class_data != nullptr) {
Elliott Hughese3c845c2012-02-28 17:23:01 -0800571 ClassDataItemIterator it(*dex_file, class_data);
572 SkipAllFields(it);
573 uint32_t class_method_index = 0;
574 while (it.HasNextDirectMethod()) {
Vladimir Markod3c5beb2014-04-11 16:32:51 +0100575 AddOffsets(oat_class.GetOatMethod(class_method_index++));
Elliott Hughese3c845c2012-02-28 17:23:01 -0800576 it.Next();
577 }
578 while (it.HasNextVirtualMethod()) {
Vladimir Markod3c5beb2014-04-11 16:32:51 +0100579 AddOffsets(oat_class.GetOatMethod(class_method_index++));
Elliott Hughese3c845c2012-02-28 17:23:01 -0800580 it.Next();
581 }
582 }
583 }
584 }
585
586 // If the last thing in the file is code for a method, there won't be an offset for the "next"
587 // thing. Instead of having a special case in the upper_bound code, let's just add an entry
588 // for the end of the file.
Ian Rogersef7d42f2014-01-06 12:55:46 -0800589 offsets_.insert(oat_file_.Size());
Elliott Hughese3c845c2012-02-28 17:23:01 -0800590 }
591
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700592 static uint32_t AlignCodeOffset(uint32_t maybe_thumb_offset) {
593 return maybe_thumb_offset & ~0x1; // TODO: Make this Thumb2 specific.
594 }
595
Elliott Hughese3c845c2012-02-28 17:23:01 -0800596 void AddOffsets(const OatFile::OatMethod& oat_method) {
Brian Carlstrom95ba0dc2012-03-05 22:06:14 -0800597 uint32_t code_offset = oat_method.GetCodeOffset();
598 if (oat_file_.GetOatHeader().GetInstructionSet() == kThumb2) {
599 code_offset &= ~0x1;
600 }
601 offsets_.insert(code_offset);
Elliott Hughese3c845c2012-02-28 17:23:01 -0800602 offsets_.insert(oat_method.GetVmapTableOffset());
Elliott Hughese3c845c2012-02-28 17:23:01 -0800603 }
604
Mathieu Chartierdc00f182016-07-14 10:10:44 -0700605 // Dex file data, may be for multiple different dex files.
606 class DexFileData {
607 public:
608 DexFileData() {}
609
610 explicit DexFileData(const DexFile& dex_file)
611 : num_string_ids_(dex_file.NumStringIds()),
612 num_method_ids_(dex_file.NumMethodIds()),
613 num_field_ids_(dex_file.NumFieldIds()),
614 num_type_ids_(dex_file.NumTypeIds()),
615 num_class_defs_(dex_file.NumClassDefs()) {
616 for (size_t class_def_index = 0; class_def_index < num_class_defs_; ++class_def_index) {
617 const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
618 WalkClass(dex_file, class_def);
619 }
620 }
621
622 void Add(const DexFileData& other) {
623 AddAll(unique_string_ids_from_code_, other.unique_string_ids_from_code_);
624 num_string_ids_from_code_ += other.num_string_ids_from_code_;
625 AddAll(dex_code_item_ptrs_, other.dex_code_item_ptrs_);
626 dex_code_bytes_ += other.dex_code_bytes_;
627 num_string_ids_ += other.num_string_ids_;
628 num_method_ids_ += other.num_method_ids_;
629 num_field_ids_ += other.num_field_ids_;
630 num_type_ids_ += other.num_type_ids_;
631 num_class_defs_ += other.num_class_defs_;
632 }
633
634 void Dump(std::ostream& os) {
635 os << "Num string ids: " << num_string_ids_ << "\n";
636 os << "Num method ids: " << num_method_ids_ << "\n";
637 os << "Num field ids: " << num_field_ids_ << "\n";
638 os << "Num type ids: " << num_type_ids_ << "\n";
639 os << "Num class defs: " << num_class_defs_ << "\n";
640 os << "Unique strings loaded from dex code: " << unique_string_ids_from_code_.size() << "\n";
641 os << "Total strings loaded from dex code: " << num_string_ids_from_code_ << "\n";
642 os << "Number of unique dex code items: " << dex_code_item_ptrs_.size() << "\n";
643 os << "Total number of dex code bytes: " << dex_code_bytes_ << "\n";
644 }
645
646 private:
647 void WalkClass(const DexFile& dex_file, const DexFile::ClassDef& class_def) {
648 const uint8_t* class_data = dex_file.GetClassData(class_def);
649 if (class_data == nullptr) { // empty class such as a marker interface?
650 return;
651 }
652 ClassDataItemIterator it(dex_file, class_data);
653 SkipAllFields(it);
654 while (it.HasNextDirectMethod()) {
655 WalkCodeItem(dex_file, it.GetMethodCodeItem());
656 it.Next();
657 }
658 while (it.HasNextVirtualMethod()) {
659 WalkCodeItem(dex_file, it.GetMethodCodeItem());
660 it.Next();
661 }
662 DCHECK(!it.HasNext());
663 }
664
665 void WalkCodeItem(const DexFile& dex_file, const DexFile::CodeItem* code_item) {
666 if (code_item == nullptr) {
667 return;
668 }
669 const size_t code_item_size = code_item->insns_size_in_code_units_;
670 const uint16_t* code_ptr = code_item->insns_;
671 const uint16_t* code_end = code_item->insns_ + code_item_size;
672
673 // If we inserted a new dex code item pointer, add to total code bytes.
674 if (dex_code_item_ptrs_.insert(code_ptr).second) {
675 dex_code_bytes_ += code_item_size * sizeof(code_ptr[0]);
676 }
677
678 while (code_ptr < code_end) {
679 const Instruction* inst = Instruction::At(code_ptr);
680 switch (inst->Opcode()) {
681 case Instruction::CONST_STRING: {
682 const uint32_t string_index = inst->VRegB_21c();
683 unique_string_ids_from_code_.insert(StringReference(&dex_file, string_index));
684 ++num_string_ids_from_code_;
685 break;
686 }
687 case Instruction::CONST_STRING_JUMBO: {
688 const uint32_t string_index = inst->VRegB_31c();
689 unique_string_ids_from_code_.insert(StringReference(&dex_file, string_index));
690 ++num_string_ids_from_code_;
691 break;
692 }
693 default:
694 break;
695 }
696
697 code_ptr += inst->SizeInCodeUnits();
698 }
699 }
700
701 // Unique string ids loaded from dex code.
702 std::set<StringReference, StringReferenceComparator> unique_string_ids_from_code_;
703
704 // Total string ids loaded from dex code.
705 size_t num_string_ids_from_code_ = 0;
706
707 // Unique code pointers.
708 std::set<const void*> dex_code_item_ptrs_;
709
710 // Total "unique" dex code bytes.
711 size_t dex_code_bytes_ = 0;
712
713 // Other dex ids.
714 size_t num_string_ids_ = 0;
715 size_t num_method_ids_ = 0;
716 size_t num_field_ids_ = 0;
717 size_t num_type_ids_ = 0;
718 size_t num_class_defs_ = 0;
719 };
720
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700721 bool DumpOatDexFile(std::ostream& os, const OatFile::OatDexFile& oat_dex_file) {
722 bool success = true;
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -0800723 bool stop_analysis = false;
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700724 os << "OatDexFile:\n";
Brian Carlstroma004aa92012-02-08 18:05:09 -0800725 os << StringPrintf("location: %s\n", oat_dex_file.GetDexFileLocation().c_str());
Elliott Hughesed2adb62012-02-29 14:41:01 -0800726 os << StringPrintf("checksum: 0x%08x\n", oat_dex_file.GetDexFileLocationChecksum());
Mathieu Chartier590fee92013-09-13 13:46:47 -0700727
Andreas Gampe2ba88952016-04-29 17:52:07 -0700728 const uint8_t* const oat_file_begin = oat_dex_file.GetOatFile()->Begin();
David Brazdil7b49e6c2016-09-01 11:06:18 +0100729 const uint8_t* const vdex_file_begin = oat_dex_file.GetOatFile()->DexBegin();
730
731 // Print data range of the dex file embedded inside the corresponding vdex file.
Andreas Gampe2ba88952016-04-29 17:52:07 -0700732 const uint8_t* const dex_file_pointer = oat_dex_file.GetDexFilePointer();
David Brazdil7b49e6c2016-09-01 11:06:18 +0100733 uint32_t dex_offset = dchecked_integral_cast<uint32_t>(dex_file_pointer - vdex_file_begin);
Andreas Gampe2ba88952016-04-29 17:52:07 -0700734 os << StringPrintf("dex-file: 0x%08x..0x%08x\n",
735 dex_offset,
736 dchecked_integral_cast<uint32_t>(dex_offset + oat_dex_file.FileSize() - 1));
Mathieu Chartier590fee92013-09-13 13:46:47 -0700737
Andreas Gampe2ba88952016-04-29 17:52:07 -0700738 // Create the dex file early. A lot of print-out things depend on it.
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700739 std::string error_msg;
Mathieu Chartierac8f4392015-08-27 13:54:20 -0700740 const DexFile* const dex_file = OpenDexFile(&oat_dex_file, &error_msg);
741 if (dex_file == nullptr) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700742 os << "NOT FOUND: " << error_msg << "\n\n";
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700743 os << std::flush;
744 return false;
Brian Carlstromaded5f72011-10-07 17:15:04 -0700745 }
Vladimir Marko8f1e08a2015-06-26 12:06:30 +0100746
Andreas Gampe2ba88952016-04-29 17:52:07 -0700747 // Print lookup table, if it exists.
748 if (oat_dex_file.GetLookupTableData() != nullptr) {
749 uint32_t table_offset = dchecked_integral_cast<uint32_t>(
750 oat_dex_file.GetLookupTableData() - oat_file_begin);
David Sehr9aa352e2016-09-15 18:13:52 -0700751 uint32_t table_size = TypeLookupTable::RawDataLength(dex_file->NumClassDefs());
Andreas Gampe2ba88952016-04-29 17:52:07 -0700752 os << StringPrintf("type-table: 0x%08x..0x%08x\n",
753 table_offset,
754 table_offset + table_size - 1);
755 }
756
Vladimir Marko8f1e08a2015-06-26 12:06:30 +0100757 VariableIndentationOutputStream vios(&os);
758 ScopedIndentation indent1(&vios);
Brian Carlstrom2ec65202014-03-03 15:16:37 -0800759 for (size_t class_def_index = 0;
760 class_def_index < dex_file->NumClassDefs();
761 class_def_index++) {
Brian Carlstromaded5f72011-10-07 17:15:04 -0700762 const DexFile::ClassDef& class_def = dex_file->GetClassDef(class_def_index);
763 const char* descriptor = dex_file->GetClassDescriptor(class_def);
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -0800764
765 // TODO: Support regex
766 if (DescriptorToDot(descriptor).find(options_.class_filter_) == std::string::npos) {
767 continue;
768 }
769
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700770 uint32_t oat_class_offset = oat_dex_file.GetOatClassOffset(class_def_index);
Vladimir Markod3c5beb2014-04-11 16:32:51 +0100771 const OatFile::OatClass oat_class = oat_dex_file.GetOatClass(class_def_index);
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700772 os << StringPrintf("%zd: %s (offset=0x%08x) (type_idx=%d)",
773 class_def_index, descriptor, oat_class_offset, class_def.class_idx_)
Vladimir Markod3c5beb2014-04-11 16:32:51 +0100774 << " (" << oat_class.GetStatus() << ")"
775 << " (" << oat_class.GetType() << ")\n";
776 // TODO: include bitmap here if type is kOatClassSomeCompiled?
Mathieu Chartierdc00f182016-07-14 10:10:44 -0700777 if (options_.list_classes_) {
778 continue;
779 }
780 if (!DumpOatClass(&vios, oat_class, *dex_file, class_def, &stop_analysis)) {
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700781 success = false;
782 }
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -0800783 if (stop_analysis) {
784 os << std::flush;
785 return success;
786 }
Brian Carlstromaded5f72011-10-07 17:15:04 -0700787 }
Mathieu Chartierdc00f182016-07-14 10:10:44 -0700788 os << "\n";
Brian Carlstromaded5f72011-10-07 17:15:04 -0700789 os << std::flush;
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700790 return success;
Brian Carlstromaded5f72011-10-07 17:15:04 -0700791 }
792
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -0800793 bool ExportDexFile(std::ostream& os, const OatFile::OatDexFile& oat_dex_file) {
794 std::string error_msg;
795 std::string dex_file_location = oat_dex_file.GetDexFileLocation();
796
Mathieu Chartierac8f4392015-08-27 13:54:20 -0700797 const DexFile* const dex_file = OpenDexFile(&oat_dex_file, &error_msg);
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -0800798 if (dex_file == nullptr) {
799 os << "Failed to open dex file '" << dex_file_location << "': " << error_msg;
800 return false;
801 }
802 size_t fsize = oat_dex_file.FileSize();
803
804 // Some quick checks just in case
805 if (fsize == 0 || fsize < sizeof(DexFile::Header)) {
806 os << "Invalid dex file\n";
807 return false;
808 }
809
810 // Verify output directory exists
811 if (!OS::DirectoryExists(options_.export_dex_location_)) {
812 // TODO: Extend OS::DirectoryExists if symlink support is required
813 os << options_.export_dex_location_ << " output directory not found or symlink\n";
814 return false;
815 }
816
817 // Beautify path names
818 if (dex_file_location.size() > PATH_MAX || dex_file_location.size() <= 0) {
819 return false;
820 }
821
822 std::string dex_orig_name;
823 size_t dex_orig_pos = dex_file_location.rfind('/');
824 if (dex_orig_pos == std::string::npos)
825 dex_orig_name = dex_file_location;
826 else
827 dex_orig_name = dex_file_location.substr(dex_orig_pos + 1);
828
829 // A more elegant approach to efficiently name user installed apps is welcome
830 if (dex_orig_name.size() == 8 && !dex_orig_name.compare("base.apk")) {
831 dex_file_location.erase(dex_orig_pos, strlen("base.apk") + 1);
832 size_t apk_orig_pos = dex_file_location.rfind('/');
833 if (apk_orig_pos != std::string::npos) {
834 dex_orig_name = dex_file_location.substr(++apk_orig_pos);
835 }
836 }
837
838 std::string out_dex_path(options_.export_dex_location_);
839 if (out_dex_path.back() != '/') {
840 out_dex_path.append("/");
841 }
842 out_dex_path.append(dex_orig_name);
843 out_dex_path.append("_export.dex");
844 if (out_dex_path.length() > PATH_MAX) {
845 return false;
846 }
847
848 std::unique_ptr<File> file(OS::CreateEmptyFile(out_dex_path.c_str()));
849 if (file.get() == nullptr) {
850 os << "Failed to open output dex file " << out_dex_path;
851 return false;
852 }
853
854 if (!file->WriteFully(dex_file->Begin(), fsize)) {
855 os << "Failed to write dex file";
856 file->Erase();
857 return false;
858 }
859
860 if (file->FlushCloseOrErase() != 0) {
861 os << "Flush and close failed";
862 return false;
863 }
864
865 os << StringPrintf("Dex file exported at %s (%zd bytes)\n", out_dex_path.c_str(), fsize);
866 os << std::flush;
867
868 return true;
869 }
870
Elliott Hughese3c845c2012-02-28 17:23:01 -0800871 static void SkipAllFields(ClassDataItemIterator& it) {
Ian Rogers0571d352011-11-03 19:51:38 -0700872 while (it.HasNextStaticField()) {
873 it.Next();
Brian Carlstromaded5f72011-10-07 17:15:04 -0700874 }
Ian Rogers0571d352011-11-03 19:51:38 -0700875 while (it.HasNextInstanceField()) {
876 it.Next();
Brian Carlstromaded5f72011-10-07 17:15:04 -0700877 }
Elliott Hughese3c845c2012-02-28 17:23:01 -0800878 }
Brian Carlstromaded5f72011-10-07 17:15:04 -0700879
Vladimir Marko8f1e08a2015-06-26 12:06:30 +0100880 bool DumpOatClass(VariableIndentationOutputStream* vios,
881 const OatFile::OatClass& oat_class, const DexFile& dex_file,
Mathieu Chartierdc00f182016-07-14 10:10:44 -0700882 const DexFile::ClassDef& class_def, bool* stop_analysis) {
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700883 bool success = true;
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -0800884 bool addr_found = false;
Ian Rogers13735952014-10-08 12:43:28 -0700885 const uint8_t* class_data = dex_file.GetClassData(class_def);
Andreas Gampe2ed8def2014-08-28 14:41:02 -0700886 if (class_data == nullptr) { // empty class such as a marker interface?
Vladimir Marko8f1e08a2015-06-26 12:06:30 +0100887 vios->Stream() << std::flush;
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700888 return success;
Elliott Hughese3c845c2012-02-28 17:23:01 -0800889 }
890 ClassDataItemIterator it(dex_file, class_data);
891 SkipAllFields(it);
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700892 uint32_t class_method_index = 0;
Ian Rogers0571d352011-11-03 19:51:38 -0700893 while (it.HasNextDirectMethod()) {
Vladimir Marko8f1e08a2015-06-26 12:06:30 +0100894 if (!DumpOatMethod(vios, class_def, class_method_index, oat_class, dex_file,
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700895 it.GetMemberIndex(), it.GetMethodCodeItem(),
Mathieu Chartierdc00f182016-07-14 10:10:44 -0700896 it.GetRawMemberAccessFlags(), &addr_found)) {
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700897 success = false;
898 }
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -0800899 if (addr_found) {
900 *stop_analysis = true;
901 return success;
902 }
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700903 class_method_index++;
Ian Rogers0571d352011-11-03 19:51:38 -0700904 it.Next();
Brian Carlstromaded5f72011-10-07 17:15:04 -0700905 }
Ian Rogers0571d352011-11-03 19:51:38 -0700906 while (it.HasNextVirtualMethod()) {
Vladimir Marko8f1e08a2015-06-26 12:06:30 +0100907 if (!DumpOatMethod(vios, class_def, class_method_index, oat_class, dex_file,
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700908 it.GetMemberIndex(), it.GetMethodCodeItem(),
Mathieu Chartierdc00f182016-07-14 10:10:44 -0700909 it.GetRawMemberAccessFlags(), &addr_found)) {
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700910 success = false;
911 }
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -0800912 if (addr_found) {
913 *stop_analysis = true;
914 return success;
915 }
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700916 class_method_index++;
Ian Rogers0571d352011-11-03 19:51:38 -0700917 it.Next();
Brian Carlstromaded5f72011-10-07 17:15:04 -0700918 }
Ian Rogers0571d352011-11-03 19:51:38 -0700919 DCHECK(!it.HasNext());
Vladimir Marko8f1e08a2015-06-26 12:06:30 +0100920 vios->Stream() << std::flush;
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700921 return success;
Brian Carlstromaded5f72011-10-07 17:15:04 -0700922 }
Elliott Hughese3c845c2012-02-28 17:23:01 -0800923
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700924 static constexpr uint32_t kPrologueBytes = 16;
925
926 // When this was picked, the largest arm method was 55,256 bytes and arm64 was 50,412 bytes.
927 static constexpr uint32_t kMaxCodeSize = 100 * 1000;
928
Vladimir Marko8f1e08a2015-06-26 12:06:30 +0100929 bool DumpOatMethod(VariableIndentationOutputStream* vios,
930 const DexFile::ClassDef& class_def,
Ian Rogers8b2c0b92013-09-19 02:56:49 -0700931 uint32_t class_method_index,
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700932 const OatFile::OatClass& oat_class, const DexFile& dex_file,
Ian Rogers2bcb4a42012-11-08 10:39:18 -0800933 uint32_t dex_method_idx, const DexFile::CodeItem* code_item,
Mathieu Chartierdc00f182016-07-14 10:10:44 -0700934 uint32_t method_access_flags, bool* addr_found) {
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700935 bool success = true;
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -0800936
937 // TODO: Support regex
938 std::string method_name = dex_file.GetMethodName(dex_file.GetMethodId(dex_method_idx));
939 if (method_name.find(options_.method_filter_) == std::string::npos) {
Nicolas Geoffray3fcd2202014-11-12 18:02:36 +0000940 return success;
941 }
942
David Sehr709b0702016-10-13 09:12:37 -0700943 std::string pretty_method = dex_file.PrettyMethod(dex_method_idx, true);
Vladimir Marko8f1e08a2015-06-26 12:06:30 +0100944 vios->Stream() << StringPrintf("%d: %s (dex_method_idx=%d)\n",
945 class_method_index, pretty_method.c_str(),
946 dex_method_idx);
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -0800947 if (options_.list_methods_) return success;
948
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -0800949 uint32_t oat_method_offsets_offset = oat_class.GetOatMethodOffsetsOffset(class_method_index);
950 const OatMethodOffsets* oat_method_offsets = oat_class.GetOatMethodOffsets(class_method_index);
951 const OatFile::OatMethod oat_method = oat_class.GetOatMethod(class_method_index);
952 uint32_t code_offset = oat_method.GetCodeOffset();
953 uint32_t code_size = oat_method.GetQuickCodeSize();
954 if (resolved_addr2instr_ != 0) {
955 if (resolved_addr2instr_ > code_offset + code_size) {
956 return success;
957 } else {
958 *addr_found = true; // stop analyzing file at next iteration
959 }
960 }
961
Vladimir Marko8f1e08a2015-06-26 12:06:30 +0100962 // Everything below is indented at least once.
963 ScopedIndentation indent1(vios);
964
Ian Rogers2bcb4a42012-11-08 10:39:18 -0800965 {
Vladimir Marko8f1e08a2015-06-26 12:06:30 +0100966 vios->Stream() << "DEX CODE:\n";
967 ScopedIndentation indent2(vios);
968 DumpDexCode(vios->Stream(), dex_file, code_item);
Ian Rogersb23a7722012-10-09 16:54:26 -0700969 }
Andreas Gampe2ed8def2014-08-28 14:41:02 -0700970
Mathieu Chartier673ed3d2015-08-28 14:56:43 -0700971 std::unique_ptr<StackHandleScope<1>> hs;
Andreas Gampe2ed8def2014-08-28 14:41:02 -0700972 std::unique_ptr<verifier::MethodVerifier> verifier;
973 if (Runtime::Current() != nullptr) {
Mathieu Chartier673ed3d2015-08-28 14:56:43 -0700974 // We need to have the handle scope stay live until after the verifier since the verifier has
975 // a handle to the dex cache from hs.
976 hs.reset(new StackHandleScope<1>(Thread::Current()));
Vladimir Marko8f1e08a2015-06-26 12:06:30 +0100977 vios->Stream() << "VERIFIER TYPE ANALYSIS:\n";
978 ScopedIndentation indent2(vios);
Mathieu Chartier673ed3d2015-08-28 14:56:43 -0700979 verifier.reset(DumpVerifier(vios, hs.get(),
Vladimir Marko8f1e08a2015-06-26 12:06:30 +0100980 dex_method_idx, &dex_file, class_def, code_item,
Andreas Gampe2ed8def2014-08-28 14:41:02 -0700981 method_access_flags));
Ian Rogersb23a7722012-10-09 16:54:26 -0700982 }
Ian Rogers2bcb4a42012-11-08 10:39:18 -0800983 {
Vladimir Marko8f1e08a2015-06-26 12:06:30 +0100984 vios->Stream() << "OatMethodOffsets ";
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -0800985 if (options_.absolute_addresses_) {
Vladimir Marko8f1e08a2015-06-26 12:06:30 +0100986 vios->Stream() << StringPrintf("%p ", oat_method_offsets);
Nicolas Geoffray39468442014-09-02 15:17:15 +0100987 }
Vladimir Marko8f1e08a2015-06-26 12:06:30 +0100988 vios->Stream() << StringPrintf("(offset=0x%08x)\n", oat_method_offsets_offset);
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700989 if (oat_method_offsets_offset > oat_file_.Size()) {
Vladimir Marko8f1e08a2015-06-26 12:06:30 +0100990 vios->Stream() << StringPrintf(
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700991 "WARNING: oat method offsets offset 0x%08x is past end of file 0x%08zx.\n",
992 oat_method_offsets_offset, oat_file_.Size());
993 // If we can't read OatMethodOffsets, the rest of the data is dangerous to read.
Vladimir Marko8f1e08a2015-06-26 12:06:30 +0100994 vios->Stream() << std::flush;
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700995 return false;
Ian Rogers2bcb4a42012-11-08 10:39:18 -0800996 }
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700997
Vladimir Marko8f1e08a2015-06-26 12:06:30 +0100998 ScopedIndentation indent2(vios);
999 vios->Stream() << StringPrintf("code_offset: 0x%08x ", code_offset);
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001000 uint32_t aligned_code_begin = AlignCodeOffset(oat_method.GetCodeOffset());
1001 if (aligned_code_begin > oat_file_.Size()) {
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001002 vios->Stream() << StringPrintf("WARNING: "
1003 "code offset 0x%08x is past end of file 0x%08zx.\n",
1004 aligned_code_begin, oat_file_.Size());
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001005 success = false;
1006 }
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001007 vios->Stream() << "\n";
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001008 }
1009 {
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001010 vios->Stream() << "OatQuickMethodHeader ";
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001011 uint32_t method_header_offset = oat_method.GetOatQuickMethodHeaderOffset();
1012 const OatQuickMethodHeader* method_header = oat_method.GetOatQuickMethodHeader();
Mathieu Chartier590fee92013-09-13 13:46:47 -07001013
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -08001014 if (options_.absolute_addresses_) {
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001015 vios->Stream() << StringPrintf("%p ", method_header);
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001016 }
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001017 vios->Stream() << StringPrintf("(offset=0x%08x)\n", method_header_offset);
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001018 if (method_header_offset > oat_file_.Size()) {
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001019 vios->Stream() << StringPrintf(
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001020 "WARNING: oat quick method header offset 0x%08x is past end of file 0x%08zx.\n",
1021 method_header_offset, oat_file_.Size());
1022 // If we can't read the OatQuickMethodHeader, the rest of the data is dangerous to read.
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001023 vios->Stream() << std::flush;
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001024 return false;
1025 }
1026
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001027 ScopedIndentation indent2(vios);
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001028 vios->Stream() << "vmap_table: ";
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -08001029 if (options_.absolute_addresses_) {
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001030 vios->Stream() << StringPrintf("%p ", oat_method.GetVmapTable());
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001031 }
1032 uint32_t vmap_table_offset = oat_method.GetVmapTableOffset();
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001033 vios->Stream() << StringPrintf("(offset=0x%08x)\n", vmap_table_offset);
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001034 if (vmap_table_offset > oat_file_.Size()) {
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001035 vios->Stream() << StringPrintf("WARNING: "
1036 "vmap table offset 0x%08x is past end of file 0x%08zx. "
1037 "vmap table offset was loaded from offset 0x%08x.\n",
1038 vmap_table_offset, oat_file_.Size(),
1039 oat_method.GetVmapTableOffsetOffset());
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001040 success = false;
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -08001041 } else if (options_.dump_vmap_) {
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001042 DumpVmapData(vios, oat_method, code_item);
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001043 }
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001044 }
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001045 {
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001046 vios->Stream() << "QuickMethodFrameInfo\n";
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001047
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001048 ScopedIndentation indent2(vios);
1049 vios->Stream()
1050 << StringPrintf("frame_size_in_bytes: %zd\n", oat_method.GetFrameSizeInBytes());
1051 vios->Stream() << StringPrintf("core_spill_mask: 0x%08x ", oat_method.GetCoreSpillMask());
1052 DumpSpillMask(vios->Stream(), oat_method.GetCoreSpillMask(), false);
1053 vios->Stream() << "\n";
1054 vios->Stream() << StringPrintf("fp_spill_mask: 0x%08x ", oat_method.GetFpSpillMask());
1055 DumpSpillMask(vios->Stream(), oat_method.GetFpSpillMask(), true);
1056 vios->Stream() << "\n";
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001057 }
1058 {
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001059 // Based on spill masks from QuickMethodFrameInfo so placed
1060 // after it is dumped, but useful for understanding quick
1061 // code, so dumped here.
1062 ScopedIndentation indent2(vios);
1063 DumpVregLocations(vios->Stream(), oat_method, code_item);
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001064 }
1065 {
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001066 vios->Stream() << "CODE: ";
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001067 uint32_t code_size_offset = oat_method.GetQuickCodeSizeOffset();
1068 if (code_size_offset > oat_file_.Size()) {
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001069 ScopedIndentation indent2(vios);
1070 vios->Stream() << StringPrintf("WARNING: "
1071 "code size offset 0x%08x is past end of file 0x%08zx.",
1072 code_size_offset, oat_file_.Size());
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001073 success = false;
1074 } else {
1075 const void* code = oat_method.GetQuickCode();
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001076 uint32_t aligned_code_begin = AlignCodeOffset(code_offset);
1077 uint64_t aligned_code_end = aligned_code_begin + code_size;
1078
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -08001079 if (options_.absolute_addresses_) {
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001080 vios->Stream() << StringPrintf("%p ", code);
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001081 }
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001082 vios->Stream() << StringPrintf("(code_offset=0x%08x size_offset=0x%08x size=%u)%s\n",
1083 code_offset,
1084 code_size_offset,
1085 code_size,
1086 code != nullptr ? "..." : "");
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001087
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001088 ScopedIndentation indent2(vios);
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001089 if (aligned_code_begin > oat_file_.Size()) {
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001090 vios->Stream() << StringPrintf("WARNING: "
1091 "start of code at 0x%08x is past end of file 0x%08zx.",
1092 aligned_code_begin, oat_file_.Size());
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001093 success = false;
1094 } else if (aligned_code_end > oat_file_.Size()) {
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001095 vios->Stream() << StringPrintf(
1096 "WARNING: "
1097 "end of code at 0x%08" PRIx64 " is past end of file 0x%08zx. "
1098 "code size is 0x%08x loaded from offset 0x%08x.\n",
1099 aligned_code_end, oat_file_.Size(),
1100 code_size, code_size_offset);
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001101 success = false;
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -08001102 if (options_.disassemble_code_) {
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001103 if (code_size_offset + kPrologueBytes <= oat_file_.Size()) {
Vladimir Marko9d07e3d2016-03-31 12:02:28 +01001104 DumpCode(vios, oat_method, code_item, true, kPrologueBytes);
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001105 }
1106 }
1107 } else if (code_size > kMaxCodeSize) {
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001108 vios->Stream() << StringPrintf(
1109 "WARNING: "
1110 "code size %d is bigger than max expected threshold of %d. "
1111 "code size is 0x%08x loaded from offset 0x%08x.\n",
1112 code_size, kMaxCodeSize,
1113 code_size, code_size_offset);
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001114 success = false;
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -08001115 if (options_.disassemble_code_) {
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001116 if (code_size_offset + kPrologueBytes <= oat_file_.Size()) {
Vladimir Marko9d07e3d2016-03-31 12:02:28 +01001117 DumpCode(vios, oat_method, code_item, true, kPrologueBytes);
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001118 }
1119 }
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -08001120 } else if (options_.disassemble_code_) {
Vladimir Marko9d07e3d2016-03-31 12:02:28 +01001121 DumpCode(vios, oat_method, code_item, !success, 0);
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001122 }
1123 }
1124 }
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001125 vios->Stream() << std::flush;
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001126 return success;
Brian Carlstromaded5f72011-10-07 17:15:04 -07001127 }
Elliott Hughese3c845c2012-02-28 17:23:01 -08001128
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001129 void DumpSpillMask(std::ostream& os, uint32_t spill_mask, bool is_float) {
1130 if (spill_mask == 0) {
1131 return;
1132 }
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001133 os << "(";
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001134 for (size_t i = 0; i < 32; i++) {
1135 if ((spill_mask & (1 << i)) != 0) {
1136 if (is_float) {
1137 os << "fr" << i;
1138 } else {
1139 os << "r" << i;
1140 }
1141 spill_mask ^= 1 << i; // clear bit
1142 if (spill_mask != 0) {
1143 os << ", ";
1144 } else {
1145 break;
1146 }
1147 }
1148 }
1149 os << ")";
1150 }
1151
Roland Levillain442b46a2015-02-18 16:54:21 +00001152 // Display data stored at the the vmap offset of an oat method.
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001153 void DumpVmapData(VariableIndentationOutputStream* vios,
Roland Levillain442b46a2015-02-18 16:54:21 +00001154 const OatFile::OatMethod& oat_method,
1155 const DexFile::CodeItem* code_item) {
Roland Levillainf2650d12015-05-28 14:53:28 +01001156 if (IsMethodGeneratedByOptimizingCompiler(oat_method, code_item)) {
1157 // The optimizing compiler outputs its CodeInfo data in the vmap table.
Roland Levillain442b46a2015-02-18 16:54:21 +00001158 const void* raw_code_info = oat_method.GetVmapTable();
1159 if (raw_code_info != nullptr) {
1160 CodeInfo code_info(raw_code_info);
1161 DCHECK(code_item != nullptr);
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001162 ScopedIndentation indent1(vios);
1163 DumpCodeInfo(vios, code_info, oat_method, *code_item);
Roland Levillain442b46a2015-02-18 16:54:21 +00001164 }
Nicolas Geoffray0a5cd122015-07-16 14:15:05 +01001165 } else if (IsMethodGeneratedByDexToDexCompiler(oat_method, code_item)) {
1166 // We don't encode the size in the table, so just emit that we have quickened
1167 // information.
1168 ScopedIndentation indent(vios);
1169 vios->Stream() << "quickened data\n";
Roland Levillain442b46a2015-02-18 16:54:21 +00001170 } else {
Vladimir Marko9d07e3d2016-03-31 12:02:28 +01001171 // Otherwise, there is nothing to display.
Nicolas Geoffray20d3eae2014-09-17 11:27:23 +01001172 }
Roland Levillain442b46a2015-02-18 16:54:21 +00001173 }
1174
1175 // Display a CodeInfo object emitted by the optimizing compiler.
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001176 void DumpCodeInfo(VariableIndentationOutputStream* vios,
Roland Levillain442b46a2015-02-18 16:54:21 +00001177 const CodeInfo& code_info,
Roland Levillainf2650d12015-05-28 14:53:28 +01001178 const OatFile::OatMethod& oat_method,
Roland Levillain442b46a2015-02-18 16:54:21 +00001179 const DexFile::CodeItem& code_item) {
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001180 code_info.Dump(vios,
Roland Levillainf2650d12015-05-28 14:53:28 +01001181 oat_method.GetCodeOffset(),
1182 code_item.registers_size_,
1183 options_.dump_code_info_stack_maps_);
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001184 }
1185
Razvan A Lupusorufaf9f0d2014-08-29 17:56:46 -07001186 void DumpVregLocations(std::ostream& os, const OatFile::OatMethod& oat_method,
1187 const DexFile::CodeItem* code_item) {
1188 if (code_item != nullptr) {
1189 size_t num_locals_ins = code_item->registers_size_;
1190 size_t num_ins = code_item->ins_size_;
1191 size_t num_locals = num_locals_ins - num_ins;
1192 size_t num_outs = code_item->outs_size_;
1193
1194 os << "vr_stack_locations:";
1195 for (size_t reg = 0; reg <= num_locals_ins; reg++) {
1196 // For readability, delimit the different kinds of VRs.
1197 if (reg == num_locals_ins) {
1198 os << "\n\tmethod*:";
1199 } else if (reg == num_locals && num_ins > 0) {
1200 os << "\n\tins:";
1201 } else if (reg == 0 && num_locals > 0) {
1202 os << "\n\tlocals:";
1203 }
1204
Nicolas Geoffray15b9d522015-03-12 15:05:13 +00001205 uint32_t offset = StackVisitor::GetVRegOffsetFromQuickCode(
1206 code_item,
1207 oat_method.GetCoreSpillMask(),
1208 oat_method.GetFpSpillMask(),
1209 oat_method.GetFrameSizeInBytes(),
1210 reg,
1211 GetInstructionSet());
Razvan A Lupusorufaf9f0d2014-08-29 17:56:46 -07001212 os << " v" << reg << "[sp + #" << offset << "]";
1213 }
1214
1215 for (size_t out_reg = 0; out_reg < num_outs; out_reg++) {
1216 if (out_reg == 0) {
1217 os << "\n\touts:";
1218 }
1219
1220 uint32_t offset = StackVisitor::GetOutVROffset(out_reg, GetInstructionSet());
1221 os << " v" << out_reg << "[sp + #" << offset << "]";
1222 }
1223
1224 os << "\n";
1225 }
1226 }
1227
Ian Rogersb23a7722012-10-09 16:54:26 -07001228 void DumpDexCode(std::ostream& os, const DexFile& dex_file, const DexFile::CodeItem* code_item) {
Andreas Gampe2ed8def2014-08-28 14:41:02 -07001229 if (code_item != nullptr) {
Ian Rogersb23a7722012-10-09 16:54:26 -07001230 size_t i = 0;
1231 while (i < code_item->insns_size_in_code_units_) {
1232 const Instruction* instruction = Instruction::At(&code_item->insns_[i]);
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -08001233 os << StringPrintf("0x%04zx: ", i) << instruction->DumpHexLE(5)
1234 << StringPrintf("\t| %s\n", instruction->DumpString(&dex_file).c_str());
Ian Rogersb23a7722012-10-09 16:54:26 -07001235 i += instruction->SizeInCodeUnits();
1236 }
1237 }
1238 }
1239
Roland Levillainf2650d12015-05-28 14:53:28 +01001240 // Has `oat_method` -- corresponding to the Dex `code_item` -- been compiled by
1241 // the optimizing compiler?
1242 static bool IsMethodGeneratedByOptimizingCompiler(const OatFile::OatMethod& oat_method,
1243 const DexFile::CodeItem* code_item) {
1244 // If the native GC map is null and the Dex `code_item` is not
1245 // null, then this method has been compiled with the optimizing
1246 // compiler.
Nicolas Geoffray0a5cd122015-07-16 14:15:05 +01001247 return oat_method.GetQuickCode() != nullptr &&
Vladimir Marko9d07e3d2016-03-31 12:02:28 +01001248 oat_method.GetVmapTable() != nullptr &&
Nicolas Geoffray0a5cd122015-07-16 14:15:05 +01001249 code_item != nullptr;
1250 }
1251
1252 // Has `oat_method` -- corresponding to the Dex `code_item` -- been compiled by
1253 // the dextodex compiler?
1254 static bool IsMethodGeneratedByDexToDexCompiler(const OatFile::OatMethod& oat_method,
1255 const DexFile::CodeItem* code_item) {
1256 // If the quick code is null, the Dex `code_item` is not
1257 // null, and the vmap table is not null, then this method has been compiled
1258 // with the dextodex compiler.
1259 return oat_method.GetQuickCode() == nullptr &&
1260 oat_method.GetVmapTable() != nullptr &&
1261 code_item != nullptr;
Roland Levillainf2650d12015-05-28 14:53:28 +01001262 }
1263
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001264 verifier::MethodVerifier* DumpVerifier(VariableIndentationOutputStream* vios,
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07001265 StackHandleScope<1>* hs,
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001266 uint32_t dex_method_idx,
Andreas Gampe2ed8def2014-08-28 14:41:02 -07001267 const DexFile* dex_file,
1268 const DexFile::ClassDef& class_def,
1269 const DexFile::CodeItem* code_item,
1270 uint32_t method_access_flags) {
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001271 if ((method_access_flags & kAccNative) == 0) {
1272 ScopedObjectAccess soa(Thread::Current());
Mathieu Chartierd57d4542015-10-14 10:55:30 -07001273 Runtime* const runtime = Runtime::Current();
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07001274 Handle<mirror::DexCache> dex_cache(
Mathieu Chartierf284d442016-06-02 11:48:30 -07001275 hs->NewHandle(runtime->GetClassLinker()->RegisterDexFile(*dex_file, nullptr)));
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -08001276 DCHECK(options_.class_loader_ != nullptr);
Mathieu Chartiere401d142015-04-22 13:56:20 -07001277 return verifier::MethodVerifier::VerifyMethodAndDump(
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001278 soa.Self(), vios, dex_method_idx, dex_file, dex_cache, *options_.class_loader_,
David Brazdil15fc7292016-09-02 14:13:18 +01001279 class_def, code_item, nullptr, method_access_flags);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001280 }
Andreas Gampe2ed8def2014-08-28 14:41:02 -07001281
1282 return nullptr;
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001283 }
1284
Vladimir Markoadbf93e2016-04-08 11:18:25 +01001285 // The StackMapsHelper provides the stack maps in the native PC order.
1286 // For identical native PCs, the order from the CodeInfo is preserved.
1287 class StackMapsHelper {
1288 public:
1289 explicit StackMapsHelper(const uint8_t* raw_code_info)
1290 : code_info_(raw_code_info),
1291 encoding_(code_info_.ExtractEncoding()),
1292 number_of_stack_maps_(code_info_.GetNumberOfStackMaps(encoding_)),
1293 indexes_(),
1294 offset_(static_cast<size_t>(-1)),
1295 stack_map_index_(0u) {
1296 if (number_of_stack_maps_ != 0u) {
1297 // Check if native PCs are ordered.
1298 bool ordered = true;
1299 StackMap last = code_info_.GetStackMapAt(0u, encoding_);
1300 for (size_t i = 1; i != number_of_stack_maps_; ++i) {
1301 StackMap current = code_info_.GetStackMapAt(i, encoding_);
1302 if (last.GetNativePcOffset(encoding_.stack_map_encoding) >
1303 current.GetNativePcOffset(encoding_.stack_map_encoding)) {
1304 ordered = false;
1305 break;
1306 }
1307 last = current;
1308 }
1309 if (!ordered) {
1310 // Create indirection indexes for access in native PC order. We do not optimize
1311 // for the fact that there can currently be only two separately ordered ranges,
1312 // namely normal stack maps and catch-point stack maps.
1313 indexes_.resize(number_of_stack_maps_);
1314 std::iota(indexes_.begin(), indexes_.end(), 0u);
1315 std::sort(indexes_.begin(),
1316 indexes_.end(),
1317 [this](size_t lhs, size_t rhs) {
1318 StackMap left = code_info_.GetStackMapAt(lhs, encoding_);
1319 uint32_t left_pc = left.GetNativePcOffset(encoding_.stack_map_encoding);
1320 StackMap right = code_info_.GetStackMapAt(rhs, encoding_);
1321 uint32_t right_pc = right.GetNativePcOffset(encoding_.stack_map_encoding);
1322 // If the PCs are the same, compare indexes to preserve the original order.
1323 return (left_pc < right_pc) || (left_pc == right_pc && lhs < rhs);
1324 });
1325 }
1326 offset_ = GetStackMapAt(0).GetNativePcOffset(encoding_.stack_map_encoding);
1327 }
1328 }
1329
1330 const CodeInfo& GetCodeInfo() const {
1331 return code_info_;
1332 }
1333
1334 const CodeInfoEncoding& GetEncoding() const {
1335 return encoding_;
1336 }
1337
1338 size_t GetOffset() const {
1339 return offset_;
1340 }
1341
1342 StackMap GetStackMap() const {
1343 return GetStackMapAt(stack_map_index_);
1344 }
1345
1346 void Next() {
1347 ++stack_map_index_;
1348 offset_ = (stack_map_index_ == number_of_stack_maps_)
1349 ? static_cast<size_t>(-1)
1350 : GetStackMapAt(stack_map_index_).GetNativePcOffset(encoding_.stack_map_encoding);
1351 }
1352
1353 private:
1354 StackMap GetStackMapAt(size_t i) const {
1355 if (!indexes_.empty()) {
1356 i = indexes_[i];
1357 }
1358 DCHECK_LT(i, number_of_stack_maps_);
1359 return code_info_.GetStackMapAt(i, encoding_);
1360 }
1361
1362 const CodeInfo code_info_;
1363 const CodeInfoEncoding encoding_;
1364 const size_t number_of_stack_maps_;
1365 dchecked_vector<size_t> indexes_; // Used if stack map native PCs are not ordered.
1366 size_t offset_;
1367 size_t stack_map_index_;
1368 };
1369
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001370 void DumpCode(VariableIndentationOutputStream* vios,
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001371 const OatFile::OatMethod& oat_method, const DexFile::CodeItem* code_item,
1372 bool bad_input, size_t code_size) {
Ian Rogersef7d42f2014-01-06 12:55:46 -08001373 const void* quick_code = oat_method.GetQuickCode();
1374
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001375 if (code_size == 0) {
1376 code_size = oat_method.GetQuickCodeSize();
1377 }
Elliott Hughes956af0f2014-12-11 14:34:28 -08001378 if (code_size == 0 || quick_code == nullptr) {
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001379 vios->Stream() << "NO CODE!\n";
Ian Rogersb23a7722012-10-09 16:54:26 -07001380 return;
Vladimir Markoadbf93e2016-04-08 11:18:25 +01001381 } else if (!bad_input && IsMethodGeneratedByOptimizingCompiler(oat_method, code_item)) {
1382 // The optimizing compiler outputs its CodeInfo data in the vmap table.
1383 StackMapsHelper helper(oat_method.GetVmapTable());
1384 const uint8_t* quick_native_pc = reinterpret_cast<const uint8_t*>(quick_code);
1385 size_t offset = 0;
1386 while (offset < code_size) {
1387 offset += disassembler_->Dump(vios->Stream(), quick_native_pc + offset);
1388 if (offset == helper.GetOffset()) {
1389 ScopedIndentation indent1(vios);
1390 StackMap stack_map = helper.GetStackMap();
1391 DCHECK(stack_map.IsValid());
1392 stack_map.Dump(vios,
1393 helper.GetCodeInfo(),
1394 helper.GetEncoding(),
1395 oat_method.GetCodeOffset(),
1396 code_item->registers_size_);
1397 do {
1398 helper.Next();
1399 // There may be multiple stack maps at a given PC. We display only the first one.
1400 } while (offset == helper.GetOffset());
1401 }
1402 DCHECK_LT(offset, helper.GetOffset());
1403 }
Elliott Hughes956af0f2014-12-11 14:34:28 -08001404 } else {
Ian Rogersef7d42f2014-01-06 12:55:46 -08001405 const uint8_t* quick_native_pc = reinterpret_cast<const uint8_t*>(quick_code);
1406 size_t offset = 0;
1407 while (offset < code_size) {
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001408 offset += disassembler_->Dump(vios->Stream(), quick_native_pc + offset);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001409 }
Ian Rogersb23a7722012-10-09 16:54:26 -07001410 }
1411 }
1412
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001413 const OatFile& oat_file_;
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001414 const std::vector<const OatFile::OatDexFile*> oat_dex_files_;
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -08001415 const OatDumperOptions& options_;
1416 uint32_t resolved_addr2instr_;
Andreas Gampe372f3a32016-08-19 10:49:06 -07001417 const InstructionSet instruction_set_;
Ian Rogersef7d42f2014-01-06 12:55:46 -08001418 std::set<uintptr_t> offsets_;
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001419 Disassembler* disassembler_;
Brian Carlstromaded5f72011-10-07 17:15:04 -07001420};
1421
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001422class ImageDumper {
Brian Carlstrom27ec9612011-09-19 20:20:38 -07001423 public:
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -08001424 ImageDumper(std::ostream* os,
1425 gc::space::ImageSpace& image_space,
1426 const ImageHeader& image_header,
1427 OatDumperOptions* oat_dumper_options)
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001428 : os_(os),
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001429 vios_(os),
1430 indent1_(&vios_),
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001431 image_space_(image_space),
1432 image_header_(image_header),
1433 oat_dumper_options_(oat_dumper_options) {}
Brian Carlstrom27ec9612011-09-19 20:20:38 -07001434
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001435 bool Dump() REQUIRES_SHARED(Locks::mutator_lock_) {
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001436 std::ostream& os = *os_;
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001437 std::ostream& indent_os = vios_.Stream();
1438
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001439 os << "MAGIC: " << image_header_.GetMagic() << "\n\n";
Brian Carlstrome24fa612011-09-29 00:53:55 -07001440
Jeff Haodcdc85b2015-12-04 14:06:18 -08001441 os << "IMAGE LOCATION: " << image_space_.GetImageLocation() << "\n\n";
1442
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001443 os << "IMAGE BEGIN: " << reinterpret_cast<void*>(image_header_.GetImageBegin()) << "\n\n";
Brian Carlstromaded5f72011-10-07 17:15:04 -07001444
Mathieu Chartiere401d142015-04-22 13:56:20 -07001445 os << "IMAGE SIZE: " << image_header_.GetImageSize() << "\n\n";
1446
1447 for (size_t i = 0; i < ImageHeader::kSectionCount; ++i) {
1448 auto section = static_cast<ImageHeader::ImageSections>(i);
1449 os << "IMAGE SECTION " << section << ": " << image_header_.GetImageSection(section) << "\n\n";
1450 }
Mathieu Chartier31e89252013-08-28 11:29:12 -07001451
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001452 os << "OAT CHECKSUM: " << StringPrintf("0x%08x\n\n", image_header_.GetOatChecksum());
Brian Carlstrom916e74e2011-09-23 11:42:01 -07001453
Brian Carlstrom700c8d32012-11-05 10:42:02 -08001454 os << "OAT FILE BEGIN:" << reinterpret_cast<void*>(image_header_.GetOatFileBegin()) << "\n\n";
Brian Carlstromaded5f72011-10-07 17:15:04 -07001455
Brian Carlstrom700c8d32012-11-05 10:42:02 -08001456 os << "OAT DATA BEGIN:" << reinterpret_cast<void*>(image_header_.GetOatDataBegin()) << "\n\n";
1457
1458 os << "OAT DATA END:" << reinterpret_cast<void*>(image_header_.GetOatDataEnd()) << "\n\n";
1459
1460 os << "OAT FILE END:" << reinterpret_cast<void*>(image_header_.GetOatFileEnd()) << "\n\n";
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001461
Alex Lighta59dd802014-07-02 16:28:08 -07001462 os << "PATCH DELTA:" << image_header_.GetPatchDelta() << "\n\n";
1463
Igor Murashkin46774762014-10-22 11:37:02 -07001464 os << "COMPILE PIC: " << (image_header_.CompilePic() ? "yes" : "no") << "\n\n";
1465
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001466 {
1467 os << "ROOTS: " << reinterpret_cast<void*>(image_header_.GetImageRoots()) << "\n";
Mathieu Chartiere401d142015-04-22 13:56:20 -07001468 static_assert(arraysize(image_roots_descriptions_) ==
1469 static_cast<size_t>(ImageHeader::kImageRootsMax), "sizes must match");
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001470 for (int i = 0; i < ImageHeader::kImageRootsMax; i++) {
1471 ImageHeader::ImageRoot image_root = static_cast<ImageHeader::ImageRoot>(i);
1472 const char* image_root_description = image_roots_descriptions_[i];
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001473 mirror::Object* image_root_object = image_header_.GetImageRoot(image_root);
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001474 indent_os << StringPrintf("%s: %p\n", image_root_description, image_root_object);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001475 if (image_root_object->IsObjectArray()) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001476 mirror::ObjectArray<mirror::Object>* image_root_object_array
Ian Rogersfa824272013-11-05 16:12:57 -08001477 = image_root_object->AsObjectArray<mirror::Object>();
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001478 ScopedIndentation indent2(&vios_);
Andreas Gampe277ccbd2014-11-03 21:36:10 -08001479 for (int j = 0; j < image_root_object_array->GetLength(); j++) {
1480 mirror::Object* value = image_root_object_array->Get(j);
Ian Rogersfa824272013-11-05 16:12:57 -08001481 size_t run = 0;
Andreas Gampe277ccbd2014-11-03 21:36:10 -08001482 for (int32_t k = j + 1; k < image_root_object_array->GetLength(); k++) {
1483 if (value == image_root_object_array->Get(k)) {
Ian Rogersfa824272013-11-05 16:12:57 -08001484 run++;
1485 } else {
1486 break;
1487 }
1488 }
1489 if (run == 0) {
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001490 indent_os << StringPrintf("%d: ", j);
Ian Rogersfa824272013-11-05 16:12:57 -08001491 } else {
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001492 indent_os << StringPrintf("%d to %zd: ", j, j + run);
Andreas Gampe277ccbd2014-11-03 21:36:10 -08001493 j = j + run;
Ian Rogersfa824272013-11-05 16:12:57 -08001494 }
Andreas Gampe2ed8def2014-08-28 14:41:02 -07001495 if (value != nullptr) {
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001496 PrettyObjectValue(indent_os, value->GetClass(), value);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001497 } else {
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001498 indent_os << j << ": null\n";
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001499 }
Ian Rogersd5b32602012-02-26 16:40:04 -08001500 }
Brian Carlstrom34f426c2011-10-04 12:58:02 -07001501 }
1502 }
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001503 }
Mathieu Chartiere401d142015-04-22 13:56:20 -07001504
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001505 {
Mathieu Chartiere401d142015-04-22 13:56:20 -07001506 os << "METHOD ROOTS\n";
1507 static_assert(arraysize(image_methods_descriptions_) ==
1508 static_cast<size_t>(ImageHeader::kImageMethodsCount), "sizes must match");
1509 for (int i = 0; i < ImageHeader::kImageMethodsCount; i++) {
1510 auto image_root = static_cast<ImageHeader::ImageMethod>(i);
1511 const char* description = image_methods_descriptions_[i];
1512 auto* image_method = image_header_.GetImageMethod(image_root);
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001513 indent_os << StringPrintf("%s: %p\n", description, image_method);
Mathieu Chartiere401d142015-04-22 13:56:20 -07001514 }
Brian Carlstrom27ec9612011-09-19 20:20:38 -07001515 }
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001516 os << "\n";
Brian Carlstrom27ec9612011-09-19 20:20:38 -07001517
Mathieu Chartierf9c6fc62015-10-07 11:44:05 -07001518 Runtime* const runtime = Runtime::Current();
1519 ClassLinker* class_linker = runtime->GetClassLinker();
Brian Carlstrom2ec65202014-03-03 15:16:37 -08001520 std::string image_filename = image_space_.GetImageFilename();
1521 std::string oat_location = ImageHeader::GetOatLocationFromImageLocation(image_filename);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001522 os << "OAT LOCATION: " << oat_location;
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001523 os << "\n";
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001524 std::string error_msg;
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -08001525 const OatFile* oat_file = image_space_.GetOatFile();
Alex Lighta59dd802014-07-02 16:28:08 -07001526 if (oat_file == nullptr) {
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -08001527 oat_file = runtime->GetOatFileManager().FindOpenedOatFileFromOatLocation(oat_location);
1528 }
1529 if (oat_file == nullptr) {
1530 oat_file = OatFile::Open(oat_location,
1531 oat_location,
1532 nullptr,
1533 nullptr,
1534 false,
1535 /*low_4gb*/false,
1536 nullptr,
Igor Murashkinb1d8c312015-08-04 11:18:43 -07001537 &error_msg);
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -08001538 }
1539 if (oat_file == nullptr) {
1540 os << "OAT FILE NOT FOUND: " << error_msg << "\n";
1541 return EXIT_FAILURE;
Brian Carlstromaded5f72011-10-07 17:15:04 -07001542 }
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001543 os << "\n";
Brian Carlstromaded5f72011-10-07 17:15:04 -07001544
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001545 stats_.oat_file_bytes = oat_file->Size();
1546
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -08001547 oat_dumper_.reset(new OatDumper(*oat_file, *oat_dumper_options_));
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001548
Mathieu Chartier02e25112013-08-14 16:14:24 -07001549 for (const OatFile::OatDexFile* oat_dex_file : oat_file->GetOatDexFiles()) {
Andreas Gampe2ed8def2014-08-28 14:41:02 -07001550 CHECK(oat_dex_file != nullptr);
Mathieu Chartier02e25112013-08-14 16:14:24 -07001551 stats_.oat_dex_file_sizes.push_back(std::make_pair(oat_dex_file->GetDexFileLocation(),
1552 oat_dex_file->FileSize()));
Ian Rogers05f28c62012-10-23 18:12:13 -07001553 }
1554
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001555 os << "OBJECTS:\n" << std::flush;
Mathieu Chartierb062fdd2012-07-03 09:51:48 -07001556
Jeff Haodcdc85b2015-12-04 14:06:18 -08001557 // Loop through the image space and dump its objects.
Mathieu Chartierf9c6fc62015-10-07 11:44:05 -07001558 gc::Heap* heap = runtime->GetHeap();
Ian Rogers50b35e22012-10-04 10:09:15 -07001559 Thread* self = Thread::Current();
Mathieu Chartier357e9be2012-08-01 11:00:14 -07001560 {
Mathieu Chartierc22c59e2014-02-24 15:16:06 -08001561 {
1562 WriterMutexLock mu(self, *Locks::heap_bitmap_lock_);
1563 heap->FlushAllocStack();
1564 }
Hiroshi Yamauchi90d70682014-02-20 16:17:30 -08001565 // Since FlushAllocStack() above resets the (active) allocation
1566 // stack. Need to revoke the thread-local allocation stacks that
1567 // point into it.
Mathieu Chartierf1d666e2015-09-03 16:13:34 -07001568 ScopedThreadSuspension sts(self, kNative);
Mathieu Chartier4f55e222015-09-04 13:26:21 -07001569 ScopedSuspendAll ssa(__FUNCTION__);
Mathieu Chartierf1d666e2015-09-03 16:13:34 -07001570 heap->RevokeAllThreadLocalAllocationStacks(self);
Mathieu Chartier357e9be2012-08-01 11:00:14 -07001571 }
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001572 {
Mathieu Chartiere401d142015-04-22 13:56:20 -07001573 // Mark dex caches.
Vladimir Marko05792b92015-08-03 11:56:49 +01001574 dex_caches_.clear();
Mathieu Chartiere401d142015-04-22 13:56:20 -07001575 {
1576 ReaderMutexLock mu(self, *class_linker->DexLock());
Hiroshi Yamauchi04302db2015-11-11 23:45:34 -08001577 for (const ClassLinker::DexCacheData& data : class_linker->GetDexCachesData()) {
Mathieu Chartierc4f39252016-10-05 18:32:08 -07001578 ObjPtr<mirror::DexCache> dex_cache =
1579 ObjPtr<mirror::DexCache>::DownCast(self->DecodeJObject(data.weak_root));
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07001580 if (dex_cache != nullptr) {
Mathieu Chartierc4f39252016-10-05 18:32:08 -07001581 dex_caches_.insert(dex_cache.Ptr());
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07001582 }
Mathieu Chartiere401d142015-04-22 13:56:20 -07001583 }
1584 }
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001585 ReaderMutexLock mu(self, *Locks::heap_bitmap_lock_);
Jeff Haodcdc85b2015-12-04 14:06:18 -08001586 // Dump the normal objects before ArtMethods.
1587 image_space_.GetLiveBitmap()->Walk(ImageDumper::Callback, this);
1588 indent_os << "\n";
1589 // TODO: Dump fields.
1590 // Dump methods after.
Jeff Haodcdc85b2015-12-04 14:06:18 -08001591 DumpArtMethodVisitor visitor(this);
Mathieu Chartiere42888f2016-04-14 10:49:19 -07001592 image_header_.VisitPackedArtMethods(&visitor,
1593 image_space_.Begin(),
1594 image_header_.GetPointerSize());
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001595 // Dump the large objects separately.
Mathieu Chartierbbd695c2014-04-16 09:48:48 -07001596 heap->GetLargeObjectsSpace()->GetLiveBitmap()->Walk(ImageDumper::Callback, this);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001597 indent_os << "\n";
Mathieu Chartierb062fdd2012-07-03 09:51:48 -07001598 }
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001599 os << "STATS:\n" << std::flush;
Ian Rogers700a4022014-05-19 16:49:03 -07001600 std::unique_ptr<File> file(OS::OpenFileForReading(image_filename.c_str()));
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -08001601 size_t data_size = image_header_.GetDataSize(); // stored size in file.
1602 if (file == nullptr) {
Brian Carlstrom2ec65202014-03-03 15:16:37 -08001603 LOG(WARNING) << "Failed to find image in " << image_filename;
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -08001604 } else {
Brian Carlstrom2ec65202014-03-03 15:16:37 -08001605 stats_.file_bytes = file->GetLength();
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -08001606 // If the image is compressed, adjust to decompressed size.
1607 size_t uncompressed_size = image_header_.GetImageSize() - sizeof(ImageHeader);
1608 if (image_header_.GetStorageMode() == ImageHeader::kStorageModeUncompressed) {
1609 DCHECK_EQ(uncompressed_size, data_size) << "Sizes should match for uncompressed image";
1610 }
1611 stats_.file_bytes += uncompressed_size - data_size;
Brian Carlstrom6f277752013-09-30 17:56:45 -07001612 }
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001613 size_t header_bytes = sizeof(ImageHeader);
Andreas Gampeace0dc12016-01-20 13:33:13 -08001614 const auto& object_section = image_header_.GetImageSection(ImageHeader::kSectionObjects);
Mathieu Chartiere401d142015-04-22 13:56:20 -07001615 const auto& field_section = image_header_.GetImageSection(ImageHeader::kSectionArtFields);
1616 const auto& method_section = image_header_.GetMethodsSection();
Vladimir Marko05792b92015-08-03 11:56:49 +01001617 const auto& dex_cache_arrays_section = image_header_.GetImageSection(
1618 ImageHeader::kSectionDexCacheArrays);
Mathieu Chartierd39645e2015-06-09 17:50:29 -07001619 const auto& intern_section = image_header_.GetImageSection(
1620 ImageHeader::kSectionInternedStrings);
Mathieu Chartier208a5cb2015-12-02 15:44:07 -08001621 const auto& class_table_section = image_header_.GetImageSection(
1622 ImageHeader::kSectionClassTable);
Andreas Gampeace0dc12016-01-20 13:33:13 -08001623 const auto& bitmap_section = image_header_.GetImageSection(ImageHeader::kSectionImageBitmap);
1624
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001625 stats_.header_bytes = header_bytes;
Andreas Gampeace0dc12016-01-20 13:33:13 -08001626
1627 // Objects are kObjectAlignment-aligned.
1628 // CHECK_EQ(RoundUp(header_bytes, kObjectAlignment), object_section.Offset());
1629 if (object_section.Offset() > header_bytes) {
1630 stats_.alignment_bytes += object_section.Offset() - header_bytes;
1631 }
1632
1633 // Field section is 4-byte aligned.
1634 constexpr size_t kFieldSectionAlignment = 4U;
1635 uint32_t end_objects = object_section.Offset() + object_section.Size();
1636 CHECK_EQ(RoundUp(end_objects, kFieldSectionAlignment), field_section.Offset());
1637 stats_.alignment_bytes += field_section.Offset() - end_objects;
1638
1639 // Method section is 4/8 byte aligned depending on target. Just check for 4-byte alignment.
1640 uint32_t end_fields = field_section.Offset() + field_section.Size();
1641 CHECK_ALIGNED(method_section.Offset(), 4);
1642 stats_.alignment_bytes += method_section.Offset() - end_fields;
1643
1644 // Dex cache arrays section is aligned depending on the target. Just check for 4-byte alignment.
1645 uint32_t end_methods = method_section.Offset() + method_section.Size();
1646 CHECK_ALIGNED(dex_cache_arrays_section.Offset(), 4);
1647 stats_.alignment_bytes += dex_cache_arrays_section.Offset() - end_methods;
1648
1649 // Intern table is 8-byte aligned.
1650 uint32_t end_caches = dex_cache_arrays_section.Offset() + dex_cache_arrays_section.Size();
1651 CHECK_EQ(RoundUp(end_caches, 8U), intern_section.Offset());
1652 stats_.alignment_bytes += intern_section.Offset() - end_caches;
1653
1654 // Add space between intern table and class table.
1655 uint32_t end_intern = intern_section.Offset() + intern_section.Size();
1656 stats_.alignment_bytes += class_table_section.Offset() - end_intern;
1657
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -08001658 // Add space between end of image data and bitmap. Expect the bitmap to be page-aligned.
1659 const size_t bitmap_offset = sizeof(ImageHeader) + data_size;
Andreas Gampeace0dc12016-01-20 13:33:13 -08001660 CHECK_ALIGNED(bitmap_section.Offset(), kPageSize);
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -08001661 stats_.alignment_bytes += RoundUp(bitmap_offset, kPageSize) - bitmap_offset;
Andreas Gampeace0dc12016-01-20 13:33:13 -08001662
Mathieu Chartiere401d142015-04-22 13:56:20 -07001663 stats_.bitmap_bytes += bitmap_section.Size();
1664 stats_.art_field_bytes += field_section.Size();
Vladimir Markocf36d492015-08-12 19:27:26 +01001665 stats_.art_method_bytes += method_section.Size();
Vladimir Marko05792b92015-08-03 11:56:49 +01001666 stats_.dex_cache_arrays_bytes += dex_cache_arrays_section.Size();
Mathieu Chartierd39645e2015-06-09 17:50:29 -07001667 stats_.interned_strings_bytes += intern_section.Size();
Mathieu Chartier208a5cb2015-12-02 15:44:07 -08001668 stats_.class_table_bytes += class_table_section.Size();
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001669 stats_.Dump(os, indent_os);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001670 os << "\n";
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001671
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001672 os << std::flush;
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001673
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001674 return oat_dumper_->Dump(os);
Brian Carlstrom78128a62011-09-15 17:21:19 -07001675 }
1676
Brian Carlstrom27ec9612011-09-19 20:20:38 -07001677 private:
Mathieu Chartier54d220e2015-07-30 16:20:06 -07001678 class DumpArtMethodVisitor : public ArtMethodVisitor {
1679 public:
1680 explicit DumpArtMethodVisitor(ImageDumper* image_dumper) : image_dumper_(image_dumper) {}
1681
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001682 virtual void Visit(ArtMethod* method) OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartier54d220e2015-07-30 16:20:06 -07001683 std::ostream& indent_os = image_dumper_->vios_.Stream();
David Sehr709b0702016-10-13 09:12:37 -07001684 indent_os << method << " " << " ArtMethod: " << ArtMethod::PrettyMethod(method) << "\n";
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -08001685 image_dumper_->DumpMethod(method, indent_os);
Mathieu Chartier54d220e2015-07-30 16:20:06 -07001686 indent_os << "\n";
1687 }
1688
1689 private:
1690 ImageDumper* const image_dumper_;
1691 };
1692
Mathieu Chartier3398c782016-09-30 10:27:43 -07001693 static void PrettyObjectValue(std::ostream& os,
1694 ObjPtr<mirror::Class> type,
1695 ObjPtr<mirror::Object> value)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001696 REQUIRES_SHARED(Locks::mutator_lock_) {
Andreas Gampe2ed8def2014-08-28 14:41:02 -07001697 CHECK(type != nullptr);
1698 if (value == nullptr) {
David Sehr709b0702016-10-13 09:12:37 -07001699 os << StringPrintf("null %s\n", type->PrettyDescriptor().c_str());
Ian Rogersd5b32602012-02-26 16:40:04 -08001700 } else if (type->IsStringClass()) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001701 mirror::String* string = value->AsString();
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001702 os << StringPrintf("%p String: %s\n", string,
Ian Rogers68b56852014-08-29 20:19:11 -07001703 PrintableString(string->ToModifiedUtf8().c_str()).c_str());
Ian Rogers64b6d142012-10-29 16:34:15 -07001704 } else if (type->IsClassClass()) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001705 mirror::Class* klass = value->AsClass();
David Sehr709b0702016-10-13 09:12:37 -07001706 os << StringPrintf("%p Class: %s\n", klass, mirror::Class::PrettyDescriptor(klass).c_str());
Ian Rogersd5b32602012-02-26 16:40:04 -08001707 } else {
David Sehr709b0702016-10-13 09:12:37 -07001708 os << StringPrintf("%p %s\n", value.Ptr(), type->PrettyDescriptor().c_str());
Ian Rogersd5b32602012-02-26 16:40:04 -08001709 }
1710 }
1711
Mathieu Chartier3398c782016-09-30 10:27:43 -07001712 static void PrintField(std::ostream& os, ArtField* field, ObjPtr<mirror::Object> obj)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001713 REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -07001714 os << StringPrintf("%s: ", field->GetName());
Ian Rogers08f1f502014-12-02 15:04:37 -08001715 switch (field->GetTypeAsPrimitiveType()) {
1716 case Primitive::kPrimLong:
Ian Rogersef7d42f2014-01-06 12:55:46 -08001717 os << StringPrintf("%" PRId64 " (0x%" PRIx64 ")\n", field->Get64(obj), field->Get64(obj));
Ian Rogers08f1f502014-12-02 15:04:37 -08001718 break;
1719 case Primitive::kPrimDouble:
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001720 os << StringPrintf("%f (%a)\n", field->GetDouble(obj), field->GetDouble(obj));
Ian Rogers08f1f502014-12-02 15:04:37 -08001721 break;
1722 case Primitive::kPrimFloat:
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001723 os << StringPrintf("%f (%a)\n", field->GetFloat(obj), field->GetFloat(obj));
Ian Rogers08f1f502014-12-02 15:04:37 -08001724 break;
1725 case Primitive::kPrimInt:
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001726 os << StringPrintf("%d (0x%x)\n", field->Get32(obj), field->Get32(obj));
Ian Rogers08f1f502014-12-02 15:04:37 -08001727 break;
1728 case Primitive::kPrimChar:
Fred Shih37f05ef2014-07-16 18:38:08 -07001729 os << StringPrintf("%u (0x%x)\n", field->GetChar(obj), field->GetChar(obj));
Ian Rogers08f1f502014-12-02 15:04:37 -08001730 break;
1731 case Primitive::kPrimShort:
Fred Shih37f05ef2014-07-16 18:38:08 -07001732 os << StringPrintf("%d (0x%x)\n", field->GetShort(obj), field->GetShort(obj));
Ian Rogers08f1f502014-12-02 15:04:37 -08001733 break;
1734 case Primitive::kPrimBoolean:
Fred Shih37f05ef2014-07-16 18:38:08 -07001735 os << StringPrintf("%s (0x%x)\n", field->GetBoolean(obj)? "true" : "false",
1736 field->GetBoolean(obj));
Ian Rogers08f1f502014-12-02 15:04:37 -08001737 break;
1738 case Primitive::kPrimByte:
Fred Shih37f05ef2014-07-16 18:38:08 -07001739 os << StringPrintf("%d (0x%x)\n", field->GetByte(obj), field->GetByte(obj));
Ian Rogers08f1f502014-12-02 15:04:37 -08001740 break;
1741 case Primitive::kPrimNot: {
1742 // Get the value, don't compute the type unless it is non-null as we don't want
1743 // to cause class loading.
Mathieu Chartier3398c782016-09-30 10:27:43 -07001744 ObjPtr<mirror::Object> value = field->GetObj(obj);
Ian Rogers08f1f502014-12-02 15:04:37 -08001745 if (value == nullptr) {
1746 os << StringPrintf("null %s\n", PrettyDescriptor(field->GetTypeDescriptor()).c_str());
Ian Rogers50239c72013-06-17 14:53:22 -07001747 } else {
Ian Rogers08f1f502014-12-02 15:04:37 -08001748 // Grab the field type without causing resolution.
Mathieu Chartier3398c782016-09-30 10:27:43 -07001749 ObjPtr<mirror::Class> field_type = field->GetType<false>();
Ian Rogers08f1f502014-12-02 15:04:37 -08001750 if (field_type != nullptr) {
1751 PrettyObjectValue(os, field_type, value);
1752 } else {
Mathieu Chartier3398c782016-09-30 10:27:43 -07001753 os << StringPrintf("%p %s\n",
Mathieu Chartier1cc62e42016-10-03 18:01:28 -07001754 value.Ptr(),
Ian Rogers08f1f502014-12-02 15:04:37 -08001755 PrettyDescriptor(field->GetTypeDescriptor()).c_str());
1756 }
Ian Rogers50239c72013-06-17 14:53:22 -07001757 }
Ian Rogers08f1f502014-12-02 15:04:37 -08001758 break;
Ian Rogers48efc2b2012-08-27 17:20:31 -07001759 }
Ian Rogers08f1f502014-12-02 15:04:37 -08001760 default:
1761 os << "unexpected field type: " << field->GetTypeDescriptor() << "\n";
1762 break;
Ian Rogersd5b32602012-02-26 16:40:04 -08001763 }
1764 }
1765
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001766 static void DumpFields(std::ostream& os, mirror::Object* obj, mirror::Class* klass)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001767 REQUIRES_SHARED(Locks::mutator_lock_) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001768 mirror::Class* super = klass->GetSuperClass();
Andreas Gampe2ed8def2014-08-28 14:41:02 -07001769 if (super != nullptr) {
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001770 DumpFields(os, obj, super);
Ian Rogersd5b32602012-02-26 16:40:04 -08001771 }
Mathieu Chartier54d220e2015-07-30 16:20:06 -07001772 for (ArtField& field : klass->GetIFields()) {
1773 PrintField(os, &field, obj);
Ian Rogersd5b32602012-02-26 16:40:04 -08001774 }
1775 }
1776
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001777 bool InDumpSpace(const mirror::Object* object) {
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001778 return image_space_.Contains(object);
Brian Carlstromf8bbb842012-03-14 03:01:42 -07001779 }
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001780
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001781 const void* GetQuickOatCodeBegin(ArtMethod* m) REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartiera7dd0382014-11-20 17:08:58 -08001782 const void* quick_code = m->GetEntryPointFromQuickCompiledCodePtrSize(
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -08001783 image_header_.GetPointerSize());
Ian Rogers6f3dbba2014-10-14 17:41:57 -07001784 if (Runtime::Current()->GetClassLinker()->IsQuickResolutionStub(quick_code)) {
Ian Rogersef7d42f2014-01-06 12:55:46 -08001785 quick_code = oat_dumper_->GetQuickOatCode(m);
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001786 }
Brian Carlstromf8bbb842012-03-14 03:01:42 -07001787 if (oat_dumper_->GetInstructionSet() == kThumb2) {
Ian Rogersef7d42f2014-01-06 12:55:46 -08001788 quick_code = reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(quick_code) & ~0x1);
Brian Carlstromf8bbb842012-03-14 03:01:42 -07001789 }
Ian Rogersef7d42f2014-01-06 12:55:46 -08001790 return quick_code;
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001791 }
1792
Mathieu Chartiere401d142015-04-22 13:56:20 -07001793 uint32_t GetQuickOatCodeSize(ArtMethod* m)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001794 REQUIRES_SHARED(Locks::mutator_lock_) {
Ian Rogersef7d42f2014-01-06 12:55:46 -08001795 const uint32_t* oat_code_begin = reinterpret_cast<const uint32_t*>(GetQuickOatCodeBegin(m));
1796 if (oat_code_begin == nullptr) {
Brian Carlstromf8bbb842012-03-14 03:01:42 -07001797 return 0;
1798 }
1799 return oat_code_begin[-1];
1800 }
1801
Mathieu Chartiere401d142015-04-22 13:56:20 -07001802 const void* GetQuickOatCodeEnd(ArtMethod* m)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001803 REQUIRES_SHARED(Locks::mutator_lock_) {
Ian Rogersef7d42f2014-01-06 12:55:46 -08001804 const uint8_t* oat_code_begin = reinterpret_cast<const uint8_t*>(GetQuickOatCodeBegin(m));
Andreas Gampe2ed8def2014-08-28 14:41:02 -07001805 if (oat_code_begin == nullptr) {
1806 return nullptr;
Brian Carlstromf8bbb842012-03-14 03:01:42 -07001807 }
Ian Rogersef7d42f2014-01-06 12:55:46 -08001808 return oat_code_begin + GetQuickOatCodeSize(m);
Brian Carlstromf8bbb842012-03-14 03:01:42 -07001809 }
1810
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001811 static void Callback(mirror::Object* obj, void* arg) REQUIRES_SHARED(Locks::mutator_lock_) {
Andreas Gampe2ed8def2014-08-28 14:41:02 -07001812 DCHECK(obj != nullptr);
1813 DCHECK(arg != nullptr);
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001814 ImageDumper* state = reinterpret_cast<ImageDumper*>(arg);
Brian Carlstrom78128a62011-09-15 17:21:19 -07001815 if (!state->InDumpSpace(obj)) {
1816 return;
1817 }
Brian Carlstrom916e74e2011-09-23 11:42:01 -07001818
1819 size_t object_bytes = obj->SizeOf();
1820 size_t alignment_bytes = RoundUp(object_bytes, kObjectAlignment) - object_bytes;
1821 state->stats_.object_bytes += object_bytes;
1822 state->stats_.alignment_bytes += alignment_bytes;
1823
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001824 std::ostream& os = state->vios_.Stream();
1825
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001826 mirror::Class* obj_class = obj->GetClass();
Ian Rogersd5b32602012-02-26 16:40:04 -08001827 if (obj_class->IsArrayClass()) {
David Sehr709b0702016-10-13 09:12:37 -07001828 os << StringPrintf("%p: %s length:%d\n", obj, obj_class->PrettyDescriptor().c_str(),
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001829 obj->AsArray()->GetLength());
Ian Rogersd5b32602012-02-26 16:40:04 -08001830 } else if (obj->IsClass()) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001831 mirror::Class* klass = obj->AsClass();
David Sehr709b0702016-10-13 09:12:37 -07001832 os << StringPrintf("%p: java.lang.Class \"%s\" (", obj,
1833 mirror::Class::PrettyDescriptor(klass).c_str())
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001834 << klass->GetStatus() << ")\n";
Ian Rogersd5b32602012-02-26 16:40:04 -08001835 } else if (obj_class->IsStringClass()) {
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001836 os << StringPrintf("%p: java.lang.String %s\n", obj,
Ian Rogers68b56852014-08-29 20:19:11 -07001837 PrintableString(obj->AsString()->ToModifiedUtf8().c_str()).c_str());
Ian Rogersd5b32602012-02-26 16:40:04 -08001838 } else {
David Sehr709b0702016-10-13 09:12:37 -07001839 os << StringPrintf("%p: %s\n", obj, obj_class->PrettyDescriptor().c_str());
Ian Rogersd5b32602012-02-26 16:40:04 -08001840 }
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001841 ScopedIndentation indent1(&state->vios_);
1842 DumpFields(os, obj, obj_class);
Andreas Gampe542451c2016-07-26 09:02:02 -07001843 const PointerSize image_pointer_size = state->image_header_.GetPointerSize();
Ian Rogersd5b32602012-02-26 16:40:04 -08001844 if (obj->IsObjectArray()) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07001845 auto* obj_array = obj->AsObjectArray<mirror::Object>();
1846 for (int32_t i = 0, length = obj_array->GetLength(); i < length; i++) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001847 mirror::Object* value = obj_array->Get(i);
Ian Rogersd5b32602012-02-26 16:40:04 -08001848 size_t run = 0;
1849 for (int32_t j = i + 1; j < length; j++) {
1850 if (value == obj_array->Get(j)) {
1851 run++;
1852 } else {
1853 break;
1854 }
1855 }
1856 if (run == 0) {
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001857 os << StringPrintf("%d: ", i);
Ian Rogersd5b32602012-02-26 16:40:04 -08001858 } else {
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001859 os << StringPrintf("%d to %zd: ", i, i + run);
Ian Rogersd5b32602012-02-26 16:40:04 -08001860 i = i + run;
1861 }
Brian Carlstrom2ec65202014-03-03 15:16:37 -08001862 mirror::Class* value_class =
Andreas Gampe2ed8def2014-08-28 14:41:02 -07001863 (value == nullptr) ? obj_class->GetComponentType() : value->GetClass();
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001864 PrettyObjectValue(os, value_class, value);
Ian Rogersd5b32602012-02-26 16:40:04 -08001865 }
1866 } else if (obj->IsClass()) {
Mathieu Chartierc7853442015-03-27 14:35:38 -07001867 mirror::Class* klass = obj->AsClass();
Mathieu Chartier54d220e2015-07-30 16:20:06 -07001868 if (klass->NumStaticFields() != 0) {
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01001869 os << "STATICS:\n";
1870 ScopedIndentation indent2(&state->vios_);
Mathieu Chartier54d220e2015-07-30 16:20:06 -07001871 for (ArtField& field : klass->GetSFields()) {
1872 PrintField(os, &field, field.GetDeclaringClass());
Ian Rogersd5b32602012-02-26 16:40:04 -08001873 }
1874 }
Mathieu Chartiere401d142015-04-22 13:56:20 -07001875 } else {
Vladimir Marko05792b92015-08-03 11:56:49 +01001876 auto it = state->dex_caches_.find(obj);
1877 if (it != state->dex_caches_.end()) {
1878 auto* dex_cache = down_cast<mirror::DexCache*>(obj);
Mathieu Chartiere401d142015-04-22 13:56:20 -07001879 const auto& field_section = state->image_header_.GetImageSection(
1880 ImageHeader::kSectionArtFields);
1881 const auto& method_section = state->image_header_.GetMethodsSection();
Vladimir Marko05792b92015-08-03 11:56:49 +01001882 size_t num_methods = dex_cache->NumResolvedMethods();
1883 if (num_methods != 0u) {
Nicolas Geoffrayc6df1e32016-07-04 10:15:47 +01001884 os << "Methods (size=" << num_methods << "):\n";
Vladimir Marko05792b92015-08-03 11:56:49 +01001885 ScopedIndentation indent2(&state->vios_);
1886 auto* resolved_methods = dex_cache->GetResolvedMethods();
1887 for (size_t i = 0, length = dex_cache->NumResolvedMethods(); i < length; ++i) {
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -08001888 auto* elem = mirror::DexCache::GetElementPtrSize(resolved_methods,
1889 i,
1890 image_pointer_size);
Vladimir Marko05792b92015-08-03 11:56:49 +01001891 size_t run = 0;
1892 for (size_t j = i + 1;
Nicolas Geoffrayc6df1e32016-07-04 10:15:47 +01001893 j != length && elem == mirror::DexCache::GetElementPtrSize(resolved_methods,
1894 j,
1895 image_pointer_size);
1896 ++j) {
1897 ++run;
1898 }
Vladimir Marko05792b92015-08-03 11:56:49 +01001899 if (run == 0) {
1900 os << StringPrintf("%zd: ", i);
1901 } else {
1902 os << StringPrintf("%zd to %zd: ", i, i + run);
1903 i = i + run;
1904 }
1905 std::string msg;
1906 if (elem == nullptr) {
1907 msg = "null";
1908 } else if (method_section.Contains(
1909 reinterpret_cast<uint8_t*>(elem) - state->image_space_.Begin())) {
David Sehr709b0702016-10-13 09:12:37 -07001910 msg = reinterpret_cast<ArtMethod*>(elem)->PrettyMethod();
Vladimir Marko05792b92015-08-03 11:56:49 +01001911 } else {
1912 msg = "<not in method section>";
1913 }
1914 os << StringPrintf("%p %s\n", elem, msg.c_str());
Ian Rogers0d2d3782012-04-10 11:09:18 -07001915 }
Vladimir Marko05792b92015-08-03 11:56:49 +01001916 }
1917 size_t num_fields = dex_cache->NumResolvedFields();
1918 if (num_fields != 0u) {
Nicolas Geoffrayc6df1e32016-07-04 10:15:47 +01001919 os << "Fields (size=" << num_fields << "):\n";
Vladimir Marko05792b92015-08-03 11:56:49 +01001920 ScopedIndentation indent2(&state->vios_);
1921 auto* resolved_fields = dex_cache->GetResolvedFields();
1922 for (size_t i = 0, length = dex_cache->NumResolvedFields(); i < length; ++i) {
Nicolas Geoffrayc6df1e32016-07-04 10:15:47 +01001923 auto* elem = mirror::DexCache::GetElementPtrSize(
1924 resolved_fields, i, image_pointer_size);
Vladimir Marko05792b92015-08-03 11:56:49 +01001925 size_t run = 0;
1926 for (size_t j = i + 1;
Nicolas Geoffrayc6df1e32016-07-04 10:15:47 +01001927 j != length && elem == mirror::DexCache::GetElementPtrSize(resolved_fields,
1928 j,
1929 image_pointer_size);
1930 ++j) {
1931 ++run;
1932 }
Vladimir Marko05792b92015-08-03 11:56:49 +01001933 if (run == 0) {
1934 os << StringPrintf("%zd: ", i);
1935 } else {
1936 os << StringPrintf("%zd to %zd: ", i, i + run);
1937 i = i + run;
1938 }
1939 std::string msg;
1940 if (elem == nullptr) {
1941 msg = "null";
1942 } else if (field_section.Contains(
1943 reinterpret_cast<uint8_t*>(elem) - state->image_space_.Begin())) {
David Sehr709b0702016-10-13 09:12:37 -07001944 msg = reinterpret_cast<ArtField*>(elem)->PrettyField();
Vladimir Marko05792b92015-08-03 11:56:49 +01001945 } else {
1946 msg = "<not in field section>";
1947 }
1948 os << StringPrintf("%p %s\n", elem, msg.c_str());
Mathieu Chartiere401d142015-04-22 13:56:20 -07001949 }
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001950 }
Nicolas Geoffrayc6df1e32016-07-04 10:15:47 +01001951 size_t num_types = dex_cache->NumResolvedTypes();
1952 if (num_types != 0u) {
1953 os << "Types (size=" << num_types << "):\n";
1954 ScopedIndentation indent2(&state->vios_);
1955 auto* resolved_types = dex_cache->GetResolvedTypes();
1956 for (size_t i = 0; i < num_types; ++i) {
1957 auto* elem = resolved_types[i].Read();
1958 size_t run = 0;
1959 for (size_t j = i + 1; j != num_types && elem == resolved_types[j].Read(); ++j) {
1960 ++run;
1961 }
1962 if (run == 0) {
1963 os << StringPrintf("%zd: ", i);
1964 } else {
1965 os << StringPrintf("%zd to %zd: ", i, i + run);
1966 i = i + run;
1967 }
1968 std::string msg;
1969 if (elem == nullptr) {
1970 msg = "null";
1971 } else {
David Sehr709b0702016-10-13 09:12:37 -07001972 msg = elem->PrettyClass();
Nicolas Geoffrayc6df1e32016-07-04 10:15:47 +01001973 }
1974 os << StringPrintf("%p %s\n", elem, msg.c_str());
1975 }
1976 }
Brian Carlstrom78128a62011-09-15 17:21:19 -07001977 }
1978 }
Ian Rogers1ff3c982014-08-12 02:30:58 -07001979 std::string temp;
1980 state->stats_.Update(obj_class->GetDescriptor(&temp), object_bytes);
Brian Carlstrom78128a62011-09-15 17:21:19 -07001981 }
Brian Carlstrom27ec9612011-09-19 20:20:38 -07001982
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -08001983 void DumpMethod(ArtMethod* method, std::ostream& indent_os)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001984 REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07001985 DCHECK(method != nullptr);
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -08001986 const void* quick_oat_code_begin = GetQuickOatCodeBegin(method);
1987 const void* quick_oat_code_end = GetQuickOatCodeEnd(method);
Andreas Gampe542451c2016-07-26 09:02:02 -07001988 const PointerSize pointer_size = image_header_.GetPointerSize();
Nicolas Geoffray524e7ea2015-10-16 17:13:34 +01001989 OatQuickMethodHeader* method_header = reinterpret_cast<OatQuickMethodHeader*>(
1990 reinterpret_cast<uintptr_t>(quick_oat_code_begin) - sizeof(OatQuickMethodHeader));
Mathieu Chartiere401d142015-04-22 13:56:20 -07001991 if (method->IsNative()) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07001992 bool first_occurrence;
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -08001993 uint32_t quick_oat_code_size = GetQuickOatCodeSize(method);
1994 ComputeOatSize(quick_oat_code_begin, &first_occurrence);
Mathieu Chartiere401d142015-04-22 13:56:20 -07001995 if (first_occurrence) {
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -08001996 stats_.native_to_managed_code_bytes += quick_oat_code_size;
Mathieu Chartiere401d142015-04-22 13:56:20 -07001997 }
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -08001998 if (quick_oat_code_begin != method->GetEntryPointFromQuickCompiledCodePtrSize(
1999 image_header_.GetPointerSize())) {
Nicolas Geoffray6bc43742015-10-12 18:11:10 +01002000 indent_os << StringPrintf("OAT CODE: %p\n", quick_oat_code_begin);
Mathieu Chartiere401d142015-04-22 13:56:20 -07002001 }
Mathieu Chartiere42888f2016-04-14 10:49:19 -07002002 } else if (method->IsAbstract() || method->IsClassInitializer()) {
Nicolas Geoffray796d6302016-03-13 22:22:31 +00002003 // Don't print information for these.
Mathieu Chartiere42888f2016-04-14 10:49:19 -07002004 } else if (method->IsRuntimeMethod()) {
2005 ImtConflictTable* table = method->GetImtConflictTable(image_header_.GetPointerSize());
2006 if (table != nullptr) {
2007 indent_os << "IMT conflict table " << table << " method: ";
2008 for (size_t i = 0, count = table->NumEntries(pointer_size); i < count; ++i) {
David Sehr709b0702016-10-13 09:12:37 -07002009 indent_os << ArtMethod::PrettyMethod(table->GetImplementationMethod(i, pointer_size))
2010 << " ";
Mathieu Chartiere42888f2016-04-14 10:49:19 -07002011 }
2012 }
Mathieu Chartiere401d142015-04-22 13:56:20 -07002013 } else {
2014 const DexFile::CodeItem* code_item = method->GetCodeItem();
2015 size_t dex_instruction_bytes = code_item->insns_size_in_code_units_ * 2;
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -08002016 stats_.dex_instruction_bytes += dex_instruction_bytes;
Mathieu Chartiere401d142015-04-22 13:56:20 -07002017
2018 bool first_occurrence;
Roland Levillain6d7f1792015-07-02 10:59:15 +01002019 size_t vmap_table_bytes = 0u;
Nicolas Geoffray524e7ea2015-10-16 17:13:34 +01002020 if (!method_header->IsOptimized()) {
Roland Levillain6d7f1792015-07-02 10:59:15 +01002021 // Method compiled with the optimizing compiler have no vmap table.
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -08002022 vmap_table_bytes = ComputeOatSize(method_header->GetVmapTable(), &first_occurrence);
Roland Levillain6d7f1792015-07-02 10:59:15 +01002023 if (first_occurrence) {
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -08002024 stats_.vmap_table_bytes += vmap_table_bytes;
Roland Levillain6d7f1792015-07-02 10:59:15 +01002025 }
Mathieu Chartiere401d142015-04-22 13:56:20 -07002026 }
2027
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -08002028 uint32_t quick_oat_code_size = GetQuickOatCodeSize(method);
2029 ComputeOatSize(quick_oat_code_begin, &first_occurrence);
Mathieu Chartiere401d142015-04-22 13:56:20 -07002030 if (first_occurrence) {
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -08002031 stats_.managed_code_bytes += quick_oat_code_size;
Mathieu Chartiere401d142015-04-22 13:56:20 -07002032 if (method->IsConstructor()) {
2033 if (method->IsStatic()) {
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -08002034 stats_.class_initializer_code_bytes += quick_oat_code_size;
Mathieu Chartiere401d142015-04-22 13:56:20 -07002035 } else if (dex_instruction_bytes > kLargeConstructorDexBytes) {
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -08002036 stats_.large_initializer_code_bytes += quick_oat_code_size;
Mathieu Chartiere401d142015-04-22 13:56:20 -07002037 }
2038 } else if (dex_instruction_bytes > kLargeMethodDexBytes) {
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -08002039 stats_.large_method_code_bytes += quick_oat_code_size;
Mathieu Chartiere401d142015-04-22 13:56:20 -07002040 }
2041 }
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -08002042 stats_.managed_code_bytes_ignoring_deduplication += quick_oat_code_size;
Mathieu Chartiere401d142015-04-22 13:56:20 -07002043
Igor Murashkin7617abd2015-07-10 18:27:47 -07002044 uint32_t method_access_flags = method->GetAccessFlags();
2045
Mathieu Chartiere401d142015-04-22 13:56:20 -07002046 indent_os << StringPrintf("OAT CODE: %p-%p\n", quick_oat_code_begin, quick_oat_code_end);
Vladimir Marko9d07e3d2016-03-31 12:02:28 +01002047 indent_os << StringPrintf("SIZE: Dex Instructions=%zd StackMaps=%zd AccessFlags=0x%x\n",
2048 dex_instruction_bytes,
2049 vmap_table_bytes,
Igor Murashkin7617abd2015-07-10 18:27:47 -07002050 method_access_flags);
Mathieu Chartiere401d142015-04-22 13:56:20 -07002051
Vladimir Marko9d07e3d2016-03-31 12:02:28 +01002052 size_t total_size = dex_instruction_bytes +
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -08002053 vmap_table_bytes + quick_oat_code_size + ArtMethod::Size(image_header_.GetPointerSize());
Mathieu Chartiere401d142015-04-22 13:56:20 -07002054
2055 double expansion =
2056 static_cast<double>(quick_oat_code_size) / static_cast<double>(dex_instruction_bytes);
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -08002057 stats_.ComputeOutliers(total_size, expansion, method);
Mathieu Chartiere401d142015-04-22 13:56:20 -07002058 }
2059 }
2060
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08002061 std::set<const void*> already_seen_;
2062 // Compute the size of the given data within the oat file and whether this is the first time
2063 // this data has been requested
Elliott Hughesa0e18062012-04-13 15:59:59 -07002064 size_t ComputeOatSize(const void* oat_data, bool* first_occurrence) {
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08002065 if (already_seen_.count(oat_data) == 0) {
Elliott Hughesa0e18062012-04-13 15:59:59 -07002066 *first_occurrence = true;
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08002067 already_seen_.insert(oat_data);
2068 } else {
Elliott Hughesa0e18062012-04-13 15:59:59 -07002069 *first_occurrence = false;
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08002070 }
2071 return oat_dumper_->ComputeSize(oat_data);
Brian Carlstrom27ec9612011-09-19 20:20:38 -07002072 }
Brian Carlstrom916e74e2011-09-23 11:42:01 -07002073
2074 public:
2075 struct Stats {
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08002076 size_t oat_file_bytes;
Brian Carlstrom916e74e2011-09-23 11:42:01 -07002077 size_t file_bytes;
2078
2079 size_t header_bytes;
2080 size_t object_bytes;
Mathieu Chartiere401d142015-04-22 13:56:20 -07002081 size_t art_field_bytes;
2082 size_t art_method_bytes;
Vladimir Marko05792b92015-08-03 11:56:49 +01002083 size_t dex_cache_arrays_bytes;
Mathieu Chartierd39645e2015-06-09 17:50:29 -07002084 size_t interned_strings_bytes;
Mathieu Chartier208a5cb2015-12-02 15:44:07 -08002085 size_t class_table_bytes;
Mathieu Chartier32327092013-08-30 14:04:08 -07002086 size_t bitmap_bytes;
Brian Carlstrom916e74e2011-09-23 11:42:01 -07002087 size_t alignment_bytes;
2088
2089 size_t managed_code_bytes;
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08002090 size_t managed_code_bytes_ignoring_deduplication;
Brian Carlstrom916e74e2011-09-23 11:42:01 -07002091 size_t managed_to_native_code_bytes;
2092 size_t native_to_managed_code_bytes;
Ian Rogers0d2d3782012-04-10 11:09:18 -07002093 size_t class_initializer_code_bytes;
2094 size_t large_initializer_code_bytes;
2095 size_t large_method_code_bytes;
Brian Carlstrom916e74e2011-09-23 11:42:01 -07002096
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08002097 size_t vmap_table_bytes;
Brian Carlstrom916e74e2011-09-23 11:42:01 -07002098
2099 size_t dex_instruction_bytes;
2100
Mathieu Chartiere401d142015-04-22 13:56:20 -07002101 std::vector<ArtMethod*> method_outlier;
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08002102 std::vector<size_t> method_outlier_size;
2103 std::vector<double> method_outlier_expansion;
Ian Rogers700a4022014-05-19 16:49:03 -07002104 std::vector<std::pair<std::string, size_t>> oat_dex_file_sizes;
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08002105
Roland Levillain3887c462015-08-12 18:15:42 +01002106 Stats()
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08002107 : oat_file_bytes(0),
2108 file_bytes(0),
Brian Carlstrom916e74e2011-09-23 11:42:01 -07002109 header_bytes(0),
2110 object_bytes(0),
Mathieu Chartiere401d142015-04-22 13:56:20 -07002111 art_field_bytes(0),
2112 art_method_bytes(0),
Vladimir Marko05792b92015-08-03 11:56:49 +01002113 dex_cache_arrays_bytes(0),
Mathieu Chartierd39645e2015-06-09 17:50:29 -07002114 interned_strings_bytes(0),
Mathieu Chartier208a5cb2015-12-02 15:44:07 -08002115 class_table_bytes(0),
Mathieu Chartier32327092013-08-30 14:04:08 -07002116 bitmap_bytes(0),
Brian Carlstrom916e74e2011-09-23 11:42:01 -07002117 alignment_bytes(0),
2118 managed_code_bytes(0),
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08002119 managed_code_bytes_ignoring_deduplication(0),
Brian Carlstrom916e74e2011-09-23 11:42:01 -07002120 managed_to_native_code_bytes(0),
2121 native_to_managed_code_bytes(0),
Ian Rogers0d2d3782012-04-10 11:09:18 -07002122 class_initializer_code_bytes(0),
2123 large_initializer_code_bytes(0),
2124 large_method_code_bytes(0),
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08002125 vmap_table_bytes(0),
Brian Carlstrom916e74e2011-09-23 11:42:01 -07002126 dex_instruction_bytes(0) {}
2127
Elliott Hughesa0e18062012-04-13 15:59:59 -07002128 struct SizeAndCount {
Andreas Gampe277ccbd2014-11-03 21:36:10 -08002129 SizeAndCount(size_t bytes_in, size_t count_in) : bytes(bytes_in), count(count_in) {}
Elliott Hughesa0e18062012-04-13 15:59:59 -07002130 size_t bytes;
2131 size_t count;
2132 };
2133 typedef SafeMap<std::string, SizeAndCount> SizeAndCountTable;
2134 SizeAndCountTable sizes_and_counts;
Brian Carlstrom916e74e2011-09-23 11:42:01 -07002135
Andreas Gampe277ccbd2014-11-03 21:36:10 -08002136 void Update(const char* descriptor, size_t object_bytes_in) {
Elliott Hughesa0e18062012-04-13 15:59:59 -07002137 SizeAndCountTable::iterator it = sizes_and_counts.find(descriptor);
2138 if (it != sizes_and_counts.end()) {
Andreas Gampe277ccbd2014-11-03 21:36:10 -08002139 it->second.bytes += object_bytes_in;
Elliott Hughesa0e18062012-04-13 15:59:59 -07002140 it->second.count += 1;
2141 } else {
Andreas Gampe277ccbd2014-11-03 21:36:10 -08002142 sizes_and_counts.Put(descriptor, SizeAndCount(object_bytes_in, 1));
Elliott Hughesa0e18062012-04-13 15:59:59 -07002143 }
2144 }
Brian Carlstrom916e74e2011-09-23 11:42:01 -07002145
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08002146 double PercentOfOatBytes(size_t size) {
2147 return (static_cast<double>(size) / static_cast<double>(oat_file_bytes)) * 100;
2148 }
2149
Brian Carlstrom916e74e2011-09-23 11:42:01 -07002150 double PercentOfFileBytes(size_t size) {
2151 return (static_cast<double>(size) / static_cast<double>(file_bytes)) * 100;
2152 }
2153
2154 double PercentOfObjectBytes(size_t size) {
2155 return (static_cast<double>(size) / static_cast<double>(object_bytes)) * 100;
2156 }
2157
Mathieu Chartiere401d142015-04-22 13:56:20 -07002158 void ComputeOutliers(size_t total_size, double expansion, ArtMethod* method) {
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08002159 method_outlier_size.push_back(total_size);
2160 method_outlier_expansion.push_back(expansion);
2161 method_outlier.push_back(method);
2162 }
Brian Carlstrom916e74e2011-09-23 11:42:01 -07002163
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002164 void DumpOutliers(std::ostream& os)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07002165 REQUIRES_SHARED(Locks::mutator_lock_) {
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08002166 size_t sum_of_sizes = 0;
2167 size_t sum_of_sizes_squared = 0;
2168 size_t sum_of_expansion = 0;
2169 size_t sum_of_expansion_squared = 0;
2170 size_t n = method_outlier_size.size();
Mathieu Chartier1ebf8d32016-06-09 11:51:27 -07002171 if (n <= 1) {
Jeff Haodcdc85b2015-12-04 14:06:18 -08002172 return;
2173 }
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08002174 for (size_t i = 0; i < n; i++) {
2175 size_t cur_size = method_outlier_size[i];
2176 sum_of_sizes += cur_size;
2177 sum_of_sizes_squared += cur_size * cur_size;
2178 double cur_expansion = method_outlier_expansion[i];
2179 sum_of_expansion += cur_expansion;
2180 sum_of_expansion_squared += cur_expansion * cur_expansion;
2181 }
2182 size_t size_mean = sum_of_sizes / n;
2183 size_t size_variance = (sum_of_sizes_squared - sum_of_sizes * size_mean) / (n - 1);
2184 double expansion_mean = sum_of_expansion / n;
2185 double expansion_variance =
2186 (sum_of_expansion_squared - sum_of_expansion * expansion_mean) / (n - 1);
2187
2188 // Dump methods whose size is a certain number of standard deviations from the mean
2189 size_t dumped_values = 0;
2190 size_t skipped_values = 0;
2191 for (size_t i = 100; i > 0; i--) { // i is the current number of standard deviations
2192 size_t cur_size_variance = i * i * size_variance;
2193 bool first = true;
2194 for (size_t j = 0; j < n; j++) {
2195 size_t cur_size = method_outlier_size[j];
2196 if (cur_size > size_mean) {
2197 size_t cur_var = cur_size - size_mean;
2198 cur_var = cur_var * cur_var;
2199 if (cur_var > cur_size_variance) {
2200 if (dumped_values > 20) {
2201 if (i == 1) {
2202 skipped_values++;
2203 } else {
2204 i = 2; // jump to counting for 1 standard deviation
2205 break;
2206 }
2207 } else {
2208 if (first) {
Elliott Hughesc073b072012-05-24 19:29:17 -07002209 os << "\nBig methods (size > " << i << " standard deviations the norm):\n";
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08002210 first = false;
2211 }
David Sehr709b0702016-10-13 09:12:37 -07002212 os << ArtMethod::PrettyMethod(method_outlier[j]) << " requires storage of "
Elliott Hughesc073b072012-05-24 19:29:17 -07002213 << PrettySize(cur_size) << "\n";
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08002214 method_outlier_size[j] = 0; // don't consider this method again
2215 dumped_values++;
2216 }
2217 }
2218 }
2219 }
2220 }
2221 if (skipped_values > 0) {
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002222 os << "... skipped " << skipped_values
Elliott Hughesc073b072012-05-24 19:29:17 -07002223 << " methods with size > 1 standard deviation from the norm\n";
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08002224 }
Elliott Hughesc073b072012-05-24 19:29:17 -07002225 os << std::flush;
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08002226
2227 // Dump methods whose expansion is a certain number of standard deviations from the mean
2228 dumped_values = 0;
2229 skipped_values = 0;
2230 for (size_t i = 10; i > 0; i--) { // i is the current number of standard deviations
2231 double cur_expansion_variance = i * i * expansion_variance;
2232 bool first = true;
2233 for (size_t j = 0; j < n; j++) {
2234 double cur_expansion = method_outlier_expansion[j];
2235 if (cur_expansion > expansion_mean) {
2236 size_t cur_var = cur_expansion - expansion_mean;
2237 cur_var = cur_var * cur_var;
2238 if (cur_var > cur_expansion_variance) {
2239 if (dumped_values > 20) {
2240 if (i == 1) {
2241 skipped_values++;
2242 } else {
2243 i = 2; // jump to counting for 1 standard deviation
2244 break;
2245 }
2246 } else {
2247 if (first) {
2248 os << "\nLarge expansion methods (size > " << i
Elliott Hughesc073b072012-05-24 19:29:17 -07002249 << " standard deviations the norm):\n";
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08002250 first = false;
2251 }
David Sehr709b0702016-10-13 09:12:37 -07002252 os << ArtMethod::PrettyMethod(method_outlier[j]) << " expanded code by "
Elliott Hughesc073b072012-05-24 19:29:17 -07002253 << cur_expansion << "\n";
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08002254 method_outlier_expansion[j] = 0.0; // don't consider this method again
2255 dumped_values++;
2256 }
2257 }
2258 }
2259 }
2260 }
2261 if (skipped_values > 0) {
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002262 os << "... skipped " << skipped_values
Elliott Hughesc073b072012-05-24 19:29:17 -07002263 << " methods with expansion > 1 standard deviation from the norm\n";
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08002264 }
Elliott Hughesc073b072012-05-24 19:29:17 -07002265 os << "\n" << std::flush;
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08002266 }
2267
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01002268 void Dump(std::ostream& os, std::ostream& indent_os)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07002269 REQUIRES_SHARED(Locks::mutator_lock_) {
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002270 {
2271 os << "art_file_bytes = " << PrettySize(file_bytes) << "\n\n"
2272 << "art_file_bytes = header_bytes + object_bytes + alignment_bytes\n";
Vladimir Marko05792b92015-08-03 11:56:49 +01002273 indent_os << StringPrintf("header_bytes = %8zd (%2.0f%% of art file bytes)\n"
2274 "object_bytes = %8zd (%2.0f%% of art file bytes)\n"
2275 "art_field_bytes = %8zd (%2.0f%% of art file bytes)\n"
2276 "art_method_bytes = %8zd (%2.0f%% of art file bytes)\n"
2277 "dex_cache_arrays_bytes = %8zd (%2.0f%% of art file bytes)\n"
2278 "interned_string_bytes = %8zd (%2.0f%% of art file bytes)\n"
Mathieu Chartier208a5cb2015-12-02 15:44:07 -08002279 "class_table_bytes = %8zd (%2.0f%% of art file bytes)\n"
Vladimir Marko05792b92015-08-03 11:56:49 +01002280 "bitmap_bytes = %8zd (%2.0f%% of art file bytes)\n"
2281 "alignment_bytes = %8zd (%2.0f%% of art file bytes)\n\n",
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002282 header_bytes, PercentOfFileBytes(header_bytes),
2283 object_bytes, PercentOfFileBytes(object_bytes),
Mathieu Chartiere401d142015-04-22 13:56:20 -07002284 art_field_bytes, PercentOfFileBytes(art_field_bytes),
2285 art_method_bytes, PercentOfFileBytes(art_method_bytes),
Vladimir Marko05792b92015-08-03 11:56:49 +01002286 dex_cache_arrays_bytes,
2287 PercentOfFileBytes(dex_cache_arrays_bytes),
Mathieu Chartierd39645e2015-06-09 17:50:29 -07002288 interned_strings_bytes,
2289 PercentOfFileBytes(interned_strings_bytes),
Mathieu Chartier208a5cb2015-12-02 15:44:07 -08002290 class_table_bytes, PercentOfFileBytes(class_table_bytes),
Mathieu Chartier32327092013-08-30 14:04:08 -07002291 bitmap_bytes, PercentOfFileBytes(bitmap_bytes),
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002292 alignment_bytes, PercentOfFileBytes(alignment_bytes))
2293 << std::flush;
Mathieu Chartier208a5cb2015-12-02 15:44:07 -08002294 CHECK_EQ(file_bytes,
2295 header_bytes + object_bytes + art_field_bytes + art_method_bytes +
2296 dex_cache_arrays_bytes + interned_strings_bytes + class_table_bytes +
2297 bitmap_bytes + alignment_bytes);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002298 }
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08002299
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002300 os << "object_bytes breakdown:\n";
Brian Carlstrom916e74e2011-09-23 11:42:01 -07002301 size_t object_bytes_total = 0;
Mathieu Chartier02e25112013-08-14 16:14:24 -07002302 for (const auto& sizes_and_count : sizes_and_counts) {
2303 const std::string& descriptor(sizes_and_count.first);
2304 double average = static_cast<double>(sizes_and_count.second.bytes) /
2305 static_cast<double>(sizes_and_count.second.count);
2306 double percent = PercentOfObjectBytes(sizes_and_count.second.bytes);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002307 os << StringPrintf("%32s %8zd bytes %6zd instances "
Elliott Hughesa0e18062012-04-13 15:59:59 -07002308 "(%4.0f bytes/instance) %2.0f%% of object_bytes\n",
Mathieu Chartier02e25112013-08-14 16:14:24 -07002309 descriptor.c_str(), sizes_and_count.second.bytes,
2310 sizes_and_count.second.count, average, percent);
2311 object_bytes_total += sizes_and_count.second.bytes;
Brian Carlstrom916e74e2011-09-23 11:42:01 -07002312 }
Elliott Hughesc073b072012-05-24 19:29:17 -07002313 os << "\n" << std::flush;
Brian Carlstrom916e74e2011-09-23 11:42:01 -07002314 CHECK_EQ(object_bytes, object_bytes_total);
2315
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002316 os << StringPrintf("oat_file_bytes = %8zd\n"
2317 "managed_code_bytes = %8zd (%2.0f%% of oat file bytes)\n"
2318 "managed_to_native_code_bytes = %8zd (%2.0f%% of oat file bytes)\n"
2319 "native_to_managed_code_bytes = %8zd (%2.0f%% of oat file bytes)\n\n"
2320 "class_initializer_code_bytes = %8zd (%2.0f%% of oat file bytes)\n"
2321 "large_initializer_code_bytes = %8zd (%2.0f%% of oat file bytes)\n"
2322 "large_method_code_bytes = %8zd (%2.0f%% of oat file bytes)\n\n",
Ian Rogers05f28c62012-10-23 18:12:13 -07002323 oat_file_bytes,
Brian Carlstrom2ec65202014-03-03 15:16:37 -08002324 managed_code_bytes,
2325 PercentOfOatBytes(managed_code_bytes),
2326 managed_to_native_code_bytes,
2327 PercentOfOatBytes(managed_to_native_code_bytes),
2328 native_to_managed_code_bytes,
2329 PercentOfOatBytes(native_to_managed_code_bytes),
2330 class_initializer_code_bytes,
2331 PercentOfOatBytes(class_initializer_code_bytes),
2332 large_initializer_code_bytes,
2333 PercentOfOatBytes(large_initializer_code_bytes),
2334 large_method_code_bytes,
2335 PercentOfOatBytes(large_method_code_bytes))
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002336 << "DexFile sizes:\n";
Mathieu Chartier02e25112013-08-14 16:14:24 -07002337 for (const std::pair<std::string, size_t>& oat_dex_file_size : oat_dex_file_sizes) {
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002338 os << StringPrintf("%s = %zd (%2.0f%% of oat file bytes)\n",
Mathieu Chartier02e25112013-08-14 16:14:24 -07002339 oat_dex_file_size.first.c_str(), oat_dex_file_size.second,
2340 PercentOfOatBytes(oat_dex_file_size.second));
Ian Rogers05f28c62012-10-23 18:12:13 -07002341 }
2342
Vladimir Marko9d07e3d2016-03-31 12:02:28 +01002343 os << "\n" << StringPrintf("vmap_table_bytes = %7zd (%2.0f%% of oat file bytes)\n\n",
Ian Rogers05f28c62012-10-23 18:12:13 -07002344 vmap_table_bytes, PercentOfOatBytes(vmap_table_bytes))
Elliott Hughesc073b072012-05-24 19:29:17 -07002345 << std::flush;
Brian Carlstrom916e74e2011-09-23 11:42:01 -07002346
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002347 os << StringPrintf("dex_instruction_bytes = %zd\n", dex_instruction_bytes)
2348 << StringPrintf("managed_code_bytes expansion = %.2f (ignoring deduplication %.2f)\n\n",
Brian Carlstrom2ec65202014-03-03 15:16:37 -08002349 static_cast<double>(managed_code_bytes) /
2350 static_cast<double>(dex_instruction_bytes),
Elliott Hughesc073b072012-05-24 19:29:17 -07002351 static_cast<double>(managed_code_bytes_ignoring_deduplication) /
Elliott Hughescf44e6f2012-05-24 19:42:18 -07002352 static_cast<double>(dex_instruction_bytes))
Elliott Hughesc073b072012-05-24 19:29:17 -07002353 << std::flush;
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08002354
2355 DumpOutliers(os);
Brian Carlstrom916e74e2011-09-23 11:42:01 -07002356 }
2357 } stats_;
2358
2359 private:
Ian Rogers0d2d3782012-04-10 11:09:18 -07002360 enum {
2361 // Number of bytes for a constructor to be considered large. Based on the 1000 basic block
2362 // threshold, we assume 2 bytes per instruction and 2 instructions per block.
2363 kLargeConstructorDexBytes = 4000,
2364 // Number of bytes for a method to be considered large. Based on the 4000 basic block
2365 // threshold, we assume 2 bytes per instruction and 2 instructions per block.
2366 kLargeMethodDexBytes = 16000
2367 };
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01002368
2369 // For performance, use the *os_ directly for anything that doesn't need indentation
2370 // and prepare an indentation stream with default indentation 1.
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002371 std::ostream* os_;
Vladimir Marko8f1e08a2015-06-26 12:06:30 +01002372 VariableIndentationOutputStream vios_;
2373 ScopedIndentation indent1_;
2374
Ian Rogers1d54e732013-05-02 21:10:01 -07002375 gc::space::ImageSpace& image_space_;
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08002376 const ImageHeader& image_header_;
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07002377 std::unique_ptr<OatDumper> oat_dumper_;
Andreas Gampedf2bb1f2015-05-04 18:25:23 -07002378 OatDumperOptions* oat_dumper_options_;
Vladimir Marko05792b92015-08-03 11:56:49 +01002379 std::set<mirror::Object*> dex_caches_;
Elliott Hughesd1bb4f62011-09-23 14:09:45 -07002380
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08002381 DISALLOW_COPY_AND_ASSIGN(ImageDumper);
Brian Carlstrom78128a62011-09-15 17:21:19 -07002382};
2383
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -08002384static int DumpImage(gc::space::ImageSpace* image_space,
2385 OatDumperOptions* options,
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07002386 std::ostream* os) REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -08002387 const ImageHeader& image_header = image_space->GetImageHeader();
2388 if (!image_header.IsValid()) {
2389 fprintf(stderr, "Invalid image header %s\n", image_space->GetImageLocation().c_str());
2390 return EXIT_FAILURE;
2391 }
2392 ImageDumper image_dumper(os, *image_space, image_header, options);
2393 if (!image_dumper.Dump()) {
2394 return EXIT_FAILURE;
2395 }
2396 return EXIT_SUCCESS;
2397}
2398
2399static int DumpImages(Runtime* runtime, OatDumperOptions* options, std::ostream* os) {
Andreas Gampe00b25f32014-09-17 21:49:05 -07002400 // Dumping the image, no explicit class loader.
Mathieu Chartier9865bde2015-12-21 09:58:16 -08002401 ScopedNullHandle<mirror::ClassLoader> null_class_loader;
Andreas Gampe00b25f32014-09-17 21:49:05 -07002402 options->class_loader_ = &null_class_loader;
2403
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002404 ScopedObjectAccess soa(Thread::Current());
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -08002405 if (options->app_image_ != nullptr) {
2406 if (options->app_oat_ == nullptr) {
2407 LOG(ERROR) << "Can not dump app image without app oat file";
Jeff Haodcdc85b2015-12-04 14:06:18 -08002408 return EXIT_FAILURE;
2409 }
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -08002410 // We can't know if the app image is 32 bits yet, but it contains pointers into the oat file.
2411 // We need to map the oat file in the low 4gb or else the fixup wont be able to fit oat file
2412 // pointers into 32 bit pointer sized ArtMethods.
2413 std::string error_msg;
2414 std::unique_ptr<OatFile> oat_file(OatFile::Open(options->app_oat_,
2415 options->app_oat_,
2416 nullptr,
2417 nullptr,
2418 false,
2419 /*low_4gb*/true,
2420 nullptr,
2421 &error_msg));
2422 if (oat_file == nullptr) {
2423 LOG(ERROR) << "Failed to open oat file " << options->app_oat_ << " with error " << error_msg;
Jeff Haodcdc85b2015-12-04 14:06:18 -08002424 return EXIT_FAILURE;
2425 }
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -08002426 std::unique_ptr<gc::space::ImageSpace> space(
2427 gc::space::ImageSpace::CreateFromAppImage(options->app_image_, oat_file.get(), &error_msg));
2428 if (space == nullptr) {
2429 LOG(ERROR) << "Failed to open app image " << options->app_image_ << " with error "
2430 << error_msg;
2431 }
2432 // Open dex files for the image.
2433 std::vector<std::unique_ptr<const DexFile>> dex_files;
2434 if (!runtime->GetClassLinker()->OpenImageDexFiles(space.get(), &dex_files, &error_msg)) {
2435 LOG(ERROR) << "Failed to open app image dex files " << options->app_image_ << " with error "
2436 << error_msg;
2437 }
2438 // Dump the actual image.
2439 int result = DumpImage(space.get(), options, os);
2440 if (result != EXIT_SUCCESS) {
2441 return result;
2442 }
2443 // Fall through to dump the boot images.
2444 }
2445
2446 gc::Heap* heap = runtime->GetHeap();
2447 CHECK(heap->HasBootImageSpace()) << "No image spaces";
2448 for (gc::space::ImageSpace* image_space : heap->GetBootImageSpaces()) {
2449 int result = DumpImage(image_space, options, os);
2450 if (result != EXIT_SUCCESS) {
2451 return result;
2452 }
Brian Carlstrom78128a62011-09-15 17:21:19 -07002453 }
Jeff Haodcdc85b2015-12-04 14:06:18 -08002454 return EXIT_SUCCESS;
Brian Carlstrom78128a62011-09-15 17:21:19 -07002455}
2456
Andreas Gampeebfc1ac2016-09-29 19:50:27 -07002457static jobject InstallOatFile(Runtime* runtime,
2458 std::unique_ptr<OatFile> oat_file,
2459 std::vector<const DexFile*>* class_path)
2460 REQUIRES_SHARED(Locks::mutator_lock_) {
Andreas Gampe00b25f32014-09-17 21:49:05 -07002461 Thread* self = Thread::Current();
2462 CHECK(self != nullptr);
2463 // Need well-known-classes.
2464 WellKnownClasses::Init(self->GetJniEnv());
2465
2466 // Need to register dex files to get a working dex cache.
Andreas Gampeebfc1ac2016-09-29 19:50:27 -07002467 OatFile* oat_file_ptr = oat_file.get();
Andreas Gampe00b25f32014-09-17 21:49:05 -07002468 ClassLinker* class_linker = runtime->GetClassLinker();
Andreas Gampeebfc1ac2016-09-29 19:50:27 -07002469 runtime->GetOatFileManager().RegisterOatFile(std::move(oat_file));
2470 for (const OatFile::OatDexFile* odf : oat_file_ptr->GetOatDexFiles()) {
Andreas Gampe00b25f32014-09-17 21:49:05 -07002471 std::string error_msg;
Mathieu Chartierac8f4392015-08-27 13:54:20 -07002472 const DexFile* const dex_file = OpenDexFile(odf, &error_msg);
Andreas Gampe00b25f32014-09-17 21:49:05 -07002473 CHECK(dex_file != nullptr) << error_msg;
Mathieu Chartierf284d442016-06-02 11:48:30 -07002474 class_linker->RegisterDexFile(*dex_file, nullptr);
Andreas Gampeebfc1ac2016-09-29 19:50:27 -07002475 class_path->push_back(dex_file);
Andreas Gampe00b25f32014-09-17 21:49:05 -07002476 }
2477
Andreas Gampeebfc1ac2016-09-29 19:50:27 -07002478 // Need a class loader. Fake that we're a compiler.
2479 // Note: this will run initializers through the unstarted runtime, so make sure it's
2480 // initialized.
2481 interpreter::UnstartedRuntime::Initialize();
2482
2483 jobject class_loader = class_linker->CreatePathClassLoader(self, *class_path);
2484
2485 return class_loader;
2486}
2487
2488static int DumpOatWithRuntime(Runtime* runtime,
2489 std::unique_ptr<OatFile> oat_file,
2490 OatDumperOptions* options,
2491 std::ostream* os) {
2492 CHECK(runtime != nullptr && oat_file != nullptr && options != nullptr);
2493 ScopedObjectAccess soa(Thread::Current());
2494
2495 OatFile* oat_file_ptr = oat_file.get();
2496 std::vector<const DexFile*> class_path;
2497 jobject class_loader = InstallOatFile(runtime, std::move(oat_file), &class_path);
Andreas Gampe00b25f32014-09-17 21:49:05 -07002498
2499 // Use the class loader while dumping.
Andreas Gampeebfc1ac2016-09-29 19:50:27 -07002500 StackHandleScope<1> scope(soa.Self());
Andreas Gampe00b25f32014-09-17 21:49:05 -07002501 Handle<mirror::ClassLoader> loader_handle = scope.NewHandle(
Mathieu Chartier0795f232016-09-27 18:43:30 -07002502 soa.Decode<mirror::ClassLoader>(class_loader));
Andreas Gampe00b25f32014-09-17 21:49:05 -07002503 options->class_loader_ = &loader_handle;
2504
Andreas Gampeebfc1ac2016-09-29 19:50:27 -07002505 OatDumper oat_dumper(*oat_file_ptr, *options);
Andreas Gampe00b25f32014-09-17 21:49:05 -07002506 bool success = oat_dumper.Dump(*os);
2507 return (success) ? EXIT_SUCCESS : EXIT_FAILURE;
2508}
2509
2510static int DumpOatWithoutRuntime(OatFile* oat_file, OatDumperOptions* options, std::ostream* os) {
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -08002511 CHECK(oat_file != nullptr && options != nullptr);
Andreas Gampe00b25f32014-09-17 21:49:05 -07002512 // No image = no class loader.
Mathieu Chartier9865bde2015-12-21 09:58:16 -08002513 ScopedNullHandle<mirror::ClassLoader> null_class_loader;
Andreas Gampe00b25f32014-09-17 21:49:05 -07002514 options->class_loader_ = &null_class_loader;
2515
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -08002516 OatDumper oat_dumper(*oat_file, *options);
Andreas Gampe00b25f32014-09-17 21:49:05 -07002517 bool success = oat_dumper.Dump(*os);
2518 return (success) ? EXIT_SUCCESS : EXIT_FAILURE;
2519}
2520
2521static int DumpOat(Runtime* runtime, const char* oat_filename, OatDumperOptions* options,
2522 std::ostream* os) {
2523 std::string error_msg;
Andreas Gampeebfc1ac2016-09-29 19:50:27 -07002524 std::unique_ptr<OatFile> oat_file(OatFile::Open(oat_filename,
2525 oat_filename,
2526 nullptr,
2527 nullptr,
2528 false,
2529 /*low_4gb*/false,
2530 nullptr,
2531 &error_msg));
Andreas Gampe00b25f32014-09-17 21:49:05 -07002532 if (oat_file == nullptr) {
2533 fprintf(stderr, "Failed to open oat file from '%s': %s\n", oat_filename, error_msg.c_str());
2534 return EXIT_FAILURE;
2535 }
2536
2537 if (runtime != nullptr) {
Andreas Gampeebfc1ac2016-09-29 19:50:27 -07002538 return DumpOatWithRuntime(runtime, std::move(oat_file), options, os);
Andreas Gampe00b25f32014-09-17 21:49:05 -07002539 } else {
Andreas Gampeebfc1ac2016-09-29 19:50:27 -07002540 return DumpOatWithoutRuntime(oat_file.get(), options, os);
Andreas Gampe00b25f32014-09-17 21:49:05 -07002541 }
2542}
2543
David Srbecky2fdd03c2016-03-10 15:32:37 +00002544static int SymbolizeOat(const char* oat_filename, std::string& output_name, bool no_bits) {
Andreas Gampe00b25f32014-09-17 21:49:05 -07002545 std::string error_msg;
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -08002546 OatFile* oat_file = OatFile::Open(oat_filename,
2547 oat_filename,
2548 nullptr,
2549 nullptr,
2550 false,
2551 /*low_4gb*/false,
2552 nullptr,
2553 &error_msg);
Andreas Gampe00b25f32014-09-17 21:49:05 -07002554 if (oat_file == nullptr) {
2555 fprintf(stderr, "Failed to open oat file from '%s': %s\n", oat_filename, error_msg.c_str());
2556 return EXIT_FAILURE;
2557 }
2558
Andreas Gampe2d8614b2016-03-07 16:31:34 -08002559 bool result;
2560 // Try to produce an ELF file of the same type. This is finicky, as we have used 32-bit ELF
2561 // files for 64-bit code in the past.
2562 if (Is64BitInstructionSet(oat_file->GetOatHeader().GetInstructionSet())) {
David Srbecky2fdd03c2016-03-10 15:32:37 +00002563 OatSymbolizer<ElfTypes64> oat_symbolizer(oat_file, output_name, no_bits);
Andreas Gampe2d8614b2016-03-07 16:31:34 -08002564 result = oat_symbolizer.Symbolize();
2565 } else {
David Srbecky2fdd03c2016-03-10 15:32:37 +00002566 OatSymbolizer<ElfTypes32> oat_symbolizer(oat_file, output_name, no_bits);
Andreas Gampe2d8614b2016-03-07 16:31:34 -08002567 result = oat_symbolizer.Symbolize();
2568 }
2569 if (!result) {
Andreas Gampe00b25f32014-09-17 21:49:05 -07002570 fprintf(stderr, "Failed to symbolize\n");
2571 return EXIT_FAILURE;
2572 }
2573
2574 return EXIT_SUCCESS;
2575}
2576
Andreas Gampe9fded872016-09-25 16:08:35 -07002577class IMTDumper {
2578 public:
Andreas Gampeebfc1ac2016-09-29 19:50:27 -07002579 static bool Dump(Runtime* runtime,
2580 const std::string& imt_file,
2581 bool dump_imt_stats,
2582 const char* oat_filename) {
2583 Thread* self = Thread::Current();
2584
2585 ScopedObjectAccess soa(self);
2586 StackHandleScope<1> scope(self);
2587 MutableHandle<mirror::ClassLoader> class_loader = scope.NewHandle<mirror::ClassLoader>(nullptr);
2588 std::vector<const DexFile*> class_path;
2589
2590 if (oat_filename != nullptr) {
2591 std::string error_msg;
2592 std::unique_ptr<OatFile> oat_file(OatFile::Open(oat_filename,
2593 oat_filename,
2594 nullptr,
2595 nullptr,
2596 false,
2597 /*low_4gb*/false,
2598 nullptr,
2599 &error_msg));
2600 if (oat_file == nullptr) {
2601 fprintf(stderr, "Failed to open oat file from '%s': %s\n", oat_filename, error_msg.c_str());
2602 return false;
2603 }
2604
2605 class_loader.Assign(soa.Decode<mirror::ClassLoader>(
2606 InstallOatFile(runtime, std::move(oat_file), &class_path)));
2607 } else {
2608 class_loader.Assign(nullptr); // Boot classloader. Just here for explicit documentation.
2609 class_path = runtime->GetClassLinker()->GetBootClassPath();
2610 }
2611
2612 if (!imt_file.empty()) {
2613 return DumpImt(runtime, imt_file, class_loader);
2614 }
2615
2616 if (dump_imt_stats) {
2617 return DumpImtStats(runtime, class_path, class_loader);
2618 }
2619
2620 LOG(FATAL) << "Should not reach here";
2621 UNREACHABLE();
2622 }
2623
2624 private:
2625 static bool DumpImt(Runtime* runtime,
2626 const std::string& imt_file,
2627 Handle<mirror::ClassLoader> h_class_loader)
2628 REQUIRES_SHARED(Locks::mutator_lock_) {
Andreas Gampe9fded872016-09-25 16:08:35 -07002629 std::vector<std::string> lines = ReadCommentedInputFromFile(imt_file);
2630 std::unordered_set<std::string> prepared;
2631
2632 for (const std::string& line : lines) {
2633 // A line should be either a class descriptor, in which case we will dump the complete IMT,
2634 // or a class descriptor and an interface method, in which case we will lookup the method,
2635 // determine its IMT slot, and check the class' IMT.
2636 size_t first_space = line.find(' ');
2637 if (first_space == std::string::npos) {
Andreas Gampeebfc1ac2016-09-29 19:50:27 -07002638 DumpIMTForClass(runtime, line, h_class_loader, &prepared);
Andreas Gampe9fded872016-09-25 16:08:35 -07002639 } else {
2640 DumpIMTForMethod(runtime,
2641 line.substr(0, first_space),
2642 line.substr(first_space + 1, std::string::npos),
Andreas Gampeebfc1ac2016-09-29 19:50:27 -07002643 h_class_loader,
Andreas Gampe9fded872016-09-25 16:08:35 -07002644 &prepared);
2645 }
2646 std::cerr << std::endl;
2647 }
2648
2649 return true;
2650 }
2651
Andreas Gampeebfc1ac2016-09-29 19:50:27 -07002652 static bool DumpImtStats(Runtime* runtime,
2653 const std::vector<const DexFile*>& dex_files,
2654 Handle<mirror::ClassLoader> h_class_loader)
2655 REQUIRES_SHARED(Locks::mutator_lock_) {
2656 size_t without_imt = 0;
2657 size_t with_imt = 0;
Andreas Gampe9fded872016-09-25 16:08:35 -07002658 std::map<size_t, size_t> histogram;
2659
2660 ClassLinker* class_linker = runtime->GetClassLinker();
2661 const PointerSize pointer_size = class_linker->GetImagePointerSize();
2662 std::unordered_set<std::string> prepared;
2663
2664 Thread* self = Thread::Current();
Andreas Gampe9fded872016-09-25 16:08:35 -07002665 StackHandleScope<1> scope(self);
2666 MutableHandle<mirror::Class> h_klass(scope.NewHandle<mirror::Class>(nullptr));
2667
2668 for (const DexFile* dex_file : dex_files) {
2669 for (uint32_t class_def_index = 0;
Andreas Gampeebfc1ac2016-09-29 19:50:27 -07002670 class_def_index != dex_file->NumClassDefs();
2671 ++class_def_index) {
Andreas Gampe9fded872016-09-25 16:08:35 -07002672 const DexFile::ClassDef& class_def = dex_file->GetClassDef(class_def_index);
2673 const char* descriptor = dex_file->GetClassDescriptor(class_def);
Andreas Gampeebfc1ac2016-09-29 19:50:27 -07002674 h_klass.Assign(class_linker->FindClass(self, descriptor, h_class_loader));
Andreas Gampe9fded872016-09-25 16:08:35 -07002675 if (h_klass.Get() == nullptr) {
2676 std::cerr << "Warning: could not load " << descriptor << std::endl;
2677 continue;
2678 }
2679
2680 if (HasNoIMT(runtime, h_klass, pointer_size, &prepared)) {
Andreas Gampeebfc1ac2016-09-29 19:50:27 -07002681 without_imt++;
Andreas Gampe9fded872016-09-25 16:08:35 -07002682 continue;
2683 }
2684
2685 ImTable* im_table = PrepareAndGetImTable(runtime, h_klass, pointer_size, &prepared);
2686 if (im_table == nullptr) {
2687 // Should not happen, but accept.
Andreas Gampeebfc1ac2016-09-29 19:50:27 -07002688 without_imt++;
Andreas Gampe9fded872016-09-25 16:08:35 -07002689 continue;
2690 }
2691
Andreas Gampeebfc1ac2016-09-29 19:50:27 -07002692 with_imt++;
Andreas Gampe9fded872016-09-25 16:08:35 -07002693 for (size_t imt_index = 0; imt_index != ImTable::kSize; ++imt_index) {
2694 ArtMethod* ptr = im_table->Get(imt_index, pointer_size);
2695 if (ptr->IsRuntimeMethod()) {
2696 if (ptr->IsImtUnimplementedMethod()) {
2697 histogram[0]++;
2698 } else {
2699 ImtConflictTable* current_table = ptr->GetImtConflictTable(pointer_size);
2700 histogram[current_table->NumEntries(pointer_size)]++;
2701 }
2702 } else {
2703 histogram[1]++;
2704 }
2705 }
2706 }
2707 }
2708
2709 std::cerr << "IMT stats:"
2710 << std::endl << std::endl;
2711
Andreas Gampeebfc1ac2016-09-29 19:50:27 -07002712 std::cerr << " " << with_imt << " classes with IMT."
Andreas Gampe9fded872016-09-25 16:08:35 -07002713 << std::endl << std::endl;
Andreas Gampeebfc1ac2016-09-29 19:50:27 -07002714 std::cerr << " " << without_imt << " classes without IMT (or copy from Object)."
Andreas Gampe9fded872016-09-25 16:08:35 -07002715 << std::endl << std::endl;
2716
2717 double sum_one = 0;
2718 size_t count_one = 0;
2719
2720 std::cerr << " " << "IMT histogram" << std::endl;
2721 for (auto& bucket : histogram) {
2722 std::cerr << " " << bucket.first << " " << bucket.second << std::endl;
2723 if (bucket.first > 0) {
2724 sum_one += bucket.second * bucket.first;
2725 count_one += bucket.second;
2726 }
2727 }
2728
2729 double count_zero = count_one + histogram[0];
2730 std::cerr << " Stats:" << std::endl;
2731 std::cerr << " Average depth (including empty): " << (sum_one / count_zero) << std::endl;
2732 std::cerr << " Average depth (excluding empty): " << (sum_one / count_one) << std::endl;
2733
2734 return true;
2735 }
2736
Andreas Gampeebfc1ac2016-09-29 19:50:27 -07002737 // Return whether the given class has no IMT (or the one shared with java.lang.Object).
Andreas Gampe9fded872016-09-25 16:08:35 -07002738 static bool HasNoIMT(Runtime* runtime,
2739 Handle<mirror::Class> klass,
2740 const PointerSize pointer_size,
2741 std::unordered_set<std::string>* prepared)
2742 REQUIRES_SHARED(Locks::mutator_lock_) {
2743 if (klass->IsObjectClass() || !klass->ShouldHaveImt()) {
2744 return true;
2745 }
2746
2747 if (klass->GetImt(pointer_size) == nullptr) {
2748 PrepareClass(runtime, klass, prepared);
2749 }
2750
2751 mirror::Class* object_class = mirror::Class::GetJavaLangClass()->GetSuperClass();
2752 DCHECK(object_class->IsObjectClass());
2753
2754 bool result = klass->GetImt(pointer_size) == object_class->GetImt(pointer_size);
2755
2756 if (klass->GetIfTable() == nullptr) {
2757 DCHECK(result);
2758 }
2759
2760 return result;
2761 }
2762
2763 static void PrintTable(ImtConflictTable* table, PointerSize pointer_size)
2764 REQUIRES_SHARED(Locks::mutator_lock_) {
2765 if (table == nullptr) {
2766 std::cerr << " <No IMT?>" << std::endl;
2767 return;
2768 }
2769 size_t table_index = 0;
2770 for (;;) {
2771 ArtMethod* ptr = table->GetInterfaceMethod(table_index, pointer_size);
2772 if (ptr == nullptr) {
2773 return;
2774 }
2775 table_index++;
David Sehr709b0702016-10-13 09:12:37 -07002776 std::cerr << " " << ptr->PrettyMethod(true) << std::endl;
Andreas Gampe9fded872016-09-25 16:08:35 -07002777 }
2778 }
2779
2780 static ImTable* PrepareAndGetImTable(Runtime* runtime,
2781 Thread* self,
Andreas Gampeebfc1ac2016-09-29 19:50:27 -07002782 Handle<mirror::ClassLoader> h_loader,
Andreas Gampe9fded872016-09-25 16:08:35 -07002783 const std::string& class_name,
2784 const PointerSize pointer_size,
2785 mirror::Class** klass_out,
2786 std::unordered_set<std::string>* prepared)
2787 REQUIRES_SHARED(Locks::mutator_lock_) {
2788 if (class_name.empty()) {
2789 return nullptr;
2790 }
2791
2792 std::string descriptor;
2793 if (class_name[0] == 'L') {
2794 descriptor = class_name;
2795 } else {
2796 descriptor = DotToDescriptor(class_name.c_str());
2797 }
2798
Andreas Gampeebfc1ac2016-09-29 19:50:27 -07002799 mirror::Class* klass = runtime->GetClassLinker()->FindClass(self, descriptor.c_str(), h_loader);
Andreas Gampe9fded872016-09-25 16:08:35 -07002800
2801 if (klass == nullptr) {
2802 self->ClearException();
2803 std::cerr << "Did not find " << class_name << std::endl;
2804 *klass_out = nullptr;
2805 return nullptr;
2806 }
2807
2808 StackHandleScope<1> scope(Thread::Current());
2809 Handle<mirror::Class> h_klass = scope.NewHandle<mirror::Class>(klass);
2810
2811 ImTable* ret = PrepareAndGetImTable(runtime, h_klass, pointer_size, prepared);
2812 *klass_out = h_klass.Get();
2813 return ret;
2814 }
2815
2816 static ImTable* PrepareAndGetImTable(Runtime* runtime,
2817 Handle<mirror::Class> h_klass,
2818 const PointerSize pointer_size,
2819 std::unordered_set<std::string>* prepared)
2820 REQUIRES_SHARED(Locks::mutator_lock_) {
2821 PrepareClass(runtime, h_klass, prepared);
2822 return h_klass->GetImt(pointer_size);
2823 }
2824
2825 static void DumpIMTForClass(Runtime* runtime,
2826 const std::string& class_name,
Andreas Gampeebfc1ac2016-09-29 19:50:27 -07002827 Handle<mirror::ClassLoader> h_loader,
2828 std::unordered_set<std::string>* prepared)
2829 REQUIRES_SHARED(Locks::mutator_lock_) {
Andreas Gampe9fded872016-09-25 16:08:35 -07002830 const PointerSize pointer_size = runtime->GetClassLinker()->GetImagePointerSize();
2831 mirror::Class* klass;
Andreas Gampeebfc1ac2016-09-29 19:50:27 -07002832 ImTable* imt = PrepareAndGetImTable(runtime,
2833 Thread::Current(),
2834 h_loader,
2835 class_name,
2836 pointer_size,
2837 &klass,
2838 prepared);
Andreas Gampe9fded872016-09-25 16:08:35 -07002839 if (imt == nullptr) {
2840 return;
2841 }
2842
2843 std::cerr << class_name << std::endl << " IMT:" << std::endl;
2844 for (size_t index = 0; index < ImTable::kSize; ++index) {
2845 std::cerr << " " << index << ":" << std::endl;
2846 ArtMethod* ptr = imt->Get(index, pointer_size);
2847 if (ptr->IsRuntimeMethod()) {
2848 if (ptr->IsImtUnimplementedMethod()) {
2849 std::cerr << " <empty>" << std::endl;
2850 } else {
2851 ImtConflictTable* current_table = ptr->GetImtConflictTable(pointer_size);
2852 PrintTable(current_table, pointer_size);
2853 }
2854 } else {
David Sehr709b0702016-10-13 09:12:37 -07002855 std::cerr << " " << ptr->PrettyMethod(true) << std::endl;
Andreas Gampe9fded872016-09-25 16:08:35 -07002856 }
2857 }
2858
2859 std::cerr << " Interfaces:" << std::endl;
2860 // Run through iftable, find methods that slot here, see if they fit.
2861 mirror::IfTable* if_table = klass->GetIfTable();
2862 if (if_table != nullptr) {
2863 for (size_t i = 0, num_interfaces = klass->GetIfTableCount(); i < num_interfaces; ++i) {
2864 mirror::Class* iface = if_table->GetInterface(i);
2865 std::string iface_name;
2866 std::cerr << " " << iface->GetDescriptor(&iface_name) << std::endl;
2867
2868 for (ArtMethod& iface_method : iface->GetVirtualMethods(pointer_size)) {
Andreas Gampea1ff30f2016-09-27 12:19:45 -07002869 uint32_t class_hash, name_hash, signature_hash;
2870 ImTable::GetImtHashComponents(&iface_method, &class_hash, &name_hash, &signature_hash);
Andreas Gampe9fded872016-09-25 16:08:35 -07002871 uint32_t imt_slot = ImTable::GetImtIndex(&iface_method);
David Sehr709b0702016-10-13 09:12:37 -07002872 std::cerr << " " << iface_method.PrettyMethod(true)
Andreas Gampea1ff30f2016-09-27 12:19:45 -07002873 << " slot=" << imt_slot
2874 << std::hex
2875 << " class_hash=0x" << class_hash
2876 << " name_hash=0x" << name_hash
2877 << " signature_hash=0x" << signature_hash
2878 << std::dec
2879 << std::endl;
Andreas Gampe9fded872016-09-25 16:08:35 -07002880 }
2881 }
2882 }
2883 }
2884
2885 static void DumpIMTForMethod(Runtime* runtime,
2886 const std::string& class_name,
2887 const std::string& method,
Andreas Gampeebfc1ac2016-09-29 19:50:27 -07002888 Handle<mirror::ClassLoader> h_loader,
2889 std::unordered_set<std::string>* prepared)
2890 REQUIRES_SHARED(Locks::mutator_lock_) {
Andreas Gampe9fded872016-09-25 16:08:35 -07002891 const PointerSize pointer_size = runtime->GetClassLinker()->GetImagePointerSize();
2892 mirror::Class* klass;
2893 ImTable* imt = PrepareAndGetImTable(runtime,
Andreas Gampeebfc1ac2016-09-29 19:50:27 -07002894 Thread::Current(),
2895 h_loader,
Andreas Gampe9fded872016-09-25 16:08:35 -07002896 class_name,
2897 pointer_size,
2898 &klass,
2899 prepared);
2900 if (imt == nullptr) {
2901 return;
2902 }
2903
2904 std::cerr << class_name << " <" << method << ">" << std::endl;
2905 for (size_t index = 0; index < ImTable::kSize; ++index) {
2906 ArtMethod* ptr = imt->Get(index, pointer_size);
2907 if (ptr->IsRuntimeMethod()) {
2908 if (ptr->IsImtUnimplementedMethod()) {
2909 continue;
2910 }
2911
2912 ImtConflictTable* current_table = ptr->GetImtConflictTable(pointer_size);
2913 if (current_table == nullptr) {
2914 continue;
2915 }
2916
2917 size_t table_index = 0;
2918 for (;;) {
2919 ArtMethod* ptr2 = current_table->GetInterfaceMethod(table_index, pointer_size);
2920 if (ptr2 == nullptr) {
2921 break;
2922 }
2923 table_index++;
2924
David Sehr709b0702016-10-13 09:12:37 -07002925 std::string p_name = ptr2->PrettyMethod(true);
Andreas Gampe9fded872016-09-25 16:08:35 -07002926 if (StartsWith(p_name, method.c_str())) {
2927 std::cerr << " Slot "
2928 << index
2929 << " ("
2930 << current_table->NumEntries(pointer_size)
2931 << ")"
2932 << std::endl;
2933 PrintTable(current_table, pointer_size);
2934 return;
2935 }
2936 }
2937 } else {
David Sehr709b0702016-10-13 09:12:37 -07002938 std::string p_name = ptr->PrettyMethod(true);
Andreas Gampe9fded872016-09-25 16:08:35 -07002939 if (StartsWith(p_name, method.c_str())) {
2940 std::cerr << " Slot " << index << " (1)" << std::endl;
2941 std::cerr << " " << p_name << std::endl;
2942 } else {
2943 // Run through iftable, find methods that slot here, see if they fit.
2944 mirror::IfTable* if_table = klass->GetIfTable();
2945 if (if_table != nullptr) {
2946 for (size_t i = 0, num_interfaces = klass->GetIfTableCount(); i < num_interfaces; ++i) {
2947 mirror::Class* iface = if_table->GetInterface(i);
2948 size_t num_methods = iface->NumDeclaredVirtualMethods();
2949 if (num_methods > 0) {
2950 for (ArtMethod& iface_method : iface->GetMethods(pointer_size)) {
2951 if (ImTable::GetImtIndex(&iface_method) == index) {
David Sehr709b0702016-10-13 09:12:37 -07002952 std::string i_name = iface_method.PrettyMethod(true);
Andreas Gampe9fded872016-09-25 16:08:35 -07002953 if (StartsWith(i_name, method.c_str())) {
2954 std::cerr << " Slot " << index << " (1)" << std::endl;
2955 std::cerr << " " << p_name << " (" << i_name << ")" << std::endl;
2956 }
2957 }
2958 }
2959 }
2960 }
2961 }
2962 }
2963 }
2964 }
2965 }
2966
2967 // Read lines from the given stream, dropping comments and empty lines
2968 static std::vector<std::string> ReadCommentedInputStream(std::istream& in_stream) {
2969 std::vector<std::string> output;
2970 while (in_stream.good()) {
2971 std::string dot;
2972 std::getline(in_stream, dot);
2973 if (StartsWith(dot, "#") || dot.empty()) {
2974 continue;
2975 }
2976 output.push_back(dot);
2977 }
2978 return output;
2979 }
2980
2981 // Read lines from the given file, dropping comments and empty lines.
2982 static std::vector<std::string> ReadCommentedInputFromFile(const std::string& input_filename) {
2983 std::unique_ptr<std::ifstream> input_file(new std::ifstream(input_filename, std::ifstream::in));
2984 if (input_file.get() == nullptr) {
2985 LOG(ERROR) << "Failed to open input file " << input_filename;
2986 return std::vector<std::string>();
2987 }
2988 std::vector<std::string> result = ReadCommentedInputStream(*input_file);
2989 input_file->close();
2990 return result;
2991 }
2992
2993 // Prepare a class, i.e., ensure it has a filled IMT. Will do so recursively for superclasses,
2994 // and note in the given set that the work was done.
2995 static void PrepareClass(Runtime* runtime,
2996 Handle<mirror::Class> h_klass,
2997 std::unordered_set<std::string>* done)
2998 REQUIRES_SHARED(Locks::mutator_lock_) {
2999 if (!h_klass->ShouldHaveImt()) {
3000 return;
3001 }
3002
3003 std::string name;
3004 name = h_klass->GetDescriptor(&name);
3005
3006 if (done->find(name) != done->end()) {
3007 return;
3008 }
3009 done->insert(name);
3010
3011 if (h_klass->HasSuperClass()) {
3012 StackHandleScope<1> h(Thread::Current());
3013 PrepareClass(runtime, h.NewHandle<mirror::Class>(h_klass->GetSuperClass()), done);
3014 }
3015
3016 if (!h_klass->IsTemp()) {
3017 runtime->GetClassLinker()->FillIMTAndConflictTables(h_klass.Get());
3018 }
3019 }
3020};
3021
Igor Murashkin37743352014-11-13 14:38:00 -08003022struct OatdumpArgs : public CmdlineArgs {
3023 protected:
3024 using Base = CmdlineArgs;
Andreas Gampe00b25f32014-09-17 21:49:05 -07003025
Igor Murashkin37743352014-11-13 14:38:00 -08003026 virtual ParseStatus ParseCustom(const StringPiece& option,
3027 std::string* error_msg) OVERRIDE {
3028 {
3029 ParseStatus base_parse = Base::ParseCustom(option, error_msg);
3030 if (base_parse != kParseUnknownArgument) {
3031 return base_parse;
Andreas Gampe00b25f32014-09-17 21:49:05 -07003032 }
3033 }
3034
Igor Murashkin37743352014-11-13 14:38:00 -08003035 if (option.starts_with("--oat-file=")) {
3036 oat_filename_ = option.substr(strlen("--oat-file=")).data();
3037 } else if (option.starts_with("--image=")) {
3038 image_location_ = option.substr(strlen("--image=")).data();
Igor Murashkin37743352014-11-13 14:38:00 -08003039 } else if (option == "--no-dump:vmap") {
3040 dump_vmap_ = false;
Roland Levillainf2650d12015-05-28 14:53:28 +01003041 } else if (option =="--dump:code_info_stack_maps") {
3042 dump_code_info_stack_maps_ = true;
Igor Murashkin37743352014-11-13 14:38:00 -08003043 } else if (option == "--no-disassemble") {
3044 disassemble_code_ = false;
David Brazdilc03d7b62016-03-02 12:18:03 +00003045 } else if (option =="--header-only") {
3046 dump_header_only_ = true;
Igor Murashkin37743352014-11-13 14:38:00 -08003047 } else if (option.starts_with("--symbolize=")) {
3048 oat_filename_ = option.substr(strlen("--symbolize=")).data();
3049 symbolize_ = true;
David Srbecky2fdd03c2016-03-10 15:32:37 +00003050 } else if (option.starts_with("--only-keep-debug")) {
3051 only_keep_debug_ = true;
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -08003052 } else if (option.starts_with("--class-filter=")) {
3053 class_filter_ = option.substr(strlen("--class-filter=")).data();
Igor Murashkin37743352014-11-13 14:38:00 -08003054 } else if (option.starts_with("--method-filter=")) {
3055 method_filter_ = option.substr(strlen("--method-filter=")).data();
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -08003056 } else if (option.starts_with("--list-classes")) {
3057 list_classes_ = true;
3058 } else if (option.starts_with("--list-methods")) {
3059 list_methods_ = true;
3060 } else if (option.starts_with("--export-dex-to=")) {
3061 export_dex_location_ = option.substr(strlen("--export-dex-to=")).data();
3062 } else if (option.starts_with("--addr2instr=")) {
3063 if (!ParseUint(option.substr(strlen("--addr2instr=")).data(), &addr2instr_)) {
3064 *error_msg = "Address conversion failed";
3065 return kParseError;
3066 }
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -08003067 } else if (option.starts_with("--app-image=")) {
3068 app_image_ = option.substr(strlen("--app-image=")).data();
3069 } else if (option.starts_with("--app-oat=")) {
3070 app_oat_ = option.substr(strlen("--app-oat=")).data();
Andreas Gampe9fded872016-09-25 16:08:35 -07003071 } else if (option.starts_with("--dump-imt=")) {
3072 imt_dump_ = option.substr(strlen("--dump-imt=")).data();
3073 } else if (option == "--dump-imt-stats") {
3074 imt_stat_dump_ = true;
Igor Murashkin37743352014-11-13 14:38:00 -08003075 } else {
3076 return kParseUnknownArgument;
Andreas Gampe00b25f32014-09-17 21:49:05 -07003077 }
3078
Igor Murashkin37743352014-11-13 14:38:00 -08003079 return kParseOk;
Andreas Gampe00b25f32014-09-17 21:49:05 -07003080 }
3081
Igor Murashkin37743352014-11-13 14:38:00 -08003082 virtual ParseStatus ParseChecks(std::string* error_msg) OVERRIDE {
3083 // Infer boot image location from the image location if possible.
3084 if (boot_image_location_ == nullptr) {
3085 boot_image_location_ = image_location_;
3086 }
3087
3088 // Perform the parent checks.
3089 ParseStatus parent_checks = Base::ParseChecks(error_msg);
3090 if (parent_checks != kParseOk) {
3091 return parent_checks;
3092 }
3093
3094 // Perform our own checks.
3095 if (image_location_ == nullptr && oat_filename_ == nullptr) {
3096 *error_msg = "Either --image or --oat-file must be specified";
3097 return kParseError;
3098 } else if (image_location_ != nullptr && oat_filename_ != nullptr) {
3099 *error_msg = "Either --image or --oat-file must be specified but not both";
3100 return kParseError;
3101 }
3102
3103 return kParseOk;
3104 }
3105
3106 virtual std::string GetUsage() const {
3107 std::string usage;
3108
3109 usage +=
3110 "Usage: oatdump [options] ...\n"
3111 " Example: oatdump --image=$ANDROID_PRODUCT_OUT/system/framework/boot.art\n"
3112 " Example: adb shell oatdump --image=/system/framework/boot.art\n"
3113 "\n"
3114 // Either oat-file or image is required.
3115 " --oat-file=<file.oat>: specifies an input oat filename.\n"
3116 " Example: --oat-file=/system/framework/boot.oat\n"
3117 "\n"
3118 " --image=<file.art>: specifies an input image location.\n"
3119 " Example: --image=/system/framework/boot.art\n"
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -08003120 "\n"
3121 " --app-image=<file.art>: specifies an input app image. Must also have a specified\n"
3122 " boot image and app oat file.\n"
3123 " Example: --app-image=app.art\n"
3124 "\n"
3125 " --app-oat=<file.odex>: specifies an input app oat.\n"
3126 " Example: --app-oat=app.odex\n"
Igor Murashkin37743352014-11-13 14:38:00 -08003127 "\n";
3128
3129 usage += Base::GetUsage();
3130
3131 usage += // Optional.
Igor Murashkin37743352014-11-13 14:38:00 -08003132 " --no-dump:vmap may be used to disable vmap dumping.\n"
3133 " Example: --no-dump:vmap\n"
3134 "\n"
Roland Levillainf2650d12015-05-28 14:53:28 +01003135 " --dump:code_info_stack_maps enables dumping of stack maps in CodeInfo sections.\n"
3136 " Example: --dump:code_info_stack_maps\n"
3137 "\n"
Igor Murashkin37743352014-11-13 14:38:00 -08003138 " --no-disassemble may be used to disable disassembly.\n"
3139 " Example: --no-disassemble\n"
3140 "\n"
David Brazdilc03d7b62016-03-02 12:18:03 +00003141 " --header-only may be used to print only the oat header.\n"
3142 " Example: --header-only\n"
3143 "\n"
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -08003144 " --list-classes may be used to list target file classes (can be used with filters).\n"
3145 " Example: --list-classes\n"
3146 " Example: --list-classes --class-filter=com.example.foo\n"
3147 "\n"
3148 " --list-methods may be used to list target file methods (can be used with filters).\n"
3149 " Example: --list-methods\n"
3150 " Example: --list-methods --class-filter=com.example --method-filter=foo\n"
3151 "\n"
3152 " --symbolize=<file.oat>: output a copy of file.oat with elf symbols included.\n"
3153 " Example: --symbolize=/system/framework/boot.oat\n"
3154 "\n"
David Srbecky2fdd03c2016-03-10 15:32:37 +00003155 " --only-keep-debug<file.oat>: Modifies the behaviour of --symbolize so that\n"
3156 " .rodata and .text sections are omitted in the output file to save space.\n"
3157 " Example: --symbolize=/system/framework/boot.oat --only-keep-debug\n"
3158 "\n"
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -08003159 " --class-filter=<class name>: only dumps classes that contain the filter.\n"
3160 " Example: --class-filter=com.example.foo\n"
3161 "\n"
Igor Murashkin37743352014-11-13 14:38:00 -08003162 " --method-filter=<method name>: only dumps methods that contain the filter.\n"
3163 " Example: --method-filter=foo\n"
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -08003164 "\n"
3165 " --export-dex-to=<directory>: may be used to export oat embedded dex files.\n"
3166 " Example: --export-dex-to=/data/local/tmp\n"
3167 "\n"
3168 " --addr2instr=<address>: output matching method disassembled code from relative\n"
3169 " address (e.g. PC from crash dump)\n"
3170 " Example: --addr2instr=0x00001a3b\n"
Andreas Gampe9fded872016-09-25 16:08:35 -07003171 "\n"
3172 " --dump-imt=<file.txt>: output IMT collisions (if any) for the given receiver\n"
3173 " types and interface methods in the given file. The file\n"
Andreas Gampeebfc1ac2016-09-29 19:50:27 -07003174 " is read line-wise, where each line should either be a class\n"
Andreas Gampe9fded872016-09-25 16:08:35 -07003175 " name or descriptor, or a class name/descriptor and a prefix\n"
Andreas Gampeebfc1ac2016-09-29 19:50:27 -07003176 " of a complete method name (separated by a whitespace).\n"
Andreas Gampe9fded872016-09-25 16:08:35 -07003177 " Example: --dump-imt=imt.txt\n"
3178 "\n"
3179 " --dump-imt-stats: output IMT statistics for the given boot image\n"
3180 " Example: --dump-imt-stats"
Igor Murashkin37743352014-11-13 14:38:00 -08003181 "\n";
3182
3183 return usage;
3184 }
3185
3186 public:
Andreas Gampe00b25f32014-09-17 21:49:05 -07003187 const char* oat_filename_ = nullptr;
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -08003188 const char* class_filter_ = "";
Nicolas Geoffray3fcd2202014-11-12 18:02:36 +00003189 const char* method_filter_ = "";
Andreas Gampe00b25f32014-09-17 21:49:05 -07003190 const char* image_location_ = nullptr;
Andreas Gampe00b25f32014-09-17 21:49:05 -07003191 std::string elf_filename_prefix_;
Andreas Gampe9fded872016-09-25 16:08:35 -07003192 std::string imt_dump_;
Andreas Gampe00b25f32014-09-17 21:49:05 -07003193 bool dump_vmap_ = true;
Roland Levillainf2650d12015-05-28 14:53:28 +01003194 bool dump_code_info_stack_maps_ = false;
Andreas Gampe00b25f32014-09-17 21:49:05 -07003195 bool disassemble_code_ = true;
3196 bool symbolize_ = false;
David Srbecky2fdd03c2016-03-10 15:32:37 +00003197 bool only_keep_debug_ = false;
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -08003198 bool list_classes_ = false;
3199 bool list_methods_ = false;
David Brazdilc03d7b62016-03-02 12:18:03 +00003200 bool dump_header_only_ = false;
Andreas Gampe9fded872016-09-25 16:08:35 -07003201 bool imt_stat_dump_ = false;
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -08003202 uint32_t addr2instr_ = 0;
3203 const char* export_dex_location_ = nullptr;
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -08003204 const char* app_image_ = nullptr;
3205 const char* app_oat_ = nullptr;
Andreas Gampe00b25f32014-09-17 21:49:05 -07003206};
3207
Igor Murashkin37743352014-11-13 14:38:00 -08003208struct OatdumpMain : public CmdlineMain<OatdumpArgs> {
3209 virtual bool NeedsRuntime() OVERRIDE {
3210 CHECK(args_ != nullptr);
Andreas Gampe00b25f32014-09-17 21:49:05 -07003211
Igor Murashkin37743352014-11-13 14:38:00 -08003212 // If we are only doing the oat file, disable absolute_addresses. Keep them for image dumping.
3213 bool absolute_addresses = (args_->oat_filename_ == nullptr);
3214
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -08003215 oat_dumper_options_.reset(new OatDumperOptions(
Igor Murashkin37743352014-11-13 14:38:00 -08003216 args_->dump_vmap_,
Roland Levillainf2650d12015-05-28 14:53:28 +01003217 args_->dump_code_info_stack_maps_,
Igor Murashkin37743352014-11-13 14:38:00 -08003218 args_->disassemble_code_,
3219 absolute_addresses,
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -08003220 args_->class_filter_,
3221 args_->method_filter_,
3222 args_->list_classes_,
3223 args_->list_methods_,
David Brazdilc03d7b62016-03-02 12:18:03 +00003224 args_->dump_header_only_,
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -08003225 args_->export_dex_location_,
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -08003226 args_->app_image_,
3227 args_->app_oat_,
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -08003228 args_->addr2instr_));
Igor Murashkin37743352014-11-13 14:38:00 -08003229
Andreas Gampe9fded872016-09-25 16:08:35 -07003230 return (args_->boot_image_location_ != nullptr ||
3231 args_->image_location_ != nullptr ||
3232 !args_->imt_dump_.empty()) &&
Igor Murashkin37743352014-11-13 14:38:00 -08003233 !args_->symbolize_;
Andreas Gampe00b25f32014-09-17 21:49:05 -07003234 }
3235
Igor Murashkin37743352014-11-13 14:38:00 -08003236 virtual bool ExecuteWithoutRuntime() OVERRIDE {
3237 CHECK(args_ != nullptr);
Andreas Gampec24f3992014-12-17 20:40:11 -08003238 CHECK(args_->oat_filename_ != nullptr);
Andreas Gampe00b25f32014-09-17 21:49:05 -07003239
Mathieu Chartierd424d082014-10-15 10:31:46 -07003240 MemMap::Init();
Igor Murashkin37743352014-11-13 14:38:00 -08003241
Andreas Gampec24f3992014-12-17 20:40:11 -08003242 if (args_->symbolize_) {
David Srbecky2fdd03c2016-03-10 15:32:37 +00003243 // ELF has special kind of section called SHT_NOBITS which allows us to create
3244 // sections which exist but their data is omitted from the ELF file to save space.
3245 // This is what "strip --only-keep-debug" does when it creates separate ELF file
3246 // with only debug data. We use it in similar way to exclude .rodata and .text.
3247 bool no_bits = args_->only_keep_debug_;
3248 return SymbolizeOat(args_->oat_filename_, args_->output_name_, no_bits) == EXIT_SUCCESS;
Andreas Gampec24f3992014-12-17 20:40:11 -08003249 } else {
3250 return DumpOat(nullptr,
3251 args_->oat_filename_,
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -08003252 oat_dumper_options_.get(),
Andreas Gampec24f3992014-12-17 20:40:11 -08003253 args_->os_) == EXIT_SUCCESS;
3254 }
Andreas Gampe00b25f32014-09-17 21:49:05 -07003255 }
3256
Igor Murashkin37743352014-11-13 14:38:00 -08003257 virtual bool ExecuteWithRuntime(Runtime* runtime) {
3258 CHECK(args_ != nullptr);
3259
Andreas Gampeebfc1ac2016-09-29 19:50:27 -07003260 if (!args_->imt_dump_.empty() || args_->imt_stat_dump_) {
3261 return IMTDumper::Dump(runtime,
3262 args_->imt_dump_,
3263 args_->imt_stat_dump_,
3264 args_->oat_filename_);
Andreas Gampe9fded872016-09-25 16:08:35 -07003265 }
3266
Igor Murashkin37743352014-11-13 14:38:00 -08003267 if (args_->oat_filename_ != nullptr) {
3268 return DumpOat(runtime,
3269 args_->oat_filename_,
Anestis Bechtsoudis32f500d2015-02-22 22:32:57 -08003270 oat_dumper_options_.get(),
Igor Murashkin37743352014-11-13 14:38:00 -08003271 args_->os_) == EXIT_SUCCESS;
Andreas Gampe00b25f32014-09-17 21:49:05 -07003272 }
Igor Murashkin37743352014-11-13 14:38:00 -08003273
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -08003274 return DumpImages(runtime, oat_dumper_options_.get(), args_->os_) == EXIT_SUCCESS;
Andreas Gampe00b25f32014-09-17 21:49:05 -07003275 }
3276
Igor Murashkin37743352014-11-13 14:38:00 -08003277 std::unique_ptr<OatDumperOptions> oat_dumper_options_;
3278};
Andreas Gampe00b25f32014-09-17 21:49:05 -07003279
Brian Carlstrom7934ac22013-07-26 10:54:15 -07003280} // namespace art
Brian Carlstrom78128a62011-09-15 17:21:19 -07003281
3282int main(int argc, char** argv) {
Igor Murashkin37743352014-11-13 14:38:00 -08003283 art::OatdumpMain main;
3284 return main.Main(argc, argv);
Brian Carlstrom78128a62011-09-15 17:21:19 -07003285}