Fix several bugs in compaction:

src/mark-compact.h

 // 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 290 matching lines @@
 
   ~SlotsBuffer() {
   }
 
   void Add(ObjectSlot slot) {
     ASSERT(0 <= idx_ && idx_ < kNumberOfElements);
     slots_[idx_++] = slot;
   }
 
   enum SlotType {
-    NONE,
     RELOCATED_CODE_OBJECT,
     CODE_TARGET_SLOT,
     CODE_ENTRY_SLOT,
     DEBUG_TARGET_SLOT,
     JS_RETURN_SLOT,
     NUMBER_OF_SLOT_TYPES
   };
 
-  // Typed slot might be splitted between two SlotsBuffers: slot's type
-  // is recorded in one buffer and type address is recorded as the first
-  // slot in the next buffer.
-  //
-  // If the first address recorded in this buffer is address of the typed
-  // slot then it's type will be passed as pending argument.
-  //
-  // If this buffer ends on slot's type and the next buffer is expected to
-  // contain address of a typed slot then the function returns that type.
-  SlotType UpdateSlots(Heap* heap, SlotType pending);
+  void UpdateSlots(Heap* heap);
 
   SlotsBuffer* next() { return next_; }
 
   static int SizeOfChain(SlotsBuffer* buffer) {
     if (buffer == NULL) return 0;
     return static_cast<int>(buffer->idx_ +
                             (buffer->chain_length_ - 1) * kNumberOfElements);
   }
 
   inline bool IsFull() {
     return idx_ == kNumberOfElements;
   }
 
+  inline bool HasSpaceForTypedSlot() {
+    return idx_ < kNumberOfElements - 1;
+  }
+
   static void UpdateSlotsRecordedIn(Heap* heap, SlotsBuffer* buffer) {
-    SlotType pending = NONE;
     while (buffer != NULL) {
-      pending = buffer->UpdateSlots(heap, pending);
+      buffer->UpdateSlots(heap);
       buffer = buffer->next();
     }
   }
 
   enum AdditionMode {
     FAIL_ON_OVERFLOW,
     IGNORE_OVERFLOW
   };
 
+  static bool ChainLengthThresholdReached(SlotsBuffer* buffer) {
+    return buffer != NULL && buffer->chain_length_ >= kChainLengthThreshold;
+  }
+
   static bool AddTo(SlotsBufferAllocator* allocator,
                     SlotsBuffer** buffer_address,
                     ObjectSlot slot,
                     AdditionMode mode) {
     SlotsBuffer* buffer = *buffer_address;
     if (buffer == NULL || buffer->IsFull()) {
-      if (mode == FAIL_ON_OVERFLOW &&
-          buffer != NULL &&
-          buffer->chain_length_ >= kChainLengthThreshold) {
+      if (mode == FAIL_ON_OVERFLOW && ChainLengthThresholdReached(buffer)) {
         allocator->DeallocateChain(buffer_address);
         return false;
       }
       buffer = allocator->AllocateBuffer(buffer);
       *buffer_address = buffer;
     }
     buffer->Add(slot);
     return true;
   }
 
@@ skipping 385 matching lines @@
 
   List<Page*> evacuation_candidates_;
 
   friend class Heap;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_MARK_COMPACT_H_