Unify markbits for old and new spaces.

src/mark-compact.cc

 // Copyright 2011 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 50 matching lines @@
       live_code_objects_size_(0),
       live_map_objects_size_(0),
       live_cell_objects_size_(0),
       live_lo_objects_size_(0),
       live_bytes_(0),
 #endif
       heap_(NULL),
       code_flusher_(NULL) { }
 
 
-bool Marking::Setup() {
-  if (new_space_bitmap_ == NULL) {
-    // TODO(gc) ISOLATES
-    int markbits_per_newspace =
-        (2*HEAP->ReservedSemiSpaceSize()) >> kPointerSizeLog2;
-
-    new_space_bitmap_ =
-        BitmapStorageDescriptor::Allocate(
-            NewSpaceMarkbitsBitmap::CellsForLength(markbits_per_newspace));
-  }
-  return new_space_bitmap_ != NULL;
-}
-
-
-void Marking::TearDown() {
-  if (new_space_bitmap_ != NULL) {
-    BitmapStorageDescriptor::Free(new_space_bitmap_);
-    new_space_bitmap_ = NULL;
-  }
-}
-
-
 #ifdef DEBUG
 class VerifyMarkingVisitor: public ObjectVisitor {
  public:
   void VisitPointers(Object** start, Object** end) {
     for (Object** current = start; current < end; current++) {
       if ((*current)->IsHeapObject()) {
         HeapObject* object = HeapObject::cast(*current);
         ASSERT(HEAP->mark_compact_collector()->IsMarked(object));
       }
     }
@@ skipping 102 matching lines @@
     ASSERT(p->markbits()->IsClean());
   }
 }
 
 static void VerifyMarkbitsAreClean() {
   VerifyMarkbitsAreClean(HEAP->old_pointer_space());
   VerifyMarkbitsAreClean(HEAP->old_data_space());
   VerifyMarkbitsAreClean(HEAP->code_space());
   VerifyMarkbitsAreClean(HEAP->cell_space());
   VerifyMarkbitsAreClean(HEAP->map_space());
+  ASSERT(HEAP->new_space()->ActivePage()->markbits()->IsClean());
 }
 #endif
 
 
 static void ClearMarkbits(PagedSpace* space) {
   PageIterator it(space);
 
   while (it.has_next()) {
     Page* p = it.next();
     p->markbits()->Clear();
   }
 }
 
 
 static void ClearMarkbits() {
   // TODO(gc): Clean the mark bits while sweeping.
   ClearMarkbits(HEAP->code_space());
   ClearMarkbits(HEAP->map_space());
   ClearMarkbits(HEAP->old_pointer_space());
   ClearMarkbits(HEAP->old_data_space());
   ClearMarkbits(HEAP->cell_space());
+  HEAP->new_space()->ActivePage()->markbits()->Clear();
 }
 
 
 void Marking::TransferMark(Address old_start, Address new_start) {
   if (old_start == new_start) return;
 
   MarkBit new_mark_bit = MarkBitFrom(new_start);
 
   if (heap_->incremental_marking()->IsMarking()) {
     MarkBit old_mark_bit = MarkBitFrom(old_start);
@@ skipping 59 matching lines @@
   }
 #endif
 
   PagedSpaces spaces;
   for (PagedSpace* space = spaces.next();
        space != NULL; space = spaces.next()) {
     space->PrepareForMarkCompact(compacting_collection_);
   }
 
   if (!heap()->incremental_marking()->IsMarking()) {
-    Address new_space_bottom = heap()->new_space()->bottom();
-    uintptr_t new_space_size =
-        RoundUp(heap()->new_space()->top() - new_space_bottom,
-                32 * kPointerSize);
-
-    heap()->marking()->ClearRange(new_space_bottom, new_space_size);
-
     ClearMarkbits();
 #ifdef DEBUG
     VerifyMarkbitsAreClean();
 #endif
   }
 
 #ifdef DEBUG
   live_bytes_ = 0;
   live_young_objects_size_ = 0;
   live_old_pointer_objects_size_ = 0;
@@ skipping 104 matching lines @@
     Code* lazy_compile = isolate_->builtins()->builtin(Builtins::kLazyCompile);
 
     JSFunction* candidate = jsfunction_candidates_head_;
     JSFunction* next_candidate;
     while (candidate != NULL) {
       next_candidate = GetNextCandidate(candidate);
 
       SharedFunctionInfo* shared = candidate->unchecked_shared();
 
       Code* code = shared->unchecked_code();
-      MarkBit code_mark = Marking::MarkBitFromOldSpace(code);
+      MarkBit code_mark = Marking::MarkBitFrom(code);
       if (!code_mark.Get()) {
         shared->set_code(lazy_compile);
         candidate->set_code(lazy_compile);
       } else {
         candidate->set_code(shared->unchecked_code());
       }
 
       candidate = next_candidate;
     }
 
     jsfunction_candidates_head_ = NULL;
   }
 
 
   void ProcessSharedFunctionInfoCandidates() {
     Code* lazy_compile = isolate_->builtins()->builtin(Builtins::kLazyCompile);
 
     SharedFunctionInfo* candidate = shared_function_info_candidates_head_;
     SharedFunctionInfo* next_candidate;
     while (candidate != NULL) {
       next_candidate = GetNextCandidate(candidate);
       SetNextCandidate(candidate, NULL);
 
       Code* code = candidate->unchecked_code();
-      MarkBit code_mark = Marking::MarkBitFromOldSpace(code);
+      MarkBit code_mark = Marking::MarkBitFrom(code);
       if (!code_mark.Get()) {
         candidate->set_code(lazy_compile);
       }
 
       candidate = next_candidate;
     }
 
     shared_function_info_candidates_head_ = NULL;
   }
 
@@ skipping 164 matching lines @@
   }
 
   static inline void VisitCodeTarget(Heap* heap, RelocInfo* rinfo) {
     ASSERT(RelocInfo::IsCodeTarget(rinfo->rmode()));
     Code* code = Code::GetCodeFromTargetAddress(rinfo->target_address());
     if (FLAG_cleanup_ics_at_gc && code->is_inline_cache_stub()) {
       IC::Clear(rinfo->pc());
       // Please note targets for cleared inline cached do not have to be
       // marked since they are contained in HEAP->non_monomorphic_cache().
     } else {
-      MarkBit code_mark = Marking::MarkBitFromOldSpace(code);
+      MarkBit code_mark = Marking::MarkBitFrom(code);
       heap->mark_compact_collector()->MarkObject(code, code_mark);
     }
   }
 
   static void VisitGlobalPropertyCell(Heap* heap, RelocInfo* rinfo) {
     ASSERT(rinfo->rmode() == RelocInfo::GLOBAL_PROPERTY_CELL);
     Object* cell = rinfo->target_cell();
     Object* old_cell = cell;
     VisitPointer(heap, &cell);
     if (cell != old_cell) {
       rinfo->set_target_cell(reinterpret_cast<JSGlobalPropertyCell*>(cell),
                              NULL);
     }
   }
 
   static inline void VisitDebugTarget(Heap* heap, RelocInfo* rinfo) {
     ASSERT((RelocInfo::IsJSReturn(rinfo->rmode()) &&
             rinfo->IsPatchedReturnSequence()) ||
            (RelocInfo::IsDebugBreakSlot(rinfo->rmode()) &&
             rinfo->IsPatchedDebugBreakSlotSequence()));
     HeapObject* code = Code::GetCodeFromTargetAddress(rinfo->call_address());
-    MarkBit code_mark = Marking::MarkBitFromOldSpace(code);
+    MarkBit code_mark = Marking::MarkBitFrom(code);
     heap->mark_compact_collector()->MarkObject(code, code_mark);
   }
 
   // Mark object pointed to by p.
   INLINE(static void MarkObjectByPointer(Heap* heap, Object** p)) {
     if (!(*p)->IsHeapObject()) return;
     HeapObject* object = ShortCircuitConsString(p);
     MarkBit mark = heap->marking()->MarkBitFrom(object);
     heap->mark_compact_collector()->MarkObject(object, mark);
   }
 
 
   // Visit an unmarked object.
   INLINE(static void VisitUnmarkedObject(MarkCompactCollector* collector,
                                          HeapObject* obj)) {
 #ifdef DEBUG
     ASSERT(Isolate::Current()->heap()->Contains(obj));
     ASSERT(!HEAP->mark_compact_collector()->IsMarked(obj));
 #endif
     Map* map = obj->map();
     Heap* heap = obj->GetHeap();
     // TODO(gc) ISOLATES MERGE
     MarkBit mark = heap->marking()->MarkBitFrom(obj);
     heap->mark_compact_collector()->SetMark(obj, mark);
     // Mark the map pointer and the body.
-    MarkBit map_mark = Marking::MarkBitFromOldSpace(map);
+    MarkBit map_mark = Marking::MarkBitFrom(map);
     heap->mark_compact_collector()->MarkObject(map, map_mark);
     IterateBody(map, obj);
   }
 
   // Visit all unmarked objects pointed to by [start, end).
   // Returns false if the operation fails (lack of stack space).
   static inline bool VisitUnmarkedObjects(Heap* heap,
                                           Object** start,
                                           Object** end) {
     // Return false is we are close to the stack limit.
@@ skipping 62 matching lines @@
     return function->unchecked_code() !=
         function->GetIsolate()->builtins()->builtin(Builtins::kLazyCompile);
   }
 
   inline static bool IsFlushable(Heap* heap, JSFunction* function) {
     SharedFunctionInfo* shared_info = function->unchecked_shared();
 
     // Code is either on stack, in compilation cache or referenced
     // by optimized version of function.
     MarkBit code_mark =
-        Marking::MarkBitFromOldSpace(function->unchecked_code());
+        Marking::MarkBitFrom(function->unchecked_code());
     if (code_mark.Get()) {
       shared_info->set_code_age(0);
       return false;
     }
 
     // We do not flush code for optimized functions.
     if (function->code() != shared_info->unchecked_code()) {
       return false;
     }
 
     return IsFlushable(heap, shared_info);
   }
 
   inline static bool IsFlushable(Heap* heap, SharedFunctionInfo* shared_info) {
     // Code is either on stack, in compilation cache or referenced
     // by optimized version of function.
     MarkBit code_mark =
-        Marking::MarkBitFromOldSpace(shared_info->unchecked_code());
+        Marking::MarkBitFrom(shared_info->unchecked_code());
     if (code_mark.Get()) {
       shared_info->set_code_age(0);
       return false;
     }
 
     // The function must be compiled and have the source code available,
     // to be able to recompile it in case we need the function again.
     if (!(shared_info->is_compiled() && HasSourceCode(heap, shared_info))) {
       return false;
     }
@@ skipping 131 matching lines @@
 
     JSFunction* jsfunction = reinterpret_cast<JSFunction*>(object);
     // The function must have a valid context and not be a builtin.
     bool flush_code_candidate = false;
     if (IsValidNotBuiltinContext(jsfunction->unchecked_context())) {
       flush_code_candidate = FlushCodeForFunction(heap, jsfunction);
     }
 
     if (!flush_code_candidate) {
       Code* code = jsfunction->unchecked_shared()->unchecked_code();
-      MarkBit code_mark = Marking::MarkBitFromOldSpace(code);
+      MarkBit code_mark = Marking::MarkBitFrom(code);
       HEAP->mark_compact_collector()->MarkObject(code, code_mark);
 
       if (jsfunction->unchecked_code()->kind() == Code::OPTIMIZED_FUNCTION) {
         // For optimized functions we should retain both non-optimized version
         // of it's code and non-optimized version of all inlined functions.
         // This is required to support bailing out from inlined code.
         DeoptimizationInputData* data =
             reinterpret_cast<DeoptimizationInputData*>(
                 jsfunction->unchecked_code()->unchecked_deoptimization_data());
 
         FixedArray* literals = data->UncheckedLiteralArray();
 
         for (int i = 0, count = data->InlinedFunctionCount()->value();
              i < count;
              i++) {
           JSFunction* inlined = reinterpret_cast<JSFunction*>(literals->get(i));
           Code* inlined_code = inlined->unchecked_shared()->unchecked_code();
           MarkBit inlined_code_mark =
-              Marking::MarkBitFromOldSpace(inlined_code);
+              Marking::MarkBitFrom(inlined_code);
           HEAP->mark_compact_collector()->MarkObject(
               inlined_code, inlined_code_mark);
         }
       }
     }
 
     VisitJSFunctionFields(map,
                           reinterpret_cast<JSFunction*>(object),
                           flush_code_candidate);
   }
@@ skipping 24 matching lines @@
     } else {
       // Don't visit code object.
 
       // Visit shared function info to avoid double checking of it's
       // flushability.
       SharedFunctionInfo* shared_info = object->unchecked_shared();
       MarkBit shared_info_mark = heap->marking()->MarkBitFrom(shared_info);
       if (!shared_info_mark.Get()) {
         Map* shared_info_map = shared_info->map();
         MarkBit shared_info_map_mark =
-            Marking::MarkBitFromOldSpace(shared_info_map);
+            Marking::MarkBitFrom(shared_info_map);
         HEAP->mark_compact_collector()->SetMark(shared_info, shared_info_mark);
         HEAP->mark_compact_collector()->MarkObject(shared_info_map,
                                                    shared_info_map_mark);
         VisitSharedFunctionInfoAndFlushCodeGeneric(shared_info_map,
                                                    shared_info,
                                                    true);
       }
     }
 
     VisitPointers(heap,
@@ skipping 61 matching lines @@
 
 
 class CodeMarkingVisitor : public ThreadVisitor {
  public:
   explicit CodeMarkingVisitor(MarkCompactCollector* collector)
       : collector_(collector) {}
 
   void VisitThread(Isolate* isolate, ThreadLocalTop* top) {
     for (StackFrameIterator it(isolate, top); !it.done(); it.Advance()) {
       Code* code = it.frame()->unchecked_code();
-      MarkBit code_bit = Marking::MarkBitFromOldSpace(code);
+      MarkBit code_bit = Marking::MarkBitFrom(code);
       HEAP->mark_compact_collector()->MarkObject(
           it.frame()->unchecked_code(), code_bit);
     }
   }
 
  private:
   MarkCompactCollector* collector_;
 };
 
 
 class SharedFunctionInfoMarkingVisitor : public ObjectVisitor {
  public:
   explicit SharedFunctionInfoMarkingVisitor(MarkCompactCollector* collector)
       : collector_(collector) {}
 
   void VisitPointers(Object** start, Object** end) {
     for (Object** p = start; p < end; p++) VisitPointer(p);
   }
 
   void VisitPointer(Object** slot) {
     Object* obj = *slot;
     if (obj->IsSharedFunctionInfo()) {
       SharedFunctionInfo* shared = reinterpret_cast<SharedFunctionInfo*>(obj);
       // TODO(gc) ISOLATES MERGE
       MarkBit shared_mark = HEAP->marking()->MarkBitFrom(shared);
       MarkBit code_mark =
-          HEAP->marking()->MarkBitFromOldSpace(shared->unchecked_code());
+          HEAP->marking()->MarkBitFrom(shared->unchecked_code());
       HEAP->mark_compact_collector()->MarkObject(shared->unchecked_code(),
                                                  code_mark);
       HEAP->mark_compact_collector()->MarkObject(shared, shared_mark);
     }
   }
 
  private:
   MarkCompactCollector* collector_;
 };
 
@@ skipping 20 matching lines @@
   HeapObject* descriptor_array = heap()->raw_unchecked_empty_descriptor_array();
   // TODO(gc) ISOLATES MERGE
   MarkBit descriptor_array_mark =
       heap()->marking()->MarkBitFrom(descriptor_array);
   MarkObject(descriptor_array, descriptor_array_mark);
 
   // Make sure we are not referencing the code from the stack.
   ASSERT(this == heap()->mark_compact_collector());
   for (StackFrameIterator it; !it.done(); it.Advance()) {
     Code* code = it.frame()->unchecked_code();
-    MarkBit code_mark = Marking::MarkBitFromOldSpace(code);
+    MarkBit code_mark = Marking::MarkBitFrom(code);
     MarkObject(code, code_mark);
   }
 
   // Iterate the archived stacks in all threads to check if
   // the code is referenced.
   CodeMarkingVisitor code_marking_visitor(this);
   heap()->isolate()->thread_manager()->IterateArchivedThreads(
       &code_marking_visitor);
 
   SharedFunctionInfoMarkingVisitor visitor(this);
@@ skipping 26 matching lines @@
     HeapObject* object = ShortCircuitConsString(p);
     // TODO(gc) ISOLATES MERGE
     MarkBit mark_bit = HEAP->marking()->MarkBitFrom(object);
     if (mark_bit.Get()) return;
 
     Map* map = object->map();
     // Mark the object.
     HEAP->mark_compact_collector()->SetMark(object, mark_bit);
 
     // Mark the map pointer and body, and push them on the marking stack.
-    MarkBit map_mark = Marking::MarkBitFromOldSpace(map);
+    MarkBit map_mark = Marking::MarkBitFrom(map);
     HEAP->mark_compact_collector()->MarkObject(map, map_mark);
     StaticMarkingVisitor::IterateBody(map, object);
 
     // Mark all the objects reachable from the map and body.  May leave
     // overflowed objects in the heap.
     collector_->EmptyMarkingDeque();
   }
 
   MarkCompactCollector* collector_;
 };
@@ skipping 315 matching lines @@
 // marking stack have been marked, or are overflowed in the heap.
 void MarkCompactCollector::EmptyMarkingDeque() {
   while (!marking_deque_.IsEmpty()) {
     HeapObject* object = marking_deque_.Pop();
     ASSERT(object->IsHeapObject());
     ASSERT(heap()->Contains(object));
     ASSERT(IsMarked(object));
     ASSERT(!object->IsOverflowed());
 
     Map* map = object->map();
-    MarkBit map_mark = Marking::MarkBitFromOldSpace(map);
+    MarkBit map_mark = Marking::MarkBitFrom(map);
     MarkObject(map, map_mark);
 
     StaticMarkingVisitor::IterateBody(map, object);
   }
 }
 
 
 // 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
@@ skipping 184 matching lines @@
   // dropping the back pointers temporarily stored in the prototype field.
   // Setting the prototype field requires following the linked list of
   // back pointers, reversing them all at once.  This allows us to find
   // those maps with map transitions that need to be nulled, and only
   // scan the descriptor arrays of those maps, not all maps.
   // All of these actions are carried out only on maps of JSObjects
   // and related subtypes.
   for (HeapObject* obj = map_iterator.Next();
        obj != NULL; obj = map_iterator.Next()) {
     Map* map = reinterpret_cast<Map*>(obj);
-    MarkBit map_mark = Marking::MarkBitFromOldSpace(map);
+    MarkBit map_mark = Marking::MarkBitFrom(map);
     if (map->IsFreeSpace()) continue;
 
     ASSERT(SafeIsMap(map));
     // Only JSObject and subtypes have map transitions and back pointers.
     if (map->instance_type() < FIRST_JS_OBJECT_TYPE) continue;
     if (map->instance_type() > JS_FUNCTION_TYPE) continue;
 
     if (map_mark.Get() &&
         map->attached_to_shared_function_info()) {
       // This map is used for inobject slack tracking and has been detached
       // from SharedFunctionInfo during the mark phase.
       // Since it survived the GC, reattach it now.
       map->unchecked_constructor()->unchecked_shared()->AttachInitialMap(map);
     }
 
     // Clear dead prototype transitions.
     FixedArray* prototype_transitions = map->unchecked_prototype_transitions();
     if (prototype_transitions->length() > 0) {
       int finger = Smi::cast(prototype_transitions->get(0))->value();
       int new_finger = 1;
       for (int i = 1; i < finger; i += 2) {
         HeapObject* prototype = HeapObject::cast(prototype_transitions->get(i));
         Map* cached_map = Map::cast(prototype_transitions->get(i + 1));
         MarkBit prototype_mark = heap()->marking()->MarkBitFrom(prototype);
-        MarkBit cached_map_mark = Marking::MarkBitFromOldSpace(cached_map);
+        MarkBit cached_map_mark = Marking::MarkBitFrom(cached_map);
         if (prototype_mark.Get() && cached_map_mark.Get()) {
           if (new_finger != i) {
             prototype_transitions->set_unchecked(heap_,
                                                  new_finger,
                                                  prototype,
                                                  UPDATE_WRITE_BARRIER);
             prototype_transitions->set_unchecked(heap_,
                                                  new_finger + 1,
                                                  cached_map,
                                                  SKIP_WRITE_BARRIER);
@@ skipping 22 matching lines @@
     Object* real_prototype = current;
 
     // Follow back pointers, setting them to prototype,
     // clearing map transitions when necessary.
     current = map;
     bool on_dead_path = !map_mark.Get();
     Object* next;
     while (SafeIsMap(current)) {
       next = current->prototype();
       // There should never be a dead map above a live map.
-      MarkBit current_mark = Marking::MarkBitFromOldSpace(current);
+      MarkBit current_mark = Marking::MarkBitFrom(current);
       ASSERT(on_dead_path || current_mark.Get());
 
       // A live map above a dead map indicates a dead transition.
       // This test will always be false on the first iteration.
       if (on_dead_path && current_mark.Get()) {
         on_dead_path = false;
         current->ClearNonLiveTransitions(heap(), real_prototype);
       }
       *HeapObject::RawField(current, Map::kPrototypeOffset) =
           real_prototype;
@@ skipping 172 matching lines @@
   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.
   for (Address current = from_bottom; current < from_top; current += size) {
     HeapObject* object = HeapObject::FromAddress(current);
 
 
-    MarkBit mark_bit = heap_->marking()->MarkBitFromNewSpace(object);
+    MarkBit mark_bit = heap_->marking()->MarkBitFrom(object);
     if (mark_bit.Get()) {
       mark_bit.Clear();
       heap_->mark_compact_collector()->tracer()->decrement_marked_count();
 
       size = object->Size();
       survivors_size += size;
 
       // Aggressively promote young survivors to the old space.
       if (TryPromoteObject(heap_, object, size)) {
         continue;
@@ skipping 75 matching lines @@
                                  uint32_t free_start,
                                  uint32_t region_end,
                                  uint32_t* cells));
 
 
 static uint32_t SweepFree(PagedSpace* space,
                           Page* p,
                           uint32_t free_start,
                           uint32_t region_end,
                           uint32_t* cells) {
-  uint32_t free_cell_index = Page::MarkbitsBitmap::IndexToCell(free_start);
+  uint32_t free_cell_index = Bitmap::IndexToCell(free_start);
   ASSERT(cells[free_cell_index] == 0);
   while (free_cell_index < region_end && cells[free_cell_index] == 0) {
     free_cell_index++;
   }
 
   if (free_cell_index >= region_end) {
     return free_cell_index;
   }
 
-  uint32_t free_end = Page::MarkbitsBitmap::CellToIndex(free_cell_index);
+  uint32_t free_end = Bitmap::CellToIndex(free_cell_index);
   space->Free(p->MarkbitIndexToAddress(free_start),
               (free_end - free_start) << kPointerSizeLog2);
 
   return free_cell_index;
 }
 
 
 INLINE(static uint32_t NextCandidate(uint32_t cell_index,
                                      uint32_t last_cell_index,
                                      uint32_t* cells));
@@ skipping 17 matching lines @@
 static int SizeOfPreviousObject(Page* p,
                                 uint32_t cell_index,
                                 uint32_t* cells) {
   ASSERT(cells[cell_index] == 0);
   if (cells[cell_index - 1] == 0) return 0;
 
   int leading_zeroes =
       CompilerIntrinsics::CountLeadingZeros(cells[cell_index - 1]) + 1;
   Address addr =
       p->MarkbitIndexToAddress(
-          Page::MarkbitsBitmap::CellToIndex(cell_index) - leading_zeroes);
+          Bitmap::CellToIndex(cell_index) - leading_zeroes);
   HeapObject* obj = HeapObject::FromAddress(addr);
   ASSERT(obj->map()->IsMap());
   return (obj->Size() >> kPointerSizeLog2) - leading_zeroes;
 }
 
 
 static const int kStartTableEntriesPerLine = 5;
 static const int kStartTableLines = 171;
 static const int kStartTableInvalidLine = 127;
 static const int kStartTableUnusedEntry = 126;
@@ skipping 274 matching lines @@
   int freed_bytes = 0;
 
   MarkBit::CellType* cells = p->markbits()->cells();
 
   p->SetFlag(MemoryChunk::WAS_SWEPT_CONSERVATIVELY);
 
   // This is the start of the 32 word block that we are currently looking at.
   Address block_address = p->ObjectAreaStart();
 
   int last_cell_index =
-      Page::MarkbitsBitmap::IndexToCell(
-          Page::MarkbitsBitmap::CellAlignIndex(
+      Bitmap::IndexToCell(
+          Bitmap::CellAlignIndex(
               p->AddressToMarkbitIndex(p->ObjectAreaEnd())));
 
   int cell_index = Page::kFirstUsedCell;
 
   // Skip over all the dead objects at the start of the page and mark them free.
   for (cell_index = Page::kFirstUsedCell;
        cell_index < last_cell_index;
        cell_index++, block_address += 32 * kPointerSize) {
     if (cells[cell_index] != 0) break;
   }
@@ skipping 14 matching lines @@
   // started.  Unless we find a large free space in the bitmap we will not
   // digest this pair into a real address.  We start the iteration here at the
   // first word in the marking bit map that indicates a live object.
   Address free_start = block_address;
   uint32_t free_start_cell = cells[cell_index];
 
   for ( ;
        cell_index < last_cell_index;
        cell_index++, block_address += 32 * kPointerSize) {
     ASSERT((unsigned)cell_index ==
-        Page::MarkbitsBitmap::IndexToCell(
-            Page::MarkbitsBitmap::CellAlignIndex(
+        Bitmap::IndexToCell(
+            Bitmap::CellAlignIndex(
                 p->AddressToMarkbitIndex(block_address))));
     uint32_t cell = cells[cell_index];
     if (cell != 0) {
       // We have a live object.  Check approximately whether it is more than 32
       // words since the last live object.
       if (block_address - free_start > 32 * kPointerSize) {
         free_start = DigestFreeStart(free_start, free_start_cell);
         if (block_address - free_start > 32 * kPointerSize) {
           // Now that we know the exact start of the free space it still looks
           // like we have a large enough free space to be worth bothering with.
@@ skipping 23 matching lines @@
 // be iterated precisely, hitting only the live objects.  Code space
 // is always swept precisely because we want to be able to iterate
 // over it.  Map space is swept precisely, because it is not compacted.
 static void SweepPrecisely(PagedSpace* space,
                            Page* p) {
   MarkBit::CellType* cells = p->markbits()->cells();
 
   p->ClearFlag(MemoryChunk::WAS_SWEPT_CONSERVATIVELY);
 
   int last_cell_index =
-      Page::MarkbitsBitmap::IndexToCell(
-          Page::MarkbitsBitmap::CellAlignIndex(
+      Bitmap::IndexToCell(
+          Bitmap::CellAlignIndex(
               p->AddressToMarkbitIndex(p->ObjectAreaEnd())));
 
   int cell_index = Page::kFirstUsedCell;
   Address free_start = p->ObjectAreaStart();
   ASSERT(reinterpret_cast<uint32_t>(free_start) % (32 * kPointerSize) == 0);
   Address object_address = p->ObjectAreaStart();
   int offsets[16];
 
   for (cell_index = Page::kFirstUsedCell;
        cell_index < last_cell_index;
        cell_index++, object_address += 32 * kPointerSize) {
     ASSERT((unsigned)cell_index ==
-        Page::MarkbitsBitmap::IndexToCell(
-            Page::MarkbitsBitmap::CellAlignIndex(
+        Bitmap::IndexToCell(
+            Bitmap::CellAlignIndex(
                 p->AddressToMarkbitIndex(object_address))));
     int live_objects = MarkWordToObjectStarts(cells[cell_index], offsets);
     int live_index = 0;
     for ( ; live_objects != 0; live_objects--) {
       Address free_end = object_address + offsets[live_index++] * kPointerSize;
       if (free_end != free_start) {
         space->Free(free_start, free_end - free_start);
       }
       HeapObject* live_object = HeapObject::FromAddress(free_end);
       free_start = free_end + live_object->Size();
@@ skipping 160 matching lines @@
 }
 
 
 void MarkCompactCollector::Initialize() {
   StaticPointersToNewGenUpdatingVisitor::Initialize();
   StaticMarkingVisitor::Initialize();
 }
 
 
 } }  // namespace v8::internal