Home | History | Annotate | Download | only in hprof
      1 /*
      2  * Copyright (C) 2008 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 /*
     18  * Preparation and completion of hprof data generation.  The output is
     19  * written into two files and then combined.  This is necessary because
     20  * we generate some of the data (strings and classes) while we dump the
     21  * heap, and some analysis tools require that the class and string data
     22  * appear first.
     23  */
     24 
     25 #include "hprof.h"
     26 
     27 #include <errno.h>
     28 #include <fcntl.h>
     29 #include <stdio.h>
     30 #include <string.h>
     31 #include <sys/time.h>
     32 #include <sys/uio.h>
     33 #include <time.h>
     34 #include <unistd.h>
     35 
     36 #include <set>
     37 
     38 #include <android-base/logging.h>
     39 #include <android-base/stringprintf.h>
     40 
     41 #include "art_field-inl.h"
     42 #include "art_method-inl.h"
     43 #include "base/array_ref.h"
     44 #include "base/file_utils.h"
     45 #include "base/macros.h"
     46 #include "base/mutex.h"
     47 #include "base/os.h"
     48 #include "base/safe_map.h"
     49 #include "base/time_utils.h"
     50 #include "base/unix_file/fd_file.h"
     51 #include "class_linker.h"
     52 #include "class_root.h"
     53 #include "common_throws.h"
     54 #include "debugger.h"
     55 #include "dex/dex_file-inl.h"
     56 #include "gc/accounting/heap_bitmap.h"
     57 #include "gc/allocation_record.h"
     58 #include "gc/heap-visit-objects-inl.h"
     59 #include "gc/heap.h"
     60 #include "gc/scoped_gc_critical_section.h"
     61 #include "gc/space/space.h"
     62 #include "gc_root.h"
     63 #include "jdwp/jdwp.h"
     64 #include "jdwp/jdwp_priv.h"
     65 #include "mirror/class-inl.h"
     66 #include "mirror/class.h"
     67 #include "mirror/object-refvisitor-inl.h"
     68 #include "runtime_globals.h"
     69 #include "scoped_thread_state_change-inl.h"
     70 #include "thread_list.h"
     71 
     72 namespace art {
     73 
     74 namespace hprof {
     75 
     76 static constexpr bool kDirectStream = true;
     77 
     78 static constexpr uint32_t kHprofTime = 0;
     79 static constexpr uint32_t kHprofNullThread = 0;
     80 
     81 static constexpr size_t kMaxObjectsPerSegment = 128;
     82 static constexpr size_t kMaxBytesPerSegment = 4096;
     83 
     84 // The static field-name for the synthetic object generated to account for class static overhead.
     85 static constexpr const char* kClassOverheadName = "$classOverhead";
     86 
     87 enum HprofTag {
     88   HPROF_TAG_STRING = 0x01,
     89   HPROF_TAG_LOAD_CLASS = 0x02,
     90   HPROF_TAG_UNLOAD_CLASS = 0x03,
     91   HPROF_TAG_STACK_FRAME = 0x04,
     92   HPROF_TAG_STACK_TRACE = 0x05,
     93   HPROF_TAG_ALLOC_SITES = 0x06,
     94   HPROF_TAG_HEAP_SUMMARY = 0x07,
     95   HPROF_TAG_START_THREAD = 0x0A,
     96   HPROF_TAG_END_THREAD = 0x0B,
     97   HPROF_TAG_HEAP_DUMP = 0x0C,
     98   HPROF_TAG_HEAP_DUMP_SEGMENT = 0x1C,
     99   HPROF_TAG_HEAP_DUMP_END = 0x2C,
    100   HPROF_TAG_CPU_SAMPLES = 0x0D,
    101   HPROF_TAG_CONTROL_SETTINGS = 0x0E,
    102 };
    103 
    104 // Values for the first byte of HEAP_DUMP and HEAP_DUMP_SEGMENT records:
    105 enum HprofHeapTag {
    106   // Traditional.
    107   HPROF_ROOT_UNKNOWN = 0xFF,
    108   HPROF_ROOT_JNI_GLOBAL = 0x01,
    109   HPROF_ROOT_JNI_LOCAL = 0x02,
    110   HPROF_ROOT_JAVA_FRAME = 0x03,
    111   HPROF_ROOT_NATIVE_STACK = 0x04,
    112   HPROF_ROOT_STICKY_CLASS = 0x05,
    113   HPROF_ROOT_THREAD_BLOCK = 0x06,
    114   HPROF_ROOT_MONITOR_USED = 0x07,
    115   HPROF_ROOT_THREAD_OBJECT = 0x08,
    116   HPROF_CLASS_DUMP = 0x20,
    117   HPROF_INSTANCE_DUMP = 0x21,
    118   HPROF_OBJECT_ARRAY_DUMP = 0x22,
    119   HPROF_PRIMITIVE_ARRAY_DUMP = 0x23,
    120 
    121   // Android.
    122   HPROF_HEAP_DUMP_INFO = 0xfe,
    123   HPROF_ROOT_INTERNED_STRING = 0x89,
    124   HPROF_ROOT_FINALIZING = 0x8a,  // Obsolete.
    125   HPROF_ROOT_DEBUGGER = 0x8b,
    126   HPROF_ROOT_REFERENCE_CLEANUP = 0x8c,  // Obsolete.
    127   HPROF_ROOT_VM_INTERNAL = 0x8d,
    128   HPROF_ROOT_JNI_MONITOR = 0x8e,
    129   HPROF_UNREACHABLE = 0x90,  // Obsolete.
    130   HPROF_PRIMITIVE_ARRAY_NODATA_DUMP = 0xc3,  // Obsolete.
    131 };
    132 
    133 enum HprofHeapId {
    134   HPROF_HEAP_DEFAULT = 0,
    135   HPROF_HEAP_ZYGOTE = 'Z',
    136   HPROF_HEAP_APP = 'A',
    137   HPROF_HEAP_IMAGE = 'I',
    138 };
    139 
    140 enum HprofBasicType {
    141   hprof_basic_object = 2,
    142   hprof_basic_boolean = 4,
    143   hprof_basic_char = 5,
    144   hprof_basic_float = 6,
    145   hprof_basic_double = 7,
    146   hprof_basic_byte = 8,
    147   hprof_basic_short = 9,
    148   hprof_basic_int = 10,
    149   hprof_basic_long = 11,
    150 };
    151 
    152 using HprofStringId = uint32_t;
    153 using HprofClassObjectId = uint32_t;
    154 using HprofClassSerialNumber = uint32_t;
    155 using HprofStackTraceSerialNumber = uint32_t;
    156 using HprofStackFrameId = uint32_t;
    157 static constexpr HprofStackTraceSerialNumber kHprofNullStackTrace = 0;
    158 
    159 class EndianOutput {
    160  public:
    161   EndianOutput() : length_(0), sum_length_(0), max_length_(0), started_(false) {}
    162   virtual ~EndianOutput() {}
    163 
    164   void StartNewRecord(uint8_t tag, uint32_t time) {
    165     if (length_ > 0) {
    166       EndRecord();
    167     }
    168     DCHECK_EQ(length_, 0U);
    169     AddU1(tag);
    170     AddU4(time);
    171     AddU4(0xdeaddead);  // Length, replaced on flush.
    172     started_ = true;
    173   }
    174 
    175   void EndRecord() {
    176     // Replace length in header.
    177     if (started_) {
    178       UpdateU4(sizeof(uint8_t) + sizeof(uint32_t),
    179                length_ - sizeof(uint8_t) - 2 * sizeof(uint32_t));
    180     }
    181 
    182     HandleEndRecord();
    183 
    184     sum_length_ += length_;
    185     max_length_ = std::max(max_length_, length_);
    186     length_ = 0;
    187     started_ = false;
    188   }
    189 
    190   void AddU1(uint8_t value) {
    191     AddU1List(&value, 1);
    192   }
    193   void AddU2(uint16_t value) {
    194     AddU2List(&value, 1);
    195   }
    196   void AddU4(uint32_t value) {
    197     AddU4List(&value, 1);
    198   }
    199 
    200   void AddU8(uint64_t value) {
    201     AddU8List(&value, 1);
    202   }
    203 
    204   void AddObjectId(const mirror::Object* value) {
    205     AddU4(PointerToLowMemUInt32(value));
    206   }
    207 
    208   void AddStackTraceSerialNumber(HprofStackTraceSerialNumber value) {
    209     AddU4(value);
    210   }
    211 
    212   // The ID for the synthetic object generated to account for class static overhead.
    213   void AddClassStaticsId(const mirror::Class* value) {
    214     AddU4(1 | PointerToLowMemUInt32(value));
    215   }
    216 
    217   void AddJniGlobalRefId(jobject value) {
    218     AddU4(PointerToLowMemUInt32(value));
    219   }
    220 
    221   void AddClassId(HprofClassObjectId value) {
    222     AddU4(value);
    223   }
    224 
    225   void AddStringId(HprofStringId value) {
    226     AddU4(value);
    227   }
    228 
    229   void AddU1List(const uint8_t* values, size_t count) {
    230     HandleU1List(values, count);
    231     length_ += count;
    232   }
    233   void AddU2List(const uint16_t* values, size_t count) {
    234     HandleU2List(values, count);
    235     length_ += count * sizeof(uint16_t);
    236   }
    237   void AddU4List(const uint32_t* values, size_t count) {
    238     HandleU4List(values, count);
    239     length_ += count * sizeof(uint32_t);
    240   }
    241   virtual void UpdateU4(size_t offset, uint32_t new_value ATTRIBUTE_UNUSED) {
    242     DCHECK_LE(offset, length_ - 4);
    243   }
    244   void AddU8List(const uint64_t* values, size_t count) {
    245     HandleU8List(values, count);
    246     length_ += count * sizeof(uint64_t);
    247   }
    248 
    249   void AddIdList(mirror::ObjectArray<mirror::Object>* values)
    250       REQUIRES_SHARED(Locks::mutator_lock_) {
    251     const int32_t length = values->GetLength();
    252     for (int32_t i = 0; i < length; ++i) {
    253       AddObjectId(values->GetWithoutChecks(i).Ptr());
    254     }
    255   }
    256 
    257   void AddUtf8String(const char* str) {
    258     // The terminating NUL character is NOT written.
    259     AddU1List((const uint8_t*)str, strlen(str));
    260   }
    261 
    262   size_t Length() const {
    263     return length_;
    264   }
    265 
    266   size_t SumLength() const {
    267     return sum_length_;
    268   }
    269 
    270   size_t MaxLength() const {
    271     return max_length_;
    272   }
    273 
    274  protected:
    275   virtual void HandleU1List(const uint8_t* values ATTRIBUTE_UNUSED,
    276                             size_t count ATTRIBUTE_UNUSED) {
    277   }
    278   virtual void HandleU1AsU2List(const uint8_t* values ATTRIBUTE_UNUSED,
    279                                 size_t count ATTRIBUTE_UNUSED) {
    280   }
    281   virtual void HandleU2List(const uint16_t* values ATTRIBUTE_UNUSED,
    282                             size_t count ATTRIBUTE_UNUSED) {
    283   }
    284   virtual void HandleU4List(const uint32_t* values ATTRIBUTE_UNUSED,
    285                             size_t count ATTRIBUTE_UNUSED) {
    286   }
    287   virtual void HandleU8List(const uint64_t* values ATTRIBUTE_UNUSED,
    288                             size_t count ATTRIBUTE_UNUSED) {
    289   }
    290   virtual void HandleEndRecord() {
    291   }
    292 
    293   size_t length_;      // Current record size.
    294   size_t sum_length_;  // Size of all data.
    295   size_t max_length_;  // Maximum seen length.
    296   bool started_;       // Was StartRecord called?
    297 };
    298 
    299 // This keeps things buffered until flushed.
    300 class EndianOutputBuffered : public EndianOutput {
    301  public:
    302   explicit EndianOutputBuffered(size_t reserve_size) {
    303     buffer_.reserve(reserve_size);
    304   }
    305   virtual ~EndianOutputBuffered() {}
    306 
    307   void UpdateU4(size_t offset, uint32_t new_value) override {
    308     DCHECK_LE(offset, length_ - 4);
    309     buffer_[offset + 0] = static_cast<uint8_t>((new_value >> 24) & 0xFF);
    310     buffer_[offset + 1] = static_cast<uint8_t>((new_value >> 16) & 0xFF);
    311     buffer_[offset + 2] = static_cast<uint8_t>((new_value >> 8)  & 0xFF);
    312     buffer_[offset + 3] = static_cast<uint8_t>((new_value >> 0)  & 0xFF);
    313   }
    314 
    315  protected:
    316   void HandleU1List(const uint8_t* values, size_t count) override {
    317     DCHECK_EQ(length_, buffer_.size());
    318     buffer_.insert(buffer_.end(), values, values + count);
    319   }
    320 
    321   void HandleU1AsU2List(const uint8_t* values, size_t count) override {
    322     DCHECK_EQ(length_, buffer_.size());
    323     // All 8-bits are grouped in 2 to make 16-bit block like Java Char
    324     if (count & 1) {
    325       buffer_.push_back(0);
    326     }
    327     for (size_t i = 0; i < count; ++i) {
    328       uint8_t value = *values;
    329       buffer_.push_back(value);
    330       values++;
    331     }
    332   }
    333 
    334   void HandleU2List(const uint16_t* values, size_t count) override {
    335     DCHECK_EQ(length_, buffer_.size());
    336     for (size_t i = 0; i < count; ++i) {
    337       uint16_t value = *values;
    338       buffer_.push_back(static_cast<uint8_t>((value >> 8) & 0xFF));
    339       buffer_.push_back(static_cast<uint8_t>((value >> 0) & 0xFF));
    340       values++;
    341     }
    342   }
    343 
    344   void HandleU4List(const uint32_t* values, size_t count) override {
    345     DCHECK_EQ(length_, buffer_.size());
    346     for (size_t i = 0; i < count; ++i) {
    347       uint32_t value = *values;
    348       buffer_.push_back(static_cast<uint8_t>((value >> 24) & 0xFF));
    349       buffer_.push_back(static_cast<uint8_t>((value >> 16) & 0xFF));
    350       buffer_.push_back(static_cast<uint8_t>((value >> 8)  & 0xFF));
    351       buffer_.push_back(static_cast<uint8_t>((value >> 0)  & 0xFF));
    352       values++;
    353     }
    354   }
    355 
    356   void HandleU8List(const uint64_t* values, size_t count) override {
    357     DCHECK_EQ(length_, buffer_.size());
    358     for (size_t i = 0; i < count; ++i) {
    359       uint64_t value = *values;
    360       buffer_.push_back(static_cast<uint8_t>((value >> 56) & 0xFF));
    361       buffer_.push_back(static_cast<uint8_t>((value >> 48) & 0xFF));
    362       buffer_.push_back(static_cast<uint8_t>((value >> 40) & 0xFF));
    363       buffer_.push_back(static_cast<uint8_t>((value >> 32) & 0xFF));
    364       buffer_.push_back(static_cast<uint8_t>((value >> 24) & 0xFF));
    365       buffer_.push_back(static_cast<uint8_t>((value >> 16) & 0xFF));
    366       buffer_.push_back(static_cast<uint8_t>((value >> 8)  & 0xFF));
    367       buffer_.push_back(static_cast<uint8_t>((value >> 0)  & 0xFF));
    368       values++;
    369     }
    370   }
    371 
    372   void HandleEndRecord() override {
    373     DCHECK_EQ(buffer_.size(), length_);
    374     if (kIsDebugBuild && started_) {
    375       uint32_t stored_length =
    376           static_cast<uint32_t>(buffer_[5]) << 24 |
    377           static_cast<uint32_t>(buffer_[6]) << 16 |
    378           static_cast<uint32_t>(buffer_[7]) << 8 |
    379           static_cast<uint32_t>(buffer_[8]);
    380       DCHECK_EQ(stored_length, length_ - sizeof(uint8_t) - 2 * sizeof(uint32_t));
    381     }
    382     HandleFlush(buffer_.data(), length_);
    383     buffer_.clear();
    384   }
    385 
    386   virtual void HandleFlush(const uint8_t* buffer ATTRIBUTE_UNUSED, size_t length ATTRIBUTE_UNUSED) {
    387   }
    388 
    389   std::vector<uint8_t> buffer_;
    390 };
    391 
    392 class FileEndianOutput final : public EndianOutputBuffered {
    393  public:
    394   FileEndianOutput(File* fp, size_t reserved_size)
    395       : EndianOutputBuffered(reserved_size), fp_(fp), errors_(false) {
    396     DCHECK(fp != nullptr);
    397   }
    398   ~FileEndianOutput() {
    399   }
    400 
    401   bool Errors() {
    402     return errors_;
    403   }
    404 
    405  protected:
    406   void HandleFlush(const uint8_t* buffer, size_t length) override {
    407     if (!errors_) {
    408       errors_ = !fp_->WriteFully(buffer, length);
    409     }
    410   }
    411 
    412  private:
    413   File* fp_;
    414   bool errors_;
    415 };
    416 
    417 class VectorEndianOuputput final : public EndianOutputBuffered {
    418  public:
    419   VectorEndianOuputput(std::vector<uint8_t>& data, size_t reserved_size)
    420       : EndianOutputBuffered(reserved_size), full_data_(data) {}
    421   ~VectorEndianOuputput() {}
    422 
    423  protected:
    424   void HandleFlush(const uint8_t* buf, size_t length) override {
    425     size_t old_size = full_data_.size();
    426     full_data_.resize(old_size + length);
    427     memcpy(full_data_.data() + old_size, buf, length);
    428   }
    429 
    430  private:
    431   std::vector<uint8_t>& full_data_;
    432 };
    433 
    434 #define __ output_->
    435 
    436 class Hprof : public SingleRootVisitor {
    437  public:
    438   Hprof(const char* output_filename, int fd, bool direct_to_ddms)
    439       : filename_(output_filename),
    440         fd_(fd),
    441         direct_to_ddms_(direct_to_ddms) {
    442     LOG(INFO) << "hprof: heap dump \"" << filename_ << "\" starting...";
    443   }
    444 
    445   void Dump()
    446     REQUIRES(Locks::mutator_lock_)
    447     REQUIRES(!Locks::heap_bitmap_lock_, !Locks::alloc_tracker_lock_) {
    448     {
    449       MutexLock mu(Thread::Current(), *Locks::alloc_tracker_lock_);
    450       if (Runtime::Current()->GetHeap()->IsAllocTrackingEnabled()) {
    451         PopulateAllocationTrackingTraces();
    452       }
    453     }
    454 
    455     // First pass to measure the size of the dump.
    456     size_t overall_size;
    457     size_t max_length;
    458     {
    459       EndianOutput count_output;
    460       output_ = &count_output;
    461       ProcessHeap(false);
    462       overall_size = count_output.SumLength();
    463       max_length = count_output.MaxLength();
    464       output_ = nullptr;
    465     }
    466 
    467     bool okay;
    468     visited_objects_.clear();
    469     if (direct_to_ddms_) {
    470       if (kDirectStream) {
    471         okay = DumpToDdmsDirect(overall_size, max_length, CHUNK_TYPE("HPDS"));
    472       } else {
    473         okay = DumpToDdmsBuffered(overall_size, max_length);
    474       }
    475     } else {
    476       okay = DumpToFile(overall_size, max_length);
    477     }
    478 
    479     if (okay) {
    480       const uint64_t duration = NanoTime() - start_ns_;
    481       LOG(INFO) << "hprof: heap dump completed (" << PrettySize(RoundUp(overall_size, KB))
    482                 << ") in " << PrettyDuration(duration)
    483                 << " objects " << total_objects_
    484                 << " objects with stack traces " << total_objects_with_stack_trace_;
    485     }
    486   }
    487 
    488  private:
    489   void DumpHeapObject(mirror::Object* obj)
    490       REQUIRES_SHARED(Locks::mutator_lock_);
    491 
    492   void DumpHeapClass(mirror::Class* klass)
    493       REQUIRES_SHARED(Locks::mutator_lock_);
    494 
    495   void DumpHeapArray(mirror::Array* obj, mirror::Class* klass)
    496       REQUIRES_SHARED(Locks::mutator_lock_);
    497 
    498   void DumpFakeObjectArray(mirror::Object* obj, const std::set<mirror::Object*>& elements)
    499       REQUIRES_SHARED(Locks::mutator_lock_);
    500 
    501   void DumpHeapInstanceObject(mirror::Object* obj,
    502                               mirror::Class* klass,
    503                               const std::set<mirror::Object*>& fake_roots)
    504       REQUIRES_SHARED(Locks::mutator_lock_);
    505 
    506   bool AddRuntimeInternalObjectsField(mirror::Class* klass) REQUIRES_SHARED(Locks::mutator_lock_);
    507 
    508   void ProcessHeap(bool header_first)
    509       REQUIRES(Locks::mutator_lock_) {
    510     // Reset current heap and object count.
    511     current_heap_ = HPROF_HEAP_DEFAULT;
    512     objects_in_segment_ = 0;
    513 
    514     if (header_first) {
    515       ProcessHeader(true);
    516       ProcessBody();
    517     } else {
    518       ProcessBody();
    519       ProcessHeader(false);
    520     }
    521   }
    522 
    523   void ProcessBody() REQUIRES(Locks::mutator_lock_) {
    524     Runtime* const runtime = Runtime::Current();
    525     // Walk the roots and the heap.
    526     output_->StartNewRecord(HPROF_TAG_HEAP_DUMP_SEGMENT, kHprofTime);
    527 
    528     simple_roots_.clear();
    529     runtime->VisitRoots(this);
    530     runtime->VisitImageRoots(this);
    531     auto dump_object = [this](mirror::Object* obj) REQUIRES_SHARED(Locks::mutator_lock_) {
    532       DCHECK(obj != nullptr);
    533       DumpHeapObject(obj);
    534     };
    535     runtime->GetHeap()->VisitObjectsPaused(dump_object);
    536     output_->StartNewRecord(HPROF_TAG_HEAP_DUMP_END, kHprofTime);
    537     output_->EndRecord();
    538   }
    539 
    540   void ProcessHeader(bool string_first) REQUIRES(Locks::mutator_lock_) {
    541     // Write the header.
    542     WriteFixedHeader();
    543     // Write the string and class tables, and any stack traces, to the header.
    544     // (jhat requires that these appear before any of the data in the body that refers to them.)
    545     // jhat also requires the string table appear before class table and stack traces.
    546     // However, WriteStackTraces() can modify the string table, so it's necessary to call
    547     // WriteStringTable() last in the first pass, to compute the correct length of the output.
    548     if (string_first) {
    549       WriteStringTable();
    550     }
    551     WriteClassTable();
    552     WriteStackTraces();
    553     if (!string_first) {
    554       WriteStringTable();
    555     }
    556     output_->EndRecord();
    557   }
    558 
    559   void WriteClassTable() REQUIRES_SHARED(Locks::mutator_lock_) {
    560     for (const auto& p : classes_) {
    561       mirror::Class* c = p.first;
    562       HprofClassSerialNumber sn = p.second;
    563       CHECK(c != nullptr);
    564       output_->StartNewRecord(HPROF_TAG_LOAD_CLASS, kHprofTime);
    565       // LOAD CLASS format:
    566       // U4: class serial number (always > 0)
    567       // ID: class object ID. We use the address of the class object structure as its ID.
    568       // U4: stack trace serial number
    569       // ID: class name string ID
    570       __ AddU4(sn);
    571       __ AddObjectId(c);
    572       __ AddStackTraceSerialNumber(LookupStackTraceSerialNumber(c));
    573       __ AddStringId(LookupClassNameId(c));
    574     }
    575   }
    576 
    577   void WriteStringTable() {
    578     for (const auto& p : strings_) {
    579       const std::string& string = p.first;
    580       const HprofStringId id = p.second;
    581 
    582       output_->StartNewRecord(HPROF_TAG_STRING, kHprofTime);
    583 
    584       // STRING format:
    585       // ID:  ID for this string
    586       // U1*: UTF8 characters for string (NOT null terminated)
    587       //      (the record format encodes the length)
    588       __ AddU4(id);
    589       __ AddUtf8String(string.c_str());
    590     }
    591   }
    592 
    593   void StartNewHeapDumpSegment() {
    594     // This flushes the old segment and starts a new one.
    595     output_->StartNewRecord(HPROF_TAG_HEAP_DUMP_SEGMENT, kHprofTime);
    596     objects_in_segment_ = 0;
    597     // Starting a new HEAP_DUMP resets the heap to default.
    598     current_heap_ = HPROF_HEAP_DEFAULT;
    599   }
    600 
    601   void CheckHeapSegmentConstraints() {
    602     if (objects_in_segment_ >= kMaxObjectsPerSegment || output_->Length() >= kMaxBytesPerSegment) {
    603       StartNewHeapDumpSegment();
    604     }
    605   }
    606 
    607   void VisitRoot(mirror::Object* obj, const RootInfo& root_info)
    608       override REQUIRES_SHARED(Locks::mutator_lock_);
    609   void MarkRootObject(const mirror::Object* obj, jobject jni_obj, HprofHeapTag heap_tag,
    610                       uint32_t thread_serial);
    611 
    612   HprofClassObjectId LookupClassId(mirror::Class* c) REQUIRES_SHARED(Locks::mutator_lock_) {
    613     if (c != nullptr) {
    614       auto it = classes_.find(c);
    615       if (it == classes_.end()) {
    616         // first time to see this class
    617         HprofClassSerialNumber sn = next_class_serial_number_++;
    618         classes_.Put(c, sn);
    619         // Make sure that we've assigned a string ID for this class' name
    620         LookupClassNameId(c);
    621       }
    622     }
    623     return PointerToLowMemUInt32(c);
    624   }
    625 
    626   HprofStackTraceSerialNumber LookupStackTraceSerialNumber(const mirror::Object* obj)
    627       REQUIRES_SHARED(Locks::mutator_lock_) {
    628     auto r = allocation_records_.find(obj);
    629     if (r == allocation_records_.end()) {
    630       return kHprofNullStackTrace;
    631     } else {
    632       const gc::AllocRecordStackTrace* trace = r->second;
    633       auto result = traces_.find(trace);
    634       CHECK(result != traces_.end());
    635       return result->second;
    636     }
    637   }
    638 
    639   HprofStringId LookupStringId(mirror::String* string) REQUIRES_SHARED(Locks::mutator_lock_) {
    640     return LookupStringId(string->ToModifiedUtf8());
    641   }
    642 
    643   HprofStringId LookupStringId(const char* string) {
    644     return LookupStringId(std::string(string));
    645   }
    646 
    647   HprofStringId LookupStringId(const std::string& string) {
    648     auto it = strings_.find(string);
    649     if (it != strings_.end()) {
    650       return it->second;
    651     }
    652     HprofStringId id = next_string_id_++;
    653     strings_.Put(string, id);
    654     return id;
    655   }
    656 
    657   HprofStringId LookupClassNameId(mirror::Class* c) REQUIRES_SHARED(Locks::mutator_lock_) {
    658     return LookupStringId(c->PrettyDescriptor());
    659   }
    660 
    661   void WriteFixedHeader() {
    662     // Write the file header.
    663     // U1: NUL-terminated magic string.
    664     const char magic[] = "JAVA PROFILE 1.0.3";
    665     __ AddU1List(reinterpret_cast<const uint8_t*>(magic), sizeof(magic));
    666 
    667     // U4: size of identifiers.  We're using addresses as IDs and our heap references are stored
    668     // as uint32_t.
    669     // Note of warning: hprof-conv hard-codes the size of identifiers to 4.
    670     static_assert(sizeof(mirror::HeapReference<mirror::Object>) == sizeof(uint32_t),
    671                   "Unexpected HeapReference size");
    672     __ AddU4(sizeof(uint32_t));
    673 
    674     // The current time, in milliseconds since 0:00 GMT, 1/1/70.
    675     timeval now;
    676     const uint64_t nowMs = (gettimeofday(&now, nullptr) < 0) ? 0 :
    677         (uint64_t)now.tv_sec * 1000 + now.tv_usec / 1000;
    678     // TODO: It seems it would be correct to use U8.
    679     // U4: high word of the 64-bit time.
    680     __ AddU4(static_cast<uint32_t>(nowMs >> 32));
    681     // U4: low word of the 64-bit time.
    682     __ AddU4(static_cast<uint32_t>(nowMs & 0xFFFFFFFF));
    683   }
    684 
    685   void WriteStackTraces() REQUIRES_SHARED(Locks::mutator_lock_) {
    686     // Write a dummy stack trace record so the analysis tools don't freak out.
    687     output_->StartNewRecord(HPROF_TAG_STACK_TRACE, kHprofTime);
    688     __ AddStackTraceSerialNumber(kHprofNullStackTrace);
    689     __ AddU4(kHprofNullThread);
    690     __ AddU4(0);    // no frames
    691 
    692     // TODO: jhat complains "WARNING: Stack trace not found for serial # -1", but no trace should
    693     // have -1 as its serial number (as long as HprofStackTraceSerialNumber doesn't overflow).
    694     for (const auto& it : traces_) {
    695       const gc::AllocRecordStackTrace* trace = it.first;
    696       HprofStackTraceSerialNumber trace_sn = it.second;
    697       size_t depth = trace->GetDepth();
    698 
    699       // First write stack frames of the trace
    700       for (size_t i = 0; i < depth; ++i) {
    701         const gc::AllocRecordStackTraceElement* frame = &trace->GetStackElement(i);
    702         ArtMethod* method = frame->GetMethod();
    703         CHECK(method != nullptr);
    704         output_->StartNewRecord(HPROF_TAG_STACK_FRAME, kHprofTime);
    705         // STACK FRAME format:
    706         // ID: stack frame ID. We use the address of the AllocRecordStackTraceElement object as its ID.
    707         // ID: method name string ID
    708         // ID: method signature string ID
    709         // ID: source file name string ID
    710         // U4: class serial number
    711         // U4: >0, line number; 0, no line information available; -1, unknown location
    712         auto frame_result = frames_.find(frame);
    713         CHECK(frame_result != frames_.end());
    714         __ AddU4(frame_result->second);
    715         __ AddStringId(LookupStringId(method->GetName()));
    716         __ AddStringId(LookupStringId(method->GetSignature().ToString()));
    717         const char* source_file = method->GetDeclaringClassSourceFile();
    718         if (source_file == nullptr) {
    719           source_file = "";
    720         }
    721         __ AddStringId(LookupStringId(source_file));
    722         auto class_result = classes_.find(method->GetDeclaringClass().Ptr());
    723         CHECK(class_result != classes_.end());
    724         __ AddU4(class_result->second);
    725         __ AddU4(frame->ComputeLineNumber());
    726       }
    727 
    728       // Then write the trace itself
    729       output_->StartNewRecord(HPROF_TAG_STACK_TRACE, kHprofTime);
    730       // STACK TRACE format:
    731       // U4: stack trace serial number. We use the address of the AllocRecordStackTrace object as its serial number.
    732       // U4: thread serial number. We use Thread::GetTid().
    733       // U4: number of frames
    734       // [ID]*: series of stack frame ID's
    735       __ AddStackTraceSerialNumber(trace_sn);
    736       __ AddU4(trace->GetTid());
    737       __ AddU4(depth);
    738       for (size_t i = 0; i < depth; ++i) {
    739         const gc::AllocRecordStackTraceElement* frame = &trace->GetStackElement(i);
    740         auto frame_result = frames_.find(frame);
    741         CHECK(frame_result != frames_.end());
    742         __ AddU4(frame_result->second);
    743       }
    744     }
    745   }
    746 
    747   bool DumpToDdmsBuffered(size_t overall_size ATTRIBUTE_UNUSED, size_t max_length ATTRIBUTE_UNUSED)
    748       REQUIRES(Locks::mutator_lock_) {
    749     LOG(FATAL) << "Unimplemented";
    750     UNREACHABLE();
    751     //        // Send the data off to DDMS.
    752     //        iovec iov[2];
    753     //        iov[0].iov_base = header_data_ptr_;
    754     //        iov[0].iov_len = header_data_size_;
    755     //        iov[1].iov_base = body_data_ptr_;
    756     //        iov[1].iov_len = body_data_size_;
    757     //        Dbg::DdmSendChunkV(CHUNK_TYPE("HPDS"), iov, 2);
    758   }
    759 
    760   bool DumpToFile(size_t overall_size, size_t max_length)
    761       REQUIRES(Locks::mutator_lock_) {
    762     // Where exactly are we writing to?
    763     int out_fd;
    764     if (fd_ >= 0) {
    765       out_fd = DupCloexec(fd_);
    766       if (out_fd < 0) {
    767         ThrowRuntimeException("Couldn't dump heap; dup(%d) failed: %s", fd_, strerror(errno));
    768         return false;
    769       }
    770     } else {
    771       out_fd = open(filename_.c_str(), O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, 0644);
    772       if (out_fd < 0) {
    773         ThrowRuntimeException("Couldn't dump heap; open(\"%s\") failed: %s", filename_.c_str(),
    774                               strerror(errno));
    775         return false;
    776       }
    777     }
    778 
    779     std::unique_ptr<File> file(new File(out_fd, filename_, true));
    780     bool okay;
    781     {
    782       FileEndianOutput file_output(file.get(), max_length);
    783       output_ = &file_output;
    784       ProcessHeap(true);
    785       okay = !file_output.Errors();
    786 
    787       if (okay) {
    788         // Check for expected size. Output is expected to be less-or-equal than first phase, see
    789         // b/23521263.
    790         DCHECK_LE(file_output.SumLength(), overall_size);
    791       }
    792       output_ = nullptr;
    793     }
    794 
    795     if (okay) {
    796       okay = file->FlushCloseOrErase() == 0;
    797     } else {
    798       file->Erase();
    799     }
    800     if (!okay) {
    801       std::string msg(android::base::StringPrintf("Couldn't dump heap; writing \"%s\" failed: %s",
    802                                                   filename_.c_str(),
    803                                                   strerror(errno)));
    804       ThrowRuntimeException("%s", msg.c_str());
    805       LOG(ERROR) << msg;
    806     }
    807 
    808     return okay;
    809   }
    810 
    811   bool DumpToDdmsDirect(size_t overall_size, size_t max_length, uint32_t chunk_type)
    812       REQUIRES(Locks::mutator_lock_) {
    813     CHECK(direct_to_ddms_);
    814 
    815     std::vector<uint8_t> out_data;
    816 
    817     // TODO It would be really good to have some streaming thing again. b/73084059
    818     VectorEndianOuputput output(out_data, max_length);
    819     output_ = &output;
    820 
    821     // Write the dump.
    822     ProcessHeap(true);
    823 
    824     Runtime::Current()->GetRuntimeCallbacks()->DdmPublishChunk(
    825         chunk_type, ArrayRef<const uint8_t>(out_data.data(), out_data.size()));
    826 
    827     // Check for expected size. See DumpToFile for comment.
    828     DCHECK_LE(output.SumLength(), overall_size);
    829     output_ = nullptr;
    830 
    831     return true;
    832   }
    833 
    834   void PopulateAllocationTrackingTraces()
    835       REQUIRES(Locks::mutator_lock_, Locks::alloc_tracker_lock_) {
    836     gc::AllocRecordObjectMap* records = Runtime::Current()->GetHeap()->GetAllocationRecords();
    837     CHECK(records != nullptr);
    838     HprofStackTraceSerialNumber next_trace_sn = kHprofNullStackTrace + 1;
    839     HprofStackFrameId next_frame_id = 0;
    840     size_t count = 0;
    841 
    842     for (auto it = records->Begin(), end = records->End(); it != end; ++it) {
    843       const mirror::Object* obj = it->first.Read();
    844       if (obj == nullptr) {
    845         continue;
    846       }
    847       ++count;
    848       const gc::AllocRecordStackTrace* trace = it->second.GetStackTrace();
    849 
    850       // Copy the pair into a real hash map to speed up look up.
    851       auto records_result = allocation_records_.emplace(obj, trace);
    852       // The insertion should always succeed, i.e. no duplicate object pointers in "records"
    853       CHECK(records_result.second);
    854 
    855       // Generate serial numbers for traces, and IDs for frames.
    856       auto traces_result = traces_.find(trace);
    857       if (traces_result == traces_.end()) {
    858         traces_.emplace(trace, next_trace_sn++);
    859         // only check frames if the trace is newly discovered
    860         for (size_t i = 0, depth = trace->GetDepth(); i < depth; ++i) {
    861           const gc::AllocRecordStackTraceElement* frame = &trace->GetStackElement(i);
    862           auto frames_result = frames_.find(frame);
    863           if (frames_result == frames_.end()) {
    864             frames_.emplace(frame, next_frame_id++);
    865           }
    866         }
    867       }
    868     }
    869     CHECK_EQ(traces_.size(), next_trace_sn - kHprofNullStackTrace - 1);
    870     CHECK_EQ(frames_.size(), next_frame_id);
    871     total_objects_with_stack_trace_ = count;
    872   }
    873 
    874   // If direct_to_ddms_ is set, "filename_" and "fd" will be ignored.
    875   // Otherwise, "filename_" must be valid, though if "fd" >= 0 it will
    876   // only be used for debug messages.
    877   std::string filename_;
    878   int fd_;
    879   bool direct_to_ddms_;
    880 
    881   uint64_t start_ns_ = NanoTime();
    882 
    883   EndianOutput* output_ = nullptr;
    884 
    885   HprofHeapId current_heap_ = HPROF_HEAP_DEFAULT;  // Which heap we're currently dumping.
    886   size_t objects_in_segment_ = 0;
    887 
    888   size_t total_objects_ = 0u;
    889   size_t total_objects_with_stack_trace_ = 0u;
    890 
    891   HprofStringId next_string_id_ = 0x400000;
    892   SafeMap<std::string, HprofStringId> strings_;
    893   HprofClassSerialNumber next_class_serial_number_ = 1;
    894   SafeMap<mirror::Class*, HprofClassSerialNumber> classes_;
    895 
    896   std::unordered_map<const gc::AllocRecordStackTrace*, HprofStackTraceSerialNumber,
    897                      gc::HashAllocRecordTypesPtr<gc::AllocRecordStackTrace>,
    898                      gc::EqAllocRecordTypesPtr<gc::AllocRecordStackTrace>> traces_;
    899   std::unordered_map<const gc::AllocRecordStackTraceElement*, HprofStackFrameId,
    900                      gc::HashAllocRecordTypesPtr<gc::AllocRecordStackTraceElement>,
    901                      gc::EqAllocRecordTypesPtr<gc::AllocRecordStackTraceElement>> frames_;
    902   std::unordered_map<const mirror::Object*, const gc::AllocRecordStackTrace*> allocation_records_;
    903 
    904   // Set used to keep track of what simple root records we have already
    905   // emitted, to avoid emitting duplicate entries. The simple root records are
    906   // those that contain no other information than the root type and the object
    907   // id. A pair of root type and object id is packed into a uint64_t, with
    908   // the root type in the upper 32 bits and the object id in the lower 32
    909   // bits.
    910   std::unordered_set<uint64_t> simple_roots_;
    911 
    912   // To make sure we don't dump the same object multiple times. b/34967844
    913   std::unordered_set<mirror::Object*> visited_objects_;
    914 
    915   friend class GcRootVisitor;
    916   DISALLOW_COPY_AND_ASSIGN(Hprof);
    917 };
    918 
    919 static HprofBasicType SignatureToBasicTypeAndSize(const char* sig, size_t* size_out) {
    920   char c = sig[0];
    921   HprofBasicType ret;
    922   size_t size;
    923 
    924   switch (c) {
    925     case '[':
    926     case 'L':
    927       ret = hprof_basic_object;
    928       size = 4;
    929       break;
    930     case 'Z':
    931       ret = hprof_basic_boolean;
    932       size = 1;
    933       break;
    934     case 'C':
    935       ret = hprof_basic_char;
    936       size = 2;
    937       break;
    938     case 'F':
    939       ret = hprof_basic_float;
    940       size = 4;
    941       break;
    942     case 'D':
    943       ret = hprof_basic_double;
    944       size = 8;
    945       break;
    946     case 'B':
    947       ret = hprof_basic_byte;
    948       size = 1;
    949       break;
    950     case 'S':
    951       ret = hprof_basic_short;
    952       size = 2;
    953       break;
    954     case 'I':
    955       ret = hprof_basic_int;
    956       size = 4;
    957       break;
    958     case 'J':
    959       ret = hprof_basic_long;
    960       size = 8;
    961       break;
    962     default:
    963       LOG(FATAL) << "UNREACHABLE";
    964       UNREACHABLE();
    965   }
    966 
    967   if (size_out != nullptr) {
    968     *size_out = size;
    969   }
    970 
    971   return ret;
    972 }
    973 
    974 // Always called when marking objects, but only does
    975 // something when ctx->gc_scan_state_ is non-zero, which is usually
    976 // only true when marking the root set or unreachable
    977 // objects.  Used to add rootset references to obj.
    978 void Hprof::MarkRootObject(const mirror::Object* obj, jobject jni_obj, HprofHeapTag heap_tag,
    979                            uint32_t thread_serial) {
    980   if (heap_tag == 0) {
    981     return;
    982   }
    983 
    984   CheckHeapSegmentConstraints();
    985 
    986   switch (heap_tag) {
    987     // ID: object ID
    988     case HPROF_ROOT_UNKNOWN:
    989     case HPROF_ROOT_STICKY_CLASS:
    990     case HPROF_ROOT_MONITOR_USED:
    991     case HPROF_ROOT_INTERNED_STRING:
    992     case HPROF_ROOT_DEBUGGER:
    993     case HPROF_ROOT_VM_INTERNAL: {
    994       uint64_t key = (static_cast<uint64_t>(heap_tag) << 32) | PointerToLowMemUInt32(obj);
    995       if (simple_roots_.insert(key).second) {
    996         __ AddU1(heap_tag);
    997         __ AddObjectId(obj);
    998       }
    999       break;
   1000     }
   1001 
   1002       // ID: object ID
   1003       // ID: JNI global ref ID
   1004     case HPROF_ROOT_JNI_GLOBAL:
   1005       __ AddU1(heap_tag);
   1006       __ AddObjectId(obj);
   1007       __ AddJniGlobalRefId(jni_obj);
   1008       break;
   1009 
   1010       // ID: object ID
   1011       // U4: thread serial number
   1012       // U4: frame number in stack trace (-1 for empty)
   1013     case HPROF_ROOT_JNI_LOCAL:
   1014     case HPROF_ROOT_JNI_MONITOR:
   1015     case HPROF_ROOT_JAVA_FRAME:
   1016       __ AddU1(heap_tag);
   1017       __ AddObjectId(obj);
   1018       __ AddU4(thread_serial);
   1019       __ AddU4((uint32_t)-1);
   1020       break;
   1021 
   1022       // ID: object ID
   1023       // U4: thread serial number
   1024     case HPROF_ROOT_NATIVE_STACK:
   1025     case HPROF_ROOT_THREAD_BLOCK:
   1026       __ AddU1(heap_tag);
   1027       __ AddObjectId(obj);
   1028       __ AddU4(thread_serial);
   1029       break;
   1030 
   1031       // ID: thread object ID
   1032       // U4: thread serial number
   1033       // U4: stack trace serial number
   1034     case HPROF_ROOT_THREAD_OBJECT:
   1035       __ AddU1(heap_tag);
   1036       __ AddObjectId(obj);
   1037       __ AddU4(thread_serial);
   1038       __ AddU4((uint32_t)-1);    // xxx
   1039       break;
   1040 
   1041     case HPROF_CLASS_DUMP:
   1042     case HPROF_INSTANCE_DUMP:
   1043     case HPROF_OBJECT_ARRAY_DUMP:
   1044     case HPROF_PRIMITIVE_ARRAY_DUMP:
   1045     case HPROF_HEAP_DUMP_INFO:
   1046     case HPROF_PRIMITIVE_ARRAY_NODATA_DUMP:
   1047       // Ignored.
   1048       break;
   1049 
   1050     case HPROF_ROOT_FINALIZING:
   1051     case HPROF_ROOT_REFERENCE_CLEANUP:
   1052     case HPROF_UNREACHABLE:
   1053       LOG(FATAL) << "obsolete tag " << static_cast<int>(heap_tag);
   1054       UNREACHABLE();
   1055   }
   1056 
   1057   ++objects_in_segment_;
   1058 }
   1059 
   1060 bool Hprof::AddRuntimeInternalObjectsField(mirror::Class* klass) {
   1061   if (klass->IsDexCacheClass()) {
   1062     return true;
   1063   }
   1064   // IsClassLoaderClass is true for subclasses of classloader but we only want to add the fake
   1065   // field to the java.lang.ClassLoader class.
   1066   if (klass->IsClassLoaderClass() && klass->GetSuperClass()->IsObjectClass()) {
   1067     return true;
   1068   }
   1069   return false;
   1070 }
   1071 
   1072 void Hprof::DumpHeapObject(mirror::Object* obj) {
   1073   // Ignore classes that are retired.
   1074   if (obj->IsClass() && obj->AsClass()->IsRetired()) {
   1075     return;
   1076   }
   1077   DCHECK(visited_objects_.insert(obj).second)
   1078       << "Already visited " << obj << "(" << obj->PrettyTypeOf() << ")";
   1079 
   1080   ++total_objects_;
   1081 
   1082   class RootCollector {
   1083    public:
   1084     RootCollector() {}
   1085 
   1086     void operator()(mirror::Object*, MemberOffset, bool) const {}
   1087 
   1088     // Note that these don't have read barriers. Its OK however since the GC is guaranteed to not be
   1089     // running during the hprof dumping process.
   1090     void VisitRootIfNonNull(mirror::CompressedReference<mirror::Object>* root) const
   1091         REQUIRES_SHARED(Locks::mutator_lock_) {
   1092       if (!root->IsNull()) {
   1093         VisitRoot(root);
   1094       }
   1095     }
   1096 
   1097     void VisitRoot(mirror::CompressedReference<mirror::Object>* root) const
   1098         REQUIRES_SHARED(Locks::mutator_lock_) {
   1099       roots_.insert(root->AsMirrorPtr());
   1100     }
   1101 
   1102     const std::set<mirror::Object*>& GetRoots() const {
   1103       return roots_;
   1104     }
   1105 
   1106    private:
   1107     // These roots are actually live from the object. Avoid marking them as roots in hprof to make
   1108     // it easier to debug class unloading.
   1109     mutable std::set<mirror::Object*> roots_;
   1110   };
   1111 
   1112   RootCollector visitor;
   1113   // Collect all native roots.
   1114   if (!obj->IsClass()) {
   1115     obj->VisitReferences(visitor, VoidFunctor());
   1116   }
   1117 
   1118   gc::Heap* const heap = Runtime::Current()->GetHeap();
   1119   const gc::space::ContinuousSpace* const space = heap->FindContinuousSpaceFromObject(obj, true);
   1120   HprofHeapId heap_type = HPROF_HEAP_APP;
   1121   if (space != nullptr) {
   1122     if (space->IsZygoteSpace()) {
   1123       heap_type = HPROF_HEAP_ZYGOTE;
   1124       VisitRoot(obj, RootInfo(kRootVMInternal));
   1125     } else if (space->IsImageSpace() && heap->ObjectIsInBootImageSpace(obj)) {
   1126       // Only count objects in the boot image as HPROF_HEAP_IMAGE, this leaves app image objects as
   1127       // HPROF_HEAP_APP. b/35762934
   1128       heap_type = HPROF_HEAP_IMAGE;
   1129       VisitRoot(obj, RootInfo(kRootVMInternal));
   1130     }
   1131   } else {
   1132     const auto* los = heap->GetLargeObjectsSpace();
   1133     if (los->Contains(obj) && los->IsZygoteLargeObject(Thread::Current(), obj)) {
   1134       heap_type = HPROF_HEAP_ZYGOTE;
   1135       VisitRoot(obj, RootInfo(kRootVMInternal));
   1136     }
   1137   }
   1138   CheckHeapSegmentConstraints();
   1139 
   1140   if (heap_type != current_heap_) {
   1141     HprofStringId nameId;
   1142 
   1143     // This object is in a different heap than the current one.
   1144     // Emit a HEAP_DUMP_INFO tag to change heaps.
   1145     __ AddU1(HPROF_HEAP_DUMP_INFO);
   1146     __ AddU4(static_cast<uint32_t>(heap_type));   // uint32_t: heap type
   1147     switch (heap_type) {
   1148     case HPROF_HEAP_APP:
   1149       nameId = LookupStringId("app");
   1150       break;
   1151     case HPROF_HEAP_ZYGOTE:
   1152       nameId = LookupStringId("zygote");
   1153       break;
   1154     case HPROF_HEAP_IMAGE:
   1155       nameId = LookupStringId("image");
   1156       break;
   1157     default:
   1158       // Internal error
   1159       LOG(ERROR) << "Unexpected desiredHeap";
   1160       nameId = LookupStringId("<ILLEGAL>");
   1161       break;
   1162     }
   1163     __ AddStringId(nameId);
   1164     current_heap_ = heap_type;
   1165   }
   1166 
   1167   mirror::Class* c = obj->GetClass();
   1168   if (c == nullptr) {
   1169     // This object will bother HprofReader, because it has a null
   1170     // class, so just don't dump it. It could be
   1171     // gDvm.unlinkedJavaLangClass or it could be an object just
   1172     // allocated which hasn't been initialized yet.
   1173   } else {
   1174     if (obj->IsClass()) {
   1175       DumpHeapClass(obj->AsClass().Ptr());
   1176     } else if (c->IsArrayClass()) {
   1177       DumpHeapArray(obj->AsArray().Ptr(), c);
   1178     } else {
   1179       DumpHeapInstanceObject(obj, c, visitor.GetRoots());
   1180     }
   1181   }
   1182 
   1183   ++objects_in_segment_;
   1184 }
   1185 
   1186 void Hprof::DumpHeapClass(mirror::Class* klass) {
   1187   if (!klass->IsResolved()) {
   1188     // Class is allocated but not yet resolved: we cannot access its fields or super class.
   1189     return;
   1190   }
   1191 
   1192   // Note: We will emit instance fields of Class as synthetic static fields with a prefix of
   1193   //       "$class$" so the class fields are visible in hprof dumps. For tools to account for that
   1194   //       correctly, we'll emit an instance size of zero for java.lang.Class, and also emit the
   1195   //       instance fields of java.lang.Object.
   1196   //
   1197   //       For other overhead (currently only the embedded vtable), we will generate a synthetic
   1198   //       byte array (or field[s] in case the overhead size is of reference size or less).
   1199 
   1200   const size_t num_static_fields = klass->NumStaticFields();
   1201 
   1202   // Total class size:
   1203   //   * class instance fields (including Object instance fields)
   1204   //   * vtable
   1205   //   * class static fields
   1206   const size_t total_class_size = klass->GetClassSize();
   1207 
   1208   // Base class size (common parts of all Class instances):
   1209   //   * class instance fields (including Object instance fields)
   1210   constexpr size_t base_class_size = sizeof(mirror::Class);
   1211   CHECK_LE(base_class_size, total_class_size);
   1212 
   1213   // Difference of Total and Base:
   1214   //   * vtable
   1215   //   * class static fields
   1216   const size_t base_overhead_size = total_class_size - base_class_size;
   1217 
   1218   // Tools (ahat/Studio) will count the static fields and account for them in the class size. We
   1219   // must thus subtract them from base_overhead_size or they will be double-counted.
   1220   size_t class_static_fields_size = 0;
   1221   for (ArtField& class_static_field : klass->GetSFields()) {
   1222     size_t size = 0;
   1223     SignatureToBasicTypeAndSize(class_static_field.GetTypeDescriptor(), &size);
   1224     class_static_fields_size += size;
   1225   }
   1226 
   1227   CHECK_GE(base_overhead_size, class_static_fields_size);
   1228   // Now we have:
   1229   //   * vtable
   1230   const size_t base_no_statics_overhead_size = base_overhead_size - class_static_fields_size;
   1231 
   1232   // We may decide to display native overhead (the actual IMT, ArtFields and ArtMethods) in the
   1233   // future.
   1234   const size_t java_heap_overhead_size = base_no_statics_overhead_size;
   1235 
   1236   // For overhead greater 4, we'll allocate a synthetic array.
   1237   if (java_heap_overhead_size > 4) {
   1238     // Create a byte array to reflect the allocation of the
   1239     // StaticField array at the end of this class.
   1240     __ AddU1(HPROF_PRIMITIVE_ARRAY_DUMP);
   1241     __ AddClassStaticsId(klass);
   1242     __ AddStackTraceSerialNumber(LookupStackTraceSerialNumber(klass));
   1243     __ AddU4(java_heap_overhead_size - 4);
   1244     __ AddU1(hprof_basic_byte);
   1245     for (size_t i = 0; i < java_heap_overhead_size - 4; ++i) {
   1246       __ AddU1(0);
   1247     }
   1248   }
   1249   const size_t java_heap_overhead_field_count = java_heap_overhead_size > 0
   1250                                                     ? (java_heap_overhead_size == 3 ? 2u : 1u)
   1251                                                     : 0;
   1252 
   1253   __ AddU1(HPROF_CLASS_DUMP);
   1254   __ AddClassId(LookupClassId(klass));
   1255   __ AddStackTraceSerialNumber(LookupStackTraceSerialNumber(klass));
   1256   __ AddClassId(LookupClassId(klass->GetSuperClass().Ptr()));
   1257   __ AddObjectId(klass->GetClassLoader().Ptr());
   1258   __ AddObjectId(nullptr);    // no signer
   1259   __ AddObjectId(nullptr);    // no prot domain
   1260   __ AddObjectId(nullptr);    // reserved
   1261   __ AddObjectId(nullptr);    // reserved
   1262   // Instance size.
   1263   if (klass->IsClassClass()) {
   1264     // As mentioned above, we will emit instance fields as synthetic static fields. So the
   1265     // base object is "empty."
   1266     __ AddU4(0);
   1267   } else if (klass->IsStringClass()) {
   1268     // Strings are variable length with character data at the end like arrays.
   1269     // This outputs the size of an empty string.
   1270     __ AddU4(sizeof(mirror::String));
   1271   } else if (klass->IsArrayClass() || klass->IsPrimitive()) {
   1272     __ AddU4(0);
   1273   } else {
   1274     __ AddU4(klass->GetObjectSize());  // instance size
   1275   }
   1276 
   1277   __ AddU2(0);  // empty const pool
   1278 
   1279   // Static fields
   1280   //
   1281   // Note: we report Class' and Object's instance fields here, too. This is for visibility reasons.
   1282   //       (b/38167721)
   1283   mirror::Class* class_class = klass->GetClass();
   1284 
   1285   DCHECK(class_class->GetSuperClass()->IsObjectClass());
   1286   const size_t static_fields_reported = class_class->NumInstanceFields()
   1287                                         + class_class->GetSuperClass()->NumInstanceFields()
   1288                                         + java_heap_overhead_field_count
   1289                                         + num_static_fields;
   1290   __ AddU2(dchecked_integral_cast<uint16_t>(static_fields_reported));
   1291 
   1292   if (java_heap_overhead_size != 0) {
   1293     __ AddStringId(LookupStringId(kClassOverheadName));
   1294     size_t overhead_fields = 0;
   1295     if (java_heap_overhead_size > 4) {
   1296       __ AddU1(hprof_basic_object);
   1297       __ AddClassStaticsId(klass);
   1298       ++overhead_fields;
   1299     } else {
   1300       switch (java_heap_overhead_size) {
   1301         case 4: {
   1302           __ AddU1(hprof_basic_int);
   1303           __ AddU4(0);
   1304           ++overhead_fields;
   1305           break;
   1306         }
   1307 
   1308         case 2: {
   1309           __ AddU1(hprof_basic_short);
   1310           __ AddU2(0);
   1311           ++overhead_fields;
   1312           break;
   1313         }
   1314 
   1315         case 3: {
   1316           __ AddU1(hprof_basic_short);
   1317           __ AddU2(0);
   1318           __ AddStringId(LookupStringId(std::string(kClassOverheadName) + "2"));
   1319           ++overhead_fields;
   1320         }
   1321         FALLTHROUGH_INTENDED;
   1322 
   1323         case 1: {
   1324           __ AddU1(hprof_basic_byte);
   1325           __ AddU1(0);
   1326           ++overhead_fields;
   1327           break;
   1328         }
   1329       }
   1330     }
   1331     DCHECK_EQ(java_heap_overhead_field_count, overhead_fields);
   1332   }
   1333 
   1334   // Helper lambda to emit the given static field. The second argument name_fn will be called to
   1335   // generate the name to emit. This can be used to emit something else than the field's actual
   1336   // name.
   1337   auto static_field_writer = [&](ArtField& field, auto name_fn)
   1338       REQUIRES_SHARED(Locks::mutator_lock_) {
   1339     __ AddStringId(LookupStringId(name_fn(field)));
   1340 
   1341     size_t size;
   1342     HprofBasicType t = SignatureToBasicTypeAndSize(field.GetTypeDescriptor(), &size);
   1343     __ AddU1(t);
   1344     switch (t) {
   1345       case hprof_basic_byte:
   1346         __ AddU1(field.GetByte(klass));
   1347         return;
   1348       case hprof_basic_boolean:
   1349         __ AddU1(field.GetBoolean(klass));
   1350         return;
   1351       case hprof_basic_char:
   1352         __ AddU2(field.GetChar(klass));
   1353         return;
   1354       case hprof_basic_short:
   1355         __ AddU2(field.GetShort(klass));
   1356         return;
   1357       case hprof_basic_float:
   1358       case hprof_basic_int:
   1359       case hprof_basic_object:
   1360         __ AddU4(field.Get32(klass));
   1361         return;
   1362       case hprof_basic_double:
   1363       case hprof_basic_long:
   1364         __ AddU8(field.Get64(klass));
   1365         return;
   1366     }
   1367     LOG(FATAL) << "Unexpected size " << size;
   1368     UNREACHABLE();
   1369   };
   1370 
   1371   {
   1372     auto class_instance_field_name_fn = [](ArtField& field) REQUIRES_SHARED(Locks::mutator_lock_) {
   1373       return std::string("$class$") + field.GetName();
   1374     };
   1375     for (ArtField& class_instance_field : class_class->GetIFields()) {
   1376       static_field_writer(class_instance_field, class_instance_field_name_fn);
   1377     }
   1378     for (ArtField& object_instance_field : class_class->GetSuperClass()->GetIFields()) {
   1379       static_field_writer(object_instance_field, class_instance_field_name_fn);
   1380     }
   1381   }
   1382 
   1383   {
   1384     auto class_static_field_name_fn = [](ArtField& field) REQUIRES_SHARED(Locks::mutator_lock_) {
   1385       return field.GetName();
   1386     };
   1387     for (ArtField& class_static_field : klass->GetSFields()) {
   1388       static_field_writer(class_static_field, class_static_field_name_fn);
   1389     }
   1390   }
   1391 
   1392   // Instance fields for this class (no superclass fields)
   1393   int iFieldCount = klass->NumInstanceFields();
   1394   // add_internal_runtime_objects is only for classes that may retain objects live through means
   1395   // other than fields. It is never the case for strings.
   1396   const bool add_internal_runtime_objects = AddRuntimeInternalObjectsField(klass);
   1397   if (klass->IsStringClass() || add_internal_runtime_objects) {
   1398     __ AddU2((uint16_t)iFieldCount + 1);
   1399   } else {
   1400     __ AddU2((uint16_t)iFieldCount);
   1401   }
   1402   for (int i = 0; i < iFieldCount; ++i) {
   1403     ArtField* f = klass->GetInstanceField(i);
   1404     __ AddStringId(LookupStringId(f->GetName()));
   1405     HprofBasicType t = SignatureToBasicTypeAndSize(f->GetTypeDescriptor(), nullptr);
   1406     __ AddU1(t);
   1407   }
   1408   // Add native value character array for strings / byte array for compressed strings.
   1409   if (klass->IsStringClass()) {
   1410     __ AddStringId(LookupStringId("value"));
   1411     __ AddU1(hprof_basic_object);
   1412   } else if (add_internal_runtime_objects) {
   1413     __ AddStringId(LookupStringId("runtimeInternalObjects"));
   1414     __ AddU1(hprof_basic_object);
   1415   }
   1416 }
   1417 
   1418 void Hprof::DumpFakeObjectArray(mirror::Object* obj, const std::set<mirror::Object*>& elements) {
   1419   __ AddU1(HPROF_OBJECT_ARRAY_DUMP);
   1420   __ AddObjectId(obj);
   1421   __ AddStackTraceSerialNumber(LookupStackTraceSerialNumber(obj));
   1422   __ AddU4(elements.size());
   1423   __ AddClassId(LookupClassId(GetClassRoot<mirror::ObjectArray<mirror::Object>>().Ptr()));
   1424   for (mirror::Object* e : elements) {
   1425     __ AddObjectId(e);
   1426   }
   1427 }
   1428 
   1429 void Hprof::DumpHeapArray(mirror::Array* obj, mirror::Class* klass) {
   1430   uint32_t length = obj->GetLength();
   1431 
   1432   if (obj->IsObjectArray()) {
   1433     // obj is an object array.
   1434     __ AddU1(HPROF_OBJECT_ARRAY_DUMP);
   1435 
   1436     __ AddObjectId(obj);
   1437     __ AddStackTraceSerialNumber(LookupStackTraceSerialNumber(obj));
   1438     __ AddU4(length);
   1439     __ AddClassId(LookupClassId(klass));
   1440 
   1441     // Dump the elements, which are always objects or null.
   1442     __ AddIdList(obj->AsObjectArray<mirror::Object>().Ptr());
   1443   } else {
   1444     size_t size;
   1445     HprofBasicType t = SignatureToBasicTypeAndSize(
   1446         Primitive::Descriptor(klass->GetComponentType()->GetPrimitiveType()), &size);
   1447 
   1448     // obj is a primitive array.
   1449     __ AddU1(HPROF_PRIMITIVE_ARRAY_DUMP);
   1450 
   1451     __ AddObjectId(obj);
   1452     __ AddStackTraceSerialNumber(LookupStackTraceSerialNumber(obj));
   1453     __ AddU4(length);
   1454     __ AddU1(t);
   1455 
   1456     // Dump the raw, packed element values.
   1457     if (size == 1) {
   1458       __ AddU1List(reinterpret_cast<const uint8_t*>(obj->GetRawData(sizeof(uint8_t), 0)), length);
   1459     } else if (size == 2) {
   1460       __ AddU2List(reinterpret_cast<const uint16_t*>(obj->GetRawData(sizeof(uint16_t), 0)), length);
   1461     } else if (size == 4) {
   1462       __ AddU4List(reinterpret_cast<const uint32_t*>(obj->GetRawData(sizeof(uint32_t), 0)), length);
   1463     } else if (size == 8) {
   1464       __ AddU8List(reinterpret_cast<const uint64_t*>(obj->GetRawData(sizeof(uint64_t), 0)), length);
   1465     }
   1466   }
   1467 }
   1468 
   1469 void Hprof::DumpHeapInstanceObject(mirror::Object* obj,
   1470                                    mirror::Class* klass,
   1471                                    const std::set<mirror::Object*>& fake_roots) {
   1472   // obj is an instance object.
   1473   __ AddU1(HPROF_INSTANCE_DUMP);
   1474   __ AddObjectId(obj);
   1475   __ AddStackTraceSerialNumber(LookupStackTraceSerialNumber(obj));
   1476   __ AddClassId(LookupClassId(klass));
   1477 
   1478   // Reserve some space for the length of the instance data, which we won't
   1479   // know until we're done writing it.
   1480   size_t size_patch_offset = output_->Length();
   1481   __ AddU4(0x77777777);
   1482 
   1483   // What we will use for the string value if the object is a string.
   1484   mirror::Object* string_value = nullptr;
   1485   mirror::Object* fake_object_array = nullptr;
   1486 
   1487   // Write the instance data;  fields for this class, followed by super class fields, and so on.
   1488   do {
   1489     const size_t instance_fields = klass->NumInstanceFields();
   1490     for (size_t i = 0; i < instance_fields; ++i) {
   1491       ArtField* f = klass->GetInstanceField(i);
   1492       size_t size;
   1493       HprofBasicType t = SignatureToBasicTypeAndSize(f->GetTypeDescriptor(), &size);
   1494       switch (t) {
   1495       case hprof_basic_byte:
   1496         __ AddU1(f->GetByte(obj));
   1497         break;
   1498       case hprof_basic_boolean:
   1499         __ AddU1(f->GetBoolean(obj));
   1500         break;
   1501       case hprof_basic_char:
   1502         __ AddU2(f->GetChar(obj));
   1503         break;
   1504       case hprof_basic_short:
   1505         __ AddU2(f->GetShort(obj));
   1506         break;
   1507       case hprof_basic_int:
   1508         if (mirror::kUseStringCompression &&
   1509             klass->IsStringClass() &&
   1510             f->GetOffset().SizeValue() == mirror::String::CountOffset().SizeValue()) {
   1511           // Store the string length instead of the raw count field with compression flag.
   1512           __ AddU4(obj->AsString()->GetLength());
   1513           break;
   1514         }
   1515         FALLTHROUGH_INTENDED;
   1516       case hprof_basic_float:
   1517       case hprof_basic_object:
   1518         __ AddU4(f->Get32(obj));
   1519         break;
   1520       case hprof_basic_double:
   1521       case hprof_basic_long:
   1522         __ AddU8(f->Get64(obj));
   1523         break;
   1524       }
   1525     }
   1526     // Add value field for String if necessary.
   1527     if (klass->IsStringClass()) {
   1528       ObjPtr<mirror::String> s = obj->AsString();
   1529       if (s->GetLength() == 0) {
   1530         // If string is empty, use an object-aligned address within the string for the value.
   1531         string_value = reinterpret_cast<mirror::Object*>(
   1532             reinterpret_cast<uintptr_t>(s.Ptr()) + kObjectAlignment);
   1533       } else {
   1534         if (s->IsCompressed()) {
   1535           string_value = reinterpret_cast<mirror::Object*>(s->GetValueCompressed());
   1536         } else {
   1537           string_value = reinterpret_cast<mirror::Object*>(s->GetValue());
   1538         }
   1539       }
   1540       __ AddObjectId(string_value);
   1541     } else if (AddRuntimeInternalObjectsField(klass)) {
   1542       // We need an id that is guaranteed to not be used, use 1/2 of the object alignment.
   1543       fake_object_array = reinterpret_cast<mirror::Object*>(
   1544           reinterpret_cast<uintptr_t>(obj) + kObjectAlignment / 2);
   1545       __ AddObjectId(fake_object_array);
   1546     }
   1547     klass = klass->GetSuperClass().Ptr();
   1548   } while (klass != nullptr);
   1549 
   1550   // Patch the instance field length.
   1551   __ UpdateU4(size_patch_offset, output_->Length() - (size_patch_offset + 4));
   1552 
   1553   // Output native value character array for strings.
   1554   CHECK_EQ(obj->IsString(), string_value != nullptr);
   1555   if (string_value != nullptr) {
   1556     ObjPtr<mirror::String> s = obj->AsString();
   1557     __ AddU1(HPROF_PRIMITIVE_ARRAY_DUMP);
   1558     __ AddObjectId(string_value);
   1559     __ AddStackTraceSerialNumber(LookupStackTraceSerialNumber(obj));
   1560     __ AddU4(s->GetLength());
   1561     if (s->IsCompressed()) {
   1562       __ AddU1(hprof_basic_byte);
   1563       __ AddU1List(s->GetValueCompressed(), s->GetLength());
   1564     } else {
   1565       __ AddU1(hprof_basic_char);
   1566       __ AddU2List(s->GetValue(), s->GetLength());
   1567     }
   1568   } else if (fake_object_array != nullptr) {
   1569     DumpFakeObjectArray(fake_object_array, fake_roots);
   1570   }
   1571 }
   1572 
   1573 void Hprof::VisitRoot(mirror::Object* obj, const RootInfo& info) {
   1574   static const HprofHeapTag xlate[] = {
   1575     HPROF_ROOT_UNKNOWN,
   1576     HPROF_ROOT_JNI_GLOBAL,
   1577     HPROF_ROOT_JNI_LOCAL,
   1578     HPROF_ROOT_JAVA_FRAME,
   1579     HPROF_ROOT_NATIVE_STACK,
   1580     HPROF_ROOT_STICKY_CLASS,
   1581     HPROF_ROOT_THREAD_BLOCK,
   1582     HPROF_ROOT_MONITOR_USED,
   1583     HPROF_ROOT_THREAD_OBJECT,
   1584     HPROF_ROOT_INTERNED_STRING,
   1585     HPROF_ROOT_FINALIZING,
   1586     HPROF_ROOT_DEBUGGER,
   1587     HPROF_ROOT_REFERENCE_CLEANUP,
   1588     HPROF_ROOT_VM_INTERNAL,
   1589     HPROF_ROOT_JNI_MONITOR,
   1590   };
   1591   CHECK_LT(info.GetType(), sizeof(xlate) / sizeof(HprofHeapTag));
   1592   if (obj == nullptr) {
   1593     return;
   1594   }
   1595   MarkRootObject(obj, nullptr, xlate[info.GetType()], info.GetThreadId());
   1596 }
   1597 
   1598 // If "direct_to_ddms" is true, the other arguments are ignored, and data is
   1599 // sent directly to DDMS.
   1600 // If "fd" is >= 0, the output will be written to that file descriptor.
   1601 // Otherwise, "filename" is used to create an output file.
   1602 void DumpHeap(const char* filename, int fd, bool direct_to_ddms) {
   1603   CHECK(filename != nullptr);
   1604   Thread* self = Thread::Current();
   1605   // Need to take a heap dump while GC isn't running. See the comment in Heap::VisitObjects().
   1606   // Also we need the critical section to avoid visiting the same object twice. See b/34967844
   1607   gc::ScopedGCCriticalSection gcs(self,
   1608                                   gc::kGcCauseHprof,
   1609                                   gc::kCollectorTypeHprof);
   1610   ScopedSuspendAll ssa(__FUNCTION__, true /* long suspend */);
   1611   Hprof hprof(filename, fd, direct_to_ddms);
   1612   hprof.Dump();
   1613 }
   1614 
   1615 }  // namespace hprof
   1616 }  // namespace art
   1617