Clean up the Result class. Reduce the size of Result from four words...

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 263 matching lines @@
 #endif
       VisitStatements(body);
 
       // Handle the return from the function.
       if (has_valid_frame()) {
         // If there is a valid frame, control flow can fall off the end of
         // the body.  In that case there is an implicit return statement.
         ASSERT(!function_return_is_shadowed_);
         CodeForReturnPosition(fun);
         frame_->PrepareForReturn();
-        Result undefined(Factory::undefined_value(), this);
+        Result undefined(Factory::undefined_value());
         if (function_return_.is_bound()) {
           function_return_.Jump(&undefined);
         } else {
           // Though this is a (possibly) backward block, the frames
           // can only differ on their top element.
           function_return_.Bind(&undefined, 1);
           GenerateReturnSequence(&undefined);
         }
       } else if (function_return_.is_linked()) {
         // If the return target has dangling jumps to it, then we have not
         // yet generated the return sequence.  This can happen when (a)
         // control does not flow off the end of the body so we did not
         // compile an artificial return statement just above, and (b) there
         // are return statements in the body but (c) they are all shadowed.
-        Result return_value(this);
+        Result return_value;
         // Though this is a (possibly) backward block, the frames can
         // only differ on their top element.
         function_return_.Bind(&return_value, 1);
         GenerateReturnSequence(&return_value);
       }
     }
   }
 
   // Adjust for function-level loop nesting.
   loop_nesting_ -= fun->loop_nesting();
@@ skipping 71 matching lines @@
       return Operand(eax);
   }
 }
 
 
 Operand CodeGenerator::ContextSlotOperandCheckExtensions(Slot* slot,
                                                          Result tmp,
                                                          JumpTarget* slow) {
   ASSERT(slot->type() == Slot::CONTEXT);
   ASSERT(tmp.is_register());
-  Result context(esi, this);
+  Result context(esi);
 
   for (Scope* s = scope(); s != slot->var()->scope(); s = s->outer_scope()) {
     if (s->num_heap_slots() > 0) {
       if (s->calls_eval()) {
         // Check that extension is NULL.
         __ cmp(ContextOperand(context.reg(), Context::EXTENSION_INDEX),
                Immediate(0));
         slow->Branch(not_equal, not_taken);
       }
       __ mov(tmp.reg(), ContextOperand(context.reg(), Context::CLOSURE_INDEX));
@@ skipping 394 matching lines @@
 
   virtual void Generate();
 
  private:
   GenericBinaryOpStub stub_;
   Token::Value op_;
 };
 
 
 void DeferredInlineBinaryOperation::Generate() {
-  Result left(generator());
-  Result right(generator());
+  Result left;

[Kevin Millikin (Chromium), 2009/05/15 10:50:49]

A separate cleanup, since we have it now, is to use the top code generator in
the deferred code objects.

+  Result right;
   enter()->Bind(&left, &right);
   generator()->frame()->Push(&left);
   generator()->frame()->Push(&right);
   Result answer = generator()->frame()->CallStub(&stub_, 2);
   exit_.Jump(&answer);
 }
 
 
 void CodeGenerator::GenericBinaryOperation(Token::Value op,
                                            SmiAnalysis* type,
@@ skipping 34 matching lines @@
 
   Result right = frame_->Pop();
   Result left = frame_->Pop();
 
   if (op == Token::ADD) {
     bool left_is_string = left.static_type().is_jsstring();
     bool right_is_string = right.static_type().is_jsstring();
     if (left_is_string || right_is_string) {
       frame_->Push(&left);
       frame_->Push(&right);
-      Result answer(this);
+      Result answer;
       if (left_is_string) {
         if (right_is_string) {
           // TODO(lrn): if (left.is_constant() && right.is_constant())
           // -- do a compile time cons, if allocation during codegen is allowed.
           answer = frame_->CallRuntime(Runtime::kStringAdd, 2);
         } else {
           answer =
             frame_->InvokeBuiltin(Builtins::STRING_ADD_LEFT, CALL_FUNCTION, 2);
         }
       } else if (right_is_string) {
@@ skipping 165 matching lines @@
   virtual void Generate();
 
  private:
   Token::Value op_;
   Smi* value_;
   OverwriteMode overwrite_mode_;
 };
 
 
 void DeferredInlineSmiOperation::Generate() {
-  Result left(generator());
+  Result left;
   enter()->Bind(&left);
   generator()->frame()->Push(&left);
   generator()->frame()->Push(value_);
   GenericBinaryOpStub igostub(op_, overwrite_mode_, SMI_CODE_INLINED);
   Result answer = generator()->frame()->CallStub(&igostub, 2);
   exit_.Jump(&answer);
 }
 
 
 class DeferredInlineSmiOperationReversed: public DeferredCode {
@@ skipping 12 matching lines @@
   virtual void Generate();
 
  private:
   Token::Value op_;
   Smi* value_;
   OverwriteMode overwrite_mode_;
 };
 
 
 void DeferredInlineSmiOperationReversed::Generate() {
-  Result right(generator());
+  Result right;
   enter()->Bind(&right);
   generator()->frame()->Push(value_);
   generator()->frame()->Push(&right);
   GenericBinaryOpStub igostub(op_, overwrite_mode_, SMI_CODE_INLINED);
   Result answer = generator()->frame()->CallStub(&igostub, 2);
   exit_.Jump(&answer);
 }
 
 
 class DeferredInlineSmiAdd: public DeferredCode {
@@ skipping 10 matching lines @@
   virtual void Generate();
 
  private:
   Smi* value_;
   OverwriteMode overwrite_mode_;
 };
 
 
 void DeferredInlineSmiAdd::Generate() {
   // Undo the optimistic add operation and call the shared stub.
-  Result left(generator());  // Initially left + value_.
+  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);
 }
@@ skipping 13 matching lines @@
   virtual void Generate();
 
  private:
   Smi* value_;
   OverwriteMode overwrite_mode_;
 };
 
 
 void DeferredInlineSmiAddReversed::Generate() {
   // Undo the optimistic add operation and call the shared stub.
-  Result right(generator());  // Initially value_ + right.
+  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);
 }
@@ skipping 13 matching lines @@
   virtual void Generate();
 
  private:
   Smi* value_;
   OverwriteMode overwrite_mode_;
 };
 
 
 void DeferredInlineSmiSub::Generate() {
   // Undo the optimistic sub operation and call the shared stub.
-  Result left(generator());  // Initially left - value_.
+  Result left;  // Initially left - value_.
   enter()->Bind(&left);
   left.ToRegister();
   generator()->frame()->Spill(left.reg());
   __ add(Operand(left.reg()), Immediate(value_));
   generator()->frame()->Push(&left);
   generator()->frame()->Push(value_);
   GenericBinaryOpStub igostub(Token::SUB, overwrite_mode_, SMI_CODE_INLINED);
   Result answer = generator()->frame()->CallStub(&igostub, 2);
   exit_.Jump(&answer);
 }
@@ skipping 13 matching lines @@
   virtual void Generate();
 
  private:
   Smi* value_;
   OverwriteMode overwrite_mode_;
 };
 
 
 void DeferredInlineSmiSubReversed::Generate() {
   // Call the shared stub.
-  Result right(generator());
+  Result right;
   enter()->Bind(&right);
   generator()->frame()->Push(value_);
   generator()->frame()->Push(&right);
   GenericBinaryOpStub igostub(Token::SUB, overwrite_mode_, SMI_CODE_INLINED);
   Result answer = generator()->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) {
   // 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 constant smi.
   // Consumes the argument "operand".
 
   // TODO(199): Optimize some special cases of operations involving a
   // smi literal (multiply by 2, shift by 0, etc.).
   if (IsUnsafeSmi(value)) {
-    Result unsafe_operand(value, this);
+    Result unsafe_operand(value);
     if (reversed) {
       LikelySmiBinaryOperation(op, &unsafe_operand, operand,
                                overwrite_mode);
     } else {
       LikelySmiBinaryOperation(op, operand, &unsafe_operand,
                                overwrite_mode);
     }
     ASSERT(!operand->is_valid());
     return;
   }
@@ skipping 19 matching lines @@
       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(this);  // Only allocate a new register if reversed.
+      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);
         __ 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);
         __ 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, this);
+        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);
         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, this);
+        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);
         operand->ToRegister();
@@ skipping 14 matching lines @@
         __ lea(answer.reg(),
                Operand(answer.reg(), answer.reg(), times_1, kSmiTag));
         deferred->BindExit(&answer);
         frame_->Push(&answer);
       }
       break;
     }
 
     case Token::SHL: {
       if (reversed) {
-        Result constant_operand(value, this);
+        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);
         operand->ToRegister();
@@ skipping 49 matching lines @@
         if (int_value != 0) {
           __ or_(Operand(operand->reg()), Immediate(value));
         }
       }
       deferred->BindExit(operand);
       frame_->Push(operand);
       break;
     }
 
     default: {
-      Result constant_operand(value, this);
+      Result constant_operand(value);
       if (reversed) {
         LikelySmiBinaryOperation(op, &constant_operand, operand,
                                  overwrite_mode);
       } else {
         LikelySmiBinaryOperation(op, operand, &constant_operand,
                                  overwrite_mode);
       }
       break;
     }
   }
@@ skipping 28 matching lines @@
 #endif
 };
 
 
 void CodeGenerator::Comparison(Condition cc,
                                bool strict,
                                ControlDestination* dest) {
   // Strict only makes sense for equality comparisons.
   ASSERT(!strict || cc == equal);
 
-  Result left_side(this);
-  Result right_side(this);
+  Result left_side;
+  Result right_side;
   // Implement '>' and '<=' by reversal to obtain ECMA-262 conversion order.
   if (cc == greater || cc == less_equal) {
     cc = ReverseCondition(cc);
     left_side = frame_->Pop();
     right_side = frame_->Pop();
   } else {
     right_side = frame_->Pop();
     left_side = frame_->Pop();
   }
   ASSERT(cc == less || cc == equal || cc == greater_equal);
@@ skipping 263 matching lines @@
     node->break_target()->Bind();
   }
   node->break_target()->Unuse();
 }
 
 
 void CodeGenerator::DeclareGlobals(Handle<FixedArray> pairs) {
   frame_->Push(pairs);
 
   // Duplicate the context register.
-  Result context(esi, this);
+  Result context(esi);
   frame_->Push(&context);
 
   frame_->Push(Smi::FromInt(is_eval() ? 1 : 0));
   Result ignored = frame_->CallRuntime(Runtime::kDeclareGlobals, 3);
   // Return value is ignored.
 }
 
 
 void CodeGenerator::VisitDeclaration(Declaration* node) {
   Comment cmnt(masm_, "[ Declaration");
   CodeForStatementPosition(node);
   Variable* var = node->proxy()->var();
   ASSERT(var != NULL);  // must have been resolved
   Slot* slot = var->slot();
 
   // If it was not possible to allocate the variable at compile time,
   // we need to "declare" it at runtime to make sure it actually
   // exists in the local context.
   if (slot != NULL && slot->type() == Slot::LOOKUP) {
     // Variables with a "LOOKUP" slot were introduced as non-locals
     // during variable resolution and must have mode DYNAMIC.
     ASSERT(var->is_dynamic());
     // For now, just do a runtime call.  Duplicate the context register.
-    Result context(esi, this);
+    Result context(esi);
     frame_->Push(&context);
     frame_->Push(var->name());
     // Declaration nodes are always introduced in one of two modes.
     ASSERT(node->mode() == Variable::VAR || node->mode() == Variable::CONST);
     PropertyAttributes attr = node->mode() == Variable::VAR ? NONE : READ_ONLY;
     frame_->Push(Smi::FromInt(attr));
     // Push initial value, if any.
     // Note: For variables we must not push an initial value (such as
     // 'undefined') because we may have a (legal) redeclaration and we
     // must not destroy the current value.
@@ skipping 218 matching lines @@
   ASSERT_EQ(Debug::kIa32JSReturnSequenceLength,
             masm_->SizeOfCodeGeneratedSince(&check_exit_codesize));
 }
 
 
 void CodeGenerator::VisitWithEnterStatement(WithEnterStatement* node) {
   ASSERT(!in_spilled_code());
   Comment cmnt(masm_, "[ WithEnterStatement");
   CodeForStatementPosition(node);
   Load(node->expression());
-  Result context(this);
+  Result context;
   if (node->is_catch_block()) {
     context = frame_->CallRuntime(Runtime::kPushCatchContext, 1);
   } else {
     context = frame_->CallRuntime(Runtime::kPushContext, 1);
   }
 
   // Update context local.
   frame_->SaveContextRegister();
 
   // Verify that the runtime call result and esi agree.
@@ skipping 888 matching lines @@
     // frame.
     frame_->EmitPop(Operand::StaticVariable(handler_address));
     frame_->Drop(StackHandlerConstants::kSize / kPointerSize - 1);
     if (has_unlinks) {
       exit.Jump();
     }
   }
 
   // Generate unlink code for the (formerly) shadowing targets that
   // have been jumped to.  Deallocate each shadow target.
-  Result return_value(this);
+  Result return_value;
   for (int i = 0; i < shadows.length(); i++) {
     if (shadows[i]->is_linked()) {
       // Unlink from try chain; be careful not to destroy the TOS if
       // there is one.
       if (i == kReturnShadowIndex) {
         shadows[i]->Bind(&return_value);
         return_value.ToRegister(eax);
       } else {
         shadows[i]->Bind();
       }
@@ skipping 111 matching lines @@
   }
 
   // Generate code to unlink and set the state for the (formerly)
   // shadowing targets that have been jumped to.
   for (int i = 0; i < shadows.length(); i++) {
     if (shadows[i]->is_linked()) {
       // If we have come from the shadowed return, the return value is
       // on the virtual frame.  We must preserve it until it is
       // pushed.
       if (i == kReturnShadowIndex) {
-        Result return_value(this);
+        Result return_value;
         shadows[i]->Bind(&return_value);
         return_value.ToRegister(eax);
       } else {
         shadows[i]->Bind();
       }
       // Because we can be jumping here (to spilled code) from
       // unspilled code, we need to reestablish a spilled frame at
       // this block.
       frame_->SpillAll();
 
@@ skipping 162 matching lines @@
   exit.Bind();
 }
 
 
 void CodeGenerator::LoadFromSlot(Slot* slot, TypeofState typeof_state) {
   if (slot->type() == Slot::LOOKUP) {
     ASSERT(slot->var()->is_dynamic());
 
     JumpTarget slow(this);
     JumpTarget done(this);
-    Result value(this);
+    Result value;
 
     // Generate fast-case code for variables that might be shadowed by
     // eval-introduced variables.  Eval is used a lot without
     // introducing variables.  In those cases, we do not want to
     // perform a runtime call for all variables in the scope
     // containing the eval.
     if (slot->var()->mode() == Variable::DYNAMIC_GLOBAL) {
       value = LoadFromGlobalSlotCheckExtensions(slot, typeof_state, &slow);
       // If there was no control flow to slow, we can exit early.
       if (!slow.is_linked()) {
@@ skipping 79 matching lines @@
   }
 }
 
 
 Result CodeGenerator::LoadFromGlobalSlotCheckExtensions(
     Slot* slot,
     TypeofState typeof_state,
     JumpTarget* slow) {
   // Check that no extension objects have been created by calls to
   // eval from the current scope to the global scope.
-  Result context(esi, this);
+  Result context(esi);
   Result tmp = allocator_->Allocate();
   ASSERT(tmp.is_valid());  // All non-reserved registers were available.
 
   Scope* s = scope();
   while (s != NULL) {
     if (s->num_heap_slots() > 0) {
       if (s->calls_eval()) {
         // Check that extension is NULL.
         __ cmp(ContextOperand(context.reg(), Context::EXTENSION_INDEX),
                Immediate(0));
@@ skipping 54 matching lines @@
 
 
 void CodeGenerator::StoreToSlot(Slot* slot, InitState init_state) {
   if (slot->type() == Slot::LOOKUP) {
     ASSERT(slot->var()->is_dynamic());
 
     // For now, just do a runtime call.
     frame_->Push(esi);
     frame_->Push(slot->var()->name());
 
-    Result value(this);
+    Result value;
     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
@@ skipping 122 matching lines @@
   }
 
   virtual void Generate();
 
  private:
   RegExpLiteral* node_;
 };
 
 
 void DeferredRegExpLiteral::Generate() {
-  Result literals(generator());
+  Result literals;
   enter()->Bind(&literals);
   // Since the entry is undefined we call the runtime system to
   // compute the literal.
 
   VirtualFrame* frame = generator()->frame();
   // Literal array (0).
   frame->Push(&literals);
   // Literal index (1).
   frame->Push(Smi::FromInt(node_->literal_index()));
   // RegExp pattern (2).
@@ skipping 56 matching lines @@
   }
 
   virtual void Generate();
 
  private:
   ObjectLiteral* node_;
 };
 
 
 void DeferredObjectLiteral::Generate() {
-  Result literals(generator());
+  Result literals;
   enter()->Bind(&literals);
   // Since the entry is undefined we call the runtime system to
   // compute the literal.
 
   VirtualFrame* frame = generator()->frame();
   // Literal array (0).
   frame->Push(&literals);
   // Literal index (1).
   frame->Push(Smi::FromInt(node_->literal_index()));
   // Constant properties (2).
@@ skipping 117 matching lines @@
   }
 
   virtual void Generate();
 
  private:
   ArrayLiteral* node_;
 };
 
 
 void DeferredArrayLiteral::Generate() {
-  Result literals(generator());
+  Result literals;
   enter()->Bind(&literals);
   // Since the entry is undefined we call the runtime system to
   // compute the literal.
 
   VirtualFrame* frame = generator()->frame();
   // Literal array (0).
   frame->Push(&literals);
   // Literal index (1).
   frame->Push(Smi::FromInt(node_->literal_index()));
   // Constant properties (2).
@@ skipping 628 matching lines @@
   value.Unuse();
   temp.Unuse();
   destination()->Split(equal);
 }
 
 
 void CodeGenerator::GenerateArgumentsLength(ZoneList<Expression*>* args) {
   ASSERT(args->length() == 0);
   // ArgumentsAccessStub takes the parameter count as an input argument
   // in register eax.  Create a constant result for it.
-  Result count(Handle<Smi>(Smi::FromInt(scope_->num_parameters())), this);
+  Result count(Handle<Smi>(Smi::FromInt(scope_->num_parameters())));
   // Call the shared stub to get to the arguments.length.
   ArgumentsAccessStub stub(ArgumentsAccessStub::READ_LENGTH);
   Result result = frame_->CallStub(&stub, &count);
   frame_->Push(&result);
 }
 
 
 void CodeGenerator::GenerateValueOf(ZoneList<Expression*>* args) {
   ASSERT(args->length() == 1);
   JumpTarget leave(this);
@@ skipping 62 matching lines @@
 
 
 void CodeGenerator::GenerateArgumentsAccess(ZoneList<Expression*>* args) {
   ASSERT(args->length() == 1);
 
   // ArgumentsAccessStub expects the key in edx and the formal
   // parameter count in eax.
   Load(args->at(0));
   Result key = frame_->Pop();
   // Explicitly create a constant result.
-  Result count(Handle<Smi>(Smi::FromInt(scope_->num_parameters())), this);
+  Result count(Handle<Smi>(Smi::FromInt(scope_->num_parameters())));
   // Call the shared stub to get to arguments[key].
   ArgumentsAccessStub stub(ArgumentsAccessStub::READ_ELEMENT);
   Result result = frame_->CallStub(&stub, &key, &count);
   frame_->Push(&result);
 }
 
 
 void CodeGenerator::GenerateObjectEquals(ZoneList<Expression*>* args) {
   ASSERT(args->length() == 2);
 
@@ skipping 229 matching lines @@
 
  private:
   bool is_postfix_;
   bool is_increment_;
   int target_size_;
 };
 
 
 void DeferredCountOperation::Generate() {
   CodeGenerator* cgen = generator();
-  Result value(cgen);
+  Result value;
   enter()->Bind(&value);
   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)));
   }
@@ skipping 477 matching lines @@
   Label* patch_site() { return &patch_site_; }
 
  private:
   Label patch_site_;
   Handle<String> name_;
 };
 
 
 void DeferredReferenceGetNamedValue::Generate() {
   CodeGenerator* cgen = generator();
-  Result receiver(cgen);
+  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
@@ skipping 21 matching lines @@
   Label* patch_site() { return &patch_site_; }
 
  private:
   Label patch_site_;
   bool is_global_;
 };
 
 
 void DeferredReferenceGetKeyedValue::Generate() {
   CodeGenerator* cgen = generator();
-  Result receiver(cgen);
-  Result key(cgen);
+  Result receiver;
+  Result key;
   enter()->Bind(&receiver, &key);
   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.
@@ skipping 1912 matching lines @@
 
   // Slow-case: Go through the JavaScript implementation.
   __ bind(&slow);
   __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal