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

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 576 matching lines @@
   Comment cmnt(masm_, "[ Enter JS frame");
   EmitPush(ebp);
 
   frame_pointer_ = stack_pointer_;
   __ mov(ebp, Operand(esp));
 
   // Store the context in the frame.  The context is kept in esi and a
   // copy is stored in the frame.  The external reference to esi
   // remains in addition to the cached copy in the frame.
   Push(esi);
+  SyncElementAt(elements_.length() - 1);
 
-  // Store the function in the frame.  The frame owns the register reference
-  // now (ie, it can keep it in edi or spill it later).
+  // Store the function in the frame.  The frame owns the register
+  // reference now (ie, it can keep it in edi or spill it later).
   Push(edi);
   cgen_->allocator()->Unuse(edi);
+  SpillElementAt(elements_.length() - 1);
 }
 
 
 void VirtualFrame::Exit() {
   Comment cmnt(masm_, "[ Exit JS frame");
   // Record the location of the JS exit code for patching when setting
   // break point.
   __ RecordJSReturn();
 
   // Avoid using the leave instruction here, because it is too
   // short. We need the return sequence to be a least the size of a
   // call instruction to support patching the exit code in the
   // debugger. See VisitReturnStatement for the full return sequence.
   __ mov(esp, Operand(ebp));
   stack_pointer_ = frame_pointer_;
   for (int i = elements_.length() - 1; i > stack_pointer_; i--) {
     FrameElement last = elements_.RemoveLast();
     if (last.is_register()) {
       Unuse(last.reg());
     }
   }
 
   frame_pointer_ = kIllegalIndex;
   EmitPop(ebp);
 }
 
 
+void VirtualFrame::PrepareForReturn() {
+  // Spill all locals. This is necessary to make sure all locals have
+  // the right value when breaking at the return site in the debugger.
+  for (int i = 0; i < expression_base_index(); i++) SpillElementAt(i);
+
+  // Forget all about non-local stack elements.
+  Forget(height());

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

As discussed offline, Forget as it currently stands probably isn't the right
thing here.  It assumes that it is forgetting things below the actual stack
pointer, and it doesn't adjust the stack pointer itself but assumes someone else
has or will.

+
+  // Validate state: The expression stack should be empty and the
+  // stack pointer should have been updated to reflect this.
+  ASSERT(height() == 0);
+  ASSERT(stack_pointer_ == expression_base_index() - 1);
+}
+
+
 void VirtualFrame::AllocateStackSlots(int count) {
   ASSERT(height() == 0);
   local_count_ = count;
 
   if (count > 0) {
     Comment cmnt(masm_, "[ Allocate space for locals");
     // The locals are initialized to a constant (the undefined value), but
     // we sync them with the actual frame to allocate space for spilling
     // them later.  First sync everything above the stack pointer so we can
     // use pushes to allocate and initialize the locals.
@@ skipping 358 matching lines @@
       return false;
     }
   }
   return true;
 }
 #endif
 
 #undef __
 
 } }  // namespace v8::internal