Fix several bugs in compaction:

src/mark-compact.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 408 matching lines @@
   if (count > 0 && FLAG_trace_fragmentation) {
     PrintF("Collected %d evacuation candidates for space %s\n",
            count,
            AllocationSpaceName(space->identity()));
   }
 }
 
 
 void MarkCompactCollector::Prepare(GCTracer* tracer) {
   FLAG_flush_code = false;
-  FLAG_always_compact = false;
 
   // Disable collection of maps if incremental marking is enabled.
   // Map collection algorithm relies on a special map transition tree traversal
   // order which is not implemented for incremental marking.
   collect_maps_ = FLAG_collect_maps &&
       !heap()->incremental_marking()->IsMarking();
 
   // Rather than passing the tracer around we stash it in a static member
   // variable.
   tracer_ = tracer;
@@ skipping 2968 matching lines @@
 bool SlotsBuffer::IsTypedSlot(ObjectSlot slot) {
   return reinterpret_cast<uintptr_t>(slot) < NUMBER_OF_SLOT_TYPES;
 }
 
 
 bool SlotsBuffer::AddTo(SlotsBufferAllocator* allocator,
                         SlotsBuffer** buffer_address,
                         SlotType type,
                         Address addr,
                         AdditionMode mode) {
-  if(!AddTo(allocator,
-            buffer_address,
-            reinterpret_cast<ObjectSlot>(type),
-            mode)) {
-    return false;
+  SlotsBuffer* buffer = *buffer_address;
+  if (buffer == NULL || !buffer->HasSpaceForTypedSlot()) {
+    if (mode == FAIL_ON_OVERFLOW && ChainLengthThresholdReached(buffer)) {
+      allocator->DeallocateChain(buffer_address);
+      return false;
+    }
+    buffer = allocator->AllocateBuffer(buffer);
+    *buffer_address = buffer;
   }
-  return AddTo(allocator,
-               buffer_address,
-               reinterpret_cast<ObjectSlot>(addr),
-               mode);
+  ASSERT(buffer->HasSpaceForTypedSlot());
+  buffer->Add(reinterpret_cast<ObjectSlot>(type));
+  buffer->Add(reinterpret_cast<ObjectSlot>(addr));
+  return true;
 }
 
 
 static inline SlotsBuffer::SlotType SlotTypeForRMode(RelocInfo::Mode rmode) {
   if (RelocInfo::IsCodeTarget(rmode)) {
     return SlotsBuffer::CODE_TARGET_SLOT;
   } else if (RelocInfo::IsDebugBreakSlot(rmode)) {
     return SlotsBuffer::DEBUG_TARGET_SLOT;
   } else if (RelocInfo::IsJSReturn(rmode)) {
     return SlotsBuffer::JS_RETURN_SLOT;
   }
   UNREACHABLE();
-  return SlotsBuffer::NONE;
+  return SlotsBuffer::NUMBER_OF_SLOT_TYPES;
 }
 
 
 void MarkCompactCollector::RecordRelocSlot(RelocInfo* rinfo, Code* target) {
   Page* target_page = Page::FromAddress(
       reinterpret_cast<Address>(target));
   if (target_page->IsEvacuationCandidate() &&
-      !ShouldSkipEvacuationSlotRecording(rinfo->host())) {
+      (rinfo->host() == NULL ||
+       !ShouldSkipEvacuationSlotRecording(rinfo->host()))) {
     if (!SlotsBuffer::AddTo(&slots_buffer_allocator_,
                             target_page->slots_buffer_address(),
                             SlotTypeForRMode(rinfo->rmode()),
                             rinfo->pc(),
                             SlotsBuffer::FAIL_ON_OVERFLOW)) {
       EvictEvacuationCandidate(target_page);
     }
   }
 }
 
@@ skipping 13 matching lines @@
   }
 }
 
 
 static inline SlotsBuffer::SlotType DecodeSlotType(
     SlotsBuffer::ObjectSlot slot) {
   return static_cast<SlotsBuffer::SlotType>(reinterpret_cast<intptr_t>(slot));
 }
 
 
-SlotsBuffer::SlotType SlotsBuffer::UpdateSlots(
-    Heap* heap,
-    SlotsBuffer::SlotType pending) {
+void SlotsBuffer::UpdateSlots(Heap* heap) {
   PointersUpdatingVisitor v(heap);
 
-  if (pending != NONE) {
-    UpdateSlot(&v, pending, reinterpret_cast<Address>(slots_[0]));
-  }
-
   for (int slot_idx = 0; slot_idx < idx_; ++slot_idx) {
     ObjectSlot slot = slots_[slot_idx];
     if (!IsTypedSlot(slot)) {
       UpdateSlot(slot);
     } else {
       ++slot_idx;
-      if (slot_idx < idx_) {
-        UpdateSlot(&v,
-                   DecodeSlotType(slot),
-                   reinterpret_cast<Address>(slots_[slot_idx]));
-      } else {
-        return DecodeSlotType(slot);
-      }
+      ASSERT(slot_idx < idx_);
+      UpdateSlot(&v,
+                 DecodeSlotType(slot),
+                 reinterpret_cast<Address>(slots_[slot_idx]));
     }
   }
-
-  return SlotsBuffer::NONE;
 }
 
 
 SlotsBuffer* SlotsBufferAllocator::AllocateBuffer(SlotsBuffer* next_buffer) {
   return new SlotsBuffer(next_buffer);
 }
 
 
 void SlotsBufferAllocator::DeallocateBuffer(SlotsBuffer* buffer) {
   delete buffer;
 }
 
 
 void SlotsBufferAllocator::DeallocateChain(SlotsBuffer** buffer_address) {
   SlotsBuffer* buffer = *buffer_address;
   while (buffer != NULL) {
     SlotsBuffer* next_buffer = buffer->next();
     DeallocateBuffer(buffer);
     buffer = next_buffer;
   }
   *buffer_address = NULL;
 }
 
 
 } }  // namespace v8::internal