Change the register allocator so that it no longer tracks references...

src/virtual-frame.cc

 // Copyright 2009 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 20 matching lines @@
 #include "register-allocator-inl.h"
 
 namespace v8 {
 namespace internal {
 
 // -------------------------------------------------------------------------
 // VirtualFrame implementation.
 
 // When cloned, a frame is a deep copy of the original.
 VirtualFrame::VirtualFrame(VirtualFrame* original)
-    : elements_(original->elements_.length()),
+    : elements_(original->element_count()),
       stack_pointer_(original->stack_pointer_) {
   elements_.AddAll(original->elements_);
   // Copy register locations from original.
   memcpy(&register_locations_,
          original->register_locations_,
          sizeof(register_locations_));
 }
 
 
 FrameElement VirtualFrame::CopyElementAt(int index) {
   ASSERT(index >= 0);
-  ASSERT(index < elements_.length());
+  ASSERT(index < element_count());
 
   FrameElement target = elements_[index];
   FrameElement result;
 
   switch (target.type()) {
     case FrameElement::CONSTANT:
       // We do not copy constants and instead return a fresh unsynced
       // constant.
       result = FrameElement::ConstantElement(target.handle(),
                                              FrameElement::NOT_SYNCED);
@@ skipping 25 matching lines @@
   return result;
 }
 
 
 // Modify the state of the virtual frame to match the actual frame by adding
 // extra in-memory elements to the top of the virtual frame.  The extra
 // elements will be externally materialized on the actual frame (eg, by
 // pushing an exception handler).  No code is emitted.
 void VirtualFrame::Adjust(int count) {
   ASSERT(count >= 0);
-  ASSERT(stack_pointer_ == elements_.length() - 1);
+  ASSERT(stack_pointer_ == element_count() - 1);
 
   for (int i = 0; i < count; i++) {
     elements_.Add(FrameElement::MemoryElement());
   }
   stack_pointer_ += count;
 }
 
 
 void VirtualFrame::ForgetElements(int count) {
   ASSERT(count >= 0);
-  ASSERT(elements_.length() >= count);
+  ASSERT(element_count() >= count);
 
   for (int i = 0; i < count; i++) {
     FrameElement last = elements_.RemoveLast();
     if (last.is_register()) {
       // A hack to properly count register references for the code
       // generator's current frame and also for other frames.  The
       // same code appears in PrepareMergeTo.
       if (cgen()->frame() == this) {
         Unuse(last.reg());
       } else {
-        register_locations_[last.reg().code()] = kIllegalIndex;
+        set_register_location(last.reg(), kIllegalIndex);
       }
     }
   }
 }
 
 
 // If there are any registers referenced only by the frame, spill one.
 Register VirtualFrame::SpillAnyRegister() {
-  // Find the leftmost (ordered by register code) register whose only
+  // Find the leftmost (ordered by register number) register whose only
   // reference is in the frame.
-  for (int i = 0; i < kNumRegisters; i++) {
+  for (int i = 0; i < RegisterAllocator::kNumRegisters; i++) {
     if (is_used(i) && cgen()->allocator()->count(i) == 1) {
-      Register result = { i };
-      Spill(result);
-      ASSERT(!cgen()->allocator()->is_used(result));
-      return result;
+      SpillElementAt(register_location(i));
+      ASSERT(!cgen()->allocator()->is_used(i));
+      return RegisterAllocator::ToRegister(i);
     }
   }
   return no_reg;
 }
 
 
 // Make the type of the element at a given index be MEMORY.
 void VirtualFrame::SpillElementAt(int index) {
   if (!elements_[index].is_valid()) return;
 
@@ skipping 18 matching lines @@
   } else if (index == stack_pointer_ + 1) {
     SyncElementByPushing(index);
   } else {
     SyncRange(stack_pointer_ + 1, index);
   }
 }
 
 
 // Make the type of all elements be MEMORY.
 void VirtualFrame::SpillAll() {
-  for (int i = 0; i < elements_.length(); i++) {
+  for (int i = 0; i < element_count(); i++) {
     SpillElementAt(i);
   }
 }
 
 
 void VirtualFrame::PrepareMergeTo(VirtualFrame* expected) {
   // Perform state changes on this frame that will make merge to the
   // expected frame simpler or else increase the likelihood that his
   // frame will match another.
-  for (int i = 0; i < elements_.length(); i++) {
+  for (int i = 0; i < element_count(); i++) {
     FrameElement source = elements_[i];
     FrameElement target = expected->elements_[i];
 
     if (!target.is_valid() ||
         (target.is_memory() && !source.is_memory() && source.is_synced())) {
       // No code needs to be generated to invalidate valid elements.
       // No code needs to be generated to move values to memory if
       // they are already synced.  We perform those moves here, before
       // merging.
       if (source.is_register()) {
         // If the frame is the code generator's current frame, we have
         // to decrement both the frame-internal and global register
         // counts.
         if (cgen()->frame() == this) {
           Unuse(source.reg());
         } else {
-          register_locations_[source.reg().code()] = kIllegalIndex;
+          set_register_location(source.reg(), kIllegalIndex);
         }
       }
       elements_[i] = target;
     } else if (target.is_register() && !target.is_synced() &&
                !source.is_memory()) {
       // If an element's target is a register that doesn't need to be
       // synced, and the element is not in memory, then the sync state
       // of the element is irrelevant.  We clear the sync bit.
       ASSERT(source.is_valid());
       elements_[i].clear_sync();
     }
     // No code needs to be generated to change the static type of an
     // element.
     elements_[i].set_static_type(target.static_type());
   }
 }
 
 
 void VirtualFrame::PrepareForCall(int spilled_args, int dropped_args) {
   ASSERT(height() >= dropped_args);
   ASSERT(height() >= spilled_args);
   ASSERT(dropped_args <= spilled_args);
 
-  SyncRange(0, elements_.length() - 1);
+  SyncRange(0, element_count() - 1);
   // Spill registers.
-  for (int i = 0; i < kNumRegisters; i++) {
+  for (int i = 0; i < RegisterAllocator::kNumRegisters; i++) {
     if (is_used(i)) {
-      SpillElementAt(register_locations_[i]);
+      SpillElementAt(register_location(i));
     }
   }
 
   // Spill the arguments.
-  for (int i = elements_.length() - spilled_args; i < elements_.length(); i++) {
+  for (int i = element_count() - spilled_args; i < element_count(); i++) {
     if (!elements_[i].is_memory()) {
       SpillElementAt(i);
     }
   }
 
   // Forget the frame elements that will be popped by the call.
   Forget(dropped_args);
 }
 
 
 void VirtualFrame::PrepareForReturn() {
   // Spill all locals. This is necessary to make sure all locals have
   // the right value when breaking at the return site in the debugger.
   // Set their static type to unknown so that they will match the known
   // return frame.
   for (int i = 0; i < expression_base_index(); i++) {
     SpillElementAt(i);
     elements_[i].set_static_type(StaticType::unknown());
   }
 }
 
 
 void VirtualFrame::SetElementAt(int index, Result* value) {
-  int frame_index = elements_.length() - index - 1;
+  int frame_index = element_count() - index - 1;
   ASSERT(frame_index >= 0);
-  ASSERT(frame_index < elements_.length());
+  ASSERT(frame_index < element_count());
   ASSERT(value->is_valid());
   FrameElement original = elements_[frame_index];
 
   // Early exit if the element is the same as the one being set.
   bool same_register = original.is_register()
       && value->is_register()
       && original.reg().is(value->reg());
   bool same_constant = original.is_constant()
       && value->is_constant()
       && original.handle().is_identical_to(value->handle());
   if (same_register || same_constant) {
     value->Unuse();
     return;
   }
 
   InvalidateFrameSlotAt(frame_index);
 
   FrameElement new_element;
   if (value->is_register()) {
     if (is_used(value->reg())) {
       // The register already appears on the frame.  Either the existing
       // register element, or the new element at frame_index, must be made
       // a copy.
-      int i = register_index(value->reg());
+      int i = register_location(value->reg());
       ASSERT(value->static_type() == elements_[i].static_type());
 
       if (i < frame_index) {
         // The register FrameElement is lower in the frame than the new copy.
         elements_[frame_index] = CopyElementAt(i);
       } else {
         // There was an early bailout for the case of setting a
         // register element to itself.
         ASSERT(i != frame_index);
         elements_[frame_index] = elements_[i];
         elements_[i] = CopyElementAt(frame_index);
         if (elements_[frame_index].is_synced()) {
           elements_[i].set_sync();
         }
         elements_[frame_index].clear_sync();
-        register_locations_[value->reg().code()] = frame_index;
-        for (int j = i + 1; j < elements_.length(); j++) {
+        set_register_location(value->reg(), frame_index);
+        for (int j = i + 1; j < element_count(); j++) {
           if (elements_[j].is_copy() && elements_[j].index() == i) {
             elements_[j].set_index(frame_index);
           }
         }
       }
     } else {
       // The register value->reg() was not already used on the frame.
       Use(value->reg(), frame_index);
       elements_[frame_index] =
           FrameElement::RegisterElement(value->reg(),
@@ skipping 10 matching lines @@
 }
 
 
 void VirtualFrame::PushFrameSlotAt(int index) {
   elements_.Add(CopyElementAt(index));
 }
 
 
 void VirtualFrame::Push(Register reg, StaticType static_type) {
   if (is_used(reg)) {
-    int index = register_index(reg);
+    int index = register_location(reg);
     FrameElement element = CopyElementAt(index);
     ASSERT(static_type.merge(element.static_type()) == element.static_type());
     elements_.Add(element);
   } else {
-    Use(reg, elements_.length());
+    Use(reg, element_count());
     FrameElement element =
         FrameElement::RegisterElement(reg,
                                       FrameElement::NOT_SYNCED,
                                       static_type);
     elements_.Add(element);
   }
 }
 
 
 void VirtualFrame::Push(Handle<Object> value) {
   FrameElement element =
       FrameElement::ConstantElement(value, FrameElement::NOT_SYNCED);
   elements_.Add(element);
 }
 
 
 void VirtualFrame::Nip(int num_dropped) {
   ASSERT(num_dropped >= 0);
   if (num_dropped == 0) return;
   Result tos = Pop();
   if (num_dropped > 1) {
     Drop(num_dropped - 1);
   }
   SetElementAt(0, &tos);
 }
 
 
 bool VirtualFrame::Equals(VirtualFrame* other) {
 #ifdef DEBUG
-  for (int i = 0; i < kNumRegisters; i++) {
-    if (register_locations_[i] != other->register_locations_[i]) {
+  for (int i = 0; i < RegisterAllocator::kNumRegisters; i++) {
+    if (register_location(i) != other->register_location(i)) {
       return false;
     }
   }
-  if (elements_.length() != other->elements_.length()) return false;
+  if (element_count() != other->element_count()) return false;
 #endif
   if (stack_pointer_ != other->stack_pointer_) return false;
-  for (int i = 0; i < elements_.length(); i++) {
+  for (int i = 0; i < element_count(); i++) {
     if (!elements_[i].Equals(other->elements_[i])) return false;
   }
 
   return true;
 }
 
 
 // Specialization of List::ResizeAdd to non-inlined version for FrameElements.
 // The function ResizeAdd becomes a real function, whose implementation is the
 // inlined ResizeAddInternal.
 template <>
 void List<FrameElement,
           FreeStoreAllocationPolicy>::ResizeAdd(const FrameElement& element) {
   ResizeAddInternal(element);
 }
 
 } }  // namespace v8::internal