Libc-594.9.5.tar.gz

[apple/libc.git] / gdtoa / FreeBSD / _hdtoa.c.patch

diff --git a/gdtoa/FreeBSD/_hdtoa.c.patch b/gdtoa/FreeBSD/_hdtoa.c.patch
index 5b4d7cf0f69521a9d32d39ddaedd6f6b2a85f5eb..69173cdefdd3399d5b18ea19bc286712e352b918 100644 (file)
--- a/gdtoa/FreeBSD/_hdtoa.c.patch
+++ b/gdtoa/FreeBSD/_hdtoa.c.patch
@@ -1,91 +1,82 @@
---- _hdtoa.c.orig      2004-06-03 15:22:08.000000000 -0700
-+++ _hdtoa.c   2004-08-28 17:10:21.000000000 -0700
-@@ -32,6 +32,9 @@
- #include <limits.h>
- #include <math.h>
- #include <stdlib.h>
-+#ifdef LDBL_HEAD_TAIL_PAIR
-+#include <alloca.h>
-+#endif /* LDBL_HEAD_TAIL_PAIR */
- #include "fpmath.h"
- #include "gdtoaimp.h"
+--- _hdtoa.c.orig      2008-09-07 11:38:10.000000000 -0700
++++ _hdtoa.c   2008-09-07 12:49:47.000000000 -0700
+@@ -55,7 +55,7 @@ roundup(char *s0, int ndigits)
+                       *s = 1;
+                       return (1);
+               }
+-              ++*s;
++              *s = 0;
+       }
+       ++*s;
+       return (0);
+@@ -126,12 +126,12 @@ __hdtoa(double d, const char *xdigs, int
+       static const int sigfigs = (DBL_MANT_DIG + 3) / 4;
+       union IEEEd2bits u;
+       char *s, *s0;
+-      int bufsize;
++      int bufsize, f;
+ 
+       u.d = d;
+       *sign = u.bits.sign;
+ 
+-      switch (fpclassify(d)) {
++      switch (f = fpclassify(d)) {
+       case FP_NORMAL:
+               *decpt = u.bits.exp - DBL_ADJ;
+               break;
+@@ -149,7 +149,7 @@ __hdtoa(double d, const char *xdigs, int
+               *decpt = INT_MAX;
+               return (nrv_alloc(NANSTR, rve, sizeof(NANSTR) - 1));
+       default:
+-              abort();
++              LIBC_ABORT("fpclassify returned %d", f);
+       }
+ 
+       /* FP_NORMAL or FP_SUBNORMAL */
+@@ -210,6 +210,7 @@ __hdtoa(double d, const char *xdigs, int
+       return (s0);
+ }

  
  

-@@ -301,16 +304,31 @@
-       int pos;
-       int shift;      /* for subnormals, # of shifts required to normalize */
-       int sigfigs;    /* number of significant hex figures in result */
++#ifndef LDBL_COMPAT
+ #if (LDBL_MANT_DIG > DBL_MANT_DIG)
+ 
+ /*
+@@ -222,13 +223,18 @@ __hldtoa(long double e, const char *xdig
+       static const int sigfigs = (LDBL_MANT_DIG + 3) / 4;
+       union IEEEl2bits u;
+       char *s, *s0;
+-      int bufsize;
++      int bufsize, f;

 +#ifdef LDBL_HEAD_TAIL_PAIR
 +      uint32_t bits[4];
 +#ifdef LDBL_HEAD_TAIL_PAIR
 +      uint32_t bits[4];

-+      int i;
++      int i, pos;

 +#endif /* LDBL_HEAD_TAIL_PAIR */
  
        u.e = e;
        *sign = u.bits.sign;
  
 +#endif /* LDBL_HEAD_TAIL_PAIR */
  
        u.e = e;
        *sign = u.bits.sign;
  

-+#ifdef LDBL_HEAD_TAIL_PAIR
-+      switch (__fpclassifyd(u.d[0])) {
-+#else /* LDBL_HEAD_TAIL_PAIR */
-       switch (fpclassify(e)) {
-+#endif /* LDBL_HEAD_TAIL_PAIR */
+-      switch (fpclassify(e)) {
++      switch (f = fpclassify(e)) {

        case FP_NORMAL:
        case FP_NORMAL:

-+#ifdef LDBL_HEAD_TAIL_PAIR
-               sigfigs = (LDBL_MANT_DIG + 3) / 4;
-               impnbit = 1 << ((LDBL_MANT_DIG - 1) % 4);
-               *decpt = u.bits.exp - LDBL_BIAS + 1 -
-                   ((LDBL_MANT_DIG - 1) % 4);
-+#else /* LDBL_HEAD_TAIL_PAIR */
-+              sigfigs = (LDBL_MANT_DIG + 3) / 4;
-+              impnbit = 1 << ((LDBL_MANT_DIG - 1) % 4);
-+              *decpt = u.bits.exp - LDBL_BIAS + 1 -
-+                  ((LDBL_MANT_DIG - 1) % 4);
-+#endif /* LDBL_HEAD_TAIL_PAIR */
++      case FP_SUPERNORMAL:
+               *decpt = u.bits.exp - LDBL_ADJ;

                break;
        case FP_ZERO:
                break;
        case FP_ZERO:

-               *decpt = 1;
-@@ -328,13 +346,26 @@
-               /* Don't trust the normalization bit to be off. */
-               u.bits.manh &= ~(~0ULL << (LDBL_MANH_SIZE - 1));
- #endif
-+#ifndef LDBL_HEAD_TAIL_PAIR
-               if (u.bits.manh != 0) {
-+#endif /* LDBL_HEAD_TAIL_PAIR */
- #if LDBL_MANH_SIZE > 32
-                       pos = log2_64(u.bits.manh);
- #else
-                       pos = log2_32(u.bits.manh);
- #endif
-                       shift = LDBL_MANH_SIZE - LDBL_NBIT_ADJ - pos;
-+#ifdef LDBL_HEAD_TAIL_PAIR
-+              sigfigs = (3 + LDBL_MANT_DIG - LDBL_NBIT_ADJ - shift) / 4;
-+              // we use DBL_MIN_EXP below because the head double is
-+              // subnormal (and the tail double is zero)
-+              *decpt = DBL_MIN_EXP + LDBL_NBIT_ADJ;
-+              pos = (LDBL_MANT_DIG + 3) % 4;
-+              if (pos < shift)
-+                      *decpt -= pos + ((shift - pos + 3) & ~(4 - 1));
-+              else
-+                      *decpt -= shift;
-+#else /* LDBL_HEAD_TAIL_PAIR */
-               } else {
- #if LDBL_MANL_SIZE > 32
-                       pos = log2_64(u.bits.manl);
-@@ -345,8 +376,9 @@
-                           LDBL_NBIT_ADJ - pos;
-               }
-               sigfigs = (3 + LDBL_MANT_DIG - LDBL_NBIT_ADJ - shift) / 4;
--              *decpt = LDBL_MIN_EXP + LDBL_NBIT_ADJ -
-+              *decpt = DBL_MIN_EXP + LDBL_NBIT_ADJ -
-                   ((shift + 3) & ~(4 - 1));
-+#endif /* LDBL_HEAD_TAIL_PAIR */
-               impnbit = 0;
-               break;
-       case FP_INFINITE:
-@@ -381,6 +413,19 @@
+@@ -245,7 +251,7 @@ __hldtoa(long double e, const char *xdig
+               *decpt = INT_MAX;
+               return (nrv_alloc(NANSTR, rve, sizeof(NANSTR) - 1));
+       default:
+-              abort();
++              LIBC_ABORT("fpclassify returned %d", f);
+       }
+ 
+       /* FP_NORMAL or FP_SUBNORMAL */
+@@ -270,6 +276,19 @@ __hldtoa(long double e, const char *xdig

         */
        for (s = s0 + bufsize - 1; s > s0 + sigfigs - 1; s--)
                *s = 0;
 +#ifdef LDBL_HEAD_TAIL_PAIR
         */
        for (s = s0 + bufsize - 1; s > s0 + sigfigs - 1; s--)
                *s = 0;
 +#ifdef LDBL_HEAD_TAIL_PAIR

-+      _ldbl2array32dd(u, bits);
++      *decpt -= _ldbl2array32dd(u, bits);

 +      i = 0;
 +      pos = 8;
 +      for (; s > s0; s--) {
 +      i = 0;
 +      pos = 8;
 +      for (; s > s0; s--) {


@@ -100,7 +91,7 @@
        for (; s > s0 + sigfigs - (LDBL_MANL_SIZE / 4) - 1 && s > s0; s--) {
                *s = u.bits.manl & 0xf;
                u.bits.manl >>= 4;
        for (; s > s0 + sigfigs - (LDBL_MANL_SIZE / 4) - 1 && s > s0; s--) {
                *s = u.bits.manl & 0xf;
                u.bits.manl >>= 4;

-@@ -389,6 +434,7 @@
+@@ -278,6 +297,7 @@ __hldtoa(long double e, const char *xdig

                *s = u.bits.manh & 0xf;
                u.bits.manh >>= 4;
        }
                *s = u.bits.manh & 0xf;
                u.bits.manh >>= 4;
        }


@@ -108,15 +99,20 @@
  
        /*
         * At this point, we have snarfed all the bits in the
  
        /*
         * At this point, we have snarfed all the bits in the

-@@ -398,7 +444,11 @@
-        * in manl instead for small subnormals.  We also tack on the
-        * implicit normalization bit if appropriate.
+@@ -285,7 +305,11 @@ __hldtoa(long double e, const char *xdig
+        * (partial) nibble, which is dealt with by the next
+        * statement.  We also tack on the implicit normalization bit.

         */
 +#ifdef LDBL_HEAD_TAIL_PAIR
         */
 +#ifdef LDBL_HEAD_TAIL_PAIR

-+      *s = bits[i] | impnbit;
++      *s = bits[i];

 +#else /* LDBL_HEAD_TAIL_PAIR */
 +#else /* LDBL_HEAD_TAIL_PAIR */

-       *s = u.bits.manh | u.bits.manl | impnbit;
+       *s = u.bits.manh | (1U << ((LDBL_MANT_DIG - 1) % 4));

 +#endif /* LDBL_HEAD_TAIL_PAIR */
  
        /* If ndigits < 0, we are expected to auto-size the precision. */
        if (ndigits < 0) {
 +#endif /* LDBL_HEAD_TAIL_PAIR */
  
        /* If ndigits < 0, we are expected to auto-size the precision. */
        if (ndigits < 0) {

+@@ -317,3 +341,4 @@ __hldtoa(long double e, const char *xdig
+ }
+ 
+ #endif        /* (LDBL_MANT_DIG == DBL_MANT_DIG) */
++#endif  /* !LDBL_COMPAT */