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

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 233 matching lines @@
 
   INLINE(static int IterateBody(Map* map, HeapObject* obj)) {
     return table_.GetVisitor(map)(map, obj);
   }
 
   INLINE(static void VisitPointers(Heap* heap, HeapObject* object,
                                    Object** start, Object** end)) {
     for (Object** p = start; p < end; p++) StaticVisitor::VisitPointer(heap, p);
   }
 
- private:
-  INLINE(static int VisitJSFunction(Map* map, HeapObject* object)) {
-    Heap* heap = map->GetHeap();
-    VisitPointers(heap, object,
-                  HeapObject::RawField(object, JSFunction::kPropertiesOffset),
-                  HeapObject::RawField(object, JSFunction::kCodeEntryOffset));
-
-    // Don't visit code entry. We are using this visitor only during scavenges.
-
-    VisitPointers(
-        heap, object, HeapObject::RawField(
-                          object, JSFunction::kCodeEntryOffset + kPointerSize),
-        HeapObject::RawField(object, JSFunction::kNonWeakFieldsEndOffset));
-    return JSFunction::kSize;
+  // Although we are using the JSFunction body descriptor which does not
+  // visit the code entry, compiler wants it to be accessible, therefore public.

[Michael Starzinger, 2015/11/10 10:40:32]

nit: Let's drop the "therefore public" part of the sentence. The weird thing is
not the method being public, it's that the method needs to exist in the first
place. The VisitCodeEntry is always public.

[Igor Sheludko, 2015/11/10 10:58:11]

Done.

+  // See JSFunction::BodyDescriptorImpl.
+  INLINE(static void VisitCodeEntry(Heap* heap, HeapObject* object,
+                                    Address entry_address)) {
+    UNREACHABLE();
   }
 
+ private:
   INLINE(static int VisitByteArray(Map* map, HeapObject* object)) {
     return reinterpret_cast<ByteArray*>(object)->ByteArraySize();
   }
 
   INLINE(static int VisitFixedDoubleArray(Map* map, HeapObject* object)) {
     int length = reinterpret_cast<FixedDoubleArray*>(object)->length();
     return FixedDoubleArray::SizeFor(length);
   }
 
   INLINE(static int VisitFixedTypedArray(Map* map, HeapObject* object)) {
@@ skipping 118 matching lines @@
   static void MarkOptimizedCodeMap(Heap* heap, FixedArray* code_map);
 
   // Code flushing support.
   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(Heap* heap, HeapObject* object);

[Michael Starzinger, 2015/11/10 10:40:32]

Can we keep these two methods for readability and make them just dispatch to the
BodyDescriptor in question? Basically one-line delegate functions.

[Igor Sheludko, 2015/11/10 10:58:11]

Done.

-  static void VisitJSFunctionWeakCode(Heap* heap, 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 FlexibleBodyVisitor<StaticVisitor, FixedArray::BodyDescriptor, void>
@@ skipping 23 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_