Oilpan: catch some self-referential leaks (main thread.)

Source/platform/heap/ThreadState.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 58 matching lines @@
 #include <pthread_np.h>
 #endif
 
 namespace blink {
 
 WTF::ThreadSpecific<ThreadState*>* ThreadState::s_threadSpecific = nullptr;
 uintptr_t ThreadState::s_mainThreadStackStart = 0;
 uintptr_t ThreadState::s_mainThreadUnderestimatedStackSize = 0;
 uint8_t ThreadState::s_mainThreadStateStorage[sizeof(ThreadState)];
 SafePointBarrier* ThreadState::s_safePointBarrier = nullptr;
+#if ENABLE(ASSERT)
+int ThreadState::s_selfKeepAliveAllocationsOnMainThread = 0;
+#endif
 
 RecursiveMutex& ThreadState::threadAttachMutex()
 {
     AtomicallyInitializedStaticReference(RecursiveMutex, mutex, (new RecursiveMutex));
     return mutex;
 }
 
 ThreadState::ThreadState()
     : m_thread(currentThread())
     , m_persistentRegion(adoptPtr(new PersistentRegion()))
@@ skipping 70 matching lines @@
 
     // Thread-local storage shouldn't be disposed, so we don't call ~ThreadSpecific().
 }
 
 void ThreadState::attachMainThread()
 {
     RELEASE_ASSERT(!Heap::s_shutdownCalled);
     MutexLocker locker(threadAttachMutex());
     ThreadState* state = new(s_mainThreadStateStorage) ThreadState();
     attachedThreads().add(state);
+#if ENABLE(ASSERT)
+    s_selfKeepAliveAllocationsOnMainThread = 0;
+#endif
 }
 
 void ThreadState::detachMainThread()
 {
     // Enter a safe point before trying to acquire threadAttachMutex
     // to avoid dead lock if another thread is preparing for GC, has acquired
     // threadAttachMutex and waiting for other threads to pause or reach a
     // safepoint.
     ThreadState* state = mainThreadState();
 
     // 1. Finish sweeping.
     state->completeSweep();
     {
         SafePointAwareMutexLocker locker(threadAttachMutex(), NoHeapPointersOnStack);
 
         // 2. Add the main thread's heap pages to the orphaned pool.
         state->cleanupPages();
 
         // 3. Detach the main thread.
         ASSERT(attachedThreads().contains(state));
         attachedThreads().remove(state);
         state->~ThreadState();
     }
+    // Catch out any self-referential leaks created by the main thread.
+    ASSERT(s_selfKeepAliveAllocationsOnMainThread == 0);
     shutdownHeapIfNecessary();
 }
 
 void ThreadState::shutdownHeapIfNecessary()
 {
     // We don't need to enter a safe point before acquiring threadAttachMutex
     // because this thread is already detached.
 
     MutexLocker locker(threadAttachMutex());
     // We start shutting down the heap if there is no running thread
@@ skipping 48 matching lines @@
         int oldCount = -1;
         int currentCount = persistentRegion()->numberOfPersistents();
         ASSERT(currentCount >= 0);
         while (currentCount != oldCount) {
             Heap::collectGarbageForTerminatingThread(this);
             oldCount = currentCount;
             currentCount = persistentRegion()->numberOfPersistents();
         }
         // We should not have any persistents left when getting to this point,
         // if we have it is probably a bug so adding a debug ASSERT to catch this.
-        ASSERT(!currentCount);
+        // (debug tip: use persistentRegion()->dumpLivePersistents() to get a list of
+        // the remaining live Persistent<>s. In gdb, performing "info symbol" on the
+        // trace callback addresses printed should tell you what Persistent<T>s are leaking.)
+        ASSERT(!currentCount && "Persistent<>s leak on thread heap shutdown");
         // All of pre-finalizers should be consumed.
         ASSERT(m_orderedPreFinalizers.isEmpty());
         RELEASE_ASSERT(gcState() == NoGCScheduled);
 
         // Add pages to the orphaned page pool to ensure any global GCs from this point
         // on will not trace objects on this thread's heaps.
         cleanupPages();
 
         ASSERT(attachedThreads().contains(this));
         attachedThreads().remove(this);
@@ skipping 1264 matching lines @@
     for (ClassAgeCountsMap::const_iterator it = classAgeCounts.begin(), end = classAgeCounts.end(); it != end; ++it) {
         json->beginArray(it->key.ascii().data());
         for (size_t age = 0; age <= maxHeapObjectAge; ++age)
             json->pushInteger(it->value.ages[age]);
         json->endArray();
     }
     TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(TRACE_DISABLED_BY_DEFAULT("blink_gc"), statsName, this, json.release());
 }
 #endif
 
+#if ENABLE(ASSERT)
+void ThreadState::incrementSelfKeepAliveAllocations()
+{
+    if (!ThreadState::current()->isMainThread())
+        return;
+
+    s_selfKeepAliveAllocationsOnMainThread++;
+}
+
+void ThreadState::decrementSelfKeepAliveAllocations()
+{
+    if (!ThreadState::current()->isMainThread())
+        return;
+
+    ASSERT(s_selfKeepAliveAllocationsOnMainThread > 0);
+    s_selfKeepAliveAllocationsOnMainThread--;
+}
+#endif
+
 } // namespace blink