Fix strict aliasing rule violations in dtoa.c.

src/third_party/dtoa/dtoa.c

 /****************************************************************
  *
  * The author of this software is David M. Gay.
  *
  * Copyright (c) 1991, 2000, 2001 by Lucent Technologies.
  *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose without fee is hereby granted, provided that this entire notice
  * is included in all copies of any software which is or includes a copy
  * or modification of this software and in all copies of the supporting
@@ skipping 252 matching lines @@
 #define CONST const
 #endif
 #endif
 
 #if defined(IEEE_8087) + defined(IEEE_MC68k) + defined(VAX) + defined(IBM) != 1
 Exactly one of IEEE_8087, IEEE_MC68k, VAX, or IBM should be defined.
 #endif
 
 typedef union { double d; ULong L[2]; } U;
 
-#ifdef YES_ALIAS
-#define dval(x) x
 #ifdef IEEE_8087
-#define word0(x) ((ULong *)&x)[1]
-#define word1(x) ((ULong *)&x)[0]
+#define word0(x) (x).L[1]
+#define word1(x) (x).L[0]
 #else
-#define word0(x) ((ULong *)&x)[0]
-#define word1(x) ((ULong *)&x)[1]
+#define word0(x) (x).L[0]
+#define word1(x) (x).L[1]
 #endif
-#else
-#ifdef IEEE_8087
-#define word0(x) ((U*)&x)->L[1]
-#define word1(x) ((U*)&x)->L[0]
-#else
-#define word0(x) ((U*)&x)->L[0]
-#define word1(x) ((U*)&x)->L[1]
-#endif
-#define dval(x) ((U*)&x)->d
-#endif
+#define dval(x) (x).d
 
 /* The following definition of Storeinc is appropriate for MIPS processors.
  * An alternative that might be better on some machines is
  * #define Storeinc(a,b,c) (*a++ = b << 16 | c & 0xffff)
  */
 #if defined(IEEE_8087) + defined(VAX)
 #define Storeinc(a,b,c) (((unsigned short *)a)[1] = (unsigned short)b, \
 ((unsigned short *)a)[0] = (unsigned short)c, a++)
 #else
 #define Storeinc(a,b,c) (((unsigned short *)a)[0] = (unsigned short)b, \
@@ skipping 799 matching lines @@
 #endif
         while(!*--xc)
                 wa--;
         c->wds = wa;
         return c;
         }
 
  static double
 ulp
 #ifdef KR_headers
-        (x) double x;
+        (dx) double dx;
 #else
-        (double x)
+        (double dx)
 #endif
 {
         register Long L;
-        double a;
+        U x, a;
+
+        dval(x) = dx;
 
         L = (word0(x) & Exp_mask) - (P-1)*Exp_msk1;
 #ifndef Avoid_Underflow
 #ifndef Sudden_Underflow
         if (L > 0) {
 #endif
 #endif
 #ifdef IBM
                 L |= Exp_msk1 >> 4;
 #endif
@@ skipping 22 matching lines @@
  static double
 b2d
 #ifdef KR_headers
         (a, e) Bigint *a; int *e;
 #else
         (Bigint *a, int *e)
 #endif
 {
         ULong *xa, *xa0, w, y, z;
         int k;
-        double d;
+        U d;
 #ifdef VAX
         ULong d0, d1;
 #else
 #define d0 word0(d)
 #define d1 word1(d)
 #endif
 
         xa0 = a->x;
         xa = xa0 + a->wds;
         y = *--xa;
@@ skipping 42 matching lines @@
 #else
 #undef d0
 #undef d1
 #endif
         return dval(d);
         }
 
  static Bigint *
 d2b
 #ifdef KR_headers
-        (d, e, bits) double d; int *e, *bits;
+        (dd, e, bits) double dd; int *e, *bits;
 #else
-        (double d, int *e, int *bits)
+        (double dd, int *e, int *bits)
 #endif
 {
         Bigint *b;
         int de, k;
         ULong *x, y, z;
 #ifndef Sudden_Underflow
         int i;
 #endif
 #ifdef VAX
         ULong d0, d1;
         d0 = word0(d) >> 16 | word0(d) << 16;
         d1 = word1(d) >> 16 | word1(d) << 16;
 #else
+        U d;
+        dval(d) = dd;
 #define d0 word0(d)
 #define d1 word1(d)
 #endif
 
 #ifdef Pack_32
         b = Balloc(1);
 #else
         b = Balloc(2);
 #endif
         x = b->x;
@@ skipping 112 matching lines @@
 #undef d1
 
  static double
 ratio
 #ifdef KR_headers
         (a, b) Bigint *a, *b;
 #else
         (Bigint *a, Bigint *b)
 #endif
 {
-        double da, db;
+        U da, db;
         int k, ka, kb;
 
         dval(da) = b2d(a, &ka);
         dval(db) = b2d(b, &kb);
 #ifdef Pack_32
         k = ka - kb + 32*(a->wds - b->wds);
 #else
         k = ka - kb + 16*(a->wds - b->wds);
 #endif
 #ifdef IBM
@@ skipping 153 matching lines @@
 #else
         (CONST char *s00, char **se)
 #endif
 {
 #ifdef Avoid_Underflow
         int scale;
 #endif
         int bb2, bb5, bbe, bd2, bd5, bbbits, bs2, c, dsign,
                  e, e1, esign, i, j, k, nd, nd0, nf, nz, nz0, sign;
         CONST char *s, *s0, *s1;
-        double aadj, aadj1, adj, rv, rv0;
+        double aadj;
+        U aadj1, adj, rv, rv0;
         Long L;
         ULong y, z;
         Bigint *bb = NULL, *bb1, *bd = NULL, *bd0, *bs = NULL, *delta = NULL;
 #ifdef SET_INEXACT
         int inexact, oldinexact;
 #endif
 #ifdef Honor_FLT_ROUNDS
         int rounding;
 #endif
 #ifdef USE_LOCALE
@@ skipping 479 matching lines @@
                                 /* Error is less than an ulp */
                                 if (!delta->x[0] && delta->wds <= 1) {
                                         /* exact */
 #ifdef SET_INEXACT
                                         inexact = 0;
 #endif
                                         break;
                                         }
                                 if (rounding) {
                                         if (dsign) {
-                                                adj = 1.;
+                                                dval(adj) = 1.;
                                                 goto apply_adj;
                                                 }
                                         }
                                 else if (!dsign) {
-                                        adj = -1.;
+                                        dval(adj) = -1.;
                                         if (!word1(rv)
                                          && !(word0(rv) & Frac_mask)) {
                                                 y = word0(rv) & Exp_mask;
 #ifdef Avoid_Underflow
                                                 if (!scale || y > 2*P*Exp_msk1)
 #else
                                                 if (y)
 #endif
                                                   {
                                                   delta = lshift(delta,Log2P);
                                                   if (cmp(delta, bs) <= 0)
-                                                        adj = -0.5;
+                                                        dval(adj) = -0.5;
                                                   }
                                                 }
  apply_adj:
 #ifdef Avoid_Underflow
                                         if (scale && (y = word0(rv) & Exp_mask)
                                                 <= 2*P*Exp_msk1)
                                           word0(adj) += (2*P+1)*Exp_msk1 - y;
 #else
 #ifdef Sudden_Underflow
                                         if ((word0(rv) & Exp_mask) <=
                                                         P*Exp_msk1) {
                                                 word0(rv) += P*Exp_msk1;
-                                                dval(rv) += adj*ulp(dval(rv));
+                                                dval(rv) += dval(adj)*ulp(dval(rv));
                                                 word0(rv) -= P*Exp_msk1;
                                                 }
                                         else
 #endif /*Sudden_Underflow*/
 #endif /*Avoid_Underflow*/
-                                        dval(rv) += adj*ulp(dval(rv));
+                                        dval(rv) += dval(adj)*ulp(dval(rv));
                                         }
                                 break;
                                 }
-                        adj = ratio(delta, bs);
-                        if (adj < 1.)
-                                adj = 1.;
-                        if (adj <= 0x7ffffffe) {
+                        dval(adj) = ratio(delta, bs);
+                        if (dval(adj) < 1.)
+                                dval(adj) = 1.;
+                        if (dval(adj) <= 0x7ffffffe) {
                                 /* adj = rounding ? ceil(adj) : floor(adj); */
-                                y = adj;
-                                if (y != adj) {
+                                y = dval(adj);
+                                if (y != dval(adj)) {
                                         if (!((rounding>>1) ^ dsign))
                                                 y++;
-                                        adj = y;
+                                        dval(adj) = y;
                                         }
                                 }
 #ifdef Avoid_Underflow
                         if (scale && (y = word0(rv) & Exp_mask) <= 2*P*Exp_msk1)
                                 word0(adj) += (2*P+1)*Exp_msk1 - y;
 #else
 #ifdef Sudden_Underflow
                         if ((word0(rv) & Exp_mask) <= P*Exp_msk1) {
                                 word0(rv) += P*Exp_msk1;
-                                adj *= ulp(dval(rv));
+                                dval(adj) *= ulp(dval(rv));
                                 if (dsign)
-                                        dval(rv) += adj;
+                                        dval(rv) += dval(adj);
                                 else
-                                        dval(rv) -= adj;
+                                        dval(rv) -= dval(adj);
                                 word0(rv) -= P*Exp_msk1;
                                 goto cont;
                                 }
 #endif /*Sudden_Underflow*/
 #endif /*Avoid_Underflow*/
-                        adj *= ulp(dval(rv));
+                        dval(adj) *= ulp(dval(rv));
                         if (dsign)
-                                dval(rv) += adj;
+                                dval(rv) += dval(adj);
                         else
-                                dval(rv) -= adj;
+                                dval(rv) -= dval(adj);
                         goto cont;
                         }
 #endif /*Honor_FLT_ROUNDS*/
 
                 if (i < 0) {
                         /* Error is less than half an ulp -- check for
                          * special case of mantissa a power of two.
                          */
                         if (dsign || word1(rv) || word0(rv) & Bndry_mask
 #ifdef IEEE_Arith
@@ skipping 101 matching lines @@
 #endif
                                 }
 #ifdef Avoid_Underflow
                         dsign = 1 - dsign;
 #endif
 #endif
                         break;
                         }
                 if ((aadj = ratio(delta, bs)) <= 2.) {
                         if (dsign)
-                                aadj = aadj1 = 1.;
+                                aadj = dval(aadj1) = 1.;
                         else if (word1(rv) || word0(rv) & Bndry_mask) {
 #ifndef Sudden_Underflow
                                 if (word1(rv) == Tiny1 && !word0(rv))
                                         goto undfl;
 #endif
                                 aadj = 1.;
-                                aadj1 = -1.;
+                                dval(aadj1) = -1.;
                                 }
                         else {
                                 /* special case -- power of FLT_RADIX to be */
                                 /* rounded down... */
 
                                 if (aadj < 2./FLT_RADIX)
                                         aadj = 1./FLT_RADIX;
                                 else
                                         aadj *= 0.5;
-                                aadj1 = -aadj;
+                                dval(aadj1) = -aadj;
                                 }
                         }
                 else {
                         aadj *= 0.5;
-                        aadj1 = dsign ? aadj : -aadj;
+                        dval(aadj1) = dsign ? aadj : -aadj;
 #ifdef Check_FLT_ROUNDS
                         switch(Rounding) {
                                 case 2: /* towards +infinity */
-                                        aadj1 -= 0.5;
+                                        dval(aadj1) -= 0.5;
                                         break;
                                 case 0: /* towards 0 */
                                 case 3: /* towards -infinity */
-                                        aadj1 += 0.5;
+                                        dval(aadj1) += 0.5;
                                 }
 #else
                         if (Flt_Rounds == 0)
-                                aadj1 += 0.5;
+                                dval(aadj1) += 0.5;
 #endif /*Check_FLT_ROUNDS*/
                         }
                 y = word0(rv) & Exp_mask;
 
                 /* Check for overflow */
 
                 if (y == Exp_msk1*(DBL_MAX_EXP+Bias-1)) {
                         dval(rv0) = dval(rv);
                         word0(rv) -= P*Exp_msk1;
-                        adj = aadj1 * ulp(dval(rv));
-                        dval(rv) += adj;
+                        dval(adj) = dval(aadj1) * ulp(dval(rv));
+                        dval(rv) += dval(adj);
                         if ((word0(rv) & Exp_mask) >=
                                         Exp_msk1*(DBL_MAX_EXP+Bias-P)) {
                                 if (word0(rv0) == Big0 && word1(rv0) == Big1)
                                         goto ovfl;
                                 word0(rv) = Big0;
                                 word1(rv) = Big1;
                                 goto cont;
                                 }
                         else
                                 word0(rv) += P*Exp_msk1;
                         }
                 else {
 #ifdef Avoid_Underflow
                         if (scale && y <= 2*P*Exp_msk1) {
                                 if (aadj <= 0x7fffffff) {
                                         if ((z = aadj) <= 0)
                                                 z = 1;
                                         aadj = z;
-                                        aadj1 = dsign ? aadj : -aadj;
+                                        dval(aadj1) = dsign ? aadj : -aadj;
                                         }
                                 word0(aadj1) += (2*P+1)*Exp_msk1 - y;
                                 }
-                        adj = aadj1 * ulp(dval(rv));
-                        dval(rv) += adj;
+                        dval(adj) = dval(aadj1) * ulp(dval(rv));
+                        dval(rv) += dval(adj);
 #else
 #ifdef Sudden_Underflow
                         if ((word0(rv) & Exp_mask) <= P*Exp_msk1) {
                                 dval(rv0) = dval(rv);
                                 word0(rv) += P*Exp_msk1;
-                                adj = aadj1 * ulp(dval(rv));
-                                dval(rv) += adj;
+                                dval(adj) = dval(aadj1) * ulp(dval(rv));
+                                dval(rv) += dval(adj);
 #ifdef IBM
                                 if ((word0(rv) & Exp_mask) <  P*Exp_msk1)
 #else
                                 if ((word0(rv) & Exp_mask) <= P*Exp_msk1)
 #endif
                                         {
                                         if (word0(rv0) == Tiny0
                                          && word1(rv0) == Tiny1)
                                                 goto undfl;
                                         word0(rv) = Tiny0;
                                         word1(rv) = Tiny1;
                                         goto cont;
                                         }
                                 else
                                         word0(rv) -= P*Exp_msk1;
                                 }
                         else {
-                                adj = aadj1 * ulp(dval(rv));
-                                dval(rv) += adj;
+                                dval(adj) = dval(aadj1) * ulp(dval(rv));
+                                dval(rv) += dval(adj);
                                 }
 #else /*Sudden_Underflow*/
                         /* Compute adj so that the IEEE rounding rules will
                          * correctly round rv + adj in some half-way cases.
                          * If rv * ulp(rv) is denormalized (i.e.,
                          * y <= (P-1)*Exp_msk1), we must adjust aadj to avoid
                          * trouble from bits lost to denormalization;
                          * example: 1.2e-307 .
                          */
                         if (y <= (P-1)*Exp_msk1 && aadj > 1.) {
-                                aadj1 = (double)(int)(aadj + 0.5);
+                                dval(aadj1) = (double)(int)(aadj + 0.5);
                                 if (!dsign)
-                                        aadj1 = -aadj1;
+                                        dval(aadj1) = -dval(aadj1);
                                 }
-                        adj = aadj1 * ulp(dval(rv));
-                        dval(rv) += adj;
+                        dval(adj) = dval(aadj1) * ulp(dval(rv));
+                        dval(rv) += dval(adj);
 #endif /*Sudden_Underflow*/
 #endif /*Avoid_Underflow*/
                         }
                 z = word0(rv) & Exp_mask;
 #ifndef SET_INEXACT
 #ifdef Avoid_Underflow
                 if (!scale)
 #endif
                 if (y == z) {
                         /* Can we stop now? */
@@ skipping 269 matching lines @@
  *         guarantee that the floating-point calculation has given
  *         the correctly rounded result.  For k requested digits and
  *         "uniformly" distributed input, the probability is
  *         something like 10^(k-15) that we must resort to the Long
  *         calculation.
  */
 
  char *
 dtoa
 #ifdef KR_headers
-        (d, mode, ndigits, decpt, sign, rve)
-        double d; int mode, ndigits, *decpt, *sign; char **rve;
+        (dd, mode, ndigits, decpt, sign, rve)
+        double dd; int mode, ndigits, *decpt, *sign; char **rve;
 #else
-        (double d, int mode, int ndigits, int *decpt, int *sign, char **rve)
+        (double dd, int mode, int ndigits, int *decpt, int *sign, char **rve)
 #endif
 {
  /*     Arguments ndigits, decpt, sign are similar to those
         of ecvt and fcvt; trailing zeros are suppressed from
         the returned string.  If not null, *rve is set to point
         to the end of the return value.  If d is +-Infinity or NaN,
         then *decpt is set to 9999.
 
         mode:
                 0 ==> shortest string that yields d when read in
@@ skipping 25 matching lines @@
 
         int bbits, b2, b5, be, dig, i, ieps, ilim, ilim0, ilim1,
                 j, j1, k, k0, k_check, leftright, m2, m5, s2, s5,
                 spec_case, try_quick, bias_round_up;
         Long L;
 #ifndef Sudden_Underflow
         int denorm;
         ULong x;
 #endif
         Bigint *b, *b1, *delta, *mlo, *mhi, *S;
-        double d2, ds, eps;
+        double ds;
+        U d2, eps;
         char *s, *s0;
 #ifdef Honor_FLT_ROUNDS
         int rounding;
 #endif
 #ifdef SET_INEXACT
         int inexact, oldinexact;
 #endif
+        U d;
+        dval(d) = dd;
 
         /* In mode 2 and 3 we bias rounding up when there are ties. */
         bias_round_up = mode == 2 || mode == 3;
 
         ilim = ilim1 = 0; /* to avoid Google3 compiler warnings */
 
 #ifndef MULTIPLE_THREADS
         if (dtoa_result) {
                 freedtoa(dtoa_result);
                 dtoa_result = 0;
@@ skipping 617 matching lines @@
         Bfree(b);
         *s = 0;
         *decpt = k + 1;
         if (rve)
                 *rve = s;
         return s0;
         }
 #ifdef __cplusplus
 }
 #endif