Add a generic remembered set class.

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/globals.h"
 #include "src/heap/slot-set.h"
 
 namespace v8 {
 namespace internal {
 
-class Page;
-class PagedSpace;
-class StoreBuffer;
-
-typedef void (*ObjectSlotCallback)(HeapObject** from, HeapObject* to);
-
-// Used to implement the write barrier by collecting addresses of pointers
-// between spaces.
+// Intermediate buffer that accumulates old-to-new stores from the generated
+// code. On buffer overflow the slots are moved to the remembered set.
 class StoreBuffer {
  public:
   explicit StoreBuffer(Heap* heap);
   static void StoreBufferOverflow(Isolate* isolate);
   void SetUp();
   void TearDown();
 
   static const int kStoreBufferOverflowBit = 1 << (14 + kPointerSizeLog2);
   static const int kStoreBufferSize = kStoreBufferOverflowBit;
   static const int kStoreBufferLength = kStoreBufferSize / sizeof(Address);
 
-  // This is used to add addresses to the store buffer non-concurrently.
-  inline void Mark(Address addr);
-
-  // Removes the given slot from the store buffer non-concurrently. If the
-  // slot was never added to the store buffer, then the function does nothing.
-  void Remove(Address addr);
-
-  // Slots that do not point to the ToSpace after callback invocation will be
-  // removed from the set.
-  void IteratePointersToNewSpace(ObjectSlotCallback callback);
-
-  void Verify();
-
-  // Eliminates all stale store buffer entries from the store buffer, i.e.,
-  // slots that are not part of live objects anymore. This method must be
-  // called after marking, when the whole transitive closure is known and
-  // must be called before sweeping when mark bits are still intact.
-  void ClearInvalidStoreBufferEntries();
-  void VerifyValidStoreBufferEntries();
+  void MoveEntriesToRememberedSet();
 
  private:
   Heap* heap_;
 
   // The start and the limit of the buffer that contains store slots
   // added from the generated code.
   Address* start_;
   Address* limit_;
 
   base::VirtualMemory* virtual_memory_;
-
-  // Used for synchronization of concurrent store buffer access.
-  base::Mutex mutex_;
-
-  void InsertEntriesFromBuffer();
-
-  inline uint32_t AddressToSlotSetAndOffset(Address slot_address,
-                                            SlotSet** slots);
-
-  template <typename Callback>
-  void Iterate(Callback callback);
-
-#ifdef VERIFY_HEAP
-  void VerifyPointers(LargeObjectSpace* space);
-#endif
 };
 
 
 class LocalStoreBuffer BASE_EMBEDDED {
  public:
-  LocalStoreBuffer() : top_(new Node(nullptr)) {}
+  explicit LocalStoreBuffer(Heap* heap)
+      : top_(new Node(nullptr)), heap_(heap) {}
 
   ~LocalStoreBuffer() {
     Node* current = top_;
     while (current != nullptr) {
       Node* tmp = current->next;
       delete current;
       current = tmp;
     }
   }
 
   inline void Record(Address addr);
   inline void Process(StoreBuffer* store_buffer);
 
  private:
   static const int kBufferSize = 16 * KB;
 
   struct Node : Malloced {
     explicit Node(Node* next_node) : next(next_node), count(0) {}
 
     inline bool is_full() { return count == kBufferSize; }
 
     Node* next;
     Address buffer[kBufferSize];
     int count;
   };
 
   Node* top_;
+  Heap* heap_;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_STORE_BUFFER_H_