Snapshots: Add --extra-code flag to mksnapshot which lets you specify a file

test/cctest/test-serialize.cc

 // Copyright 2007-2010 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 232 matching lines @@
   // will clear the pending fixups array, which would otherwise contain GC roots
   // that would confuse the serialization/deserialization process.
   v8::Persistent<v8::Context> env = v8::Context::New();
   env.Dispose();
   WriteToFile(FLAG_testing_serialization_file);
 }
 
 
 // Test that the whole heap can be serialized.
 TEST(Serialize) {
-  Serializer::Enable();
-  v8::V8::Initialize();
-  Serialize();
+  if (!Snapshot::HaveASnapshotToStartFrom()) {
+    Serializer::Enable();
+    v8::V8::Initialize();
+    Serialize();
+  }
 }
 
 
 // Test that heap serialization is non-destructive.
 TEST(SerializeTwice) {
-  Serializer::Enable();
-  v8::V8::Initialize();
-  Serialize();
-  Serialize();
+  if (!Snapshot::HaveASnapshotToStartFrom()) {
+    Serializer::Enable();
+    v8::V8::Initialize();
+    Serialize();
+    Serialize();
+  }
 }
 
 
 //----------------------------------------------------------------------------
 // Tests that the heap can be deserialized.
 
 static void Deserialize() {
   CHECK(Snapshot::Initialize(FLAG_testing_serialization_file));
 }
 
 
 static void SanityCheck() {
   v8::HandleScope scope;
 #ifdef DEBUG
   HEAP->Verify();
 #endif
   CHECK(Isolate::Current()->global()->IsJSObject());
   CHECK(Isolate::Current()->global_context()->IsContext());
   CHECK(HEAP->symbol_table()->IsSymbolTable());
   CHECK(!FACTORY->LookupAsciiSymbol("Empty")->IsFailure());
 }
 
 
 DEPENDENT_TEST(Deserialize, Serialize) {
   // The serialize-deserialize tests only work if the VM is built without
   // serialization.  That doesn't matter.  We don't need to be able to
   // serialize a snapshot in a VM that is booted from a snapshot.
-  if (!Snapshot::IsEnabled()) {
+  if (!Snapshot::HaveASnapshotToStartFrom()) {
     v8::HandleScope scope;
     Deserialize();
 
     v8::Persistent<v8::Context> env = v8::Context::New();
     env->Enter();
 
     SanityCheck();
   }
 }
 
 
 DEPENDENT_TEST(DeserializeFromSecondSerialization, SerializeTwice) {
-  if (!Snapshot::IsEnabled()) {
+  if (!Snapshot::HaveASnapshotToStartFrom()) {
     v8::HandleScope scope;
     Deserialize();
 
     v8::Persistent<v8::Context> env = v8::Context::New();
     env->Enter();
 
     SanityCheck();
   }
 }
 
 
 DEPENDENT_TEST(DeserializeAndRunScript2, Serialize) {
-  if (!Snapshot::IsEnabled()) {
+  if (!Snapshot::HaveASnapshotToStartFrom()) {
     v8::HandleScope scope;
     Deserialize();
 
     v8::Persistent<v8::Context> env = v8::Context::New();
     env->Enter();
 
     const char* c_source = "\"1234\".length";
     v8::Local<v8::String> source = v8::String::New(c_source);
     v8::Local<v8::Script> script = v8::Script::Compile(source);
     CHECK_EQ(4, script->Run()->Int32Value());
   }
 }
 
 
 DEPENDENT_TEST(DeserializeFromSecondSerializationAndRunScript2,
                SerializeTwice) {
-  if (!Snapshot::IsEnabled()) {
+  if (!Snapshot::HaveASnapshotToStartFrom()) {
     v8::HandleScope scope;
     Deserialize();
 
     v8::Persistent<v8::Context> env = v8::Context::New();
     env->Enter();
 
     const char* c_source = "\"1234\".length";
     v8::Local<v8::String> source = v8::String::New(c_source);
     v8::Local<v8::Script> script = v8::Script::Compile(source);
     CHECK_EQ(4, script->Run()->Int32Value());
   }
 }
 
 
 TEST(PartialSerialization) {
-  Serializer::Enable();
-  v8::V8::Initialize();
+  if (!Snapshot::HaveASnapshotToStartFrom()) {
+    Serializer::Enable();
+    v8::V8::Initialize();
 
-  v8::Persistent<v8::Context> env = v8::Context::New();
-  ASSERT(!env.IsEmpty());
-  env->Enter();
-  // Make sure all builtin scripts are cached.
-  { HandleScope scope;
-    for (int i = 0; i < Natives::GetBuiltinsCount(); i++) {
-      Isolate::Current()->bootstrapper()->NativesSourceLookup(i);
+    v8::Persistent<v8::Context> env = v8::Context::New();
+    ASSERT(!env.IsEmpty());
+    env->Enter();
+    // Make sure all builtin scripts are cached.
+    { HandleScope scope;
+      for (int i = 0; i < Natives::GetBuiltinsCount(); i++) {
+        Isolate::Current()->bootstrapper()->NativesSourceLookup(i);
+      }
     }
+    HEAP->CollectAllGarbage(Heap::kNoGCFlags);
+    HEAP->CollectAllGarbage(Heap::kNoGCFlags);
+
+    Object* raw_foo;
+    {
+      v8::HandleScope handle_scope;
+      v8::Local<v8::String> foo = v8::String::New("foo");
+      ASSERT(!foo.IsEmpty());
+      raw_foo = *(v8::Utils::OpenHandle(*foo));
+    }
+
+    int file_name_length = StrLength(FLAG_testing_serialization_file) + 10;
+    Vector<char> startup_name = Vector<char>::New(file_name_length + 1);
+    OS::SNPrintF(startup_name, "%s.startup", FLAG_testing_serialization_file);
+
+    env->Exit();
+    env.Dispose();
+
+    FileByteSink startup_sink(startup_name.start());
+    startup_name.Dispose();
+    StartupSerializer startup_serializer(&startup_sink);
+    startup_serializer.SerializeStrongReferences();
+
+    FileByteSink partial_sink(FLAG_testing_serialization_file);
+    PartialSerializer p_ser(&startup_serializer, &partial_sink);
+    p_ser.Serialize(&raw_foo);
+    startup_serializer.SerializeWeakReferences();
+    partial_sink.WriteSpaceUsed(
+        p_ser.CurrentAllocationAddress(NEW_SPACE),
+        p_ser.CurrentAllocationAddress(OLD_POINTER_SPACE),
+        p_ser.CurrentAllocationAddress(OLD_DATA_SPACE),
+        p_ser.CurrentAllocationAddress(CODE_SPACE),
+        p_ser.CurrentAllocationAddress(MAP_SPACE),
+        p_ser.CurrentAllocationAddress(CELL_SPACE),
+        p_ser.CurrentAllocationAddress(LO_SPACE));
   }
-  HEAP->CollectAllGarbage(Heap::kNoGCFlags);
-  HEAP->CollectAllGarbage(Heap::kNoGCFlags);
-
-  Object* raw_foo;
-  {
-    v8::HandleScope handle_scope;
-    v8::Local<v8::String> foo = v8::String::New("foo");
-    ASSERT(!foo.IsEmpty());
-    raw_foo = *(v8::Utils::OpenHandle(*foo));
-  }
-
-  int file_name_length = StrLength(FLAG_testing_serialization_file) + 10;
-  Vector<char> startup_name = Vector<char>::New(file_name_length + 1);
-  OS::SNPrintF(startup_name, "%s.startup", FLAG_testing_serialization_file);
-
-  env->Exit();
-  env.Dispose();
-
-  FileByteSink startup_sink(startup_name.start());
-  startup_name.Dispose();
-  StartupSerializer startup_serializer(&startup_sink);
-  startup_serializer.SerializeStrongReferences();
-
-  FileByteSink partial_sink(FLAG_testing_serialization_file);
-  PartialSerializer p_ser(&startup_serializer, &partial_sink);
-  p_ser.Serialize(&raw_foo);
-  startup_serializer.SerializeWeakReferences();
-  partial_sink.WriteSpaceUsed(p_ser.CurrentAllocationAddress(NEW_SPACE),
-                              p_ser.CurrentAllocationAddress(OLD_POINTER_SPACE),
-                              p_ser.CurrentAllocationAddress(OLD_DATA_SPACE),
-                              p_ser.CurrentAllocationAddress(CODE_SPACE),
-                              p_ser.CurrentAllocationAddress(MAP_SPACE),
-                              p_ser.CurrentAllocationAddress(CELL_SPACE),
-                              p_ser.CurrentAllocationAddress(LO_SPACE));
 }
 
 
 static void ReserveSpaceForPartialSnapshot(const char* file_name) {
   int file_name_length = StrLength(file_name) + 10;
   Vector<char> name = Vector<char>::New(file_name_length + 1);
   OS::SNPrintF(name, "%s.size", file_name);
   FILE* fp = OS::FOpen(name.start(), "r");
   name.Dispose();
   int new_size, pointer_size, data_size, code_size, map_size, cell_size;
@@ skipping 57 matching lines @@
       Deserializer deserializer(&source);
       deserializer.DeserializePartial(&root2);
       CHECK(root2->IsString());
       CHECK(*root_handle == root2);
     }
   }
 }
 
 
 TEST(ContextSerialization) {
-  Serializer::Enable();
-  v8::V8::Initialize();
+  if (!Snapshot::HaveASnapshotToStartFrom()) {
+    Serializer::Enable();
+    v8::V8::Initialize();
 
-  v8::Persistent<v8::Context> env = v8::Context::New();
-  ASSERT(!env.IsEmpty());
-  env->Enter();
-  // Make sure all builtin scripts are cached.
-  { HandleScope scope;
-    for (int i = 0; i < Natives::GetBuiltinsCount(); i++) {
-      Isolate::Current()->bootstrapper()->NativesSourceLookup(i);
+    v8::Persistent<v8::Context> env = v8::Context::New();
+    ASSERT(!env.IsEmpty());
+    env->Enter();
+    // Make sure all builtin scripts are cached.
+    { HandleScope scope;
+      for (int i = 0; i < Natives::GetBuiltinsCount(); i++) {
+        Isolate::Current()->bootstrapper()->NativesSourceLookup(i);
+      }
     }
+    // If we don't do this then we end up with a stray root pointing at the
+    // context even after we have disposed of env.
+    HEAP->CollectAllGarbage(Heap::kNoGCFlags);
+
+    int file_name_length = StrLength(FLAG_testing_serialization_file) + 10;
+    Vector<char> startup_name = Vector<char>::New(file_name_length + 1);
+    OS::SNPrintF(startup_name, "%s.startup", FLAG_testing_serialization_file);
+
+    env->Exit();
+
+    Object* raw_context = *(v8::Utils::OpenHandle(*env));
+
+    env.Dispose();
+
+    FileByteSink startup_sink(startup_name.start());
+    startup_name.Dispose();
+    StartupSerializer startup_serializer(&startup_sink);
+    startup_serializer.SerializeStrongReferences();
+
+    FileByteSink partial_sink(FLAG_testing_serialization_file);
+    PartialSerializer p_ser(&startup_serializer, &partial_sink);
+    p_ser.Serialize(&raw_context);
+    startup_serializer.SerializeWeakReferences();
+    partial_sink.WriteSpaceUsed(
+        p_ser.CurrentAllocationAddress(NEW_SPACE),
+        p_ser.CurrentAllocationAddress(OLD_POINTER_SPACE),
+        p_ser.CurrentAllocationAddress(OLD_DATA_SPACE),
+        p_ser.CurrentAllocationAddress(CODE_SPACE),
+        p_ser.CurrentAllocationAddress(MAP_SPACE),
+        p_ser.CurrentAllocationAddress(CELL_SPACE),
+        p_ser.CurrentAllocationAddress(LO_SPACE));
   }
-  // If we don't do this then we end up with a stray root pointing at the
-  // context even after we have disposed of env.
-  HEAP->CollectAllGarbage(Heap::kNoGCFlags);
-
-  int file_name_length = StrLength(FLAG_testing_serialization_file) + 10;
-  Vector<char> startup_name = Vector<char>::New(file_name_length + 1);
-  OS::SNPrintF(startup_name, "%s.startup", FLAG_testing_serialization_file);
-
-  env->Exit();
-
-  Object* raw_context = *(v8::Utils::OpenHandle(*env));
-
-  env.Dispose();
-
-  FileByteSink startup_sink(startup_name.start());
-  startup_name.Dispose();
-  StartupSerializer startup_serializer(&startup_sink);
-  startup_serializer.SerializeStrongReferences();
-
-  FileByteSink partial_sink(FLAG_testing_serialization_file);
-  PartialSerializer p_ser(&startup_serializer, &partial_sink);
-  p_ser.Serialize(&raw_context);
-  startup_serializer.SerializeWeakReferences();
-  partial_sink.WriteSpaceUsed(p_ser.CurrentAllocationAddress(NEW_SPACE),
-                              p_ser.CurrentAllocationAddress(OLD_POINTER_SPACE),
-                              p_ser.CurrentAllocationAddress(OLD_DATA_SPACE),
-                              p_ser.CurrentAllocationAddress(CODE_SPACE),
-                              p_ser.CurrentAllocationAddress(MAP_SPACE),
-                              p_ser.CurrentAllocationAddress(CELL_SPACE),
-                              p_ser.CurrentAllocationAddress(LO_SPACE));
 }
 
 
 DEPENDENT_TEST(ContextDeserialization, ContextSerialization) {
-  if (!Snapshot::IsEnabled()) {
+  if (!Snapshot::HaveASnapshotToStartFrom()) {
     int file_name_length = StrLength(FLAG_testing_serialization_file) + 10;
     Vector<char> startup_name = Vector<char>::New(file_name_length + 1);
     OS::SNPrintF(startup_name, "%s.startup", FLAG_testing_serialization_file);
 
     CHECK(Snapshot::Initialize(startup_name.start()));
     startup_name.Dispose();
 
     const char* file_name = FLAG_testing_serialization_file;
     ReserveSpaceForPartialSnapshot(file_name);
 
@@ skipping 144 matching lines @@
 TEST(TestThatAlwaysFails) {
   bool ArtificialFailure = false;
   CHECK(ArtificialFailure);
 }
 
 
 DEPENDENT_TEST(DependentTestThatAlwaysFails, TestThatAlwaysSucceeds) {
   bool ArtificialFailure2 = false;
   CHECK(ArtificialFailure2);
 }