Kaveh R. GHAZI - [PATCH]: add folding of builtin modf (original) (raw)

This is the mail archive of the gcc-patches@gcc.gnu.orgmailing list for the GCC project.

Index Nav:	[Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav:	[Date Prev] [Date Next]	[Thread Prev] [Thread Next]
Other format:	[Raw text]

From: "Kaveh R. GHAZI"
To: gcc-patches at gcc dot gnu dot org
Date: Sat, 24 Feb 2007 10:37:30 -0500 (EST)
Subject: [PATCH]: add folding of builtin modf

This patch adds folding of builtin modf when the first argument is a constant.

Tested on sparc-sun-solaris2.10, no regressions.

Okay for mainline?

    Thanks,
    --Kaveh

2007-02-24 Kaveh R. Ghazi ghazi@caip.rutgers.edu

* builtins.c (fold_builtin_modf): New.
(fold_builtin_2): Use it.

testsuite: * gcc.dg/torture/builtin-modf-1.c: New test.

diff -rup orig/egcc-SVN20070223/gcc/builtins.c egcc-SVN20070223/gcc/builtins.c --- orig/egcc-SVN20070223/gcc/builtins.c 2007-02-23 09:49:47.000000000 -0500 +++ egcc-SVN20070223/gcc/builtins.c 2007-02-24 00:40:02.563843168 -0500 @@ -9214,6 +9214,62 @@ fold_builtin_load_exponent (tree arg0, t return NULL_TREE; }

+/* Fold a call to builtin modf. */ + +static tree +fold_builtin_modf (tree arg0, tree arg1, tree rettype) +{

if (! validate_arg (arg0, REAL_TYPE) || ! validate_arg (arg1, POINTER_TYPE))
return NULL_TREE;
STRIP_NOPS (arg0);
if (!(TREE_CODE (arg0) == REAL_CST && ! TREE_OVERFLOW (arg0)))
return NULL_TREE;
arg1 = build_fold_indirect_ref (arg1);
/* Proceed if a valid pointer type was passed in. */
if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1)) == TYPE_MAIN_VARIANT (rettype))
{

 const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg0);

```
 REAL_VALUE_TYPE trunc, frac;
```
```
 switch (value->cl)
```
```
 {
```
```
 case rvc_nan:
```
```
 case rvc_zero:
```
/* For +-NaN or +-0, return (*arg1 = arg0, arg0). */
trunc = frac = *value;
break;
```
 case rvc_inf:
```
/* For +-Inf, return (*arg1 = arg0, +-0). */
frac = dconst0;
frac.sign = value->sign;
trunc = *value;
break;
```
 case rvc_normal:
```
/* Return (*arg1 = trunc(arg0), arg0-trunc(arg0)). */
real_trunc (&trunc, VOIDmode, value);
real_arithmetic (&frac, MINUS_EXPR, value, &trunc);
/* If the original number was negative and already

  integral, then the fractional part is -0.0.  */

if (value->sign && frac.cl == rvc_zero)
```
 frac.sign = value->sign;
```
break;
```
 }
```

 /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */

 arg1 = fold_build2 (MODIFY_EXPR, rettype, arg1,

```
       build_real (rettype, trunc));
```
```
 TREE_SIDE_EFFECTS (arg1) = 1;
```

 return fold_build2 (COMPOUND_EXPR, rettype, arg1,

```
       build_real (rettype, frac));
```
}
return NULL_TREE; +}
/* Fold a call to __builtin_isnan(), __builtin_isinf, __builtin_finite. ARG is the argument for the call. */

@@ -9690,6 +9746,9 @@ fold_builtin_2 (tree fndecl, tree arg0, CASE_FLT_FN (BUILT_IN_FREXP): return fold_builtin_frexp (arg0, arg1, type);

CASE_FLT_FN (BUILT_IN_MODF):

 return fold_builtin_modf (arg0, arg1, type);

case BUILT_IN_BZERO:
  return fold_builtin_bzero (arg0, arg1, ignore);

diff -rup orig/egcc-SVN20070223/gcc/testsuite/gcc.dg/torture/builtin-modf-1.c egcc-SVN20070223/gcc/testsuite/gcc.dg/torture/builtin-modf-1.c --- orig/egcc-SVN20070223/gcc/testsuite/gcc.dg/torture/builtin-modf-1.c 2007-02-23 11:30:15.106672005 -0500 +++ egcc-SVN20070223/gcc/testsuite/gcc.dg/torture/builtin-modf-1.c 2007-02-24 01:08:14.114118356 -0500 @@ -0,0 +1,159 @@ +/* Copyright (C) 2007 Free Software Foundation. +

Verify that built-in folding of modf is correctly performed by the
compiler.
Origin: Kaveh R. Ghazi, February 23, 2007. */
+/* { dg-do link } */
+extern void link_error(int);
+/* Return TRUE if the sign of X != sign of Y. This is important when
comparing signed zeros. */ +#define CKSGN_F(X,Y) \
(__builtin_copysignf(1.0F,(X)) != __builtin_copysignf(1.0F,(Y))) +#define CKSGN(X,Y) \
(__builtin_copysign(1.0,(X)) != __builtin_copysign(1.0,(Y))) +#define CKSGN_L(X,Y) \
(__builtin_copysignl(1.0L,(X)) != __builtin_copysignl(1.0L,(Y)))
+/* We use these macros if we can only check these when optimizing. In
some cases we rely on other optimizations to propagate the value
and fold away certain constructs. Likewise for the sign testing.
TRUE means an error occurred. */ +#ifdef OPTIMIZE +#define CKRES(X) (X) +#define CKIPTR(X,Y) X != Y +#define CKSGN_IPTR_F(X,Y) CKSGN_F(X,Y) +#define CKSGN_IPTR(X,Y) CKSGN(X,Y) +#define CKSGN_IPTR_L(X,Y) CKSGN_L(X,Y) +#else +#define CKRES(X) 0 +#define CKIPTR(X,Y) 0 +#define CKSGN_IPTR_F(X,Y) 0 +#define CKSGN_IPTR(X,Y) 0 +#define CKSGN_IPTR_L(X,Y) 0 +#endif
+/* Test that modf(ARG1,&iptr) == FRACRES && iptr == INTRES. Check the
sign in case we get -0.0. */ +#define TESTIT_MODF(ARG,INTRES,FRACRES) do { \
float iptrf = 0.5; double iptr = 0.5; long double iptrl = 0.5; \
if (__builtin_modff(ARG##f,&iptrf) != FRACRES##f \
```
 || CKIPTR(iptrf,INTRES##f) \
```

 || CKSGN_F(__builtin_modff(ARG##f,&iptrf),FRACRES##f) \

```
 || CKSGN_IPTR_F(iptrf,INTRES##f)) \
```
link_error(LINE); \
if (__builtin_modf(ARG,&iptr) != FRACRES \
```
 || CKIPTR(iptr,INTRES) \
```

 || CKSGN(__builtin_modf(ARG,&iptr),FRACRES) \

```
 || CKSGN_IPTR(iptr,INTRES)) \
```
link_error(LINE); \
if (__builtin_modfl(ARG##l,&iptrl) != FRACRES##l \
```
 || CKIPTR(iptrl,INTRES##l) \
```

 || CKSGN_L(__builtin_modfl(ARG##l,&iptrl),FRACRES##l) \

```
 || CKSGN_IPTR_L(iptrl,INTRES##l)) \
```
link_error(LINE); \
} while (0)
+/* Test that modf(NEG FUNCARG(ARGARG, &iptr)) == FRACRES &&
FUNCRES(iptr) is true. Check the sign of both as well. This is
for checking an argument of Inf. */ +#define TESTIT_MODF2(NEG,FUNCARG,ARGARG,FUNCRES,FRACRES) do { \
float iptrf = 0.5; double iptr = 0.5; long double iptrl = 0.5; \
if (__builtin_modff(NEG _builtin##FUNCARG##f(ARGARG),&iptrf) != FRACRES##f \

 || CKSGN_F(__builtin_modff(NEG __builtin_##FUNCARG##f(ARGARG),&iptrf), FRACRES##f) \

 || CKIPTR(!__builtin_##FUNCRES##f(iptrf),0) \

```
 || CKSGN_IPTR_F(iptrf,FRACRES##f)) \
```
link_error(LINE); \
if (__builtin_modf(NEG _builtin##FUNCARG(ARGARG),&iptr) != FRACRES \

 || CKSGN(__builtin_modf(NEG __builtin_##FUNCARG(ARGARG),&iptr), FRACRES) \

 || CKIPTR(!__builtin_##FUNCRES(iptr),0) \

```
 || CKSGN_IPTR(iptr,FRACRES)) \
```
link_error(LINE); \
if (__builtin_modfl(NEG _builtin##FUNCARG##l(ARGARG),&iptrl) != FRACRES##l \

 || CKSGN_L(__builtin_modfl(NEG __builtin_##FUNCARG##l(ARGARG),&iptrl), FRACRES##l) \

 || CKIPTR(!__builtin_##FUNCRES##l(iptrl),0) \

```
 || CKSGN_IPTR_L(iptrl,FRACRES##l)) \
```
link_error(LINE); \
} while (0)
+/* Test that FUNCRES(modf(NEG FUNCARG(ARGARG, &iptr))) is true &&
FUNCRES(iptr) is true. Check the sign of both as well. This is
for checking an argument of NaN. */ +#define TESTIT_MODF3(NEG,FUNCARG,ARGARG,FUNCRES) do { \
float iptrf = 0.5; double iptr = 0.5; long double iptrl = 0.5; \
if (CKRES(!_builtin##FUNCRES##f(__builtin_modff(NEG _builtin##FUNCARG##f(ARGARG),&iptrf))) \

 || CKSGN_F(__builtin_modff(NEG __builtin_##FUNCARG##f(ARGARG),&iptrf), NEG 1) \

 || CKIPTR(!__builtin_##FUNCRES##f(iptrf),0) \

```
 || CKSGN_IPTR_F(iptrf,NEG 1)) \
```
link_error(LINE); \
if (CKRES(!_builtin##FUNCRES(__builtin_modf(NEG _builtin##FUNCARG(ARGARG),&iptr))) \

 || CKSGN(__builtin_modf(NEG __builtin_##FUNCARG(ARGARG),&iptr), NEG 1) \

 || CKIPTR(!__builtin_##FUNCRES(iptr),0) \

```
 || CKSGN_IPTR(iptr,NEG 1)) \
```
link_error(LINE); \
if (CKRES(!_builtin##FUNCRES##l(__builtin_modfl(NEG _builtin##FUNCARG##l(ARGARG),&iptrl))) \

 || CKSGN_L(__builtin_modfl(NEG __builtin_##FUNCARG##l(ARGARG),&iptrl), NEG 1) \

 || CKIPTR(!__builtin_##FUNCRES##l(iptrl),0) \

```
 || CKSGN_IPTR_L(iptrl,NEG 1)) \
```
link_error(LINE); \
} while (0)
+void attribute ((noinline)) +foo(void) +{
/* Test that modf(ARG1,&iptr) -> ARG3 && iptr == ARG2. */
TESTIT_MODF (0x1p10F+0.5, 0x1p10, 0.5);
TESTIT_MODF (0x1p10F+0x1p-10, 0x1p10, 0x1p-10);
TESTIT_MODF (12345678L/17.0, 726216.0, -726216L+12345678L/17.0);
TESTIT_MODF (555.555, 555.0, -555+555.555);
TESTIT_MODF (5000/11.0, 454.0, -454+5000/11.0);
TESTIT_MODF (1000/7.0, 142.0, -142+1000/7.0);
TESTIT_MODF (123/7.0, 17.0, -17+123/7.0);
TESTIT_MODF (117/7.0, 16.0, -16+117/7.0);
TESTIT_MODF (5.5, 5.0, 0.5);
TESTIT_MODF (1.5, 1.0, 0.5);
TESTIT_MODF (4/3.0, 1.0, -1+4/3.0);
TESTIT_MODF (1.0, 1.0, 0.0);
TESTIT_MODF (0.5, 0.0, 0.5);
TESTIT_MODF (4/9.0, 0.0, 4/9.0);
TESTIT_MODF (1/3.0, 0.0, 1/3.0);
TESTIT_MODF (1/9.0, 0.0, 1/9.0);
TESTIT_MODF (0.0, 0.0, 0.0);
TESTIT_MODF (-0.0, -0.0, -0.0);
TESTIT_MODF (-1/9.0, -0.0, -1/9.0);
TESTIT_MODF (-1/3.0, -0.0, -1/3.0);
TESTIT_MODF (-4/9.0, -0.0, -4/9.0);
TESTIT_MODF (-0.5, -0.0, -0.5);
TESTIT_MODF (-1.0, -1.0, -0.0);
TESTIT_MODF (-4/3.0, -1.0, 1-4/3.0);
TESTIT_MODF (-1.5, -1.0, -0.5);
TESTIT_MODF (-5.5, -5.0, -0.5);
TESTIT_MODF (-117/7.0, -16.0, 16-117/7.0);
TESTIT_MODF (-123/7.0, -17.0, 17-123/7.0);
TESTIT_MODF (-1000/7.0, -142.0, 142-1000/7.0);
TESTIT_MODF (-5000/11.0, -454.0, 454-5000/11.0);
TESTIT_MODF (-555.555, -555.0, 555-555.555);
TESTIT_MODF (-12345678L/17.0, -726216.0, 726216L-12345678L/17.0);
TESTIT_MODF (-0x1p10F-0x1p-10, -0x1p10, -0x1p-10);
TESTIT_MODF (-0x1p10F-0.5, -0x1p10, -0.5);
/* Test for modf(+-Inf,&i) -> (i=+-0.0, +-Inf). */
TESTIT_MODF2 ( ,inf, , isinf, 0.0);
TESTIT_MODF2 (- ,inf, , isinf, -0.0);
/* Test for and modf(+-NaN,&i) -> (i=+-NaN, +-NaN). */
TESTIT_MODF3 ( ,nan, "", isnan);
TESTIT_MODF3 (- ,nan, "", isnan); +}
+int main() +{
foo();
return 0; +}

Follow-Ups:
- Re: [PATCH]: add folding of builtin modf
  * From: Richard Guenther
- Re: [PATCH]: add folding of builtin modf
  * From: Kaz Kojima

Index Nav:	[Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav:	[Date Prev] [Date Next]	[Thread Prev] [Thread Next]