Remove code that adjusts synced and copied flags in MergeTo.

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 169 matching lines @@
 }
 
 
 void VirtualFrame::MakeMergable(int mergable_elements) {
   if (mergable_elements == JumpTarget::kAllElements) {
     mergable_elements = elements_.length();
   }
   ASSERT(mergable_elements <= elements_.length());
 
   int start_index = elements_.length() - mergable_elements;
-
-  // The is_copied flags on entry frame elements are expected to be
-  // exact.  Set them for the elements below the water mark.
-  for (int i = 0; i < start_index; i++) {
-    elements_[i].clear_copied();
-    if (elements_[i].is_copy()) {
-      elements_[elements_[i].index()].set_copied();
-    }
-  }
-
   for (int i = start_index; i < elements_.length(); 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.
@@ skipping 55 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 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 pointer downward 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.
   ASSERT(Equals(expected));
 }
 
 
 void VirtualFrame::MergeMoveRegistersToMemory(VirtualFrame* expected) {
   ASSERT(stack_pointer_ >= expected->stack_pointer_);
 
   // 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;
-  // Loop downward from the stack pointer or the top of the frame if
-  // the stack pointer is floating above the frame.
-  int start = Min(static_cast<int>(stack_pointer_), elements_.length() - 1);
-  for (int i = start; i >= 0; i--) {
+  for (int i = elements_.length() - 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;
 
         case FrameElement::MEMORY:
           // Already in place.
@@ skipping 29 matching lines @@
                 __ mov(esi, Operand(ebp, fp_relative(backing_index)));
               }
               __ mov(Operand(ebp, fp_relative(i)), esi);
             } else {
               ASSERT(backing_element.is_register());
               __ mov(Operand(ebp, fp_relative(i)), backing_element.reg());
             }
           }
           break;
       }
-      elements_[i] = target;
     }
+    elements_[i] = target;
   }
 
   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.
@@ skipping 31 matching lines @@
         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 is done from the bottom up so that the backing
+  // 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];
     if (index != kIllegalIndex) {
       FrameElement source = elements_[index];
       FrameElement target = expected->elements_[index];
       Register target_reg = { i };
-      ASSERT(expected->elements_[index].reg().is(target_reg));
+      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.
           break;
         case FrameElement::MEMORY:
           ASSERT(index <= stack_pointer_);
@@ skipping 682 matching lines @@
   ASSERT(stack_pointer_ == elements_.length() - 1);
   elements_.Add(FrameElement::MemoryElement());
   stack_pointer_++;
   __ push(immediate);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal