[heap] Make non-atomic markbit operations consistent with atomic ones.

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 1158 matching lines @@
       if (MarkRecursively(heap, target_object)) return;
       heap->minor_mark_compact_collector()->MarkObject(target_object);
     }
   }
 
  protected:
   inline static bool MarkRecursively(Heap* heap, HeapObject* object) {
     StackLimitCheck check(heap->isolate());
     if (check.HasOverflowed()) return false;
 
-    if (ObjectMarking::IsBlackOrGrey<MarkBit::NON_ATOMIC>(
-            object, MarkingState::External(object)))
-      return true;
-    ObjectMarking::WhiteToBlack<MarkBit::NON_ATOMIC>(
-        object, MarkingState::External(object));
-    IterateBody(object->map(), object);
+    if (ObjectMarking::WhiteToBlack<MarkBit::NON_ATOMIC>(
+            object, MarkingState::External(object))) {
+      IterateBody(object->map(), object);
+    }
     return true;
   }
 };
 
 class MarkCompactMarkingVisitor
     : public StaticMarkingVisitor<MarkCompactMarkingVisitor> {
  public:
   static void Initialize();
 
   INLINE(static void VisitPointer(Heap* heap, HeapObject* object, Object** p)) {
@@ skipping 15 matching lines @@
   }
 
   // Marks the object black and pushes it on the marking stack.
   INLINE(static void MarkObject(Heap* heap, HeapObject* object)) {
     heap->mark_compact_collector()->MarkObject(object);
   }
 
   // Marks the object black without pushing it on the marking stack.
   // Returns true if object needed marking and false otherwise.
   INLINE(static bool MarkObjectWithoutPush(Heap* heap, HeapObject* object)) {
-    if (ObjectMarking::IsWhite(object, MarkingState::Internal(object))) {
-      ObjectMarking::WhiteToBlack(object, MarkingState::Internal(object));
-      return true;
-    }
-    return false;
+    return ObjectMarking::WhiteToBlack(object, MarkingState::Internal(object));
   }
 
   // Mark object pointed to by p.
   INLINE(static void MarkObjectByPointer(MarkCompactCollector* collector,
                                          HeapObject* object, Object** p)) {
     if (!(*p)->IsHeapObject()) return;
     HeapObject* target_object = HeapObject::cast(*p);
     collector->RecordSlot(object, p, target_object);
     collector->MarkObject(target_object);
   }
 
 
   // Visit an unmarked object.
   INLINE(static void VisitUnmarkedObject(MarkCompactCollector* collector,
                                          HeapObject* obj)) {
 #ifdef DEBUG
     DCHECK(collector->heap()->Contains(obj));
-    DCHECK(ObjectMarking::IsWhite(obj, MarkingState::Internal(obj)));
 #endif
-    Map* map = obj->map();
-    Heap* heap = obj->GetHeap();
-    ObjectMarking::WhiteToBlack(obj, MarkingState::Internal(obj));
-    // Mark the map pointer and the body.
-    heap->mark_compact_collector()->MarkObject(map);
-    IterateBody(map, obj);
+    if (ObjectMarking::WhiteToBlack(obj, MarkingState::Internal(obj))) {
+      Map* map = obj->map();
+      Heap* heap = obj->GetHeap();
+      ObjectMarking::WhiteToBlack(obj, MarkingState::Internal(obj));
+      // Mark the map pointer and the body.
+      heap->mark_compact_collector()->MarkObject(map);
+      IterateBody(map, obj);
+    }
   }
 
   // Visit all unmarked objects pointed to by [start, end).
   // Returns false if the operation fails (lack of stack space).
   INLINE(static bool VisitUnmarkedObjects(Heap* heap, HeapObject* object,
                                           Object** start, Object** end)) {
     // Return false is we are close to the stack limit.
     StackLimitCheck check(heap->isolate());
     if (check.HasOverflowed()) return false;
 
     MarkCompactCollector* collector = heap->mark_compact_collector();
     // Visit the unmarked objects.
     for (Object** p = start; p < end; p++) {
       Object* o = *p;
       if (!o->IsHeapObject()) continue;
       collector->RecordSlot(object, p, o);
       HeapObject* obj = HeapObject::cast(o);
-      if (ObjectMarking::IsBlackOrGrey(obj, MarkingState::Internal(obj)))
-        continue;
       VisitUnmarkedObject(collector, obj);
     }
     return true;
   }
 
  private:
   // Code flushing support.
 
   static const int kRegExpCodeThreshold = 5;
 
@@ skipping 176 matching lines @@
   }
 
  private:
   void MarkObjectByPointer(Object** p) {
     if (!(*p)->IsHeapObject()) return;
 
     HeapObject* object = HeapObject::cast(*p);
 
     if (!collector_->heap()->InNewSpace(object)) return;
 
-    if (ObjectMarking::IsBlackOrGrey<MarkBit::NON_ATOMIC>(
-            object, MarkingState::External(object)))
-      return;
-
-    Map* map = object->map();
-    ObjectMarking::WhiteToBlack<MarkBit::NON_ATOMIC>(
-        object, MarkingState::External(object));
-    StaticYoungGenerationMarkingVisitor::IterateBody(map, object);
-
-    collector_->EmptyMarkingDeque();
+    if (ObjectMarking::WhiteToBlack<MarkBit::NON_ATOMIC>(
+            object, MarkingState::External(object))) {
+      Map* map = object->map();
+      StaticYoungGenerationMarkingVisitor::IterateBody(map, object);
+      collector_->EmptyMarkingDeque();
+    }
   }
 
   MinorMarkCompactCollector* collector_;
 };
 
 // Visitor class for marking heap roots.
 // TODO(ulan): Remove ObjectVisitor base class after fixing marking of
 // the string table and the top optimized code.
 class MarkCompactCollector::RootMarkingVisitor : public ObjectVisitor,
                                                  public RootVisitor {
@@ skipping 20 matching lines @@
   // Skip the weak next code link in a code object, which is visited in
   // ProcessTopOptimizedFrame.
   void VisitNextCodeLink(Code* host, Object** p) override {}
 
  private:
   void MarkObjectByPointer(Object** p) {
     if (!(*p)->IsHeapObject()) return;
 
     HeapObject* object = HeapObject::cast(*p);
 
-    if (ObjectMarking::IsBlackOrGrey<MarkBit::NON_ATOMIC>(
-            object, MarkingState::Internal(object)))
-      return;
-
-    Map* map = object->map();
-    // Mark the object.
-    ObjectMarking::WhiteToBlack<MarkBit::NON_ATOMIC>(
-        object, MarkingState::Internal(object));
-
-    // Mark the map pointer and body, and push them on the marking stack.
-    collector_->MarkObject(map);
-    MarkCompactMarkingVisitor::IterateBody(map, object);
-
-    // Mark all the objects reachable from the map and body.  May leave
-    // overflowed objects in the heap.
-    collector_->EmptyMarkingDeque();
+    if (ObjectMarking::WhiteToBlack<MarkBit::NON_ATOMIC>(
+            object, MarkingState::Internal(object))) {
+      Map* map = object->map();
+      // Mark the map pointer and body, and push them on the marking stack.
+      collector_->MarkObject(map);
+      MarkCompactMarkingVisitor::IterateBody(map, object);
+      // Mark all the objects reachable from the map and body.  May leave
+      // overflowed objects in the heap.
+      collector_->EmptyMarkingDeque();
+    }
   }
 
   MarkCompactCollector* collector_;
 };
 
 class InternalizedStringTableCleaner : public ObjectVisitor {
  public:
   InternalizedStringTableCleaner(Heap* heap, HeapObject* table)
       : heap_(heap), pointers_removed_(0), table_(table) {}
 
@@ skipping 90 matching lines @@
 // is reached, whichever comes first.
 template <class T>
 void MarkCompactCollector::DiscoverGreyObjectsWithIterator(T* it) {
   // The caller should ensure that the marking stack is initially not full,
   // so that we don't waste effort pointlessly scanning for objects.
   DCHECK(!marking_deque()->IsFull());
 
   Map* filler_map = heap()->one_pointer_filler_map();
   for (HeapObject* object = it->Next(); object != NULL; object = it->Next()) {
     if ((object->map() != filler_map) &&
-        ObjectMarking::IsGrey(object, MarkingState::Internal(object))) {
-      ObjectMarking::GreyToBlack(object, MarkingState::Internal(object));
+        ObjectMarking::GreyToBlack(object, MarkingState::Internal(object))) {
       PushBlack(object);
       if (marking_deque()->IsFull()) return;
     }
   }
 }
 
 void MarkCompactCollector::DiscoverGreyObjectsOnPage(MemoryChunk* p) {
   DCHECK(!marking_deque()->IsFull());
   LiveObjectIterator<kGreyObjects> it(p, MarkingState::Internal(p));
   HeapObject* object = NULL;
   while ((object = it.Next()) != NULL) {
-    DCHECK(ObjectMarking::IsGrey(object, MarkingState::Internal(object)));
-    ObjectMarking::GreyToBlack(object, MarkingState::Internal(object));
+    bool success =
+        ObjectMarking::GreyToBlack(object, MarkingState::Internal(object));
+    DCHECK(success);
+    USE(success);
     PushBlack(object);
     if (marking_deque()->IsFull()) return;
   }
 }
 
 class RecordMigratedSlotVisitor : public ObjectVisitor {
  public:
   explicit RecordMigratedSlotVisitor(MarkCompactCollector* collector)
       : collector_(collector) {}
 
@@ skipping 473 matching lines @@
 bool MarkCompactCollector::IsUnmarkedHeapObject(Object** p) {
   Object* o = *p;
   if (!o->IsHeapObject()) return false;
   return ObjectMarking::IsWhite(HeapObject::cast(o),
                                 MarkingState::Internal(HeapObject::cast(o)));
 }
 
 void MarkCompactCollector::MarkStringTable(RootMarkingVisitor* visitor) {
   StringTable* string_table = heap()->string_table();
   // Mark the string table itself.
-  if (ObjectMarking::IsWhite(string_table,
-                             MarkingState::Internal(string_table))) {
-    // String table could have already been marked by visiting the handles list.
-    ObjectMarking::WhiteToBlack(string_table,
-                                MarkingState::Internal(string_table));
+  if (ObjectMarking::WhiteToBlack(string_table,
+                                  MarkingState::Internal(string_table))) {
+    // Explicitly mark the prefix.
+    string_table->IteratePrefix(visitor);
+    ProcessMarkingDeque();
   }
-  // Explicitly mark the prefix.
-  string_table->IteratePrefix(visitor);

[Michael Lippautz, 2017/05/03 07:48:39]

:)

-  ProcessMarkingDeque();
 }
 
 void MarkCompactCollector::MarkRoots(RootMarkingVisitor* visitor) {
   // Mark the heap roots including global variables, stack variables,
   // etc., and all objects reachable from them.
   heap()->IterateStrongRoots(visitor, VISIT_ONLY_STRONG);
 
   // Handle the string table specially.
   MarkStringTable(visitor);
 
@@ skipping 2018 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