Rename MarkedSpace::version/MarkedBlock::version to MarkedSpace::markingVersion/Marke...
[WebKit-https.git] / Source / JavaScriptCore / heap / SlotVisitor.h
1 /*
2  * Copyright (C) 2011-2013, 2015-2016 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. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #ifndef SlotVisitor_h
27 #define SlotVisitor_h
28
29 #include "CellState.h"
30 #include "HandleTypes.h"
31 #include "MarkStack.h"
32 #include "OpaqueRootSet.h"
33
34 namespace JSC {
35
36 class ConservativeRoots;
37 class GCThreadSharedData;
38 class Heap;
39 class HeapCell;
40 class HeapSnapshotBuilder;
41 template<typename T> class JITWriteBarrier;
42 class MarkedBlock;
43 class UnconditionalFinalizer;
44 template<typename T> class Weak;
45 class WeakReferenceHarvester;
46 template<typename T> class WriteBarrierBase;
47
48 typedef uint32_t HeapVersion;
49
50 class SlotVisitor {
51     WTF_MAKE_NONCOPYABLE(SlotVisitor);
52     WTF_MAKE_FAST_ALLOCATED;
53
54     friend class SetCurrentCellScope;
55     friend class HeapRootVisitor; // Allowed to mark a JSValue* or JSCell** directly.
56     friend class Heap;
57
58 public:
59     SlotVisitor(Heap&);
60     ~SlotVisitor();
61
62     MarkStackArray& markStack() { return m_stack; }
63     const MarkStackArray& markStack() const { return m_stack; }
64
65     VM& vm();
66     const VM& vm() const;
67     Heap* heap() const;
68
69     void append(ConservativeRoots&);
70     
71     template<typename T> void append(WriteBarrierBase<T>*);
72     template<typename T> void appendHidden(WriteBarrierBase<T>*);
73     template<typename Iterator> void append(Iterator begin , Iterator end);
74     void appendValues(WriteBarrierBase<Unknown>*, size_t count);
75     void appendValuesHidden(WriteBarrierBase<Unknown>*, size_t count);
76     
77     template<typename T>
78     void appendUnbarrieredPointer(T**);
79     void appendUnbarrieredValue(JSValue*);
80     template<typename T>
81     void appendUnbarrieredWeak(Weak<T>*);
82     template<typename T>
83     void appendUnbarrieredReadOnlyPointer(T*);
84     void appendUnbarrieredReadOnlyValue(JSValue);
85     
86     JS_EXPORT_PRIVATE void addOpaqueRoot(void*);
87     JS_EXPORT_PRIVATE bool containsOpaqueRoot(void*) const;
88     TriState containsOpaqueRootTriState(void*) const;
89     int opaqueRootCount();
90
91     bool isEmpty() { return m_stack.isEmpty(); }
92
93     void didStartMarking();
94     void reset();
95     void clearMarkStack();
96
97     size_t bytesVisited() const { return m_bytesVisited; }
98     size_t bytesCopied() const { return m_bytesCopied; }
99     size_t visitCount() const { return m_visitCount; }
100
101     void donate();
102     void drain();
103     void donateAndDrain();
104     
105     enum SharedDrainMode { SlaveDrain, MasterDrain };
106     void drainFromShared(SharedDrainMode);
107
108     void harvestWeakReferences();
109     void finalizeUnconditionalFinalizers();
110     
111     // This informs the GC about auxiliary of some size that we are keeping alive. If you don't do
112     // this then the space will be freed at end of GC.
113     void markAuxiliary(const void* base);
114
115     void reportExtraMemoryVisited(size_t);
116 #if ENABLE(RESOURCE_USAGE)
117     void reportExternalMemoryVisited(size_t);
118 #endif
119     
120     void addWeakReferenceHarvester(WeakReferenceHarvester*);
121     void addUnconditionalFinalizer(UnconditionalFinalizer*);
122
123     void dump(PrintStream&) const;
124
125     bool isBuildingHeapSnapshot() const { return !!m_heapSnapshotBuilder; }
126     
127     HeapVersion markingVersion() const { return m_markingVersion; }
128
129 private:
130     friend class ParallelModeEnabler;
131     
132     JS_EXPORT_PRIVATE void append(JSValue); // This is private to encourage clients to use WriteBarrier<T>.
133     void appendJSCellOrAuxiliary(HeapCell*);
134     void appendHidden(JSValue);
135
136     JS_EXPORT_PRIVATE void setMarkedAndAppendToMarkStack(JSCell*);
137     
138     template<typename ContainerType>
139     void setMarkedAndAppendToMarkStack(ContainerType&, JSCell*);
140     
141     void appendToMarkStack(JSCell*);
142     
143     template<typename ContainerType>
144     void appendToMarkStack(ContainerType&, JSCell*);
145     
146     void noteLiveAuxiliaryCell(HeapCell*);
147     
148     JS_EXPORT_PRIVATE void mergeOpaqueRoots();
149     void mergeOpaqueRootsIfNecessary();
150     void mergeOpaqueRootsIfProfitable();
151
152     void visitChildren(const JSCell*);
153     
154     void donateKnownParallel();
155
156     MarkStackArray m_stack;
157     OpaqueRootSet m_opaqueRoots; // Handle-owning data structures not visible to the garbage collector.
158     
159     size_t m_bytesVisited;
160     size_t m_bytesCopied;
161     size_t m_visitCount;
162     bool m_isInParallelMode;
163     
164     HeapVersion m_markingVersion;
165     
166     Heap& m_heap;
167
168     HeapSnapshotBuilder* m_heapSnapshotBuilder { nullptr };
169     JSCell* m_currentCell { nullptr };
170
171     CellState m_currentObjectCellStateBeforeVisiting { CellState::NewWhite };
172
173 public:
174 #if !ASSERT_DISABLED
175     bool m_isCheckingForDefaultMarkViolation;
176     bool m_isDraining;
177 #endif
178 };
179
180 class ParallelModeEnabler {
181 public:
182     ParallelModeEnabler(SlotVisitor& stack)
183         : m_stack(stack)
184     {
185         ASSERT(!m_stack.m_isInParallelMode);
186         m_stack.m_isInParallelMode = true;
187     }
188     
189     ~ParallelModeEnabler()
190     {
191         ASSERT(m_stack.m_isInParallelMode);
192         m_stack.m_isInParallelMode = false;
193     }
194     
195 private:
196     SlotVisitor& m_stack;
197 };
198
199 } // namespace JSC
200
201 #endif // SlotVisitor_h