X64: Fixed bug de-tagging of smis in multiplication code.

src/x64/codegen-x64.cc

 // Copyright 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 5136 matching lines @@
     case Token::SUB:
       __ subl(answer.reg(), right->reg());
       deferred->Branch(overflow);
       break;
 
     case Token::MUL: {
       // If the smi tag is 0 we can just leave the tag on one operand.
       ASSERT(kSmiTag == 0);  // Adjust code below if not the case.
       // Remove smi tag from the left operand (but keep sign).
       // Left-hand operand has been copied into answer.
-      __ sar(answer.reg(), Immediate(kSmiTagSize));
+      __ sarl(answer.reg(), Immediate(kSmiTagSize));
       // Do multiplication of smis, leaving result in answer.
       __ imull(answer.reg(), right->reg());
       // Go slow on overflows.
       deferred->Branch(overflow);
       // Check for negative zero result.  If product is zero, and one
       // argument is negative, go to slow case.  The frame is unchanged
       // in this block, so local control flow can use a Label rather
       // than a JumpTarget.
       Label non_zero_result;
       __ testq(answer.reg(), answer.reg());
       __ j(not_zero, &non_zero_result);
       __ movq(answer.reg(), left->reg());
       __ or_(answer.reg(), right->reg());
       deferred->Branch(negative);
       __ xor_(answer.reg(), answer.reg());  // Positive 0 is correct.
       __ bind(&non_zero_result);
       break;
     }
 
     case Token::BIT_OR:
       __ or_(answer.reg(), right->reg());
       break;
 
     case Token::BIT_AND:
       __ and_(answer.reg(), right->reg());
       break;
 
     case Token::BIT_XOR:
+      ASSERT(kSmiTag == 0);  // Adjust code below if not the case.
       __ xor_(answer.reg(), right->reg());
       break;
 
     default:
       UNREACHABLE();
       break;
   }
   deferred->BindExit();
   left->Unuse();
   right->Unuse();
@@ skipping 1227 matching lines @@
                                            Register src,
                                            XMMRegister dst) {
   Label load_smi, done;
 
   __ testl(src, Immediate(kSmiTagMask));
   __ j(zero, &load_smi);
   __ movsd(dst, FieldOperand(src, HeapNumber::kValueOffset));
   __ jmp(&done);
 
   __ bind(&load_smi);
-  __ sar(src, Immediate(kSmiTagSize));
+  __ sarl(src, Immediate(kSmiTagSize));
   __ cvtlsi2sd(dst, src);
 
   __ bind(&done);
 }
 
 
 void FloatingPointHelper::LoadFloatOperands(MacroAssembler* masm,
                                             XMMRegister dst1,
                                             XMMRegister dst2) {
   __ movq(kScratchRegister, Operand(rsp, 2 * kPointerSize));
@@ skipping 135 matching lines @@
       __ subl(rax, rbx);
       __ j(overflow, slow);  // The slow case rereads operands from the stack.
       __ movsxlq(rax, rax);  // Sign extend eax into rax.
       break;
     }
 
     case Token::MUL:
       // If the smi tag is 0 we can just leave the tag on one operand.
       ASSERT(kSmiTag == 0);  // adjust code below if not the case
       // Remove tag from one of the operands (but keep sign).
-      __ sar(rax, Immediate(kSmiTagSize));
+      __ sarl(rax, Immediate(kSmiTagSize));
       // Do multiplication.
       __ imull(rax, rbx);  // multiplication of smis; result in eax
       // Go slow on overflows.
       __ j(overflow, slow);
       // Check for negative zero result.
       __ movsxlq(rax, rax);  // Sign extend eax into rax.
       __ NegativeZeroTest(rax, rcx, slow);  // use rcx = x | y
       break;
 
     case Token::DIV:
@@ skipping 342 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