Changeset 213675 in webkit for trunk/Source/JavaScriptCore/tools/HeapVerifier.cpp

Timestamp:

Mar 9, 2017, 2:39:09 PM (8 years ago)

Author:

[email protected]

Message:

Refactoring some HeapVerifier code.
​https://bugs.webkit.org/show_bug.cgi?id=169443

Reviewed by Filip Pizlo.

Renamed LiveObjectData to CellProfile.
Renamed LiveObjectList to CellList.
Moved CellProfile.*, CellList.*, and HeapVerifier.* from the heap folder to the tools folder.
Updated the HeapVerifier to handle JSCells instead of just JSObjects.

This is in preparation for subsequent patches to fix up the HeapVerifier for service again.

• CMakeLists.txt:
• JavaScriptCore.xcodeproj/project.pbxproj:
• heap/Heap.cpp:

(JSC::Heap::runBeginPhase):
(JSC::Heap::runEndPhase):

• heap/HeapVerifier.cpp: Removed.
• heap/HeapVerifier.h: Removed.
• heap/LiveObjectData.h: Removed.
• heap/LiveObjectList.cpp: Removed.
• heap/LiveObjectList.h: Removed.
• tools/CellList.cpp: Copied from Source/JavaScriptCore/heap/LiveObjectList.cpp.

(JSC::CellList::findCell):
(JSC::LiveObjectList::findObject): Deleted.

• tools/CellList.h: Copied from Source/JavaScriptCore/heap/LiveObjectList.h.

(JSC::CellList::CellList):
(JSC::CellList::reset):
(JSC::LiveObjectList::LiveObjectList): Deleted.
(JSC::LiveObjectList::reset): Deleted.

• tools/CellProfile.h: Copied from Source/JavaScriptCore/heap/LiveObjectData.h.

(JSC::CellProfile::CellProfile):
(JSC::LiveObjectData::LiveObjectData): Deleted.

• tools/HeapVerifier.cpp: Copied from Source/JavaScriptCore/heap/HeapVerifier.cpp.

(JSC::GatherCellFunctor::GatherCellFunctor):
(JSC::GatherCellFunctor::visit):
(JSC::GatherCellFunctor::operator()):
(JSC::HeapVerifier::gatherLiveCells):
(JSC::HeapVerifier::cellListForGathering):
(JSC::trimDeadCellsFromList):
(JSC::HeapVerifier::trimDeadCells):
(JSC::HeapVerifier::verifyButterflyIsInStorageSpace):
(JSC::HeapVerifier::reportCell):
(JSC::HeapVerifier::checkIfRecorded):
(JSC::GatherLiveObjFunctor::GatherLiveObjFunctor): Deleted.
(JSC::GatherLiveObjFunctor::visit): Deleted.
(JSC::GatherLiveObjFunctor::operator()): Deleted.
(JSC::HeapVerifier::gatherLiveObjects): Deleted.
(JSC::HeapVerifier::liveObjectListForGathering): Deleted.
(JSC::trimDeadObjectsFromList): Deleted.
(JSC::HeapVerifier::trimDeadObjects): Deleted.
(JSC::HeapVerifier::reportObject): Deleted.

• tools/HeapVerifier.h: Copied from Source/JavaScriptCore/heap/HeapVerifier.h.

File:

• trunk/Source/JavaScriptCore/tools/HeapVerifier.cpp (moved) (moved from trunk/Source/JavaScriptCore/heap/HeapVerifier.cpp ) (7 diffs)

trunk/Source/JavaScriptCore/tools/HeapVerifier.cpp

@@ -67 +67 @@
 }
 
-struct GatherLiveObjFunctor : MarkedBlock::CountFunctor {
-    GatherLiveObjFunctor(LiveObjectList& list)
+struct GatherCellFunctor : MarkedBlock::CountFunctor {
+    GatherCellFunctor(CellList& list)
         : m_list(list)
     {
-        ASSERT(!list.liveObjects.size());
+        ASSERT(!list.liveCells.size());
     }
 
     inline void visit(JSCell* cell)
     {
-        if (!cell->isObject())
-            return;        
-        LiveObjectData data(asObject(cell));
-        m_list.liveObjects.append(data);
+        CellProfile profile(cell);
+        m_list.liveCells.append(profile);
     }
 
@@ -87 +85 @@
             // FIXME: This const_cast exists because this isn't a C++ lambda.
             // https://bugs.webkit.org/show_bug.cgi?id=159644
-            const_cast<GatherLiveObjFunctor*>(this)->visit(static_cast<JSCell*>(cell));
+            const_cast<GatherCellFunctor*>(this)->visit(static_cast<JSCell*>(cell));
         }
         return IterationStatus::Continue;
     }
 
-    LiveObjectList& m_list;
+    CellList& m_list;
 };
 
-void HeapVerifier::gatherLiveObjects(HeapVerifier::Phase phase)
+void HeapVerifier::gatherLiveCells(HeapVerifier::Phase phase)
 {
     Heap* heap = m_heap;
-    LiveObjectList& list = *liveObjectListForGathering(phase);
+    CellList& list = *cellListForGathering(phase);
 
     HeapIterationScope iterationScope(*heap);
     list.reset();
-    GatherLiveObjFunctor functor(list);
+    GatherCellFunctor functor(list);
     heap->m_objectSpace.forEachLiveCell(iterationScope, functor);
 }
 
-LiveObjectList* HeapVerifier::liveObjectListForGathering(HeapVerifier::Phase phase)
+CellList* HeapVerifier::cellListForGathering(HeapVerifier::Phase phase)
 {
     switch (phase) {
@@ -115 +113 @@
     case Phase::BeforeGC:
     case Phase::AfterGC:
-        // We should not be gathering live objects during these phases.
+        // We should not be gathering live cells during these phases.
         break;
     }
@@ -122 +120 @@
 }
 
-static void trimDeadObjectsFromList(HashSet<JSObject*>& knownLiveSet, LiveObjectList& list)
-{
-    if (!list.hasLiveObjects)
+static void trimDeadCellsFromList(HashSet<JSCell*>& knownLiveSet, CellList& list)
+{
+    if (!list.hasLiveCells)
         return;
 
-    size_t liveObjectsFound = 0;
-    for (auto& objData : list.liveObjects) {
-        if (objData.isConfirmedDead)
-            continue; // Don't "resurrect" known dead objects.
-        if (!knownLiveSet.contains(objData.obj)) {
-            objData.isConfirmedDead = true;
+    size_t liveCellsFound = 0;
+    for (auto& cellProfile : list.liveCells) {
+        if (cellProfile.isConfirmedDead)
+            continue; // Don't "resurrect" known dead cells.
+        if (!knownLiveSet.contains(cellProfile.cell)) {
+            cellProfile.isConfirmedDead = true;
             continue;
         }
-        liveObjectsFound++;
-    }
-    list.hasLiveObjects = !!liveObjectsFound;
-}
-
-void HeapVerifier::trimDeadObjects()
-{
-    HashSet<JSObject*> knownLiveSet;
-
-    LiveObjectList& after = currentCycle().after;
-    for (auto& objData : after.liveObjects)
-        knownLiveSet.add(objData.obj);
-
-    trimDeadObjectsFromList(knownLiveSet, currentCycle().before);
+        liveCellsFound++;
+    }
+    list.hasLiveCells = !!liveCellsFound;
+}
+
+void HeapVerifier::trimDeadCells()
+{
+    HashSet<JSCell*> knownLiveSet;
+
+    CellList& after = currentCycle().after;
+    for (auto& cellProfile : after.liveCells)
+        knownLiveSet.add(cellProfile.cell);
+
+    trimDeadCellsFromList(knownLiveSet, currentCycle().before);
 
     for (int i = -1; i > -m_numberOfCycles; i--) {
-        trimDeadObjectsFromList(knownLiveSet, cycleForIndex(i).before);
-        trimDeadObjectsFromList(knownLiveSet, cycleForIndex(i).after);
-    }
-}
-
-bool HeapVerifier::verifyButterflyIsInStorageSpace(Phase, LiveObjectList&)
+        trimDeadCellsFromList(knownLiveSet, cycleForIndex(i).before);
+        trimDeadCellsFromList(knownLiveSet, cycleForIndex(i).after);
+    }
+}
+
+bool HeapVerifier::verifyButterflyIsInStorageSpace(Phase, CellList&)
 {
     // FIXME: Make this work again. https://bugs.webkit.org/show_bug.cgi?id=161752
@@ -169 +167 @@
 }
 
-void HeapVerifier::reportObject(LiveObjectData& objData, int cycleIndex, HeapVerifier::GCCycle& cycle, LiveObjectList& list)
-{
-    JSObject* obj = objData.obj;
-
-    if (objData.isConfirmedDead) {
-        dataLogF("FOUND dead obj %p in GC[%d] %s list '%s'\n",
-            obj, cycleIndex, collectionScopeName(cycle.scope), list.name);
+void HeapVerifier::reportCell(CellProfile& cellProfile, int cycleIndex, HeapVerifier::GCCycle& cycle, CellList& list)
+{
+    JSCell* cell = cellProfile.cell;
+
+    if (cellProfile.isConfirmedDead) {
+        dataLogF("FOUND dead cell %p in GC[%d] %s list '%s'\n",
+            cell, cycleIndex, collectionScopeName(cycle.scope), list.name);
         return;
     }
 
-    Structure* structure = obj->structure();
-    Butterfly* butterfly = obj->butterfly();
-    void* butterflyBase = butterfly->base(structure);
-
-    dataLogF("FOUND obj %p type '%s' butterfly %p (base %p) in GC[%d] %s list '%s'\n",
-        obj, structure->classInfo()->className,
-        butterfly, butterflyBase,
-        cycleIndex, collectionScopeName(cycle.scope), list.name);
-}
-
-void HeapVerifier::checkIfRecorded(JSObject* obj)
+    if (cell->isObject()) {
+        JSObject* object = static_cast<JSObject*>(cell);
+        Structure* structure = object->structure();
+        Butterfly* butterfly = object->butterfly();
+        void* butterflyBase = butterfly->base(structure);
+
+        dataLogF("FOUND object %p type '%s' butterfly %p (base %p) in GC[%d] %s list '%s'\n",
+            object, structure->classInfo()->className,
+            butterfly, butterflyBase,
+            cycleIndex, collectionScopeName(cycle.scope), list.name);
+    } else {
+        Structure* structure = cell->structure();
+        dataLogF("FOUND cell %p type '%s' in GC[%d] %s list '%s'\n",
+            cell, structure->classInfo()->className,
+            cycleIndex, collectionScopeName(cycle.scope), list.name);
+    }
+}
+
+void HeapVerifier::checkIfRecorded(JSCell* cell)
 {
     bool found = false;
@@ -195 +201 @@
     for (int cycleIndex = 0; cycleIndex > -m_numberOfCycles; cycleIndex--) {
         GCCycle& cycle = cycleForIndex(cycleIndex);
-        LiveObjectList& beforeList = cycle.before; 
-        LiveObjectList& afterList = cycle.after; 
-
-        LiveObjectData* objData;
-        objData = beforeList.findObject(obj);
-        if (objData) {
-            reportObject(*objData, cycleIndex, cycle, beforeList);
+        CellList& beforeList = cycle.before;
+        CellList& afterList = cycle.after;
+
+        CellProfile* profile;
+        profile = beforeList.findCell(cell);
+        if (profile) {
+            reportCell(*profile, cycleIndex, cycle, beforeList);
             found = true;
         }
-        objData = afterList.findObject(obj);
-        if (objData) {
-            reportObject(*objData, cycleIndex, cycle, afterList);
+        profile = afterList.findCell(cell);
+        if (profile) {
+            reportCell(*profile, cycleIndex, cycle, afterList);
             found = true;
         }
@@ -212 +218 @@
 
     if (!found)
-        dataLogF("obj %p NOT FOUND\n", obj);
+        dataLogF("cell %p NOT FOUND\n", cell);
 }