Implement new equality spec.

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 281 matching lines @@
                                        EqualityCompareComp* comp) {
   compiler->AddCurrentDescriptor(PcDescriptors::kDeopt,
                                  comp->deopt_id(),
                                  comp->token_pos(),
                                  comp->try_index());
   const String& operator_name = String::ZoneHandle(Symbols::New("=="));
   const int kNumberOfArguments = 2;
   const Array& kNoArgumentNames = Array::Handle();
   const int kNumArgumentsChecked = 2;
 
+  Label done, false_label, true_label;
+  Register left = comp->locs()->in(0).reg();
+  Register right = comp->locs()->in(1).reg();
+  __ popq(right);
+  __ popq(left);
+  const Immediate raw_null =
+      Immediate(reinterpret_cast<intptr_t>(Object::null()));
+  Label check_identity, instance_call;
+  __ cmpq(right, raw_null);
+  __ j(EQUAL, &check_identity, Assembler::kNearJump);
+  __ cmpq(left, raw_null);
+  __ j(NOT_EQUAL, &instance_call, Assembler::kNearJump);
+
+  __ Bind(&check_identity);
+  __ cmpq(left, right);
+  __ j(EQUAL, &true_label);
+  if (comp->kind() == Token::kEQ) {
+    __ LoadObject(RAX, compiler->bool_false());
+    __ jmp(&done);
+    __ Bind(&true_label);
+    __ LoadObject(RAX, compiler->bool_true());
+    __ jmp(&done);
+  } else {
+    ASSERT(comp->kind() == Token::kNE);
+    __ jmp(&false_label);
+  }
+
+  __ Bind(&instance_call);
+  __ pushq(left);
+  __ pushq(right);
   compiler->GenerateInstanceCall(comp->deopt_id(),
                                  comp->token_pos(),
                                  comp->try_index(),
                                  operator_name,
                                  kNumberOfArguments,
                                  kNoArgumentNames,
                                  kNumArgumentsChecked,
                                  comp->locs()->stack_bitmap());
   ASSERT(comp->locs()->out().reg() == RAX);
   if (comp->kind() == Token::kNE) {
-    Label done, false_label;
+    // Negate the condition: true label returns false and vice versa.
     __ CompareObject(RAX, compiler->bool_true());
-    __ j(EQUAL, &false_label, Assembler::kNearJump);
+    __ j(EQUAL, &true_label, Assembler::kNearJump);
+    __ Bind(&false_label);
     __ LoadObject(RAX, compiler->bool_true());
     __ jmp(&done, Assembler::kNearJump);
-    __ Bind(&false_label);
+    __ Bind(&true_label);
     __ LoadObject(RAX, compiler->bool_false());
-    __ Bind(&done);
   }
+  __ Bind(&done);
 }
 
 
 static void EmitEqualityAsPolymorphicCall(FlowGraphCompiler* compiler,
                                           const ICData& orig_ic_data,
                                           const LocationSummary& locs,
                                           BranchInstr* branch,
                                           Token::Kind kind,
                                           intptr_t deopt_id,
                                           intptr_t token_pos,
@@ skipping 95 matching lines @@
   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);
+  // 'left' is not Smi.
+  const Immediate raw_null =
+      Immediate(reinterpret_cast<intptr_t>(Object::null()));
+  Label identity_compare;
+  __ cmpq(right, raw_null);
+  __ j(EQUAL, &identity_compare);
+  __ cmpq(left, raw_null);
+  __ j(EQUAL, &identity_compare);
+
   __ 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);
+      __ j(EQUAL, &identity_compare);
     }
   }
-  __ Bind(&done);
+  __ Bind(&identity_compare);
   __ 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);
@@ skipping 17 matching lines @@
                                        const ICData& ic_data,
                                        intptr_t deopt_id,
                                        intptr_t token_pos,
                                        intptr_t try_index) {
   ASSERT((kind == Token::kEQ) || (kind == Token::kNE));
   ASSERT(!ic_data.IsNull() && (ic_data.NumberOfChecks() > 0));
   Register left = locs.in(0).reg();
   Register right = locs.in(1).reg();
   const Immediate raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
-  Label done, non_null_compare;
+  Label done, identity_compare, non_null_compare;
+  __ cmpq(right, raw_null);
+  __ j(EQUAL, &identity_compare, Assembler::kNearJump);
   __ cmpq(left, raw_null);
   __ j(NOT_EQUAL, &non_null_compare, Assembler::kNearJump);
   // Comparison with NULL is "===".
+  __ Bind(&identity_compare);
   __ cmpq(left, right);
   Condition cond = TokenKindToSmiCondition(kind);
   if (branch != NULL) {
     branch->EmitBranchOnCondition(compiler, cond);
   } else {
     Register result = locs.out().reg();
     Label load_true;
     __ j(cond, &load_true, Assembler::kNearJump);
     __ LoadObject(result, compiler->bool_false());
     __ jmp(&done);
@@ skipping 95 matching lines @@
         true_condition, XMM0, XMM1, branch);
   } else {
     compiler->EmitDoubleCompareBool(
         true_condition, XMM0, XMM1, locs.out().reg());
   }
 }
 
 
 void EqualityCompareComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   if (receiver_class_id() == kSmiCid) {
+    // Deoptimizes if both arguments not Smi.
     EmitSmiComparisonOp(compiler, *locs(), kind(), NULL,  // No branch.
                         deopt_id(), token_pos(), try_index());
     return;
   }
   if (receiver_class_id() == kDoubleCid) {
+    // Deoptimizes if both arguments are Smi, or if none is Double or Smi.
     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;
@@ skipping 1523 matching lines @@
                                  locs()->stack_bitmap());
   __ CompareObject(RAX, compiler->bool_true());
   EmitBranchOnCondition(compiler, branch_condition);
 }
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64