[heap] Refactor heap object iteration

src/heap/spaces.cc

 // 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.
 
 #include "src/heap/spaces.h"
 
 #include <utility>
 
 #include "src/base/bits.h"
 #include "src/base/platform/platform.h"
@@ skipping 11 matching lines @@
 
 
 // ----------------------------------------------------------------------------
 // HeapObjectIterator
 
 HeapObjectIterator::HeapObjectIterator(PagedSpace* space)
     : cur_addr_(nullptr),
       cur_end_(nullptr),
       space_(space),
       page_range_(space->anchor()->next_page(), space->anchor()),
-      current_page_(page_range_.begin()) {}
+      next_page_(page_range_.begin()) {}
+
+HeapObjectIterator::HeapObjectIterator(NewSpace* space)
+    : cur_addr_(nullptr),
+      cur_end_(nullptr),
+      space_(space),
+      page_range_(space->bottom(), space->top()),
+      next_page_(page_range_.begin()) {}
 
 HeapObjectIterator::HeapObjectIterator(Page* page)
     : cur_addr_(nullptr),
       cur_end_(nullptr),
-      space_(reinterpret_cast<PagedSpace*>(page->owner())),
+      space_(reinterpret_cast<SpaceWithInlineAllocationArea*>(page->owner())),
       page_range_(page),
-      current_page_(page_range_.begin()) {
+      next_page_(page_range_.begin()) {
 #ifdef DEBUG
   Space* owner = page->owner();
-  DCHECK(owner == page->heap()->old_space() ||
-         owner == page->heap()->map_space() ||
-         owner == page->heap()->code_space());
+  Heap* heap = page->heap();
+  DCHECK(owner == heap->old_space() || owner == heap->map_space() ||
+         owner == heap->code_space() || owner == heap->new_space());
 #endif  // DEBUG
 }
 
 // We have hit the end of the page and should advance to the next block of
 // objects.  This happens at the end of the page.
 bool HeapObjectIterator::AdvanceToNextPage() {
   DCHECK_EQ(cur_addr_, cur_end_);
-  if (current_page_ == page_range_.end()) return false;
-  Page* cur_page = *(current_page_++);
+  if (next_page_ == page_range_.end()) return false;
+  Page* cur_page = *(next_page_++);
   space_->heap()
       ->mark_compact_collector()
       ->sweeper()
       .SweepOrWaitUntilSweepingCompleted(cur_page);
   cur_addr_ = cur_page->area_start();
   cur_end_ = cur_page->area_end();
   DCHECK(cur_page->SweepingDone());
   return true;
 }
 
@@ skipping 1109 matching lines @@
   if (!allocation_observers_paused_) {
     for (int i = 0; i < allocation_observers_->length(); ++i) {
       AllocationObserver* o = (*allocation_observers_)[i];
       o->AllocationStep(size, soon_object, size);
     }
   }
 }
 
 PagedSpace::PagedSpace(Heap* heap, AllocationSpace space,
                        Executability executable)
-    : Space(heap, space, executable), anchor_(this), free_list_(this) {
+    : SpaceWithInlineAllocationArea(heap, space, executable),
+      anchor_(this),
+      free_list_(this) {
   area_size_ = MemoryAllocator::PageAreaSize(space);
   accounting_stats_.Clear();
 
   allocation_info_.Reset(nullptr, nullptr);
 }
 
 
 bool PagedSpace::SetUp() { return true; }
 
 
@@ skipping 894 matching lines @@
   std::swap(from->current_page_, to->current_page_);
 
   to->FixPagesFlags(saved_to_space_flags, Page::kCopyOnFlipFlagsMask);
   from->FixPagesFlags(0, 0);
 }
 
 void SemiSpace::set_age_mark(Address mark) {
   DCHECK_EQ(Page::FromAllocationAreaAddress(mark)->owner(), this);
   age_mark_ = mark;
   // Mark all pages up to the one containing mark.
-  for (Page* p : NewSpacePageRange(space_start(), mark)) {
+  for (Page* p : PageRange(space_start(), mark)) {
     p->SetFlag(MemoryChunk::NEW_SPACE_BELOW_AGE_MARK);
   }
 }
 
 std::unique_ptr<ObjectIterator> SemiSpace::GetObjectIterator() {
   // Use the NewSpace::NewObjectIterator to iterate the ToSpace.
   UNREACHABLE();
   return std::unique_ptr<ObjectIterator>();
 }
 
@@ skipping 1138 matching lines @@
     object->ShortPrint();
     PrintF("\n");
   }
   printf(" --------------------------------------\n");
   printf(" Marked: %x, LiveCount: %x\n", mark_size, LiveBytes());
 }
 
 #endif  // DEBUG
 }  // namespace internal
 }  // namespace v8