Implement patch records to patch canonical objects.

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 195 matching lines @@
   // 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());
     for (intptr_t i = 0; i < backward_references_->length(); i++) {
       if (!(*backward_references_)[i].is_deserialized()) {
         ReadObjectImpl();
         (*backward_references_)[i].set_state(kIsDeserialized);
       }
     }
+    ProcessDeferredCanonicalizations();
     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, kInvalidPatchIndex, 0);
   library_ = Library::LookupLibrary(str_);
   if (library_.IsNull() || !library_.Loaded()) {
     SetReadException("Invalid object found in message.");
   }
   str_ ^= ReadObjectImpl();
   cls = library_.LookupClass(str_);
   if (cls.IsNull()) {
     SetReadException("Invalid object found in message.");
   }
   cls.EnsureIsFinalized(isolate());
@@ skipping 36 matching lines @@
   }
   func = func.ImplicitClosureFunction();
   ASSERT(!func.IsNull());
 
   // Return the associated implicit static closure.
   obj = func.ImplicitStaticClosure();
   return obj.raw();
 }
 
 
-RawObject* SnapshotReader::ReadObjectImpl() {
+RawObject* SnapshotReader::ReadObjectImpl(intptr_t patch_object_id,
+                                          intptr_t patch_offset) {
   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));
+  return ReadObjectImpl(static_cast<intptr_t>(value),
+                        patch_object_id,
+                        patch_offset);
 }
 
 
 intptr_t SnapshotReader::NextAvailableObjectId() const {
   return backward_references_->length() +
       kMaxPredefinedObjectIds + max_vm_isolate_object_id_;
 }
 
 
 void SnapshotReader::SetReadException(const char* msg) {
@@ skipping 12 matching lines @@
       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(intptr_t header_value,
+                                          intptr_t patch_object_id,
+                                          intptr_t patch_offset) {
   if (IsVMIsolateObject(header_value)) {
     return ReadVMIsolateObject(header_value);
   } else {
     if (SerializedHeaderTag::decode(header_value) == kObjectId) {
-      return ReadIndexedObject(SerializedHeaderData::decode(header_value));
+      return ReadIndexedObject(SerializedHeaderData::decode(header_value),
+                               patch_object_id,
+                               patch_offset);
     }
     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);
+    return ReadInlinedObject(object_id, patch_object_id, patch_offset);
   }
 }
 
 
-RawObject* SnapshotReader::ReadObjectRef() {
+RawObject* SnapshotReader::ReadObjectRef(intptr_t patch_object_id,
+                                         intptr_t patch_offset) {
   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));
+    return ReadIndexedObject(SerializedHeaderData::decode(value),
+                             patch_object_id,
+                             patch_offset);
   }
   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>();
@@ skipping 77 matching lines @@
       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();
   }
+  AddPatchRecord(object_id, patch_object_id, patch_offset);
   return pobj_.raw();
 }
 
 
 void SnapshotReader::AddBackRef(intptr_t id,
                                 Object* obj,
-                                DeserializeState state) {
+                                DeserializeState state,
+                                bool defer_canonicalization) {
   intptr_t index = (id - kMaxPredefinedObjectIds);
   ASSERT(index >= max_vm_isolate_object_id_);
   index -= max_vm_isolate_object_id_;
   ASSERT(index == backward_references_->length());
-  BackRefNode node(obj, state);
+  BackRefNode node(obj, state, defer_canonicalization);
   backward_references_->Add(node);
 }
 
 
 Object* SnapshotReader::GetBackRef(intptr_t id) {
   ASSERT(id >= kMaxPredefinedObjectIds);
   intptr_t index = (id - kMaxPredefinedObjectIds);
   ASSERT(index >= max_vm_isolate_object_id_);
   index -= max_vm_isolate_object_id_;
   if (index < backward_references_->length()) {
@@ skipping 504 matching lines @@
     return isolate()->class_table()->At(class_id);  // get singleton class.
   } else {
     ASSERT(Symbols::IsVMSymbolId(object_id));
     return Symbols::GetVMSymbol(object_id);  // return VM symbol.
   }
   UNREACHABLE();
   return Object::null();
 }
 
 
-RawObject* SnapshotReader::ReadIndexedObject(intptr_t object_id) {
+RawObject* SnapshotReader::ReadIndexedObject(intptr_t object_id,
+                                             intptr_t patch_object_id,
+                                             intptr_t patch_offset) {
   intptr_t class_id = ClassIdFromObjectId(object_id);
   if (IsObjectStoreClassId(class_id)) {
     return isolate()->class_table()->At(class_id);  // get singleton class.
   }
   if (kind_ != Snapshot::kFull) {
     if (IsObjectStoreTypeId(object_id)) {
       return GetType(object_store(), object_id);  // return type obj.
     }
   }
   ASSERT(object_id >= kMaxPredefinedObjectIds);
   intptr_t index = (object_id - kMaxPredefinedObjectIds);
   if (index < max_vm_isolate_object_id_) {
     return VmIsolateSnapshotObject(index);
   }
+  AddPatchRecord(object_id, patch_object_id, patch_offset);
   return GetBackRef(object_id)->raw();
 }
 
 
-RawObject* SnapshotReader::ReadInlinedObject(intptr_t object_id) {
+RawObject* SnapshotReader::ReadInlinedObject(intptr_t object_id,
+                                             intptr_t patch_object_id,
+                                             intptr_t patch_offset) {
   // 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);
+  bool is_canonical = RawObject::IsCanonical(tags);
   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.
@@ skipping 10 matching lines @@
       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)) {
+    } else if (is_canonical) {
       *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);
   }
@@ skipping 23 matching lines @@
       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();
   }
+  AddPatchRecord(object_id, patch_object_id, patch_offset);
   return pobj_.raw();
 }
 
 
-void SnapshotReader::ArrayReadFrom(const Array& result,
+void SnapshotReader::AddPatchRecord(intptr_t object_id,
+                                    intptr_t patch_object_id,
+                                    intptr_t patch_offset) {
+  if (patch_object_id != kInvalidPatchIndex && kind() != Snapshot::kFull) {
+    ASSERT(object_id >= kMaxPredefinedObjectIds);
+    intptr_t index = (object_id - kMaxPredefinedObjectIds);
+    ASSERT(index >= max_vm_isolate_object_id_);
+    index -= max_vm_isolate_object_id_;
+    ASSERT(index < backward_references_->length());
+    BackRefNode& ref = (*backward_references_)[index];
+    if (ref.defer_canonicalization()) {

[rmacnak, 2015/07/28 22:43:22]

Redundant with check in AddPatchRecord.

[siva, 2015/07/30 02:03:48]

Removed check.

+      ref.AddPatchRecord(patch_object_id, patch_offset);
+    }
+  }
+}
+
+
+void SnapshotReader::ProcessDeferredCanonicalizations() {
+  AbstractType& typeobj = AbstractType::Handle();
+  TypeArguments& typeargs = TypeArguments::Handle();
+  Object& newobj = Object::Handle();
+  for (intptr_t i = 0; i < backward_references_->length(); i++) {
+    BackRefNode& backref = (*backward_references_)[i];
+    if (backref.defer_canonicalization()) {
+      Object* objref = backref.reference();
+      // Object should either be an abstract type or a type argument.
+      if (objref->IsAbstractType()) {
+        typeobj ^= objref->raw();
+        typeobj.ClearCanonical();
+        newobj = typeobj.Canonicalize();
+      } else {
+        ASSERT(objref->IsTypeArguments());
+        typeargs ^= objref->raw();
+        typeargs.ClearCanonical();
+        newobj = typeargs.Canonicalize();
+      }
+      if (newobj.raw() == objref->raw()) {
+        // Restore Canonical bit.
+        objref->SetCanonical();
+      } else {
+        ZoneGrowableArray<intptr_t>* patches = backref.patch_records();
+        ASSERT(newobj.IsCanonical());
+        ASSERT(patches != NULL);
+        for (intptr_t j = 0; j < patches->length(); j+=2) {
+          NoSafepointScope no_safepoint;
+          intptr_t patch_object_id = (*patches)[j];
+          intptr_t patch_offset = (*patches)[j + 1];
+          Object* target = GetBackRef(patch_object_id);
+          RawObject** rawptr =
+              reinterpret_cast<RawObject**>(target->raw()->ptr());
+          target->StorePointer((rawptr + patch_offset), newobj.raw());
+        }
+      }
+    }
+  }
+}
+
+
+void SnapshotReader::ArrayReadFrom(intptr_t object_id,
+                                   const Array& result,
                                    intptr_t len,
                                    intptr_t tags) {
   // Set the object tags.
   result.set_tags(tags);
 
   // Setup the object fields.
-  *TypeArgumentsHandle() ^= ReadObjectImpl();
+  intptr_t typeargs_offset =
+      reinterpret_cast<RawObject**>(&result.raw()->ptr()->type_arguments_) -
+      reinterpret_cast<RawObject**>(result.raw()->ptr());
+  *TypeArgumentsHandle() ^= ReadObjectImpl(object_id, typeargs_offset);
   result.SetTypeArguments(*TypeArgumentsHandle());
 
   bool is_canonical = RawObject::IsCanonical(tags);
 
+  intptr_t offset = result.raw_ptr()->data() -
+      reinterpret_cast<RawObject**>(result.raw()->ptr());
   for (intptr_t i = 0; i < len; i++) {
-    *PassiveObjectHandle() = is_canonical ? ReadObjectImpl() : ReadObjectRef();
+    *PassiveObjectHandle() = is_canonical ?
+        ReadObjectImpl(object_id, i) : ReadObjectRef(object_id, (i + offset));
     result.SetAt(i, *PassiveObjectHandle());
   }
 }
 
 
 VmIsolateSnapshotReader::VmIsolateSnapshotReader(const uint8_t* buffer,
                                                  intptr_t size,
                                                  Zone* zone)
     : SnapshotReader(buffer,
                      size,
@@ skipping 1197 matching lines @@
     NoSafepointScope no_safepoint;
     WriteObject(obj.raw());
     UnmarkAll();
   } else {
     ThrowException(exception_type(), exception_msg());
   }
 }
 
 
 }  // namespace dart