Make JSFunction::BodyDescriptor the only single place that knows how to iterate JSFunction's body.

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 7894 matching lines @@
 void ExternalTwoByteString::ExternalTwoByteStringIterateBody() {
   typedef v8::String::ExternalStringResource Resource;
   StaticVisitor::VisitExternalTwoByteString(
       reinterpret_cast<Resource**>(FIELD_ADDR(this, kResourceOffset)));
 }
 
 
 void BodyDescriptorBase::IterateBodyImpl(HeapObject* obj, int start_offset,
                                          int end_offset, ObjectVisitor* v) {
   if (!FLAG_unbox_double_fields || obj->map()->HasFastPointerLayout()) {
-    v->VisitPointers(HeapObject::RawField(obj, start_offset),
-                     HeapObject::RawField(obj, end_offset));
+    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());
     DCHECK(!helper.all_fields_tagged());
     for (int offset = start_offset; offset < end_offset;) {
       int end_of_region_offset;
       if (helper.IsTagged(offset, end_offset, &end_of_region_offset)) {
-        v->VisitPointers(HeapObject::RawField(obj, offset),
-                         HeapObject::RawField(obj, end_of_region_offset));
+        IteratePointers(obj, offset, end_of_region_offset, v);
       }
       offset = end_of_region_offset;
     }
   }
 }
 
 
 template <typename StaticVisitor>
-void BodyDescriptorBase::IterateBodyImpl(HeapObject* obj, int start_offset,
-                                         int end_offset) {
-  Heap* heap = obj->GetHeap();
+void BodyDescriptorBase::IterateBodyImpl(Heap* heap, HeapObject* obj,
+                                         int start_offset, int end_offset) {
   if (!FLAG_unbox_double_fields || obj->map()->HasFastPointerLayout()) {
-    StaticVisitor::VisitPointers(heap, obj,
-                                 HeapObject::RawField(obj, start_offset),
-                                 HeapObject::RawField(obj, end_offset));
+    IteratePointers<StaticVisitor>(heap, obj, start_offset, end_offset);
   } else {
     DCHECK(FLAG_unbox_double_fields);
     DCHECK(IsAligned(start_offset, kPointerSize) &&
            IsAligned(end_offset, kPointerSize));
 
     LayoutDescriptorHelper helper(obj->map());
     DCHECK(!helper.all_fields_tagged());
     for (int offset = start_offset; offset < end_offset;) {
       int end_of_region_offset;
       if (helper.IsTagged(offset, end_offset, &end_of_region_offset)) {
-        StaticVisitor::VisitPointers(
-            heap, obj, HeapObject::RawField(obj, offset),
-            HeapObject::RawField(obj, end_of_region_offset));
+        IteratePointers<StaticVisitor>(heap, obj, offset, end_of_region_offset);
       }
       offset = end_of_region_offset;
     }
   }
 }
 
 
+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));
+}
+
+
+// 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);
+
+  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);
+    }
+
+    // TODO(ishell): v8:4531, fix when JFunctions 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,
+                                   kNonWeakFieldsEndOffset);
+
+    if (body_visiting_policy & kVisitCodeEntry) {
+      StaticVisitor::VisitCodeEntry(heap, obj,
+                                    obj->address() + kCodeEntryOffset);
+    }
+
+    if (body_visiting_policy & kVisitNextFunction) {
+      IteratePointers<StaticVisitor>(heap, obj, kNextFunctionLinkOffset, kSize);
+    }
+
+    // TODO(ishell): v8:4531, fix when JFunctions 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 JFunctions are allowed to have in-object
+    // properties
+    return JSFunction::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_