Unify class ids and snapshot object ids list so that we don't have disparate and sometimes confusin…

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 232 matching lines @@
     case Token::kGTE: return  GREATER_EQUAL;
     default:
       UNREACHABLE();
       return OVERFLOW;
   }
 }
 
 
 LocationSummary* EqualityCompareComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
-  if (receiver_class_id() != kObject) {
-    ASSERT((receiver_class_id() == kSmi) || (receiver_class_id() == kDouble));
+  if (receiver_class_id() != kObjectCid) {
+    ASSERT((receiver_class_id() == kSmiCid) ||
+           (receiver_class_id() == kDoubleCid));
     const intptr_t kNumTemps = 1;
     LocationSummary* locs =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     locs->set_in(0, Location::RequiresRegister());
     locs->set_in(1, Location::RequiresRegister());
     locs->set_temp(0, Location::RequiresRegister());
     locs->set_out(Location::RequiresRegister());
     return locs;
   }
   if (HasICData() && (ic_data()->NumberOfChecks() > 0)) {
@@ skipping 61 matching lines @@
   ASSERT(ic_data.NumberOfChecks() > 0);
   ASSERT(ic_data.num_args_tested() == 1);
   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) {
+  if (ic_data.GetReceiverClassIdAt(0) == kSmiCid) {
     Label done, load_class_id;
     __ j(NOT_ZERO, &load_class_id, Assembler::kNearJump);
-    __ movq(temp, Immediate(kSmi));
+    __ movq(temp, Immediate(kSmiCid));
     __ jmp(&done, Assembler::kNearJump);
     __ Bind(&load_class_id);
     __ LoadClassId(temp, left);
     __ Bind(&done);
   } else {
     __ j(ZERO, deopt);  // Smi deopts.
     __ LoadClassId(temp, left);
   }
   Condition cond = TokenKindToSmiCondition(kind);
   Label done;
   for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
-    ASSERT((ic_data.GetReceiverClassIdAt(i) != kSmi) || (i == 0));
+    ASSERT((ic_data.GetReceiverClassIdAt(i) != kSmiCid) || (i == 0));
     Label next_test;
     __ cmpq(temp, Immediate(ic_data.GetReceiverClassIdAt(i)));
     __ j(NOT_EQUAL, &next_test);
     const Function& target = Function::ZoneHandle(ic_data.GetTargetAt(i));
     ObjectStore* object_store = Isolate::Current()->object_store();
     if (target.owner() == object_store->object_class()) {
       // Object.== is same as ===.
       __ Drop(2);
       __ cmpq(left, right);
       if (branch != NULL) {
@@ skipping 165 matching lines @@
     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() == kSmi) {
+  if (receiver_class_id() == kSmiCid) {
     EmitSmiComparisonOp(compiler, *locs(), kind(), NULL,  // No branch.
                         deopt_id(), token_pos(), try_index());
     return;
   }
-  if (receiver_class_id() == kDouble) {
+  if (receiver_class_id() == kDoubleCid) {
     EmitDoubleComparisonOp(compiler, *locs(), kind(), NULL,  // No branch.
                            deopt_id(), token_pos(), 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);
     EmitEqualityAsInstanceCall(compiler, this);
   }
 }
 
 
 LocationSummary* RelationalOpComp::MakeLocationSummary() const {
-  if (operands_class_id() == kSmi || operands_class_id() == kDouble) {
+  if (operands_class_id() == kSmiCid || operands_class_id() == kDoubleCid) {
     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());
     summary->set_out(Location::RequiresRegister());
     summary->set_temp(0, Location::RequiresRegister());
     return summary;
   }
-  ASSERT(operands_class_id() == kObject);
+  ASSERT(operands_class_id() == kObjectCid);
   return MakeCallSummary();
 }
 
 
 void RelationalOpComp::EmitNativeCode(FlowGraphCompiler* compiler) {
-  if (operands_class_id() == kSmi) {
+  if (operands_class_id() == kSmiCid) {
     EmitSmiComparisonOp(compiler, *locs(), kind(), NULL,
                         deopt_id(), token_pos(), try_index());
     return;
   }
-  if (operands_class_id() == kDouble) {
+  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(kSmi));
+    __ movq(RDI, Immediate(kSmiCid));
     __ 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.
@@ skipping 59 matching lines @@
   compiler->GenerateCall(token_pos(),
                          try_index(),
                          &StubCode::CallNativeCFunctionLabel(),
                          PcDescriptors::kOther);
   __ popq(result);
 }
 
 
 LocationSummary* LoadIndexedComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
-  if (receiver_type() == kGrowableObjectArray) {
+  if (receiver_type() == kGrowableObjectArrayCid) {
     const intptr_t kNumTemps = 1;
     LocationSummary* locs =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     locs->set_in(0, Location::RequiresRegister());
     locs->set_in(1, Location::RequiresRegister());
     locs->set_temp(0, Location::RequiresRegister());
     locs->set_out(Location::RequiresRegister());
     return locs;
-  } else if ((receiver_type() == kArray) ||
-             (receiver_type() == kImmutableArray)) {
+  } else if ((receiver_type() == kArrayCid) ||
+             (receiver_type() == kImmutableArrayCid)) {
     return LocationSummary::Make(kNumInputs,
                                  Location::RequiresRegister(),
                                  LocationSummary::kNoCall);
   } else {
-    ASSERT(receiver_type() == kIllegalObjectKind);
+    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) != kSmi);
+  ASSERT(ic_data.GetReceiverClassIdAt(0) != kSmiCid);
   // 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->deopt_id(),
                             comp->token_pos(),
                             comp->try_index());
 }
 
 
 void LoadIndexedComp::EmitNativeCode(FlowGraphCompiler* compiler) {
-  if (receiver_type() == kIllegalObjectKind) {
+  if (receiver_type() == kIllegalCid) {
     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) ?
+  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);
 
   __ testq(index, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, deopt);
 
   switch (receiver_type()) {
-    case kArray:
-    case kImmutableArray:
+    case kArrayCid:
+    case kImmutableArrayCid:
       __ cmpq(index, FieldAddress(receiver, Array::length_offset()));
       __ j(ABOVE_EQUAL, deopt);
       // Note that index is Smi, i.e, times 4.
       ASSERT(kSmiTagShift == 1);
       __ movq(result, FieldAddress(receiver, index, TIMES_4, sizeof(RawArray)));
       break;
 
-    case kGrowableObjectArray: {
+    case kGrowableObjectArrayCid: {
       Register temp = locs()->temp(0).reg();
 
       __ cmpq(index,
               FieldAddress(receiver, GrowableObjectArray::length_offset()));
       __ j(ABOVE_EQUAL, deopt);
       __ movq(temp, FieldAddress(receiver, GrowableObjectArray::data_offset()));
       // Note that index is Smi, i.e, times 4.
       ASSERT(kSmiTagShift == 1);
       __ movq(result, FieldAddress(temp, index, TIMES_4, sizeof(RawArray)));
       break;
     }
 
     default:
       UNREACHABLE();
       break;
   }
 }
 
 
 LocationSummary* StoreIndexedComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 3;
-  if (receiver_type() == kGrowableObjectArray) {
+  if (receiver_type() == kGrowableObjectArrayCid) {
     const intptr_t kNumTemps = 1;
     LocationSummary* locs =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     locs->set_in(0, Location::RequiresRegister());
     locs->set_in(1, Location::RequiresRegister());
     locs->set_in(2, Location::RequiresRegister());
     locs->set_temp(0, Location::RequiresRegister());
     locs->set_out(Location::NoLocation());
     return locs;
-  } else if (receiver_type() == kArray) {
+  } else if (receiver_type() == kArrayCid) {
     return LocationSummary::Make(kNumInputs,
                                  Location::NoLocation(),
                                  LocationSummary::kNoCall);
   } else {
-    ASSERT(receiver_type() == kIllegalObjectKind);
+    ASSERT(receiver_type() == kIllegalCid);
     return MakeCallSummary();
   }
 }
 
 
 static void EmitStoreIndexedGeneric(FlowGraphCompiler* compiler,
                                     StoreIndexedComp* comp) {
   const String& function_name =
       String::ZoneHandle(Symbols::New(Token::Str(Token::kASSIGN_INDEX)));
 
@@ skipping 18 matching lines @@
                                         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) != kSmi);
+  ASSERT(ic_data.GetReceiverClassIdAt(0) != kSmiCid);
   // 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->deopt_id(),
                             comp->token_pos(),
                             comp->try_index());
 }
 
 
 void StoreIndexedComp::EmitNativeCode(FlowGraphCompiler* compiler) {
-  if (receiver_type() == kIllegalObjectKind) {
+  if (receiver_type() == kIllegalCid) {
     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(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);
 
   __ testq(index, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, deopt);
 
   switch (receiver_type()) {
-    case kArray:
-    case kImmutableArray:
+    case kArrayCid:
+    case kImmutableArrayCid:
       __ cmpq(index, FieldAddress(receiver, Array::length_offset()));
       __ j(ABOVE_EQUAL, deopt);
       // Note that index is Smi, i.e, times 4.
       ASSERT(kSmiTagShift == 1);
       __ StoreIntoObject(receiver,
           FieldAddress(receiver, index, TIMES_4, sizeof(RawArray)),
           value);
       break;
 
-    case kGrowableObjectArray: {
+    case kGrowableObjectArrayCid: {
       Register temp = locs()->temp(0).reg();
       __ cmpq(index,
               FieldAddress(receiver, GrowableObjectArray::length_offset()));
       __ j(ABOVE_EQUAL, deopt);
       __ movq(temp, FieldAddress(receiver, GrowableObjectArray::data_offset()));
       // Note that index is Smi, i.e, times 4.
       ASSERT(kSmiTagShift == 1);
       __ StoreIntoObject(temp,
           FieldAddress(temp, index, TIMES_4, sizeof(RawArray)),
           value);
@@ skipping 203 matching lines @@
     __ j(EQUAL, &type_arguments_instantiated, Assembler::kNearJump);
   }
   // Instantiate non-null type arguments.
   if (type_arguments().IsUninstantiatedIdentity()) {
     // Check if the instantiator type argument vector is a TypeArguments of a
     // matching length and, if so, use it as the instantiated type_arguments.
     // No need to check the instantiator ('instantiator_reg') for null here,
     // because a null instantiator will have the wrong class (Null instead of
     // TypeArguments).
     Label type_arguments_uninstantiated;
-    __ CompareClassId(instantiator_reg, kTypeArguments);
+    __ CompareClassId(instantiator_reg, kTypeArgumentsCid);
     __ 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.
@@ skipping 40 matching lines @@
     __ cmpq(instantiator_reg, raw_null);
     __ j(EQUAL, &type_arguments_instantiated, Assembler::kNearJump);
   }
   // Instantiate non-null type arguments.
   if (type_arguments().IsUninstantiatedIdentity()) {
     // Check if the instantiator type argument vector is a TypeArguments of a
     // matching length and, if so, use it as the instantiated type_arguments.
     // No need to check instantiator_reg for null here, because a null
     // instantiator will have the wrong class (Null instead of TypeArguments).
     Label type_arguments_uninstantiated;
-    __ CompareClassId(instantiator_reg, kTypeArguments);
+    __ CompareClassId(instantiator_reg, kTypeArgumentsCid);
     __ j(NOT_EQUAL, &type_arguments_uninstantiated, Assembler::kNearJump);
     Immediate arguments_length =
         Immediate(Smi::RawValue(type_arguments().Length()));
     __ cmpq(FieldAddress(instantiator_reg, TypeArguments::length_offset()),
         arguments_length);
     __ j(EQUAL, &type_arguments_instantiated, Assembler::kNearJump);
     __ Bind(&type_arguments_uninstantiated);
   }
   // In the non-factory case, we rely on the allocation stub to
   // instantiate the type arguments.
@@ skipping 46 matching lines @@
     // TODO(regis): The following emitted code is duplicated in
     // VisitExtractConstructorTypeArguments above. The reason is that the code
     // is split between two computations, so that each one produces a
     // single value, rather than producing a pair of values.
     // If this becomes an issue, we should expose these tests at the IL level.
 
     // Check if the instantiator type argument vector is a TypeArguments of a
     // matching length and, if so, use it as the instantiated type_arguments.
     // No need to check the instantiator (RAX) for null here, because a null
     // instantiator will have the wrong class (Null instead of TypeArguments).
-    __ CompareClassId(instantiator_reg, kTypeArguments);
+    __ CompareClassId(instantiator_reg, kTypeArgumentsCid);
     __ j(NOT_EQUAL, &done, Assembler::kNearJump);
     Immediate arguments_length =
         Immediate(Smi::RawValue(type_arguments().Length()));
     __ cmpq(FieldAddress(instantiator_reg, TypeArguments::length_offset()),
         arguments_length);
     __ j(NOT_EQUAL, &done, Assembler::kNearJump);
     // The instantiator was used in VisitExtractConstructorTypeArguments as the
     // instantiated type arguments, no proper instantiator needed.
     __ movq(instantiator_reg,
             Immediate(Smi::RawValue(StubCode::kNoInstantiator)));
@@ skipping 278 matching lines @@
       __ shlq(left, right_temp);
       __ sarq(left, right_temp);
       __ cmpq(left, temp);
       __ j(NOT_EQUAL, &call_method, Assembler::kNearJump);  // Overflow.
       // Shift for result now we know there is no overflow.
       __ shlq(left, right_temp);
       __ jmp(&done);
       {
         __ Bind(&call_method);
         Function& target = Function::ZoneHandle(
-            comp->ic_data()->GetTargetForReceiverClassId(kSmi));
+            comp->ic_data()->GetTargetForReceiverClassId(kSmiCid));
         ASSERT(!target.IsNull());
         const intptr_t kArgumentCount = 2;
         __ pushq(temp);
         __ pushq(right);
         compiler->GenerateStaticCall(comp->instance_call()->deopt_id(),
                                      comp->instance_call()->token_pos(),
                                      comp->instance_call()->try_index(),
                                      target,
                                      kArgumentCount,
                                      Array::Handle());  // No argument names.
@@ skipping 41 matching lines @@
                                         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, kMint);  // Is argument Mint?
+  __ 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.
 
   // Positive Smi receiver, Mint argument.
   // Load lower argument Mint word, convert to Smi. It is OK to loose bits.
   __ movq(right, FieldAddress(right, Mint::value_offset()));
   __ SmiTag(right);
   __ andq(result, right);
   __ jmp(&done);
 
   __ Bind(&non_smi);  // Receiver is non-Smi.
-  __ CompareClassId(left, kMint);  // Is receiver Mint?
+  __ CompareClassId(left, kMintCid);  // Is receiver Mint?
   __ j(NOT_EQUAL, deopt);  // Receiver neither Smi nor Mint.
   __ testq(right, Immediate(kSmiTagMask));  // Is argument Smi?
   __ j(NOT_ZERO, &mint_static_call);  // Mint receiver, non-Smi argument.
   __ cmpq(right, Immediate(0));
   __ j(LESS, &mint_static_call);  // Mint receiver, negative Smi argument.
 
   // Mint receiver, positive Smi argument.
   // Load lower receiver Mint word, convert to Smi. It is OK to loose bits.
   __ movq(result, FieldAddress(left, Mint::value_offset()));
   __ SmiTag(result);
   __ Bind(&smi_smi);
   __ andq(result, right);
   __ jmp(&done);
 
   __ Bind(&smi_static_call);
   {
     Function& target = Function::ZoneHandle(
-        comp->ic_data()->GetTargetForReceiverClassId(kSmi));
+        comp->ic_data()->GetTargetForReceiverClassId(kSmiCid));
     if (target.IsNull()) {
       __ jmp(deopt);
     } else {
       __ pushq(left);
       __ pushq(right);
       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));
+        comp->ic_data()->GetTargetForReceiverClassId(kMintCid));
     if (target.IsNull()) {
       __ jmp(deopt);
     } else {
       __ pushq(left);
       __ pushq(right);
       compiler->GenerateStaticCall(comp->instance_call()->deopt_id(),
                                    comp->instance_call()->token_pos(),
                                    comp->instance_call()->try_index(),
                                    target,
                                    comp->instance_call()->ArgumentCount(),
@@ skipping 95 matching lines @@
   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 == kSmi) {
+  if (test_class_id == kSmiCid) {
     __ testq(value, Immediate(kSmiTagMask));
     __ j(NOT_ZERO, deopt);
     switch (op_kind()) {
       case Token::kNEGATE:
         __ negq(value);
         __ j(OVERFLOW, deopt);
         break;
       case Token::kBIT_NOT:
         __ notq(value);
         __ andq(value, Immediate(~kSmiTagMask));  // Remove inverted smi-tag.
@@ skipping 31 matching lines @@
   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 == kDouble) {
+  if (test_class_id == kDoubleCid) {
     Register temp = locs()->temp(0).reg();
     __ testq(value, Immediate(kSmiTagMask));
     __ j(ZERO, deopt);  // Smi.
-    __ CompareClassId(value, kDouble);
+    __ CompareClassId(value, kDoubleCid);
     __ j(NOT_EQUAL, deopt);
     // Allocate result object.
     const Class& double_class = compiler->double_class();
     const Code& stub =
         Code::Handle(StubCode::GetAllocationStubForClass(double_class));
     const ExternalLabel label(double_class.ToCString(), stub.EntryPoint());
     __ pushq(value);
     compiler->GenerateCall(instance_call()->token_pos(),
                            instance_call()->try_index(),
                            &label,
                            PcDescriptors::kOther);
     // Result is in RAX.
     ASSERT(result != temp);
     __ movq(result, RAX);
     __ popq(temp);
     __ movsd(XMM0, FieldAddress(temp, Double::value_offset()));
     __ DoubleNegate(XMM0);
     __ movsd(FieldAddress(result, Double::value_offset()), XMM0);
   } else {
     UNREACHABLE();
   }
 }
 
 
 LocationSummary* ToDoubleComp::MakeLocationSummary() const {
   const intptr_t kNumInputs = 1;
-  if (from() == kDouble) {
+  if (from() == kDoubleCid) {
     const intptr_t kNumTemps = 0;
     LocationSummary* locs =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     locs->set_in(0, Location::RequiresRegister());
     locs->set_out(Location::SameAsFirstInput());
     return locs;
   } else {
-    ASSERT(from() == kSmi);
+    ASSERT(from() == kSmiCid);
     return MakeCallSummary();  // Calls a stub to allocate result.
   }
 }
 
 
 void ToDoubleComp::EmitNativeCode(FlowGraphCompiler* compiler) {
-  Register value = (from() == kDouble) ? locs()->in(0).reg() : RBX;
+  Register value = (from() == kDoubleCid) ? locs()->in(0).reg() : RBX;
   Register result = locs()->out().reg();
 
-  const DeoptReasonId deopt_reason = (from() == kDouble) ?
+  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() == kDouble) {
+  if (from() == kDoubleCid) {
     __ testq(value, Immediate(kSmiTagMask));
     __ j(ZERO, deopt);  // Deoptimize if Smi.
-    __ CompareClassId(value, kDouble);
+    __ CompareClassId(value, kDoubleCid);
     __ j(NOT_EQUAL, deopt);  // Deoptimize if not Double.
     ASSERT(value == result);
     return;
   }
 
-  ASSERT(from() == kSmi);
+  ASSERT(from() == kSmiCid);
 
   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(vegorov): allocate box in the driver loop to avoid spilling.
   compiler->GenerateCall(instance_call()->token_pos(),
                          instance_call()->try_index(),
                          &label,
@@ skipping 20 matching lines @@
                                         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;
+      ic_data()->GetReceiverClassIdAt(0) == kSmiCid ?  &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()->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);
+    ASSERT(ic_data()->GetReceiverClassIdAt(0) == kSmiCid);
     const Function& target = Function::ZoneHandle(ic_data()->GetTargetAt(0));
     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 14 matching lines @@
   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(), kSmi) ||
-        ICDataWithBothClassIds(*ic_data(), kDouble)) {
+    if (ICDataWithBothClassIds(*ic_data(), kSmiCid) ||
+        ICDataWithBothClassIds(*ic_data(), kDoubleCid)) {
       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());
       summary->set_temp(0, Location::RequiresRegister());
       return summary;
     }
     if ((kind() == Token::kEQ) || (kind() == Token::kNE)) {
@@ skipping 17 matching lines @@
   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(), kSmi)) {
+    if (ICDataWithBothClassIds(*ic_data(), kSmiCid)) {
       EmitSmiComparisonOp(compiler, *locs(), kind(), this,
                           deopt_id(), token_pos(), try_index());
       return;
     }
-    if (ICDataWithBothClassIds(*ic_data(), kDouble)) {
+    if (ICDataWithBothClassIds(*ic_data(), kDoubleCid)) {
       EmitDoubleComparisonOp(compiler, *locs(), kind(), this,
                              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(),
                                  deopt_id(), token_pos(), try_index());
       return;
     }
@@ skipping 20 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