Optimize the equality check case of ICCompare stubs.

src/ic.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 2297 matching lines @@
   return static_cast<State>(target->compare_state());
 }
 
 
 const char* CompareIC::GetStateName(State state) {
   switch (state) {
     case UNINITIALIZED: return "UNINITIALIZED";
     case SMIS: return "SMIS";
     case HEAP_NUMBERS: return "HEAP_NUMBERS";
     case OBJECTS: return "OBJECTS";
+    case KNOWN_OBJECTS: return "OBJECTS";
     case SYMBOLS: return "SYMBOLS";
     case STRINGS: return "STRINGS";
     case GENERIC: return "GENERIC";
     default:
       UNREACHABLE();
       return NULL;
   }
 }
 
 
 CompareIC::State CompareIC::TargetState(State state,
                                         bool has_inlined_smi_code,
                                         Handle<Object> x,
                                         Handle<Object> y) {
   if (!has_inlined_smi_code && state != UNINITIALIZED && state != SYMBOLS) {
     return GENERIC;
   }
-  if (state == UNINITIALIZED && x->IsSmi() && y->IsSmi()) return SMIS;
+  if (state == UNINITIALIZED && x->IsSmi() && y->IsSmi()) {

[Kevin Millikin (Chromium), 2011/11/10 19:08:42]

I don't like this function.  It's really hard to figure out what transitions
will happen.

It seems to be programmed after listing the possible output types with some
exceptions up front, but that's not the way that most people think about state
transitions.  What about rewriting it to something more structured like:

switch (state) {
  case UNINITIALIZED:
    if (x->IsSmi() && y->IsSmi()) return SMIS;
    if (x->IsNumber() && y->IsNumber()) return HEAP_NUMBERS;
    if (!Token::IsEqualityOp(op_)) return GENERIC;
    if (x->IsSymbol() && y->IsSymbol()) return SYMBOLS;
    if (x->IsString() && y->IsString()) return STRINGS;
    if (x->IsJSObject() && y->IsJSObject()) {
      // Your new stuff here.
    }
    return GENERIC;
  case SMIS:
    return has_inlined_smi_code && x->IsNumber() && y->IsNumber()
        ? HEAP_NUMBERS
        : GENERIC;
  case SYMBOLS:
    ASSERT(Token::IsEqualityOp(op_));
    return x->IsString() && y->IsString() ? STRINGS : GENERIC;
  case HEAP_NUMBERS:
  case STRINGS:
  case OBJECTS:
  case KNOWN_OBJECTS:
  case GENERIC:
    return GENERIC;
}

[Rico, 2011/11/11 08:49:11]

Done.

+    return SMIS;
+  }
   if ((state == UNINITIALIZED || (state == SMIS && has_inlined_smi_code)) &&
-      x->IsNumber() && y->IsNumber()) return HEAP_NUMBERS;
-  if (op_ != Token::EQ && op_ != Token::EQ_STRICT) return GENERIC;
+      x->IsNumber() && y->IsNumber()) {
+    return HEAP_NUMBERS;
+  }
+  if (op_ != Token::EQ && op_ != Token::EQ_STRICT) {
+    return GENERIC;
+  }
   if (state == UNINITIALIZED &&
-      x->IsSymbol() && y->IsSymbol()) return SYMBOLS;
+      x->IsSymbol() && y->IsSymbol()) {
+    return SYMBOLS;
+  }
   if ((state == UNINITIALIZED || state == SYMBOLS) &&
-      x->IsString() && y->IsString()) return STRINGS;
-  if (state == UNINITIALIZED &&
-      x->IsJSObject() && y->IsJSObject()) return OBJECTS;
+      x->IsString() && y->IsString()) {
+    return STRINGS;
+  }
+  if (state == UNINITIALIZED && x->IsJSObject() && y->IsJSObject()) {
+    if (Handle<JSObject>::cast(x)->map() == Handle<JSObject>::cast(y)->map() &&
+        op_ == Token::EQ) {
+      return KNOWN_OBJECTS;
+    } else {
+      return OBJECTS;
+    }
+  }
   return GENERIC;
 }
 
 
 // Used from ic_<arch>.cc.
 RUNTIME_FUNCTION(Code*, CompareIC_Miss) {
   NoHandleAllocation na;
   ASSERT(args.length() == 3);
   CompareIC ic(isolate, static_cast<Token::Value>(args.smi_at(2)));
   ic.UpdateCaches(args.at<Object>(0), args.at<Object>(1));
@@ skipping 33 matching lines @@
 #undef ADDR
 };
 
 
 Address IC::AddressFromUtilityId(IC::UtilityId id) {
   return IC_utilities[id];
 }
 
 
 } }  // namespace v8::internal