[heap] Add --stress-incremental-marking flag.

test/cctest/heap/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 471 matching lines @@
     const v8::WeakCallbackInfo<void>& data) {
   std::pair<v8::Persistent<v8::Value>*, int>* p =
       reinterpret_cast<std::pair<v8::Persistent<v8::Value>*, int>*>(
           data.GetParameter());
   if (p->second == 1234) WeakPointerCleared = true;
   p->first->Reset();
 }
 
 
 TEST(WeakGlobalHandlesScavenge) {
-  i::FLAG_stress_compaction = false;
+  FLAG_stress_compaction = false;
+  FLAG_stress_incremental_marking = false;
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   Factory* factory = isolate->factory();
   GlobalHandles* global_handles = isolate->global_handles();
 
   WeakPointerCleared = false;
 
   Handle<Object> h1;
   Handle<Object> h2;
 
@@ skipping 144 matching lines @@
 
   CcTest::CollectGarbage(NEW_SPACE);
 
   CHECK(!WeakPointerCleared);
   CHECK(!global_handles->IsNearDeath(h1.location()));
 
   GlobalHandles::Destroy(h1.location());
 }
 
 TEST(WeakGlobalHandlesMark) {
+  FLAG_stress_incremental_marking = false;
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   Heap* heap = isolate->heap();
   Factory* factory = isolate->factory();
   GlobalHandles* global_handles = isolate->global_handles();
 
   WeakPointerCleared = false;
 
   Handle<Object> h1;
   Handle<Object> h2;
@@ skipping 26 matching lines @@
   CHECK((*h1)->IsString());
 
   CHECK(WeakPointerCleared);
   CHECK(!GlobalHandles::IsNearDeath(h1.location()));
 
   GlobalHandles::Destroy(h1.location());
 }
 
 
 TEST(DeleteWeakGlobalHandle) {
-  i::FLAG_stress_compaction = false;
+  FLAG_stress_compaction = false;
+  FLAG_stress_incremental_marking = false;
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   Factory* factory = isolate->factory();
   GlobalHandles* global_handles = isolate->global_handles();
 
   WeakPointerCleared = false;
 
   Handle<Object> h;
 
   {
@@ skipping 18 matching lines @@
 
   CHECK(WeakPointerCleared);
 }
 
 TEST(BytecodeArray) {
   static const uint8_t kRawBytes[] = {0xc3, 0x7e, 0xa5, 0x5a};
   static const int kRawBytesSize = sizeof(kRawBytes);
   static const int kFrameSize = 32;
   static const int kParameterCount = 2;
 
-  i::FLAG_manual_evacuation_candidates_selection = true;
+  FLAG_manual_evacuation_candidates_selection = true;
+  FLAG_stress_incremental_marking = false;
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   Heap* heap = isolate->heap();
   Factory* factory = isolate->factory();
   HandleScope scope(isolate);
 
   heap::SimulateFullSpace(heap->old_space());
   Handle<FixedArray> constant_pool = factory->NewFixedArray(5, TENURED);
   for (int i = 0; i < 5; i++) {
     Handle<Object> number = factory->NewHeapNumber(i);
@@ skipping 449 matching lines @@
   delete[] str;
 
   // Add a Map object to look for.
   objs[next_objs_index++] = Handle<Map>(HeapObject::cast(*objs[0])->map());
 
   CHECK_EQ(objs_count, next_objs_index);
   CHECK_EQ(objs_count, ObjectsFoundInHeap(CcTest::heap(), objs, objs_count));
 }
 
 TEST(TestUseOfIncrementalBarrierOnCompileLazy) {
-  if (!i::FLAG_incremental_marking) return;
+  if (!FLAG_incremental_marking) return;
   // Turn off always_opt because it interferes with running the built-in for
   // the last call to g().
-  i::FLAG_always_opt = false;
-  i::FLAG_allow_natives_syntax = true;
+  FLAG_always_opt = false;
+  FLAG_allow_natives_syntax = true;
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   Factory* factory = isolate->factory();
   Heap* heap = isolate->heap();
   v8::HandleScope scope(CcTest::isolate());
 
   CompileRun(
       "function make_closure(x) {"
       "  return function() { return x + 3 };"
       "}"
@@ skipping 127 matching lines @@
 }
 
 
 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;
+  if (FLAG_gc_global || FLAG_stress_compaction ||
+      FLAG_stress_incremental_marking)
+    return;
   FLAG_retain_maps_for_n_gc = 0;
 
   static const int kNumTestContexts = 10;
 
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
   v8::Local<v8::Context> ctx[kNumTestContexts];
   if (!isolate->use_optimizer()) return;
 
   CHECK_EQ(0, CountNativeContexts());
@@ skipping 576 matching lines @@
   for (HeapObject* obj = iterator.next(); obj != NULL; obj = iterator.next()) {
     if (obj->IsJSGlobalObject()) count++;
   }
   return count;
 }
 
 
 // Test that we don't embed maps from foreign contexts into
 // optimized code.
 TEST(LeakNativeContextViaMap) {
-  i::FLAG_allow_natives_syntax = true;
+  FLAG_allow_natives_syntax = true;
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope outer_scope(isolate);
   v8::Persistent<v8::Context> ctx1p;
   v8::Persistent<v8::Context> ctx2p;
   {
     v8::HandleScope scope(isolate);
     ctx1p.Reset(isolate, v8::Context::New(isolate));
     ctx2p.Reset(isolate, v8::Context::New(isolate));
     v8::Local<v8::Context>::New(isolate, ctx1p)->Enter();
   }
@@ skipping 28 matching lines @@
   CHECK_EQ(1, NumberOfGlobalObjects());
   ctx2p.Reset();
   CcTest::CollectAllAvailableGarbage();
   CHECK_EQ(0, NumberOfGlobalObjects());
 }
 
 
 // Test that we don't embed functions from foreign contexts into
 // optimized code.
 TEST(LeakNativeContextViaFunction) {
-  i::FLAG_allow_natives_syntax = true;
+  FLAG_allow_natives_syntax = true;
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope outer_scope(isolate);
   v8::Persistent<v8::Context> ctx1p;
   v8::Persistent<v8::Context> ctx2p;
   {
     v8::HandleScope scope(isolate);
     ctx1p.Reset(isolate, v8::Context::New(isolate));
     ctx2p.Reset(isolate, v8::Context::New(isolate));
     v8::Local<v8::Context>::New(isolate, ctx1p)->Enter();
   }
@@ skipping 26 matching lines @@
   }
   CcTest::CollectAllAvailableGarbage();
   CHECK_EQ(1, NumberOfGlobalObjects());
   ctx2p.Reset();
   CcTest::CollectAllAvailableGarbage();
   CHECK_EQ(0, NumberOfGlobalObjects());
 }
 
 
 TEST(LeakNativeContextViaMapKeyed) {
-  i::FLAG_allow_natives_syntax = true;
+  FLAG_allow_natives_syntax = true;
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope outer_scope(isolate);
   v8::Persistent<v8::Context> ctx1p;
   v8::Persistent<v8::Context> ctx2p;
   {
     v8::HandleScope scope(isolate);
     ctx1p.Reset(isolate, v8::Context::New(isolate));
     ctx2p.Reset(isolate, v8::Context::New(isolate));
     v8::Local<v8::Context>::New(isolate, ctx1p)->Enter();
   }
@@ skipping 26 matching lines @@
   }
   CcTest::CollectAllAvailableGarbage();
   CHECK_EQ(1, NumberOfGlobalObjects());
   ctx2p.Reset();
   CcTest::CollectAllAvailableGarbage();
   CHECK_EQ(0, NumberOfGlobalObjects());
 }
 
 
 TEST(LeakNativeContextViaMapProto) {
-  i::FLAG_allow_natives_syntax = true;
+  FLAG_allow_natives_syntax = true;
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope outer_scope(isolate);
   v8::Persistent<v8::Context> ctx1p;
   v8::Persistent<v8::Context> ctx2p;
   {
     v8::HandleScope scope(isolate);
     ctx1p.Reset(isolate, v8::Context::New(isolate));
     ctx2p.Reset(isolate, v8::Context::New(isolate));
     v8::Local<v8::Context>::New(isolate, ctx1p)->Enter();
   }
@@ skipping 30 matching lines @@
   }
   CcTest::CollectAllAvailableGarbage();
   CHECK_EQ(1, NumberOfGlobalObjects());
   ctx2p.Reset();
   CcTest::CollectAllAvailableGarbage();
   CHECK_EQ(0, NumberOfGlobalObjects());
 }
 
 
 TEST(InstanceOfStubWriteBarrier) {
-  if (!i::FLAG_incremental_marking) return;
-  i::FLAG_allow_natives_syntax = true;
+  if (!FLAG_incremental_marking) return;
+  FLAG_stress_incremental_marking = false;
+  FLAG_allow_natives_syntax = true;
 #ifdef VERIFY_HEAP
-  i::FLAG_verify_heap = true;
+  FLAG_verify_heap = true;
 #endif
 
   CcTest::InitializeVM();
   if (!CcTest::i_isolate()->use_optimizer()) return;
-  if (i::FLAG_force_marking_deque_overflows) return;
+  if (FLAG_force_marking_deque_overflows) return;
   v8::HandleScope outer_scope(CcTest::isolate());
   v8::Local<v8::Context> ctx = CcTest::isolate()->GetCurrentContext();
 
   {
     v8::HandleScope scope(CcTest::isolate());
     CompileRun(
         "function foo () { }"
         "function mkbar () { return new (new Function(\"\")) (); }"
         "function f (x) { return (x instanceof foo); }"
         "function g () { f(mkbar()); }"
@@ skipping 39 matching lines @@
 namespace {
 
 int GetProfilerTicks(SharedFunctionInfo* shared) {
   return FLAG_ignition || FLAG_turbo ? shared->profiler_ticks()
                                      : shared->code()->profiler_ticks();
 }
 
 }  // namespace
 
 TEST(ResetSharedFunctionInfoCountersDuringIncrementalMarking) {
-  if (!i::FLAG_incremental_marking) return;
-  i::FLAG_stress_compaction = false;
-  i::FLAG_allow_natives_syntax = true;
+  if (!FLAG_incremental_marking) return;
+  FLAG_stress_compaction = false;
+  FLAG_stress_incremental_marking = false;
+  FLAG_allow_natives_syntax = true;
 #ifdef VERIFY_HEAP
-  i::FLAG_verify_heap = true;
+  FLAG_verify_heap = true;
 #endif
 
   CcTest::InitializeVM();
   if (!CcTest::i_isolate()->use_optimizer()) return;
   v8::HandleScope outer_scope(CcTest::isolate());
   v8::Local<v8::Context> ctx = CcTest::isolate()->GetCurrentContext();
 
   {
     v8::HandleScope scope(CcTest::isolate());
     CompileRun(
@@ skipping 21 matching lines @@
   heap::SimulateIncrementalMarking(CcTest::heap());
   CcTest::CollectAllGarbage();
 
   CHECK_EQ(CcTest::heap()->global_ic_age(), f->shared()->ic_age());
   CHECK_EQ(0, f->shared()->opt_count());
   CHECK_EQ(0, GetProfilerTicks(f->shared()));
 }
 
 
 TEST(ResetSharedFunctionInfoCountersDuringMarkSweep) {
-  i::FLAG_stress_compaction = false;
-  i::FLAG_allow_natives_syntax = true;
+  FLAG_stress_compaction = false;
+  FLAG_stress_incremental_marking = false;
+  FLAG_allow_natives_syntax = true;
 #ifdef VERIFY_HEAP
-  i::FLAG_verify_heap = true;
+  FLAG_verify_heap = true;
 #endif
 
   CcTest::InitializeVM();
   if (!CcTest::i_isolate()->use_optimizer()) return;
   v8::HandleScope outer_scope(CcTest::isolate());
   v8::Local<v8::Context> ctx = CcTest::isolate()->GetCurrentContext();
 
   {
     v8::HandleScope scope(CcTest::isolate());
     CompileRun(
@@ skipping 18 matching lines @@
   CcTest::isolate()->ContextDisposedNotification();
   CcTest::CollectAllGarbage();
 
   CHECK_EQ(CcTest::heap()->global_ic_age(), f->shared()->ic_age());
   CHECK_EQ(0, f->shared()->opt_count());
   CHECK_EQ(0, GetProfilerTicks(f->shared()));
 }
 
 
 HEAP_TEST(GCFlags) {
-  if (!i::FLAG_incremental_marking) return;
+  if (!FLAG_incremental_marking) return;
   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);
   CcTest::CollectAllGarbage(Heap::kReduceMemoryFootprintMask);
   CHECK_EQ(Heap::kNoGCFlags, heap->current_gc_flags_);
@@ skipping 12 matching lines @@
   CcTest::CollectGarbage(NEW_SPACE);
   // NewSpace scavenges should not overwrite the flags.
   CHECK_NE(0, heap->current_gc_flags_ & Heap::kReduceMemoryFootprintMask);
 
   CcTest::CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);
   CHECK_EQ(Heap::kNoGCFlags, heap->current_gc_flags_);
 }
 
 
 TEST(IdleNotificationFinishMarking) {
-  if (!i::FLAG_incremental_marking) return;
-  i::FLAG_allow_natives_syntax = true;
+  if (!FLAG_incremental_marking) return;
+  FLAG_stress_incremental_marking = false;
+  FLAG_allow_natives_syntax = true;
   CcTest::InitializeVM();
   const int initial_gc_count = CcTest::heap()->gc_count();
   heap::SimulateFullSpace(CcTest::heap()->old_space());
   IncrementalMarking* marking = CcTest::heap()->incremental_marking();
   marking->Stop();
   CcTest::heap()->StartIncrementalMarking(i::Heap::kNoGCFlags,
                                           i::GarbageCollectionReason::kTesting);
 
   CHECK_EQ(CcTest::heap()->gc_count(), initial_gc_count);
 
@@ skipping 26 matching lines @@
   CcTest::isolate()->IdleNotificationDeadline(
       (v8::base::TimeTicks::HighResolutionNow().ToInternalValue() /
        static_cast<double>(v8::base::Time::kMicrosecondsPerSecond)) +
       kLongIdleTime);
   CHECK_EQ(CcTest::heap()->gc_count(), initial_gc_count + 1);
 }
 
 
 // Test that HAllocateObject will always return an object in new-space.
 TEST(OptimizedAllocationAlwaysInNewSpace) {
-  i::FLAG_allow_natives_syntax = true;
+  FLAG_allow_natives_syntax = true;
   CcTest::InitializeVM();
-  if (!CcTest::i_isolate()->use_optimizer() || i::FLAG_always_opt) return;
-  if (i::FLAG_gc_global || i::FLAG_stress_compaction) return;
+  if (!CcTest::i_isolate()->use_optimizer() || FLAG_always_opt) return;
+  if (FLAG_gc_global || FLAG_stress_compaction ||
+      FLAG_stress_incremental_marking)
+    return;
   v8::HandleScope scope(CcTest::isolate());
   v8::Local<v8::Context> ctx = CcTest::isolate()->GetCurrentContext();
   heap::SimulateFullSpace(CcTest::heap()->new_space());
   AlwaysAllocateScope always_allocate(CcTest::i_isolate());
   v8::Local<v8::Value> res = CompileRun(
       "function c(x) {"
       "  this.x = x;"
       "  for (var i = 0; i < 32; i++) {"
       "    this['x' + i] = x;"
       "  }"
@@ skipping 10 matching lines @@
                   .FromJust());
 
   i::Handle<JSReceiver> o =
       v8::Utils::OpenHandle(*v8::Local<v8::Object>::Cast(res));
 
   CHECK(CcTest::heap()->InNewSpace(*o));
 }
 
 
 TEST(OptimizedPretenuringAllocationFolding) {
-  i::FLAG_allow_natives_syntax = true;
-  i::FLAG_expose_gc = true;
+  FLAG_allow_natives_syntax = true;
+  FLAG_expose_gc = true;
   CcTest::InitializeVM();
-  if (!CcTest::i_isolate()->use_optimizer() || i::FLAG_always_opt) return;
-  if (i::FLAG_gc_global || i::FLAG_stress_compaction) return;
+  if (!CcTest::i_isolate()->use_optimizer() || FLAG_always_opt) return;
+  if (FLAG_gc_global || FLAG_stress_compaction ||
+      FLAG_stress_incremental_marking)
+    return;
   v8::HandleScope scope(CcTest::isolate());
   v8::Local<v8::Context> ctx = CcTest::isolate()->GetCurrentContext();
   // Grow new space unitl maximum capacity reached.
   while (!CcTest::heap()->new_space()->IsAtMaximumCapacity()) {
     CcTest::heap()->new_space()->Grow();
   }
 
   i::ScopedVector<char> source(1024);
   i::SNPrintF(
       source,
@@ skipping 26 matching lines @@
       v8::Utils::OpenHandle(*v8::Local<v8::Object>::Cast(res));
   CHECK(CcTest::heap()->InOldSpace(*o));
   CHECK(CcTest::heap()->InOldSpace(*int_array_handle));
   CHECK(CcTest::heap()->InOldSpace(int_array_handle->elements()));
   CHECK(CcTest::heap()->InOldSpace(*double_array_handle));
   CHECK(CcTest::heap()->InOldSpace(double_array_handle->elements()));
 }
 
 
 TEST(OptimizedPretenuringObjectArrayLiterals) {
-  i::FLAG_allow_natives_syntax = true;
-  i::FLAG_expose_gc = true;
+  FLAG_allow_natives_syntax = true;
+  FLAG_expose_gc = true;
   CcTest::InitializeVM();
-  if (!CcTest::i_isolate()->use_optimizer() || i::FLAG_always_opt) return;
-  if (i::FLAG_gc_global || i::FLAG_stress_compaction) return;
+  if (!CcTest::i_isolate()->use_optimizer() || FLAG_always_opt) return;
+  if (FLAG_gc_global || FLAG_stress_compaction ||
+      FLAG_stress_incremental_marking)
+    return;
   v8::HandleScope scope(CcTest::isolate());
 
   // Grow new space unitl maximum capacity reached.
   while (!CcTest::heap()->new_space()->IsAtMaximumCapacity()) {
     CcTest::heap()->new_space()->Grow();
   }
 
   i::ScopedVector<char> source(1024);
   i::SNPrintF(
       source,
@@ skipping 15 matching lines @@
 
   i::Handle<JSObject> o = Handle<JSObject>::cast(
       v8::Utils::OpenHandle(*v8::Local<v8::Object>::Cast(res)));
 
   CHECK(CcTest::heap()->InOldSpace(o->elements()));
   CHECK(CcTest::heap()->InOldSpace(*o));
 }
 
 
 TEST(OptimizedPretenuringMixedInObjectProperties) {
-  i::FLAG_allow_natives_syntax = true;
-  i::FLAG_expose_gc = true;
+  FLAG_allow_natives_syntax = true;
+  FLAG_expose_gc = true;
   CcTest::InitializeVM();
-  if (!CcTest::i_isolate()->use_optimizer() || i::FLAG_always_opt) return;
-  if (i::FLAG_gc_global || i::FLAG_stress_compaction) return;
+  if (!CcTest::i_isolate()->use_optimizer() || FLAG_always_opt) return;
+  if (FLAG_gc_global || FLAG_stress_compaction ||
+      FLAG_stress_incremental_marking)
+    return;
   v8::HandleScope scope(CcTest::isolate());
 
   // Grow new space unitl maximum capacity reached.
   while (!CcTest::heap()->new_space()->IsAtMaximumCapacity()) {
     CcTest::heap()->new_space()->Grow();
   }
 
 
   i::ScopedVector<char> source(1024);
   i::SNPrintF(
@@ skipping 33 matching lines @@
   if (!inner_object->IsUnboxedDoubleField(idx1)) {
     CHECK(CcTest::heap()->InOldSpace(inner_object->RawFastPropertyAt(idx1)));
   } else {
     CHECK_EQ(2.2, inner_object->RawFastDoublePropertyAt(idx1));
   }
   CHECK(CcTest::heap()->InOldSpace(inner_object->RawFastPropertyAt(idx2)));
 }
 
 
 TEST(OptimizedPretenuringDoubleArrayProperties) {
-  i::FLAG_allow_natives_syntax = true;
-  i::FLAG_expose_gc = true;
+  FLAG_allow_natives_syntax = true;
+  FLAG_expose_gc = true;
   CcTest::InitializeVM();
-  if (!CcTest::i_isolate()->use_optimizer() || i::FLAG_always_opt) return;
-  if (i::FLAG_gc_global || i::FLAG_stress_compaction) return;
+  if (!CcTest::i_isolate()->use_optimizer() || FLAG_always_opt) return;
+  if (FLAG_gc_global || FLAG_stress_compaction ||
+      FLAG_stress_incremental_marking)
+    return;
   v8::HandleScope scope(CcTest::isolate());
 
   // Grow new space unitl maximum capacity reached.
   while (!CcTest::heap()->new_space()->IsAtMaximumCapacity()) {
     CcTest::heap()->new_space()->Grow();
   }
 
   i::ScopedVector<char> source(1024);
   i::SNPrintF(
       source,
@@ skipping 15 matching lines @@
 
   i::Handle<JSObject> o = Handle<JSObject>::cast(
       v8::Utils::OpenHandle(*v8::Local<v8::Object>::Cast(res)));
 
   CHECK(CcTest::heap()->InOldSpace(*o));
   CHECK(CcTest::heap()->InOldSpace(o->properties()));
 }
 
 
 TEST(OptimizedPretenuringdoubleArrayLiterals) {
-  i::FLAG_allow_natives_syntax = true;
-  i::FLAG_expose_gc = true;
+  FLAG_allow_natives_syntax = true;
+  FLAG_expose_gc = true;
   CcTest::InitializeVM();
-  if (!CcTest::i_isolate()->use_optimizer() || i::FLAG_always_opt) return;
-  if (i::FLAG_gc_global || i::FLAG_stress_compaction) return;
+  if (!CcTest::i_isolate()->use_optimizer() || FLAG_always_opt) return;
+  if (FLAG_gc_global || FLAG_stress_compaction ||
+      FLAG_stress_incremental_marking)
+    return;
   v8::HandleScope scope(CcTest::isolate());
 
   // Grow new space unitl maximum capacity reached.
   while (!CcTest::heap()->new_space()->IsAtMaximumCapacity()) {
     CcTest::heap()->new_space()->Grow();
   }
 
   i::ScopedVector<char> source(1024);
   i::SNPrintF(
       source,
@@ skipping 15 matching lines @@
 
   i::Handle<JSObject> o = Handle<JSObject>::cast(
       v8::Utils::OpenHandle(*v8::Local<v8::Object>::Cast(res)));
 
   CHECK(CcTest::heap()->InOldSpace(o->elements()));
   CHECK(CcTest::heap()->InOldSpace(*o));
 }
 
 
 TEST(OptimizedPretenuringNestedMixedArrayLiterals) {
-  i::FLAG_allow_natives_syntax = true;
-  i::FLAG_expose_gc = true;
+  FLAG_allow_natives_syntax = true;
+  FLAG_expose_gc = true;
   CcTest::InitializeVM();
-  if (!CcTest::i_isolate()->use_optimizer() || i::FLAG_always_opt) return;
-  if (i::FLAG_gc_global || i::FLAG_stress_compaction) return;
+  if (!CcTest::i_isolate()->use_optimizer() || FLAG_always_opt) return;
+  if (FLAG_gc_global || FLAG_stress_compaction ||
+      FLAG_stress_incremental_marking)
+    return;
   v8::HandleScope scope(CcTest::isolate());
   v8::Local<v8::Context> ctx = CcTest::isolate()->GetCurrentContext();
   // Grow new space unitl maximum capacity reached.
   while (!CcTest::heap()->new_space()->IsAtMaximumCapacity()) {
     CcTest::heap()->new_space()->Grow();
   }
 
   i::ScopedVector<char> source(1024);
   i::SNPrintF(
       source,
@@ skipping 25 matching lines @@
       v8::Utils::OpenHandle(*v8::Local<v8::Object>::Cast(res)));
   CHECK(CcTest::heap()->InOldSpace(*o));
   CHECK(CcTest::heap()->InOldSpace(*int_array_handle));
   CHECK(CcTest::heap()->InOldSpace(int_array_handle->elements()));
   CHECK(CcTest::heap()->InOldSpace(*double_array_handle));
   CHECK(CcTest::heap()->InOldSpace(double_array_handle->elements()));
 }
 
 
 TEST(OptimizedPretenuringNestedObjectLiterals) {
-  i::FLAG_allow_natives_syntax = true;
-  i::FLAG_expose_gc = true;
+  FLAG_allow_natives_syntax = true;
+  FLAG_expose_gc = true;
   CcTest::InitializeVM();
-  if (!CcTest::i_isolate()->use_optimizer() || i::FLAG_always_opt) return;
-  if (i::FLAG_gc_global || i::FLAG_stress_compaction) return;
+  if (!CcTest::i_isolate()->use_optimizer() || FLAG_always_opt) return;
+  if (FLAG_gc_global || FLAG_stress_compaction ||
+      FLAG_stress_incremental_marking)
+    return;
   v8::HandleScope scope(CcTest::isolate());
   v8::Local<v8::Context> ctx = CcTest::isolate()->GetCurrentContext();
   // Grow new space unitl maximum capacity reached.
   while (!CcTest::heap()->new_space()->IsAtMaximumCapacity()) {
     CcTest::heap()->new_space()->Grow();
   }
 
   i::ScopedVector<char> source(1024);
   i::SNPrintF(
       source,
@@ skipping 26 matching lines @@
       v8::Utils::OpenHandle(*v8::Local<v8::Object>::Cast(res)));
   CHECK(CcTest::heap()->InOldSpace(*o));
   CHECK(CcTest::heap()->InOldSpace(*int_array_handle_1));
   CHECK(CcTest::heap()->InOldSpace(int_array_handle_1->elements()));
   CHECK(CcTest::heap()->InOldSpace(*int_array_handle_2));
   CHECK(CcTest::heap()->InOldSpace(int_array_handle_2->elements()));
 }
 
 
 TEST(OptimizedPretenuringNestedDoubleLiterals) {
-  i::FLAG_allow_natives_syntax = true;
-  i::FLAG_expose_gc = true;
+  FLAG_allow_natives_syntax = true;
+  FLAG_expose_gc = true;
   CcTest::InitializeVM();
-  if (!CcTest::i_isolate()->use_optimizer() || i::FLAG_always_opt) return;
-  if (i::FLAG_gc_global || i::FLAG_stress_compaction) return;
+  if (!CcTest::i_isolate()->use_optimizer() || FLAG_always_opt) return;
+  if (FLAG_gc_global || FLAG_stress_compaction ||
+      FLAG_stress_incremental_marking)
+    return;
   v8::HandleScope scope(CcTest::isolate());
   v8::Local<v8::Context> ctx = CcTest::isolate()->GetCurrentContext();
   // Grow new space unitl maximum capacity reached.
   while (!CcTest::heap()->new_space()->IsAtMaximumCapacity()) {
     CcTest::heap()->new_space()->Grow();
   }
 
   i::ScopedVector<char> source(1024);
   i::SNPrintF(
       source,
@@ skipping 27 matching lines @@
   CHECK(CcTest::heap()->InOldSpace(*o));
   CHECK(CcTest::heap()->InOldSpace(*double_array_handle_1));
   CHECK(CcTest::heap()->InOldSpace(double_array_handle_1->elements()));
   CHECK(CcTest::heap()->InOldSpace(*double_array_handle_2));
   CHECK(CcTest::heap()->InOldSpace(double_array_handle_2->elements()));
 }
 
 
 // Test regular array literals allocation.
 TEST(OptimizedAllocationArrayLiterals) {
-  i::FLAG_allow_natives_syntax = true;
+  FLAG_allow_natives_syntax = true;
   CcTest::InitializeVM();
-  if (!CcTest::i_isolate()->use_optimizer() || i::FLAG_always_opt) return;
-  if (i::FLAG_gc_global || i::FLAG_stress_compaction) return;
+  if (!CcTest::i_isolate()->use_optimizer() || FLAG_always_opt) return;
+  if (FLAG_gc_global || FLAG_stress_compaction ||
+      FLAG_stress_incremental_marking)
+    return;
   v8::HandleScope scope(CcTest::isolate());
   v8::Local<v8::Context> ctx = CcTest::isolate()->GetCurrentContext();
   v8::Local<v8::Value> res = CompileRun(
       "function f() {"
       "  var numbers = new Array(1, 2, 3);"
       "  numbers[0] = 3.14;"
       "  return numbers;"
       "};"
       "f(); f(); f();"
       "%OptimizeFunctionOnNextCall(f);"
@@ skipping 12 matching lines @@
 
 
 static int CountMapTransitions(Map* map) {
   return TransitionArray::NumberOfTransitions(map->raw_transitions());
 }
 
 
 // Test that map transitions are cleared and maps are collected with
 // incremental marking as well.
 TEST(Regress1465) {
-  if (!i::FLAG_incremental_marking) return;
-  i::FLAG_stress_compaction = false;
-  i::FLAG_allow_natives_syntax = true;
-  i::FLAG_trace_incremental_marking = true;
-  i::FLAG_retain_maps_for_n_gc = 0;
+  if (!FLAG_incremental_marking) return;
+  FLAG_stress_compaction = false;
+  FLAG_stress_incremental_marking = false;
+  FLAG_allow_natives_syntax = true;
+  FLAG_trace_incremental_marking = true;
+  FLAG_retain_maps_for_n_gc = 0;
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   v8::Local<v8::Context> ctx = CcTest::isolate()->GetCurrentContext();
   static const int transitions_count = 256;
 
   CompileRun("function F() {}");
   {
     AlwaysAllocateScope always_allocate(CcTest::i_isolate());
     for (int i = 0; i < transitions_count; i++) {
       EmbeddedVector<char, 64> buffer;
@@ skipping 42 matching lines @@
               .ToLocalChecked())));
 }
 
 
 static void AddPropertyTo(
     int gc_count, Handle<JSObject> object, const char* property_name) {
   Isolate* isolate = CcTest::i_isolate();
   Factory* factory = isolate->factory();
   Handle<String> prop_name = factory->InternalizeUtf8String(property_name);
   Handle<Smi> twenty_three(Smi::FromInt(23), isolate);
-  i::FLAG_gc_interval = gc_count;
-  i::FLAG_gc_global = true;
-  i::FLAG_retain_maps_for_n_gc = 0;
+  FLAG_gc_interval = gc_count;
+  FLAG_gc_global = true;
+  FLAG_retain_maps_for_n_gc = 0;
   CcTest::heap()->set_allocation_timeout(gc_count);
   JSReceiver::SetProperty(object, prop_name, twenty_three, SLOPPY).Check();
 }
 
 
 TEST(TransitionArrayShrinksDuringAllocToZero) {
-  i::FLAG_stress_compaction = false;
-  i::FLAG_allow_natives_syntax = true;
+  FLAG_stress_compaction = false;
+  FLAG_stress_incremental_marking = false;
+  FLAG_allow_natives_syntax = true;
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   static const int transitions_count = 10;
   CompileRun("function F() { }");
   AddTransitions(transitions_count);
   CompileRun("var root = new F;");
   Handle<JSObject> root = GetByName("root");
 
   // Count number of live transitions before marking.
   int transitions_before = CountMapTransitions(root->map());
   CHECK_EQ(transitions_count, transitions_before);
 
   // Get rid of o
   CompileRun("o = new F;"
              "root = new F");
   root = GetByName("root");
   AddPropertyTo(2, root, "funny");
   CcTest::CollectGarbage(NEW_SPACE);
 
   // Count number of live transitions after marking.  Note that one transition
   // is left, because 'o' still holds an instance of one transition target.
   int transitions_after = CountMapTransitions(
       Map::cast(root->map()->GetBackPointer()));
   CHECK_EQ(1, transitions_after);
 }
 
 
 TEST(TransitionArrayShrinksDuringAllocToOne) {
-  i::FLAG_stress_compaction = false;
-  i::FLAG_allow_natives_syntax = true;
+  FLAG_stress_compaction = false;
+  FLAG_stress_incremental_marking = false;
+  FLAG_allow_natives_syntax = true;
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   static const int transitions_count = 10;
   CompileRun("function F() {}");
   AddTransitions(transitions_count);
   CompileRun("var root = new F;");
   Handle<JSObject> root = GetByName("root");
 
   // Count number of live transitions before marking.
   int transitions_before = CountMapTransitions(root->map());
   CHECK_EQ(transitions_count, transitions_before);
 
   root = GetByName("root");
   AddPropertyTo(2, root, "funny");
   CcTest::CollectGarbage(NEW_SPACE);
 
   // Count number of live transitions after marking.  Note that one transition
   // is left, because 'o' still holds an instance of one transition target.
   int transitions_after = CountMapTransitions(
       Map::cast(root->map()->GetBackPointer()));
   CHECK_EQ(2, transitions_after);
 }
 
 
 TEST(TransitionArrayShrinksDuringAllocToOnePropertyFound) {
-  i::FLAG_stress_compaction = false;
-  i::FLAG_allow_natives_syntax = true;
+  FLAG_stress_compaction = false;
+  FLAG_stress_incremental_marking = false;
+  FLAG_allow_natives_syntax = true;
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   static const int transitions_count = 10;
   CompileRun("function F() {}");
   AddTransitions(transitions_count);
   CompileRun("var root = new F;");
   Handle<JSObject> root = GetByName("root");
 
   // Count number of live transitions before marking.
   int transitions_before = CountMapTransitions(root->map());
   CHECK_EQ(transitions_count, transitions_before);
 
   root = GetByName("root");
   AddPropertyTo(0, root, "prop9");
   CcTest::CollectGarbage(OLD_SPACE);
 
   // Count number of live transitions after marking.  Note that one transition
   // is left, because 'o' still holds an instance of one transition target.
   int transitions_after = CountMapTransitions(
       Map::cast(root->map()->GetBackPointer()));
   CHECK_EQ(1, transitions_after);
 }
 
 
 TEST(TransitionArraySimpleToFull) {
-  i::FLAG_stress_compaction = false;
-  i::FLAG_allow_natives_syntax = true;
+  FLAG_stress_compaction = false;
+  FLAG_stress_incremental_marking = false;
+  FLAG_allow_natives_syntax = true;
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   static const int transitions_count = 1;
   CompileRun("function F() {}");
   AddTransitions(transitions_count);
   CompileRun("var root = new F;");
   Handle<JSObject> root = GetByName("root");
 
   // Count number of live transitions before marking.
   int transitions_before = CountMapTransitions(root->map());
   CHECK_EQ(transitions_count, transitions_before);
 
   CompileRun("o = new F;"
              "root = new F");
   root = GetByName("root");
   CHECK(TransitionArray::IsSimpleTransition(root->map()->raw_transitions()));
   AddPropertyTo(2, root, "happy");
 
   // Count number of live transitions after marking.  Note that one transition
   // is left, because 'o' still holds an instance of one transition target.
   int transitions_after = CountMapTransitions(
       Map::cast(root->map()->GetBackPointer()));
   CHECK_EQ(1, transitions_after);
 }
 #endif  // DEBUG
 
 
 TEST(Regress2143a) {
-  i::FLAG_incremental_marking = true;
+  FLAG_incremental_marking = true;
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
 
   // Prepare a map transition from the root object together with a yet
   // untransitioned root object.
   CompileRun("var root = new Object;"
              "root.foo = 0;"
              "root = new Object;");
 
   heap::SimulateIncrementalMarking(CcTest::heap());
@@ skipping 18 matching lines @@
           ->Get(CcTest::isolate()->GetCurrentContext(), v8_str("root"))
           .ToLocalChecked()));
 
   // The root object should be in a sane state.
   CHECK(root->IsJSObject());
   CHECK(root->map()->IsMap());
 }
 
 
 TEST(Regress2143b) {
-  i::FLAG_incremental_marking = true;
-  i::FLAG_allow_natives_syntax = true;
+  FLAG_incremental_marking = true;
+  FLAG_allow_natives_syntax = true;
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
 
   // Prepare a map transition from the root object together with a yet
   // untransitioned root object.
   CompileRun("var root = new Object;"
              "root.foo = 0;"
              "root = new Object;");
 
   heap::SimulateIncrementalMarking(CcTest::heap());
@@ skipping 22 matching lines @@
           .ToLocalChecked()));
 
   // The root object should be in a sane state.
   CHECK(root->IsJSObject());
   CHECK(root->map()->IsMap());
 }
 
 
 TEST(ReleaseOverReservedPages) {
   if (FLAG_never_compact) return;
-  i::FLAG_trace_gc = true;
+  FLAG_trace_gc = true;
   // The optimizer can allocate stuff, messing up the test.
-  i::FLAG_opt = false;
-  i::FLAG_always_opt = false;
+  FLAG_opt = false;
+  FLAG_always_opt = false;
   // Parallel compaction increases fragmentation, depending on how existing
   // memory is distributed. Since this is non-deterministic because of
   // concurrent sweeping, we disable it for this test.
-  i::FLAG_parallel_compaction = false;
+  FLAG_parallel_compaction = false;
   // Concurrent sweeping adds non determinism, depending on when memory is
   // available for further reuse.
-  i::FLAG_concurrent_sweeping = false;
+  FLAG_concurrent_sweeping = false;
   // Fast evacuation of pages may result in a different page count in old space.
-  i::FLAG_page_promotion = false;
+  FLAG_page_promotion = false;
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   // If there's snapshot available, we don't know whether 20 small arrays will
   // fit on the initial pages.
   if (!isolate->snapshot_available()) return;
   Factory* factory = isolate->factory();
   Heap* heap = isolate->heap();
   v8::HandleScope scope(CcTest::isolate());
   static const int number_of_test_pages = 20;
 
@@ skipping 36 matching lines @@
 void MockUseCounterCallback(v8::Isolate* isolate,
                             v8::Isolate::UseCounterFeature feature) {
   isolate->GetCurrentContext();
   if (feature == v8::Isolate::kForcedGC) {
     forced_gc_counter++;
   }
 }
 
 
 TEST(CountForcedGC) {
-  i::FLAG_expose_gc = true;
+  FLAG_expose_gc = true;
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   v8::HandleScope scope(CcTest::isolate());
 
   isolate->SetUseCounterCallback(MockUseCounterCallback);
 
   forced_gc_counter = 0;
   const char* source = "gc();";
   CompileRun(source);
   CHECK_GT(forced_gc_counter, 0);
@@ skipping 14 matching lines @@
 
   OFStream os(stdout);
   g->shared()->Print(os);
   os << std::endl;
 }
 #endif  // OBJECT_PRINT
 
 
 TEST(IncrementalMarkingPreservesMonomorphicCallIC) {
   if (!FLAG_incremental_marking) return;
-  if (i::FLAG_always_opt) return;
+  if (FLAG_always_opt) return;
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   v8::Local<v8::Value> fun1, fun2;
   v8::Local<v8::Context> ctx = CcTest::isolate()->GetCurrentContext();
   {
     CompileRun("function fun() {};");
     fun1 = CcTest::global()->Get(ctx, v8_str("fun")).ToLocalChecked();
   }
 
   {
@@ skipping 53 matching lines @@
     LoadICNexus nexus(vector, slot);
     CHECK(nexus.StateFromFeedback() == desired_state);
   } else {
     CHECK(vector->IsKeyedLoadIC(slot));
     KeyedLoadICNexus nexus(vector, slot);
     CHECK(nexus.StateFromFeedback() == desired_state);
   }
 }
 
 TEST(IncrementalMarkingPreservesMonomorphicConstructor) {
-  if (!i::FLAG_incremental_marking) return;
-  if (i::FLAG_always_opt) return;
+  if (!FLAG_incremental_marking) return;
+  if (FLAG_always_opt) return;
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   v8::Local<v8::Context> ctx = CcTest::isolate()->GetCurrentContext();
   // Prepare function f that contains a monomorphic IC for object
   // originating from the same native context.
   CompileRun(
       "function fun() { this.x = 1; };"
       "function f(o) { return new o(); } f(fun); f(fun);");
   Handle<JSFunction> f = Handle<JSFunction>::cast(
       v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
           CcTest::global()->Get(ctx, v8_str("f")).ToLocalChecked())));
 
   Handle<FeedbackVector> vector(f->feedback_vector());
   CHECK(vector->Get(FeedbackSlot(0))->IsWeakCell());
 
   heap::SimulateIncrementalMarking(CcTest::heap());
   CcTest::CollectAllGarbage();
 
   CHECK(vector->Get(FeedbackSlot(0))->IsWeakCell());
 }
 
 TEST(IncrementalMarkingPreservesMonomorphicIC) {
-  if (!i::FLAG_incremental_marking) return;
-  if (i::FLAG_always_opt) return;
+  if (!FLAG_incremental_marking) return;
+  if (FLAG_always_opt) return;
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   v8::Local<v8::Context> ctx = CcTest::isolate()->GetCurrentContext();
   // Prepare function f that contains a monomorphic IC for object
   // originating from the same native context.
   CompileRun("function fun() { this.x = 1; }; var obj = new fun();"
              "function f(o) { return o.x; } f(obj); f(obj);");
   Handle<JSFunction> f = Handle<JSFunction>::cast(
       v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
           CcTest::global()->Get(ctx, v8_str("f")).ToLocalChecked())));
 
   CheckVectorIC(f, 0, MONOMORPHIC);
 
   heap::SimulateIncrementalMarking(CcTest::heap());
   CcTest::CollectAllGarbage();
 
   CheckVectorIC(f, 0, MONOMORPHIC);
 }
 
 TEST(IncrementalMarkingPreservesPolymorphicIC) {
-  if (!i::FLAG_incremental_marking) return;
-  if (i::FLAG_always_opt) return;
+  if (!FLAG_incremental_marking) return;
+  if (FLAG_always_opt) return;
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   v8::Local<v8::Value> obj1, obj2;
   v8::Local<v8::Context> ctx = CcTest::isolate()->GetCurrentContext();
 
   {
     LocalContext env;
     CompileRun("function fun() { this.x = 1; }; var obj = new fun();");
     obj1 = env->Global()->Get(env.local(), v8_str("obj")).ToLocalChecked();
   }
@@ skipping 16 matching lines @@
   CheckVectorIC(f, 0, POLYMORPHIC);
 
   // Fire context dispose notification.
   heap::SimulateIncrementalMarking(CcTest::heap());
   CcTest::CollectAllGarbage();
 
   CheckVectorIC(f, 0, POLYMORPHIC);
 }
 
 TEST(ContextDisposeDoesntClearPolymorphicIC) {
-  if (!i::FLAG_incremental_marking) return;
-  if (i::FLAG_always_opt) return;
+  if (!FLAG_incremental_marking) return;
+  if (FLAG_always_opt) return;
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   v8::Local<v8::Value> obj1, obj2;
   v8::Local<v8::Context> ctx = CcTest::isolate()->GetCurrentContext();
 
   {
     LocalContext env;
     CompileRun("function fun() { this.x = 1; }; var obj = new fun();");
     obj1 = env->Global()->Get(env.local(), v8_str("obj")).ToLocalChecked();
   }
@@ skipping 75 matching lines @@
   i_isolate->heap()->CollectAllAvailableGarbage(
       i::GarbageCollectionReason::kTesting);
 
   // External source has been released.
   CHECK(resource->IsDisposed());
   delete resource;
 }
 
 
 UNINITIALIZED_TEST(ReleaseStackTraceData) {
-  if (i::FLAG_always_opt) {
+  if (FLAG_always_opt) {
     // TODO(ulan): Remove this once the memory leak via code_next_link is fixed.
     // See: https://codereview.chromium.org/181833004/
     return;
   }
   FLAG_use_ic = false;  // ICs retain objects.
   FLAG_concurrent_recompilation = false;
   v8::Isolate::CreateParams create_params;
   create_params.array_buffer_allocator = CcTest::array_buffer_allocator();
   v8::Isolate* isolate = v8::Isolate::New(create_params);
   {
@@ skipping 38 matching lines @@
     ReleaseStackTraceDataTest(isolate, source1, getter);
     ReleaseStackTraceDataTest(isolate, source2, getter);
     ReleaseStackTraceDataTest(isolate, source3, getter);
     ReleaseStackTraceDataTest(isolate, source4, getter);
   }
   isolate->Dispose();
 }
 
 
 TEST(Regress159140) {
-  if (!i::FLAG_incremental_marking) return;
-  i::FLAG_allow_natives_syntax = true;
+  if (!FLAG_incremental_marking) return;
+  FLAG_allow_natives_syntax = true;
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   LocalContext env;
   Heap* heap = isolate->heap();
   HandleScope scope(isolate);
 
   // Perform one initial GC to enable code flushing.
   CcTest::CollectAllGarbage();
 
   // Prepare several closures that are all eligible for code flushing
@@ skipping 39 matching lines @@
   heap::SimulateIncrementalMarking(heap);
   CompileRun("%OptimizeFunctionOnNextCall(g); g(3);");
   CcTest::CollectAllGarbage();
 
   // Unoptimized code is missing and the deoptimizer will go ballistic.
   CompileRun("g('bozo');");
 }
 
 
 TEST(Regress165495) {
-  if (!i::FLAG_incremental_marking) return;
-  i::FLAG_allow_natives_syntax = true;
+  if (!FLAG_incremental_marking) return;
+  FLAG_allow_natives_syntax = true;
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   Heap* heap = isolate->heap();
   HandleScope scope(isolate);
 
   // Perform one initial GC to enable code flushing.
   CcTest::CollectAllGarbage();
 
   // Prepare an optimized closure that the optimized code map will get
   // populated. Then age the unoptimized code to trigger code flushing
@@ skipping 24 matching lines @@
   // even though it still is cached in the optimized code map.
   heap::SimulateIncrementalMarking(heap);
   CcTest::CollectAllGarbage();
 
   // Make a new closure that will get code installed from the code map.
   // Unoptimized code is missing and the deoptimizer will go ballistic.
   CompileRun("var g = mkClosure(); g('bozo');");
 }
 
 TEST(Regress169928) {
-  i::FLAG_allow_natives_syntax = true;
-  i::FLAG_opt = false;
+  FLAG_allow_natives_syntax = true;
+  FLAG_opt = false;
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   LocalContext env;
   Factory* factory = isolate->factory();
   v8::HandleScope scope(CcTest::isolate());
 
   // 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;
+  if (FLAG_gc_global || FLAG_stress_compaction ||
+      FLAG_stress_incremental_marking)
+    return;
 
   // Prepare the environment
   CompileRun("function fastliteralcase(literal, value) {"
              "    literal[0] = value;"
              "    return literal;"
              "}"
              "function get_standard_literal() {"
              "    var literal = [1, 2, 3];"
              "    return literal;"
              "}"
@@ skipping 49 matching lines @@
   AlwaysAllocateScope aa_scope(isolate);
   v8::Script::Compile(env.local(), mote_code_string)
       .ToLocalChecked()
       ->Run(env.local())
       .ToLocalChecked();
 }
 
 
 #ifdef DEBUG
 TEST(Regress513507) {
-  i::FLAG_allow_natives_syntax = true;
-  i::FLAG_gc_global = true;
+  FLAG_allow_natives_syntax = true;
+  FLAG_gc_global = true;
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   LocalContext env;
   Heap* heap = isolate->heap();
   HandleScope scope(isolate);
 
   // Prepare function whose optimized code map we can use.
   Handle<SharedFunctionInfo> shared;
   {
     HandleScope inner_scope(isolate);
@@ skipping 28 matching lines @@
   heap->set_allocation_timeout(5);
   FLAG_gc_interval = 1000;
   for (int i = 0; i < 10; ++i) {
     BailoutId id = BailoutId(i + 1);
     Context::AddToOSROptimizedCodeCache(context, shared, code, id);
   }
 }
 #endif  // DEBUG
 
 TEST(Regress513496) {
-  i::FLAG_allow_natives_syntax = true;
+  FLAG_allow_natives_syntax = true;
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
 
   // Perfrom one initial GC to enable code flushing.
   CcTest::CollectAllGarbage();
 
   // Prepare an optimized closure with containing an inlined function. Then age
   // the inlined unoptimized code to trigger code flushing but make sure the
   // outer optimized code is kept in the optimized code map.
@@ skipping 39 matching lines @@
   // though the optimized code for 'f' is reachable via the optimized code map.
   CcTest::CollectAllGarbage();
 
   // Make a new closure that will get code installed from the code map.
   // Unoptimized code is missing and the deoptimizer will go ballistic.
   CompileRun("var h = mkClosure(); h('bozo');");
 }
 
 
 TEST(LargeObjectSlotRecording) {
-  if (!i::FLAG_incremental_marking) return;
+  if (!FLAG_incremental_marking) return;
   FLAG_manual_evacuation_candidates_selection = true;
+  FLAG_stress_incremental_marking = false;
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   Heap* heap = isolate->heap();
   HandleScope scope(isolate);
 
   // Create an object on an evacuation candidate.
   heap::SimulateFullSpace(heap->old_space());
   Handle<FixedArray> lit = isolate->factory()->NewFixedArray(4, TENURED);
   Page* evac_page = Page::FromAddress(lit->address());
   heap::ForceEvacuationCandidate(evac_page);
@@ skipping 72 matching lines @@
   }
   // This big step should be sufficient to mark the whole array.
   marking->Step(100 * MB, IncrementalMarking::NO_GC_VIA_STACK_GUARD,
                 IncrementalMarking::FORCE_COMPLETION, StepOrigin::kV8);
   CHECK(marking->IsComplete() ||
         marking->IsReadyToOverApproximateWeakClosure());
 }
 
 
 TEST(DisableInlineAllocation) {
-  i::FLAG_allow_natives_syntax = true;
+  FLAG_allow_natives_syntax = true;
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   CompileRun("function test() {"
              "  var x = [];"
              "  for (var i = 0; i < 10; i++) {"
              "    x[i] = [ {}, [1,2,3], [1,x,3] ];"
              "  }"
              "}"
              "function run() {"
              "  %OptimizeFunctionOnNextCall(test);"
@@ skipping 19 matching lines @@
   for (Object* site = heap->allocation_sites_list();
        !(site->IsUndefined(heap->isolate()));
        site = AllocationSite::cast(site)->weak_next()) {
     count++;
   }
   return count;
 }
 
 
 TEST(EnsureAllocationSiteDependentCodesProcessed) {
-  if (i::FLAG_always_opt || !i::FLAG_opt) return;
-  i::FLAG_allow_natives_syntax = true;
+  if (FLAG_always_opt || !FLAG_opt) return;
+  FLAG_allow_natives_syntax = true;
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   v8::internal::Heap* heap = CcTest::heap();
   GlobalHandles* global_handles = isolate->global_handles();
 
   if (!isolate->use_optimizer()) return;
 
   // The allocation site at the head of the list is ours.
   Handle<AllocationSite> site;
   {
@@ skipping 49 matching lines @@
   }
 
   // The site still exists because of our global handle, but the code is no
   // longer referred to by dependent_code().
   CHECK(site->dependent_code()->object_at(0)->IsWeakCell() &&
         WeakCell::cast(site->dependent_code()->object_at(0))->cleared());
 }
 
 
 TEST(CellsInOptimizedCodeAreWeak) {
-  if (i::FLAG_always_opt || !i::FLAG_opt) return;
-  i::FLAG_allow_natives_syntax = true;
+  if (FLAG_always_opt || !FLAG_opt) return;
+  FLAG_allow_natives_syntax = true;
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   v8::internal::Heap* heap = CcTest::heap();
 
   if (!isolate->use_optimizer()) return;
   HandleScope outer_scope(heap->isolate());
   Handle<Code> code;
   {
     LocalContext context;
     HandleScope scope(heap->isolate());
@@ skipping 22 matching lines @@
   // Now make sure that a gc should get rid of the function
   for (int i = 0; i < 4; i++) {
     CcTest::CollectAllGarbage();
   }
 
   CHECK(code->marked_for_deoptimization());
 }
 
 
 TEST(ObjectsInOptimizedCodeAreWeak) {
-  if (i::FLAG_always_opt || !i::FLAG_opt) return;
-  i::FLAG_allow_natives_syntax = true;
+  if (FLAG_always_opt || !FLAG_opt) return;
+  FLAG_allow_natives_syntax = true;
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   v8::internal::Heap* heap = CcTest::heap();
 
   if (!isolate->use_optimizer()) return;
   HandleScope outer_scope(heap->isolate());
   Handle<Code> code;
   {
     LocalContext context;
     HandleScope scope(heap->isolate());
@@ skipping 19 matching lines @@
 
   // Now make sure that a gc should get rid of the function
   for (int i = 0; i < 4; i++) {
     CcTest::CollectAllGarbage();
   }
 
   CHECK(code->marked_for_deoptimization());
 }
 
 TEST(NewSpaceObjectsInOptimizedCode) {
-  if (i::FLAG_always_opt || !i::FLAG_opt || i::FLAG_turbo) return;
-  i::FLAG_allow_natives_syntax = true;
+  if (FLAG_always_opt || !FLAG_opt || FLAG_turbo) return;
+  FLAG_allow_natives_syntax = true;
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   v8::internal::Heap* heap = CcTest::heap();
 
   if (!isolate->use_optimizer()) return;
   HandleScope outer_scope(heap->isolate());
   Handle<Code> code;
   {
     LocalContext context;
     HandleScope scope(heap->isolate());
@@ skipping 39 matching lines @@
 
   // Now make sure that a gc should get rid of the function
   for (int i = 0; i < 4; i++) {
     CcTest::CollectAllGarbage();
   }
 
   CHECK(code->marked_for_deoptimization());
 }
 
 TEST(NoWeakHashTableLeakWithIncrementalMarking) {
-  if (i::FLAG_always_opt || !i::FLAG_opt) return;
-  if (!i::FLAG_incremental_marking) return;
-  i::FLAG_allow_natives_syntax = true;
-  i::FLAG_compilation_cache = false;
-  i::FLAG_retain_maps_for_n_gc = 0;
+  if (FLAG_always_opt || !FLAG_opt) return;
+  if (!FLAG_incremental_marking) return;
+  FLAG_allow_natives_syntax = true;
+  FLAG_compilation_cache = false;
+  FLAG_retain_maps_for_n_gc = 0;
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
 
   // Do not run for no-snap builds.
   if (!i::Snapshot::HasContextSnapshot(isolate, 0)) return;
 
   v8::internal::Heap* heap = CcTest::heap();
 
   // Get a clean slate regarding optimized functions on the heap.
   i::Deoptimizer::DeoptimizeAll(isolate);
@@ skipping 54 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;
+  FLAG_always_opt = false;
+  FLAG_allow_natives_syntax = true;
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   v8::internal::Heap* heap = CcTest::heap();
 
   if (!isolate->use_optimizer()) return;
   HandleScope outer_scope(heap->isolate());
   Handle<Code> code;
   CcTest::CollectAllAvailableGarbage();
   int code_chain_length_before, code_chain_length_after;
   {
@@ skipping 25 matching lines @@
   masm.GetCode(&desc);
   Handle<Object> undefined(isolate->heap()->undefined_value(), isolate);
   Handle<Code> code = isolate->factory()->NewCode(
       desc, Code::ComputeFlags(Code::OPTIMIZED_FUNCTION), undefined);
   CHECK(code->IsCode());
   return code;
 }
 
 
 TEST(NextCodeLinkIsWeak2) {
-  i::FLAG_allow_natives_syntax = true;
+  FLAG_allow_natives_syntax = true;
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   v8::internal::Heap* heap = CcTest::heap();
 
   if (!isolate->use_optimizer()) return;
   HandleScope outer_scope(heap->isolate());
   CcTest::CollectAllAvailableGarbage();
   Handle<Context> context(Context::cast(heap->native_contexts_list()), isolate);
   Handle<Code> new_head;
   Handle<Object> old_head(context->get(Context::OPTIMIZED_CODE_LIST), isolate);
@@ skipping 16 matching lines @@
 
 static void ClearWeakIC(
     const v8::WeakCallbackInfo<v8::Persistent<v8::Object>>& data) {
   printf("clear weak is called\n");
   weak_ic_cleared = true;
   data.GetParameter()->Reset();
 }
 
 
 TEST(WeakFunctionInConstructor) {
-  if (i::FLAG_always_opt) return;
-  i::FLAG_stress_compaction = false;
+  if (FLAG_always_opt) return;
+  FLAG_stress_compaction = false;
+  FLAG_stress_incremental_marking = false;
   CcTest::InitializeVM();
   v8::Isolate* isolate = CcTest::isolate();
   LocalContext env;
   v8::HandleScope scope(isolate);
   CompileRun(
       "function createObj(obj) {"
       "  return new obj();"
       "}");
   i::Handle<JSFunction> createObj = Handle<JSFunction>::cast(
       v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
@@ skipping 38 matching lines @@
   CompileRun(
       "function coat() { this.x = 6; }"
       "createObj(coat);");
   slot_value = feedback_vector->Get(FeedbackSlot(0));
   CHECK(slot_value->IsWeakCell() && !WeakCell::cast(slot_value)->cleared());
 }
 
 
 // Checks that the value returned by execution of the source is weak.
 void CheckWeakness(const char* source) {
-  i::FLAG_stress_compaction = false;
+  FLAG_stress_compaction = false;
+  FLAG_stress_incremental_marking = false;
   CcTest::InitializeVM();
   v8::Isolate* isolate = CcTest::isolate();
   LocalContext env;
   v8::HandleScope scope(isolate);
   v8::Persistent<v8::Object> garbage;
   {
     v8::HandleScope scope(isolate);
     garbage.Reset(isolate, CompileRun(env.local(), source)
                                .ToLocalChecked()
                                ->ToObject(env.local())
@@ skipping 321 matching lines @@
   CcTest::CollectAllGarbage();
   CHECK_EQ(*survivor, weak_cells[0]->value());
   for (int i = 1; i < N; i++) {
     CHECK(weak_cells[i]->cleared());
   }
 }
 
 
 #ifdef DEBUG
 TEST(AddInstructionChangesNewSpacePromotion) {
-  i::FLAG_allow_natives_syntax = true;
-  i::FLAG_expose_gc = true;
-  i::FLAG_stress_compaction = true;
-  i::FLAG_gc_interval = 1000;
+  FLAG_allow_natives_syntax = true;
+  FLAG_expose_gc = true;
+  FLAG_stress_compaction = true;
+  FLAG_gc_interval = 1000;
   CcTest::InitializeVM();
-  if (!i::FLAG_allocation_site_pretenuring) return;
+  if (!FLAG_allocation_site_pretenuring) return;
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Heap* heap = isolate->heap();
   LocalContext env;
   CompileRun(
       "function add(a, b) {"
       "  return a + b;"
       "}"
       "add(1, 2);"
       "add(\"a\", \"b\");"
@@ skipping 22 matching lines @@
 }
 
 
 void OnFatalErrorExpectOOM(const char* location, const char* message) {
   // Exit with 0 if the location matches our expectation.
   exit(strcmp(location, "CALL_AND_RETRY_LAST"));
 }
 
 
 TEST(CEntryStubOOM) {
-  i::FLAG_allow_natives_syntax = true;
+  FLAG_allow_natives_syntax = true;
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   CcTest::isolate()->SetFatalErrorHandler(OnFatalErrorExpectOOM);
 
   v8::Local<v8::Value> result = CompileRun(
       "%SetFlags('--gc-interval=1');"
       "var a = [];"
       "a.__proto__ = [];"
       "a.unshift(1)");
 
   CHECK(result->IsNumber());
 }
 
 #endif  // DEBUG
 
 
 static void InterruptCallback357137(v8::Isolate* isolate, void* data) { }
 
 
 static void RequestInterrupt(const v8::FunctionCallbackInfo<v8::Value>& args) {
   CcTest::isolate()->RequestInterrupt(&InterruptCallback357137, NULL);
 }
 
 HEAP_TEST(Regress538257) {
-  i::FLAG_manual_evacuation_candidates_selection = true;
+  FLAG_manual_evacuation_candidates_selection = true;
   v8::Isolate::CreateParams create_params;
   // Set heap limits.
   create_params.constraints.set_max_semi_space_size(1);
   create_params.constraints.set_max_old_space_size(6);
   create_params.array_buffer_allocator = CcTest::array_buffer_allocator();
   v8::Isolate* isolate = v8::Isolate::New(create_params);
   isolate->Enter();
   {
     i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
     Heap* heap = i_isolate->heap();
@@ skipping 61 matching lines @@
   o1->Shrink(kFixedArrayLen - 1);
 
   for (HeapObject* obj = it.next(); obj != NULL; obj = it.next()) {
     // Let's not optimize the loop away.
     CHECK(obj->address() != nullptr);
   }
 }
 
 
 UNINITIALIZED_TEST(PromotionQueue) {
-  i::FLAG_expose_gc = true;
-  i::FLAG_max_semi_space_size = 2 * Page::kPageSize / MB;
-  i::FLAG_min_semi_space_size = i::FLAG_max_semi_space_size;
+  FLAG_expose_gc = true;
+  FLAG_max_semi_space_size = 2 * Page::kPageSize / MB;
+  FLAG_min_semi_space_size = FLAG_max_semi_space_size;
   v8::Isolate::CreateParams create_params;
   create_params.array_buffer_allocator = CcTest::array_buffer_allocator();
   v8::Isolate* isolate = v8::Isolate::New(create_params);
   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
   {
     v8::Isolate::Scope isolate_scope(isolate);
     v8::HandleScope handle_scope(isolate);
     v8::Context::New(isolate)->Enter();
     Heap* heap = i_isolate->heap();
     NewSpace* new_space = heap->new_space();
@@ skipping 12 matching lines @@
     // (2) and will create promotion queue entries at the end of the second
     // semi-space page during the next scavenge when it promotes the objects to
     // the old generation. The first allocation of (3) will fill up the first
     // semi-space page. The second allocation in (3) will not fit into the
     // first semi-space page, but it will overwrite the promotion queue which
     // are in the second semi-space page. If the right guards are in place, the
     // promotion queue will be evacuated in that case.
 
 
     CHECK(new_space->IsAtMaximumCapacity());
-    CHECK_EQ(static_cast<size_t>(i::FLAG_min_semi_space_size * MB),
+    CHECK_EQ(static_cast<size_t>(FLAG_min_semi_space_size * MB),
              new_space->TotalCapacity());
 
     // Call the scavenger two times to get an empty new space
     heap->CollectGarbage(NEW_SPACE, i::GarbageCollectionReason::kTesting);
     heap->CollectGarbage(NEW_SPACE, i::GarbageCollectionReason::kTesting);
 
     // 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, i::GarbageCollectionReason::kTesting);
-    CHECK_EQ(static_cast<size_t>(i::FLAG_min_semi_space_size * MB),
+    CHECK_EQ(static_cast<size_t>(FLAG_min_semi_space_size * MB),
              new_space->TotalCapacity());
 
     // Fill-up the first semi-space page.
     heap::FillUpOnePage(new_space);
 
     // Create a small object to initialize the bump pointer on the second
     // semi-space page.
     Handle<FixedArray> small =
         i_isolate->factory()->NewFixedArray(1, NOT_TENURED);
     CHECK(heap->InNewSpace(*small));
 
     // Fill-up the second semi-space page.
     heap::FillUpOnePage(new_space);
 
     // This scavenge will corrupt memory if the promotion queue is not
     // evacuated.
     heap->CollectGarbage(NEW_SPACE, i::GarbageCollectionReason::kTesting);
   }
   isolate->Dispose();
 }
 
 
 TEST(Regress388880) {
   if (!FLAG_incremental_marking) return;
-  i::FLAG_expose_gc = true;
+  FLAG_stress_incremental_marking = false;
+  FLAG_expose_gc = true;
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Factory* factory = isolate->factory();
   Heap* heap = isolate->heap();
 
   Handle<Map> map1 = Map::Create(isolate, 1);
   Handle<String> name = factory->NewStringFromStaticChars("foo");
   name = factory->InternalizeString(name);
   Handle<Map> map2 =
@@ skipping 27 matching lines @@
   CHECK(marking->IsMarking());
 
   // Now everything is set up for crashing in JSObject::MigrateFastToFast()
   // when it calls heap->AdjustLiveBytes(...).
   JSObject::MigrateToMap(o, map2);
 }
 
 
 TEST(Regress3631) {
   if (!FLAG_incremental_marking) return;
-  i::FLAG_expose_gc = true;
+  FLAG_expose_gc = true;
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Heap* heap = isolate->heap();
   IncrementalMarking* marking = CcTest::heap()->incremental_marking();
   v8::Local<v8::Value> result = CompileRun(
       "var weak_map = new WeakMap();"
       "var future_keys = [];"
       "for (var i = 0; i < 50; i++) {"
       "  var key = {'k' : i + 0.1};"
@@ skipping 114 matching lines @@
   }
   CHECK(!weak_cell->cleared());
   heap::SimulateIncrementalMarking(heap);
   CcTest::CollectGarbage(OLD_SPACE);
   CHECK(weak_cell->cleared());
 }
 
 
 TEST(MapRetaining) {
   if (!FLAG_incremental_marking) return;
+  FLAG_stress_incremental_marking = false;
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   CheckMapRetainingFor(FLAG_retain_maps_for_n_gc);
   CheckMapRetainingFor(0);
   CheckMapRetainingFor(1);
   CheckMapRetainingFor(7);
 }
 
 
 TEST(RegressArrayListGC) {
@@ skipping 665 matching lines @@
   Isolate* isolate = heap->isolate();
 
   intptr_t size_before = heap->SizeOfObjects();
   Handle<FixedArray> array = isolate->factory()->NewFixedArray(200000);
   array->Shrink(1);
   intptr_t size_after = heap->SizeOfObjects();
   CHECK_EQ(size_after, size_before + array->Size());
 }
 
 TEST(Regress615489) {
-  if (!i::FLAG_incremental_marking) return;
+  if (!FLAG_incremental_marking) return;
   FLAG_black_allocation = true;
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Heap* heap = CcTest::heap();
   Isolate* isolate = heap->isolate();
   CcTest::CollectAllGarbage();
 
   i::MarkCompactCollector* collector = heap->mark_compact_collector();
   i::IncrementalMarking* marking = heap->incremental_marking();
   if (collector->sweeping_in_progress()) {
@@ skipping 80 matching lines @@
   }
 
   {
     StaticOneByteResource external_string("12345678901234");
     s3->MakeExternal(&external_string);
     CcTest::CollectGarbage(OLD_SPACE);
   }
 }
 
 TEST(LeftTrimFixedArrayInBlackArea) {
-  if (!i::FLAG_incremental_marking) return;
+  if (!FLAG_incremental_marking) return;
   FLAG_black_allocation = true;
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Heap* heap = CcTest::heap();
   Isolate* isolate = heap->isolate();
   CcTest::CollectAllGarbage();
 
   i::MarkCompactCollector* collector = heap->mark_compact_collector();
   i::IncrementalMarking* marking = heap->incremental_marking();
   if (collector->sweeping_in_progress()) {
@@ skipping 18 matching lines @@
   // Now left trim the allocated black area. A filler has to be installed
   // for the trimmed area and all mark bits of the trimmed area have to be
   // cleared.
   FixedArrayBase* trimmed = heap->LeftTrimFixedArray(*array, 10);
   CHECK(ObjectMarking::IsBlack(trimmed, MarkingState::Internal(trimmed)));
 
   heap::GcAndSweep(heap, OLD_SPACE);
 }
 
 TEST(ContinuousLeftTrimFixedArrayInBlackArea) {
-  if (!i::FLAG_incremental_marking) return;
+  if (!FLAG_incremental_marking) return;
   FLAG_black_allocation = true;
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Heap* heap = CcTest::heap();
   Isolate* isolate = heap->isolate();
   CcTest::CollectAllGarbage();
 
   i::MarkCompactCollector* collector = heap->mark_compact_collector();
   i::IncrementalMarking* marking = heap->incremental_marking();
   if (collector->sweeping_in_progress()) {
@@ skipping 45 matching lines @@
       CHECK(ObjectMarking::IsBlack(trimmed, MarkingState::Internal(trimmed)));
       CHECK(ObjectMarking::IsBlack(previous, MarkingState::Internal(previous)));
       previous = trimmed;
     }
   }
 
   heap::GcAndSweep(heap, OLD_SPACE);
 }
 
 TEST(ContinuousRightTrimFixedArrayInBlackArea) {
-  if (!i::FLAG_incremental_marking) return;
+  if (!FLAG_incremental_marking) return;
   FLAG_black_allocation = true;
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Heap* heap = CcTest::heap();
   Isolate* isolate = heap->isolate();
   CcTest::CollectAllGarbage();
 
   i::MarkCompactCollector* collector = heap->mark_compact_collector();
   i::IncrementalMarking* marking = heap->incremental_marking();
   if (collector->sweeping_in_progress()) {
@@ skipping 39 matching lines @@
       HeapObject* filler = HeapObject::FromAddress(previous);
       CHECK(filler->IsFiller());
       CHECK(ObjectMarking::IsWhite(filler, MarkingState::Internal(filler)));
     }
   }
 
   heap::GcAndSweep(heap, OLD_SPACE);
 }
 
 TEST(Regress618958) {
-  if (!i::FLAG_incremental_marking) return;
+  if (!FLAG_incremental_marking) return;
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Heap* heap = CcTest::heap();
   bool isolate_is_locked = true;
   heap->update_external_memory(100 * MB);
   int mark_sweep_count_before = heap->ms_count();
   heap->MemoryPressureNotification(MemoryPressureLevel::kCritical,
                                    isolate_is_locked);
   int mark_sweep_count_after = heap->ms_count();
   int mark_sweeps_performed = mark_sweep_count_after - mark_sweep_count_before;
@@ skipping 89 matching lines @@
       SlotSet::FREE_EMPTY_BUCKETS);
   slots[chunk->area_end() - kPointerSize] = false;
   RememberedSet<OLD_TO_NEW>::Iterate(chunk, [&slots](Address addr) {
     CHECK(slots[addr]);
     return KEEP_SLOT;
   });
 }
 
 HEAP_TEST(Regress670675) {
   if (!FLAG_incremental_marking) return;
+  FLAG_stress_incremental_marking = false;
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Heap* heap = CcTest::heap();
   Isolate* isolate = heap->isolate();
   i::MarkCompactCollector* collector = heap->mark_compact_collector();
   CcTest::CollectAllGarbage();
 
   if (collector->sweeping_in_progress()) {
     collector->EnsureSweepingCompleted();
   }
@@ skipping 64 matching lines @@
   CHECK(!heap->code_space()->FirstPage()->Contains(code->address()));
 
   // Ensure it's not in large object space.
   MemoryChunk* chunk = MemoryChunk::FromAddress(code->address());
   CHECK(chunk->owner()->identity() != LO_SPACE);
   CHECK(chunk->NeverEvacuate());
 }
 
 }  // namespace internal
 }  // namespace v8