Equality compare should record two arguments in IC data. INline double equality comparison.

runtime/vm/intermediate_language_ia32.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_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/intermediate_language.h"
 
 #include "lib/error.h"
@@ skipping 174 matching lines @@
   // We should never return here.
   __ int3();
 
   __ Bind(&done);
   ASSERT(obj == result);
 }
 
 
 LocationSummary* EqualityCompareComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
-  if (HasICData() &&
-      (ic_data()->NumberOfChecks() == 1) &&
-      (ic_data()->GetReceiverClassIdAt(0) == kSmi)) {
+  if (receiver_class_id() != kObject) {
+    ASSERT((receiver_class_id() == kSmi) || (receiver_class_id() == kDouble));
     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());
     if (!is_fused_with_branch()) {
       locs->set_out(Location::RequiresRegister());
     }
@@ skipping 18 matching lines @@
                                               LocationSummary::kCall);
   locs->set_in(0, Location::RequiresRegister());
   locs->set_in(1, Location::RequiresRegister());
   if (!is_fused_with_branch()) {
     locs->set_out(Location::RegisterLocation(EAX));
   }
   return locs;
 }
 
 
+// Optional integer arguments can often be null. Null is not collected
+// by IC data. TODO(srdjan): Shall we collect null classes in ICData as well?
 static void EmitSmiEqualityCompare(FlowGraphCompiler* compiler,
                                    EqualityCompareComp* comp) {
   Register left = comp->locs()->in(0).reg();
   Register right = comp->locs()->in(1).reg();
   Register temp = comp->locs()->temp(0).reg();
   Label* deopt = compiler->AddDeoptStub(comp->cid(),
                                         comp->token_pos(),
                                         comp->try_index(),
-                                        kDeoptSmiCompareSmis,
+                                        kDeoptSmiCompareSmi,
                                         left,
                                         right);
-  // TODO(srdjan): Should we always include NULL test (common case)?
   __ movl(temp, left);
   __ orl(temp, right);
   __ testl(temp, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, deopt);
   __ cmpl(left, right);
   if (comp->is_fused_with_branch()) {
     comp->fused_with_branch()->EmitBranchOnCondition(compiler, EQUAL);
   } else {
     Register result = comp->locs()->out().reg();
     Label load_true, done;
     __ j(EQUAL, &load_true, Assembler::kNearJump);
     __ LoadObject(result, compiler->bool_false());
     __ jmp(&done, Assembler::kNearJump);
     __ Bind(&load_true);
     __ LoadObject(result, compiler->bool_true());
     __ Bind(&done);
   }
 }
 
 
+// TODO(srdjan): Add support for mixed Smi/Double equality
+// (see LoadDoubleOrSmiToXmm).
+static void EmitDoubleEqualityCompare(FlowGraphCompiler* compiler,
+                                      EqualityCompareComp* comp) {
+  Register left = comp->locs()->in(0).reg();
+  Register right = comp->locs()->in(1).reg();
+  Register temp = comp->locs()->temp(0).reg();
+  Label* deopt = compiler->AddDeoptStub(comp->cid(),
+                                        comp->token_pos(),
+                                        comp->try_index(),
+                                        kDeoptDoubleCompareDouble,
+                                        left,
+                                        right);
+  Label done, is_false, is_true;
+  __ CompareClassId(left, kDouble, temp);
+  __ j(NOT_EQUAL, deopt);
+  __ CompareClassId(right, kDouble, temp);
+  __ j(NOT_EQUAL, deopt);
+  __ movsd(XMM0, FieldAddress(left, Double::value_offset()));
+  __ movsd(XMM1, FieldAddress(right, Double::value_offset()));
+  if (comp->is_fused_with_branch()) {
+    compiler->EmitDoubleCompareBranch(
+        EQUAL, XMM0, XMM1, comp->fused_with_branch());
+  } else {
+    compiler->EmitDoubleCompareBool(
+        EQUAL, XMM0, XMM1, comp->locs()->out().reg());
+  }
+}
+
+
 static void EmitEqualityAsInstanceCall(FlowGraphCompiler* compiler,
                                        EqualityCompareComp* comp) {
   compiler->AddCurrentDescriptor(PcDescriptors::kDeopt,
                                  comp->cid(),
                                  comp->token_pos(),
                                  comp->try_index());
   const String& operator_name = String::ZoneHandle(String::NewSymbol("=="));
   const int kNumberOfArguments = 2;
   const Array& kNoArgumentNames = Array::Handle();
   const int kNumArgumentsChecked = 2;
@@ skipping 12 matching lines @@
     comp->fused_with_branch()->EmitBranchOnCondition(compiler, EQUAL);
   }
 }
 
 
 static void EmitEqualityAsPolymorphicCall(FlowGraphCompiler* compiler,
                                           EqualityCompareComp* comp,
                                           Register left,
                                           Register right) {
   ASSERT(comp->HasICData());
-  const ICData& ic_data = *comp->ic_data();
+  const ICData& ic_data = ICData::Handle(comp->ic_data()->AsUnaryClassChecks());
   ASSERT(ic_data.NumberOfChecks() > 0);
   ASSERT(ic_data.num_args_tested() == 1);
   Label* deopt = compiler->AddDeoptStub(comp->cid(),
                                         comp->token_pos(),
                                         comp->try_index(),
                                         kDeoptEquality);
   __ testl(left, Immediate(kSmiTagMask));
   Register temp = comp->locs()->temp(0).reg();
   if (ic_data.GetReceiverClassIdAt(0) == kSmi) {
     Label done, load_class_id;
@@ skipping 89 matching lines @@
   if (comp->HasICData() && (comp->ic_data()->NumberOfChecks() > 0)) {
     EmitEqualityAsPolymorphicCall(compiler, comp, left, right);
   } else {
     EmitEqualityAsInstanceCall(compiler, comp);
   }
   __ Bind(&done);
 }
 
 
 void EqualityCompareComp::EmitNativeCode(FlowGraphCompiler* compiler) {
-  if (HasICData() &&
-      (ic_data()->NumberOfChecks() == 1) &&
-      (ic_data()->GetReceiverClassIdAt(0) == kSmi)) {
+  if (receiver_class_id() == kSmi) {
     EmitSmiEqualityCompare(compiler, this);
     return;
   }
+  if (receiver_class_id() == kDouble) {
+    EmitDoubleEqualityCompare(compiler, this);
+    return;
+  }
   EmitGenericEqualityCompare(compiler, this);
 }
 
 
 LocationSummary* RelationalOpComp::MakeLocationSummary() const {
   if ((operands_class_id() == kSmi) || (operands_class_id() == kDouble)) {
     const intptr_t kNumInputs = 2;
     const intptr_t kNumTemps = 1;
     LocationSummary* summary = new LocationSummary(kNumInputs,
                                                    kNumTemps,
@@ skipping 28 matching lines @@
 
 
 static void EmitSmiRelationalOp(FlowGraphCompiler* compiler,
                                 RelationalOpComp* comp) {
   Register left = comp->locs()->in(0).reg();
   Register right = comp->locs()->in(1).reg();
   Register temp = comp->locs()->temp(0).reg();
   Label* deopt = compiler->AddDeoptStub(comp->cid(),
                                         comp->token_pos(),
                                         comp->try_index(),
-                                        kDeoptSmiCompareSmis,
+                                        kDeoptSmiCompareSmi,
                                         left,
                                         right);
   __ movl(temp, left);
   __ orl(temp, right);
   __ testl(temp, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, deopt);
 
   Condition true_condition = TokenKindToSmiCondition(comp->kind());
   __ cmpl(left, right);
 
@@ skipping 35 matching lines @@
   Label* deopt = compiler->AddDeoptStub(comp->cid(),
                                         comp->token_pos(),
                                         comp->try_index(),
                                         kDeoptDoubleComparison,
                                         left,
                                         right);
   compiler->LoadDoubleOrSmiToXmm(XMM0, left, temp, deopt);
   compiler->LoadDoubleOrSmiToXmm(XMM1, right, temp, deopt);
 
   Condition true_condition = TokenKindToDoubleCondition(comp->kind());
-  __ comisd(XMM0, XMM1);
-
   if (comp->is_fused_with_branch()) {
-    BranchInstr* branch = comp->fused_with_branch();
-    BlockEntryInstr* nan_result = branch->is_negated() ?
-        branch->true_successor() : branch->false_successor();
-    __ j(PARITY_EVEN, compiler->GetBlockLabel(nan_result));
-    branch->EmitBranchOnCondition(compiler, true_condition);
+    compiler->EmitDoubleCompareBranch(
+        true_condition, XMM0, XMM1, comp->fused_with_branch());
   } else {
-    Register result = comp->locs()->out().reg();
-    Label is_false, is_true, done;
-    __ j(PARITY_EVEN, &is_false, Assembler::kNearJump);  // NaN -> false;
-    __ j(true_condition, &is_true, Assembler::kNearJump);
-    __ Bind(&is_false);
-    __ LoadObject(result, compiler->bool_false());
-    __ jmp(&done);
-    __ Bind(&is_true);
-    __ LoadObject(result, compiler->bool_true());
-    __ Bind(&done);
+    compiler->EmitDoubleCompareBool(
+        true_condition, XMM0, XMM1, comp->locs()->out().reg());
   }
 }
 
 
 void RelationalOpComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   if (operands_class_id() == kSmi) {
     EmitSmiRelationalOp(compiler, this);
     return;
   }
   if (operands_class_id() == kDouble) {
@@ skipping 1405 matching lines @@
                                  instance_call()->argument_names());
   }
   __ Bind(&done);
 }
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64