Support stacktrace and objecthistogram service commands

runtime/vm/object.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/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 13 matching lines @@
 #include "vm/deopt_instructions.h"
 #include "vm/disassembler.h"
 #include "vm/double_conversion.h"
 #include "vm/exceptions.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/growable_array.h"
 #include "vm/heap.h"
 #include "vm/intermediate_language.h"
 #include "vm/intrinsifier.h"
 #include "vm/longjump.h"
+#include "vm/object_id_ring.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/runtime_entry.h"
 #include "vm/scopes.h"
 #include "vm/stack_frame.h"
 #include "vm/symbols.h"
 #include "vm/timer.h"
 #include "vm/unicode.h"
 
 namespace dart {
@@ skipping 2749 matching lines @@
   const char* library_name = lib.IsNull() ? "" : lib.ToCString();
   const char* class_name = String::Handle(Name()).ToCString();
   intptr_t len = OS::SNPrint(NULL, 0, format, library_name, class_name) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, format, library_name, class_name);
   return chars;
 }
 
 
 void Class::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  const char* class_name = String::Handle(UserVisibleName()).ToCString();
+  ObjectIdRing* ring = Isolate::Current()->object_id_ring();
+  intptr_t id = ring->GetIdForObject(raw());
+  if (ref) {
+    stream->OpenObject();
+    stream->PrintProperty("type", "@Class");
+    stream->PrintProperty("id", id);
+    stream->PrintProperty("name", class_name);
+    stream->CloseObject();
+    return;
+  }
   stream->OpenObject();
+  stream->PrintProperty("type", "Class");
+  stream->PrintProperty("id", id);
+  stream->PrintProperty("name", class_name);
+  stream->PrintProperty("library", Object::Handle(library()));
   stream->CloseObject();
 }
 
 
 void Class::InsertCanonicalConstant(intptr_t index,
                                     const Instance& constant) const {
   // The constant needs to be added to the list. Grow the list if it is full.
   Array& canonical_list = Array::Handle(constants());
   const intptr_t list_len = canonical_list.Length();
   if (index >= list_len) {
@@ skipping 2139 matching lines @@
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, function_name,
                              static_str, abstract_str, kind_str, const_str) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, function_name,
               static_str, abstract_str, kind_str, const_str);
   return chars;
 }
 
 
 void Function::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  const char* function_name =
+      String::Handle(QualifiedUserVisibleName()).ToCString();
+  ObjectIdRing* ring = Isolate::Current()->object_id_ring();
+  intptr_t id = ring->GetIdForObject(raw());
+  if (ref) {
+    stream->OpenObject();
+    stream->PrintProperty("type", "@Function");
+    stream->PrintProperty("id", id);
+    stream->PrintProperty("name", function_name);
+    stream->CloseObject();
+    return;
+  }
   stream->OpenObject();
+  stream->PrintProperty("type", "Function");
+  stream->PrintProperty("name", function_name);
+  stream->PrintProperty("id", id);
+  stream->PrintPropertyBool("is_static", is_static());
+  stream->PrintPropertyBool("is_const", is_const());
+  stream->PrintPropertyBool("is_optimizable", is_optimizable());
+  stream->PrintPropertyBool("is_inlinable", IsInlineable());
+  const char* kind_string = NULL;
+  switch (kind()) {
+      case RawFunction::kRegularFunction:
+        kind_string = "regular";
+        break;
+      case RawFunction::kGetterFunction:
+        kind_string = "getter";
+        break;
+      case RawFunction::kSetterFunction:
+        kind_string = "setter";
+        break;
+      case RawFunction::kImplicitGetter:
+        kind_string = "implicit getter";
+        break;
+      case RawFunction::kImplicitSetter:
+        kind_string = "implicit setter";
+        break;
+      case RawFunction::kMethodExtractor:
+        kind_string = "method extractor";
+        break;
+      case RawFunction::kNoSuchMethodDispatcher:
+        kind_string = "no such method";
+        break;
+      case RawFunction::kClosureFunction:
+        kind_string = "closure";
+        break;
+      case RawFunction::kConstructor:
+        kind_string = "constructor";
+        break;
+      case RawFunction::kImplicitStaticFinalGetter:
+        kind_string = "static final getter";
+        break;
+      default:
+        UNREACHABLE();
+  }
+  stream->PrintProperty("kind", kind_string);
+  stream->PrintProperty("unoptimized_code", Object::Handle(unoptimized_code()));
+  stream->PrintProperty("usage_counter", usage_counter());
+  stream->PrintProperty("optimized_call_site_count",
+                        optimized_call_site_count());
+  stream->PrintProperty("code", Object::Handle(CurrentCode()));
+  stream->PrintProperty("deoptimizations",
+                        static_cast<intptr_t>(deoptimization_counter()));
   stream->CloseObject();
 }
 
 
 void ClosureData::set_context_scope(const ContextScope& value) const {
   StorePointer(&raw_ptr()->context_scope_, value.raw());
 }
 
 
 void ClosureData::set_implicit_static_closure(const Instance& closure) const {
@@ skipping 2210 matching lines @@
   const char* kFormat = "Library:'%s'";
   const String& name = String::Handle(url());
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, name.ToCString()) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, name.ToCString());
   return chars;
 }
 
 
 void Library::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  const char* library_name = String::Handle(name()).ToCString();
+  const char* library_url = String::Handle(url()).ToCString();
+  ObjectIdRing* ring = Isolate::Current()->object_id_ring();
+  intptr_t id = ring->GetIdForObject(raw());
+  if (ref) {
+    // Print a reference
+    stream->OpenObject();
+    stream->PrintProperty("type", "@Library");
+    stream->PrintProperty("id", id);
+    stream->PrintProperty("name", library_name);
+    stream->CloseObject();
+    return;
+  }
   stream->OpenObject();
+  stream->PrintProperty("type", "Library");
+  stream->PrintProperty("id", id);
+  stream->PrintProperty("name", library_name);
+  stream->PrintProperty("url", library_url);
+  ClassDictionaryIterator class_iter(*this);
+  stream->OpenArray("classes");
+  Class& klass = Class::Handle();
+  while (class_iter.HasNext()) {
+    klass = class_iter.GetNextClass();
+    stream->PrintValue(klass);
+  }
+  stream->CloseArray();
+  stream->OpenArray("libraries");
+  Library& lib = Library::Handle();
+  for (intptr_t i = 0; i < num_imports(); i++) {
+    lib = ImportLibraryAt(i);
+    stream->PrintValue(lib);
+  }
+  stream->CloseArray();
   stream->CloseObject();
 }
 
 
 RawLibrary* LibraryPrefix::GetLibrary(int index) const {
   if ((index >= 0) || (index < num_imports())) {
     const Array& imports = Array::Handle(this->imports());
     Namespace& import = Namespace::Handle();
     import ^= imports.At(index);
     return import.library();
@@ skipping 1392 matching lines @@
 const char* Code::ToCString() const {
   const char* kFormat = "Code entry:%p";
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, EntryPoint()) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, EntryPoint());
   return chars;
 }
 
 
 void Code::PrintToJSONStream(JSONStream* stream, bool ref) const {
+  ObjectIdRing* ring = Isolate::Current()->object_id_ring();
+  intptr_t id = ring->GetIdForObject(raw());
+  if (ref) {
+    stream->OpenObject();
+    stream->PrintProperty("type", "@Code");
+    stream->PrintProperty("id", id);
+    stream->CloseObject();
+    return;
+  }
   stream->OpenObject();
+  stream->PrintProperty("type", "Code");
+  stream->PrintProperty("id", id);
+  stream->PrintPropertyBool("is_optimized", is_optimized());
+  stream->PrintPropertyBool("is_alive", is_alive());
+  stream->PrintProperty("function", Object::Handle(function()));
+  stream->OpenArray("disassembly");
+  DisassembleToJSONStream formatter(stream);
+  const Instructions& instr = Instructions::Handle(instructions());
+  uword start = instr.EntryPoint();
+  Disassembler::Disassemble(start, start + instr.size(), &formatter,
+                            comments());
+  stream->CloseArray();
   stream->CloseObject();
 }
 
 
 uword Code::GetPatchCodePc() const {
   const PcDescriptors& descriptors = PcDescriptors::Handle(pc_descriptors());
   return descriptors.GetPcForKind(PcDescriptors::kPatchCode);
 }
 
 
@@ skipping 5797 matching lines @@
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   stream->OpenObject();
   stream->CloseObject();
 }
 
 
 }  // namespace dart