Removed pointer space to pointer space compaction check when migrating objects.

src/mark-compact.cc

 // Copyright 2012 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 2722 matching lines @@
 // pointer iteration.  This is an issue if the store buffer overflows and we
 // have to scan the entire old space, including dead objects, looking for
 // pointers to new space.
 void MarkCompactCollector::MigrateObject(Address dst,
                                          Address src,
                                          int size,
                                          AllocationSpace dest) {
   HEAP_PROFILE(heap(), ObjectMoveEvent(src, dst));
   // TODO(hpayer): Replace that check with an assert.
   CHECK(dest != LO_SPACE && size <= Page::kMaxNonCodeHeapObjectSize);
-  // Objects in old pointer space and old data space can just be moved by
-  // compaction to a different page in the same space.
-  // TODO(hpayer): Replace that following checks with asserts.
-  CHECK(!heap_->old_pointer_space()->Contains(src) ||
-        (heap_->old_pointer_space()->Contains(dst) &&
-        heap_->TargetSpace(HeapObject::FromAddress(src)) ==
-        heap_->old_pointer_space()));
-  CHECK(!heap_->old_data_space()->Contains(src) ||
-        (heap_->old_data_space()->Contains(dst) &&
-        heap_->TargetSpace(HeapObject::FromAddress(src)) ==
-        heap_->old_data_space()));
   if (dest == OLD_POINTER_SPACE) {
     // TODO(hpayer): Replace this check with an assert.
     CHECK(heap_->TargetSpace(HeapObject::FromAddress(src)) ==
           heap_->old_pointer_space());
     Address src_slot = src;
     Address dst_slot = dst;
     ASSERT(IsAligned(size, kPointerSize));
 
     for (int remaining = size / kPointerSize; remaining > 0; remaining--) {
       Object* value = Memory::Object_at(src_slot);
@@ skipping 29 matching lines @@
     PROFILE(isolate(), CodeMoveEvent(src, dst));
     heap()->MoveBlock(dst, src, size);
     SlotsBuffer::AddTo(&slots_buffer_allocator_,
                        &migration_slots_buffer_,
                        SlotsBuffer::RELOCATED_CODE_OBJECT,
                        dst,
                        SlotsBuffer::IGNORE_OVERFLOW);
     Code::cast(HeapObject::FromAddress(dst))->Relocate(dst - src);
   } else {
     ASSERT(dest == OLD_DATA_SPACE || dest == NEW_SPACE);
+    // Objects in old data space can just be moved by compaction to a different
+    // page in old data space.
+    // TODO(hpayer): Replace the following check with an assert.
+    CHECK(!heap_->old_data_space()->Contains(src) ||
+          (heap_->old_data_space()->Contains(dst) &&
+          heap_->TargetSpace(HeapObject::FromAddress(src)) ==
+          heap_->old_data_space()));
     heap()->MoveBlock(dst, src, size);
   }
   Memory::Address_at(src) = dst;
 }
 
 
 // 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 1528 matching lines @@
   while (buffer != NULL) {
     SlotsBuffer* next_buffer = buffer->next();
     DeallocateBuffer(buffer);
     buffer = next_buffer;
   }
   *buffer_address = NULL;
 }
 
 
 } }  // namespace v8::internal