[heap] More flag cleanup.

src/heap/heap-inl.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_HEAP_HEAP_INL_H_
 #define V8_HEAP_HEAP_INL_H_
 
 #include <cmath>
 
 #include "src/base/platform/platform.h"
@@ skipping 479 matching lines @@
          memento_address + HeapObject::kHeaderSize <= top ||
          !NewSpacePage::OnSamePage(memento_address, top - 1));
   if (memento_address == top) return NULL;
 
   AllocationMemento* memento = AllocationMemento::cast(candidate);
   if (!memento->IsValid()) return NULL;
   return memento;
 }
 
 
+bool Heap::CollectGarbage(AllocationSpace space, const char* gc_reason,
+                          const GCFlags flags,
+                          const GCCallbackFlags callback_flags) {
+  const char* collector_reason = nullptr;
+  GarbageCollector collector = SelectGarbageCollector(space, &collector_reason);
+  set_current_gc_flags(flags);
+  current_gc_callback_flags_ = callback_flags;
+  const bool next_gc_likely_to_collect_more =
+      CollectGarbage(collector, gc_reason, collector_reason);
+  set_current_gc_flags(kNoGCFlags);
+  current_gc_callback_flags_ = kNoGCCallbackFlags;
+  return next_gc_likely_to_collect_more;
+}
+
+
 void Heap::UpdateAllocationSiteFeedback(HeapObject* object,
                                         ScratchpadSlotMode mode) {
   Heap* heap = object->GetHeap();
   DCHECK(heap->InFromSpace(object));
 
   if (!FLAG_allocation_site_pretenuring ||
       !AllocationSite::CanTrack(object->map()->instance_type()))
     return;
 
   AllocationMemento* memento = heap->FindAllocationMemento(object);
@@ skipping 25 matching lines @@
 
   UpdateAllocationSiteFeedback(object, IGNORE_SCRATCHPAD_SLOT);
 
   // AllocationMementos are unrooted and shouldn't survive a scavenge
   DCHECK(object->map() != object->GetHeap()->allocation_memento_map());
   // Call the slow part of scavenge object.
   return ScavengeObjectSlow(p, object);
 }
 
 
-bool Heap::CollectGarbage(AllocationSpace space, const char* gc_reason,
-                          const v8::GCCallbackFlags callbackFlags) {
-  const char* collector_reason = NULL;
-  GarbageCollector collector = SelectGarbageCollector(space, &collector_reason);
-  return CollectGarbage(collector, gc_reason, collector_reason, callbackFlags);
-}
-
-
 Isolate* Heap::isolate() {
   return reinterpret_cast<Isolate*>(
       reinterpret_cast<intptr_t>(this) -
       reinterpret_cast<size_t>(reinterpret_cast<Isolate*>(16)->heap()) + 16);
 }
 
 
 // Calls the FUNCTION_CALL function and retries it up to three times
 // to guarantee that any allocations performed during the call will
 // succeed if there's enough memory.
 
 // Warning: Do not use the identifiers __object__, __maybe_object__ or
 // __scope__ in a call to this macro.
 
 #define RETURN_OBJECT_UNLESS_RETRY(ISOLATE, RETURN_VALUE) \
   if (__allocation__.To(&__object__)) {                   \
     DCHECK(__object__ != (ISOLATE)->heap()->exception()); \
     RETURN_VALUE;                                         \
   }
 
-#define CALL_AND_RETRY(ISOLATE, FUNCTION_CALL, RETURN_VALUE, RETURN_EMPTY)    \
-  do {                                                                        \
-    AllocationResult __allocation__ = FUNCTION_CALL;                          \
-    Object* __object__ = NULL;                                                \
-    RETURN_OBJECT_UNLESS_RETRY(ISOLATE, RETURN_VALUE)                         \
-    /* Two GCs before panicking.  In newspace will almost always succeed. */  \
-    for (int __i__ = 0; __i__ < 2; __i__++) {                                 \
-      (ISOLATE)->heap()->CollectGarbage(__allocation__.RetrySpace(),          \
-                                        "allocation failure");                \
-      __allocation__ = FUNCTION_CALL;                                         \
-      RETURN_OBJECT_UNLESS_RETRY(ISOLATE, RETURN_VALUE)                       \
-    }                                                                         \
-    (ISOLATE)->counters()->gc_last_resort_from_handles()->Increment();        \
-    (ISOLATE)->heap()->CollectAllAvailableGarbage("last resort gc");          \
-    {                                                                         \
-      AlwaysAllocateScope __scope__(ISOLATE);                                 \
-      __allocation__ = FUNCTION_CALL;                                         \
-    }                                                                         \
-    RETURN_OBJECT_UNLESS_RETRY(ISOLATE, RETURN_VALUE)                         \
-    /* TODO(1181417): Fix this. */                                            \
-    v8::internal::Heap::FatalProcessOutOfMemory("CALL_AND_RETRY_LAST", true); \
-    RETURN_EMPTY;                                                             \
+#define CALL_AND_RETRY(ISOLATE, FUNCTION_CALL, RETURN_VALUE, RETURN_EMPTY)     \
+  do {                                                                         \
+    AllocationResult __allocation__ = FUNCTION_CALL;                           \
+    Object* __object__ = NULL;                                                 \
+    RETURN_OBJECT_UNLESS_RETRY(ISOLATE, RETURN_VALUE)                          \
+    /* Two GCs before panicking.  In newspace will almost always succeed. */   \
+    for (int __i__ = 0; __i__ < 2; __i__++) {                                  \
+      (ISOLATE)->heap()->CollectGarbage(__allocation__.RetrySpace(),           \
+                                        "allocation failure",                  \
+                                        Heap::kNoGCFlags, kNoGCCallbackFlags); \
+      __allocation__ = FUNCTION_CALL;                                          \
+      RETURN_OBJECT_UNLESS_RETRY(ISOLATE, RETURN_VALUE)                        \
+    }                                                                          \
+    (ISOLATE)->counters()->gc_last_resort_from_handles()->Increment();         \
+    (ISOLATE)->heap()->CollectAllAvailableGarbage("last resort gc");           \
+    {                                                                          \
+      AlwaysAllocateScope __scope__(ISOLATE);                                  \
+      __allocation__ = FUNCTION_CALL;                                          \
+    }                                                                          \
+    RETURN_OBJECT_UNLESS_RETRY(ISOLATE, RETURN_VALUE)                          \
+    /* TODO(1181417): Fix this. */                                             \
+    v8::internal::Heap::FatalProcessOutOfMemory("CALL_AND_RETRY_LAST", true);  \
+    RETURN_EMPTY;                                                              \
   } while (false)
 
 #define CALL_AND_RETRY_OR_DIE(ISOLATE, FUNCTION_CALL, RETURN_VALUE, \
                               RETURN_EMPTY)                         \
   CALL_AND_RETRY(ISOLATE, FUNCTION_CALL, RETURN_VALUE, RETURN_EMPTY)
 
 #define CALL_HEAP_FUNCTION(ISOLATE, FUNCTION_CALL, TYPE)                      \
   CALL_AND_RETRY_OR_DIE(ISOLATE, FUNCTION_CALL,                               \
                         return Handle<TYPE>(TYPE::cast(__object__), ISOLATE), \
                         return Handle<TYPE>())
@@ skipping 174 matching lines @@
 
 void VerifySmisVisitor::VisitPointers(Object** start, Object** end) {
   for (Object** current = start; current < end; current++) {
     CHECK((*current)->IsSmi());
   }
 }
 }
 }  // namespace v8::internal
 
 #endif  // V8_HEAP_HEAP_INL_H_