Make VirtualFrame::CallStub on IA32 responsible for moving arguments...

src/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 1490 matching lines @@
         // CompareStub and the inline code both support all values of cc.
       }
       // Implement comparison against a constant Smi, inlining the case
       // where both sides are Smis.
       left_side.ToRegister();
       ASSERT(left_side.is_valid());
       JumpTarget is_smi(this);
       __ test(left_side.reg(), Immediate(kSmiTagMask));
       is_smi.Branch(zero, &left_side, &right_side, taken);
 
-      // Setup and call the compare stub, which expects arguments in edx
-      // and eax.
+      // Setup and call the compare stub, which expects its arguments
+      // in registers.
       CompareStub stub(cc, strict);
-      left_side.ToRegister(edx);  // Only left_side currently uses a register.
-      right_side.ToRegister(eax);  // left_side is not in eax.  eax is free.
-      Result result = frame_->CallStub(&stub, &left_side, &right_side, 0);
+      Result result = frame_->CallStub(&stub, &left_side, &right_side);
       result.ToRegister();
       __ cmp(result.reg(), 0);
       result.Unuse();
       dest->true_target()->Branch(cc);
       dest->false_target()->Jump();
 
       is_smi.Bind(&left_side, &right_side);
       left_side.ToRegister();
       // Test smi equality and comparison by signed int comparison.
       if (IsUnsafeSmi(right_side.handle())) {
@@ skipping 54 matching lines @@
     if (!known_non_smi) {
       // Check for the smi case.
       Result temp = allocator_->Allocate();
       ASSERT(temp.is_valid());
       __ mov(temp.reg(), left_side.reg());
       __ or_(temp.reg(), Operand(right_side.reg()));
       __ test(temp.reg(), Immediate(kSmiTagMask));
       temp.Unuse();
       is_smi.Branch(zero, &left_side, &right_side, taken);
     }
-    // When non-smi, call out to the compare stub.  "parameters" setup by
-    // calling code in edx and eax and "result" is returned in the flags.
-    if (!left_side.reg().is(eax)) {
-      right_side.ToRegister(eax);
-      left_side.ToRegister(edx);
-    } else if (!right_side.reg().is(edx)) {
-      left_side.ToRegister(edx);
-      right_side.ToRegister(eax);
-    } else {
-      frame_->Spill(eax);  // Can be multiply referenced, even now.
-      frame_->Spill(edx);
-      __ xchg(eax, edx);
-      // If left_side and right_side become real (non-dummy) arguments
-      // to CallStub, they need to be swapped in this case.
-    }
+    // When non-smi, call out to the compare stub, which expects its
+    // arguments in registers.
     CompareStub stub(cc, strict);
-    Result answer = frame_->CallStub(&stub, &right_side, &left_side, 0);
+    Result answer = frame_->CallStub(&stub, &left_side, &right_side);
     if (cc == equal) {
       __ test(answer.reg(), Operand(answer.reg()));
     } else {
       __ cmp(answer.reg(), 0);
     }
     answer.Unuse();
     if (known_non_smi) {
       dest->Split(cc);
     } else {
       dest->true_target()->Branch(cc);
@@ skipping 2767 matching lines @@
   // Check if the object is a JS array or not.
   __ CmpObjectType(value.reg(), JS_ARRAY_TYPE, temp.reg());
   value.Unuse();
   temp.Unuse();
   destination()->Split(equal);
 }
 
 
 void CodeGenerator::GenerateArgumentsLength(ZoneList<Expression*>* args) {
   ASSERT(args->length() == 0);
-  Result initial_value = allocator()->Allocate(eax);
-  ASSERT(initial_value.is_valid());
-  __ Set(initial_value.reg(),
-         Immediate(Smi::FromInt(scope_->num_parameters())));
   // ArgumentsAccessStub takes the parameter count as an input argument
-  // in register eax.
+  // in register eax.  Create a constant result for it.
+  Result count(Handle<Smi>(Smi::FromInt(scope_->num_parameters())), this);
   // Call the shared stub to get to the arguments.length.
   ArgumentsAccessStub stub(ArgumentsAccessStub::READ_LENGTH);
-  Result result = frame_->CallStub(&stub, &initial_value, 0);
+  Result result = frame_->CallStub(&stub, &count);
   frame_->Push(&result);
 }
 
 
 void CodeGenerator::GenerateValueOf(ZoneList<Expression*>* args) {
   ASSERT(args->length() == 1);
   JumpTarget leave(this);
   Load(args->at(0));  // Load the object.
   frame_->Dup();
   Result object = frame_->Pop();
@@ skipping 54 matching lines @@
 
   // Leave.
   leave.Bind(&value);
   frame_->Push(&value);
 }
 
 
 void CodeGenerator::GenerateArgumentsAccess(ZoneList<Expression*>* args) {
   ASSERT(args->length() == 1);
 
-  // Load the key into edx and set eax to the formal parameters count
-  // for the currently executing function.
+  // ArgumentsAccessStub expects the key in edx and the formal
+  // parameter count in eax.
   Load(args->at(0));
   Result key = frame_->Pop();
-  key.ToRegister(edx);
-
-  Result parameters_count = allocator()->Allocate(eax);
-  ASSERT(parameters_count.is_valid());
-  __ Set(parameters_count.reg(),
-         Immediate(Smi::FromInt(scope_->num_parameters())));
-
+  // Explicitly create a constant result.
+  Result count(Handle<Smi>(Smi::FromInt(scope_->num_parameters())), this);
   // Call the shared stub to get to arguments[key].
   ArgumentsAccessStub stub(ArgumentsAccessStub::READ_ELEMENT);
-  Result result = frame_->CallStub(&stub, &parameters_count, &key, 0);
+  Result result = frame_->CallStub(&stub, &key, &count);
   frame_->Push(&result);
 }
 
 
 void CodeGenerator::GenerateObjectEquals(ZoneList<Expression*>* args) {
   ASSERT(args->length() == 2);
 
   // Load the two objects into registers and perform the comparison.
   Load(args->at(0));
   Load(args->at(1));
@@ skipping 138 matching lines @@
       case Token::NOT:
       case Token::DELETE:
       case Token::TYPEOF:
         UNREACHABLE();  // handled above
         break;
 
       case Token::SUB: {
         UnarySubStub stub;
         // TODO(1222589): remove dependency of TOS being cached inside stub
         Result operand = frame_->Pop();
-        operand.ToRegister(eax);
-        Result answer = frame_->CallStub(&stub, &operand, 0);
+        Result answer = frame_->CallStub(&stub, &operand);
         frame_->Push(&answer);
         break;
       }
 
       case Token::BIT_NOT: {
         // Smi check.
         JumpTarget smi_label(this);
         JumpTarget continue_label(this);
         Result operand = frame_->Pop();
         operand.ToRegister();
@@ skipping 112 matching lines @@
   }
 #endif
 };
 
 
 void DeferredCountOperation::Generate() {
   CodeGenerator* cgen = generator();
 
   Result value(cgen);
   enter()->Bind(&value);
-  value.ToRegister(eax);  // The stubs below expect their argument in eax.
-
   if (is_postfix_) {
     RevertToNumberStub to_number_stub(is_increment_);
-    value = generator()->frame()->CallStub(&to_number_stub, &value, 0);
+    value = generator()->frame()->CallStub(&to_number_stub, &value);
   }
 
   CounterOpStub stub(result_offset_, is_postfix_, is_increment_);
-  value = generator()->frame()->CallStub(&stub, &value, 0);
+  value = generator()->frame()->CallStub(&stub, &value);
   exit_.Jump(&value);
 }
 
 
 void CodeGenerator::VisitCountOperation(CountOperation* node) {
   Comment cmnt(masm_, "[ CountOperation");
 
   bool is_postfix = node->is_postfix();
   bool is_increment = node->op() == Token::INC;
 
@@ skipping 2291 matching lines @@
 
   // Slow-case: Go through the JavaScript implementation.
   __ bind(&slow);
   __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal