Change VirtualFrame::AdjustCopies to mark target as invalid.

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 480 matching lines @@
 
 
 void VirtualFrame::PushReceiverSlotAddress() {
   Result temp = cgen_->allocator()->Allocate();
   ASSERT(temp.is_valid());
   __ lea(temp.reg(), ParameterAt(-1));
   Push(&temp);
 }
 
 
-// Before changing an element which is copied, adjust so that the
-// first copy becomes the new backing store and all the other copies
-// are updated.  If the original was in memory, the new backing store
-// is allocated to a register.  Return a copy of the new backing store
-// or an invalid element if the original was not a copy.
-FrameElement VirtualFrame::AdjustCopies(int index) {
+int VirtualFrame::InvalidateFrameSlotAt(int index) {
   FrameElement original = elements_[index];
-  ASSERT(original.is_memory() || original.is_register());
 
-  // Go looking for a first copy above index.
-  int i = index + 1;
-  while (i < elements_.length()) {
-    FrameElement elt = elements_[i];
-    if (elt.is_copy() && elt.index() == index) break;
-    i++;
+  // 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++) {
+      if (elements_[i].is_copy() && elements_[i].index() == index) {
+        new_backing_index = i;
+        break;
+      }
+    }
   }
 
-  if (i < elements_.length()) {
-    // There was a first copy.  Make it the new backing element.
-    Register backing_reg;
-    if (original.is_memory()) {
-      Result fresh = cgen_->allocator()->Allocate();
-      ASSERT(fresh.is_valid());
-      backing_reg = fresh.reg();
-      __ mov(backing_reg, Operand(ebp, fp_relative(index)));
-    } else {
-      // The original was in a register.
-      backing_reg = original.reg();
+  if (new_backing_index == kIllegalIndex) {
+    // No copies found, return kIllegalIndex.
+    if (original.is_register()) {
+      Unuse(original.reg());
     }
-    FrameElement new_backing_element =
-        FrameElement::RegisterElement(backing_reg, FrameElement::NOT_SYNCED);
-    if (elements_[i].is_synced()) {
-      new_backing_element.set_sync();
-    }
-    Use(backing_reg);
-    elements_[i] = new_backing_element;
-
-    // Update the other copies.
-    FrameElement copy = CopyElementAt(i);
-    for (int j = i; j < elements_.length(); j++) {
-      FrameElement elt = elements_[j];
-      if (elt.is_copy() && elt.index() == index) {
-        if (elt.is_synced()) {
-          copy.set_sync();
-        } else {
-          copy.clear_sync();
-        }
-        elements_[j] = copy;
-      }
-    }
-
-    copy.clear_sync();
-    return copy;
+    elements_[index] = FrameElement::InvalidElement();
+    return kIllegalIndex;
   }
 
-  elements_[index].clear_copied();
-  return FrameElement::InvalidElement();
+  // 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());
+    backing_reg = fresh.reg();
+    __ mov(backing_reg, Operand(ebp, fp_relative(index)));
+  } else {
+    // The original was in a register.
+    backing_reg = original.reg();
+  }
+  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++) {
+    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());
   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::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 = 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)));
-      }
+      // 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_.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 = 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.
-        original.clear_sync();
-        elements_.Add(original);
-      }
-      break;
-    }
-
+    case FrameElement::REGISTER:
+      Use(original.reg());
+      // Fall through.
     case FrameElement::CONSTANT:
-      original.clear_sync();
-      elements_.Add(original);
-      break;
-
     case FrameElement::COPY:
       original.clear_sync();
       elements_.Add(original);
       break;
+    case FrameElement::INVALID:
+      UNREACHABLE();
+      break;
   }
-  elements_[index] = FrameElement::InvalidElement();
 }
 
 
 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_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];
+  FrameElement original = elements_[index];
+  if (top.is_copy() && top.index() == index) return;
   ASSERT(top.is_valid());
 
+  InvalidateFrameSlotAt(index);
+
   if (top.is_copy()) {
     // There are two cases based on the relative positions of the
     // stored-to slot and the backing slot of the top element.
     int backing_index = top.index();
     ASSERT(backing_index != index);
     if (backing_index < index) {
       // 1. The top element is a copy of a slot below the stored-to
       // slot.  The stored-to slot becomes an unsynced copy of that
       // same backing slot.
       elements_[index] = CopyElementAt(backing_index);
@@ skipping 31 matching lines @@
       // 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++) {
-        FrameElement current = elements_[i];
-        if (current.is_copy() && current.index() == backing_index) {
-          elements_[i] = new_element;
-          if (current.is_synced()) {
-            elements_[i].set_sync();
-          }
+        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.
@@ skipping 265 matching lines @@
   ASSERT(stack_pointer_ == elements_.length() - 1);
   elements_.Add(FrameElement::MemoryElement());
   stack_pointer_++;
   __ push(immediate);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal