Do not scan the active part of the stack in oilpan conservative garbage collections.

Source/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 292 matching lines @@
 void ThreadState::visitRoots(Visitor* visitor)
 {
     AttachedThreadStateSet& threads = attachedThreads();
     for (AttachedThreadStateSet::iterator it = threads.begin(), end = threads.end(); it != end; ++it)
         (*it)->trace(visitor);
 }
 
 NO_SANITIZE_ADDRESS
 void ThreadState::visitStack(Visitor* visitor)
 {
-    Address* end = reinterpret_cast<Address*>(m_startOfStack);
-    for (Address* current = reinterpret_cast<Address*>(m_endOfStack); current < end; ++current) {
+    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;
+    for (; current < start; ++current) {
         Heap::checkAndMarkPointer(visitor, *current);
     }
 
     for (Vector<Address>::iterator it = m_safePointStackCopy.begin(); it != m_safePointStackCopy.end(); ++it)
         Heap::checkAndMarkPointer(visitor, *it);
 }
 
 void ThreadState::visitPersistents(Visitor* visitor)
 {
     for (PersistentNode* current = m_persistents->m_next; current != m_persistents; current = current->m_next) {
@@ skipping 312 matching lines @@
     state->safePoint(HeapPointersOnStack);
 }
 
 ThreadState::AttachedThreadStateSet& ThreadState::attachedThreads()
 {
     DEFINE_STATIC_LOCAL(AttachedThreadStateSet, threads, ());
     return threads;
 }
 
 }