Emit pushes and pops through the virtual frame on ARM. Merging of...

src/codegen-arm.h

 // Copyright 2006-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 31 matching lines @@
 enum TypeofState { INSIDE_TYPEOF, NOT_INSIDE_TYPEOF };
 
 
 // -------------------------------------------------------------------------
 // Virtual frame
 
 class VirtualFrame BASE_EMBEDDED {
  public:
   explicit VirtualFrame(CodeGenerator* cgen);
 
+  void Enter();
+  void Exit();
+
+  void AllocateLocals();
+
   MemOperand Top() const { return MemOperand(sp, 0); }
 
   MemOperand Element(int index) const {
     return MemOperand(sp, index * kPointerSize);
   }
 
   MemOperand Local(int index) const {
     ASSERT(0 <= index && index < frame_local_count_);
     return MemOperand(fp, kLocal0Offset - index * kPointerSize);
   }
 
   MemOperand Function() const { return MemOperand(fp, kFunctionOffset); }
 
   MemOperand Context() const { return MemOperand(fp, kContextOffset); }
 
   MemOperand Parameter(int index) const {
     // Index -1 corresponds to the receiver.
     ASSERT(-1 <= index && index <= parameter_count_);
     return MemOperand(fp, (1 + parameter_count_ - index) * kPointerSize);
   }
 
+  inline void Drop(int count);
+
+  inline void Pop();
+  inline void Pop(Register reg);
+
+  inline void Push(Register reg);
+
  private:
   static const int kLocal0Offset = JavaScriptFrameConstants::kLocal0Offset;
   static const int kFunctionOffset = JavaScriptFrameConstants::kFunctionOffset;
   static const int kContextOffset = StandardFrameConstants::kContextOffset;
 
   MacroAssembler* masm_;
   int frame_local_count_;
   int parameter_count_;
 };
 
@@ skipping 105 matching lines @@
                               int function_token_position,
                               int start_position,
                               int end_position,
                               bool is_expression,
                               bool is_toplevel,
                               Handle<Script> script);
 
   // Accessors
   MacroAssembler* masm() { return masm_; }
 
+  VirtualFrame* frame() const { return frame_; }
+
   CodeGenState* state() { return state_; }
   void set_state(CodeGenState* state) { state_ = state; }
 
   void AddDeferred(DeferredCode* code) { deferred_.Add(code); }
 
  private:
   // Construction/Destruction
   CodeGenerator(int buffer_size, Handle<Script> script, bool is_eval);
   virtual ~CodeGenerator() { delete masm_; }
 
@@ skipping 151 matching lines @@
   // permits optimization and calls GenerateFastCaseSwitch if it does.
   // Returns true if the fast-case switch was generated, and false if not.
   bool TryGenerateFastCaseSwitchStatement(SwitchStatement* node);
 
 
   // Bottle-neck interface to call the Assembler to generate the statement
   // position. This allows us to easily control whether statement positions
   // should be generated or not.
   void RecordStatementPosition(Node* node);
 
-  // Activation frames.
-  void EnterJSFrame();
-  void ExitJSFrame();
-
-
   bool is_eval_;  // Tells whether code is generated for eval.
   Handle<Script> script_;
   List<DeferredCode*> deferred_;
 
   // Assembler
   MacroAssembler* masm_;  // to generate code
 
   // Code generation state
   Scope* scope_;
   VirtualFrame* frame_;
   Condition cc_reg_;
   CodeGenState* state_;
   bool is_inside_try_;
   int break_stack_height_;
 
   // Labels
   Label function_return_;
 
   friend class VirtualFrame;
   friend class Reference;
 
   DISALLOW_COPY_AND_ASSIGN(CodeGenerator);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_CODEGEN_ARM_H_