Disable turbofan for serializer tests.

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 33 matching lines @@
 #include "test/cctest/cctest.h"
 
 using namespace v8::internal;
 
 
 bool DefaultSnapshotAvailable() {
   return i::Snapshot::DefaultSnapshotBlob() != NULL;
 }
 
 
+void DisableTurbofan() {
+  const char* flag = "--turbo-filter=\"\"";
+  FlagList::SetFlagsFromString(flag, StrLength(flag));
+}
+
+
 // TestIsolate is used for testing isolate serialization.
 class TestIsolate : public Isolate {
  public:
   static v8::Isolate* NewInitialized(bool enable_serializer) {
     i::Isolate* isolate = new TestIsolate(enable_serializer);
     v8::Isolate* v8_isolate = reinterpret_cast<v8::Isolate*>(isolate);
     v8::Isolate::Scope isolate_scope(v8_isolate);
     isolate->Init(NULL);
     return v8_isolate;
   }
@@ skipping 123 matching lines @@
   }
   CopyChars(source + head.length() + repeats * body.length(), tail.start(),
             tail.length());
   return Vector<const uint8_t>(const_cast<const uint8_t*>(source),
                                source_length);
 }
 
 
 // Test that the whole heap can be serialized.
 UNINITIALIZED_TEST(Serialize) {
+  DisableTurbofan();
   if (DefaultSnapshotAvailable()) return;
   v8::Isolate* isolate = TestIsolate::NewInitialized(true);
   Serialize(isolate);
 }
 
 
 // Test that heap serialization is non-destructive.
 UNINITIALIZED_TEST(SerializeTwice) {
+  DisableTurbofan();
   if (DefaultSnapshotAvailable()) return;
   v8::Isolate* isolate = TestIsolate::NewInitialized(true);
   Serialize(isolate);
   Serialize(isolate);
 }
 
 
 //----------------------------------------------------------------------------
 // Tests that the heap can be deserialized.
 
@@ skipping 32 matching lines @@
   CHECK(isolate->native_context()->IsContext());
   CHECK(isolate->heap()->string_table()->IsStringTable());
   isolate->factory()->InternalizeOneByteString(STATIC_CHAR_VECTOR("Empty"));
 }
 
 
 UNINITIALIZED_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.
+  DisableTurbofan();
   if (DefaultSnapshotAvailable()) return;
   v8::Isolate* isolate = Deserialize();
   {
     v8::HandleScope handle_scope(isolate);
     v8::Isolate::Scope isolate_scope(isolate);
 
     v8::Local<v8::Context> env = v8::Context::New(isolate);
     env->Enter();
 
     SanityCheck(isolate);
   }
   isolate->Dispose();
 }
 
 
 UNINITIALIZED_DEPENDENT_TEST(DeserializeFromSecondSerialization,
                              SerializeTwice) {
+  DisableTurbofan();
   if (DefaultSnapshotAvailable()) return;
   v8::Isolate* isolate = Deserialize();
   {
     v8::Isolate::Scope isolate_scope(isolate);
     v8::HandleScope handle_scope(isolate);
 
     v8::Local<v8::Context> env = v8::Context::New(isolate);
     env->Enter();
 
     SanityCheck(isolate);
   }
   isolate->Dispose();
 }
 
 
 UNINITIALIZED_DEPENDENT_TEST(DeserializeAndRunScript2, Serialize) {
+  DisableTurbofan();
   if (DefaultSnapshotAvailable()) return;
   v8::Isolate* isolate = Deserialize();
   {
     v8::Isolate::Scope isolate_scope(isolate);
     v8::HandleScope handle_scope(isolate);
 
 
     v8::Local<v8::Context> env = v8::Context::New(isolate);
     env->Enter();
 
     const char* c_source = "\"1234\".length";
     v8::Local<v8::String> source = v8::String::NewFromUtf8(isolate, c_source);
     v8::Local<v8::Script> script = v8::Script::Compile(source);
     CHECK_EQ(4, script->Run()->Int32Value());
   }
   isolate->Dispose();
 }
 
 
 UNINITIALIZED_DEPENDENT_TEST(DeserializeFromSecondSerializationAndRunScript2,
                              SerializeTwice) {
+  DisableTurbofan();
   if (DefaultSnapshotAvailable()) return;
   v8::Isolate* isolate = Deserialize();
   {
     v8::Isolate::Scope isolate_scope(isolate);
     v8::HandleScope handle_scope(isolate);
 
     v8::Local<v8::Context> env = v8::Context::New(isolate);
     env->Enter();
 
     const char* c_source = "\"1234\".length";
     v8::Local<v8::String> source = v8::String::NewFromUtf8(isolate, c_source);
     v8::Local<v8::Script> script = v8::Script::Compile(source);
     CHECK_EQ(4, script->Run()->Int32Value());
   }
   isolate->Dispose();
 }
 
 
 UNINITIALIZED_TEST(PartialSerialization) {
+  DisableTurbofan();
   if (DefaultSnapshotAvailable()) return;
   v8::Isolate* v8_isolate = TestIsolate::NewInitialized(true);
   Isolate* isolate = reinterpret_cast<Isolate*>(v8_isolate);
   v8_isolate->Enter();
   {
     Heap* heap = isolate->heap();
 
     v8::Persistent<v8::Context> env;
     {
       HandleScope scope(isolate);
@@ skipping 50 matching lines @@
     WritePayload(startup_snapshot.RawData(), startup_name.start());
 
     startup_name.Dispose();
   }
   v8_isolate->Exit();
   v8_isolate->Dispose();
 }
 
 
 UNINITIALIZED_DEPENDENT_TEST(PartialDeserialization, PartialSerialization) {
+  DisableTurbofan();
   if (DefaultSnapshotAvailable()) return;
   int file_name_length = StrLength(FLAG_testing_serialization_file) + 10;
   Vector<char> startup_name = Vector<char>::New(file_name_length + 1);
   SNPrintF(startup_name, "%s.startup", FLAG_testing_serialization_file);
 
   v8::Isolate* v8_isolate = InitializeFromFile(startup_name.start());
   CHECK(v8_isolate);
   startup_name.Dispose();
   {
     v8::Isolate::Scope isolate_scope(v8_isolate);
@@ skipping 31 matching lines @@
       CHECK(root.is_identical_to(root2));
     }
 
     DeleteArray(snapshot);
   }
   v8_isolate->Dispose();
 }
 
 
 UNINITIALIZED_TEST(ContextSerialization) {
+  DisableTurbofan();
   if (DefaultSnapshotAvailable()) return;
   v8::Isolate* v8_isolate = TestIsolate::NewInitialized(true);
   Isolate* isolate = reinterpret_cast<Isolate*>(v8_isolate);
   Heap* heap = isolate->heap();
   {
     v8::Isolate::Scope isolate_scope(v8_isolate);
 
     v8::Persistent<v8::Context> env;
     {
       HandleScope scope(isolate);
@@ skipping 44 matching lines @@
     WritePayload(partial_snapshot.RawData(), FLAG_testing_serialization_file);
     WritePayload(startup_snapshot.RawData(), startup_name.start());
 
     startup_name.Dispose();
   }
   v8_isolate->Dispose();
 }
 
 
 UNINITIALIZED_DEPENDENT_TEST(ContextDeserialization, ContextSerialization) {
+  DisableTurbofan();
   if (DefaultSnapshotAvailable()) return;
   int file_name_length = StrLength(FLAG_testing_serialization_file) + 10;
   Vector<char> startup_name = Vector<char>::New(file_name_length + 1);
   SNPrintF(startup_name, "%s.startup", FLAG_testing_serialization_file);
 
   v8::Isolate* v8_isolate = InitializeFromFile(startup_name.start());
   CHECK(v8_isolate);
   startup_name.Dispose();
   {
     v8::Isolate::Scope isolate_scope(v8_isolate);
@@ skipping 30 matching lines @@
       CHECK(root2->IsContext());
       CHECK(!root.is_identical_to(root2));
     }
     DeleteArray(snapshot);
   }
   v8_isolate->Dispose();
 }
 
 
 UNINITIALIZED_TEST(CustomContextSerialization) {
+  DisableTurbofan();
   if (DefaultSnapshotAvailable()) return;
   v8::Isolate* v8_isolate = TestIsolate::NewInitialized(true);
   Isolate* isolate = reinterpret_cast<Isolate*>(v8_isolate);
   {
     v8::Isolate::Scope isolate_scope(v8_isolate);
 
     v8::Persistent<v8::Context> env;
     {
       HandleScope scope(isolate);
       env.Reset(v8_isolate, v8::Context::New(v8_isolate));
@@ skipping 64 matching lines @@
     WritePayload(startup_snapshot.RawData(), startup_name.start());
 
     startup_name.Dispose();
   }
   v8_isolate->Dispose();
 }
 
 
 UNINITIALIZED_DEPENDENT_TEST(CustomContextDeserialization,
                              CustomContextSerialization) {
+  DisableTurbofan();
   FLAG_crankshaft = false;
   if (DefaultSnapshotAvailable()) return;
   int file_name_length = StrLength(FLAG_testing_serialization_file) + 10;
   Vector<char> startup_name = Vector<char>::New(file_name_length + 1);
   SNPrintF(startup_name, "%s.startup", FLAG_testing_serialization_file);
 
   v8::Isolate* v8_isolate = InitializeFromFile(startup_name.start());
   CHECK(v8_isolate);
   startup_name.Dispose();
   {
@@ skipping 40 matching lines @@
       int b = CompileRun("b.length")->ToNumber(v8_isolate)->Int32Value();
       CHECK_EQ(100002, b);
     }
     DeleteArray(snapshot);
   }
   v8_isolate->Dispose();
 }
 
 
 TEST(PerIsolateSnapshotBlobs) {
-  const char* flag = "--turbo-filter=\"\"";
-  FlagList::SetFlagsFromString(flag, StrLength(flag));
-
+  DisableTurbofan();
   const char* source1 = "function f() { return 42; }";
   const char* source2 =
       "function f() { return g() * 2; }"
       "function g() { return 43; }"
       "/./.test('a')";
 
   v8::StartupData data1 = v8::V8::CreateSnapshotDataBlob(source1);
   v8::StartupData data2 = v8::V8::CreateSnapshotDataBlob(source2);
 
   v8::Isolate::CreateParams params1;
@@ skipping 20 matching lines @@
     delete[] data2.data;  // We can dispose of the snapshot blob now.
     v8::Context::Scope c_scope(context);
     CHECK_EQ(86, CompileRun("f()")->ToInt32(isolate2)->Int32Value());
     CHECK_EQ(43, CompileRun("g()")->ToInt32(isolate2)->Int32Value());
   }
   isolate2->Dispose();
 }
 
 
 TEST(PerIsolateSnapshotBlobsWithLocker) {
+  DisableTurbofan();
   v8::Isolate* isolate0 = v8::Isolate::New();
   {
     v8::Locker locker(isolate0);
     v8::Isolate::Scope i_scope(isolate0);
     v8::HandleScope h_scope(isolate0);
     v8::Local<v8::Context> context = v8::Context::New(isolate0);
     v8::Context::Scope c_scope(context);
     CHECK_EQ(1, CompileRun("Math.cos(0)")->ToInt32(isolate0)->Int32Value());
   }
   isolate0->Dispose();
@@ skipping 779 matching lines @@
     v8::Local<v8::Context> context = v8::Context::New(isolate);
     delete[] data.data;  // We can dispose of the snapshot blob now.
     v8::Context::Scope c_scope(context);
     v8::Handle<v8::Function> foo =
         v8::Handle<v8::Function>::Cast(CompileRun("foo"));
     CHECK(v8::Utils::OpenHandle(*foo)->code()->is_turbofanned());
     CHECK_EQ(3, CompileRun("foo(4)")->ToInt32(isolate)->Int32Value());
   }
   isolate->Dispose();
 }