Begin counting references to registers, both in the frame and out....

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 11 matching lines @@
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef V8_VIRTUAL_FRAME_IA32_H_
 #define V8_VIRTUAL_FRAME_IA32_H_
 
 #include "macro-assembler.h"
+#include "register-allocator.h"
 
 namespace v8 { namespace internal {
 
 // -------------------------------------------------------------------------
 // Virtual frame elements
 //
-// The internal elements of the virtual frames.  Elements are (currently) of
-// only one kind, in-memory.  Their actual location is given by their
-// position in the virtual frame.
+// The internal elements of the virtual frames.  There are several kinds of
+// elements:
+//   * Memory: an element that resides in the actual frame.  Its address is
+//     given by its position in the virtual frame.
+//   * Register: an element that resides in a register.
+//   * Constant: an element whose value is known at compile time.
 
 class FrameElement BASE_EMBEDDED {
  public:
+  enum SyncFlag { SYNCED, NOT_SYNCED };
+
+  // Construct an in-memory frame element.
   FrameElement() {
-    type_ = TypeField::encode(MEMORY) | DirtyField::encode(false);
-    // Memory elements have no useful data.
+    type_ = TypeField::encode(MEMORY) | SyncField::encode(SYNCED);
+    // In-memory elements have no useful data.
     data_.reg_ = no_reg;
   }
 
-  explicit FrameElement(Register reg) {
-    type_ = TypeField::encode(REGISTER) | DirtyField::encode(true);
+  // Construct an in-register frame element.
+  FrameElement(Register reg, SyncFlag is_synced) {
+    type_ = TypeField::encode(REGISTER) | SyncField::encode(is_synced);
     data_.reg_ = reg;
   }
 
-  explicit FrameElement(Handle<Object> value) {
-    type_ = TypeField::encode(CONSTANT) | DirtyField::encode(true);
+  // Construct a frame element whose value is known at compile time.
+  FrameElement(Handle<Object> value, SyncFlag is_synced) {
+    type_ = TypeField::encode(CONSTANT) | SyncField::encode(is_synced);
     data_.handle_ = value.location();
   }
 
-  bool is_dirty() const { return DirtyField::decode(type_); }
+  bool is_synced() const { return SyncField::decode(type_) == SYNCED; }
 
-  void set_dirty() {
+  void set_sync() {
     ASSERT(type() != MEMORY);
-    type_ = type_ | DirtyField::encode(true);
+    type_ = type_ | SyncField::encode(SYNCED);
   }
 
-  void clear_dirty() {
+  void clear_sync() {
     ASSERT(type() != MEMORY);
-    type_ = type_ & ~DirtyField::mask();
+    type_ = type_ & ~SyncField::mask();
   }
 
   bool is_register() const { return type() == REGISTER; }
   bool is_constant() const { return type() == CONSTANT; }
 
   Register reg() const {
     ASSERT(type() == REGISTER);
     return data_.reg_;
   }
 
   Handle<Object> handle() const {
     ASSERT(type() == CONSTANT);
     return Handle<Object>(data_.handle_);
   }
 
  private:
   enum Type { MEMORY, REGISTER, CONSTANT };
 
   // BitField is <type, shift, size>.
-  class DirtyField : public BitField<bool, 0, 1> {};
+  class SyncField : public BitField<SyncFlag, 0, 1> {};
   class TypeField : public BitField<Type, 1, 32 - 1> {};
 
   Type type() const { return TypeField::decode(type_); }
 
   // The element's type and a dirty bit.  The dirty bit can be cleared
   // for non-memory elements to indicate that the element agrees with
   // the value in memory in the actual frame.
   int type_;
 
   union {
@@ skipping 30 matching lines @@
   // 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.
+  Register SpillAnyRegister();
+
   // 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 EnsureMergable();
 
   // 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);
 
   // Emit code for the physical JS entry and exit frame sequences.  After
@@ skipping 74 matching lines @@
   // corresponding pop instruction.
   void EmitPop(Register reg);
   void EmitPop(Operand operand);
 
   // Push an element on top of the expression stack and emit a corresponding
   // push instruction.
   void EmitPush(Register reg);
   void EmitPush(Operand operand);
   void EmitPush(Immediate immediate);
 
+  // Push an element on the virtual frame.
+  void Push(Register reg);
+  void Push(Handle<Object> value);
+
  private:
   // An illegal index into the virtual frame.
   static const int kIllegalIndex = -1;
 
   static const int kLocal0Offset = JavaScriptFrameConstants::kLocal0Offset;
   static const int kFunctionOffset = JavaScriptFrameConstants::kFunctionOffset;
   static const int kContextOffset = StandardFrameConstants::kContextOffset;
 
   static const int kHandlerSize = StackHandlerConstants::kSize / kPointerSize;
 
+  CodeGenerator* cgen_;
   MacroAssembler* masm_;
 
   List<FrameElement> elements_;
 
   int parameter_count_;
   int local_count_;
 
   // The index of the element that is at the processor's stack pointer
   // (the esp register).
   int stack_pointer_;
 
   // The index of the element that is at the processor's frame pointer
   // (the ebp register).
   int frame_pointer_;
 
+  // The frame has an embedded register file that it uses to track registers
+  // used in the frame.
+  RegisterFile frame_registers_;
+
   // The index of the first parameter.  The receiver lies below the first
   // parameter.
   int param0_index() const { return 1; }
 
+  // The index of the context slot in the frame.
+  int context_index() const {
+    ASSERT(frame_pointer_ != kIllegalIndex);
+    return frame_pointer_ + 1;
+  }
+
+  // The index of the function slot in the frame.  It lies above the context
+  // slot.
+  int function_index() const {
+    ASSERT(frame_pointer_ != kIllegalIndex);
+    return frame_pointer_ + 2;
+  }
+
   // The index of the first local.  Between the parameters and the locals
   // lie the return address, the saved frame pointer, the context, and the
   // function.
-  int local0_index() const { return param0_index() + parameter_count_ + 4; }
+  int local0_index() const {
+    ASSERT(frame_pointer_ != kIllegalIndex);
+    return frame_pointer_ + 3;
+  }
 
   // The index of the base of the expression stack.
   int expression_base_index() const { return local0_index() + local_count_; }
 
   // Convert a frame index into a frame pointer relative offset into the
   // actual stack.
   int fp_relative(int index) const {
     return (frame_pointer_ - index) * kPointerSize;
   }
 
+  // Record an occurrence of a register in the virtual frame.  This has the
+  // effect of incrementing both the register's frame-internal reference
+  // count and its external reference count.
+  void Use(Register reg);
+
+  // Record that a register reference has been dropped from the frame.  This
+  // decrements both the register's internal and external reference counts.
+  void Unuse(Register reg);
+
   // Sync the element at a particular index---write it to memory if
   // necessary, but do not free any associated register or forget its value
   // if constant.  Space should have already been allocated in the actual
   // frame for all the elements below this one (at least).
   void SyncElementAt(int index);
 
   // Spill the element at a particular index---write it to memory if
   // necessary, free any associated register, and forget its value if
   // constant.  Space should have already been allocated in the actual frame
   // for all the elements below this one (at least).
   void SpillElementAt(int index);
 
+  // Sync all elements in the frame.
+  void SyncAll();
+
   // Spill the topmost elements of the frame to memory (eg, they are the
   // arguments to a call) and all registers.
   void PrepareForCall(int count);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_VIRTUAL_FRAME_IA32_H_