Experimental: the code to make a frame mergable is sometimes emitted...

src/virtual-frame-ia32.cc

 // 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 178 matching lines @@
 // The element must be on the physical stack, or the first
 // element below the stack pointer (created by a single push).
 void VirtualFrame::RawSyncElementAt(int index) {
   FrameElement element = elements_[index];
 
   if (!element.is_synced()) {
     if (index <= stack_pointer_) {
       // Write elements below the stack pointer to their (already allocated)
       // actual frame location.
       if (element.is_constant()) {
-        __ Set(Operand(ebp, fp_relative(index)), Immediate(element.handle()));
+        __ mov(Operand(ebp, fp_relative(index)), Immediate(element.handle()));
       } else {
         ASSERT(element.is_register());
         __ mov(Operand(ebp, fp_relative(index)), element.reg());
       }
     } else {
       // Push elements above the stack pointer to allocate space and sync
       // them.  Space should have already been allocated in the actual frame
       // for all the elements below this one.
       ASSERT(index == stack_pointer_ + 1);
       stack_pointer_++;
@@ skipping 148 matching lines @@
     }
   }
 
   // Perform the moves.
   for (int i = 0; i < elements_.length(); i++) {
     FrameElement source = elements_[i];
     FrameElement target = new_elements[i];
     ASSERT(!target.is_valid() || target.is_register() || target.is_memory());
     if (target.is_register()) {
       if (source.is_constant()) {
-        __ Set(target.reg(), Immediate(source.handle()));
+        __ mov(target.reg(), Immediate(source.handle()));
       } else if (source.is_register() && !source.reg().is(target.reg())) {
         __ mov(target.reg(), source.reg());
       }
       elements_[i] = target;
     } else if (target.is_memory()) {
       if (!source.is_memory()) {
         // Spilling a source register would decrement its reference count,
         // but we have already done that when computing new target elements,
         // so we use a raw spill.
         RawSpillElementAt(i);
@@ skipping 583 matching lines @@
       return false;
     }
   }
   return true;
 }
 #endif
 
 #undef __
 
 } }  // namespace v8::internal