From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 5627 invoked by alias); 21 Aug 2019 11:41:20 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Received: (qmail 5618 invoked by uid 89); 21 Aug 2019 11:41:20 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-18.5 required=5.0 tests=AWL,BAYES_00,GIT_PATCH_0,GIT_PATCH_1,GIT_PATCH_2,GIT_PATCH_3,SPF_PASS autolearn=ham version=3.3.1 spammy=005, H*UA:https, Joshi, U*tejasjoshi9673 X-HELO: mx1.suse.de Received: from mx2.suse.de (HELO mx1.suse.de) (195.135.220.15) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Wed, 21 Aug 2019 11:41:16 +0000 Received: from relay2.suse.de (unknown [195.135.220.254]) by mx1.suse.de (Postfix) with ESMTP id EC9BBADBB; Wed, 21 Aug 2019 11:41:13 +0000 (UTC) From: Martin Jambor To: Tejas Joshi , gcc-patches@gcc.gnu.org Cc: hubicka@ucw.cz, joseph@codesourcery.com Subject: Re: [PATCH] Builtin function roundeven folding implementation In-Reply-To: References: User-Agent: Notmuch/0.29.1 (https://notmuchmail.org) Emacs/26.2 (x86_64-suse-linux-gnu) Date: Wed, 21 Aug 2019 11:52:00 -0000 Message-ID: MIME-Version: 1.0 Content-Type: text/plain X-IsSubscribed: yes X-SW-Source: 2019-08/txt/msg01483.txt.bz2 Hi Tejas, On Wed, Aug 14 2019, Tejas Joshi wrote: > Hi. > Here is a clean patch that does not fold roundeven resulting for > integer type and the conditions for folding functions > round/ceil/floor/roundeven and trunc only checks for signaling NaN. wouldn't checking for *signalling* NaNs mean using the macro REAL_VALUE_ISSIGNALING_NAN rather than REAL_VALUE_ISNAN? Joseph, would fixing this make the patch good to go? Tejas's GSoC project results would look much better if we could get this and the (already approved) follow-up patch committed by the end of the week. Thanks a lot, Martin > 2019-06-12 Tejas Joshi > > * builtins.c (mathfn_built_in_2): Added CASE_MATHFN for ROUNDEVEN. > * builtins.def: Added function definitions for roundeven function > variants. > * fold-const-call.c (fold_const_call_ss): Added case for roundeven > function call. > * fold-const.c (negate_mathfn_p): Added case for roundeven function. > (tree_call_nonnegative_warnv_p): Added case for roundeven function. > (integer_valued_real_call_p): Added case for roundeven function. > * real.c (is_even): New function. Returns true if real number is > even, otherwise returns false. > (is_halfway_below): New function. Returns true if real number is > halfway between two integers, else return false. > (real_roundeven): New function. Round real number to nearest > integer, rounding halfway cases towards even. > * real.h (real_value): Added descriptive comments. > Added function declaration for roundeven function. > > gcc/testsuite/ChangeLog: > > 2019-06-12 Tejas Joshi > > * gcc.dg/torture/builtin-round-roundeven.c: New test. > * gcc.dg/torture/builtin-round-roundevenf128.c: New test. > > On Sat, 10 Aug 2019 at 02:15, Joseph Myers wrote: >> >> On Fri, 28 Jun 2019, Tejas Joshi wrote: >> >> > + CASE_CFN_ROUNDEVEN: >> > + CASE_CFN_ROUNDEVEN_FN: >> > + if (!REAL_VALUE_ISNAN (*arg) || !flag_errno_math) >> >> Checking flag_errno_math here does not make sense. roundeven never sets >> errno (at least, TS 18661-1 makes it implementation-defined whether sNaN >> input counts as a domain error, but I'm not aware of implementations that >> make it a domain error and set errno, and typically GCC follows glibc in >> such cases in the absence of known implementations requiring a different >> approach). >> >> The only case where you need to avoid folding is where the argument is a >> signaling NaN (it's fine to fold for quiet NaNs). In that case, you need >> to avoid folding to avoid losing an exception (if the user cares about >> signaling NaNs, they probably care about exceptions) - so it still doesn't >> matter whether the library implementation also sets errno or not. >> >> (Yes, this means the existing ceil / floor / round checks should be >> adjusted just to check for signaling NaN, though that's fairly cosmetic as >> calls to those functions with quiet NaN argument still get folded via >> match.pd. trunc ought also check for signaling NaN rather than folding >> unconditionally, so all those functions should end up with the same >> conditions for folding.) >> >> > @@ -898,6 +907,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); >> > + >> >> This is the version of fold_const_call_ss for functions returning a result >> of integer type; roundeven returns an integer value in a floating-point >> type. I don't think this code should be there, and I don't think this >> version of the function should be called at all for roundeven. >> >> -- >> Joseph S. Myers >> joseph@codesourcery.com > diff --git a/gcc/builtins.c b/gcc/builtins.c > index e2ba356c0d3..8ceb077b0bf 100644 > --- a/gcc/builtins.c > +++ b/gcc/builtins.c > @@ -2056,6 +2056,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 6d41bdb4f44..8bb7027aac7 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 702c8b4057a..73dfb6980f1 100644 > --- a/gcc/fold-const-call.c > +++ b/gcc/fold-const-call.c > @@ -806,7 +806,7 @@ fold_const_call_ss (real_value *result, combined_fn fn, > > CASE_CFN_FLOOR: > CASE_CFN_FLOOR_FN: > - if (!REAL_VALUE_ISNAN (*arg) || !flag_errno_math) > + if (!REAL_VALUE_ISNAN (*arg)) > { > real_floor (result, format, arg); > return true; > @@ -815,7 +815,7 @@ fold_const_call_ss (real_value *result, combined_fn fn, > > CASE_CFN_CEIL: > CASE_CFN_CEIL_FN: > - if (!REAL_VALUE_ISNAN (*arg) || !flag_errno_math) > + if (!REAL_VALUE_ISNAN (*arg)) > { > real_ceil (result, format, arg); > return true; > @@ -824,18 +824,31 @@ fold_const_call_ss (real_value *result, combined_fn fn, > > CASE_CFN_TRUNC: > CASE_CFN_TRUNC_FN: > - real_trunc (result, format, arg); > - return true; > + if (!REAL_VALUE_ISNAN (*arg)) > + { > + real_trunc (result, format, arg); > + return true; > + } > + return false; > > CASE_CFN_ROUND: > CASE_CFN_ROUND_FN: > - if (!REAL_VALUE_ISNAN (*arg) || !flag_errno_math) > + if (!REAL_VALUE_ISNAN (*arg)) > { > real_round (result, format, arg); > return true; > } > return false; > > + CASE_CFN_ROUNDEVEN: > + CASE_CFN_ROUNDEVEN_FN: > + if (!REAL_VALUE_ISNAN (*arg)) > + { > + real_roundeven (result, format, arg); > + return true; > + } > + return false; > + > CASE_CFN_LOGB: > return fold_const_logb (result, arg, format); > > diff --git a/gcc/fold-const.c b/gcc/fold-const.c > index 0ca472d422f..07d82a17e25 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: > @@ -13063,6 +13065,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: > @@ -13586,6 +13590,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/real.c b/gcc/real.c > index 0164f097a53..0c0d8c51fe4 100644 > --- a/gcc/real.c > +++ b/gcc/real.c > @@ -5010,6 +5010,89 @@ 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. The function is not valid for rvc_inf and rvc_nan classes. */ > + > +bool > +is_even (REAL_VALUE_TYPE *r) > +{ > + gcc_assert (r->cl != rvc_inf); > + gcc_assert (r->cl != rvc_nan); > + > + if (r->cl == rvc_zero) > + return true; > + > + /* For (-1,1), 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 > + return true; > + > + return false; > +} > + > +/* Return true if R is halfway between two integers, else return > + false. The function is not valid for rvc_inf and rvc_nan classes. */ > + > +bool > +is_halfway_below (const REAL_VALUE_TYPE *r) > +{ > + 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) - 1; > + int w = n / HOST_BITS_PER_LONG; > + > + for (i = 0; i < w; ++i) > + if (r->sig[i] != 0) > + return false; > + > + unsigned long num = ((unsigned long)1 << (n % 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 95b9db83d24..2f41834ecfd 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]; > }; > > @@ -500,6 +507,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 *); > diff --git a/gcc/testsuite/gcc.dg/torture/builtin-round-roundeven.c b/gcc/testsuite/gcc.dg/torture/builtin-round-roundeven.c > new file mode 100644 > index 00000000000..f75adf6ec8a > --- /dev/null > +++ b/gcc/testsuite/gcc.dg/torture/builtin-round-roundeven.c > @@ -0,0 +1,23 @@ > +/* { 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; > +} > \ No newline at end of file > diff --git a/gcc/testsuite/gcc.dg/torture/builtin-round-roundevenf128.c b/gcc/testsuite/gcc.dg/torture/builtin-round-roundevenf128.c > new file mode 100644 > index 00000000000..592bad49623 > --- /dev/null > +++ b/gcc/testsuite/gcc.dg/torture/builtin-round-roundevenf128.c > @@ -0,0 +1,20 @@ > +/* { 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)) > + return 0; > +} > \ No newline at end of file