Oilpan: HeapVectorBacking should call destructors for its elements

Source/wtf/Vector.h

 /*
  *  Copyright (C) 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Library General Public
  *  License as published by the Free Software Foundation; either
  *  version 2 of the License, or (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 61 matching lines @@
                 cur->~T();
         }
     };
 
     template <bool unusedSlotsMustBeZeroed, typename T>
     struct VectorUnusedSlotClearer;
 
     template<typename T>
     struct VectorUnusedSlotClearer<false, T> {
         static void clear(T*, T*) { }
+#if ENABLE(ASSERT)
+        static void checkCleared(const T*, const T*) { }
+#endif
     };
 
     template<typename T>
     struct VectorUnusedSlotClearer<true, T> {
         static void clear(T* begin, T* end)
         {
             // We clear out unused slots so that the visitor and the finalizer
             // do not visit them (or at least it does not matter if they do).
             memset(begin, 0, sizeof(T) * (end - begin));
         }
+
+#if ENABLE(ASSERT)
+        static void checkCleared(const T* begin, const T* end)
+        {
+            const unsigned char* unusedArea = reinterpret_cast<const unsigned char*>(begin);
+            const unsigned char* endAddress = reinterpret_cast<const unsigned char*>(end);
+            ASSERT(endAddress >= unusedArea);
+            for (int i = 0; i < endAddress - unusedArea; ++i)
+                ASSERT(!unusedArea[i]);
+        }
+#endif
     };
 
     template <bool canInitializeWithMemset, typename T>
     struct VectorInitializer;
 
     template<typename T>
     struct VectorInitializer<false, T>
     {
         static void initialize(T* begin, T* end)
         {
@@ skipping 222 matching lines @@
 
         T* buffer() { return m_buffer; }
         const T* buffer() const { return m_buffer; }
         size_t capacity() const { return m_capacity; }
 
         void clearUnusedSlots(T* from, T* to)
         {
             VectorUnusedSlotClearer<Allocator::isGarbageCollected && (VectorTraits<T>::needsDestruction || ShouldBeTraced<VectorTraits<T>>::value), T>::clear(from, to);
         }
 
+        void checkUnusedSlots(const T* from, const T* to)
+        {
+#if ENABLE(ASSERT) && !defined(ANNOTATE_CONTIGUOUS_CONTAINER)
+            VectorUnusedSlotClearer<Allocator::isGarbageCollected && (VectorTraits<T>::needsDestruction || ShouldBeTraced<VectorTraits<T>>::value), T>::checkCleared(from, to);
+#endif
+        }
+
     protected:
         VectorBufferBase()
             : m_buffer(0)
             , m_capacity(0)
         {
         }
 
         VectorBufferBase(T* buffer, size_t capacity)
             : m_buffer(buffer)
             , m_capacity(capacity)
@@ skipping 68 matching lines @@
             std::swap(m_capacity, other.m_capacity);
         }
 
         using Base::allocateBuffer;
         using Base::allocationSize;
 
         using Base::buffer;
         using Base::capacity;
 
         using Base::clearUnusedSlots;
+        using Base::checkUnusedSlots;
 
         bool hasOutOfLineBuffer() const
         {
             // When inlineCapacity is 0 we have an out of line buffer if we have a buffer.
             return buffer();
         }
 
     protected:
         using Base::m_size;
 
@@ skipping 100 matching lines @@
         void swapVectorBuffer(VectorBuffer<T, inlineCapacity, Allocator>& other)
         {
             typedef VectorTypeOperations<T> TypeOperations;
 
             if (buffer() == inlineBuffer() && other.buffer() == other.inlineBuffer()) {
                 ASSERT(m_capacity == other.m_capacity);
                 if (m_size > other.m_size) {
                     ANNOTATE_CHANGE_SIZE(other.inlineBuffer(), inlineCapacity, other.m_size, m_size);
                     TypeOperations::swap(inlineBuffer(), inlineBuffer() + other.m_size, other.inlineBuffer());
                     TypeOperations::move(inlineBuffer() + other.m_size, inlineBuffer() + m_size, other.inlineBuffer() + other.m_size);
+                    Base::clearUnusedSlots(inlineBuffer() + other.m_size, inlineBuffer() + m_size);
                     ANNOTATE_CHANGE_SIZE(inlineBuffer(), inlineCapacity, m_size, other.m_size);
                 } else {
                     ANNOTATE_CHANGE_SIZE(inlineBuffer(), inlineCapacity, m_size, other.m_size);
                     TypeOperations::swap(inlineBuffer(), inlineBuffer() + m_size, other.inlineBuffer());
                     TypeOperations::move(other.inlineBuffer() + m_size, other.inlineBuffer() + other.m_size, inlineBuffer() + m_size);
+                    Base::clearUnusedSlots(other.inlineBuffer() + m_size, other.inlineBuffer() + other.m_size);
                     ANNOTATE_CHANGE_SIZE(other.inlineBuffer(), inlineCapacity, other.m_size, m_size);
                 }
             } else if (buffer() == inlineBuffer()) {
                 ANNOTATE_DELETE_BUFFER(m_buffer, inlineCapacity, m_size);
                 m_buffer = other.m_buffer;
                 other.m_buffer = other.inlineBuffer();
                 ANNOTATE_NEW_BUFFER(other.m_buffer, inlineCapacity, m_size);
                 TypeOperations::move(inlineBuffer(), inlineBuffer() + m_size, other.inlineBuffer());
+                Base::clearUnusedSlots(inlineBuffer(), inlineBuffer() + m_size);
                 std::swap(m_capacity, other.m_capacity);
             } else if (other.buffer() == other.inlineBuffer()) {
                 ANNOTATE_DELETE_BUFFER(other.m_buffer, inlineCapacity, other.m_size);
                 other.m_buffer = m_buffer;
                 m_buffer = inlineBuffer();
                 ANNOTATE_NEW_BUFFER(m_buffer, inlineCapacity, other.m_size);
                 TypeOperations::move(other.inlineBuffer(), other.inlineBuffer() + other.m_size, inlineBuffer());
+                Base::clearUnusedSlots(other.inlineBuffer(), other.inlineBuffer() + other.m_size);
                 std::swap(m_capacity, other.m_capacity);
             } else {
                 std::swap(m_buffer, other.m_buffer);
                 std::swap(m_capacity, other.m_capacity);
             }
         }
 
         using Base::buffer;
         using Base::capacity;
 
@@ skipping 200 matching lines @@
         void shrinkCapacity(size_t newCapacity);
         template<typename U> void appendSlowCase(const U&);
 
         using Base::m_size;
         using Base::buffer;
         using Base::capacity;
         using Base::swapVectorBuffer;
         using Base::allocateBuffer;
         using Base::allocationSize;
         using Base::clearUnusedSlots;
+        using Base::checkUnusedSlots;
     };
 
     template<typename T, size_t inlineCapacity, typename Allocator>
     Vector<T, inlineCapacity, Allocator>::Vector(const Vector& other)
         : Base(other.capacity())
     {
         ANNOTATE_NEW_BUFFER(begin(), capacity(), other.size());
         m_size = other.size();
         TypeOperations::uninitializedCopy(other.begin(), other.end(), begin());
     }
@@ skipping 171 matching lines @@
     {
         expandCapacity(newMinCapacity);
         return ptr;
     }
 
     template<typename T, size_t inlineCapacity, typename Allocator>
     inline void Vector<T, inlineCapacity, Allocator>::resize(size_t size)
     {
         if (size <= m_size) {
             TypeOperations::destruct(begin() + size, end());
+            clearUnusedSlots(begin() + size, end());
             ANNOTATE_CHANGE_SIZE(begin(), capacity(), m_size, size);
         } else {
             if (size > capacity())
                 expandCapacity(size);
             ANNOTATE_CHANGE_SIZE(begin(), capacity(), m_size, size);
             TypeOperations::initialize(end(), begin() + size);
         }
 
         m_size = size;
     }
@@ skipping 36 matching lines @@
         // The check is just a static hint for a compiler to indicate that
         // Base::expandBuffer returns false if Allocator is a DefaultAllocator.
         if (Allocator::isGarbageCollected && Base::expandBuffer(newCapacity)) {
             ANNOTATE_CHANGE_CAPACITY(begin(), oldCapacity, m_size, capacity());
             return;
         }
         T* oldEnd = end();
         Base::allocateExpandedBuffer(newCapacity);
         ANNOTATE_NEW_BUFFER(begin(), capacity(), m_size);
         TypeOperations::move(oldBuffer, oldEnd, begin());
+        clearUnusedSlots(oldBuffer, oldEnd);
         ANNOTATE_DELETE_BUFFER(oldBuffer, oldCapacity, m_size);
         Base::deallocateBuffer(oldBuffer);
     }
 
     template<typename T, size_t inlineCapacity, typename Allocator>
     inline void Vector<T, inlineCapacity, Allocator>::reserveInitialCapacity(size_t initialCapacity)
     {
         ASSERT(!m_size);
         ASSERT(capacity() == INLINE_CAPACITY);
         if (initialCapacity > INLINE_CAPACITY) {
@@ skipping 20 matching lines @@
             if (Base::shrinkBuffer(newCapacity)) {
                 ANNOTATE_CHANGE_CAPACITY(begin(), oldCapacity, m_size, capacity());
                 return;
             }
 
             T* oldEnd = end();
             Base::allocateBuffer(newCapacity);
             if (begin() != oldBuffer) {
                 ANNOTATE_NEW_BUFFER(begin(), capacity(), m_size);
                 TypeOperations::move(oldBuffer, oldEnd, begin());
+                clearUnusedSlots(oldBuffer, oldEnd);
                 ANNOTATE_DELETE_BUFFER(oldBuffer, oldCapacity, m_size);
             }
         } else {
             Base::resetBufferPointer();
 #ifdef ANNOTATE_CONTIGUOUS_CONTAINER
             if (oldBuffer != begin()) {
                 ANNOTATE_NEW_BUFFER(begin(), capacity(), m_size);
                 ANNOTATE_DELETE_BUFFER(oldBuffer, oldCapacity, m_size);
             }
 #endif
@@ skipping 201 matching lines @@
     template<typename T, size_t inlineCapacity, typename Allocator>
     template<typename VisitorDispatcher>
     void Vector<T, inlineCapacity, Allocator>::trace(VisitorDispatcher visitor)
     {
         ASSERT(Allocator::isGarbageCollected); // Garbage collector must be enabled.
         const T* bufferBegin = buffer();
         const T* bufferEnd = buffer() + size();
         if (ShouldBeTraced<VectorTraits<T>>::value) {
             for (const T* bufferEntry = bufferBegin; bufferEntry != bufferEnd; bufferEntry++)
                 Allocator::template trace<VisitorDispatcher, T, VectorTraits<T>>(visitor, *const_cast<T*>(bufferEntry));
+            checkUnusedSlots(buffer() + size(), buffer() + capacity());
         }
         if (this->hasOutOfLineBuffer())
             Allocator::markNoTracing(visitor, buffer());
     }
 
 #if !ENABLE(OILPAN)
     template<typename T, size_t N>
     struct NeedsTracing<Vector<T, N>> {
         static const bool value = false;
     };
 #endif
 
 } // namespace WTF
 
 using WTF::Vector;
 
 #endif // WTF_Vector_h