2 * Copyright (C) 2011 Apple Inc. All rights reserved.
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
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.
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.
26 #ifndef WriteBarrier_h
27 #define WriteBarrier_h
29 #include "GCAssertions.h"
30 #include "HandleTypes.h"
32 #include "SamplingCounter.h"
33 #include <wtf/TypeTraits.h>
41 template<class T
> class WriteBarrierBase
;
42 template<> class WriteBarrierBase
<JSValue
>;
44 JS_EXPORT_PRIVATE
void slowValidateCell(JSCell
*);
45 JS_EXPORT_PRIVATE
void slowValidateCell(JSGlobalObject
*);
47 #if ENABLE(GC_VALIDATION)
48 template<class T
> inline void validateCell(T cell
)
50 ASSERT_GC_OBJECT_INHERITS(cell
, &WTF::RemovePointer
<T
>::Type::s_info
);
53 template<> inline void validateCell
<JSCell
*>(JSCell
* cell
)
55 slowValidateCell(cell
);
58 template<> inline void validateCell
<JSGlobalObject
*>(JSGlobalObject
* globalObject
)
60 slowValidateCell(globalObject
);
63 template<class T
> inline void validateCell(T
)
68 // We have a separate base class with no constructors for use in Unions.
69 template <typename T
> class WriteBarrierBase
{
71 void set(VM
& vm
, const JSCell
* owner
, T
* value
)
75 setEarlyValue(vm
, owner
, value
);
78 // This is meant to be used like operator=, but is called copyFrom instead, in
79 // order to kindly inform the C++ compiler that its advice is not appreciated.
80 void copyFrom(const WriteBarrierBase
<T
>& other
)
82 m_cell
= other
.m_cell
;
85 void setMayBeNull(VM
& vm
, const JSCell
* owner
, T
* value
)
89 setEarlyValue(vm
, owner
, value
);
92 // Should only be used by JSCell during early initialisation
93 // when some basic types aren't yet completely instantiated
94 void setEarlyValue(VM
&, const JSCell
* owner
, T
* value
)
96 this->m_cell
= reinterpret_cast<JSCell
*>(value
);
97 Heap::writeBarrier(owner
, this->m_cell
);
102 // Copy m_cell to a local to avoid multiple-read issues. (See <http://webkit.org/b/110854>)
103 JSCell
* cell
= m_cell
;
106 return reinterpret_cast<T
*>(static_cast<void*>(cell
));
112 validateCell
<T
>(static_cast<T
*>(m_cell
));
113 return static_cast<T
*>(m_cell
);
116 T
* operator->() const
119 validateCell(static_cast<T
*>(m_cell
));
120 return static_cast<T
*>(m_cell
);
123 void clear() { m_cell
= 0; }
125 JSCell
** slot() { return &m_cell
; }
127 typedef T
* (WriteBarrierBase::*UnspecifiedBoolType
);
128 operator UnspecifiedBoolType
*() const { return m_cell
? reinterpret_cast<UnspecifiedBoolType
*>(1) : 0; }
130 bool operator!() const { return !m_cell
; }
132 void setWithoutWriteBarrier(T
* value
)
134 #if ENABLE(WRITE_BARRIER_PROFILING)
135 WriteBarrierCounters::usesWithoutBarrierFromCpp
.count();
137 this->m_cell
= reinterpret_cast<JSCell
*>(value
);
140 #if ENABLE(GC_VALIDATION)
141 T
* unvalidatedGet() const { return reinterpret_cast<T
*>(static_cast<void*>(m_cell
)); }
148 template <> class WriteBarrierBase
<Unknown
> {
150 void set(VM
&, const JSCell
* owner
, JSValue value
)
152 m_value
= JSValue::encode(value
);
153 Heap::writeBarrier(owner
, value
);
156 void setWithoutWriteBarrier(JSValue value
)
158 m_value
= JSValue::encode(value
);
163 return JSValue::decode(m_value
);
165 void clear() { m_value
= JSValue::encode(JSValue()); }
166 void setUndefined() { m_value
= JSValue::encode(jsUndefined()); }
167 bool isNumber() const { return get().isNumber(); }
168 bool isObject() const { return get().isObject(); }
169 bool isNull() const { return get().isNull(); }
170 bool isGetterSetter() const { return get().isGetterSetter(); }
182 int32_t* tagPointer() { return &bitwise_cast
<EncodedValueDescriptor
*>(&m_value
)->asBits
.tag
; }
183 int32_t* payloadPointer() { return &bitwise_cast
<EncodedValueDescriptor
*>(&m_value
)->asBits
.payload
; }
185 typedef JSValue (WriteBarrierBase::*UnspecifiedBoolType
);
186 operator UnspecifiedBoolType
*() const { return get() ? reinterpret_cast<UnspecifiedBoolType
*>(1) : 0; }
187 bool operator!() const { return !get(); }
190 EncodedJSValue m_value
;
193 template <typename T
> class WriteBarrier
: public WriteBarrierBase
<T
> {
197 this->setWithoutWriteBarrier(0);
200 WriteBarrier(VM
& vm
, const JSCell
* owner
, T
* value
)
202 this->set(vm
, owner
, value
);
205 enum MayBeNullTag
{ MayBeNull
};
206 WriteBarrier(VM
& vm
, const JSCell
* owner
, T
* value
, MayBeNullTag
)
208 this->setMayBeNull(vm
, owner
, value
);
212 template <> class WriteBarrier
<Unknown
> : public WriteBarrierBase
<Unknown
> {
216 this->setWithoutWriteBarrier(JSValue());
219 WriteBarrier(VM
& vm
, const JSCell
* owner
, JSValue value
)
221 this->set(vm
, owner
, value
);
225 template <typename U
, typename V
> inline bool operator==(const WriteBarrierBase
<U
>& lhs
, const WriteBarrierBase
<V
>& rhs
)
227 return lhs
.get() == rhs
.get();
230 // SlotVisitor functions
232 template<typename T
> inline void SlotVisitor::append(WriteBarrierBase
<T
>* slot
)
234 internalAppend(*slot
->slot());
237 ALWAYS_INLINE
void SlotVisitor::appendValues(WriteBarrierBase
<Unknown
>* barriers
, size_t count
)
239 append(barriers
->slot(), count
);
244 #endif // WriteBarrier_h