ARM64: Generate optimized code for Math.floor and Math.round with double outputs.

src/arm64/lithium-codegen-arm64.cc

 // Copyright 2013 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 3766 matching lines @@
   Register temp1 = ToRegister(instr->temp1());
   Register temp2 = ToRegister(instr->temp2());
   Register temp3 = ToRegister(instr->temp3());
 
   MathExpGenerator::EmitMathExp(masm(), input, result,
                                 double_temp1, double_temp2,
                                 temp1, temp2, temp3);
 }
 
 
-void LCodeGen::DoMathFloor(LMathFloor* instr) {
-  // TODO(jbramley): If we could provide a double result, we could use frintm
-  // and produce a valid double result in a single instruction.
+void LCodeGen::DoMathFloorD(LMathFloorD* instr) {
+  DoubleRegister input = ToDoubleRegister(instr->value());
+  DoubleRegister result = ToDoubleRegister(instr->result());
+
+  __ Frintm(result, input);
+}
+
+
+void LCodeGen::DoMathFloorI(LMathFloorI* instr) {
   DoubleRegister input = ToDoubleRegister(instr->value());
   Register result = ToRegister(instr->result());
 
   if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {
     DeoptimizeIfMinusZero(input, instr->environment());
   }
 
   __ Fcvtms(result, input);
 
   // Check that the result fits into a 32-bit integer.
@@ skipping 212 matching lines @@
     MathPowStub stub(isolate(), MathPowStub::INTEGER);
     __ CallStub(&stub);
   } else {
     ASSERT(exponent_type.IsDouble());
     MathPowStub stub(isolate(), MathPowStub::DOUBLE);
     __ CallStub(&stub);
   }
 }
 
 
-void LCodeGen::DoMathRound(LMathRound* instr) {
-  // TODO(jbramley): We could provide a double result here using frint.
+void LCodeGen::DoMathRoundD(LMathRoundD* instr) {
+  DoubleRegister input = ToDoubleRegister(instr->value());
+  DoubleRegister result = ToDoubleRegister(instr->result());
+  DoubleRegister scratch_d = crankshaft_fp_scratch;
+  Register scratch_x = ToRegister(instr->temp());
+
+  ASSERT(!AreAliased(input, result, scratch_d));
+
+  Label done;
+
+  // If the exponent is greater than or equal to the width of the mantissa (52),
+  // there is no fractional part.
+  __ Fmov(scratch_x, input);
+  __ Ubfx(scratch_x, scratch_x, kDoubleMantissaBits, kDoubleExponentBits);
+  __ Cmp(scratch_x, Operand(kDoubleExponentBias + kDoubleMantissaBits));
+  __ Fmov(result, input);
+  __ B(hs, &done);
+
+  // Otherwise except for the range yielding -0.0, the result is the same as
+  // floor(val + 0.5).
+  __ Fmov(scratch_d, 0.5);
+  __ Fadd(result, input, scratch_d);
+  __ Frintm(result, result);
+  __ Fcmp(result, 0.0);
+  __ B(ne, &done);
+
+  // Frintn computes the correct result for [-0.5, 0.5[.
+  __ Frintn(result, input);
+
+  __ Bind(&done);
+}
+
+
+void LCodeGen::DoMathRoundI(LMathRoundI* instr) {
   DoubleRegister input = ToDoubleRegister(instr->value());
   DoubleRegister temp1 = ToDoubleRegister(instr->temp1());
   Register result = ToRegister(instr->result());
   Label try_rounding;
   Label done;
 
   // Math.round() rounds to the nearest integer, with ties going towards
   // +infinity. This does not match any IEEE-754 rounding mode.
   //  - Infinities and NaNs are propagated unchanged, but cause deopts because
   //    they can't be represented as integers.
@@ skipping 18 matching lines @@
   __ Mov(result, 1);  // +0.5.
   // Remaining cases: [+0, +0.5[ or [-0.5, +0.5[, depending on
   // flag kBailoutOnMinusZero, will return 0 (xzr).
   __ Csel(result, result, xzr, eq);
   __ B(&done);
 
   __ Bind(&try_rounding);
   // Since we're providing a 32-bit result, we can implement ties-to-infinity by
   // adding 0.5 to the input, then taking the floor of the result. This does not
   // work for very large positive doubles because adding 0.5 would cause an
-  // intermediate rounding stage, so a different approach will be necessary if a
+  // intermediate rounding stage, so a different approach is necessary when a
   // double result is needed.
   __ Fadd(temp1, input, dot_five);
   __ Fcvtms(result, temp1);
 
   // Deopt if
   //  * the input was NaN
   //  * the result is not representable using a 32-bit integer.
   __ Fcmp(input, 0.0);
   __ Ccmp(result, Operand(result.W(), SXTW), NoFlag, vc);
   DeoptimizeIf(ne, instr->environment());
@@ skipping 1826 matching lines @@
   __ Ldr(result, FieldMemOperand(object, JSObject::kPropertiesOffset));
   // Index is equal to negated out of object property index plus 1.
   __ Sub(result, result, Operand::UntagSmiAndScale(index, kPointerSizeLog2));
   __ Ldr(result, FieldMemOperand(result,
                                  FixedArray::kHeaderSize - kPointerSize));
   __ Bind(deferred->exit());
   __ Bind(&done);
 }
 
 } }  // namespace v8::internal