2015-09-23 Joseph Myers <joseph@codesourcery.com>
+ * sysdeps/generic/math_private.h (fabs_tg): New macro.
+ (min_of_type): Likewise.
+ (math_check_force_underflow): Likewise.
+ (math_check_force_underflow_nonneg): Likewise.
+ (math_check_force_underflow_complex): Likewise.
+ * math/e_exp2l.c (__ieee754_exp2l): Use
+ math_check_force_underflow_nonneg.
+ * math/k_casinh.c (__kernel_casinh): Likewise.
+ * math/k_casinhf.c (__kernel_casinhf): Likewise.
+ * math/k_casinhl.c (__kernel_casinhl): Likewise.
+ * math/s_catan.c (__catan): Use
+ math_check_force_underflow_complex.
+ * math/s_catanf.c (__catanf): Likewise.
+ * math/s_catanh.c (__catanh): Likewise.
+ * math/s_catanhf.c (__catanhf): Likewise.
+ * math/s_catanhl.c (__catanhl): Likewise.
+ * math/s_catanl.c (__catanl): Likewise.
+ * math/s_ccosh.c (__ccosh): Likewise.
+ * math/s_ccoshf.c (__ccoshf): Likewise.
+ * math/s_ccoshl.c (__ccoshl): Likewise.
+ * math/s_cexp.c (__cexp): Likewise.
+ * math/s_cexpf.c (__cexpf): Likewise.
+ * math/s_cexpl.c (__cexpl): Likewise.
+ * math/s_clog.c (__clog): Use math_check_force_underflow_nonneg.
+ * math/s_clog10.c (__clog10): Likewise.
+ * math/s_clog10f.c (__clog10f): Likewise.
+ * math/s_clog10l.c (__clog10l): Likewise.
+ * math/s_clogf.c (__clogf): Likewise.
+ * math/s_clogl.c (__clogl): Likewise.
+ * math/s_csin.c (__csin): Use math_check_force_underflow_complex.
+ * math/s_csinf.c (__csinf): Likewise.
+ * math/s_csinh.c (__csinh): Likewise.
+ * math/s_csinhf.c (__csinhf): Likewise.
+ * math/s_csinhl.c (__csinhl): Likewise.
+ * math/s_csinl.c (__csinl): Likewise.
+ * math/s_csqrt.c (__csqrt): Use math_check_force_underflow.
+ * math/s_csqrtf.c (__csqrtf): Likewise.
+ * math/s_csqrtl.c (__csqrtl): Likewise.
+ * math/s_ctan.c (__ctan): Use math_check_force_underflow_complex.
+ * math/s_ctanf.c (__ctanf): Likewise.
+ * math/s_ctanh.c (__ctanh): Likewise.
+ * math/s_ctanhf.c (__ctanhf): Likewise.
+ * math/s_ctanhl.c (__ctanhl): Likewise.
+ * math/s_ctanl.c (__ctanl): Likewise.
+ * stdlib/strtod_l.c (round_and_return): Use math_force_eval
+ instead of volatile.
+ * sysdeps/ieee754/dbl-64/e_asin.c (__ieee754_asin): Use
+ math_check_force_underflow.
+ * sysdeps/ieee754/dbl-64/e_atanh.c (__ieee754_atanh): Likewise.
+ * sysdeps/ieee754/dbl-64/e_exp.c (__ieee754_exp): Do not use
+ volatile when forcing underflow.
+ * sysdeps/ieee754/dbl-64/e_exp2.c (__ieee754_exp2): Use
+ math_check_force_underflow_nonneg.
+ * sysdeps/ieee754/dbl-64/e_gamma_r.c (__ieee754_gamma_r):
+ Likewise.
+ * sysdeps/ieee754/dbl-64/e_j1.c (__ieee754_j1): Use
+ math_check_force_underflow.
+ * sysdeps/ieee754/dbl-64/e_jn.c (__ieee754_jn): Likewise.
+ * sysdeps/ieee754/dbl-64/e_sinh.c (__ieee754_sinh): Likewise.
+ * sysdeps/ieee754/dbl-64/s_asinh.c (__asinh): Likewise.
+ * sysdeps/ieee754/dbl-64/s_atan.c (atan): Use
+ math_check_force_underflow_nonneg.
+ * sysdeps/ieee754/dbl-64/s_erf.c (__erf): Use
+ math_check_force_underflow.
+ * sysdeps/ieee754/dbl-64/s_expm1.c (__expm1): Likewise.
+ * sysdeps/ieee754/dbl-64/s_fma.c (__fma): Use math_force_eval
+ instead of volatile.
+ * sysdeps/ieee754/dbl-64/s_log1p.c (__log1p): Use
+ math_check_force_underflow.
+ * sysdeps/ieee754/dbl-64/s_sin.c (__sin): Likewise.
+ * sysdeps/ieee754/dbl-64/s_tan.c (tan): Use
+ math_check_force_underflow_nonneg.
+ * sysdeps/ieee754/dbl-64/s_tanh.c (__tanh): Use
+ math_check_force_underflow.
+ * sysdeps/ieee754/flt-32/e_asinf.c (__ieee754_asinf): Likewise.
+ * sysdeps/ieee754/flt-32/e_atanhf.c (__ieee754_atanhf): Likewise.
+ * sysdeps/ieee754/flt-32/e_exp2f.c (__ieee754_exp2f): Use
+ math_check_force_underflow_nonneg.
+ * sysdeps/ieee754/flt-32/e_gammaf_r.c (__ieee754_gammaf_r):
+ Likewise.
+ * sysdeps/ieee754/flt-32/e_j1f.c (__ieee754_j1f): Use
+ math_check_force_underflow.
+ * sysdeps/ieee754/flt-32/e_jnf.c (__ieee754_jnf): Likewise.
+ * sysdeps/ieee754/flt-32/e_sinhf.c (__ieee754_sinhf): Likewise.
+ * sysdeps/ieee754/flt-32/k_sinf.c (__kernel_sinf): Likewise.
+ * sysdeps/ieee754/flt-32/k_tanf.c (__kernel_tanf): Likewise.
+ * sysdeps/ieee754/flt-32/s_asinhf.c (__asinhf): Likewise.
+ * sysdeps/ieee754/flt-32/s_atanf.c (__atanf): Likewise.
+ * sysdeps/ieee754/flt-32/s_erff.c (__erff): Likewise.
+ * sysdeps/ieee754/flt-32/s_expm1f.c (__expm1f): Likewise.
+ * sysdeps/ieee754/flt-32/s_log1pf.c (__log1pf): Likewise.
+ * sysdeps/ieee754/flt-32/s_tanhf.c (__tanhf): Likewise.
+ * sysdeps/ieee754/ldbl-128/e_asinl.c (__ieee754_asinl): Likewise.
+ * sysdeps/ieee754/ldbl-128/e_atanhl.c (__ieee754_atanhl):
+ Likewise.
+ * sysdeps/ieee754/ldbl-128/e_expl.c (__ieee754_expl): Use
+ math_check_force_underflow_nonneg.
+ * sysdeps/ieee754/ldbl-128/e_gammal_r.c (__ieee754_gammal_r):
+ Likewise.
+ * sysdeps/ieee754/ldbl-128/e_j1l.c (__ieee754_j1l): Use
+ math_check_force_underflow.
+ * sysdeps/ieee754/ldbl-128/e_jnl.c (__ieee754_jnl): Likewise.
+ * sysdeps/ieee754/ldbl-128/e_sinhl.c (__ieee754_sinhl): Likewise.
+ * sysdeps/ieee754/ldbl-128/k_sincosl.c (__kernel_sincosl):
+ Likewise.
+ * sysdeps/ieee754/ldbl-128/k_sinl.c (__kernel_sinl): Likewise.
+ * sysdeps/ieee754/ldbl-128/k_tanl.c (__kernel_tanl): Likewise.
+ * sysdeps/ieee754/ldbl-128/s_asinhl.c (__asinhl): Likewise.
+ * sysdeps/ieee754/ldbl-128/s_atanl.c (__atanl): Likewise.
+ * sysdeps/ieee754/ldbl-128/s_erfl.c (__erfl): Likewise.
+ * sysdeps/ieee754/ldbl-128/s_expm1l.c (__expm1l): Likewise.
+ * sysdeps/ieee754/ldbl-128/s_fmal.c (__fmal): Use math_force_eval
+ instead of volatile.
+ * sysdeps/ieee754/ldbl-128/s_log1pl.c (__log1pl): Use
+ math_check_force_underflow.
+ * sysdeps/ieee754/ldbl-128/s_tanhl.c (__tanhl): Likewise.
+ * sysdeps/ieee754/ldbl-128ibm/e_asinl.c (__ieee754_asinl): Use
+ math_check_force_underflow.
+ * sysdeps/ieee754/ldbl-128ibm/e_atanhl.c (__ieee754_atanhl):
+ Likewise.
+ * sysdeps/ieee754/ldbl-128ibm/e_gammal_r.c (__ieee754_gammal_r):
+ Use math_check_force_underflow_nonneg.
+ * sysdeps/ieee754/ldbl-128ibm/e_jnl.c (__ieee754_jnl): Use
+ math_check_force_underflow.
+ * sysdeps/ieee754/ldbl-128ibm/e_sinhl.c (__ieee754_sinhl):
+ Likewise.
+ * sysdeps/ieee754/ldbl-128ibm/k_sincosl.c (__kernel_sincosl):
+ Likewise.
+ * sysdeps/ieee754/ldbl-128ibm/k_sinl.c (__kernel_sinl): Likewise.
+ * sysdeps/ieee754/ldbl-128ibm/k_tanl.c (__kernel_tanl): Likewise.
+ * sysdeps/ieee754/ldbl-128ibm/s_asinhl.c (__asinhl): Likewise.
+ * sysdeps/ieee754/ldbl-128ibm/s_atanl.c (__atanl): Likewise.
+ * sysdeps/ieee754/ldbl-128ibm/s_erfl.c (__erfl): Likewise.
+ * sysdeps/ieee754/ldbl-128ibm/s_tanhl.c (__tanhl): Likewise.
+ * sysdeps/ieee754/ldbl-96/e_asinl.c (__ieee754_asinl): Likewise.
+ * sysdeps/ieee754/ldbl-96/e_atanhl.c (__ieee754_atanhl): Likewise.
+ * sysdeps/ieee754/ldbl-96/e_gammal_r.c (__ieee754_gammal_r): Use
+ math_check_force_underflow_nonneg.
+ * sysdeps/ieee754/ldbl-96/e_j1l.c (__ieee754_j1l): Use
+ math_check_force_underflow.
+ * sysdeps/ieee754/ldbl-96/e_jnl.c (__ieee754_jnl): Likewise.
+ * sysdeps/ieee754/ldbl-96/e_sinhl.c (__ieee754_sinhl): Likewise.
+ * sysdeps/ieee754/ldbl-96/k_sinl.c (__kernel_sinl): Likewise.
+ * sysdeps/ieee754/ldbl-96/k_tanl.c (__kernel_tanl): Use
+ math_check_force_underflow_nonneg.
+ * sysdeps/ieee754/ldbl-96/s_asinhl.c (__asinhl): Use
+ math_check_force_underflow.
+ * sysdeps/ieee754/ldbl-96/s_erfl.c (__erfl): Likewise.
+ * sysdeps/ieee754/ldbl-96/s_fmal.c (__fmal): Use math_force_eval
+ instead of volatile.
+ * sysdeps/ieee754/ldbl-96/s_tanhl.c (__tanhl): Use
+ math_check_force_underflow.
+
* math/s_nexttowardf.c (__nexttowardf): Use math_narrow_eval.
* stdlib/strtod_l.c: Include <math_private.h>.
(overflow_value): Use math_narrow_eval.
result = __scalbnl (1.0L + fractx, intx);
else
result = __scalbnl (__ieee754_expl (M_LN2l * fractx), intx);
- if (result < LDBL_MIN)
- {
- long double force_underflow = result * result;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow_nonneg (result);
return result;
}
else
else
__imag__ res = __ieee754_atan2 (ix, s);
}
- if (__real__ res < DBL_MIN)
- {
- volatile double force_underflow = __real__ res * __real__ res;
- (void) force_underflow;
- }
+ math_check_force_underflow_nonneg (__real__ res);
}
else
{
else
__imag__ res = __ieee754_atan2f (ix, s);
}
- if (__real__ res < FLT_MIN)
- {
- volatile float force_underflow = __real__ res * __real__ res;
- (void) force_underflow;
- }
+ math_check_force_underflow_nonneg (__real__ res);
}
else
{
else
__imag__ res = __ieee754_atan2l (ix, s);
}
- if (__real__ res < LDBL_MIN)
- {
- volatile long double force_underflow = __real__ res * __real__ res;
- (void) force_underflow;
- }
+ math_check_force_underflow_nonneg (__real__ res);
}
else
{
}
}
- if (fabs (__real__ res) < DBL_MIN)
- {
- volatile double force_underflow = __real__ res * __real__ res;
- (void) force_underflow;
- }
- if (fabs (__imag__ res) < DBL_MIN)
- {
- volatile double force_underflow = __imag__ res * __imag__ res;
- (void) force_underflow;
- }
+ math_check_force_underflow_complex (res);
}
return res;
}
}
- if (fabsf (__real__ res) < FLT_MIN)
- {
- volatile float force_underflow = __real__ res * __real__ res;
- (void) force_underflow;
- }
- if (fabsf (__imag__ res) < FLT_MIN)
- {
- volatile float force_underflow = __imag__ res * __imag__ res;
- (void) force_underflow;
- }
+ math_check_force_underflow_complex (res);
}
return res;
__imag__ res = 0.5 * __ieee754_atan2 (2.0 * __imag__ x, den);
}
- if (fabs (__real__ res) < DBL_MIN)
- {
- volatile double force_underflow = __real__ res * __real__ res;
- (void) force_underflow;
- }
- if (fabs (__imag__ res) < DBL_MIN)
- {
- volatile double force_underflow = __imag__ res * __imag__ res;
- (void) force_underflow;
- }
+ math_check_force_underflow_complex (res);
}
return res;
__imag__ res = 0.5f * __ieee754_atan2f (2.0f * __imag__ x, den);
}
- if (fabsf (__real__ res) < FLT_MIN)
- {
- volatile float force_underflow = __real__ res * __real__ res;
- (void) force_underflow;
- }
- if (fabsf (__imag__ res) < FLT_MIN)
- {
- volatile float force_underflow = __imag__ res * __imag__ res;
- (void) force_underflow;
- }
+ math_check_force_underflow_complex (res);
}
return res;
__imag__ res = 0.5L * __ieee754_atan2l (2.0L * __imag__ x, den);
}
- if (fabsl (__real__ res) < LDBL_MIN)
- {
- volatile long double force_underflow = __real__ res * __real__ res;
- (void) force_underflow;
- }
- if (fabsl (__imag__ res) < LDBL_MIN)
- {
- volatile long double force_underflow = __imag__ res * __imag__ res;
- (void) force_underflow;
- }
+ math_check_force_underflow_complex (res);
}
return res;
}
}
- if (fabsl (__real__ res) < LDBL_MIN)
- {
- volatile long double force_underflow = __real__ res * __real__ res;
- (void) force_underflow;
- }
- if (fabsl (__imag__ res) < LDBL_MIN)
- {
- volatile long double force_underflow = __imag__ res * __imag__ res;
- (void) force_underflow;
- }
+ math_check_force_underflow_complex (res);
}
return res;
__imag__ retval = __ieee754_sinh (__real__ x) * sinix;
}
- if (fabs (__real__ retval) < DBL_MIN)
- {
- volatile double force_underflow
- = __real__ retval * __real__ retval;
- (void) force_underflow;
- }
- if (fabs (__imag__ retval) < DBL_MIN)
- {
- volatile double force_underflow
- = __imag__ retval * __imag__ retval;
- (void) force_underflow;
- }
+ math_check_force_underflow_complex (retval);
}
else
{
__imag__ retval = __ieee754_sinhf (__real__ x) * sinix;
}
- if (fabsf (__real__ retval) < FLT_MIN)
- {
- volatile float force_underflow
- = __real__ retval * __real__ retval;
- (void) force_underflow;
- }
- if (fabsf (__imag__ retval) < FLT_MIN)
- {
- volatile float force_underflow
- = __imag__ retval * __imag__ retval;
- (void) force_underflow;
- }
+ math_check_force_underflow_complex (retval);
}
else
{
__imag__ retval = __ieee754_sinhl (__real__ x) * sinix;
}
- if (fabsl (__real__ retval) < LDBL_MIN)
- {
- volatile long double force_underflow
- = __real__ retval * __real__ retval;
- (void) force_underflow;
- }
- if (fabsl (__imag__ retval) < LDBL_MIN)
- {
- volatile long double force_underflow
- = __imag__ retval * __imag__ retval;
- (void) force_underflow;
- }
+ math_check_force_underflow_complex (retval);
}
else
{
__real__ retval = exp_val * cosix;
__imag__ retval = exp_val * sinix;
}
- if (fabs (__real__ retval) < DBL_MIN)
- {
- volatile double force_underflow
- = __real__ retval * __real__ retval;
- (void) force_underflow;
- }
- if (fabs (__imag__ retval) < DBL_MIN)
- {
- volatile double force_underflow
- = __imag__ retval * __imag__ retval;
- (void) force_underflow;
- }
+ math_check_force_underflow_complex (retval);
}
else
{
__real__ retval = exp_val * cosix;
__imag__ retval = exp_val * sinix;
}
- if (fabsf (__real__ retval) < FLT_MIN)
- {
- volatile float force_underflow
- = __real__ retval * __real__ retval;
- (void) force_underflow;
- }
- if (fabsf (__imag__ retval) < FLT_MIN)
- {
- volatile float force_underflow
- = __imag__ retval * __imag__ retval;
- (void) force_underflow;
- }
+ math_check_force_underflow_complex (retval);
}
else
{
__real__ retval = exp_val * cosix;
__imag__ retval = exp_val * sinix;
}
- if (fabsl (__real__ retval) < LDBL_MIN)
- {
- volatile long double force_underflow
- = __real__ retval * __real__ retval;
- (void) force_underflow;
- }
- if (fabsl (__imag__ retval) < LDBL_MIN)
- {
- volatile long double force_underflow
- = __imag__ retval * __imag__ retval;
- (void) force_underflow;
- }
+ math_check_force_underflow_complex (retval);
}
else
{
if (absx == 1.0 && scale == 0)
{
- double absy2 = absy * absy;
- if (absy2 <= DBL_MIN * 2.0)
- {
- double force_underflow = absy2 * absy2;
- __real__ result = absy2 / 2.0;
- math_force_eval (force_underflow);
- }
- else
- __real__ result = __log1p (absy2) / 2.0;
+ __real__ result = __log1p (absy * absy) / 2.0;
+ math_check_force_underflow_nonneg (__real__ result);
}
else if (absx > 1.0 && absx < 2.0 && absy < 1.0 && scale == 0)
{
if (absx == 1.0 && scale == 0)
{
- double absy2 = absy * absy;
- if (absy2 <= DBL_MIN * 2.0 * M_LN10)
- {
- double force_underflow = absy2 * absy2;
- __real__ result = absy2 * (M_LOG10E / 2.0);
- math_force_eval (force_underflow);
- }
- else
- __real__ result = __log1p (absy2) * (M_LOG10E / 2.0);
+ __real__ result = __log1p (absy * absy) * (M_LOG10E / 2.0);
+ math_check_force_underflow_nonneg (__real__ result);
}
else if (absx > 1.0 && absx < 2.0 && absy < 1.0 && scale == 0)
{
if (absx == 1.0f && scale == 0)
{
- float absy2 = absy * absy;
- if (absy2 <= FLT_MIN * 2.0f * (float) M_LN10)
- {
- float force_underflow = absy2 * absy2;
- __real__ result = absy2 * ((float) M_LOG10E / 2.0f);
- math_force_eval (force_underflow);
- }
- else
- __real__ result = __log1pf (absy2) * ((float) M_LOG10E / 2.0f);
+ __real__ result = __log1pf (absy * absy) * ((float) M_LOG10E / 2.0f);
+ math_check_force_underflow_nonneg (__real__ result);
}
else if (absx > 1.0f && absx < 2.0f && absy < 1.0f && scale == 0)
{
if (absx == 1.0L && scale == 0)
{
- long double absy2 = absy * absy;
- if (absy2 <= LDBL_MIN * 2.0L * M_LN10l)
- {
- long double force_underflow = absy2 * absy2;
- __real__ result = absy2 * (M_LOG10El / 2.0);
- math_force_eval (force_underflow);
- }
- else
- __real__ result = __log1pl (absy2) * (M_LOG10El / 2.0L);
+ __real__ result = __log1pl (absy * absy) * (M_LOG10El / 2.0L);
+ math_check_force_underflow_nonneg (__real__ result);
}
else if (absx > 1.0L && absx < 2.0L && absy < 1.0L && scale == 0)
{
if (absx == 1.0f && scale == 0)
{
- float absy2 = absy * absy;
- if (absy2 <= FLT_MIN * 2.0f)
- {
- float force_underflow = absy2 * absy2;
- __real__ result = absy2 / 2.0f;
- math_force_eval (force_underflow);
- }
- else
- __real__ result = __log1pf (absy2) / 2.0f;
+ __real__ result = __log1pf (absy * absy) / 2.0f;
+ math_check_force_underflow_nonneg (__real__ result);
}
else if (absx > 1.0f && absx < 2.0f && absy < 1.0f && scale == 0)
{
if (absx == 1.0L && scale == 0)
{
- long double absy2 = absy * absy;
- if (absy2 <= LDBL_MIN * 2.0L)
- {
- long double force_underflow = absy2 * absy2;
- __real__ result = absy2 / 2.0L;
- math_force_eval (force_underflow);
- }
- else
- __real__ result = __log1pl (absy2) / 2.0L;
+ __real__ result = __log1pl (absy * absy) / 2.0L;
+ math_check_force_underflow_nonneg (__real__ result);
}
else if (absx > 1.0L && absx < 2.0L && absy < 1.0L && scale == 0)
{
__imag__ retval = __ieee754_sinh (__imag__ x) * cosix;
}
- if (fabs (__real__ retval) < DBL_MIN)
- {
- volatile double force_underflow
- = __real__ retval * __real__ retval;
- (void) force_underflow;
- }
- if (fabs (__imag__ retval) < DBL_MIN)
- {
- volatile double force_underflow
- = __imag__ retval * __imag__ retval;
- (void) force_underflow;
- }
+ math_check_force_underflow_complex (retval);
}
else
{
__imag__ retval = __ieee754_sinhf (__imag__ x) * cosix;
}
- if (fabsf (__real__ retval) < FLT_MIN)
- {
- volatile float force_underflow
- = __real__ retval * __real__ retval;
- (void) force_underflow;
- }
- if (fabsf (__imag__ retval) < FLT_MIN)
- {
- volatile float force_underflow
- = __imag__ retval * __imag__ retval;
- (void) force_underflow;
- }
+ math_check_force_underflow_complex (retval);
}
else
{
__imag__ retval = __ieee754_cosh (__real__ x) * sinix;
}
- if (fabs (__real__ retval) < DBL_MIN)
- {
- volatile double force_underflow
- = __real__ retval * __real__ retval;
- (void) force_underflow;
- }
- if (fabs (__imag__ retval) < DBL_MIN)
- {
- volatile double force_underflow
- = __imag__ retval * __imag__ retval;
- (void) force_underflow;
- }
+ math_check_force_underflow_complex (retval);
}
else
{
__imag__ retval = __ieee754_coshf (__real__ x) * sinix;
}
- if (fabsf (__real__ retval) < FLT_MIN)
- {
- volatile float force_underflow
- = __real__ retval * __real__ retval;
- (void) force_underflow;
- }
- if (fabsf (__imag__ retval) < FLT_MIN)
- {
- volatile float force_underflow
- = __imag__ retval * __imag__ retval;
- (void) force_underflow;
- }
+ math_check_force_underflow_complex (retval);
}
else
{
__imag__ retval = __ieee754_coshl (__real__ x) * sinix;
}
- if (fabsl (__real__ retval) < LDBL_MIN)
- {
- volatile long double force_underflow
- = __real__ retval * __real__ retval;
- (void) force_underflow;
- }
- if (fabsl (__imag__ retval) < LDBL_MIN)
- {
- volatile long double force_underflow
- = __imag__ retval * __imag__ retval;
- (void) force_underflow;
- }
+ math_check_force_underflow_complex (retval);
}
else
{
__imag__ retval = __ieee754_sinhl (__imag__ x) * cosix;
}
- if (fabsl (__real__ retval) < LDBL_MIN)
- {
- volatile long double force_underflow
- = __real__ retval * __real__ retval;
- (void) force_underflow;
- }
- if (fabsl (__imag__ retval) < LDBL_MIN)
- {
- volatile long double force_underflow
- = __imag__ retval * __imag__ retval;
- (void) force_underflow;
- }
+ math_check_force_underflow_complex (retval);
}
else
{
s = __scalbn (s, scale);
}
- if (fabs (r) < DBL_MIN)
- {
- double force_underflow = r * r;
- math_force_eval (force_underflow);
- }
- if (fabs (s) < DBL_MIN)
- {
- double force_underflow = s * s;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (r);
+ math_check_force_underflow (s);
__real__ res = r;
__imag__ res = __copysign (s, __imag__ x);
s = __scalbnf (s, scale);
}
- if (fabsf (r) < FLT_MIN)
- {
- float force_underflow = r * r;
- math_force_eval (force_underflow);
- }
- if (fabsf (s) < FLT_MIN)
- {
- float force_underflow = s * s;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (r);
+ math_check_force_underflow (s);
__real__ res = r;
__imag__ res = __copysignf (s, __imag__ x);
s = __scalbnl (s, scale);
}
- if (fabsl (r) < LDBL_MIN)
- {
- long double force_underflow = r * r;
- math_force_eval (force_underflow);
- }
- if (fabsl (s) < LDBL_MIN)
- {
- long double force_underflow = s * s;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (r);
+ math_check_force_underflow (s);
__real__ res = r;
__imag__ res = __copysignl (s, __imag__ x);
__real__ res = sinrx * cosrx / den;
__imag__ res = sinhix * coshix / den;
}
- if (fabs (__real__ res) < DBL_MIN)
- {
- double force_underflow = __real__ res * __real__ res;
- math_force_eval (force_underflow);
- }
- if (fabs (__imag__ res) < DBL_MIN)
- {
- double force_underflow = __imag__ res * __imag__ res;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow_complex (res);
}
return res;
__real__ res = sinrx * cosrx / den;
__imag__ res = sinhix * coshix / den;
}
- if (fabsf (__real__ res) < FLT_MIN)
- {
- float force_underflow = __real__ res * __real__ res;
- math_force_eval (force_underflow);
- }
- if (fabsf (__imag__ res) < FLT_MIN)
- {
- float force_underflow = __imag__ res * __imag__ res;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow_complex (res);
}
return res;
__real__ res = sinhrx * coshrx / den;
__imag__ res = sinix * cosix / den;
}
- if (fabs (__real__ res) < DBL_MIN)
- {
- double force_underflow = __real__ res * __real__ res;
- math_force_eval (force_underflow);
- }
- if (fabs (__imag__ res) < DBL_MIN)
- {
- double force_underflow = __imag__ res * __imag__ res;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow_complex (res);
}
return res;
__real__ res = sinhrx * coshrx / den;
__imag__ res = sinix * cosix / den;
}
- if (fabsf (__real__ res) < FLT_MIN)
- {
- float force_underflow = __real__ res * __real__ res;
- math_force_eval (force_underflow);
- }
- if (fabsf (__imag__ res) < FLT_MIN)
- {
- float force_underflow = __imag__ res * __imag__ res;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow_complex (res);
}
return res;
__real__ res = sinhrx * coshrx / den;
__imag__ res = sinix * cosix / den;
}
- if (fabsl (__real__ res) < LDBL_MIN)
- {
- long double force_underflow = __real__ res * __real__ res;
- math_force_eval (force_underflow);
- }
- if (fabsl (__imag__ res) < LDBL_MIN)
- {
- long double force_underflow = __imag__ res * __imag__ res;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow_complex (res);
}
return res;
__real__ res = sinrx * cosrx / den;
__imag__ res = sinhix * coshix / den;
}
- if (fabsl (__real__ res) < LDBL_MIN)
- {
- long double force_underflow = __real__ res * __real__ res;
- math_force_eval (force_underflow);
- }
- if (fabsl (__imag__ res) < LDBL_MIN)
- {
- long double force_underflow = __imag__ res * __imag__ res;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow_complex (res);
}
return res;
|| (round_limb & ((((mp_limb_t) 1) << round_bit) - 1)) != 0))
{
__set_errno (ERANGE);
- volatile FLOAT force_underflow_exception = MIN_VALUE * MIN_VALUE;
- (void) force_underflow_exception;
+ FLOAT force_underflow = MIN_VALUE * MIN_VALUE;
+ math_force_eval (force_underflow);
}
}
})
#endif
+#define fabs_tg(x) __builtin_choose_expr \
+ (__builtin_types_compatible_p (__typeof (x), float), \
+ __builtin_fabsf (x), \
+ __builtin_choose_expr \
+ (__builtin_types_compatible_p (__typeof (x), double), \
+ __builtin_fabs (x), __builtin_fabsl (x)))
+#define min_of_type(type) __builtin_choose_expr \
+ (__builtin_types_compatible_p (type, float), \
+ FLT_MIN, \
+ __builtin_choose_expr \
+ (__builtin_types_compatible_p (type, double), \
+ DBL_MIN, LDBL_MIN))
+
+/* If X (which is not a NaN) is subnormal, force an underflow
+ exception. */
+#define math_check_force_underflow(x) \
+ do \
+ { \
+ __typeof (x) force_underflow_tmp = (x); \
+ if (fabs_tg (force_underflow_tmp) \
+ < min_of_type (__typeof (force_underflow_tmp))) \
+ { \
+ __typeof (force_underflow_tmp) force_underflow_tmp2 \
+ = force_underflow_tmp * force_underflow_tmp; \
+ math_force_eval (force_underflow_tmp2); \
+ } \
+ } \
+ while (0)
+/* Likewise, but X is also known to be nonnegative. */
+#define math_check_force_underflow_nonneg(x) \
+ do \
+ { \
+ __typeof (x) force_underflow_tmp = (x); \
+ if (force_underflow_tmp \
+ < min_of_type (__typeof (force_underflow_tmp))) \
+ { \
+ __typeof (force_underflow_tmp) force_underflow_tmp2 \
+ = force_underflow_tmp * force_underflow_tmp; \
+ math_force_eval (force_underflow_tmp2); \
+ } \
+ } \
+ while (0)
+/* Likewise, for both real and imaginary parts of a complex
+ result. */
+#define math_check_force_underflow_complex(x) \
+ do \
+ { \
+ __typeof (x) force_underflow_complex_tmp = (x); \
+ math_check_force_underflow (__real__ force_underflow_complex_tmp); \
+ math_check_force_underflow (__imag__ force_underflow_complex_tmp); \
+ } \
+ while (0)
/* The standards only specify one variant of the fenv.h interfaces.
But at least for some architectures we can be more efficient if we
if (k < 0x3e500000)
{
- if (fabs (x) < DBL_MIN)
- {
- double force_underflow = x * x;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (x);
return x; /* for x->0 => sin(x)=x */
}
/*----------------------2^-26 <= |x| < 2^ -3 -----------------*/
if (__glibc_unlikely (xa < 0x1.0p-28))
{
math_force_eval (huge + x);
- if (fabs (x) < DBL_MIN)
- {
- double force_underflow = x * x;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (x);
return x;
}
check_uflow_ret:
if (retval < DBL_MIN)
{
-#if FLT_EVAL_METHOD != 0
- volatile
-#endif
- double force_underflow = tiny * tiny;
+ double force_underflow = tiny * tiny;
math_force_eval (force_underflow);
}
if (retval == 0)
else
{
result *= scale_u.d;
- if (result < DBL_MIN)
- {
- double force_underflow = result * result;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow_nonneg (result);
return result;
}
}
double tret = M_PI / (-x * sinpix
* gamma_positive (-x, &exp2_adj));
ret = __scalbn (tret, -exp2_adj);
- if (ret < DBL_MIN)
- {
- double force_underflow = ret * ret;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow_nonneg (ret);
}
}
ret = math_narrow_eval (ret);
if (huge + x > one) /* inexact if x!=0 necessary */
{
double ret = 0.5 * x;
- if (fabs (ret) < DBL_MIN)
- {
- double force_underflow = ret * ret;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (ret);
return ret;
}
}
}
if (ret == 0)
ret = __copysign (DBL_MIN, ret) * DBL_MIN;
- else if (fabs (ret) < DBL_MIN)
- {
- double force_underflow = ret * ret;
- math_force_eval (force_underflow);
- }
+ else
+ math_check_force_underflow (ret);
return ret;
}
strong_alias (__ieee754_jn, __jn_finite)
if (ix < 0x40360000) /* |x|<22 */
{
if (__glibc_unlikely (ix < 0x3e300000)) { /* |x|<2**-28 */
- if (fabs (x) < DBL_MIN)
- {
- double force_underflow = x * x;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (x);
if (shuge + x > one)
return x;
/* sinh(tiny) = tiny with inexact */
ix = hx & 0x7fffffff;
if (__glibc_unlikely (ix < 0x3e300000)) /* |x|<2**-28 */
{
- if (fabs (x) < DBL_MIN)
- {
- double force_underflow = x * x;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (x);
if (huge + x > one)
return x; /* return x inexact except 0 */
}
{
if (u < A)
{
- if (u < DBL_MIN)
- {
- double force_underflow = x * x;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow_nonneg (u);
return x;
}
else
{
/* Avoid spurious underflow. */
double ret = 0.0625 * (16.0 * x + (16.0 * efx) * x);
- if (fabs (ret) < DBL_MIN)
- {
- double force_underflow = ret * ret;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (ret);
return ret;
}
return x + efx * x;
}
else if (hx < 0x3c900000) /* when |x|<2**-54, return x */
{
- if (fabs (x) < DBL_MIN)
- {
- double force_underflow = x * x;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (x);
t = huge + x; /* return x with inexact flags when x!=0 */
return x - (t - (huge + x));
}
&& w.ieee.mantissa1 == 0
&& w.ieee.mantissa0 == 0)))
{
- volatile double force_underflow = x * y;
- (void) force_underflow;
+ double force_underflow = x * y;
+ math_force_eval (force_underflow);
}
return v.d * 0x1p-54;
}
math_force_eval (two54 + x); /* raise inexact */
if (ax < 0x3c900000) /* |x| < 2**-54 */
{
- if (fabs (x) < DBL_MIN)
- {
- double force_underflow = x * x;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (x);
return x;
}
else
k = 0x7fffffff & m; /* no sign */
if (k < 0x3e500000) /* if x->0 =>sin(x)=x */
{
- if (fabs (x) < DBL_MIN)
- {
- double force_underflow = x * x;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (x);
retval = x;
}
/*---------------------------- 2^-26 < |x|< 0.25 ----------------------*/
/* (I) The case abs(x) <= 1.259e-8 */
if (w <= g1.d)
{
- if (w < DBL_MIN)
- {
- double force_underflow = x * x;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow_nonneg (w);
retval = x;
goto ret;
}
return x; /* x == +-0 */
if (ix < 0x3c800000) /* |x|<2**-55 */
{
- if (fabs (x) < DBL_MIN)
- {
- double force_underflow = x * x;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (x);
return x * (one + x); /* tanh(small) = small */
}
if (ix >= 0x3ff00000) /* |x|>=1 */
return (x-x)/(x-x); /* asin(|x|>1) is NaN */
} else if (ix<0x3f000000) { /* |x|<0.5 */
if(ix<0x32000000) { /* if |x| < 2**-27 */
- if (fabsf (x) < FLT_MIN)
- {
- float force_underflow = x * x;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (x);
if(huge+x>one) return x;/* return x with inexact if x!=0*/
} else {
t = x*x;
if (__glibc_unlikely (xa < 0x1.0p-28f))
{
math_force_eval (huge + x);
- if (fabsf (x) < FLT_MIN)
- {
- float force_underflow = x * x;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (x);
return x;
}
else
{
result *= scale_u.f;
- if (result < FLT_MIN)
- {
- float force_underflow = result * result;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow_nonneg (result);
return result;
}
}
float tret = (float) M_PI / (-x * sinpix
* gammaf_positive (-x, &exp2_adj));
ret = __scalbnf (tret, -exp2_adj);
- if (ret < FLT_MIN)
- {
- float force_underflow = ret * ret;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow_nonneg (ret);
}
}
ret = math_narrow_eval (ret);
if(__builtin_expect(ix<0x32000000, 0)) { /* |x|<2**-27 */
if(huge+x>one) { /* inexact if x!=0 necessary */
float ret = (float) 0.5 * x;
- if (fabsf (ret) < FLT_MIN) {
- float force_underflow = ret * ret;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (ret);
return ret;
}
}
}
if (ret == 0)
ret = __copysignf (FLT_MIN, ret) * FLT_MIN;
- else if (fabsf (ret) < FLT_MIN) {
- float force_underflow = ret * ret;
- math_force_eval (force_underflow);
- }
+ else
+ math_check_force_underflow (ret);
return ret;
}
strong_alias (__ieee754_jnf, __jnf_finite)
/* |x| in [0,22], return sign(x)*0.5*(E+E/(E+1))) */
if (ix < 0x41b00000) { /* |x|<22 */
if (__builtin_expect(ix<0x31800000, 0)) { /* |x|<2**-28 */
- if (fabsf (x) < FLT_MIN)
- {
- float force_underflow = x * x;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (x);
if(shuge+x>one) return x;/* sinh(tiny) = tiny with inexact */
}
t = __expm1f(fabsf(x));
ix &= 0x7fffffff; /* high word of x */
if(ix<0x32000000) /* |x| < 2**-27 */
{
- if (fabsf (x) < FLT_MIN)
- {
- float force_underflow = x * x;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (x);
if ((int) x == 0)
return x; /* generate inexact */
}
if((ix|(iy+1))==0) return one/fabsf(x);
else if (iy == 1)
{
- if (fabsf (x) < FLT_MIN)
- {
- float force_underflow = x * x;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (x);
return x;
}
else
GET_FLOAT_WORD(hx,x);
ix = hx&0x7fffffff;
if(__builtin_expect(ix< 0x38000000, 0)) { /* |x|<2**-14 */
- if (fabsf (x) < FLT_MIN)
- {
- float force_underflow = x * x;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (x);
if(huge+x>one) return x; /* return x inexact except 0 */
}
if(__builtin_expect(ix>0x47000000, 0)) { /* |x| > 2**14 */
else return -atanhi[3]-atanlo[3];
} if (ix < 0x3ee00000) { /* |x| < 0.4375 */
if (ix < 0x31000000) { /* |x| < 2^-29 */
- if (fabsf (x) < FLT_MIN)
- {
- float force_underflow = x * x;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (x);
if(huge+x>one) return x; /* raise inexact */
}
id = -1;
{
/* Avoid spurious underflow. */
float ret = 0.0625f * (16.0f * x + (16.0f * efx) * x);
- if (fabsf (ret) < FLT_MIN)
- {
- float force_underflow = ret * ret;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (ret);
return ret;
}
return x + efx*x;
c = (hi-x)-lo;
}
else if(hx < 0x33000000) { /* when |x|<2**-25, return x */
- if (fabsf (x) < FLT_MIN)
- {
- float force_underflow = x * x;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (x);
t = huge+x; /* return x with inexact flags when x!=0 */
return x - (t-(huge+x));
}
math_force_eval(two25+x); /* raise inexact */
if (ax<0x24800000) /* |x| < 2**-54 */
{
- if (fabsf (x) < FLT_MIN)
- {
- float force_underflow = x * x;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (x);
return x;
}
else
return x; /* x == +-0 */
if (ix<0x24000000) /* |x|<2**-55 */
{
- if (fabsf (x) < FLT_MIN)
- {
- float force_underflow = x * x;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (x);
return x*(one+x); /* tanh(small) = small */
}
if (ix>=0x3f800000) { /* |x|>=1 */
{
if (ix < 0x3fc60000) /* |x| < 2**-57 */
{
- if (fabsl (x) < LDBL_MIN)
- {
- long double force_underflow = x * x;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (x);
long double force_inexact = huge + x;
math_force_eval (force_inexact);
return x; /* return x with inexact if x!=0 */
}
if(ix<0x3fc60000 && (huge+x)>zero) /* x < 2^-57 */
{
- if (fabsl (x) < LDBL_MIN)
- {
- long double force_underflow = x * x;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (x);
return x;
}
else
{
result *= scale_u.d;
- if (result < LDBL_MIN)
- {
- long double force_underflow = result * result;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow_nonneg (result);
return result;
}
}
ret = M_PIl / (-x * sinpix
* gammal_positive (-x, &exp2_adj));
ret = __scalbnl (ret, -exp2_adj);
- if (ret < LDBL_MIN)
- {
- long double force_underflow = ret * ret;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow_nonneg (ret);
}
}
}
if (xx <= 0x1p-58L)
{
long double ret = x * 0.5L;
- if (fabsl (ret) < LDBL_MIN)
- {
- long double force_underflow = ret * ret;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (ret);
return ret;
}
if (xx <= 2.0L)
}
if (ret == 0)
ret = __copysignl (LDBL_MIN, ret) * LDBL_MIN;
- else if (fabsl (ret) < LDBL_MIN)
- {
- long double force_underflow = ret * ret;
- math_force_eval (force_underflow);
- }
+ else
+ math_check_force_underflow (ret);
return ret;
}
strong_alias (__ieee754_jnl, __jnl_finite)
{
if (ix < 0x3fc60000) /* |x| < 2^-57 */
{
- if (fabsl (x) < LDBL_MIN)
- {
- long double force_underflow = x * x;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (x);
if (shuge + x > one)
return x; /* sinh(tiny) = tiny with inexact */
}
polynomial of degree 16(17). */
if (tix < 0x3fc60000) /* |x| < 2^-57 */
{
- if (fabsl (x) < LDBL_MIN)
- {
- long double force_underflow = x * x;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (x);
if (!((int)x)) /* generate inexact */
{
*sinx = x;
polynomial of degree 17. */
if (tix < 0x3fc60000) /* |x| < 2^-57 */
{
- if (fabsl (x) < LDBL_MIN)
- {
- long double force_underflow = x * x;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (x);
if (!((int)x)) return x; /* generate inexact */
}
z = x * x;
return one / fabs (x);
else if (iy == 1)
{
- if (fabsl (x) < LDBL_MIN)
- {
- long double force_underflow = x * x;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (x);
return x;
}
else
return x + x; /* x is inf or NaN */
if (ix < 0x3fc70000)
{ /* |x| < 2^ -56 */
- if (fabsl (x) < LDBL_MIN)
- {
- long double force_underflow = x * x;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (x);
if (huge + x > one)
return x; /* return x inexact except 0 */
}
if (k <= 0x3fc50000) /* |x| < 2**-58 */
{
- if (fabsl (x) < LDBL_MIN)
- {
- long double force_underflow = x * x;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (x);
/* Raise inexact. */
if (huge + x > 0.0)
return x;
{
/* Avoid spurious underflow. */
long double ret = 0.0625 * (16.0 * x + (16.0 * efx) * x);
- if (fabsl (ret) < LDBL_MIN)
- {
- long double force_underflow = ret * ret;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (ret);
return ret;
}
return x + efx * x;
when the result does underflow. */
if (fabsl (x) < 0x1p-113L)
{
- if (fabsl (x) < LDBL_MIN)
- {
- long double force_underflow = x * x;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (x);
return x;
}
&& w.ieee.mantissa1 == 0
&& w.ieee.mantissa0 == 0)))
{
- volatile long double force_underflow = x * y;
- (void) force_underflow;
+ long double force_underflow = x * y;
+ math_force_eval (force_underflow);
}
return v.d * 0x1p-114L;
}
if ((hx & 0x7fffffff) < 0x3f8e0000)
{
- if (fabsl (xm1) < LDBL_MIN)
- {
- long double force_underflow = xm1 * xm1;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (xm1);
if ((int) xm1 == 0)
return xm1;
}
return x; /* x == +- 0 */
if (ix < 0x3fc60000) /* |x| < 2^-57 */
{
- if (fabsl (x) < LDBL_MIN)
- {
- long double force_underflow = x * x;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (x);
return x * (one + tiny); /* tanh(small) = small */
}
u.parts32.w0 = ix; /* Absolute value of x. */
{
if (a < 6.938893903907228e-18L) /* |x| < 2**-57 */
{
- if (fabsl (x) < LDBL_MIN)
- {
- long double force_underflow = x * x;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (x);
long double force_inexact = huge + x;
math_force_eval (force_inexact);
return x; /* return x with inexact if x!=0 */
}
if(ix<0x3c70000000000000LL&&(huge+x)>zero) /* x<2**-56 */
{
- if (fabsl (x) < LDBL_MIN)
- {
- long double force_underflow = x * x;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (x);
return x;
}
x = fabsl (x);
ret = M_PIl / (-x * sinpix
* gammal_positive (-x, &exp2_adj));
ret = __scalbnl (ret, -exp2_adj);
- if (ret < LDBL_MIN)
- {
- long double force_underflow = ret * ret;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow_nonneg (ret);
}
}
}
}
if (ret == 0)
ret = __copysignl (LDBL_MIN, ret) * LDBL_MIN;
- else if (fabsl (ret) < LDBL_MIN)
- {
- long double force_underflow = ret * ret;
- math_force_eval (force_underflow);
- }
+ else
+ math_check_force_underflow (ret);
return ret;
}
strong_alias (__ieee754_jnl, __jnl_finite)
/* |x| in [0,40], return sign(x)*0.5*(E+E/(E+1))) */
if (ix < 0x4044000000000000LL) { /* |x|<40 */
if (ix<0x3c90000000000000LL) { /* |x|<2**-54 */
- if (fabsl (x) < LDBL_MIN)
- {
- long double force_underflow = x * x;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (x);
if(shuge+x>one) return x;/* sinhl(tiny) = tiny with inexact */
}
t = __expm1l(fabsl(x));
polynomial of degree 16(17). */
if (tix < 0x3c600000) /* |x| < 2^-57 */
{
- if (fabsl (x) < LDBL_MIN)
- {
- long double force_underflow = x * x;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (x);
if (!((int)x)) /* generate inexact */
{
*sinx = x;
polynomial of degree 17. */
if (tix < 0x3c600000) /* |x| < 2^-57 */
{
- if (fabsl (x) < LDBL_MIN)
- {
- long double force_underflow = x * x;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (x);
if (!((int)x)) return x; /* generate inexact */
}
z = x * x;
return one / fabs (x);
else if (iy == 1)
{
- if (fabsl (x) < LDBL_MIN)
- {
- long double force_underflow = x * x;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (x);
return x;
}
else
ix = hx&0x7fffffffffffffffLL;
if(ix>=0x7ff0000000000000LL) return x+x; /* x is inf or NaN */
if(ix< 0x3c70000000000000LL) { /* |x|<2**-56 */
- if (fabsl (x) < LDBL_MIN)
- {
- long double force_underflow = x * x;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (x);
if(huge+x>one) return x; /* return x inexact except 0 */
}
if(ix>0x4370000000000000LL) { /* |x| > 2**56 */
if (k <= 0x3c800000) /* |x| <= 2**-55. */
{
- if (fabsl (x) < LDBL_MIN)
- {
- long double force_underflow = x * x;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (x);
/* Raise inexact. */
if (1e300L + x > 0.0)
return x;
if (x == 0)
return x;
long double ret = 0.0625 * (16.0 * x + (16.0 * efx) * x);
- if (fabsl (ret) < LDBL_MIN)
- {
- long double force_underflow = ret * ret;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (ret);
return ret;
}
return x + efx * x;
return x; /* x == +-0 */
if (ix<0x3c60000000000000LL) /* |x|<2**-57 */
{
- if (fabsl (x) < LDBL_MIN)
- {
- long double force_underflow = x * x;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (x);
return x*(one+x); /* tanh(small) = small */
}
if (ix>=0x3ff0000000000000LL) { /* |x|>=1 */
{ /* |x|<0.5 */
if (ix < 0x3fde8000)
{ /* if |x| < 2**-33 */
- if (fabsl (x) < LDBL_MIN)
- {
- long double force_underflow = x * x;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (x);
if (huge + x > one)
return x; /* return x with inexact if x!=0 */
}
return x/zero;
if(ix<0x3fdf) {
math_force_eval(huge+x);
- if (fabsl (x) < LDBL_MIN)
- {
- long double force_underflow = x * x;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (x);
return x; /* x<2**-32 */
}
SET_LDOUBLE_EXP(x,ix);
ret = M_PIl / (-x * sinpix
* gammal_positive (-x, &exp2_adj));
ret = __scalbnl (ret, -exp2_adj);
- if (ret < LDBL_MIN)
- {
- long double force_underflow = ret * ret;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow_nonneg (ret);
}
}
}
if (huge + x > one) /* inexact if x!=0 necessary */
{
long double ret = 0.5 * x;
- if (fabsl (ret) < LDBL_MIN)
- {
- long double force_underflow = ret * ret;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (ret);
return ret;
}
}
}
if (ret == 0)
ret = __copysignl (LDBL_MIN, ret) * LDBL_MIN;
- else if (fabsl (ret) < LDBL_MIN)
- {
- long double force_underflow = ret * ret;
- math_force_eval (force_underflow);
- }
+ else
+ math_check_force_underflow (ret);
return ret;
}
strong_alias (__ieee754_jnl, __jnl_finite)
/* |x| in [0,25], return sign(x)*0.5*(E+E/(E+1))) */
if (ix < 0x4003 || (ix == 0x4003 && i0 <= 0xc8000000)) { /* |x|<25 */
if (ix<0x3fdf) { /* |x|<2**-32 */
- if (fabsl (x) < LDBL_MIN)
- {
- long double force_underflow = x * x;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (x);
if(shuge+x>one) return x;/* sinh(tiny) = tiny with inexact */
}
t = __expm1l(fabsl(x));
polynomial of degree 17. */
if (absx < 0x1p-33L)
{
- if (fabsl (x) < LDBL_MIN)
- {
- long double force_underflow = x * x;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (x);
if (!((int)x)) return x; /* generate inexact */
}
z = x * x;
return one / fabsl (x);
else if (iy == 1)
{
- if (absx < LDBL_MIN)
- {
- long double force_underflow = x * x;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow_nonneg (absx);
return x;
}
else
GET_LDOUBLE_EXP(hx,x);
ix = hx&0x7fff;
if(__builtin_expect(ix< 0x3fde, 0)) { /* |x|<2**-34 */
- if (fabsl (x) < LDBL_MIN)
- {
- long double force_underflow = x * x;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (x);
if(huge+x>one) return x; /* return x inexact except 0 */
}
if(__builtin_expect(ix>0x4020,0)) { /* |x| > 2**34 */
{
/* Avoid spurious underflow. */
long double ret = 0.0625 * (16.0 * x + (16.0 * efx) * x);
- if (fabsl (ret) < LDBL_MIN)
- {
- long double force_underflow = ret * ret;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (ret);
return ret;
}
return x + efx * x;
&& w.ieee.mantissa1 == 0
&& w.ieee.mantissa0 == 0x80000000)))
{
- volatile long double force_underflow = x * y;
- (void) force_underflow;
+ long double force_underflow = x * y;
+ math_force_eval (force_underflow);
}
return v.d * 0x1p-65L;
}
return x; /* x == +- 0 */
if (ix<0x3fc8) /* |x|<2**-55 */
{
- if (fabsl (x) < LDBL_MIN)
- {
- long double force_underflow = x * x;
- math_force_eval (force_underflow);
- }
+ math_check_force_underflow (x);
return x*(one+tiny); /* tanh(small) = small */
}
if (ix>=0x3fff) { /* |x|>=1 */
projects / platform / upstream / glibc.git / commitdiff