⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 170697 in webkit


Ignore:
Timestamp:
Jul 1, 2014, 9:49:39 PM (12 years ago)
Author:
achristensen@apple.com
Message:

Reduce dynamic memory allocation in css jit.
​https://bugs.webkit.org/show_bug.cgi?id=134416

Reviewed by Benjamin Poulain.

Source/WebCore:

  • cssjit/FunctionCall.h:

(WebCore::FunctionCall::saveAllocatedRegisters):

  • cssjit/RegisterAllocator.h:
  • cssjit/SelectorCompiler.cpp:

(WebCore::SelectorCompiler::addPseudoClassType):
(WebCore::SelectorCompiler::SelectorCodeGenerator::generateSelectorChecker):
(WebCore::SelectorCompiler::SelectorCodeGenerator::generateElementIsNthChild):

  • cssjit/StackAllocator.h:

(WebCore::StackAllocator::push):
(WebCore::StackAllocator::pop):
Use inlineCapacity template parameter to reduce malloc calls.
I use 32 as the inline capacity for non-register related vectors because that
is probably big enough for the selector compiler, and if it is not then a malloc
call will not be significant because the selector is very complex.

Source/WTF:

  • wtf/Deque.h:

Added inlineCapacity optional template parameter.

Location:
trunk/Source
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WTF/ChangeLog

    r170630 r170697  
     12014-07-01  Alex Christensen  <achristensen@webkit.org>
     2
     3        Reduce dynamic memory allocation in css jit.
     4        https://bugs.webkit.org/show_bug.cgi?id=134416
     5
     6        Reviewed by Benjamin Poulain.
     7
     8        * wtf/Deque.h:
     9        Added inlineCapacity optional template parameter.
     10
    1112014-06-30  Commit Queue  <commit-queue@webkit.org>
    212

  • trunk/Source/WTF/wtf/Deque.h

    r170630 r170697  
    3939namespace WTF {
    4040
    41     template<typename T> class DequeIteratorBase;
    42     template<typename T> class DequeIterator;
    43     template<typename T> class DequeConstIterator;
    44 
    45     template<typename T>
     41    template<typename T, size_t inlineCapacity> class DequeIteratorBase;
     42    template<typename T, size_t inlineCapacity> class DequeIterator;
     43    template<typename T, size_t inlineCapacity> class DequeConstIterator;
     44
     45    template<typename T, size_t inlineCapacity = 0>
    4646    class Deque {
    4747        WTF_MAKE_FAST_ALLOCATED;
    4848    public:
    49         typedef DequeIterator<T> iterator;
    50         typedef DequeConstIterator<T> const_iterator;
     49        typedef DequeIterator<T, inlineCapacity> iterator;
     50        typedef DequeConstIterator<T, inlineCapacity> const_iterator;
    5151        typedef std::reverse_iterator<iterator> reverse_iterator;
    5252        typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
    5353
    5454        Deque();
    55         Deque(const Deque<T>&);
    56         Deque& operator=(const Deque<T>&);
     55        Deque(const Deque<T, inlineCapacity>&);
     56        Deque& operator=(const Deque<T, inlineCapacity>&);
    5757        ~Deque();
    5858
    59         void swap(Deque<T>&);
     59        void swap(Deque<T, inlineCapacity>&);
    6060
    6161        size_t size() const { return m_start <= m_end ? m_end - m_start : m_end + m_buffer.capacity() - m_start; }
    … …  
    9292
    9393    private:
    94         friend class DequeIteratorBase<T>;
    95 
    96         typedef VectorBuffer<T, 0> Buffer;
     94        friend class DequeIteratorBase<T, inlineCapacity>;
     95
     96        typedef VectorBuffer<T, inlineCapacity> Buffer;
    9797        typedef VectorTypeOperations<T> TypeOperations;
    98         typedef DequeIteratorBase<T> IteratorBase;
     98        typedef DequeIteratorBase<T, inlineCapacity> IteratorBase;
    9999
    100100        void remove(size_t position);
    … …  
    114114    };
    115115
    116     template<typename T>
     116    template<typename T, size_t inlineCapacity>
    117117    class DequeIteratorBase {
    118118    protected:
    119119        DequeIteratorBase();
    120         DequeIteratorBase(const Deque<T>*, size_t);
     120        DequeIteratorBase(const Deque<T, inlineCapacity>*, size_t);
    121121        DequeIteratorBase(const DequeIteratorBase&);
    122122        DequeIteratorBase& operator=(const DequeIteratorBase&);
    … …  
    139139        void checkValidity(const DequeIteratorBase&) const;
    140140
    141         Deque<T>* m_deque;
     141        Deque<T, inlineCapacity>* m_deque;
    142142        size_t m_index;
    143143
    144         friend class Deque<T>;
     144        friend class Deque<T, inlineCapacity>;
    145145
    146146#ifndef NDEBUG
    … …  
    150150    };
    151151
    152     template<typename T>
    153     class DequeIterator : public DequeIteratorBase<T> {
     152    template<typename T, size_t inlineCapacity>
     153    class DequeIterator : public DequeIteratorBase<T, inlineCapacity> {
    154154    private:
    155         typedef DequeIteratorBase<T> Base;
    156         typedef DequeIterator<T> Iterator;
     155        typedef DequeIteratorBase<T, inlineCapacity> Base;
     156        typedef DequeIterator<T, inlineCapacity> Iterator;
    157157
    158158    public:
    … …  
    163163        typedef std::bidirectional_iterator_tag iterator_category;
    164164
    165         DequeIterator(Deque<T>* deque, size_t index) : Base(deque, index) { }
     165        DequeIterator(Deque<T, inlineCapacity>* deque, size_t index)
     166            : Base(deque, index) { }
    166167
    167168        DequeIterator(const Iterator& other) : Base(other) { }
    … …  
    180181    };
    181182
    182     template<typename T>
    183     class DequeConstIterator : public DequeIteratorBase<T> {
     183    template<typename T, size_t inlineCapacity>
     184    class DequeConstIterator : public DequeIteratorBase<T, inlineCapacity> {
    184185    private:
    185         typedef DequeIteratorBase<T> Base;
    186         typedef DequeConstIterator<T> Iterator;
    187         typedef DequeIterator<T> NonConstIterator;
     186        typedef DequeIteratorBase<T, inlineCapacity> Base;
     187        typedef DequeConstIterator<T, inlineCapacity> Iterator;
     188        typedef DequeIterator<T, inlineCapacity> NonConstIterator;
    188189
    189190    public:
    … …  
    194195        typedef std::bidirectional_iterator_tag iterator_category;
    195196
    196         DequeConstIterator(const Deque<T>* deque, size_t index) : Base(deque, index) { }
     197        DequeConstIterator(const Deque<T, inlineCapacity>* deque, size_t index)
     198            : Base(deque, index) { }
    197199
    198200        DequeConstIterator(const Iterator& other) : Base(other) { }
    … …  
    214216
    215217#ifdef NDEBUG
    216     template<typename T> inline void Deque<T>::checkValidity() const { }
    217     template<typename T> inline void Deque<T>::checkIndexValidity(size_t) const { }
    218     template<typename T> inline void Deque<T>::invalidateIterators() { }
     218    template<typename T, size_t inlineCapacity> inline void Deque<T, inlineCapacity>::checkValidity() const { }
     219    template<typename T, size_t inlineCapacity> inline void Deque<T, inlineCapacity>::checkIndexValidity(size_t) const { }
     220    template<typename T, size_t inlineCapacity> inline void Deque<T, inlineCapacity>::invalidateIterators() { }
    219221#else
    220     template<typename T>
    221     void Deque<T>::checkValidity() const
     222    template<typename T, size_t inlineCapacity>
     223    void Deque<T, inlineCapacity>::checkValidity() const
    222224    {
    223225        // In this implementation a capacity of 1 would confuse append() and
    … …  
    234236    }
    235237
    236     template<typename T>
    237     void Deque<T>::checkIndexValidity(size_t index) const
     238    template<typename T, size_t inlineCapacity>
     239    void Deque<T, inlineCapacity>::checkIndexValidity(size_t index) const
    238240    {
    239241        ASSERT_UNUSED(index, index <= m_buffer.capacity());
    … …  
    246248    }
    247249
    248     template<typename T>
    249     void Deque<T>::invalidateIterators()
     250    template<typename T, size_t inlineCapacity>
     251    void Deque<T, inlineCapacity>::invalidateIterators()
    250252    {
    251253        IteratorBase* next;
    … …  
    260262#endif
    261263
    262     template<typename T>
    263     inline Deque<T>::Deque()
     264    template<typename T, size_t inlineCapacity>
     265    inline Deque<T, inlineCapacity>::Deque()
    264266        : m_start(0)
    265267        , m_end(0)
    … …  
    271273    }
    272274
    273     template<typename T>
    274     inline Deque<T>::Deque(const Deque<T>& other)
     275    template<typename T, size_t inlineCapacity>
     276    inline Deque<T, inlineCapacity>::Deque(const Deque<T, inlineCapacity>& other)
    275277        : m_start(other.m_start)
    276278        , m_end(other.m_end)
    … …  
    289291    }
    290292
    291     template<typename T>
    292     inline Deque<T>& Deque<T>::operator=(const Deque<T>& other)
     293    template<typename T, size_t inlineCapacity>
     294    inline Deque<T, inlineCapacity>& Deque<T, inlineCapacity>::operator=(const Deque<T, inlineCapacity>& other)
    293295    {
    294296        // FIXME: This is inefficient if we're using an inline buffer and T is
    295297        // expensive to copy since it will copy the buffer twice instead of once.
    296         Deque<T> copy(other);
     298        Deque<T, inlineCapacity> copy(other);
    297299        swap(copy);
    298300        return *this;
    299301    }
    300302
    301     template<typename T>
    302     inline void Deque<T>::destroyAll()
     303    template<typename T, size_t inlineCapacity>
     304    inline void Deque<T, inlineCapacity>::destroyAll()
    303305    {
    304306        if (m_start <= m_end)
    … …  
    310312    }
    311313
    312     template<typename T>
    313     inline Deque<T>::~Deque()
     314    template<typename T, size_t inlineCapacity>
     315    inline Deque<T, inlineCapacity>::~Deque()
    314316    {
    315317        checkValidity();
    … …  
    318320    }
    319321
    320     template<typename T>
    321     inline void Deque<T>::swap(Deque<T>& other)
     322    template<typename T, size_t inlineCapacity>
     323    inline void Deque<T, inlineCapacity>::swap(Deque<T, inlineCapacity>& other)
    322324    {
    323325        checkValidity();
    … …  
    331333    }
    332334
    333     template<typename T>
    334     inline void Deque<T>::clear()
     335    template<typename T, size_t inlineCapacity>
     336    inline void Deque<T, inlineCapacity>::clear()
    335337    {
    336338        checkValidity();
    … …  
    343345    }
    344346
    345     template<typename T>
     347    template<typename T, size_t inlineCapacity>
    346348    template<typename Predicate>
    347     inline auto Deque<T>::findIf(Predicate&& predicate) -> iterator
     349    inline auto Deque<T, inlineCapacity>::findIf(Predicate&& predicate) -> iterator
    348350    {
    349351        iterator end_iterator = end();
    … …  
    355357    }
    356358
    357     template<typename T>
    358     inline void Deque<T>::expandCapacityIfNeeded()
     359    template<typename T, size_t inlineCapacity>
     360    inline void Deque<T, inlineCapacity>::expandCapacityIfNeeded()
    359361    {
    360362        if (m_start) {
    … …  
    370372    }
    371373
    372     template<typename T>
    373     void Deque<T>::expandCapacity()
     374    template<typename T, size_t inlineCapacity>
     375    void Deque<T, inlineCapacity>::expandCapacity()
    374376    {
    375377        checkValidity();
    … …  
    389391    }
    390392
    391     template<typename T>
    392     inline auto Deque<T>::takeFirst() -> T
     393    template<typename T, size_t inlineCapacity>
     394    inline auto Deque<T, inlineCapacity>::takeFirst() -> T
    393395    {
    394396        T oldFirst = std::move(first());
    … …  
    397399    }
    398400
    399     template<typename T>
    400     inline auto Deque<T>::takeLast() -> T
     401    template<typename T, size_t inlineCapacity>
     402    inline auto Deque<T, inlineCapacity>::takeLast() -> T
    401403    {
    402404        T oldLast = std::move(last());
    … …  
    405407    }
    406408
    407     template<typename T> template<typename U>
    408     inline void Deque<T>::append(U&& value)
     409    template<typename T, size_t inlineCapacity> template<typename U>
     410    inline void Deque<T, inlineCapacity>::append(U&& value)
    409411    {
    410412        checkValidity();
    … …  
    418420    }
    419421
    420     template<typename T> template<typename U>
    421     inline void Deque<T>::prepend(U&& value)
     422    template<typename T, size_t inlineCapacity> template<typename U>
     423    inline void Deque<T, inlineCapacity>::prepend(U&& value)
    422424    {
    423425        checkValidity();
    … …  
    431433    }
    432434
    433     template<typename T>
    434     inline void Deque<T>::removeFirst()
     435    template<typename T, size_t inlineCapacity>
     436    inline void Deque<T, inlineCapacity>::removeFirst()
    435437    {
    436438        checkValidity();
    … …  
    445447    }
    446448
    447     template<typename T>
    448     inline void Deque<T>::removeLast()
     449    template<typename T, size_t inlineCapacity>
     450    inline void Deque<T, inlineCapacity>::removeLast()
    449451    {
    450452        checkValidity();
    … …  
    459461    }
    460462
    461     template<typename T>
    462     inline void Deque<T>::remove(iterator& it)
     463    template<typename T, size_t inlineCapacity>
     464    inline void Deque<T, inlineCapacity>::remove(iterator& it)
    463465    {
    464466        it.checkValidity();
    … …  
    466468    }
    467469
    468     template<typename T>
    469     inline void Deque<T>::remove(const_iterator& it)
     470    template<typename T, size_t inlineCapacity>
     471    inline void Deque<T, inlineCapacity>::remove(const_iterator& it)
    470472    {
    471473        it.checkValidity();
    … …  
    473475    }
    474476
    475     template<typename T>
    476     inline void Deque<T>::remove(size_t position)
     477    template<typename T, size_t inlineCapacity>
     478    inline void Deque<T, inlineCapacity>::remove(size_t position)
    477479    {
    478480        if (position == m_end)
    … …  
    497499
    498500#ifdef NDEBUG
    499     template<typename T> inline void DequeIteratorBase<T>::checkValidity() const { }
    500     template<typename T> inline void DequeIteratorBase<T>::checkValidity(const DequeIteratorBase<T>&) const { }
    501     template<typename T> inline void DequeIteratorBase<T>::addToIteratorsList() { }
    502     template<typename T> inline void DequeIteratorBase<T>::removeFromIteratorsList() { }
     501    template<typename T, size_t inlineCapacity> inline void DequeIteratorBase<T, inlineCapacity>::checkValidity() const { }
     502    template<typename T, size_t inlineCapacity> inline void DequeIteratorBase<T, inlineCapacity>::checkValidity(const DequeIteratorBase<T, inlineCapacity>&) const { }
     503    template<typename T, size_t inlineCapacity> inline void DequeIteratorBase<T, inlineCapacity>::addToIteratorsList() { }
     504    template<typename T, size_t inlineCapacity> inline void DequeIteratorBase<T, inlineCapacity>::removeFromIteratorsList() { }
    503505#else
    504     template<typename T>
    505     void DequeIteratorBase<T>::checkValidity() const
     506    template<typename T, size_t inlineCapacity>
     507    void DequeIteratorBase<T, inlineCapacity>::checkValidity() const
    506508    {
    507509        ASSERT(m_deque);
    … …  
    509511    }
    510512
    511     template<typename T>
    512     void DequeIteratorBase<T>::checkValidity(const DequeIteratorBase& other) const
     513    template<typename T, size_t inlineCapacity>
     514    void DequeIteratorBase<T, inlineCapacity>::checkValidity(const DequeIteratorBase& other) const
    513515    {
    514516        checkValidity();
    … …  
    517519    }
    518520
    519     template<typename T>
    520     void DequeIteratorBase<T>::addToIteratorsList()
     521    template<typename T, size_t inlineCapacity>
     522    void DequeIteratorBase<T, inlineCapacity>::addToIteratorsList()
    521523    {
    522524        if (!m_deque)
    … …  
    531533    }
    532534
    533     template<typename T>
    534     void DequeIteratorBase<T>::removeFromIteratorsList()
     535    template<typename T, size_t inlineCapacity>
     536    void DequeIteratorBase<T, inlineCapacity>::removeFromIteratorsList()
    535537    {
    536538        if (!m_deque) {
    … …  
    556558#endif
    557559
    558     template<typename T>
    559     inline DequeIteratorBase<T>::DequeIteratorBase()
     560    template<typename T, size_t inlineCapacity>
     561    inline DequeIteratorBase<T, inlineCapacity>::DequeIteratorBase()
    560562        : m_deque(0)
    561563    {
    562564    }
    563565
    564     template<typename T>
    565     inline DequeIteratorBase<T>::DequeIteratorBase(const Deque<T>* deque, size_t index)
    566         : m_deque(const_cast<Deque<T>*>(deque))
     566    template<typename T, size_t inlineCapacity>
     567    inline DequeIteratorBase<T, inlineCapacity>::DequeIteratorBase(const Deque<T, inlineCapacity>* deque, size_t index)
     568        : m_deque(const_cast<Deque<T, inlineCapacity>*>(deque))
    567569        , m_index(index)
    568570    {
    … …  
    571573    }
    572574
    573     template<typename T>
    574     inline DequeIteratorBase<T>::DequeIteratorBase(const DequeIteratorBase& other)
     575    template<typename T, size_t inlineCapacity>
     576    inline DequeIteratorBase<T, inlineCapacity>::DequeIteratorBase(const DequeIteratorBase& other)
    575577        : m_deque(other.m_deque)
    576578        , m_index(other.m_index)
    … …  
    580582    }
    581583
    582     template<typename T>
    583     inline DequeIteratorBase<T>& DequeIteratorBase<T>::operator=(const DequeIteratorBase& other)
     584    template<typename T, size_t inlineCapacity>
     585    inline DequeIteratorBase<T, inlineCapacity>& DequeIteratorBase<T, inlineCapacity>::operator=(const DequeIteratorBase& other)
    584586    {
    585587        other.checkValidity();
    … …  
    593595    }
    594596
    595     template<typename T>
    596     inline DequeIteratorBase<T>::~DequeIteratorBase()
     597    template<typename T, size_t inlineCapacity>
     598    inline DequeIteratorBase<T, inlineCapacity>::~DequeIteratorBase()
    597599    {
    598600#ifndef NDEBUG
    … …  
    602604    }
    603605
    604     template<typename T>
    605     inline bool DequeIteratorBase<T>::isEqual(const DequeIteratorBase& other) const
     606    template<typename T, size_t inlineCapacity>
     607    inline bool DequeIteratorBase<T, inlineCapacity>::isEqual(const DequeIteratorBase& other) const
    606608    {
    607609        checkValidity(other);
    … …  
    609611    }
    610612
    611     template<typename T>
    612     inline void DequeIteratorBase<T>::increment()
     613    template<typename T, size_t inlineCapacity>
     614    inline void DequeIteratorBase<T, inlineCapacity>::increment()
    613615    {
    614616        checkValidity();
    … …  
    622624    }
    623625
    624     template<typename T>
    625     inline void DequeIteratorBase<T>::decrement()
     626    template<typename T, size_t inlineCapacity>
     627    inline void DequeIteratorBase<T, inlineCapacity>::decrement()
    626628    {
    627629        checkValidity();
    … …  
    635637    }
    636638
    637     template<typename T>
    638     inline T* DequeIteratorBase<T>::after() const
     639    template<typename T, size_t inlineCapacity>
     640    inline T* DequeIteratorBase<T, inlineCapacity>::after() const
    639641    {
    640642        checkValidity();
    … …  
    643645    }
    644646
    645     template<typename T>
    646     inline T* DequeIteratorBase<T>::before() const
     647    template<typename T, size_t inlineCapacity>
     648    inline T* DequeIteratorBase<T, inlineCapacity>::before() const
    647649    {
    648650        checkValidity();

  • trunk/Source/WebCore/ChangeLog

    r170694 r170697  
     12014-07-01  Alex Christensen  <achristensen@webkit.org>
     2
     3        Reduce dynamic memory allocation in css jit.
     4        https://bugs.webkit.org/show_bug.cgi?id=134416
     5
     6        Reviewed by Benjamin Poulain.
     7
     8        * cssjit/FunctionCall.h:
     9        (WebCore::FunctionCall::saveAllocatedRegisters):
     10        * cssjit/RegisterAllocator.h:
     11        * cssjit/SelectorCompiler.cpp:
     12        (WebCore::SelectorCompiler::addPseudoClassType):
     13        (WebCore::SelectorCompiler::SelectorCodeGenerator::generateSelectorChecker):
     14        (WebCore::SelectorCompiler::SelectorCodeGenerator::generateElementIsNthChild):
     15        * cssjit/StackAllocator.h:
     16        (WebCore::StackAllocator::push):
     17        (WebCore::StackAllocator::pop):
     18        Use inlineCapacity template parameter to reduce malloc calls.
     19        I use 32 as the inline capacity for non-register related vectors because that
     20        is probably big enough for the selector compiler, and if it is not then a malloc
     21        call will not be significant because the selector is very complex.
     22
    1232014-07-01  Eric Carlson  <eric.carlson@apple.com>
    224

  • trunk/Source/WebCore/cssjit/FunctionCall.h

    r170630 r170697  
    3838class FunctionCall {
    3939public:
    40     FunctionCall(JSC::MacroAssembler& assembler, RegisterAllocator& registerAllocator, StackAllocator& stackAllocator, Vector<std::pair<JSC::MacroAssembler::Call, JSC::FunctionPtr>>& callRegistry)
     40    FunctionCall(JSC::MacroAssembler& assembler, RegisterAllocator& registerAllocator, StackAllocator& stackAllocator, Vector<std::pair<JSC::MacroAssembler::Call, JSC::FunctionPtr>, 32>& callRegistry)
    4141        : m_assembler(assembler)
    4242        , m_registerAllocator(registerAllocator)
    … …  
    168168                m_savedRegisters.append(registerID);
    169169        }
    170         Vector<StackAllocator::StackReference> stackReferences = m_stackAllocator.push(m_savedRegisters);
     170        Vector<StackAllocator::StackReference, registerCount> stackReferences = m_stackAllocator.push(m_savedRegisters);
    171171        m_savedRegisterStackReferences.appendVector(stackReferences);
    172172    }
    … …  
    181181    RegisterAllocator& m_registerAllocator;
    182182    StackAllocator& m_stackAllocator;
    183     Vector<std::pair<JSC::MacroAssembler::Call, JSC::FunctionPtr>>& m_callRegistry;
     183    Vector<std::pair<JSC::MacroAssembler::Call, JSC::FunctionPtr>, 32>& m_callRegistry;
    184184
    185185    Vector<JSC::MacroAssembler::RegisterID, registerCount> m_savedRegisters;

  • trunk/Source/WebCore/cssjit/RegisterAllocator.h

    r170630 r170697  
    206206
    207207private:
    208     Deque<JSC::MacroAssembler::RegisterID> m_registers;
     208    Deque<JSC::MacroAssembler::RegisterID, registerCount> m_registers;
    209209    Vector<JSC::MacroAssembler::RegisterID, registerCount> m_allocatedRegisters;
    210210    Vector<JSC::MacroAssembler::RegisterID, calleeSavedRegisterCount> m_reservedCalleeSavedRegisters;

  • trunk/Source/WebCore/cssjit/SelectorCompiler.cpp

    r170630 r170697  
    160160    const AtomicString* id;
    161161    const AtomicString* langFilter;
    162     Vector<const AtomicStringImpl*, 1> classNames;
     162    Vector<const AtomicStringImpl*, 32> classNames;
    163163    HashSet<unsigned> pseudoClasses;
    164     Vector<JSC::FunctionPtr> unoptimizedPseudoClasses;
    165     Vector<AttributeMatchingInfo> attributes;
    166     Vector<std::pair<int, int>> nthChildFilters;
     164    Vector<JSC::FunctionPtr, 32> unoptimizedPseudoClasses;
     165    Vector<AttributeMatchingInfo, 32> attributes;
     166    Vector<std::pair<int, int>, 32> nthChildFilters;
    167167    Vector<SelectorFragment> notFilters;
    168168    Vector<Vector<SelectorFragment>> anyFilters;
    … …  
    193193
    194194typedef JSC::MacroAssembler Assembler;
    195 typedef Vector<SelectorFragment, 8> SelectorFragmentList;
    196 typedef Vector<TagNamePattern, 8> TagNameList;
     195typedef Vector<SelectorFragment, 32> SelectorFragmentList;
     196typedef Vector<TagNamePattern, 32> TagNameList;
    197197
    198198class SelectorCodeGenerator {
    … …  
    266266    bool generatePrologue();
    267267    void generateEpilogue();
    268     Vector<StackAllocator::StackReference> m_prologueStackReferences;
     268    Vector<StackAllocator::StackReference, registerCount> m_prologueStackReferences;
    269269
    270270    Assembler m_assembler;
    271271    RegisterAllocator m_registerAllocator;
    272272    StackAllocator m_stackAllocator;
    273     Vector<std::pair<Assembler::Call, JSC::FunctionPtr>> m_functionCalls;
     273    Vector<std::pair<Assembler::Call, JSC::FunctionPtr>, 32> m_functionCalls;
    274274
    275275    SelectorContext m_selectorContext;
    … …  
    477477    case CSSSelector::PseudoClassAny:
    478478        {
    479             Vector<SelectorFragment> anyFragments;
     479            Vector<SelectorFragment, 32> anyFragments;
    480480            FunctionType functionType = FunctionType::SimpleSelectorChecker;
    481481            for (const CSSSelector* rootSelector = selector.selectorList()->first(); rootSelector; rootSelector = CSSSelectorList::next(rootSelector)) {
    … …  
    11671167void SelectorCodeGenerator::generateSelectorChecker()
    11681168{
    1169     Vector<StackAllocator::StackReference> calleeSavedRegisterStackReferences;
     1169    Vector<StackAllocator::StackReference, calleeSavedRegisterCount> calleeSavedRegisterStackReferences;
    11701170    bool reservedCalleeSavedRegisters = false;
    11711171    unsigned availableRegisterCount = m_registerAllocator.availableRegisterCount();
    … …  
    25832583    generateWalkToParentElement(failureCases, parentElement);
    25842584
    2585     Vector<std::pair<int, int>> validSubsetFilters;
     2585    Vector<std::pair<int, int>, 32> validSubsetFilters;
    25862586    validSubsetFilters.reserveInitialCapacity(fragment.nthChildFilters.size());
    25872587    for (const auto& slot : fragment.nthChildFilters) {

  • trunk/Source/WebCore/cssjit/StackAllocator.h

    r170630 r170697  
    2929#if ENABLE(CSS_SELECTOR_JIT)
    3030
     31#include "RegisterAllocator.h"
    3132#include <JavaScriptCore/MacroAssembler.h>
    3233
    … …  
    6970    }
    7071
    71     Vector<StackReference> push(const Vector<JSC::MacroAssembler::RegisterID>& registerIDs)
    72     {
    73         RELEASE_ASSERT(!m_hasFunctionCallPadding);
    74         unsigned registerCount = registerIDs.size();
    75         Vector<StackReference> stackReferences;
    76         stackReferences.reserveInitialCapacity(registerCount);
     72    Vector<StackReference, registerCount> push(const Vector<JSC::MacroAssembler::RegisterID>& registerIDs)
     73    {
     74        RELEASE_ASSERT(!m_hasFunctionCallPadding);
     75        Vector<StackReference, registerCount> stackReferences;
    7776#if CPU(ARM64)
    78         for (unsigned i = 0; i < registerCount - 1; i += 2) {
     77        unsigned pushRegisterCount = registerIDs.size();
     78        for (unsigned i = 0; i < pushRegisterCount - 1; i += 2) {
    7979            m_assembler.pushPair(registerIDs[i + 1], registerIDs[i]);
    8080            m_offsetFromTop += stackUnitInBytes();
    … …  
    8282            stackReferences.append(StackReference(m_offsetFromTop));
    8383        }
    84         if (registerCount % 2)
    85             stackReferences.append(push(registerIDs[registerCount - 1]));
     84        if (pushRegisterCount % 2)
     85            stackReferences.append(push(registerIDs[pushRegisterCount - 1]));
    8686#else
    8787        for (auto registerID : registerIDs)
    … …  
    103103        RELEASE_ASSERT(!m_hasFunctionCallPadding);
    104104
    105         unsigned registerCount = registerIDs.size();
    106         RELEASE_ASSERT(stackReferences.size() == registerCount);
     105        unsigned popRegisterCount = registerIDs.size();
     106        RELEASE_ASSERT(stackReferences.size() == popRegisterCount);
    107107#if CPU(ARM64)
    108         ASSERT(m_offsetFromTop >= stackUnitInBytes() * ((registerCount + 1) / 2));
    109         unsigned registerCountOdd = registerCount % 2;
    110         if (registerCountOdd)
    111             pop(stackReferences[registerCount - 1], registerIDs[registerCount - 1]);
    112         for (unsigned i = registerCount - registerCountOdd; i > 0; i -= 2) {
     108        ASSERT(m_offsetFromTop >= stackUnitInBytes() * ((popRegisterCount + 1) / 2));
     109        unsigned popRegisterCountOdd = popRegisterCount % 2;
     110        if (popRegisterCountOdd)
     111            pop(stackReferences[popRegisterCount - 1], registerIDs[popRegisterCount - 1]);
     112        for (unsigned i = popRegisterCount - popRegisterCountOdd; i > 0; i -= 2) {
    113113            RELEASE_ASSERT(stackReferences[i - 1] == m_offsetFromTop);
    114114            RELEASE_ASSERT(stackReferences[i - 2] == m_offsetFromTop - stackUnitInBytes() / 2);
    … …  
    118118        }
    119119#else
    120         ASSERT(m_offsetFromTop >= stackUnitInBytes() * registerCount);
    121         for (unsigned i = registerCount; i > 0; --i)
     120        ASSERT(m_offsetFromTop >= stackUnitInBytes() * popRegisterCount);
     121        for (unsigned i = popRegisterCount; i > 0; --i)
    122122            pop(stackReferences[i - 1], registerIDs[i - 1]);
    123123#endif
Note: See TracChangeset for help on using the changeset viewer.