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

vm/object.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/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
@@ skipping 31 matching lines @@
     "instead of showing the corresponding interface names (e.g. \"String\")");
 DECLARE_FLAG(bool, trace_compiler);
 DECLARE_FLAG(bool, enable_type_checks);
 
 static const char* kGetterPrefix = "get:";
 static const intptr_t kGetterPrefixLength = strlen(kGetterPrefix);
 static const char* kSetterPrefix = "set:";
 static const intptr_t kSetterPrefixLength = strlen(kSetterPrefix);
 
 cpp_vtable Object::handle_vtable_ = 0;
-cpp_vtable Object::builtin_vtables_[kNumPredefinedKinds] = { 0 };
+cpp_vtable Object::builtin_vtables_[kNumPredefinedCids] = { 0 };
 cpp_vtable Smi::handle_vtable_ = 0;
 
 // These are initialized to a value that will force a illegal memory access if
 // they are being used.
 #if defined(RAW_NULL)
 #error RAW_NULL should not be defined.
 #endif
 #define RAW_NULL kHeapObjectTag
 RawObject* Object::null_ = reinterpret_cast<RawInstance*>(RAW_NULL);
 RawInstance* Object::sentinel_ = reinterpret_cast<RawInstance*>(RAW_NULL);
@@ skipping 115 matching lines @@
   if (is_setter) {
     // Setters need to end with '='.
     const String& suffix = String::Handle(Symbols::Equals());
     return String::Concat(result, suffix);
   }
 
   return result.raw();
 }
 
 
-int Object::GetSingletonClassIndex(const RawClass* raw_class) {
-  ASSERT(raw_class->IsHeapObject());
-  if (raw_class == class_class()) {
-    return kClassClass;
-  } else if (raw_class == null_class()) {
-    return kNullClass;
-  } else if (raw_class == dynamic_class()) {
-    return kDynamicClass;
-  } else if (raw_class == void_class()) {
-    return kVoidClass;
-  } else if (raw_class == unresolved_class_class()) {
-    return kUnresolvedClassClass;
-  } else if (raw_class == type_class()) {
-    return kTypeClass;
-  } else if (raw_class == type_parameter_class()) {
-    return kTypeParameterClass;
-  } else if (raw_class == type_arguments_class()) {
-    return kTypeArgumentsClass;
-  } else if (raw_class == instantiated_type_arguments_class()) {
-    return kInstantiatedTypeArgumentsClass;
-  } else if (raw_class == function_class()) {
-    return kFunctionClass;
-  } else if (raw_class == field_class()) {
-    return kFieldClass;
-  } else if (raw_class == literal_token_class()) {
-    return kLiteralTokenClass;
-  } else if (raw_class == token_stream_class()) {
-    return kTokenStreamClass;
-  } else if (raw_class == script_class()) {
-    return kScriptClass;
-  } else if (raw_class == library_class()) {
-    return kLibraryClass;
-  } else if (raw_class == library_prefix_class()) {
-    return kLibraryPrefixClass;
-  } else if (raw_class == code_class()) {
-    return kCodeClass;
-  } else if (raw_class == instructions_class()) {
-    return kInstructionsClass;
-  } else if (raw_class == pc_descriptors_class()) {
-    return kPcDescriptorsClass;
-  } else if (raw_class == stackmap_class()) {
-    return kStackmapClass;
-  } else if (raw_class == var_descriptors_class()) {
-    return kLocalVarDescriptorsClass;
-  } else if (raw_class == exception_handlers_class()) {
-    return kExceptionHandlersClass;
-  } else if (raw_class == deopt_info_class()) {
-    return kDeoptInfoClass;
-  } else if (raw_class == context_class()) {
-    return kContextClass;
-  } else if (raw_class == context_scope_class()) {
-    return kContextScopeClass;
-  } else if (raw_class == icdata_class()) {
-    return kICDataClass;
-  } else if (raw_class == subtypetestcache_class()) {
-    return kSubtypeTestCacheClass;
-  } else if (raw_class == api_error_class()) {
-    return kApiErrorClass;
-  } else if (raw_class == language_error_class()) {
-    return kLanguageErrorClass;
-  } else if (raw_class == unhandled_exception_class()) {
-    return kUnhandledExceptionClass;
-  } else if (raw_class == unwind_error_class()) {
-    return kUnwindErrorClass;
-  }
-  return kInvalidIndex;
-}
-
-
-RawClass* Object::GetSingletonClass(int index) {
-  switch (index) {
-    case kClassClass: return class_class();
-    case kNullClass: return null_class();
-    case kDynamicClass: return dynamic_class();
-    case kVoidClass: return void_class();
-    case kUnresolvedClassClass: return unresolved_class_class();
-    case kTypeClass: return type_class();
-    case kTypeParameterClass: return type_parameter_class();
-    case kTypeArgumentsClass: return type_arguments_class();
-    case kInstantiatedTypeArgumentsClass:
-        return instantiated_type_arguments_class();
-    case kFunctionClass: return function_class();
-    case kFieldClass: return field_class();
-    case kLiteralTokenClass: return literal_token_class();
-    case kTokenStreamClass: return token_stream_class();
-    case kScriptClass: return script_class();
-    case kLibraryClass: return library_class();
-    case kLibraryPrefixClass: return library_prefix_class();
-    case kCodeClass: return code_class();
-    case kInstructionsClass: return instructions_class();
-    case kPcDescriptorsClass: return pc_descriptors_class();
-    case kStackmapClass: return stackmap_class();
-    case kLocalVarDescriptorsClass: return var_descriptors_class();
-    case kExceptionHandlersClass: return exception_handlers_class();
-    case kDeoptInfoClass: return deopt_info_class();
-    case kContextClass: return context_class();
-    case kContextScopeClass: return context_scope_class();
-    case kICDataClass: return icdata_class();
-    case kSubtypeTestCacheClass: return subtypetestcache_class();
-    case kApiErrorClass: return api_error_class();
-    case kLanguageErrorClass: return language_error_class();
-    case kUnhandledExceptionClass: return unhandled_exception_class();
-    case kUnwindErrorClass: return unwind_error_class();
-    default: break;
-  }
-  UNREACHABLE();
-  return reinterpret_cast<RawClass*>(kHeapObjectTag);  // return RAW_NULL.
-}
-
-
-const char* Object::GetSingletonClassName(int index) {
-  switch (index) {
-    case kClassClass: return "Class";
-    case kNullClass: return "Null";
-    case kDynamicClass: return "Dynamic";
-    case kVoidClass: return "void";
-    case kUnresolvedClassClass: return "UnresolvedClass";
-    case kTypeClass: return "Type";
-    case kTypeParameterClass: return "TypeParameter";
-    case kTypeArgumentsClass: return "TypeArguments";
-    case kInstantiatedTypeArgumentsClass: return "InstantiatedTypeArguments";
-    case kFunctionClass: return "Function";
-    case kFieldClass: return "Field";
-    case kLiteralTokenClass: return "LiteralToken";
-    case kTokenStreamClass: return "TokenStream";
-    case kScriptClass: return "Script";
-    case kLibraryClass: return "Library";
-    case kLibraryPrefixClass: return "LibraryPrefix";
-    case kCodeClass: return "Code";
-    case kInstructionsClass: return "Instructions";
-    case kPcDescriptorsClass: return "PcDescriptors";
-    case kStackmapClass: return "Stackmap";
-    case kLocalVarDescriptorsClass: return "LocalVarDescriptors";
-    case kExceptionHandlersClass: return "ExceptionHandlers";
-    case kDeoptInfoClass: return "DeoptInfo";
-    case kContextClass: return "Context";
-    case kContextScopeClass: return "ContextScope";
-    case kICDataClass: return "ICData";
-    case kSubtypeTestCacheClass: return "SubtypeTestCache";
-    case kApiErrorClass: return "ApiError";
-    case kLanguageErrorClass: return "LanguageError";
-    case kUnhandledExceptionClass: return "UnhandledException";
-    case kUnwindErrorClass: return "UnwindError";
+// TODO(asiva): Get rid of this function once we have predefined names for
+// the shared classes and set that up in the name field.
+const char* Object::GetSingletonClassName(intptr_t class_id) {
+  switch (class_id) {
+    case kClassCid: return "Class";
+    case kNullCid: return "Null";
+    case kDynamicCid: return "Dynamic";
+    case kVoidCid: return "void";
+    case kUnresolvedClassCid: return "UnresolvedClass";
+    case kTypeCid: return "Type";
+    case kTypeParameterCid: return "TypeParameter";
+    case kTypeArgumentsCid: return "TypeArguments";
+    case kInstantiatedTypeArgumentsCid: return "InstantiatedTypeArguments";
+    case kFunctionCid: return "Function";
+    case kFieldCid: return "Field";
+    case kLiteralTokenCid: return "LiteralToken";
+    case kTokenStreamCid: return "TokenStream";
+    case kScriptCid: return "Script";
+    case kLibraryCid: return "Library";
+    case kLibraryPrefixCid: return "LibraryPrefix";
+    case kCodeCid: return "Code";
+    case kInstructionsCid: return "Instructions";
+    case kPcDescriptorsCid: return "PcDescriptors";
+    case kStackmapCid: return "Stackmap";
+    case kLocalVarDescriptorsCid: return "LocalVarDescriptors";
+    case kExceptionHandlersCid: return "ExceptionHandlers";
+    case kContextCid: return "Context";
+    case kContextScopeCid: return "ContextScope";
+    case kICDataCid: return "ICData";
+    case kSubtypeTestCacheCid: return "SubtypeTestCache";
+    case kApiErrorCid: return "ApiError";
+    case kLanguageErrorCid: return "LanguageError";
+    case kUnhandledExceptionCid: return "UnhandledException";
+    case kUnwindErrorCid: return "UnwindError";
     default: break;
   }
   UNREACHABLE();
   return NULL;
 }
 
 
 void Object::InitOnce() {
   // TODO(iposva): NoGCScope needs to be added here.
   ASSERT(class_class() == null_);
   // Initialize the static vtable values.
   {
     Object fake_object;
     Smi fake_smi;
     Object::handle_vtable_ = fake_object.vtable();
     Smi::handle_vtable_ = fake_smi.vtable();
   }
 
   Isolate* isolate = Isolate::Current();
   Heap* heap = isolate->heap();
   // Allocate and initialize the null instance, except its class_ field.
   // 'null_' must be the first object allocated as it is used in allocation to
   // clear the object.
   {
     uword address = heap->Allocate(Instance::InstanceSize(), Heap::kOld);
     null_ = reinterpret_cast<RawInstance*>(address + kHeapObjectTag);
     // The call below is using 'null_' to initialize itself.
-    InitializeObject(address, kNullClassId, Instance::InstanceSize());
+    InitializeObject(address, kNullCid, Instance::InstanceSize());
   }
 
   // Initialize object_store empty array to null_ in order to be able to check
   // if the empty array was allocated (RAW_NULL is not available).
   isolate->object_store()->set_empty_array(Array::Handle());
 
   Class& cls = Class::Handle();
 
   // Allocate and initialize the class class.
   {
     intptr_t size = Class::InstanceSize();
     uword address = heap->Allocate(size, Heap::kOld);
     class_class_ = reinterpret_cast<RawClass*>(address + kHeapObjectTag);
-    InitializeObject(address, Class::kInstanceKind, size);
+    InitializeObject(address, Class::kClassId, size);
 
     Class fake;
     // Initialization from Class::New<Class>.
     // Directly set raw_ to break a circular dependency: SetRaw will attempt
     // to lookup class class in the class table where it is not registered yet.
     cls.raw_ = class_class_;
     cls.set_handle_vtable(fake.vtable());
     cls.set_instance_size(Class::InstanceSize());
     cls.set_next_field_offset(Class::InstanceSize());
-    cls.set_instance_kind(Class::kInstanceKind);
-    cls.set_id(Class::kInstanceKind);
+    cls.set_id(Class::kClassId);
     cls.raw_ptr()->is_const_ = false;
     cls.raw_ptr()->is_interface_ = false;
     cls.set_is_finalized();
     cls.raw_ptr()->type_arguments_instance_field_offset_ =
         Class::kNoTypeArguments;
     cls.raw_ptr()->num_native_fields_ = 0;
     cls.InitEmptyFields();
     isolate->class_table()->Register(cls);
   }
 
   // Allocate and initialize the null class.
-  cls = Class::New<Instance>(kNullClassId);
+  cls = Class::New<Instance>(kNullCid);
   cls.set_is_finalized();
   null_class_ = cls.raw();
 
   // Allocate and initialize the free list element class.
   cls = Class::New<FreeListElement::FakeInstance>(kFreeListElement);
   cls.set_is_finalized();
 
   // Allocate and initialize the sentinel values of Null class.
   {
     Instance& sentinel = Instance::Handle();
     sentinel ^=
-        Object::Allocate(kNullClassId, Instance::InstanceSize(), Heap::kOld);
+        Object::Allocate(kNullCid, Instance::InstanceSize(), Heap::kOld);
     sentinel_ = sentinel.raw();
 
     Instance& transition_sentinel = Instance::Handle();
     transition_sentinel ^=
-        Object::Allocate(kNullClassId, Instance::InstanceSize(), Heap::kOld);
+        Object::Allocate(kNullCid, Instance::InstanceSize(), Heap::kOld);
     transition_sentinel_ = transition_sentinel.raw();
   }
 
   // The interface "Dynamic" is not a VM internal class. It is the type class of
   // the "unknown type". For efficiency, we allocate it in the VM isolate.
   // Therefore, it cannot have a heap allocated name (the name is hard coded,
-  // see GetSingletonClassIndex) and its array fields cannot be set to the empty
+  // see GetSingletonClassName) and its array fields cannot be set to the empty
   // array, but remain null.
   //
   // TODO(turnidge): Once the empty array is allocated in the vm
   // isolate, use it here.
-  cls = Class::New<Instance>(kDynamicClassId);
+  cls = Class::New<Instance>(kDynamicCid);
   cls.set_is_finalized();
   cls.set_is_interface();
   dynamic_class_ = cls.raw();
 
   // Allocate the remaining VM internal classes.
   cls = Class::New<UnresolvedClass>();
   unresolved_class_class_ = cls.raw();
 
-  cls = Class::New<Instance>(kVoidClassId);
+  cls = Class::New<Instance>(kVoidCid);
   cls.set_is_finalized();
   void_class_ = cls.raw();
 
   cls = Class::New<Type>();
   type_class_ = cls.raw();
 
   cls = Class::New<TypeParameter>();
   type_parameter_class_ = cls.raw();
 
   cls = Class::New<TypeArguments>();
@@ skipping 70 matching lines @@
 
   ASSERT(class_class() != null_);
 
   // Pre-allocate the Array and OneByteString class in the vm isolate so that
   // we can create a symbol table and populate it with some frequently used
   // strings as symbols.
   cls = Class::New<Array>();
   isolate->object_store()->set_array_class(cls);
   cls = Class::New<OneByteString>();
   isolate->object_store()->set_one_byte_string_class(cls);
-
-  // TODO(asiva): Assign the names of shared classes instead of relying on the
-  // lookup switch in Object::GetSingletonClassName.
 }
 
 
 RawClass* Object::CreateAndRegisterInterface(const char* cname,
                                              const Script& script,
                                              const Library& lib) {
   const String& name = String::Handle(Symbols::New(cname));
   const Class& cls = Class::Handle(
       Class::NewInterface(name, script, Scanner::kDummyTokenIndex));
   lib.AddClass(cls);
@@ skipping 530 matching lines @@
   bool_value = Bool::New(false);
   object_store->set_false_value(bool_value);
 }
 
 
 void Object::Print() const {
   OS::Print("%s\n", ToCString());
 }
 
 
-void Object::InitializeObject(uword address, intptr_t index, intptr_t size) {
+void Object::InitializeObject(uword address, intptr_t class_id, intptr_t size) {
   // TODO(iposva): Get a proper halt instruction from the assembler which
   // would be needed here for code objects.
   uword initial_value = reinterpret_cast<uword>(null_);
   uword cur = address;
   uword end = address + size;
   while (cur < end) {
     *reinterpret_cast<uword*>(cur) = initial_value;
     cur += kWordSize;
   }
   uword tags = 0;
-  ASSERT(index != kIllegalObjectKind);
-  tags = RawObject::ClassIdTag::update(index, tags);
+  ASSERT(class_id != kIllegalCid);
+  tags = RawObject::ClassIdTag::update(class_id, tags);
   tags = RawObject::SizeTag::update(size, tags);
   reinterpret_cast<RawObject*>(address)->tags_ = tags;
 }
 
 
 RawObject* Object::Allocate(intptr_t cls_id,
                             intptr_t size,
                             Heap::Space space) {
   ASSERT(Utils::IsAligned(size, kObjectAlignment));
   Isolate* isolate = Isolate::Current();
@@ skipping 47 matching lines @@
   }
   return raw_obj;
 }
 
 
 RawString* Class::Name() const {
   if (raw_ptr()->name_ != String::null()) {
     return raw_ptr()->name_;
   }
   ASSERT(class_class() != Class::null());  // class_class_ should be set up.
-  intptr_t index = GetSingletonClassIndex(raw());
-  return Symbols::New(GetSingletonClassName(index));
+  return Symbols::New(GetSingletonClassName(raw_ptr()->id_));
 }
 
 
 RawString* Class::UserVisibleName() const {
   if (FLAG_show_internal_names) {
     return Name();
   }
   switch (id()) {
-    case kInteger:
-    case kSmi:
-    case kMint:
-    case kBigint:
+    case kIntegerCid:
+    case kSmiCid:
+    case kMintCid:
+    case kBigintCid:
       return Symbols::New("int");
-    case kDouble:
+    case kDoubleCid:
       return Symbols::New("double");
-    case kOneByteString:
-    case kTwoByteString:
-    case kFourByteString:
-    case kExternalOneByteString:
-    case kExternalTwoByteString:
-    case kExternalFourByteString:
+    case kOneByteStringCid:
+    case kTwoByteStringCid:
+    case kFourByteStringCid:
+    case kExternalOneByteStringCid:
+    case kExternalTwoByteStringCid:
+    case kExternalFourByteStringCid:
       return Symbols::New("String");
-    case kBool:
+    case kBoolCid:
       return Symbols::New("bool");
-    case kArray:
-    case kImmutableArray:
-    case kGrowableObjectArray:
+    case kArrayCid:
+    case kImmutableArrayCid:
+    case kGrowableObjectArrayCid:
       return Symbols::New("List");
-    case kInt8Array:
-    case kExternalInt8Array:
+    case kInt8ArrayCid:
+    case kExternalInt8ArrayCid:
       return Symbols::New("Int8List");
-    case kUint8Array:
-    case kExternalUint8Array:
+    case kUint8ArrayCid:
+    case kExternalUint8ArrayCid:
       return Symbols::New("Uint8List");
-    case kInt16Array:
-    case kExternalInt16Array:
+    case kInt16ArrayCid:
+    case kExternalInt16ArrayCid:
       return Symbols::New("Int16List");
-    case kUint16Array:
-    case kExternalUint16Array:
+    case kUint16ArrayCid:
+    case kExternalUint16ArrayCid:
       return Symbols::New("Uint16List");
-    case kInt32Array:
-    case kExternalInt32Array:
+    case kInt32ArrayCid:
+    case kExternalInt32ArrayCid:
       return Symbols::New("Int32List");
-    case kUint32Array:
-    case kExternalUint32Array:
+    case kUint32ArrayCid:
+    case kExternalUint32ArrayCid:
       return Symbols::New("Uint32List");
-    case kInt64Array:
-    case kExternalInt64Array:
+    case kInt64ArrayCid:
+    case kExternalInt64ArrayCid:
       return Symbols::New("Int64List");
-    case kUint64Array:
-    case kExternalUint64Array:
+    case kUint64ArrayCid:
+    case kExternalUint64ArrayCid:
       return Symbols::New("Uint64List");
-    case kFloat32Array:
-    case kExternalFloat32Array:
+    case kFloat32ArrayCid:
+    case kExternalFloat32ArrayCid:
       return Symbols::New("Float32List");
-    case kFloat64Array:
-    case kExternalFloat64Array:
+    case kFloat64ArrayCid:
+    case kExternalFloat64ArrayCid:
       return Symbols::New("Float64List");
     default:
       const String& name = String::Handle(Name());
       return IdentifierPrettyName(name);
   }
   UNREACHABLE();
 }
 
 
 RawType* Class::SignatureType() const {
@@ skipping 34 matching lines @@
   ASSERT(!signature_type.IsFinalized());
   return signature_type.raw();
 }
 
 
 template <class FakeObject>
 RawClass* Class::New() {
   ASSERT(Object::class_class() != Class::null());
   Class& result = Class::Handle();
   {
-    RawObject* raw = Object::Allocate(Class::kInstanceKind,
+    RawObject* raw = Object::Allocate(Class::kClassId,
                                       Class::InstanceSize(),
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
   }
   FakeObject fake;
   result.set_handle_vtable(fake.vtable());
   result.set_instance_size(FakeObject::InstanceSize());
   result.set_next_field_offset(FakeObject::InstanceSize());
-  result.set_instance_kind(FakeObject::kInstanceKind);
-  result.set_id((FakeObject::kInstanceKind != kInstance) ?
-                FakeObject::kInstanceKind : kIllegalObjectKind);
+  result.set_id((FakeObject::kClassId != kInstanceCid &&
+                 FakeObject::kClassId != kClosureCid) ?
+                FakeObject::kClassId : kIllegalCid);
   result.raw_ptr()->is_const_ = false;
   result.raw_ptr()->is_interface_ = false;
   // VM backed classes are almost ready: run checks and resolve class
   // references, but do not recompute size.
   result.raw_ptr()->class_state_ = RawClass::kPreFinalized;
   result.raw_ptr()->type_arguments_instance_field_offset_ = kNoTypeArguments;
   result.raw_ptr()->num_native_fields_ = 0;
   result.raw_ptr()->token_pos_ = Scanner::kDummyTokenIndex;
   result.InitEmptyFields();
   Isolate::Current()->class_table()->Register(result);
@@ skipping 304 matching lines @@
   // The value of static fields is already initialized to null.
   StorePointer(&raw_ptr()->fields_, value.raw());
 }
 
 
 template <class FakeInstance>
 RawClass* Class::New(intptr_t index) {
   ASSERT(Object::class_class() != Class::null());
   Class& result = Class::Handle();
   {
-    RawObject* raw = Object::Allocate(Class::kInstanceKind,
+    RawObject* raw = Object::Allocate(Class::kClassId,
                                       Class::InstanceSize(),
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
   }
   FakeInstance fake;
   ASSERT(fake.IsInstance());
   result.set_handle_vtable(fake.vtable());
   result.set_instance_size(FakeInstance::InstanceSize());
   result.set_next_field_offset(FakeInstance::InstanceSize());
-  result.set_instance_kind(FakeInstance::kInstanceKind);
   result.set_id(index);
   result.raw_ptr()->is_const_ = false;
   result.raw_ptr()->is_interface_ = false;
   result.raw_ptr()->class_state_ = RawClass::kAllocated;
   result.raw_ptr()->type_arguments_instance_field_offset_ = kNoTypeArguments;
   result.raw_ptr()->num_native_fields_ = 0;
   result.InitEmptyFields();
   Isolate::Current()->class_table()->Register(result);
   return result.raw();
 }
 
 
 template <class FakeInstance>
 RawClass* Class::New(const String& name,
                      const Script& script,
                      intptr_t token_pos) {
-  Class& result = Class::Handle(New<FakeInstance>(kIllegalObjectKind));
+  Class& result = Class::Handle(New<FakeInstance>(kIllegalCid));
   result.set_name(name);
   result.set_script(script);
   result.set_token_pos(token_pos);
   return result.raw();
 }
 
 
 RawClass* Class::New(const String& name,
                      const Script& script,
                      intptr_t token_pos) {
@@ skipping 60 matching lines @@
   // Cache the signature type as the first canonicalized type in result.
   const Type& signature_type = Type::Handle(result.SignatureType());
   ASSERT(!signature_type.IsFinalized());
   const Array& new_canonical_types = Array::Handle(Array::New(1, Heap::kOld));
   new_canonical_types.SetAt(0, signature_type);
   result.set_canonical_types(new_canonical_types);
   return result.raw();
 }
 
 
-RawClass* Class::GetClass(ObjectKind kind) {
-  ObjectStore* object_store = Isolate::Current()->object_store();
-  switch (kind) {
-    case kInteger:
-      ASSERT(object_store->integer_implementation_class() != Class::null());
-      return object_store->integer_implementation_class();
-    case kSmi:
-      ASSERT(object_store->smi_class() != Class::null());
-      return object_store->smi_class();
-    case kMint:
-      ASSERT(object_store->mint_class() != Class::null());
-      return object_store->mint_class();
-    case kBigint:
-      ASSERT(object_store->bigint_class() != Class::null());
-      return object_store->bigint_class();
-    case kDouble:
-      ASSERT(object_store->double_class() != Class::null());
-      return object_store->double_class();
-    case kOneByteString:
-      ASSERT(object_store->one_byte_string_class() != Class::null());
-      return object_store->one_byte_string_class();
-    case kTwoByteString:
-      ASSERT(object_store->two_byte_string_class() != Class::null());
-      return object_store->two_byte_string_class();
-    case kFourByteString:
-      ASSERT(object_store->four_byte_string_class() != Class::null());
-      return object_store->four_byte_string_class();
-    case kExternalOneByteString:
-      ASSERT(object_store->external_one_byte_string_class() != Class::null());
-      return object_store->external_one_byte_string_class();
-    case kExternalTwoByteString:
-      ASSERT(object_store->external_two_byte_string_class() != Class::null());
-      return object_store->external_two_byte_string_class();
-    case kExternalFourByteString:
-      ASSERT(object_store->external_four_byte_string_class() != Class::null());
-      return object_store->external_four_byte_string_class();
-    case kBool:
-      ASSERT(object_store->bool_class() != Class::null());
-      return object_store->bool_class();
-    case kArray:
-      ASSERT(object_store->array_class() != Class::null());
-      return object_store->array_class();
-    case kImmutableArray:
-      ASSERT(object_store->immutable_array_class() != Class::null());
-      return object_store->immutable_array_class();
-    case kGrowableObjectArray:
-      ASSERT(object_store->growable_object_array_class() != Class::null());
-      return object_store->growable_object_array_class();
-    case kInt8Array:
-      ASSERT(object_store->int8_array_class() != Class::null());
-      return object_store->int8_array_class();
-    case kUint8Array:
-      ASSERT(object_store->uint8_array_class() != Class::null());
-      return object_store->uint8_array_class();
-    case kInt16Array:
-      ASSERT(object_store->int16_array_class() != Class::null());
-      return object_store->int16_array_class();
-    case kUint16Array:
-      ASSERT(object_store->uint16_array_class() != Class::null());
-      return object_store->uint16_array_class();
-    case kInt32Array:
-      ASSERT(object_store->int32_array_class() != Class::null());
-      return object_store->int32_array_class();
-    case kUint32Array:
-      ASSERT(object_store->uint32_array_class() != Class::null());
-      return object_store->uint32_array_class();
-    case kInt64Array:
-      ASSERT(object_store->int64_array_class() != Class::null());
-      return object_store->int64_array_class();
-    case kUint64Array:
-      ASSERT(object_store->uint64_array_class() != Class::null());
-      return object_store->uint64_array_class();
-    case kFloat32Array:
-      ASSERT(object_store->float32_array_class() != Class::null());
-      return object_store->float32_array_class();
-    case kFloat64Array:
-      ASSERT(object_store->float64_array_class() != Class::null());
-      return object_store->float64_array_class();
-    case kExternalInt8Array:
-      ASSERT(object_store->external_int8_array_class() != Class::null());
-      return object_store->external_int8_array_class();
-    case kExternalUint8Array:
-      ASSERT(object_store->external_uint8_array_class() != Class::null());
-      return object_store->external_uint8_array_class();
-    case kExternalInt16Array:
-      ASSERT(object_store->external_int16_array_class() != Class::null());
-      return object_store->external_int16_array_class();
-    case kExternalUint16Array:
-      ASSERT(object_store->external_uint16_array_class() != Class::null());
-      return object_store->external_uint16_array_class();
-    case kExternalInt32Array:
-      ASSERT(object_store->external_int32_array_class() != Class::null());
-      return object_store->external_int32_array_class();
-    case kExternalUint32Array:
-      ASSERT(object_store->external_uint32_array_class() != Class::null());
-      return object_store->external_uint32_array_class();
-    case kExternalInt64Array:
-      ASSERT(object_store->external_int64_array_class() != Class::null());
-      return object_store->external_int64_array_class();
-    case kExternalUint64Array:
-      ASSERT(object_store->external_uint64_array_class() != Class::null());
-      return object_store->external_uint64_array_class();
-    case kExternalFloat32Array:
-      ASSERT(object_store->external_float32_array_class() != Class::null());
-      return object_store->external_float32_array_class();
-    case kExternalFloat64Array:
-      ASSERT(object_store->external_float64_array_class() != Class::null());
-      return object_store->external_float64_array_class();
-    case kStacktrace:
-      ASSERT(object_store->stacktrace_class() != Class::null());
-      return object_store->stacktrace_class();
-    case kJSRegExp:
-      ASSERT(object_store->jsregexp_class() != Class::null());
-      return object_store->jsregexp_class();
-    case kClosure:
+RawClass* Class::GetClass(intptr_t class_id, bool is_signature_class) {
+  if (class_id >= kIntegerCid && class_id <= kJSRegExpCid) {
+    return Isolate::Current()->class_table()->At(class_id);
+  }
+  if (class_id >= kNumPredefinedCids) {
+    if (is_signature_class) {
       return Class::New<Closure>();
-    case kInstance:
-      return Class::New<Instance>();
-    default:
-      OS::Print("Class::GetClass kind unknown: %d\n", kind);
-      UNREACHABLE();
+    }
+    return Class::New<Instance>();
   }
+  OS::Print("Class::GetClass id unknown: %d\n", class_id);
+  UNREACHABLE();
   return Class::null();
 }
 
 
 RawClass* Class::NewNativeWrapper(Library* library,
                                   const String& name,
                                   int field_count) {
   Class& cls = Class::Handle(library->LookupClass(name));
   if (cls.IsNull()) {
     cls = New<Instance>(name, Script::Handle(), Scanner::kDummyTokenIndex);
@@ skipping 472 matching lines @@
   const UnresolvedClass& type = UnresolvedClass::Handle(UnresolvedClass::New());
   type.set_library_prefix(library_prefix);
   type.set_ident(ident);
   type.set_token_pos(token_pos);
   return type.raw();
 }
 
 
 RawUnresolvedClass* UnresolvedClass::New() {
   ASSERT(Object::unresolved_class_class() != Class::null());
-  RawObject* raw = Object::Allocate(UnresolvedClass::kInstanceKind,
+  RawObject* raw = Object::Allocate(UnresolvedClass::kClassId,
                                     UnresolvedClass::InstanceSize(),
                                     Heap::kOld);
   return reinterpret_cast<RawUnresolvedClass*>(raw);
 }
 
 
 void UnresolvedClass::set_token_pos(intptr_t token_pos) const {
   ASSERT(token_pos >= 0);
   raw_ptr()->token_pos_ = token_pos;
 }
@@ skipping 628 matching lines @@
 }
 
 
 void Type::set_arguments(const AbstractTypeArguments& value) const {
   StorePointer(&raw_ptr()->arguments_, value.raw());
 }
 
 
 RawType* Type::New(Heap::Space space) {
   ASSERT(Object::type_class() != Class::null());
-  RawObject* raw = Object::Allocate(Type::kInstanceKind,
+  RawObject* raw = Object::Allocate(Type::kClassId,
                                     Type::InstanceSize(),
                                     space);
   return reinterpret_cast<RawType*>(raw);
 }
 
 
 RawType* Type::New(const Object& clazz,
                    const AbstractTypeArguments& arguments,
                    intptr_t token_pos,
                    Heap::Space space) {
@@ skipping 138 matching lines @@
   ASSERT(IsFinalized());
   if (instantiator_type_arguments.IsNull()) {
     return Type::DynamicType();
   }
   return instantiator_type_arguments.TypeAt(index());
 }
 
 
 RawTypeParameter* TypeParameter::New() {
   ASSERT(Object::type_parameter_class() != Class::null());
-  RawObject* raw = Object::Allocate(TypeParameter::kInstanceKind,
+  RawObject* raw = Object::Allocate(TypeParameter::kClassId,
                                     TypeParameter::InstanceSize(),
                                     Heap::kOld);
   return reinterpret_cast<RawTypeParameter*>(raw);
 }
 
 
 RawTypeParameter* TypeParameter::New(const Class& parameterized_class,
                                      intptr_t index,
                                      const String& name,
                                      const AbstractType& bound,
@@ skipping 402 matching lines @@
 }
 
 
 RawTypeArguments* TypeArguments::New(intptr_t len, Heap::Space space) {
   if (len < 0 || len > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in TypeArguments::New: invalid len %ld\n", len);
   }
   TypeArguments& result = TypeArguments::Handle();
   {
-    RawObject* raw = Object::Allocate(TypeArguments::kInstanceKind,
+    RawObject* raw = Object::Allocate(TypeArguments::kClassId,
                                       TypeArguments::InstanceSize(len),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
     // Length must be set before we start storing into the array.
     result.SetLength(len);
   }
   return result.raw();
 }
 
@@ skipping 99 matching lines @@
 
 
 void InstantiatedTypeArguments::set_instantiator_type_arguments(
     const AbstractTypeArguments& value) const {
   StorePointer(&raw_ptr()->instantiator_type_arguments_, value.raw());
 }
 
 
 RawInstantiatedTypeArguments* InstantiatedTypeArguments::New() {
   ASSERT(Object::instantiated_type_arguments_class() != Class::null());
-  RawObject* raw = Object::Allocate(InstantiatedTypeArguments::kInstanceKind,
+  RawObject* raw = Object::Allocate(InstantiatedTypeArguments::kClassId,
                                     InstantiatedTypeArguments::InstanceSize(),
                                     Heap::kNew);
   return reinterpret_cast<RawInstantiatedTypeArguments*>(raw);
 }
 
 
 RawInstantiatedTypeArguments* InstantiatedTypeArguments::New(
     const AbstractTypeArguments& uninstantiated_type_arguments,
     const AbstractTypeArguments& instantiator_type_arguments) {
   const InstantiatedTypeArguments& result =
@@ skipping 507 matching lines @@
   if (!IsClosureFunction()) {
     return false;
   }
   const Function& parent = Function::Handle(parent_function());
   return parent.raw_ptr()->implicit_closure_function_ == raw();
 }
 
 
 RawFunction* Function::New() {
   ASSERT(Object::function_class() != Class::null());
-  RawObject* raw = Object::Allocate(Function::kInstanceKind,
+  RawObject* raw = Object::Allocate(Function::kClassId,
                                     Function::InstanceSize(),
                                     Heap::kOld);
   return reinterpret_cast<RawFunction*>(raw);
 }
 
 
 RawFunction* Function::New(const String& name,
                            RawFunction::Kind kind,
                            bool is_static,
                            bool is_const,
@@ skipping 383 matching lines @@
 
 
 void Field::set_type(const AbstractType& value) const {
   ASSERT(!value.IsNull());
   StorePointer(&raw_ptr()->type_, value.raw());
 }
 
 
 RawField* Field::New() {
   ASSERT(Object::field_class() != Class::null());
-  RawObject* raw = Object::Allocate(Field::kInstanceKind,
+  RawObject* raw = Object::Allocate(Field::kClassId,
                                     Field::InstanceSize(),
                                     Heap::kOld);
   return reinterpret_cast<RawField*>(raw);
 }
 
 
 RawField* Field::New(const String& name,
                      bool is_static,
                      bool is_final,
                      bool is_const,
@@ skipping 45 matching lines @@
 }
 
 
 void LiteralToken::set_value(const Object& value) const {
   StorePointer(&raw_ptr()->value_, value.raw());
 }
 
 
 RawLiteralToken* LiteralToken::New() {
   ASSERT(Object::literal_token_class() != Class::null());
-  RawObject* raw = Object::Allocate(LiteralToken::kInstanceKind,
+  RawObject* raw = Object::Allocate(LiteralToken::kClassId,
                                     LiteralToken::InstanceSize(),
                                     Heap::kOld);
   return reinterpret_cast<RawLiteralToken*>(raw);
 }
 
 
 RawLiteralToken* LiteralToken::New(Token::Kind kind, const String& literal) {
   const LiteralToken& result = LiteralToken::Handle(LiteralToken::New());
   result.set_kind(kind);
   result.set_literal(literal);
@@ skipping 165 matching lines @@
 
 
 RawTokenStream* TokenStream::New(intptr_t len) {
   ASSERT(Object::token_stream_class() != Class::null());
   if (len < 0 || len > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in TokenStream::New: invalid len %ld\n", len);
   }
   TokenStream& result = TokenStream::Handle();
   {
-    RawObject* raw = Object::Allocate(TokenStream::kInstanceKind,
+    RawObject* raw = Object::Allocate(TokenStream::kClassId,
                                       TokenStream::InstanceSize(len),
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
     result.SetLength(len);
   }
   return result.raw();
 }
 
 
@@ skipping 476 matching lines @@
   if ((snippet_start != -1) && (snippet_end != -1)) {
     snippet =
         String::SubString(src, snippet_start, snippet_end - snippet_start);
   }
   return snippet.raw();
 }
 
 
 RawScript* Script::New() {
   ASSERT(Object::script_class() != Class::null());
-  RawObject* raw = Object::Allocate(Script::kInstanceKind,
+  RawObject* raw = Object::Allocate(Script::kClassId,
                                     Script::InstanceSize(),
                                     Heap::kOld);
   return reinterpret_cast<RawScript*>(raw);
 }
 
 
 RawScript* Script::New(const String& url,
                        const String& source,
                        RawScript::Kind kind) {
   const Script& result = Script::Handle(Script::New());
@@ skipping 804 matching lines @@
 void Library::InitImportedIntoList() const {
   const Array& imported_into =
       Array::Handle(Array::New(kInitialImportedIntoCapacity, Heap::kOld));
   StorePointer(&raw_ptr()->imported_into_, imported_into.raw());
   raw_ptr()->num_imported_into_ = 0;
 }
 
 
 RawLibrary* Library::New() {
   ASSERT(Object::library_class() != Class::null());
-  RawObject* raw = Object::Allocate(Library::kInstanceKind,
+  RawObject* raw = Object::Allocate(Library::kClassId,
                                     Library::InstanceSize(),
                                     Heap::kOld);
   return reinterpret_cast<RawLibrary*>(raw);
 }
 
 
 RawLibrary* Library::NewLibraryHelper(const String& url,
                                       bool import_core_lib) {
   const Library& result = Library::Handle(Library::New());
   result.StorePointer(&result.raw_ptr()->name_, url.raw());
@@ skipping 306 matching lines @@
     if (!resolved_class.IsNull()) {
       return resolved_class.raw();
     }
   }
   return Class::null();
 }
 
 
 RawLibraryPrefix* LibraryPrefix::New() {
   ASSERT(Object::library_prefix_class() != Class::null());
-  RawObject* raw = Object::Allocate(LibraryPrefix::kInstanceKind,
+  RawObject* raw = Object::Allocate(LibraryPrefix::kClassId,
                                     LibraryPrefix::InstanceSize(),
                                     Heap::kOld);
   return reinterpret_cast<RawLibraryPrefix*>(raw);
 }
 
 
 RawLibraryPrefix* LibraryPrefix::New(const String& name, const Library& lib) {
   const LibraryPrefix& result = LibraryPrefix::Handle(LibraryPrefix::New());
   result.set_name(name);
   result.set_num_libs(0);
@@ skipping 111 matching lines @@
 
 RawInstructions* Instructions::New(intptr_t size) {
   ASSERT(Object::instructions_class() != Class::null());
   if (size < 0 || size > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in Instructions::New: invalid size %ld\n", size);
   }
   Instructions& result = Instructions::Handle();
   {
     uword aligned_size = Instructions::InstanceSize(size);
-    RawObject* raw = Object::Allocate(Instructions::kInstanceKind,
+    RawObject* raw = Object::Allocate(Instructions::kClassId,
                                       aligned_size,
                                       Heap::kCode);
     NoGCScope no_gc;
     // TODO(iposva): Remove premarking once old and code spaces are merged.
     raw->SetMarkBit();
     result ^= raw;
     result.set_size(size);
   }
   return result.raw();
 }
@@ skipping 76 matching lines @@
 RawPcDescriptors* PcDescriptors::New(intptr_t num_descriptors) {
   ASSERT(Object::pc_descriptors_class() != Class::null());
   if (num_descriptors < 0 || num_descriptors > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in PcDescriptors::New: invalid num_descriptors %ld\n",
            num_descriptors);
   }
   PcDescriptors& result = PcDescriptors::Handle();
   {
     uword size = PcDescriptors::InstanceSize(num_descriptors);
-    RawObject* raw = Object::Allocate(PcDescriptors::kInstanceKind,
+    RawObject* raw = Object::Allocate(PcDescriptors::kClassId,
                                       size,
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
     result.SetLength(num_descriptors);
   }
   return result.raw();
 }
 
 
@@ skipping 114 matching lines @@
   ASSERT(bmap != NULL);
   Stackmap& result = Stackmap::Handle();
   intptr_t size = bmap->SizeInBytes();
   if (size < 0 || size > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in PcDescriptors::New: invalid size %ld\n", size);
   }
   {
     // Stackmap data objects are associated with a code object, allocate them
     // in old generation.
-    RawObject* raw = Object::Allocate(Stackmap::kInstanceKind,
+    RawObject* raw = Object::Allocate(Stackmap::kClassId,
                                       Stackmap::InstanceSize(size),
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
     result.set_bitmap_size_in_bytes(size);
   }
   result.SetPC(pc_offset);
   intptr_t bound = bmap->SizeInBits();
   for (intptr_t i = 0; i < bound; i++) {
     result.SetBit(i, bmap->Get(i));
@@ skipping 74 matching lines @@
 RawLocalVarDescriptors* LocalVarDescriptors::New(intptr_t num_variables) {
   ASSERT(Object::var_descriptors_class() != Class::null());
   if (num_variables < 0 || num_variables > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in LocalVarDescriptors::New: "
            "invalid num_variables %ld\n", num_variables);
   }
   LocalVarDescriptors& result = LocalVarDescriptors::Handle();
   {
     uword size = LocalVarDescriptors::InstanceSize(num_variables);
-    RawObject* raw = Object::Allocate(LocalVarDescriptors::kInstanceKind,
+    RawObject* raw = Object::Allocate(LocalVarDescriptors::kClassId,
                                       size,
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
     result.raw_ptr()->length_ = num_variables;
   }
   const Array& names = Array::Handle(Array::New(num_variables, Heap::kOld));
   result.raw_ptr()->names_ = names.raw();
   return result.raw();
 }
@@ skipping 40 matching lines @@
 RawExceptionHandlers* ExceptionHandlers::New(intptr_t num_handlers) {
   ASSERT(Object::exception_handlers_class() != Class::null());
   if (num_handlers < 0 || num_handlers > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in ExceptionHandlers::New: invalid num_handlers %ld\n",
            num_handlers);
   }
   ExceptionHandlers& result = ExceptionHandlers::Handle();
   {
     uword size = ExceptionHandlers::InstanceSize(num_handlers);
-    RawObject* raw = Object::Allocate(ExceptionHandlers::kInstanceKind,
+    RawObject* raw = Object::Allocate(ExceptionHandlers::kClassId,
                                       size,
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
     result.SetLength(num_handlers);
   }
   return result.raw();
 }
 
 
@@ skipping 63 matching lines @@
   }
   return buffer;
 }
 
 
 RawDeoptInfo* DeoptInfo::New(intptr_t num_commands) {
   ASSERT(Object::deopt_info_class() != Class::null());
   DeoptInfo& result = DeoptInfo::Handle();
   {
     uword size = DeoptInfo::InstanceSize(num_commands);
-    RawObject* raw = Object::Allocate(DeoptInfo::kInstanceKind,
+    RawObject* raw = Object::Allocate(DeoptInfo::kClassId,
                                       size,
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
     result.SetLength(num_commands);
   }
   return result.raw();
 }
 
 
@@ skipping 92 matching lines @@
 RawCode* Code::New(intptr_t pointer_offsets_length) {
   if (pointer_offsets_length < 0 || pointer_offsets_length > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in Code::New: invalid pointer_offsets_length %ld\n",
            pointer_offsets_length);
   }
   ASSERT(Object::code_class() != Class::null());
   Code& result = Code::Handle();
   {
     uword size = Code::InstanceSize(pointer_offsets_length);
-    RawObject* raw = Object::Allocate(Code::kInstanceKind, size, Heap::kOld);
+    RawObject* raw = Object::Allocate(Code::kClassId, size, Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
     result.set_pointer_offsets_length(pointer_offsets_length);
     result.set_is_optimized(false);
     result.set_comments(Comments::New(0));
   }
   return result.raw();
 }
 
 
@@ skipping 217 matching lines @@
   ASSERT(num_variables >= 0);
   ASSERT(Object::context_class() != Class::null());
 
   if (num_variables < 0 || num_variables > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in Context::New: invalid num_variables %ld\n",
            num_variables);
   }
   Context& result = Context::Handle();
   {
-    RawObject* raw = Object::Allocate(Context::kInstanceKind,
+    RawObject* raw = Object::Allocate(Context::kClassId,
                                       Context::InstanceSize(num_variables),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
     result.set_num_variables(num_variables);
   }
   result.set_isolate(Isolate::Current());
   return result.raw();
 }
 
 
 const char* Context::ToCString() const {
   return "Context";
 }
 
 
 RawContextScope* ContextScope::New(intptr_t num_variables) {
   ASSERT(Object::context_scope_class() != Class::null());
   if (num_variables < 0 || num_variables > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in ContextScope::New: invalid num_variables %ld\n",
            num_variables);
   }
   intptr_t size = ContextScope::InstanceSize(num_variables);
   ContextScope& result = ContextScope::Handle();
   {
-    RawObject* raw = Object::Allocate(ContextScope::kInstanceKind,
+    RawObject* raw = Object::Allocate(ContextScope::kClassId,
                                       size,
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
     result.set_num_variables(num_variables);
   }
   return result.raw();
 }
 
 
@@ skipping 106 matching lines @@
 }
 
 
 intptr_t ICData::NumberOfChecks() const {
   // Do not count the sentinel;
   return (Array::Handle(ic_data()).Length() / TestEntryLength()) - 1;
 }
 
 
 void ICData::WriteSentinel() const {
-  const Smi& sentinel_value = Smi::Handle(Smi::New(kIllegalObjectKind));
+  const Smi& sentinel_value = Smi::Handle(Smi::New(kIllegalCid));
   const Array& data = Array::Handle(ic_data());
   for (intptr_t i = 1; i <= TestEntryLength(); i++) {
     data.SetAt(data.Length() - i, sentinel_value);
   }
 }
 
 
 void ICData::AddCheck(const GrowableArray<intptr_t>& class_ids,
                       const Function& target) const {
   ASSERT(num_args_tested() > 1);  // Otherwise use 'AddReceiverCheck'.
   ASSERT(class_ids.length() == num_args_tested());
   const intptr_t old_num = NumberOfChecks();
   Array& data = Array::Handle(ic_data());
   const intptr_t new_len = data.Length() + TestEntryLength();
   data = Array::Grow(data, new_len, Heap::kOld);
   set_ic_data(data);
   WriteSentinel();
   intptr_t data_pos = old_num * TestEntryLength();
   for (intptr_t i = 0; i < class_ids.length(); i++) {
-    // kIllegalObjectKind is used as terminating value, do not add it.
-    ASSERT(class_ids[i] != kIllegalObjectKind);
+    // kIllegalCid is used as terminating value, do not add it.
+    ASSERT(class_ids[i] != kIllegalCid);
     data.SetAt(data_pos++, Smi::Handle(Smi::New(class_ids[i])));
   }
   ASSERT(!target.IsNull());
   data.SetAt(data_pos, target);
 }
 
 
 void ICData::AddReceiverCheck(intptr_t receiver_class_id,
                               const Function& target) const {
   ASSERT(num_args_tested() == 1);  // Otherwise use 'AddCheck'.
-  ASSERT(receiver_class_id != kIllegalObjectKind);
+  ASSERT(receiver_class_id != kIllegalCid);
   ASSERT(!target.IsNull());
 
   const intptr_t old_num = NumberOfChecks();
   Array& data = Array::Handle(ic_data());
   const intptr_t new_len = data.Length() + TestEntryLength();
   data = Array::Grow(data, new_len, Heap::kOld);
   set_ic_data(data);
   WriteSentinel();
   intptr_t data_pos = old_num * TestEntryLength();
-  if ((receiver_class_id == kSmi) && (data_pos > 0)) {
-    // Instert kSmi in position 0.
+  if ((receiver_class_id == kSmiCid) && (data_pos > 0)) {
+    // Instert kSmiCid in position 0.
     const intptr_t zero_class_id = GetReceiverClassIdAt(0);
-    ASSERT(zero_class_id != kSmi);  // Simple duplicate entry check.
+    ASSERT(zero_class_id != kSmiCid);  // Simple duplicate entry check.
     const Function& zero_target = Function::Handle(GetTargetAt(0));
     data.SetAt(0, Smi::Handle(Smi::New(receiver_class_id)));
     data.SetAt(1, target);
     data.SetAt(data_pos, Smi::Handle(Smi::New(zero_class_id)));
     data.SetAt(data_pos + 1, zero_target);
   } else {
     data.SetAt(data_pos, Smi::Handle(Smi::New(receiver_class_id)));
     data.SetAt(data_pos + 1, target);
   }
 }
@@ skipping 92 matching lines @@
 
 RawICData* ICData::New(const Function& function,
                        const String& target_name,
                        intptr_t deopt_id,
                        intptr_t num_args_tested) {
   ASSERT(Object::icdata_class() != Class::null());
   ASSERT(num_args_tested > 0);
   ICData& result = ICData::Handle();
   {
     // IC data objects are long living objects, allocate them in old generation.
-    RawObject* raw = Object::Allocate(ICData::kInstanceKind,
+    RawObject* raw = Object::Allocate(ICData::kClassId,
                                       ICData::InstanceSize(),
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
   }
   result.set_function(function);
   result.set_target_name(target_name);
   result.set_deopt_id(deopt_id);
   result.set_num_args_tested(num_args_tested);
   // Number of array elements in one test entry (num_args_tested + 1)
   intptr_t len = result.TestEntryLength();
   // IC data array must be null terminated (sentinel entry).
   const Array& ic_data = Array::Handle(Array::New(len, Heap::kOld));
   result.set_ic_data(ic_data);
   result.WriteSentinel();
   return result.raw();
 }
 
 
 RawSubtypeTestCache* SubtypeTestCache::New() {
   ASSERT(Object::subtypetestcache_class() != Class::null());
   SubtypeTestCache& result = SubtypeTestCache::Handle();
   {
     // SubtypeTestCache objects are long living objects, allocate them in the
     // old generation.
-    RawObject* raw = Object::Allocate(SubtypeTestCache::kInstanceKind,
+    RawObject* raw = Object::Allocate(SubtypeTestCache::kClassId,
                                       SubtypeTestCache::InstanceSize(),
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
   }
   const Array& cache = Array::Handle(Array::New(kTestEntryLength));
   result.set_cache(cache);
   return result.raw();
 }
 
@@ skipping 62 matching lines @@
   // Error is an abstract class.  We should never reach here.
   UNREACHABLE();
   return "Error";
 }
 
 
 RawApiError* ApiError::New(const String& message, Heap::Space space) {
   ASSERT(Object::api_error_class() != Class::null());
   ApiError& result = ApiError::Handle();
   {
-    RawObject* raw = Object::Allocate(ApiError::kInstanceKind,
+    RawObject* raw = Object::Allocate(ApiError::kClassId,
                                       ApiError::InstanceSize(),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
   }
   result.set_message(message);
   return result.raw();
 }
 
 
@@ skipping 10 matching lines @@
 
 const char* ApiError::ToCString() const {
   return "ApiError";
 }
 
 
 RawLanguageError* LanguageError::New(const String& message, Heap::Space space) {
   ASSERT(Object::language_error_class() != Class::null());
   LanguageError& result = LanguageError::Handle();
   {
-    RawObject* raw = Object::Allocate(LanguageError::kInstanceKind,
+    RawObject* raw = Object::Allocate(LanguageError::kClassId,
                                       LanguageError::InstanceSize(),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
   }
   result.set_message(message);
   return result.raw();
 }
 
 
@@ skipping 12 matching lines @@
   return "LanguageError";
 }
 
 
 RawUnhandledException* UnhandledException::New(const Instance& exception,
                                                const Instance& stacktrace,
                                                Heap::Space space) {
   ASSERT(Object::unhandled_exception_class() != Class::null());
   UnhandledException& result = UnhandledException::Handle();
   {
-    RawObject* raw = Object::Allocate(UnhandledException::kInstanceKind,
+    RawObject* raw = Object::Allocate(UnhandledException::kClassId,
                                       UnhandledException::InstanceSize(),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
   }
   result.set_exception(exception);
   result.set_stacktrace(stacktrace);
   return result.raw();
 }
 
@@ skipping 40 matching lines @@
 
 const char* UnhandledException::ToCString() const {
   return "UnhandledException";
 }
 
 
 RawUnwindError* UnwindError::New(const String& message, Heap::Space space) {
   ASSERT(Object::unwind_error_class() != Class::null());
   UnwindError& result = UnwindError::Handle();
   {
-    RawObject* raw = Object::Allocate(UnwindError::kInstanceKind,
+    RawObject* raw = Object::Allocate(UnwindError::kClassId,
                                       UnwindError::InstanceSize(),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
   }
   result.set_message(message);
   return result.raw();
 }
 
 
@@ skipping 394 matching lines @@
   raw_ptr()->value_ = value;
 }
 
 
 RawMint* Mint::New(int64_t val, Heap::Space space) {
   // Do not allocate a Mint if Smi would do.
   ASSERT(!Smi::IsValid64(val));
   ASSERT(Isolate::Current()->object_store()->mint_class() != Class::null());
   Mint& result = Mint::Handle();
   {
-    RawObject* raw = Object::Allocate(Mint::kInstanceKind,
+    RawObject* raw = Object::Allocate(Mint::kClassId,
                                       Mint::InstanceSize(),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
   }
   result.set_value(val);
   return result.raw();
 }
 
 
@@ skipping 106 matching lines @@
     return false;
   }
   return EqualsToDouble(Double::Cast(other).value());
 }
 
 
 RawDouble* Double::New(double d, Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->double_class() != Class::null());
   Double& result = Double::Handle();
   {
-    RawObject* raw = Object::Allocate(Double::kInstanceKind,
+    RawObject* raw = Object::Allocate(Double::kClassId,
                                       Double::InstanceSize(),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
   }
   result.set_value(d);
   return result.raw();
 }
 
 
@@ skipping 142 matching lines @@
 
 
 RawBigint* Bigint::Allocate(intptr_t length, Heap::Space space) {
   if (length < 0 || length > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in Bigint::Allocate: invalid length %ld\n", length);
   }
   ASSERT(Isolate::Current()->object_store()->bigint_class() != Class::null());
   Bigint& result = Bigint::Handle();
   {
-    RawObject* raw = Object::Allocate(Bigint::kInstanceKind,
+    RawObject* raw = Object::Allocate(Bigint::kClassId,
                                       Bigint::InstanceSize(length),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
     result.raw_ptr()->allocated_length_ = length;  // Chunk length allocated.
     result.raw_ptr()->signed_length_ = length;  // Chunk length in use.
   }
   return result.raw();
 }
 
@@ skipping 742 matching lines @@
                                      Heap::Space space) {
   ASSERT(Isolate::Current() == Dart::vm_isolate() ||
          Isolate::Current()->object_store()->one_byte_string_class() !=
          Class::null());
   if (len < 0 || len > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in OneByteString::New: invalid len %ld\n", len);
   }
   OneByteString& result = OneByteString::Handle();
   {
-    RawObject* raw = Object::Allocate(OneByteString::kInstanceKind,
+    RawObject* raw = Object::Allocate(OneByteString::kClassId,
                                       OneByteString::InstanceSize(len),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
     result.SetLength(len);
     result.SetHash(0);
   }
   return result.raw();
 }
 
@@ skipping 121 matching lines @@
 
 RawTwoByteString* TwoByteString::New(intptr_t len,
                                      Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->two_byte_string_class());
   if (len < 0 || len > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in TwoByteString::New: invalid len %ld\n", len);
   }
   TwoByteString& result = TwoByteString::Handle();
   {
-    RawObject* raw = Object::Allocate(TwoByteString::kInstanceKind,
+    RawObject* raw = Object::Allocate(TwoByteString::kClassId,
                                       TwoByteString::InstanceSize(len),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
     result.SetLength(len);
     result.SetHash(0);
   }
   return result.raw();
 }
 
@@ skipping 112 matching lines @@
 RawFourByteString* FourByteString::New(intptr_t len,
                                        Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->four_byte_string_class() !=
          Class::null());
   if (len < 0 || len > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in FourByteString::New: invalid len %ld\n", len);
   }
   FourByteString& result = FourByteString::Handle();
   {
-    RawObject* raw = Object::Allocate(FourByteString::kInstanceKind,
+    RawObject* raw = Object::Allocate(FourByteString::kClassId,
                                       FourByteString::InstanceSize(len),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
     result.SetLength(len);
     result.SetHash(0);
   }
   return result.raw();
 }
 
@@ skipping 92 matching lines @@
   ASSERT(Isolate::Current()->object_store()->external_one_byte_string_class() !=
          Class::null());
   if (len < 0 || len > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in ExternalOneByteString::New: invalid len %ld\n", len);
   }
   ExternalOneByteString& result = ExternalOneByteString::Handle();
   ExternalStringData<uint8_t>* external_data =
       new ExternalStringData<uint8_t>(data, peer, callback);
   {
-    RawObject* raw = Object::Allocate(ExternalOneByteString::kInstanceKind,
+    RawObject* raw = Object::Allocate(ExternalOneByteString::kClassId,
                                       ExternalOneByteString::InstanceSize(),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
     result.SetLength(len);
     result.SetHash(0);
     result.SetExternalData(external_data);
   }
   AddFinalizer(result, external_data, ExternalOneByteString::Finalize);
   return result.raw();
@@ skipping 30 matching lines @@
   ASSERT(Isolate::Current()->object_store()->external_two_byte_string_class() !=
          Class::null());
   if (len < 0 || len > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in ExternalTwoByteString::New: invalid len %ld\n", len);
   }
   ExternalTwoByteString& result = ExternalTwoByteString::Handle();
   ExternalStringData<uint16_t>* external_data =
       new ExternalStringData<uint16_t>(data, peer, callback);
   {
-    RawObject* raw = Object::Allocate(ExternalTwoByteString::kInstanceKind,
+    RawObject* raw = Object::Allocate(ExternalTwoByteString::kClassId,
                                       ExternalTwoByteString::InstanceSize(),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
     result.SetLength(len);
     result.SetHash(0);
     result.SetExternalData(external_data);
   }
   AddFinalizer(result, external_data, ExternalTwoByteString::Finalize);
   return result.raw();
@@ skipping 21 matching lines @@
          external_four_byte_string_class() != Class::null());
   if (len < 0 || len > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in ExternalFourByteString::New: invalid len %ld\n",
            len);
   }
   ExternalFourByteString& result = ExternalFourByteString::Handle();
   ExternalStringData<uint32_t>* external_data =
       new ExternalStringData<uint32_t>(data, peer, callback);
   {
-    RawObject* raw = Object::Allocate(ExternalFourByteString::kInstanceKind,
+    RawObject* raw = Object::Allocate(ExternalFourByteString::kClassId,
                                       ExternalFourByteString::InstanceSize(),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
     result.SetLength(len);
     result.SetHash(0);
     result.SetExternalData(external_data);
   }
   AddFinalizer(result, external_data, ExternalFourByteString::Finalize);
   return result.raw();
@@ skipping 20 matching lines @@
   return Isolate::Current()->object_store()->false_value();
 }
 
 
 RawBool* Bool::New(bool value) {
   ASSERT(Isolate::Current()->object_store()->bool_class() != Class::null());
   Bool& result = Bool::Handle();
   {
     // Since the two boolean instances are singletons we allocate them straight
     // in the old generation.
-    RawObject* raw = Object::Allocate(Bool::kInstanceKind,
+    RawObject* raw = Object::Allocate(Bool::kClassId,
                                       Bool::InstanceSize(),
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
   }
   result.set_value(value);
   return result.raw();
 }
 
 
@@ skipping 108 matching lines @@
   intptr_t capacity_len = growable_array.Capacity();
   Isolate* isolate = Isolate::Current();
   const Array& array = Array::Handle(isolate, growable_array.data());
   const Array& new_array = Array::Handle(isolate, Array::Empty());
   intptr_t capacity_size = Array::InstanceSize(capacity_len);
   intptr_t used_size = Array::InstanceSize(used_len);
   NoGCScope no_gc;
 
   // Update the size in the header field and length of the array object.
   uword tags = array.raw_ptr()->tags_;
-  ASSERT(kArray == RawObject::ClassIdTag::decode(tags));
+  ASSERT(kArrayCid == RawObject::ClassIdTag::decode(tags));
   tags = RawObject::SizeTag::update(used_size, tags);
   array.raw_ptr()->tags_ = tags;
   array.SetLength(used_len);
 
   // Null the GrowableObjectArray, we are removing it's backing array.
   growable_array.SetLength(0);
   growable_array.SetData(new_array);
 
   // If there is any left over space fill it with either an Array object or
   // just a plain object (depending on the amount of left over space) so
@@ skipping 136 matching lines @@
   return New(data, space);
 }
 
 
 RawGrowableObjectArray* GrowableObjectArray::New(const Array& array,
                                                  Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->growable_object_array_class()
          != Class::null());
   GrowableObjectArray& result = GrowableObjectArray::Handle();
   {
-    RawObject* raw = Object::Allocate(GrowableObjectArray::kInstanceKind,
+    RawObject* raw = Object::Allocate(GrowableObjectArray::kClassId,
                                       GrowableObjectArray::InstanceSize(),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
     result.SetLength(0);
     result.SetData(array);
   }
   return result.raw();
 }
 
@@ skipping 681 matching lines @@
 
 
 RawStacktrace* Stacktrace::New(const GrowableObjectArray& func_list,
                                const GrowableObjectArray& code_list,
                                const GrowableObjectArray& pc_offset_list,
                                Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->stacktrace_class() !=
          Class::null());
   Stacktrace& result = Stacktrace::Handle();
   {
-    RawObject* raw = Object::Allocate(Stacktrace::kInstanceKind,
+    RawObject* raw = Object::Allocate(Stacktrace::kClassId,
                                       Stacktrace::InstanceSize(),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
   }
   // Create arrays for the function, code and pc_offset triplet for each frame.
   const Array& function_array = Array::Handle(Array::MakeArray(func_list));
   const Array& code_array = Array::Handle(Array::MakeArray(code_list));
   const Array& pc_offset_array =
       Array::Handle(Array::MakeArray(pc_offset_list));
@@ skipping 104 matching lines @@
 
 RawJSRegExp* JSRegExp::New(intptr_t len, Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->jsregexp_class() !=
          Class::null());
   if (len < 0 || len > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in JSRegexp::New: invalid len %ld\n", len);
   }
   JSRegExp& result = JSRegExp::Handle();
   {
-    RawObject* raw = Object::Allocate(JSRegExp::kInstanceKind,
+    RawObject* raw = Object::Allocate(JSRegExp::kClassId,
                                       JSRegExp::InstanceSize(len),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
     result.set_type(kUnitialized);
     result.set_flags(0);
     result.SetLength(len);
   }
   return result.raw();
 }
@@ skipping 58 matching lines @@
 const char* JSRegExp::ToCString() const {
   const String& str = String::Handle(pattern());
   const char* format = "JSRegExp: pattern=%s flags=%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags());
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len + 1);
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 }  // namespace dart