Fix a failure to correctly set the static type on a frame element at a...

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 296 matching lines @@
   // 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;
-  // A "singleton" memory element.
-  FrameElement memory_element = FrameElement::MemoryElement();
   // 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--) {
     FrameElement target = expected->elements_[i];
     if (target.is_memory()) {
       FrameElement source = elements_[i];
       switch (source.type()) {
         case FrameElement::INVALID:
           // Not a legal merge move.
@@ skipping 34 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] = memory_element;
+      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.
   ASSERT(stack_pointer_ >= expected->stack_pointer_);
 
   for (int i = 0; i < kNumRegisters; i++) {
     // Move the right value into register i if it is currently in a register.
     int index = expected->register_locations_[i];
     int use_index = register_locations_[i];
-    // Fast check if register is unused in target or already correct
-    if (index != kIllegalIndex
-        && index != use_index
-        && elements_[index].is_register()) {
-      Register source = elements_[index].reg();
-      Register target = { i };
+    // Skip if register i is unused in the target or else if source is
+    // not a register (this is not a register-to-register move).
+    if (index == kIllegalIndex || !elements_[index].is_register()) continue;
+
+    Register target = { i };
+    Register source = elements_[index].reg();
+
+    if (index != use_index) {
       if (use_index == kIllegalIndex) {  // Target is currently unused.
         // Copy contents of source from source to target.
         // Set frame element register to target.
-        elements_[index].set_reg(target);
         Use(target, index);
         Unuse(source);
         __ mov(target, source);
       } else {
         // Exchange contents of registers source and target.
+        // Nothing except the register backing use_index has changed.
         elements_[use_index].set_reg(source);
-        elements_[index].set_reg(target);
         register_locations_[target.code()] = index;
         register_locations_[source.code()] = use_index;
         __ xchg(source, target);
       }
     }
+
+    if (!elements_[index].is_synced() &&
+        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
   // elements of copies are in their correct locations when we
   // encounter the copies.
   for (int i = 0; i < kNumRegisters; i++) {
@@ skipping 698 matching lines @@
   ASSERT(stack_pointer_ == elements_.length() - 1);
   elements_.Add(FrameElement::MemoryElement());
   stack_pointer_++;
   __ push(immediate);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal