Improve equality operation (inline, direct calls).

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 172 matching lines @@
   // We should never return here.
   __ int3();
 
   __ Bind(&done);
   ASSERT(obj == result);
 }
 
 
 LocationSummary* EqualityCompareComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
-  if (operands_class_id() == kSmi) {
+  if ((NumTargets() == 1) && (ClassIdAt(0) == kSmi)) {
     const intptr_t kNumTemps = 1;
     LocationSummary* locs = new LocationSummary(kNumInputs, kNumTemps);
     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());
     }
     return locs;
   }
-  if (operands_class_id() == kObject) {
-    const intptr_t kNumTemps = 0;
+  if (NumTargets() > 0) {
+    const intptr_t kNumTemps = 1;
     LocationSummary* locs = new LocationSummary(kNumInputs, kNumTemps);
     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::RegisterLocation(EAX));
     }
     return locs;
   }
-  UNREACHABLE();
-  return NULL;
+  const intptr_t kNumTemps = 0;
+  LocationSummary* locs = new LocationSummary(kNumInputs, kNumTemps);
+  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;
 }
 
 
 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_index(),
@@ skipping 15 matching lines @@
     __ 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);
   }
 }
 
 
+static void EmitEqualityAsInstanceCall(FlowGraphCompiler* compiler,
+                                       EqualityCompareComp* comp) {
+  compiler->AddCurrentDescriptor(PcDescriptors::kDeopt,
+                                 comp->cid(),
+                                 comp->token_index(),
+                                 comp->try_index());
+  const String& operator_name = String::ZoneHandle(String::NewSymbol("=="));
+  const int kNumberOfArguments = 2;
+  const Array& kNoArgumentNames = Array::Handle();
+  const int kNumArgumentsChecked = 2;
+
+  compiler->GenerateInstanceCall(comp->cid(),
+                                 comp->token_index(),
+                                 comp->try_index(),
+                                 operator_name,
+                                 kNumberOfArguments,
+                                 kNoArgumentNames,
+                                 kNumArgumentsChecked);
+  ASSERT(comp->is_fused_with_branch() || (comp->locs()->out().reg() == EAX));
+
+  if (comp->is_fused_with_branch()) {
+    __ CompareObject(EAX, compiler->bool_true());
+    comp->fused_with_branch()->EmitBranchOnCondition(compiler, EQUAL);
+  }
+}
+
+
+static void EmitEqualityAsPolymorphicCall(FlowGraphCompiler* compiler,
+                                          EqualityCompareComp* comp,
+                                          Register left,
+                                          Register right) {
+  ASSERT(comp->NumTargets() > 0);
+  Label* deopt = compiler->AddDeoptStub(comp->cid(),
+                                        comp->token_index(),
+                                        comp->try_index(),
+                                        kDeoptEquality);
+  __ testl(left, Immediate(kSmiTagMask));
+  Register temp = comp->locs()->temp(0).reg();
+  if (comp->ClassIdAt(0) == kSmi) {
+    Label done, load_class_id;
+    __ j(NOT_ZERO, &load_class_id, Assembler::kNearJump);
+    __ movl(temp, Immediate(kSmi));
+    __ jmp(&done, Assembler::kNearJump);
+    __ Bind(&load_class_id);
+    __ LoadClassId(temp, left);
+    __ Bind(&done);
+  } else {
+    __ j(ZERO, deopt);  // Smi deopts.
+    __ LoadClassId(temp, left);
+  }
+  Label done;
+  for (intptr_t i = 0; i < comp->NumTargets(); i++) {
+    ASSERT((comp->ClassIdAt(i) != kSmi) || (i == 0));
+    Label next_test;
+    __ cmpl(temp, Immediate(comp->ClassIdAt(i)));
+    __ j(NOT_EQUAL, &next_test, Assembler::kNearJump);
+    const Function& target = *comp->TargetAt(i);
+    ObjectStore* object_store = Isolate::Current()->object_store();
+    if (target.owner() == object_store->object_class()) {
+      // Object.== is same as ===.
+      __ Drop(2);
+      __ cmpl(left, right);
+      if (comp->is_fused_with_branch()) {
+        comp->fused_with_branch()->EmitBranchOnCondition(compiler, EQUAL);
+      } else {
+        // This case should be rare.
+        Register result = comp->locs()->out().reg();
+        Label load_true;
+        __ j(EQUAL, &load_true, Assembler::kNearJump);
+        __ LoadObject(result, compiler->bool_false());
+        __ jmp(&done);
+        __ Bind(&load_true);
+        __ LoadObject(result, compiler->bool_true());
+      }
+    } else {
+      const int kNumberOfArguments = 2;
+      const Array& kNoArgumentNames = Array::Handle();
+      compiler->GenerateStaticCall(comp->cid(),
+                                   comp->token_index(),
+                                   comp->try_index(),
+                                   target,
+                                   kNumberOfArguments,
+                                   kNoArgumentNames);
+      ASSERT(comp->is_fused_with_branch() ||
+            (comp->locs()->out().reg() == EAX));
+      if (comp->is_fused_with_branch()) {
+        __ CompareObject(EAX, compiler->bool_true());
+        comp->fused_with_branch()->EmitBranchOnCondition(compiler, EQUAL);
+      }
+    }
+    __ jmp(&done);
+    __ Bind(&next_test);
+  }
+  // Fall through leads to deoptimization
+  __ jmp(deopt);
+  __ Bind(&done);
+}
+
+
+// First test if receiver is NULL, in which case === is applied.
+// If type feedback was provided (lists of <class-id, target>), do a
+// type by type check (either === or static call to the operator.
 static void EmitGenericEqualityCompare(FlowGraphCompiler* compiler,
                                        EqualityCompareComp* comp) {
   Register left = comp->locs()->in(0).reg();
   Register right = comp->locs()->in(1).reg();
   const Immediate raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   Label done, non_null_compare;
   __ cmpl(left, raw_null);
   __ j(NOT_EQUAL, &non_null_compare, Assembler::kNearJump);
   // Comparison with NULL is "===".
   __ 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;
     __ j(EQUAL, &load_true, Assembler::kNearJump);
     __ LoadObject(result, compiler->bool_false());
-    __ jmp(&done, Assembler::kNearJump);
+    __ jmp(&done);
     __ Bind(&load_true);
     __ LoadObject(result, compiler->bool_true());
   }
   __ jmp(&done);
 
-  __ Bind(&non_null_compare);
+  __ Bind(&non_null_compare);  // Receiver is not null.
   __ pushl(left);
   __ pushl(right);
-  compiler->AddCurrentDescriptor(PcDescriptors::kDeopt,
-                                 comp->cid(),
-                                 comp->token_index(),
-                                 comp->try_index());
-  const String& operator_name = String::ZoneHandle(String::NewSymbol("=="));
-  const int kNumberOfArguments = 2;
-  const Array& kNoArgumentNames = Array::Handle();
-  const int kNumArgumentsChecked = 2;
-
-  compiler->GenerateInstanceCall(comp->cid(),
-                                 comp->token_index(),
-                                 comp->try_index(),
-                                 operator_name,
-                                 kNumberOfArguments,
-                                 kNoArgumentNames,
-                                 kNumArgumentsChecked);
-  ASSERT(comp->is_fused_with_branch() || (comp->locs()->out().reg() == EAX));
-
-  if (comp->is_fused_with_branch()) {
-    __ CompareObject(EAX, compiler->bool_true());
-    comp->fused_with_branch()->EmitBranchOnCondition(compiler, EQUAL);
+  if (comp->NumTargets() > 0) {
+    EmitEqualityAsPolymorphicCall(compiler, comp, left, right);
+  } else {
+    EmitEqualityAsInstanceCall(compiler, comp);
   }
   __ Bind(&done);
 }
 
 
 void EqualityCompareComp::EmitNativeCode(FlowGraphCompiler* compiler) {
-  if (operands_class_id() == kSmi) {
+  if ((NumTargets() == 1) && (ClassIdAt(0) == kSmi)) {
     EmitSmiEqualityCompare(compiler, this);
     return;
   }
-  if (operands_class_id() == kObject) {
-    EmitGenericEqualityCompare(compiler, this);
-    return;
-  }
-  UNREACHABLE();
+  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);
     summary->set_in(0, Location::RequiresRegister());
     summary->set_in(1, Location::RequiresRegister());
@@ skipping 1308 matching lines @@
   }
   __ Bind(&done);
 }
 
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64