[heap] Introduce HeapVisitor interface.

src/heap/concurrent-marking.cc

 // Copyright 2017 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/concurrent-marking.h"
 
 #include <stack>
 #include <unordered_map>
 
 #include "src/heap/heap-inl.h"
 #include "src/heap/heap.h"
 #include "src/heap/marking.h"
+#include "src/heap/objects-visiting-inl.h"
+#include "src/heap/objects-visiting.h"
 #include "src/isolate.h"
 #include "src/locked-queue-inl.h"
 #include "src/utils-inl.h"
 #include "src/utils.h"
 #include "src/v8.h"
 
 namespace v8 {
 namespace internal {
 
 class ConcurrentMarkingMarkbits {
@@ skipping 20 matching lines @@
   Bitmap* AllocateBitmap() {
     return static_cast<Bitmap*>(calloc(1, Bitmap::kSize));
   }
 
   void FreeBitmap(Bitmap* bitmap) { free(bitmap); }
 
  private:
   std::unordered_map<MemoryChunk*, Bitmap*> bitmap_;
 };
 
-class ConcurrentMarkingVisitor : public ObjectVisitor {
+class ConcurrentMarkingVisitor final
+    : public HeapVisitor<int, ConcurrentMarkingVisitor> {
  public:
+  using BaseClass = HeapVisitor<int, ConcurrentMarkingVisitor>;
+
   ConcurrentMarkingVisitor() : bytes_marked_(0) {}
 
   void VisitPointers(HeapObject* host, Object** start, Object** end) override {
     for (Object** p = start; p < end; p++) {
       if (!(*p)->IsHeapObject()) continue;
       MarkObject(HeapObject::cast(*p));
     }
   }
 
+  // ===========================================================================
+  // JS object =================================================================
+  // ===========================================================================
+
+  int VisitJSObject(Map* map, JSObject* object) override {
+    // TODO(ulan): impement snapshot iteration.
+    return BaseClass::VisitJSObject(map, object);
+  }
+
+  int VisitJSObjectFast(Map* map, JSObject* object) override {
+    return VisitJSObject(map, object);
+  }
+
+  int VisitJSApiObject(Map* map, JSObject* object) override {
+    return VisitJSObject(map, object);
+  }
+
+  // ===========================================================================
+  // Fixed array object ========================================================
+  // ===========================================================================
+
+  int VisitFixedArray(Map* map, FixedArray* object) override {
+    // TODO(ulan): implement iteration with prefetched length.
+    return BaseClass::VisitFixedArray(map, object);
+  }
+
+  // ===========================================================================
+  // Code object ===============================================================
+  // ===========================================================================
+
+  int VisitCode(Map* map, Code* object) override {
+    // TODO(ulan): push the object to the bail-out deque.
+    return 0;
+  }
+
+  // ===========================================================================
+  // Objects with weak fields and/or side-effectiful visitation.
+  // ===========================================================================
+
+  int VisitBytecodeArray(Map* map, BytecodeArray* object) override {
+    // TODO(ulan): implement iteration of strong fields and push the object to
+    // the bailout deque.
+    return 0;
+  }
+
+  int VisitJSFunction(Map* map, JSFunction* object) override {
+    // TODO(ulan): implement iteration of strong fields and push the object to
+    // the bailout deque.
+    return 0;
+  }
+
+  int VisitMap(Map* map, Map* object) override {
+    // TODO(ulan): implement iteration of strong fields and push the object to
+    // the bailout deque.
+    return 0;
+  }
+
+  int VisitNativeContext(Map* map, Context* object) override {
+    // TODO(ulan): implement iteration of strong fields and push the object to
+    // the bailout deque.
+    return 0;
+  }
+
+  int VisitSharedFunctionInfo(Map* map, SharedFunctionInfo* object) override {
+    // TODO(ulan): implement iteration of strong fields and push the object to
+    // the bailout deque.
+    return 0;
+  }
+
+  int VisitTransitionArray(Map* map, TransitionArray* object) override {
+    // TODO(ulan): implement iteration of strong fields and push the object to
+    // the bailout deque.
+    return 0;
+  }
+
+  int VisitWeakCell(Map* map, WeakCell* object) override {
+    // TODO(ulan): implement iteration of strong fields and push the object to
+    // the bailout deque.
+    return 0;
+  }
+
+  int VisitJSWeakCollection(Map* map, JSWeakCollection* object) override {
+    // TODO(ulan): implement iteration of strong fields and push the object to
+    // the bailout deque.
+    return 0;
+  }
+
   void MarkObject(HeapObject* obj) {
     if (markbits_.Mark(obj)) {
-      bytes_marked_ += obj->Size();
       marking_stack_.push(obj);
     }
   }
 
   void MarkTransitively() {
     while (!marking_stack_.empty()) {
       HeapObject* obj = marking_stack_.top();
       marking_stack_.pop();
-      obj->Iterate(this);
+      bytes_marked_ += IterateBody(obj);
     }
   }
 
   size_t bytes_marked() { return bytes_marked_; }
 
  private:
   size_t bytes_marked_;
   std::stack<HeapObject*> marking_stack_;
   ConcurrentMarkingMarkbits markbits_;
 };
@@ skipping 66 matching lines @@
 }
 
 void ConcurrentMarking::EnsureTaskCompleted() {
   if (IsTaskPending()) {
     WaitForTaskToComplete();
   }
 }
 
 }  // namespace internal
 }  // namespace v8