Enable register allocation for return statements. Make sure to...

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 219 matching lines @@
   // binding a label.
   void AttachToCodeGenerator();
 
   // 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.
   void Enter();
   void Exit();
 
+  // Prepare for returning from the frame by spilling locals and
+  // forgetting about all non-locals elements in the virtual frame.
+  // This avoid generating unnecessary merge code when jumping to the

[Kevin Millikin (Chromium), 2009/01/07 10:25:12]

avoids

+  // shared return site.  Emits code for spills.
+  void PrepareForReturn();
+
   // Allocate and initialize the frame-allocated locals.  The eax register
   // us clobbered.
   void AllocateStackSlots(int count);
 
   // The current top of the expression stack as an assembly operand.
   Operand Top() const { return Operand(esp, 0); }
 
   // An element of the expression stack as an assembly operand.
   Operand ElementAt(int index) const {
     return Operand(esp, index * kPointerSize);
@@ skipping 238 matching lines @@
   // 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);
+  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);
+  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);
+  void MergeMoveMemoryToRegisters(VirtualFrame* expected);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_VIRTUAL_FRAME_IA32_H_