Revert "Use WeakCells in the optimized code map rather than traversing in pause."

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 424 matching lines @@
     shared->ResetForNewContext(heap->global_ic_age());
   }
   if (FLAG_cleanup_code_caches_at_gc) {
     shared->ClearTypeFeedbackInfoAtGCTime();
   }
   if (FLAG_flush_optimized_code_cache) {
     if (!shared->OptimizedCodeMapIsCleared()) {
       // Always flush the optimized code map if requested by flag.
       shared->ClearOptimizedCodeMap();
     }
+  } else {
+    if (!shared->OptimizedCodeMapIsCleared()) {
+      // Treat some references within the code map weakly by marking the
+      // code map itself but not pushing it onto the marking deque. The
+      // map will be processed after marking.
+      FixedArray* code_map = shared->optimized_code_map();
+      MarkOptimizedCodeMap(heap, code_map);
+    }
   }
   MarkCompactCollector* collector = heap->mark_compact_collector();
   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.
@@ skipping 119 matching lines @@
   }
 
   int num_transitions = TransitionArray::NumberOfTransitions(transitions);
   for (int i = 0; i < num_transitions; ++i) {
     StaticVisitor::VisitPointer(heap, transitions, transitions->GetKeySlot(i));
   }
 }
 
 
 template <typename StaticVisitor>
+void StaticMarkingVisitor<StaticVisitor>::MarkOptimizedCodeMap(
+    Heap* heap, FixedArray* code_map) {
+  if (!StaticVisitor::MarkObjectWithoutPush(heap, code_map)) return;
+
+  // Mark the context-independent entry in the optimized code map. Depending on
+  // the age of the code object, we treat it as a strong or a weak reference.
+  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();
@@ skipping 154 matching lines @@
   typedef FlexibleBodyVisitor<StaticVisitor, JSFunction::BodyDescriptorWeakCode,
                               void> JSFunctionWeakCodeBodyVisitor;
   JSFunctionWeakCodeBodyVisitor::Visit(map, object);
 }
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_OBJECTS_VISITING_INL_H_