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

runtime/vm/snapshot_test.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 "platform/globals.h"
 
 #include "include/dart_debugger_api.h"
 #include "platform/assert.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart_api_impl.h"
@@ skipping 139 matching lines @@
   StackZone zone(Isolate::Current());
 
   // Write snapshot with object content.
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator, true);
   const Object& null_object = Object::Handle();
   writer.WriteMessage(null_object);
   intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
-  SnapshotReader reader(buffer, buffer_len,
-                        Snapshot::kMessage, Isolate::Current(), zone.GetZone());
+  MessageSnapshotReader reader(buffer,
+                               buffer_len,
+                               Isolate::Current(),
+                               zone.GetZone());
   const Object& serialized_object = Object::Handle(reader.ReadObject());
   EXPECT(Equals(null_object, serialized_object));
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
   ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
   Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_NOTNULL(root);
   EXPECT_EQ(Dart_CObject_kNull, root->type);
   CheckEncodeDecodeMessage(root);
 }
 
 
 TEST_CASE(SerializeSmi1) {
   StackZone zone(Isolate::Current());
 
   // Write snapshot with object content.
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator, true);
   const Smi& smi = Smi::Handle(Smi::New(124));
   writer.WriteMessage(smi);
   intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
-  SnapshotReader reader(buffer, buffer_len,
-                        Snapshot::kMessage, Isolate::Current(), zone.GetZone());
+  MessageSnapshotReader reader(buffer,
+                               buffer_len,
+                               Isolate::Current(),
+                               zone.GetZone());
   const Object& serialized_object = Object::Handle(reader.ReadObject());
   EXPECT(Equals(smi, serialized_object));
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
   ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
   Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_NOTNULL(root);
   EXPECT_EQ(Dart_CObject_kInt32, root->type);
   EXPECT_EQ(smi.Value(), root->value.as_int32);
   CheckEncodeDecodeMessage(root);
 }
 
 
 TEST_CASE(SerializeSmi2) {
   StackZone zone(Isolate::Current());
 
   // Write snapshot with object content.
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator, true);
   const Smi& smi = Smi::Handle(Smi::New(-1));
   writer.WriteMessage(smi);
   intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
-  SnapshotReader reader(buffer, buffer_len,
-                        Snapshot::kMessage, Isolate::Current(), zone.GetZone());
+  MessageSnapshotReader reader(buffer,
+                               buffer_len,
+                               Isolate::Current(),
+                               zone.GetZone());
   const Object& serialized_object = Object::Handle(reader.ReadObject());
   EXPECT(Equals(smi, serialized_object));
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
   ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
   Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_NOTNULL(root);
   EXPECT_EQ(Dart_CObject_kInt32, root->type);
   EXPECT_EQ(smi.Value(), root->value.as_int32);
   CheckEncodeDecodeMessage(root);
 }
 
 
 Dart_CObject* SerializeAndDeserializeMint(const Mint& mint) {
   // Write snapshot with object content.
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator, true);
   writer.WriteMessage(mint);
   intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
-  SnapshotReader reader(buffer, buffer_len,
-                        Snapshot::kMessage, Isolate::Current(),
-                        Thread::Current()->zone());
+  MessageSnapshotReader reader(buffer,
+                               buffer_len,
+                               Isolate::Current(),
+                               Thread::Current()->zone());
   const Object& serialized_object = Object::Handle(reader.ReadObject());
   EXPECT(serialized_object.IsMint());
 
   // Read object back from the snapshot into a C structure.
   ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
   Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_NOTNULL(root);
   CheckEncodeDecodeMessage(root);
   return root;
 }
@@ skipping 49 matching lines @@
   StackZone zone(Isolate::Current());
 
   // Write snapshot with object content.
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator, true);
   const Double& dbl = Double::Handle(Double::New(101.29));
   writer.WriteMessage(dbl);
   intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
-  SnapshotReader reader(buffer, buffer_len,
-                        Snapshot::kMessage, Isolate::Current(), zone.GetZone());
+  MessageSnapshotReader reader(buffer,
+                               buffer_len,
+                               Isolate::Current(),
+                               zone.GetZone());
   const Object& serialized_object = Object::Handle(reader.ReadObject());
   EXPECT(Equals(dbl, serialized_object));
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
   ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
   Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_NOTNULL(root);
   EXPECT_EQ(Dart_CObject_kDouble, root->type);
   EXPECT_EQ(dbl.value(), root->value.as_double);
   CheckEncodeDecodeMessage(root);
 }
 
 
 TEST_CASE(SerializeTrue) {
   StackZone zone(Isolate::Current());
 
   // Write snapshot with true object.
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator, true);
   const Bool& bl = Bool::True();
   writer.WriteMessage(bl);
   intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
-  SnapshotReader reader(buffer, buffer_len,
-                        Snapshot::kMessage, Isolate::Current(), zone.GetZone());
+  MessageSnapshotReader reader(buffer,
+                               buffer_len,
+                               Isolate::Current(),
+                               zone.GetZone());
   const Object& serialized_object = Object::Handle(reader.ReadObject());
   fprintf(stderr, "%s / %s\n", bl.ToCString(), serialized_object.ToCString());
 
   EXPECT(Equals(bl, serialized_object));
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
   ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
   Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_NOTNULL(root);
   EXPECT_EQ(Dart_CObject_kBool, root->type);
   EXPECT_EQ(true, root->value.as_bool);
   CheckEncodeDecodeMessage(root);
 }
 
 
 TEST_CASE(SerializeFalse) {
   StackZone zone(Isolate::Current());
 
   // Write snapshot with false object.
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator, true);
   const Bool& bl = Bool::False();
   writer.WriteMessage(bl);
   intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
-  SnapshotReader reader(buffer, buffer_len,
-                        Snapshot::kMessage, Isolate::Current(), zone.GetZone());
+  MessageSnapshotReader reader(buffer,
+                               buffer_len,
+                               Isolate::Current(),
+                               zone.GetZone());
   const Object& serialized_object = Object::Handle(reader.ReadObject());
   EXPECT(Equals(bl, serialized_object));
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
   ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
   Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_NOTNULL(root);
   EXPECT_EQ(Dart_CObject_kBool, root->type);
   EXPECT_EQ(false, root->value.as_bool);
@@ skipping 13 matching lines @@
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator, true);
   const char* cstr = "0x270FFFFFFFFFFFFFD8F0";
   const String& str = String::Handle(String::New(cstr));
   Bigint& bigint = Bigint::Handle();
   bigint ^= Integer::NewCanonical(str);
   writer.WriteMessage(bigint);
   intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
-  SnapshotReader reader(buffer, buffer_len,
-                        Snapshot::kMessage, Isolate::Current(), zone.GetZone());
+  MessageSnapshotReader reader(buffer,
+                               buffer_len,
+                               Isolate::Current(),
+                               zone.GetZone());
   Bigint& obj = Bigint::Handle();
   obj ^= reader.ReadObject();
 
   EXPECT_STREQ(bigint.ToHexCString(allocator), obj.ToHexCString(allocator));
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
   ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
   Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_NOTNULL(root);
   EXPECT_EQ(Dart_CObject_kBigint, root->type);
   char* hex_value = TestCase::BigintToHexValue(root);
   EXPECT_STREQ(cstr, hex_value);
   free(hex_value);
   CheckEncodeDecodeMessage(root);
 }
 
 
 Dart_CObject* SerializeAndDeserializeBigint(const Bigint& bigint) {
   // Write snapshot with object content.
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator, true);
   writer.WriteMessage(bigint);
   intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
-  SnapshotReader reader(buffer, buffer_len,
-                        Snapshot::kMessage, Isolate::Current(),
-                        Thread::Current()->zone());
+  MessageSnapshotReader reader(buffer,
+                               buffer_len,
+                               Isolate::Current(),
+                               Thread::Current()->zone());
   Bigint& serialized_bigint = Bigint::Handle();
   serialized_bigint ^= reader.ReadObject();
   const char* str1 = bigint.ToHexCString(allocator);
   const char* str2 = serialized_bigint.ToHexCString(allocator);
   EXPECT_STREQ(str1, str2);
   free(const_cast<char*>(str1));
   free(const_cast<char*>(str2));
 
   // Read object back from the snapshot into a C structure.
   ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
@@ skipping 42 matching lines @@
   writer.WriteObject(Object::library_class());
   writer.WriteObject(Object::code_class());
   writer.WriteObject(Object::instructions_class());
   writer.WriteObject(Object::pc_descriptors_class());
   writer.WriteObject(Object::exception_handlers_class());
   writer.WriteObject(Object::context_class());
   writer.WriteObject(Object::context_scope_class());
   intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
-  SnapshotReader reader(buffer, buffer_len, Snapshot::kMessage,
-                        Isolate::Current(), Thread::Current()->zone());
+  MessageSnapshotReader reader(buffer,
+                                 buffer_len,
+                                 Isolate::Current(),
+                                 Thread::Current()->zone());
   EXPECT(Object::class_class() == reader.ReadObject());
   EXPECT(Object::type_arguments_class() == reader.ReadObject());
   EXPECT(Object::function_class() == reader.ReadObject());
   EXPECT(Object::field_class() == reader.ReadObject());
   EXPECT(Object::token_stream_class() == reader.ReadObject());
   EXPECT(Object::script_class() == reader.ReadObject());
   EXPECT(Object::library_class() == reader.ReadObject());
   EXPECT(Object::code_class() == reader.ReadObject());
   EXPECT(Object::instructions_class() == reader.ReadObject());
   EXPECT(Object::pc_descriptors_class() == reader.ReadObject());
   EXPECT(Object::exception_handlers_class() == reader.ReadObject());
   EXPECT(Object::context_class() == reader.ReadObject());
   EXPECT(Object::context_scope_class() == reader.ReadObject());
 
   free(buffer);
 }
 
 
 static void TestString(const char* cstr) {
   StackZone zone(Isolate::Current());
   EXPECT(Utf8::IsValid(reinterpret_cast<const uint8_t*>(cstr), strlen(cstr)));
   // Write snapshot with object content.
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator, true);
   String& str = String::Handle(String::New(cstr));
   writer.WriteMessage(str);
   intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
-  SnapshotReader reader(buffer, buffer_len,
-                        Snapshot::kMessage, Isolate::Current(), zone.GetZone());
+  MessageSnapshotReader reader(buffer,
+                               buffer_len,
+                               Isolate::Current(),
+                               zone.GetZone());
   String& serialized_str = String::Handle();
   serialized_str ^= reader.ReadObject();
   EXPECT(str.Equals(serialized_str));
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
   ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
   Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_EQ(Dart_CObject_kString, root->type);
   EXPECT_STREQ(cstr, root->value.as_string);
@@ skipping 26 matching lines @@
   Array& array = Array::Handle(Array::New(kArrayLength));
   Smi& smi = Smi::Handle();
   for (int i = 0; i < kArrayLength; i++) {
     smi ^= Smi::New(i);
     array.SetAt(i, smi);
   }
   writer.WriteMessage(array);
   intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
-  SnapshotReader reader(buffer, buffer_len,
-                        Snapshot::kMessage, Isolate::Current(), zone.GetZone());
+  MessageSnapshotReader reader(buffer,
+                               buffer_len,
+                               Isolate::Current(),
+                               zone.GetZone());
   Array& serialized_array = Array::Handle();
   serialized_array ^= reader.ReadObject();
   EXPECT(array.CanonicalizeEquals(serialized_array));
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
   ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
   Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_EQ(Dart_CObject_kArray, root->type);
   EXPECT_EQ(kArrayLength, root->value.as_array.length);
@@ skipping 63 matching lines @@
 
   // Write snapshot with object content.
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator, true);
   const int kArrayLength = 0;
   Array& array = Array::Handle(Array::New(kArrayLength));
   writer.WriteMessage(array);
   intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
-  SnapshotReader reader(buffer, buffer_len,
-                        Snapshot::kMessage, Isolate::Current(), zone.GetZone());
+  MessageSnapshotReader reader(buffer,
+                               buffer_len,
+                               Isolate::Current(),
+                               zone.GetZone());
   Array& serialized_array = Array::Handle();
   serialized_array ^= reader.ReadObject();
   EXPECT(array.CanonicalizeEquals(serialized_array));
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
   ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
   Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_EQ(Dart_CObject_kArray, root->type);
   EXPECT_EQ(kArrayLength, root->value.as_array.length);
@@ skipping 11 matching lines @@
   const int kTypedDataLength = 256;
   TypedData& typed_data = TypedData::Handle(
       TypedData::New(kTypedDataUint8ArrayCid, kTypedDataLength));
   for (int i = 0; i < kTypedDataLength; i++) {
     typed_data.SetUint8(i, i);
   }
   writer.WriteMessage(typed_data);
   intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
-  SnapshotReader reader(buffer, buffer_len,
-                        Snapshot::kMessage, Isolate::Current(), zone.GetZone());
+  MessageSnapshotReader reader(buffer,
+                               buffer_len,
+                               Isolate::Current(),
+                               zone.GetZone());
   TypedData& serialized_typed_data = TypedData::Handle();
   serialized_typed_data ^= reader.ReadObject();
   EXPECT(serialized_typed_data.IsTypedData());
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
   ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
   Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_EQ(Dart_CObject_kTypedData, root->type);
   EXPECT_EQ(kTypedDataLength, root->value.as_typed_data.length);
@@ skipping 11 matching lines @@
     MessageWriter writer(&buffer, &zone_allocator, true);                     \
     const int kArrayLength = 127;                                             \
     TypedData& array = TypedData::Handle(                                     \
         TypedData::New(kTypedData##darttype##ArrayCid, kArrayLength));        \
     intptr_t scale = array.ElementSizeInBytes();                              \
     for (int i = 0; i < kArrayLength; i++) {                                  \
       array.Set##darttype((i * scale), i);                                    \
     }                                                                         \
     writer.WriteMessage(array);                                               \
     intptr_t buffer_len = writer.BytesWritten();                              \
-    SnapshotReader reader(buffer, buffer_len,                                 \
-                          Snapshot::kMessage, Isolate::Current(),             \
+    MessageSnapshotReader reader(buffer, buffer_len,                          \
+                          Isolate::Current(),                                 \
                           zone.GetZone());                                    \
     TypedData& serialized_array = TypedData::Handle();                        \
     serialized_array ^= reader.ReadObject();                                  \
     for (int i = 0; i < kArrayLength; i++) {                                  \
       EXPECT_EQ(static_cast<ctype>(i),                                        \
                 serialized_array.Get##darttype(i*scale));                     \
     }                                                                         \
   }
 
 
 #define TEST_EXTERNAL_TYPED_ARRAY(darttype, ctype)                            \
   {                                                                           \
     StackZone zone(Isolate::Current());                                       \
     ctype data[] = { 0, 11, 22, 33, 44, 55, 66, 77 };                         \
     intptr_t length = ARRAY_SIZE(data);                                       \
     ExternalTypedData& array = ExternalTypedData::Handle(                     \
         ExternalTypedData::New(kExternalTypedData##darttype##ArrayCid,        \
                                reinterpret_cast<uint8_t*>(data), length));    \
     intptr_t scale = array.ElementSizeInBytes();                              \
     uint8_t* buffer;                                                          \
     MessageWriter writer(&buffer, &zone_allocator, true);                     \
     writer.WriteMessage(array);                                               \
     intptr_t buffer_len = writer.BytesWritten();                              \
-    SnapshotReader reader(buffer, buffer_len,                                 \
-                          Snapshot::kMessage, Isolate::Current(),             \
+    MessageSnapshotReader reader(buffer, buffer_len,                          \
+                          Isolate::Current(),                                 \
                           zone.GetZone());                                    \
     TypedData& serialized_array = TypedData::Handle();                        \
     serialized_array ^= reader.ReadObject();                                  \
     for (int i = 0; i < length; i++) {                                        \
       EXPECT_EQ(static_cast<ctype>(data[i]),                                  \
                 serialized_array.Get##darttype(i*scale));                     \
     }                                                                         \
   }
 
 
@@ skipping 31 matching lines @@
   // Write snapshot with object content.
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator, true);
   const int kTypedDataLength = 0;
   TypedData& typed_data = TypedData::Handle(
       TypedData::New(kTypedDataUint8ArrayCid, kTypedDataLength));
   writer.WriteMessage(typed_data);
   intptr_t buffer_len = writer.BytesWritten();
 
   // Read object back from the snapshot.
-  SnapshotReader reader(buffer, buffer_len,
-                        Snapshot::kMessage, Isolate::Current(), zone.GetZone());
+  MessageSnapshotReader reader(buffer,
+                               buffer_len,
+                               Isolate::Current(),
+                               zone.GetZone());
   TypedData& serialized_typed_data = TypedData::Handle();
   serialized_typed_data ^= reader.ReadObject();
   EXPECT(serialized_typed_data.IsTypedData());
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
   ApiMessageReader api_reader(buffer, buffer_len, &zone_allocator);
   Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_EQ(Dart_CObject_kTypedData, root->type);
   EXPECT_EQ(Dart_TypedData_kUint8, root->value.as_typed_data.type);
   EXPECT_EQ(kTypedDataLength, root->value.as_typed_data.length);
   EXPECT(root->value.as_typed_data.values == NULL);
   CheckEncodeDecodeMessage(root);
 }
 
 
 class TestSnapshotWriter : public SnapshotWriter {
  public:
   static const intptr_t kInitialSize = 64 * KB;
   TestSnapshotWriter(uint8_t** buffer, ReAlloc alloc)
-      : SnapshotWriter(Snapshot::kScript, buffer, alloc, kInitialSize, true) {
+      : SnapshotWriter(Snapshot::kScript,
+                       buffer,
+                       alloc,
+                       kInitialSize,
+                       &forward_list_,
+                       true),
+        forward_list_(SnapshotWriter::FirstObjectId()) {
     ASSERT(buffer != NULL);
     ASSERT(alloc != NULL);
   }
   ~TestSnapshotWriter() { }
 
   // Writes just a script object
   void WriteScript(const Script& script) {
     WriteObject(script.raw());
     UnmarkAll();
   }
 
  private:
+  ForwardList forward_list_;
+
   DISALLOW_COPY_AND_ASSIGN(TestSnapshotWriter);
 };
 
 
 static void GenerateSourceAndCheck(const Script& script) {
   // Check if we are able to generate the source from the token stream.
   // Rescan this source and compare the token stream to see if they are
   // the same.
   const TokenStream& expected_tokens = TokenStream::Handle(script.tokens());
   TokenStream::Iterator expected_iterator(
@@ skipping 76 matching lines @@
   Library& lib = Library::Handle(Library::New(lib_url));
   lib.Register();
   EXPECT(CompilerTest::TestCompileScript(lib, script));
 
   // Write snapshot with script content.
   uint8_t* buffer;
   TestSnapshotWriter writer(&buffer, &malloc_allocator);
   writer.WriteScript(script);
 
   // Read object back from the snapshot.
-  SnapshotReader reader(buffer, writer.BytesWritten(),
-                        Snapshot::kScript, Isolate::Current(),
-                        Thread::Current()->zone());
+  ScriptSnapshotReader reader(buffer,
+                              writer.BytesWritten(),
+                              Isolate::Current(),
+                              Thread::Current()->zone());
   Script& serialized_script = Script::Handle();
   serialized_script ^= reader.ReadObject();
 
   // Check if the serialized script object matches the original script.
   String& expected_literal = String::Handle();
   String& actual_literal = String::Handle();
   String& str = String::Handle();
   str ^= serialized_script.url();
   EXPECT(url.Equals(str));
 
@@ skipping 77 matching lines @@
       "class FieldsTest {\n"
       "  static Fields testMain() {\n"
       "    Expect.equals(true, Fields.bigint_sfld == 0xfffffffffff);\n"
       "    Fields obj = new Fields(10, 20);\n"
       "    Expect.equals(true, obj.bigint_fld == 0xfffffffffff);\n"
       "    return obj;\n"
       "  }\n"
       "}\n";
   Dart_Handle result;
 
-  uint8_t* vm_isolate_snapshot_buffer;
   uint8_t* isolate_snapshot_buffer;
 
   // Start an Isolate, load a script and create a full snapshot.
   Timer timer1(true, "Snapshot_test");
   timer1.Start();
   {
     TestIsolateScope __test_isolate__;
 
     Isolate* isolate = Isolate::Current();
     StackZone zone(isolate);
     HandleScope scope(isolate);
 
     // Create a test library and Load up a test script in it.
     TestCase::LoadTestScript(kScriptChars, NULL);
     EXPECT_VALID(Api::CheckAndFinalizePendingClasses(isolate));
     timer1.Stop();
     OS::PrintErr("Without Snapshot: %" Pd64 "us\n", timer1.TotalElapsedTime());
 
     // Write snapshot with object content.
-    FullSnapshotWriter writer(&vm_isolate_snapshot_buffer,
+    FullSnapshotWriter writer(NULL,
                               &isolate_snapshot_buffer,
                               &malloc_allocator);
     writer.WriteFullSnapshot();
   }
 
   // Now Create another isolate using the snapshot and execute a method
   // from the script.
   Timer timer2(true, "Snapshot_test");
   timer2.Start();
   TestCase::CreateTestIsolateFromSnapshot(isolate_snapshot_buffer);
@@ skipping 16 matching lines @@
 
 UNIT_TEST_CASE(FullSnapshot1) {
   // This buffer has to be static for this to compile with Visual Studio.
   // If it is not static compilation of this file with Visual Studio takes
   // more than 30 minutes!
   static const char kFullSnapshotScriptChars[] = {
 #include "snapshot_test.dat"
   };
   const char* kScriptChars = kFullSnapshotScriptChars;
 
-  uint8_t* vm_isolate_snapshot_buffer;
   uint8_t* isolate_snapshot_buffer;
 
   // Start an Isolate, load a script and create a full snapshot.
   Timer timer1(true, "Snapshot_test");
   timer1.Start();
   {
     TestIsolateScope __test_isolate__;
 
     Isolate* isolate = Isolate::Current();
     StackZone zone(isolate);
     HandleScope scope(isolate);
 
     // Create a test library and Load up a test script in it.
     Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
     EXPECT_VALID(Api::CheckAndFinalizePendingClasses(isolate));
     timer1.Stop();
     OS::PrintErr("Without Snapshot: %" Pd64 "us\n", timer1.TotalElapsedTime());
 
     // Write snapshot with object content.
-    FullSnapshotWriter writer(&vm_isolate_snapshot_buffer,
+    FullSnapshotWriter writer(NULL,
                               &isolate_snapshot_buffer,
                               &malloc_allocator);
     writer.WriteFullSnapshot();
 
     // Invoke a function which returns an object.
     Dart_Handle cls = Dart_GetClass(lib, NewString("FieldsTest"));
     Dart_Handle result = Dart_Invoke(cls, NewString("testMain"), 0, NULL);
     EXPECT_VALID(result);
   }
 
@@ skipping 62 matching lines @@
       "    if (Fields.fld4 != 10) {"
       "      throw new Exception('Fields.fld4 needs to be 10');"
       "    }"
       "    return obj;"
       "  }"
       "}";
   Dart_Handle result;
 
   uint8_t* buffer;
   intptr_t size;
-  uint8_t* vm_isolate_snapshot = NULL;
   intptr_t vm_isolate_snapshot_size;
   uint8_t* isolate_snapshot = NULL;
   intptr_t isolate_snapshot_size;
   uint8_t* full_snapshot = NULL;
   uint8_t* script_snapshot = NULL;
   intptr_t expected_num_libs;
   intptr_t actual_num_libs;
 
   {
     // Start an Isolate, and create a full snapshot of it.
     TestIsolateScope __test_isolate__;
     Dart_EnterScope();  // Start a Dart API scope for invoking API functions.
 
     // Write out the script snapshot.
-    result = Dart_CreateSnapshot(&vm_isolate_snapshot,
+    result = Dart_CreateSnapshot(NULL,
                                  &vm_isolate_snapshot_size,
                                  &isolate_snapshot,
                                  &isolate_snapshot_size);
     EXPECT_VALID(result);
     full_snapshot = reinterpret_cast<uint8_t*>(malloc(isolate_snapshot_size));
     memmove(full_snapshot, isolate_snapshot, isolate_snapshot_size);
     Dart_ExitScope();
   }
 
   {
@@ skipping 63 matching lines @@
 UNIT_TEST_CASE(ScriptSnapshot1) {
   const char* kScriptChars =
     "class _SimpleNumEnumerable<T extends num> {"
       "final Iterable<T> _source;"
       "const _SimpleNumEnumerable(this._source) : super();"
     "}";
 
   Dart_Handle result;
   uint8_t* buffer;
   intptr_t size;
-  uint8_t* vm_isolate_snapshot = NULL;
   intptr_t vm_isolate_snapshot_size;
   uint8_t* isolate_snapshot = NULL;
   intptr_t isolate_snapshot_size;
   uint8_t* full_snapshot = NULL;
   uint8_t* script_snapshot = NULL;
 
   {
     // Start an Isolate, and create a full snapshot of it.
     TestIsolateScope __test_isolate__;
     Dart_EnterScope();  // Start a Dart API scope for invoking API functions.
 
     // Write out the script snapshot.
-    result = Dart_CreateSnapshot(&vm_isolate_snapshot,
+    result = Dart_CreateSnapshot(NULL,
                                  &vm_isolate_snapshot_size,
                                  &isolate_snapshot,
                                  &isolate_snapshot_size);
     EXPECT_VALID(result);
     full_snapshot = reinterpret_cast<uint8_t*>(malloc(isolate_snapshot_size));
     memmove(full_snapshot, isolate_snapshot, isolate_snapshot_size);
     Dart_ExitScope();
   }
 
   {
@@ skipping 50 matching lines @@
       "test_i() {"
       "  i;"
       "}"
       "test_b() {"
       "  b = 0;"
       "}";
   Dart_Handle result;
 
   uint8_t* buffer;
   intptr_t size;
-  uint8_t* vm_isolate_snapshot = NULL;
   intptr_t vm_isolate_snapshot_size;
   uint8_t* isolate_snapshot = NULL;
   intptr_t isolate_snapshot_size;
   uint8_t* full_snapshot = NULL;
   uint8_t* script_snapshot = NULL;
 
   // Force creation of snapshot in production mode.
   bool saved_mode = FLAG_enable_type_checks;
   FLAG_enable_type_checks = false;
 
   {
     // Start an Isolate, and create a full snapshot of it.
     TestIsolateScope __test_isolate__;
     Dart_EnterScope();  // Start a Dart API scope for invoking API functions.
 
     // Write out the script snapshot.
-    result = Dart_CreateSnapshot(&vm_isolate_snapshot,
+    result = Dart_CreateSnapshot(NULL,
                                  &vm_isolate_snapshot_size,
                                  &isolate_snapshot,
                                  &isolate_snapshot_size);
     EXPECT_VALID(result);
     full_snapshot = reinterpret_cast<uint8_t*>(malloc(isolate_snapshot_size));
     memmove(full_snapshot, isolate_snapshot, isolate_snapshot_size);
     Dart_ExitScope();
   }
 
   {
@@ skipping 62 matching lines @@
   uint8_t* buffer = NULL;
   ApiMessageWriter writer(&buffer, &zone_allocator);
 
   static const int kArrayLength = 2;
   intptr_t data[kArrayLength] = {1, 2};
   int len = kArrayLength;
   writer.WriteMessage(len, data);
 
   // Read object back from the snapshot into a C structure.
   ApiNativeScope scope;
-  ApiMessageReader api_reader(buffer, writer.BytesWritten(), &zone_allocator);
+  ApiMessageReader api_reader(buffer,
+                              writer.BytesWritten(),
+                              &zone_allocator,
+                              false);
   Dart_CObject* root = api_reader.ReadMessage();
   EXPECT_EQ(Dart_CObject_kArray, root->type);
   EXPECT_EQ(kArrayLength, root->value.as_array.length);
   for (int i = 0; i < kArrayLength; i++) {
     Dart_CObject* element = root->value.as_array.values[i];
     EXPECT_EQ(Dart_CObject_kInt32, element->type);
     EXPECT_EQ(i + 1, element->value.as_int32);
   }
   CheckEncodeDecodeMessage(root);
 }
@@ skipping 1272 matching lines @@
   StackZone zone(Isolate::Current());
   uint8_t* buffer;
   MessageWriter writer(&buffer, &zone_allocator, true);
   writer.WriteInlinedObjectHeader(kOmittedObjectId);
   // For performance, we'd like single-byte headers when ids are omitted.
   // If this starts failing, consider renumbering the snapshot ids.
   EXPECT_EQ(1, writer.BytesWritten());
 }
 
 }  // namespace dart