Use special allocation functions for object creation while deserializing from a full snapshot in ...

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 2649 matching lines @@
       Class::Handle(Object::type_arguments_class());
   TypeArguments& result = TypeArguments::Handle();
   {
     RawObject* raw = Object::Allocate(type_arguments_class,
                                       TypeArguments::InstanceSize(len),
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
     // Length must be set before we start storing into the array.
     result.SetLength(len);
-    for (intptr_t i = 0; i < len; i++) {
-      *result.TypeAddr(i) = Type::null();
-    }
   }
   return result.raw();
 }
 
 
 
 RawAbstractType** TypeArguments::TypeAddr(intptr_t index) const {
   // TODO(iposva): Determine if we should throw an exception here.
   ASSERT((index >= 0) && (index < Length()));
   return &raw_ptr()->types_[index];
@@ skipping 4508 matching lines @@
 
   for (intptr_t i = 0; i < len; i++) {
     if (this->At(i) != other_arr.At(i)) {
       return false;
     }
   }
   return true;
 }
 
 
-RawArray* Array::New(word len, bool immutable, Heap::Space space) {
+RawArray* Array::New(intptr_t len, Heap::Space space) {
+  ObjectStore* object_store = Isolate::Current()->object_store();
+  Class& cls = Class::Handle(object_store->array_class());
+  return New(cls, len, space);
+}
+
+
+RawArray* Array::New(const Class& cls, intptr_t len, Heap::Space space) {
   if ((len < 0) || (len > kMaxArrayElements)) {
     // TODO(iposva): Should we throw an illegal parameter exception?
     UNIMPLEMENTED();
     return null();
   }
-
-  Isolate* isolate = Isolate::Current();
-  Class& cls = Class::Handle();
-  if (immutable) {
-    cls = isolate->object_store()->immutable_array_class();
-  } else {
-    cls = isolate->object_store()->array_class();
-  }
   Array& result = Array::Handle();
   {
     RawObject* raw = Object::Allocate(cls,
                                       Array::InstanceSize(len),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
     result.SetLength(len);
   }
   return result.raw();
@@ skipping 23 matching lines @@
   }
   return result.raw();
 }
 
 
 RawArray* Array::Empty() {
   return Isolate::Current()->object_store()->empty_array();
 }
 
 
+RawImmutableArray* ImmutableArray::New(intptr_t len,
+                                       Heap::Space space) {
+  ObjectStore* object_store = Isolate::Current()->object_store();
+  Class& cls = Class::Handle(object_store->immutable_array_class());
+  return reinterpret_cast<RawImmutableArray*>(Array::New(cls, len, space));
+}
+
+
 const char* ImmutableArray::ToCString() const {
   return "ImmutableArray";
 }
 
 
 RawByteBuffer* ByteBuffer::New(uint8_t* data,
                                intptr_t len,
                                Heap::Space space) {
   Isolate* isolate = Isolate::Current();
   const Class& byte_buffer_class =
@@ skipping 341 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