Simplify deferred code by removing some unneeded or redundant stuff.

src/ia32/codegen-ia32.cc

 // Copyright 2006-2009 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 300 matching lines @@
   loop_nesting_ -= fun->loop_nesting();
 
   // Code generation state must be reset.
   ASSERT(state_ == NULL);
   ASSERT(loop_nesting() == 0);
   ASSERT(!function_return_is_shadowed_);
   function_return_.Unuse();
   DeleteFrame();
 
   // Process any deferred code using the register allocator.
-  if (HasStackOverflow()) {
-    ClearDeferred();
-  } else {
+  if (!HasStackOverflow()) {
     HistogramTimerScope deferred_timer(&Counters::deferred_code_generation);
     JumpTarget::set_compiling_deferred_code(true);
     ProcessDeferred();
     JumpTarget::set_compiling_deferred_code(false);
   }
 
   // There is no need to delete the register allocator, it is a
   // stack-allocated local.
   allocator_ = NULL;
   scope_ = NULL;
@@ skipping 443 matching lines @@
   }
 }
 
 
 // A deferred code class implementing binary operations on likely smis.
 // This class generates both inline code and deferred code.
 // The fastest path is implemented inline.  Deferred code calls
 // the GenericBinaryOpStub stub for slow cases.
 class DeferredInlineBinaryOperation: public DeferredCode {
  public:
-  DeferredInlineBinaryOperation(CodeGenerator* generator,
-                                Token::Value op,
+  DeferredInlineBinaryOperation(Token::Value op,
                                 OverwriteMode mode,
                                 GenericBinaryFlags flags)
-      : DeferredCode(generator), stub_(op, mode, flags), op_(op) {
+      : stub_(op, mode, flags), op_(op) {
     set_comment("[ DeferredInlineBinaryOperation");
   }
 
   // Consumes its arguments, left and right, leaving them invalid.
   Result GenerateInlineCode(Result* left, Result* right);
 
   virtual void Generate();
 
  private:
   GenericBinaryOpStub stub_;
   Token::Value op_;
 };
 
 
 void DeferredInlineBinaryOperation::Generate() {
   Result left;
   Result right;
   enter()->Bind(&left, &right);
-  generator()->frame()->Push(&left);
-  generator()->frame()->Push(&right);
-  Result answer = generator()->frame()->CallStub(&stub_, 2);
+  cgen()->frame()->Push(&left);
+  cgen()->frame()->Push(&right);
+  Result answer = cgen()->frame()->CallStub(&stub_, 2);
   exit_.Jump(&answer);
 }
 
 
 void CodeGenerator::GenericBinaryOperation(Token::Value op,
                                            SmiAnalysis* type,
                                            OverwriteMode overwrite_mode) {
   Comment cmnt(masm_, "[ BinaryOperation");
   Comment cmnt_token(masm_, Token::String(op));
 
@@ skipping 183 matching lines @@
 }
 
 
 void CodeGenerator::LikelySmiBinaryOperation(Token::Value op,
                                              Result* left,
                                              Result* right,
                                              OverwriteMode overwrite_mode) {
   // Implements a binary operation using a deferred code object
   // and some inline code to operate on smis quickly.
   DeferredInlineBinaryOperation* deferred =
-      new DeferredInlineBinaryOperation(this, op, overwrite_mode,
-                                        SMI_CODE_INLINED);
+      new DeferredInlineBinaryOperation(op, overwrite_mode, SMI_CODE_INLINED);
   // Generate the inline code that handles some smi operations,
   // and jumps to the deferred code for everything else.
   Result answer = deferred->GenerateInlineCode(left, right);
   deferred->BindExit(&answer);
   frame_->Push(&answer);
 }
 
 
 class DeferredInlineSmiOperation: public DeferredCode {
  public:
-  DeferredInlineSmiOperation(CodeGenerator* generator,
-                             Token::Value op,
+  DeferredInlineSmiOperation(Token::Value op,
                              Smi* value,
                              OverwriteMode overwrite_mode)
-      : DeferredCode(generator),
-        op_(op),
+      : op_(op),
         value_(value),
         overwrite_mode_(overwrite_mode) {
     set_comment("[ DeferredInlineSmiOperation");
   }
 
   virtual void Generate();
 
  private:
   Token::Value op_;
   Smi* value_;
   OverwriteMode overwrite_mode_;
 };
 
 
 void DeferredInlineSmiOperation::Generate() {
   Result left;
   enter()->Bind(&left);
-  generator()->frame()->Push(&left);
-  generator()->frame()->Push(value_);
+  cgen()->frame()->Push(&left);
+  cgen()->frame()->Push(value_);
   GenericBinaryOpStub igostub(op_, overwrite_mode_, SMI_CODE_INLINED);
-  Result answer = generator()->frame()->CallStub(&igostub, 2);
+  Result answer = cgen()->frame()->CallStub(&igostub, 2);
   exit_.Jump(&answer);
 }
 
 
 class DeferredInlineSmiOperationReversed: public DeferredCode {
  public:
-  DeferredInlineSmiOperationReversed(CodeGenerator* generator,
-                                     Token::Value op,
+  DeferredInlineSmiOperationReversed(Token::Value op,
                                      Smi* value,
                                      OverwriteMode overwrite_mode)
-      : DeferredCode(generator),
-        op_(op),
+      : op_(op),
         value_(value),
         overwrite_mode_(overwrite_mode) {
     set_comment("[ DeferredInlineSmiOperationReversed");
   }
 
   virtual void Generate();
 
  private:
   Token::Value op_;
   Smi* value_;
   OverwriteMode overwrite_mode_;
 };
 
 
 void DeferredInlineSmiOperationReversed::Generate() {
   Result right;
   enter()->Bind(&right);
-  generator()->frame()->Push(value_);
-  generator()->frame()->Push(&right);
+  cgen()->frame()->Push(value_);
+  cgen()->frame()->Push(&right);
   GenericBinaryOpStub igostub(op_, overwrite_mode_, SMI_CODE_INLINED);
-  Result answer = generator()->frame()->CallStub(&igostub, 2);
+  Result answer = cgen()->frame()->CallStub(&igostub, 2);
   exit_.Jump(&answer);
 }
 
 
 class DeferredInlineSmiAdd: public DeferredCode {
  public:
-  DeferredInlineSmiAdd(CodeGenerator* generator,
-                       Smi* value,
+  DeferredInlineSmiAdd(Smi* value,
                        OverwriteMode overwrite_mode)
-      : DeferredCode(generator),
-        value_(value),
+      : value_(value),
         overwrite_mode_(overwrite_mode) {
     set_comment("[ DeferredInlineSmiAdd");
   }
 
   virtual void Generate();
 
  private:
   Smi* value_;
   OverwriteMode overwrite_mode_;
 };
 
 
-void DeferredInlineSmiAdd::Generate() {
-  // Undo the optimistic add operation and call the shared stub.
-  Result left;  // Initially left + value_.
-  enter()->Bind(&left);
-  left.ToRegister();
-  generator()->frame()->Spill(left.reg());
-  __ sub(Operand(left.reg()), Immediate(value_));
-  generator()->frame()->Push(&left);
-  generator()->frame()->Push(value_);
-  GenericBinaryOpStub igostub(Token::ADD, overwrite_mode_, SMI_CODE_INLINED);
-  Result answer = generator()->frame()->CallStub(&igostub, 2);
-  exit_.Jump(&answer);
-}
-
-
 class DeferredInlineSmiAddReversed: public DeferredCode {
  public:
-  DeferredInlineSmiAddReversed(CodeGenerator* generator,
-                               Smi* value,
+  DeferredInlineSmiAddReversed(Smi* value,
                                OverwriteMode overwrite_mode)
-      : DeferredCode(generator),
-        value_(value),
+      : value_(value),
         overwrite_mode_(overwrite_mode) {
     set_comment("[ DeferredInlineSmiAddReversed");
   }
 
   virtual void Generate();
 
  private:
   Smi* value_;
   OverwriteMode overwrite_mode_;
 };
 
 
-void DeferredInlineSmiAddReversed::Generate() {
-  // Undo the optimistic add operation and call the shared stub.
-  Result right;  // Initially value_ + right.
-  enter()->Bind(&right);
-  right.ToRegister();
-  generator()->frame()->Spill(right.reg());
-  __ sub(Operand(right.reg()), Immediate(value_));
-  generator()->frame()->Push(value_);
-  generator()->frame()->Push(&right);
-  GenericBinaryOpStub igostub(Token::ADD, overwrite_mode_, SMI_CODE_INLINED);
-  Result answer = generator()->frame()->CallStub(&igostub, 2);
-  exit_.Jump(&answer);
-}
-
-
 class DeferredInlineSmiSub: public DeferredCode {
  public:
-  DeferredInlineSmiSub(CodeGenerator* generator,
-                       Smi* value,
+  DeferredInlineSmiSub(Smi* value,
                        OverwriteMode overwrite_mode)
-      : DeferredCode(generator),
-        value_(value),
+      : value_(value),
         overwrite_mode_(overwrite_mode) {
     set_comment("[ DeferredInlineSmiSub");
   }
 
   virtual void Generate();
 
  private:
   Smi* value_;
   OverwriteMode overwrite_mode_;
 };
 
 
+#undef __
+#define __ ACCESS_MASM(cgen()->masm())
+
+
+void DeferredInlineSmiAdd::Generate() {
+  // Undo the optimistic add operation and call the shared stub.
+  Result left;  // Initially left + value_.
+  enter()->Bind(&left);
+  left.ToRegister();
+  cgen()->frame()->Spill(left.reg());
+  __ sub(Operand(left.reg()), Immediate(value_));
+  cgen()->frame()->Push(&left);
+  cgen()->frame()->Push(value_);
+  GenericBinaryOpStub igostub(Token::ADD, overwrite_mode_, SMI_CODE_INLINED);
+  Result answer = cgen()->frame()->CallStub(&igostub, 2);
+  exit_.Jump(&answer);
+}
+
+
+void DeferredInlineSmiAddReversed::Generate() {
+  // Undo the optimistic add operation and call the shared stub.
+  Result right;  // Initially value_ + right.
+  enter()->Bind(&right);
+  right.ToRegister();
+  cgen()->frame()->Spill(right.reg());
+  __ sub(Operand(right.reg()), Immediate(value_));
+  cgen()->frame()->Push(value_);
+  cgen()->frame()->Push(&right);
+  GenericBinaryOpStub igostub(Token::ADD, overwrite_mode_, SMI_CODE_INLINED);
+  Result answer = cgen()->frame()->CallStub(&igostub, 2);
+  exit_.Jump(&answer);
+}
+
+
 void DeferredInlineSmiSub::Generate() {
   // Undo the optimistic sub operation and call the shared stub.
   Result left;  // Initially left - value_.
   enter()->Bind(&left);
   left.ToRegister();
-  generator()->frame()->Spill(left.reg());
+  cgen()->frame()->Spill(left.reg());
   __ add(Operand(left.reg()), Immediate(value_));
-  generator()->frame()->Push(&left);
-  generator()->frame()->Push(value_);
+  cgen()->frame()->Push(&left);
+  cgen()->frame()->Push(value_);
   GenericBinaryOpStub igostub(Token::SUB, overwrite_mode_, SMI_CODE_INLINED);
-  Result answer = generator()->frame()->CallStub(&igostub, 2);
+  Result answer = cgen()->frame()->CallStub(&igostub, 2);
   exit_.Jump(&answer);
 }
 
 
+#undef __
+#define __ ACCESS_MASM(masm_)
+
+
 class DeferredInlineSmiSubReversed: public DeferredCode {
  public:
-  DeferredInlineSmiSubReversed(CodeGenerator* generator,
-                               Smi* value,
+  DeferredInlineSmiSubReversed(Smi* value,
                                OverwriteMode overwrite_mode)
-      : DeferredCode(generator),
-        value_(value),
+      : value_(value),
         overwrite_mode_(overwrite_mode) {
     set_comment("[ DeferredInlineSmiSubReversed");
   }
 
   virtual void Generate();
 
  private:
   Smi* value_;
   OverwriteMode overwrite_mode_;
 };
 
 
 void DeferredInlineSmiSubReversed::Generate() {
   // Call the shared stub.
   Result right;
   enter()->Bind(&right);
-  generator()->frame()->Push(value_);
-  generator()->frame()->Push(&right);
+  cgen()->frame()->Push(value_);
+  cgen()->frame()->Push(&right);
   GenericBinaryOpStub igostub(Token::SUB, overwrite_mode_, SMI_CODE_INLINED);
-  Result answer = generator()->frame()->CallStub(&igostub, 2);
+  Result answer = cgen()->frame()->CallStub(&igostub, 2);
   exit_.Jump(&answer);
 }
 
 
 void CodeGenerator::ConstantSmiBinaryOperation(Token::Value op,
                                                Result* operand,
                                                Handle<Object> value,
                                                SmiAnalysis* type,
                                                bool reversed,
                                                OverwriteMode overwrite_mode) {
@@ skipping 22 matching lines @@
   int int_value = smi_value->value();
 
   switch (op) {
     case Token::ADD: {
       operand->ToRegister();
       frame_->Spill(operand->reg());
       __ add(Operand(operand->reg()), Immediate(value));
 
       DeferredCode* deferred = NULL;
       if (reversed) {
-        deferred = new DeferredInlineSmiAddReversed(this, smi_value,
-                                                    overwrite_mode);
+        deferred = new DeferredInlineSmiAddReversed(smi_value, overwrite_mode);
       } else {
-        deferred = new DeferredInlineSmiAdd(this, smi_value, overwrite_mode);
+        deferred = new DeferredInlineSmiAdd(smi_value, overwrite_mode);
       }
       deferred->SetEntryFrame(operand);
       deferred->enter()->Branch(overflow, operand, not_taken);
       __ test(operand->reg(), Immediate(kSmiTagMask));
       deferred->enter()->Branch(not_zero, operand, not_taken);
       deferred->BindExit(operand);
       frame_->Push(operand);
       break;
     }
 
     case Token::SUB: {
       DeferredCode* deferred = NULL;
       Result answer;  // Only allocate a new register if reversed.
       if (reversed) {
         answer = allocator()->Allocate();
         ASSERT(answer.is_valid());
-        deferred = new DeferredInlineSmiSubReversed(this, smi_value,
-                                                    overwrite_mode);
+        deferred = new DeferredInlineSmiSubReversed(smi_value, overwrite_mode);
         __ Set(answer.reg(), Immediate(value));
         // We are in the reversed case so they can't both be Smi constants.
         ASSERT(operand->is_register());
         __ sub(answer.reg(), Operand(operand->reg()));
       } else {
         operand->ToRegister();
         frame_->Spill(operand->reg());
-        deferred = new DeferredInlineSmiSub(this, smi_value, overwrite_mode);
+        deferred = new DeferredInlineSmiSub(smi_value, overwrite_mode);
         __ sub(Operand(operand->reg()), Immediate(value));
         answer = *operand;
       }
       deferred->SetEntryFrame(operand);
       deferred->enter()->Branch(overflow, operand, not_taken);
       __ test(answer.reg(), Immediate(kSmiTagMask));
       deferred->enter()->Branch(not_zero, operand, not_taken);
       operand->Unuse();
       deferred->BindExit(&answer);
       frame_->Push(&answer);
       break;
     }
 
     case Token::SAR: {
       if (reversed) {
         Result constant_operand(value);
         LikelySmiBinaryOperation(op, &constant_operand, operand,
                                  overwrite_mode);
       } else {
         // Only the least significant 5 bits of the shift value are used.
         // In the slow case, this masking is done inside the runtime call.
         int shift_value = int_value & 0x1f;
         DeferredCode* deferred =
-            new DeferredInlineSmiOperation(this, Token::SAR, smi_value,
-                                           overwrite_mode);
+            new DeferredInlineSmiOperation(op, smi_value, overwrite_mode);
         operand->ToRegister();
         __ test(operand->reg(), Immediate(kSmiTagMask));
         deferred->enter()->Branch(not_zero, operand, not_taken);
         if (shift_value > 0) {
           frame_->Spill(operand->reg());
           __ sar(operand->reg(), shift_value);
           __ and_(operand->reg(), ~kSmiTagMask);
         }
         deferred->BindExit(operand);
         frame_->Push(operand);
       }
       break;
     }
 
     case Token::SHR: {
       if (reversed) {
         Result constant_operand(value);
         LikelySmiBinaryOperation(op, &constant_operand, operand,
                                  overwrite_mode);
       } else {
         // Only the least significant 5 bits of the shift value are used.
         // In the slow case, this masking is done inside the runtime call.
         int shift_value = int_value & 0x1f;
         DeferredCode* deferred =
-            new DeferredInlineSmiOperation(this, Token::SHR, smi_value,
-                                           overwrite_mode);
+            new DeferredInlineSmiOperation(op, smi_value, overwrite_mode);
         operand->ToRegister();
         __ test(operand->reg(), Immediate(kSmiTagMask));
         deferred->enter()->Branch(not_zero, operand, not_taken);
         Result answer = allocator()->Allocate();
         ASSERT(answer.is_valid());
         __ mov(answer.reg(), operand->reg());
         __ sar(answer.reg(), kSmiTagSize);
         __ shr(answer.reg(), shift_value);
         // A negative Smi shifted right two is in the positive Smi range.
         if (shift_value < 2) {
@@ skipping 13 matching lines @@
     case Token::SHL: {
       if (reversed) {
         Result constant_operand(value);
         LikelySmiBinaryOperation(op, &constant_operand, operand,
                                  overwrite_mode);
       } else {
         // Only the least significant 5 bits of the shift value are used.
         // In the slow case, this masking is done inside the runtime call.
         int shift_value = int_value & 0x1f;
         DeferredCode* deferred =
-            new DeferredInlineSmiOperation(this, Token::SHL, smi_value,
-                                           overwrite_mode);
+            new DeferredInlineSmiOperation(op, smi_value, overwrite_mode);
         operand->ToRegister();
         __ test(operand->reg(), Immediate(kSmiTagMask));
         deferred->enter()->Branch(not_zero, operand, not_taken);
         if (shift_value != 0) {
           Result answer = allocator()->Allocate();
           ASSERT(answer.is_valid());
           __ mov(answer.reg(), operand->reg());
           ASSERT(kSmiTag == 0);  // adjust code if not the case
           // We do no shifts, only the Smi conversion, if shift_value is 1.
           if (shift_value > 1) {
@@ skipping 12 matching lines @@
         }
       }
       break;
     }
 
     case Token::BIT_OR:
     case Token::BIT_XOR:
     case Token::BIT_AND: {
       DeferredCode* deferred = NULL;
       if (reversed) {
-        deferred = new DeferredInlineSmiOperationReversed(this, op, smi_value,
+        deferred = new DeferredInlineSmiOperationReversed(op, smi_value,
                                                           overwrite_mode);
       } else {
-        deferred =  new DeferredInlineSmiOperation(this, op, smi_value,
+        deferred =  new DeferredInlineSmiOperation(op, smi_value,
                                                    overwrite_mode);
       }
       operand->ToRegister();
       __ test(operand->reg(), Immediate(kSmiTagMask));
       deferred->enter()->Branch(not_zero, operand, not_taken);
       frame_->Spill(operand->reg());
       if (op == Token::BIT_AND) {
         __ and_(Operand(operand->reg()), Immediate(value));
       } else if (op == Token::BIT_XOR) {
         if (int_value != 0) {
@@ skipping 265 matching lines @@
   Result answer = frame_->CallStub(&call_function, arg_count + 1);
   // Restore context and replace function on the stack with the
   // result of the stub invocation.
   frame_->RestoreContextRegister();
   frame_->SetElementAt(0, &answer);
 }
 
 
 class DeferredStackCheck: public DeferredCode {
  public:
-  explicit DeferredStackCheck(CodeGenerator* generator)
-      : DeferredCode(generator) {
+  explicit DeferredStackCheck() {
     set_comment("[ DeferredStackCheck");
   }
 
   virtual void Generate();
 };
 
 
 void DeferredStackCheck::Generate() {
   enter()->Bind();
   StackCheckStub stub;
-  Result ignored = generator()->frame()->CallStub(&stub, 0);
+  Result ignored = cgen()->frame()->CallStub(&stub, 0);
   ignored.Unuse();
   exit_.Jump();
 }
 
 
 void CodeGenerator::CheckStack() {
   if (FLAG_check_stack) {
-    DeferredStackCheck* deferred = new DeferredStackCheck(this);
+    DeferredStackCheck* deferred = new DeferredStackCheck;
     ExternalReference stack_guard_limit =
         ExternalReference::address_of_stack_guard_limit();
     __ cmp(esp, Operand::StaticVariable(stack_guard_limit));
     deferred->enter()->Branch(below, not_taken);
     deferred->BindExit();
   }
 }
 
 
 void CodeGenerator::VisitAndSpill(Statement* statement) {
@@ skipping 1837 matching lines @@
 
 bool CodeGenerator::IsUnsafeSmi(Handle<Object> value) {
   if (!value->IsSmi()) return false;
   int int_value = Smi::cast(*value)->value();
   return !is_intn(int_value, kMaxSmiInlinedBits);
 }
 
 
 class DeferredRegExpLiteral: public DeferredCode {
  public:
-  DeferredRegExpLiteral(CodeGenerator* generator, RegExpLiteral* node)
-      : DeferredCode(generator), node_(node) {
+  DeferredRegExpLiteral(RegExpLiteral* node) : node_(node) {
     set_comment("[ DeferredRegExpLiteral");
   }
 
   virtual void Generate();
 
  private:
   RegExpLiteral* node_;
 };
 
 
 void DeferredRegExpLiteral::Generate() {
   Result literals;
   enter()->Bind(&literals);
   // Since the entry is undefined we call the runtime system to
   // compute the literal.
 
-  VirtualFrame* frame = generator()->frame();
+  VirtualFrame* frame = cgen()->frame();
   // Literal array (0).
   frame->Push(&literals);
   // Literal index (1).
   frame->Push(Smi::FromInt(node_->literal_index()));
   // RegExp pattern (2).
   frame->Push(node_->pattern());
   // RegExp flags (3).
   frame->Push(node_->flags());
   Result boilerplate =
       frame->CallRuntime(Runtime::kMaterializeRegExpLiteral, 4);
   exit_.Jump(&boilerplate);
 }
 
 
 void CodeGenerator::VisitRegExpLiteral(RegExpLiteral* node) {
   Comment cmnt(masm_, "[ RegExp Literal");
-  DeferredRegExpLiteral* deferred = new DeferredRegExpLiteral(this, node);
+  DeferredRegExpLiteral* deferred = new DeferredRegExpLiteral(node);
 
   // Retrieve the literals array and check the allocated entry.  Begin
   // with a writable copy of the function of this activation in a
   // register.
   frame_->PushFunction();
   Result literals = frame_->Pop();
   literals.ToRegister();
   frame_->Spill(literals.reg());
 
   // Load the literals array of the function.
@@ skipping 20 matching lines @@
   frame_->Push(&boilerplate);
 }
 
 
 // This deferred code stub will be used for creating the boilerplate
 // by calling Runtime_CreateObjectLiteral.
 // Each created boilerplate is stored in the JSFunction and they are
 // therefore context dependent.
 class DeferredObjectLiteral: public DeferredCode {
  public:
-  DeferredObjectLiteral(CodeGenerator* generator,
-                        ObjectLiteral* node)
-      : DeferredCode(generator), node_(node) {
+  DeferredObjectLiteral(ObjectLiteral* node) : node_(node) {
     set_comment("[ DeferredObjectLiteral");
   }
 
   virtual void Generate();
 
  private:
   ObjectLiteral* node_;
 };
 
 
 void DeferredObjectLiteral::Generate() {
   Result literals;
   enter()->Bind(&literals);
   // Since the entry is undefined we call the runtime system to
   // compute the literal.
 
-  VirtualFrame* frame = generator()->frame();
+  VirtualFrame* frame = cgen()->frame();
   // Literal array (0).
   frame->Push(&literals);
   // Literal index (1).
   frame->Push(Smi::FromInt(node_->literal_index()));
   // Constant properties (2).
   frame->Push(node_->constant_properties());
   Result boilerplate =
       frame->CallRuntime(Runtime::kCreateObjectLiteralBoilerplate, 3);
   exit_.Jump(&boilerplate);
 }
 
 
 void CodeGenerator::VisitObjectLiteral(ObjectLiteral* node) {
   Comment cmnt(masm_, "[ ObjectLiteral");
-  DeferredObjectLiteral* deferred = new DeferredObjectLiteral(this, node);
+  DeferredObjectLiteral* deferred = new DeferredObjectLiteral(node);
 
   // Retrieve the literals array and check the allocated entry.  Begin
   // with a writable copy of the function of this activation in a
   // register.
   frame_->PushFunction();
   Result literals = frame_->Pop();
   literals.ToRegister();
   frame_->Spill(literals.reg());
 
   // Load the literals array of the function.
@@ skipping 83 matching lines @@
   }
 }
 
 
 // This deferred code stub will be used for creating the boilerplate
 // by calling Runtime_CreateArrayLiteralBoilerplate.
 // Each created boilerplate is stored in the JSFunction and they are
 // therefore context dependent.
 class DeferredArrayLiteral: public DeferredCode {
  public:
-  DeferredArrayLiteral(CodeGenerator* generator,
-                       ArrayLiteral* node)
-      : DeferredCode(generator), node_(node) {
+  DeferredArrayLiteral(ArrayLiteral* node) : node_(node) {
     set_comment("[ DeferredArrayLiteral");
   }
 
   virtual void Generate();
 
  private:
   ArrayLiteral* node_;
 };
 
 
 void DeferredArrayLiteral::Generate() {
   Result literals;
   enter()->Bind(&literals);
   // Since the entry is undefined we call the runtime system to
   // compute the literal.
 
-  VirtualFrame* frame = generator()->frame();
+  VirtualFrame* frame = cgen()->frame();
   // Literal array (0).
   frame->Push(&literals);
   // Literal index (1).
   frame->Push(Smi::FromInt(node_->literal_index()));
   // Constant properties (2).
   frame->Push(node_->literals());
   Result boilerplate =
       frame->CallRuntime(Runtime::kCreateArrayLiteralBoilerplate, 3);
   exit_.Jump(&boilerplate);
 }
 
 
 void CodeGenerator::VisitArrayLiteral(ArrayLiteral* node) {
   Comment cmnt(masm_, "[ ArrayLiteral");
-  DeferredArrayLiteral* deferred = new DeferredArrayLiteral(this, node);
+  DeferredArrayLiteral* deferred = new DeferredArrayLiteral(node);
 
   // Retrieve the literals array and check the allocated entry.  Begin
   // with a writable copy of the function of this activation in a
   // register.
   frame_->PushFunction();
   Result literals = frame_->Pop();
   literals.ToRegister();
   frame_->Spill(literals.reg());
 
   // Load the literals array of the function.
@@ skipping 934 matching lines @@
 
       default:
         UNREACHABLE();
     }
   }
 }
 
 
 class DeferredCountOperation: public DeferredCode {
  public:
-  DeferredCountOperation(CodeGenerator* generator,
-                         bool is_postfix,
+  DeferredCountOperation(bool is_postfix,
                          bool is_increment,
                          int target_size)
-      : DeferredCode(generator),
-        is_postfix_(is_postfix),
+      : is_postfix_(is_postfix),
         is_increment_(is_increment),
         target_size_(target_size) {
     set_comment("[ DeferredCountOperation");
   }
 
   virtual void Generate();
 
  private:
   bool is_postfix_;
   bool is_increment_;
   int target_size_;
 };
 
 
+#undef __
+#define __ ACCESS_MASM(cgen()->masm())
+
+
 void DeferredCountOperation::Generate() {
-  CodeGenerator* cgen = generator();
   Result value;
   enter()->Bind(&value);
-  VirtualFrame* frame = cgen->frame();
+  VirtualFrame* frame = cgen()->frame();
   // Undo the optimistic smi operation.
   value.ToRegister();
   frame->Spill(value.reg());
   if (is_increment_) {
     __ sub(Operand(value.reg()), Immediate(Smi::FromInt(1)));
   } else {
     __ add(Operand(value.reg()), Immediate(Smi::FromInt(1)));
   }
   frame->Push(&value);
   value = frame->InvokeBuiltin(Builtins::TO_NUMBER, CALL_FUNCTION, 1);
   frame->Push(&value);
   if (is_postfix_) {  // Fix up copy of old value with ToNumber(value).
     // This is only safe because VisitCountOperation makes this frame slot
     // beneath the reference a register, which is spilled at the above call.
     // We cannot safely write to constants or copies below the water line.
     frame->StoreToElementAt(target_size_ + 1);
   }
   frame->Push(Smi::FromInt(1));
   if (is_increment_) {
     value = frame->CallRuntime(Runtime::kNumberAdd, 2);
   } else {
     value = frame->CallRuntime(Runtime::kNumberSub, 2);
   }
   exit_.Jump(&value);
 }
 
 
+#undef __
+#define __ ACCESS_MASM(masm_)
+
+
 void CodeGenerator::VisitCountOperation(CountOperation* node) {
   Comment cmnt(masm_, "[ CountOperation");
 
   bool is_postfix = node->is_postfix();
   bool is_increment = node->op() == Token::INC;
 
   Variable* var = node->expression()->AsVariableProxy()->AsVariable();
   bool is_const = (var != NULL && var->mode() == Variable::CONST);
 
   // Postfix operators need a stack slot under the reference to hold
   // the old value while the new one is being stored.
   if (is_postfix) {
     frame_->Push(Smi::FromInt(0));
   }
 
   { Reference target(this, node->expression());
     if (target.is_illegal()) {
       // Spoof the virtual frame to have the expected height (one higher
       // than on entry).
       if (!is_postfix) {
         frame_->Push(Smi::FromInt(0));
       }
       return;
     }
     target.TakeValue(NOT_INSIDE_TYPEOF);
 
     DeferredCountOperation* deferred =
-        new DeferredCountOperation(this, is_postfix,
-                                   is_increment, target.size());
+        new DeferredCountOperation(is_postfix, is_increment, target.size());
 
     Result value = frame_->Pop();
     value.ToRegister();
 
     // Postfix: Store the old value as the result.
     if (is_postfix) {
       // Explicitly back the slot for the old value with a new register.
       // This improves performance in some cases.
       Result old_value = allocator_->Allocate();
       ASSERT(old_value.is_valid());
@@ skipping 403 matching lines @@
       && (allocator()->count(ebx) == (frame()->is_used(ebx) ? 1 : 0))
       && (allocator()->count(ecx) == (frame()->is_used(ecx) ? 1 : 0))
       && (allocator()->count(edx) == (frame()->is_used(edx) ? 1 : 0))
       && (allocator()->count(edi) == (frame()->is_used(edi) ? 1 : 0));
 }
 #endif
 
 
 class DeferredReferenceGetNamedValue: public DeferredCode {
  public:
-  DeferredReferenceGetNamedValue(CodeGenerator* cgen, Handle<String> name)
-      : DeferredCode(cgen), name_(name) {
+  DeferredReferenceGetNamedValue(Handle<String> name) : name_(name) {
     set_comment("[ DeferredReferenceGetNamedValue");
   }
 
   virtual void Generate();
 
   Label* patch_site() { return &patch_site_; }
 
  private:
   Label patch_site_;
   Handle<String> name_;
 };
 
 
-void DeferredReferenceGetNamedValue::Generate() {
-  CodeGenerator* cgen = generator();
-  Result receiver;
-  enter()->Bind(&receiver);
-
-  cgen->frame()->Push(&receiver);
-  cgen->frame()->Push(name_);
-  Result answer = cgen->frame()->CallLoadIC(RelocInfo::CODE_TARGET);
-  // The call must be followed by a test eax instruction to indicate
-  // that the inobject property case was inlined.
-  ASSERT(answer.is_register() && answer.reg().is(eax));
-  // Store the delta to the map check instruction here in the test instruction.
-  // Use masm_-> instead of the double underscore macro since the latter can't
-  // return a value.
-  int delta_to_patch_site = masm_->SizeOfCodeGeneratedSince(patch_site());
-  // Here we use masm_-> instead of the double underscore macro because
-  // this is the instruction that gets patched and coverage code gets in
-  // the way.
-  masm_->test(answer.reg(), Immediate(-delta_to_patch_site));
-  __ IncrementCounter(&Counters::named_load_inline_miss, 1);
-  receiver = cgen->frame()->Pop();
-  exit_.Jump(&receiver, &answer);
-}
-
-
 class DeferredReferenceGetKeyedValue: public DeferredCode {
  public:
-  DeferredReferenceGetKeyedValue(CodeGenerator* generator, bool is_global)
-      : DeferredCode(generator), is_global_(is_global) {
+  DeferredReferenceGetKeyedValue(bool is_global) : is_global_(is_global) {
     set_comment("[ DeferredReferenceGetKeyedValue");
   }
 
   virtual void Generate();
 
   Label* patch_site() { return &patch_site_; }
 
  private:
   Label patch_site_;
   bool is_global_;
 };
 
 
+#undef __
+#define __ ACCESS_MASM(cgen()->masm())
+
+
+void DeferredReferenceGetNamedValue::Generate() {
+  Result receiver;
+  enter()->Bind(&receiver);
+
+  cgen()->frame()->Push(&receiver);
+  cgen()->frame()->Push(name_);
+  Result answer = cgen()->frame()->CallLoadIC(RelocInfo::CODE_TARGET);
+  // The call must be followed by a test eax instruction to indicate
+  // that the inobject property case was inlined.
+  ASSERT(answer.is_register() && answer.reg().is(eax));
+  // Store the delta to the map check instruction here in the test
+  // instruction.  Use cgen()->masm()-> instead of the __ macro since
+  // the latter can't return a value.
+  int delta_to_patch_site =
+      cgen()->masm()->SizeOfCodeGeneratedSince(patch_site());
+  // Here we use cgen()->masm()-> instead of the __ macro because this
+  // is the instruction that gets patched and coverage code gets in the
+  // way.
+  cgen()->masm()->test(answer.reg(), Immediate(-delta_to_patch_site));
+  __ IncrementCounter(&Counters::named_load_inline_miss, 1);
+  receiver = cgen()->frame()->Pop();
+  exit_.Jump(&receiver, &answer);
+}
+
+
 void DeferredReferenceGetKeyedValue::Generate() {
-  CodeGenerator* cgen = generator();
   Result receiver;
   Result key;
   enter()->Bind(&receiver, &key);
-  cgen->frame()->Push(&receiver);  // First IC argument.
-  cgen->frame()->Push(&key);       // Second IC argument.
+  cgen()->frame()->Push(&receiver);  // First IC argument.
+  cgen()->frame()->Push(&key);       // Second IC argument.
 
   // Calculate the delta from the IC call instruction to the map check
   // cmp instruction in the inlined version.  This delta is stored in
   // a test(eax, delta) instruction after the call so that we can find
   // it in the IC initialization code and patch the cmp instruction.
   // This means that we cannot allow test instructions after calls to
   // KeyedLoadIC stubs in other places.
   RelocInfo::Mode mode = is_global_
                          ? RelocInfo::CODE_TARGET_CONTEXT
                          : RelocInfo::CODE_TARGET;
-  Result value = cgen->frame()->CallKeyedLoadIC(mode);
+  Result value = cgen()->frame()->CallKeyedLoadIC(mode);
   // The result needs to be specifically the eax register because the
   // offset to the patch site will be expected in a test eax
   // instruction.
   ASSERT(value.is_register() && value.reg().is(eax));
-  // The delta from the start of the map-compare instruction to the
-  // test instruction.  We use masm_ directly here instead of the
-  // double underscore macro because the macro sometimes uses macro
-  // expansion to turn into something that can't return a value.  This
-  // is encountered when doing generated code coverage tests.
-  int delta_to_patch_site = masm_->SizeOfCodeGeneratedSince(patch_site());
-  // Here we use masm_-> instead of the double underscore macro because this
-  // is the instruction that gets patched and coverage code gets in the way.
-  masm_->test(value.reg(), Immediate(-delta_to_patch_site));
+  // The delta from the start of the map-compare instruction to the test
+  // instruction.  We use cgen()->masm() directly here instead of the __
+  // macro because the macro sometimes uses macro expansion to turn into
+  // something that can't return a value.  This is encountered when
+  // doing generated code coverage tests.
+  int delta_to_patch_site =
+      cgen()->masm()->SizeOfCodeGeneratedSince(patch_site());
+  // Here we use cgen()->masm()-> instead of the __ macro because this
+  // is the instruction that gets patched and coverage code gets in the
+  // way.
+  cgen()->masm()->test(value.reg(), Immediate(-delta_to_patch_site));
   __ IncrementCounter(&Counters::keyed_load_inline_miss, 1);
 
   // The receiver and key were spilled by the call, so their state as
   // constants or copies has been changed.  Thus, they need to be
   // "mergable" in the block at the exit label and are therefore
   // passed as return results here.
-  key = cgen->frame()->Pop();
-  receiver = cgen->frame()->Pop();
+  key = cgen()->frame()->Pop();
+  receiver = cgen()->frame()->Pop();
   exit_.Jump(&receiver, &key, &value);
 }
 
 
 #undef __
 #define __ ACCESS_MASM(masm)
 
 Handle<String> Reference::GetName() {
   ASSERT(type_ == NAMED);
   Property* property = expression_->AsProperty();
@@ skipping 52 matching lines @@
         Result answer = cgen_->frame()->CallLoadIC(mode);
         // A test eax instruction following the call signals that the
         // inobject property case was inlined.  Ensure that there is not
         // a test eax instruction here.
         __ nop();
         cgen_->frame()->Push(&answer);
       } else {
         // Inline the inobject property case.
         Comment cmnt(masm, "[ Inlined named property load");
         DeferredReferenceGetNamedValue* deferred =
-            new DeferredReferenceGetNamedValue(cgen_, GetName());
+            new DeferredReferenceGetNamedValue(GetName());
         Result receiver = cgen_->frame()->Pop();
         receiver.ToRegister();
 
         // Try to preallocate the value register so that all frames
         // reaching the deferred code are identical.
         Result value = cgen_->allocator()->AllocateWithoutSpilling();
         if (value.is_valid()) {
           deferred->SetEntryFrame(&receiver);
         }
 
@@ skipping 44 matching lines @@
       Variable* var = expression_->AsVariableProxy()->AsVariable();
       bool is_global = var != NULL;
       ASSERT(!is_global || var->is_global());
       // Inline array load code if inside of a loop.  We do not know
       // the receiver map yet, so we initially generate the code with
       // a check against an invalid map.  In the inline cache code, we
       // patch the map check if appropriate.
       if (cgen_->loop_nesting() > 0) {
         Comment cmnt(masm, "[ Inlined array index load");
         DeferredReferenceGetKeyedValue* deferred =
-            new DeferredReferenceGetKeyedValue(cgen_, is_global);
+            new DeferredReferenceGetKeyedValue(is_global);
 
         Result key = cgen_->frame()->Pop();
         Result receiver = cgen_->frame()->Pop();
         key.ToRegister();
         receiver.ToRegister();
 
         // Try to preallocate the elements and index scratch registers
         // so that all frames reaching the deferred code are identical.
         Result elements = cgen_->allocator()->AllocateWithoutSpilling();
         Result index = cgen_->allocator()->AllocateWithoutSpilling();
@@ skipping 207 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 __ ACCESS_MASM(masm_)
-
 Result DeferredInlineBinaryOperation::GenerateInlineCode(Result* left,
                                                          Result* right) {
+  MacroAssembler* masm = cgen()->masm();
   // Perform fast-case smi code for the operation (left <op> right) and
   // returns the result in a Result.
   // If any fast-case tests fail, it jumps to the slow-case deferred code,
   // which calls the binary operation stub, with the arguments (in registers)
   // on top of the frame.
   // Consumes its arguments (sets left and right to invalid and frees their
   // registers).
 
   left->ToRegister();
   right->ToRegister();
   // A newly allocated register answer is used to hold the answer.
   // The registers containing left and right are not modified in
   // most cases, so they usually don't need to be spilled in the fast case.
-  Result answer = generator()->allocator()->Allocate();
+  Result answer = cgen()->allocator()->Allocate();
 
   ASSERT(answer.is_valid());
   // Perform the smi check.
   if (left->reg().is(right->reg())) {
     __ test(left->reg(), Immediate(kSmiTagMask));
   } else {
     __ mov(answer.reg(), left->reg());
     __ or_(answer.reg(), Operand(right->reg()));
     ASSERT(kSmiTag == 0);  // adjust zero check if not the case
     __ test(answer.reg(), Immediate(kSmiTagMask));
@@ skipping 50 matching lines @@
       // Div and mod use the registers eax and edx.  Left and right must
       // be preserved, because the original operands are needed if we switch
       // to the slow case.  Move them if either is in eax or edx.
       // The Result answer should be changed into an alias for eax.
       // Precondition:
       // The Results left and right are valid.  They may be the same register,
       // and may be unspilled.  The Result answer is valid and is distinct
       // from left and right, and is spilled.
       // The value in left is copied to answer.
 
-      Result reg_eax = generator()->allocator()->Allocate(eax);
-      Result reg_edx = generator()->allocator()->Allocate(edx);
+      Result reg_eax = cgen()->allocator()->Allocate(eax);
+      Result reg_edx = cgen()->allocator()->Allocate(edx);
       // These allocations may have failed, if one of left, right, or answer
       // is in register eax or edx.
       bool left_copied_to_eax = false;  // We will make sure this becomes true.
 
       // Part 1: Get eax
       if (answer.reg().is(eax)) {
         reg_eax = answer;
         left_copied_to_eax = true;
       } else if (right->reg().is(eax) || left->reg().is(eax)) {
         // We need a non-edx register to move one or both of left and right to.
         // We use answer if it is not edx, otherwise we allocate one.
         if (answer.reg().is(edx)) {
           reg_edx = answer;
-          answer = generator()->allocator()->Allocate();
+          answer = cgen()->allocator()->Allocate();
           ASSERT(answer.is_valid());
         }
 
         if (left->reg().is(eax)) {
           reg_eax = *left;
           left_copied_to_eax = true;
           *left = answer;
         }
         if (right->reg().is(eax)) {
           reg_eax = *right;
@@ skipping 10 matching lines @@
       // Part 2: Get edx
       // reg_edx is invalid if and only if either left, right,
       // or answer is in edx.  If edx is valid, then either edx
       // was free, or it was answer, but answer was reallocated.
       if (answer.reg().is(edx)) {
         reg_edx = answer;
       } else if (right->reg().is(edx) || left->reg().is(edx)) {
         // Is answer used?
         if (answer.reg().is(eax) || answer.reg().is(left->reg()) ||
             answer.reg().is(right->reg())) {
-          answer = generator()->allocator()->Allocate();
+          answer = cgen()->allocator()->Allocate();
           ASSERT(answer.is_valid());  // We cannot hit both Allocate() calls.
         }
         if (left->reg().is(edx)) {
           reg_edx = *left;
           *left = answer;
         }
         if (right->reg().is(edx)) {
           reg_edx = *right;
           *right = answer;
         }
         __ mov(answer.reg(), edx);
       }
       // End of Part 2
       ASSERT(reg_edx.is_valid());
       ASSERT(!left->reg().is(eax));
       ASSERT(!right->reg().is(eax));
 
       answer = reg_eax;  // May free answer, if it was never used.
-      generator()->frame()->Spill(eax);
+      cgen()->frame()->Spill(eax);
       if (!left_copied_to_eax) {
         __ mov(eax, left->reg());
         left_copied_to_eax = true;
       }
-      generator()->frame()->Spill(edx);
+      cgen()->frame()->Spill(edx);
 
       // Postcondition:
       // reg_eax, reg_edx are valid, correct, and spilled.
       // reg_eax contains the value originally in left
       // left and right are not eax or edx.  They may or may not be
       // spilled or distinct.
       // answer is an alias for reg_eax.
 
       // Sign extend eax into edx:eax.
       __ cdq();
@@ skipping 69 matching lines @@
       // Left is in two registers already, so even if left or answer is ecx,
       // we can move right to it, and use the other one.
       // Right operand must be in register cl because x86 likes it that way.
       if (right->reg().is(ecx)) {
         // Right is already in the right place.  Left may be in the
         // same register, which causes problems. Always use answer
         // instead of left, even if left is not ecx, since this avoids
         // spilling left.
         *left = answer;
       } else if (left->reg().is(ecx)) {
-        generator()->frame()->Spill(left->reg());
+        cgen()->frame()->Spill(left->reg());
         __ mov(left->reg(), right->reg());
         *right = *left;
         *left = answer;  // Use copy of left in answer as left.
       } else if (answer.reg().is(ecx)) {
         __ mov(answer.reg(), right->reg());
         *right = answer;
       } else {
-        Result reg_ecx = generator()->allocator()->Allocate(ecx);
+        Result reg_ecx = cgen()->allocator()->Allocate(ecx);
         ASSERT(reg_ecx.is_valid());
         __ mov(ecx, right->reg());
         *right = reg_ecx;
         // Answer and left both contain the left operand.  Use answer, so
         // left is not spilled.
         *left = answer;
       }
       ASSERT(left->reg().is_valid());
       ASSERT(!left->reg().is(ecx));
       ASSERT(right->reg().is(ecx));
       answer.Unuse();  // Answer may now be being used for left or right.
       // We will modify left and right, which we do not do in any other
       // binary operation.  The exits to slow code need to restore the
       // original values of left and right, or at least values that give
       // the same answer.
 
       // We are modifying left and right.  They must be spilled!
-      generator()->frame()->Spill(left->reg());
-      generator()->frame()->Spill(right->reg());
+      cgen()->frame()->Spill(left->reg());
+      cgen()->frame()->Spill(right->reg());
 
       // Remove tags from operands (but keep sign).
       __ sar(left->reg(), kSmiTagSize);
       __ sar(ecx, kSmiTagSize);
       // Perform the operation.
       switch (op_) {
         case Token::SAR:
           __ sar(left->reg());
           // No checks of result necessary
           break;
@@ skipping 49 matching lines @@
     default:
       UNREACHABLE();
       break;
   }
   left->Unuse();
   right->Unuse();
   return answer;
 }
 
 
-#undef __
-#define __ ACCESS_MASM(masm)
-
 void GenericBinaryOpStub::GenerateSmiCode(MacroAssembler* masm, Label* slow) {
   // Perform fast-case smi code for the operation (eax <op> ebx) and
   // leave result in register eax.
 
   // Prepare the smi check of both operands by or'ing them together
   // before checking against the smi mask.
   __ mov(ecx, Operand(ebx));
   __ or_(ecx, Operand(eax));
 
   switch (op_) {
@@ skipping 1200 matching lines @@
 
   // Slow-case: Go through the JavaScript implementation.
   __ bind(&slow);
   __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal