Remove markDead() and isDead()

third_party/WebKit/Source/platform/heap/HeapPage.cpp

 /*
  * Copyright (C) 2013 Google Inc. 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
@@ skipping 161 matching lines @@
 #endif
 
 void BaseArena::makeConsistentForGC() {
   clearFreeLists();
   ASSERT(isConsistentForGC());
   for (BasePage* page = m_firstPage; page; page = page->next()) {
     page->markAsUnswept();
     page->invalidateObjectStartBitmap();
   }
 
-  // If a new GC is requested before this thread got around to sweep,
-  // ie. due to the thread doing a long running operation, we clear
-  // the mark bits and mark any of the dead objects as dead. The latter
-  // is used to ensure the next GC marking does not trace already dead
-  // objects. If we trace a dead object we could end up tracing into
-  // garbage or the middle of another object via the newly conservatively
-  // found object.
-  BasePage* previousPage = nullptr;
-  for (BasePage *page = m_firstUnsweptPage; page;
-       previousPage = page, page = page->next()) {
-    page->makeConsistentForGC();
-    ASSERT(!page->hasBeenSwept());
-    page->invalidateObjectStartBitmap();
-  }
-  if (previousPage) {
-    ASSERT(m_firstUnsweptPage);
-    previousPage->m_next = m_firstPage;
-    m_firstPage = m_firstUnsweptPage;
-    m_firstUnsweptPage = nullptr;
-  }
-  ASSERT(!m_firstUnsweptPage);
+  // We should not start a new GC until we finish sweeping in the current GC.
+  CHECK(!m_firstUnsweptPage);
 
   HeapCompact* heapCompactor = getThreadState()->heap().compaction();
   if (!heapCompactor->isCompactingArena(arenaIndex()))
     return;
 
   BasePage* nextPage = m_firstPage;
   while (nextPage) {
     if (!nextPage->isLargeObjectPage())
       heapCompactor->addCompactingPage(nextPage);
     nextPage = nextPage->next();
@@ skipping 1305 matching lines @@
   // Zap the unused portion, until it is either compacted into or freed.
   if (currentPage != this) {
     FreeList::zapFreedMemory(payload(), payloadSize());
   } else {
     FreeList::zapFreedMemory(payload() + allocationPoint,
                              payloadSize() - allocationPoint);
   }
 #endif
 }
 
-void NormalPage::makeConsistentForGC() {
-  size_t markedObjectSize = 0;
-  for (Address headerAddress = payload(); headerAddress < payloadEnd();) {
-    HeapObjectHeader* header =
-        reinterpret_cast<HeapObjectHeader*>(headerAddress);
-    ASSERT(header->size() < blinkPagePayloadSize());
-    // Check if a free list entry first since we cannot call
-    // isMarked on a free list entry.
-    if (header->isFree()) {
-      headerAddress += header->size();
-      continue;
-    }
-    if (header->isMarked()) {
-      header->unmark();
-      markedObjectSize += header->size();
-    } else {
-      header->markDead();
-    }
-    headerAddress += header->size();
-  }
-  if (markedObjectSize)
-    arenaForNormalPage()->getThreadState()->increaseMarkedObjectSize(
-        markedObjectSize);
-}
-
 void NormalPage::makeConsistentForMutator() {
   Address startOfGap = payload();
   NormalPageArena* normalArena = arenaForNormalPage();
   for (Address headerAddress = payload(); headerAddress < payloadEnd();) {
     HeapObjectHeader* header =
         reinterpret_cast<HeapObjectHeader*>(headerAddress);
     size_t size = header->size();
     ASSERT(size < blinkPagePayloadSize());
     if (header->isPromptlyFreed())
       arenaForNormalPage()->decreasePromptlyFreedSize(size);
@@ skipping 133 matching lines @@
   } else {
     visitor->markHeader(header, gcInfo->m_trace);
   }
 }
 
 void NormalPage::checkAndMarkPointer(Visitor* visitor, Address address) {
 #if DCHECK_IS_ON()
   DCHECK(contains(address));
 #endif
   HeapObjectHeader* header = findHeaderFromAddress(address);
-  if (!header || header->isDead())
+  if (!header)
     return;
   markPointer(visitor, header);
 }
 
 #if DCHECK_IS_ON()
 void NormalPage::checkAndMarkPointer(Visitor* visitor,
                                      Address address,
                                      MarkedPointerCallbackForTesting callback) {
   DCHECK(contains(address));
   HeapObjectHeader* header = findHeaderFromAddress(address);
-  if (!header || header->isDead())
+  if (!header)
     return;
   if (!callback(header))
     markPointer(visitor, header);
 }
 #endif
 
 void NormalPage::markOrphaned() {
 // Zap the payload with a recognizable value to detect any incorrect
 // cross thread pointer usage.
 #if defined(ADDRESS_SANITIZER)
@@ skipping 81 matching lines @@
 
 void LargeObjectPage::removeFromHeap() {
   static_cast<LargeObjectArena*>(arena())->freeLargeObjectPage(this);
 }
 
 void LargeObjectPage::sweep() {
   heapObjectHeader()->unmark();
   arena()->getThreadState()->increaseMarkedObjectSize(size());
 }
 
-void LargeObjectPage::makeConsistentForGC() {
-  HeapObjectHeader* header = heapObjectHeader();
-  if (header->isMarked()) {
-    header->unmark();
-    arena()->getThreadState()->increaseMarkedObjectSize(size());
-  } else {
-    header->markDead();
-  }
-}
-
 void LargeObjectPage::makeConsistentForMutator() {
   HeapObjectHeader* header = heapObjectHeader();
   if (header->isMarked())
     header->unmark();
 }
 
 #if defined(ADDRESS_SANITIZER)
 void LargeObjectPage::poisonUnmarkedObjects() {
   HeapObjectHeader* header = heapObjectHeader();
   if (!header->isMarked())
     ASAN_POISON_MEMORY_REGION(header->payload(), header->payloadSize());
 }
 #endif
 
 void LargeObjectPage::checkAndMarkPointer(Visitor* visitor, Address address) {
 #if DCHECK_IS_ON()
   DCHECK(contains(address));
 #endif
-  if (!containedInObjectPayload(address) || heapObjectHeader()->isDead())
+  if (!containedInObjectPayload(address))
     return;
   markPointer(visitor, heapObjectHeader());
 }
 
 #if DCHECK_IS_ON()
 void LargeObjectPage::checkAndMarkPointer(
     Visitor* visitor,
     Address address,
     MarkedPointerCallbackForTesting callback) {
   DCHECK(contains(address));
-  if (!containedInObjectPayload(address) || heapObjectHeader()->isDead())
+  if (!containedInObjectPayload(address))
     return;
   if (!callback(heapObjectHeader()))
     markPointer(visitor, heapObjectHeader());
 }
 #endif
 
 void LargeObjectPage::markOrphaned() {
   // Zap the payload with a recognizable value to detect any incorrect
   // cross thread pointer usage.
   OrphanedPagePool::asanDisabledMemset(
@@ skipping 71 matching lines @@
 
   m_hasEntries = true;
   size_t index = hash(address);
   ASSERT(!(index & 1));
   Address cachePage = roundToBlinkPageStart(address);
   m_entries[index + 1] = m_entries[index];
   m_entries[index] = cachePage;
 }
 
 }  // namespace blink