Tweaks to perf jitdump support

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 5794 matching lines @@
     }
   }
   return true;
 }
 
 
 // Helper allocating a C string buffer in the zone, printing the fully qualified
 // name of a function in it, and replacing ':' by '_' to make sure the
 // constructed name is a valid C++ identifier for debugging purpose.
 // Set 'chars' to allocated buffer and return number of written characters.
-static intptr_t ConstructFunctionFullyQualifiedCString(const Function& function,
-                                                       char** chars,
-                                                       intptr_t reserve_len,
-                                                       bool with_lib) {
+
+enum QualifiedFunctionLibKind {
+  kQualifiedFunctionLibKindLibUrl,
+  kQualifiedFunctionLibKindLibName
+};
+
+
+static intptr_t ConstructFunctionFullyQualifiedCString(
+    const Function& function,
+    char** chars,
+    intptr_t reserve_len,
+    bool with_lib,
+    QualifiedFunctionLibKind lib_kind = kQualifiedFunctionLibKindLibUrl) {

[siva, 2014/08/20 20:40:09]

instead of a default value for the param why not just pass this in.
There are only two call points for this function.

[Cutch, 2014/08/20 20:43:40]

Done.

   const char* name = String::Handle(function.name()).ToCString();
   const char* function_format = (reserve_len == 0) ? "%s" : "%s_";
   reserve_len += OS::SNPrint(NULL, 0, function_format, name);
   const Function& parent = Function::Handle(function.parent_function());
   intptr_t written = 0;
   if (parent.IsNull()) {
     const Class& function_class = Class::Handle(function.Owner());
     ASSERT(!function_class.IsNull());
     const char* class_name = String::Handle(function_class.Name()).ToCString();
     ASSERT(class_name != NULL);
     const Library& library = Library::Handle(function_class.library());
     ASSERT(!library.IsNull());
     const char* library_name = NULL;
     const char* lib_class_format = NULL;
     if (with_lib) {
-      library_name = String::Handle(library.url()).ToCString();
+      switch (lib_kind) {
+        case kQualifiedFunctionLibKindLibUrl:
+          library_name = String::Handle(library.url()).ToCString();
+          break;
+        case kQualifiedFunctionLibKindLibName:
+          library_name = String::Handle(library.name()).ToCString();
+          break;
+        default:
+          UNIMPLEMENTED();

[siva, 2014/08/20 20:40:09]

UNREACHABLE() instead of unimplemented?

[Cutch, 2014/08/20 20:43:41]

Done.

+      }
       ASSERT(library_name != NULL);
       lib_class_format = (library_name[0] == '\0') ? "%s%s_" : "%s_%s_";
     } else {
       library_name = "";
       lib_class_format = "%s%s.";
     }
     reserve_len +=
         OS::SNPrint(NULL, 0, lib_class_format, library_name, class_name);
     ASSERT(chars != NULL);
     *chars = Isolate::Current()->current_zone()->Alloc<char>(reserve_len + 1);
     written = OS::SNPrint(
         *chars, reserve_len + 1, lib_class_format, library_name, class_name);
   } else {
     written = ConstructFunctionFullyQualifiedCString(parent,
                                                      chars,
                                                      reserve_len,
-                                                     with_lib);
+                                                     with_lib,
+                                                     lib_kind);
   }
   ASSERT(*chars != NULL);
   char* next = *chars + written;
   written += OS::SNPrint(next, reserve_len + 1, function_format, name);
   // Replace ":" with "_".
   while (true) {
     next = strchr(next, ':');
     if (next == NULL) break;
     *next = '_';
   }
   return written;
 }
 
 
 const char* Function::ToFullyQualifiedCString() const {
   char* chars = NULL;
   ConstructFunctionFullyQualifiedCString(*this, &chars, 0, true);
   return chars;
 }
 
 
+const char* Function::ToLibNamePrefixedQualifiedCString() const {
+  char* chars = NULL;
+  ConstructFunctionFullyQualifiedCString(*this, &chars, 0, true,
+                                         kQualifiedFunctionLibKindLibName);
+  return chars;
+}
+
+
 const char* Function::ToQualifiedCString() const {
   char* chars = NULL;
   ConstructFunctionFullyQualifiedCString(*this, &chars, 0, false);
   return chars;
 }
 
 
 bool Function::HasCompatibleParametersWith(const Function& other,
                                            Error* bound_error) const {
   ASSERT(FLAG_error_on_bad_override);
@@ skipping 6119 matching lines @@
     }
   }
   code.set_comments(assembler->GetCodeComments());
   return code.raw();
 }
 
 
 RawCode* Code::FinalizeCode(const Function& function,
                             Assembler* assembler,
                             bool optimized) {
-  // Calling ToFullyQualifiedCString is very expensive, try to avoid it.
+  // Calling ToLibNamePrefixedQualifiedCString is very expensive,
+  // try to avoid it.
   if (CodeObservers::AreActive()) {
-    return FinalizeCode(function.ToFullyQualifiedCString(),
+    return FinalizeCode(function.ToLibNamePrefixedQualifiedCString(),
                         assembler,
                         optimized);
   } else {
     return FinalizeCode("", assembler);
   }
 }
 
 
 // Check if object matches find condition.
 bool Code::FindRawCodeVisitor::FindObject(RawObject* obj) const {
@@ skipping 7448 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart