Merge bleeding_edge revision 3032 to trunk...

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 6513 matching lines @@
   __ mov(eax, 0);
   __ ret(1 * kPointerSize);
 }
 
 
 void GenericBinaryOpStub::GenerateCall(
     MacroAssembler* masm,
     Register left,
     Register right) {
   if (!ArgsInRegistersSupported()) {
-    // Only pass arguments in registers if there is no smi code in the stub.
+    // Pass arguments on the stack.
     __ push(left);
     __ push(right);
   } else {
     // The calling convention with registers is left in edx and right in eax.
     __ IncrementCounter(&Counters::generic_binary_stub_calls_regs, 1);
     if (!(left.is(edx) && right.is(eax))) {
       if (left.is(eax) && right.is(edx)) {
         if (IsOperationCommutative()) {
           SetArgsReversed();
         } else {
@@ skipping 32 matching lines @@
   // Call the stub.
   __ CallStub(this);
 }
 
 
 void GenericBinaryOpStub::GenerateCall(
     MacroAssembler* masm,
     Register left,
     Smi* right) {
   if (!ArgsInRegistersSupported()) {
-    // Only pass arguments in registers if there is no smi code in the stub.
+    // Pass arguments on the stack.
     __ push(left);
     __ push(Immediate(right));
   } else {
     // Adapt arguments to the calling convention left in edx and right in eax.
     if (left.is(edx)) {
       __ mov(eax, Immediate(right));
     } else if (left.is(eax) && IsOperationCommutative()) {
       __ mov(edx, Immediate(right));
       SetArgsReversed();
     } else {
       __ mov(edx, left);
       __ mov(eax, Immediate(right));
     }
 
     // Update flags to indicate that arguments are in registers.
     SetArgsInRegisters();
   }
 
   // Call the stub.
   __ CallStub(this);
 }
 
 
 void GenericBinaryOpStub::GenerateCall(
     MacroAssembler* masm,
     Smi* left,
     Register right) {
-  if (flags_ != NO_SMI_CODE_IN_STUB) {
-    // Only pass arguments in registers if there is no smi code in the stub.
+  if (!ArgsInRegistersSupported()) {
+    // Pass arguments on the stack.
     __ push(Immediate(left));
     __ push(right);
   } else {
     // Adapt arguments to the calling convention left in edx and right in eax.
     bool is_commutative = (op_ == (Token::ADD) || (op_ == Token::MUL));
     if (right.is(eax)) {
       __ mov(edx, Immediate(left));
     } else if (right.is(edx) && is_commutative) {
         __ mov(eax, Immediate(left));
     } else {
@@ skipping 1499 matching lines @@
 
 int CompareStub::MinorKey() {
   // Encode the two parameters in a unique 16 bit value.
   ASSERT(static_cast<unsigned>(cc_) < (1 << 15));
   return (static_cast<unsigned>(cc_) << 1) | (strict_ ? 1 : 0);
 }
 
 #undef __
 
 } }  // namespace v8::internal