Fix some correctness issues with the store buffer shown up by...

src/store-buffer.cc

 // Copyright 2010 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 63 matching lines @@
                           kStoreBufferSize,
                           false);  // Not executable.
   Heap::public_set_store_buffer_top(start_);
 
   hash_map_1_ = new uintptr_t[kHashMapLength];
   hash_map_2_ = new uintptr_t[kHashMapLength];
 
   Heap::AddGCPrologueCallback(&GCPrologue, kGCTypeAll);
   Heap::AddGCEpilogueCallback(&GCEpilogue, kGCTypeAll);
 
-  GCPrologue(kGCTypeMarkSweepCompact, kNoGCCallbackFlags);
+  ZapHashTables();
 }
 
 
 void StoreBuffer::TearDown() {
   delete virtual_memory_;
   delete[] hash_map_1_;
   delete[] hash_map_2_;
   delete[] old_start_;
   old_start_ = old_top_ = old_limit_ = NULL;
   start_ = limit_ = NULL;
@@ skipping 44 matching lines @@
     }
     previous = current;
   }
   old_top_ = write;
 }
 
 
 void StoreBuffer::SortUniq() {
   Compact();
   if (old_buffer_is_sorted_) return;
-  if (store_buffer_mode_ == kStoreBufferDisabled) {
+  if (store_buffer_mode() == kStoreBufferDisabled) {
     old_top_ = old_start_;
     return;
   }
   ZapHashTables();
   qsort(reinterpret_cast<void*>(old_start_),
         old_top_ - old_start_,
         sizeof(*old_top_),
         &CompareAddresses);
   Uniq();
 
   old_buffer_is_sorted_ = true;
 }
 
 
 #ifdef DEBUG
 void StoreBuffer::Clean() {
-  if (store_buffer_mode_ == kStoreBufferDisabled) {
+  if (store_buffer_mode() == kStoreBufferDisabled) {
     old_top_ = old_start_;  // Just clear the cache.
     return;
   }
   ZapHashTables();
   Uniq();  // Also removes things that no longer point to new space.
   CheckForFullBuffer();
 }
 
 
 static bool Zapped(char* start, int size) {
@@ skipping 10 matching lines @@
       Zapped(reinterpret_cast<char*>(hash_map_2_),
              sizeof(uintptr_t) * kHashMapLength);
 }
 
 
 static Address* in_store_buffer_1_element_cache = NULL;
 
 
 bool StoreBuffer::CellIsInStoreBuffer(Address cell_address) {
   if (!FLAG_enable_slow_asserts) return true;
-  if (store_buffer_mode_ != kStoreBufferFunctional) return true;
+  if (store_buffer_mode() != kStoreBufferFunctional) return true;
   if (in_store_buffer_1_element_cache != NULL &&
       *in_store_buffer_1_element_cache == cell_address) {
     return true;
   }
   Address* top = reinterpret_cast<Address*>(Heap::store_buffer_top());
   for (Address* current = top - 1; current >= start_; current--) {
     if (*current == cell_address) {
       in_store_buffer_1_element_cache = current;
       return true;
     }
@@ skipping 21 matching lines @@
 
 void StoreBuffer::GCPrologue(GCType type, GCCallbackFlags flags) {
   ZapHashTables();
   during_gc_ = true;
 }
 
 
 void StoreBuffer::Verify() {
 #ifdef DEBUG
   if (FLAG_verify_heap &&
-      StoreBuffer::store_buffer_mode_ == kStoreBufferFunctional) {
+      StoreBuffer::store_buffer_mode() == kStoreBufferFunctional) {
     Heap::OldPointerSpaceCheckStoreBuffer(Heap::WATERMARK_SHOULD_BE_VALID);
     Heap::MapSpaceCheckStoreBuffer(Heap::WATERMARK_SHOULD_BE_VALID);
     Heap::LargeObjectSpaceCheckStoreBuffer();
   }
 #endif
 }
 
 
 void StoreBuffer::GCEpilogue(GCType type, GCCallbackFlags flags) {
   during_gc_ = false;
-  if (store_buffer_mode_ == kStoreBufferBeingRebuilt) {
-    store_buffer_mode_ = kStoreBufferFunctional;
+  if (store_buffer_mode() == kStoreBufferBeingRebuilt) {
+    set_store_buffer_mode(kStoreBufferFunctional);
   }
   Verify();
 }
 
 
 void StoreBuffer::IteratePointersToNewSpace(ObjectSlotCallback callback) {
-  if (store_buffer_mode_ != kStoreBufferFunctional) {
+  if (store_buffer_mode() == kStoreBufferFunctional) {
+    SortUniq();
+  }
+  if (store_buffer_mode() != kStoreBufferFunctional) {
     old_top_ = old_start_;
     ZapHashTables();
     Heap::public_set_store_buffer_top(start_);
-    store_buffer_mode_ = kStoreBufferBeingRebuilt;
+    set_store_buffer_mode(kStoreBufferBeingRebuilt);
     Heap::IteratePointers(Heap::old_pointer_space(),
                           &Heap::IteratePointersToNewSpace,
                           callback,
                           Heap::WATERMARK_SHOULD_BE_VALID);
 
     Heap::IteratePointers(Heap::map_space(),
                           &Heap::IteratePointersFromMapsToNewSpace,
                           callback,
                           Heap::WATERMARK_SHOULD_BE_VALID);
 
     Heap::lo_space()->IteratePointersToNewSpace(callback);
   } else {
-    SortUniq();
     Address* limit = old_top_;
     old_top_ = old_start_;
     {
       DontMoveStoreBufferEntriesScope scope;
       for (Address* current = old_start_; current < limit; current++) {
 #ifdef DEBUG
         Address* saved_top = old_top_;
 #endif
         Object** cell = reinterpret_cast<Object**>(*current);
         Object* object = *cell;
@@ skipping 18 matching lines @@
 
   if (top == start_) return;
 
   // There's no check of the limit in the loop below so we check here for
   // the worst case (compaction doesn't eliminate any pointers).
   ASSERT(top <= limit_);
   Heap::public_set_store_buffer_top(start_);
   if (top - start_ > old_limit_ - old_top_) {
     CheckForFullBuffer();
   }
-  if (store_buffer_mode_ == kStoreBufferDisabled) return;
+  if (store_buffer_mode() == kStoreBufferDisabled) return;
   ASSERT(may_move_store_buffer_entries_);
   // Goes through the addresses in the store buffer attempting to remove
   // duplicates.  In the interest of speed this is a lossy operation.  Some
   // duplicates will remain.  We have two hash tables with different hash
   // functions to reduce the number of unnecessary clashes.
   for (Address* current = start_; current < top; current++) {
     uintptr_t int_addr = reinterpret_cast<uintptr_t>(*current);
     // Shift out the last bits including any tags.
     int_addr >>= kPointerSizeLog2;
     int hash1 =
@@ skipping 21 matching lines @@
   CheckForFullBuffer();
 }
 
 
 void StoreBuffer::CheckForFullBuffer() {
   if (old_limit_ - old_top_ < kStoreBufferSize * 2) {
     // After compression we don't have enough space that we can be sure that
     // the next two compressions will have enough space in the buffer.  We
     // start by trying a more agressive compression.  If this frees up at least
     // half the space then we can keep going, otherwise it is time to brake.
-    SortUniq();
+    if (!during_gc_) {
+      SortUniq();
+    }
     if (old_limit_ - old_top_ < old_limit_ - old_top_) {
       return;
     }
     // TODO(gc): Set an interrupt to do a GC on the next back edge.
     // TODO(gc): Allocate the rest of new space to force a GC on the next
     // allocation.
     if (old_limit_ - old_top_ < kStoreBufferSize) {
       // After compression we don't even have enough space for the next
       // compression to be guaranteed to succeed.
       // TODO(gc): Set a flag to scan all of memory.
       Counters::store_buffer_overflows.Increment();
-      store_buffer_mode_ = kStoreBufferDisabled;
+      set_store_buffer_mode(kStoreBufferDisabled);
     }
   }
 }
 
 } }  // namespace v8::internal