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

src/ia32/virtual-frame-ia32.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 29 matching lines @@
 // VirtualFrame implementation.
 
 // On entry to a function, the virtual frame already contains the receiver,
 // the parameters, and a return address.  All frame elements are in memory.
 VirtualFrame::VirtualFrame()
     : elements_(parameter_count() + local_count() + kPreallocatedElements),
       stack_pointer_(parameter_count() + 1) {  // 0-based index of TOS.
   for (int i = 0; i <= stack_pointer_; i++) {
     elements_.Add(FrameElement::MemoryElement());
   }
-  for (int i = 0; i < kNumRegisters; i++) {
+  for (int i = 0; i < RegisterAllocator::kNumRegisters; i++) {
     register_locations_[i] = kIllegalIndex;
   }
 }
 
 
 void VirtualFrame::SyncElementBelowStackPointer(int index) {
   // Emit code to write elements below the stack pointer to their
   // (already allocated) stack address.
   ASSERT(index <= stack_pointer_);
   FrameElement element = elements_[index];
@@ skipping 88 matching lines @@
     }
   }
   elements_[index].set_sync();
 }
 
 
 // Clear the dirty bits for the range of elements in
 // [min(stack_pointer_ + 1,begin), end].
 void VirtualFrame::SyncRange(int begin, int end) {
   ASSERT(begin >= 0);
-  ASSERT(end < elements_.length());
+  ASSERT(end < element_count());
   // Sync elements below the range if they have not been materialized
   // on the stack.
   int start = Min(begin, stack_pointer_ + 1);
 
   // If positive we have to adjust the stack pointer.
   int delta = end - stack_pointer_;
   if (delta > 0) {
     stack_pointer_ = end;
     __ sub(Operand(esp), Immediate(delta * kPointerSize));
   }
 
   for (int i = start; i <= end; i++) {
     if (!elements_[i].is_synced()) SyncElementBelowStackPointer(i);
   }
 }
 
 
 void VirtualFrame::MakeMergable(int mergable_elements) {
   if (mergable_elements == JumpTarget::kAllElements) {
-    mergable_elements = elements_.length();
+    mergable_elements = element_count();
   }
-  ASSERT(mergable_elements <= elements_.length());
+  ASSERT(mergable_elements <= element_count());
 
-  int start_index = elements_.length() - mergable_elements;
-  for (int i = start_index; i < elements_.length(); i++) {
+  int start_index = element_count() - mergable_elements;
+  for (int i = start_index; i < element_count(); i++) {
     FrameElement element = elements_[i];
 
     if (element.is_constant() || element.is_copy()) {
       if (element.is_synced()) {
         // Just spill.
         elements_[i] = FrameElement::MemoryElement();
       } else {
         // Allocate to a register.
         FrameElement backing_element;  // Invalid if not a copy.
         if (element.is_copy()) {
@@ skipping 79 matching lines @@
   // Move registers, constants, and copies to memory.  Perform moves
   // from the top downward in the frame in order to leave the backing
   // stores of copies in registers.
   //
   // Moving memory-backed copies to memory requires a spare register
   // for the memory-to-memory moves.  Since we are performing a merge,
   // we use esi (which is already saved in the frame).  We keep track
   // of the index of the frame element esi is caching or kIllegalIndex
   // if esi has not been disturbed.
   int esi_caches = kIllegalIndex;
-  for (int i = elements_.length() - 1; i >= 0; i--) {
+  for (int i = element_count() - 1; i >= 0; i--) {
     FrameElement target = expected->elements_[i];
     if (target.is_register()) continue;  // Handle registers later.
     if (target.is_memory()) {
       FrameElement source = elements_[i];
       switch (source.type()) {
         case FrameElement::INVALID:
           // Not a legal merge move.
           UNREACHABLE();
           break;
 
@@ skipping 45 matching lines @@
   if (esi_caches != kIllegalIndex) {
     __ mov(esi, Operand(ebp, fp_relative(context_index())));
   }
 }
 
 
 void VirtualFrame::MergeMoveRegistersToRegisters(VirtualFrame* expected) {
   // We have already done X-to-memory moves.
   ASSERT(stack_pointer_ >= expected->stack_pointer_);
 
-  for (int i = 0; i < kNumRegisters; i++) {
+  for (int i = 0; i < RegisterAllocator::kNumRegisters; i++) {
     // Move the right value into register i if it is currently in a register.
-    int index = expected->register_locations_[i];
-    int use_index = register_locations_[i];
+    int index = expected->register_location(i);
+    int use_index = register_location(i);
     // Skip if register i is unused in the target or else if source is
     // not a register (this is not a register-to-register move).
     if (index == kIllegalIndex || !elements_[index].is_register()) continue;
 
-    Register target = { i };
+    Register target = RegisterAllocator::ToRegister(i);
     Register source = elements_[index].reg();
-
     if (index != use_index) {
       if (use_index == kIllegalIndex) {  // Target is currently unused.
         // Copy contents of source from source to target.
         // Set frame element register to target.
         Use(target, index);
         Unuse(source);
         __ mov(target, source);
       } else {
         // Exchange contents of registers source and target.
         // Nothing except the register backing use_index has changed.
         elements_[use_index].set_reg(source);
-        register_locations_[target.code()] = index;
-        register_locations_[source.code()] = use_index;
+        set_register_location(target, index);
+        set_register_location(source, use_index);
         __ xchg(source, target);
       }
     }
 
     if (!elements_[index].is_synced() &&
         expected->elements_[index].is_synced()) {
       __ mov(Operand(ebp, fp_relative(index)), target);
     }
     elements_[index] = expected->elements_[index];
   }
 }
 
 
 void VirtualFrame::MergeMoveMemoryToRegisters(VirtualFrame* expected) {
   // Move memory, constants, and copies to registers.  This is the
   // final step and since it is not done from the bottom up, but in
   // register code order, we have special code to ensure that the backing
   // elements of copies are in their correct locations when we
   // encounter the copies.
-  for (int i = 0; i < kNumRegisters; i++) {
-    int index = expected->register_locations_[i];
+  for (int i = 0; i < RegisterAllocator::kNumRegisters; i++) {
+    int index = expected->register_location(i);
     if (index != kIllegalIndex) {
       FrameElement source = elements_[index];
       FrameElement target = expected->elements_[index];
-      Register target_reg = { i };
+      Register target_reg = RegisterAllocator::ToRegister(i);
       ASSERT(target.reg().is(target_reg));
       switch (source.type()) {
         case FrameElement::INVALID:  // Fall through.
           UNREACHABLE();
           break;
         case FrameElement::REGISTER:
-          ASSERT(source.reg().is(target_reg));
-          continue;  // Go to next iteration.  Skips Use(target_reg) below.
+          ASSERT(source.Equals(target));
+          // Go to next iteration.  Skips Use(target_reg) and syncing
+          // below.  It is safe to skip syncing because a target
+          // register frame element would only be synced if all source
+          // elements were.
+          continue;
           break;
         case FrameElement::MEMORY:
           ASSERT(index <= stack_pointer_);
           __ mov(target_reg, Operand(ebp, fp_relative(index)));
           break;
 
         case FrameElement::CONSTANT:
           if (cgen()->IsUnsafeSmi(source.handle())) {
             cgen()->LoadUnsafeSmi(target_reg, source.handle());
           } else {
@@ skipping 19 matching lines @@
                      Operand(ebp, fp_relative(backing_index)));
               __ mov(target_reg, new_backing_reg);
             } else {
               __ mov(target_reg, Operand(ebp, fp_relative(backing_index)));
             }
           } else {
             __ mov(target_reg, backing.reg());
           }
         }
       }
-      // Ensure the proper sync state.  If the source was memory no
-      // code needs to be emitted.
+      // Ensure the proper sync state.
       if (target.is_synced() && !source.is_synced()) {
         __ mov(Operand(ebp, fp_relative(index)), target_reg);
       }
       Use(target_reg, index);
       elements_[index] = target;
     }
   }
 }
 
 
@@ skipping 17 matching lines @@
   __ mov(ebp, Operand(esp));
 
   // Store the context in the frame.  The context is kept in esi and a
   // copy is stored in the frame.  The external reference to esi
   // remains.
   EmitPush(esi);
 
   // Store the function in the frame.  The frame owns the register
   // reference now (ie, it can keep it in edi or spill it later).
   Push(edi);
-  SyncElementAt(elements_.length() - 1);
+  SyncElementAt(element_count() - 1);
   cgen()->allocator()->Unuse(edi);
 }
 
 
 void VirtualFrame::Exit() {
   Comment cmnt(masm(), "[ Exit JS frame");
   // Record the location of the JS exit code for patching when setting
   // break point.
   __ RecordJSReturn();
 
   // Avoid using the leave instruction here, because it is too
   // short. We need the return sequence to be a least the size of a
   // call instruction to support patching the exit code in the
   // debugger. See VisitReturnStatement for the full return sequence.
   __ mov(esp, Operand(ebp));
   stack_pointer_ = frame_pointer();
-  for (int i = elements_.length() - 1; i > stack_pointer_; i--) {
+  for (int i = element_count() - 1; i > stack_pointer_; i--) {
     FrameElement last = elements_.RemoveLast();
     if (last.is_register()) {
       Unuse(last.reg());
     }
   }
 
   EmitPop(ebp);
 }
 
 
 void VirtualFrame::AllocateStackSlots() {
   int count = local_count();
   if (count > 0) {
     Comment cmnt(masm(), "[ Allocate space for locals");
     // The locals are initialized to a constant (the undefined value), but
     // we sync them with the actual frame to allocate space for spilling
     // them later.  First sync everything above the stack pointer so we can
     // use pushes to allocate and initialize the locals.
-    SyncRange(stack_pointer_ + 1, elements_.length() - 1);
+    SyncRange(stack_pointer_ + 1, element_count() - 1);
     Handle<Object> undefined = Factory::undefined_value();
     FrameElement initial_value =
         FrameElement::ConstantElement(undefined, FrameElement::SYNCED);
     Result temp = cgen()->allocator()->Allocate();
     ASSERT(temp.is_valid());
     __ Set(temp.reg(), Immediate(undefined));
     for (int i = 0; i < count; i++) {
       elements_.Add(initial_value);
       stack_pointer_++;
       __ push(temp.reg());
@@ skipping 22 matching lines @@
 }
 
 
 int VirtualFrame::InvalidateFrameSlotAt(int index) {
   FrameElement original = elements_[index];
 
   // Is this element the backing store of any copies?
   int new_backing_index = kIllegalIndex;
   if (original.is_copied()) {
     // Verify it is copied, and find first copy.
-    for (int i = index + 1; i < elements_.length(); i++) {
+    for (int i = index + 1; i < element_count(); i++) {
       if (elements_[i].is_copy() && elements_[i].index() == index) {
         new_backing_index = i;
         break;
       }
     }
   }
 
   if (new_backing_index == kIllegalIndex) {
     // No copies found, return kIllegalIndex.
     if (original.is_register()) {
       Unuse(original.reg());
     }
     elements_[index] = FrameElement::InvalidElement();
     return kIllegalIndex;
   }
 
   // This is the backing store of copies.
   Register backing_reg;
   if (original.is_memory()) {
     Result fresh = cgen()->allocator()->Allocate();
     ASSERT(fresh.is_valid());
     Use(fresh.reg(), new_backing_index);
     backing_reg = fresh.reg();
     __ mov(backing_reg, Operand(ebp, fp_relative(index)));
   } else {
     // The original was in a register.
     backing_reg = original.reg();
-    register_locations_[backing_reg.code()] = new_backing_index;
+    set_register_location(backing_reg, new_backing_index);
   }
   // Invalidate the element at index.
   elements_[index] = FrameElement::InvalidElement();
   // Set the new backing element.
   if (elements_[new_backing_index].is_synced()) {
     elements_[new_backing_index] =
         FrameElement::RegisterElement(backing_reg, FrameElement::SYNCED);
   } else {
     elements_[new_backing_index] =
         FrameElement::RegisterElement(backing_reg, FrameElement::NOT_SYNCED);
   }
   // Update the other copies.
-  for (int i = new_backing_index + 1; i < elements_.length(); i++) {
+  for (int i = new_backing_index + 1; i < element_count(); i++) {
     if (elements_[i].is_copy() && elements_[i].index() == index) {
       elements_[i].set_index(new_backing_index);
       elements_[new_backing_index].set_copied();
     }
   }
   return new_backing_index;
 }
 
 
 void VirtualFrame::TakeFrameSlotAt(int index) {
   ASSERT(index >= 0);
-  ASSERT(index <= elements_.length());
+  ASSERT(index <= element_count());
   FrameElement original = elements_[index];
   int new_backing_store_index = InvalidateFrameSlotAt(index);
   if (new_backing_store_index != kIllegalIndex) {
     elements_.Add(CopyElementAt(new_backing_store_index));
     return;
   }
 
   switch (original.type()) {
     case FrameElement::MEMORY: {
       // Emit code to load the original element's data into a register.
       // Push that register as a FrameElement on top of the frame.
       Result fresh = cgen()->allocator()->Allocate();
       ASSERT(fresh.is_valid());
       FrameElement new_element =
           FrameElement::RegisterElement(fresh.reg(),
                                         FrameElement::NOT_SYNCED);
-      Use(fresh.reg(), elements_.length());
+      Use(fresh.reg(), element_count());
       elements_.Add(new_element);
       __ mov(fresh.reg(), Operand(ebp, fp_relative(index)));
       break;
     }
     case FrameElement::REGISTER:
-      Use(original.reg(), elements_.length());
+      Use(original.reg(), element_count());
       // Fall through.
     case FrameElement::CONSTANT:
     case FrameElement::COPY:
       original.clear_sync();
       elements_.Add(original);
       break;
     case FrameElement::INVALID:
       UNREACHABLE();
       break;
   }
 }
 
 
 void VirtualFrame::StoreToFrameSlotAt(int index) {
   // Store the value on top of the frame to the virtual frame slot at
   // a given index.  The value on top of the frame is left in place.
   // This is a duplicating operation, so it can create copies.
   ASSERT(index >= 0);
-  ASSERT(index < elements_.length());
+  ASSERT(index < element_count());
 
-  int top_index = elements_.length() - 1;
+  int top_index = element_count() - 1;
   FrameElement top = elements_[top_index];
   FrameElement original = elements_[index];
   if (top.is_copy() && top.index() == index) return;
   ASSERT(top.is_valid());
 
   InvalidateFrameSlotAt(index);
 
   // InvalidateFrameSlotAt can potentially change any frame element, due
   // to spilling registers to allocate temporaries in order to preserve
   // the copy-on-write semantics of aliased elements.  Reload top from
@@ skipping 26 matching lines @@
         //
         // TODO(209): considering allocating the stored-to slot to the
         // temp register.  Alternatively, allow copies to appear in
         // any order in the frame and lazily move the value down to
         // the slot.
         Result temp = cgen()->allocator()->Allocate();
         ASSERT(temp.is_valid());
         __ mov(temp.reg(), Operand(ebp, fp_relative(backing_index)));
         __ mov(Operand(ebp, fp_relative(index)), temp.reg());
       } else {
-        register_locations_[backing_element.reg().code()] = index;
+        set_register_location(backing_element.reg(), index);
         if (backing_element.is_synced()) {
           // If the element is a register, we will not actually move
           // anything on the stack but only update the virtual frame
           // element.
           backing_element.clear_sync();
         }
       }
       elements_[index] = backing_element;
 
       // The old backing element becomes a copy of the new backing
       // element.
       FrameElement new_element = CopyElementAt(index);
       elements_[backing_index] = new_element;
       if (backing_element.is_synced()) {
         elements_[backing_index].set_sync();
       }
 
       // All the copies of the old backing element (including the top
       // element) become copies of the new backing element.
-      for (int i = backing_index + 1; i < elements_.length(); i++) {
+      for (int i = backing_index + 1; i < element_count(); i++) {
         if (elements_[i].is_copy() && elements_[i].index() == backing_index) {
           elements_[i].set_index(index);
         }
       }
     }
     return;
   }
 
   // Move the top element to the stored-to slot and replace it (the
   // top element) with a copy.
   elements_[index] = top;
   if (top.is_memory()) {
     // TODO(209): consider allocating the stored-to slot to the temp
     // register.  Alternatively, allow copies to appear in any order
     // in the frame and lazily move the value down to the slot.
     FrameElement new_top = CopyElementAt(index);
     new_top.set_sync();
     elements_[top_index] = new_top;
 
     // The sync state of the former top element is correct (synced).
     // Emit code to move the value down in the frame.
     Result temp = cgen()->allocator()->Allocate();
     ASSERT(temp.is_valid());
     __ mov(temp.reg(), Operand(esp, 0));
     __ mov(Operand(ebp, fp_relative(index)), temp.reg());
   } else if (top.is_register()) {
-    register_locations_[top.reg().code()] = index;
+    set_register_location(top.reg(), index);
     // The stored-to slot has the (unsynced) register reference and
     // the top element becomes a copy.  The sync state of the top is
     // preserved.
     FrameElement new_top = CopyElementAt(index);
     if (top.is_synced()) {
       new_top.set_sync();
       elements_[index].clear_sync();
     }
     elements_[top_index] = new_top;
   } else {
@@ skipping 203 matching lines @@
   __ Set(num_args.reg(), Immediate(arg_count));
 
   function.Unuse();
   num_args.Unuse();
   return RawCallCodeObject(ic, RelocInfo::CONSTRUCT_CALL);
 }
 
 
 void VirtualFrame::Drop(int count) {
   ASSERT(height() >= count);
-  int num_virtual_elements = (elements_.length() - 1) - stack_pointer_;
+  int num_virtual_elements = (element_count() - 1) - stack_pointer_;
 
   // Emit code to lower the stack pointer if necessary.
   if (num_virtual_elements < count) {
     int num_dropped = count - num_virtual_elements;
     stack_pointer_ -= num_dropped;
     __ add(Operand(esp), Immediate(num_dropped * kPointerSize));
   }
 
   // Discard elements from the virtual frame and free any registers.
   for (int i = 0; i < count; i++) {
     FrameElement dropped = elements_.RemoveLast();
     if (dropped.is_register()) {
       Unuse(dropped.reg());
     }
   }
 }
 
 
 Result VirtualFrame::Pop() {
   FrameElement element = elements_.RemoveLast();
-  int index = elements_.length();
+  int index = element_count();
   ASSERT(element.is_valid());
 
   bool pop_needed = (stack_pointer_ == index);
   if (pop_needed) {
     stack_pointer_--;
     if (element.is_memory()) {
       Result temp = cgen()->allocator()->Allocate();
       ASSERT(temp.is_valid());
       temp.set_static_type(element.static_type());
       __ pop(temp.reg());
@@ skipping 34 matching lines @@
   } else if (element.is_register()) {
     return Result(element.reg(), element.static_type());
   } else {
     ASSERT(element.is_constant());
     return Result(element.handle());
   }
 }
 
 
 void VirtualFrame::EmitPop(Register reg) {
-  ASSERT(stack_pointer_ == elements_.length() - 1);
+  ASSERT(stack_pointer_ == element_count() - 1);
   stack_pointer_--;
   elements_.RemoveLast();
   __ pop(reg);
 }
 
 
 void VirtualFrame::EmitPop(Operand operand) {
-  ASSERT(stack_pointer_ == elements_.length() - 1);
+  ASSERT(stack_pointer_ == element_count() - 1);
   stack_pointer_--;
   elements_.RemoveLast();
   __ pop(operand);
 }
 
 
 void VirtualFrame::EmitPush(Register reg) {
-  ASSERT(stack_pointer_ == elements_.length() - 1);
+  ASSERT(stack_pointer_ == element_count() - 1);
   elements_.Add(FrameElement::MemoryElement());
   stack_pointer_++;
   __ push(reg);
 }
 
 
 void VirtualFrame::EmitPush(Operand operand) {
-  ASSERT(stack_pointer_ == elements_.length() - 1);
+  ASSERT(stack_pointer_ == element_count() - 1);
   elements_.Add(FrameElement::MemoryElement());
   stack_pointer_++;
   __ push(operand);
 }
 
 
 void VirtualFrame::EmitPush(Immediate immediate) {
-  ASSERT(stack_pointer_ == elements_.length() - 1);
+  ASSERT(stack_pointer_ == element_count() - 1);
   elements_.Add(FrameElement::MemoryElement());
   stack_pointer_++;
   __ push(immediate);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal