Use unspilled frames in unary operations.

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 476 matching lines @@
   Variable* variable = x->AsVariableProxy()->AsVariable();
   if (variable != NULL && !variable->is_this() && variable->is_global()) {
     // NOTE: This is somewhat nasty. We force the compiler to load
     // the variable as if through '<global>.<variable>' to make sure we
     // do not get reference errors.
     Slot global(variable, Slot::CONTEXT, Context::GLOBAL_INDEX);
     Literal key(variable->name());
     // TODO(1241834): Fetch the position from the variable instead of using
     // no position.
     Property property(&global, &key, RelocInfo::kNoPosition);
-    LoadAndSpill(&property);
+    Load(&property);
   } else {
-    LoadAndSpill(x, INSIDE_TYPEOF);
+    Load(x, INSIDE_TYPEOF);
   }
 }
 
 
 Reference::Reference(CodeGenerator* cgen, Expression* expression)
     : cgen_(cgen), expression_(expression), type_(ILLEGAL) {
   cgen->LoadReference(this);
 }
 
 
@@ skipping 3113 matching lines @@
 
 void CodeGenerator::VisitUnaryOperation(UnaryOperation* node) {
   // 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);
+    LoadCondition(node->expression(), NOT_INSIDE_TYPEOF,
+                  false_target(), true_target(), true);
 
   } 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);
+      Load(property->obj());
+      Load(property->key());
+      Result answer = frame_->InvokeBuiltin(Builtins::DELETE, CALL_FUNCTION, 2);
+      frame_->Push(&answer);
       return;
     }
 
     Variable* variable = node->expression()->AsVariableProxy()->AsVariable();
     if (variable != NULL) {
       Slot* slot = variable->slot();
       if (variable->is_global()) {
         LoadGlobal();
-        frame_->EmitPush(Immediate(variable->name()));
-        frame_->InvokeBuiltin(Builtins::DELETE, CALL_FUNCTION, 2);
-        frame_->EmitPush(eax);
+        frame_->Push(variable->name());
+        Result answer = frame_->InvokeBuiltin(Builtins::DELETE,
+                                              CALL_FUNCTION, 2);
+        frame_->Push(&answer);
         return;
 
       } else if (slot != NULL && slot->type() == Slot::LOOKUP) {
         // lookup the context holding the named variable
-        frame_->EmitPush(esi);
-        frame_->EmitPush(Immediate(variable->name()));
-        frame_->CallRuntime(Runtime::kLookupContext, 2);
-        // eax: context
-        frame_->EmitPush(eax);
-        frame_->EmitPush(Immediate(variable->name()));
-        frame_->InvokeBuiltin(Builtins::DELETE, CALL_FUNCTION, 2);
-        frame_->EmitPush(eax);
+        frame_->Push(esi);
+        frame_->Push(variable->name());
+        Result context = frame_->CallRuntime(Runtime::kLookupContext, 2);
+        frame_->Push(&context);
+        frame_->Push(variable->name());
+        Result answer = frame_->InvokeBuiltin(Builtins::DELETE,
+                                              CALL_FUNCTION, 2);
+        frame_->Push(&answer);
         return;
       }
 
       // Default: Result of deleting non-global, not dynamically
       // introduced variables is false.
-      frame_->EmitPush(Immediate(Factory::false_value()));
+      frame_->Push(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()));
+      Load(node->expression());  // may have side-effects
+      frame_->SetElementAt(0, 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);
+    Result answer = frame_->CallRuntime(Runtime::kTypeof, 1);
+    frame_->Push(&answer);
 
   } else {
     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);
+        Result operand = frame_->Pop();
+        operand.ToRegister(eax);
+        Result answer = frame_->CallStub(&stub, &operand, 0);
+        frame_->Push(&answer);
         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);
+        Result operand = frame_->Pop();
+        operand.ToRegister();
+        __ test(operand.reg(), Immediate(kSmiTagMask));
+        smi_label.Branch(zero, &operand, taken);
 
-        frame_->EmitPush(eax);  // undo popping of TOS
-        frame_->InvokeBuiltin(Builtins::BIT_NOT, CALL_FUNCTION, 1);
+        frame_->Push(&operand);  // undo popping of TOS
+        Result answer = 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);
+        continue_label.Jump(&answer);
+        smi_label.Bind(&answer);
+        answer.ToRegister();
+        frame_->Spill(answer.reg());
+        __ not_(answer.reg());
+        __ and_(answer.reg(), ~kSmiTagMask);  // Remove inverted smi-tag.
+        continue_label.Bind(&answer);
+        frame_->Push(&answer);
         break;
       }
 
       case Token::VOID: {
-        VirtualFrame::SpilledScope spilled_scope(this);
-        __ mov(frame_->Top(), Factory::undefined_value());
+        frame_->SetElementAt(0, 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);
+        Result operand = frame_->Pop();
+        operand.ToRegister();
+        __ test(operand.reg(), Immediate(kSmiTagMask));
+        continue_label.Branch(zero, &operand, taken);
 
-        frame_->EmitPush(eax);
-        frame_->InvokeBuiltin(Builtins::TO_NUMBER, CALL_FUNCTION, 1);
+        frame_->Push(&operand);
+        Result answer = frame_->InvokeBuiltin(Builtins::TO_NUMBER,
+                                              CALL_FUNCTION, 1);
 
-        continue_label.Bind();
-        frame_->EmitPush(eax);
+        continue_label.Bind(&answer);
+        frame_->Push(&answer);
         break;
       }
 
       default:
         UNREACHABLE();
     }
   }
 }
 
 
@@ skipping 379 matching lines @@
   // To make typeof testing for natives implemented in JavaScript really
   // efficient, we generate special code for expressions of the form:
   // 'typeof <expression> == <string>'.
   UnaryOperation* operation = left->AsUnaryOperation();
   if ((op == Token::EQ || op == Token::EQ_STRICT) &&
       (operation != NULL && operation->op() == Token::TYPEOF) &&
       (right->AsLiteral() != NULL &&
        right->AsLiteral()->handle()->IsString())) {
     Handle<String> check(String::cast(*right->AsLiteral()->handle()));
 
-    VirtualFrame::SpilledScope spilled_scope(this);
     // Load the operand and move it to register edx.
     LoadTypeofExpression(operation->expression());
-    frame_->EmitPop(edx);
+    Result type_returned = frame_->Pop();
+    type_returned.ToRegister(edx);
+
+    VirtualFrame::SpilledScope spilled_scope(this);
+    type_returned.Unuse();
 
     if (check->Equals(Heap::number_symbol())) {
       __ test(edx, Immediate(kSmiTagMask));
       true_target()->Branch(zero);
       __ mov(edx, FieldOperand(edx, HeapObject::kMapOffset));
       __ cmp(edx, Factory::heap_number_map());
       true_target()->Branch(equal);
       false_target()->Jump();
 
     } else if (check->Equals(Heap::string_symbol())) {
@@ skipping 1923 matching lines @@
 
   // Slow-case: Go through the JavaScript implementation.
   __ bind(&slow);
   __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal