Special case ConstantPoolArray in MarkCompactCollector::MigrateObject.

src/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 "v8.h"
 
 #include "code-stubs.h"
 #include "compilation-cache.h"
 #include "cpu-profiler.h"
 #include "deoptimizer.h"
@@ skipping 2804 matching lines @@
         table->RemoveEntry(i);
       }
     }
     weak_collection_obj = weak_collection->next();
     weak_collection->set_next(Smi::FromInt(0));
   }
   set_encountered_weak_collections(Smi::FromInt(0));
 }
 
 
+void MarkCompactCollector::RecordMigratedSlot(Object* value, Address slot) {
+  if (heap_->InNewSpace(value)) {
+    heap_->store_buffer()->Mark(slot);
+  } else if (value->IsHeapObject() && IsOnEvacuationCandidate(value)) {
+    SlotsBuffer::AddTo(&slots_buffer_allocator_,
+                       &migration_slots_buffer_,
+                       reinterpret_cast<Object**>(slot),
+                       SlotsBuffer::IGNORE_OVERFLOW);
+  }
+}
+
+
+
 // We scavange new space simultaneously with sweeping. This is done in two
 // passes.
 //
 // The first pass migrates all alive objects from one semispace to another or
 // promotes them to old space.  Forwarding address is written directly into
 // first word of object without any encoding.  If object is dead we write
 // NULL as a forwarding address.
 //
 // The second pass updates pointers to new space in all spaces.  It is possible
 // to encounter pointers to dead new space objects during traversal of pointers
@@ skipping 16 matching lines @@
   if (dest == OLD_POINTER_SPACE) {
     Address src_slot = src_addr;
     Address dst_slot = dst_addr;
     ASSERT(IsAligned(size, kPointerSize));
 
     for (int remaining = size / kPointerSize; remaining > 0; remaining--) {
       Object* value = Memory::Object_at(src_slot);
 
       Memory::Object_at(dst_slot) = value;
 
-      if (heap_->InNewSpace(value)) {
-        heap_->store_buffer()->Mark(dst_slot);
-      } else if (value->IsHeapObject() && IsOnEvacuationCandidate(value)) {
-        SlotsBuffer::AddTo(&slots_buffer_allocator_,
-                           &migration_slots_buffer_,
-                           reinterpret_cast<Object**>(dst_slot),
-                           SlotsBuffer::IGNORE_OVERFLOW);
+      // We special case ConstantPoolArrays below since they could contain

[Hannes Payer (out of office), 2014/06/04 07:25:04]

contain contain => contain

[rmcilroy, 2014/06/04 10:19:26]

Done.

+      // contain integers value entries which look like tagged pointers.
+      if (!(compacting_ && dst->IsConstantPoolArray())) {

[Michael Starzinger, 2014/06/03 22:57:11]

OMG, this is a giant hack. Please leave a TODO(mstarzinger) here that this code
needs to be re-structured somehow. I haven't thought about it long enough to
give constructive feedback yet.

[Hannes Payer (out of office), 2014/06/04 07:25:04]

The problem is that constant pools do not belong to old pointer space or old
data space, they can contain both data and pointers. This is reason why we have
to do the special handling left and right. Merging both old spaces may help
cleaning this up.

I am not happy with this hack, but there is not much we can do right now.

[Hannes Payer (out of office), 2014/06/04 07:25:04]

if (!(compacting_ && dst->IsConstantPoolArray()))
=>
if (!compacting_ || !dst->IsConstantPoolArray())

Why do you need !compacting_? With that you would still create store buffer
entries for constant pool entries that look like tagged pointers.

[rmcilroy, 2014/06/04 10:15:56]

ConstantPoolArrays are pre-tenured, so they should only ever be being migrated
when "compacting_".  I removed the check in anycase since it shouldn't make a
difference either way.  Also changed the check to src->IsConstantPoolArray() to
avoid issues if the compiler aggressively moves this statement before the
"Memory::Object_at(dst_slot) = value" above.

[rmcilroy, 2014/06/04 10:15:56]

Done.

[Hannes Payer (out of office), 2014/06/04 10:54:16]

I was worried about creating store buffer entries for int values that look like
new space pointers.

+        RecordMigratedSlot(value, dst_slot);
       }
 
       src_slot += kPointerSize;
       dst_slot += kPointerSize;
     }
 
     if (compacting_ && dst->IsJSFunction()) {
       Address code_entry_slot = dst_addr + JSFunction::kCodeEntryOffset;
       Address code_entry = Memory::Address_at(code_entry_slot);
 
@@ skipping 13 matching lines @@
         Address code_entry = Memory::Address_at(code_entry_slot);
 
         if (Page::FromAddress(code_entry)->IsEvacuationCandidate()) {
           SlotsBuffer::AddTo(&slots_buffer_allocator_,
                              &migration_slots_buffer_,
                              SlotsBuffer::CODE_ENTRY_SLOT,
                              code_entry_slot,
                              SlotsBuffer::IGNORE_OVERFLOW);
         }
       }
+      ConstantPoolArray::Iterator heap_iter(array, ConstantPoolArray::HEAP_PTR);
+      while (!heap_iter.is_finished()) {
+        Address heap_slot =
+            dst_addr + array->OffsetOfElementAt(heap_iter.next_index());
+        Object* value = Memory::Object_at(heap_slot);
+        RecordMigratedSlot(value, heap_slot);
+      }
     }
   } else if (dest == CODE_SPACE) {
     PROFILE(isolate(), CodeMoveEvent(src_addr, dst_addr));
     heap()->MoveBlock(dst_addr, src_addr, size);
     SlotsBuffer::AddTo(&slots_buffer_allocator_,
                        &migration_slots_buffer_,
                        SlotsBuffer::RELOCATED_CODE_OBJECT,
                        dst_addr,
                        SlotsBuffer::IGNORE_OVERFLOW);
     Code::cast(dst)->Relocate(dst_addr - src_addr);
@@ skipping 1591 matching lines @@
   while (buffer != NULL) {
     SlotsBuffer* next_buffer = buffer->next();
     DeallocateBuffer(buffer);
     buffer = next_buffer;
   }
   *buffer_address = NULL;
 }
 
 
 } }  // namespace v8::internal