Changed the PageIterator class so that it only returns pages existing...

src/spaces.cc

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 93 matching lines @@
   Page* p = Page::FromAllocationTop(cur_addr_);
   ASSERT(p == Page::FromAllocationTop(cur_limit_));
   ASSERT(p->Offset(cur_addr_) <= p->Offset(cur_limit_));
 }
 #endif
 
 
 // -----------------------------------------------------------------------------
 // PageIterator
 
-PageIterator::PageIterator(PagedSpace* space, Mode mode) {
-  cur_page_ = space->first_page_;
+PageIterator::PageIterator(PagedSpace* space, Mode mode) : space_(space) {
+  prev_page_ = NULL;
   switch (mode) {
     case PAGES_IN_USE:
-      stop_page_ = space->AllocationTopPage()->next_page();
+      stop_page_ = space->AllocationTopPage();
       break;
     case PAGES_USED_BY_MC:
-      stop_page_ = space->MCRelocationTopPage()->next_page();
+      stop_page_ = space->MCRelocationTopPage();
       break;
     case ALL_PAGES:
-      stop_page_ = Page::FromAddress(NULL);
+      stop_page_ = space->last_page_;
       break;
     default:
       UNREACHABLE();
   }
 }
 
 
 // -----------------------------------------------------------------------------
 // Page
 
@@ skipping 356 matching lines @@
 
   // We are sure that the first page is valid and that we have at least one
   // page.
   ASSERT(first_page_->is_valid());
   ASSERT(num_pages > 0);
   accounting_stats_.ExpandSpace(num_pages * Page::kObjectAreaSize);
   ASSERT(Capacity() <= max_capacity_);
 
   for (Page* p = first_page_; p->is_valid(); p = p->next_page()) {
     p->ClearRSet();
+    last_page_ = p;
   }
 
   // Use first_page_ for allocation.
   SetAllocationInfo(&allocation_info_, first_page_);
 
   return true;
 }
 
 
 bool PagedSpace::HasBeenSetup() {
@@ skipping 161 matching lines @@
   if (!p->is_valid()) return false;
 
   accounting_stats_.ExpandSpace(desired_pages * Page::kObjectAreaSize);
   ASSERT(Capacity() <= max_capacity_);
 
   MemoryAllocator::SetNextPage(last_page, p);
 
   // Clear remembered set of new pages.
   while (p->is_valid()) {
     p->ClearRSet();
+    last_page_ = p;
     p = p->next_page();
   }
 
   return true;
 }
 
 
 #ifdef DEBUG
 int PagedSpace::CountTotalPages() {
   int count = 0;
@@ skipping 28 matching lines @@
   }
 
   // Free pages after last_page_to_keep, and adjust the next_page link.
   Page* p = MemoryAllocator::FreePages(last_page_to_keep->next_page());
   MemoryAllocator::SetNextPage(last_page_to_keep, p);
 
   // Since pages are only freed in whole chunks, we may have kept more than
   // pages_to_keep.
   while (p->is_valid()) {
     pages_to_keep++;
+    last_page_ = p;
     p = p->next_page();
   }
 
   // The difference between free_pages and pages_to_keep is the number of
   // pages actually freed.
   ASSERT(pages_to_keep <= free_pages);
   int bytes_freed = (free_pages - pages_to_keep) * Page::kObjectAreaSize;
   accounting_stats_.ShrinkSpace(bytes_freed);
 
   ASSERT(Capacity() == CountTotalPages() * Page::kObjectAreaSize);
@@ skipping 1850 matching lines @@
                      reinterpret_cast<Object**>(object->address()
                                                 + Page::kObjectAreaSize),
                      allocation_top);
       PrintF("\n");
     }
   }
 }
 #endif  // DEBUG
 
 } }  // namespace v8::internal