diff --git a/mingw-w64-crt/ChangeLog b/mingw-w64-crt/ChangeLog
index 558e8b4..bbbc6dd 100644
--- a/mingw-w64-crt/ChangeLog
+++ b/mingw-w64-crt/ChangeLog
@@ -1,3 +1,10 @@
+2009-04-14  Ozkan Sezer  <sezeroz@gmail.com>
+
+	* gdtoa/dmisc.c, gdtoa/dtoa.c, gdtoa/gdtoa.c, gdtoa/gdtoa.h,
+	gdtoa/gdtoaimp.h, gdtoa/misc.c, gdtoa/smisc.c, gdtoa/strtodg.c,
+	gdtoa/strtof.c, gdtoa/ulp.c: merged the aliasing violation changes from
+	the latest netlib.org sources.
+
 2009-04-13  Ozkan Sezer  <sezeroz@gmail.com>
 
 	* gdtoa/dtoa.c, gdtoa/gdtoa.c, gdtoa/gdtoaimp.h, gdtoa/misc.c,
diff --git a/mingw-w64-crt/gdtoa/dmisc.c b/mingw-w64-crt/gdtoa/dmisc.c
index 1ea03f3..4e9a6bc 100644
--- a/mingw-w64-crt/gdtoa/dmisc.c
+++ b/mingw-w64-crt/gdtoa/dmisc.c
@@ -31,6 +31,10 @@
 
 #include "gdtoaimp.h"
 
+#ifndef MULTIPLE_THREADS
+char *dtoa_result;
+#endif
+
 char *rv_alloc (int i)
 {
 	int j, k, *r;
diff --git a/mingw-w64-crt/gdtoa/dtoa.c b/mingw-w64-crt/gdtoa/dtoa.c
index 6e90fec..538b418 100644
--- a/mingw-w64-crt/gdtoa/dtoa.c
+++ b/mingw-w64-crt/gdtoa/dtoa.c
@@ -109,7 +109,7 @@
 		to hold the suppressed trailing zeros.
 	*/
 
-	int bbits, b2, b5, be, dig, i, ieps, ilim = 0, ilim0, ilim1 = 0,
+	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;
 	Long L;
@@ -118,17 +118,16 @@
 	ULong x;
 #endif
 	Bigint *b, *b1, *delta, *mlo, *mhi, *S;
+	union _dbl_union d, d2, eps;
 	double ds;
 	char *s, *s0;
-#ifdef Honor_FLT_ROUNDS
-	int rounding;
-#endif
 #ifdef SET_INEXACT
 	int inexact, oldinexact;
 #endif
-	union _dbl_union d, d2, eps;
+#ifdef Honor_FLT_ROUNDS
+	int rounding;
+#endif
 
-	d.d = val;
 #ifndef MULTIPLE_THREADS
 	if (dtoa_result) {
 		__freedtoa(dtoa_result);
@@ -136,23 +135,24 @@
 	}
 #endif
 
-	if (word0(d) & Sign_bit) {
+	d.d = val;
+	if (word0(&d) & Sign_bit) {
 		/* set sign for everything, including 0's and NaNs */
 		*sign = 1;
-		word0(d) &= ~Sign_bit;	/* clear sign bit */
+		word0(&d) &= ~Sign_bit;	/* clear sign bit */
 	}
 	else
 		*sign = 0;
 
-	if ((word0(d) & Exp_mask) == Exp_mask)
+	if ((word0(&d) & Exp_mask) == Exp_mask)
 	{
 		/* Infinity or NaN */
 		*decpt = 9999;
-		if (!word1(d) && !(word0(d) & 0xfffff))
+		if (!word1(&d) && !(word0(&d) & 0xfffff))
 			return nrv_alloc("Infinity", rve, 8);
 		return nrv_alloc("NaN", rve, 3);
 	}
-	if (!dval(d)) {
+	if (!dval(&d)) {
 		*decpt = 1;
 		return nrv_alloc("0", rve, 1);
 	}
@@ -171,22 +171,22 @@
 	}
 #endif
 
-	b = d2b(dval(d), &be, &bbits);
+	b = d2b(dval(&d), &be, &bbits);
 #ifdef Sudden_Underflow
-	i = (int)(word0(d) >> Exp_shift1 & (Exp_mask>>Exp_shift1));
+	i = (int)(word0(&d) >> Exp_shift1 & (Exp_mask>>Exp_shift1));
 #else
-	if (( i = (int)(word0(d) >> Exp_shift1 & (Exp_mask>>Exp_shift1)) )!=0) {
+	if (( i = (int)(word0(&d) >> Exp_shift1 & (Exp_mask>>Exp_shift1)) )!=0) {
 #endif
-		dval(d2) = dval(d);
-		word0(d2) &= Frac_mask1;
-		word0(d2) |= Exp_11;
+		dval(&d2) = dval(&d);
+		word0(&d2) &= Frac_mask1;
+		word0(&d2) |= Exp_11;
 
 		/* log(x)	~=~ log(1.5) + (x-1.5)/1.5
 		 * log10(x)	 =  log(x) / log(10)
 		 *		~=~ log(1.5)/log(10) + (x-1.5)/(1.5*log(10))
-		 * log10(d) = (i-Bias)*log(2)/log(10) + log10(d2)
+		 * log10(&d) = (i-Bias)*log(2)/log(10) + log10(&d2)
 		 *
-		 * This suggests computing an approximation k to log10(d) by
+		 * This suggests computing an approximation k to log10(&d) by
 		 *
 		 * k = (i - Bias)*0.301029995663981
 		 *	+ ( (d2-1.5)*0.289529654602168 + 0.176091259055681 );
@@ -211,21 +211,21 @@
 		/* d is denormalized */
 
 		i = bbits + be + (Bias + (P-1) - 1);
-		x = i > 32  ? word0(d) << (64 - i) | word1(d) >> (i - 32)
-			    : word1(d) << (32 - i);
-		dval(d2) = x;
-		word0(d2) -= 31*Exp_msk1; /* adjust exponent */
+		x = i > 32  ? word0(&d) << (64 - i) | word1(&d) >> (i - 32)
+			    : word1(&d) << (32 - i);
+		dval(&d2) = x;
+		word0(&d2) -= 31*Exp_msk1; /* adjust exponent */
 		i -= (Bias + (P-1) - 1) + 1;
 		denorm = 1;
 	}
 #endif
-	ds = (dval(d2)-1.5)*0.289529654602168 + 0.1760912590558 + i*0.301029995663981;
+	ds = (dval(&d2)-1.5)*0.289529654602168 + 0.1760912590558 + i*0.301029995663981;
 	k = (int)ds;
 	if (ds < 0. && ds != k)
 		k--;	/* want k = floor(ds) */
 	k_check = 1;
 	if (k >= 0 && k <= Ten_pmax) {
-		if (dval(d) < tens[k])
+		if (dval(&d) < tens[k])
 			k--;
 		k_check = 0;
 	}
@@ -264,10 +264,11 @@
 		try_quick = 0;
 	}
 	leftright = 1;
+	ilim = ilim1 = -1;	/* Values for cases 0 and 1; done here to */
+				/* silence erroneous "gcc -Wall" warning. */
 	switch(mode) {
 		case 0:
 		case 1:
-			ilim = ilim1 = -1;
 			i = 18;
 			ndigits = 0;
 			break;
@@ -299,7 +300,7 @@
 	if (ilim >= 0 && ilim <= Quick_max && try_quick) {
 		/* Try to get by with floating-point arithmetic. */
 		i = 0;
-		dval(d2) = dval(d);
+		dval(&d2) = dval(&d);
 		k0 = k;
 		ilim0 = ilim;
 		ieps = 2; /* conservative */
@@ -309,7 +310,7 @@
 			if (j & Bletch) {
 				/* prevent overflows */
 				j &= Bletch - 1;
-				dval(d) /= bigtens[n_bigtens-1];
+				dval(&d) /= bigtens[n_bigtens-1];
 				ieps++;
 			}
 			for(; j; j >>= 1, i++)
@@ -317,32 +318,32 @@
 					ieps++;
 					ds *= bigtens[i];
 				}
-			dval(d) /= ds;
+			dval(&d) /= ds;
 		}
 		else if (( j1 = -k )!=0) {
-			dval(d) *= tens[j1 & 0xf];
+			dval(&d) *= tens[j1 & 0xf];
 			for(j = j1 >> 4; j; j >>= 1, i++)
 				if (j & 1) {
 					ieps++;
-					dval(d) *= bigtens[i];
+					dval(&d) *= bigtens[i];
 				}
 		}
-		if (k_check && dval(d) < 1. && ilim > 0) {
+		if (k_check && dval(&d) < 1. && ilim > 0) {
 			if (ilim1 <= 0)
 				goto fast_failed;
 			ilim = ilim1;
 			k--;
-			dval(d) *= 10.;
+			dval(&d) *= 10.;
 			ieps++;
 		}
-		dval(eps) = ieps*dval(d) + 7.;
-		word0(eps) -= (P-1)*Exp_msk1;
+		dval(&eps) = ieps*dval(&d) + 7.;
+		word0(&eps) -= (P-1)*Exp_msk1;
 		if (ilim == 0) {
 			S = mhi = 0;
-			dval(d) -= 5.;
-			if (dval(d) > dval(eps))
+			dval(&d) -= 5.;
+			if (dval(&d) > dval(&eps))
 				goto one_digit;
-			if (dval(d) < -dval(eps))
+			if (dval(&d) < -dval(&eps))
 				goto no_digits;
 			goto fast_failed;
 		}
@@ -351,34 +352,34 @@
 			/* Use Steele & White method of only
 			 * generating digits needed.
 			 */
-			dval(eps) = 0.5/tens[ilim-1] - dval(eps);
+			dval(&eps) = 0.5/tens[ilim-1] - dval(&eps);
 			for(i = 0;;) {
-				L = dval(d);
-				dval(d) -= L;
+				L = dval(&d);
+				dval(&d) -= L;
 				*s++ = '0' + (int)L;
-				if (dval(d) < dval(eps))
+				if (dval(&d) < dval(&eps))
 					goto ret1;
-				if (1. - dval(d) < dval(eps))
+				if (1. - dval(&d) < dval(&eps))
 					goto bump_up;
 				if (++i >= ilim)
 					break;
-				dval(eps) *= 10.;
-				dval(d) *= 10.;
+				dval(&eps) *= 10.;
+				dval(&d) *= 10.;
 			}
 		}
 		else {
 #endif
 			/* Generate ilim digits, then fix them up. */
-			dval(eps) *= tens[ilim-1];
-			for(i = 1;; i++, dval(d) *= 10.) {
-				L = (Long)(dval(d));
-				if (!(dval(d) -= L))
+			dval(&eps) *= tens[ilim-1];
+			for(i = 1;; i++, dval(&d) *= 10.) {
+				L = (Long)(dval(&d));
+				if (!(dval(&d) -= L))
 					ilim = i;
 				*s++ = '0' + (int)L;
 				if (i == ilim) {
-					if (dval(d) > 0.5 + dval(eps))
+					if (dval(&d) > 0.5 + dval(&eps))
 						goto bump_up;
-					else if (dval(d) < 0.5 - dval(eps)) {
+					else if (dval(&d) < 0.5 - dval(&eps)) {
 						while(*--s == '0');
 						s++;
 						goto ret1;
@@ -391,7 +392,7 @@
 #endif
  fast_failed:
 		s = s0;
-		dval(d) = dval(d2);
+		dval(&d) = dval(&d2);
 		k = k0;
 		ilim = ilim0;
 	}
@@ -403,22 +404,22 @@
 		ds = tens[k];
 		if (ndigits < 0 && ilim <= 0) {
 			S = mhi = 0;
-			if (ilim < 0 || dval(d) <= 5*ds)
+			if (ilim < 0 || dval(&d) <= 5*ds)
 				goto no_digits;
 			goto one_digit;
 		}
-		for(i = 1;; i++, dval(d) *= 10.) {
-			L = (Long)(dval(d) / ds);
-			dval(d) -= L*ds;
+		for(i = 1;; i++, dval(&d) *= 10.) {
+			L = (Long)(dval(&d) / ds);
+			dval(&d) -= L*ds;
 #ifdef Check_FLT_ROUNDS
 			/* If FLT_ROUNDS == 2, L will usually be high by 1 */
-			if (dval(d) < 0) {
+			if (dval(&d) < 0) {
 				L--;
-				dval(d) += ds;
+				dval(&d) += ds;
 			}
 #endif
 			*s++ = '0' + (int)L;
-			if (!dval(d)) {
+			if (!dval(&d)) {
 #ifdef SET_INEXACT
 				inexact = 0;
 #endif
@@ -432,8 +433,8 @@
 				  case 2: goto bump_up;
 				 }
 #endif
-				dval(d) += dval(d);
-				if (dval(d) > ds || (dval(d) == ds && L & 1)) {
+				dval(&d) += dval(&d);
+				if (dval(&d) > ds || (dval(&d) == ds && L & 1)) {
  bump_up:
 					while(*--s == '9')
 						if (s == s0) {
@@ -494,9 +495,9 @@
 			&& rounding == 1
 #endif
 				) {
-		if (!word1(d) && !(word0(d) & Bndry_mask)
+		if (!word1(&d) && !(word0(&d) & Bndry_mask)
 #ifndef Sudden_Underflow
-		 && word0(d) & (Exp_mask & ~Exp_msk1)
+		 && word0(&d) & (Exp_mask & ~Exp_msk1)
 #endif
 				) {
 			/* The special case */
@@ -582,7 +583,7 @@
 			j1 = delta->sign ? 1 : cmp(b, delta);
 			Bfree(delta);
 #ifndef ROUND_BIASED
-			if (j1 == 0 && mode != 1 && !(word1(d) & 1)
+			if (j1 == 0 && mode != 1 && !(word1(&d) & 1)
 #ifdef Honor_FLT_ROUNDS
 				&& rounding >= 1
 #endif
@@ -601,7 +602,7 @@
 #endif
 			if (j < 0 || (j == 0 && mode != 1
 #ifndef ROUND_BIASED
-							&& !(word1(d) & 1)
+							&& !(word1(&d) & 1)
 #endif
 					)) {
 				if (!b->x[0] && b->wds <= 1) {
@@ -706,9 +707,9 @@
 #ifdef SET_INEXACT
 	if (inexact) {
 		if (!oldinexact) {
-			word0(d) = Exp_1 + (70 << Exp_shift);
-			word1(d) = 0;
-			dval(d) += 1.;
+			word0(&d) = Exp_1 + (70 << Exp_shift);
+			word1(&d) = 0;
+			dval(&d) += 1.;
 		}
 	}
 	else if (!oldinexact)
diff --git a/mingw-w64-crt/gdtoa/gdtoa.c b/mingw-w64-crt/gdtoa/gdtoa.c
index 6050135..cdd8e66 100644
--- a/mingw-w64-crt/gdtoa/gdtoa.c
+++ b/mingw-w64-crt/gdtoa/gdtoa.c
@@ -140,14 +140,14 @@
 		to hold the suppressed trailing zeros.
 	*/
 
-	int bbits, b2, b5, be0, dig, i, ieps, ilim = 0, ilim0, ilim1 = 0, inex;
+	int bbits, b2, b5, be0, dig, i, ieps, ilim, ilim0, ilim1, inex;
 	int j, j1, k, k0, k_check, kind, leftright, m2, m5, nbits;
 	int rdir, s2, s5, spec_case, try_quick;
 	Long L;
 	Bigint *b, *b1, *delta, *mlo, *mhi, *mhi1, *S;
 	double d2, ds;
-	union _dbl_union d, eps;
 	char *s, *s0;
+	union _dbl_union d, eps;
 
 #ifndef MULTIPLE_THREADS
 	if (dtoa_result) {
@@ -186,17 +186,17 @@
 		return nrv_alloc("0", rve, 1);
 	}
 
-	dval(d) = b2d(b, &i);
+	dval(&d) = b2d(b, &i);
 	i = be + bbits - 1;
-	word0(d) &= Frac_mask1;
-	word0(d) |= Exp_11;
+	word0(&d) &= Frac_mask1;
+	word0(&d) |= Exp_11;
 
 	/* log(x)	~=~ log(1.5) + (x-1.5)/1.5
 	 * log10(x)	 =  log(x) / log(10)
 	 *		~=~ log(1.5)/log(10) + (x-1.5)/(1.5*log(10))
-	 * log10(d) = (i-Bias)*log(2)/log(10) + log10(d2)
+	 * log10(&d) = (i-Bias)*log(2)/log(10) + log10(d2)
 	 *
-	 * This suggests computing an approximation k to log10(d) by
+	 * This suggests computing an approximation k to log10(&d) by
 	 *
 	 * k = (i - Bias)*0.301029995663981
 	 *	+ ( (d2-1.5)*0.289529654602168 + 0.176091259055681 );
@@ -212,7 +212,7 @@
 	 * (We could get a more accurate k by invoking log10,
 	 *  but this is probably not worthwhile.)
 	 */
-	ds = (dval(d)-1.5)*0.289529654602168 + 0.1760912590558 + i*0.301029995663981;
+	ds = (dval(&d)-1.5)*0.289529654602168 + 0.1760912590558 + i*0.301029995663981;
 
 	/* correct assumption about exponent range */
 	if ((j = i) < 0)
@@ -224,9 +224,9 @@
 	if (ds < 0. && ds != k)
 		k--;	/* want k = floor(ds) */
 	k_check = 1;
-	word0(d) += (be + bbits - 1) << Exp_shift;
+	word0(&d) += (be + bbits - 1) << Exp_shift;
 	if (k >= 0 && k <= Ten_pmax) {
-		if (dval(d) < tens[k])
+		if (dval(&d) < tens[k])
 			k--;
 		k_check = 0;
 	}
@@ -257,10 +257,11 @@
 		try_quick = 0;
 	}
 	leftright = 1;
+	ilim = ilim1 = -1;	/* Values for cases 0 and 1; done here to */
+				/* silence erroneous "gcc -Wall" warning. */
 	switch(mode) {
 		case 0:
 		case 1:
-			ilim = ilim1 = -1;
 			i = (int)(nbits * .30103) + 3;
 			ndigits = 0;
 			break;
@@ -302,7 +303,7 @@
 		/* Try to get by with floating-point arithmetic. */
 
 		i = 0;
-		d2 = dval(d);
+		d2 = dval(&d);
 		k0 = k;
 		ilim0 = ilim;
 		ieps = 2; /* conservative */
@@ -312,7 +313,7 @@
 			if (j & Bletch) {
 				/* prevent overflows */
 				j &= Bletch - 1;
-				dval(d) /= bigtens[n_bigtens-1];
+				dval(&d) /= bigtens[n_bigtens-1];
 				ieps++;
 			}
 			for(; j; j >>= 1, i++)
@@ -324,30 +325,30 @@
 		else  {
 			ds = 1.;
 			if ( (j1 = -k) !=0) {
-				dval(d) *= tens[j1 & 0xf];
+				dval(&d) *= tens[j1 & 0xf];
 				for(j = j1 >> 4; j; j >>= 1, i++)
 					if (j & 1) {
 						ieps++;
-						dval(d) *= bigtens[i];
+						dval(&d) *= bigtens[i];
 					}
 			}
 		}
-		if (k_check && dval(d) < 1. && ilim > 0) {
+		if (k_check && dval(&d) < 1. && ilim > 0) {
 			if (ilim1 <= 0)
 				goto fast_failed;
 			ilim = ilim1;
 			k--;
-			dval(d) *= 10.;
+			dval(&d) *= 10.;
 			ieps++;
 		}
-		dval(eps) = ieps*dval(d) + 7.;
-		word0(eps) -= (P-1)*Exp_msk1;
+		dval(&eps) = ieps*dval(&d) + 7.;
+		word0(&eps) -= (P-1)*Exp_msk1;
 		if (ilim == 0) {
 			S = mhi = 0;
-			dval(d) -= 5.;
-			if (dval(d) > dval(eps))
+			dval(&d) -= 5.;
+			if (dval(&d) > dval(&eps))
 				goto one_digit;
-			if (dval(d) < -dval(eps))
+			if (dval(&d) < -dval(&eps))
 				goto no_digits;
 			goto fast_failed;
 		}
@@ -356,40 +357,40 @@
 			/* Use Steele & White method of only
 			 * generating digits needed.
 			 */
-			dval(eps) = ds*0.5/tens[ilim-1] - dval(eps);
+			dval(&eps) = ds*0.5/tens[ilim-1] - dval(&eps);
 			for(i = 0;;) {
-				L = (Long)(dval(d)/ds);
-				dval(d) -= L*ds;
+				L = (Long)(dval(&d)/ds);
+				dval(&d) -= L*ds;
 				*s++ = '0' + (int)L;
-				if (dval(d) < dval(eps)) {
-					if (dval(d))
+				if (dval(&d) < dval(&eps)) {
+					if (dval(&d))
 						inex = STRTOG_Inexlo;
 					goto ret1;
 				}
-				if (ds - dval(d) < dval(eps))
+				if (ds - dval(&d) < dval(&eps))
 					goto bump_up;
 				if (++i >= ilim)
 					break;
-				dval(eps) *= 10.;
-				dval(d) *= 10.;
+				dval(&eps) *= 10.;
+				dval(&d) *= 10.;
 			}
 		}
 		else {
 #endif
 			/* Generate ilim digits, then fix them up. */
-			dval(eps) *= tens[ilim-1];
-			for(i = 1;; i++, dval(d) *= 10.) {
-				if ( (L = (Long)(dval(d)/ds)) !=0)
-					dval(d) -= L*ds;
+			dval(&eps) *= tens[ilim-1];
+			for(i = 1;; i++, dval(&d) *= 10.) {
+				if ( (L = (Long)(dval(&d)/ds)) !=0)
+					dval(&d) -= L*ds;
 				*s++ = '0' + (int)L;
 				if (i == ilim) {
 					ds *= 0.5;
-					if (dval(d) > ds + dval(eps))
+					if (dval(&d) > ds + dval(&eps))
 						goto bump_up;
-					else if (dval(d) < ds - dval(eps)) {
+					else if (dval(&d) < ds - dval(&eps)) {
 						while(*--s == '0'){}
 						s++;
-						if (dval(d))
+						if (dval(&d))
 							inex = STRTOG_Inexlo;
 						goto ret1;
 					}
@@ -401,7 +402,7 @@
 #endif
  fast_failed:
 		s = s0;
-		dval(d) = d2;
+		dval(&d) = d2;
 		k = k0;
 		ilim = ilim0;
 	}
@@ -413,22 +414,22 @@
 		ds = tens[k];
 		if (ndigits < 0 && ilim <= 0) {
 			S = mhi = 0;
-			if (ilim < 0 || dval(d) <= 5*ds)
+			if (ilim < 0 || dval(&d) <= 5*ds)
 				goto no_digits;
 			goto one_digit;
 		}
-		for(i = 1;; i++, dval(d) *= 10.) {
-			L = dval(d) / ds;
-			dval(d) -= L*ds;
+		for(i = 1;; i++, dval(&d) *= 10.) {
+			L = dval(&d) / ds;
+			dval(&d) -= L*ds;
 #ifdef Check_FLT_ROUNDS
 			/* If FLT_ROUNDS == 2, L will usually be high by 1 */
-			if (dval(d) < 0) {
+			if (dval(&d) < 0) {
 				L--;
-				dval(d) += ds;
+				dval(&d) += ds;
 			}
 #endif
 			*s++ = '0' + (int)L;
-			if (dval(d) == 0.)
+			if (dval(&d) == 0.)
 				break;
 			if (i == ilim) {
 				if (rdir) {
@@ -437,8 +438,8 @@
 					inex = STRTOG_Inexlo;
 					goto ret1;
 				}
-				dval(d) += dval(d);
-				if (dval(d) > ds || (dval(d) == ds && L & 1)) {
+				dval(&d) += dval(&d);
+				if (dval(&d) > ds || (dval(&d) == ds && L & 1)) {
  bump_up:
 					inex = STRTOG_Inexhi;
 					while(*--s == '9')
diff --git a/mingw-w64-crt/gdtoa/gdtoa.h b/mingw-w64-crt/gdtoa/gdtoa.h
index ed249bc..9a9b849 100644
--- a/mingw-w64-crt/gdtoa/gdtoa.h
+++ b/mingw-w64-crt/gdtoa/gdtoa.h
@@ -98,10 +98,10 @@
 		     int mode, int ndigits, int *decpt, char **rve);
 extern void __freedtoa (char *);
 
-extern int __strtodg (const char *, char **, FPI *, Long *, ULong *);
 extern float  __strtof (const char *, char **);
 extern double  __strtod (const char *, char **);
 extern long double strtold (const char *, char **);
+extern int __strtodg (const char *, char **, FPI *, Long *, ULong *);
 
 extern char*	__g__fmt   (char*, char*, char*, int, ULong);
 extern char*	__g_dfmt   (char*, double*, int, unsigned);
diff --git a/mingw-w64-crt/gdtoa/gdtoaimp.h b/mingw-w64-crt/gdtoa/gdtoaimp.h
index 609a446..6b1e046 100644
--- a/mingw-w64-crt/gdtoa/gdtoaimp.h
+++ b/mingw-w64-crt/gdtoa/gdtoaimp.h
@@ -157,11 +157,6 @@
  * #define NO_STRING_H to use private versions of memcpy.
  *	On some K&R systems, it may also be necessary to
  *	#define DECLARE_SIZE_T in this case.
- * #define YES_ALIAS to permit aliasing certain double values with
- *	arrays of ULongs.  This leads to slightly better code with
- *	some compilers and was always used prior to 19990916, but it
- *	is not strictly legal and can cause trouble with aggressively
- *	optimizing compilers (e.g., gcc 2.95.1 under -O2).
  * #define USE_LOCALE to use the current locale's decimal_point value.
  */
 
@@ -261,18 +256,14 @@
 
 typedef union _dbl_union { double d; ULong L[2]; } dbl_union;
 
-/* gcc >= 4.4 at -O2 and higher is seriously allergic to aliasing
-   violations, unions must be used instead of typecast assignment:
-   in the following macros, the x argument must be of 'dbl_union'
-   type. */
 #ifdef IEEE_8087
-#define word0(x) x.L[1]
-#define word1(x) x.L[0]
+#define word0(x) (x)->L[1]
+#define word1(x) (x)->L[0]
 #else
-#define word0(x) x.L[0]
-#define word1(x) x.L[1]
+#define word0(x) (x)->L[0]
+#define word1(x) (x)->L[1]
 #endif
-#define dval(x)  x.d
+#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
@@ -567,7 +558,7 @@
 extern char *strcp (char*, const char*);
 extern Bigint *sum (Bigint*, Bigint*);
 extern int trailz (Bigint*);
-extern double ulp (double);
+extern double ulp (dbl_union *);
 
 #ifdef __cplusplus
 }
diff --git a/mingw-w64-crt/gdtoa/misc.c b/mingw-w64-crt/gdtoa/misc.c
index 7c225ce..c58059e 100644
--- a/mingw-w64-crt/gdtoa/misc.c
+++ b/mingw-w64-crt/gdtoa/misc.c
@@ -30,16 +30,16 @@
  * with " at " changed at "@" and " dot " changed to ".").	*/
 
 
-#ifdef __MINGW32__
-/* we have to include windows.h before gdtoa headers, otherwise
-   defines cause conflicts.  */
+#if defined(__MINGW32__) || defined(__MINGW64__)
+/* we have to include windows.h before gdtoa
+   headers, otherwise defines cause conflicts. */
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
 
 #define NLOCKS 2
 
 #ifdef USE_WIN32_SL
-/* Use spin locks. */ 
+/* Use spin locks. */
 static long dtoa_sl[NLOCKS];
 
 #define ACQUIRE_DTOA_LOCK(n) \
@@ -47,7 +47,8 @@
      Sleep (0);
 #define FREE_DTOA_LOCK(n) InterlockedExchange (&dtoa_sl[n], 0);
 
-#else
+#else	/* USE_WIN32_SL */
+
 #include <stdlib.h>
 static CRITICAL_SECTION dtoa_CritSec[NLOCKS];
 static long dtoa_CS_init = 0;
@@ -101,16 +102,12 @@
 
 #define ACQUIRE_DTOA_LOCK(n) dtoa_lock(n)
 #define FREE_DTOA_LOCK(n) dtoa_unlock(n)
-#endif
+#endif	/* USE_WIN32_SL */
 
-#endif /* __MINGW32__ */
+#endif	/* __MINGW32__ / __MINGW64__ */
 
 #include "gdtoaimp.h"
 
-#ifndef MULTIPLE_THREADS
-char *dtoa_result;
-#endif
-
 static Bigint *freelist[Kmax+1];
 #ifndef Omit_Private_Memory
 #ifndef PRIVATE_MEM
@@ -630,52 +627,53 @@
 	*e = 32 - k;
 #ifdef Pack_32
 	if (k < Ebits) {
-		word0(d) = Exp_1 | y >> (Ebits - k);
+		word0(&d) = Exp_1 | y >> (Ebits - k);
 		w = xa > xa0 ? *--xa : 0;
-		word1(d) = y << ((32-Ebits) + k) | w >> (Ebits - k);
+		word1(&d) = y << ((32-Ebits) + k) | w >> (Ebits - k);
 		goto ret_d;
 	}
 	z = xa > xa0 ? *--xa : 0;
 	if (k -= Ebits) {
-		word0(d) = Exp_1 | y << k | z >> (32 - k);
+		word0(&d) = Exp_1 | y << k | z >> (32 - k);
 		y = xa > xa0 ? *--xa : 0;
-		word1(d) = z << k | y >> (32 - k);
+		word1(&d) = z << k | y >> (32 - k);
 	}
 	else {
-		word0(d) = Exp_1 | y;
-		word1(d) = z;
+		word0(&d) = Exp_1 | y;
+		word1(&d) = z;
 	}
 #else
 	if (k < Ebits + 16) {
 		z = xa > xa0 ? *--xa : 0;
-		word0(d) = Exp_1 | y << k - Ebits | z >> Ebits + 16 - k;
+		word0(&d) = Exp_1 | y << k - Ebits | z >> Ebits + 16 - k;
 		w = xa > xa0 ? *--xa : 0;
 		y = xa > xa0 ? *--xa : 0;
-		word1(d) = z << k + 16 - Ebits | w << k - Ebits | y >> 16 + Ebits - k;
+		word1(&d) = z << k + 16 - Ebits | w << k - Ebits | y >> 16 + Ebits - k;
 		goto ret_d;
 	}
 	z = xa > xa0 ? *--xa : 0;
 	w = xa > xa0 ? *--xa : 0;
 	k -= Ebits + 16;
-	word0(d) = Exp_1 | y << k + 16 | z << k | w >> 16 - k;
+	word0(&d) = Exp_1 | y << k + 16 | z << k | w >> 16 - k;
 	y = xa > xa0 ? *--xa : 0;
-	word1(d) = w << k + 16 | y << k;
+	word1(&d) = w << k + 16 | y << k;
 #endif
  ret_d:
-	return dval(d);
+	return dval(&d);
 }
 
 Bigint *d2b (double val, int *e, int *bits)
 {
 	Bigint *b;
+	union _dbl_union d;
 #ifndef Sudden_Underflow
 	int i;
 #endif
 	int de, k;
 	ULong *x, y, z;
-	union _dbl_union d;
 
 	d.d = val;
+
 #ifdef Pack_32
 	b = Balloc(1);
 #else
@@ -683,17 +681,17 @@
 #endif
 	x = b->x;
 
-	z = word0(d) & Frac_mask;
-	word0(d) &= 0x7fffffff;	/* clear sign bit, which we ignore */
+	z = word0(&d) & Frac_mask;
+	word0(&d) &= 0x7fffffff;	/* clear sign bit, which we ignore */
 #ifdef Sudden_Underflow
-	de = (int)(word0(d) >> Exp_shift);
+	de = (int)(word0(&d) >> Exp_shift);
 	z |= Exp_msk11;
 #else
-	if ( (de = (int)(word0(d) >> Exp_shift)) !=0)
+	if ( (de = (int)(word0(&d) >> Exp_shift)) !=0)
 		z |= Exp_msk1;
 #endif
 #ifdef Pack_32
-	if ( (y = word1(d)) !=0) {
+	if ( (y = word1(&d)) !=0) {
 		if ( (k = lo0bits(&y)) !=0) {
 			x[0] = y | z << (32 - k);
 			z >>= k;
@@ -719,7 +717,7 @@
 		k += 32;
 	}
 #else
-	if ( (y = word1(d)) !=0) {
+	if ( (y = word1(&d)) !=0) {
 		if ( (k = lo0bits(&y)) !=0)
 			if (k >= 16) {
 				x[0] = y | z << 32 - k & 0xffff;
diff --git a/mingw-w64-crt/gdtoa/smisc.c b/mingw-w64-crt/gdtoa/smisc.c
index 690e840..e5b9c58 100644
--- a/mingw-w64-crt/gdtoa/smisc.c
+++ b/mingw-w64-crt/gdtoa/smisc.c
@@ -68,16 +68,16 @@
 	union _dbl_union da, db;
 	int k, ka, kb;
 
-	dval(da) = b2d(a, &ka);
-	dval(db) = b2d(b, &kb);
+	dval(&da) = b2d(a, &ka);
+	dval(&db) = b2d(b, &kb);
 	k = ka - kb + ULbits*(a->wds - b->wds);
 	if (k > 0)
-		word0(da) += k*Exp_msk1;
+		word0(&da) += k*Exp_msk1;
 	else {
 		k = -k;
-		word0(db) += k*Exp_msk1;
+		word0(&db) += k*Exp_msk1;
 	}
-	return dval(da) / dval(db);
+	return dval(&da) / dval(&db);
 }
 
 #ifdef INFNAN_CHECK
diff --git a/mingw-w64-crt/gdtoa/strtodg.c b/mingw-w64-crt/gdtoa/strtodg.c
index fed1401..652f252 100644
--- a/mingw-w64-crt/gdtoa/strtodg.c
+++ b/mingw-w64-crt/gdtoa/strtodg.c
@@ -145,7 +145,7 @@
 	return b;
 }
 
-static int rvOK (double d, FPI *fpi, Long *exp, ULong *bits,
+static int rvOK (dbl_union *d, FPI *fpi, Long *exp, ULong *bits,
 				int exact, int rd, int *irv)
 {
 	Bigint *b;
@@ -153,7 +153,7 @@
 	int bdif, e, j, k, k1, nb, rv;
 
 	carry = rv = 0;
-	b = d2b(d, &e, &bdif);
+	b = d2b(dval(d), &e, &bdif);
 	bdif -= nb = fpi->nbits;
 	e += bdif;
 	if (bdif <= 0) {
@@ -260,12 +260,9 @@
 	return rv;
 }
 
-static int mantbits (double val)
+static int mantbits (dbl_union *d)
 {
 	ULong L;
-	union _dbl_union d;
-
-	d.d = val;
 	if ( (L = word1(d)) !=0)
 		return P - lo0bits(&L);
 	L = word0(d) | Exp_msk1;
@@ -281,14 +278,14 @@
 	int sudden_underflow;
 	const char *s, *s0, *s1;
 	double adj0, tol;
-	union _dbl_union adj, rv;
 	Long L;
+	union _dbl_union adj, rv;
 	ULong y, z;
 	Bigint *ab, *bb, *bb1, *bd, *bd0, *bs, *delta, *rvb, *rvb0;
 
 	irv = STRTOG_Zero;
 	denorm = sign = nz0 = nz = 0;
-	dval(rv) = 0.;
+	dval(&rv) = 0.;
 	rvb = 0;
 	nbits = fpi->nbits;
 	for(s = s00;;s++) switch(*s) {
@@ -476,20 +473,20 @@
 	if (!nd0)
 		nd0 = nd;
 	k = nd < DBL_DIG + 1 ? nd : DBL_DIG + 1;
-	dval(rv) = y;
+	dval(&rv) = y;
 	if (k > 9)
-		dval(rv) = tens[k - 9] * dval(rv) + z;
+		dval(&rv) = tens[k - 9] * dval(&rv) + z;
 	bd0 = 0;
 	if (nbits <= P && nd <= DBL_DIG) {
 		if (!e) {
-			if (rvOK(dval(rv), fpi, exp, bits, 1, rd, &irv))
+			if (rvOK(&rv, fpi, exp, bits, 1, rd, &irv))
 				goto ret;
 		}
 		else if (e > 0) {
 			if (e <= Ten_pmax) {
-				i = fivesbits[e] + mantbits(dval(rv)) <= P;
-				/* rv = */ rounded_product(dval(rv), tens[e]);
-				if (rvOK(dval(rv), fpi, exp, bits, i, rd, &irv))
+				i = fivesbits[e] + mantbits(&rv) <= P;
+				/* rv = */ rounded_product(dval(&rv), tens[e]);
+				if (rvOK(&rv, fpi, exp, bits, i, rd, &irv))
 					goto ret;
 				e1 -= e;
 				goto rv_notOK;
@@ -501,17 +498,17 @@
 				 */
 				e2 = e - i;
 				e1 -= i;
-				dval(rv) *= tens[i];
-				/* rv = */ rounded_product(dval(rv), tens[e2]);
-				if (rvOK(dval(rv), fpi, exp, bits, 0, rd, &irv))
+				dval(&rv) *= tens[i];
+				/* rv = */ rounded_product(dval(&rv), tens[e2]);
+				if (rvOK(&rv, fpi, exp, bits, 0, rd, &irv))
 					goto ret;
 				e1 -= e2;
 			}
 		}
 #ifndef Inaccurate_Divide
 		else if (e >= -Ten_pmax) {
-			/* rv = */ rounded_quotient(dval(rv), tens[-e]);
-			if (rvOK(dval(rv), fpi, exp, bits, 0, rd, &irv))
+			/* rv = */ rounded_quotient(dval(&rv), tens[-e]);
+			if (rvOK(&rv, fpi, exp, bits, 0, rd, &irv))
 				goto ret;
 			e1 -= e;
 		}
@@ -525,48 +522,48 @@
 	e2 = 0;
 	if (e1 > 0) {
 		if ( (i = e1 & 15) !=0)
-			dval(rv) *= tens[i];
+			dval(&rv) *= tens[i];
 		if (e1 &= ~15) {
 			e1 >>= 4;
 			while(e1 >= (1 << (n_bigtens-1))) {
-				e2 += ((word0(rv) & Exp_mask)
+				e2 += ((word0(&rv) & Exp_mask)
 					>> Exp_shift1) - Bias;
-				word0(rv) &= ~Exp_mask;
-				word0(rv) |= Bias << Exp_shift1;
-				dval(rv) *= bigtens[n_bigtens-1];
+				word0(&rv) &= ~Exp_mask;
+				word0(&rv) |= Bias << Exp_shift1;
+				dval(&rv) *= bigtens[n_bigtens-1];
 				e1 -= 1 << (n_bigtens-1);
 			}
-			e2 += ((word0(rv) & Exp_mask) >> Exp_shift1) - Bias;
-			word0(rv) &= ~Exp_mask;
-			word0(rv) |= Bias << Exp_shift1;
+			e2 += ((word0(&rv) & Exp_mask) >> Exp_shift1) - Bias;
+			word0(&rv) &= ~Exp_mask;
+			word0(&rv) |= Bias << Exp_shift1;
 			for(j = 0; e1 > 0; j++, e1 >>= 1)
 				if (e1 & 1)
-					dval(rv) *= bigtens[j];
+					dval(&rv) *= bigtens[j];
 		}
 	}
 	else if (e1 < 0) {
 		e1 = -e1;
 		if ( (i = e1 & 15) !=0)
-			dval(rv) /= tens[i];
+			dval(&rv) /= tens[i];
 		if (e1 &= ~15) {
 			e1 >>= 4;
 			while(e1 >= (1 << (n_bigtens-1))) {
-				e2 += ((word0(rv) & Exp_mask)
+				e2 += ((word0(&rv) & Exp_mask)
 					>> Exp_shift1) - Bias;
-				word0(rv) &= ~Exp_mask;
-				word0(rv) |= Bias << Exp_shift1;
-				dval(rv) *= tinytens[n_bigtens-1];
+				word0(&rv) &= ~Exp_mask;
+				word0(&rv) |= Bias << Exp_shift1;
+				dval(&rv) *= tinytens[n_bigtens-1];
 				e1 -= 1 << (n_bigtens-1);
 			}
-			e2 += ((word0(rv) & Exp_mask) >> Exp_shift1) - Bias;
-			word0(rv) &= ~Exp_mask;
-			word0(rv) |= Bias << Exp_shift1;
+			e2 += ((word0(&rv) & Exp_mask) >> Exp_shift1) - Bias;
+			word0(&rv) &= ~Exp_mask;
+			word0(&rv) |= Bias << Exp_shift1;
 			for(j = 0; e1 > 0; j++, e1 >>= 1)
 				if (e1 & 1)
-					dval(rv) *= tinytens[j];
+					dval(&rv) *= tinytens[j];
 		}
 	}
-	rvb = d2b(dval(rv), &rve, &rvbits);	/* rv = rvb * 2^rve */
+	rvb = d2b(dval(&rv), &rve, &rvbits);	/* rv = rvb * 2^rve */
 	rve += e2;
 	if ((j = rvbits - nbits) > 0) {
 		rshift(rvb, j);
@@ -763,7 +760,7 @@
 			}
 			break;
 		}
-		if ((dval(adj) = ratio(delta, bs)) <= 2.) {
+		if ((dval(&adj) = ratio(delta, bs)) <= 2.) {
  adj1:
 			inex = STRTOG_Inexlo;
 			if (dsign) {
@@ -777,15 +774,15 @@
 				irv = STRTOG_Underflow | STRTOG_Inexlo;
 				break;
 			}
-			adj0 = dval(adj) = 1.;
+			adj0 = dval(&adj) = 1.;
 		}
 		else {
-			adj0 = dval(adj) *= 0.5;
+			adj0 = dval(&adj) *= 0.5;
 			if (dsign) {
 				asub = 0;
 				inex = STRTOG_Inexlo;
 			}
-			if (dval(adj) < 2147483647.) {
+			if (dval(&adj) < 2147483647.) {
 				L = adj0;
 				adj0 -= L;
 				switch(rd) {
@@ -804,12 +801,12 @@
 						inex = STRTOG_Inexact - inex;
 					}
 				}
-				dval(adj) = L;
+				dval(&adj) = L;
 			}
 		}
 		y = rve + rvbits;
 
-		/* adj *= ulp(dval(rv)); */
+		/* adj *= ulp(&rv); */
 		/* if (asub) rv -= adj; else rv += adj; */
 
 		if (!denorm && rvbits < nbits) {
@@ -817,7 +814,7 @@
 			rve -= j;
 			rvbits = nbits;
 		}
-		ab = d2b(dval(adj), &abe, &abits);
+		ab = d2b(dval(&adj), &abe, &abits);
 		if (abe < 0)
 			rshift(ab, -abe);
 		else if (abe > 0)
@@ -871,15 +868,15 @@
 		z = rve + rvbits;
 		if (y == z && L) {
 			/* Can we stop now? */
-			tol = dval(adj) * 5e-16; /* > max rel error */
-			dval(adj) = adj0 - .5;
-			if (dval(adj) < -tol) {
+			tol = dval(&adj) * 5e-16; /* > max rel error */
+			dval(&adj) = adj0 - .5;
+			if (dval(&adj) < -tol) {
 				if (adj0 > tol) {
 					irv |= inex;
 					break;
 				}
 			}
-			else if (dval(adj) > tol && adj0 < 1. - tol) {
+			else if (dval(&adj) > tol && adj0 < 1. - tol) {
 				irv |= inex;
 				break;
 			}
diff --git a/mingw-w64-crt/gdtoa/strtof.c b/mingw-w64-crt/gdtoa/strtof.c
index bcead5a..d9c69d6 100644
--- a/mingw-w64-crt/gdtoa/strtof.c
+++ b/mingw-w64-crt/gdtoa/strtof.c
@@ -48,7 +48,7 @@
 
 	  case STRTOG_Normal:
 	  case STRTOG_NaNbits:
-		u.L[0] = (bits[0] & 0x7fffff) | (exp + 0x7f + 23) << 23;
+		u.L[0] = (bits[0] & 0x7fffff) | ((exp + 0x7f + 23) << 23);
 		break;
 
 	  case STRTOG_Denormal:
diff --git a/mingw-w64-crt/gdtoa/ulp.c b/mingw-w64-crt/gdtoa/ulp.c
index 373c9cd..bfa9bde 100644
--- a/mingw-w64-crt/gdtoa/ulp.c
+++ b/mingw-w64-crt/gdtoa/ulp.c
@@ -31,33 +31,31 @@
 
 #include "gdtoaimp.h"
 
-double ulp (double x)
+double ulp (dbl_union *x)
 {
 	Long L;
 	union _dbl_union a;
 
-	a.d = x;
-	L = (word0(a) & Exp_mask) - (P-1)*Exp_msk1;
-
+	L = (word0(x) & Exp_mask) - (P-1)*Exp_msk1;
 #ifndef Sudden_Underflow
 	if (L > 0) {
 #endif
-		word0(a) = L;
-		word1(a) = 0;
+		word0(&a) = L;
+		word1(&a) = 0;
 #ifndef Sudden_Underflow
 	}
 	else {
 		L = -L >> Exp_shift;
 		if (L < Exp_shift) {
-			word0(a) = 0x80000 >> L;
-			word1(a) = 0;
+			word0(&a) = 0x80000 >> L;
+			word1(&a) = 0;
 		}
 		else {
-			word0(a) = 0;
+			word0(&a) = 0;
 			L -= Exp_shift;
-			word1(a) = L >= 31 ? 1 : 1 << (31 - L);
+			word1(&a) = L >= 31 ? 1 : 1 << (31 - L);
 		}
 	}
 #endif
-	return dval(a);
+	return dval(&a);
 }