SSE2 truncating double-to-i.

src/ia32/lithium-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 2226 matching lines @@
   DeoptimizeIf(equal, instr->environment());
 }
 
 
 void LCodeGen::DoMathRound(LUnaryMathOperation* instr) {
   XMMRegister xmm_scratch = xmm0;
   Register output_reg = ToRegister(instr->result());
   XMMRegister input_reg = ToDoubleRegister(instr->input());
 
   // xmm_scratch = 0.5
   ExternalReference one_half = ExternalReference::address_of_one_half();

[Erik Corry, 2011/01/04 22:33:00]

Here's how to load a constant into an XMM register.

   __ movdbl(xmm_scratch, Operand::StaticVariable(one_half));
 
   // input = input + 0.5
   __ addsd(input_reg, xmm_scratch);
 
   // We need to return -0 for the input range [-0.5, 0[, otherwise
   // compute Math.floor(value + 0.5).
   if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {
     __ ucomisd(input_reg, xmm_scratch);
     DeoptimizeIf(below_equal, instr->environment());
@@ skipping 620 matching lines @@
       __ add(Operand(esp), Immediate(kDoubleSize));
       DeoptimizeIf(no_condition, instr->environment());
       __ bind(&convert);
       // Do conversion, which cannot fail because we checked the exponent.
       __ fld_d(Operand(esp, 0));
       __ fisttp_d(Operand(esp, 0));
       __ mov(result_reg, Operand(esp, 0));  // Low word of answer is the result.
       __ add(Operand(esp), Immediate(kDoubleSize));
       __ bind(&done);
     } else {
-      // This will bail out if the input was not in the int32 range (or,
-      // unfortunately, if the input was 0x80000000).
-      DeoptimizeIf(equal, instr->environment());
+      NearLabel done;
+      Register temp_reg = ToRegister(instr->temporary());
+      XMMRegister xmm_scratch = xmm0;
+
+      __ j(not_equal, &done);
+
+      // Get high 32 bits of the input in temp_reg.
+      __ pshufd(xmm_scratch, input_reg, 1);
+      __ movd(Operand(temp_reg), xmm_scratch);
+
+      // Zero out the sign and the exponent in the input (by shifting
+      // it to the left) and restore the implicit mantissa bit,
+      // i.e. convert the input to unsigned int64 shifted left by
+      // kExponentBits.
+      __ mov(result_reg, 1);
+      __ movd(xmm_scratch, Operand(result_reg));
+      __ psllq(xmm_scratch, kDoubleSize * kBitsPerByte - 1);

[Erik Corry, 2011/01/04 22:33:00]

It might be faster to load xmm_scratch using the technique above?

+      __ psllq(input_reg, HeapNumber::kExponentBits);
+      __ por(input_reg, xmm_scratch);
+
+      // Restore high 32 bits of the input in result_reg.
+      __ mov(result_reg, temp_reg);
+
+      // Prepare negation mask in temp_reg.
+      __ sar(temp_reg, kBitsPerInt - 1);
+
+      // Extract the exponent from result_reg and subtract adjusted
+      // bias from it. The adjustment is selected in a way such that
+      // when the difference is zero, the answer is in the low 32 bits
+      // of the input, otherwise a shift has to be performed.
+      __ shr(result_reg, HeapNumber::kExponentShift);
+      __ and_(result_reg,
+              HeapNumber::kExponentMask >> HeapNumber::kExponentShift);
+      __ sub(Operand(result_reg),
+             Immediate(HeapNumber::kExponentBias +
+                       HeapNumber::kExponentBits +
+                       HeapNumber::kMantissaBits));
+      // Don't handle big (or special) exponents.

[Erik Corry, 2011/01/04 22:33:00]

Could you add a comment describing the range handled?

+      DeoptimizeIf(greater_equal, instr->environment());
+
+      // Get the amount to shift the input right in xmm_scratch.
+      __ neg(result_reg);
+      __ movd(xmm_scratch, Operand(result_reg));
+
+      // Shift the input right and extract low 32 bits.
+      __ psrlq(input_reg, xmm_scratch);
+      __ movd(Operand(result_reg), input_reg);
+
+      // Use the prepared mask in temp_reg to negate the result if necessary.
+      __ xor_(result_reg, Operand(temp_reg));
+      __ sub(result_reg, Operand(temp_reg));

[Erik Corry, 2011/01/04 22:33:00]

ooh, nice!

+      __ bind(&done);
     }
   } else {
     NearLabel done;
     __ cvttsd2si(result_reg, Operand(input_reg));
     __ cvtsi2sd(xmm0, Operand(result_reg));
     __ ucomisd(xmm0, input_reg);
     DeoptimizeIf(not_equal, instr->environment());
     DeoptimizeIf(parity_even, instr->environment());  // NaN.
     if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {
       // The integer converted back is equal to the original. We
@@ skipping 399 matching lines @@
   ASSERT(!environment->HasBeenRegistered());
   RegisterEnvironmentForDeoptimization(environment);
   ASSERT(osr_pc_offset_ == -1);
   osr_pc_offset_ = masm()->pc_offset();
 }
 
 
 #undef __
 
 } }  // namespace v8::internal