Revert of [heap] Unify evacuating an object for new and old generation.

src/heap/mark-compact.cc

 // Copyright 2012 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/mark-compact.h"
 
 #include "src/base/atomicops.h"
 #include "src/base/bits.h"
 #include "src/base/sys-info.h"
 #include "src/code-stubs.h"
@@ skipping 1538 matching lines @@
 }
 
 
 class MarkCompactCollector::HeapObjectVisitor {
  public:
   virtual ~HeapObjectVisitor() {}
   virtual bool Visit(HeapObject* object) = 0;
 };
 
 
-class MarkCompactCollector::EvacuateVisitorBase
-    : public MarkCompactCollector::HeapObjectVisitor {
- public:
-  EvacuateVisitorBase(Heap* heap, SlotsBuffer** evacuation_slots_buffer)
-      : heap_(heap), evacuation_slots_buffer_(evacuation_slots_buffer) {}
-
-  bool TryEvacuateObject(PagedSpace* target_space, HeapObject* object,
-                         HeapObject** target_object) {
-    int size = object->Size();
-    AllocationAlignment alignment = object->RequiredAlignment();
-    AllocationResult allocation = target_space->AllocateRaw(size, alignment);
-    if (allocation.To(target_object)) {
-      heap_->mark_compact_collector()->MigrateObject(
-          *target_object, object, size, target_space->identity(),
-          evacuation_slots_buffer_);
-      return true;
-    }
-    return false;
-  }
-
- protected:
-  Heap* heap_;
-  SlotsBuffer** evacuation_slots_buffer_;
-};
-
-
 class MarkCompactCollector::EvacuateNewSpaceVisitor
-    : public MarkCompactCollector::EvacuateVisitorBase {
+    : public MarkCompactCollector::HeapObjectVisitor {
  public:
-  explicit EvacuateNewSpaceVisitor(Heap* heap,
-                                   SlotsBuffer** evacuation_slots_buffer)
-      : EvacuateVisitorBase(heap, evacuation_slots_buffer) {}
+  explicit EvacuateNewSpaceVisitor(Heap* heap) : heap_(heap) {}
 
   virtual bool Visit(HeapObject* object) {
     Heap::UpdateAllocationSiteFeedback(object, Heap::RECORD_SCRATCHPAD_SLOT);
     int size = object->Size();
-    HeapObject* target_object = nullptr;
+
+    // TODO(hpayer): Refactor EvacuateObject and call this function instead.
     if (heap_->ShouldBePromoted(object->address(), size) &&
-        TryEvacuateObject(heap_->old_space(), object, &target_object)) {
-      // If we end up needing more special cases, we should factor this out.
-      if (V8_UNLIKELY(target_object->IsJSArrayBuffer())) {
-        heap_->array_buffer_tracker()->Promote(
-            JSArrayBuffer::cast(target_object));
-      }
-      heap_->IncrementPromotedObjectsSize(size);
+        heap_->mark_compact_collector()->TryPromoteObject(object, size)) {
       return true;
     }
 
     AllocationAlignment alignment = object->RequiredAlignment();
     AllocationResult allocation =
         heap_->new_space()->AllocateRaw(size, alignment);
     if (allocation.IsRetry()) {
       if (!heap_->new_space()->AddFreshPage()) {
         // Shouldn't happen. We are sweeping linearly, and to-space
         // has the same number of pages as from-space, so there is
         // always room unless we are in an OOM situation.
         FatalProcessOutOfMemory("MarkCompactCollector: semi-space copy\n");
       }
       allocation = heap_->new_space()->AllocateRaw(size, alignment);
       DCHECK(!allocation.IsRetry());
     }
     Object* target = allocation.ToObjectChecked();
 
     heap_->mark_compact_collector()->MigrateObject(
         HeapObject::cast(target), object, size, NEW_SPACE, nullptr);
     if (V8_UNLIKELY(target->IsJSArrayBuffer())) {
       heap_->array_buffer_tracker()->MarkLive(JSArrayBuffer::cast(target));
     }
     heap_->IncrementSemiSpaceCopiedObjectSize(size);
     return true;
   }
+
+ private:
+  Heap* heap_;
 };
 
 
 class MarkCompactCollector::EvacuateOldSpaceVisitor
-    : public MarkCompactCollector::EvacuateVisitorBase {
+    : public MarkCompactCollector::HeapObjectVisitor {
  public:
   EvacuateOldSpaceVisitor(Heap* heap,
                           CompactionSpaceCollection* compaction_spaces,
                           SlotsBuffer** evacuation_slots_buffer)
-      : EvacuateVisitorBase(heap, evacuation_slots_buffer),
-        compaction_spaces_(compaction_spaces) {}
+      : heap_(heap),
+        compaction_spaces_(compaction_spaces),
+        evacuation_slots_buffer_(evacuation_slots_buffer) {}
 
   virtual bool Visit(HeapObject* object) {
-    CompactionSpace* target_space = compaction_spaces_->Get(
-        Page::FromAddress(object->address())->owner()->identity());
+    int size = object->Size();
+    AllocationAlignment alignment = object->RequiredAlignment();
     HeapObject* target_object = nullptr;
-    if (TryEvacuateObject(target_space, object, &target_object)) {
-      DCHECK(object->map_word().IsForwardingAddress());
-      return true;
+    AllocationSpace id =
+        Page::FromAddress(object->address())->owner()->identity();
+    AllocationResult allocation =
+        compaction_spaces_->Get(id)->AllocateRaw(size, alignment);
+    if (!allocation.To(&target_object)) {
+      return false;
     }
-    return false;
+    heap_->mark_compact_collector()->MigrateObject(
+        target_object, object, size, id, evacuation_slots_buffer_);
+    DCHECK(object->map_word().IsForwardingAddress());
+    return true;
   }
 
  private:
+  Heap* heap_;
   CompactionSpaceCollection* compaction_spaces_;
+  SlotsBuffer** evacuation_slots_buffer_;
 };
 
 
 bool MarkCompactCollector::IterateLiveObjectsOnPage(MemoryChunk* page,
                                                     HeapObjectVisitor* visitor,
                                                     IterationMode mode) {
   Address offsets[16];
   for (MarkBitCellIterator it(page); !it.Done(); it.Advance()) {
     Address cell_base = it.CurrentCellBase();
     MarkBit::CellType* cell = it.CurrentCell();
@@ skipping 1338 matching lines @@
   MapWord map_word = HeapObject::cast(*p)->map_word();
 
   if (map_word.IsForwardingAddress()) {
     return String::cast(map_word.ToForwardingAddress());
   }
 
   return String::cast(*p);
 }
 
 
+bool MarkCompactCollector::TryPromoteObject(HeapObject* object,
+                                            int object_size) {
+  OldSpace* old_space = heap()->old_space();
+
+  HeapObject* target = nullptr;
+  AllocationAlignment alignment = object->RequiredAlignment();
+  AllocationResult allocation = old_space->AllocateRaw(object_size, alignment);
+  if (allocation.To(&target)) {
+    MigrateObject(target, object, object_size, old_space->identity(),
+                  &migration_slots_buffer_);
+    // If we end up needing more special cases, we should factor this out.
+    if (V8_UNLIKELY(target->IsJSArrayBuffer())) {
+      heap()->array_buffer_tracker()->Promote(JSArrayBuffer::cast(target));
+    }
+    heap()->IncrementPromotedObjectsSize(object_size);
+    return true;
+  }
+
+  return false;
+}
+
+
 bool MarkCompactCollector::IsSlotInBlackObject(Page* p, Address slot,
                                                HeapObject** out_object) {
   Space* owner = p->owner();
   if (owner == heap_->lo_space() || owner == NULL) {
     Object* large_object = heap_->lo_space()->FindObject(slot);
     // This object has to exist, otherwise we would not have recorded a slot
     // for it.
     CHECK(large_object->IsHeapObject());
     HeapObject* large_heap_object = HeapObject::cast(large_object);
     if (IsMarked(large_heap_object)) {
@@ skipping 152 matching lines @@
   new_space->Flip();
   new_space->ResetAllocationInfo();
 
   int survivors_size = 0;
 
   // First pass: traverse all objects in inactive semispace, remove marks,
   // migrate live objects and write forwarding addresses.  This stage puts
   // new entries in the store buffer and may cause some pages to be marked
   // scan-on-scavenge.
   NewSpacePageIterator it(from_bottom, from_top);
-  EvacuateNewSpaceVisitor new_space_visitor(heap(), &migration_slots_buffer_);
+  EvacuateNewSpaceVisitor new_space_visitor(heap());
   while (it.has_next()) {
     NewSpacePage* p = it.next();
     survivors_size += p->LiveBytes();
     bool ok = IterateLiveObjectsOnPage(p, &new_space_visitor, kClearMarkbits);
     USE(ok);
     DCHECK(ok);
   }
 
   heap_->IncrementYoungSurvivorsCounter(survivors_size);
   new_space->set_age_mark(new_space->top());
@@ skipping 971 matching lines @@
     MarkBit mark_bit = Marking::MarkBitFrom(host);
     if (Marking::IsBlack(mark_bit)) {
       RelocInfo rinfo(pc, RelocInfo::CODE_TARGET, 0, host);
       RecordRelocSlot(&rinfo, target);
     }
   }
 }
 
 }  // namespace internal
 }  // namespace v8