Support register arguments in more cases....

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 960 matching lines @@
   if (left_is_smi && right_is_smi) {
     // Compute the constant result at compile time, and leave it on the frame.
     int left_int = Smi::cast(*left.handle())->value();
     int right_int = Smi::cast(*right.handle())->value();
     if (FoldConstantSmis(op, left_int, right_int)) return;
   }
 
   Result answer;
   if (left_is_non_smi || right_is_non_smi) {
     // Go straight to the slow case, with no smi code.
-    frame_->Push(&left);
-    frame_->Push(&right);
     GenericBinaryOpStub stub(op, overwrite_mode, NO_SMI_CODE_IN_STUB);
-    answer = frame_->CallStub(&stub, 2);
+    answer = stub.GenerateCall(masm_, frame_, &left, &right);
   } else if (right_is_smi) {
     answer = ConstantSmiBinaryOperation(op, &left, right.handle(),
                                         type, false, overwrite_mode);
   } else if (left_is_smi) {
     answer = ConstantSmiBinaryOperation(op, &right, left.handle(),
                                         type, true, overwrite_mode);
   } else {
     // Set the flags based on the operation, type and loop nesting level.
     // Bit operations always assume they likely operate on Smis. Still only
     // generate the inline Smi check code if this operation is part of a loop.
     // For all other operations only inline the Smi check code for likely smis
     // if the operation is part of a loop.
     if (loop_nesting() > 0 && (Token::IsBitOp(op) || type->IsLikelySmi())) {
       answer = LikelySmiBinaryOperation(op, &left, &right, overwrite_mode);
     } else {
-      frame_->Push(&left);
-      frame_->Push(&right);
       GenericBinaryOpStub stub(op, overwrite_mode, NO_GENERIC_BINARY_FLAGS);
-      answer = frame_->CallStub(&stub, 2);
+      answer = stub.GenerateCall(masm_, frame_, &left, &right);
     }
   }
   frame_->Push(&answer);
 }
 
 
 bool CodeGenerator::FoldConstantSmis(Token::Value op, int left, int right) {
   Object* answer_object = Heap::undefined_value();
   switch (op) {
     case Token::ADD:
@@ skipping 6055 matching lines @@
     // Update flags to indicate that arguments are in registers.
     SetArgsInRegisters();
     __ IncrementCounter(&Counters::generic_binary_stub_calls_regs, 1);
   }
 
   // Call the stub.
   __ CallStub(this);
 }
 
 
+Result GenericBinaryOpStub::GenerateCall(MacroAssembler* masm,
+                                         VirtualFrame* frame,
+                                         Result* left,
+                                         Result* right) {
+  if (ArgsInRegistersSupported()) {
+    SetArgsInRegisters();
+    return frame->CallStub(this, left, right);
+  } else {
+    frame->Push(left);
+    frame->Push(right);
+    return frame->CallStub(this, 2);
+  }
+}
+
+
 void GenericBinaryOpStub::GenerateSmiCode(MacroAssembler* masm, Label* slow) {
   if (HasArgsInRegisters()) {
     __ mov(ebx, eax);
     __ mov(eax, edx);
   } else {
     __ mov(ebx, Operand(esp, 1 * kPointerSize));
     __ mov(eax, Operand(esp, 2 * kPointerSize));
   }
 
   Label not_smis, not_smis_or_overflow, not_smis_undo_optimistic;
@@ skipping 11 matching lines @@
     case Token::ADD:
       __ add(eax, Operand(ebx));  // add optimistically
       __ j(overflow, &not_smis_or_overflow, not_taken);
       break;
 
     case Token::SUB:
       __ sub(eax, Operand(ebx));  // subtract optimistically
       __ j(overflow, &not_smis_or_overflow, not_taken);
       break;
 
+    case Token::MUL:
+      __ mov(edi, Operand(eax));  // backup the 1st operand

[Kevin Millikin (Chromium), 2010/01/26 09:07:22]

No need for Operand: __ mov(edi, eax).

Comment should be formatted like a sentence: Backup the left operand.

[Vladislav Kaznacheev, 2010/01/26 10:21:18]

Done.

+      break;
+
     case Token::DIV:
+      __ mov(edi, Operand(eax));  // backup the 1st operand
+      // Fall through.
     case Token::MOD:
       // Sign extend eax into edx:eax.
       __ cdq();
       // Check for 0 divisor.
       __ test(ebx, Operand(ebx));
       __ j(zero, &not_smis_or_overflow, not_taken);
       break;
 
     default:
       // Fall-through to smi check.
@@ skipping 115 matching lines @@
     default: break;
   }
   ASSERT(kSmiTag == 0);  // Adjust zero check if not the case.
   __ test(ecx, Immediate(kSmiTagMask));
   __ j(not_zero, &not_smis, not_taken);
   //  Correct operand values are in eax, ebx at this point.
 
   __ bind(&use_fp_on_smis);
   // Both operands are known to be SMIs but the result does not fit into a SMI.
   switch (op_) {
+    case Token::MUL:
+    case Token::DIV:
+      __ mov(eax, edi);  // Restore the 1st operand.
+      // Fall through.
     case Token::ADD:
-    case Token::SUB:
-    case Token::MUL:
-    case Token::DIV: {
+    case Token::SUB: {
       Label after_alloc_failure;
-
-      FloatingPointHelper::ArgLocation arg_location =
-          (op_ == Token::ADD || op_ == Token::SUB) ?
-          FloatingPointHelper::ARGS_IN_REGISTERS :
-          FloatingPointHelper::ARGS_ON_STACK;
-
-      __ AllocateHeapNumber(
-          edx,
-          ecx,
-          no_reg,
-          arg_location == FloatingPointHelper::ARGS_IN_REGISTERS ?
-              &after_alloc_failure :
-              slow);
+      __ AllocateHeapNumber(edx, ecx, no_reg, &after_alloc_failure);
 
       if (CpuFeatures::IsSupported(SSE2)) {
         CpuFeatures::Scope use_sse2(SSE2);
-        FloatingPointHelper::LoadSse2Smis(masm, ecx, arg_location);
+        FloatingPointHelper::LoadSse2Smis(
+            masm,
+            ecx,
+            FloatingPointHelper::ARGS_IN_REGISTERS);

[Kevin Millikin (Chromium), 2010/01/26 09:07:22]

Does LoadSse2Smis need the ArgLocation argument any more?  It now expects them
in registers at all call sites.

[Vladislav Kaznacheev, 2010/01/26 10:21:18]

Removed (also for LoadFloatSmis).
On 2010/01/26 09:07:22, Kevin Millikin wrote:

         switch (op_) {
           case Token::ADD: __ addsd(xmm0, xmm1); break;
           case Token::SUB: __ subsd(xmm0, xmm1); break;
           case Token::MUL: __ mulsd(xmm0, xmm1); break;
           case Token::DIV: __ divsd(xmm0, xmm1); break;
           default: UNREACHABLE();
         }
         __ movdbl(FieldOperand(edx, HeapNumber::kValueOffset), xmm0);
       } else {  // SSE2 not available, use FPU.
-        FloatingPointHelper::LoadFloatSmis(masm, ecx, arg_location);
+        FloatingPointHelper::LoadFloatSmis(
+            masm,
+            ecx,
+            FloatingPointHelper::ARGS_IN_REGISTERS);
         switch (op_) {
           case Token::ADD: __ faddp(1); break;
           case Token::SUB: __ fsubp(1); break;
           case Token::MUL: __ fmulp(1); break;
           case Token::DIV: __ fdivp(1); break;
           default: UNREACHABLE();
         }
         __ fstp_d(FieldOperand(edx, HeapNumber::kValueOffset));
       }
       __ mov(eax, edx);
       GenerateReturn(masm);
 
-      if (arg_location == FloatingPointHelper::ARGS_IN_REGISTERS) {
-        __ bind(&after_alloc_failure);
-        __ mov(edx, eax);
-        __ mov(eax, ebx);
-        __ jmp(slow);
-      }
+      __ bind(&after_alloc_failure);
+      __ mov(edx, eax);
+      __ mov(eax, ebx);
+      __ jmp(slow);
       break;
     }
 
     case Token::BIT_OR:
     case Token::BIT_AND:
     case Token::BIT_XOR:
     case Token::SAR:
       // Do nothing here as these operations always succeed on a pair of smis.
       break;
 
@@ skipping 125 matching lines @@
       }
       // Tag smi result and return.
       __ SmiTag(eax);
       GenerateReturn(masm);
 
       // All ops except SHR return a signed int32 that we load in a HeapNumber.
       if (op_ != Token::SHR) {
         __ bind(&non_smi_result);
         // Allocate a heap number if needed.
         __ mov(ebx, Operand(eax));  // ebx: result
-       Label skip_allocation;
+        Label skip_allocation;
         switch (mode_) {
           case OVERWRITE_LEFT:
           case OVERWRITE_RIGHT:
             // If the operand was an object, we skip the
             // allocation of a heap number.
             __ mov(eax, Operand(esp, mode_ == OVERWRITE_RIGHT ?
                                 1 * kPointerSize : 2 * kPointerSize));
             __ test(eax, Immediate(kSmiTagMask));
             __ j(not_zero, &skip_allocation, not_taken);
             // Fall through!
@@ skipping 2536 matching lines @@
 
   // Call the runtime; it returns -1 (less), 0 (equal), or 1 (greater)
   // tagged as a small integer.
   __ bind(&runtime);
   __ TailCallRuntime(ExternalReference(Runtime::kStringCompare), 2, 1);
 }
 
 #undef __
 
 } }  // namespace v8::internal