- 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 8693 matching lines @@
   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();
+  return Object::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());
   intptr_t capacity_size = Array::InstanceSize(capacity_len);
@@ skipping 1058 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