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

vm/raw_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/raw_object.h"
 
 #include "vm/class_table.h"
 #include "vm/freelist.h"
 #include "vm/isolate.h"
 #include "vm/object.h"
@@ skipping 31 matching lines @@
 
 intptr_t RawObject::SizeFromClass() const {
   Isolate* isolate = Isolate::Current();
   NoHandleScope no_handles(isolate);
 
   // Only reasonable to be called on heap objects.
   ASSERT(IsHeapObject());
 
   RawClass* raw_class = isolate->class_table()->At(GetClassId());
   intptr_t instance_size = raw_class->ptr()->instance_size_;
-  ObjectKind instance_kind = raw_class->ptr()->instance_kind_;
+  intptr_t class_id = raw_class->ptr()->id_;
 
   if (instance_size == 0) {
-    switch (instance_kind) {
-      case kTokenStream: {
+    switch (class_id) {
+      case kTokenStreamCid: {
         const RawTokenStream* raw_tokens =
             reinterpret_cast<const RawTokenStream*>(this);
         intptr_t tokens_length = Smi::Value(raw_tokens->ptr()->length_);
         instance_size = TokenStream::InstanceSize(tokens_length);
         break;
       }
-      case kCode: {
+      case kCodeCid: {
         const RawCode* raw_code = reinterpret_cast<const RawCode*>(this);
         intptr_t pointer_offsets_length =
             raw_code->ptr()->pointer_offsets_length_;
         instance_size = Code::InstanceSize(pointer_offsets_length);
         break;
       }
-      case kInstructions: {
+      case kInstructionsCid: {
         const RawInstructions* raw_instructions =
             reinterpret_cast<const RawInstructions*>(this);
         intptr_t instructions_size = raw_instructions->ptr()->size_;
         instance_size = Instructions::InstanceSize(instructions_size);
         break;
       }
-      case kContext: {
+      case kContextCid: {
         const RawContext* raw_context =
             reinterpret_cast<const RawContext*>(this);
         intptr_t num_variables = raw_context->ptr()->num_variables_;
         instance_size = Context::InstanceSize(num_variables);
         break;
       }
-      case kContextScope: {
+      case kContextScopeCid: {
         const RawContextScope* raw_context_scope =
             reinterpret_cast<const RawContextScope*>(this);
         intptr_t num_variables = raw_context_scope->ptr()->num_variables_;
         instance_size = ContextScope::InstanceSize(num_variables);
         break;
       }
-      case kBigint: {
+      case kBigintCid: {
         const RawBigint* raw_bgi = reinterpret_cast<const RawBigint*>(this);
         intptr_t length = raw_bgi->ptr()->allocated_length_;
         instance_size = Bigint::InstanceSize(length);
         break;
       }
-      case kOneByteString: {
+      case kOneByteStringCid: {
         const RawOneByteString* raw_string =
             reinterpret_cast<const RawOneByteString*>(this);
         intptr_t string_length = Smi::Value(raw_string->ptr()->length_);
         instance_size = OneByteString::InstanceSize(string_length);
         break;
       }
-      case kTwoByteString: {
+      case kTwoByteStringCid: {
         const RawTwoByteString* raw_string =
             reinterpret_cast<const RawTwoByteString*>(this);
         intptr_t string_length = Smi::Value(raw_string->ptr()->length_);
         instance_size = TwoByteString::InstanceSize(string_length);
         break;
       }
-      case kFourByteString: {
+      case kFourByteStringCid: {
         const RawFourByteString* raw_string =
             reinterpret_cast<const RawFourByteString*>(this);
         intptr_t string_length = Smi::Value(raw_string->ptr()->length_);
         instance_size = FourByteString::InstanceSize(string_length);
         break;
       }
-      case kArray:
-      case kImmutableArray: {
+      case kArrayCid:
+      case kImmutableArrayCid: {
         const RawArray* raw_array = reinterpret_cast<const RawArray*>(this);
         intptr_t array_length = Smi::Value(raw_array->ptr()->length_);
         instance_size = Array::InstanceSize(array_length);
         break;
       }
-      case kInt8Array: {
+      case kInt8ArrayCid: {
         const RawInt8Array* raw_byte_array =
             reinterpret_cast<const RawInt8Array*>(this);
         intptr_t byte_array_length = Smi::Value(raw_byte_array->ptr()->length_);
         instance_size = Int8Array::InstanceSize(byte_array_length);
         break;
       }
-      case kUint8Array: {
+      case kUint8ArrayCid: {
         const RawUint8Array* raw_byte_array =
             reinterpret_cast<const RawUint8Array*>(this);
         intptr_t byte_array_length = Smi::Value(raw_byte_array->ptr()->length_);
         instance_size = Uint8Array::InstanceSize(byte_array_length);
         break;
       }
-      case kInt16Array: {
+      case kInt16ArrayCid: {
         const RawInt16Array* raw_byte_array =
             reinterpret_cast<const RawInt16Array*>(this);
         intptr_t byte_array_length = Smi::Value(raw_byte_array->ptr()->length_);
         instance_size = Int16Array::InstanceSize(byte_array_length);
         break;
       }
-      case kUint16Array: {
+      case kUint16ArrayCid: {
         const RawUint16Array* raw_byte_array =
             reinterpret_cast<const RawUint16Array*>(this);
         intptr_t byte_array_length = Smi::Value(raw_byte_array->ptr()->length_);
         instance_size = Uint16Array::InstanceSize(byte_array_length);
         break;
       }
-      case kInt32Array: {
+      case kInt32ArrayCid: {
         const RawInt32Array* raw_byte_array =
             reinterpret_cast<const RawInt32Array*>(this);
         intptr_t byte_array_length = Smi::Value(raw_byte_array->ptr()->length_);
         instance_size = Int32Array::InstanceSize(byte_array_length);
         break;
       }
-      case kUint32Array: {
+      case kUint32ArrayCid: {
         const RawUint32Array* raw_byte_array =
             reinterpret_cast<const RawUint32Array*>(this);
         intptr_t byte_array_length = Smi::Value(raw_byte_array->ptr()->length_);
         instance_size = Uint32Array::InstanceSize(byte_array_length);
         break;
       }
-      case kInt64Array: {
+      case kInt64ArrayCid: {
         const RawInt64Array* raw_byte_array =
             reinterpret_cast<const RawInt64Array*>(this);
         intptr_t byte_array_length = Smi::Value(raw_byte_array->ptr()->length_);
         instance_size = Int64Array::InstanceSize(byte_array_length);
         break;
       }
-      case kUint64Array: {
+      case kUint64ArrayCid: {
         const RawUint64Array* raw_byte_array =
             reinterpret_cast<const RawUint64Array*>(this);
         intptr_t byte_array_length = Smi::Value(raw_byte_array->ptr()->length_);
         instance_size = Uint64Array::InstanceSize(byte_array_length);
         break;
       }
-      case kFloat32Array: {
+      case kFloat32ArrayCid: {
         const RawFloat32Array* raw_byte_array =
             reinterpret_cast<const RawFloat32Array*>(this);
         intptr_t byte_array_length = Smi::Value(raw_byte_array->ptr()->length_);
         instance_size = Float32Array::InstanceSize(byte_array_length);
         break;
       }
-      case kFloat64Array: {
+      case kFloat64ArrayCid: {
         const RawFloat64Array* raw_byte_array =
             reinterpret_cast<const RawFloat64Array*>(this);
         intptr_t byte_array_length = Smi::Value(raw_byte_array->ptr()->length_);
         instance_size = Float64Array::InstanceSize(byte_array_length);
         break;
       }
-      case kTypeArguments: {
+      case kTypeArgumentsCid: {
         const RawTypeArguments* raw_array =
             reinterpret_cast<const RawTypeArguments*>(this);
         intptr_t array_length = Smi::Value(raw_array->ptr()->length_);
         instance_size = TypeArguments::InstanceSize(array_length);
         break;
       }
-      case kPcDescriptors: {
+      case kPcDescriptorsCid: {
         const RawPcDescriptors* raw_descriptors =
             reinterpret_cast<const RawPcDescriptors*>(this);
         intptr_t num_descriptors = Smi::Value(raw_descriptors->ptr()->length_);
         instance_size = PcDescriptors::InstanceSize(num_descriptors);
         break;
       }
-      case kStackmap: {
+      case kStackmapCid: {
         const RawStackmap* map = reinterpret_cast<const RawStackmap*>(this);
         intptr_t size_in_bytes = Smi::Value(map->ptr()->bitmap_size_in_bytes_);
         instance_size = Stackmap::InstanceSize(size_in_bytes);
         break;
       }
-      case kLocalVarDescriptors: {
+      case kLocalVarDescriptorsCid: {
         const RawLocalVarDescriptors* raw_descriptors =
             reinterpret_cast<const RawLocalVarDescriptors*>(this);
         intptr_t num_descriptors = raw_descriptors->ptr()->length_;
         instance_size = LocalVarDescriptors::InstanceSize(num_descriptors);
         break;
       }
-      case kExceptionHandlers: {
+      case kExceptionHandlersCid: {
         const RawExceptionHandlers* raw_handlers =
             reinterpret_cast<const RawExceptionHandlers*>(this);
         intptr_t num_handlers = Smi::Value(raw_handlers->ptr()->length_);
         instance_size = ExceptionHandlers::InstanceSize(num_handlers);
         break;
       }
-      case kDeoptInfo: {
+      case kDeoptInfoCid: {
         const RawDeoptInfo* raw_deopt_info =
             reinterpret_cast<const RawDeoptInfo*>(this);
         intptr_t num_entries = Smi::Value(raw_deopt_info->ptr()->length_);
         instance_size = DeoptInfo::InstanceSize(num_entries);
         break;
       }
-      case kJSRegExp: {
+      case kJSRegExpCid: {
         const RawJSRegExp* raw_jsregexp =
             reinterpret_cast<const RawJSRegExp*>(this);
         intptr_t data_length = Smi::Value(raw_jsregexp->ptr()->data_length_);
         instance_size = JSRegExp::InstanceSize(data_length);
         break;
       }
       case kFreeListElement: {
         ASSERT(FreeBit::decode(ptr()->tags_));
         uword addr = RawObject::ToAddr(const_cast<RawObject*>(this));
         FreeListElement* element = reinterpret_cast<FreeListElement*>(addr);
         instance_size = element->Size();
         break;
       }
       default:
         UNREACHABLE();
         break;
     }
   }
   ASSERT(instance_size != 0);
   uword tags = ptr()->tags_;
   ASSERT((instance_size == SizeTag::decode(tags)) ||
          (SizeTag::decode(tags) == 0));
   return instance_size;
 }
 
 
-ObjectKind RawObject::GetObjectKind() const {
-  intptr_t class_id = GetClassId();
-  ObjectKind kind;
-  if (class_id < kNumPredefinedKinds) {
-    kind = static_cast<ObjectKind>(class_id);
-  } else {
-    RawClass* raw_class = Isolate::Current()->class_table()->At(class_id);
-    kind = raw_class->ptr()->instance_kind_;
-  }
-  return kind;
-}
-
-
 intptr_t RawObject::VisitPointers(ObjectPointerVisitor* visitor) {
   intptr_t size = 0;
   NoHandleScope no_handles(visitor->isolate());
 
   // Only reasonable to be called on heap objects.
   ASSERT(IsHeapObject());
 
   // Read the necessary data out of the class before visting the class itself.
   intptr_t class_id = GetClassId();
-  ObjectKind kind;
 
-  if (class_id < kNumPredefinedKinds) {
-    kind = static_cast<ObjectKind>(class_id);
+  if (class_id < kNumPredefinedCids) {
+    switch (class_id) {
+#define RAW_VISITPOINTERS(clazz)                                               \
+      case clazz::kClassId: {                                                  \
+        Raw##clazz* raw_obj = reinterpret_cast<Raw##clazz*>(this);             \
+        size = Raw##clazz::Visit##clazz##Pointers(raw_obj, visitor);           \
+        break;                                                                 \
+      }
+      CLASS_LIST_NO_OBJECT(RAW_VISITPOINTERS)
+#undef RAW_VISITPOINTERS
+      case kFreeListElement: {
+        ASSERT(FreeBit::decode(ptr()->tags_));
+        uword addr = RawObject::ToAddr(const_cast<RawObject*>(this));
+        FreeListElement* element = reinterpret_cast<FreeListElement*>(addr);
+        size = element->Size();
+        break;
+      }
+      default:
+        OS::Print("Class Id: %d\n", class_id);
+        UNREACHABLE();
+        break;
+    }
   } else {
     RawClass* raw_class = Isolate::Current()->class_table()->At(class_id);
-    kind = raw_class->ptr()->instance_kind_;
-  }
-
-  switch (kind) {
-#define RAW_VISITPOINTERS(clazz) \
-    case clazz::kInstanceKind: { \
-      Raw##clazz* raw_obj = reinterpret_cast<Raw##clazz*>(this); \
-      size = Raw##clazz::Visit##clazz##Pointers(raw_obj, visitor); \
-      break; \
+    if (Class::IsSignatureClass(raw_class)) {
+      RawClosure* raw_obj = reinterpret_cast<RawClosure*>(this);
+      size = RawClosure::VisitClosurePointers(raw_obj, visitor);
+    } else {
+      RawInstance* raw_obj = reinterpret_cast<RawInstance*>(this);
+      size = RawInstance::VisitInstancePointers(raw_obj, visitor);
     }
-    CLASS_LIST_NO_OBJECT(RAW_VISITPOINTERS)
-#undef RAW_VISITPOINTERS
-    case kFreeListElement: {
-      ASSERT(FreeBit::decode(ptr()->tags_));
-      uword addr = RawObject::ToAddr(const_cast<RawObject*>(this));
-      FreeListElement* element = reinterpret_cast<FreeListElement*>(addr);
-      size = element->Size();
-      break;
-    }
-    default:
-      OS::Print("Kind: %d\n", kind);
-      UNREACHABLE();
-      break;
   }
 
   ASSERT(size != 0);
   ASSERT(size == Size());
   return size;
 }
 
 
 bool RawObject::FindObject(FindObjectVisitor* visitor) {
   ASSERT(visitor != NULL);
@@ skipping 130 matching lines @@
 intptr_t RawInstructions::VisitInstructionsPointers(
     RawInstructions* raw_obj, ObjectPointerVisitor* visitor) {
   RawInstructions* obj = raw_obj->ptr();
   visitor->VisitPointer(reinterpret_cast<RawObject**>(&obj->code_));
   return Instructions::InstanceSize(obj->size_);
 }
 
 
 bool RawInstructions::ContainsPC(RawObject* raw_obj, uword pc) {
   uword tags = raw_obj->ptr()->tags_;
-  if (RawObject::ClassIdTag::decode(tags) == kInstructions) {
+  if (RawObject::ClassIdTag::decode(tags) == kInstructionsCid) {
     RawInstructions* raw_instr = reinterpret_cast<RawInstructions*>(raw_obj);
     uword start_pc =
         reinterpret_cast<uword>(raw_instr->ptr()) + Instructions::HeaderSize();
     uword end_pc = start_pc + raw_instr->ptr()->size_;
     ASSERT(end_pc > start_pc);
     if ((pc >= start_pc) && (pc < end_pc)) {
       return true;
     }
   }
   return false;
@@ skipping 111 matching lines @@
     RawUnwindError* raw_obj, ObjectPointerVisitor* visitor) {
   visitor->VisitPointers(raw_obj->from(), raw_obj->to());
   return UnwindError::InstanceSize();
 }
 
 
 intptr_t RawInstance::VisitInstancePointers(RawInstance* raw_obj,
                                             ObjectPointerVisitor* visitor) {
   // Make sure that we got here with the tagged pointer as this.
   ASSERT(raw_obj->IsHeapObject());
-  RawClass* cls = Isolate::Current()->class_table()->At(
-    raw_obj->GetClassId());
+  RawClass* cls = Isolate::Current()->class_table()->At(raw_obj->GetClassId());
   intptr_t instance_size = cls->ptr()->instance_size_;
   intptr_t num_native_fields = cls->ptr()->num_native_fields_;
 
   // Calculate the first and last raw object pointer fields.
   uword obj_addr = RawObject::ToAddr(raw_obj);
   uword from = obj_addr + sizeof(RawObject) + num_native_fields * kWordSize;
   uword to = obj_addr + instance_size - kWordSize;
   visitor->VisitPointers(reinterpret_cast<RawObject**>(from),
                          reinterpret_cast<RawObject**>(to));
   return instance_size;
@@ skipping 357 matching lines @@
 intptr_t RawJSRegExp::VisitJSRegExpPointers(RawJSRegExp* raw_obj,
                                             ObjectPointerVisitor* visitor) {
   // Make sure that we got here with the tagged pointer as this.
   ASSERT(raw_obj->IsHeapObject());
   intptr_t length = Smi::Value(raw_obj->ptr()->data_length_);
   visitor->VisitPointers(raw_obj->from(), raw_obj->to());
   return JSRegExp::InstanceSize(length);
 }
 
 }  // namespace dart