Implement patch records to patch canonical objects.

runtime/vm/snapshot.h

 // 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.
 
 #ifndef VM_SNAPSHOT_H_
 #define VM_SNAPSHOT_H_
 
 #include "platform/assert.h"
 #include "vm/allocation.h"
 #include "vm/bitfield.h"
@@ skipping 81 matching lines @@
 //   (a unique id for this object | 0x1)
 enum SerializedHeaderType {
   kInlined  = 0x1,
   kObjectId = 0x3,
 };
 static const int8_t kHeaderTagBits = 2;
 static const int8_t kObjectIdBits = (kBitsPerInt32 - (kHeaderTagBits + 1));
 static const intptr_t kMaxObjectId = (kMaxUint32 >> (kHeaderTagBits + 1));
 static const bool kAsReference = true;
 static const bool kAsInlinedObject = false;
+static const intptr_t kInvalidPatchIndex = -1;
 
 
 class SerializedHeaderTag : public BitField<enum SerializedHeaderType,
                                             0,
                                             kHeaderTagBits> {
 };
 
 
 class SerializedHeaderData : public BitField<intptr_t,
                                              kHeaderTagBits,
@@ skipping 131 matching lines @@
     return SerializedHeaderData::decode(value);
   }
 
  private:
   ReadStream stream_;  // input stream.
 };
 
 
 class BackRefNode : public ValueObject {
  public:
-  BackRefNode(Object* reference, DeserializeState state)
-      : reference_(reference), state_(state) {}
+  BackRefNode(Object* reference,
+              DeserializeState state,
+              bool defer_canonicalization)
+      : reference_(reference),
+        state_(state),
+        defer_canonicalization_(defer_canonicalization),
+        patch_records_(NULL) {}
   Object* reference() const { return reference_; }
   bool is_deserialized() const { return state_ == kIsDeserialized; }
   void set_state(DeserializeState state) { state_ = state; }
+  bool defer_canonicalization() const { return defer_canonicalization_; }
+  ZoneGrowableArray<intptr_t>* patch_records() const { return patch_records_; }
 
   BackRefNode& operator=(const BackRefNode& other) {
     reference_ = other.reference_;
     state_ = other.state_;
+    defer_canonicalization_ = other.defer_canonicalization_;
+    patch_records_ = other.patch_records_;
     return *this;
   }
 
+  void AddPatchRecord(intptr_t patch_object_id, intptr_t patch_offset) {
+    if (defer_canonicalization_) {
+      if (patch_records_ == NULL) {
+        patch_records_ = new ZoneGrowableArray<intptr_t>();
+      }
+      patch_records_->Add(patch_object_id);
+      patch_records_->Add(patch_offset);
+    }
+  }
+
  private:
   Object* reference_;
   DeserializeState state_;
+  bool defer_canonicalization_;
+  ZoneGrowableArray<intptr_t>* patch_records_;
 };
 
 
 // Reads a snapshot into objects.
 class SnapshotReader : public BaseReader {
  public:
   Zone* zone() const { return zone_; }
   Isolate* isolate() const { return isolate_; }
   Heap* heap() const { return heap_; }
   ObjectStore* object_store() const { return isolate_->object_store(); }
   ClassTable* class_table() const { return isolate_->class_table(); }
   PassiveObject* PassiveObjectHandle() { return &pobj_; }
   Array* ArrayHandle() { return &array_; }
   String* StringHandle() { return &str_; }
   AbstractType* TypeHandle() { return &type_; }
   TypeArguments* TypeArgumentsHandle() { return &type_arguments_; }
   Array* TokensHandle() { return &tokens_; }
   TokenStream* StreamHandle() { return &stream_; }
   ExternalTypedData* DataHandle() { return &data_; }
   TypedData* TypedDataHandle() { return &typed_data_; }
   Snapshot::Kind kind() const { return kind_; }
   bool allow_code() const { return false; }
 
   // Reads an object.
   RawObject* ReadObject();
 
   // Add object to backward references.
-  void AddBackRef(intptr_t id, Object* obj, DeserializeState state);
+  void AddBackRef(intptr_t id,
+                  Object* obj,
+                  DeserializeState state,
+                  bool defer_canonicalization = false);
 
   // Get an object from the backward references list.
   Object* GetBackRef(intptr_t id);
 
   // Read a full snap shot.
   RawApiError* ReadFullSnapshot();
 
   // Read a script snap shot.
   RawObject* ReadScriptSnapshot();
 
@@ skipping 58 matching lines @@
   PageSpace* old_space() const { return old_space_; }
 
  private:
   // Allocate uninitialized objects, this is used when reading a full snapshot.
   RawObject* AllocateUninitialized(intptr_t class_id, intptr_t size);
 
   RawClass* ReadClassId(intptr_t object_id);
   RawObject* ReadStaticImplicitClosure(intptr_t object_id, intptr_t cls_header);
 
   // Implementation to read an object.
-  RawObject* ReadObjectImpl(bool as_reference);
-  RawObject* ReadObjectImpl(intptr_t header, bool as_reference);
+  RawObject* ReadObjectImpl(bool as_reference,
+                            intptr_t patch_object_id = kInvalidPatchIndex,
+                            intptr_t patch_offset = 0);
+  RawObject* ReadObjectImpl(intptr_t header,
+                            bool as_reference,
+                            intptr_t patch_object_id,
+                            intptr_t patch_offset);
 
   // Read an object reference from the stream.
   RawObject* ReadObjectRef(intptr_t object_id,
                            intptr_t class_header,
-                           intptr_t tags);
+                           intptr_t tags,
+                           intptr_t patch_object_id = kInvalidPatchIndex,
+                           intptr_t patch_offset = 0);
 
   // Read an inlined object from the stream.
   RawObject* ReadInlinedObject(intptr_t object_id,
                                intptr_t class_header,
-                               intptr_t tags);
+                               intptr_t tags,
+                               intptr_t patch_object_id,
+                               intptr_t patch_offset);
 
   // Read a VM isolate object that was serialized as an Id.
   RawObject* ReadVMIsolateObject(intptr_t object_id);
 
   // Read an object that was serialized as an Id (singleton in object store,
   // or an object that was already serialized before).
-  RawObject* ReadIndexedObject(intptr_t object_id);
+  RawObject* ReadIndexedObject(intptr_t object_id,
+                               intptr_t patch_object_id,
+                               intptr_t patch_offset);
+
+  // Add a patch record for the object so that objects whose canonicalization
+  // is deferred can be back patched after they are canonicalized.
+  void AddPatchRecord(intptr_t object_id,
+                      intptr_t patch_object_id,
+                      intptr_t patch_offset);
+
+  // Process all the deferred canonicalization entries and patch all references.
+  void ProcessDeferredCanonicalizations();
 
   // Decode class id from the header field.
   intptr_t LookupInternalClass(intptr_t class_header);
 
-  void ArrayReadFrom(const Array& result, intptr_t len, intptr_t tags);
+  void ArrayReadFrom(intptr_t object_id,
+                     const Array& result,
+                     intptr_t len,
+                     intptr_t tags);
 
   intptr_t NextAvailableObjectId() const;
 
   void SetReadException(const char* msg);
 
   RawObject* VmIsolateSnapshotObject(intptr_t index) const;
 
   Snapshot::Kind kind_;  // Indicates type of snapshot(full, script, message).
   Isolate* isolate_;  // Current isolate.
   Zone* zone_;  // Zone for allocations while reading snapshot.
@@ skipping 476 matching lines @@
  private:
   SnapshotWriter* writer_;
   bool as_references_;
 
   DISALLOW_COPY_AND_ASSIGN(SnapshotWriterVisitor);
 };
 
 }  // namespace dart
 
 #endif  // VM_SNAPSHOT_H_