Make TestInternalWeakLists more robust against flags.

test/cctest/test-heap.cc

 // Copyright 2012 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 1416 matching lines @@
   }
 
   // If we aged the cache before caching the script, ensure that we didn't cache
   // on next compilation.
   info = compilation_cache->LookupScript(source, Handle<Object>(), 0, 0, false,
                                          true, native_context, language_mode);
   CHECK(info.is_null());
 }
 
 
+static void OptimizeEmptyFunction(const char* name) {
+  HandleScope scope(CcTest::i_isolate());
+  EmbeddedVector<char, 256> source;
+  SNPrintF(source,
+           "function %s() { return 0; }"
+           "%s(); %s();"
+           "%%OptimizeFunctionOnNextCall(%s);"
+           "%s();",
+           name, name, name, name, name);
+  CompileRun(source.start());
+}
+
+
 // Count the number of native contexts in the weak list of native contexts.
 int CountNativeContexts() {
   int count = 0;
   Object* object = CcTest::heap()->native_contexts_list();
   while (!object->IsUndefined()) {
     count++;
     object = Context::cast(object)->get(Context::NEXT_CONTEXT_LINK);
   }
   return count;
 }
 
 
 // Count the number of user functions in the weak list of optimized
 // functions attached to a native context.
 static int CountOptimizedUserFunctions(v8::Handle<v8::Context> context) {
   int count = 0;
   Handle<Context> icontext = v8::Utils::OpenHandle(*context);
   Object* object = icontext->get(Context::OPTIMIZED_FUNCTIONS_LIST);
   while (object->IsJSFunction() && !JSFunction::cast(object)->IsBuiltin()) {
     count++;
     object = JSFunction::cast(object)->next_function_link();
   }
   return count;
 }
 
 
 TEST(TestInternalWeakLists) {
+  FLAG_always_opt = false;
+  FLAG_allow_natives_syntax = true;
   v8::V8::Initialize();
 
   // Some flags turn Scavenge collections into Mark-sweep collections
   // and hence are incompatible with this test case.
   if (FLAG_gc_global || FLAG_stress_compaction) return;
   FLAG_retain_maps_for_n_gc = 0;
 
   static const int kNumTestContexts = 10;
 
   Isolate* isolate = CcTest::i_isolate();
   Heap* heap = isolate->heap();
   HandleScope scope(isolate);
   v8::Handle<v8::Context> ctx[kNumTestContexts];
+  if (!isolate->use_crankshaft()) return;
 
   CHECK_EQ(0, CountNativeContexts());
 
   // Create a number of global contests which gets linked together.
   for (int i = 0; i < kNumTestContexts; i++) {
     ctx[i] = v8::Context::New(CcTest::isolate());
 
     // Collect garbage that might have been created by one of the
     // installed extensions.
     isolate->compilation_cache()->Clear();
     heap->CollectAllGarbage(Heap::kNoGCFlags);
 
-    bool opt = (FLAG_always_opt && isolate->use_crankshaft());
-
     CHECK_EQ(i + 1, CountNativeContexts());
 
     ctx[i]->Enter();
 
-    // Create a handle scope so no function objects get stuch in the outer
-    // handle scope
+    // Create a handle scope so no function objects get stuck in the outer
+    // handle scope.
     HandleScope scope(isolate);
-    const char* source = "function f1() { };"
-                         "function f2() { };"
-                         "function f3() { };"
-                         "function f4() { };"
-                         "function f5() { };";
-    CompileRun(source);
     CHECK_EQ(0, CountOptimizedUserFunctions(ctx[i]));
-    CompileRun("f1()");
-    CHECK_EQ(opt ? 1 : 0, CountOptimizedUserFunctions(ctx[i]));
-    CompileRun("f2()");
-    CHECK_EQ(opt ? 2 : 0, CountOptimizedUserFunctions(ctx[i]));
-    CompileRun("f3()");
-    CHECK_EQ(opt ? 3 : 0, CountOptimizedUserFunctions(ctx[i]));
-    CompileRun("f4()");
-    CHECK_EQ(opt ? 4 : 0, CountOptimizedUserFunctions(ctx[i]));
-    CompileRun("f5()");
-    CHECK_EQ(opt ? 5 : 0, CountOptimizedUserFunctions(ctx[i]));
+    OptimizeEmptyFunction("f1");
+    CHECK_EQ(1, CountOptimizedUserFunctions(ctx[i]));
+    OptimizeEmptyFunction("f2");
+    CHECK_EQ(2, CountOptimizedUserFunctions(ctx[i]));
+    OptimizeEmptyFunction("f3");
+    CHECK_EQ(3, CountOptimizedUserFunctions(ctx[i]));
+    OptimizeEmptyFunction("f4");
+    CHECK_EQ(4, CountOptimizedUserFunctions(ctx[i]));
+    OptimizeEmptyFunction("f5");
+    CHECK_EQ(5, CountOptimizedUserFunctions(ctx[i]));
 
     // Remove function f1, and
     CompileRun("f1=null");
 
     // Scavenge treats these references as strong.
     for (int j = 0; j < 10; j++) {
       CcTest::heap()->CollectGarbage(NEW_SPACE);
-      CHECK_EQ(opt ? 5 : 0, CountOptimizedUserFunctions(ctx[i]));
+      CHECK_EQ(5, CountOptimizedUserFunctions(ctx[i]));
     }
 
     // Mark compact handles the weak references.
     isolate->compilation_cache()->Clear();
     heap->CollectAllGarbage(Heap::kNoGCFlags);
-    CHECK_EQ(opt ? 4 : 0, CountOptimizedUserFunctions(ctx[i]));
+    CHECK_EQ(4, CountOptimizedUserFunctions(ctx[i]));
 
     // Get rid of f3 and f5 in the same way.
     CompileRun("f3=null");
     for (int j = 0; j < 10; j++) {
       CcTest::heap()->CollectGarbage(NEW_SPACE);
-      CHECK_EQ(opt ? 4 : 0, CountOptimizedUserFunctions(ctx[i]));
+      CHECK_EQ(4, CountOptimizedUserFunctions(ctx[i]));
     }
     CcTest::heap()->CollectAllGarbage(Heap::kNoGCFlags);
-    CHECK_EQ(opt ? 3 : 0, CountOptimizedUserFunctions(ctx[i]));
+    CHECK_EQ(3, CountOptimizedUserFunctions(ctx[i]));
     CompileRun("f5=null");
     for (int j = 0; j < 10; j++) {
       CcTest::heap()->CollectGarbage(NEW_SPACE);
-      CHECK_EQ(opt ? 3 : 0, CountOptimizedUserFunctions(ctx[i]));
+      CHECK_EQ(3, CountOptimizedUserFunctions(ctx[i]));
     }
     CcTest::heap()->CollectAllGarbage(Heap::kNoGCFlags);
-    CHECK_EQ(opt ? 2 : 0, CountOptimizedUserFunctions(ctx[i]));
+    CHECK_EQ(2, CountOptimizedUserFunctions(ctx[i]));
 
     ctx[i]->Exit();
   }
 
   // Force compilation cache cleanup.
   CcTest::heap()->NotifyContextDisposed(true);
   CcTest::heap()->CollectAllGarbage(Heap::kNoGCFlags);
 
   // Dispose the native contexts one by one.
   for (int i = 0; i < kNumTestContexts; i++) {
@@ skipping 50 matching lines @@
     if (count == n) isolate->heap()->CollectAllGarbage(Heap::kNoGCFlags);
     object = Handle<Object>(
         Object::cast(JSFunction::cast(*object)->next_function_link()),
         isolate);
   }
   return count;
 }
 
 
 TEST(TestInternalWeakListsTraverseWithGC) {
+  FLAG_always_opt = false;
+  FLAG_allow_natives_syntax = true;
   v8::V8::Initialize();
-  Isolate* isolate = CcTest::i_isolate();
 
   static const int kNumTestContexts = 10;
 
+  Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
   v8::Handle<v8::Context> ctx[kNumTestContexts];
+  if (!isolate->use_crankshaft()) return;
 
   CHECK_EQ(0, CountNativeContexts());
 
   // Create an number of contexts and check the length of the weak list both
   // with and without GCs while iterating the list.
   for (int i = 0; i < kNumTestContexts; i++) {
     ctx[i] = v8::Context::New(CcTest::isolate());
     CHECK_EQ(i + 1, CountNativeContexts());
     CHECK_EQ(i + 1, CountNativeContextsWithGC(isolate, i / 2 + 1));
   }
 
-  bool opt = (FLAG_always_opt && isolate->use_crankshaft());
+  ctx[0]->Enter();
 
   // Compile a number of functions the length of the weak list of optimized
   // functions both with and without GCs while iterating the list.
-  ctx[0]->Enter();
-  const char* source = "function f1() { };"
-                       "function f2() { };"
-                       "function f3() { };"
-                       "function f4() { };"
-                       "function f5() { };";
-  CompileRun(source);
   CHECK_EQ(0, CountOptimizedUserFunctions(ctx[0]));
-  CompileRun("f1()");
-  CHECK_EQ(opt ? 1 : 0, CountOptimizedUserFunctions(ctx[0]));
-  CHECK_EQ(opt ? 1 : 0, CountOptimizedUserFunctionsWithGC(ctx[0], 1));
-  CompileRun("f2()");
-  CHECK_EQ(opt ? 2 : 0, CountOptimizedUserFunctions(ctx[0]));
-  CHECK_EQ(opt ? 2 : 0, CountOptimizedUserFunctionsWithGC(ctx[0], 1));
-  CompileRun("f3()");
-  CHECK_EQ(opt ? 3 : 0, CountOptimizedUserFunctions(ctx[0]));
-  CHECK_EQ(opt ? 3 : 0, CountOptimizedUserFunctionsWithGC(ctx[0], 1));
-  CompileRun("f4()");
-  CHECK_EQ(opt ? 4 : 0, CountOptimizedUserFunctions(ctx[0]));
-  CHECK_EQ(opt ? 4 : 0, CountOptimizedUserFunctionsWithGC(ctx[0], 2));
-  CompileRun("f5()");
-  CHECK_EQ(opt ? 5 : 0, CountOptimizedUserFunctions(ctx[0]));
-  CHECK_EQ(opt ? 5 : 0, CountOptimizedUserFunctionsWithGC(ctx[0], 4));
+  OptimizeEmptyFunction("f1");
+  CHECK_EQ(1, CountOptimizedUserFunctions(ctx[0]));
+  CHECK_EQ(1, CountOptimizedUserFunctionsWithGC(ctx[0], 1));
+  OptimizeEmptyFunction("f2");
+  CHECK_EQ(2, CountOptimizedUserFunctions(ctx[0]));
+  CHECK_EQ(2, CountOptimizedUserFunctionsWithGC(ctx[0], 1));
+  OptimizeEmptyFunction("f3");
+  CHECK_EQ(3, CountOptimizedUserFunctions(ctx[0]));
+  CHECK_EQ(3, CountOptimizedUserFunctionsWithGC(ctx[0], 1));
+  OptimizeEmptyFunction("f4");
+  CHECK_EQ(4, CountOptimizedUserFunctions(ctx[0]));
+  CHECK_EQ(4, CountOptimizedUserFunctionsWithGC(ctx[0], 2));
+  OptimizeEmptyFunction("f5");
+  CHECK_EQ(5, CountOptimizedUserFunctions(ctx[0]));
+  CHECK_EQ(5, CountOptimizedUserFunctionsWithGC(ctx[0], 4));
 
   ctx[0]->Exit();
 }
 
 
 TEST(TestSizeOfRegExpCode) {
   if (!FLAG_regexp_optimization) return;
 
   v8::V8::Initialize();
 
@@ skipping 2714 matching lines @@
   int result = 0;
   while (code->next_code_link()->IsCode()) {
     result++;
     code = Code::cast(code->next_code_link());
   }
   return result;
 }
 
 
 TEST(NextCodeLinkIsWeak) {
+  i::FLAG_always_opt = false;
   i::FLAG_allow_natives_syntax = true;
   i::FLAG_turbo_deoptimization = true;
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   v8::internal::Heap* heap = CcTest::heap();
 
   if (!isolate->use_crankshaft()) return;
   HandleScope outer_scope(heap->isolate());
   Handle<Code> code;
   heap->CollectAllAvailableGarbage();
@@ skipping 950 matching lines @@
   TestRightTrimFixedTypedArray(v8::kExternalUint32Array, 8, 6);
   TestRightTrimFixedTypedArray(v8::kExternalUint32Array, 8 - 1, 6);
 
   // 32-bit cases.
   TestRightTrimFixedTypedArray(v8::kExternalUint8Array, 16, 3);
   TestRightTrimFixedTypedArray(v8::kExternalUint8Array, 16 - 3, 3);
   TestRightTrimFixedTypedArray(v8::kExternalUint16Array, 8, 3);
   TestRightTrimFixedTypedArray(v8::kExternalUint16Array, 8 - 1, 3);
   TestRightTrimFixedTypedArray(v8::kExternalUint32Array, 4, 3);
 }