[turbofan] Implement rounding of floats on x64 and ia32 without sse4.1.

src/compiler/ia32/code-generator-ia32.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/compiler/code-generator.h"
 
 #include "src/ast/scopes.h"
 #include "src/compiler/code-generator-impl.h"
 #include "src/compiler/gap-resolver.h"
 #include "src/compiler/node-matchers.h"
@@ skipping 636 matching lines @@
       break;
     }
     case kSSEFloat32Neg: {
       // TODO(bmeurer): Use 128-bit constants.
       __ pcmpeqd(kScratchDoubleReg, kScratchDoubleReg);
       __ psllq(kScratchDoubleReg, 31);
       __ xorps(i.OutputDoubleRegister(), kScratchDoubleReg);
       break;
     }
     case kSSEFloat32Round: {
-      CpuFeatureScope sse_scope(masm(), SSE4_1);
       RoundingMode const mode =
           static_cast<RoundingMode>(MiscField::decode(instr->opcode()));
+      if (CpuFeatures::IsSupported(SSE4_1)) {
+        CpuFeatureScope sse_scope(masm(), SSE4_1);
       __ roundss(i.OutputDoubleRegister(), i.InputDoubleRegister(0), mode);
+      } else {
+        Register kScratchRegister = i.TempRegister(0);

[titzer, 2016/01/18 10:44:28]

Don't call this kScratchRegister, it's not a constant.

[ahaas, 2016/01/18 15:30:30]

Done.

+
+        // We have to store the original rounding mode to restore it later.

[titzer, 2016/01/18 10:44:28]

This code sucks so much I think it should go to macro assembler hell.

[ahaas, 2016/01/18 15:30:30]

Done.

+        __ sub(esp, Immediate(kPointerSize * 2));
+        __ stmxcsr(Operand(esp, 0));
+        __ mov(kScratchRegister, Operand(esp, 0));
+        __ and_(kScratchRegister, Immediate(0xffff9fff));
+        __ or_(kScratchRegister, Immediate(mode << 13));
+        __ mov(Operand(esp, kPointerSize), kScratchRegister);
+        __ ldmxcsr(Operand(esp, kPointerSize));
+
+        // Convert the input to int32.
+        if (instr->InputAt(0)->IsDoubleRegister()) {
+          __ cvtss2si(kScratchRegister, i.InputDoubleRegister(0));

[titzer, 2016/01/18 10:44:28]

If you require the input to be in a register, you can get rid of some of this.

[ahaas, 2016/01/18 15:30:30]

Done.

+        } else {
+          __ cvtss2si(kScratchRegister, i.InputOperand(0));
+        }
+
+        Label out_of_range;
+        Label done;
+        // Check whether the input is within int32 range.
+        __ cmp(kScratchRegister, Immediate(1));
+        __ j(overflow, &out_of_range);
+        // The input is within int32 range. We achieve rounding by converting
+        // back to float.
+        __ cvtsi2ss(i.OutputDoubleRegister(), kScratchRegister);
+        __ jmp(&done);
+        __ bind(&out_of_range);
+
+        // The input value is already an integer number, no rounding necessary.

[titzer, 2016/01/18 10:44:28]

If you do a DefineSameAsFirst, you can get rid of these explicit moves.

[ahaas, 2016/01/18 15:30:30]

Done.

+        if (instr->InputAt(0)->IsDoubleRegister()) {
+          __ movss(i.OutputDoubleRegister(), i.InputDoubleRegister(0));
+        } else {
+          __ movss(i.OutputDoubleRegister(), i.InputOperand(0));
+        }
+
+        __ bind(&done);
+        // Restore the original rounding mode.
+        __ ldmxcsr(Operand(esp, 0));
+        __ add(esp, Immediate(kPointerSize * 2));
+      }
       break;
     }
     case kSSEFloat64Cmp:
       __ ucomisd(i.InputDoubleRegister(0), i.InputOperand(1));
       break;
     case kSSEFloat64Add:
       __ addsd(i.InputDoubleRegister(0), i.InputOperand(1));
       break;
     case kSSEFloat64Sub:
       __ subsd(i.InputDoubleRegister(0), i.InputOperand(1));
@@ skipping 49 matching lines @@
       // TODO(bmeurer): Use 128-bit constants.
       __ pcmpeqd(kScratchDoubleReg, kScratchDoubleReg);
       __ psllq(kScratchDoubleReg, 63);
       __ xorpd(i.OutputDoubleRegister(), kScratchDoubleReg);
       break;
     }
     case kSSEFloat64Sqrt:
       __ sqrtsd(i.OutputDoubleRegister(), i.InputOperand(0));
       break;
     case kSSEFloat64Round: {
-      CpuFeatureScope sse_scope(masm(), SSE4_1);
       RoundingMode const mode =
           static_cast<RoundingMode>(MiscField::decode(instr->opcode()));
-      __ roundsd(i.OutputDoubleRegister(), i.InputDoubleRegister(0), mode);
+      if (CpuFeatures::IsSupported(SSE4_1)) {
+        CpuFeatureScope sse_scope(masm(), SSE4_1);
+        __ roundsd(i.OutputDoubleRegister(), i.InputDoubleRegister(0), mode);
+      } else {
+        Register kScratchRegister = i.TempRegister(0);
+
+        // We have to store the original rounding mode to restore it later.
+        __ sub(esp, Immediate(kPointerSize * 2));
+        __ stmxcsr(Operand(esp, 0));
+        __ mov(kScratchRegister, Operand(esp, 0));
+        __ and_(kScratchRegister, Immediate(0xffff9fff));
+        __ or_(kScratchRegister, Immediate(mode << 13));
+        __ mov(Operand(esp, kPointerSize), kScratchRegister);
+        __ ldmxcsr(Operand(esp, kPointerSize));
+
+        // Convert the input to int32.
+        if (instr->InputAt(0)->IsDoubleRegister()) {

[titzer, 2016/01/18 10:44:28]

Same for this one. Require the input in a register, since we use it so many
times.

[ahaas, 2016/01/18 15:30:30]

Done.

+          __ cvtsd2si(kScratchRegister, i.InputDoubleRegister(0));
+        } else {
+          __ cvtsd2si(kScratchRegister, i.InputOperand(0));
+        }
+
+        Label out_of_range;
+        Label done;
+        // Check whether the input is within int32 range.
+        __ cmp(kScratchRegister, Immediate(1));
+        __ j(overflow, &out_of_range);
+        // The input is within int32 range. We achieve rounding by converting
+        // back to float.
+        __ Cvtsi2sd(i.OutputDoubleRegister(), kScratchRegister);
+        __ jmp(&done);
+        __ bind(&out_of_range);
+
+        if (instr->InputAt(0)->IsDoubleRegister()) {
+          __ movsd(i.OutputDoubleRegister(), i.InputDoubleRegister(0));
+        } else {
+          __ movsd(i.OutputDoubleRegister(), i.InputOperand(0));
+        }
+
+        // If the input is outside [-2^52, 2^52], then the result = input.
+        int64_t offset = 1;
+        offset <<= 52;
+        __ Move(kScratchDoubleReg, static_cast<double>(offset));
+
+        if (instr->InputAt(0)->IsDoubleRegister()) {
+          __ ucomisd(kScratchDoubleReg, i.InputDoubleRegister(0));
+        } else {
+          __ ucomisd(kScratchDoubleReg, i.InputOperand(0));
+        }
+
+        __ j(below_equal, &done);
+
+        __ Move(kScratchDoubleReg, static_cast<double>(-offset));
+
+        if (instr->InputAt(0)->IsDoubleRegister()) {
+          __ ucomisd(kScratchDoubleReg, i.InputDoubleRegister(0));
+        } else {
+          __ ucomisd(kScratchDoubleReg, i.InputOperand(0));
+        }
+        __ j(above_equal, &done);
+
+        // Positive number have to be handled differently than negative numbers.
+        __ xorpd(kScratchDoubleReg, kScratchDoubleReg);
+        if (instr->InputAt(0)->IsDoubleRegister()) {
+          __ ucomisd(kScratchDoubleReg, i.InputDoubleRegister(0));
+        } else {
+          __ ucomisd(kScratchDoubleReg, i.InputOperand(0));
+        }
+
+        __ Move(kScratchDoubleReg, static_cast<double>(offset));
+
+        Label below_zero;
+        __ j(above, &below_zero);
+
+        __ addsd(i.OutputDoubleRegister(), kScratchDoubleReg);
+        __ subsd(i.OutputDoubleRegister(), kScratchDoubleReg);
+        __ jmp(&done);
+
+        __ bind(&below_zero);
+        __ subsd(i.OutputDoubleRegister(), kScratchDoubleReg);
+        __ addsd(i.OutputDoubleRegister(), kScratchDoubleReg);
+
+        __ bind(&done);
+        // Restore the original rounding mode.
+        __ ldmxcsr(Operand(esp, 0));
+        __ add(esp, Immediate(kPointerSize * 2));
+      }
       break;
     }
     case kSSEFloat32ToFloat64:
       __ cvtss2sd(i.OutputDoubleRegister(), i.InputOperand(0));
       break;
     case kSSEFloat64ToFloat32:
       __ cvtsd2ss(i.OutputDoubleRegister(), i.InputOperand(0));
       break;
     case kSSEFloat64ToInt32:
       __ cvttsd2si(i.OutputRegister(), i.InputOperand(0));
@@ skipping 944 matching lines @@
     int padding_size = last_lazy_deopt_pc_ + space_needed - current_pc;
     __ Nop(padding_size);
   }
 }
 
 #undef __
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8