Merge ObjectIterator::has_next and ObjectIterator::next methods....

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 64 matching lines @@
   size_func_ = size_f;
   Page* p = Page::FromAllocationTop(cur_addr_);
   cur_limit_ = (p == end_page_) ? end_addr_ : p->AllocationTop();
 
 #ifdef DEBUG
   Verify();
 #endif
 }
 
 
-bool HeapObjectIterator::HasNextInNextPage() {
-  if (cur_addr_ == end_addr_) return false;
+HeapObject* HeapObjectIterator::FromNextPage() {
+  if (cur_addr_ == end_addr_) return NULL;
 
   Page* cur_page = Page::FromAllocationTop(cur_addr_);
   cur_page = cur_page->next_page();
   ASSERT(cur_page->is_valid());
 
   cur_addr_ = cur_page->ObjectAreaStart();
   cur_limit_ = (cur_page == end_page_) ? end_addr_ : cur_page->AllocationTop();
 
-  if (cur_addr_ == end_addr_) return false;
+  if (cur_addr_ == end_addr_) return NULL;
   ASSERT(cur_addr_ < cur_limit_);
 #ifdef DEBUG
   Verify();
 #endif
-  return true;
+  return FromCurrentPage();
 }
 
 
 #ifdef DEBUG
 void HeapObjectIterator::Verify() {
   Page* p = Page::FromAllocationTop(cur_addr_);
   ASSERT(p == Page::FromAllocationTop(cur_limit_));
   ASSERT(p->Offset(cur_addr_) <= p->Offset(cur_limit_));
 }
 #endif
@@ skipping 1319 matching lines @@
 }
 
 // Because the copying collector does not touch garbage objects, we iterate
 // the new space before a collection to get a histogram of allocated objects.
 // This only happens (1) when compiled with DEBUG and the --heap-stats flag is
 // set, or when compiled with ENABLE_LOGGING_AND_PROFILING and the --log-gc
 // flag is set.
 void NewSpace::CollectStatistics() {
   ClearHistograms();
   SemiSpaceIterator it(this);
-  while (it.has_next()) RecordAllocation(it.next());
+  for (HeapObject* obj = it.next(); obj != NULL; obj = it.next())
+    RecordAllocation(obj);
 }
 
 
 #ifdef ENABLE_LOGGING_AND_PROFILING
 static void DoReportStatistics(HistogramInfo* info, const char* description) {
   LOG(HeapSampleBeginEvent("NewSpace", description));
   // Lump all the string types together.
   int string_number = 0;
   int string_bytes = 0;
 #define INCREMENT(type, size, name, camel_name)       \
@@ skipping 596 matching lines @@
   }
   EnterComment(comment_txt, flat_delta);
 }
 
 
 // Collects code size statistics:
 // - by code kind
 // - by code comment
 void PagedSpace::CollectCodeStatistics() {
   HeapObjectIterator obj_it(this);
-  while (obj_it.has_next()) {
-    HeapObject* obj = obj_it.next();
+  for (HeapObject* obj = obj_it.next(); obj != NULL; obj = obj_it.next()) {
     if (obj->IsCode()) {
       Code* code = Code::cast(obj);
       code_kind_statistics[code->kind()] += code->Size();
       RelocIterator it(code);
       int delta = 0;
       const byte* prev_pc = code->instruction_start();
       while (!it.done()) {
         if (it.rinfo()->rmode() == RelocInfo::COMMENT) {
           delta += static_cast<int>(it.rinfo()->pc() - prev_pc);
           CollectCommentStatistics(&it);
@@ skipping 81 matching lines @@
   pct = (rset_marked_pointers + rset_marked_array_elements) == 0 ? 0
         : (cross_gen_pointers + cross_gen_array_elements) * 100 /
           (rset_marked_pointers + rset_marked_array_elements);
   PrintF("  total rset pointers %d, true cross generation ones %d (%%%d)\n",
          (rset_marked_pointers + rset_marked_array_elements),
          (cross_gen_pointers + cross_gen_array_elements),
          pct);
 
   ClearHistograms();
   HeapObjectIterator obj_it(this);
-  while (obj_it.has_next()) { CollectHistogramInfo(obj_it.next()); }
+  for (HeapObject* obj = obj_it.next(); obj != NULL; obj = obj_it.next())
+    CollectHistogramInfo(obj);
   ReportHistogram(true);
 }
 
 
 // Dump the range of remembered set words between [start, end) corresponding
 // to the pointers starting at object_p.  The allocation_top is an object
 // pointer which should not be read past.  This is important for large object
 // pages, where some bits in the remembered set range do not correspond to
 // allocated addresses.
 static void PrintRSetRange(Address start, Address end, Object** object_p,
@@ skipping 215 matching lines @@
     }
   }
 
   pct = rset_marked_pointers == 0 ?
           0 : cross_gen_pointers * 100 / rset_marked_pointers;
   PrintF("  rset-marked pointers %d, to-new-space %d (%%%d)\n",
             rset_marked_pointers, cross_gen_pointers, pct);
 
   ClearHistograms();
   HeapObjectIterator obj_it(this);
-  while (obj_it.has_next()) { CollectHistogramInfo(obj_it.next()); }
+  for (HeapObject* obj = obj_it.next(); obj != NULL; obj = obj_it.next())
+    CollectHistogramInfo(obj);
   ReportHistogram(false);
 }
 
 
 void FixedSpace::PrintRSet() { DoPrintRSet(name_); }
 #endif
 
 
 // -----------------------------------------------------------------------------
 // MapSpace implementation
@@ skipping 48 matching lines @@
 
 
 LargeObjectIterator::LargeObjectIterator(LargeObjectSpace* space,
                                          HeapObjectCallback size_func) {
   current_ = space->first_chunk_;
   size_func_ = size_func;
 }
 
 
 HeapObject* LargeObjectIterator::next() {
-  ASSERT(has_next());
+  if (current_ == NULL) return NULL;
+
   HeapObject* object = current_->GetObject();
   current_ = current_->next();
   return object;
 }
 
 
 // -----------------------------------------------------------------------------
 // LargeObjectChunk
 
 LargeObjectChunk* LargeObjectChunk::New(int size_in_bytes,
@@ skipping 156 matching lines @@
     }
   }
   return Failure::Exception();
 }
 
 
 void LargeObjectSpace::ClearRSet() {
   ASSERT(Page::is_rset_in_use());
 
   LargeObjectIterator it(this);
-  while (it.has_next()) {
-    HeapObject* object = it.next();
+  for (HeapObject* object = it.next(); object != NULL; object = it.next()) {
     // We only have code, sequential strings, or fixed arrays in large
     // object space, and only fixed arrays need remembered set support.
     if (object->IsFixedArray()) {
       // Clear the normal remembered set region of the page;
       Page* page = Page::FromAddress(object->address());
       page->ClearRSet();
 
       // Clear the extra remembered set.
       int size = object->Size();
       int extra_rset_bytes = ExtraRSetBytesFor(size);
       memset(object->address() + size, 0, extra_rset_bytes);
     }
   }
 }
 
 
 void LargeObjectSpace::IterateRSet(ObjectSlotCallback copy_object_func) {
   ASSERT(Page::is_rset_in_use());
 
   static void* lo_rset_histogram = StatsTable::CreateHistogram(
       "V8.RSetLO",
       0,
       // Keeping this histogram's buckets the same as the paged space histogram.
       Page::kObjectAreaSize / kPointerSize,
       30);
 
   LargeObjectIterator it(this);
-  while (it.has_next()) {
+  for (HeapObject* object = it.next(); object != NULL; object = it.next()) {
     // We only have code, sequential strings, or fixed arrays in large
     // object space, and only fixed arrays can possibly contain pointers to
     // the young generation.
-    HeapObject* object = it.next();
     if (object->IsFixedArray()) {
       // Iterate the normal page remembered set range.
       Page* page = Page::FromAddress(object->address());
       Address object_end = object->address() + object->Size();
       int count = Heap::IterateRSetRange(page->ObjectAreaStart(),
                                          Min(page->ObjectAreaEnd(), object_end),
                                          page->RSetStart(),
                                          copy_object_func);
 
       // Iterate the extra array elements.
@@ skipping 105 matching lines @@
           }
         }
       }
     }
   }
 }
 
 
 void LargeObjectSpace::Print() {
   LargeObjectIterator it(this);
-  while (it.has_next()) {
-    it.next()->Print();
+  for (HeapObject* obj = it.next(); obj != NULL; obj = it.next()) {
+    obj->Print();
   }
 }
 
 
 void LargeObjectSpace::ReportStatistics() {
   PrintF("  size: %d\n", size_);
   int num_objects = 0;
   ClearHistograms();
   LargeObjectIterator it(this);
-  while (it.has_next()) {
+  for (HeapObject* obj = it.next(); obj != NULL; obj = it.next()) {
     num_objects++;
-    CollectHistogramInfo(it.next());
+    CollectHistogramInfo(obj);
   }
 
   PrintF("  number of objects %d\n", num_objects);
   if (num_objects > 0) ReportHistogram(false);
 }
 
 
 void LargeObjectSpace::CollectCodeStatistics() {
   LargeObjectIterator obj_it(this);
-  while (obj_it.has_next()) {
-    HeapObject* obj = obj_it.next();
+  for (HeapObject* obj = obj_it.next(); obj != NULL; obj = obj_it.next()) {
     if (obj->IsCode()) {
       Code* code = Code::cast(obj);
       code_kind_statistics[code->kind()] += code->Size();
     }
   }
 }
 
 
 void LargeObjectSpace::PrintRSet() {
   LargeObjectIterator it(this);
-  while (it.has_next()) {
-    HeapObject* object = it.next();
+  for (HeapObject* object = it.next(); object != NULL; object = it.next()) {
     if (object->IsFixedArray()) {
       Page* page = Page::FromAddress(object->address());
 
       Address allocation_top = object->address() + object->Size();
       PrintF("large page 0x%x:\n", page);
       PrintRSetRange(page->RSetStart(), page->RSetEnd(),
                      reinterpret_cast<Object**>(object->address()),
                      allocation_top);
       int extra_array_bytes = object->Size() - Page::kObjectAreaSize;
       int extra_rset_bits = RoundUp(extra_array_bytes / kPointerSize,
                                     kBitsPerInt);
       PrintF("------------------------------------------------------------"
              "-----------\n");
       PrintRSetRange(allocation_top,
                      allocation_top + extra_rset_bits / kBitsPerByte,
                      reinterpret_cast<Object**>(object->address()
                                                 + Page::kObjectAreaSize),
                      allocation_top);
       PrintF("\n");
     }
   }
 }
 #endif  // DEBUG
 
 } }  // namespace v8::internal