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 <[email protected]> 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 <[email protected]> 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
> > [email protected]
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 *);
