Oilpan: more lazy sweep ASan exemptions.

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 109 matching lines @@
     TimerHeapIterator operator--(int) { checkConsistency(-1); return TimerHeapIterator(m_pointer--); }
 
     TimerHeapIterator& operator+=(ptrdiff_t i) { checkConsistency(); m_pointer += i; checkConsistency(); return *this; }
     TimerHeapIterator& operator-=(ptrdiff_t i) { checkConsistency(); m_pointer -= i; checkConsistency(); return *this; }
 
     TimerHeapReference operator*() const { return TimerHeapReference(*m_pointer); }
     TimerHeapReference operator[](ptrdiff_t i) const { return TimerHeapReference(m_pointer[i]); }
     TimerBase* operator->() const { return *m_pointer; }
 
 private:
+    NO_LAZY_SWEEP_SANITIZE_ADDRESS
     void checkConsistency(ptrdiff_t offset = 0) const
     {
         ASSERT(m_pointer >= threadGlobalTimerHeap().data());
         ASSERT(m_pointer <= threadGlobalTimerHeap().data() + threadGlobalTimerHeap().size());
         ASSERT_UNUSED(offset, m_pointer + offset >= threadGlobalTimerHeap().data());
         ASSERT_UNUSED(offset, m_pointer + offset <= threadGlobalTimerHeap().data() + threadGlobalTimerHeap().size());
     }
 
     friend bool operator==(TimerHeapIterator, TimerHeapIterator);
     friend bool operator!=(TimerHeapIterator, TimerHeapIterator);
@@ skipping 90 matching lines @@
 
 double TimerBase::nextFireInterval() const
 {
     ASSERT(isActive());
     double current = monotonicallyIncreasingTime();
     if (m_nextFireTime < current)
         return 0;
     return m_nextFireTime - current;
 }
 
+NO_LAZY_SWEEP_SANITIZE_ADDRESS
 inline void TimerBase::checkHeapIndex() const
 {
     ASSERT(timerHeap() == threadGlobalTimerHeap());
     ASSERT(!timerHeap().isEmpty());
     ASSERT(m_heapIndex >= 0);
     ASSERT(m_heapIndex < static_cast<int>(timerHeap().size()));
     ASSERT(timerHeap()[m_heapIndex] == this);
 }
 
 inline void TimerBase::checkConsistency() const
 {
     // Timers should be in the heap if and only if they have a non-zero next fire time.
     ASSERT(inHeap() == (m_nextFireTime != 0));
     if (inHeap())
         checkHeapIndex();
 }
 
 void TimerBase::heapDecreaseKey()
 {
     ASSERT(m_nextFireTime != 0);
     checkHeapIndex();
     TimerBase** heapData = timerHeap().data();
     push_heap(TimerHeapIterator(heapData), TimerHeapIterator(heapData + m_heapIndex + 1), TimerHeapLessThanFunction());
     checkHeapIndex();
 }
 
+NO_LAZY_SWEEP_SANITIZE_ADDRESS
 inline void TimerBase::heapDelete()
 {
     ASSERT(m_nextFireTime == 0);
     heapPop();
     timerHeap().removeLast();
     m_heapIndex = -1;
 }
 
+NO_LAZY_SWEEP_SANITIZE_ADDRESS
 void TimerBase::heapDeleteMin()
 {
     ASSERT(m_nextFireTime == 0);
     heapPopMin();
     timerHeap().removeLast();
     m_heapIndex = -1;
 }
 
 inline void TimerBase::heapIncreaseKey()
 {
@@ skipping 14 matching lines @@
 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;
 }
 
+NO_LAZY_SWEEP_SANITIZE_ADDRESS
 void TimerBase::heapPopMin()
 {
     ASSERT(this == timerHeap().first());
     checkHeapIndex();
     Vector<TimerBase*>& heap = timerHeap();
     TimerBase** heapData = heap.data();
     pop_heap(TimerHeapIterator(heapData), TimerHeapIterator(heapData + heap.size()), TimerHeapLessThanFunction());
     checkHeapIndex();
     ASSERT(this == timerHeap().last());
 }
@@ skipping 43 matching lines @@
     else if (!m_nextFireTime)
         heapDelete();
     else if (m_nextFireTime < oldTime)
         heapDecreaseKey();
     else
         heapIncreaseKey();
     ASSERT(m_heapIndex != oldHeapIndex);
     ASSERT(!inHeap() || hasValidHeapPosition());
 }
 
+NO_LAZY_SWEEP_SANITIZE_ADDRESS
 void TimerBase::setNextFireTime(double newUnalignedTime)
 {
     ASSERT(m_thread == currentThread());
 
     if (m_unalignedNextFireTime != newUnalignedTime)
         m_unalignedNextFireTime = newUnalignedTime;
 
     // Accessing thread global data is slow. Cache the heap pointer.
     if (!m_cachedThreadGlobalTimerHeap)
         m_cachedThreadGlobalTimerHeap = &threadGlobalTimerHeap();
@@ skipping 24 matching lines @@
     setNextFireTime(m_unalignedNextFireTime);
 }
 
 double TimerBase::nextUnalignedFireInterval() const
 {
     ASSERT(isActive());
     return std::max(m_unalignedNextFireTime - monotonicallyIncreasingTime(), 0.0);
 }
 
 } // namespace blink