- Register canonical names for internal VM classes and get rid of the method GetSingletonClassName

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/bigint_operations.h"
@@ skipping 41 matching lines @@
 cpp_vtable Object::builtin_vtables_[kNumPredefinedCids] = { 0 };
 cpp_vtable Smi::handle_vtable_ = 0;
 
 // These are initialized to a value that will force a illegal memory access if
 // they are being used.
 #if defined(RAW_NULL)
 #error RAW_NULL should not be defined.
 #endif
 #define RAW_NULL kHeapObjectTag
 RawObject* Object::null_ = reinterpret_cast<RawInstance*>(RAW_NULL);
+RawArray* Object::empty_array_ = reinterpret_cast<RawArray*>(RAW_NULL);
 RawInstance* Object::sentinel_ = reinterpret_cast<RawInstance*>(RAW_NULL);
 RawInstance* Object::transition_sentinel_ =
     reinterpret_cast<RawInstance*>(RAW_NULL);
 RawClass* Object::class_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::null_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::dynamic_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::void_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::unresolved_class_class_ =
     reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::type_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
@@ skipping 106 matching lines @@
   if (is_setter) {
     // Setters need to end with '='.
     const String& suffix = String::Handle(Symbols::Equals());
     return String::Concat(result, suffix);
   }
 
   return result.raw();
 }
 
 
-// TODO(asiva): Get rid of this function once we have predefined names for
-// the shared classes and set that up in the name field.
-const char* Object::GetSingletonClassName(intptr_t class_id) {
-  switch (class_id) {
-    case kClassCid: return "Class";
-    case kNullCid: return "Null";
-    case kDynamicCid: return "Dynamic";
-    case kVoidCid: return "void";
-    case kUnresolvedClassCid: return "UnresolvedClass";
-    case kTypeCid: return "Type";
-    case kTypeParameterCid: return "TypeParameter";
-    case kTypeArgumentsCid: return "TypeArguments";
-    case kInstantiatedTypeArgumentsCid: return "InstantiatedTypeArguments";
-    case kFunctionCid: return "Function";
-    case kFieldCid: return "Field";
-    case kLiteralTokenCid: return "LiteralToken";
-    case kTokenStreamCid: return "TokenStream";
-    case kScriptCid: return "Script";
-    case kLibraryCid: return "Library";
-    case kLibraryPrefixCid: return "LibraryPrefix";
-    case kCodeCid: return "Code";
-    case kInstructionsCid: return "Instructions";
-    case kPcDescriptorsCid: return "PcDescriptors";
-    case kStackmapCid: return "Stackmap";
-    case kLocalVarDescriptorsCid: return "LocalVarDescriptors";
-    case kExceptionHandlersCid: return "ExceptionHandlers";
-    case kContextCid: return "Context";
-    case kContextScopeCid: return "ContextScope";
-    case kICDataCid: return "ICData";
-    case kSubtypeTestCacheCid: return "SubtypeTestCache";
-    case kApiErrorCid: return "ApiError";
-    case kLanguageErrorCid: return "LanguageError";
-    case kUnhandledExceptionCid: return "UnhandledException";
-    case kUnwindErrorCid: return "UnwindError";
-    default: break;
-  }
-  UNREACHABLE();
-  return NULL;
-}
-
-
 void Object::InitOnce() {
   // TODO(iposva): NoGCScope needs to be added here.
   ASSERT(class_class() == null_);
   // Initialize the static vtable values.
   {
     Object fake_object;
     Smi fake_smi;
     Object::handle_vtable_ = fake_object.vtable();
     Smi::handle_vtable_ = fake_smi.vtable();
   }
 
   Isolate* isolate = Isolate::Current();
   Heap* heap = isolate->heap();
-  // Allocate and initialize the null instance, except its class_ field.
+  // Allocate and initialize the null instance.
   // '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);
     // The call below is using 'null_' to initialize itself.
     InitializeObject(address, kNullCid, Instance::InstanceSize());
   }
 
   // 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->object_store()->set_empty_array(Array::Handle());
+  empty_array_ = Array::null();
 
   Class& cls = Class::Handle();
 
   // Allocate and initialize the class class.
   {
     intptr_t size = Class::InstanceSize();
     uword address = heap->Allocate(size, Heap::kOld);
     class_class_ = reinterpret_cast<RawClass*>(address + kHeapObjectTag);
     InitializeObject(address, Class::kClassId, size);
 
@@ skipping 31 matching lines @@
     sentinel ^=
         Object::Allocate(kNullCid, Instance::InstanceSize(), Heap::kOld);
     sentinel_ = sentinel.raw();
 
     Instance& transition_sentinel = Instance::Handle();
     transition_sentinel ^=
         Object::Allocate(kNullCid, 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 GetSingletonClassName) and its array fields cannot be set to the empty
-  // array, but remain null.
-  //
-  // TODO(turnidge): Once the empty array is allocated in the vm
-  // isolate, use it here.
   cls = Class::New<Instance>(kDynamicCid);
   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>(kVoidCid);
@@ skipping 80 matching lines @@
 
   ASSERT(class_class() != null_);
 
   // Pre-allocate the Array and OneByteString class in the vm isolate so that
   // we can create a symbol table and populate it with some frequently used
   // strings as symbols.
   cls = Class::New<Array>();
   isolate->object_store()->set_array_class(cls);
   cls = Class::New<OneByteString>();
   isolate->object_store()->set_one_byte_string_class(cls);
+
+  // Allocate and initialize the empty_array instance.
+  {
+    uword address = heap->Allocate(Array::InstanceSize(0), Heap::kOld);
+    empty_array_ = reinterpret_cast<RawArray*>(address + kHeapObjectTag);
+    InitializeObject(address, kArrayCid, Array::InstanceSize(0));
+    empty_array_->ptr()->length_ = Smi::New(0);
+  }
+}
+
+
+#define SET_CLASS_NAME(class_name, name)                                       \
+  cls = class_name##_class();                                                  \
+  str = Symbols::name();                                                       \
+  cls.set_name(str);                                                           \
+
+void Object::RegisterSingletonClassNames() {
+  Class& cls = Class::Handle();
+  String& str = String::Handle();
+
+  SET_CLASS_NAME(class, Class);
+  SET_CLASS_NAME(null, Null);
+  SET_CLASS_NAME(dynamic, Dynamic);
+  SET_CLASS_NAME(void, Void);
+  SET_CLASS_NAME(unresolved_class, UnresolvedClass);
+  SET_CLASS_NAME(type, Type);
+  SET_CLASS_NAME(type_parameter, TypeParameter);
+  SET_CLASS_NAME(type_arguments, TypeArguments);
+  SET_CLASS_NAME(instantiated_type_arguments, InstantiatedTypeArguments);
+  SET_CLASS_NAME(function, Function);
+  SET_CLASS_NAME(field, Field);
+  SET_CLASS_NAME(literal_token, LiteralToken);
+  SET_CLASS_NAME(token_stream, TokenStream);
+  SET_CLASS_NAME(script, Script);
+  SET_CLASS_NAME(library, LibraryClass);
+  SET_CLASS_NAME(library_prefix, LibraryPrefix);
+  SET_CLASS_NAME(code, Code);
+  SET_CLASS_NAME(instructions, Instructions);
+  SET_CLASS_NAME(pc_descriptors, PcDescriptors);
+  SET_CLASS_NAME(stackmap, Stackmap);
+  SET_CLASS_NAME(var_descriptors, LocalVarDescriptors);
+  SET_CLASS_NAME(exception_handlers, ExceptionHandlers);
+  SET_CLASS_NAME(deopt_info, DeoptInfo);
+  SET_CLASS_NAME(context, Context);
+  SET_CLASS_NAME(context_scope, ContextScope);
+  SET_CLASS_NAME(icdata, ICData);
+  SET_CLASS_NAME(subtypetestcache, SubtypeTestCache);
+  SET_CLASS_NAME(api_error, ApiError);
+  SET_CLASS_NAME(language_error, LanguageError);
+  SET_CLASS_NAME(unhandled_exception, UnhandledException);
+  SET_CLASS_NAME(unwind_error, UnwindError);
 }
 
 
 RawClass* Object::CreateAndRegisterInterface(const char* cname,
                                              const Script& script,
                                              const Library& lib) {
   const String& name = String::Handle(Symbols::New(cname));
   const Class& cls = Class::Handle(
       Class::NewInterface(name, script, Scanner::kDummyTokenIndex));
   lib.AddClass(cls);
@@ skipping 37 matching lines @@
   // initialize array class first.
   cls = Class::New<Array>();
   object_store->set_array_class(cls);
 
   // Array and ImmutableArray are the only VM classes that are parameterized.
   // Since they are pre-finalized, CalculateFieldOffsets() is not called, so we
   // need to set the offset of their type_arguments_ field, which is explicitly
   // declared in RawArray.
   cls.set_type_arguments_instance_field_offset(Array::type_arguments_offset());
 
-  Array& empty_array = Array::Handle();
-  empty_array = Array::New(0, Heap::kOld);
-  object_store->set_empty_array(empty_array);
-
-  // Re-initialize fields of the array class now that the empty array
-  // has been created.
-  cls.InitEmptyFields();
-
   // Set up the growable object array class (Has to be done after the array
   // class is setup as one of its field is an array object).
   cls = Class::New<GrowableObjectArray>();
   object_store->set_growable_object_array_class(cls);
   cls.set_type_arguments_instance_field_offset(
       GrowableObjectArray::type_arguments_offset());
 
   // canonical_type_arguments_ are NULL terminated.
   array = Array::New(4);
   object_store->set_canonical_type_arguments(array);
@@ skipping 339 matching lines @@
   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.
   cls = Class::New<Array>();
   object_store->set_array_class(cls);
 
-  Array& empty_array = Array::Handle();
-  empty_array = Array::New(0);
-  object_store->set_empty_array(empty_array);
-
   cls = Class::New<ImmutableArray>();
   object_store->set_immutable_array_class(cls);
 
   cls = Class::New<GrowableObjectArray>();
   object_store->set_growable_object_array_class(cls);
 
   cls = Class::New<Int8Array>();
   object_store->set_int8_array_class(cls);
 
   cls = Class::New<Uint8Array>();
@@ skipping 178 matching lines @@
   memmove(raw_obj->ptr(), src.raw()->ptr(), size);
   if (space == Heap::kOld) {
     StoreBufferObjectPointerVisitor visitor(Isolate::Current());
     raw_obj->VisitPointers(&visitor);
   }
   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.
-  return Symbols::New(GetSingletonClassName(raw_ptr()->id_));
+  ASSERT(raw_ptr()->name_ != String::null());
+  return raw_ptr()->name_;
 }
 
 
 RawString* Class::UserVisibleName() const {
   if (FLAG_show_internal_names) {
     return Name();
   }
   switch (id()) {
     case kIntegerCid:
     case kSmiCid:
@@ skipping 124 matching lines @@
   result.raw_ptr()->num_native_fields_ = 0;
   result.raw_ptr()->token_pos_ = 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()) {
+  if (Object::empty_array() == Array::null()) {
     // The empty array has not been initialized yet.
     return;
   }
-  StorePointer(&raw_ptr()->interfaces_, empty_array.raw());
-  // TODO(srdjan): Make functions_cache growable and start with a smaller size.
-  Array& fcache =
-      Array::Handle(Array::New(FunctionsCache::kNumEntries * 32, Heap::kOld));
-  StorePointer(&raw_ptr()->functions_cache_, fcache.raw());
-  StorePointer(&raw_ptr()->constants_, empty_array.raw());
-  StorePointer(&raw_ptr()->canonical_types_, empty_array.raw());
-  StorePointer(&raw_ptr()->functions_, empty_array.raw());
-  StorePointer(&raw_ptr()->fields_, empty_array.raw());
+  StorePointer(&raw_ptr()->interfaces_, Object::empty_array());
+  StorePointer(&raw_ptr()->constants_, Object::empty_array());
+  StorePointer(&raw_ptr()->canonical_types_, Object::empty_array());
+  StorePointer(&raw_ptr()->functions_, Object::empty_array());
+  StorePointer(&raw_ptr()->fields_, Object::empty_array());
+}
+
+
+void Class::InitFunctionsCache() const {
+  // TODO(srdjan): Make functions_cache growable and start with smaller size.
+  StorePointer(&raw_ptr()->functions_cache_,
+               Array::New(FunctionsCache::kNumEntries * 32, Heap::kOld));
 }
 
 
 bool Class::HasInstanceFields() const {
   const Array& field_array = Array::Handle(fields());
   Field& field = Field::Handle();
   for (intptr_t i = 0; i < field_array.Length(); ++i) {
     field ^= field_array.At(i);
     if (!field.is_static()) {
       return true;
@@ skipping 344 matching lines @@
   // way as the owner class of its non-static signature function.
   // It is not type parameterized if its signature function is static.
   if (!signature_function.is_static() &&
       (owner_class.NumTypeParameters() > 0) &&
       !signature_function.HasInstantiatedSignature()) {
     type_parameters = owner_class.type_parameters();
   }
   const intptr_t token_pos = signature_function.token_pos();
   Class& result = Class::Handle(New<Closure>(name, script, token_pos));
   const Type& super_type = Type::Handle(Type::ObjectType());
+  const Array& empty_array = Array::Handle(Object::empty_array());
   ASSERT(!super_type.IsNull());
   result.set_super_type(super_type);
   result.set_signature_function(signature_function);
   result.set_type_parameters(type_parameters);
-  result.SetFields(Array::Handle(Array::Empty()));
-  result.SetFunctions(Array::Handle(Array::Empty()));
+  result.SetFields(empty_array);
+  result.SetFunctions(empty_array);
   result.set_type_arguments_instance_field_offset(
       Closure::type_arguments_offset());
   // Implements interface "Function".
   const Type& function_interface = Type::Handle(Type::FunctionInterface());
   const Array& interfaces = Array::Handle(Array::New(1, Heap::kOld));
   interfaces.SetAt(0, function_interface);
   result.set_interfaces(interfaces);
   // Unless the signature function already has a signature class, create a
   // canonical signature class by having the signature function point back to
   // the signature class.
@@ skipping 33 matching lines @@
   UNREACHABLE();
   return Class::null();
 }
 
 
 RawClass* Class::NewNativeWrapper(Library* library,
                                   const String& name,
                                   int field_count) {
   Class& cls = Class::Handle(library->LookupClass(name));
   if (cls.IsNull()) {
+    const Array& empty_array = Array::Handle(Object::empty_array());
     cls = New<Instance>(name, Script::Handle(), Scanner::kDummyTokenIndex);
-    cls.SetFields(Array::Handle(Array::Empty()));
-    cls.SetFunctions(Array::Handle(Array::Empty()));
+    cls.SetFields(empty_array);
+    cls.SetFunctions(empty_array);
     // Set super class to Object.
     cls.set_super_type(Type::Handle(Type::ObjectType()));
     // Compute instance size.
     intptr_t instance_size = (field_count * kWordSize) + sizeof(RawObject);
     cls.set_instance_size(RoundedAllocationSize(instance_size));
     cls.set_next_field_offset(instance_size);
     cls.set_num_native_fields(field_count);
     cls.set_is_finalized();
     library->AddClass(cls);
     return cls.raw();
@@ skipping 2376 matching lines @@
                            RawFunction::Kind kind,
                            bool is_static,
                            bool is_const,
                            bool is_abstract,
                            bool is_external,
                            const Class& owner,
                            intptr_t token_pos) {
   ASSERT(name.IsOneByteString());
   ASSERT(!owner.IsNull());
   const Function& result = Function::Handle(Function::New());
-  result.set_parameter_types(Array::Handle(Array::Empty()));
-  result.set_parameter_names(Array::Handle(Array::Empty()));
+  const Array& empty_array = Array::Handle(Object::empty_array());
+  result.set_parameter_types(empty_array);
+  result.set_parameter_names(empty_array);
   result.set_name(name);
   result.set_kind(kind);
   result.set_is_static(is_static);
   result.set_is_const(is_const);
   result.set_is_abstract(is_abstract);
   result.set_is_external(is_external);
   result.set_owner(owner);
   result.set_token_pos(token_pos);
   result.set_end_token_pos(token_pos);
   result.set_num_fixed_parameters(0);
@@ skipping 2000 matching lines @@
   return reinterpret_cast<RawLibrary*>(raw);
 }
 
 
 RawLibrary* Library::NewLibraryHelper(const String& url,
                                       bool import_core_lib) {
   const Library& result = Library::Handle(Library::New());
   result.StorePointer(&result.raw_ptr()->name_, url.raw());
   result.StorePointer(&result.raw_ptr()->url_, url.raw());
   result.raw_ptr()->private_key_ = Scanner::AllocatePrivateKey(result);
-  result.raw_ptr()->dictionary_ = Array::Empty();
-  result.raw_ptr()->anonymous_classes_ = Array::Empty();
+  result.raw_ptr()->dictionary_ = Object::empty_array();
+  result.raw_ptr()->anonymous_classes_ = Object::empty_array();
   result.raw_ptr()->num_anonymous_ = 0;
-  result.raw_ptr()->imports_ = Array::Empty();
+  result.raw_ptr()->imports_ = Object::empty_array();
   result.raw_ptr()->loaded_scripts_ = Array::null();
   result.set_native_entry_resolver(NULL);
   result.raw_ptr()->corelib_imported_ = true;
   result.set_debuggable(false);
   result.raw_ptr()->load_state_ = RawLibrary::kAllocated;
   result.raw_ptr()->index_ = -1;
   result.InitClassDictionary();
   result.InitImportList();
   result.InitImportedIntoList();
   if (import_core_lib) {
@@ skipping 946 matching lines @@
 }
 
 
 Code::Comments& Code::Comments::New(intptr_t count) {
   Comments* comments;
   if (count < 0 || count > (kIntptrMax / kNumberOfEntries)) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in Code::Comments::New: invalid count %ld\n", count);
   }
   if (count == 0) {
-    comments = new Comments(Array::Empty());
+    comments = new Comments(Object::empty_array());
   } else {
     comments = new Comments(Array::New(count * kNumberOfEntries));
   }
   return *comments;
 }
 
 
 intptr_t Code::Comments::Length() const {
   if (comments_.IsNull()) {
     return 0;
@@ skipping 2945 matching lines @@
   ASSERT(new_length != len);  // Unnecessary copying of array.
   Object& obj = Object::Handle();
   for (int i = 0; i < len; i++) {
     obj = source.At(i);
     result.SetAt(i, obj);
   }
   return result.raw();
 }
 
 
-RawArray* Array::Empty() {
-  return Isolate::Current()->object_store()->empty_array();
-}
-
-
 RawArray* Array::MakeArray(const GrowableObjectArray& growable_array) {
   intptr_t used_len = growable_array.Length();
   intptr_t capacity_len = growable_array.Capacity();
   Isolate* isolate = Isolate::Current();
   const Array& array = Array::Handle(isolate, growable_array.data());
-  const Array& new_array = Array::Handle(isolate, Array::Empty());
+  const Array& new_array = Array::Handle(isolate, Object::empty_array());
   intptr_t capacity_size = Array::InstanceSize(capacity_len);
   intptr_t used_size = Array::InstanceSize(used_len);
   NoGCScope no_gc;
 
   // Update the size in the header field and length of the array object.
   uword tags = array.raw_ptr()->tags_;
   ASSERT(kArrayCid == RawObject::ClassIdTag::decode(tags));
   tags = RawObject::SizeTag::update(used_size, tags);
   array.raw_ptr()->tags_ = tags;
   array.SetLength(used_len);
@@ skipping 1049 matching lines @@
 const char* JSRegExp::ToCString() const {
   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 = Isolate::Current()->current_zone()->Alloc<char>(len + 1);
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 }  // namespace dart