some Watchpoints' ::fireInternal method will call operations that might GC where...
[WebKit-https.git] / Source / JavaScriptCore / bytecode / Watchpoint.cpp
1 /*
2  * Copyright (C) 2012-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. ``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 #include "config.h"
27 #include "Watchpoint.h"
28
29 #include "HeapInlines.h"
30 #include "VM.h"
31 #include <wtf/CompilationThread.h>
32 #include <wtf/PassRefPtr.h>
33
34 namespace JSC {
35
36 void StringFireDetail::dump(PrintStream& out) const
37 {
38     out.print(m_string);
39 }
40
41 Watchpoint::~Watchpoint()
42 {
43     if (isOnList()) {
44         // This will happen if we get destroyed before the set fires. That's totally a valid
45         // possibility. For example:
46         //
47         // CodeBlock has a Watchpoint on transition from structure S1. The transition never
48         // happens, but the CodeBlock gets destroyed because of GC.
49         remove();
50     }
51 }
52
53 void Watchpoint::fire(const FireDetail& detail)
54 {
55     RELEASE_ASSERT(!isOnList());
56     fireInternal(detail);
57 }
58
59 WatchpointSet::WatchpointSet(WatchpointState state)
60     : m_state(state)
61     , m_setIsNotEmpty(false)
62 {
63 }
64
65 WatchpointSet::~WatchpointSet()
66 {
67     // Remove all watchpoints, so that they don't try to remove themselves. Note that we
68     // don't fire watchpoints on deletion. We assume that any code that is interested in
69     // watchpoints already also separately has a mechanism to make sure that the code is
70     // either keeping the watchpoint set's owner alive, or does some weak reference thing.
71     while (!m_set.isEmpty())
72         m_set.begin()->remove();
73 }
74
75 void WatchpointSet::add(Watchpoint* watchpoint)
76 {
77     ASSERT(!isCompilationThread());
78     ASSERT(state() != IsInvalidated);
79     if (!watchpoint)
80         return;
81     m_set.push(watchpoint);
82     m_setIsNotEmpty = true;
83     m_state = IsWatched;
84 }
85
86 void WatchpointSet::fireAllSlow(VM& vm, const FireDetail& detail)
87 {
88     ASSERT(state() == IsWatched);
89     
90     WTF::storeStoreFence();
91     m_state = IsInvalidated; // Do this first. Needed for adaptive watchpoints.
92     fireAllWatchpoints(vm, detail);
93     WTF::storeStoreFence();
94 }
95
96 void WatchpointSet::fireAllSlow(VM& vm, const char* reason)
97 {
98     fireAllSlow(vm, StringFireDetail(reason));
99 }
100
101 void WatchpointSet::fireAllWatchpoints(VM& vm, const FireDetail& detail)
102 {
103     // In case there are any adaptive watchpoints, we need to make sure that they see that this
104     // watchpoint has been already invalidated.
105     RELEASE_ASSERT(hasBeenInvalidated());
106
107     // Firing a watchpoint may cause a GC to happen. This GC could destroy various
108     // Watchpoints themselves while they're in the process of firing. It's not safe
109     // for most Watchpoints to be destructed while they're in the middle of firing.
110     // This GC could also destroy us, and we're not in a safe state to be destroyed.
111     // The safest thing to do is to DeferGCForAWhile to prevent this GC from happening.
112     DeferGCForAWhile deferGC(vm.heap);
113     
114     while (!m_set.isEmpty()) {
115         Watchpoint* watchpoint = m_set.begin();
116         ASSERT(watchpoint->isOnList());
117         
118         // Removing the Watchpoint before firing it makes it possible to implement watchpoints
119         // that add themselves to a different set when they fire. This kind of "adaptive"
120         // watchpoint can be used to track some semantic property that is more fine-graiend than
121         // what the set can convey. For example, we might care if a singleton object ever has a
122         // property called "foo". We can watch for this by checking if its Structure has "foo" and
123         // then watching its transitions. But then the watchpoint fires if any property is added.
124         // So, before the watchpoint decides to invalidate any code, it can check if it is
125         // possible to add itself to the transition watchpoint set of the singleton object's new
126         // Structure.
127         watchpoint->remove();
128         ASSERT(m_set.begin() != watchpoint);
129         ASSERT(!watchpoint->isOnList());
130         
131         watchpoint->fire(detail);
132         // After we fire the watchpoint, the watchpoint pointer may be a dangling pointer. That's
133         // fine, because we have no use for the pointer anymore.
134     }
135 }
136
137 void InlineWatchpointSet::add(Watchpoint* watchpoint)
138 {
139     inflate()->add(watchpoint);
140 }
141
142 void InlineWatchpointSet::fireAll(VM& vm, const char* reason)
143 {
144     fireAll(vm, StringFireDetail(reason));
145 }
146
147 WatchpointSet* InlineWatchpointSet::inflateSlow()
148 {
149     ASSERT(isThin());
150     ASSERT(!isCompilationThread());
151     WatchpointSet* fat = adoptRef(new WatchpointSet(decodeState(m_data))).leakRef();
152     WTF::storeStoreFence();
153     m_data = bitwise_cast<uintptr_t>(fat);
154     return fat;
155 }
156
157 void InlineWatchpointSet::freeFat()
158 {
159     ASSERT(isFat());
160     fat()->deref();
161 }
162
163 } // namespace JSC
164