Change the register allocator so that it no longer tracks references...

src/x64/virtual-frame-x64.h

 // Copyright 2009 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 65 matching lines @@
 
   // Construct a virtual frame as a clone of an existing one.
   explicit VirtualFrame(VirtualFrame* original);
 
   CodeGenerator* cgen() { return CodeGeneratorScope::Current(); }
   MacroAssembler* masm() { return cgen()->masm(); }
 
   // Create a duplicate of an existing valid frame element.
   FrameElement CopyElementAt(int index);
 
+  // The number of elements on the virtual frame.
+  int element_count() { return elements_.length(); }
+
   // The height of the virtual expression stack.
   int height() {
-    return elements_.length() - expression_base_index();
+    return element_count() - expression_base_index();
   }
 
-  int register_index(Register reg) {
-    return register_locations_[reg.code()];
+  int register_location(int num) {
+    ASSERT(num >= 0 && num < RegisterAllocator::kNumRegisters);
+    return register_locations_[num];
   }
 
-  bool is_used(int reg_code) {
-    return register_locations_[reg_code] != kIllegalIndex;
+  int register_location(Register reg) {
+    return register_locations_[RegisterAllocator::ToNumber(reg)];
+  }
+
+  void set_register_location(Register reg, int index) {
+    register_locations_[RegisterAllocator::ToNumber(reg)] = index;
+  }
+
+  bool is_used(int num) {
+    ASSERT(num >= 0 && num < RegisterAllocator::kNumRegisters);
+    return register_locations_[num] != kIllegalIndex;
   }
 
   bool is_used(Register reg) {
-    return is_used(reg.code());
+    return register_locations_[RegisterAllocator::ToNumber(reg)]
+        != kIllegalIndex;
   }
 
   // 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 count elements from the top of the frame all in-memory
   // (including synced) and adjust the stack pointer downward, to
   // match an external frame effect (examples include a call removing
   // its arguments, and exiting a try/catch removing an exception
   // handler).  No code will be emitted.
   void Forget(int count) {
     ASSERT(count >= 0);
-    ASSERT(stack_pointer_ == elements_.length() - 1);
+    ASSERT(stack_pointer_ == element_count() - 1);
     stack_pointer_ -= count;
     ForgetElements(count);
   }
 
   // Forget count elements from the top of the frame without adjusting
   // the stack pointer downward.  This is used, for example, before
   // merging frames at break, continue, and return targets.
   void ForgetElements(int count);
 
   // Spill all values from the frame to memory.
   void SpillAll();
 
   // Spill all occurrences of a specific register from the frame.
   void Spill(Register reg) {
-    if (is_used(reg)) SpillElementAt(register_index(reg));
+    if (is_used(reg)) SpillElementAt(register_location(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();
 
+  // Sync the range of elements in [begin, end] with memory.
+  void SyncRange(int begin, int end);
+
   // Make this frame so that an arbitrary frame of the same height can
   // be merged to it.  Copies and constants are removed from the
   // topmost mergable_elements elements of the frame.  A
   // mergable_elements of JumpTarget::kAllElements indicates constants
   // and copies are should be removed from the entire frame.
   void MakeMergable(int mergable_elements);
 
   // Prepare this virtual frame for merging to an expected frame by
   // performing some state changes that do not require generating
   // code.  It is guaranteed that no code will be generated.
   void PrepareMergeTo(VirtualFrame* expected);
 
   // 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);
 
   // Detach a frame from its code generator, perhaps temporarily.  This
   // tells the register allocator that it is free to use frame-internal
   // registers.  Used when the code generator's frame is switched from this
   // one to NULL by an unconditional jump.
   void DetachFromCodeGenerator() {
     RegisterAllocator* cgen_allocator = cgen()->allocator();
-    for (int i = 0; i < kNumRegisters; i++) {
-      if (is_used(i)) {
-        Register temp = { i };
-        cgen_allocator->Unuse(temp);
-      }
+    for (int i = 0; i < RegisterAllocator::kNumRegisters; i++) {
+      if (is_used(i)) cgen_allocator->Unuse(i);
     }
   }
 
   // (Re)attach a frame to its code generator.  This informs the register
   // allocator that the frame-internal register references are active again.
   // Used when a code generator's frame is switched from NULL to this one by
   // binding a label.
   void AttachToCodeGenerator() {
     RegisterAllocator* cgen_allocator = cgen()->allocator();
-    for (int i = 0; i < kNumRegisters; i++) {
-      if (is_used(i)) {
-        Register temp = { i };
-        cgen_allocator->Use(temp);
-      }
+    for (int i = 0; i < RegisterAllocator::kNumRegisters; i++) {
+      if (is_used(i)) cgen_allocator->Use(i);
     }
   }
 
   // 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();
 
@@ skipping 14 matching lines @@
   // 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);
     SetElementAt(index, &temp);
   }
 
   void PushElementAt(int index) {
-    PushFrameSlotAt(elements_.length() - index - 1);
+    PushFrameSlotAt(element_count() - index - 1);
   }
 
   void StoreToElementAt(int index) {
-    StoreToFrameSlotAt(elements_.length() - index - 1);
+    StoreToFrameSlotAt(element_count() - index - 1);
   }
 
   // A frame-allocated local as an assembly operand.
   Operand LocalAt(int index) {
     ASSERT(0 <= index);
     ASSERT(index < local_count());
     return Operand(rbp, kLocal0Offset - index * kPointerSize);
   }
 
   // Push a copy of the value of a local frame slot on top of the frame.
@@ skipping 116 matching lines @@
 
   // 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.
-  void Dup() { PushFrameSlotAt(elements_.length() - 1); }
+  void Dup() { PushFrameSlotAt(element_count() - 1); }
 
   // Pop an element from the top of the expression stack.  Returns a
   // Result, which may be a constant or a register.
   Result Pop();
 
   // Pop and save an element from the top of the expression stack and
   // emit a corresponding pop instruction.
   void EmitPop(Register reg);
   void EmitPop(Operand operand);
 
@@ skipping 34 matching lines @@
   static const int kPreallocatedElements = 5 + 8;  // 8 expression stack slots.
 
   ZoneList<FrameElement> elements_;
 
   // The index of the element that is at the processor's stack pointer
   // (the esp register).
   int stack_pointer_;
 
   // The index of the register frame element using each register, or
   // kIllegalIndex if a register is not on the frame.
-  int register_locations_[kNumRegisters];
+  int register_locations_[RegisterAllocator::kNumRegisters];
 
   // The number of frame-allocated locals and parameters respectively.
   int parameter_count() { return cgen()->scope()->num_parameters(); }
   int local_count() { return cgen()->scope()->num_stack_slots(); }
 
   // The index of the element that is at the processor's frame pointer
   // (the ebp register).  The parameters, receiver, and return address
   // are below the frame pointer.
   int frame_pointer() { return parameter_count() + 2; }
 
   // The index of the first parameter.  The receiver lies below the first
   // parameter.
-  int param0_index() const { return 1; }
+  int param0_index() { return 1; }
 
   // The index of the context slot in the frame.  It is immediately
   // above the frame pointer.
   int context_index() { return frame_pointer() + 1; }
 
   // The index of the function slot in the frame.  It is above the frame
   // pointer and the context slot.
   int function_index() { return frame_pointer() + 2; }
 
   // The index of the first local.  Between the frame pointer and the
   // locals lie the context and the function.
   int local0_index() { return frame_pointer() + 3; }
 
   // The index of the base of the expression stack.
   int expression_base_index() { return local0_index() + local_count(); }
 
   // Convert a frame index into a frame pointer relative offset into the
   // actual stack.
   int fp_relative(int index) {
-    ASSERT(index < elements_.length());
-    ASSERT(frame_pointer() < elements_.length());  // FP is on the frame.
+    ASSERT(index < element_count());
+    ASSERT(frame_pointer() < element_count());  // FP is on the frame.
     return (frame_pointer() - index) * kPointerSize;
   }
 
   // Record an occurrence of a register in the virtual frame.  This has the
   // effect of incrementing the register's external reference count and
   // of updating the index of the register's location in the frame.
   void Use(Register reg, int index) {
     ASSERT(!is_used(reg));
-    register_locations_[reg.code()] = index;
+    set_register_location(reg, index);
     cgen()->allocator()->Use(reg);
   }
 
   // Record that a register reference has been dropped from the frame.  This
   // decrements the register's external reference count and invalidates the
   // index of the register's location in the frame.
   void Unuse(Register reg) {
-    ASSERT(register_locations_[reg.code()] != kIllegalIndex);
-    register_locations_[reg.code()] = kIllegalIndex;
+    ASSERT(is_used(reg));
+    set_register_location(reg, kIllegalIndex);
     cgen()->allocator()->Unuse(reg);
   }
 
   // Spill the element at a particular index---write it to memory if
   // necessary, free any associated register, and forget its value if
   // constant.
   void SpillElementAt(int index);
 
   // Sync the element at a particular index.  If it is a register or
   // constant that disagrees with the value on the stack, write it to memory.
   // Keep the element type as register or constant, and clear the dirty bit.
   void SyncElementAt(int index);
 
-  // Sync the range of elements in [begin, end).
-  void SyncRange(int begin, int end);
-
   // Sync a single unsynced element that lies beneath or at the stack pointer.
   void SyncElementBelowStackPointer(int index);
 
   // Sync a single unsynced element that lies just above the stack pointer.
   void SyncElementByPushing(int index);
 
   // Push a copy of a frame slot (typically a local or parameter) on top of
   // the frame.
   void PushFrameSlotAt(int index);
 
@@ skipping 48 matching lines @@
 
   bool Equals(VirtualFrame* other);
 
   friend class JumpTarget;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_X64_VIRTUAL_FRAME_X64_H_