Changes to support dprof and Observatory profiler UIs

runtime/vm/service.cc

 // Copyright (c) 2013, 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/service.h"
 
 #include "vm/cpu.h"
 #include "vm/dart_entry.h"
 #include "vm/debugger.h"
 #include "vm/heap_histogram.h"
 #include "vm/isolate.h"
 #include "vm/message.h"
 #include "vm/object.h"
 #include "vm/object_id_ring.h"
 #include "vm/object_store.h"
 #include "vm/port.h"
+#include "vm/profiler.h"
 
 namespace dart {
 
 typedef void (*ServiceMessageHandler)(Isolate* isolate, JSONStream* stream);
 
 struct ServiceMessageHandlerEntry {
   const char* command;
   ServiceMessageHandler handler;
 };
 
@@ skipping 217 matching lines @@
     PrintError(js, "Must specify collection object id: %s/id", collection);    \
     return;                                                                    \
   }                                                                            \
   if ((id < 0) || (id >= length)) {                                            \
     PrintError(js, "%s id (%" Pd ") must be in [0, %" Pd ").", collection, id, \
                                                                length);        \
     return;                                                                    \
   }
 
 
-static bool GetIntegerId(const char* s, intptr_t* id) {
+static bool GetIntegerId(const char* s, intptr_t* id, int base = 10) {
   if ((s == NULL) || (*s == '\0')) {
     // Empty string.
     return false;
   }
   if (id == NULL) {
     // No id pointer.
     return false;
   }
   intptr_t r = 0;
   char* end_ptr = NULL;
-  r = strtol(s, &end_ptr, 10);
+  r = strtol(s, &end_ptr, base);
   if (end_ptr == s) {
     // String was not advanced at all, cannot be valid.
     return false;
+  }
+  *id = r;
+  return true;
+}
+
+
+static bool GetUnsignedIntegerId(const char* s, uintptr_t* id, int base = 10) {
+  if ((s == NULL) || (*s == '\0')) {
+    // Empty string.
+    return false;
+  }
+  if (id == NULL) {
+    // No id pointer.
+    return false;
+  }
+  uintptr_t r = 0;
+  char* end_ptr = NULL;
+  r = strtoul(s, &end_ptr, base);
+  if (end_ptr == s) {
+    // String was not advanced at all, cannot be valid.
+    return false;
   }
   *id = r;
   return true;
 }
 
 
 static void HandleClassesClosures(Isolate* isolate, const Class& cls,
                                   JSONStream* js) {
   const GrowableObjectArray& closures =
       GrowableObjectArray::Handle(cls.closures());
   intptr_t id;
   if (js->num_arguments() > 4) {
     PrintError(js, "Command too long");
     return;
   }
   CHECK_COLLECTION_ID_BOUNDS("closures", closures.Length(), js->GetArgument(3),
                              id, js);
   Function& function = Function::Handle();
   function ^= closures.At(id);
   ASSERT(!function.IsNull());
   function.PrintToJSONStream(js, false);
 }
 
 
+static void HandleClassesDispatchers(Isolate* isolate, const Class& cls,
+                                     JSONStream* js) {
+  intptr_t id;
+  if (js->num_arguments() > 4) {
+    PrintError(js, "Command too long");
+    return;
+  }
+  if (!GetIntegerId(js->GetArgument(3), &id)) {
+    PrintError(js, "Must specify collection object id: dispatchers/id");
+    return;
+  }
+  Function& func = Function::Handle();
+  func ^= cls.InvocationDispatcherFunctionFromIndex(id);
+  if (func.IsNull()) {
+    PrintError(js, "Dispatcher %" Pd " is not a function.", id);
+    return;
+  }
+  func.PrintToJSONStream(js, false);
+}
+
+
 static void HandleClassesFunctions(Isolate* isolate, const Class& cls,
-                                   JSONStream* js) {
+                                   JSONStream* js, bool implicit_closure) {
   const Array& functions =
       Array::Handle(cls.functions());
   intptr_t id;
   if (js->num_arguments() > 4) {
     PrintError(js, "Command too long");
     return;
   }
-  CHECK_COLLECTION_ID_BOUNDS("functions", functions.Length(),
-                             js->GetArgument(3), id, js);
+  if (implicit_closure) {
+    CHECK_COLLECTION_ID_BOUNDS("implicit_closures", functions.Length(),
+                               js->GetArgument(3), id, js);
+  } else {
+    CHECK_COLLECTION_ID_BOUNDS("functions", functions.Length(),
+                               js->GetArgument(3), id, js);
+  }
   Function& function = Function::Handle();
   function ^= functions.At(id);
   ASSERT(!function.IsNull());
-  function.PrintToJSONStream(js, false);
+  if (!implicit_closure) {
+    function.PrintToJSONStream(js, false);
+    return;
+  }
+  if (!function.HasImplicitClosureFunction()) {
+    PrintError(js, "Function %" Pd " does not have an implicit closure.", id);
+    return;
+  }
+  Function& closure_function = Function::Handle();
+  closure_function ^= function.ImplicitClosureFunction();
+  ASSERT(!closure_function.IsNull());
+  closure_function.PrintToJSONStream(js, false);
 }
 
 
 static void HandleClassesFields(Isolate* isolate, const Class& cls,
                                 JSONStream* js) {
   const Array& fields =
       Array::Handle(cls.fields());
   intptr_t id;
   if (js->num_arguments() > 4) {
     PrintError(js, "Command too long");
@@ skipping 29 matching lines @@
   if (js->num_arguments() == 2) {
     cls.PrintToJSONStream(js, false);
     return;
   } else if (js->num_arguments() >= 3) {
     const char* second = js->GetArgument(2);
     if (!strcmp(second, "closures")) {
       HandleClassesClosures(isolate, cls, js);
     } else if (!strcmp(second, "fields")) {
       HandleClassesFields(isolate, cls, js);
     } else if (!strcmp(second, "functions")) {
-      HandleClassesFunctions(isolate, cls, js);
+      HandleClassesFunctions(isolate, cls, js, false);
+    } else if (!strcmp(second, "implicit_closures")) {
+      HandleClassesFunctions(isolate, cls, js, true);
+    } else if (!strcmp(second, "dispatchers")) {
+      HandleClassesDispatchers(isolate, cls, js);
     } else {
       PrintError(js, "Invalid sub collection %s", second);
     }
     return;
   }
   UNREACHABLE();
 }
 
 
 static void HandleLibrary(Isolate* isolate, JSONStream* js) {
@@ skipping 146 matching lines @@
 }
 
 
 static void HandleCpu(Isolate* isolate, JSONStream* js) {
   JSONObject jsobj(js);
   jsobj.AddProperty("type", "CPU");
   jsobj.AddProperty("architecture", CPU::Id());
 }
 
 
+static void HandleCode(Isolate* isolate, JSONStream* js) {
+  REQUIRE_COLLECTION_ID("code");
+  uintptr_t pc;
+  if (!GetUnsignedIntegerId(js->GetArgument(1), &pc, 16)) {
+    PrintError(js, "Must specify code address: code/c0deadd0.");
+    return;
+  }
+  Code& code = Code::Handle(Code::LookupCode(pc));
+  if (code.IsNull()) {
+    PrintError(js, "Could not find code at %" Px "", pc);
+    return;
+  }
+  code.PrintToJSONStream(js, false);
+}
+
+
+static void HandleProfile(Isolate* isolate, JSONStream* js) {
+  Profiler::PrintToJSONStream(isolate, js, true);
+}
+
+
 static ServiceMessageHandlerEntry __message_handlers[] = {
   { "_echo", HandleEcho },
   { "classes", HandleClasses },
+  { "code", HandleCode },
   { "cpu", HandleCpu },
   { "debug", HandleDebug },
   { "libraries", HandleLibraries },
   { "library", HandleLibrary },
   { "name", HandleName },
   { "objecthistogram", HandleObjectHistogram},
   { "objects", HandleObjects },
+  { "profile", HandleProfile },
   { "scripts", HandleScripts },
   { "stacktrace", HandleStackTrace },
 };
 
 
 static void HandleFallthrough(Isolate* isolate, JSONStream* js) {
   JSONObject jsobj(js);
   jsobj.AddProperty("type", "Error");
   jsobj.AddProperty("text", "request not understood.");
   PrintArgumentsAndOptions(jsobj, js);
 }
 
 
 static ServiceMessageHandler FindServiceMessageHandler(const char* command) {
   intptr_t num_message_handlers = sizeof(__message_handlers) /
                                   sizeof(__message_handlers[0]);
   for (intptr_t i = 0; i < num_message_handlers; i++) {
     const ServiceMessageHandlerEntry& entry = __message_handlers[i];
     if (!strcmp(command, entry.command)) {
       return entry.handler;
     }
   }
   return HandleFallthrough;
 }
 
 }  // namespace dart