Separate markbits from heap object map words into bitmaps.

src/spaces.cc

 // Copyright 2006-2010 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 1541 matching lines @@
     free_[rem].head_node_ = rem_node->address();
     if (rem_node->next() == NULL) InsertSize(rem);
   }
   available_ -= size_in_bytes;
   *wasted_bytes = 0;
   return cur_node;
 }
 
 
 void OldSpaceFreeList::MarkNodes() {
+#if 0
   for (int i = 0; i < kFreeListsLength; i++) {
     Address cur_addr = free_[i].head_node_;
     while (cur_addr != NULL) {
       FreeListNode* cur_node = FreeListNode::FromAddress(cur_addr);
       cur_addr = cur_node->next();
       cur_node->SetMark();
     }
   }
+#endif
+  UNREACHABLE();
 }
 
 
 #ifdef DEBUG
 bool OldSpaceFreeList::Contains(FreeListNode* node) {
   for (int i = 0; i < kFreeListsLength; i++) {
     Address cur_addr = free_[i].head_node_;
     while (cur_addr != NULL) {
       FreeListNode* cur_node = FreeListNode::FromAddress(cur_addr);
       if (cur_node == node) return true;
@@ skipping 43 matching lines @@
 
   ASSERT(!FLAG_always_compact);  // We only use the freelists with mark-sweep.
   FreeListNode* node = FreeListNode::FromAddress(head_);
   head_ = node->next();
   available_ -= object_size_;
   return node;
 }
 
 
 void FixedSizeFreeList::MarkNodes() {
+#if 0
   Address cur_addr = head_;
   while (cur_addr != NULL && cur_addr != tail_) {
     FreeListNode* cur_node = FreeListNode::FromAddress(cur_addr);
     cur_addr = cur_node->next();
     cur_node->SetMark();
   }
+#endif
+  UNREACHABLE();
 }
 
 
 // -----------------------------------------------------------------------------
 // OldSpace implementation
 
 void OldSpace::PrepareForMarkCompact(bool will_compact) {
   ASSERT(!will_compact);
   // Call prepare of the super class.
   PagedSpace::PrepareForMarkCompact(will_compact);
@@ skipping 41 matching lines @@
   last_page_->set_next_page(first);
   last_page_ = last;
   last->set_next_page(NULL);
 
   // Clean them up.
   do {
     first->InvalidateWatermark(true);
     first->SetAllocationWatermark(first->ObjectAreaStart());
     first->SetCachedAllocationWatermark(first->ObjectAreaStart());
     first->SetRegionMarks(Page::kAllRegionsCleanMarks);
+    first->markbits()->Clear();
     first = first->next_page();
   } while (first != NULL);
 }
 
 
 void PagedSpace::PrepareForMarkCompact(bool will_compact) {
   ASSERT(!will_compact);
 }
 
 
@@ skipping 611 matching lines @@
     }
   }
 }
 
 
 void LargeObjectSpace::FreeUnmarkedObjects() {
   LargePage* previous = NULL;
   LargePage* current = first_page_;
   while (current != NULL) {
     HeapObject* object = current->GetObject();
-    if (object->IsMarked()) {
-      object->ClearMark();
+    if (Marking::IsMarked(object)) {
+      Marking::ClearMark(object);
       MarkCompactCollector::tracer()->decrement_marked_count();
       previous = current;
       current = current->next_page();
     } else {
       LargePage* page = current;
       // Cut the chunk out from the chunk list.
       current = current->next_page();
       if (previous == NULL) {
         first_page_ = current;
       } else {
@@ skipping 117 matching lines @@
   for (HeapObject* obj = obj_it.next(); obj != NULL; obj = obj_it.next()) {
     if (obj->IsCode()) {
       Code* code = Code::cast(obj);
       code_kind_statistics[code->kind()] += code->Size();
     }
   }
 }
 #endif  // DEBUG
 
 } }  // namespace v8::internal