src/v8/src/elements-kind.cc

   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 #include "src/elements-kind.h"
   6
   7 #include "src/api.h"
   8 #include "src/base/lazy-instance.h"
   9 #include "src/elements.h"
  10 #include "src/objects.h"
  11
  12 namespace v8 {
  13 namespace internal {
  14
  15
  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:
  21     case UINT8_ELEMENTS:
  22     case INT8_ELEMENTS:
  23     case UINT8_CLAMPED_ELEMENTS:
  24       return 0;
  25     case EXTERNAL_INT16_ELEMENTS:
  26     case EXTERNAL_UINT16_ELEMENTS:
  27     case UINT16_ELEMENTS:
  28     case INT16_ELEMENTS:
  29       return 1;
  30     case EXTERNAL_INT32_ELEMENTS:
  31     case EXTERNAL_UINT32_ELEMENTS:
  32     case EXTERNAL_FLOAT32_ELEMENTS:
  33     case UINT32_ELEMENTS:
  34     case INT32_ELEMENTS:
  35     case FLOAT32_ELEMENTS:
  36       return 2;
  37     case EXTERNAL_FLOAT64_ELEMENTS:
  38     case FAST_DOUBLE_ELEMENTS:
  39     case FAST_HOLEY_DOUBLE_ELEMENTS:
  40     case FLOAT64_ELEMENTS:
  41       return 3;
  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:
  48       return 4;
  49     case FAST_SMI_ELEMENTS:
  50     case FAST_ELEMENTS:
  51     case FAST_HOLEY_SMI_ELEMENTS:
  52     case FAST_HOLEY_ELEMENTS:
  53     case DICTIONARY_ELEMENTS:
  54     case SLOPPY_ARGUMENTS_ELEMENTS:
  55       return kPointerSizeLog2;
  56   }
  57   UNREACHABLE();
  58   return 0;
  59 }
  60
  61
  62 int GetDefaultHeaderSizeForElementsKind(ElementsKind elements_kind) {
  63   STATIC_ASSERT(FixedArray::kHeaderSize == FixedDoubleArray::kHeaderSize);
  64   return IsExternalArrayElementsKind(elements_kind)
  65       ? 0 : (FixedArray::kHeaderSize - kHeapObjectTag);
  66 }
  67
  68
  69 const char* ElementsKindToString(ElementsKind kind) {
  70   ElementsAccessor* accessor = ElementsAccessor::ForKind(kind);
  71   return accessor->name();
  72 }
  73
  74
  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;
  88
  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 ==
  95                   FAST_HOLEY_ELEMENTS);
  96   }
  97 };
  98
  99
 100 static base::LazyInstance<ElementsKind*,
 101                           InitializeFastElementsKindSequence>::type
 102     fast_elements_kind_sequence = LAZY_INSTANCE_INITIALIZER;
 103
 104
 105 ElementsKind GetFastElementsKindFromSequenceIndex(int sequence_number) {
 106   DCHECK(sequence_number >= 0 &&
 107          sequence_number < kFastElementsKindCount);
 108   return fast_elements_kind_sequence.Get()[sequence_number];
 109 }
 110
 111
 112 int GetSequenceIndexFromFastElementsKind(ElementsKind elements_kind) {
 113   for (int i = 0; i < kFastElementsKindCount; ++i) {
 114     if (fast_elements_kind_sequence.Get()[i] == elements_kind) {
 115       return i;
 116     }
 117   }
 118   UNREACHABLE();
 119   return 0;
 120 }
 121
 122
 123 ElementsKind GetNextTransitionElementsKind(ElementsKind kind) {
 124   switch (kind) {
 125 #define FIXED_TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) \
 126     case TYPE##_ELEMENTS: return EXTERNAL_##TYPE##_ELEMENTS;
 127
 128     TYPED_ARRAYS(FIXED_TYPED_ARRAY_CASE)
 129 #undef FIXED_TYPED_ARRAY_CASE
 130     default: {
 131       int index = GetSequenceIndexFromFastElementsKind(kind);
 132       return GetFastElementsKindFromSequenceIndex(index + 1);
 133     }
 134   }
 135 }
 136
 137
 138 ElementsKind GetNextMoreGeneralFastElementsKind(ElementsKind elements_kind,
 139                                                 bool allow_only_packed) {
 140   DCHECK(IsFastElementsKind(elements_kind));
 141   DCHECK(elements_kind != TERMINAL_FAST_ELEMENTS_KIND);
 142   while (true) {
 143     elements_kind = GetNextTransitionElementsKind(elements_kind);
 144     if (!IsFastHoleyElementsKind(elements_kind) || !allow_only_packed) {
 145       return elements_kind;
 146     }
 147   }
 148   UNREACHABLE();
 149   return TERMINAL_FAST_ELEMENTS_KIND;
 150 }
 151
 152
 153 static bool IsTypedArrayElementsKind(ElementsKind elements_kind) {
 154   return IsFixedTypedArrayElementsKind(elements_kind) ||
 155       IsExternalArrayElementsKind(elements_kind);
 156 }
 157
 158
 159 static inline bool IsFastTransitionTarget(ElementsKind elements_kind) {
 160   return IsFastElementsKind(elements_kind) ||
 161       elements_kind == DICTIONARY_ELEMENTS;
 162 }
 163
 164 bool IsMoreGeneralElementsKindTransition(ElementsKind from_kind,
 165                                          ElementsKind to_kind) {
 166   if (IsTypedArrayElementsKind(from_kind) ||
 167       IsTypedArrayElementsKind(to_kind)) {
 168     switch (from_kind) {
 169 #define FIXED_TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) \
 170       case TYPE##_ELEMENTS:                                   \
 171         return to_kind == EXTERNAL_##TYPE##_ELEMENTS;
 172
 173       TYPED_ARRAYS(FIXED_TYPED_ARRAY_CASE);
 174 #undef FIXED_TYPED_ARRAY_CASE
 175       default:
 176         return false;
 177     }
 178   }
 179   if (IsFastElementsKind(from_kind) && IsFastTransitionTarget(to_kind)) {
 180     switch (from_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;
 193       case FAST_ELEMENTS:
 194         return to_kind == FAST_HOLEY_ELEMENTS;
 195       case FAST_HOLEY_ELEMENTS:
 196         return false;
 197       default:
 198         return false;
 199     }
 200   }
 201   return false;
 202 }
 203
 204
 205 } }  // namespace v8::internal