Experimental parser: merge r19949

src/a64/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 511 matching lines @@
   __ Mov(constants, Operand(ExternalReference::math_exp_constants(0)));
 
   // We have to do a four-way split here:
   //  - If input <= about -708.4, the output always rounds to zero.
   //  - If input >= about 709.8, the output always rounds to +infinity.
   //  - If the input is NaN, the output is NaN.
   //  - Otherwise, the result needs to be calculated.
   Label result_is_finite_non_zero;
   // Assert that we can load offset 0 (the small input threshold) and offset 1
   // (the large input threshold) with a single ldp.
-  ASSERT(kDRegSizeInBytes == (ExpConstant(constants, 1).offset() -
+  ASSERT(kDRegSize == (ExpConstant(constants, 1).offset() -
                               ExpConstant(constants, 0).offset()));
   __ Ldp(double_temp1, double_temp2, ExpConstant(constants, 0));
 
   __ Fcmp(input, double_temp1);
   __ Fccmp(input, double_temp2, NoFlag, hi);
   // At this point, the condition flags can be in one of five states:
   //  NZCV
   //  1000      -708.4 < input < 709.8    result = exp(input)
   //  0110      input == 709.8            result = +infinity
   //  0010      input > 709.8             result = +infinity
   //  0011      input is NaN              result = input
   //  0000      input <= -708.4           result = +0.0
 
   // Continue the common case first. 'mi' tests N == 1.
   __ B(&result_is_finite_non_zero, mi);
 
-  // TODO(jbramley): Add (and use) a zero D register for A64.
   // TODO(jbramley): Consider adding a +infinity register for A64.
   __ Ldr(double_temp2, ExpConstant(constants, 2));    // Synthesize +infinity.
-  __ Fsub(double_temp1, double_temp1, double_temp1);  // Synthesize +0.0.
 
   // Select between +0.0 and +infinity. 'lo' tests C == 0.
-  __ Fcsel(result, double_temp1, double_temp2, lo);
+  __ Fcsel(result, fp_zero, double_temp2, lo);
   // Select between {+0.0 or +infinity} and input. 'vc' tests V == 0.
   __ Fcsel(result, result, input, vc);
   __ B(&done);
 
   // The rest is magic, as described in InitializeMathExpData().
   __ Bind(&result_is_finite_non_zero);
 
   // Assert that we can load offset 3 and offset 4 with a single ldp.
-  ASSERT(kDRegSizeInBytes == (ExpConstant(constants, 4).offset() -
+  ASSERT(kDRegSize == (ExpConstant(constants, 4).offset() -
                               ExpConstant(constants, 3).offset()));
   __ Ldp(double_temp1, double_temp3, ExpConstant(constants, 3));
   __ Fmadd(double_temp1, double_temp1, input, double_temp3);
   __ Fmov(temp2.W(), double_temp1.S());
   __ Fsub(double_temp1, double_temp1, double_temp3);
 
   // Assert that we can load offset 5 and offset 6 with a single ldp.
-  ASSERT(kDRegSizeInBytes == (ExpConstant(constants, 6).offset() -
+  ASSERT(kDRegSize == (ExpConstant(constants, 6).offset() -
                               ExpConstant(constants, 5).offset()));
   __ Ldp(double_temp2, double_temp3, ExpConstant(constants, 5));
   // TODO(jbramley): Consider using Fnmsub here.
   __ Fmul(double_temp1, double_temp1, double_temp2);
   __ Fsub(double_temp1, double_temp1, input);
 
   __ Fmul(double_temp2, double_temp1, double_temp1);
   __ Fsub(double_temp3, double_temp3, double_temp1);
   __ Fmul(double_temp3, double_temp3, double_temp2);
 
   __ Mov(temp1.W(), Operand(temp2.W(), LSR, 11));
 
   __ Ldr(double_temp2, ExpConstant(constants, 7));
   // TODO(jbramley): Consider using Fnmsub here.
   __ Fmul(double_temp3, double_temp3, double_temp2);
   __ Fsub(double_temp3, double_temp3, double_temp1);
 
   // The 8th constant is 1.0, so use an immediate move rather than a load.
   // We can't generate a runtime assertion here as we would need to call Abort
   // in the runtime and we don't have an Isolate when we generate this code.
   __ Fmov(double_temp2, 1.0);
   __ Fadd(double_temp3, double_temp3, double_temp2);
 
   __ And(temp2, temp2, 0x7ff);
   __ Add(temp1, temp1, 0x3ff);
 
   // Do the final table lookup.
   __ Mov(temp3, Operand(ExternalReference::math_exp_log_table()));
 
-  __ Add(temp3, temp3, Operand(temp2, LSL, kDRegSizeInBytesLog2));
+  __ Add(temp3, temp3, Operand(temp2, LSL, kDRegSizeLog2));
   __ Ldp(temp2.W(), temp3.W(), MemOperand(temp3));
   __ Orr(temp1.W(), temp3.W(), Operand(temp1.W(), LSL, 20));
   __ Bfi(temp2, temp1, 32, 32);
   __ Fmov(double_temp1, temp2);
 
   __ Fmul(result, double_temp3, double_temp1);
 
   __ Bind(&done);
 }
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_A64