Separate markbits from heap object map words into bitmaps.

src/heap.cc

Index: src/heap.cc
diff --git a/src/heap.cc b/src/heap.cc
index 2b66dad2093cca55c16fcb37336cc2f9e2a0997c..4ec7e341a81dbfd24a9ca9b54c1155681cbbc2ad 100644
--- a/src/heap.cc
+++ b/src/heap.cc
@@ -216,12 +216,7 @@ bool Heap::HasBeenSetup() {
 
 
 int Heap::GcSafeSizeOfOldObject(HeapObject* object) {

[Erik Corry, 2011/01/07 12:13:21]

Shouldn't we just get rid of this alltogether?

-  ASSERT(!Heap::InNewSpace(object));  // Code only works for old objects.
-  ASSERT(!MarkCompactCollector::are_map_pointers_encoded());
-  MapWord map_word = object->map_word();
-  map_word.ClearMark();
-  map_word.ClearOverflow();
-  return object->SizeFromMap(map_word.ToMap());
+  return object->Size();
 }
 
 
@@ -4598,6 +4593,8 @@ bool Heap::Setup(bool create_heap_objects) {
   ProducerHeapProfile::Setup();
 #endif
 
+  if (!Marking::Setup()) return false;
+
   return true;
 }
 
@@ -4672,6 +4669,8 @@ void Heap::TearDown() {
     lo_space_ = NULL;
   }
 
+  Marking::TearDown();
+
   MemoryAllocator::TearDown();
 }
 
@@ -4905,6 +4904,34 @@ class HeapObjectsFilter {
 };
 
 
+// Intrusive object marking uses least significant bit of
+// heap object's map word to mark objects.
+// Normally all map words have least significant bit set
+// because they contain tagged map pointer.
+// If the bit is not set object is marked.
+// All objects should be unmarked before resuming
+// JavaScript execution.
+class IntrusiveMarking {
+ public:
+  static bool IsMarked(HeapObject* object) {
+    return (object->map_word().ToRawValue() & kNotMarkedBit) == 0;
+  }
+
+  static void ClearMark(HeapObject* object) {
+    uintptr_t map_word = object->map_word().ToRawValue();
+    object->set_map_word(MapWord::FromRawValue(map_word | kNotMarkedBit));
+  }
+
+  static void SetMark(HeapObject* object) {
+    uintptr_t map_word = object->map_word().ToRawValue();
+    object->set_map_word(MapWord::FromRawValue(map_word & ~kNotMarkedBit));
+  }
+
+ private:
+  static const uintptr_t kNotMarkedBit = 0x1;
+  STATIC_ASSERT((kHeapObjectTag & kNotMarkedBit) != 0);
+};
+
 class FreeListNodesFilter : public HeapObjectsFilter {
  public:
   FreeListNodesFilter() {
@@ -4912,8 +4939,8 @@ class FreeListNodesFilter : public HeapObjectsFilter {
   }
 
   bool SkipObject(HeapObject* object) {
-    if (object->IsMarked()) {
-      object->ClearMark();
+    if (IntrusiveMarking::IsMarked(object)) {
+      IntrusiveMarking::ClearMark(object);
       return true;
     } else {
       return false;
@@ -4935,7 +4962,9 @@ class FreeListNodesFilter : public HeapObjectsFilter {
     for (HeapObject* obj = iter.next_object();
          obj != NULL;
          obj = iter.next_object()) {
-      if (FreeListNode::IsFreeListNode(obj)) obj->SetMark();
+      if (FreeListNode::IsFreeListNode(obj)) {
+        IntrusiveMarking::SetMark(obj);
+      }
     }
   }
 
@@ -4950,8 +4979,8 @@ class UnreachableObjectsFilter : public HeapObjectsFilter {
   }
 
   bool SkipObject(HeapObject* object) {
-    if (object->IsMarked()) {
-      object->ClearMark();
+    if (IntrusiveMarking::IsMarked(object)) {
+      IntrusiveMarking::ClearMark(object);
       return true;
     } else {
       return false;
@@ -4967,8 +4996,8 @@ class UnreachableObjectsFilter : public HeapObjectsFilter {
       for (Object** p = start; p < end; p++) {
         if (!(*p)->IsHeapObject()) continue;
         HeapObject* obj = HeapObject::cast(*p);
-        if (obj->IsMarked()) {
-          obj->ClearMark();
+        if (IntrusiveMarking::IsMarked(obj)) {
+          IntrusiveMarking::ClearMark(obj);
           list_.Add(obj);
         }
       }
@@ -4990,7 +5019,7 @@ class UnreachableObjectsFilter : public HeapObjectsFilter {
     for (HeapObject* obj = iterator.next();
          obj != NULL;
          obj = iterator.next()) {
-      obj->SetMark();
+      IntrusiveMarking::SetMark(obj);
     }
     UnmarkingVisitor visitor;
     Heap::IterateRoots(&visitor, VISIT_ONLY_STRONG);
@@ -5284,7 +5313,6 @@ GCTracer::GCTracer()
   // These two fields reflect the state of the previous full collection.
   // Set them before they are changed by the collector.
   previous_has_compacted_ = MarkCompactCollector::HasCompacted();
-  previous_marked_count_ = MarkCompactCollector::previous_marked_count();
   if (!FLAG_trace_gc && !FLAG_print_cumulative_gc_stat) return;
   start_time_ = OS::TimeCurrentMillis();
   start_size_ = Heap::SizeOfObjects();