Support untagged object pool 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/assembler.h"
 #include "vm/class_table.h"
 #include "vm/dart.h"
 #include "vm/freelist.h"
 #include "vm/isolate.h"
 #include "vm/object.h"
 #include "vm/visitor.h"
 
 
 namespace dart {
 
@@ skipping 91 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);
 }
 
 
+RawObjectPool::Entry* RawObjectPool::from() {
+  return &ptr()->data()[Assembler::kNumFixedEntries];
+}
+
+
+RawObjectPool::Entry* RawObjectPool::to() {
+  return &ptr()->data()[Assembler::kNumFixedEntries +
+                        ptr()->num_tagged_entries_ - 1];
+}
+
+
+intptr_t RawObjectPool::VisitObjectPoolPointers(
+    RawObjectPool* raw_obj, ObjectPointerVisitor* visitor) {
+  for (Entry* current = raw_obj->from();
+       current <= raw_obj->to();
+       current++) {
+    visitor->VisitPointer(&current->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