Various ASan exemptions to allow Oilpan pre-sweep poisoning of unmarkeds.

Source/platform/Timer.cpp

 /*
  * Copyright (C) 2006, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2009 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 11 matching lines @@
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "platform/Timer.h"
 
 #include "platform/PlatformThreadData.h"
 #include "platform/ThreadTimers.h"
+#include "platform/heap/AddressSanitizer.h"
 #include "wtf/Atomics.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/HashSet.h"
 #include <algorithm>
 #include <limits.h>
 #include <limits>
 #include <math.h>
 
 namespace blink {
 
@@ skipping 28 matching lines @@
     TimerHeapReference& operator=(TimerHeapReference);
 private:
     TimerBase*& m_reference;
 };
 
 inline TimerHeapReference TimerHeapPointer::operator*() const
 {
     return *m_pointer;
 }
 
+NO_LAZY_SWEEP_SANITIZE_ADDRESS
 inline TimerHeapReference& TimerHeapReference::operator=(TimerBase* timer)
 {
     m_reference = timer;
     Vector<TimerBase*>& heap = timer->timerHeap();
     if (&m_reference >= heap.data() && &m_reference < heap.data() + heap.size())
         timer->m_heapIndex = &m_reference - heap.data();
     return *this;
 }
 
+NO_LAZY_SWEEP_SANITIZE_ADDRESS
 inline TimerHeapReference& TimerHeapReference::operator=(TimerHeapReference b)
 {
     TimerBase* timer = b;
     return *this = timer;
 }
 
 inline void swap(TimerHeapReference a, TimerHeapReference b)
 {
     TimerBase* timerA = a;
     TimerBase* timerB = b;
@@ skipping 62 matching lines @@
 inline TimerHeapIterator operator-(TimerHeapIterator a, size_t b) { return TimerHeapIterator(a.m_pointer - b); }
 inline ptrdiff_t operator-(TimerHeapIterator a, TimerHeapIterator b) { return a.m_pointer - b.m_pointer; }
 
 // ----------------
 
 class TimerHeapLessThanFunction {
 public:
     bool operator()(const TimerBase*, const TimerBase*) const;
 };
 
+NO_LAZY_SWEEP_SANITIZE_ADDRESS
 inline bool TimerHeapLessThanFunction::operator()(const TimerBase* a, const TimerBase* b) const
 {
     // The comparisons below are "backwards" because the heap puts the largest
     // element first and we want the lowest time to be the first one in the heap.
     double aFireTime = a->m_nextFireTime;
     double bFireTime = b->m_nextFireTime;
     if (bFireTime != aFireTime)
         return bFireTime < aFireTime;
 
     // We need to look at the difference of the insertion orders instead of comparing the two
@@ skipping 102 matching lines @@
 }
 
 inline void TimerBase::heapInsert()
 {
     ASSERT(!inHeap());
     timerHeap().append(this);
     m_heapIndex = timerHeap().size() - 1;
     heapDecreaseKey();
 }
 
+NO_LAZY_SWEEP_SANITIZE_ADDRESS
 inline void TimerBase::heapPop()
 {
     // Temporarily force this timer to have the minimum key so we can pop it.
     double fireTime = m_nextFireTime;
     m_nextFireTime = -std::numeric_limits<double>::infinity();
     heapDecreaseKey();
     heapPopMin();
     m_nextFireTime = fireTime;
 }
 
@@ skipping 97 matching lines @@
     setNextFireTime(m_unalignedNextFireTime);
 }
 
 double TimerBase::nextUnalignedFireInterval() const
 {
     ASSERT(isActive());
     return std::max(m_unalignedNextFireTime - monotonicallyIncreasingTime(), 0.0);
 }
 
 } // namespace blink