JavaScriptCore/runtime/CollectorHeapIterator.h

   1 /*
   2  * Copyright (C) 2008, 2009 Apple Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "config.h"
  27 #include "Collector.h"
  28
  29 #ifndef CollectorHeapIterator_h
  30 #define CollectorHeapIterator_h
  31
  32 namespace JSC {
  33
  34     class CollectorHeapIterator {
  35     public:
  36         bool operator!=(const CollectorHeapIterator& other);
  37         JSCell* operator*() const;
  38
  39     protected:
  40         CollectorHeapIterator(CollectorHeap&, size_t startBlock, size_t startCell);
  41         void advance(size_t cellsPerBlock);
  42
  43         CollectorHeap& m_heap;
  44         size_t m_block;
  45         size_t m_cell;
  46     };
  47
  48     template <HeapType heapType>
  49     class LiveObjectIterator : public CollectorHeapIterator {
  50     public:
  51         LiveObjectIterator(CollectorHeap&, size_t startBlock, size_t startCell = 0);
  52         LiveObjectIterator<heapType>& operator++();
  53     };
  54
  55     template <HeapType heapType>
  56     class DeadObjectIterator : public CollectorHeapIterator {
  57     public:
  58         DeadObjectIterator(CollectorHeap&, size_t startBlock, size_t startCell = 0);
  59         DeadObjectIterator<heapType>& operator++();
  60     };
  61
  62     template <HeapType heapType>
  63     class ObjectIterator : public CollectorHeapIterator {
  64     public:
  65         ObjectIterator(CollectorHeap&, size_t startBlock, size_t startCell = 0);
  66         ObjectIterator<heapType>& operator++();
  67     };
  68
  69     inline CollectorHeapIterator::CollectorHeapIterator(CollectorHeap& heap, size_t startBlock, size_t startCell)
  70         : m_heap(heap)
  71         , m_block(startBlock)
  72         , m_cell(startCell)
  73     {
  74     }
  75
  76     inline bool CollectorHeapIterator::operator!=(const CollectorHeapIterator& other)
  77     {
  78         return m_block != other.m_block || m_cell != other.m_cell;
  79     }
  80
  81     inline JSCell* CollectorHeapIterator::operator*() const
  82     {
  83         return reinterpret_cast<JSCell*>(m_heap.blocks[m_block]->cells + m_cell);
  84     }
  85
  86     inline void CollectorHeapIterator::advance(size_t cellsPerBlock)
  87     {
  88         ++m_cell;
  89         if (m_cell == cellsPerBlock) {
  90             m_cell = 0;
  91             ++m_block;
  92         }
  93     }
  94
  95     template <HeapType heapType>
  96     inline LiveObjectIterator<heapType>::LiveObjectIterator(CollectorHeap& heap, size_t startBlock, size_t startCell)
  97         : CollectorHeapIterator(heap, startBlock, startCell - 1)
  98     {
  99         ++(*this);
 100     }
 101
 102     template <HeapType heapType>
 103     inline LiveObjectIterator<heapType>& LiveObjectIterator<heapType>::operator++()
 104     {
 105         if (m_block < m_heap.nextBlock || m_cell < m_heap.nextCell) {
 106             advance(HeapConstants<heapType>::cellsPerBlock);
 107             return *this;
 108         }
 109
 110         do {
 111             advance(HeapConstants<heapType>::cellsPerBlock);
 112         } while (m_block < m_heap.usedBlocks && !m_heap.blocks[m_block]->marked.get(m_cell));
 113         return *this;
 114     }
 115
 116     template <HeapType heapType>
 117     inline DeadObjectIterator<heapType>::DeadObjectIterator(CollectorHeap& heap, size_t startBlock, size_t startCell)
 118         : CollectorHeapIterator(heap, startBlock, startCell - 1)
 119     {
 120         ++(*this);
 121     }
 122
 123     template <HeapType heapType>
 124     inline DeadObjectIterator<heapType>& DeadObjectIterator<heapType>::operator++()
 125     {
 126         do {
 127             advance(HeapConstants<heapType>::cellsPerBlock);
 128             ASSERT(m_block > m_heap.nextBlock || (m_block == m_heap.nextBlock && m_cell >= m_heap.nextCell));
 129         } while (m_block < m_heap.usedBlocks && m_heap.blocks[m_block]->marked.get(m_cell));
 130         return *this;
 131     }
 132
 133     template <HeapType heapType>
 134     inline ObjectIterator<heapType>::ObjectIterator(CollectorHeap& heap, size_t startBlock, size_t startCell)
 135         : CollectorHeapIterator(heap, startBlock, startCell - 1)
 136     {
 137         ++(*this);
 138     }
 139
 140     template <HeapType heapType>
 141     inline ObjectIterator<heapType>& ObjectIterator<heapType>::operator++()
 142     {
 143         advance(HeapConstants<heapType>::cellsPerBlock);
 144         return *this;
 145     }
 146
 147 } // namespace JSC
 148
 149 #endif // CollectorHeapIterator_h