Revert of [heap] Simplify marking of JSFunction and SFI

src/heap/objects-visiting-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.
 
 #ifndef V8_OBJECTS_VISITING_INL_H_
 #define V8_OBJECTS_VISITING_INL_H_
 
 #include "src/heap/array-buffer-tracker.h"
 #include "src/heap/objects-visiting.h"
 #include "src/ic/ic-state.h"
@@ skipping 431 matching lines @@
   if (collector->is_code_flushing_enabled()) {
     if (IsFlushable(heap, shared)) {
       // This function's code looks flushable. But we have to postpone
       // the decision until we see all functions that point to the same
       // SharedFunctionInfo because some of them might be optimized.
       // That would also make the non-optimized version of the code
       // non-flushable, because it is required for bailing out from
       // optimized code.
       collector->code_flusher()->AddCandidate(shared);
       // Treat the reference to the code object weakly.
-      VisitSharedFunctionInfoWeakCode(map, object);
+      VisitSharedFunctionInfoWeakCode(heap, object);
       return;
     }
   }
-  VisitSharedFunctionInfoStrongCode(map, object);
+  VisitSharedFunctionInfoStrongCode(heap, object);
 }
 
 
 template <typename StaticVisitor>
 void StaticMarkingVisitor<StaticVisitor>::VisitJSFunction(Map* map,
                                                           HeapObject* object) {
   Heap* heap = map->GetHeap();
   JSFunction* function = JSFunction::cast(object);
   if (FLAG_cleanup_code_caches_at_gc) {
     function->ClearTypeFeedbackInfoAtGCTime();
@@ skipping 147 matching lines @@
   }
 
   // Check age of code. If code aging is disabled we never flush.
   if (!FLAG_age_code || !shared_info->code()->IsOld()) {
     return false;
   }
 
   return true;
 }
 
+
 template <typename StaticVisitor>
 void StaticMarkingVisitor<StaticVisitor>::VisitSharedFunctionInfoStrongCode(
-    Map* map, HeapObject* object) {
-  FixedBodyVisitor<StaticVisitor, SharedFunctionInfo::BodyDescriptor,
-                   void>::Visit(map, object);
+    Heap* heap, HeapObject* object) {
+  Object** start_slot = HeapObject::RawField(
+      object, SharedFunctionInfo::BodyDescriptor::kStartOffset);
+  Object** end_slot = HeapObject::RawField(
+      object, SharedFunctionInfo::BodyDescriptor::kEndOffset);
+  StaticVisitor::VisitPointers(heap, object, start_slot, end_slot);
 }
 
+
 template <typename StaticVisitor>
 void StaticMarkingVisitor<StaticVisitor>::VisitSharedFunctionInfoWeakCode(
-    Map* map, HeapObject* object) {
+    Heap* heap, HeapObject* object) {
+  Object** name_slot =
+      HeapObject::RawField(object, SharedFunctionInfo::kNameOffset);
+  StaticVisitor::VisitPointer(heap, object, name_slot);
+
   // Skip visiting kCodeOffset as it is treated weakly here.
-  STATIC_ASSERT(SharedFunctionInfo::kCodeOffset <
-                SharedFunctionInfo::BodyDescriptorWeakCode::kStartOffset);
-  FixedBodyVisitor<StaticVisitor, SharedFunctionInfo::BodyDescriptorWeakCode,
-                   void>::Visit(map, object);
+  STATIC_ASSERT(SharedFunctionInfo::kNameOffset + kPointerSize ==
+                SharedFunctionInfo::kCodeOffset);
+  STATIC_ASSERT(SharedFunctionInfo::kCodeOffset + kPointerSize ==
+                SharedFunctionInfo::kOptimizedCodeMapOffset);
+
+  Object** start_slot =
+      HeapObject::RawField(object, SharedFunctionInfo::kOptimizedCodeMapOffset);
+  Object** end_slot = HeapObject::RawField(
+      object, SharedFunctionInfo::BodyDescriptor::kEndOffset);
+  StaticVisitor::VisitPointers(heap, object, start_slot, end_slot);
 }
 
+
 template <typename StaticVisitor>
 void StaticMarkingVisitor<StaticVisitor>::VisitJSFunctionStrongCode(
     Map* map, HeapObject* object) {
   typedef FlexibleBodyVisitor<StaticVisitor,
                               JSFunction::BodyDescriptorStrongCode,
                               void> JSFunctionStrongCodeBodyVisitor;
   JSFunctionStrongCodeBodyVisitor::Visit(map, object);
 }
 
 
 template <typename StaticVisitor>
 void StaticMarkingVisitor<StaticVisitor>::VisitJSFunctionWeakCode(
     Map* map, HeapObject* object) {
   typedef FlexibleBodyVisitor<StaticVisitor, JSFunction::BodyDescriptorWeakCode,
                               void> JSFunctionWeakCodeBodyVisitor;
   JSFunctionWeakCodeBodyVisitor::Visit(map, object);
 }
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_OBJECTS_VISITING_INL_H_