Changes to support dprof and Observatory profiler UIs

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 1800 matching lines @@
 intptr_t Class::FindFunctionIndex(const Function& needle) const {
   Isolate* isolate = Isolate::Current();
   if (EnsureIsFinalized(isolate) != Error::null()) {
     return -1;
   }
   ReusableHandleScope reused_handles(isolate);
   Array& funcs = reused_handles.ArrayHandle();
   funcs ^= functions();
   ASSERT(!funcs.IsNull());
   Function& function = reused_handles.FunctionHandle();
-  String& function_name = reused_handles.StringHandle();
-  String& needle_name = String::Handle(isolate);
-  needle_name ^= needle.name();
   const intptr_t len = funcs.Length();
   for (intptr_t i = 0; i < len; i++) {
     function ^= funcs.At(i);
-    function_name ^= function.name();
-    if (function_name.Equals(needle_name)) {
+    if (function.raw() == needle.raw()) {
       return i;
     }
   }
   // No function found.
   return -1;
 }
 
 
+RawFunction* Class::FunctionFromIndex(intptr_t idx) const {
+  const Array& funcs = Array::Handle(functions());
+  if ((idx < 0) || (idx >= funcs.Length())) {
+    return Function::null();
+  }
+  Function& func = Function::Handle();
+  func ^= funcs.At(idx);
+  ASSERT(!func.IsNull());
+  return func.raw();
+}
+
+
+RawFunction* Class::ImplicitClosureFunctionFromIndex(intptr_t idx) const {
+  const Array& funcs = Array::Handle(functions());
+  if ((idx < 0) || (idx >= funcs.Length())) {
+    return Function::null();
+  }
+  Function& func = Function::Handle();
+  func ^= funcs.At(idx);
+  ASSERT(!func.IsNull());
+  if (!func.HasImplicitClosureFunction()) {
+    return Function::null();
+  }
+  const Function& closure_func =
+      Function::Handle(func.ImplicitClosureFunction());
+  ASSERT(!closure_func.IsNull());
+  return closure_func.raw();
+}
+
+
+intptr_t Class::FindImplicitClosureFunctionIndex(const Function& needle) const {
+  Isolate* isolate = Isolate::Current();
+  if (EnsureIsFinalized(isolate) != Error::null()) {
+    return -1;
+  }
+  ReusableHandleScope reused_handles(isolate);
+  Array& funcs = reused_handles.ArrayHandle();
+  funcs ^= functions();
+  ASSERT(!funcs.IsNull());
+  Function& function = reused_handles.FunctionHandle();
+  Function& implicit_closure = Function::Handle();
+  const intptr_t len = funcs.Length();
+  for (intptr_t i = 0; i < len; i++) {
+    function ^= funcs.At(i);
+    implicit_closure ^= function.implicit_closure_function();
+    if (implicit_closure.IsNull()) {
+      // Skip non-implicit closure functions.
+      continue;
+    }
+    if (needle.raw() == implicit_closure.raw()) {
+      return i;
+    }
+  }
+  // No function found.
+  return -1;
+}
+
+
+
+intptr_t Class::FindInvocationDispatcherFunctionIndex(
+    const Function& needle) const {
+  Isolate* isolate = Isolate::Current();
+  if (EnsureIsFinalized(isolate) != Error::null()) {
+    return -1;
+  }
+  ReusableHandleScope reused_handles(isolate);
+  Array& funcs = reused_handles.ArrayHandle();
+  funcs ^= invocation_dispatcher_cache();
+  ASSERT(!funcs.IsNull());
+  Object& object = reused_handles.ObjectHandle();
+  const intptr_t len = funcs.Length();
+  for (intptr_t i = 0; i < len; i++) {
+    object = funcs.At(i);
+    // The invocation_dispatcher_cache is a table with some entries that
+    // are functions.
+    if (object.IsFunction()) {
+      if (Function::Cast(object).raw() == needle.raw()) {
+      return i;
+      }
+    }
+  }
+  // No function found.
+  return -1;
+}
+
+
+
+RawFunction* Class::InvocationDispatcherFunctionFromIndex(intptr_t idx) const {
+  ReusableHandleScope reused_handles(Isolate::Current());
+  Array& dispatcher_cache = reused_handles.ArrayHandle();
+  dispatcher_cache ^= invocation_dispatcher_cache();
+  Object& object = reused_handles.ObjectHandle();
+  object = dispatcher_cache.At(idx);
+  if (!object.IsFunction()) {
+    return Function::null();
+  }
+  return Function::Cast(object).raw();
+}
+
+
 void Class::AddClosureFunction(const Function& function) const {
   GrowableObjectArray& closures =
       GrowableObjectArray::Handle(raw_ptr()->closure_functions_);
   if (closures.IsNull()) {
     closures = GrowableObjectArray::New(4);
     StorePointer(&raw_ptr()->closure_functions_, closures.raw());
   }
   ASSERT(function.IsNonImplicitClosureFunction());
   closures.Add(function);
 }
@@ skipping 20 matching lines @@
       best_fit_token_pos = closure.token_pos();
     }
   }
   closure = Function::null();
   if (best_fit_index >= 0) {
     closure ^= closures.At(best_fit_index);
   }
   return closure.raw();
 }
 
-intptr_t Class::FindClosureIndex(intptr_t token_pos) const {
+intptr_t Class::FindClosureIndex(const Function& needle) const {
   if (closures() == GrowableObjectArray::null()) {
     return -1;
   }
   Isolate* isolate = Isolate::Current();
   ReusableHandleScope reused_handles(isolate);
   const GrowableObjectArray& closures_array =
       GrowableObjectArray::Handle(isolate, closures());
   Function& closure = reused_handles.FunctionHandle();
   intptr_t num_closures = closures_array.Length();
-  intptr_t best_fit_token_pos = -1;
-  intptr_t best_fit_index = -1;
   for (intptr_t i = 0; i < num_closures; i++) {
     closure ^= closures_array.At(i);
     ASSERT(!closure.IsNull());
-    if ((closure.token_pos() <= token_pos) &&
-        (token_pos <= closure.end_token_pos()) &&
-        (best_fit_token_pos < closure.token_pos())) {
-      best_fit_index = i;
-      best_fit_token_pos = closure.token_pos();
+    if (closure.raw() == needle.raw()) {
+      return i;
     }
   }
-  return best_fit_index;
+  return -1;
 }
 
 
+RawFunction* Class::ClosureFunctionFromIndex(intptr_t idx) const {
+  const GrowableObjectArray& closures_array =
+      GrowableObjectArray::Handle(closures());
+  if ((idx < 0) || (idx >= closures_array.Length())) {
+    return Function::null();
+  }
+  Function& func = Function::Handle();
+  func ^= closures_array.At(idx);
+  ASSERT(!func.IsNull());
+  return func.raw();
+}
+
+
 void Class::set_signature_function(const Function& value) const {
   ASSERT(value.IsClosureFunction() || value.IsSignatureFunction());
   StorePointer(&raw_ptr()->signature_function_, value.raw());
 }
 
 
 void Class::set_state_bits(intptr_t bits) const {
   raw_ptr()->state_bits_ = static_cast<uint16_t>(bits);
 }
 
@@ skipping 557 matching lines @@
     field_name ^= field.name();
     if (field_name.Equals(needle_name)) {
       return i;
     }
   }
   // No field found.
   return -1;
 }
 
 
+RawField* Class::FieldFromIndex(intptr_t idx) const {
+  const Array& flds = Array::Handle(fields());
+  if ((idx < 0) || (idx >= flds.Length())) {
+    return Field::null();
+  }
+  Field& field = Field::Handle();
+  field ^= flds.At(idx);
+  ASSERT(!field.IsNull());
+  return field.raw();
+}
+
+
 template <class FakeInstance>
 RawClass* Class::New(intptr_t index) {
   ASSERT(Object::class_class() != Class::null());
   Class& result = Class::Handle();
   {
     RawObject* raw = Object::Allocate(Class::kClassId,
                                       Class::InstanceSize(),
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
@@ skipping 1954 matching lines @@
 
 
 RawType* Function::RedirectionType() const {
   ASSERT(IsRedirectingFactory());
   const Object& obj = Object::Handle(raw_ptr()->data_);
   ASSERT(!obj.IsNull());
   return RedirectionData::Cast(obj).type();
 }
 
 
+const char* Function::KindToCString(RawFunction::Kind kind) {
+  switch (kind) {
+    case RawFunction::kRegularFunction:
+      return "kRegularFunction";
+      break;
+    case RawFunction::kClosureFunction:
+      return "kClosureFunction";
+      break;
+    case RawFunction::kSignatureFunction:
+      return "kSignatureFunction";
+      break;
+    case RawFunction::kGetterFunction:
+      return "kGetterFunction";
+      break;
+    case RawFunction::kSetterFunction:
+      return "kSetterFunction";
+      break;
+    case RawFunction::kConstructor:
+      return "kConstructor";
+      break;
+    case RawFunction::kImplicitGetter:
+      return "kImplicitGetter";
+      break;
+    case RawFunction::kImplicitSetter:
+      return "kImplicitSetter";
+      break;
+    case RawFunction::kImplicitStaticFinalGetter:
+      return "kImplicitStaticFinalGetter";
+      break;
+    case RawFunction::kStaticInitializer:
+      return "kStaticInitializer";
+      break;
+    case RawFunction::kMethodExtractor:
+      return "kMethodExtractor";
+      break;
+    case RawFunction::kNoSuchMethodDispatcher:
+      return "kNoSuchMethodDispatcher";
+      break;
+    case RawFunction::kInvokeFieldDispatcher:
+      return "kInvokeFieldDispatcher";
+      break;
+    default:
+      UNREACHABLE();
+      return NULL;
+  }
+}
+
+
 void Function::SetRedirectionType(const Type& type) const {
   ASSERT(IsFactory());
   Object& obj = Object::Handle(raw_ptr()->data_);
   if (obj.IsNull()) {
     obj = RedirectionData::New();
     set_data(obj);
   }
   RedirectionData::Cast(obj).set_type(type);
 }
 
@@ skipping 1240 matching lines @@
               static_str, abstract_str, kind_str, const_str);
   return chars;
 }
 
 
 void Function::PrintToJSONStream(JSONStream* stream, bool ref) const {
   const char* internal_function_name = String::Handle(name()).ToCString();
   const char* function_name =
       String::Handle(QualifiedUserVisibleName()).ToCString();
   Class& cls = Class::Handle(Owner());
+  ASSERT(!cls.IsNull());
   Error& err = Error::Handle();
   err ^= cls.EnsureIsFinalized(Isolate::Current());
   ASSERT(err.IsNull());
-  const Function& func = *this;
-  intptr_t id;
+  intptr_t id = -1;
+  const char* selector = NULL;
   if (IsNonImplicitClosureFunction()) {
-    id = cls.FindClosureIndex(token_pos());
+    id = cls.FindClosureIndex(*this);
+    selector = "closures";
+  } else if (IsImplicitClosureFunction()) {
+    id = cls.FindImplicitClosureFunctionIndex(*this);
+    selector = "implicit_closures";
+  } else if (IsNoSuchMethodDispatcher() || IsInvokeFieldDispatcher()) {
+    id = cls.FindInvocationDispatcherFunctionIndex(*this);
+    selector = "dispatchers";
   } else {
-    id = cls.FindFunctionIndex(func);
+    id = cls.FindFunctionIndex(*this);
+    selector = "functions";
   }
   ASSERT(id >= 0);
   intptr_t cid = cls.id();
   JSONObject jsobj(stream);
   jsobj.AddProperty("type", JSONType(ref));
-  if (IsNonImplicitClosureFunction()) {
-    jsobj.AddPropertyF("id", "classes/%" Pd "/closures/%" Pd "", cid, id);
-  } else {
-    jsobj.AddPropertyF("id", "classes/%" Pd "/functions/%" Pd "", cid, id);
-  }
+  jsobj.AddPropertyF("id", "classes/%" Pd "/%s/%" Pd "", cid, selector, id);
   jsobj.AddProperty("name", internal_function_name);
   jsobj.AddProperty("user_name", function_name);
   if (ref) return;
   jsobj.AddProperty("is_static", is_static());
   jsobj.AddProperty("is_const", is_const());
   jsobj.AddProperty("is_optimizable", is_optimizable());
   jsobj.AddProperty("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::kStaticInitializer:
-        kind_string = "static initializer";
-        break;
-      case RawFunction::kImplicitStaticFinalGetter:
-        kind_string = "static final getter";
-        break;
-      default:
-        UNREACHABLE();
-  }
+  const char* kind_string = Function::KindToCString(kind());
   jsobj.AddProperty("kind", kind_string);
   jsobj.AddProperty("unoptimized_code", Object::Handle(unoptimized_code()));
   jsobj.AddProperty("usage_counter", usage_counter());
   jsobj.AddProperty("optimized_call_site_count", optimized_call_site_count());
   jsobj.AddProperty("code", Object::Handle(CurrentCode()));
   jsobj.AddProperty("deoptimizations",
                     static_cast<intptr_t>(deoptimization_counter()));
 }
 
 
@@ skipping 3896 matching lines @@
   const intptr_t i = BinarySearchInSCallTable(pc);
   ASSERT(i >= 0);
   const Array& array =
       Array::Handle(raw_ptr()->static_calls_target_table_);
   ASSERT(code.IsNull() ||
          (code.function() == array.At(i + kSCallTableFunctionEntry)));
   array.SetAt(i + kSCallTableCodeEntry, code);
 }
 
 
-void Code::Disassemble() const {
+void Code::Disassemble(DisassemblyFormatter* formatter) const {
+  const bool fix_patch = CodePatcher::CodeIsPatchable(*this) &&
+                         CodePatcher::IsEntryPatched(*this);
+  if (fix_patch) {
+    // The disassembler may choke on illegal instructions if the code has been
+    // patched, un-patch the code before disassembling and re-patch after.
+    CodePatcher::RestoreEntry(*this);
+  }
   const Instructions& instr = Instructions::Handle(instructions());
   uword start = instr.EntryPoint();
-  Disassembler::Disassemble(start, start + instr.size(), comments());
+  if (formatter == NULL) {
+    Disassembler::Disassemble(start, start + instr.size(), comments());
+  } else {
+    Disassembler::Disassemble(start, start + instr.size(), formatter,
+                              comments());
+  }
+  if (fix_patch) {
+    // Redo the patch.
+    CodePatcher::PatchEntry(*this);
+  }
 }
 
 
 const Code::Comments& Code::comments() const  {
   Comments* comments = new Code::Comments(Array::Handle(raw_ptr()->comments_));
   return *comments;
 }
 
 
 void Code::set_comments(const Code::Comments& comments) const {
@@ skipping 161 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 {
-  Isolate* isolate = Isolate::Current();
-  ObjectIdRing* ring = isolate->object_id_ring();
-  intptr_t id = ring->GetIdForObject(raw());
   JSONObject jsobj(stream);
   jsobj.AddProperty("type", JSONType(ref));
-  jsobj.AddPropertyF("id", "objects/%" Pd "", id);
+  jsobj.AddPropertyF("id", "code/%" Px "", EntryPoint());
+  jsobj.AddPropertyF("start", "%" Px "", EntryPoint());
+  jsobj.AddPropertyF("end", "%" Px "", EntryPoint() + Size());
   Function& func = Function::Handle();
+  func ^= function();
+  ASSERT(!func.IsNull());
   String& name = String::Handle();
-  func ^= function();
   ASSERT(!func.IsNull());
   name ^= func.name();
   const char* internal_function_name = name.ToCString();
   jsobj.AddPropertyF("name", "%s%s", is_optimized() ? "*" : "",
                                      internal_function_name);
   name ^= func.QualifiedUserVisibleName();
   const char* function_name = name.ToCString();
   jsobj.AddPropertyF("user_name", "%s%s", is_optimized() ? "*" : "",
                                           function_name);
   if (ref) {
     return;
   }
   jsobj.AddProperty("is_optimized", is_optimized());
   jsobj.AddProperty("is_alive", is_alive());
   jsobj.AddProperty("function", Object::Handle(function()));
   JSONArray jsarr(&jsobj, "disassembly");
   DisassembleToJSONStream formatter(jsarr);
-  const Instructions& instr = Instructions::Handle(instructions());
-  uword start = instr.EntryPoint();
-  Disassembler::Disassemble(start, start + instr.size(), &formatter,
-                            comments());
+  Disassemble(&formatter);
 }
 
 
 uword Code::GetPatchCodePc() const {
   const PcDescriptors& descriptors = PcDescriptors::Handle(pc_descriptors());
   return descriptors.GetPcForKind(PcDescriptors::kPatchCode);
 }
 
 
 uword Code::GetLazyDeoptPc() const {
@@ skipping 6863 matching lines @@
   return "_MirrorReference";
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   Instance::PrintToJSONStream(stream, ref);
 }
 
 
 }  // namespace dart