Avoid manual object's body traversal in GC.

src/objects-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.
 //
 // Review notes:
 //
 // - The use of macros in these inline functions may seem superfluous
 // but it is absolutely needed to make sure gcc generates optimal
 // code. gcc is not happy when attempting to inline too deep.
 //
@@ skipping 6666 matching lines @@
 
 
 bool JSArrayBuffer::is_shared() { return IsShared::decode(bit_field()); }
 
 
 void JSArrayBuffer::set_is_shared(bool value) {
   set_bit_field(IsShared::update(bit_field(), value));
 }
 
 
-// static
-template <typename StaticVisitor>
-void JSArrayBuffer::JSArrayBufferIterateBody(Heap* heap, HeapObject* obj) {
-  StaticVisitor::VisitPointers(
-      heap, obj,
-      HeapObject::RawField(obj, JSArrayBuffer::BodyDescriptor::kStartOffset),
-      HeapObject::RawField(obj,
-                           JSArrayBuffer::kByteLengthOffset + kPointerSize));
-  StaticVisitor::VisitPointers(
-      heap, obj, HeapObject::RawField(obj, JSArrayBuffer::kSize),
-      HeapObject::RawField(obj, JSArrayBuffer::kSizeWithInternalFields));
-}
-
-
-void JSArrayBuffer::JSArrayBufferIterateBody(HeapObject* obj,
-                                             ObjectVisitor* v) {
-  v->VisitPointers(
-      HeapObject::RawField(obj, JSArrayBuffer::BodyDescriptor::kStartOffset),
-      HeapObject::RawField(obj,
-                           JSArrayBuffer::kByteLengthOffset + kPointerSize));
-  v->VisitPointers(
-      HeapObject::RawField(obj, JSArrayBuffer::kSize),
-      HeapObject::RawField(obj, JSArrayBuffer::kSizeWithInternalFields));
-}
-
-
 Object* JSArrayBufferView::byte_offset() const {
   if (WasNeutered()) return Smi::FromInt(0);
   return Object::cast(READ_FIELD(this, kByteOffsetOffset));
 }
 
 
 void JSArrayBufferView::set_byte_offset(Object* value, WriteBarrierMode mode) {
   WRITE_FIELD(this, kByteOffsetOffset, value);
   CONDITIONAL_WRITE_BARRIER(GetHeap(), this, kByteOffsetOffset, value, mode);
 }
@@ skipping 1138 matching lines @@
 }
 
 
 template<typename StaticVisitor>
 void Foreign::ForeignIterateBody() {
   StaticVisitor::VisitExternalReference(
       reinterpret_cast<Address*>(FIELD_ADDR(this, kForeignAddressOffset)));
 }
 
 
-void FixedTypedArrayBase::FixedTypedArrayBaseIterateBody(ObjectVisitor* v) {
-  v->VisitPointer(
-      reinterpret_cast<Object**>(FIELD_ADDR(this, kBasePointerOffset)));
-}
-
-
-template <typename StaticVisitor>
-void FixedTypedArrayBase::FixedTypedArrayBaseIterateBody() {
-  StaticVisitor::VisitPointer(
-      reinterpret_cast<Object**>(FIELD_ADDR(this, kBasePointerOffset)));
-}
-
-
 void ExternalOneByteString::ExternalOneByteStringIterateBody(ObjectVisitor* v) {
   typedef v8::String::ExternalOneByteStringResource Resource;
   v->VisitExternalOneByteString(
       reinterpret_cast<Resource**>(FIELD_ADDR(this, kResourceOffset)));
 }
 
 
 template <typename StaticVisitor>
 void ExternalOneByteString::ExternalOneByteStringIterateBody() {
   typedef v8::String::ExternalOneByteStringResource Resource;
@@ skipping 10 matching lines @@
 
 
 template<typename StaticVisitor>
 void ExternalTwoByteString::ExternalTwoByteStringIterateBody() {
   typedef v8::String::ExternalStringResource Resource;
   StaticVisitor::VisitExternalTwoByteString(
       reinterpret_cast<Resource**>(FIELD_ADDR(this, kResourceOffset)));
 }
 
 
+template <typename ObjectVisitor>
 void BodyDescriptorBase::IterateBodyImpl(HeapObject* obj, int start_offset,
                                          int end_offset, ObjectVisitor* v) {
   if (!FLAG_unbox_double_fields || obj->map()->HasFastPointerLayout()) {
     IteratePointers(obj, start_offset, end_offset, v);
   } else {
     DCHECK(FLAG_unbox_double_fields);
     DCHECK(IsAligned(start_offset, kPointerSize) &&
            IsAligned(end_offset, kPointerSize));
 
     LayoutDescriptorHelper helper(obj->map());
@@ skipping 25 matching lines @@
       int end_of_region_offset;
       if (helper.IsTagged(offset, end_offset, &end_of_region_offset)) {
         IteratePointers<StaticVisitor>(heap, obj, offset, end_of_region_offset);
       }
       offset = end_of_region_offset;
     }
   }
 }
 
 
+template <typename ObjectVisitor>
 void BodyDescriptorBase::IteratePointers(HeapObject* obj, int start_offset,
                                          int end_offset, ObjectVisitor* v) {
   v->VisitPointers(HeapObject::RawField(obj, start_offset),
                    HeapObject::RawField(obj, end_offset));
 }
 
 
 template <typename StaticVisitor>
 void BodyDescriptorBase::IteratePointers(Heap* heap, HeapObject* obj,
                                          int start_offset, int end_offset) {
   StaticVisitor::VisitPointers(heap, obj,
                                HeapObject::RawField(obj, start_offset),
                                HeapObject::RawField(obj, end_offset));
 }
 
 
+template <typename ObjectVisitor>
+void BodyDescriptorBase::IteratePointer(HeapObject* obj, int offset,
+                                        ObjectVisitor* v) {
+  v->VisitPointer(HeapObject::RawField(obj, offset));
+}
+
+
+template <typename StaticVisitor>
+void BodyDescriptorBase::IteratePointer(Heap* heap, HeapObject* obj,
+                                        int offset) {
+  StaticVisitor::VisitPointer(heap, obj, HeapObject::RawField(obj, offset));
+}
+
+
 // Iterates the function object according to the visiting policy.
 template <JSFunction::BodyVisitingPolicy body_visiting_policy>
 class JSFunction::BodyDescriptorImpl : public BodyDescriptorBase {
  public:
   STATIC_ASSERT(kNonWeakFieldsEndOffset == kCodeEntryOffset);
   STATIC_ASSERT(kCodeEntryOffset + kPointerSize == kNextFunctionLinkOffset);
   STATIC_ASSERT(kNextFunctionLinkOffset + kPointerSize == kSize);
 
+  template <typename ObjectVisitor>
   static inline void IterateBody(HeapObject* obj, int object_size,
                                  ObjectVisitor* v) {
     IteratePointers(obj, kPropertiesOffset, kNonWeakFieldsEndOffset, v);
 
     if (body_visiting_policy & kVisitCodeEntry) {
       v->VisitCodeEntry(obj->address() + kCodeEntryOffset);
     }
 
     if (body_visiting_policy & kVisitNextFunction) {
       IteratePointers(obj, kNextFunctionLinkOffset, kSize, v);
@@ skipping 25 matching lines @@
   }
 
   static inline int SizeOf(Map* map, HeapObject* object) {
     // TODO(ishell): v8:4531, fix when JFunctions are allowed to have in-object
     // properties
     return JSFunction::kSize;
   }
 };
 
 
+class JSArrayBuffer::BodyDescriptor : public BodyDescriptorBase {
+ public:
+  STATIC_ASSERT(kByteLengthOffset + kPointerSize == kBackingStoreOffset);
+  STATIC_ASSERT(kBackingStoreOffset + kPointerSize == kBitFieldSlot);
+  STATIC_ASSERT(kBitFieldSlot + kPointerSize == kSize);
+
+  template <typename ObjectVisitor>
+  static inline void IterateBody(HeapObject* obj, int object_size,
+                                 ObjectVisitor* v) {
+    IteratePointers(obj, kPropertiesOffset, kBackingStoreOffset, v);
+    IteratePointers(obj, kSize, kSizeWithInternalFields, v);
+
+    // TODO(ishell): v8:4531, fix when JSArrayBuffers are allowed to have
+    // in-object properties
+    // IterateBodyImpl(obj, kSize, object_size, v);
+  }
+
+  template <typename StaticVisitor>
+  static inline void IterateBody(HeapObject* obj, int object_size) {
+    Heap* heap = obj->GetHeap();
+    IteratePointers<StaticVisitor>(heap, obj, kPropertiesOffset,
+                                   kBackingStoreOffset);
+    IteratePointers<StaticVisitor>(heap, obj, kSize, kSizeWithInternalFields);
+
+    // TODO(ishell): v8:4531, fix when JSArrayBuffers are allowed to have
+    // in-object properties
+    // IterateBodyImpl<StaticVisitor>(heap, obj, kSize, object_size);
+  }
+
+  static inline int SizeOf(Map* map, HeapObject* object) {
+    // TODO(ishell): v8:4531, fix when JSArrayBuffers are allowed to have
+    // in-object properties
+    // return map->instance_size();
+    return kSizeWithInternalFields;
+  }
+};
+
+
+class BytecodeArray::BodyDescriptor : public BodyDescriptorBase {
+ public:
+  template <typename ObjectVisitor>
+  static inline void IterateBody(HeapObject* obj, int object_size,
+                                 ObjectVisitor* v) {
+    IteratePointer(obj, kConstantPoolOffset, v);
+  }
+
+  template <typename StaticVisitor>
+  static inline void IterateBody(HeapObject* obj, int object_size) {
+    Heap* heap = obj->GetHeap();
+    IteratePointer<StaticVisitor>(heap, obj, kConstantPoolOffset);
+  }
+
+  static inline int SizeOf(Map* map, HeapObject* object) {
+    return SizeFor(
+        reinterpret_cast<FixedArray*>(object)->synchronized_length());
+  }
+};
+
+
+class FixedTypedArrayBase::BodyDescriptor : public BodyDescriptorBase {
+ public:
+  template <typename ObjectVisitor>
+  static inline void IterateBody(HeapObject* obj, int object_size,
+                                 ObjectVisitor* v) {
+    IteratePointer(obj, kBasePointerOffset, v);
+  }
+
+  template <typename StaticVisitor>
+  static inline void IterateBody(HeapObject* obj, int object_size) {
+    Heap* heap = obj->GetHeap();
+    IteratePointer<StaticVisitor>(heap, obj, kBasePointerOffset);
+  }
+
+  static inline int SizeOf(Map* map, HeapObject* object) {
+    return reinterpret_cast<FixedTypedArrayBase*>(object)->size();
+  }
+};
+
+
+class JSWeakCollection::BodyDescriptor : public BodyDescriptorBase {
+ public:
+  template <typename ObjectVisitor>
+  static inline void IterateBody(HeapObject* obj, int object_size,
+                                 ObjectVisitor* v) {
+    IteratePointers(obj, kPropertiesOffset, kSize, v);
+
+    // TODO(ishell): v8:4531, fix when JSWeakCollection are allowed to have
+    // in-object properties
+    // IterateBodyImpl(obj, kSize, object_size, v);
+  }
+
+  template <typename StaticVisitor>
+  static inline void IterateBody(HeapObject* obj, int object_size) {
+    Heap* heap = obj->GetHeap();
+    IteratePointers<StaticVisitor>(heap, obj, kPropertiesOffset, kSize);
+
+    // TODO(ishell): v8:4531, fix when JSWeakCollection are allowed to have
+    // in-object properties
+    // IterateBodyImpl<StaticVisitor>(heap, obj, kSize, object_size);
+  }
+
+  static inline int SizeOf(Map* map, HeapObject* object) { return kSize; }
+};
+
+
 template<class Derived, class TableType>
 Object* OrderedHashTableIterator<Derived, TableType>::CurrentKey() {
   TableType* table(TableType::cast(this->table()));
   int index = Smi::cast(this->index())->value();
   Object* key = table->KeyAt(index);
   DCHECK(!key->IsTheHole());
   return key;
 }
 
 
@@ skipping 113 matching lines @@
 #undef WRITE_INT64_FIELD
 #undef READ_BYTE_FIELD
 #undef WRITE_BYTE_FIELD
 #undef NOBARRIER_READ_BYTE_FIELD
 #undef NOBARRIER_WRITE_BYTE_FIELD
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_OBJECTS_INL_H_