Create read only handles for empty_array and sentinel objects

vm/object.h

 // 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.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 192 matching lines @@
   bool IsNew() const { return raw()->IsNewObject(); }
   bool IsOld() const { return raw()->IsOldObject(); }
 
   // Print the object on stdout for debugging.
   void Print() const;
 
   bool IsZoneHandle() const {
     return VMHandles::IsZoneHandle(reinterpret_cast<uword>(this));
   }
 
+  bool IsReadOnlyHandle() const;
+
   bool IsNotTemporaryScopedHandle() const;
 
   static RawObject* Clone(const Object& src, Heap::Space space = Heap::kNew);
 
   static Object& Handle(Isolate* isolate, RawObject* raw_ptr) {
     Object* obj = reinterpret_cast<Object*>(VMHandles::AllocateHandle(isolate));
     initializeHandle(obj, raw_ptr);
     return *obj;
   }
 
@@ skipping 18 matching lines @@
 
   static Object& ZoneHandle() {
     return ZoneHandle(Isolate::Current(), null_);
   }
 
   static Object& ZoneHandle(RawObject* raw_ptr) {
     return ZoneHandle(Isolate::Current(), raw_ptr);
   }
 
   static RawObject* null() { return null_; }
-  static RawArray* empty_array() { return empty_array_; }
+  static const Array& empty_array() {
+    ASSERT(empty_array_ != NULL);
+    return *empty_array_;
+  }
 
   // The sentinel is a value that cannot be produced by Dart code.
   // It can be used to mark special values, for example to distinguish
   // "uninitialized" fields.
-  static RawInstance* sentinel() { return sentinel_; }
+  static const Instance& sentinel() {
+    ASSERT(sentinel_ != NULL);
+    return *sentinel_;
+  }
   // Value marking that we are transitioning from sentinel, e.g., computing
   // a field value. Used to detect circular initialization.
-  static RawInstance* transition_sentinel() { return transition_sentinel_; }
+  static const Instance& transition_sentinel() {
+    ASSERT(transition_sentinel_ != NULL);
+    return *transition_sentinel_;
+  }
 
   static RawClass* class_class() { return class_class_; }
   static RawClass* null_class() { return null_class_; }
   static RawClass* dynamic_class() { return dynamic_class_; }
   static RawClass* void_class() { return void_class_; }
   static RawClass* unresolved_class_class() { return unresolved_class_class_; }
   static RawClass* type_arguments_class() { return type_arguments_class_; }
   static RawClass* instantiated_type_arguments_class() {
       return instantiated_type_arguments_class_;
   }
@@ skipping 123 matching lines @@
     uword vtable_addr = reinterpret_cast<uword>(this);
     return reinterpret_cast<cpp_vtable*>(vtable_addr);
   }
 
   static cpp_vtable handle_vtable_;
   static cpp_vtable builtin_vtables_[kNumPredefinedCids];
 
   // The static values below are singletons shared between the different
   // isolates. They are all allocated in the non-GC'd Dart::vm_isolate_.
   static RawObject* null_;
-  static RawArray* empty_array_;
-  static RawInstance* sentinel_;
-  static RawInstance* transition_sentinel_;
 
   static RawClass* class_class_;  // Class of the Class vm object.
   static RawClass* null_class_;  // Class of the null object.
   static RawClass* dynamic_class_;  // Class of the 'dynamic' type.
   static RawClass* void_class_;  // Class of the 'void' type.
   static RawClass* unresolved_class_class_;  // Class of UnresolvedClass.
   // Class of the TypeArguments vm object.
   static RawClass* type_arguments_class_;
   static RawClass* instantiated_type_arguments_class_;  // Class of Inst..ments.
   static RawClass* patch_class_class_;  // Class of the PatchClass vm object.
@@ skipping 17 matching lines @@
   static RawClass* context_class_;  // Class of the Context vm object.
   static RawClass* context_scope_class_;  // Class of ContextScope vm object.
   static RawClass* icdata_class_;  // Class of ICData.
   static RawClass* megamorphic_cache_class_;  // Class of MegamorphiCache.
   static RawClass* subtypetestcache_class_;  // Class of SubtypeTestCache.
   static RawClass* api_error_class_;  // Class of ApiError.
   static RawClass* language_error_class_;  // Class of LanguageError.
   static RawClass* unhandled_exception_class_;  // Class of UnhandledException.
   static RawClass* unwind_error_class_;  // Class of UnwindError.
 
+  // The static values below are read-only handle pointers for singleton
+  // objects that are shared between the different isolates.
+  static Array* empty_array_;
+  static Instance* sentinel_;
+  static Instance* transition_sentinel_;
+
   friend void ClassTable::Register(const Class& cls);
   friend void RawObject::Validate(Isolate* isolate) const;
   friend class Closure;
   friend class SnapshotReader;
   friend class OneByteString;
   friend class TwoByteString;
   friend class ExternalOneByteString;
   friend class ExternalTwoByteString;
 
   // Disallow allocation.
@@ skipping 2092 matching lines @@
 
     intptr_t Length() const;
 
     void SetPCOffsetAt(intptr_t idx, intptr_t pc_offset);
     void SetCommentAt(intptr_t idx, const String& comment);
 
     intptr_t PCOffsetAt(intptr_t idx) const;
     const String& CommentAt(intptr_t idx) const;
 
    private:
-    explicit Comments(RawArray* comments);
+    explicit Comments(const Array& comments);
 
     // Layout of entries describing comments.
     enum {
       kPCOffsetEntry = 0,  // PC offset to a comment as a Smi.
       kCommentEntry,  // Comment text as a String.
       kNumberOfEntries
     };
 
     const Array& comments_;
 
@@ skipping 3632 matching lines @@
 
 
 RawObject* MegamorphicCache::GetTargetFunction(const Array& array,
                                                intptr_t index) {
   return array.At((index * kEntryLength) + kTargetFunctionIndex);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_