Remove spilled code from SetValue and GetValue

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 244 matching lines @@
   // Random-access store to a frame-top relative frame element.  The result
   // becomes owned by the frame and is invalidated.
   void SetElementAt(int index, Result* value);
 
   // Set a frame element to a constant.  The index is frame-top relative.
   void SetElementAt(int index, Handle<Object> value) {
     Result temp(value, cgen_);
     SetElementAt(index, &temp);
   }
 
+  void PushElementAt(int index) {
+    LoadFrameSlotAt(elements_.length() - index - 1);
+  }
+
   // A frame-allocated local as an assembly operand.
   Operand LocalAt(int index) const {
     ASSERT(0 <= index);
     ASSERT(index < local_count_);
     return Operand(ebp, kLocal0Offset - index * kPointerSize);
   }
 
   // Push a copy of the value of a local frame slot on top of the frame.
   void LoadLocalAt(int index) {
     LoadFrameSlotAt(local0_index() + index);
@@ skipping 72 matching lines @@
   // removed from) the top of the physical frame.
   Result CallRuntime(Runtime::Function* f, int frame_arg_count);
   Result CallRuntime(Runtime::FunctionId id, int frame_arg_count);
 
   // Invoke a builtin, given the number of arguments it expects on (and
   // removes from) the top of the physical frame.
   Result InvokeBuiltin(Builtins::JavaScript id,
                        InvokeFlag flag,
                        int frame_arg_count);
 
-  // Call into a JS code object, given the number of arguments it expects on
-  // (and removes from) the top of the physical frame.
+  // Call into a JS code object, given the number of arguments it
+  // removes from the top of the physical frame.
+  // Register arguments are passed as results and consumed by the call.
   Result CallCodeObject(Handle<Code> ic,
                         RelocInfo::Mode rmode,
-                        int frame_arg_count);
+                        int dropped_args);
+  Result CallCodeObject(Handle<Code> ic,
+                        RelocInfo::Mode rmode,
+                        Result* arg,
+                        int dropped_args);
+  Result CallCodeObject(Handle<Code> ic,
+                        RelocInfo::Mode rmode,
+                        Result* arg0,
+                        Result* arg1,
+                        int dropped_args);
+
+
 
   // Drop a number of elements from the top of the expression stack.  May
   // emit code to affect the physical frame.  Does not clobber any registers
   // excepting possibly the stack pointer.
   void Drop(int count);
 
   // Drop one element.
   void Drop() { Drop(1); }
 
   // Duplicate the top element of the frame.
@@ skipping 131 matching lines @@
   void LoadFrameSlotAt(int index);
 
   // Push a the value of a frame slot (typically a local or parameter) on
   // top of the frame and invalidate the slot.
   void TakeFrameSlotAt(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);
+  // Spill all elements in registers. Spill the top spilled_args elements
+  // on the frame.  Sync all other frame elements.
+  // Then drop dropped_args elements from the virtual frame, to match
+  // the effect of an upcoming call that will drop them from the stack.
+  void PrepareForCall(int spilled_args, int dropped_args);
 
   // 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);
+
+  // Calls a code object which takes spilled_args frame arguments
+  // and which drops dropped_args of them.
+  Result RawCallCodeObject(Handle<Code> code,
+                           RelocInfo::Mode rmode,
+                           int spilled_args,
+                           int dropped_args);
 };
 
-
 } }  // namespace v8::internal
 
 #endif  // V8_VIRTUAL_FRAME_IA32_H_