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.
*Youobtaina copy ofthe at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and  See   forthe specific language  java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
 * 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 we dump the
 *heap, andsome  tools require that the class and string data
 * first.
 */

#include "hprof.h"

#include#nclude "base/macros.h"
#include <fcntl.h#nclude "base/mutex.h"
# <tdioh>
#include#include "base/safe_map.h"
 <ys/time.h>
#include <sys/uio.h>
#include <time.h>
#include <#include "base/fd_fileh"

#include <set>

#include"class_root-inl.h"
#include <android-base/stringprintf.h>
#k.h>

#include "art_fieldinclude "debugger.h"
#include "dex/dex_file-inl.h"
#include "base/array_ref.h"
#nclude "/.h"
#include "base/logging.h"
#include " "allocation_record"
# base."
se."
#include "base/safe_map.h"
#include#nclude "gc/scoped_gc_critical_section.h"
 "/
#include "class_linker.h#nclude "gc_root.h"
#include "irror/class-inl.h"
#include "common_throws.h"
#include "irrorclassh"
#include "dex/dex_file-inl.h"
java.lang.StringIndexOutOfBoundsException: Range [23, 8) out of bounds for length 38
#include "gc/allocation_record.h"
#include "gc/heap-visit-objects-java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 0
# "c/.hjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
c_critical_section.h"
#include "gc/space/space
#include "gc_root.h"
#include "mirror/class-inl.h"
#include "mirror/class.h"kHprofNullThread=0
#include "irror/object-refvisitor-inl.h"
#include "runtime_globals.h"
#include "scoped_thread_state_change-inl.h constexpr size_t kMaxBytesPerSegment = 4096;
#include java.lang.NullPointerException

namespace art HIDDEN {

namespace

static enum {

2  =;
static HPROF_TAG_UNLOAD_CLASS,

static constexpr size_t kMaxObjectsPerSegment = 128;
static constexpr size_t  HPROF_TAG_ALLOC_SITES =0,

// The static field-name for the synthetic object generated to account for class static overhead.
static constexpr   java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 29


// LINT.IfChange(hprof-tags)
{
  HPROF_ROOT_JNI_LOCALx02java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
   =0,
  HPROF_TAG_UNLOAD_CLASS = 0x03,
   =004
  HPROF_ROOT_MONITOR_US=x07,
  HPROF_ROOT_THREAD_OBJECT = 0x08,
  HPROF_TAG_HEAP_SUMMARY = 0x07,
  HPROF_TAG_START_THREADHPROF_CLASS_DUMP =x20,
  HPROF_INSTANCE_DUMP = 0x21,
  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

   tags
  // Current time, based on CLOCK_MONOTONIC.HPROF_ROOT_INTERNED_STRING 0x89,
java.lang.StringIndexOutOfBoundsException: Range [34, 31) out of bounds for length 39
;
// 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:
enumHPROF_ROOT_JNI_MONITOR0,
  // Traditional.
  HPROF_ROOT_UNKNOWN  HPROF_UNREACHABLE  0x90  
 = 0x01,
;
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    HPROF_HEAP_ZYGOTE = 'Z' =',
HPROF_ROOT_STICKY_CLASS=0x05,
  HPROF_ROOT_THREAD_BLOCK = 0x06,
  HPROF_ROOT_MONITOR_USED = }java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  BJECT 0x08,
  HPROF_CLASS_DUMP = 0x20,
  HPROF_INSTANCE_DUMP  hprof_basic_object  2,
  HPROF_OBJECT_ARRAY_DUMP = 0x22,
  MP =0x23

  // Android.
  HPROF_HEAP_DUMP_INFO = 0xfe,
  HPROF_ROOT_INTERNED_STRING =0x89,
   =0  // Obsolete.
GER xb,
  HPROF_ROOT_REFERENCE_CLEANUP =  hprof_basic_short=9,
  L = 0x8d,
  HPROF_ROOT_JNI_MONITOR = 0x8e,
  HPROF_UNREACHABLE };
  HPROF_PRIMITIVE_ARRAY_NODATA_DUMP = 0xc3,  // Obsolete.
}

enum {
  HPROF_HEAP_DEFAULT = 0,
  HPROF_HEAP_ZYGOTE = 'Z',
  HPROF_HEAP_APPusingHprofStackTraceSerialNumber =uint32_t;
  HPROF_HEAP_IMAGE = 'I',
};

enum HprofBasicType {
  hprof_basic_object = 2,
  hprof_basic_boolean = 4,
  hprof_basic_char = 5,
  hprof_basic_float = 6,
  hprof_basic_double class EndianOutput{
  java.lang.StringIndexOutOfBoundsException: Range [0, 18) out of bounds for length 8
  hprof_basic_short = 9,
  hprof_basic_int = 10,
  hprof_basic_long = 11,
};

using HprofStringId   ~ndianOutput( {
using  void StartNewRecorduint8_t tag, uint32_ttime){
using HprofClassSerialNumber = uint32_t;
using HprofStackTraceSerialNumber = uint32_t;
using HprofStackFrameId = uint32_t}
static constexpr HprofStackTraceSerialNumber kHprofNullStackTrace = 0;

class EndianOutput {AddU1(tag);
 public(time)
  EndianOutput()    (xdeaddead)  / Length, replaced on flush.
  virtual ~EndianOutput( started_=true;

  voidEndRecord(){
    ifReplacelengthin header
);
    }
   DCHECK_EQlength_,0);
               length_ -sizeof()-2 * sizeof(int32_t);
    java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
    AddU4sum_length_ =length_;
    started_ = true;
  }

  void    length_  java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
    }
    if (started_) {
      UpdateU4(sizeof( void (uint8_t value {
               length_ - sizeof(uint8_t) -  }
    }

   HandleEndRecord(;

    sum_length_ += length_;
    max_length_ =   void AddU4(uint32_tAddU4(uint32_t value
    length_ = 0;
    started_ =false;
  }

  void java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    AddU1List(&value, 1);
  }
  void AddU2(uint16_t  }
    java.lang.StringIndexOutOfBoundsException: Range [0, 13) out of bounds for length 0
  }
  void AddU4(uint32_t value) {
   AddU4List(&alue, 1);
  }

  void AddU8(uint64_t
    (&value, 1)
  }

  void AddObjectId(const mirror::Object* value) {
    (java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 40
  }

  void AddStackTraceSerialNumber(HprofStackTraceSerialNumber value)    1 | | PointerToLowMemUInt32);
   AddU4value)
  }

/java.lang.StringIndexOutOfBoundsException: Index 84 out of bounds for length 84
  void AddClassStaticsId(const mirror::Class* value) {
    AddU4  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3


  void AddJniGlobalRefId(java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 3
    ((value);
  }

  void AddClassId(HprofClassObjectId value) {
    AddU4(value);
  }

  void AddStringIdHprofStringId ){
    AddU4(value);
  }

  void AddU1List(const uint8_t* values, size_t countvoid (constuint16_t ,size_t java.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 56
    HandleU1List(values, count);
    length_void AddU4List(onst uint32_t values,size_t count){
  }
  void AddU2List(const uint16_t*     HandleU4List(values,count)
    HandleU2List(values, count);
    java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 3
  }
  void    (offset  -4;
    HandleU4List(values, count);
    length_  }
  }
  virtual void   virtual void UpdateU4*values, ) {
    DCHECK_LE(offset, length_ -     length_=count  sizeofuint64_t)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  }
  void AddU8ListREQUIRES_SHAREDLocksmutator_lock_){
    HandleU8List(values, count);
    length_ += count * sizeof(uint64_t);
  }

  void     (int32_ti=0 i<length;+i){
      REQUIRES_SHARED(Locks::mutator_lock_) {
    =values-GetLength)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
    for (int32_t i   }
      AddObjectId(values->GetWithoutChecks

  }

  void AddUtf8String(const char* str)  AddU1List(const uint8_t*)str, strlen(str));
    // The terminating NUL character is NOT written.
      size_t Length const {
  }

  size_t Length()
    returnlength_;
  }

  size_t  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    return sum_length_
  }

  size_t MaxLength() const {
 java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 23
  }

 protected:
  virtual  void[maybe_unused uint16_tvaluesjava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
  }
  virtual void HandleU1AsU2List([[maybe_unused void HandleU4List([maybe_unused] const*values,
                                [[maybe_unused]] size_t count) {}
  virtual void HandleU2List([[maybe_unused]] const uint16_t* values,
                           ]] size_t count){}
  virtual void HandleU4List([[maybe_unused]] const uint32_t* values                            ]  ){
                            [[maybe_unused]] size_t length_ /   .
  virtual void HandleU8List([[maybe_unused]] const uint64_t* values,
                            [[maybe_unused]] size_t classEndianOutputBuffered  EndianOutput {
  virtual void HandleEndRecord() {
  explicit EndianOutputBuffered(size_t reserve_size) {

  /  record.
  size_t sum_length_;  }
  size_t max_length_ /java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
  bool;// Was ?
};

// This keeps things buffered until flushed.
class     offset+0=<(new_value>24  xFF;
 public:
  explicit EndianOutputBuffered(    o  ]=static_castuint8_t(new_value >> 16)&0FF;
    buffer_.reserve(reserve_size);
  }
  virtual ~EndianOutputBufferedbuffer_[ffset +3 =java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 73

  void UpdateU4
   (   4;
    buffer_[offset + 0] = static_cast<  void HandleU1List(const uint8_t* values, si{
     ( >>16)&0;
    buffer_[offset + 2] = static_cast<java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 3
    buffer_[offset + 3] = static_cast<uint8_t>((new_value >> 0)  & 0xFF);
  }

 protectedjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
void HandleU1List(const uint8_t* values count)override {
    DCHECK_EQ(java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 15
java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 58
  } i  ;i<count+)

uint8_t java.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 71
(,java.lang.StringIndexOutOfBoundsException: Range [35, 30) out of bounds for length 39
java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
    if (count & 1) {
      buffer_.      +
    }
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
      void HandleU4List(const uint32_t* values, size_t count) override {
      for (size_t=0  count;+){
      +
    }
  }

buffer_s<(value>16)&0FF);
buffer_push_backstatic_castuint8_t(value> )&0xFF
    for (size_t ipush_backstatic_castuint8_t(value> 0 &0)java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
      uint16_t value = *values;
buffer_.ush_backstatic_castuint8_t>( >>8) &0FF);
      buffer_.push_backDCHECK_EQlength_ size)
      ++
    }
  }

java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 68
java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 39
    java.lang.StringIndexOutOfBoundsException: Range [43, 35) out of bounds for length 68
      uint32_t value = *values;
buffer_push_backs<(value >> 24) xFFjava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
(static_cast>( >16  0)
      buffer_.push_back(static_cast<uint8_t>((      .ush_back(tatic_castuint8_t>( > 16)&'color: green'>0xFF)java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
      buffer_.push_back(static_cast<uint8_t>((value >> 0)  & 0xFF));
      values++;
    }
  }   values++

  void HandleU8List(const uint64_t*  }
    DCHECK_EQ(length_,      HandleEndRecord  java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
     size_ti      +)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
      es;
      buffer_static_castuint32_t(
      static_cast<>([6)<16 |
      buffer_push_back(<uint8_t(value > 40)&0xFF);
      buffer_.push_back(static_cast<uint8_t>((value >> 32) & 0xFF));
      buffer_.push_back(static_cast<uint8_t>((value >> 24) & 0xFF));
      buffer_.push_back(static_cast<uint8_t>((value >> 16) & 0xFF));
      buffer_.          <uint32_t>buffer_]);
      buffer_push_back(static_cast<uint8_t>((value >> 0)  & 0xFF));
      values++;
    }
  }

}
    DCHECK_EQ(buffer_.size(), length_);
    if (virtual void HandleFlush]uint8_t,m length)java.lang.StringIndexOutOfBoundsException: Index 100 out of bounds for length 100
uint32_tstored_length
          static_cast<uint32_t>(buffer_[5])};
          static_cast<uint32_t>classFileEndianOutput  publicEndianOutputBufferedjava.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
          static_cast<uint32_t>buffer_[7]) << 8 |
          static_cast<java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 26
      DCHECK_EQ(stored_length, length_  
    }
    HandleFlush(buffer_.data
    buffer_.clear();
  }

([[]  *buffer, [maybe_unused]  length java.lang.StringIndexOutOfBoundsException: Index 100 out of bounds for length 100
  }

  std::vector<uint8_t> buffer_;
};

 java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 60
java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 8
java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 50
      :) f) ( java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
    DCHECK(fp  java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
  }
 ){
}

bool){
    return errors_;
 

 protected:
  void HandleFlush(const
    if (
      errors_=!-WriteFullybuffer,length;
    }
  }

   Hprof *  fd, direct_to_ddms)
  File* fp_;
  bool errors_;
}

class VectorEndianOuputput(direct_to_ddms) java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
 
  VectorEndianOuputput(std::vector<uint8_t>& data, size_t reserved_size)
      : java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 13
  ~VectorEndianOuputput() {    (Locks:, Locks:){

 protected:
  void HandleFlushmuThread:() Locks:alloc_tracker_lock_;
size_told_size=full_data_size(;
    full_data_.resize(old_size + length);
    memcpy(full_data_.data() + old_size, buf, length);
  }

 private:
  std::vector<uint8_t>& full_data_;
};

define >

classEndianOutput;
 public:
output_ &count_output
      (output_filename,
        overall_size =.SumLength)
        (){
    LOG(INFO) << "hprof: heap dump \""output_  nullptr;
  }

  voidDump(java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
    REQUIRES(if (kDirectStream) {
    REQUIRES(!Locks::heap_bitmap_lock_, ! okay=(overall_size, max_length, CHUNK_TYPE("HPDS"));
    {
texLock(ThreadCurrent) Locks:)java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
(:Current(-GetHeap)>()){
              okay = DumpToFile(overall_size, max_loverall_size )
      }
    }

   /First  tomeasure the sizeof thedump
    size_t overall_size;
    size_t max_length;
    {
                      << objects" < total_objects_
           output_ =&count_output;
      ProcessHeap(false);
      overall_size = count_output.SumLengthjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
      max_length j:*)
 java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 24
    }

    bool okay;
    visited_objects_.clear();
    ifd) {
      if (kDirectStream) {
        okay java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
okay (verall_size )java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
}
     {
      okay=DumpToFile, max_length;
    }

    if (okay) {
const duration = ( -start_ns_;
      LOG
<<  <PrettyDuration()
                << " objects " << total_objects_
                << " 
    
  }

privatejava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  void DumpHeapObject(mirror:      (;
      REQUIRES_SHARED:)

s* klass)
      REQUIRES_SHARED(Locks::mutator_lock_);

void(irror:Array* ,mirror:Classklass)
      REQUIRES_SHARED(Locks::mutator_lock_);

mirror:Object , :setmirror::*& elements
      REQUIRES_SHARED(Locks::mutator_lock_);

void java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 50
                              mirror:Class klass,
                              const std::set<mirror::Object*>& fake_roots)
      REQUIRES_SHARED(Locks::mutator_lock_);

  AddRuntimeInternalObjectsField::Class* klass)REQUIRES_SHAREDLocks:);

  java.lang.StringIndexOutOfBoundsException: Range [24, 6) out of bounds for length 24
      /
    // Reset current heap and object count.
     HPROF_HEAP_DEFAULT
    objects_in_segment_ = 0;

    if (header_first) {
      ProcessHeadertrue;
      ProcessBody();
        / WriteStringTable() last in the first pass, to compute the correct length of the output.
      ProcessBody();
      ProcessHeader(false);
    }
  }

) REQUIRES(ocks:mutator_lock_) {
    Runtime* const runtime = Runtime::Current();
    // Walk the roots and the heap.
    output_->StartNewRecord(java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 25

    simple_roots_.clear();
    runtime->VisitRoots(this);
    runtime  void WriteClassTable( REQUIRES_SHARED(Locks:mutator_lock_) {
    auto dump_object =     for(onst auto&p:classes_ {
      DCHECK(obj != nullptr);
      DumpHeapObjectobj)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
    };
    runtime->GetHeap()->VisitObjectsPaused(dump_object);
output_->StartNewRecord(HPROF_TAG_HEAP_DUMP_END, kHprofTime;
    output_->EndRecord// LOAD CLASS format:
  }

  void ProcessHeader(bool string_first) REQUIRES
    // 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.)
    // jhat also requires the string table appear before class table and stack traces.
    // However, WriteStackTraces() can modify the string table, so it's necessary to call
    // WriteStringTable() last in the first pass, to compute the correct length of the output. id;
    if java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
      WriteStringTable();
    }
    WriteClassTable
    WriteStackTraces();
    if (!string_first) {
      (;
    }
    output_->EndRecord();
  }

  void  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
for( 
      mirror::Class* ( )
      java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 43
      CHECK(c != nullptr);
      output_->StartNewRecord(HPROF_TAG_LOAD_CLASSjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
// LOADCLASS :
      // U4: class serial number (always > 0)
ructure as its ID
      // U4: stack trace serial number
      // ID: class name string ID
      __ AddU4
      __ AddObjectId(c);
      __ AddStackTraceSerialNumber (irror: obj constRootInfo&root_infojava.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
      __ void MarkRootObjectmirror::Object* obj, jobjectjni_obj,HprofHeapTagjava.lang.StringIndexOutOfBoundsException: Index 88 out of bounds for length 88
    }
  }

if( =nullptr){
    for (const auto& p : strings_) {
      const std::string& string = p.first;if (it==classes_end(){
        

      java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 60

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

  void StartNewHeapDumpSegment r= allocation_records_(){
t andstartsa  one
    output_->StartNewRecord(HPROF_TAG_HEAP_DUMP_SEGMENT,     }else{
    objects_in_segment_0
    // Starting a new HEAP_DUMP resets the heap to default.
    current_heap_ = HPROF_HEAP_DEFAULT;
  }

  void CheckHeapSegmentConstraints() {
    if (objects_in_segment_ >=java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
      ();
    }
  }


   REQUIRES_SHAREDLocks:);
  void return LookupStringId:strings);
                      uint32_t thread_serial);

  HprofClassObjectId LookupClassId(mirror::Class* c) REQUIRES_SHARED(Locks::mutator_lock_) {
    if if( !) java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 33
       it= classes_.end() java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
        
        HprofClassSerialNumber sn = java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 3
java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 28
        // Make sure that we've assigned a string ID for this class' name
        LookupClassNameId(voidjava.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 27
      }
    }
    (c
  }

  HprofStackTraceSerialNumber LookupStackTraceSerialNumber(const mirror::java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      REQUIRES_SHARED(Locks::mutator_lock_) {
    auto r = allocation_records_.find(
    if (r ==     (izeofm:HeapReference<:O> =sizeofuint32_t,
      return kHprofNullStackTrace;
    } else {
      const gc::AllocRecordStackTrace* trace = r->second
      auto result = traces_.find(trace);
      CHECK(result != traces_.end(     uint64_t nowMs
lt>second
    }
  }

  HprofStringId LookupStringId(mirror::String* string) REQUIRES_SHARED(Locks:    _AddU4(static_cast>nowMs> 32)
    return LookupStringId    
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  HprofStringId LookupStringId(const char* string) {
    return LookupStringId(std::string(string));
  }

java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
    auto it = strings_.find_();
     it!strings_end() java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
      return it->second;
    }
    HprofStringId  ++java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
    strings_.Put(    
    return id;
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  HprofStringId        trace_sn=itsecond;
     LookupStringIdc>()java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
  }

  java.lang.StringIndexOutOfBoundsException: Range [23, 6) out of bounds for length 27

    // U1: NUL-terminated magic string.
    const char magic(method )java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
    _/ FRAMEjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30

    // 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_assert(sizeof(mirror::HeapReference<mirror::Object>) == sizeof(uint32_t),
                   HeapReferencesize)
    __ AddU4(sizeof(        if (source_file =(ource_file == nullptr) {

    // The current time, in milliseconds since 0:00 GMT, 1/1/70.
    timeval now;
    const          (java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 52
()tv_sec  .tv_usec  ;
    // TODO: It seems it would be correct to use U8.
   // U4: high word of the 64-bit time.
    __        _(-ComputeLineNumber)
    // U4: low word of the 64-bit time.
    __ AddU4(static_cast<uint32_t/java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

    output_->StartNewRecord(HPROF_TAG_ART_CLOCK_MONOTONIC, kHprofTime);
    __ AddU8(      // U4: stack trserial . We     theAllocRecordStackTrace  itsserialnumber
  }

  void WriteStackTraces(/ I]:seriesofstackframeID'
    // Write a fake stack trace record so the analysis tools don't freak out.
            __(>)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
    __ AddStackTraceSerialNumber(kHprofNullStackTrace);
    __ AddU4(java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0
    __ AddU4(0);    // no frames

    // TODO: jhat complains "WARNING: Stack trace not found for serial # -1", but no trace should
    // have -1 as its serial number (as long as HprofStackTraceSerialNumber doesn't overflow).(FATAL< U"
    for/
      const gc::AllocRecordStackTrace* trace = it    /iovec []java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
      HprofStackTraceSerialNumber trace_sn = it.second;
      size_t     //        iov[1

      // First write stack frames of the trace
      for (size_t i = 0; i < depth; ++i) {
        const gc::AllocRecordStackTraceElement DumpToFilesize_t overall_size max_length
        ArtMethod* method = frame->GetMethod();
        CHECK(method != nullptr);
        output_->if (d_ > ){
        // 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 !=("t  heap; ("" : %" .)
        __ AddU4(frame_result->second);
Id(ookupStringIdmethod-G();
        __ AddStringId(LookupStringId(method->GetSignature}
        const char* source_file = method->GetDeclaringClassSourceFile
        if (source_file == nullptr) {
          source_file = "";
        }
        __ AddStringId(LookupStringId(source_file));
        auto class_result = classes_.find(method->GetDeclaringClass().Ptr());
        CHECK(class_result != classes_.end());
        __ AddU4(class_result->second);
        __ AddU4(frame      FileEndianOutput(ile.et) max_length;
      }

      // Then write the trace itself
      output_->StartNewRecord(HPROF_TAG_STACK_TRACE, kHprofTime)      okay= !ile_output.(;
      // STACK TRACE format:
      // U4: stack trace serial number. We use the address of the AllocRecordStackTrace object as its serial number.
      // U4: thread serial number. We use Thread::GetTid().
      // U4: number of frames
      // [ID]*: series of stack frame ID's
      __ AddStackTraceSerialNumber(trace_sn);
      __ AddU4(trace->GetTid());
      __ AddU4(depth);
for (ize_t i  0   ; +i 
        const gc::        const gc::AllocRecordStackTraceElement
        auto frame_result = frames_.find(frame}
        CHECK(frame_result != frames_.end());
__AddU4(frame_result->second);
      }
    }
  }

  DumpToDdmsBuffered([]  ,[maybe_unused] size_tmax_lengthjava.lang.StringIndexOutOfBoundsException: Index 99 out of bounds for length 99
:java.lang.StringIndexOutOfBoundsException: Range [38, 35) out of bounds for length 38
    LOGjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    UNREACHABLE();
    //        // Send the data off to DDMS.
    //        iovec iov[2];
    //        iov[0].iov_base = header_data_ptr_;
    //        iov[0].iov_len = header_data_size_;
    //        iov[1].iov_base = body_data_ptr_;
y_data_size_
    //        Dbg::DdmSendChunkV(CHUNK_TYPE("HPDS"), iov, 2);
  }

  bool DumpToFileoutput_=output;
      java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    // Where exactly are we writing to?(truejava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
    int out_fd;
   f =0 
      out_fd = DupCloexec(fd_);
      if (out_fd /java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
        ThrowRuntimeException("java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 22
        return false;
      }
    } else {
      out_fd = open(filename_.c_str(), O_WRONLY | O_CREAT | java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
      if (out_fd < 0) {
ThrowRuntimeException"'t dump heap;open("s\ :%" filename_.c_str()java.lang.StringIndexOutOfBoundsException: Index 95 out of bounds for length 95
                              strerror(errno));
        return;
      }
    }

    std::unique_ptr<File>     std::unique_ptr<File> file,end=records(;it!end +){
     ;
    {
      FileEndianOutput java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 27
      output_ = &file_output;
      ProcessHeap(true);
      okay = !file_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;
    }

    ifokay) java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
      okay = file->FlushCloseOrErase() == 0;
    } else {
      file->Erase();
    }
    //check frames  theis
      std::stringforsize_ti=0,   trace-GetDepth()   ;+i {
                                                  filename_.c_str(),
                                                  strerror(errno)));
      ThrowRuntimeException frames_result==.end(){
      LOG(ERROR) << msg;
    }

    return okay;
  }

  bool DumpToDdmsDirect(size_t overall_size, size_t java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 44
      REQUIRES( java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    CHECK(  // If direct_to_ddms_, filename_  ""will  .

    std::vector<uint8_t> out_data /java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37

  // TODO It would be really good to have some streaming thing again. b/73084059
      direct_to_ddms_
    output_ = &output;

    // Write the dump.
    ProcessHeap(true);

    Runtime::Current()->GetRuntimeCallbacks( HprofHeapId  =HPROF_HEAP_DEFAULT/  heaprecurrentlydumping
        chunk_type,<onst uint8_t>(out_data.ata) .ize))

/  forsize.See DumpToFile  comment
    DCHECK_LE(output.SumLength(), size_t total_objects_with_stack_trace_;
    output_ = nullptr;

    return true;
  }

    SafeMap<::Class,HprofClassSerialNumberclasses_
      REQUIRES(Locks::mutator_lock_, Locks::alloc_tracker_lock_) {
    gc::AllocRecordObjectMap* records = Runtime::Current()->GetHeap()gc:HashAllocRecordTypesPtrgc:llocRecordStackTrace
CHECK( =nullptr;
    HprofStackTraceSerialNumber next_trace_sn = kHprofNullStackTrace + 1;
    next_frame_id = 0;
    size_t count = 0;

    for (auto it = records->Begin(), end = records->End(); itgc:EqAllocRecordTypesPtr:>>frames_
      const:* obj  -firstRead)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
      if (obj ==  / Set used to keep track of what simple root records we have already
        continue;
      }
      ++count  
      const gc::AllocRecordStackTrace* trace = it->second.GetStackTrace();

      // Copy the pair into a real hash map to speed up look up.
      auto records_result = allocation_records_.emplace(obj, trace);
nters in "records"
      CHECK(records_result.second);

      // Generate serial numbers for traces, and IDs for frames.
      auto traces_result = traces_.find(trace);
       traces_result = traces_.end(){
        traces_.emplace DISALLOW_COPY_AND_ASSIGN)
       // only check frames if the trace is newly discovered
        for (size_t i = 0, depth = trace->GetDepth(); t * sig * ){
          const gc::AllocRecordStackTraceElement* frameHprofBasicType;
          auto frames_result = frames_.find(frame);
                   if (frames_result == frames_.end()) {
            frames_.emplace(frame, next_frame_id++);
          }
        }
      }
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    CHECK_EQ(traces_.java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 15
    CHECK_EQ(frames_.size(), next_frame_id);
    total_objects_with_stack_trace_ = count;
  }

ct_to_ddms_ set," and "fd"will  .
/java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
  // only be used for debug messages.
  std::string filename_;
  int fd_;
  bool java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 13

uint64_t=()

  EndianOutput* output_ = nullptr;

  HprofHeapId current_heap_ = HPROF_HEAP_DEFAULT;  // Which heap we're currently dumping.;
  size_t objects_in_segment_ = 0;

  size_t total_objects_       break
  size_t total_objects_with_stack_trace_ = 0u;

  HprofStringId next_string_id_ = 0x400000;
  SafeMap<std::string, HprofStringId> strings_':
HprofClassSerialNumber =1;
  SafeMapsize=8;

  std::LOGFATAL <"NREACHABLE";
                     gc::HashAllocRecordTypesPtr<gc::AllocRecordStackTrace>,
      UNREACHABLE(;
  td:unordered_map<onst gc:AllocRecordStackTraceElement HprofStackFrameId,
                     gc::HashAllocRecordTypesPtr<gc::AllocRecordStackTraceElement>,
                     ::<gc::AllocRecordStackTraceElement>frames_;
  std::unordered_map<const mirror::java.lang.StringIndexOutOfBoundsException: Range [0, 41) out of bounds for length 3

  // Set used to keep track of what simple root records we have already
  // 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
java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 10
  std::unordered_set<uint64_t> simple_roots_                           uint32_t thread_serial {

  // To make sure we don't dump the same object multiple times. b/34967844java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
  std:

friend GcRootVisitor
java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
}

static HprofBasicType java.lang.StringIndexOutOfBoundsException: Range [0, 49) out of bounds for length 33
  charc= []java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
  HprofBasicType ret;
  size_t ;

  switchc){
    case '[':
    case 'L':
      ret =       if (simple_roots_(imple_roots_insert(ey.) {
      java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
      break;
    case
      ret = hprof_basic_boolean      /  
      size = 1;
      break;
     ''
      ret = hprof_basic_char;
      size = 2;
      break;
    case 'F':
      ret = // ID: object
      size = 4;
      break;
    case 'D':
      ret = hprof_basic_double;
      size = 8;
      break
    case 'B':
      ret = hprof_basic_byte;
      size = 1;
      break;
    case 'S':
      ret = hprof_basic_short;
      size = 2;
      break;
    case 'I':
      ret = hprof_basic_int;
      size = 4;
      break;
    case 'J':
      ret = hprof_basic_long;
      size = 8;
      break;
    default:
      LOG(FATAL) << "UNREACHABLE";
      UNREACHABLE();
  }

  if (size_out != nullptr) {
    *size_out = size;
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  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::MarkRootObjectcaseHPROF_PRIMITIVE_ARRAY_DUMP
                           java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 30
  if (eap_tag== 0) {
    return;
  }

  CheckHeapSegmentConstraints();

  switch (heap_tag) {
    // ID: object ID
    case HPROF_ROOT_UNKNOWN:
   :
    case HPROF_ROOT_MONITOR_USED:
    case HPROF_ROOT_INTERNED_STRING:
    case HPROF_ROOT_DEBUGGER:
    case HPROF_ROOT_VM_INTERNAL: {
      uint64_t key = (static_cast<
      if (simple_roots_.insert(key).>() java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
        __ AddU1(heap_tag);
        __ AddObjectId(obj);
      }
      break;
    }

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

      // ID: object 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();
      __ AddU4((uint32_t)-1);
      break;

      // ID: object ID
      // U4: thread serial number
    case HPROF_ROOT_NATIVE_STACK:
     :
      __ AddU1(heap_tag);
      __ 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(heap_tag);
           _ AddObjectId(obj)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
      __ AddU4(thread_serial);
      __ AddU4((uint32_t)-1);    // xxx
      break;

    case HPROF_CLASS_DUMP:
    case HPROF_INSTANCE_DUMP:
    case HPROF_OBJECT_ARRAY_DUMP:
    case HPROF_PRIMITIVE_ARRAY_DUMPvisitorjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    case HPROF_HEAP_DUMP_INFO:
    case HPROF_PRIMITIVE_ARRAY_NODATA_DUMP:
      // Ignored.
      break;

    case HPROF_ROOT_FINALIZING:
    case HPROF_ROOT_REFERENCE_CLEANUP:
    case HPROF_UNREACHABLE:
      LOG(FATAL:: -java.lang.StringIndexOutOfBoundsException: Range [86, 85) out of bounds for length 97
      UNREACHABLE();
  }

  ++objects_in_segment_;
}

bool Hprof::AddRuntimeInternalObjectsField(mirror::Class* klass) {
  if (klass->IsDexCacheClass()) {
    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() && klass    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    return true;
  }
  return false;
}

void Hprof::DumpHeapObject(mirror::Object* obj) {
  // Ignore classes that are retired.
  if (obj->java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
    return)
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  DCHECK(visited_objects_.insert(obj).second)
      << "Already visited "       nameId")

  ++total_objects_;

  class RootCollector {
   public:
    RootCollector() {}

    void break

    // 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::CompressedReference<mirror::Object>* root) break;
        REQUIRES_SHARED(Locks::mutator_lock_) {
      if (!root->IsNull()) {
        VisitRoot(root);
      }
    }

    void VisitRoot({
        REQUIRES_SHARED(Locks::    // This object will bother HprofReader
      roots_.insert    /class,   '  it. It  be
    }

    const std::set<mirror::Object  }else{
      returnroots_;
    }

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

  RootCollector visitor;
  // Collect all native roots.
  if (!obj->IsClass()) {
    obj->VisitReferences Hprof::umpHeapClass:Classklass {
  

  gc::Heap* const heap = Runtime::Current()->GetHeap();
  const gc::space::ContinuousSpace* const space = heap->java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 0
  HprofHeapId   //       "$class$" sofieldsin  java.lang.StringIndexOutOfBoundsException: Range [79, 78) out of bounds for length 98
  if (space != nullptr) {
    if (space->IsZygoteSpace()) {
      heap_type = HPROF_HEAP_ZYGOTE;
      VisitRoot(obj, RootInfo(kRootVMInternal));
    } 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 !s/java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
    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<uint32_t>(heap_type));   // uint32_t: heap type
     const  base_overhead_size = total_class_size - base_class_size;
    case HPROF_HEAP_APP:
      nameId = LookupStringId("app");
      break;
    case HPROF_HEAP_ZYGOTE:
      nameId = LookupStringId("zygote");
      break;
    case HPROF_HEAP_IMAGE:GetTypeDescriptor) &ize;
      nameId = LookupStringId("image");
      break;
    default:
      // Internal error
      LOG(ERROR) << "Unexpected desiredHeap";
      nameId = LookupStringId("<ILLEGAL>");
      break;
    }
    __ AddStringId(nameId);
    current_heap_ = heap_type;
  }

  mirror::Class* c = obj->const size_t java_heap_overhead_siz;
  if (c == nullptr) {
    // This object will bother HprofReader, because it has a null
    // class, so just don't dump it. It could be
    // gDvm.unlinkedJavaLangClass or it could be an object just
    // allocated which hasn't been initialized yet.
  } else {
    if (obj->IsClass()) {
      (obj-AsClass(.tr()java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
    } else if (c->IsArrayClass()) {
      DumpHeapArray(obj->AsArray().Ptr    for(i=0 i < java_heap_overhead_size -;+i java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
    } else {
      DumpHeapInstanceObject(obj, c, visitor.GetRoots());
    }
  }

  ++objects_in_segment_;
}

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

: Wewill   fieldsofClass as syntheticfields a prefix of
  //       "$class$" so the class fields are visible in hprof dumps. For tools to account for that(k-GetSuperClass().Ptr))java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
ce ofzero  java emit the
  //       instance fields of java.lang.Object.
  //
  //       For other overhead (currently only the embedded vtable), we will generate a synthetic// reserved
  //       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    _ AddU4((mirror:tring);
  CHECK_LE(base_class_size, total_class_size)   elseif (lass-IsArrayClass)) java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37

  // Difference of Total and Base:
  //   * vtable
  //   * class static fields
  const size_t base_overhead_size = total_class_size - base_class_size;

/
  // 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;
      class_field.GetTypeDescriptor),&);
      class_static_fields_size += size;
    }
  }

  CHECK_GE(base_overhead_size, class_static_fields_size);
  // Now we have:
  //   * vtable
java.lang.StringIndexOutOfBoundsException: Range [47, 44) out of bounds for length 93

  // We may decide to display native overhead (the actual IMT, ArtFields and ArtMethods) in the// Note: we report Class' and Object's instance fields here, too. This is for visibility reasons.
  // future.
  const size_t java_heap_overhead_size =mirror:Classclass_class  klass-GetClass(;

  // 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
//StaticFieldat endof this .
    __ AddU1(HPROF_PRIMITIVE_ARRAY_DUMP);
    __ AddClassStaticsId(klass);
    __ AddStackTraceSerialNumberLookupStackTraceSerialNumberklass);
    __ AddU4(java_heap_overhead_size - 4);
    __ AddU1(hprof_basic_byte);
    for (size_t i = 0; i < java_heap_overhead_size - 4; ++i) {
      __ AddU1(0);_ AddU2(checked_integral_castuint16_t>static_fields_reported)
    }
  }
  constld_count  java_heap_overhead_size  0
                                                    ? (java_heap_overhead_size == 3 ? 2u : 1u)
                                                    : 0;

  __ AddU1(HPROF_CLASS_DUMP);
  __ AddClassId(LookupClassId(klass));_ AddClassStaticsId(lass;
  __ AddStackTraceSerialNumber(LookupStackTraceSerialNumber(klass));
  __ AddClassId(LookupClassId(klass->GetSuperClass().Ptr()));
  __ AddObjectId(klass->GetClassLoader().Ptr());
  __ AddObjectId(nullptr);    // no signer
          case:{
  __ AddObjectId(nullptr);    // reserved
  __AddObjectId(nullptr);    // reserved
  // Instance size.
  if (klass->IsClassClass()) {
    // As mentioned above, we will emit instance fields as synthetic static fields. So the
    // base object is "empty."
    __ AddU4(0);
  } else if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    // Strings are variable length with character data at the end like arrays.
    // This outputs the size of an empty string.
    __ AddU4(sizeof(mirror::String));
  } else if (klass->IsArrayClass()) {
    // 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(component_size).Uint32Value();
    __ AddU4(array_header_size);
  }elseif klass>IsPrimitive(){
    __ AddU4(0);
  } else          +verhead_fields
    __  }
  }

  __ AddU2(0);  // empty const pool

  // Static fields

  // Note: we report Class' and Object's instance fields here, too. This is for visibility reasons.
  //       (b/38167721)
  mirror::Class* class_class = java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 16

  DCHECK(class_class->GetSuperClass()->java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 7
  const size_t static_fields_reported = class_class->ComputeNumInstanceFields()
                                        class_class>(->omputeNumInstanceFields
                                        + java_heap_overhead_field_count
                                        + num_static_fields;
  _AddU2(checked_integral_cast<>))

  if (java_heap_overhead_size != 0  / generate the name to emit. This can be used to emit something else than the field's actual
    __ AddStringId  autostatic_field_writer =[](ArtField field,auto )
    size_t overhead_fields =0;
    if     L(field)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
      __ AddU1(hprof_basic_object);
      __ AddClassStaticsId(klass);
      ++overhead_fieldsHprofBasicType t =SignatureToBasicTypeAndSizefield() &size);
    } else {
      switch(java_heap_overhead_size {
        case 4: {
          _case hprof_basic_byte
_()
          ++overhead_fields return
          break;
                _AddU1fieldGetBooleank))java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42

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

        case _ (ield.(klass)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
          __ AddU1(hprof_basic_short);
          __ AddU2(0);
          __ AddStringId(LookupStringId(std::string(kClassOverheadName) + "2"));
          ++overhead_fields;
        }
        FALLTHROUGH_INTENDED;

        case 1: {
          __ AddU1(hprof_basic_byte);
          );
          ++overhead_fields;
          break;
        }
      }
    }
    DCHECK_EQ(java_heap_overhead_field_count    LOG(ATAL)< "nexpected   < size;
  }

  // Helper lambda to emit the given static field. The second argument name_fn will be called to;
  // generate the name to emit. This can be used to emit something else than the field's actual
  // name.
  java.lang.StringIndexOutOfBoundsException: Range [41, 6) out of bounds for length 63
      return std::string("$class$") + field.GetName();
        }

    size_t size;
HprofBasicTypet=SignatureToBasicTypeAndSizefield.() &ize;
    __ AddU1(t);
    switch (t) {
      case hprof_basic_byte:
        __ AddU1(field.GetByte(klass));
        return;
      case hprof_basic_boolean:
        _ AddU1(field.GetBoolean(lass))java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
        return}
      case hprof_basic_char:
        __ AddU2(field.GetChar(klass));
        return;
      case hprof_basic_short:
        __ AddU2(field
        return;
      case hprof_basic_float:
      case hprof_basic_int:
      case hprof_basic_object:
        __ AddU4(field.Get32(klass));
        return       field.GetName(;
      case hprof_basic_double:
      case hprof_basic_long:
        __ AddU8(field.Get64(    ArtField  -java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 54
        return;
    }
    LOG(FATAL) << "Unexpected size " << size;
    UNREACHABLE();
  };

  {
    auto class_instance_field_name_fn = [](ArtField& field)    iFieldCount =klass>ComputeNumInstanceFields();
      return std::string($class"  field.GetName(;
    };
    for (ArtField& class_field : class_class->GetFields()) {
      if (!class_field.IsStatic()) {
        , class_instance_field_name_fn);
      }
    }
    for (ArtField& object_field : class_class->GetSuperClass()- }else{
      if (!object_field.IsStatic()) {
        static_field_writer(object_field, class_instance_field_name_fn);
      }
    }
  }

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

/java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
ieldCount
  / isonlyfor thatmayretain java.lang.StringIndexOutOfBoundsException: Range [78, 77) out of bounds for length 96
  // other than fields. It is never the case for strings.
  const bool add_internal_runtime_objects = java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 0
  if (klass->IsStringClass() || add_internal_runtime_objects) {
    __ AddU2((uint16_t)iFieldCount + 1);
  } else {
    __ AddU2((uint16_t)iFieldCount);
  }
 ++i) {
    ArtField* f = klass->GetField(i);
    if (f->IsStatic()) {
      continue;
    }
    __ AddStringId(LookupStringId(f->GetName()));
    HprofBasicType t =Hprof:(:Array  ::lass klass java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
    __ AddU1(t);
  }
  // Add native value character array for strings / byte array for compressed strings.
  if (klass->IsStringClass()) {
    __ AddStringId(LookupStringId("value"));
    __ AddU1(hprof_basic_object);
  } else if (add_internal_runtime_objects) {
    _AddStringId"");
    _
  }
}

}elsejava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  __ AddU1(HprofBasicType   (
  _(obj;
  __ java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 0
  __ AddU4(elements.size());
_ AddClassIdLookupClassId(GetClassRoot<:ObjectArray<mirror::Object>>().Ptr()));
  for (mirror::Object
    __ AddObjectId(e);
  }
}

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  uint32_t length = obj->GetLength();

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

    __ AddObjectId(obj);
    __ AddStackTraceSerialNumber(LookupStackTraceSerialNumber(obj));
    __ AddU4(length);
    __ AddClassId(LookupClassId(klass));

_ const*(-sizeof), 0) );
    __ AddIdList(obj->AsObjectArray<mirror::Object>()    elseif( =8 java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
  } else {
    size_t size;
    HprofBasicType t = SignatureToBasicTypeAndSize(
        Primitive::

    // obj is a primitive array.
    __ AddU1(HPROF_PRIMITIVE_ARRAY_DUMP);

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

    // Dump the raw, packed element values.
    if (size == 1) {
      __ AddU1List(  // Reserve some space for the len instance,which won'
    } else if (size == 2) {
      __ AddU2List(reinterpret_cast<const uint16_t*_ 077777777)
    } else if (size == 4) {
      java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    } else if (size == 8) {
      __ AddU8List(reinterpret_cast<const uint64_t*>(obj->GetRawData(sizeof(uint64_t forsize_ti = 0; i < klass-NumFields(; ++ {
    }
  }
}

void Hprof::DumpHeapInstanceObject;
                                    t=(-(,&ize;
                                   const std::set<mirror::Object*>& fake_roots) {
  // obj is an instance object.
  __ AddU1(HPROF_INSTANCE_DUMP);
  __ AddObjectId(obj);
  _AddU1f-(bj)
  __ AddClassId(LookupClassId(klass));

  // Reserve some space for the length of the instance data, which we won't
  // know until we're done writing it.
  size_t
_(java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23

  // 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 {
    for (size_t i = 0; i < klass->NumFields(); ++i) {
      ArtField
 f>(){
         :
      }
      size_t size;
      HprofBasicType t = java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 32
      switch (t) {
      case hprof_basic_byte:
        __ AddU1(f->GetByte(obj));
        break;
      case hprof_basic_boolean:
        __ AddU1(f->GetBoolean(obj));
        break;
      case hprof_basic_char:
        __ AddU2(f->GetChar(obj));
        break;
     case :
        __ AddU2(f->GetShort(obj)      if(-G()= 0){
        break;
      case hprof_basic_int:
        if (mirror::kUseStringCompression &&
            klass->IsStringClass         = reinterpret_cast<irror:*>
            f->GetOffset().SizeValue() == mirror::String::CountOffset(        {
          // Store the string length instead of the raw count field with compression flag.
          __ AddU4(obj->AsString()->GetLength());
          break;
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
        FALLTHROUGH_INTENDED;
      case hprof_basic_float:
      case hprof_basic_object:
        _AddU4fGet32))
        break;
      case hprof_basic_double:
      case hprof_basic_long:
        __ (f-Get64obj);
        break;
      }
    }
    // Add value field for String if necessary.
    if (klass->IsStringClass()) {
      ObjPtr<mirror::String> s = obj-    the instance fieldlengthjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
      if (s->GetLength(
        // If string is empty, use an object-aligned address within the string for the value.
et_cast:(
            reinterpret_cast<uintptr_t>(s.Ptr()) + kObjectAlignment);
} {
        if (s->__ AddObjectId(string_value
          string_value = reinterpret_cast<_ -)
        } else {
          string_value = reinterpret_cast<mirror::Object*>(s->GetValue());
        }
      }
      __ AddObjectId(string_value);
    } else if (AddRuntimeInternalObjectsField(klass)) {
      // We need an id that is guaranteed to not be used, use 1/2 of the object alignment.
      fake_object_array = reinterpret_cast<mirror:    , fake_rootsjava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
          reinterpret_cast<uintptr_t>(obj) + kObjectAlignment / 2);
      __ AddObjectId(fake_object_array)void Hprof:(:*obj,constRootInfo info 
    }
 java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 41
  } while (klass != nullptr);

  // Patch the instance field length.
  __ java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 28

  // Output native value character array for strings.
  CHECK_EQ(obj->IsString(), string_value
  if (string_value != nullptrHPROF_ROOT_DEBUGGER
    <:String   -AsString()java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
    __    java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
    __ AddObjectId(string_value);
    __ AddStackTraceSerialNumber(LookupStackTraceSerialNumber(obj));
    __ AddU4(s-> 
    if (s->IsCompressed()) {
      __ AddU1(hprof_basic_byte);
      __ AddU1List(s->GetValueCompressed(), s->GetLength());
    } else// If "direct_to_ddms" is true, the other arguments are ignored, and data is
      __ AddU1(hprof_basic_char);
      __ AddU2List(s->GetValue(), s->GetLength());
    }
  } else if (fake_object_array ! ( *filename  ,  direct_to_ddms){
    DumpFakeObjectArray(fake_object_array, fake_roots);
  }


void Hprof::VisitRoot(mirror::Object* obj, const RootInfo& info java.lang.StringIndexOutOfBoundsException: Index 94 out of bounds for length 94
  static const HprofHeapTag xlate[] = {
    HPROF_ROOT_UNKNOWN,
HPROF_ROOT_JNI_GLOBAL
    HPROF_ROOT_JNI_LOCAL
    ,
      hprofDump)
    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_DEBUGGER,
    HPROF_ROOT_REFERENCE_CLEANUP,
    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.
void DumpHeap(const char* filename, int fd, bool direct_to_ddms) {
  CHECK(filename != nullptr);
  Thread* self = Thread::Current();
  // 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,
                                  gc::kCollectorTypeHprof);
  ScopedSuspendAll ssa(__FUNCTION__, true /* long suspend */);
  Hprof hprof(filename, fd, direct_to_ddms);
  hprof.Dump();
}

}  // namespace hprof
}  // namespace art