Optimize the equality check case of ICCompare stubs.

src/ic.cc

Index: src/ic.cc
===================================================================
--- src/ic.cc	(revision 9957)
+++ src/ic.cc	(working copy)
@@ -2315,6 +2315,7 @@
     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";
@@ -2332,16 +2333,32 @@
   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;
 }