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

vm/raw_object_snapshot.cc

-// Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
+// 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/bigint_operations.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/snapshot.h"
 #include "vm/visitor.h"
 
 namespace dart {
 
-static RawSmi* GetSmi(intptr_t value) {
+#define NEW_OBJECT(type)                                                       \
+  ((kind == Snapshot::kFull) ? reader->New##type() : type::New())
+
+#define NEW_OBJECT_WITH_LEN(type, len)                                         \
+  ((kind == Snapshot::kFull) ? reader->New##type(len) : type::New(len))
+
+
+static RawSmi* AsSmi(intptr_t value) {
   ASSERT((value & kSmiTagMask) == 0);
   return reinterpret_cast<RawSmi*>(value);
 }
 
 
+static intptr_t GetSmiValue(intptr_t value) {
+  return Smi::Value(AsSmi(value));
+}
+
+
 static uword ZoneAllocator(intptr_t size) {
   Zone* zone = Isolate::Current()->current_zone();
   return zone->Allocate(size);
 }
 
 
 RawClass* Class::ReadFrom(SnapshotReader* reader,
                           intptr_t object_id,
                           intptr_t tags,
                           Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   Class& cls = Class::ZoneHandle(reader->isolate(), Class::null());
   if ((kind == Snapshot::kFull) ||
       (kind == Snapshot::kScript && !RawObject::IsCreatedFromSnapshot(tags))) {
     // Read in the base information.
-    ObjectKind kind = reader->Read<ObjectKind>();
+    ObjectKind object_kind = reader->Read<ObjectKind>();
 
     // Allocate class object of specified kind.
-    cls = Class::GetClass(kind);
+    if (kind == Snapshot::kFull) {
+      cls = reader->NewClass(object_kind);
+    } else {
+      cls = Class::GetClass(object_kind);
+    }
     reader->AddBackwardReference(object_id, &cls);
 
     // Set the object tags.
     cls.set_tags(tags);
 
     // Set all non object fields.
     cls.set_instance_size(reader->ReadIntptrValue());
     cls.set_type_arguments_instance_field_offset(reader->ReadIntptrValue());
     cls.set_next_field_offset(reader->ReadIntptrValue());
     cls.set_num_native_fields(reader->ReadIntptrValue());
@@ skipping 52 matching lines @@
 }
 
 
 RawUnresolvedClass* UnresolvedClass::ReadFrom(SnapshotReader* reader,
                                               intptr_t object_id,
                                               intptr_t tags,
                                               Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   // Allocate parameterized type object.
-  UnresolvedClass& unresolved_class =
-      UnresolvedClass::ZoneHandle(reader->isolate(), UnresolvedClass::New());
+  UnresolvedClass& unresolved_class = UnresolvedClass::ZoneHandle(
+      reader->isolate(), NEW_OBJECT(UnresolvedClass));
   reader->AddBackwardReference(object_id, &unresolved_class);
 
   // Set the object tags.
   unresolved_class.set_tags(tags);
 
   // Set all non object fields.
   unresolved_class.set_token_index(reader->ReadIntptrValue());
 
   // Set all the object fields.
   // TODO(5411462): Need to assert No GC can happen here, even though
@@ skipping 43 matching lines @@
 }
 
 
 RawType* Type::ReadFrom(SnapshotReader* reader,
                         intptr_t object_id,
                         intptr_t tags,
                         Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   // Allocate parameterized type object.
-  Type& parameterized_type = Type::ZoneHandle(reader->isolate(), Type::New());
+  Type& parameterized_type = Type::ZoneHandle(
+      reader->isolate(), NEW_OBJECT(Type));
   reader->AddBackwardReference(object_id, &parameterized_type);
 
   // Set the object tags.
   parameterized_type.set_tags(tags);
 
   // Set all non object fields.
   parameterized_type.set_type_state(reader->Read<int8_t>());
 
   // Set all the object fields.
   // TODO(5411462): Need to assert No GC can happen here, even though
@@ skipping 32 matching lines @@
 }
 
 
 RawTypeParameter* TypeParameter::ReadFrom(SnapshotReader* reader,
                                           intptr_t object_id,
                                           intptr_t tags,
                                           Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   // Allocate type parameter object.
-  TypeParameter& type_parameter =
-      TypeParameter::ZoneHandle(reader->isolate(), TypeParameter::New());
+  TypeParameter& type_parameter = TypeParameter::ZoneHandle(
+          reader->isolate(), NEW_OBJECT(TypeParameter));
   reader->AddBackwardReference(object_id, &type_parameter);
 
   // Set the object tags.
   type_parameter.set_tags(tags);
 
   // Set all non object fields.
   type_parameter.set_index(reader->ReadIntptrValue());
   type_parameter.set_type_state(reader->Read<int8_t>());
 
   // Set all the object fields.
@@ skipping 92 matching lines @@
 }
 
 
 RawTypeArguments* TypeArguments::ReadFrom(SnapshotReader* reader,
                                           intptr_t object_id,
                                           intptr_t tags,
                                           Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   // Read the length so that we can determine instance size to allocate.
-  RawSmi* smi_len = GetSmi(reader->ReadIntptrValue());
-  intptr_t len = Smi::Value(smi_len);
+  intptr_t len = GetSmiValue(reader->ReadIntptrValue());
 
-  TypeArguments& type_arguments =
-      TypeArguments::ZoneHandle(reader->isolate(), TypeArguments::New(len));
+  TypeArguments& type_arguments = TypeArguments::ZoneHandle(
+      reader->isolate(), NEW_OBJECT_WITH_LEN(TypeArguments, len));
   reader->AddBackwardReference(object_id, &type_arguments);
 
   // Now set all the object fields.
   for (intptr_t i = 0; i < len; i++) {
     *reader->TypeHandle() ^= reader->ReadObject();
     type_arguments.SetTypeAt(i, *reader->TypeHandle());
   }
 
   // Set the object tags (This is done after setting the object fields
   // because 'SetTypeAt' has an assertion to check if the object is not
@@ skipping 79 matching lines @@
 
 
 RawFunction* Function::ReadFrom(SnapshotReader* reader,
                                 intptr_t object_id,
                                 intptr_t tags,
                                 Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   ASSERT(kind != Snapshot::kMessage && !RawObject::IsCreatedFromSnapshot(tags));
 
   // Allocate function object.
-  Function& func = Function::ZoneHandle(reader->isolate(), Function::New());
+  Function& func = Function::ZoneHandle(
+      reader->isolate(), NEW_OBJECT(Function));
   reader->AddBackwardReference(object_id, &func);
 
   // Set the object tags.
   func.set_tags(tags);
 
   // Set all the non object fields.
   func.set_token_index(reader->ReadIntptrValue());
   func.set_num_fixed_parameters(reader->ReadIntptrValue());
   func.set_num_optional_parameters(reader->ReadIntptrValue());
   func.set_invocation_counter(reader->ReadIntptrValue());
@@ skipping 45 matching lines @@
 
 
 RawField* Field::ReadFrom(SnapshotReader* reader,
                           intptr_t object_id,
                           intptr_t tags,
                           Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   ASSERT(kind != Snapshot::kMessage && !RawObject::IsCreatedFromSnapshot(tags));
 
   // Allocate field object.
-  Field& field = Field::ZoneHandle(reader->isolate(), Field::New());
+  Field& field = Field::ZoneHandle(reader->isolate(), NEW_OBJECT(Field));
   reader->AddBackwardReference(object_id, &field);
 
   // Set the object tags.
   field.set_tags(tags);
 
   // Set all non object fields.
   field.set_token_index(reader->ReadIntptrValue());
   field.set_is_static(reader->Read<bool>());
   field.set_is_final(reader->Read<bool>());
   field.set_has_initializer(reader->Read<bool>());
@@ skipping 35 matching lines @@
 
 
 RawTokenStream* TokenStream::ReadFrom(SnapshotReader* reader,
                                       intptr_t object_id,
                                       intptr_t tags,
                                       Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   ASSERT(kind != Snapshot::kMessage && !RawObject::IsCreatedFromSnapshot(tags));
 
   // Read the length so that we can determine number of tokens to read.
-  RawSmi* smi_len = GetSmi(reader->ReadIntptrValue());
-  intptr_t len = Smi::Value(smi_len);
+  intptr_t len = GetSmiValue(reader->ReadIntptrValue());
 
   // Create the token stream object.
-  TokenStream& token_stream = TokenStream::ZoneHandle(reader->isolate(),
-                                                      TokenStream::New(len));
+  TokenStream& token_stream = TokenStream::ZoneHandle(
+      reader->isolate(), NEW_OBJECT_WITH_LEN(TokenStream, len));
   reader->AddBackwardReference(object_id, &token_stream);
 
   // Set the object tags.
   token_stream.set_tags(tags);
 
   // Read the token stream into the TokenStream.
   for (intptr_t i = 0; i < len; i++) {
     Token::Kind kind = static_cast<Token::Kind>(
-        Smi::Value(GetSmi(reader->ReadIntptrValue())));
+        GetSmiValue(reader->ReadIntptrValue()));
     *reader->StringHandle() ^= reader->ReadObject();
     token_stream.SetTokenAt(i, kind, *reader->StringHandle());
   }
   return token_stream.raw();
 }
 
 
 void RawTokenStream::WriteTo(SnapshotWriter* writer,
                              intptr_t object_id,
                              Snapshot::Kind kind) {
@@ skipping 18 matching lines @@
 
 
 RawScript* Script::ReadFrom(SnapshotReader* reader,
                             intptr_t object_id,
                             intptr_t tags,
                             Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   ASSERT(kind != Snapshot::kMessage && !RawObject::IsCreatedFromSnapshot(tags));
 
   // Allocate script object.
-  Script& script = Script::ZoneHandle(reader->isolate(), Script::New());
+  Script& script = Script::ZoneHandle(reader->isolate(), NEW_OBJECT(Script));
   reader->AddBackwardReference(object_id, &script);
 
   // Set the object tags.
   script.set_tags(tags);
 
   // Set all the object fields.
   // TODO(5411462): Need to assert No GC can happen here, even though
   // allocations may happen.
   intptr_t num_flds = (script.raw()->to() - script.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
@@ skipping 33 matching lines @@
   Library& library = Library::ZoneHandle(reader->isolate(), Library::null());
   reader->AddBackwardReference(object_id, &library);
 
   if (RawObject::IsCreatedFromSnapshot(tags)) {
     ASSERT(kind != Snapshot::kFull);
     // Lookup the object as it should already exist in the heap.
     *reader->StringHandle() ^= reader->ReadObject();
     library = Library::LookupLibrary(*reader->StringHandle());
   } else {
     // Allocate library object.
-    library = Library::New();
+    library = NEW_OBJECT(Library);
 
     // Set the object tags.
     library.set_tags(tags);
 
     // Set all non object fields.
     library.raw_ptr()->num_imports_ = reader->ReadIntptrValue();
     library.raw_ptr()->num_imported_into_ = reader->ReadIntptrValue();
     library.raw_ptr()->num_anonymous_ = reader->ReadIntptrValue();
     library.raw_ptr()->corelib_imported_ = reader->Read<bool>();
     library.raw_ptr()->load_state_ = reader->Read<int8_t>();
@@ skipping 50 matching lines @@
 
 
 RawLibraryPrefix* LibraryPrefix::ReadFrom(SnapshotReader* reader,
                                           intptr_t object_id,
                                           intptr_t tags,
                                           Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   ASSERT(kind != Snapshot::kMessage && !RawObject::IsCreatedFromSnapshot(tags));
 
   // Allocate library prefix object.
-  LibraryPrefix& prefix = LibraryPrefix::ZoneHandle(reader->isolate(),
-                                                    LibraryPrefix::New());
+  LibraryPrefix& prefix = LibraryPrefix::ZoneHandle(
+      reader->isolate(), NEW_OBJECT(LibraryPrefix));
   reader->AddBackwardReference(object_id, &prefix);
 
   // Set the object tags.
   prefix.set_tags(tags);
 
   // Set all the object fields.
   // TODO(5411462): Need to assert No GC can happen here, even though
   // allocations may happen.
   intptr_t num_flds = (prefix.raw()->to() - prefix.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
@@ skipping 19 matching lines @@
   // Write out all the object pointer fields.
   SnapshotWriterVisitor visitor(writer);
   visitor.VisitPointers(from(), to());
 }
 
 
 RawCode* Code::ReadFrom(SnapshotReader* reader,
                         intptr_t object_id,
                         intptr_t tags,
                         Snapshot::Kind kind) {
-  ASSERT(reader != NULL);
-  ASSERT(kind != Snapshot::kMessage);
-
-  // Create Code object.
-  Code& code = Code::ZoneHandle(reader->isolate(), Code::New(0));
-  reader->AddBackwardReference(object_id, &code);
-  return code.raw();
+  UNREACHABLE();
+  return Code::null();
 }
 
 
 void RawCode::WriteTo(SnapshotWriter* writer,
                       intptr_t object_id,
                       Snapshot::Kind kind) {
   // Currently we do not serialize any code and hence we write
   // out a null object for it.
   ASSERT(writer != NULL);
   ASSERT(kind != Snapshot::kMessage);
@@ skipping 67 matching lines @@
 
 
 RawContext* Context::ReadFrom(SnapshotReader* reader,
                               intptr_t object_id,
                               intptr_t tags,
                               Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   // Allocate context object.
   intptr_t num_vars = reader->ReadIntptrValue();
-  Context& context = Context::ZoneHandle(
-      reader->isolate(),
-      Context::New(num_vars,
-                   (kind == Snapshot::kFull) ? Heap::kOld : Heap::kNew));
+  Context& context = Context::ZoneHandle(reader->isolate(), Context::null());
+  if (kind == Snapshot::kFull) {
+    context = reader->NewContext(num_vars);
+  } else {
+    context = Context::New(num_vars);
+  }
   reader->AddBackwardReference(object_id, &context);
 
   // Set the object tags.
   context.set_tags(tags);
 
   // Set the isolate implicitly.
   context.set_isolate(Isolate::Current());
 
   // Set all the object fields.
   // TODO(5411462): Need to assert No GC can happen here, even though
@@ skipping 178 matching lines @@
                         intptr_t object_id,
                         intptr_t tags,
                         Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   // Read the 64 bit value for the object.
   int64_t value = reader->Read<int64_t>();
 
   // Create a Mint object or get canonical one if it is a canonical constant.
   Mint& mint = Mint::ZoneHandle(reader->isolate(), Mint::null());
-  if ((kind != Snapshot::kFull) && RawObject::IsCanonical(tags)) {
-    mint = Mint::NewCanonical(value);
+  if (kind == Snapshot::kFull) {
+    mint = reader->NewMint(value);
   } else {
-    mint = Mint::New(value,
-                     (kind == Snapshot::kFull) ? Heap::kOld : Heap::kNew);
+    if (RawObject::IsCanonical(tags)) {
+      mint = Mint::NewCanonical(value);
+    } else {
+      mint = Mint::New(value, Heap::kNew);
+    }
   }
   reader->AddBackwardReference(object_id, &mint);
 
   // Set the object tags.
   mint.set_tags(tags);
 
   return mint.raw();
 }
 
 
@@ skipping 69 matching lines @@
 RawDouble* Double::ReadFrom(SnapshotReader* reader,
                             intptr_t object_id,
                             intptr_t tags,
                             Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   // Read the double value for the object.
   double value = reader->Read<double>();
 
   // Create a Double object or get canonical one if it is a canonical constant.
   Double& dbl = Double::ZoneHandle(reader->isolate(), Double::null());
-  if ((kind != Snapshot::kFull) && RawObject::IsCanonical(tags)) {
-    dbl = Double::NewCanonical(value);
+  if (kind == Snapshot::kFull) {
+    dbl = reader->NewDouble(value);
   } else {
-    dbl = Double::New(value,
-                      (kind == Snapshot::kFull) ? Heap::kOld : Heap::kNew);
+    if (RawObject::IsCanonical(tags)) {
+      dbl = Double::NewCanonical(value);
+    } else {
+      dbl = Double::New(value, Heap::kNew);
+    }
   }
   reader->AddBackwardReference(object_id, &dbl);
 
   // Set the object tags.
   dbl.set_tags(tags);
 
   return dbl.raw();
 }
 
 
@@ skipping 23 matching lines @@
 
 
 void RawString::WriteTo(SnapshotWriter* writer,
                         intptr_t object_id,
                         Snapshot::Kind kind) {
   UNREACHABLE();  // String is an abstract class.
 }
 
 
 template<typename HandleType, typename CharacterType>
-RawString* String::ReadFromImpl(SnapshotReader* reader,
-                                intptr_t object_id,
-                                intptr_t tags,
-                                Snapshot::Kind kind) {
+void String::ReadFromImpl(SnapshotReader* reader,
+                          HandleType* str_obj,
+                          intptr_t len,
+                          intptr_t tags) {
   ASSERT(reader != NULL);
-  // Read the length so that we can determine instance size to allocate.
-  RawSmi* smi_len = GetSmi(reader->ReadIntptrValue());
-  intptr_t len = Smi::Value(smi_len);
-  RawSmi* smi_hash = GetSmi(reader->ReadIntptrValue());
-
-  HandleType& str_obj = HandleType::ZoneHandle(reader->isolate(),
-                                               HandleType::null());
-  if (kind != Snapshot::kFull && RawObject::IsCanonical(tags)) {
+  if (RawObject::IsCanonical(tags)) {
+    // Set up canonical string object.
+    ASSERT(reader != NULL);
     CharacterType* ptr = reinterpret_cast<CharacterType*>(ZoneAllocator(len));
     for (intptr_t i = 0; i < len; i++) {
       ptr[i] = reader->Read<CharacterType>();
     }
-    str_obj ^= String::NewSymbol(ptr, len);
+    *str_obj ^= String::NewSymbol(ptr, len);
   } else {
     // Set up the string object.
-    str_obj = HandleType::New(
-        len, (kind == Snapshot::kFull) ? Heap::kOld : Heap::kNew);
+    *str_obj = HandleType::New(len, Heap::kNew);
+    str_obj->set_tags(tags);
+    str_obj->SetHash(0);  // Will get computed when needed.
     for (intptr_t i = 0; i < len; i++) {
-      *str_obj.CharAddr(i) = reader->Read<CharacterType>();
+      *str_obj->CharAddr(i) = reader->Read<CharacterType>();
     }
-    str_obj.set_tags(tags);
-    str_obj.SetHash(Smi::Value(smi_hash));
   }
-  reader->AddBackwardReference(object_id, &str_obj);
-
-  return str_obj.raw();
 }
 
 
 RawOneByteString* OneByteString::ReadFrom(SnapshotReader* reader,
                                           intptr_t object_id,
                                           intptr_t tags,
                                           Snapshot::Kind kind) {
-  return static_cast<RawOneByteString*>(
-      ReadFromImpl<OneByteString, uint8_t>(reader, object_id, tags, kind));
+  // Read the length so that we can determine instance size to allocate.
+  ASSERT(reader != NULL);
+  intptr_t len = GetSmiValue(reader->ReadIntptrValue());
+  intptr_t hash = GetSmiValue(reader->ReadIntptrValue());
+  OneByteString& str_obj = OneByteString::ZoneHandle(reader->isolate(),
+                                                     OneByteString::null());
+
+  if (kind == Snapshot::kFull) {
+    ASSERT(reader->isolate()->no_gc_scope_depth() != 0);
+    RawOneByteString* obj = reader->NewOneByteString(len);
+    str_obj = obj;
+    str_obj.set_tags(tags);
+    obj->ptr()->hash_ = Smi::New(hash);
+    uint8_t* raw_ptr = (len > 0) ? str_obj.CharAddr(0) : NULL;
+    for (intptr_t i = 0; i < len; i++) {
+      ASSERT(str_obj.CharAddr(i) == raw_ptr);  // Will trigger assertions.
+      *raw_ptr = reader->Read<uint8_t>();
+      raw_ptr += 1;
+    }
+    ASSERT((hash == 0) || (String::Hash(str_obj, 0, str_obj.Length()) == hash));
+  } else {
+    ReadFromImpl<OneByteString, uint8_t>(reader, &str_obj, len, tags);
+  }
+  reader->AddBackwardReference(object_id, &str_obj);
+  return str_obj.raw();
 }
 
 
 RawTwoByteString* TwoByteString::ReadFrom(SnapshotReader* reader,
                                           intptr_t object_id,
                                           intptr_t tags,
                                           Snapshot::Kind kind) {
-  return static_cast<RawTwoByteString*>(
-      ReadFromImpl<TwoByteString, uint16_t>(reader, object_id, tags, kind));
+  // Read the length so that we can determine instance size to allocate.
+  ASSERT(reader != NULL);
+  intptr_t len = GetSmiValue(reader->ReadIntptrValue());
+  intptr_t hash = GetSmiValue(reader->ReadIntptrValue());
+  TwoByteString& str_obj = TwoByteString::ZoneHandle(reader->isolate(),
+                                                     TwoByteString::null());
+
+  if (kind == Snapshot::kFull) {
+    RawTwoByteString* obj = reader->NewTwoByteString(len);
+    str_obj = obj;
+    str_obj.set_tags(tags);
+    obj->ptr()->hash_ = Smi::New(hash);
+    uint16_t* raw_ptr = (len > 0)? str_obj.CharAddr(0) : NULL;
+    for (intptr_t i = 0; i < len; i++) {
+      ASSERT(str_obj.CharAddr(i) == raw_ptr);  // Will trigger assertions.
+      *raw_ptr = reader->Read<uint16_t>();
+      raw_ptr += 1;
+    }
+    ASSERT(String::Hash(str_obj, 0, str_obj.Length()) == hash);
+  } else {
+    ReadFromImpl<TwoByteString, uint16_t>(reader, &str_obj, len, tags);
+  }
+  reader->AddBackwardReference(object_id, &str_obj);
+  return str_obj.raw();
 }
 
 
 RawFourByteString* FourByteString::ReadFrom(SnapshotReader* reader,
                                             intptr_t object_id,
                                             intptr_t tags,
                                             Snapshot::Kind kind) {
-  return static_cast<RawFourByteString*>(
-      ReadFromImpl<FourByteString, uint32_t>(reader, object_id, tags, kind));
+  // Read the length so that we can determine instance size to allocate.
+  ASSERT(reader != NULL);
+  intptr_t len = GetSmiValue(reader->ReadIntptrValue());
+  intptr_t hash = GetSmiValue(reader->ReadIntptrValue());
+  FourByteString& str_obj = FourByteString::ZoneHandle(reader->isolate(),
+                                                       FourByteString::null());
+
+  if (kind == Snapshot::kFull) {
+    RawFourByteString* obj = reader->NewFourByteString(len);
+    str_obj = obj;
+    str_obj.set_tags(tags);
+    obj->ptr()->hash_ = Smi::New(hash);
+    uint32_t* raw_ptr = (len > 0)? str_obj.CharAddr(0) : NULL;
+    for (intptr_t i = 0; i < len; i++) {
+      ASSERT(str_obj.CharAddr(i) == raw_ptr);  // Will trigger assertions.
+      *raw_ptr = reader->Read<uint32_t>();
+      raw_ptr += 1;
+    }
+    ASSERT(String::Hash(str_obj, 0, str_obj.Length()) == hash);
+  } else {
+    ReadFromImpl<FourByteString, uint32_t>(reader, &str_obj, len, tags);
+  }
+  reader->AddBackwardReference(object_id, &str_obj);
+  return str_obj.raw();
 }
 
 
 template<typename T>
 static void StringWriteTo(SnapshotWriter* writer,
                           intptr_t object_id,
                           Snapshot::Kind kind,
                           intptr_t class_id,
                           intptr_t tags,
                           RawSmi* length,
@@ skipping 147 matching lines @@
 }
 
 
 void RawBool::WriteTo(SnapshotWriter* writer,
                       intptr_t object_id,
                       Snapshot::Kind kind) {
   UNREACHABLE();
 }
 
 
-template <class T>
-static RawObject* ArrayReadFrom(SnapshotReader* reader,
-                                intptr_t object_id,
-                                intptr_t tags,
-                                Snapshot::Kind kind) {
+static void ArrayReadFrom(SnapshotReader* reader,
+                          const Array& result,
+                          intptr_t len,
+                          intptr_t tags) {
   ASSERT(reader != NULL);
 
-  // Read the length so that we can determine instance size to allocate.
-  RawSmi* smi_len = GetSmi(reader->ReadIntptrValue());
-  intptr_t len = Smi::Value(smi_len);
-  T& result = T::ZoneHandle(
-      reader->isolate(),
-      T::New(len, (kind == Snapshot::kFull) ? Heap::kOld : Heap::kNew));
-  reader->AddBackwardReference(object_id, &result);
-
   // Set the object tags.
   result.set_tags(tags);
 
   // Setup the object fields.
   *reader->TypeArgumentsHandle() ^= reader->ReadObject();
   result.SetTypeArguments(*reader->TypeArgumentsHandle());
 
   for (intptr_t i = 0; i < len; i++) {
     *reader->ObjectHandle() = reader->ReadObject();
     result.SetAt(i, *reader->ObjectHandle());
   }
-  return result.raw();
 }
 
 
 RawArray* Array::ReadFrom(SnapshotReader* reader,
                           intptr_t object_id,
                           intptr_t tags,
                           Snapshot::Kind kind) {
-  return reinterpret_cast<RawArray*>(
-      ArrayReadFrom<Array>(reader, object_id, tags, kind));
+  ASSERT(reader != NULL);
+
+  // Read the length so that we can determine instance size to allocate.
+  intptr_t len = GetSmiValue(reader->ReadIntptrValue());
+  Array& array = Array::ZoneHandle(reader->isolate(),
+                                   NEW_OBJECT_WITH_LEN(Array, len));
+  reader->AddBackwardReference(object_id, &array);
+  ArrayReadFrom(reader, array, len, tags);
+  return array.raw();
 }
 
 
 RawImmutableArray* ImmutableArray::ReadFrom(SnapshotReader* reader,
                                             intptr_t object_id,
                                             intptr_t tags,
                                             Snapshot::Kind kind) {
-  return reinterpret_cast<RawImmutableArray*>(
-      ArrayReadFrom<ImmutableArray>(reader, object_id, tags, kind));
+  ASSERT(reader != NULL);
+
+  // Read the length so that we can determine instance size to allocate.
+  intptr_t len = GetSmiValue(reader->ReadIntptrValue());
+  ImmutableArray& array = ImmutableArray::ZoneHandle(
+      reader->isolate(), NEW_OBJECT_WITH_LEN(ImmutableArray, len));
+  reader->AddBackwardReference(object_id, &array);
+  ArrayReadFrom(reader, array, len, tags);
+  return array.raw();
 }
 
 
 static void ArrayWriteTo(SnapshotWriter* writer,
                          intptr_t object_id,
                          Snapshot::Kind kind,
                          intptr_t array_kind,
                          intptr_t tags,
                          RawSmi* length,
                          RawAbstractTypeArguments* type_arguments,
@@ skipping 97 matching lines @@
 
 
 RawJSRegExp* JSRegExp::ReadFrom(SnapshotReader* reader,
                                 intptr_t object_id,
                                 intptr_t tags,
                                 Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   ASSERT(kind == Snapshot::kMessage);
 
   // Read the length so that we can determine instance size to allocate.
-  RawSmi* smi_len = GetSmi(reader->ReadIntptrValue());
-  intptr_t len = Smi::Value(smi_len);
+  intptr_t len = GetSmiValue(reader->ReadIntptrValue());
 
   // Allocate JSRegExp object.
   JSRegExp& regex = JSRegExp::ZoneHandle(
       reader->isolate(),
       JSRegExp::New(len, (kind == Snapshot::kFull) ? Heap::kOld : Heap::kNew));
   reader->AddBackwardReference(object_id, &regex);
 
   // Set the object tags.
   regex.set_tags(tags);
 
   // Read and Set all the other fields.
-  regex.raw_ptr()->num_bracket_expressions_ = GetSmi(reader->ReadIntptrValue());
+  regex.raw_ptr()->num_bracket_expressions_ = AsSmi(reader->ReadIntptrValue());
   *reader->StringHandle() ^= reader->ReadObject();
   regex.raw_ptr()->pattern_ = (*reader->StringHandle()).raw();
   regex.raw_ptr()->type_ = reader->ReadIntptrValue();
   regex.raw_ptr()->flags_ = reader->ReadIntptrValue();
 
   // TODO(5411462): Need to implement a way of recompiling the regex.
 
   return regex.raw();
 }
 
@@ skipping 16 matching lines @@
   // Write out all the other fields.
   writer->Write<RawObject*>(ptr()->num_bracket_expressions_);
   writer->WriteObject(ptr()->pattern_);
   writer->WriteIntptrValue(ptr()->type_);
   writer->WriteIntptrValue(ptr()->flags_);
 
   // Do not write out the data part which is native.
 }
 
 }  // namespace dart