Support slots recording for compaction during incremental marking.

src/heap.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 4286 matching lines @@
                                              Address end,
                                              ObjectSlotCallback callback) {
   Address slot_address = start;
   while (slot_address < end) {
     Object** slot = reinterpret_cast<Object**>(slot_address);
     Object* object = *slot;
     // If the store buffer becomes overfull we mark pages as being exempt from
     // the store buffer.  These pages are scanned to find pointers that point
     // to the new space.  In that case we may hit newly promoted objects and
     // fix the pointers before the promotion queue gets to them.  Thus the 'if'.
-    if (Heap::InFromSpace(object)) {
-      callback(reinterpret_cast<HeapObject**>(slot), HeapObject::cast(object));
-      if (InNewSpace(*slot)) {
-        ASSERT(Heap::InToSpace(*slot));
-        ASSERT((*slot)->IsHeapObject());
-        store_buffer_.EnterDirectlyIntoStoreBuffer(
-            reinterpret_cast<Address>(slot));
+    if (object->IsHeapObject()) {
+      if (Heap::InFromSpace(object)) {
+        callback(reinterpret_cast<HeapObject**>(slot),
+                 HeapObject::cast(object));
+        Object* new_object = *slot;
+        if (InNewSpace(new_object)) {
+          ASSERT(Heap::InToSpace(new_object));
+          ASSERT(new_object->IsHeapObject());
+          store_buffer_.EnterDirectlyIntoStoreBuffer(
+              reinterpret_cast<Address>(slot));
+        }
+        ASSERT(!MarkCompactCollector::IsOnEvacuationCandidate(new_object));
+      } else if (MarkCompactCollector::IsOnEvacuationCandidate(object)) {
+        mark_compact_collector()->RecordSlot(slot, slot, object);

[Erik Corry, 2011/07/04 11:04:11]

Does this happen?  The pointer can't suddenly start pointing into the evacuation
candidate unless we are allocating in the evacuation candidate while promoting
from new space.  It seems wrong to allocate in an evacuation candidate once we
have decided it is an evacuation candidate.

[Vyacheslav Egorov (Chromium), 2011/08/05 12:50:28]

This else if belongs to the first if. So yes this can happen. Added a comment.

       }
     }
     slot_address += kPointerSize;
   }
 }
 
 
 #ifdef DEBUG
 typedef bool (*CheckStoreBufferFilter)(Object** addr);
 
@@ skipping 1523 matching lines @@
   }
   isolate_->heap()->store_buffer()->Filter(MemoryChunk::ABOUT_TO_BE_FREED);
   for (chunk = chunks_queued_for_free_; chunk != NULL; chunk = next) {
     next = chunk->next_chunk();
     isolate_->memory_allocator()->Free(chunk);
   }
   chunks_queued_for_free_ = NULL;
 }
 
 } }  // namespace v8::internal