Object pool with support for untagged entries.

runtime/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 395 matching lines @@
 
   static const Array& empty_array() {
     ASSERT(empty_array_ != NULL);
     return *empty_array_;
   }
   static const Array& zero_array() {
     ASSERT(zero_array_ != NULL);
     return *zero_array_;
   }
 
+  static const ObjectPool& empty_object_pool() {
+    ASSERT(empty_object_pool_ != NULL);
+    return *empty_object_pool_;
+  }
+
   static const PcDescriptors& empty_descriptors() {
     ASSERT(empty_descriptors_ != NULL);
     return *empty_descriptors_;
   }
 
   static const LocalVarDescriptors& empty_var_descriptors() {
     ASSERT(empty_var_descriptors_ != NULL);
     return *empty_var_descriptors_;
   }
 
@@ skipping 77 matching lines @@
   static RawClass* closure_data_class() { return closure_data_class_; }
   static RawClass* redirection_data_class() { return redirection_data_class_; }
   static RawClass* field_class() { return field_class_; }
   static RawClass* literal_token_class() { return literal_token_class_; }
   static RawClass* token_stream_class() { return token_stream_class_; }
   static RawClass* script_class() { return script_class_; }
   static RawClass* library_class() { return library_class_; }
   static RawClass* namespace_class() { return namespace_class_; }
   static RawClass* code_class() { return code_class_; }
   static RawClass* instructions_class() { return instructions_class_; }
+  static RawClass* object_pool_class() { return object_pool_class_; }
   static RawClass* pc_descriptors_class() { return pc_descriptors_class_; }
   static RawClass* stackmap_class() { return stackmap_class_; }
   static RawClass* var_descriptors_class() { return var_descriptors_class_; }
   static RawClass* exception_handlers_class() {
     return exception_handlers_class_;
   }
   static RawClass* deopt_info_class() { return deopt_info_class_; }
   static RawClass* context_class() { return context_class_; }
   static RawClass* context_scope_class() { return context_scope_class_; }
   static RawClass* api_error_class() { return api_error_class_; }
@@ skipping 238 matching lines @@
   static RawClass* closure_data_class_;  // Class of ClosureData vm obj.
   static RawClass* redirection_data_class_;  // Class of RedirectionData vm obj.
   static RawClass* field_class_;  // Class of the Field vm object.
   static RawClass* literal_token_class_;  // Class of LiteralToken vm object.
   static RawClass* token_stream_class_;  // Class of the TokenStream vm object.
   static RawClass* script_class_;  // Class of the Script vm object.
   static RawClass* library_class_;  // Class of the Library vm object.
   static RawClass* namespace_class_;  // Class of Namespace vm object.
   static RawClass* code_class_;  // Class of the Code vm object.
   static RawClass* instructions_class_;  // Class of the Instructions vm object.
+  static RawClass* object_pool_class_;  // Class of the ObjectPool vm object.
   static RawClass* pc_descriptors_class_;  // Class of PcDescriptors vm object.
   static RawClass* stackmap_class_;  // Class of Stackmap vm object.
   static RawClass* var_descriptors_class_;  // Class of LocalVarDescriptors.
   static RawClass* exception_handlers_class_;  // Class of ExceptionHandlers.
   static RawClass* deopt_info_class_;  // Class of DeoptInfo.
   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 Object* null_object_;
   static Array* null_array_;
   static String* null_string_;
   static Instance* null_instance_;
   static TypeArguments* null_type_arguments_;
   static Array* empty_array_;
   static Array* zero_array_;
+  static ObjectPool* empty_object_pool_;
   static PcDescriptors* empty_descriptors_;
   static LocalVarDescriptors* empty_var_descriptors_;
   static ExceptionHandlers* empty_exception_handlers_;
   static Array* extractor_parameter_types_;
   static Array* extractor_parameter_names_;
   static Instance* sentinel_;
   static Instance* transition_sentinel_;
   static Instance* unknown_constant_;
   static Instance* non_constant_;
   static Bool* bool_true_;
@@ skipping 2683 matching lines @@
   static RawNamespace* New();
 
   RawField* metadata_field() const { return raw_ptr()->metadata_field_; }
   void set_metadata_field(const Field& value) const;
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Namespace, Object);
   friend class Class;
 };
 
 
+// ObjectPool contains constants, immediates and addresses embedded in code
+// and deoptimization infos. Each entry has an type-info associated with it
+// which is stored in a typed data array (info_array).
+class ObjectPool : public Object {
+ public:
+  enum EntryType {
+    kTaggedObject,
+    kImmediate,
+  };
+
+  struct Entry {
+    Entry() : raw_value_(), type_() { }
+    explicit Entry(const Object* obj) : obj_(obj), type_(kTaggedObject) { }
+    Entry(uword value, EntryType info) : raw_value_(value), type_(info) { }
+    union {
+      const Object* obj_;
+      uword raw_value_;
+    };
+    EntryType type_;
+  };
+
+  intptr_t Length() const {
+    return raw_ptr()->length_;
+  }
+  void SetLength(intptr_t value) const {
+    StoreNonPointer(&raw_ptr()->length_, value);
+  }
+
+  RawTypedData* info_array() const {
+    return raw_ptr()->info_array_;
+  }
+
+  void set_info_array(const TypedData& info_array) const;
+
+  static intptr_t length_offset() { return OFFSET_OF(RawObjectPool, length_); }
+  static intptr_t data_offset() {
+    return OFFSET_OF_RETURNED_VALUE(RawObjectPool, data);
+  }
+  static intptr_t element_offset(intptr_t index) {
+    return OFFSET_OF_RETURNED_VALUE(RawObjectPool, data)
+        + kBytesPerElement * index;
+  }
+
+  EntryType InfoAt(intptr_t index) const;
+  void SetInfoAt(intptr_t index, EntryType info) const;
+
+  RawObject* ObjectAt(intptr_t index) const {
+    ASSERT(InfoAt(index) == kTaggedObject);
+    return EntryAddr(index)->raw_obj_;
+  }
+  void SetObjectAt(intptr_t index, const Object& obj) const {
+    ASSERT(InfoAt(index) == kTaggedObject);
+    StorePointer(&EntryAddr(index)->raw_obj_, obj.raw());
+  }
+
+  uword RawValueAt(intptr_t index) const {
+    ASSERT(InfoAt(index) != kTaggedObject);
+    return EntryAddr(index)->raw_value_;
+  }
+  void SetRawValueAt(intptr_t index, uword raw_value) const {
+    ASSERT(InfoAt(index) != kTaggedObject);
+    StoreNonPointer(&EntryAddr(index)->raw_value_, raw_value);
+  }
+
+  static intptr_t InstanceSize() {
+    ASSERT(sizeof(RawObjectPool) ==
+           OFFSET_OF_RETURNED_VALUE(RawObjectPool, data));
+    return 0;
+  }
+
+  static const intptr_t kBytesPerElement = sizeof(RawObjectPool::Entry);
+  static const intptr_t kMaxElements = kSmiMax / kBytesPerElement;
+
+  static intptr_t InstanceSize(intptr_t len) {
+    // Ensure that variable length data is not adding to the object length.
+    ASSERT(sizeof(RawObjectPool) == (sizeof(RawObject) + (2 * kWordSize)));
+    ASSERT(0 <= len && len <= kMaxElements);
+    return RoundedAllocationSize(
+        sizeof(RawObjectPool) + (len * kBytesPerElement));
+  }
+
+  static RawObjectPool* New(intptr_t len);
+
+  static intptr_t IndexFromOffset(intptr_t offset) {
+    return (offset + kHeapObjectTag - data_offset()) / kBytesPerElement;
+  }
+
+  void DebugPrint() const;
+
+ private:
+  RawObjectPool::Entry const* EntryAddr(intptr_t index) const {
+    ASSERT((index >= 0) && (index < Length()));
+    return &raw_ptr()->data()[index];
+  }
+
+  FINAL_HEAP_OBJECT_IMPLEMENTATION(ObjectPool, Object);
+  friend class Class;
+  friend class Object;
+  friend class RawObjectPool;
+};
+
+
 class Instructions : public Object {
  public:
   intptr_t size() const { return raw_ptr()->size_; }  // Excludes HeaderSize().
   RawCode* code() const { return raw_ptr()->code_; }
   static intptr_t code_offset() {
     return OFFSET_OF(RawInstructions, code_);
   }
-  RawArray* object_pool() const { return raw_ptr()->object_pool_; }
+  RawObjectPool* object_pool() const { return raw_ptr()->object_pool_; }
   static intptr_t object_pool_offset() {
     return OFFSET_OF(RawInstructions, object_pool_);
   }
 
   uword EntryPoint() const {
     return reinterpret_cast<uword>(raw_ptr()) + HeaderSize();
   }
 
   static const intptr_t kMaxElements = (kMaxInt32 -
                                         (sizeof(RawInstructions) +
@@ skipping 24 matching lines @@
         entry_point - HeaderSize() + kHeapObjectTag);
   }
 
  private:
   void set_size(intptr_t size) const {
     StoreNonPointer(&raw_ptr()->size_, size);
   }
   void set_code(RawCode* code) const {
     StorePointer(&raw_ptr()->code_, code);
   }
-  void set_object_pool(RawArray* object_pool) const {
+  void set_object_pool(RawObjectPool* object_pool) const {
     StorePointer(&raw_ptr()->object_pool_, object_pool);
   }
 
   // New is a private method as RawInstruction and RawCode objects should
   // only be created using the Code::FinalizeCode method. This method creates
   // the RawInstruction and RawCode objects, sets up the pointer offsets
   // and links the two in a GC safe manner.
   static RawInstructions* New(intptr_t size);
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Instructions, Object);
@@ skipping 331 matching lines @@
   void set_is_alive(bool value) const;
 
   uword EntryPoint() const {
     const Instructions& instr = Instructions::Handle(instructions());
     return instr.EntryPoint();
   }
   intptr_t Size() const {
     const Instructions& instr = Instructions::Handle(instructions());
     return instr.size();
   }
-  RawArray* ObjectPool() const {
+  RawObjectPool* GetObjectPool() const {
     const Instructions& instr = Instructions::Handle(instructions());
     return instr.object_pool();
   }
   bool ContainsInstructionAt(uword addr) const {
     const Instructions& instr = Instructions::Handle(instructions());
     const uword offset = addr - instr.EntryPoint();
     return offset < static_cast<uword>(instr.size());
   }
 
   // Returns true if there is a debugger breakpoint set in this code object.
@@ skipping 3941 matching lines @@
 
 
 RawObject* MegamorphicCache::GetTargetFunction(const Array& array,
                                                intptr_t index) {
   return array.At((index * kEntryLength) + kTargetFunctionIndex);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_