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

vm/flow_graph_compiler_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/flow_graph_compiler.h"
 
 #include "lib/error.h"
@@ skipping 246 matching lines @@
   const Register kClassIdReg = R10;
   __ LoadClassId(kClassIdReg, kInstanceReg);
   // If type is an interface, we can skip the class equality check.
   if (!type_class.is_interface()) {
     __ cmpl(kClassIdReg, Immediate(type_class.id()));
     __ j(EQUAL, is_instance_lbl);
   }
   // Bool interface can be implemented only by core class Bool.
   // (see ClassFinalizer::ResolveInterfaces for list of restricted interfaces).
   if (type.IsBoolInterface()) {
-    __ cmpl(kClassIdReg, Immediate(kBool));
+    __ cmpl(kClassIdReg, Immediate(kBoolCid));
     __ j(EQUAL, is_instance_lbl);
     __ jmp(is_not_instance_lbl);
     return false;
   }
   if (type.IsFunctionInterface()) {
     // Check if instance is a closure.
     const Immediate raw_null =
         Immediate(reinterpret_cast<intptr_t>(Object::null()));
     __ LoadClassById(R13, kClassIdReg);
     __ movq(R13, FieldAddress(R13, Class::signature_function_offset()));
@@ skipping 66 matching lines @@
     const TypeParameter& type_param = TypeParameter::Cast(type);
     // Load instantiator (or null) and instantiator type arguments on stack.
     __ movq(RDX, Address(RSP, 0));  // Get instantiator type arguments.
     // RDX: instantiator type arguments.
     // Check if type argument is Dynamic.
     __ cmpq(RDX, raw_null);
     __ j(EQUAL, is_instance_lbl);
     // Can handle only type arguments that are instances of TypeArguments.
     // (runtime checks canonicalize type arguments).
     Label fall_through;
-    __ CompareClassId(RDX, kTypeArguments);
+    __ CompareClassId(RDX, kTypeArgumentsCid);
     __ j(NOT_EQUAL, &fall_through);
     __ movq(RDI,
         FieldAddress(RDX, TypeArguments::type_at_offset(type_param.index())));
     // RDI: Concrete type of type.
     // Check if type argument is dynamic.
     __ CompareObject(RDI, Type::ZoneHandle(Type::DynamicType()));
     __ j(EQUAL,  is_instance_lbl);
     __ cmpq(RDI, raw_null);
     __ j(EQUAL,  is_instance_lbl);
     const Type& object_type = Type::ZoneHandle(Type::ObjectType());
@@ skipping 518 matching lines @@
   __ movq(RAX, raw_null);
   __ ret();
 }
 
 
 void FlowGraphCompiler::GenerateInlinedMathSqrt(Label* done) {
   Label smi_to_double, double_op, call_method;
   __ movq(RAX, Address(RSP, 0));
   __ testq(RAX, Immediate(kSmiTagMask));
   __ j(ZERO, &smi_to_double);
-  __ CompareClassId(RAX, kDouble);
+  __ CompareClassId(RAX, kDoubleCid);
   __ j(NOT_EQUAL, &call_method);
   __ movsd(XMM1, FieldAddress(RAX, Double::value_offset()));
   __ Bind(&double_op);
   __ sqrtsd(XMM0, XMM1);
   AssemblerMacros::TryAllocate(assembler_,
                                double_class_,
                                &call_method,
                                RAX);  // Result register.
   __ movsd(FieldAddress(RAX, Double::value_offset()), XMM0);
   __ Drop(1);
@@ skipping 156 matching lines @@
 }
 
 
 // Checks class id of instance against all 'class_ids'. Jump to 'deopt' label
 // if no match or instance is Smi.
 void FlowGraphCompiler::EmitClassChecksNoSmi(const ICData& ic_data,
                                              Register instance_reg,
                                              Register temp_reg,
                                              Label* deopt) {
   Label ok;
-  ASSERT(ic_data.GetReceiverClassIdAt(0) != kSmi);
+  ASSERT(ic_data.GetReceiverClassIdAt(0) != kSmiCid);
   __ testq(instance_reg, Immediate(kSmiTagMask));
   __ j(ZERO, deopt);
   Label is_ok;
   const intptr_t num_checks = ic_data.NumberOfChecks();
   const bool use_near_jump = num_checks < 5;
   __ LoadClassId(temp_reg, instance_reg);
   for (intptr_t i = 0; i < num_checks; i++) {
     __ cmpl(temp_reg, Immediate(ic_data.GetReceiverClassIdAt(i)));
     if (i == (num_checks - 1)) {
       __ j(NOT_EQUAL, deopt);
     } else {
       if (use_near_jump) {
         __ j(EQUAL, &is_ok, Assembler::kNearJump);
       } else {
         __ j(EQUAL, &is_ok);
       }
     }
   }
   __ Bind(&is_ok);
 }
 
 
 void FlowGraphCompiler::LoadDoubleOrSmiToXmm(XmmRegister result,
                                              Register reg,
                                              Register temp,
                                              Label* not_double_or_smi) {
   Label is_smi, done;
   __ testq(reg, Immediate(kSmiTagMask));
   __ j(ZERO, &is_smi);
-  __ CompareClassId(reg, kDouble);
+  __ CompareClassId(reg, kDoubleCid);
   __ j(NOT_EQUAL, not_double_or_smi);
   __ movsd(result, FieldAddress(reg, Double::value_offset()));
   __ jmp(&done);
   __ Bind(&is_smi);
   __ movq(temp, reg);
   __ SmiUntag(temp);
   __ cvtsi2sd(result, temp);
   __ Bind(&done);
 }
 
@@ skipping 104 matching lines @@
 void ParallelMoveResolver::Exchange(const Address& mem1, const Address& mem2) {
   __ Exchange(mem1, mem2);
 }
 
 
 #undef __
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64