Use new ASAN APIs for scanning ASAN fake stacks during garbage collection.

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 224 matching lines @@
     , m_atSafePoint(false)
     , m_interruptors()
     , m_gcRequested(false)
     , m_forcePreciseGCForTesting(false)
     , m_sweepRequested(0)
     , m_sweepInProgress(false)
     , m_noAllocationCount(0)
     , m_inGC(false)
     , m_heapContainsCache(adoptPtr(new HeapContainsCache()))
     , m_isCleaningUp(false)
+#if defined(ADDRESS_SANITIZER) && !OS(WIN)
+    , m_asanFakeStack(__asan_get_current_fake_stack())
+#endif
 {
     ASSERT(!**s_threadSpecific);
     **s_threadSpecific = this;
 
     m_stats.clear();
     m_statsAfterLastGC.clear();
     // First allocate the general heap, second iterate through to
     // allocate the type specific heaps
     m_heaps[GeneralHeap] = new ThreadHeap<FinalizedHeapObjectHeader>(this);
     for (int i = GeneralHeap + 1; i < NumberOfHeaps; i++)
@@ skipping 82 matching lines @@
         MutexLocker locker(globalRootsMutex());
         globalRoots()->trace(visitor);
     }
 
     AttachedThreadStateSet& threads = attachedThreads();
     for (AttachedThreadStateSet::iterator it = threads.begin(), end = threads.end(); it != end; ++it)
         (*it)->trace(visitor);
 }
 
 NO_SANITIZE_ADDRESS
+void ThreadState::visitAsanFakeStackForPointer(Visitor* visitor, Address ptr)
+{
+#if defined(ADDRESS_SANITIZER) && !OS(WIN)
+    Address* start = reinterpret_cast<Address*>(m_startOfStack);
+    Address* end = reinterpret_cast<Address*>(m_endOfStack);
+    Address* fakeFrameStart = 0;
+    Address* fakeFrameEnd = 0;
+    Address* maybeFakeFrame = reinterpret_cast<Address*>(ptr);
+    Address* realFrameForFakeFrame =
+        reinterpret_cast<Address*>(
+            __asan_addr_is_in_fake_stack(
+                m_asanFakeStack, maybeFakeFrame,
+                reinterpret_cast<void**>(&fakeFrameStart),
+                reinterpret_cast<void**>(&fakeFrameEnd)));
+    if (realFrameForFakeFrame) {
+        // This is a fake frame from the asan fake stack.
+        if (realFrameForFakeFrame > end && start > realFrameForFakeFrame) {
+            // The real stack address for the asan fake frame is
+            // within the stack range that we need to scan so we need
+            // to visit the values in the fake frame.
+            for (Address* p = fakeFrameStart; p < fakeFrameEnd; p++)
+                Heap::checkAndMarkPointer(visitor, *p);
+        }
+    }
+#endif
+}
+
+NO_SANITIZE_ADDRESS
 void ThreadState::visitStack(Visitor* visitor)
 {
     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;
 
     // Ensure that current is aligned by address size otherwise the loop below
     // will read past start address.
     current = reinterpret_cast<Address*>(reinterpret_cast<intptr_t>(current) & ~(sizeof(Address) - 1));
 
-    for (; current < start; ++current)
+    for (; current < start; ++current) {
         Heap::checkAndMarkPointer(visitor, *current);
+        visitAsanFakeStackForPointer(visitor, *current);
+    }
 
-    for (Vector<Address>::iterator it = m_safePointStackCopy.begin(); it != m_safePointStackCopy.end(); ++it)
+    for (Vector<Address>::iterator it = m_safePointStackCopy.begin(); it != m_safePointStackCopy.end(); ++it) {
         Heap::checkAndMarkPointer(visitor, *it);
+        visitAsanFakeStackForPointer(visitor, *it);
+    }
 }
 
 void ThreadState::visitPersistents(Visitor* visitor)
 {
     m_persistents->trace(visitor);
 }
 
 void ThreadState::trace(Visitor* visitor)
 {
     if (m_stackState == HeapPointersOnStack)
@@ skipping 359 matching lines @@
     state->safePoint(HeapPointersOnStack);
 }
 
 ThreadState::AttachedThreadStateSet& ThreadState::attachedThreads()
 {
     DEFINE_STATIC_LOCAL(AttachedThreadStateSet, threads, ());
     return threads;
 }
 
 }