Fix null-equality comparison for unoptimized branch code.

runtime/vm/intermediate_language_x64.cc

Index: runtime/vm/intermediate_language_x64.cc
===================================================================
--- runtime/vm/intermediate_language_x64.cc	(revision 10909)
+++ runtime/vm/intermediate_language_x64.cc	(working copy)
@@ -289,19 +289,23 @@
 
 
 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 =
@@ -315,30 +319,29 @@
   __ 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);
@@ -668,7 +671,13 @@
     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);
   }
 }
 
@@ -2164,25 +2173,32 @@
   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);
 }