VM: Avoid allocating strings when disassembling code.

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/become.h"
@@ skipping 11907 matching lines @@
                                             uword pc_offset) const {
   const Function& func =
       Function::Handle(FunctionForPCOffset(code, function, pc_offset));
   return func.script();
 }
 
 
 void CodeSourceMap::Dump(const CodeSourceMap& code_source_map,
                          const Code& code,
                          const Function& function) {
-  const String& code_name = String::Handle(code.QualifiedName());
-  THR_Print("Dumping Code Source Map for %s\n", code_name.ToCString());
+  const char* code_name = code.QualifiedName();
+  THR_Print("Dumping Code Source Map for %s\n", code_name);
   if (code_source_map.Length() == 0) {
     THR_Print("<empty>\n");
     return;
   }
 
   const int addr_width = kBitsPerWord / 4;
 
   Iterator iterator(code_source_map);
   Function& current_function = Function::Handle();
   Script& current_script = Script::Handle();
   TokenPosition tp;
   while (iterator.MoveNext()) {
     const uword pc_offset = iterator.PcOffset();
     tp = code_source_map.TokenPositionForPCOffset(pc_offset);
     current_function ^=
         code_source_map.FunctionForPCOffset(code, function, pc_offset);
     current_script ^=
         code_source_map.ScriptForPCOffset(code, function, pc_offset);
     if (current_function.IsNull() || current_script.IsNull()) {
       THR_Print("%#-*" Px "\t%s\t%s\n", addr_width,
                 pc_offset,
                 tp.ToCString(),
-                code_name.ToCString());
+                code_name);
       continue;
     }
     const String& uri = String::Handle(current_script.url());
     ASSERT(!uri.IsNull());
     THR_Print("%#-*" Px "\t%s\t%s\t%s\n", addr_width,
               pc_offset,
               tp.ToCString(),
               current_function.ToQualifiedCString(),
               uri.ToCString());
   }
@@ skipping 2474 matching lines @@
   Zone* zone = Thread::Current()->zone();
   if (IsStubCode()) {
     const char* name = StubCode::NameOfStub(UncheckedEntryPoint());
     return zone->PrintToString("[stub: %s]", name);
   } else {
     return zone->PrintToString("Code entry: 0x%" Px, UncheckedEntryPoint());
   }
 }
 
 
-RawString* Code::Name() const {
+const char* Code::Name() const {
   const Object& obj = Object::Handle(owner());
   if (obj.IsNull()) {
     // Regular stub.
     Thread* thread = Thread::Current();
     Zone* zone = thread->zone();
     const char* name = StubCode::NameOfStub(UncheckedEntryPoint());
     ASSERT(name != NULL);
     char* stub_name = OS::SCreate(zone,
         "%s%s", Symbols::StubPrefix().ToCString(), name);
-    return Symbols::New(thread, stub_name, strlen(stub_name));
+    return stub_name;
   } else if (obj.IsClass()) {
     // Allocation stub.
     Thread* thread = Thread::Current();
     Zone* zone = thread->zone();
     const Class& cls = Class::Cast(obj);
     String& cls_name = String::Handle(zone, cls.ScrubbedName());
     ASSERT(!cls_name.IsNull());
-    return Symbols::FromConcat(thread, Symbols::AllocationStubFor(), cls_name);
+    char* stub_name = OS::SCreate(zone,
+        "%s%s", Symbols::AllocationStubFor().ToCString(), cls_name.ToCString());
+    return stub_name;
   } else {
     ASSERT(obj.IsFunction());
     // Dart function.
-    return Function::Cast(obj).UserVisibleName();  // Same as scrubbed name.
+    // Same as scrubbed name.
+    return String::Handle(Function::Cast(obj).UserVisibleName()).ToCString();
   }
 }
 
 
-RawString* Code::QualifiedName() const {
+const char* Code::QualifiedName() const {
   const Object& obj = Object::Handle(owner());
   if (obj.IsFunction()) {
-    return Function::Cast(obj).QualifiedScrubbedName();
+    return String::Handle(
+        Function::Cast(obj).QualifiedScrubbedName()).ToCString();
   }
   return Name();
 }
 
 
 bool Code::IsAllocationStubCode() const {
   const Object& obj = Object::Handle(owner());
   return obj.IsClass();
 }
 
@@ skipping 1879 matching lines @@
                            name_visibility));
     pieces.Add(args_name);
   }
   // The name is only used for type checking and debugging purposes.
   // Unless profiling data shows otherwise, it is not worth caching the name in
   // the type.
   return Symbols::FromConcatAll(thread, pieces);
 }
 
 
-// Same as user visible name, but including the URI of each occuring type.
-// Used to report errors involving types with identical names.
-//
-// e.g.
-//   MyClass<String>     -> MyClass<String> where
-//                            MyClass is from my_uri
-//                            String is from dart:core
-//   MyClass<dynamic, T> -> MyClass<dynamic, T> where
-//                            MyClass is from my_uri
-//                            T of OtherClass is from other_uri
-//   (MyClass) => int    -> (MyClass) => int where
-//                            MyClass is from my_uri
-//                            int is from dart:core
-RawString* AbstractType::UserVisibleNameWithURI() const {
-  Thread* thread = Thread::Current();
-  Zone* zone = thread->zone();
-  GrowableHandlePtrArray<const String> pieces(zone, 3);
-  pieces.Add(String::Handle(zone, BuildName(kUserVisibleName)));
-  if (!IsDynamicType() && !IsVoidType()) {
-    pieces.Add(Symbols::SpaceWhereNewLine());
-    pieces.Add(String::Handle(zone, EnumerateURIs()));
-  }
-  return Symbols::FromConcatAll(thread, pieces);
-}
-
-
 RawString* AbstractType::ClassName() const {
   ASSERT(!IsFunctionType());
   if (HasResolvedTypeClass()) {
     return Class::Handle(type_class()).Name();
   } else {
     return UnresolvedClass::Handle(unresolved_class()).Name();
   }
 }
 
 
@@ skipping 4058 matching lines @@
   UNREACHABLE();
   return 0;
 }
 
 
 static int32_t MergeHexCharacters(int32_t c1, int32_t c2) {
   return GetHexValue(c1) << 4 | GetHexValue(c2);
 }
 
 
-RawString* String::EncodeIRI(const String& str) {
+const char* String::EncodeIRI(const String& str) {
   const intptr_t len = Utf8::Length(str);
   Zone* zone = Thread::Current()->zone();
   uint8_t* utf8 = zone->Alloc<uint8_t>(len);
   str.ToUTF8(utf8, len);
   intptr_t num_escapes = 0;
   for (int i = 0; i < len; ++i) {
     uint8_t byte = utf8[i];
     if (!IsURISafeCharacter(byte)) {
       num_escapes += 2;
     }
   }
-  const String& dststr = String::Handle(
-      OneByteString::New(len + num_escapes, Heap::kNew));
-  {
-    intptr_t index = 0;
-    for (int i = 0; i < len; ++i) {
-      uint8_t byte = utf8[i];
-      if (!IsURISafeCharacter(byte)) {
-        OneByteString::SetCharAt(dststr, index, '%');
-        OneByteString::SetCharAt(dststr, index + 1,
-                                 GetHexCharacter(byte >> 4));
-        OneByteString::SetCharAt(dststr, index + 2,
-                                 GetHexCharacter(byte & 0xF));
-        index += 3;
-      } else {
-        ASSERT(byte <= 127);
-        OneByteString::SetCharAt(dststr, index, byte);
-        index += 1;
-      }
+  intptr_t cstr_len = len + num_escapes + 1;
+  char* cstr = zone->Alloc<char>(cstr_len);
+  intptr_t index = 0;
+  for (int i = 0; i < len; ++i) {
+    uint8_t byte = utf8[i];
+    if (!IsURISafeCharacter(byte)) {
+      cstr[index++] = '%';
+      cstr[index++] = GetHexCharacter(byte >> 4);
+      cstr[index++] = GetHexCharacter(byte & 0xF);
+    } else {
+      ASSERT(byte <= 127);
+      cstr[index++] = byte;
     }
   }
-  return dststr.raw();
+  cstr[index] = '\0';
+  return cstr;
 }
 
 
 RawString* String::DecodeIRI(const String& str) {
   CodePointIterator cpi(str);
   intptr_t num_escapes = 0;
   intptr_t len = str.Length();
   {
     CodePointIterator cpi(str);
     while (cpi.Next()) {
@@ skipping 2513 matching lines @@
   return UserTag::null();
 }
 
 
 const char* UserTag::ToCString() const {
   const String& tag_label = String::Handle(label());
   return tag_label.ToCString();
 }
 
 }  // namespace dart