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

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 45 matching lines @@
       elements_(original->elements_.length()),
       parameter_count_(original->parameter_count_),
       local_count_(original->local_count_),
       stack_pointer_(original->stack_pointer_),
       frame_pointer_(original->frame_pointer_),
       frame_registers_(original->frame_registers_) {
   // Copy all the elements from the original.
   for (int i = 0; i < original->elements_.length(); i++) {
     elements_.Add(original->elements_[i]);
   }
+  for (int i = 0; i < kNumRegisters; i++) {
+    register_locations_[i] = original->register_locations_[i];
+  }
 }
 
 
 FrameElement VirtualFrame::CopyElementAt(int index) {
   ASSERT(index >= 0);
   ASSERT(index < elements_.length());
 
   FrameElement target = elements_[index];
   FrameElement result;
 
@@ skipping 67 matching lines @@
   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 {
         frame_registers_.Unuse(last.reg());
+        register_locations_[last.reg().code()] = kIllegalIndex;
       }
     }
   }
 }
 
 
-void VirtualFrame::Use(Register reg) {
+void VirtualFrame::Use(Register reg, int index) {
+  ASSERT(frame_registers_.count(reg) == 0);
+  ASSERT(register_locations_[reg.code()] == kIllegalIndex);
+  register_locations_[reg.code()] = index;
   frame_registers_.Use(reg);
   cgen_->allocator()->Use(reg);
 }
 
 
 void VirtualFrame::Unuse(Register reg) {
+  ASSERT(frame_registers_.count(reg) == 1);
+  ASSERT(register_locations_[reg.code()] != kIllegalIndex);
+  register_locations_[reg.code()] = kIllegalIndex;
   frame_registers_.Unuse(reg);
   cgen_->allocator()->Unuse(reg);
 }
 
 
 void VirtualFrame::Spill(Register target) {
   if (!frame_registers_.is_used(target)) return;
   for (int i = 0; i < elements_.length(); i++) {
     if (elements_[i].is_register() && elements_[i].reg().is(target)) {
       SpillElementAt(i);
@@ skipping 87 matching lines @@
       // 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 {
           frame_registers_.Unuse(source.reg());
+          register_locations_[source.reg().code()] = 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();
@@ skipping 92 matching lines @@
     return;
   }
 
   InvalidateFrameSlotAt(frame_index);
 
   FrameElement new_element;
   if (value->is_register()) {
     // There are two cases depending no whether the register already
     // occurs in the frame or not.
     if (register_count(value->reg()) == 0) {
-      Use(value->reg());
+      Use(value->reg(), frame_index);
       elements_[frame_index] =
           FrameElement::RegisterElement(value->reg(),
                                         FrameElement::NOT_SYNCED);
     } else {
       int i = 0;
       for (; i < elements_.length(); i++) {
         if (elements_[i].is_register() && elements_[i].reg().is(value->reg())) {
           break;
         }
       }
       ASSERT(i < elements_.length());
 
       if (i < frame_index) {
         // The register backing store is lower in the frame than its 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++) {
           if (elements_[j].is_copy() && elements_[j].index() == i) {
             elements_[j].set_index(frame_index);
           }
         }
       }
     }
   } else {
     ASSERT(value->is_constant());
     elements_[frame_index] =
@@ skipping 59 matching lines @@
       break;
   }
   PrepareForCall(spilled_args, dropped_args);
   return RawCallCodeObject(code, rmode);
 }
 
 
 void VirtualFrame::Push(Register reg) {
   FrameElement new_element;
   if (register_count(reg) == 0) {
-    Use(reg);
+    Use(reg, elements_.length());
     new_element =
         FrameElement::RegisterElement(reg, FrameElement::NOT_SYNCED);
   } else {
     for (int i = 0; i < elements_.length(); i++) {
       FrameElement element = elements_[i];
       if (element.is_register() && element.reg().is(reg)) {
         new_element = CopyElementAt(i);
         break;
       }
     }
@@ skipping 52 matching lines @@
   if (cgen_ != other->cgen_) return false;
   if (masm_ != other->masm_) return false;
   if (parameter_count_ != other->parameter_count_) return false;
   if (local_count_ != other->local_count_) return false;
   if (frame_pointer_ != other->frame_pointer_) return false;
 
   for (int i = 0; i < kNumRegisters; i++) {
     if (frame_registers_.count(i) != other->frame_registers_.count(i)) {
       return false;
     }
+    if (register_locations_[i] != other->register_locations_[i]) {
+      return false;
+    }
   }
   if (elements_.length() != other->elements_.length()) return false;
 #endif
   if (stack_pointer_ != other->stack_pointer_) return false;
   for (int i = 0; i < elements_.length(); i++) {
     if (!elements_[i].Equals(other->elements_[i])) return false;
   }
 
   return true;
 }
 
 } }  // namespace v8::internal