1 /* 2 * Copyright (C) 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 #ifndef MarkStack_h 27 #define MarkStack_h 28 29 #include "JSValue.h" 30 #include <wtf/Noncopyable.h> 31 32 namespace JSC { 33 34 class JSGlobalData; 35 class Register; 36 37 enum MarkSetProperties { MayContainNullValues, NoNullValues }; 38 39 class MarkStack : Noncopyable { 40 public: MarkStack(void * jsArrayVPtr)41 MarkStack(void* jsArrayVPtr) 42 : m_jsArrayVPtr(jsArrayVPtr) 43 #ifndef NDEBUG 44 , m_isCheckingForDefaultMarkViolation(false) 45 #endif 46 { 47 } 48 49 ALWAYS_INLINE void append(JSValue); 50 void append(JSCell*); 51 52 ALWAYS_INLINE void appendValues(Register* values, size_t count, MarkSetProperties properties = NoNullValues) 53 { 54 appendValues(reinterpret_cast<JSValue*>(values), count, properties); 55 } 56 57 ALWAYS_INLINE void appendValues(JSValue* values, size_t count, MarkSetProperties properties = NoNullValues) 58 { 59 if (count) 60 m_markSets.append(MarkSet(values, values + count, properties)); 61 } 62 63 inline void drain(); 64 void compact(); 65 ~MarkStack()66 ~MarkStack() 67 { 68 ASSERT(m_markSets.isEmpty()); 69 ASSERT(m_values.isEmpty()); 70 } 71 72 private: 73 void markChildren(JSCell*); 74 75 struct MarkSet { MarkSetMarkSet76 MarkSet(JSValue* values, JSValue* end, MarkSetProperties properties) 77 : m_values(values) 78 , m_end(end) 79 , m_properties(properties) 80 { 81 ASSERT(values); 82 } 83 JSValue* m_values; 84 JSValue* m_end; 85 MarkSetProperties m_properties; 86 }; 87 88 static void* allocateStack(size_t size); 89 static void releaseStack(void* addr, size_t size); 90 91 static void initializePagesize(); pageSize()92 static size_t pageSize() 93 { 94 if (!s_pageSize) 95 initializePagesize(); 96 return s_pageSize; 97 } 98 99 template <typename T> struct MarkStackArray { MarkStackArrayMarkStackArray100 MarkStackArray() 101 : m_top(0) 102 , m_allocated(MarkStack::pageSize()) 103 , m_capacity(m_allocated / sizeof(T)) 104 { 105 m_data = reinterpret_cast<T*>(allocateStack(m_allocated)); 106 } 107 ~MarkStackArrayMarkStackArray108 ~MarkStackArray() 109 { 110 releaseStack(m_data, m_allocated); 111 } 112 expandMarkStackArray113 void expand() 114 { 115 size_t oldAllocation = m_allocated; 116 m_allocated *= 2; 117 m_capacity = m_allocated / sizeof(T); 118 void* newData = allocateStack(m_allocated); 119 memcpy(newData, m_data, oldAllocation); 120 releaseStack(m_data, oldAllocation); 121 m_data = reinterpret_cast<T*>(newData); 122 } 123 appendMarkStackArray124 inline void append(const T& v) 125 { 126 if (m_top == m_capacity) 127 expand(); 128 m_data[m_top++] = v; 129 } 130 removeLastMarkStackArray131 inline T removeLast() 132 { 133 ASSERT(m_top); 134 return m_data[--m_top]; 135 } 136 lastMarkStackArray137 inline T& last() 138 { 139 ASSERT(m_top); 140 return m_data[m_top - 1]; 141 } 142 isEmptyMarkStackArray143 inline bool isEmpty() 144 { 145 return m_top == 0; 146 } 147 sizeMarkStackArray148 inline size_t size() { return m_top; } 149 shrinkAllocationMarkStackArray150 inline void shrinkAllocation(size_t size) 151 { 152 ASSERT(size <= m_allocated); 153 ASSERT(0 == (size % MarkStack::pageSize())); 154 if (size == m_allocated) 155 return; 156 #if OS(WINDOWS) || OS(SYMBIAN) || PLATFORM(BREWMP) 157 // We cannot release a part of a region with VirtualFree. To get around this, 158 // we'll release the entire region and reallocate the size that we want. 159 releaseStack(m_data, m_allocated); 160 m_data = reinterpret_cast<T*>(allocateStack(size)); 161 #else 162 releaseStack(reinterpret_cast<char*>(m_data) + size, m_allocated - size); 163 #endif 164 m_allocated = size; 165 m_capacity = m_allocated / sizeof(T); 166 } 167 168 private: 169 size_t m_top; 170 size_t m_allocated; 171 size_t m_capacity; 172 T* m_data; 173 }; 174 175 void* m_jsArrayVPtr; 176 MarkStackArray<MarkSet> m_markSets; 177 MarkStackArray<JSCell*> m_values; 178 static size_t s_pageSize; 179 180 #ifndef NDEBUG 181 public: 182 bool m_isCheckingForDefaultMarkViolation; 183 #endif 184 }; 185 } 186 187 #endif 188