Add a flag to over approximate the weak closure during GC

src/heap/incremental-marking.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_INCREMENTAL_MARKING_H_
 #define V8_HEAP_INCREMENTAL_MARKING_H_
 
 
 #include "src/execution.h"
 #include "src/heap/mark-compact.h"
 #include "src/objects.h"
 
 namespace v8 {
 namespace internal {
 
 
 class IncrementalMarking {
  public:
   enum State { STOPPED, SWEEPING, MARKING, COMPLETE };
 
   enum CompletionAction { GC_VIA_STACK_GUARD, NO_GC_VIA_STACK_GUARD };
 
   enum ForceMarkingAction { FORCE_MARKING, DO_NOT_FORCE_MARKING };
 
   enum ForceCompletionAction { FORCE_COMPLETION, DO_NOT_FORCE_COMPLETION };
 
+  enum GCRequestType { COMPLETE_MARKING, OVERAPPROXIMATION };
+
   explicit IncrementalMarking(Heap* heap);
 
   static void Initialize();
 
   State state() {
     DCHECK(state_ == STOPPED || FLAG_incremental_marking);
     return state_;
   }
 
   bool should_hurry() { return should_hurry_; }
   void set_should_hurry(bool val) { should_hurry_ = val; }
 
+  bool weak_closure_was_overapproximated() const {
+    return weak_closure_was_overapproximated_;
+  }
+  void set_weak_closure_was_overapproximated(bool val) {
+    weak_closure_was_overapproximated_ = val;
+  }
+
   inline bool IsStopped() { return state() == STOPPED; }
 
   INLINE(bool IsMarking()) { return state() >= MARKING; }
 
   inline bool IsMarkingIncomplete() { return state() == MARKING; }
 
   inline bool IsComplete() { return state() == COMPLETE; }
 
+  GCRequestType request_type() const { return request_type_; }
+
   bool WorthActivating();
 
   bool ShouldActivate();
 
   bool WasActivated();
 
   enum CompactionFlag { ALLOW_COMPACTION, PREVENT_COMPACTION };
 
   void Start(CompactionFlag flag = ALLOW_COMPACTION);
 
   void Stop();
 
   void PrepareForScavenge();
 
   void UpdateMarkingDequeAfterScavenge();
 
   void Hurry();
 
   void Finalize();
 
   void Abort();
 
+  void OverApproximateWeakClosure();
+
   void MarkingComplete(CompletionAction action);
 
   void Epilogue();
 
   // It's hard to know how much work the incremental marker should do to make
   // progress in the face of the mutator creating new work for it.  We start
   // of at a moderate rate of work and gradually increase the speed of the
   // incremental marker until it completes.
   // Do some marking every time this much memory has been allocated or that many
   // heavy (color-checking) write barriers have been invoked.
@@ skipping 142 matching lines @@
   intptr_t allocated_;
   intptr_t write_barriers_invoked_since_last_step_;
   size_t idle_marking_delay_counter_;
 
   int no_marking_scope_depth_;
 
   int unscanned_bytes_of_large_object_;
 
   bool was_activated_;
 
+  bool weak_closure_was_overapproximated_;
+
+  GCRequestType request_type_;
+
   DISALLOW_IMPLICIT_CONSTRUCTORS(IncrementalMarking);
 };
 }
 }  // namespace v8::internal
 
 #endif  // V8_HEAP_INCREMENTAL_MARKING_H_