src/v8/src/elements-kind.cc

   1 // Copyright 2012 the V8 project authors. All rights reserved.
   2 // Redistribution and use in source and binary forms, with or without
   3 // modification, are permitted provided that the following conditions are
   4 // met:
   5 //
   6 //     * Redistributions of source code must retain the above copyright
   7 //       notice, this list of conditions and the following disclaimer.
   8 //     * Redistributions in binary form must reproduce the above
   9 //       copyright notice, this list of conditions and the following
  10 //       disclaimer in the documentation and/or other materials provided
  11 //       with the distribution.
  12 //     * Neither the name of Google Inc. nor the names of its
  13 //       contributors may be used to endorse or promote products derived
  14 //       from this software without specific prior written permission.
  15 //
  16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27
  28 #include "elements-kind.h"
  29
  30 #include "api.h"
  31 #include "elements.h"
  32 #include "objects.h"
  33
  34 namespace v8 {
  35 namespace internal {
  36
  37
  38 int ElementsKindToShiftSize(ElementsKind elements_kind) {
  39   switch (elements_kind) {
  40     case EXTERNAL_INT8_ELEMENTS:
  41     case EXTERNAL_UINT8_CLAMPED_ELEMENTS:
  42     case EXTERNAL_UINT8_ELEMENTS:
  43     case UINT8_ELEMENTS:
  44     case INT8_ELEMENTS:
  45     case UINT8_CLAMPED_ELEMENTS:
  46       return 0;
  47     case EXTERNAL_INT16_ELEMENTS:
  48     case EXTERNAL_UINT16_ELEMENTS:
  49     case UINT16_ELEMENTS:
  50     case INT16_ELEMENTS:
  51       return 1;
  52     case EXTERNAL_INT32_ELEMENTS:
  53     case EXTERNAL_UINT32_ELEMENTS:
  54     case EXTERNAL_FLOAT32_ELEMENTS:
  55     case UINT32_ELEMENTS:
  56     case INT32_ELEMENTS:
  57     case FLOAT32_ELEMENTS:
  58       return 2;
  59     case EXTERNAL_FLOAT64_ELEMENTS:
  60     case FAST_DOUBLE_ELEMENTS:
  61     case FAST_HOLEY_DOUBLE_ELEMENTS:
  62     case FLOAT64_ELEMENTS:
  63       return 3;
  64     case EXTERNAL_FLOAT32x4_ELEMENTS:
  65     case EXTERNAL_INT32x4_ELEMENTS:
  66     case FLOAT32x4_ELEMENTS:
  67     case INT32x4_ELEMENTS:
  68       return 4;
  69     case FAST_SMI_ELEMENTS:
  70     case FAST_ELEMENTS:
  71     case FAST_HOLEY_SMI_ELEMENTS:
  72     case FAST_HOLEY_ELEMENTS:
  73     case DICTIONARY_ELEMENTS:
  74     case NON_STRICT_ARGUMENTS_ELEMENTS:
  75       return kPointerSizeLog2;
  76   }
  77   UNREACHABLE();
  78   return 0;
  79 }
  80
  81
  82 const char* ElementsKindToString(ElementsKind kind) {
  83   ElementsAccessor* accessor = ElementsAccessor::ForKind(kind);
  84   return accessor->name();
  85 }
  86
  87
  88 void PrintElementsKind(FILE* out, ElementsKind kind) {
  89   PrintF(out, "%s", ElementsKindToString(kind));
  90 }
  91
  92
  93 ElementsKind GetInitialFastElementsKind() {
  94   if (FLAG_packed_arrays) {
  95     return FAST_SMI_ELEMENTS;
  96   } else {
  97     return FAST_HOLEY_SMI_ELEMENTS;
  98   }
  99 }
 100
 101
 102 struct InitializeFastElementsKindSequence {
 103   static void Construct(
 104       ElementsKind** fast_elements_kind_sequence_ptr) {
 105     ElementsKind* fast_elements_kind_sequence =
 106         new ElementsKind[kFastElementsKindCount];
 107     *fast_elements_kind_sequence_ptr = fast_elements_kind_sequence;
 108     STATIC_ASSERT(FAST_SMI_ELEMENTS == FIRST_FAST_ELEMENTS_KIND);
 109     fast_elements_kind_sequence[0] = FAST_SMI_ELEMENTS;
 110     fast_elements_kind_sequence[1] = FAST_HOLEY_SMI_ELEMENTS;
 111     fast_elements_kind_sequence[2] = FAST_DOUBLE_ELEMENTS;
 112     fast_elements_kind_sequence[3] = FAST_HOLEY_DOUBLE_ELEMENTS;
 113     fast_elements_kind_sequence[4] = FAST_ELEMENTS;
 114     fast_elements_kind_sequence[5] = FAST_HOLEY_ELEMENTS;
 115
 116     // Verify that kFastElementsKindPackedToHoley is correct.
 117     STATIC_ASSERT(FAST_SMI_ELEMENTS + kFastElementsKindPackedToHoley ==
 118                   FAST_HOLEY_SMI_ELEMENTS);
 119     STATIC_ASSERT(FAST_DOUBLE_ELEMENTS + kFastElementsKindPackedToHoley ==
 120                   FAST_HOLEY_DOUBLE_ELEMENTS);
 121     STATIC_ASSERT(FAST_ELEMENTS + kFastElementsKindPackedToHoley ==
 122                   FAST_HOLEY_ELEMENTS);
 123   }
 124 };
 125
 126
 127 static LazyInstance<ElementsKind*,
 128                     InitializeFastElementsKindSequence>::type
 129     fast_elements_kind_sequence = LAZY_INSTANCE_INITIALIZER;
 130
 131
 132 ElementsKind GetFastElementsKindFromSequenceIndex(int sequence_number) {
 133   ASSERT(sequence_number >= 0 &&
 134          sequence_number < kFastElementsKindCount);
 135   return fast_elements_kind_sequence.Get()[sequence_number];
 136 }
 137
 138
 139 int GetSequenceIndexFromFastElementsKind(ElementsKind elements_kind) {
 140   for (int i = 0; i < kFastElementsKindCount; ++i) {
 141     if (fast_elements_kind_sequence.Get()[i] == elements_kind) {
 142       return i;
 143     }
 144   }
 145   UNREACHABLE();
 146   return 0;
 147 }
 148
 149
 150 ElementsKind GetNextMoreGeneralFastElementsKind(ElementsKind elements_kind,
 151                                                 bool allow_only_packed) {
 152   ASSERT(IsFastElementsKind(elements_kind));
 153   ASSERT(elements_kind != TERMINAL_FAST_ELEMENTS_KIND);
 154   while (true) {
 155     int index =
 156         GetSequenceIndexFromFastElementsKind(elements_kind) + 1;
 157     elements_kind = GetFastElementsKindFromSequenceIndex(index);
 158     if (!IsFastHoleyElementsKind(elements_kind) || !allow_only_packed) {
 159       return elements_kind;
 160     }
 161   }
 162   UNREACHABLE();
 163   return TERMINAL_FAST_ELEMENTS_KIND;
 164 }
 165
 166
 167 bool IsMoreGeneralElementsKindTransition(ElementsKind from_kind,
 168                                          ElementsKind to_kind) {
 169   switch (from_kind) {
 170     case FAST_SMI_ELEMENTS:
 171       return to_kind != FAST_SMI_ELEMENTS;
 172     case FAST_HOLEY_SMI_ELEMENTS:
 173       return to_kind != FAST_SMI_ELEMENTS &&
 174           to_kind != FAST_HOLEY_SMI_ELEMENTS;
 175     case FAST_DOUBLE_ELEMENTS:
 176       return to_kind != FAST_SMI_ELEMENTS &&
 177           to_kind != FAST_HOLEY_SMI_ELEMENTS &&
 178           to_kind != FAST_DOUBLE_ELEMENTS;
 179     case FAST_HOLEY_DOUBLE_ELEMENTS:
 180       return to_kind == FAST_ELEMENTS ||
 181           to_kind == FAST_HOLEY_ELEMENTS;
 182     case FAST_ELEMENTS:
 183       return to_kind == FAST_HOLEY_ELEMENTS;
 184     case FAST_HOLEY_ELEMENTS:
 185       return false;
 186     default:
 187       return false;
 188   }
 189 }
 190
 191
 192 } }  // namespace v8::internal