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 IsExternalArrayElementsKind(ElementsKind kind) {
  97   return kind >= FIRST_EXTERNAL_ARRAY_ELEMENTS_KIND &&
  98       kind <= LAST_EXTERNAL_ARRAY_ELEMENTS_KIND;
  99 }
 100
 101
 102 inline bool IsTerminalElementsKind(ElementsKind kind) {
 103   return kind == TERMINAL_FAST_ELEMENTS_KIND ||
 104       IsExternalArrayElementsKind(kind);
 105 }
 106
 107
 108 inline bool IsFixedTypedArrayElementsKind(ElementsKind kind) {
 109   return kind >= FIRST_FIXED_TYPED_ARRAY_ELEMENTS_KIND &&
 110       kind <= LAST_FIXED_TYPED_ARRAY_ELEMENTS_KIND;
 111 }
 112
 113
 114 inline bool IsFastElementsKind(ElementsKind kind) {
 115   DCHECK(FIRST_FAST_ELEMENTS_KIND == 0);
 116   return kind <= FAST_HOLEY_DOUBLE_ELEMENTS;
 117 }
 118
 119
 120 inline bool IsTransitionElementsKind(ElementsKind kind) {
 121   return IsFastElementsKind(kind) || IsFixedTypedArrayElementsKind(kind);
 122 }
 123
 124
 125 inline bool IsFastDoubleElementsKind(ElementsKind kind) {
 126   return kind == FAST_DOUBLE_ELEMENTS ||
 127       kind == FAST_HOLEY_DOUBLE_ELEMENTS;
 128 }
 129
 130
 131 inline bool IsExternalFloatOrDoubleElementsKind(ElementsKind kind) {
 132   return kind == EXTERNAL_FLOAT64_ELEMENTS ||
 133       kind == EXTERNAL_FLOAT32_ELEMENTS;
 134 }
 135
 136
 137 inline bool IsExternalFloat32x4ElementsKind(ElementsKind kind) {
 138   return kind == EXTERNAL_FLOAT32x4_ELEMENTS;
 139 }
 140
 141
 142 inline bool IsExternalFloat64x2ElementsKind(ElementsKind kind) {
 143   return kind == EXTERNAL_FLOAT64x2_ELEMENTS;
 144 }
 145
 146
 147 inline bool IsExternalInt32x4ElementsKind(ElementsKind kind) {
 148   return kind == EXTERNAL_INT32x4_ELEMENTS;
 149 }
 150
 151
 152 inline bool IsFixedFloatElementsKind(ElementsKind kind) {
 153   return kind == FLOAT32_ELEMENTS || kind == FLOAT64_ELEMENTS;
 154 }
 155
 156
 157 inline bool IsFixedFloat32x4ElementsKind(ElementsKind kind) {
 158   return kind == FLOAT32x4_ELEMENTS;
 159 }
 160
 161
 162 inline bool IsFixedFloat64x2ElementsKind(ElementsKind kind) {
 163   return kind == FLOAT64x2_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 IsFloat64x2ElementsKind(ElementsKind kind) {
 186   return IsExternalFloat64x2ElementsKind(kind) ||
 187       IsFixedFloat64x2ElementsKind(kind);
 188 }
 189
 190
 191 inline bool IsInt32x4ElementsKind(ElementsKind kind) {
 192   return IsExternalInt32x4ElementsKind(kind) ||
 193       IsFixedInt32x4ElementsKind(kind);
 194 }
 195
 196
 197 inline bool IsSIMD128ElementsKind(ElementsKind kind) {
 198   return IsFloat32x4ElementsKind(kind) || IsFloat64x2ElementsKind(kind) ||
 199          IsInt32x4ElementsKind(kind);
 200 }
 201
 202
 203 inline bool IsFastSmiOrObjectElementsKind(ElementsKind kind) {
 204   return kind == FAST_SMI_ELEMENTS ||
 205       kind == FAST_HOLEY_SMI_ELEMENTS ||
 206       kind == FAST_ELEMENTS ||
 207       kind == FAST_HOLEY_ELEMENTS;
 208 }
 209
 210
 211 inline bool IsFastSmiElementsKind(ElementsKind kind) {
 212   return kind == FAST_SMI_ELEMENTS ||
 213       kind == FAST_HOLEY_SMI_ELEMENTS;
 214 }
 215
 216
 217 inline bool IsFastObjectElementsKind(ElementsKind kind) {
 218   return kind == FAST_ELEMENTS ||
 219       kind == FAST_HOLEY_ELEMENTS;
 220 }
 221
 222
 223 inline bool IsFastHoleyElementsKind(ElementsKind kind) {
 224   return kind == FAST_HOLEY_SMI_ELEMENTS ||
 225       kind == FAST_HOLEY_DOUBLE_ELEMENTS ||
 226       kind == FAST_HOLEY_ELEMENTS;
 227 }
 228
 229
 230 inline bool IsHoleyElementsKind(ElementsKind kind) {
 231   return IsFastHoleyElementsKind(kind) ||
 232       kind == DICTIONARY_ELEMENTS;
 233 }
 234
 235
 236 inline bool IsFastPackedElementsKind(ElementsKind kind) {
 237   return kind == FAST_SMI_ELEMENTS ||
 238       kind == FAST_DOUBLE_ELEMENTS ||
 239       kind == FAST_ELEMENTS;
 240 }
 241
 242
 243 inline ElementsKind GetPackedElementsKind(ElementsKind holey_kind) {
 244   if (holey_kind == FAST_HOLEY_SMI_ELEMENTS) {
 245     return FAST_SMI_ELEMENTS;
 246   }
 247   if (holey_kind == FAST_HOLEY_DOUBLE_ELEMENTS) {
 248     return FAST_DOUBLE_ELEMENTS;
 249   }
 250   if (holey_kind == FAST_HOLEY_ELEMENTS) {
 251     return FAST_ELEMENTS;
 252   }
 253   return holey_kind;
 254 }
 255
 256
 257 inline ElementsKind GetHoleyElementsKind(ElementsKind packed_kind) {
 258   if (packed_kind == FAST_SMI_ELEMENTS) {
 259     return FAST_HOLEY_SMI_ELEMENTS;
 260   }
 261   if (packed_kind == FAST_DOUBLE_ELEMENTS) {
 262     return FAST_HOLEY_DOUBLE_ELEMENTS;
 263   }
 264   if (packed_kind == FAST_ELEMENTS) {
 265     return FAST_HOLEY_ELEMENTS;
 266   }
 267   return packed_kind;
 268 }
 269
 270
 271 inline ElementsKind FastSmiToObjectElementsKind(ElementsKind from_kind) {
 272   DCHECK(IsFastSmiElementsKind(from_kind));
 273   return (from_kind == FAST_SMI_ELEMENTS)
 274       ? FAST_ELEMENTS
 275       : FAST_HOLEY_ELEMENTS;
 276 }
 277
 278
 279 inline bool IsSimpleMapChangeTransition(ElementsKind from_kind,
 280                                         ElementsKind to_kind) {
 281   return (GetHoleyElementsKind(from_kind) == to_kind) ||
 282       (IsFastSmiElementsKind(from_kind) &&
 283        IsFastObjectElementsKind(to_kind));
 284 }
 285
 286
 287 bool IsMoreGeneralElementsKindTransition(ElementsKind from_kind,
 288                                          ElementsKind to_kind);
 289
 290
 291 inline bool IsTransitionableFastElementsKind(ElementsKind from_kind) {
 292   return IsFastElementsKind(from_kind) &&
 293       from_kind != TERMINAL_FAST_ELEMENTS_KIND;
 294 }
 295
 296
 297 ElementsKind GetNextMoreGeneralFastElementsKind(ElementsKind elements_kind,
 298                                                 bool allow_only_packed);
 299
 300
 301 inline bool CanTransitionToMoreGeneralFastElementsKind(
 302     ElementsKind elements_kind,
 303     bool allow_only_packed) {
 304   return IsFastElementsKind(elements_kind) &&
 305       (elements_kind != TERMINAL_FAST_ELEMENTS_KIND &&
 306        (!allow_only_packed || elements_kind != FAST_ELEMENTS));
 307 }
 308
 309
 310 } }  // namespace v8::internal
 311
 312 #endif  // V8_ELEMENTS_KIND_H_