Revert of Merge cellspace into old pointer space

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/v8.h"
 
 #include "src/base/atomicops.h"
 #include "src/base/bits.h"
 #include "src/code-stubs.h"
 #include "src/compilation-cache.h"
@@ skipping 119 matching lines @@
   while (it.has_next()) {
     Page* p = it.next();
     VerifyMarking(space->heap(), p->area_start(), p->area_end());
   }
 }
 
 
 static void VerifyMarking(Heap* heap) {
   VerifyMarking(heap->old_space());
   VerifyMarking(heap->code_space());
+  VerifyMarking(heap->cell_space());
   VerifyMarking(heap->map_space());
   VerifyMarking(heap->new_space());
 
   VerifyMarkingVisitor visitor(heap);
 
   LargeObjectIterator it(heap->lo_space());
   for (HeapObject* obj = it.Next(); obj != NULL; obj = it.Next()) {
     if (MarkCompactCollector::IsMarked(obj)) {
       obj->Iterate(&visitor);
     }
@@ skipping 57 matching lines @@
     Page* p = it.next();
     if (p->IsEvacuationCandidate()) continue;
     VerifyEvacuation(p);
   }
 }
 
 
 static void VerifyEvacuation(Heap* heap) {
   VerifyEvacuation(heap, heap->old_space());
   VerifyEvacuation(heap, heap->code_space());
+  VerifyEvacuation(heap, heap->cell_space());
   VerifyEvacuation(heap, heap->map_space());
   VerifyEvacuation(heap->new_space());
 
   VerifyEvacuationVisitor visitor;
   heap->IterateStrongRoots(&visitor, VISIT_ALL);
 }
 #endif  // VERIFY_HEAP
 
 
 void MarkCompactCollector::SetUp() {
@@ skipping 32 matching lines @@
 
     if (FLAG_compact_code_space && (mode == NON_INCREMENTAL_COMPACTION ||
                                     FLAG_incremental_code_compaction)) {
       CollectEvacuationCandidates(heap()->code_space());
     } else if (FLAG_trace_fragmentation) {
       TraceFragmentation(heap()->code_space());
     }
 
     if (FLAG_trace_fragmentation) {
       TraceFragmentation(heap()->map_space());
+      TraceFragmentation(heap()->cell_space());
     }
 
     heap()->old_space()->EvictEvacuationCandidatesFromFreeLists();
     heap()->code_space()->EvictEvacuationCandidatesFromFreeLists();
 
     compacting_ = evacuation_candidates_.length() > 0;
   }
 
   return compacting_;
 }
 
 
 void MarkCompactCollector::ClearInvalidSlotsBufferEntries(PagedSpace* space) {
   PageIterator it(space);
   while (it.has_next()) {
     Page* p = it.next();
     SlotsBuffer::RemoveInvalidSlots(heap_, p->slots_buffer());
   }
 }
 
 
 void MarkCompactCollector::ClearInvalidStoreAndSlotsBufferEntries() {
   heap_->store_buffer()->ClearInvalidStoreBufferEntries();
 
   ClearInvalidSlotsBufferEntries(heap_->old_space());
   ClearInvalidSlotsBufferEntries(heap_->code_space());
+  ClearInvalidSlotsBufferEntries(heap_->cell_space());
   ClearInvalidSlotsBufferEntries(heap_->map_space());
 
   LargeObjectIterator it(heap_->lo_space());
   for (HeapObject* object = it.Next(); object != NULL; object = it.Next()) {
     MemoryChunk* chunk = MemoryChunk::FromAddress(object->address());
     SlotsBuffer::RemoveInvalidSlots(heap_, chunk->slots_buffer());
   }
 }
 
 
 #ifdef VERIFY_HEAP
 static void VerifyValidSlotsBufferEntries(Heap* heap, PagedSpace* space) {
   PageIterator it(space);
   while (it.has_next()) {
     Page* p = it.next();
     SlotsBuffer::VerifySlots(heap, p->slots_buffer());
   }
 }
 
 
 static void VerifyValidStoreAndSlotsBufferEntries(Heap* heap) {
   heap->store_buffer()->VerifyValidStoreBufferEntries();
 
   VerifyValidSlotsBufferEntries(heap, heap->old_space());
   VerifyValidSlotsBufferEntries(heap, heap->code_space());
+  VerifyValidSlotsBufferEntries(heap, heap->cell_space());
   VerifyValidSlotsBufferEntries(heap, heap->map_space());
 
   LargeObjectIterator it(heap->lo_space());
   for (HeapObject* object = it.Next(); object != NULL; object = it.Next()) {
     MemoryChunk* chunk = MemoryChunk::FromAddress(object->address());
     SlotsBuffer::VerifySlots(heap, chunk->slots_buffer());
   }
 }
 #endif
 
@@ skipping 70 matching lines @@
     NewSpacePage* p = it.next();
     CHECK(p->markbits()->IsClean());
     CHECK_EQ(0, p->LiveBytes());
   }
 }
 
 
 void MarkCompactCollector::VerifyMarkbitsAreClean() {
   VerifyMarkbitsAreClean(heap_->old_space());
   VerifyMarkbitsAreClean(heap_->code_space());
+  VerifyMarkbitsAreClean(heap_->cell_space());
   VerifyMarkbitsAreClean(heap_->map_space());
   VerifyMarkbitsAreClean(heap_->new_space());
 
   LargeObjectIterator it(heap_->lo_space());
   for (HeapObject* obj = it.Next(); obj != NULL; obj = it.Next()) {
     MarkBit mark_bit = Marking::MarkBitFrom(obj);
     CHECK(Marking::IsWhite(mark_bit));
     CHECK_EQ(0, Page::FromAddress(obj->address())->LiveBytes());
   }
 }
@@ skipping 36 matching lines @@
   while (it.has_next()) {
     Bitmap::Clear(it.next());
   }
 }
 
 
 void MarkCompactCollector::ClearMarkbits() {
   ClearMarkbitsInPagedSpace(heap_->code_space());
   ClearMarkbitsInPagedSpace(heap_->map_space());
   ClearMarkbitsInPagedSpace(heap_->old_space());
+  ClearMarkbitsInPagedSpace(heap_->cell_space());
   ClearMarkbitsInNewSpace(heap_->new_space());
 
   LargeObjectIterator it(heap_->lo_space());
   for (HeapObject* obj = it.Next(); obj != NULL; obj = it.Next()) {
     MarkBit mark_bit = Marking::MarkBitFrom(obj);
     mark_bit.Clear();
     mark_bit.Next().Clear();
     Page::FromAddress(obj->address())->ResetProgressBar();
     Page::FromAddress(obj->address())->ResetLiveBytes();
   }
@@ skipping 123 matching lines @@
 const char* AllocationSpaceName(AllocationSpace space) {
   switch (space) {
     case NEW_SPACE:
       return "NEW_SPACE";
     case OLD_SPACE:
       return "OLD_SPACE";
     case CODE_SPACE:
       return "CODE_SPACE";
     case MAP_SPACE:
       return "MAP_SPACE";
+    case CELL_SPACE:
+      return "CELL_SPACE";
     case LO_SPACE:
       return "LO_SPACE";
     default:
       UNREACHABLE();
   }
 
   return NULL;
 }
 
 
@@ skipping 1458 matching lines @@
 
   DiscoverGreyObjectsInSpace(heap(), &marking_deque_, heap()->old_space());
   if (marking_deque_.IsFull()) return;
 
   DiscoverGreyObjectsInSpace(heap(), &marking_deque_, heap()->code_space());
   if (marking_deque_.IsFull()) return;
 
   DiscoverGreyObjectsInSpace(heap(), &marking_deque_, heap()->map_space());
   if (marking_deque_.IsFull()) return;
 
+  DiscoverGreyObjectsInSpace(heap(), &marking_deque_, heap()->cell_space());
+  if (marking_deque_.IsFull()) return;
+
   LargeObjectIterator lo_it(heap()->lo_space());
   DiscoverGreyObjectsWithIterator(heap(), &marking_deque_, &lo_it);
   if (marking_deque_.IsFull()) return;
 
   marking_deque_.ClearOverflowed();
 }
 
 
 // Mark all objects reachable (transitively) from objects on the marking
 // stack.  Before: the marking stack contains zero or more heap object
@@ skipping 170 matching lines @@
 
 #ifdef DEBUG
   DCHECK(state_ == PREPARE_GC);
   state_ = MARK_LIVE_OBJECTS;
 #endif
 
   EnsureMarkingDequeIsCommittedAndInitialize();
 
   PrepareForCodeFlushing();
 
+  if (was_marked_incrementally_) {
+    // There is no write barrier on cells so we have to scan them now at the end
+    // of the incremental marking.
+    {
+      HeapObjectIterator cell_iterator(heap()->cell_space());
+      HeapObject* cell;
+      while ((cell = cell_iterator.Next()) != NULL) {
+        DCHECK(cell->IsCell());
+        if (IsMarked(cell)) {
+          int offset = Cell::kValueOffset;
+          MarkCompactMarkingVisitor::VisitPointer(
+              heap(), reinterpret_cast<Object**>(cell->address() + offset));
+        }
+      }
+    }
+  }
+
   RootMarkingVisitor root_visitor(heap());
   MarkRoots(&root_visitor);
 
   ProcessTopOptimizedFrame(&root_visitor);
 
   // Retaining dying maps should happen before or during ephemeral marking
   // because a map could keep the key of an ephemeron alive. Note that map
   // aging is imprecise: maps that are kept alive only by ephemerons will age.
   RetainMaps();
 
@@ skipping 532 matching lines @@
 class PointersUpdatingVisitor : public ObjectVisitor {
  public:
   explicit PointersUpdatingVisitor(Heap* heap) : heap_(heap) {}
 
   void VisitPointer(Object** p) { UpdatePointer(p); }
 
   void VisitPointers(Object** start, Object** end) {
     for (Object** p = start; p < end; p++) UpdatePointer(p);
   }
 
-  void VisitCell(RelocInfo* rinfo) {
-    DCHECK(rinfo->rmode() == RelocInfo::CELL);
-    Object* cell = rinfo->target_cell();
-    Object* old_cell = cell;
-    VisitPointer(&cell);
-    if (cell != old_cell) {
-      rinfo->set_target_cell(reinterpret_cast<Cell*>(cell));
-    }
-  }
-
   void VisitEmbeddedPointer(RelocInfo* rinfo) {
     DCHECK(rinfo->rmode() == RelocInfo::EMBEDDED_OBJECT);
     Object* target = rinfo->target_object();
     Object* old_target = target;
     VisitPointer(&target);
     // Avoid unnecessary changes that might unnecessary flush the instruction
     // cache.
     if (target != old_target) {
       rinfo->set_target_object(target);
     }
@@ skipping 88 matching lines @@
   if (heap->new_space()->ToSpaceContains(slot_address)) {
     space_owner_id = 1;
   } else if (heap->new_space()->FromSpaceContains(slot_address)) {
     space_owner_id = 2;
   } else if (heap->old_space()->ContainsSafe(slot_address)) {
     space_owner_id = 3;
   } else if (heap->code_space()->ContainsSafe(slot_address)) {
     space_owner_id = 4;
   } else if (heap->map_space()->ContainsSafe(slot_address)) {
     space_owner_id = 5;
+  } else if (heap->cell_space()->ContainsSafe(slot_address)) {
+    space_owner_id = 6;
   } else {
     // Lo space or other.
-    space_owner_id = 6;
+    space_owner_id = 7;
   }
   data[index++] = space_owner_id;
   data[index++] = 0x20aaaaaaaaUL;
 
   // Find map word lying near before the slot address (usually the map word is
   // at -3 words from the slot but just in case we look up further.
   Object** map_slot = slot;
   bool found = false;
   const int kMaxDistanceToMap = 64;
   for (int i = 0; i < kMaxDistanceToMap; i++, map_slot--) {
@@ skipping 407 matching lines @@
 
 
 static inline void UpdateSlot(Isolate* isolate, ObjectVisitor* v,
                               SlotsBuffer::SlotType slot_type, Address addr) {
   switch (slot_type) {
     case SlotsBuffer::CODE_TARGET_SLOT: {
       RelocInfo rinfo(addr, RelocInfo::CODE_TARGET, 0, NULL);
       rinfo.Visit(isolate, v);
       break;
     }
-    case SlotsBuffer::CELL_TARGET_SLOT: {
-      RelocInfo rinfo(addr, RelocInfo::CELL, 0, NULL);
-      rinfo.Visit(isolate, v);
-      break;
-    }
     case SlotsBuffer::CODE_ENTRY_SLOT: {
       v->VisitCodeEntry(addr);
       break;
     }
     case SlotsBuffer::RELOCATED_CODE_OBJECT: {
       HeapObject* obj = HeapObject::FromAddress(addr);
       Code::cast(obj)->CodeIterateBody(v);
       break;
     }
     case SlotsBuffer::DEBUG_TARGET_SLOT: {
@@ skipping 377 matching lines @@
             UNREACHABLE();
             break;
         }
       }
     }
   }
 
   GCTracer::Scope gc_scope(heap()->tracer(),
                            GCTracer::Scope::MC_UPDATE_MISC_POINTERS);
 
+  // Update pointers from cells.
+  HeapObjectIterator cell_iterator(heap_->cell_space());
+  for (HeapObject* cell = cell_iterator.Next(); cell != NULL;
+       cell = cell_iterator.Next()) {
+    if (cell->IsCell()) {
+      Cell::BodyDescriptor::IterateBody(cell, &updating_visitor);
+    }
+  }
+
   heap_->string_table()->Iterate(&updating_visitor);
 
   // Update pointers from external string table.
   heap_->UpdateReferencesInExternalStringTable(
       &UpdateReferenceInExternalStringTableEntry);
 
   EvacuationWeakObjectRetainer evacuation_object_retainer;
   heap()->ProcessAllWeakReferences(&evacuation_object_retainer);
 
   // Collects callback info for handles that are pending (about to be
@@ skipping 594 matching lines @@
     }
   }
   RemoveDeadInvalidatedCode();
 
   {
     GCTracer::Scope sweep_scope(heap()->tracer(),
                                 GCTracer::Scope::MC_SWEEP_CODE);
     SweepSpace(heap()->code_space(), SEQUENTIAL_SWEEPING);
   }
 
+  {
+    GCTracer::Scope sweep_scope(heap()->tracer(),
+                                GCTracer::Scope::MC_SWEEP_CELL);
+    SweepSpace(heap()->cell_space(), SEQUENTIAL_SWEEPING);
+  }
+
   EvacuateNewSpaceAndCandidates();
 
   // ClearNonLiveReferences depends on precise sweeping of map space to
   // detect whether unmarked map became dead in this collection or in one
   // of the previous ones.
   {
     GCTracer::Scope sweep_scope(heap()->tracer(),
                                 GCTracer::Scope::MC_SWEEP_MAP);
     SweepSpace(heap()->map_space(), SEQUENTIAL_SWEEPING);
   }
@@ skipping 158 matching lines @@
       }
     }
     buffer = buffer->next();
   }
 }
 
 
 static inline SlotsBuffer::SlotType SlotTypeForRMode(RelocInfo::Mode rmode) {
   if (RelocInfo::IsCodeTarget(rmode)) {
     return SlotsBuffer::CODE_TARGET_SLOT;
-  } else if (RelocInfo::IsCell(rmode)) {
-    return SlotsBuffer::CELL_TARGET_SLOT;
   } else if (RelocInfo::IsEmbeddedObject(rmode)) {
     return SlotsBuffer::EMBEDDED_OBJECT_SLOT;
   } else if (RelocInfo::IsDebugBreakSlot(rmode)) {
     return SlotsBuffer::DEBUG_TARGET_SLOT;
   } else if (RelocInfo::IsJSReturn(rmode)) {
     return SlotsBuffer::JS_RETURN_SLOT;
   }
   UNREACHABLE();
   return SlotsBuffer::NUMBER_OF_SLOT_TYPES;
 }
@@ skipping 138 matching lines @@
   SlotsBuffer* buffer = *buffer_address;
   while (buffer != NULL) {
     SlotsBuffer* next_buffer = buffer->next();
     DeallocateBuffer(buffer);
     buffer = next_buffer;
   }
   *buffer_address = NULL;
 }
 }
 }  // namespace v8::internal