Remove half of the checks for comparing two Obejcts

src/hydrogen-check-elimination.cc

 // Copyright 2013 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 83 matching lines @@
         break;
       }
       case HValue::kCheckMapValue: {
         ReduceCheckMapValue(HCheckMapValue::cast(instr));
         break;
       }
       case HValue::kCheckHeapObject: {
         ReduceCheckHeapObject(HCheckHeapObject::cast(instr));
         break;
       }
+      case HValue::kCompareObjectEqAndBranch: {
+        ReduceCompareObjectEqAndBranch(HCompareObjectEqAndBranch::cast(instr));
+        break;
+      }
       default: {
         // If the instruction changes maps uncontrollably, drop everything.
         if (instr->CheckGVNFlag(kChangesMaps) ||
             instr->CheckGVNFlag(kChangesOsrEntries)) {
           Kill();
         }
       }
       // Improvements possible:
       // - eliminate redundant HCheckSmi, HCheckInstanceType instructions
       // - track which values have been HCheckHeapObject'd
@@ skipping 145 matching lines @@
   }
 
   void ReduceCheckHeapObject(HCheckHeapObject* instr) {
     if (FindMaps(instr->value()->ActualValue()) != NULL) {
       // If the object has known maps, it's definitely a heap object.
       instr->DeleteAndReplaceWith(instr->value());
       INC_STAT(removed_cho_);
     }
   }
 
+  void ReduceCompareObjectEqAndBranch(HCompareObjectEqAndBranch* instr) {
+    HCheckMaps* removed = NULL;
+    HValue* left = instr->left();
+    HValue* right = instr->right();
+    if (left->IsCheckMaps() && right->IsCheckMaps()) {
+      HCheckMaps* left_check = HCheckMaps::cast(left);
+      HCheckMaps* right_check = HCheckMaps::cast(right);
+      MapSet left_maps = left_check->map_set().Copy(phase_->zone());
+      MapSet right_maps = right_check->map_set().Copy(phase_->zone());
+      if (left_maps->Equals(right_maps)) {
+        // Object equality comparison guarantees one check suffices, so
+        // eliminate the other. After LICM, we could easily find the correct
+        // one (loop invariant object's map check could be hoisted out of loop).
+        removed = left->block()->block_id() > right->block()->block_id()
+            ? left_check : right_check;
+      }
+    } else if (left->IsCheckMaps() || right->IsCheckMaps()) {
+      // For the case one side map check is eliminated by previous optimization.
+      HValue* obj = left->IsCheckMaps() ? right : left;
+      HCheckMaps* check = (obj == left) ? HCheckMaps::cast(right)
+                                        : HCheckMaps::cast(left);
+      MapSet obj_maps = FindMaps(obj);
+      MapSet check_maps = check->map_set().Copy(phase_->zone());
+      if (obj_maps->IsSubset(check_maps)) {
+        // Obj check is more strict; the remaining check is redundant.
+        removed = check;
+      }
+    }
+
+    if (removed != NULL) {
+      // Check whether there is prior CheckHeapObject refering to the same
+      // object as the removed CheckMaps.
+      if (removed->previous()->IsCheckHeapObject()) {
+        HCheckHeapObject* cho = HCheckHeapObject::cast(removed->previous());
+        if (cho->value() == removed->ActualValue()) {
+          cho->DeleteAndReplaceWith(cho->value());
+          INC_STAT(removed_cho_);
+        }
+      }
+      removed->DeleteAndReplaceWith(removed->ActualValue());
+      INC_STAT(removed_);
+    }
+  }
+
   void ReduceStoreNamedField(HStoreNamedField* instr) {
     HValue* object = instr->object()->ActualValue();
     if (instr->has_transition()) {
       // This store transitions the object to a new map.
       Kill(object);
       Insert(object, MapConstant(instr->transition()));
     } else if (IsMapAccess(instr->access())) {
       // This is a store directly to the map field of the object.
       Kill(object);
       if (!instr->value()->IsConstant()) return;
@@ skipping 248 matching lines @@
   PRINT_STAT(removed_cho);
   PRINT_STAT(narrowed);
   PRINT_STAT(loads);
   PRINT_STAT(empty);
   PRINT_STAT(compares_true);
   PRINT_STAT(compares_false);
   PRINT_STAT(transitions);
 }
 
 } }  // namespace v8::internal