Fix null-equality comparison for unoptimized branch code.

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 271 matching lines @@
   LocationSummary* locs =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   locs->set_in(0, Location::RegisterLocation(RCX));
   locs->set_in(1, Location::RegisterLocation(RDX));
   locs->set_out(Location::RegisterLocation(RAX));
   return locs;
 }
 
 
 static void EmitEqualityAsInstanceCall(FlowGraphCompiler* compiler,
-                                       EqualityCompareComp* comp) {
+                                       intptr_t deopt_id,
+                                       intptr_t token_pos,
+                                       intptr_t try_index,
+                                       Token::Kind kind,
+                                       const LocationSummary& locs) {
   compiler->AddCurrentDescriptor(PcDescriptors::kDeopt,
-                                 comp->deopt_id(),
-                                 comp->token_pos(),
-                                 comp->try_index());
+                                 deopt_id,
+                                 token_pos,
+                                 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();
+  Register left = locs.in(0).reg();
+  Register right = 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) {
+  if (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);
+    ASSERT(kind == Token::kNE);
     __ jmp(&false_label);
   }
 
   __ Bind(&instance_call);
   __ pushq(left);
   __ pushq(right);
-  compiler->GenerateInstanceCall(comp->deopt_id(),
-                                 comp->token_pos(),
-                                 comp->try_index(),
+  compiler->GenerateInstanceCall(deopt_id,
+                                 token_pos,
+                                 try_index,
                                  operator_name,
                                  kNumberOfArguments,
                                  kNoArgumentNames,
                                  kNumArgumentsChecked,
-                                 comp->locs()->stack_bitmap());
-  ASSERT(comp->locs()->out().reg() == RAX);
-  if (comp->kind() == Token::kNE) {
+                                 locs.stack_bitmap());
+  if (kind == Token::kNE) {
     // Negate the condition: true label returns false and vice versa.
     __ CompareObject(RAX, compiler->bool_true());
     __ j(EQUAL, &true_label, Assembler::kNearJump);
     __ Bind(&false_label);
     __ LoadObject(RAX, compiler->bool_true());
     __ jmp(&done, Assembler::kNearJump);
     __ Bind(&true_label);
     __ LoadObject(RAX, compiler->bool_false());
   }
   __ Bind(&done);
@@ skipping 309 matching lines @@
     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);
+    EmitEqualityAsInstanceCall(compiler,
+                               deopt_id(),
+                               token_pos(),
+                               try_index(),
+                               kind(),
+                               *locs());
+    ASSERT(locs()->out().reg() == RAX);
   }
 }
 
 
 LocationSummary* RelationalOpComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
   if (operands_class_id() == kSmiCid || operands_class_id() == kDoubleCid) {
     const intptr_t kNumTemps = 1;
     LocationSummary* summary =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
@@ skipping 1475 matching lines @@
       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();
   __ pushq(left);
   __ pushq(right);
-  // Not equal is always split into '==' and negate,
+  if ((kind() == Token::kNE) || (kind() == Token::kEQ)) {
+    EmitEqualityAsInstanceCall(compiler,
+                               deopt_id(),
+                               token_pos(),
+                               try_index(),
+                               Token::kEQ,  // kNE reverse occurs at branch.
+                               *locs());
+  } else {
+    const String& function_name =
+        String::ZoneHandle(Symbols::New(Token::Str(kind())));
+    compiler->AddCurrentDescriptor(PcDescriptors::kDeopt,
+                                   deopt_id(),
+                                   token_pos(),
+                                   try_index());
+    const intptr_t kNumArguments = 2;
+    const intptr_t kNumArgsChecked = 2;  // Type-feedback.
+    compiler->GenerateInstanceCall(deopt_id(),
+                                   token_pos(),
+                                   try_index(),
+                                   function_name,
+                                   kNumArguments,
+                                   Array::ZoneHandle(),  // No optional args.
+                                   kNumArgsChecked,
+                                   locs()->stack_bitmap());
+  }
   Condition branch_condition = (kind() == Token::kNE) ? NOT_EQUAL : EQUAL;
-  Token::Kind call_kind = (kind() == Token::kNE) ? Token::kEQ : kind();
-  const String& function_name =
-      String::ZoneHandle(Symbols::New(Token::Str(call_kind)));
-  compiler->AddCurrentDescriptor(PcDescriptors::kDeopt,
-                                 deopt_id(),
-                                 token_pos(),
-                                 try_index());
-  const intptr_t kNumArguments = 2;
-  const intptr_t kNumArgsChecked = 2;  // Type-feedback.
-  compiler->GenerateInstanceCall(deopt_id(),
-                                 token_pos(),
-                                 try_index(),
-                                 function_name,
-                                 kNumArguments,
-                                 Array::ZoneHandle(),  // No optional arguments.
-                                 kNumArgsChecked,
-                                 locs()->stack_bitmap());
   __ CompareObject(RAX, compiler->bool_true());
   EmitBranchOnCondition(compiler, branch_condition);
 }
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64