- Canonicalize types, type_arguments only when the object is marked as being from the core librarie…

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 187 matching lines @@
 
   // 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());
   }
 
   // If object needs to be a canonical object, Canonicalize it.
-  if ((kind != Snapshot::kFull) && RawObject::IsCanonical(tags)) {
+  // 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.
+  if ((kind != Snapshot::kFull) && RawObject::IsCanonical(tags) &&
+      (RawObject::IsCreatedFromSnapshot(tags) ||
+       (kind == Snapshot::kMessage))) {
     type ^= type.Canonicalize();
   }
 
   // Set the object tags (This is done after 'Canonicalize', which
   // does not canonicalize a type already marked as canonical).
   type.set_tags(tags);
 
   return type.raw();
 }
 
@@ skipping 232 matching lines @@
       reader->isolate(), NEW_OBJECT_WITH_LEN_SPACE(TypeArguments, len, kind));
   reader->AddBackRef(object_id, &type_arguments, kIsDeserialized);
 
   // Now set all the object fields.
   for (intptr_t i = 0; i < len; i++) {
     *reader->TypeHandle() ^= reader->ReadObjectImpl();
     type_arguments.SetTypeAt(i, *reader->TypeHandle());
   }
 
   // If object needs to be a canonical object, Canonicalize it.
-  if ((kind != Snapshot::kFull) && RawObject::IsCanonical(tags)) {
+  // 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.
+  if ((kind != Snapshot::kFull) && RawObject::IsCanonical(tags) &&
+      (RawObject::IsCreatedFromSnapshot(tags) ||
+       (kind == Snapshot::kMessage))) {
     type_arguments ^= type_arguments.Canonicalize();
   }
 
   // Set the object tags (This is done after setting the object fields
   // because 'SetTypeAt' has an assertion to check if the object is not
   // already canonical. Also, this is done after 'Canonicalize', which
   // does not canonicalize a type already marked as canonical).
   type_arguments.set_tags(tags);
 
   return type_arguments.raw();
@@ skipping 1118 matching lines @@
   ASSERT(reader != NULL);
 
   // Read the 64 bit value for the object.
   int64_t value = reader->Read<int64_t>();
 
   // Create a Mint object or get canonical one if it is a canonical constant.
   Mint& mint = Mint::ZoneHandle(reader->isolate(), Mint::null());
   if (kind == Snapshot::kFull) {
     mint = reader->NewMint(value);
   } else {
-    if (RawObject::IsCanonical(tags)) {
+    // 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.
+    if (RawObject::IsCanonical(tags) &&
+        (RawObject::IsCreatedFromSnapshot(tags) ||
+         (kind == Snapshot::kMessage))) {
       mint = Mint::NewCanonical(value);
     } else {
       mint = Mint::New(value, HEAP_SPACE(kind));
     }
   }
   reader->AddBackRef(object_id, &mint, kIsDeserialized);
 
   // Set the object tags.
   mint.set_tags(tags);
 
@@ skipping 30 matching lines @@
   str[len] = '\0';
   reader->ReadBytes(reinterpret_cast<uint8_t*>(str), len);
 
   // Create a Bigint object from HexCString.
   Bigint& obj = Bigint::ZoneHandle(
       reader->isolate(),
       ((kind == Snapshot::kFull) ? reader->NewBigint(str) :
        BigintOperations::FromHexCString(str, HEAP_SPACE(kind))));
 
   // If it is a canonical constant make it one.
-  if ((kind != Snapshot::kFull) && RawObject::IsCanonical(tags)) {
+  // 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.
+  if ((kind != Snapshot::kFull) && RawObject::IsCanonical(tags) &&
+      (RawObject::IsCreatedFromSnapshot(tags) ||
+       (kind == Snapshot::kMessage))) {
     obj ^= obj.Canonicalize();
   }
   reader->AddBackRef(object_id, &obj, kIsDeserialized);
 
   // Set the object tags.
   obj.set_tags(tags);
 
   return obj.raw();
 }
 
@@ skipping 46 matching lines @@
                             Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   // Read the double value for the object.
   double value = reader->Read<double>();
 
   // Create a Double object or get canonical one if it is a canonical constant.
   Double& dbl = Double::ZoneHandle(reader->isolate(), Double::null());
   if (kind == Snapshot::kFull) {
     dbl = reader->NewDouble(value);
   } else {
-    if (RawObject::IsCanonical(tags)) {
+    // 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.
+    if (RawObject::IsCanonical(tags) &&
+        (RawObject::IsCreatedFromSnapshot(tags) ||
+         (kind == Snapshot::kMessage))) {
       dbl = Double::NewCanonical(value);
     } else {
       dbl = Double::New(value, HEAP_SPACE(kind));
     }
   }
   reader->AddBackRef(object_id, &dbl, kIsDeserialized);
 
   // Set the object tags.
   dbl.set_tags(tags);
 
@@ skipping 1067 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