Create an abstraction (MarkBit) object to hold the location of the...

src/mark-compact.h

 // 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 27 matching lines @@
 // to the first live object in the page (only used for old and map objects).
 typedef bool (*IsAliveFunction)(HeapObject* obj, int* size, int* offset);
 
 // Forward declarations.
 class RootMarkingVisitor;
 class MarkingVisitor;
 
 
 class Marking {
  public:
-  INLINE(static bool IsMarked(HeapObject* obj)) {
-    return IsMarked(obj->address());
+  static inline MarkBit MarkBitFrom(HeapObject* obj) {
+    return MarkBitFrom(reinterpret_cast<Address>(obj));
   }
 
-  INLINE(static void SetMark(HeapObject* obj)) {
-    SetMark(obj->address());
+  static inline MarkBit MarkBitFromNewSpace(HeapObject* obj) {
+    ASSERT(Heap::InNewSpace(obj));
+    uint32_t index = Heap::new_space()->AddressToMarkbitIndex(
+        reinterpret_cast<Address>(obj));
+    return new_space_bitmap_->MarkBitFromIndex(index);
   }
 
-  INLINE(static void ClearMark(HeapObject* obj)) {
-    ClearMark(obj->address());
-  }
-
-  INLINE(static bool TestAndMark(Address addr)) {
+  static inline MarkBit MarkBitFrom(Address addr) {
     if (Heap::InNewSpace(addr)) {
       uint32_t index = Heap::new_space()->AddressToMarkbitIndex(addr);
-      return new_space_bitmap_->TestAndSet(index);
+      return new_space_bitmap_->MarkBitFromIndex(index);
     } else {
       Page *p = Page::FromAddress(addr);
-      return p->markbits()->TestAndSet(p->AddressToMarkbitIndex(addr));
+      return p->markbits()->MarkBitFromIndex(p->AddressToMarkbitIndex(addr));
     }
   }
 
-  INLINE(static bool IsMarked(Address addr)) {
-    if (Heap::InNewSpace(addr)) {
-      uint32_t index = Heap::new_space()->AddressToMarkbitIndex(addr);
-      return new_space_bitmap_->Get(index);
-    } else {
-      Page *p = Page::FromAddress(addr);
-      return p->markbits()->Get(p->AddressToMarkbitIndex(addr));
-    }
-  }
-
-  INLINE(static void SetMark(Address addr)) {
-    if (Heap::InNewSpace(addr)) {
-      uint32_t index = Heap::new_space()->AddressToMarkbitIndex(addr);
-      new_space_bitmap_->Set(index);
-    } else {
-      Page *p = Page::FromAddress(addr);
-      p->markbits()->Set(p->FastAddressToMarkbitIndex(addr));
-    }
-  }
-
-  INLINE(static void ClearMark(Address addr)) {
-    if (Heap::InNewSpace(addr)) {
-      uint32_t index = Heap::new_space()->AddressToMarkbitIndex(addr);
-      new_space_bitmap_->Clear(index);
-    } else {
-      Page *p = Page::FromAddress(addr);
-      p->markbits()->Clear(p->FastAddressToMarkbitIndex(addr));
-    }
-  }
-
-  INLINE(static void ClearRange(Address addr, int size)) {
+  static void ClearRange(Address addr, int size) {
     if (Heap::InNewSpace(addr)) {
       uint32_t index = Heap::new_space()->AddressToMarkbitIndex(addr);
       new_space_bitmap_->ClearRange(index, size >> kPointerSizeLog2);
     } else {
       Page *p = Page::FromAddress(addr);
       p->markbits()->ClearRange(p->FastAddressToMarkbitIndex(addr),
                                 size >> kPointerSizeLog2);
     }
   }
 
@@ skipping 134 matching lines @@
 #endif
 
   // Determine type of object and emit deletion log event.
   static void ReportDeleteIfNeeded(HeapObject* obj);
 
   // Distinguishable invalid map encodings (for single word and multiple words)
   // that indicate free regions.
   static const uint32_t kSingleFreeEncoding = 0;
   static const uint32_t kMultiFreeEncoding = 1;
 
+#ifdef DEBUG
+  static bool IsMarked(Object* obj) {
+    ASSERT(obj->IsHeapObject());
+    HeapObject* heap_object = HeapObject::cast(obj);
+    return Marking::MarkBitFrom(heap_object).Get();
+  }
+#endif
+
  private:
 #ifdef DEBUG
   enum CollectorState {
     IDLE,
     PREPARE_GC,
     MARK_LIVE_OBJECTS,
     SWEEP_SPACES,
     ENCODE_FORWARDING_ADDRESSES,
     UPDATE_POINTERS,
     RELOCATE_OBJECTS
@@ skipping 40 matching lines @@
   friend class SharedFunctionInfoMarkingVisitor;
 
   static void PrepareForCodeFlushing();
 
   // Marking operations for objects reachable from roots.
   static void MarkLiveObjects();
 
   static void AfterMarking();
 
 
-  INLINE(static void MarkObject(HeapObject* obj)) {
-    if (!Marking::TestAndMark(obj->address())) {
+  INLINE(static void MarkObject(HeapObject* obj, MarkBit mark_bit)) {
+    ASSERT(Marking::MarkBitFrom(obj) == mark_bit);
+    if (!mark_bit.Get()) {
+      mark_bit.Set();
       tracer_->increment_marked_count();
 #ifdef DEBUG
       UpdateLiveObjectCount(obj);
 #endif
       ProcessNewlyMarkedObject(obj);
     }
   }
 
-  INLINE(static void SetMark(HeapObject* obj)) {
-    Marking::SetMark(obj);
+  INLINE(static void SetMark(HeapObject* obj, MarkBit mark_bit)) {
+    ASSERT(Marking::MarkBitFrom(obj) == mark_bit);
+    mark_bit.Set();
     tracer_->increment_marked_count();
 #ifdef DEBUG
     UpdateLiveObjectCount(obj);
 #endif
   }
 
   static void ProcessNewlyMarkedObject(HeapObject* obj);
 
   // Creates back pointers for all map transitions, stores them in
   // the prototype field.  The original prototype pointers are restored
@@ skipping 120 matching lines @@
 
   friend class UnmarkObjectVisitor;
   static void UnmarkObject(HeapObject* obj);
 #endif
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_MARK_COMPACT_H_