3ac02e6750
My PR114623 change started using soft-fp.h and quad.h for the sqrtq implementation.
Unfortunately, that seems to fail building in some powerpc* configurations, where
TFmode isn't available.
quad.h has:
#ifndef TFtype
typedef float TFtype __attribute__ ((mode (TF)));
#endif
and uses TFtype. quad.h has:
/* Define the complex type corresponding to __float128
("_Complex __float128" is not allowed) */
#if (!defined(_ARCH_PPC)) || defined(__LONG_DOUBLE_IEEE128__)
typedef _Complex float __attribute__((mode(TC))) __complex128;
#else
typedef _Complex float __attribute__((mode(KC))) __complex128;
#endif
with the conditional and KCmode use added during porting of libquadmath
to powerpc*, so I've just defined TFtype for powerpc when __LONG_DOUBLE_IEEE128__
isn't defined; I could define it to float __attribute__ ((mode (KF))) but it
seemed easier to just define it to __float128 which should do the same thing.
2024-08-03 Jakub Jelinek <jakub@redhat.com>
PR target/116007
* math/sqrtq.c (TFtype): For PowerPC without __LONG_DOUBLE_IEEE128__
define to __float128 before including soft-fp.h and quad.h.
89 lines
1.8 KiB
C
89 lines
1.8 KiB
C
#include "quadmath-imp.h"
|
|
#include <math.h>
|
|
#include <float.h>
|
|
#if __has_include("../../libgcc/soft-fp/soft-fp.h") \
|
|
&& __has_include("../../libgcc/soft-fp/quad.h") \
|
|
&& defined(FE_TONEAREST) \
|
|
&& defined(FE_UPWARD) \
|
|
&& defined(FE_DOWNWARD) \
|
|
&& defined(FE_TOWARDZERO) \
|
|
&& defined(FE_INEXACT)
|
|
#define USE_SOFT_FP 1
|
|
#if defined(_ARCH_PPC) && !defined(__LONG_DOUBLE_IEEE128__)
|
|
#define TFtype __float128
|
|
#endif
|
|
#include "../../libgcc/soft-fp/soft-fp.h"
|
|
#include "../../libgcc/soft-fp/quad.h"
|
|
#endif
|
|
|
|
__float128
|
|
sqrtq (const __float128 x)
|
|
{
|
|
__float128 y;
|
|
int exp;
|
|
|
|
if (isnanq (x) || (isinfq (x) && x > 0))
|
|
return x;
|
|
|
|
if (x == 0)
|
|
return x;
|
|
|
|
if (x < 0)
|
|
{
|
|
/* Return NaN with invalid signal. */
|
|
return (x - x) / (x - x);
|
|
}
|
|
|
|
#if USE_SOFT_FP
|
|
FP_DECL_EX;
|
|
FP_DECL_Q (X);
|
|
FP_DECL_Q (Y);
|
|
|
|
FP_INIT_ROUNDMODE;
|
|
FP_UNPACK_Q (X, x);
|
|
FP_SQRT_Q (Y, X);
|
|
FP_PACK_Q (y, Y);
|
|
FP_HANDLE_EXCEPTIONS;
|
|
return y;
|
|
#else
|
|
if (x <= DBL_MAX && x >= DBL_MIN)
|
|
{
|
|
/* Use double result as starting point. */
|
|
y = sqrt ((double) x);
|
|
|
|
/* Two Newton iterations. */
|
|
y -= 0.5q * (y - x / y);
|
|
y -= 0.5q * (y - x / y);
|
|
return y;
|
|
}
|
|
|
|
#ifdef HAVE_SQRTL
|
|
{
|
|
long double xl = (long double) x;
|
|
if (xl <= LDBL_MAX && xl >= LDBL_MIN)
|
|
{
|
|
/* Use long double result as starting point. */
|
|
y = (__float128) sqrtl (xl);
|
|
|
|
/* One Newton iteration. */
|
|
y -= 0.5q * (y - x / y);
|
|
return y;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/* If we're outside of the range of C types, we have to compute
|
|
the initial guess the hard way. */
|
|
y = frexpq (x, &exp);
|
|
if (exp % 2)
|
|
y *= 2, exp--;
|
|
|
|
y = sqrt (y);
|
|
y = scalbnq (y, exp / 2);
|
|
|
|
/* Two Newton iterations. */
|
|
y -= 0.5q * (y - x / y);
|
|
y -= 0.5q * (y - x / y);
|
|
return y;
|
|
#endif
|
|
}
|