oatdump.cc revision 197160d47f34238cb5e7444fa4c2de300db8e2c6 
1/*
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 */
16
17#include <stdio.h>
18#include <stdlib.h>
19
20#include <fstream>
21#include <iostream>
22#include <map>
23#include <set>
24#include <string>
25#include <unordered_map>
26#include <vector>
27
28#include "arch/instruction_set_features.h"
29#include "art_field-inl.h"
30#include "art_method-inl.h"
31#include "base/stl_util.h"
32#include "base/unix_file/fd_file.h"
33#include "class_linker.h"
34#include "class_linker-inl.h"
35#include "dex_file-inl.h"
36#include "dex_instruction.h"
37#include "disassembler.h"
38#include "elf_builder.h"
39#include "gc_map.h"
40#include "gc/space/image_space.h"
41#include "gc/space/large_object_space.h"
42#include "gc/space/space-inl.h"
43#include "image-inl.h"
44#include "indenter.h"
45#include "linker/buffered_output_stream.h"
46#include "linker/file_output_stream.h"
47#include "mapping_table.h"
48#include "mirror/array-inl.h"
49#include "mirror/class-inl.h"
50#include "mirror/dex_cache-inl.h"
51#include "mirror/object-inl.h"
52#include "mirror/object_array-inl.h"
53#include "oat.h"
54#include "oat_file-inl.h"
55#include "oat_file_manager.h"
56#include "os.h"
57#include "safe_map.h"
58#include "scoped_thread_state_change.h"
59#include "stack_map.h"
60#include "ScopedLocalRef.h"
61#include "thread_list.h"
62#include "verifier/dex_gc_map.h"
63#include "verifier/method_verifier.h"
64#include "vmap_table.h"
65#include "well_known_classes.h"
66
67#include <sys/stat.h>
68#include "cmdline.h"
69
70namespace art {
71
72const char* image_methods_descriptions_[] = {
73  "kResolutionMethod",
74  "kImtConflictMethod",
75  "kImtUnimplementedMethod",
76  "kCalleeSaveMethod",
77  "kRefsOnlySaveMethod",
78  "kRefsAndArgsSaveMethod",
79};
80
81const char* image_roots_descriptions_[] = {
82  "kDexCaches",
83  "kClassRoots",
84};
85
86// Map is so that we don't allocate multiple dex files for the same OatDexFile.
87static std::map<const OatFile::OatDexFile*,
88                std::unique_ptr<const DexFile>> opened_dex_files;
89
90const DexFile* OpenDexFile(const OatFile::OatDexFile* oat_dex_file, std::string* error_msg) {
91  DCHECK(oat_dex_file != nullptr);
92  auto it = opened_dex_files.find(oat_dex_file);
93  if (it != opened_dex_files.end()) {
94    return it->second.get();
95  }
96  const DexFile* ret = oat_dex_file->OpenDexFile(error_msg).release();
97  opened_dex_files.emplace(oat_dex_file, std::unique_ptr<const DexFile>(ret));
98  return ret;
99}
100
101template <typename ElfTypes>
102class OatSymbolizer FINAL {
103 public:
104  OatSymbolizer(const OatFile* oat_file, const std::string& output_name) :
105      oat_file_(oat_file), builder_(nullptr),
106      output_name_(output_name.empty() ? "symbolized.oat" : output_name) {
107  }
108
109  typedef void (OatSymbolizer::*Callback)(const DexFile::ClassDef&,
110                                          uint32_t,
111                                          const OatFile::OatMethod&,
112                                          const DexFile&,
113                                          uint32_t,
114                                          const DexFile::CodeItem*,
115                                          uint32_t);
116
117  bool Symbolize() {
118    const InstructionSet isa = oat_file_->GetOatHeader().GetInstructionSet();
119    const InstructionSetFeatures* features = InstructionSetFeatures::FromBitmap(
120        isa, oat_file_->GetOatHeader().GetInstructionSetFeaturesBitmap());
121
122    File* elf_file = OS::CreateEmptyFile(output_name_.c_str());
123    std::unique_ptr<BufferedOutputStream> output_stream(
124        MakeUnique<BufferedOutputStream>(MakeUnique<FileOutputStream>(elf_file)));
125    builder_.reset(new ElfBuilder<ElfTypes>(isa, features, output_stream.get()));
126
127    builder_->Start();
128
129    auto* rodata = builder_->GetRoData();
130    auto* text = builder_->GetText();
131    auto* bss = builder_->GetBss();
132    auto* strtab = builder_->GetStrTab();
133    auto* symtab = builder_->GetSymTab();
134
135    rodata->Start();
136    const uint8_t* rodata_begin = oat_file_->Begin();
137    const size_t rodata_size = oat_file_->GetOatHeader().GetExecutableOffset();
138    rodata->WriteFully(rodata_begin, rodata_size);
139    rodata->End();
140
141    text->Start();
142    const uint8_t* text_begin = oat_file_->Begin() + rodata_size;
143    const size_t text_size = oat_file_->End() - text_begin;
144    text->WriteFully(text_begin, text_size);
145    text->End();
146
147    if (oat_file_->BssSize() != 0) {
148      bss->WriteNoBitsSection(oat_file_->BssSize());
149    }
150
151    builder_->PrepareDynamicSection(
152        elf_file->GetPath(), rodata_size, text_size, oat_file_->BssSize());
153    builder_->WriteDynamicSection();
154
155    Walk(&art::OatSymbolizer<ElfTypes>::RegisterForDedup);
156
157    NormalizeState();
158
159    strtab->Start();
160    strtab->Write("");  // strtab should start with empty string.
161    AddTrampolineSymbols();
162    Walk(&art::OatSymbolizer<ElfTypes>::AddSymbol);
163    strtab->End();
164
165    symtab->Start();
166    symtab->Write();
167    symtab->End();
168
169    builder_->End();
170
171    return builder_->Good();
172  }
173
174  void AddTrampolineSymbol(const char* name, uint32_t code_offset) {
175    if (code_offset != 0) {
176      uint32_t name_offset = builder_->GetStrTab()->Write(name);
177      uint64_t symbol_value = code_offset - oat_file_->GetOatHeader().GetExecutableOffset();
178      // Specifying 0 as the symbol size means that the symbol lasts until the next symbol or until
179      // the end of the section in case of the last symbol.
180      builder_->GetSymTab()->Add(
181          name_offset,
182          builder_->GetText(),
183          builder_->GetText()->GetAddress() + symbol_value,
184          /* size */ 0,
185          STB_GLOBAL,
186          STT_FUNC);
187    }
188  }
189
190  void AddTrampolineSymbols() {
191    const OatHeader& oat_header = oat_file_->GetOatHeader();
192    AddTrampolineSymbol("interpreterToInterpreterBridge",
193                        oat_header.GetInterpreterToInterpreterBridgeOffset());
194    AddTrampolineSymbol("interpreterToCompiledCodeBridge",
195                        oat_header.GetInterpreterToCompiledCodeBridgeOffset());
196    AddTrampolineSymbol("jniDlsymLookup",
197                        oat_header.GetJniDlsymLookupOffset());
198    AddTrampolineSymbol("quickGenericJniTrampoline",
199                        oat_header.GetQuickGenericJniTrampolineOffset());
200    AddTrampolineSymbol("quickImtConflictTrampoline",
201                        oat_header.GetQuickImtConflictTrampolineOffset());
202    AddTrampolineSymbol("quickResolutionTrampoline",
203                        oat_header.GetQuickResolutionTrampolineOffset());
204    AddTrampolineSymbol("quickToInterpreterBridge",
205                        oat_header.GetQuickToInterpreterBridgeOffset());
206  }
207
208  void Walk(Callback callback) {
209    std::vector<const OatFile::OatDexFile*> oat_dex_files = oat_file_->GetOatDexFiles();
210    for (size_t i = 0; i < oat_dex_files.size(); i++) {
211      const OatFile::OatDexFile* oat_dex_file = oat_dex_files[i];
212      CHECK(oat_dex_file != nullptr);
213      WalkOatDexFile(oat_dex_file, callback);
214    }
215  }
216
217  void WalkOatDexFile(const OatFile::OatDexFile* oat_dex_file, Callback callback) {
218    std::string error_msg;
219    const DexFile* const dex_file = OpenDexFile(oat_dex_file, &error_msg);
220    if (dex_file == nullptr) {
221      return;
222    }
223    for (size_t class_def_index = 0;
224        class_def_index < dex_file->NumClassDefs();
225        class_def_index++) {
226      const DexFile::ClassDef& class_def = dex_file->GetClassDef(class_def_index);
227      const OatFile::OatClass oat_class = oat_dex_file->GetOatClass(class_def_index);
228      OatClassType type = oat_class.GetType();
229      switch (type) {
230        case kOatClassAllCompiled:
231        case kOatClassSomeCompiled:
232          WalkOatClass(oat_class, *dex_file, class_def, callback);
233          break;
234
235        case kOatClassNoneCompiled:
236        case kOatClassMax:
237          // Ignore.
238          break;
239      }
240    }
241  }
242
243  void WalkOatClass(const OatFile::OatClass& oat_class, const DexFile& dex_file,
244                    const DexFile::ClassDef& class_def, Callback callback) {
245    const uint8_t* class_data = dex_file.GetClassData(class_def);
246    if (class_data == nullptr) {  // empty class such as a marker interface?
247      return;
248    }
249    // Note: even if this is an interface or a native class, we still have to walk it, as there
250    //       might be a static initializer.
251    ClassDataItemIterator it(dex_file, class_data);
252    SkipAllFields(&it);
253    uint32_t class_method_idx = 0;
254    while (it.HasNextDirectMethod()) {
255      const OatFile::OatMethod oat_method = oat_class.GetOatMethod(class_method_idx);
256      WalkOatMethod(class_def, class_method_idx, oat_method, dex_file, it.GetMemberIndex(),
257                    it.GetMethodCodeItem(), it.GetMethodAccessFlags(), callback);
258      class_method_idx++;
259      it.Next();
260    }
261    while (it.HasNextVirtualMethod()) {
262      const OatFile::OatMethod oat_method = oat_class.GetOatMethod(class_method_idx);
263      WalkOatMethod(class_def, class_method_idx, oat_method, dex_file, it.GetMemberIndex(),
264                    it.GetMethodCodeItem(), it.GetMethodAccessFlags(), callback);
265      class_method_idx++;
266      it.Next();
267    }
268    DCHECK(!it.HasNext());
269  }
270
271  void WalkOatMethod(const DexFile::ClassDef& class_def, uint32_t class_method_index,
272                     const OatFile::OatMethod& oat_method, const DexFile& dex_file,
273                     uint32_t dex_method_idx, const DexFile::CodeItem* code_item,
274                     uint32_t method_access_flags, Callback callback) {
275    if ((method_access_flags & kAccAbstract) != 0) {
276      // Abstract method, no code.
277      return;
278    }
279    if (oat_method.GetCodeOffset() == 0) {
280      // No code.
281      return;
282    }
283
284    (this->*callback)(class_def, class_method_index, oat_method, dex_file, dex_method_idx, code_item,
285                      method_access_flags);
286  }
287
288  void RegisterForDedup(const DexFile::ClassDef& class_def ATTRIBUTE_UNUSED,
289                        uint32_t class_method_index ATTRIBUTE_UNUSED,
290                        const OatFile::OatMethod& oat_method,
291                        const DexFile& dex_file ATTRIBUTE_UNUSED,
292                        uint32_t dex_method_idx ATTRIBUTE_UNUSED,
293                        const DexFile::CodeItem* code_item ATTRIBUTE_UNUSED,
294                        uint32_t method_access_flags ATTRIBUTE_UNUSED) {
295    state_[oat_method.GetCodeOffset()]++;
296  }
297
298  void NormalizeState() {
299    for (auto& x : state_) {
300      if (x.second == 1) {
301        state_[x.first] = 0;
302      }
303    }
304  }
305
306  enum class DedupState {  // private
307    kNotDeduplicated,
308    kDeduplicatedFirst,
309    kDeduplicatedOther
310  };
311  DedupState IsDuplicated(uint32_t offset) {
312    if (state_[offset] == 0) {
313      return DedupState::kNotDeduplicated;
314    }
315    if (state_[offset] == 1) {
316      return DedupState::kDeduplicatedOther;
317    }
318    state_[offset] = 1;
319    return DedupState::kDeduplicatedFirst;
320  }
321
322  void AddSymbol(const DexFile::ClassDef& class_def ATTRIBUTE_UNUSED,
323                 uint32_t class_method_index ATTRIBUTE_UNUSED,
324                 const OatFile::OatMethod& oat_method,
325                 const DexFile& dex_file,
326                 uint32_t dex_method_idx,
327                 const DexFile::CodeItem* code_item ATTRIBUTE_UNUSED,
328                 uint32_t method_access_flags ATTRIBUTE_UNUSED) {
329    DedupState dedup = IsDuplicated(oat_method.GetCodeOffset());
330    if (dedup != DedupState::kDeduplicatedOther) {
331      std::string pretty_name = PrettyMethod(dex_method_idx, dex_file, true);
332
333      if (dedup == DedupState::kDeduplicatedFirst) {
334        pretty_name = "[Dedup]" + pretty_name;
335      }
336
337      int name_offset = builder_->GetStrTab()->Write(pretty_name);
338      uint64_t address = oat_method.GetCodeOffset() -
339                         oat_file_->GetOatHeader().GetExecutableOffset() +
340                         builder_->GetText()->GetAddress();
341      builder_->GetSymTab()->Add(name_offset,
342                                 builder_->GetText(),
343                                 address,
344                                 oat_method.GetQuickCodeSize(),
345                                 STB_GLOBAL,
346                                 STT_FUNC);
347    }
348  }
349
350 private:
351  static void SkipAllFields(ClassDataItemIterator* it) {
352    while (it->HasNextStaticField()) {
353      it->Next();
354    }
355    while (it->HasNextInstanceField()) {
356      it->Next();
357    }
358  }
359
360  const OatFile* oat_file_;
361  std::unique_ptr<ElfBuilder<ElfTypes> > builder_;
362  std::unordered_map<uint32_t, uint32_t> state_;
363  const std::string output_name_;
364};
365
366class OatDumperOptions {
367 public:
368  OatDumperOptions(bool dump_raw_mapping_table,
369                   bool dump_raw_gc_map,
370                   bool dump_vmap,
371                   bool dump_code_info_stack_maps,
372                   bool disassemble_code,
373                   bool absolute_addresses,
374                   const char* class_filter,
375                   const char* method_filter,
376                   bool list_classes,
377                   bool list_methods,
378                   bool dump_header_only,
379                   const char* export_dex_location,
380                   uint32_t addr2instr)
381    : dump_raw_mapping_table_(dump_raw_mapping_table),
382      dump_raw_gc_map_(dump_raw_gc_map),
383      dump_vmap_(dump_vmap),
384      dump_code_info_stack_maps_(dump_code_info_stack_maps),
385      disassemble_code_(disassemble_code),
386      absolute_addresses_(absolute_addresses),
387      class_filter_(class_filter),
388      method_filter_(method_filter),
389      list_classes_(list_classes),
390      list_methods_(list_methods),
391      dump_header_only_(dump_header_only),
392      export_dex_location_(export_dex_location),
393      addr2instr_(addr2instr),
394      class_loader_(nullptr) {}
395
396  const bool dump_raw_mapping_table_;
397  const bool dump_raw_gc_map_;
398  const bool dump_vmap_;
399  const bool dump_code_info_stack_maps_;
400  const bool disassemble_code_;
401  const bool absolute_addresses_;
402  const char* const class_filter_;
403  const char* const method_filter_;
404  const bool list_classes_;
405  const bool list_methods_;
406  const bool dump_header_only_;
407  const char* const export_dex_location_;
408  uint32_t addr2instr_;
409  Handle<mirror::ClassLoader>* class_loader_;
410};
411
412class OatDumper {
413 public:
414  OatDumper(const OatFile& oat_file, const OatDumperOptions& options)
415    : oat_file_(oat_file),
416      oat_dex_files_(oat_file.GetOatDexFiles()),
417      options_(options),
418      resolved_addr2instr_(0),
419      instruction_set_(oat_file_.GetOatHeader().GetInstructionSet()),
420      disassembler_(Disassembler::Create(instruction_set_,
421                                         new DisassemblerOptions(options_.absolute_addresses_,
422                                                                 oat_file.Begin(),
423                                                                 true /* can_read_literals_ */))) {
424    CHECK(options_.class_loader_ != nullptr);
425    CHECK(options_.class_filter_ != nullptr);
426    CHECK(options_.method_filter_ != nullptr);
427    AddAllOffsets();
428  }
429
430  ~OatDumper() {
431    delete disassembler_;
432  }
433
434  InstructionSet GetInstructionSet() {
435    return instruction_set_;
436  }
437
438  bool Dump(std::ostream& os) {
439    bool success = true;
440    const OatHeader& oat_header = oat_file_.GetOatHeader();
441
442    os << "MAGIC:\n";
443    os << oat_header.GetMagic() << "\n\n";
444
445    os << "LOCATION:\n";
446    os << oat_file_.GetLocation() << "\n\n";
447
448    os << "CHECKSUM:\n";
449    os << StringPrintf("0x%08x\n\n", oat_header.GetChecksum());
450
451    os << "INSTRUCTION SET:\n";
452    os << oat_header.GetInstructionSet() << "\n\n";
453
454    {
455      std::unique_ptr<const InstructionSetFeatures> features(
456          InstructionSetFeatures::FromBitmap(oat_header.GetInstructionSet(),
457                                             oat_header.GetInstructionSetFeaturesBitmap()));
458      os << "INSTRUCTION SET FEATURES:\n";
459      os << features->GetFeatureString() << "\n\n";
460    }
461
462    os << "DEX FILE COUNT:\n";
463    os << oat_header.GetDexFileCount() << "\n\n";
464
465#define DUMP_OAT_HEADER_OFFSET(label, offset) \
466    os << label " OFFSET:\n"; \
467    os << StringPrintf("0x%08x", oat_header.offset()); \
468    if (oat_header.offset() != 0 && options_.absolute_addresses_) { \
469      os << StringPrintf(" (%p)", oat_file_.Begin() + oat_header.offset()); \
470    } \
471    os << StringPrintf("\n\n");
472
473    DUMP_OAT_HEADER_OFFSET("EXECUTABLE", GetExecutableOffset);
474    DUMP_OAT_HEADER_OFFSET("INTERPRETER TO INTERPRETER BRIDGE",
475                           GetInterpreterToInterpreterBridgeOffset);
476    DUMP_OAT_HEADER_OFFSET("INTERPRETER TO COMPILED CODE BRIDGE",
477                           GetInterpreterToCompiledCodeBridgeOffset);
478    DUMP_OAT_HEADER_OFFSET("JNI DLSYM LOOKUP",
479                           GetJniDlsymLookupOffset);
480    DUMP_OAT_HEADER_OFFSET("QUICK GENERIC JNI TRAMPOLINE",
481                           GetQuickGenericJniTrampolineOffset);
482    DUMP_OAT_HEADER_OFFSET("QUICK IMT CONFLICT TRAMPOLINE",
483                           GetQuickImtConflictTrampolineOffset);
484    DUMP_OAT_HEADER_OFFSET("QUICK RESOLUTION TRAMPOLINE",
485                           GetQuickResolutionTrampolineOffset);
486    DUMP_OAT_HEADER_OFFSET("QUICK TO INTERPRETER BRIDGE",
487                           GetQuickToInterpreterBridgeOffset);
488#undef DUMP_OAT_HEADER_OFFSET
489
490    os << "IMAGE PATCH DELTA:\n";
491    os << StringPrintf("%d (0x%08x)\n\n",
492                       oat_header.GetImagePatchDelta(),
493                       oat_header.GetImagePatchDelta());
494
495    os << "IMAGE FILE LOCATION OAT CHECKSUM:\n";
496    os << StringPrintf("0x%08x\n\n", oat_header.GetImageFileLocationOatChecksum());
497
498    os << "IMAGE FILE LOCATION OAT BEGIN:\n";
499    os << StringPrintf("0x%08x\n\n", oat_header.GetImageFileLocationOatDataBegin());
500
501    // Print the key-value store.
502    {
503      os << "KEY VALUE STORE:\n";
504      size_t index = 0;
505      const char* key;
506      const char* value;
507      while (oat_header.GetStoreKeyValuePairByIndex(index, &key, &value)) {
508        os << key << " = " << value << "\n";
509        index++;
510      }
511      os << "\n";
512    }
513
514    if (options_.absolute_addresses_) {
515      os << "BEGIN:\n";
516      os << reinterpret_cast<const void*>(oat_file_.Begin()) << "\n\n";
517
518      os << "END:\n";
519      os << reinterpret_cast<const void*>(oat_file_.End()) << "\n\n";
520    }
521
522    os << "SIZE:\n";
523    os << oat_file_.Size() << "\n\n";
524
525    os << std::flush;
526
527    // If set, adjust relative address to be searched
528    if (options_.addr2instr_ != 0) {
529      resolved_addr2instr_ = options_.addr2instr_ + oat_header.GetExecutableOffset();
530      os << "SEARCH ADDRESS (executable offset + input):\n";
531      os << StringPrintf("0x%08x\n\n", resolved_addr2instr_);
532    }
533
534    if (!options_.dump_header_only_) {
535      for (size_t i = 0; i < oat_dex_files_.size(); i++) {
536        const OatFile::OatDexFile* oat_dex_file = oat_dex_files_[i];
537        CHECK(oat_dex_file != nullptr);
538
539        // If file export selected skip file analysis
540        if (options_.export_dex_location_) {
541          if (!ExportDexFile(os, *oat_dex_file)) {
542            success = false;
543          }
544        } else {
545          if (!DumpOatDexFile(os, *oat_dex_file)) {
546            success = false;
547          }
548        }
549      }
550    }
551
552    os << std::flush;
553    return success;
554  }
555
556  size_t ComputeSize(const void* oat_data) {
557    if (reinterpret_cast<const uint8_t*>(oat_data) < oat_file_.Begin() ||
558        reinterpret_cast<const uint8_t*>(oat_data) > oat_file_.End()) {
559      return 0;  // Address not in oat file
560    }
561    uintptr_t begin_offset = reinterpret_cast<uintptr_t>(oat_data) -
562                             reinterpret_cast<uintptr_t>(oat_file_.Begin());
563    auto it = offsets_.upper_bound(begin_offset);
564    CHECK(it != offsets_.end());
565    uintptr_t end_offset = *it;
566    return end_offset - begin_offset;
567  }
568
569  InstructionSet GetOatInstructionSet() {
570    return oat_file_.GetOatHeader().GetInstructionSet();
571  }
572
573  const void* GetQuickOatCode(ArtMethod* m) SHARED_REQUIRES(Locks::mutator_lock_) {
574    for (size_t i = 0; i < oat_dex_files_.size(); i++) {
575      const OatFile::OatDexFile* oat_dex_file = oat_dex_files_[i];
576      CHECK(oat_dex_file != nullptr);
577      std::string error_msg;
578      const DexFile* const dex_file = OpenDexFile(oat_dex_file, &error_msg);
579      if (dex_file == nullptr) {
580        LOG(WARNING) << "Failed to open dex file '" << oat_dex_file->GetDexFileLocation()
581            << "': " << error_msg;
582      } else {
583        const char* descriptor = m->GetDeclaringClassDescriptor();
584        const DexFile::ClassDef* class_def =
585            dex_file->FindClassDef(descriptor, ComputeModifiedUtf8Hash(descriptor));
586        if (class_def != nullptr) {
587          uint16_t class_def_index = dex_file->GetIndexForClassDef(*class_def);
588          const OatFile::OatClass oat_class = oat_dex_file->GetOatClass(class_def_index);
589          size_t method_index = m->GetMethodIndex();
590          return oat_class.GetOatMethod(method_index).GetQuickCode();
591        }
592      }
593    }
594    return nullptr;
595  }
596
597 private:
598  void AddAllOffsets() {
599    // We don't know the length of the code for each method, but we need to know where to stop
600    // when disassembling. What we do know is that a region of code will be followed by some other
601    // region, so if we keep a sorted sequence of the start of each region, we can infer the length
602    // of a piece of code by using upper_bound to find the start of the next region.
603    for (size_t i = 0; i < oat_dex_files_.size(); i++) {
604      const OatFile::OatDexFile* oat_dex_file = oat_dex_files_[i];
605      CHECK(oat_dex_file != nullptr);
606      std::string error_msg;
607      const DexFile* const dex_file = OpenDexFile(oat_dex_file, &error_msg);
608      if (dex_file == nullptr) {
609        LOG(WARNING) << "Failed to open dex file '" << oat_dex_file->GetDexFileLocation()
610            << "': " << error_msg;
611        continue;
612      }
613      offsets_.insert(reinterpret_cast<uintptr_t>(&dex_file->GetHeader()));
614      for (size_t class_def_index = 0;
615           class_def_index < dex_file->NumClassDefs();
616           class_def_index++) {
617        const DexFile::ClassDef& class_def = dex_file->GetClassDef(class_def_index);
618        const OatFile::OatClass oat_class = oat_dex_file->GetOatClass(class_def_index);
619        const uint8_t* class_data = dex_file->GetClassData(class_def);
620        if (class_data != nullptr) {
621          ClassDataItemIterator it(*dex_file, class_data);
622          SkipAllFields(it);
623          uint32_t class_method_index = 0;
624          while (it.HasNextDirectMethod()) {
625            AddOffsets(oat_class.GetOatMethod(class_method_index++));
626            it.Next();
627          }
628          while (it.HasNextVirtualMethod()) {
629            AddOffsets(oat_class.GetOatMethod(class_method_index++));
630            it.Next();
631          }
632        }
633      }
634    }
635
636    // If the last thing in the file is code for a method, there won't be an offset for the "next"
637    // thing. Instead of having a special case in the upper_bound code, let's just add an entry
638    // for the end of the file.
639    offsets_.insert(oat_file_.Size());
640  }
641
642  static uint32_t AlignCodeOffset(uint32_t maybe_thumb_offset) {
643    return maybe_thumb_offset & ~0x1;  // TODO: Make this Thumb2 specific.
644  }
645
646  void AddOffsets(const OatFile::OatMethod& oat_method) {
647    uint32_t code_offset = oat_method.GetCodeOffset();
648    if (oat_file_.GetOatHeader().GetInstructionSet() == kThumb2) {
649      code_offset &= ~0x1;
650    }
651    offsets_.insert(code_offset);
652    offsets_.insert(oat_method.GetMappingTableOffset());
653    offsets_.insert(oat_method.GetVmapTableOffset());
654    offsets_.insert(oat_method.GetGcMapOffset());
655  }
656
657  bool DumpOatDexFile(std::ostream& os, const OatFile::OatDexFile& oat_dex_file) {
658    bool success = true;
659    bool stop_analysis = false;
660    os << "OatDexFile:\n";
661    os << StringPrintf("location: %s\n", oat_dex_file.GetDexFileLocation().c_str());
662    os << StringPrintf("checksum: 0x%08x\n", oat_dex_file.GetDexFileLocationChecksum());
663
664    // Create the verifier early.
665
666    std::string error_msg;
667    const DexFile* const dex_file = OpenDexFile(&oat_dex_file, &error_msg);
668    if (dex_file == nullptr) {
669      os << "NOT FOUND: " << error_msg << "\n\n";
670      os << std::flush;
671      return false;
672    }
673
674    VariableIndentationOutputStream vios(&os);
675    ScopedIndentation indent1(&vios);
676    for (size_t class_def_index = 0;
677         class_def_index < dex_file->NumClassDefs();
678         class_def_index++) {
679      const DexFile::ClassDef& class_def = dex_file->GetClassDef(class_def_index);
680      const char* descriptor = dex_file->GetClassDescriptor(class_def);
681
682      // TODO: Support regex
683      if (DescriptorToDot(descriptor).find(options_.class_filter_) == std::string::npos) {
684        continue;
685      }
686
687      uint32_t oat_class_offset = oat_dex_file.GetOatClassOffset(class_def_index);
688      const OatFile::OatClass oat_class = oat_dex_file.GetOatClass(class_def_index);
689      os << StringPrintf("%zd: %s (offset=0x%08x) (type_idx=%d)",
690                         class_def_index, descriptor, oat_class_offset, class_def.class_idx_)
691         << " (" << oat_class.GetStatus() << ")"
692         << " (" << oat_class.GetType() << ")\n";
693      // TODO: include bitmap here if type is kOatClassSomeCompiled?
694      if (options_.list_classes_) continue;
695      if (!DumpOatClass(&vios, oat_class, *dex_file, class_def, &stop_analysis)) {
696        success = false;
697      }
698      if (stop_analysis) {
699        os << std::flush;
700        return success;
701      }
702    }
703
704    os << std::flush;
705    return success;
706  }
707
708  bool ExportDexFile(std::ostream& os, const OatFile::OatDexFile& oat_dex_file) {
709    std::string error_msg;
710    std::string dex_file_location = oat_dex_file.GetDexFileLocation();
711
712    const DexFile* const dex_file = OpenDexFile(&oat_dex_file, &error_msg);
713    if (dex_file == nullptr) {
714      os << "Failed to open dex file '" << dex_file_location << "': " << error_msg;
715      return false;
716    }
717    size_t fsize = oat_dex_file.FileSize();
718
719    // Some quick checks just in case
720    if (fsize == 0 || fsize < sizeof(DexFile::Header)) {
721      os << "Invalid dex file\n";
722      return false;
723    }
724
725    // Verify output directory exists
726    if (!OS::DirectoryExists(options_.export_dex_location_)) {
727      // TODO: Extend OS::DirectoryExists if symlink support is required
728      os << options_.export_dex_location_ << " output directory not found or symlink\n";
729      return false;
730    }
731
732    // Beautify path names
733    if (dex_file_location.size() > PATH_MAX || dex_file_location.size() <= 0) {
734      return false;
735    }
736
737    std::string dex_orig_name;
738    size_t dex_orig_pos = dex_file_location.rfind('/');
739    if (dex_orig_pos == std::string::npos)
740      dex_orig_name = dex_file_location;
741    else
742      dex_orig_name = dex_file_location.substr(dex_orig_pos + 1);
743
744    // A more elegant approach to efficiently name user installed apps is welcome
745    if (dex_orig_name.size() == 8 && !dex_orig_name.compare("base.apk")) {
746      dex_file_location.erase(dex_orig_pos, strlen("base.apk") + 1);
747      size_t apk_orig_pos = dex_file_location.rfind('/');
748      if (apk_orig_pos != std::string::npos) {
749        dex_orig_name = dex_file_location.substr(++apk_orig_pos);
750      }
751    }
752
753    std::string out_dex_path(options_.export_dex_location_);
754    if (out_dex_path.back() != '/') {
755      out_dex_path.append("/");
756    }
757    out_dex_path.append(dex_orig_name);
758    out_dex_path.append("_export.dex");
759    if (out_dex_path.length() > PATH_MAX) {
760      return false;
761    }
762
763    std::unique_ptr<File> file(OS::CreateEmptyFile(out_dex_path.c_str()));
764    if (file.get() == nullptr) {
765      os << "Failed to open output dex file " << out_dex_path;
766      return false;
767    }
768
769    if (!file->WriteFully(dex_file->Begin(), fsize)) {
770      os << "Failed to write dex file";
771      file->Erase();
772      return false;
773    }
774
775    if (file->FlushCloseOrErase() != 0) {
776      os << "Flush and close failed";
777      return false;
778    }
779
780    os << StringPrintf("Dex file exported at %s (%zd bytes)\n", out_dex_path.c_str(), fsize);
781    os << std::flush;
782
783    return true;
784  }
785
786  static void SkipAllFields(ClassDataItemIterator& it) {
787    while (it.HasNextStaticField()) {
788      it.Next();
789    }
790    while (it.HasNextInstanceField()) {
791      it.Next();
792    }
793  }
794
795  bool DumpOatClass(VariableIndentationOutputStream* vios,
796                    const OatFile::OatClass& oat_class, const DexFile& dex_file,
797                    const DexFile::ClassDef& class_def, bool* stop_analysis) {
798    bool success = true;
799    bool addr_found = false;
800    const uint8_t* class_data = dex_file.GetClassData(class_def);
801    if (class_data == nullptr) {  // empty class such as a marker interface?
802      vios->Stream() << std::flush;
803      return success;
804    }
805    ClassDataItemIterator it(dex_file, class_data);
806    SkipAllFields(it);
807    uint32_t class_method_index = 0;
808    while (it.HasNextDirectMethod()) {
809      if (!DumpOatMethod(vios, class_def, class_method_index, oat_class, dex_file,
810                         it.GetMemberIndex(), it.GetMethodCodeItem(),
811                         it.GetRawMemberAccessFlags(), &addr_found)) {
812        success = false;
813      }
814      if (addr_found) {
815        *stop_analysis = true;
816        return success;
817      }
818      class_method_index++;
819      it.Next();
820    }
821    while (it.HasNextVirtualMethod()) {
822      if (!DumpOatMethod(vios, class_def, class_method_index, oat_class, dex_file,
823                         it.GetMemberIndex(), it.GetMethodCodeItem(),
824                         it.GetRawMemberAccessFlags(), &addr_found)) {
825        success = false;
826      }
827      if (addr_found) {
828        *stop_analysis = true;
829        return success;
830      }
831      class_method_index++;
832      it.Next();
833    }
834    DCHECK(!it.HasNext());
835    vios->Stream() << std::flush;
836    return success;
837  }
838
839  static constexpr uint32_t kPrologueBytes = 16;
840
841  // When this was picked, the largest arm method was 55,256 bytes and arm64 was 50,412 bytes.
842  static constexpr uint32_t kMaxCodeSize = 100 * 1000;
843
844  bool DumpOatMethod(VariableIndentationOutputStream* vios,
845                     const DexFile::ClassDef& class_def,
846                     uint32_t class_method_index,
847                     const OatFile::OatClass& oat_class, const DexFile& dex_file,
848                     uint32_t dex_method_idx, const DexFile::CodeItem* code_item,
849                     uint32_t method_access_flags, bool* addr_found) {
850    bool success = true;
851
852    // TODO: Support regex
853    std::string method_name = dex_file.GetMethodName(dex_file.GetMethodId(dex_method_idx));
854    if (method_name.find(options_.method_filter_) == std::string::npos) {
855      return success;
856    }
857
858    std::string pretty_method = PrettyMethod(dex_method_idx, dex_file, true);
859    vios->Stream() << StringPrintf("%d: %s (dex_method_idx=%d)\n",
860                                   class_method_index, pretty_method.c_str(),
861                                   dex_method_idx);
862    if (options_.list_methods_) return success;
863
864    uint32_t oat_method_offsets_offset = oat_class.GetOatMethodOffsetsOffset(class_method_index);
865    const OatMethodOffsets* oat_method_offsets = oat_class.GetOatMethodOffsets(class_method_index);
866    const OatFile::OatMethod oat_method = oat_class.GetOatMethod(class_method_index);
867    uint32_t code_offset = oat_method.GetCodeOffset();
868    uint32_t code_size = oat_method.GetQuickCodeSize();
869    if (resolved_addr2instr_ != 0) {
870      if (resolved_addr2instr_ > code_offset + code_size) {
871        return success;
872      } else {
873        *addr_found = true;  // stop analyzing file at next iteration
874      }
875    }
876
877    // Everything below is indented at least once.
878    ScopedIndentation indent1(vios);
879
880    {
881      vios->Stream() << "DEX CODE:\n";
882      ScopedIndentation indent2(vios);
883      DumpDexCode(vios->Stream(), dex_file, code_item);
884    }
885
886    std::unique_ptr<StackHandleScope<1>> hs;
887    std::unique_ptr<verifier::MethodVerifier> verifier;
888    if (Runtime::Current() != nullptr) {
889      // We need to have the handle scope stay live until after the verifier since the verifier has
890      // a handle to the dex cache from hs.
891      hs.reset(new StackHandleScope<1>(Thread::Current()));
892      vios->Stream() << "VERIFIER TYPE ANALYSIS:\n";
893      ScopedIndentation indent2(vios);
894      verifier.reset(DumpVerifier(vios, hs.get(),
895                                  dex_method_idx, &dex_file, class_def, code_item,
896                                  method_access_flags));
897    }
898    {
899      vios->Stream() << "OatMethodOffsets ";
900      if (options_.absolute_addresses_) {
901        vios->Stream() << StringPrintf("%p ", oat_method_offsets);
902      }
903      vios->Stream() << StringPrintf("(offset=0x%08x)\n", oat_method_offsets_offset);
904      if (oat_method_offsets_offset > oat_file_.Size()) {
905        vios->Stream() << StringPrintf(
906            "WARNING: oat method offsets offset 0x%08x is past end of file 0x%08zx.\n",
907            oat_method_offsets_offset, oat_file_.Size());
908        // If we can't read OatMethodOffsets, the rest of the data is dangerous to read.
909        vios->Stream() << std::flush;
910        return false;
911      }
912
913      ScopedIndentation indent2(vios);
914      vios->Stream() << StringPrintf("code_offset: 0x%08x ", code_offset);
915      uint32_t aligned_code_begin = AlignCodeOffset(oat_method.GetCodeOffset());
916      if (aligned_code_begin > oat_file_.Size()) {
917        vios->Stream() << StringPrintf("WARNING: "
918                                       "code offset 0x%08x is past end of file 0x%08zx.\n",
919                                       aligned_code_begin, oat_file_.Size());
920        success = false;
921      }
922      vios->Stream() << "\n";
923
924      vios->Stream() << "gc_map: ";
925      if (options_.absolute_addresses_) {
926        vios->Stream() << StringPrintf("%p ", oat_method.GetGcMap());
927      }
928      uint32_t gc_map_offset = oat_method.GetGcMapOffset();
929      vios->Stream() << StringPrintf("(offset=0x%08x)\n", gc_map_offset);
930      if (gc_map_offset > oat_file_.Size()) {
931        vios->Stream() << StringPrintf("WARNING: "
932                           "gc map table offset 0x%08x is past end of file 0x%08zx.\n",
933                           gc_map_offset, oat_file_.Size());
934        success = false;
935      } else if (options_.dump_raw_gc_map_) {
936        ScopedIndentation indent3(vios);
937        DumpGcMap(vios->Stream(), oat_method, code_item);
938      }
939    }
940    {
941      vios->Stream() << "OatQuickMethodHeader ";
942      uint32_t method_header_offset = oat_method.GetOatQuickMethodHeaderOffset();
943      const OatQuickMethodHeader* method_header = oat_method.GetOatQuickMethodHeader();
944
945      if (options_.absolute_addresses_) {
946        vios->Stream() << StringPrintf("%p ", method_header);
947      }
948      vios->Stream() << StringPrintf("(offset=0x%08x)\n", method_header_offset);
949      if (method_header_offset > oat_file_.Size()) {
950        vios->Stream() << StringPrintf(
951            "WARNING: oat quick method header offset 0x%08x is past end of file 0x%08zx.\n",
952            method_header_offset, oat_file_.Size());
953        // If we can't read the OatQuickMethodHeader, the rest of the data is dangerous to read.
954        vios->Stream() << std::flush;
955        return false;
956      }
957
958      ScopedIndentation indent2(vios);
959      vios->Stream() << "mapping_table: ";
960      if (options_.absolute_addresses_) {
961        vios->Stream() << StringPrintf("%p ", oat_method.GetMappingTable());
962      }
963      uint32_t mapping_table_offset = oat_method.GetMappingTableOffset();
964      vios->Stream() << StringPrintf("(offset=0x%08x)\n", oat_method.GetMappingTableOffset());
965      if (mapping_table_offset > oat_file_.Size()) {
966        vios->Stream() << StringPrintf("WARNING: "
967                                       "mapping table offset 0x%08x is past end of file 0x%08zx. "
968                                       "mapping table offset was loaded from offset 0x%08x.\n",
969                                       mapping_table_offset, oat_file_.Size(),
970                                       oat_method.GetMappingTableOffsetOffset());
971        success = false;
972      } else if (options_.dump_raw_mapping_table_) {
973        ScopedIndentation indent3(vios);
974        DumpMappingTable(vios, oat_method);
975      }
976
977      vios->Stream() << "vmap_table: ";
978      if (options_.absolute_addresses_) {
979        vios->Stream() << StringPrintf("%p ", oat_method.GetVmapTable());
980      }
981      uint32_t vmap_table_offset = oat_method.GetVmapTableOffset();
982      vios->Stream() << StringPrintf("(offset=0x%08x)\n", vmap_table_offset);
983      if (vmap_table_offset > oat_file_.Size()) {
984        vios->Stream() << StringPrintf("WARNING: "
985                                       "vmap table offset 0x%08x is past end of file 0x%08zx. "
986                                       "vmap table offset was loaded from offset 0x%08x.\n",
987                                       vmap_table_offset, oat_file_.Size(),
988                                       oat_method.GetVmapTableOffsetOffset());
989        success = false;
990      } else if (options_.dump_vmap_) {
991        DumpVmapData(vios, oat_method, code_item);
992      }
993    }
994    {
995      vios->Stream() << "QuickMethodFrameInfo\n";
996
997      ScopedIndentation indent2(vios);
998      vios->Stream()
999          << StringPrintf("frame_size_in_bytes: %zd\n", oat_method.GetFrameSizeInBytes());
1000      vios->Stream() << StringPrintf("core_spill_mask: 0x%08x ", oat_method.GetCoreSpillMask());
1001      DumpSpillMask(vios->Stream(), oat_method.GetCoreSpillMask(), false);
1002      vios->Stream() << "\n";
1003      vios->Stream() << StringPrintf("fp_spill_mask: 0x%08x ", oat_method.GetFpSpillMask());
1004      DumpSpillMask(vios->Stream(), oat_method.GetFpSpillMask(), true);
1005      vios->Stream() << "\n";
1006    }
1007    {
1008      // Based on spill masks from QuickMethodFrameInfo so placed
1009      // after it is dumped, but useful for understanding quick
1010      // code, so dumped here.
1011      ScopedIndentation indent2(vios);
1012      DumpVregLocations(vios->Stream(), oat_method, code_item);
1013    }
1014    {
1015      vios->Stream() << "CODE: ";
1016      uint32_t code_size_offset = oat_method.GetQuickCodeSizeOffset();
1017      if (code_size_offset > oat_file_.Size()) {
1018        ScopedIndentation indent2(vios);
1019        vios->Stream() << StringPrintf("WARNING: "
1020                                       "code size offset 0x%08x is past end of file 0x%08zx.",
1021                                       code_size_offset, oat_file_.Size());
1022        success = false;
1023      } else {
1024        const void* code = oat_method.GetQuickCode();
1025        uint32_t aligned_code_begin = AlignCodeOffset(code_offset);
1026        uint64_t aligned_code_end = aligned_code_begin + code_size;
1027
1028        if (options_.absolute_addresses_) {
1029          vios->Stream() << StringPrintf("%p ", code);
1030        }
1031        vios->Stream() << StringPrintf("(code_offset=0x%08x size_offset=0x%08x size=%u)%s\n",
1032                                       code_offset,
1033                                       code_size_offset,
1034                                       code_size,
1035                                       code != nullptr ? "..." : "");
1036
1037        ScopedIndentation indent2(vios);
1038        if (aligned_code_begin > oat_file_.Size()) {
1039          vios->Stream() << StringPrintf("WARNING: "
1040                                         "start of code at 0x%08x is past end of file 0x%08zx.",
1041                                         aligned_code_begin, oat_file_.Size());
1042          success = false;
1043        } else if (aligned_code_end > oat_file_.Size()) {
1044          vios->Stream() << StringPrintf(
1045              "WARNING: "
1046              "end of code at 0x%08" PRIx64 " is past end of file 0x%08zx. "
1047              "code size is 0x%08x loaded from offset 0x%08x.\n",
1048              aligned_code_end, oat_file_.Size(),
1049              code_size, code_size_offset);
1050          success = false;
1051          if (options_.disassemble_code_) {
1052            if (code_size_offset + kPrologueBytes <= oat_file_.Size()) {
1053              DumpCode(vios, verifier.get(), oat_method, code_item, true, kPrologueBytes);
1054            }
1055          }
1056        } else if (code_size > kMaxCodeSize) {
1057          vios->Stream() << StringPrintf(
1058              "WARNING: "
1059              "code size %d is bigger than max expected threshold of %d. "
1060              "code size is 0x%08x loaded from offset 0x%08x.\n",
1061              code_size, kMaxCodeSize,
1062              code_size, code_size_offset);
1063          success = false;
1064          if (options_.disassemble_code_) {
1065            if (code_size_offset + kPrologueBytes <= oat_file_.Size()) {
1066              DumpCode(vios, verifier.get(), oat_method, code_item, true, kPrologueBytes);
1067            }
1068          }
1069        } else if (options_.disassemble_code_) {
1070          DumpCode(vios, verifier.get(), oat_method, code_item, !success, 0);
1071        }
1072      }
1073    }
1074    vios->Stream() << std::flush;
1075    return success;
1076  }
1077
1078  void DumpSpillMask(std::ostream& os, uint32_t spill_mask, bool is_float) {
1079    if (spill_mask == 0) {
1080      return;
1081    }
1082    os << "(";
1083    for (size_t i = 0; i < 32; i++) {
1084      if ((spill_mask & (1 << i)) != 0) {
1085        if (is_float) {
1086          os << "fr" << i;
1087        } else {
1088          os << "r" << i;
1089        }
1090        spill_mask ^= 1 << i;  // clear bit
1091        if (spill_mask != 0) {
1092          os << ", ";
1093        } else {
1094          break;
1095        }
1096      }
1097    }
1098    os << ")";
1099  }
1100
1101  // Display data stored at the the vmap offset of an oat method.
1102  void DumpVmapData(VariableIndentationOutputStream* vios,
1103                    const OatFile::OatMethod& oat_method,
1104                    const DexFile::CodeItem* code_item) {
1105    if (IsMethodGeneratedByOptimizingCompiler(oat_method, code_item)) {
1106      // The optimizing compiler outputs its CodeInfo data in the vmap table.
1107      const void* raw_code_info = oat_method.GetVmapTable();
1108      if (raw_code_info != nullptr) {
1109        CodeInfo code_info(raw_code_info);
1110        DCHECK(code_item != nullptr);
1111        ScopedIndentation indent1(vios);
1112        DumpCodeInfo(vios, code_info, oat_method, *code_item);
1113      }
1114    } else if (IsMethodGeneratedByDexToDexCompiler(oat_method, code_item)) {
1115      // We don't encode the size in the table, so just emit that we have quickened
1116      // information.
1117      ScopedIndentation indent(vios);
1118      vios->Stream() << "quickened data\n";
1119    } else {
1120      // Otherwise, display the vmap table.
1121      const uint8_t* raw_table = oat_method.GetVmapTable();
1122      if (raw_table != nullptr) {
1123        VmapTable vmap_table(raw_table);
1124        DumpVmapTable(vios->Stream(), oat_method, vmap_table);
1125      }
1126    }
1127  }
1128
1129  // Display a CodeInfo object emitted by the optimizing compiler.
1130  void DumpCodeInfo(VariableIndentationOutputStream* vios,
1131                    const CodeInfo& code_info,
1132                    const OatFile::OatMethod& oat_method,
1133                    const DexFile::CodeItem& code_item) {
1134    code_info.Dump(vios,
1135                   oat_method.GetCodeOffset(),
1136                   code_item.registers_size_,
1137                   options_.dump_code_info_stack_maps_);
1138  }
1139
1140  // Display a vmap table.
1141  void DumpVmapTable(std::ostream& os,
1142                     const OatFile::OatMethod& oat_method,
1143                     const VmapTable& vmap_table) {
1144    bool first = true;
1145    bool processing_fp = false;
1146    uint32_t spill_mask = oat_method.GetCoreSpillMask();
1147    for (size_t i = 0; i < vmap_table.Size(); i++) {
1148      uint16_t dex_reg = vmap_table[i];
1149      uint32_t cpu_reg = vmap_table.ComputeRegister(spill_mask, i,
1150                                                    processing_fp ? kFloatVReg : kIntVReg);
1151      os << (first ? "v" : ", v")  << dex_reg;
1152      if (!processing_fp) {
1153        os << "/r" << cpu_reg;
1154      } else {
1155        os << "/fr" << cpu_reg;
1156      }
1157      first = false;
1158      if (!processing_fp && dex_reg == 0xFFFF) {
1159        processing_fp = true;
1160        spill_mask = oat_method.GetFpSpillMask();
1161      }
1162    }
1163    os << "\n";
1164  }
1165
1166  void DumpVregLocations(std::ostream& os, const OatFile::OatMethod& oat_method,
1167                         const DexFile::CodeItem* code_item) {
1168    if (code_item != nullptr) {
1169      size_t num_locals_ins = code_item->registers_size_;
1170      size_t num_ins = code_item->ins_size_;
1171      size_t num_locals = num_locals_ins - num_ins;
1172      size_t num_outs = code_item->outs_size_;
1173
1174      os << "vr_stack_locations:";
1175      for (size_t reg = 0; reg <= num_locals_ins; reg++) {
1176        // For readability, delimit the different kinds of VRs.
1177        if (reg == num_locals_ins) {
1178          os << "\n\tmethod*:";
1179        } else if (reg == num_locals && num_ins > 0) {
1180          os << "\n\tins:";
1181        } else if (reg == 0 && num_locals > 0) {
1182          os << "\n\tlocals:";
1183        }
1184
1185        uint32_t offset = StackVisitor::GetVRegOffsetFromQuickCode(
1186            code_item,
1187            oat_method.GetCoreSpillMask(),
1188            oat_method.GetFpSpillMask(),
1189            oat_method.GetFrameSizeInBytes(),
1190            reg,
1191            GetInstructionSet());
1192        os << " v" << reg << "[sp + #" << offset << "]";
1193      }
1194
1195      for (size_t out_reg = 0; out_reg < num_outs; out_reg++) {
1196        if (out_reg == 0) {
1197          os << "\n\touts:";
1198        }
1199
1200        uint32_t offset = StackVisitor::GetOutVROffset(out_reg, GetInstructionSet());
1201        os << " v" << out_reg << "[sp + #" << offset << "]";
1202      }
1203
1204      os << "\n";
1205    }
1206  }
1207
1208  void DescribeVReg(std::ostream& os, const OatFile::OatMethod& oat_method,
1209                    const DexFile::CodeItem* code_item, size_t reg, VRegKind kind) {
1210    const uint8_t* raw_table = oat_method.GetVmapTable();
1211    if (raw_table != nullptr) {
1212      const VmapTable vmap_table(raw_table);
1213      uint32_t vmap_offset;
1214      if (vmap_table.IsInContext(reg, kind, &vmap_offset)) {
1215        bool is_float = (kind == kFloatVReg) || (kind == kDoubleLoVReg) || (kind == kDoubleHiVReg);
1216        uint32_t spill_mask = is_float ? oat_method.GetFpSpillMask()
1217                                       : oat_method.GetCoreSpillMask();
1218        os << (is_float ? "fr" : "r") << vmap_table.ComputeRegister(spill_mask, vmap_offset, kind);
1219      } else {
1220        uint32_t offset = StackVisitor::GetVRegOffsetFromQuickCode(
1221            code_item,
1222            oat_method.GetCoreSpillMask(),
1223            oat_method.GetFpSpillMask(),
1224            oat_method.GetFrameSizeInBytes(),
1225            reg,
1226            GetInstructionSet());
1227        os << "[sp + #" << offset << "]";
1228      }
1229    }
1230  }
1231
1232  void DumpGcMapRegisters(std::ostream& os, const OatFile::OatMethod& oat_method,
1233                          const DexFile::CodeItem* code_item,
1234                          size_t num_regs, const uint8_t* reg_bitmap) {
1235    bool first = true;
1236    for (size_t reg = 0; reg < num_regs; reg++) {
1237      if (((reg_bitmap[reg / 8] >> (reg % 8)) & 0x01) != 0) {
1238        if (first) {
1239          os << "  v" << reg << " (";
1240          DescribeVReg(os, oat_method, code_item, reg, kReferenceVReg);
1241          os << ")";
1242          first = false;
1243        } else {
1244          os << ", v" << reg << " (";
1245          DescribeVReg(os, oat_method, code_item, reg, kReferenceVReg);
1246          os << ")";
1247        }
1248      }
1249    }
1250    if (first) {
1251      os << "No registers in GC map\n";
1252    } else {
1253      os << "\n";
1254    }
1255  }
1256  void DumpGcMap(std::ostream& os, const OatFile::OatMethod& oat_method,
1257                 const DexFile::CodeItem* code_item) {
1258    const uint8_t* gc_map_raw = oat_method.GetGcMap();
1259    if (gc_map_raw == nullptr) {
1260      return;  // No GC map.
1261    }
1262    const void* quick_code = oat_method.GetQuickCode();
1263    NativePcOffsetToReferenceMap map(gc_map_raw);
1264    for (size_t entry = 0; entry < map.NumEntries(); entry++) {
1265      const uint8_t* native_pc = reinterpret_cast<const uint8_t*>(quick_code) +
1266          map.GetNativePcOffset(entry);
1267      os << StringPrintf("%p", native_pc);
1268      DumpGcMapRegisters(os, oat_method, code_item, map.RegWidth() * 8, map.GetBitMap(entry));
1269    }
1270  }
1271
1272  void DumpMappingTable(VariableIndentationOutputStream* vios,
1273                        const OatFile::OatMethod& oat_method) {
1274    const void* quick_code = oat_method.GetQuickCode();
1275    if (quick_code == nullptr) {
1276      return;
1277    }
1278    MappingTable table(oat_method.GetMappingTable());
1279    if (table.TotalSize() != 0) {
1280      if (table.PcToDexSize() != 0) {
1281        typedef MappingTable::PcToDexIterator It;
1282        vios->Stream() << "suspend point mappings {\n";
1283        for (It cur = table.PcToDexBegin(), end = table.PcToDexEnd(); cur != end; ++cur) {
1284          ScopedIndentation indent1(vios);
1285          vios->Stream() << StringPrintf("0x%04x -> 0x%04x\n", cur.NativePcOffset(), cur.DexPc());
1286        }
1287        vios->Stream() << "}\n";
1288      }
1289      if (table.DexToPcSize() != 0) {
1290        typedef MappingTable::DexToPcIterator It;
1291        vios->Stream() << "catch entry mappings {\n";
1292        for (It cur = table.DexToPcBegin(), end = table.DexToPcEnd(); cur != end; ++cur) {
1293          ScopedIndentation indent1(vios);
1294          vios->Stream() << StringPrintf("0x%04x -> 0x%04x\n", cur.NativePcOffset(), cur.DexPc());
1295        }
1296        vios->Stream() << "}\n";
1297      }
1298    }
1299  }
1300
1301  uint32_t DumpInformationAtOffset(VariableIndentationOutputStream* vios,
1302                                   const OatFile::OatMethod& oat_method,
1303                                   const DexFile::CodeItem* code_item,
1304                                   size_t offset,
1305                                   bool suspend_point_mapping) {
1306    if (IsMethodGeneratedByOptimizingCompiler(oat_method, code_item)) {
1307      if (suspend_point_mapping) {
1308        ScopedIndentation indent1(vios);
1309        DumpDexRegisterMapAtOffset(vios, oat_method, code_item, offset);
1310      }
1311      // The return value is not used in the case of a method compiled
1312      // with the optimizing compiler.
1313      return DexFile::kDexNoIndex;
1314    } else {
1315      return DumpMappingAtOffset(vios->Stream(), oat_method, offset, suspend_point_mapping);
1316    }
1317  }
1318
1319  uint32_t DumpMappingAtOffset(std::ostream& os, const OatFile::OatMethod& oat_method,
1320                               size_t offset, bool suspend_point_mapping) {
1321    MappingTable table(oat_method.GetMappingTable());
1322    if (suspend_point_mapping && table.PcToDexSize() > 0) {
1323      typedef MappingTable::PcToDexIterator It;
1324      for (It cur = table.PcToDexBegin(), end = table.PcToDexEnd(); cur != end; ++cur) {
1325        if (offset == cur.NativePcOffset()) {
1326          os << StringPrintf("suspend point dex PC: 0x%04x\n", cur.DexPc());
1327          return cur.DexPc();
1328        }
1329      }
1330    } else if (!suspend_point_mapping && table.DexToPcSize() > 0) {
1331      typedef MappingTable::DexToPcIterator It;
1332      for (It cur = table.DexToPcBegin(), end = table.DexToPcEnd(); cur != end; ++cur) {
1333        if (offset == cur.NativePcOffset()) {
1334          os << StringPrintf("catch entry dex PC: 0x%04x\n", cur.DexPc());
1335          return cur.DexPc();
1336        }
1337      }
1338    }
1339    return DexFile::kDexNoIndex;
1340  }
1341
1342  void DumpGcMapAtNativePcOffset(std::ostream& os, const OatFile::OatMethod& oat_method,
1343                                 const DexFile::CodeItem* code_item, size_t native_pc_offset) {
1344    const uint8_t* gc_map_raw = oat_method.GetGcMap();
1345    if (gc_map_raw != nullptr) {
1346      NativePcOffsetToReferenceMap map(gc_map_raw);
1347      if (map.HasEntry(native_pc_offset)) {
1348        size_t num_regs = map.RegWidth() * 8;
1349        const uint8_t* reg_bitmap = map.FindBitMap(native_pc_offset);
1350        bool first = true;
1351        for (size_t reg = 0; reg < num_regs; reg++) {
1352          if (((reg_bitmap[reg / 8] >> (reg % 8)) & 0x01) != 0) {
1353            if (first) {
1354              os << "GC map objects:  v" << reg << " (";
1355              DescribeVReg(os, oat_method, code_item, reg, kReferenceVReg);
1356              os << ")";
1357              first = false;
1358            } else {
1359              os << ", v" << reg << " (";
1360              DescribeVReg(os, oat_method, code_item, reg, kReferenceVReg);
1361              os << ")";
1362            }
1363          }
1364        }
1365        if (!first) {
1366          os << "\n";
1367        }
1368      }
1369    }
1370  }
1371
1372  void DumpVRegsAtDexPc(std::ostream& os, verifier::MethodVerifier* verifier,
1373                        const OatFile::OatMethod& oat_method,
1374                        const DexFile::CodeItem* code_item, uint32_t dex_pc) {
1375    DCHECK(verifier != nullptr);
1376    std::vector<int32_t> kinds = verifier->DescribeVRegs(dex_pc);
1377    bool first = true;
1378    for (size_t reg = 0; reg < code_item->registers_size_; reg++) {
1379      VRegKind kind = static_cast<VRegKind>(kinds.at(reg * 2));
1380      if (kind != kUndefined) {
1381        if (first) {
1382          os << "VRegs:  v";
1383          first = false;
1384        } else {
1385          os << ", v";
1386        }
1387        os << reg << " (";
1388        switch (kind) {
1389          case kImpreciseConstant:
1390            os << "Imprecise Constant: " << kinds.at((reg * 2) + 1) << ", ";
1391            DescribeVReg(os, oat_method, code_item, reg, kind);
1392            break;
1393          case kConstant:
1394            os << "Constant: " << kinds.at((reg * 2) + 1);
1395            break;
1396          default:
1397            DescribeVReg(os, oat_method, code_item, reg, kind);
1398            break;
1399        }
1400        os << ")";
1401      }
1402    }
1403    if (!first) {
1404      os << "\n";
1405    }
1406  }
1407
1408
1409  void DumpDexCode(std::ostream& os, const DexFile& dex_file, const DexFile::CodeItem* code_item) {
1410    if (code_item != nullptr) {
1411      size_t i = 0;
1412      while (i < code_item->insns_size_in_code_units_) {
1413        const Instruction* instruction = Instruction::At(&code_item->insns_[i]);
1414        os << StringPrintf("0x%04zx: ", i) << instruction->DumpHexLE(5)
1415           << StringPrintf("\t| %s\n", instruction->DumpString(&dex_file).c_str());
1416        i += instruction->SizeInCodeUnits();
1417      }
1418    }
1419  }
1420
1421  // Has `oat_method` -- corresponding to the Dex `code_item` -- been compiled by
1422  // the optimizing compiler?
1423  static bool IsMethodGeneratedByOptimizingCompiler(const OatFile::OatMethod& oat_method,
1424                                                    const DexFile::CodeItem* code_item) {
1425    // If the native GC map is null and the Dex `code_item` is not
1426    // null, then this method has been compiled with the optimizing
1427    // compiler.
1428    return oat_method.GetQuickCode() != nullptr &&
1429           oat_method.GetGcMap() == nullptr &&
1430           code_item != nullptr;
1431  }
1432
1433  // Has `oat_method` -- corresponding to the Dex `code_item` -- been compiled by
1434  // the dextodex compiler?
1435  static bool IsMethodGeneratedByDexToDexCompiler(const OatFile::OatMethod& oat_method,
1436                                                  const DexFile::CodeItem* code_item) {
1437    // If the quick code is null, the Dex `code_item` is not
1438    // null, and the vmap table is not null, then this method has been compiled
1439    // with the dextodex compiler.
1440    return oat_method.GetQuickCode() == nullptr &&
1441           oat_method.GetVmapTable() != nullptr &&
1442           code_item != nullptr;
1443  }
1444
1445  void DumpDexRegisterMapAtOffset(VariableIndentationOutputStream* vios,
1446                                  const OatFile::OatMethod& oat_method,
1447                                  const DexFile::CodeItem* code_item,
1448                                  size_t offset) {
1449    // This method is only relevant for oat methods compiled with the
1450    // optimizing compiler.
1451    DCHECK(IsMethodGeneratedByOptimizingCompiler(oat_method, code_item));
1452
1453    // The optimizing compiler outputs its CodeInfo data in the vmap table.
1454    const void* raw_code_info = oat_method.GetVmapTable();
1455    if (raw_code_info != nullptr) {
1456      CodeInfo code_info(raw_code_info);
1457      StackMapEncoding encoding = code_info.ExtractEncoding();
1458      StackMap stack_map = code_info.GetStackMapForNativePcOffset(offset, encoding);
1459      if (stack_map.IsValid()) {
1460        stack_map.Dump(vios, code_info, encoding, oat_method.GetCodeOffset(),
1461                       code_item->registers_size_);
1462      }
1463    }
1464  }
1465
1466  verifier::MethodVerifier* DumpVerifier(VariableIndentationOutputStream* vios,
1467                                         StackHandleScope<1>* hs,
1468                                         uint32_t dex_method_idx,
1469                                         const DexFile* dex_file,
1470                                         const DexFile::ClassDef& class_def,
1471                                         const DexFile::CodeItem* code_item,
1472                                         uint32_t method_access_flags) {
1473    if ((method_access_flags & kAccNative) == 0) {
1474      ScopedObjectAccess soa(Thread::Current());
1475      Runtime* const runtime = Runtime::Current();
1476      Handle<mirror::DexCache> dex_cache(
1477          hs->NewHandle(runtime->GetClassLinker()->RegisterDexFile(*dex_file,
1478                                                                   runtime->GetLinearAlloc())));
1479      DCHECK(options_.class_loader_ != nullptr);
1480      return verifier::MethodVerifier::VerifyMethodAndDump(
1481          soa.Self(), vios, dex_method_idx, dex_file, dex_cache, *options_.class_loader_,
1482          &class_def, code_item, nullptr, method_access_flags);
1483    }
1484
1485    return nullptr;
1486  }
1487
1488  void DumpCode(VariableIndentationOutputStream* vios,
1489                verifier::MethodVerifier* verifier,
1490                const OatFile::OatMethod& oat_method, const DexFile::CodeItem* code_item,
1491                bool bad_input, size_t code_size) {
1492    const void* quick_code = oat_method.GetQuickCode();
1493
1494    if (code_size == 0) {
1495      code_size = oat_method.GetQuickCodeSize();
1496    }
1497    if (code_size == 0 || quick_code == nullptr) {
1498      vios->Stream() << "NO CODE!\n";
1499      return;
1500    } else {
1501      const uint8_t* quick_native_pc = reinterpret_cast<const uint8_t*>(quick_code);
1502      size_t offset = 0;
1503      while (offset < code_size) {
1504        if (!bad_input) {
1505          DumpInformationAtOffset(vios, oat_method, code_item, offset, false);
1506        }
1507        offset += disassembler_->Dump(vios->Stream(), quick_native_pc + offset);
1508        if (!bad_input) {
1509          uint32_t dex_pc =
1510              DumpInformationAtOffset(vios, oat_method, code_item, offset, true);
1511          if (dex_pc != DexFile::kDexNoIndex) {
1512            DumpGcMapAtNativePcOffset(vios->Stream(), oat_method, code_item, offset);
1513            if (verifier != nullptr) {
1514              DumpVRegsAtDexPc(vios->Stream(), verifier, oat_method, code_item, dex_pc);
1515            }
1516          }
1517        }
1518      }
1519    }
1520  }
1521
1522  const OatFile& oat_file_;
1523  const std::vector<const OatFile::OatDexFile*> oat_dex_files_;
1524  const OatDumperOptions& options_;
1525  uint32_t resolved_addr2instr_;
1526  InstructionSet instruction_set_;
1527  std::set<uintptr_t> offsets_;
1528  Disassembler* disassembler_;
1529};
1530
1531class ImageDumper {
1532 public:
1533  ImageDumper(std::ostream* os, gc::space::ImageSpace& image_space,
1534              const ImageHeader& image_header, OatDumperOptions* oat_dumper_options)
1535      : os_(os),
1536        vios_(os),
1537        indent1_(&vios_),
1538        image_space_(image_space),
1539        image_header_(image_header),
1540        oat_dumper_options_(oat_dumper_options) {}
1541
1542  bool Dump() SHARED_REQUIRES(Locks::mutator_lock_) {
1543    std::ostream& os = *os_;
1544    std::ostream& indent_os = vios_.Stream();
1545
1546    os << "MAGIC: " << image_header_.GetMagic() << "\n\n";
1547
1548    os << "IMAGE LOCATION: " << image_space_.GetImageLocation() << "\n\n";
1549
1550    os << "IMAGE BEGIN: " << reinterpret_cast<void*>(image_header_.GetImageBegin()) << "\n\n";
1551
1552    os << "IMAGE SIZE: " << image_header_.GetImageSize() << "\n\n";
1553
1554    for (size_t i = 0; i < ImageHeader::kSectionCount; ++i) {
1555      auto section = static_cast<ImageHeader::ImageSections>(i);
1556      os << "IMAGE SECTION " << section << ": " << image_header_.GetImageSection(section) << "\n\n";
1557    }
1558
1559    os << "OAT CHECKSUM: " << StringPrintf("0x%08x\n\n", image_header_.GetOatChecksum());
1560
1561    os << "OAT FILE BEGIN:" << reinterpret_cast<void*>(image_header_.GetOatFileBegin()) << "\n\n";
1562
1563    os << "OAT DATA BEGIN:" << reinterpret_cast<void*>(image_header_.GetOatDataBegin()) << "\n\n";
1564
1565    os << "OAT DATA END:" << reinterpret_cast<void*>(image_header_.GetOatDataEnd()) << "\n\n";
1566
1567    os << "OAT FILE END:" << reinterpret_cast<void*>(image_header_.GetOatFileEnd()) << "\n\n";
1568
1569    os << "PATCH DELTA:" << image_header_.GetPatchDelta() << "\n\n";
1570
1571    os << "COMPILE PIC: " << (image_header_.CompilePic() ? "yes" : "no") << "\n\n";
1572
1573    {
1574      os << "ROOTS: " << reinterpret_cast<void*>(image_header_.GetImageRoots()) << "\n";
1575      static_assert(arraysize(image_roots_descriptions_) ==
1576          static_cast<size_t>(ImageHeader::kImageRootsMax), "sizes must match");
1577      for (int i = 0; i < ImageHeader::kImageRootsMax; i++) {
1578        ImageHeader::ImageRoot image_root = static_cast<ImageHeader::ImageRoot>(i);
1579        const char* image_root_description = image_roots_descriptions_[i];
1580        mirror::Object* image_root_object = image_header_.GetImageRoot(image_root);
1581        indent_os << StringPrintf("%s: %p\n", image_root_description, image_root_object);
1582        if (image_root_object->IsObjectArray()) {
1583          mirror::ObjectArray<mirror::Object>* image_root_object_array
1584              = image_root_object->AsObjectArray<mirror::Object>();
1585          ScopedIndentation indent2(&vios_);
1586          for (int j = 0; j < image_root_object_array->GetLength(); j++) {
1587            mirror::Object* value = image_root_object_array->Get(j);
1588            size_t run = 0;
1589            for (int32_t k = j + 1; k < image_root_object_array->GetLength(); k++) {
1590              if (value == image_root_object_array->Get(k)) {
1591                run++;
1592              } else {
1593                break;
1594              }
1595            }
1596            if (run == 0) {
1597              indent_os << StringPrintf("%d: ", j);
1598            } else {
1599              indent_os << StringPrintf("%d to %zd: ", j, j + run);
1600              j = j + run;
1601            }
1602            if (value != nullptr) {
1603              PrettyObjectValue(indent_os, value->GetClass(), value);
1604            } else {
1605              indent_os << j << ": null\n";
1606            }
1607          }
1608        }
1609      }
1610    }
1611
1612    {
1613      os << "METHOD ROOTS\n";
1614      static_assert(arraysize(image_methods_descriptions_) ==
1615          static_cast<size_t>(ImageHeader::kImageMethodsCount), "sizes must match");
1616      for (int i = 0; i < ImageHeader::kImageMethodsCount; i++) {
1617        auto image_root = static_cast<ImageHeader::ImageMethod>(i);
1618        const char* description = image_methods_descriptions_[i];
1619        auto* image_method = image_header_.GetImageMethod(image_root);
1620        indent_os << StringPrintf("%s: %p\n", description, image_method);
1621      }
1622    }
1623    os << "\n";
1624
1625    Runtime* const runtime = Runtime::Current();
1626    ClassLinker* class_linker = runtime->GetClassLinker();
1627    std::string image_filename = image_space_.GetImageFilename();
1628    std::string oat_location = ImageHeader::GetOatLocationFromImageLocation(image_filename);
1629    os << "OAT LOCATION: " << oat_location;
1630    os << "\n";
1631    std::string error_msg;
1632    const OatFile* oat_file = runtime->GetOatFileManager().FindOpenedOatFileFromOatLocation(
1633        oat_location);
1634    if (oat_file == nullptr) {
1635      oat_file = OatFile::Open(oat_location, oat_location,
1636                               nullptr, nullptr, false, nullptr,
1637                               &error_msg);
1638      if (oat_file == nullptr) {
1639        os << "NOT FOUND: " << error_msg << "\n";
1640        return false;
1641      }
1642    }
1643    os << "\n";
1644
1645    stats_.oat_file_bytes = oat_file->Size();
1646
1647    oat_dumper_.reset(new OatDumper(*oat_file, *oat_dumper_options_));
1648
1649    for (const OatFile::OatDexFile* oat_dex_file : oat_file->GetOatDexFiles()) {
1650      CHECK(oat_dex_file != nullptr);
1651      stats_.oat_dex_file_sizes.push_back(std::make_pair(oat_dex_file->GetDexFileLocation(),
1652                                                         oat_dex_file->FileSize()));
1653    }
1654
1655    os << "OBJECTS:\n" << std::flush;
1656
1657    // Loop through the image space and dump its objects.
1658    gc::Heap* heap = runtime->GetHeap();
1659    Thread* self = Thread::Current();
1660    {
1661      {
1662        WriterMutexLock mu(self, *Locks::heap_bitmap_lock_);
1663        heap->FlushAllocStack();
1664      }
1665      // Since FlushAllocStack() above resets the (active) allocation
1666      // stack. Need to revoke the thread-local allocation stacks that
1667      // point into it.
1668      ScopedThreadSuspension sts(self, kNative);
1669      ScopedSuspendAll ssa(__FUNCTION__);
1670      heap->RevokeAllThreadLocalAllocationStacks(self);
1671    }
1672    {
1673      // Mark dex caches.
1674      dex_caches_.clear();
1675      {
1676        ReaderMutexLock mu(self, *class_linker->DexLock());
1677        for (const ClassLinker::DexCacheData& data : class_linker->GetDexCachesData()) {
1678          mirror::DexCache* dex_cache =
1679              down_cast<mirror::DexCache*>(self->DecodeJObject(data.weak_root));
1680          if (dex_cache != nullptr) {
1681            dex_caches_.insert(dex_cache);
1682          }
1683        }
1684      }
1685      ReaderMutexLock mu(self, *Locks::heap_bitmap_lock_);
1686      // Dump the normal objects before ArtMethods.
1687      image_space_.GetLiveBitmap()->Walk(ImageDumper::Callback, this);
1688      indent_os << "\n";
1689      // TODO: Dump fields.
1690      // Dump methods after.
1691      const auto& methods_section = image_header_.GetMethodsSection();
1692      const size_t pointer_size =
1693          InstructionSetPointerSize(oat_dumper_->GetOatInstructionSet());
1694      DumpArtMethodVisitor visitor(this);
1695      methods_section.VisitPackedArtMethods(&visitor, image_space_.Begin(), pointer_size);
1696      // Dump the large objects separately.
1697      heap->GetLargeObjectsSpace()->GetLiveBitmap()->Walk(ImageDumper::Callback, this);
1698      indent_os << "\n";
1699    }
1700    os << "STATS:\n" << std::flush;
1701    std::unique_ptr<File> file(OS::OpenFileForReading(image_filename.c_str()));
1702    if (file.get() == nullptr) {
1703      LOG(WARNING) << "Failed to find image in " << image_filename;
1704    }
1705    if (file.get() != nullptr) {
1706      stats_.file_bytes = file->GetLength();
1707    }
1708    size_t header_bytes = sizeof(ImageHeader);
1709    const auto& object_section = image_header_.GetImageSection(ImageHeader::kSectionObjects);
1710    const auto& field_section = image_header_.GetImageSection(ImageHeader::kSectionArtFields);
1711    const auto& method_section = image_header_.GetMethodsSection();
1712    const auto& dex_cache_arrays_section = image_header_.GetImageSection(
1713        ImageHeader::kSectionDexCacheArrays);
1714    const auto& intern_section = image_header_.GetImageSection(
1715        ImageHeader::kSectionInternedStrings);
1716    const auto& class_table_section = image_header_.GetImageSection(
1717        ImageHeader::kSectionClassTable);
1718    const auto& bitmap_section = image_header_.GetImageSection(ImageHeader::kSectionImageBitmap);
1719
1720    stats_.header_bytes = header_bytes;
1721
1722    // Objects are kObjectAlignment-aligned.
1723    // CHECK_EQ(RoundUp(header_bytes, kObjectAlignment), object_section.Offset());
1724    if (object_section.Offset() > header_bytes) {
1725      stats_.alignment_bytes += object_section.Offset() - header_bytes;
1726    }
1727
1728    // Field section is 4-byte aligned.
1729    constexpr size_t kFieldSectionAlignment = 4U;
1730    uint32_t end_objects = object_section.Offset() + object_section.Size();
1731    CHECK_EQ(RoundUp(end_objects, kFieldSectionAlignment), field_section.Offset());
1732    stats_.alignment_bytes += field_section.Offset() - end_objects;
1733
1734    // Method section is 4/8 byte aligned depending on target. Just check for 4-byte alignment.
1735    uint32_t end_fields = field_section.Offset() + field_section.Size();
1736    CHECK_ALIGNED(method_section.Offset(), 4);
1737    stats_.alignment_bytes += method_section.Offset() - end_fields;
1738
1739    // Dex cache arrays section is aligned depending on the target. Just check for 4-byte alignment.
1740    uint32_t end_methods = method_section.Offset() + method_section.Size();
1741    CHECK_ALIGNED(dex_cache_arrays_section.Offset(), 4);
1742    stats_.alignment_bytes += dex_cache_arrays_section.Offset() - end_methods;
1743
1744    // Intern table is 8-byte aligned.
1745    uint32_t end_caches = dex_cache_arrays_section.Offset() + dex_cache_arrays_section.Size();
1746    CHECK_EQ(RoundUp(end_caches, 8U), intern_section.Offset());
1747    stats_.alignment_bytes += intern_section.Offset() - end_caches;
1748
1749    // Add space between intern table and class table.
1750    uint32_t end_intern = intern_section.Offset() + intern_section.Size();
1751    stats_.alignment_bytes += class_table_section.Offset() - end_intern;
1752
1753    // Add space between class table and bitmap. Expect the bitmap to be page-aligned.
1754    uint32_t end_ctable = class_table_section.Offset() + class_table_section.Size();
1755    CHECK_ALIGNED(bitmap_section.Offset(), kPageSize);
1756    stats_.alignment_bytes += bitmap_section.Offset() - end_ctable;
1757
1758    stats_.bitmap_bytes += bitmap_section.Size();
1759    stats_.art_field_bytes += field_section.Size();
1760    stats_.art_method_bytes += method_section.Size();
1761    stats_.dex_cache_arrays_bytes += dex_cache_arrays_section.Size();
1762    stats_.interned_strings_bytes += intern_section.Size();
1763    stats_.class_table_bytes += class_table_section.Size();
1764    stats_.Dump(os, indent_os);
1765    os << "\n";
1766
1767    os << std::flush;
1768
1769    return oat_dumper_->Dump(os);
1770  }
1771
1772 private:
1773  class DumpArtMethodVisitor : public ArtMethodVisitor {
1774   public:
1775    explicit DumpArtMethodVisitor(ImageDumper* image_dumper) : image_dumper_(image_dumper) {}
1776
1777    virtual void Visit(ArtMethod* method) OVERRIDE SHARED_REQUIRES(Locks::mutator_lock_) {
1778      std::ostream& indent_os = image_dumper_->vios_.Stream();
1779      indent_os << method << " " << " ArtMethod: " << PrettyMethod(method) << "\n";
1780      image_dumper_->DumpMethod(method, image_dumper_, indent_os);
1781      indent_os << "\n";
1782    }
1783
1784   private:
1785    ImageDumper* const image_dumper_;
1786  };
1787
1788  static void PrettyObjectValue(std::ostream& os, mirror::Class* type, mirror::Object* value)
1789      SHARED_REQUIRES(Locks::mutator_lock_) {
1790    CHECK(type != nullptr);
1791    if (value == nullptr) {
1792      os << StringPrintf("null   %s\n", PrettyDescriptor(type).c_str());
1793    } else if (type->IsStringClass()) {
1794      mirror::String* string = value->AsString();
1795      os << StringPrintf("%p   String: %s\n", string,
1796                         PrintableString(string->ToModifiedUtf8().c_str()).c_str());
1797    } else if (type->IsClassClass()) {
1798      mirror::Class* klass = value->AsClass();
1799      os << StringPrintf("%p   Class: %s\n", klass, PrettyDescriptor(klass).c_str());
1800    } else {
1801      os << StringPrintf("%p   %s\n", value, PrettyDescriptor(type).c_str());
1802    }
1803  }
1804
1805  static void PrintField(std::ostream& os, ArtField* field, mirror::Object* obj)
1806      SHARED_REQUIRES(Locks::mutator_lock_) {
1807    os << StringPrintf("%s: ", field->GetName());
1808    switch (field->GetTypeAsPrimitiveType()) {
1809      case Primitive::kPrimLong:
1810        os << StringPrintf("%" PRId64 " (0x%" PRIx64 ")\n", field->Get64(obj), field->Get64(obj));
1811        break;
1812      case Primitive::kPrimDouble:
1813        os << StringPrintf("%f (%a)\n", field->GetDouble(obj), field->GetDouble(obj));
1814        break;
1815      case Primitive::kPrimFloat:
1816        os << StringPrintf("%f (%a)\n", field->GetFloat(obj), field->GetFloat(obj));
1817        break;
1818      case Primitive::kPrimInt:
1819        os << StringPrintf("%d (0x%x)\n", field->Get32(obj), field->Get32(obj));
1820        break;
1821      case Primitive::kPrimChar:
1822        os << StringPrintf("%u (0x%x)\n", field->GetChar(obj), field->GetChar(obj));
1823        break;
1824      case Primitive::kPrimShort:
1825        os << StringPrintf("%d (0x%x)\n", field->GetShort(obj), field->GetShort(obj));
1826        break;
1827      case Primitive::kPrimBoolean:
1828        os << StringPrintf("%s (0x%x)\n", field->GetBoolean(obj)? "true" : "false",
1829            field->GetBoolean(obj));
1830        break;
1831      case Primitive::kPrimByte:
1832        os << StringPrintf("%d (0x%x)\n", field->GetByte(obj), field->GetByte(obj));
1833        break;
1834      case Primitive::kPrimNot: {
1835        // Get the value, don't compute the type unless it is non-null as we don't want
1836        // to cause class loading.
1837        mirror::Object* value = field->GetObj(obj);
1838        if (value == nullptr) {
1839          os << StringPrintf("null   %s\n", PrettyDescriptor(field->GetTypeDescriptor()).c_str());
1840        } else {
1841          // Grab the field type without causing resolution.
1842          mirror::Class* field_type = field->GetType<false>();
1843          if (field_type != nullptr) {
1844            PrettyObjectValue(os, field_type, value);
1845          } else {
1846            os << StringPrintf("%p   %s\n", value,
1847                               PrettyDescriptor(field->GetTypeDescriptor()).c_str());
1848          }
1849        }
1850        break;
1851      }
1852      default:
1853        os << "unexpected field type: " << field->GetTypeDescriptor() << "\n";
1854        break;
1855    }
1856  }
1857
1858  static void DumpFields(std::ostream& os, mirror::Object* obj, mirror::Class* klass)
1859      SHARED_REQUIRES(Locks::mutator_lock_) {
1860    mirror::Class* super = klass->GetSuperClass();
1861    if (super != nullptr) {
1862      DumpFields(os, obj, super);
1863    }
1864    for (ArtField& field : klass->GetIFields()) {
1865      PrintField(os, &field, obj);
1866    }
1867  }
1868
1869  bool InDumpSpace(const mirror::Object* object) {
1870    return image_space_.Contains(object);
1871  }
1872
1873  const void* GetQuickOatCodeBegin(ArtMethod* m)
1874      SHARED_REQUIRES(Locks::mutator_lock_) {
1875    const void* quick_code = m->GetEntryPointFromQuickCompiledCodePtrSize(
1876        InstructionSetPointerSize(oat_dumper_->GetOatInstructionSet()));
1877    if (Runtime::Current()->GetClassLinker()->IsQuickResolutionStub(quick_code)) {
1878      quick_code = oat_dumper_->GetQuickOatCode(m);
1879    }
1880    if (oat_dumper_->GetInstructionSet() == kThumb2) {
1881      quick_code = reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(quick_code) & ~0x1);
1882    }
1883    return quick_code;
1884  }
1885
1886  uint32_t GetQuickOatCodeSize(ArtMethod* m)
1887      SHARED_REQUIRES(Locks::mutator_lock_) {
1888    const uint32_t* oat_code_begin = reinterpret_cast<const uint32_t*>(GetQuickOatCodeBegin(m));
1889    if (oat_code_begin == nullptr) {
1890      return 0;
1891    }
1892    return oat_code_begin[-1];
1893  }
1894
1895  const void* GetQuickOatCodeEnd(ArtMethod* m)
1896      SHARED_REQUIRES(Locks::mutator_lock_) {
1897    const uint8_t* oat_code_begin = reinterpret_cast<const uint8_t*>(GetQuickOatCodeBegin(m));
1898    if (oat_code_begin == nullptr) {
1899      return nullptr;
1900    }
1901    return oat_code_begin + GetQuickOatCodeSize(m);
1902  }
1903
1904  static void Callback(mirror::Object* obj, void* arg) SHARED_REQUIRES(Locks::mutator_lock_) {
1905    DCHECK(obj != nullptr);
1906    DCHECK(arg != nullptr);
1907    ImageDumper* state = reinterpret_cast<ImageDumper*>(arg);
1908    if (!state->InDumpSpace(obj)) {
1909      return;
1910    }
1911
1912    size_t object_bytes = obj->SizeOf();
1913    size_t alignment_bytes = RoundUp(object_bytes, kObjectAlignment) - object_bytes;
1914    state->stats_.object_bytes += object_bytes;
1915    state->stats_.alignment_bytes += alignment_bytes;
1916
1917    std::ostream& os = state->vios_.Stream();
1918
1919    mirror::Class* obj_class = obj->GetClass();
1920    if (obj_class->IsArrayClass()) {
1921      os << StringPrintf("%p: %s length:%d\n", obj, PrettyDescriptor(obj_class).c_str(),
1922                         obj->AsArray()->GetLength());
1923    } else if (obj->IsClass()) {
1924      mirror::Class* klass = obj->AsClass();
1925      os << StringPrintf("%p: java.lang.Class \"%s\" (", obj, PrettyDescriptor(klass).c_str())
1926         << klass->GetStatus() << ")\n";
1927    } else if (obj_class->IsStringClass()) {
1928      os << StringPrintf("%p: java.lang.String %s\n", obj,
1929                         PrintableString(obj->AsString()->ToModifiedUtf8().c_str()).c_str());
1930    } else {
1931      os << StringPrintf("%p: %s\n", obj, PrettyDescriptor(obj_class).c_str());
1932    }
1933    ScopedIndentation indent1(&state->vios_);
1934    DumpFields(os, obj, obj_class);
1935    const auto image_pointer_size =
1936        InstructionSetPointerSize(state->oat_dumper_->GetOatInstructionSet());
1937    if (obj->IsObjectArray()) {
1938      auto* obj_array = obj->AsObjectArray<mirror::Object>();
1939      for (int32_t i = 0, length = obj_array->GetLength(); i < length; i++) {
1940        mirror::Object* value = obj_array->Get(i);
1941        size_t run = 0;
1942        for (int32_t j = i + 1; j < length; j++) {
1943          if (value == obj_array->Get(j)) {
1944            run++;
1945          } else {
1946            break;
1947          }
1948        }
1949        if (run == 0) {
1950          os << StringPrintf("%d: ", i);
1951        } else {
1952          os << StringPrintf("%d to %zd: ", i, i + run);
1953          i = i + run;
1954        }
1955        mirror::Class* value_class =
1956            (value == nullptr) ? obj_class->GetComponentType() : value->GetClass();
1957        PrettyObjectValue(os, value_class, value);
1958      }
1959    } else if (obj->IsClass()) {
1960      mirror::Class* klass = obj->AsClass();
1961      if (klass->NumStaticFields() != 0) {
1962        os << "STATICS:\n";
1963        ScopedIndentation indent2(&state->vios_);
1964        for (ArtField& field : klass->GetSFields()) {
1965          PrintField(os, &field, field.GetDeclaringClass());
1966        }
1967      }
1968    } else {
1969      auto it = state->dex_caches_.find(obj);
1970      if (it != state->dex_caches_.end()) {
1971        auto* dex_cache = down_cast<mirror::DexCache*>(obj);
1972        const auto& field_section = state->image_header_.GetImageSection(
1973            ImageHeader::kSectionArtFields);
1974        const auto& method_section = state->image_header_.GetMethodsSection();
1975        size_t num_methods = dex_cache->NumResolvedMethods();
1976        if (num_methods != 0u) {
1977          os << "Methods (size=" << num_methods << "):";
1978          ScopedIndentation indent2(&state->vios_);
1979          auto* resolved_methods = dex_cache->GetResolvedMethods();
1980          for (size_t i = 0, length = dex_cache->NumResolvedMethods(); i < length; ++i) {
1981            auto* elem = mirror::DexCache::GetElementPtrSize(resolved_methods, i, image_pointer_size);
1982            size_t run = 0;
1983            for (size_t j = i + 1;
1984                j != length && elem == mirror::DexCache::GetElementPtrSize(resolved_methods,
1985                                                                           j,
1986                                                                           image_pointer_size);
1987                ++j, ++run) {}
1988            if (run == 0) {
1989              os << StringPrintf("%zd: ", i);
1990            } else {
1991              os << StringPrintf("%zd to %zd: ", i, i + run);
1992              i = i + run;
1993            }
1994            std::string msg;
1995            if (elem == nullptr) {
1996              msg = "null";
1997            } else if (method_section.Contains(
1998                reinterpret_cast<uint8_t*>(elem) - state->image_space_.Begin())) {
1999              msg = PrettyMethod(reinterpret_cast<ArtMethod*>(elem));
2000            } else {
2001              msg = "<not in method section>";
2002            }
2003            os << StringPrintf("%p   %s\n", elem, msg.c_str());
2004          }
2005        }
2006        size_t num_fields = dex_cache->NumResolvedFields();
2007        if (num_fields != 0u) {
2008          os << "Fields (size=" << num_fields << "):";
2009          ScopedIndentation indent2(&state->vios_);
2010          auto* resolved_fields = dex_cache->GetResolvedFields();
2011          for (size_t i = 0, length = dex_cache->NumResolvedFields(); i < length; ++i) {
2012            auto* elem = mirror::DexCache::GetElementPtrSize(resolved_fields, i, image_pointer_size);
2013            size_t run = 0;
2014            for (size_t j = i + 1;
2015                j != length && elem == mirror::DexCache::GetElementPtrSize(resolved_fields,
2016                                                                           j,
2017                                                                           image_pointer_size);
2018                ++j, ++run) {}
2019            if (run == 0) {
2020              os << StringPrintf("%zd: ", i);
2021            } else {
2022              os << StringPrintf("%zd to %zd: ", i, i + run);
2023              i = i + run;
2024            }
2025            std::string msg;
2026            if (elem == nullptr) {
2027              msg = "null";
2028            } else if (field_section.Contains(
2029                reinterpret_cast<uint8_t*>(elem) - state->image_space_.Begin())) {
2030              msg = PrettyField(reinterpret_cast<ArtField*>(elem));
2031            } else {
2032              msg = "<not in field section>";
2033            }
2034            os << StringPrintf("%p   %s\n", elem, msg.c_str());
2035          }
2036        }
2037      }
2038    }
2039    std::string temp;
2040    state->stats_.Update(obj_class->GetDescriptor(&temp), object_bytes);
2041  }
2042
2043  void DumpMethod(ArtMethod* method, ImageDumper* state, std::ostream& indent_os)
2044      SHARED_REQUIRES(Locks::mutator_lock_) {
2045    DCHECK(method != nullptr);
2046    const auto image_pointer_size =
2047        InstructionSetPointerSize(state->oat_dumper_->GetOatInstructionSet());
2048    const void* quick_oat_code_begin = state->GetQuickOatCodeBegin(method);
2049    const void* quick_oat_code_end = state->GetQuickOatCodeEnd(method);
2050    OatQuickMethodHeader* method_header = reinterpret_cast<OatQuickMethodHeader*>(
2051        reinterpret_cast<uintptr_t>(quick_oat_code_begin) - sizeof(OatQuickMethodHeader));
2052    if (method->IsNative()) {
2053      if (!Runtime::Current()->GetClassLinker()->IsQuickGenericJniStub(quick_oat_code_begin)) {
2054        DCHECK(method_header->GetNativeGcMap() == nullptr) << PrettyMethod(method);
2055        DCHECK(method_header->GetMappingTable() == nullptr) << PrettyMethod(method);
2056      }
2057      bool first_occurrence;
2058      uint32_t quick_oat_code_size = state->GetQuickOatCodeSize(method);
2059      state->ComputeOatSize(quick_oat_code_begin, &first_occurrence);
2060      if (first_occurrence) {
2061        state->stats_.native_to_managed_code_bytes += quick_oat_code_size;
2062      }
2063      if (quick_oat_code_begin !=
2064            method->GetEntryPointFromQuickCompiledCodePtrSize(image_pointer_size)) {
2065        indent_os << StringPrintf("OAT CODE: %p\n", quick_oat_code_begin);
2066      }
2067    } else if (method->IsAbstract() || method->IsCalleeSaveMethod() ||
2068      method->IsResolutionMethod() || method->IsImtConflictMethod() ||
2069      method->IsImtUnimplementedMethod() || method->IsClassInitializer()) {
2070    } else {
2071      const DexFile::CodeItem* code_item = method->GetCodeItem();
2072      size_t dex_instruction_bytes = code_item->insns_size_in_code_units_ * 2;
2073      state->stats_.dex_instruction_bytes += dex_instruction_bytes;
2074
2075      bool first_occurrence;
2076      size_t gc_map_bytes = state->ComputeOatSize(
2077          method_header->GetNativeGcMap(), &first_occurrence);
2078      if (first_occurrence) {
2079        state->stats_.gc_map_bytes += gc_map_bytes;
2080      }
2081
2082      size_t pc_mapping_table_bytes = state->ComputeOatSize(
2083          method_header->GetMappingTable(), &first_occurrence);
2084      if (first_occurrence) {
2085        state->stats_.pc_mapping_table_bytes += pc_mapping_table_bytes;
2086      }
2087
2088      size_t vmap_table_bytes = 0u;
2089      if (!method_header->IsOptimized()) {
2090        // Method compiled with the optimizing compiler have no vmap table.
2091        vmap_table_bytes = state->ComputeOatSize(
2092            method_header->GetVmapTable(), &first_occurrence);
2093        if (first_occurrence) {
2094          state->stats_.vmap_table_bytes += vmap_table_bytes;
2095        }
2096      }
2097
2098      uint32_t quick_oat_code_size = state->GetQuickOatCodeSize(method);
2099      state->ComputeOatSize(quick_oat_code_begin, &first_occurrence);
2100      if (first_occurrence) {
2101        state->stats_.managed_code_bytes += quick_oat_code_size;
2102        if (method->IsConstructor()) {
2103          if (method->IsStatic()) {
2104            state->stats_.class_initializer_code_bytes += quick_oat_code_size;
2105          } else if (dex_instruction_bytes > kLargeConstructorDexBytes) {
2106            state->stats_.large_initializer_code_bytes += quick_oat_code_size;
2107          }
2108        } else if (dex_instruction_bytes > kLargeMethodDexBytes) {
2109          state->stats_.large_method_code_bytes += quick_oat_code_size;
2110        }
2111      }
2112      state->stats_.managed_code_bytes_ignoring_deduplication += quick_oat_code_size;
2113
2114      uint32_t method_access_flags = method->GetAccessFlags();
2115
2116      indent_os << StringPrintf("OAT CODE: %p-%p\n", quick_oat_code_begin, quick_oat_code_end);
2117      indent_os << StringPrintf("SIZE: Dex Instructions=%zd GC=%zd Mapping=%zd AccessFlags=0x%x\n",
2118                                dex_instruction_bytes, gc_map_bytes, pc_mapping_table_bytes,
2119                                method_access_flags);
2120
2121      size_t total_size = dex_instruction_bytes + gc_map_bytes + pc_mapping_table_bytes +
2122          vmap_table_bytes + quick_oat_code_size + ArtMethod::Size(image_pointer_size);
2123
2124      double expansion =
2125      static_cast<double>(quick_oat_code_size) / static_cast<double>(dex_instruction_bytes);
2126      state->stats_.ComputeOutliers(total_size, expansion, method);
2127    }
2128  }
2129
2130  std::set<const void*> already_seen_;
2131  // Compute the size of the given data within the oat file and whether this is the first time
2132  // this data has been requested
2133  size_t ComputeOatSize(const void* oat_data, bool* first_occurrence) {
2134    if (already_seen_.count(oat_data) == 0) {
2135      *first_occurrence = true;
2136      already_seen_.insert(oat_data);
2137    } else {
2138      *first_occurrence = false;
2139    }
2140    return oat_dumper_->ComputeSize(oat_data);
2141  }
2142
2143 public:
2144  struct Stats {
2145    size_t oat_file_bytes;
2146    size_t file_bytes;
2147
2148    size_t header_bytes;
2149    size_t object_bytes;
2150    size_t art_field_bytes;
2151    size_t art_method_bytes;
2152    size_t dex_cache_arrays_bytes;
2153    size_t interned_strings_bytes;
2154    size_t class_table_bytes;
2155    size_t bitmap_bytes;
2156    size_t alignment_bytes;
2157
2158    size_t managed_code_bytes;
2159    size_t managed_code_bytes_ignoring_deduplication;
2160    size_t managed_to_native_code_bytes;
2161    size_t native_to_managed_code_bytes;
2162    size_t class_initializer_code_bytes;
2163    size_t large_initializer_code_bytes;
2164    size_t large_method_code_bytes;
2165
2166    size_t gc_map_bytes;
2167    size_t pc_mapping_table_bytes;
2168    size_t vmap_table_bytes;
2169
2170    size_t dex_instruction_bytes;
2171
2172    std::vector<ArtMethod*> method_outlier;
2173    std::vector<size_t> method_outlier_size;
2174    std::vector<double> method_outlier_expansion;
2175    std::vector<std::pair<std::string, size_t>> oat_dex_file_sizes;
2176
2177    Stats()
2178        : oat_file_bytes(0),
2179          file_bytes(0),
2180          header_bytes(0),
2181          object_bytes(0),
2182          art_field_bytes(0),
2183          art_method_bytes(0),
2184          dex_cache_arrays_bytes(0),
2185          interned_strings_bytes(0),
2186          class_table_bytes(0),
2187          bitmap_bytes(0),
2188          alignment_bytes(0),
2189          managed_code_bytes(0),
2190          managed_code_bytes_ignoring_deduplication(0),
2191          managed_to_native_code_bytes(0),
2192          native_to_managed_code_bytes(0),
2193          class_initializer_code_bytes(0),
2194          large_initializer_code_bytes(0),
2195          large_method_code_bytes(0),
2196          gc_map_bytes(0),
2197          pc_mapping_table_bytes(0),
2198          vmap_table_bytes(0),
2199          dex_instruction_bytes(0) {}
2200
2201    struct SizeAndCount {
2202      SizeAndCount(size_t bytes_in, size_t count_in) : bytes(bytes_in), count(count_in) {}
2203      size_t bytes;
2204      size_t count;
2205    };
2206    typedef SafeMap<std::string, SizeAndCount> SizeAndCountTable;
2207    SizeAndCountTable sizes_and_counts;
2208
2209    void Update(const char* descriptor, size_t object_bytes_in) {
2210      SizeAndCountTable::iterator it = sizes_and_counts.find(descriptor);
2211      if (it != sizes_and_counts.end()) {
2212        it->second.bytes += object_bytes_in;
2213        it->second.count += 1;
2214      } else {
2215        sizes_and_counts.Put(descriptor, SizeAndCount(object_bytes_in, 1));
2216      }
2217    }
2218
2219    double PercentOfOatBytes(size_t size) {
2220      return (static_cast<double>(size) / static_cast<double>(oat_file_bytes)) * 100;
2221    }
2222
2223    double PercentOfFileBytes(size_t size) {
2224      return (static_cast<double>(size) / static_cast<double>(file_bytes)) * 100;
2225    }
2226
2227    double PercentOfObjectBytes(size_t size) {
2228      return (static_cast<double>(size) / static_cast<double>(object_bytes)) * 100;
2229    }
2230
2231    void ComputeOutliers(size_t total_size, double expansion, ArtMethod* method) {
2232      method_outlier_size.push_back(total_size);
2233      method_outlier_expansion.push_back(expansion);
2234      method_outlier.push_back(method);
2235    }
2236
2237    void DumpOutliers(std::ostream& os)
2238        SHARED_REQUIRES(Locks::mutator_lock_) {
2239      size_t sum_of_sizes = 0;
2240      size_t sum_of_sizes_squared = 0;
2241      size_t sum_of_expansion = 0;
2242      size_t sum_of_expansion_squared = 0;
2243      size_t n = method_outlier_size.size();
2244      if (n == 0) {
2245        return;
2246      }
2247      for (size_t i = 0; i < n; i++) {
2248        size_t cur_size = method_outlier_size[i];
2249        sum_of_sizes += cur_size;
2250        sum_of_sizes_squared += cur_size * cur_size;
2251        double cur_expansion = method_outlier_expansion[i];
2252        sum_of_expansion += cur_expansion;
2253        sum_of_expansion_squared += cur_expansion * cur_expansion;
2254      }
2255      size_t size_mean = sum_of_sizes / n;
2256      size_t size_variance = (sum_of_sizes_squared - sum_of_sizes * size_mean) / (n - 1);
2257      double expansion_mean = sum_of_expansion / n;
2258      double expansion_variance =
2259          (sum_of_expansion_squared - sum_of_expansion * expansion_mean) / (n - 1);
2260
2261      // Dump methods whose size is a certain number of standard deviations from the mean
2262      size_t dumped_values = 0;
2263      size_t skipped_values = 0;
2264      for (size_t i = 100; i > 0; i--) {  // i is the current number of standard deviations
2265        size_t cur_size_variance = i * i * size_variance;
2266        bool first = true;
2267        for (size_t j = 0; j < n; j++) {
2268          size_t cur_size = method_outlier_size[j];
2269          if (cur_size > size_mean) {
2270            size_t cur_var = cur_size - size_mean;
2271            cur_var = cur_var * cur_var;
2272            if (cur_var > cur_size_variance) {
2273              if (dumped_values > 20) {
2274                if (i == 1) {
2275                  skipped_values++;
2276                } else {
2277                  i = 2;  // jump to counting for 1 standard deviation
2278                  break;
2279                }
2280              } else {
2281                if (first) {
2282                  os << "\nBig methods (size > " << i << " standard deviations the norm):\n";
2283                  first = false;
2284                }
2285                os << PrettyMethod(method_outlier[j]) << " requires storage of "
2286                    << PrettySize(cur_size) << "\n";
2287                method_outlier_size[j] = 0;  // don't consider this method again
2288                dumped_values++;
2289              }
2290            }
2291          }
2292        }
2293      }
2294      if (skipped_values > 0) {
2295        os << "... skipped " << skipped_values
2296           << " methods with size > 1 standard deviation from the norm\n";
2297      }
2298      os << std::flush;
2299
2300      // Dump methods whose expansion is a certain number of standard deviations from the mean
2301      dumped_values = 0;
2302      skipped_values = 0;
2303      for (size_t i = 10; i > 0; i--) {  // i is the current number of standard deviations
2304        double cur_expansion_variance = i * i * expansion_variance;
2305        bool first = true;
2306        for (size_t j = 0; j < n; j++) {
2307          double cur_expansion = method_outlier_expansion[j];
2308          if (cur_expansion > expansion_mean) {
2309            size_t cur_var = cur_expansion - expansion_mean;
2310            cur_var = cur_var * cur_var;
2311            if (cur_var > cur_expansion_variance) {
2312              if (dumped_values > 20) {
2313                if (i == 1) {
2314                  skipped_values++;
2315                } else {
2316                  i = 2;  // jump to counting for 1 standard deviation
2317                  break;
2318                }
2319              } else {
2320                if (first) {
2321                  os << "\nLarge expansion methods (size > " << i
2322                      << " standard deviations the norm):\n";
2323                  first = false;
2324                }
2325                os << PrettyMethod(method_outlier[j]) << " expanded code by "
2326                   << cur_expansion << "\n";
2327                method_outlier_expansion[j] = 0.0;  // don't consider this method again
2328                dumped_values++;
2329              }
2330            }
2331          }
2332        }
2333      }
2334      if (skipped_values > 0) {
2335        os << "... skipped " << skipped_values
2336           << " methods with expansion > 1 standard deviation from the norm\n";
2337      }
2338      os << "\n" << std::flush;
2339    }
2340
2341    void Dump(std::ostream& os, std::ostream& indent_os)
2342        SHARED_REQUIRES(Locks::mutator_lock_) {
2343      {
2344        os << "art_file_bytes = " << PrettySize(file_bytes) << "\n\n"
2345           << "art_file_bytes = header_bytes + object_bytes + alignment_bytes\n";
2346        indent_os << StringPrintf("header_bytes           =  %8zd (%2.0f%% of art file bytes)\n"
2347                                  "object_bytes           =  %8zd (%2.0f%% of art file bytes)\n"
2348                                  "art_field_bytes        =  %8zd (%2.0f%% of art file bytes)\n"
2349                                  "art_method_bytes       =  %8zd (%2.0f%% of art file bytes)\n"
2350                                  "dex_cache_arrays_bytes =  %8zd (%2.0f%% of art file bytes)\n"
2351                                  "interned_string_bytes  =  %8zd (%2.0f%% of art file bytes)\n"
2352                                  "class_table_bytes      =  %8zd (%2.0f%% of art file bytes)\n"
2353                                  "bitmap_bytes           =  %8zd (%2.0f%% of art file bytes)\n"
2354                                  "alignment_bytes        =  %8zd (%2.0f%% of art file bytes)\n\n",
2355                                  header_bytes, PercentOfFileBytes(header_bytes),
2356                                  object_bytes, PercentOfFileBytes(object_bytes),
2357                                  art_field_bytes, PercentOfFileBytes(art_field_bytes),
2358                                  art_method_bytes, PercentOfFileBytes(art_method_bytes),
2359                                  dex_cache_arrays_bytes,
2360                                  PercentOfFileBytes(dex_cache_arrays_bytes),
2361                                  interned_strings_bytes,
2362                                  PercentOfFileBytes(interned_strings_bytes),
2363                                  class_table_bytes, PercentOfFileBytes(class_table_bytes),
2364                                  bitmap_bytes, PercentOfFileBytes(bitmap_bytes),
2365                                  alignment_bytes, PercentOfFileBytes(alignment_bytes))
2366            << std::flush;
2367        CHECK_EQ(file_bytes,
2368                 header_bytes + object_bytes + art_field_bytes + art_method_bytes +
2369                 dex_cache_arrays_bytes + interned_strings_bytes + class_table_bytes +
2370                 bitmap_bytes + alignment_bytes);
2371      }
2372
2373      os << "object_bytes breakdown:\n";
2374      size_t object_bytes_total = 0;
2375      for (const auto& sizes_and_count : sizes_and_counts) {
2376        const std::string& descriptor(sizes_and_count.first);
2377        double average = static_cast<double>(sizes_and_count.second.bytes) /
2378            static_cast<double>(sizes_and_count.second.count);
2379        double percent = PercentOfObjectBytes(sizes_and_count.second.bytes);
2380        os << StringPrintf("%32s %8zd bytes %6zd instances "
2381                           "(%4.0f bytes/instance) %2.0f%% of object_bytes\n",
2382                           descriptor.c_str(), sizes_and_count.second.bytes,
2383                           sizes_and_count.second.count, average, percent);
2384        object_bytes_total += sizes_and_count.second.bytes;
2385      }
2386      os << "\n" << std::flush;
2387      CHECK_EQ(object_bytes, object_bytes_total);
2388
2389      os << StringPrintf("oat_file_bytes               = %8zd\n"
2390                         "managed_code_bytes           = %8zd (%2.0f%% of oat file bytes)\n"
2391                         "managed_to_native_code_bytes = %8zd (%2.0f%% of oat file bytes)\n"
2392                         "native_to_managed_code_bytes = %8zd (%2.0f%% of oat file bytes)\n\n"
2393                         "class_initializer_code_bytes = %8zd (%2.0f%% of oat file bytes)\n"
2394                         "large_initializer_code_bytes = %8zd (%2.0f%% of oat file bytes)\n"
2395                         "large_method_code_bytes      = %8zd (%2.0f%% of oat file bytes)\n\n",
2396                         oat_file_bytes,
2397                         managed_code_bytes,
2398                         PercentOfOatBytes(managed_code_bytes),
2399                         managed_to_native_code_bytes,
2400                         PercentOfOatBytes(managed_to_native_code_bytes),
2401                         native_to_managed_code_bytes,
2402                         PercentOfOatBytes(native_to_managed_code_bytes),
2403                         class_initializer_code_bytes,
2404                         PercentOfOatBytes(class_initializer_code_bytes),
2405                         large_initializer_code_bytes,
2406                         PercentOfOatBytes(large_initializer_code_bytes),
2407                         large_method_code_bytes,
2408                         PercentOfOatBytes(large_method_code_bytes))
2409            << "DexFile sizes:\n";
2410      for (const std::pair<std::string, size_t>& oat_dex_file_size : oat_dex_file_sizes) {
2411        os << StringPrintf("%s = %zd (%2.0f%% of oat file bytes)\n",
2412                           oat_dex_file_size.first.c_str(), oat_dex_file_size.second,
2413                           PercentOfOatBytes(oat_dex_file_size.second));
2414      }
2415
2416      os << "\n" << StringPrintf("gc_map_bytes           = %7zd (%2.0f%% of oat file bytes)\n"
2417                                 "pc_mapping_table_bytes = %7zd (%2.0f%% of oat file bytes)\n"
2418                                 "vmap_table_bytes       = %7zd (%2.0f%% of oat file bytes)\n\n",
2419                                 gc_map_bytes, PercentOfOatBytes(gc_map_bytes),
2420                                 pc_mapping_table_bytes, PercentOfOatBytes(pc_mapping_table_bytes),
2421                                 vmap_table_bytes, PercentOfOatBytes(vmap_table_bytes))
2422         << std::flush;
2423
2424      os << StringPrintf("dex_instruction_bytes = %zd\n", dex_instruction_bytes)
2425         << StringPrintf("managed_code_bytes expansion = %.2f (ignoring deduplication %.2f)\n\n",
2426                         static_cast<double>(managed_code_bytes) /
2427                             static_cast<double>(dex_instruction_bytes),
2428                         static_cast<double>(managed_code_bytes_ignoring_deduplication) /
2429                             static_cast<double>(dex_instruction_bytes))
2430         << std::flush;
2431
2432      DumpOutliers(os);
2433    }
2434  } stats_;
2435
2436 private:
2437  enum {
2438    // Number of bytes for a constructor to be considered large. Based on the 1000 basic block
2439    // threshold, we assume 2 bytes per instruction and 2 instructions per block.
2440    kLargeConstructorDexBytes = 4000,
2441    // Number of bytes for a method to be considered large. Based on the 4000 basic block
2442    // threshold, we assume 2 bytes per instruction and 2 instructions per block.
2443    kLargeMethodDexBytes = 16000
2444  };
2445
2446  // For performance, use the *os_ directly for anything that doesn't need indentation
2447  // and prepare an indentation stream with default indentation 1.
2448  std::ostream* os_;
2449  VariableIndentationOutputStream vios_;
2450  ScopedIndentation indent1_;
2451
2452  gc::space::ImageSpace& image_space_;
2453  const ImageHeader& image_header_;
2454  std::unique_ptr<OatDumper> oat_dumper_;
2455  OatDumperOptions* oat_dumper_options_;
2456  std::set<mirror::Object*> dex_caches_;
2457
2458  DISALLOW_COPY_AND_ASSIGN(ImageDumper);
2459};
2460
2461static int DumpImage(Runtime* runtime, OatDumperOptions* options, std::ostream* os) {
2462  // Dumping the image, no explicit class loader.
2463  ScopedNullHandle<mirror::ClassLoader> null_class_loader;
2464  options->class_loader_ = &null_class_loader;
2465
2466  ScopedObjectAccess soa(Thread::Current());
2467  gc::Heap* heap = runtime->GetHeap();
2468  std::vector<gc::space::ImageSpace*> image_spaces = heap->GetBootImageSpaces();
2469  CHECK(!image_spaces.empty());
2470  for (gc::space::ImageSpace* image_space : image_spaces) {
2471    const ImageHeader& image_header = image_space->GetImageHeader();
2472    if (!image_header.IsValid()) {
2473      fprintf(stderr, "Invalid image header %s\n", image_space->GetImageLocation().c_str());
2474      return EXIT_FAILURE;
2475    }
2476
2477    ImageDumper image_dumper(os, *image_space, image_header, options);
2478    if (!image_dumper.Dump()) {
2479      return EXIT_FAILURE;
2480    }
2481  }
2482  return EXIT_SUCCESS;
2483}
2484
2485static int DumpOatWithRuntime(Runtime* runtime, OatFile* oat_file, OatDumperOptions* options,
2486                              std::ostream* os) {
2487  CHECK(runtime != nullptr && oat_file != nullptr && options != nullptr);
2488
2489  Thread* self = Thread::Current();
2490  CHECK(self != nullptr);
2491  // Need well-known-classes.
2492  WellKnownClasses::Init(self->GetJniEnv());
2493
2494  // Need to register dex files to get a working dex cache.
2495  ScopedObjectAccess soa(self);
2496  ClassLinker* class_linker = runtime->GetClassLinker();
2497  runtime->GetOatFileManager().RegisterOatFile(std::unique_ptr<const OatFile>(oat_file));
2498  std::vector<const DexFile*> class_path;
2499  for (const OatFile::OatDexFile* odf : oat_file->GetOatDexFiles()) {
2500    std::string error_msg;
2501    const DexFile* const dex_file = OpenDexFile(odf, &error_msg);
2502    CHECK(dex_file != nullptr) << error_msg;
2503    class_linker->RegisterDexFile(*dex_file, runtime->GetLinearAlloc());
2504    class_path.push_back(dex_file);
2505  }
2506
2507  // Need a class loader.
2508  // Fake that we're a compiler.
2509  jobject class_loader = class_linker->CreatePathClassLoader(self, class_path);
2510
2511  // Use the class loader while dumping.
2512  StackHandleScope<1> scope(self);
2513  Handle<mirror::ClassLoader> loader_handle = scope.NewHandle(
2514      soa.Decode<mirror::ClassLoader*>(class_loader));
2515  options->class_loader_ = &loader_handle;
2516
2517  OatDumper oat_dumper(*oat_file, *options);
2518  bool success = oat_dumper.Dump(*os);
2519  return (success) ? EXIT_SUCCESS : EXIT_FAILURE;
2520}
2521
2522static int DumpOatWithoutRuntime(OatFile* oat_file, OatDumperOptions* options, std::ostream* os) {
2523  CHECK(oat_file != nullptr && options != nullptr);
2524  // No image = no class loader.
2525  ScopedNullHandle<mirror::ClassLoader> null_class_loader;
2526  options->class_loader_ = &null_class_loader;
2527
2528  OatDumper oat_dumper(*oat_file, *options);
2529  bool success = oat_dumper.Dump(*os);
2530  return (success) ? EXIT_SUCCESS : EXIT_FAILURE;
2531}
2532
2533static int DumpOat(Runtime* runtime, const char* oat_filename, OatDumperOptions* options,
2534                   std::ostream* os) {
2535  std::string error_msg;
2536  OatFile* oat_file = OatFile::Open(oat_filename, oat_filename, nullptr, nullptr, false,
2537                                    nullptr, &error_msg);
2538  if (oat_file == nullptr) {
2539    fprintf(stderr, "Failed to open oat file from '%s': %s\n", oat_filename, error_msg.c_str());
2540    return EXIT_FAILURE;
2541  }
2542
2543  if (runtime != nullptr) {
2544    return DumpOatWithRuntime(runtime, oat_file, options, os);
2545  } else {
2546    return DumpOatWithoutRuntime(oat_file, options, os);
2547  }
2548}
2549
2550static int SymbolizeOat(const char* oat_filename, std::string& output_name) {
2551  std::string error_msg;
2552  OatFile* oat_file = OatFile::Open(oat_filename, oat_filename, nullptr, nullptr, false,
2553                                    nullptr, &error_msg);
2554  if (oat_file == nullptr) {
2555    fprintf(stderr, "Failed to open oat file from '%s': %s\n", oat_filename, error_msg.c_str());
2556    return EXIT_FAILURE;
2557  }
2558
2559  bool result;
2560  // Try to produce an ELF file of the same type. This is finicky, as we have used 32-bit ELF
2561  // files for 64-bit code in the past.
2562  if (Is64BitInstructionSet(oat_file->GetOatHeader().GetInstructionSet())) {
2563    OatSymbolizer<ElfTypes64> oat_symbolizer(oat_file, output_name);
2564    result = oat_symbolizer.Symbolize();
2565  } else {
2566    OatSymbolizer<ElfTypes32> oat_symbolizer(oat_file, output_name);
2567    result = oat_symbolizer.Symbolize();
2568  }
2569  if (!result) {
2570    fprintf(stderr, "Failed to symbolize\n");
2571    return EXIT_FAILURE;
2572  }
2573
2574  return EXIT_SUCCESS;
2575}
2576
2577struct OatdumpArgs : public CmdlineArgs {
2578 protected:
2579  using Base = CmdlineArgs;
2580
2581  virtual ParseStatus ParseCustom(const StringPiece& option,
2582                                  std::string* error_msg) OVERRIDE {
2583    {
2584      ParseStatus base_parse = Base::ParseCustom(option, error_msg);
2585      if (base_parse != kParseUnknownArgument) {
2586        return base_parse;
2587      }
2588    }
2589
2590    if (option.starts_with("--oat-file=")) {
2591      oat_filename_ = option.substr(strlen("--oat-file=")).data();
2592    } else if (option.starts_with("--image=")) {
2593      image_location_ = option.substr(strlen("--image=")).data();
2594    } else if (option =="--dump:raw_mapping_table") {
2595      dump_raw_mapping_table_ = true;
2596    } else if (option == "--dump:raw_gc_map") {
2597      dump_raw_gc_map_ = true;
2598    } else if (option == "--no-dump:vmap") {
2599      dump_vmap_ = false;
2600    } else if (option =="--dump:code_info_stack_maps") {
2601      dump_code_info_stack_maps_ = true;
2602    } else if (option == "--no-disassemble") {
2603      disassemble_code_ = false;
2604    } else if (option =="--header-only") {
2605      dump_header_only_ = true;
2606    } else if (option.starts_with("--symbolize=")) {
2607      oat_filename_ = option.substr(strlen("--symbolize=")).data();
2608      symbolize_ = true;
2609    } else if (option.starts_with("--class-filter=")) {
2610      class_filter_ = option.substr(strlen("--class-filter=")).data();
2611    } else if (option.starts_with("--method-filter=")) {
2612      method_filter_ = option.substr(strlen("--method-filter=")).data();
2613    } else if (option.starts_with("--list-classes")) {
2614      list_classes_ = true;
2615    } else if (option.starts_with("--list-methods")) {
2616      list_methods_ = true;
2617    } else if (option.starts_with("--export-dex-to=")) {
2618      export_dex_location_ = option.substr(strlen("--export-dex-to=")).data();
2619    } else if (option.starts_with("--addr2instr=")) {
2620      if (!ParseUint(option.substr(strlen("--addr2instr=")).data(), &addr2instr_)) {
2621        *error_msg = "Address conversion failed";
2622        return kParseError;
2623      }
2624    } else {
2625      return kParseUnknownArgument;
2626    }
2627
2628    return kParseOk;
2629  }
2630
2631  virtual ParseStatus ParseChecks(std::string* error_msg) OVERRIDE {
2632    // Infer boot image location from the image location if possible.
2633    if (boot_image_location_ == nullptr) {
2634      boot_image_location_ = image_location_;
2635    }
2636
2637    // Perform the parent checks.
2638    ParseStatus parent_checks = Base::ParseChecks(error_msg);
2639    if (parent_checks != kParseOk) {
2640      return parent_checks;
2641    }
2642
2643    // Perform our own checks.
2644    if (image_location_ == nullptr && oat_filename_ == nullptr) {
2645      *error_msg = "Either --image or --oat-file must be specified";
2646      return kParseError;
2647    } else if (image_location_ != nullptr && oat_filename_ != nullptr) {
2648      *error_msg = "Either --image or --oat-file must be specified but not both";
2649      return kParseError;
2650    }
2651
2652    return kParseOk;
2653  }
2654
2655  virtual std::string GetUsage() const {
2656    std::string usage;
2657
2658    usage +=
2659        "Usage: oatdump [options] ...\n"
2660        "    Example: oatdump --image=$ANDROID_PRODUCT_OUT/system/framework/boot.art\n"
2661        "    Example: adb shell oatdump --image=/system/framework/boot.art\n"
2662        "\n"
2663        // Either oat-file or image is required.
2664        "  --oat-file=<file.oat>: specifies an input oat filename.\n"
2665        "      Example: --oat-file=/system/framework/boot.oat\n"
2666        "\n"
2667        "  --image=<file.art>: specifies an input image location.\n"
2668        "      Example: --image=/system/framework/boot.art\n"
2669        "\n";
2670
2671    usage += Base::GetUsage();
2672
2673    usage +=  // Optional.
2674        "  --dump:raw_mapping_table enables dumping of the mapping table.\n"
2675        "      Example: --dump:raw_mapping_table\n"
2676        "\n"
2677        "  --dump:raw_gc_map enables dumping of the GC map.\n"
2678        "      Example: --dump:raw_gc_map\n"
2679        "\n"
2680        "  --no-dump:vmap may be used to disable vmap dumping.\n"
2681        "      Example: --no-dump:vmap\n"
2682        "\n"
2683        "  --dump:code_info_stack_maps enables dumping of stack maps in CodeInfo sections.\n"
2684        "      Example: --dump:code_info_stack_maps\n"
2685        "\n"
2686        "  --no-disassemble may be used to disable disassembly.\n"
2687        "      Example: --no-disassemble\n"
2688        "\n"
2689        "  --header-only may be used to print only the oat header.\n"
2690        "      Example: --header-only\n"
2691        "\n"
2692        "  --list-classes may be used to list target file classes (can be used with filters).\n"
2693        "      Example: --list-classes\n"
2694        "      Example: --list-classes --class-filter=com.example.foo\n"
2695        "\n"
2696        "  --list-methods may be used to list target file methods (can be used with filters).\n"
2697        "      Example: --list-methods\n"
2698        "      Example: --list-methods --class-filter=com.example --method-filter=foo\n"
2699        "\n"
2700        "  --symbolize=<file.oat>: output a copy of file.oat with elf symbols included.\n"
2701        "      Example: --symbolize=/system/framework/boot.oat\n"
2702        "\n"
2703        "  --class-filter=<class name>: only dumps classes that contain the filter.\n"
2704        "      Example: --class-filter=com.example.foo\n"
2705        "\n"
2706        "  --method-filter=<method name>: only dumps methods that contain the filter.\n"
2707        "      Example: --method-filter=foo\n"
2708        "\n"
2709        "  --export-dex-to=<directory>: may be used to export oat embedded dex files.\n"
2710        "      Example: --export-dex-to=/data/local/tmp\n"
2711        "\n"
2712        "  --addr2instr=<address>: output matching method disassembled code from relative\n"
2713        "                          address (e.g. PC from crash dump)\n"
2714        "      Example: --addr2instr=0x00001a3b\n"
2715        "\n";
2716
2717    return usage;
2718  }
2719
2720 public:
2721  const char* oat_filename_ = nullptr;
2722  const char* class_filter_ = "";
2723  const char* method_filter_ = "";
2724  const char* image_location_ = nullptr;
2725  std::string elf_filename_prefix_;
2726  bool dump_raw_mapping_table_ = false;
2727  bool dump_raw_gc_map_ = false;
2728  bool dump_vmap_ = true;
2729  bool dump_code_info_stack_maps_ = false;
2730  bool disassemble_code_ = true;
2731  bool symbolize_ = false;
2732  bool list_classes_ = false;
2733  bool list_methods_ = false;
2734  bool dump_header_only_ = false;
2735  uint32_t addr2instr_ = 0;
2736  const char* export_dex_location_ = nullptr;
2737};
2738
2739struct OatdumpMain : public CmdlineMain<OatdumpArgs> {
2740  virtual bool NeedsRuntime() OVERRIDE {
2741    CHECK(args_ != nullptr);
2742
2743    // If we are only doing the oat file, disable absolute_addresses. Keep them for image dumping.
2744    bool absolute_addresses = (args_->oat_filename_ == nullptr);
2745
2746    oat_dumper_options_ = std::unique_ptr<OatDumperOptions>(new OatDumperOptions(
2747        args_->dump_raw_mapping_table_,
2748        args_->dump_raw_gc_map_,
2749        args_->dump_vmap_,
2750        args_->dump_code_info_stack_maps_,
2751        args_->disassemble_code_,
2752        absolute_addresses,
2753        args_->class_filter_,
2754        args_->method_filter_,
2755        args_->list_classes_,
2756        args_->list_methods_,
2757        args_->dump_header_only_,
2758        args_->export_dex_location_,
2759        args_->addr2instr_));
2760
2761    return (args_->boot_image_location_ != nullptr || args_->image_location_ != nullptr) &&
2762          !args_->symbolize_;
2763  }
2764
2765  virtual bool ExecuteWithoutRuntime() OVERRIDE {
2766    CHECK(args_ != nullptr);
2767    CHECK(args_->oat_filename_ != nullptr);
2768
2769    MemMap::Init();
2770
2771    if (args_->symbolize_) {
2772      return SymbolizeOat(args_->oat_filename_, args_->output_name_) == EXIT_SUCCESS;
2773    } else {
2774      return DumpOat(nullptr,
2775                     args_->oat_filename_,
2776                     oat_dumper_options_.get(),
2777                     args_->os_) == EXIT_SUCCESS;
2778    }
2779  }
2780
2781  virtual bool ExecuteWithRuntime(Runtime* runtime) {
2782    CHECK(args_ != nullptr);
2783
2784    if (args_->oat_filename_ != nullptr) {
2785      return DumpOat(runtime,
2786                     args_->oat_filename_,
2787                     oat_dumper_options_.get(),
2788                     args_->os_) == EXIT_SUCCESS;
2789    }
2790
2791    return DumpImage(runtime, oat_dumper_options_.get(), args_->os_) == EXIT_SUCCESS;
2792  }
2793
2794  std::unique_ptr<OatDumperOptions> oat_dumper_options_;
2795};
2796
2797}  // namespace art
2798
2799int main(int argc, char** argv) {
2800  art::OatdumpMain main;
2801  return main.Main(argc, argv);
2802}
2803