First step towards making JumpTarget work on ARM. Instead...

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 12 matching lines @@
 // 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_X64_VIRTUAL_FRAME_X64_H_
 #define V8_X64_VIRTUAL_FRAME_X64_H_
 
 #include "type-info.h"
 #include "register-allocator.h"
 #include "scopes.h"

[Søren Thygesen Gjesse, 2010/05/06 07:48:11]

Sort includes.

+#include "codegen.h"
 
 namespace v8 {
 namespace internal {
 
 // -------------------------------------------------------------------------
 // Virtual frames
 //
 // The virtual frame is an abstraction of the physical stack frame.  It
 // encapsulates the parameters, frame-allocated locals, and the expression
 // stack.  It supports push/pop operations on the expression stack, as well
@@ skipping 47 matching lines @@
   // The height of the virtual expression stack.
   int height() {
     return element_count() - expression_base_index();
   }
 
   int register_location(int num) {
     ASSERT(num >= 0 && num < RegisterAllocator::kNumRegisters);
     return register_locations_[num];
   }
 
-  int register_location(Register reg) {
-    return register_locations_[RegisterAllocator::ToNumber(reg)];
-  }
+  inline int register_location(Register reg);
 
-  void set_register_location(Register reg, int index) {
-    register_locations_[RegisterAllocator::ToNumber(reg)] = index;
-  }
+  inline void set_register_location(Register reg, int index);
 
   bool is_used(int num) {
     ASSERT(num >= 0 && num < RegisterAllocator::kNumRegisters);
     return register_locations_[num] != kIllegalIndex;
   }
 
-  bool is_used(Register reg) {
-    return register_locations_[RegisterAllocator::ToNumber(reg)]
-        != kIllegalIndex;
-  }
+  inline bool is_used(Register 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 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
@@ skipping 83 matching lines @@
   // An element of the expression stack as an assembly operand.
   Operand ElementAt(int index) const {
     return Operand(rsp, index * kPointerSize);
   }
 
   // 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);
-    SetElementAt(index, &temp);
-  }
+  inline void SetElementAt(int index, Handle<Object> value);
 
   void PushElementAt(int index) {
     PushFrameSlotAt(element_count() - index - 1);
   }
 
   void StoreToElementAt(int index) {
     StoreToFrameSlotAt(element_count() - index - 1);
   }
 
   // A frame-allocated local as an assembly operand.
@@ skipping 60 matching lines @@
   }
 
   // The receiver frame slot.
   Operand Receiver() { return ParameterAt(-1); }
 
   // Push a try-catch or try-finally handler on top of the virtual frame.
   void PushTryHandler(HandlerType type);
 
   // Call stub given the number of arguments it expects on (and
   // removes from) the stack.
-  Result CallStub(CodeStub* stub, int arg_count) {
-    PrepareForCall(arg_count, arg_count);
-    return RawCallStub(stub);
-  }
+  inline Result CallStub(CodeStub* stub, int arg_count);
 
   // Call stub that takes a single argument passed in eax.  The
   // argument is given as a result which does not have to be eax or
   // even a register.  The argument is consumed by the call.
   Result CallStub(CodeStub* stub, Result* arg);
 
   // Call stub that takes a pair of arguments passed in edx (arg0, rdx) and
   // eax (arg1, rax).  The arguments are given as results which do not have
   // to be in the proper registers or even in registers.  The
   // arguments are consumed by the call.
@@ skipping 120 matching lines @@
 
   // 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_[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(); }
+  inline int parameter_count();
+  inline int local_count();
 
   // 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() { return 1; }
 
@@ skipping 111 matching lines @@
 
   // Classes that need raw access to the elements_ array.
   friend class DeferredCode;
   friend class JumpTarget;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_X64_VIRTUAL_FRAME_X64_H_