Perform TODO(gc) cleanup for TODO-lockdown.

src/store-buffer.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 66 matching lines @@
          0);
 
   virtual_memory_->Commit(reinterpret_cast<Address>(start_),
                           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);
-
   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;
@@ skipping 54 matching lines @@
 
 
 void StoreBuffer::HandleFullness() {
   if (old_buffer_is_filtered_) return;
   ASSERT(may_move_store_buffer_entries_);
   Compact();
 
   old_buffer_is_filtered_ = true;
   bool page_has_scan_on_scavenge_flag = false;
 
-  PointerChunkIterator it;
+  PointerChunkIterator it(heap_);
   MemoryChunk* chunk;
   while ((chunk = it.next()) != NULL) {
     if (chunk->scan_on_scavenge()) page_has_scan_on_scavenge_flag = true;
   }
 
   if (page_has_scan_on_scavenge_flag) {
     Filter(MemoryChunk::SCAN_ON_SCAVENGE);
   }
 
   // If filtering out the entries from scan_on_scavenge pages got us down to
@@ skipping 19 matching lines @@
     ASSERT(i != 0 || old_top_ == old_start_);
     if (old_limit_ - old_top_ > old_top_ - old_start_) return;
   }
   UNREACHABLE();
 }
 
 
 // Sample the store buffer to see if some pages are taking up a lot of space
 // in the store buffer.
 void StoreBuffer::ExemptPopularPages(int prime_sample_step, int threshold) {
-  PointerChunkIterator it;
+  PointerChunkIterator it(heap_);
   MemoryChunk* chunk;
   while ((chunk = it.next()) != NULL) {
     chunk->set_store_buffer_counter(0);
   }
   bool created_new_scan_on_scavenge_pages = false;
   MemoryChunk* previous_chunk = NULL;
   for (Address* p = old_start_; p < old_top_; p += prime_sample_step) {
     Address addr = *p;
     MemoryChunk* containing_chunk = NULL;
     if (previous_chunk != NULL && previous_chunk->Contains(addr)) {
@@ skipping 45 matching lines @@
         sizeof(*old_top_),
         &CompareAddresses);
   Uniq();
 
   old_buffer_is_sorted_ = true;
 }
 
 
 bool StoreBuffer::PrepareForIteration() {
   Compact();
-  PointerChunkIterator it;
+  PointerChunkIterator it(heap_);
   MemoryChunk* chunk;
   bool page_has_scan_on_scavenge_flag = false;
   while ((chunk = it.next()) != NULL) {
     if (chunk->scan_on_scavenge()) page_has_scan_on_scavenge_flag = true;
   }
 
   if (page_has_scan_on_scavenge_flag) {
     Filter(MemoryChunk::SCAN_ON_SCAVENGE);
   }
   ZapHashTables();
@@ skipping 55 matching lines @@
 void StoreBuffer::ZapHashTables() {
   memset(reinterpret_cast<void*>(hash_map_1_),
          0,
          sizeof(uintptr_t) * kHashMapLength);
   memset(reinterpret_cast<void*>(hash_map_2_),
          0,
          sizeof(uintptr_t) * kHashMapLength);
 }
 
 
-void StoreBuffer::GCPrologue(GCType type, GCCallbackFlags flags) {
-  // TODO(gc) ISOLATES MERGE
-  HEAP->store_buffer()->ZapHashTables();
-  HEAP->store_buffer()->during_gc_ = true;
+void StoreBuffer::GCPrologue() {
+  ZapHashTables();
+  during_gc_ = true;
 }
 
 
 #ifdef DEBUG
 static void DummyScavengePointer(HeapObject** p, HeapObject* o) {
   // Do nothing.
 }
 
 
 void StoreBuffer::VerifyPointers(PagedSpace* space,
@@ skipping 36 matching lines @@
 #ifdef DEBUG
   VerifyPointers(heap_->old_pointer_space(),
                  &StoreBuffer::FindPointersToNewSpaceInRegion);
   VerifyPointers(heap_->map_space(),
                  &StoreBuffer::FindPointersToNewSpaceInMapsRegion);
   VerifyPointers(heap_->lo_space());
 #endif
 }
 
 
-void StoreBuffer::GCEpilogue(GCType type, GCCallbackFlags flags) {
-  // TODO(gc) ISOLATES MERGE
-  HEAP->store_buffer()->during_gc_ = false;
-  HEAP->store_buffer()->Verify();
+void StoreBuffer::GCEpilogue() {
+  during_gc_ = false;
+  Verify();
 }
 
 
 void StoreBuffer::FindPointersToNewSpaceInRegion(
     Address start, Address end, ObjectSlotCallback slot_callback) {
   for (Address slot_address = start;
        slot_address < end;
        slot_address += kPointerSize) {
     Object** slot = reinterpret_cast<Object**>(slot_address);
     if (heap_->InNewSpace(*slot)) {
@@ skipping 177 matching lines @@
   // scan, the surviving pointers to new space will be added to the store
   // buffer.  If there are still a lot of pointers to new space then we will
   // keep the scan_on_scavenge flag on the page and discard the pointers that
   // were added to the store buffer.  If there are not many pointers to new
   // space left on the page we will keep the pointers in the store buffer and
   // remove the flag from the page.
   if (some_pages_to_scan) {
     if (callback_ != NULL) {
       (*callback_)(heap_, NULL, kStoreBufferStartScanningPagesEvent);
     }
-    PointerChunkIterator it;
+    PointerChunkIterator it(heap_);
     MemoryChunk* chunk;
     while ((chunk = it.next()) != NULL) {
       if (chunk->scan_on_scavenge()) {
         chunk->set_scan_on_scavenge(false);
         if (callback_ != NULL) {
           (*callback_)(heap_, chunk, kStoreBufferScanningPageEvent);
         }
         if (chunk->owner() == heap_->lo_space()) {
           LargePage* large_page = reinterpret_cast<LargePage*>(chunk);
           HeapObject* array = large_page->GetObject();
@@ skipping 72 matching lines @@
 }
 
 
 void StoreBuffer::CheckForFullBuffer() {
   if (old_limit_ - old_top_ < kStoreBufferSize * 2) {
     HandleFullness();
   }
 }
 
 } }  // namespace v8::internal