Change the code generator state constructor to implicitly push the state on...

src/codegen-ia32.cc

 // 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 89 matching lines @@
 
   bool is_illegal() const  { return type_ == ILLEGAL; }
 
  private:
   Ia32CodeGenerator* cgen_;
   Expression* expression_;
   Type type_;
 };
 
 
-// -----------------------------------------------------------------------------
+// -------------------------------------------------------------------------
 // Code generation state
 
+// The state is passed down the AST by the code generator.  It is passed
+// implicitly (in a member variable) to the non-static code generator member
+// functions, and explicitly (as an argument) to the static member functions
+// and the AST node member functions.
+//
+// The state is threaded through the call stack.  Constructing a state
+// implicitly pushes it on the owning code generator's stack of states, and
+// destroying one implicitly pops it.
+
 class CodeGenState BASE_EMBEDDED {
  public:
   enum AccessType {
     UNDEFINED,
     LOAD,
     LOAD_TYPEOF_EXPR
   };
 
-  CodeGenState()
-      : access_(UNDEFINED),
-        ref_(NULL),
-        true_target_(NULL),
-        false_target_(NULL) {
-  }
+  // Create an initial code generator state.  Destroying the initial state
+  // leaves the code generator with a NULL state.
+  CodeGenState(Ia32CodeGenerator* owner);
 
-  CodeGenState(AccessType access,
-               Reference* ref,
+  // Create a code generator state based on a code generator's current
+  // state.  The new state has its own access type and pair of branch
+  // labels, and no reference.
+  CodeGenState(Ia32CodeGenerator* owner,
+               AccessType access,
                Label* true_target,
-               Label* false_target)
-      : access_(access),
-        ref_(ref),
-        true_target_(true_target),
-        false_target_(false_target) {
-  }
+               Label* false_target);
+
+  // Create a code generator state based on a code generator's current
+  // state.  The new state has an access type of LOAD, its own reference,
+  // and inherits the pair of branch labels of the current state.
+  CodeGenState(Ia32CodeGenerator* owner, Reference* ref);
+
+  // Destroy a code generator state and restore the owning code generator's
+  // previous state.
+  ~CodeGenState();
 
   AccessType access() const { return access_; }
   Reference* ref() const { return ref_; }
   Label* true_target() const { return true_target_; }
   Label* false_target() const { return false_target_; }
 
  private:
+  Ia32CodeGenerator* owner_;
   AccessType access_;
   Reference* ref_;
   Label* true_target_;
   Label* false_target_;
+  CodeGenState* previous_;
 };
 
 
 // -----------------------------------------------------------------------------
 // Ia32CodeGenerator
 
 class Ia32CodeGenerator: public CodeGenerator {
  public:
   static Handle<Code> MakeCode(FunctionLiteral* fun,
                                Handle<Script> script,
                                bool is_eval);
 
   MacroAssembler* masm()  { return masm_; }
 
+  CodeGenState* state() { return state_; }
+  void set_state(CodeGenState* state) { state_ = state; }
+
  private:
   // Assembler
   MacroAssembler* masm_;  // to generate code
 
   // Code generation state
   Scope* scope_;
   Condition cc_reg_;
   CodeGenState* state_;
   bool is_inside_try_;
   int break_stack_height_;
@@ skipping 72 matching lines @@
   // non-existing properties of the global object, so we must make it
   // look like an explicit property access, instead of an access
   // through the context chain.
   void LoadTypeofExpression(Expression* x);
 
   // References
 
   // Generate code to fetch the value of a reference.  The reference is
   // expected to be on top of the expression stack.  It is left in place and
   // its value is pushed on top of it.
-  void GetValue(Reference* ref);
+  void GetValue(Reference* ref) {
+    ASSERT(!has_cc());
+    ASSERT(!ref->is_illegal());
+    CodeGenState new_state(this, ref);
+    Visit(ref->expression());
+  }
 
   // Generate code to store a value in a reference.  The stored value is
   // expected on top of the expression stack, with the reference immediately
   // below it.  The expression stack is left unchanged.
   void SetValue(Reference* ref) {
     ASSERT(!has_cc());
     ASSERT(!ref->is_illegal());
     ref->expression()->GenerateStoreCode(masm_, scope_, ref, NOT_CONST_INIT);
   }
 
@@ skipping 84 matching lines @@
 
   virtual void GenerateObjectEquals(ZoneList<Expression*>* args);
 
   friend class Reference;
   friend class Property;
   friend class VariableProxy;
   friend class Slot;
 };
 
 
+// -------------------------------------------------------------------------
+// CodeGenState implementation.
+
+CodeGenState::CodeGenState(Ia32CodeGenerator* owner)
+    : owner_(owner),
+      access_(UNDEFINED),
+      ref_(NULL),
+      true_target_(NULL),
+      false_target_(NULL),
+      previous_(NULL) {
+  owner_->set_state(this);
+}
+
+
+CodeGenState::CodeGenState(Ia32CodeGenerator* owner,
+                           AccessType access,
+                           Label* true_target,
+                           Label* false_target)
+    : owner_(owner),
+      access_(access),
+      ref_(NULL),
+      true_target_(true_target),
+      false_target_(false_target),
+      previous_(owner->state()) {
+  owner_->set_state(this);
+}
+
+
+CodeGenState::CodeGenState(Ia32CodeGenerator* owner, Reference* ref)
+    : owner_(owner),
+      access_(LOAD),
+      ref_(ref),
+      true_target_(owner->state()->true_target_),
+      false_target_(owner->state()->false_target_),
+      previous_(owner->state()) {
+  owner_->set_state(this);
+}
+
+
+CodeGenState::~CodeGenState() {
+  ASSERT(owner_->state() == this);
+  owner_->set_state(previous_);
+}
+
+
 // -----------------------------------------------------------------------------
 // Ia32CodeGenerator implementation
 
 #define __  masm_->
 
 
 Handle<Code> Ia32CodeGenerator::MakeCode(FunctionLiteral* flit,
                                          Handle<Script> script,
                                          bool is_eval) {
 #ifdef ENABLE_DISASSEMBLER
@@ skipping 98 matching lines @@
 
 
 void Ia32CodeGenerator::GenCode(FunctionLiteral* fun) {
   // Record the position for debugging purposes.
   __ RecordPosition(fun->start_position());
 
   Scope* scope = fun->scope();
   ZoneList<Statement*>* body = fun->body();
 
   // Initialize state.
-  { CodeGenState state;
-    state_ = &state;
+  { CodeGenState state(this);
     scope_ = scope;
     cc_reg_ = no_condition;
 
     // Entry
     // stack: function, receiver, arguments, return address
     // esp: stack pointer
     // ebp: frame pointer
     // edi: caller's parameter pointer
     // esi: callee's context
 
@@ skipping 163 matching lines @@
       VisitStatements(body);
 
       // Generate a return statement if necessary.
       if (body->is_empty() || body->last()->AsReturnStatement() == NULL) {
         Literal undefined(Factory::undefined_value());
         ReturnStatement statement(&undefined);
         statement.set_statement_pos(fun->end_position());
         VisitReturnStatement(&statement);
       }
     }
-
-    state_ = NULL;
   }
 
   // Code generation state must be reset.
   scope_ = NULL;
   ASSERT(!has_cc());
   ASSERT(state_ == NULL);
 }
 
 
 Operand Ia32CodeGenerator::SlotOperand(MacroAssembler* masm,
@@ skipping 59 matching lines @@
 // has_cc() is true and cc_reg_ contains the condition to test for 'true'.
 void Ia32CodeGenerator::LoadCondition(Expression* x,
                                       CodeGenState::AccessType access,
                                       Label* true_target,
                                       Label* false_target,
                                       bool force_cc) {
   ASSERT(access == CodeGenState::LOAD ||
          access == CodeGenState::LOAD_TYPEOF_EXPR);
   ASSERT(!has_cc() && !is_referenced());
 
-  CodeGenState* old_state = state_;
-  CodeGenState new_state(access, NULL, true_target, false_target);
-  state_ = &new_state;
-  Visit(x);
-  state_ = old_state;
+  { CodeGenState new_state(this, access, true_target, false_target);
+    Visit(x);
+  }
   if (force_cc && !has_cc()) {
     ToBoolean(true_target, false_target);
   }
   ASSERT(has_cc() || !force_cc);
 }
 
 
 void Ia32CodeGenerator::Load(Expression* x, CodeGenState::AccessType access) {
   ASSERT(access == CodeGenState::LOAD ||
          access == CodeGenState::LOAD_TYPEOF_EXPR);
@@ skipping 127 matching lines @@
     __ pop(eax);
     __ mov(TOS, eax);
   } else {
     __ pop(eax);
     __ add(Operand(esp), Immediate(size * kPointerSize));
     __ push(eax);
   }
 }
 
 
-void Ia32CodeGenerator::GetValue(Reference* ref) {
-  ASSERT(!has_cc());
-  ASSERT(ref->type() != Reference::ILLEGAL);
-  CodeGenState* old_state = state_;
-  CodeGenState new_state(CodeGenState::LOAD, ref, true_target(),
-                         false_target());
-  state_ = &new_state;
-  Visit(ref->expression());
-  state_ = old_state;
-}
-
-
 void Property::GenerateStoreCode(MacroAssembler* masm,
                                  Scope* scope,
                                  Reference* ref,
                                  InitState init_state) {
   Comment cmnt(masm, "[ Store to Property");
   masm->RecordPosition(position());
   Ia32CodeGenerator::SetReferenceProperty(masm, ref, key());
 }
 
 
@@ skipping 51 matching lines @@
       masm->CallRuntime(Runtime::kStoreContextSlot, 3);
     }
     // Storing a variable must keep the (new) value on the expression
     // stack. This is necessary for compiling assignment expressions.
     masm->push(eax);
 
   } else {
     ASSERT(var()->mode() != Variable::DYNAMIC);
 
     Label exit;
-    bool may_skip_write = false;
     if (init_state == CONST_INIT) {
       ASSERT(var()->mode() == Variable::CONST);
       // Only the first const initialization must be executed (the slot
       // still contains 'the hole' value). When the assignment is executed,
       // the code is identical to a normal store (see below).
       Comment cmnt(masm, "[ Init const");
       masm->mov(eax, Ia32CodeGenerator::SlotOperand(masm, scope, this, ecx));
       masm->cmp(eax, Factory::the_hole_value());
       masm->j(not_equal, &exit);
-      may_skip_write = true;
     }
 
     // We must execute the store.
     // Storing a variable must keep the (new) value on the stack. This is
     // necessary for compiling assignment expressions.  ecx may be loaded
     // with context; used below in RecordWrite.
     //
     // Note: We will reach here even with node->var()->mode() ==
     // Variable::CONST because of const declarations which will initialize
     // consts to 'the hole' value and by doing so, end up calling this
     // code.
     masm->pop(eax);
     masm->mov(Ia32CodeGenerator::SlotOperand(masm, scope, this, ecx), eax);
     masm->push(eax);  // RecordWrite may destroy the value in eax.
     if (type() == Slot::CONTEXT) {
       // ecx is loaded with context when calling SlotOperand above.
       int offset = FixedArray::kHeaderSize + index() * kPointerSize;
       masm->RecordWrite(ecx, offset, eax, ebx);
     }
     // If we definitely did not jump over the assignment, we do not need to
     // bind the exit label.  Doing so can defeat peephole optimization.
-    if (may_skip_write) masm->bind(&exit);
+    if (init_state == CONST_INIT) masm->bind(&exit);
   }
 }
 
 
 #undef __
 #define __  masm->
 
 class ToBooleanStub: public CodeStub {
  public:
   ToBooleanStub() { }
@@ skipping 4427 matching lines @@
                                      bool is_eval) {
   Handle<Code> code = Ia32CodeGenerator::MakeCode(fun, script, is_eval);
   if (!code.is_null()) {
     Counters::total_compiled_code_size.Increment(code->instruction_size());
   }
   return code;
 }
 
 
 } }  // namespace v8::internal