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

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 46 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(Ia32CodeGenerator* 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:
   Ia32CodeGenerator* cgen_;
   Expression* expression_;
@@ skipping 59 matching lines @@
 
 // -----------------------------------------------------------------------------
 // Ia32CodeGenerator
 
 class Ia32CodeGenerator: 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_;
   bool is_inside_try_;
   int break_stack_height_;
 
   // Labels
   Label function_return_;
 
   // Construction/destruction
   Ia32CodeGenerator(int buffer_size,
                     Handle<Script> script,
                     bool is_eval);
-  virtual ~Ia32CodeGenerator()  { delete masm_; }
+  virtual ~Ia32CodeGenerator() { 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_ >= 0; }
   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
   Operand GlobalObject() const {
     return ContextOperand(esi, Context::GLOBAL_INDEX);
   }
 
   // Support functions for accessing parameters.  Static versions can
   // require some code generator state to be passed in as arguments.
-  static Operand ParameterOperand(Scope* scope, int index) {
-    ASSERT(-2 <= index && index < scope->num_parameters());
-    return Operand(ebp, (1 + scope->num_parameters() - index) * kPointerSize);
+  static Operand ParameterOperand(const CodeGenerator* cgen, int index) {

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

Extra whitespace at end of line?

+    int num_parameters = cgen->scope()->num_parameters();
+    ASSERT(-2 <= index && index < num_parameters);
+    return Operand(ebp, (1 + num_parameters - index) * kPointerSize);
   }
 
   Operand ParameterOperand(int index) const {
-    return ParameterOperand(scope_, index);
+    return ParameterOperand(this, index);
   }
 
   Operand ReceiverOperand() const { return ParameterOperand(-1); }
 
   Operand FunctionOperand() const {
     return Operand(ebp, JavaScriptFrameConstants::kFunctionOffset);
   }
 
   static Operand ContextOperand(Register context, int index) {
     return Operand(context, Context::SlotOffset(index));
   }
 
-  static Operand SlotOperand(MacroAssembler* masm,
-                             Scope* scope,
+  static Operand SlotOperand(CodeGenerator* cgen,
                              Slot* slot,
                              Register tmp);
 
   Operand 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();
@@ skipping 17 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);
   }
 
   // Same as SetValue, used to set the initial value of a constant.
   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,
       const OverwriteMode overwrite_mode = NO_OVERWRITE);
   void Comparison(Condition cc, bool strict = false);
 
@@ skipping 129 matching lines @@
 
 CodeGenState::~CodeGenState() {
   ASSERT(owner_->state() == this);
   owner_->set_state(previous_);
 }
 
 
 // -----------------------------------------------------------------------------
 // Ia32CodeGenerator implementation
 
-#define __  masm_->
-
+#define __ masm_->
 
 Handle<Code> Ia32CodeGenerator::MakeCode(FunctionLiteral* flit,
                                          Handle<Script> script,
                                          bool is_eval) {
 #ifdef ENABLE_DISASSEMBLER
   bool print_code = FLAG_print_code && !Bootstrapper::IsActive();
 #endif
 
 #ifdef DEBUG
   bool print_source = false;
@@ skipping 286 matching lines @@
     }
   }
 
   // Code generation state must be reset.
   scope_ = NULL;
   ASSERT(!has_cc());
   ASSERT(state_ == NULL);
 }
 
 
-Operand Ia32CodeGenerator::SlotOperand(MacroAssembler* masm,
-                                       Scope* scope,
+#undef __
+#define __ masm->
+
+Operand Ia32CodeGenerator::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);
+    case Slot::PARAMETER: return ParameterOperand(cgen, index);
 
     case Slot::LOCAL: {
-      ASSERT(0 <= index && index < scope->num_stack_slots());
+      ASSERT(0 <= index && index < cgen->scope()->num_stack_slots());
       const int kLocal0Offset = JavaScriptFrameConstants::kLocal0Offset;
       return Operand(ebp, kLocal0Offset - index * kPointerSize);
     }
 
     case Slot::CONTEXT: {
+      MacroAssembler* masm = cgen->masm();
       // Follow the context chain if necessary.
       ASSERT(!tmp.is(esi));  // do not overwrite context register
       Register context = esi;
-      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->mov(tmp, ContextOperand(context, Context::CLOSURE_INDEX));
+        __ mov(tmp, ContextOperand(context, Context::CLOSURE_INDEX));
         // Load the function context (which is the incoming, outer context).
-        masm->mov(tmp, FieldOperand(tmp, JSFunction::kContextOffset));
+        __ mov(tmp, FieldOperand(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->mov(tmp, ContextOperand(context, Context::FCONTEXT_INDEX));
+      __ mov(tmp, ContextOperand(context, Context::FCONTEXT_INDEX));
       return ContextOperand(tmp, index);
     }
 
     default:
       UNREACHABLE();
       return Operand(eax);
   }
 }
 
 
+#undef __
+#define __ masm_->
+
 // Loads a value on TOS. 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 Ia32CodeGenerator::LoadCondition(Expression* x,
                                       CodeGenState::AccessType access,
                                       Label* true_target,
                                       Label* false_target,
                                       bool force_cc) {
@@ skipping 144 matching lines @@
     __ pop(eax);
     __ mov(TOS, eax);
   } else {
     __ pop(eax);
     __ add(Operand(esp), Immediate(size * kPointerSize));
     __ push(eax);
   }
 }
 
 
-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());
-  Ia32CodeGenerator::SetReferenceProperty(masm, ref, key());
+  __ RecordPosition(position());
+  Ia32CodeGenerator::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());
     }
-    Ia32CodeGenerator::SetReferenceProperty(masm, ref,
-                                            new Literal(node->name()));
+    Expression* key = new Literal(node->name());
+    Ia32CodeGenerator::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(Operand(esi));
-    masm->push(Immediate(var()->name()));
+    __ push(esi);
+    __ push(Immediate(var()->name()));
 
     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(eax);
+    __ push(eax);
 
   } 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->mov(eax, Ia32CodeGenerator::SlotOperand(masm, scope, this, ecx));
-      masm->cmp(eax, Factory::the_hole_value());
-      masm->j(not_equal, &exit);
+      __ mov(eax, Ia32CodeGenerator::SlotOperand(cgen, this, ecx));
+      __ cmp(eax, Factory::the_hole_value());
+      __ j(not_equal, &exit);
     }
 
     // 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.
+    __ pop(eax);
+    __ mov(Ia32CodeGenerator::SlotOperand(cgen, this, ecx), eax);
+    __ 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);
+      __ 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 (init_state == CONST_INIT) masm->bind(&exit);
+    if (init_state == CONST_INIT) __ bind(&exit);
   }
 }
 
 
-#undef __
-#define __  masm->
-
 class ToBooleanStub: public CodeStub {
  public:
   ToBooleanStub() { }
 
   void Generate(MacroAssembler* masm);
 
  private:
 
   Major MajorKey() { return ToBoolean; }
 
@@ skipping 58 matching lines @@
 
   // Return 1/0 for true/false in eax.
   __ bind(&true_result);
   __ mov(eax, 1);
   __ ret(1 * kPointerSize);
   __ bind(&false_result);
   __ mov(eax, 0);
   __ ret(1 * kPointerSize);
 }
 
+
 #undef __
-#define __  masm_->
-
+#define __ masm_->
 
 // ECMA-262, section 9.2, page 30: ToBoolean(). Pop the top of stack and
 // convert it to a boolean in the condition code register or jump to
 // 'false_target'/'true_target' as appropriate.
 void Ia32CodeGenerator::ToBoolean(Label* true_target, Label* false_target) {
   Comment cmnt(masm_, "[ ToBoolean");
 
   // The value to convert should be popped from the stack.
   __ pop(eax);
 
@@ skipping 65 matching lines @@
       ASSERT(var->is_global());
       __ call(ic, RelocInfo::CODE_TARGET_CONTEXT);
     } else {
       __ call(ic, RelocInfo::CODE_TARGET);
     }
   }
   __ push(eax);  // IC call leaves result in eax, push it out
 }
 
 
-void Ia32CodeGenerator::SetReferenceProperty(MacroAssembler* masm,
+#undef __
+#define __ masm->
+
+void Ia32CodeGenerator::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.
     Handle<Code> ic(Builtins::builtin(Builtins::StoreIC_Initialize));
     // TODO(1222589): Make the IC grab the values from the stack.
-    masm->pop(eax);
+    __ pop(eax);
     // Setup the name register.
-    masm->Set(ecx, Immediate(name));
-    masm->call(ic, RelocInfo::CODE_TARGET);
+    __ Set(ecx, Immediate(name));
+    __ call(ic, RelocInfo::CODE_TARGET);
   } else {
     // Access keyed property.
-    ASSERT(type == Reference::KEYED);
+    ASSERT(ref->type() == Reference::KEYED);
 
     // Call IC code.
     Handle<Code> ic(Builtins::builtin(Builtins::KeyedStoreIC_Initialize));
     // TODO(1222589): Make the IC grab the values from the stack.
-    masm->pop(eax);
-    masm->call(ic, RelocInfo::CODE_TARGET);
+    __ pop(eax);
+    __ call(ic, RelocInfo::CODE_TARGET);
   }
-  masm->push(eax);  // IC call leaves result in eax, push it out
+  __ push(eax);  // IC call leaves result in eax, push it out
 }
 
 
-#undef __
-#define __  masm->
-
-
 class FloatingPointHelper : public AllStatic {
  public:
   // Code pattern for loading floating point values. Input values must
   // be either smi or heap number objects (fp values). Requirements:
   // operand_1 on TOS+1 , operand_2 on TOS+2; Returns operands as
   // floating point numbers on FPU stack.
   static void LoadFloatOperands(MacroAssembler* masm, Register scratch);
   // Test if operands are smi or number objects (fp). Requirements:
   // operand_1 in eax, operand_2 in edx; falls through on float
   // operands, jumps to the non_float label otherwise.
@@ skipping 489 matching lines @@
   __ j(zero, &done);  // argument in eax is OK
   __ mov(scratch, FieldOperand(eax, HeapObject::kMapOffset));
   __ cmp(scratch, Factory::heap_number_map());
   __ j(not_equal, non_float);  // argument in eax is not a number -> NaN
 
   // Fall-through: Both operands are numbers.
   __ bind(&done);
 }
 
 
-#undef __
-#define __  masm->
-
-
 void UnarySubStub::Generate(MacroAssembler* masm) {
   Label undo;
   Label slow;
   Label done;
   Label try_float;
 
   // Check whether the value is a smi.
   __ test(eax, Immediate(kSmiTagMask));
   __ j(not_zero, &try_float, not_taken);
 
@@ skipping 32 matching lines @@
   __ mov(edx, Operand(eax));
   // edx: operand
   FloatingPointHelper::AllocateHeapNumber(masm, &undo, ebx, ecx);
   // eax: allocated 'empty' number
   __ fld_d(FieldOperand(edx, HeapNumber::kValueOffset));
   __ fchs();
   __ fstp_d(FieldOperand(eax, HeapNumber::kValueOffset));
 
   __ bind(&done);
 
-  masm->StubReturn(1);
+  __ StubReturn(1);
 }
 
 
 class ArgumentsAccessStub: public CodeStub {
  public:
   explicit ArgumentsAccessStub(bool is_length) : is_length_(is_length) { }
 
  private:
   bool is_length_;
 
@@ skipping 78 matching lines @@
   // Slow-case: Handle non-smi or out-of-bounds access to arguments
   // by calling the runtime system.
   if (!is_length_) {
     __ bind(&slow);
     __ TailCallRuntime(ExternalReference(Runtime::kGetArgumentsProperty), 1);
   }
 }
 
 
 #undef __
-#define __  masm_->
-
+#define __ masm_->
 
 void Ia32CodeGenerator::GenericBinaryOperation(Token::Value op,
                                                OverwriteMode overwrite_mode) {
   Comment cmnt(masm_, "[ BinaryOperation");
   Comment cmnt_token(masm_, Token::String(op));
   switch (op) {
     case Token::ADD:
     case Token::SUB:
     case Token::MUL:
     case Token::DIV:
@@ skipping 417 matching lines @@
         __ push(eax);
       }
       GenericBinaryOperation(op, overwrite_mode);
       break;
     }
   }
 }
 
 
 #undef __
-#define __  masm->
+#define __ masm->
 
 class CompareStub: public CodeStub {
  public:
   CompareStub(Condition cc, bool strict) : cc_(cc), strict_(strict) { }
 
   void Generate(MacroAssembler* masm);
 
  private:
   Condition cc_;
   bool strict_;
@@ skipping 95 matching lines @@
   __ pop(eax);
   __ push(Immediate(Smi::FromInt(0)));
   __ push(eax);
 
   // Do tail-call to runtime routine.
   __ TailCallRuntime(ExternalReference(Runtime::kStackGuard), 1);
 }
 
 
 #undef __
-#define __  masm_->
-
+#define __ masm_->
 
 void Ia32CodeGenerator::Comparison(Condition cc, bool strict) {
   // Strict only makes sense for equality comparisons.
   ASSERT(!strict || cc == equal);
 
   // Implement '>' and '<=' by reversal to obtain ECMA-262 conversion order.
   if (cc == greater || cc == less_equal) {
     cc = ReverseCondition(cc);
     __ pop(edx);
     __ pop(eax);
@@ skipping 89 matching lines @@
 
 #ifdef DEBUG
   void Print() { PrintF("CallFunctionStub (args %d)\n", argc_); }
 #endif
 
   Major MajorKey() { return CallFunction; }
   int MinorKey() { return argc_; }
 };
 
 
+#undef __
+#define __ masm->
+
 void CallFunctionStub::Generate(MacroAssembler* masm) {
   Label slow;
 
   // Get the function to call from the stack.
   // +2 ~ receiver, return address
-  masm->mov(edi, Operand(esp, (argc_ + 2) * kPointerSize));
+  __ mov(edi, Operand(esp, (argc_ + 2) * kPointerSize));
 
   // Check that the function really is a JavaScript function.
-  masm->test(edi, Immediate(kSmiTagMask));
-  masm->j(zero, &slow, not_taken);
+  __ test(edi, Immediate(kSmiTagMask));
+  __ j(zero, &slow, not_taken);
   // Get the map.
-  masm->mov(ecx, FieldOperand(edi, HeapObject::kMapOffset));
-  masm->movzx_b(ecx, FieldOperand(ecx, Map::kInstanceTypeOffset));
-  masm->cmp(ecx, JS_FUNCTION_TYPE);
-  masm->j(not_equal, &slow, not_taken);
+  __ mov(ecx, FieldOperand(edi, HeapObject::kMapOffset));
+  __ movzx_b(ecx, FieldOperand(ecx, Map::kInstanceTypeOffset));
+  __ cmp(ecx, JS_FUNCTION_TYPE);
+  __ j(not_equal, &slow, not_taken);
 
   // Fast-case: Just invoke the function.
   ParameterCount actual(argc_);
-  masm->InvokeFunction(edi, actual, JUMP_FUNCTION);
+  __ InvokeFunction(edi, actual, JUMP_FUNCTION);
 
   // Slow-case: Non-function called.
-  masm->bind(&slow);
-  masm->Set(eax, Immediate(argc_));
-  masm->Set(ebx, Immediate(0));
-  masm->GetBuiltinEntry(edx, Builtins::CALL_NON_FUNCTION);
+  __ bind(&slow);
+  __ Set(eax, Immediate(argc_));
+  __ Set(ebx, Immediate(0));
+  __ GetBuiltinEntry(edx, Builtins::CALL_NON_FUNCTION);
   Handle<Code> adaptor(Builtins::builtin(Builtins::ArgumentsAdaptorTrampoline));
-  masm->jmp(adaptor, RelocInfo::CODE_TARGET);
+  __ jmp(adaptor, RelocInfo::CODE_TARGET);
 }
 
 
+#undef __
+#define __ masm_->
+
 // Call the function just below TOS on the stack with the given
 // arguments. The receiver is the TOS.
 void Ia32CodeGenerator::CallWithArguments(ZoneList<Expression*>* args,
                                           int position) {
   // Push the arguments ("left-to-right") on the stack.
   for (int i = 0; i < args->length(); i++) Load(args->at(i));
 
   // Record the position for debugging purposes.
   __ RecordPosition(position);
 
@@ skipping 1986 matching lines @@
   virtual void Generate();
 
  private:
   bool is_postfix_;
   bool is_increment_;
   int result_offset_;
 };
 
 
 #undef __
-#define __  masm->
-
+#define __ masm->
 
 class RevertToNumberStub: public CodeStub {
  public:
   explicit RevertToNumberStub(bool is_increment)
      :  is_increment_(is_increment) { }
 
  private:
   bool is_increment_;
 
   Major MajorKey() { return RevertToNumber; }
@@ skipping 83 matching lines @@
   __ pop(ecx);
   __ push(eax);
   __ push(ecx);
   Builtins::JavaScript builtin = is_increment_ ? Builtins::INC : Builtins::DEC;
   __ InvokeBuiltin(builtin, JUMP_FUNCTION);
   // Code never returns due to JUMP_FUNCTION.
 }
 
 
 #undef __
-#define __  masm_->
-
+#define __ masm_->
 
 void CountOperationDeferred::Generate() {
   if (is_postfix_) {
     RevertToNumberStub to_number_stub(is_increment_);
     __ CallStub(&to_number_stub);
   }
   CounterOpStub stub(result_offset_, is_postfix_, is_increment_);
   __ CallStub(&stub);
 }
 
@@ skipping 416 matching lines @@
   // Avoid using the leave instruction here, because it is too
   // short. We need the return sequence to be a least the size of a
   // call instruction to support patching the exit code in the
   // debugger. See VisitReturnStatement for the full return sequence.
   __ mov(esp, Operand(ebp));
   __ pop(ebp);
 }
 
 
 #undef __
-#define __  masm->
-
+#define __ masm->
 
 void CEntryStub::GenerateThrowTOS(MacroAssembler* masm) {
   ASSERT(StackHandlerConstants::kSize == 6 * kPointerSize);  // adjust this code
   ExternalReference handler_address(Top::k_handler_address);
   __ mov(edx, Operand::StaticVariable(handler_address));
   __ mov(ecx, Operand(edx, -1 * kPointerSize));  // get next in chain
   __ mov(Operand::StaticVariable(handler_address), ecx);
   __ mov(esp, Operand(edx));
   __ pop(edi);
   __ pop(ebp);
@@ skipping 287 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