Get rid of ast node ids.

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 70 matching lines @@
       __ Bind(&not_yet_hot);
       __ Bind(&already_optimized);
     }
   }
   if (FLAG_trace_functions) {
     const Function& function =
         Function::ZoneHandle(compiler->parsed_function().function().raw());
     __ LoadObject(temp, function);
     __ pushq(result);  // Preserve result.
     __ pushq(temp);
-    compiler->GenerateCallRuntime(AstNode::kNoId,
+    compiler->GenerateCallRuntime(Isolate::kNoDeoptId,
                                   0,
                                   CatchClauseNode::kInvalidTryIndex,
                                   kTraceFunctionExitRuntimeEntry);
     __ popq(temp);  // Remove argument.
     __ popq(result);  // Restore result.
   }
   __ LeaveFrame();
   __ ret();
 
   // Generate 8 bytes of NOPs so that the debugger can patch the
   // return pattern with a call to the debug stub.
   // Note that the nop(8) byte pattern is not recognized by the debugger.
   __ nop(1);
   __ nop(1);
   __ nop(1);
   __ nop(1);
   __ nop(1);
   __ nop(1);
   __ nop(1);
   __ nop(1);
   compiler->AddCurrentDescriptor(PcDescriptors::kReturn,
-                                 cid(),
+                                 deopt_id(),
                                  token_pos(),
                                  CatchClauseNode::kInvalidTryIndex);
 }
 
 
 LocationSummary* ClosureCallComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 0;
   const intptr_t kNumTemps = 1;
   LocationSummary* result =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
@@ skipping 74 matching lines @@
 
   // Check that the type of the value is allowed in conditional context.
   // Call the runtime if the object is not bool::true or bool::false.
   Label done;
   __ CompareObject(obj, compiler->bool_true());
   __ j(EQUAL, &done, Assembler::kNearJump);
   __ CompareObject(obj, compiler->bool_false());
   __ j(EQUAL, &done, Assembler::kNearJump);
 
   __ pushq(obj);  // Push the source object.
-  compiler->GenerateCallRuntime(cid(),
+  compiler->GenerateCallRuntime(deopt_id(),
                                 token_pos(),
                                 try_index(),
                                 kConditionTypeErrorRuntimeEntry);
   // We should never return here.
   __ int3();
 
   __ Bind(&done);
   ASSERT(obj == result);
 }
 
@@ skipping 49 matching lines @@
 }
 
 
 // Optional integer arguments can often be null. Null is not collected
 // by IC data. TODO(srdjan): Shall we collect null classes in ICData as well?
 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(),
+  Label* deopt = compiler->AddDeoptStub(comp->deopt_id(),
                                         comp->token_pos(),
                                         comp->try_index(),
                                         kDeoptSmiCompareSmi,
                                         left,
                                         right);
   __ movq(temp, left);
   __ orq(temp, right);
   __ testq(temp, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, deopt);
   __ cmpq(left, right);
   Register result = comp->locs()->out().reg();
   Label load_true, done;
   __ j(TokenKindToSmiCondition(comp->kind()), &load_true, Assembler::kNearJump);
   __ LoadObject(result, compiler->bool_false());
   __ jmp(&done, Assembler::kNearJump);
   __ Bind(&load_true);
   __ LoadObject(result, compiler->bool_true());
   __ Bind(&done);
 }
 
 
 // TODO(srdjan): Add support for mixed Smi/Double equality
 // (see LoadDoubleOrSmiToXmm).
 static void EmitDoubleEqualityCompare(FlowGraphCompiler* compiler,
                                       EqualityCompareComp* comp) {
   Register left = comp->locs()->in(0).reg();
   Register right = comp->locs()->in(1).reg();
-  Label* deopt = compiler->AddDeoptStub(comp->cid(),
+  Label* deopt = compiler->AddDeoptStub(comp->deopt_id(),
                                         comp->token_pos(),
                                         comp->try_index(),
                                         kDeoptDoubleCompareDouble,
                                         left,
                                         right);
   __ CompareClassId(left, kDouble);
   __ j(NOT_EQUAL, deopt);
   __ CompareClassId(right, kDouble);
   __ j(NOT_EQUAL, deopt);
   __ movsd(XMM0, FieldAddress(left, Double::value_offset()));
   __ movsd(XMM1, FieldAddress(right, Double::value_offset()));
   compiler->EmitDoubleCompareBool(TokenKindToSmiCondition(comp->kind()),
                                   XMM0, XMM1,
                                   comp->locs()->out().reg());
 }
 
 
 static void EmitEqualityAsInstanceCall(FlowGraphCompiler* compiler,
                                        EqualityCompareComp* comp) {
   compiler->AddCurrentDescriptor(PcDescriptors::kDeopt,
-                                 comp->cid(),
+                                 comp->deopt_id(),
                                  comp->token_pos(),
                                  comp->try_index());
   const String& operator_name = String::ZoneHandle(Symbols::New("=="));
   const int kNumberOfArguments = 2;
   const Array& kNoArgumentNames = Array::Handle();
   const int kNumArgumentsChecked = 2;
 
-  compiler->GenerateInstanceCall(comp->cid(),
+  compiler->GenerateInstanceCall(comp->deopt_id(),
                                  comp->token_pos(),
                                  comp->try_index(),
                                  operator_name,
                                  kNumberOfArguments,
                                  kNoArgumentNames,
                                  kNumArgumentsChecked);
   ASSERT(comp->locs()->out().reg() == RAX);
   if (comp->kind() == Token::kNE) {
     Label done, false_label;
     __ CompareObject(RAX, compiler->bool_true());
     __ j(EQUAL, &false_label, Assembler::kNearJump);
     __ LoadObject(RAX, compiler->bool_true());
     __ jmp(&done, Assembler::kNearJump);
     __ Bind(&false_label);
     __ LoadObject(RAX, compiler->bool_false());
     __ Bind(&done);
   }
 }
 
 
 static void EmitEqualityAsPolymorphicCall(FlowGraphCompiler* compiler,
                                           const ICData& orig_ic_data,
                                           const LocationSummary& locs,
                                           BranchInstr* branch,
                                           Token::Kind kind,
-                                          intptr_t cid,
+                                          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(cid,
+  Label* deopt = compiler->AddDeoptStub(deopt_id,
                                         token_pos,
                                         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) == kSmi) {
     Label done, load_class_id;
     __ j(NOT_ZERO, &load_class_id, Assembler::kNearJump);
@@ skipping 27 matching lines @@
         Label load_true;
         __ j(cond, &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(cid,
+      compiler->GenerateStaticCall(deopt_id,
                                    token_pos,
                                    try_index,
                                    target,
                                    kNumberOfArguments,
                                    kNoArgumentNames);
       if (branch == NULL) {
         if (kind == Token::kNE) {
           Label false_label;
           __ CompareObject(RAX, compiler->bool_true());
           __ j(EQUAL, &false_label, Assembler::kNearJump);
@@ skipping 18 matching lines @@
 
 
 // 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,
                                        const LocationSummary& locs,
                                        Token::Kind kind,
                                        BranchInstr* branch,
                                        const ICData& ic_data,
-                                       intptr_t cid,
+                                       intptr_t deopt_id,
                                        intptr_t token_pos,
                                        intptr_t try_index) {
   ASSERT((kind == Token::kEQ) || (kind == Token::kNE));
   ASSERT(!ic_data.IsNull() && (ic_data.NumberOfChecks() > 0));
   Register left = locs.in(0).reg();
   Register right = locs.in(1).reg();
   const Immediate raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   Label done, non_null_compare;
   __ cmpq(left, raw_null);
@@ skipping 10 matching lines @@
     __ LoadObject(result, compiler->bool_false());
     __ jmp(&done);
     __ Bind(&load_true);
     __ LoadObject(result, compiler->bool_true());
   }
   __ jmp(&done);
   __ Bind(&non_null_compare);  // Receiver is not null.
   __ pushq(left);
   __ pushq(right);
   EmitEqualityAsPolymorphicCall(compiler, ic_data, locs, branch, kind,
-                                cid, token_pos, try_index);
+                                deopt_id, token_pos, try_index);
   __ Bind(&done);
 }
 
 
 void EqualityCompareComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   if (receiver_class_id() == kSmi) {
     EmitSmiEqualityCompare(compiler, this);
     return;
   }
   if (receiver_class_id() == kDouble) {
     EmitDoubleEqualityCompare(compiler, this);
     return;
   }
   if (HasICData() && (ic_data()->NumberOfChecks() > 0)) {
-    EmitGenericEqualityCompare(compiler, *locs(), kind(), NULL,
-                               *ic_data(), cid(), token_pos(), try_index());
+    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);
     EmitEqualityAsInstanceCall(compiler, this);
   }
 }
 
 
@@ skipping 11 matching lines @@
   }
   ASSERT(operands_class_id() == kObject);
   return MakeCallSummary();
 }
 
 
 static void EmitSmiComparisonOp(FlowGraphCompiler* compiler,
                                 const LocationSummary& locs,
                                 Token::Kind kind,
                                 BranchInstr* branch,
-                                intptr_t cid,
+                                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(cid,
+  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);
 
@@ skipping 27 matching lines @@
       UNREACHABLE();
       return OVERFLOW;
   }
 }
 
 
 static void EmitDoubleComparisonOp(FlowGraphCompiler* compiler,
                                    const LocationSummary& locs,
                                    Token::Kind kind,
                                    BranchInstr* branch,
-                                   intptr_t cid,
+                                   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(cid,
+  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(
         true_condition, XMM0, XMM1, branch);
   } else {
     compiler->EmitDoubleCompareBool(
         true_condition, XMM0, XMM1, locs.out().reg());
   }
 }
 
 
 void RelationalOpComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   if (operands_class_id() == kSmi) {
     EmitSmiComparisonOp(compiler, *locs(), kind(), NULL,
-                        cid(), token_pos(), try_index());
+                        deopt_id(), token_pos(), try_index());
     return;
   }
   if (operands_class_id() == kDouble) {
     EmitDoubleComparisonOp(compiler, *locs(), kind(), NULL,
-                           cid(), token_pos(), try_index());
+                           deopt_id(), token_pos(), try_index());
     return;
   }
   if (HasICData() && (ic_data()->NumberOfChecks() > 0)) {
-    Label* deopt = compiler->AddDeoptStub(cid(),
+    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(kSmi));
     __ movq(RAX, Address(RSP, (kNumArguments - 1) * kWordSize));
     __ testq(RAX, Immediate(kSmiTagMask));
     __ j(ZERO, &done);
     __ LoadClassId(RDI, RAX);
     __ Bind(&done);
     compiler->EmitTestAndCall(ICData::Handle(ic_data()->AsUnaryClassChecks()),
                               RDI,  // Class id register.
                               kNumArguments,
                               Array::Handle(),  // No named arguments.
                               deopt,  // Deoptimize target.
                               NULL,   // Fallthrough when done.
-                              cid(),
+                              deopt_id(),
                               token_pos(),
                               try_index());
     return;
   }
   const String& function_name =
       String::ZoneHandle(Symbols::New(Token::Str(kind())));
   compiler->AddCurrentDescriptor(PcDescriptors::kDeopt,
-                                 cid(),
+                                 deopt_id(),
                                  token_pos(),
                                  try_index());
   const intptr_t kNumArguments = 2;
   const intptr_t kNumArgsChecked = 2;  // Type-feedback.
-  compiler->GenerateInstanceCall(cid(),
+  compiler->GenerateInstanceCall(deopt_id(),
                                  token_pos(),
                                  try_index(),
                                  function_name,
                                  kNumArguments,
                                  Array::ZoneHandle(),  // No optional arguments.
                                  kNumArgsChecked);
   ASSERT(locs()->out().reg() == RAX);
 }
 
 
@@ skipping 57 matching lines @@
                                  LocationSummary::kNoCall);
   } else {
     ASSERT(receiver_type() == kIllegalObjectKind);
     return MakeCallSummary();
   }
 }
 
 
 static void EmitLoadIndexedPolymorphic(FlowGraphCompiler* compiler,
                                         LoadIndexedComp* comp) {
-  Label* deopt = compiler->AddDeoptStub(comp->cid(),
+  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) != kSmi);
   // Load receiver into RAX.
   const intptr_t kNumArguments = 2;
   __ movq(RAX, Address(RSP, (kNumArguments - 1) * kWordSize));
   __ testq(RAX, Immediate(kSmiTagMask));
   __ j(ZERO, deopt);
   __ LoadClassId(RDI, RAX);
   compiler->EmitTestAndCall(ic_data,
                             RDI,  // Class id register.
                             kNumArguments,
                             Array::Handle(),  // No named arguments.
                             deopt,  // Deoptimize target.
                             NULL,   // Fallthrough when done.
-                            comp->cid(),
+                            comp->deopt_id(),
                             comp->token_pos(),
                             comp->try_index());
 }
 
 
 void LoadIndexedComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   if (receiver_type() == kIllegalObjectKind) {
     if (HasICData() && (ic_data()->NumberOfChecks() > 0)) {
       EmitLoadIndexedPolymorphic(compiler, this);
     } else {
       compiler->EmitLoadIndexedGeneric(this);
     }
     ASSERT(locs()->out().reg() == RAX);
     return;
   }
 
   Register receiver = locs()->in(0).reg();
   Register index = locs()->in(1).reg();
   Register result = locs()->out().reg();
 
   const DeoptReasonId deopt_reason = (receiver_type() == kGrowableObjectArray) ?
       kDeoptLoadIndexedGrowableArray : kDeoptLoadIndexedFixedArray;
 
-  Label* deopt = compiler->AddDeoptStub(cid(),
+  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 53 matching lines @@
   }
 }
 
 
 static void EmitStoreIndexedGeneric(FlowGraphCompiler* compiler,
                                     StoreIndexedComp* comp) {
   const String& function_name =
       String::ZoneHandle(Symbols::New(Token::Str(Token::kASSIGN_INDEX)));
 
   compiler->AddCurrentDescriptor(PcDescriptors::kDeopt,
-                                 comp->cid(),
+                                 comp->deopt_id(),
                                  comp->token_pos(),
                                  comp->try_index());
 
   const intptr_t kNumArguments = 3;
   const intptr_t kNumArgsChecked = 1;  // Type-feedback.
-  compiler->GenerateInstanceCall(comp->cid(),
+  compiler->GenerateInstanceCall(comp->deopt_id(),
                                  comp->token_pos(),
                                  comp->try_index(),
                                  function_name,
                                  kNumArguments,
                                  Array::ZoneHandle(),  // No named arguments.
                                  kNumArgsChecked);
 }
 
 
 static void EmitStoreIndexedPolymorphic(FlowGraphCompiler* compiler,
                                         StoreIndexedComp* comp) {
-  Label* deopt = compiler->AddDeoptStub(comp->cid(),
+  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) != kSmi);
   // Load receiver into RAX.
   const intptr_t kNumArguments = 3;
   __ movq(RAX, Address(RSP, (kNumArguments - 1) * kWordSize));
   __ testq(RAX, Immediate(kSmiTagMask));
   __ j(ZERO, deopt);
   __ LoadClassId(RDI, RAX);
   compiler->EmitTestAndCall(ic_data,
                             RDI,  // Class id register.
                             kNumArguments,
                             Array::Handle(),  // No named arguments.
                             deopt,  // deoptimize label.
                             NULL,   // fallthrough when done.
-                            comp->cid(),
+                            comp->deopt_id(),
                             comp->token_pos(),
                             comp->try_index());
 }
 
 
 void StoreIndexedComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   if (receiver_type() == kIllegalObjectKind) {
     if (HasICData() && (ic_data()->NumberOfChecks() > 0)) {
       EmitStoreIndexedPolymorphic(compiler, this);
     } else {
       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(cid(),
+  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());
@@ skipping 36 matching lines @@
 
 
 LocationSummary* InstanceSetterComp::MakeLocationSummary() const {
   return MakeCallSummary();
 }
 
 
 void InstanceSetterComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Label* deopt = NULL;
   if (compiler->is_optimizing()) {
-    deopt = compiler->AddDeoptStub(cid(),
+    deopt = compiler->AddDeoptStub(deopt_id(),
                                    token_pos(),
                                    try_index(),
                                    kDeoptInstanceSetter);
   }
   if (HasICData() && (ic_data()->NumberOfChecks() > 0)) {
     // No index-setter on Smi's.
     ASSERT(ic_data()->GetReceiverClassIdAt(0) != kSmi);
     // Load receiver into RAX.
     const intptr_t kNumArguments = 2;
     __ movq(RAX, Address(RSP, (kNumArguments - 1) * kWordSize));
     __ testq(RAX, Immediate(kSmiTagMask));
     __ j(ZERO, deopt);
     __ LoadClassId(RDI, RAX);
     compiler->EmitTestAndCall(*ic_data(),
                               RDI,  // Class id register.
                               kNumArguments,
                               Array::Handle(),  // No named arguments.
                               deopt,  // Deoptimize target.
                               NULL,   // Fallthrough when done.
-                              cid(),
+                              deopt_id(),
                               token_pos(),
                               try_index());
 
   } else if (compiler->is_optimizing()) {
     // Get some IC data then optimize again.
     __ jmp(deopt);
   } else {
     // Unoptimized code.
     const String& function_name =
         String::ZoneHandle(Field::SetterSymbol(field_name()));
 
     compiler->AddCurrentDescriptor(PcDescriptors::kDeopt,
-                                   cid(),
+                                   deopt_id(),
                                    token_pos(),
                                    try_index());
     const intptr_t kArgumentCount = 2;
     const intptr_t kCheckedArgumentCount = 1;
-    compiler->GenerateInstanceCall(cid(),
+    compiler->GenerateInstanceCall(deopt_id(),
                                    token_pos(),
                                    try_index(),
                                    function_name,
                                    kArgumentCount,
                                    Array::ZoneHandle(),
                                    kCheckedArgumentCount);
   }
 }
 
 
 LocationSummary* LoadInstanceFieldComp::MakeLocationSummary() const {
   // TODO(fschneider): For this instruction the input register may be
   // reused for the result (but is not required to) because the input
   // is not used after the result is defined.  We should consider adding
   // this information to the input policy.
   return LocationSummary::Make(1,
                                Location::RequiresRegister(),
                                LocationSummary::kNoCall);
 }
 
 
 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()->cid(),
+    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 26 matching lines @@
   summary->set_out(Location::RegisterLocation(RAX));
   return summary;
 }
 
 
 void InstanceOfComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(locs()->in(0).reg() == RAX);  // Value.
   ASSERT(locs()->in(1).reg() == RCX);  // Instantiator.
   ASSERT(locs()->in(2).reg() == RDX);  // Instantiator type arguments.
 
-  compiler->GenerateInstanceOf(cid(),
+  compiler->GenerateInstanceOf(deopt_id(),
                                token_pos(),
                                try_index(),
                                type(),
                                negate_result());
   ASSERT(locs()->out().reg() == RAX);
 }
 
 
 LocationSummary* CreateArrayComp::MakeLocationSummary() const {
   // TODO(regis): The elements of the array could be considered as arguments to
@@ skipping 52 matching lines @@
   const Class& cls = Class::ZoneHandle(constructor().owner());
   Register type_arguments = locs()->in(0).reg();
   Register instantiator_type_arguments = locs()->in(1).reg();
   Register result = locs()->out().reg();
 
   // Push the result place holder initialized to NULL.
   __ PushObject(Object::ZoneHandle());
   __ PushObject(cls);
   __ pushq(type_arguments);
   __ pushq(instantiator_type_arguments);
-  compiler->GenerateCallRuntime(cid(),
+  compiler->GenerateCallRuntime(deopt_id(),
                                 token_pos(),
                                 try_index(),
                                 kAllocateObjectWithBoundsCheckRuntimeEntry);
   // Pop instantiator type arguments, type arguments, and class.
   __ Drop(3);
   __ popq(result);  // Pop new instance.
 }
 
 
 LocationSummary* LoadVMFieldComp::MakeLocationSummary() const {
   return LocationSummary::Make(1,
                                Location::RequiresRegister(),
                                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()->cid(),
+    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 43 matching lines @@
     __ j(NOT_EQUAL, &type_arguments_uninstantiated, Assembler::kNearJump);
     __ cmpq(FieldAddress(instantiator_reg, TypeArguments::length_offset()),
             Immediate(Smi::RawValue(len)));
     __ j(EQUAL, &type_arguments_instantiated, Assembler::kNearJump);
     __ Bind(&type_arguments_uninstantiated);
   }
   // A runtime call to instantiate the type arguments is required.
   __ PushObject(Object::ZoneHandle());  // Make room for the result.
   __ PushObject(type_arguments());
   __ pushq(instantiator_reg);  // Push instantiator type arguments.
-  compiler->GenerateCallRuntime(cid(),
+  compiler->GenerateCallRuntime(deopt_id(),
                                 token_pos(),
                                 try_index(),
                                 kInstantiateTypeArgumentsRuntimeEntry);
   __ Drop(2);  // Drop instantiator and uninstantiated type arguments.
   __ popq(result_reg);  // Pop instantiated type arguments.
   __ Bind(&type_arguments_instantiated);
   ASSERT(instantiator_reg == result_reg);
   // 'result_reg': Instantiated type arguments.
 }
 
@@ skipping 155 matching lines @@
   return locs;
 }
 
 
 void CloneContextComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register context_value = locs()->in(0).reg();
   Register result = locs()->out().reg();
 
   __ PushObject(Object::ZoneHandle());  // Make room for the result.
   __ pushq(context_value);
-  compiler->GenerateCallRuntime(cid(),
+  compiler->GenerateCallRuntime(deopt_id(),
                                 token_pos(),
                                 try_index(),
                                 kCloneContextRuntimeEntry);
   __ popq(result);  // Remove argument.
   __ popq(result);  // Get result (cloned context).
 }
 
 
 LocationSummary* CatchEntryComp::MakeLocationSummary() const {
   return LocationSummary::Make(0,
@@ skipping 35 matching lines @@
 }
 
 
 void CheckStackOverflowComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register temp = locs()->temp(0).reg();
   // Generate stack overflow check.
   __ movq(temp, Immediate(Isolate::Current()->stack_limit_address()));
   __ cmpq(RSP, Address(temp, 0));
   Label no_stack_overflow;
   __ j(ABOVE, &no_stack_overflow, Assembler::kNearJump);
-  compiler->GenerateCallRuntime(cid(),
+  compiler->GenerateCallRuntime(deopt_id(),
                                 token_pos(),
                                 try_index(),
                                 kStackOverflowRuntimeEntry);
   __ Bind(&no_stack_overflow);
 }
 
 
 LocationSummary* BinaryOpComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
 
@@ skipping 57 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()->cid(),
+  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));
@@ skipping 90 matching lines @@
       __ shlq(left, right_temp);
       __ jmp(&done);
       {
         __ Bind(&call_method);
         Function& target = Function::ZoneHandle(
             comp->ic_data()->GetTargetForReceiverClassId(kSmi));
         ASSERT(!target.IsNull());
         const intptr_t kArgumentCount = 2;
         __ pushq(temp);
         __ pushq(right);
-        compiler->GenerateStaticCall(comp->instance_call()->cid(),
+        compiler->GenerateStaticCall(comp->instance_call()->deopt_id(),
                                      comp->instance_call()->token_pos(),
                                      comp->instance_call()->try_index(),
                                      target,
                                      kArgumentCount,
                                      Array::Handle());  // No argument names.
         ASSERT(result == RAX);
       }
       __ Bind(&done);
       break;
     }
@@ skipping 25 matching lines @@
 static void EmitMintBinaryOp(FlowGraphCompiler* compiler, BinaryOpComp* comp) {
   // 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()->cid(),
+  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);
@@ skipping 27 matching lines @@
 
   __ Bind(&smi_static_call);
   {
     Function& target = Function::ZoneHandle(
         comp->ic_data()->GetTargetForReceiverClassId(kSmi));
     if (target.IsNull()) {
       __ jmp(deopt);
     } else {
       __ pushq(left);
       __ pushq(right);
-      compiler->GenerateStaticCall(comp->instance_call()->cid(),
+      compiler->GenerateStaticCall(comp->instance_call()->deopt_id(),
                                    comp->instance_call()->token_pos(),
                                    comp->instance_call()->try_index(),
                                    target,
                                    comp->instance_call()->ArgumentCount(),
                                    comp->instance_call()->argument_names());
       ASSERT(result == RAX);
       __ jmp(&done);
     }
   }
 
   __ Bind(&mint_static_call);
   {
     Function& target = Function::ZoneHandle(
         comp->ic_data()->GetTargetForReceiverClassId(kMint));
     if (target.IsNull()) {
       __ jmp(deopt);
     } else {
       __ pushq(left);
       __ pushq(right);
-      compiler->GenerateStaticCall(comp->instance_call()->cid(),
+      compiler->GenerateStaticCall(comp->instance_call()->deopt_id(),
                                    comp->instance_call()->token_pos(),
                                    comp->instance_call()->try_index(),
                                    target,
                                    comp->instance_call()->ArgumentCount(),
                                    comp->instance_call()->argument_names());
       ASSERT(result == RAX);
     }
   }
   __ Bind(&done);
 }
@@ skipping 32 matching lines @@
   const ExternalLabel label(double_class.ToCString(), stub.EntryPoint());
   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()->cid(),
+  Label* deopt = compiler->AddDeoptStub(instance_call()->deopt_id(),
                                         instance_call()->token_pos(),
                                         instance_call()->try_index(),
                                         kDeoptDoubleBinaryOp,
                                         left,
                                         right);
 
   compiler->LoadDoubleOrSmiToXmm(XMM0, left, temp, deopt);
   compiler->LoadDoubleOrSmiToXmm(XMM1, right, temp, deopt);
 
   switch (op_kind()) {
@@ skipping 25 matching lines @@
   ASSERT(ic_data.num_args_tested() == 1);
   // 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()->cid(),
+  Label* deopt = compiler->AddDeoptStub(instance_call()->deopt_id(),
                                         instance_call()->token_pos(),
                                         instance_call()->try_index(),
                                         kDeoptUnaryOp,
                                         value);
   if (test_class_id == kSmi) {
     __ testq(value, Immediate(kSmiTagMask));
     __ j(NOT_ZERO, deopt);
     switch (op_kind()) {
       case Token::kNEGATE:
         __ negq(value);
@@ 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()->cid(),
+  Label* deopt = compiler->AddDeoptStub(instance_call()->deopt_id(),
                                         instance_call()->token_pos(),
                                         instance_call()->try_index(),
                                         kDeoptUnaryOp,
                                         value);
   if (test_class_id == kDouble) {
     Register temp = locs()->temp(0).reg();
     __ testq(value, Immediate(kSmiTagMask));
     __ j(ZERO, deopt);  // Smi.
     __ CompareClassId(value, kDouble);
     __ j(NOT_EQUAL, deopt);
@@ skipping 35 matching lines @@
   }
 }
 
 
 void ToDoubleComp::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register value = (from() == kDouble) ? locs()->in(0).reg() : RBX;
   Register result = locs()->out().reg();
 
   const DeoptReasonId deopt_reason = (from() == kDouble) ?
       kDeoptDoubleToDouble : kDeoptIntegerToDouble;
-  Label* deopt = compiler->AddDeoptStub(instance_call()->cid(),
+  Label* deopt = compiler->AddDeoptStub(instance_call()->deopt_id(),
                                         instance_call()->token_pos(),
                                         instance_call()->try_index(),
                                         deopt_reason,
                                         value);
 
   if (from() == kDouble) {
     __ testq(value, Immediate(kSmiTagMask));
     __ j(ZERO, deopt);  // Deoptimize if Smi.
     __ CompareClassId(value, kDouble);
     __ j(NOT_EQUAL, deopt);  // Deoptimize if not Double.
@@ skipping 23 matching lines @@
   __ movsd(FieldAddress(result, Double::value_offset()), XMM0);
 }
 
 
 LocationSummary* PolymorphicInstanceCallComp::MakeLocationSummary() const {
   return MakeCallSummary();
 }
 
 
 void PolymorphicInstanceCallComp::EmitNativeCode(FlowGraphCompiler* compiler) {
-  Label* deopt = compiler->AddDeoptStub(instance_call()->cid(),
+  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 =
       ic_data()->GetReceiverClassIdAt(0) == kSmi ?  &handle_smi : deopt;
 
   // Load receiver into RAX.
   __ movq(RAX,
       Address(RSP, (instance_call()->ArgumentCount() - 1) * kWordSize));
   __ testq(RAX, Immediate(kSmiTagMask));
   __ j(ZERO, is_smi_label);
   Label done;
   __ LoadClassId(RDI, RAX);
   compiler->EmitTestAndCall(*ic_data(),
                             RDI,  // Class id register.
                             instance_call()->ArgumentCount(),
                             instance_call()->argument_names(),
                             deopt,
                             (is_smi_label == &handle_smi) ? &done : NULL,
-                            instance_call()->cid(),
+                            instance_call()->deopt_id(),
                             instance_call()->token_pos(),
                             instance_call()->try_index());
   if (is_smi_label == &handle_smi) {
     __ Bind(&handle_smi);
     ASSERT(ic_data()->GetReceiverClassIdAt(0) == kSmi);
     const Function& target = Function::ZoneHandle(ic_data()->GetTargetAt(0));
-    compiler->GenerateStaticCall(instance_call()->cid(),
+    compiler->GenerateStaticCall(instance_call()->deopt_id(),
                                  instance_call()->token_pos(),
                                  instance_call()->try_index(),
                                  target,
                                  instance_call()->ArgumentCount(),
                                  instance_call()->argument_names());
   }
   __ Bind(&done);
 }
 
 
@@ skipping 53 matching lines @@
     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(), kSmi)) {
       EmitSmiComparisonOp(compiler, *locs(), kind(), this,
-                          cid(), token_pos(), try_index());
+                          deopt_id(), token_pos(), try_index());
       return;
     }
     if (ICDataWithBothClassIds(*ic_data(), kDouble)) {
       EmitDoubleComparisonOp(compiler, *locs(), kind(), this,
-                             cid(), token_pos(), try_index());
+                             deopt_id(), token_pos(), 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(),
-                                 cid(), token_pos(), try_index());
+                                 deopt_id(), token_pos(), try_index());
       return;
     }
     // Otherwise polymorphic dispatch?
   }
   // Not equal is always split into '==' and negate,
   Condition branch_condition = (kind() == Token::kNE) ? NOT_EQUAL : EQUAL;
   Token::Kind call_kind = (kind() == Token::kNE) ? Token::kEQ : kind();
   const String& function_name =
       String::ZoneHandle(Symbols::New(Token::Str(call_kind)));
   compiler->AddCurrentDescriptor(PcDescriptors::kDeopt,
-                                 cid(),
+                                 deopt_id(),
                                  token_pos(),
                                  try_index());
   const intptr_t kNumArguments = 2;
   const intptr_t kNumArgsChecked = 2;  // Type-feedback.
-  compiler->GenerateInstanceCall(cid(),
+  compiler->GenerateInstanceCall(deopt_id(),
                                  token_pos(),
                                  try_index(),
                                  function_name,
                                  kNumArguments,
                                  Array::ZoneHandle(),  // No optional arguments.
                                  kNumArgsChecked);
   ASSERT(locs()->out().reg() == RAX);
   __ CompareObject(locs()->out().reg(), compiler->bool_true());
   EmitBranchOnCondition(compiler, branch_condition);
 }
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64