Hi,
On Wed, Aug 21 2019, Joseph Myers wrote:
> On Wed, 21 Aug 2019, Martin Jambor wrote:
>
>> 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?
>
> Yes, it would. So the patch should be retested / reposted with that
> change.
>
>> > \ No newline at end of file
>
> This should be fixed (in both places, the tests should each end with
> exactly one newline character).
>
> The new built-in functions roundeven / roundevenf / roundevenl also need
> to be added to the lists in extend.texi (the list of GNU extension
> functions for now, though once we add DEF_C2X_BUILTIN they'd go in a list
> of C2X built-in functions instead).
OK, because I will be committing the patch on Tejas's behalf anyway, I
took the liberty of doing these few last changes too:
- I replaced all REAL_VALUE_ISNAN in Tejas's patch with
REAL_VALUE_ISSIGNALING_NAN.
- I have fixed the missing newlines in the testcases
- I have listed roundeven variants in extend.texi. If I did not find
the right spot, I will gladly move to a more appropriate one.
Otherwise I have not changed the patch in any way. It has passed
bootstrap and testing on x86_64-linux, I will test on at least aarch64
too together with the followup i386 expansion patch.
Tejas, please have a quick look whether it all looks OK.
Joseph, please let me know if I can commit this to trunk.
Thanks a lot,
Martin
gcc/ChangeLog:
2019-08-21 Tejas Joshi <tejasjoshi9...@gmail.com>
Martin Jambor <mjam...@suse.cz>
* 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.
* doc/extend.texi (Other Builtins): Document roundeven and its variants.
gcc/testsuite/ChangeLog:
2019-08-21 Tejas Joshi <tejasjoshi9...@gmail.com>
* gcc.dg/torture/builtin-round-roundeven.c: New test.
* gcc.dg/torture/builtin-round-roundevenf128.c: New test.
---
gcc/builtins.c | 1 +
gcc/builtins.def | 6 ++
gcc/doc/extend.texi | 16 ++++
gcc/fold-const-call.c | 23 +++--
gcc/fold-const.c | 6 ++
gcc/real.c | 83 +++++++++++++++++++
gcc/real.h | 9 ++
.../gcc.dg/torture/builtin-round-roundeven.c | 23 +++++
.../torture/builtin-round-roundevenf128.c | 20 +++++
9 files changed, 182 insertions(+), 5 deletions(-)
create mode 100644 gcc/testsuite/gcc.dg/torture/builtin-round-roundeven.c
create mode 100644 gcc/testsuite/gcc.dg/torture/builtin-round-roundevenf128.c
diff --git a/gcc/builtins.c b/gcc/builtins.c
index 9a766e4ad63..5149d901a96 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/doc/extend.texi b/gcc/doc/extend.texi
index 2ba9b74811a..4d11f522466 100644
--- a/gcc/doc/extend.texi
+++ b/gcc/doc/extend.texi
@@ -13584,6 +13584,22 @@ Returns the openacc gang, worker or vector size
depending on whether @var{x} is
0, 1 or 2.
@end deftypefn
+@deftypefn {Built-in Function} double __builtin_roundeven (double x)
+Returns the argument @var{x} rounded to the nearest integer value in
+floating-point format, rounding halfway cases to the nearest even
+integer.
+@end deftypefn
+
+@deftypefn {Built-in Function} float __builtin_roundevenf (float x)
+Similar to @code{__builtin_roundeven}, except the argument and return
+types are @code{float}.
+@end deftypefn
+
+@deftypefn {Built-in Function} {long double} __builtin_roundevenl (long double
x)
+Similar to @code{__builtin_roundeven}, except the argument and return types
+are @code{long double}.
+@end deftypefn
+
@node Target Builtins
@section Built-in Functions Specific to Particular Target Machines
diff --git a/gcc/fold-const-call.c b/gcc/fold-const-call.c
index e21d8e11072..3a14d2a41c1 100644
--- a/gcc/fold-const-call.c
+++ b/gcc/fold-const-call.c
@@ -836,7 +836,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_ISSIGNALING_NAN (*arg))
{
real_floor (result, format, arg);
return true;
@@ -845,7 +845,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_ISSIGNALING_NAN (*arg))
{
real_ceil (result, format, arg);
return true;
@@ -854,18 +854,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_ISSIGNALING_NAN (*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_ISSIGNALING_NAN (*arg))
{
real_round (result, format, arg);
return true;
}
return false;
+ CASE_CFN_ROUNDEVEN:
+ CASE_CFN_ROUNDEVEN_FN:
+ if (!REAL_VALUE_ISSIGNALING_NAN (*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 8c711aba12a..0376cdb73a4 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:
@@ -13107,6 +13109,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:
@@ -13630,6 +13634,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..f3b7b40fc1f
--- /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;
+}
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..42c28ddb0cd
--- /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;
+}
--
2.22.0
