Initial real implementation of simple merge for frames. Does not yet...

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 133 matching lines @@
   // the frame after a runtime call).  No code is emitted.
   void Forget(int count);
 
   // Spill all values from the frame to memory.
   void SpillAll();
 
   // Spill a register if possible.  Return the register spilled or no_reg if
   // it was not possible to spill one.
   Register SpillAnyRegister();
 
+  // True if an arbitrary frame of the same size could be merged to this
+  // one.  Requires all values to be in a unique register or memory
+  // location.
+  bool IsMergable();
+
   // Ensure that this frame is in a state where an arbitrary frame of the
   // right size could be merged to it.  May emit code.
-  void EnsureMergable();
+  void MakeMergable();
 
   // Make this virtual frame have a state identical to an expected virtual
   // frame.  As a side effect, code may be emitted to make this frame match
   // the expected one.
   void MergeTo(VirtualFrame* expected);
 
   // Emit code for the physical JS entry and exit frame sequences.  After
   // calling Enter, the virtual frame is ready for use; and after calling
   // Exit it should not be used.  Note that Enter does not allocate space in
   // the physical frame for storing frame-allocated locals.
@@ skipping 176 matching lines @@
   // 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.  Space should have already been allocated in the actual frame
   // for all the elements below this one (at least).
   void SpillElementAt(int index);
 
-  // Sync all elements in the frame.
-  void SyncAll();
+  // Sync the range of elements in [begin, end).
+  void SyncRange(int begin, int end);
 
   // 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);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_VIRTUAL_FRAME_IA32_H_