Re: About GSOC.

[Tejas Joshi <tejasjoshi9673@gmail.com>]

[-- Attachment #1: Type: text/plain, Size: 7124 bytes --]

Hello.
I have developed a fairly working patch for roundeven, attaching herewith.
The testcase function as follows :

double f()
{
  double x = 4.5;
  double ret = __builtin_roundeven (x);
  return ret;
}

We can inspect the file foo.c.028t.ccp1, where we can see f() returns
value 4.0e+0.
I am also writing the proposal and make draft ready in couple of days
for community review.
Do roundeven have to be added in internals-fn.def to be called internal?

Thanks,
-Tejas


On Sun, 24 Feb 2019 at 17:39, Tejas Joshi <tejasjoshi9673@gmail.com> wrote:
>
> Hello.
> I had a little pause on roundeven due to seminars in my college. I've
> tried to implement roundeven but can not figure out what are just
> minimal needs to roundeven be called for a test program like
> __builtin_roundeven();
> Also, build exited returning status as:
>
> DEF_INTERNAL_FLT_FN (ROUNDEVEN) has no associated built-in functions
>
> Here is the .diff flie.
>
> Thanks,
> -Tejas
>
> On Mon, 4 Feb 2019 at 22:55, Tejas Joshi <tejasjoshi9673@gmail.com> wrote:
> >
> > Hi.
> > Although now, I am unable to build the compiler.
> > The build exited returning status as:
> >
> > DEF_INTERNAL_FLT_FN (ROUNDEVEN) has no associated built-in functions
> >
> > I have added the entry in fold_const_call_ss() and do not find any
> > other place to add the case.
> > Here is the latest patch.
> >
> > On Mon, 4 Feb 2019 at 22:14, Prathamesh Kulkarni
> > <prathamesh.kulkarni@linaro.org> wrote:
> > >
> > > On Mon, 4 Feb 2019 at 21:27, Tejas Joshi <tejasjoshi9673@gmail.com> wrote:
> > > >
> > > > Thanks.
> > > > > Did you add an entry for roundeven in builtins.def ?
> > > > Yes, I did.
> > > >
> > > > Find here the attached patch.diff for which I did the changes to
> > > > implement roundeven. There might be some unnecessary changes and some
> > > > necessary changes which have not been made.
> > > You haven't called roundeven() in the patch. You'll need to add an
> > > entry in fold_const_call_ss()
> > > similar to real_ceil, and probably in other places too.
> > >
> > > Thanks,
> > > Prathamesh
> > > >
> > > > Regards,
> > > > -Tejas
> > > >
> > > > On Mon, 4 Feb 2019 at 20:36, Prathamesh Kulkarni
> > > > <prathamesh.kulkarni@linaro.org> wrote:
> > > > >
> > > > > On Mon, 4 Feb 2019 at 20:10, Tejas Joshi <tejasjoshi9673@gmail.com> wrote:
> > > > > >
> > > > > > Hello.
> > > > > > I have implemented roundeven function in real.c as follows: (and
> > > > > > respective changes in real.h)
> > > > > It's a better idea to include all changes in patch instead of copy-pasting.
> > > > > Use the command:
> > > > > git diff > patch.diff
> > > > > which will create a file called "patch.diff" containing the changes
> > > > > and send it as an attachment.
> > > > > >
> > > > > > /* Round X to nearest even integer towards zero. */
> > > > > >
> > > > > > void
> > > > > > real_roundeven (REAL_VALUE_TYPE *r, format_helper fmt,
> > > > > >         const REAL_VALUE_TYPE *x)
> > > > > > {
> > > > > >   REAL_VALUE_TYPE t;
> > > > > >
> > > > > >   do_fix_trunc (&t, x);
> > > > > >   HOST_WIDE_INT i = real_to_integer (&t);
> > > > > >   if(i % 2)
> > > > > >     do_add (r, &t, &dconstm1, 0);
> > > > > >   else
> > > > > >     *r = t;
> > > > > > }
> > > > > >
> > > > > > Although I cant get it to test like
> > > > > >
> > > > > > int foo()
> > > > > > {
> > > > > >     double x = __builtin_roundeven (3.5);
> > > > > >     printf("%f",x);
> > > > > >     return (int) x;
> > > > > > }
> > > > > > Because I do not know its dependencies through other files. I tried to
> > > > > > track them down by inspecting real_ceil function, but it also includes
> > > > > > other optimization procedures like folding. How do I know enough
> > > > > > declarations to be made in respective files?
> > > > > Did you add an entry for roundeven in builtins.def ?
> > > > >
> > > > > Thanks,
> > > > > Prathamesh
> > > > > >
> > > > > > Thanks.
> > > > > > -Tejas
> > > > > >
> > > > > > On Mon, 28 Jan 2019 at 22:33, Tejas Joshi <tejasjoshi9673@gmail.com> wrote:
> > > > > > >
> > > > > > > Hello.
> > > > > > > Representations of real numbers in real.c are a little complex to
> > > > > > > understand right now for me. I am still trying to understand them and
> > > > > > > figure them out using gdb and cscope. Though conventions are given in
> > > > > > > comments in real.c, I will still be trying to figure it out. The
> > > > > > > equation and its bitwise representation is not pretty elaborated in
> > > > > > > any documentation I could find.
> > > > > > >
> > > > > > > x = s * b^e * \sum_{k=1}^p f_k * b^{-k}
> > > > > > >
> > > > > > >     where
> > > > > > >         s = sign (+- 1)
> > > > > > >         b = base or radix, here always 2
> > > > > > >         e = exponent
> > > > > > >         p = precision (the number of base-b digits in the significand)
> > > > > > >         f_k = the digits of the significand.
> > > > > > >
> > > > > > > In mean time, I've tried real_round function to work like roundeven. I
> > > > > > > will try to submit a clean patch along with roundeven implemented
> > > > > > > separately with changes like in builtins.def, adding cases, etc.
> > > > > > >
> > > > > > > void
> > > > > > > real_round (REAL_VALUE_TYPE *r, format_helper fmt,
> > > > > > >         const REAL_VALUE_TYPE *x)
> > > > > > > {
> > > > > > > #if 0
> > > > > > >   do_add (r, x, &dconsthalf, x->sign);
> > > > > > >   do_fix_trunc (r, r);
> > > > > > >   if (fmt)
> > > > > > >     real_convert (r, fmt, r);
> > > > > > > #endif
> > > > > > >   fprintf (stderr, "\nhere\n");
> > > > > > >   real_value z;
> > > > > > >   do_fix_trunc (&z, x);
> > > > > > >   HOST_WIDE_INT i = real_to_integer (&z);
> > > > > > >   fprintf (stderr, "\n i = %ld\n", i);
> > > > > > >   if (i % 2)
> > > > > > >     do_add (r, &z, &dconstm1, 0);
> > > > > > >   else
> > > > > > >     *r = z;
> > > > > > > }
> > > > > > >
> > > > > > > Thanks.
> > > > > > > -Tejas
> > > > > > >
> > > > > > > On Sat, 26 Jan 2019 at 03:02, Joseph Myers <joseph@codesourcery.com> wrote:
> > > > > > > >
> > > > > > > > On Sat, 26 Jan 2019, Tejas Joshi wrote:
> > > > > > > >
> > > > > > > > > function with byte-byte comparison which also include mpfr. (Correct
> > > > > > > > > me if I am wrong.) What is the significance of mpfr related to these
> > > > > > > > > internal representations?
> > > > > > > >
> > > > > > > > real.c provides a fixed-size representation of floating-point numbers that
> > > > > > > > allows for various non-IEEE formats supported by GCC, and also allows
> > > > > > > > functions from dfp.c to be used for decimal floating-point formats.
> > > > > > > >
> > > > > > > > MPFR is used in GCC to provide operations that are nontrivial to
> > > > > > > > implement, especially those that are nontrivial to implement in such a
> > > > > > > > fixed-size context.  real.c operations wrap around MPFR ones where
> > > > > > > > appropriate, doing whatever's needed in cases where there are non-IEEE
> > > > > > > > semantics or sets of values.
> > > > > > > >
> > > > > > > > --
> > > > > > > > Joseph S. Myers
> > > > > > > > joseph@codesourcery.com

[-- Attachment #2: roundeven.patch --]
[-- Type: text/x-patch, Size: 4321 bytes --]

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..e1d593a8765 100644
--- a/gcc/builtins.def
+++ b/gcc/builtins.def
@@ -542,6 +542,9 @@ 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)
diff --git a/gcc/fold-const-call.c b/gcc/fold-const-call.c
index 06a420601c0..7eafd91e9a2 100644
--- a/gcc/fold-const-call.c
+++ b/gcc/fold-const-call.c
@@ -792,6 +792,14 @@ fold_const_call_ss (real_value *result, combined_fn fn,
 	}
       return false;
 
+    case CFN_BUILT_IN_ROUNDEVEN:
+      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 +862,9 @@ fold_const_call_ss (wide_int *result, combined_fn fn,
       return fold_const_conversion (result, real_round, arg,
 				    precision, format);
 
+    case CFN_BUILT_IN_ROUNDEVEN:
+      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..30c409e95bf 100644
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -329,6 +329,7 @@ negate_mathfn_p (combined_fn fn)
     CASE_CFN_LLROUND:
     CASE_CFN_LROUND:
     CASE_CFN_ROUND:
+    CASE_CFN_ROUNDEVEN:
     CASE_CFN_SIN:
     CASE_CFN_SINH:
     CASE_CFN_TAN:
@@ -13060,6 +13061,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 +13586,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 f822ae82d61..087478841e5 100644
--- a/gcc/real.c
+++ b/gcc/real.c
@@ -5010,6 +5010,22 @@ real_round (REAL_VALUE_TYPE *r, format_helper fmt,
     real_convert (r, fmt, r);
 }
 
+/* Round X to nearest even integer towards zero. */
+
+void
+real_roundeven (REAL_VALUE_TYPE *r, format_helper fmt,
+		const REAL_VALUE_TYPE *x)
+{
+  REAL_VALUE_TYPE t;
+
+  do_fix_trunc (&t, x);
+  HOST_WIDE_INT i = real_to_integer (&t);
+  if(i % 2)
+    do_add (r, &t, &dconstm1, 0);
+  else
+    *r = t;
+}
+
 /* Set the sign of R to the sign of X.  */
 
 void
diff --git a/gcc/real.h b/gcc/real.h
index 0ce42565708..10898eae79e 100644
--- a/gcc/real.h
+++ b/gcc/real.h
@@ -499,6 +499,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 *);

[-- Attachment #3: foo.c.028t.ccp1 --]
[-- Type: application/octet-stream, Size: 1149 bytes --]


;; Function f (f, funcdef_no=0, decl_uid=1907, cgraph_uid=1, symbol_order=0)

Adding destination of edge (0 -> 2) to worklist

Simulating block 2

Visiting statement:
x_1 = 4.5e+0;
which is likely CONSTANT
Lattice value changed to CONSTANT 4.5e+0.  Adding SSA edges to worklist.
marking stmt to be not simulated again

Visiting statement:
ret_2 = __builtin_roundeven (x_1);
which is likely CONSTANT
Match-and-simplified __builtin_roundeven (x_1) to 4.0e+0
Lattice value changed to CONSTANT 4.0e+0.  Adding SSA edges to worklist.
marking stmt to be not simulated again

Visiting statement:
_3 = ret_2;
which is likely CONSTANT
Match-and-simplified ret_2 to 4.0e+0
Lattice value changed to CONSTANT 4.0e+0.  Adding SSA edges to worklist.
marking stmt to be not simulated again

Visiting statement:
return _3;
No interesting values produced.  Marked VARYING.

Substituting values and folding statements

Folding statement: return _3;
Folded into: return 4.0e+0;

Removing dead stmt _3 = ret_2;

Removing dead stmt ret_2 = __builtin_roundeven (x_1);

Removing dead stmt x_1 = 4.5e+0;

f ()
{
  double ret;
  double x;

  <bb 2> :
  return 4.0e+0;

}