Unreviewed, rolling out r184123.
[WebKit-https.git] / Source / JavaScriptCore / runtime / WriteBarrier.h
1 /*
2  * Copyright (C) 2011, 2013 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 WriteBarrier_h
27 #define WriteBarrier_h
28
29 #include "GCAssertions.h"
30 #include "HandleTypes.h"
31 #include "Heap.h"
32 #include "SamplingCounter.h"
33
34 namespace JSC {
35
36 namespace DFG {
37 class DesiredWriteBarrier;
38 }
39
40 class JSCell;
41 class VM;
42 class JSGlobalObject;
43
44 template<class T> class WriteBarrierBase;
45 template<> class WriteBarrierBase<JSValue>;
46
47 JS_EXPORT_PRIVATE void slowValidateCell(JSCell*);
48 JS_EXPORT_PRIVATE void slowValidateCell(JSGlobalObject*);
49     
50 #if ENABLE(GC_VALIDATION)
51 template<class T> inline void validateCell(T cell)
52 {
53     ASSERT_GC_OBJECT_INHERITS(cell, std::remove_pointer<T>::type::info());
54 }
55
56 template<> inline void validateCell<JSCell*>(JSCell* cell)
57 {
58     slowValidateCell(cell);
59 }
60
61 template<> inline void validateCell<JSGlobalObject*>(JSGlobalObject* globalObject)
62 {
63     slowValidateCell(globalObject);
64 }
65 #else
66 template<class T> inline void validateCell(T)
67 {
68 }
69 #endif
70
71 // We have a separate base class with no constructors for use in Unions.
72 template <typename T> class WriteBarrierBase {
73 public:
74     void set(VM&, const JSCell* owner, T* value);
75     
76     // This is meant to be used like operator=, but is called copyFrom instead, in
77     // order to kindly inform the C++ compiler that its advice is not appreciated.
78     void copyFrom(const WriteBarrierBase<T>& other)
79     {
80         m_cell = other.m_cell;
81     }
82
83     void setMayBeNull(VM&, const JSCell* owner, T* value);
84
85     // Should only be used by JSCell during early initialisation
86     // when some basic types aren't yet completely instantiated
87     void setEarlyValue(VM&, const JSCell* owner, T* value);
88     
89     T* get() const
90     {
91         // Copy m_cell to a local to avoid multiple-read issues. (See <http://webkit.org/b/110854>)
92         JSCell* cell = m_cell;
93         if (cell)
94             validateCell(cell);
95         return reinterpret_cast<T*>(static_cast<void*>(cell));
96     }
97
98     T* operator*() const
99     {
100         ASSERT(m_cell);
101         validateCell<T>(static_cast<T*>(m_cell));
102         return static_cast<T*>(m_cell);
103     }
104
105     T* operator->() const
106     {
107         ASSERT(m_cell);
108         validateCell(static_cast<T*>(m_cell));
109         return static_cast<T*>(m_cell);
110     }
111
112     void clear() { m_cell = 0; }
113     
114     T** slot() { return reinterpret_cast<T**>(&m_cell); }
115     
116     typedef T* (WriteBarrierBase::*UnspecifiedBoolType);
117     operator UnspecifiedBoolType*() const { return m_cell ? reinterpret_cast<UnspecifiedBoolType*>(1) : 0; }
118     
119     bool operator!() const { return !m_cell; }
120
121     void setWithoutWriteBarrier(T* value)
122     {
123 #if ENABLE(WRITE_BARRIER_PROFILING)
124         WriteBarrierCounters::usesWithoutBarrierFromCpp.count();
125 #endif
126         this->m_cell = reinterpret_cast<JSCell*>(value);
127     }
128
129 #if ENABLE(GC_VALIDATION)
130     T* unvalidatedGet() const { return reinterpret_cast<T*>(static_cast<void*>(m_cell)); }
131 #endif
132
133 private:
134     JSCell* m_cell;
135 };
136
137 template <> class WriteBarrierBase<Unknown> {
138 public:
139     void set(VM&, const JSCell* owner, JSValue);
140     void setWithoutWriteBarrier(JSValue value)
141     {
142         m_value = JSValue::encode(value);
143     }
144
145     JSValue get() const
146     {
147         return JSValue::decode(m_value);
148     }
149     void clear() { m_value = JSValue::encode(JSValue()); }
150     void setUndefined() { m_value = JSValue::encode(jsUndefined()); }
151     bool isNumber() const { return get().isNumber(); }
152     bool isObject() const { return get().isObject(); }
153     bool isNull() const { return get().isNull(); }
154     bool isGetterSetter() const { return get().isGetterSetter(); }
155     bool isCustomGetterSetter() const { return get().isCustomGetterSetter(); }
156     
157     JSValue* slot()
158     { 
159         union {
160             EncodedJSValue* v;
161             JSValue* slot;
162         } u;
163         u.v = &m_value;
164         return u.slot;
165     }
166     
167     int32_t* tagPointer() { return &bitwise_cast<EncodedValueDescriptor*>(&m_value)->asBits.tag; }
168     int32_t* payloadPointer() { return &bitwise_cast<EncodedValueDescriptor*>(&m_value)->asBits.payload; }
169     
170     typedef JSValue (WriteBarrierBase::*UnspecifiedBoolType);
171     operator UnspecifiedBoolType*() const { return get() ? reinterpret_cast<UnspecifiedBoolType*>(1) : 0; }
172     bool operator!() const { return !get(); } 
173     
174 private:
175     EncodedJSValue m_value;
176 };
177
178 template <typename T> class WriteBarrier : public WriteBarrierBase<T> {
179     WTF_MAKE_FAST_ALLOCATED;
180 public:
181     WriteBarrier()
182     {
183         this->setWithoutWriteBarrier(0);
184     }
185
186     WriteBarrier(VM& vm, const JSCell* owner, T* value)
187     {
188         this->set(vm, owner, value);
189     }
190
191     WriteBarrier(DFG::DesiredWriteBarrier&, T* value)
192     {
193         ASSERT(isCompilationThread());
194         this->setWithoutWriteBarrier(value);
195     }
196
197     enum MayBeNullTag { MayBeNull };
198     WriteBarrier(VM& vm, const JSCell* owner, T* value, MayBeNullTag)
199     {
200         this->setMayBeNull(vm, owner, value);
201     }
202 };
203
204 enum UndefinedWriteBarrierTagType { UndefinedWriteBarrierTag };
205 template <> class WriteBarrier<Unknown> : public WriteBarrierBase<Unknown> {
206     WTF_MAKE_FAST_ALLOCATED;
207 public:
208     WriteBarrier()
209     {
210         this->setWithoutWriteBarrier(JSValue());
211     }
212     WriteBarrier(UndefinedWriteBarrierTagType)
213     {
214         this->setWithoutWriteBarrier(jsUndefined());
215     }
216
217     WriteBarrier(VM& vm, const JSCell* owner, JSValue value)
218     {
219         this->set(vm, owner, value);
220     }
221
222     WriteBarrier(DFG::DesiredWriteBarrier&, JSValue value)
223     {
224         ASSERT(isCompilationThread());
225         this->setWithoutWriteBarrier(value);
226     }
227 };
228
229 template <typename U, typename V> inline bool operator==(const WriteBarrierBase<U>& lhs, const WriteBarrierBase<V>& rhs)
230 {
231     return lhs.get() == rhs.get();
232 }
233
234 } // namespace JSC
235
236 #endif // WriteBarrier_h