Remove unused SlotVisitor::append() variant.
[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 "CopyToken.h"
31 #include "HandleTypes.h"
32 #include "MarkStack.h"
33 #include "OpaqueRootSet.h"
34
35 namespace JSC {
36
37 class ConservativeRoots;
38 class GCThreadSharedData;
39 class Heap;
40 class HeapSnapshotBuilder;
41 template<typename T> class JITWriteBarrier;
42 class UnconditionalFinalizer;
43 template<typename T> class Weak;
44 class WeakReferenceHarvester;
45 template<typename T> class WriteBarrierBase;
46
47 class SlotVisitor {
48     WTF_MAKE_NONCOPYABLE(SlotVisitor);
49     WTF_MAKE_FAST_ALLOCATED;
50
51     friend class SetCurrentCellScope;
52     friend class HeapRootVisitor; // Allowed to mark a JSValue* or JSCell** directly.
53     friend class Heap;
54
55 public:
56     SlotVisitor(Heap&);
57     ~SlotVisitor();
58
59     MarkStackArray& markStack() { return m_stack; }
60     const MarkStackArray& markStack() const { return m_stack; }
61
62     VM& vm();
63     const VM& vm() const;
64     Heap* heap() const;
65
66     void append(ConservativeRoots&);
67     
68     template<typename T> void append(WriteBarrierBase<T>*);
69     template<typename T> void appendHidden(WriteBarrierBase<T>*);
70     template<typename Iterator> void append(Iterator begin , Iterator end);
71     void appendValues(WriteBarrierBase<Unknown>*, size_t count);
72     void appendValuesHidden(WriteBarrierBase<Unknown>*, size_t count);
73     
74     template<typename T>
75     void appendUnbarrieredPointer(T**);
76     void appendUnbarrieredValue(JSValue*);
77     template<typename T>
78     void appendUnbarrieredWeak(Weak<T>*);
79     template<typename T>
80     void appendUnbarrieredReadOnlyPointer(T*);
81     void appendUnbarrieredReadOnlyValue(JSValue);
82     
83     JS_EXPORT_PRIVATE void addOpaqueRoot(void*);
84     JS_EXPORT_PRIVATE bool containsOpaqueRoot(void*) const;
85     TriState containsOpaqueRootTriState(void*) const;
86     int opaqueRootCount();
87
88     bool isEmpty() { return m_stack.isEmpty(); }
89
90     void didStartMarking();
91     void reset();
92     void clearMarkStack();
93
94     size_t bytesVisited() const { return m_bytesVisited; }
95     size_t bytesCopied() const { return m_bytesCopied; }
96     size_t visitCount() const { return m_visitCount; }
97
98     void donate();
99     void drain();
100     void donateAndDrain();
101     
102     enum SharedDrainMode { SlaveDrain, MasterDrain };
103     void drainFromShared(SharedDrainMode);
104
105     void harvestWeakReferences();
106     void finalizeUnconditionalFinalizers();
107
108     void copyLater(JSCell*, CopyToken, void*, size_t);
109     
110     void reportExtraMemoryVisited(size_t);
111 #if ENABLE(RESOURCE_USAGE)
112     void reportExternalMemoryVisited(size_t);
113 #endif
114     
115     void addWeakReferenceHarvester(WeakReferenceHarvester*);
116     void addUnconditionalFinalizer(UnconditionalFinalizer*);
117
118     void dump(PrintStream&) const;
119
120     bool isBuildingHeapSnapshot() const { return !!m_heapSnapshotBuilder; }
121
122 private:
123     friend class ParallelModeEnabler;
124     
125     JS_EXPORT_PRIVATE void append(JSValue); // This is private to encourage clients to use WriteBarrier<T>.
126     void appendHidden(JSValue);
127
128     JS_EXPORT_PRIVATE void setMarkedAndAppendToMarkStack(JSCell*);
129     void appendToMarkStack(JSCell*);
130     
131     JS_EXPORT_PRIVATE void mergeOpaqueRoots();
132     void mergeOpaqueRootsIfNecessary();
133     void mergeOpaqueRootsIfProfitable();
134
135     void visitChildren(const JSCell*);
136     
137     void donateKnownParallel();
138
139     MarkStackArray m_stack;
140     OpaqueRootSet m_opaqueRoots; // Handle-owning data structures not visible to the garbage collector.
141     
142     size_t m_bytesVisited;
143     size_t m_bytesCopied;
144     size_t m_visitCount;
145     bool m_isInParallelMode;
146     
147     Heap& m_heap;
148
149     HeapSnapshotBuilder* m_heapSnapshotBuilder { nullptr };
150     JSCell* m_currentCell { nullptr };
151
152     CellState m_currentObjectCellStateBeforeVisiting { CellState::NewWhite };
153
154 public:
155 #if !ASSERT_DISABLED
156     bool m_isCheckingForDefaultMarkViolation;
157     bool m_isDraining;
158 #endif
159 };
160
161 class ParallelModeEnabler {
162 public:
163     ParallelModeEnabler(SlotVisitor& stack)
164         : m_stack(stack)
165     {
166         ASSERT(!m_stack.m_isInParallelMode);
167         m_stack.m_isInParallelMode = true;
168     }
169     
170     ~ParallelModeEnabler()
171     {
172         ASSERT(m_stack.m_isInParallelMode);
173         m_stack.m_isInParallelMode = false;
174     }
175     
176 private:
177     SlotVisitor& m_stack;
178 };
179
180 } // namespace JSC
181
182 #endif // SlotVisitor_h