Add a VirtualFrame class to the IA32 code generator. All frame...

src/codegen-ia32.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 20 matching lines @@
 #include "scopes.h"
 
 namespace v8 { namespace internal {
 
 // Forward declarations
 class DeferredCode;
 
 // Mode to overwrite BinaryExpression values.
 enum OverwriteMode { NO_OVERWRITE, OVERWRITE_LEFT, OVERWRITE_RIGHT };
 
+enum InitState { CONST_INIT, NOT_CONST_INIT };
+enum TypeofState { INSIDE_TYPEOF, NOT_INSIDE_TYPEOF };
 
-// -----------------------------------------------------------------------------
+
+// -------------------------------------------------------------------------
+// Virtual frame
+
+class VirtualFrame BASE_EMBEDDED {
+ public:
+  explicit VirtualFrame(CodeGenerator* cgen);
+
+  void Enter();
+  void Exit();
+
+  void AllocateLocals();
+
+  Operand Top() const { return Operand(esp, 0); }
+
+  Operand Element(int index) const {
+    return Operand(esp, index * kPointerSize);
+  }
+
+  Operand Local(int index) const {
+    ASSERT(0 <= index && index < frame_local_count_);
+    return Operand(ebp, kLocal0Offset - index * kPointerSize);
+  }
+
+  Operand Function() const { return Operand(ebp, kFunctionOffset); }
+
+  Operand Context() const { return Operand(ebp, kContextOffset); }
+
+  Operand Parameter(int index) const {
+    ASSERT(-1 <= index && index < parameter_count_);
+    return Operand(ebp, (1 + parameter_count_ - index) * kPointerSize);
+  }
+
+  Operand Receiver() const { return Parameter(-1); }
+
+  inline void Drop(int count);
+
+  inline void Pop(Register reg);
+  inline void Pop(Operand operand);
+
+  inline void Push(Register reg);
+  inline void Push(Operand operand);
+  inline void Push(Immediate immediate);
+
+ 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_;
+};
+
+
+// -------------------------------------------------------------------------
 // Reference support
 
 // A reference is a C++ stack-allocated object that keeps an ECMA
 // reference on the execution stack while in scope. For variables
 // the reference is empty, indicating that it isn't necessary to
 // store state on the stack for keeping track of references to those.
 // For properties, we keep either one (named) or two (indexed) values
 // on the execution stack to represent the reference.
 
-enum InitState { CONST_INIT, NOT_CONST_INIT };
-enum TypeofState { INSIDE_TYPEOF, NOT_INSIDE_TYPEOF };
-
 class Reference BASE_EMBEDDED {
  public:
   // The values of the types is important, see size().
   enum Type { ILLEGAL = -1, SLOT = 0, NAMED = 1, KEYED = 2 };
   Reference(CodeGenerator* cgen, Expression* expression);
   ~Reference();
 
   Expression* expression() const { return expression_; }
   Type type() const { return type_; }
   void set_type(Type value) {
@@ skipping 63 matching lines @@
   CodeGenerator* owner_;
   TypeofState typeof_state_;
   Label* true_target_;
   Label* false_target_;
   CodeGenState* previous_;
 };
 
 
 
 
-// -----------------------------------------------------------------------------
+// -------------------------------------------------------------------------
 // CodeGenerator
 
-//
 class CodeGenerator: public Visitor {
  public:
   // Takes a function literal, generates code for it. This function should only
   // be called by compiler.cc.
   static Handle<Code> MakeCode(FunctionLiteral* fun,
                                Handle<Script> script,
                                bool is_eval);
 
   static void SetFunctionInfo(Handle<JSFunction> fun,
                               int length,
                               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 17 matching lines @@
   NODE_LIST(DEF_VISIT)
 #undef DEF_VISIT
 
   // Main code generation function
   void GenCode(FunctionLiteral* fun);
 
   // The following are used by class Reference.
   void LoadReference(Reference* ref);
   void UnloadReference(Reference* ref);
 
-  // Support functions for accessing parameters and other operands.
-  Operand ParameterOperand(int index) const {
-    int num_parameters = scope()->num_parameters();
-    ASSERT(-2 <= index && index < num_parameters);
-    return Operand(ebp, (1 + num_parameters - index) * kPointerSize);
-  }
-
-  Operand ReceiverOperand() const { return ParameterOperand(-1); }
-
-  Operand FunctionOperand() const {
-    return Operand(ebp, JavaScriptFrameConstants::kFunctionOffset);
-  }
-
   Operand ContextOperand(Register context, int index) const {
     return Operand(context, Context::SlotOffset(index));
   }
 
   Operand SlotOperand(Slot* slot, Register tmp);
 
 
   // Expressions
   Operand GlobalObject() const {
     return ContextOperand(esi, Context::GLOBAL_INDEX);
@@ skipping 120 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;
-  friend class Property;
-  friend class VariableProxy;
-  friend class Slot;
 
   DISALLOW_COPY_AND_ASSIGN(CodeGenerator);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_CODEGEN_IA32_H_