Reland of [heap] Cleanup mark bit usage.

src/heap/mark-compact.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/heap/mark-compact.h"
 
 #include "src/base/atomicops.h"
 #include "src/base/bits.h"
 #include "src/base/sys-info.h"
 #include "src/code-stubs.h"
@@ skipping 1399 matching lines @@
 
 typedef StringTableCleaner<false> InternalizedStringTableCleaner;
 typedef StringTableCleaner<true> ExternalStringTableCleaner;
 
 
 // Implementation of WeakObjectRetainer for mark compact GCs. All marked objects
 // are retained.
 class MarkCompactWeakObjectRetainer : public WeakObjectRetainer {
  public:
   virtual Object* RetainAs(Object* object) {
-    if (Marking::IsBlackOrGrey(
-            Marking::MarkBitFrom(HeapObject::cast(object)))) {
+    MarkBit mark_bit = Marking::MarkBitFrom(HeapObject::cast(object));
+    DCHECK(!Marking::IsGrey(mark_bit));
+    if (Marking::IsBlack(mark_bit)) {
       return object;
     } else if (object->IsAllocationSite() &&
                !(AllocationSite::cast(object)->IsZombie())) {
       // "dead" AllocationSites need to live long enough for a traversal of new
       // space. These sites get a one-time reprieve.
       AllocationSite* site = AllocationSite::cast(object);
       site->MarkZombie();
       site->GetHeap()->mark_compact_collector()->MarkAllocationSite(site);
       return object;
     } else {
@@ skipping 888 matching lines @@
 }
 
 
 void MarkCompactCollector::ClearNonLiveMapTransitions(Map* map) {
   Object* potential_parent = map->GetBackPointer();
   if (!potential_parent->IsMap()) return;
   Map* parent = Map::cast(potential_parent);
 
   // Follow back pointer, check whether we are dealing with a map transition
   // from a live map to a dead path and in case clear transitions of parent.
-  DCHECK(!Marking::IsBlackOrGrey(Marking::MarkBitFrom(map)));
-  bool parent_is_alive = Marking::IsBlackOrGrey(Marking::MarkBitFrom(parent));
+  DCHECK(!Marking::IsGrey(Marking::MarkBitFrom(map)));
+  bool parent_is_alive = Marking::IsBlack(Marking::MarkBitFrom(parent));
   if (parent_is_alive) {
     ClearMapTransitions(parent, map);
   }
 }
 
 
 // Clear a possible back pointer in case the transition leads to a dead map.
 // Return true in case a back pointer has been cleared and false otherwise.
 bool MarkCompactCollector::ClearMapBackPointer(Map* target) {
-  if (Marking::IsBlackOrGrey(Marking::MarkBitFrom(target))) return false;
+  DCHECK(!Marking::IsGrey(Marking::MarkBitFrom(target)));
+  if (Marking::IsBlack(Marking::MarkBitFrom(target))) return false;
   target->SetBackPointer(heap_->undefined_value(), SKIP_WRITE_BARRIER);
   return true;
 }
 
 
 void MarkCompactCollector::ClearMapTransitions(Map* map, Map* dead_transition) {
   Object* transitions = map->raw_transitions();
   int num_transitions = TransitionArray::NumberOfTransitions(transitions);
 
   int number_of_own_descriptors = map->NumberOfOwnDescriptors();
@@ skipping 1770 matching lines @@
     MarkBit mark_bit = Marking::MarkBitFrom(host);
     if (Marking::IsBlack(mark_bit)) {
       RelocInfo rinfo(pc, RelocInfo::CODE_TARGET, 0, host);
       RecordRelocSlot(&rinfo, target);
     }
   }
 }
 
 }  // namespace internal
 }  // namespace v8