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

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 222 matching lines @@
     , m_endOfStack(reinterpret_cast<intptr_t*>(getStackStart()))
     , m_safePointScopeMarker(0)
     , m_atSafePoint(false)
     , m_interruptors()
     , m_gcRequested(false)
     , m_sweepRequested(0)
     , m_sweepInProgress(false)
     , m_noAllocationCount(0)
     , m_inGC(false)
     , m_heapContainsCache(new HeapContainsCache())
+#if defined(ADDRESS_SANITIZER) && !OS(WIN)
+    , m_asanFakeStack(__asan_get_current_fake_stack())
+#endif
 {
     ASSERT(!**s_threadSpecific);
     **s_threadSpecific = this;
 
     m_persistents = new PersistentAnchor();
     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);
@@ skipping 47 matching lines @@
     delete state;
 }
 
 void ThreadState::visitRoots(Visitor* visitor)
 {
     AttachedThreadStateSet& threads = attachedThreads();
     for (AttachedThreadStateSet::iterator it = threads.begin(), end = threads.end(); it != end; ++it)
         (*it)->trace(visitor);
 }
 
+#if defined(ADDRESS_SANITIZER) && !OS(WIN)
+NO_SANITIZE_ADDRESS

[kcc1, 2014/02/06 13:44:06]

I'd put #ifdef inside the function body, this will get rid of most other ifdefs.
But that's up to you

[Mads Ager (chromium), 2014/02/06 14:15:17]

Good idea. Done!

+void ThreadState::visitAsanFakeStackForPointer(Visitor* visitor, Address ptr)
+{
+    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* end = reinterpret_cast<Address*>(m_startOfStack);
     for (Address* current = reinterpret_cast<Address*>(m_endOfStack); current < end; ++current) {
         Heap::checkAndMarkPointer(visitor, *current);
+#if defined(ADDRESS_SANITIZER) && !OS(WIN)
+        visitAsanFakeStackForPointer(visitor, *current);
+#endif
     }
 
-    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);
+#if defined(ADDRESS_SANITIZER) && !OS(WIN)
+        visitAsanFakeStackForPointer(visitor, *it);
+#endif
+    }
 }
 
 void ThreadState::visitPersistents(Visitor* visitor)
 {
     for (PersistentNode* current = m_persistents->m_next; current != m_persistents; current = current->m_next) {
         current->trace(visitor);
     }
 }
 
 void ThreadState::trace(Visitor* visitor)
@@ skipping 307 matching lines @@
     state->safePoint(HeapPointersOnStack);
 }
 
 ThreadState::AttachedThreadStateSet& ThreadState::attachedThreads()
 {
     DEFINE_STATIC_LOCAL(AttachedThreadStateSet, threads, ());
     return threads;
 }
 
 }