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: |
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(values: 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(v: MarkSet(values, values + count, properties)); |
61 | } |
62 | |
63 | inline void drain(); |
64 | void compact(); |
65 | |
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 { |
76 | 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(); |
92 | static size_t pageSize() |
93 | { |
94 | if (!s_pageSize) |
95 | initializePagesize(); |
96 | return s_pageSize; |
97 | } |
98 | |
99 | template <typename T> struct MarkStackArray { |
100 | 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(size: m_allocated)); |
106 | } |
107 | |
108 | ~MarkStackArray() |
109 | { |
110 | releaseStack(addr: m_data, size: m_allocated); |
111 | } |
112 | |
113 | void expand() |
114 | { |
115 | size_t oldAllocation = m_allocated; |
116 | m_allocated *= 2; |
117 | m_capacity = m_allocated / sizeof(T); |
118 | void* newData = allocateStack(size: m_allocated); |
119 | memcpy(newData, m_data, oldAllocation); |
120 | releaseStack(addr: m_data, size: oldAllocation); |
121 | m_data = reinterpret_cast<T*>(newData); |
122 | } |
123 | |
124 | inline void append(const T& v) |
125 | { |
126 | if (m_top == m_capacity) |
127 | expand(); |
128 | m_data[m_top++] = v; |
129 | } |
130 | |
131 | inline T removeLast() |
132 | { |
133 | ASSERT(m_top); |
134 | return m_data[--m_top]; |
135 | } |
136 | |
137 | inline T& last() |
138 | { |
139 | ASSERT(m_top); |
140 | return m_data[m_top - 1]; |
141 | } |
142 | |
143 | inline bool isEmpty() |
144 | { |
145 | return m_top == 0; |
146 | } |
147 | |
148 | inline size_t size() { return m_top; } |
149 | |
150 | 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(addr: reinterpret_cast<char*>(m_data) + size, 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 | |