Hello!
Attached (mostly mechanical) patch uses equivalent built-in functions
for fabsq, copysignq and nanq. The patch allows more aggressive
compiler optimizations, where for fabsq and copysignq, the compiler
will emit 128bit SSE bitops, and a 128bit constant load instead of
nanq function call.
The patch also improves detection of required builtins, so for ia64,
additional patch [1] is needed.
2016-06-12 Uros Bizjak <ubiz...@gmail.com>
* configure.ac (__float128 support): Also test _builtin_fabsq,
__builtin_copysignq, __builtin_infq and __builtin_nanq.
* configure: Regenerate.
* math/*.c: Use __builtin_fabsq instead of fabsq, __builtin_copysignq
instead of copysignq, __builtin_infq instead of __builtin_inf and
__builtin_nanq instead of nanq.
Patch was bootstrapped and regression tested on x86_64-linux-gnu
{,-m32}. I have also checked, that no fabsq, copysignq or nanq calls
remain in the library.
OK for mainline?
[1] https://gcc.gnu.org/ml/gcc-patches/2016-06/msg00888.html
Uros.
Index: configure
===================================================================
--- configure (revision 237340)
+++ configure (working copy)
@@ -8513,7 +8513,7 @@ _LT_EOF
if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then
export_symbols_cmds='$NM -Bpg $libobjs $convenience | awk '\''{ if
(((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) &&
(substr(\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
else
- export_symbols_cmds='$NM -BCpg $libobjs $convenience | awk '\''{ if
(((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && (substr(\$ 3,1,1) !=
".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
+ export_symbols_cmds='$NM -BCpg $libobjs $convenience | awk '\''{ if
(((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "L")) &&
(substr(\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
fi
aix_use_runtimelinking=no
@@ -12514,29 +12514,53 @@ else
typedef _Complex float __attribute__((mode(TC))) __complex128;
- __float128 foo (__float128 x)
+ __float128 test_cplx (__float128 x)
{
- __complex128 z1, z2;
+ __complex128 z1, z2;
- z1 = x;
- z2 = x / 7.Q;
- z2 /= z1;
+ z1 = x;
+ z2 = x / 7.Q;
+ z2 /= z1;
- return (__float128) z2;
+ return (__float128) z2;
}
- __float128 bar (__float128 x)
+ __float128 test_fabs (__float128 x)
{
+ return __builtin_fabsq (x);
+ }
+
+ __float128 test_copysign (__float128 x, __float128 y)
+ {
+ return __builtin_copysignq (x, y);
+ }
+
+ __float128 test_huge_val (__float128 x)
+ {
return x * __builtin_huge_valq ();
}
+ __float128 test_inf (__float128 x)
+ {
+ return x * __builtin_infq ();
+ }
+
+ __float128 test_nan (__float128 x)
+ {
+ return x * __builtin_nanq ("");
+ }
+
int
main ()
{
- foo (1.2Q);
- bar (1.2Q);
+ test_cplx (1.2Q);
+ test_fabs (1.2Q);
+ test_copysign (1.2Q, -1.2Q);
+ test_huge_val (1.2Q);
+ test_inf (1.2Q);
+ test_nan (1.2Q);
;
return 0;
@@ -12561,29 +12585,53 @@ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
typedef _Complex float __attribute__((mode(TC))) __complex128;
- __float128 foo (__float128 x)
+ __float128 test_cplx (__float128 x)
{
- __complex128 z1, z2;
+ __complex128 z1, z2;
- z1 = x;
- z2 = x / 7.Q;
- z2 /= z1;
+ z1 = x;
+ z2 = x / 7.Q;
+ z2 /= z1;
- return (__float128) z2;
+ return (__float128) z2;
}
- __float128 bar (__float128 x)
+ __float128 test_fabs (__float128 x)
{
+ return __builtin_fabsq (x);
+ }
+
+ __float128 test_copysign (__float128 x, __float128 y)
+ {
+ return __builtin_copysignq (x, y);
+ }
+
+ __float128 test_huge_val (__float128 x)
+ {
return x * __builtin_huge_valq ();
}
+ __float128 test_inf (__float128 x)
+ {
+ return x * __builtin_infq ();
+ }
+
+ __float128 test_nan (__float128 x)
+ {
+ return x * __builtin_nanq ("");
+ }
+
int
main ()
{
- foo (1.2Q);
- bar (1.2Q);
+ test_cplx (1.2Q);
+ test_fabs (1.2Q);
+ test_copysign (1.2Q, -1.2Q);
+ test_huge_val (1.2Q);
+ test_inf (1.2Q);
+ test_nan (1.2Q);
;
return 0;
Index: configure.ac
===================================================================
--- configure.ac (revision 237340)
+++ configure.ac (working copy)
@@ -212,25 +212,49 @@ AC_CACHE_CHECK([whether __float128 is supported],
[GCC_TRY_COMPILE_OR_LINK([
typedef _Complex float __attribute__((mode(TC))) __complex128;
- __float128 foo (__float128 x)
+ __float128 test_cplx (__float128 x)
{
- __complex128 z1, z2;
+ __complex128 z1, z2;
- z1 = x;
- z2 = x / 7.Q;
- z2 /= z1;
+ z1 = x;
+ z2 = x / 7.Q;
+ z2 /= z1;
- return (__float128) z2;
+ return (__float128) z2;
}
- __float128 bar (__float128 x)
+ __float128 test_fabs (__float128 x)
{
+ return __builtin_fabsq (x);
+ }
+
+ __float128 test_copysign (__float128 x, __float128 y)
+ {
+ return __builtin_copysignq (x, y);
+ }
+
+ __float128 test_huge_val (__float128 x)
+ {
return x * __builtin_huge_valq ();
}
+
+ __float128 test_inf (__float128 x)
+ {
+ return x * __builtin_infq ();
+ }
+
+ __float128 test_nan (__float128 x)
+ {
+ return x * __builtin_nanq ("");
+ }
],[
- foo (1.2Q);
- bar (1.2Q);
+ test_cplx (1.2Q);
+ test_fabs (1.2Q);
+ test_copysign (1.2Q, -1.2Q);
+ test_huge_val (1.2Q);
+ test_inf (1.2Q);
+ test_nan (1.2Q);
],[
libquad_cv_have_float128=yes
],[
Index: math/atan2q.c
===================================================================
--- math/atan2q.c (revision 237340)
+++ math/atan2q.c (working copy)
@@ -104,7 +104,7 @@ atan2q (__float128 y, __float128 x)
k = (iy-ix)>>48;
if(k > 120) z=pi_o_2+0.5Q*pi_lo; /* |y/x| > 2**120 */
else if(hx<0&&k<-120) z=0.0Q; /* |y|/x < -2**120 */
- else z=atanq(fabsq(y/x)); /* safe to do y/x */
+ else z=atanq(__builtin_fabsq(y/x)); /* safe to do y/x */
switch (m) {
case 0: return z ; /* atan(+,+) */
case 1: {
Index: math/cacoshq.c
===================================================================
--- math/cacoshq.c (revision 237340)
+++ math/cacoshq.c (working copy)
@@ -35,9 +35,9 @@ cacoshq (__complex128 x)
__real__ res = HUGE_VALQ;
if (rcls == QUADFP_NAN)
- __imag__ res = nanq ("");
+ __imag__ res = __builtin_nanq ("");
else
- __imag__ res = copysignq ((rcls == QUADFP_INFINITE
+ __imag__ res = __builtin_copysignq ((rcls == QUADFP_INFINITE
? (__real__ x < 0.0
? M_PIq - M_PI_4q : M_PI_4q)
: M_PI_2q), __imag__ x);
@@ -47,24 +47,24 @@ cacoshq (__complex128 x)
__real__ res = HUGE_VALQ;
if (icls >= QUADFP_ZERO)
- __imag__ res = copysignq (signbitq (__real__ x) ? M_PIq : 0.0,
+ __imag__ res = __builtin_copysignq (signbitq (__real__ x) ? M_PIq :
0.0,
__imag__ x);
else
- __imag__ res = nanq ("");
+ __imag__ res = __builtin_nanq ("");
}
else
{
- __real__ res = nanq ("");
- __imag__ res = nanq ("");
+ __real__ res = __builtin_nanq ("");
+ __imag__ res = __builtin_nanq ("");
}
}
else if (rcls == QUADFP_ZERO && icls == QUADFP_ZERO)
{
__real__ res = 0.0;
- __imag__ res = copysignq (M_PI_2q, __imag__ x);
+ __imag__ res = __builtin_copysignq (M_PI_2q, __imag__ x);
}
/* The factor 16 is just a guess. */
- else if (16.0Q * fabsq (__imag__ x) < fabsq (__real__ x))
+ else if (16.0Q * __builtin_fabsq (__imag__ x) < __builtin_fabsq (__real__ x))
{
/* Kahan's formula which avoid cancellation through subtraction in
some cases. */
Index: math/casinhq.c
===================================================================
--- math/casinhq.c (revision 237340)
+++ math/casinhq.c (working copy)
@@ -32,12 +32,12 @@ casinhq (__complex128 x)
{
if (icls == QUADFP_INFINITE)
{
- __real__ res = copysignq (HUGE_VALQ, __real__ x);
+ __real__ res = __builtin_copysignq (HUGE_VALQ, __real__ x);
if (rcls == QUADFP_NAN)
- __imag__ res = nanq ("");
+ __imag__ res = __builtin_nanq ("");
else
- __imag__ res = copysignq (rcls >= QUADFP_ZERO ? M_PI_2q : M_PI_4q,
+ __imag__ res = __builtin_copysignq (rcls >= QUADFP_ZERO ? M_PI_2q :
M_PI_4q,
__imag__ x);
}
else if (rcls <= QUADFP_INFINITE)
@@ -45,14 +45,14 @@ casinhq (__complex128 x)
__real__ res = __real__ x;
if ((rcls == QUADFP_INFINITE && icls >= QUADFP_ZERO)
|| (rcls == QUADFP_NAN && icls == QUADFP_ZERO))
- __imag__ res = copysignq (0.0, __imag__ x);
+ __imag__ res = __builtin_copysignq (0.0, __imag__ x);
else
- __imag__ res = nanq ("");
+ __imag__ res = __builtin_nanq ("");
}
else
{
- __real__ res = nanq ("");
- __imag__ res = nanq ("");
+ __real__ res = __builtin_nanq ("");
+ __imag__ res = __builtin_nanq ("");
}
}
else if (rcls == QUADFP_ZERO && icls == QUADFP_ZERO)
@@ -75,8 +75,8 @@ casinhq (__complex128 x)
/* Ensure zeros have correct sign and results are correct if
very close to branch cuts. */
- __real__ res = copysignq (__real__ res, __real__ x);
- __imag__ res = copysignq (__imag__ res, __imag__ x);
+ __real__ res = __builtin_copysignq (__real__ res, __real__ x);
+ __imag__ res = __builtin_copysignq (__imag__ res, __imag__ x);
}
return res;
Index: math/casinq.c
===================================================================
--- math/casinq.c (revision 237340)
+++ math/casinq.c (working copy)
@@ -34,13 +34,13 @@ casinq (__complex128 x)
}
else if (isinfq (__real__ x) || isinfq (__imag__ x))
{
- __real__ res = nanq ("");
- __imag__ res = copysignq (HUGE_VALQ, __imag__ x);
+ __real__ res = __builtin_nanq ("");
+ __imag__ res = __builtin_copysignq (HUGE_VALQ, __imag__ x);
}
else
{
- __real__ res = nanq ("");
- __imag__ res = nanq ("");
+ __real__ res = __builtin_nanq ("");
+ __imag__ res = __builtin_nanq ("");
}
}
else
Index: math/catanhq.c
===================================================================
--- math/catanhq.c (revision 237340)
+++ math/catanhq.c (working copy)
@@ -32,21 +32,21 @@ catanhq (__complex128 x)
{
if (icls == QUADFP_INFINITE)
{
- __real__ res = copysignq (0.0, __real__ x);
- __imag__ res = copysignq (M_PI_2q, __imag__ x);
+ __real__ res = __builtin_copysignq (0.0, __real__ x);
+ __imag__ res = __builtin_copysignq (M_PI_2q, __imag__ x);
}
else if (rcls == QUADFP_INFINITE || rcls == QUADFP_ZERO)
{
- __real__ res = copysignq (0.0, __real__ x);
+ __real__ res = __builtin_copysignq (0.0, __real__ x);
if (icls >= QUADFP_ZERO)
- __imag__ res = copysignq (M_PI_2q, __imag__ x);
+ __imag__ res = __builtin_copysignq (M_PI_2q, __imag__ x);
else
- __imag__ res = nanq ("");
+ __imag__ res = __builtin_nanq ("");
}
else
{
- __real__ res = nanq ("");
- __imag__ res = nanq ("");
+ __real__ res = __builtin_nanq ("");
+ __imag__ res = __builtin_nanq ("");
}
}
else if (rcls == QUADFP_ZERO && icls == QUADFP_ZERO)
Index: math/catanq.c
===================================================================
--- math/catanq.c (revision 237340)
+++ math/catanq.c (working copy)
@@ -32,26 +32,26 @@ catanq (__complex128 x)
{
if (rcls == QUADFP_INFINITE)
{
- __real__ res = copysignq (M_PI_2q, __real__ x);
- __imag__ res = copysignq (0.0, __imag__ x);
+ __real__ res = __builtin_copysignq (M_PI_2q, __real__ x);
+ __imag__ res = __builtin_copysignq (0.0, __imag__ x);
}
else if (icls == QUADFP_INFINITE)
{
if (rcls >= QUADFP_ZERO)
- __real__ res = copysignq (M_PI_2q, __real__ x);
+ __real__ res = __builtin_copysignq (M_PI_2q, __real__ x);
else
- __real__ res = nanq ("");
- __imag__ res = copysignq (0.0, __imag__ x);
+ __real__ res = __builtin_nanq ("");
+ __imag__ res = __builtin_copysignq (0.0, __imag__ x);
}
else if (icls == QUADFP_ZERO || icls == QUADFP_INFINITE)
{
- __real__ res = nanq ("");
- __imag__ res = copysignq (0.0, __imag__ x);
+ __real__ res = __builtin_nanq ("");
+ __imag__ res = __builtin_copysignq (0.0, __imag__ x);
}
else
{
- __real__ res = nanq ("");
- __imag__ res = nanq ("");
+ __real__ res = __builtin_nanq ("");
+ __imag__ res = __builtin_nanq ("");
}
}
else if (rcls == QUADFP_ZERO && icls == QUADFP_ZERO)
Index: math/ccoshq.c
===================================================================
--- math/ccoshq.c (revision 237340)
+++ math/ccoshq.c (working copy)
@@ -50,10 +50,10 @@ ccoshq (__complex128 x)
cosix = 1.0Q;
}
- if (fabsq (__real__ x) > t)
+ if (__builtin_fabsq (__real__ x) > t)
{
__float128 exp_t = expq (t);
- __float128 rx = fabsq (__real__ x);
+ __float128 rx = __builtin_fabsq (__real__ x);
if (signbitq (__real__ x))
sinix = -sinix;
rx -= t;
@@ -86,8 +86,8 @@ ccoshq (__complex128 x)
}
else
{
- __imag__ retval = __real__ x == 0.0Q ? 0.0Q : nanq ("");
- __real__ retval = nanq ("") + nanq ("");
+ __imag__ retval = __real__ x == 0.0Q ? 0.0Q : __builtin_nanq ("");
+ __real__ retval = __builtin_nanq ("") + __builtin_nanq ("");
#ifdef HAVE_FENV_H
if (icls == QUADFP_INFINITE)
@@ -113,21 +113,21 @@ ccoshq (__complex128 x)
cosix = 1.0Q;
}
- __real__ retval = copysignq (HUGE_VALQ, cosix);
- __imag__ retval = (copysignq (HUGE_VALQ, sinix)
- * copysignq (1.0Q, __real__ x));
+ __real__ retval = __builtin_copysignq (HUGE_VALQ, cosix);
+ __imag__ retval = (__builtin_copysignq (HUGE_VALQ, sinix)
+ * __builtin_copysignq (1.0Q, __real__ x));
}
else if (icls == QUADFP_ZERO)
{
/* Imaginary part is 0.0. */
__real__ retval = HUGE_VALQ;
- __imag__ retval = __imag__ x * copysignq (1.0Q, __real__ x);
+ __imag__ retval = __imag__ x * __builtin_copysignq (1.0Q, __real__ x);
}
else
{
/* The addition raises the invalid exception. */
__real__ retval = HUGE_VALQ;
- __imag__ retval = nanq ("") + nanq ("");
+ __imag__ retval = __builtin_nanq ("") + __builtin_nanq ("");
#ifdef HAVE_FENV_H
if (icls == QUADFP_INFINITE)
@@ -137,8 +137,8 @@ ccoshq (__complex128 x)
}
else
{
- __real__ retval = nanq ("");
- __imag__ retval = __imag__ x == 0.0 ? __imag__ x : nanq ("");
+ __real__ retval = __builtin_nanq ("");
+ __imag__ retval = __imag__ x == 0.0 ? __imag__ x : __builtin_nanq ("");
}
return retval;
Index: math/cexpq.c
===================================================================
--- math/cexpq.c (revision 237340)
+++ math/cexpq.c (working copy)
@@ -80,8 +80,8 @@ cexpq (__complex128 x)
{
/* If the imaginary part is +-inf or NaN and the real part
is not +-inf the result is NaN + iNaN. */
- __real__ retval = nanq ("");
- __imag__ retval = nanq ("");
+ __real__ retval = __builtin_nanq ("");
+ __imag__ retval = __builtin_nanq ("");
#ifdef HAVE_FENV_H
feraiseexcept (FE_INVALID);
@@ -116,14 +116,14 @@ cexpq (__complex128 x)
cosix = 1.0Q;
}
- __real__ retval = copysignq (value, cosix);
- __imag__ retval = copysignq (value, sinix);
+ __real__ retval = __builtin_copysignq (value, cosix);
+ __imag__ retval = __builtin_copysignq (value, sinix);
}
}
else if (signbitq (__real__ x) == 0)
{
__real__ retval = HUGE_VALQ;
- __imag__ retval = nanq ("");
+ __imag__ retval = __builtin_nanq ("");
#ifdef HAVE_FENV_H
if (icls == QUADFP_INFINITE)
@@ -133,14 +133,14 @@ cexpq (__complex128 x)
else
{
__real__ retval = 0.0Q;
- __imag__ retval = copysignq (0.0Q, __imag__ x);
+ __imag__ retval = __builtin_copysignq (0.0Q, __imag__ x);
}
}
else
{
/* If the real part is NaN the result is NaN + iNaN. */
- __real__ retval = nanq ("");
- __imag__ retval = nanq ("");
+ __real__ retval = __builtin_nanq ("");
+ __imag__ retval = __builtin_nanq ("");
#ifdef HAVE_FENV_H
if (rcls != QUADFP_NAN || icls != QUADFP_NAN)
Index: math/clog10q.c
===================================================================
--- math/clog10q.c (revision 237340)
+++ math/clog10q.c (working copy)
@@ -35,14 +35,14 @@ clog10q (__complex128 x)
{
/* Real and imaginary part are 0.0. */
__imag__ result = signbitq (__real__ x) ? M_PIq : 0.0Q;
- __imag__ result = copysignq (__imag__ result, __imag__ x);
+ __imag__ result = __builtin_copysignq (__imag__ result, __imag__ x);
/* Yes, the following line raises an exception. */
- __real__ result = -1.0Q / fabsq (__real__ x);
+ __real__ result = -1.0Q / __builtin_fabsq (__real__ x);
}
else if (__builtin_expect (rcls != QUADFP_NAN && icls != QUADFP_NAN, 1))
{
/* Neither real nor imaginary part is NaN. */
- __float128 absx = fabsq (__real__ x), absy = fabsq (__imag__ x);
+ __float128 absx = __builtin_fabsq (__real__ x), absy = __builtin_fabsq
(__imag__ x);
int scale = 0;
if (absx < absy)
@@ -104,12 +104,12 @@ clog10q (__complex128 x)
}
else
{
- __imag__ result = nanq ("");
+ __imag__ result = __builtin_nanq ("");
if (rcls == QUADFP_INFINITE || icls == QUADFP_INFINITE)
/* Real or imaginary part is infinite. */
__real__ result = HUGE_VALQ;
else
- __real__ result = nanq ("");
+ __real__ result = __builtin_nanq ("");
}
return result;
Index: math/clogq.c
===================================================================
--- math/clogq.c (revision 237340)
+++ math/clogq.c (working copy)
@@ -31,14 +31,14 @@ clogq (__complex128 x)
{
/* Real and imaginary part are 0.0. */
__imag__ result = signbitq (__real__ x) ? M_PIq : 0.0Q;
- __imag__ result = copysignq (__imag__ result, __imag__ x);
+ __imag__ result = __builtin_copysignq (__imag__ result, __imag__ x);
/* Yes, the following line raises an exception. */
- __real__ result = -1.0Q / fabsq (__real__ x);
+ __real__ result = -1.0Q / __builtin_fabsq (__real__ x);
}
else if (__builtin_expect (rcls != QUADFP_NAN && icls != QUADFP_NAN, 1))
{
/* Neither real nor imaginary part is NaN. */
- __float128 absx = fabsq (__real__ x), absy = fabsq (__imag__ x);
+ __float128 absx = __builtin_fabsq (__real__ x), absy = __builtin_fabsq
(__imag__ x);
int scale = 0;
if (absx < absy)
@@ -99,12 +99,12 @@ clogq (__complex128 x)
}
else
{
- __imag__ result = nanq ("");
+ __imag__ result = __builtin_nanq ("");
if (rcls == QUADFP_INFINITE || icls == QUADFP_INFINITE)
/* Real or imaginary part is infinite. */
__real__ result = HUGE_VALQ;
else
- __real__ result = nanq ("");
+ __real__ result = __builtin_nanq ("");
}
return result;
Index: math/cprojq.c
===================================================================
--- math/cprojq.c (revision 237340)
+++ math/cprojq.c (working copy)
@@ -30,8 +30,8 @@ cprojq (__complex128 x)
{
__complex128 res;
- __real__ res = __builtin_inf ();
- __imag__ res = copysignq (0.0, __imag__ x);
+ __real__ res = __builtin_infq ();
+ __imag__ res = __builtin_copysignq (0.0, __imag__ x);
return res;
}
Index: math/csinhq.c
===================================================================
--- math/csinhq.c (revision 237340)
+++ math/csinhq.c (working copy)
@@ -32,7 +32,7 @@ csinhq (__complex128 x)
int rcls = fpclassifyq (__real__ x);
int icls = fpclassifyq (__imag__ x);
- __real__ x = fabsq (__real__ x);
+ __real__ x = __builtin_fabsq (__real__ x);
if (__builtin_expect (rcls >= QUADFP_ZERO, 1))
{
@@ -53,10 +53,10 @@ csinhq (__complex128 x)
cosix = 1.0Q;
}
- if (fabsq (__real__ x) > t)
+ if (__builtin_fabsq (__real__ x) > t)
{
__float128 exp_t = expq (t);
- __float128 rx = fabsq (__real__ x);
+ __float128 rx = __builtin_fabsq (__real__ x);
if (signbitq (__real__ x))
cosix = -cosix;
rx -= t;
@@ -95,8 +95,8 @@ csinhq (__complex128 x)
if (rcls == QUADFP_ZERO)
{
/* Real part is 0.0. */
- __real__ retval = copysignq (0.0Q, negate ? -1.0Q : 1.0Q);
- __imag__ retval = nanq ("") + nanq ("");
+ __real__ retval = __builtin_copysignq (0.0Q, negate ? -1.0Q :
1.0Q);
+ __imag__ retval = __builtin_nanq ("") + __builtin_nanq ("");
#ifdef HAVE_FENV_H
if (icls == QUADFP_INFINITE)
@@ -105,8 +105,8 @@ csinhq (__complex128 x)
}
else
{
- __real__ retval = nanq ("");
- __imag__ retval = nanq ("");
+ __real__ retval = __builtin_nanq ("");
+ __imag__ retval = __builtin_nanq ("");
#ifdef HAVE_FENV_H
feraiseexcept (FE_INVALID);
@@ -132,8 +132,8 @@ csinhq (__complex128 x)
cosix = 1.0;
}
- __real__ retval = copysignq (HUGE_VALQ, cosix);
- __imag__ retval = copysignq (HUGE_VALQ, sinix);
+ __real__ retval = __builtin_copysignq (HUGE_VALQ, cosix);
+ __imag__ retval = __builtin_copysignq (HUGE_VALQ, sinix);
if (negate)
__real__ retval = -__real__ retval;
@@ -148,7 +148,7 @@ csinhq (__complex128 x)
{
/* The addition raises the invalid exception. */
__real__ retval = HUGE_VALQ;
- __imag__ retval = nanq ("") + nanq ("");
+ __imag__ retval = __builtin_nanq ("") + __builtin_nanq ("");
#ifdef HAVE_FENV_H
if (icls == QUADFP_INFINITE)
@@ -158,8 +158,8 @@ csinhq (__complex128 x)
}
else
{
- __real__ retval = nanq ("");
- __imag__ retval = __imag__ x == 0.0Q ? __imag__ x : nanq ("");
+ __real__ retval = __builtin_nanq ("");
+ __imag__ retval = __imag__ x == 0.0Q ? __imag__ x : __builtin_nanq ("");
}
return retval;
Index: math/csinq.c
===================================================================
--- math/csinq.c (revision 237340)
+++ math/csinq.c (working copy)
@@ -32,7 +32,7 @@ csinq (__complex128 x)
int rcls = fpclassifyq (__real__ x);
int icls = fpclassifyq (__imag__ x);
- __real__ x = fabsq (__real__ x);
+ __real__ x = __builtin_fabsq (__real__ x);
if (__builtin_expect (icls >= QUADFP_ZERO, 1))
{
@@ -53,10 +53,10 @@ csinq (__complex128 x)
cosix = 1.0Q;
}
- if (fabsq (__imag__ x) > t)
+ if (__builtin_fabsq (__imag__ x) > t)
{
__float128 exp_t = expq (t);
- __float128 ix = fabsq (__imag__ x);
+ __float128 ix = __builtin_fabsq (__imag__ x);
if (signbitq (__imag__ x))
cosix = -cosix;
ix -= t;
@@ -95,7 +95,7 @@ csinq (__complex128 x)
if (icls == QUADFP_ZERO)
{
/* Imaginary part is 0.0. */
- __real__ retval = nanq ("");
+ __real__ retval = __builtin_nanq ("");
__imag__ retval = __imag__ x;
#ifdef HAVE_FENV_H
@@ -105,8 +105,8 @@ csinq (__complex128 x)
}
else
{
- __real__ retval = nanq ("");
- __imag__ retval = nanq ("");
+ __real__ retval = __builtin_nanq ("");
+ __imag__ retval = __builtin_nanq ("");
#ifdef HAVE_FENV_H
feraiseexcept (FE_INVALID);
@@ -120,7 +120,7 @@ csinq (__complex128 x)
if (rcls == QUADFP_ZERO)
{
/* Real part is 0.0. */
- __real__ retval = copysignq (0.0Q, negate ? -1.0Q : 1.0Q);
+ __real__ retval = __builtin_copysignq (0.0Q, negate ? -1.0Q : 1.0Q);
__imag__ retval = __imag__ x;
}
else if (rcls > QUADFP_ZERO)
@@ -138,8 +138,8 @@ csinq (__complex128 x)
cosix = 1.0;
}
- __real__ retval = copysignq (HUGE_VALQ, sinix);
- __imag__ retval = copysignq (HUGE_VALQ, cosix);
+ __real__ retval = __builtin_copysignq (HUGE_VALQ, sinix);
+ __imag__ retval = __builtin_copysignq (HUGE_VALQ, cosix);
if (negate)
__real__ retval = -__real__ retval;
@@ -149,7 +149,7 @@ csinq (__complex128 x)
else
{
/* The addition raises the invalid exception. */
- __real__ retval = nanq ("");
+ __real__ retval = __builtin_nanq ("");
__imag__ retval = HUGE_VALQ;
#ifdef HAVE_FENV_H
@@ -161,10 +161,10 @@ csinq (__complex128 x)
else
{
if (rcls == QUADFP_ZERO)
- __real__ retval = copysignq (0.0Q, negate ? -1.0Q : 1.0Q);
+ __real__ retval = __builtin_copysignq (0.0Q, negate ? -1.0Q : 1.0Q);
else
- __real__ retval = nanq ("");
- __imag__ retval = nanq ("");
+ __real__ retval = __builtin_nanq ("");
+ __imag__ retval = __builtin_nanq ("");
}
return retval;
Index: math/csqrtq.c
===================================================================
--- math/csqrtq.c (revision 237340)
+++ math/csqrtq.c (working copy)
@@ -43,20 +43,20 @@ csqrtq (__complex128 x)
{
if (__real__ x < 0.0Q)
{
- __real__ res = icls == QUADFP_NAN ? nanq ("") : 0;
- __imag__ res = copysignq (HUGE_VALQ, __imag__ x);
+ __real__ res = icls == QUADFP_NAN ? __builtin_nanq ("") : 0;
+ __imag__ res = __builtin_copysignq (HUGE_VALQ, __imag__ x);
}
else
{
__real__ res = __real__ x;
__imag__ res = (icls == QUADFP_NAN
- ? nanq ("") : copysignq (0.0Q, __imag__ x));
+ ? __builtin_nanq ("") : __builtin_copysignq
(0.0Q, __imag__ x));
}
}
else
{
- __real__ res = nanq ("");
- __imag__ res = nanq ("");
+ __real__ res = __builtin_nanq ("");
+ __imag__ res = __builtin_nanq ("");
}
}
else
@@ -66,25 +66,25 @@ csqrtq (__complex128 x)
if (__real__ x < 0.0Q)
{
__real__ res = 0.0Q;
- __imag__ res = copysignq (sqrtq (-__real__ x),
+ __imag__ res = __builtin_copysignq (sqrtq (-__real__ x),
__imag__ x);
}
else
{
- __real__ res = fabsq (sqrtq (__real__ x));
- __imag__ res = copysignq (0.0Q, __imag__ x);
+ __real__ res = __builtin_fabsq (sqrtq (__real__ x));
+ __imag__ res = __builtin_copysignq (0.0Q, __imag__ x);
}
}
else if (__builtin_expect (rcls == QUADFP_ZERO, 0))
{
__float128 r;
- if (fabsq (__imag__ x) >= 2.0Q * FLT128_MIN)
- r = sqrtq (0.5Q * fabsq (__imag__ x));
+ if (__builtin_fabsq (__imag__ x) >= 2.0Q * FLT128_MIN)
+ r = sqrtq (0.5Q * __builtin_fabsq (__imag__ x));
else
- r = 0.5Q * sqrtq (2.0Q * fabsq (__imag__ x));
+ r = 0.5Q * sqrtq (2.0Q * __builtin_fabsq (__imag__ x));
__real__ res = r;
- __imag__ res = copysignq (r, __imag__ x);
+ __imag__ res = __builtin_copysignq (r, __imag__ x);
}
else
{
@@ -91,23 +91,23 @@ csqrtq (__complex128 x)
__float128 d, r, s;
int scale = 0;
- if (fabsq (__real__ x) > FLT128_MAX / 4.0Q)
+ if (__builtin_fabsq (__real__ x) > FLT128_MAX / 4.0Q)
{
scale = 1;
__real__ x = scalbnq (__real__ x, -2 * scale);
__imag__ x = scalbnq (__imag__ x, -2 * scale);
}
- else if (fabsq (__imag__ x) > FLT128_MAX / 4.0Q)
+ else if (__builtin_fabsq (__imag__ x) > FLT128_MAX / 4.0Q)
{
scale = 1;
- if (fabsq (__real__ x) >= 4.0Q * FLT128_MIN)
+ if (__builtin_fabsq (__real__ x) >= 4.0Q * FLT128_MIN)
__real__ x = scalbnq (__real__ x, -2 * scale);
else
__real__ x = 0.0Q;
__imag__ x = scalbnq (__imag__ x, -2 * scale);
}
- else if (fabsq (__real__ x) < FLT128_MIN
- && fabsq (__imag__ x) < FLT128_MIN)
+ else if (__builtin_fabsq (__real__ x) < FLT128_MIN
+ && __builtin_fabsq (__imag__ x) < FLT128_MIN)
{
scale = -(FLT128_MANT_DIG / 2);
__real__ x = scalbnq (__real__ x, -2 * scale);
@@ -125,7 +125,7 @@ csqrtq (__complex128 x)
else
{
s = sqrtq (0.5Q * (d - __real__ x));
- r = fabsq (0.5Q * (__imag__ x / s));
+ r = __builtin_fabsq (0.5Q * (__imag__ x / s));
}
if (scale)
@@ -135,7 +135,7 @@ csqrtq (__complex128 x)
}
__real__ res = r;
- __imag__ res = copysignq (s, __imag__ x);
+ __imag__ res = __builtin_copysignq (s, __imag__ x);
}
}
Index: math/ctanhq.c
===================================================================
--- math/ctanhq.c (revision 237340)
+++ math/ctanhq.c (working copy)
@@ -33,8 +33,8 @@ ctanhq (__complex128 x)
{
if (__quadmath_isinf_nsq (__real__ x))
{
- __real__ res = copysignq (1.0Q, __real__ x);
- __imag__ res = copysignq (0.0Q, __imag__ x);
+ __real__ res = __builtin_copysignq (1.0Q, __real__ x);
+ __imag__ res = __builtin_copysignq (0.0Q, __imag__ x);
}
else if (__imag__ x == 0.0Q)
{
@@ -42,8 +42,8 @@ ctanhq (__complex128 x)
}
else
{
- __real__ res = nanq ("");
- __imag__ res = nanq ("");
+ __real__ res = __builtin_nanq ("");
+ __imag__ res = __builtin_nanq ("");
#ifdef HAVE_FENV_H
if (__quadmath_isinf_nsq (__imag__ x))
@@ -71,7 +71,7 @@ ctanhq (__complex128 x)
cosix = 1.0Q;
}
- if (fabsq (__real__ x) > t)
+ if (__builtin_fabsq (__real__ x) > t)
{
/* Avoid intermediate overflow when the imaginary part of
the result may be subnormal. Ignoring negligible terms,
@@ -79,9 +79,9 @@ ctanhq (__complex128 x)
sin(y)*cos(y)/sinh(x)^2 = 4*sin(y)*cos(y)/exp(2x). */
__float128 exp_2t = expq (2 * t);
- __real__ res = copysignq (1.0, __real__ x);
+ __real__ res = __builtin_copysignq (1.0, __real__ x);
__imag__ res = 4 * sinix * cosix;
- __real__ x = fabsq (__real__ x);
+ __real__ x = __builtin_fabsq (__real__ x);
__real__ x -= t;
__imag__ res /= exp_2t;
if (__real__ x > t)
@@ -96,7 +96,7 @@ ctanhq (__complex128 x)
else
{
__float128 sinhrx, coshrx;
- if (fabsq (__real__ x) > FLT128_MIN)
+ if (__builtin_fabsq (__real__ x) > FLT128_MIN)
{
sinhrx = sinhq (__real__ x);
coshrx = coshq (__real__ x);
@@ -107,7 +107,7 @@ ctanhq (__complex128 x)
coshrx = 1.0Q;
}
- if (fabsq (sinhrx) > fabsq (cosix) * FLT128_EPSILON)
+ if (__builtin_fabsq (sinhrx) > __builtin_fabsq (cosix) *
FLT128_EPSILON)
den = sinhrx * sinhrx + cosix * cosix;
else
den = cosix * cosix;
Index: math/ctanq.c
===================================================================
--- math/ctanq.c (revision 237340)
+++ math/ctanq.c (working copy)
@@ -33,8 +33,8 @@ ctanq (__complex128 x)
{
if (__quadmath_isinf_nsq (__imag__ x))
{
- __real__ res = copysignq (0.0Q, __real__ x);
- __imag__ res = copysignq (1.0Q, __imag__ x);
+ __real__ res = __builtin_copysignq (0.0Q, __real__ x);
+ __imag__ res = __builtin_copysignq (1.0Q, __imag__ x);
}
else if (__real__ x == 0.0Q)
{
@@ -42,8 +42,8 @@ ctanq (__complex128 x)
}
else
{
- __real__ res = nanq ("");
- __imag__ res = nanq ("");
+ __real__ res = __builtin_nanq ("");
+ __imag__ res = __builtin_nanq ("");
#ifdef HAVE_FENV_H
if (__quadmath_isinf_nsq (__real__ x))
@@ -71,7 +71,7 @@ ctanq (__complex128 x)
cosrx = 1.0Q;
}
- if (fabsq (__imag__ x) > t)
+ if (__builtin_fabsq (__imag__ x) > t)
{
/* Avoid intermediate overflow when the real part of the
result may be subnormal. Ignoring negligible terms, the
@@ -79,9 +79,9 @@ ctanq (__complex128 x)
sin(x)*cos(x)/sinh(y)^2 = 4*sin(x)*cos(x)/exp(2y). */
__float128 exp_2t = expq (2 * t);
- __imag__ res = copysignq (1.0Q, __imag__ x);
+ __imag__ res = __builtin_copysignq (1.0Q, __imag__ x);
__real__ res = 4 * sinrx * cosrx;
- __imag__ x = fabsq (__imag__ x);
+ __imag__ x = __builtin_fabsq (__imag__ x);
__imag__ x -= t;
__real__ res /= exp_2t;
if (__imag__ x > t)
@@ -96,7 +96,7 @@ ctanq (__complex128 x)
else
{
__float128 sinhix, coshix;
- if (fabsq (__imag__ x) > FLT128_MIN)
+ if (__builtin_fabsq (__imag__ x) > FLT128_MIN)
{
sinhix = sinhq (__imag__ x);
coshix = coshq (__imag__ x);
@@ -107,7 +107,7 @@ ctanq (__complex128 x)
coshix = 1.0Q;
}
- if (fabsq (sinhix) > fabsq (cosrx) * FLT128_EPSILON)
+ if (__builtin_fabsq (sinhix) > __builtin_fabsq (cosrx) *
FLT128_EPSILON)
den = cosrx * cosrx + sinhix * sinhix;
else
den = cosrx * cosrx;
Index: math/erfq.c
===================================================================
--- math/erfq.c (revision 237340)
+++ math/erfq.c (working copy)
@@ -884,7 +884,7 @@ erfcq (__float128 x)
if ((ix >= 0x40022000) && (sign & 0x80000000))
return two - tiny;
- x = fabsq (x);
+ x = __builtin_fabsq (x);
z = one / (x * x);
i = 8.0 / x;
switch (i)
Index: math/j0q.c
===================================================================
--- math/j0q.c (revision 237340)
+++ math/j0q.c (working copy)
@@ -688,7 +688,7 @@ j0q (__float128 x)
if (x == 0.0Q)
return 1.0Q;
- xx = fabsq (x);
+ xx = __builtin_fabsq (x);
if (xx <= 2.0Q)
{
/* 0 <= x <= 2 */
@@ -829,7 +829,7 @@ y0q (__float128 x)
return (zero / (zero * x));
return -HUGE_VALQ + x;
}
- xx = fabsq (x);
+ xx = __builtin_fabsq (x);
if (xx <= 0x1p-57)
return U0 + TWOOPI * logq (x);
if (xx <= 2.0Q)
Index: math/j1q.c
===================================================================
--- math/j1q.c (revision 237340)
+++ math/j1q.c (working copy)
@@ -693,7 +693,7 @@ j1q (__float128 x)
}
if (x == 0.0Q)
return x;
- xx = fabsq (x);
+ xx = __builtin_fabsq (x);
if (xx <= 2.0Q)
{
/* 0 <= x <= 2 */
@@ -835,7 +835,7 @@ y1q (__float128 x)
return (zero / (zero * x));
return -HUGE_VALQ + x;
}
- xx = fabsq (x);
+ xx = __builtin_fabsq (x);
if (xx <= 0x1p-114)
return -TWOOPI / x;
if (xx <= 2.0Q)
Index: math/jnq.c
===================================================================
--- math/jnq.c (revision 237340)
+++ math/jnq.c (working copy)
@@ -102,7 +102,7 @@ jnq (int n, __float128 x)
if (n == 1)
return (j1q (x));
sgn = (n & 1) & (se >> 31); /* even n -- 0, odd n -- sign(x) */
- x = fabsq (x);
+ x = __builtin_fabsq (x);
if (x == 0.0Q || ix >= 0x7fff0000) /* if x is 0 or inf */
b = zero;
@@ -243,7 +243,7 @@ jnq (int n, __float128 x)
*/
tmp = n;
v = two / x;
- tmp = tmp * logq (fabsq (v * tmp));
+ tmp = tmp * logq (__builtin_fabsq (v * tmp));
if (tmp < 1.1356523406294143949491931077970765006170e+04Q)
{
@@ -280,7 +280,7 @@ jnq (int n, __float128 x)
*/
z = j0q (x);
w = j1q (x);
- if (fabsq (z) >= fabsq (w))
+ if (__builtin_fabsq (z) >= __builtin_fabsq (w))
b = (t * z / b);
else
b = (t * w / a);
Index: math/logbq.c
===================================================================
--- math/logbq.c (revision 237340)
+++ math/logbq.c (working copy)
@@ -29,7 +29,7 @@ logbq (__float128 x)
GET_FLT128_WORDS64 (hx, lx, x);
hx &= 0x7fffffffffffffffLL; /* high |x| */
if ((hx | lx) == 0)
- return -1.0 / fabsq (x);
+ return -1.0 / __builtin_fabsq (x);
if (hx >= 0x7fff000000000000LL)
return x * x;
if ((ex = hx >> 48) == 0) /* IEEE 754 logb */
Index: math/powq.c
===================================================================
--- math/powq.c (revision 237340)
+++ math/powq.c (working copy)
@@ -235,7 +235,7 @@ powq (__float128 x, __float128 y)
}
}
- ax = fabsq (x);
+ ax = __builtin_fabsq (x);
/* special value of x */
if ((p.words32.w1 | p.words32.w2 | p.words32.w3) == 0)
{
Index: math/remainderq.c
===================================================================
--- math/remainderq.c (revision 237340)
+++ math/remainderq.c (working copy)
@@ -47,8 +47,8 @@ remainderq (__float128 x, __float128 p)
if (hp<=0x7ffdffffffffffffLL) x = fmodq (x,p+p); /* now x < 2p */
if (((hx-hp)|(lx-lp))==0) return zero*x;
- x = fabsq(x);
- p = fabsq(p);
+ x = __builtin_fabsq(x);
+ p = __builtin_fabsq(p);
if (hp<0x0002000000000000LL) {
if(x+x>p) {
x-=p;
Index: math/remquoq.c
===================================================================
--- math/remquoq.c (revision 237340)
+++ math/remquoq.c (working copy)
@@ -56,8 +56,8 @@ remquoq (__float128 x, __float128 y, int *quo)
return zero * x;
}
- x = fabsq (x);
- y = fabsq (y);
+ x = __builtin_fabsq (x);
+ y = __builtin_fabsq (y);
cquo = 0;
if (x >= 4 * y)
Index: math/scalblnq.c
===================================================================
--- math/scalblnq.c (revision 237340)
+++ math/scalblnq.c (working copy)
@@ -41,9 +41,9 @@ scalblnq (__float128 x, long int n)
k = ((hx>>48)&0x7fff) - 114;
}
if (k==0x7fff) return x+x; /* NaN or Inf */
- if (n< -50000) return tiny*copysignq(tiny,x); /*underflow*/
+ if (n< -50000) return tiny*__builtin_copysignq(tiny,x); /*underflow*/
if (n> 50000 || k+n > 0x7ffe)
- return huge*copysignq(huge,x); /* overflow */
+ return huge*__builtin_copysignq(huge,x); /* overflow */
/* Now k and n are bounded we know that k = k+n does not
overflow. */
k = k+n;
@@ -50,7 +50,7 @@ scalblnq (__float128 x, long int n)
if (k > 0) /* normal result */
{SET_FLT128_MSW64(x,(hx&0x8000ffffffffffffULL)|(k<<48)); return x;}
if (k <= -114)
- return tiny*copysignq(tiny,x); /*underflow*/
+ return tiny*__builtin_copysignq(tiny,x); /*underflow*/
k += 114; /* subnormal result */
SET_FLT128_MSW64(x,(hx&0x8000ffffffffffffULL)|(k<<48));
return x*twom114;
Index: math/scalbnq.c
===================================================================
--- math/scalbnq.c (revision 237340)
+++ math/scalbnq.c (working copy)
@@ -42,9 +42,9 @@ scalbnq (__float128 x, int n)
k = ((hx>>48)&0x7fff) - 114;
}
if (k==0x7fff) return x+x; /* NaN or Inf */
- if (n< -50000) return tiny*copysignq(tiny,x); /*underflow*/
+ if (n< -50000) return tiny*__builtin_copysignq(tiny,x); /*underflow*/
if (n> 50000 || k+n > 0x7ffe)
- return huge*copysignq(huge,x); /* overflow */
+ return huge*__builtin_copysignq(huge,x); /* overflow */
/* Now k and n are bounded we know that k = k+n does not
overflow. */
k = k+n;
@@ -51,7 +51,7 @@ scalbnq (__float128 x, int n)
if (k > 0) /* normal result */
{SET_FLT128_MSW64(x,(hx&0x8000ffffffffffffULL)|(k<<48)); return x;}
if (k <= -114)
- return tiny*copysignq(tiny,x); /*underflow*/
+ return tiny*__builtin_copysignq(tiny,x); /*underflow*/
k += 114; /* subnormal result */
SET_FLT128_MSW64(x,(hx&0x8000ffffffffffffULL)|(k<<48));
return x*twom114;
Index: math/sinq_kernel.c
===================================================================
--- math/sinq_kernel.c (revision 237340)
+++ math/sinq_kernel.c (working copy)
@@ -105,7 +105,7 @@ __quadmath_kernel_sinq (__float128 x, __float128 y
sinq(h+l) = sinq(h)cosq(l) + cosq(h)sinq(l). */
index = 0x3ffe - (tix >> 16);
hix = (tix + (0x200 << index)) & (0xfffffc00 << index);
- x = fabsq (x);
+ x = __builtin_fabsq (x);
switch (index)
{
case 0: index = ((45 << 10) + hix - 0x3ffe0000) >> 8; break;
Index: math/tanq.c
===================================================================
--- math/tanq.c (revision 237340)
+++ math/tanq.c (working copy)
@@ -98,7 +98,7 @@ __quadmath_kernel_tanq (__float128 x, __float128 y
{ /* generate inexact */
if ((ix | u.words32.w1 | u.words32.w2 | u.words32.w3
| (iy + 1)) == 0)
- return one / fabsq (x);
+ return one / __builtin_fabsq (x);
else
return (iy == 1) ? x : -one / x;
}
Index: math/x2y2m1q.c
===================================================================
--- math/x2y2m1q.c (revision 237340)
+++ math/x2y2m1q.c (working copy)
@@ -49,8 +49,8 @@ mul_split (__float128 *hi, __float128 *lo, __float
static int
compare (const void *p, const void *q)
{
- __float128 pld = fabsq (*(const __float128 *) p);
- __float128 qld = fabsq (*(const __float128 *) q);
+ __float128 pld = __builtin_fabsq (*(const __float128 *) p);
+ __float128 qld = __builtin_fabsq (*(const __float128 *) q);
if (pld < qld)
return -1;
else if (pld == qld)
