[heap] MC: Go through marking deque when marking roots

Bug: chromium:750084
Change-Id: I3c0059f1e986b5e4400f84f44b7f179e7232eae1
Reviewed-on: https://chromium-review.googlesource.com/610781
Commit-Queue: Michael Lippautz <mlippautz@chromium.org>
Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
Cr-Commit-Position: refs/heads/master@{#47292}

src/heap/mark-compact-inl.h

@@ -28,6 +28,15 @@ void MarkCompactCollector::MarkObject(HeapObject* host, HeapObject* obj) {
   }
 }
 
+void MarkCompactCollector::MarkRootObject(Root root, HeapObject* obj) {
+  if (non_atomic_marking_state()->WhiteToBlack(obj)) {
+    PushBlack(obj);
+    if (V8_UNLIKELY(FLAG_track_retaining_path)) {
+      heap_->AddRetainingRoot(root, obj);
+    }
+  }
+}
+
 void MarkCompactCollector::MarkExternallyReferencedObject(HeapObject* obj) {
   if (non_atomic_marking_state()->WhiteToBlack(obj)) {
     PushBlack(obj);

src/heap/mark-compact.cc

@@ -1197,50 +1197,28 @@ void MinorMarkCompactCollector::CleanupSweepToIteratePages() {
   sweep_to_iterate_pages_.clear();
 }
 
-class MarkCompactCollector::RootMarkingVisitor : public RootVisitor {
+class MarkCompactCollector::RootMarkingVisitor final : public RootVisitor {
  public:
   explicit RootMarkingVisitor(MarkCompactCollector* collector)
-      : collector_(collector),
-        marking_state_(collector->non_atomic_marking_state()),
-        visitor_(collector_) {}
+      : collector_(collector) {}
 
-  void VisitRootPointer(Root root, Object** p) override {
-    MarkObjectByPointer(nullptr, p, root);
+  void VisitRootPointer(Root root, Object** p) final {
+    MarkObjectByPointer(root, p);
   }
 
-  void VisitRootPointers(Root root, Object** start, Object** end) override {
-    for (Object** p = start; p < end; p++)
-      MarkObjectByPointer(nullptr, p, root);
+  void VisitRootPointers(Root root, Object** start, Object** end) final {
+    for (Object** p = start; p < end; p++) MarkObjectByPointer(root, p);
   }
 
  private:
-  void MarkObjectByPointer(HeapObject* host, Object** p,
-                           Root root = Root::kUnknown) {
+  V8_INLINE void MarkObjectByPointer(Root root, Object** p) {
     if (!(*p)->IsHeapObject()) return;
 
-    HeapObject* object = HeapObject::cast(*p);
-
-    if (marking_state_->WhiteToBlack(object)) {
-      if (V8_UNLIKELY(FLAG_track_retaining_path)) {
-        if (host) {
-          object->GetHeap()->AddRetainer(host, object);
-        } else {
-          object->GetHeap()->AddRetainingRoot(root, object);
-        }
-      }
-      Map* map = object->map();
-      // Mark the map pointer and body, and push them on the marking stack.
-      collector_->MarkObject(object, map);
-      visitor_.Visit(map, object);
-      // Mark all the objects reachable from the map and body.  May leave
-      // overflowed objects in the heap.
-      collector_->EmptyMarkingWorklist();
-    }
+    collector_->MarkRootObject(root, HeapObject::cast(*p));
+    collector_->EmptyMarkingWorklist();
   }
 
   MarkCompactCollector* const collector_;
-  MarkCompactCollector::NonAtomicMarkingState* marking_state_;
-  MarkCompactMarkingVisitor visitor_;
 };
 
 // This visitor is used to visit the body of special objects held alive by

src/heap/mark-compact.h

@@ -776,14 +776,17 @@ class MarkCompactCollector final : public MarkCompactCollectorBase {
 
   void MarkLiveObjects() override;
 
-  // Pushes a black object onto the marking stack and accounts for live bytes.
-  // Note that this assumes live bytes have not yet been counted.
+  // Pushes a black object onto the marking work list.
   V8_INLINE void PushBlack(HeapObject* obj);
 
-  // Marks the object black and pushes it on the marking stack.
+  // Marks the object black and adds it to the marking work list.
   // This is for non-incremental marking only.
   V8_INLINE void MarkObject(HeapObject* host, HeapObject* obj);
 
+  // Marks the object black and adds it to the marking work list.
+  // This is for non-incremental marking only.
+  V8_INLINE void MarkRootObject(Root root, HeapObject* obj);
+
   // Used by wrapper tracing.
   V8_INLINE void MarkExternallyReferencedObject(HeapObject* obj);