Regularly check hash set addresses to verify memory integrity.

src/heap/store-buffer.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <algorithm>
 
 #include "src/v8.h"
 
 #include "src/base/atomicops.h"
 #include "src/counters.h"
@@ skipping 63 matching lines @@
   CHECK(virtual_memory_->Commit(reinterpret_cast<Address>(start_),
                                 kStoreBufferSize,
                                 false));  // Not executable.
   heap_->public_set_store_buffer_top(start_);
 
   hash_set_1_ = new uintptr_t[kHashSetLength];
   hash_set_2_ = new uintptr_t[kHashSetLength];
   hash_sets_are_empty_ = false;
 
   ClearFilteringHashSets();
+
+  heap_->isolate()->set_store_buffer_hash_set_1_address(hash_set_1_);
+  heap_->isolate()->set_store_buffer_hash_set_2_address(hash_set_2_);
 }
 
 
 void StoreBuffer::TearDown() {
   delete virtual_memory_;
   delete old_virtual_memory_;
   delete[] hash_set_1_;
   delete[] hash_set_2_;
   old_start_ = old_top_ = old_limit_ = old_reserved_limit_ = NULL;
   start_ = limit_ = NULL;
@@ skipping 453 matching lines @@
       }
     }
     if (callback_ != NULL) {
       (*callback_)(heap_, NULL, kStoreBufferScanningPageEvent);
     }
   }
 }
 
 
 void StoreBuffer::Compact() {
+  CHECK(hash_set_1_ == heap_->isolate()->store_buffer_hash_set_1_address());
+  CHECK(hash_set_2_ == heap_->isolate()->store_buffer_hash_set_2_address());
+
   Address* top = reinterpret_cast<Address*>(heap_->store_buffer_top());
 
   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).
   DCHECK(top <= limit_);
   heap_->public_set_store_buffer_top(start_);
   EnsureSpace(top - start_);
   DCHECK(may_move_store_buffer_entries_);
@@ skipping 33 matching lines @@
     }
     old_buffer_is_sorted_ = false;
     old_buffer_is_filtered_ = false;
     *old_top_++ = reinterpret_cast<Address>(int_addr << kPointerSizeLog2);
     DCHECK(old_top_ <= old_limit_);
   }
   heap_->isolate()->counters()->store_buffer_compactions()->Increment();
 }
 }
 }  // namespace v8::internal