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 // V has parameters (Type, type, TYPE, C type) 15 #define TYPED_ARRAYS(V) \ 16 V(Uint8, uint8, UINT8, uint8_t) \ 17 V(Int8, int8, INT8, int8_t) \ 18 V(Uint16, uint16, UINT16, uint16_t) \ 19 V(Int16, int16, INT16, int16_t) \ 20 V(Uint32, uint32, UINT32, uint32_t) \ 21 V(Int32, int32, INT32, int32_t) \ 22 V(Float32, float32, FLOAT32, float) \ 23 V(Float64, float64, FLOAT64, double) \ 24 V(Uint8Clamped, uint8_clamped, UINT8_CLAMPED, uint8_t) \ 25 V(BigUint64, biguint64, BIGUINT64, uint64_t) \ 26 V(BigInt64, bigint64, BIGINT64, int64_t) 27 28 enum ElementsKind { 29 // The "fast" kind for elements that only contain SMI values. Must be first 30 // to make it possible to efficiently check maps for this kind. 31 PACKED_SMI_ELEMENTS, 32 HOLEY_SMI_ELEMENTS, 33 34 // The "fast" kind for tagged values. Must be second to make it possible to 35 // efficiently check maps for this and the PACKED_SMI_ELEMENTS kind 36 // together at once. 37 PACKED_ELEMENTS, 38 HOLEY_ELEMENTS, 39 40 // The "fast" kind for unwrapped, non-tagged double values. 41 PACKED_DOUBLE_ELEMENTS, 42 HOLEY_DOUBLE_ELEMENTS, 43 44 // The "slow" kind. 45 DICTIONARY_ELEMENTS, 46 47 // Elements kind of the "arguments" object (only in sloppy mode). 48 FAST_SLOPPY_ARGUMENTS_ELEMENTS, 49 SLOW_SLOPPY_ARGUMENTS_ELEMENTS, 50 51 // For string wrapper objects ("new String('...')"), the string's characters 52 // are overlaid onto a regular elements backing store. 53 FAST_STRING_WRAPPER_ELEMENTS, 54 SLOW_STRING_WRAPPER_ELEMENTS, 55 56 // Fixed typed arrays. 57 #define TYPED_ARRAY_ELEMENTS_KIND(Type, type, TYPE, ctype) TYPE##_ELEMENTS, 58 TYPED_ARRAYS(TYPED_ARRAY_ELEMENTS_KIND) 59 #undef TYPED_ARRAY_ELEMENTS_KIND 60 61 // Sentinel ElementsKind for objects with no elements. 62 NO_ELEMENTS, 63 64 // Derived constants from ElementsKind. 65 FIRST_ELEMENTS_KIND = PACKED_SMI_ELEMENTS, 66 LAST_ELEMENTS_KIND = BIGINT64_ELEMENTS, 67 FIRST_FAST_ELEMENTS_KIND = PACKED_SMI_ELEMENTS, 68 LAST_FAST_ELEMENTS_KIND = HOLEY_DOUBLE_ELEMENTS, 69 FIRST_FIXED_TYPED_ARRAY_ELEMENTS_KIND = UINT8_ELEMENTS, 70 LAST_FIXED_TYPED_ARRAY_ELEMENTS_KIND = BIGINT64_ELEMENTS, 71 TERMINAL_FAST_ELEMENTS_KIND = HOLEY_ELEMENTS 72 }; 73 74 const int kElementsKindCount = LAST_ELEMENTS_KIND - FIRST_ELEMENTS_KIND + 1; 75 const int kFastElementsKindCount = 76 LAST_FAST_ELEMENTS_KIND - FIRST_FAST_ELEMENTS_KIND + 1; 77 78 // The number to add to a packed elements kind to reach a holey elements kind 79 const int kFastElementsKindPackedToHoley = 80 HOLEY_SMI_ELEMENTS - PACKED_SMI_ELEMENTS; 81 82 int ElementsKindToShiftSize(ElementsKind elements_kind); 83 int ElementsKindToByteSize(ElementsKind elements_kind); 84 int GetDefaultHeaderSizeForElementsKind(ElementsKind elements_kind); 85 const char* ElementsKindToString(ElementsKind kind); 86 87 inline ElementsKind GetInitialFastElementsKind() { return PACKED_SMI_ELEMENTS; } 88 89 ElementsKind GetFastElementsKindFromSequenceIndex(int sequence_number); 90 int GetSequenceIndexFromFastElementsKind(ElementsKind elements_kind); 91 92 ElementsKind GetNextTransitionElementsKind(ElementsKind elements_kind); 93 94 inline bool IsDictionaryElementsKind(ElementsKind kind) { 95 return kind == DICTIONARY_ELEMENTS; 96 } 97 98 inline bool IsSloppyArgumentsElementsKind(ElementsKind kind) { 99 return kind == FAST_SLOPPY_ARGUMENTS_ELEMENTS || 100 kind == SLOW_SLOPPY_ARGUMENTS_ELEMENTS; 101 } 102 103 inline bool IsStringWrapperElementsKind(ElementsKind kind) { 104 return kind == FAST_STRING_WRAPPER_ELEMENTS || 105 kind == SLOW_STRING_WRAPPER_ELEMENTS; 106 } 107 108 inline bool IsFixedTypedArrayElementsKind(ElementsKind kind) { 109 return kind >= FIRST_FIXED_TYPED_ARRAY_ELEMENTS_KIND && 110 kind <= LAST_FIXED_TYPED_ARRAY_ELEMENTS_KIND; 111 } 112 113 inline bool IsTerminalElementsKind(ElementsKind kind) { 114 return kind == TERMINAL_FAST_ELEMENTS_KIND || 115 IsFixedTypedArrayElementsKind(kind); 116 } 117 118 inline bool IsFastElementsKind(ElementsKind kind) { 119 STATIC_ASSERT(FIRST_FAST_ELEMENTS_KIND == 0); 120 return kind <= HOLEY_DOUBLE_ELEMENTS; 121 } 122 123 inline bool IsTransitionElementsKind(ElementsKind kind) { 124 return IsFastElementsKind(kind) || IsFixedTypedArrayElementsKind(kind) || 125 kind == FAST_SLOPPY_ARGUMENTS_ELEMENTS || 126 kind == FAST_STRING_WRAPPER_ELEMENTS; 127 } 128 129 inline bool IsDoubleElementsKind(ElementsKind kind) { 130 return kind == PACKED_DOUBLE_ELEMENTS || kind == HOLEY_DOUBLE_ELEMENTS; 131 } 132 133 134 inline bool IsFixedFloatElementsKind(ElementsKind kind) { 135 return kind == FLOAT32_ELEMENTS || kind == FLOAT64_ELEMENTS; 136 } 137 138 139 inline bool IsDoubleOrFloatElementsKind(ElementsKind kind) { 140 return IsDoubleElementsKind(kind) || IsFixedFloatElementsKind(kind); 141 } 142 143 inline bool IsSmiOrObjectElementsKind(ElementsKind kind) { 144 return kind == PACKED_SMI_ELEMENTS || kind == HOLEY_SMI_ELEMENTS || 145 kind == PACKED_ELEMENTS || kind == HOLEY_ELEMENTS; 146 } 147 148 inline bool IsSmiElementsKind(ElementsKind kind) { 149 return kind == PACKED_SMI_ELEMENTS || kind == HOLEY_SMI_ELEMENTS; 150 } 151 152 inline bool IsFastNumberElementsKind(ElementsKind kind) { 153 return IsSmiElementsKind(kind) || IsDoubleElementsKind(kind); 154 } 155 156 inline bool IsObjectElementsKind(ElementsKind kind) { 157 return kind == PACKED_ELEMENTS || kind == HOLEY_ELEMENTS; 158 } 159 160 inline bool IsHoleyElementsKind(ElementsKind kind) { 161 return kind == HOLEY_SMI_ELEMENTS || kind == HOLEY_DOUBLE_ELEMENTS || 162 kind == HOLEY_ELEMENTS; 163 } 164 165 inline bool IsHoleyOrDictionaryElementsKind(ElementsKind kind) { 166 return IsHoleyElementsKind(kind) || kind == DICTIONARY_ELEMENTS; 167 } 168 169 170 inline bool IsFastPackedElementsKind(ElementsKind kind) { 171 return kind == PACKED_SMI_ELEMENTS || kind == PACKED_DOUBLE_ELEMENTS || 172 kind == PACKED_ELEMENTS; 173 } 174 175 176 inline ElementsKind GetPackedElementsKind(ElementsKind holey_kind) { 177 if (holey_kind == HOLEY_SMI_ELEMENTS) { 178 return PACKED_SMI_ELEMENTS; 179 } 180 if (holey_kind == HOLEY_DOUBLE_ELEMENTS) { 181 return PACKED_DOUBLE_ELEMENTS; 182 } 183 if (holey_kind == HOLEY_ELEMENTS) { 184 return PACKED_ELEMENTS; 185 } 186 return holey_kind; 187 } 188 189 190 inline ElementsKind GetHoleyElementsKind(ElementsKind packed_kind) { 191 if (packed_kind == PACKED_SMI_ELEMENTS) { 192 return HOLEY_SMI_ELEMENTS; 193 } 194 if (packed_kind == PACKED_DOUBLE_ELEMENTS) { 195 return HOLEY_DOUBLE_ELEMENTS; 196 } 197 if (packed_kind == PACKED_ELEMENTS) { 198 return HOLEY_ELEMENTS; 199 } 200 return packed_kind; 201 } 202 203 inline bool UnionElementsKindUptoPackedness(ElementsKind* a_out, 204 ElementsKind b) { 205 // Assert that the union of two ElementKinds can be computed via std::max. 206 static_assert(PACKED_SMI_ELEMENTS < HOLEY_SMI_ELEMENTS, 207 "ElementsKind union not computable via std::max."); 208 static_assert(PACKED_ELEMENTS < HOLEY_ELEMENTS, 209 "ElementsKind union not computable via std::max."); 210 static_assert(PACKED_DOUBLE_ELEMENTS < HOLEY_DOUBLE_ELEMENTS, 211 "ElementsKind union not computable via std::max."); 212 ElementsKind a = *a_out; 213 switch (a) { 214 case HOLEY_SMI_ELEMENTS: 215 case PACKED_SMI_ELEMENTS: 216 if (b == PACKED_SMI_ELEMENTS || b == HOLEY_SMI_ELEMENTS) { 217 *a_out = std::max(a, b); 218 return true; 219 } 220 break; 221 case PACKED_ELEMENTS: 222 case HOLEY_ELEMENTS: 223 if (b == PACKED_ELEMENTS || b == HOLEY_ELEMENTS) { 224 *a_out = std::max(a, b); 225 return true; 226 } 227 break; 228 case PACKED_DOUBLE_ELEMENTS: 229 case HOLEY_DOUBLE_ELEMENTS: 230 if (b == PACKED_DOUBLE_ELEMENTS || b == HOLEY_DOUBLE_ELEMENTS) { 231 *a_out = std::max(a, b); 232 return true; 233 } 234 break; 235 default: 236 break; 237 } 238 return false; 239 } 240 241 bool UnionElementsKindUptoSize(ElementsKind* a_out, ElementsKind b); 242 243 inline ElementsKind FastSmiToObjectElementsKind(ElementsKind from_kind) { 244 DCHECK(IsSmiElementsKind(from_kind)); 245 return (from_kind == PACKED_SMI_ELEMENTS) ? PACKED_ELEMENTS : HOLEY_ELEMENTS; 246 } 247 248 249 inline bool IsSimpleMapChangeTransition(ElementsKind from_kind, 250 ElementsKind to_kind) { 251 return (GetHoleyElementsKind(from_kind) == to_kind) || 252 (IsSmiElementsKind(from_kind) && IsObjectElementsKind(to_kind)); 253 } 254 255 256 bool IsMoreGeneralElementsKindTransition(ElementsKind from_kind, 257 ElementsKind to_kind); 258 259 260 inline ElementsKind GetMoreGeneralElementsKind(ElementsKind from_kind, 261 ElementsKind to_kind) { 262 if (IsMoreGeneralElementsKindTransition(from_kind, to_kind)) { 263 return to_kind; 264 } 265 return from_kind; 266 } 267 268 269 inline bool IsTransitionableFastElementsKind(ElementsKind from_kind) { 270 return IsFastElementsKind(from_kind) && 271 from_kind != TERMINAL_FAST_ELEMENTS_KIND; 272 } 273 274 inline bool ElementsKindEqual(ElementsKind a, ElementsKind b) { return a == b; } 275 276 } // namespace internal 277 } // namespace v8 278 279 #endif // V8_ELEMENTS_KIND_H_ 280