Support for taking full snapshots from 'dart', not just 'dart_bootstrap'.

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 1544 matching lines @@
     }
   }
 
   // Check if it is a singleton ICData array object.
   for (intptr_t i = 0; i < ICData::kCachedICDataArrayCount; i++) {
     if (object_id == (kCachedICDataArray0 + i)) {
       return ICData::cached_icdata_arrays_[i];
     }
   }
 
-  ASSERT(Symbols::IsVMSymbolId(object_id));
-  return Symbols::GetVMSymbol(object_id);  // return VM symbol.
+  ASSERT(Symbols::IsPredefinedSymbolId(object_id));
+  return Symbols::GetPredefinedSymbol(object_id);  // return VM symbol.
 }
 
 
 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.
   }
@@ skipping 234 matching lines @@
 
 
 SnapshotWriter::SnapshotWriter(Thread* thread,
                                Snapshot::Kind kind,
                                uint8_t** buffer,
                                ReAlloc alloc,
                                intptr_t initial_size,
                                ForwardList* forward_list,
                                InstructionsWriter* instructions_writer,
                                bool can_send_any_object,
-                               bool vm_isolate_is_symbolic)
+                               bool writing_vm_isolate)
     : BaseWriter(buffer, alloc, initial_size),
       thread_(thread),
       kind_(kind),
       object_store_(isolate()->object_store()),
       class_table_(isolate()->class_table()),
       forward_list_(forward_list),
       instructions_writer_(instructions_writer),
       exception_type_(Exceptions::kNone),
       exception_msg_(NULL),
       unmarked_objects_(false),
       can_send_any_object_(can_send_any_object),
-      vm_isolate_is_symbolic_(vm_isolate_is_symbolic) {
+      writing_vm_isolate_(writing_vm_isolate) {
   ASSERT(forward_list_ != NULL);
 }
 
 
 void SnapshotWriter::WriteObject(RawObject* rawobj) {
   WriteObjectImpl(rawobj, kAsInlinedObject);
   WriteForwardedObjects();
 }
 
 
@@ skipping 71 matching lines @@
   }
 
   // Check if it is a singleton ICData array object.
   for (intptr_t i = 0; i < ICData::kCachedICDataArrayCount; i++) {
     if (rawobj == ICData::cached_icdata_arrays_[i]) {
       WriteVMIsolateObject(kCachedICDataArray0 + i);
       return true;
     }
   }
 
+  if (writing_vm_isolate_) {
+    // Write the object instead of a reference.

[siva, 2016/05/10 00:49:10]

maybe make this comment a little more elaborate by stating that we are writing
the VM isolate snapshot here and hence we should not be writing out a VM object
id but the object itself.

[rmacnak, 2016/05/10 01:45:01]

Done.

+    return false;
+  }
+
   if (Snapshot::IsFull(kind())) {
     // Check it is a predefined symbol in the VM isolate.
-    id = Symbols::LookupVMSymbol(rawobj);
+    id = Symbols::LookupPredefinedSymbol(rawobj);
     if (id != kInvalidIndex) {
       WriteVMIsolateObject(id);
       return true;
     }
 
     // Check if it is an object from the vm isolate snapshot object table.
     id = FindVmSnapshotObject(rawobj);
     if (id != kInvalidIndex) {
       WriteIndexedObject(id);
       return true;
@@ skipping 15 matching lines @@
           raw_obj->WriteTo(this, object_id, kind(), false);
           return true;
         }
         default:
           OS::Print("class id = %" Pd "\n", id);
           break;
       }
     }
   }
 
-  if (!vm_isolate_is_symbolic()) {
-    return false;
-  }
-
   const Object& obj = Object::Handle(rawobj);
   FATAL1("Unexpected reference to object in VM isolate: %s\n", obj.ToCString());
   return false;
 }
 
 #undef VM_OBJECT_WRITE
 
 
 // An object visitor which will iterate over all the script objects in the heap
 // and either count them or collect them into an array. This is used during
@@ skipping 27 matching lines @@
   Object& objHandle_;
   intptr_t count_;
   const Array* scripts_;
 };
 
 
 FullSnapshotWriter::FullSnapshotWriter(Snapshot::Kind kind,
                                        uint8_t** vm_isolate_snapshot_buffer,
                                        uint8_t** isolate_snapshot_buffer,
                                        ReAlloc alloc,
-                                       InstructionsWriter* instructions_writer,
-                                       bool vm_isolate_is_symbolic)
+                                       InstructionsWriter* instructions_writer)
     : thread_(Thread::Current()),
       kind_(kind),
       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_(NULL),
       instructions_writer_(instructions_writer),
       scripts_(Array::Handle(zone())),
-      symbol_table_(Array::Handle(zone())),
-      vm_isolate_is_symbolic_(vm_isolate_is_symbolic) {
+      saved_symbol_table_(Array::Handle(zone())),
+      new_vm_symbol_table_(Array::Handle(zone())) {
   ASSERT(isolate_snapshot_buffer_ != NULL);
   ASSERT(alloc_ != NULL);
   ASSERT(isolate() != NULL);
   ASSERT(ClassFinalizer::AllClassesFinalized());
   ASSERT(isolate() != NULL);
   ASSERT(heap() != NULL);
   ObjectStore* object_store = isolate()->object_store();
   ASSERT(object_store != NULL);
+
+#if defined(DEBUG)
   // Ensure the class table is valid.
-#if defined(DEBUG)
   isolate()->ValidateClassTable();
 #endif
+  // Can't have any mutation happening while we're serializing.
   ASSERT(isolate()->background_compiler() == NULL);
 
-  // Collect all the script objects and their accompanying token stream objects
-  // into an array so that we can write it out as part of the VM isolate
-  // snapshot. We first count the number of script objects, allocate an array
-  // and then fill it up with the script objects.
-  ScriptVisitor scripts_counter(thread());
-  heap()->IterateOldObjects(&scripts_counter);
-  intptr_t count = scripts_counter.count();
-  scripts_ = Array::New(count, Heap::kOld);
-  ScriptVisitor script_visitor(thread(), &scripts_);
-  heap()->IterateOldObjects(&script_visitor);
+  intptr_t first_object_id = -1;
+  if (vm_isolate_snapshot_buffer != NULL) {
+    // Collect all the script objects and their accompanying token stream
+    // objects into an array so that we can write it out as part of the VM
+    // isolate snapshot. We first count the number of script objects, allocate
+    // an array and then fill it up with the script objects.
+    ScriptVisitor scripts_counter(thread());
+    heap()->IterateOldObjects(&scripts_counter);
+    Dart::vm_isolate()->heap()->IterateOldObjects(&scripts_counter);
+    intptr_t count = scripts_counter.count();
+    scripts_ = Array::New(count, Heap::kOld);
+    ScriptVisitor script_visitor(thread(), &scripts_);
+    heap()->IterateOldObjects(&script_visitor);
+    Dart::vm_isolate()->heap()->IterateOldObjects(&script_visitor);
+    ASSERT(script_visitor.count() == count);
 
-  if (vm_isolate_snapshot_buffer != NULL) {
-    // Stash the symbol table away for writing and reading into the vm isolate,
-    // 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.
-    symbol_table_ = object_store->symbol_table();
+    // Tuck away the current symbol table.
+    saved_symbol_table_ = object_store->symbol_table();
+
+    // Create a unified symbol table that will be written as the vm isolate's
+    // symbol table.
+    new_vm_symbol_table_ = Symbols::UnifiedSymbolTable();
+
+    // Create an empty symbol table that will be written as the isolate's symbol
+    // table.
     Symbols::SetupSymbolTable(isolate());
+
+    first_object_id = kMaxPredefinedObjectIds;
+  } else {
+    intptr_t max_vm_isolate_object_id =
+        Object::vm_isolate_snapshot_object_table().Length();
+    first_object_id = kMaxPredefinedObjectIds + max_vm_isolate_object_id;
   }
 
-  forward_list_ = new ForwardList(thread(), SnapshotWriter::FirstObjectId());
+  forward_list_ = new ForwardList(thread(), first_object_id);
   ASSERT(forward_list_ != NULL);
 }
 
 
 FullSnapshotWriter::~FullSnapshotWriter() {
   delete forward_list_;
   // We may run Dart code afterwards, restore the symbol table if needed.
-  if (!symbol_table_.IsNull()) {
-    isolate()->object_store()->set_symbol_table(symbol_table_);
-    symbol_table_ = Array::null();
+  if (!saved_symbol_table_.IsNull()) {
+    isolate()->object_store()->set_symbol_table(saved_symbol_table_);
+    saved_symbol_table_ = Array::null();
   }
+  new_vm_symbol_table_ = Array::null();
   scripts_ = Array::null();
 }
 
 
 void FullSnapshotWriter::WriteVmIsolateSnapshot() {
   ASSERT(vm_isolate_snapshot_buffer_ != NULL);
   SnapshotWriter writer(thread(),
                         kind_,
                         vm_isolate_snapshot_buffer_,
                         alloc_,
                         kInitialSize,
                         forward_list_,
                         instructions_writer_,
                         true, /* can_send_any_object */
-                        vm_isolate_is_symbolic_);
+                        true /* writing_vm_isolate */);
   // Write full snapshot for the VM 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();
 
     /*
      * Now Write out the following
      * - the symbol table
      * - all the scripts and token streams for these scripts
-     *
+     * - the stub code (precompiled snapshots only)
      **/
     // Write out the symbol table.
-    writer.WriteObject(symbol_table_.raw());
+    writer.WriteObject(new_vm_symbol_table_.raw());
 
     // Write out all the script objects and the accompanying token streams
     // for the bootstrap libraries so that they are in the VM isolate
     // read only memory.
     writer.WriteObject(scripts_.raw());
 
     if (Snapshot::IncludesCode(kind_)) {
-      ASSERT(!vm_isolate_is_symbolic_);
       StubCode::WriteTo(&writer);
     }
 
-
     writer.FillHeader(writer.kind());
 
     vm_isolate_snapshot_size_ = writer.BytesWritten();
   } else {
     writer.ThrowException(writer.exception_type(), writer.exception_msg());
   }
 }
 
 
 void FullSnapshotWriter::WriteIsolateFullSnapshot() {
   SnapshotWriter writer(thread(),
                         kind_,
                         isolate_snapshot_buffer_,
                         alloc_,
                         kInitialSize,
                         forward_list_,
                         instructions_writer_,
                         true, /* can_send_any_object */
-                        true /* vm_isolate_is_symbolic */);
+                        false /* writing_vm_isolate */);
   ObjectStore* object_store = isolate()->object_store();
   ASSERT(object_store != NULL);
 
   // 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();
@@ skipping 39 matching lines @@
     OS::Print("Total(CodeSize): %" Pd "\n", total);
   }
 }
 
 
 ForwardList::ForwardList(Thread* thread, intptr_t first_object_id)
     : thread_(thread),
       first_object_id_(first_object_id),
       nodes_(),
       first_unprocessed_object_id_(first_object_id) {
+  ASSERT(first_object_id > 0);
 }
 
 
 ForwardList::~ForwardList() {
   heap()->ResetObjectIdTable();
 }
 
 
 intptr_t ForwardList::AddObject(Zone* zone,
                                 RawObject* raw,
                                 SerializeState state) {
   NoSafepointScope no_safepoint;
   intptr_t object_id = next_object_id();
   ASSERT(object_id > 0 && object_id <= kMaxObjectId);
   const Object& obj = Object::ZoneHandle(zone, raw);
   Node* node = new Node(&obj, state);
   ASSERT(node != NULL);
   nodes_.Add(node);
-  ASSERT(SnapshotWriter::FirstObjectId() > 0);
   ASSERT(object_id != 0);
   heap()->SetObjectId(raw, object_id);
   return object_id;
 }
 
 
 intptr_t ForwardList::FindObject(RawObject* raw) {
   NoSafepointScope no_safepoint;
-  ASSERT(SnapshotWriter::FirstObjectId() > 0);
   intptr_t id = heap()->GetObjectId(raw);
   ASSERT(id == 0 || NodeForObjectId(id)->obj()->raw() == raw);
   return (id == 0) ? static_cast<intptr_t>(kInvalidIndex) : id;
 }
 
 
 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)
@@ skipping 438 matching lines @@
 
 
 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(Thread::Current(),
                      Snapshot::kScript,
                      buffer,
                      alloc,
                      kInitialSize,
                      &forward_list_,
                      NULL, /* instructions_writer */
                      true, /* can_send_any_object */
-                     true /* vm_isolate_is_symbolic */),
+                     false /* writing_vm_isolate */),
       forward_list_(thread(), kMaxPredefinedObjectIds) {
   ASSERT(buffer != NULL);
   ASSERT(alloc != NULL);
 }
 
 
 void ScriptSnapshotWriter::WriteScriptSnapshot(const Library& lib) {
   ASSERT(kind() == Snapshot::kScript);
   ASSERT(isolate() != NULL);
   ASSERT(ClassFinalizer::AllClassesFinalized());
@@ skipping 35 matching lines @@
                              ReAlloc alloc,
                              bool can_send_any_object)
     : SnapshotWriter(Thread::Current(),
                      Snapshot::kMessage,
                      buffer,
                      alloc,
                      kInitialSize,
                      &forward_list_,
                      NULL, /* instructions_writer */
                      can_send_any_object,
-                     true /* vm_isolate_is_symbolic */),
+                     false /* writing_vm_isolate */),
       forward_list_(thread(), kMaxPredefinedObjectIds) {
   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());
   } else {
     ThrowException(exception_type(), exception_msg());
   }
 }
 
 
 }  // namespace dart