Revert "Revert "[oilpan]: Make thread shutdown more robust.""

Source/platform/heap/ThreadState.h

 /*
  * 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 31 matching lines @@
 #include "wtf/Vector.h"
 
 namespace WebCore {
 
 class BaseHeap;
 class BaseHeapPage;
 class FinalizedHeapObjectHeader;
 struct GCInfo;
 class HeapContainsCache;
 class HeapObjectHeader;
+class PageMemory;
 class PersistentNode;
 class Visitor;
 class SafePointBarrier;
 class SafePointAwareMutexLocker;
 template<typename Header> class ThreadHeap;
 class CallbackStack;
 
 typedef uint8_t* Address;
 
 typedef void (*FinalizationCallback)(void*);
@@ skipping 170 matching lines @@
     // The set of ThreadStates for all threads attached to the Blink
     // garbage collector.
     typedef HashSet<ThreadState*> AttachedThreadStateSet;
     static AttachedThreadStateSet& attachedThreads();
 
     // Initialize threading infrastructure. Should be called from the main
     // thread.
     static void init();
     static void shutdown();
     static void shutdownHeapIfNecessary();
+    bool isTerminating() { return m_isTerminating; }
 
     static void attachMainThread();
     static void detachMainThread();
 
     // Trace all GC roots, called when marking the managed heap objects.
     static void visitRoots(Visitor*);
 
     // Associate ThreadState object with the current thread. After this
     // call thread can start using the garbage collected heap infrastructure.
     // It also has to periodically check for safepoints.
@@ skipping 248 matching lines @@
     static const GCInfo* findGCInfoFromAllThreads(Address);
 #endif
 
     void pushWeakObjectPointerCallback(void*, WeakPointerCallback);
     bool popAndInvokeWeakPointerCallback(Visitor*);
 
     void getStats(HeapStats&);
     HeapStats& stats() { return m_stats; }
     HeapStats& statsAfterLastGC() { return m_statsAfterLastGC; }
 
+    void setupHeapsForTermination();
+    void visitLocalRoots(Visitor*);
+
 private:
     explicit ThreadState();
     ~ThreadState();
 
     friend class SafePointBarrier;
     friend class SafePointAwareMutexLocker;
 
     void enterSafePoint(StackState, void*);
     NO_SANITIZE_ADDRESS void copyStackUntilSafePointScope();
     void clearSafePointScopeMarker()
@@ skipping 11 matching lines @@
     BaseHeapPage* heapPageFromAddress(Address);
 
     // When ThreadState is detaching from non-main thread its
     // heap is expected to be empty (because it is going away).
     // Perform registered cleanup tasks and garbage collection
     // to sweep away any objects that are left on this heap.
     // We assert that nothing must remain after this cleanup.
     // If assertion does not hold we crash as we are potentially
     // in the dangling pointer situation.
     void cleanup();
-    void preCleanup();
-    void postCleanup();
+    void cleanupPages();
 
     static WTF::ThreadSpecific<ThreadState*>* s_threadSpecific;
     static SafePointBarrier* s_safePointBarrier;
 
     // This variable is flipped to true after all threads are stoped
     // and outermost GC has started.
     static bool s_inGC;
 
     // We can't create a static member of type ThreadState here
     // because it will introduce global constructor and destructor.
@@ skipping 20 matching lines @@
     volatile int m_sweepRequested;
     bool m_sweepInProgress;
     size_t m_noAllocationCount;
     bool m_inGC;
     BaseHeap* m_heaps[NumberOfHeaps];
     OwnPtr<HeapContainsCache> m_heapContainsCache;
     HeapStats m_stats;
     HeapStats m_statsAfterLastGC;
 
     Vector<OwnPtr<CleanupTask> > m_cleanupTasks;
-    bool m_isCleaningUp;
+    bool m_isTerminating;
 
     CallbackStack* m_weakCallbackStack;
 
 #if defined(ADDRESS_SANITIZER)
     void* m_asanFakeStack;
 #endif
 };
 
 template<ThreadAffinity affinity> class ThreadStateFor;
 
@@ skipping 13 matching lines @@
 };
 
 // The SafePointAwareMutexLocker is used to enter a safepoint while waiting for
 // a mutex lock. It also ensures that the lock is not held while waiting for a GC
 // to complete in the leaveSafePoint method, by releasing the lock if the
 // leaveSafePoint method cannot complete without blocking, see
 // SafePointBarrier::checkAndPark.
 class SafePointAwareMutexLocker {
     WTF_MAKE_NONCOPYABLE(SafePointAwareMutexLocker);
 public:
-    explicit SafePointAwareMutexLocker(Mutex& mutex) : m_mutex(mutex), m_locked(false)
+    explicit SafePointAwareMutexLocker(Mutex& mutex, ThreadState::StackState stackState = ThreadState::HeapPointersOnStack)
+        : m_mutex(mutex)
+        , m_locked(false)
     {
         ThreadState* state = ThreadState::current();
         do {
             bool leaveSafePoint = false;
             // We cannot enter a safepoint if we are currently sweeping. In that
             // case we just try to acquire the lock without being at a safepoint.
             // If another thread tries to do a GC at that time it might time out
             // due to this thread not being at a safepoint and waiting on the lock.
             if (!state->isSweepInProgress() && !state->isAtSafePoint()) {
-                state->enterSafePoint(ThreadState::HeapPointersOnStack, this);
+                state->enterSafePoint(stackState, this);
                 leaveSafePoint = true;
             }
             m_mutex.lock();
             m_locked = true;
             if (leaveSafePoint) {
                 // When leaving the safepoint we might end up release the mutex
                 // if another thread is requesting a GC, see
                 // SafePointBarrier::checkAndPark. This is the case where we
                 // loop around to reacquire the lock.
                 state->leaveSafePoint(this);
@@ skipping 14 matching lines @@
     {
         ASSERT(m_locked);
         m_mutex.unlock();
         m_locked = false;
     }
 
     Mutex& m_mutex;
     bool m_locked;
 };
 
+// Common header for heap pages. Needs to be defined before class Visitor.
+class BaseHeapPage {
+public:
+    BaseHeapPage(PageMemory*, const GCInfo*, ThreadState*);
+    virtual ~BaseHeapPage() { }
+
+    // Check if the given address points to an object in this
+    // heap page. If so, find the start of that object and mark it
+    // using the given Visitor. Otherwise do nothing. The pointer must
+    // be within the same aligned blinkPageSize as the this-pointer.
+    //
+    // This is used during conservative stack scanning to
+    // conservatively mark all objects that could be referenced from
+    // the stack.
+    virtual void checkAndMarkPointer(Visitor*, Address) = 0;
+    virtual bool contains(Address) = 0;
+
+#if ENABLE(GC_TRACING)
+    virtual const GCInfo* findGCInfo(Address) = 0;
+#endif
+
+    Address address() { return reinterpret_cast<Address>(this); }
+    PageMemory* storage() const { return m_storage; }
+    ThreadState* threadState() const { return m_threadState; }
+    const GCInfo* gcInfo() { return m_gcInfo; }
+    virtual bool isLargeObject() { return false; }
+    virtual void markOrphaned()
+    {
+        m_threadState = 0;
+        m_gcInfo = 0;
+        m_terminating = false;
+        m_tracedAfterOrphaned = false;
+    }
+    bool orphaned() { return !m_threadState; }
+    bool terminating() { return m_terminating; }
+    void setTerminating() { m_terminating = true; }
+    bool tracedAfterOrphaned() { return m_tracedAfterOrphaned; }
+    void setTracedAfterOrphaned() { m_tracedAfterOrphaned = true; }
+
+private:
+    PageMemory* m_storage;
+    const GCInfo* m_gcInfo;
+    ThreadState* m_threadState;
+    // Pointer sized integer to ensure proper alignment of the
+    // HeapPage header. We use some of the bits to determine
+    // whether the page is part of a terminting thread or
+    // if the page is traced after being terminated (orphaned).
+    uintptr_t m_terminating : 1;
+    uintptr_t m_tracedAfterOrphaned : 1;
+};
+
 }
 
 #endif // ThreadState_h