Simplify virtual frame by removing the virtual stack pointer, which...

src/virtual-frame-arm.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 49 matching lines @@
  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);
 
   int height() const {
-    return virtual_stack_pointer_ - expression_base_index() + 1;
+    return elements_.length() - expression_base_index();
   }
 
   // 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);
 
   // Make this virtual frame have a state identical to an expected virtual
@@ skipping 84 matching lines @@
   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;
 
   MacroAssembler* masm_;
 
   List<Element> elements_;
 
-  // The virtual stack pointer is the index of the top element of the stack.
-  int virtual_stack_pointer_;
-
-  int virtual_frame_pointer_;
-
   // The number of frame-allocated locals and parameters respectively.
   int parameter_count_;
   int local_count_;
 
+  int frame_pointer_;
+
   // The index of the first parameter.  The receiver lies below the first
   // parameter.
   int param0_index() const { return 1; }
 
   // 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; }
 
   // The index of the base of the expression stack.
   int expression_base_index() const { return local0_index() + local_count_; }
-
-  void AddElement(const Element& element) {
-    virtual_stack_pointer_++;
-    elements_.Add(element);
-  }
-
-  Element RemoveElement() {
-    virtual_stack_pointer_--;
-    return elements_.RemoveLast();
-  }
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_VIRTUAL_FRAME_ARM_H_