Support untagged object pool entries.

runtime/vm/assembler.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/assembler.h"
 
 #include "platform/utils.h"
 #include "vm/cpu.h"
 #include "vm/heap.h"
 #include "vm/memory_region.h"
@@ skipping 46 matching lines @@
   // Unmark the buffer, so we cannot emit after this.
   buffer_->has_ensured_capacity_ = false;
   // Make sure the generated instruction doesn't take up more
   // space than the minimum gap.
   intptr_t delta = gap_ - ComputeGap();
   ASSERT(delta <= kMinimumGap);
 }
 #endif
 
 
-AssemblerBuffer::AssemblerBuffer()
-    : pointer_offsets_(new ZoneGrowableArray<intptr_t>(16)) {
+AssemblerBuffer::AssemblerBuffer(Assembler* assembler)
+    : assembler_(assembler),
+      pointer_offsets_(new ZoneGrowableArray<intptr_t>(16)) {
   static const intptr_t kInitialBufferCapacity = 4 * KB;
   contents_ = NewContents(kInitialBufferCapacity);
   cursor_ = contents_;
   limit_ = ComputeLimit(contents_, kInitialBufferCapacity);
   fixup_ = NULL;
 #if defined(DEBUG)
   has_ensured_capacity_ = false;
   fixups_processed_ = false;
 #endif
 
   // Verify internal state.
   ASSERT(Capacity() == kInitialBufferCapacity);
   ASSERT(Size() == 0);
 }
 
 
 AssemblerBuffer::~AssemblerBuffer() {
 }
 
 
 void AssemblerBuffer::ProcessFixups(const MemoryRegion& region) {
   AssemblerFixup* fixup = fixup_;
   while (fixup != NULL) {
-    fixup->Process(region, fixup->position());
+    fixup->Process(region, fixup->position(), assembler_);
     fixup = fixup->previous();
   }
 }
 
 
 void AssemblerBuffer::FinalizeInstructions(const MemoryRegion& instructions) {
   // Copy the instructions from the buffer.
   MemoryRegion from(reinterpret_cast<void*>(contents()), Size());
   instructions.CopyFrom(0, from);
 
@@ skipping 34 matching lines @@
 }
 
 
 class PatchCodeWithHandle : public AssemblerFixup {
  public:
   PatchCodeWithHandle(ZoneGrowableArray<intptr_t>* pointer_offsets,
                       const Object& object)
       : pointer_offsets_(pointer_offsets), object_(object) {
   }
 
-  void Process(const MemoryRegion& region, intptr_t position) {
+  void Process(const MemoryRegion& region,
+               intptr_t position,
+               Assembler* assembler) {
     // Patch the handle into the code. Once the instructions are installed into
     // a raw code object and the pointer offsets are setup, the handle is
     // resolved.
     region.Store<const Object*>(position, &object_);
     pointer_offsets_->Add(position);
   }
 
   virtual bool IsPointerOffset() const { return true; }
 
  private:
@@ skipping 77 matching lines @@
 
   for (intptr_t i = 0; i < comments_.length(); i++) {
     comments.SetPCOffsetAt(i, comments_[i]->pc_offset());
     comments.SetCommentAt(i, comments_[i]->comment());
   }
 
   return comments;
 }
 
 
-intptr_t ObjectPool::AddObject(const Object& obj, Patchability patchable) {
+intptr_t ObjectPoolHelper::AddObject(const Object& obj) {
   // The object pool cannot be used in the vm isolate.
   ASSERT(Isolate::Current() != Dart::vm_isolate());
-  if (object_pool_.IsNull()) {
-    object_pool_ = GrowableObjectArray::New(Heap::kOld);
-  }
-  object_pool_.Add(obj, Heap::kOld);
-  patchable_pool_entries_.Add(patchable);
-  if (patchable == kNotPatchable) {
-    // The object isn't patchable. Record the index for fast lookup.
-    object_pool_index_table_.Insert(
-        ObjIndexPair(&obj, object_pool_.Length() - 1));
-  }
-  return object_pool_.Length() - 1;
+  ASSERT(obj.IsNotTemporaryScopedHandle());
+  tagged_entries_.Add(&obj);
+  // The object isn't patchable. Record the index for fast lookup.
+  intptr_t index = Assembler::kNumFixedEntries + tagged_entries_.length() - 1;
+  object_index_table_.Insert(ObjIndexPair(&obj, index));
+  return index;
 }
 
 
-intptr_t ObjectPool::AddExternalLabel(const ExternalLabel* label,
-                                      Patchability patchable) {
+intptr_t ObjectPoolHelper::AddFixedObject(const Object& obj) {
+  // The object pool cannot be used in the vm isolate.
   ASSERT(Isolate::Current() != Dart::vm_isolate());
-  const uword address = label->address();
-  ASSERT(Utils::IsAligned(address, 4));
-  // The address is stored in the object array as a RawSmi.
-  const Smi& smi = Smi::Handle(reinterpret_cast<RawSmi*>(address));
-  return AddObject(smi, patchable);
+  ASSERT(obj.IsNotTemporaryScopedHandle());
+  fixed_entries_.Add(ObjectPool::Entry(&obj));
+  // The object isn't patchable. Record the index for fast lookup.
+  object_index_table_.Insert(
+      ObjIndexPair(&obj, fixed_entries_.length() - 1));
+  return fixed_entries_.length() - 1;
 }
 
 
-intptr_t ObjectPool::FindObject(const Object& obj, Patchability patchable) {
+intptr_t ObjectPoolHelper::AddFixedExternalLabel(const ExternalLabel* label) {
+  ASSERT(Isolate::Current() != Dart::vm_isolate());
+  uword value = label->address();
+  fixed_entries_.Add(ObjectPool::Entry(value));
+  ASSERT(fixed_entries_.length() <= Assembler::kNumFixedEntries);
+  untagged_index_table_.Insert(
+      UntaggedIndexPair(value, fixed_entries_.length() - 1));
+  return fixed_entries_.length() - 1;
+}
+
+
+intptr_t ObjectPoolHelper::AddUntagged(uword value, Patchability patchable) {
+  ASSERT(Isolate::Current() != Dart::vm_isolate());
+  untagged_entries_.Add(value);
+  intptr_t index =
+      Assembler::kNumFixedEntries + untagged_entries_.length() - 1;
+  if (patchable == kNotPatchable) {
+    // The entry isn't patchable. Record the index for fast lookup.
+    untagged_index_table_.Insert(UntaggedIndexPair(value, index));
+  }
+  return index;
+}
+
+
+intptr_t ObjectPoolHelper::AddExternalLabel(const ExternalLabel* label,
+                                            Patchability patchable) {
+  return AddUntagged(label->address(), patchable);
+}
+
+
+intptr_t ObjectPoolHelper::AddImmediate(uword imm) {
+  return AddUntagged(imm, kNotPatchable);
+}
+
+
+intptr_t ObjectPoolHelper::FindObject(const Object& obj) {
   // The object pool cannot be used in the vm isolate.
   ASSERT(Isolate::Current() != Dart::vm_isolate());
+  // Check if we've already got it in the object pool.
+  intptr_t idx = object_index_table_.Lookup(&obj);
+  return (idx != ObjIndexPair::kNoIndex) ? idx : AddObject(obj);
+}
 
-  // If the object is not patchable, check if we've already got it in the
-  // object pool.
-  if (patchable == kNotPatchable && !object_pool_.IsNull()) {
-    intptr_t idx = object_pool_index_table_.Lookup(&obj);
-    if (idx != ObjIndexPair::kNoIndex) {
-      ASSERT(patchable_pool_entries_[idx] == kNotPatchable);
+
+intptr_t ObjectPoolHelper::FindUntagged(uword value, Patchability patchable) {
+  // The object pool cannot be used in the vm isolate.
+  ASSERT(Isolate::Current() != Dart::vm_isolate());
+  if (patchable == kNotPatchable) {
+    // Check if we've already got it in the object pool.
+    intptr_t idx = untagged_index_table_.Lookup(value);
+    if (idx != UntaggedIndexPair::kNoIndex) {
       return idx;
     }
   }
-
-  return AddObject(obj, patchable);
+  return AddUntagged(value, patchable);
 }
 
 
-intptr_t ObjectPool::FindExternalLabel(const ExternalLabel* label,
-                                       Patchability patchable) {
-  // The object pool cannot be used in the vm isolate.
-  ASSERT(Isolate::Current() != Dart::vm_isolate());
-  const uword address = label->address();
-  ASSERT(Utils::IsAligned(address, 4));
-  // The address is stored in the object array as a RawSmi.
-  const Smi& smi = Smi::Handle(reinterpret_cast<RawSmi*>(address));
-  return FindObject(smi, patchable);
+intptr_t ObjectPoolHelper::FindExternalLabel(const ExternalLabel* label,
+                                             Patchability patchable) {
+  return FindUntagged(label->address(), patchable);
 }
 
 
+intptr_t ObjectPoolHelper::FindImmediate(uword imm) {
+  return FindUntagged(imm, kNotPatchable);
+}
+
+
+RawObjectPool* ObjectPoolHelper::MakeObjectPool() {
+  // Code in the VM isolate does not use object pool.
+  if (Isolate::Current() == Dart::vm_isolate()) {
+    return Object::empty_object_pool().raw();
+  }
+
+  intptr_t length =
+      Assembler::kNumFixedEntries +
+      tagged_entries_.length() +
+      untagged_entries_.length();
+  const ObjectPool& object_pool = ObjectPool::Handle(
+      ObjectPool::New(length, tagged_entries_.length()));
+  intptr_t i = 0;
+  for (; i < Assembler::kNumFixedObjectEntries; ++i) {
+    object_pool.SetObjectAt(i, *fixed_entries_[i].obj_);
+  }
+  for (; i < Assembler::kNumFixedEntries; ++i) {
+    object_pool.SetRawValueAt(i, fixed_entries_[i].raw_value_);
+  }
+  for (i = 0; i < tagged_entries_.length(); ++i) {
+    object_pool.SetObjectAt(Assembler::kNumFixedEntries + i,
+                            *tagged_entries_[i]);
+  }
+  for (intptr_t j = 0; j < untagged_entries_.length(); ++j) {
+    object_pool.SetRawValueAt(Assembler::kNumFixedEntries + i + j,
+                              untagged_entries_[j]);
+  }
+  return object_pool.raw();
+}
+
+
+void ObjectPoolIndexFixup::Process(const MemoryRegion& region,
+                                   intptr_t position,
+                                   Assembler* assembler) {
+  int32_t index = region.Load<int32_t>(position - sizeof(int32_t));
+  index += assembler->object_pool().UntaggedEntryStart() * kWordSize;
+  region.Store<int32_t>(position - sizeof(int32_t), index);
+}
+
 }  // namespace dart