[ieee754] Use uint32_t/uint64_t instead of u_int32_t/u_int64_t.

src/base/ieee754.cc

 // The following is adapted from fdlibm (http://www.netlib.org/fdlibm).
 //
 // ====================================================
 // Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
 //
 // Developed at SunSoft, a Sun Microsystems, Inc. business.
 // Permission to use, copy, modify, and distribute this
 // software is freely granted, provided that this notice
 // is preserved.
 // ====================================================
 //
 // The original source code covered by the above license above has been
 // modified significantly by Google Inc.
 // Copyright 2016 the V8 project authors. All rights reserved.
 
 #include "src/base/ieee754.h"
 
 #include <cmath>
 #include <limits>
 
 #include "src/base/build_config.h"
 #include "src/base/macros.h"
 
 namespace v8 {
 namespace base {
 namespace ieee754 {
 
 namespace {
 
-/* Fix-up typedefs so we can use the FreeBSD msun code mostly unmodified. */
-
-#if V8_OS_WIN
-
-typedef uint32_t u_int32_t;
-typedef uint64_t u_int64_t;
-
-#endif
-
 /* Disable "potential divide by 0" warning in Visual Studio compiler. */
 
 #if V8_CC_MSVC
 
 #pragma warning(disable : 4723)
 
 #endif
 
 /*
  * The original fdlibm code used statements like:
@@ skipping 11 matching lines @@
 /*
  * A union which permits us to convert between a double and two 32 bit
  * ints.
  */
 
 #if V8_TARGET_LITTLE_ENDIAN
 
 typedef union {
   double value;
   struct {
-    u_int32_t lsw;
-    u_int32_t msw;
+    uint32_t lsw;
+    uint32_t msw;
   } parts;
   struct {
-    u_int64_t w;
+    uint64_t w;
   } xparts;
 } ieee_double_shape_type;
 
 #else
 
 typedef union {
   double value;
   struct {
-    u_int32_t msw;
-    u_int32_t lsw;
+    uint32_t msw;
+    uint32_t lsw;
   } parts;
   struct {
-    u_int64_t w;
+    uint64_t w;
   } xparts;
 } ieee_double_shape_type;
 
 #endif
 
 /* Get two 32 bit ints from a double.  */
 
 #define EXTRACT_WORDS(ix0, ix1, d) \
   do {                             \
     ieee_double_shape_type ew_u;   \
@@ skipping 125 matching lines @@
       pio2_1 = 1.57079632673412561417e+00,  /* 0x3FF921FB, 0x54400000 */
       pio2_1t = 6.07710050650619224932e-11, /* 0x3DD0B461, 0x1A626331 */
       pio2_2 = 6.07710050630396597660e-11,  /* 0x3DD0B461, 0x1A600000 */
       pio2_2t = 2.02226624879595063154e-21, /* 0x3BA3198A, 0x2E037073 */
       pio2_3 = 2.02226624871116645580e-21,  /* 0x3BA3198A, 0x2E000000 */
       pio2_3t = 8.47842766036889956997e-32; /* 0x397B839A, 0x252049C1 */
 
   double z, w, t, r, fn;
   double tx[3];
   int32_t e0, i, j, nx, n, ix, hx;
-  u_int32_t low;
+  uint32_t low;
 
   z = 0;
   GET_HIGH_WORD(hx, x); /* high word of x */
   ix = hx & 0x7fffffff;
   if (ix <= 0x3fe921fb) { /* |x| ~<= pi/4 , no need for reduction */
     y[0] = x;
     y[1] = 0;
     return 0;
   }
   if (ix < 0x4002d97c) { /* |x| < 3pi/4, special case with n=+-1 */
@@ skipping 23 matching lines @@
   }
   if (ix <= 0x413921fb) { /* |x| ~<= 2^19*(pi/2), medium size */
     t = fabs(x);
     n = static_cast<int32_t>(t * invpio2 + half);
     fn = static_cast<double>(n);
     r = t - fn * pio2_1;
     w = fn * pio2_1t; /* 1st round good to 85 bit */
     if (n < 32 && ix != npio2_hw[n - 1]) {
       y[0] = r - w; /* quick check no cancellation */
     } else {
-      u_int32_t high;
+      uint32_t high;
       j = ix >> 20;
       y[0] = r - w;
       GET_HIGH_WORD(high, y[0]);
       i = j - ((high >> 20) & 0x7ff);
       if (i > 16) { /* 2nd iteration needed, good to 118 */
         t = r;
         w = fn * pio2_2;
         r = t - w;
         w = fn * pio2_2t - ((t - r) - w);
         y[0] = r - w;
@@ skipping 530 matching lines @@
 #define pio4lo xxx[15]
 #define T xxx
 
   double z, r, v, w, s;
   int32_t ix, hx;
 
   GET_HIGH_WORD(hx, x);             /* high word of x */
   ix = hx & 0x7fffffff;             /* high word of |x| */
   if (ix < 0x3e300000) {            /* x < 2**-28 */
     if (static_cast<int>(x) == 0) { /* generate inexact */
-      u_int32_t low;
+      uint32_t low;
       GET_LOW_WORD(low, x);
       if (((ix | low) | (iy + 1)) == 0) {
         return one / fabs(x);
       } else {
         if (iy == 1) {
           return x;
         } else { /* compute -1 / (x+y) carefully */
           double a, t;
 
           z = w = x + y;
@@ skipping 110 matching lines @@
   };
 
   static const double one = 1.0, huge = 1.0e300;
 
   double w, s1, s2, z;
   int32_t ix, hx, id;
 
   GET_HIGH_WORD(hx, x);
   ix = hx & 0x7fffffff;
   if (ix >= 0x44100000) { /* if |x| >= 2^66 */
-    u_int32_t low;
+    uint32_t low;
     GET_LOW_WORD(low, x);
     if (ix > 0x7ff00000 || (ix == 0x7ff00000 && (low != 0)))
       return x + x; /* NaN */
     if (hx > 0)
       return atanhi[3] + *(volatile double *)&atanlo[3];
     else
       return -atanhi[3] - *(volatile double *)&atanlo[3];
   }
   if (ix < 0x3fdc0000) {            /* |x| < 0.4375 */
     if (ix < 0x3e400000) {          /* |x| < 2^-27 */
@@ skipping 66 matching lines @@
   static const double
       zero = 0.0,
       pi_o_4 = 7.8539816339744827900E-01, /* 0x3FE921FB, 0x54442D18 */
       pi_o_2 = 1.5707963267948965580E+00, /* 0x3FF921FB, 0x54442D18 */
       pi = 3.1415926535897931160E+00;     /* 0x400921FB, 0x54442D18 */
   static volatile double pi_lo =
       1.2246467991473531772E-16; /* 0x3CA1A626, 0x33145C07 */
 
   double z;
   int32_t k, m, hx, hy, ix, iy;
-  u_int32_t lx, ly;
+  uint32_t lx, ly;
 
   EXTRACT_WORDS(hx, lx, x);
   ix = hx & 0x7fffffff;
   EXTRACT_WORDS(hy, ly, y);
   iy = hy & 0x7fffffff;
   if (((ix | ((lx | -static_cast<int32_t>(lx)) >> 31)) > 0x7ff00000) ||
       ((iy | ((ly | -static_cast<int32_t>(ly)) >> 31)) > 0x7ff00000)) {
     return x + y; /* x or y is NaN */
   }
   if (((hx - 0x3ff00000) | lx) == 0) return atan(y); /* x=1.0 */
@@ skipping 204 matching lines @@
       P4 = -1.65339022054652515390e-06,          /* 0xBEBBBD41, 0xC5D26BF1 */
       P5 = 4.13813679705723846039e-08;           /* 0x3E663769, 0x72BEA4D0 */
 
   static volatile double
       huge = 1.0e+300,
       twom1000 = 9.33263618503218878990e-302, /* 2**-1000=0x01700000,0*/
       two1023 = 8.988465674311579539e307;     /* 0x1p1023 */
 
   double y, hi = 0.0, lo = 0.0, c, t, twopk;
   int32_t k = 0, xsb;
-  u_int32_t hx;
+  uint32_t hx;
 
   GET_HIGH_WORD(hx, x);
   xsb = (hx >> 31) & 1; /* sign bit of x */
   hx &= 0x7fffffff;     /* high word of |x| */
 
   /* filter out non-finite argument */
   if (hx >= 0x40862E42) { /* if |x|>=709.78... */
     if (hx >= 0x7ff00000) {
-      u_int32_t lx;
+      uint32_t lx;
       GET_LOW_WORD(lx, x);
       if (((hx & 0xfffff) | lx) != 0)
         return x + x; /* NaN */
       else
         return (xsb == 0) ? x : 0.0; /* exp(+-inf)={inf,0} */
     }
     if (x > o_threshold) return huge * huge;         /* overflow */
     if (x < u_threshold) return twom1000 * twom1000; /* underflow */
   }
 
@@ skipping 53 matching lines @@
  *  atanh(NaN) is that NaN with no signal;
  *  atanh(+-1) is +-INF with signal.
  *
  */
 double atanh(double x) {
   static const double one = 1.0, huge = 1e300;
   static const double zero = 0.0;
 
   double t;
   int32_t hx, ix;
-  u_int32_t lx;
+  uint32_t lx;
   EXTRACT_WORDS(hx, lx, x);
   ix = hx & 0x7fffffff;
   if ((ix | ((lx | -static_cast<int32_t>(lx)) >> 31)) > 0x3ff00000) /* |x|>1 */
     return (x - x) / (x - x);
   if (ix == 0x3ff00000) return x / zero;
   if (ix < 0x3e300000 && (huge + x) > zero) return x; /* x<2**-28 */
   SET_HIGH_WORD(x, ix);
   if (ix < 0x3fe00000) { /* x < 0.5 */
     t = x + x;
     t = 0.5 * log1p(t + t * x / (one - x));
@@ skipping 67 matching lines @@
       Lg4 = 2.222219843214978396e-01,      /* 3FCC71C5 1D8E78AF */
       Lg5 = 1.818357216161805012e-01,      /* 3FC74664 96CB03DE */
       Lg6 = 1.531383769920937332e-01,      /* 3FC39A09 D078C69F */
       Lg7 = 1.479819860511658591e-01;      /* 3FC2F112 DF3E5244 */
 
   static const double zero = 0.0;
   static volatile double vzero = 0.0;
 
   double hfsq, f, s, z, R, w, t1, t2, dk;
   int32_t k, hx, i, j;
-  u_int32_t lx;
+  uint32_t lx;
 
   EXTRACT_WORDS(hx, lx, x);
 
   k = 0;
   if (hx < 0x00100000) { /* x < 2**-1022  */
     if (((hx & 0x7fffffff) | lx) == 0)
       return -two54 / vzero;           /* log(+-0)=-inf */
     if (hx < 0) return (x - x) / zero; /* log(-#) = NaN */
     k -= 54;
     x *= two54; /* subnormal number, scale up x */
@@ skipping 306 matching lines @@
   static const double
       two54 = 1.80143985094819840000e+16,   /* 0x43500000, 0x00000000 */
       ivln2hi = 1.44269504072144627571e+00, /* 0x3ff71547, 0x65200000 */
       ivln2lo = 1.67517131648865118353e-10; /* 0x3de705fc, 0x2eefa200 */
 
   static const double zero = 0.0;
   static volatile double vzero = 0.0;
 
   double f, hfsq, hi, lo, r, val_hi, val_lo, w, y;
   int32_t i, k, hx;
-  u_int32_t lx;
+  uint32_t lx;
 
   EXTRACT_WORDS(hx, lx, x);
 
   k = 0;
   if (hx < 0x00100000) { /* x < 2**-1022  */
     if (((hx & 0x7fffffff) | lx) == 0)
       return -two54 / vzero;           /* log(+-0)=-inf */
     if (hx < 0) return (x - x) / zero; /* log(-#) = NaN */
     k -= 54;
     x *= two54; /* subnormal number, scale up x */
@@ skipping 86 matching lines @@
       two54 = 1.80143985094819840000e+16, /* 0x43500000, 0x00000000 */
       ivln10 = 4.34294481903251816668e-01,
       log10_2hi = 3.01029995663611771306e-01, /* 0x3FD34413, 0x509F6000 */
       log10_2lo = 3.69423907715893078616e-13; /* 0x3D59FEF3, 0x11F12B36 */
 
   static const double zero = 0.0;
   static volatile double vzero = 0.0;
 
   double y;
   int32_t i, k, hx;
-  u_int32_t lx;
+  uint32_t lx;
 
   EXTRACT_WORDS(hx, lx, x);
 
   k = 0;
   if (hx < 0x00100000) { /* x < 2**-1022  */
     if (((hx & 0x7fffffff) | lx) == 0)
       return -two54 / vzero;           /* log(+-0)=-inf */
     if (hx < 0) return (x - x) / zero; /* log(-#) = NaN */
     k -= 54;
     x *= two54; /* subnormal number, scale up x */
@@ skipping 121 matching lines @@
       Q1 = -3.33333333333331316428e-02, /* BFA11111 111110F4 */
       Q2 = 1.58730158725481460165e-03,  /* 3F5A01A0 19FE5585 */
       Q3 = -7.93650757867487942473e-05, /* BF14CE19 9EAADBB7 */
       Q4 = 4.00821782732936239552e-06,  /* 3ED0CFCA 86E65239 */
       Q5 = -2.01099218183624371326e-07; /* BE8AFDB7 6E09C32D */
 
   static volatile double huge = 1.0e+300;
 
   double y, hi, lo, c, t, e, hxs, hfx, r1, twopk;
   int32_t k, xsb;
-  u_int32_t hx;
+  uint32_t hx;
 
   GET_HIGH_WORD(hx, x);
   xsb = hx & 0x80000000; /* sign bit of x */
   hx &= 0x7fffffff;      /* high word of |x| */
 
   /* filter out huge and non-finite argument */
   if (hx >= 0x4043687A) {   /* if |x|>=56*ln2 */
     if (hx >= 0x40862E42) { /* if |x|>=709.78... */
       if (hx >= 0x7ff00000) {
-        u_int32_t low;
+        uint32_t low;
         GET_LOW_WORD(low, x);
         if (((hx & 0xfffff) | low) != 0)
           return x + x; /* NaN */
         else
           return (xsb == 0) ? x : -1.0; /* exp(+-inf)={inf,-1} */
       }
       if (x > o_threshold) return huge * huge; /* overflow */
     }
     if (xsb != 0) {        /* x < -56*ln2, return -1.0 with inexact */
       if (x + tiny < 0.0)  /* raise inexact */
@@ skipping 67 matching lines @@
       SET_HIGH_WORD(t, ((0x3ff - k) << 20)); /* 2^-k */
       y = x - (e + t);
       y += one;
       y = y * twopk;
     }
   }
   return y;
 }
 
 double cbrt(double x) {
-  static const u_int32_t
+  static const uint32_t
       B1 = 715094163, /* B1 = (1023-1023/3-0.03306235651)*2**20 */
       B2 = 696219795; /* B2 = (1023-1023/3-54/3-0.03306235651)*2**20 */
 
   /* |1/cbrt(x) - p(x)| < 2**-23.5 (~[-7.93e-8, 7.929e-8]). */
   static const double P0 = 1.87595182427177009643, /* 0x3ffe03e6, 0x0f61e692 */
       P1 = -1.88497979543377169875,                /* 0xbffe28e0, 0x92f02420 */
       P2 = 1.621429720105354466140,                /* 0x3ff9f160, 0x4a49d6c2 */
       P3 = -0.758397934778766047437,               /* 0xbfe844cb, 0xbee751d9 */
       P4 = 0.145996192886612446982;                /* 0x3fc2b000, 0xd4e4edd7 */
 
   int32_t hx;
   union {
     double value;
     uint64_t bits;
   } u;
   double r, s, t = 0.0, w;
-  u_int32_t sign;
-  u_int32_t high, low;
+  uint32_t sign;
+  uint32_t high, low;
 
   EXTRACT_WORDS(hx, low, x);
   sign = hx & 0x80000000; /* sign= sign(x) */
   hx ^= sign;
   if (hx >= 0x7ff00000) return (x + x); /* cbrt(NaN,INF) is itself */
 
   /*
    * Rough cbrt to 5 bits:
    *    cbrt(2**e*(1+m) ~= 2**(e/3)*(1+(e%3+m)/3)
    * where e is integral and >= 0, m is real and in [0, 1), and "/" and
@@ skipping 162 matching lines @@
     /* argument reduction needed */
     n = __ieee754_rem_pio2(x, y);
     /* 1 -> n even, -1 -> n odd */
     return __kernel_tan(y[0], y[1], 1 - ((n & 1) << 1));
   }
 }
 
 }  // namespace ieee754
 }  // namespace base
 }  // namespace v8