A64: Improve the deoptimization exit code for LMathRound.

src/a64/lithium-codegen-a64.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 4007 matching lines @@
   }
 }
 
 
 void LCodeGen::DoMathRound(LMathRound* instr) {
   // TODO(jbramley): We could provide a double result here using frint.
   DoubleRegister input = ToDoubleRegister(instr->value());
   DoubleRegister temp1 = ToDoubleRegister(instr->temp1());
   Register result = ToRegister(instr->result());
   Label try_rounding;
-  Label deopt;
   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.
   //  - The sign of the result is the same as the sign of the input. This means
   //    that -0.0 rounds to itself, and values -0.5 <= input < 0 also produce a
   //    result of -0.0.
 
   DoubleRegister dot_five = double_scratch();
   __ Fmov(dot_five, 0.5);
   __ Fabs(temp1, input);
   __ Fcmp(temp1, dot_five);
   // If input is in [-0.5, -0], the result is -0.
   // If input is in [+0, +0.5[, the result is +0.
   // If the input is +0.5, the result is 1.
   __ B(hi, &try_rounding);  // hi so NaN will also branch.
 
   if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {
     __ Fmov(result, input);
-    __ Cmp(result, 0);
-    DeoptimizeIf(mi, instr->environment());  // [-0.5, -0.0].
+    DeoptimizeIfNegative(result, instr->environment());  // [-0.5, -0.0].
   }
   __ Fcmp(input, dot_five);
   __ 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(&deopt);
-  Deoptimize(instr->environment());
-
   __ 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
   // 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);
-  __ B(ne, &deopt);
+  DeoptimizeIf(ne, instr->environment());
 
   __ Bind(&done);
 }
 
 
 void LCodeGen::DoMathSqrt(LMathSqrt* instr) {
   DoubleRegister input = ToDoubleRegister(instr->value());
   DoubleRegister result = ToDoubleRegister(instr->result());
   __ Fsqrt(result, input);
 }
@@ skipping 1749 matching lines @@
   __ Bind(&out_of_object);
   __ 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(&done);
 }
 
 } }  // namespace v8::internal