Make separate spilled scopes for each unary operation.

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 3745 matching lines @@
     __ mov(frame_->Top(), eax);
   } else {
     // Call the C runtime function.
     frame_->CallRuntime(function, arg_count);
     frame_->EmitPush(eax);
   }
 }
 
 
 void CodeGenerator::VisitUnaryOperation(UnaryOperation* node) {
-  VirtualFrame::SpilledScope spilled_scope(this);
   // Note that because of NOT and an optimization in comparison of a typeof
   // expression to a literal string, this function can fail to leave a value
   // on top of the frame or in the cc register.
   Comment cmnt(masm_, "[ UnaryOperation");
 
   Token::Value op = node->op();
 
   if (op == Token::NOT) {
+    VirtualFrame::SpilledScope spilled_scope(this);
     LoadConditionAndSpill(node->expression(), NOT_INSIDE_TYPEOF,
                           false_target(), true_target(), true);
     cc_reg_ = NegateCondition(cc_reg_);
 
   } else if (op == Token::DELETE) {
+    VirtualFrame::SpilledScope spilled_scope(this);
     Property* property = node->expression()->AsProperty();
     if (property != NULL) {
       LoadAndSpill(property->obj());
       LoadAndSpill(property->key());
       frame_->InvokeBuiltin(Builtins::DELETE, CALL_FUNCTION, 2);
       frame_->EmitPush(eax);
       return;
     }
 
     Variable* variable = node->expression()->AsVariableProxy()->AsVariable();
@@ skipping 23 matching lines @@
       // introduced variables is false.
       frame_->EmitPush(Immediate(Factory::false_value()));
 
     } else {
       // Default: Result of deleting expressions is true.
       LoadAndSpill(node->expression());  // may have side-effects
       __ Set(frame_->Top(), Immediate(Factory::true_value()));
     }
 
   } else if (op == Token::TYPEOF) {
+    VirtualFrame::SpilledScope spilled_scope(this);
     // Special case for loading the typeof expression; see comment on
     // LoadTypeofExpression().
     LoadTypeofExpression(node->expression());
     frame_->CallRuntime(Runtime::kTypeof, 1);
     frame_->EmitPush(eax);
 
   } else {
-    LoadAndSpill(node->expression());
+    Load(node->expression());
     switch (op) {
       case Token::NOT:
       case Token::DELETE:
       case Token::TYPEOF:
         UNREACHABLE();  // handled above
         break;
 
       case Token::SUB: {
+        VirtualFrame::SpilledScope spilled_scope(this);
         UnarySubStub stub;
         // TODO(1222589): remove dependency of TOS being cached inside stub
         frame_->EmitPop(eax);
         frame_->CallStub(&stub, 0);
         frame_->EmitPush(eax);
         break;
       }
 
       case Token::BIT_NOT: {
+        VirtualFrame::SpilledScope spilled_scope(this);
         // Smi check.
         JumpTarget smi_label(this);
         JumpTarget continue_label(this);
         frame_->EmitPop(eax);
         __ test(eax, Immediate(kSmiTagMask));
         smi_label.Branch(zero, taken);
 
         frame_->EmitPush(eax);  // undo popping of TOS
         frame_->InvokeBuiltin(Builtins::BIT_NOT, CALL_FUNCTION, 1);
 
         continue_label.Jump();
         smi_label.Bind();
         __ not_(eax);
         __ and_(eax, ~kSmiTagMask);  // Remove inverted smi-tag.
         continue_label.Bind();
         frame_->EmitPush(eax);
         break;
       }
 
-      case Token::VOID:
+      case Token::VOID: {
+        VirtualFrame::SpilledScope spilled_scope(this);
         __ mov(frame_->Top(), Factory::undefined_value());
         break;
+      }
 
       case Token::ADD: {
+        VirtualFrame::SpilledScope spilled_scope(this);
         // Smi check.
         JumpTarget continue_label(this);
         frame_->EmitPop(eax);
         __ test(eax, Immediate(kSmiTagMask));
         continue_label.Branch(zero);
 
         frame_->EmitPush(eax);
         frame_->InvokeBuiltin(Builtins::TO_NUMBER, CALL_FUNCTION, 1);
 
         continue_label.Bind();
@@ skipping 2354 matching lines @@
 
   // Slow-case: Go through the JavaScript implementation.
   __ bind(&slow);
   __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal