Emit fake classes to please the third party HPROF tool infrastructure.

runtime/vm/heap_profiler.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/heap_profiler.h"
 
 #include "vm/dart_api_state.h"
 #include "vm/object.h"
 #include "vm/raw_object.h"
 #include "vm/stack_frame.h"
@@ skipping 101 matching lines @@
   record_->WriteObjectId(value);
 }
 
 
 HeapProfiler::HeapProfiler(Dart_FileWriteCallback callback, void* stream)
     : write_callback_(callback),
       output_stream_(stream),
       heap_dump_record_(NULL) {
   WriteHeader();
   WriteStackTrace();
+  WriteFakeLoadClass(kJavaLangClass, "java.lang.Class");
+  WriteFakeLoadClass(kJavaLangClassLoader, "java.lang.ClassLoader");
+  WriteFakeLoadClass(kJavaLangObject, "java.lang.Object");
+  WriteFakeLoadClass(kJavaLangString, "java.lang.String");
+  WriteFakeLoadClass(kArrayObject, "Object[]");
+  WriteFakeLoadClass(kArrayBoolean, "bool[]");
+  WriteFakeLoadClass(kArrayChar, "char[]");
+  WriteFakeLoadClass(kArrayFloat, "float[]");
+  WriteFakeLoadClass(kArrayDouble, "double[]");
+  WriteFakeLoadClass(kArrayByte, "byte[]");
+  WriteFakeLoadClass(kArrayShort, "short[]");
+  WriteFakeLoadClass(kArrayInt, "int[]");
+  WriteFakeLoadClass(kArrayLong, "long[]");
   heap_dump_record_ = new Record(kHeapDump, this);
+  WriteFakeClassDump(kJavaLangClass, static_cast<FakeClass>(0));
+  WriteFakeClassDump(kJavaLangClassLoader, kJavaLangObject);
+  WriteFakeClassDump(kJavaLangObject, static_cast<FakeClass>(0));
+  WriteFakeClassDump(kJavaLangString, kJavaLangObject);
 }
 
 
 HeapProfiler::~HeapProfiler() {
   delete heap_dump_record_;
 }
 
 
 const RawObject* HeapProfiler::ObjectId(const RawObject* raw_obj) {
   if (!raw_obj->IsHeapObject()) {
@@ skipping 274 matching lines @@
     const char* format = "<an unnamed class with id %d>";
     intptr_t len = OS::SNPrint(NULL, 0, format, raw_class->ptr()->id_);
     char* str = new char[len + 1];
     OS::SNPrint(str, len + 1, format, raw_class->ptr()->id_);
     record.WriteObjectId(StringId(str));
     delete[] str;
   }
 }
 
 
+void HeapProfiler::WriteFakeLoadClass(FakeClass fake_class,
+                                      const char* class_name) {
+  Record record(kLoadClass, this);
+  record.Write32(1);
+  record.WriteObjectId(reinterpret_cast<void*>(fake_class));
+  record.Write32(0);
+  record.WriteObjectId(StringId(class_name));
+}
+
+
 // STACK TRACE - 0x05
 //
 //  u4 - stack trace serial number
 //  u4 - thread serial number
 //  u4 - number of frames
 //  [ID]* - series of stack frame ID's
 void HeapProfiler::WriteStackTrace() {
   Record record(kStackTrace, this);
   // stack trace serial number
   record.Write32(0);
@@ skipping 132 matching lines @@
         ASSERT(raw_field->ptr()->name_ != String::null());
         // field name string ID
         sub.WriteObjectId(StringId(raw_field->ptr()->name_));
         // type of field
         sub.Write8(kObject);
       }
     }
   }
 }
 
+void HeapProfiler::WriteFakeClassDump(FakeClass fake_class,
+                                      FakeClass fake_super_class) {
+  SubRecord sub(kClassDump, this);
+  // class object ID
+  sub.WriteObjectId(reinterpret_cast<void*>(fake_class));
+  // stack trace serial number
+  sub.Write32(0);
+  // super class object ID
+  sub.WriteObjectId(reinterpret_cast<void*>(fake_super_class));
+  // class loader object ID
+  sub.WriteObjectId(NULL);
+  // signers object ID
+  sub.WriteObjectId(NULL);
+  // protection domain object ID
+  sub.WriteObjectId(NULL);
+  // reserved
+  sub.WriteObjectId(NULL);
+  // reserved
+  sub.WriteObjectId(NULL);
+  // instance size (in bytes)
+  sub.Write32(0);
+  // size of constant pool and number of records that follow:
+  sub.Write16(0);
+  // Number of static fields
+  sub.Write16(0);
+  // Number of instance fields (not include super class's)
+  sub.Write16(0);
+}
+
+
 
 // INSTANCE DUMP - 0x21
 //
 // Format:
 //  ID - object ID
 //  u4 - stack trace serial number
 //  ID - class object ID
 //  u4 - number of bytes that follow
 //  [value]* - instance field values (this class, followed by super class, etc)
 void HeapProfiler::WriteInstanceDump(const RawObject* raw_obj) {
@@ skipping 59 matching lines @@
 void HeapProfiler::WriteObjectArrayDump(const RawArray* raw_array) {
   SubRecord sub(kObjectArrayDump, this);
   // array object ID
   sub.WriteObjectId(raw_array);
   // stack trace serial number
   sub.Write32(0);
   // number of elements
   intptr_t length = Smi::Value(raw_array->ptr()->length_);
   sub.Write32(length);
   // array class object ID
-  sub.WriteObjectId(NULL);
+  sub.WriteObjectId(reinterpret_cast<void*>(kArrayObject));
   // elements
   for (intptr_t i = 0; i < length; ++i) {
     sub.WriteObjectId(ObjectId(raw_array->ptr()->data()[i]));
   }
 }
 
 
 // PRIMITIVE ARRAY DUMP - 0x23
 //
 // Format:
@@ skipping 60 matching lines @@
   RawObject* raw_obj = handle->raw();
   visitor_->VisitPointer(&raw_obj);
 }
 
 
 void HeapProfilerObjectVisitor::VisitObject(RawObject* raw_obj) {
   profiler_->WriteObject(raw_obj);
 }
 
 }  // namespace dart