[heap] Introduce HeapVisitor interface.

src/objects-body-descriptors-inl.h

 // Copyright 2015 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_BODY_DESCRIPTORS_INL_H_
 #define V8_OBJECTS_BODY_DESCRIPTORS_INL_H_
 
 #include "src/assembler-inl.h"
 #include "src/objects-body-descriptors.h"
 #include "src/transitions.h"
@@ skipping 221 matching lines @@
     IteratePointers<StaticVisitor>(heap, obj, kPropertiesOffset,
                                    kBackingStoreOffset);
     IterateBodyImpl<StaticVisitor>(heap, obj, kSize, object_size);
   }
 
   static inline int SizeOf(Map* map, HeapObject* object) {
     return map->instance_size();
   }
 };
 
+class ByteArray::BodyDescriptor final : public BodyDescriptorBase {
+ public:
+  static bool IsValidSlot(HeapObject* obj, int offset) { return false; }
+
+  template <typename ObjectVisitor>
+  static inline void IterateBody(HeapObject* obj, int object_size,
+                                 ObjectVisitor* v) {}
+
+  template <typename StaticVisitor>
+  static inline void IterateBody(HeapObject* obj, int object_size) {}
+
+  static inline int SizeOf(Map* map, HeapObject* obj) {
+    return reinterpret_cast<ByteArray*>(obj)->ByteArraySize();
+  }
+};
+
 class BytecodeArray::BodyDescriptor final : public BodyDescriptorBase {
  public:
   static bool IsValidSlot(HeapObject* obj, int offset) {
     return offset >= kConstantPoolOffset &&
            offset <= kSourcePositionTableOffset;
   }
 
   template <typename ObjectVisitor>
   static inline void IterateBody(HeapObject* obj, int object_size,
                                  ObjectVisitor* v) {
     IteratePointer(obj, kConstantPoolOffset, v);
     IteratePointer(obj, kHandlerTableOffset, v);
     IteratePointer(obj, kSourcePositionTableOffset, v);
   }
 
   template <typename StaticVisitor>
   static inline void IterateBody(HeapObject* obj, int object_size) {
     Heap* heap = obj->GetHeap();
     IteratePointer<StaticVisitor>(heap, obj, kConstantPoolOffset);
     IteratePointer<StaticVisitor>(heap, obj, kHandlerTableOffset);
     IteratePointer<StaticVisitor>(heap, obj, kSourcePositionTableOffset);
   }
 
   static inline int SizeOf(Map* map, HeapObject* obj) {
     return reinterpret_cast<BytecodeArray*>(obj)->BytecodeArraySize();
   }
 };
 
+class FixedDoubleArray::BodyDescriptor final : public BodyDescriptorBase {
+ public:
+  static bool IsValidSlot(HeapObject* obj, int offset) { return false; }
+
+  template <typename ObjectVisitor>
+  static inline void IterateBody(HeapObject* obj, int object_size,
+                                 ObjectVisitor* v) {}
+
+  template <typename StaticVisitor>
+  static inline void IterateBody(HeapObject* obj, int object_size) {}
+
+  static inline int SizeOf(Map* map, HeapObject* obj) {
+    return FixedDoubleArray::SizeFor(
+        reinterpret_cast<FixedDoubleArray*>(obj)->length());
+  }
+};
+
 class FixedTypedArrayBase::BodyDescriptor final : public BodyDescriptorBase {
  public:
   static bool IsValidSlot(HeapObject* obj, int offset) {
     return offset == kBasePointerOffset;
   }
 
   template <typename ObjectVisitor>
   static inline void IterateBody(HeapObject* obj, int object_size,
                                  ObjectVisitor* v) {
     IteratePointer(obj, kBasePointerOffset, v);
@@ skipping 172 matching lines @@
   template <typename StaticVisitor>
   static inline void IterateBody(HeapObject* obj, int object_size) {
     IterateBody<StaticVisitor>(obj);
   }
 
   static inline int SizeOf(Map* map, HeapObject* object) {
     return reinterpret_cast<Code*>(object)->CodeSize();
   }
 };
 
+class SeqOneByteString::BodyDescriptor final : public BodyDescriptorBase {
+ public:
+  static bool IsValidSlot(HeapObject* obj, int offset) { return false; }
+
+  template <typename ObjectVisitor>
+  static inline void IterateBody(HeapObject* obj, int object_size,
+                                 ObjectVisitor* v) {}
+
+  template <typename StaticVisitor>
+  static inline void IterateBody(HeapObject* obj, int object_size) {}
+
+  static inline int SizeOf(Map* map, HeapObject* obj) {
+    SeqOneByteString* string = SeqOneByteString::cast(obj);
+    return string->SizeFor(string->length());
+  }
+};
+
+class SeqTwoByteString::BodyDescriptor final : public BodyDescriptorBase {
+ public:
+  static bool IsValidSlot(HeapObject* obj, int offset) { return false; }
+
+  template <typename ObjectVisitor>
+  static inline void IterateBody(HeapObject* obj, int object_size,
+                                 ObjectVisitor* v) {}
+
+  template <typename StaticVisitor>
+  static inline void IterateBody(HeapObject* obj, int object_size) {}
+
+  static inline int SizeOf(Map* map, HeapObject* obj) {
+    SeqTwoByteString* string = SeqTwoByteString::cast(obj);
+    return string->SizeFor(string->length());
+  }
+};
 
 template <typename Op, typename ReturnType, typename T1, typename T2,
           typename T3>
 ReturnType BodyDescriptorApply(InstanceType type, T1 p1, T2 p2, T3 p3) {
   if (type < FIRST_NONSTRING_TYPE) {
     switch (type & kStringRepresentationMask) {
       case kSeqStringTag:
         return ReturnType();
       case kConsStringTag:
         return Op::template apply<ConsString::BodyDescriptor>(p1, p2, p3);
@@ skipping 170 matching lines @@
 
 template <typename ObjectVisitor>
 void HeapObject::IterateBodyFast(InstanceType type, int object_size,
                                  ObjectVisitor* v) {
   BodyDescriptorApply<CallIterateBody, void>(type, this, object_size, v);
 }
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_OBJECTS_BODY_DESCRIPTORS_INL_H_