1. Remove recursion during snapshot writing and reading

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"
 #include "vm/globals.h"
 #include "vm/growable_array.h"
 #include "vm/isolate.h"
 #include "vm/visitor.h"
 
 namespace dart {
 
 // Forward declarations.
 class AbstractType;
 class AbstractTypeArguments;
+class Array;
 class Class;
 class Heap;
 class Library;
 class Object;
 class ObjectStore;
+class RawAbstractTypeArguments;
 class RawArray;
 class RawBigint;
 class RawClass;
 class RawContext;
 class RawDouble;
 class RawField;
 class RawFourByteString;
 class RawFunction;
 class RawGrowableObjectArray;
 class RawImmutableArray;
@@ skipping 41 matching lines @@
                                             kHeaderTagBits> {
 };
 
 
 class SerializedHeaderData : public BitField<intptr_t,
                                              kHeaderTagBits,
                                              kObjectIdTagBits> {
 };
 
 
+enum DeserializeState {
+  kIsDeserialized = 0,
+  kIsNotDeserialized = 1,
+};
+
+
+enum SerializeState {
+  kIsSerialized = 0,
+  kIsNotSerialized = 1,
+};
+
+
 // Structure capturing the raw snapshot.
 class Snapshot {
  public:
   enum Kind {
     kFull = 0,  // Full snapshot of the current dart heap.
     kScript,    // A partial snapshot of only the application script.
     kMessage,   // A partial snapshot used only for isolate messaging.
   };
 
   static const int kHeaderSize = 2 * sizeof(int32_t);
@@ skipping 251 matching lines @@
   Heap* heap() const { return isolate_->heap(); }
   ObjectStore* object_store() const { return isolate_->object_store(); }
   Object* ObjectHandle() { return &obj_; }
   String* StringHandle() { return &str_; }
   AbstractType* TypeHandle() { return &type_; }
   AbstractTypeArguments* TypeArgumentsHandle() { return &type_arguments_; }
 
   // Reads an object.
   RawObject* ReadObject();
 
-  RawClass* ReadClassId(intptr_t object_id);
+  // Add object to backward references.
+  void AddBackRef(intptr_t id, Object* obj, DeserializeState state);
 
-  // Add object to backward references.
-  void AddBackwardReference(intptr_t id, Object* obj);
+  // Get an object from the backward references list.
+  Object* GetBackRef(intptr_t id);
 
   // Read a full snap shot.
   void ReadFullSnapshot();
 
   // Helper functions for creating uninitialized versions
   // of various object types. These are used when reading a
   // full snapshot.
   RawArray* NewArray(intptr_t len);
   RawImmutableArray* NewImmutableArray(intptr_t len);
   RawOneByteString* NewOneByteString(intptr_t len);
@@ skipping 11 matching lines @@
   RawTypeParameter* NewTypeParameter();
   RawFunction* NewFunction();
   RawField* NewField();
   RawLibrary* NewLibrary();
   RawLibraryPrefix* NewLibraryPrefix();
   RawScript* NewScript();
   RawLiteralToken* NewLiteralToken();
   RawGrowableObjectArray* NewGrowableObjectArray();
 
  private:
+  class BackRefNode : public ZoneAllocated {
+   public:
+    BackRefNode(Object* reference, DeserializeState state)
+        : reference_(reference), state_(state) {}
+    Object* reference() const { return reference_; }
+    bool is_deserialized() const { return state_ == kIsDeserialized; }
+    void set_state(DeserializeState state) { state_ = state; }
+
+   private:
+    Object* reference_;
+    DeserializeState state_;
+
+    DISALLOW_COPY_AND_ASSIGN(BackRefNode);
+  };
+
   // Allocate uninitialized objects, this is used when reading a full snapshot.
   RawObject* AllocateUninitialized(const Class& cls, intptr_t size);
 
-  // Internal implementation of ReadObject once the header value is read.
+  RawClass* ReadClassId(intptr_t object_id);
+  RawObject* ReadObjectImpl();
   RawObject* ReadObjectImpl(intptr_t header);
+  RawObject* ReadObjectRef();
 
   // Read an object that was serialized as an Id (singleton, object store,
   // or an object that was already serialized before).
   RawObject* ReadIndexedObject(intptr_t object_id);
 
   // Read an inlined object from the stream.
   RawObject* ReadInlinedObject(intptr_t object_id);
 
   // Based on header field check to see if it is an internal VM class.
   RawClass* LookupInternalClass(intptr_t class_header);
 
+  void ArrayReadFrom(const Array& result, intptr_t len, intptr_t tags);
+
   Snapshot::Kind kind_;  // Indicates type of snapshot(full, script, message).
   Isolate* isolate_;  // Current isolate.
   Class& cls_;  // Temporary Class handle.
   Object& obj_;  // Temporary Object handle.
   String& str_;  // Temporary String handle.
   Library& library_;  // Temporary library handle.
   AbstractType& type_;  // Temporary type handle.
   AbstractTypeArguments& type_arguments_;  // Temporary type argument handle.
-  GrowableArray<Object*> backward_references_;
+  GrowableArray<BackRefNode*> backward_references_;
 
+  friend class Array;
+  friend class Class;
+  friend class Context;
+  friend class ContextScope;
+  friend class Field;
+  friend class Function;
+  friend class GrowableObjectArray;
+  friend class ImmutableArray;
+  friend class InstantiatedTypeArguments;
+  friend class JSRegExp;
+  friend class Library;
+  friend class LibraryPrefix;
+  friend class LiteralToken;
+  friend class Script;
+  friend class TokenStream;
+  friend class Type;
+  friend class TypeArguments;
+  friend class TypeParameter;
+  friend class UnresolvedClass;
   DISALLOW_COPY_AND_ASSIGN(SnapshotReader);
 };
 
 
 class BaseWriter {
  public:
   // Size of the snapshot.
   intptr_t BytesWritten() const { return stream_.bytes_written(); }
 
   // Writes raw data to the stream (basic type).
@@ skipping 72 matching lines @@
   // which comprises of a flag(full/partial snaphot) and the length of
   // serialzed bytes.
   void FinalizeBuffer() {
     BaseWriter::FinalizeBuffer(kind_);
     UnmarkAll();
   }
 
   // Serialize an object into the buffer.
   void WriteObject(RawObject* raw);
 
-  void WriteClassId(RawClass* cls);
-
-  // Unmark all objects that were marked as forwarded for serializing.
-  void UnmarkAll();
-
   // Writes a full snapshot of the Isolate.
   void WriteFullSnapshot();
 
   uword GetObjectTags(RawObject* raw);
 
  private:
   class ForwardObjectNode : public ZoneAllocated {
    public:
-    ForwardObjectNode(RawObject* raw, uword tags) : raw_(raw), tags_(tags) {}
+    ForwardObjectNode(RawObject* raw, uword tags, SerializeState state)
+        : raw_(raw), tags_(tags), state_(state) {}
     RawObject* raw() const { return raw_; }
     uword tags() const { return tags_; }
+    bool is_serialized() const { return state_ == kIsSerialized; }
+    void set_state(SerializeState value) { state_ = value; }
 
    private:
     RawObject* raw_;
     uword tags_;
+    SerializeState state_;
 
     DISALLOW_COPY_AND_ASSIGN(ForwardObjectNode);
   };
 
-  intptr_t MarkObject(RawObject* raw);
+  intptr_t MarkObject(RawObject* raw, SerializeState state);
+  void UnmarkAll();
 
   bool CheckAndWritePredefinedObject(RawObject* raw);
 
+  void WriteObjectRef(RawObject* raw);
+  void WriteClassId(RawClass* cls);
+  void WriteObjectImpl(RawObject* raw);
   void WriteInlinedObject(RawObject* raw);
+  void WriteForwardedObjects();
+  void ArrayWriteTo(intptr_t object_id,
+                    intptr_t array_kind,
+                    intptr_t tags,
+                    RawSmi* length,
+                    RawAbstractTypeArguments* type_arguments,
+                    RawObject* data[]);
 
   ObjectStore* object_store() const { return object_store_; }
 
   Snapshot::Kind kind_;
   ObjectStore* object_store_;  // Object store for common classes.
   ClassTable* class_table_;  // Class table for the class index to class lookup.
   GrowableArray<ForwardObjectNode*> forward_list_;
 
+  friend class RawArray;
+  friend class RawClass;
+  friend class RawGrowableObjectArray;
+  friend class RawImmutableArray;
+  friend class RawJSRegExp;
+  friend class RawLibrary;
+  friend class RawLiteralToken;
+  friend class RawScript;
+  friend class RawTokenStream;
+  friend class RawTypeArguments;
+  friend class SnapshotWriterVisitor;
   DISALLOW_COPY_AND_ASSIGN(SnapshotWriter);
 };
 
 
 class ScriptSnapshotWriter : public SnapshotWriter {
  public:
   ScriptSnapshotWriter(uint8_t** buffer, ReAlloc alloc)
       : SnapshotWriter(Snapshot::kScript, buffer, alloc) {
     ASSERT(buffer != NULL);
     ASSERT(alloc != NULL);
   }
   ~ScriptSnapshotWriter() { }
 
   // Writes a partial snapshot of the script.
   void WriteScriptSnapshot(const Library& lib);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ScriptSnapshotWriter);
 };
 
 
 // An object pointer visitor implementation which writes out
 // objects to a snap shot.
 class SnapshotWriterVisitor : public ObjectPointerVisitor {
  public:
   explicit SnapshotWriterVisitor(SnapshotWriter* writer)
-      : ObjectPointerVisitor(Isolate::Current()), writer_(writer) {}
+      : ObjectPointerVisitor(Isolate::Current()),
+        writer_(writer),
+        as_references_(true) {}
+
+  SnapshotWriterVisitor(SnapshotWriter* writer, bool as_references)
+      : ObjectPointerVisitor(Isolate::Current()),
+        writer_(writer),
+        as_references_(as_references) {}
 
   virtual void VisitPointers(RawObject** first, RawObject** last);
 
  private:
   SnapshotWriter* writer_;
+  bool as_references_;
 
   DISALLOW_COPY_AND_ASSIGN(SnapshotWriterVisitor);
 };
 
 }  // namespace dart
 
 #endif  // VM_SNAPSHOT_H_