[heap] Separate out optimized code map processing.

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 425 matching lines @@
 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()) {
     shared->ResetForNewContext(heap->global_ic_age());
   }
   if (FLAG_cleanup_code_caches_at_gc) {
     shared->ClearTypeFeedbackInfoAtGCTime();
   }
-  if ((FLAG_flush_optimized_code_cache ||
-       heap->isolate()->serializer_enabled()) &&
-      !shared->optimized_code_map()->IsSmi()) {
-    // Always flush the optimized code map if requested by flag.
-    shared->ClearOptimizedCodeMap();
+  if (FLAG_flush_optimized_code_cache ||
+      heap->isolate()->serializer_enabled()) {
+    if (!shared->optimized_code_map()->IsSmi()) {
+      // Always flush the optimized code map if requested by flag.
+      shared->ClearOptimizedCodeMap();
+    }
+  } else {
+    if (!shared->optimized_code_map()->IsSmi()) {
+      // 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 = FixedArray::cast(shared->optimized_code_map());
+      MarkOptimizedCodeMap(heap, code_map);

[ulan, 2015/11/05 13:23:17]

Not related to the CL: there is a potential memory leak here if the code map is
updated during incremental marking.

[Michael Starzinger, 2015/11/05 13:51:03]

Acknowledged. As discussed offline: Yes, you are absolutely right. An entry in
the optimized code map could be updated (i.e. code field changed from undefined
to code), which would cause the optimized code map to transition from black to
gray. That would make all entries strong for the current cycle. The only true
solution to this is to migrate towards weak cells eventually. I am all in favor
of doing that at some point.

+    }
   }
   MarkCompactCollector* collector = heap->mark_compact_collector();
   if (collector->is_code_flushing_enabled()) {
-    if (!shared->optimized_code_map()->IsSmi()) {
-      // Add the shared function info holding an optimized code map to
-      // the code flusher for processing of code maps after marking.
-      collector->code_flusher()->AddOptimizedCodeMap(shared);
-      // Treat some references within the code map weakly by marking the
-      // code map itself but not pushing it onto the marking deque.
-      FixedArray* code_map = FixedArray::cast(shared->optimized_code_map());
-      MarkOptimizedCodeMap(heap, code_map);
-    }
     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(heap, object);
       return;
     }
   } else {
+    // TODO(mstarzinger): Drop this case, it shouldn't be done here!
     if (!shared->optimized_code_map()->IsSmi()) {
       // Flush optimized code map on major GCs without code flushing,
       // needed because cached code doesn't contain breakpoints.
       shared->ClearOptimizedCodeMap();
     }
   }
   VisitSharedFunctionInfoStrongCode(heap, object);
 }
 
 
@@ skipping 412 matching lines @@
 
   RelocIterator it(this, mode_mask);
   for (; !it.done(); it.next()) {
     it.rinfo()->template Visit<StaticVisitor>(heap);
   }
 }
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_OBJECTS_VISITING_INL_H_