LCOV - code coverage report
Current view: top level - src/ic - ic-state.h (source / functions) Hit Total Coverage
Test: app.info Lines: 11 11 100.0 %
Date: 2017-04-26 Functions: 0 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_IC_STATE_H_
       6             : #define V8_IC_STATE_H_
       7             : 
       8             : #include "src/macro-assembler.h"
       9             : #include "src/parsing/token.h"
      10             : 
      11             : namespace v8 {
      12             : namespace internal {
      13             : 
      14             : class AstType;
      15             : 
      16             : const int kMaxKeyedPolymorphism = 4;
      17             : 
      18             : 
      19             : class ICUtility : public AllStatic {
      20             :  public:
      21             :   // Clear the inline cache to initial state.
      22             :   static void Clear(Isolate* isolate, Address address, Address constant_pool);
      23             : };
      24             : 
      25             : 
      26             : class BinaryOpICState final BASE_EMBEDDED {
      27             :  public:
      28             :   BinaryOpICState(Isolate* isolate, ExtraICState extra_ic_state);
      29             :   BinaryOpICState(Isolate* isolate, Token::Value op)
      30             :       : op_(op),
      31             :         left_kind_(NONE),
      32             :         right_kind_(NONE),
      33             :         result_kind_(NONE),
      34             :         fixed_right_arg_(Nothing<int>()),
      35      843205 :         isolate_(isolate) {
      36             :     DCHECK_LE(FIRST_TOKEN, op);
      37             :     DCHECK_LE(op, LAST_TOKEN);
      38             :   }
      39             : 
      40             :   InlineCacheState GetICState() const {
      41     1305418 :     if (Max(left_kind_, right_kind_) == NONE) {
      42             :       return ::v8::internal::UNINITIALIZED;
      43             :     }
      44      466360 :     if (Max(left_kind_, right_kind_) == GENERIC) {
      45             :       return ::v8::internal::MEGAMORPHIC;
      46             :     }
      47      456835 :     if (Min(left_kind_, right_kind_) == GENERIC) {
      48             :       return ::v8::internal::GENERIC;
      49             :     }
      50             :     return ::v8::internal::MONOMORPHIC;
      51             :   }
      52             : 
      53             :   ExtraICState GetExtraICState() const;
      54             :   std::string ToString() const;
      55             : 
      56             :   static void GenerateAheadOfTime(Isolate*,
      57             :                                   void (*Generate)(Isolate*,
      58             :                                                    const BinaryOpICState&));
      59             : 
      60             :   // Returns true if the IC _could_ create allocation mementos.
      61             :   bool CouldCreateAllocationMementos() const {
      62      498491 :     if (left_kind_ == STRING || right_kind_ == STRING) {
      63             :       DCHECK_EQ(Token::ADD, op_);
      64             :       return true;
      65             :     }
      66             :     return false;
      67             :   }
      68             : 
      69             :   // Returns true if the IC _should_ create allocation mementos.
      70      433347 :   bool ShouldCreateAllocationMementos() const {
      71      866694 :     return FLAG_allocation_site_pretenuring && CouldCreateAllocationMementos();
      72             :   }
      73             : 
      74             :   bool HasSideEffects() const {
      75             :     return Max(left_kind_, right_kind_) == GENERIC;
      76             :   }
      77             : 
      78             :   // Returns true if the IC should enable the inline smi code (i.e. if either
      79             :   // parameter may be a smi).
      80             :   bool UseInlinedSmiCode() const {
      81     1418676 :     return KindMaybeSmi(left_kind_) || KindMaybeSmi(right_kind_);
      82             :   }
      83             : 
      84             :   static const int FIRST_TOKEN = Token::BIT_OR;
      85             :   static const int LAST_TOKEN = Token::MOD;
      86             : 
      87             :   Token::Value op() const { return op_; }
      88             :   Maybe<int> fixed_right_arg() const { return fixed_right_arg_; }
      89             : 
      90      820516 :   AstType* GetLeftType() const { return KindToType(left_kind_); }
      91      774535 :   AstType* GetRightType() const { return KindToType(right_kind_); }
      92             :   AstType* GetResultType() const;
      93             : 
      94             :   void Update(Handle<Object> left, Handle<Object> right, Handle<Object> result);
      95             : 
      96             :   Isolate* isolate() const { return isolate_; }
      97             : 
      98             :   enum Kind { NONE, SMI, INT32, NUMBER, STRING, GENERIC };
      99             :   Kind kind() const {
     100             :     return KindGeneralize(KindGeneralize(left_kind_, right_kind_),
     101             :                           result_kind_);
     102             :   }
     103             : 
     104             :  private:
     105             :   friend std::ostream& operator<<(std::ostream& os, const BinaryOpICState& s);
     106             : 
     107             :   Kind UpdateKind(Handle<Object> object, Kind kind) const;
     108             : 
     109             :   static const char* KindToString(Kind kind);
     110             :   static AstType* KindToType(Kind kind);
     111             :   static bool KindMaybeSmi(Kind kind) {
     112     1365687 :     return (kind >= SMI && kind <= NUMBER) || kind == GENERIC;
     113             :   }
     114             :   static bool KindLessGeneralThan(Kind kind1, Kind kind2) {
     115             :     if (kind1 == NONE) return true;
     116             :     if (kind1 == kind2) return true;
     117             :     if (kind2 == GENERIC) return true;
     118             :     if (kind2 == STRING) return false;
     119             :     return kind1 <= kind2;
     120             :   }
     121             :   static Kind KindGeneralize(Kind kind1, Kind kind2) {
     122             :     if (KindLessGeneralThan(kind1, kind2)) return kind2;
     123             :     if (KindLessGeneralThan(kind2, kind1)) return kind1;
     124             :     return GENERIC;
     125             :   }
     126             : 
     127             :   // We truncate the last bit of the token.
     128             :   STATIC_ASSERT(LAST_TOKEN - FIRST_TOKEN < (1 << 4));
     129             :   class OpField : public BitField<int, 0, 4> {};
     130             :   class ResultKindField : public BitField<Kind, 4, 3> {};
     131             :   class LeftKindField : public BitField<Kind, 7, 3> {};
     132             :   // When fixed right arg is set, we don't need to store the right kind.
     133             :   // Thus the two fields can overlap.
     134             :   class HasFixedRightArgField : public BitField<bool, 10, 1> {};
     135             :   class FixedRightArgValueField : public BitField<int, 11, 4> {};
     136             :   class RightKindField : public BitField<Kind, 11, 3> {};
     137             : 
     138             :   Token::Value op_;
     139             :   Kind left_kind_;
     140             :   Kind right_kind_;
     141             :   Kind result_kind_;
     142             :   Maybe<int> fixed_right_arg_;
     143             :   Isolate* isolate_;
     144             : };
     145             : 
     146             : 
     147             : std::ostream& operator<<(std::ostream& os, const BinaryOpICState& s);
     148             : 
     149             : 
     150             : class CompareICState {
     151             :  public:
     152             :   // The type/state lattice is defined by the following inequations:
     153             :   //   UNINITIALIZED < ...
     154             :   //   ... < GENERIC
     155             :   //   SMI < NUMBER
     156             :   //   INTERNALIZED_STRING < STRING
     157             :   //   INTERNALIZED_STRING < UNIQUE_NAME
     158             :   //   KNOWN_RECEIVER < RECEIVER
     159             :   enum State {
     160             :     UNINITIALIZED,
     161             :     BOOLEAN,
     162             :     SMI,
     163             :     NUMBER,
     164             :     STRING,
     165             :     INTERNALIZED_STRING,
     166             :     UNIQUE_NAME,     // Symbol or InternalizedString
     167             :     RECEIVER,        // JSReceiver
     168             :     KNOWN_RECEIVER,  // JSReceiver with specific map (faster check)
     169             :     GENERIC
     170             :   };
     171             : 
     172             :   static AstType* StateToType(Zone* zone, State state,
     173             :                               Handle<Map> map = Handle<Map>());
     174             : 
     175             :   static State NewInputState(State old_state, Handle<Object> value);
     176             : 
     177             :   static const char* GetStateName(CompareICState::State state);
     178             : 
     179             :   static State TargetState(Isolate* isolate, State old_state, State old_left,
     180             :                            State old_right, Token::Value op,
     181             :                            bool has_inlined_smi_code, Handle<Object> x,
     182             :                            Handle<Object> y);
     183             : };
     184             : 
     185             : }  // namespace internal
     186             : }  // namespace v8
     187             : 
     188             : #endif  // V8_IC_STATE_H_

Generated by: LCOV version 1.10