Save more memory by compacting LocalVarDescriptors

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 651 matching lines @@
     InitializeObject(address, kPcDescriptorsCid,
         PcDescriptors::InstanceSize(0, RawPcDescriptors::kCompressedRecSize));
     PcDescriptors::initializeHandle(
         empty_descriptors_,
         reinterpret_cast<RawPcDescriptors*>(address + kHeapObjectTag));
     empty_descriptors_->raw_ptr()->length_ = 0;
   }
 
   // Allocate and initialize the canonical empty variable descriptor object.
   {
-    uword address = heap->Allocate(
-        LocalVarDescriptors::InstanceSize(0), Heap::kOld);
-    InitializeObject(address, kLocalVarDescriptorsCid,
-        LocalVarDescriptors::InstanceSize(0));
+    uword address =
+        heap->Allocate(LocalVarDescriptors::InstanceSize(0), Heap::kOld);
+    InitializeObject(address,
+                     kLocalVarDescriptorsCid,
+                     LocalVarDescriptors::InstanceSize(0));
     LocalVarDescriptors::initializeHandle(
         empty_var_descriptors_,
         reinterpret_cast<RawLocalVarDescriptors*>(address + kHeapObjectTag));
-    empty_var_descriptors_->raw_ptr()->length_ = 0;
-    // Can't use instance mentod StorePointer() here, but this pointer
-    // assignment is safe (from old space to old space).
-    empty_var_descriptors_->raw_ptr()->names_ = empty_array_->raw_ptr();
+    empty_var_descriptors_->raw_ptr()->num_entries_ = 0;
   }
 
   cls = Class::New<Instance>(kDynamicCid);
   cls.set_is_abstract();
   cls.set_num_type_arguments(0);
   cls.set_num_own_type_arguments(0);
   cls.set_is_type_finalized();
   cls.set_is_finalized();
   dynamic_class_ = cls.raw();
 
@@ skipping 10100 matching lines @@
 }
 
 
 void Stackmap::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Object::PrintJSONImpl(stream, ref);
 }
 
 
 RawString* LocalVarDescriptors::GetName(intptr_t var_index) const {
   ASSERT(var_index < Length());
-  const Array& names = Array::Handle(raw_ptr()->names_);
-  ASSERT(Length() == names.Length());
-  String& name = String::Handle();
-  name ^= names.At(var_index);
-  return name.raw();
+  ASSERT(Object::Handle(*raw()->nameAddrAt(var_index)).IsString());
+  return *raw()->nameAddrAt(var_index);
 }
 
 
 void LocalVarDescriptors::SetVar(intptr_t var_index,
                                  const String& name,
                                  RawLocalVarDescriptors::VarInfo* info) const {
   ASSERT(var_index < Length());
-  const Array& names = Array::Handle(raw_ptr()->names_);
-  ASSERT(Length() == names.Length());
-  names.SetAt(var_index, name);
-  raw_ptr()->data()[var_index] = *info;
+  ASSERT(!name.IsNull());
+  StorePointer(raw()->nameAddrAt(var_index), name.raw());
+  raw()->data()[var_index] = *info;
 }
 
 
 void LocalVarDescriptors::GetInfo(intptr_t var_index,
                                   RawLocalVarDescriptors::VarInfo* info) const {
   ASSERT(var_index < Length());
-  *info = raw_ptr()->data()[var_index];
+  *info = raw()->data()[var_index];
 }
 
 
 static const char* VarKindString(int kind) {
   switch (kind) {
     case RawLocalVarDescriptors::kStackVar:
       return "StackVar";
       break;
     case RawLocalVarDescriptors::kContextVar:
       return "ContextVar";
@@ skipping 58 matching lines @@
 
 const char* LocalVarDescriptors::ToCString() const {
   if (IsNull()) {
     return "LocalVarDescriptors(NULL)";
   }
   intptr_t len = 1;  // Trailing '\0'.
   String& var_name = String::Handle();
   for (intptr_t i = 0; i < Length(); i++) {
     RawLocalVarDescriptors::VarInfo info;
     var_name = GetName(i);
-    if (var_name.IsNull()) {
-      var_name = Symbols::Empty().raw();
-    }
     GetInfo(i, &info);
     len += PrintVarInfo(NULL, 0, i, var_name, info);
   }
   char* buffer = Isolate::Current()->current_zone()->Alloc<char>(len + 1);
   buffer[0] = '\0';
   intptr_t num_chars = 0;
   for (intptr_t i = 0; i < Length(); i++) {
     RawLocalVarDescriptors::VarInfo info;
     var_name = GetName(i);
-    if (var_name.IsNull()) {
-      var_name = Symbols::Empty().raw();
-    }
     GetInfo(i, &info);
     num_chars += PrintVarInfo((buffer + num_chars),
                               (len - num_chars),
                               i, var_name, info);
   }
   return buffer;
 }
 
 
 void LocalVarDescriptors::PrintJSONImpl(JSONStream* stream,
                                         bool ref) const {
   JSONObject jsobj(stream);
   AddTypeProperties(&jsobj, "Object", JSONType(), ref);
   // TODO(johnmccutchan): Generate a stable id. LocalVarDescriptors hang off
   // a Code object but do not have a back reference to generate an ID.
   ObjectIdRing* ring = Isolate::Current()->object_id_ring();
   const intptr_t id = ring->GetIdForObject(raw());
   jsobj.AddPropertyF("id", "objects/%" Pd "", id);
   if (ref) {
     return;
   }
   Class& cls = Class::Handle(this->clazz());
   jsobj.AddProperty("class", cls);
   jsobj.AddProperty("size", raw()->Size());
   JSONArray members(&jsobj, "members");
   String& var_name = String::Handle();
   for (intptr_t i = 0; i < Length(); i++) {
     RawLocalVarDescriptors::VarInfo info;
     var_name = GetName(i);
-    if (var_name.IsNull()) {
-      var_name = Symbols::Empty().raw();
-    }
     GetInfo(i, &info);
     JSONObject var(&members);
     var.AddProperty("name", var_name.ToCString());
     var.AddProperty("index", static_cast<intptr_t>(info.index()));
     var.AddProperty("beginPos", static_cast<intptr_t>(info.begin_pos));
     var.AddProperty("endPos", static_cast<intptr_t>(info.end_pos));
     var.AddProperty("scopeId", static_cast<intptr_t>(info.scope_id));
     var.AddProperty("kind", KindToStr(info.kind()));
   }
 }
@@ skipping 26 matching lines @@
            num_variables, RawLocalVarDescriptors::kMaxIndex);
   }
   LocalVarDescriptors& result = LocalVarDescriptors::Handle();
   {
     uword size = LocalVarDescriptors::InstanceSize(num_variables);
     RawObject* raw = Object::Allocate(LocalVarDescriptors::kClassId,
                                       size,
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
-    result.raw_ptr()->length_ = num_variables;
+    result.raw_ptr()->num_entries_ = num_variables;
   }
-  const Array& names = (num_variables == 0) ? Object::empty_array() :
-      Array::Handle(Array::New(num_variables, Heap::kOld));
-  result.raw_ptr()->names_ = names.raw();
   return result.raw();
 }
 
 
 intptr_t LocalVarDescriptors::Length() const {
-  return raw_ptr()->length_;
+  return raw_ptr()->num_entries_;
 }
 
 
 intptr_t ExceptionHandlers::Length() const {
   return raw_ptr()->length_;
 }
 
 
 void ExceptionHandlers::SetHandlerInfo(intptr_t try_index,
                                        intptr_t outer_try_index,
@@ skipping 9334 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart