Use unary class checks when emitting instance calls in optimized mode.

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 336 matching lines @@
 
   const Immediate raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   Label check_identity;
   __ cmpq(Address(RSP, 0 * kWordSize), raw_null);
   __ j(EQUAL, &check_identity, Assembler::kNearJump);
   __ cmpq(Address(RSP, 1 * kWordSize), raw_null);
   __ j(EQUAL, &check_identity, Assembler::kNearJump);
 
   ICData& equality_ic_data = ICData::ZoneHandle(original_ic_data.raw());
-  if (equality_ic_data.IsNull()) {
+  if (compiler->is_optimizing()) {
+    ASSERT(!original_ic_data.IsNull());
+    equality_ic_data = original_ic_data.AsUnaryClassChecks();
+  } else {
     equality_ic_data = ICData::New(compiler->parsed_function().function(),
                                    operator_name,
                                    deopt_id,
                                    kNumArgumentsChecked);
   }
   compiler->GenerateInstanceCall(deopt_id,
                                  token_pos,
                                  kNumberOfArguments,
                                  kNoArgumentNames,
                                  locs,
                                  equality_ic_data);
   Label check_ne;
   __ jmp(&check_ne);
 
   __ Bind(&check_identity);
-  // Call stub, load IC data in register. The stub will update ICData if
-  // necessary.
-  Register ic_data_reg = locs->temp(0).reg();
-  ASSERT(ic_data_reg == RBX);  // Stub depends on it.
-  __ LoadObject(ic_data_reg, equality_ic_data);
-  compiler->GenerateCall(token_pos,
-                         &StubCode::EqualityWithNullArgLabel(),
-                         PcDescriptors::kOther,
-                         locs);
-  __ Drop(2);
+  Label equality_done;
+  if (compiler->is_optimizing()) {
+    // No need to update IC data.
+    Label is_true;
+    __ popq(RAX);
+    __ popq(RDX);
+    __ cmpq(RAX, RDX);
+    __ j(EQUAL, &is_true);
+    __ LoadObject(RAX, (kind == Token::kEQ) ? compiler->bool_false()
+                                            : compiler->bool_true());
+    __ jmp(&equality_done);
+    __ Bind(&is_true);
+    __ LoadObject(RAX, (kind == Token::kEQ) ? compiler->bool_true()
+                                            : compiler->bool_false());
+    if (kind == Token::kNE) {
+      // Skip not-equal result conversion.
+      __ jmp(&equality_done);
+    }
+  } else {
+    // Call stub, load IC data in register. The stub will update ICData if
+    // necessary.
+    Register ic_data_reg = locs->temp(0).reg();
+    ASSERT(ic_data_reg == RBX);  // Stub depends on it.
+    __ LoadObject(ic_data_reg, equality_ic_data);
+    compiler->GenerateCall(token_pos,
+                           &StubCode::EqualityWithNullArgLabel(),
+                           PcDescriptors::kOther,
+                           locs);
+    __ Drop(2);
+  }
   __ Bind(&check_ne);
   if (kind == Token::kNE) {
     Label false_label, true_label, done;
     // 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);
   }
+  __ Bind(&equality_done);
 }
 
 
 static void EmitEqualityAsPolymorphicCall(FlowGraphCompiler* compiler,
                                           const ICData& orig_ic_data,
                                           LocationSummary* locs,
                                           BranchInstr* branch,
                                           Token::Kind kind,
                                           intptr_t deopt_id,
                                           intptr_t token_pos) {
@@ skipping 428 matching lines @@
   const String& function_name =
       String::ZoneHandle(Symbols::New(Token::Str(kind())));
   if (!compiler->is_optimizing()) {
     compiler->AddCurrentDescriptor(PcDescriptors::kDeoptBefore,
                                    deopt_id(),
                                    token_pos());
   }
   const intptr_t kNumArguments = 2;
   const intptr_t kNumArgsChecked = 2;  // Type-feedback.
   ICData& relational_ic_data = ICData::ZoneHandle(ic_data()->raw());
-  if (relational_ic_data.IsNull()) {
+  if (compiler->is_optimizing()) {
+    ASSERT(!ic_data()->IsNull());
+    relational_ic_data = ic_data()->AsUnaryClassChecks();
+  } else {
     relational_ic_data = ICData::New(compiler->parsed_function().function(),
                                      function_name,
                                      deopt_id(),
                                      kNumArgsChecked);
   }
   compiler->GenerateInstanceCall(deopt_id(),
                                  token_pos(),
                                  kNumArguments,
                                  Array::ZoneHandle(),  // No optional arguments.
                                  locs(),
@@ skipping 1449 matching lines @@
 
 void ShiftMintOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   UNIMPLEMENTED();
 }
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64