Move symbol table from per isolate snapshot to vm isolate snapshot, this reduces the per isolate in…

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"
 #include "vm/dart_entry.h"
 #include "vm/exceptions.h"
 #include "vm/heap.h"
 #include "vm/lockers.h"
 #include "vm/longjump.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/snapshot_ids.h"
 #include "vm/symbols.h"
 #include "vm/verified_memory.h"
 #include "vm/version.h"
 
 namespace dart {
 
+static const int kNumVmIsolateSnapshotReferences = 32 * KB;
 static const int kNumInitialReferencesInFullSnapshot = 160 * KB;
 static const int kNumInitialReferences = 64;
 
 
 static bool IsSingletonClassId(intptr_t class_id) {
   // Check if this is a singleton object class which is shared by all isolates.
   return ((class_id >= kClassCid && class_id <= kUnwindErrorCid) ||
           (class_id >= kNullCid && class_id <= kVoidCid));
 }
 
@@ skipping 120 matching lines @@
   ASSERT((value & kSmiTagMask) == kSmiTag);
   return reinterpret_cast<RawSmi*>(value);
 }
 
 
 intptr_t BaseReader::ReadSmiValue() {
   return Smi::Value(ReadAsSmi());
 }
 
 
-SnapshotReader::SnapshotReader(const uint8_t* buffer,
-                               intptr_t size,
-                               Snapshot::Kind kind,
-                               Isolate* isolate,
-                               Zone* zone)
+SnapshotReader::SnapshotReader(
+    const uint8_t* buffer,
+    intptr_t size,
+    Snapshot::Kind kind,
+    ZoneGrowableArray<BackRefNode>* backward_refs,
+    Isolate* isolate,
+    Zone* zone)
     : BaseReader(buffer, size),
       kind_(kind),
       isolate_(isolate),
       zone_(zone),
       heap_(isolate->heap()),
       old_space_(isolate->heap()->old_space()),
       cls_(Class::Handle(isolate)),
       obj_(Object::Handle(isolate)),
       pobj_(PassiveObject::Handle(isolate)),
       array_(Array::Handle(isolate)),
       field_(Field::Handle(isolate)),
       str_(String::Handle(isolate)),
       library_(Library::Handle(isolate)),
       type_(AbstractType::Handle(isolate)),
       type_arguments_(TypeArguments::Handle(isolate)),
       tokens_(Array::Handle(isolate)),
       stream_(TokenStream::Handle(isolate)),
       data_(ExternalTypedData::Handle(isolate)),
       error_(UnhandledException::Handle(isolate)),
-      backward_references_((kind == Snapshot::kFull) ?
-                           kNumInitialReferencesInFullSnapshot :
-                           kNumInitialReferences) {
+      max_vm_isolate_object_id_(
+          Object::vm_isolate_snapshot_object_table().Length()),
+      backward_references_(backward_refs) {
 }
 
 
 RawObject* SnapshotReader::ReadObject() {
   // 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()) {
+    for (intptr_t i = 0; i < backward_references_->length(); i++) {
+      if (!(*backward_references_)[i].is_deserialized()) {
         ReadObjectImpl();
-        backward_references_[i].set_state(kIsDeserialized);
+        (*backward_references_)[i].set_state(kIsDeserialized);
       }
     }
     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();
   }
 }
@@ skipping 72 matching lines @@
   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));
 }
 
 
 intptr_t SnapshotReader::NextAvailableObjectId() const {
-  return backward_references_.length() + kMaxPredefinedObjectIds;
+  return backward_references_->length() +
+      kMaxPredefinedObjectIds + max_vm_isolate_object_id_;
 }
 
 
 void SnapshotReader::SetReadException(const char* msg) {
   Isolate* isolate = Isolate::Current();
   const String& error_str = String::Handle(isolate, String::New(msg));
   const Array& args = Array::Handle(isolate, Array::New(1));
   args.SetAt(0, error_str);
   Object& result = Object::Handle(isolate);
   const Library& library = Library::Handle(isolate, Library::CoreLibrary());
   result = DartLibraryCalls::InstanceCreate(library,
                                             Symbols::ArgumentError(),
                                             Symbols::Dot(),
                                             args);
   const Stacktrace& stacktrace = Stacktrace::Handle(isolate);
   const UnhandledException& error = UnhandledException::Handle(
       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) {
   if (IsVMIsolateObject(header_value)) {
     return ReadVMIsolateObject(header_value);
   } else {
     if (SerializedHeaderTag::decode(header_value) == kObjectId) {
       return ReadIndexedObject(SerializedHeaderData::decode(header_value));
     }
     ASSERT(SerializedHeaderTag::decode(header_value) == kInlined);
     intptr_t object_id = SerializedHeaderData::decode(header_value);
     if (object_id == kOmittedObjectId) {
@@ skipping 113 matching lines @@
     pobj_.SetCreatedFromSnapshot();
   }
   return pobj_.raw();
 }
 
 
 void SnapshotReader::AddBackRef(intptr_t id,
                                 Object* obj,
                                 DeserializeState state) {
   intptr_t index = (id - kMaxPredefinedObjectIds);
-  ASSERT(index == backward_references_.length());
+  ASSERT(index >= max_vm_isolate_object_id_);
+  index -= max_vm_isolate_object_id_;
+  ASSERT(index == backward_references_->length());
   BackRefNode node(obj, state);
-  backward_references_.Add(node);
+  backward_references_->Add(node);
 }
 
 
 Object* SnapshotReader::GetBackRef(intptr_t id) {
   ASSERT(id >= kMaxPredefinedObjectIds);
   intptr_t index = (id - kMaxPredefinedObjectIds);
-  if (index < backward_references_.length()) {
-    return backward_references_[index].reference();
+  ASSERT(index >= max_vm_isolate_object_id_);
+  index -= max_vm_isolate_object_id_;
+  if (index < backward_references_->length()) {
+    return (*backward_references_)[index].reference();
   }
   return NULL;
 }
 
 
 class HeapLocker : public StackResource {
  public:
   HeapLocker(Isolate* isolate, PageSpace* page_space)
       : StackResource(isolate), page_space_(page_space) {
         page_space_->AcquireDataLock();
@@ skipping 26 matching lines @@
   // size for the full snapshot being read.
   {
     NoSafepointScope no_safepoint;
     HeapLocker hl(isolate, old_space());
 
     // Read in all the objects stored in the object store.
     intptr_t num_flds = (object_store->to() - object_store->from());
     for (intptr_t i = 0; i <= num_flds; i++) {
       *(object_store->from() + i) = ReadObjectImpl();
     }
-    for (intptr_t i = 0; i < backward_references_.length(); i++) {
-      if (!backward_references_[i].is_deserialized()) {
+    for (intptr_t i = 0; i < backward_references_->length(); i++) {
+      if (!(*backward_references_)[i].is_deserialized()) {
         ReadObjectImpl();
-        backward_references_[i].set_state(kIsDeserialized);
+        (*backward_references_)[i].set_state(kIsDeserialized);
       }
     }
 
     // Validate the class table.
 #if defined(DEBUG)
     isolate->ValidateClassTable();
 #endif
 
     // Setup native resolver for bootstrap impl.
     Bootstrap::SetupNativeResolver();
@@ skipping 451 matching lines @@
 RawObject* SnapshotReader::ReadIndexedObject(intptr_t object_id) {
   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.
     }
   }
-  Object* object = GetBackRef(object_id);
-  return object->raw();
+  ASSERT(object_id >= kMaxPredefinedObjectIds);
+  intptr_t index = (object_id - kMaxPredefinedObjectIds);
+  if (index < max_vm_isolate_object_id_) {
+    return VmIsolateSnapshotObject(index);
+  }
+  return GetBackRef(object_id)->raw();
 }
 
 
 RawObject* SnapshotReader::ReadInlinedObject(intptr_t object_id) {
   // 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);
   if (header_id == kInstanceObjectId) {
     // Object is regular dart instance.
@@ skipping 107 matching lines @@
                                    intptr_t len,
                                    intptr_t tags) {
   // Set the object tags.
   result.set_tags(tags);
 
   // Setup the object fields.
   *TypeArgumentsHandle() ^= ReadObjectImpl();
   result.SetTypeArguments(*TypeArgumentsHandle());
 
   bool is_canonical = RawObject::IsCanonical(tags);
+  Object& obj = Object::Handle(isolate());
 
   for (intptr_t i = 0; i < len; i++) {
     *PassiveObjectHandle() = is_canonical ? ReadObjectImpl() : ReadObjectRef();
+    obj = (*PassiveObjectHandle()).raw();
     result.SetAt(i, *PassiveObjectHandle());
   }
 }
 
 
+VmIsolateSnapshotReader::VmIsolateSnapshotReader(const uint8_t* buffer,
+                                                 intptr_t size,
+                                                 Zone* zone)
+    : SnapshotReader(buffer,
+                     size,
+                     Snapshot::kFull,
+                     new ZoneGrowableArray<BackRefNode>(
+                         kNumVmIsolateSnapshotReferences),
+                     Dart::vm_isolate(),
+                     zone) {
+}
+
+
+VmIsolateSnapshotReader::~VmIsolateSnapshotReader() {
+  intptr_t len = GetBackwardReferenceTable()->length();
+  Object::InitVmIsolateSnapshotObjectTable(len);
+  ZoneGrowableArray<BackRefNode>* backrefs = GetBackwardReferenceTable();
+  for (intptr_t i = 0; i < len; i++) {
+    Object::vm_isolate_snapshot_object_table().SetAt(
+        i, *(backrefs->At(i).reference()));
+  }
+  ResetBackwardReferenceTable();
+}
+
+
+RawApiError* VmIsolateSnapshotReader::ReadVmIsolateSnapshot() {
+  ASSERT(kind() == Snapshot::kFull);
+  Isolate* isolate = Isolate::Current();
+  ASSERT(isolate != NULL);
+  ASSERT(isolate == Dart::vm_isolate());
+  ObjectStore* object_store = isolate->object_store();
+  ASSERT(object_store != NULL);
+
+  // First read the version string, and check that it matches.
+  RawApiError* error = VerifyVersion();
+  if (error != ApiError::null()) {
+    return error;
+  }
+
+  // The version string matches. Read the rest of the snapshot.
+
+  {
+    NoSafepointScope no_safepoint;
+    HeapLocker hl(isolate, old_space());
+
+    // Read in the symbol table.
+    object_store->symbol_table_ = reinterpret_cast<RawArray*>(ReadObject());
+
+    // Validate the class table.
+#if defined(DEBUG)
+    isolate->ValidateClassTable();
+#endif
+
+    return ApiError::null();
+  }
+}
+
+
+IsolateSnapshotReader::IsolateSnapshotReader(const uint8_t* buffer,
+                                             intptr_t size,
+                                             Isolate* isolate,
+                                             Zone* zone)
+    : SnapshotReader(buffer,
+                     size,
+                     Snapshot::kFull,
+                     new ZoneGrowableArray<BackRefNode>(
+                         kNumInitialReferencesInFullSnapshot),
+                     isolate,
+                     zone) {
+}
+
+
+IsolateSnapshotReader::~IsolateSnapshotReader() {
+  ResetBackwardReferenceTable();
+}
+
+
+ScriptSnapshotReader::ScriptSnapshotReader(const uint8_t* buffer,
+                                           intptr_t size,
+                                           Isolate* isolate,
+                                           Zone* zone)
+    : SnapshotReader(buffer,
+                     size,
+                     Snapshot::kScript,
+                     new ZoneGrowableArray<BackRefNode>(kNumInitialReferences),
+                     isolate,
+                     zone) {
+}
+
+
+ScriptSnapshotReader::~ScriptSnapshotReader() {
+  ResetBackwardReferenceTable();
+}
+
+
+MessageSnapshotReader::MessageSnapshotReader(const uint8_t* buffer,
+                                             intptr_t size,
+                                             Isolate* isolate,
+                                             Zone* zone)
+    : SnapshotReader(buffer,
+                     size,
+                     Snapshot::kMessage,
+                     new ZoneGrowableArray<BackRefNode>(kNumInitialReferences),
+                     isolate,
+                     zone) {
+}
+
+
+MessageSnapshotReader::~MessageSnapshotReader() {
+  ResetBackwardReferenceTable();
+}
+
+
 SnapshotWriter::SnapshotWriter(Snapshot::Kind kind,
                                uint8_t** buffer,
                                ReAlloc alloc,
                                intptr_t initial_size,
+                               ForwardList* forward_list,
                                bool can_send_any_object)
     : BaseWriter(buffer, alloc, initial_size),
       kind_(kind),
       isolate_(Isolate::Current()),
       object_store_(isolate_->object_store()),
       class_table_(isolate_->class_table()),
-      forward_list_(kMaxPredefinedObjectIds),
+      forward_list_(forward_list),
       exception_type_(Exceptions::kNone),
       exception_msg_(NULL),
       unmarked_objects_(false),
       can_send_any_object_(can_send_any_object) {
+  ASSERT(forward_list_ != NULL);
 }
 
 
 void SnapshotWriter::WriteObject(RawObject* rawobj) {
   WriteObjectImpl(rawobj);
   WriteForwardedObjects();
 }
 
 
 void SnapshotWriter::HandleVMIsolateObject(RawObject* rawobj) {
@@ skipping 51 matching lines @@
   if (id == kClassCid) {
     RawClass* raw_class = reinterpret_cast<RawClass*>(rawobj);
     intptr_t class_id = raw_class->ptr()->id_;
     if (IsSingletonClassId(class_id)) {
       intptr_t object_id = ObjectIdFromClassId(class_id);
       WriteVMIsolateObject(object_id);
       return;
     }
   }
 
-
   // Check it is a predefined symbol in the VM isolate.
   id = Symbols::LookupVMSymbol(rawobj);
   if (id != kInvalidIndex) {
     WriteVMIsolateObject(id);
     return;
   }
 
+  // Check if it is an object from the vm isolate snapshot object table.
+  id = FindVmSnapshotObject(rawobj);
+  if (id != kInvalidIndex) {
+    WriteIndexedObject(id);
+    return;
+  }
   UNREACHABLE();
 }
 
 
 void SnapshotWriter::WriteObjectRef(RawObject* raw) {
   // First check if object can be written as a simple predefined type.
   if (CheckAndWritePredefinedObject(raw)) {
     return;
   }
 
   NoSafepointScope no_safepoint;
   RawClass* cls = class_table_->At(raw->GetClassId());
   intptr_t class_id = cls->ptr()->id_;
   ASSERT(class_id == raw->GetClassId());
   if (class_id >= kNumPredefinedCids) {
     WriteInstanceRef(raw, cls);
     return;
   }
   if (class_id == kArrayCid) {
     // Object is being referenced, add it to the forward ref list and mark
     // it so that future references to this object in the snapshot will use
     // this object id. Mark it as not having been serialized yet so that we
     // will serialize the object when we go through the forward list.
-    forward_list_.MarkAndAddObject(raw, kIsNotSerialized);
+    forward_list_->MarkAndAddObject(raw, kIsNotSerialized);
 
     RawArray* rawarray = reinterpret_cast<RawArray*>(raw);
 
     // Write out the serialization header value for this object.
     WriteInlinedObjectHeader(kOmittedObjectId);
 
     // Write out the class information.
     WriteIndexedObject(kArrayCid);
 
     // Write out the length field.
     Write<RawObject*>(rawarray->ptr()->length_);
 
     return;
   }
   if (class_id == kImmutableArrayCid) {
     // Object is being referenced, add it to the forward ref list and mark
     // it so that future references to this object in the snapshot will use
     // this object id. Mark it as not having been serialized yet so that we
     // will serialize the object when we go through the forward list.
-    forward_list_.MarkAndAddObject(raw, kIsNotSerialized);
+    forward_list_->MarkAndAddObject(raw, kIsNotSerialized);
 
     RawArray* rawarray = reinterpret_cast<RawArray*>(raw);
 
     // Write out the serialization header value for this object.
     WriteInlinedObjectHeader(kOmittedObjectId);
 
     // Write out the class information.
     WriteIndexedObject(kImmutableArrayCid);
 
     // Write out the length field.
     Write<RawObject*>(rawarray->ptr()->length_);
 
     return;
   }
   if (RawObject::IsImplicitFieldClassId(class_id)) {
     WriteInstanceRef(raw, cls);
     return;
   }
   // Add object to the forward ref list and mark it so that future references
   // to this object in the snapshot will use this object id. Mark it as having
   // been serialized so that we do not serialize the object when we go through
   // the forward list.
-  forward_list_.MarkAndAddObject(raw, kIsSerialized);
+  forward_list_->MarkAndAddObject(raw, kIsSerialized);
   switch (class_id) {
 #define SNAPSHOT_WRITE(clazz)                                                  \
     case clazz::kClassId: {                                                    \
       Raw##clazz* raw_obj = reinterpret_cast<Raw##clazz*>(raw);                \
       raw_obj->WriteTo(this, kOmittedObjectId, kind_);                         \
       return;                                                                  \
     }                                                                          \
 
     CLASS_LIST_NO_OBJECT(SNAPSHOT_WRITE)
 #undef SNAPSHOT_WRITE
@@ skipping 15 matching lines @@
       raw_obj->WriteTo(this, kOmittedObjectId, kind_);
       return;
     }
 #undef SNAPSHOT_WRITE
     default: break;
   }
   UNREACHABLE();
 }
 
 
-void FullSnapshotWriter::WriteFullSnapshot() {
-  ASSERT(isolate() != NULL);
-  ObjectStore* object_store = isolate()->object_store();
+FullSnapshotWriter::FullSnapshotWriter(uint8_t** vm_isolate_snapshot_buffer,
+                                       uint8_t** isolate_snapshot_buffer,
+                                       ReAlloc alloc)
+    : vm_isolate_snapshot_buffer_(vm_isolate_snapshot_buffer),
+      isolate_snapshot_buffer_(isolate_snapshot_buffer),
+      alloc_(alloc),
+      vm_isolate_snapshot_size_(0),
+      isolate_snapshot_size_(0),
+      forward_list_(SnapshotWriter::FirstObjectId()) {
+  ASSERT(isolate_snapshot_buffer_ != NULL);
+  ASSERT(alloc_ != NULL);
+}
+
+
+void FullSnapshotWriter::WriteVmIsolateSnapshot() {
+  ASSERT(vm_isolate_snapshot_buffer_ != NULL);
+  SnapshotWriter writer(Snapshot::kFull,
+                        vm_isolate_snapshot_buffer_,
+                        alloc_,
+                        kInitialSize,
+                        &forward_list_,
+                        true);  // Can send any kind of object.
+  Isolate* isolate = writer.isolate();
+  ASSERT(isolate != NULL);
+  ObjectStore* object_store = isolate->object_store();
   ASSERT(object_store != NULL);
   ASSERT(ClassFinalizer::AllClassesFinalized());
 
   // Ensure the class table is valid.
 #if defined(DEBUG)
-  isolate()->ValidateClassTable();
+  isolate->ValidateClassTable();
 #endif
 
+  // Write full snapshot for a regular isolate.
   // Setup for long jump in case there is an exception while writing
   // the snapshot.
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     // Reserve space in the output buffer for a snapshot header.
-    ReserveHeader();
+    writer.ReserveHeader();
 
     // Write out the version string.
-    WriteVersion();
+    writer.WriteVersion();
+
+    // Write out the symbol table.
+    {
+      NoSafepointScope no_safepoint;
+
+      // Write out the symbol table and reset the symbol table for the
+      // regular isolate so that we do not write these symbols into the
+      // snapshot of a regular dart isolate.
+      writer.WriteObject(object_store->symbol_table());
+
+      writer.FillHeader(writer.kind());
+    }
+    vm_isolate_snapshot_size_ = writer.BytesWritten();
+    // Reset the symbol table for the regular isolate so that we do not
+    // write these symbols into the snapshot of a regular dart isolate.
+    Symbols::SetupSymbolTable(isolate);
+  } else {
+    writer.ThrowException(writer.exception_type(), writer.exception_msg());
+  }
+}
+
+
+void FullSnapshotWriter::WriteIsolateFullSnapshot() {
+  SnapshotWriter writer(Snapshot::kFull,
+                        isolate_snapshot_buffer_,
+                        alloc_,
+                        kInitialSize,
+                        &forward_list_,
+                        true);
+  Isolate* isolate = writer.isolate();
+  ASSERT(isolate != NULL);
+  ObjectStore* object_store = isolate->object_store();
+  ASSERT(object_store != NULL);
+  ASSERT(ClassFinalizer::AllClassesFinalized());
+
+  // Ensure the class table is valid.
+#if defined(DEBUG)
+  isolate->ValidateClassTable();
+#endif
+
+  // Write full snapshot for a regular isolate.
+  // Setup for long jump in case there is an exception while writing
+  // the snapshot.
+  LongJumpScope jump;
+  if (setjmp(*jump.Set()) == 0) {
+    // Reserve space in the output buffer for a snapshot header.
+    writer.ReserveHeader();
+
+    // Write out the version string.
+    writer.WriteVersion();
 
     // Write out the full snapshot.
     {
       NoSafepointScope no_safepoint;
 
       // Write out all the objects in the object store of the isolate which
       // is the root set for all dart allocated objects at this point.
-      SnapshotWriterVisitor visitor(this, false);
+      SnapshotWriterVisitor visitor(&writer, false);
       object_store->VisitObjectPointers(&visitor);
 
       // Write out all forwarded objects.
-      WriteForwardedObjects();
+      writer.WriteForwardedObjects();
 
-      FillHeader(kind());
-      UnmarkAll();
+      writer.FillHeader(writer.kind());
+      writer.UnmarkAll();
     }
+    isolate_snapshot_size_ = writer.BytesWritten();
   } else {
-    ThrowException(exception_type(), exception_msg());
+    writer.ThrowException(writer.exception_type(), writer.exception_msg());
   }
 }
 
 
+void FullSnapshotWriter::WriteFullSnapshot() {
+  if (vm_isolate_snapshot_buffer() != NULL) {
+    WriteVmIsolateSnapshot();
+  }
+  WriteIsolateFullSnapshot();
+}
+
+
 uword SnapshotWriter::GetObjectTags(RawObject* raw) {
   uword tags = raw->ptr()->tags_;
   if (SerializedHeaderTag::decode(tags) == kObjectId) {
     intptr_t id = SerializedHeaderData::decode(tags);
-    return forward_list_.NodeForObjectId(id)->tags();
+    return forward_list_->NodeForObjectId(id)->tags();
   } else {
     return tags;
   }
 }
 
 
 ForwardList::ForwardList(intptr_t first_object_id)
     : first_object_id_(first_object_id),
       nodes_(),
       first_unprocessed_object_id_(first_object_id) {
@@ skipping 13 matching lines @@
   MonitorLocker ml(page_space->tasks_lock());
   ASSERT(page_space->tasks() == 1);
   page_space->set_tasks(0);
   ml.Notify();
 }
 
 
 intptr_t ForwardList::MarkAndAddObject(RawObject* raw, SerializeState state) {
   NoSafepointScope no_safepoint;
   intptr_t object_id = next_object_id();
-  ASSERT(object_id <= kMaxObjectId);
+  ASSERT(object_id > 0 && object_id <= kMaxObjectId);
   uword value = 0;
   value = SerializedHeaderTag::update(kObjectId, value);
   value = SerializedHeaderData::update(object_id, value);
   uword tags = raw->ptr()->tags_;
   ASSERT(SerializedHeaderTag::decode(tags) != kObjectId);
   raw->ptr()->tags_ = value;
   Node* node = new Node(raw, tags, state);
   ASSERT(node != NULL);
   nodes_.Add(node);
   return object_id;
 }
 
 
 void ForwardList::UnmarkAll() const {
-  NoSafepointScope no_safepoint;
-  for (intptr_t id = first_object_id(); id < next_object_id(); ++id) {
-    const Node* node = NodeForObjectId(id);
-    RawObject* raw = node->raw();
-    raw->ptr()->tags_ = node->tags();  // Restore original tags.
+  {
+    NoSafepointScope no_safepoint;
+    for (intptr_t id = first_object_id(); id < next_object_id(); ++id) {
+      const Node* node = NodeForObjectId(id);
+      RawObject* raw = node->raw();
+      raw->ptr()->tags_ = node->tags();  // Restore original tags.
+    }
   }
 }
 
 
 bool SnapshotWriter::CheckAndWritePredefinedObject(RawObject* rawobj) {
   // Check if object can be written in one of the following ways:
   // - Smi: the Smi value is written as is (last bit is not tagged).
   // - VM internal class (from VM isolate): (index of class in vm isolate | 0x3)
   // - Object that has already been written: (negative id in stream | 0x3)
 
@@ skipping 80 matching lines @@
 
 void SnapshotWriter::WriteObjectImpl(RawObject* raw) {
   // First check if object can be written as a simple predefined type.
   if (CheckAndWritePredefinedObject(raw)) {
     return;
   }
 
   // Object is being serialized, add it to the forward ref list and mark
   // it so that future references to this object in the snapshot will use
   // an object id, instead of trying to serialize it again.
-  forward_list_.MarkAndAddObject(raw, kIsSerialized);
+  forward_list_->MarkAndAddObject(raw, kIsSerialized);
 
   WriteInlinedObject(raw);
 }
 
 
 void SnapshotWriter::WriteInlinedObject(RawObject* raw) {
   // Now write the object out inline in the stream as follows:
   // - Object is seen for the first time (inlined as follows):
   //    (object size in multiples of kObjectAlignment | 0x1)
   //    serialized fields of the object
   //    ......
   NoSafepointScope no_safepoint;
   uword tags = raw->ptr()->tags_;
   ASSERT(SerializedHeaderTag::decode(tags) == kObjectId);
   intptr_t object_id = SerializedHeaderData::decode(tags);
-  tags = forward_list_.NodeForObjectId(object_id)->tags();
+  tags = forward_list_->NodeForObjectId(object_id)->tags();
   RawClass* cls = class_table_->At(RawObject::ClassIdTag::decode(tags));
   intptr_t class_id = cls->ptr()->id_;
 
   if (!IsSplitClassId(class_id)) {
     object_id = kOmittedObjectId;
   }
 
   if (class_id >= kNumPredefinedCids) {
     WriteInstance(object_id, raw, cls, tags);
     return;
@@ skipping 51 matching lines @@
     writer_->WriteInlinedObject(obj);
   }
 
  private:
   SnapshotWriter* writer_;
 };
 
 
 void SnapshotWriter::WriteForwardedObjects() {
   WriteInlinedObjectVisitor visitor(this);
-  forward_list_.SerializeAll(&visitor);
+  forward_list_->SerializeAll(&visitor);
 }
 
 
 void ForwardList::SerializeAll(ObjectVisitor* writer) {
   // Write out all objects that were added to the forward list and have
   // not been serialized yet. These would typically be fields of instance
   // objects, arrays or immutable arrays (this is done in order to avoid
   // deep recursive calls to WriteObjectImpl).
   // NOTE: The forward list might grow as we process the list.
 #ifdef DEBUG
@@ skipping 221 matching lines @@
   CheckForNativeFields(cls);
 
   // Check if object is a closure that is serializable, if the object is a
   // closure that is not serializable this will throw an exception.
   RawFunction* func = IsSerializableClosure(cls, raw);
   if (func != Function::null()) {
     // Add object to the forward ref list and mark it so that future references
     // to this object in the snapshot will use this object id. Mark it as having
     // been serialized so that we do not serialize the object when we go through
     // the forward list.
-    forward_list_.MarkAndAddObject(raw, kIsSerialized);
+    forward_list_->MarkAndAddObject(raw, kIsSerialized);
     uword tags = raw->ptr()->tags_;
     ASSERT(SerializedHeaderTag::decode(tags) == kObjectId);
     intptr_t object_id = SerializedHeaderData::decode(tags);
-    tags = forward_list_.NodeForObjectId(object_id)->tags();
+    tags = forward_list_->NodeForObjectId(object_id)->tags();
     WriteStaticImplicitClosure(object_id, func, tags);
     return;
   }
 
   // Object is being referenced, add it to the forward ref list and mark
   // it so that future references to this object in the snapshot will use
   // this object id. Mark it as not having been serialized yet so that we
   // will serialize the object when we go through the forward list.
-  forward_list_.MarkAndAddObject(raw, kIsNotSerialized);
+  forward_list_->MarkAndAddObject(raw, kIsNotSerialized);
 
   // Write out the serialization header value for this object.
   WriteInlinedObjectHeader(kOmittedObjectId);
 
   // Indicate this is an instance object.
   Write<int32_t>(SerializedHeaderData::encode(kInstanceObjectId));
 
   // Write out the class information for this object.
   WriteObjectImpl(cls);
 }
 
 
 bool SnapshotWriter::AllowObjectsInDartLibrary(RawLibrary* library) {
   return (library == object_store()->collection_library() ||
           library == object_store()->typed_data_library());
 }
 
 
+intptr_t SnapshotWriter::FindVmSnapshotObject(RawObject* rawobj) {
+  intptr_t length = Object::vm_isolate_snapshot_object_table().Length();
+  for (intptr_t i = 0; i < length; i++) {
+    if (Object::vm_isolate_snapshot_object_table().At(i) == rawobj) {
+      return (i + kMaxPredefinedObjectIds);
+    }
+  }
+  return kInvalidIndex;
+}
+
+
 void SnapshotWriter::ThrowException(Exceptions::ExceptionType type,
                                     const char* msg) {
   object_store()->clear_sticky_error();
   UnmarkAll();
   if (msg != NULL) {
     const String& msg_obj = String::Handle(String::New(msg));
     const Array& args = Array::Handle(Array::New(1));
     args.SetAt(0, msg_obj);
     Exceptions::ThrowByType(type, args);
   } else {
     Exceptions::ThrowByType(type, Object::empty_array());
   }
   UNREACHABLE();
 }
 
 
 void SnapshotWriter::WriteVersion() {
   const char* expected_version = Version::SnapshotString();
   ASSERT(expected_version != NULL);
   const intptr_t version_len = strlen(expected_version);
   WriteBytes(reinterpret_cast<const uint8_t*>(expected_version), version_len);
 }
 
 
+intptr_t SnapshotWriter::FirstObjectId() {
+  intptr_t max_vm_isolate_object_id =
+      Object::vm_isolate_snapshot_object_table().Length();
+  return kMaxPredefinedObjectIds + max_vm_isolate_object_id;
+}
+
+
+ScriptSnapshotWriter::ScriptSnapshotWriter(uint8_t** buffer,
+                                           ReAlloc alloc)
+    : SnapshotWriter(Snapshot::kScript,
+                     buffer,
+                     alloc,
+                     kInitialSize,
+                     &forward_list_,
+                     true),
+      forward_list_(SnapshotWriter::FirstObjectId()) {
+  ASSERT(buffer != NULL);
+  ASSERT(alloc != NULL);
+}
+
+
 void ScriptSnapshotWriter::WriteScriptSnapshot(const Library& lib) {
   ASSERT(kind() == Snapshot::kScript);
   ASSERT(isolate() != NULL);
   ASSERT(ClassFinalizer::AllClassesFinalized());
 
   // Setup for long jump in case there is an exception while writing
   // the snapshot.
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     // Reserve space in the output buffer for a snapshot header.
@@ skipping 23 matching lines @@
     RawObject* raw_obj = *current;
     if (as_references_) {
       writer_->WriteObjectRef(raw_obj);
     } else {
       writer_->WriteObjectImpl(raw_obj);
     }
   }
 }
 
 
+MessageWriter::MessageWriter(uint8_t** buffer,
+                             ReAlloc alloc,
+                             bool can_send_any_object)
+    : SnapshotWriter(Snapshot::kMessage,
+                     buffer,
+                     alloc,
+                     kInitialSize,
+                     &forward_list_,
+                     can_send_any_object),
+      forward_list_(SnapshotWriter::FirstObjectId()) {
+  ASSERT(buffer != NULL);
+  ASSERT(alloc != NULL);
+}
+
+
 void MessageWriter::WriteMessage(const Object& obj) {
   ASSERT(kind() == Snapshot::kMessage);
   ASSERT(isolate() != NULL);
 
   // Setup for long jump in case there is an exception while writing
   // the message.
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     NoSafepointScope no_safepoint;
     WriteObject(obj.raw());
     UnmarkAll();
   } else {
     ThrowException(exception_type(), exception_msg());
   }
 }
 
 
 }  // namespace dart