Heap Snapshot should include different Edge types and data (Property, Index, Variable)
[WebKit-https.git] / Source / JavaScriptCore / heap / SlotVisitor.h
1 /*
2  * Copyright (C) 2011-2013, 2015 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(JITWriteBarrier<T>*);
69     template<typename T> void append(WriteBarrierBase<T>*);
70     template<typename T> void appendHidden(WriteBarrierBase<T>*);
71     template<typename Iterator> void append(Iterator begin , Iterator end);
72     void appendValues(WriteBarrierBase<Unknown>*, size_t count);
73     void appendValuesHidden(WriteBarrierBase<Unknown>*, size_t count);
74     
75     template<typename T>
76     void appendUnbarrieredPointer(T**);
77     void appendUnbarrieredValue(JSValue*);
78     template<typename T>
79     void appendUnbarrieredWeak(Weak<T>*);
80     template<typename T>
81     void appendUnbarrieredReadOnlyPointer(T*);
82     void appendUnbarrieredReadOnlyValue(JSValue);
83     
84     JS_EXPORT_PRIVATE void addOpaqueRoot(void*);
85     JS_EXPORT_PRIVATE bool containsOpaqueRoot(void*) const;
86     TriState containsOpaqueRootTriState(void*) const;
87     int opaqueRootCount();
88
89     bool isEmpty() { return m_stack.isEmpty(); }
90
91     void didStartMarking();
92     void reset();
93     void clearMarkStack();
94
95     size_t bytesVisited() const { return m_bytesVisited; }
96     size_t bytesCopied() const { return m_bytesCopied; }
97     size_t visitCount() const { return m_visitCount; }
98
99     void donate();
100     void drain();
101     void donateAndDrain();
102     
103     enum SharedDrainMode { SlaveDrain, MasterDrain };
104     void drainFromShared(SharedDrainMode);
105
106     void harvestWeakReferences();
107     void finalizeUnconditionalFinalizers();
108
109     void copyLater(JSCell*, CopyToken, void*, size_t);
110     
111     void reportExtraMemoryVisited(size_t);
112     
113     void addWeakReferenceHarvester(WeakReferenceHarvester*);
114     void addUnconditionalFinalizer(UnconditionalFinalizer*);
115
116     void dump(PrintStream&) const;
117
118     bool isBuildingHeapSnapshot() const { return !!m_heapSnapshotBuilder; }
119
120 private:
121     friend class ParallelModeEnabler;
122     
123     JS_EXPORT_PRIVATE void append(JSValue); // This is private to encourage clients to use WriteBarrier<T>.
124     void appendHidden(JSValue);
125
126     JS_EXPORT_PRIVATE void setMarkedAndAppendToMarkStack(JSCell*);
127     void appendToMarkStack(JSCell*);
128     
129     JS_EXPORT_PRIVATE void mergeOpaqueRoots();
130     void mergeOpaqueRootsIfNecessary();
131     void mergeOpaqueRootsIfProfitable();
132
133     void visitChildren(const JSCell*);
134     
135     void donateKnownParallel();
136
137     MarkStackArray m_stack;
138     OpaqueRootSet m_opaqueRoots; // Handle-owning data structures not visible to the garbage collector.
139     
140     size_t m_bytesVisited;
141     size_t m_bytesCopied;
142     size_t m_visitCount;
143     bool m_isInParallelMode;
144     
145     Heap& m_heap;
146
147     HeapSnapshotBuilder* m_heapSnapshotBuilder { nullptr };
148     JSCell* m_currentCell { nullptr };
149
150     CellState m_currentObjectCellStateBeforeVisiting { CellState::NewWhite };
151
152 public:
153 #if !ASSERT_DISABLED
154     bool m_isCheckingForDefaultMarkViolation;
155     bool m_isDraining;
156 #endif
157 };
158
159 class ParallelModeEnabler {
160 public:
161     ParallelModeEnabler(SlotVisitor& stack)
162         : m_stack(stack)
163     {
164         ASSERT(!m_stack.m_isInParallelMode);
165         m_stack.m_isInParallelMode = true;
166     }
167     
168     ~ParallelModeEnabler()
169     {
170         ASSERT(m_stack.m_isInParallelMode);
171         m_stack.m_isInParallelMode = false;
172     }
173     
174 private:
175     SlotVisitor& m_stack;
176 };
177
178 } // namespace JSC
179
180 #endif // SlotVisitor_h