Small cleanup of the code generator: make the static code gen...

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 40 matching lines @@
 // on the execution stack to represent the reference.
 
 class Reference BASE_EMBEDDED {
  public:
   enum Type { ILLEGAL = -1, EMPTY = 0, NAMED = 1, KEYED = 2 };
   Reference(ArmCodeGenerator* cgen, Expression* expression);
   ~Reference();
 
   Expression* expression() const  { return expression_; }
   Type type() const  { return type_; }
-  void set_type(Type value)  {
+  void set_type(Type value) {
     ASSERT(type_ == ILLEGAL);
     type_ = value;
   }
   int size() const  { return type_; }
 
   bool is_illegal() const  { return type_ == ILLEGAL; }
 
  private:
   ArmCodeGenerator* cgen_;
   Expression* expression_;
@@ skipping 59 matching lines @@
 
 // -----------------------------------------------------------------------------
 // ArmCodeGenerator
 
 class ArmCodeGenerator: public CodeGenerator {
  public:
   static Handle<Code> MakeCode(FunctionLiteral* fun,
                                Handle<Script> script,
                                bool is_eval);
 
-  MacroAssembler* masm()  { return masm_; }
+  MacroAssembler* masm() { return masm_; }
+
+  Scope* scope() const { return scope_; }
 
   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_;
 
   // Labels
   Label function_return_;
 
   // Construction/destruction
   ArmCodeGenerator(int buffer_size,
                    Handle<Script> script,
                    bool is_eval);
 
-  virtual ~ArmCodeGenerator()  { delete masm_; }
+  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);
 
   // 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);
   }
 
   static MemOperand ContextOperand(Register context, int index) {
     return MemOperand(context, Context::SlotOffset(index));
   }
 
-  static MemOperand ParameterOperand(Scope* scope, int index) {
+  static MemOperand ParameterOperand(const CodeGenerator* cgen, int index) {
+    int num_parameters = cgen->scope()->num_parameters();
     // index -2 corresponds to the activated closure, -1 corresponds
     // to the receiver
-    ASSERT(-2 <= index && index < scope->num_parameters());
-    int offset = (1 + scope->num_parameters() - index) * kPointerSize;
+    ASSERT(-2 <= index && index < num_parameters);
+    int offset = (1 + num_parameters - index) * kPointerSize;
     return MemOperand(fp, offset);
   }
 
   MemOperand ParameterOperand(int index) const {
-    return ParameterOperand(scope_, index);
+    return ParameterOperand(this, index);
   }
 
   MemOperand FunctionOperand() const {
     return MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset);
   }
 
-  static MemOperand SlotOperand(MacroAssembler* masm,
-                                Scope* scope,
+  static MemOperand SlotOperand(CodeGenerator* cgen,
                                 Slot* slot,
                                 Register tmp);
 
   MemOperand SlotOperand(Slot* slot, Register tmp) {
-    return SlotOperand(masm_, scope_, slot, tmp);
+    return SlotOperand(this, 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'
@@ skipping 15 matching lines @@
     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);
+    ref->expression()->GenerateStoreCode(this, ref, NOT_CONST_INIT);
   }
 
   // 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, CONST_INIT);
+    ref->expression()->GenerateStoreCode(this, ref, CONST_INIT);
   }
 
   // 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,
+  static void SetReferenceProperty(CodeGenerator* cgen,
                                    Reference* ref,
                                    Expression* key);
 
 
   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);
@@ skipping 86 matching lines @@
 
 CodeGenState::~CodeGenState() {
   ASSERT(owner_->state() == this);
   owner_->set_state(previous_);
 }
 
 
 // -----------------------------------------------------------------------------
 // ArmCodeGenerator implementation
 
-#define __  masm_->
-
+#define __ masm_->
 
 Handle<Code> ArmCodeGenerator::MakeCode(FunctionLiteral* flit,
                                         Handle<Script> script,
                                         bool is_eval) {
 #ifdef ENABLE_DISASSEMBLER
   bool print_code = FLAG_print_code && !Bootstrapper::IsActive();
 #endif  // ENABLE_DISASSEMBLER
 
 #ifdef DEBUG
   bool print_source = false;
@@ skipping 274 matching lines @@
   __ add(sp, sp, Operand((scope_->num_parameters() + 1) * kPointerSize));
   __ mov(pc, lr);
 
   // Code generation state must be reset.
   scope_ = NULL;
   ASSERT(!has_cc());
   ASSERT(state_ == NULL);
 }
 
 
-MemOperand ArmCodeGenerator::SlotOperand(MacroAssembler* masm,
-                                         Scope* scope,
+#undef __
+#define __ masm->
+
+MemOperand ArmCodeGenerator::SlotOperand(CodeGenerator* cgen,
                                          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(scope, index);
+      return ParameterOperand(cgen, index);
 
     case Slot::LOCAL: {
       ASSERT(0 <= index &&
-             index < scope->num_stack_slots() &&
+             index < cgen->scope()->num_stack_slots() &&
              index >= 0);
       int local_offset = JavaScriptFrameConstants::kLocal0Offset -
                          index * kPointerSize;
       return MemOperand(fp, local_offset);
     }
 
     case Slot::CONTEXT: {
+      MacroAssembler* masm = cgen->masm();
       // 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 =
+          cgen->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.)
-        masm->ldr(tmp, ContextOperand(context, Context::CLOSURE_INDEX));
+        __ ldr(tmp, ContextOperand(context, Context::CLOSURE_INDEX));
         // Load the function context (which is the incoming, outer context).
-        masm->ldr(tmp, FieldMemOperand(tmp, JSFunction::kContextOffset));
+        __ 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...)
-      masm->ldr(tmp, ContextOperand(context, Context::FCONTEXT_INDEX));
+      __ ldr(tmp, ContextOperand(context, Context::FCONTEXT_INDEX));
       return ContextOperand(tmp, index);
     }
 
     default:
       UNREACHABLE();
       return MemOperand(r0, 0);
   }
 }
 
 
+#undef __
+#define __ masm_->
+
 // Loads a value on the stack. If it is a boolean value, the result may have
 // been (partially) translated into branches, or it may have set the condition
 // code register. If force_cc is set, the value is forced to set the condition
 // code register and no value is pushed. If the condition code register was set,
 // 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) {
@@ skipping 144 matching lines @@
   if (size <= 0) {
     // Do nothing. No popping is necessary.
   } else {
     __ pop(r0);
     __ add(sp, sp, Operand(size * kPointerSize));
     __ push(r0);
   }
 }
 
 
-void Property::GenerateStoreCode(MacroAssembler* masm,
-                                 Scope* scope,
+#undef __
+#define __ masm->
+
+void Property::GenerateStoreCode(CodeGenerator* cgen,
                                  Reference* ref,
                                  InitState init_state) {
+  MacroAssembler* masm = cgen->masm();
   Comment cmnt(masm, "[ Store to Property");
-  masm->RecordPosition(position());
-  ArmCodeGenerator::SetReferenceProperty(masm, ref, key());
+  __ RecordPosition(position());
+  ArmCodeGenerator::SetReferenceProperty(cgen, ref, key());
 }
 
 
-void VariableProxy::GenerateStoreCode(MacroAssembler* masm,
-                                      Scope* scope,
+void VariableProxy::GenerateStoreCode(CodeGenerator* cgen,
                                       Reference* ref,
                                       InitState init_state) {
+  MacroAssembler* masm = cgen->masm();
   Comment cmnt(masm, "[ Store to VariableProxy");
   Variable* node = var();
 
   Expression* expr = node->rewrite();
   if (expr != NULL) {
-    expr->GenerateStoreCode(masm, scope, ref, init_state);
+    expr->GenerateStoreCode(cgen, ref, init_state);
   } else {
     ASSERT(node->is_global());
     if (node->AsProperty() != NULL) {
-      masm->RecordPosition(node->AsProperty()->position());
+      __ RecordPosition(node->AsProperty()->position());
     }
-    ArmCodeGenerator::SetReferenceProperty(masm, ref,
-                                           new Literal(node->name()));
+    Expression* key = new Literal(node->name());
+    ArmCodeGenerator::SetReferenceProperty(cgen, ref, key);
   }
 }
 
 
-void Slot::GenerateStoreCode(MacroAssembler* masm,
-                             Scope* scope,
+void Slot::GenerateStoreCode(CodeGenerator* cgen,
                              Reference* ref,
                              InitState init_state) {
+  MacroAssembler* masm = cgen->masm();
   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);
+    __ push(cp);
+    __ mov(r0, Operand(var()->name()));
+    __ push(r0);
 
     if (init_state == 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);
+      __ CallRuntime(Runtime::kInitializeConstContextSlot, 3);
     } else {
-      masm->CallRuntime(Runtime::kStoreContextSlot, 3);
+      __ 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);
+    __ push(r0);
 
   } else {
     ASSERT(var()->mode() != Variable::DYNAMIC);
 
     Label exit;
     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);
+      __ ldr(r2, ArmCodeGenerator::SlotOperand(cgen, this, r2));
+      __ cmp(r2, Operand(Factory::the_hole_value()));
+      __ 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);
+    __ pop(r0);
+    __ str(r0, ArmCodeGenerator::SlotOperand(cgen, this, r2));
+    __ 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);
+      __ tst(r0, Operand(kSmiTagMask));
+      __ 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);
+      __ mov(r3, Operand(offset));
+      __ 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 (init_state == CONST_INIT || type() == Slot::CONTEXT) {
-      masm->bind(&exit);
+      __ bind(&exit);
     }
   }
 }
 
 
+#undef __
+#define __ masm_->
+
 // 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 21 matching lines @@
   __ CallRuntime(Runtime::kToBool, 1);
 
   // Convert result (r0) to condition code
   __ cmp(r0, Operand(Factory::false_value()));
 
   cc_reg_ = ne;
 }
 
 
 #undef __
-#define __  masm->
-
+#define __ masm->
 
 class GetPropertyStub : public CodeStub {
  public:
   GetPropertyStub() { }
 
  private:
   Major MajorKey() { return GetProperty; }
   int MinorKey() { return 0; }
   void Generate(MacroAssembler* masm);
 
@@ skipping 920 matching lines @@
 
   if (!is_length_) {
     __ bind(&slow);
     __ push(r1);
     __ TailCallRuntime(ExternalReference(Runtime::kGetArgumentsProperty), 1);
   }
 }
 
 
 #undef __
-#define __  masm_->
-
+#define __ masm_->
 
 void ArmCodeGenerator::GetReferenceProperty(Expression* key) {
   ASSERT(!ref()->is_illegal());
   Reference::Type type = ref()->type();
 
   // 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).
@@ skipping 19 matching lines @@
     ASSERT(type == Reference::KEYED);
 
     // TODO(1224671): Implement inline caching for keyed loads as on ia32.
     GetPropertyStub stub;
     __ CallStub(&stub);
   }
   __ push(r0);
 }
 
 
-void ArmCodeGenerator::SetReferenceProperty(MacroAssembler* masm,
+#undef __
+#define __ masm->
+
+void ArmCodeGenerator::SetReferenceProperty(CodeGenerator* cgen,
                                             Reference* ref,
                                             Expression* key) {
   ASSERT(!ref->is_illegal());
-  Reference::Type type = ref->type();
+  MacroAssembler* masm = cgen->masm();
 
-  if (type == Reference::NAMED) {
+  if (ref->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

[Kasper Lund, 2008/10/02 08:57:58]

Shouldn't this be __?

     // Setup the name register.
     masm->mov(r2, Operand(name));
     Handle<Code> ic(Builtins::builtin(Builtins::StoreIC_Initialize));
     masm->Call(ic, RelocInfo::CODE_TARGET);
 
   } else {
     // Access keyed property.
-    ASSERT(type == Reference::KEYED);
+    ASSERT(ref->type() == Reference::KEYED);
 
     masm->pop(r0);  // value
     SetPropertyStub stub;
     masm->CallStub(&stub);
   }
   masm->push(r0);
 }
 
 
+#undef __
+#define __ masm_->
+
 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 2452 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