// CHECK-LABEL: define void @bar(
void bar() {
float f;
double d;
long double ld;
// LLVM's hex representation of float constants is really unfortunate;
// basically it does a float-to-double "conversion" and then prints the
// hex form of that. That gives us weird artifacts like exponents
// that aren't numerically similar to the original exponent and
// significand bit-patterns that are offset by three bits (because
// the exponent was expanded from 8 bits to 11).
//
// 0xAE98 == 1010111010011000
// 0x15D3 == 1010111010011
f = __builtin_huge_valf(); // CHECK: float 0x7FF0000000000000
d = __builtin_huge_val(); // CHECK: double 0x7FF0000000000000
ld = __builtin_huge_vall(); // CHECK: x86_fp80 0xK7FFF8000000000000000
f = __builtin_nanf(""); // CHECK: float 0x7FF8000000000000
d = __builtin_nan(""); // CHECK: double 0x7FF8000000000000
ld = __builtin_nanl(""); // CHECK: x86_fp80 0xK7FFFC000000000000000
f = __builtin_nanf("0xAE98"); // CHECK: float 0x7FF815D300000000
d = __builtin_nan("0xAE98"); // CHECK: double 0x7FF800000000AE98
ld = __builtin_nanl("0xAE98"); // CHECK: x86_fp80 0xK7FFFC00000000000AE98
f = __builtin_nansf(""); // CHECK: float 0x7FF4000000000000
d = __builtin_nans(""); // CHECK: double 0x7FF4000000000000
ld = __builtin_nansl(""); // CHECK: x86_fp80 0xK7FFFA000000000000000
f = __builtin_nansf("0xAE98"); // CHECK: float 0x7FF015D300000000
d = __builtin_nans("0xAE98"); // CHECK: double 0x7FF000000000AE98
ld = __builtin_nansl("0xAE98");// CHECK: x86_fp80 0xK7FFF800000000000AE98
}
__complex float
__go_complex64_div (__complex float a, __complex float b)
{
if (__builtin_expect (b == 0+0i, 0))
{
if (!__builtin_isinff (__real__ a)
&& !__builtin_isinff (__imag__ a)
&& (__builtin_isnanf (__real__ a) || __builtin_isnanf (__imag__ a)))
{
/* Pass "1" to nanf to match math/bits.go. */
return __builtin_nanf("1") + __builtin_nanf("1")*1i;
}
}
return a / b;
}
float __builtin_tanhf(float x)
{
float t,z;
int jx,ix;
GET_FLOAT_WORD(jx,x);
ix = jx&0x7fffffff;
/* x is INF or NaN */
if(!FLT_UWORD_IS_FINITE(ix)) {
if (jx>=0) return one/x+one; /* tanh(+-inf)=+-1 */
else return __builtin_nanf(""); /* tanh(NaN) = NaN */
}
/* |x| < 22 */
if (ix < 0x41b00000) { /* |x|<22 */
if (ix<0x24000000) /* |x|<2**-55 */
return x*(one+x); /* tanh(small) = small */
if (ix>=0x3f800000) { /* |x|>=1 */
t = __builtin_expm1f(two*__builtin_fabsf(x));
z = one - two/(t+two);
} else {
t = __builtin_expm1f(-two*__builtin_fabsf(x));
z= -t/(t+two);
}
/* |x| > 22, return +-1 */
} else {
z = one - tiny; /* raised inexact flag */
}
return (jx>=0)? z: -z;
}
int
main ()
{
double nan = __builtin_nan ("");
float nanf = __builtin_nanf ("");
long double nanl = __builtin_nanl ("");
double pinf = __builtin_inf ();
float pinff = __builtin_inff ();
long double pinfl = __builtin_infl ();
if (__builtin_finite (pinf))
link_error ();
if (__builtin_finitef (pinff))
link_error ();
if (__builtin_finitel (pinfl))
link_error ();
if (__builtin_finite (nan))
link_error ();
if (__builtin_finitef (nanf))
link_error ();
if (__builtin_finitel (nanl))
link_error ();
if (!__builtin_finite (4.0))
link_error ();
if (!__builtin_finitef (4.0))
link_error ();
if (!__builtin_finitel (4.0))
link_error ();
}
main()
{
float nan = __builtin_nanf("");
if(five(nan, nan)) return 1;
if(five(5, nan)) return 2;
if(five(nan, 5)) return 3;
if(!five(3, 5)) return 4;
if(!ne(nan, nan)) return 5;
if(!ne(3, nan)) return 6;
if(!ne(nan, 3)) return 7;
if(ne(3, 3)) return 8;
return 0;
}
void testf (void)
{
float xxxxx[8];
int i;
xxxxx[0] = __builtin_copysignf (1.0, Yf[0]);
xxxxx[1] = __builtin_copysignf (1.0, Yf[1]);
xxxxx[2] = __builtin_copysignf (-1.0, Yf[2]);
xxxxx[3] = __builtin_copysignf (0.0, Yf[3]);
xxxxx[4] = __builtin_copysignf (-0.0, Yf[4]);
xxxxx[5] = __builtin_copysignf (-0.0, Yf[5]);
xxxxx[6] = __builtin_copysignf (__builtin_inff (), Yf[6]);
xxxxx[7] = __builtin_copysignf (-__builtin_nanf (""), Yf[7]);
for (i = 0; i < 8; ++i)
if (__builtin_memcmp (xxxxx+i, Zf+i, sizeof(float)) != 0)
abort ();
}
int main() {
volatile float a = __builtin_nanf("");
if (__builtin_isfinite(a)) {
return 1;
}
volatile float b = __builtin_inff();
if (__builtin_isfinite(b)) {
return 1;
}
volatile double c = __builtin_nan("");
if (__builtin_isfinite(c)) {
return 1;
}
volatile double d = __builtin_inf();
if (__builtin_isfinite(d)) {
return 1;
}
#ifdef __clang__ // TODO: dragonegg uses native calls which do not work with X86_FP80
volatile long double e = __builtin_nanl("");
if (__builtin_isfinite(e)) {
return 1;
}
volatile long double f = __builtin_infl();
if (__builtin_isfinite(f)) {
return 1;
}
#endif
volatile float g = 0;
if (!__builtin_isfinite(g)) {
return 1;
}
volatile double h = 0;
if (!__builtin_isfinite(h)) {
return 1;
}
#ifdef __clang__ // TODO: dragonegg uses native calls which do not work with X86_FP80
volatile long double i = 0;
if (!__builtin_isfinite(i)) {
return 1;
}
#endif
return 0;
}
int main() {
volatile float a = __builtin_nanf("");
if (!__builtin_isnan(a)) {
return 1;
}
volatile float b = __builtin_nansf("");
if (!__builtin_isnan(b)) {
return 1;
}
volatile double c = __builtin_nan("");
if (!__builtin_isnan(c)) {
return 1;
}
volatile double d = __builtin_nans("");
if (!__builtin_isnan(d)) {
return 1;
}
volatile long double e = __builtin_nanl("");
if (!__builtin_isnan(e)) {
return 1;
}
volatile long double f = __builtin_nansl("");
if (!__builtin_isnan(f)) {
return 1;
}
volatile float g = 0;
if (__builtin_isnan(g)) {
return 1;
}
volatile double h = 0;
if (__builtin_isnan(h)) {
return 1;
}
volatile long double i = 0;
if (__builtin_isnan(i)) {
return 1;
}
return 0;
}
/*
* Copyright (c) 2017, 2018, Oracle and/or its affiliates.
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice, this list of
* conditions and the following disclaimer in the documentation and/or other materials provided
* with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its contributors may be used to
* endorse or promote products derived from this software without specific prior written
* permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*/
int main() {
volatile float pos1 = 1.;
volatile float neg1 = -1.;
volatile float posZero = 0.;
volatile float negZero = -0.;
volatile float nan = __builtin_nanf("");
if (__builtin_isunordered(neg1, neg1) != 0) {
return 1;
}
if (__builtin_isunordered(posZero, negZero) != 0) {
return 1;
}
if (__builtin_isunordered(pos1, nan) == 0) {
return 1;
}
if (__builtin_isunordered(nan, pos1) == 0) {
return 1;
}
if (__builtin_isunordered(nan, nan) == 0) {
return 1;
}
return 0;
}
// RUN: %clang_cc1 -fsyntax-only -verify %s
// Math stuff
double g0 = __builtin_huge_val();
float g1 = __builtin_huge_valf();
long double g2 = __builtin_huge_vall();
double g3 = __builtin_inf();
float g4 = __builtin_inff();
long double g5 = __builtin_infl();
double g6 = __builtin_nan("");
float g7 = __builtin_nanf("");
long double g8 = __builtin_nanl("");
// GCC constant folds these too (via native strtol):
//double g6_1 = __builtin_nan("1");
//float g7_1 = __builtin_nanf("1");
//long double g8_1 = __builtin_nanl("1");
// APFloat doesn't have signalling NaN functions.
//double g9 = __builtin_nans("");
//float g10 = __builtin_nansf("");
//long double g11 = __builtin_nansl("");
//int g12 = __builtin_abs(-12);
double g13 = __builtin_fabs(-12.);
double g13_0 = __builtin_fabs(-0.);
double g13_1 = __builtin_fabs(-__builtin_inf());
void bar()
{
/* An argument of NaN is not evaluated at compile-time. */
#ifndef __SPU__
foof (__builtin_exp2f (__builtin_nanf("")));
#endif
foo (__builtin_exp2 (__builtin_nan("")));
fool (__builtin_exp2l (__builtin_nanl("")));
/* An argument of Inf/-Inf is not evaluated at compile-time. */
#ifndef __SPU__
foof (__builtin_exp2f (__builtin_inff()));
#endif
foo (__builtin_exp2 (__builtin_inf()));
fool (__builtin_exp2l (__builtin_infl()));
#ifndef __SPU__
foof (__builtin_exp2f (-__builtin_inff()));
#endif
foo (__builtin_exp2 (-__builtin_inf()));
fool (__builtin_exp2l (-__builtin_infl()));
/* Result overflows MPFR, which in version 2.2.x has 30 exponent bits. */
TESTIT (exp2, 0x1p50);
/* Result underflows MPFR, which in version 2.2.x has 30 exponent bits. */
TESTIT (exp2, -0x1p50);
/* Result overflows GCC's REAL_VALUE_TYPE, which has 26 exponent bits. */
TESTIT (exp2, 0x1p28);
/* Result underflows GCC's REAL_VALUE_TYPE, which has 26 exponent bits. */
TESTIT (exp2, -0x1p28);
/* Result overflows (even an extended) C double's mode. */
TESTIT (exp2, 0x1p24);
/* Result underflows (even an extended) C double's mode. */
TESTIT (exp2, -0x1p24);
/* Ensure that normal arguments/results are folded. */
TESTIT (exp2, 1.5);
TESTIT (exp2, -1.5);
/* The asin arg must be [-1 ... 1] inclusive. */
TESTIT (asin, -1.5);
TESTIT (asin, 1.5);
/* The acos arg must be [-1 ... 1] inclusive. */
TESTIT (acos, -1.5);
TESTIT (acos, 1.5);
/* The acosh arg must be [1 ... Inf] inclusive. */
TESTIT (acosh, 0.5);
/* The atanh arg must be [-1 ... 1] EXclusive. */
TESTIT (atanh, -1.0);
TESTIT (atanh, 1.0);
/* The log* arg must be [0 ... Inf] EXclusive. */
TESTIT (log, -1.0);
TESTIT (log, 0.0);
TESTIT (log, -0.0);
TESTIT (log2, -1.0);
TESTIT (log2, 0.0);
TESTIT (log2, -0.0);
TESTIT (log10, -1.0);
TESTIT (log10, 0.0);
TESTIT (log10, -0.0);
/* The log1p arg must be [-1 ... Inf] EXclusive. */
TESTIT (log1p, -2.0);
TESTIT (log1p, -1.0);
/* The tgamma arg errors with zero or negative integers. */
TESTIT (tgamma, 0.0);
TESTIT (tgamma, -0.0);
TESTIT (tgamma, -1.0);
TESTIT (tgamma, -2.0);
TESTIT (tgamma, -3.0);
/* An argument of NaN is not evaluated at compile-time. */
#ifndef __SPU__
foof (__builtin_powf (__builtin_nanf(""), 2.5F));
#endif
foo (__builtin_pow (__builtin_nan(""), 2.5));
fool (__builtin_powl (__builtin_nanl(""), 2.5L));
#ifndef __SPU__
foof (__builtin_powf (2.5F, __builtin_nanf("")));
#endif
foo (__builtin_pow (2.5, __builtin_nan("")));
fool (__builtin_powl (2.5L, __builtin_nanl("")));
/* An argument of Inf/-Inf is not evaluated at compile-time. */
#ifndef __SPU__
foof (__builtin_powf (__builtin_inff(), 2.5F));
#endif
foo (__builtin_pow (__builtin_inf(), 2.5));
fool (__builtin_powl (__builtin_infl(), 2.5L));
#ifndef __SPU__
foof (__builtin_powf (-__builtin_inff(), 2.5F));
#endif
foo (__builtin_pow (-__builtin_inf(), 2.5));
fool (__builtin_powl (-__builtin_infl(), 2.5L));
#ifndef __SPU__
foof (__builtin_powf (2.5F, __builtin_inff()));
#endif
foo (__builtin_pow (2.5, __builtin_inf()));
fool (__builtin_powl (2.5L, __builtin_infl()));
#ifndef __SPU__
foof (__builtin_powf (2.5F, -__builtin_inff()));
#endif
foo (__builtin_pow (2.5, -__builtin_inf()));
fool (__builtin_powl (2.5L, -__builtin_infl()));
/* Check for Inv/NaN return values. */
TESTIT2 (pow, -0.0, -4.5); /* Returns Inf */
TESTIT2 (pow, 0.0, -4.5); /* Returns Inf */
TESTIT2 (pow, -3.0, -4.5); /* Returns NaN */
/* Check for overflow/underflow. */
foof (__builtin_powf (__FLT_MAX__, 3.5F));
foo (__builtin_pow (__DBL_MAX__, 3.5));
fool (__builtin_powl (__LDBL_MAX__, 3.5L));
TESTIT2 (pow, 2.0, 0x1p50);
foof (__builtin_powf (__FLT_MAX__, -3.5F));
foo (__builtin_pow (__DBL_MAX__, -3.5));
fool (__builtin_powl (__LDBL_MAX__, -3.5L));
TESTIT2 (pow, 2.0, -0x1p50);
/* The sqrt arg must be [0 ... Inf] inclusive. */
TESTIT (sqrt, -0.5);
TESTIT (sqrt, -0.0);
TESTIT (sqrt, 0.0);
/* Check for overflow/underflow. */
/* These adjustments are too big. */
#define FLT_EXP_ADJ (2*(__FLT_MAX_EXP__-__FLT_MIN_EXP__)+1)
#define DBL_EXP_ADJ (2*(__DBL_MAX_EXP__-__DBL_MIN_EXP__)+1)
#define LDBL_EXP_ADJ (2*(__LDBL_MAX_EXP__-__LDBL_MIN_EXP__)+1)
TESTIT2_I2 (ldexp, 1.0, __INT_MAX__);
TESTIT2_I2 (ldexp, 1.0, -__INT_MAX__-1);
TESTIT2_I2 (ldexp, -1.0, __INT_MAX__);
TESTIT2_I2 (ldexp, -1.0, -__INT_MAX__-1);
TESTIT2_I2ALL (ldexp, __FLT_MIN__, FLT_EXP_ADJ, __DBL_MIN__,
DBL_EXP_ADJ, __LDBL_MIN__, LDBL_EXP_ADJ);
TESTIT2_I2ALL (ldexp, __FLT_MAX__, -FLT_EXP_ADJ, __DBL_MAX__,
-DBL_EXP_ADJ, __LDBL_MAX__, -LDBL_EXP_ADJ);
TESTIT2_I2ALL (ldexp, __FLT_MIN__, __FLT_MIN_EXP__, __DBL_MIN__,
__DBL_MIN_EXP__, __LDBL_MIN__, __LDBL_MIN_EXP__);
TESTIT2_I2ALL (ldexp, __FLT_MAX__, __FLT_MAX_EXP__, __DBL_MAX__,
__DBL_MAX_EXP__, __LDBL_MAX__, __LDBL_MAX_EXP__);
TESTIT2_I2 (scalbn, 1.0, __INT_MAX__);
TESTIT2_I2 (scalbn, 1.0, -__INT_MAX__-1);
TESTIT2_I2 (scalbn, -1.0, __INT_MAX__);
TESTIT2_I2 (scalbn, -1.0, -__INT_MAX__-1);
TESTIT2_I2ALL (scalbn, __FLT_MIN__, FLT_EXP_ADJ, __DBL_MIN__,
DBL_EXP_ADJ, __LDBL_MIN__, LDBL_EXP_ADJ);
TESTIT2_I2ALL (scalbn, __FLT_MAX__, -FLT_EXP_ADJ, __DBL_MAX__,
-DBL_EXP_ADJ, __LDBL_MAX__, -LDBL_EXP_ADJ);
TESTIT2_I2ALL (scalbn, __FLT_MIN__, __FLT_MIN_EXP__, __DBL_MIN__,
__DBL_MIN_EXP__, __LDBL_MIN__, __LDBL_MIN_EXP__);
TESTIT2_I2ALL (scalbn, __FLT_MAX__, __FLT_MAX_EXP__, __DBL_MAX__,
__DBL_MAX_EXP__, __LDBL_MAX__, __LDBL_MAX_EXP__);
TESTIT2_I2 (scalbln, 1.0, __LONG_MAX__);
TESTIT2_I2 (scalbln, 1.0, -__LONG_MAX__-1);
TESTIT2_I2 (scalbln, -1.0, __LONG_MAX__);
TESTIT2_I2 (scalbln, -1.0, -__LONG_MAX__-1);
TESTIT2_I2ALL (scalbln, __FLT_MIN__, FLT_EXP_ADJ, __DBL_MIN__,
DBL_EXP_ADJ, __LDBL_MIN__, LDBL_EXP_ADJ);
TESTIT2_I2ALL (scalbln, __FLT_MAX__, -FLT_EXP_ADJ, __DBL_MAX__,
-DBL_EXP_ADJ, __LDBL_MAX__, -LDBL_EXP_ADJ);
TESTIT2_I2ALL (scalbln, __FLT_MIN__, __FLT_MIN_EXP__, __DBL_MIN__,
__DBL_MIN_EXP__, __LDBL_MIN__, __LDBL_MIN_EXP__);
TESTIT2_I2ALL (scalbln, __FLT_MAX__, __FLT_MAX_EXP__, __DBL_MAX__,
__DBL_MAX_EXP__, __LDBL_MAX__, __LDBL_MAX_EXP__);
TESTIT (logb, 0.0);
TESTIT (logb, -0.0);
TESTIT (ilogb, 0.0);
TESTIT (ilogb, -0.0);
#ifndef __SPU__
foof (__builtin_ilogbf (__builtin_inff()));
#endif
foo (__builtin_ilogb (__builtin_inf()));
fool (__builtin_ilogbl (__builtin_infl()));
#ifndef __SPU__
foof (__builtin_ilogbf (-__builtin_inff()));
#endif
foo (__builtin_ilogb (-__builtin_inf()));
fool (__builtin_ilogbl (-__builtin_infl()));
#ifndef __SPU__
foof (__builtin_ilogbf (__builtin_nanf("")));
#endif
foo (__builtin_ilogb (__builtin_nan("")));
fool (__builtin_ilogbl (__builtin_nanl("")));
#ifndef __SPU__
foof (__builtin_ilogbf (-__builtin_nanf("")));
#endif
foo (__builtin_ilogb (-__builtin_nan("")));
fool (__builtin_ilogbl (-__builtin_nanl("")));
/* The y* arg must be [0 ... Inf] EXclusive. */
TESTIT (y0, -1.0);
TESTIT (y0, 0.0);
TESTIT (y0, -0.0);
TESTIT (y1, -1.0);
TESTIT (y1, 0.0);
TESTIT (y1, -0.0);
TESTIT2_I1 (yn, 2, -1.0);
TESTIT2_I1 (yn, 2, 0.0);
TESTIT2_I1 (yn, 2, -0.0);
TESTIT2_I1 (yn, -3, -1.0);
TESTIT2_I1 (yn, -3, 0.0);
TESTIT2_I1 (yn, -3, -0.0);
/* The second argument of remquo/remainder/drem must not be 0. */
TESTIT_REMQUO (1.0, 0.0);
TESTIT_REMQUO (1.0, -0.0);
TESTIT2 (remainder, 1.0, 0.0);
TESTIT2 (remainder, 1.0, -0.0);
TESTIT2 (drem, 1.0, 0.0);
TESTIT2 (drem, 1.0, -0.0);
/* The argument to lgamma* cannot be zero or a negative integer. */
TESTIT_REENT (lgamma, -4.0); /* lgamma_r */
TESTIT_REENT (lgamma, -3.0); /* lgamma_r */
TESTIT_REENT (lgamma, -2.0); /* lgamma_r */
TESTIT_REENT (lgamma, -1.0); /* lgamma_r */
TESTIT_REENT (lgamma, -0.0); /* lgamma_r */
TESTIT_REENT (lgamma, 0.0); /* lgamma_r */
TESTIT_REENT (gamma, -4.0); /* gamma_r */
TESTIT_REENT (gamma, -3.0); /* gamma_r */
TESTIT_REENT (gamma, -2.0); /* gamma_r */
TESTIT_REENT (gamma, -1.0); /* gamma_r */
TESTIT_REENT (gamma, -0.0); /* gamma_r */
TESTIT_REENT (gamma, 0.0); /* gamma_r */
}
VERIFY (NZ, NAN, TYPE, COMPARE, CL); \
VERIFY (NZ, INF, TYPE, COMPARE, CL); \
VERIFY (NAN, PZ, TYPE, COMPARE, CL); \
VERIFY (NAN, NZ, TYPE, COMPARE, CL); \
VERIFY (NAN, NAN, TYPE, COMPARE, CL); \
VERIFY (NAN, INF, TYPE, COMPARE, CL); \
VERIFY (INF, PZ, TYPE, COMPARE,CL); \
VERIFY (INF, NZ, TYPE, COMPARE, CL); \
VERIFY (INF, NAN, TYPE, COMPARE, CL); \
VERIFY (INF, INF, TYPE, COMPARE, CL); \
} while (0)
static void
check_float (void)
{
ALL_CHECKS (0.0f, -0.0f, __builtin_nanf (""), __builtin_inff (),
float, comparecf, CMPLXF);
}
static void
check_double (void)
{
ALL_CHECKS (0.0, -0.0, __builtin_nan (""), __builtin_inf (),
double, comparec, CMPLX);
}
static void
check_long_double (void)
{
ALL_CHECKS (0.0l, -0.0l, __builtin_nanl (""), __builtin_infl (),
long double, comparecl, CMPLXL);
int
convert_infnan (st_parameter_dt *dtp, void *dest, const char *buffer,
int length)
{
const char *s = buffer;
int is_inf, plus = 1;
if (*s == '+')
s++;
else if (*s == '-')
{
s++;
plus = 0;
}
is_inf = *s == 'i';
switch (length)
{
case 4:
if (is_inf)
*((GFC_REAL_4*) dest) = plus ? __builtin_inff () : -__builtin_inff ();
else
*((GFC_REAL_4*) dest) = plus ? __builtin_nanf ("") : -__builtin_nanf ("");
break;
case 8:
if (is_inf)
*((GFC_REAL_8*) dest) = plus ? __builtin_inf () : -__builtin_inf ();
else
*((GFC_REAL_8*) dest) = plus ? __builtin_nan ("") : -__builtin_nan ("");
break;
#if defined(HAVE_GFC_REAL_10)
case 10:
if (is_inf)
*((GFC_REAL_10*) dest) = plus ? __builtin_infl () : -__builtin_infl ();
else
*((GFC_REAL_10*) dest) = plus ? __builtin_nanl ("") : -__builtin_nanl ("");
break;
#endif
#if defined(HAVE_GFC_REAL_16)
# if defined(GFC_REAL_16_IS_FLOAT128)
case 16:
*((GFC_REAL_16*) dest) = __qmath_(strtoflt128) (buffer, NULL);
break;
# else
case 16:
if (is_inf)
*((GFC_REAL_16*) dest) = plus ? __builtin_infl () : -__builtin_infl ();
else
*((GFC_REAL_16*) dest) = plus ? __builtin_nanl ("") : -__builtin_nanl ("");
break;
# endif
#endif
default:
internal_error (&dtp->common, "Unsupported real kind during IO");
}
return 0;
}
/* { dg-do compile } */
/* { dg-options "-O2 -ftree-vectorize -mavx -mtune=generic" } */
/* { dg-skip-if "" { x86_64-*-mingw* } { "*" } { "" } } */
/* { dg-final { scan-assembler "and\[lq\]?\[\\t \]*\\$-32,\[\\t \]*%\[re\]?sp" } } */
/* { dg-final { scan-assembler "vmovaps\[\\t \]*%ymm" } } */
extern void abort (void);
static float Yf[] = { 2.0, -2.0, -2.0, -2.0, -2.0, 2.0, -0.0, __builtin_inff () };
static const float Zf[] = { 1.0, -1.0, -1.0, -0.0, -0.0, 0.0, -__builtin_inff (), __builtin_nanf ("") };
void testf (void)
{
float xxxxx[8];
int i;
xxxxx[0] = __builtin_copysignf (1.0, Yf[0]);
xxxxx[1] = __builtin_copysignf (1.0, Yf[1]);
xxxxx[2] = __builtin_copysignf (-1.0, Yf[2]);
xxxxx[3] = __builtin_copysignf (0.0, Yf[3]);
xxxxx[4] = __builtin_copysignf (-0.0, Yf[4]);
xxxxx[5] = __builtin_copysignf (-0.0, Yf[5]);
xxxxx[6] = __builtin_copysignf (__builtin_inff (), Yf[6]);
xxxxx[7] = __builtin_copysignf (-__builtin_nanf (""), Yf[7]);
for (i = 0; i < 8; ++i)
if (__builtin_memcmp (xxxxx+i, Zf+i, sizeof(float)) != 0)
abort ();
}
void bar()
{
/* An argument of NaN is not evaluated at compile-time. */
#ifndef __SPU__
foof (__builtin_csqrtf (__builtin_nanf("")));
#endif
foo (__builtin_csqrt (__builtin_nan("")));
fool (__builtin_csqrtl (__builtin_nanl("")));
/* An argument of Inf/-Inf is not evaluated at compile-time. */
#ifndef __SPU__
foof (__builtin_csqrtf (__builtin_inff()));
#endif
foo (__builtin_csqrt (__builtin_inf()));
fool (__builtin_csqrtl (__builtin_infl()));
#ifndef __SPU__
foof (__builtin_csqrtf (-__builtin_inff()));
#endif
foo (__builtin_csqrt (-__builtin_inf()));
fool (__builtin_csqrtl (-__builtin_infl()));
/* Check for overflow/underflow. */
TESTIT (cexp, 1e20);
TESTIT (cexp, -1e20);
/* An argument of NaN is not evaluated at compile-time. */
#ifndef __SPU__
foof (__builtin_cpowf (__builtin_nanf(""), 2.5F));
#endif
foo (__builtin_cpow (__builtin_nan(""), 2.5));
fool (__builtin_cpowl (__builtin_nanl(""), 2.5L));
#ifndef __SPU__
foof (__builtin_cpowf (2.5F, __builtin_nanf("")));
#endif
foo (__builtin_cpow (2.5, __builtin_nan("")));
fool (__builtin_cpowl (2.5L, __builtin_nanl("")));
/* An argument of Inf/-Inf is not evaluated at compile-time. */
#ifndef __SPU__
foof (__builtin_cpowf (__builtin_inff(), 2.5F));
#endif
foo (__builtin_cpow (__builtin_inf(), 2.5));
fool (__builtin_cpowl (__builtin_infl(), 2.5L));
#ifndef __SPU__
foof (__builtin_cpowf (-__builtin_inff(), 2.5F));
#endif
foo (__builtin_cpow (-__builtin_inf(), 2.5));
fool (__builtin_cpowl (-__builtin_infl(), 2.5L));
#ifndef __SPU__
foof (__builtin_cpowf (2.5F, __builtin_inff()));
#endif
foo (__builtin_cpow (2.5, __builtin_inf()));
fool (__builtin_cpowl (2.5L, __builtin_infl()));
#ifndef __SPU__
foof (__builtin_cpowf (2.5F, -__builtin_inff()));
#endif
foo (__builtin_cpow (2.5, -__builtin_inf()));
fool (__builtin_cpowl (2.5L, -__builtin_infl()));
/* Check for Inv/NaN return values. */
TESTIT2 (cpow, -0.0, -4.5); /* Returns Inf */
TESTIT2 (cpow, 0.0, -4.5); /* Returns Inf */
/* Check for overflow/underflow. */
foof (__builtin_cpowf (__FLT_MAX__, 3.5F));
foof (__builtin_cpowf (__FLT_MAX__ * 1.FI, 3.5F));
foo (__builtin_cpow (__DBL_MAX__, 3.5));
foo (__builtin_cpow (__DBL_MAX__ * 1.I, 3.5));
fool (__builtin_cpowl (__LDBL_MAX__, 3.5L));
fool (__builtin_cpowl (__LDBL_MAX__ * 1.LI, 3.5L));
TESTIT2 (cpow, 2.0, 0x1p50);
TESTIT2 (cpow, 2.0, 0x1p28);
TESTIT2 (cpow, 2.0, 0x1p24);
foof (__builtin_cpowf (__FLT_MAX__, -3.5F));
foof (__builtin_cpowf (__FLT_MAX__ * 1.FI, -3.5F));
foo (__builtin_cpow (__DBL_MAX__, -3.5));
foo (__builtin_cpow (__DBL_MAX__ * 1.I, -3.5));
fool (__builtin_cpowl (__LDBL_MAX__, -3.5L));
fool (__builtin_cpowl (__LDBL_MAX__ * 1.LI, -3.5L));
TESTIT2 (cpow, 2.0, -0x1p50);
TESTIT2 (cpow, 2.0, -0x1p28);
TESTIT2 (cpow, 2.0, -0x1p24);
}
int main()
{
float f = __builtin_nanf("");
foo(f);
return 0;
}
double __builtin_nan(const char *arg)
{
return (double) __builtin_nanf(arg);
}
float __nan( void )
{
return __builtin_nanf("");
}
