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

vm/snapshot.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/snapshot.h"
 
 #include "platform/assert.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
 #include "vm/exceptions.h"
 #include "vm/heap.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
+#include "vm/snapshot_ids.h"
 #include "vm/symbols.h"
 
 namespace dart {
 
-enum {
-  kInstanceId = ObjectStore::kMaxId,
-  kMaxPredefinedObjectIds,
-};
 static const int kNumInitialReferencesInFullSnapshot = 160 * KB;
 static const int kNumInitialReferences = 4;
 
 
-static bool IsSingletonClassId(intptr_t index) {
+static bool IsSingletonClassId(intptr_t class_id) {
   // Check if this is a singleton object class which is shared by all isolates.
-  return (index >= Object::kClassClass && index < Object::kMaxId);
+  return ((class_id >= kClassCid && class_id <= kUnwindErrorCid) ||
+          (class_id >= kNullCid && class_id <= kVoidCid));
 }
 
 
-static bool IsObjectStoreClassId(intptr_t index) {
+static bool IsObjectStoreClassId(intptr_t class_id) {
   // Check if this is a class which is stored in the object store.
-  return (index >= ObjectStore::kObjectClass && index < ObjectStore::kMaxId);
+  return (class_id == kObjectCid ||
+          (class_id >= kInstanceCid && class_id <= kJSRegExpCid));
 }
 
 
 static bool IsObjectStoreTypeId(intptr_t index) {
   // Check if this is a type which is stored in the object store.
-  return (index >= ObjectStore::kObjectType &&
-          index <= ObjectStore::kListInterface);
+  return (index >= kObjectType && index <= kByteArrayInterface);
+}
+
+
+static intptr_t ClassIdFromObjectId(intptr_t object_id) {
+  ASSERT(object_id > kClassIdsOffset);
+  intptr_t class_id = (object_id - kClassIdsOffset);
+  return class_id;
+}
+
+
+static intptr_t ObjectIdFromClassId(intptr_t class_id) {
+  ASSERT(class_id > kIllegalCid && class_id < kNumPredefinedCids);
+  return (class_id + kClassIdsOffset);
+}
+
+
+static RawType* GetType(ObjectStore* object_store, int index) {
+  switch (index) {
+    case kObjectType: return object_store->object_type();
+    case kNullType: return object_store->null_type();
+    case kDynamicType: return object_store->dynamic_type();
+    case kVoidType: return object_store->void_type();
+    case kFunctionInterface: return object_store->function_interface();
+    case kNumberInterface: return object_store->number_interface();
+    case kDoubleInterface: return object_store->double_interface();
+    case kIntInterface: return object_store->int_interface();
+    case kBoolInterface: return object_store->bool_interface();
+    case kStringInterface: return object_store->string_interface();
+    case kListInterface: return object_store->list_interface();
+    case kByteArrayInterface: return object_store->byte_array_interface();
+    default: break;
+  }
+  UNREACHABLE();
+  return Type::null();
+}
+
+
+static int GetTypeIndex(ObjectStore* object_store, const RawType* raw_type) {
+  ASSERT(raw_type->IsHeapObject());
+  if (raw_type == object_store->object_type()) {
+    return kObjectType;
+  } else if (raw_type == object_store->null_type()) {
+    return kNullType;
+  } else if (raw_type == object_store->dynamic_type()) {
+    return kDynamicType;
+  } else if (raw_type == object_store->void_type()) {
+    return kVoidType;
+  } else if (raw_type == object_store->function_interface()) {
+    return kFunctionInterface;
+  } else if (raw_type == object_store->number_interface()) {
+    return kNumberInterface;
+  } else if (raw_type == object_store->double_interface()) {
+    return kDoubleInterface;
+  } else if (raw_type == object_store->int_interface()) {
+    return kIntInterface;
+  } else if (raw_type == object_store->bool_interface()) {
+    return kBoolInterface;
+  } else if (raw_type == object_store->string_interface()) {
+    return kStringInterface;
+  } else if (raw_type == object_store->list_interface()) {
+    return kListInterface;
+  } else if (raw_type == object_store->byte_array_interface()) {
+    return kByteArrayInterface;
+  }
+  return kInvalidIndex;
 }
 
 
 // TODO(5411462): Temporary setup of snapshot for testing purposes,
 // the actual creation of a snapshot maybe done differently.
 const Snapshot* Snapshot::SetupFromBuffer(const void* raw_memory) {
   ASSERT(raw_memory != NULL);
   ASSERT(kHeaderSize == sizeof(Snapshot));
   ASSERT(kLengthIndex == length_offset());
   ASSERT((kSnapshotFlagIndex * sizeof(int32_t)) == kind_offset());
@@ skipping 108 matching lines @@
   ASSERT(SerializedHeaderTag::decode(header_value) == kInlined);
   intptr_t object_id = SerializedHeaderData::decode(header_value);
   ASSERT(GetBackRef(object_id) == NULL);
 
   // Read the class header information and lookup the class.
   intptr_t class_header = ReadIntptrValue();
 
   // Since we are only reading an object reference, If it is an instance kind
   // then we only need to figure out the class of the object and allocate an
   // instance of it. The individual fields will be read later.
-  if (SerializedHeaderData::decode(class_header) == kInstanceId) {
+  if (SerializedHeaderData::decode(class_header) == kInstanceObjectId) {
     Instance& result = Instance::ZoneHandle(isolate(), Instance::null());
     AddBackRef(object_id, &result, kIsNotDeserialized);
 
     cls_ ^= ReadObjectImpl();  // Read class information.
     ASSERT(!cls_.IsNull());
     intptr_t instance_size = cls_.instance_size();
     ASSERT(instance_size > 0);
     if (kind_ == Snapshot::kFull) {
       result ^= AllocateUninitialized(cls_, instance_size);
     } else {
       result ^= Object::Allocate(cls_.id(), instance_size, Heap::kNew);
     }
     return result.raw();
-  } else {
-    ASSERT((class_header & kSmiTagMask) != 0);
-    cls_ = LookupInternalClass(class_header);
-    ASSERT(!cls_.IsNull());
   }
+  ASSERT((class_header & kSmiTagMask) != 0);
+  cls_ = LookupInternalClass(class_header);
+  ASSERT(!cls_.IsNull());
 
   // Similarly Array and ImmutableArray objects are also similarly only
   // allocated here, the individual array elements are read later.
-  ObjectKind obj_kind = cls_.instance_kind();
-  if (obj_kind == Array::kInstanceKind) {
+  intptr_t class_id = cls_.id();
+  if (class_id == kArrayCid) {
     // Read the length and allocate an object based on the len.
     intptr_t len = ReadSmiValue();
     Array& array = Array::ZoneHandle(
         isolate(),
         (kind_ == Snapshot::kFull) ? NewArray(len) : Array::New(len));
     AddBackRef(object_id, &array, kIsNotDeserialized);
 
     return array.raw();
   }
-  if (obj_kind == ImmutableArray::kInstanceKind) {
+  if (class_id == kImmutableArrayCid) {
     // Read the length and allocate an object based on the len.
     intptr_t len = ReadSmiValue();
     ImmutableArray& array = ImmutableArray::ZoneHandle(
         isolate(),
         (kind_ == Snapshot::kFull) ?
           NewImmutableArray(len) : ImmutableArray::New(len));
     AddBackRef(object_id, &array, kIsNotDeserialized);
 
     return array.raw();
   }
 
   // For all other internal VM classes we read the object inline.
   intptr_t tags = ReadIntptrValue();
-  switch (obj_kind) {
+  switch (class_id) {
 #define SNAPSHOT_READ(clazz)                                                   \
-    case clazz::kInstanceKind: {                                               \
+    case clazz::kClassId: {                                                    \
       obj_ = clazz::ReadFrom(this, object_id, tags, kind_);                    \
       break;                                                                   \
     }
     CLASS_LIST_NO_OBJECT(SNAPSHOT_READ)
 #undef SNAPSHOT_READ
     default: UNREACHABLE(); break;
   }
   if (kind_ == Snapshot::kFull) {
     obj_.SetCreatedFromSnapshot();
   }
@@ skipping 111 matching lines @@
   ASSERT(kind_ == Snapshot::kFull);
   ASSERT(isolate()->no_gc_scope_depth() != 0);
   cls_ = Object::context_class();
   RawContext* obj = reinterpret_cast<RawContext*>(
       AllocateUninitialized(cls_, Context::InstanceSize(num_variables)));
   obj->ptr()->num_variables_ = num_variables;
   return obj;
 }
 
 
-RawClass* SnapshotReader::NewClass(int value) {
+RawClass* SnapshotReader::NewClass(intptr_t class_id, bool is_signature_class) {
   ASSERT(kind_ == Snapshot::kFull);
   ASSERT(isolate()->no_gc_scope_depth() != 0);
-  ObjectKind object_kind = static_cast<ObjectKind>(value);
-  if ((object_kind == kInstance || object_kind == kClosure)) {
-    cls_ = Object::class_class();
-    RawClass* obj = reinterpret_cast<RawClass*>(
-        AllocateUninitialized(cls_, Class::InstanceSize()));
-    if (object_kind == kInstance) {
-      Instance fake;
-      obj->ptr()->handle_vtable_ = fake.vtable();
-    } else {
-      Closure fake;
-      obj->ptr()->handle_vtable_ = fake.vtable();
-    }
-    cls_ = obj;
-    cls_.set_instance_kind(object_kind);
-    cls_.set_id(kIllegalObjectKind);
-    isolate()->class_table()->Register(cls_);
-    return cls_.raw();
+  if (class_id < kNumPredefinedCids) {
+    return Class::GetClass(class_id, is_signature_class);
   }
-  return Class::GetClass(object_kind);
+  cls_ = Object::class_class();
+  RawClass* obj = reinterpret_cast<RawClass*>(
+      AllocateUninitialized(cls_, Class::InstanceSize()));
+  if (is_signature_class) {
+    Closure fake;
+    obj->ptr()->handle_vtable_ = fake.vtable();
+  } else {
+    Instance fake;
+    obj->ptr()->handle_vtable_ = fake.vtable();
+  }
+  cls_ = obj;
+  cls_.set_id(kIllegalCid);
+  isolate()->class_table()->Register(cls_);
+  return cls_.raw();
 }
 
 
 RawMint* SnapshotReader::NewMint(int64_t value) {
   ASSERT(kind_ == Snapshot::kFull);
   ASSERT(isolate()->no_gc_scope_depth() != 0);
   cls_ = object_store()->mint_class();
   RawMint* obj = reinterpret_cast<RawMint*>(
       AllocateUninitialized(cls_, Mint::InstanceSize()));
   obj->ptr()->value_ = value;
@@ skipping 84 matching lines @@
                    object_store()->growable_object_array_class());
 }
 
 
 RawClass* SnapshotReader::LookupInternalClass(intptr_t class_header) {
   // If the header is an object Id, lookup singleton VM classes or classes
   // stored in the object store.
   if (IsVMIsolateObject(class_header)) {
     intptr_t class_id = GetVMIsolateObjectId(class_header);
     if (IsSingletonClassId(class_id)) {
-      return Object::GetSingletonClass(class_id);  // return singleton.
+      return isolate()->class_table()->At(class_id);  // get singleton class.
     }
   } else if (SerializedHeaderTag::decode(class_header) == kObjectId) {
-    intptr_t header_value = SerializedHeaderData::decode(class_header);
-    if (IsObjectStoreClassId(header_value)) {
-      return object_store()->GetClass(header_value);
+    intptr_t class_id = SerializedHeaderData::decode(class_header);
+    if (IsObjectStoreClassId(class_id)) {
+      return isolate()->class_table()->At(class_id);  // get singleton class.
     }
   }
   return Class::null();
 }
 
 
 RawObject* SnapshotReader::AllocateUninitialized(const Class& cls,
                                                  intptr_t size) {
   ASSERT(isolate()->no_gc_scope_depth() != 0);
   ASSERT(Utils::IsAligned(size, kObjectAlignment));
   Heap* heap = isolate()->heap();
 
   uword address = heap->TryAllocate(size, Heap::kOld);
   if (address == 0) {
     // Use the preallocated out of memory exception to avoid calling
     // into dart code or allocating any code.
     const Instance& exception =
         Instance::Handle(object_store()->out_of_memory());
     Exceptions::Throw(exception);
     UNREACHABLE();
   }
   RawObject* raw_obj = reinterpret_cast<RawObject*>(address + kHeapObjectTag);
   uword tags = 0;
   intptr_t index = cls.id();
-  ASSERT(index != kIllegalObjectKind);
+  ASSERT(index != kIllegalCid);
   tags = RawObject::ClassIdTag::update(index, tags);
   tags = RawObject::SizeTag::update(size, tags);
   raw_obj->ptr()->tags_ = tags;
   return raw_obj;
 }
 
 
 RawObject* SnapshotReader::ReadVMIsolateObject(intptr_t header_value) {
   intptr_t object_id = GetVMIsolateObjectId(header_value);
-  if (object_id == Object::kNullObject) {
+  if (object_id == kNullObject) {
     // This is a singleton null object, return it.
     return Object::null();
   }
-  if (object_id == Object::kSentinelObject) {
+  if (object_id == kSentinelObject) {
     return Object::sentinel();
   }
-  if (IsSingletonClassId(object_id)) {
-    return Object::GetSingletonClass(object_id);  // return singleton object.
+  intptr_t class_id = ClassIdFromObjectId(object_id);
+  if (IsSingletonClassId(class_id)) {
+    return isolate()->class_table()->At(class_id);  // get singleton class.
   } else {
     ASSERT(Symbols::IsVMSymbolId(object_id));
     return Symbols::GetVMSymbol(object_id);  // return VM symbol.
   }
   UNREACHABLE();
+  return Object::null();
 }
 
 
 RawObject* SnapshotReader::ReadIndexedObject(intptr_t object_id) {
-  if (IsObjectStoreClassId(object_id)) {
-    return object_store()->GetClass(object_id);
-  } else if (object_id == ObjectStore::kTrueValue) {
+  if (object_id == kTrueValue) {
     return object_store()->true_value();
-  } else if (object_id == ObjectStore::kFalseValue) {
+  }
+  if (object_id == kFalseValue) {
     return object_store()->false_value();
-  } else if (kind_ != Snapshot::kFull) {
+  }
+  intptr_t class_id = ClassIdFromObjectId(object_id);
+  if (IsObjectStoreClassId(class_id)) {
+    return isolate()->class_table()->At(class_id);  // get singleton class.
+  }
+  if (kind_ != Snapshot::kFull) {
     if (IsObjectStoreTypeId(object_id)) {
-      return object_store()->GetType(object_id);  // return type object.
+      return GetType(object_store(), object_id);  // return type obj.
     }
   }
-
   Object* object = GetBackRef(object_id);
   return object->raw();
 }
 
 
 RawObject* SnapshotReader::ReadInlinedObject(intptr_t object_id) {
   // Read the class header information and lookup the class.
   intptr_t class_header = ReadIntptrValue();
   intptr_t tags = ReadIntptrValue();
-  if (SerializedHeaderData::decode(class_header) == kInstanceId) {
+  if (SerializedHeaderData::decode(class_header) == kInstanceObjectId) {
     // Object is regular dart instance.
     Instance* result = reinterpret_cast<Instance*>(GetBackRef(object_id));
     intptr_t instance_size = 0;
     if (result == NULL) {
       result = &(Instance::ZoneHandle(isolate(), Instance::null()));
       AddBackRef(object_id, result, kIsDeserialized);
       cls_ ^= ReadObjectImpl();
       ASSERT(!cls_.IsNull());
       instance_size = cls_.instance_size();
       ASSERT(instance_size > 0);
@@ skipping 13 matching lines @@
       obj_ = ReadObjectRef();
       result->SetFieldAtOffset(offset, obj_);
       offset += kWordSize;
     }
     if (kind_ == Snapshot::kFull) {
       result->SetCreatedFromSnapshot();
     } else if (result->IsCanonical()) {
       *result = result->Canonicalize();
     }
     return result->raw();
-  } else {
-    ASSERT((class_header & kSmiTagMask) != 0);
-    cls_ = LookupInternalClass(class_header);
-    ASSERT(!cls_.IsNull());
   }
-  switch (cls_.instance_kind()) {
+  ASSERT((class_header & kSmiTagMask) != 0);
+  cls_ = LookupInternalClass(class_header);
+  ASSERT(!cls_.IsNull());
+  switch (cls_.id()) {
 #define SNAPSHOT_READ(clazz)                                                   \
-    case clazz::kInstanceKind: {                                               \
+    case clazz::kClassId: {                                                    \
       obj_ = clazz::ReadFrom(this, object_id, tags, kind_);                    \
       break;                                                                   \
     }
     CLASS_LIST_NO_OBJECT(SNAPSHOT_READ)
 #undef SNAPSHOT_READ
     default: UNREACHABLE(); break;
   }
   if (kind_ == Snapshot::kFull) {
     obj_.SetCreatedFromSnapshot();
   }
@@ skipping 20 matching lines @@
 
 void SnapshotWriter::WriteObject(RawObject* rawobj) {
   WriteObjectImpl(rawobj);
   WriteForwardedObjects();
 }
 
 
 void SnapshotWriter::HandleVMIsolateObject(RawObject* rawobj) {
   // Check if it is a singleton null object.
   if (rawobj == Object::null()) {
-    WriteVMIsolateObject(Object::kNullObject);
+    WriteVMIsolateObject(kNullObject);
     return;
   }
 
   // Check if it is a singleton sentinel object.
   if (rawobj == Object::sentinel()) {
-    WriteVMIsolateObject(Object::kSentinelObject);
+    WriteVMIsolateObject(kSentinelObject);
     return;
   }
 
-  // Check if it is a singleton class object.
-  RawClass* raw_class = reinterpret_cast<RawClass*>(rawobj);
-  intptr_t index = Object::GetSingletonClassIndex(raw_class);
-  if (index != Object::kInvalidIndex) {
-    WriteVMIsolateObject(index);
+  // Check if it is a singleton class object which is shared by
+  // all isolates.
+  intptr_t id = rawobj->GetClassId();
+  if (id == kClassCid) {
+    RawClass* raw_class = reinterpret_cast<RawClass*>(rawobj);
+    intptr_t class_id = raw_class->ptr()->id_;
+    if (IsSingletonClassId(class_id)) {
+      intptr_t object_id = ObjectIdFromClassId(class_id);
+      WriteVMIsolateObject(object_id);
+      return;
+    }
+  }
+
+  // Check it is a predefined symbol in the VM isolate.
+  id = Symbols::LookupVMSymbol(rawobj);
+  if (id != kInvalidIndex) {
+    WriteVMIsolateObject(id);
     return;
   }
 
-  // Check it is a predefined symbol.
-  index = Symbols::LookupVMSymbol(rawobj);
-  if (index != Object::kInvalidIndex) {
-    WriteVMIsolateObject(index);
-    return;
-  }
-
   UNREACHABLE();
 }
 
 
 void SnapshotWriter::WriteObjectRef(RawObject* raw) {
   // First check if object can be written as a simple predefined type.
   if (CheckAndWritePredefinedObject(raw)) {
     return;
   }
-  // Check if object has already been serialized, in that
-  // case just write the object id out.
-  uword tags = raw->ptr()->tags_;
-  if (SerializedHeaderTag::decode(tags) == kObjectId) {
-    intptr_t id = SerializedHeaderData::decode(tags);
-    WriteIndexedObject(id);
-    return;
-  }
 
   NoGCScope no_gc;
-  RawClass* cls = class_table_->At(RawObject::ClassIdTag::decode(tags));
-
-  ObjectKind obj_kind = cls->ptr()->instance_kind_;
-  if (obj_kind == Instance::kInstanceKind) {
+  RawClass* cls = class_table_->At(raw->GetClassId());
+  intptr_t class_id = cls->ptr()->id_;
+  ASSERT(class_id == raw->GetClassId());
+  if (class_id >= kNumPredefinedCids) {
+    ASSERT(!Class::IsSignatureClass(cls));
     // Object is being referenced, add it to the forward ref list and mark
     // it so that future references to this object in the snapshot will use
     // this object id. Mark it as not having been serialized yet so that we
     // will serialize the object when we go through the forward list.
     intptr_t object_id = MarkObject(raw, kIsNotSerialized);
 
     // Write out the serialization header value for this object.
     WriteInlinedObjectHeader(object_id);
 
     // Indicate this is an instance object.
-    WriteIntptrValue(SerializedHeaderData::encode(kInstanceId));
+    WriteIntptrValue(SerializedHeaderData::encode(kInstanceObjectId));
 
     // Write out the class information for this object.
     WriteObjectImpl(cls);
 
     return;
   }
-  if (obj_kind == Array::kInstanceKind) {
+  if (class_id == kArrayCid) {
     // Object is being referenced, add it to the forward ref list and mark
     // it so that future references to this object in the snapshot will use
     // this object id. Mark it as not having been serialized yet so that we
     // will serialize the object when we go through the forward list.
     intptr_t object_id = MarkObject(raw, kIsNotSerialized);
 
     RawArray* rawarray = reinterpret_cast<RawArray*>(raw);
 
     // Write out the serialization header value for this object.
     WriteInlinedObjectHeader(object_id);
 
     // Write out the class information.
-    WriteIndexedObject(ObjectStore::kArrayClass);
+    WriteIndexedObject(kArrayCid);
 
     // Write out the length field.
     Write<RawObject*>(rawarray->ptr()->length_);
 
     return;
   }
-  if (obj_kind == ImmutableArray::kInstanceKind) {
+  if (class_id == kImmutableArrayCid) {
     // Object is being referenced, add it to the forward ref list and mark
     // it so that future references to this object in the snapshot will use
     // this object id. Mark it as not having been serialized yet so that we
     // will serialize the object when we go through the forward list.
     intptr_t object_id = MarkObject(raw, kIsNotSerialized);
 
     RawArray* rawarray = reinterpret_cast<RawArray*>(raw);
 
     // Write out the serialization header value for this object.
     WriteInlinedObjectHeader(object_id);
 
     // Write out the class information.
-    WriteIndexedObject(ObjectStore::kImmutableArrayClass);
+    WriteIndexedObject(kImmutableArrayCid);
 
     // Write out the length field.
     Write<RawObject*>(rawarray->ptr()->length_);
 
     return;
   }
   // Object is being referenced, add it to the forward ref list and mark
   // it so that future references to this object in the snapshot will use
   // this object id. Mark it as not having been serialized yet so that we
   // will serialize the object when we go through the forward list.
   intptr_t object_id = MarkObject(raw, kIsSerialized);
-  switch (obj_kind) {
+  switch (class_id) {
 #define SNAPSHOT_WRITE(clazz)                                                  \
-    case clazz::kInstanceKind: {                                               \
+    case clazz::kClassId: {                                                    \
       Raw##clazz* raw_obj = reinterpret_cast<Raw##clazz*>(raw);                \
       raw_obj->WriteTo(this, object_id, kind_);                                \
       return;                                                                  \
     }                                                                          \
 
     CLASS_LIST_NO_OBJECT(SNAPSHOT_WRITE)
 #undef SNAPSHOT_WRITE
     default: break;
   }
   UNREACHABLE();
@@ skipping 82 matching lines @@
   // Now check if it is an object from the VM isolate (NOTE: premarked objects
   // are considered to be objects in the VM isolate). These objects are shared
   // by all isolates.
   if (rawobj->IsMarked()) {
     HandleVMIsolateObject(rawobj);
     return true;
   }
 
   // Check if it is a singleton boolean true value.
   if (rawobj == object_store()->true_value()) {
-    WriteIndexedObject(ObjectStore::kTrueValue);
+    WriteIndexedObject(kTrueValue);
     return true;
   }
 
   // Check if it is a singleton boolean false value.
   if (rawobj == object_store()->false_value()) {
-    WriteIndexedObject(ObjectStore::kFalseValue);
+    WriteIndexedObject(kFalseValue);
     return true;
   }
 
   // Check if it is a code object in that case just write a Null object
   // as we do not want code objects in the snapshot.
-  if (rawobj->GetClassId() == kCode) {
-    WriteVMIsolateObject(Object::kNullObject);
+  if (rawobj->GetClassId() == kCodeCid) {
+    WriteVMIsolateObject(kNullObject);
     return true;
   }
 
   // Check if classes are not being serialized and it is preinitialized type.
   if (kind_ != Snapshot::kFull) {
     RawType* raw_type = reinterpret_cast<RawType*>(rawobj);
-    intptr_t index = object_store()->GetTypeIndex(raw_type);
-    if (index != ObjectStore::kInvalidIndex) {
+    intptr_t index = GetTypeIndex(object_store(), raw_type);
+    if (index != kInvalidIndex) {
       WriteIndexedObject(index);
       return true;
     }
   }
 
   return false;
 }
 
 
 void SnapshotWriter::WriteObjectImpl(RawObject* raw) {
@@ skipping 16 matching lines @@
   // - Object is seen for the first time (inlined as follows):
   //    (object size in multiples of kObjectAlignment | 0x1)
   //    serialized fields of the object
   //    ......
   NoGCScope no_gc;
   uword tags = raw->ptr()->tags_;
   ASSERT(SerializedHeaderTag::decode(tags) == kObjectId);
   intptr_t object_id = SerializedHeaderData::decode(tags);
   tags = forward_list_[object_id - kMaxPredefinedObjectIds]->tags();
   RawClass* cls = class_table_->At(RawObject::ClassIdTag::decode(tags));
-  ObjectKind kind = cls->ptr()->instance_kind_;
+  intptr_t class_id = cls->ptr()->id_;
 
-  if (kind == Instance::kInstanceKind) {
+  if (class_id >= kNumPredefinedCids) {
+    ASSERT(!Class::IsSignatureClass(cls));
     // Object is regular dart instance.
     // TODO(5411462): figure out what we need to do if an object with native
     // fields is serialized (throw exception or serialize a null object).
     ASSERT(cls->ptr()->num_native_fields_ == 0);
     intptr_t instance_size = cls->ptr()->instance_size_;
     ASSERT(instance_size != 0);
 
     // Write out the serialization header value for this object.
     WriteInlinedObjectHeader(object_id);
 
     // Indicate this is an instance object.
-    WriteIntptrValue(SerializedHeaderData::encode(kInstanceId));
+    WriteIntptrValue(SerializedHeaderData::encode(kInstanceObjectId));
 
     // Write out the tags.
     WriteIntptrValue(tags);
 
     // Write out the class information for this object.
     WriteObjectImpl(cls);
 
     // Write out all the fields for the object.
     intptr_t offset = Object::InstanceSize();
     while (offset < instance_size) {
       WriteObjectRef(*reinterpret_cast<RawObject**>(
           reinterpret_cast<uword>(raw->ptr()) + offset));
       offset += kWordSize;
     }
     return;
   }
-  switch (kind) {
+  switch (class_id) {
 #define SNAPSHOT_WRITE(clazz)                                                  \
-    case clazz::kInstanceKind: {                                               \
+    case clazz::kClassId: {                                                    \
       Raw##clazz* raw_obj = reinterpret_cast<Raw##clazz*>(raw);                \
       raw_obj->WriteTo(this, object_id, kind_);                                \
       return;                                                                  \
     }                                                                          \
 
     CLASS_LIST_NO_OBJECT(SNAPSHOT_WRITE)
 #undef SNAPSHOT_WRITE
     default: break;
   }
   UNREACHABLE();
@@ skipping 14 matching lines @@
 
       // Mark object as serialized.
       forward_list_[i]->set_state(kIsSerialized);
     }
   }
 }
 
 
 void SnapshotWriter::WriteClassId(RawClass* cls) {
   ASSERT(kind_ != Snapshot::kFull);
-  int id = object_store()->GetClassIndex(cls);
-  if (IsSingletonClassId(id)) {
-    WriteVMIsolateObject(id);
-  } else if (IsObjectStoreClassId(id)) {
-    WriteIndexedObject(id);
+  int class_id = cls->ptr()->id_;
+  if (IsSingletonClassId(class_id)) {
+    intptr_t object_id = ObjectIdFromClassId(class_id);
+    WriteVMIsolateObject(object_id);
+  } else if (IsObjectStoreClassId(class_id)) {
+    intptr_t object_id = ObjectIdFromClassId(class_id);
+    WriteIndexedObject(object_id);
   } else {
     // TODO(5411462): Should restrict this to only core-lib classes in this
     // case.
     // Write out the class and tags information.
-    WriteVMIsolateObject(Object::kClassClass);
+    WriteVMIsolateObject(kClassCid);
     WriteIntptrValue(GetObjectTags(cls));
 
     // Write out the library url and class name.
     RawLibrary* library = cls->ptr()->library_;
     ASSERT(library != Library::null());
     WriteObjectImpl(library->ptr()->url_);
     WriteObjectImpl(cls->ptr()->name_);
   }
 }
 
@@ skipping 42 matching lines @@
     RawObject* raw_obj = *current;
     if (as_references_) {
       writer_->WriteObjectRef(raw_obj);
     } else {
       writer_->WriteObjectImpl(raw_obj);
     }
   }
 }
 
 }  // namespace dart