[turbofan] Support preserving of optimized code maps over GCs.

src/heap/mark-compact.cc

 // 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.
 
 #include "src/v8.h"
 
 #include "src/base/atomicops.h"
 #include "src/base/bits.h"
 #include "src/code-stubs.h"
 #include "src/compilation-cache.h"
@@ skipping 850 matching lines @@
     SharedFunctionInfo* shared = candidate->shared();
 
     Code* code = shared->code();
     MarkBit code_mark = Marking::MarkBitFrom(code);
     if (Marking::IsWhite(code_mark)) {
       if (FLAG_trace_code_flushing && shared->is_compiled()) {
         PrintF("[code-flushing clears: ");
         shared->ShortPrint();
         PrintF(" - age: %d]\n", code->GetAge());
       }
-      // Always flush the optimized code map if requested by flag.
-      if (FLAG_flush_optimized_code_cache &&
-          !shared->optimized_code_map()->IsSmi()) {
+      // Always flush the optimized code map if there is one.
+      if (!shared->optimized_code_map()->IsSmi()) {
         shared->ClearOptimizedCodeMap();
       }
       shared->set_code(lazy_compile);
       candidate->set_code(lazy_compile);
     } else {
       DCHECK(Marking::IsBlack(code_mark));
       candidate->set_code(code);
     }
 
     // We are in the middle of a GC cycle so the write barrier in the code
@@ skipping 25 matching lines @@
     ClearNextCandidate(candidate);
 
     Code* code = candidate->code();
     MarkBit code_mark = Marking::MarkBitFrom(code);
     if (Marking::IsWhite(code_mark)) {
       if (FLAG_trace_code_flushing && candidate->is_compiled()) {
         PrintF("[code-flushing clears: ");
         candidate->ShortPrint();
         PrintF(" - age: %d]\n", code->GetAge());
       }
-      // Always flush the optimized code map if requested by flag.
-      if (FLAG_flush_optimized_code_cache &&
-          !candidate->optimized_code_map()->IsSmi()) {
+      // Always flush the optimized code map if there is one.
+      if (!candidate->optimized_code_map()->IsSmi()) {
         candidate->ClearOptimizedCodeMap();
       }
       candidate->set_code(lazy_compile);
     }
 
     Object** code_slot =
         HeapObject::RawField(candidate, SharedFunctionInfo::kCodeOffset);
     isolate_->heap()->mark_compact_collector()->RecordSlot(code_slot, code_slot,
                                                            *code_slot);
 
     candidate = next_candidate;
   }
 
   shared_function_info_candidates_head_ = NULL;
 }
 
 
 void CodeFlusher::ProcessOptimizedCodeMaps() {
   STATIC_ASSERT(SharedFunctionInfo::kEntryLength == 4);
 
   SharedFunctionInfo* holder = optimized_code_map_holder_head_;
   SharedFunctionInfo* next_holder;
 
   while (holder != NULL) {
     next_holder = GetNextCodeMap(holder);
     ClearNextCodeMap(holder);
 
+    // Process context-dependent entries in the optimized code map.
     FixedArray* code_map = FixedArray::cast(holder->optimized_code_map());
     int new_length = SharedFunctionInfo::kEntriesStart;
     int old_length = code_map->length();
     for (int i = SharedFunctionInfo::kEntriesStart; i < old_length;
          i += SharedFunctionInfo::kEntryLength) {
       Code* code =
           Code::cast(code_map->get(i + SharedFunctionInfo::kCachedCodeOffset));
       if (Marking::IsWhite(Marking::MarkBitFrom(code))) continue;
       DCHECK(Marking::IsBlack(Marking::MarkBitFrom(code)));
       // Move every slot in the entry.
       for (int j = 0; j < SharedFunctionInfo::kEntryLength; j++) {
         int dst_index = new_length++;
         Object** slot = code_map->RawFieldOfElementAt(dst_index);
         Object* object = code_map->get(i + j);
         code_map->set(dst_index, object);
         if (j == SharedFunctionInfo::kOsrAstIdOffset) {
           DCHECK(object->IsSmi());
         } else {
           DCHECK(
               Marking::IsBlack(Marking::MarkBitFrom(HeapObject::cast(*slot))));
           isolate_->heap()->mark_compact_collector()->RecordSlot(slot, slot,
                                                                  *slot);
         }
       }
     }
 
+    // Process context-independent entry in the optimized code map.
+    Object* shared_object = code_map->get(SharedFunctionInfo::kSharedCodeIndex);
+    if (shared_object->IsCode()) {
+      Code* shared_code = Code::cast(shared_object);
+      if (Marking::IsWhite(Marking::MarkBitFrom(shared_code))) {
+        code_map->set_undefined(SharedFunctionInfo::kSharedCodeIndex);
+      } else {
+        DCHECK(Marking::IsBlack(Marking::MarkBitFrom(shared_code)));
+        Object** slot =
+            code_map->RawFieldOfElementAt(SharedFunctionInfo::kSharedCodeIndex);
+        isolate_->heap()->mark_compact_collector()->RecordSlot(slot, slot,
+                                                               *slot);
+      }
+    }
+
     // Trim the optimized code map if entries have been removed.
     if (new_length < old_length) {
       holder->TrimOptimizedCodeMap(old_length - new_length);
     }
 
     holder = next_holder;
   }
 
   optimized_code_map_holder_head_ = NULL;
 }
@@ skipping 3639 matching lines @@
   SlotsBuffer* buffer = *buffer_address;
   while (buffer != NULL) {
     SlotsBuffer* next_buffer = buffer->next();
     DeallocateBuffer(buffer);
     buffer = next_buffer;
   }
   *buffer_address = NULL;
 }
 }  // namespace internal
 }  // namespace v8