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

vm/intrinsifier_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/intrinsifier.h"
 
 #include "vm/assembler.h"
@@ skipping 769 matching lines @@
   Label receiver_not_smi;
   __ Bind(&check_for_mint);
   __ movq(RAX, Address(RSP, + 2 * kWordSize));  // Receiver.
   __ testq(RAX, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, &receiver_not_smi);
 
   // Left (receiver) is Smi, return false if right is not Double.
   // Note that an instance of Mint or Bigint never contains a value that can be
   // represented by Smi.
   __ movq(RAX, Address(RSP, + 1 * kWordSize));
-  __ CompareClassId(RAX, kDouble);
+  __ CompareClassId(RAX, kDoubleCid);
   __ j(EQUAL, &fall_through);
   __ LoadObject(RAX, bool_false);
   __ ret();
 
   __ Bind(&receiver_not_smi);
   // RAX:: receiver.
-  __ CompareClassId(RAX, kMint);
+  __ CompareClassId(RAX, kMintCid);
   __ j(NOT_EQUAL, &fall_through);
   // Receiver is Mint, return false if right is Smi.
   __ movq(RAX, Address(RSP, + 1 * kWordSize));  // Right argument.
   __ testq(RAX, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, &fall_through);
   __ LoadObject(RAX, bool_false);  // Smi == Mint -> false.
   __ ret();
   // TODO(srdjan): Implement Mint == Mint comparison.
 
   __ Bind(&fall_through);
@@ skipping 44 matching lines @@
 
 // Check if the last argument is a double, jump to label 'is_smi' if smi
 // (easy to convert to double), otherwise jump to label 'not_double_smi',
 // Returns the last argument in RAX.
 static void TestLastArgumentIsDouble(Assembler* assembler,
                                      Label* is_smi,
                                      Label* not_double_smi) {
   __ movq(RAX, Address(RSP, + 1 * kWordSize));
   __ testq(RAX, Immediate(kSmiTagMask));
   __ j(ZERO, is_smi, Assembler::kNearJump);  // Jump if Smi.
-  __ CompareClassId(RAX, kDouble);
+  __ CompareClassId(RAX, kDoubleCid);
   __ j(NOT_EQUAL, not_double_smi, Assembler::kNearJump);
   // Fall through if double.
 }
 
 
 // Both arguments on stack, left argument is a double, right argument is of
 // unknown type. Return true or false object in RAX. Any NaN argument
 // returns false. Any non-double argument causes control flow to fall through
 // to the slow case (compiled method body).
 static bool CompareDoubles(Assembler* assembler, Condition true_condition) {
@@ skipping 401 matching lines @@
 bool Intrinsifier::String_charCodeAt(Assembler* assembler) {
   Label fall_through;
   __ movq(RCX, Address(RSP, + 1 * kWordSize));  // Index.
   __ movq(RAX, Address(RSP, + 2 * kWordSize));  // String.
   __ testq(RCX, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, &fall_through, Assembler::kNearJump);  // Non-smi index.
   // Range check.
   __ cmpq(RCX, FieldAddress(RAX, String::length_offset()));
   // Runtime throws exception.
   __ j(ABOVE_EQUAL, &fall_through, Assembler::kNearJump);
-  __ CompareClassId(RAX, kOneByteString);
+  __ CompareClassId(RAX, kOneByteStringCid);
   __ j(NOT_EQUAL, &fall_through);
   __ SmiUntag(RCX);
   __ movzxb(RAX, FieldAddress(RAX, RCX, TIMES_1, OneByteString::data_offset()));
   __ SmiTag(RAX);
   __ ret();
   __ Bind(&fall_through);
   return false;
 }
 
 
@@ skipping 25 matching lines @@
   __ LoadObject(RAX, bool_true);
   __ ret();
   return true;
 }
 
 #undef __
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64