Make |Heap::findGCInfo()| threadsafe.

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 78 matching lines @@
 #error Unsupported getStackStart on this platform.
 #endif
 }
 
 
 WTF::ThreadSpecific<ThreadState*>* ThreadState::s_threadSpecific = 0;
 uint8_t ThreadState::s_mainThreadStateStorage[sizeof(ThreadState)];
 SafePointBarrier* ThreadState::s_safePointBarrier = 0;
 bool ThreadState::s_inGC = false;
 
-static Mutex& threadAttachMutex()
+Mutex& ThreadState::threadAttachMutex()
 {
     AtomicallyInitializedStatic(Mutex&, mutex = *new Mutex);
     return mutex;
 }
 
 static double lockingTimeout()
 {
     // Wait time for parking all threads is at most 500 MS.
     return 0.100;
 }
 
 
 typedef void (*PushAllRegistersCallback)(SafePointBarrier*, ThreadState*, intptr_t*);
 extern "C" void pushAllRegisters(SafePointBarrier*, ThreadState*, PushAllRegistersCallback);
 
 class SafePointBarrier {
 public:
     SafePointBarrier() : m_canResume(1), m_unparkedThreadCount(0) { }
     ~SafePointBarrier() { }
 
     // Request other attached threads that are not at safe points to park themselves on safepoints.
     bool parkOthers()
     {
         ASSERT(ThreadState::current()->isAtSafePoint());
 
         // Lock threadAttachMutex() to prevent threads from attaching.
-        threadAttachMutex().lock();
+        ThreadState::threadAttachMutex().lock();
 
         ThreadState::AttachedThreadStateSet& threads = ThreadState::attachedThreads();
 
         MutexLocker locker(m_mutex);
         atomicAdd(&m_unparkedThreadCount, threads.size());
         releaseStore(&m_canResume, 0);
 
         ThreadState* current = ThreadState::current();
         for (ThreadState::AttachedThreadStateSet::iterator it = threads.begin(), end = threads.end(); it != end; ++it) {
             if (*it == current)
@@ skipping 38 matching lines @@
         ThreadState* current = ThreadState::current();
         for (ThreadState::AttachedThreadStateSet::iterator it = threads.begin(), end = threads.end(); it != end; ++it) {
             if (*it == current)
                 continue;
 
             const Vector<ThreadState::Interruptor*>& interruptors = (*it)->interruptors();
             for (size_t i = 0; i < interruptors.size(); i++)
                 interruptors[i]->clearInterrupt();
         }
 
-        threadAttachMutex().unlock();
+        ThreadState::threadAttachMutex().unlock();
         ASSERT(ThreadState::current()->isAtSafePoint());
     }
 
     void checkAndPark(ThreadState* state)
     {
         ASSERT(!state->isSweepInProgress());
         if (!acquireLoad(&m_canResume)) {
             pushAllRegisters(this, state, parkAfterPushRegisters);
             state->performPendingSweep();
         }
@@ skipping 112 matching lines @@
 {
     delete s_safePointBarrier;
     s_safePointBarrier = 0;
 
     // Thread-local storage shouldn't be disposed, so we don't call ~ThreadSpecific().
 }
 
 void ThreadState::attachMainThread()
 {
     RELEASE_ASSERT(!Heap::s_shutdownCalled);
-    MutexLocker locker(threadAttachMutex());
+    MutexLocker locker(ThreadState::threadAttachMutex());
     ThreadState* state = new(s_mainThreadStateStorage) ThreadState();
     attachedThreads().add(state);
 }
 
 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();
     if (!state->isAtSafePoint())
         state->enterSafePointWithoutPointers();
 
     {
-        MutexLocker locker(threadAttachMutex());
+        MutexLocker locker(ThreadState::threadAttachMutex());
         state->leaveSafePoint();
         ASSERT(attachedThreads().contains(state));
         attachedThreads().remove(state);
         state->~ThreadState();
     }
     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());
+    MutexLocker locker(ThreadState::threadAttachMutex());
     // We start shutting down the heap if there is no running thread
     // and Heap::shutdown() is already called.
     if (!attachedThreads().size() && Heap::s_shutdownCalled)
         Heap::doShutdown();
 }
 
 void ThreadState::attach()
 {
     RELEASE_ASSERT(!Heap::s_shutdownCalled);
-    MutexLocker locker(threadAttachMutex());
+    MutexLocker locker(ThreadState::threadAttachMutex());
     ThreadState* state = new ThreadState();
     attachedThreads().add(state);
 }
 
 void ThreadState::cleanup()
 {
     // From here on ignore all conservatively discovered
     // pointers into the heap owned by this thread.
     m_isCleaningUp = true;
 
@@ skipping 21 matching lines @@
     state->cleanup();
 
     // 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.
     if (!state->isAtSafePoint())
         state->enterSafePointWithoutPointers();
 
     {
-        MutexLocker locker(threadAttachMutex());
+        MutexLocker locker(ThreadState::threadAttachMutex());
         state->leaveSafePoint();
         ASSERT(attachedThreads().contains(state));
         attachedThreads().remove(state);
         delete state;
     }
     shutdownHeapIfNecessary();
 }
 
 void ThreadState::visitRoots(Visitor* visitor)
 {
@@ skipping 442 matching lines @@
 
     if (isMainThread())
         TRACE_EVENT_SET_NONCONST_SAMPLING_STATE(samplingState);
 }
 
 void ThreadState::addInterruptor(Interruptor* interruptor)
 {
     SafePointScope scope(HeapPointersOnStack, SafePointScope::AllowNesting);
 
     {
-        MutexLocker locker(threadAttachMutex());
+        MutexLocker locker(ThreadState::threadAttachMutex());
         m_interruptors.append(interruptor);
     }
 }
 
 void ThreadState::removeInterruptor(Interruptor* interruptor)
 {
     SafePointScope scope(HeapPointersOnStack, SafePointScope::AllowNesting);
 
     {
-        MutexLocker locker(threadAttachMutex());
+        MutexLocker locker(ThreadState::threadAttachMutex());
         size_t index = m_interruptors.find(interruptor);
         RELEASE_ASSERT(index >= 0);
         m_interruptors.remove(index);
     }
 }
 
 void ThreadState::Interruptor::onInterrupted()
 {
     ThreadState* state = ThreadState::current();
     ASSERT(state);
     ASSERT(!state->isAtSafePoint());
     state->safePoint(HeapPointersOnStack);
 }
 
 ThreadState::AttachedThreadStateSet& ThreadState::attachedThreads()
 {
     DEFINE_STATIC_LOCAL(AttachedThreadStateSet, threads, ());
     return threads;
 }
 
 }