Patch for allowing several V8 instances in process:...

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 20 matching lines @@
 #include "global-handles.h"
 #include "ic-inl.h"
 #include "mark-compact.h"
 #include "stub-cache.h"
 
 namespace v8 {
 namespace internal {
 
 // -------------------------------------------------------------------------
 // MarkCompactCollector
-
-bool MarkCompactCollector::force_compaction_ = false;
-bool MarkCompactCollector::compacting_collection_ = false;
-bool MarkCompactCollector::compact_on_next_gc_ = false;
-
-int MarkCompactCollector::previous_marked_count_ = 0;
-GCTracer* MarkCompactCollector::tracer_ = NULL;
-
-
-#ifdef DEBUG
-MarkCompactCollector::CollectorState MarkCompactCollector::state_ = IDLE;
-
-// Counters used for debugging the marking phase of mark-compact or mark-sweep
-// collection.
-int MarkCompactCollector::live_bytes_ = 0;
-int MarkCompactCollector::live_young_objects_ = 0;
-int MarkCompactCollector::live_old_data_objects_ = 0;
-int MarkCompactCollector::live_old_pointer_objects_ = 0;
-int MarkCompactCollector::live_code_objects_ = 0;
-int MarkCompactCollector::live_map_objects_ = 0;
-int MarkCompactCollector::live_cell_objects_ = 0;
-int MarkCompactCollector::live_lo_objects_ = 0;
-#endif
-
 void MarkCompactCollector::CollectGarbage() {
+  MarkCompactCollectorData& data = v8_context()->mark_compact_collector_data_;
   // Make sure that Prepare() has been called. The individual steps below will
   // update the state as they proceed.
-  ASSERT(state_ == PREPARE_GC);
+  ASSERT(data.state_ == MarkCompactCollectorData::PREPARE_GC);
 
   // Prepare has selected whether to compact the old generation or not.
   // Tell the tracer.
-  if (IsCompacting()) tracer_->set_is_compacting();
+  if (IsCompacting()) data.tracer_->set_is_compacting();
 
   MarkLiveObjects();
 
   if (FLAG_collect_maps) ClearNonLiveTransitions();
 
   SweepLargeObjectSpace();
 
   if (IsCompacting()) {
     EncodeForwardingAddresses();
 
     UpdatePointers();
 
     RelocateObjects();
 
     RebuildRSets();
 
   } else {
     SweepSpaces();
   }
 
   Finish();
 
   // Save the count of marked objects remaining after the collection and
   // null out the GC tracer.
-  previous_marked_count_ = tracer_->marked_count();
-  ASSERT(previous_marked_count_ == 0);
-  tracer_ = NULL;
+  data.previous_marked_count_ = data.tracer_->marked_count();
+  ASSERT(data.previous_marked_count_ == 0);
+  data.tracer_ = NULL;
 }
 
 
 void MarkCompactCollector::Prepare(GCTracer* tracer) {
+  MarkCompactCollectorData& data = v8_context()->mark_compact_collector_data_;
   // Rather than passing the tracer around we stash it in a static member
   // variable.
-  tracer_ = tracer;
+  data.tracer_ = tracer;
 
 #ifdef DEBUG
-  ASSERT(state_ == IDLE);
-  state_ = PREPARE_GC;
+  ASSERT(data.state_ == MarkCompactCollectorData::IDLE);
+  data.state_ = MarkCompactCollectorData::PREPARE_GC;
 #endif
   ASSERT(!FLAG_always_compact || !FLAG_never_compact);
 
-  compacting_collection_ =
-      FLAG_always_compact || force_compaction_ || compact_on_next_gc_;
-  compact_on_next_gc_ = false;
+  data.compacting_collection_ =
+      FLAG_always_compact || data.force_compaction_ || data.compact_on_next_gc_;
+  data.compact_on_next_gc_ = false;
 
-  if (FLAG_never_compact) compacting_collection_ = false;
+  if (FLAG_never_compact) data.compacting_collection_ = false;
   if (FLAG_collect_maps) CreateBackPointers();
 
 #ifdef DEBUG
-  if (compacting_collection_) {
+  if (data.compacting_collection_) {
     // We will write bookkeeping information to the remembered set area
     // starting now.
     Page::set_rset_state(Page::NOT_IN_USE);
   }
 #endif
 
   PagedSpaces spaces;
   while (PagedSpace* space = spaces.next()) {
-    space->PrepareForMarkCompact(compacting_collection_);
+    space->PrepareForMarkCompact(data.compacting_collection_);
   }
 
 #ifdef DEBUG
-  live_bytes_ = 0;
-  live_young_objects_ = 0;
-  live_old_pointer_objects_ = 0;
-  live_old_data_objects_ = 0;
-  live_code_objects_ = 0;
-  live_map_objects_ = 0;
-  live_cell_objects_ = 0;
-  live_lo_objects_ = 0;
+  data.live_bytes_ = 0;
+  data.live_young_objects_ = 0;
+  data.live_old_pointer_objects_ = 0;
+  data.live_old_data_objects_ = 0;
+  data.live_code_objects_ = 0;
+  data.live_map_objects_ = 0;
+  data.live_cell_objects_ = 0;
+  data.live_lo_objects_ = 0;
 #endif
 }
 
 
 void MarkCompactCollector::Finish() {
+  MarkCompactCollectorData& data = v8_context()->mark_compact_collector_data_;
 #ifdef DEBUG
-  ASSERT(state_ == SWEEP_SPACES || state_ == REBUILD_RSETS);
-  state_ = IDLE;
+  ASSERT(data.state_ == MarkCompactCollectorData::SWEEP_SPACES ||
+         data.state_ == MarkCompactCollectorData::REBUILD_RSETS);
+  data.state_ = MarkCompactCollectorData::IDLE;
 #endif
   // The stub cache is not traversed during GC; clear the cache to
   // force lazy re-initialization of it. This must be done after the
   // GC, because it relies on the new address of certain old space
   // objects (empty string, illegal builtin).
   StubCache::Clear();
 
   // If we've just compacted old space there's no reason to check the
   // fragmentation limit. Just return.
   if (HasCompacted()) return;
 
   // We compact the old generation on the next GC if it has gotten too
   // fragmented (ie, we could recover an expected amount of space by
   // reclaiming the waste and free list blocks).
   static const int kFragmentationLimit = 15;        // Percent.
   static const int kFragmentationAllowed = 1 * MB;  // Absolute.
   int old_gen_recoverable = 0;
   int old_gen_used = 0;
 
   OldSpaces spaces;
   while (OldSpace* space = spaces.next()) {
     old_gen_recoverable += space->Waste() + space->AvailableFree();
     old_gen_used += space->Size();
   }
 
   int old_gen_fragmentation =
       static_cast<int>((old_gen_recoverable * 100.0) / old_gen_used);
   if (old_gen_fragmentation > kFragmentationLimit &&
       old_gen_recoverable > kFragmentationAllowed) {
-    compact_on_next_gc_ = true;
+    data.compact_on_next_gc_ = true;
   }
 }
 
-
+class MarkCompactCollectorPrivateData {
+ public:
 // -------------------------------------------------------------------------
 // Phase 1: tracing and marking live objects.
 //   before: all objects are in normal state.
 //   after: a live object's map pointer is marked as '00'.
 
 // Marking all live objects in the heap as part of mark-sweep or mark-compact
 // collection.  Before marking, all objects are in their normal state.  After
 // marking, live objects' map pointers are marked indicating that the object
 // has been found reachable.
 //
 // The marking algorithm is a (mostly) depth-first (because of possible stack
 // overflow) traversal of the graph of objects reachable from the roots.  It
 // uses an explicit stack of pointers rather than recursion.  The young
 // generation's inactive ('from') space is used as a marking stack.  The
 // objects in the marking stack are the ones that have been reached and marked
 // but their children have not yet been visited.
 //
 // The marking stack can overflow during traversal.  In that case, we set an
 // overflow flag.  When the overflow flag is set, we continue marking objects
 // reachable from the objects on the marking stack, but no longer push them on
 // the marking stack.  Instead, we mark them as both marked and overflowed.
 // When the stack is in the overflowed state, objects marked as overflowed
 // have been reached and marked but their children have not been visited yet.
 // After emptying the marking stack, we clear the overflow flag and traverse
 // the heap looking for objects marked as overflowed, push them on the stack,
 // and continue with marking.  This process repeats until all reachable
 // objects have been marked.
 
-static MarkingStack marking_stack;
+  MarkingStack marking_stack_;
+  MarkCompactCollectorPrivateData() {}
+  DISALLOW_COPY_AND_ASSIGN(MarkCompactCollectorPrivateData);
+};
 
+MarkCompactCollectorData::MarkCompactCollectorData()
+  :force_compaction_(false),
+  compacting_collection_(false),
+  compact_on_next_gc_(false),
+  previous_marked_count_(0),
+#ifdef DEBUG
+  state_(IDLE),
+
+// Counters used for debugging the marking phase of mark-compact or mark-sweep
+// collection.
+  live_bytes_(0),
+  live_young_objects_(0),
+  live_old_data_objects_(0),
+  live_old_pointer_objects_(0),
+  live_code_objects_(0),
+  live_map_objects_(0),
+  live_cell_objects_(0),
+  live_lo_objects_(0),
+#endif
+  tracer_(NULL),
+  private_data_(*new MarkCompactCollectorPrivateData()) {
+}
+
+MarkCompactCollectorData::~MarkCompactCollectorData() {
+  delete &private_data_;
+}
 
 static inline HeapObject* ShortCircuitConsString(Object** p) {
   // Optimization: If the heap object pointed to by p is a non-symbol
   // cons string whose right substring is Heap::empty_string, update
   // it in place to its left substring.  Return the updated value.
   //
   // Here we assume that if we change *p, we replace it with a heap object
   // (ie, the left substring of a cons string is always a heap object).
   //
   // The check performed is:
@@ skipping 191 matching lines @@
     return pointers_removed_;
   }
  private:
   int pointers_removed_;
 };
 
 
 void MarkCompactCollector::MarkUnmarkedObject(HeapObject* object) {
   ASSERT(!object->IsMarked());
   ASSERT(Heap::Contains(object));
+  MarkingStack& marking_stack = v8_context()->mark_compact_collector_data_.
+    private_data_.marking_stack_;
+
   if (object->IsMap()) {
     Map* map = Map::cast(object);
     if (FLAG_cleanup_caches_in_maps_at_gc) {
       map->ClearCodeCache();
     }
     SetMark(map);
     if (FLAG_collect_maps &&
         map->instance_type() >= FIRST_JS_OBJECT_TYPE &&
         map->instance_type() <= JS_FUNCTION_TYPE) {
       MarkMapContents(map);
@@ skipping 27 matching lines @@
   ASSERT(descriptors != Heap::raw_unchecked_empty_descriptor_array());
   SetMark(descriptors);
 
   FixedArray* contents = reinterpret_cast<FixedArray*>(
       descriptors->get(DescriptorArray::kContentArrayIndex));
   ASSERT(contents->IsHeapObject());
   ASSERT(!contents->IsMarked());
   ASSERT(contents->IsFixedArray());
   ASSERT(contents->length() >= 2);
   SetMark(contents);
+  MarkingStack& marking_stack = v8_context()->mark_compact_collector_data_.
+    private_data_.marking_stack_;
   // Contents contains (value, details) pairs.  If the details say
   // that the type of descriptor is MAP_TRANSITION, CONSTANT_TRANSITION,
   // or NULL_DESCRIPTOR, we don't mark the value as live.  Only for
   // type MAP_TRANSITION is the value a Object* (a Map*).
   for (int i = 0; i < contents->length(); i += 2) {
     // If the pair (value, details) at index i, i+1 is not
     // a transition or null descriptor, mark the value.
     PropertyDetails details(Smi::cast(contents->get(i + 1)));
     if (details.type() < FIRST_PHANTOM_PROPERTY_TYPE) {
       HeapObject* object = reinterpret_cast<HeapObject*>(contents->get(i));
@@ skipping 34 matching lines @@
   map_word.ClearOverflow();
   return obj->SizeFromMap(map_word.ToMap());
 }
 
 
 // Fill the marking stack with overflowed objects returned by the given
 // iterator.  Stop when the marking stack is filled or the end of the space
 // is reached, whichever comes first.
 template<class T>
 static void ScanOverflowedObjects(T* it) {
+  MarkingStack& marking_stack = v8_context()->mark_compact_collector_data_.
+    private_data_.marking_stack_;
   // The caller should ensure that the marking stack is initially not full,
   // so that we don't waste effort pointlessly scanning for objects.
   ASSERT(!marking_stack.is_full());
 
   while (it->has_next()) {
     HeapObject* object = it->next();
     if (object->IsOverflowed()) {
       object->ClearOverflow();
       ASSERT(object->IsMarked());
       ASSERT(Heap::Contains(object));
@@ skipping 53 matching lines @@
 
 
 void MarkCompactCollector::MarkRoots(RootMarkingVisitor* visitor) {
   // Mark the heap roots including global variables, stack variables,
   // etc., and all objects reachable from them.
   Heap::IterateStrongRoots(visitor, VISIT_ONLY_STRONG);
 
   // Handle the symbol table specially.
   MarkSymbolTable();
 
+  MarkingStack& marking_stack = v8_context()->mark_compact_collector_data_.
+    private_data_.marking_stack_;
   // There may be overflowed objects in the heap.  Visit them now.
   while (marking_stack.overflowed()) {
     RefillMarkingStack();
     EmptyMarkingStack(visitor->stack_visitor());
   }
 }
 
 
 void MarkCompactCollector::MarkObjectGroups() {
   List<ObjectGroup*>* object_groups = GlobalHandles::ObjectGroups();
@@ skipping 27 matching lines @@
     object_groups->at(i) = NULL;
   }
 }
 
 
 // Mark all objects reachable from the objects on the marking stack.
 // Before: the marking stack contains zero or more heap object pointers.
 // After: the marking stack is empty, and all objects reachable from the
 // marking stack have been marked, or are overflowed in the heap.
 void MarkCompactCollector::EmptyMarkingStack(MarkingVisitor* visitor) {
+  MarkingStack& marking_stack = v8_context()->mark_compact_collector_data_.
+    private_data_.marking_stack_;
   while (!marking_stack.is_empty()) {
     HeapObject* object = marking_stack.Pop();
     ASSERT(object->IsHeapObject());
     ASSERT(Heap::Contains(object));
     ASSERT(object->IsMarked());
     ASSERT(!object->IsOverflowed());
 
     // Because the object is marked, we have to recover the original map
     // pointer and use it to mark the object's body.
     MapWord map_word = object->map_word();
     map_word.ClearMark();
     Map* map = map_word.ToMap();
     MarkObject(map);
     object->IterateBody(map->instance_type(), object->SizeFromMap(map),
                         visitor);
   }
 }
 
 
 // Sweep the heap for overflowed objects, clear their overflow bits, and
 // push them on the marking stack.  Stop early if the marking stack fills
 // before sweeping completes.  If sweeping completes, there are no remaining
 // overflowed objects in the heap so the overflow flag on the markings stack
 // is cleared.
 void MarkCompactCollector::RefillMarkingStack() {
+  MarkingStack& marking_stack = v8_context()->mark_compact_collector_data_.
+    private_data_.marking_stack_;
   ASSERT(marking_stack.overflowed());
 
   SemiSpaceIterator new_it(Heap::new_space(), &OverflowObjectSize);
   ScanOverflowedObjects(&new_it);
   if (marking_stack.is_full()) return;
 
   HeapObjectIterator old_pointer_it(Heap::old_pointer_space(),
                                     &OverflowObjectSize);
   ScanOverflowedObjects(&old_pointer_it);
   if (marking_stack.is_full()) return;
@@ skipping 20 matching lines @@
 
   marking_stack.clear_overflowed();
 }
 
 
 // Mark all objects reachable (transitively) from objects on the marking
 // stack.  Before: the marking stack contains zero or more heap object
 // pointers.  After: the marking stack is empty and there are no overflowed
 // objects in the heap.
 void MarkCompactCollector::ProcessMarkingStack(MarkingVisitor* visitor) {
+  MarkingStack& marking_stack = v8_context()->mark_compact_collector_data_.
+    private_data_.marking_stack_;
   EmptyMarkingStack(visitor);
   while (marking_stack.overflowed()) {
     RefillMarkingStack();
     EmptyMarkingStack(visitor);
   }
 }
 
 
 void MarkCompactCollector::ProcessObjectGroups(MarkingVisitor* visitor) {
+  MarkingStack& marking_stack = v8_context()->mark_compact_collector_data_.
+    private_data_.marking_stack_;
   bool work_to_do = true;
   ASSERT(marking_stack.is_empty());
   while (work_to_do) {
     MarkObjectGroups();
     work_to_do = !marking_stack.is_empty();
     ProcessMarkingStack(visitor);
   }
 }
 
 
 void MarkCompactCollector::MarkLiveObjects() {
+  MarkCompactCollectorData& data = v8_context()->mark_compact_collector_data_;
 #ifdef DEBUG
-  ASSERT(state_ == PREPARE_GC);
-  state_ = MARK_LIVE_OBJECTS;
+  ASSERT(data.state_ == MarkCompactCollectorData::PREPARE_GC);
+  data.state_ = MarkCompactCollectorData::MARK_LIVE_OBJECTS;
 #endif
+  MarkingStack& marking_stack = data.private_data_.marking_stack_;
   // The to space contains live objects, the from space is used as a marking
   // stack.
   marking_stack.Initialize(Heap::new_space()->FromSpaceLow(),
                            Heap::new_space()->FromSpaceHigh());
 
   ASSERT(!marking_stack.overflowed());
 
   RootMarkingVisitor root_visitor;
   MarkRoots(&root_visitor);
 
@@ skipping 36 matching lines @@
 
 static int CountMarkedCallback(HeapObject* obj) {
   MapWord map_word = obj->map_word();
   map_word.ClearMark();
   return obj->SizeFromMap(map_word.ToMap());
 }
 
 
 #ifdef DEBUG
 void MarkCompactCollector::UpdateLiveObjectCount(HeapObject* obj) {
-  live_bytes_ += obj->Size();
+  MarkCompactCollectorData& data = v8_context()->mark_compact_collector_data_;
+  data.live_bytes_ += obj->Size();
   if (Heap::new_space()->Contains(obj)) {
-    live_young_objects_++;
+    data.live_young_objects_++;
   } else if (Heap::map_space()->Contains(obj)) {
     ASSERT(obj->IsMap());
-    live_map_objects_++;
+    data.live_map_objects_++;
   } else if (Heap::cell_space()->Contains(obj)) {
     ASSERT(obj->IsJSGlobalPropertyCell());
-    live_cell_objects_++;
+    data.live_cell_objects_++;
   } else if (Heap::old_pointer_space()->Contains(obj)) {
-    live_old_pointer_objects_++;
+    data.live_old_pointer_objects_++;
   } else if (Heap::old_data_space()->Contains(obj)) {
-    live_old_data_objects_++;
+    data.live_old_data_objects_++;
   } else if (Heap::code_space()->Contains(obj)) {
-    live_code_objects_++;
+    data.live_code_objects_++;
   } else if (Heap::lo_space()->Contains(obj)) {
-    live_lo_objects_++;
+    data.live_lo_objects_++;
   } else {
     UNREACHABLE();
   }
 }
 #endif  // DEBUG
 
 
 void MarkCompactCollector::SweepLargeObjectSpace() {
 #ifdef DEBUG
-  ASSERT(state_ == MARK_LIVE_OBJECTS);
-  state_ =
-      compacting_collection_ ? ENCODE_FORWARDING_ADDRESSES : SWEEP_SPACES;
+  MarkCompactCollectorData& data = v8_context()->mark_compact_collector_data_;
+  ASSERT(data.state_ == MarkCompactCollectorData::MARK_LIVE_OBJECTS);
+  data.state_ = data.compacting_collection_ ?
+    MarkCompactCollectorData::ENCODE_FORWARDING_ADDRESSES :
+    MarkCompactCollectorData::SWEEP_SPACES;
 #endif
   // Deallocate unmarked objects and clear marked bits for marked objects.
   Heap::lo_space()->FreeUnmarkedObjects();
 }
 
 // Safe to use during marking phase only.
 bool MarkCompactCollector::SafeIsMap(HeapObject* object) {
   MapWord metamap = object->map_word();
   metamap.ClearMark();
   return metamap.ToMap()->instance_type() == MAP_TYPE;
@@ skipping 410 matching lines @@
   ASSERT(size_in_bytes % size == 0);
   Heap::ClearRSetRange(start, size_in_bytes);
   Address end = start + size_in_bytes;
   for (Address a = start; a < end; a += size) {
     Heap::cell_space()->Free(a);
   }
 }
 
 
 void MarkCompactCollector::EncodeForwardingAddresses() {
-  ASSERT(state_ == ENCODE_FORWARDING_ADDRESSES);
+  ASSERT(v8_context()->mark_compact_collector_data_.state_ ==
+    MarkCompactCollectorData::ENCODE_FORWARDING_ADDRESSES);
   // Objects in the active semispace of the young generation may be
   // relocated to the inactive semispace (if not promoted).  Set the
   // relocation info to the beginning of the inactive semispace.
   Heap::new_space()->MCResetRelocationInfo();
 
   // Compute the forwarding pointers in each space.
   EncodeForwardingAddressesInPagedSpace<MCAllocateFromOldPointerSpace,
                                         IgnoreNonLiveObject>(
       Heap::old_pointer_space());
 
@@ skipping 26 matching lines @@
   // allocation top.
   Heap::old_pointer_space()->MCWriteRelocationInfoToPage();
   Heap::old_data_space()->MCWriteRelocationInfoToPage();
   Heap::code_space()->MCWriteRelocationInfoToPage();
   Heap::map_space()->MCWriteRelocationInfoToPage();
   Heap::cell_space()->MCWriteRelocationInfoToPage();
 }
 
 
 void MarkCompactCollector::SweepSpaces() {
-  ASSERT(state_ == SWEEP_SPACES);
+  ASSERT(v8_context()->mark_compact_collector_data_.state_ ==
+    MarkCompactCollectorData::SWEEP_SPACES);
   ASSERT(!IsCompacting());
   // Noncompacting collections simply sweep the spaces to clear the mark
   // bits and free the nonlive blocks (for old and map spaces).  We sweep
   // the map space last because freeing non-live maps overwrites them and
   // the other spaces rely on possibly non-live maps to get the sizes for
   // non-live objects.
   SweepSpace(Heap::old_pointer_space(), &DeallocateOldPointerBlock);
   SweepSpace(Heap::old_data_space(), &DeallocateOldDataBlock);
   SweepSpace(Heap::code_space(), &DeallocateCodeBlock);
   SweepSpace(Heap::cell_space(), &DeallocateCellBlock);
@@ skipping 23 matching lines @@
       live_objects++;
       current += size_func(HeapObject::FromAddress(current));
     }
   }
   return live_objects;
 }
 
 
 int MarkCompactCollector::IterateLiveObjects(NewSpace* space,
                                              HeapObjectCallback size_f) {
-  ASSERT(MARK_LIVE_OBJECTS < state_ && state_ <= RELOCATE_OBJECTS);
+#ifdef DEBUG
+  MarkCompactCollectorData& data = v8_context()->mark_compact_collector_data_;
+  ASSERT(MarkCompactCollectorData::MARK_LIVE_OBJECTS < data.state_ &&
+    data.state_ <= MarkCompactCollectorData::RELOCATE_OBJECTS);
+#endif
   return IterateLiveObjectsInRange(space->bottom(), space->top(), size_f);
 }
 
 
 int MarkCompactCollector::IterateLiveObjects(PagedSpace* space,
                                              HeapObjectCallback size_f) {
-  ASSERT(MARK_LIVE_OBJECTS < state_ && state_ <= RELOCATE_OBJECTS);
+#ifdef DEBUG
+  MarkCompactCollectorData& data = v8_context()->mark_compact_collector_data_;
+  ASSERT(MarkCompactCollectorData::MARK_LIVE_OBJECTS < data.state_ &&
+    data.state_ <= MarkCompactCollectorData::RELOCATE_OBJECTS);
+#endif
   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;
 }
@@ skipping 84 matching lines @@
     if (FLAG_gc_verbose) {
       PrintF("update %p : %p -> %p\n",
              reinterpret_cast<Address>(p), old_addr, new_addr);
     }
 #endif
   }
 };
 
 
 void MarkCompactCollector::UpdatePointers() {
+  MarkCompactCollectorData& data = v8_context()->mark_compact_collector_data_;
 #ifdef DEBUG
-  ASSERT(state_ == ENCODE_FORWARDING_ADDRESSES);
-  state_ = UPDATE_POINTERS;
+  ASSERT(data.state_ == MarkCompactCollectorData::ENCODE_FORWARDING_ADDRESSES);
+  data.state_ = MarkCompactCollectorData::UPDATE_POINTERS;
 #endif
   UpdatingVisitor updating_visitor;
   Heap::IterateRoots(&updating_visitor, VISIT_ONLY_STRONG);
   GlobalHandles::IterateWeakRoots(&updating_visitor);
 
   int live_maps = IterateLiveObjects(Heap::map_space(),
                                      &UpdatePointersInOldObject);
   int live_pointer_olds = IterateLiveObjects(Heap::old_pointer_space(),
                                              &UpdatePointersInOldObject);
   int live_data_olds = IterateLiveObjects(Heap::old_data_space(),
                                           &UpdatePointersInOldObject);
   int live_codes = IterateLiveObjects(Heap::code_space(),
                                       &UpdatePointersInOldObject);
   int live_cells = IterateLiveObjects(Heap::cell_space(),
                                       &UpdatePointersInOldObject);
   int live_news = IterateLiveObjects(Heap::new_space(),
                                      &UpdatePointersInNewObject);
 
   // Large objects do not move, the map word can be updated directly.
   LargeObjectIterator it(Heap::lo_space());
   while (it.has_next()) UpdatePointersInNewObject(it.next());
 
   USE(live_maps);
   USE(live_pointer_olds);
   USE(live_data_olds);
   USE(live_codes);
   USE(live_cells);
   USE(live_news);
-  ASSERT(live_maps == live_map_objects_);
-  ASSERT(live_data_olds == live_old_data_objects_);
-  ASSERT(live_pointer_olds == live_old_pointer_objects_);
-  ASSERT(live_codes == live_code_objects_);
-  ASSERT(live_cells == live_cell_objects_);
-  ASSERT(live_news == live_young_objects_);
+  ASSERT(live_maps == data.live_map_objects_);
+  ASSERT(live_data_olds == data.live_old_data_objects_);
+  ASSERT(live_pointer_olds == data.live_old_pointer_objects_);
+  ASSERT(live_codes == data.live_code_objects_);
+  ASSERT(live_cells == data.live_cell_objects_);
+  ASSERT(live_news == data.live_young_objects_);
 }
 
 
 int MarkCompactCollector::UpdatePointersInNewObject(HeapObject* obj) {
   // Keep old map pointers
   Map* old_map = obj->map();
   ASSERT(old_map->IsHeapObject());
 
   Address forwarded = GetForwardingAddressInOldSpace(old_map);
 
@@ skipping 88 matching lines @@
   ASSERT(next_page->OffsetToAddress(offset) < next_page->mc_relocation_top);
 
   return next_page->OffsetToAddress(offset);
 }
 
 
 // -------------------------------------------------------------------------
 // Phase 4: Relocate objects
 
 void MarkCompactCollector::RelocateObjects() {
+  MarkCompactCollectorData& data = v8_context()->mark_compact_collector_data_;
 #ifdef DEBUG
-  ASSERT(state_ == UPDATE_POINTERS);
-  state_ = RELOCATE_OBJECTS;
+  ASSERT(data.state_ == MarkCompactCollectorData::UPDATE_POINTERS);
+  data.state_ = MarkCompactCollectorData::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 = IterateLiveObjects(Heap::map_space(), &RelocateMapObject);
   int live_pointer_olds = IterateLiveObjects(Heap::old_pointer_space(),
                                              &RelocateOldPointerObject);
   int live_data_olds = IterateLiveObjects(Heap::old_data_space(),
                                           &RelocateOldDataObject);
   int live_codes = IterateLiveObjects(Heap::code_space(), &RelocateCodeObject);
   int live_cells = IterateLiveObjects(Heap::cell_space(), &RelocateCellObject);
   int live_news = IterateLiveObjects(Heap::new_space(), &RelocateNewObject);
 
   USE(live_maps);
   USE(live_data_olds);
   USE(live_pointer_olds);
   USE(live_codes);
   USE(live_cells);
   USE(live_news);
-  ASSERT(live_maps == live_map_objects_);
-  ASSERT(live_data_olds == live_old_data_objects_);
-  ASSERT(live_pointer_olds == live_old_pointer_objects_);
-  ASSERT(live_codes == live_code_objects_);
-  ASSERT(live_cells == live_cell_objects_);
-  ASSERT(live_news == live_young_objects_);
+  ASSERT(live_maps == data.live_map_objects_);
+  ASSERT(live_data_olds == data.live_old_data_objects_);
+  ASSERT(live_pointer_olds == data.live_old_pointer_objects_);
+  ASSERT(live_codes == data.live_code_objects_);
+  ASSERT(live_cells == data.live_cell_objects_);
+  ASSERT(live_news == data.live_young_objects_);
 
   // Flip from and to spaces
   Heap::new_space()->Flip();
 
   // Set age_mark to bottom in to space
   Address mark = Heap::new_space()->bottom();
   Heap::new_space()->set_age_mark(mark);
 
   Heap::new_space()->MCCommitRelocationInfo();
 #ifdef DEBUG
@@ skipping 165 matching lines @@
 
   return obj_size;
 }
 
 
 // -------------------------------------------------------------------------
 // Phase 5: rebuild remembered sets
 
 void MarkCompactCollector::RebuildRSets() {
 #ifdef DEBUG
-  ASSERT(state_ == RELOCATE_OBJECTS);
-  state_ = REBUILD_RSETS;
+  MarkCompactCollectorData& data = v8_context()->mark_compact_collector_data_;
+  ASSERT(data.state_ == MarkCompactCollectorData::RELOCATE_OBJECTS);
+  data.state_ = MarkCompactCollectorData::REBUILD_RSETS;
 #endif
   Heap::RebuildRSets();
 }
 
 } }  // namespace v8::internal