src/v8/src/elements-kind.h

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