Add a generic remembered set class.

src/heap/slot-set.h

 // Copyright 2016 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_SLOT_SET_H
 #define V8_SLOT_SET_H
 
 #include "src/allocation.h"
 #include "src/base/bits.h"
 
@@ skipping 93 matching lines @@
     SlotToIndices(slot_offset, &bucket_index, &cell_index, &bit_index);
     if (bucket[bucket_index] != nullptr) {
       uint32_t cell = bucket[bucket_index][cell_index];
       return (cell & (1u << bit_index)) != 0;
     }
     return false;
   }
 
   // Iterate over all slots in the set and for each slot invoke the callback.
   // If the callback returns REMOVE_SLOT then the slot is removed from the set.
+  // Returns the new number of slots.
   //
   // Sample usage:
   // Iterate([](Address slot_address) {
   //    if (good(slot_address)) return KEEP_SLOT;
   //    else return REMOVE_SLOT;
   // });
   template <typename Callback>
-  void Iterate(Callback callback) {
+  int Iterate(Callback callback) {
+    int new_count = 0;
     for (int bucket_index = 0; bucket_index < kBuckets; bucket_index++) {
       if (bucket[bucket_index] != nullptr) {
-        bool bucket_is_empty = true;
+        int in_bucket_count = 0;
         uint32_t* current_bucket = bucket[bucket_index];
         int cell_offset = bucket_index * kBitsPerBucket;
         for (int i = 0; i < kCellsPerBucket; i++, cell_offset += kBitsPerCell) {
           if (current_bucket[i]) {
             uint32_t cell = current_bucket[i];
             uint32_t old_cell = cell;
             uint32_t new_cell = cell;
             while (cell) {
               int bit_offset = base::bits::CountTrailingZeros32(cell);
               uint32_t bit_mask = 1u << bit_offset;
               uint32_t slot = (cell_offset + bit_offset) << kPointerSizeLog2;
               if (callback(page_start_ + slot) == KEEP_SLOT) {
-                bucket_is_empty = false;
+                ++in_bucket_count;
               } else {
                 new_cell ^= bit_mask;
               }
               cell ^= bit_mask;
             }
             if (old_cell != new_cell) {
               current_bucket[i] = new_cell;
             }
           }
         }
-        if (bucket_is_empty) {
+        if (in_bucket_count == 0) {
           ReleaseBucket(bucket_index);
         }
+        new_count += in_bucket_count;
       }
     }
+    return new_count;
   }
 
  private:
   static const int kMaxSlots = (1 << kPageSizeBits) / kPointerSize;
   static const int kCellsPerBucket = 32;
   static const int kCellsPerBucketLog2 = 5;
   static const int kBitsPerCell = 32;
   static const int kBitsPerCellLog2 = 5;
   static const int kBitsPerBucket = kCellsPerBucket * kBitsPerCell;
   static const int kBitsPerBucketLog2 = kCellsPerBucketLog2 + kBitsPerCellLog2;
@@ skipping 31 matching lines @@
   }
 
   uint32_t* bucket[kBuckets];
   Address page_start_;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_SLOT_SET_H