Line data Source code
1 : // Copyright 2012 the V8 project authors. All rights reserved.
2 : // Use of this source code is governed by a BSD-style license that can be
3 : // found in the LICENSE file.
4 :
5 : #ifndef V8_ELEMENTS_KIND_H_
6 : #define V8_ELEMENTS_KIND_H_
7 :
8 : #include "src/base/macros.h"
9 : #include "src/checks.h"
10 :
11 : namespace v8 {
12 : namespace internal {
13 :
14 : enum ElementsKind {
15 : // The "fast" kind for elements that only contain SMI values. Must be first
16 : // to make it possible to efficiently check maps for this kind.
17 : PACKED_SMI_ELEMENTS,
18 : HOLEY_SMI_ELEMENTS,
19 :
20 : // The "fast" kind for tagged values. Must be second to make it possible to
21 : // efficiently check maps for this and the PACKED_SMI_ELEMENTS kind
22 : // together at once.
23 : PACKED_ELEMENTS,
24 : HOLEY_ELEMENTS,
25 :
26 : // The "fast" kind for unwrapped, non-tagged double values.
27 : PACKED_DOUBLE_ELEMENTS,
28 : HOLEY_DOUBLE_ELEMENTS,
29 :
30 : // The "slow" kind.
31 : DICTIONARY_ELEMENTS,
32 :
33 : // Elements kind of the "arguments" object (only in sloppy mode).
34 : FAST_SLOPPY_ARGUMENTS_ELEMENTS,
35 : SLOW_SLOPPY_ARGUMENTS_ELEMENTS,
36 :
37 : // For string wrapper objects ("new String('...')"), the string's characters
38 : // are overlaid onto a regular elements backing store.
39 : FAST_STRING_WRAPPER_ELEMENTS,
40 : SLOW_STRING_WRAPPER_ELEMENTS,
41 :
42 : // Fixed typed arrays.
43 : UINT8_ELEMENTS,
44 : INT8_ELEMENTS,
45 : UINT16_ELEMENTS,
46 : INT16_ELEMENTS,
47 : UINT32_ELEMENTS,
48 : INT32_ELEMENTS,
49 : FLOAT32_ELEMENTS,
50 : FLOAT64_ELEMENTS,
51 : UINT8_CLAMPED_ELEMENTS,
52 :
53 : // Sentinel ElementsKind for objects with no elements.
54 : NO_ELEMENTS,
55 :
56 : // Derived constants from ElementsKind.
57 : FIRST_ELEMENTS_KIND = PACKED_SMI_ELEMENTS,
58 : LAST_ELEMENTS_KIND = UINT8_CLAMPED_ELEMENTS,
59 : FIRST_FAST_ELEMENTS_KIND = PACKED_SMI_ELEMENTS,
60 : LAST_FAST_ELEMENTS_KIND = HOLEY_DOUBLE_ELEMENTS,
61 : FIRST_FIXED_TYPED_ARRAY_ELEMENTS_KIND = UINT8_ELEMENTS,
62 : LAST_FIXED_TYPED_ARRAY_ELEMENTS_KIND = UINT8_CLAMPED_ELEMENTS,
63 : TERMINAL_FAST_ELEMENTS_KIND = HOLEY_ELEMENTS
64 : };
65 :
66 : const int kElementsKindCount = LAST_ELEMENTS_KIND - FIRST_ELEMENTS_KIND + 1;
67 : const int kFastElementsKindCount =
68 : LAST_FAST_ELEMENTS_KIND - FIRST_FAST_ELEMENTS_KIND + 1;
69 :
70 : // The number to add to a packed elements kind to reach a holey elements kind
71 : const int kFastElementsKindPackedToHoley =
72 : HOLEY_SMI_ELEMENTS - PACKED_SMI_ELEMENTS;
73 :
74 : int ElementsKindToShiftSize(ElementsKind elements_kind);
75 : int GetDefaultHeaderSizeForElementsKind(ElementsKind elements_kind);
76 : const char* ElementsKindToString(ElementsKind kind);
77 :
78 : inline ElementsKind GetInitialFastElementsKind() { return PACKED_SMI_ELEMENTS; }
79 :
80 : ElementsKind GetFastElementsKindFromSequenceIndex(int sequence_number);
81 : int GetSequenceIndexFromFastElementsKind(ElementsKind elements_kind);
82 :
83 : ElementsKind GetNextTransitionElementsKind(ElementsKind elements_kind);
84 :
85 : inline bool IsDictionaryElementsKind(ElementsKind kind) {
86 : return kind == DICTIONARY_ELEMENTS;
87 : }
88 :
89 : inline bool IsSloppyArgumentsElementsKind(ElementsKind kind) {
90 7377337 : return kind == FAST_SLOPPY_ARGUMENTS_ELEMENTS ||
91 1203327 : kind == SLOW_SLOPPY_ARGUMENTS_ELEMENTS;
92 : }
93 :
94 : inline bool IsStringWrapperElementsKind(ElementsKind kind) {
95 6174177 : return kind == FAST_STRING_WRAPPER_ELEMENTS ||
96 93274 : kind == SLOW_STRING_WRAPPER_ELEMENTS;
97 : }
98 :
99 2515 : inline bool IsFixedTypedArrayElementsKind(ElementsKind kind) {
100 34520145 : return kind >= FIRST_FIXED_TYPED_ARRAY_ELEMENTS_KIND &&
101 1545804 : kind <= LAST_FIXED_TYPED_ARRAY_ELEMENTS_KIND;
102 : }
103 :
104 : inline bool IsTerminalElementsKind(ElementsKind kind) {
105 177646 : return kind == TERMINAL_FAST_ELEMENTS_KIND ||
106 : IsFixedTypedArrayElementsKind(kind);
107 : }
108 :
109 5853 : inline bool IsFastElementsKind(ElementsKind kind) {
110 : STATIC_ASSERT(FIRST_FAST_ELEMENTS_KIND == 0);
111 99739337 : return kind <= HOLEY_DOUBLE_ELEMENTS;
112 : }
113 :
114 : inline bool IsTransitionElementsKind(ElementsKind kind) {
115 837 : return IsFastElementsKind(kind) || IsFixedTypedArrayElementsKind(kind) ||
116 429796 : kind == FAST_SLOPPY_ARGUMENTS_ELEMENTS ||
117 837 : kind == FAST_STRING_WRAPPER_ELEMENTS;
118 : }
119 :
120 : inline bool IsDoubleElementsKind(ElementsKind kind) {
121 30961766 : return kind == PACKED_DOUBLE_ELEMENTS || kind == HOLEY_DOUBLE_ELEMENTS;
122 : }
123 :
124 :
125 : inline bool IsFixedFloatElementsKind(ElementsKind kind) {
126 : return kind == FLOAT32_ELEMENTS || kind == FLOAT64_ELEMENTS;
127 : }
128 :
129 :
130 : inline bool IsDoubleOrFloatElementsKind(ElementsKind kind) {
131 : return IsDoubleElementsKind(kind) || IsFixedFloatElementsKind(kind);
132 : }
133 :
134 : inline bool IsSmiOrObjectElementsKind(ElementsKind kind) {
135 : return kind == PACKED_SMI_ELEMENTS || kind == HOLEY_SMI_ELEMENTS ||
136 1502121 : kind == PACKED_ELEMENTS || kind == HOLEY_ELEMENTS;
137 : }
138 :
139 : inline bool IsSmiElementsKind(ElementsKind kind) {
140 1775593 : return kind == PACKED_SMI_ELEMENTS || kind == HOLEY_SMI_ELEMENTS;
141 : }
142 :
143 26192 : inline bool IsFastNumberElementsKind(ElementsKind kind) {
144 29251 : return IsSmiElementsKind(kind) || IsDoubleElementsKind(kind);
145 : }
146 :
147 : inline bool IsObjectElementsKind(ElementsKind kind) {
148 10564002 : return kind == PACKED_ELEMENTS || kind == HOLEY_ELEMENTS;
149 : }
150 :
151 2419 : inline bool IsHoleyElementsKind(ElementsKind kind) {
152 16650330 : return kind == HOLEY_SMI_ELEMENTS || kind == HOLEY_DOUBLE_ELEMENTS ||
153 2419 : kind == HOLEY_ELEMENTS;
154 : }
155 :
156 : inline bool IsHoleyOrDictionaryElementsKind(ElementsKind kind) {
157 8541412 : return IsHoleyElementsKind(kind) || kind == DICTIONARY_ELEMENTS;
158 : }
159 :
160 :
161 5224 : inline bool IsFastPackedElementsKind(ElementsKind kind) {
162 2339261 : return kind == PACKED_SMI_ELEMENTS || kind == PACKED_DOUBLE_ELEMENTS ||
163 5224 : kind == PACKED_ELEMENTS;
164 : }
165 :
166 :
167 : inline ElementsKind GetPackedElementsKind(ElementsKind holey_kind) {
168 412612 : if (holey_kind == HOLEY_SMI_ELEMENTS) {
169 : return PACKED_SMI_ELEMENTS;
170 : }
171 289786 : if (holey_kind == HOLEY_DOUBLE_ELEMENTS) {
172 : return PACKED_DOUBLE_ELEMENTS;
173 : }
174 289659 : if (holey_kind == HOLEY_ELEMENTS) {
175 : return PACKED_ELEMENTS;
176 : }
177 : return holey_kind;
178 : }
179 :
180 :
181 761 : inline ElementsKind GetHoleyElementsKind(ElementsKind packed_kind) {
182 16543055 : if (packed_kind == PACKED_SMI_ELEMENTS) {
183 : return HOLEY_SMI_ELEMENTS;
184 : }
185 11261936 : if (packed_kind == PACKED_DOUBLE_ELEMENTS) {
186 : return HOLEY_DOUBLE_ELEMENTS;
187 : }
188 11021114 : if (packed_kind == PACKED_ELEMENTS) {
189 : return HOLEY_ELEMENTS;
190 : }
191 0 : return packed_kind;
192 : }
193 :
194 :
195 : inline ElementsKind FastSmiToObjectElementsKind(ElementsKind from_kind) {
196 : DCHECK(IsSmiElementsKind(from_kind));
197 : return (from_kind == PACKED_SMI_ELEMENTS) ? PACKED_ELEMENTS : HOLEY_ELEMENTS;
198 : }
199 :
200 :
201 : inline bool IsSimpleMapChangeTransition(ElementsKind from_kind,
202 : ElementsKind to_kind) {
203 1772 : return (GetHoleyElementsKind(from_kind) == to_kind) ||
204 1392 : (IsSmiElementsKind(from_kind) && IsObjectElementsKind(to_kind));
205 : }
206 :
207 :
208 : bool IsMoreGeneralElementsKindTransition(ElementsKind from_kind,
209 : ElementsKind to_kind);
210 :
211 :
212 : inline ElementsKind GetMoreGeneralElementsKind(ElementsKind from_kind,
213 : ElementsKind to_kind) {
214 15102396 : if (IsMoreGeneralElementsKindTransition(from_kind, to_kind)) {
215 : return to_kind;
216 : }
217 : return from_kind;
218 : }
219 :
220 :
221 : inline bool IsTransitionableFastElementsKind(ElementsKind from_kind) {
222 8278494 : return IsFastElementsKind(from_kind) &&
223 : from_kind != TERMINAL_FAST_ELEMENTS_KIND;
224 : }
225 :
226 :
227 : } // namespace internal
228 : } // namespace v8
229 :
230 : #endif // V8_ELEMENTS_KIND_H_
|
