Separate branch on strict compare into a new IL instruction.

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 431 matching lines @@
 }
 
 
 // Emit code when ICData's targets are all Object == (which is ===).
 static void EmitCheckedStrictEqual(FlowGraphCompiler* compiler,
                                    const ICData& ic_data,
                                    const LocationSummary& locs,
                                    Token::Kind kind,
                                    BranchInstr* branch,
                                    intptr_t deopt_id,
-                                   intptr_t token_pos,
                                    intptr_t try_index) {
   ASSERT((kind == Token::kEQ) || (kind == Token::kNE));
   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);
   __ testq(left, Immediate(kSmiTagMask));
   __ j(ZERO, deopt);
@@ skipping 81 matching lines @@
                                 deopt_id, token_pos, try_index);
   __ Bind(&done);
 }
 
 
 static void EmitSmiComparisonOp(FlowGraphCompiler* compiler,
                                 const LocationSummary& locs,
                                 Token::Kind kind,
                                 BranchInstr* branch,
                                 intptr_t deopt_id,
-                                intptr_t token_pos,
                                 intptr_t try_index) {
   Register left = locs.in(0).reg();
   Register right = locs.in(1).reg();
   const bool left_is_smi = (branch == NULL) ?
       false : (branch->left()->ResultCid() == kSmiCid);
   const bool right_is_smi = (branch == NULL) ?
       false : (branch->right()->ResultCid() == kSmiCid);
   if (!left_is_smi || !right_is_smi) {
     Register temp = locs.temp(0).reg();
     Label* deopt = compiler->AddDeoptStub(deopt_id,
@@ skipping 36 matching lines @@
       return OVERFLOW;
   }
 }
 
 
 static void EmitDoubleComparisonOp(FlowGraphCompiler* compiler,
                                    const LocationSummary& locs,
                                    Token::Kind kind,
                                    BranchInstr* branch,
                                    intptr_t deopt_id,
-                                   intptr_t token_pos,
                                    intptr_t try_index) {
   Register left = locs.in(0).reg();
   Register right = locs.in(1).reg();
   // TODO(srdjan): temp is only needed if a conversion Smi->Double occurs.
   Register temp = locs.temp(0).reg();
   Label* deopt = compiler->AddDeoptStub(deopt_id,
                                         try_index,
                                         kDeoptDoubleComparison);
   compiler->LoadDoubleOrSmiToXmm(XMM0, left, temp, deopt);
   compiler->LoadDoubleOrSmiToXmm(XMM1, right, temp, deopt);
 
   Condition true_condition = TokenKindToDoubleCondition(kind);
   if (branch != NULL) {
     compiler->EmitDoubleCompareBranch(
         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());
+                        deopt_id(), 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());
+                           deopt_id(), 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());
+                           deopt_id(), try_index());
     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);
@@ skipping 27 matching lines @@
   locs->set_in(0, Location::RegisterLocation(RAX));
   locs->set_in(1, Location::RegisterLocation(RCX));
   locs->set_out(Location::RegisterLocation(RAX));
   return locs;
 }
 
 
 void RelationalOpComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   if (operands_class_id() == kSmiCid) {
     EmitSmiComparisonOp(compiler, *locs(), kind(), NULL,
-                        deopt_id(), token_pos(), try_index());
+                        deopt_id(), try_index());
     return;
   }
   if (operands_class_id() == kDoubleCid) {
     EmitDoubleComparisonOp(compiler, *locs(), kind(), NULL,
-                           deopt_id(), token_pos(), try_index());
+                           deopt_id(), try_index());
     return;
   }
 
   // Push arguments for the call.
   // TODO(fschneider): Split this instruction into different types to avoid
   // explicitly pushing arguments to the call here.
   Register left = locs()->in(0).reg();
   Register right = locs()->in(1).reg();
   __ pushq(left);
   __ pushq(right);
@@ skipping 1313 matching lines @@
 
 static bool IsCheckedStrictEquals(const ICData& ic_data, Token::Kind kind) {
   if ((kind == Token::kEQ) || (kind == Token::kNE)) {
     return ic_data.AllTargetsHaveSameOwner(kInstanceCid);
   }
   return false;
 }
 
 
 LocationSummary* BranchInstr::MakeLocationSummary() const {
-  if ((kind() == Token::kEQ_STRICT) || (kind() == Token::kNE_STRICT)) {
-    const int kNumInputs = 2;
-    const int kNumTemps = 0;
-    LocationSummary* locs =
-        new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
-    locs->set_in(0, Location::RequiresRegister());
-    locs->set_in(1, Location::RequiresRegister());
-    return locs;
-  }
   if (HasICData() && (ic_data()->NumberOfChecks() > 0)) {
     if (ICDataWithBothClassIds(*ic_data(), kSmiCid) ||
         ICDataWithBothClassIds(*ic_data(), kDoubleCid) ||
         IsCheckedStrictEquals(*ic_data(), kind())) {
       const intptr_t kNumInputs = 2;
       const intptr_t kNumTemps = 1;
       LocationSummary* summary =
           new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
       summary->set_in(0, Location::RequiresRegister());
       summary->set_in(1, Location::RequiresRegister());
@@ skipping 17 matching lines @@
   const intptr_t kNumTemps = 0;
   LocationSummary* locs =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   locs->set_in(0, Location::RegisterLocation(RAX));
   locs->set_in(1, Location::RegisterLocation(RCX));
   return locs;
 }
 
 
 void BranchInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  if ((kind() == Token::kEQ_STRICT) || (kind() == Token::kNE_STRICT)) {
-    Register left = locs()->in(0).reg();
-    Register right = locs()->in(1).reg();
-    __ cmpq(left, right);
-    Condition cond = (kind() == Token::kEQ_STRICT) ? EQUAL : NOT_EQUAL;
-    EmitBranchOnCondition(compiler, cond);
-    return;
-  }
   // Relational or equality.
   if (HasICData() && (ic_data()->NumberOfChecks() > 0)) {
     if (ICDataWithBothClassIds(*ic_data(), kSmiCid)) {
       EmitSmiComparisonOp(compiler, *locs(), kind(), this,
-                          deopt_id(), token_pos(), try_index());
+                          deopt_id(), try_index());
       return;
     }
     if (ICDataWithBothClassIds(*ic_data(), kDoubleCid)) {
       EmitDoubleComparisonOp(compiler, *locs(), kind(), this,
-                             deopt_id(), token_pos(), try_index());
+                             deopt_id(), try_index());
       return;
     }
     if (IsCheckedStrictEquals(*ic_data(), kind())) {
       EmitCheckedStrictEqual(compiler, *ic_data(), *locs(), kind(), this,
-                             deopt_id(), token_pos(), try_index());
+                             deopt_id(), try_index());
       return;
     }
     // TODO(srdjan): Add Smi/Double, Double/Smi comparisons.
     if ((kind() == Token::kEQ) || (kind() == Token::kNE)) {
       EmitGenericEqualityCompare(compiler, locs(), kind(), this, *ic_data(),
                                  deopt_id(), token_pos(), try_index());
       return;
     }
     // Otherwise polymorphic dispatch?
   }
@@ skipping 25 matching lines @@
                                    Array::ZoneHandle(),  // No optional args.
                                    kNumArgsChecked,
                                    locs());
   }
   Condition branch_condition = (kind() == Token::kNE) ? NOT_EQUAL : EQUAL;
   __ CompareObject(RAX, compiler->bool_true());
   EmitBranchOnCondition(compiler, branch_condition);
 }
 
 
+LocationSummary* StrictCompareAndBranchInstr::MakeLocationSummary() const {
+  const int kNumInputs = 2;
+  const int kNumTemps = 0;
+  LocationSummary* locs =
+      new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
+  locs->set_in(0, Location::RequiresRegister());
+  locs->set_in(1, Location::RequiresRegister());
+  return locs;
+}
+
+
+void StrictCompareAndBranchInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+  Register left = locs()->in(0).reg();
+  Register right = locs()->in(1).reg();
+  __ cmpq(left, right);
+  Condition cond = (kind() == Token::kEQ_STRICT) ? EQUAL : NOT_EQUAL;
+  EmitBranchOnCondition(compiler, cond);
+  return;
+}
+
+
 LocationSummary* CheckClassComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 1;
   LocationSummary* summary =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_in(0, Location::RequiresRegister());
   summary->set_temp(0, Location::RequiresRegister());
   return summary;
 }
 
@@ skipping 52 matching lines @@
   __ testq(value, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, deopt);
 }
 
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64