builtins.def (lceil, [...]): Mark with ATTR_CONST_NOTHROW_LIST.
* builtins.def (lceil, lceilf, lceill, lfloor, lfloorf, lfloorl, llceil, llceilf, llceill, llfloor, llfloorf, llfloorl): Mark with ATTR_CONST_NOTHROW_LIST. * fold-const.c (tree_expr_nonnegative_warnv_p): Handle FIX_TRUNC_EXPR. testsuite: * gcc.dg/builtins-55.c: Test *lceil* and *lfloor*. * gcc.dg/torture/builtin-attr-1.c: Likewise. * gcc.dg/torture/builtin-convert-1.c: Likewise. Also test *lrint* and *lround*. * gcc.dg/torture/builtin-convert-2.c: Test ceil->lceil and floor->lfloor. * gcc.dg/torture/builtin-convert-3.c: Test *lceil* and *lfloor*. * gcc.dg/torture/builtin-integral-1.c: Likewise. * gcc.dg/torture/builtin-minmax-1.c: Likewise. Also test *lrint* and *lround*. Correct macro names. * gcc.dg/torture/builtin-nonneg-1.c: Test *lceil* and *lfloor*. * gcc.dg/torture/builtin-rounding-1.c: Likewise. From-SVN: r122713
This commit is contained in:
Kaveh R. Ghazi
Kaveh Ghazi
parent
f53e867d73
commit
aeabd15d45
13 changed files with 188 additions and 127 deletions
|
|
@ -1,3 +1,12 @@
|
|||
2007-03-08 Kaveh R. Ghazi <ghazi@caip.rutgers.edu>
|
||||
|
||||
* builtins.def (lceil, lceilf, lceill, lfloor, lfloorf, lfloorl,
|
||||
llceil, llceilf, llceill, llfloor, llfloorf, llfloorl): Mark with
|
||||
ATTR_CONST_NOTHROW_LIST.
|
||||
|
||||
* fold-const.c (tree_expr_nonnegative_warnv_p): Handle
|
||||
FIX_TRUNC_EXPR.
|
||||
|
||||
2007-03-08 Diego Novillo <dnovillo@redhat.com>
|
||||
|
||||
* doc/tree-ssa.texi: Remove documentation for V_MUST_DEF.
|
||||
|
|
|
|||
|
|
@ -282,24 +282,24 @@ DEF_EXT_LIB_BUILTIN (BUILT_IN_J1L, "j1l", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_M
|
|||
DEF_EXT_LIB_BUILTIN (BUILT_IN_JN, "jn", BT_FN_DOUBLE_INT_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
|
||||
DEF_EXT_LIB_BUILTIN (BUILT_IN_JNF, "jnf", BT_FN_FLOAT_INT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO)
|
||||
DEF_EXT_LIB_BUILTIN (BUILT_IN_JNL, "jnl", BT_FN_LONGDOUBLE_INT_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
|
||||
DEF_GCC_BUILTIN (BUILT_IN_LCEIL, "lceil", BT_FN_LONG_DOUBLE, ATTR_MATHFN_FPROUNDING)
|
||||
DEF_GCC_BUILTIN (BUILT_IN_LCEILF, "lceilf", BT_FN_LONG_FLOAT, ATTR_MATHFN_FPROUNDING)
|
||||
DEF_GCC_BUILTIN (BUILT_IN_LCEILL, "lceill", BT_FN_LONG_LONGDOUBLE, ATTR_MATHFN_FPROUNDING)
|
||||
DEF_GCC_BUILTIN (BUILT_IN_LCEIL, "lceil", BT_FN_LONG_DOUBLE, ATTR_CONST_NOTHROW_LIST)
|
||||
DEF_GCC_BUILTIN (BUILT_IN_LCEILF, "lceilf", BT_FN_LONG_FLOAT, ATTR_CONST_NOTHROW_LIST)
|
||||
DEF_GCC_BUILTIN (BUILT_IN_LCEILL, "lceill", BT_FN_LONG_LONGDOUBLE, ATTR_CONST_NOTHROW_LIST)
|
||||
DEF_LIB_BUILTIN (BUILT_IN_LDEXP, "ldexp", BT_FN_DOUBLE_DOUBLE_INT, ATTR_MATHFN_FPROUNDING_ERRNO)
|
||||
DEF_C99_C90RES_BUILTIN (BUILT_IN_LDEXPF, "ldexpf", BT_FN_FLOAT_FLOAT_INT, ATTR_MATHFN_FPROUNDING_ERRNO)
|
||||
DEF_C99_C90RES_BUILTIN (BUILT_IN_LDEXPL, "ldexpl", BT_FN_LONGDOUBLE_LONGDOUBLE_INT, ATTR_MATHFN_FPROUNDING_ERRNO)
|
||||
DEF_GCC_BUILTIN (BUILT_IN_LFLOOR, "lfloor", BT_FN_LONG_DOUBLE, ATTR_MATHFN_FPROUNDING)
|
||||
DEF_GCC_BUILTIN (BUILT_IN_LFLOORF, "lfloorf", BT_FN_LONG_FLOAT, ATTR_MATHFN_FPROUNDING)
|
||||
DEF_GCC_BUILTIN (BUILT_IN_LFLOORL, "lfloorl", BT_FN_LONG_LONGDOUBLE, ATTR_MATHFN_FPROUNDING)
|
||||
DEF_GCC_BUILTIN (BUILT_IN_LFLOOR, "lfloor", BT_FN_LONG_DOUBLE, ATTR_CONST_NOTHROW_LIST)
|
||||
DEF_GCC_BUILTIN (BUILT_IN_LFLOORF, "lfloorf", BT_FN_LONG_FLOAT, ATTR_CONST_NOTHROW_LIST)
|
||||
DEF_GCC_BUILTIN (BUILT_IN_LFLOORL, "lfloorl", BT_FN_LONG_LONGDOUBLE, ATTR_CONST_NOTHROW_LIST)
|
||||
DEF_C99_BUILTIN (BUILT_IN_LGAMMA, "lgamma", BT_FN_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_STORE)
|
||||
DEF_C99_BUILTIN (BUILT_IN_LGAMMAF, "lgammaf", BT_FN_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_STORE)
|
||||
DEF_C99_BUILTIN (BUILT_IN_LGAMMAL, "lgammal", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_STORE)
|
||||
DEF_GCC_BUILTIN (BUILT_IN_LLCEIL, "llceil", BT_FN_LONGLONG_DOUBLE, ATTR_MATHFN_FPROUNDING)
|
||||
DEF_GCC_BUILTIN (BUILT_IN_LLCEILF, "llceilf", BT_FN_LONGLONG_FLOAT, ATTR_MATHFN_FPROUNDING)
|
||||
DEF_GCC_BUILTIN (BUILT_IN_LLCEILL, "llceill", BT_FN_LONGLONG_LONGDOUBLE, ATTR_MATHFN_FPROUNDING)
|
||||
DEF_GCC_BUILTIN (BUILT_IN_LLFLOOR, "llfloor", BT_FN_LONGLONG_DOUBLE, ATTR_MATHFN_FPROUNDING)
|
||||
DEF_GCC_BUILTIN (BUILT_IN_LLFLOORF, "llfloorf", BT_FN_LONGLONG_FLOAT, ATTR_MATHFN_FPROUNDING)
|
||||
DEF_GCC_BUILTIN (BUILT_IN_LLFLOORL, "llfloorl", BT_FN_LONGLONG_LONGDOUBLE, ATTR_MATHFN_FPROUNDING)
|
||||
DEF_GCC_BUILTIN (BUILT_IN_LLCEIL, "llceil", BT_FN_LONGLONG_DOUBLE, ATTR_CONST_NOTHROW_LIST)
|
||||
DEF_GCC_BUILTIN (BUILT_IN_LLCEILF, "llceilf", BT_FN_LONGLONG_FLOAT, ATTR_CONST_NOTHROW_LIST)
|
||||
DEF_GCC_BUILTIN (BUILT_IN_LLCEILL, "llceill", BT_FN_LONGLONG_LONGDOUBLE, ATTR_CONST_NOTHROW_LIST)
|
||||
DEF_GCC_BUILTIN (BUILT_IN_LLFLOOR, "llfloor", BT_FN_LONGLONG_DOUBLE, ATTR_CONST_NOTHROW_LIST)
|
||||
DEF_GCC_BUILTIN (BUILT_IN_LLFLOORF, "llfloorf", BT_FN_LONGLONG_FLOAT, ATTR_CONST_NOTHROW_LIST)
|
||||
DEF_GCC_BUILTIN (BUILT_IN_LLFLOORL, "llfloorl", BT_FN_LONGLONG_LONGDOUBLE, ATTR_CONST_NOTHROW_LIST)
|
||||
DEF_C99_BUILTIN (BUILT_IN_LLRINT, "llrint", BT_FN_LONGLONG_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
|
||||
DEF_C99_BUILTIN (BUILT_IN_LLRINTF, "llrintf", BT_FN_LONGLONG_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO)
|
||||
DEF_C99_BUILTIN (BUILT_IN_LLRINTL, "llrintl", BT_FN_LONGLONG_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO)
|
||||
|
|
|
|||
|
|
@ -13256,6 +13256,7 @@ tree_expr_nonnegative_warnv_p (tree t, bool *strict_overflow_p)
|
|||
case SAVE_EXPR:
|
||||
case NON_LVALUE_EXPR:
|
||||
case FLOAT_EXPR:
|
||||
case FIX_TRUNC_EXPR:
|
||||
return tree_expr_nonnegative_warnv_p (TREE_OPERAND (t, 0),
|
||||
strict_overflow_p);
|
||||
|
||||
|
|
|
|||
|
|
@ -1,3 +1,16 @@
|
|||
2007-03-08 Kaveh R. Ghazi <ghazi@caip.rutgers.edu>
|
||||
|
||||
* gcc.dg/builtins-55.c: Test *lceil* and *lfloor*.
|
||||
* gcc.dg/torture/builtin-attr-1.c: Likewise.
|
||||
* gcc.dg/torture/builtin-convert-1.c: Likewise. Also test *lrint* and *lround*.
|
||||
* gcc.dg/torture/builtin-convert-2.c: Test ceil->lceil and floor->lfloor.
|
||||
* gcc.dg/torture/builtin-convert-3.c: Test *lceil* and *lfloor*.
|
||||
* gcc.dg/torture/builtin-integral-1.c: Likewise.
|
||||
* gcc.dg/torture/builtin-minmax-1.c: Likewise. Also test *lrint*
|
||||
and *lround*. Correct macro names.
|
||||
* gcc.dg/torture/builtin-nonneg-1.c: Test *lceil* and *lfloor*.
|
||||
* gcc.dg/torture/builtin-rounding-1.c: Likewise.
|
||||
|
||||
2007-03-08 Ian Lance Taylor <iant@google.com>
|
||||
|
||||
* gcc.dg/no-strict-overflow-5.c: New test.
|
||||
|
|
|
|||
|
|
@ -32,6 +32,10 @@ void test(double x)
|
|||
if (sizeof(long) != sizeof(long long))
|
||||
return;
|
||||
|
||||
if (__builtin_lceil(x) != __builtin_llceil(x))
|
||||
link_error();
|
||||
if (__builtin_lfloor(x) != __builtin_llfloor(x))
|
||||
link_error();
|
||||
if (lround(x) != llround(x))
|
||||
link_error();
|
||||
if (lrint(x) != llrint(x))
|
||||
|
|
@ -45,6 +49,10 @@ void testf(float x)
|
|||
if (sizeof(long) != sizeof(long long))
|
||||
return;
|
||||
|
||||
if (__builtin_lceilf(x) != __builtin_llceilf(x))
|
||||
link_error();
|
||||
if (__builtin_lfloorf(x) != __builtin_llfloorf(x))
|
||||
link_error();
|
||||
if (lroundf(x) != llroundf(x))
|
||||
link_error();
|
||||
if (lrintf(x) != llrintf(x))
|
||||
|
|
@ -58,6 +66,10 @@ void testl(long double x)
|
|||
if (sizeof(long) != sizeof(long long))
|
||||
return;
|
||||
|
||||
if (__builtin_lceill(x) != __builtin_llceill(x))
|
||||
link_error();
|
||||
if (__builtin_lfloorl(x) != __builtin_llfloorl(x))
|
||||
link_error();
|
||||
if (lroundl(x) != llroundl(x))
|
||||
link_error();
|
||||
if (lrintl(x) != llrintl(x))
|
||||
|
|
|
|||
|
|
@ -344,6 +344,8 @@ FPTEST1 (j0)
|
|||
FPTEST1 (j1)
|
||||
FPTEST2ARG1 (jn, int)
|
||||
FPTEST2ARG2 (ldexp, int)
|
||||
BUILTIN_FPTEST1 (llceil)
|
||||
BUILTIN_FPTEST1 (llfloor)
|
||||
FPTEST1T (llrint, long long)
|
||||
FPTEST1T (llround, long long)
|
||||
FPTEST1 (log)
|
||||
|
|
@ -351,6 +353,8 @@ FPTEST1 (log10)
|
|||
FPTEST1 (log1p)
|
||||
FPTEST1 (log2)
|
||||
FPTEST1 (logb)
|
||||
BUILTIN_FPTEST1 (lceil)
|
||||
BUILTIN_FPTEST1 (lfloor)
|
||||
FPTEST1T (lrint, long)
|
||||
FPTEST1T (lround, long)
|
||||
BUILTIN_FPTEST1ARG (nan, char *)
|
||||
|
|
|
|||
|
|
@ -21,9 +21,6 @@
|
|||
#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
|
||||
|
|
@ -33,7 +30,6 @@ void test(double d1, float f1, long double ld1)
|
|||
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); \
|
||||
|
|
@ -41,52 +37,51 @@ void test(double d1, float f1, long double ld1)
|
|||
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)) \
|
||||
&& MAYBEC99 ((double) __builtin_##MATHFN##l((double)ld1) != __builtin_##MATHFN(ld1), C99)) \
|
||||
link_failure_outer_##MATHFN##l_##MATHFN##_1(); \
|
||||
if (sizeof (long double) > sizeof (double) \
|
||||
&& MAYBEC99 ((double) MATHFN##l(d1) != MATHFN(d1), C99)) \
|
||||
&& MAYBEC99 ((double) __builtin_##MATHFN##l(d1) != __builtin_##MATHFN(d1), C99)) \
|
||||
link_failure_outer_##MATHFN##l_##MATHFN##_1(); \
|
||||
if (sizeof (long double) > sizeof (double) \
|
||||
&& MAYBEC99 ((double) MATHFN##l(f1) != MATHFN(f1), C99)) \
|
||||
&& MAYBEC99 ((double) __builtin_##MATHFN##l(f1) != __builtin_##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))) \
|
||||
&& C99CODE ((float) __builtin_##MATHFN##l((float) ld1) != __builtin_##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))) \
|
||||
&& C99CODE ((float) __builtin_##MATHFN##l((float) d1) != __builtin_##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))) \
|
||||
&& C99CODE ((float) __builtin_##MATHFN##l(f1) != __builtin_##MATHFN##f(f1))) \
|
||||
link_failure_outer_##MATHFN##l_##MATHFN##f_2(); \
|
||||
if (sizeof (double) > sizeof (float) \
|
||||
&& C99CODE ((float) MATHFN((float) ld1) != MATHFN##f(ld1))) \
|
||||
&& C99CODE ((float) __builtin_##MATHFN((float) ld1) != __builtin_##MATHFN##f(ld1))) \
|
||||
link_failure_outer_##MATHFN##_##MATHFN##f_1(); \
|
||||
if (sizeof (double) > sizeof (float) \
|
||||
&& C99CODE ((float) MATHFN((float) d1) != MATHFN##f(d1))) \
|
||||
&& C99CODE ((float) __builtin_##MATHFN((float) d1) != __builtin_##MATHFN##f(d1))) \
|
||||
link_failure_outer_##MATHFN##_##MATHFN##f_1(); \
|
||||
if (sizeof (double) > sizeof (float) \
|
||||
&& C99CODE ((float) MATHFN(f1) != MATHFN##f(f1))) \
|
||||
&& C99CODE ((float) __builtin_##MATHFN(f1) != __builtin_##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)) \
|
||||
&& MAYBEC99 (__builtin_##MATHFN##l(d1) != (long double) __builtin_##MATHFN(d1), C99)) \
|
||||
link_failure_inner_##MATHFN##l_##MATHFN(); \
|
||||
if (sizeof (long double) > sizeof (float) \
|
||||
&& C99CODE (MATHFN##l(f1) != (long double) MATHFN##f(f1))) \
|
||||
&& C99CODE (__builtin_##MATHFN##l(f1) != (long double) __builtin_##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))) \
|
||||
&& C99CODE (__builtin_##MATHFN##l((double)f1) != (long double) __builtin_##MATHFN##f(f1))) \
|
||||
link_failure_inner_##MATHFN##l_##MATHFN##f(); \
|
||||
if (sizeof (double) > sizeof (float) \
|
||||
&& C99CODE (MATHFN(f1) != (double) MATHFN##f(f1))) \
|
||||
&& C99CODE (__builtin_##MATHFN(f1) != (double) __builtin_##MATHFN##f(f1))) \
|
||||
link_failure_inner_##MATHFN##_##MATHFN##f()
|
||||
|
||||
|
||||
|
|
@ -122,6 +117,22 @@ void test(double d1, float f1, long double ld1)
|
|||
OUTER_CAST1 (ceil, /*C99=*/ 0);
|
||||
INNER_CAST1 (floor, /*C99=*/ 0);
|
||||
OUTER_CAST1 (floor, /*C99=*/ 0);
|
||||
INNER_CAST1 (lceil, /*C99=*/ 1);
|
||||
OUTER_CAST1 (lceil, /*C99=*/ 1);
|
||||
INNER_CAST1 (lfloor, /*C99=*/ 1);
|
||||
OUTER_CAST1 (lfloor, /*C99=*/ 1);
|
||||
INNER_CAST1 (lrint, /*C99=*/ 1);
|
||||
OUTER_CAST1 (lrint, /*C99=*/ 1);
|
||||
INNER_CAST1 (lround, /*C99=*/ 1);
|
||||
OUTER_CAST1 (lround, /*C99=*/ 1);
|
||||
INNER_CAST1 (llceil, /*C99=*/ 1);
|
||||
OUTER_CAST1 (llceil, /*C99=*/ 1);
|
||||
INNER_CAST1 (llfloor, /*C99=*/ 1);
|
||||
OUTER_CAST1 (llfloor, /*C99=*/ 1);
|
||||
INNER_CAST1 (llrint, /*C99=*/ 1);
|
||||
OUTER_CAST1 (llrint, /*C99=*/ 1);
|
||||
INNER_CAST1 (llround, /*C99=*/ 1);
|
||||
OUTER_CAST1 (llround, /*C99=*/ 1);
|
||||
INNER_CAST1 (nearbyint, /*C99=*/ 1);
|
||||
OUTER_CAST1 (nearbyint, /*C99=*/ 1);
|
||||
INNER_CAST1 (rint, /*C99=*/ 1);
|
||||
|
|
|
|||
|
|
@ -12,36 +12,26 @@
|
|||
|
||||
#include "../builtins-config.h"
|
||||
|
||||
#define PROTOTYPE(FN) extern double FN(double); \
|
||||
extern float FN##f(float); \
|
||||
extern long double FN##l(long double);
|
||||
#define PROTOTYPE_RET(FN, RET) extern RET FN(double); \
|
||||
extern RET FN##f(float); \
|
||||
extern RET FN##l(long double);
|
||||
|
||||
/* Macro to do all FP type combinations. The second half tests
|
||||
narrowing the FP type. */
|
||||
#define TEST_FP2FIXED(FN1, FN2) \
|
||||
PROTOTYPE(FN1) \
|
||||
PROTOTYPE_RET(FN2, long) \
|
||||
PROTOTYPE_RET(l##FN2, long long) \
|
||||
extern void link_error_##FN1##_##FN2(void); \
|
||||
extern void link_error_##FN1##f_##FN2##f(void); \
|
||||
extern void link_error_##FN1##l_##FN2##l(void); \
|
||||
extern void link_error_##FN1##_l##FN2(void); \
|
||||
extern void link_error_##FN1##f_l##FN2##f(void); \
|
||||
extern void link_error_##FN1##l_l##FN2##l(void); \
|
||||
if ((long)FN1(d) != FN2(d)) \
|
||||
if ((long)__builtin_##FN1(d) != __builtin_##FN2(d)) \
|
||||
link_error_##FN1##_##FN2(); \
|
||||
if ((long)FN1##f(f) != FN2##f(f)) \
|
||||
if ((long)__builtin_##FN1##f(f) != __builtin_##FN2##f(f)) \
|
||||
link_error_##FN1##f_##FN2##f(); \
|
||||
if ((long)FN1##l(ld) != FN2##l(ld)) \
|
||||
if ((long)__builtin_##FN1##l(ld) != __builtin_##FN2##l(ld)) \
|
||||
link_error_##FN1##l_##FN2##l(); \
|
||||
if ((long long)FN1(d) != l##FN2(d)) \
|
||||
if ((long long)__builtin_##FN1(d) != __builtin_l##FN2(d)) \
|
||||
link_error_##FN1##_l##FN2(); \
|
||||
if ((long long)FN1##f(f) != l##FN2##f(f)) \
|
||||
if ((long long)__builtin_##FN1##f(f) != __builtin_l##FN2##f(f)) \
|
||||
link_error_##FN1##f_l##FN2##f(); \
|
||||
if ((long long)FN1##l(ld) != l##FN2##l(ld)) \
|
||||
if ((long long)__builtin_##FN1##l(ld) != __builtin_l##FN2##l(ld)) \
|
||||
link_error_##FN1##l_l##FN2##l(); \
|
||||
extern void link_error_##FN1##_##FN2##f(void); \
|
||||
extern void link_error_##FN1##l_##FN2(void); \
|
||||
|
|
@ -49,17 +39,23 @@
|
|||
extern void link_error_##FN1##_l##FN2##f(void); \
|
||||
extern void link_error_##FN1##l_l##FN2(void); \
|
||||
extern void link_error_##FN1##l_l##FN2##f(void); \
|
||||
if (sizeof(double) > sizeof(float) && (long)FN1(f) != FN2##f(f)) \
|
||||
if (sizeof(double) > sizeof(float) \
|
||||
&& (long)__builtin_##FN1(f) != __builtin_##FN2##f(f)) \
|
||||
link_error_##FN1##_##FN2##f(); \
|
||||
if (sizeof(long double) > sizeof(double) && (long)FN1##l(d) != FN2(d)) \
|
||||
if (sizeof(long double) > sizeof(double) \
|
||||
&& (long)__builtin_##FN1##l(d) != __builtin_##FN2(d)) \
|
||||
link_error_##FN1##l_##FN2(); \
|
||||
if (sizeof(long double) > sizeof(float) && (long)FN1##l(f) != FN2##f(f)) \
|
||||
if (sizeof(long double) > sizeof(float) \
|
||||
&& (long)__builtin_##FN1##l(f) != __builtin_##FN2##f(f)) \
|
||||
link_error_##FN1##l_##FN2##f(); \
|
||||
if (sizeof(double) > sizeof(float) && (long long)FN1(f) != l##FN2##f(f)) \
|
||||
if (sizeof(double) > sizeof(float) \
|
||||
&& (long long)__builtin_##FN1(f) != __builtin_l##FN2##f(f)) \
|
||||
link_error_##FN1##_l##FN2##f(); \
|
||||
if (sizeof(long double) > sizeof(double) && (long long)FN1##l(d) != l##FN2(d)) \
|
||||
if (sizeof(long double) > sizeof(double) \
|
||||
&& (long long)__builtin_##FN1##l(d) != __builtin_l##FN2(d)) \
|
||||
link_error_##FN1##l_l##FN2(); \
|
||||
if (sizeof(long double) > sizeof(float) && (long long)FN1##l(f) != l##FN2##f(f)) \
|
||||
if (sizeof(long double) > sizeof(float) \
|
||||
&& (long long)__builtin_##FN1##l(f) != __builtin_l##FN2##f(f)) \
|
||||
link_error_##FN1##l_l##FN2##f()
|
||||
|
||||
void __attribute__ ((__noinline__)) foo (double d, float f, long double ld)
|
||||
|
|
@ -67,6 +63,8 @@ void __attribute__ ((__noinline__)) foo (double d, float f, long double ld)
|
|||
#ifdef __OPTIMIZE__
|
||||
# ifdef HAVE_C99_RUNTIME
|
||||
/* The resulting transformation functions are all C99. */
|
||||
TEST_FP2FIXED (ceil, lceil);
|
||||
TEST_FP2FIXED (floor, lfloor);
|
||||
TEST_FP2FIXED (round, lround);
|
||||
TEST_FP2FIXED (nearbyint, lrint);
|
||||
TEST_FP2FIXED (rint, lrint);
|
||||
|
|
|
|||
|
|
@ -43,6 +43,10 @@ void __attribute__ ((__noinline__)) test (double d1, float f1)
|
|||
#ifdef __OPTIMIZE__
|
||||
#ifdef HAVE_C99_RUNTIME
|
||||
/* We're converting to implicitly generated C99 functions. */
|
||||
INNER_CAST1 (__builtin_lceil, long);
|
||||
INNER_CAST1 (__builtin_llceil, long long);
|
||||
INNER_CAST1 (__builtin_lfloor, long);
|
||||
INNER_CAST1 (__builtin_llfloor, long long);
|
||||
INNER_CAST1 (lround, long);
|
||||
INNER_CAST1 (llround, long long);
|
||||
INNER_CAST1 (lrint, long);
|
||||
|
|
|
|||
|
|
@ -5,48 +5,30 @@
|
|||
Written by Kaveh Ghazi, 2004-03-16. */
|
||||
|
||||
/* { dg-do link } */
|
||||
/* { dg-options "-ffast-math" } */
|
||||
/* We need -ffinite-math-only so that we can fold "foo != foo", where
|
||||
foo is a floating point expression. We need -fno-math-errno so
|
||||
that various math functions are marked const/pure and can be
|
||||
folded. */
|
||||
/* { dg-options "-ffinite-math-only -fno-math-errno" } */
|
||||
|
||||
#define PROTOTYPE1(FN) extern double FN(double); extern float FN##f(float); \
|
||||
extern long double FN##l(long double);
|
||||
#define PROTOTYPE1_RET(FN, RET) extern RET FN(double); extern RET FN##f(float); \
|
||||
extern RET FN##l(long double);
|
||||
#define PROTOTYPE_LINK_FAILURE(FN) extern void link_failure_##FN(void); \
|
||||
extern void link_failure_##FN##f(void); \
|
||||
extern void link_failure_##FN##l(void); \
|
||||
|
||||
PROTOTYPE1(fabs)
|
||||
PROTOTYPE1(ceil)
|
||||
PROTOTYPE1(floor)
|
||||
PROTOTYPE1(nearbyint)
|
||||
PROTOTYPE1(rint)
|
||||
PROTOTYPE1(round)
|
||||
PROTOTYPE1(trunc)
|
||||
PROTOTYPE1_RET(lround, long)
|
||||
PROTOTYPE1_RET(llround, long long)
|
||||
PROTOTYPE1_RET(lrint, long)
|
||||
PROTOTYPE1_RET(llrint, long long)
|
||||
extern int link_failure (int);
|
||||
|
||||
/* Test that the various FP truncation builtins detect integral
|
||||
arguments. */
|
||||
#define CHECK_FN(MATHFN) \
|
||||
PROTOTYPE_LINK_FAILURE(MATHFN); \
|
||||
if (MATHFN(i1) != i1) link_failure_##MATHFN(); \
|
||||
if (MATHFN##f(i1) != i1) link_failure_##MATHFN##f(); \
|
||||
if (MATHFN##l(i1) != i1) link_failure_##MATHFN##l();
|
||||
if (__builtin_##MATHFN(i1) != i1) link_failure (__LINE__); \
|
||||
if (__builtin_##MATHFN##f(i1) != i1) link_failure (__LINE__); \
|
||||
if (__builtin_##MATHFN##l(i1) != i1) link_failure (__LINE__);
|
||||
|
||||
#define CHECK_FN_RET(MATHFN, RET) \
|
||||
PROTOTYPE_LINK_FAILURE(MATHFN); \
|
||||
if (MATHFN(i1) != (RET)(double)i1) link_failure_##MATHFN(); \
|
||||
if (MATHFN##f(i1) != (RET)(float)i1) link_failure_##MATHFN##f(); \
|
||||
if (MATHFN##l(i1) != (RET)(long double)i1) link_failure_##MATHFN##l();
|
||||
if (__builtin_##MATHFN(i1) != (RET)(double)i1) link_failure (__LINE__); \
|
||||
if (__builtin_##MATHFN##f(i1) != (RET)(float)i1) link_failure (__LINE__); \
|
||||
if (__builtin_##MATHFN##l(i1) != (RET)(long double)i1) link_failure (__LINE__);
|
||||
|
||||
/* Check that various other integral expressions are detected. */
|
||||
#define CHECK_EXPR(EXPR,NAME) \
|
||||
extern void link_failure_FP_##NAME(void); \
|
||||
extern void link_failure_fixed_##NAME(void); \
|
||||
if (ceill(EXPR) != (EXPR)) link_failure_FP_##NAME(); \
|
||||
if (lroundl(EXPR) != (long)(long double)(EXPR)) link_failure_fixed_##NAME();
|
||||
if (__builtin_ceill(EXPR) != (EXPR)) link_failure (__LINE__); \
|
||||
if (__builtin_lroundl(EXPR) != (long)(long double)(EXPR)) link_failure (__LINE__);
|
||||
|
||||
void __attribute__ ((__noinline__)) test (int i1, int i2)
|
||||
{
|
||||
|
|
@ -60,6 +42,10 @@ void __attribute__ ((__noinline__)) test (int i1, int i2)
|
|||
CHECK_FN_RET(llround, long long);
|
||||
CHECK_FN_RET(lrint, long);
|
||||
CHECK_FN_RET(llrint, long long);
|
||||
CHECK_FN_RET(lceil, long);
|
||||
CHECK_FN_RET(llceil, long long);
|
||||
CHECK_FN_RET(lfloor, long);
|
||||
CHECK_FN_RET(llfloor, long long);
|
||||
|
||||
CHECK_EXPR (5.0, REAL_CST);
|
||||
CHECK_EXPR (5.0F, REAL_CSTf);
|
||||
|
|
@ -67,9 +53,9 @@ void __attribute__ ((__noinline__)) test (int i1, int i2)
|
|||
CHECK_EXPR ((double)i1, FLOAT_EXPR);
|
||||
CHECK_EXPR ((float)i1, FLOAT_EXPRf);
|
||||
CHECK_EXPR ((long double)i1, FLOAT_EXPRl);
|
||||
CHECK_EXPR (fabs(i1), ABS_EXPR);
|
||||
CHECK_EXPR (fabsf(i1), ABS_EXPRf);
|
||||
CHECK_EXPR (fabsl(i1), ABS_EXPRl);
|
||||
CHECK_EXPR (__builtin_fabs(i1), ABS_EXPR);
|
||||
CHECK_EXPR (__builtin_fabsf(i1), ABS_EXPRf);
|
||||
CHECK_EXPR (__builtin_fabsl(i1), ABS_EXPRl);
|
||||
CHECK_EXPR (((void)i1,(double)i2), COMPOUND_EXPR);
|
||||
CHECK_EXPR ((double)i1+i2, PLUS_EXPR);
|
||||
CHECK_EXPR ((double)i1-i2, MINUS_EXPR);
|
||||
|
|
|
|||
|
|
@ -15,10 +15,6 @@ extern void link_error(int);
|
|||
extern float FUNC##f (float); \
|
||||
extern double FUNC (double); \
|
||||
extern long double FUNC##l (long double)
|
||||
#define DECLARE_L(FUNC) \
|
||||
extern long FUNC##f (float); \
|
||||
extern long FUNC (double); \
|
||||
extern long FUNC##l (long double)
|
||||
#define DECLARE2(FUNC) \
|
||||
extern float FUNC##f (float, float); \
|
||||
extern double FUNC (double, double); \
|
||||
|
|
@ -26,9 +22,6 @@ extern void link_error(int);
|
|||
|
||||
DECLARE2(fmin);
|
||||
DECLARE2(fmax);
|
||||
DECLARE_L(lround);
|
||||
DECLARE_L(lrint);
|
||||
DECLARE(sqrt);
|
||||
DECLARE(fabs);
|
||||
extern int pure(int) __attribute__ ((__pure__));
|
||||
|
||||
|
|
@ -52,20 +45,32 @@ extern int pure(int) __attribute__ ((__pure__));
|
|||
link_error(__LINE__); \
|
||||
} while (0)
|
||||
|
||||
/* Test that lround(FUNC(int,int)) == lrint(FUNC(int,int)), i.e. both
|
||||
lround() and lrint() should be folded away. */
|
||||
#define TEST_NONNEG(FUNC) do { \
|
||||
if (lroundf(FUNC##f(i,j)) != lrintf(FUNC##f(i,j))) \
|
||||
/* Test that FIXFUNC(FUNC(int1,int2)) == (TYPE)FUNC(int1,int2),
|
||||
i.e. FIXFUNC should be folded away and replaced with a cast. */
|
||||
#define TEST_FIXFUNC(FUNC,FIXFUNC,TYPE) do { \
|
||||
if (FIXFUNC##f(FUNC##f(i,j)) != (TYPE)FUNC##f(i,j)) \
|
||||
link_error(__LINE__); \
|
||||
if (lround(FUNC(i,j)) != lrint(FUNC(i,j))) \
|
||||
if (FIXFUNC(FUNC(i,j)) != (TYPE)FUNC(i,j)) \
|
||||
link_error(__LINE__); \
|
||||
if (lroundl(FUNC##l(i,j)) != lrintl(FUNC##l(i,j))) \
|
||||
if (FIXFUNC##l(FUNC##l(i,j)) != (TYPE)FUNC##l(i,j)) \
|
||||
link_error(__LINE__); \
|
||||
} while (0)
|
||||
|
||||
/* Test that FUNC(int1,int2) has an integer return type. */
|
||||
#define TEST_INT(FUNC) do { \
|
||||
TEST_FIXFUNC(FUNC,__builtin_lround,long); \
|
||||
TEST_FIXFUNC(FUNC,__builtin_llround,long long); \
|
||||
TEST_FIXFUNC(FUNC,__builtin_lrint,long); \
|
||||
TEST_FIXFUNC(FUNC,__builtin_llrint,long long); \
|
||||
TEST_FIXFUNC(FUNC,__builtin_lceil,long); \
|
||||
TEST_FIXFUNC(FUNC,__builtin_llceil,long long); \
|
||||
TEST_FIXFUNC(FUNC,__builtin_lfloor,long); \
|
||||
TEST_FIXFUNC(FUNC,__builtin_llfloor,long long); \
|
||||
} while (0)
|
||||
|
||||
/* Test that (long)fabs(FUNC(fabs(x),fabs(y))) ==
|
||||
(long)FUNC(fabs(x),fabs(y)). We cast to (long) so "!=" folds. */
|
||||
#define TEST_INT(FUNC) do { \
|
||||
#define TEST_NONNEG(FUNC) do { \
|
||||
if ((long)fabsf(FUNC##f(fabsf(xf),fabsf(yf))) != (long)FUNC##f(fabsf(xf),fabsf(yf))) \
|
||||
link_error(__LINE__); \
|
||||
if ((long)fabs(FUNC(fabs(x),fabs(y))) != (long)FUNC(fabs(x),fabs(y))) \
|
||||
|
|
|
|||
|
|
@ -144,8 +144,12 @@ void test(double d1, double d2, float f1, float f2,
|
|||
ARG1TEST1 (floor);
|
||||
ARG1TEST2 (fmod);
|
||||
ARG1TEST2_A2INT (ldexp, int);
|
||||
ARG1TEST1_RTYPE (__builtin_llceil, long long);
|
||||
ARG1TEST1_RTYPE (__builtin_llfloor, long long);
|
||||
ARG1TEST1_RTYPE (llrint, long long);
|
||||
ARG1TEST1_RTYPE (llround, long long);
|
||||
ARG1TEST1_RTYPE (__builtin_lceil, long);
|
||||
ARG1TEST1_RTYPE (__builtin_lfloor, long);
|
||||
ARG1TEST1_RTYPE (lrint, long);
|
||||
ARG1TEST1_RTYPE (lround, long);
|
||||
/* The modf* functions aren't ever "const" or "pure" even with
|
||||
|
|
|
|||
|
|
@ -7,34 +7,12 @@
|
|||
|
||||
/* { dg-do link } */
|
||||
|
||||
#define PROTOTYPE(FN) \
|
||||
PROTOTYPE_LINK_ERROR(FN) \
|
||||
extern double FN (double); \
|
||||
extern float FN##f (float); \
|
||||
extern long double FN##l (long double);
|
||||
|
||||
#define PROTOTYPE_RET(FN, RET) \
|
||||
PROTOTYPE_LINK_ERROR(FN) \
|
||||
extern RET FN (double); \
|
||||
extern RET FN##f (float); \
|
||||
extern RET FN##l (long double);
|
||||
|
||||
#define PROTOTYPE_LINK_ERROR(FN) \
|
||||
extern void link_error_##FN(void); \
|
||||
extern void link_error_##FN##f(void); \
|
||||
extern void link_error_##FN##l(void);
|
||||
extern int link_error (int);
|
||||
|
||||
#define TEST(FN, VALUE, RESULT) \
|
||||
if (FN (VALUE) != RESULT) link_error_##FN(); \
|
||||
if (FN##f (VALUE) != RESULT) link_error_##FN##f(); \
|
||||
if (FN##l (VALUE) != RESULT) link_error_##FN##l(); \
|
||||
|
||||
PROTOTYPE (trunc);
|
||||
PROTOTYPE (floor);
|
||||
PROTOTYPE (ceil);
|
||||
PROTOTYPE (round);
|
||||
PROTOTYPE_RET (lround, long);
|
||||
PROTOTYPE_RET (llround, long long);
|
||||
if (__builtin_##FN (VALUE) != RESULT) link_error (__LINE__); \
|
||||
if (__builtin_##FN##f (VALUE) != RESULT) link_error (__LINE__); \
|
||||
if (__builtin_##FN##l (VALUE) != RESULT) link_error (__LINE__); \
|
||||
|
||||
int
|
||||
main (void)
|
||||
|
|
@ -45,6 +23,10 @@ main (void)
|
|||
TEST(round, 0, 0);
|
||||
TEST(lround, 0, 0);
|
||||
TEST(llround, 0, 0);
|
||||
TEST(lfloor, 0, 0);
|
||||
TEST(llfloor, 0, 0);
|
||||
TEST(lceil, 0, 0);
|
||||
TEST(llceil, 0, 0);
|
||||
|
||||
TEST(trunc, 6, 6);
|
||||
TEST(floor, 6, 6);
|
||||
|
|
@ -52,6 +34,10 @@ main (void)
|
|||
TEST(round, 6, 6);
|
||||
TEST(lround, 6, 6);
|
||||
TEST(llround, 6, 6);
|
||||
TEST(lfloor, 6, 6);
|
||||
TEST(llfloor, 6, 6);
|
||||
TEST(lceil, 6, 6);
|
||||
TEST(llceil, 6, 6);
|
||||
|
||||
TEST(trunc, -8, -8);
|
||||
TEST(floor, -8, -8);
|
||||
|
|
@ -59,6 +45,10 @@ main (void)
|
|||
TEST(round, -8, -8);
|
||||
TEST(lround, -8, -8);
|
||||
TEST(llround, -8, -8);
|
||||
TEST(lfloor, -8, -8);
|
||||
TEST(llfloor, -8, -8);
|
||||
TEST(lceil, -8, -8);
|
||||
TEST(llceil, -8, -8);
|
||||
|
||||
TEST(trunc, 3.2, 3);
|
||||
TEST(floor, 3.2, 3);
|
||||
|
|
@ -66,6 +56,10 @@ main (void)
|
|||
TEST(round, 3.2, 3);
|
||||
TEST(lround, 3.2, 3);
|
||||
TEST(llround, 3.2, 3);
|
||||
TEST(lfloor, 3.2, 3);
|
||||
TEST(llfloor, 3.2, 3);
|
||||
TEST(lceil, 3.2, 4);
|
||||
TEST(llceil, 3.2, 4);
|
||||
|
||||
TEST(trunc, -2.8, -2);
|
||||
TEST(floor, -2.8, -3);
|
||||
|
|
@ -73,6 +67,10 @@ main (void)
|
|||
TEST(round, -2.8, -3);
|
||||
TEST(lround, -2.8, -3);
|
||||
TEST(llround, -2.8, -3);
|
||||
TEST(lfloor, -2.8, -3);
|
||||
TEST(llfloor, -2.8, -3);
|
||||
TEST(lceil, -2.8, -2);
|
||||
TEST(llceil, -2.8, -2);
|
||||
|
||||
TEST(trunc, 0.01, 0);
|
||||
TEST(floor, 0.01, 0);
|
||||
|
|
@ -80,6 +78,10 @@ main (void)
|
|||
TEST(round, 0.01, 0);
|
||||
TEST(lround, 0.01, 0);
|
||||
TEST(llround, 0.01, 0);
|
||||
TEST(lfloor, 0.01, 0);
|
||||
TEST(llfloor, 0.01, 0);
|
||||
TEST(lceil, 0.01, 1);
|
||||
TEST(llceil, 0.01, 1);
|
||||
|
||||
TEST(trunc, -0.7, 0);
|
||||
TEST(floor, -0.7, -1);
|
||||
|
|
@ -87,6 +89,10 @@ main (void)
|
|||
TEST(round, -0.7, -1);
|
||||
TEST(lround, -0.7, -1);
|
||||
TEST(llround, -0.7, -1);
|
||||
TEST(lfloor, -0.7, -1);
|
||||
TEST(llfloor, -0.7, -1);
|
||||
TEST(lceil, -0.7, 0);
|
||||
TEST(llceil, -0.7, 0);
|
||||
|
||||
TEST(trunc, 2.5, 2);
|
||||
TEST(floor, 2.5, 2);
|
||||
|
|
@ -94,6 +100,10 @@ main (void)
|
|||
TEST(round, 2.5, 3);
|
||||
TEST(lround, 2.5, 3);
|
||||
TEST(llround, 2.5, 3);
|
||||
TEST(lfloor, 2.5, 2);
|
||||
TEST(llfloor, 2.5, 2);
|
||||
TEST(lceil, 2.5, 3);
|
||||
TEST(llceil, 2.5, 3);
|
||||
|
||||
TEST(trunc, -1.5, -1);
|
||||
TEST(floor, -1.5, -2);
|
||||
|
|
@ -101,6 +111,10 @@ main (void)
|
|||
TEST(round, -1.5, -2);
|
||||
TEST(lround, -1.5, -2);
|
||||
TEST(llround, -1.5, -2);
|
||||
TEST(lfloor, -1.5, -2);
|
||||
TEST(llfloor, -1.5, -2);
|
||||
TEST(lceil, -1.5, -1);
|
||||
TEST(llceil, -1.5, -1);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue