Experimental: this is a substantial change to allow the virtual frame...

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 157 matching lines @@
   explicit VirtualFrame(CodeGenerator* cgen);
 
   // Construct a virtual frame as a clone of an existing one.
   explicit VirtualFrame(VirtualFrame* original);
 
   // The height of the virtual expression stack.
   int height() const {
     return elements_.length() - expression_base_index();
   }
 
+  int register_count(Register reg) {
+    return frame_registers_.count(reg);
+  }
+
   // Add extra in-memory elements to the top of the frame to match an actual
   // frame (eg, the frame after an exception handler is pushed).  No code is
   // emitted.
   void Adjust(int count);
 
   // Forget elements from the top of the frame to match an actual frame (eg,
   // 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.
+  // Spill all occurrences of a specific register from the frame.
+  void Spill(Register reg);
+
+  // Spill all occurrences of an arbitrary register if possible.  Return the
+  // register spilled or no_reg if it was not possible to free any register
+  // (ie, they all have frame-external references).
   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();
-
   // True if making the frame mergable via MakeMergable will generate code.
-  // This differs from !IsMergable() because there are some non-mergable
-  // frames that can be made mergable simply by changing internal state (eg,
-  // forgetting about constants that are synced to memory) without
-  // generating code.
   bool RequiresMergeCode();
 
   // 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 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);
@@ skipping 73 matching lines @@
 
   // The receiver frame slot.
   Operand Receiver() const { return ParameterAt(-1); }
 
   // Push a try-catch or try-finally handler on top of the virtual frame.
   void PushTryHandler(HandlerType type);
 
   // Call a code stub, given the number of arguments it expects on (and
   // removes from) the top of the physical frame.
   void CallStub(CodeStub* stub, int frame_arg_count);
+  Result CallStub(CodeStub* stub,
+                  Result* arg0,
+                  Result* arg1,
+                  int frame_arg_count);
 
   // Call the runtime, given the number of arguments expected on (and
   // removed from) the top of the physical frame.
   void CallRuntime(Runtime::Function* f, int frame_arg_count);
   void 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.
   void InvokeBuiltin(Builtins::JavaScript id,
                      InvokeFlag flag,
@@ skipping 164 matching lines @@
   // 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);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_VIRTUAL_FRAME_IA32_H_