Fix for issue 23244

runtime/vm/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/snapshot.h"
 
 #include "platform/assert.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart.h"
@@ skipping 188 matching lines @@
           (kind == Snapshot::kFull) ?
               Object::vm_isolate_snapshot_object_table().Length() : 0),
       backward_references_(backward_refs) {
 }
 
 
 RawObject* SnapshotReader::ReadObject() {
   // Setup for long jump in case there is an exception while reading.
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
-    PassiveObject& obj = PassiveObject::Handle(isolate(), ReadObjectImpl());
+    PassiveObject& obj =
+        PassiveObject::Handle(isolate(), ReadObjectImpl(kAsInlinedObject));
     for (intptr_t i = 0; i < backward_references_->length(); i++) {
       if (!(*backward_references_)[i].is_deserialized()) {
-        ReadObjectImpl();
+        ReadObjectImpl(kAsInlinedObject);
         (*backward_references_)[i].set_state(kIsDeserialized);
       }
     }
     return obj.raw();
   } else {
     // An error occurred while reading, return the error object.
     const Error& err = Error::Handle(isolate()->object_store()->sticky_error());
     isolate()->object_store()->clear_sticky_error();
     return err.raw();
   }
 }
 
 
 RawClass* SnapshotReader::ReadClassId(intptr_t object_id) {
   ASSERT(kind_ != Snapshot::kFull);
   // Read the class header information and lookup the class.
   intptr_t class_header = Read<int32_t>();
   ASSERT((class_header & kSmiTagMask) != kSmiTag);
   ASSERT(!IsVMIsolateObject(class_header) ||
          !IsSingletonClassId(GetVMIsolateObjectId(class_header)));
   ASSERT((SerializedHeaderTag::decode(class_header) != kObjectId) ||
          !IsObjectStoreClassId(SerializedHeaderData::decode(class_header)));
   Class& cls = Class::ZoneHandle(zone(), Class::null());
   AddBackRef(object_id, &cls, kIsDeserialized);
   // Read the library/class information and lookup the class.
-  str_ ^= ReadObjectImpl(class_header);
+  str_ ^= ReadObjectImpl(class_header, kAsInlinedObject);
   library_ = Library::LookupLibrary(str_);
   if (library_.IsNull() || !library_.Loaded()) {
     SetReadException("Invalid object found in message.");
   }
-  str_ ^= ReadObjectImpl();
+  str_ ^= ReadObjectImpl(kAsInlinedObject);
   cls = library_.LookupClass(str_);
   if (cls.IsNull()) {
     SetReadException("Invalid object found in message.");
   }
   cls.EnsureIsFinalized(isolate());
   return cls.raw();
 }
 
 
 RawObject* SnapshotReader::ReadStaticImplicitClosure(intptr_t object_id,
                                                      intptr_t class_header) {
   ASSERT(kind_ == Snapshot::kMessage);
 
   // First create a function object and associate it with the specified
   // 'object_id'.
   Function& func = Function::Handle(isolate(), Function::null());
   Instance& obj = Instance::ZoneHandle(zone(), Instance::null());
   AddBackRef(object_id, &obj, kIsDeserialized);
 
   // Read the library/class/function information and lookup the function.
-  str_ ^= ReadObjectImpl();
+  str_ ^= ReadObjectImpl(kAsInlinedObject);
   library_ = Library::LookupLibrary(str_);
   if (library_.IsNull() || !library_.Loaded()) {
     SetReadException("Invalid Library object found in message.");
   }
-  str_ ^= ReadObjectImpl();
+  str_ ^= ReadObjectImpl(kAsInlinedObject);
   if (str_.Equals(Symbols::TopLevel())) {
-    str_ ^= ReadObjectImpl();
+    str_ ^= ReadObjectImpl(kAsInlinedObject);
     func = library_.LookupFunctionAllowPrivate(str_);
   } else {
     cls_ = library_.LookupClassAllowPrivate(str_);
     if (cls_.IsNull()) {
       OS::Print("Name of class not found %s\n", str_.ToCString());
       SetReadException("Invalid Class object found in message.");
     }
     cls_.EnsureIsFinalized(isolate());
-    str_ ^= ReadObjectImpl();
+    str_ ^= ReadObjectImpl(kAsInlinedObject);
     func = cls_.LookupFunctionAllowPrivate(str_);
   }
   if (func.IsNull()) {
     SetReadException("Invalid function object found in message.");
   }
   func = func.ImplicitClosureFunction();
   ASSERT(!func.IsNull());
 
   // Return the associated implicit static closure.
   obj = func.ImplicitStaticClosure();
   return obj.raw();
 }
 
 
-RawObject* SnapshotReader::ReadObjectImpl() {
-  int64_t value = Read<int64_t>();
-  if ((value & kSmiTagMask) == kSmiTag) {
-    return NewInteger(value);
-  }
-  ASSERT((value <= kIntptrMax) && (value >= kIntptrMin));
-  return ReadObjectImpl(static_cast<intptr_t>(value));
-}
-
-
 intptr_t SnapshotReader::NextAvailableObjectId() const {
   return backward_references_->length() +
       kMaxPredefinedObjectIds + max_vm_isolate_object_id_;
 }
 
 
 void SnapshotReader::SetReadException(const char* msg) {
   Isolate* isolate = Isolate::Current();
   const String& error_str = String::Handle(isolate, String::New(msg));
   const Array& args = Array::Handle(isolate, Array::New(1));
   args.SetAt(0, error_str);
   Object& result = Object::Handle(isolate);
   const Library& library = Library::Handle(isolate, Library::CoreLibrary());
   result = DartLibraryCalls::InstanceCreate(library,
                                             Symbols::ArgumentError(),
                                             Symbols::Dot(),
                                             args);
   const Stacktrace& stacktrace = Stacktrace::Handle(isolate);
   const UnhandledException& error = UnhandledException::Handle(
       isolate, UnhandledException::New(Instance::Cast(result), stacktrace));
   isolate->long_jump_base()->Jump(1, error);
 }
 
 
 RawObject* SnapshotReader::VmIsolateSnapshotObject(intptr_t index) const {
   return Object::vm_isolate_snapshot_object_table().At(index);
 }
 
 
-RawObject* SnapshotReader::ReadObjectImpl(intptr_t header_value) {
+RawObject* SnapshotReader::ReadObjectImpl(bool as_reference) {
+  int64_t header_value = Read<int64_t>();
+  if ((header_value & kSmiTagMask) == kSmiTag) {
+    return NewInteger(header_value);
+  }
+  ASSERT((header_value <= kIntptrMax) && (header_value >= kIntptrMin));
+  return ReadObjectImpl(static_cast<intptr_t>(header_value), as_reference);
+}
+
+
+RawObject* SnapshotReader::ReadObjectImpl(intptr_t header_value,
+                                          bool as_reference) {
   if (IsVMIsolateObject(header_value)) {
     return ReadVMIsolateObject(header_value);
   } else {
     if (SerializedHeaderTag::decode(header_value) == kObjectId) {
       return ReadIndexedObject(SerializedHeaderData::decode(header_value));
     }
     ASSERT(SerializedHeaderTag::decode(header_value) == kInlined);
     intptr_t object_id = SerializedHeaderData::decode(header_value);
     if (object_id == kOmittedObjectId) {
       object_id = NextAvailableObjectId();
     }
-    return ReadInlinedObject(object_id);
+
+    // Read the class header information.
+    intptr_t class_header = Read<int32_t>();
+    intptr_t tags = ReadTags();
+    if (as_reference && !RawObject::IsCanonical(tags)) {
+      return ReadObjectRef(object_id, class_header, tags);
+    } else {
+      return ReadInlinedObject(object_id, class_header, tags);
+    }
   }
 }
 
 
-RawObject* SnapshotReader::ReadObjectRef() {
-  int64_t header_value = Read<int64_t>();
-  if ((header_value & kSmiTagMask) == kSmiTag) {
-    return NewInteger(header_value);
-  }
-  ASSERT((header_value <= kIntptrMax) && (header_value >= kIntptrMin));
-  intptr_t value = static_cast<intptr_t>(header_value);
-  if (IsVMIsolateObject(value)) {
-    return ReadVMIsolateObject(value);
-  } else if (SerializedHeaderTag::decode(value) == kObjectId) {
-    return ReadIndexedObject(SerializedHeaderData::decode(value));
-  }
-  ASSERT(SerializedHeaderTag::decode(value) == kInlined);
-  intptr_t object_id = SerializedHeaderData::decode(value);
-  if (object_id == kOmittedObjectId) {
-    object_id = NextAvailableObjectId();
-  }
-  ASSERT(GetBackRef(object_id) == NULL);
-
-  // Read the class header information and lookup the class.
-  intptr_t class_header = Read<int32_t>();
-
+RawObject* SnapshotReader::ReadObjectRef(intptr_t object_id,
+                                         intptr_t class_header,
+                                         intptr_t tags) {
   // Since we are only reading an object reference, If it is an instance kind
   // then we only need to figure out the class of the object and allocate an
   // instance of it. The individual fields will be read later.
   intptr_t header_id = SerializedHeaderData::decode(class_header);
   if (header_id == kInstanceObjectId) {
     Instance& result = Instance::ZoneHandle(zone(), Instance::null());
     AddBackRef(object_id, &result, kIsNotDeserialized);
 
-    cls_ ^= ReadObjectImpl();  // Read class information.
+    cls_ ^= ReadObjectImpl(kAsInlinedObject);  // Read class information.
     ASSERT(!cls_.IsNull());
     intptr_t instance_size = cls_.instance_size();
     ASSERT(instance_size > 0);
     if (kind_ == Snapshot::kFull) {
       result ^= AllocateUninitialized(cls_.id(), instance_size);
     } else {
       result ^= Object::Allocate(cls_.id(), instance_size, HEAP_SPACE(kind_));
     }
     return result.raw();
   } else if (header_id == kStaticImplicitClosureObjectId) {
     // We skip the tags that have been written as the implicit static
     // closure is going to be created in this isolate or the canonical
     // version already created in the isolate will be used.
-    ReadTags();
     return ReadStaticImplicitClosure(object_id, class_header);
   }
   ASSERT((class_header & kSmiTagMask) != kSmiTag);
 
   // Similarly Array and ImmutableArray objects are also similarly only
   // allocated here, the individual array elements are read later.
   intptr_t class_id = LookupInternalClass(class_header);
   if (class_id == kArrayCid) {
     // Read the length and allocate an object based on the len.
     intptr_t len = ReadSmiValue();
@@ skipping 11 matching lines @@
     Array& array = Array::ZoneHandle(
         zone(),
         (kind_ == Snapshot::kFull) ?
         NewImmutableArray(len) : ImmutableArray::New(len, HEAP_SPACE(kind_)));
     AddBackRef(object_id, &array, kIsNotDeserialized);
 
     return array.raw();
   }
 
   // For all other internal VM classes we read the object inline.
-  intptr_t tags = ReadTags();
   switch (class_id) {
 #define SNAPSHOT_READ(clazz)                                                   \
     case clazz::kClassId: {                                                    \
+      pobj_ = clazz::ReadFrom(this, object_id, tags, kind_);                   \
+      break;                                                                   \
+    }
+    CLASS_LIST_NO_OBJECT(SNAPSHOT_READ)
+#undef SNAPSHOT_READ
+#define SNAPSHOT_READ(clazz)                                                   \
+    case kTypedData##clazz##Cid:                                               \
+
+    CLASS_LIST_TYPED_DATA(SNAPSHOT_READ) {
+      tags = RawObject::ClassIdTag::update(class_id, tags);
+      pobj_ = TypedData::ReadFrom(this, object_id, tags, kind_);
+      break;
+    }
+#undef SNAPSHOT_READ
+#define SNAPSHOT_READ(clazz)                                                   \
+    case kExternalTypedData##clazz##Cid:                                       \
+
+    CLASS_LIST_TYPED_DATA(SNAPSHOT_READ) {
+      tags = RawObject::ClassIdTag::update(class_id, tags);
+      pobj_ = ExternalTypedData::ReadFrom(this, object_id, tags, kind_);
+      break;
+    }
+#undef SNAPSHOT_READ
+    default: UNREACHABLE(); break;
+  }
+  if (kind_ == Snapshot::kFull) {
+    pobj_.SetCreatedFromSnapshot();
+  }
+  return pobj_.raw();
+}
+
+
+RawObject* SnapshotReader::ReadInlinedObject(intptr_t object_id,
+                                             intptr_t class_header,
+                                             intptr_t tags) {
+  // Lookup the class based on the class header information.
+  intptr_t header_id = SerializedHeaderData::decode(class_header);
+  if (header_id == kInstanceObjectId) {
+    // Object is regular dart instance.
+    Instance* result = reinterpret_cast<Instance*>(GetBackRef(object_id));
+    intptr_t instance_size = 0;
+    if (result == NULL) {
+      result = &(Instance::ZoneHandle(zone(), Instance::null()));
+      AddBackRef(object_id, result, kIsDeserialized);
+      cls_ ^= ReadObjectImpl(kAsInlinedObject);
+      ASSERT(!cls_.IsNull());
+      instance_size = cls_.instance_size();
+      ASSERT(instance_size > 0);
+      // Allocate the instance and read in all the fields for the object.
+      if (kind_ == Snapshot::kFull) {
+        *result ^= AllocateUninitialized(cls_.id(), instance_size);
+      } else {
+        *result ^= Object::Allocate(cls_.id(),
+                                    instance_size,
+                                    HEAP_SPACE(kind_));
+      }
+    } else {
+      cls_ ^= ReadObjectImpl(kAsInlinedObject);
+      ASSERT(!cls_.IsNull());
+      instance_size = cls_.instance_size();
+    }
+    intptr_t next_field_offset = cls_.next_field_offset();
+    intptr_t type_argument_field_offset = cls_.type_arguments_field_offset();
+    ASSERT(next_field_offset > 0);
+    // Instance::NextFieldOffset() returns the offset of the first field in
+    // a Dart object.
+    bool as_reference = RawObject::IsCanonical(tags) ? false : true;
+    intptr_t offset = Instance::NextFieldOffset();
+    intptr_t result_cid = result->GetClassId();
+    while (offset < next_field_offset) {
+      pobj_ = ReadObjectImpl(as_reference);
+      result->SetFieldAtOffset(offset, pobj_);
+      if ((offset != type_argument_field_offset) &&
+          (kind_ == Snapshot::kMessage)) {
+        // TODO(fschneider): Consider hoisting these lookups out of the loop.
+        // This would involve creating a handle, since cls_ can't be reused
+        // across the call to ReadObjectRef.
+        cls_ = isolate()->class_table()->At(result_cid);
+        array_ = cls_.OffsetToFieldMap();
+        field_ ^= array_.At(offset >> kWordSizeLog2);
+        ASSERT(!field_.IsNull());
+        ASSERT(field_.Offset() == offset);
+        obj_ = pobj_.raw();
+        field_.RecordStore(obj_);
+      }
+      // TODO(fschneider): Verify the guarded cid and length for other kinds of
+      // snapshot (kFull, kScript) with asserts.
+      offset += kWordSize;
+    }
+    if (kind_ == Snapshot::kFull) {
+      // We create an uninitialized object in the case of full snapshots, so
+      // we need to initialize any remaining padding area with the Null object.
+      while (offset < instance_size) {
+        result->SetFieldAtOffset(offset, Object::null_object());
+        offset += kWordSize;
+      }
+      result->SetCreatedFromSnapshot();
+    } else if (RawObject::IsCanonical(tags)) {
+      *result = result->CheckAndCanonicalize(NULL);
+      ASSERT(!result->IsNull());
+    }
+    return result->raw();
+  } else if (header_id == kStaticImplicitClosureObjectId) {
+    // We do not use the tags as the implicit static closure
+    // is going to be created in this isolate or the canonical
+    // version already created in the isolate will be used.
+    return ReadStaticImplicitClosure(object_id, class_header);
+  }
+  ASSERT((class_header & kSmiTagMask) != kSmiTag);
+  intptr_t class_id = LookupInternalClass(class_header);
+  switch (class_id) {
+#define SNAPSHOT_READ(clazz)                                                   \
+    case clazz::kClassId: {                                                    \
       pobj_ = clazz::ReadFrom(this, object_id, tags, kind_);                   \
       break;                                                                   \
     }
     CLASS_LIST_NO_OBJECT(SNAPSHOT_READ)
 #undef SNAPSHOT_READ
 #define SNAPSHOT_READ(clazz)                                                   \
     case kTypedData##clazz##Cid:                                               \
 
     CLASS_LIST_TYPED_DATA(SNAPSHOT_READ) {
       tags = RawObject::ClassIdTag::update(class_id, tags);
@@ skipping 75 matching lines @@
 
   // TODO(asiva): Add a check here to ensure we have the right heap
   // size for the full snapshot being read.
   {
     NoSafepointScope no_safepoint;
     HeapLocker hl(isolate, old_space());
 
     // Read in all the objects stored in the object store.
     intptr_t num_flds = (object_store->to() - object_store->from());
     for (intptr_t i = 0; i <= num_flds; i++) {
-      *(object_store->from() + i) = ReadObjectImpl();
+      *(object_store->from() + i) = ReadObjectImpl(kAsInlinedObject);
     }
     for (intptr_t i = 0; i < backward_references_->length(); i++) {
       if (!(*backward_references_)[i].is_deserialized()) {
-        ReadObjectImpl();
+        ReadObjectImpl(kAsInlinedObject);
         (*backward_references_)[i].set_state(kIsDeserialized);
       }
     }
 
     // Validate the class table.
 #if defined(DEBUG)
     isolate->ValidateClassTable();
 #endif
 
     // Setup native resolver for bootstrap impl.
@@ skipping 463 matching lines @@
   }
   ASSERT(object_id >= kMaxPredefinedObjectIds);
   intptr_t index = (object_id - kMaxPredefinedObjectIds);
   if (index < max_vm_isolate_object_id_) {
     return VmIsolateSnapshotObject(index);
   }
   return GetBackRef(object_id)->raw();
 }
 
 
-RawObject* SnapshotReader::ReadInlinedObject(intptr_t object_id) {
-  // Read the class header information and lookup the class.
-  intptr_t class_header = Read<int32_t>();
-  intptr_t tags = ReadTags();
-  intptr_t header_id = SerializedHeaderData::decode(class_header);
-  if (header_id == kInstanceObjectId) {
-    // Object is regular dart instance.
-    Instance* result = reinterpret_cast<Instance*>(GetBackRef(object_id));
-    intptr_t instance_size = 0;
-    if (result == NULL) {
-      result = &(Instance::ZoneHandle(zone(), Instance::null()));
-      AddBackRef(object_id, result, kIsDeserialized);
-      cls_ ^= ReadObjectImpl();
-      ASSERT(!cls_.IsNull());
-      instance_size = cls_.instance_size();
-      ASSERT(instance_size > 0);
-      // Allocate the instance and read in all the fields for the object.
-      if (kind_ == Snapshot::kFull) {
-        *result ^= AllocateUninitialized(cls_.id(), instance_size);
-      } else {
-        *result ^= Object::Allocate(cls_.id(),
-                                    instance_size,
-                                    HEAP_SPACE(kind_));
-      }
-    } else {
-      cls_ ^= ReadObjectImpl();
-      ASSERT(!cls_.IsNull());
-      instance_size = cls_.instance_size();
-    }
-    intptr_t next_field_offset = cls_.next_field_offset();
-    intptr_t type_argument_field_offset = cls_.type_arguments_field_offset();
-    ASSERT(next_field_offset > 0);
-    // Instance::NextFieldOffset() returns the offset of the first field in
-    // a Dart object.
-    bool is_canonical = RawObject::IsCanonical(tags);
-    intptr_t offset = Instance::NextFieldOffset();
-    intptr_t result_cid = result->GetClassId();
-    while (offset < next_field_offset) {
-      pobj_ = is_canonical ? ReadObjectImpl() : ReadObjectRef();
-      result->SetFieldAtOffset(offset, pobj_);
-      if ((offset != type_argument_field_offset) &&
-          (kind_ == Snapshot::kMessage)) {
-        // TODO(fschneider): Consider hoisting these lookups out of the loop.
-        // This would involve creating a handle, since cls_ can't be reused
-        // across the call to ReadObjectRef.
-        cls_ = isolate()->class_table()->At(result_cid);
-        array_ = cls_.OffsetToFieldMap();
-        field_ ^= array_.At(offset >> kWordSizeLog2);
-        ASSERT(!field_.IsNull());
-        ASSERT(field_.Offset() == offset);
-        obj_ = pobj_.raw();
-        field_.RecordStore(obj_);
-      }
-      // TODO(fschneider): Verify the guarded cid and length for other kinds of
-      // snapshot (kFull, kScript) with asserts.
-      offset += kWordSize;
-    }
-    if (kind_ == Snapshot::kFull) {
-      // We create an uninitialized object in the case of full snapshots, so
-      // we need to initialize any remaining padding area with the Null object.
-      while (offset < instance_size) {
-        result->SetFieldAtOffset(offset, Object::null_object());
-        offset += kWordSize;
-      }
-      result->SetCreatedFromSnapshot();
-    } else if (RawObject::IsCanonical(tags)) {
-      *result = result->CheckAndCanonicalize(NULL);
-      ASSERT(!result->IsNull());
-    }
-    return result->raw();
-  } else if (header_id == kStaticImplicitClosureObjectId) {
-    // We do not use the tags as the implicit static closure
-    // is going to be created in this isolate or the canonical
-    // version already created in the isolate will be used.
-    return ReadStaticImplicitClosure(object_id, class_header);
-  }
-  ASSERT((class_header & kSmiTagMask) != kSmiTag);
-  intptr_t class_id = LookupInternalClass(class_header);
-  switch (class_id) {
-#define SNAPSHOT_READ(clazz)                                                   \
-    case clazz::kClassId: {                                                    \
-      pobj_ = clazz::ReadFrom(this, object_id, tags, kind_);                   \
-      break;                                                                   \
-    }
-    CLASS_LIST_NO_OBJECT(SNAPSHOT_READ)
-#undef SNAPSHOT_READ
-#define SNAPSHOT_READ(clazz)                                                   \
-    case kTypedData##clazz##Cid:                                               \
-
-    CLASS_LIST_TYPED_DATA(SNAPSHOT_READ) {
-      tags = RawObject::ClassIdTag::update(class_id, tags);
-      pobj_ = TypedData::ReadFrom(this, object_id, tags, kind_);
-      break;
-    }
-#undef SNAPSHOT_READ
-#define SNAPSHOT_READ(clazz)                                                   \
-    case kExternalTypedData##clazz##Cid:                                       \
-
-    CLASS_LIST_TYPED_DATA(SNAPSHOT_READ) {
-      tags = RawObject::ClassIdTag::update(class_id, tags);
-      pobj_ = ExternalTypedData::ReadFrom(this, object_id, tags, kind_);
-      break;
-    }
-#undef SNAPSHOT_READ
-    default: UNREACHABLE(); break;
-  }
-  if (kind_ == Snapshot::kFull) {
-    pobj_.SetCreatedFromSnapshot();
-  }
-  return pobj_.raw();
-}
-
-
 void SnapshotReader::ArrayReadFrom(const Array& result,
                                    intptr_t len,
                                    intptr_t tags) {
   // Set the object tags.
   result.set_tags(tags);
 
   // Setup the object fields.
-  *TypeArgumentsHandle() ^= ReadObjectImpl();
+  *TypeArgumentsHandle() ^= ReadObjectImpl(kAsInlinedObject);
   result.SetTypeArguments(*TypeArgumentsHandle());
 
-  bool is_canonical = RawObject::IsCanonical(tags);
+  bool as_reference = RawObject::IsCanonical(tags) ? false : true;
 
   for (intptr_t i = 0; i < len; i++) {
-    *PassiveObjectHandle() = is_canonical ? ReadObjectImpl() : ReadObjectRef();
+    *PassiveObjectHandle() = ReadObjectImpl(as_reference);
     result.SetAt(i, *PassiveObjectHandle());
   }
 }
 
 
 VmIsolateSnapshotReader::VmIsolateSnapshotReader(const uint8_t* buffer,
                                                  intptr_t size,
                                                  Zone* zone)
     : SnapshotReader(buffer,
                      size,
@@ skipping 126 matching lines @@
       forward_list_(forward_list),
       exception_type_(Exceptions::kNone),
       exception_msg_(NULL),
       unmarked_objects_(false),
       can_send_any_object_(can_send_any_object) {
   ASSERT(forward_list_ != NULL);
 }
 
 
 void SnapshotWriter::WriteObject(RawObject* rawobj) {
-  WriteObjectImpl(rawobj);
+  WriteObjectImpl(rawobj, kAsInlinedObject);
   WriteForwardedObjects();
 }
 
 #define VM_OBJECT_CLASS_LIST(V)                                                \
   V(OneByteString)                                                             \
   V(Mint)                                                                      \
   V(Bigint)                                                                    \
   V(Double)                                                                    \
 
 #define VM_OBJECT_WRITE(clazz)                                                 \
@@ skipping 102 matching lines @@
           break;
       }
     }
   }
   UNREACHABLE();
 }
 
 #undef VM_OBJECT_WRITE
 
 
-void SnapshotWriter::WriteObjectRef(RawObject* raw) {
-  // First check if object can be written as a simple predefined type.
-  if (CheckAndWritePredefinedObject(raw)) {
-    return;
-  }
-
-  NoSafepointScope no_safepoint;
-  RawClass* cls = class_table_->At(raw->GetClassId());
-  intptr_t class_id = cls->ptr()->id_;
-  ASSERT(class_id == raw->GetClassId());
-  if (class_id >= kNumPredefinedCids) {
-    WriteInstanceRef(raw, cls);
-    return;
-  }
-  if (class_id == kArrayCid) {
-    // Object is being referenced, add it to the forward ref list and mark
-    // it so that future references to this object in the snapshot will use
-    // this object id. Mark it as not having been serialized yet so that we
-    // will serialize the object when we go through the forward list.
-    forward_list_->MarkAndAddObject(raw, kIsNotSerialized);
-
-    RawArray* rawarray = reinterpret_cast<RawArray*>(raw);
-
-    // Write out the serialization header value for this object.
-    WriteInlinedObjectHeader(kOmittedObjectId);
-
-    // Write out the class information.
-    WriteIndexedObject(kArrayCid);
-
-    // Write out the length field.
-    Write<RawObject*>(rawarray->ptr()->length_);
-
-    return;
-  }
-  if (class_id == kImmutableArrayCid) {
-    // Object is being referenced, add it to the forward ref list and mark
-    // it so that future references to this object in the snapshot will use
-    // this object id. Mark it as not having been serialized yet so that we
-    // will serialize the object when we go through the forward list.
-    forward_list_->MarkAndAddObject(raw, kIsNotSerialized);
-
-    RawArray* rawarray = reinterpret_cast<RawArray*>(raw);
-
-    // Write out the serialization header value for this object.
-    WriteInlinedObjectHeader(kOmittedObjectId);
-
-    // Write out the class information.
-    WriteIndexedObject(kImmutableArrayCid);
-
-    // Write out the length field.
-    Write<RawObject*>(rawarray->ptr()->length_);
-
-    return;
-  }
-  if (RawObject::IsImplicitFieldClassId(class_id)) {
-    WriteInstanceRef(raw, cls);
-    return;
-  }
-  // Add object to the forward ref list and mark it so that future references
-  // to this object in the snapshot will use this object id. Mark it as having
-  // been serialized so that we do not serialize the object when we go through
-  // the forward list.
-  forward_list_->MarkAndAddObject(raw, kIsSerialized);
-  switch (class_id) {
-#define SNAPSHOT_WRITE(clazz)                                                  \
-    case clazz::kClassId: {                                                    \
-      Raw##clazz* raw_obj = reinterpret_cast<Raw##clazz*>(raw);                \
-      raw_obj->WriteTo(this, kOmittedObjectId, kind_);                         \
-      return;                                                                  \
-    }                                                                          \
-
-    CLASS_LIST_NO_OBJECT(SNAPSHOT_WRITE)
-#undef SNAPSHOT_WRITE
-#define SNAPSHOT_WRITE(clazz)                                                  \
-    case kTypedData##clazz##Cid:                                               \
-
-    CLASS_LIST_TYPED_DATA(SNAPSHOT_WRITE) {
-      RawTypedData* raw_obj = reinterpret_cast<RawTypedData*>(raw);
-      raw_obj->WriteTo(this, kOmittedObjectId, kind_);
-      return;
-    }
-#undef SNAPSHOT_WRITE
-#define SNAPSHOT_WRITE(clazz)                                                  \
-    case kExternalTypedData##clazz##Cid:                                       \
-
-    CLASS_LIST_TYPED_DATA(SNAPSHOT_WRITE) {
-      RawExternalTypedData* raw_obj =
-        reinterpret_cast<RawExternalTypedData*>(raw);
-      raw_obj->WriteTo(this, kOmittedObjectId, kind_);
-      return;
-    }
-#undef SNAPSHOT_WRITE
-    default: break;
-  }
-  UNREACHABLE();
-}
-
-
 // An object visitor which will iterate over all the script objects in the heap
 // and either count them or collect them into an array. This is used during
 // full snapshot generation of the VM isolate to write out all script
 // objects and their accompanying token streams.
 class ScriptVisitor : public ObjectVisitor {
  public:
   explicit ScriptVisitor(Isolate* isolate) :
       ObjectVisitor(isolate),
       objHandle_(Object::Handle(isolate)),
       count_(0),
@@ skipping 328 matching lines @@
     if (index != kInvalidIndex) {
       WriteIndexedObject(index);
       return true;
     }
   }
 
   return false;
 }
 
 
-void SnapshotWriter::WriteObjectImpl(RawObject* raw) {
+void SnapshotWriter::WriteObjectImpl(RawObject* raw, bool as_reference) {
   // First check if object can be written as a simple predefined type.
   if (CheckAndWritePredefinedObject(raw)) {
     return;
   }
 
-  // Object is being serialized, add it to the forward ref list and mark
-  // it so that future references to this object in the snapshot will use
-  // an object id, instead of trying to serialize it again.
-  forward_list_->MarkAndAddObject(raw, kIsSerialized);
+  if (as_reference && !raw->IsCanonical()) {
+    WriteObjectRef(raw);
+  } else {
+    // Object is being serialized, add it to the forward ref list and mark
+    // it so that future references to this object in the snapshot will use
+    // an object id, instead of trying to serialize it again.
+    forward_list_->MarkAndAddObject(raw, kIsSerialized);
 
-  WriteInlinedObject(raw);
+    WriteInlinedObject(raw);
+  }
 }
 
 
+void SnapshotWriter::WriteObjectRef(RawObject* raw) {
+  NoSafepointScope no_safepoint;
+  RawClass* cls = class_table_->At(raw->GetClassId());
+  intptr_t class_id = cls->ptr()->id_;
+  ASSERT(class_id == raw->GetClassId());
+  if (class_id >= kNumPredefinedCids ||
+      RawObject::IsImplicitFieldClassId(class_id)) {
+    WriteInstanceRef(raw, cls);
+    return;
+  }
+  if (class_id == kArrayCid || class_id == kImmutableArrayCid) {
+    intptr_t tags = GetObjectTags(raw);
+
+    // Object is being referenced, add it to the forward ref list and mark
+    // it so that future references to this object in the snapshot will use
+    // this object id. Mark it as not having been serialized yet so that we
+    // will serialize the object when we go through the forward list.
+    forward_list_->MarkAndAddObject(raw, kIsNotSerialized);
+
+    RawArray* rawarray = reinterpret_cast<RawArray*>(raw);
+
+    // Write out the serialization header value for this object.
+    WriteInlinedObjectHeader(kOmittedObjectId);
+
+    // Write out the class information.
+    WriteIndexedObject(class_id);
+    WriteTags(tags);
+
+    // Write out the length field.
+    Write<RawObject*>(rawarray->ptr()->length_);
+
+    return;
+  }
+  // Add object to the forward ref list and mark it so that future references
+  // to this object in the snapshot will use this object id. Mark it as having
+  // been serialized so that we do not serialize the object when we go through
+  // the forward list.
+  forward_list_->MarkAndAddObject(raw, kIsSerialized);
+  switch (class_id) {
+#define SNAPSHOT_WRITE(clazz)                                                  \
+    case clazz::kClassId: {                                                    \
+      Raw##clazz* raw_obj = reinterpret_cast<Raw##clazz*>(raw);                \
+      raw_obj->WriteTo(this, kOmittedObjectId, kind_);                         \
+      return;                                                                  \
+    }                                                                          \
+
+    CLASS_LIST_NO_OBJECT(SNAPSHOT_WRITE)
+#undef SNAPSHOT_WRITE
+#define SNAPSHOT_WRITE(clazz)                                                  \
+    case kTypedData##clazz##Cid:                                               \
+
+    CLASS_LIST_TYPED_DATA(SNAPSHOT_WRITE) {
+      RawTypedData* raw_obj = reinterpret_cast<RawTypedData*>(raw);
+      raw_obj->WriteTo(this, kOmittedObjectId, kind_);
+      return;
+    }
+#undef SNAPSHOT_WRITE
+#define SNAPSHOT_WRITE(clazz)                                                  \
+    case kExternalTypedData##clazz##Cid:                                       \
+
+    CLASS_LIST_TYPED_DATA(SNAPSHOT_WRITE) {
+      RawExternalTypedData* raw_obj =
+        reinterpret_cast<RawExternalTypedData*>(raw);
+      raw_obj->WriteTo(this, kOmittedObjectId, kind_);
+      return;
+    }
+#undef SNAPSHOT_WRITE
+    default: break;
+  }
+  UNREACHABLE();
+}
+
+
 void SnapshotWriter::WriteInlinedObject(RawObject* raw) {
   // Now write the object out inline in the stream as follows:
   // - Object is seen for the first time (inlined as follows):
   //    (object size in multiples of kObjectAlignment | 0x1)
   //    serialized fields of the object
   //    ......
   NoSafepointScope no_safepoint;
   uword tags = raw->ptr()->tags_;
   ASSERT(SerializedHeaderTag::decode(tags) == kObjectId);
   intptr_t object_id = SerializedHeaderData::decode(tags);
@@ skipping 106 matching lines @@
   ASSERT(!IsSingletonClassId(class_id) && !IsObjectStoreClassId(class_id));
   // TODO(5411462): Should restrict this to only core-lib classes in this
   // case.
   // Write out the class and tags information.
   WriteVMIsolateObject(kClassCid);
   WriteTags(GetObjectTags(cls));
 
   // Write out the library url and class name.
   RawLibrary* library = cls->ptr()->library_;
   ASSERT(library != Library::null());
-  WriteObjectImpl(library->ptr()->url_);
-  WriteObjectImpl(cls->ptr()->name_);
+  WriteObjectImpl(library->ptr()->url_, kAsInlinedObject);
+  WriteObjectImpl(cls->ptr()->name_, kAsInlinedObject);
 }
 
 
 void SnapshotWriter::WriteStaticImplicitClosure(intptr_t object_id,
                                                 RawFunction* func,
                                                 intptr_t tags) {
   // Write out the serialization header value for this object.
   WriteInlinedObjectHeader(object_id);
 
   // Indicate this is a static implicit closure object.
   Write<int32_t>(SerializedHeaderData::encode(kStaticImplicitClosureObjectId));
 
   // Write out the tags.
   WriteTags(tags);
 
   // Write out the library url, class name and signature function name.
   RawClass* cls = GetFunctionOwner(func);
   ASSERT(cls != Class::null());
   RawLibrary* library = cls->ptr()->library_;
   ASSERT(library != Library::null());
-  WriteObjectImpl(library->ptr()->url_);
-  WriteObjectImpl(cls->ptr()->name_);
-  WriteObjectImpl(func->ptr()->name_);
+  WriteObjectImpl(library->ptr()->url_, kAsInlinedObject);
+  WriteObjectImpl(cls->ptr()->name_, kAsInlinedObject);
+  WriteObjectImpl(func->ptr()->name_, kAsInlinedObject);
 }
 
 
 void SnapshotWriter::ArrayWriteTo(intptr_t object_id,
                                   intptr_t array_kind,
                                   intptr_t tags,
                                   RawSmi* length,
                                   RawTypeArguments* type_arguments,
                                   RawObject* data[]) {
   intptr_t len = Smi::Value(length);
 
   // Write out the serialization header value for this object.
   WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   WriteIndexedObject(array_kind);
   WriteTags(tags);
 
   // Write out the length field.
   Write<RawObject*>(length);
 
   // Write out the type arguments.
-  WriteObjectImpl(type_arguments);
+  WriteObjectImpl(type_arguments, kAsInlinedObject);
 
   // Write out the individual object ids.
-  bool is_canonical = RawObject::IsCanonical(tags);
+  bool as_reference = RawObject::IsCanonical(tags) ? false : true;
   for (intptr_t i = 0; i < len; i++) {
-    if (is_canonical) {
-      WriteObjectImpl(data[i]);
-    } else {
-      WriteObjectRef(data[i]);
-    }
+    WriteObjectImpl(data[i], as_reference);
   }
 }
 
 
 RawFunction* SnapshotWriter::IsSerializableClosure(RawClass* cls,
                                                    RawObject* obj) {
   if (Class::IsSignatureClass(cls)) {
     // 'obj' is a closure as its class is a signature class, extract
     // the function object to check if this closure can be sent in an
     // isolate message.
@@ skipping 88 matching lines @@
   // Write out the serialization header value for this object.
   WriteInlinedObjectHeader(object_id);
 
   // Indicate this is an instance object.
   Write<int32_t>(SerializedHeaderData::encode(kInstanceObjectId));
 
   // Write out the tags.
   WriteTags(tags);
 
   // Write out the class information for this object.
-  WriteObjectImpl(cls);
+  WriteObjectImpl(cls, kAsInlinedObject);
 
   // Write out all the fields for the object.
   // Instance::NextFieldOffset() returns the offset of the first field in
   // a Dart object.
-  bool is_canonical = RawObject::IsCanonical(tags);
+  bool as_reference = RawObject::IsCanonical(tags) ? false : true;
   intptr_t offset = Instance::NextFieldOffset();
   while (offset < next_field_offset) {
     RawObject* raw_obj = *reinterpret_cast<RawObject**>(
         reinterpret_cast<uword>(raw->ptr()) + offset);
-    if (is_canonical) {
-      WriteObjectImpl(raw_obj);
-    } else {
-      WriteObjectRef(raw_obj);
-    }
+    WriteObjectImpl(raw_obj, as_reference);
     offset += kWordSize;
   }
   return;
 }
 
 
 void SnapshotWriter::WriteInstanceRef(RawObject* raw, RawClass* cls) {
   // Check if the instance has native fields and throw an exception if it does.
   CheckForNativeFields(cls);
 
@@ skipping 11 matching lines @@
     intptr_t object_id = SerializedHeaderData::decode(tags);
     tags = forward_list_->NodeForObjectId(object_id)->tags();
     WriteStaticImplicitClosure(object_id, func, tags);
     return;
   }
 
   // Object is being referenced, add it to the forward ref list and mark
   // it so that future references to this object in the snapshot will use
   // this object id. Mark it as not having been serialized yet so that we
   // will serialize the object when we go through the forward list.
+  intptr_t tags = raw->ptr()->tags_;
   forward_list_->MarkAndAddObject(raw, kIsNotSerialized);
 
   // Write out the serialization header value for this object.
   WriteInlinedObjectHeader(kOmittedObjectId);
 
   // Indicate this is an instance object.
   Write<int32_t>(SerializedHeaderData::encode(kInstanceObjectId));
+  WriteTags(tags);
 
   // Write out the class information for this object.
-  WriteObjectImpl(cls);
+  WriteObjectImpl(cls, kAsInlinedObject);
 }
 
 
 bool SnapshotWriter::AllowObjectsInDartLibrary(RawLibrary* library) {
   return library == object_store()->typed_data_library();
 }
 
 
 intptr_t SnapshotWriter::FindVmSnapshotObject(RawObject* rawobj) {
   intptr_t length = Object::vm_isolate_snapshot_object_table().Length();
@@ skipping 78 matching lines @@
     }
   } else {
     ThrowException(exception_type(), exception_msg());
   }
 }
 
 
 void SnapshotWriterVisitor::VisitPointers(RawObject** first, RawObject** last) {
   for (RawObject** current = first; current <= last; current++) {
     RawObject* raw_obj = *current;
-    if (as_references_) {
-      writer_->WriteObjectRef(raw_obj);
-    } else {
-      writer_->WriteObjectImpl(raw_obj);
-    }
+    writer_->WriteObjectImpl(raw_obj, as_references_);
   }
 }
 
 
 MessageWriter::MessageWriter(uint8_t** buffer,
                              ReAlloc alloc,
                              bool can_send_any_object)
     : SnapshotWriter(Snapshot::kMessage,
                      buffer,
                      alloc,
@@ skipping 17 matching lines @@
     NoSafepointScope no_safepoint;
     WriteObject(obj.raw());
     UnmarkAll();
   } else {
     ThrowException(exception_type(), exception_msg());
   }
 }
 
 
 }  // namespace dart