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.
5 #include "src/elements-kind.h"
8 #include "src/base/lazy-instance.h"
9 #include "src/elements.h"
10 #include "src/objects.h"
16 int ElementsKindToShiftSize(ElementsKind elements_kind) {
17 switch (elements_kind) {
18 case EXTERNAL_INT8_ELEMENTS:
19 case EXTERNAL_UINT8_CLAMPED_ELEMENTS:
20 case EXTERNAL_UINT8_ELEMENTS:
23 case UINT8_CLAMPED_ELEMENTS:
25 case EXTERNAL_INT16_ELEMENTS:
26 case EXTERNAL_UINT16_ELEMENTS:
30 case EXTERNAL_INT32_ELEMENTS:
31 case EXTERNAL_UINT32_ELEMENTS:
32 case EXTERNAL_FLOAT32_ELEMENTS:
35 case FLOAT32_ELEMENTS:
37 case EXTERNAL_FLOAT64_ELEMENTS:
38 case FAST_DOUBLE_ELEMENTS:
39 case FAST_HOLEY_DOUBLE_ELEMENTS:
40 case FLOAT64_ELEMENTS:
42 case EXTERNAL_FLOAT32x4_ELEMENTS:
43 case EXTERNAL_FLOAT64x2_ELEMENTS:
44 case EXTERNAL_INT32x4_ELEMENTS:
45 case FLOAT32x4_ELEMENTS:
46 case FLOAT64x2_ELEMENTS:
47 case INT32x4_ELEMENTS:
49 case FAST_SMI_ELEMENTS:
51 case FAST_HOLEY_SMI_ELEMENTS:
52 case FAST_HOLEY_ELEMENTS:
53 case DICTIONARY_ELEMENTS:
54 case SLOPPY_ARGUMENTS_ELEMENTS:
55 return kPointerSizeLog2;
62 int GetDefaultHeaderSizeForElementsKind(ElementsKind elements_kind) {
63 STATIC_ASSERT(FixedArray::kHeaderSize == FixedDoubleArray::kHeaderSize);
64 return IsExternalArrayElementsKind(elements_kind)
65 ? 0 : (FixedArray::kHeaderSize - kHeapObjectTag);
69 const char* ElementsKindToString(ElementsKind kind) {
70 ElementsAccessor* accessor = ElementsAccessor::ForKind(kind);
71 return accessor->name();
75 struct InitializeFastElementsKindSequence {
76 static void Construct(
77 ElementsKind** fast_elements_kind_sequence_ptr) {
78 ElementsKind* fast_elements_kind_sequence =
79 new ElementsKind[kFastElementsKindCount];
80 *fast_elements_kind_sequence_ptr = fast_elements_kind_sequence;
81 STATIC_ASSERT(FAST_SMI_ELEMENTS == FIRST_FAST_ELEMENTS_KIND);
82 fast_elements_kind_sequence[0] = FAST_SMI_ELEMENTS;
83 fast_elements_kind_sequence[1] = FAST_HOLEY_SMI_ELEMENTS;
84 fast_elements_kind_sequence[2] = FAST_DOUBLE_ELEMENTS;
85 fast_elements_kind_sequence[3] = FAST_HOLEY_DOUBLE_ELEMENTS;
86 fast_elements_kind_sequence[4] = FAST_ELEMENTS;
87 fast_elements_kind_sequence[5] = FAST_HOLEY_ELEMENTS;
89 // Verify that kFastElementsKindPackedToHoley is correct.
90 STATIC_ASSERT(FAST_SMI_ELEMENTS + kFastElementsKindPackedToHoley ==
91 FAST_HOLEY_SMI_ELEMENTS);
92 STATIC_ASSERT(FAST_DOUBLE_ELEMENTS + kFastElementsKindPackedToHoley ==
93 FAST_HOLEY_DOUBLE_ELEMENTS);
94 STATIC_ASSERT(FAST_ELEMENTS + kFastElementsKindPackedToHoley ==
100 static base::LazyInstance<ElementsKind*,
101 InitializeFastElementsKindSequence>::type
102 fast_elements_kind_sequence = LAZY_INSTANCE_INITIALIZER;
105 ElementsKind GetFastElementsKindFromSequenceIndex(int sequence_number) {
106 DCHECK(sequence_number >= 0 &&
107 sequence_number < kFastElementsKindCount);
108 return fast_elements_kind_sequence.Get()[sequence_number];
112 int GetSequenceIndexFromFastElementsKind(ElementsKind elements_kind) {
113 for (int i = 0; i < kFastElementsKindCount; ++i) {
114 if (fast_elements_kind_sequence.Get()[i] == elements_kind) {
123 ElementsKind GetNextTransitionElementsKind(ElementsKind kind) {
125 #define FIXED_TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) \
126 case TYPE##_ELEMENTS: return EXTERNAL_##TYPE##_ELEMENTS;
128 TYPED_ARRAYS(FIXED_TYPED_ARRAY_CASE)
129 #undef FIXED_TYPED_ARRAY_CASE
131 int index = GetSequenceIndexFromFastElementsKind(kind);
132 return GetFastElementsKindFromSequenceIndex(index + 1);
138 ElementsKind GetNextMoreGeneralFastElementsKind(ElementsKind elements_kind,
139 bool allow_only_packed) {
140 DCHECK(IsFastElementsKind(elements_kind));
141 DCHECK(elements_kind != TERMINAL_FAST_ELEMENTS_KIND);
143 elements_kind = GetNextTransitionElementsKind(elements_kind);
144 if (!IsFastHoleyElementsKind(elements_kind) || !allow_only_packed) {
145 return elements_kind;
149 return TERMINAL_FAST_ELEMENTS_KIND;
153 static bool IsTypedArrayElementsKind(ElementsKind elements_kind) {
154 return IsFixedTypedArrayElementsKind(elements_kind) ||
155 IsExternalArrayElementsKind(elements_kind);
159 static inline bool IsFastTransitionTarget(ElementsKind elements_kind) {
160 return IsFastElementsKind(elements_kind) ||
161 elements_kind == DICTIONARY_ELEMENTS;
164 bool IsMoreGeneralElementsKindTransition(ElementsKind from_kind,
165 ElementsKind to_kind) {
166 if (IsTypedArrayElementsKind(from_kind) ||
167 IsTypedArrayElementsKind(to_kind)) {
169 #define FIXED_TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) \
170 case TYPE##_ELEMENTS: \
171 return to_kind == EXTERNAL_##TYPE##_ELEMENTS;
173 TYPED_ARRAYS(FIXED_TYPED_ARRAY_CASE);
174 #undef FIXED_TYPED_ARRAY_CASE
179 if (IsFastElementsKind(from_kind) && IsFastTransitionTarget(to_kind)) {
181 case FAST_SMI_ELEMENTS:
182 return to_kind != FAST_SMI_ELEMENTS;
183 case FAST_HOLEY_SMI_ELEMENTS:
184 return to_kind != FAST_SMI_ELEMENTS &&
185 to_kind != FAST_HOLEY_SMI_ELEMENTS;
186 case FAST_DOUBLE_ELEMENTS:
187 return to_kind != FAST_SMI_ELEMENTS &&
188 to_kind != FAST_HOLEY_SMI_ELEMENTS &&
189 to_kind != FAST_DOUBLE_ELEMENTS;
190 case FAST_HOLEY_DOUBLE_ELEMENTS:
191 return to_kind == FAST_ELEMENTS ||
192 to_kind == FAST_HOLEY_ELEMENTS;
194 return to_kind == FAST_HOLEY_ELEMENTS;
195 case FAST_HOLEY_ELEMENTS:
205 } } // namespace v8::internal