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

src/codegen-arm.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 83 matching lines @@
 
   bool is_illegal() const  { return type_ == ILLEGAL; }
 
  private:
   ArmCodeGenerator* 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(ArmCodeGenerator* 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(ArmCodeGenerator* 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(ArmCodeGenerator* 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:
+  ArmCodeGenerator* owner_;
   AccessType access_;
   Reference* ref_;
   Label* true_target_;
   Label* false_target_;
+  CodeGenState* previous_;
 };
 
 
 // -----------------------------------------------------------------------------
 // ArmCodeGenerator
 
 class ArmCodeGenerator: 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_;
   int break_stack_height_;
 
@@ skipping 70 matching lines @@
   // 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 77 matching lines @@
 
   virtual void GenerateObjectEquals(ZoneList<Expression*>* args);
 
   friend class Reference;
   friend class Property;
   friend class VariableProxy;
   friend class Slot;
 };
 
 
+// -------------------------------------------------------------------------
+// CodeGenState implementation.
+
+CodeGenState::CodeGenState(ArmCodeGenerator* owner)
+    : owner_(owner),
+      access_(UNDEFINED),
+      ref_(NULL),
+      true_target_(NULL),
+      false_target_(NULL),
+      previous_(NULL) {
+  owner_->set_state(this);
+}
+
+
+CodeGenState::CodeGenState(ArmCodeGenerator* 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(ArmCodeGenerator* 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_);
+}
+
+
 // -----------------------------------------------------------------------------
 // ArmCodeGenerator implementation
 
 #define __  masm_->
 
 
 Handle<Code> ArmCodeGenerator::MakeCode(FunctionLiteral* flit,
                                         Handle<Script> script,
                                         bool is_eval) {
 #ifdef ENABLE_DISASSEMBLER
@@ skipping 95 matching lines @@
 // fp: frame pointer
 // sp: stack pointer
 // pp: caller's parameter pointer
 // cp: callee's context
 
 void ArmCodeGenerator::GenCode(FunctionLiteral* fun) {
   Scope* scope = fun->scope();
   ZoneList<Statement*>* body = fun->body();
 
   // Initialize state.
-  { CodeGenState state;
-    state_ = &state;
+  { CodeGenState state(this);
     scope_ = scope;
     cc_reg_ = al;
 
     // Entry
     // stack: function, receiver, arguments, return address
     // r0: number of arguments
     // sp: stack pointer
     // fp: frame pointer
     // pp: caller's parameter pointer
     // cp: callee's context
@@ skipping 131 matching lines @@
       if (should_trace) {
         // Push a valid value as the parameter. The runtime call only uses
         // it as the return value to indicate non-failure.
         __ mov(r0, Operand(Smi::FromInt(0)));
         __ push(r0);
         __ CallRuntime(Runtime::kDebugTrace, 1);
       }
 #endif
       VisitStatements(body);
     }
-
-    state_ = NULL;
   }
 
   // exit
   // r0: result
   // sp: stack pointer
   // fp: frame pointer
   // pp: parameter pointer
   // cp: callee's context
   __ mov(r0, Operand(Factory::undefined_value()));
 
@@ skipping 86 matching lines @@
 // has_cc() is true and cc_reg_ contains the condition to test for 'true'.
 void ArmCodeGenerator::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()) {
     // Convert the TOS value to a boolean in the condition code register.
     ToBoolean(true_target, false_target);
   }
   ASSERT(has_cc() || !force_cc);
 }
 
 
 void ArmCodeGenerator::Load(Expression* x, CodeGenState::AccessType access) {
   ASSERT(access == CodeGenState::LOAD ||
@@ skipping 127 matching lines @@
   if (size <= 0) {
     // Do nothing. No popping is necessary.
   } else {
     __ pop(r0);
     __ add(sp, sp, Operand(size * kPointerSize));
     __ push(r0);
   }
 }
 
 
-void ArmCodeGenerator::GetValue(Reference* ref) {
-  ASSERT(!has_cc());
-  ASSERT(!ref->is_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());
   ArmCodeGenerator::SetReferenceProperty(masm, ref, key());
 }
 
 
@@ skipping 52 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(r0);
 
   } 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->ldr(r2, ArmCodeGenerator::SlotOperand(masm, scope, this, r2));
       masm->cmp(r2, Operand(Factory::the_hole_value()));
       masm->b(ne, &exit);
-      may_skip_write = true;
     }
 
     // We must execute the store.
     // r2 may be loaded with context; used below in RecordWrite.
     // Storing a variable must keep the (new) value on the stack. This is
     // necessary for compiling assignment expressions.
     //
     // Note: We will reach here even with 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.  r2 may be
     // loaded with context; used below in RecordWrite.
     masm->pop(r0);
     masm->str(r0, ArmCodeGenerator::SlotOperand(masm, scope, this, r2));
     masm->push(r0);
 
     if (type() == Slot::CONTEXT) {
       // Skip write barrier if the written value is a smi.
       masm->tst(r0, Operand(kSmiTagMask));
       masm->b(eq, &exit);
-      may_skip_write = true;
       // r2 is loaded with context when calling SlotOperand above.
       int offset = FixedArray::kHeaderSize + index() * kPointerSize;
       masm->mov(r3, Operand(offset));
       masm->RecordWrite(r2, r3, r1);
     }
     // 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 || type() == Slot::CONTEXT) {
+      masm->bind(&exit);
+    }
   }
 }
 
 
 // ECMA-262, section 9.2, page 30: ToBoolean(). Convert the given
 // register to a boolean in the condition code register. The code
 // may jump to 'false_target' in case the register converts to 'false'.
 void ArmCodeGenerator::ToBoolean(Label* true_target,
                                  Label* false_target) {
   // Note: The generated code snippet does not change stack variables.
@@ skipping 3613 matching lines @@
                                      bool is_eval) {
   Handle<Code> code = ArmCodeGenerator::MakeCode(fun, script, is_eval);
   if (!code.is_null()) {
     Counters::total_compiled_code_size.Increment(code->instruction_size());
   }
   return code;
 }
 
 
 } }  // namespace v8::internal