Revert of Revert "Revert of [oilpan]: Change marking to do precise roots first and conservative

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 428 matching lines @@
 
 
 void ThreadState::detach()
 {
     ThreadState* state = current();
     state->cleanup();
     delete state;
     shutdownHeapIfNecessary();
 }
 
-void ThreadState::visitPersistentRoots(Visitor* visitor)
+void ThreadState::visitRoots(Visitor* visitor)
 {
     {
         // All threads are at safepoints so this is not strictly necessary.
         // However we acquire the mutex to make mutation and traversal of this
         // list symmetrical.
         MutexLocker locker(globalRootsMutex());
         globalRoots()->trace(visitor);
     }
 
     AttachedThreadStateSet& threads = attachedThreads();
     for (AttachedThreadStateSet::iterator it = threads.begin(), end = threads.end(); it != end; ++it)
-        (*it)->visitPersistents(visitor);
+        (*it)->trace(visitor);
 }
 
-void ThreadState::visitStackRoots(Visitor* visitor)
+void ThreadState::visitLocalRoots(Visitor* visitor)
 {
-    AttachedThreadStateSet& threads = attachedThreads();
-    for (AttachedThreadStateSet::iterator it = threads.begin(), end = threads.end(); it != end; ++it)
-        (*it)->visitStack(visitor);
+    // We assume that orphaned pages have no objects reachable from persistent
+    // handles on other threads or CrossThreadPersistents. The only cases where
+    // this could happen is if a global conservative GC finds a "pointer" on
+    // the stack or due to a programming error where an object has a dangling
+    // cross-thread pointer to an object on this heap.
+    m_persistents->trace(visitor);
 }
 
 NO_SANITIZE_ADDRESS
 void ThreadState::visitAsanFakeStackForPointer(Visitor* visitor, Address ptr)
 {
 #if defined(ADDRESS_SANITIZER)
     Address* start = reinterpret_cast<Address*>(m_startOfStack);
     Address* end = reinterpret_cast<Address*>(m_endOfStack);
     Address* fakeFrameStart = 0;
     Address* fakeFrameEnd = 0;
@@ skipping 13 matching lines @@
             for (Address* p = fakeFrameStart; p < fakeFrameEnd; p++)
                 Heap::checkAndMarkPointer(visitor, *p);
         }
     }
 #endif
 }
 
 NO_SANITIZE_ADDRESS
 void ThreadState::visitStack(Visitor* visitor)
 {
-    if (m_stackState == NoHeapPointersOnStack)
-        return;
-
     Address* start = reinterpret_cast<Address*>(m_startOfStack);
     // If there is a safepoint scope marker we should stop the stack
     // scanning there to not touch active parts of the stack. Anything
     // interesting beyond that point is in the safepoint stack copy.
     // If there is no scope marker the thread is blocked and we should
     // scan all the way to the recorded end stack pointer.
     Address* end = reinterpret_cast<Address*>(m_endOfStack);
     Address* safePointScopeMarker = reinterpret_cast<Address*>(m_safePointScopeMarker);
     Address* current = safePointScopeMarker ? safePointScopeMarker : end;
 
@@ skipping 24 matching lines @@
         Heap::checkAndMarkPointer(visitor, ptr);
         visitAsanFakeStackForPointer(visitor, ptr);
     }
 }
 
 void ThreadState::visitPersistents(Visitor* visitor)
 {
     m_persistents->trace(visitor);
 }
 
+void ThreadState::trace(Visitor* visitor)
+{
+    if (m_stackState == HeapPointersOnStack)
+        visitStack(visitor);
+    visitPersistents(visitor);
+}
+
 bool ThreadState::checkAndMarkPointer(Visitor* visitor, Address address)
 {
     // If thread is terminating ignore conservative pointers.
     if (m_isTerminating)
         return false;
 
     // This checks for normal pages and for large objects which span the extent
     // of several normal pages.
     BaseHeapPage* page = heapPageFromAddress(address);
     if (page) {
@@ skipping 404 matching lines @@
                 threadAttachMutex().unlock();
             return gcInfo;
         }
     }
     if (needLockForIteration)
         threadAttachMutex().unlock();
     return 0;
 }
 #endif
 }