[heap] Add atomics to mark bit operations.

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 1069 matching lines @@
       heap->mark_compact_collector()->MarkObject<MarkingMode::YOUNG_GENERATION>(
           HeapObject::cast(target));
     }
   }
 
  protected:
   inline static bool MarkRecursively(Heap* heap, HeapObject* object) {
     StackLimitCheck check(heap->isolate());
     if (check.HasOverflowed()) return false;
 
-    if (ObjectMarking::IsBlackOrGrey<MarkingMode::YOUNG_GENERATION>(object))
+    if (ObjectMarking::IsBlackOrGrey<MarkBit::NON_ATOMIC,
+                                     MarkingMode::YOUNG_GENERATION>(object))
       return true;
-    ObjectMarking::WhiteToBlack<MarkingMode::YOUNG_GENERATION>(object);
+    ObjectMarking::WhiteToBlack<MarkBit::NON_ATOMIC,
+                                MarkingMode::YOUNG_GENERATION>(object);
     IterateBody(object->map(), object);
     return true;
   }
 };
 
 class MarkCompactMarkingVisitor
     : public StaticMarkingVisitor<MarkCompactMarkingVisitor> {
  public:
   static void Initialize();
 
@@ skipping 258 matching lines @@
  private:
   void MarkObjectByPointer(Object** p) {
     if (!(*p)->IsHeapObject()) return;
 
     HeapObject* object = HeapObject::cast(*p);
 
     if (mode == MarkingMode::YOUNG_GENERATION &&
         !collector_->heap()->InNewSpace(object))
       return;
 
-    if (ObjectMarking::IsBlackOrGrey<mode>(object)) return;
+    if (ObjectMarking::IsBlackOrGrey<MarkBit::NON_ATOMIC, mode>(object)) return;
 
     Map* map = object->map();
     // Mark the object.
-    ObjectMarking::WhiteToBlack<mode>(object);
+    ObjectMarking::WhiteToBlack<MarkBit::NON_ATOMIC, mode>(object);
 
     switch (mode) {
       case MarkingMode::FULL: {
         // Mark the map pointer and body, and push them on the marking stack.
         collector_->MarkObject(map);
         MarkCompactMarkingVisitor::IterateBody(map, object);
       } break;
       case MarkingMode::YOUNG_GENERATION:
         StaticYoungGenerationMarkingVisitor::IterateBody(map, object);
         break;
@@ skipping 594 matching lines @@
 // After: the marking stack is empty, and all objects reachable from the
 // marking stack have been marked, or are overflowed in the heap.
 template <MarkingMode mode>
 void MarkCompactCollector::EmptyMarkingDeque() {
   while (!marking_deque<mode>()->IsEmpty()) {
     HeapObject* object = marking_deque<mode>()->Pop();
 
     DCHECK(!object->IsFiller());
     DCHECK(object->IsHeapObject());
     DCHECK(heap()->Contains(object));
-    DCHECK(!ObjectMarking::IsWhite<mode>(object));
+    DCHECK(!(ObjectMarking::IsWhite<MarkBit::NON_ATOMIC, mode>(object)));
 
     Map* map = object->map();
     switch (mode) {
       case MarkingMode::FULL: {
         MarkObject(map);
         MarkCompactMarkingVisitor::IterateBody(map, object);
       } break;
       case MarkingMode::YOUNG_GENERATION: {
-        DCHECK(ObjectMarking::IsBlack<mode>(object));
+        DCHECK((ObjectMarking::IsBlack<MarkBit::NON_ATOMIC, mode>(object)));
         StaticYoungGenerationMarkingVisitor::IterateBody(map, object);
       } break;
     }
   }
 }
 
 
 // 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 237 matching lines @@
 }
 
 SlotCallbackResult MarkCompactCollector::CheckAndMarkObject(
     Heap* heap, Address slot_address) {
   Object* object = *reinterpret_cast<Object**>(slot_address);
   if (heap->InNewSpace(object)) {
     // Marking happens before flipping the young generation, so the object
     // has to be in ToSpace.
     DCHECK(heap->InToSpace(object));
     HeapObject* heap_object = reinterpret_cast<HeapObject*>(object);
-    if (ObjectMarking::IsBlackOrGrey<MarkingMode::YOUNG_GENERATION>(
+    if (ObjectMarking::IsBlackOrGrey<MarkBit::NON_ATOMIC,
+                                     MarkingMode::YOUNG_GENERATION>(
             heap_object)) {
       return KEEP_SLOT;
     }
-    ObjectMarking::WhiteToBlack<MarkingMode::YOUNG_GENERATION>(heap_object);
+    ObjectMarking::WhiteToBlack<MarkBit::NON_ATOMIC,
+                                MarkingMode::YOUNG_GENERATION>(heap_object);
     StaticYoungGenerationMarkingVisitor::IterateBody(heap_object->map(),
                                                      heap_object);
     return KEEP_SLOT;
   }
   return REMOVE_SLOT;
 }
 
 static bool IsUnmarkedObject(Heap* heap, Object** p) {
   DCHECK_IMPLIES(heap->InNewSpace(*p), heap->InToSpace(*p));
   return heap->InNewSpace(*p) && !ObjectMarking::IsBlack(HeapObject::cast(*p));
@@ skipping 1735 matching lines @@
       // The target is always in old space, we don't have to record the slot in
       // the old-to-new remembered set.
       DCHECK(!heap()->InNewSpace(target));
       RecordRelocSlot(host, &rinfo, target);
     }
   }
 }
 
 }  // namespace internal
 }  // namespace v8