1. Remove recursion during snapshot writing and reading

vm/raw_object_snapshot.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/bigint_operations.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/snapshot.h"
 #include "vm/visitor.h"
 
@@ skipping 23 matching lines @@
       (kind == Snapshot::kScript && !RawObject::IsCreatedFromSnapshot(tags))) {
     // Read in the base information.
     ObjectKind object_kind = reader->Read<ObjectKind>();
 
     // Allocate class object of specified kind.
     if (kind == Snapshot::kFull) {
       cls = reader->NewClass(object_kind);
     } else {
       cls = Class::GetClass(object_kind);
     }
-    reader->AddBackwardReference(object_id, &cls);
+    reader->AddBackRef(object_id, &cls, kIsDeserialized);
 
     // 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());
     cls.set_token_index(reader->ReadIntptrValue());
     cls.set_class_state(reader->Read<int8_t>());
     if (reader->Read<bool>()) {
       cls.set_is_const();
     }
     if (reader->Read<bool>()) {
       cls.set_is_interface();
     }
 
     // Set all the object fields.
     // TODO(5411462): Need to assert No GC can happen here, even though
     // allocations may happen.
     intptr_t num_flds = (cls.raw()->to() - cls.raw()->from());
     for (intptr_t i = 0; i <= num_flds; i++) {
-      *(cls.raw()->from() + i) = reader->ReadObject();
+      *(cls.raw()->from() + i) = reader->ReadObjectRef();
     }
   } else {
     cls ^= reader->ReadClassId(object_id);
   }
   return cls.raw();
 }
 
 
 void RawClass::WriteTo(SnapshotWriter* writer,
                        intptr_t object_id,
@@ skipping 32 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(), NEW_OBJECT(UnresolvedClass));
-  reader->AddBackwardReference(object_id, &unresolved_class);
+  reader->AddBackRef(object_id, &unresolved_class, kIsDeserialized);
 
   // 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
   // allocations may happen.
   intptr_t num_flds = (unresolved_class.raw()->to() -
                        unresolved_class.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
-    *(unresolved_class.raw()->from() + i) = reader->ReadObject();
+    *(unresolved_class.raw()->from() + i) = reader->ReadObjectRef();
   }
   return unresolved_class.raw();
 }
 
 
 void RawUnresolvedClass::WriteTo(SnapshotWriter* writer,
                                  intptr_t object_id,
                                  Snapshot::Kind kind) {
   ASSERT(writer != NULL);
 
@@ skipping 31 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(), NEW_OBJECT(Type));
-  reader->AddBackwardReference(object_id, &parameterized_type);
+  reader->AddBackRef(object_id, &parameterized_type, kIsDeserialized);
 
   // Set the object tags.
   parameterized_type.set_tags(tags);
 
   // Set all non object fields.
   parameterized_type.set_token_index(reader->ReadIntptrValue());
   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
   // allocations may happen.
   intptr_t num_flds = (parameterized_type.raw()->to() -
                        parameterized_type.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
-    *(parameterized_type.raw()->from() + i) = reader->ReadObject();
+    *(parameterized_type.raw()->from() + i) = reader->ReadObjectImpl();
   }
 
   // If object needs to be a canonical object, Canonicalize it.
   if ((kind != Snapshot::kFull) && parameterized_type.IsCanonical()) {
     parameterized_type ^= parameterized_type.Canonicalize();
   }
   return parameterized_type.raw();
 }
 
 
 void RawType::WriteTo(SnapshotWriter* writer,
                       intptr_t object_id,
                       Snapshot::Kind kind) {
   ASSERT(writer != NULL);
 
   // Write out the serialization header value for this object.
   writer->WriteSerializationMarker(kInlined, object_id);
 
   // Write out the class and tags information.
   writer->WriteObjectHeader(Object::kTypeClass, writer->GetObjectTags(this));
 
   // Write out all the non object pointer fields.
   writer->WriteIntptrValue(ptr()->token_index_);
   writer->Write<int8_t>(ptr()->type_state_);
 
   // Write out all the object pointer fields.
-  SnapshotWriterVisitor visitor(writer);
+  SnapshotWriterVisitor visitor(writer, false);
   visitor.VisitPointers(from(), to());
 }
 
 
 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(), NEW_OBJECT(TypeParameter));
-  reader->AddBackwardReference(object_id, &type_parameter);
+  reader->AddBackRef(object_id, &type_parameter, kIsDeserialized);
 
   // Set the object tags.
   type_parameter.set_tags(tags);
 
   // Set all non object fields.
   type_parameter.set_index(reader->ReadIntptrValue());
   type_parameter.set_token_index(reader->ReadIntptrValue());
   type_parameter.set_type_state(reader->Read<int8_t>());
 
   // Set all the object fields.
   // TODO(5411462): Need to assert No GC can happen here, even though
   // allocations may happen.
   intptr_t num_flds = (type_parameter.raw()->to() -
                        type_parameter.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
-    *(type_parameter.raw()->from() + i) = reader->ReadObject();
+    *(type_parameter.raw()->from() + i) = reader->ReadObjectImpl();
   }
 
   return type_parameter.raw();
 }
 
 
 void RawTypeParameter::WriteTo(SnapshotWriter* writer,
                                intptr_t object_id,
                                Snapshot::Kind kind) {
   ASSERT(writer != NULL);
 
   // Write out the serialization header value for this object.
   writer->WriteSerializationMarker(kInlined, object_id);
 
   // Write out the class and tags information.
   writer->WriteObjectHeader(Object::kTypeParameterClass,
                             writer->GetObjectTags(this));
 
   // Write out all the non object pointer fields.
   writer->WriteIntptrValue(ptr()->index_);
   writer->WriteIntptrValue(ptr()->token_index_);
   writer->Write<int8_t>(ptr()->type_state_);
 
   // Write out all the object pointer fields.
-  SnapshotWriterVisitor visitor(writer);
+  SnapshotWriterVisitor visitor(writer, false);
   visitor.VisitPointers(from(), to());
 }
 
 
 RawAbstractTypeArguments* AbstractTypeArguments::ReadFrom(
     SnapshotReader* reader,
     intptr_t object_id,
     intptr_t tags,
     Snapshot::Kind kind) {
   UNREACHABLE();  // AbstractTypeArguments is an abstract class.
@@ skipping 12 matching lines @@
                                           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.
   intptr_t len = reader->ReadSmiValue();
 
   TypeArguments& type_arguments = TypeArguments::ZoneHandle(
       reader->isolate(), NEW_OBJECT_WITH_LEN(TypeArguments, len));
-  reader->AddBackwardReference(object_id, &type_arguments);
+  reader->AddBackRef(object_id, &type_arguments, kIsDeserialized);
 
   // Now set all the object fields.
   for (intptr_t i = 0; i < len; i++) {
-    *reader->TypeHandle() ^= reader->ReadObject();
+    *reader->TypeHandle() ^= reader->ReadObjectImpl();
     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
   // already canonical).
   type_arguments.set_tags(tags);
 
   // If object needs to be a canonical object, Canonicalize it.
   if ((kind != Snapshot::kFull) && type_arguments.IsCanonical()) {
@@ skipping 14 matching lines @@
   // Write out the class and tags information.
   writer->WriteObjectHeader(Object::kTypeArgumentsClass,
                             writer->GetObjectTags(this));
 
   // Write out the length field.
   writer->Write<RawObject*>(ptr()->length_);
 
   // Write out the individual types.
   intptr_t len = Smi::Value(ptr()->length_);
   for (intptr_t i = 0; i < len; i++) {
-    writer->WriteObject(ptr()->types_[i]);
+    writer->WriteObjectImpl(ptr()->types_[i]);
   }
 }
 
 
 RawInstantiatedTypeArguments* InstantiatedTypeArguments::ReadFrom(
     SnapshotReader* reader,
     intptr_t object_id,
     intptr_t tags,
     Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   ASSERT(kind == Snapshot::kMessage);
 
   // Allocate instantiated types object.
   InstantiatedTypeArguments& instantiated_type_arguments =
       InstantiatedTypeArguments::ZoneHandle(reader->isolate(),
                                             InstantiatedTypeArguments::New());
-  reader->AddBackwardReference(object_id, &instantiated_type_arguments);
+  reader->AddBackRef(object_id, &instantiated_type_arguments, kIsDeserialized);
 
   // Set the object tags.
   instantiated_type_arguments.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 = (instantiated_type_arguments.raw()->to() -
                        instantiated_type_arguments.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
-    *(instantiated_type_arguments.raw()->from() + i) = reader->ReadObject();
+    *(instantiated_type_arguments.raw()->from() + i) = reader->ReadObjectImpl();
   }
   return instantiated_type_arguments.raw();
 }
 
 
 void RawInstantiatedTypeArguments::WriteTo(SnapshotWriter* writer,
                                            intptr_t object_id,
                                            Snapshot::Kind kind) {
   ASSERT(writer != NULL);
   ASSERT(kind == Snapshot::kMessage);
 
   // Write out the serialization header value for this object.
   writer->WriteSerializationMarker(kInlined, object_id);
 
   // Write out the class and tags information.
   writer->WriteObjectHeader(Object::kInstantiatedTypeArgumentsClass,
                             writer->GetObjectTags(this));
 
   // Write out all the object pointer fields.
-  SnapshotWriterVisitor visitor(writer);
+  SnapshotWriterVisitor visitor(writer, false);
   visitor.VisitPointers(from(), to());
 }
 
 
 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(), NEW_OBJECT(Function));
-  reader->AddBackwardReference(object_id, &func);
+  reader->AddBackRef(object_id, &func, kIsDeserialized);
 
   // Set the object tags.
   func.set_tags(tags);
 
   // Set all the non object fields.
   func.set_token_index(reader->ReadIntptrValue());
   func.set_end_token_index(reader->ReadIntptrValue());
   func.set_num_fixed_parameters(reader->ReadIntptrValue());
   func.set_num_optional_parameters(reader->ReadIntptrValue());
   func.set_usage_counter(reader->ReadIntptrValue());
   func.set_deoptimization_counter(reader->ReadIntptrValue());
   func.set_kind(static_cast<RawFunction::Kind >(reader->ReadIntptrValue()));
   func.set_is_static(reader->Read<bool>());
   func.set_is_const(reader->Read<bool>());
   func.set_is_optimizable(reader->Read<bool>());
 
   // Set all the object fields.
   // TODO(5411462): Need to assert No GC can happen here, even though
   // allocations may happen.
   intptr_t num_flds = (func.raw()->to() - func.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
-    *(func.raw()->from() + i) = reader->ReadObject();
+    *(func.raw()->from() + i) = reader->ReadObjectRef();
   }
 
   return func.raw();
 }
 
 
 void RawFunction::WriteTo(SnapshotWriter* writer,
                           intptr_t object_id,
                           Snapshot::Kind kind) {
   ASSERT(writer != NULL);
@@ skipping 27 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(), NEW_OBJECT(Field));
-  reader->AddBackwardReference(object_id, &field);
+  reader->AddBackRef(object_id, &field, kIsDeserialized);
 
   // 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>());
 
   // Set all the object fields.
   // TODO(5411462): Need to assert No GC can happen here, even though
   // allocations may happen.
   intptr_t num_flds = (field.raw()->to() - field.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
-    *(field.raw()->from() + i) = reader->ReadObject();
+    *(field.raw()->from() + i) = reader->ReadObjectRef();
   }
 
   return field.raw();
 }
 
 
 void RawField::WriteTo(SnapshotWriter* writer,
                        intptr_t object_id,
                        Snapshot::Kind kind) {
   ASSERT(writer != NULL);
@@ skipping 21 matching lines @@
 RawLiteralToken* LiteralToken::ReadFrom(SnapshotReader* reader,
                                         intptr_t object_id,
                                         intptr_t tags,
                                         Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   ASSERT(kind != Snapshot::kMessage);
 
   // Create the literal token object.
   LiteralToken& literal_token = LiteralToken::ZoneHandle(
       reader->isolate(), NEW_OBJECT(LiteralToken));
-  reader->AddBackwardReference(object_id, &literal_token);
+  reader->AddBackRef(object_id, &literal_token, kIsDeserialized);
 
   // Set the object tags.
   literal_token.set_tags(tags);
 
   // Read the token attributes.
   Token::Kind token_kind = static_cast<Token::Kind>(reader->ReadIntptrValue());
   literal_token.set_kind(token_kind);
-  *reader->StringHandle() ^= reader->ReadObject();
+  *reader->StringHandle() ^= reader->ReadObjectImpl();
   literal_token.set_literal(*reader->StringHandle());
-  *reader->ObjectHandle() = reader->ReadObject();
+  *reader->ObjectHandle() = reader->ReadObjectImpl();
   literal_token.set_value(*reader->ObjectHandle());
 
   return literal_token.raw();
 }
 
 
 void RawLiteralToken::WriteTo(SnapshotWriter* writer,
                               intptr_t object_id,
                               Snapshot::Kind kind) {
   ASSERT(writer != NULL);
   ASSERT(kind != Snapshot::kMessage);
 
   // Write out the serialization header value for this object.
   writer->WriteSerializationMarker(kInlined, object_id);
 
   // Write out the class and tags information.
   writer->WriteObjectHeader(Object::kLiteralTokenClass,
                             writer->GetObjectTags(this));
 
   // Write out the kind field.
   writer->Write<intptr_t>(ptr()->kind_);
 
   // Write out literal and value fields.
-  writer->WriteObject(ptr()->literal_);
-  writer->WriteObject(ptr()->value_);
+  writer->WriteObjectImpl(ptr()->literal_);
+  writer->WriteObjectImpl(ptr()->value_);
 }
 
 
 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.
   intptr_t len = reader->ReadSmiValue();
 
   // Create the token stream object.
   TokenStream& token_stream = TokenStream::ZoneHandle(
       reader->isolate(), NEW_OBJECT_WITH_LEN(TokenStream, len));
-  reader->AddBackwardReference(object_id, &token_stream);
+  reader->AddBackRef(object_id, &token_stream, kIsDeserialized);
 
   // Set the object tags.
   token_stream.set_tags(tags);
 
   // Read the token stream into the TokenStream.
   for (intptr_t i = 0; i < len; i++) {
-    *reader->ObjectHandle() = reader->ReadObject();
+    *reader->ObjectHandle() = reader->ReadObjectImpl();
     token_stream.SetTokenAt(i, *reader->ObjectHandle());
   }
   return token_stream.raw();
 }
 
 
 void RawTokenStream::WriteTo(SnapshotWriter* writer,
                              intptr_t object_id,
                              Snapshot::Kind kind) {
   ASSERT(writer != NULL);
   ASSERT(kind != Snapshot::kMessage &&
          !RawObject::IsCreatedFromSnapshot(writer->GetObjectTags(this)));
 
   // Write out the serialization header value for this object.
   writer->WriteSerializationMarker(kInlined, object_id);
 
   // Write out the class and tags information.
   writer->WriteObjectHeader(Object::kTokenStreamClass,
                             writer->GetObjectTags(this));
 
   // Write out the length field.
   writer->Write<RawObject*>(ptr()->length_);
 
   // Write out the token stream (token kind and literal).
   intptr_t len = Smi::Value(ptr()->length_);
   for (intptr_t i = 0; i < TokenStream::StreamLength(len); i++) {
-    writer->WriteObject(ptr()->data_[i]);
+    writer->WriteObjectImpl(ptr()->data_[i]);
   }
 }
 
 
 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(), NEW_OBJECT(Script));
-  reader->AddBackwardReference(object_id, &script);
+  reader->AddBackRef(object_id, &script, kIsDeserialized);
 
   // 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.
-  *reader->StringHandle() ^= reader->ReadObject();
+  *reader->StringHandle() ^= reader->ReadObjectImpl();
   script.set_url(*reader->StringHandle());
   *reader->StringHandle() ^= String::null();
   script.set_source(*reader->StringHandle());
   TokenStream& stream = TokenStream::Handle();
-  stream ^= reader->ReadObject();
+  stream ^= reader->ReadObjectImpl();
   script.set_tokens(stream);
 
   return script.raw();
 }
 
 
 void RawScript::WriteTo(SnapshotWriter* writer,
                         intptr_t object_id,
                         Snapshot::Kind kind) {
   ASSERT(writer != NULL);
   ASSERT(tokens_ != TokenStream::null());
   ASSERT(kind != Snapshot::kMessage &&
          !RawObject::IsCreatedFromSnapshot(writer->GetObjectTags(this)));
 
   // Write out the serialization header value for this object.
   writer->WriteSerializationMarker(kInlined, object_id);
 
   // Write out the class and tags information.
   writer->WriteObjectHeader(Object::kScriptClass, writer->GetObjectTags(this));
 
   // Write out all the object pointer fields.
-  writer->WriteObject(ptr()->url_);
-  writer->WriteObject(ptr()->tokens_);
+  writer->WriteObjectImpl(ptr()->url_);
+  writer->WriteObjectImpl(ptr()->tokens_);
 }
 
 
 RawLibrary* Library::ReadFrom(SnapshotReader* reader,
                               intptr_t object_id,
                               intptr_t tags,
                               Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   ASSERT(kind != Snapshot::kMessage);
 
   Library& library = Library::ZoneHandle(reader->isolate(), Library::null());
-  reader->AddBackwardReference(object_id, &library);
+  reader->AddBackRef(object_id, &library, kIsDeserialized);
 
   if (RawObject::IsCreatedFromSnapshot(tags)) {
     ASSERT(kind != Snapshot::kFull);
     // Lookup the object as it should already exist in the heap.
-    *reader->StringHandle() ^= reader->ReadObject();
+    *reader->StringHandle() ^= reader->ReadObjectImpl();
     library = Library::LookupLibrary(*reader->StringHandle());
   } else {
     // Allocate library object.
     library = NEW_OBJECT(Library);
 
     // Set the object tags.
     library.set_tags(tags);
 
     // Set all non object fields.
     library.raw_ptr()->index_ = reader->ReadIntptrValue();
     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()->debuggable_ = reader->Read<bool>();
     library.raw_ptr()->load_state_ = reader->Read<int8_t>();
     // The native resolver is not serialized.
     Dart_NativeEntryResolver resolver =
         reader->Read<Dart_NativeEntryResolver>();
     ASSERT(resolver == NULL);
     library.set_native_entry_resolver(resolver);
     // The cache of loaded scripts is not serialized.
     library.raw_ptr()->loaded_scripts_ = Array::null();
 
     // Set all the object fields.
     // TODO(5411462): Need to assert No GC can happen here, even though
     // allocations may happen.
     intptr_t num_flds = (library.raw()->to() - library.raw()->from());
     for (intptr_t i = 0; i <= num_flds; i++) {
-      *(library.raw()->from() + i) = reader->ReadObject();
+      *(library.raw()->from() + i) = reader->ReadObjectRef();
     }
     if (kind != Snapshot::kFull) {
       library.Register();
     }
   }
   return library.raw();
 }
 
 
 void RawLibrary::WriteTo(SnapshotWriter* writer,
                          intptr_t object_id,
                          Snapshot::Kind kind) {
   ASSERT(writer != NULL);
   ASSERT(kind != Snapshot::kMessage);
 
   // Write out the serialization header value for this object.
   writer->WriteSerializationMarker(kInlined, object_id);
 
   // Write out the class and tags information.
   writer->WriteObjectHeader(Object::kLibraryClass, writer->GetObjectTags(this));
 
   if (RawObject::IsCreatedFromSnapshot(writer->GetObjectTags(this))) {
     ASSERT(kind != Snapshot::kFull);
     // Write out library URL so that it can be looked up when reading.
-    writer->WriteObject(ptr()->url_);
+    writer->WriteObjectImpl(ptr()->url_);
   } else {
     // Write out all non object fields.
     writer->WriteIntptrValue(ptr()->index_);
     writer->WriteIntptrValue(ptr()->num_imports_);
     writer->WriteIntptrValue(ptr()->num_imported_into_);
     writer->WriteIntptrValue(ptr()->num_anonymous_);
     writer->Write<bool>(ptr()->corelib_imported_);
     writer->Write<bool>(ptr()->debuggable_);
     writer->Write<int8_t>(ptr()->load_state_);
     // We do not serialize the native resolver over, this needs to be explicitly
@@ skipping 13 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(), NEW_OBJECT(LibraryPrefix));
-  reader->AddBackwardReference(object_id, &prefix);
+  reader->AddBackRef(object_id, &prefix, kIsDeserialized);
 
   // Set the object tags.
   prefix.set_tags(tags);
 
   // Set all non object fields.
   prefix.raw_ptr()->num_libs_ = reader->ReadIntptrValue();
 
   // 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++) {
-    *(prefix.raw()->from() + i) = reader->ReadObject();
+    *(prefix.raw()->from() + i) = reader->ReadObjectRef();
   }
 
   return prefix.raw();
 }
 
 
 void RawLibraryPrefix::WriteTo(SnapshotWriter* writer,
                                intptr_t object_id,
                                Snapshot::Kind kind) {
   ASSERT(writer != NULL);
@@ skipping 121 matching lines @@
   ASSERT(reader != NULL);
 
   // Allocate context object.
   intptr_t num_vars = reader->ReadIntptrValue();
   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);
+  reader->AddBackRef(object_id, &context, kIsDeserialized);
 
   // 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
   // allocations may happen.
   intptr_t num_flds = (context.raw()->to(num_vars) - context.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
-    *(context.raw()->from() + i) = reader->ReadObject();
+    *(context.raw()->from() + i) = reader->ReadObjectRef();
   }
 
   return context.raw();
 }
 
 
 void RawContext::WriteTo(SnapshotWriter* writer,
                          intptr_t object_id,
                          Snapshot::Kind kind) {
   ASSERT(writer != NULL);
@@ skipping 19 matching lines @@
                                         intptr_t object_id,
                                         intptr_t tags,
                                         Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   ASSERT(kind == Snapshot::kMessage);
 
   // Allocate context scope object.
   intptr_t num_vars = reader->ReadIntptrValue();
   ContextScope& scope = ContextScope::ZoneHandle(reader->isolate(),
                                                  ContextScope::New(num_vars));
-  reader->AddBackwardReference(object_id, &scope);
+  reader->AddBackRef(object_id, &scope, kIsDeserialized);
 
   // Set the object tags.
   scope.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 = (scope.raw()->to(num_vars) - scope.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
-    *(scope.raw()->from() + i) = reader->ReadObject();
+    *(scope.raw()->from() + i) = reader->ReadObjectRef();
   }
 
   return scope.raw();
 }
 
 
 void RawContextScope::WriteTo(SnapshotWriter* writer,
                               intptr_t object_id,
                               Snapshot::Kind kind) {
   ASSERT(writer != NULL);
@@ skipping 156 matching lines @@
   Mint& mint = Mint::ZoneHandle(reader->isolate(), Mint::null());
   if (kind == Snapshot::kFull) {
     mint = reader->NewMint(value);
   } else {
     if (RawObject::IsCanonical(tags)) {
       mint = Mint::NewCanonical(value);
     } else {
       mint = Mint::New(value, Heap::kNew);
     }
   }
-  reader->AddBackwardReference(object_id, &mint);
+  reader->AddBackRef(object_id, &mint, kIsDeserialized);
 
   // Set the object tags.
   mint.set_tags(tags);
 
   return mint.raw();
 }
 
 
 void RawMint::WriteTo(SnapshotWriter* writer,
                       intptr_t object_id,
@@ skipping 27 matching lines @@
   // Create a Bigint object from HexCString.
   Bigint& obj = Bigint::ZoneHandle(
       reader->isolate(),
       (kind == Snapshot::kFull) ? reader->NewBigint(str) :
                                   BigintOperations::FromHexCString(str));
 
   // If it is a canonical constant make it one.
   if ((kind != Snapshot::kFull) && RawObject::IsCanonical(tags)) {
     obj ^= obj.Canonicalize();
   }
-  reader->AddBackwardReference(object_id, &obj);
+  reader->AddBackRef(object_id, &obj, kIsDeserialized);
 
   // Set the object tags.
   obj.set_tags(tags);
 
   return obj.raw();
 }
 
 
 void RawBigint::WriteTo(SnapshotWriter* writer,
                         intptr_t object_id,
@@ skipping 51 matching lines @@
   Double& dbl = Double::ZoneHandle(reader->isolate(), Double::null());
   if (kind == Snapshot::kFull) {
     dbl = reader->NewDouble(value);
   } else {
     if (RawObject::IsCanonical(tags)) {
       dbl = Double::NewCanonical(value);
     } else {
       dbl = Double::New(value, Heap::kNew);
     }
   }
-  reader->AddBackwardReference(object_id, &dbl);
+  reader->AddBackRef(object_id, &dbl, kIsDeserialized);
 
   // Set the object tags.
   dbl.set_tags(tags);
 
   return dbl.raw();
 }
 
 
 void RawDouble::WriteTo(SnapshotWriter* writer,
                         intptr_t object_id,
@@ skipping 72 matching lines @@
     str_obj.set_tags(tags);
     obj->ptr()->hash_ = Smi::New(hash);
     if (len > 0) {
       uint8_t* raw_ptr = str_obj.CharAddr(0);
       reader->ReadBytes(raw_ptr, len);
     }
     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);
+  reader->AddBackRef(object_id, &str_obj, kIsDeserialized);
   return str_obj.raw();
 }
 
 
 RawTwoByteString* TwoByteString::ReadFrom(SnapshotReader* reader,
                                           intptr_t object_id,
                                           intptr_t tags,
                                           Snapshot::Kind kind) {
   // Read the length so that we can determine instance size to allocate.
   ASSERT(reader != NULL);
@@ skipping 10 matching lines @@
     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);
+  reader->AddBackRef(object_id, &str_obj, kIsDeserialized);
   return str_obj.raw();
 }
 
 
 RawFourByteString* FourByteString::ReadFrom(SnapshotReader* reader,
                                             intptr_t object_id,
                                             intptr_t tags,
                                             Snapshot::Kind kind) {
   // Read the length so that we can determine instance size to allocate.
   ASSERT(reader != NULL);
@@ skipping 10 matching lines @@
     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);
+  reader->AddBackRef(object_id, &str_obj, kIsDeserialized);
   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,
@@ skipping 148 matching lines @@
 }
 
 
 void RawBool::WriteTo(SnapshotWriter* writer,
                       intptr_t object_id,
                       Snapshot::Kind kind) {
   UNREACHABLE();
 }
 
 
-static void ArrayReadFrom(SnapshotReader* reader,
-                          const Array& result,
-                          intptr_t len,
-                          intptr_t tags) {
-  ASSERT(reader != NULL);
-
-  // 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());
-  }
-}
-
-
 RawArray* Array::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.
   intptr_t len = reader->ReadSmiValue();
-  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();
+  Array* array = reinterpret_cast<Array*>(
+      reader->GetBackRef(object_id));
+  if (array == NULL) {
+    array = &(Array::ZoneHandle(reader->isolate(),
+                                NEW_OBJECT_WITH_LEN(Array, len)));
+    reader->AddBackRef(object_id, array, kIsDeserialized);
+  }
+  reader->ArrayReadFrom(*array, len, tags);
+  return array->raw();
 }
 
 
 RawImmutableArray* ImmutableArray::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.
   intptr_t len = reader->ReadSmiValue();
-  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,
-                         RawObject* data[]) {
-  ASSERT(writer != NULL);
-  intptr_t len = Smi::Value(length);
-
-  // Write out the serialization header value for this object.
-  writer->WriteSerializationMarker(kInlined, object_id);
-
-  // Write out the class and tags information.
-  writer->WriteObjectHeader(array_kind, tags);
-
-  // Write out the length field.
-  writer->Write<RawObject*>(length);
-
-  // Write out the type arguments.
-  writer->WriteObject(type_arguments);
-
-  // Write out the individual objects.
-  for (intptr_t i = 0; i < len; i++) {
-    writer->WriteObject(data[i]);
+  ImmutableArray* array = reinterpret_cast<ImmutableArray*>(
+      reader->GetBackRef(object_id));
+  if (array == NULL) {
+    array = &(ImmutableArray::ZoneHandle(
+        reader->isolate(), NEW_OBJECT_WITH_LEN(ImmutableArray, len)));
+    reader->AddBackRef(object_id, array, kIsDeserialized);
   }
+  reader->ArrayReadFrom(*array, len, tags);
+  return array->raw();
 }
 
 
 void RawArray::WriteTo(SnapshotWriter* writer,
                        intptr_t object_id,
                        Snapshot::Kind kind) {
-  ArrayWriteTo(writer,
-               object_id,
-               kind,
-               ObjectStore::kArrayClass,
-               writer->GetObjectTags(this),
-               ptr()->length_,
-               ptr()->type_arguments_,
-               ptr()->data());
+  writer->ArrayWriteTo(object_id,
+                       ObjectStore::kArrayClass,
+                       writer->GetObjectTags(this),
+                       ptr()->length_,
+                       ptr()->type_arguments_,
+                       ptr()->data());
 }
 
 
 void RawImmutableArray::WriteTo(SnapshotWriter* writer,
                                 intptr_t object_id,
                                 Snapshot::Kind kind) {
-  ArrayWriteTo(writer,
-               object_id,
-               kind,
-               ObjectStore::kImmutableArrayClass,
-               writer->GetObjectTags(this),
-               ptr()->length_,
-               ptr()->type_arguments_,
-               ptr()->data());
+  writer->ArrayWriteTo(object_id,
+                       ObjectStore::kImmutableArrayClass,
+                       writer->GetObjectTags(this),
+                       ptr()->length_,
+                       ptr()->type_arguments_,
+                       ptr()->data());
 }
 
 
 RawGrowableObjectArray* GrowableObjectArray::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.
   GrowableObjectArray& array = GrowableObjectArray::ZoneHandle(
       reader->isolate(), GrowableObjectArray::null());
   if (kind == Snapshot::kFull) {
     array = reader->NewGrowableObjectArray();
   } else {
     array = GrowableObjectArray::New(0);
   }
-  reader->AddBackwardReference(object_id, &array);
+  reader->AddBackRef(object_id, &array, kIsDeserialized);
   intptr_t length = reader->ReadSmiValue();
   array.SetLength(length);
   Array& contents = Array::Handle();
-  contents ^= reader->ReadObject();
+  contents ^= reader->ReadObjectImpl();
   array.SetData(contents);
   const AbstractTypeArguments& type_arguments =
       AbstractTypeArguments::Handle(contents.GetTypeArguments());
   array.SetTypeArguments(type_arguments);
   return array.raw();
 }
 
 
 void RawGrowableObjectArray::WriteTo(SnapshotWriter* writer,
                                      intptr_t object_id,
                                      Snapshot::Kind kind) {
   ASSERT(writer != NULL);
 
   // Write out the serialization header value for this object.
   writer->WriteSerializationMarker(kInlined, object_id);
 
   // Write out the class and tags information.
   writer->WriteObjectHeader(ObjectStore::kGrowableObjectArrayClass,
                             writer->GetObjectTags(this));
 
   // Write out the used length field.
   writer->Write<RawObject*>(ptr()->length_);
 
   // Write out the Array object.
-  writer->WriteObject(ptr()->data_);
+  writer->WriteObjectImpl(ptr()->data_);
 }
 
 
 RawByteArray* ByteArray::ReadFrom(SnapshotReader* reader,
                                   intptr_t object_id,
                                   intptr_t tags,
                                   Snapshot::Kind kind) {
   UNREACHABLE();  // ByteArray is an abstract class.
   return ByteArray::null();
 }
 
 
 template<typename HandleT, typename RawT, typename ElementT>
 RawT* ByteArray::ReadFromImpl(SnapshotReader* reader,
                               intptr_t object_id,
                               intptr_t tags,
                               Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   intptr_t len = reader->ReadSmiValue();
   Heap::Space space = (kind == Snapshot::kFull) ? Heap::kOld : Heap::kNew;
   HandleT& result =
       HandleT::ZoneHandle(reader->isolate(), HandleT::New(len, space));
-  reader->AddBackwardReference(object_id, &result);
+  reader->AddBackRef(object_id, &result, kIsDeserialized);
 
   // Set the object tags.
   result.set_tags(tags);
 
   // Setup the array elements.
   for (intptr_t i = 0; i < len; ++i) {
     result.SetAt(i, reader->Read<ElementT>());
   }
   return result.raw();
 }
@@ skipping 152 matching lines @@
   ASSERT(reader != NULL);
   ASSERT(kind == Snapshot::kMessage);
 
   // Read the length so that we can determine instance size to allocate.
   intptr_t len = reader->ReadSmiValue();
 
   // Allocate JSRegExp object.
   JSRegExp& regex = JSRegExp::ZoneHandle(
       reader->isolate(),
       JSRegExp::New(len, (kind == Snapshot::kFull) ? Heap::kOld : Heap::kNew));
-  reader->AddBackwardReference(object_id, &regex);
+  reader->AddBackRef(object_id, &regex, kIsDeserialized);
 
   // Set the object tags.
   regex.set_tags(tags);
 
   // Read and Set all the other fields.
   regex.raw_ptr()->num_bracket_expressions_ = reader->ReadAsSmi();
-  *reader->StringHandle() ^= reader->ReadObject();
+  *reader->StringHandle() ^= reader->ReadObjectImpl();
   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();
 }
 
 
 void RawJSRegExp::WriteTo(SnapshotWriter* writer,
                           intptr_t object_id,
                           Snapshot::Kind kind) {
   ASSERT(writer != NULL);
   ASSERT(kind == Snapshot::kMessage);
 
   // Write out the serialization header value for this object.
   writer->WriteSerializationMarker(kInlined, object_id);
 
   // Write out the class and tags information.
   writer->WriteObjectHeader(ObjectStore::kJSRegExpClass,
                             writer->GetObjectTags(this));
 
   // Write out the data length field.
   writer->Write<RawObject*>(ptr()->data_length_);
 
   // Write out all the other fields.
   writer->Write<RawObject*>(ptr()->num_bracket_expressions_);
-  writer->WriteObject(ptr()->pattern_);
+  writer->WriteObjectImpl(ptr()->pattern_);
   writer->WriteIntptrValue(ptr()->type_);
   writer->WriteIntptrValue(ptr()->flags_);
 
   // Do not write out the data part which is native.
 }
 
 
 }  // namespace dart