[heap] Refactor heap object iteration

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"
@@ skipping 10 matching lines @@
   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)
-    : range_(Page::FromAddress(start),
-             Page::FromAllocationAreaAddress(limit)->next_page()) {
-  SemiSpace::AssertValidRange(start, limit);
+PageRange::PageRange(Address start, Address limit)
+    : begin_(Page::FromAllocationAreaAddress(start)),
+      end_(Page::FromAllocationAreaAddress(limit)->next_page()) {
+#ifdef DEBUG
+  if (begin_->InNewSpace()) {
+    SemiSpace::AssertValidRange(start, limit);
+  }
+#endif  // DEBUG
 }
 
 // -----------------------------------------------------------------------------
 // SemiSpaceIterator
 
 HeapObject* SemiSpaceIterator::Next() {
   while (current_ != limit_) {
     if (Page::IsAlignedToPageSize(current_)) {
       Page* page = Page::FromAllocationAreaAddress(current_);
       page = page->next_page();
@@ skipping 16 matching lines @@
 HeapObject* HeapObjectIterator::Next() {
   do {
     HeapObject* next_obj = FromCurrentPage();
     if (next_obj != nullptr) return next_obj;
   } while (AdvanceToNextPage());
   return nullptr;
 }
 
 HeapObject* HeapObjectIterator::FromCurrentPage() {
   while (cur_addr_ != cur_end_) {
-    if (cur_addr_ == space_->top() && cur_addr_ != space_->limit()) {
-      cur_addr_ = space_->limit();
+    // When the current address equals top we have to handle two scenarios:
+    // - Old space page: Move forward to limit if top != limit. We will find
+    //   a filler following limit.
+    // - New space page: We have to stop iteration before the linear allocation
+    //   area as there are no fillers behind it.
+    if (cur_addr_ == space_->top() &&
+        (cur_addr_ != space_->limit() || current_page()->InNewSpace())) {
+      cur_addr_ = current_page()->InNewSpace() ? cur_end_ : space_->limit();
       continue;
     }
     HeapObject* obj = HeapObject::FromAddress(cur_addr_);
     const int obj_size = obj->Size();
     cur_addr_ += obj_size;
     DCHECK_LE(cur_addr_, cur_end_);
     if (!obj->IsFiller()) {
       if (obj->IsCode()) {
         DCHECK_EQ(space_, space_->heap()->code_space());
-        DCHECK_CODEOBJECT_SIZE(obj_size, space_);
+        DCHECK_CODEOBJECT_SIZE(obj_size, reinterpret_cast<PagedSpace*>(space_));
       } else {
         DCHECK_OBJECT_SIZE(obj_size);
       }
       return obj;
     }
   }
   return nullptr;
 }
 
 // -----------------------------------------------------------------------------
@@ skipping 527 matching lines @@
     other->allocation_info_.Reset(nullptr, nullptr);
     return true;
   }
   return false;
 }
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_HEAP_SPACES_INL_H_