Remove some of the unused classes stored in the object store.

runtime/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/cpu.h"
@@ skipping 697 matching lines @@
   cls = Class::New<Instance>(kVoidCid);
   cls.set_num_type_arguments(0);
   cls.set_num_own_type_arguments(0);
   cls.set_is_type_finalized();
   cls.set_is_finalized();
   void_class_ = cls.raw();
 
   cls = Class::New<Type>();
   cls.set_is_type_finalized();
   cls.set_is_finalized();
-  isolate->object_store()->set_type_class(cls);
 
   cls = dynamic_class_;
   dynamic_type_ = Type::NewNonParameterizedType(cls);
 
   cls = void_class_;
   void_type_ = Type::NewNonParameterizedType(cls);
 
   // Allocate and initialize singleton true and false boolean objects.
   cls = Class::New<Bool>();
   isolate->object_store()->set_bool_class(cls);
@@ skipping 216 matching lines @@
 
   // canonical_type_arguments_ are Smi terminated.
   // Last element contains the count of used slots.
   const intptr_t kInitialCanonicalTypeArgumentsSize = 4;
   array = Array::New(kInitialCanonicalTypeArgumentsSize + 1);
   array.SetAt(kInitialCanonicalTypeArgumentsSize,
               Smi::Handle(isolate, Smi::New(0)));
   object_store->set_canonical_type_arguments(array);
 
   // Setup type class early in the process.
-  cls = Class::New<Type>();
-  object_store->set_type_class(cls);
-
-  cls = Class::New<TypeRef>();
-  object_store->set_type_ref_class(cls);
-
-  cls = Class::New<TypeParameter>();
-  object_store->set_type_parameter_class(cls);
-
-  cls = Class::New<BoundedType>();
-  object_store->set_bounded_type_class(cls);
-
-  cls = Class::New<MixinAppType>();
-  object_store->set_mixin_app_type_class(cls);
-
-  cls = Class::New<LibraryPrefix>();
-  object_store->set_library_prefix_class(cls);
+  const Class& type_cls = Class::Handle(isolate, Class::New<Type>());
+  const Class& type_ref_cls = Class::Handle(isolate, Class::New<TypeRef>());
+  const Class& type_parameter_cls = Class::Handle(isolate,
+                                                  Class::New<TypeParameter>());
+  const Class& bounded_type_cls = Class::Handle(isolate,
+                                                Class::New<BoundedType>());
+  const Class& mixin_app_type_cls = Class::Handle(isolate,
+                                                  Class::New<MixinAppType>());
+  const Class& library_prefix_cls = Class::Handle(isolate,
+                                                  Class::New<LibraryPrefix>());
 
   // Pre-allocate the OneByteString class needed by the symbol table.
   cls = Class::NewStringClass(kOneByteStringCid);
   object_store->set_one_byte_string_class(cls);
 
   // Pre-allocate the TwoByteString class needed by the symbol table.
   cls = Class::NewStringClass(kTwoByteStringCid);
   object_store->set_two_byte_string_class(cls);
 
   // Setup the symbol table for the symbols created in the isolate.
@@ skipping 84 matching lines @@
   pending_classes.Add(cls);
 
   cls = Class::New<ReceivePort>();
   RegisterPrivateClass(cls, Symbols::_RawReceivePortImpl(), isolate_lib);
   pending_classes.Add(cls);
 
   cls = Class::New<SendPort>();
   RegisterPrivateClass(cls, Symbols::_SendPortImpl(), isolate_lib);
   pending_classes.Add(cls);
 
-  cls = Class::New<Stacktrace>();
-  object_store->set_stacktrace_class(cls);
-  RegisterClass(cls, Symbols::StackTrace(), core_lib);
-  pending_classes.Add(cls);
+  const Class& stacktrace_cls = Class::Handle(isolate,
+                                              Class::New<Stacktrace>());
+  RegisterClass(stacktrace_cls, Symbols::StackTrace(), core_lib);
+  pending_classes.Add(stacktrace_cls);
   // Super type set below, after Object is allocated.
 
   cls = Class::New<JSRegExp>();
   RegisterPrivateClass(cls, Symbols::JSSyntaxRegExp(), core_lib);
   pending_classes.Add(cls);
 
   // Initialize the base interfaces used by the core VM classes.
 
   // Allocate and initialize the pre-allocated classes in the core library.
   // The script and token index of these pre-allocated classes is set up in
@@ skipping 16 matching lines @@
   pending_classes.Add(cls);
 
   cls = Class::New<Instance>(kNullCid);
   object_store->set_null_class(cls);
   cls.set_num_type_arguments(0);
   cls.set_num_own_type_arguments(0);
   cls.set_is_prefinalized();
   RegisterClass(cls, Symbols::Null(), core_lib);
   pending_classes.Add(cls);
 
-  cls = object_store->library_prefix_class();
-  ASSERT(!cls.IsNull());
-  RegisterPrivateClass(cls, Symbols::_LibraryPrefix(), core_lib);
-  pending_classes.Add(cls);
+  ASSERT(!library_prefix_cls.IsNull());
+  RegisterPrivateClass(library_prefix_cls, Symbols::_LibraryPrefix(), core_lib);
+  pending_classes.Add(library_prefix_cls);
 
-  cls = object_store->type_class();
-  RegisterPrivateClass(cls, Symbols::Type(), core_lib);
-  pending_classes.Add(cls);
+  RegisterPrivateClass(type_cls, Symbols::Type(), core_lib);
+  pending_classes.Add(type_cls);
 
-  cls = object_store->type_ref_class();
-  RegisterPrivateClass(cls, Symbols::TypeRef(), core_lib);
-  pending_classes.Add(cls);
+  RegisterPrivateClass(type_ref_cls, Symbols::TypeRef(), core_lib);
+  pending_classes.Add(type_ref_cls);
 
-  cls = object_store->type_parameter_class();
-  RegisterPrivateClass(cls, Symbols::TypeParameter(), core_lib);
-  pending_classes.Add(cls);
+  RegisterPrivateClass(type_parameter_cls, Symbols::TypeParameter(), core_lib);
+  pending_classes.Add(type_parameter_cls);
 
-  cls = object_store->bounded_type_class();
-  RegisterPrivateClass(cls, Symbols::BoundedType(), core_lib);
-  pending_classes.Add(cls);
+  RegisterPrivateClass(bounded_type_cls, Symbols::BoundedType(), core_lib);
+  pending_classes.Add(bounded_type_cls);
 
-  cls = object_store->mixin_app_type_class();
-  RegisterPrivateClass(cls, Symbols::MixinAppType(), core_lib);
-  pending_classes.Add(cls);
+  RegisterPrivateClass(mixin_app_type_cls, Symbols::MixinAppType(), core_lib);
+  pending_classes.Add(mixin_app_type_cls);
 
   cls = Class::New<Integer>();
   object_store->set_integer_implementation_class(cls);
   RegisterPrivateClass(cls, Symbols::IntegerImplementation(), core_lib);
   pending_classes.Add(cls);
 
   cls = Class::New<Smi>();
   object_store->set_smi_class(cls);
   RegisterPrivateClass(cls, Symbols::_Smi(), core_lib);
   pending_classes.Add(cls);
@@ skipping 93 matching lines @@
   lib = Library::LookupLibrary(Symbols::DartTypedData());
   if (lib.IsNull()) {
     lib = Library::NewLibraryHelper(Symbols::DartTypedData(), true);
     lib.SetLoadRequested();
     lib.Register();
     isolate->object_store()->set_bootstrap_library(ObjectStore::kTypedData,
                                                    lib);
   }
   ASSERT(!lib.IsNull());
   ASSERT(lib.raw() == Library::TypedDataLibrary());
-  const intptr_t typed_data_class_array_length =
-      RawObject::NumberOfTypedDataClasses();
-  Array& typed_data_classes =
-      Array::Handle(Array::New(typed_data_class_array_length));
-  int index = 0;
 #define REGISTER_TYPED_DATA_CLASS(clazz)                                       \
   cls = Class::NewTypedDataClass(kTypedData##clazz##Cid);                      \
-  index = kTypedData##clazz##Cid - kTypedDataInt8ArrayCid;                     \
-  typed_data_classes.SetAt(index, cls);                                        \
   RegisterPrivateClass(cls, Symbols::_##clazz(), lib);                         \
 
   CLASS_LIST_TYPED_DATA(REGISTER_TYPED_DATA_CLASS);
 #undef REGISTER_TYPED_DATA_CLASS
 #define REGISTER_TYPED_DATA_VIEW_CLASS(clazz)                                  \
   cls = Class::NewTypedDataViewClass(kTypedData##clazz##ViewCid);              \
-  index = kTypedData##clazz##ViewCid - kTypedDataInt8ArrayCid;                 \
-  typed_data_classes.SetAt(index, cls);                                        \
   RegisterPrivateClass(cls, Symbols::_##clazz##View(), lib);                   \
   pending_classes.Add(cls);                                                    \
 
   CLASS_LIST_TYPED_DATA(REGISTER_TYPED_DATA_VIEW_CLASS);
   cls = Class::NewTypedDataViewClass(kByteDataViewCid);
-  index = kByteDataViewCid - kTypedDataInt8ArrayCid;
-  typed_data_classes.SetAt(index, cls);
   RegisterPrivateClass(cls, Symbols::_ByteDataView(), lib);
   pending_classes.Add(cls);
 #undef REGISTER_TYPED_DATA_VIEW_CLASS
 #define REGISTER_EXT_TYPED_DATA_CLASS(clazz)                                   \
   cls = Class::NewExternalTypedDataClass(kExternalTypedData##clazz##Cid);      \
-  index = kExternalTypedData##clazz##Cid - kTypedDataInt8ArrayCid;             \
-  typed_data_classes.SetAt(index, cls);                                        \
   RegisterPrivateClass(cls, Symbols::_External##clazz(), lib);                 \
 
   cls = Class::New<Instance>(kByteBufferCid);
   cls.set_instance_size(0);
   cls.set_next_field_offset(-kWordSize);
-  index = kByteBufferCid - kTypedDataInt8ArrayCid;
-  typed_data_classes.SetAt(index, cls);
   RegisterPrivateClass(cls, Symbols::_ByteBuffer(), lib);
   pending_classes.Add(cls);
 
   CLASS_LIST_TYPED_DATA(REGISTER_EXT_TYPED_DATA_CLASS);
 #undef REGISTER_EXT_TYPED_DATA_CLASS
   // Register Float32x4 and Int32x4 in the object store.
   cls = Class::New<Float32x4>();
   object_store->set_float32x4_class(cls);
   RegisterPrivateClass(cls, Symbols::_Float32x4(), lib);
   cls = Class::New<Int32x4>();
@@ skipping 23 matching lines @@
 
   cls = Class::New<Instance>(kIllegalCid);
   RegisterClass(cls, Symbols::Float64x2(), lib);
   cls.set_num_type_arguments(0);
   cls.set_num_own_type_arguments(0);
   cls.set_is_prefinalized();
   pending_classes.Add(cls);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_float64x2_type(type);
 
-  object_store->set_typed_data_classes(typed_data_classes);
-
   // Set the super type of class Stacktrace to Object type so that the
   // 'toString' method is implemented.
-  cls = object_store->stacktrace_class();
   type = object_store->object_type();
-  cls.set_super_type(type);
+  stacktrace_cls.set_super_type(type);
 
   // Abstract class that represents the Dart class Function.
   cls = Class::New<Instance>(kIllegalCid);
   cls.set_num_type_arguments(0);
   cls.set_num_own_type_arguments(0);
   cls.set_is_prefinalized();
   RegisterClass(cls, Symbols::Function(), core_lib);
   pending_classes.Add(cls);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_function_type(type);
@@ skipping 104 matching lines @@
 
 void Object::InitFromSnapshot(Isolate* isolate) {
   TIMERSCOPE(isolate, time_bootstrap);
   ObjectStore* object_store = isolate->object_store();
 
   Class& cls = Class::Handle();
 
   // Set up empty classes in the object store, these will get
   // initialized correctly when we read from the snapshot.
   // This is done to allow bootstrapping of reading classes from the snapshot.
+  // Some classes are not stored in the object store. Yet we still need to
+  // create their Class object so that they get put into the class_table
+  // (as a side effect of Class::New()).
+
   cls = Class::New<Instance>(kInstanceCid);
   object_store->set_object_class(cls);
 
   cls = Class::New<LibraryPrefix>();
-  object_store->set_library_prefix_class(cls);
-
   cls = Class::New<Type>();
-  object_store->set_type_class(cls);
-
   cls = Class::New<TypeRef>();
-  object_store->set_type_ref_class(cls);
-
   cls = Class::New<TypeParameter>();
-  object_store->set_type_parameter_class(cls);
-
   cls = Class::New<BoundedType>();
-  object_store->set_bounded_type_class(cls);
-
   cls = Class::New<MixinAppType>();
-  object_store->set_mixin_app_type_class(cls);
 
   cls = Class::New<Array>();
   object_store->set_array_class(cls);
 
   cls = Class::New<Array>(kImmutableArrayCid);
   object_store->set_immutable_array_class(cls);
 
   cls = Class::New<GrowableObjectArray>();
   object_store->set_growable_object_array_class(cls);
 
@@ skipping 54 matching lines @@
 
   cls = Class::New<Bool>();
   object_store->set_bool_class(cls);
 
   cls = Class::New<Instance>(kNullCid);
   object_store->set_null_class(cls);
 
   cls = Class::New<Capability>();
   cls = Class::New<ReceivePort>();
   cls = Class::New<SendPort>();
-
   cls = Class::New<Stacktrace>();
-  object_store->set_stacktrace_class(cls);
-
   cls = Class::New<JSRegExp>();
-
-  // Some classes are not stored in the object store. Yet we still need to
-  // create their Class object so that they get put into the class_table
-  // (as a side effect of Class::New()).
   cls = Class::New<Number>();
 
   cls = Class::New<WeakProperty>();
   object_store->set_weak_property_class(cls);
 
   cls = Class::New<MirrorReference>();
-
   cls = Class::New<UserTag>();
 }
 
 
 void Object::Print() const {
   OS::Print("%s\n", ToCString());
 }
 
 
 static void AddNameProperties(JSONObject* jsobj,
@@ skipping 8593 matching lines @@
 
 
 void LibraryPrefix::InvalidateDependentCode() const {
   PrefixDependentArray a(*this);
   a.DisableCode();
   set_is_loaded();
 }
 
 
 RawLibraryPrefix* LibraryPrefix::New() {
-  ASSERT(Isolate::Current()->object_store()->library_prefix_class() !=
-      Class::null());
   RawObject* raw = Object::Allocate(LibraryPrefix::kClassId,
                                     LibraryPrefix::InstanceSize(),
                                     Heap::kOld);
   return reinterpret_cast<RawLibraryPrefix*>(raw);
 }
 
 
 RawLibraryPrefix* LibraryPrefix::New(const String& name,
                                      const Namespace& import,
                                      bool deferred_load,
@@ skipping 4558 matching lines @@
   StorePointer(&raw_ptr()->type_class_, value.raw());
 }
 
 
 void Type::set_arguments(const TypeArguments& value) const {
   StorePointer(&raw_ptr()->arguments_, value.raw());
 }
 
 
 RawType* Type::New(Heap::Space space) {
-  ASSERT(Isolate::Current()->object_store()->type_class() != Class::null());
   RawObject* raw = Object::Allocate(Type::kClassId,
                                     Type::InstanceSize(),
                                     space);
   return reinterpret_cast<RawType*>(raw);
 }
 
 
 RawType* Type::New(const Object& clazz,
                    const TypeArguments& arguments,
                    intptr_t token_pos,
@@ skipping 189 matching lines @@
       }
     }
   }
   (*trail)->Add(*this);
   (*trail)->Add(buddy);
   return false;
 }
 
 
 RawTypeRef* TypeRef::New() {
-  ASSERT(Isolate::Current()->object_store()->type_ref_class() != Class::null());
   RawObject* raw = Object::Allocate(TypeRef::kClassId,
                                     TypeRef::InstanceSize(),
                                     Heap::kOld);
   return reinterpret_cast<RawTypeRef*>(raw);
 }
 
 
 RawTypeRef* TypeRef::New(const AbstractType& type) {
   const TypeRef& result = TypeRef::Handle(TypeRef::New());
   result.set_type(type);
@@ skipping 177 matching lines @@
   ASSERT(IsFinalized());
   uint32_t result = Class::Handle(parameterized_class()).id();
   // No need to include the hash of the bound, since the type parameter is fully
   // identified by its class and index.
   result = CombineHashes(result, index());
   return FinalizeHash(result);
 }
 
 
 RawTypeParameter* TypeParameter::New() {
-  ASSERT(Isolate::Current()->object_store()->type_parameter_class() !=
-         Class::null());
   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,
@@ skipping 199 matching lines @@
   uint32_t result = AbstractType::Handle(type()).Hash();
   // No need to include the hash of the bound, since the bound is defined by the
   // type parameter (modulo instantiation state).
   result = CombineHashes(result,
                          TypeParameter::Handle(type_parameter()).Hash());
   return FinalizeHash(result);
 }
 
 
 RawBoundedType* BoundedType::New() {
-  ASSERT(Isolate::Current()->object_store()->bounded_type_class() !=
-         Class::null());
   RawObject* raw = Object::Allocate(BoundedType::kClassId,
                                     BoundedType::InstanceSize(),
                                     Heap::kOld);
   return reinterpret_cast<RawBoundedType*>(raw);
 }
 
 
 RawBoundedType* BoundedType::New(const AbstractType& type,
                                  const AbstractType& bound,
                                  const TypeParameter& type_parameter) {
@@ skipping 85 matching lines @@
   StorePointer(&raw_ptr()->super_type_, value.raw());
 }
 
 
 void MixinAppType::set_mixin_types(const Array& value) const {
   StorePointer(&raw_ptr()->mixin_types_, value.raw());
 }
 
 
 RawMixinAppType* MixinAppType::New() {
-  ASSERT(Isolate::Current()->object_store()->mixin_app_type_class() !=
-         Class::null());
   // MixinAppType objects do not survive finalization, so allocate
   // on new heap.
   RawObject* raw = Object::Allocate(MixinAppType::kClassId,
                                     MixinAppType::InstanceSize(),
                                     Heap::kNew);
   return reinterpret_cast<RawMixinAppType*>(raw);
 }
 
 
 RawMixinAppType* MixinAppType::New(const AbstractType& super_type,
@@ skipping 4363 matching lines @@
 
 
 bool Stacktrace::expand_inlined() const {
   return raw_ptr()->expand_inlined_;
 }
 
 
 RawStacktrace* Stacktrace::New(const Array& code_array,
                                const Array& pc_offset_array,
                                Heap::Space space) {
-  ASSERT(Isolate::Current()->object_store()->stacktrace_class() !=
-         Class::null());
   Stacktrace& result = Stacktrace::Handle();
   {
     RawObject* raw = Object::Allocate(Stacktrace::kClassId,
                                       Stacktrace::InstanceSize(),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
   }
   result.set_code_array(code_array);
   result.set_pc_offset_array(pc_offset_array);
@@ skipping 519 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart