Hello. Following patch is tested on following test cases in the testsuite and tests did not fail. I have considered most of the test cases this time hopefully.
/* { dg-do link } */ extern int link_error (int); #define TEST(FN, VALUE, RESULT) \ if (__builtin_##FN (VALUE) != RESULT) link_error (__LINE__); int main (void) { TEST(roundeven, 0, 0); TEST(roundeven, 0.5, 0); TEST(roundeven, -0.5, 0); TEST(roundeven, 6, 6); TEST(roundeven, -8, -8); TEST(roundeven, 2.5, 2); TEST(roundeven, 3.5, 4); TEST(roundeven, -1.5, -2); TEST(roundeven, 3.499, 3); TEST(roundeven, 3.501, 4); return 0; } _Float128 test cases : /* { dg-do link } */ /* { dg-add-options float128 } */ /* { dg-require-effective-target float128 } */ extern int link_error (int); #define TEST(FN, VALUE, RESULT) \ if (__builtin_##FN##f128 (VALUE) != RESULT) link_error (__LINE__); int main (void) { TEST(roundeven, (0x1p64+0.5f128), (0x1p64f128)); TEST(roundeven, (0x1p63+0.5f128), (0x1p63f128)); TEST(roundeven, (0x1p63-0.5f128), (0x1p63f128)); TEST(roundeven, (0x1p64-0.5f128), (0x1p64f128)); TEST(roundeven, (0x1p64+0.501f128), (0x1p64+1.0f128)); TEST(roundeven, (0x1.C00000000000039A5653p1f128), (0x1p2f128)) // the hex number is 3.50000000...01 which would fail for roundeven but not for f128 return 0; } Thanks, -Tejas On Tue, 4 Jun 2019 at 12:38, Tejas Joshi <tejasjoshi9...@gmail.com> wrote: > > Hello. > > > NaN, and you should make sure it behaves accordingly. (If it should never > > be called for them, a gcc_assert would be appropriate.) > > I can't find any documentation about how and when to use gcc_assert. > But I used it looking at the comment at its definition and locations > it is used, is this appropriate? Or is it supposed to be used before > calling the function? : > > +bool > +is_even (REAL_VALUE_TYPE *r) > +{ > + /* The function is not supposed to use for Inf and NaN. */ > + gcc_assert (r->cl != rvc_inf); > + gcc_assert (r->cl != rvc_nan); > > > So n is the bit position, and w is the word position, of the bit with > > value 1; n-1 is the position of the bit with value 0.5. > > If n is a multiple of HOST_BITS_PER_LONG (that is, the bits with values > > 0.5 and 1 are in different words), this will incorrectly return false when > > the 0.5 bit is set. > > I did not understand this. What is the bit with value 1? > But when n is a multiple of HOST_BITS_PER_LONG, the function was > computing value of w wrong (e.g. for number 2^63 + 0.5). At such time, > would the following improvisation be acceptable in is_halfway_below? > > +bool > +is_halfway_below (const REAL_VALUE_TYPE *r) > +{ > + /* The function is not supposed to use for Inf and NaN. */ > + gcc_assert (r->cl != rvc_inf); > + gcc_assert (r->cl != rvc_nan); > + int i; > + > + /* For numbers (-0.5,0) and (0,0.5). */ > + if (REAL_EXP (r) < 0) > + return false; > + > + else if (REAL_EXP (r) <= SIGNIFICAND_BITS) > + { > + unsigned int n = SIGNIFICAND_BITS - REAL_EXP (r); > + int w = n / HOST_BITS_PER_LONG; > + > + if (n % HOST_BITS_PER_LONG == 0) > + { > + if (w > 0) > + w = w - 1; > + else > + w = 0; > + } > + > + for (i = 0; i < w; ++i) > + { > + if (r->sig[i] != 0) > + return false; > + } > > Thanks. > > > On Mon, 3 Jun 2019 at 22:08, Joseph Myers <jos...@codesourcery.com> wrote: > > > > On Fri, 31 May 2019, Tejas Joshi wrote: > > > > > +/* Return true if integer part of R is even, else return false. */ > > > + > > > +bool > > > +is_even (REAL_VALUE_TYPE *r) > > > +{ > > > + if (REAL_EXP (r) <= 0) > > > + return false; > > > > But the integer part (truncation towards 0) of something in the interval > > (-1, 1) is of course even. > > > > > + else if (REAL_EXP (r) < SIGNIFICAND_BITS) > > > + { > > > + unsigned int n = SIGNIFICAND_BITS - REAL_EXP (r); > > > + int w = n / HOST_BITS_PER_LONG; > > > + > > > + unsigned long num = ((unsigned long)1 << (n % HOST_BITS_PER_LONG)); > > > + > > > + if ((r->sig[w] & num) == 0) > > > + return true; > > > + } > > > + return false; > > > +} > > > > Suppose REAL_EXP (r) == SIGNIFICAND_BITS. Then you still need to check > > the low bit in that case. > > > > Suppose REAL_EXP (r) > SIGNIFICAND_BITS. Then the number is definitely > > even, so you should return true, not false. > > > > The comment on this function needs to define what it does for infinity / > > NaN, and you should make sure it behaves accordingly. (If it should never > > be called for them, a gcc_assert would be appropriate.) > > > > What does this function do for zero? It should, of course, return that it > > is even. > > > > > +/* Return true if R is halfway between two integers, else return false. > > > */ > > > > Again, define what this does for infinity / NaN and make sure it behaves > > accordingly. > > > > > +bool > > > +is_halfway_below (const REAL_VALUE_TYPE *r) > > > +{ > > > + if (REAL_EXP (r) < 0) > > > + return false; > > > + > > > + if (REAL_EXP (r) == 0) > > > + { > > > + unsigned long temp = ((unsigned long)1 << 63); > > > > unsigned long might be 32-bit; you can't assume it's 64-bit. You may mean > > (HOST_BITS_PER_LONG - 1) instead of 63. > > > > > + if (((r->sig[SIGSZ-1] & temp) != 0) && ((r->sig[SIGSZ-1] & (temp-1)) > > > == 0)) > > > + return true; > > > + else > > > + return false; > > > > This appears only to be checking the high word, not lower bits. > > > > > + else if (REAL_EXP (r) < SIGNIFICAND_BITS) > > > + { > > > + unsigned int n = SIGNIFICAND_BITS - REAL_EXP (r); > > > + int i, w = n / HOST_BITS_PER_LONG; > > > > So n is the bit position, and w is the word position, of the bit with > > value 1; n-1 is the position of the bit with value 0.5. > > > > > + for (i = 0; i < w; ++i) > > > + { > > > + if (r->sig[i] != 0) > > > + return false; > > > + } > > > > If n is a multiple of HOST_BITS_PER_LONG (that is, the bits with values > > 0.5 and 1 are in different words), this will incorrectly return false when > > the 0.5 bit is set. > > > > > + unsigned long num = ((unsigned long)1 << ((n - 1) % > > > HOST_BITS_PER_LONG)); > > > + > > > + if (((r->sig[w] & num) != 0) && ((r->sig[w] & (num-1)) == 0)) > > > + return true; > > > > And this also needs updating to handle the case where 0.5 and 1 are in > > different words correctly; currently it's checking bits that are all one > > word too high. It's possible that for both issues, you want w to be the > > word with the 0.5 bit, not the word with the 1 bit. > > > > For all the above, please add appropriate tests in the testsuite (for > > example, where 0.5 and 1 are in different words and the above would have > > produced incorrect results). > > > > -- > > Joseph S. Myers > > jos...@codesourcery.com
diff --git a/gcc/builtins.c b/gcc/builtins.c index 25e01e4092b..0b2d6bf82f9 100644 --- a/gcc/builtins.c +++ b/gcc/builtins.c @@ -2067,6 +2067,7 @@ mathfn_built_in_2 (tree type, combined_fn fn) CASE_MATHFN (REMQUO) CASE_MATHFN_FLOATN (RINT) CASE_MATHFN_FLOATN (ROUND) + CASE_MATHFN (ROUNDEVEN) CASE_MATHFN (SCALB) CASE_MATHFN (SCALBLN) CASE_MATHFN (SCALBN) diff --git a/gcc/builtins.def b/gcc/builtins.def index ef89729fd0c..f284a3eae3b 100644 --- a/gcc/builtins.def +++ b/gcc/builtins.def @@ -542,12 +542,18 @@ DEF_C99_BUILTIN (BUILT_IN_RINTL, "rintl", BT_FN_LONGDOUBLE_LONGDOUBLE, AT #define RINT_TYPE(F) BT_FN_##F##_##F DEF_EXT_LIB_FLOATN_NX_BUILTINS (BUILT_IN_RINT, "rint", RINT_TYPE, ATTR_CONST_NOTHROW_LEAF_LIST) #undef RINT_TYPE +DEF_EXT_LIB_BUILTIN (BUILT_IN_ROUNDEVEN, "roundeven", BT_FN_DOUBLE_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_ROUNDEVENF, "roundevenf", BT_FN_FLOAT_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST) +DEF_EXT_LIB_BUILTIN (BUILT_IN_ROUNDEVENL, "roundevenl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) DEF_C99_BUILTIN (BUILT_IN_ROUND, "round", BT_FN_DOUBLE_DOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) DEF_C99_BUILTIN (BUILT_IN_ROUNDF, "roundf", BT_FN_FLOAT_FLOAT, ATTR_CONST_NOTHROW_LEAF_LIST) DEF_C99_BUILTIN (BUILT_IN_ROUNDL, "roundl", BT_FN_LONGDOUBLE_LONGDOUBLE, ATTR_CONST_NOTHROW_LEAF_LIST) #define ROUND_TYPE(F) BT_FN_##F##_##F DEF_EXT_LIB_FLOATN_NX_BUILTINS (BUILT_IN_ROUND, "round", ROUND_TYPE, ATTR_CONST_NOTHROW_LEAF_LIST) #undef ROUND_TYPE +#define ROUNDEVEN_TYPE(F) BT_FN_##F##_##F +DEF_EXT_LIB_FLOATN_NX_BUILTINS (BUILT_IN_ROUNDEVEN, "roundeven", ROUNDEVEN_TYPE, ATTR_CONST_NOTHROW_LEAF_LIST) +#undef ROUNDEVEN_TYPE DEF_EXT_LIB_BUILTIN (BUILT_IN_SCALB, "scalb", BT_FN_DOUBLE_DOUBLE_DOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) DEF_EXT_LIB_BUILTIN (BUILT_IN_SCALBF, "scalbf", BT_FN_FLOAT_FLOAT_FLOAT, ATTR_MATHFN_FPROUNDING_ERRNO) DEF_EXT_LIB_BUILTIN (BUILT_IN_SCALBL, "scalbl", BT_FN_LONGDOUBLE_LONGDOUBLE_LONGDOUBLE, ATTR_MATHFN_FPROUNDING_ERRNO) diff --git a/gcc/fold-const-call.c b/gcc/fold-const-call.c index 06a420601c0..54315d057a2 100644 --- a/gcc/fold-const-call.c +++ b/gcc/fold-const-call.c @@ -792,6 +792,15 @@ fold_const_call_ss (real_value *result, combined_fn fn, } return false; + CASE_CFN_ROUNDEVEN: + CASE_CFN_ROUNDEVEN_FN: + if (!REAL_VALUE_ISNAN (*arg) || !flag_errno_math) + { + real_roundeven (result, format, arg); + return true; + } + return false; + CASE_CFN_LOGB: return fold_const_logb (result, arg, format); @@ -854,6 +863,10 @@ fold_const_call_ss (wide_int *result, combined_fn fn, return fold_const_conversion (result, real_round, arg, precision, format); + CASE_CFN_ROUNDEVEN: + CASE_CFN_ROUNDEVEN_FN: + return fold_const_conversion (result, real_roundeven, arg, precision, format); + CASE_CFN_IRINT: CASE_CFN_LRINT: CASE_CFN_LLRINT: diff --git a/gcc/fold-const.c b/gcc/fold-const.c index 59cedeafd71..ab96f197d5f 100644 --- a/gcc/fold-const.c +++ b/gcc/fold-const.c @@ -329,6 +329,8 @@ negate_mathfn_p (combined_fn fn) CASE_CFN_LLROUND: CASE_CFN_LROUND: CASE_CFN_ROUND: + CASE_CFN_ROUNDEVEN: + CASE_CFN_ROUNDEVEN_FN: CASE_CFN_SIN: CASE_CFN_SINH: CASE_CFN_TAN: @@ -13060,6 +13062,8 @@ tree_call_nonnegative_warnv_p (tree type, combined_fn fn, tree arg0, tree arg1, CASE_CFN_RINT_FN: CASE_CFN_ROUND: CASE_CFN_ROUND_FN: + CASE_CFN_ROUNDEVEN: + CASE_CFN_ROUNDEVEN_FN: CASE_CFN_SCALB: CASE_CFN_SCALBLN: CASE_CFN_SCALBN: @@ -13583,6 +13587,8 @@ integer_valued_real_call_p (combined_fn fn, tree arg0, tree arg1, int depth) CASE_CFN_RINT_FN: CASE_CFN_ROUND: CASE_CFN_ROUND_FN: + CASE_CFN_ROUNDEVEN: + CASE_CFN_ROUNDEVEN_FN: CASE_CFN_TRUNC: CASE_CFN_TRUNC_FN: return true; diff --git a/gcc/internal-fn.def b/gcc/internal-fn.def index cda314e1121..b89918815f9 100644 --- a/gcc/internal-fn.def +++ b/gcc/internal-fn.def @@ -224,6 +224,7 @@ DEF_INTERNAL_FLT_FLOATN_FN (FLOOR, ECF_CONST, floor, unary) DEF_INTERNAL_FLT_FLOATN_FN (NEARBYINT, ECF_CONST, nearbyint, unary) DEF_INTERNAL_FLT_FLOATN_FN (RINT, ECF_CONST, rint, unary) DEF_INTERNAL_FLT_FLOATN_FN (ROUND, ECF_CONST, round, unary) +DEF_INTERNAL_FLT_FLOATN_FN (ROUNDEVEN, ECF_CONST, roundeven, unary) DEF_INTERNAL_FLT_FLOATN_FN (TRUNC, ECF_CONST, btrunc, unary) /* Binary math functions. */ diff --git a/gcc/match.pd b/gcc/match.pd index 7cc2374ffeb..fa18b499162 100644 --- a/gcc/match.pd +++ b/gcc/match.pd @@ -4229,7 +4229,7 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT) (abs @0)) /* trunc(trunc(x)) -> trunc(x), etc. */ -(for fns (TRUNC_ALL FLOOR_ALL CEIL_ALL ROUND_ALL NEARBYINT_ALL RINT_ALL) +(for fns (TRUNC_ALL FLOOR_ALL CEIL_ALL ROUND_ALL BUILT_IN_ROUNDEVEN NEARBYINT_ALL RINT_ALL) (simplify (fns (fns @0)) (fns @0))) diff --git a/gcc/optabs.def b/gcc/optabs.def index 5a67f5eed5e..eb9e22acd8f 100644 --- a/gcc/optabs.def +++ b/gcc/optabs.def @@ -267,6 +267,7 @@ OPTAB_D (fnms_optab, "fnms$a4") OPTAB_D (rint_optab, "rint$a2") OPTAB_D (round_optab, "round$a2") +OPTAB_D (roundeven_optab, "roundeven$a2") OPTAB_D (floor_optab, "floor$a2") OPTAB_D (ceil_optab, "ceil$a2") OPTAB_D (btrunc_optab, "btrunc$a2") diff --git a/gcc/real.c b/gcc/real.c index f822ae82d61..aee11e52dd4 100644 --- a/gcc/real.c +++ b/gcc/real.c @@ -5010,6 +5010,96 @@ real_round (REAL_VALUE_TYPE *r, format_helper fmt, real_convert (r, fmt, r); } +/* Return true including 0 if integer part of R is even, else return false. */ + +bool +is_even (REAL_VALUE_TYPE *r) +{ + /* The function is not supposed to use for Inf and NaN. */ + gcc_assert (r->cl != rvc_inf); + gcc_assert (r->cl != rvc_nan); + + /* For (-1,1) including 0, number is even. */ + if (REAL_EXP (r) <= 0) + return true; + + /* Check lowest bit, if not set, return true. */ + else if (REAL_EXP (r) <= SIGNIFICAND_BITS) + { + unsigned int n = SIGNIFICAND_BITS - REAL_EXP (r); + int w = n / HOST_BITS_PER_LONG; + + unsigned long num = ((unsigned long)1 << (n % HOST_BITS_PER_LONG)); + + if ((r->sig[w] & num) == 0) + return true; + } + + else if (REAL_EXP (r) > SIGNIFICAND_BITS) + return true; + + return false; +} + +/* Return true if R is halfway between two integers, else return false. */ + +bool +is_halfway_below (const REAL_VALUE_TYPE *r) +{ + /* The function is not supposed to use for Inf and NaN. */ + gcc_assert (r->cl != rvc_inf); + gcc_assert (r->cl != rvc_nan); + int i; + + /* For numbers (-0.5,0) and (0,0.5). */ + if (REAL_EXP (r) < 0) + return false; + + else if (REAL_EXP (r) <= SIGNIFICAND_BITS) + { + unsigned int n = SIGNIFICAND_BITS - REAL_EXP (r); + int w = n / HOST_BITS_PER_LONG; + + if (n % HOST_BITS_PER_LONG == 0) + { + if (w > 0) + w = w - 1; + else + w = 0; + } + + for (i = 0; i < w; ++i) + { + if (r->sig[i] != 0) + return false; + } + + unsigned long num = ((unsigned long)1 << ((n - 1) % HOST_BITS_PER_LONG)); + + if (((r->sig[w] & num) != 0) && ((r->sig[w] & (num-1)) == 0)) + return true; + } + return false; +} + +/* Round X to nearest integer, rounding halfway cases towards even. */ + +void +real_roundeven (REAL_VALUE_TYPE *r, format_helper fmt, + const REAL_VALUE_TYPE *x) +{ + if (is_halfway_below (x)) + { + do_add (r, x, &dconsthalf, x->sign); + if (!is_even (r)) + do_add (r, r, &dconstm1, x->sign); + if (fmt) + real_convert (r, fmt, r); + } + else + real_round (r, fmt, x); +} + /* Set the sign of R to the sign of X. */ void diff --git a/gcc/real.h b/gcc/real.h index 0ce42565708..ebe66d234af 100644 --- a/gcc/real.h +++ b/gcc/real.h @@ -41,11 +41,18 @@ struct GTY(()) real_value { sure they're packed together, otherwise REAL_VALUE_TYPE_SIZE will be miscomputed. */ unsigned int /* ENUM_BITFIELD (real_value_class) */ cl : 2; + /* 1 if number is decimal floating point */ unsigned int decimal : 1; + /* 1 if number is negative */ unsigned int sign : 1; + /* 1 if number is signalling */ unsigned int signalling : 1; + /* 1 if number is canonical + All are generally used for handling cases in real.c */ unsigned int canonical : 1; + /* unbiased exponent of the number */ unsigned int uexp : EXP_BITS; + /* significand of the number */ unsigned long sig[SIGSZ]; }; @@ -499,6 +506,8 @@ extern void real_ceil (REAL_VALUE_TYPE *, format_helper, const REAL_VALUE_TYPE *); extern void real_round (REAL_VALUE_TYPE *, format_helper, const REAL_VALUE_TYPE *); +extern void real_roundeven (REAL_VALUE_TYPE *, format_helper, + const REAL_VALUE_TYPE *); /* Set the sign of R to the sign of X. */ extern void real_copysign (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);