X64 implementation: Emit correct merge code for virtual frames at CFG merges.

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 171 matching lines @@
       if (element.is_synced()) {
         // Just spill.
         elements_[i] = FrameElement::MemoryElement();
       } else {
         // Allocate to a register.
         FrameElement backing_element;  // Invalid if not a copy.
         if (element.is_copy()) {
           backing_element = elements_[element.index()];
         }
         Result fresh = cgen()->allocator()->Allocate();
-        ASSERT(fresh.is_valid());
+        ASSERT(fresh.is_valid());  // A register was spilled if all were in use.
         elements_[i] =
             FrameElement::RegisterElement(fresh.reg(),
                                           FrameElement::NOT_SYNCED);
         Use(fresh.reg(), i);
 
         // Emit a move.
         if (element.is_constant()) {
           if (cgen()->IsUnsafeSmi(element.handle())) {
             cgen()->LoadUnsafeSmi(fresh.reg(), element.handle());
           } else {
             __ Set(fresh.reg(), Immediate(element.handle()));
           }
         } else {
           ASSERT(element.is_copy());
           // Copies are only backed by register or memory locations.
           if (backing_element.is_register()) {
             // The backing store may have been spilled by allocating,
             // but that's OK.  If it was, the value is right where we
             // want it.
             if (!fresh.reg().is(backing_element.reg())) {
               __ mov(fresh.reg(), backing_element.reg());
             }
           } else {
             ASSERT(backing_element.is_memory());
             __ mov(fresh.reg(), Operand(ebp, fp_relative(element.index())));
           }
         }
       }
-      // No need to set the copied flag---there are no copies of
-      // copies or constants so the original was not copied.
+      // No need to set the copied flag---there are no copies.
       elements_[i].set_static_type(element.static_type());
     } else {
-      // Clear the copy flag of non-constant, non-copy elements above
-      // the high water mark.  They cannot be copied because copes are
-      // always higher than their backing store and copies are not
-      // allowed above the water mark.
+      // Clear the copy flag of non-constant, non-copy elements.
+      // They cannot be copied because copies are not allowed.
+      // The copy flag is not relied on before the end of this loop,
+      // including when registers are spilled.
       elements_[i].clear_copied();
     }
   }
 }
 
 
 void VirtualFrame::MergeTo(VirtualFrame* expected) {
   Comment cmnt(masm(), "[ Merge frame");
   // We should always be merging the code generator's current frame to an
   // expected frame.
@@ skipping 840 matching lines @@
   ASSERT(stack_pointer_ == element_count() - 1);
   elements_.Add(FrameElement::MemoryElement());
   stack_pointer_++;
   __ push(immediate);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal