Fix for issue 23244

runtime/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/object.h"
 #include "vm/object_store.h"
 #include "vm/snapshot.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 #include "vm/visitor.h"
@@ skipping 50 matching lines @@
     cls.set_num_own_type_arguments(reader->Read<int16_t>());
     cls.set_num_native_fields(reader->Read<uint16_t>());
     cls.set_token_pos(reader->Read<int32_t>());
     cls.set_state_bits(reader->Read<uint16_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 = (cls.raw()->to() - cls.raw()->from());
     for (intptr_t i = 0; i <= num_flds; i++) {
-      (*reader->PassiveObjectHandle()) = reader->ReadObjectRef();
+      (*reader->PassiveObjectHandle()) = reader->ReadObjectImpl(kAsReference);
        cls.StorePointer((cls.raw()->from() + i),
                        reader->PassiveObjectHandle()->raw());
     }
   } else {
     cls ^= reader->ReadClassId(object_id);
   }
   return cls.raw();
 }
 
 
@@ skipping 63 matching lines @@
 
   // Set all non object fields.
   unresolved_class.set_token_pos(reader->Read<int32_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 = (unresolved_class.raw()->to() -
                        unresolved_class.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
-    (*reader->PassiveObjectHandle()) = reader->ReadObjectRef();
+    (*reader->PassiveObjectHandle()) = reader->ReadObjectImpl(kAsReference);
     unresolved_class.StorePointer((unresolved_class.raw()->from() + i),
                                   reader->PassiveObjectHandle()->raw());
   }
   return unresolved_class.raw();
 }
 
 
 void RawUnresolvedClass::WriteTo(SnapshotWriter* writer,
                                  intptr_t object_id,
                                  Snapshot::Kind kind) {
@@ skipping 43 matching lines @@
 
   // Set all non object fields.
   type.set_token_pos(reader->Read<int32_t>());
   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 = (type.raw()->to() - type.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
-    (*reader->PassiveObjectHandle()) = reader->ReadObjectImpl();
+    (*reader->PassiveObjectHandle()) = reader->ReadObjectImpl(kAsInlinedObject);
     type.StorePointer((type.raw()->from() + i),
                       reader->PassiveObjectHandle()->raw());
   }
 
   // If object needs to be a canonical object, Canonicalize it.
   // When reading a full snapshot we don't need to canonicalize the object
   // as it would already be a canonical object.
   // When reading a script snapshot we need to canonicalize only those object
   // references that are objects from the core library (loaded from a
   // full snapshot). Objects that are only in the script need not be
@@ skipping 53 matching lines @@
   reader->AddBackRef(object_id, &type_ref, kIsDeserialized);
 
   // Set the object tags.
   type_ref.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 = (type_ref.raw()->to() - type_ref.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
-    (*reader->PassiveObjectHandle()) = reader->ReadObjectRef();
+    (*reader->PassiveObjectHandle()) = reader->ReadObjectImpl(kAsReference);
     type_ref.StorePointer((type_ref.raw()->from() + i),
                           reader->PassiveObjectHandle()->raw());
   }
 
   return type_ref.raw();
 }
 
 
 void RawTypeRef::WriteTo(SnapshotWriter* writer,
                          intptr_t object_id,
@@ skipping 31 matching lines @@
   type_parameter.set_token_pos(reader->Read<int32_t>());
   type_parameter.set_index(reader->Read<int16_t>());
   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++) {
-    (*reader->PassiveObjectHandle()) = reader->ReadObjectRef();
+    (*reader->PassiveObjectHandle()) = reader->ReadObjectImpl(kAsReference);
     type_parameter.StorePointer((type_parameter.raw()->from() + i),
                                 reader->PassiveObjectHandle()->raw());
   }
 
   return type_parameter.raw();
 }
 
 
 void RawTypeParameter::WriteTo(SnapshotWriter* writer,
                                intptr_t object_id,
@@ skipping 34 matching lines @@
 
   // Set the object tags.
   bounded_type.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 = (bounded_type.raw()->to() -
                        bounded_type.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
-    (*reader->PassiveObjectHandle()) = reader->ReadObjectRef();
+    (*reader->PassiveObjectHandle()) = reader->ReadObjectImpl(kAsReference);
     bounded_type.StorePointer((bounded_type.raw()->from() + i),
                               reader->PassiveObjectHandle()->raw());
   }
 
   return bounded_type.raw();
 }
 
 
 void RawBoundedType::WriteTo(SnapshotWriter* writer,
                              intptr_t object_id,
@@ skipping 37 matching lines @@
 
   // Read the length so that we can determine instance size to allocate.
   intptr_t len = reader->ReadSmiValue();
 
   TypeArguments& type_arguments = TypeArguments::ZoneHandle(
       reader->zone(), NEW_OBJECT_WITH_LEN_SPACE(TypeArguments, len, kind));
   reader->AddBackRef(object_id, &type_arguments, kIsDeserialized);
 
   // Set the instantiations field, which is only read from a full snapshot.
   if (kind == Snapshot::kFull) {
-    *(reader->ArrayHandle()) ^= reader->ReadObjectImpl();
+    *(reader->ArrayHandle()) ^= reader->ReadObjectImpl(kAsInlinedObject);
     type_arguments.set_instantiations(*(reader->ArrayHandle()));
   } else {
     type_arguments.set_instantiations(Object::zero_array());
   }
 
   // Now set all the type fields.
   for (intptr_t i = 0; i < len; i++) {
-    *reader->TypeHandle() ^= reader->ReadObjectImpl();
+    *reader->TypeHandle() ^= reader->ReadObjectImpl(kAsInlinedObject);
     type_arguments.SetTypeAt(i, *reader->TypeHandle());
   }
 
   // If object needs to be a canonical object, Canonicalize it.
   // When reading a full snapshot we don't need to canonicalize the object
   // as it would already be a canonical object.
   // When reading a script snapshot we need to canonicalize only those object
   // references that are objects from the core library (loaded from a
   // full snapshot). Objects that are only in the script need not be
   // canonicalized as they are already canonical.
@@ skipping 24 matching lines @@
 
   // Write out the class and tags information.
   writer->WriteVMIsolateObject(kTypeArgumentsCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
   // Write out the length field.
   writer->Write<RawObject*>(ptr()->length_);
 
   // Write out the instantiations field, but only in a full snapshot.
   if (kind == Snapshot::kFull) {
-    writer->WriteObjectImpl(ptr()->instantiations_);
+    writer->WriteObjectImpl(ptr()->instantiations_, kAsInlinedObject);
   }
 
   // Write out the individual types.
   intptr_t len = Smi::Value(ptr()->length_);
   for (intptr_t i = 0; i < len; i++) {
-    writer->WriteObjectImpl(ptr()->types()[i]);
+    writer->WriteObjectImpl(ptr()->types()[i], kAsInlinedObject);
   }
 }
 
 
 RawPatchClass* PatchClass::ReadFrom(SnapshotReader* reader,
                                     intptr_t object_id,
                                     intptr_t tags,
                                     Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   ASSERT(((kind == Snapshot::kScript) &&
           !RawObject::IsCreatedFromSnapshot(tags)) ||
          (kind == Snapshot::kFull));
 
   // Allocate function object.
   PatchClass& cls = PatchClass::ZoneHandle(reader->zone(),
                                             NEW_OBJECT(PatchClass));
   reader->AddBackRef(object_id, &cls, kIsDeserialized);
 
   // Set the object tags.
   cls.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 = (cls.raw()->to() - cls.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
-    (*reader->PassiveObjectHandle()) = reader->ReadObjectRef();
+    (*reader->PassiveObjectHandle()) = reader->ReadObjectImpl(kAsReference);
     cls.StorePointer((cls.raw()->from() + i),
                      reader->PassiveObjectHandle()->raw());
   }
 
   return cls.raw();
 }
 
 
 void RawPatchClass::WriteTo(SnapshotWriter* writer,
                             intptr_t object_id,
@@ skipping 30 matching lines @@
   reader->AddBackRef(object_id, &data, kIsDeserialized);
 
   // Set the object tags.
   data.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 = (data.raw()->to() - data.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
-    *(data.raw()->from() + i) = reader->ReadObjectRef();
+    *(data.raw()->from() + i) = reader->ReadObjectImpl(kAsReference);
   }
 
   return data.raw();
 }
 
 
 void RawClosureData::WriteTo(SnapshotWriter* writer,
                              intptr_t object_id,
                              Snapshot::Kind kind) {
   ASSERT(writer != NULL);
   ASSERT(((kind == Snapshot::kScript) &&
           !RawObject::IsCreatedFromSnapshot(writer->GetObjectTags(this))) ||
          (kind == Snapshot::kFull));
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteVMIsolateObject(kClosureDataCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
   // Context scope.
   // We don't write the context scope in the snapshot.
-  writer->WriteObjectImpl(Object::null());
+  writer->WriteObjectImpl(Object::null(), kAsInlinedObject);
 
   // Parent function.
-  writer->WriteObjectImpl(ptr()->parent_function_);
+  writer->WriteObjectImpl(ptr()->parent_function_, kAsInlinedObject);
 
   // Signature class.
-  writer->WriteObjectImpl(ptr()->signature_class_);
+  writer->WriteObjectImpl(ptr()->signature_class_, kAsInlinedObject);
 
   // Static closure/Closure allocation stub.
   // We don't write the closure or allocation stub in the snapshot.
-  writer->WriteObjectImpl(Object::null());
+  writer->WriteObjectImpl(Object::null(), kAsInlinedObject);
 }
 
 
 RawRedirectionData* RedirectionData::ReadFrom(SnapshotReader* reader,
                                               intptr_t object_id,
                                               intptr_t tags,
                                               Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   ASSERT(((kind == Snapshot::kScript) &&
           !RawObject::IsCreatedFromSnapshot(tags)) ||
          (kind == Snapshot::kFull));
 
   // Allocate redirection data object.
   RedirectionData& data = RedirectionData::ZoneHandle(
       reader->zone(), NEW_OBJECT(RedirectionData));
   reader->AddBackRef(object_id, &data, kIsDeserialized);
 
   // Set the object tags.
   data.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 = (data.raw()->to() - data.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
-    (*reader->PassiveObjectHandle()) = reader->ReadObjectRef();
+    (*reader->PassiveObjectHandle()) = reader->ReadObjectImpl(kAsReference);
     data.StorePointer((data.raw()->from() + i),
                       reader->PassiveObjectHandle()->raw());
   }
 
   return data.raw();
 }
 
 
 void RawRedirectionData::WriteTo(SnapshotWriter* writer,
                                  intptr_t object_id,
@@ skipping 43 matching lines @@
   func.set_regexp_cid(reader->ReadClassIDValue());
   func.set_kind_tag(reader->Read<uint32_t>());
   func.set_optimized_instruction_count(reader->Read<uint16_t>());
   func.set_optimized_call_site_count(reader->Read<uint16_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 = (func.raw()->to_snapshot() - func.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
-    (*reader->PassiveObjectHandle()) = reader->ReadObjectRef();
+    (*reader->PassiveObjectHandle()) = reader->ReadObjectImpl(kAsReference);
     func.StorePointer((func.raw()->from() + i),
                       reader->PassiveObjectHandle()->raw());
   }
 
   // Initialize all fields that are not part of the snapshot.
   func.ClearICDataArray();
   func.ClearCode();
   return func.raw();
 }
 
@@ skipping 51 matching lines @@
   field.set_token_pos(reader->Read<int32_t>());
   field.set_guarded_cid(reader->Read<int32_t>());
   field.set_is_nullable(reader->Read<int32_t>());
   field.set_kind_bits(reader->Read<uint8_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 = (field.raw()->to() - field.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
-    (*reader->PassiveObjectHandle()) = reader->ReadObjectRef();
+    (*reader->PassiveObjectHandle()) = reader->ReadObjectImpl(kAsReference);
     field.StorePointer((field.raw()->from() + i),
                        reader->PassiveObjectHandle()->raw());
   }
 
   field.InitializeGuardedListLengthInObjectOffset();
 
   return field.raw();
 }
 
 
@@ skipping 41 matching lines @@
 
   // Read the token attributes.
   Token::Kind token_kind = static_cast<Token::Kind>(reader->Read<int32_t>());
   literal_token.set_kind(token_kind);
 
   // Set all the object fields.
   // TODO(5411462): Need to assert No GC can happen here, even though
   // allocations may happen.
   intptr_t num_flds = (literal_token.raw()->to() - literal_token.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
-    (*reader->PassiveObjectHandle()) = reader->ReadObjectRef();
+    (*reader->PassiveObjectHandle()) = reader->ReadObjectImpl(kAsReference);
     literal_token.StorePointer((literal_token.raw()->from() + i),
                                reader->PassiveObjectHandle()->raw());
   }
 
   return literal_token.raw();
 }
 
 
 void RawLiteralToken::WriteTo(SnapshotWriter* writer,
                               intptr_t object_id,
@@ skipping 39 matching lines @@
 
   // Read the stream of tokens into the TokenStream object for script
   // snapshots as we made a copy of token stream.
   if (kind == Snapshot::kScript) {
     NoSafepointScope no_safepoint;
     RawExternalTypedData* stream = token_stream.GetStream();
     reader->ReadBytes(stream->ptr()->data_, len);
   }
 
   // Read in the literal/identifier token array.
-  *(reader->TokensHandle()) ^= reader->ReadObjectImpl();
+  *(reader->TokensHandle()) ^= reader->ReadObjectImpl(kAsInlinedObject);
   token_stream.SetTokenObjects(*(reader->TokensHandle()));
   // Read in the private key in use by the token stream.
-  *(reader->StringHandle()) ^= reader->ReadObjectImpl();
+  *(reader->StringHandle()) ^= reader->ReadObjectImpl(kAsInlinedObject);
   token_stream.SetPrivateKey(*(reader->StringHandle()));
 
   return token_stream.raw();
 }
 
 
 void RawTokenStream::WriteTo(SnapshotWriter* writer,
                              intptr_t object_id,
                              Snapshot::Kind kind) {
   ASSERT(writer != NULL);
   ASSERT(((kind == Snapshot::kScript) &&
           !RawObject::IsCreatedFromSnapshot(writer->GetObjectTags(this))) ||
          (kind == Snapshot::kFull));
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteVMIsolateObject(kTokenStreamCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
   // Write out the length field and the token stream.
   RawExternalTypedData* stream = ptr()->stream_;
   intptr_t len = Smi::Value(stream->ptr()->length_);
   writer->Write<RawObject*>(stream->ptr()->length_);
   writer->WriteBytes(stream->ptr()->data_, len);
 
   // Write out the literal/identifier token array.
-  writer->WriteObjectImpl(ptr()->token_objects_);
+  writer->WriteObjectImpl(ptr()->token_objects_, kAsInlinedObject);
   // Write out the private key in use by the token stream.
-  writer->WriteObjectImpl(ptr()->private_key_);
+  writer->WriteObjectImpl(ptr()->private_key_, kAsInlinedObject);
 }
 
 
 RawScript* Script::ReadFrom(SnapshotReader* reader,
                             intptr_t object_id,
                             intptr_t tags,
                             Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   ASSERT(((kind == Snapshot::kScript) &&
           !RawObject::IsCreatedFromSnapshot(tags)) ||
@@ skipping 11 matching lines @@
   script.StoreNonPointer(&script.raw_ptr()->col_offset_,
                          reader->Read<int32_t>());
   script.StoreNonPointer(&script.raw_ptr()->kind_,
                          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 = (script.raw()->to_snapshot() - script.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
-    (*reader->PassiveObjectHandle()) = reader->ReadObjectRef();
+    (*reader->PassiveObjectHandle()) = reader->ReadObjectImpl(kAsReference);
     script.StorePointer((script.raw()->from() + i),
                         reader->PassiveObjectHandle()->raw());
   }
   // Script wasn't allocated with nulls?
   *reader->StringHandle() ^= String::null();
   script.set_source(*reader->StringHandle());
 
   return script.raw();
 }
 
@@ skipping 31 matching lines @@
                               Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   ASSERT(kind != Snapshot::kMessage);
 
   Library& library = Library::ZoneHandle(reader->zone(), Library::null());
   reader->AddBackRef(object_id, &library, kIsDeserialized);
 
   if ((kind == Snapshot::kScript) && RawObject::IsCreatedFromSnapshot(tags)) {
     ASSERT(kind != Snapshot::kFull);
     // Lookup the object as it should already exist in the heap.
-    *reader->StringHandle() ^= reader->ReadObjectImpl();
+    *reader->StringHandle() ^= reader->ReadObjectImpl(kAsInlinedObject);
     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.StoreNonPointer(&library.raw_ptr()->index_,
@@ skipping 14 matching lines @@
     library.set_native_entry_resolver(NULL);
     library.set_native_entry_symbol_resolver(NULL);
     // The cache of loaded scripts is not serialized.
     library.StorePointer(&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++) {
-      (*reader->PassiveObjectHandle()) = reader->ReadObjectRef();
+      (*reader->PassiveObjectHandle()) = reader->ReadObjectImpl(kAsReference);
       library.StorePointer((library.raw()->from() + i),
                            reader->PassiveObjectHandle()->raw());
     }
     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->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteVMIsolateObject(kLibraryCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
   if ((kind == Snapshot::kScript) &&
       RawObject::IsCreatedFromSnapshot(writer->GetObjectTags(this))) {
     ASSERT(kind != Snapshot::kFull);
     // Write out library URL so that it can be looked up when reading.
-    writer->WriteObjectImpl(ptr()->url_);
+    writer->WriteObjectImpl(ptr()->url_, kAsInlinedObject);
   } else {
     // Write out all non object fields.
     writer->WriteClassIDValue(ptr()->index_);
     writer->WriteClassIDValue(ptr()->num_anonymous_);
     writer->Write<uint16_t>(ptr()->num_imports_);
     writer->Write<int8_t>(ptr()->load_state_);
     writer->Write<bool>(ptr()->corelib_imported_);
     writer->Write<bool>(ptr()->is_dart_scheme_);
     writer->Write<bool>(ptr()->debuggable_);
     // We do not serialize the native resolver or symbolizer. These need to be
@@ skipping 31 matching lines @@
                          reader->Read<int16_t>());
   prefix.StoreNonPointer(&prefix.raw_ptr()->is_deferred_load_,
                          reader->Read<bool>());
   prefix.StoreNonPointer(&prefix.raw_ptr()->is_loaded_, 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 = (prefix.raw()->to() - prefix.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
-    (*reader->PassiveObjectHandle()) = reader->ReadObjectRef();
+    (*reader->PassiveObjectHandle()) = reader->ReadObjectImpl(kAsReference);
     prefix.StorePointer((prefix.raw()->from() + i),
                          reader->PassiveObjectHandle()->raw());
   }
 
   return prefix.raw();
 }
 
 
 void RawLibraryPrefix::WriteTo(SnapshotWriter* writer,
                                intptr_t object_id,
@@ skipping 36 matching lines @@
   reader->AddBackRef(object_id, &ns, kIsDeserialized);
 
   // Set the object tags.
   ns.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 = (ns.raw()->to() - ns.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
-    (*reader->PassiveObjectHandle()) = reader->ReadObjectRef();
+    (*reader->PassiveObjectHandle()) = reader->ReadObjectImpl(kAsReference);
     ns.StorePointer((ns.raw()->from() + i),
                     reader->PassiveObjectHandle()->raw());
   }
 
   return ns.raw();
 }
 
 
 void RawNamespace::WriteTo(SnapshotWriter* writer,
                            intptr_t object_id,
@@ skipping 168 matching lines @@
 
   LocalVarDescriptors& result =
       LocalVarDescriptors::ZoneHandle(reader->zone(),
         LocalVarDescriptors::New(num_entries));
   reader->AddBackRef(object_id, &result, kIsDeserialized);
 
   // Set the object tags.
   result.set_tags(tags);
 
   for (intptr_t i = 0; i < num_entries; i++) {
-    (*reader->StringHandle()) ^= reader->ReadObjectRef();
+    (*reader->StringHandle()) ^= reader->ReadObjectImpl(kAsReference);
     result.StorePointer(result.raw()->nameAddrAt(i),
                         reader->StringHandle()->raw());
   }
 
   if (num_entries > 0) {
     NoSafepointScope no_safepoint;
     intptr_t len = num_entries * sizeof(RawLocalVarDescriptors::VarInfo);
     uint8_t* data = result.UnsafeMutableNonPointer(
         reinterpret_cast<const uint8_t*>(result.raw()->data()));
     reader->ReadBytes(data, len);
   }
 
   return result.raw();
 }
 
 
 void RawLocalVarDescriptors::WriteTo(SnapshotWriter* writer,
                                      intptr_t object_id,
                                      Snapshot::Kind kind) {
   ASSERT(writer->allow_code());
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
   writer->WriteIndexedObject(kLocalVarDescriptorsCid);
   writer->WriteTags(writer->GetObjectTags(this));
   writer->Write<int32_t>(ptr()->num_entries_);
   for (intptr_t i = 0; i < ptr()->num_entries_; i++) {
-    writer->WriteObjectImpl(ptr()->names()[i]);
+    writer->WriteObjectImpl(ptr()->names()[i], kAsInlinedObject);
   }
   if (ptr()->num_entries_ > 0) {
     intptr_t len = ptr()->num_entries_ * sizeof(VarInfo);
     uint8_t* data = reinterpret_cast<uint8_t*>(this->data());
     writer->WriteBytes(data, len);
   }
 }
 
 
 RawExceptionHandlers* ExceptionHandlers::ReadFrom(SnapshotReader* reader,
                                                   intptr_t object_id,
                                                   intptr_t tags,
                                                   Snapshot::Kind kind) {
   ASSERT(reader->allow_code());
 
-  *(reader->ArrayHandle()) ^= reader->ReadObjectImpl();  // handled_types_data_
+  // handled_types_data.
+  *(reader->ArrayHandle()) ^= reader->ReadObjectImpl(kAsInlinedObject);
 
   ExceptionHandlers& result =
       ExceptionHandlers::ZoneHandle(reader->zone(),
         ExceptionHandlers::New(*reader->ArrayHandle()));
   reader->AddBackRef(object_id, &result, kIsDeserialized);
 
   // Set the object tags.
   result.set_tags(tags);
 
   if (result.num_entries() > 0) {
@@ skipping 11 matching lines @@
 
 void RawExceptionHandlers::WriteTo(SnapshotWriter* writer,
                                    intptr_t object_id,
                                    Snapshot::Kind kind) {
   ASSERT(writer->allow_code());
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
   writer->WriteIndexedObject(kExceptionHandlersCid);
   writer->WriteTags(writer->GetObjectTags(this));
-  writer->WriteObjectImpl(ptr()->handled_types_data_);
+  writer->WriteObjectImpl(ptr()->handled_types_data_, kAsInlinedObject);
 
   if (ptr()->num_entries_ > 0) {
     intptr_t len = ptr()->num_entries_ * sizeof(HandlerInfo);
     uint8_t* data = reinterpret_cast<uint8_t*>(ptr()->data());
     writer->WriteBytes(data, len);
   }
 }
 
 
 RawContext* Context::ReadFrom(SnapshotReader* reader,
@@ skipping 12 matching lines @@
     context ^= NEW_OBJECT_WITH_LEN(Context, num_vars);
 
     // Set the object tags.
     context.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 = (context.raw()->to(num_vars) - context.raw()->from());
     for (intptr_t i = 0; i <= num_flds; i++) {
-      (*reader->PassiveObjectHandle()) = reader->ReadObjectRef();
+      (*reader->PassiveObjectHandle()) = reader->ReadObjectImpl(kAsReference);
       context.StorePointer((context.raw()->from() + i),
                            reader->PassiveObjectHandle()->raw());
     }
   }
   return context.raw();
 }
 
 
 void RawContext::WriteTo(SnapshotWriter* writer,
                          intptr_t object_id,
@@ skipping 110 matching lines @@
   reader->AddBackRef(object_id, &api_error, kIsDeserialized);
 
   // Set the object tags.
   api_error.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 = (api_error.raw()->to() - api_error.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
-    (*reader->PassiveObjectHandle()) = reader->ReadObjectRef();
+    (*reader->PassiveObjectHandle()) = reader->ReadObjectImpl(kAsReference);
     api_error.StorePointer((api_error.raw()->from() + i),
                            reader->PassiveObjectHandle()->raw());
   }
 
   return api_error.raw();
 }
 
 
 void RawApiError::WriteTo(SnapshotWriter* writer,
                           intptr_t object_id,
@@ skipping 30 matching lines @@
   // Set all non object fields.
   language_error.set_token_pos(reader->Read<int32_t>());
   language_error.set_kind(reader->Read<uint8_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 =
       (language_error.raw()->to() - language_error.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
-    (*reader->PassiveObjectHandle()) = reader->ReadObjectRef();
+    (*reader->PassiveObjectHandle()) = reader->ReadObjectImpl(kAsReference);
     language_error.StorePointer((language_error.raw()->from() + i),
                                 reader->PassiveObjectHandle()->raw());
   }
 
   return language_error.raw();
 }
 
 
 void RawLanguageError::WriteTo(SnapshotWriter* writer,
                                intptr_t object_id,
@@ skipping 26 matching lines @@
   reader->AddBackRef(object_id, &result, kIsDeserialized);
 
   // Set the object tags.
   result.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 = (result.raw()->to() - result.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
-    (*reader->PassiveObjectHandle()) = reader->ReadObjectRef();
+    (*reader->PassiveObjectHandle()) = reader->ReadObjectImpl(kAsReference);
     result.StorePointer((result.raw()->from() + i),
                          reader->PassiveObjectHandle()->raw());
   }
 
   return result.raw();
 }
 
 
 void RawUnhandledException::WriteTo(SnapshotWriter* writer,
                                     intptr_t object_id,
@@ skipping 145 matching lines @@
 
   // Allocate bigint object.
   Bigint& obj = Bigint::ZoneHandle(reader->zone(), NEW_OBJECT(Bigint));
   reader->AddBackRef(object_id, &obj, kIsDeserialized);
 
   // Set all the object fields.
   // TODO(5411462): Need to assert No GC can happen here, even though
   // allocations may happen.
   intptr_t num_flds = (obj.raw()->to() - obj.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
-    (*reader->PassiveObjectHandle()) = reader->ReadObjectImpl();
+    (*reader->PassiveObjectHandle()) = reader->ReadObjectImpl(kAsInlinedObject);
     obj.StorePointer(obj.raw()->from() + i,
                      reader->PassiveObjectHandle()->raw());
   }
 
   // If it is a canonical constant make it one.
   // When reading a full snapshot we don't need to canonicalize the object
   // as it would already be a canonical object.
   // When reading a script snapshot we need to canonicalize only those object
   // references that are objects from the core library (loaded from a
   // full snapshot). Objects that are only in the script need not be
@@ skipping 415 matching lines @@
   GrowableObjectArray& array = GrowableObjectArray::ZoneHandle(
       reader->zone(), GrowableObjectArray::null());
   if (kind == Snapshot::kFull) {
     array = reader->NewGrowableObjectArray();
   } else {
     array = GrowableObjectArray::New(0, HEAP_SPACE(kind));
   }
   reader->AddBackRef(object_id, &array, kIsDeserialized);
   intptr_t length = reader->ReadSmiValue();
   array.SetLength(length);
-  *(reader->ArrayHandle()) ^= reader->ReadObjectImpl();
+  *(reader->ArrayHandle()) ^= reader->ReadObjectImpl(kAsInlinedObject);
   array.SetData(*(reader->ArrayHandle()));
   *(reader->TypeArgumentsHandle()) = reader->ArrayHandle()->GetTypeArguments();
   array.SetTypeArguments(*(reader->TypeArgumentsHandle()));
   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->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteIndexedObject(kGrowableObjectArrayCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
   // Write out the used length field.
   writer->Write<RawObject*>(ptr()->length_);
 
   // Write out the Array object.
-  writer->WriteObjectImpl(ptr()->data_);
+  writer->WriteObjectImpl(ptr()->data_, kAsInlinedObject);
 }
 
 
 RawLinkedHashMap* LinkedHashMap::ReadFrom(SnapshotReader* reader,
                                           intptr_t object_id,
                                           intptr_t tags,
                                           Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   LinkedHashMap& map = LinkedHashMap::ZoneHandle(
       reader->zone(), LinkedHashMap::null());
   if (kind == Snapshot::kFull || kind == Snapshot::kScript) {
     // The immutable maps that seed map literals are not yet VM-internal, so
     // we don't reach this.
     UNREACHABLE();
   } else {
     // Since the map might contain itself as a key or value, allocate first.
     map = LinkedHashMap::NewUninitialized(HEAP_SPACE(kind));
   }
   reader->AddBackRef(object_id, &map, kIsDeserialized);
   // Set the object tags.
   map.set_tags(tags);
 
   // Read the type arguments.
-  *reader->TypeArgumentsHandle() ^= reader->ReadObjectImpl();
+  *reader->TypeArgumentsHandle() ^= reader->ReadObjectImpl(kAsInlinedObject);
   map.SetTypeArguments(*reader->TypeArgumentsHandle());
 
   // Read the number of key/value pairs.
   intptr_t len = reader->ReadSmiValue();
   intptr_t used_data = (len << 1);
   map.SetUsedData(used_data);
 
   // Allocate the data array.
   intptr_t data_size = Utils::Maximum(
       Utils::RoundUpToPowerOfTwo(used_data),
       static_cast<uintptr_t>(LinkedHashMap::kInitialIndexSize));
   Array& data = Array::ZoneHandle(reader->zone(),
                                   Array::New(data_size, HEAP_SPACE(kind)));
   map.SetData(data);
   map.SetDeletedKeys(0);
 
   // The index and hashMask is regenerated by the maps themselves on demand.
   // Thus, the index will probably be allocated in new space (unless it's huge).
   // TODO(koda): Eagerly rehash here when no keys have user-defined '==', and
   // in particular, if/when (const) maps are needed in the VM isolate snapshot.
   ASSERT(reader->isolate() != Dart::vm_isolate());
   map.SetHashMask(0);  // Prefer sentinel 0 over null for better type feedback.
 
   // Read the keys and values.
-  bool is_canonical = RawObject::IsCanonical(tags);
+  bool as_reference = RawObject::IsCanonical(tags) ? false : true;
   for (intptr_t i = 0; i < used_data; i++) {
-    *reader->PassiveObjectHandle() =
-        is_canonical ? reader->ReadObjectImpl() : reader->ReadObjectRef();
+    *reader->PassiveObjectHandle() = reader->ReadObjectImpl(as_reference);
     data.SetAt(i, *reader->PassiveObjectHandle());
   }
   return map.raw();
 }
 
 
 void RawLinkedHashMap::WriteTo(SnapshotWriter* writer,
                                intptr_t object_id,
                                Snapshot::Kind kind) {
   if (kind == Snapshot::kFull || kind == Snapshot::kScript) {
     // The immutable maps that seed map literals are not yet VM-internal, so
     // we don't reach this.
     UNREACHABLE();
   }
   ASSERT(writer != NULL);
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteIndexedObject(kLinkedHashMapCid);
   const uword tags = writer->GetObjectTags(this);
   writer->WriteTags(tags);
 
   // Write out the type arguments.
-  writer->WriteObjectImpl(ptr()->type_arguments_);
+  writer->WriteObjectImpl(ptr()->type_arguments_, kAsInlinedObject);
 
   const intptr_t used_data = Smi::Value(ptr()->used_data_);
   ASSERT((used_data & 1) == 0);  // Keys + values, so must be even.
   const intptr_t deleted_keys = Smi::Value(ptr()->deleted_keys_);
 
   // Write out the number of (not deleted) key/value pairs that will follow.
   writer->Write<RawObject*>(Smi::New((used_data >> 1) - deleted_keys));
 
   // Write out the keys and values.
-  const bool is_canonical = RawObject::IsCanonical(tags);
+  const bool as_reference = RawObject::IsCanonical(tags) ? false : true;
   RawArray* data_array = ptr()->data_;
   RawObject** data_elements = data_array->ptr()->data();
   ASSERT(used_data <= Smi::Value(data_array->ptr()->length_));
 #if defined(DEBUG)
   intptr_t deleted_keys_found = 0;
 #endif  // DEBUG
   for (intptr_t i = 0; i < used_data; i += 2) {
     RawObject* key = data_elements[i];
     if (key == data_array) {
 #if defined(DEBUG)
       ++deleted_keys_found;
 #endif  // DEBUG
       continue;
     }
     RawObject* value = data_elements[i + 1];
-    if (is_canonical) {
-      writer->WriteObjectImpl(key);
-      writer->WriteObjectImpl(value);
-    } else {
-      writer->WriteObjectRef(key);
-      writer->WriteObjectRef(value);
-    }
+    writer->WriteObjectImpl(key, as_reference);
+    writer->WriteObjectImpl(value, as_reference);
   }
   DEBUG_ASSERT(deleted_keys_found == deleted_keys);
 }
 
 
 RawFloat32x4* Float32x4::ReadFrom(SnapshotReader* reader,
                                   intptr_t object_id,
                                   intptr_t tags,
                                   Snapshot::Kind kind) {
   ASSERT(reader != NULL);
@@ skipping 432 matching lines @@
   if (kind == Snapshot::kFull) {
     Stacktrace& result = Stacktrace::ZoneHandle(reader->zone(),
                                                 reader->NewStacktrace());
     reader->AddBackRef(object_id, &result, kIsDeserialized);
 
     // Set all the object fields.
     // TODO(5411462): Need to assert No GC can happen here, even though
     // allocations may happen.
     intptr_t num_flds = (result.raw()->to() - result.raw()->from());
     for (intptr_t i = 0; i <= num_flds; i++) {
-      (*reader->PassiveObjectHandle()) = reader->ReadObjectRef();
+      (*reader->PassiveObjectHandle()) = reader->ReadObjectImpl(kAsReference);
       result.StorePointer((result.raw()->from() + i),
                           reader->PassiveObjectHandle()->raw());
     }
 
     bool expand_inlined = reader->Read<bool>();
     result.set_expand_inlined(expand_inlined);
 
     return result.raw();
   }
   UNREACHABLE();  // Stacktraces are not sent in a snapshot.
@@ skipping 41 matching lines @@
   JSRegExp& regex = JSRegExp::ZoneHandle(
       reader->zone(), JSRegExp::New(HEAP_SPACE(kind)));
   reader->AddBackRef(object_id, &regex, kIsDeserialized);
 
   // Set the object tags.
   regex.set_tags(tags);
 
   // Read and Set all the other fields.
   regex.StoreSmi(&regex.raw_ptr()->num_bracket_expressions_,
                  reader->ReadAsSmi());
-  *reader->StringHandle() ^= reader->ReadObjectImpl();
+  *reader->StringHandle() ^= reader->ReadObjectImpl(kAsInlinedObject);
   regex.set_pattern(*reader->StringHandle());
   regex.StoreNonPointer(&regex.raw_ptr()->num_registers_,
                         reader->Read<int32_t>());
   regex.StoreNonPointer(&regex.raw_ptr()->type_flags_,
                         reader->Read<int8_t>());
 
   // TODO(18854): Need to implement a way of recreating the irrexp functions.
   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->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteIndexedObject(kJSRegExpCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
   // Write out all the other fields.
   writer->Write<RawObject*>(ptr()->num_bracket_expressions_);
-  writer->WriteObjectImpl(ptr()->pattern_);
+  writer->WriteObjectImpl(ptr()->pattern_, kAsInlinedObject);
   writer->Write<int32_t>(ptr()->num_registers_);
   writer->Write<int8_t>(ptr()->type_flags_);
 }
 
 
 RawWeakProperty* WeakProperty::ReadFrom(SnapshotReader* reader,
                                         intptr_t object_id,
                                         intptr_t tags,
                                         Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   // Allocate the weak property object.
   WeakProperty& weak_property = WeakProperty::ZoneHandle(
       reader->zone(), WeakProperty::New(HEAP_SPACE(kind)));
   reader->AddBackRef(object_id, &weak_property, kIsDeserialized);
 
   // Set the object tags.
   weak_property.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 = (weak_property.raw()->to() -
                        weak_property.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
-    (*reader->PassiveObjectHandle()) = reader->ReadObjectRef();
+    (*reader->PassiveObjectHandle()) = reader->ReadObjectImpl(kAsReference);
     weak_property.StorePointer((weak_property.raw()->from() + i),
                                reader->PassiveObjectHandle()->raw());
   }
 
   return weak_property.raw();
 }
 
 
 void RawWeakProperty::WriteTo(SnapshotWriter* writer,
                           intptr_t object_id,
@@ skipping 52 matching lines @@
     // We do not allow objects with native fields in an isolate message.
     writer->SetWriteException(Exceptions::kArgument,
                               "Illegal argument in isolate message"
                               " : (object is a UserTag)");
   } else {
     UNREACHABLE();
   }
 }
 
 }  // namespace dart