Simplify deferred code by removing some unneeded or redundant stuff.

src/arm/codegen-arm.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 271 matching lines @@
   }
 
   // Code generation state must be reset.
   ASSERT(!has_cc());
   ASSERT(state_ == NULL);
   ASSERT(!function_return_is_shadowed_);
   function_return_.Unuse();
   DeleteFrame();
 
   // Process any deferred code using the register allocator.
-  if (HasStackOverflow()) {
-    ClearDeferred();
-  } else {
+  if (!HasStackOverflow()) {
     ProcessDeferred();
   }
 
   allocator_ = NULL;
   scope_ = NULL;
 }
 
 
 MemOperand CodeGenerator::SlotOperand(Slot* slot, Register tmp) {
   // Currently, this assertion will fail if we try to assign to
@@ skipping 445 matching lines @@
     default:
       // Other cases should have been handled before this point.
       UNREACHABLE();
       break;
   }
 }
 
 
 class DeferredInlineSmiOperation: public DeferredCode {
  public:
-  DeferredInlineSmiOperation(CodeGenerator* generator,
-                             Token::Value op,
+  DeferredInlineSmiOperation(Token::Value op,
                              int value,
                              bool reversed,
                              OverwriteMode overwrite_mode)
-      : DeferredCode(generator),
-        op_(op),
+      : op_(op),
         value_(value),
         reversed_(reversed),
         overwrite_mode_(overwrite_mode) {
     set_comment("[ DeferredInlinedSmiOperation");
   }
 
   virtual void Generate();
 
  private:
   Token::Value op_;
   int value_;
   bool reversed_;
   OverwriteMode overwrite_mode_;
 };
 
 
+#undef __
+#define __ ACCESS_MASM(masm)
+
+
 void DeferredInlineSmiOperation::Generate() {
+  MacroAssembler* masm = cgen()->masm();
   enter()->Bind();
   VirtualFrame::SpilledScope spilled_scope;
 
   switch (op_) {
     case Token::ADD: {
       if (reversed_) {
         // revert optimistic add
         __ sub(r0, r0, Operand(Smi::FromInt(value_)));
         __ mov(r1, Operand(Smi::FromInt(value_)));
       } else {
@@ skipping 40 matching lines @@
       break;
     }
 
     default:
       // other cases should have been handled before this point.
       UNREACHABLE();
       break;
   }
 
   GenericBinaryOpStub igostub(op_, overwrite_mode_);
-  Result arg0 = generator()->allocator()->Allocate(r1);
+  Result arg0 = cgen()->allocator()->Allocate(r1);
   ASSERT(arg0.is_valid());
-  Result arg1 = generator()->allocator()->Allocate(r0);
+  Result arg1 = cgen()->allocator()->Allocate(r0);
   ASSERT(arg1.is_valid());
-  generator()->frame()->CallStub(&igostub, &arg0, &arg1);
+  cgen()->frame()->CallStub(&igostub, &arg0, &arg1);
   exit_.Jump();
 }
 
 
+#undef __
+#define __ ACCESS_MASM(masm_)
+
+
 void CodeGenerator::SmiOperation(Token::Value op,
                                  Handle<Object> value,
                                  bool reversed,
                                  OverwriteMode mode) {
   VirtualFrame::SpilledScope spilled_scope;
   // NOTE: This is an attempt to inline (a bit) more of the code for
   // some possible smi operations (like + and -) when (at least) one
   // of the operands is a literal smi. With this optimization, the
   // performance of the system is increased by ~15%, and the generated
   // code size is increased by ~1% (measured on a combination of
   // different benchmarks).
 
   // sp[0] : operand
 
   int int_value = Smi::cast(*value)->value();
 
   JumpTarget exit;
   frame_->EmitPop(r0);
 
   switch (op) {
     case Token::ADD: {
       DeferredCode* deferred =
-        new DeferredInlineSmiOperation(this, op, int_value, reversed, mode);
+        new DeferredInlineSmiOperation(op, int_value, reversed, mode);
 
       __ add(r0, r0, Operand(value), SetCC);
       deferred->enter()->Branch(vs);
       __ tst(r0, Operand(kSmiTagMask));
       deferred->enter()->Branch(ne);
       deferred->BindExit();
       break;
     }
 
     case Token::SUB: {
       DeferredCode* deferred =
-        new DeferredInlineSmiOperation(this, op, int_value, reversed, mode);
+        new DeferredInlineSmiOperation(op, int_value, reversed, mode);
 
       if (!reversed) {
         __ sub(r0, r0, Operand(value), SetCC);
       } else {
         __ rsb(r0, r0, Operand(value), SetCC);
       }
       deferred->enter()->Branch(vs);
       __ tst(r0, Operand(kSmiTagMask));
       deferred->enter()->Branch(ne);
       deferred->BindExit();
       break;
     }
 
     case Token::BIT_OR:
     case Token::BIT_XOR:
     case Token::BIT_AND: {
       DeferredCode* deferred =
-        new DeferredInlineSmiOperation(this, op, int_value, reversed, mode);
+        new DeferredInlineSmiOperation(op, int_value, reversed, mode);
       __ tst(r0, Operand(kSmiTagMask));
       deferred->enter()->Branch(ne);
       switch (op) {
         case Token::BIT_OR:  __ orr(r0, r0, Operand(value)); break;
         case Token::BIT_XOR: __ eor(r0, r0, Operand(value)); break;
         case Token::BIT_AND: __ and_(r0, r0, Operand(value)); break;
         default: UNREACHABLE();
       }
       deferred->BindExit();
       break;
     }
 
     case Token::SHL:
     case Token::SHR:
     case Token::SAR: {
       if (reversed) {
         __ mov(ip, Operand(value));
         frame_->EmitPush(ip);
         frame_->EmitPush(r0);
         GenericBinaryOperation(op, mode);
 
       } else {
         int shift_value = int_value & 0x1f;  // least significant 5 bits
         DeferredCode* deferred =
-          new DeferredInlineSmiOperation(this, op, shift_value, false, mode);
+          new DeferredInlineSmiOperation(op, shift_value, false, mode);
         __ tst(r0, Operand(kSmiTagMask));
         deferred->enter()->Branch(ne);
         __ mov(r2, Operand(r0, ASR, kSmiTagSize));  // remove tags
         switch (op) {
           case Token::SHL: {
             __ mov(r2, Operand(r2, LSL, shift_value));
             // check that the *unsigned* result fits in a smi
             __ add(r3, r2, Operand(0x40000000), SetCC);
             deferred->enter()->Branch(mi);
             break;
@@ skipping 1706 matching lines @@
   ASSERT(frame_->height() == original_height + 1);
 }
 
 
 // This deferred code stub will be used for creating the boilerplate
 // by calling Runtime_CreateObjectLiteralBoilerplate.
 // 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_;
 };
 
 
+#undef __
+#define __ ACCESS_MASM(masm)
+
+
 void DeferredObjectLiteral::Generate() {
+  MacroAssembler* masm = cgen()->masm();
   // Argument is passed in r1.
   enter()->Bind();
   VirtualFrame::SpilledScope spilled_scope;
 
   // If 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->EmitPush(r1);
   // Literal index (1).
   __ mov(r0, Operand(Smi::FromInt(node_->literal_index())));
   frame->EmitPush(r0);
   // Constant properties (2).
   __ mov(r0, Operand(node_->constant_properties()));
   frame->EmitPush(r0);
   Result boilerplate =
       frame->CallRuntime(Runtime::kCreateObjectLiteralBoilerplate, 3);
   __ mov(r2, Operand(boilerplate.reg()));
   // Result is returned in r2.
   exit_.Jump();
 }
 
 
+#undef __
+#define __ ACCESS_MASM(masm_)
+
+
 void CodeGenerator::VisitObjectLiteral(ObjectLiteral* node) {
 #ifdef DEBUG
   int original_height = frame_->height();
 #endif
   VirtualFrame::SpilledScope spilled_scope;
   Comment cmnt(masm_, "[ ObjectLiteral");
 
-  DeferredObjectLiteral* deferred = new DeferredObjectLiteral(this, node);
+  DeferredObjectLiteral* deferred = new DeferredObjectLiteral(node);
 
   // Retrieve the literal array and check the allocated entry.
 
   // Load the function of this activation.
   __ ldr(r1, frame_->Function());
 
   // Load the literals array of the function.
   __ ldr(r1, FieldMemOperand(r1, JSFunction::kLiteralsOffset));
 
   // Load the literal at the ast saved index.
@@ skipping 64 matching lines @@
   ASSERT(frame_->height() == original_height + 1);
 }
 
 
 // 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_;
 };
 
 
+#undef __
+#define __ ACCESS_MASM(masm)
+
+
 void DeferredArrayLiteral::Generate() {
+  MacroAssembler* masm = cgen()->masm();
   // Argument is passed in r1.
   enter()->Bind();
   VirtualFrame::SpilledScope spilled_scope;
 
   // If the entry is undefined we call the runtime system to computed
   // the literal.
 
-  VirtualFrame* frame = generator()->frame();
+  VirtualFrame* frame = cgen()->frame();
   // Literal array (0).
   frame->EmitPush(r1);
   // Literal index (1).
   __ mov(r0, Operand(Smi::FromInt(node_->literal_index())));
   frame->EmitPush(r0);
   // Constant properties (2).
   __ mov(r0, Operand(node_->literals()));
   frame->EmitPush(r0);
   Result boilerplate =
       frame->CallRuntime(Runtime::kCreateArrayLiteralBoilerplate, 3);
   __ mov(r2, Operand(boilerplate.reg()));
   // Result is returned in r2.
   exit_.Jump();
 }
 
 
+#undef __
+#define __ ACCESS_MASM(masm_)
+
+
 void CodeGenerator::VisitArrayLiteral(ArrayLiteral* node) {
 #ifdef DEBUG
   int original_height = frame_->height();
 #endif
   VirtualFrame::SpilledScope spilled_scope;
   Comment cmnt(masm_, "[ ArrayLiteral");
 
-  DeferredArrayLiteral* deferred = new DeferredArrayLiteral(this, node);
+  DeferredArrayLiteral* deferred = new DeferredArrayLiteral(node);
 
   // Retrieve the literal array and check the allocated entry.
 
   // Load the function of this activation.
   __ ldr(r1, frame_->Function());
 
   // Load the literals array of the function.
   __ ldr(r1, FieldMemOperand(r1, JSFunction::kLiteralsOffset));
 
   // Load the literal at the ast saved index.
@@ skipping 2348 matching lines @@
   __ mov(r2, Operand(0));
   __ GetBuiltinEntry(r3, Builtins::CALL_NON_FUNCTION);
   __ Jump(Handle<Code>(Builtins::builtin(Builtins::ArgumentsAdaptorTrampoline)),
           RelocInfo::CODE_TARGET);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal