Remove spilled frame from some function entry code....

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 156 matching lines @@
 #endif
 
     // Allocate space for locals and initialize them.
     frame_->AllocateStackSlots(scope_->num_stack_slots());
 
     // Allocate the arguments object and copy the parameters into it.
     if (scope_->arguments() != NULL) {
       ASSERT(scope_->arguments_shadow() != NULL);
       Comment cmnt(masm_, "[ Allocate arguments object");
       ArgumentsAccessStub stub(ArgumentsAccessStub::NEW_OBJECT);
-      VirtualFrame::SpilledScope spilled_scope(this);
-      __ lea(eax, frame_->Receiver());
-      frame_->EmitPush(frame_->Function());
-      frame_->EmitPush(eax);
-      frame_->EmitPush(Immediate(Smi::FromInt(scope_->num_parameters())));
+      frame_->PushFunction();
+      frame_->PushReceiverSlotAddress();
+      frame_->Push(Smi::FromInt(scope_->num_parameters()));
       Result answer = frame_->CallStub(&stub, 3);
       frame_->Push(&answer);
     }
 
     if (scope_->num_heap_slots() > 0) {
       Comment cmnt(masm_, "[ allocate local context");
       // Allocate local context.
       // Get outer context and create a new context based on it.
-      VirtualFrame::SpilledScope spilled_scope(this);
-      frame_->EmitPush(frame_->Function());
-      frame_->CallRuntime(Runtime::kNewContext, 1);  // eax holds the result
+      frame_->PushFunction();
+      Result context = frame_->CallRuntime(Runtime::kNewContext, 1);
 
       if (kDebug) {
+        frame_->SpillAll();  // Needed for breakpoint below.
         JumpTarget verified_true(this);
         // Verify eax and esi are the same in debug mode
-        __ cmp(eax, Operand(esi));
+        __ cmp(context.reg(), Operand(esi));
+        context.Unuse();
         verified_true.Branch(equal);
         __ int3();
         verified_true.Bind();
       }
       // Update context local.
       frame_->SaveContextRegister();
     }
 
     // TODO(1241774): Improve this code:
     // 1) only needed if we have a context
@@ skipping 648 matching lines @@
 
 class DeferredInlinedSmiAdd: public DeferredCode {
  public:
   DeferredInlinedSmiAdd(CodeGenerator* generator, int value,
                         OverwriteMode overwrite_mode) :
       DeferredCode(generator), value_(value), overwrite_mode_(overwrite_mode) {
     set_comment("[ DeferredInlinedSmiAdd");
   }
 
   virtual void Generate() {
-    // The argument is actually passed in eax.
-    enter()->Bind();
-    VirtualFrame::SpilledScope spilled_scope(generator());
+    Result arg(generator());
+    enter()->Bind(&arg);
+    arg.ToRegister();
+    generator()->frame()->Spill(arg.reg());
     // Undo the optimistic add operation and call the shared stub.
-    Immediate immediate(Smi::FromInt(value_));
-    __ sub(Operand(eax), immediate);
-    generator()->frame()->EmitPush(eax);
-    generator()->frame()->EmitPush(immediate);
+    __ sub(Operand(arg.reg()), Immediate(Smi::FromInt(value_)));
+    generator()->frame()->Push(&arg);
+    generator()->frame()->Push(Smi::FromInt(value_));
     GenericBinaryOpStub igostub(Token::ADD, overwrite_mode_, SMI_CODE_INLINED);
-    generator()->frame()->CallStub(&igostub, 2);
-    // The result is actually returned in eax.
-    exit()->Jump();
+    Result result = generator()->frame()->CallStub(&igostub, 2);
+    exit()->Jump(&result);
   }
 
  private:
   int value_;
   OverwriteMode overwrite_mode_;
 };
 
 
 class DeferredInlinedSmiAddReversed: public DeferredCode {
  public:
   DeferredInlinedSmiAddReversed(CodeGenerator* generator, int value,
                         OverwriteMode overwrite_mode) :
       DeferredCode(generator), value_(value), overwrite_mode_(overwrite_mode) {
     set_comment("[ DeferredInlinedSmiAddReversed");
   }
 
   virtual void Generate() {
-    // The argument is actually passed in eax.
-    enter()->Bind();
-    VirtualFrame::SpilledScope spilled_scope(generator());
+    Result arg(generator());
+    enter()->Bind(&arg);
+    arg.ToRegister();
+    generator()->frame()->Spill(arg.reg());  // Should not be needed.
     // Undo the optimistic add operation and call the shared stub.
     Immediate immediate(Smi::FromInt(value_));
-    __ sub(Operand(eax), immediate);
-    generator()->frame()->EmitPush(immediate);
-    generator()->frame()->EmitPush(eax);
+    __ sub(Operand(arg.reg()), immediate);
+    generator()->frame()->Push(Smi::FromInt(value_));
+    generator()->frame()->Push(&arg);
     GenericBinaryOpStub igostub(Token::ADD, overwrite_mode_, SMI_CODE_INLINED);
-    generator()->frame()->CallStub(&igostub, 2);
-    // The result is actually returned in eax.
-    exit()->Jump();
+    arg = generator()->frame()->CallStub(&igostub, 2);
+    exit()->Jump(&arg);
   }
 
  private:
   int value_;
   OverwriteMode overwrite_mode_;
 };
 
 
 class DeferredInlinedSmiSub: public DeferredCode {
  public:
@@ skipping 77 matching lines @@
 
   switch (op) {
     case Token::ADD: {
       DeferredCode* deferred = NULL;
       if (!reversed) {
         deferred = new DeferredInlinedSmiAdd(this, int_value, overwrite_mode);
       } else {
         deferred = new DeferredInlinedSmiAddReversed(this, int_value,
                                                      overwrite_mode);
       }
-      frame_->EmitPop(eax);
-      __ add(Operand(eax), Immediate(value));
-      deferred->enter()->Branch(overflow, not_taken);
-      __ test(eax, Immediate(kSmiTagMask));
-      deferred->enter()->Branch(not_zero, not_taken);
-      deferred->exit()->Bind();
-      frame_->EmitPush(eax);
+      Result operand = frame_->Pop();
+      operand.ToRegister();
+      frame_->Spill(operand.reg());
+      __ add(Operand(operand.reg()), Immediate(value));
+      deferred->enter()->Branch(overflow, &operand, not_taken);
+      __ test(Operand(operand.reg()), Immediate(kSmiTagMask));
+      deferred->enter()->Branch(not_zero, &operand, not_taken);
+      deferred->exit()->Bind(&operand);
+      frame_->Push(&operand);
       break;
     }
 
     case Token::SUB: {
       DeferredCode* deferred = NULL;
       frame_->EmitPop(eax);
       if (!reversed) {
         deferred = new DeferredInlinedSmiSub(this, int_value, overwrite_mode);
         __ sub(Operand(eax), Immediate(value));
       } else {
@@ skipping 1987 matching lines @@
 
 
 void CodeGenerator::VisitAssignment(Assignment* node) {
   Comment cmnt(masm_, "[ Assignment");
   CodeForStatement(node);
 
   { Reference target(this, node->target());
     if (target.is_illegal()) {
       // Fool the virtual frame into thinking that we left the assignment's
       // value on the frame.
-      frame_->Push(Handle<Object>(Smi::FromInt(0)));
+      frame_->Push(Smi::FromInt(0));
       return;
     }
 
     if (node->op() == Token::ASSIGN ||
         node->op() == Token::INIT_VAR ||
         node->op() == Token::INIT_CONST) {
       Load(node->value());
 
     } else {
       VirtualFrame::SpilledScope spilled_scope(this);
@@ skipping 829 matching lines @@
   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: Make room for the result.
   if (is_postfix) {
-    frame_->Push(Handle<Object>(Smi::FromInt(0)));
+    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(Handle<Object>(Smi::FromInt(0)));
+        frame_->Push(Smi::FromInt(0));
       }
       return;
     }
     target.TakeValue(NOT_INSIDE_TYPEOF);
 
     DeferredCountOperation* deferred =
         new DeferredCountOperation(this, is_postfix, is_increment,
                                    target.size() * kPointerSize);
 
     Result value = frame_->Pop();
@@ skipping 2222 matching lines @@
 
   // Slow-case: Go through the JavaScript implementation.
   __ bind(&slow);
   __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal