1/*
2 * Copyright (C) 2008, 2009, 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. ``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#ifndef StructureTransitionTable_h
27#define StructureTransitionTable_h
28
29#include "IndexingType.h"
30#include "WeakGCMap.h"
31#include <wtf/HashFunctions.h>
32#include <wtf/text/UniquedStringImpl.h>
33
34namespace JSC {
35
36class JSCell;
37class Structure;
38
39static const unsigned FirstInternalAttribute = 1 << 6; // Use for transitions that don't have to do with property additions.
40
41// Support for attributes used to indicate transitions not related to properties.
42// If any of these are used, the string portion of the key should be 0.
43enum NonPropertyTransition {
44 AllocateUndecided,
45 AllocateInt32,
46 AllocateDouble,
47 AllocateContiguous,
48 AllocateArrayStorage,
49 AllocateSlowPutArrayStorage,
50 SwitchToSlowPutArrayStorage,
51 AddIndexedAccessors
52};
53
54inline unsigned toAttributes(NonPropertyTransition transition)
55{
56 return transition + FirstInternalAttribute;
57}
58
59inline IndexingType newIndexingType(IndexingType oldType, NonPropertyTransition transition)
60{
61 switch (transition) {
62 case AllocateUndecided:
63 ASSERT(!hasIndexedProperties(oldType));
64 return oldType | UndecidedShape;
65 case AllocateInt32:
66 ASSERT(!hasIndexedProperties(oldType) || hasUndecided(oldType));
67 return (oldType & ~IndexingShapeMask) | Int32Shape;
68 case AllocateDouble:
69 ASSERT(!hasIndexedProperties(oldType) || hasUndecided(oldType) || hasInt32(oldType));
70 return (oldType & ~IndexingShapeMask) | DoubleShape;
71 case AllocateContiguous:
72 ASSERT(!hasIndexedProperties(oldType) || hasUndecided(oldType) || hasInt32(oldType) || hasDouble(oldType));
73 return (oldType & ~IndexingShapeMask) | ContiguousShape;
74 case AllocateArrayStorage:
75 ASSERT(!hasIndexedProperties(oldType) || hasUndecided(oldType) || hasInt32(oldType) || hasDouble(oldType) || hasContiguous(oldType));
76 return (oldType & ~IndexingShapeMask) | ArrayStorageShape;
77 case AllocateSlowPutArrayStorage:
78 ASSERT(!hasIndexedProperties(oldType) || hasUndecided(oldType) || hasInt32(oldType) || hasDouble(oldType) || hasContiguous(oldType) || hasContiguous(oldType));
79 return (oldType & ~IndexingShapeMask) | SlowPutArrayStorageShape;
80 case SwitchToSlowPutArrayStorage:
81 ASSERT(hasArrayStorage(oldType));
82 return (oldType & ~IndexingShapeMask) | SlowPutArrayStorageShape;
83 case AddIndexedAccessors:
84 return oldType | MayHaveIndexedAccessors;
85 default:
86 RELEASE_ASSERT_NOT_REACHED();
87 return oldType;
88 }
89}
90
91class StructureTransitionTable {
92 static const intptr_t UsingSingleSlotFlag = 1;
93
94
95 struct Hash {
96 typedef std::pair<UniquedStringImpl*, unsigned> Key;
97
98 static unsigned hash(const Key& p)
99 {
100 return PtrHash<UniquedStringImpl*>::hash(p.first) + p.second;
101 }
102
103 static bool equal(const Key& a, const Key& b)
104 {
105 return a == b;
106 }
107
108 static const bool safeToCompareToEmptyOrDeleted = true;
109 };
110
111 typedef WeakGCMap<Hash::Key, Structure, Hash> TransitionMap;
112
113public:
114 StructureTransitionTable()
115 : m_data(UsingSingleSlotFlag)
116 {
117 }
118
119 ~StructureTransitionTable()
120 {
121 if (!isUsingSingleSlot()) {
122 delete map();
123 return;
124 }
125
126 WeakImpl* impl = this->weakImpl();
127 if (!impl)
128 return;
129 WeakSet::deallocate(impl);
130 }
131
132 void add(VM&, Structure*);
133 bool contains(UniquedStringImpl*, unsigned attributes) const;
134 Structure* get(UniquedStringImpl*, unsigned attributes) const;
135
136private:
137 friend class SingleSlotTransitionWeakOwner;
138
139 bool isUsingSingleSlot() const
140 {
141 return m_data & UsingSingleSlotFlag;
142 }
143
144 TransitionMap* map() const
145 {
146 ASSERT(!isUsingSingleSlot());
147 return reinterpret_cast<TransitionMap*>(m_data);
148 }
149
150 WeakImpl* weakImpl() const
151 {
152 ASSERT(isUsingSingleSlot());
153 return reinterpret_cast<WeakImpl*>(m_data & ~UsingSingleSlotFlag);
154 }
155
156 void setMap(TransitionMap* map)
157 {
158 ASSERT(isUsingSingleSlot());
159
160 if (WeakImpl* impl = this->weakImpl())
161 WeakSet::deallocate(impl);
162
163 // This implicitly clears the flag that indicates we're using a single transition
164 m_data = reinterpret_cast<intptr_t>(map);
165
166 ASSERT(!isUsingSingleSlot());
167 }
168
169 Structure* singleTransition() const;
170 void setSingleTransition(Structure*);
171
172 intptr_t m_data;
173};
174
175} // namespace JSC
176
177#endif // StructureTransitionTable_h
178