Avoid manual object's body traversal in GC.

src/heap/objects-visiting.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_H_
 #define V8_OBJECTS_VISITING_H_
 
 #include "src/allocation.h"
 #include "src/heap/heap.h"
 #include "src/heap/spaces.h"
@@ skipping 173 matching lines @@
   }
 
  private:
   base::AtomicWord callbacks_[StaticVisitorBase::kVisitorIdCount];
 };
 
 
 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>
-  static inline ReturnType VisitSpecialized(Map* map, HeapObject* object) {
+  V8_INLINE static ReturnType VisitSpecialized(Map* map, HeapObject* object) {
     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<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>
+  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());
+    BodyDescriptor::template IteratePointers(
+        object, BodyDescriptor::kStartOffset, object_size, v);
     return static_cast<ReturnType>(object_size);
   }
 };
 
 
 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);
+  }
+};
+
+
 // Base class for visitors used for a linear new space iteration.
 // IterateBody returns size of visited object.
 // Certain types of objects (i.e. Code objects) are not handled
 // by dispatch table of this visitor because they cannot appear
 // in the new space.
 //
 // This class is intended to be used in the following way:
 //
 //   class SomeVisitor : public StaticNewSpaceVisitor<SomeVisitor> {
 //     ...
@@ skipping 55 matching lines @@
 
   INLINE(static int VisitFreeSpace(Map* map, HeapObject* object)) {
     return FreeSpace::cast(object)->size();
   }
 
   INLINE(static int VisitJSArrayBuffer(Map* map, HeapObject* object));
   INLINE(static int VisitJSTypedArray(Map* map, HeapObject* object));
   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;
 
   typedef FlexibleBodyVisitor<StaticVisitor, JSObject::BodyDescriptor, int>
       JSObjectVisitor;
 
   typedef int (*Callback)(Map* map, HeapObject* object);
 
   static VisitorDispatchTable<Callback> table_;
@@ skipping 74 matching lines @@
   INLINE(static bool IsFlushable(Heap* heap, JSFunction* function));
   INLINE(static bool IsFlushable(Heap* heap, SharedFunctionInfo* shared_info));
 
   // Helpers used by code flushing support that visit pointer fields and treat
   // references to code objects either strongly or weakly.
   static void VisitSharedFunctionInfoStrongCode(Heap* heap, HeapObject* object);
   static void VisitSharedFunctionInfoWeakCode(Heap* heap, HeapObject* object);
   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;
 
   typedef FlexibleBodyVisitor<StaticVisitor, JSObject::BodyDescriptor, void>
       JSObjectVisitor;
 
   typedef FlexibleBodyVisitor<StaticVisitor, StructBodyDescriptor, void>
       StructObjectVisitor;
 
@@ skipping 15 matching lines @@
 // the next element. Given the head of the list, this function removes dead
 // elements from the list and if requested records slots for next-element
 // pointers. The template parameter T is a WeakListVisitor that defines how to
 // access the next-element pointers.
 template <class T>
 Object* VisitWeakList(Heap* heap, Object* list, WeakObjectRetainer* retainer);
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_OBJECTS_VISITING_H_