Avoid manual object's body traversal in GC.

src/heap/objects-visiting.h

Index: src/heap/objects-visiting.h
diff --git a/src/heap/objects-visiting.h b/src/heap/objects-visiting.h
index 787410d76f14ef7627ba2058ec25897c02d2202c..cf3e838c4e6c7213604ab055704622dafa56216e 100644
--- a/src/heap/objects-visiting.h
+++ b/src/heap/objects-visiting.h
@@ -191,21 +191,37 @@ class VisitorDispatchTable {
 template <typename StaticVisitor, typename BodyDescriptor, typename ReturnType>
 class FlexibleBodyVisitor : public AllStatic {
  public:
-  INLINE(static ReturnType Visit(Map* map, HeapObject* object)) {
+  V8_INLINE static ReturnType Visit(Map* map, HeapObject* object) {
     int object_size = BodyDescriptor::SizeOf(map, object);
     BodyDescriptor::template IterateBody<StaticVisitor>(object, object_size);
     return static_cast<ReturnType>(object_size);
   }
 
+  V8_INLINE static ReturnType Visit(Map* map, HeapObject* object,

[ulan, 2015/11/12 12:27:27]

Is this leftover from the previous patch?

+                                    StaticVisitor* v) {
+    int object_size = BodyDescriptor::SizeOf(map, object);
+    BodyDescriptor::template IterateBody(object, object_size, v);
+    return static_cast<ReturnType>(object_size);
+  }
+
+  // This specialization is only suitable for objects containing pointer fields.
+  template <int object_size>
+  V8_INLINE static ReturnType VisitSpecialized(Map* map, HeapObject* object) {
+    DCHECK(BodyDescriptor::SizeOf(map, object) == object_size);
+    DCHECK(!FLAG_unbox_double_fields || map->HasFastPointerLayout());
+    BodyDescriptor::template IteratePointers<StaticVisitor>(
+        object->GetHeap(), object, BodyDescriptor::kStartOffset, object_size);
+    return static_cast<ReturnType>(object_size);
+  }
+
   // This specialization is only suitable for objects containing pointer fields.
   template <int object_size>
-  static inline ReturnType VisitSpecialized(Map* map, HeapObject* object) {
+  V8_INLINE static ReturnType VisitSpecialized(Map* map, HeapObject* object,
+                                               StaticVisitor* v) {
     DCHECK(BodyDescriptor::SizeOf(map, object) == object_size);
     DCHECK(!FLAG_unbox_double_fields || map->HasFastPointerLayout());
-    StaticVisitor::VisitPointers(
-        object->GetHeap(), object,
-        HeapObject::RawField(object, BodyDescriptor::kStartOffset),
-        HeapObject::RawField(object, object_size));
+    BodyDescriptor::template IteratePointers(
+        object, BodyDescriptor::kStartOffset, object_size, v);
     return static_cast<ReturnType>(object_size);
   }
 };
@@ -214,10 +230,45 @@ class FlexibleBodyVisitor : public AllStatic {
 template <typename StaticVisitor, typename BodyDescriptor, typename ReturnType>
 class FixedBodyVisitor : public AllStatic {
  public:
-  INLINE(static ReturnType Visit(Map* map, HeapObject* object)) {
+  V8_INLINE static ReturnType Visit(Map* map, HeapObject* object) {
     BodyDescriptor::template IterateBody<StaticVisitor>(object);
     return static_cast<ReturnType>(BodyDescriptor::kSize);
   }
+
+  V8_INLINE static ReturnType Visit(Map* map, HeapObject* object,
+                                    StaticVisitor* v) {
+    BodyDescriptor::template IterateBody(object, v);
+    return static_cast<ReturnType>(BodyDescriptor::kSize);
+  }
+};
+
+
+template <typename StaticVisitor, typename BodyDescriptor, typename ReturnType>
+class DataBodyVisitor {
+ public:
+  V8_INLINE static ReturnType Visit(Map* map, HeapObject* object) {
+    int object_size = BodyDescriptor::SizeOf(map, object);
+    return static_cast<ReturnType>(object_size);
+  }
+
+  V8_INLINE static ReturnType Visit(Map* map, HeapObject* object,
+                                    StaticVisitor* v) {
+    int object_size = BodyDescriptor::SizeOf(map, object);
+    return static_cast<ReturnType>(object_size);
+  }
+
+  template <int object_size>
+  V8_INLINE static ReturnType VisitSpecialized(Map* map, HeapObject* object) {
+    DCHECK(BodyDescriptor::SizeOf(map, object) == object_size);
+    return static_cast<ReturnType>(object_size);
+  }
+
+  template <int object_size>
+  V8_INLINE static ReturnType VisitSpecialized(Map* map, HeapObject* object,
+                                               StaticVisitor* v) {
+    DCHECK(BodyDescriptor::SizeOf(map, object) == object_size);
+    return static_cast<ReturnType>(object_size);
+  }
 };
 
 
@@ -296,17 +347,8 @@ class StaticNewSpaceVisitor : public StaticVisitorBase {
   INLINE(static int VisitJSDataView(Map* map, HeapObject* object));
   INLINE(static int VisitBytecodeArray(Map* map, HeapObject* object));
 
-  class DataObjectVisitor {
-   public:
-    template <int object_size>
-    static inline int VisitSpecialized(Map* map, HeapObject* object) {
-      return object_size;
-    }
-
-    INLINE(static int Visit(Map* map, HeapObject* object)) {
-      return map->instance_size();
-    }
-  };
+  typedef DataBodyVisitor<StaticVisitor, StructBodyDescriptor, int>
+      DataObjectVisitor;
 
   typedef FlexibleBodyVisitor<StaticVisitor, StructBodyDescriptor, int>
       StructVisitor;
@@ -401,13 +443,8 @@ class StaticMarkingVisitor : public StaticVisitorBase {
   static void VisitJSFunctionStrongCode(Map* map, HeapObject* object);
   static void VisitJSFunctionWeakCode(Map* map, HeapObject* object);
 
-  class DataObjectVisitor {
-   public:
-    template <int size>
-    static inline void VisitSpecialized(Map* map, HeapObject* object) {}
-
-    INLINE(static void Visit(Map* map, HeapObject* object)) {}
-  };
+  typedef DataBodyVisitor<StaticVisitor, StructBodyDescriptor, void>
+      DataObjectVisitor;
 
   typedef FlexibleBodyVisitor<StaticVisitor, FixedArray::BodyDescriptor, void>
       FixedArrayVisitor;