LCOV - code coverage report
Current view: top level - src - elements-kind.h (source / functions) Hit Total Coverage
Test: app.info Lines: 39 39 100.0 %
Date: 2017-04-26 Functions: 4 4 100.0 %

          Line data    Source code
       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/base/macros.h"
       9             : #include "src/checks.h"
      10             : 
      11             : namespace v8 {
      12             : namespace internal {
      13             : 
      14             : enum ElementsKind {
      15             :   // The "fast" kind for elements that only contain SMI values. Must be first
      16             :   // to make it possible to efficiently check maps for this kind.
      17             :   FAST_SMI_ELEMENTS,
      18             :   FAST_HOLEY_SMI_ELEMENTS,
      19             : 
      20             :   // The "fast" kind for tagged values. Must be second to make it possible to
      21             :   // efficiently check maps for this and the FAST_SMI_ONLY_ELEMENTS kind
      22             :   // together at once.
      23             :   FAST_ELEMENTS,
      24             :   FAST_HOLEY_ELEMENTS,
      25             : 
      26             :   // The "fast" kind for unwrapped, non-tagged double values.
      27             :   FAST_DOUBLE_ELEMENTS,
      28             :   FAST_HOLEY_DOUBLE_ELEMENTS,
      29             : 
      30             :   // The "slow" kind.
      31             :   DICTIONARY_ELEMENTS,
      32             : 
      33             :   // Elements kind of the "arguments" object (only in sloppy mode).
      34             :   FAST_SLOPPY_ARGUMENTS_ELEMENTS,
      35             :   SLOW_SLOPPY_ARGUMENTS_ELEMENTS,
      36             : 
      37             :   // For string wrapper objects ("new String('...')"), the string's characters
      38             :   // are overlaid onto a regular elements backing store.
      39             :   FAST_STRING_WRAPPER_ELEMENTS,
      40             :   SLOW_STRING_WRAPPER_ELEMENTS,
      41             : 
      42             :   // Fixed typed arrays.
      43             :   UINT8_ELEMENTS,
      44             :   INT8_ELEMENTS,
      45             :   UINT16_ELEMENTS,
      46             :   INT16_ELEMENTS,
      47             :   UINT32_ELEMENTS,
      48             :   INT32_ELEMENTS,
      49             :   FLOAT32_ELEMENTS,
      50             :   FLOAT64_ELEMENTS,
      51             :   UINT8_CLAMPED_ELEMENTS,
      52             : 
      53             :   // Sentinel ElementsKind for objects with no elements.
      54             :   NO_ELEMENTS,
      55             : 
      56             :   // Derived constants from ElementsKind.
      57             :   FIRST_ELEMENTS_KIND = FAST_SMI_ELEMENTS,
      58             :   LAST_ELEMENTS_KIND = UINT8_CLAMPED_ELEMENTS,
      59             :   FIRST_FAST_ELEMENTS_KIND = FAST_SMI_ELEMENTS,
      60             :   LAST_FAST_ELEMENTS_KIND = FAST_HOLEY_DOUBLE_ELEMENTS,
      61             :   FIRST_FIXED_TYPED_ARRAY_ELEMENTS_KIND = UINT8_ELEMENTS,
      62             :   LAST_FIXED_TYPED_ARRAY_ELEMENTS_KIND = UINT8_CLAMPED_ELEMENTS,
      63             :   TERMINAL_FAST_ELEMENTS_KIND = FAST_HOLEY_ELEMENTS
      64             : };
      65             : 
      66             : const int kElementsKindCount = LAST_ELEMENTS_KIND - FIRST_ELEMENTS_KIND + 1;
      67             : const int kFastElementsKindCount = LAST_FAST_ELEMENTS_KIND -
      68             :     FIRST_FAST_ELEMENTS_KIND + 1;
      69             : 
      70             : // The number to add to a packed elements kind to reach a holey elements kind
      71             : const int kFastElementsKindPackedToHoley =
      72             :     FAST_HOLEY_SMI_ELEMENTS - FAST_SMI_ELEMENTS;
      73             : 
      74             : int ElementsKindToShiftSize(ElementsKind elements_kind);
      75             : int GetDefaultHeaderSizeForElementsKind(ElementsKind elements_kind);
      76             : const char* ElementsKindToString(ElementsKind kind);
      77             : 
      78             : inline ElementsKind GetInitialFastElementsKind() { return FAST_SMI_ELEMENTS; }
      79             : 
      80             : ElementsKind GetFastElementsKindFromSequenceIndex(int sequence_number);
      81             : int GetSequenceIndexFromFastElementsKind(ElementsKind elements_kind);
      82             : 
      83             : ElementsKind GetNextTransitionElementsKind(ElementsKind elements_kind);
      84             : 
      85             : inline bool IsDictionaryElementsKind(ElementsKind kind) {
      86             :   return kind == DICTIONARY_ELEMENTS;
      87             : }
      88             : 
      89             : inline bool IsSloppyArgumentsElementsKind(ElementsKind kind) {
      90     5631999 :   return kind == FAST_SLOPPY_ARGUMENTS_ELEMENTS ||
      91     1228826 :          kind == SLOW_SLOPPY_ARGUMENTS_ELEMENTS;
      92             : }
      93             : 
      94             : inline bool IsStringWrapperElementsKind(ElementsKind kind) {
      95    19777326 :   return kind == FAST_STRING_WRAPPER_ELEMENTS ||
      96      129458 :          kind == SLOW_STRING_WRAPPER_ELEMENTS;
      97             : }
      98             : 
      99        3747 : inline bool IsFixedTypedArrayElementsKind(ElementsKind kind) {
     100    41630687 :   return kind >= FIRST_FIXED_TYPED_ARRAY_ELEMENTS_KIND &&
     101     1974014 :          kind <= LAST_FIXED_TYPED_ARRAY_ELEMENTS_KIND;
     102             : }
     103             : 
     104             : 
     105             : inline bool IsTerminalElementsKind(ElementsKind kind) {
     106      277845 :   return kind == TERMINAL_FAST_ELEMENTS_KIND ||
     107             :          IsFixedTypedArrayElementsKind(kind);
     108             : }
     109             : 
     110             : 
     111        5755 : inline bool IsFastElementsKind(ElementsKind kind) {
     112             :   STATIC_ASSERT(FIRST_FAST_ELEMENTS_KIND == 0);
     113   143947266 :   return kind <= FAST_HOLEY_DOUBLE_ELEMENTS;
     114             : }
     115             : 
     116             : 
     117             : inline bool IsTransitionElementsKind(ElementsKind kind) {
     118        3323 :   return IsFastElementsKind(kind) || IsFixedTypedArrayElementsKind(kind) ||
     119      662535 :          kind == FAST_SLOPPY_ARGUMENTS_ELEMENTS ||
     120        3323 :          kind == FAST_STRING_WRAPPER_ELEMENTS;
     121             : }
     122             : 
     123             : 
     124             : inline bool IsFastDoubleElementsKind(ElementsKind kind) {
     125    42556681 :   return kind == FAST_DOUBLE_ELEMENTS ||
     126     4665806 :       kind == FAST_HOLEY_DOUBLE_ELEMENTS;
     127             : }
     128             : 
     129             : 
     130             : inline bool IsFixedFloatElementsKind(ElementsKind kind) {
     131       38646 :   return kind == FLOAT32_ELEMENTS || kind == FLOAT64_ELEMENTS;
     132             : }
     133             : 
     134             : 
     135             : inline bool IsDoubleOrFloatElementsKind(ElementsKind kind) {
     136       73521 :   return IsFastDoubleElementsKind(kind) || IsFixedFloatElementsKind(kind);
     137             : }
     138             : 
     139             : 
     140             : inline bool IsFastSmiOrObjectElementsKind(ElementsKind kind) {
     141             :   return kind == FAST_SMI_ELEMENTS ||
     142             :       kind == FAST_HOLEY_SMI_ELEMENTS ||
     143             :       kind == FAST_ELEMENTS ||
     144     2254997 :       kind == FAST_HOLEY_ELEMENTS;
     145             : }
     146             : 
     147             : 
     148             : inline bool IsFastSmiElementsKind(ElementsKind kind) {
     149             :   return kind == FAST_SMI_ELEMENTS ||
     150     1941341 :       kind == FAST_HOLEY_SMI_ELEMENTS;
     151             : }
     152             : 
     153       36387 : inline bool IsFastNumberElementsKind(ElementsKind kind) {
     154       41094 :   return IsFastSmiElementsKind(kind) || IsFastDoubleElementsKind(kind);
     155             : }
     156             : 
     157             : 
     158             : inline bool IsFastObjectElementsKind(ElementsKind kind) {
     159     6542159 :   return kind == FAST_ELEMENTS ||
     160     3213746 :       kind == FAST_HOLEY_ELEMENTS;
     161             : }
     162             : 
     163             : 
     164             : inline bool IsFastHoleyElementsKind(ElementsKind kind) {
     165    39441886 :   return kind == FAST_HOLEY_SMI_ELEMENTS ||
     166    39442178 :       kind == FAST_HOLEY_DOUBLE_ELEMENTS ||
     167             :       kind == FAST_HOLEY_ELEMENTS;
     168             : }
     169             : 
     170             : 
     171             : inline bool IsHoleyElementsKind(ElementsKind kind) {
     172     7718143 :   return IsFastHoleyElementsKind(kind) ||
     173             :       kind == DICTIONARY_ELEMENTS;
     174             : }
     175             : 
     176             : 
     177        7004 : inline bool IsFastPackedElementsKind(ElementsKind kind) {
     178     2499188 :   return kind == FAST_SMI_ELEMENTS || kind == FAST_DOUBLE_ELEMENTS ||
     179        7004 :          kind == FAST_ELEMENTS;
     180             : }
     181             : 
     182             : 
     183             : inline ElementsKind GetPackedElementsKind(ElementsKind holey_kind) {
     184      634610 :   if (holey_kind == FAST_HOLEY_SMI_ELEMENTS) {
     185             :     return FAST_SMI_ELEMENTS;
     186             :   }
     187      448551 :   if (holey_kind == FAST_HOLEY_DOUBLE_ELEMENTS) {
     188             :     return FAST_DOUBLE_ELEMENTS;
     189             :   }
     190      448388 :   if (holey_kind == FAST_HOLEY_ELEMENTS) {
     191             :     return FAST_ELEMENTS;
     192             :   }
     193             :   return holey_kind;
     194             : }
     195             : 
     196             : 
     197             : inline ElementsKind GetHoleyElementsKind(ElementsKind packed_kind) {
     198    13568539 :   if (packed_kind == FAST_SMI_ELEMENTS) {
     199             :     return FAST_HOLEY_SMI_ELEMENTS;
     200             :   }
     201    10781725 :   if (packed_kind == FAST_DOUBLE_ELEMENTS) {
     202             :     return FAST_HOLEY_DOUBLE_ELEMENTS;
     203             :   }
     204    10366851 :   if (packed_kind == FAST_ELEMENTS) {
     205             :     return FAST_HOLEY_ELEMENTS;
     206             :   }
     207             :   return packed_kind;
     208             : }
     209             : 
     210             : 
     211             : inline ElementsKind FastSmiToObjectElementsKind(ElementsKind from_kind) {
     212             :   DCHECK(IsFastSmiElementsKind(from_kind));
     213             :   return (from_kind == FAST_SMI_ELEMENTS)
     214             :       ? FAST_ELEMENTS
     215             :       : FAST_HOLEY_ELEMENTS;
     216             : }
     217             : 
     218             : 
     219             : inline bool IsSimpleMapChangeTransition(ElementsKind from_kind,
     220             :                                         ElementsKind to_kind) {
     221        4939 :   return (GetHoleyElementsKind(from_kind) == to_kind) ||
     222        3635 :       (IsFastSmiElementsKind(from_kind) &&
     223             :        IsFastObjectElementsKind(to_kind));
     224             : }
     225             : 
     226             : 
     227             : bool IsMoreGeneralElementsKindTransition(ElementsKind from_kind,
     228             :                                          ElementsKind to_kind);
     229             : 
     230             : 
     231             : inline ElementsKind GetMoreGeneralElementsKind(ElementsKind from_kind,
     232             :                                                ElementsKind to_kind) {
     233    17634796 :   if (IsMoreGeneralElementsKindTransition(from_kind, to_kind)) {
     234             :     return to_kind;
     235             :   }
     236             :   return from_kind;
     237             : }
     238             : 
     239             : 
     240             : inline bool IsTransitionableFastElementsKind(ElementsKind from_kind) {
     241      477825 :   return IsFastElementsKind(from_kind) &&
     242             :       from_kind != TERMINAL_FAST_ELEMENTS_KIND;
     243             : }
     244             : 
     245             : 
     246             : }  // namespace internal
     247             : }  // namespace v8
     248             : 
     249             : #endif  // V8_ELEMENTS_KIND_H_

Generated by: LCOV version 1.10