diff options
Diffstat (limited to 'gcc/testsuite/gcc.dg/torture')
-rw-r--r-- | gcc/testsuite/gcc.dg/torture/builtin-convert-1.c | 138 | ||||
-rw-r--r-- | gcc/testsuite/gcc.dg/torture/builtin-ctype-1.c | 44 | ||||
-rw-r--r-- | gcc/testsuite/gcc.dg/torture/builtin-ctype-2.c | 107 | ||||
-rw-r--r-- | gcc/testsuite/gcc.dg/torture/builtin-power-1.c | 105 | ||||
-rw-r--r-- | gcc/testsuite/gcc.dg/torture/builtin-wctype-1.c | 42 |
5 files changed, 436 insertions, 0 deletions
diff --git a/gcc/testsuite/gcc.dg/torture/builtin-convert-1.c b/gcc/testsuite/gcc.dg/torture/builtin-convert-1.c new file mode 100644 index 00000000000..ac671590d20 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/builtin-convert-1.c @@ -0,0 +1,138 @@ +/* Copyright (C) 2004 Free Software Foundation. + + Verify that built-in math function conversion to smaller FP types + is correctly performed by the compiler. + + Written by Kaveh Ghazi, 2004-03-17. */ + +/* { dg-do link } */ +/* { dg-options "-ffast-math" } */ + +#include "../builtins-config.h" + +/* This check is necessary when converting to a C99 function. */ +#ifdef HAVE_C99_RUNTIME +#define C99CODE(CODE) (CODE) +#define MAYBEC99(CODE, C99) (CODE) +#else +#define C99CODE(CODE) 0 +#define MAYBEC99(CODE, C99) (!(C99) && (CODE)) +#endif + +#define PROTOTYPE1(FN) extern double FN(double); extern float FN##f(float); \ + extern long double FN##l(long double); + +void test(double d1, float f1, long double ld1) +{ + /* Test converting math builtins to narrower FP types based on a + narrowing cast on the outside of the call. MATHFN is the + function to test, and C99 is 0/1 depending on whether the + `double' version of MATHFN is a C99 function. The optimization + is only performed if the replacement function is actually + narrower in width, so check that first. */ +#define OUTER_CAST1(MATHFN, C99) \ + PROTOTYPE1 (MATHFN) \ + extern void link_failure_outer_##MATHFN##l_##MATHFN##_1(void); \ + extern void link_failure_outer_##MATHFN##l_##MATHFN##_2(void); \ + extern void link_failure_outer_##MATHFN##l_##MATHFN##f_1(void); \ + extern void link_failure_outer_##MATHFN##l_##MATHFN##f_2(void); \ + extern void link_failure_outer_##MATHFN##_##MATHFN##f_1(void); \ + extern void link_failure_outer_##MATHFN##_##MATHFN##f_2(void); \ + if (sizeof (long double) > sizeof (double) \ + && MAYBEC99 ((double) MATHFN##l((double)ld1) != MATHFN(ld1), C99)) \ + link_failure_outer_##MATHFN##l_##MATHFN##_1(); \ + if (sizeof (long double) > sizeof (double) \ + && MAYBEC99 ((double) MATHFN##l(d1) != MATHFN(d1), C99)) \ + link_failure_outer_##MATHFN##l_##MATHFN##_1(); \ + if (sizeof (long double) > sizeof (double) \ + && MAYBEC99 ((double) MATHFN##l(f1) != MATHFN(f1), C99)) \ + link_failure_outer_##MATHFN##l_##MATHFN##_2(); \ + if (sizeof (long double) > sizeof (float) \ + && C99CODE ((float) MATHFN##l((float) ld1) != MATHFN##f(ld1))) \ + link_failure_outer_##MATHFN##l_##MATHFN##f_1(); \ + if (sizeof (long double) > sizeof (float) \ + && C99CODE ((float) MATHFN##l((float) d1) != MATHFN##f(d1))) \ + link_failure_outer_##MATHFN##l_##MATHFN##f_1(); \ + if (sizeof (long double) > sizeof (float) \ + && C99CODE ((float) MATHFN##l(f1) != MATHFN##f(f1))) \ + link_failure_outer_##MATHFN##l_##MATHFN##f_2(); \ + if (sizeof (double) > sizeof (float) \ + && C99CODE ((float) MATHFN((float) ld1) != MATHFN##f(ld1))) \ + link_failure_outer_##MATHFN##_##MATHFN##f_1(); \ + if (sizeof (double) > sizeof (float) \ + && C99CODE ((float) MATHFN((float) d1) != MATHFN##f(d1))) \ + link_failure_outer_##MATHFN##_##MATHFN##f_1(); \ + if (sizeof (double) > sizeof (float) \ + && C99CODE ((float) MATHFN(f1) != MATHFN##f(f1))) \ + link_failure_outer_##MATHFN##_##MATHFN##f_2() + + /* Test converting math builtins to narrower FP types based on if + the argument is a narrower type (perhaps implicitly) cast to a + wider one. */ +#define INNER_CAST1(MATHFN, C99) \ + PROTOTYPE1 (MATHFN) \ + extern void link_failure_inner_##MATHFN##l_##MATHFN(void); \ + extern void link_failure_inner_##MATHFN##l_##MATHFN##f(void); \ + extern void link_failure_inner_##MATHFN##_##MATHFN##f(void); \ + if (sizeof (long double) > sizeof (double) \ + && MAYBEC99 (MATHFN##l(d1) != (long double) MATHFN(d1), C99)) \ + link_failure_inner_##MATHFN##l_##MATHFN(); \ + if (sizeof (long double) > sizeof (float) \ + && C99CODE (MATHFN##l(f1) != (long double) MATHFN##f(f1))) \ + link_failure_inner_##MATHFN##l_##MATHFN##f(); \ + if (sizeof (long double) > sizeof (float) \ + && C99CODE (MATHFN##l((double)f1) != (long double) MATHFN##f(f1))) \ + link_failure_inner_##MATHFN##l_##MATHFN##f(); \ + if (sizeof (double) > sizeof (float) \ + && C99CODE (MATHFN(f1) != (double) MATHFN##f(f1))) \ + link_failure_inner_##MATHFN##_##MATHFN##f() + + +#ifdef __OPTIMIZE__ + OUTER_CAST1 (acos, /*C99=*/ 0); + OUTER_CAST1 (acosh, /*C99=*/ 1); + OUTER_CAST1 (asin, /*C99=*/ 1); + OUTER_CAST1 (asinh, /*C99=*/ 1); + OUTER_CAST1 (atan, /*C99=*/ 0); + OUTER_CAST1 (atanh, /*C99=*/ 1); + OUTER_CAST1 (cbrt, /*C99=*/ 1); + OUTER_CAST1 (cos, /*C99=*/ 0); + OUTER_CAST1 (cosh, /*C99=*/ 0); + OUTER_CAST1 (erf, /*C99=*/ 1); + OUTER_CAST1 (erfc, /*C99=*/ 1); + OUTER_CAST1 (exp, /*C99=*/ 0); + OUTER_CAST1 (exp2, /*C99=*/ 1); + OUTER_CAST1 (expm1, /*C99=*/ 1); + OUTER_CAST1 (fabs, /*C99=*/ 0); + OUTER_CAST1 (lgamma, /*C99=*/ 1); + OUTER_CAST1 (log, /*C99=*/ 0); + OUTER_CAST1 (log10, /*C99=*/ 0); + OUTER_CAST1 (log1p, /*C99=*/ 1); + OUTER_CAST1 (log2, /*C99=*/ 1); + OUTER_CAST1 (logb, /*C99=*/ 1); + OUTER_CAST1 (sin, /*C99=*/ 0); + OUTER_CAST1 (sinh, /*C99=*/ 0); + OUTER_CAST1 (sqrt, /*C99=*/ 0); + OUTER_CAST1 (tan, /*C99=*/ 0); + OUTER_CAST1 (tanh, /*C99=*/ 0); + OUTER_CAST1 (tgamma, /*C99=*/ 1); + + INNER_CAST1 (ceil, /*C99=*/ 0); + OUTER_CAST1 (ceil, /*C99=*/ 0); + INNER_CAST1 (floor, /*C99=*/ 0); + OUTER_CAST1 (floor, /*C99=*/ 0); + INNER_CAST1 (nearbyint, /*C99=*/ 1); + OUTER_CAST1 (nearbyint, /*C99=*/ 1); + INNER_CAST1 (rint, /*C99=*/ 1); + OUTER_CAST1 (rint, /*C99=*/ 1); + INNER_CAST1 (round, /*C99=*/ 1); + OUTER_CAST1 (round, /*C99=*/ 1); + INNER_CAST1 (trunc, /*C99=*/ 1); + OUTER_CAST1 (trunc, /*C99=*/ 1); +#endif /* __OPTIMIZE__ */ +} + +int main (void) +{ + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/builtin-ctype-1.c b/gcc/testsuite/gcc.dg/torture/builtin-ctype-1.c new file mode 100644 index 00000000000..ad6fc1c60b6 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/builtin-ctype-1.c @@ -0,0 +1,44 @@ +/* Copyright (C) 2004 Free Software Foundation. + + Verify that built-in ctype function attributes are correctly set by + the compiler. + + Written by Kaveh Ghazi, 2004-03-23. */ + +/* { dg-do link } */ + + +void test(int i) +{ + /* All of these ctype functions should be const/pure and thus + eliminated. */ +#define TEST_CTYPE(FN) \ + extern int FN(int); \ + extern void link_failure_##FN(void); \ + if (FN(i) != FN(i)) \ + link_failure_##FN() + +#ifdef __OPTIMIZE__ + TEST_CTYPE(isalnum); + TEST_CTYPE(isalpha); + TEST_CTYPE(isascii); + TEST_CTYPE(isblank); + TEST_CTYPE(iscntrl); + TEST_CTYPE(isdigit); + TEST_CTYPE(isgraph); + TEST_CTYPE(islower); + TEST_CTYPE(isprint); + TEST_CTYPE(ispunct); + TEST_CTYPE(isspace); + TEST_CTYPE(isupper); + TEST_CTYPE(isxdigit); + TEST_CTYPE(toascii); + TEST_CTYPE(tolower); + TEST_CTYPE(toupper); +#endif /* __OPTIMIZE__ */ +} + +int main (void) +{ + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/builtin-ctype-2.c b/gcc/testsuite/gcc.dg/torture/builtin-ctype-2.c new file mode 100644 index 00000000000..7046aad6562 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/builtin-ctype-2.c @@ -0,0 +1,107 @@ +/* Copyright (C) 2004 Free Software Foundation. + + Verify that built-in ctype transformations are done correctly by + the compiler. + + Written by Kaveh Ghazi, 2004-04-05. */ + +/* { dg-do link } */ + +extern void link_failure_var(void); + +void test(int i) +{ + /* All of these ctype calls should compile-time evaluate to true. */ +#define TEST_CTYPE_CST_TRUE(FN, VALUE) \ + extern void link_failure_##FN##_cst_true(void); \ + extern int FN(int); \ + if (! FN(VALUE)) \ + link_failure_##FN##_cst_true() + + /* All of these ctype calls should compile-time evaluate to false. */ +#define TEST_CTYPE_CST_FALSE(FN, VALUE) \ + extern void link_failure_##FN##_cst_false(void); \ + extern int FN(int); \ + if (FN(VALUE)) \ + link_failure_##FN##_cst_false() + + /* All of these ctype calls should compile-time evaluate to true. */ +#define TEST_TOCTYPE_CST_TRUE(FN, VALUE) \ + extern void link_failure_##FN##_cst_true(void); \ + extern int FN(int); \ + if (FN(VALUE) != (VALUE)) \ + link_failure_##FN##_cst_true() + + /* All of these ctype calls should compile-time evaluate to false. */ +#define TEST_TOCTYPE_CST_FALSE(FN, VALUE) \ + extern void link_failure_##FN##_cst_false(void); \ + extern int FN(int); \ + if (FN(VALUE) == (VALUE)) \ + link_failure_##FN##_cst_false() + +#ifdef __OPTIMIZE__ + TEST_CTYPE_CST_TRUE (isascii, 0); + TEST_CTYPE_CST_TRUE (isascii, 1); + TEST_CTYPE_CST_TRUE (isascii, 126); + TEST_CTYPE_CST_TRUE (isascii, 127); + + TEST_CTYPE_CST_FALSE (isascii, -1); + TEST_CTYPE_CST_FALSE (isascii, 128); + TEST_CTYPE_CST_FALSE (isascii, 129); + TEST_CTYPE_CST_FALSE (isascii, 255); + TEST_CTYPE_CST_FALSE (isascii, 256); + TEST_CTYPE_CST_FALSE (isascii, 257); + TEST_CTYPE_CST_FALSE (isascii, 10000); + TEST_CTYPE_CST_FALSE (isascii, __INT_MAX__); + + /* This ctype call should transform into another expression. */ + if (isascii(i) != ((i & ~0x7f) == 0)) + link_failure_var(); + + TEST_TOCTYPE_CST_TRUE (toascii, 0); + TEST_TOCTYPE_CST_TRUE (toascii, 1); + TEST_TOCTYPE_CST_TRUE (toascii, 126); + TEST_TOCTYPE_CST_TRUE (toascii, 127); + + TEST_TOCTYPE_CST_FALSE (toascii, -1); + TEST_TOCTYPE_CST_FALSE (toascii, 128); + TEST_TOCTYPE_CST_FALSE (toascii, 129); + TEST_TOCTYPE_CST_FALSE (toascii, 255); + TEST_TOCTYPE_CST_FALSE (toascii, 256); + TEST_TOCTYPE_CST_FALSE (toascii, 10000); + TEST_TOCTYPE_CST_FALSE (toascii, __INT_MAX__); + + /* This ctype call should transform into another expression. */ + if (toascii(i) != (i & 0x7f)) + link_failure_var(); + + TEST_CTYPE_CST_TRUE (isdigit, '0'); + TEST_CTYPE_CST_TRUE (isdigit, '1'); + TEST_CTYPE_CST_TRUE (isdigit, '2'); + TEST_CTYPE_CST_TRUE (isdigit, '3'); + TEST_CTYPE_CST_TRUE (isdigit, '4'); + TEST_CTYPE_CST_TRUE (isdigit, '5'); + TEST_CTYPE_CST_TRUE (isdigit, '6'); + TEST_CTYPE_CST_TRUE (isdigit, '7'); + TEST_CTYPE_CST_TRUE (isdigit, '8'); + TEST_CTYPE_CST_TRUE (isdigit, '9'); + + TEST_CTYPE_CST_FALSE (isdigit, '0'-1); + TEST_CTYPE_CST_FALSE (isdigit, '9'+1); + TEST_CTYPE_CST_FALSE (isdigit, -1); + TEST_CTYPE_CST_FALSE (isdigit, 0); + TEST_CTYPE_CST_FALSE (isdigit, 255); + TEST_CTYPE_CST_FALSE (isdigit, 256); + TEST_CTYPE_CST_FALSE (isdigit, 10000); + TEST_CTYPE_CST_FALSE (isdigit, __INT_MAX__); + + /* This ctype call should transform into another expression. */ + if (isdigit(i) != ((unsigned)i - '0' <= 9)) + link_failure_var(); +#endif /* __OPTIMIZE__ */ +} + +int main (void) +{ + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/builtin-power-1.c b/gcc/testsuite/gcc.dg/torture/builtin-power-1.c new file mode 100644 index 00000000000..45566118a81 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/builtin-power-1.c @@ -0,0 +1,105 @@ +/* Copyright (C) 2004 Free Software Foundation. + + Verify that built-in folding of various math "power" functions is + correctly performed by the compiler. + + Written by Kaveh Ghazi, 2004-03-11. */ + +/* { dg-do link } */ +/* { dg-options "-ffast-math" } */ + +#include "../builtins-config.h" + +#ifdef HAVE_C99_RUNTIME +#define C99CODE(CODE) CODE +#else +#define C99CODE(CODE) 0 +#endif + +#define PROTOTYPE(FN) extern double FN(double); extern float FN##f(float); \ + extern long double FN##l(long double); +#define PROTOTYPE2(FN) extern double FN(double, double); \ + extern float FN##f(float, float); \ + extern long double FN##l(long double, long double); + +PROTOTYPE(sqrt) +PROTOTYPE(cbrt) +PROTOTYPE2(pow) + +void test(double d1, double d2, double d3, + float f1, float f2, float f3, + long double ld1, long double ld2, long double ld3) +{ + /* Test N1root(N2root(x)) -> pow(x,1/(N1*N2)). */ + /* E.g. sqrt(cbrt(x)) -> pow(x,1/6). */ +#define ROOT_ROOT(FN1,N1,FN2,N2) \ + extern void link_failure_##FN1##_##FN2(void); \ + if (FN1(FN2(d1)) != pow(d1,1.0/(N1*N2)) \ + || C99CODE (FN1##f(FN2##f(f1)) != powf(f1,1.0F/(N1*N2))) \ + || C99CODE (FN1##l(FN2##l(ld1)) != powl(ld1,1.0L/(N1*N2)))) \ + link_failure_##FN1##_##FN2() + + ROOT_ROOT(sqrt,2,sqrt,2); + ROOT_ROOT(sqrt,2,cbrt,3); + ROOT_ROOT(cbrt,3,sqrt,2); + /*ROOT_ROOT(cbrt,3,cbrt,3); Intentionally not implemented. */ + + /* Test pow(Nroot(x),y) -> pow(x,y/N). */ +#define POW_ROOT(FN,N) \ + extern void link_failure_pow_##FN(void); \ + if (pow(FN(d1), d2) != pow(d1,d2/N) \ + || powf(FN##f(f1),f2) != powf(f1,f2/N) \ + || powl(FN##l(ld1),ld2) != powl(ld1,ld2/N)) \ + link_failure_pow_##FN() + + POW_ROOT(sqrt,2); + /*POW_ROOT(cbrt,3); Intentionally not implemented. */ + + /* Test Nroot(pow(x,y)) -> pow(x,y/N). */ +#define ROOT_POW(FN,N) \ + extern void link_failure_##FN##_pow(void); \ + if (FN(pow(d1, d2)) != pow(d1,d2/N) \ + || FN##f(powf(f1,f2)) != powf(f1,f2/N) \ + || FN##l(powl(ld1,ld2)) != powl(ld1,ld2/N)) \ + link_failure_##FN##_pow() + + ROOT_POW(sqrt,2); + /*ROOT_POW(cbrt,3); Intentionally not implemented. */ + + /* Test pow(pow(x,y),z) -> pow(x,y*z). */ +#define POW_POW \ + extern void link_failure_pow_pow(void); \ + if (pow(pow(d1, d2), d3) != pow(d1,d2*d3) \ + || powf(powf(f1,f2),f3) != powf(f1,f2*f3) \ + || powl(powl(ld1,ld2),ld3) != powl(ld1,ld2*ld3)) \ + link_failure_pow_pow() + + POW_POW; + + /* Test Nroot(x)*Nroot(y) -> Nroot(x*y). */ +#define ROOT_X_ROOT(FN) \ + extern void link_failure_root_x_root(void); \ + if (FN(d1)*FN(d2) != FN(d1*d2) \ + || FN##f(f1)*FN##f(f2) != FN##f(f1*f2) \ + || FN##l(ld1)*FN##l(ld2) != FN##l(ld1*ld2)) \ + link_failure_root_x_root() + + ROOT_X_ROOT(sqrt); + ROOT_X_ROOT(cbrt); + + /* Test pow(x,y)*pow(x,z) -> pow(x,y+z). */ +#define POW_X_POW \ + extern void link_failure_pow_x_pow(void); \ + if (pow(d1,d2)*pow(d1,d3) != pow(d1,d2+d3) \ + || powf(f1,f2)*powf(f1,f3) != powf(f1,f2+f3) \ + || powl(ld1,ld2)*powl(ld1,ld3) != powl(ld1,ld2+ld3)) \ + link_failure_pow_x_pow() + + POW_X_POW; + +} + +int main (void) +{ + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/builtin-wctype-1.c b/gcc/testsuite/gcc.dg/torture/builtin-wctype-1.c new file mode 100644 index 00000000000..b8338de0bd1 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/builtin-wctype-1.c @@ -0,0 +1,42 @@ +/* Copyright (C) 2004 Free Software Foundation. + + Verify that built-in wctype function attributes are correctly set + by the compiler. + + Written by Kaveh Ghazi, 2004-03-25. */ + +/* { dg-do link } */ + + +void test(int i) +{ + /* All of these ctype functions should be const/pure and thus + eliminated. */ +#define TEST_CTYPE(FN) \ + extern int FN(int); \ + extern void link_failure_##FN(void); \ + if (FN(i) != FN(i)) \ + link_failure_##FN() + +#ifdef __OPTIMIZE__ + TEST_CTYPE(iswalnum); + TEST_CTYPE(iswalpha); + TEST_CTYPE(iswblank); + TEST_CTYPE(iswcntrl); + TEST_CTYPE(iswdigit); + TEST_CTYPE(iswgraph); + TEST_CTYPE(iswlower); + TEST_CTYPE(iswprint); + TEST_CTYPE(iswpunct); + TEST_CTYPE(iswspace); + TEST_CTYPE(iswupper); + TEST_CTYPE(iswxdigit); + TEST_CTYPE(towlower); + TEST_CTYPE(towupper); +#endif /* __OPTIMIZE__ */ +} + +int main (void) +{ + return 0; +} |