[ic] Introduce BOOLEAN state for CompareIC.

src/ic/ic-state.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/ic/ic-state.h"
 
 #include "src/ic/ic.h"
 
 namespace v8 {
 namespace internal {
@@ skipping 340 matching lines @@
   }
   UNREACHABLE();
   return NULL;
 }
 
 
 const char* CompareICState::GetStateName(State state) {
   switch (state) {
     case UNINITIALIZED:
       return "UNINITIALIZED";
+    case BOOLEAN:
+      return "BOOLEAN";
     case SMI:
       return "SMI";
     case NUMBER:
       return "NUMBER";
     case INTERNALIZED_STRING:
       return "INTERNALIZED_STRING";
     case STRING:
       return "STRING";
     case UNIQUE_NAME:
       return "UNIQUE_NAME";
     case OBJECT:
       return "OBJECT";
     case KNOWN_OBJECT:
       return "KNOWN_OBJECT";
     case GENERIC:
       return "GENERIC";
   }
   UNREACHABLE();
   return NULL;
 }
 
 
 Type* CompareICState::StateToType(Zone* zone, State state, Handle<Map> map) {
   switch (state) {
     case UNINITIALIZED:
       return Type::None(zone);
+    case BOOLEAN:
+      return Type::Boolean(zone);
     case SMI:
       return Type::SignedSmall(zone);
     case NUMBER:
       return Type::Number(zone);
     case STRING:
       return Type::String(zone);
     case INTERNALIZED_STRING:
       return Type::InternalizedString(zone);
     case UNIQUE_NAME:
       return Type::UniqueName(zone);
     case OBJECT:
       return Type::Receiver(zone);
     case KNOWN_OBJECT:
       return map.is_null() ? Type::Receiver(zone) : Type::Class(map, zone);
     case GENERIC:
       return Type::Any(zone);
   }
   UNREACHABLE();
   return NULL;
 }
 
 
 CompareICState::State CompareICState::NewInputState(State old_state,
                                                     Handle<Object> value) {
   switch (old_state) {
     case UNINITIALIZED:
+      if (value->IsBoolean()) return BOOLEAN;
       if (value->IsSmi()) return SMI;
       if (value->IsHeapNumber()) return NUMBER;
       if (value->IsInternalizedString()) return INTERNALIZED_STRING;
       if (value->IsString()) return STRING;
       if (value->IsSymbol()) return UNIQUE_NAME;
       if (value->IsJSObject()) return OBJECT;
       break;
+    case BOOLEAN:
+      if (value->IsBoolean()) return BOOLEAN;
+      break;
     case SMI:
       if (value->IsSmi()) return SMI;
       if (value->IsHeapNumber()) return NUMBER;
       break;
     case NUMBER:
       if (value->IsNumber()) return NUMBER;
       break;
     case INTERNALIZED_STRING:
       if (value->IsInternalizedString()) return INTERNALIZED_STRING;
       if (value->IsString()) return STRING;
@@ skipping 17 matching lines @@
   return GENERIC;
 }
 
 
 // static
 CompareICState::State CompareICState::TargetState(
     State old_state, State old_left, State old_right, Token::Value op,
     bool has_inlined_smi_code, Handle<Object> x, Handle<Object> y) {
   switch (old_state) {
     case UNINITIALIZED:
+      if (x->IsBoolean() && y->IsBoolean()) return BOOLEAN;
       if (x->IsSmi() && y->IsSmi()) return SMI;
       if (x->IsNumber() && y->IsNumber()) return NUMBER;
       if (Token::IsOrderedRelationalCompareOp(op)) {
         // Ordered comparisons treat undefined as NaN, so the
         // NUMBER stub will do the right thing.
         if ((x->IsNumber() && y->IsUndefined()) ||
             (y->IsNumber() && x->IsUndefined())) {
           return NUMBER;
         }
       }
@@ skipping 26 matching lines @@
       // then keep the state (if other changed at the same time, we will get
       // a second miss and then go to generic).
       if (old_left == SMI && x->IsHeapNumber()) return NUMBER;
       if (old_right == SMI && y->IsHeapNumber()) return NUMBER;
       return GENERIC;
     case KNOWN_OBJECT:
       if (x->IsJSObject() && y->IsJSObject()) {
         return Token::IsEqualityOp(op) ? OBJECT : GENERIC;
       }
       return GENERIC;
+    case BOOLEAN:
     case STRING:
     case UNIQUE_NAME:
     case OBJECT:
     case GENERIC:
       return GENERIC;
   }
   UNREACHABLE();
   return GENERIC;  // Make the compiler happy.
 }
+
 }  // namespace internal
 }  // namespace v8