Add pointers to a VirtualFrame that keep track of the indexes of register...

src/virtual-frame-ia32.cc

 // Copyright 2008 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 33 matching lines @@
     : cgen_(cgen),
       masm_(cgen->masm()),
       elements_(0),
       parameter_count_(cgen->scope()->num_parameters()),
       local_count_(0),
       stack_pointer_(parameter_count_ + 1),  // 0-based index of TOS.
       frame_pointer_(kIllegalIndex) {
   for (int i = 0; i < parameter_count_ + 2; i++) {
     elements_.Add(FrameElement::MemoryElement());
   }
+  for (int i = 0; i < kNumRegisters; i++) {
+    register_locations_[i] = kIllegalIndex;
+  }
 }
 
 
 // Clear the dirty bit for the element at a given index if it is a
 // valid element.  The stack address corresponding to the element must
 // be allocated on the physical stack, or the first element above the
 // stack pointer so it can be allocated by a single push instruction.
 void VirtualFrame::RawSyncElementAt(int index) {
   FrameElement element = elements_[index];
 
@@ skipping 254 matching lines @@
               }
               last_move_blocked = i;
               any_moves_blocked = true;
             }
           } else {
             // The move is not blocked.  This frame element can be moved from
             // its source register to its target register.
             if (target.is_synced() && !source.is_synced()) {
               SyncElementAt(i);
             }
-            Use(target.reg());
+            Use(target.reg(), i);
             Unuse(source.reg());
             elements_[i] = target;
             __ mov(target.reg(), source.reg());
             any_moves_made = true;
           }
         }
       }
     }
     // Update control flags for next iteration.
     should_break_cycles = (any_moves_blocked && !any_moves_made);
@@ skipping 42 matching lines @@
           } else {
             __ mov(target.reg(), backing.reg());
           }
         }
       }
       // Ensure the proper sync state.  If the source was memory no
       // code needs to be emitted.
       if (target.is_synced() && !source.is_memory()) {
         SyncElementAt(i);
       }
-      Use(target.reg());
+      Use(target.reg(), i);
       elements_[i] = target;
     }
   }
 }
 
 
 void VirtualFrame::Enter() {
   // Registers live on entry: esp, ebp, esi, edi.
   Comment cmnt(masm_, "[ Enter JS frame");
 
@@ skipping 118 matching lines @@
     }
     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());
+    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;
   }
   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++) {
@@ skipping 18 matching lines @@
 
   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());
+      Use(fresh.reg(), elements_.length());
       elements_.Add(new_element);
       __ mov(fresh.reg(), Operand(ebp, fp_relative(index)));
       break;
     }
     case FrameElement::REGISTER:
-      Use(original.reg());
+      Use(original.reg(), elements_.length());
       // Fall through.
     case FrameElement::CONSTANT:
     case FrameElement::COPY:
       original.clear_sync();
       elements_.Add(original);
       break;
     case FrameElement::INVALID:
       UNREACHABLE();
       break;
   }
@@ skipping 40 matching lines @@
         // have to move the actual value down in the stack.
         //
         // 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 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();
+      } else {
+        register_locations_[backing_element.reg().code()] = 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();
       }
@@ skipping 20 matching lines @@
     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;
     // 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 186 matching lines @@
   }
   ASSERT(!element.is_copy());
 
   // The element is memory, a register, or a constant.
   if (element.is_memory()) {
     // Memory elements could only be the backing store of a copy.
     // Allocate the original to a register.
     ASSERT(index <= stack_pointer_);
     Result temp = cgen_->allocator()->Allocate();
     ASSERT(temp.is_valid());
-    Use(temp.reg());
+    Use(temp.reg(), index);
     FrameElement new_element =
         FrameElement::RegisterElement(temp.reg(), FrameElement::SYNCED);
     elements_[index] = new_element;
     __ mov(temp.reg(), Operand(ebp, fp_relative(index)));
     return Result(temp.reg(), cgen_);
   } else if (element.is_register()) {
     return Result(element.reg(), cgen_);
   } else {
     ASSERT(element.is_constant());
     return Result(element.handle(), cgen_);
@@ skipping 37 matching lines @@
   ASSERT(stack_pointer_ == elements_.length() - 1);
   elements_.Add(FrameElement::MemoryElement());
   stack_pointer_++;
   __ push(immediate);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal