blob: 2e641985bdc75c8ef4785d04264fc6a6da41322e [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>
Brian Carlstrom78128a62011-09-15 17:21:19 -070022#include <string>
Andreas Gampe54fc26c2014-09-04 21:47:42 -070023#include <unordered_map>
Brian Carlstrom78128a62011-09-15 17:21:19 -070024#include <vector>
25
Elliott Hughese222ee02012-12-13 14:41:43 -080026#include "base/stringpiece.h"
Elliott Hughes76160052012-12-12 16:31:20 -080027#include "base/unix_file/fd_file.h"
Brian Carlstrom78128a62011-09-15 17:21:19 -070028#include "class_linker.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080029#include "class_linker-inl.h"
Ian Rogers4f6ad8a2013-03-18 15:27:28 -070030#include "dex_file-inl.h"
Elliott Hughese3c845c2012-02-28 17:23:01 -080031#include "dex_instruction.h"
Ian Rogers3a5c1ce2012-02-29 10:06:46 -080032#include "disassembler.h"
Andreas Gampe54fc26c2014-09-04 21:47:42 -070033#include "elf_builder.h"
Ian Rogers22d5e732014-07-15 22:23:51 -070034#include "field_helper.h"
Ian Rogers2bcb4a42012-11-08 10:39:18 -080035#include "gc_map.h"
Ian Rogers1d54e732013-05-02 21:10:01 -070036#include "gc/space/image_space.h"
37#include "gc/space/large_object_space.h"
38#include "gc/space/space-inl.h"
Brian Carlstrom78128a62011-09-15 17:21:19 -070039#include "image.h"
Ian Rogers2bcb4a42012-11-08 10:39:18 -080040#include "indenter.h"
Ian Rogers1809a722013-08-09 22:05:32 -070041#include "mapping_table.h"
Brian Carlstromea46f952013-07-30 01:26:50 -070042#include "mirror/art_field-inl.h"
43#include "mirror/art_method-inl.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080044#include "mirror/array-inl.h"
45#include "mirror/class-inl.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080046#include "mirror/object-inl.h"
47#include "mirror/object_array-inl.h"
Brian Carlstromc0a1b182014-03-04 23:19:06 -080048#include "noop_compiler_callbacks.h"
Brian Carlstrom700c8d32012-11-05 10:42:02 -080049#include "oat.h"
Vladimir Marko8a630572014-04-09 18:45:35 +010050#include "oat_file-inl.h"
Elliott Hughese5448b52012-01-18 16:44:06 -080051#include "os.h"
Andreas Gampe54fc26c2014-09-04 21:47:42 -070052#include "output_stream.h"
Brian Carlstrom78128a62011-09-15 17:21:19 -070053#include "runtime.h"
Elliott Hughesa0e18062012-04-13 15:59:59 -070054#include "safe_map.h"
Ian Rogers00f7d0e2012-07-19 15:28:27 -070055#include "scoped_thread_state_change.h"
Andreas Gampe00b25f32014-09-17 21:49:05 -070056#include "ScopedLocalRef.h"
Mathieu Chartierc22c59e2014-02-24 15:16:06 -080057#include "thread_list.h"
Ian Rogersef7d42f2014-01-06 12:55:46 -080058#include "verifier/dex_gc_map.h"
Ian Rogers2bcb4a42012-11-08 10:39:18 -080059#include "verifier/method_verifier.h"
Ian Rogers1809a722013-08-09 22:05:32 -070060#include "vmap_table.h"
Andreas Gampe00b25f32014-09-17 21:49:05 -070061#include "well_known_classes.h"
Brian Carlstrom78128a62011-09-15 17:21:19 -070062
63namespace art {
64
65static void usage() {
66 fprintf(stderr,
67 "Usage: oatdump [options] ...\n"
Nicolas Geoffray9583fbc2014-02-28 15:21:07 +000068 " Example: oatdump --image=$ANDROID_PRODUCT_OUT/system/framework/boot.art\n"
Brian Carlstrom29e7ac72011-12-05 23:42:57 -080069 " Example: adb shell oatdump --image=/system/framework/boot.art\n"
Brian Carlstrom78128a62011-09-15 17:21:19 -070070 "\n");
71 fprintf(stderr,
Brian Carlstroma6cc8932012-01-04 14:44:07 -080072 " --oat-file=<file.oat>: specifies an input oat filename.\n"
TDYa127a0a2a6c2012-10-16 22:47:38 -070073 " Example: --oat-file=/system/framework/boot.oat\n"
Brian Carlstromaded5f72011-10-07 17:15:04 -070074 "\n");
75 fprintf(stderr,
76 " --image=<file.art>: specifies an input image filename.\n"
Brian Carlstrom29e7ac72011-12-05 23:42:57 -080077 " Example: --image=/system/framework/boot.art\n"
Brian Carlstrome24fa612011-09-29 00:53:55 -070078 "\n");
Brian Carlstrom78128a62011-09-15 17:21:19 -070079 fprintf(stderr,
Brian Carlstrome24fa612011-09-29 00:53:55 -070080 " --boot-image=<file.art>: provide the image file for the boot class path.\n"
Brian Carlstrom29e7ac72011-12-05 23:42:57 -080081 " Example: --boot-image=/system/framework/boot.art\n"
Brian Carlstrom78128a62011-09-15 17:21:19 -070082 "\n");
Brian Carlstrome24fa612011-09-29 00:53:55 -070083 fprintf(stderr,
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -070084 " --instruction-set=(arm|arm64|mips|x86|x86_64): for locating the image\n"
85 " file based on the image location set.\n"
Brian Carlstrom0f5baa02014-05-22 11:54:18 -070086 " Example: --instruction-set=x86\n"
87 " Default: %s\n"
88 "\n",
89 GetInstructionSetString(kRuntimeISA));
90 fprintf(stderr,
Brian Carlstrom27ec9612011-09-19 20:20:38 -070091 " --output=<file> may be used to send the output to a file.\n"
92 " Example: --output=/tmp/oatdump.txt\n"
93 "\n");
Dave Allison404f59f2014-02-24 11:10:01 -080094 fprintf(stderr,
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -070095 " --dump:raw_mapping_table enables dumping of the mapping table.\n"
96 " Example: --dump:raw_mapping_table\n"
97 "\n");
98 fprintf(stderr,
99 " --dump:raw_mapping_table enables dumping of the GC map.\n"
100 " Example: --dump:raw_gc_map\n"
101 "\n");
102 fprintf(stderr,
103 " --no-dump:vmap may be used to disable vmap dumping.\n"
104 " Example: --no-dump:vmap\n"
105 "\n");
106 fprintf(stderr,
107 " --no-disassemble may be used to disable disassembly.\n"
108 " Example: --no-disassemble\n"
Dave Allison404f59f2014-02-24 11:10:01 -0800109 "\n");
Brian Carlstrom78128a62011-09-15 17:21:19 -0700110}
111
Ian Rogersff1ed472011-09-20 13:46:24 -0700112const char* image_roots_descriptions_[] = {
Ian Rogers19846512012-02-24 11:42:47 -0800113 "kResolutionMethod",
Jeff Hao88474b42013-10-23 16:24:40 -0700114 "kImtConflictMethod",
115 "kDefaultImt",
Brian Carlstrome24fa612011-09-29 00:53:55 -0700116 "kCalleeSaveMethod",
Brian Carlstromaded5f72011-10-07 17:15:04 -0700117 "kRefsOnlySaveMethod",
118 "kRefsAndArgsSaveMethod",
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700119 "kDexCaches",
Brian Carlstrom34f426c2011-10-04 12:58:02 -0700120 "kClassRoots",
Brian Carlstrom78128a62011-09-15 17:21:19 -0700121};
122
Ian Rogers0279ebb2014-10-08 17:27:48 -0700123class OatSymbolizer FINAL : public CodeOutput {
Andreas Gampe54fc26c2014-09-04 21:47:42 -0700124 public:
Ian Rogers0279ebb2014-10-08 17:27:48 -0700125 explicit OatSymbolizer(const OatFile* oat_file, const std::string& output_name) :
126 oat_file_(oat_file), builder_(nullptr), elf_output_(nullptr),
127 output_name_(output_name.empty() ? "symbolized.oat" : output_name) {
128 }
Andreas Gampe54fc26c2014-09-04 21:47:42 -0700129
130 bool Init() {
131 Elf32_Word oat_data_size = oat_file_->GetOatHeader().GetExecutableOffset();
132
133 uint32_t diff = static_cast<uint32_t>(oat_file_->End() - oat_file_->Begin());
134 uint32_t oat_exec_size = diff - oat_data_size;
135
Andreas Gampe54fc26c2014-09-04 21:47:42 -0700136 elf_output_ = OS::CreateEmptyFile(output_name_.c_str());
137
138 builder_.reset(new ElfBuilder<Elf32_Word, Elf32_Sword, Elf32_Addr, Elf32_Dyn,
139 Elf32_Sym, Elf32_Ehdr, Elf32_Phdr, Elf32_Shdr>(
140 this,
141 elf_output_,
142 oat_file_->GetOatHeader().GetInstructionSet(),
143 0,
144 oat_data_size,
145 oat_data_size,
146 oat_exec_size,
147 true,
148 false));
149
150 if (!builder_->Init()) {
151 builder_.reset(nullptr);
152 return false;
153 }
154
155 return true;
156 }
157
158 typedef void (OatSymbolizer::*Callback)(const DexFile::ClassDef&,
159 uint32_t,
160 const OatFile::OatMethod&,
161 const DexFile&,
162 uint32_t,
163 const DexFile::CodeItem*,
164 uint32_t);
165
166 bool Symbolize() {
167 if (builder_.get() == nullptr) {
168 return false;
169 }
170
171 Walk(&art::OatSymbolizer::RegisterForDedup);
172
173 NormalizeState();
174
175 Walk(&art::OatSymbolizer::AddSymbol);
176
177 bool result = builder_->Write();
178
179 elf_output_->Flush();
180 elf_output_->Close();
181
182 return result;
183 }
184
185 void Walk(Callback callback) {
186 std::vector<const OatFile::OatDexFile*> oat_dex_files = oat_file_->GetOatDexFiles();
187 for (size_t i = 0; i < oat_dex_files.size(); i++) {
188 const OatFile::OatDexFile* oat_dex_file = oat_dex_files[i];
189 CHECK(oat_dex_file != NULL);
190 WalkOatDexFile(oat_dex_file, callback);
191 }
192 }
193
194 void WalkOatDexFile(const OatFile::OatDexFile* oat_dex_file, Callback callback) {
195 std::string error_msg;
196 std::unique_ptr<const DexFile> dex_file(oat_dex_file->OpenDexFile(&error_msg));
197 if (dex_file.get() == nullptr) {
198 return;
199 }
200 for (size_t class_def_index = 0;
201 class_def_index < dex_file->NumClassDefs();
202 class_def_index++) {
203 const DexFile::ClassDef& class_def = dex_file->GetClassDef(class_def_index);
204 const OatFile::OatClass oat_class = oat_dex_file->GetOatClass(class_def_index);
205 OatClassType type = oat_class.GetType();
206 switch (type) {
207 case kOatClassAllCompiled:
208 case kOatClassSomeCompiled:
209 WalkOatClass(oat_class, *dex_file.get(), class_def, callback);
210 break;
211
212 case kOatClassNoneCompiled:
213 case kOatClassMax:
214 // Ignore.
215 break;
216 }
217 }
218 }
219
220 void WalkOatClass(const OatFile::OatClass& oat_class, const DexFile& dex_file,
221 const DexFile::ClassDef& class_def, Callback callback) {
Ian Rogers13735952014-10-08 12:43:28 -0700222 const uint8_t* class_data = dex_file.GetClassData(class_def);
Andreas Gampe54fc26c2014-09-04 21:47:42 -0700223 if (class_data == nullptr) { // empty class such as a marker interface?
224 return;
225 }
226 // Note: even if this is an interface or a native class, we still have to walk it, as there
227 // might be a static initializer.
228 ClassDataItemIterator it(dex_file, class_data);
229 SkipAllFields(&it);
230 uint32_t class_method_idx = 0;
231 while (it.HasNextDirectMethod()) {
232 const OatFile::OatMethod oat_method = oat_class.GetOatMethod(class_method_idx);
233 WalkOatMethod(class_def, class_method_idx, oat_method, dex_file, it.GetMemberIndex(),
Andreas Gampe51829322014-08-25 15:05:04 -0700234 it.GetMethodCodeItem(), it.GetMethodAccessFlags(), callback);
Andreas Gampe54fc26c2014-09-04 21:47:42 -0700235 class_method_idx++;
236 it.Next();
237 }
238 while (it.HasNextVirtualMethod()) {
239 const OatFile::OatMethod oat_method = oat_class.GetOatMethod(class_method_idx);
240 WalkOatMethod(class_def, class_method_idx, oat_method, dex_file, it.GetMemberIndex(),
Andreas Gampe51829322014-08-25 15:05:04 -0700241 it.GetMethodCodeItem(), it.GetMethodAccessFlags(), callback);
Andreas Gampe54fc26c2014-09-04 21:47:42 -0700242 class_method_idx++;
243 it.Next();
244 }
245 DCHECK(!it.HasNext());
246 }
247
248 void WalkOatMethod(const DexFile::ClassDef& class_def, uint32_t class_method_index,
249 const OatFile::OatMethod& oat_method, const DexFile& dex_file,
250 uint32_t dex_method_idx, const DexFile::CodeItem* code_item,
251 uint32_t method_access_flags, Callback callback) {
252 if ((method_access_flags & kAccAbstract) != 0) {
253 // Abstract method, no code.
254 return;
255 }
256 if (oat_method.GetCodeOffset() == 0) {
257 // No code.
258 return;
259 }
260
261 (this->*callback)(class_def, class_method_index, oat_method, dex_file, dex_method_idx, code_item,
262 method_access_flags);
263 }
264
265 void RegisterForDedup(const DexFile::ClassDef& class_def, uint32_t class_method_index,
266 const OatFile::OatMethod& oat_method, const DexFile& dex_file,
267 uint32_t dex_method_idx, const DexFile::CodeItem* code_item,
268 uint32_t method_access_flags) {
269 state_[oat_method.GetCodeOffset()]++;
270 }
271
272 void NormalizeState() {
273 for (auto& x : state_) {
274 if (x.second == 1) {
275 state_[x.first] = 0;
276 }
277 }
278 }
279
280 enum class DedupState { // private
281 kNotDeduplicated,
282 kDeduplicatedFirst,
283 kDeduplicatedOther
284 };
285 DedupState IsDuplicated(uint32_t offset) {
286 if (state_[offset] == 0) {
287 return DedupState::kNotDeduplicated;
288 }
289 if (state_[offset] == 1) {
290 return DedupState::kDeduplicatedOther;
291 }
292 state_[offset] = 1;
293 return DedupState::kDeduplicatedFirst;
294 }
295
296 void AddSymbol(const DexFile::ClassDef& class_def, uint32_t class_method_index,
297 const OatFile::OatMethod& oat_method, const DexFile& dex_file,
298 uint32_t dex_method_idx, const DexFile::CodeItem* code_item,
299 uint32_t method_access_flags) {
300 DedupState dedup = IsDuplicated(oat_method.GetCodeOffset());
301 if (dedup != DedupState::kDeduplicatedOther) {
302 std::string pretty_name = PrettyMethod(dex_method_idx, dex_file, true);
303
304 if (dedup == DedupState::kDeduplicatedFirst) {
305 pretty_name = "[Dedup]" + pretty_name;
306 }
307
308 ElfSymtabBuilder<Elf32_Word, Elf32_Sword, Elf32_Addr,
Ian Rogers0279ebb2014-10-08 17:27:48 -0700309 Elf32_Sym, Elf32_Shdr>* symtab = builder_->GetSymtabBuilder();
Andreas Gampe54fc26c2014-09-04 21:47:42 -0700310
Ian Rogers0279ebb2014-10-08 17:27:48 -0700311 symtab->AddSymbol(pretty_name, &builder_->GetTextBuilder(),
312 oat_method.GetCodeOffset() - oat_file_->GetOatHeader().GetExecutableOffset(),
313 true, oat_method.GetQuickCodeSize(), STB_GLOBAL, STT_FUNC);
Andreas Gampe54fc26c2014-09-04 21:47:42 -0700314 }
315 }
316
Vladimir Markof4da6752014-08-01 19:04:18 +0100317 // Set oat data offset. Required by ElfBuilder/CodeOutput.
318 void SetCodeOffset(size_t offset) {
319 // Nothing to do.
320 }
321
Andreas Gampe54fc26c2014-09-04 21:47:42 -0700322 // Write oat code. Required by ElfBuilder/CodeOutput.
323 bool Write(OutputStream* out) {
324 return out->WriteFully(oat_file_->Begin(), oat_file_->End() - oat_file_->Begin());
325 }
326
327 private:
328 static void SkipAllFields(ClassDataItemIterator* it) {
329 while (it->HasNextStaticField()) {
330 it->Next();
331 }
332 while (it->HasNextInstanceField()) {
333 it->Next();
334 }
335 }
336
337 const OatFile* oat_file_;
338 std::unique_ptr<ElfBuilder<Elf32_Word, Elf32_Sword, Elf32_Addr, Elf32_Dyn,
339 Elf32_Sym, Elf32_Ehdr, Elf32_Phdr, Elf32_Shdr> > builder_;
340 File* elf_output_;
341 std::unordered_map<uint32_t, uint32_t> state_;
Ian Rogers0279ebb2014-10-08 17:27:48 -0700342 const std::string output_name_;
Andreas Gampe54fc26c2014-09-04 21:47:42 -0700343};
344
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700345class OatDumperOptions {
346 public:
347 OatDumperOptions(bool dump_raw_mapping_table,
348 bool dump_raw_gc_map,
349 bool dump_vmap,
350 bool disassemble_code,
Andreas Gampe00b25f32014-09-17 21:49:05 -0700351 bool absolute_addresses,
352 Handle<mirror::ClassLoader>* class_loader)
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700353 : dump_raw_mapping_table_(dump_raw_mapping_table),
354 dump_raw_gc_map_(dump_raw_gc_map),
355 dump_vmap_(dump_vmap),
356 disassemble_code_(disassemble_code),
Andreas Gampe00b25f32014-09-17 21:49:05 -0700357 absolute_addresses_(absolute_addresses),
358 class_loader_(class_loader) {}
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700359
360 const bool dump_raw_mapping_table_;
361 const bool dump_raw_gc_map_;
362 const bool dump_vmap_;
363 const bool disassemble_code_;
364 const bool absolute_addresses_;
Andreas Gampe00b25f32014-09-17 21:49:05 -0700365 Handle<mirror::ClassLoader>* class_loader_;
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700366};
367
Elliott Hughese3c845c2012-02-28 17:23:01 -0800368class OatDumper {
Brian Carlstromaded5f72011-10-07 17:15:04 -0700369 public:
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700370 explicit OatDumper(const OatFile& oat_file, OatDumperOptions* options)
Nicolas Geoffray9583fbc2014-02-28 15:21:07 +0000371 : oat_file_(oat_file),
Elliott Hughesa72ec822012-03-05 17:12:22 -0800372 oat_dex_files_(oat_file.GetOatDexFiles()),
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700373 options_(options),
374 disassembler_(Disassembler::Create(oat_file_.GetOatHeader().GetInstructionSet(),
375 new DisassemblerOptions(options_->absolute_addresses_,
376 oat_file.Begin()))) {
Andreas Gampe00b25f32014-09-17 21:49:05 -0700377 CHECK(options_->class_loader_ != nullptr);
Ian Rogers3a5c1ce2012-02-29 10:06:46 -0800378 AddAllOffsets();
379 }
380
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700381 ~OatDumper() {
382 delete options_;
383 delete disassembler_;
384 }
385
386 bool Dump(std::ostream& os) {
387 bool success = true;
Ian Rogers3a5c1ce2012-02-29 10:06:46 -0800388 const OatHeader& oat_header = oat_file_.GetOatHeader();
Brian Carlstromaded5f72011-10-07 17:15:04 -0700389
390 os << "MAGIC:\n";
391 os << oat_header.GetMagic() << "\n\n";
392
393 os << "CHECKSUM:\n";
Elliott Hughesed2adb62012-02-29 14:41:01 -0800394 os << StringPrintf("0x%08x\n\n", oat_header.GetChecksum());
Brian Carlstromaded5f72011-10-07 17:15:04 -0700395
Elliott Hughesa72ec822012-03-05 17:12:22 -0800396 os << "INSTRUCTION SET:\n";
397 os << oat_header.GetInstructionSet() << "\n\n";
398
Ian Rogers6f3dbba2014-10-14 17:41:57 -0700399 {
400 std::unique_ptr<const InstructionSetFeatures> features(
401 InstructionSetFeatures::FromBitmap(oat_header.GetInstructionSet(),
402 oat_header.GetInstructionSetFeaturesBitmap()));
403 os << "INSTRUCTION SET FEATURES:\n";
404 os << features->GetFeatureString() << "\n\n";
405 }
Dave Allison70202782013-10-22 17:52:19 -0700406
Brian Carlstromaded5f72011-10-07 17:15:04 -0700407 os << "DEX FILE COUNT:\n";
408 os << oat_header.GetDexFileCount() << "\n\n";
409
Brian Carlstrom2ec65202014-03-03 15:16:37 -0800410#define DUMP_OAT_HEADER_OFFSET(label, offset) \
411 os << label " OFFSET:\n"; \
412 os << StringPrintf("0x%08x", oat_header.offset()); \
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700413 if (oat_header.offset() != 0 && options_->absolute_addresses_) { \
Brian Carlstrom2ec65202014-03-03 15:16:37 -0800414 os << StringPrintf(" (%p)", oat_file_.Begin() + oat_header.offset()); \
415 } \
416 os << StringPrintf("\n\n");
417
418 DUMP_OAT_HEADER_OFFSET("EXECUTABLE", GetExecutableOffset);
419 DUMP_OAT_HEADER_OFFSET("INTERPRETER TO INTERPRETER BRIDGE",
420 GetInterpreterToInterpreterBridgeOffset);
421 DUMP_OAT_HEADER_OFFSET("INTERPRETER TO COMPILED CODE BRIDGE",
422 GetInterpreterToCompiledCodeBridgeOffset);
423 DUMP_OAT_HEADER_OFFSET("JNI DLSYM LOOKUP",
424 GetJniDlsymLookupOffset);
425 DUMP_OAT_HEADER_OFFSET("PORTABLE IMT CONFLICT TRAMPOLINE",
426 GetPortableImtConflictTrampolineOffset);
427 DUMP_OAT_HEADER_OFFSET("PORTABLE RESOLUTION TRAMPOLINE",
428 GetPortableResolutionTrampolineOffset);
429 DUMP_OAT_HEADER_OFFSET("PORTABLE TO INTERPRETER BRIDGE",
430 GetPortableToInterpreterBridgeOffset);
431 DUMP_OAT_HEADER_OFFSET("QUICK GENERIC JNI TRAMPOLINE",
432 GetQuickGenericJniTrampolineOffset);
433 DUMP_OAT_HEADER_OFFSET("QUICK IMT CONFLICT TRAMPOLINE",
434 GetQuickImtConflictTrampolineOffset);
435 DUMP_OAT_HEADER_OFFSET("QUICK RESOLUTION TRAMPOLINE",
436 GetQuickResolutionTrampolineOffset);
437 DUMP_OAT_HEADER_OFFSET("QUICK TO INTERPRETER BRIDGE",
438 GetQuickToInterpreterBridgeOffset);
439#undef DUMP_OAT_HEADER_OFFSET
Brian Carlstromaded5f72011-10-07 17:15:04 -0700440
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700441 os << "IMAGE PATCH DELTA:\n";
442 os << StringPrintf("%d (0x%08x)\n\n",
443 oat_header.GetImagePatchDelta(),
444 oat_header.GetImagePatchDelta());
Alex Lighta59dd802014-07-02 16:28:08 -0700445
Brian Carlstrom28db0122012-10-18 16:20:41 -0700446 os << "IMAGE FILE LOCATION OAT CHECKSUM:\n";
447 os << StringPrintf("0x%08x\n\n", oat_header.GetImageFileLocationOatChecksum());
448
449 os << "IMAGE FILE LOCATION OAT BEGIN:\n";
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800450 os << StringPrintf("0x%08x\n\n", oat_header.GetImageFileLocationOatDataBegin());
Brian Carlstrom81f3ca12012-03-17 00:27:35 -0700451
Andreas Gampe22f8e5c2014-07-09 11:38:21 -0700452 // Print the key-value store.
453 {
454 os << "KEY VALUE STORE:\n";
455 size_t index = 0;
456 const char* key;
457 const char* value;
458 while (oat_header.GetStoreKeyValuePairByIndex(index, &key, &value)) {
459 os << key << " = " << value << "\n";
460 index++;
461 }
462 os << "\n";
463 }
Brian Carlstrom81f3ca12012-03-17 00:27:35 -0700464
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700465 if (options_->absolute_addresses_) {
466 os << "BEGIN:\n";
467 os << reinterpret_cast<const void*>(oat_file_.Begin()) << "\n\n";
Brian Carlstromaded5f72011-10-07 17:15:04 -0700468
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700469 os << "END:\n";
470 os << reinterpret_cast<const void*>(oat_file_.End()) << "\n\n";
471 }
472
473 os << "SIZE:\n";
474 os << oat_file_.Size() << "\n\n";
Brian Carlstromaded5f72011-10-07 17:15:04 -0700475
476 os << std::flush;
477
Ian Rogers3a5c1ce2012-02-29 10:06:46 -0800478 for (size_t i = 0; i < oat_dex_files_.size(); i++) {
479 const OatFile::OatDexFile* oat_dex_file = oat_dex_files_[i];
Andreas Gampe2ed8def2014-08-28 14:41:02 -0700480 CHECK(oat_dex_file != nullptr);
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700481 if (!DumpOatDexFile(os, *oat_dex_file)) {
482 success = false;
483 }
Brian Carlstromaded5f72011-10-07 17:15:04 -0700484 }
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700485 os << std::flush;
486 return success;
Brian Carlstromaded5f72011-10-07 17:15:04 -0700487 }
488
Ian Rogers3a5c1ce2012-02-29 10:06:46 -0800489 size_t ComputeSize(const void* oat_data) {
Ian Rogers13735952014-10-08 12:43:28 -0700490 if (reinterpret_cast<const uint8_t*>(oat_data) < oat_file_.Begin() ||
491 reinterpret_cast<const uint8_t*>(oat_data) > oat_file_.End()) {
Ian Rogers3a5c1ce2012-02-29 10:06:46 -0800492 return 0; // Address not in oat file
493 }
Ian Rogersef7d42f2014-01-06 12:55:46 -0800494 uintptr_t begin_offset = reinterpret_cast<uintptr_t>(oat_data) -
495 reinterpret_cast<uintptr_t>(oat_file_.Begin());
496 auto it = offsets_.upper_bound(begin_offset);
Ian Rogers3a5c1ce2012-02-29 10:06:46 -0800497 CHECK(it != offsets_.end());
Ian Rogersef7d42f2014-01-06 12:55:46 -0800498 uintptr_t end_offset = *it;
Ian Rogers3a5c1ce2012-02-29 10:06:46 -0800499 return end_offset - begin_offset;
500 }
501
Brian Carlstromf8bbb842012-03-14 03:01:42 -0700502 InstructionSet GetInstructionSet() {
503 return oat_file_.GetOatHeader().GetInstructionSet();
504 }
505
Ian Rogersef7d42f2014-01-06 12:55:46 -0800506 const void* GetQuickOatCode(mirror::ArtMethod* m) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers3a5c1ce2012-02-29 10:06:46 -0800507 for (size_t i = 0; i < oat_dex_files_.size(); i++) {
508 const OatFile::OatDexFile* oat_dex_file = oat_dex_files_[i];
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700509 CHECK(oat_dex_file != nullptr);
510 std::string error_msg;
Ian Rogers700a4022014-05-19 16:49:03 -0700511 std::unique_ptr<const DexFile> dex_file(oat_dex_file->OpenDexFile(&error_msg));
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700512 if (dex_file.get() == nullptr) {
513 LOG(WARNING) << "Failed to open dex file '" << oat_dex_file->GetDexFileLocation()
514 << "': " << error_msg;
515 } else {
Ian Rogers8b2c0b92013-09-19 02:56:49 -0700516 const DexFile::ClassDef* class_def =
Mathieu Chartierbfd9a432014-05-21 17:43:44 -0700517 dex_file->FindClassDef(m->GetDeclaringClassDescriptor());
Andreas Gampe2ed8def2014-08-28 14:41:02 -0700518 if (class_def != nullptr) {
Ian Rogers8b2c0b92013-09-19 02:56:49 -0700519 uint16_t class_def_index = dex_file->GetIndexForClassDef(*class_def);
Vladimir Markod3c5beb2014-04-11 16:32:51 +0100520 const OatFile::OatClass oat_class = oat_dex_file->GetOatClass(class_def_index);
Ian Rogers3a5c1ce2012-02-29 10:06:46 -0800521 size_t method_index = m->GetMethodIndex();
Vladimir Markod3c5beb2014-04-11 16:32:51 +0100522 return oat_class.GetOatMethod(method_index).GetQuickCode();
Ian Rogers3a5c1ce2012-02-29 10:06:46 -0800523 }
524 }
525 }
Andreas Gampe2ed8def2014-08-28 14:41:02 -0700526 return nullptr;
Ian Rogers3a5c1ce2012-02-29 10:06:46 -0800527 }
528
Brian Carlstromaded5f72011-10-07 17:15:04 -0700529 private:
Ian Rogers3a5c1ce2012-02-29 10:06:46 -0800530 void AddAllOffsets() {
Elliott Hughese3c845c2012-02-28 17:23:01 -0800531 // We don't know the length of the code for each method, but we need to know where to stop
532 // when disassembling. What we do know is that a region of code will be followed by some other
533 // region, so if we keep a sorted sequence of the start of each region, we can infer the length
534 // of a piece of code by using upper_bound to find the start of the next region.
Ian Rogers3a5c1ce2012-02-29 10:06:46 -0800535 for (size_t i = 0; i < oat_dex_files_.size(); i++) {
536 const OatFile::OatDexFile* oat_dex_file = oat_dex_files_[i];
Andreas Gampe2ed8def2014-08-28 14:41:02 -0700537 CHECK(oat_dex_file != nullptr);
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700538 std::string error_msg;
Ian Rogers700a4022014-05-19 16:49:03 -0700539 std::unique_ptr<const DexFile> dex_file(oat_dex_file->OpenDexFile(&error_msg));
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700540 if (dex_file.get() == nullptr) {
541 LOG(WARNING) << "Failed to open dex file '" << oat_dex_file->GetDexFileLocation()
542 << "': " << error_msg;
Ian Rogers3a5c1ce2012-02-29 10:06:46 -0800543 continue;
Elliott Hughese3c845c2012-02-28 17:23:01 -0800544 }
Ian Rogersef7d42f2014-01-06 12:55:46 -0800545 offsets_.insert(reinterpret_cast<uintptr_t>(&dex_file->GetHeader()));
Brian Carlstrom2ec65202014-03-03 15:16:37 -0800546 for (size_t class_def_index = 0;
547 class_def_index < dex_file->NumClassDefs();
548 class_def_index++) {
Elliott Hughese3c845c2012-02-28 17:23:01 -0800549 const DexFile::ClassDef& class_def = dex_file->GetClassDef(class_def_index);
Vladimir Markod3c5beb2014-04-11 16:32:51 +0100550 const OatFile::OatClass oat_class = oat_dex_file->GetOatClass(class_def_index);
Ian Rogers13735952014-10-08 12:43:28 -0700551 const uint8_t* class_data = dex_file->GetClassData(class_def);
Andreas Gampe2ed8def2014-08-28 14:41:02 -0700552 if (class_data != nullptr) {
Elliott Hughese3c845c2012-02-28 17:23:01 -0800553 ClassDataItemIterator it(*dex_file, class_data);
554 SkipAllFields(it);
555 uint32_t class_method_index = 0;
556 while (it.HasNextDirectMethod()) {
Vladimir Markod3c5beb2014-04-11 16:32:51 +0100557 AddOffsets(oat_class.GetOatMethod(class_method_index++));
Elliott Hughese3c845c2012-02-28 17:23:01 -0800558 it.Next();
559 }
560 while (it.HasNextVirtualMethod()) {
Vladimir Markod3c5beb2014-04-11 16:32:51 +0100561 AddOffsets(oat_class.GetOatMethod(class_method_index++));
Elliott Hughese3c845c2012-02-28 17:23:01 -0800562 it.Next();
563 }
564 }
565 }
566 }
567
568 // If the last thing in the file is code for a method, there won't be an offset for the "next"
569 // thing. Instead of having a special case in the upper_bound code, let's just add an entry
570 // for the end of the file.
Ian Rogersef7d42f2014-01-06 12:55:46 -0800571 offsets_.insert(oat_file_.Size());
Elliott Hughese3c845c2012-02-28 17:23:01 -0800572 }
573
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700574 static uint32_t AlignCodeOffset(uint32_t maybe_thumb_offset) {
575 return maybe_thumb_offset & ~0x1; // TODO: Make this Thumb2 specific.
576 }
577
Elliott Hughese3c845c2012-02-28 17:23:01 -0800578 void AddOffsets(const OatFile::OatMethod& oat_method) {
Brian Carlstrom95ba0dc2012-03-05 22:06:14 -0800579 uint32_t code_offset = oat_method.GetCodeOffset();
580 if (oat_file_.GetOatHeader().GetInstructionSet() == kThumb2) {
581 code_offset &= ~0x1;
582 }
583 offsets_.insert(code_offset);
Elliott Hughese3c845c2012-02-28 17:23:01 -0800584 offsets_.insert(oat_method.GetMappingTableOffset());
585 offsets_.insert(oat_method.GetVmapTableOffset());
Ian Rogers0c7abda2012-09-19 13:33:42 -0700586 offsets_.insert(oat_method.GetNativeGcMapOffset());
Elliott Hughese3c845c2012-02-28 17:23:01 -0800587 }
588
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700589 bool DumpOatDexFile(std::ostream& os, const OatFile::OatDexFile& oat_dex_file) {
590 bool success = true;
591 os << "OatDexFile:\n";
Brian Carlstroma004aa92012-02-08 18:05:09 -0800592 os << StringPrintf("location: %s\n", oat_dex_file.GetDexFileLocation().c_str());
Elliott Hughesed2adb62012-02-29 14:41:01 -0800593 os << StringPrintf("checksum: 0x%08x\n", oat_dex_file.GetDexFileLocationChecksum());
Mathieu Chartier590fee92013-09-13 13:46:47 -0700594
595 // Create the verifier early.
596
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700597 std::string error_msg;
Ian Rogers700a4022014-05-19 16:49:03 -0700598 std::unique_ptr<const DexFile> dex_file(oat_dex_file.OpenDexFile(&error_msg));
Andreas Gampe2ed8def2014-08-28 14:41:02 -0700599 if (dex_file.get() == nullptr) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700600 os << "NOT FOUND: " << error_msg << "\n\n";
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700601 os << std::flush;
602 return false;
Brian Carlstromaded5f72011-10-07 17:15:04 -0700603 }
Brian Carlstrom2ec65202014-03-03 15:16:37 -0800604 for (size_t class_def_index = 0;
605 class_def_index < dex_file->NumClassDefs();
606 class_def_index++) {
Brian Carlstromaded5f72011-10-07 17:15:04 -0700607 const DexFile::ClassDef& class_def = dex_file->GetClassDef(class_def_index);
608 const char* descriptor = dex_file->GetClassDescriptor(class_def);
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700609 uint32_t oat_class_offset = oat_dex_file.GetOatClassOffset(class_def_index);
Vladimir Markod3c5beb2014-04-11 16:32:51 +0100610 const OatFile::OatClass oat_class = oat_dex_file.GetOatClass(class_def_index);
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700611 os << StringPrintf("%zd: %s (offset=0x%08x) (type_idx=%d)",
612 class_def_index, descriptor, oat_class_offset, class_def.class_idx_)
Vladimir Markod3c5beb2014-04-11 16:32:51 +0100613 << " (" << oat_class.GetStatus() << ")"
614 << " (" << oat_class.GetType() << ")\n";
615 // TODO: include bitmap here if type is kOatClassSomeCompiled?
Ian Rogers2bcb4a42012-11-08 10:39:18 -0800616 Indenter indent_filter(os.rdbuf(), kIndentChar, kIndentBy1Count);
617 std::ostream indented_os(&indent_filter);
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700618 if (!DumpOatClass(indented_os, oat_class, *(dex_file.get()), class_def)) {
619 success = false;
620 }
Brian Carlstromaded5f72011-10-07 17:15:04 -0700621 }
622
623 os << std::flush;
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700624 return success;
Brian Carlstromaded5f72011-10-07 17:15:04 -0700625 }
626
Elliott Hughese3c845c2012-02-28 17:23:01 -0800627 static void SkipAllFields(ClassDataItemIterator& it) {
Ian Rogers0571d352011-11-03 19:51:38 -0700628 while (it.HasNextStaticField()) {
629 it.Next();
Brian Carlstromaded5f72011-10-07 17:15:04 -0700630 }
Ian Rogers0571d352011-11-03 19:51:38 -0700631 while (it.HasNextInstanceField()) {
632 it.Next();
Brian Carlstromaded5f72011-10-07 17:15:04 -0700633 }
Elliott Hughese3c845c2012-02-28 17:23:01 -0800634 }
Brian Carlstromaded5f72011-10-07 17:15:04 -0700635
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700636 bool DumpOatClass(std::ostream& os, const OatFile::OatClass& oat_class, const DexFile& dex_file,
Ian Rogers3a5c1ce2012-02-29 10:06:46 -0800637 const DexFile::ClassDef& class_def) {
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700638 bool success = true;
Ian Rogers13735952014-10-08 12:43:28 -0700639 const uint8_t* class_data = dex_file.GetClassData(class_def);
Andreas Gampe2ed8def2014-08-28 14:41:02 -0700640 if (class_data == nullptr) { // empty class such as a marker interface?
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700641 os << std::flush;
642 return success;
Elliott Hughese3c845c2012-02-28 17:23:01 -0800643 }
644 ClassDataItemIterator it(dex_file, class_data);
645 SkipAllFields(it);
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700646 uint32_t class_method_index = 0;
Ian Rogers0571d352011-11-03 19:51:38 -0700647 while (it.HasNextDirectMethod()) {
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700648 if (!DumpOatMethod(os, class_def, class_method_index, oat_class, dex_file,
649 it.GetMemberIndex(), it.GetMethodCodeItem(),
650 it.GetRawMemberAccessFlags())) {
651 success = false;
652 }
653 class_method_index++;
Ian Rogers0571d352011-11-03 19:51:38 -0700654 it.Next();
Brian Carlstromaded5f72011-10-07 17:15:04 -0700655 }
Ian Rogers0571d352011-11-03 19:51:38 -0700656 while (it.HasNextVirtualMethod()) {
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700657 if (!DumpOatMethod(os, class_def, class_method_index, oat_class, dex_file,
658 it.GetMemberIndex(), it.GetMethodCodeItem(),
659 it.GetRawMemberAccessFlags())) {
660 success = false;
661 }
662 class_method_index++;
Ian Rogers0571d352011-11-03 19:51:38 -0700663 it.Next();
Brian Carlstromaded5f72011-10-07 17:15:04 -0700664 }
Ian Rogers0571d352011-11-03 19:51:38 -0700665 DCHECK(!it.HasNext());
Brian Carlstromaded5f72011-10-07 17:15:04 -0700666 os << std::flush;
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700667 return success;
Brian Carlstromaded5f72011-10-07 17:15:04 -0700668 }
Elliott Hughese3c845c2012-02-28 17:23:01 -0800669
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700670 static constexpr uint32_t kPrologueBytes = 16;
671
672 // When this was picked, the largest arm method was 55,256 bytes and arm64 was 50,412 bytes.
673 static constexpr uint32_t kMaxCodeSize = 100 * 1000;
674
675 bool DumpOatMethod(std::ostream& os, const DexFile::ClassDef& class_def,
Ian Rogers8b2c0b92013-09-19 02:56:49 -0700676 uint32_t class_method_index,
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700677 const OatFile::OatClass& oat_class, const DexFile& dex_file,
Ian Rogers2bcb4a42012-11-08 10:39:18 -0800678 uint32_t dex_method_idx, const DexFile::CodeItem* code_item,
679 uint32_t method_access_flags) {
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700680 bool success = true;
Ian Rogers2bcb4a42012-11-08 10:39:18 -0800681 os << StringPrintf("%d: %s (dex_method_idx=%d)\n",
Ian Rogersdb7bdc12012-04-09 21:27:15 -0700682 class_method_index, PrettyMethod(dex_method_idx, dex_file, true).c_str(),
683 dex_method_idx);
Ian Rogers2bcb4a42012-11-08 10:39:18 -0800684 Indenter indent1_filter(os.rdbuf(), kIndentChar, kIndentBy1Count);
Andreas Gampea8b41aa2014-06-04 22:42:28 -0700685 std::unique_ptr<std::ostream> indent1_os(new std::ostream(&indent1_filter));
686 Indenter indent2_filter(indent1_os->rdbuf(), kIndentChar, kIndentBy1Count);
687 std::unique_ptr<std::ostream> indent2_os(new std::ostream(&indent2_filter));
Ian Rogers2bcb4a42012-11-08 10:39:18 -0800688 {
Andreas Gampea8b41aa2014-06-04 22:42:28 -0700689 *indent1_os << "DEX CODE:\n";
690 DumpDexCode(*indent2_os, dex_file, code_item);
Ian Rogersb23a7722012-10-09 16:54:26 -0700691 }
Andreas Gampe2ed8def2014-08-28 14:41:02 -0700692
693 std::unique_ptr<verifier::MethodVerifier> verifier;
694 if (Runtime::Current() != nullptr) {
Andreas Gampea8b41aa2014-06-04 22:42:28 -0700695 *indent1_os << "VERIFIER TYPE ANALYSIS:\n";
Andreas Gampe2ed8def2014-08-28 14:41:02 -0700696 verifier.reset(DumpVerifier(*indent2_os, dex_method_idx, &dex_file, class_def, code_item,
697 method_access_flags));
Ian Rogersb23a7722012-10-09 16:54:26 -0700698 }
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700699
700 uint32_t oat_method_offsets_offset = oat_class.GetOatMethodOffsetsOffset(class_method_index);
701 const OatMethodOffsets* oat_method_offsets = oat_class.GetOatMethodOffsets(class_method_index);
702 const OatFile::OatMethod oat_method = oat_class.GetOatMethod(class_method_index);
Ian Rogers2bcb4a42012-11-08 10:39:18 -0800703 {
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700704 *indent1_os << "OatMethodOffsets ";
705 if (options_->absolute_addresses_) {
706 *indent1_os << StringPrintf("%p ", oat_method_offsets);
Nicolas Geoffray39468442014-09-02 15:17:15 +0100707 }
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700708 *indent1_os << StringPrintf("(offset=0x%08x)\n", oat_method_offsets_offset);
709 if (oat_method_offsets_offset > oat_file_.Size()) {
710 *indent1_os << StringPrintf(
711 "WARNING: oat method offsets offset 0x%08x is past end of file 0x%08zx.\n",
712 oat_method_offsets_offset, oat_file_.Size());
713 // If we can't read OatMethodOffsets, the rest of the data is dangerous to read.
714 os << std::flush;
715 return false;
Ian Rogers2bcb4a42012-11-08 10:39:18 -0800716 }
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700717
718 uint32_t code_offset = oat_method.GetCodeOffset();
719 *indent2_os << StringPrintf("code_offset: 0x%08x ", code_offset);
720 uint32_t aligned_code_begin = AlignCodeOffset(oat_method.GetCodeOffset());
721 if (aligned_code_begin > oat_file_.Size()) {
722 *indent2_os << StringPrintf("WARNING: "
723 "code offset 0x%08x is past end of file 0x%08zx.\n",
724 aligned_code_begin, oat_file_.Size());
725 success = false;
726 }
727 *indent2_os << "\n";
728
729 *indent2_os << "gc_map: ";
730 if (options_->absolute_addresses_) {
731 *indent2_os << StringPrintf("%p ", oat_method.GetNativeGcMap());
732 }
733 uint32_t gc_map_offset = oat_method.GetNativeGcMapOffset();
734 *indent2_os << StringPrintf("(offset=0x%08x)\n", gc_map_offset);
735 if (gc_map_offset > oat_file_.Size()) {
736 *indent2_os << StringPrintf("WARNING: "
737 "gc map table offset 0x%08x is past end of file 0x%08zx.\n",
738 gc_map_offset, oat_file_.Size());
739 success = false;
740 } else if (options_->dump_raw_gc_map_) {
Andreas Gampea8b41aa2014-06-04 22:42:28 -0700741 Indenter indent3_filter(indent2_os->rdbuf(), kIndentChar, kIndentBy1Count);
Ian Rogers2bcb4a42012-11-08 10:39:18 -0800742 std::ostream indent3_os(&indent3_filter);
743 DumpGcMap(indent3_os, oat_method, code_item);
744 }
745 }
746 {
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700747 *indent1_os << "OatQuickMethodHeader ";
748 uint32_t method_header_offset = oat_method.GetOatQuickMethodHeaderOffset();
749 const OatQuickMethodHeader* method_header = oat_method.GetOatQuickMethodHeader();
Mathieu Chartier590fee92013-09-13 13:46:47 -0700750
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700751 if (options_->absolute_addresses_) {
752 *indent1_os << StringPrintf("%p ", method_header);
753 }
754 *indent1_os << StringPrintf("(offset=0x%08x)\n", method_header_offset);
755 if (method_header_offset > oat_file_.Size()) {
756 *indent1_os << StringPrintf(
757 "WARNING: oat quick method header offset 0x%08x is past end of file 0x%08zx.\n",
758 method_header_offset, oat_file_.Size());
759 // If we can't read the OatQuickMethodHeader, the rest of the data is dangerous to read.
760 os << std::flush;
761 return false;
762 }
763
764 *indent2_os << "mapping_table: ";
765 if (options_->absolute_addresses_) {
766 *indent2_os << StringPrintf("%p ", oat_method.GetMappingTable());
767 }
768 uint32_t mapping_table_offset = oat_method.GetMappingTableOffset();
769 *indent2_os << StringPrintf("(offset=0x%08x)\n", oat_method.GetMappingTableOffset());
770 if (mapping_table_offset > oat_file_.Size()) {
771 *indent2_os << StringPrintf("WARNING: "
772 "mapping table offset 0x%08x is past end of file 0x%08zx. "
773 "mapping table offset was loaded from offset 0x%08x.\n",
774 mapping_table_offset, oat_file_.Size(),
775 oat_method.GetMappingTableOffsetOffset());
776 success = false;
777 } else if (options_->dump_raw_mapping_table_) {
778 Indenter indent3_filter(indent2_os->rdbuf(), kIndentChar, kIndentBy1Count);
779 std::ostream indent3_os(&indent3_filter);
780 DumpMappingTable(indent3_os, oat_method);
781 }
782
783 *indent2_os << "vmap_table: ";
784 if (options_->absolute_addresses_) {
785 *indent2_os << StringPrintf("%p ", oat_method.GetVmapTable());
786 }
787 uint32_t vmap_table_offset = oat_method.GetVmapTableOffset();
788 *indent2_os << StringPrintf("(offset=0x%08x)\n", vmap_table_offset);
789 if (vmap_table_offset > oat_file_.Size()) {
790 *indent2_os << StringPrintf("WARNING: "
791 "vmap table offset 0x%08x is past end of file 0x%08zx. "
792 "vmap table offset was loaded from offset 0x%08x.\n",
793 vmap_table_offset, oat_file_.Size(),
794 oat_method.GetVmapTableOffsetOffset());
795 success = false;
796 } else if (options_->dump_vmap_) {
Nicolas Geoffray20d3eae2014-09-17 11:27:23 +0100797 DumpVmap(*indent2_os, oat_method);
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700798 }
Ian Rogers2bcb4a42012-11-08 10:39:18 -0800799 }
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -0700800 {
801 *indent1_os << "QuickMethodFrameInfo\n";
802
803 *indent2_os << StringPrintf("frame_size_in_bytes: %zd\n", oat_method.GetFrameSizeInBytes());
804 *indent2_os << StringPrintf("core_spill_mask: 0x%08x ", oat_method.GetCoreSpillMask());
805 DumpSpillMask(*indent2_os, oat_method.GetCoreSpillMask(), false);
806 *indent2_os << "\n";
807 *indent2_os << StringPrintf("fp_spill_mask: 0x%08x ", oat_method.GetFpSpillMask());
808 DumpSpillMask(*indent2_os, oat_method.GetFpSpillMask(), true);
809 *indent2_os << "\n";
810 }
811 {
812 // Based on spill masks from QuickMethodFrameInfo so placed
813 // after it is dumped, but useful for understanding quick
814 // code, so dumped here.
815 DumpVregLocations(*indent2_os, oat_method, code_item);
816 }
817 {
818 *indent1_os << "CODE: ";
819 uint32_t code_size_offset = oat_method.GetQuickCodeSizeOffset();
820 if (code_size_offset > oat_file_.Size()) {
821 *indent2_os << StringPrintf("WARNING: "
822 "code size offset 0x%08x is past end of file 0x%08zx.",
823 code_size_offset, oat_file_.Size());
824 success = false;
825 } else {
826 const void* code = oat_method.GetQuickCode();
827 uint32_t code_size = oat_method.GetQuickCodeSize();
828 if (code == nullptr) {
829 code = oat_method.GetPortableCode();
830 code_size = oat_method.GetPortableCodeSize();
831 code_size_offset = 0;
832 }
833 uint32_t code_offset = oat_method.GetCodeOffset();
834 uint32_t aligned_code_begin = AlignCodeOffset(code_offset);
835 uint64_t aligned_code_end = aligned_code_begin + code_size;
836
837 if (options_->absolute_addresses_) {
838 *indent1_os << StringPrintf("%p ", code);
839 }
840 *indent1_os << StringPrintf("(code_offset=0x%08x size_offset=0x%08x size=%u)%s\n",
841 code_offset,
842 code_size_offset,
843 code_size,
844 code != nullptr ? "..." : "");
845
846 if (aligned_code_begin > oat_file_.Size()) {
847 *indent2_os << StringPrintf("WARNING: "
848 "start of code at 0x%08x is past end of file 0x%08zx.",
849 aligned_code_begin, oat_file_.Size());
850 success = false;
851 } else if (aligned_code_end > oat_file_.Size()) {
852 *indent2_os << StringPrintf("WARNING: "
853 "end of code at 0x%08" PRIx64 " is past end of file 0x%08zx. "
854 "code size is 0x%08x loaded from offset 0x%08x.\n",
855 aligned_code_end, oat_file_.Size(),
856 code_size, code_size_offset);
857 success = false;
858 if (options_->disassemble_code_) {
859 if (code_size_offset + kPrologueBytes <= oat_file_.Size()) {
860 DumpCode(*indent2_os, verifier.get(), oat_method, code_item, true, kPrologueBytes);
861 }
862 }
863 } else if (code_size > kMaxCodeSize) {
864 *indent2_os << StringPrintf("WARNING: "
865 "code size %d is bigger than max expected threshold of %d. "
866 "code size is 0x%08x loaded from offset 0x%08x.\n",
867 code_size, kMaxCodeSize,
868 code_size, code_size_offset);
869 success = false;
870 if (options_->disassemble_code_) {
871 if (code_size_offset + kPrologueBytes <= oat_file_.Size()) {
872 DumpCode(*indent2_os, verifier.get(), oat_method, code_item, true, kPrologueBytes);
873 }
874 }
875 } else if (options_->disassemble_code_) {
876 DumpCode(*indent2_os, verifier.get(), oat_method, code_item, !success, 0);
877 }
878 }
879 }
880 os << std::flush;
881 return success;
Brian Carlstromaded5f72011-10-07 17:15:04 -0700882 }
Elliott Hughese3c845c2012-02-28 17:23:01 -0800883
Ian Rogers3a5c1ce2012-02-29 10:06:46 -0800884 void DumpSpillMask(std::ostream& os, uint32_t spill_mask, bool is_float) {
885 if (spill_mask == 0) {
886 return;
887 }
Ian Rogers2bcb4a42012-11-08 10:39:18 -0800888 os << "(";
Ian Rogers3a5c1ce2012-02-29 10:06:46 -0800889 for (size_t i = 0; i < 32; i++) {
890 if ((spill_mask & (1 << i)) != 0) {
891 if (is_float) {
892 os << "fr" << i;
893 } else {
894 os << "r" << i;
895 }
896 spill_mask ^= 1 << i; // clear bit
897 if (spill_mask != 0) {
898 os << ", ";
899 } else {
900 break;
901 }
902 }
903 }
904 os << ")";
905 }
906
Ian Rogersb23a7722012-10-09 16:54:26 -0700907 void DumpVmap(std::ostream& os, const OatFile::OatMethod& oat_method) {
Nicolas Geoffray20d3eae2014-09-17 11:27:23 +0100908 // If the native GC map is null, then this method has been compiled with the
909 // optimizing compiler. The optimizing compiler currently outputs its stack map
910 // in the vmap table, and the code below does not work with such a stack map.
911 if (oat_method.GetNativeGcMap() == nullptr) {
912 return;
913 }
Ian Rogers1809a722013-08-09 22:05:32 -0700914 const uint8_t* raw_table = oat_method.GetVmapTable();
Andreas Gampe2ed8def2014-08-28 14:41:02 -0700915 if (raw_table != nullptr) {
Ian Rogers1809a722013-08-09 22:05:32 -0700916 const VmapTable vmap_table(raw_table);
917 bool first = true;
918 bool processing_fp = false;
919 uint32_t spill_mask = oat_method.GetCoreSpillMask();
920 for (size_t i = 0; i < vmap_table.Size(); i++) {
921 uint16_t dex_reg = vmap_table[i];
922 uint32_t cpu_reg = vmap_table.ComputeRegister(spill_mask, i,
923 processing_fp ? kFloatVReg : kIntVReg);
924 os << (first ? "v" : ", v") << dex_reg;
925 if (!processing_fp) {
926 os << "/r" << cpu_reg;
927 } else {
928 os << "/fr" << cpu_reg;
929 }
930 first = false;
931 if (!processing_fp && dex_reg == 0xFFFF) {
932 processing_fp = true;
933 spill_mask = oat_method.GetFpSpillMask();
934 }
Ian Rogers3a5c1ce2012-02-29 10:06:46 -0800935 }
Ian Rogers1809a722013-08-09 22:05:32 -0700936 os << "\n";
Ian Rogers3a5c1ce2012-02-29 10:06:46 -0800937 }
Ian Rogers3a5c1ce2012-02-29 10:06:46 -0800938 }
939
Razvan A Lupusorufaf9f0d2014-08-29 17:56:46 -0700940 void DumpVregLocations(std::ostream& os, const OatFile::OatMethod& oat_method,
941 const DexFile::CodeItem* code_item) {
942 if (code_item != nullptr) {
943 size_t num_locals_ins = code_item->registers_size_;
944 size_t num_ins = code_item->ins_size_;
945 size_t num_locals = num_locals_ins - num_ins;
946 size_t num_outs = code_item->outs_size_;
947
948 os << "vr_stack_locations:";
949 for (size_t reg = 0; reg <= num_locals_ins; reg++) {
950 // For readability, delimit the different kinds of VRs.
951 if (reg == num_locals_ins) {
952 os << "\n\tmethod*:";
953 } else if (reg == num_locals && num_ins > 0) {
954 os << "\n\tins:";
955 } else if (reg == 0 && num_locals > 0) {
956 os << "\n\tlocals:";
957 }
958
959 uint32_t offset = StackVisitor::GetVRegOffset(code_item, oat_method.GetCoreSpillMask(),
960 oat_method.GetFpSpillMask(),
961 oat_method.GetFrameSizeInBytes(), reg,
962 GetInstructionSet());
963 os << " v" << reg << "[sp + #" << offset << "]";
964 }
965
966 for (size_t out_reg = 0; out_reg < num_outs; out_reg++) {
967 if (out_reg == 0) {
968 os << "\n\touts:";
969 }
970
971 uint32_t offset = StackVisitor::GetOutVROffset(out_reg, GetInstructionSet());
972 os << " v" << out_reg << "[sp + #" << offset << "]";
973 }
974
975 os << "\n";
976 }
977 }
978
Ian Rogersb23a7722012-10-09 16:54:26 -0700979 void DescribeVReg(std::ostream& os, const OatFile::OatMethod& oat_method,
Ian Rogers2bcb4a42012-11-08 10:39:18 -0800980 const DexFile::CodeItem* code_item, size_t reg, VRegKind kind) {
Ian Rogers1809a722013-08-09 22:05:32 -0700981 const uint8_t* raw_table = oat_method.GetVmapTable();
Andreas Gampe2ed8def2014-08-28 14:41:02 -0700982 if (raw_table != nullptr) {
Ian Rogersb23a7722012-10-09 16:54:26 -0700983 const VmapTable vmap_table(raw_table);
984 uint32_t vmap_offset;
Ian Rogers1809a722013-08-09 22:05:32 -0700985 if (vmap_table.IsInContext(reg, kind, &vmap_offset)) {
Ian Rogers2bcb4a42012-11-08 10:39:18 -0800986 bool is_float = (kind == kFloatVReg) || (kind == kDoubleLoVReg) || (kind == kDoubleHiVReg);
987 uint32_t spill_mask = is_float ? oat_method.GetFpSpillMask()
988 : oat_method.GetCoreSpillMask();
989 os << (is_float ? "fr" : "r") << vmap_table.ComputeRegister(spill_mask, vmap_offset, kind);
Ian Rogersb23a7722012-10-09 16:54:26 -0700990 } else {
991 uint32_t offset = StackVisitor::GetVRegOffset(code_item, oat_method.GetCoreSpillMask(),
992 oat_method.GetFpSpillMask(),
Nicolas Geoffray42fcd982014-04-22 11:03:52 +0000993 oat_method.GetFrameSizeInBytes(), reg,
994 GetInstructionSet());
Ian Rogersb23a7722012-10-09 16:54:26 -0700995 os << "[sp + #" << offset << "]";
996 }
997 }
998 }
999
Ian Rogersef7d42f2014-01-06 12:55:46 -08001000 void DumpGcMapRegisters(std::ostream& os, const OatFile::OatMethod& oat_method,
1001 const DexFile::CodeItem* code_item,
1002 size_t num_regs, const uint8_t* reg_bitmap) {
1003 bool first = true;
1004 for (size_t reg = 0; reg < num_regs; reg++) {
1005 if (((reg_bitmap[reg / 8] >> (reg % 8)) & 0x01) != 0) {
1006 if (first) {
1007 os << " v" << reg << " (";
1008 DescribeVReg(os, oat_method, code_item, reg, kReferenceVReg);
1009 os << ")";
1010 first = false;
1011 } else {
1012 os << ", v" << reg << " (";
1013 DescribeVReg(os, oat_method, code_item, reg, kReferenceVReg);
1014 os << ")";
1015 }
1016 }
1017 }
1018 if (first) {
1019 os << "No registers in GC map\n";
1020 } else {
1021 os << "\n";
1022 }
1023 }
Ian Rogersb23a7722012-10-09 16:54:26 -07001024 void DumpGcMap(std::ostream& os, const OatFile::OatMethod& oat_method,
1025 const DexFile::CodeItem* code_item) {
1026 const uint8_t* gc_map_raw = oat_method.GetNativeGcMap();
Ian Rogersef7d42f2014-01-06 12:55:46 -08001027 if (gc_map_raw == nullptr) {
1028 return; // No GC map.
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001029 }
Ian Rogersef7d42f2014-01-06 12:55:46 -08001030 const void* quick_code = oat_method.GetQuickCode();
1031 if (quick_code != nullptr) {
1032 NativePcOffsetToReferenceMap map(gc_map_raw);
1033 for (size_t entry = 0; entry < map.NumEntries(); entry++) {
1034 const uint8_t* native_pc = reinterpret_cast<const uint8_t*>(quick_code) +
1035 map.GetNativePcOffset(entry);
1036 os << StringPrintf("%p", native_pc);
1037 DumpGcMapRegisters(os, oat_method, code_item, map.RegWidth() * 8, map.GetBitMap(entry));
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001038 }
Ian Rogersef7d42f2014-01-06 12:55:46 -08001039 } else {
1040 const void* portable_code = oat_method.GetPortableCode();
1041 CHECK(portable_code != nullptr);
1042 verifier::DexPcToReferenceMap map(gc_map_raw);
1043 for (size_t entry = 0; entry < map.NumEntries(); entry++) {
1044 uint32_t dex_pc = map.GetDexPc(entry);
1045 os << StringPrintf("0x%08x", dex_pc);
1046 DumpGcMapRegisters(os, oat_method, code_item, map.RegWidth() * 8, map.GetBitMap(entry));
1047 }
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001048 }
1049 }
1050
1051 void DumpMappingTable(std::ostream& os, const OatFile::OatMethod& oat_method) {
Ian Rogersef7d42f2014-01-06 12:55:46 -08001052 const void* quick_code = oat_method.GetQuickCode();
1053 if (quick_code == nullptr) {
Elliott Hughese3c845c2012-02-28 17:23:01 -08001054 return;
1055 }
Ian Rogers1809a722013-08-09 22:05:32 -07001056 MappingTable table(oat_method.GetMappingTable());
1057 if (table.TotalSize() != 0) {
1058 Indenter indent_filter(os.rdbuf(), kIndentChar, kIndentBy1Count);
1059 std::ostream indent_os(&indent_filter);
1060 if (table.PcToDexSize() != 0) {
1061 typedef MappingTable::PcToDexIterator It;
1062 os << "suspend point mappings {\n";
1063 for (It cur = table.PcToDexBegin(), end = table.PcToDexEnd(); cur != end; ++cur) {
1064 indent_os << StringPrintf("0x%04x -> 0x%04x\n", cur.NativePcOffset(), cur.DexPc());
1065 }
1066 os << "}\n";
1067 }
1068 if (table.DexToPcSize() != 0) {
1069 typedef MappingTable::DexToPcIterator It;
1070 os << "catch entry mappings {\n";
1071 for (It cur = table.DexToPcBegin(), end = table.DexToPcEnd(); cur != end; ++cur) {
1072 indent_os << StringPrintf("0x%04x -> 0x%04x\n", cur.NativePcOffset(), cur.DexPc());
1073 }
1074 os << "}\n";
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001075 }
1076 }
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001077 }
1078
Ian Rogers1809a722013-08-09 22:05:32 -07001079 uint32_t DumpMappingAtOffset(std::ostream& os, const OatFile::OatMethod& oat_method,
1080 size_t offset, bool suspend_point_mapping) {
1081 MappingTable table(oat_method.GetMappingTable());
1082 if (suspend_point_mapping && table.PcToDexSize() > 0) {
1083 typedef MappingTable::PcToDexIterator It;
1084 for (It cur = table.PcToDexBegin(), end = table.PcToDexEnd(); cur != end; ++cur) {
1085 if (offset == cur.NativePcOffset()) {
Brian Carlstrom4b8c13e2013-08-23 18:10:32 -07001086 os << StringPrintf("suspend point dex PC: 0x%04x\n", cur.DexPc());
Ian Rogers1809a722013-08-09 22:05:32 -07001087 return cur.DexPc();
1088 }
Elliott Hughese3c845c2012-02-28 17:23:01 -08001089 }
Ian Rogers1809a722013-08-09 22:05:32 -07001090 } else if (!suspend_point_mapping && table.DexToPcSize() > 0) {
1091 typedef MappingTable::DexToPcIterator It;
1092 for (It cur = table.DexToPcBegin(), end = table.DexToPcEnd(); cur != end; ++cur) {
1093 if (offset == cur.NativePcOffset()) {
Brian Carlstrom4b8c13e2013-08-23 18:10:32 -07001094 os << StringPrintf("catch entry dex PC: 0x%04x\n", cur.DexPc());
Ian Rogers1809a722013-08-09 22:05:32 -07001095 return cur.DexPc();
Ian Rogersb23a7722012-10-09 16:54:26 -07001096 }
1097 }
Elliott Hughese3c845c2012-02-28 17:23:01 -08001098 }
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001099 return DexFile::kDexNoIndex;
Ian Rogersb23a7722012-10-09 16:54:26 -07001100 }
1101
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001102 void DumpGcMapAtNativePcOffset(std::ostream& os, const OatFile::OatMethod& oat_method,
1103 const DexFile::CodeItem* code_item, size_t native_pc_offset) {
Ian Rogersb23a7722012-10-09 16:54:26 -07001104 const uint8_t* gc_map_raw = oat_method.GetNativeGcMap();
Andreas Gampe2ed8def2014-08-28 14:41:02 -07001105 if (gc_map_raw != nullptr) {
Ian Rogersb23a7722012-10-09 16:54:26 -07001106 NativePcOffsetToReferenceMap map(gc_map_raw);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001107 if (map.HasEntry(native_pc_offset)) {
Ian Rogersb23a7722012-10-09 16:54:26 -07001108 size_t num_regs = map.RegWidth() * 8;
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001109 const uint8_t* reg_bitmap = map.FindBitMap(native_pc_offset);
Ian Rogersb23a7722012-10-09 16:54:26 -07001110 bool first = true;
1111 for (size_t reg = 0; reg < num_regs; reg++) {
1112 if (((reg_bitmap[reg / 8] >> (reg % 8)) & 0x01) != 0) {
1113 if (first) {
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001114 os << "GC map objects: v" << reg << " (";
1115 DescribeVReg(os, oat_method, code_item, reg, kReferenceVReg);
Ian Rogersb23a7722012-10-09 16:54:26 -07001116 os << ")";
1117 first = false;
1118 } else {
1119 os << ", v" << reg << " (";
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001120 DescribeVReg(os, oat_method, code_item, reg, kReferenceVReg);
Ian Rogersb23a7722012-10-09 16:54:26 -07001121 os << ")";
1122 }
1123 }
1124 }
1125 if (!first) {
1126 os << "\n";
1127 }
1128 }
1129 }
1130 }
1131
Mathieu Chartier590fee92013-09-13 13:46:47 -07001132 void DumpVRegsAtDexPc(std::ostream& os, verifier::MethodVerifier* verifier,
1133 const OatFile::OatMethod& oat_method,
1134 const DexFile::CodeItem* code_item, uint32_t dex_pc) {
1135 DCHECK(verifier != nullptr);
Ian Rogers7b3ddd22013-02-21 15:19:52 -08001136 std::vector<int32_t> kinds = verifier->DescribeVRegs(dex_pc);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001137 bool first = true;
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001138 for (size_t reg = 0; reg < code_item->registers_size_; reg++) {
1139 VRegKind kind = static_cast<VRegKind>(kinds.at(reg * 2));
1140 if (kind != kUndefined) {
1141 if (first) {
1142 os << "VRegs: v";
1143 first = false;
1144 } else {
1145 os << ", v";
1146 }
1147 os << reg << " (";
1148 switch (kind) {
1149 case kImpreciseConstant:
1150 os << "Imprecise Constant: " << kinds.at((reg * 2) + 1) << ", ";
1151 DescribeVReg(os, oat_method, code_item, reg, kind);
1152 break;
1153 case kConstant:
1154 os << "Constant: " << kinds.at((reg * 2) + 1);
1155 break;
1156 default:
1157 DescribeVReg(os, oat_method, code_item, reg, kind);
1158 break;
1159 }
1160 os << ")";
1161 }
1162 }
1163 if (!first) {
1164 os << "\n";
1165 }
1166 }
1167
1168
Ian Rogersb23a7722012-10-09 16:54:26 -07001169 void DumpDexCode(std::ostream& os, const DexFile& dex_file, const DexFile::CodeItem* code_item) {
Andreas Gampe2ed8def2014-08-28 14:41:02 -07001170 if (code_item != nullptr) {
Ian Rogersb23a7722012-10-09 16:54:26 -07001171 size_t i = 0;
1172 while (i < code_item->insns_size_in_code_units_) {
1173 const Instruction* instruction = Instruction::At(&code_item->insns_[i]);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001174 os << StringPrintf("0x%04zx: %s\n", i, instruction->DumpString(&dex_file).c_str());
Ian Rogersb23a7722012-10-09 16:54:26 -07001175 i += instruction->SizeInCodeUnits();
1176 }
1177 }
1178 }
1179
Andreas Gampe2ed8def2014-08-28 14:41:02 -07001180 verifier::MethodVerifier* DumpVerifier(std::ostream& os, uint32_t dex_method_idx,
1181 const DexFile* dex_file,
1182 const DexFile::ClassDef& class_def,
1183 const DexFile::CodeItem* code_item,
1184 uint32_t method_access_flags) {
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001185 if ((method_access_flags & kAccNative) == 0) {
1186 ScopedObjectAccess soa(Thread::Current());
Mathieu Chartierbf99f772014-08-23 16:37:27 -07001187 StackHandleScope<1> hs(soa.Self());
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07001188 Handle<mirror::DexCache> dex_cache(
1189 hs.NewHandle(Runtime::Current()->GetClassLinker()->FindDexCache(*dex_file)));
Andreas Gampe00b25f32014-09-17 21:49:05 -07001190 DCHECK(options_->class_loader_ != nullptr);
Andreas Gampe2ed8def2014-08-28 14:41:02 -07001191 return verifier::MethodVerifier::VerifyMethodAndDump(soa.Self(), os, dex_method_idx, dex_file,
1192 dex_cache,
Andreas Gampe00b25f32014-09-17 21:49:05 -07001193 *options_->class_loader_,
Andreas Gampe2ed8def2014-08-28 14:41:02 -07001194 &class_def, code_item,
1195 NullHandle<mirror::ArtMethod>(),
1196 method_access_flags);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001197 }
Andreas Gampe2ed8def2014-08-28 14:41:02 -07001198
1199 return nullptr;
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001200 }
1201
Mathieu Chartier590fee92013-09-13 13:46:47 -07001202 void DumpCode(std::ostream& os, verifier::MethodVerifier* verifier,
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001203 const OatFile::OatMethod& oat_method, const DexFile::CodeItem* code_item,
1204 bool bad_input, size_t code_size) {
Ian Rogersef7d42f2014-01-06 12:55:46 -08001205 const void* portable_code = oat_method.GetPortableCode();
1206 const void* quick_code = oat_method.GetQuickCode();
1207
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001208 if (code_size == 0) {
1209 code_size = oat_method.GetQuickCodeSize();
1210 }
Ian Rogersef7d42f2014-01-06 12:55:46 -08001211 if ((code_size == 0) || ((portable_code == nullptr) && (quick_code == nullptr))) {
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001212 os << "NO CODE!\n";
Ian Rogersb23a7722012-10-09 16:54:26 -07001213 return;
Ian Rogersef7d42f2014-01-06 12:55:46 -08001214 } else if (quick_code != nullptr) {
1215 const uint8_t* quick_native_pc = reinterpret_cast<const uint8_t*>(quick_code);
1216 size_t offset = 0;
1217 while (offset < code_size) {
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001218 if (!bad_input) {
1219 DumpMappingAtOffset(os, oat_method, offset, false);
1220 }
Ian Rogersef7d42f2014-01-06 12:55:46 -08001221 offset += disassembler_->Dump(os, quick_native_pc + offset);
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001222 if (!bad_input) {
1223 uint32_t dex_pc = DumpMappingAtOffset(os, oat_method, offset, true);
1224 if (dex_pc != DexFile::kDexNoIndex) {
1225 DumpGcMapAtNativePcOffset(os, oat_method, code_item, offset);
1226 if (verifier != nullptr) {
1227 DumpVRegsAtDexPc(os, verifier, oat_method, code_item, dex_pc);
1228 }
Ian Rogersef7d42f2014-01-06 12:55:46 -08001229 }
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001230 }
1231 }
Ian Rogersef7d42f2014-01-06 12:55:46 -08001232 } else {
1233 CHECK(portable_code != nullptr);
1234 CHECK_EQ(code_size, 0U); // TODO: disassembly of portable is currently not supported.
Ian Rogersb23a7722012-10-09 16:54:26 -07001235 }
1236 }
1237
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001238 const OatFile& oat_file_;
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001239 const std::vector<const OatFile::OatDexFile*> oat_dex_files_;
1240 const OatDumperOptions* options_;
Ian Rogersef7d42f2014-01-06 12:55:46 -08001241 std::set<uintptr_t> offsets_;
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001242 Disassembler* disassembler_;
Brian Carlstromaded5f72011-10-07 17:15:04 -07001243};
1244
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001245class ImageDumper {
Brian Carlstrom27ec9612011-09-19 20:20:38 -07001246 public:
Brian Carlstrom2ec65202014-03-03 15:16:37 -08001247 explicit ImageDumper(std::ostream* os, gc::space::ImageSpace& image_space,
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001248 const ImageHeader& image_header, OatDumperOptions* oat_dumper_options)
1249 : os_(os),
1250 image_space_(image_space),
1251 image_header_(image_header),
1252 oat_dumper_options_(oat_dumper_options) {}
Brian Carlstrom27ec9612011-09-19 20:20:38 -07001253
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001254 bool Dump() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001255 std::ostream& os = *os_;
1256 os << "MAGIC: " << image_header_.GetMagic() << "\n\n";
Brian Carlstrome24fa612011-09-29 00:53:55 -07001257
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001258 os << "IMAGE BEGIN: " << reinterpret_cast<void*>(image_header_.GetImageBegin()) << "\n\n";
Brian Carlstromaded5f72011-10-07 17:15:04 -07001259
Mathieu Chartier31e89252013-08-28 11:29:12 -07001260 os << "IMAGE BITMAP OFFSET: " << reinterpret_cast<void*>(image_header_.GetImageBitmapOffset())
1261 << " SIZE: " << reinterpret_cast<void*>(image_header_.GetImageBitmapSize()) << "\n\n";
1262
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001263 os << "OAT CHECKSUM: " << StringPrintf("0x%08x\n\n", image_header_.GetOatChecksum());
Brian Carlstrom916e74e2011-09-23 11:42:01 -07001264
Brian Carlstrom700c8d32012-11-05 10:42:02 -08001265 os << "OAT FILE BEGIN:" << reinterpret_cast<void*>(image_header_.GetOatFileBegin()) << "\n\n";
Brian Carlstromaded5f72011-10-07 17:15:04 -07001266
Brian Carlstrom700c8d32012-11-05 10:42:02 -08001267 os << "OAT DATA BEGIN:" << reinterpret_cast<void*>(image_header_.GetOatDataBegin()) << "\n\n";
1268
1269 os << "OAT DATA END:" << reinterpret_cast<void*>(image_header_.GetOatDataEnd()) << "\n\n";
1270
1271 os << "OAT FILE END:" << reinterpret_cast<void*>(image_header_.GetOatFileEnd()) << "\n\n";
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001272
Alex Lighta59dd802014-07-02 16:28:08 -07001273 os << "PATCH DELTA:" << image_header_.GetPatchDelta() << "\n\n";
1274
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001275 {
1276 os << "ROOTS: " << reinterpret_cast<void*>(image_header_.GetImageRoots()) << "\n";
1277 Indenter indent1_filter(os.rdbuf(), kIndentChar, kIndentBy1Count);
1278 std::ostream indent1_os(&indent1_filter);
1279 CHECK_EQ(arraysize(image_roots_descriptions_), size_t(ImageHeader::kImageRootsMax));
1280 for (int i = 0; i < ImageHeader::kImageRootsMax; i++) {
1281 ImageHeader::ImageRoot image_root = static_cast<ImageHeader::ImageRoot>(i);
1282 const char* image_root_description = image_roots_descriptions_[i];
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001283 mirror::Object* image_root_object = image_header_.GetImageRoot(image_root);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001284 indent1_os << StringPrintf("%s: %p\n", image_root_description, image_root_object);
1285 if (image_root_object->IsObjectArray()) {
1286 Indenter indent2_filter(indent1_os.rdbuf(), kIndentChar, kIndentBy1Count);
1287 std::ostream indent2_os(&indent2_filter);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001288 mirror::ObjectArray<mirror::Object>* image_root_object_array
Ian Rogersfa824272013-11-05 16:12:57 -08001289 = image_root_object->AsObjectArray<mirror::Object>();
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001290 for (int i = 0; i < image_root_object_array->GetLength(); i++) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001291 mirror::Object* value = image_root_object_array->Get(i);
Ian Rogersfa824272013-11-05 16:12:57 -08001292 size_t run = 0;
1293 for (int32_t j = i + 1; j < image_root_object_array->GetLength(); j++) {
1294 if (value == image_root_object_array->Get(j)) {
1295 run++;
1296 } else {
1297 break;
1298 }
1299 }
1300 if (run == 0) {
1301 indent2_os << StringPrintf("%d: ", i);
1302 } else {
1303 indent2_os << StringPrintf("%d to %zd: ", i, i + run);
1304 i = i + run;
1305 }
Andreas Gampe2ed8def2014-08-28 14:41:02 -07001306 if (value != nullptr) {
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001307 PrettyObjectValue(indent2_os, value->GetClass(), value);
1308 } else {
1309 indent2_os << i << ": null\n";
1310 }
Ian Rogersd5b32602012-02-26 16:40:04 -08001311 }
Brian Carlstrom34f426c2011-10-04 12:58:02 -07001312 }
1313 }
Brian Carlstrom27ec9612011-09-19 20:20:38 -07001314 }
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001315 os << "\n";
Brian Carlstrom27ec9612011-09-19 20:20:38 -07001316
Brian Carlstromaded5f72011-10-07 17:15:04 -07001317 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
Brian Carlstrom2ec65202014-03-03 15:16:37 -08001318 std::string image_filename = image_space_.GetImageFilename();
1319 std::string oat_location = ImageHeader::GetOatLocationFromImageLocation(image_filename);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001320 os << "OAT LOCATION: " << oat_location;
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001321 os << "\n";
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001322 std::string error_msg;
Alex Lighta59dd802014-07-02 16:28:08 -07001323 const OatFile* oat_file = class_linker->FindOpenedOatFileFromOatLocation(oat_location);
1324 if (oat_file == nullptr) {
Andreas Gampe2ed8def2014-08-28 14:41:02 -07001325 oat_file = OatFile::Open(oat_location, oat_location, nullptr, false, &error_msg);
Alex Lighta59dd802014-07-02 16:28:08 -07001326 if (oat_file == nullptr) {
1327 os << "NOT FOUND: " << error_msg << "\n";
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001328 return false;
Alex Lighta59dd802014-07-02 16:28:08 -07001329 }
Brian Carlstromaded5f72011-10-07 17:15:04 -07001330 }
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001331 os << "\n";
Brian Carlstromaded5f72011-10-07 17:15:04 -07001332
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001333 stats_.oat_file_bytes = oat_file->Size();
1334
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001335 oat_dumper_.reset(new OatDumper(*oat_file, oat_dumper_options_.release()));
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001336
Mathieu Chartier02e25112013-08-14 16:14:24 -07001337 for (const OatFile::OatDexFile* oat_dex_file : oat_file->GetOatDexFiles()) {
Andreas Gampe2ed8def2014-08-28 14:41:02 -07001338 CHECK(oat_dex_file != nullptr);
Mathieu Chartier02e25112013-08-14 16:14:24 -07001339 stats_.oat_dex_file_sizes.push_back(std::make_pair(oat_dex_file->GetDexFileLocation(),
1340 oat_dex_file->FileSize()));
Ian Rogers05f28c62012-10-23 18:12:13 -07001341 }
1342
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001343 os << "OBJECTS:\n" << std::flush;
Mathieu Chartierb062fdd2012-07-03 09:51:48 -07001344
1345 // Loop through all the image spaces and dump their objects.
Ian Rogers1d54e732013-05-02 21:10:01 -07001346 gc::Heap* heap = Runtime::Current()->GetHeap();
1347 const std::vector<gc::space::ContinuousSpace*>& spaces = heap->GetContinuousSpaces();
Ian Rogers50b35e22012-10-04 10:09:15 -07001348 Thread* self = Thread::Current();
Mathieu Chartier357e9be2012-08-01 11:00:14 -07001349 {
Mathieu Chartierc22c59e2014-02-24 15:16:06 -08001350 {
1351 WriterMutexLock mu(self, *Locks::heap_bitmap_lock_);
1352 heap->FlushAllocStack();
1353 }
Hiroshi Yamauchi90d70682014-02-20 16:17:30 -08001354 // Since FlushAllocStack() above resets the (active) allocation
1355 // stack. Need to revoke the thread-local allocation stacks that
1356 // point into it.
Mathieu Chartierc22c59e2014-02-24 15:16:06 -08001357 {
1358 self->TransitionFromRunnableToSuspended(kNative);
1359 ThreadList* thread_list = Runtime::Current()->GetThreadList();
1360 thread_list->SuspendAll();
1361 heap->RevokeAllThreadLocalAllocationStacks(self);
1362 thread_list->ResumeAll();
1363 self->TransitionFromSuspendedToRunnable();
1364 }
Mathieu Chartier357e9be2012-08-01 11:00:14 -07001365 }
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001366 {
1367 std::ostream* saved_os = os_;
1368 Indenter indent_filter(os.rdbuf(), kIndentChar, kIndentBy1Count);
1369 std::ostream indent_os(&indent_filter);
1370 os_ = &indent_os;
1371 ReaderMutexLock mu(self, *Locks::heap_bitmap_lock_);
Mathieu Chartier02e25112013-08-14 16:14:24 -07001372 for (const auto& space : spaces) {
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001373 if (space->IsImageSpace()) {
Ian Rogers1d54e732013-05-02 21:10:01 -07001374 gc::space::ImageSpace* image_space = space->AsImageSpace();
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001375 image_space->GetLiveBitmap()->Walk(ImageDumper::Callback, this);
1376 indent_os << "\n";
1377 }
Mathieu Chartier2fde5332012-09-14 14:51:54 -07001378 }
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001379 // Dump the large objects separately.
Mathieu Chartierbbd695c2014-04-16 09:48:48 -07001380 heap->GetLargeObjectsSpace()->GetLiveBitmap()->Walk(ImageDumper::Callback, this);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001381 indent_os << "\n";
1382 os_ = saved_os;
Mathieu Chartierb062fdd2012-07-03 09:51:48 -07001383 }
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001384 os << "STATS:\n" << std::flush;
Ian Rogers700a4022014-05-19 16:49:03 -07001385 std::unique_ptr<File> file(OS::OpenFileForReading(image_filename.c_str()));
Andreas Gampe2ed8def2014-08-28 14:41:02 -07001386 if (file.get() == nullptr) {
Brian Carlstrom2ec65202014-03-03 15:16:37 -08001387 LOG(WARNING) << "Failed to find image in " << image_filename;
Brian Carlstrom6f277752013-09-30 17:56:45 -07001388 }
Andreas Gampe2ed8def2014-08-28 14:41:02 -07001389 if (file.get() != nullptr) {
Brian Carlstrom2ec65202014-03-03 15:16:37 -08001390 stats_.file_bytes = file->GetLength();
Brian Carlstrom6f277752013-09-30 17:56:45 -07001391 }
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001392 size_t header_bytes = sizeof(ImageHeader);
1393 stats_.header_bytes = header_bytes;
1394 size_t alignment_bytes = RoundUp(header_bytes, kObjectAlignment) - header_bytes;
1395 stats_.alignment_bytes += alignment_bytes;
Mathieu Chartier32327092013-08-30 14:04:08 -07001396 stats_.alignment_bytes += image_header_.GetImageBitmapOffset() - image_header_.GetImageSize();
1397 stats_.bitmap_bytes += image_header_.GetImageBitmapSize();
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001398 stats_.Dump(os);
1399 os << "\n";
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001400
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001401 os << std::flush;
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001402
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001403 return oat_dumper_->Dump(os);
Brian Carlstrom78128a62011-09-15 17:21:19 -07001404 }
1405
Brian Carlstrom27ec9612011-09-19 20:20:38 -07001406 private:
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001407 static void PrettyObjectValue(std::ostream& os, mirror::Class* type, mirror::Object* value)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001408 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Andreas Gampe2ed8def2014-08-28 14:41:02 -07001409 CHECK(type != nullptr);
1410 if (value == nullptr) {
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001411 os << StringPrintf("null %s\n", PrettyDescriptor(type).c_str());
Ian Rogersd5b32602012-02-26 16:40:04 -08001412 } else if (type->IsStringClass()) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001413 mirror::String* string = value->AsString();
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001414 os << StringPrintf("%p String: %s\n", string,
Ian Rogers68b56852014-08-29 20:19:11 -07001415 PrintableString(string->ToModifiedUtf8().c_str()).c_str());
Ian Rogers64b6d142012-10-29 16:34:15 -07001416 } else if (type->IsClassClass()) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001417 mirror::Class* klass = value->AsClass();
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001418 os << StringPrintf("%p Class: %s\n", klass, PrettyDescriptor(klass).c_str());
Brian Carlstromea46f952013-07-30 01:26:50 -07001419 } else if (type->IsArtFieldClass()) {
1420 mirror::ArtField* field = value->AsArtField();
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001421 os << StringPrintf("%p Field: %s\n", field, PrettyField(field).c_str());
Brian Carlstromea46f952013-07-30 01:26:50 -07001422 } else if (type->IsArtMethodClass()) {
1423 mirror::ArtMethod* method = value->AsArtMethod();
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001424 os << StringPrintf("%p Method: %s\n", method, PrettyMethod(method).c_str());
Ian Rogersd5b32602012-02-26 16:40:04 -08001425 } else {
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001426 os << StringPrintf("%p %s\n", value, PrettyDescriptor(type).c_str());
Ian Rogersd5b32602012-02-26 16:40:04 -08001427 }
1428 }
1429
Brian Carlstromea46f952013-07-30 01:26:50 -07001430 static void PrintField(std::ostream& os, mirror::ArtField* field, mirror::Object* obj)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001431 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -07001432 const char* descriptor = field->GetTypeDescriptor();
1433 os << StringPrintf("%s: ", field->GetName());
Ian Rogers48efc2b2012-08-27 17:20:31 -07001434 if (descriptor[0] != 'L' && descriptor[0] != '[') {
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -07001435 StackHandleScope<1> hs(Thread::Current());
1436 FieldHelper fh(hs.NewHandle(field));
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001437 mirror::Class* type = fh.GetType();
Fred Shih37f05ef2014-07-16 18:38:08 -07001438 DCHECK(type->IsPrimitive());
Ian Rogers48efc2b2012-08-27 17:20:31 -07001439 if (type->IsPrimitiveLong()) {
Ian Rogersef7d42f2014-01-06 12:55:46 -08001440 os << StringPrintf("%" PRId64 " (0x%" PRIx64 ")\n", field->Get64(obj), field->Get64(obj));
Ian Rogers48efc2b2012-08-27 17:20:31 -07001441 } else if (type->IsPrimitiveDouble()) {
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001442 os << StringPrintf("%f (%a)\n", field->GetDouble(obj), field->GetDouble(obj));
Ian Rogers48efc2b2012-08-27 17:20:31 -07001443 } else if (type->IsPrimitiveFloat()) {
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001444 os << StringPrintf("%f (%a)\n", field->GetFloat(obj), field->GetFloat(obj));
Fred Shih37f05ef2014-07-16 18:38:08 -07001445 } else if (type->IsPrimitiveInt()) {
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001446 os << StringPrintf("%d (0x%x)\n", field->Get32(obj), field->Get32(obj));
Fred Shih37f05ef2014-07-16 18:38:08 -07001447 } else if (type->IsPrimitiveChar()) {
1448 os << StringPrintf("%u (0x%x)\n", field->GetChar(obj), field->GetChar(obj));
1449 } else if (type->IsPrimitiveShort()) {
1450 os << StringPrintf("%d (0x%x)\n", field->GetShort(obj), field->GetShort(obj));
1451 } else if (type->IsPrimitiveBoolean()) {
1452 os << StringPrintf("%s (0x%x)\n", field->GetBoolean(obj)? "true" : "false",
1453 field->GetBoolean(obj));
1454 } else if (type->IsPrimitiveByte()) {
1455 os << StringPrintf("%d (0x%x)\n", field->GetByte(obj), field->GetByte(obj));
1456 } else {
1457 LOG(FATAL) << "Unknown type: " << PrettyClass(type);
Ian Rogers48efc2b2012-08-27 17:20:31 -07001458 }
Ian Rogersd5b32602012-02-26 16:40:04 -08001459 } else {
Ian Rogers48efc2b2012-08-27 17:20:31 -07001460 // Get the value, don't compute the type unless it is non-null as we don't want
1461 // to cause class loading.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001462 mirror::Object* value = field->GetObj(obj);
Andreas Gampe2ed8def2014-08-28 14:41:02 -07001463 if (value == nullptr) {
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001464 os << StringPrintf("null %s\n", PrettyDescriptor(descriptor).c_str());
Ian Rogers48efc2b2012-08-27 17:20:31 -07001465 } else {
Ian Rogers50239c72013-06-17 14:53:22 -07001466 // Grab the field type without causing resolution.
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -07001467 StackHandleScope<1> hs(Thread::Current());
1468 FieldHelper fh(hs.NewHandle(field));
Ian Rogers50239c72013-06-17 14:53:22 -07001469 mirror::Class* field_type = fh.GetType(false);
Andreas Gampe2ed8def2014-08-28 14:41:02 -07001470 if (field_type != nullptr) {
Ian Rogers50239c72013-06-17 14:53:22 -07001471 PrettyObjectValue(os, field_type, value);
1472 } else {
1473 os << StringPrintf("%p %s\n", value, PrettyDescriptor(descriptor).c_str());
1474 }
Ian Rogers48efc2b2012-08-27 17:20:31 -07001475 }
Ian Rogersd5b32602012-02-26 16:40:04 -08001476 }
1477 }
1478
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001479 static void DumpFields(std::ostream& os, mirror::Object* obj, mirror::Class* klass)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001480 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001481 mirror::Class* super = klass->GetSuperClass();
Andreas Gampe2ed8def2014-08-28 14:41:02 -07001482 if (super != nullptr) {
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001483 DumpFields(os, obj, super);
Ian Rogersd5b32602012-02-26 16:40:04 -08001484 }
Brian Carlstromea46f952013-07-30 01:26:50 -07001485 mirror::ObjectArray<mirror::ArtField>* fields = klass->GetIFields();
Andreas Gampe2ed8def2014-08-28 14:41:02 -07001486 if (fields != nullptr) {
Ian Rogersd5b32602012-02-26 16:40:04 -08001487 for (int32_t i = 0; i < fields->GetLength(); i++) {
Brian Carlstromea46f952013-07-30 01:26:50 -07001488 mirror::ArtField* field = fields->Get(i);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001489 PrintField(os, field, obj);
Ian Rogersd5b32602012-02-26 16:40:04 -08001490 }
1491 }
1492 }
1493
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001494 bool InDumpSpace(const mirror::Object* object) {
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001495 return image_space_.Contains(object);
Brian Carlstromf8bbb842012-03-14 03:01:42 -07001496 }
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001497
Ian Rogersef7d42f2014-01-06 12:55:46 -08001498 const void* GetQuickOatCodeBegin(mirror::ArtMethod* m)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001499 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogersef7d42f2014-01-06 12:55:46 -08001500 const void* quick_code = m->GetEntryPointFromQuickCompiledCode();
Ian Rogers6f3dbba2014-10-14 17:41:57 -07001501 if (Runtime::Current()->GetClassLinker()->IsQuickResolutionStub(quick_code)) {
Ian Rogersef7d42f2014-01-06 12:55:46 -08001502 quick_code = oat_dumper_->GetQuickOatCode(m);
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001503 }
Brian Carlstromf8bbb842012-03-14 03:01:42 -07001504 if (oat_dumper_->GetInstructionSet() == kThumb2) {
Ian Rogersef7d42f2014-01-06 12:55:46 -08001505 quick_code = reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(quick_code) & ~0x1);
Brian Carlstromf8bbb842012-03-14 03:01:42 -07001506 }
Ian Rogersef7d42f2014-01-06 12:55:46 -08001507 return quick_code;
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001508 }
1509
Ian Rogersef7d42f2014-01-06 12:55:46 -08001510 uint32_t GetQuickOatCodeSize(mirror::ArtMethod* m)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001511 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogersef7d42f2014-01-06 12:55:46 -08001512 const uint32_t* oat_code_begin = reinterpret_cast<const uint32_t*>(GetQuickOatCodeBegin(m));
1513 if (oat_code_begin == nullptr) {
Brian Carlstromf8bbb842012-03-14 03:01:42 -07001514 return 0;
1515 }
1516 return oat_code_begin[-1];
1517 }
1518
Ian Rogersef7d42f2014-01-06 12:55:46 -08001519 const void* GetQuickOatCodeEnd(mirror::ArtMethod* m)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001520 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogersef7d42f2014-01-06 12:55:46 -08001521 const uint8_t* oat_code_begin = reinterpret_cast<const uint8_t*>(GetQuickOatCodeBegin(m));
Andreas Gampe2ed8def2014-08-28 14:41:02 -07001522 if (oat_code_begin == nullptr) {
1523 return nullptr;
Brian Carlstromf8bbb842012-03-14 03:01:42 -07001524 }
Ian Rogersef7d42f2014-01-06 12:55:46 -08001525 return oat_code_begin + GetQuickOatCodeSize(m);
Brian Carlstromf8bbb842012-03-14 03:01:42 -07001526 }
1527
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001528 static void Callback(mirror::Object* obj, void* arg)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001529 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Andreas Gampe2ed8def2014-08-28 14:41:02 -07001530 DCHECK(obj != nullptr);
1531 DCHECK(arg != nullptr);
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001532 ImageDumper* state = reinterpret_cast<ImageDumper*>(arg);
Brian Carlstrom78128a62011-09-15 17:21:19 -07001533 if (!state->InDumpSpace(obj)) {
1534 return;
1535 }
Brian Carlstrom916e74e2011-09-23 11:42:01 -07001536
1537 size_t object_bytes = obj->SizeOf();
1538 size_t alignment_bytes = RoundUp(object_bytes, kObjectAlignment) - object_bytes;
1539 state->stats_.object_bytes += object_bytes;
1540 state->stats_.alignment_bytes += alignment_bytes;
1541
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001542 std::ostream& os = *state->os_;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001543 mirror::Class* obj_class = obj->GetClass();
Ian Rogersd5b32602012-02-26 16:40:04 -08001544 if (obj_class->IsArrayClass()) {
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001545 os << StringPrintf("%p: %s length:%d\n", obj, PrettyDescriptor(obj_class).c_str(),
1546 obj->AsArray()->GetLength());
Ian Rogersd5b32602012-02-26 16:40:04 -08001547 } else if (obj->IsClass()) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001548 mirror::Class* klass = obj->AsClass();
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001549 os << StringPrintf("%p: java.lang.Class \"%s\" (", obj, PrettyDescriptor(klass).c_str())
1550 << klass->GetStatus() << ")\n";
Brian Carlstromea46f952013-07-30 01:26:50 -07001551 } else if (obj->IsArtField()) {
Brian Carlstrom4b8c13e2013-08-23 18:10:32 -07001552 os << StringPrintf("%p: java.lang.reflect.ArtField %s\n", obj,
Brian Carlstromea46f952013-07-30 01:26:50 -07001553 PrettyField(obj->AsArtField()).c_str());
1554 } else if (obj->IsArtMethod()) {
Brian Carlstrom4b8c13e2013-08-23 18:10:32 -07001555 os << StringPrintf("%p: java.lang.reflect.ArtMethod %s\n", obj,
Brian Carlstromea46f952013-07-30 01:26:50 -07001556 PrettyMethod(obj->AsArtMethod()).c_str());
Ian Rogersd5b32602012-02-26 16:40:04 -08001557 } else if (obj_class->IsStringClass()) {
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001558 os << StringPrintf("%p: java.lang.String %s\n", obj,
Ian Rogers68b56852014-08-29 20:19:11 -07001559 PrintableString(obj->AsString()->ToModifiedUtf8().c_str()).c_str());
Ian Rogersd5b32602012-02-26 16:40:04 -08001560 } else {
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001561 os << StringPrintf("%p: %s\n", obj, PrettyDescriptor(obj_class).c_str());
Ian Rogersd5b32602012-02-26 16:40:04 -08001562 }
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001563 Indenter indent_filter(os.rdbuf(), kIndentChar, kIndentBy1Count);
1564 std::ostream indent_os(&indent_filter);
1565 DumpFields(indent_os, obj, obj_class);
Ian Rogersd5b32602012-02-26 16:40:04 -08001566 if (obj->IsObjectArray()) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001567 mirror::ObjectArray<mirror::Object>* obj_array = obj->AsObjectArray<mirror::Object>();
Ian Rogersd5b32602012-02-26 16:40:04 -08001568 int32_t length = obj_array->GetLength();
1569 for (int32_t i = 0; i < length; i++) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001570 mirror::Object* value = obj_array->Get(i);
Ian Rogersd5b32602012-02-26 16:40:04 -08001571 size_t run = 0;
1572 for (int32_t j = i + 1; j < length; j++) {
1573 if (value == obj_array->Get(j)) {
1574 run++;
1575 } else {
1576 break;
1577 }
1578 }
1579 if (run == 0) {
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001580 indent_os << StringPrintf("%d: ", i);
Ian Rogersd5b32602012-02-26 16:40:04 -08001581 } else {
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001582 indent_os << StringPrintf("%d to %zd: ", i, i + run);
Ian Rogersd5b32602012-02-26 16:40:04 -08001583 i = i + run;
1584 }
Brian Carlstrom2ec65202014-03-03 15:16:37 -08001585 mirror::Class* value_class =
Andreas Gampe2ed8def2014-08-28 14:41:02 -07001586 (value == nullptr) ? obj_class->GetComponentType() : value->GetClass();
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001587 PrettyObjectValue(indent_os, value_class, value);
Ian Rogersd5b32602012-02-26 16:40:04 -08001588 }
1589 } else if (obj->IsClass()) {
Brian Carlstromea46f952013-07-30 01:26:50 -07001590 mirror::ObjectArray<mirror::ArtField>* sfields = obj->AsClass()->GetSFields();
Andreas Gampe2ed8def2014-08-28 14:41:02 -07001591 if (sfields != nullptr) {
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001592 indent_os << "STATICS:\n";
1593 Indenter indent2_filter(indent_os.rdbuf(), kIndentChar, kIndentBy1Count);
1594 std::ostream indent2_os(&indent2_filter);
Ian Rogersd5b32602012-02-26 16:40:04 -08001595 for (int32_t i = 0; i < sfields->GetLength(); i++) {
Brian Carlstromea46f952013-07-30 01:26:50 -07001596 mirror::ArtField* field = sfields->Get(i);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001597 PrintField(indent2_os, field, field->GetDeclaringClass());
Ian Rogersd5b32602012-02-26 16:40:04 -08001598 }
1599 }
Brian Carlstromea46f952013-07-30 01:26:50 -07001600 } else if (obj->IsArtMethod()) {
1601 mirror::ArtMethod* method = obj->AsArtMethod();
Brian Carlstrom78128a62011-09-15 17:21:19 -07001602 if (method->IsNative()) {
Ian Rogersef7d42f2014-01-06 12:55:46 -08001603 // TODO: portable dumping.
1604 DCHECK(method->GetNativeGcMap() == nullptr) << PrettyMethod(method);
1605 DCHECK(method->GetMappingTable() == nullptr) << PrettyMethod(method);
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001606 bool first_occurrence;
Ian Rogersef7d42f2014-01-06 12:55:46 -08001607 const void* quick_oat_code = state->GetQuickOatCodeBegin(method);
1608 uint32_t quick_oat_code_size = state->GetQuickOatCodeSize(method);
1609 state->ComputeOatSize(quick_oat_code, &first_occurrence);
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001610 if (first_occurrence) {
Ian Rogersef7d42f2014-01-06 12:55:46 -08001611 state->stats_.native_to_managed_code_bytes += quick_oat_code_size;
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001612 }
Ian Rogersef7d42f2014-01-06 12:55:46 -08001613 if (quick_oat_code != method->GetEntryPointFromQuickCompiledCode()) {
1614 indent_os << StringPrintf("OAT CODE: %p\n", quick_oat_code);
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001615 }
Ian Rogers19846512012-02-24 11:42:47 -08001616 } else if (method->IsAbstract() || method->IsCalleeSaveMethod() ||
Jeff Hao88474b42013-10-23 16:24:40 -07001617 method->IsResolutionMethod() || method->IsImtConflictMethod() ||
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07001618 method->IsClassInitializer()) {
Andreas Gampe2ed8def2014-08-28 14:41:02 -07001619 DCHECK(method->GetNativeGcMap() == nullptr) << PrettyMethod(method);
1620 DCHECK(method->GetMappingTable() == nullptr) << PrettyMethod(method);
Brian Carlstrom916e74e2011-09-23 11:42:01 -07001621 } else {
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07001622 const DexFile::CodeItem* code_item = method->GetCodeItem();
Ian Rogersd81871c2011-10-03 13:57:23 -07001623 size_t dex_instruction_bytes = code_item->insns_size_in_code_units_ * 2;
Brian Carlstrom916e74e2011-09-23 11:42:01 -07001624 state->stats_.dex_instruction_bytes += dex_instruction_bytes;
Brian Carlstrome7d856b2012-01-11 18:10:55 -08001625
Elliott Hughesa0e18062012-04-13 15:59:59 -07001626 bool first_occurrence;
Ian Rogers0c7abda2012-09-19 13:33:42 -07001627 size_t gc_map_bytes = state->ComputeOatSize(method->GetNativeGcMap(), &first_occurrence);
Elliott Hughesa0e18062012-04-13 15:59:59 -07001628 if (first_occurrence) {
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001629 state->stats_.gc_map_bytes += gc_map_bytes;
1630 }
1631
1632 size_t pc_mapping_table_bytes =
Ian Rogers1809a722013-08-09 22:05:32 -07001633 state->ComputeOatSize(method->GetMappingTable(), &first_occurrence);
Elliott Hughesa0e18062012-04-13 15:59:59 -07001634 if (first_occurrence) {
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001635 state->stats_.pc_mapping_table_bytes += pc_mapping_table_bytes;
1636 }
1637
1638 size_t vmap_table_bytes =
Ian Rogers1809a722013-08-09 22:05:32 -07001639 state->ComputeOatSize(method->GetVmapTable(), &first_occurrence);
Elliott Hughesa0e18062012-04-13 15:59:59 -07001640 if (first_occurrence) {
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001641 state->stats_.vmap_table_bytes += vmap_table_bytes;
1642 }
1643
Ian Rogersef7d42f2014-01-06 12:55:46 -08001644 // TODO: portable dumping.
1645 const void* quick_oat_code_begin = state->GetQuickOatCodeBegin(method);
1646 const void* quick_oat_code_end = state->GetQuickOatCodeEnd(method);
1647 uint32_t quick_oat_code_size = state->GetQuickOatCodeSize(method);
1648 state->ComputeOatSize(quick_oat_code_begin, &first_occurrence);
Elliott Hughesa0e18062012-04-13 15:59:59 -07001649 if (first_occurrence) {
Ian Rogersef7d42f2014-01-06 12:55:46 -08001650 state->stats_.managed_code_bytes += quick_oat_code_size;
Ian Rogers0d2d3782012-04-10 11:09:18 -07001651 if (method->IsConstructor()) {
1652 if (method->IsStatic()) {
Ian Rogersef7d42f2014-01-06 12:55:46 -08001653 state->stats_.class_initializer_code_bytes += quick_oat_code_size;
Ian Rogers0d2d3782012-04-10 11:09:18 -07001654 } else if (dex_instruction_bytes > kLargeConstructorDexBytes) {
Ian Rogersef7d42f2014-01-06 12:55:46 -08001655 state->stats_.large_initializer_code_bytes += quick_oat_code_size;
Ian Rogers0d2d3782012-04-10 11:09:18 -07001656 }
1657 } else if (dex_instruction_bytes > kLargeMethodDexBytes) {
Ian Rogersef7d42f2014-01-06 12:55:46 -08001658 state->stats_.large_method_code_bytes += quick_oat_code_size;
Ian Rogers0d2d3782012-04-10 11:09:18 -07001659 }
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001660 }
Ian Rogersef7d42f2014-01-06 12:55:46 -08001661 state->stats_.managed_code_bytes_ignoring_deduplication += quick_oat_code_size;
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001662
Ian Rogersef7d42f2014-01-06 12:55:46 -08001663 indent_os << StringPrintf("OAT CODE: %p-%p\n", quick_oat_code_begin, quick_oat_code_end);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001664 indent_os << StringPrintf("SIZE: Dex Instructions=%zd GC=%zd Mapping=%zd\n",
1665 dex_instruction_bytes, gc_map_bytes, pc_mapping_table_bytes);
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001666
1667 size_t total_size = dex_instruction_bytes + gc_map_bytes + pc_mapping_table_bytes +
Ian Rogersef7d42f2014-01-06 12:55:46 -08001668 vmap_table_bytes + quick_oat_code_size + object_bytes;
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001669
1670 double expansion =
Ian Rogersef7d42f2014-01-06 12:55:46 -08001671 static_cast<double>(quick_oat_code_size) / static_cast<double>(dex_instruction_bytes);
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001672 state->stats_.ComputeOutliers(total_size, expansion, method);
Brian Carlstrom78128a62011-09-15 17:21:19 -07001673 }
1674 }
Ian Rogers1ff3c982014-08-12 02:30:58 -07001675 std::string temp;
1676 state->stats_.Update(obj_class->GetDescriptor(&temp), object_bytes);
Brian Carlstrom78128a62011-09-15 17:21:19 -07001677 }
Brian Carlstrom27ec9612011-09-19 20:20:38 -07001678
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001679 std::set<const void*> already_seen_;
1680 // Compute the size of the given data within the oat file and whether this is the first time
1681 // this data has been requested
Elliott Hughesa0e18062012-04-13 15:59:59 -07001682 size_t ComputeOatSize(const void* oat_data, bool* first_occurrence) {
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001683 if (already_seen_.count(oat_data) == 0) {
Elliott Hughesa0e18062012-04-13 15:59:59 -07001684 *first_occurrence = true;
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001685 already_seen_.insert(oat_data);
1686 } else {
Elliott Hughesa0e18062012-04-13 15:59:59 -07001687 *first_occurrence = false;
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001688 }
1689 return oat_dumper_->ComputeSize(oat_data);
Brian Carlstrom27ec9612011-09-19 20:20:38 -07001690 }
Brian Carlstrom916e74e2011-09-23 11:42:01 -07001691
1692 public:
1693 struct Stats {
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001694 size_t oat_file_bytes;
Brian Carlstrom916e74e2011-09-23 11:42:01 -07001695 size_t file_bytes;
1696
1697 size_t header_bytes;
1698 size_t object_bytes;
Mathieu Chartier32327092013-08-30 14:04:08 -07001699 size_t bitmap_bytes;
Brian Carlstrom916e74e2011-09-23 11:42:01 -07001700 size_t alignment_bytes;
1701
1702 size_t managed_code_bytes;
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001703 size_t managed_code_bytes_ignoring_deduplication;
Brian Carlstrom916e74e2011-09-23 11:42:01 -07001704 size_t managed_to_native_code_bytes;
1705 size_t native_to_managed_code_bytes;
Ian Rogers0d2d3782012-04-10 11:09:18 -07001706 size_t class_initializer_code_bytes;
1707 size_t large_initializer_code_bytes;
1708 size_t large_method_code_bytes;
Brian Carlstrom916e74e2011-09-23 11:42:01 -07001709
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001710 size_t gc_map_bytes;
Brian Carlstrom916e74e2011-09-23 11:42:01 -07001711 size_t pc_mapping_table_bytes;
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001712 size_t vmap_table_bytes;
Brian Carlstrom916e74e2011-09-23 11:42:01 -07001713
1714 size_t dex_instruction_bytes;
1715
Brian Carlstromea46f952013-07-30 01:26:50 -07001716 std::vector<mirror::ArtMethod*> method_outlier;
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001717 std::vector<size_t> method_outlier_size;
1718 std::vector<double> method_outlier_expansion;
Ian Rogers700a4022014-05-19 16:49:03 -07001719 std::vector<std::pair<std::string, size_t>> oat_dex_file_sizes;
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001720
1721 explicit Stats()
1722 : oat_file_bytes(0),
1723 file_bytes(0),
Brian Carlstrom916e74e2011-09-23 11:42:01 -07001724 header_bytes(0),
1725 object_bytes(0),
Mathieu Chartier32327092013-08-30 14:04:08 -07001726 bitmap_bytes(0),
Brian Carlstrom916e74e2011-09-23 11:42:01 -07001727 alignment_bytes(0),
1728 managed_code_bytes(0),
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001729 managed_code_bytes_ignoring_deduplication(0),
Brian Carlstrom916e74e2011-09-23 11:42:01 -07001730 managed_to_native_code_bytes(0),
1731 native_to_managed_code_bytes(0),
Ian Rogers0d2d3782012-04-10 11:09:18 -07001732 class_initializer_code_bytes(0),
1733 large_initializer_code_bytes(0),
1734 large_method_code_bytes(0),
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001735 gc_map_bytes(0),
Brian Carlstrom916e74e2011-09-23 11:42:01 -07001736 pc_mapping_table_bytes(0),
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001737 vmap_table_bytes(0),
Brian Carlstrom916e74e2011-09-23 11:42:01 -07001738 dex_instruction_bytes(0) {}
1739
Elliott Hughesa0e18062012-04-13 15:59:59 -07001740 struct SizeAndCount {
1741 SizeAndCount(size_t bytes, size_t count) : bytes(bytes), count(count) {}
1742 size_t bytes;
1743 size_t count;
1744 };
1745 typedef SafeMap<std::string, SizeAndCount> SizeAndCountTable;
1746 SizeAndCountTable sizes_and_counts;
Brian Carlstrom916e74e2011-09-23 11:42:01 -07001747
Ian Rogersfc0e94b2013-09-23 23:51:32 -07001748 void Update(const char* descriptor, size_t object_bytes) {
Elliott Hughesa0e18062012-04-13 15:59:59 -07001749 SizeAndCountTable::iterator it = sizes_and_counts.find(descriptor);
1750 if (it != sizes_and_counts.end()) {
1751 it->second.bytes += object_bytes;
1752 it->second.count += 1;
1753 } else {
1754 sizes_and_counts.Put(descriptor, SizeAndCount(object_bytes, 1));
1755 }
1756 }
Brian Carlstrom916e74e2011-09-23 11:42:01 -07001757
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001758 double PercentOfOatBytes(size_t size) {
1759 return (static_cast<double>(size) / static_cast<double>(oat_file_bytes)) * 100;
1760 }
1761
Brian Carlstrom916e74e2011-09-23 11:42:01 -07001762 double PercentOfFileBytes(size_t size) {
1763 return (static_cast<double>(size) / static_cast<double>(file_bytes)) * 100;
1764 }
1765
1766 double PercentOfObjectBytes(size_t size) {
1767 return (static_cast<double>(size) / static_cast<double>(object_bytes)) * 100;
1768 }
1769
Brian Carlstromea46f952013-07-30 01:26:50 -07001770 void ComputeOutliers(size_t total_size, double expansion, mirror::ArtMethod* method) {
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001771 method_outlier_size.push_back(total_size);
1772 method_outlier_expansion.push_back(expansion);
1773 method_outlier.push_back(method);
1774 }
Brian Carlstrom916e74e2011-09-23 11:42:01 -07001775
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001776 void DumpOutliers(std::ostream& os)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001777 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001778 size_t sum_of_sizes = 0;
1779 size_t sum_of_sizes_squared = 0;
1780 size_t sum_of_expansion = 0;
1781 size_t sum_of_expansion_squared = 0;
1782 size_t n = method_outlier_size.size();
1783 for (size_t i = 0; i < n; i++) {
1784 size_t cur_size = method_outlier_size[i];
1785 sum_of_sizes += cur_size;
1786 sum_of_sizes_squared += cur_size * cur_size;
1787 double cur_expansion = method_outlier_expansion[i];
1788 sum_of_expansion += cur_expansion;
1789 sum_of_expansion_squared += cur_expansion * cur_expansion;
1790 }
1791 size_t size_mean = sum_of_sizes / n;
1792 size_t size_variance = (sum_of_sizes_squared - sum_of_sizes * size_mean) / (n - 1);
1793 double expansion_mean = sum_of_expansion / n;
1794 double expansion_variance =
1795 (sum_of_expansion_squared - sum_of_expansion * expansion_mean) / (n - 1);
1796
1797 // Dump methods whose size is a certain number of standard deviations from the mean
1798 size_t dumped_values = 0;
1799 size_t skipped_values = 0;
1800 for (size_t i = 100; i > 0; i--) { // i is the current number of standard deviations
1801 size_t cur_size_variance = i * i * size_variance;
1802 bool first = true;
1803 for (size_t j = 0; j < n; j++) {
1804 size_t cur_size = method_outlier_size[j];
1805 if (cur_size > size_mean) {
1806 size_t cur_var = cur_size - size_mean;
1807 cur_var = cur_var * cur_var;
1808 if (cur_var > cur_size_variance) {
1809 if (dumped_values > 20) {
1810 if (i == 1) {
1811 skipped_values++;
1812 } else {
1813 i = 2; // jump to counting for 1 standard deviation
1814 break;
1815 }
1816 } else {
1817 if (first) {
Elliott Hughesc073b072012-05-24 19:29:17 -07001818 os << "\nBig methods (size > " << i << " standard deviations the norm):\n";
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001819 first = false;
1820 }
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001821 os << PrettyMethod(method_outlier[j]) << " requires storage of "
Elliott Hughesc073b072012-05-24 19:29:17 -07001822 << PrettySize(cur_size) << "\n";
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001823 method_outlier_size[j] = 0; // don't consider this method again
1824 dumped_values++;
1825 }
1826 }
1827 }
1828 }
1829 }
1830 if (skipped_values > 0) {
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001831 os << "... skipped " << skipped_values
Elliott Hughesc073b072012-05-24 19:29:17 -07001832 << " methods with size > 1 standard deviation from the norm\n";
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001833 }
Elliott Hughesc073b072012-05-24 19:29:17 -07001834 os << std::flush;
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001835
1836 // Dump methods whose expansion is a certain number of standard deviations from the mean
1837 dumped_values = 0;
1838 skipped_values = 0;
1839 for (size_t i = 10; i > 0; i--) { // i is the current number of standard deviations
1840 double cur_expansion_variance = i * i * expansion_variance;
1841 bool first = true;
1842 for (size_t j = 0; j < n; j++) {
1843 double cur_expansion = method_outlier_expansion[j];
1844 if (cur_expansion > expansion_mean) {
1845 size_t cur_var = cur_expansion - expansion_mean;
1846 cur_var = cur_var * cur_var;
1847 if (cur_var > cur_expansion_variance) {
1848 if (dumped_values > 20) {
1849 if (i == 1) {
1850 skipped_values++;
1851 } else {
1852 i = 2; // jump to counting for 1 standard deviation
1853 break;
1854 }
1855 } else {
1856 if (first) {
1857 os << "\nLarge expansion methods (size > " << i
Elliott Hughesc073b072012-05-24 19:29:17 -07001858 << " standard deviations the norm):\n";
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001859 first = false;
1860 }
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001861 os << PrettyMethod(method_outlier[j]) << " expanded code by "
Elliott Hughesc073b072012-05-24 19:29:17 -07001862 << cur_expansion << "\n";
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001863 method_outlier_expansion[j] = 0.0; // don't consider this method again
1864 dumped_values++;
1865 }
1866 }
1867 }
1868 }
1869 }
1870 if (skipped_values > 0) {
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001871 os << "... skipped " << skipped_values
Elliott Hughesc073b072012-05-24 19:29:17 -07001872 << " methods with expansion > 1 standard deviation from the norm\n";
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001873 }
Elliott Hughesc073b072012-05-24 19:29:17 -07001874 os << "\n" << std::flush;
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001875 }
1876
Ian Rogersb726dcb2012-09-05 08:57:23 -07001877 void Dump(std::ostream& os) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001878 {
1879 os << "art_file_bytes = " << PrettySize(file_bytes) << "\n\n"
1880 << "art_file_bytes = header_bytes + object_bytes + alignment_bytes\n";
1881 Indenter indent_filter(os.rdbuf(), kIndentChar, kIndentBy1Count);
1882 std::ostream indent_os(&indent_filter);
1883 indent_os << StringPrintf("header_bytes = %8zd (%2.0f%% of art file bytes)\n"
1884 "object_bytes = %8zd (%2.0f%% of art file bytes)\n"
Mathieu Chartier32327092013-08-30 14:04:08 -07001885 "bitmap_bytes = %8zd (%2.0f%% of art file bytes)\n"
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001886 "alignment_bytes = %8zd (%2.0f%% of art file bytes)\n\n",
1887 header_bytes, PercentOfFileBytes(header_bytes),
1888 object_bytes, PercentOfFileBytes(object_bytes),
Mathieu Chartier32327092013-08-30 14:04:08 -07001889 bitmap_bytes, PercentOfFileBytes(bitmap_bytes),
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001890 alignment_bytes, PercentOfFileBytes(alignment_bytes))
1891 << std::flush;
Mathieu Chartier32327092013-08-30 14:04:08 -07001892 CHECK_EQ(file_bytes, bitmap_bytes + header_bytes + object_bytes + alignment_bytes);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001893 }
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001894
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001895 os << "object_bytes breakdown:\n";
Brian Carlstrom916e74e2011-09-23 11:42:01 -07001896 size_t object_bytes_total = 0;
Mathieu Chartier02e25112013-08-14 16:14:24 -07001897 for (const auto& sizes_and_count : sizes_and_counts) {
1898 const std::string& descriptor(sizes_and_count.first);
1899 double average = static_cast<double>(sizes_and_count.second.bytes) /
1900 static_cast<double>(sizes_and_count.second.count);
1901 double percent = PercentOfObjectBytes(sizes_and_count.second.bytes);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001902 os << StringPrintf("%32s %8zd bytes %6zd instances "
Elliott Hughesa0e18062012-04-13 15:59:59 -07001903 "(%4.0f bytes/instance) %2.0f%% of object_bytes\n",
Mathieu Chartier02e25112013-08-14 16:14:24 -07001904 descriptor.c_str(), sizes_and_count.second.bytes,
1905 sizes_and_count.second.count, average, percent);
1906 object_bytes_total += sizes_and_count.second.bytes;
Brian Carlstrom916e74e2011-09-23 11:42:01 -07001907 }
Elliott Hughesc073b072012-05-24 19:29:17 -07001908 os << "\n" << std::flush;
Brian Carlstrom916e74e2011-09-23 11:42:01 -07001909 CHECK_EQ(object_bytes, object_bytes_total);
1910
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001911 os << StringPrintf("oat_file_bytes = %8zd\n"
1912 "managed_code_bytes = %8zd (%2.0f%% of oat file bytes)\n"
1913 "managed_to_native_code_bytes = %8zd (%2.0f%% of oat file bytes)\n"
1914 "native_to_managed_code_bytes = %8zd (%2.0f%% of oat file bytes)\n\n"
1915 "class_initializer_code_bytes = %8zd (%2.0f%% of oat file bytes)\n"
1916 "large_initializer_code_bytes = %8zd (%2.0f%% of oat file bytes)\n"
1917 "large_method_code_bytes = %8zd (%2.0f%% of oat file bytes)\n\n",
Ian Rogers05f28c62012-10-23 18:12:13 -07001918 oat_file_bytes,
Brian Carlstrom2ec65202014-03-03 15:16:37 -08001919 managed_code_bytes,
1920 PercentOfOatBytes(managed_code_bytes),
1921 managed_to_native_code_bytes,
1922 PercentOfOatBytes(managed_to_native_code_bytes),
1923 native_to_managed_code_bytes,
1924 PercentOfOatBytes(native_to_managed_code_bytes),
1925 class_initializer_code_bytes,
1926 PercentOfOatBytes(class_initializer_code_bytes),
1927 large_initializer_code_bytes,
1928 PercentOfOatBytes(large_initializer_code_bytes),
1929 large_method_code_bytes,
1930 PercentOfOatBytes(large_method_code_bytes))
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001931 << "DexFile sizes:\n";
Mathieu Chartier02e25112013-08-14 16:14:24 -07001932 for (const std::pair<std::string, size_t>& oat_dex_file_size : oat_dex_file_sizes) {
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001933 os << StringPrintf("%s = %zd (%2.0f%% of oat file bytes)\n",
Mathieu Chartier02e25112013-08-14 16:14:24 -07001934 oat_dex_file_size.first.c_str(), oat_dex_file_size.second,
1935 PercentOfOatBytes(oat_dex_file_size.second));
Ian Rogers05f28c62012-10-23 18:12:13 -07001936 }
1937
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001938 os << "\n" << StringPrintf("gc_map_bytes = %7zd (%2.0f%% of oat file bytes)\n"
1939 "pc_mapping_table_bytes = %7zd (%2.0f%% of oat file bytes)\n"
1940 "vmap_table_bytes = %7zd (%2.0f%% of oat file bytes)\n\n",
Ian Rogers05f28c62012-10-23 18:12:13 -07001941 gc_map_bytes, PercentOfOatBytes(gc_map_bytes),
1942 pc_mapping_table_bytes, PercentOfOatBytes(pc_mapping_table_bytes),
1943 vmap_table_bytes, PercentOfOatBytes(vmap_table_bytes))
Elliott Hughesc073b072012-05-24 19:29:17 -07001944 << std::flush;
Brian Carlstrom916e74e2011-09-23 11:42:01 -07001945
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001946 os << StringPrintf("dex_instruction_bytes = %zd\n", dex_instruction_bytes)
1947 << StringPrintf("managed_code_bytes expansion = %.2f (ignoring deduplication %.2f)\n\n",
Brian Carlstrom2ec65202014-03-03 15:16:37 -08001948 static_cast<double>(managed_code_bytes) /
1949 static_cast<double>(dex_instruction_bytes),
Elliott Hughesc073b072012-05-24 19:29:17 -07001950 static_cast<double>(managed_code_bytes_ignoring_deduplication) /
Elliott Hughescf44e6f2012-05-24 19:42:18 -07001951 static_cast<double>(dex_instruction_bytes))
Elliott Hughesc073b072012-05-24 19:29:17 -07001952 << std::flush;
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001953
1954 DumpOutliers(os);
Brian Carlstrom916e74e2011-09-23 11:42:01 -07001955 }
1956 } stats_;
1957
1958 private:
Ian Rogers0d2d3782012-04-10 11:09:18 -07001959 enum {
1960 // Number of bytes for a constructor to be considered large. Based on the 1000 basic block
1961 // threshold, we assume 2 bytes per instruction and 2 instructions per block.
1962 kLargeConstructorDexBytes = 4000,
1963 // Number of bytes for a method to be considered large. Based on the 4000 basic block
1964 // threshold, we assume 2 bytes per instruction and 2 instructions per block.
1965 kLargeMethodDexBytes = 16000
1966 };
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001967 std::ostream* os_;
Ian Rogers1d54e732013-05-02 21:10:01 -07001968 gc::space::ImageSpace& image_space_;
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001969 const ImageHeader& image_header_;
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07001970 std::unique_ptr<OatDumper> oat_dumper_;
1971 std::unique_ptr<OatDumperOptions> oat_dumper_options_;
Elliott Hughesd1bb4f62011-09-23 14:09:45 -07001972
Ian Rogers3a5c1ce2012-02-29 10:06:46 -08001973 DISALLOW_COPY_AND_ASSIGN(ImageDumper);
Brian Carlstrom78128a62011-09-15 17:21:19 -07001974};
1975
Andreas Gampe00b25f32014-09-17 21:49:05 -07001976static NoopCompilerCallbacks callbacks;
Elliott Hughes72395bf2012-04-24 13:45:26 -07001977
Andreas Gampe00b25f32014-09-17 21:49:05 -07001978static Runtime* StartRuntime(const char* boot_image_location, const char* image_location,
1979 InstructionSet instruction_set) {
Ian Rogerse63db272014-07-15 15:36:11 -07001980 RuntimeOptions options;
Brian Carlstrom78128a62011-09-15 17:21:19 -07001981 std::string image_option;
Brian Carlstrome24fa612011-09-29 00:53:55 -07001982 std::string oat_option;
Brian Carlstrom78128a62011-09-15 17:21:19 -07001983 std::string boot_image_option;
Brian Carlstrome24fa612011-09-29 00:53:55 -07001984 std::string boot_oat_option;
Brian Carlstrom6c871802013-07-17 14:25:35 -07001985
1986 // We are more like a compiler than a run-time. We don't want to execute code.
Brian Carlstromc0a1b182014-03-04 23:19:06 -08001987 options.push_back(std::make_pair("compilercallbacks", &callbacks));
Brian Carlstrom6c871802013-07-17 14:25:35 -07001988
Andreas Gampe2ed8def2014-08-28 14:41:02 -07001989 if (boot_image_location != nullptr) {
Brian Carlstrom58ae9412011-10-04 00:56:06 -07001990 boot_image_option += "-Ximage:";
Brian Carlstrom0f5baa02014-05-22 11:54:18 -07001991 boot_image_option += boot_image_location;
Andreas Gampe2ed8def2014-08-28 14:41:02 -07001992 options.push_back(std::make_pair(boot_image_option.c_str(), nullptr));
Brian Carlstrom78128a62011-09-15 17:21:19 -07001993 }
Andreas Gampe2ed8def2014-08-28 14:41:02 -07001994 if (image_location != nullptr) {
Brian Carlstromaded5f72011-10-07 17:15:04 -07001995 image_option += "-Ximage:";
Brian Carlstrom0f5baa02014-05-22 11:54:18 -07001996 image_option += image_location;
Andreas Gampe2ed8def2014-08-28 14:41:02 -07001997 options.push_back(std::make_pair(image_option.c_str(), nullptr));
Brian Carlstromaded5f72011-10-07 17:15:04 -07001998 }
Brian Carlstrom0f5baa02014-05-22 11:54:18 -07001999 options.push_back(
2000 std::make_pair("imageinstructionset",
2001 reinterpret_cast<const void*>(GetInstructionSetString(instruction_set))));
Brian Carlstrom58ae9412011-10-04 00:56:06 -07002002
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002003 if (!Runtime::Create(options, false)) {
Brian Carlstromaded5f72011-10-07 17:15:04 -07002004 fprintf(stderr, "Failed to create runtime\n");
Andreas Gampe00b25f32014-09-17 21:49:05 -07002005 return nullptr;
Brian Carlstrom78128a62011-09-15 17:21:19 -07002006 }
Andreas Gampe00b25f32014-09-17 21:49:05 -07002007
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002008 // Runtime::Create acquired the mutator_lock_ that is normally given away when we Runtime::Start,
Ian Rogersb9beb2e2014-05-09 16:57:40 -07002009 // give it away now and then switch to a more manageable ScopedObjectAccess.
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002010 Thread::Current()->TransitionFromRunnableToSuspended(kNative);
Andreas Gampe00b25f32014-09-17 21:49:05 -07002011
2012 return Runtime::Current();
2013}
2014
2015static int DumpImage(Runtime* runtime, const char* image_location, OatDumperOptions* options,
2016 std::ostream* os) {
2017 // Dumping the image, no explicit class loader.
2018 NullHandle<mirror::ClassLoader> null_class_loader;
2019 options->class_loader_ = &null_class_loader;
2020
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002021 ScopedObjectAccess soa(Thread::Current());
Andreas Gampe00b25f32014-09-17 21:49:05 -07002022 gc::Heap* heap = runtime->GetHeap();
Ian Rogers1d54e732013-05-02 21:10:01 -07002023 gc::space::ImageSpace* image_space = heap->GetImageSpace();
Andreas Gampe2ed8def2014-08-28 14:41:02 -07002024 CHECK(image_space != nullptr);
Brian Carlstrom78128a62011-09-15 17:21:19 -07002025 const ImageHeader& image_header = image_space->GetImageHeader();
2026 if (!image_header.IsValid()) {
Brian Carlstrom0f5baa02014-05-22 11:54:18 -07002027 fprintf(stderr, "Invalid image header %s\n", image_location);
Brian Carlstrom78128a62011-09-15 17:21:19 -07002028 return EXIT_FAILURE;
2029 }
Andreas Gampe00b25f32014-09-17 21:49:05 -07002030 ImageDumper image_dumper(os, *image_space, image_header, options);
Brian Carlstrom2cbaccb2014-09-14 20:34:17 -07002031 bool success = image_dumper.Dump();
2032 return (success) ? EXIT_SUCCESS : EXIT_FAILURE;
Brian Carlstrom78128a62011-09-15 17:21:19 -07002033}
2034
Andreas Gampe00b25f32014-09-17 21:49:05 -07002035static int DumpOatWithRuntime(Runtime* runtime, OatFile* oat_file, OatDumperOptions* options,
2036 std::ostream* os) {
2037 CHECK(runtime != nullptr && oat_file != nullptr && options != nullptr);
2038
2039 Thread* self = Thread::Current();
2040 CHECK(self != nullptr);
2041 // Need well-known-classes.
2042 WellKnownClasses::Init(self->GetJniEnv());
2043
2044 // Need to register dex files to get a working dex cache.
2045 ScopedObjectAccess soa(self);
2046 ClassLinker* class_linker = runtime->GetClassLinker();
2047 class_linker->RegisterOatFile(oat_file);
2048 std::vector<const DexFile*> dex_files;
2049 for (const OatFile::OatDexFile* odf : oat_file->GetOatDexFiles()) {
2050 std::string error_msg;
2051 const DexFile* dex_file = odf->OpenDexFile(&error_msg);
2052 CHECK(dex_file != nullptr) << error_msg;
2053 class_linker->RegisterDexFile(*dex_file);
2054 dex_files.push_back(dex_file);
2055 }
2056
2057 // Need a class loader.
2058 soa.Env()->AllocObject(WellKnownClasses::dalvik_system_PathClassLoader);
2059 ScopedLocalRef<jobject> class_loader_local(soa.Env(),
2060 soa.Env()->AllocObject(WellKnownClasses::dalvik_system_PathClassLoader));
2061 jobject class_loader = soa.Env()->NewGlobalRef(class_loader_local.get());
2062 // Fake that we're a compiler.
2063 runtime->SetCompileTimeClassPath(class_loader, dex_files);
2064
2065 // Use the class loader while dumping.
2066 StackHandleScope<1> scope(self);
2067 Handle<mirror::ClassLoader> loader_handle = scope.NewHandle(
2068 soa.Decode<mirror::ClassLoader*>(class_loader));
2069 options->class_loader_ = &loader_handle;
2070
2071 OatDumper oat_dumper(*oat_file, options);
2072 bool success = oat_dumper.Dump(*os);
2073 return (success) ? EXIT_SUCCESS : EXIT_FAILURE;
2074}
2075
2076static int DumpOatWithoutRuntime(OatFile* oat_file, OatDumperOptions* options, std::ostream* os) {
2077 // No image = no class loader.
2078 NullHandle<mirror::ClassLoader> null_class_loader;
2079 options->class_loader_ = &null_class_loader;
2080
2081 OatDumper oat_dumper(*oat_file, options);
2082 bool success = oat_dumper.Dump(*os);
2083 return (success) ? EXIT_SUCCESS : EXIT_FAILURE;
2084}
2085
2086static int DumpOat(Runtime* runtime, const char* oat_filename, OatDumperOptions* options,
2087 std::ostream* os) {
2088 std::string error_msg;
2089 OatFile* oat_file = OatFile::Open(oat_filename, oat_filename, nullptr, false, &error_msg);
2090 if (oat_file == nullptr) {
2091 fprintf(stderr, "Failed to open oat file from '%s': %s\n", oat_filename, error_msg.c_str());
2092 return EXIT_FAILURE;
2093 }
2094
2095 if (runtime != nullptr) {
2096 return DumpOatWithRuntime(runtime, oat_file, options, os);
2097 } else {
2098 return DumpOatWithoutRuntime(oat_file, options, os);
2099 }
2100}
2101
2102static int SymbolizeOat(const char* oat_filename, std::string& output_name) {
2103 std::string error_msg;
2104 OatFile* oat_file = OatFile::Open(oat_filename, oat_filename, nullptr, false, &error_msg);
2105 if (oat_file == nullptr) {
2106 fprintf(stderr, "Failed to open oat file from '%s': %s\n", oat_filename, error_msg.c_str());
2107 return EXIT_FAILURE;
2108 }
2109
2110 OatSymbolizer oat_symbolizer(oat_file, output_name);
2111 if (!oat_symbolizer.Init()) {
2112 fprintf(stderr, "Failed to initialize symbolizer\n");
2113 return EXIT_FAILURE;
2114 }
2115 if (!oat_symbolizer.Symbolize()) {
2116 fprintf(stderr, "Failed to symbolize\n");
2117 return EXIT_FAILURE;
2118 }
2119
2120 return EXIT_SUCCESS;
2121}
2122
2123struct OatdumpArgs {
2124 bool Parse(int argc, char** argv) {
2125 // Skip over argv[0].
2126 argv++;
2127 argc--;
2128
2129 if (argc == 0) {
2130 fprintf(stderr, "No arguments specified\n");
2131 usage();
2132 return false;
2133 }
2134
2135 for (int i = 0; i < argc; i++) {
2136 const StringPiece option(argv[i]);
2137 if (option.starts_with("--oat-file=")) {
2138 oat_filename_ = option.substr(strlen("--oat-file=")).data();
2139 } else if (option.starts_with("--image=")) {
2140 image_location_ = option.substr(strlen("--image=")).data();
2141 } else if (option.starts_with("--boot-image=")) {
2142 boot_image_location_ = option.substr(strlen("--boot-image=")).data();
2143 } else if (option.starts_with("--instruction-set=")) {
2144 StringPiece instruction_set_str = option.substr(strlen("--instruction-set=")).data();
2145 instruction_set_ = GetInstructionSetFromString(instruction_set_str.data());
2146 if (instruction_set_ == kNone) {
2147 fprintf(stderr, "Unsupported instruction set %s\n", instruction_set_str.data());
2148 usage();
2149 return false;
2150 }
2151 } else if (option =="--dump:raw_mapping_table") {
2152 dump_raw_mapping_table_ = true;
2153 } else if (option == "--dump:raw_gc_map") {
2154 dump_raw_gc_map_ = true;
2155 } else if (option == "--no-dump:vmap") {
2156 dump_vmap_ = false;
2157 } else if (option == "--no-disassemble") {
2158 disassemble_code_ = false;
2159 } else if (option.starts_with("--output=")) {
2160 output_name_ = option.substr(strlen("--output=")).ToString();
2161 const char* filename = output_name_.c_str();
2162 out_.reset(new std::ofstream(filename));
2163 if (!out_->good()) {
2164 fprintf(stderr, "Failed to open output filename %s\n", filename);
2165 usage();
2166 return false;
2167 }
2168 os_ = out_.get();
2169 } else if (option.starts_with("--symbolize=")) {
2170 oat_filename_ = option.substr(strlen("--symbolize=")).data();
2171 symbolize_ = true;
2172 } else {
2173 fprintf(stderr, "Unknown argument %s\n", option.data());
2174 usage();
2175 return false;
2176 }
2177 }
2178
2179 if (image_location_ == nullptr && oat_filename_ == nullptr) {
2180 fprintf(stderr, "Either --image or --oat must be specified\n");
2181 return false;
2182 }
2183
2184 if (image_location_ != nullptr && oat_filename_ != nullptr) {
2185 fprintf(stderr, "Either --image or --oat must be specified but not both\n");
2186 return false;
2187 }
2188
2189 return true;
2190 }
2191
2192 const char* oat_filename_ = nullptr;
2193 const char* image_location_ = nullptr;
2194 const char* boot_image_location_ = nullptr;
2195 InstructionSet instruction_set_ = kRuntimeISA;
2196 std::string elf_filename_prefix_;
2197 std::ostream* os_ = &std::cout;
2198 std::unique_ptr<std::ofstream> out_;
2199 std::string output_name_;
2200 bool dump_raw_mapping_table_ = false;
2201 bool dump_raw_gc_map_ = false;
2202 bool dump_vmap_ = true;
2203 bool disassemble_code_ = true;
2204 bool symbolize_ = false;
2205};
2206
2207static int oatdump(int argc, char** argv) {
2208 InitLogging(argv);
2209
2210 OatdumpArgs args;
2211 if (!args.Parse(argc, argv)) {
2212 return EXIT_FAILURE;
2213 }
2214
2215 // If we are only doing the oat file, disable absolute_addresses. Keep them for image dumping.
2216 bool absolute_addresses = (args.oat_filename_ == nullptr);
2217
2218 std::unique_ptr<OatDumperOptions> oat_dumper_options(new OatDumperOptions(
2219 args.dump_raw_mapping_table_,
2220 args.dump_raw_gc_map_,
2221 args.dump_vmap_,
2222 args.disassemble_code_,
2223 absolute_addresses,
2224 nullptr));
2225
2226 std::unique_ptr<Runtime> runtime;
2227 if ((args.boot_image_location_ != nullptr || args.image_location_ != nullptr) &&
2228 !args.symbolize_) {
2229 // If we have a boot image option, try to start the runtime; except when just symbolizing.
2230 runtime.reset(StartRuntime(args.boot_image_location_,
2231 args.image_location_,
2232 args.instruction_set_));
2233 }
2234
2235 if (args.oat_filename_ != nullptr) {
2236 if (args.symbolize_) {
2237 return SymbolizeOat(args.oat_filename_, args.output_name_);
2238 } else {
2239 return DumpOat(runtime.get(), args.oat_filename_, oat_dumper_options.release(), args.os_);
2240 }
2241 }
2242
2243 if (runtime.get() == nullptr) {
2244 // We need the runtime when printing an image.
2245 return EXIT_FAILURE;
2246 }
2247
2248 return DumpImage(runtime.get(), args.image_location_, oat_dumper_options.release(), args.os_);
2249}
2250
Brian Carlstrom7934ac22013-07-26 10:54:15 -07002251} // namespace art
Brian Carlstrom78128a62011-09-15 17:21:19 -07002252
2253int main(int argc, char** argv) {
2254 return art::oatdump(argc, argv);
2255}