[heap] Make link from optimized code to inlined code explicit.

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 397 matching lines @@
 template <typename StaticVisitor>
 void StaticMarkingVisitor<StaticVisitor>::VisitCode(Map* map,
                                                     HeapObject* object) {
   typedef FlexibleBodyVisitor<StaticVisitor, Code::BodyDescriptor, void>
       CodeBodyVisitor;
   Heap* heap = map->GetHeap();
   Code* code = Code::cast(object);
   if (FLAG_age_code && !heap->isolate()->serializer_enabled()) {
     code->MakeOlder(heap->mark_compact_collector()->marking_parity());
   }
-  MarkCompactCollector* collector = heap->mark_compact_collector();
-  if (collector->is_code_flushing_enabled()) {
-    if (code->kind() == Code::OPTIMIZED_FUNCTION) {
-      // Visit all unoptimized code objects to prevent flushing them.
-      MarkInlinedFunctionsCode(heap, code);
-    }
-  }
   CodeBodyVisitor::Visit(map, object);
 }
 
 
 template <typename StaticVisitor>
 void StaticMarkingVisitor<StaticVisitor>::VisitSharedFunctionInfo(
     Map* map, HeapObject* object) {
   Heap* heap = map->GetHeap();
   SharedFunctionInfo* shared = SharedFunctionInfo::cast(object);
   if (shared->ic_age() != heap->global_ic_age()) {
@@ skipping 163 matching lines @@
   Object* shared_object = code_map->get(SharedFunctionInfo::kSharedCodeIndex);
   if (FLAG_turbo_preserve_shared_code && shared_object->IsCode() &&
       FLAG_age_code && !Code::cast(shared_object)->IsOld()) {
     StaticVisitor::VisitPointer(
         heap, code_map,
         code_map->RawFieldOfElementAt(SharedFunctionInfo::kSharedCodeIndex));
   }
 }
 
 
-template <typename StaticVisitor>
-void StaticMarkingVisitor<StaticVisitor>::MarkInlinedFunctionsCode(Heap* heap,
-                                                                   Code* code) {
-  // For optimized functions we should retain both non-optimized version
-  // of its code and non-optimized version of all inlined functions.
-  // This is required to support bailing out from inlined code.
-  if (code->deoptimization_data() != heap->empty_fixed_array()) {
-    DeoptimizationInputData* const data =
-        DeoptimizationInputData::cast(code->deoptimization_data());
-    FixedArray* const literals = data->LiteralArray();
-    int const inlined_count = data->InlinedFunctionCount()->value();
-    for (int i = 0; i < inlined_count; ++i) {
-      StaticVisitor::MarkObject(
-          heap, SharedFunctionInfo::cast(literals->get(i))->code());
-    }
-  }
-}
-
-
 inline static bool HasSourceCode(Heap* heap, SharedFunctionInfo* info) {
   Object* undefined = heap->undefined_value();
   return (info->script() != undefined) &&
          (reinterpret_cast<Script*>(info->script())->source() != undefined);
 }
 
 
 template <typename StaticVisitor>
 bool StaticMarkingVisitor<StaticVisitor>::IsFlushable(Heap* heap,
                                                       JSFunction* function) {
@@ skipping 136 matching lines @@
   typedef FlexibleBodyVisitor<StaticVisitor, JSFunction::BodyDescriptorWeakCode,
                               void> JSFunctionWeakCodeBodyVisitor;
   JSFunctionWeakCodeBodyVisitor::Visit(map, object);
 }
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_OBJECTS_VISITING_INL_H_