Add a copied flag to virtual frame elements that tells if a copy has...

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 153 matching lines @@
   if (stack_pointer_ < expected->stack_pointer_) {
     int difference = expected->stack_pointer_ - stack_pointer_;
     stack_pointer_ = expected->stack_pointer_;
     __ sub(Operand(esp), Immediate(difference * kPointerSize));
   }
 
   MergeMoveRegistersToMemory(expected);
   MergeMoveRegistersToRegisters(expected);
   MergeMoveMemoryToRegisters(expected);
 
-  // Fix any sync bit problems from the bottom-up, stopping when we
-  // hit the stack pointer or the top of the frame if the stack
-  // pointer is floating above the frame.
-  int limit = Min(stack_pointer_, elements_.length() - 1);
-  for (int i = 0; i <= limit; i++) {
+  // Fix any sync flag problems from the bottom-up and make the copied
+  // flags exact.  This assumes that the backing store of copies is
+  // always lower in the frame.
+  for (int i = 0; i < elements_.length(); i++) {
     FrameElement source = elements_[i];
     FrameElement target = expected->elements_[i];
     if (source.is_synced() && !target.is_synced()) {
       elements_[i].clear_sync();
     } else if (!source.is_synced() && target.is_synced()) {
       SyncElementAt(i);
     }
+    elements_[i].clear_copied();
+    if (elements_[i].is_copy()) {
+      elements_[elements_[i].index()].set_copied();
+    }
   }
 
   // Adjust the stack point downard if necessary.
   if (stack_pointer_ > expected->stack_pointer_) {
     int difference = stack_pointer_ - expected->stack_pointer_;
     stack_pointer_ = expected->stack_pointer_;
     __ add(Operand(esp), Immediate(difference * kPointerSize));
   }
 
   // At this point, the frames should be identical.
@@ skipping 347 matching lines @@
           copy.clear_sync();
         }
         elements_[j] = copy;
       }
     }
 
     copy.clear_sync();
     return copy;
   }
 
+  elements_[index].clear_copied();
   return FrameElement::InvalidElement();
 }
 
 
 void VirtualFrame::TakeFrameSlotAt(int index) {
   ASSERT(index >= 0);
   ASSERT(index <= elements_.length());
   FrameElement original = elements_[index];
 
   switch (original.type()) {
     case FrameElement::INVALID:
       UNREACHABLE();
       break;
 
     case FrameElement::MEMORY: {
       // Allocate the element to a register.  If it is not copied,
       // push that register on top of the frame.  If it is copied,
       // make the first copy the backing store and push a fresh copy
       // on top of the frame.
-      FrameElement copy = AdjustCopies(index);
+      FrameElement copy = original.is_copied()
+                          ? AdjustCopies(index)
+                          : FrameElement::InvalidElement();
       if (copy.is_valid()) {
         // The original element was a copy.  Push the copy of the new
         // backing store.
         elements_.Add(copy);
       } else {
         // The element was not a copy.  Move it to a register and push
         // that.
         Result fresh = cgen_->allocator()->Allocate();
         ASSERT(fresh.is_valid());
         FrameElement new_element =
             FrameElement::RegisterElement(fresh.reg(),
                                           FrameElement::NOT_SYNCED);
         Use(fresh.reg());
         elements_.Add(new_element);
         __ mov(fresh.reg(), Operand(ebp, fp_relative(index)));
       }
       break;
     }
 
     case FrameElement::REGISTER: {
       // If the element is not copied, push it on top of the frame.
       // If it is copied, make the first copy be the new backing store
       // and push a fresh copy on top of the frame.
-      FrameElement copy = AdjustCopies(index);
+      FrameElement copy = original.is_copied()
+                          ? AdjustCopies(index)
+                          : FrameElement::InvalidElement();
       if (copy.is_valid()) {
         // The original element was a copy.  Push the copy of the new
         // backing store.
         elements_.Add(copy);
         // This is the only case where we have to unuse the original
         // register.  The original is still counted and so is the new
         // backing store of the copies.
         Unuse(original.reg());
       } else {
         // The element was not a copy.  Push it.
@@ skipping 20 matching lines @@
 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());
 
   FrameElement original = elements_[index];
   // If the stored-to slot may be copied, adjust to preserve the
   // copy-on-write semantics of copied elements.
-  if (original.is_register() || original.is_memory()) {
+  if (original.is_copied() &&
+      (original.is_register() || original.is_memory())) {
     FrameElement ignored = AdjustCopies(index);
   }
 
   // If the stored-to slot is a register reference, deallocate it.
   if (original.is_register()) {
     Unuse(original.reg());
   }
 
   int top_index = elements_.length() - 1;
   FrameElement top = elements_[top_index];
@@ skipping 338 matching lines @@
   ASSERT(stack_pointer_ == elements_.length() - 1);
   elements_.Add(FrameElement::MemoryElement());
   stack_pointer_++;
   __ push(immediate);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal