- Add a class index to the classes.

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 "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
@@ skipping 201 matching lines @@
     case kVoidClass: return "void";
     case kUnresolvedClassClass: return "UnresolvedClass";
     case kTypeClass: return "Type";
     case kTypeParameterClass: return "TypeParameter";
     case kInstantiatedTypeClass: return "InstantiatedType";
     case kAbstractTypeArgumentsClass: return "AbstractTypeArguments";
     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";
@@ skipping 22 matching lines @@
     Smi::handle_vtable_ = fake_smi.vtable();
   }
 
   Heap* heap = Isolate::Current()->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);
-    InitializeObject(address, Instance::InstanceSize());  // Using 'null_'.
-    null_->ptr()->tags_ = 0;
+    InitializeObject(address,
+                     kNullClassIndex,
+                     Instance::InstanceSize());  // Using 'null_'.
   }
 
   // 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::Current()->object_store()->set_empty_array(Array::Handle());
 
   Class& cls = Class::Handle();
 
   // Allocate and initialize the class class.
-  // At this point, class_class_ is still RAW_NULL, i.e. different from 'null_',
-  // since 'null_' is not RAW_NULL anymore. However, class_class_ == null_ must
-  // be true before calling Class::New<Class>(), or it will fail.
-  class_class_ = Class::Handle().raw();  // Set 'class_class_' to 'null_'.
-  cls = Class::New<Class>();
-  cls.set_is_finalized();
-  class_class_ = cls.raw();
-  // Make the class_ field point to itself.
-  class_class_->ptr()->class_ = 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);
+    // Make the class_ field point to itself.
+    class_class_->ptr()->class_ = class_class_;
+
+    Class fake;
+    // Initialization from Class::New<Class>.
+    cls = 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_index(Class::kInstanceKind);
+    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::Current()->class_table()->Register(cls);
+  }
 
   // Allocate and initialize the null class.
-  cls = Class::New<Instance>();
+  cls = Class::New<Instance>(kNullClassIndex);
   cls.set_is_finalized();
   null_class_ = cls.raw();
 
   // Complete initialization of null_ instance, i.e. initialize its class_
   // field.
   null_->ptr()->class_ = null_class_;
 
-  // Allocate and initialize the sentinel values of an instance class.
+  // Allocate and initialize the sentinel values.
   {
-    cls = Class::New<Instance>();
+    cls = Class::New<Instance>(kSentinelClassIndex);
     Instance& sentinel = Instance::Handle();
     sentinel ^= Object::Allocate(cls, Instance::InstanceSize(), Heap::kOld);
     sentinel_ = sentinel.raw();
 
     Instance& transition_sentinel = Instance::Handle();
     transition_sentinel ^=
         Object::Allocate(cls, 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
   // array, but remain null.
-  cls = Class::New<Instance>();
+  cls = Class::New<Instance>(kDynamicClassIndex);
   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>();
+  cls = Class::New<Instance>(kVoidClassIndex);
   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<InstantiatedType>();
@@ skipping 189 matching lines @@
   RegisterClass(cls, "ObjectArray", impl_script, core_impl_lib);
   pending_classes.Add(cls, Heap::kOld);
 
   cls = Class::New<ImmutableArray>();
   object_store->set_immutable_array_class(cls);
   cls.set_type_arguments_instance_field_offset(Array::type_arguments_offset());
   ASSERT(object_store->immutable_array_class() != object_store->array_class());
   RegisterClass(cls, "ImmutableArray", impl_script, core_impl_lib);
   pending_classes.Add(cls, Heap::kOld);
 
+  cls = object_store->growable_object_array_class();  // Was allocated above.
+  RegisterClass(cls, "Siva's GrowableObjectArray", impl_script, core_impl_lib);
+  pending_classes.Add(cls, Heap::kOld);
+
   cls = object_store->one_byte_string_class();  // Was allocated above.
   RegisterClass(cls, "OneByteString", impl_script, core_impl_lib);
   pending_classes.Add(cls, Heap::kOld);
 
   cls = Class::New<TwoByteString>();
   object_store->set_two_byte_string_class(cls);
   RegisterClass(cls, "TwoByteString", impl_script, core_impl_lib);
   pending_classes.Add(cls, Heap::kOld);
 
   cls = Class::New<FourByteString>();
@@ skipping 30 matching lines @@
   // Initialize the base interfaces used by the core VM classes.
   const Script& script = Script::Handle(Bootstrap::LoadScript());
 
   // Allocate and initialize the Object class and type.
   // The Object and ExternalByteArray classes are the only pre-allocated
   // non-interface classes in the core library.
   cls = Class::New<Instance>();
   object_store->set_object_class(cls);
   cls.set_name(String::Handle(String::NewSymbol("Object")));
   cls.set_script(script);
+  cls.set_class_state(RawClass::kPreFinalized);
   core_lib.AddClass(cls);
   pending_classes.Add(cls, Heap::kOld);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_object_type(type);
 
   cls = Class::New<InternalByteArray>();
   object_store->set_internal_byte_array_class(cls);
   String& public_class_name = String::Handle();
   public_class_name = String::New("_InternalByteArray");
   cls.set_name(String::Handle(core_lib.PrivateName(public_class_name)));
@@ skipping 145 matching lines @@
 
   cls = Class::New<GrowableObjectArray>();
   object_store->set_growable_object_array_class(cls);
 
   cls = Class::New<InternalByteArray>();
   object_store->set_internal_byte_array_class(cls);
 
   cls = Class::New<ExternalByteArray>();
   object_store->set_external_byte_array_class(cls);
 
-  cls = Class::New<Instance>();
-  object_store->set_object_class(cls);
-
   cls = Class::New<Smi>();
   object_store->set_smi_class(cls);
 
   cls = Class::New<Mint>();
   object_store->set_mint_class(cls);
 
   cls = Class::New<Double>();
   object_store->set_double_class(cls);
 
   cls = Class::New<Bigint>();
@@ skipping 33 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 size) {
+void Object::InitializeObject(uword address, intptr_t index, 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::ClassTag::update(index, tags);
+  tags = RawObject::SizeTag::update(size, tags);
+  reinterpret_cast<RawObject*>(address)->tags_ = tags;
 }
 
 
 RawObject* Object::Allocate(const Class& cls,
                             intptr_t size,
                             Heap::Space space) {
   ASSERT(Utils::IsAligned(size, kObjectAlignment));
   Isolate* isolate = Isolate::Current();
   Heap* heap = isolate->heap();
 
   uword address = heap->Allocate(size, space);
   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(isolate->object_store()->out_of_memory());
     Exceptions::Throw(exception);
     UNREACHABLE();
   }
   NoGCScope no_gc;
-  InitializeObject(address, size);
+  InitializeObject(address, cls.index(), size);
   RawObject* raw_obj = reinterpret_cast<RawObject*>(address + kHeapObjectTag);
   raw_obj->ptr()->class_ = cls.raw();
-  uword tags = 0;
-  tags = RawObject::SizeTag::update(size, tags);
-  raw_obj->ptr()->tags_ = tags;
+  ASSERT(cls.index() == RawObject::ClassTag::decode(raw_obj->ptr()->tags_));
   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());
@@ skipping 33 matching lines @@
 
 template <class FakeObject>
 RawClass* Class::New() {
   Class& class_class = Class::Handle(Object::class_class());
   Class& result = Class::Handle();
   {
     RawObject* raw = Object::Allocate(class_class,
                                       Class::InstanceSize(),
                                       Heap::kOld);
     NoGCScope no_gc;
-    if (class_class.IsNull()) {
-      // Allocating class_class, avoid using uninitialized class vtable.
-      result.raw_ = raw;
-    } else {
-      result ^= raw;
-    }
+    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_index((FakeObject::kInstanceKind != kInstance) ?
+                   FakeObject::kInstanceKind : kIllegalObjectKind);
   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_index_ = Scanner::kDummyTokenIndex;
   result.InitEmptyFields();
+  Isolate::Current()->class_table()->Register(result);
   return result.raw();
 }
 
 
 // Initialize class fields of type Array with empty array.
 void Class::InitEmptyFields() {
   const Array& empty_array = Array::Handle(Array::Empty());
   if (empty_array.IsNull()) {
     // The empty array has not been initialized yet.
     return;
@@ skipping 272 matching lines @@
     // Only static const fields may contain the Object::sentinel value.
     ASSERT(!(field.is_static() && field.is_final()) ||
            (field.value() == Object::sentinel()));
   }
   // The value of static fields is already initialized to null.
   StorePointer(&raw_ptr()->fields_, value.raw());
 }
 
 
 template <class FakeInstance>
-RawClass* Class::New(const String& name,
-                     const Script& script,
-                     intptr_t token_index) {
-  ASSERT(token_index >= 0);
+RawClass* Class::New(intptr_t index) {
   Class& class_class = Class::Handle(Object::class_class());
   Class& result = Class::Handle();
   {
     RawObject* raw = Object::Allocate(class_class,
                                       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_name(name);
-  result.set_script(script);
-  result.set_token_index(token_index);
+  result.set_index(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_index) {
+  Class& result = Class::Handle(New<FakeInstance>(kIllegalObjectKind));
+  result.set_name(name);
+  result.set_script(script);
+  result.set_token_index(token_index);
   return result.raw();
 }
 
 
 RawClass* Class::New(const String& name,
                      const Script& script,
                      intptr_t token_index) {
   Class& result = Class::Handle(New<Instance>(name, script, token_index));
   return result.raw();
 }
@@ skipping 7084 matching lines @@
     NoGCScope no_gc;
     result ^= raw;
     result.SetLength(len);
   }
   return result.raw();
 }
 
 
 void Array::MakeImmutable() const {
   Isolate* isolate = Isolate::Current();
-  raw()->ptr()->class_ = isolate->object_store()->immutable_array_class();
+  const Class& cls = Class::Handle(
+      isolate, isolate->object_store()->immutable_array_class());
+  {
+    NoGCScope no_gc;
+    raw_ptr()->class_ = cls.raw();
+    uword tags = raw_ptr()->tags_;
+    tags = RawObject::ClassTag::update(cls.index(), tags);
+    raw_ptr()->tags_ = tags;
+  }
 }
 
 
 const char* Array::ToCString() const {
   return "Array";
 }
 
 
 RawArray* Array::Grow(const Array& source, int new_length, Heap::Space space) {
   intptr_t len = source.IsNull() ? 0 : source.Length();
@@ skipping 622 matching lines @@
   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 = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len + 1));
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 }  // namespace dart