Fix problem with GenericBinaryOperationStub::GenerateCall for a Smi...

src/ia32/codegen-ia32.cc

 // Copyright 2010 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 7018 matching lines @@
     Register right_arg = eax;
     if (!(left.is(left_arg) && right.is(right_arg))) {
       if (left.is(right_arg) && right.is(left_arg)) {
         if (IsOperationCommutative()) {
           SetArgsReversed();
         } else {
           __ xchg(left, right);
         }
       } else if (left.is(left_arg)) {
         __ mov(right_arg, right);
+      } else if (right.is(right_arg)) {
+        __ mov(left_arg, left);
       } else if (left.is(right_arg)) {
         if (IsOperationCommutative()) {
           __ mov(left_arg, right);
           SetArgsReversed();
         } else {
           // Order of moves important to avoid destroying left argument.
           __ mov(left_arg, left);
           __ mov(right_arg, right);
         }
       } else if (right.is(left_arg)) {
         if (IsOperationCommutative()) {
           __ mov(right_arg, left);
           SetArgsReversed();
         } else {
           // Order of moves important to avoid destroying right argument.
           __ mov(right_arg, right);
           __ mov(left_arg, left);
         }
-      } else if (right.is(right_arg)) {
-        __ mov(left_arg, left);
       } else {
         // Order of moves is not important.
         __ mov(left_arg, left);
         __ mov(right_arg, right);
       }
     }
 
     // Update flags to indicate that arguments are in registers.
     SetArgsInRegisters();
     __ IncrementCounter(&Counters::generic_binary_stub_calls_regs, 1);
@@ skipping 15 matching lines @@
   } else {
     // The calling convention with registers is left in edx and right in eax.
     Register left_arg = edx;
     Register right_arg = eax;
     if (left.is(left_arg)) {
       __ mov(right_arg, Immediate(right));
     } else if (left.is(right_arg) && IsOperationCommutative()) {
       __ mov(left_arg, Immediate(right));
       SetArgsReversed();
     } else {
+      // For non-commutative operations, left and right_arg might be
+      // the same register.  Therefore, the order of the moves is
+      // important here in order to not overwrite left before moving
+      // it to left_arg.
       __ mov(left_arg, left);
       __ mov(right_arg, Immediate(right));
     }
 
     // Update flags to indicate that arguments are in registers.
     SetArgsInRegisters();
     __ IncrementCounter(&Counters::generic_binary_stub_calls_regs, 1);
   }
 
   // Call the stub.
@@ skipping 12 matching lines @@
   } else {
     // The calling convention with registers is left in edx and right in eax.
     Register left_arg = edx;
     Register right_arg = eax;
     if (right.is(right_arg)) {
       __ mov(left_arg, Immediate(left));
     } else if (right.is(left_arg) && IsOperationCommutative()) {
       __ mov(right_arg, Immediate(left));
       SetArgsReversed();
     } else {
+      // For non-commutative operations, right and left_arg might be
+      // the same register.  Therefore, the order of the moves is
+      // important here in order to not overwrite right before moving
+      // it to right_arg.
+      __ mov(right_arg, right);
       __ mov(left_arg, Immediate(left));
-      __ mov(right_arg, right);
     }
     // Update flags to indicate that arguments are in registers.
     SetArgsInRegisters();
     __ IncrementCounter(&Counters::generic_binary_stub_calls_regs, 1);
   }
 
   // Call the stub.
   __ CallStub(this);
 }
 
@@ skipping 2956 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