[heap] Modernize all *Page iterators to be proper C++ iterators

src/heap/spaces-inl.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_HEAP_SPACES_INL_H_
 #define V8_HEAP_SPACES_INL_H_
 
 #include "src/heap/incremental-marking.h"
 #include "src/heap/spaces.h"
 #include "src/isolate.h"
 #include "src/msan.h"
 #include "src/profiler/heap-profiler.h"
 #include "src/v8memory.h"
 
 namespace v8 {
 namespace internal {
 
+template <class PAGE_TYPE>
+PageIteratorImpl<PAGE_TYPE>& PageIteratorImpl<PAGE_TYPE>::operator++() {
+  p_ = p_->next_page();
+  return *this;
+}
+
+template <class PAGE_TYPE>
+PageIteratorImpl<PAGE_TYPE> PageIteratorImpl<PAGE_TYPE>::operator++(int) {
+  PageIteratorImpl<PAGE_TYPE> tmp(*this);
+  operator++();
+  return tmp;
+}
+
+NewSpacePageRange::NewSpacePageRange(Address start, Address limit)
+    : start_(start), limit_(limit) {
+  SemiSpace::AssertValidRange(start, limit);
+}
 
 // -----------------------------------------------------------------------------
 // Bitmap
 
 void Bitmap::Clear(MemoryChunk* chunk) {
   Bitmap* bitmap = chunk->markbits();
   for (int i = 0; i < bitmap->CellsCount(); i++) bitmap->cells()[i] = 0;
   chunk->ResetLiveBytes();
 }
 
 void Bitmap::SetAllBits(MemoryChunk* chunk) {
   Bitmap* bitmap = chunk->markbits();
   for (int i = 0; i < bitmap->CellsCount(); i++)
     bitmap->cells()[i] = 0xffffffff;
 }
 
-// -----------------------------------------------------------------------------
-// PageIterator
-
-PageIterator::PageIterator(PagedSpace* space)
-    : space_(space),
-      prev_page_(&space->anchor_),
-      next_page_(prev_page_->next_page()) {}
-
-
-bool PageIterator::has_next() { return next_page_ != &space_->anchor_; }
-
-
-Page* PageIterator::next() {
-  DCHECK(has_next());
-  prev_page_ = next_page_;
-  next_page_ = next_page_->next_page();
-  return prev_page_;
-}
-
 
 // -----------------------------------------------------------------------------
 // SemiSpaceIterator
 
 HeapObject* SemiSpaceIterator::Next() {
   while (current_ != limit_) {
     if (Page::IsAlignedToPageSize(current_)) {
       Page* page = Page::FromAllocationAreaAddress(current_);
       page = page->next_page();
       DCHECK(!page->is_anchor());
       current_ = page->area_start();
       if (current_ == limit_) return nullptr;
     }
     HeapObject* object = HeapObject::FromAddress(current_);
     current_ += object->Size();
     if (!object->IsFiller()) {
       return object;
     }
   }
   return nullptr;
 }
 
 
 HeapObject* SemiSpaceIterator::next_object() { return Next(); }
 
 
 // -----------------------------------------------------------------------------
-// NewSpacePageIterator
-
-NewSpacePageIterator::NewSpacePageIterator(NewSpace* space)
-    : prev_page_(Page::FromAddress(space->ToSpaceStart())->prev_page()),
-      next_page_(Page::FromAddress(space->ToSpaceStart())),
-      last_page_(Page::FromAllocationAreaAddress(space->ToSpaceEnd())) {}
-
-NewSpacePageIterator::NewSpacePageIterator(SemiSpace* space)
-    : prev_page_(space->anchor()),
-      next_page_(prev_page_->next_page()),
-      last_page_(prev_page_->prev_page()) {}
-
-NewSpacePageIterator::NewSpacePageIterator(Address start, Address limit)
-    : prev_page_(Page::FromAddress(start)->prev_page()),
-      next_page_(Page::FromAddress(start)),
-      last_page_(Page::FromAllocationAreaAddress(limit)) {
-  SemiSpace::AssertValidRange(start, limit);
-}
-
-
-bool NewSpacePageIterator::has_next() { return prev_page_ != last_page_; }
-
-Page* NewSpacePageIterator::next() {
-  DCHECK(has_next());
-  prev_page_ = next_page_;
-  next_page_ = next_page_->next_page();
-  return prev_page_;
-}
-
-
-// -----------------------------------------------------------------------------
 // HeapObjectIterator
 
 HeapObject* HeapObjectIterator::Next() {
   do {
     HeapObject* next_obj = FromCurrentPage();
     if (next_obj != NULL) return next_obj;
   } while (AdvanceToNextPage());
   return NULL;
 }
 
@@ skipping 24 matching lines @@
       } else {
         DCHECK_OBJECT_SIZE(obj_size);
       }
       return obj;
     }
   }
   return NULL;
 }
 
 // -----------------------------------------------------------------------------
-// LargePageIterator
-
-LargePageIterator::LargePageIterator(LargeObjectSpace* space)
-    : next_page_(space->first_page()) {}
-
-LargePage* LargePageIterator::next() {
-  LargePage* result = next_page_;
-  if (next_page_ != nullptr) {
-    next_page_ = next_page_->next_page();
-  }
-  return result;
-}
-
-// -----------------------------------------------------------------------------
 // MemoryAllocator
 
 #ifdef ENABLE_HEAP_PROTECTION
 
 void MemoryAllocator::Protect(Address start, size_t size) {
   base::OS::Protect(start, size);
 }
 
 
 void MemoryAllocator::Unprotect(Address start, size_t size,
@@ skipping 23 matching lines @@
   return id_ == kToSpace
              ? MemoryChunk::FromAddress(o->address())->InToSpace()
              : MemoryChunk::FromAddress(o->address())->InFromSpace();
 }
 
 bool SemiSpace::Contains(Object* o) {
   return o->IsHeapObject() && Contains(HeapObject::cast(o));
 }
 
 bool SemiSpace::ContainsSlow(Address a) {
-  NewSpacePageIterator it(this);
-  while (it.has_next()) {
-    if (it.next() == MemoryChunk::FromAddress(a)) return true;
+  for (Page* p : *this) {
+    if (p == MemoryChunk::FromAddress(a)) return true;
   }
   return false;
 }
 
 // --------------------------------------------------------------------------
 // NewSpace
 
 bool NewSpace::Contains(HeapObject* o) {
   return MemoryChunk::FromAddress(o->address())->InNewSpace();
 }
@@ skipping 174 matching lines @@
 void Page::ClearEvacuationCandidate() {
   if (!IsFlagSet(COMPACTION_WAS_ABORTED)) {
     DCHECK_NULL(old_to_old_slots_);
     DCHECK_NULL(typed_old_to_old_slots_);
   }
   ClearFlag(EVACUATION_CANDIDATE);
   InitializeFreeListCategories();
 }
 
 MemoryChunkIterator::MemoryChunkIterator(Heap* heap)
-    : state_(kOldSpaceState),
-      old_iterator_(heap->old_space()),
-      code_iterator_(heap->code_space()),
-      map_iterator_(heap->map_space()),
-      lo_iterator_(heap->lo_space()) {}
+    : heap_(heap),
+      state_(kOldSpaceState),
+      old_iterator_(heap->old_space()->begin()),
+      code_iterator_(heap->code_space()->begin()),
+      map_iterator_(heap->map_space()->begin()),
+      lo_iterator_(heap->lo_space()->begin()) {}
 
 MemoryChunk* MemoryChunkIterator::next() {
   switch (state_) {
     case kOldSpaceState: {
-      if (old_iterator_.has_next()) {
-        return old_iterator_.next();
-      }
+      if (old_iterator_ != heap_->old_space()->end()) return *(old_iterator_++);
       state_ = kMapState;
       // Fall through.
     }
     case kMapState: {
-      if (map_iterator_.has_next()) {
-        return map_iterator_.next();
-      }
+      if (map_iterator_ != heap_->map_space()->end()) return *(map_iterator_++);
       state_ = kCodeState;
       // Fall through.
     }
     case kCodeState: {
-      if (code_iterator_.has_next()) {
-        return code_iterator_.next();
-      }
+      if (code_iterator_ != heap_->code_space()->end())
+        return *(code_iterator_++);
       state_ = kLargeObjectState;
       // Fall through.
     }
     case kLargeObjectState: {
-      MemoryChunk* answer = lo_iterator_.next();
-      if (answer != nullptr) {
-        return answer;
-      }
+      if (lo_iterator_ != heap_->lo_space()->end()) return *(lo_iterator_++);
       state_ = kFinishedState;
       // Fall through;
     }
     case kFinishedState:
       return nullptr;
     default:
       break;
   }
   UNREACHABLE();
   return nullptr;
@@ skipping 261 matching lines @@
     other->allocation_info_.Reset(nullptr, nullptr);
     return true;
   }
   return false;
 }
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_HEAP_SPACES_INL_H_