Factor out handling of mixed objects preprocessing after migration

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 2775 matching lines @@
   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);
   }
 }
 
 
+void MarkCompactCollector::MigrateMixedObjectEpilog(HeapObject* dst) {
+  DCHECK(dst->MayContainMixedValues());
+  Address dst_addr = dst->address();
+  if (compacting_ && dst->IsJSFunction()) {
+    Address code_entry_slot = dst_addr + JSFunction::kCodeEntryOffset;
+    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);
+    }
+  } else if (dst->IsConstantPoolArray()) {
+    // We special case ConstantPoolArrays since they could contain integers
+    // value entries which look like tagged pointers.
+    // TODO(mstarzinger): restructure this code to avoid this special-casing.
+    ConstantPoolArray* array = ConstantPoolArray::cast(dst);
+    ConstantPoolArray::Iterator code_iter(array, ConstantPoolArray::CODE_PTR);
+    while (!code_iter.is_finished()) {
+      Address code_entry_slot =
+          dst_addr + array->OffsetOfElementAt(code_iter.next_index());
+      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);
+    }
+  }
+}
+
+
 // We scavenge 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 15 matching lines @@
     bool may_contain_raw_values = src->MayContainRawValues();
 #if V8_DOUBLE_FIELDS_UNBOXING
     LayoutDescriptorHelper helper(src->map());
     bool has_only_tagged_fields = helper.all_fields_tagged();
 #endif
     for (int remaining = size / kPointerSize; remaining > 0; remaining--) {
       Object* value = Memory::Object_at(src_slot);
 
       Memory::Object_at(dst_slot) = value;
 
 #if V8_DOUBLE_FIELDS_UNBOXING

[Hannes Payer (out of office), 2015/05/13 06:47:38]

Double unboxing would also be part of mixed objects.

[jochen (gone - plz use gerrit), 2015/05/13 06:51:45]

yeah, but this isn't really an epilogue but the actual moving...

[Hannes Payer (out of office), 2015/05/13 12:12:36]

Maybe it not really an Epilog, but more a HandleMixedObject.

[Igor Sheludko, 2015/05/13 12:22:59]

yeah, we could have three versions of this moving loop: for raw data objects,
mixed and normal ones.

       if (!may_contain_raw_values &&
           (has_only_tagged_fields ||
            helper.IsTagged(static_cast<int>(src_slot - src_addr))))
 #else
       if (!may_contain_raw_values)
 #endif
       {
         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);
-
-      if (Page::FromAddress(code_entry)->IsEvacuationCandidate()) {
-        SlotsBuffer::AddTo(&slots_buffer_allocator_, &migration_slots_buffer_,
-                           SlotsBuffer::CODE_ENTRY_SLOT, code_entry_slot,
-                           SlotsBuffer::IGNORE_OVERFLOW);
-      }
-    } else if (dst->IsConstantPoolArray()) {
-      // We special case ConstantPoolArrays since they could contain integers
-      // value entries which look like tagged pointers.
-      // TODO(mstarzinger): restructure this code to avoid this special-casing.
-      ConstantPoolArray* array = ConstantPoolArray::cast(dst);
-      ConstantPoolArray::Iterator code_iter(array, ConstantPoolArray::CODE_PTR);
-      while (!code_iter.is_finished()) {
-        Address code_entry_slot =
-            dst_addr + array->OffsetOfElementAt(code_iter.next_index());
-        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);
-      }
-    }
+    if (dst->MayContainMixedValues()) MigrateMixedObjectEpilog(dst);

[Igor Sheludko, 2015/05/13 12:22:59]

Do we need MayContainMixedValues() at all given that we are going to do
different stuff based on instance type anyway.

   } 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);
   } else {
     DCHECK(dest == NEW_SPACE);
     heap()->MoveBlock(dst_addr, src_addr, size);
+    if (dst->MayContainMixedValues()) {
+      heap()->MigrateMixedObjectInNewSpaceEpilog(dst);
+    }
   }
   heap()->OnMoveEvent(dst, src, size);
   Memory::Address_at(src_addr) = dst_addr;
 }
 
 
 // Visitor for updating pointers from live objects in old spaces to new space.
 // It does not expect to encounter pointers to dead objects.
 class PointersUpdatingVisitor : public ObjectVisitor {
  public:
@@ skipping 1882 matching lines @@
   SlotsBuffer* buffer = *buffer_address;
   while (buffer != NULL) {
     SlotsBuffer* next_buffer = buffer->next();
     DeallocateBuffer(buffer);
     buffer = next_buffer;
   }
   *buffer_address = NULL;
 }
 }
 }  // namespace v8::internal