Finish porting jump target changes to the ARM platform. The v8 test...

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 48 matching lines @@
 class VirtualFrame : public Malloced {
  public:
   // Construct a virtual frame with the given code generator used to
   // generate code.
   explicit VirtualFrame(CodeGenerator* cgen);
 
   // Construct a virtual frame that is a clone of an existing one, initially
   // with an identical state.
   explicit VirtualFrame(VirtualFrame* original);
 
-  // The height of the virtual expression stack.  Always non-negative.
+  // The height of the virtual expression stack.
   int height() const {
     return virtual_stack_pointer_ - expression_base_index() + 1;
   }
 
   // Add extra in-memory elements to the top of the frame without generating
   // code.
   void Adjust(int count);
 
   // Forget frame elements without generating code.
   void Forget(int count);
@@ skipping 17 matching lines @@
 
   // The current top of the expression stack as an assembly operand.
   Operand Top() const { return Operand(esp, 0); }
 
   // An element of the expression stack as an assembly operand.
   Operand ElementAt(int index) const {
     return Operand(esp, index * kPointerSize);
   }
 
   // A frame-allocated local as an assembly operand.
-  Operand Local(int index) const {
+  Operand LocalAt(int index) const {
     ASSERT(0 <= index);
     ASSERT(index < local_count_);
     return Operand(ebp, kLocal0Offset - index * kPointerSize);
   }
 
   // The function frame slot.
   Operand Function() const { return Operand(ebp, kFunctionOffset); }
 
   // The context frame slot.
   Operand Context() const { return Operand(ebp, kContextOffset); }
 
   // A parameter as an assembly operand.
-  Operand Parameter(int index) const {
-    ASSERT(-1 <= index);
+  Operand ParameterAt(int index) const {
+    ASSERT(-1 <= index);  // -1 is the receiver.
     ASSERT(index < parameter_count_);
     return Operand(ebp, (1 + parameter_count_ - index) * kPointerSize);
   }
 
   // The receiver frame slot.
-  Operand Receiver() const { return Parameter(-1); }
+  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);
 
   // 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,
                      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.
-  void CallCode(Handle<Code> ic, RelocInfo::Mode rmode, int frame_arg_count);
+  void CallCodeObject(Handle<Code> ic,
+                      RelocInfo::Mode rmode,
+                      int frame_arg_count);
 
   // 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();
 
   // Pop and save an element from the top of the expression stack.  May emit
@@ skipping 39 matching lines @@
 
   void AddElement(const Element& element) {
     virtual_stack_pointer_++;
     elements_.Add(element);
   }
 
   Element RemoveElement() {
     virtual_stack_pointer_--;
     return elements_.RemoveLast();
   }
-
-  // The JumpTarget class explicitly sets the height_ field of the expected
-  // frame at the actual return target.
-  friend class JumpTarget;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_VIRTUAL_FRAME_IA32_H_