Use handles to save the object being read before calling StorePointer to make

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/bigint_operations.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/snapshot.h"
 #include "vm/symbols.h"
 #include "vm/visitor.h"
@@ skipping 120 matching lines @@
 
   // Set all non object fields.
   unresolved_class.set_token_pos(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++) {
+    (*reader->ObjectHandle()) = reader->ReadObjectRef();
     unresolved_class.StorePointer((unresolved_class.raw()->from() + i),
-                                  reader->ReadObjectRef());
+                                  reader->ObjectHandle()->raw());
   }
   return unresolved_class.raw();
 }
 
 
 void RawUnresolvedClass::WriteTo(SnapshotWriter* writer,
                                  intptr_t object_id,
                                  Snapshot::Kind kind) {
   ASSERT(writer != NULL);
 
@@ skipping 41 matching lines @@
 
   // Set all non object fields.
   type.set_token_pos(reader->ReadIntptrValue());
   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++) {
-    type.StorePointer((type.raw()->from() + i), reader->ReadObjectRef());
+    (*reader->ObjectHandle()) = reader->ReadObjectRef();
+    type.StorePointer((type.raw()->from() + i), reader->ObjectHandle()->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
   // canonicalized as they are already canonical.
   // When reading a message snapshot we always have to canonicalize the object.
@@ skipping 93 matching lines @@
   type_parameter.set_index(reader->ReadIntptrValue());
   type_parameter.set_token_pos(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++) {
+    (*reader->ObjectHandle()) = reader->ReadObjectRef();
     type_parameter.StorePointer((type_parameter.raw()->from() + i),
-                                reader->ReadObjectRef());
+                                reader->ObjectHandle()->raw());
   }
 
   return type_parameter.raw();
 }
 
 
 void RawTypeParameter::WriteTo(SnapshotWriter* writer,
                                intptr_t object_id,
                                Snapshot::Kind kind) {
   ASSERT(writer != NULL);
@@ skipping 49 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->ObjectHandle()) = reader->ReadObjectRef();
     bounded_type.StorePointer((bounded_type.raw()->from() + i),
-                              reader->ReadObjectRef());
+                              reader->ObjectHandle()->raw());
   }
 
   bounded_type.set_is_being_checked(false);
 
   return bounded_type.raw();
 }
 
 
 void RawBoundedType::WriteTo(SnapshotWriter* writer,
                              intptr_t object_id,
@@ skipping 128 matching lines @@
 
   // 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++) {
+    (*reader->ObjectHandle()) = reader->ReadObjectRef();
     instantiated_type_arguments.StorePointer(
         (instantiated_type_arguments.raw()->from() + i),
-        reader->ReadObjectRef());
+        reader->ObjectHandle()->raw());
   }
   return instantiated_type_arguments.raw();
 }
 
 
 void RawInstantiatedTypeArguments::WriteTo(SnapshotWriter* writer,
                                            intptr_t object_id,
                                            Snapshot::Kind kind) {
   ASSERT(writer != NULL);
   ASSERT(kind == Snapshot::kMessage);
@@ skipping 793 matching lines @@
   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.StorePointer((context.raw()->from() + i), reader->ReadObjectRef());
+    (*reader->ObjectHandle()) = reader->ReadObjectRef();
+    context.StorePointer((context.raw()->from() + i),
+                         reader->ObjectHandle()->raw());
   }
 
   return context.raw();
 }
 
 
 void RawContext::WriteTo(SnapshotWriter* writer,
                          intptr_t object_id,
                          Snapshot::Kind kind) {
   ASSERT(writer != NULL);
@@ skipping 108 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->ObjectHandle()) = reader->ReadObjectRef();
     api_error.StorePointer((api_error.raw()->from() + i),
-                           reader->ReadObjectRef());
+                           reader->ObjectHandle()->raw());
   }
 
   return api_error.raw();
 }
 
 
 void RawApiError::WriteTo(SnapshotWriter* writer,
                           intptr_t object_id,
                           Snapshot::Kind kind) {
   ASSERT(writer != NULL);
@@ skipping 24 matching lines @@
 
   // Set the object tags.
   language_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 =
       (language_error.raw()->to() - language_error.raw()->from());
   for (intptr_t i = 0; i <= num_flds; i++) {
+    (*reader->ObjectHandle()) = reader->ReadObjectRef();
     language_error.StorePointer((language_error.raw()->from() + i),
-                                reader->ReadObjectRef());
+                                reader->ObjectHandle()->raw());
   }
 
   return language_error.raw();
 }
 
 
 void RawLanguageError::WriteTo(SnapshotWriter* writer,
                                intptr_t object_id,
                                Snapshot::Kind kind) {
   ASSERT(writer != NULL);
@@ skipping 1070 matching lines @@
   // Write out the class and tags information.
   writer->WriteIndexedObject(kWeakPropertyCid);
   writer->WriteIntptrValue(writer->GetObjectTags(this));
 
   // Write out all the other fields.
   writer->Write<RawObject*>(ptr()->key_);
   writer->Write<RawObject*>(ptr()->value_);
 }
 
 }  // namespace dart