Create read only handles for empty_array and sentinel objects

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::handle_vtable_ = 0;
 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);
+Array* Object::empty_array_ = NULL;
+Instance* Object::sentinel_ = NULL;
+Instance* Object::transition_sentinel_ = NULL;
+
+RawObject* Object::null_ = reinterpret_cast<RawObject*>(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_arguments_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::instantiated_type_arguments_class_ =
     reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::patch_class_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
@@ skipping 156 matching lines @@
   // 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();
   }
 
+  // Allocate the read only object handles here.
+  empty_array_ = reinterpret_cast<Array*>(Dart::AllocateReadOnlyHandle());
+  sentinel_ = reinterpret_cast<Instance*>(Dart::AllocateReadOnlyHandle());
+  transition_sentinel_ =
+      reinterpret_cast<Instance*>(Dart::AllocateReadOnlyHandle());
+
   Isolate* isolate = Isolate::Current();
   Heap* heap = isolate->heap();
   // 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
+  // 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();
+  *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 19 matching lines @@
   cls = Class::New<Instance>(kNullCid);
   cls.set_is_finalized();
   null_class_ = cls.raw();
 
   // Allocate and initialize the free list element class.
   cls = Class::New<FreeListElement::FakeInstance>(kFreeListElement);
   cls.set_is_finalized();
 
   // Allocate and initialize the sentinel values of Null class.
   {
-    Instance& sentinel = Instance::Handle();
-    sentinel ^=
+    *sentinel_ ^=
         Object::Allocate(kNullCid, Instance::InstanceSize(), Heap::kOld);
-    sentinel_ = sentinel.raw();
 
-    Instance& transition_sentinel = Instance::Handle();
-    transition_sentinel ^=
+    *transition_sentinel_ ^=
         Object::Allocate(kNullCid, Instance::InstanceSize(), Heap::kOld);
-    transition_sentinel_ = transition_sentinel.raw();
   }
 
   cls = Class::New<Instance>(kDynamicCid);
   cls.set_is_finalized();
   cls.set_is_abstract();
   dynamic_class_ = cls.raw();
 
   // Allocate the remaining VM internal classes.
   cls = Class::New<UnresolvedClass>();
   unresolved_class_class_ = cls.raw();
@@ skipping 97 matching lines @@
   cls = Class::New<Array>();
   isolate->object_store()->set_array_class(cls);
   cls = Class::NewStringClass(kOneByteStringCid);
   isolate->object_store()->set_one_byte_string_class(cls);
   cls = Class::NewStringClass(kTwoByteStringCid);
   isolate->object_store()->set_two_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);
+    *empty_array_ = reinterpret_cast<RawArray*>(address + kHeapObjectTag);
     InitializeObject(address, kArrayCid, Array::InstanceSize(0));
-    empty_array_->ptr()->length_ = Smi::New(0);
+    empty_array_->raw()->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() {
@@ skipping 812 matching lines @@
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(StoreBufferObjectPointerVisitor);
 };
 
 
 bool Object::IsNotTemporaryScopedHandle() const {
   return (IsZoneHandle() ||
-          Symbols::IsPredefinedHandle(reinterpret_cast<uword>(this)));
+          Dart::IsReadOnlyHandle(reinterpret_cast<uword>(this)));

[Ivan Posva, 2012/12/20 23:43:52]

Could we have a IsReadOnlyHandle similar to IsZoneHandle on object instead?

Also I find it a bit strange to have a method called IsNotXYZ.

[siva, 2012/12/21 02:28:06]

Added IsReadOnlyHandle method to Object.

Regarding IsNotTemporaryScopedHandle(): Srdjan was not
in favour of changing all the places where we have
ASSERt(IsZoneHandle()) to also be 
ASSERT(IsZoneHandle() || IsReadOnlyHandle());
Maybe I should talk with him regarding this and replace
IsNotTemporaryScopedHandle to something more meaningful.

On 2012/12/20 23:43:52, Ivan Posva wrote:

[Ivan Posva, 2012/12/21 07:33:41]

I find the name confusing on two fronts:
- The Not in IsNotXYZ. We try to avoid that in general.
- What is a non-temporary scoped handle? Or are all scoped handles temporary,
then either the scoped or the temporary are redundant.

Personally I would favor IsScopedHandle or something less mind-twisting.

 }
 
 
 
 RawObject* Object::Clone(const Object& src, Heap::Space space) {
   const Class& cls = Class::Handle(src.clazz());
   intptr_t size = src.raw()->Size();
   RawObject* raw_obj = Object::Allocate(cls.id(), size, space);
   NoGCScope no_gc;
   memmove(raw_obj->ptr(), src.raw()->ptr(), size);
@@ skipping 142 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() {
-  if (Object::empty_array() == Array::null()) {
+  if (Object::empty_array().raw() == Array::null()) {
     // The empty array has not been initialized yet.
     return;
   }
-  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());
+  StorePointer(&raw_ptr()->interfaces_, Object::empty_array().raw());
+  StorePointer(&raw_ptr()->constants_, Object::empty_array().raw());
+  StorePointer(&raw_ptr()->canonical_types_, Object::empty_array().raw());
+  StorePointer(&raw_ptr()->functions_, Object::empty_array().raw());
+  StorePointer(&raw_ptr()->fields_, Object::empty_array().raw());
 }
 
 
 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 393 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<Instance>(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_instance_size(Closure::InstanceSize());
   result.set_next_field_offset(Closure::InstanceSize());
   result.set_super_type(super_type);
   result.set_signature_function(signature_function);
   result.set_type_parameters(type_parameters);
-  result.SetFields(empty_array);
-  result.SetFunctions(empty_array);
+  result.SetFields(Object::empty_array());
+  result.SetFunctions(Object::empty_array());
   result.set_type_arguments_field_offset(
       Closure::type_arguments_offset());
   // Implements interface "Function".
   const Type& function_type = Type::Handle(Type::Function());
   const Array& interfaces = Array::Handle(Array::New(1, Heap::kOld));
   interfaces.SetAt(0, function_type);
   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 17 matching lines @@
   result.set_canonical_types(new_canonical_types);
   return result.raw();
 }
 
 
 RawClass* Class::NewNativeWrapper(const 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(empty_array);
-    cls.SetFunctions(empty_array);
+    cls.SetFields(Object::empty_array());
+    cls.SetFunctions(Object::empty_array());
     // Set super class to Object.
     cls.set_super_type(Type::Handle(Type::ObjectType()));
     // Compute instance size. First word contains a pointer to a properly
     // sized typed array once the first native field has been set.
     intptr_t instance_size = sizeof(RawObject) + kWordSize;
     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);
@@ skipping 2029 matching lines @@
                            RawFunction::Kind kind,
                            bool is_static,
                            bool is_const,
                            bool is_abstract,
                            bool is_external,
                            const Object& owner,
                            intptr_t token_pos) {
   ASSERT(name.IsOneByteString());
   ASSERT(!owner.IsNull());
   const Function& result = Function::Handle(Function::New());
-  const Array& empty_array = Array::Handle(Object::empty_array());
-  result.set_parameter_types(empty_array);
-  result.set_parameter_names(empty_array);
+  result.set_parameter_types(Object::empty_array());
+  result.set_parameter_names(Object::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_intrinsic_kind(kUnknownIntrinsic);
   result.set_owner(owner);
   result.set_token_pos(token_pos);
   result.set_end_token_pos(token_pos);
@@ skipping 1997 matching lines @@
   }
   intptr_t index = num_imports();
   imports.SetAt(index, ns);
   set_num_imports(index + 1);
 }
 
 
 // Convenience function to determine whether the export list is
 // non-empty.
 bool Library::HasExports() const {
-  return exports() != Object::empty_array();
+  return exports() != Object::empty_array().raw();
 }
 
 
 // We add one namespace at a time to the exports array and don't
 // pre-allocate any unused capacity. The assumption is that
 // re-exports are quite rare.
 void Library::AddExport(const Namespace& ns) const {
   Array &exports = Array::Handle(this->exports());
   intptr_t num_exports = exports.Length();
   exports = Array::Grow(exports, num_exports + 1);
@@ skipping 30 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_ = Object::empty_array();
-  result.raw_ptr()->anonymous_classes_ = Object::empty_array();
+  result.raw_ptr()->dictionary_ = Object::empty_array().raw();
+  result.raw_ptr()->anonymous_classes_ = Object::empty_array().raw();
   result.raw_ptr()->num_anonymous_ = 0;
-  result.raw_ptr()->imports_ = Object::empty_array();
-  result.raw_ptr()->exports_ = Object::empty_array();
+  result.raw_ptr()->imports_ = Object::empty_array().raw();
+  result.raw_ptr()->exports_ = Object::empty_array().raw();
   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();
   if (import_core_lib) {
     const Library& core_lib = Library::Handle(Library::CoreLibrary());
@@ skipping 1033 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 %"Pd"\n", count);
   }
   if (count == 0) {
     comments = new Comments(Object::empty_array());
   } else {
-    comments = new Comments(Array::New(count * kNumberOfEntries));
+    comments =
+        new Comments(Array::ZoneHandle(Array::New(count * kNumberOfEntries)));

[Ivan Posva, 2012/12/20 23:43:52]

Should probably be a regular scoped handle.

[siva, 2012/12/21 02:28:06]

Done.

   }
   return *comments;
 }
 
 
 intptr_t Code::Comments::Length() const {
   if (comments_.IsNull()) {
     return 0;
   }
   return comments_.Length() / kNumberOfEntries;
@@ skipping 16 matching lines @@
   return String::CheckedHandle(
       comments_.At(idx * kNumberOfEntries + kCommentEntry));
 }
 
 
 void Code::Comments::SetCommentAt(intptr_t idx, const String& comment) {
   comments_.SetAt(idx * kNumberOfEntries + kCommentEntry, comment);
 }
 
 
-Code::Comments::Comments(RawArray* comments)
-    : comments_(Array::Handle(comments)) {
+Code::Comments::Comments(const Array& comments)
+    : comments_(comments) {
 }
 
 
 void Code::set_stackmaps(const Array& maps) const {
   StorePointer(&raw_ptr()->stackmaps_, maps.raw());
 }
 
 
 void Code::set_deopt_info_array(const Array& array) const {
   StorePointer(&raw_ptr()->deopt_info_array_, array.raw());
@@ skipping 37 matching lines @@
              (code.function() == array.At(i + kSCallTableFunctionEntry)));
       array.SetAt(i + kSCallTableCodeEntry, code);
       return;
     }
   }
   UNREACHABLE();
 }
 
 
 const Code::Comments& Code::comments() const  {
-  Comments* comments = new Code::Comments(raw_ptr()->comments_);
+  Comments* comments = new Code::Comments(Array::Handle(raw_ptr()->comments_));
   return *comments;
 }
 
 
 void Code::set_comments(const Code::Comments& comments) const {
   StorePointer(&raw_ptr()->comments_, comments.comments_.raw());
 }
 
 
 RawCode* Code::New(intptr_t pointer_offsets_length) {
@@ skipping 1233 matching lines @@
   ASSERT(other.IsFinalized());
   ASSERT(!other.IsDynamicType());
   ASSERT(!other.IsMalformed());
   const Class& cls = Class::Handle(clazz());
   if (cls.IsNullClass()) {
     if (!IsNull()) {
       // We can only encounter Object::sentinel() or
       // Object::transition_sentinel() if type checks were not eliminated at
       // compile time. Both sentinels are instances of the Null class, but they
       // are not the Object::null() instance.
-      ASSERT((raw() == Object::transition_sentinel()) ||
-             (raw() == Object::sentinel()));
+      ASSERT((raw() == Object::transition_sentinel().raw()) ||
+             (raw() == Object::sentinel().raw()));
       ASSERT(!FLAG_eliminate_type_checks);
       return true;  // We are doing an instance of test as part of a type check.
     }
     // The null instance can be returned from a void function.
     if (other.IsVoidType()) {
       return true;
     }
     // Otherwise, null is only an instance of Object and of dynamic.
     // It is not necessary to fully instantiate the other type for this test.
     Class& other_class = Class::Handle();
@@ skipping 132 matching lines @@
 
 bool Instance::IsValidFieldOffset(int offset) const {
   const Class& cls = Class::Handle(clazz());
   return (offset >= 0 && offset <= (cls.instance_size() - kWordSize));
 }
 
 
 const char* Instance::ToCString() const {
   if (IsNull()) {
     return "null";
-  } else if (raw() == Object::sentinel()) {
+  } else if (raw() == Object::sentinel().raw()) {
     return "sentinel";
-  } else if (raw() == Object::transition_sentinel()) {
+  } else if (raw() == Object::transition_sentinel().raw()) {
     return "transition_sentinel";
   } else if (Isolate::Current()->no_gc_scope_depth() > 0) {
     // Can occur when running disassembler.
     return "Instance";
   } else {
     if (IsClosure()) {
       return Closure::ToCString(*this);
     }
     const char* kFormat = "Instance of '%s'";
     const Class& cls = Class::Handle(clazz());
@@ skipping 2878 matching lines @@
   }
   return result.raw();
 }
 
 
 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, 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);
 
   // Null the GrowableObjectArray, we are removing it's backing array.
   growable_array.SetLength(0);
-  growable_array.SetData(new_array);
+  growable_array.SetData(Object::empty_array());
 
   // If there is any left over space fill it with either an Array object or
   // just a plain object (depending on the amount of left over space) so
   // that it can be traversed over successfully during garbage collection.
   Object::MakeUnusedSpaceTraversable(array, capacity_size, used_size);
 
   return array.raw();
 }
 
 
@@ skipping 992 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart