[heap] Introduce HeapVisitor interface.

src/heap/objects-visiting-inl.h

 // 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.
 
 #ifndef V8_OBJECTS_VISITING_INL_H_
 #define V8_OBJECTS_VISITING_INL_H_
 
 #include "src/heap/array-buffer-tracker.h"
 #include "src/heap/mark-compact.h"
 #include "src/heap/objects-visiting.h"
@@ skipping 32 matching lines @@
   table_.Register(
       kVisitSymbol,
       &FixedBodyVisitor<StaticVisitor, Symbol::BodyDescriptor, int>::Visit);
 
   table_.Register(kVisitFixedArray,
                   &FlexibleBodyVisitor<StaticVisitor,
                                        FixedArray::BodyDescriptor, int>::Visit);
 
   table_.Register(kVisitFixedDoubleArray, &VisitFixedDoubleArray);
   table_.Register(
-      kVisitFixedTypedArray,
+      kVisitFixedTypedArrayBase,
       &FlexibleBodyVisitor<StaticVisitor, FixedTypedArrayBase::BodyDescriptor,
                            int>::Visit);
 
   table_.Register(
       kVisitFixedFloat64Array,
       &FlexibleBodyVisitor<StaticVisitor, FixedTypedArrayBase::BodyDescriptor,
                            int>::Visit);
 
   table_.Register(
       kVisitNativeContext,
@@ skipping 65 matching lines @@
 
   table_.Register(
       kVisitSymbol,
       &FixedBodyVisitor<StaticVisitor, Symbol::BodyDescriptor, void>::Visit);
 
   table_.Register(kVisitFixedArray, &FixedArrayVisitor::Visit);
 
   table_.Register(kVisitFixedDoubleArray, &DataObjectVisitor::Visit);
 
   table_.Register(
-      kVisitFixedTypedArray,
+      kVisitFixedTypedArrayBase,
       &FlexibleBodyVisitor<StaticVisitor, FixedTypedArrayBase::BodyDescriptor,
                            void>::Visit);
 
   table_.Register(
       kVisitFixedFloat64Array,
       &FlexibleBodyVisitor<StaticVisitor, FixedTypedArrayBase::BodyDescriptor,
                            void>::Visit);
 
   table_.Register(kVisitNativeContext, &VisitNativeContext);
 
@@ skipping 471 matching lines @@
 
 template <typename StaticVisitor>
 void StaticMarkingVisitor<StaticVisitor>::VisitJSFunctionStrongCode(
     Map* map, HeapObject* object) {
   typedef FlexibleBodyVisitor<StaticVisitor,
                               JSFunction::BodyDescriptorStrongCode,
                               void> JSFunctionStrongCodeBodyVisitor;
   JSFunctionStrongCodeBodyVisitor::Visit(map, object);
 }
 
-
 template <typename StaticVisitor>
 void StaticMarkingVisitor<StaticVisitor>::VisitJSFunctionWeakCode(
     Map* map, HeapObject* object) {
   typedef FlexibleBodyVisitor<StaticVisitor, JSFunction::BodyDescriptorWeakCode,
                               void> JSFunctionWeakCodeBodyVisitor;
   JSFunctionWeakCodeBodyVisitor::Visit(map, object);
 }
 
+template <typename ResultType, typename ConcreteVisitor>
+ResultType HeapVisitor<ResultType, ConcreteVisitor>::IterateBody(
+    HeapObject* object) {
+  Map* map = object->map();
+  ConcreteVisitor* visitor = static_cast<ConcreteVisitor*>(this);
+  switch (static_cast<VisitorId>(map->visitor_id())) {
+#define CASE(type)   \
+  case kVisit##type: \
+    return visitor->Visit##type(map, type::cast(object));
+    TYPED_VISITOR_ID_LIST(CASE)
+#undef CASE
+    case kVisitShortcutCandidate:
+      return visitor->VisitShortcutCandidate(map, ConsString::cast(object));
+    case kVisitNativeContext:
+      return visitor->VisitNativeContext(map, Context::cast(object));
+    case kVisitDataObject:
+      return visitor->VisitDataObject(map, HeapObject::cast(object));
+    case kVisitJSObjectFast:
+      return visitor->VisitJSObjectFast(map, JSObject::cast(object));
+    case kVisitJSApiObject:
+      return visitor->VisitJSApiObject(map, JSObject::cast(object));
+    case kVisitStruct:
+      return visitor->VisitStruct(map, HeapObject::cast(object));
+    case kVisitFreeSpace:
+      return visitor->VisitFreeSpace(map, FreeSpace::cast(object));
+    case kVisitorIdCount:
+      UNREACHABLE();
+  }
+  UNREACHABLE();
+  // Make the compiler happy.
+  return ResultType();
+}
+
+#define VISIT(type)                                                         \
+  template <typename ResultType, typename ConcreteVisitor>                  \
+  ResultType HeapVisitor<ResultType, ConcreteVisitor>::Visit##type(         \
+      Map* map, type* object) {                                             \
+    int size = type::BodyDescriptor::SizeOf(map, object);                   \
+    type::BodyDescriptor::IterateBody(object, size,                         \
+                                      static_cast<ConcreteVisitor*>(this)); \
+    return static_cast<ResultType>(size);                                   \
+  }
+TYPED_VISITOR_ID_LIST(VISIT)
+#undef VISIT
+
+template <typename ResultType, typename ConcreteVisitor>
+ResultType HeapVisitor<ResultType, ConcreteVisitor>::VisitShortcutCandidate(
+    Map* map, ConsString* object) {
+  int size = ConsString::BodyDescriptor::SizeOf(map, object);
+  ConsString::BodyDescriptor::IterateBody(object, size,
+                                          static_cast<ConcreteVisitor*>(this));
+  return static_cast<ResultType>(size);
+}
+
+template <typename ResultType, typename ConcreteVisitor>
+ResultType HeapVisitor<ResultType, ConcreteVisitor>::VisitNativeContext(
+    Map* map, Context* object) {
+  int size = Context::BodyDescriptor::SizeOf(map, object);
+  Context::BodyDescriptor::IterateBody(object, size,
+                                       static_cast<ConcreteVisitor*>(this));
+  return static_cast<ResultType>(size);
+}
+
+template <typename ResultType, typename ConcreteVisitor>
+ResultType HeapVisitor<ResultType, ConcreteVisitor>::VisitDataObject(
+    Map* map, HeapObject* object) {
+  int size = map->instance_size();
+  return static_cast<ResultType>(size);
+}
+
+template <typename ResultType, typename ConcreteVisitor>
+ResultType HeapVisitor<ResultType, ConcreteVisitor>::VisitJSObjectFast(
+    Map* map, JSObject* object) {
+  int size = JSObject::FastBodyDescriptor::SizeOf(map, object);
+  JSObject::FastBodyDescriptor::IterateBody(
+      object, size, static_cast<ConcreteVisitor*>(this));
+  return static_cast<ResultType>(size);
+}
+template <typename ResultType, typename ConcreteVisitor>
+ResultType HeapVisitor<ResultType, ConcreteVisitor>::VisitJSApiObject(
+    Map* map, JSObject* object) {
+  int size = JSObject::BodyDescriptor::SizeOf(map, object);
+  JSObject::BodyDescriptor::IterateBody(object, size,
+                                        static_cast<ConcreteVisitor*>(this));
+  return static_cast<ResultType>(size);
+}
+template <typename ResultType, typename ConcreteVisitor>
+ResultType HeapVisitor<ResultType, ConcreteVisitor>::VisitStruct(
+    Map* map, HeapObject* object) {
+  int size = map->instance_size();
+  StructBodyDescriptor::IterateBody(object, size,
+                                    static_cast<ConcreteVisitor*>(this));
+  return static_cast<ResultType>(size);
+}
+template <typename ResultType, typename ConcreteVisitor>
+ResultType HeapVisitor<ResultType, ConcreteVisitor>::VisitFreeSpace(
+    Map* map, FreeSpace* object) {
+  return static_cast<ResultType>(FreeSpace::cast(object)->size());
+}
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_OBJECTS_VISITING_INL_H_