[Isolates] Make MarkCompactCollector::IterateLiveObject to treat callback as a method of the class.

src/mark-compact.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 2077 matching lines @@
 
 
 // Iterate the live objects in a range of addresses (eg, a page or a
 // semispace).  The live regions of the range have been linked into a list.
 // The first live region is [first_live_start, first_live_end), and the last
 // address in the range is top.  The callback function is used to get the
 // size of each live object.
 int MarkCompactCollector::IterateLiveObjectsInRange(
     Address start,
     Address end,
-    HeapObjectCallback size_func) {
+    LiveObjectCallback size_func) {
   int live_objects_size = 0;
   Address current = start;
   while (current < end) {
     uint32_t encoded_map = Memory::uint32_at(current);
     if (encoded_map == kSingleFreeEncoding) {
       current += kPointerSize;
     } else if (encoded_map == kMultiFreeEncoding) {
       current += Memory::int_at(current + kIntSize);
     } else {
-      int size = size_func(HeapObject::FromAddress(current));
+      int size = (this->*size_func)(HeapObject::FromAddress(current));
       current += size;
       live_objects_size += size;
     }
   }
   return live_objects_size;
 }
 
 
-int MarkCompactCollector::IterateLiveObjects(NewSpace* space,
-                                             HeapObjectCallback size_f) {
+int MarkCompactCollector::IterateLiveObjects(
+    NewSpace* space, LiveObjectCallback size_f) {
   ASSERT(MARK_LIVE_OBJECTS < state_ && state_ <= RELOCATE_OBJECTS);
   return IterateLiveObjectsInRange(space->bottom(), space->top(), size_f);
 }
 
 
-int MarkCompactCollector::IterateLiveObjects(PagedSpace* space,
-                                             HeapObjectCallback size_f) {
+int MarkCompactCollector::IterateLiveObjects(
+    PagedSpace* space, LiveObjectCallback size_f) {
   ASSERT(MARK_LIVE_OBJECTS < state_ && state_ <= RELOCATE_OBJECTS);
   int total = 0;
   PageIterator it(space, PageIterator::PAGES_IN_USE);
   while (it.has_next()) {
     Page* p = it.next();
     total += IterateLiveObjectsInRange(p->ObjectAreaStart(),
                                        p->AllocationTop(),
                                        size_f);
   }
   return total;
 }
 
 
 // -------------------------------------------------------------------------
 // Phase 3: Update pointers
 
 // Helper class for updating pointers in HeapObjects.
 class UpdatingVisitor: public ObjectVisitor {
  public:
-  UpdatingVisitor() {}
+  explicit UpdatingVisitor(Heap* heap) : heap_(heap) {}
 
   void VisitPointer(Object** p) {
     UpdatePointer(p);
   }
 
   void VisitPointers(Object** start, Object** end) {
     // Mark all HeapObject pointers in [start, end)
     for (Object** p = start; p < end; p++) UpdatePointer(p);
   }
 
@@ skipping 16 matching lines @@
         reinterpret_cast<Code*>(target)->instruction_start());
   }
 
  private:
   void UpdatePointer(Object** p) {
     if (!(*p)->IsHeapObject()) return;
 
     HeapObject* obj = HeapObject::cast(*p);
     Address old_addr = obj->address();
     Address new_addr;
-    ASSERT(!HEAP->InFromSpace(obj));
+    ASSERT(!heap_->InFromSpace(obj));
 
-    if (HEAP->new_space()->Contains(obj)) {
+    if (heap_->new_space()->Contains(obj)) {
       Address forwarding_pointer_addr =
-          HEAP->new_space()->FromSpaceLow() +
-          HEAP->new_space()->ToSpaceOffsetForAddress(old_addr);
+          heap_->new_space()->FromSpaceLow() +
+          heap_->new_space()->ToSpaceOffsetForAddress(old_addr);
       new_addr = Memory::Address_at(forwarding_pointer_addr);
 
 #ifdef DEBUG
-      ASSERT(HEAP->old_pointer_space()->Contains(new_addr) ||
-             HEAP->old_data_space()->Contains(new_addr) ||
-             HEAP->new_space()->FromSpaceContains(new_addr) ||
-             HEAP->lo_space()->Contains(HeapObject::FromAddress(new_addr)));
+      ASSERT(heap_->old_pointer_space()->Contains(new_addr) ||
+             heap_->old_data_space()->Contains(new_addr) ||
+             heap_->new_space()->FromSpaceContains(new_addr) ||
+             heap_->lo_space()->Contains(HeapObject::FromAddress(new_addr)));
 
-      if (HEAP->new_space()->FromSpaceContains(new_addr)) {
-        ASSERT(HEAP->new_space()->FromSpaceOffsetForAddress(new_addr) <=
-               HEAP->new_space()->ToSpaceOffsetForAddress(old_addr));
+      if (heap_->new_space()->FromSpaceContains(new_addr)) {
+        ASSERT(heap_->new_space()->FromSpaceOffsetForAddress(new_addr) <=
+               heap_->new_space()->ToSpaceOffsetForAddress(old_addr));
       }
 #endif
 
-    } else if (HEAP->lo_space()->Contains(obj)) {
+    } else if (heap_->lo_space()->Contains(obj)) {
       // Don't move objects in the large object space.
       return;
 
     } else {
 #ifdef DEBUG
       PagedSpaces spaces;
       PagedSpace* original_space = spaces.next();
       while (original_space != NULL) {
         if (original_space->Contains(obj)) break;
         original_space = spaces.next();
       }
       ASSERT(original_space != NULL);
 #endif
       new_addr = MarkCompactCollector::GetForwardingAddressInOldSpace(obj);
       ASSERT(original_space->Contains(new_addr));
       ASSERT(original_space->MCSpaceOffsetForAddress(new_addr) <=
              original_space->MCSpaceOffsetForAddress(old_addr));
     }
 
     *p = HeapObject::FromAddress(new_addr);
 
 #ifdef DEBUG
     if (FLAG_gc_verbose) {
       PrintF("update %p : %p -> %p\n",
              reinterpret_cast<Address>(p), old_addr, new_addr);
     }
 #endif
   }
+
+  Heap* heap_;
 };
 
 
 void MarkCompactCollector::UpdatePointers() {
 #ifdef DEBUG
   ASSERT(state_ == ENCODE_FORWARDING_ADDRESSES);
   state_ = UPDATE_POINTERS;
 #endif
-  UpdatingVisitor updating_visitor;
+  UpdatingVisitor updating_visitor(heap_);
   heap_->IterateRoots(&updating_visitor, VISIT_ONLY_STRONG);
   heap_->isolate_->global_handles()->IterateWeakRoots(&updating_visitor);
 
-  int live_maps_size = IterateLiveObjects(heap_->map_space(),
-                                          &UpdatePointersInOldObject);
-  int live_pointer_olds_size = IterateLiveObjects(heap_->old_pointer_space(),
-                                                  &UpdatePointersInOldObject);
-  int live_data_olds_size = IterateLiveObjects(heap_->old_data_space(),
-                                               &UpdatePointersInOldObject);
-  int live_codes_size = IterateLiveObjects(heap_->code_space(),
-                                           &UpdatePointersInOldObject);
-  int live_cells_size = IterateLiveObjects(heap_->cell_space(),
-                                           &UpdatePointersInOldObject);
-  int live_news_size = IterateLiveObjects(heap_->new_space(),
-                                          &UpdatePointersInNewObject);
+  int live_maps_size = IterateLiveObjects(
+      heap_->map_space(), &MarkCompactCollector::UpdatePointersInOldObject);
+  int live_pointer_olds_size = IterateLiveObjects(
+      heap_->old_pointer_space(),
+      &MarkCompactCollector::UpdatePointersInOldObject);
+  int live_data_olds_size = IterateLiveObjects(
+      heap_->old_data_space(),
+      &MarkCompactCollector::UpdatePointersInOldObject);
+  int live_codes_size = IterateLiveObjects(
+      heap_->code_space(), &MarkCompactCollector::UpdatePointersInOldObject);
+  int live_cells_size = IterateLiveObjects(
+      heap_->cell_space(), &MarkCompactCollector::UpdatePointersInOldObject);
+  int live_news_size = IterateLiveObjects(
+      heap_->new_space(), &MarkCompactCollector::UpdatePointersInNewObject);
 
   // Large objects do not move, the map word can be updated directly.
   LargeObjectIterator it(heap_->lo_space());
   for (HeapObject* obj = it.next(); obj != NULL; obj = it.next())
     UpdatePointersInNewObject(obj);
 
   USE(live_maps_size);
   USE(live_pointer_olds_size);
   USE(live_data_olds_size);
   USE(live_codes_size);
   USE(live_cells_size);
   USE(live_news_size);
   ASSERT(live_maps_size == live_map_objects_size_);
   ASSERT(live_data_olds_size == live_old_data_objects_size_);
   ASSERT(live_pointer_olds_size == live_old_pointer_objects_size_);
   ASSERT(live_codes_size == live_code_objects_size_);
   ASSERT(live_cells_size == live_cell_objects_size_);
   ASSERT(live_news_size == live_young_objects_size_);
 }
 
 
 int MarkCompactCollector::UpdatePointersInNewObject(HeapObject* obj) {
   // Keep old map pointers
   Map* old_map = obj->map();
   ASSERT(old_map->IsHeapObject());
 
   Address forwarded = GetForwardingAddressInOldSpace(old_map);
 
-  ASSERT(HEAP->map_space()->Contains(old_map));
-  ASSERT(HEAP->map_space()->Contains(forwarded));
+  ASSERT(heap_->map_space()->Contains(old_map));
+  ASSERT(heap_->map_space()->Contains(forwarded));
 #ifdef DEBUG
   if (FLAG_gc_verbose) {
     PrintF("update %p : %p -> %p\n", obj->address(), old_map->address(),
            forwarded);
   }
 #endif
   // Update the map pointer.
   obj->set_map(reinterpret_cast<Map*>(HeapObject::FromAddress(forwarded)));
 
   // We have to compute the object size relying on the old map because
   // map objects are not relocated yet.
   int obj_size = obj->SizeFromMap(old_map);
 
   // Update pointers in the object body.
-  UpdatingVisitor updating_visitor;
+  UpdatingVisitor updating_visitor(heap_);
   obj->IterateBody(old_map->instance_type(), obj_size, &updating_visitor);
   return obj_size;
 }
 
 
 int MarkCompactCollector::UpdatePointersInOldObject(HeapObject* obj) {
   // Decode the map pointer.
   MapWord encoding = obj->map_word();
-  Address map_addr = encoding.DecodeMapAddress(HEAP->map_space());
-  ASSERT(HEAP->map_space()->Contains(HeapObject::FromAddress(map_addr)));
+  Address map_addr = encoding.DecodeMapAddress(heap_->map_space());
+  ASSERT(heap_->map_space()->Contains(HeapObject::FromAddress(map_addr)));
 
   // At this point, the first word of map_addr is also encoded, cannot
   // cast it to Map* using Map::cast.
   Map* map = reinterpret_cast<Map*>(HeapObject::FromAddress(map_addr));
   int obj_size = obj->SizeFromMap(map);
   InstanceType type = map->instance_type();
 
   // Update map pointer.
   Address new_map_addr = GetForwardingAddressInOldSpace(map);
   int offset = encoding.DecodeOffset();
   obj->set_map_word(MapWord::EncodeAddress(new_map_addr, offset));
 
 #ifdef DEBUG
   if (FLAG_gc_verbose) {
     PrintF("update %p : %p -> %p\n", obj->address(),
            map_addr, new_map_addr);
   }
 #endif
 
   // Update pointers in the object body.
-  UpdatingVisitor updating_visitor;
+  UpdatingVisitor updating_visitor(heap_);
   obj->IterateBody(type, obj_size, &updating_visitor);
   return obj_size;
 }
 
 
 Address MarkCompactCollector::GetForwardingAddressInOldSpace(HeapObject* obj) {
   // Object should either in old or map space.
   MapWord encoding = obj->map_word();
 
   // Offset to the first live object's forwarding address.
@@ skipping 35 matching lines @@
 // -------------------------------------------------------------------------
 // Phase 4: Relocate objects
 
 void MarkCompactCollector::RelocateObjects() {
 #ifdef DEBUG
   ASSERT(state_ == UPDATE_POINTERS);
   state_ = RELOCATE_OBJECTS;
 #endif
   // Relocates objects, always relocate map objects first. Relocating
   // objects in other space relies on map objects to get object size.
-  int live_maps_size = IterateLiveObjects(heap_->map_space(),
-                                          &RelocateMapObject);
-  int live_pointer_olds_size = IterateLiveObjects(heap_->old_pointer_space(),
-                                                  &RelocateOldPointerObject);
-  int live_data_olds_size = IterateLiveObjects(heap_->old_data_space(),
-                                               &RelocateOldDataObject);
-  int live_codes_size = IterateLiveObjects(heap_->code_space(),
-                                           &RelocateCodeObject);
-  int live_cells_size = IterateLiveObjects(heap_->cell_space(),
-                                           &RelocateCellObject);
-  int live_news_size = IterateLiveObjects(heap_->new_space(),
-                                          &RelocateNewObject);
+  int live_maps_size = IterateLiveObjects(
+      heap_->map_space(), &MarkCompactCollector::RelocateMapObject);
+  int live_pointer_olds_size = IterateLiveObjects(
+      heap_->old_pointer_space(),
+      &MarkCompactCollector::RelocateOldPointerObject);
+  int live_data_olds_size = IterateLiveObjects(
+      heap_->old_data_space(), &MarkCompactCollector::RelocateOldDataObject);
+  int live_codes_size = IterateLiveObjects(
+      heap_->code_space(), &MarkCompactCollector::RelocateCodeObject);
+  int live_cells_size = IterateLiveObjects(
+      heap_->cell_space(), &MarkCompactCollector::RelocateCellObject);
+  int live_news_size = IterateLiveObjects(
+      heap_->new_space(), &MarkCompactCollector::RelocateNewObject);
 
   USE(live_maps_size);
   USE(live_pointer_olds_size);
   USE(live_data_olds_size);
   USE(live_codes_size);
   USE(live_cells_size);
   USE(live_news_size);
   ASSERT(live_maps_size == live_map_objects_size_);
   ASSERT(live_data_olds_size == live_old_data_objects_size_);
   ASSERT(live_pointer_olds_size == live_old_pointer_objects_size_);
@@ skipping 15 matching lines @@
     space->MCCommitRelocationInfo();
 
   heap_->CheckNewSpaceExpansionCriteria();
   heap_->IncrementYoungSurvivorsCounter(live_news_size);
 }
 
 
 int MarkCompactCollector::RelocateMapObject(HeapObject* obj) {
   // Recover map pointer.
   MapWord encoding = obj->map_word();
-  Address map_addr = encoding.DecodeMapAddress(HEAP->map_space());
-  ASSERT(HEAP->map_space()->Contains(HeapObject::FromAddress(map_addr)));
+  Address map_addr = encoding.DecodeMapAddress(heap_->map_space());
+  ASSERT(heap_->map_space()->Contains(HeapObject::FromAddress(map_addr)));
 
   // Get forwarding address before resetting map pointer
   Address new_addr = GetForwardingAddressInOldSpace(obj);
 
   // Reset map pointer.  The meta map object may not be copied yet so
   // Map::cast does not yet work.
   obj->set_map(reinterpret_cast<Map*>(HeapObject::FromAddress(map_addr)));
 
   Address old_addr = obj->address();
 
   if (new_addr != old_addr) {
     // Move contents.
-    HEAP->MoveBlockToOldSpaceAndUpdateRegionMarks(new_addr,
-                                                  old_addr,
-                                                  Map::kSize);
+    heap_->MoveBlockToOldSpaceAndUpdateRegionMarks(new_addr,
+                                                   old_addr,
+                                                   Map::kSize);
   }
 
 #ifdef DEBUG
   if (FLAG_gc_verbose) {
     PrintF("relocate %p -> %p\n", old_addr, new_addr);
   }
 #endif
 
   return Map::kSize;
 }
@@ skipping 58 matching lines @@
   if (copied_to->IsJSFunction()) {
     PROFILE(FunctionMoveEvent(old_addr, new_addr));
   }
   HEAP_PROFILE(heap_, ObjectMoveEvent(old_addr, new_addr));
 
   return obj_size;
 }
 
 
 int MarkCompactCollector::RelocateOldPointerObject(HeapObject* obj) {
-  Heap* heap = HEAP;
-  return heap->mark_compact_collector()->RelocateOldNonCodeObject(
-      obj, heap->old_pointer_space());
+  return RelocateOldNonCodeObject(obj, heap_->old_pointer_space());
 }
 
 
 int MarkCompactCollector::RelocateOldDataObject(HeapObject* obj) {
-  Heap* heap = HEAP;
-  return heap->mark_compact_collector()->RelocateOldNonCodeObject(
-      obj, heap->old_data_space());
+  return RelocateOldNonCodeObject(obj, heap_->old_data_space());
 }
 
 
 int MarkCompactCollector::RelocateCellObject(HeapObject* obj) {
-  Heap* heap = HEAP;
-  return heap->mark_compact_collector()->RelocateOldNonCodeObject(
-      obj, heap->cell_space());
+  return RelocateOldNonCodeObject(obj, heap_->cell_space());
 }
 
 
 int MarkCompactCollector::RelocateCodeObject(HeapObject* obj) {
   // Recover map pointer.
   MapWord encoding = obj->map_word();
-  Heap* heap = HEAP;
-  Address map_addr = encoding.DecodeMapAddress(heap->map_space());
-  ASSERT(heap->map_space()->Contains(HeapObject::FromAddress(map_addr)));
+  Address map_addr = encoding.DecodeMapAddress(heap_->map_space());
+  ASSERT(heap_->map_space()->Contains(HeapObject::FromAddress(map_addr)));
 
   // Get forwarding address before resetting map pointer
   Address new_addr = GetForwardingAddressInOldSpace(obj);
 
   // Reset the map pointer.
-  int obj_size = RestoreMap(obj, heap->code_space(), new_addr, map_addr);
+  int obj_size = RestoreMap(obj, heap_->code_space(), new_addr, map_addr);
 
   Address old_addr = obj->address();
 
   if (new_addr != old_addr) {
     // Move contents.
-    heap->MoveBlock(new_addr, old_addr, obj_size);
+    heap_->MoveBlock(new_addr, old_addr, obj_size);
   }
 
   HeapObject* copied_to = HeapObject::FromAddress(new_addr);
   if (copied_to->IsCode()) {
     // May also update inline cache target.
     Code::cast(copied_to)->Relocate(new_addr - old_addr);
     // Notify the logger that compiled code has moved.
     PROFILE(CodeMoveEvent(old_addr, new_addr));
   }
-  HEAP_PROFILE(heap, ObjectMoveEvent(old_addr, new_addr));
+  HEAP_PROFILE(heap_, ObjectMoveEvent(old_addr, new_addr));
 
   return obj_size;
 }
 
 
 int MarkCompactCollector::RelocateNewObject(HeapObject* obj) {
   int obj_size = obj->Size();
 
   // Get forwarding address
   Address old_addr = obj->address();
-  Heap* heap = HEAP;
-  int offset = heap->new_space()->ToSpaceOffsetForAddress(old_addr);
+  int offset = heap_->new_space()->ToSpaceOffsetForAddress(old_addr);
 
   Address new_addr =
-    Memory::Address_at(heap->new_space()->FromSpaceLow() + offset);
+    Memory::Address_at(heap_->new_space()->FromSpaceLow() + offset);
 
 #ifdef DEBUG
-  if (heap->new_space()->FromSpaceContains(new_addr)) {
-    ASSERT(heap->new_space()->FromSpaceOffsetForAddress(new_addr) <=
-           heap->new_space()->ToSpaceOffsetForAddress(old_addr));
+  if (heap_->new_space()->FromSpaceContains(new_addr)) {
+    ASSERT(heap_->new_space()->FromSpaceOffsetForAddress(new_addr) <=
+           heap_->new_space()->ToSpaceOffsetForAddress(old_addr));
   } else {
-    ASSERT(heap->TargetSpace(obj) == heap->old_pointer_space() ||
-           heap->TargetSpace(obj) == heap->old_data_space());
+    ASSERT(heap_->TargetSpace(obj) == heap_->old_pointer_space() ||
+           heap_->TargetSpace(obj) == heap_->old_data_space());
   }
 #endif
 
   // New and old addresses cannot overlap.
-  if (heap->InNewSpace(HeapObject::FromAddress(new_addr))) {
-    heap->CopyBlock(new_addr, old_addr, obj_size);
+  if (heap_->InNewSpace(HeapObject::FromAddress(new_addr))) {
+    heap_->CopyBlock(new_addr, old_addr, obj_size);
   } else {
-    heap->CopyBlockToOldSpaceAndUpdateRegionMarks(new_addr,
-                                                  old_addr,
-                                                  obj_size);
+    heap_->CopyBlockToOldSpaceAndUpdateRegionMarks(new_addr,
+                                                   old_addr,
+                                                   obj_size);
   }
 
 #ifdef DEBUG
   if (FLAG_gc_verbose) {
     PrintF("relocate %p -> %p\n", old_addr, new_addr);
   }
 #endif
 
   HeapObject* copied_to = HeapObject::FromAddress(new_addr);
   if (copied_to->IsJSFunction()) {
     PROFILE(FunctionMoveEvent(old_addr, new_addr));
   }
-  HEAP_PROFILE(heap, ObjectMoveEvent(old_addr, new_addr));
+  HEAP_PROFILE(heap_, ObjectMoveEvent(old_addr, new_addr));
 
   return obj_size;
 }
 
 
 void MarkCompactCollector::ReportDeleteIfNeeded(HeapObject* obj) {
 #ifdef ENABLE_LOGGING_AND_PROFILING
   if (obj->IsCode()) {
     PROFILE(CodeDeleteEvent(obj->address()));
   } else if (obj->IsJSFunction()) {
     PROFILE(FunctionDeleteEvent(obj->address()));
   }
 #endif
 }
 
 
 void MarkCompactCollector::Initialize() {
   StaticPointersToNewGenUpdatingVisitor::Initialize();
   StaticMarkingVisitor::Initialize();
 }
 
 
 } }  // namespace v8::internal