Object pool with support for untagged entries.

runtime/vm/raw_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/raw_object.h"
 
 #include "vm/class_table.h"
 #include "vm/dart.h"
 #include "vm/freelist.h"
 #include "vm/isolate.h"
@@ skipping 97 matching lines @@
       instance_size = TwoByteString::InstanceSize(string_length);
       break;
     }
     case kArrayCid:
     case kImmutableArrayCid: {
       const RawArray* raw_array = reinterpret_cast<const RawArray*>(this);
       intptr_t array_length = Smi::Value(raw_array->ptr()->length_);
       instance_size = Array::InstanceSize(array_length);
       break;
     }
+    case kObjectPoolCid: {
+      const RawObjectPool* raw_object_pool =
+          reinterpret_cast<const RawObjectPool*>(this);
+      intptr_t len = raw_object_pool->ptr()->length_;
+      instance_size = ObjectPool::InstanceSize(len);
+      break;
+    }
 #define SIZE_FROM_CLASS(clazz)                                                 \
     case kTypedData##clazz##Cid:
     CLASS_LIST_TYPED_DATA(SIZE_FROM_CLASS) {
       const RawTypedData* raw_obj =
           reinterpret_cast<const RawTypedData*>(this);
       intptr_t cid = raw_obj->GetClassId();
       intptr_t array_len = Smi::Value(raw_obj->ptr()->length_);
       intptr_t lengthInBytes = array_len * TypedData::ElementSizeInBytes(cid);
       instance_size = TypedData::InstanceSize(lengthInBytes);
       break;
@@ skipping 388 matching lines @@
     for (intptr_t i = 0; i < length; i++) {
       int32_t offset = obj->data()[i];
       visitor->VisitPointer(
           reinterpret_cast<RawObject**>(entry_point + offset));
     }
   }
   return Code::InstanceSize(length);
 }
 
 
+intptr_t RawObjectPool::VisitObjectPoolPointers(
+    RawObjectPool* raw_obj, ObjectPointerVisitor* visitor) {
+  visitor->VisitPointer(
+      reinterpret_cast<RawObject**>(&raw_obj->ptr()->info_array_));
+  const intptr_t len = raw_obj->ptr()->length_;
+  RawTypedData* info_array = raw_obj->ptr()->info_array_->ptr();
+  Entry* first = raw_obj->first_entry();
+  for (intptr_t i = 0; i < len; ++i) {
+    ObjectPool::EntryType entry_type =
+        static_cast<ObjectPool::EntryType>(info_array->data()[i]);
+    if (entry_type == ObjectPool::kTaggedObject) {
+      visitor->VisitPointer(&(first + i)->raw_obj_);
+    }
+  }
+  return ObjectPool::InstanceSize(raw_obj->ptr()->length_);
+}
+
+
 intptr_t RawInstructions::VisitInstructionsPointers(
     RawInstructions* raw_obj, ObjectPointerVisitor* visitor) {
   RawInstructions* obj = raw_obj->ptr();
   visitor->VisitPointers(raw_obj->from(), raw_obj->to());
   return Instructions::InstanceSize(obj->size_);
 }
 
 
 bool RawInstructions::ContainsPC(RawObject* raw_obj, uword pc) {
   uword tags = raw_obj->ptr()->tags_;
@@ skipping 376 matching lines @@
 intptr_t RawUserTag::VisitUserTagPointers(
     RawUserTag* raw_obj, ObjectPointerVisitor* visitor) {
   // Make sure that we got here with the tagged pointer as this.
   ASSERT(raw_obj->IsHeapObject());
   visitor->VisitPointers(raw_obj->from(), raw_obj->to());
   return UserTag::InstanceSize();
 }
 
 
 }  // namespace dart