src/v8/src/elements-kind.h

   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 #ifndef V8_ELEMENTS_KIND_H_
  29 #define V8_ELEMENTS_KIND_H_
  30
  31 #include "v8checks.h"
  32
  33 namespace v8 {
  34 namespace internal {
  35
  36 enum ElementsKind {
  37   // The "fast" kind for elements that only contain SMI values. Must be first
  38   // to make it possible to efficiently check maps for this kind.
  39   FAST_SMI_ELEMENTS,
  40   FAST_HOLEY_SMI_ELEMENTS,
  41
  42   // The "fast" kind for tagged values. Must be second to make it possible to
  43   // efficiently check maps for this and the FAST_SMI_ONLY_ELEMENTS kind
  44   // together at once.
  45   FAST_ELEMENTS,
  46   FAST_HOLEY_ELEMENTS,
  47
  48   // The "fast" kind for unwrapped, non-tagged double values.
  49   FAST_DOUBLE_ELEMENTS,
  50   FAST_HOLEY_DOUBLE_ELEMENTS,
  51
  52   // The "slow" kind.
  53   DICTIONARY_ELEMENTS,
  54   NON_STRICT_ARGUMENTS_ELEMENTS,
  55   // The "fast" kind for external arrays
  56   EXTERNAL_INT8_ELEMENTS,
  57   EXTERNAL_UINT8_ELEMENTS,
  58   EXTERNAL_INT16_ELEMENTS,
  59   EXTERNAL_UINT16_ELEMENTS,
  60   EXTERNAL_INT32_ELEMENTS,
  61   EXTERNAL_INT32x4_ELEMENTS,
  62   EXTERNAL_UINT32_ELEMENTS,
  63   EXTERNAL_FLOAT32_ELEMENTS,
  64   EXTERNAL_FLOAT32x4_ELEMENTS,
  65   EXTERNAL_FLOAT64_ELEMENTS,
  66   EXTERNAL_UINT8_CLAMPED_ELEMENTS,
  67
  68   // Fixed typed arrays
  69   UINT8_ELEMENTS,
  70   INT8_ELEMENTS,
  71   UINT16_ELEMENTS,
  72   INT16_ELEMENTS,
  73   UINT32_ELEMENTS,
  74   INT32_ELEMENTS,
  75   INT32x4_ELEMENTS,
  76   FLOAT32_ELEMENTS,
  77   FLOAT32x4_ELEMENTS,
  78   FLOAT64_ELEMENTS,
  79   UINT8_CLAMPED_ELEMENTS,
  80
  81   // Derived constants from ElementsKind
  82   FIRST_ELEMENTS_KIND = FAST_SMI_ELEMENTS,
  83   LAST_ELEMENTS_KIND = UINT8_CLAMPED_ELEMENTS,
  84   FIRST_FAST_ELEMENTS_KIND = FAST_SMI_ELEMENTS,
  85   LAST_FAST_ELEMENTS_KIND = FAST_HOLEY_DOUBLE_ELEMENTS,
  86   FIRST_EXTERNAL_ARRAY_ELEMENTS_KIND = EXTERNAL_INT8_ELEMENTS,
  87   LAST_EXTERNAL_ARRAY_ELEMENTS_KIND = EXTERNAL_UINT8_CLAMPED_ELEMENTS,
  88   FIRST_FIXED_TYPED_ARRAY_ELEMENTS_KIND = UINT8_ELEMENTS,
  89   LAST_FIXED_TYPED_ARRAY_ELEMENTS_KIND = UINT8_CLAMPED_ELEMENTS,
  90   TERMINAL_FAST_ELEMENTS_KIND = FAST_HOLEY_ELEMENTS
  91 };
  92
  93 const int kElementsKindCount = LAST_ELEMENTS_KIND - FIRST_ELEMENTS_KIND + 1;
  94 const int kFastElementsKindCount = LAST_FAST_ELEMENTS_KIND -
  95     FIRST_FAST_ELEMENTS_KIND + 1;
  96
  97 // The number to add to a packed elements kind to reach a holey elements kind
  98 const int kFastElementsKindPackedToHoley =
  99     FAST_HOLEY_SMI_ELEMENTS - FAST_SMI_ELEMENTS;
 100
 101 int ElementsKindToShiftSize(ElementsKind elements_kind);
 102 const char* ElementsKindToString(ElementsKind kind);
 103 void PrintElementsKind(FILE* out, ElementsKind kind);
 104
 105 ElementsKind GetInitialFastElementsKind();
 106
 107 ElementsKind GetFastElementsKindFromSequenceIndex(int sequence_index);
 108
 109 int GetSequenceIndexFromFastElementsKind(ElementsKind elements_kind);
 110
 111
 112 inline bool IsDictionaryElementsKind(ElementsKind kind) {
 113   return kind == DICTIONARY_ELEMENTS;
 114 }
 115
 116
 117 inline bool IsExternalArrayElementsKind(ElementsKind kind) {
 118   return kind >= FIRST_EXTERNAL_ARRAY_ELEMENTS_KIND &&
 119       kind <= LAST_EXTERNAL_ARRAY_ELEMENTS_KIND;
 120 }
 121
 122
 123 inline bool IsFixedTypedArrayElementsKind(ElementsKind kind) {
 124   return kind >= FIRST_FIXED_TYPED_ARRAY_ELEMENTS_KIND &&
 125       kind <= LAST_FIXED_TYPED_ARRAY_ELEMENTS_KIND;
 126 }
 127
 128
 129 inline bool IsFastElementsKind(ElementsKind kind) {
 130   ASSERT(FIRST_FAST_ELEMENTS_KIND == 0);
 131   return kind <= FAST_HOLEY_DOUBLE_ELEMENTS;
 132 }
 133
 134
 135 inline bool IsFastDoubleElementsKind(ElementsKind kind) {
 136   return kind == FAST_DOUBLE_ELEMENTS ||
 137       kind == FAST_HOLEY_DOUBLE_ELEMENTS;
 138 }
 139
 140
 141 inline bool IsExternalFloatOrDoubleElementsKind(ElementsKind kind) {
 142   return kind == EXTERNAL_FLOAT64_ELEMENTS ||
 143       kind == EXTERNAL_FLOAT32_ELEMENTS;
 144 }
 145
 146
 147 inline bool IsExternalFloat32x4ElementsKind(ElementsKind kind) {
 148   return kind == EXTERNAL_FLOAT32x4_ELEMENTS;
 149 }
 150
 151
 152 inline bool IsExternalInt32x4ElementsKind(ElementsKind kind) {
 153   return kind == EXTERNAL_INT32x4_ELEMENTS;
 154 }
 155
 156
 157 inline bool IsFixedFloatElementsKind(ElementsKind kind) {
 158   return kind == FLOAT32_ELEMENTS || kind == FLOAT64_ELEMENTS;
 159 }
 160
 161
 162 inline bool IsFixedFloat32x4ElementsKind(ElementsKind kind) {
 163   return kind == FLOAT32x4_ELEMENTS;
 164 }
 165
 166
 167 inline bool IsFixedInt32x4ElementsKind(ElementsKind kind) {
 168   return kind == INT32x4_ELEMENTS;
 169 }
 170
 171
 172 inline bool IsDoubleOrFloatElementsKind(ElementsKind kind) {
 173   return IsFastDoubleElementsKind(kind) ||
 174       IsExternalFloatOrDoubleElementsKind(kind) ||
 175       IsFixedFloatElementsKind(kind);
 176 }
 177
 178
 179 inline bool IsFloat32x4ElementsKind(ElementsKind kind) {
 180   return IsExternalFloat32x4ElementsKind(kind) ||
 181       IsFixedFloat32x4ElementsKind(kind);
 182 }
 183
 184
 185 inline bool IsInt32x4ElementsKind(ElementsKind kind) {
 186   return IsExternalInt32x4ElementsKind(kind) ||
 187       IsFixedInt32x4ElementsKind(kind);
 188 }
 189
 190
 191 inline bool IsSIMD128ElementsKind(ElementsKind kind) {
 192   return IsFloat32x4ElementsKind(kind) || IsInt32x4ElementsKind(kind);
 193 }
 194
 195
 196 inline bool IsFastSmiOrObjectElementsKind(ElementsKind kind) {
 197   return kind == FAST_SMI_ELEMENTS ||
 198       kind == FAST_HOLEY_SMI_ELEMENTS ||
 199       kind == FAST_ELEMENTS ||
 200       kind == FAST_HOLEY_ELEMENTS;
 201 }
 202
 203
 204 inline bool IsFastSmiElementsKind(ElementsKind kind) {
 205   return kind == FAST_SMI_ELEMENTS ||
 206       kind == FAST_HOLEY_SMI_ELEMENTS;
 207 }
 208
 209
 210 inline bool IsFastObjectElementsKind(ElementsKind kind) {
 211   return kind == FAST_ELEMENTS ||
 212       kind == FAST_HOLEY_ELEMENTS;
 213 }
 214
 215
 216 inline bool IsFastHoleyElementsKind(ElementsKind kind) {
 217   return kind == FAST_HOLEY_SMI_ELEMENTS ||
 218       kind == FAST_HOLEY_DOUBLE_ELEMENTS ||
 219       kind == FAST_HOLEY_ELEMENTS;
 220 }
 221
 222
 223 inline bool IsHoleyElementsKind(ElementsKind kind) {
 224   return IsFastHoleyElementsKind(kind) ||
 225       kind == DICTIONARY_ELEMENTS;
 226 }
 227
 228
 229 inline bool IsFastPackedElementsKind(ElementsKind kind) {
 230   return kind == FAST_SMI_ELEMENTS ||
 231       kind == FAST_DOUBLE_ELEMENTS ||
 232       kind == FAST_ELEMENTS;
 233 }
 234
 235
 236 inline ElementsKind GetPackedElementsKind(ElementsKind holey_kind) {
 237   if (holey_kind == FAST_HOLEY_SMI_ELEMENTS) {
 238     return FAST_SMI_ELEMENTS;
 239   }
 240   if (holey_kind == FAST_HOLEY_DOUBLE_ELEMENTS) {
 241     return FAST_DOUBLE_ELEMENTS;
 242   }
 243   if (holey_kind == FAST_HOLEY_ELEMENTS) {
 244     return FAST_ELEMENTS;
 245   }
 246   return holey_kind;
 247 }
 248
 249
 250 inline ElementsKind GetHoleyElementsKind(ElementsKind packed_kind) {
 251   if (packed_kind == FAST_SMI_ELEMENTS) {
 252     return FAST_HOLEY_SMI_ELEMENTS;
 253   }
 254   if (packed_kind == FAST_DOUBLE_ELEMENTS) {
 255     return FAST_HOLEY_DOUBLE_ELEMENTS;
 256   }
 257   if (packed_kind == FAST_ELEMENTS) {
 258     return FAST_HOLEY_ELEMENTS;
 259   }
 260   return packed_kind;
 261 }
 262
 263
 264 inline ElementsKind FastSmiToObjectElementsKind(ElementsKind from_kind) {
 265   ASSERT(IsFastSmiElementsKind(from_kind));
 266   return (from_kind == FAST_SMI_ELEMENTS)
 267       ? FAST_ELEMENTS
 268       : FAST_HOLEY_ELEMENTS;
 269 }
 270
 271
 272 inline bool IsSimpleMapChangeTransition(ElementsKind from_kind,
 273                                         ElementsKind to_kind) {
 274   return (GetHoleyElementsKind(from_kind) == to_kind) ||
 275       (IsFastSmiElementsKind(from_kind) &&
 276        IsFastObjectElementsKind(to_kind));
 277 }
 278
 279
 280 bool IsMoreGeneralElementsKindTransition(ElementsKind from_kind,
 281                                          ElementsKind to_kind);
 282
 283
 284 inline bool IsTransitionableFastElementsKind(ElementsKind from_kind) {
 285   return IsFastElementsKind(from_kind) &&
 286       from_kind != TERMINAL_FAST_ELEMENTS_KIND;
 287 }
 288
 289
 290 ElementsKind GetNextMoreGeneralFastElementsKind(ElementsKind elements_kind,
 291                                                 bool allow_only_packed);
 292
 293
 294 inline bool CanTransitionToMoreGeneralFastElementsKind(
 295     ElementsKind elements_kind,
 296     bool allow_only_packed) {
 297   return IsFastElementsKind(elements_kind) &&
 298       (elements_kind != TERMINAL_FAST_ELEMENTS_KIND &&
 299        (!allow_only_packed || elements_kind != FAST_ELEMENTS));
 300 }
 301
 302
 303 } }  // namespace v8::internal
 304
 305 #endif  // V8_ELEMENTS_KIND_H_