Do not rewrite the VM isolate's symbol table during AOT snapshots.

runtime/vm/clustered_snapshot.cc

 // Copyright (c) 2016, 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/clustered_snapshot.h"
 
 #include "platform/assert.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart.h"
@@ skipping 4699 matching lines @@
     }
   }
 
   intptr_t num_objects = num_base_objects_ + num_written_objects_;
 #if defined(ARCH_IS_64_BIT)
   if (!Utils::IsInt(32, num_objects)) {
     FATAL("Ref overflow");
   }
 #endif
 
+  Write<int32_t>(num_base_objects_);
   Write<int32_t>(num_objects);
   Write<int32_t>(num_clusters);
 
   for (intptr_t cid = 1; cid < num_cids_; cid++) {
     SerializationCluster* cluster = clusters_by_cid_[cid];
     if (cluster != NULL) {
       cluster->WriteAlloc(this);
 #if defined(DEBUG)
       Write<int32_t>(next_ref_index_);
 #endif
@@ skipping 353 matching lines @@
     const String& msg = String::Handle(String::New(message_buffer, Heap::kOld));
     return ApiError::New(msg, Heap::kOld);
   }
   free(const_cast<char*>(expected_features));
   Advance(expected_len + 1);
   return ApiError::null();
 }
 
 
 void Deserializer::Prepare() {
+  num_base_objects_ = Read<int32_t>();
   num_objects_ = Read<int32_t>();
   num_clusters_ = Read<int32_t>();
 
   clusters_ = new DeserializationCluster*[num_clusters_];
   refs_ = Array::New(num_objects_ + 1, Heap::kOld);
 }
 
 
 void Deserializer::Deserialize() {
-  // TODO(rmacnak): Verify num of base objects.
+  if (num_base_objects_ != (next_ref_index_ - 1)) {
+    FATAL2("Snapshot expects %" Pd
+           " base objects, but deserializer provided %" Pd,
+           num_base_objects_, next_ref_index_ - 1);
+  }
 
   {
     NOT_IN_PRODUCT(TimelineDurationScope tds(
         thread(), Timeline::GetIsolateStream(), "ReadAlloc"));
     for (intptr_t i = 0; i < num_clusters_; i++) {
       clusters_[i] = ReadCluster();
       clusters_[i]->ReadAlloc(this);
 #if defined(DEBUG)
       intptr_t serializers_next_ref_index_ = Read<int32_t>();
       ASSERT(serializers_next_ref_index_ == next_ref_index_);
@@ skipping 236 matching lines @@
   ObjectStore* object_store = isolate()->object_store();
   ASSERT(object_store != NULL);
 
 #if defined(DEBUG)
   // Ensure the class table is valid.
   isolate()->ValidateClassTable();
 #endif
   // Can't have any mutation happening while we're serializing.
   ASSERT(isolate()->background_compiler() == NULL);
 
-  if (vm_snapshot_data_buffer != NULL) {
+  // TODO(rmacnak): The special case for AOT causes us to always generate the
+  // same VM isolate snapshot for every app. This should be cleaned up so the VM
+  // isolate snapshot is generated separately and each app is generated from a
+  // VM that has loaded this snapshots, much like app-jit snapshots.

[siva, 2017/04/06 19:19:40]

this snapshot?

[rmacnak, 2017/04/06 20:09:48]

Clarified comment that it is AOT snapshots which need cleanup.

+  if ((vm_snapshot_data_buffer != NULL) && (kind != Snapshot::kAppAOT)) {
     NOT_IN_PRODUCT(TimelineDurationScope tds(
         thread(), Timeline::GetIsolateStream(), "PrepareNewVMIsolate"));
 
     // Collect all the 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
     // token streams, allocate an array and then fill it up with the token
     // streams.
     SnapshotTokenStreamVisitor token_streams_counter(thread());
     heap()->IterateOldObjects(&token_streams_counter);
     Dart::vm_isolate()->heap()->IterateOldObjects(&token_streams_counter);
     intptr_t count = token_streams_counter.count();
     token_streams_ = Array::New(count, Heap::kOld);
     SnapshotTokenStreamVisitor script_visitor(thread(), &token_streams_);
     heap()->IterateOldObjects(&script_visitor);
     Dart::vm_isolate()->heap()->IterateOldObjects(&script_visitor);
     ASSERT(script_visitor.count() == count);
 
     // 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());
   } else {
     // Reuse the current vm isolate.
+    saved_symbol_table_ = object_store->symbol_table();
+    new_vm_symbol_table_ = Dart::vm_isolate()->object_store()->symbol_table();
   }
 }
 
 FullSnapshotWriter::~FullSnapshotWriter() {
   // We may run Dart code afterwards, restore the symbol table if needed.
   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();
@@ skipping 150 matching lines @@
     thread_->isolate()->SetupImagePage(data_buffer_,
                                        /* is_executable */ false);
   }
 
   deserializer.ReadIsolateSnapshot(thread_->isolate()->object_store());
 
   return ApiError::null();
 }
 
 }  // namespace dart