[test] no longer 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 32 matching lines @@
 #include "src/snapshot/deserializer.h"
 #include "src/snapshot/natives.h"
 #include "src/snapshot/partial-serializer.h"
 #include "src/snapshot/snapshot.h"
 #include "src/snapshot/startup-serializer.h"
 #include "test/cctest/cctest.h"
 #include "test/cctest/heap/heap-utils.h"
 
 using namespace v8::internal;
 
-void DisableTurbofan() {
-  const char* flag = "--turbo-filter=\"\"";
-  FlagList::SetFlagsFromString(flag, StrLength(flag));
+void DisableAlwaysOpt() {
+  // Isolates prepared for serialization do not optimize. The only exception is
+  // with the flag --always-opt.
+  FLAG_always_opt = false;
 }
 
 
 // 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);
@@ skipping 77 matching lines @@
 #ifdef VERIFY_HEAP
   isolate->heap()->Verify();
 #endif
   CHECK(isolate->global_object()->IsJSObject());
   CHECK(isolate->native_context()->IsContext());
   CHECK(isolate->heap()->string_table()->IsStringTable());
   isolate->factory()->InternalizeOneByteString(STATIC_CHAR_VECTOR("Empty"));
 }
 
 UNINITIALIZED_TEST(StartupSerializerOnce) {
-  // 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();
+  DisableAlwaysOpt();
   v8::Isolate* isolate = TestIsolate::NewInitialized(true);
   Vector<const byte> blob = Serialize(isolate);
   isolate = Deserialize(blob);
   blob.Dispose();
   {
     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_TEST(StartupSerializerTwice) {
-  DisableTurbofan();
+  DisableAlwaysOpt();
   v8::Isolate* isolate = TestIsolate::NewInitialized(true);
   Vector<const byte> blob1 = Serialize(isolate);
   Vector<const byte> blob2 = Serialize(isolate);
   blob1.Dispose();
   isolate = Deserialize(blob2);
   blob2.Dispose();
   {
     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_TEST(StartupSerializerOnceRunScript) {
-  DisableTurbofan();
+  DisableAlwaysOpt();
   v8::Isolate* isolate = TestIsolate::NewInitialized(true);
   Vector<const byte> blob = Serialize(isolate);
   isolate = Deserialize(blob);
   blob.Dispose();
   {
     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::Script> script = v8_compile(c_source);
     v8::Maybe<int32_t> result = script->Run(isolate->GetCurrentContext())
                                     .ToLocalChecked()
                                     ->Int32Value(isolate->GetCurrentContext());
     CHECK_EQ(4, result.FromJust());
   }
   isolate->Dispose();
 }
 
 UNINITIALIZED_TEST(StartupSerializerTwiceRunScript) {
-  DisableTurbofan();
+  DisableAlwaysOpt();
   v8::Isolate* isolate = TestIsolate::NewInitialized(true);
   Vector<const byte> blob1 = Serialize(isolate);
   Vector<const byte> blob2 = Serialize(isolate);
   blob1.Dispose();
   isolate = Deserialize(blob2);
   blob2.Dispose();
   {
     v8::Isolate::Scope isolate_scope(isolate);
     v8::HandleScope handle_scope(isolate);
 
@@ skipping 67 matching lines @@
     SnapshotData partial_snapshot(&partial_serializer);
 
     *partial_blob_out = WritePayload(partial_snapshot.RawData());
     *startup_blob_out = WritePayload(startup_snapshot.RawData());
   }
   v8_isolate->Exit();
   v8_isolate->Dispose();
 }
 
 UNINITIALIZED_TEST(PartialSerializerObject) {
-  DisableTurbofan();
+  DisableAlwaysOpt();
   Vector<const byte> startup_blob;
   Vector<const byte> partial_blob;
   PartiallySerializeObject(&startup_blob, &partial_blob);
 
   v8::Isolate* v8_isolate = InitializeFromBlob(startup_blob);
   startup_blob.Dispose();
   CHECK(v8_isolate);
   {
     v8::Isolate::Scope isolate_scope(v8_isolate);
 
@@ skipping 77 matching lines @@
     SnapshotData startup_snapshot(&startup_serializer);
     SnapshotData partial_snapshot(&partial_serializer);
 
     *partial_blob_out = WritePayload(partial_snapshot.RawData());
     *startup_blob_out = WritePayload(startup_snapshot.RawData());
   }
   v8_isolate->Dispose();
 }
 
 UNINITIALIZED_TEST(PartialSerializerContext) {
-  DisableTurbofan();
+  DisableAlwaysOpt();
   Vector<const byte> startup_blob;
   Vector<const byte> partial_blob;
   PartiallySerializeContext(&startup_blob, &partial_blob);
 
   v8::Isolate* v8_isolate = InitializeFromBlob(startup_blob);
   CHECK(v8_isolate);
   startup_blob.Dispose();
   {
     v8::Isolate::Scope isolate_scope(v8_isolate);
 
@@ skipping 98 matching lines @@
     SnapshotData startup_snapshot(&startup_serializer);
     SnapshotData partial_snapshot(&partial_serializer);
 
     *partial_blob_out = WritePayload(partial_snapshot.RawData());
     *startup_blob_out = WritePayload(startup_snapshot.RawData());
   }
   v8_isolate->Dispose();
 }
 
 UNINITIALIZED_TEST(PartialSerializerCustomContext) {
-  DisableTurbofan();
+  DisableAlwaysOpt();
   Vector<const byte> startup_blob;
   Vector<const byte> partial_blob;
   PartiallySerializeCustomContext(&startup_blob, &partial_blob);
 
   v8::Isolate* v8_isolate = InitializeFromBlob(startup_blob);
   CHECK(v8_isolate);
   startup_blob.Dispose();
   {
     v8::Isolate::Scope isolate_scope(v8_isolate);
 
@@ skipping 69 matching lines @@
                   ->Int32Value(v8_isolate->GetCurrentContext())
                   .FromJust();
       CHECK_EQ(100002, b);
     }
     partial_blob.Dispose();
   }
   v8_isolate->Dispose();
 }
 
 TEST(CustomSnapshotDataBlob1) {
-  DisableTurbofan();
+  DisableAlwaysOpt();
   const char* source1 = "function f() { return 42; }";
 
   v8::StartupData data1 = v8::V8::CreateSnapshotDataBlob(source1);
 
   v8::Isolate::CreateParams params1;
   params1.snapshot_blob = &data1;
   params1.array_buffer_allocator = CcTest::array_buffer_allocator();
 
   v8::Isolate* isolate1 = v8::Isolate::New(params1);
   {
     v8::Isolate::Scope i_scope(isolate1);
     v8::HandleScope h_scope(isolate1);
     v8::Local<v8::Context> context = v8::Context::New(isolate1);
     delete[] data1.data;  // We can dispose of the snapshot blob now.
     v8::Context::Scope c_scope(context);
     v8::Maybe<int32_t> result =
         CompileRun("f()")->Int32Value(isolate1->GetCurrentContext());
     CHECK_EQ(42, result.FromJust());
     CHECK(CompileRun("this.g")->IsUndefined());
   }
   isolate1->Dispose();
 }
 
 TEST(CustomSnapshotDataBlob2) {
-  DisableTurbofan();
+  DisableAlwaysOpt();
   const char* source2 =
       "function f() { return g() * 2; }"
       "function g() { return 43; }"
       "/./.test('a')";
 
   v8::StartupData data2 = v8::V8::CreateSnapshotDataBlob(source2);
 
   v8::Isolate::CreateParams params2;
   params2.snapshot_blob = &data2;
   params2.array_buffer_allocator = CcTest::array_buffer_allocator();
@@ skipping 12 matching lines @@
   }
   isolate2->Dispose();
 }
 
 static void SerializationFunctionTemplate(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   args.GetReturnValue().Set(args[0]);
 }
 
 TEST(CustomSnapshotDataBlobOutdatedContextWithOverflow) {
-  DisableTurbofan();
-
+  DisableAlwaysOpt();
   const char* source1 =
       "var o = {};"
       "(function() {"
       "  function f1(x) { return f2(x) instanceof Array; }"
       "  function f2(x) { return foo.bar(x); }"
       "  o.a = f2.bind(null);"
       "  o.b = 1;"
       "  o.c = 2;"
       "  o.d = 3;"
       "  o.e = 4;"
@@ skipping 24 matching lines @@
     v8::Context::Scope c_scope(context);
     v8::Local<v8::Value> result = CompileRun(source2);
     v8::Maybe<bool> compare = v8_str("42")->Equals(
         v8::Isolate::GetCurrent()->GetCurrentContext(), result);
     CHECK(compare.FromJust());
   }
   isolate->Dispose();
 }
 
 TEST(CustomSnapshotDataBlobWithLocker) {
-  DisableTurbofan();
+  DisableAlwaysOpt();
   v8::Isolate::CreateParams create_params;
   create_params.array_buffer_allocator = CcTest::array_buffer_allocator();
   v8::Isolate* isolate0 = v8::Isolate::New(create_params);
   {
     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);
     v8::Maybe<int32_t> result =
@@ skipping 17 matching lines @@
     v8::Local<v8::Context> context = v8::Context::New(isolate1);
     delete[] data1.data;  // We can dispose of the snapshot blob now.
     v8::Context::Scope c_scope(context);
     v8::Maybe<int32_t> result = CompileRun("f()")->Int32Value(context);
     CHECK_EQ(42, result.FromJust());
   }
   isolate1->Dispose();
 }
 
 TEST(CustomSnapshotDataBlobStackOverflow) {
-  DisableTurbofan();
+  DisableAlwaysOpt();
   const char* source =
       "var a = [0];"
       "var b = a;"
       "for (var i = 0; i < 10000; i++) {"
       "  var c = [i];"
       "  b.push(c);"
       "  b.push(c);"
       "  b = c;"
       "}";
 
@@ skipping 25 matching lines @@
 }
 
 bool IsCompiled(const char* name) {
   return i::Handle<i::JSFunction>::cast(
              v8::Utils::OpenHandle(*CompileRun(name)))
       ->shared()
       ->is_compiled();
 }
 
 TEST(SnapshotDataBlobWithWarmup) {
-  DisableTurbofan();
+  DisableAlwaysOpt();
   const char* warmup = "Math.abs(1); Math.random = 1;";
 
   v8::StartupData cold = v8::V8::CreateSnapshotDataBlob();
   v8::StartupData warm = v8::V8::WarmUpSnapshotDataBlob(cold, warmup);
   delete[] cold.data;
 
   v8::Isolate::CreateParams params;
   params.snapshot_blob = &warm;
   params.array_buffer_allocator = CcTest::array_buffer_allocator();
 
   v8::Isolate* isolate = v8::Isolate::New(params);
   {
     v8::Isolate::Scope i_scope(isolate);
     v8::HandleScope h_scope(isolate);
     v8::Local<v8::Context> context = v8::Context::New(isolate);
     delete[] warm.data;
     v8::Context::Scope c_scope(context);
     // Running the warmup script has effect on whether functions are
     // pre-compiled, but does not pollute the context.
     CHECK(IsCompiled("Math.abs"));
     CHECK(!IsCompiled("String.raw"));
     CHECK(CompileRun("Math.random")->IsFunction());
   }
   isolate->Dispose();
 }
 
 TEST(CustomSnapshotDataBlobWithWarmup) {
-  DisableTurbofan();
+  DisableAlwaysOpt();
   const char* source =
       "function f() { return Math.abs(1); }\n"
       "function g() { return String.raw(1); }\n"
       "Object.valueOf(1);"
       "var a = 5";
   const char* warmup = "a = f()";
 
   v8::StartupData cold = v8::V8::CreateSnapshotDataBlob(source);
   v8::StartupData warm = v8::V8::WarmUpSnapshotDataBlob(cold, warmup);
   delete[] cold.data;
@@ skipping 15 matching lines @@
     CHECK(IsCompiled("Math.abs"));
     CHECK(!IsCompiled("g"));
     CHECK(!IsCompiled("String.raw"));
     CHECK(!IsCompiled("Object.valueOf"));
     CHECK_EQ(5, CompileRun("a")->Int32Value(context).FromJust());
   }
   isolate->Dispose();
 }
 
 TEST(CustomSnapshotDataBlobImmortalImmovableRoots) {
-  DisableTurbofan();
+  DisableAlwaysOpt();
   // Flood the startup snapshot with shared function infos. If they are
   // serialized before the immortal immovable root, the root will no longer end
   // up on the first page.
   Vector<const uint8_t> source =
       ConstructSource(STATIC_CHAR_VECTOR("var a = [];"),
                       STATIC_CHAR_VECTOR("a.push(function() {return 7});"),
                       STATIC_CHAR_VECTOR("\0"), 10000);
 
   v8::StartupData data = v8::V8::CreateSnapshotDataBlob(
       reinterpret_cast<const char*>(source.start()));
@@ skipping 1070 matching lines @@
 
   RelocIterator rit3(copy->code(),
                      RelocInfo::ModeMask(RelocInfo::EMBEDDED_OBJECT));
   CHECK(rit3.rinfo()->target_object()->IsHeapNumber());
   CHECK_EQ(0.3, HeapNumber::cast(rit3.rinfo()->target_object())->value());
 
   delete script_data;
 }
 
 TEST(SnapshotCreatorMultipleContexts) {
-  DisableTurbofan();
+  DisableAlwaysOpt();
   v8::StartupData blob;
   {
     v8::SnapshotCreator creator;
     v8::Isolate* isolate = creator.GetIsolate();
     {
       v8::HandleScope handle_scope(isolate);
       v8::Local<v8::Context> context = v8::Context::New(isolate);
       v8::Context::Scope context_scope(context);
       CompileRun("var f = function() { return 1; }");
       CHECK_EQ(0, creator.AddContext(context));
@@ skipping 56 matching lines @@
   args.GetReturnValue().Set(v8_num(1337));
 }
 
 intptr_t original_external_references[] = {
     reinterpret_cast<intptr_t>(SerializedCallback), 0};
 
 intptr_t replaced_external_references[] = {
     reinterpret_cast<intptr_t>(SerializedCallbackReplacement), 0};
 
 TEST(SnapshotCreatorExternalReferences) {
-  DisableTurbofan();
+  DisableAlwaysOpt();
   v8::StartupData blob;
   {
     v8::SnapshotCreator creator(original_external_references);
     v8::Isolate* isolate = creator.GetIsolate();
     {
       v8::HandleScope handle_scope(isolate);
       v8::Local<v8::Context> context = v8::Context::New(isolate);
       v8::Context::Scope context_scope(context);
       v8::Local<v8::FunctionTemplate> callback =
           v8::FunctionTemplate::New(isolate, SerializedCallback);
@@ skipping 39 matching lines @@
           v8::Context::FromSnapshot(isolate, 0).ToLocalChecked();
       v8::Context::Scope context_scope(context);
       ExpectInt32("f()", 1337);
     }
     isolate->Dispose();
   }
   delete[] blob.data;
 }
 
 TEST(SnapshotCreatorUnknownExternalReferences) {
-  DisableTurbofan();
+  DisableAlwaysOpt();
   v8::SnapshotCreator creator;
   v8::Isolate* isolate = creator.GetIsolate();
   {
     v8::HandleScope handle_scope(isolate);
     v8::Local<v8::Context> context = v8::Context::New(isolate);
     v8::Context::Scope context_scope(context);
 
     v8::Local<v8::FunctionTemplate> callback =
         v8::FunctionTemplate::New(isolate, SerializedCallback);
     v8::Local<v8::Value> function =
@@ skipping 25 matching lines @@
 }
 
 void DeserializeInternalFields(v8::Local<v8::Object> holder, int index,
                                v8::StartupData payload) {
   InternalFieldData* data = new InternalFieldData{0};
   memcpy(data, payload.data, payload.raw_size);
   holder->SetAlignedPointerInInternalField(index, data);
 }
 
 TEST(SnapshotCreatorTemplates) {
-  DisableTurbofan();
+  DisableAlwaysOpt();
   v8::StartupData blob;
 
   {
     InternalFieldData* a1 = new InternalFieldData{11};
     InternalFieldData* b0 = new InternalFieldData{20};
     InternalFieldData* c0 = new InternalFieldData{30};
     InternalFieldData* c1 = new InternalFieldData{31};
 
     v8::SnapshotCreator creator(original_external_references);
     v8::Isolate* isolate = creator.GetIsolate();
@@ skipping 137 matching lines @@
   }
   delete[] blob.data;
 }
 
 TEST(SerializationMemoryStats) {
   FLAG_profile_deserialization = true;
   FLAG_always_opt = false;
   v8::StartupData blob = v8::V8::CreateSnapshotDataBlob();
   delete[] blob.data;
 }