Eliminate try-index for deopt stubs.

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 345 matching lines @@
                                           LocationSummary* locs,
                                           BranchInstr* branch,
                                           Token::Kind kind,
                                           intptr_t deopt_id,
                                           intptr_t token_pos,
                                           intptr_t try_index) {
   ASSERT((kind == Token::kEQ) || (kind == Token::kNE));
   const ICData& ic_data = ICData::Handle(orig_ic_data.AsUnaryClassChecks());
   ASSERT(ic_data.NumberOfChecks() > 0);
   ASSERT(ic_data.num_args_tested() == 1);
-  Label* deopt = compiler->AddDeoptStub(deopt_id, try_index, kDeoptEquality);
+  Label* deopt = compiler->AddDeoptStub(deopt_id, kDeoptEquality);
   Register left = locs->in(0).reg();
   Register right = locs->in(1).reg();
   __ testq(left, Immediate(kSmiTagMask));
   Register temp = locs->temp(0).reg();
   if (ic_data.GetReceiverClassIdAt(0) == kSmiCid) {
     Label done, load_class_id;
     __ j(NOT_ZERO, &load_class_id, Assembler::kNearJump);
     __ movq(temp, Immediate(kSmiCid));
     __ jmp(&done, Assembler::kNearJump);
     __ Bind(&load_class_id);
@@ skipping 64 matching lines @@
   __ Bind(&done);
 }
 
 
 // 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 try_index) {
+                                   intptr_t deopt_id) {
   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);
+  Label* deopt = compiler->AddDeoptStub(deopt_id, kDeoptEquality);
   __ testq(left, Immediate(kSmiTagMask));
   __ j(ZERO, deopt);
   // 'left' is not Smi.
   const Immediate raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   Label identity_compare;
   __ cmpq(right, raw_null);
   __ j(EQUAL, &identity_compare);
   __ cmpq(left, raw_null);
   __ j(EQUAL, &identity_compare);
@@ skipping 72 matching lines @@
   EmitEqualityAsPolymorphicCall(compiler, ic_data, locs, branch, kind,
                                 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 try_index) {
+                                intptr_t deopt_id) {
   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,
-                                          try_index,
-                                          kDeoptSmiCompareSmi);
+    Label* deopt = compiler->AddDeoptStub(deopt_id, kDeoptSmiCompareSmi);
     __ movq(temp, left);
     __ orq(temp, right);
     __ testq(temp, Immediate(kSmiTagMask));
     __ j(NOT_ZERO, deopt);
   }
 
   Condition true_condition = TokenKindToSmiCondition(kind);
   __ cmpq(left, right);
 
   if (branch != NULL) {
@@ skipping 23 matching lines @@
       UNREACHABLE();
       return OVERFLOW;
   }
 }
 
 
 static void EmitDoubleComparisonOp(FlowGraphCompiler* compiler,
                                    const LocationSummary& locs,
                                    Token::Kind kind,
                                    BranchInstr* branch,
-                                   intptr_t deopt_id,
-                                   intptr_t try_index) {
+                                   intptr_t deopt_id) {
   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);
+  Label* deopt = compiler->AddDeoptStub(deopt_id, 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) {
+  BranchInstr* kNoBranch = NULL;
   if (receiver_class_id() == kSmiCid) {
     // Deoptimizes if both arguments not Smi.
-    EmitSmiComparisonOp(compiler, *locs(), kind(), NULL,  // No branch.
-                        deopt_id(), try_index());
+    EmitSmiComparisonOp(compiler, *locs(), kind(), kNoBranch, deopt_id());
     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(), try_index());
+    EmitDoubleComparisonOp(compiler, *locs(), kind(), kNoBranch, deopt_id());
     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(), try_index());
+    EmitCheckedStrictEqual(compiler, *ic_data(), *locs(), kind(), kNoBranch,
+                           deopt_id());
     return;
   }
   if (HasICData() && (ic_data()->NumberOfChecks() > 0)) {
-    EmitGenericEqualityCompare(compiler, locs(), kind(), NULL, *ic_data(),
+    EmitGenericEqualityCompare(compiler, locs(), kind(), kNoBranch, *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,
                                deopt_id(),
                                token_pos(),
                                try_index(),
@@ skipping 22 matching lines @@
   // Pick arbitrary fixed input registers because this is a call.
   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(), try_index());
+    EmitSmiComparisonOp(compiler, *locs(), kind(), NULL, deopt_id());
     return;
   }
   if (operands_class_id() == kDoubleCid) {
-    EmitDoubleComparisonOp(compiler, *locs(), kind(), NULL,
-                           deopt_id(), try_index());
+    EmitDoubleComparisonOp(compiler, *locs(), kind(), NULL, deopt_id());
     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);
   if (HasICData() && (ic_data()->NumberOfChecks() > 0)) {
-    Label* deopt = compiler->AddDeoptStub(deopt_id(),
-                                          try_index(),
-                                          kDeoptRelationalOp);
+    Label* deopt = compiler->AddDeoptStub(deopt_id(), kDeoptRelationalOp);
 
     // Load class into RDI. Since this is a call, any register except
     // the fixed input registers would be ok.
     ASSERT((left != RDI) && (right != RDI));
     Label done;
     __ movq(RDI, Immediate(kSmiCid));
     __ testq(left, Immediate(kSmiTagMask));
     __ j(ZERO, &done);
     __ LoadClassId(RDI, left);
     __ Bind(&done);
@@ skipping 369 matching lines @@
                                LocationSummary::kNoCall);
 }
 
 
 void LoadVMFieldComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register instance_reg = locs()->in(0).reg();
   Register result_reg = locs()->out().reg();
   if (HasICData()) {
     ASSERT(original() != NULL);
     Label* deopt = compiler->AddDeoptStub(original()->deopt_id(),
-                                          original()->try_index(),
                                           kDeoptInstanceGetterSameTarget);
     // Smis do not have instance fields (Smi class is always first).
     // Use 'result' as temporary register.
     ASSERT(result_reg != instance_reg);
     ASSERT(ic_data() != NULL);
     compiler->EmitClassChecksNoSmi(*ic_data(), instance_reg, result_reg, deopt);
   }
 
   __ movq(result_reg, FieldAddress(instance_reg, offset_in_bytes()));
 }
@@ skipping 361 matching lines @@
   ASSERT(left == result);
   Label* deopt = NULL;
   switch (op_kind()) {
     case Token::kBIT_AND:
     case Token::kBIT_OR:
     case Token::kBIT_XOR:
       // Can't deoptimize. Arguments are already checked for smi.
       break;
     default:
       deopt = compiler->AddDeoptStub(instance_call()->deopt_id(),
-                                     instance_call()->try_index(),
                                      kDeoptBinarySmiOp);
   }
   switch (op_kind()) {
     case Token::kADD: {
       __ addq(left, right);
       __ j(OVERFLOW, deopt);
       break;
     }
     case Token::kSUB: {
       __ subq(left, right);
@@ skipping 145 matching lines @@
   // TODO(regis): For now, we only support Token::kBIT_AND for a Mint or Smi
   // receiver and a Mint or Smi argument. We fall back to the run time call if
   // both receiver and argument are Mint or if one of them is Mint and the other
   // is a negative Smi.
   Register left = locs()->in(0).reg();
   Register right = locs()->in(1).reg();
   Register result = locs()->out().reg();
   ASSERT(left == result);
   ASSERT(op_kind() == Token::kBIT_AND);
   Label* deopt = compiler->AddDeoptStub(instance_call()->deopt_id(),
-                                        instance_call()->try_index(),
                                         kDeoptBinaryMintOp);
   Label mint_static_call, smi_static_call, non_smi, smi_smi, done;
   __ testq(left, Immediate(kSmiTagMask));  // Is receiver Smi?
   __ j(NOT_ZERO, &non_smi);
   __ testq(right, Immediate(kSmiTagMask));  // Is argument Smi?
   __ j(ZERO, &smi_smi);
   __ CompareClassId(right, kMintCid);  // Is argument Mint?
   __ j(NOT_EQUAL, deopt);  // Argument neither Smi nor Mint.
   __ cmpq(left, Immediate(0));
   __ j(LESS, &smi_static_call);  // Negative Smi receiver, Mint argument.
@@ skipping 86 matching lines @@
                          instance_call()->try_index(),
                          &label,
                          PcDescriptors::kOther,
                          locs());
   // Newly allocated object is now in the result register (RAX).
   ASSERT(result == RAX);
   __ movq(right, Address(RSP, 0));
   __ movq(left, Address(RSP, kWordSize));
 
   Label* deopt = compiler->AddDeoptStub(instance_call()->deopt_id(),
-                                        instance_call()->try_index(),
                                         kDeoptBinaryDoubleOp);
 
   // Binary operation of two Smi's produces a Smi not a double.
   __ movq(temp, left);
   __ orq(temp, right);
   __ testq(temp, Immediate(kSmiTagMask));
   __ j(ZERO, deopt);
 
   compiler->LoadDoubleOrSmiToXmm(XMM0, left, temp, deopt);
   compiler->LoadDoubleOrSmiToXmm(XMM1, right, temp, deopt);
@@ skipping 21 matching lines @@
     new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_in(0, Location::RequiresRegister());
   summary->set_in(1, Location::RequiresRegister());
   summary->set_temp(0, Location::RequiresRegister());
   return summary;
 }
 
 
 void CheckEitherNonSmiComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Label* deopt = compiler->AddDeoptStub(instance_call_->deopt_id(),
-                                        instance_call_->try_index(),
                                         kDeoptBinaryDoubleOp);
 
   Register temp = locs()->temp(0).reg();
   __ movq(temp, locs()->in(0).reg());
   __ orq(temp, locs()->in(1).reg());
   __ testl(temp, Immediate(kSmiTagMask));
   __ j(ZERO, deopt);
 }
 
 
@@ skipping 75 matching lines @@
 }
 
 
 void UnboxDoubleComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   const intptr_t v_cid = value()->ResultCid();
 
   const Register value = locs()->in(0).reg();
   const XmmRegister result = locs()->out().xmm_reg();
   if (v_cid != kDoubleCid) {
     Label* deopt = compiler->AddDeoptStub(instance_call()->deopt_id(),
-                                          instance_call()->try_index(),
                                           kDeoptBinaryDoubleOp);
     compiler->LoadDoubleOrSmiToXmm(result,
                                    value,
                                    locs()->temp(0).reg(),
                                    deopt);
   } else {
     __ movsd(result, FieldAddress(value, Double::value_offset()));
   }
 }
 
@@ skipping 36 matching lines @@
   return summary;
 }
 
 
 void UnarySmiOpComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register value = locs()->in(0).reg();
   ASSERT(value == locs()->out().reg());
   switch (op_kind()) {
     case Token::kNEGATE: {
       Label* deopt = compiler->AddDeoptStub(instance_call()->deopt_id(),
-                                            instance_call()->try_index(),
                                             kDeoptUnaryOp);
       __ negq(value);
       __ j(OVERFLOW, deopt);
       break;
     }
     case Token::kBIT_NOT:
       __ notq(value);
       __ andq(value, Immediate(~kSmiTagMask));  // Remove inverted smi-tag.
       break;
     default:
@@ skipping 22 matching lines @@
   // TODO(srdjan): Implement for more checks.
   ASSERT(ic_data.NumberOfChecks() == 1);
   intptr_t test_class_id;
   Function& target = Function::Handle();
   ic_data.GetOneClassCheckAt(0, &test_class_id, &target);
 
   Register value = locs()->in(0).reg();
   Register result = locs()->out().reg();
   ASSERT(value == result);
   Label* deopt = compiler->AddDeoptStub(instance_call()->deopt_id(),
-                                        instance_call()->try_index(),
                                         kDeoptUnaryOp);
   if (test_class_id == kDoubleCid) {
     Register temp = locs()->temp(0).reg();
     __ testq(value, Immediate(kSmiTagMask));
     __ j(ZERO, deopt);  // Smi.
     __ CompareClassId(value, kDoubleCid);
     __ j(NOT_EQUAL, deopt);
     // Allocate result object.
     const Class& double_class = compiler->double_class();
     const Code& stub =
@@ skipping 28 matching lines @@
   locs->set_out(Location::SameAsFirstInput());
   return locs;
 }
 
 
 void DoubleToDoubleComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register value = locs()->in(0).reg();
   Register result = locs()->out().reg();
 
   Label* deopt = compiler->AddDeoptStub(instance_call()->deopt_id(),
-                                        instance_call()->try_index(),
                                         kDeoptDoubleToDouble);
 
   __ testq(value, Immediate(kSmiTagMask));
   __ j(ZERO, deopt);  // Deoptimize if Smi.
   __ CompareClassId(value, kDoubleCid);
   __ j(NOT_EQUAL, deopt);  // Deoptimize if not Double.
   ASSERT(value == result);
 }
 
 
 LocationSummary* SmiToDoubleComp::MakeLocationSummary() const {
   return MakeCallSummary();  // Calls a stub to allocate result.
 }
 
 
 void SmiToDoubleComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register result = locs()->out().reg();
 
   Label* deopt = compiler->AddDeoptStub(instance_call()->deopt_id(),
-                                        instance_call()->try_index(),
                                         kDeoptIntegerToDouble);
 
   const Class& double_class = compiler->double_class();
   const Code& stub =
     Code::Handle(StubCode::GetAllocationStubForClass(double_class));
   const ExternalLabel label(double_class.ToCString(), stub.EntryPoint());
 
   // TODO(fschneider): Inline new-space allocation and move the call into
   // deferred code.
   compiler->GenerateCall(instance_call()->token_pos(),
@@ skipping 15 matching lines @@
 }
 
 
 LocationSummary* PolymorphicInstanceCallComp::MakeLocationSummary() const {
   return MakeCallSummary();
 }
 
 
 void PolymorphicInstanceCallComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Label* deopt = compiler->AddDeoptStub(instance_call()->deopt_id(),
-                                        instance_call()->try_index(),
                                         kDeoptPolymorphicInstanceCallTestFail);
   if (!HasICData() || (ic_data()->NumberOfChecks() == 0)) {
     __ jmp(deopt);
     return;
   }
   ASSERT(HasICData());
   ASSERT(ic_data()->num_args_tested() == 1);
   if (!with_checks()) {
     const Function& target = Function::ZoneHandle(ic_data()->GetTargetAt(0));
     compiler->GenerateStaticCall(instance_call()->deopt_id(),
@@ skipping 80 matching lines @@
   locs->set_in(0, Location::RegisterLocation(RAX));
   locs->set_in(1, Location::RegisterLocation(RCX));
   return locs;
 }
 
 
 void BranchInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   // Relational or equality.
   if (HasICData() && (ic_data()->NumberOfChecks() > 0)) {
     if (ICDataWithBothClassIds(*ic_data(), kSmiCid)) {
-      EmitSmiComparisonOp(compiler, *locs(), kind(), this,
-                          deopt_id(), try_index());
+      EmitSmiComparisonOp(compiler, *locs(), kind(), this, deopt_id());
       return;
     }
     if (ICDataWithBothClassIds(*ic_data(), kDoubleCid)) {
-      EmitDoubleComparisonOp(compiler, *locs(), kind(), this,
-                             deopt_id(), try_index());
+      EmitDoubleComparisonOp(compiler, *locs(), kind(), this, deopt_id());
       return;
     }
     if (IsCheckedStrictEquals(*ic_data(), kind())) {
       EmitCheckedStrictEqual(compiler, *ic_data(), *locs(), kind(), this,
-                             deopt_id(), try_index());
+                             deopt_id());
       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 60 matching lines @@
   summary->set_in(0, Location::RequiresRegister());
   summary->set_temp(0, Location::RequiresRegister());
   return summary;
 }
 
 
 void CheckClassComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register value = locs()->in(0).reg();
   Register temp = locs()->temp(0).reg();
   Label* deopt = compiler->AddDeoptStub(deopt_id(),
-                                        try_index(),
                                         kDeoptCheckClass);
   ASSERT(ic_data()->GetReceiverClassIdAt(0) != kSmiCid);
   __ testq(value, Immediate(kSmiTagMask));
   __ j(ZERO, deopt);
   __ LoadClassId(temp, value);
   Label is_ok;
   const intptr_t num_checks = ic_data()->NumberOfChecks();
   const bool use_near_jump = num_checks < 5;
   for (intptr_t i = 0; i < num_checks; i++) {
     __ cmpl(temp, Immediate(ic_data()->GetReceiverClassIdAt(i)));
@@ skipping 17 matching lines @@
   LocationSummary* summary =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_in(0, Location::RequiresRegister());
   return summary;
 }
 
 
 void CheckSmiComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register value = locs()->in(0).reg();
   Label* deopt = compiler->AddDeoptStub(deopt_id(),
-                                        try_index(),
                                         kDeoptCheckSmi);
   __ testq(value, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, deopt);
 }
 
 
 LocationSummary* CheckArrayBoundComp::MakeLocationSummary() const {
   return LocationSummary::Make(2,
                                Location::NoLocation(),
                                LocationSummary::kNoCall);
 }
 
 
 void CheckArrayBoundComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register receiver = locs()->in(0).reg();
   Register index = locs()->in(1).reg();
 
   const DeoptReasonId deopt_reason =
       (array_type() == kGrowableObjectArrayCid) ?
       kDeoptLoadIndexedGrowableArray : kDeoptLoadIndexedFixedArray;
   Label* deopt = compiler->AddDeoptStub(deopt_id(),
-                                        try_index(),
                                         deopt_reason);
   switch (array_type()) {
     case kArrayCid:
     case kImmutableArrayCid:
       __ cmpq(index, FieldAddress(receiver, Array::length_offset()));
       break;
     case kGrowableObjectArrayCid:
       __ cmpq(index,
               FieldAddress(receiver, GrowableObjectArray::length_offset()));
       break;
   }
   __ j(ABOVE_EQUAL, deopt);
 }
 
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64