Wire GrowableArray to use the internal VM object.

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 "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
@@ skipping 439 matching lines @@
   object_store->set_empty_array(empty_array);
 
   // Re-initialize fields of the array class now that the empty array
   // has been created.
   cls.InitEmptyFields();
 
   // Set up the growable object array class (Has to be done after the array
   // class is setup as one of its field is an array object).
   cls = Class::New<GrowableObjectArray>();
   object_store->set_growable_object_array_class(cls);
+  cls.set_type_arguments_instance_field_offset(
+      GrowableObjectArray::type_arguments_offset());
 
   // Setup the symbol table used within the String class.
   const int kInitialSymbolTableSize = 16;
   array = Array::New(kInitialSymbolTableSize + 1);
   // Last element contains the count of used slots.
   array.SetAt(kInitialSymbolTableSize, Smi::Handle(Smi::New(0)));
   object_store->set_symbol_table(array);
 
   // canonical_type_arguments_ are NULL terminated.
   array = Array::New(4);
@@ skipping 44 matching lines @@
 
   cls = Class::New<Bool>();
   object_store->set_bool_class(cls);
   RegisterClass(cls, "Bool", impl_script, core_impl_lib);
   pending_classes.Add(cls, Heap::kOld);
 
   cls = object_store->array_class();  // Was allocated above.
   RegisterClass(cls, "ObjectArray", impl_script, core_impl_lib);
   pending_classes.Add(cls, Heap::kOld);
 
+  cls = object_store->growable_object_array_class();  // Was allocated above.
+  RegisterClass(cls, "GrowableObjectArray", impl_script, core_impl_lib);
+  pending_classes.Add(cls, Heap::kOld);
+
   cls = Class::New<ImmutableArray>();
   object_store->set_immutable_array_class(cls);
   cls.set_type_arguments_instance_field_offset(Array::type_arguments_offset());
   ASSERT(object_store->immutable_array_class() != object_store->array_class());
   RegisterClass(cls, "ImmutableArray", impl_script, core_impl_lib);
   pending_classes.Add(cls, Heap::kOld);
 
   cls = object_store->one_byte_string_class();  // Was allocated above.
   RegisterClass(cls, "OneByteString", impl_script, core_impl_lib);
   pending_classes.Add(cls, Heap::kOld);
@@ skipping 8027 matching lines @@
 
 const char* ImmutableArray::ToCString() const {
   return "ImmutableArray";
 }
 
 
 void GrowableObjectArray::Add(const Object& value, Heap::Space space) const {
   ASSERT(!IsNull());
   Array& contents = Array::Handle(data());
   if (Length() == Capacity()) {
-    intptr_t new_capacity = Capacity() * 2;
+    intptr_t new_capacity = (Capacity() == 0) ? 4 : Capacity() * 2;

[srdjan, 2012/04/06 21:19:51]

Capacity * 2 may be to-harsh. Adding one element to a 256k array creates a 512k
array... any plans there?

[siva, 2012/04/09 20:57:24]

I have opened a Bug to track this and figure out how we should increment the
capacity
(Issue 2500). Added a TODO here.

On 2012/04/06 21:19:51, srdjan wrote:

     if (new_capacity <= Capacity()) {
       // Use the preallocated out of memory exception to avoid calling
       // into dart code or allocating any code.
       const Instance& exception =
           Instance::Handle(Isolate::Current()->object_store()->out_of_memory());
       Exceptions::Throw(exception);
       UNREACHABLE();
     }
-    StorePointer(&(raw_ptr()->data_),
-                 Array::Grow(contents, new_capacity, space));
+    Grow(new_capacity, space);
     contents = data();
   }
   ASSERT(Length() < Capacity());
   intptr_t index = Length();
   SetLength(index + 1);
   contents.SetAt(index, value);
 }
 
 
+void GrowableObjectArray::Grow(intptr_t new_capacity, Heap::Space space) const {
+  ASSERT(new_capacity > Capacity());
+  Array& contents = Array::Handle(data());
+  StorePointer(&(raw_ptr()->data_),
+               Array::Grow(contents, new_capacity, space));
+}
+
+
 RawObject* GrowableObjectArray::RemoveLast() const {
   ASSERT(!IsNull());
   ASSERT(Length() > 0);
   intptr_t index = Length() - 1;
   const Array& contents = Array::Handle(data());
   const Object& obj = Object::Handle(contents.At(index));
   contents.SetAt(index, Object::Handle());
   SetLength(index);
   return obj.raw();
 }
@@ skipping 32 matching lines @@
     if (contents.At(i) != other_contents.At(i)) {
       return false;
     }
   }
   return true;
 }
 
 
 RawGrowableObjectArray* GrowableObjectArray::New(intptr_t capacity,
                                                  Heap::Space space) {
+  const Array& data = Array::Handle(Array::New(capacity, space));
+  return New(data, space);
+}
+
+
+RawGrowableObjectArray* GrowableObjectArray::New(const Array& array,
+                                                 Heap::Space space) {
   ObjectStore* object_store = Isolate::Current()->object_store();
   Class& cls = Class::Handle(object_store->growable_object_array_class());
-  const Array& data = Array::Handle(Array::New(capacity, space));
   GrowableObjectArray& result = GrowableObjectArray::Handle();
   {
     RawObject* raw = Object::Allocate(cls,
                                       GrowableObjectArray::InstanceSize(),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
     result.SetLength(0);
-    result.SetData(data);
+    result.SetData(array);
   }
   return result.raw();
 }
 
 
 const char* GrowableObjectArray::ToCString() const {
   return "GrowableObjectArray";
 }
 
 
@@ skipping 442 matching lines @@
   const String& str = String::Handle(pattern());
   const char* format = "JSRegExp: pattern=%s flags=%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags());
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len + 1));
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 }  // namespace dart