Make sure that we grow the slots buffer when we are in evacuation scope.

src/mark-compact-inl.h

 // 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 68 matching lines @@
 }
 
 
 void MarkCompactCollector::RecordSlot(Object** anchor_slot,
                                       Object** slot,
                                       Object* object,
                                       SlotsBuffer::AdditionMode mode) {
   Page* object_page = Page::FromAddress(reinterpret_cast<Address>(object));
   if (object_page->IsEvacuationCandidate() &&
       !ShouldSkipEvacuationSlotRecording(anchor_slot)) {
-    if (!SlotsBuffer::AddTo(&slots_buffer_allocator_,
+    if (!SlotsBuffer::AddTo(heap_,
+                            &slots_buffer_allocator_,
                             object_page->slots_buffer_address(),
                             slot,
                             mode)) {
       EvictEvacuationCandidate(object_page);
     }
   }
 }
 
 
+bool SlotsBuffer::AddTo(Heap* heap,
+                        SlotsBufferAllocator* allocator,
+                        SlotsBuffer** buffer_address,
+                        ObjectSlot slot,
+                        AdditionMode mode) {
+  ASSERT(!heap->mark_compact_collector()->IsInsideEvacuationScope() ||
+      mode == IGNORE_OVERFLOW);
+  ASSERT(heap->mark_compact_collector()->IsInsideEvacuationScope() ||
+      mode == FAIL_ON_OVERFLOW);

[Michael Starzinger, 2014/03/06 10:47:25]

This invariant can be expressed in one expression I think.

ASSERT(heap->mark_compact_collector()->IsInsideEvacuationScope() ==
       mode != IGNORE_OVERFLOW);

+  SlotsBuffer* buffer = *buffer_address;
+  if (buffer == NULL || buffer->IsFull()) {
+    if (mode == FAIL_ON_OVERFLOW && ChainLengthThresholdReached(buffer)) {
+      allocator->DeallocateChain(buffer_address);
+      return false;
+    }
+    buffer = allocator->AllocateBuffer(heap, buffer);
+    *buffer_address = buffer;
+  }
+  buffer->Add(slot);
+  return true;
+}
+
+
+bool SlotsBuffer::AddTo(Heap* heap,
+                        SlotsBufferAllocator* allocator,
+                        SlotsBuffer** buffer_address,
+                        SlotType type,
+                        Address addr,
+                        AdditionMode mode) {
+  ASSERT(!heap->mark_compact_collector()->IsInsideEvacuationScope() ||
+      mode == IGNORE_OVERFLOW);
+  ASSERT(heap->mark_compact_collector()->IsInsideEvacuationScope() ||
+      mode == FAIL_ON_OVERFLOW);

[Michael Starzinger, 2014/03/06 10:47:25]

Likewise.

+  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(heap, buffer);
+    *buffer_address = buffer;
+  }
+  ASSERT(buffer->HasSpaceForTypedSlot());
+  buffer->Add(reinterpret_cast<ObjectSlot>(type));
+  buffer->Add(reinterpret_cast<ObjectSlot>(addr));
+  return true;
+}
+
+
 } }  // namespace v8::internal
 
 #endif  // V8_MARK_COMPACT_INL_H_