Fix strict aliasing bug with gcc-4.4, bug 265579. Those letters really are huge. dirtyepic++ for backporting.

Package-Manager: portage-2.2_rc28/cvs/Linux x86_64

6 files changed, 1797 insertions, 9 deletions

diff --git a/net-libs/webkit-gtk/ChangeLog b/net-libs/webkit-gtk/ChangeLog
index d1722c53e07a..cc4042e0be44 100644
--- a/net-libs/webkit-gtk/ChangeLog
+++ b/net-libs/webkit-gtk/ChangeLog
@@ -1,6 +1,13 @@
 # ChangeLog for net-libs/webkit-gtk
 # Copyright 1999-2009 Gentoo Foundation; Distributed under the GPL v2
-# $Header: /var/cvsroot/gentoo-x86/net-libs/webkit-gtk/ChangeLog,v 1.23 2009/04/05 15:33:05 jokey Exp $
+# $Header: /var/cvsroot/gentoo-x86/net-libs/webkit-gtk/ChangeLog,v 1.24 2009/05/07 22:13:15 loki_val Exp $
+
+  07 May 2009; Peter Alfredsen <loki_val@gentoo.org>
+  webkit-gtk-0_p40220.ebuild, webkit-gtk-0_p42162.ebuild,
+  +files/webkit-gtk-0_p40220-gcc44-aliasing.patch,
+  +files/webkit-gtk-0_p42162-gcc44-aliasing.patch:
+  Fix strict aliasing bug with gcc-4.4, bug 265579. Those letters really are
+  huge. dirtyepic++ for backporting.
 
 *webkit-gtk-0_p42162 (05 Apr 2009)
 
diff --git a/net-libs/webkit-gtk/Manifest b/net-libs/webkit-gtk/Manifest
index 927de41ca8b2..cc19646eaf8d 100644
--- a/net-libs/webkit-gtk/Manifest
+++ b/net-libs/webkit-gtk/Manifest
@@ -1,6 +1,8 @@
+AUX webkit-gtk-0_p40220-gcc44-aliasing.patch 31876 RMD160 19f850df93fd81d1a736dbcc5441d0193929ef35 SHA1 293465980ececa6f2dbdd55787edf2676f628edf SHA256 6aee86b94b443a088502a35d25ffc7f17fa36f6e89dd082dcca11042a7af110f
+AUX webkit-gtk-0_p42162-gcc44-aliasing.patch 26682 RMD160 6e74cd94ff6cd26b521df3e474527835f2319821 SHA1 bff55f18d164ec53ab636a7ff60fe6acf60b882a SHA256 914348d8818b26b140b9d3e636dc3487e5ba26456c2f1c44f02b5ce082b1251f
 DIST WebKit-r40220.tar.bz2 10307835 RMD160 5700977d5a9a23680e58b1e3952ecb2fe1430e9a SHA1 2aa2bd3a9c60f53a1a1ef0bf810ea2c59b0a80e2 SHA256 223154d0e247336cd3cf808b030cfb00739103b7a258050e71703903df922020
 DIST WebKit-r42162.tar.bz2 10587869 RMD160 19d39fe4025dc6c5dc048bb0111dbab4adab09f6 SHA1 059e0d94a9bd4cfc589fc79a49f660571ce0d88d SHA256 c160a5cd8d95d257582a3d71803890868c03901953c929a2178b1a34d8f8f6a5
-EBUILD webkit-gtk-0_p40220.ebuild 1747 RMD160 733af6590526649244bb38433c5770b4d64dc221 SHA1 4f52b13c13c3deee7306afa685487b3536a6e938 SHA256 a09d15ce292266abfca7cbc85e08d974bc4195579f4e06a76df56764c79b8471
-EBUILD webkit-gtk-0_p42162.ebuild 1811 RMD160 a218152473106b1b548134fad96aaeea96bedf1f SHA1 b8f2b0ee2e238b49326199e2bc697ddb615fbf45 SHA256 f739378bb1eb6204f0cc8a440d831b3248a6c684038baaad4d02f1caea698c22
-MISC ChangeLog 6496 RMD160 684280b2e99f7caab8741c35610ef8947d901379 SHA1 772c564d416aebcce4ea812f5fe884eeef1a0598 SHA256 de5229e1aadbaa82005ad7c2dbca01a7cda849cbd1b01ba4df4baa75f2157655
+EBUILD webkit-gtk-0_p40220.ebuild 1803 RMD160 155733d5699332aa88e06bf9b8f225e07443c0f8 SHA1 599f5dfc10471af258d61774d88214371792378b SHA256 691f39e796b530ffc7801729e20b1343d4fbbe0f7c1f1a25f97a3fb302602412
+EBUILD webkit-gtk-0_p42162.ebuild 1869 RMD160 e7edf88405d085d46c645c927f233f07d9058f77 SHA1 0b6e9c0623e76902f61dc5fc9e49955b839aaeeb SHA256 f0ae27ec83f2a6ded671dea5135ea67727b501bcc006def41a16e7c881a34b34
+MISC ChangeLog 6827 RMD160 dfc3b8db3c734a7a6a6118f1132c84b975533d28 SHA1 6a3fc9b4dd70cb2ca0a6c1fad8ab7611e16f7578 SHA256 f4c268e95682998bc278f18ad98641290bbdf0b8bb60d9e124a61d878d524ce4
 MISC metadata.xml 533 RMD160 ff61aeef26bfef5b2f6ba6de2ad8c4c55548e84b SHA1 6b47fbec6901f23ec311ec2bd5b6e62c996b406c SHA256 c38f1b44c497e5dc6fc4d33cab656255fee3a0f705624d59f7058c7ad43304ff
diff --git a/net-libs/webkit-gtk/files/webkit-gtk-0_p40220-gcc44-aliasing.patch b/net-libs/webkit-gtk/files/webkit-gtk-0_p40220-gcc44-aliasing.patch
new file mode 100644
index 000000000000..212659e31809
--- /dev/null
+++ b/net-libs/webkit-gtk/files/webkit-gtk-0_p40220-gcc44-aliasing.patch
@@ -0,0 +1,954 @@
+diff -Naurp WebKit-r40220-orig/JavaScriptCore/wtf/dtoa.cpp WebKit-r40220/JavaScriptCore/wtf/dtoa.cpp
+--- WebKit-r40220-orig/JavaScriptCore/wtf/dtoa.cpp	2009-01-22 17:57:26.000000000 -0600
++++ WebKit-r40220/JavaScriptCore/wtf/dtoa.cpp	2009-04-09 14:55:22.000000000 -0600
+@@ -189,13 +189,13 @@ typedef union { double d; uint32_t L[2];
+ #endif
+ #else
+ #ifdef IEEE_8087
+-#define word0(x) ((U*)&x)->L[1]
+-#define word1(x) ((U*)&x)->L[0]
++#define word0(x) (x)->L[1]
++#define word1(x) (x)->L[0]
+ #else
+-#define word0(x) ((U*)&x)->L[0]
+-#define word1(x) ((U*)&x)->L[1]
++#define word0(x) (x)->L[0]
++#define word1(x) (x)->L[1]
+ #endif
+-#define dval(x) ((U*)&x)->d
++#define dval(x) (x)->d
+ #endif
+ 
+ /* The following definition of Storeinc is appropriate for MIPS processors.
+@@ -772,10 +772,10 @@ static Bigint* diff(Bigint* a, Bigint* b
+     return c;
+ }
+ 
+-static double ulp(double x)
++static double ulp(U *x)
+ {
+     register int32_t L;
+-    double a;
++    U u;
+ 
+     L = (word0(x) & Exp_mask) - (P - 1) * Exp_msk1;
+ #ifndef Avoid_Underflow
+@@ -783,24 +783,24 @@ static double ulp(double x)
+     if (L > 0) {
+ #endif
+ #endif
+-        word0(a) = L;
+-        word1(a) = 0;
++        word0(&u) = L;
++        word1(&u) = 0;
+ #ifndef Avoid_Underflow
+ #ifndef Sudden_Underflow
+     } else {
+         L = -L >> Exp_shift;
+         if (L < Exp_shift) {
+-            word0(a) = 0x80000 >> L;
+-            word1(a) = 0;
++            word0(&u) = 0x80000 >> L;
++            word1(&u) = 0;
+         } else {
+-            word0(a) = 0;
++            word0(&u) = 0;
+             L -= Exp_shift;
+-            word1(a) = L >= 31 ? 1 : 1 << 31 - L;
++            word1(&u) = L >= 31 ? 1 : 1 << 31 - L;
+         }
+     }
+ #endif
+ #endif
+-    return dval(a);
++    return dval(&u);
+ }
+ 
+ static double b2d(Bigint* a, int* e)
+@@ -811,10 +811,10 @@ static double b2d(Bigint* a, int* e)
+     uint32_t y;
+     uint32_t z;
+     int k;
+-    double d;
++    U d;
+ 
+-#define d0 word0(d)
+-#define d1 word1(d)
++#define d0 word0(&d)
++#define d1 word1(&d)
+ 
+     xa0 = a->x;
+     xa = xa0 + a->wds;
+@@ -824,16 +824,16 @@ static double b2d(Bigint* a, int* e)
+     *e = 32 - k;
+ #ifdef Pack_32
+     if (k < Ebits) {
+-        d0 = Exp_1 | y >> Ebits - k;
++        d0 = Exp_1 | (y >> (Ebits - k));
+         w = xa > xa0 ? *--xa : 0;
+-        d1 = y << (32 - Ebits) + k | w >> Ebits - k;
++        d1 = (y << (32 - Ebits + k)) | (w >> (Ebits - k));
+         goto ret_d;
+     }
+     z = xa > xa0 ? *--xa : 0;
+     if (k -= Ebits) {
+-        d0 = Exp_1 | y << k | z >> 32 - k;
++        d0 = Exp_1 | (y << k) | (z >> (32 - k));
+         y = xa > xa0 ? *--xa : 0;
+-        d1 = z << k | y >> 32 - k;
++        d1 = (z << k) | (y >> (32 - k));
+     } else {
+         d0 = Exp_1 | y;
+         d1 = z;
+@@ -857,10 +857,10 @@ static double b2d(Bigint* a, int* e)
+ ret_d:
+ #undef d0
+ #undef d1
+-    return dval(d);
++    return dval(&d);
+ }
+ 
+-static Bigint* d2b(double d, int* e, int* bits)
++static Bigint* d2b(U* d, int* e, int* bits)
+ {
+     Bigint* b;
+     int de, k;
+@@ -889,7 +889,7 @@ static Bigint* d2b(double d, int* e, int
+ #ifdef Pack_32
+     if ((y = d1)) {
+         if ((k = lo0bits(&y))) {
+-            x[0] = y | z << 32 - k;
++            x[0] = y | (z << (32 - k));
+             z >>= k;
+         } else
+             x[0] = y;
+@@ -965,23 +965,23 @@ static Bigint* d2b(double d, int* e, int
+ 
+ static double ratio(Bigint* a, Bigint* b)
+ {
+-    double da, db;
++    U 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);
+ #ifdef Pack_32
+     k = ka - kb + 32 * (a->wds - b->wds);
+ #else
+     k = ka - kb + 16 * (a->wds - b->wds);
+ #endif
+     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);
+ }
+ 
+ static const double tens[] = {
+@@ -1031,7 +1031,7 @@ static int match(const char** sp, const 
+ }
+ 
+ #ifndef No_Hex_NaN
+-static void hexnan(double* rvp, const char** sp)
++static void hexnan(U* rvp, const char** sp)
+ {
+     uint32_t c, x[2];
+     const char* s;
+@@ -1070,8 +1070,8 @@ static void hexnan(double* rvp, const ch
+         x[1] = (x[1] << 4) | c;
+     }
+     if ((x[0] &= 0xfffff) || x[1]) {
+-        word0(*rvp) = Exp_mask | x[0];
+-        word1(*rvp) = x[1];
++        word0(rvp) = Exp_mask | x[0];
++        word1(rvp) = x[1];
+     }
+ }
+ #endif /*No_Hex_NaN*/
+@@ -1085,7 +1085,8 @@ double strtod(const char* s00, char** se
+     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, aadj1;
++    U aadj2, adj, rv, rv0;
+     int32_t L;
+     uint32_t y, z;
+     Bigint *bb = NULL, *bb1 = NULL, *bd = NULL, *bd0 = NULL, *bs = NULL, *delta = NULL;
+@@ -1094,7 +1095,7 @@ double strtod(const char* s00, char** se
+ #endif
+ 
+     sign = nz0 = nz = 0;
+-    dval(rv) = 0.;
++    dval(&rv) = 0;
+     for (s = s00; ; s++)
+         switch (*s) {
+             case '-':
+@@ -1209,16 +1210,16 @@ dig_done:
+                         --s;
+                         if (!match(&s,"inity"))
+                             ++s;
+-                        word0(rv) = 0x7ff00000;
+-                        word1(rv) = 0;
++                        word0(&rv) = 0x7ff00000;
++                        word1(&rv) = 0;
+                         goto ret;
+                     }
+                     break;
+                 case 'n':
+                 case 'N':
+                     if (match(&s, "an")) {
+-                        word0(rv) = NAN_WORD0;
+-                        word1(rv) = NAN_WORD1;
++                        word0(&rv) = NAN_WORD0;
++                        word1(&rv) = NAN_WORD1;
+ #ifndef No_Hex_NaN
+                         if (*s == '(') /*)*/
+                             hexnan(&rv, &s);
+@@ -1243,13 +1244,13 @@ ret0:
+     if (!nd0)
+         nd0 = nd;
+     k = nd < DBL_DIG + 1 ? nd : DBL_DIG + 1;
+-    dval(rv) = y;
++    dval(&rv) = y;
+     if (k > 9) {
+ #ifdef SET_INEXACT
+         if (k > DBL_DIG)
+             oldinexact = get_inexact();
+ #endif
+-        dval(rv) = tens[k - 9] * dval(rv) + z;
++        dval(&rv) = tens[k - 9] * dval(&rv) + z;
+     }
+     bd0 = 0;
+     if (nd <= DBL_DIG && Flt_Rounds == 1) {
+@@ -1257,7 +1258,7 @@ ret0:
+             goto ret;
+         if (e > 0) {
+             if (e <= Ten_pmax) {
+-                /* rv = */ rounded_product(dval(rv), tens[e]);
++                /* rv = */ rounded_product(dval(&rv), tens[e]);
+                 goto ret;
+             }
+             i = DBL_DIG - nd;
+@@ -1266,14 +1267,14 @@ ret0:
+                  * this for larger i values.
+                  */
+                 e -= i;
+-                dval(rv) *= tens[i];
+-                /* rv = */ rounded_product(dval(rv), tens[e]);
++                dval(&rv) *= tens[i];
++                /* rv = */ rounded_product(dval(&rv), tens[e]);
+                 goto ret;
+             }
+         }
+ #ifndef Inaccurate_Divide
+         else if (e >= -Ten_pmax) {
+-            /* rv = */ rounded_quotient(dval(rv), tens[-e]);
++            /* rv = */ rounded_quotient(dval(&rv), tens[-e]);
+             goto ret;
+         }
+ #endif
+@@ -1293,7 +1294,7 @@ ret0:
+ 
+     if (e1 > 0) {
+         if ((i = e1 & 15))
+-            dval(rv) *= tens[i];
++            dval(&rv) *= tens[i];
+         if (e1 &= ~15) {
+             if (e1 > DBL_MAX_10_EXP) {
+ ovfl:
+@@ -1301,12 +1302,12 @@ ovfl:
+                 errno = ERANGE;
+ #endif
+                 /* Can't trust HUGE_VAL */
+-                word0(rv) = Exp_mask;
+-                word1(rv) = 0;
++                word0(&rv) = Exp_mask;
++                word1(&rv) = 0;
+ #ifdef SET_INEXACT
+                 /* set overflow bit */
+-                dval(rv0) = 1e300;
+-                dval(rv0) *= dval(rv0);
++                dval(&rv0) = 1e300;
++                dval(&rv0) *= dval(&rv0);
+ #endif
+                 if (bd0)
+                     goto retfree;
+@@ -1315,24 +1316,24 @@ ovfl:
+             e1 >>= 4;
+             for (j = 0; e1 > 1; j++, e1 >>= 1)
+                 if (e1 & 1)
+-                    dval(rv) *= bigtens[j];
++                    dval(&rv) *= bigtens[j];
+         /* The last multiplication could overflow. */
+-            word0(rv) -= P * Exp_msk1;
+-            dval(rv) *= bigtens[j];
+-            if ((z = word0(rv) & Exp_mask) > Exp_msk1 * (DBL_MAX_EXP + Bias - P))
++            word0(&rv) -= P * Exp_msk1;
++            dval(&rv) *= bigtens[j];
++            if ((z = word0(&rv) & Exp_mask) > Exp_msk1 * (DBL_MAX_EXP + Bias - P))
+                 goto ovfl;
+             if (z > Exp_msk1 * (DBL_MAX_EXP + Bias - 1 - P)) {
+                 /* set to largest number */
+                 /* (Can't trust DBL_MAX) */
+-                word0(rv) = Big0;
+-                word1(rv) = Big1;
++                word0(&rv) = Big0;
++                word1(&rv) = Big1;
+             } else
+-                word0(rv) += P * Exp_msk1;
++                word0(&rv) += P * Exp_msk1;
+         }
+     } else if (e1 < 0) {
+         e1 = -e1;
+         if ((i = e1 & 15))
+-            dval(rv) /= tens[i];
++            dval(&rv) /= tens[i];
+         if (e1 >>= 4) {
+             if (e1 >= 1 << n_bigtens)
+                 goto undfl;
+@@ -1341,32 +1342,32 @@ ovfl:
+                 scale = 2 * P;
+             for (j = 0; e1 > 0; j++, e1 >>= 1)
+                 if (e1 & 1)
+-                    dval(rv) *= tinytens[j];
+-            if (scale && (j = (2 * P) + 1 - ((word0(rv) & Exp_mask) >> Exp_shift)) > 0) {
++                    dval(&rv) *= tinytens[j];
++            if (scale && (j = (2 * P) + 1 - ((word0(&rv) & Exp_mask) >> Exp_shift)) > 0) {
+                 /* scaled rv is denormal; zap j low bits */
+                 if (j >= 32) {
+-                    word1(rv) = 0;
++                    word1(&rv) = 0;
+                     if (j >= 53)
+-                       word0(rv) = (P + 2) * Exp_msk1;
++                       word0(&rv) = (P + 2) * Exp_msk1;
+                     else
+-                       word0(rv) &= 0xffffffff << j - 32;
++                       word0(&rv) &= 0xffffffff << (j - 32);
+                 } else
+-                    word1(rv) &= 0xffffffff << j;
++                    word1(&rv) &= 0xffffffff << j;
+             }
+ #else
+             for (j = 0; e1 > 1; j++, e1 >>= 1)
+                 if (e1 & 1)
+-                    dval(rv) *= tinytens[j];
++                    dval(&rv) *= tinytens[j];
+             /* The last multiplication could underflow. */
+-            dval(rv0) = dval(rv);
+-            dval(rv) *= tinytens[j];
+-            if (!dval(rv)) {
+-                dval(rv) = 2. * dval(rv0);
+-                dval(rv) *= tinytens[j];
++            dval(&rv0) = dval(&rv);
++            dval(&rv) *= tinytens[j];
++            if (!dval(&rv)) {
++                dval(&rv) = 2. * dval(&rv0);
++                dval(&rv) *= tinytens[j];
+ #endif
+-                if (!dval(rv)) {
++                if (!dval(&rv)) {
+ undfl:
+-                    dval(rv) = 0.;
++                    dval(&rv) = 0.;
+ #ifndef NO_ERRNO
+                     errno = ERANGE;
+ #endif
+@@ -1375,8 +1376,8 @@ undfl:
+                     goto ret;
+                 }
+ #ifndef Avoid_Underflow
+-                word0(rv) = Tiny0;
+-                word1(rv) = Tiny1;
++                word0(&rv) = Tiny0;
++                word1(&rv) = Tiny1;
+                 /* The refinement below will clean
+                  * this approximation up.
+                  */
+@@ -1394,7 +1395,7 @@ undfl:
+     for (;;) {
+         bd = Balloc(bd0->k);
+         Bcopy(bd, bd0);
+-        bb = d2b(dval(rv), &bbe, &bbbits);    /* rv = bb * 2^bbe */
++        bb = d2b(&rv, &bbe, &bbbits);    /* rv = bb * 2^bbe */
+         bs = i2b(1);
+ 
+         if (e >= 0) {
+@@ -1464,11 +1465,11 @@ undfl:
+             /* 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
++            if (dsign || word1(&rv) || word0(&rv) & Bndry_mask
+ #ifdef Avoid_Underflow
+-             || (word0(rv) & Exp_mask) <= (2 * P + 1) * Exp_msk1
++             || (word0(&rv) & Exp_mask) <= (2 * P + 1) * Exp_msk1
+ #else
+-             || (word0(rv) & Exp_mask) <= Exp_msk1
++             || (word0(&rv) & Exp_mask) <= Exp_msk1
+ #endif
+                 ) {
+ #ifdef SET_INEXACT
+@@ -1492,26 +1493,26 @@ undfl:
+         if (i == 0) {
+             /* exactly half-way between */
+             if (dsign) {
+-                if ((word0(rv) & Bndry_mask1) == Bndry_mask1
+-                 &&  word1(rv) == (
++                if ((word0(&rv) & Bndry_mask1) == Bndry_mask1
++                 &&  word1(&rv) == (
+ #ifdef Avoid_Underflow
+-            (scale && (y = word0(rv) & Exp_mask) <= 2 * P * Exp_msk1)
++            (scale && (y = word0(&rv) & Exp_mask) <= 2 * P * Exp_msk1)
+         ? (0xffffffff & (0xffffffff << (2 * P + 1 - (y >> Exp_shift)))) :
+ #endif
+                            0xffffffff)) {
+                     /*boundary case -- increment exponent*/
+-                    word0(rv) = (word0(rv) & Exp_mask) + Exp_msk1;
+-                    word1(rv) = 0;
++                    word0(&rv) = (word0(&rv) & Exp_mask) + Exp_msk1;
++                    word1(&rv) = 0;
+ #ifdef Avoid_Underflow
+                     dsign = 0;
+ #endif
+                     break;
+                 }
+-            } else if (!(word0(rv) & Bndry_mask) && !word1(rv)) {
++            } else if (!(word0(&rv) & Bndry_mask) && !word1(&rv)) {
+ drop_down:
+                 /* boundary case -- decrement exponent */
+ #ifdef Sudden_Underflow /*{{*/
+-                L = word0(rv) & Exp_mask;
++                L = word0(&rv) & Exp_mask;
+ #ifdef Avoid_Underflow
+                 if (L <= (scale ? (2 * P + 1) * Exp_msk1 : Exp_msk1))
+ #else
+@@ -1522,7 +1523,7 @@ drop_down:
+ #else /*Sudden_Underflow}{*/
+ #ifdef Avoid_Underflow
+                 if (scale) {
+-                    L = word0(rv) & Exp_mask;
++                    L = word0(&rv) & Exp_mask;
+                     if (L <= (2 * P + 1) * Exp_msk1) {
+                         if (L > (P + 2) * Exp_msk1)
+                             /* round even ==> */
+@@ -1533,20 +1534,20 @@ drop_down:
+                     }
+                 }
+ #endif /*Avoid_Underflow*/
+-                L = (word0(rv) & Exp_mask) - Exp_msk1;
++                L = (word0(&rv) & Exp_mask) - Exp_msk1;
+ #endif /*Sudden_Underflow}}*/
+-                word0(rv) = L | Bndry_mask1;
+-                word1(rv) = 0xffffffff;
++                word0(&rv) = L | Bndry_mask1;
++                word1(&rv) = 0xffffffff;
+                 break;
+             }
+-            if (!(word1(rv) & LSB))
++            if (!(word1(&rv) & LSB))
+                 break;
+             if (dsign)
+-                dval(rv) += ulp(dval(rv));
++                dval(&rv) += ulp(&rv);
+             else {
+-                dval(rv) -= ulp(dval(rv));
++                dval(&rv) -= ulp(&rv);
+ #ifndef Sudden_Underflow
+-                if (!dval(rv))
++                if (!dval(&rv))
+                     goto undfl;
+ #endif
+             }
+@@ -1558,9 +1559,9 @@ drop_down:
+         if ((aadj = ratio(delta, bs)) <= 2.) {
+             if (dsign)
+                 aadj = aadj1 = 1.;
+-            else if (word1(rv) || word0(rv) & Bndry_mask) {
++            else if (word1(&rv) || word0(&rv) & Bndry_mask) {
+ #ifndef Sudden_Underflow
+-                if (word1(rv) == Tiny1 && !word0(rv))
++                if (word1(&rv) == Tiny1 && !word0(&rv))
+                     goto undfl;
+ #endif
+                 aadj = 1.;
+@@ -1592,23 +1593,23 @@ drop_down:
+                 aadj1 += 0.5;
+ #endif /*Check_FLT_ROUNDS*/
+         }
+-        y = word0(rv) & Exp_mask;
++        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;
+-            if ((word0(rv) & Exp_mask) >= Exp_msk1 * (DBL_MAX_EXP + Bias - P)) {
+-                if (word0(rv0) == Big0 && word1(rv0) == Big1)
++            dval(&rv0) = dval(&rv);
++            word0(&rv) -= P * Exp_msk1;
++            adj.d = aadj1 * ulp(&rv);
++            dval(&rv) += adj.d;
++            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;
++                word0(&rv) = Big0;
++                word1(&rv) = Big1;
+                 goto cont;
+             } else
+-                word0(rv) += P * Exp_msk1;
++                word0(&rv) += P * Exp_msk1;
+         } else {
+ #ifdef Avoid_Underflow
+             if (scale && y <= 2 * P * Exp_msk1) {
+@@ -1618,30 +1619,32 @@ drop_down:
+                     aadj = z;
+                     aadj1 = dsign ? aadj : -aadj;
+                 }
+-                word0(aadj1) += (2 * P + 1) * Exp_msk1 - y;
++                dval(&aadj2) = aadj1;
++                word0(&aadj2) += (2 * P + 1) * Exp_msk1 - y;
++                aadj1 = dval(&aadj2);
+             }
+-            adj = aadj1 * ulp(dval(rv));
+-            dval(rv) += adj;
++            adj.d = aadj1 * ulp(&rv);
++            dval(&rv) += adj.d;
+ #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;
+-                if ((word0(rv) & Exp_mask) <= P * Exp_msk1)
++            if ((word0(&rv) & Exp_mask) <= P * Exp_msk1) {
++                dval(&rv0) = dval(&rv);
++                word0(&rv) += P * Exp_msk1;
++                adj.d = aadj1 * ulp(&rv);
++                dval(&rv) += adj.d;
++                if ((word0(&rv) & Exp_mask) <= P * Exp_msk1)
+                 {
+-                    if (word0(rv0) == Tiny0 && word1(rv0) == Tiny1)
++                    if (word0(&rv0) == Tiny0 && word1(&rv0) == Tiny1)
+                         goto undfl;
+-                    word0(rv) = Tiny0;
+-                    word1(rv) = Tiny1;
++                    word0(&rv) = Tiny0;
++                    word1(&rv) = Tiny1;
+                     goto cont;
+                 }
+                 else
+-                    word0(rv) -= P * Exp_msk1;
++                    word0(&rv) -= P * Exp_msk1;
+             } else {
+-                adj = aadj1 * ulp(dval(rv));
+-                dval(rv) += adj;
++                adj.d = aadj1 * ulp(&rv);
++                dval(&rv) += adj.d;
+             }
+ #else /*Sudden_Underflow*/
+             /* Compute adj so that the IEEE rounding rules will
+@@ -1656,12 +1659,12 @@ drop_down:
+                 if (!dsign)
+                     aadj1 = -aadj1;
+             }
+-            adj = aadj1 * ulp(dval(rv));
+-            dval(rv) += adj;
++            adj.d = aadj1 * ulp(&rv);
++            dval(&rv) += adj.d;
+ #endif /*Sudden_Underflow*/
+ #endif /*Avoid_Underflow*/
+         }
+-        z = word0(rv) & Exp_mask;
++        z = word0(&rv) & Exp_mask;
+ #ifndef SET_INEXACT
+ #ifdef Avoid_Underflow
+         if (!scale)
+@@ -1671,7 +1674,7 @@ drop_down:
+             L = (int32_t)aadj;
+             aadj -= L;
+             /* The tolerances below are conservative. */
+-            if (dsign || word1(rv) || word0(rv) & Bndry_mask) {
++            if (dsign || word1(&rv) || word0(&rv) & Bndry_mask) {
+                 if (aadj < .4999999 || aadj > .5000001)
+                     break;
+             } else if (aadj < .4999999 / FLT_RADIX)
+@@ -1687,30 +1690,30 @@ cont:
+ #ifdef SET_INEXACT
+     if (inexact) {
+         if (!oldinexact) {
+-            word0(rv0) = Exp_1 + (70 << Exp_shift);
+-            word1(rv0) = 0;
+-            dval(rv0) += 1.;
++            word0(&rv0) = Exp_1 + (70 << Exp_shift);
++            word1(&rv0) = 0;
++            dval(&rv0) += 1.;
+         }
+     } else if (!oldinexact)
+         clear_inexact();
+ #endif
+ #ifdef Avoid_Underflow
+     if (scale) {
+-        word0(rv0) = Exp_1 - 2 * P * Exp_msk1;
+-        word1(rv0) = 0;
+-        dval(rv) *= dval(rv0);
++        word0(&rv0) = Exp_1 - 2 * P * Exp_msk1;
++        word1(&rv0) = 0;
++        dval(&rv) *= dval(&rv0);
+ #ifndef NO_ERRNO
+         /* try to avoid the bug of testing an 8087 register value */
+-        if (word0(rv) == 0 && word1(rv) == 0)
++        if (word0(&rv) == 0 && word1(&rv) == 0)
+             errno = ERANGE;
+ #endif
+     }
+ #endif /* Avoid_Underflow */
+ #ifdef SET_INEXACT
+-    if (inexact && !(word0(rv) & Exp_mask)) {
++    if (inexact && !(word0(&rv) & Exp_mask)) {
+         /* set underflow bit */
+-        dval(rv0) = 1e-300;
+-        dval(rv0) *= dval(rv0);
++        dval(&rv0) = 1e-300;
++        dval(&rv0) *= dval(&rv0);
+     }
+ #endif
+ retfree:
+@@ -1722,7 +1725,7 @@ retfree:
+ ret:
+     if (se)
+         *se = const_cast<char*>(s);
+-    return sign ? -dval(rv) : dval(rv);
++    return sign ? -dval(&rv) : dval(&rv);
+ }
+ 
+ static int quorem(Bigint* b, Bigint* S)
+@@ -1914,7 +1917,7 @@ void freedtoa(char* s)
+  *       calculation.
+  */
+ 
+-char* dtoa(double d, int ndigits, int* decpt, int* sign, char** rve)
++char* dtoa(double dd, int ndigits, int* decpt, int* sign, char** rve)
+ {
+     /*
+         Arguments ndigits, decpt, sign are similar to those
+@@ -1934,7 +1937,8 @@ char* dtoa(double d, int ndigits, int* d
+     uint32_t x;
+ #endif
+     Bigint *b, *b1, *delta, *mlo = NULL, *mhi, *S;
+-    double d2, ds, eps;
++    U d2, eps, u;
++    double ds;
+     char *s, *s0;
+ #ifdef SET_INEXACT
+     int inexact, oldinexact;
+@@ -1947,22 +1951,23 @@ char* dtoa(double d, int ndigits, int* d
+     }
+ #endif
+ 
+-    if (word0(d) & Sign_bit) {
++    u.d = dd;
++    if (word0(&u) & Sign_bit) {
+         /* set sign for everything, including 0's and NaNs */
+         *sign = 1;
+-        word0(d) &= ~Sign_bit;    /* clear sign bit */
++        word0(&u) &= ~Sign_bit;    /* clear sign bit */
+     } else
+         *sign = 0;
+ 
+-    if ((word0(d) & Exp_mask) == Exp_mask)
++    if ((word0(&u) & Exp_mask) == Exp_mask)
+     {
+         /* Infinity or NaN */
+         *decpt = 9999;
+-        if (!word1(d) && !(word0(d) & 0xfffff))
++        if (!word1(&u) && !(word0(&u) & 0xfffff))
+             return nrv_alloc("Infinity", rve, 8);
+         return nrv_alloc("NaN", rve, 3);
+     }
+-    if (!dval(d)) {
++    if (!dval(&u)) {
+         *decpt = 1;
+         return nrv_alloc("0", rve, 1);
+     }
+@@ -1972,15 +1977,15 @@ char* dtoa(double d, int ndigits, int* d
+     inexact = 1;
+ #endif
+ 
+-    b = d2b(dval(d), &be, &bbits);
++    b = d2b(&u, &be, &bbits);
+ #ifdef Sudden_Underflow
+-    i = (int)(word0(d) >> Exp_shift1 & (Exp_mask >> Exp_shift1));
++    i = (int)(word0(&u) >> Exp_shift1 & (Exp_mask >> Exp_shift1));
+ #else
+-    if ((i = (int)(word0(d) >> Exp_shift1 & (Exp_mask >> Exp_shift1)))) {
++    if ((i = (int)(word0(&u) >> Exp_shift1 & (Exp_mask >> Exp_shift1)))) {
+ #endif
+-        dval(d2) = dval(d);
+-        word0(d2) &= Frac_mask1;
+-        word0(d2) |= Exp_11;
++        dval(&d2) = dval(&u);
++        word0(&d2) &= Frac_mask1;
++        word0(&d2) |= Exp_11;
+ 
+         /* log(x)    ~=~ log(1.5) + (x-1.5)/1.5
+          * log10(x)     =  log(x) / log(10)
+@@ -2011,21 +2016,21 @@ char* dtoa(double d, int ndigits, int* d
+         /* 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(&u) << (64 - i)) | (word1(&u) >> (i - 32))
++                : word1(&u) << (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(&u) < tens[k])
+             k--;
+         k_check = 0;
+     }
+@@ -2066,7 +2071,7 @@ char* dtoa(double d, int ndigits, int* d
+         /* Try to get by with floating-point arithmetic. */
+ 
+         i = 0;
+-        dval(d2) = dval(d);
++        dval(&d2) = dval(&u);
+         k0 = k;
+         ilim0 = ilim;
+         ieps = 2; /* conservative */
+@@ -2076,7 +2081,7 @@ char* dtoa(double d, int ndigits, int* d
+             if (j & Bletch) {
+                 /* prevent overflows */
+                 j &= Bletch - 1;
+-                dval(d) /= bigtens[n_bigtens - 1];
++                dval(&u) /= bigtens[n_bigtens - 1];
+                 ieps++;
+             }
+             for (; j; j >>= 1, i++) {
+@@ -2085,32 +2090,32 @@ char* dtoa(double d, int ndigits, int* d
+                     ds *= bigtens[i];
+                 }
+             }
+-            dval(d) /= ds;
++            dval(&u) /= ds;
+         } else if ((j1 = -k)) {
+-            dval(d) *= tens[j1 & 0xf];
++            dval(&u) *= tens[j1 & 0xf];
+             for (j = j1 >> 4; j; j >>= 1, i++) {
+                 if (j & 1) {
+                     ieps++;
+-                    dval(d) *= bigtens[i];
++                    dval(&u) *= bigtens[i];
+                 }
+             }
+         }
+-        if (k_check && dval(d) < 1. && ilim > 0) {
++        if (k_check && dval(&u) < 1. && ilim > 0) {
+             if (ilim1 <= 0)
+                 goto fast_failed;
+             ilim = ilim1;
+             k--;
+-            dval(d) *= 10.;
++            dval(&u) *= 10.;
+             ieps++;
+         }
+-        dval(eps) = (ieps * dval(d)) + 7.;
+-        word0(eps) -= (P - 1) * Exp_msk1;
++        dval(&eps) = (ieps * dval(&u)) + 7.;
++        word0(&eps) -= (P - 1) * Exp_msk1;
+         if (ilim == 0) {
+             S = mhi = 0;
+-            dval(d) -= 5.;
+-            if (dval(d) > dval(eps))
++            dval(&u) -= 5.;
++            if (dval(&u) > dval(&eps))
+                 goto one_digit;
+-            if (dval(d) < -dval(eps))
++            if (dval(&u) < -dval(&eps))
+                 goto no_digits;
+             goto fast_failed;
+         }
+@@ -2119,33 +2124,33 @@ char* dtoa(double d, int ndigits, int* d
+             /* 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 = (long int)dval(d);
+-                dval(d) -= L;
++                L = (long int)dval(&u);
++                dval(&u) -= L;
+                 *s++ = '0' + (int)L;
+-                if (dval(d) < dval(eps))
++                if (dval(&u) < dval(&eps))
+                     goto ret1;
+-                if (1. - dval(d) < dval(eps))
++                if (1. - dval(&u) < dval(&eps))
+                     goto bump_up;
+                 if (++i >= ilim)
+                     break;
+-                dval(eps) *= 10.;
+-                dval(d) *= 10.;
++                dval(&eps) *= 10.;
++                dval(&u) *= 10.;
+             }
+         } else {
+ #endif
+             /* Generate ilim digits, then fix them up. */
+-            dval(eps) *= tens[ilim - 1];
+-            for (i = 1;; i++, dval(d) *= 10.) {
+-                L = (int32_t)(dval(d));
+-                if (!(dval(d) -= L))
++            dval(&eps) *= tens[ilim - 1];
++            for (i = 1;; i++, dval(&u) *= 10.) {
++                L = (int32_t)(dval(&u));
++                if (!(dval(&u) -= L))
+                     ilim = i;
+                 *s++ = '0' + (int)L;
+                 if (i == ilim) {
+-                    if (dval(d) > 0.5 + dval(eps))
++                    if (dval(&u) > 0.5 + dval(&eps))
+                         goto bump_up;
+-                    else if (dval(d) < 0.5 - dval(eps)) {
++                    else if (dval(&u) < 0.5 - dval(&eps)) {
+                         while (*--s == '0') { }
+                         s++;
+                         goto ret1;
+@@ -2158,7 +2163,7 @@ char* dtoa(double d, int ndigits, int* d
+ #endif
+ fast_failed:
+         s = s0;
+-        dval(d) = dval(d2);
++        dval(&u) = dval(&d2);
+         k = k0;
+         ilim = ilim0;
+     }
+@@ -2170,30 +2175,30 @@ fast_failed:
+         ds = tens[k];
+         if (ndigits < 0 && ilim <= 0) {
+             S = mhi = 0;
+-            if (ilim < 0 || dval(d) <= 5 * ds)
++            if (ilim < 0 || dval(&u) <= 5 * ds)
+                 goto no_digits;
+             goto one_digit;
+         }
+-        for (i = 1;; i++, dval(d) *= 10.) {
+-            L = (int32_t)(dval(d) / ds);
+-            dval(d) -= L * ds;
++        for (i = 1;; i++, dval(&u) *= 10.) {
++            L = (int32_t)(dval(&u) / ds);
++            dval(&u) -= L * ds;
+ #ifdef Check_FLT_ROUNDS
+             /* If FLT_ROUNDS == 2, L will usually be high by 1 */
+-            if (dval(d) < 0) {
++            if (dval(&u) < 0) {
+                 L--;
+-                dval(d) += ds;
++                dval(&u) += ds;
+             }
+ #endif
+             *s++ = '0' + (int)L;
+-            if (!dval(d)) {
++            if (!dval(&u)) {
+ #ifdef SET_INEXACT
+                 inexact = 0;
+ #endif
+                 break;
+             }
+             if (i == ilim) {
+-                dval(d) += dval(d);
+-                if (dval(d) > ds || dval(d) == ds && L & 1) {
++                dval(&u) += dval(&u);
++                if (dval(&u) > ds || (dval(&u) == ds && (L & 1))) {
+ bump_up:
+                     while (*--s == '9')
+                         if (s == s0) {
+@@ -2248,9 +2253,9 @@ bump_up:
+     /* Check for special case that d is a normalized power of 2. */
+ 
+     spec_case = 0;
+-    if (!word1(d) && !(word0(d) & Bndry_mask)
++    if (!word1(&u) && !(word0(&u) & Bndry_mask)
+ #ifndef Sudden_Underflow
+-     && word0(d) & (Exp_mask & ~Exp_msk1)
++     && word0(&u) & (Exp_mask & ~Exp_msk1)
+ #endif
+             ) {
+         /* The special case */
+@@ -2322,7 +2327,7 @@ bump_up:
+             delta = diff(S, mhi);
+             j1 = delta->sign ? 1 : cmp(b, delta);
+             Bfree(delta);
+-            if (j1 == 0 && !(word1(d) & 1)) {
++            if (j1 == 0 && !(word1(&u) & 1)) {
+                 if (dig == '9')
+                     goto round_9_up;
+                 if (j > 0)
+@@ -2334,7 +2339,7 @@ bump_up:
+                 *s++ = dig;
+                 goto ret;
+             }
+-            if (j < 0 || j == 0 && !(word1(d) & 1)) {
++            if (j < 0 || (j == 0 && !(word1(&u) & 1))) {
+                 if (!b->x[0] && b->wds <= 1) {
+ #ifdef SET_INEXACT
+                     inexact = 0;
+@@ -2344,7 +2349,7 @@ bump_up:
+                 if (j1 > 0) {
+                     b = lshift(b, 1);
+                     j1 = cmp(b, S);
+-                    if ((j1 > 0 || j1 == 0 && dig & 1) && dig++ == '9')
++                    if ((j1 > 0 || (j1 == 0 && (dig & 1))) && dig++ == '9')
+                         goto round_9_up;
+                 }
+ accept_dig:
+@@ -2389,7 +2394,7 @@ round_9_up:
+ 
+     b = lshift(b, 1);
+     j = cmp(b, S);
+-    if (j > 0 || j == 0 && dig & 1) {
++    if (j > 0 || (j == 0 && (dig & 1))) {
+ roundoff:
+         while (*--s == '9')
+             if (s == s0) {
+@@ -2421,9 +2426,9 @@ ret1:
+ #ifdef SET_INEXACT
+     if (inexact) {
+         if (!oldinexact) {
+-            word0(d) = Exp_1 + (70 << Exp_shift);
+-            word1(d) = 0;
+-            dval(d) += 1.;
++            word0(&u) = Exp_1 + (70 << Exp_shift);
++            word1(&u) = 0;
++            dval(&u) += 1.;
+         }
+     } else if (!oldinexact)
+         clear_inexact();
diff --git a/net-libs/webkit-gtk/files/webkit-gtk-0_p42162-gcc44-aliasing.patch b/net-libs/webkit-gtk/files/webkit-gtk-0_p42162-gcc44-aliasing.patch
new file mode 100644
index 000000000000..47a818d2cca3
--- /dev/null
+++ b/net-libs/webkit-gtk/files/webkit-gtk-0_p42162-gcc44-aliasing.patch
@@ -0,0 +1,824 @@
+Index: trunk/JavaScriptCore/wtf/dtoa.cpp
+===================================================================
+--- trunk/JavaScriptCore/wtf/dtoa.cpp (revision 41954)
++++ trunk/JavaScriptCore/wtf/dtoa.cpp (revision 42262)
+@@ -190,11 +190,11 @@
+ #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
++#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]
++#endif
++#define dval(x) (x)->d
+ #endif
+ 
+@@ -773,8 +773,8 @@
+ }
+ 
+-static double ulp(double x)
++static double ulp(U *x)
+ {
+     register int32_t L;
+-    double a;
++    U u;
+ 
+     L = (word0(x) & Exp_mask) - (P - 1) * Exp_msk1;
+@@ -784,6 +784,6 @@
+ #endif
+ #endif
+-        word0(a) = L;
+-        word1(a) = 0;
++        word0(&u) = L;
++        word1(&u) = 0;
+ #ifndef Avoid_Underflow
+ #ifndef Sudden_Underflow
+@@ -791,15 +791,15 @@
+         L = -L >> Exp_shift;
+         if (L < Exp_shift) {
+-            word0(a) = 0x80000 >> L;
+-            word1(a) = 0;
++            word0(&u) = 0x80000 >> L;
++            word1(&u) = 0;
+         } else {
+-            word0(a) = 0;
++            word0(&u) = 0;
+             L -= Exp_shift;
+-            word1(a) = L >= 31 ? 1 : 1 << 31 - L;
+-        }
+-    }
+-#endif
+-#endif
+-    return dval(a);
++            word1(&u) = L >= 31 ? 1 : 1 << 31 - L;
++        }
++    }
++#endif
++#endif
++    return dval(&u);
+ }
+ 
+@@ -812,8 +812,8 @@
+     uint32_t z;
+     int k;
+-    double d;
+-
+-#define d0 word0(d)
+-#define d1 word1(d)
++    U d;
++
++#define d0 word0(&d)
++#define d1 word1(&d)
+ 
+     xa0 = a->x;
+@@ -858,8 +858,8 @@
+ #undef d0
+ #undef d1
+-    return dval(d);
++    return dval(&d);
+ }
+ 
+-static Bigint* d2b(double d, int* e, int* bits)
++static Bigint* d2b(U* d, int* e, int* bits)
+ {
+     Bigint* b;
+@@ -966,9 +966,9 @@
+ static double ratio(Bigint* a, Bigint* b)
+ {
+-    double da, db;
++    U 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);
+ #ifdef Pack_32
+     k = ka - kb + 32 * (a->wds - b->wds);
+@@ -977,10 +977,10 @@
+ #endif
+     if (k > 0)
+-        word0(da) += k * Exp_msk1;
++        word0(&da) += k * Exp_msk1;
+     else {
+         k = -k;
+-        word0(db) += k * Exp_msk1;
+-    }
+-    return dval(da) / dval(db);
++        word0(&db) += k * Exp_msk1;
++    }
++    return dval(&da) / dval(&db);
+ }
+ 
+@@ -1032,5 +1032,5 @@
+ 
+ #ifndef No_Hex_NaN
+-static void hexnan(double* rvp, const char** sp)
++static void hexnan(U* rvp, const char** sp)
+ {
+     uint32_t c, x[2];
+@@ -1071,6 +1071,6 @@
+     }
+     if ((x[0] &= 0xfffff) || x[1]) {
+-        word0(*rvp) = Exp_mask | x[0];
+-        word1(*rvp) = x[1];
++        word0(rvp) = Exp_mask | x[0];
++        word1(rvp) = x[1];
+     }
+ }
+@@ -1086,5 +1086,6 @@
+          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, aadj1;
++    U aadj2, adj, rv, rv0;
+     int32_t L;
+     uint32_t y, z;
+@@ -1095,5 +1096,5 @@
+ 
+     sign = nz0 = nz = 0;
+-    dval(rv) = 0.;
++    dval(&rv) = 0;
+     for (s = s00; ; s++)
+         switch (*s) {
+@@ -1210,6 +1211,6 @@
+                         if (!match(&s,"inity"))
+                             ++s;
+-                        word0(rv) = 0x7ff00000;
+-                        word1(rv) = 0;
++                        word0(&rv) = 0x7ff00000;
++                        word1(&rv) = 0;
+                         goto ret;
+                     }
+@@ -1218,6 +1219,6 @@
+                 case 'N':
+                     if (match(&s, "an")) {
+-                        word0(rv) = NAN_WORD0;
+-                        word1(rv) = NAN_WORD1;
++                        word0(&rv) = NAN_WORD0;
++                        word1(&rv) = NAN_WORD1;
+ #ifndef No_Hex_NaN
+                         if (*s == '(') /*)*/
+@@ -1244,5 +1245,5 @@
+         nd0 = nd;
+     k = nd < DBL_DIG + 1 ? nd : DBL_DIG + 1;
+-    dval(rv) = y;
++    dval(&rv) = y;
+     if (k > 9) {
+ #ifdef SET_INEXACT
+@@ -1250,5 +1251,5 @@
+             oldinexact = get_inexact();
+ #endif
+-        dval(rv) = tens[k - 9] * dval(rv) + z;
++        dval(&rv) = tens[k - 9] * dval(&rv) + z;
+     }
+     bd0 = 0;
+@@ -1258,5 +1259,5 @@
+         if (e > 0) {
+             if (e <= Ten_pmax) {
+-                /* rv = */ rounded_product(dval(rv), tens[e]);
++                /* rv = */ rounded_product(dval(&rv), tens[e]);
+                 goto ret;
+             }
+@@ -1267,6 +1268,6 @@
+                  */
+                 e -= i;
+-                dval(rv) *= tens[i];
+-                /* rv = */ rounded_product(dval(rv), tens[e]);
++                dval(&rv) *= tens[i];
++                /* rv = */ rounded_product(dval(&rv), tens[e]);
+                 goto ret;
+             }
+@@ -1274,5 +1275,5 @@
+ #ifndef Inaccurate_Divide
+         else if (e >= -Ten_pmax) {
+-            /* rv = */ rounded_quotient(dval(rv), tens[-e]);
++            /* rv = */ rounded_quotient(dval(&rv), tens[-e]);
+             goto ret;
+         }
+@@ -1294,5 +1295,5 @@
+     if (e1 > 0) {
+         if ((i = e1 & 15))
+-            dval(rv) *= tens[i];
++            dval(&rv) *= tens[i];
+         if (e1 &= ~15) {
+             if (e1 > DBL_MAX_10_EXP) {
+@@ -1302,10 +1303,10 @@
+ #endif
+                 /* Can't trust HUGE_VAL */
+-                word0(rv) = Exp_mask;
+-                word1(rv) = 0;
++                word0(&rv) = Exp_mask;
++                word1(&rv) = 0;
+ #ifdef SET_INEXACT
+                 /* set overflow bit */
+-                dval(rv0) = 1e300;
+-                dval(rv0) *= dval(rv0);
++                dval(&rv0) = 1e300;
++                dval(&rv0) *= dval(&rv0);
+ #endif
+                 if (bd0)
+@@ -1316,22 +1317,22 @@
+             for (j = 0; e1 > 1; j++, e1 >>= 1)
+                 if (e1 & 1)
+-                    dval(rv) *= bigtens[j];
++                    dval(&rv) *= bigtens[j];
+         /* The last multiplication could overflow. */
+-            word0(rv) -= P * Exp_msk1;
+-            dval(rv) *= bigtens[j];
+-            if ((z = word0(rv) & Exp_mask) > Exp_msk1 * (DBL_MAX_EXP + Bias - P))
++            word0(&rv) -= P * Exp_msk1;
++            dval(&rv) *= bigtens[j];
++            if ((z = word0(&rv) & Exp_mask) > Exp_msk1 * (DBL_MAX_EXP + Bias - P))
+                 goto ovfl;
+             if (z > Exp_msk1 * (DBL_MAX_EXP + Bias - 1 - P)) {
+                 /* set to largest number */
+                 /* (Can't trust DBL_MAX) */
+-                word0(rv) = Big0;
+-                word1(rv) = Big1;
++                word0(&rv) = Big0;
++                word1(&rv) = Big1;
+             } else
+-                word0(rv) += P * Exp_msk1;
++                word0(&rv) += P * Exp_msk1;
+         }
+     } else if (e1 < 0) {
+         e1 = -e1;
+         if ((i = e1 & 15))
+-            dval(rv) /= tens[i];
++            dval(&rv) /= tens[i];
+         if (e1 >>= 4) {
+             if (e1 >= 1 << n_bigtens)
+@@ -1342,30 +1343,30 @@
+             for (j = 0; e1 > 0; j++, e1 >>= 1)
+                 if (e1 & 1)
+-                    dval(rv) *= tinytens[j];
+-            if (scale && (j = (2 * P) + 1 - ((word0(rv) & Exp_mask) >> Exp_shift)) > 0) {
++                    dval(&rv) *= tinytens[j];
++            if (scale && (j = (2 * P) + 1 - ((word0(&rv) & Exp_mask) >> Exp_shift)) > 0) {
+                 /* scaled rv is denormal; zap j low bits */
+                 if (j >= 32) {
+-                    word1(rv) = 0;
++                    word1(&rv) = 0;
+                     if (j >= 53)
+-                       word0(rv) = (P + 2) * Exp_msk1;
++                       word0(&rv) = (P + 2) * Exp_msk1;
+                     else
+-                       word0(rv) &= 0xffffffff << (j - 32);
++                       word0(&rv) &= 0xffffffff << (j - 32);
+                 } else
+-                    word1(rv) &= 0xffffffff << j;
++                    word1(&rv) &= 0xffffffff << j;
+             }
+ #else
+             for (j = 0; e1 > 1; j++, e1 >>= 1)
+                 if (e1 & 1)
+-                    dval(rv) *= tinytens[j];
++                    dval(&rv) *= tinytens[j];
+             /* The last multiplication could underflow. */
+-            dval(rv0) = dval(rv);
+-            dval(rv) *= tinytens[j];
+-            if (!dval(rv)) {
+-                dval(rv) = 2. * dval(rv0);
+-                dval(rv) *= tinytens[j];
+-#endif
+-                if (!dval(rv)) {
++            dval(&rv0) = dval(&rv);
++            dval(&rv) *= tinytens[j];
++            if (!dval(&rv)) {
++                dval(&rv) = 2. * dval(&rv0);
++                dval(&rv) *= tinytens[j];
++#endif
++                if (!dval(&rv)) {
+ undfl:
+-                    dval(rv) = 0.;
++                    dval(&rv) = 0.;
+ #ifndef NO_ERRNO
+                     errno = ERANGE;
+@@ -1376,6 +1377,6 @@
+                 }
+ #ifndef Avoid_Underflow
+-                word0(rv) = Tiny0;
+-                word1(rv) = Tiny1;
++                word0(&rv) = Tiny0;
++                word1(&rv) = Tiny1;
+                 /* The refinement below will clean
+                  * this approximation up.
+@@ -1395,5 +1396,5 @@
+         bd = Balloc(bd0->k);
+         Bcopy(bd, bd0);
+-        bb = d2b(dval(rv), &bbe, &bbbits);    /* rv = bb * 2^bbe */
++        bb = d2b(&rv, &bbe, &bbbits);    /* rv = bb * 2^bbe */
+         bs = i2b(1);
+ 
+@@ -1465,9 +1466,9 @@
+              * special case of mantissa a power of two.
+              */
+-            if (dsign || word1(rv) || word0(rv) & Bndry_mask
++            if (dsign || word1(&rv) || word0(&rv) & Bndry_mask
+ #ifdef Avoid_Underflow
+-             || (word0(rv) & Exp_mask) <= (2 * P + 1) * Exp_msk1
+-#else
+-             || (word0(rv) & Exp_mask) <= Exp_msk1
++             || (word0(&rv) & Exp_mask) <= (2 * P + 1) * Exp_msk1
++#else
++             || (word0(&rv) & Exp_mask) <= Exp_msk1
+ #endif
+                 ) {
+@@ -1493,14 +1494,14 @@
+             /* exactly half-way between */
+             if (dsign) {
+-                if ((word0(rv) & Bndry_mask1) == Bndry_mask1
+-                 &&  word1(rv) == (
++                if ((word0(&rv) & Bndry_mask1) == Bndry_mask1
++                 &&  word1(&rv) == (
+ #ifdef Avoid_Underflow
+-            (scale && (y = word0(rv) & Exp_mask) <= 2 * P * Exp_msk1)
++            (scale && (y = word0(&rv) & Exp_mask) <= 2 * P * Exp_msk1)
+         ? (0xffffffff & (0xffffffff << (2 * P + 1 - (y >> Exp_shift)))) :
+ #endif
+                            0xffffffff)) {
+                     /*boundary case -- increment exponent*/
+-                    word0(rv) = (word0(rv) & Exp_mask) + Exp_msk1;
+-                    word1(rv) = 0;
++                    word0(&rv) = (word0(&rv) & Exp_mask) + Exp_msk1;
++                    word1(&rv) = 0;
+ #ifdef Avoid_Underflow
+                     dsign = 0;
+@@ -1508,9 +1509,9 @@
+                     break;
+                 }
+-            } else if (!(word0(rv) & Bndry_mask) && !word1(rv)) {
++            } else if (!(word0(&rv) & Bndry_mask) && !word1(&rv)) {
+ drop_down:
+                 /* boundary case -- decrement exponent */
+ #ifdef Sudden_Underflow /*{{*/
+-                L = word0(rv) & Exp_mask;
++                L = word0(&rv) & Exp_mask;
+ #ifdef Avoid_Underflow
+                 if (L <= (scale ? (2 * P + 1) * Exp_msk1 : Exp_msk1))
+@@ -1523,5 +1524,5 @@
+ #ifdef Avoid_Underflow
+                 if (scale) {
+-                    L = word0(rv) & Exp_mask;
++                    L = word0(&rv) & Exp_mask;
+                     if (L <= (2 * P + 1) * Exp_msk1) {
+                         if (L > (P + 2) * Exp_msk1)
+@@ -1534,18 +1535,18 @@
+                 }
+ #endif /*Avoid_Underflow*/
+-                L = (word0(rv) & Exp_mask) - Exp_msk1;
++                L = (word0(&rv) & Exp_mask) - Exp_msk1;
+ #endif /*Sudden_Underflow}}*/
+-                word0(rv) = L | Bndry_mask1;
+-                word1(rv) = 0xffffffff;
++                word0(&rv) = L | Bndry_mask1;
++                word1(&rv) = 0xffffffff;
+                 break;
+             }
+-            if (!(word1(rv) & LSB))
++            if (!(word1(&rv) & LSB))
+                 break;
+             if (dsign)
+-                dval(rv) += ulp(dval(rv));
++                dval(&rv) += ulp(&rv);
+             else {
+-                dval(rv) -= ulp(dval(rv));
++                dval(&rv) -= ulp(&rv);
+ #ifndef Sudden_Underflow
+-                if (!dval(rv))
++                if (!dval(&rv))
+                     goto undfl;
+ #endif
+@@ -1559,7 +1560,7 @@
+             if (dsign)
+                 aadj = aadj1 = 1.;
+-            else if (word1(rv) || word0(rv) & Bndry_mask) {
++            else if (word1(&rv) || word0(&rv) & Bndry_mask) {
+ #ifndef Sudden_Underflow
+-                if (word1(rv) == Tiny1 && !word0(rv))
++                if (word1(&rv) == Tiny1 && !word0(&rv))
+                     goto undfl;
+ #endif
+@@ -1593,21 +1594,21 @@
+ #endif /*Check_FLT_ROUNDS*/
+         }
+-        y = word0(rv) & Exp_mask;
++        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;
+-            if ((word0(rv) & Exp_mask) >= Exp_msk1 * (DBL_MAX_EXP + Bias - P)) {
+-                if (word0(rv0) == Big0 && word1(rv0) == Big1)
++            dval(&rv0) = dval(&rv);
++            word0(&rv) -= P * Exp_msk1;
++            adj.d = aadj1 * ulp(&rv);
++            dval(&rv) += adj.d;
++            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;
++                word0(&rv) = Big0;
++                word1(&rv) = Big1;
+                 goto cont;
+             } else
+-                word0(rv) += P * Exp_msk1;
++                word0(&rv) += P * Exp_msk1;
+         } else {
+ #ifdef Avoid_Underflow
+@@ -1619,28 +1620,30 @@
+                     aadj1 = dsign ? aadj : -aadj;
+                 }
+-                word0(aadj1) += (2 * P + 1) * Exp_msk1 - y;
+-            }
+-            adj = aadj1 * ulp(dval(rv));
+-            dval(rv) += adj;
++                dval(&aadj2) = aadj1;
++                word0(&aadj2) += (2 * P + 1) * Exp_msk1 - y;
++                aadj1 = dval(&aadj2);
++            }
++            adj.d = aadj1 * ulp(&rv);
++            dval(&rv) += adj.d;
+ #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;
+-                if ((word0(rv) & Exp_mask) <= P * Exp_msk1)
++            if ((word0(&rv) & Exp_mask) <= P * Exp_msk1) {
++                dval(&rv0) = dval(&rv);
++                word0(&rv) += P * Exp_msk1;
++                adj.d = aadj1 * ulp(&rv);
++                dval(&rv) += adj.d;
++                if ((word0(&rv) & Exp_mask) <= P * Exp_msk1)
+                 {
+-                    if (word0(rv0) == Tiny0 && word1(rv0) == Tiny1)
++                    if (word0(&rv0) == Tiny0 && word1(&rv0) == Tiny1)
+                         goto undfl;
+-                    word0(rv) = Tiny0;
+-                    word1(rv) = Tiny1;
++                    word0(&rv) = Tiny0;
++                    word1(&rv) = Tiny1;
+                     goto cont;
+                 }
+                 else
+-                    word0(rv) -= P * Exp_msk1;
++                    word0(&rv) -= P * Exp_msk1;
+             } else {
+-                adj = aadj1 * ulp(dval(rv));
+-                dval(rv) += adj;
++                adj.d = aadj1 * ulp(&rv);
++                dval(&rv) += adj.d;
+             }
+ #else /*Sudden_Underflow*/
+@@ -1657,10 +1660,10 @@
+                     aadj1 = -aadj1;
+             }
+-            adj = aadj1 * ulp(dval(rv));
+-            dval(rv) += adj;
++            adj.d = aadj1 * ulp(&rv);
++            dval(&rv) += adj.d;
+ #endif /*Sudden_Underflow*/
+ #endif /*Avoid_Underflow*/
+         }
+-        z = word0(rv) & Exp_mask;
++        z = word0(&rv) & Exp_mask;
+ #ifndef SET_INEXACT
+ #ifdef Avoid_Underflow
+@@ -1672,5 +1675,5 @@
+             aadj -= L;
+             /* The tolerances below are conservative. */
+-            if (dsign || word1(rv) || word0(rv) & Bndry_mask) {
++            if (dsign || word1(&rv) || word0(&rv) & Bndry_mask) {
+                 if (aadj < .4999999 || aadj > .5000001)
+                     break;
+@@ -1688,7 +1691,7 @@
+     if (inexact) {
+         if (!oldinexact) {
+-            word0(rv0) = Exp_1 + (70 << Exp_shift);
+-            word1(rv0) = 0;
+-            dval(rv0) += 1.;
++            word0(&rv0) = Exp_1 + (70 << Exp_shift);
++            word1(&rv0) = 0;
++            dval(&rv0) += 1.;
+         }
+     } else if (!oldinexact)
+@@ -1697,10 +1700,10 @@
+ #ifdef Avoid_Underflow
+     if (scale) {
+-        word0(rv0) = Exp_1 - 2 * P * Exp_msk1;
+-        word1(rv0) = 0;
+-        dval(rv) *= dval(rv0);
++        word0(&rv0) = Exp_1 - 2 * P * Exp_msk1;
++        word1(&rv0) = 0;
++        dval(&rv) *= dval(&rv0);
+ #ifndef NO_ERRNO
+         /* try to avoid the bug of testing an 8087 register value */
+-        if (word0(rv) == 0 && word1(rv) == 0)
++        if (word0(&rv) == 0 && word1(&rv) == 0)
+             errno = ERANGE;
+ #endif
+@@ -1708,8 +1711,8 @@
+ #endif /* Avoid_Underflow */
+ #ifdef SET_INEXACT
+-    if (inexact && !(word0(rv) & Exp_mask)) {
++    if (inexact && !(word0(&rv) & Exp_mask)) {
+         /* set underflow bit */
+-        dval(rv0) = 1e-300;
+-        dval(rv0) *= dval(rv0);
++        dval(&rv0) = 1e-300;
++        dval(&rv0) *= dval(&rv0);
+     }
+ #endif
+@@ -1723,5 +1726,5 @@
+     if (se)
+         *se = const_cast<char*>(s);
+-    return sign ? -dval(rv) : dval(rv);
++    return sign ? -dval(&rv) : dval(&rv);
+ }
+ 
+@@ -1915,5 +1918,5 @@
+  */
+ 
+-char* dtoa(double d, int ndigits, int* decpt, int* sign, char** rve)
++char* dtoa(double dd, int ndigits, int* decpt, int* sign, char** rve)
+ {
+     /*
+@@ -1935,5 +1938,6 @@
+ #endif
+     Bigint *b, *b1, *delta, *mlo = NULL, *mhi, *S;
+-    double d2, ds, eps;
++    U d2, eps, u;
++    double ds;
+     char *s, *s0;
+ #ifdef SET_INEXACT
+@@ -1948,20 +1952,21 @@
+ #endif
+ 
+-    if (word0(d) & Sign_bit) {
++    u.d = dd;
++    if (word0(&u) & Sign_bit) {
+         /* set sign for everything, including 0's and NaNs */
+         *sign = 1;
+-        word0(d) &= ~Sign_bit;    /* clear sign bit */
++        word0(&u) &= ~Sign_bit;    /* clear sign bit */
+     } else
+         *sign = 0;
+ 
+-    if ((word0(d) & Exp_mask) == Exp_mask)
++    if ((word0(&u) & Exp_mask) == Exp_mask)
+     {
+         /* Infinity or NaN */
+         *decpt = 9999;
+-        if (!word1(d) && !(word0(d) & 0xfffff))
++        if (!word1(&u) && !(word0(&u) & 0xfffff))
+             return nrv_alloc("Infinity", rve, 8);
+         return nrv_alloc("NaN", rve, 3);
+     }
+-    if (!dval(d)) {
++    if (!dval(&u)) {
+         *decpt = 1;
+         return nrv_alloc("0", rve, 1);
+@@ -1973,13 +1978,13 @@
+ #endif
+ 
+-    b = d2b(dval(d), &be, &bbits);
++    b = d2b(&u, &be, &bbits);
+ #ifdef Sudden_Underflow
+-    i = (int)(word0(d) >> Exp_shift1 & (Exp_mask >> Exp_shift1));
+-#else
+-    if ((i = (int)(word0(d) >> Exp_shift1 & (Exp_mask >> Exp_shift1)))) {
+-#endif
+-        dval(d2) = dval(d);
+-        word0(d2) &= Frac_mask1;
+-        word0(d2) |= Exp_11;
++    i = (int)(word0(&u) >> Exp_shift1 & (Exp_mask >> Exp_shift1));
++#else
++    if ((i = (int)(word0(&u) >> Exp_shift1 & (Exp_mask >> Exp_shift1)))) {
++#endif
++        dval(&d2) = dval(&u);
++        word0(&d2) &= Frac_mask1;
++        word0(&d2) |= Exp_11;
+ 
+         /* log(x)    ~=~ log(1.5) + (x-1.5)/1.5
+@@ -2012,13 +2017,13 @@
+ 
+         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(&u) << (64 - i)) | (word1(&u) >> (i - 32))
++                : word1(&u) << (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)
+@@ -2026,5 +2031,5 @@
+     k_check = 1;
+     if (k >= 0 && k <= Ten_pmax) {
+-        if (dval(d) < tens[k])
++        if (dval(&u) < tens[k])
+             k--;
+         k_check = 0;
+@@ -2067,5 +2072,5 @@
+ 
+         i = 0;
+-        dval(d2) = dval(d);
++        dval(&d2) = dval(&u);
+         k0 = k;
+         ilim0 = ilim;
+@@ -2077,5 +2082,5 @@
+                 /* prevent overflows */
+                 j &= Bletch - 1;
+-                dval(d) /= bigtens[n_bigtens - 1];
++                dval(&u) /= bigtens[n_bigtens - 1];
+                 ieps++;
+             }
+@@ -2086,30 +2091,30 @@
+                 }
+             }
+-            dval(d) /= ds;
++            dval(&u) /= ds;
+         } else if ((j1 = -k)) {
+-            dval(d) *= tens[j1 & 0xf];
++            dval(&u) *= tens[j1 & 0xf];
+             for (j = j1 >> 4; j; j >>= 1, i++) {
+                 if (j & 1) {
+                     ieps++;
+-                    dval(d) *= bigtens[i];
++                    dval(&u) *= bigtens[i];
+                 }
+             }
+         }
+-        if (k_check && dval(d) < 1. && ilim > 0) {
++        if (k_check && dval(&u) < 1. && ilim > 0) {
+             if (ilim1 <= 0)
+                 goto fast_failed;
+             ilim = ilim1;
+             k--;
+-            dval(d) *= 10.;
++            dval(&u) *= 10.;
+             ieps++;
+         }
+-        dval(eps) = (ieps * dval(d)) + 7.;
+-        word0(eps) -= (P - 1) * Exp_msk1;
++        dval(&eps) = (ieps * dval(&u)) + 7.;
++        word0(&eps) -= (P - 1) * Exp_msk1;
+         if (ilim == 0) {
+             S = mhi = 0;
+-            dval(d) -= 5.;
+-            if (dval(d) > dval(eps))
++            dval(&u) -= 5.;
++            if (dval(&u) > dval(&eps))
+                 goto one_digit;
+-            if (dval(d) < -dval(eps))
++            if (dval(&u) < -dval(&eps))
+                 goto no_digits;
+             goto fast_failed;
+@@ -2120,31 +2125,31 @@
+              * 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 = (long int)dval(d);
+-                dval(d) -= L;
++                L = (long int)dval(&u);
++                dval(&u) -= L;
+                 *s++ = '0' + (int)L;
+-                if (dval(d) < dval(eps))
++                if (dval(&u) < dval(&eps))
+                     goto ret1;
+-                if (1. - dval(d) < dval(eps))
++                if (1. - dval(&u) < dval(&eps))
+                     goto bump_up;
+                 if (++i >= ilim)
+                     break;
+-                dval(eps) *= 10.;
+-                dval(d) *= 10.;
++                dval(&eps) *= 10.;
++                dval(&u) *= 10.;
+             }
+         } else {
+ #endif
+             /* Generate ilim digits, then fix them up. */
+-            dval(eps) *= tens[ilim - 1];
+-            for (i = 1;; i++, dval(d) *= 10.) {
+-                L = (int32_t)(dval(d));
+-                if (!(dval(d) -= L))
++            dval(&eps) *= tens[ilim - 1];
++            for (i = 1;; i++, dval(&u) *= 10.) {
++                L = (int32_t)(dval(&u));
++                if (!(dval(&u) -= L))
+                     ilim = i;
+                 *s++ = '0' + (int)L;
+                 if (i == ilim) {
+-                    if (dval(d) > 0.5 + dval(eps))
++                    if (dval(&u) > 0.5 + dval(&eps))
+                         goto bump_up;
+-                    else if (dval(d) < 0.5 - dval(eps)) {
++                    else if (dval(&u) < 0.5 - dval(&eps)) {
+                         while (*--s == '0') { }
+                         s++;
+@@ -2159,5 +2164,5 @@
+ fast_failed:
+         s = s0;
+-        dval(d) = dval(d2);
++        dval(&u) = dval(&d2);
+         k = k0;
+         ilim = ilim0;
+@@ -2171,20 +2176,20 @@
+         if (ndigits < 0 && ilim <= 0) {
+             S = mhi = 0;
+-            if (ilim < 0 || dval(d) <= 5 * ds)
++            if (ilim < 0 || dval(&u) <= 5 * ds)
+                 goto no_digits;
+             goto one_digit;
+         }
+-        for (i = 1;; i++, dval(d) *= 10.) {
+-            L = (int32_t)(dval(d) / ds);
+-            dval(d) -= L * ds;
++        for (i = 1;; i++, dval(&u) *= 10.) {
++            L = (int32_t)(dval(&u) / ds);
++            dval(&u) -= L * ds;
+ #ifdef Check_FLT_ROUNDS
+             /* If FLT_ROUNDS == 2, L will usually be high by 1 */
+-            if (dval(d) < 0) {
++            if (dval(&u) < 0) {
+                 L--;
+-                dval(d) += ds;
++                dval(&u) += ds;
+             }
+ #endif
+             *s++ = '0' + (int)L;
+-            if (!dval(d)) {
++            if (!dval(&u)) {
+ #ifdef SET_INEXACT
+                 inexact = 0;
+@@ -2193,6 +2198,6 @@
+             }
+             if (i == ilim) {
+-                dval(d) += dval(d);
+-                if (dval(d) > ds || (dval(d) == ds && (L & 1))) {
++                dval(&u) += dval(&u);
++                if (dval(&u) > ds || (dval(&u) == ds && (L & 1))) {
+ bump_up:
+                     while (*--s == '9')
+@@ -2249,7 +2254,7 @@
+ 
+     spec_case = 0;
+-    if (!word1(d) && !(word0(d) & Bndry_mask)
++    if (!word1(&u) && !(word0(&u) & Bndry_mask)
+ #ifndef Sudden_Underflow
+-     && word0(d) & (Exp_mask & ~Exp_msk1)
++     && word0(&u) & (Exp_mask & ~Exp_msk1)
+ #endif
+             ) {
+@@ -2323,5 +2328,5 @@
+             j1 = delta->sign ? 1 : cmp(b, delta);
+             Bfree(delta);
+-            if (j1 == 0 && !(word1(d) & 1)) {
++            if (j1 == 0 && !(word1(&u) & 1)) {
+                 if (dig == '9')
+                     goto round_9_up;
+@@ -2335,5 +2340,5 @@
+                 goto ret;
+             }
+-            if (j < 0 || (j == 0 && !(word1(d) & 1))) {
++            if (j < 0 || (j == 0 && !(word1(&u) & 1))) {
+                 if (!b->x[0] && b->wds <= 1) {
+ #ifdef SET_INEXACT
+@@ -2422,7 +2427,7 @@
+     if (inexact) {
+         if (!oldinexact) {
+-            word0(d) = Exp_1 + (70 << Exp_shift);
+-            word1(d) = 0;
+-            dval(d) += 1.;
++            word0(&u) = Exp_1 + (70 << Exp_shift);
++            word1(&u) = 0;
++            dval(&u) += 1.;
+         }
+     } else if (!oldinexact)
diff --git a/net-libs/webkit-gtk/webkit-gtk-0_p40220.ebuild b/net-libs/webkit-gtk/webkit-gtk-0_p40220.ebuild
index 6174fc1df321..2972989c1104 100644
--- a/net-libs/webkit-gtk/webkit-gtk-0_p40220.ebuild
+++ b/net-libs/webkit-gtk/webkit-gtk-0_p40220.ebuild
@@ -1,8 +1,8 @@
 # Copyright 1999-2009 Gentoo Foundation
 # Distributed under the terms of the GNU General Public License v2
-# $Header: /var/cvsroot/gentoo-x86/net-libs/webkit-gtk/webkit-gtk-0_p40220.ebuild,v 1.7 2009/03/20 23:26:44 maekke Exp $
+# $Header: /var/cvsroot/gentoo-x86/net-libs/webkit-gtk/webkit-gtk-0_p40220.ebuild,v 1.8 2009/05/07 22:13:15 loki_val Exp $
 
-inherit autotools flag-o-matic
+inherit autotools flag-o-matic eutils
 
 MY_P="WebKit-r${PV/0\_p}"
 DESCRIPTION="Open source web browser engine"
@@ -38,7 +38,7 @@ S="${WORKDIR}/${MY_P}"
 src_unpack() {
 	unpack ${A}
 	cd "${S}"
-
+	epatch "${FILESDIR}/${P}-gcc44-aliasing.patch"
 	eautoreconf
 }
 
diff --git a/net-libs/webkit-gtk/webkit-gtk-0_p42162.ebuild b/net-libs/webkit-gtk/webkit-gtk-0_p42162.ebuild
index c850b458b6ea..82d87d90b9fd 100644
--- a/net-libs/webkit-gtk/webkit-gtk-0_p42162.ebuild
+++ b/net-libs/webkit-gtk/webkit-gtk-0_p42162.ebuild
@@ -1,10 +1,10 @@
 # Copyright 1999-2009 Gentoo Foundation
 # Distributed under the terms of the GNU General Public License v2
-# $Header: /var/cvsroot/gentoo-x86/net-libs/webkit-gtk/webkit-gtk-0_p42162.ebuild,v 1.1 2009/04/05 15:33:05 jokey Exp $
+# $Header: /var/cvsroot/gentoo-x86/net-libs/webkit-gtk/webkit-gtk-0_p42162.ebuild,v 1.2 2009/05/07 22:13:15 loki_val Exp $
 
 EAPI=2
 
-inherit autotools flag-o-matic
+inherit autotools flag-o-matic eutils
 
 MY_P="WebKit-r${PV/0\_p}"
 DESCRIPTION="Open source web browser engine"
@@ -42,6 +42,7 @@ S="${WORKDIR}/${MY_P}"
 src_prepare() {
 	AT_M4DIR=./autotools
 	gtkdocize
+	epatch "${FILESDIR}/${P}-gcc44-aliasing.patch"
 	eautoreconf
 }