- Add a class index to the classes.

vm/object.h

 // 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.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 344 matching lines @@
     // Filter stores based on source and target.
     if (value->IsNewObject() && raw()->IsOldObject()) {
       uword ptr = reinterpret_cast<uword>(addr);
       Isolate::Current()->store_buffer()->AddPointer(ptr);
     }
   }
 
   RawObject* raw_;  // The raw object reference.
 
  private:
-  static void InitializeObject(uword address, intptr_t size);
+  static void InitializeObject(uword address, intptr_t index, intptr_t size);
 
   cpp_vtable* vtable_address() const {
     return reinterpret_cast<cpp_vtable*>(reinterpret_cast<word>(this));
   }
 
   static cpp_vtable handle_vtable_;
 
   // The static values below are singletons shared between the different
   // isolates. They are all allocated in the non-GC'd Dart::vm_isolate_.
   static RawObject* null_;
@@ skipping 68 matching lines @@
             (value + kWordSize == raw_ptr()->instance_size_)));
     raw_ptr()->next_field_offset_ = value;
   }
 
   cpp_vtable handle_vtable() const { return raw_ptr()->handle_vtable_; }
   void set_handle_vtable(cpp_vtable value) const {
     raw_ptr()->handle_vtable_ = value;
   }
 
   ObjectKind instance_kind() const { return raw_ptr()->instance_kind_; }
-  void set_instance_kind(ObjectKind value) {
+  void set_instance_kind(ObjectKind value) const {
     raw_ptr()->instance_kind_ = value;
   }
 
+  intptr_t index() const { return raw_ptr()->index_; }
+  void set_index(intptr_t value) const {
+    raw_ptr()->index_ = value;
+  }
+
   RawString* Name() const;
 
   RawScript* script() const { return raw_ptr()->script_; }
 
   intptr_t token_index() const { return raw_ptr()->token_index_; }
 
   // This class represents the signature class of a closure function if
   // signature_function() is not null.
   // The associated function may be a closure function (with code) or a
   // signature function (without code) solely describing the result type and
@@ skipping 187 matching lines @@
   }
   void set_allocation_stub(const Code& value) const;
 
   RawArray* constants() const;
 
   void Finalize() const;
 
   // Allocate a class used for VM internal objects.
   template <class FakeObject> static RawClass* New();
 
-  // Allocate an instance class which has a VM implementation.
-  template <class FakeInstance> static RawClass* New(const String& name,
-                                                     const Script& script,
-                                                     intptr_t token_index);
-
   // Allocate instance classes and interfaces.
   static RawClass* New(const String& name,
                        const Script& script,
                        intptr_t token_index);
   static RawClass* NewInterface(const String& name,
                                 const Script& script,
                                 intptr_t token_index);
   static RawClass* NewNativeWrapper(Library* library,
                                     const String& name,
                                     int num_fields);
@@ skipping 28 matching lines @@
 
   void CalculateFieldOffsets() const;
 
   // Assigns empty array to all raw class array fields.
   void InitEmptyFields();
 
   RawFunction* LookupAccessorFunction(const char* prefix,
                                       intptr_t prefix_length,
                                       const String& name) const;
 
+  // Allocate an instance class which has a VM implementation.
+  template <class FakeInstance> static RawClass* New(intptr_t index);
+  template <class FakeInstance> static RawClass* New(const String& name,
+                                                     const Script& script,
+                                                     intptr_t token_index);
+
   HEAP_OBJECT_IMPLEMENTATION(Class, Object);
   friend class Object;
   friend class Instance;
   friend class Type;
 };
 
 
 // Unresolved class is used for storing unresolved names which will be resolved
 // to a class after all classes have been loaded and finalized.
 class UnresolvedClass : public Object {
@@ skipping 3113 matching lines @@
   friend class Class;
 };
 
 
 // Breaking cycles and loops.
 RawClass* Object::clazz() const {
   uword raw_value = reinterpret_cast<uword>(raw_);
   if ((raw_value & kSmiTagMask) == kSmiTag) {
     return Smi::Class();
   }
-  return raw_->ptr()->class_;
+  RawClass* result = raw_->ptr()->class_;
+  ASSERT(result->ptr()->index_ ==
+      RawObject::ClassTag::decode(raw_->ptr()->tags_));

[siva, 2012/04/02 18:29:21]

Also assert class_table.At(RawObject::ClassTag::decode(raw_->ptr()->tags_) ==
result
because that is what we will be returning here right.

[Ivan Posva, 2012/04/29 21:08:25]

Done.

+  return result;
 }
 
 
 void Object::SetRaw(RawObject* value) {
   // NOTE: The assignment "raw_ = value" should be the first statement in
   // this function. Also do not use 'value' in this function after the
   // assignment (use 'raw_' instead).
   raw_ = value;
   if ((reinterpret_cast<uword>(raw_) & kSmiTagMask) == kSmiTag) {
     set_vtable(Smi::handle_vtable_);
@@ skipping 52 matching lines @@
 }
 
 
 intptr_t Stackmap::SizeInBits() const {
   return (Smi::Value(raw_ptr()->bitmap_size_in_bytes_) * kBitsPerByte);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_