[turbofan] Use builtin inlining mechanism for Math.abs and Math.sqrt.

src/math.js

 // Copyright 2012 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.
 
 var rngstate;  // Initialized to a Uint32Array during genesis.
 
 var $abs;
 var $exp;
 var $floor;
 var $max;
 var $min;
 
 (function() {
 
 "use strict";
 
 %CheckIsBootstrapping();
 
 var GlobalObject = global.Object;
 var GlobalArray = global.Array;
 
 //-------------------------------------------------------------------
 
 // ECMA 262 - 15.8.2.1
 function MathAbs(x) {
-  if (%_IsSmi(x)) return x >= 0 ? x : -x;
-  x = TO_NUMBER_INLINE(x);
-  if (x === 0) return 0;  // To handle -0.
-  return x > 0 ? x : -x;
+  x = +x;
+  if (x > 0) return x;
+  return 0 - x;
 }
 
 // ECMA 262 - 15.8.2.2
 function MathAcosJS(x) {
   return %MathAcos(TO_NUMBER_INLINE(x));
 }
 
 // ECMA 262 - 15.8.2.3
 function MathAsinJS(x) {
   return %MathAsin(TO_NUMBER_INLINE(x));
@@ skipping 101 matching lines @@
   return (x < 0 ? (x + 0x100000000) : x) * 2.3283064365386962890625e-10;
 }
 
 // ECMA 262 - 15.8.2.15
 function MathRound(x) {
   return %RoundNumber(TO_NUMBER_INLINE(x));
 }
 
 // ECMA 262 - 15.8.2.17
 function MathSqrt(x) {
-  return %_MathSqrtRT(TO_NUMBER_INLINE(x));
+  return %_MathSqrt(+x);
 }
 
 // Non-standard extension.
 function MathImul(x, y) {
   return %NumberImul(TO_NUMBER_INLINE(x), TO_NUMBER_INLINE(y));
 }
 
 // ES6 draft 09-27-13, section 20.2.2.28.
 function MathSign(x) {
   x = TO_NUMBER_INLINE(x);
@@ skipping 22 matching lines @@
   var exp1 = MathExp(x);
   var exp2 = MathExp(-x);
   return (exp1 - exp2) / (exp1 + exp2);
 }
 
 // ES6 draft 09-27-13, section 20.2.2.5.
 function MathAsinh(x) {
   if (!IS_NUMBER(x)) x = NonNumberToNumber(x);
   // Idempotent for NaN, +/-0 and +/-Infinity.
   if (x === 0 || !NUMBER_IS_FINITE(x)) return x;
-  if (x > 0) return MathLog(x + MathSqrt(x * x + 1));
+  if (x > 0) return MathLog(x + %_MathSqrt(x * x + 1));
   // This is to prevent numerical errors caused by large negative x.
-  return -MathLog(-x + MathSqrt(x * x + 1));
+  return -MathLog(-x + %_MathSqrt(x * x + 1));
 }
 
 // ES6 draft 09-27-13, section 20.2.2.3.
 function MathAcosh(x) {
   if (!IS_NUMBER(x)) x = NonNumberToNumber(x);
   if (x < 1) return NAN;
   // Idempotent for NaN and +Infinity.
   if (!NUMBER_IS_FINITE(x)) return x;
-  return MathLog(x + MathSqrt(x + 1) * MathSqrt(x - 1));
+  return MathLog(x + %_MathSqrt(x + 1) * %_MathSqrt(x - 1));
 }
 
 // ES6 draft 09-27-13, section 20.2.2.7.
 function MathAtanh(x) {
   if (!IS_NUMBER(x)) x = NonNumberToNumber(x);
   // Idempotent for +/-0.
   if (x === 0) return x;
   // Returns NaN for NaN and +/- Infinity.
   if (!NUMBER_IS_FINITE(x)) return NAN;
   return 0.5 * MathLog((1 + x) / (1 - x));
@@ skipping 21 matching lines @@
   if (max === 0) max = 1;
   var sum = 0;
   var compensation = 0;
   for (var i = 0; i < length; i++) {
     var n = args[i] / max;
     var summand = n * n - compensation;
     var preliminary = sum + summand;
     compensation = (preliminary - sum) - summand;
     sum = preliminary;
   }
-  return MathSqrt(sum) * max;
+  return %_MathSqrt(sum) * max;
 }
 
 // ES6 draft 09-27-13, section 20.2.2.16.
 function MathFroundJS(x) {
   return %MathFround(TO_NUMBER_INLINE(x));
 }
 
 // ES6 draft 07-18-14, section 20.2.2.11
 function MathClz32(x) {
   x = ToUint32(TO_NUMBER_INLINE(x));
@@ skipping 85 matching lines @@
   "tanh", MathTanh,
   "asinh", MathAsinh,
   "acosh", MathAcosh,
   "atanh", MathAtanh,
   "hypot", MathHypot,
   "fround", MathFroundJS,
   "clz32", MathClz32,
   "cbrt", MathCbrt
 ));
 
+%SetInlineBuiltinFlag(MathAbs);
 %SetInlineBuiltinFlag(MathCeil);
 %SetInlineBuiltinFlag(MathFloor);
 %SetInlineBuiltinFlag(MathRandom);
+%SetInlineBuiltinFlag(MathSqrt);
 
 // Expose to the global scope.
 $abs = MathAbs;
 $exp = MathExp;
 $floor = MathFloor;
 $max = MathMax;
 $min = MathMin;
 
 })();