Remove some of the state-dependent behavior from the code generator....

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 91 matching lines @@
 
 
 // -----------------------------------------------------------------------------
 // Code generation state
 
 class CodeGenState BASE_EMBEDDED {
  public:
   enum AccessType {
     UNDEFINED,
     LOAD,
-    LOAD_TYPEOF_EXPR,
-    STORE,
-    INIT_CONST
+    LOAD_TYPEOF_EXPR
   };
 
   CodeGenState()
       : access_(UNDEFINED),
         ref_(NULL),
         true_target_(NULL),
         false_target_(NULL) {
   }
 
   CodeGenState(AccessType access,
@@ skipping 49 matching lines @@
                    bool is_eval);
 
   virtual ~ArmCodeGenerator()  { delete masm_; }
 
   // Main code generation function
   void GenCode(FunctionLiteral* fun);
 
   // The following are used by class Reference.
   void LoadReference(Reference* ref);
   void UnloadReference(Reference* ref);
-  friend class Reference;
 
   // State
   bool has_cc() const  { return cc_reg_ != al; }
   CodeGenState::AccessType access() const  { return state_->access(); }
   Reference* ref() const  { return state_->ref(); }
   bool is_referenced() const { return state_->ref() != NULL; }
   Label* true_target() const  { return state_->true_target(); }
   Label* false_target() const  { return state_->false_target(); }
 
 
   // Expressions
   MemOperand GlobalObject() const  {
     return ContextOperand(cp, Context::GLOBAL_INDEX);
   }
 
-  MemOperand ContextOperand(Register context, int index) const {
+  static MemOperand ContextOperand(Register context, int index) {
     return MemOperand(context, Context::SlotOffset(index));
   }
 
-  MemOperand ParameterOperand(int index) const {
+  static MemOperand ParameterOperand(Scope* scope, int index) {
     // index -2 corresponds to the activated closure, -1 corresponds
     // to the receiver
-    ASSERT(-2 <= index && index < scope_->num_parameters());
+    ASSERT(-2 <= index && index < scope->num_parameters());
     int offset = JavaScriptFrameConstants::kParam0Offset - index * kPointerSize;
     return MemOperand(pp, offset);
   }
 
+  MemOperand ParameterOperand(int index) const {
+    return ParameterOperand(scope_, index);
+  }
+
   MemOperand FunctionOperand() const { return ParameterOperand(-2); }
 
-  MemOperand SlotOperand(Slot* slot, Register tmp);
+  static MemOperand SlotOperand(MacroAssembler* masm,
+                                Scope* scope,
+                                Slot* slot,
+                                Register tmp);
+
+  MemOperand SlotOperand(Slot* slot, Register tmp) {
+    return SlotOperand(masm_, scope_, slot, tmp);
+  }
 
   void LoadCondition(Expression* x, CodeGenState::AccessType access,
                      Label* true_target, Label* false_target, bool force_cc);
   void Load(Expression* x,
             CodeGenState::AccessType access = CodeGenState::LOAD);
   void LoadGlobal();
 
   // Special code for typeof expressions: Unfortunately, we must
   // be careful when loading the expression in 'typeof'
   // expressions. We are not allowed to throw reference errors for
   // 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
-  void AccessReference(Reference* ref, CodeGenState::AccessType access);
 
-  void GetValue(Reference* ref)  { AccessReference(ref, CodeGenState::LOAD); }
-  void SetValue(Reference* ref)  { AccessReference(ref, CodeGenState::STORE); }
-  void InitConst(Reference* ref)  {
-    AccessReference(ref, CodeGenState::INIT_CONST);
+  // 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);
+
+  // 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, false);
   }
 
-  void ToBoolean(Label* true_target, Label* false_target);
+  // 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 InitConst(Reference* ref) {
+    ASSERT(!has_cc());
+    ASSERT(!ref->is_illegal());
+    ref->expression()->GenerateStoreCode(masm_, scope_, ref, true);
+  }
+
+  // Generate code to fetch a value from a property of a reference.  The
+  // reference is expected on top of the expression stack.  It is left in
+  // place and its value is pushed on top of it.
+  void GetReferenceProperty(Expression* key);
+
+  // Generate code to store a value in a property of 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.
+  static void SetReferenceProperty(MacroAssembler* masm,
+                                   Reference* ref,
+                                   Expression* key);
 
 
-  // Access property from the reference (must be at the TOS).
-  void AccessReferenceProperty(Expression* key,
-                               CodeGenState::AccessType access);
+  void ToBoolean(Label* true_target, Label* false_target);
 
   void GenericBinaryOperation(Token::Value op);
   void Comparison(Condition cc, bool strict = false);
 
   void SmiOperation(Token::Value op, Handle<Object> value, bool reversed);
 
   void CallWithArguments(ZoneList<Expression*>* arguments, int position);
 
   // Declare global variables and functions in the given array of
   // name/value pairs.
@@ skipping 35 matching lines @@
 
   virtual void GenerateArgumentsLength(ZoneList<Expression*>* args);
   virtual void GenerateArgumentsAccess(ZoneList<Expression*>* args);
 
   virtual void GenerateValueOf(ZoneList<Expression*>* args);
   virtual void GenerateSetValueOf(ZoneList<Expression*>* args);
 
   virtual void GenerateFastCharCodeAt(ZoneList<Expression*>* args);
 
   virtual void GenerateObjectEquals(ZoneList<Expression*>* args);
+
+  friend class Reference;
+  friend class Property;
+  friend class VariableProxy;
+  friend class Slot;
 };
 
 
 // -----------------------------------------------------------------------------
 // ArmCodeGenerator implementation
 
 #define __  masm_->
 
 
 Handle<Code> ArmCodeGenerator::MakeCode(FunctionLiteral* flit,
@@ skipping 282 matching lines @@
 
   ExitJSFrame();
 
   // Code generation state must be reset.
   scope_ = NULL;
   ASSERT(!has_cc());
   ASSERT(state_ == NULL);
 }
 
 
-MemOperand ArmCodeGenerator::SlotOperand(Slot* slot, Register tmp) {
+MemOperand ArmCodeGenerator::SlotOperand(MacroAssembler* masm,
+                                         Scope* scope,
+                                         Slot* slot,
+                                         Register tmp) {
   // Currently, this assertion will fail if we try to assign to
   // a constant variable that is constant because it is read-only
   // (such as the variable referring to a named function expression).
   // We need to implement assignments to read-only variables.
   // Ideally, we should do this during AST generation (by converting
   // such assignments into expression statements); however, in general
   // we may not be able to make the decision until past AST generation,
   // that is when the entire program is known.
   ASSERT(slot != NULL);
   int index = slot->index();
   switch (slot->type()) {
     case Slot::PARAMETER:
-      return ParameterOperand(index);
+      return ParameterOperand(scope, index);
 
     case Slot::LOCAL: {
       ASSERT(0 <= index &&
-             index < scope_->num_stack_slots() &&
+             index < scope->num_stack_slots() &&
              index >= 0);
       int local_offset = JavaScriptFrameConstants::kLocal0Offset -
                          index * kPointerSize;
       return MemOperand(fp, local_offset);
     }
 
     case Slot::CONTEXT: {
       // Follow the context chain if necessary.
       ASSERT(!tmp.is(cp));  // do not overwrite context register
       Register context = cp;
-      int chain_length = scope_->ContextChainLength(slot->var()->scope());
+      int chain_length = scope->ContextChainLength(slot->var()->scope());
       for (int i = chain_length; i-- > 0;) {
         // Load the closure.
         // (All contexts, even 'with' contexts, have a closure,
         // and it is the same for all contexts inside a function.
         // There is no need to go to the function context first.)
-        __ ldr(tmp, ContextOperand(context, Context::CLOSURE_INDEX));
+        masm->ldr(tmp, ContextOperand(context, Context::CLOSURE_INDEX));
         // Load the function context (which is the incoming, outer context).
-        __ ldr(tmp, FieldMemOperand(tmp, JSFunction::kContextOffset));
+        masm->ldr(tmp, FieldMemOperand(tmp, JSFunction::kContextOffset));
         context = tmp;
       }
       // We may have a 'with' context now. Get the function context.
       // (In fact this mov may never be the needed, since the scope analysis
       // may not permit a direct context access in this case and thus we are
       // always at a function context. However it is safe to dereference be-
       // cause the function context of a function context is itself. Before
       // deleting this mov we should try to create a counter-example first,
       // though...)
-      __ ldr(tmp, ContextOperand(context, Context::FCONTEXT_INDEX));
+      masm->ldr(tmp, ContextOperand(context, Context::FCONTEXT_INDEX));
       return ContextOperand(tmp, index);
     }
 
     default:
       UNREACHABLE();
       return MemOperand(r0, 0);
   }
 }
 
 
@@ skipping 156 matching lines @@
   if (size <= 0) {
     // Do nothing. No popping is necessary.
   } else {
     __ pop(r0);
     __ add(sp, sp, Operand(size * kPointerSize));
     __ push(r0);
   }
 }
 
 
-void ArmCodeGenerator::AccessReference(Reference* ref,
-                                       CodeGenState::AccessType access) {
+void ArmCodeGenerator::GetValue(Reference* ref) {
   ASSERT(!has_cc());
-  ASSERT(ref->type() != Reference::ILLEGAL);
+  ASSERT(!ref->is_illegal());
   CodeGenState* old_state = state_;
-  CodeGenState new_state(access, ref, true_target(), false_target());
+  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,
+                                 bool is_const_init) {
+  Comment cmnt(masm, "[ Store to Property");
+  masm->RecordPosition(position());
+  ArmCodeGenerator::SetReferenceProperty(masm, ref, key());
+}
+
+
+void VariableProxy::GenerateStoreCode(MacroAssembler* masm,
+                                      Scope* scope,
+                                      Reference* ref,
+                                      bool is_const_init) {
+  Comment cmnt(masm, "[ Store to VariableProxy");
+  Variable* node = var();
+
+  Expression* expr = node->rewrite();
+  if (expr != NULL) {
+    expr->GenerateStoreCode(masm, scope, ref, is_const_init);
+  } else {
+    ASSERT(node->is_global());
+    if (node->AsProperty() != NULL) {
+      masm->RecordPosition(node->AsProperty()->position());
+    }
+    ArmCodeGenerator::SetReferenceProperty(masm, ref,
+                                           new Literal(node->name()));
+  }
+}
+
+
+void Slot::GenerateStoreCode(MacroAssembler* masm,
+                             Scope* scope,
+                             Reference* ref,
+                             bool is_const_init) {
+  Comment cmnt(masm, "[ Store to Slot");
+
+  if (type() == Slot::LOOKUP) {
+    ASSERT(var()->mode() == Variable::DYNAMIC);
+
+    // For now, just do a runtime call.
+    masm->push(cp);
+    masm->mov(r0, Operand(var()->name()));
+    masm->push(r0);
+
+    if (is_const_init) {
+      // Same as the case for a normal store, but ignores attribute
+      // (e.g. READ_ONLY) of context slot so that we can initialize const
+      // properties (introduced via eval("const foo = (some expr);")). Also,
+      // uses the current function context instead of the top context.
+      //
+      // Note that we must declare the foo upon entry of eval(), via a
+      // context slot declaration, but we cannot initialize it at the same
+      // time, because the const declaration may be at the end of the eval
+      // code (sigh...) and the const variable may have been used before
+      // (where its value is 'undefined'). Thus, we can only do the
+      // initialization when we actually encounter the expression and when
+      // the expression operands are defined and valid, and thus we need the
+      // split into 2 operations: declaration of the context slot followed
+      // by initialization.
+      masm->CallRuntime(Runtime::kInitializeConstContextSlot, 3);
+    } else {
+      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;
+    if (is_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);
+    }
+
+    // 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);
+      // 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);
+    }
+    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.
   //       Only the condition code should be set.
   __ pop(r0);
 
   // Fast case checks
@@ skipping 982 matching lines @@
     __ push(r0);
     __ TailCallRuntime(ExternalReference(Runtime::kGetArgumentsProperty), 1);
   }
 }
 
 
 #undef __
 #define __  masm_->
 
 
-void ArmCodeGenerator::AccessReferenceProperty(
-    Expression* key,
-    CodeGenState::AccessType access) {
+void ArmCodeGenerator::GetReferenceProperty(Expression* key) {
   Reference::Type type = ref()->type();
-  ASSERT(type != Reference::ILLEGAL);
+  ASSERT(!ref()->is_illegal());
 
-  // TODO(1241834): Make sure that this is sufficient. If there is a chance
-  // that reference errors can be thrown below, we must distinguish
-  // between the 2 kinds of loads (typeof expression loads must not
-  // throw a reference error).
-  bool is_load = (access == CodeGenState::LOAD ||
-                  access == CodeGenState::LOAD_TYPEOF_EXPR);
-
+  // TODO(1241834): Make sure that this it is safe to ignore the distinction
+  // between access types LOAD and LOAD_TYPEOF_EXPR. If there is a chance
+  // that reference errors can be thrown below, we must distinguish between
+  // the two kinds of loads (typeof expression loads must not throw a
+  // reference error).
   if (type == Reference::NAMED) {
     // Compute the name of the property.
     Literal* literal = key->AsLiteral();
     Handle<String> name(String::cast(*literal->handle()));
 
     // Call the appropriate IC code.
-    if (is_load) {
-      // Setup the name register.
-      __ mov(r2, Operand(name));
-      Handle<Code> ic(Builtins::builtin(Builtins::LoadIC_Initialize));
-      Variable* var = ref()->expression()->AsVariableProxy()->AsVariable();
-      if (var != NULL) {
-        ASSERT(var->is_global());
-        __ Call(ic, code_target_context);
-      } else {
-        __ Call(ic, code_target);
-      }
-
+    // Setup the name register.
+    __ mov(r2, Operand(name));
+    Handle<Code> ic(Builtins::builtin(Builtins::LoadIC_Initialize));
+    Variable* var = ref()->expression()->AsVariableProxy()->AsVariable();
+    if (var != NULL) {
+      ASSERT(var->is_global());
+      __ Call(ic, code_target_context);
     } else {
-      __ pop(r0);  // value
-      // Setup the name register.
-      __ mov(r2, Operand(name));
-      Handle<Code> ic(Builtins::builtin(Builtins::StoreIC_Initialize));
       __ Call(ic, code_target);
     }
 
   } else {
     // Access keyed property.
     ASSERT(type == Reference::KEYED);
 
-    if (is_load) {
-      // TODO(1224671): Implement inline caching for keyed loads as on ia32.
-      GetPropertyStub stub;
-      __ CallStub(&stub);
-
-    } else {
-      __ pop(r0);  // value
-      SetPropertyStub stub;
-      __ CallStub(&stub);
-    }
+    // TODO(1224671): Implement inline caching for keyed loads as on ia32.
+    GetPropertyStub stub;
+    __ CallStub(&stub);
   }
   __ push(r0);
 }
 
 
+void ArmCodeGenerator::SetReferenceProperty(MacroAssembler* masm,
+                                            Reference* ref,
+                                            Expression* key) {
+  Reference::Type type = ref->type();
+  ASSERT(!ref->is_illegal());

[iposva, 2008/09/10 18:01:44]

Nit: Don't you want to assert before accessing any fields of ref?

[Kevin Millikin (Chromium), 2008/09/11 07:15:55]

Changed.  Illegal references have a type, so it's safe to access it.  But it
*is* clearer to read the preconditions earlier in the function.

+
+  if (type == Reference::NAMED) {
+    // Compute the name of the property.
+    Literal* literal = key->AsLiteral();
+    Handle<String> name(String::cast(*literal->handle()));
+
+    // Call the appropriate IC code.
+    masm->pop(r0);  // value
+    // Setup the name register.
+    masm->mov(r2, Operand(name));
+    Handle<Code> ic(Builtins::builtin(Builtins::StoreIC_Initialize));
+    masm->Call(ic, code_target);
+
+  } else {
+    // Access keyed property.
+    ASSERT(type == Reference::KEYED);
+
+    masm->pop(r0);  // value
+    SetPropertyStub stub;
+    masm->CallStub(&stub);
+  }
+  masm->push(r0);
+}
+
+
 void ArmCodeGenerator::GenericBinaryOperation(Token::Value op) {
   // sp[0] : y
   // sp[1] : x
   // result : r0
 
   // Stub is entered with a call: 'return address' is in lr.
   switch (op) {
     case Token::ADD:  // fall through.
     case Token::SUB:  // fall through.
     case Token::MUL:
@@ skipping 1202 matching lines @@
   __ bind(&then);
   Load(node->then_expression(), access());
   __ b(&exit);
   __ bind(&else_);
   Load(node->else_expression(), access());
   __ bind(&exit);
 }
 
 
 void ArmCodeGenerator::VisitSlot(Slot* node) {
+  ASSERT(access() != CodeGenState::UNDEFINED);
   Comment cmnt(masm_, "[ Slot");
 
   if (node->type() == Slot::LOOKUP) {
     ASSERT(node->var()->mode() == Variable::DYNAMIC);
 
     // For now, just do a runtime call.
     __ push(cp);
     __ mov(r0, Operand(node->var()->name()));
     __ push(r0);
 
-    switch (access()) {
-      case CodeGenState::UNDEFINED:
-        UNREACHABLE();
-        break;
-
-      case CodeGenState::LOAD:
-        __ CallRuntime(Runtime::kLoadContextSlot, 2);
-        __ push(r0);
-        break;
-
-      case CodeGenState::LOAD_TYPEOF_EXPR:
-        __ CallRuntime(Runtime::kLoadContextSlotNoReferenceError, 2);
-        __ push(r0);
-        break;
-
-      case CodeGenState::STORE:
-        // Storing a variable must keep the (new) value on the stack. This
-        // is necessary for compiling assignment expressions.
-        __ CallRuntime(Runtime::kStoreContextSlot, 3);
-        __ push(r0);
-        // result (TOS) is the value that was stored
-        break;
-
-      case CodeGenState::INIT_CONST:
-        // Same as STORE but ignores attribute (e.g. READ_ONLY) of
-        // context slot so that we can initialize const properties
-        // (introduced via eval("const foo = (some expr);")). Also,
-        // uses the current function context instead of the top
-        // context.
-        //
-        // Note that we must declare the foo upon entry of eval(),
-        // via a context slot declaration, but we cannot initialize
-        // it at the same time, because the const declaration may
-        // be at the end of the eval code (sigh...) and the const
-        // variable may have been used before (where its value is
-        // 'undefined'). Thus, we can only do the initialization
-        // when we actually encounter the expression and when the
-        // expression operands are defined and valid, and thus we
-        // need the split into 2 operations: declaration of the
-        // context slot followed by initialization.
-        __ CallRuntime(Runtime::kInitializeConstContextSlot, 3);
-        __ push(r0);
-        break;
+    if (access() == CodeGenState::LOAD) {
+      __ CallRuntime(Runtime::kLoadContextSlot, 2);
+    } else {
+      // CodeGenState::LOAD_TYPEOF_EXPR.

[iposva, 2008/09/10 18:01:44]

Please assert that the CodeGenState is LOAD_TYPEOF_EXPR. That way you ensure
that you are not entering here with UNDEFINED or a newly added state.

[Kevin Millikin (Chromium), 2008/09/11 07:15:55]

Done.  Earlier assert already ruled out UNDEFINED, but the point about new
states is valid.

+      __ CallRuntime(Runtime::kLoadContextSlotNoReferenceError, 2);
     }
+    __ push(r0);
 
   } else {
-    // Note: We would like to keep the assert below, but it fires because
-    // of some nasty code in LoadTypeofExpression() which should be removed...
+    // Note: We would like to keep the assert below, but it fires because of
+    // some nasty code in LoadTypeofExpression() which should be removed...
     // ASSERT(node->var()->mode() != Variable::DYNAMIC);
 
-    switch (access()) {
-      case CodeGenState::UNDEFINED:
-        UNREACHABLE();
-        break;
-
-      case CodeGenState::LOAD:  // fall through
-      case CodeGenState::LOAD_TYPEOF_EXPR:
-        // Special handling for locals allocated in registers.
-        __ ldr(r0, SlotOperand(node, r2));
-        __ push(r0);
-        if (node->var()->mode() == Variable::CONST) {
-          // Const slots may contain 'the hole' value (the constant hasn't
-          // been initialized yet) which needs to be converted into the
-          // 'undefined' value.
-          Comment cmnt(masm_, "[ Unhole const");
-          __ pop(r0);
-          __ cmp(r0, Operand(Factory::the_hole_value()));
-          __ mov(r0, Operand(Factory::undefined_value()), LeaveCC, eq);
-          __ push(r0);
-        }
-        break;
-
-      case CodeGenState::INIT_CONST: {
-        ASSERT(node->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");
-          Label L;
-          __ ldr(r2, SlotOperand(node, r2));
-          __ cmp(r2, Operand(Factory::the_hole_value()));
-          __ b(ne, &L);
-          // We must execute the store.
-          // r2 may be loaded with context; used below in RecordWrite.
-          __ ldr(r0, MemOperand(sp, 0));
-          __ str(r0, SlotOperand(node, r2));
-          if (node->type() == Slot::CONTEXT) {
-            // Skip write barrier if the written value is a smi.
-            Label exit;
-            __ tst(r0, Operand(kSmiTagMask));
-            __ b(eq, &exit);
-            // r2 is loaded with context when calling SlotOperand above.
-            int offset = FixedArray::kHeaderSize + node->index() * kPointerSize;
-            __ mov(r3, Operand(offset));
-            __ RecordWrite(r2, r3, r1);
-            __ bind(&exit);
-          }
-          __ bind(&L);
-        }
-        break;
-      }
-
-      case CodeGenState::STORE: {
-        // Storing a variable must keep the (new) value on the stack. This
-        // is necessary for compiling assignment expressions.
-        // Special handling for locals allocated in registers.
-        //
-        // 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.
-        // r2 may be loaded with context; used below in RecordWrite.
-        __ pop(r0);
-        __ str(r0, SlotOperand(node, r2));
-        __ push(r0);
-        if (node->type() == Slot::CONTEXT) {
-          // Skip write barrier if the written value is a smi.
-          Label exit;
-          __ tst(r0, Operand(kSmiTagMask));
-          __ b(eq, &exit);
-          // r2 is loaded with context when calling SlotOperand above.
-          int offset = FixedArray::kHeaderSize + node->index() * kPointerSize;
-          __ mov(r3, Operand(offset));
-          __ RecordWrite(r2, r3, r1);
-          __ bind(&exit);
-        }
-        break;
-      }
+    // Special handling for locals allocated in registers.
+    __ ldr(r0, SlotOperand(node, r2));
+    __ push(r0);
+    if (node->var()->mode() == Variable::CONST) {
+      // Const slots may contain 'the hole' value (the constant hasn't been
+      // initialized yet) which needs to be converted into the 'undefined'
+      // value.
+      Comment cmnt(masm_, "[ Unhole const");
+      __ pop(r0);
+      __ cmp(r0, Operand(Factory::the_hole_value()));
+      __ mov(r0, Operand(Factory::undefined_value()), LeaveCC, eq);
+      __ push(r0);
     }
   }
 }
 
 
-void ArmCodeGenerator::VisitVariableProxy(VariableProxy* proxy_node) {
+void ArmCodeGenerator::VisitVariableProxy(VariableProxy* node) {
   Comment cmnt(masm_, "[ VariableProxy");
-  Variable* node = proxy_node->var();
+  Variable* var_node = node->var();
 
-  Expression* x = node->rewrite();
-  if (x != NULL) {
-    Visit(x);
-    return;
-  }
-
-  ASSERT(node->is_global());
-  if (is_referenced()) {
-    if (node->AsProperty() != NULL) {
-      __ RecordPosition(node->AsProperty()->position());
+  Expression* expr = var_node->rewrite();
+  if (expr != NULL) {
+    Visit(expr);
+  } else {
+    ASSERT(var_node->is_global());
+    if (is_referenced()) {
+      if (var_node->AsProperty() != NULL) {
+        __ RecordPosition(var_node->AsProperty()->position());
+      }
+      GetReferenceProperty(new Literal(var_node->name()));
+    } else {
+      Reference property(this, node);
+      GetValue(&property);
     }
-    AccessReferenceProperty(new Literal(node->name()), access());
-
-  } else {
-    // All stores are through references.
-    ASSERT(access() != CodeGenState::STORE);
-    Reference property(this, proxy_node);
-    GetValue(&property);
   }
 }
 
 
 void ArmCodeGenerator::VisitLiteral(Literal* node) {
   Comment cmnt(masm_, "[ Literal");
   __ mov(r0, Operand(node->handle()));
   __ push(r0);
 }
 
@@ skipping 240 matching lines @@
 
   Load(node->exception());
   __ RecordPosition(node->position());
   __ CallRuntime(Runtime::kThrow, 1);
   __ push(r0);
 }
 
 
 void ArmCodeGenerator::VisitProperty(Property* node) {
   Comment cmnt(masm_, "[ Property");
+
   if (is_referenced()) {
     __ RecordPosition(node->position());
-    AccessReferenceProperty(node->key(), access());
-
+    GetReferenceProperty(node->key());
   } else {
-    // All stores are through references.
-    ASSERT(access() != CodeGenState::STORE);
     Reference property(this, node);
     __ RecordPosition(node->position());
     GetValue(&property);
   }
 }
 
 
 void ArmCodeGenerator::VisitCall(Call* node) {
   Comment cmnt(masm_, "[ Call");
 
@@ skipping 1089 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