Create specific null read only handles for the frequently used types

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 53 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
 Object* Object::null_object_ = NULL;
+Array* Object::null_array_ = NULL;
+String* Object::null_string_ = NULL;
+Instance* Object::null_instance_ = NULL;
+AbstractTypeArguments* Object::null_abstract_type_arguments_ = NULL;
 Array* Object::empty_array_ = NULL;
 Instance* Object::sentinel_ = NULL;
 Instance* Object::transition_sentinel_ = NULL;
 Instance* Object::unknown_constant_ = NULL;
 Instance* Object::non_constant_ = NULL;
 Bool* Object::bool_true_ = NULL;
 Bool* Object::bool_false_ = NULL;
 Smi* Object::smi_illegal_cid_ = NULL;
 LanguageError* Object::snapshot_writer_error_ = NULL;
 
@@ skipping 233 matching lines @@
     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 the read only object handles here.
-  null_object_ = Array::ReadOnlyHandle();
+  null_object_ = Object::ReadOnlyHandle();
+  null_array_ = Array::ReadOnlyHandle();
+  null_string_ = String::ReadOnlyHandle();
+  null_instance_ = Instance::ReadOnlyHandle();
+  null_abstract_type_arguments_ = AbstractTypeArguments::ReadOnlyHandle();
   empty_array_ = Array::ReadOnlyHandle();
   sentinel_ = Instance::ReadOnlyHandle();
   transition_sentinel_ = Instance::ReadOnlyHandle();
   unknown_constant_ =  Instance::ReadOnlyHandle();
   non_constant_ =  Instance::ReadOnlyHandle();
   bool_true_ = Bool::ReadOnlyHandle();
   bool_false_ = Bool::ReadOnlyHandle();
   smi_illegal_cid_ = Smi::ReadOnlyHandle();
   snapshot_writer_error_ = LanguageError::ReadOnlyHandle();
 
   // 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());
   }
 
   *null_object_ = null_;
+  *null_array_ ^= null_;
+  *null_string_ ^= null_;
+  *null_instance_ ^= null_;
+  *null_abstract_type_arguments_ ^= null_;
 
   // Initialize the empty array handle to null_ in order to be able to check
   // if the empty array was allocated (RAW_NULL is not available).
   *empty_array_ = Array::null();
 
   Class& cls = Class::Handle();
 
   // Allocate and initialize the class class.
   {
     intptr_t size = Class::InstanceSize();
@@ skipping 179 matching lines @@
   cls = Class::New<Bool>();
   isolate->object_store()->set_bool_class(cls);
   *bool_true_ = Bool::New(true);
   *bool_false_ = Bool::New(false);
 
   *smi_illegal_cid_ = Smi::New(kIllegalCid);
   *snapshot_writer_error_ =
       LanguageError::New(String::Handle(String::New("SnapshotWriter Error")));
 
   ASSERT(!null_object_->IsSmi());
+  ASSERT(!null_array_->IsSmi());
+  ASSERT(null_array_->IsArray());
+  ASSERT(!null_string_->IsSmi());
+  ASSERT(null_string_->IsString());
+  ASSERT(!null_instance_->IsSmi());
+  ASSERT(null_instance_->IsInstance());
+  ASSERT(!null_abstract_type_arguments_->IsSmi());
+  ASSERT(null_abstract_type_arguments_->IsAbstractTypeArguments());
   ASSERT(!empty_array_->IsSmi());
   ASSERT(empty_array_->IsArray());
   ASSERT(!sentinel_->IsSmi());
   ASSERT(sentinel_->IsInstance());
   ASSERT(!transition_sentinel_->IsSmi());
   ASSERT(transition_sentinel_->IsInstance());
   ASSERT(!unknown_constant_->IsSmi());
   ASSERT(unknown_constant_->IsInstance());
   ASSERT(!non_constant_->IsSmi());
   ASSERT(non_constant_->IsInstance());
@@ skipping 499 matching lines @@
   // Finish the initialization by compiling the bootstrap scripts containing the
   // base interfaces and the implementation of the internal classes.
   const Error& error = Error::Handle(Bootstrap::LoadandCompileScripts());
   if (!error.IsNull()) {
     return error.raw();
   }
 
   // Remove the Object superclass cycle by setting the super type to null (not
   // to the type of null).
   cls = object_store->object_class();
-  cls.set_super_type(Type::null_object());
+  cls.set_super_type(AbstractType::Handle());
 
   ClassFinalizer::VerifyBootstrapClasses();
   MarkInvisibleFunctions();
 
   // Set up the intrinsic state of all functions (core, math and scalar list).
   Intrinsifier::InitializeState();
 
   return Error::null();
 }
 
@@ skipping 517 matching lines @@
     if (cls.IsSignatureClass()) {
       const Function& signature_fun =
           Function::Handle(isolate, cls.signature_function());
       if (!signature_fun.is_static() &&
           !signature_fun.HasInstantiatedSignature()) {
         cls = signature_fun.Owner();
       }
     }
     num_type_args += cls.NumTypeParameters();
     // Object is its own super class during bootstrap.
-    if (cls.super_type() == Type::null() ||
+    if (cls.super_type() == AbstractType::null() ||
         cls.super_type() == isolate->object_store()->object_type()) {
       break;
     }
     cls = cls.SuperClass();
   } while (true);
   return num_type_args;
 }
 
 
 bool Class::HasTypeArguments() const {
   if (!IsSignatureClass() && (is_type_finalized() || is_prefinalized())) {
     // More efficient than calling NumTypeArguments().
     return type_arguments_field_offset() != kNoTypeArguments;
   } else {
     // No need to check NumTypeArguments() if class has type parameters.
     return (NumTypeParameters() > 0) || (NumTypeArguments() > 0);
   }
 }
 
 
 RawClass* Class::SuperClass() const {
-  if (super_type() == Type::null()) {
+  if (super_type() == AbstractType::null()) {
     return Class::null();
   }
   const AbstractType& sup_type = AbstractType::Handle(super_type());
   return sup_type.type_class();
 }
 
 
 void Class::set_super_type(const AbstractType& value) const {
   ASSERT(value.IsNull() ||
          value.IsType() ||
@@ skipping 3235 matching lines @@
                      bool is_static,
                      bool is_final,
                      bool is_const,
                      const Class& owner,
                      intptr_t token_pos) {
   ASSERT(!owner.IsNull());
   const Field& result = Field::Handle(Field::New());
   result.set_name(name);
   result.set_is_static(is_static);
   if (is_static) {
-    result.set_value(Instance::null_object());
+    result.set_value(Object::null_instance());
   } else {
     result.SetOffset(0);
   }
   result.set_is_final(is_final);
   result.set_is_const(is_const);
   result.set_owner(owner);
   result.set_token_pos(token_pos);
   result.set_has_initializer(false);
   result.set_guarded_cid(kIllegalCid);
   result.set_is_nullable(false);
-  result.set_dependent_code(Array::null_object());
+  result.set_dependent_code(Object::null_array());
   return result.raw();
 }
 
 
 
 RawField* Field::Clone(const Class& new_owner) const {
   Field& clone = Field::Handle();
   clone ^= Object::Clone(*this, Heap::kOld);
   const Class& owner = Class::Handle(this->owner());
   const PatchClass& clone_owner =
       PatchClass::Handle(PatchClass::New(new_owner, owner));
   clone.set_owner(clone_owner);
-  clone.set_dependent_code(Array::null_object());
+  clone.set_dependent_code(Object::null_array());
   if (!clone.is_static()) {
     clone.SetOffset(0);
   }
   return clone.raw();
 }
 
 
 RawString* Field::UserVisibleName() const {
   const String& str = String::Handle(name());
   return IdentifierPrettyName(str);
@@ skipping 73 matching lines @@
   return false;
 }
 
 
 void Field::DeoptimizeDependentCode() const {
   const Array& code_objects = Array::Handle(dependent_code());
 
   if (code_objects.IsNull()) {
     return;
   }
-  set_dependent_code(Array::null_object());
+  set_dependent_code(Object::null_array());
 
   // Deoptimize all dependent code on the stack.
   Code& code = Code::Handle();
   {
     DartFrameIterator iterator;
     StackFrame* frame = iterator.NextFrame();
     while (frame != NULL) {
       code = frame->LookupDartCode();
       if (IsDependentCode(code_objects, code)) {
         DeoptimizeAt(code, frame->pc());
@@ skipping 624 matching lines @@
   } else if (obj.IsSmi()) {
     Token::Kind kind = static_cast<Token::Kind>(
         Smi::Value(reinterpret_cast<RawSmi*>(obj.raw())));
     ASSERT(kind < Token::kNumTokens);
     if (Token::IsPseudoKeyword(kind) || Token::IsKeyword(kind)) {
       Isolate* isolate = Isolate::Current();
       ObjectStore* object_store = isolate->object_store();
       const Array& symbols = Array::Handle(isolate,
                                            object_store->keyword_symbols());
       ASSERT(!symbols.IsNull());
-      ASSERT(symbols.At(kind - Token::kFirstKeyword) != String::null());
+      ASSERT(symbols.At(kind - Token::kFirstKeyword) != Object::null());
       return String::RawCast(symbols.At(kind - Token::kFirstKeyword));
     }
     return Symbols::New(Token::Str(kind));
   } else {
     ASSERT(obj.IsLiteralToken());  // Must be a literal token.
     const LiteralToken& literal_token = LiteralToken::Cast(obj);
     return literal_token.literal();
   }
 }
 
@@ skipping 864 matching lines @@
   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();
   if (import_core_lib) {
     const Library& core_lib = Library::Handle(Library::CoreLibrary());
     ASSERT(!core_lib.IsNull());
     const Namespace& ns = Namespace::Handle(
-        Namespace::New(core_lib, Array::null_object(), Array::null_object()));
+        Namespace::New(core_lib, Object::null_array(), Object::null_array()));
     result.AddImport(ns);
   }
   return result.raw();
 }
 
 
 RawLibrary* Library::New(const String& url) {
   return NewLibraryHelper(url, false);
 }
 
 
 void Library::InitCoreLibrary(Isolate* isolate) {
   const String& core_lib_url = Symbols::DartCore();
   const Library& core_lib =
       Library::Handle(Library::NewLibraryHelper(core_lib_url, false));
   core_lib.Register();
   isolate->object_store()->set_bootstrap_library(ObjectStore::kCore, core_lib);
-  isolate->object_store()->set_root_library(Library::null_object());
+  isolate->object_store()->set_root_library(Library::Handle());
 
   // Hook up predefined classes without setting their library pointers. These
   // classes are coming from the VM isolate, and are shared between multiple
   // isolates so setting their library pointers would be wrong.
   const Class& cls = Class::Handle(Object::dynamic_class());
   core_lib.AddObject(cls, String::Handle(cls.Name()));
 }
 
 
 void Library::InitNativeWrappersLibrary(Isolate* isolate) {
@@ skipping 6003 matching lines @@
   StorePointer(&(raw_ptr()->data_), new_contents.raw());
 }
 
 
 RawObject* GrowableObjectArray::RemoveLast() const {
   ASSERT(!IsNull());
   ASSERT(Length() > 0);
   intptr_t index = Length() - 1;
   const Array& contents = Array::Handle(data());
   const Object& obj = Object::Handle(contents.At(index));
-  contents.SetAt(index, null_object());
+  contents.SetAt(index, Object::null_object());
   SetLength(index);
   return obj.raw();
 }
 
 
 bool GrowableObjectArray::Equals(const Instance& other) const {
   // If both handles point to the same raw instance they are equal.
   if (this->raw() == other.raw()) {
     return true;
   }
@@ skipping 721 matching lines @@
                                     space);
   return reinterpret_cast<RawWeakProperty*>(raw);
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart