Factor VirtualFrame::MergeTo() into three functions, for...

src/virtual-frame-ia32.h

 // 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 460 matching lines @@
 
   // Record an occurrence of a register in the virtual frame.  This has the
   // effect of incrementing both the register's frame-internal reference
   // count and its external reference count.
   void Use(Register reg);
 
   // Record that a register reference has been dropped from the frame.  This
   // decrements both the register's internal and external reference counts.
   void Unuse(Register reg);
 
-  // Sync the element at a particular index---write it to memory if
-  // necessary, but do not free any associated register or forget its value
-  // if constant.  Space should have already been allocated in the actual
-  // frame for all the elements below this one (at least).
-  void SyncElementAt(int index);
-
   // Spill the element at a particular index---write it to memory if
   // necessary, free any associated register, and forget its value if
   // constant.
   void SpillElementAt(int index);
 
   // Spill the element at an index without modifying its reference count (if
   // it was in a register).
   void RawSpillElementAt(int index);
 
+  // Sync the element at a particular index.  If it is a register or
+  // constant that disagrees with the value on the stack, write it to memory.
+  // Keep the element type as register or constant, and clear the dirty bit.
+  void SyncElementAt(int index);
+
   // Sync the range of elements in [begin, end).
   void SyncRange(int begin, int end);
 
+  // Sync a single element, assuming that its index is less than
+  // or equal to stack pointer + 1.
+  void RawSyncElementAt(int index);
+
   // Push a copy of a frame slot (typically a local or parameter) on top of
   // the frame.
   void LoadFrameSlotAt(int index);
 
   // Store the value on top of the frame to a frame slot (typically a local
   // or parameter).
   void StoreToFrameSlotAt(int index);
 
   // Spill the topmost elements of the frame to memory (eg, they are the
   // arguments to a call) and all registers.
   void PrepareForCall(int count);
 
+  // Move frame elements currently in registers or constants, that
+  // should be in memory in the expected frame, to memory.
+  void MergeMoveRegistersToMemory(VirtualFrame *expected);
+
   // Make the register-to-register moves necessary to
   // merge this frame with the expected frame.
   // Register to memory moves must already have been made,
   // and memory to register moves must follow this call.
   // This is because some new memory-to-register moves are
   // created in order to break cycles of register moves.
   // Used in the implementation of MergeTo().
   void MergeMoveRegistersToRegisters(VirtualFrame *expected);
+
+  // Make the memory-to-register and constant-to-register moves
+  // needed to make this frame equal the expected frame.
+  // Called after all register-to-memory and register-to-register
+  // moves have been made.  After this function returns, the frames
+  // should be equal.
+  void MergeMoveMemoryToRegisters(VirtualFrame *expected);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_VIRTUAL_FRAME_IA32_H_