Clear mark bits while sweeping and not explicitly.

src/spaces.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 1912 matching lines @@
 
 void PagedSpace::PrepareForMarkCompact() {
   // We don't have a linear allocation area while sweeping.  It will be restored
   // on the first allocation after the sweep.
   // Mark the old linear allocation area with a free space map so it can be
   // skipped when scanning the heap.
   int old_linear_size = static_cast<int>(limit() - top());
   Free(top(), old_linear_size);
   SetTop(NULL, NULL);
 
-  // Stop lazy sweeping for the space.
-  if (FLAG_trace_gc && first_unswept_page_ != NULL) {
+  // Stop lazy sweeping and clear marking bits for the space.
+  if (first_unswept_page_ != NULL) {
     int pages = 0;
-    Page* p = last_unswept_page_;
+    Page* last = last_unswept_page_->next_page();
+    Page* p = first_unswept_page_;
     do {
       pages++;
+      Bitmap::Clear(p);
       p = p->next_page();
-    } while (p != last_unswept_page_);
-    PrintF("Abandoned %d unswept pages\n", pages);
+    } while (p != last);
+    if (FLAG_trace_gc) {
+      PrintF("Abandoned %d unswept pages\n", pages);
+    }
   }
   first_unswept_page_ = last_unswept_page_ = Page::FromAddress(NULL);
 
   // Clear the free list before a full GC---it will be rebuilt afterward.
   free_list_.Reset();
 
-  // Clear EVACUATED flag from all pages.
+  // Clear WAS_SWEPT and WAS_SWEPT_CONSERVATIVELY flags from all pages.
   PageIterator it(this);
   while (it.has_next()) {
     Page* page = it.next();
     page->ClearSwept();
+    page->ClearFlag(MemoryChunk::WAS_SWEPT_CONSERVATIVELY);
   }
 }
 
 
 bool PagedSpace::ReserveSpace(int size_in_bytes) {
   ASSERT(size_in_bytes <= Page::kMaxHeapObjectSize);
   ASSERT(size_in_bytes == RoundSizeDownToObjectAlignment(size_in_bytes));
   Address current_top = allocation_info_.top;
   Address new_top = current_top + size_in_bytes;
   if (new_top <= allocation_info_.limit) return true;
@@ skipping 555 matching lines @@
   for (HeapObject* obj = obj_it.Next(); obj != NULL; obj = obj_it.Next()) {
     if (obj->IsCode()) {
       Code* code = Code::cast(obj);
       isolate->code_kind_statistics()[code->kind()] += code->Size();
     }
   }
 }
 #endif  // DEBUG
 
 } }  // namespace v8::internal