[heap] Ensure consistency between store buffer mode and moving all entries to remembered set.

src/heap/store-buffer.h

 // Copyright 2011 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_STORE_BUFFER_H_
 #define V8_STORE_BUFFER_H_
 
 #include "src/allocation.h"
 #include "src/base/logging.h"
 #include "src/base/platform/platform.h"
 #include "src/cancelable-task.h"
 #include "src/globals.h"
 #include "src/heap/remembered-set.h"
 #include "src/heap/slot-set.h"
 
 namespace v8 {
 namespace internal {
 
 // Intermediate buffer that accumulates old-to-new stores from the generated
 // code. Moreover, it stores invalid old-to-new slots with two entries.
 // The first is a tagged address of the start of the invalid range, the second
 // one is the end address of the invalid range or null if there is just one slot
 // that needs to be removed from the remembered set. On buffer overflow the
 // slots are moved to the remembered set.
 class StoreBuffer {
  public:
+  enum StoreBufferMode { IN_GC, NOT_IN_GC };
+
   static const int kStoreBufferSize = 1 << (11 + kPointerSizeLog2);
   static const int kStoreBufferMask = kStoreBufferSize - 1;
   static const int kStoreBuffers = 2;
   static const intptr_t kDeletionTag = 1;
 
   V8_EXPORT_PRIVATE static void StoreBufferOverflow(Isolate* isolate);
 
   explicit StoreBuffer(Heap* heap);
   void SetUp();
   void TearDown();
@@ skipping 30 matching lines @@
     // Deletions coming from the GC are directly deleted from the remembered
     // set. Deletions coming from the runtime are added to the store buffer
     // to allow concurrent processing.
     deletion_callback(this, start, end);
   }
 
   static void DeleteDuringGarbageCollection(StoreBuffer* store_buffer,
                                             Address start, Address end) {
     // In GC the store buffer has to be empty at any time.
     DCHECK(store_buffer->Empty());
-    DCHECK(store_buffer->heap()->gc_state() != Heap::NOT_IN_GC);
+    DCHECK(store_buffer->mode() != StoreBuffer::NOT_IN_GC);
     Page* page = Page::FromAddress(start);
     if (end) {
       RememberedSet<OLD_TO_NEW>::RemoveRange(page, start, end,
                                              SlotSet::PREFREE_EMPTY_BUCKETS);
     } else {
       RememberedSet<OLD_TO_NEW>::Remove(page, start);
     }
   }
 
   static void DeleteDuringRuntime(StoreBuffer* store_buffer, Address start,
                                   Address end) {
-    DCHECK(store_buffer->heap()->gc_state() == Heap::NOT_IN_GC);
+    DCHECK(store_buffer->mode() == StoreBuffer::NOT_IN_GC);
     store_buffer->InsertDeletionIntoStoreBuffer(start, end);
   }
 
   void InsertDeletionIntoStoreBuffer(Address start, Address end) {
     if (top_ + sizeof(Address) * 2 > limit_[current_]) {
       StoreBufferOverflow(heap_->isolate());
     }
     *top_ = MarkDeletionAddress(start);
     top_++;
     *top_ = end;
     top_++;
   }
 
   static void InsertDuringGarbageCollection(StoreBuffer* store_buffer,
                                             Address slot) {
-    DCHECK(store_buffer->heap()->gc_state() != Heap::NOT_IN_GC);
+    DCHECK(store_buffer->mode() != StoreBuffer::NOT_IN_GC);
     RememberedSet<OLD_TO_NEW>::Insert(Page::FromAddress(slot), slot);
   }
 
   static void InsertDuringRuntime(StoreBuffer* store_buffer, Address slot) {
-    DCHECK(store_buffer->heap()->gc_state() == Heap::NOT_IN_GC);
+    DCHECK(store_buffer->mode() == StoreBuffer::NOT_IN_GC);
     store_buffer->InsertIntoStoreBuffer(slot);
   }
 
   void InsertIntoStoreBuffer(Address slot) {
     if (top_ + sizeof(Address) > limit_[current_]) {
       StoreBufferOverflow(heap_->isolate());
     }
     *top_ = slot;
     top_++;
   }
 
   void InsertEntry(Address slot) {
     // Insertions coming from the GC are directly inserted into the remembered
     // set. Insertions coming from the runtime are added to the store buffer to
     // allow concurrent processing.
     insertion_callback(this, slot);
   }
 
-  void SetMode(Heap::HeapState state) {
-    if (state == Heap::NOT_IN_GC) {
+  void SetMode(StoreBufferMode mode) {
+    mode_ = mode;
+    if (mode == NOT_IN_GC) {
       insertion_callback = &InsertDuringRuntime;
       deletion_callback = &DeleteDuringRuntime;
     } else {
       insertion_callback = &InsertDuringGarbageCollection;
       deletion_callback = &DeleteDuringGarbageCollection;
     }
   }
 
   // Used by the concurrent processing thread to transfer entries from the
   // store buffer to the remembered set.
@@ skipping 27 matching lines @@
     virtual ~Task() {}
 
    private:
     void RunInternal() override {
       store_buffer_->ConcurrentlyProcessStoreBuffer();
     }
     StoreBuffer* store_buffer_;
     DISALLOW_COPY_AND_ASSIGN(Task);
   };
 
+  StoreBufferMode mode() const { return mode_; }
+
   void FlipStoreBuffers();
 
   Heap* heap_;
 
   Address* top_;
 
   // The start and the limit of the buffer that contains store slots
   // added from the generated code. We have two chunks of store buffers.
   // Whenever one fills up, we notify a concurrent processing thread and
   // use the other empty one in the meantime.
   Address* start_[kStoreBuffers];
   Address* limit_[kStoreBuffers];
 
   // At most one lazy_top_ pointer is set at any time.
   Address* lazy_top_[kStoreBuffers];
   base::Mutex mutex_;
 
   // We only want to have at most one concurrent processing tas running.
   bool task_running_;
 
   // Points to the current buffer in use.
   int current_;
 
+  // During GC, entries are directly added to the remembered set without
+  // going through the store buffer. This is signaled by a special
+  // IN_GC mode.
+  StoreBufferMode mode_;
+
   base::VirtualMemory* virtual_memory_;
 
   // Callbacks are more efficient than reading out the gc state for every
   // store buffer operation.
   void (*insertion_callback)(StoreBuffer*, Address);
   void (*deletion_callback)(StoreBuffer*, Address, Address);
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_STORE_BUFFER_H_