re PR fortran/46625 (libquadmath: Mangle internal symbols; rename __float128 <->...

2010-12-13  Tobias Burnus  <burnus@net-b.de>

        PR fortran/46625
        * gdtoa/gdtoaimp.h: Mangle internal functions by
        prefixing them with __quadmath. Don't use gdtoa's strcp(y).
        * gdtoa/g_Qfmt.c (g_Qfmt): Use strcpy instead of strcp.
        * gdtoa/misc.c (strcpy): Renamed from strcp and only use
        if NO_STRING_H is set.
        * quadmath-imp.h (__quadmath_rem_pio2q,
        * __quadmath_kernel_sincosq
        __quadmath_kernel_sinq, __quadmath_kernel_cosq): Added
        __quadmath prefix to internal functions.
        * math/cosq.c (cosq): Ditto.
        * math/sinq.c (cosq): Ditto.
        * math/tanq.c (tanq,__quadmath_kernel_tanq): Ditto.
        * math/rem_pio2q.c (rem_pio2, __quadmath_kernel_rem_pio2):
        * Ditto.
        * math/sinq_kernel.c (__quadmath_kernel_sinq): Ditto.
        * math/cosq_kernel.c (__quadmath_kernel_cosq): Ditto.

From-SVN: r167768

diff --git a/libquadmath/ChangeLog b/libquadmath/ChangeLog
index 8e17d2d5f55ab90874ba1be811c22fdbaec748d4..de3eaa0643475047d3fcf117c63fa2402769fd4e 100644 (file)
--- a/libquadmath/ChangeLog
+++ b/libquadmath/ChangeLog
@@ -1,3 +1,21 @@
+2010-12-13  Tobias Burnus  <burnus@net-b.de>
+
+       PR fortran/46625
+       * gdtoa/gdtoaimp.h: Mangle internal functions by
+       prefixing them with __quadmath. Don't use gdtoa's strcp(y).
+       * gdtoa/g_Qfmt.c (g_Qfmt): Use strcpy instead of strcp.
+       * gdtoa/misc.c (strcpy): Renamed from strcp and only use
+       if NO_STRING_H is set.
+       * quadmath-imp.h (__quadmath_rem_pio2q, __quadmath_kernel_sincosq
+       __quadmath_kernel_sinq, __quadmath_kernel_cosq): Added
+       __quadmath prefix to internal functions.
+       * math/cosq.c (cosq): Ditto.
+       * math/sinq.c (cosq): Ditto.
+       * math/tanq.c (tanq,__quadmath_kernel_tanq): Ditto.
+       * math/rem_pio2q.c (rem_pio2, __quadmath_kernel_rem_pio2): Ditto.
+       * math/sinq_kernel.c (__quadmath_kernel_sinq): Ditto.
+       * math/cosq_kernel.c (__quadmath_kernel_cosq): Ditto.
+
 2010-12-08  Tobias Burnus  <burnus@net-b.de>
 
        PR fortran/46772

diff --git a/libquadmath/gdtoa/g_Qfmt.c b/libquadmath/gdtoa/g_Qfmt.c
index 563fa36bfa5dac2491bf1a3abf463276d1557401..426c598cfc806fcbd9fc5dd146858a2fc7370cad 100644 (file)
--- a/libquadmath/gdtoa/g_Qfmt.c
+++ b/libquadmath/gdtoa/g_Qfmt.c
@@ -82,12 +82,12 @@ g_Qfmt(char *buf, void *V, int ndig, size_t bufsize)
                if (ex == 0x7fff) {
                        /* Infinity or NaN */
                        if (bits[0] | bits[1] | bits[2] | bits[3])
-                               b = strcp(b, "NaN");
+                               b = strcpy(b, "NaN");
                        else {
                                b = buf;
                                if (sign)
                                        *b++ = '-';
-                               b = strcp(b, "Infinity");
+                               b = strcpy(b, "Infinity");
                                }
                        return b;
                        }

diff --git a/libquadmath/gdtoa/gdtoaimp.h b/libquadmath/gdtoa/gdtoaimp.h
index 68438086d74addaed7b6121bf67074f935a419ae..4aa8f78d307263c14fe521fbc708ff67e40c7c56 100644 (file)
--- a/libquadmath/gdtoa/gdtoaimp.h
+++ b/libquadmath/gdtoa/gdtoaimp.h
@@ -472,51 +472,54 @@ extern void memcpy_D2A ANSI((void*, const void*, size_t));
 #define Bcopy(x,y) memcpy(&x->sign,&y->sign,y->wds*sizeof(ULong) + 2*sizeof(int))
 #endif /* NO_STRING_H */
 
-#define Balloc Balloc_D2A
-#define Bfree Bfree_D2A
-#define ULtoQ ULtoQ_D2A
-#define ULtof ULtof_D2A
-#define ULtod ULtod_D2A
-#define ULtodd ULtodd_D2A
-#define ULtox ULtox_D2A
-#define ULtoxL ULtoxL_D2A
-#define any_on any_on_D2A
-#define b2d b2d_D2A
-#define bigtens bigtens_D2A
-#define cmp cmp_D2A
-#define copybits copybits_D2A
-#define d2b d2b_D2A
-#define decrement decrement_D2A
-#define diff diff_D2A
-#define dtoa_result dtoa_result_D2A
-#define g__fmt g__fmt_D2A
-#define gethex gethex_D2A
-#define hexdig hexdig_D2A
-#define hexnan hexnan_D2A
-#define hi0bits(x) hi0bits_D2A((ULong)(x))
-#define i2b i2b_D2A
-#define increment increment_D2A
-#define lo0bits lo0bits_D2A
-#define lshift lshift_D2A
-#define match match_D2A
-#define mult mult_D2A
-#define multadd multadd_D2A
-#define nrv_alloc nrv_alloc_D2A
-#define pow5mult pow5mult_D2A
-#define quorem quorem_D2A
-#define ratio ratio_D2A
-#define rshift rshift_D2A
-#define rv_alloc rv_alloc_D2A
-#define s2b s2b_D2A
-#define set_ones set_ones_D2A
-#define strcp strcp_D2A
-#define strtoIg strtoIg_D2A
-#define sum sum_D2A
-#define tens tens_D2A
-#define tinytens tinytens_D2A
-#define tinytens tinytens_D2A
-#define trailz trailz_D2A
-#define ulp ulp_D2A
+#define Balloc __quadmath_Balloc_D2A
+#define Bfree __quadmath_Bfree_D2A
+#define ULtoQ __quadmath_ULtoQ_D2A
+#define ULtof __quadmath_ULtof_D2A
+#define ULtod __quadmath_ULtod_D2A
+#define ULtodd __quadmath_ULtodd_D2A
+#define ULtox __quadmath_ULtox_D2A
+#define ULtoxL __quadmath_ULtoxL_D2A
+#define any_on __quadmath_any_on_D2A
+#define b2d __quadmath_b2d_D2A
+#define bigtens __quadmath_bigtens_D2A
+#define cmp __quadmath_cmp_D2A
+#define copybits __quadmath_copybits_D2A
+#define d2b __quadmath_d2b_D2A
+#define decrement __quadmath_decrement_D2A
+#define diff __quadmath_diff_D2A
+#define dtoa_result __quadmath_dtoa_result_D2A
+#define g__fmt __quadmath_g__fmt_D2A
+#define gethex __quadmath_gethex_D2A
+#define hexdig __quadmath_hexdig_D2A
+#define hexnan __quadmath_hexnan_D2A
+#define hi0bits_D2A __quadmath_hi0bits_D2A
+#define hi0bits(x) __quadmath_hi0bits_D2A((ULong)(x))
+#define i2b __quadmath_i2b_D2A
+#define increment __quadmath_increment_D2A
+#define lo0bits __quadmath_lo0bits_D2A
+#define lshift __quadmath_lshift_D2A
+#define match __quadmath_match_D2A
+#define mult __quadmath_mult_D2A
+#define multadd __quadmath_multadd_D2A
+#define nrv_alloc __quadmath_nrv_alloc_D2A
+#define pow5mult __quadmath_pow5mult_D2A
+#define quorem __quadmath_quorem_D2A
+#define ratio __quadmath_ratio_D2A
+#define rshift __quadmath_rshift_D2A
+#define rv_alloc __quadmath_rv_alloc_D2A
+#define s2b __quadmath_s2b_D2A
+#define set_ones __quadmath_set_ones_D2A
+#ifdef NO_STRING_H
+#define strcp __quadmath_strcp_D2A
+#endif
+#define strtoIg __quadmath_strtoIg_D2A
+#define sum __quadmath_sum_D2A
+#define tens __quadmath_tens_D2A
+#define tinytens __quadmath_tinytens_D2A
+#define tinytens __quadmath_tinytens_D2A
+#define trailz __quadmath_trailz_D2A
+#define ulp __quadmath_ulp_D2A
 
  extern char *dtoa_result;
  extern CONST double bigtens[], tens[], tinytens[];
@@ -559,7 +562,9 @@ extern void memcpy_D2A ANSI((void*, const void*, size_t));
  extern char *rv_alloc ANSI((int));
  extern Bigint *s2b ANSI((CONST char*, int, int, ULong, int));
  extern Bigint *set_ones ANSI((Bigint*, int));
- extern char *strcp ANSI((char*, const char*));
+#ifdef NO_STRING_H
+ extern char *strcpy ANSI((char*, const char*));
+#endif
  extern int strtoIg ANSI((CONST char*, char**, FPI*, Long*, Bigint**, int*));
  extern Bigint *sum ANSI((Bigint*, Bigint*));
  extern int trailz ANSI((Bigint*));

diff --git a/libquadmath/gdtoa/misc.c b/libquadmath/gdtoa/misc.c
index e5f7b046b2e87bdffae3adbf6c19a9b33125f4ce..ed81c470fbaf88414e32257d5f6d1661d7bd36c8 100644 (file)
--- a/libquadmath/gdtoa/misc.c
+++ b/libquadmath/gdtoa/misc.c
@@ -844,11 +844,12 @@ tens[] = {
 #endif
                };
 
+#ifdef NO_STRING_H
  char *
 #ifdef KR_headers
-strcp_D2A(a, b) char *a; char *b;
+strcpy_D2A(a, b) char *a; char *b;
 #else
-strcp_D2A(char *a, CONST char *b)
+strcpy_D2A(char *a, CONST char *b)
 #endif
 {
        while((*a = *b++))
@@ -856,7 +857,6 @@ strcp_D2A(char *a, CONST char *b)
        return a;
        }
 
-#ifdef NO_STRING_H
 
  Char *
 #ifdef KR_headers

diff --git a/libquadmath/math/cosq.c b/libquadmath/math/cosq.c
index fff0861d652b1be4f40c30615c8a4b558da24005..16955511e04cec4a5dac42319ca0257965e704cd 100644 (file)
--- a/libquadmath/math/cosq.c
+++ b/libquadmath/math/cosq.c
@@ -58,7 +58,7 @@ cosq (__float128 x)
     /* |x| ~< pi/4 */
        ix &= 0x7fffffffffffffffLL;
        if(ix <= 0x3ffe921fb54442d1LL)
-         return __kernel_cosq(x,z);
+         return __quadmath_kernel_cosq(x,z);
 
     /* cos(Inf or NaN) is NaN */
        else if (ix>=0x7fff000000000000LL) {
@@ -70,13 +70,13 @@ cosq (__float128 x)
 
     /* argument reduction needed */
        else {
-           n = rem_pio2q(x,y);
+           n = __quadmath_rem_pio2q(x,y);
            switch(n&3) {
-               case 0: return  __kernel_cosq(y[0],y[1]);
-               case 1: return -__kernel_sinq(y[0],y[1],1);
-               case 2: return -__kernel_cosq(y[0],y[1]);
+               case 0: return  __quadmath_kernel_cosq(y[0],y[1]);
+               case 1: return -__quadmath_kernel_sinq(y[0],y[1],1);
+               case 2: return -__quadmath_kernel_cosq(y[0],y[1]);
                default:
-                       return  __kernel_sinq(y[0],y[1],1);
+                       return  __quadmath_kernel_sinq(y[0],y[1],1);
            }
        }
 }

diff --git a/libquadmath/math/cosq_kernel.c b/libquadmath/math/cosq_kernel.c
index b310dc0ef32e7433d20e28c646f4bca5ce127328..86f39551c3232d509f9950248a2f8af570a035e0 100644 (file)
--- a/libquadmath/math/cosq_kernel.c
+++ b/libquadmath/math/cosq_kernel.c
@@ -77,7 +77,7 @@ static const __float128 c[] = {
 extern const __float128 __sincosq_table[];
 
 __float128
-__kernel_cosq (__float128 x, __float128 y)
+__quadmath_kernel_cosq (__float128 x, __float128 y)
 {
   __float128 h, l, z, sin_l, cos_l_m1;
   int64_t ix;

diff --git a/libquadmath/math/rem_pio2q.c b/libquadmath/math/rem_pio2q.c
index db0059dd1860ec9862cc746c2f5d03eca542869f..a1c0b831ddbd9bef788e9d8efedc82dc32b61fc0 100644 (file)
--- a/libquadmath/math/rem_pio2q.c
+++ b/libquadmath/math/rem_pio2q.c
@@ -151,7 +151,7 @@ static const double
 
 
 static int
-__kernel_rem_pio2 (double *x, double *y, int e0, int nx, int prec, const int32_t *ipio2)
+__quadmath_kernel_rem_pio2 (double *x, double *y, int e0, int nx, int prec, const int32_t *ipio2)
 {
        int32_t jz,jx,jv,jp,jk,carry,n,iq[20],i,j,k,m,q0,ih;
        double z,fw,f[20],fq[20],q[20];
@@ -500,7 +500,7 @@ static const __float128 c[] = {
 
 
 int32_t
-rem_pio2q (__float128 x, __float128 *y)
+__quadmath_rem_pio2q (__float128 x, __float128 *y)
 {
   __float128 z, w, t;
   double tx[8];
@@ -557,8 +557,9 @@ rem_pio2q (__float128 x, __float128 *y)
   tx [3] = (double)((lx >> 17) & 0xffffff);
   tx [4] = (double)((lx << 7) & 0xffffff);
 
-  n = __kernel_rem_pio2 (tx, tx + 5, exp, ((lx << 7) & 0xffffff) ? 5 : 4,
-                        3, two_over_pi);
+  n = __quadmath_kernel_rem_pio2 (tx, tx + 5, exp,
+                                 ((lx << 7) & 0xffffff) ? 5 : 4,
+                                 3, two_over_pi);
 
   /* The result is now stored in 3 double values, we need to convert it into
      two __float128 values.  */

diff --git a/libquadmath/math/sincosq.c b/libquadmath/math/sincosq.c
index a9f41fc99c8181ddc7958a2b595b3ac140ce7f77..b7c221486d7f60e7e418d1f6af44e21c5e722e92 100644 (file)
--- a/libquadmath/math/sincosq.c
+++ b/libquadmath/math/sincosq.c
@@ -32,7 +32,7 @@ sincosq (__float128 x, __float128 *sinx, __float128 *cosx)
   /* |x| ~< pi/4 */
   ix &= 0x7fffffffffffffffLL;
   if (ix <= 0x3ffe921fb54442d1LL)
-    __kernel_sincosq (x, 0.0Q, sinx, cosx, 0);
+    __quadmath_kernel_sincosq (x, 0.0Q, sinx, cosx, 0);
   else if (ix >= 0x7fff000000000000LL)
     {
       /* sin(Inf or NaN) is NaN */
@@ -44,23 +44,23 @@ sincosq (__float128 x, __float128 *sinx, __float128 *cosx)
       __float128 y[2];
       int n;
 
-      n = rem_pio2q (x, y);
+      n = __quadmath_rem_pio2q (x, y);
       switch (n & 3)
        {
        case 0:
-         __kernel_sincosq (y[0], y[1], sinx, cosx, 1);
+         __quadmath_kernel_sincosq (y[0], y[1], sinx, cosx, 1);
          break;
        case 1:
-         __kernel_sincosq (y[0], y[1], cosx, sinx, 1);
+         __quadmath_kernel_sincosq (y[0], y[1], cosx, sinx, 1);
          *cosx = -*cosx;
          break;
        case 2:
-         __kernel_sincosq (y[0], y[1], sinx, cosx, 1);
+         __quadmath_kernel_sincosq (y[0], y[1], sinx, cosx, 1);
          *sinx = -*sinx;
          *cosx = -*cosx;
          break;
        default:
-         __kernel_sincosq (y[0], y[1], cosx, sinx, 1);
+         __quadmath_kernel_sincosq (y[0], y[1], cosx, sinx, 1);
          *sinx = -*sinx;
          break;
        }

diff --git a/libquadmath/math/sincosq_kernel.c b/libquadmath/math/sincosq_kernel.c
index 64ccaf83fca6b3156f168542fdfbf3786a8ec8f7..578d1828f754cd8920ea7c1cdb24266f0f56bfde 100644 (file)
--- a/libquadmath/math/sincosq_kernel.c
+++ b/libquadmath/math/sincosq_kernel.c
@@ -96,7 +96,8 @@ static const __float128 c[] = {
 extern const __float128 __sincosq_table[];
 
 void
-__kernel_sincosq(__float128 x, __float128 y, __float128 *sinx, __float128 *cosx, int iy)
+__quadmath_kernel_sincosq(__float128 x, __float128 y, __float128 *sinx,
+                         __float128 *cosx, int iy)
 {
   __float128 h, l, z, sin_l, cos_l_m1;
   int64_t ix;

diff --git a/libquadmath/math/sinq.c b/libquadmath/math/sinq.c
index 2d573e42409a8f2e21c6b9d7bbe55a9de3e9ef80..76254a373020464ec2eb8a42b021c43531e18215 100644 (file)
--- a/libquadmath/math/sinq.c
+++ b/libquadmath/math/sinq.c
@@ -58,7 +58,7 @@ sinq (__float128 x)
     /* |x| ~< pi/4 */
        ix &= 0x7fffffffffffffffLL;
        if(ix <= 0x3ffe921fb54442d1LL)
-         return __kernel_sinq(x,z,0);
+         return __quadmath_kernel_sinq(x,z,0);
 
     /* sin(Inf or NaN) is NaN */
        else if (ix>=0x7fff000000000000LL) {
@@ -70,13 +70,13 @@ sinq (__float128 x)
 
     /* argument reduction needed */
        else {
-           n = rem_pio2q(x,y);
+           n = __quadmath_rem_pio2q(x,y);
            switch(n&3) {
-               case 0: return  __kernel_sinq(y[0],y[1],1);
-               case 1: return  __kernel_cosq(y[0],y[1]);
-               case 2: return -__kernel_sinq(y[0],y[1],1);
+               case 0: return  __quadmath_kernel_sinq(y[0],y[1],1);
+               case 1: return  __quadmath_kernel_cosq(y[0],y[1]);
+               case 2: return -__quadmath_kernel_sinq(y[0],y[1],1);
                default:
-                       return -__kernel_cosq(y[0],y[1]);
+                       return -__quadmath_kernel_cosq(y[0],y[1]);
            }
        }
 }

diff --git a/libquadmath/math/sinq_kernel.c b/libquadmath/math/sinq_kernel.c
index fdfe4e80599d97ef51086c861b8fc14d47b12e1e..395fcaba9cb4d1dbef532764bb9d0391aa2a6e21 100644 (file)
--- a/libquadmath/math/sinq_kernel.c
+++ b/libquadmath/math/sinq_kernel.c
@@ -77,7 +77,7 @@ static const __float128 c[] = {
 extern const __float128 __sincosq_table[];
 
 __float128
-__kernel_sinq (__float128 x, __float128 y, int iy)
+__quadmath_kernel_sinq (__float128 x, __float128 y, int iy)
 {
   __float128 h, l, z, sin_l, cos_l_m1;
   int64_t ix;

diff --git a/libquadmath/math/tanq.c b/libquadmath/math/tanq.c
index c490c6a3025e7070909698725c0c7d393987d05a..e1ec6aae86c1cfed2f75a12e36d99fdacd50734e 100644 (file)
--- a/libquadmath/math/tanq.c
+++ b/libquadmath/math/tanq.c
@@ -31,7 +31,7 @@
     License along with this library; if not, write to the Free Software
     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA */
 
-/* __kernel_tanq( x, y, k )
+/* __quadmath_kernel_tanq( x, y, k )
  * kernel tan function on [-pi/4, pi/4], pi/4 ~ 0.7854
  * Input x is assumed to be bounded by ~pi/4 in magnitude.
  * Input y is the tail of x.
@@ -84,7 +84,7 @@ static const __float128
 
 
 static __float128
-__kernel_tanq (__float128 x, __float128 y, int iy)
+__quadmath_kernel_tanq (__float128 x, __float128 y, int iy)
 {
   __float128 z, r, v, w, s;
   int32_t ix, sign = 1;
@@ -218,7 +218,7 @@ tanq (__float128 x)
 
     /* |x| ~< pi/4 */
        ix &= 0x7fffffffffffffffLL;
-       if(ix <= 0x3ffe921fb54442d1LL) return __kernel_tanq(x,z,1);
+       if(ix <= 0x3ffe921fb54442d1LL) return __quadmath_kernel_tanq(x,z,1);
 
     /* tanl(Inf or NaN) is NaN */
        else if (ix>=0x7fff000000000000LL) {
@@ -230,8 +230,8 @@ tanq (__float128 x)
 
     /* argument reduction needed */
        else {
-           n = rem_pio2q(x,y);
-           return __kernel_tanq(y[0],y[1],1-((n&1)<<1)); /*   1 -- n even
-                                                       -1 -- n odd */
+           n = __quadmath_rem_pio2q(x,y);
+                                       /*   1 -- n even, -1 -- n odd */
+           return __quadmath_kernel_tanq(y[0],y[1],1-((n&1)<<1));
        }
 }

diff --git a/libquadmath/quadmath-imp.h b/libquadmath/quadmath-imp.h
index 5544fabca19be5a8d2d96d94b0d275609626561d..e297529a1e693d24d606162f5f0fcde5d3a0e396 100644 (file)
--- a/libquadmath/quadmath-imp.h
+++ b/libquadmath/quadmath-imp.h
@@ -27,10 +27,11 @@ Boston, MA 02110-1301, USA.  */
 
 
 // Prototypes for internal functions
-extern int32_t rem_pio2q (__float128, __float128 *);
-extern void __kernel_sincosq (__float128, __float128, __float128 *, __float128 *, int);
-extern __float128 __kernel_sinq (__float128, __float128, int);
-extern __float128 __kernel_cosq (__float128, __float128);
+extern int32_t __quadmath_rem_pio2q (__float128, __float128 *);
+extern void __quadmath_kernel_sincosq (__float128, __float128, __float128 *,
+                                      __float128 *, int);
+extern __float128 __quadmath_kernel_sinq (__float128, __float128, int);
+extern __float128 __quadmath_kernel_cosq (__float128, __float128);