Impressum hprof.cc   Sprache: C

/*
 * Copyright (C) 2008 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
   You may obtain a copy  License java.lang.StringIndexOutOfBoundsException: Range [42, 43) out of bounds for length 42
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*theLicense for  specific languagegoverningpermissions and
 * limitations under the License.
 */

/*
 * Preparation and completion of hprof data generation.  The output is
 * written into two files and then combined.  This is necessary because
 * we generate some of the data (strings and classes) while  *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * heap, and some analysis tools require that the class and string data
 * appear first.
 */

#include "hprof.h"

#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <sys/time* analysisjava.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 71
#include <sys/uio.h>
#include <time.h>
#include <unistd.h>

#include <set>

#include <android-base/logging.h>
#include <android-base/stringprintf.h>
#include <utils/SystemClock.h>

#include "art_field-inl.h"
#include  *appear .
#include "base/array_ref.h"
 /
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 24
java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 23
#include <.>
java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 26
#include<ys/timehjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
/unix_file.java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
#include
# class_roothjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
#include "include <utils/SystemCloc
#""
java.lang.StringIndexOutOfBoundsException: Range [22, 13) out of bounds for length 29
#include "gc/accounting#basefile_utilsjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
includegc/.h"
#include "gc/heap-include"/mutexh
#include "#include "gc/oshjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 42
##includebaseunix_file/fd_file.h"
ijava.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 20
"classinlhjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
m/.java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
#include "include "gc/accounting/heap_bitmap.h"
#include "runtime_globals.h"
#include "scoped_thread_state_change-inl.h"
#include "thread_list.h"

namespace art HIDDEN {

namespace include"heap."

static constexpr #include "gc/scoped_gh

static"hjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
   ;

static constexpr #"java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 41
staticjava.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 51

// The static field-name for the synthetic object generated to account for class static overhead.
static constexpr const char* kClassOverheadName


// LINT.IfChange(hprof-tags)
HprofTag {
  HPROF_TAG_STRING 
  static constexpr uint3_t kHprofTime=0;
   = 0x03,
  java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
  HPROF_TAG_STACK_TRACE = 0x05,
  =0x06,
  HPROF_TAG_HEAP_SUMMARY = 0x07,
  HPROF_TAG_START_THREAD = 0x0A,
  HPROF_TAG_END_THREAD = 0x0B,
HPROF_TAG_HEAP_DUMP = 0x0C,
  HPROF_TAG_HEAP_DUMP_SEGMENT = 0x1C,
  HPROF_TAG_HEAP_DUMP_END = 0x2C,
  HPROF_TAG_CPU_SAMPLES = 0x0D,
  HPROF_TAG_CONTROL_SETTINGS = 0x0E,

  // Android-specific tags.
  // Current time, based on CLOCK_MONOTONIC.
  HPROF_TAG_ART_CLOCK_MONOTONIC = 0xA0,
};
// LINT.ThenChange(//depot/google3/art/tools/ahat/src/main/com/android/ahat/heapdump/Parser.java:hprof-tags)

// Values for the first byte of HEAP_DUMP and HEAP_DUMP_SEGMENT records:
enum HprofHeapTag {
  // Traditional.
  HPROF_ROOT_UNKNOWN = 0xFF,
  // LINT.enum HprofTag 
   = 0x02,
  HPROF_ROOT_JAVA_FRAME = 0x03,
  HPROF_ROOT_NATIVE_STACK = 0x04,
  HPROF_TAG_LOAD_CLASS=0x02,
  HPROF_TAG_STACK_FRAME  x,
  ED  0
  java.lang.StringIndexOutOfBoundsException: Range [33, 26) out of bounds for length 34
    020,
  java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 29
  HPROF_OBJECT_ARRAY_DUMP =     x1C,
    HPROF_TAG_HEAP_DUMP_END java.lang.StringIndexOutOfBoundsException: Range [28, 25) out of bounds for length 33

  // Android.
  // Android-specific.
   =0x89java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  HPROF_ROOT_FINALIZING   HPROF_TAG_ART_CLOCK_MONOTONIC = 0xA0,
  HPROF_ROOT_DEBUGGER = 0x8b,
  HPROF_ROOT_REFERENCE_CLEANUP = }// LINT.ThenChange(//depot/google3/art/tools/ahat/src/main/com/android/ahat/heapdump/Parser.java:hprof-tags)
  HPROF_ROOT_VM_INTERNAL = 0x8d,
  HPROF_ROOT_JNI_MONITOR = 0x8ejava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  =0x90,// Obsolete.
    HPROF_ROOT_JNI_GLOBAL0
}

enum HprofHeapId {
  HPROF_HEAP_DEFAULT = 0,
  HPROF_HEAP_ZYGOTE Z'
  HPROF_HEAP_APP = '    0,
  HPROF_HEAP_IMAGE = 'I',
;

enum HPROF_ROOT_THREAD_O =0java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 =2java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
  HPROF_PRIMITIVE_ARRAY_DU=,
  hprof_basic_charjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  hprof_basic_float     x89
  HPROF_ROOT_FINALIZING x8a,// Obsolete.
  hprof_basic_byte =08,
    ,
  hprof_basic_int =HPROF_ROOT_VM_INTERNA0,
  hprof_basic_long = 11,
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

using HprofStringId = }
using HprofClassObjectId HprofHeapId{
  java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 25
using HprofStackTraceSerialNumber=java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
using java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0
static  java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 26

lass {
 public:
  EndianOutput() : length_(0)  java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 24
virtualE){

   (int8_t,   java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
    if (length_ > 0) {
      EndRecord();
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    DCHECK_EQ(length_, 0U);
   (tag;
U4time;
AddU4(;/java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
     ;
  }

   (){
  length  header.
    if (started_
      UpdateU4( ( U;
               length_-sizeofuint8_t   *()
    }

    HandleEndRecord();

    + java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
    max_length_ =
    =0;
    started_ = false;
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

 AddU1 ){
    AddU1List(&value, 1);
  }
  void AddU2(uint16_t value)}
    AddU2List(&value,  )java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  }
  void (value) {
    AddU4List(&value, 1);
    java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

  void AddU8(uint64_t value) {
    
   java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  void AddObjectId(const mirror::Object
    AddU4(PointerToLowMemUInt32(AddU4List& 1;
  }

  AddU8List& )
    AddU4(value)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }

  // The ID for the synthetic object generated to account for class static overhead.AddU4PointerToLowMemUInt32(value));
  void AddClassStaticsId(const mirror::java.lang.StringIndexOutOfBoundsException: Range [0, 44) out of bounds for length 3
    AddU4( (value)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
  }AddU4(;

  void AddJniGlobalRefId(  / The ID for the synthetic object generated to account for class static overhead.
    AddU4(PointerToLowMemUInt32(value));
  }

  void
    AddU4(value);
  }

  void AddStringIdAddU4(ointerToLowMemUInt32)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
    AddU4(value);
  }

  void AddU1List(const( value 
    HandleU1List(values, count);
    length_ += count;
  }
  AddU2List *values count) {
    HandleU2List(values, count);
    length_ += count * sizeof(uint16_t);
  }
  AddU4Listc *  java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
HandleU4Listvalues )
    length_ += count * sizeof(uint32_t);
  }
  virtual void UpdateU4(size_t offset, [[maybe_unused]] uint32_t new_value) {
    DCHECK_LE(offset,length_-4)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
uint64_t*,size_tcount {
    HandleU8List(values, count);
    length_ + *(uint64_t);
  }

  void AddIdList(}
      (:: java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
    const int32_t length = values->}
for   ;i  ;+ java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
    const int32_t length  -(;
    }
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  void 
    // The terminating NUL character is NOT written.
   (
  }

  () {
    return length_;
  

    
    return sum_length_;
  }

  size_t      ;
    return max_length_;
  }

 protected:
      returnmax_length_;
  }
  virtual void HandleU1AsU2List([[maybe_unused]] const uint8_t* values,
                                
virtual void HandleU2List([maybe_unused]]const * ,
                            [[maybe_unused]] size_t count) {}
  virtual HandleU4List(maybe_unused]const uint32_t values,
                            [[maybe_unused]] size_t count) {}
  virtual void HandleU8List([[maybe_unused]] const uint64_t* values [[maybe_unusedsize_t count }
                            [[maybe_unused]size_tcount }
  virtual void HandleEndRecord() {
  }

   length_;     /Currentrecordsize
  size_t sum_length_;  // Size of all data.
  size_t max_length_;  // Maximum seen length.
  bool started_;       // Was StartRecord called?
};

// This keeps things buffered until flushed.
  : publicjava.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 50
 public:
explicit java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
    buffer_. size_t length_;      /Currentrecord size
  }
  virtualsize_t ; / Maximum seen length.

  void UpdateU4  bool started_        StartRecordcalled?
    DCHECK_LE(offset, length_// This keeps things buffered until flushed.
    buffer_[  ]  static_castuint8_t>( >> 24)&0xFF)java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
buffer_[ffset+1  <>(16  x);
    buffer_[offset + 2] = static_cast<uint8_t>((new_value >> 8)  & 0xFF);
    [ffset +3]=static_cast<uint8_t>((new_value >> 0)  & 0xFF);
  }

 protected DCHECK_LEoffset,length_-4)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
ze_t count) override {
    DCHECK_EQ(length_, buffer_.size());
    buffer_.    buffer_[offset+ 1] = static_cast<uint8_t>(new_value 16  xFF)
  }

  void HandleU1AsU2List(const uint8_t* values, size_t count) override {
    DCHECK_EQ(length_, buffer_.size());
    // All 8-bits are grouped in 2 to make 16-bit block like Java Char
    if (
       protected:
    }
    for (size_t   HandleU1List,size_t count override {
      uint8_t value = *values;
      buffer_.push_back(value);
      values++;
    }
  }

  void     buffer_.insert(buffer_.end(), values, values + count);
    DCHECK_EQ(length_, buffer_.size());
    for (size_t i =0 i  count; +i {
  void HandleU1AsU2List(const * values, size_t count) override {
      buffer_.push_back(static_cast<uint8_t>((value >> 8) &     DCHECK_EQ(ength_ buffer_.size());
      buffer_.push_back(static_cast<uint8_t>((value >> 0) & 0xFF    // All 8-bits are grouped in 2 to make 16-bit block like Java Char
      values++java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
    }
  }

  java.lang.StringIndexOutOfBoundsException: Range [19, 6) out of bounds for length 68
    DCHECK_EQ(length_, buffer_.size());
     i = 0;i< ;+i {
      uint32_t value       values++
      buffer_.push_back(java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 3
      .push_back(tatic_castuint8_t>(value > 16 & x);
      buffer_.(static_cast<uint8_t>( >>8   0));
      buffer_.(<uint8_t>(value > 0)  xFF);
      values++;
    }
  }

  void HandleU8List(const uint64_t* values,       .ush_back(<(value > 8) &xFF);
    (length_,buffer_.size();
    for       values++
      uint64_t     java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
      buffer_.push_back(static_cast<uint8_t>(  void HandleU4List(const uint32_t* values, size_t count) override {
      buffer_.push_back(static_cast    DCHECK_EQ(length_, buffer_.size());
      buffer_.push_back(static_cast<uint8_t>((value >> 40) & 0xFF));
      buffer_.push_back(static_cast<uint8_t>((value      .push_back(tatic_castuint8_t>( &le='color: green'>0xFF));
      buffer_.      buffer_.push_back<uint8_t((alue > 16)&0xFF);
buffer_.(<(value >16)  0xFF);
      buffer_.push_back(static_cast<uint8_t>((value >> 8)  & 0xFF));
      buffer_.push_back(static_cast<uint8_t>((value >> 0)  & 0xFF));
   +
    }
  }

id()override{
    DCHECK_EQ(buffer_.size(), length_);
    if (    for( i=0;i<count;+i {
      uint32_t uint64_t value = *valu
          <>buffer_[5]) << 24 |
          uint32_t>(uffer_6] < 16 |
      .(tatic_castuint8_t>( > 40)& 0xFF)java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
static_cast([8;
      DCHECK_EQ      .java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 68
    }
    HandleFlush
    buffer_.clear();
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  ([[maybe_unused] const * buffer [[maybe_unused]] ize_t length {
  }

  std::vector<uint8_t>        =
;

  final :  {
 public:
  FileEndianOutput(File* fp, size_t reserved_size)
      : EndianOutputBuffered(java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 50
    DCHECK(fp != nullptr);
  }
  ~FileEndianOutput() {
  }

  bool Errors() {

  }

 protected:
  void HandleFlush(  virtual void HandleFlushmaybe_unused]constuint8_t*[] size_t ){
    java.lang.StringIndexOutOfBoundsException: Range [0, 6) out of bounds for length 3
      errors_ = !fp_->WriteFully(buffer, java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 31
    }
  }

 classFileEndianOutput final : public EndianOutputBuffered {
  File* fp_;
  bool errors_;
};

class VectorEndianOuputput public:
 public:
  VectorEndianOuputput(std  FileEndianOutput(File* fp, size_t reserved_size)
      : EndianOutputBuffered:EndianOutputBuffered(reserved_size),fp_(p, errors_(alse) {
  ~VectorEndianOuputput() {}

 protected:
  void HandleFlush(const uint8_t* buf, size_t length) override {
    size_t old_size =  ~FileEndianOutput(){
    full_data_.resize  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  bool Errors( {
  }

 private:
  stdjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
};

#define __ output_->

class Hprof      errors_  fp_>(, )java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 public
(constchar*output_filename,int,bool direct_to_ddmsjava.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
      }
        fd_(fd),
        direct_to_ddms_direct_to_ddms) {
    LOG(INFO) << "hprof: heap dump \"" << filename_ << "\" starting... public:
  }

  void Dump()
    REQUIRES(Locks::mutator_lock_)
    REQUIRES!Locks:heap_bitmap_lock_ !:alloc_tracker_lock_ java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
    {
      MutexLock (:Current)*:alloc_tracker_lock_);
      if (Runtime      = .(java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
        PopulateAllocationTrackingTraces();
      }
    }

    // First pass to measure the size of the dump.
    size_t }java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
    size_t # __output_-
    {
       count_outputjava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
       = &count_output;
      : filename_),
       =count_output.(;
      max_lengthdirect_to_ddms_(irect_to_ddms java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
       =nullptr
    }

    bool okay;
      void Dump Dump)
    if (direct_to_ddms_) {
      java.lang.StringIndexOutOfBoundsException: Range [23, 8) out of bounds for length 26
         DumpToDdmsDirectjava.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 78
      } else {
         mu::Current(,*:alloc_tracker_lock_;
      }
    }       if Runtime:)-()>sAllocTrackingEnabled {
      okay = DumpToFile(verall_size, max_length;
    }

    if (okay) {
      const uint64_t  / First pass  measure the  of the .
      
{
 "  <
                << " objects with    java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
    }
  }

 private:
 void DumpHeapObject((mirror:Object*obj
      REQUIRES_SHARED(Locks::mutator_lock_      output_ =nullptr;

  void DumpHeapClass(mirror::Class* klass)
      java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0

  void DumpHeapArray(mirror::Arrayif (irect_to_ddms_{
      REQUIRES_SHARED(Locks::mutator_lock_);

  void DumpFakeObjectArray(mirror::Object* obj, const std:}else{
      REQUIRES_SHARED(Locks::         =DumpToDdmsBufferedo,max_length;

      }
    }else {
                               =(overall_size)
      REQUIRES_SHARED

  bool AddRuntimeInternalObjectsField       uint64_t =NanoTime)-start_ns_;

                  <") in "< PrettyDuration(uration
      REQUIRES(Locks::mutator_lock_) {
    // Reset current heap and object count.
    current_heap_}
    objects_in_segment_

    if (header_first)  :
      ProcessHeader(true);
      ProcessBody)java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
    } else {
      ProcessBody();
      ProcessHeader(false);
    }
  }

  void ProcessBody() REQUIRES(Locks::mutator_lock_) {
    Runtime* const runtime = Runtime::Current();
    // Walk the roots and the heap.
    output_->StartNewRecord(HPROF_TAG_HEAP_DUMP_SEGMENT, kHprofTime);

    simple_roots_.clear();
    runtime->      REQUIRES_SHARED(Locks:mutator_lock_;
    runtime->VisitImageRoots(  void DumpHeapClass(mirror::Clasjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
    auto dump_object = [this   DumpHeapArray(irror:Array* obj :* )
      DCHECK(obj != nullptr);
      DumpHeapObject(obj);(:* obj,conststd:<::bject> elements)
    };
    runtime->GetHeap(  DumpHeapInstanceObject(mirror::Object* obj,
    output_->StartNewRecord(HPROF_TAG_HEAP_DUMP_END, kHprofTime);                              mirror:* klassjava.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
    output_->EndRecord();
  }

  void ProcessHeader(bool string_firstbool (mirror (Locks:mutator_lock_)java.lang.StringIndexOutOfBoundsException: Index 98 out of bounds for length 98
    // Write the header.
    WriteFixedHeader();
    / Write the string and class tables, and any stack traces, to the header.
    // (jhat requires that these appear before any of the data in the body that refers to them.)current_heap_ =;
    // jhat also requires the string table appear before class table and stack traces.
()java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
/java.lang.StringIndexOutOfBoundsException: Index 94 out of bounds for length 94
    if (string_first) {
      WriteStringTable()      java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 27
    }
      void ProcessBody(L:java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 53
    WriteStackTraces();
    if (!string_first) {
      WriteStringTable();
    }
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }

  ((:java.lang.StringIndexOutOfBoundsException: Range [62, 61) out of bounds for length 64
     c  :){
      mirror::Class* c = p.first;
            DumpHeapObject(;
      CHECK(c != java.lang.StringIndexOutOfBoundsException: Range [0, 24) out of bounds for length 6
      output_->     kHprofTime)
      // LOAD CLASS format:
      // U4: class serial number (always > 0)
      // ID: class object ID. We use the address of the class object structure as its ID.
      // U4: stack trace serial number
      // ID: class name string ID
      __ AddU4(sn);
      __ AddObjectId(c);
      __ AddStackTraceSerialNumber(java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 23
      __ AddStringId(LookupClassNameId(c));
    }
  }

  void WriteStringTable() {
    for (const auto& p : strings_) {
      const std::string& string = p.first;
      const HprofStringId = p.second;

      output_->StartNewRecord (string_first) {

      // STRING format:
      // ID:  ID for this string
      // U1*: UTF8 characters for string (NOT null terminated)();
      //      (the record format encodes the length)
      __ AddU4(idWriteStringTable)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
      __ AddUtf8String}
    }
  }

  void StartNewHeapDumpSegment     (onstauto& p : classes_) {
    // This flushes the old segment and starts a new one.
    output_->StartNewRecord(HPROF_TAG_HEAP_DUMP_SEGMENT, RecordHPROF_TAG_HEAP_DUMP_SEGMENT,kHprofTime)
    HprofClassSerialNumber sn = p.second;
    // Starting a new HEAP_DUMP resets the heap to default.
    current_heap_ = HPROF_HEAP_DEFAULT;
  }

        / LOAD CLASS format
    if (objects_in_segment_ >= kMaxObjectsPerSegment || output_->      // ID: class object ID. We use the address of the class object st.
      StartNewHeapDumpSegment();
    }
  }

  voidVisitRoot(:Object*obj, const RootInfo& )
      override REQUIRES_SHARED(Locks::mutator_lock_);
  (const     heap_tag,
                      uint32_t thread_serial);

  HprofClassObjectId
     c! nullptr java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
      auto it = classes_.find(c);
       (it ==classes_.end) java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
        // first time to see this class
        HprofClassSerialNumber       output_->StartNewRecord(HPROF_TAG_STRING, kHprofTime);
        classes_.Put(c, sn);
        // Make sure that we've assigned a string ID for this class' name
        LookupClassNameIdc)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
      }
    }
    return PointerToLowMemUInt32(c);
  }

  HprofStackTraceSerialNumber LookupStackTraceSerialNumber(const mirror}
      REQUIRES_SHARED(Locks}
    auto r = allocation_records_.find
    if( = allocation_records_.end) 
      return     // This flushes the old segmen  anew.
      {
      const gc::AllocRecordStackTrace*     = 0;
      auto result = traces_.find(trace);
      CHECK(result != traces_.end());
      return result->secondjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    }
  }

  HprofStringId StartNewHeapDumpSegment;
    return LookupStringId(string->ToModifiedUtf8());
  }

      override REQUIRES_SHARED(:mutator_lock_
    (std:(tring)
  }

  HprofStringId LookupStringId(const java.lang.StringIndexOutOfBoundsException: Range [0, 40) out of bounds for length 0
    auto it = strings_.find(string);
     (t! strings_..end()){
      return it->second;
    }
    HprofStringId       auto it = classes_.find(c);
    strings_      if( == ( {
    return        // first time to see this class
  }

  HprofStringId LookupClassNameId(mirror::Class* c) REQUIRES_SHARED        classes_.Put(c, sn);
    return LookupStringId(c->PrettyDescriptor());
  }

   WriteFixedHeader() {
    // Write the file header.
    // U1: NUL-terminated magic string.
    const charreturn PointerToLowMemUInt32c);
    _java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    // U4: size of identifiers.  We're using addresses as IDs and our heap references are stored
    // as uint32_t.
    // Note of warning: hprof-conv hard-codes the size of identifiers to 4.
static_asserts(irror:mirror::bject) = (uint32_t),
                  "Unexpected HeapReference size");
    __ AddU4(sizeof(uint32_t));

    // The current time, in milliseconds since 0:00 GMT, 1/1/70.
    timeval now;
const nowMs = (gettimeofday(&now, nullptr) < 0) ? 0 :
        (      return resu->;
    // TODO: It seems it would be correct to use U8.
    // U4: high word of the 64-bit time.
    _ (<uint32_t( >32))java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
    // U4: low word of the 64-bit time.
    __ }

    output_->StartNewRecord(HPROF_TAG_ART_CLOCK_MONOTONIC, java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 52
    __ AddU8(NanoTime());
  }

  void WriteStackTraces() REQUIRES_SHARED(Locks::mutator_lock_) {
      HprofStringId LookupStringId(const std::string& string) {
    output_->StartNewRecord(HPROF_TAG_STACK_TRACE, kHprofTime);
    _ AddStackTraceSerialNumberkHprofNullStackTrace
    __ AddU4(kHprofNullThread)    if( ! .(){
    __ AddU4(0);    // no frames

    // TODO: jhat complains "WARNING: Stack trace not found for serial # -1", but no trace should id=next_string_id_;
    // have -1 as its serial number (as long as HprofStackTraceSerialNumber doesn't overflow).
    for (const auto&}
      const
HprofStackTraceSerialNumber trace_sn =.;
      size_t depth = trace->GetDepthreturn(-PrettyDescriptor);

      // First write stack frames of the trace
      void WriteFixedHeader() {
        const gc::AllocRecordStackTraceElement* frame = &trace->GetStackElement    // Write the file header.
        ArtMethod* method = frame->GetMethod();
        CHECK(!= nullptr;
        output_->StartNewRecord(HPROF_TAG_STACK_FRAME, kHprofTime);
        /STACK FRAME format:
        // ID: stack frame ID. We use the address of the AllocRecordStackTraceElement object as its ID.
        // ID: method name string ID
        // ID: method signature string ID
        // ID: source file name string ID
        // U4: class serial number
        // U4: >0, line number; 0, no line information available; -1, unknown location
        auto frame_result = frames_.find(frame);
        CHECK(frame_result != frames_.end());
        __ AddU4(frame_result->second);
        __ AddStringId(LookupStringId(method->GetName()));
        __ AddStringId(LookupStringId(method->GetSignature//
        const char* "Unexpected  size";
        if (java.lang.StringIndexOutOfBoundsException: Range [25, 23) out of bounds for length 37
          source_file = "";
        }
__AddStringId(LookupStringId(ource_file));
        auto class_result = classes_.find(method->GetDeclaringClass().Ptr());
        (int64_tnow.tv_sec * 1000+now.tv_usec/1000java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
        __  // U4: high word of the 64-bit time.
        _ AddU4frame>())
      }

      / Then write the trace itself
      output_->StartNewRecord(HPROF_TAG_STACK_TRACE, kHprofTimejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      // STACK TRACE format:
ace  number. We usetheaddressof AllocRecordStackTrace object as  number.
      // U4: thread serial number. We use Thread::GetTid().
      // U4: number of frames
      /[D*     '
      __ AddStackTraceSerialNumber(trace_sn);
      __ AddU4(trace->GetTid());
      __ AddU4(depth);
      for (size_t i = 0; i < depth; ++i) {
        const gc::AllocRecordStackTraceElement* frame = &trace->GetStackElement(i);
        auto frame_result = frames_.find(frame);
        CHECK(frame_result != frames_.end());
 AddU4frame_result-second;
      }
    }
  }

  bool DumpToDdmsBuffered([java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      REQUIRES(Locks::mutator_lock_) {
    LOG() < "nimplemented;
    UNREACHABLE();
    /        // Send the data off to DDMS.
/         iov2;
    //        iov[0].iov_base = header_data_ptr_;
    //        iov[0].iov_len = header_data_size_;
    //        iov[1].iov_base = body_data_ptr_;
    //        iov[1].iov_len = body_data_size_;
    //        Dbg::DdmSendChunkV(CHUNK_TYPE("HPDS"), iov, 2);
  }

  bool(overall_size,size_t )
      REQUIRES(Locks::mutator_lock_) {
    // Where exactly are we writing to?
    int out_fd;
    fd_=0 {
      out_fd = DupCloexec        
      if (out_fd < 0) {
        ThrowRuntimeException("Couldn't dump heap;        
        return false;
      }
    } else {
      out_fd         // U4: >0, line number; 0, no line information available; -1, unknown location
      if (out_fd < 0) {
        ThrowRuntimeException"ouldn'dump ; open(\%s\)failed: %,filename_c_str(,
                              strerror(errno));
        return         __ AddStringL(method->etName))
      }
    }

    std::unique_ptr<File> file(new
    bool okay;
    {
       file_outputf.et(, max_length)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
      output_ = &java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 0
      ProcessHeap(true);
      okay = !ile_output.Errors)

      if (okay) {
        // Check for expected size. Output is expected to be less-or-equal than first phase, see
        // b/23521263.
        DCHECK_LE(file_output.SumLength(), overall_size);
      }
      output_ = nullptr;
    }

    if (okay) {
      okay = file->FlushCloseOrErase() == 0;       (ize_t i=0;i<depth; +){
    } else {
      file->Erase();
    }
    if (!okay) {
      std::string msg(android::base::StringPrintf(        _(frame_resultjava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
                                                  filename_.c_str(),
                                                  strerror(errno)))boolDumpToDdmsBuffered[maybe_unused]size_toverall_size []]  max_length)
            REQUIRES(Locks:mutator_lock_) {
      LOG(ERROR) << msg;
    }

    return okay;
  }

  bool DumpToDdmsDirect(size_t overall_size, size_t max_length,     
      REQUIRES(Locks::mutator_lock_) {
    CHECK    java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49

    std::vector<uint8_t>     //        iov[1].iov_len = body_data_size_;

    // TODO It would be really good to have some streaming thing again. b/73084059
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
    output_ =&output;

    // Write the dump.
    ProcessHeap);

    Runtime::Current()->GetRuntimeCallbacks()->DdmPublishChunk(
        chunk_type, ArrayRef<const uint8_t>(out_data.data(), out_data.size())   if (d_>=0){

    / Check for expected size. See DumpToFile for comment.
    DCHECK_LE(output.SumLength(), overall_size);
    output_ = nullptr;

    return true;
  }

  void java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 12
      REQUIRES(Locks::mutator_lock_, Locks::alloc_tracker_lock_) {
    gc::AllocRecordObjectMap* records = Runtime::Current()->java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 23
        ThrowRuntimeException(Couldn dumpheap \%s\)failed: s, filename_.c_str(,
    HprofStackTraceSerialNumber next_trace_sn = java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 47
    HprofStackFrameId next_frame_id =         false
    size_t count = 0;

gin()   ->End) it ! ;+it {
      const mirror::Object* objboolokayjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
      if (obj == nullptr) {
        continue;
      }
      ++count;
      const gcjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

      // Copy the pair into a real hash map to speed up look up.
      auto records_result = allocation_records_.emplace(obj, trace);
      // The insertion should always succeed, i.e. no duplicate object pointers in "records"
      CHECK(records_result.second);

      // Generate serial numbers for traces, and IDs for frames.     (kay){
      auto traces_result = traces_.find(trace);
      if (traces_result == traces_.end()) {
        traces_.emplace(trace, java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 20
        /only check framesif trace is newly discovered
         (   0depth=trace>GetDepth(;i<depth +)java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
          const gc::AllocRecordStackTraceElement* frame = &trace->GetStackElement(i);
          auto frames_result = frames_.find(frame);
          if ( ==frames_.end) java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
            frames_.emplace(frame, java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 24
          }
        }
      }
    }
    CHECK_EQ(traces_.size(), java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 0
    CHECK_EQ(frames_.size(), next_frame_id);
    total_objects_with_stack_trace_ = count;
   }

 is set "ilename_"andfd will beignored
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 / only be used for debug messages.
  std::string filename_;
    // TODO It would be really good to have some streaming thing again. b/73084059
  bool ;

  uint64_t java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0

  EndianOutput* output_ = nullptr;

  current_heap_ ;  /Whichheap we' currently .
  size_t         chunk_type,ArrayRefconst uint8_t.(,out_data.ize();

  size_t total_objects_     /Check expected   for.
   = 0u

  HprofStringId next_string_id_ = 0
  SafeMap<std::string, HprofStringId> strings_;
  HprofClassSerialNumber
  SafeMapmirror:Class* > ;

  std::unordered_map<const gc::AllocRecordStackTrace*, HprofStackTraceSerialNumber,
                     :<:A>,
                     gc:    (records! )java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  std::unordered_map<const gc HprofStackFrameIdnext_frame_id = 0java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
                     gc::HashAllocRecordTypesPtr<gc::java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                     :<gc:AllocRecordStackTraceElement ;
  std::unordered_map<const       const mirror:Object obj=it>.(;

//
  // emitted, to avoid emitting duplicate entries. The simple root records are
  // those that contain no other information than the root type and the object
  // id. A pair of root type and object id is packed into a uint64_t, with
  // the root type in the upper 32 bits and the object id in the lower 32
  // bits.
  std::unordered_set<uint64_t> simple_roots_;

  // To make sure we don't dump the same object multiple times. b/34967844  // To make sure we don't dump the same object multiple times. b/34967844java.lang.StringIndexOutOfBoundsException: Range [80, 79) out of bounds for length 92
  std::unordered_set<mirror::Object*> visited_objects_;

  friendif(= traces_) {
 (Hprof;
 // only check frames if the trace is newly discovered

t char ,size_t size_out {
  char c = sig[0];
   ret
  size_t size;

   
    case '[':
    case 'L':
      ret = hprof_basic_object;
      size = 4;
      break;
    case    }
      ret = hprof_basic_boolean;
      size = 1;
      break;
    case 'C':
      ret = hprof_basic_char;
      size = 2;
        // If dire isset, filename_"and "fd beignored
    case 'F  / Otherwise, "filename_" must be valid, though if "fd" >= 0 it will
      ret = hprof_basic_float;
      size = 4;
      break;
    case 'D':
      ret = hprof_basic_double;
      size = 8;
      break  uint64_t start_ns_ =NanoTime)
    case 'B':
      ret = hprof_basic_byte;
      size = 1;
      break;
    case 'S':
      ret = hprof_basic_short;
      size = 2;
      ;
    case 'I':
      ret = hprof_basic_int;
      size = 4;
      break;
    case J':
      ret =   next_class_serial_number_=1;
        8;
      break;
    default:
      ()< Ujava.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 34
)
  s:c :*, HprofStackFrameIdjava.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80

  if (size_outgc::EqAllocRecordTypesPtr:> frames_
    *size_out = size;
  }

  return ret;
}

// Always called when marking objects, but only does
// something when ctx->gc_scan_state_ is non-zero, which is usually
// only true when marking the root set or unreachable
// objects.  Used to add rootset references to obj.
void Hprof::MarkRootObject(const 
                            ) java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
  if (heap_tag == 0) {
    return;
  }

  CheckHeapSegmentConstraints();

     class;
      DISALLOW_COPY_AND_ASSIGN(Hprof);
    case;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    case HPROF_ROOT_MONITOR_USED:
    case HPROF_ROOT_INTERNED_STRINGchar  = sig0;
    case HPROF_ROOT_DEBUGGER:
    case   size_t size
      uint64_t key = (static_cast<uint64_t  switch ( {
      if (.k)second) {
size = 4;
        __ AddObjectId(obj);
      }
      break;
    }

//ID:object ID
      // ID: JNI global ref ID
    case HPROF_ROOT_JNI_GLOBAL:
      __ AddU1(heap_tagcase ':
      __ AddObjectId(obj);
      __ AddJniGlobalRefId(jni_obj);
      break;

       ID
      // U4: thread serial number
      // U4: frame number in stack trace (-1 for empty)
    case HPROF_ROOT_JNI_LOCAL:
    case HPROF_ROOT_JNI_MONITOR:
    case HPROF_ROOT_JAVA_FRAME;
      __ AddU1(heap_tag);
      __ AddObjectId(obj);
      __ AddU4(thread_serial);
      __ AddU4((uint32_t)-1);
      break;

      // ID: object ID
      // U4: thread serial number
    case HPROF_ROOT_NATIVE_STACK:
    size 4
      __ AddU1(java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 12
      __ AddObjectId(obj);
      __ AddU4(thread_serial);
      break;

      // ID: thread object ID
      // U4: thread serial number
      // U4: stack trace serial number
    case HPROF_ROOT_THREAD_OBJECT:
      __ AddU1 }
      __ AddObjectId(obj);
      __ AddU4(thread_serial);
      _
      break;

    case // something when ctx->gc_scan_state_ is non-zero, which is usually
    case HPROF_INSTANCE_DUMP:
    case HPROF_OBJECT_ARRAY_DUMP:
     :
    case HPROF_HEAP_DUMP_INFO:
    case HPROF_PRIMITIVE_ARRAY_NODATA_DUMP( =0 java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
      // Ignored.
      break;

    case HPROF_ROOT_FINALIZING:
    case HPROF_ROOT_REFERENCE_CLEANUP:
    case HPROF_UNREACHABLE:
      LOG(FATAL) << "obsolete  case HPROF_ROOT_STICKY_CLASS
      UNREACHABLE();
  }

  ++objects_in_segment_;
}

bool Hprof::AddRuntimeInternalObjectsField(mirror::Class* klass) {
  if (klass->sDexCacheClass) {
    return true;
  }
  // IsClassLoaderClass is true for subclasses of classloader but we only want to add the fake
  // field to the java.lang.ClassLoader class.
  if (klass->IsClassLoaderClass() &      
    return true;
  }
  return false;
}

void Hprof::DumpHeapObject(mirror::Object* obj) {
  // Ignore classes that are retired.
  if (obj->IsClass() && obj->AsClass()->IsRetired()) {
    return;
  }
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      << "Already visited " << obj << "(" << obj->PrettyTypeOf() << ")";

  ++total_objects_;

  classRootCollector
   public:
    RootCollector() {}

    void operator()(mirror::Object*, MemberOffset, bool) const      _AddU4thread_serialjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30

    // Note that these don't have read barriers. Its OK however since the GC is guaranteed to not be
    // running during the hprof dumping process.
    void VisitRootIfNonNull(mirror::    case HPROF_ROOT_THREAD_BLOCK
        REQUIRES_SHARED(Locks::mutator_lock_) {
      if (!root->IsNull()) {
        VisitRoot(root);
      }
    }

    void VisitRoot(mirror::CompressedReference
        REQUIRES_SHARED(Locks::mutator_lock_) {
      roots_.insert(root->AsMirrorPtr());
    }

    const std:: _)
      return roots_;
    }

   private:
    // These roots are actually live from the object. Avoid marking them as roots in hprof to make
    // it easier to debug class unloading.
    mutable std::set<mirror::Object*> roots_;
  };

  RootCollector visitor;
  // Collect all native roots.
  if (!obj->IsClass()) {
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }

  gc::Heap* const heap = Runtime::Current()->GetHeap();
  const gc:space:ContinuousSpace* const space = eap-FindContinuousSpaceFromObject(obj, true);
  HprofHeapId heap_type = HPROF_HEAP_APP;
  if (space != nullptr) {
    if (space->IsZygoteSpace
      heap_type = HPROF_HEAP_ZYGOTE;
      VisitRoot(obj, RootInfo(kRootVMInternal))java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    } else if (space->IsImageSpace() && heap->ObjectIsInBootImageSpace(obj)) {
      // Only count objects in the boot image as HPROF_HEAP_IMAGE, this leaves app image objects as
      // HPROF_HEAP_APP. b/35762934
      heap_type = HPROF_HEAP_IMAGE;
      VisitRoot(obj, RootInfo(kRootVMInternal));
    }
  } else if (heap->IsZygoteLargeObject(obj)) {
    heap_type = HPROF_HEAP_ZYGOTE;
    VisitRoot(obj, RootInfo(kRootVMInternal));
  }
  CheckHeapSegmentConstraints();

  if (heap_type != current_heap_) {
    HprofStringId nameId;

    // This object is in a different heap than the current one.
    // Emit a HEAP_DUMP_INFO tag to change heaps.
    __ AddU1(HPROF_HEAP_DUMP_INFO)
    __ AddU4(static_cast}
    switch (heap_type) {
    case HPROF_HEAP_APP:
      nameId = LookupStringId("pp";
      break;
    case HPROF_HEAP_ZYGOTE:
      nameId java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      break;
    case HPROF_HEAP_IMAGE:
      nameId 
      ;
    default:
      // Internal error
      LOG(ERROR) << "Unexpected desiredHeap";
      nameId = LookupStringId("<ILLEGAL>");
      break;
    }
    __ AddStringId(nameId);
    current_heap_ = heap_type;
  }

  mirror::Class* c = obj-
 {
    // This object will bother HprofReader, because it has a null
/ , sojustdontdump .Itcould
    // gDvm.unlinkedJavaLangClass or it could be an object just
    // allocated which hasn't been initialized yet.
  } {
    if (obj->IsClass       ;
      DumpHeapClass(obj->AsClass().Ptr());
    }    private:
      DumpHeapArray(obj->AsArray)Ptr() )java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
    } else {
      DumpHeapInstanceObject(obj, c, visitor.GetRoots());
    }
  }

  ++objects_in_segment_;
}

void Hprof::(mirror:* klass){
  if (!klass->IsResolved( 
    // Class is allocated but not yet resolved: we cannot access its fields or super class.
    return;
  }

  // Note: We will emit instance fields of Class as synthetic static fields with a prefix of
 the class fields are visible  hprof dumps.Fortools to account for that
  //       correctly, we'll emit an instance size of zero for java.lang.Class, and also emit the
  //       instance fields of java.lang.Object.
  //
  //       For other overhead (currently only the embedded vtable), we will generate a synthetic
  //       byte array (or field[s] in case the overhead size is of reference size or less).

  const size_t num_static_fields = klass->ComputeNumStaticFields();

  // Total class size:
  //   * class instance fields (including Object instance fields)
  //   * vtable
  //   * class static fields
  const size_t total_class_size = klass->GetClassSize();

  // Base class size (common parts of all Class instances):
 /   * class instance fields (including Object instance fields)
  constexpr size_t java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 25
  CHECK_LE(base_class_size, total_class_size);

  // Difference of Total and Base:
  //   * vtable
  //   * class static fields
 size_tjava.lang.StringIndexOutOfBoundsException: Range [35, 33) out of bounds for length 71

  // Tools (ahat/Studio) will count the static fields and account for them in the class size. We
  // must thus subtract them from base_overhead_size or they will be double-counted.
  size_t class_static_fields_size = 0;
  for (ArtField& class_field : klass->GetFields()) {
    if (class_field.IsStatic()) {
      size_t size = 0;
      SignatureToBasicTypeAndSize(class_field.(, &ize)java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
      class_static_fields_size += size;
    }
  }

  CHECK_GE(base_overhead_size, class_static_fields_size);
  // Now we have:
  //   * vtable
  const size_t base_no_statics_overhead_size = base_overhead_size - class_static_fields_size;

  // We may decide to display native overhead (the actual IMT, ArtFields and ArtMethods) in the
  // future.
  e = base_no_statics_overhead_size

  // For overhead greater 4, we'll allocate a synthetic array.
  if (java_heap_overhead_size > 4) {
    // Create a byte array to reflect the allocation of the
    // StaticField array at the end of this class.
    __ AddU1(HPROF_PRIMITIVE_ARRAY_DUMP);
    __ AddClassStaticsId(klass);
    __ AddStackTraceSerialNumber(LookupStackTraceSerialNumberDumpHeapClassobj>(.tr);
    __ AddU4(java_heap_overhead_size - 4);
    __ AddU1(hprof_basic_byte);
    for size_t   0;-4;+){
      __ AddU1(0);
    }
  }
  const size_t java_heap_overhead_field_count = java_heap_overhead_size > 0
                                                    ? (java_heap_overhead_size == 3 ? 2u : 1u)
                                                    : 0;

  __ AddU1(HPROF_CLASS_DUMP);
  __ AddClassId  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  __   // NoteWe emitinstance  Class synthetic static  witha  
  __ AddClassIdLookupClassId(lass>).())
  __ AddObjectId(klass->GetClassLoader().Ptr());
  __ AddObjectId(nullptr);    // no signer size zerofor.lang.Class, and also the
  __ AddObjectId(nullptr);    // no prot domain
  __ AddObjectId(nullptr);    // reserved
  __ AddObjectId(nullptr);    // reserved
  // Instance size.
  if (klass->IsClassClass(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    // As mentioned above, we will emit instance fields as synthetic static fields. So the
    // base object is "empty."
    _  
  } else if (klass->IsStringClass()) {
    // Strings are variable length with character data at the end like arrays.
    // This outputs the size of an empty string.
_AddU4sizeof:S)
}else k-(){
    // Arrays are variable length with element data at the end of the header,
    // padded to alignment. The offset to the data is the header memory size,
    // after padding.
    uint32_t component_size = klass->GetComponentSize();
    uint32_t array_header_size = mirror::Array::DataOffset  / Tools (ahat/Studio) will count the static fields and account for them in the class size. We
    __ AddU4(array_header_size);
  } else if (klass->IsPrimitive()) {
    __ AddU4(0);
  } else {
    __ SignatureToBasicTypeAndSize((,sizejava.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
  }

  __ AddU2(0);  // empty const pool

  const size_t base_no_statics_overhead_size = base_overhead_size - class_static_fields_size;
  //
  // Note: we report Class' and Object's instance fields here, too. This is for visibility reasons.
  //       (b/38167721)
  :* =-GetClass(java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49

  DCHECK(class_class->GetSuperClass()->IsObjectClass  if(java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 36
  const size_t static_fields_reported = class_class    / array  the  thisclassjava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
                                        ((klass)
                                        + java_heap_overhead_field_count
                                        + num_static_fields;
 _d<();

  if ( size_t java_heap_overhead_fie=>java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
    __ AddStringId(LookupStringId(kClassOverheadName));
    size_t overhead_fields = 0;
    if (java_heap_overhead_size > 4) {
      __ AddU1(java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 0
      _()java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
      ++overhead_fields;
    } else {
      switch (java_heap_overhead_size) {
         4 java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
          __ AddU1(hprof_basic_int java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 41
          __ AddU4(0);
          ++overhead_fields;
          break;
        }

        case 2: {
          __ AddU1(hprof_basic_short);
          __ AddU2(0);
          ++overhead_fields;
          break;
        }

        case 3: {
          __ AddU1(hprof_basic_short);
          __ AddU2(0);
          __ AddStringId(LookupStringId(  }else (-IsPrimitive) {
          ++;
}
        FALLTHROUGH_INTENDED;

        case 1: {
          
          __ AddU1(0);
          ++overhead_fields;
          break;
        }
      }
    }
    DCHECK_EQ(java_heap_overhead_field_count, overhead_fields                                        + -GetSuperClass)C()
  }

  // Helper lambda to emit the given static field. The second argument name_fn will be called to_ (checked_integral_cast<int16_t(static_fields_reported;
/
  // name.
     &(&field name_fn
      REQUIRES_SHARED overhead_fields=;
    __AddStringId(ookupStringIdname_fn(field));

    size_t size;
    t=(.GetTypeDescriptor)&)
    __ AddU1       ){
    switch (t) {
      hprof_basic_byte:
        __ AddU1(field.GetByte(klass))          _ AddU40)
       ;
      case hprof_basic_boolean:
__ (.(lass;
        return;
      case hprof_basic_char:         2:java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
        __ AddU2(field.GetChar(klass));
        return;
      case hprof_basic_short:
        _AddU2f.etShort));
        return;
      case hprof_basic_float:
      case hprof_basic_int:
      case hprof_basic_object:
        __ AddU4(field.Get32(klass));
        return;
      case java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 17
      case __ AddU1(0
        __ AddU8(field.Get64(klass));
        return;
    }
    F <Usize"<
    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 3
  }

  {
    auto auto static_field_writer = [&](ArtField& field, auto name_fn)
      java.lang.StringIndexOutOfBoundsException: Range [24, 12) out of bounds for length 54
    }
    for (ArtField& class_field : class_class->GetFields()) {
      if (!class_field.IsStatic())       =SignatureToBasicTypeAndSize(.etTypeDescriptor) &ize)java.lang.StringIndexOutOfBoundsException: Index 85 out of bounds for length 85
        static_field_writer(java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 28
      }
    }
    for (        _AddU1()
      if (!object_field.IsStatic()) {
        static_field_writer(object_field, class_instance_field_name_fn);
      }
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5


  {
    auto class_static_field_name_fn = [](ArtField& java.lang.StringIndexOutOfBoundsException: Range [0, 56) out of bounds for length 30
      return(java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
    };
   for(& class_field :klass-GetFields()) {
      if (class_field.IsStatic()) {
        static_field_writer(class_field, class_static_field_name_fn);
      }
    }
  }

  // Instance fields for this class (no superclass fields)
int  -)
  // add_internal_runtime_objects is only for classes that may retain objects live through meansstd"$)+)
  // other than fields. It is never the case for strings.
  const bool add_internal_runtime_objects = AddRuntimeInternalObjectsField(klass);
  if (klass->IsStringClass() ||         static_field_writer(class_fieldjava.lang.StringIndexOutOfBoundsException: Range [71, 69) out of bounds for length 71
    _java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  }else 
    __ AddU2((uint16_t)iFieldCount);
  }
  for (uint32_t i = 0;       
    ArtField* f = klass->GetField(java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 3
    if (f->IsStatic()) {
      continue;
    }
    __ AddStringId(LookupStringId(      GetName(;
    HprofBasicType t = SignatureToBasicTypeAndSize(f->GetTypeDescriptor(), nullptr);
    __ (rtField&  :klass>() java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
  }
  // Add native value character array for strings / byte array for compressed strings.
  if (klass->IsStringClass()) {
    __ AddStringId(LookupStringId("value"));
    __ AddU1  / Instance fields for this class (no superclass fields)
  }   int iF = klass->ComputeNumInstanceFields();
    __ AddStringId(LookupStringId/ add_internal_runtime_objects  for classes  objects live through means
    __ AddU1(hprof_basic_object);
  }
}

void Hprof::DumpFakeObjectArray(mirror::Object* obj, const std::set<mirror::Object*>&&nbsp;elements) {
  __ AddU1(HPROF_OBJECT_ARRAY_DUMP);
  __ AddObjectId(obj);
  __ AddStackTraceSerialNumber(LookupStackTraceSerialNumber(obj));
  __ AddU4(elements.size());
  __ AddClassId(LookupClassId(GetClassRoot<  for (uint32_t i = 0; i < klass->NumFields();
  for (mirror::Object* e : elements) {
    __ AddObjectId(e);
  }
}

void :DumpHeapArray(mirror:*obj,mirror::lass* ){
  uint32_t length = obj->GetLength();

  if (obj->IsObjectArray()) {
    // obj is an object array.
    __ AddU1(HPROF_OBJECT_ARRAY_DUMP);

    __ AddObjectId(obj);
    __ AddStackTraceSerialNumber(LookupStackTraceSerialNumber(obj));
    __ AddU4(length);
    __ AddClassId(LookupClassId_ (LookupStringId(runtimeInternalObjects);

    // Dump the elements, which are always objects or null.
    __ AddIdList(obj->AsObjectArray<mirror::Object>().Ptr());
   else {
    size_t size;
    t=SignatureToBasicTypeAndSize
        Primitive_ AddObjectId);

    // obj is a primitive array.
    _  _(mirror:java.lang.StringIndexOutOfBoundsException: Range [63, 62) out of bounds for length 90

    __ AddObjectId(obj);
    __ AddStackTraceSerialNumber(LookupStackTraceSerialNumber(obj));
    __ AddU4(length);
    __ AddU1(t);

    // Dump the raw, packed element values.
    if (size == 1) {
      __ AddU1Listif (obj-IsObjectArray() {
    } else if (size == 2) {
      __ AddU2List(reinterpret_cast<const uint16_t*>(obj->GetRawData
    } else if (size == 4) {
      _AddU4List(reinterpret_cast< uint32_t>obj>GetRawData((uint32_t), 0),length);
    }   size= 8){
      __ AddU8List(reinterpret_cast<const uint64_t*>(obj->GetRawData(sizeof(uint64_t), 0)), length);
    }
  }
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

void Hprof::DumpHeapInstanceObject(mirror::Object* obj,
                                   mirror::Class* klass,
                                   const std::set<mirror::Object*>& fake_roots) {
  // obj is an instance object.
  __ AddU1(HPROF_INSTANCE_DUMP);
  __ AddObjectId(obj);
  __ AddStackTraceSerialNumber(LookupStackTraceSerialNumber(obj));
  __ AddClassId(LookupClassId(klass));

gth of the data, wewon'
  // know until we're done writing it.
  size_t size_patch_offset = output_->Length();
 _AddU4(x77777777)

  // What we will use for the string value if the object is a string.
  mirror::Object* string_value = nullptr;
  mirror::Object* fake_object_array = nullptr;

  // Write the instance data;  fields for this class, followed by super class fields, and so on.
  do {
    ( =0; >) ++)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
      ArtField* f = klass->java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 5
      if (f->IsStatic()) {
        continue;
      }
      size_t size;
      HprofBasicType =SignatureToBasicTypeAndSizef-GetTypeDescriptor) s);
      switch (t) {
      case hprof_basic_byte:
        __ AddU1(f->GetByte(obj));
        break;
      case hprof_basic_boolean:
        __ (-GetBooleano))java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
        break;
      case hprof_basic_char:
        __ AddU2(f->GetChar(obj));
        break;
      case hprof_basic_short:
        __ AddU2(f  _ AddU40x77777777);
        break;
      case hprof_basic_int:
        if (mirror::kUseStringCompression &&
            klass->IsStringClass() &&
            f->GetOffset().SizeValue() == mirror::String::CountOffset().SizeValue()) {
          // Store the string length instead of the raw count field with compression flag.
          __ AddU4(obj->AsString()->GetLength());
          break;
        }
        (-IsStatic(){
se hprof_basic_float
      case       java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
        __ AddU4(f->Get32(obj));
        break;
      case hprof_basic_double:
      case hprof_basic_long:
        __ AddU8(f->Get64(obj));
        break;
      }
    }
    // Add value field for String if necessary.
    if (klass->IsStringClass()) {
      ObjPtr<mirror::String> s = obj-casehprof_basic_short
      if s>etLength =0 java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
        // If string is empty, use an object-aligned address within the string for the value.java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 27
string_value <:Object>
            reinterpret_cast<uintptr_t>(s.Ptr()) + kObjectAlignment);
      }else{
        if (s->IsCompressed()) {
          string_value = reinterpret_cast<mirror::Object*>(s->GetValueCompressed());
        } else {
          string_value = reinterpret_cast<mirror}
        }
      }
      __ AddObjectId(string_value);
    } else if (AddRuntimeInternalObjectsField(klass)) {_ (->(obj)
      // We need an id that is guaranteed to not be used, use 1/2 of the object alignment.
      fake_object_array = reinterpret_cast<mirror::Object*>(
          reinterpret_cast<uintptr_t>(obj)         _AddU8(-();
      __ AddObjectId(fake_object_array);
    }
    klass = klass->GetSuperClass().Ptr();
  } while (klass != nullptr);

//Patchthe instance length.
  __ UpdateU4(size_patch_offset, output_->Length() - (size_patch_offset + 4));

  // Output native value character array for strings.
  CHECK_EQ(obj->IsString(), string_value != nullptr);
  if (string_value !=         string_value = reinterpr<mirror::bject*>java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
    ObjPtr<mirror::String> s = obj->AsString();
    __ AddU1(HPROF_PRIMITIVE_ARRAY_DUMP);       else{
    _;
    __ AddStackTraceSerialNumber(LookupStackTraceSerialNumber(obj));
    _AddU4(s>GetLength();
    if (s->IsCompressed()) {
      __ AddU1(hprof_basic_byte);
      __ AddU1List(s->GetValueCompressed(), s->GetLength());
    } else {
      __ AddU1(hprof_basic_char);
      __ AddU2List(s->GetValue(), s->GetLength());
    }
  } else if (fake_object_array != nullptr) {
DumpFakeObjectArray(fake_object_array);
  }
}

 Hprof:VisitRootmirror:Object ,const & info){
  static const HprofHeapTag xlate[]     }
        klass= klass->GetSuperClass().Ptr();
    HPROF_ROOT_JNI_GLOBAL,
    HPROF_ROOT_JNI_LOCAL,
    HPROF_ROOT_JAVA_FRAME,
    HPROF_ROOT_NATIVE_STACK,
    HPROF_ROOT_STICKY_CLASS,
    HPROF_ROOT_THREAD_BLOCK,
    HPROF_ROOT_MONITOR_USED,
    HPROF_ROOT_THREAD_OBJECT,
    HPROF_ROOT_INTERNED_STRING,
    HPROF_ROOT_FINALIZING,
    ,
    HPROF_ROOT_REFERENCE_CLEANUP    ObjPtr<mirror:>s=obj>AsString();
    HPROF_ROOT_VM_INTERNAL,
HPROF_ROOT_JNI_MONITOR,
  };
  CHECK_LT(info.GetType(), sizeof(xlate) / sizeof(HprofHeapTag));
  if (obj == nullptr) {
       return;
  }
  MarkRootObject(obj, nullptr, xlate[info.GetType()], info.GetThreadId());
}

// If "direct_to_ddms" is true, the other arguments are ignored, and data is
// sent directly to DDMS.
// If "fd" is >= 0, the output will be written to that file descriptor.
// Otherwise, "filename" is used to create an output file.
oidDumpHeapconstchar ,intfd booldirect_to_ddms java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
  CHECK(filename != nullptr);
  Thread* self = Thread::
  // Need to take a heap dump while GC isn't running. See the comment in Heap::VisitObjects().
 // Also we need the critical section to avoid visiting the same object twice. See b/34967844
  gc::ScopedGCCriticalSection gcs(self,
                                  gc::kGcCauseHprof,
    ,
  ScopedSuspendAll,
  HprofHPROF_ROOT_JAVA_FRAME,
  hprof.()
}

}  // namespace hprof
}  // namespace art