Support serializing ObjectPool as reference.

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/native_entry.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/snapshot.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
@@ skipping 1288 matching lines @@
 
 RawObjectPool* ObjectPool::ReadFrom(SnapshotReader* reader,
                                     intptr_t object_id,
                                     intptr_t tags,
                                     Snapshot::Kind kind) {
   ASSERT(reader->snapshot_code());
   ASSERT(kind == Snapshot::kFull);
 
   intptr_t length = reader->Read<intptr_t>();
 
-  ObjectPool& result =
-      ObjectPool::ZoneHandle(reader->zone(),
-                             NEW_OBJECT_WITH_LEN(ObjectPool, length));
-  reader->AddBackRef(object_id, &result, kIsDeserialized);
+  ObjectPool* result =
+      reinterpret_cast<ObjectPool*>(reader->GetBackRef(object_id));
+  if (result == NULL) {
+    result =
+        &(ObjectPool::ZoneHandle(reader->zone(),
+                                 NEW_OBJECT_WITH_LEN(ObjectPool, length)));
+    reader->AddBackRef(object_id, result, kIsDeserialized);
+  }
 
   const TypedData& info_array =
       TypedData::Handle(reader->NewTypedData(kTypedDataInt8ArrayCid, length));
-  result.set_info_array(info_array);
+  result->set_info_array(info_array);
 
   NoSafepointScope no_safepoint;
   for (intptr_t i = 0; i < length; i++) {
     ObjectPool::EntryType entry_type =
         static_cast<ObjectPool::EntryType>(reader->Read<int8_t>());
     *reinterpret_cast<int8_t*>(info_array.DataAddr(i)) = entry_type;
     switch (entry_type) {
       case ObjectPool::kTaggedObject: {
         (*reader->PassiveObjectHandle()) =
-            reader->ReadObjectImpl(kAsInlinedObject);
-        result.SetObjectAt(i, *(reader->PassiveObjectHandle()));
+            reader->ReadObjectImpl(kAsReference);
+        result->SetObjectAt(i, *(reader->PassiveObjectHandle()));
         break;
       }
       case ObjectPool::kImmediate: {
         intptr_t raw_value = reader->Read<intptr_t>();
-        result.SetRawValueAt(i, raw_value);
+        result->SetRawValueAt(i, raw_value);
         break;
       }
       case ObjectPool::kNativeEntry: {
         // Read nothing. Initialize with the lazy link entry.
         uword new_entry = NativeEntry::LinkNativeCallEntry();
-        result.SetRawValueAt(i, static_cast<intptr_t>(new_entry));
+        result->SetRawValueAt(i, static_cast<intptr_t>(new_entry));
         break;
       }
       default:
         UNREACHABLE();
     }
   }
 
-  return result.raw();
+  return result->raw();
 }
 
 
 void RawObjectPool::WriteTo(SnapshotWriter* writer,
                             intptr_t object_id,
                             Snapshot::Kind kind) {
   ASSERT(writer->snapshot_code());
   ASSERT(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(kObjectPoolCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
   intptr_t length = ptr()->length_;
   RawTypedData* info_array = ptr()->info_array_->ptr();
   ASSERT(info_array != TypedData::null());
 
   writer->Write<intptr_t>(length);
   for (intptr_t i = 0; i < length; i++) {
     ObjectPool::EntryType entry_type =
         static_cast<ObjectPool::EntryType>(info_array->data()[i]);
     writer->Write<int8_t>(entry_type);
     Entry& entry = ptr()->data()[i];
     switch (entry_type) {
       case ObjectPool::kTaggedObject: {
-        writer->WriteObjectImpl(entry.raw_obj_, kAsInlinedObject);
+        writer->WriteObjectImpl(entry.raw_obj_, kAsReference);
         break;
       }
       case ObjectPool::kImmediate: {
         writer->Write<intptr_t>(entry.raw_value_);
         break;
       }
       case ObjectPool::kNativeEntry: {
         // Write nothing. Will initialize with the lazy link entry.
         break;
       }
@@ skipping 327 matching lines @@
 
   ICData& result = ICData::ZoneHandle(reader->zone(), NEW_OBJECT(ICData));
   reader->AddBackRef(object_id, &result, kIsDeserialized);
 
   result.set_deopt_id(reader->Read<int32_t>());
   result.set_state_bits(reader->Read<uint32_t>());
 
   // Set all the object fields.
   READ_OBJECT_FIELDS(result,
                      result.raw()->from(), result.raw()->to(),
-                     kAsInlinedObject);
+                     kAsReference);
 
   return result.raw();
 }
 
 
 void RawICData::WriteTo(SnapshotWriter* writer,
                         intptr_t object_id,
                         Snapshot::Kind kind) {
   ASSERT((kind == Snapshot::kScript) || (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(kICDataCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
   // Write out all the non object fields.
   writer->Write<int32_t>(ptr()->deopt_id_);
   writer->Write<uint32_t>(ptr()->state_bits_);
 
   // Write out all the object pointer fields.
-  SnapshotWriterVisitor visitor(writer, kAsInlinedObject);
+  SnapshotWriterVisitor visitor(writer, kAsReference);
   visitor.VisitPointers(from(), to());
 }
 
 
 RawMegamorphicCache* MegamorphicCache::ReadFrom(SnapshotReader* reader,
                                                 intptr_t object_id,
                                                 intptr_t tags,
                                                 Snapshot::Kind kind) {
   ASSERT(reader->snapshot_code());
   ASSERT(kind == Snapshot::kFull);
@@ skipping 1535 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