Optimize equality for case when all targets are Object.equals.

runtime/vm/intermediate_language_x64.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/globals.h"  // Needed here to get TARGET_ARCH_X64.
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/intermediate_language.h"
 
 #include "lib/error.h"
@@ skipping 233 matching lines @@
     case Token::kGTE: return  GREATER_EQUAL;
     default:
       UNREACHABLE();
       return OVERFLOW;
   }
 }
 
 
 LocationSummary* EqualityCompareComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
-  if (receiver_class_id() != kObjectCid) {
-    ASSERT((receiver_class_id() == kSmiCid) ||
-           (receiver_class_id() == kDoubleCid));
+  const bool is_checked_strict_equal =
+      HasICData() && ic_data()->AllTargetsHaveSameOwner(kInstanceCid);
+  if ((receiver_class_id() == kSmiCid) ||
+      (receiver_class_id() == kDoubleCid) ||
+      is_checked_strict_equal) {
     const intptr_t kNumTemps = 1;
     LocationSummary* locs =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     locs->set_in(0, Location::RequiresRegister());
     locs->set_in(1, Location::RequiresRegister());
     locs->set_temp(0, Location::RequiresRegister());
     locs->set_out(Location::RequiresRegister());
     return locs;
   }
   if (HasICData() && (ic_data()->NumberOfChecks() > 0)) {
@@ skipping 70 matching lines @@
     __ j(NOT_ZERO, &load_class_id, Assembler::kNearJump);
     __ movq(temp, Immediate(kSmiCid));
     __ jmp(&done, Assembler::kNearJump);
     __ Bind(&load_class_id);
     __ LoadClassId(temp, left);
     __ Bind(&done);
   } else {
     __ j(ZERO, deopt);  // Smi deopts.
     __ LoadClassId(temp, left);
   }
+  // 'temp' contains class-id of the left argument.
+  ObjectStore* object_store = Isolate::Current()->object_store();
   Condition cond = TokenKindToSmiCondition(kind);
   Label done;
   for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
+    // Assert that the Smi is at position 0, if at all.
     ASSERT((ic_data.GetReceiverClassIdAt(i) != kSmiCid) || (i == 0));
     Label next_test;
     __ cmpq(temp, Immediate(ic_data.GetReceiverClassIdAt(i)));
     __ j(NOT_EQUAL, &next_test);
     const Function& target = Function::ZoneHandle(ic_data.GetTargetAt(i));
-    ObjectStore* object_store = Isolate::Current()->object_store();
     if (target.owner() == object_store->object_class()) {
       // Object.== is same as ===.
       __ Drop(2);
       __ cmpq(left, right);
       if (branch != NULL) {
         branch->EmitBranchOnCondition(compiler, cond);
       } else {
         // This case should be rare.
         Register result = locs.out().reg();
         Label load_true;
@@ skipping 30 matching lines @@
     }
     __ jmp(&done);
     __ Bind(&next_test);
   }
   // Fall through leads to deoptimization
   __ jmp(deopt);
   __ Bind(&done);
 }
 
 
+// Emit code when ICData's targets are all Object == (which is ===).
+static void EmitCheckedStrictEqual(FlowGraphCompiler* compiler,
+                                   const ICData& ic_data,
+                                   const LocationSummary& locs,
+                                   Token::Kind kind,
+                                   BranchInstr* branch,
+                                   intptr_t deopt_id,
+                                   intptr_t token_pos,
+                                   intptr_t try_index) {
+  ASSERT((kind == Token::kEQ) || (kind == Token::kNE));
+  Register left = locs.in(0).reg();
+  Register right = locs.in(1).reg();
+  Register temp = locs.temp(0).reg();
+  Label* deopt = compiler->AddDeoptStub(deopt_id,
+                                        try_index,
+                                        kDeoptEquality,
+                                        left,
+                                        right);
+  __ testq(left, Immediate(kSmiTagMask));
+  __ j(ZERO, deopt);
+  __ LoadClassId(temp, left);
+  Label done;
+  for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
+    __ cmpq(temp, Immediate(ic_data.GetReceiverClassIdAt(i)));
+    if (i == (ic_data.NumberOfChecks() - 1)) {
+      __ j(NOT_EQUAL, deopt);
+    } else {
+      __ j(EQUAL, &done);
+    }
+  }
+  __ Bind(&done);
+  __ cmpq(left, right);
+  if (branch == NULL) {
+    Label done, is_equal;
+    Register result = locs.out().reg();
+    __ j(EQUAL, &is_equal, Assembler::kNearJump);
+    // Not equal.
+    __ LoadObject(result, (kind == Token::kEQ) ? compiler->bool_false()
+                                               : compiler->bool_true());
+    __ jmp(&done, Assembler::kNearJump);
+    __ Bind(&is_equal);
+    __ LoadObject(result, (kind == Token::kEQ) ? compiler->bool_true()
+                                               : compiler->bool_false());
+    __ Bind(&done);
+  } else {
+    Condition cond = TokenKindToSmiCondition(kind);
+    branch->EmitBranchOnCondition(compiler, cond);
+  }
+}
+
+
 // First test if receiver is NULL, in which case === is applied.
 // If type feedback was provided (lists of <class-id, target>), do a
 // type by type check (either === or static call to the operator.
 static void EmitGenericEqualityCompare(FlowGraphCompiler* compiler,
                                        const LocationSummary& locs,
                                        Token::Kind kind,
                                        BranchInstr* branch,
                                        const ICData& ic_data,
                                        intptr_t deopt_id,
                                        intptr_t token_pos,
@@ skipping 130 matching lines @@
   if (receiver_class_id() == kSmiCid) {
     EmitSmiComparisonOp(compiler, *locs(), kind(), NULL,  // No branch.
                         deopt_id(), token_pos(), try_index());
     return;
   }
   if (receiver_class_id() == kDoubleCid) {
     EmitDoubleComparisonOp(compiler, *locs(), kind(), NULL,  // No branch.
                            deopt_id(), token_pos(), try_index());
     return;
   }
+  const bool is_checked_strict_equal =
+      HasICData() && ic_data()->AllTargetsHaveSameOwner(kInstanceCid);
+  if (is_checked_strict_equal) {
+    EmitCheckedStrictEqual(compiler, *ic_data(), *locs(), kind(), NULL,
+                           deopt_id(), token_pos(), try_index());
+    return;
+  }
   if (HasICData() && (ic_data()->NumberOfChecks() > 0)) {
     EmitGenericEqualityCompare(compiler, *locs(), kind(), NULL, *ic_data(),
                                deopt_id(), token_pos(), try_index());
   } else {
     Register left = locs()->in(0).reg();
     Register right = locs()->in(1).reg();
     __ pushq(left);
     __ pushq(right);
     EmitEqualityAsInstanceCall(compiler, this);
   }
 }
 
 
 LocationSummary* RelationalOpComp::MakeLocationSummary() const {
   if (operands_class_id() == kSmiCid || operands_class_id() == kDoubleCid) {
     const intptr_t kNumInputs = 2;
     const intptr_t kNumTemps = 1;
     LocationSummary* summary =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     summary->set_in(0, Location::RequiresRegister());
     summary->set_in(1, Location::RequiresRegister());
     summary->set_out(Location::RequiresRegister());
     summary->set_temp(0, Location::RequiresRegister());
     return summary;
   }
-  ASSERT(operands_class_id() == kObjectCid);
   return MakeCallSummary();
 }
 
 
 void RelationalOpComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   if (operands_class_id() == kSmiCid) {
     EmitSmiComparisonOp(compiler, *locs(), kind(), NULL,
                         deopt_id(), token_pos(), try_index());
     return;
   }
@@ skipping 1406 matching lines @@
 static bool ICDataWithBothClassIds(const ICData& ic_data, intptr_t class_id) {
   if (ic_data.num_args_tested() != 2) return false;
   if (ic_data.NumberOfChecks() != 1) return false;
   Function& target = Function::Handle();
   GrowableArray<intptr_t> class_ids;
   ic_data.GetCheckAt(0, &class_ids, &target);
   return (class_ids[0] == class_id) && (class_ids[1] == class_id);
 }
 
 
+static bool IsCheckedStrictEquals(const ICData& ic_data, Token::Kind kind) {
+  if ((kind == Token::kEQ) || (kind == Token::kNE)) {
+    return ic_data.AllTargetsHaveSameOwner(kInstanceCid);
+  }
+  return false;
+}
+
+
 LocationSummary* BranchInstr::MakeLocationSummary() const {
   if ((kind() == Token::kEQ_STRICT) || (kind() == Token::kNE_STRICT)) {
     const int kNumInputs = 2;
     const int kNumTemps = 0;
     LocationSummary* locs =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     locs->set_in(0, Location::RequiresRegister());
     locs->set_in(1, Location::RequiresRegister());
     return locs;
   }
   if (HasICData() && (ic_data()->NumberOfChecks() > 0)) {
     if (ICDataWithBothClassIds(*ic_data(), kSmiCid) ||
-        ICDataWithBothClassIds(*ic_data(), kDoubleCid)) {
+        ICDataWithBothClassIds(*ic_data(), kDoubleCid) ||
+        IsCheckedStrictEquals(*ic_data(), kind())) {
       const intptr_t kNumInputs = 2;
       const intptr_t kNumTemps = 1;
       LocationSummary* summary =
           new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
       summary->set_in(0, Location::RequiresRegister());
       summary->set_in(1, Location::RequiresRegister());
       summary->set_temp(0, Location::RequiresRegister());
       return summary;
     }
     if ((kind() == Token::kEQ) || (kind() == Token::kNE)) {
@@ skipping 33 matching lines @@
     if (ICDataWithBothClassIds(*ic_data(), kSmiCid)) {
       EmitSmiComparisonOp(compiler, *locs(), kind(), this,
                           deopt_id(), token_pos(), try_index());
       return;
     }
     if (ICDataWithBothClassIds(*ic_data(), kDoubleCid)) {
       EmitDoubleComparisonOp(compiler, *locs(), kind(), this,
                              deopt_id(), token_pos(), try_index());
       return;
     }
+    if (IsCheckedStrictEquals(*ic_data(), kind())) {
+      EmitCheckedStrictEqual(compiler, *ic_data(), *locs(), kind(), this,
+                             deopt_id(), token_pos(), try_index());
+      return;
+    }
     // TODO(srdjan): Add Smi/Double, Double/Smi comparisons.
     if ((kind() == Token::kEQ) || (kind() == Token::kNE)) {
       EmitGenericEqualityCompare(compiler, *locs(), kind(), this, *ic_data(),
                                  deopt_id(), token_pos(), try_index());
       return;
     }
     // Otherwise polymorphic dispatch?
   }
   Register left = locs()->in(0).reg();
   Register right = locs()->in(1).reg();
@@ skipping 19 matching lines @@
                                  kNumArgsChecked);
   __ CompareObject(RAX, compiler->bool_true());
   EmitBranchOnCondition(compiler, branch_condition);
 }
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64