1/*
2 * Copyright (C) 2011-2019 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#pragma once
27
28#include <wtf/Assertions.h>
29#include "Handle.h"
30#include "HandleSet.h"
31#include "JSLock.h"
32
33namespace JSC {
34
35class VM;
36
37// A strongly referenced handle that prevents the object it points to from being garbage collected.
38template <typename T, ShouldStrongDestructorGrabLock shouldStrongDestructorGrabLock = ShouldStrongDestructorGrabLock::No> class Strong : public Handle<T> {
39 using Handle<T>::slot;
40 using Handle<T>::setSlot;
41 template <typename U, ShouldStrongDestructorGrabLock> friend class Strong;
42
43public:
44 typedef typename Handle<T>::ExternalType ExternalType;
45
46 Strong()
47 : Handle<T>()
48 {
49 }
50
51 Strong(VM&, ExternalType = ExternalType());
52
53 Strong(VM&, Handle<T>);
54
55 Strong(const Strong& other)
56 : Handle<T>()
57 {
58 if (!other.slot())
59 return;
60 setSlot(HandleSet::heapFor(other.slot())->allocate());
61 set(other.get());
62 }
63
64 template <typename U> Strong(const Strong<U>& other)
65 : Handle<T>()
66 {
67 if (!other.slot())
68 return;
69 setSlot(HandleSet::heapFor(other.slot())->allocate());
70 set(other.get());
71 }
72
73 enum HashTableDeletedValueTag { HashTableDeletedValue };
74 bool isHashTableDeletedValue() const { return slot() == hashTableDeletedValue(); }
75 Strong(HashTableDeletedValueTag)
76 : Handle<T>(hashTableDeletedValue())
77 {
78 }
79
80 ~Strong()
81 {
82 clear();
83 }
84
85 bool operator!() const { return !slot() || !*slot(); }
86
87 explicit operator bool() const { return !!*this; }
88
89 void swap(Strong& other)
90 {
91 Handle<T>::swap(other);
92 }
93
94 ExternalType get() const { return HandleTypes<T>::getFromSlot(this->slot()); }
95
96 void set(VM&, ExternalType);
97
98 template <typename U> Strong& operator=(const Strong<U>& other)
99 {
100 if (!other.slot()) {
101 clear();
102 return *this;
103 }
104
105 set(*HandleSet::heapFor(other.slot())->vm(), other.get());
106 return *this;
107 }
108
109 Strong& operator=(const Strong& other)
110 {
111 if (!other.slot()) {
112 clear();
113 return *this;
114 }
115
116 set(HandleSet::heapFor(other.slot())->vm(), other.get());
117 return *this;
118 }
119
120 void clear()
121 {
122 if (!slot())
123 return;
124
125 auto* heap = HandleSet::heapFor(slot());
126 if (shouldStrongDestructorGrabLock == ShouldStrongDestructorGrabLock::Yes) {
127 JSLockHolder holder(heap->vm());
128 heap->deallocate(slot());
129 setSlot(0);
130 } else {
131 heap->deallocate(slot());
132 setSlot(0);
133 }
134 }
135
136private:
137 static HandleSlot hashTableDeletedValue() { return reinterpret_cast<HandleSlot>(-1); }
138
139 void set(ExternalType externalType)
140 {
141 ASSERT(slot());
142 JSValue value = HandleTypes<T>::toJSValue(externalType);
143 HandleSet::heapFor(slot())->writeBarrier(slot(), value);
144 *slot() = value;
145 }
146};
147
148template<class T> inline void swap(Strong<T>& a, Strong<T>& b)
149{
150 a.swap(b);
151}
152
153} // namespace JSC
154
155namespace WTF {
156
157template<typename T> struct VectorTraits<JSC::Strong<T>> : SimpleClassVectorTraits {
158 static constexpr bool canCompareWithMemcmp = false;
159};
160
161template<typename P> struct HashTraits<JSC::Strong<P>> : SimpleClassHashTraits<JSC::Strong<P>> { };
162
163} // namespace WTF
164