Move deopt reason into PcDescriptor so the EAX/RAX register is not destroyed. Some cleanups in PC d…

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 308 matching lines @@
                                           const 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,
-                                        token_pos,
-                                        try_index,
-                                        kDeoptEquality);
+  Label* deopt = compiler->AddDeoptStub(deopt_id, try_index, 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 110 matching lines @@
                                 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();
   Register temp = locs.temp(0).reg();
   Label* deopt = compiler->AddDeoptStub(deopt_id,
-                                        token_pos,
                                         try_index,
                                         kDeoptSmiCompareSmi,
                                         left,
                                         right);
   __ movq(temp, left);
   __ orq(temp, right);
   __ testq(temp, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, deopt);
 
   Condition true_condition = TokenKindToSmiCondition(kind);
@@ skipping 34 matching lines @@
                                    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,
-                                        token_pos,
                                         try_index,
                                         kDeoptDoubleComparison,
                                         left,
                                         right);
   compiler->LoadDoubleOrSmiToXmm(XMM0, left, temp, deopt);
   compiler->LoadDoubleOrSmiToXmm(XMM1, right, temp, deopt);
 
   Condition true_condition = TokenKindToDoubleCondition(kind);
   if (branch != NULL) {
     compiler->EmitDoubleCompareBranch(
@@ skipping 52 matching lines @@
                         deopt_id(), token_pos(), try_index());
     return;
   }
   if (operands_class_id() == kDoubleCid) {
     EmitDoubleComparisonOp(compiler, *locs(), kind(), NULL,
                            deopt_id(), token_pos(), try_index());
     return;
   }
   if (HasICData() && (ic_data()->NumberOfChecks() > 0)) {
     Label* deopt = compiler->AddDeoptStub(deopt_id(),
-                                          token_pos(),
                                           try_index(),
                                           kDeoptRelationalOp);
     // Load receiver into RAX, class into RDI.
     Label done;
     const intptr_t kNumArguments = 2;
     __ movq(RDI, Immediate(kSmiCid));
     __ movq(RAX, Address(RSP, (kNumArguments - 1) * kWordSize));
     __ testq(RAX, Immediate(kSmiTagMask));
     __ j(ZERO, &done);
     __ LoadClassId(RDI, RAX);
@@ skipping 89 matching lines @@
   } else {
     ASSERT(receiver_type() == kIllegalCid);
     return MakeCallSummary();
   }
 }
 
 
 static void EmitLoadIndexedPolymorphic(FlowGraphCompiler* compiler,
                                         LoadIndexedComp* comp) {
   Label* deopt = compiler->AddDeoptStub(comp->deopt_id(),
-                                        comp->token_pos(),
                                         comp->try_index(),
                                         kDeoptLoadIndexedPolymorphic);
   ASSERT(comp->ic_data()->NumberOfChecks() > 0);
   ASSERT(comp->HasICData());
   const ICData& ic_data = *comp->ic_data();
   ASSERT(ic_data.num_args_tested() == 1);
   // No indexed access on Smi.
   ASSERT(ic_data.GetReceiverClassIdAt(0) != kSmiCid);
   // Load receiver into RAX.
   const intptr_t kNumArguments = 2;
@@ skipping 26 matching lines @@
 
   Register receiver = locs()->in(0).reg();
   Register index = locs()->in(1).reg();
   Register result = locs()->out().reg();
 
   const DeoptReasonId deopt_reason =
       (receiver_type() == kGrowableObjectArrayCid) ?
       kDeoptLoadIndexedGrowableArray : kDeoptLoadIndexedFixedArray;
 
   Label* deopt = compiler->AddDeoptStub(deopt_id(),
-                                        token_pos(),
                                         try_index(),
                                         deopt_reason,
                                         receiver,
                                         index);
 
   __ testq(receiver, Immediate(kSmiTagMask));  // Deoptimize if Smi.
   __ j(ZERO, deopt);
   __ CompareClassId(receiver, receiver_type());
   __ j(NOT_EQUAL, deopt);
 
@@ skipping 71 matching lines @@
                                  function_name,
                                  kNumArguments,
                                  Array::ZoneHandle(),  // No named arguments.
                                  kNumArgsChecked);
 }
 
 
 static void EmitStoreIndexedPolymorphic(FlowGraphCompiler* compiler,
                                         StoreIndexedComp* comp) {
   Label* deopt = compiler->AddDeoptStub(comp->deopt_id(),
-                                        comp->token_pos(),
                                         comp->try_index(),
                                         kDeoptStoreIndexedPolymorphic);
   ASSERT(comp->ic_data()->NumberOfChecks() > 0);
   ASSERT(comp->HasICData());
   const ICData& ic_data = *comp->ic_data();
   ASSERT(ic_data.num_args_tested() == 1);
   // No indexed access on Smi.
   ASSERT(ic_data.GetReceiverClassIdAt(0) != kSmiCid);
   // Load receiver into RAX.
   const intptr_t kNumArguments = 3;
@@ skipping 21 matching lines @@
       EmitStoreIndexedGeneric(compiler, this);
     }
     return;
   }
 
   Register receiver = locs()->in(0).reg();
   Register index = locs()->in(1).reg();
   Register value = locs()->in(2).reg();
 
   Label* deopt = compiler->AddDeoptStub(deopt_id(),
-                                        token_pos(),
                                         try_index(),
                                         kDeoptStoreIndexed,
                                         receiver,
                                         index,
                                         value);
 
   __ testq(receiver, Immediate(kSmiTagMask));  // Deoptimize if Smi.
   __ j(ZERO, deopt);
   __ CompareClassId(receiver, receiver_type());
   __ j(NOT_EQUAL, deopt);
@@ skipping 45 matching lines @@
 }
 
 
 void LoadInstanceFieldComp::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()->token_pos(),
                                           original()->try_index(),
                                           kDeoptInstanceGetterSameTarget,
                                           instance_reg);
     // 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, field().Offset()));
@@ skipping 112 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()->token_pos(),
                                           original()->try_index(),
                                           kDeoptInstanceGetterSameTarget,
                                           instance_reg);
     // 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);
   }
 
@@ skipping 353 matching lines @@
 }
 
 
 static void EmitSmiBinaryOp(FlowGraphCompiler* compiler, BinaryOpComp* comp) {
   Register left = comp->locs()->in(0).reg();
   Register right = comp->locs()->in(1).reg();
   Register result = comp->locs()->out().reg();
   Register temp = comp->locs()->temp(0).reg();
   ASSERT(left == result);
   Label* deopt = compiler->AddDeoptStub(comp->instance_call()->deopt_id(),
-                                        comp->instance_call()->token_pos(),
                                         comp->instance_call()->try_index(),
                                         kDeoptSmiBinaryOp,
                                         temp,
                                         right);
   // TODO(vegorov): for many binary operations this pattern can be rearranged
   // to save one move.
   __ movq(temp, left);
   __ orq(left, right);
   __ testq(left, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, deopt);
@@ skipping 136 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 = comp->locs()->in(0).reg();
   Register right = comp->locs()->in(1).reg();
   Register result = comp->locs()->out().reg();
   ASSERT(left == result);
   ASSERT(comp->op_kind() == Token::kBIT_AND);
   Label* deopt = compiler->AddDeoptStub(comp->instance_call()->deopt_id(),
-                                        comp->instance_call()->token_pos(),
                                         comp->instance_call()->try_index(),
                                         kDeoptMintBinaryOp,
                                         left,
                                         right);
   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?
@@ skipping 100 matching lines @@
   compiler->GenerateCall(instance_call()->token_pos(),
                          instance_call()->try_index(),
                          &label,
                          PcDescriptors::kOther);
   // Newly allocated object is now in the result register (RAX).
   ASSERT(result == RAX);
   __ popq(right);
   __ popq(left);
 
   Label* deopt = compiler->AddDeoptStub(instance_call()->deopt_id(),
-                                        instance_call()->token_pos(),
                                         instance_call()->try_index(),
                                         kDeoptDoubleBinaryOp,
                                         left,
                                         right);
 
   // 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);
@@ skipping 31 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()->token_pos(),
                                         instance_call()->try_index(),
                                         kDeoptUnaryOp,
                                         value);
   if (test_class_id == kSmiCid) {
     __ testq(value, Immediate(kSmiTagMask));
     __ j(NOT_ZERO, deopt);
     switch (op_kind()) {
       case Token::kNEGATE:
         __ negq(value);
         __ j(OVERFLOW, deopt);
@@ skipping 31 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()->token_pos(),
                                         instance_call()->try_index(),
                                         kDeoptUnaryOp,
                                         value);
   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.
@@ skipping 35 matching lines @@
 }
 
 
 void ToDoubleComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register value = (from() == kDoubleCid) ? locs()->in(0).reg() : RBX;
   Register result = locs()->out().reg();
 
   const DeoptReasonId deopt_reason = (from() == kDoubleCid) ?
       kDeoptDoubleToDouble : kDeoptIntegerToDouble;
   Label* deopt = compiler->AddDeoptStub(instance_call()->deopt_id(),
-                                        instance_call()->token_pos(),
                                         instance_call()->try_index(),
                                         deopt_reason,
                                         value);
 
   if (from() == kDoubleCid) {
     __ testq(value, Immediate(kSmiTagMask));
     __ j(ZERO, deopt);  // Deoptimize if Smi.
     __ CompareClassId(value, kDoubleCid);
     __ j(NOT_EQUAL, deopt);  // Deoptimize if not Double.
     ASSERT(value == result);
@@ skipping 23 matching lines @@
 }
 
 
 LocationSummary* PolymorphicInstanceCallComp::MakeLocationSummary() const {
   return MakeCallSummary();
 }
 
 
 void PolymorphicInstanceCallComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Label* deopt = compiler->AddDeoptStub(instance_call()->deopt_id(),
-                                        instance_call()->token_pos(),
                                         instance_call()->try_index(),
                                         kDeoptPolymorphicInstanceCallTestFail);
   if (!HasICData() || (ic_data()->NumberOfChecks() == 0)) {
     __ jmp(deopt);
     return;
   }
   ASSERT(HasICData());
   ASSERT(ic_data()->num_args_tested() == 1);
   Label handle_smi;
   Label* is_smi_label =
@@ skipping 130 matching lines @@
   ASSERT(locs()->out().reg() == RAX);
   __ CompareObject(locs()->out().reg(), compiler->bool_true());
   EmitBranchOnCondition(compiler, branch_condition);
 }
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64