Push revision 3834 to trunk to fix binary operation bug that causes...

src/x64/codegen-x64.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 8001 matching lines @@
     Register right_arg = rax;
     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)) {
         __ movq(right_arg, right);
+      } else if (right.is(right_arg)) {
+        __ movq(left_arg, left);
       } else if (left.is(right_arg)) {
         if (IsOperationCommutative()) {
           __ movq(left_arg, right);
           SetArgsReversed();
         } else {
           // Order of moves important to avoid destroying left argument.
           __ movq(left_arg, left);
           __ movq(right_arg, right);
         }
       } else if (right.is(left_arg)) {
         if (IsOperationCommutative()) {
           __ movq(right_arg, left);
           SetArgsReversed();
         } else {
           // Order of moves important to avoid destroying right argument.
           __ movq(right_arg, right);
           __ movq(left_arg, left);
         }
-      } else if (right.is(right_arg)) {
-        __ movq(left_arg, left);
       } else {
         // Order of moves is not important.
         __ movq(left_arg, left);
         __ movq(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 rdx and right in rax.
     Register left_arg = rdx;
     Register right_arg = rax;
     if (left.is(left_arg)) {
       __ Move(right_arg, right);
     } else if (left.is(right_arg) && IsOperationCommutative()) {
       __ Move(left_arg, 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.
       __ movq(left_arg, left);
       __ Move(right_arg, 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 rdx and right in rax.
     Register left_arg = rdx;
     Register right_arg = rax;
     if (right.is(right_arg)) {
       __ Move(left_arg, left);
     } else if (right.is(left_arg) && IsOperationCommutative()) {
       __ Move(right_arg, 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.
+      __ movq(right_arg, right);
       __ Move(left_arg, left);
-      __ movq(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 1077 matching lines @@
   // Call the function from C++.
   return FUNCTION_CAST<ModuloFunction>(buffer);
 }
 
 #endif
 
 
 #undef __
 
 } }  // namespace v8::internal