[heap] More flag cleanup.

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 417 matching lines @@
 
 
 TEST(GarbageCollection) {
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   Heap* heap = isolate->heap();
   Factory* factory = isolate->factory();
 
   HandleScope sc(isolate);
   // Check GC.
-  heap->CollectGarbage(NEW_SPACE);
+  heap->CollectGarbageNewSpace();
 
   Handle<GlobalObject> global(CcTest::i_isolate()->context()->global_object());
   Handle<String> name = factory->InternalizeUtf8String("theFunction");
   Handle<String> prop_name = factory->InternalizeUtf8String("theSlot");
   Handle<String> prop_namex = factory->InternalizeUtf8String("theSlotx");
   Handle<String> obj_name = factory->InternalizeUtf8String("theObject");
   Handle<Smi> twenty_three(Smi::FromInt(23), isolate);
   Handle<Smi> twenty_four(Smi::FromInt(24), isolate);
 
   {
     HandleScope inner_scope(isolate);
     // Allocate a function and keep it in global object's property.
     Handle<JSFunction> function = factory->NewFunction(name);
     JSReceiver::SetProperty(global, name, function, SLOPPY).Check();
     // Allocate an object.  Unrooted after leaving the scope.
     Handle<JSObject> obj = factory->NewJSObject(function);
     JSReceiver::SetProperty(obj, prop_name, twenty_three, SLOPPY).Check();
     JSReceiver::SetProperty(obj, prop_namex, twenty_four, SLOPPY).Check();
 
     CHECK_EQ(Smi::FromInt(23),
              *Object::GetProperty(obj, prop_name).ToHandleChecked());
     CHECK_EQ(Smi::FromInt(24),
              *Object::GetProperty(obj, prop_namex).ToHandleChecked());
   }
 
-  heap->CollectGarbage(NEW_SPACE);
+  heap->CollectGarbageNewSpace();
 
   // Function should be alive.
   CHECK(Just(true) == JSReceiver::HasOwnProperty(global, name));
   // Check function is retained.
   Handle<Object> func_value =
       Object::GetProperty(global, name).ToHandleChecked();
   CHECK(func_value->IsJSFunction());
   Handle<JSFunction> function = Handle<JSFunction>::cast(func_value);
 
   {
@@ skipping 69 matching lines @@
     Handle<Object> i = factory->NewStringFromStaticChars("fisk");
     Handle<Object> u = factory->NewNumber(1.12344);
 
     h1 = global_handles->Create(*i);
     h2 = global_handles->Create(*u);
     h3 = global_handles->Create(*i);
     h4 = global_handles->Create(*u);
   }
 
   // after gc, it should survive
-  heap->CollectGarbage(NEW_SPACE);
+  heap->CollectGarbageNewSpace();
 
   CHECK((*h1)->IsString());
   CHECK((*h2)->IsHeapNumber());
   CHECK((*h3)->IsString());
   CHECK((*h4)->IsHeapNumber());
 
   CHECK_EQ(*h3, *h1);
   GlobalHandles::Destroy(h1.location());
   GlobalHandles::Destroy(h3.location());
 
@@ skipping 37 matching lines @@
     h1 = global_handles->Create(*i);
     h2 = global_handles->Create(*u);
   }
 
   std::pair<Handle<Object>*, int> handle_and_id(&h2, 1234);
   GlobalHandles::MakeWeak(h2.location(),
                           reinterpret_cast<void*>(&handle_and_id),
                           &TestWeakGlobalHandleCallback);
 
   // Scavenge treats weak pointers as normal roots.
-  heap->CollectGarbage(NEW_SPACE);
+  heap->CollectGarbageNewSpace();
 
   CHECK((*h1)->IsString());
   CHECK((*h2)->IsHeapNumber());
 
   CHECK(!WeakPointerCleared);
   CHECK(!global_handles->IsNearDeath(h2.location()));
   CHECK(!global_handles->IsNearDeath(h1.location()));
 
   GlobalHandles::Destroy(h1.location());
   GlobalHandles::Destroy(h2.location());
@@ skipping 17 matching lines @@
 
     Handle<Object> i = factory->NewStringFromStaticChars("fisk");
     Handle<Object> u = factory->NewNumber(1.12344);
 
     h1 = global_handles->Create(*i);
     h2 = global_handles->Create(*u);
   }
 
   // Make sure the objects are promoted.
   heap->CollectGarbage(OLD_SPACE);
-  heap->CollectGarbage(NEW_SPACE);
+  heap->CollectGarbageNewSpace();
   CHECK(!heap->InNewSpace(*h1) && !heap->InNewSpace(*h2));
 
   std::pair<Handle<Object>*, int> handle_and_id(&h2, 1234);
   GlobalHandles::MakeWeak(h2.location(),
                           reinterpret_cast<void*>(&handle_and_id),
                           &TestWeakGlobalHandleCallback);
   CHECK(!GlobalHandles::IsNearDeath(h1.location()));
   CHECK(!GlobalHandles::IsNearDeath(h2.location()));
 
   // Incremental marking potentially marked handles before they turned weak.
@@ skipping 26 matching lines @@
     Handle<Object> i = factory->NewStringFromStaticChars("fisk");
     h = global_handles->Create(*i);
   }
 
   std::pair<Handle<Object>*, int> handle_and_id(&h, 1234);
   GlobalHandles::MakeWeak(h.location(),
                           reinterpret_cast<void*>(&handle_and_id),
                           &TestWeakGlobalHandleCallback);
 
   // Scanvenge does not recognize weak reference.
-  heap->CollectGarbage(NEW_SPACE);
+  heap->CollectGarbageNewSpace();
 
   CHECK(!WeakPointerCleared);
 
   // Mark-compact treats weak reference properly.
   heap->CollectGarbage(OLD_SPACE);
 
   CHECK(WeakPointerCleared);
 }
 
 
@@ skipping 798 matching lines @@
   for (int i = 0; i < kAgingThreshold; i++) {
     function->shared()->code()->MakeOlder(static_cast<MarkingParity>(i % 2));
     function2->shared()->code()->MakeOlder(static_cast<MarkingParity>(i % 2));
   }
 
   // Simulate incremental marking so that the functions are enqueued as
   // code flushing candidates. Then kill one of the functions. Finally
   // perform a scavenge while incremental marking is still running.
   SimulateIncrementalMarking(CcTest::heap());
   *function2.location() = NULL;
-  CcTest::heap()->CollectGarbage(NEW_SPACE, "test scavenge while marking");
+  CcTest::heap()->CollectGarbageNewSpace("test scavenge while marking");
 
   // Simulate one final GC to make sure the candidate queue is sane.
   CcTest::heap()->CollectAllGarbage();
   CHECK(!function->shared()->is_compiled() || function->IsOptimized());
   CHECK(!function->is_compiled() || function->IsOptimized());
 }
 
 
 TEST(TestCodeFlushingIncrementalAbort) {
   // If we do not flush code this test is invalid.
@@ skipping 253 matching lines @@
     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);
+      CcTest::heap()->CollectGarbageNewSpace();
       CHECK_EQ(5, CountOptimizedUserFunctions(ctx[i]));
     }
 
     // Mark compact handles the weak references.
     isolate->compilation_cache()->Clear();
     heap->CollectAllGarbage();
     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);
+      CcTest::heap()->CollectGarbageNewSpace();
       CHECK_EQ(4, CountOptimizedUserFunctions(ctx[i]));
     }
     CcTest::heap()->CollectAllGarbage();
     CHECK_EQ(3, CountOptimizedUserFunctions(ctx[i]));
     CompileRun("f5=null");
     for (int j = 0; j < 10; j++) {
       CcTest::heap()->CollectGarbage(NEW_SPACE);
       CHECK_EQ(3, CountOptimizedUserFunctions(ctx[i]));
     }
     CcTest::heap()->CollectAllGarbage();
@@ skipping 562 matching lines @@
   new_capacity = new_space->TotalCapacity();
   CHECK(old_capacity == new_capacity);
 
   // Explicitly shrinking should not affect space capacity.
   old_capacity = new_space->TotalCapacity();
   new_space->Shrink();
   new_capacity = new_space->TotalCapacity();
   CHECK(old_capacity == new_capacity);
 
   // Let the scavenger empty the new space.
-  heap->CollectGarbage(NEW_SPACE);
+  heap->CollectGarbageNewSpace();
   CHECK_LE(new_space->Size(), old_capacity);
 
   // Explicitly shrinking should halve the space capacity.
   old_capacity = new_space->TotalCapacity();
   new_space->Shrink();
   new_capacity = new_space->TotalCapacity();
   CHECK(old_capacity == 2 * new_capacity);
 
   // Consecutive shrinking should not affect space capacity.
   old_capacity = new_space->TotalCapacity();
@@ skipping 434 matching lines @@
 
 HEAP_TEST(GCFlags) {
   CcTest::InitializeVM();
   Heap* heap = CcTest::heap();
 
   heap->set_current_gc_flags(Heap::kNoGCFlags);
   CHECK_EQ(Heap::kNoGCFlags, heap->current_gc_flags_);
 
   // Set the flags to check whether we appropriately resets them after the GC.
   heap->set_current_gc_flags(Heap::kAbortIncrementalMarkingMask);
-  heap->CollectAllGarbage(Heap::kReduceMemoryFootprintMask);
+  heap->CollectAllGarbage("GCFlags", Heap::kReduceMemoryFootprintMask);
   CHECK_EQ(Heap::kNoGCFlags, heap->current_gc_flags_);
 
   MarkCompactCollector* collector = heap->mark_compact_collector();
   if (collector->sweeping_in_progress()) {
     collector->EnsureSweepingCompleted();
   }
 
   IncrementalMarking* marking = heap->incremental_marking();
   marking->Stop();
   heap->StartIncrementalMarking(Heap::kReduceMemoryFootprintMask);
   CHECK_NE(0, heap->current_gc_flags_ & Heap::kReduceMemoryFootprintMask);
 
-  heap->CollectGarbage(NEW_SPACE);
+  heap->CollectGarbageNewSpace();
   // NewSpace scavenges should not overwrite the flags.
   CHECK_NE(0, heap->current_gc_flags_ & Heap::kReduceMemoryFootprintMask);
 
-  heap->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);
+  heap->CollectAllGarbage("GCFlags", Heap::kAbortIncrementalMarkingMask);
   CHECK_EQ(Heap::kNoGCFlags, heap->current_gc_flags_);
 }
 
 
 TEST(IdleNotificationFinishMarking) {
   i::FLAG_allow_natives_syntax = true;
   CcTest::InitializeVM();
   SimulateFullSpace(CcTest::heap()->old_space());
   IncrementalMarking* marking = CcTest::heap()->incremental_marking();
   marking->Stop();
@@ skipping 865 matching lines @@
   CHECK_EQ(1, old_space->CountTotalPages());
   for (int i = 0; i < number_of_test_pages; i++) {
     AlwaysAllocateScope always_allocate(isolate);
     SimulateFullSpace(old_space);
     factory->NewFixedArray(1, TENURED);
   }
   CHECK_EQ(number_of_test_pages + 1, old_space->CountTotalPages());
 
   // Triggering one GC will cause a lot of garbage to be discovered but
   // even spread across all allocated pages.
-  heap->CollectAllGarbage(Heap::kFinalizeIncrementalMarkingMask,
-                          "triggered for preparation");
+  heap->CollectAllGarbage("triggered for preparation",
+                          Heap::kFinalizeIncrementalMarkingMask);
   CHECK_GE(number_of_test_pages + 1, old_space->CountTotalPages());
 
   // Triggering subsequent GCs should cause at least half of the pages
   // to be released to the OS after at most two cycles.
-  heap->CollectAllGarbage(Heap::kFinalizeIncrementalMarkingMask,
-                          "triggered by test 1");
+  heap->CollectAllGarbage("triggered by test 1",
+                          Heap::kFinalizeIncrementalMarkingMask);
+  ;
   CHECK_GE(number_of_test_pages + 1, old_space->CountTotalPages());
-  heap->CollectAllGarbage(Heap::kFinalizeIncrementalMarkingMask,
-                          "triggered by test 2");
+  heap->CollectAllGarbage("triggered by test 2",
+                          Heap::kFinalizeIncrementalMarkingMask);
   CHECK_GE(number_of_test_pages + 1, old_space->CountTotalPages() * 2);
 
   // Triggering a last-resort GC should cause all pages to be released to the
   // OS so that other processes can seize the memory.  If we get a failure here
   // where there are 2 pages left instead of 1, then we should increase the
   // size of the first page a little in SizeOfFirstPage in spaces.cc.  The
   // first page should be small in order to reduce memory used when the VM
   // boots, but if the 20 small arrays don't fit on the first page then that's
   // an indication that it is too small.
   heap->CollectAllAvailableGarbage("triggered really hard");
@@ skipping 677 matching lines @@
              "obj = fastliteralcase(get_standard_literal(), 2);");
 
   // prepare the heap
   v8::Local<v8::String> mote_code_string =
       v8_str("fastliteralcase(mote, 2.5);");
 
   v8::Local<v8::String> array_name = v8_str("mote");
   CcTest::global()->Set(array_name, v8::Int32::New(CcTest::isolate(), 0));
 
   // First make sure we flip spaces
-  CcTest::heap()->CollectGarbage(NEW_SPACE);
+  CcTest::heap()->CollectGarbageNewSpace();
 
   // Allocate the object.
   Handle<FixedArray> array_data = factory->NewFixedArray(2, NOT_TENURED);
   array_data->set(0, Smi::FromInt(1));
   array_data->set(1, Smi::FromInt(2));
 
   AllocateAllButNBytes(CcTest::heap()->new_space(),
                        JSArray::kSize + AllocationMemento::kSize +
                        kPointerSize);
 
@@ skipping 1049 matching lines @@
   }
 
   Handle<FixedArray> survivor = factory->NewFixedArray(1, NOT_TENURED);
   Handle<WeakCell> weak_cell2;
   {
     HandleScope inner_scope(isolate);
     weak_cell2 = inner_scope.CloseAndEscape(factory->NewWeakCell(survivor));
   }
   CHECK(weak_cell1->value()->IsFixedArray());
   CHECK_EQ(*survivor, weak_cell2->value());
-  heap->CollectGarbage(NEW_SPACE);
+  heap->CollectGarbageNewSpace();
   CHECK(weak_cell1->value()->IsFixedArray());
   CHECK_EQ(*survivor, weak_cell2->value());
-  heap->CollectGarbage(NEW_SPACE);
+  heap->CollectGarbageNewSpace();
   CHECK(weak_cell1->value()->IsFixedArray());
   CHECK_EQ(*survivor, weak_cell2->value());
   heap->CollectAllAvailableGarbage();
   CHECK(weak_cell1->cleared());
   CHECK_EQ(*survivor, weak_cell2->value());
 }
 
 
 TEST(WeakCellsWithIncrementalMarking) {
   CcTest::InitializeVM();
@@ skipping 10 matching lines @@
     HandleScope inner_scope(isolate);
     Handle<HeapObject> value =
         i == 0 ? survivor : factory->NewFixedArray(1, NOT_TENURED);
     Handle<WeakCell> weak_cell = factory->NewWeakCell(value);
     CHECK(weak_cell->value()->IsFixedArray());
     IncrementalMarking* marking = heap->incremental_marking();
     if (marking->IsStopped()) {
       heap->StartIncrementalMarking();
     }
     marking->Step(128, IncrementalMarking::NO_GC_VIA_STACK_GUARD);
-    heap->CollectGarbage(NEW_SPACE);
+    heap->CollectGarbageNewSpace();
     CHECK(weak_cell->value()->IsFixedArray());
     weak_cells[i] = inner_scope.CloseAndEscape(weak_cell);
   }
   heap->CollectAllGarbage();
   CHECK_EQ(*survivor, weak_cells[0]->value());
   for (int i = 1; i < N; i++) {
     CHECK(weak_cells[i]->cleared());
   }
 }
 
@@ skipping 185 matching lines @@
     // If we are in a low memory config, we can't grow to two pages and we can't
     // run this test. This also means the issue we are testing cannot arise, as
     // there is no fragmentation.
     if (new_space->IsAtMaximumCapacity()) return;
 
     new_space->Grow();
     CHECK(new_space->IsAtMaximumCapacity());
     CHECK(2 * old_capacity == new_space->TotalCapacity());
 
     // Call the scavenger two times to get an empty new space
-    heap->CollectGarbage(NEW_SPACE);
-    heap->CollectGarbage(NEW_SPACE);
+    heap->CollectGarbageNewSpace();
+    heap->CollectGarbageNewSpace();
 
     // First create a few objects which will survive a scavenge, and will get
     // promoted to the old generation later on. These objects will create
     // promotion queue entries at the end of the second semi-space page.
     const int number_handles = 12;
     Handle<FixedArray> handles[number_handles];
     for (int i = 0; i < number_handles; i++) {
       handles[i] = i_isolate->factory()->NewFixedArray(1, NOT_TENURED);
     }
-    heap->CollectGarbage(NEW_SPACE);
+    heap->CollectGarbageNewSpace();
 
     // Create the first huge object which will exactly fit the first semi-space
     // page.
     int new_linear_size =
         static_cast<int>(*heap->new_space()->allocation_limit_address() -
                          *heap->new_space()->allocation_top_address());
     int length = new_linear_size / kPointerSize - FixedArray::kHeaderSize;
     Handle<FixedArray> first =
         i_isolate->factory()->NewFixedArray(length, NOT_TENURED);
     CHECK(heap->InNewSpace(*first));
 
     // Create the second huge object of maximum allocatable second semi-space
     // page size.
     new_linear_size =
         static_cast<int>(*heap->new_space()->allocation_limit_address() -
                          *heap->new_space()->allocation_top_address());
     length = Page::kMaxRegularHeapObjectSize / kPointerSize -
              FixedArray::kHeaderSize;
     Handle<FixedArray> second =
         i_isolate->factory()->NewFixedArray(length, NOT_TENURED);
     CHECK(heap->InNewSpace(*second));
 
     // This scavenge will corrupt memory if the promotion queue is not
     // evacuated.
-    heap->CollectGarbage(NEW_SPACE);
+    heap->CollectGarbageNewSpace();
   }
   isolate->Dispose();
 }
 
 
 TEST(Regress388880) {
   i::FLAG_expose_gc = true;
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
@@ skipping 404 matching lines @@
   CHECK_EQ(bytes, static_cast<size_t>(array->Size()));
 }
 
 
 TEST(NewSpaceAllocationCounter) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Heap* heap = isolate->heap();
   size_t counter1 = heap->NewSpaceAllocationCounter();
-  heap->CollectGarbage(NEW_SPACE);
+  heap->CollectGarbageNewSpace();
   const size_t kSize = 1024;
   AllocateInSpace(isolate, kSize, NEW_SPACE);
   size_t counter2 = heap->NewSpaceAllocationCounter();
   CHECK_EQ(kSize, counter2 - counter1);
-  heap->CollectGarbage(NEW_SPACE);
+  heap->CollectGarbageNewSpace();
   size_t counter3 = heap->NewSpaceAllocationCounter();
   CHECK_EQ(0U, counter3 - counter2);
   // Test counter overflow.
   size_t max_counter = -1;
   heap->set_new_space_allocation_counter(max_counter - 10 * kSize);
   size_t start = heap->NewSpaceAllocationCounter();
   for (int i = 0; i < 20; i++) {
     AllocateInSpace(isolate, kSize, NEW_SPACE);
     size_t counter = heap->NewSpaceAllocationCounter();
     CHECK_EQ(kSize, counter - start);
     start = counter;
   }
 }
 
 
 TEST(OldSpaceAllocationCounter) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Heap* heap = isolate->heap();
   size_t counter1 = heap->OldGenerationAllocationCounter();
-  heap->CollectGarbage(NEW_SPACE);
-  heap->CollectGarbage(NEW_SPACE);
+  heap->CollectGarbageNewSpace();
+  heap->CollectGarbageNewSpace();
   const size_t kSize = 1024;
   AllocateInSpace(isolate, kSize, OLD_SPACE);
   size_t counter2 = heap->OldGenerationAllocationCounter();
   // TODO(ulan): replace all CHECK_LE with CHECK_EQ after v8:4148 is fixed.
   CHECK_LE(kSize, counter2 - counter1);
-  heap->CollectGarbage(NEW_SPACE);
+  heap->CollectGarbageNewSpace();
   size_t counter3 = heap->OldGenerationAllocationCounter();
   CHECK_EQ(0u, counter3 - counter2);
   AllocateInSpace(isolate, kSize, OLD_SPACE);
   heap->CollectGarbage(OLD_SPACE);
   size_t counter4 = heap->OldGenerationAllocationCounter();
   CHECK_LE(kSize, counter4 - counter3);
   // Test counter overflow.
   size_t max_counter = -1;
   heap->set_old_generation_allocation_counter(max_counter - 10 * kSize);
   size_t start = heap->OldGenerationAllocationCounter();
@@ skipping 391 matching lines @@
   {
     SharedFunctionInfo::Iterator iterator(isolate);
     while (iterator.Next()) sfi_count--;
   }
 
   CHECK_EQ(0, sfi_count);
 }
 
 }  // namespace internal
 }  // namespace v8