Record code slots that may point to evacuation candidate objects after deoptimizing them.

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 3233 matching lines @@
     Page* p = evacuation_candidates_[i];
     DCHECK(p->IsEvacuationCandidate() ||
            p->IsFlagSet(Page::RESCAN_ON_EVACUATION));
     if (p->IsEvacuationCandidate()) {
       SlotsBuffer::RemoveObjectSlots(heap_, p->slots_buffer(), invalid_object);
     }
   }
 }
 
 
+void MarkCompactCollector::RecordDeoptimizedCodeSlots(Code* code) {
+  Object** reloc_info_slot = Code::RawField(code, Code::kRelocationInfoOffset);
+  RecordSlot(reloc_info_slot, reloc_info_slot, *reloc_info_slot);
+  Object** handler_table_slot = Code::RawField(code, Code::kHandlerTableOffset);
+  RecordSlot(handler_table_slot, handler_table_slot, *handler_table_slot);
+  Object** deopt_data_slot =
+      Code::RawField(code, Code::kDeoptimizationDataOffset);
+  RecordSlot(deopt_data_slot, deopt_data_slot, *deopt_data_slot);
+  Object** type_feedback_slot =
+      Code::RawField(code, Code::kTypeFeedbackInfoOffset);
+  RecordSlot(type_feedback_slot, type_feedback_slot, *type_feedback_slot);
+  Object** next_code_slot = Code::RawField(code, Code::kNextCodeLinkOffset);
+  RecordSlot(next_code_slot, next_code_slot, *next_code_slot);
+  Object** meta_data_slot = Code::RawField(code, Code::kGCMetadataOffset);
+  RecordSlot(meta_data_slot, meta_data_slot, *meta_data_slot);
+  Object** constant_pool_slot = Code::RawField(code, Code::kConstantPoolOffset);
+  RecordSlot(constant_pool_slot, constant_pool_slot, *constant_pool_slot);
+}
+
+
 void MarkCompactCollector::EvacuateNewSpace() {
   // There are soft limits in the allocation code, designed trigger a mark
   // sweep collection by failing allocations.  But since we are already in
   // a mark-sweep allocation, there is no sense in trying to trigger one.
   AlwaysAllocateScope scope(isolate());
 
   NewSpace* new_space = heap()->new_space();
 
   // Store allocation range before flipping semispaces.
   Address from_bottom = new_space->bottom();
@@ skipping 1431 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