This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
fold math functions
- From: Jan Hubicka <jh at suse dot cz>
- To: gcc-patches at gcc dot gnu dot org, rth at cygnus dot com
- Date: Sat, 25 Jan 2003 00:08:25 +0100
- Subject: fold math functions
Hi,
now we are finally ready to actually simplify the math functions I hope.
The patch has been quite heavilly tested on hammer branch.
I am bootstrapping and regtesting it on i386 right now. OK if it
suceeds?
# Only Linux does inlclude all c99 functions at the moment.
if { ! [istarget "*linux*"] } { return 1 }
return 0
/* Verify wehther math functions are simplified. */
double sin(double);
double floor(double);
float
t(float a)
{
return sin(a);
}
float
q(float a)
{
return floor(a);
}
double
q1(float a)
{
return floor(a);
}
float
q2(double a)
{
return floor(a);
}
main()
{
if (t(0)!=0)
abort ();
if (q(0)!=0)
abort ();
if (q1(0)!=0)
abort ();
if (q2(0)!=0)
abort ();
return 1;
}
__attribute__ ((noinline))
double
floor(double a)
{
abort ();
}
__attribute__ ((noinline))
float
floorf(float a)
{
return a;
}
__attribute__ ((noinline))
double
sin(double a)
{
abort ();
}
__attribute__ ((noinline))
float
sinf(float a)
{
return a;
}
Sat Jan 25 00:04:37 CET 2003 Jan Hubicka <jh@suse.cz>
(fold_trunc_transparent_mathfn): New function.
(fold_builtin): Use it.
* convert.c (convert_to_real): Re-enable code to convert
math functions; add support for floor familly functions.
Index: builtins.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/builtins.c,v
retrieving revision 1.169
diff -c -3 -p -r1.169 builtins.c
*** builtins.c 24 Jan 2003 22:06:59 -0000 1.169
--- builtins.c 24 Jan 2003 22:52:17 -0000
*************** static tree fold_builtin_classify_type P
*** 153,158 ****
--- 157,163 ----
static tree fold_builtin_inf PARAMS ((tree, int));
static tree fold_builtin_nan PARAMS ((tree, tree, int));
static int validate_arglist PARAMS ((tree, ...));
+ static tree fold_trunc_transparent_mathfn PARAMS ((tree));
/* Return the alignment in bits of EXP, a pointer valued expression.
But don't return more than MAX_ALIGN no matter what.
*************** fold_builtin_nan (arglist, type, quiet)
*** 4423,4428 ****
--- 4423,4454 ----
return build_real (type, real);
}
+ static tree
+ fold_trunc_transparent_mathfn (exp)
+ tree exp;
+ {
+ tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
+ tree arglist = TREE_OPERAND (exp, 1);
+ enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
+
+ if (optimize && validate_arglist (arglist, REAL_TYPE, VOID_TYPE))
+ {
+ tree arg0 = strip_float_extensions (TREE_VALUE (arglist));
+ tree ftype = TREE_TYPE (exp);
+ tree newtype = TREE_TYPE (arg0);
+ tree decl;
+
+ if (TYPE_PRECISION (newtype) < TYPE_PRECISION (ftype)
+ && (decl = mathfn_built_in (newtype, fcode)))
+ {
+ arglist =
+ build_tree_list (NULL_TREE, fold (convert (newtype, arg0)));
+ return convert (ftype,
+ build_function_call_expr (decl, arglist));
+ }
+ }
+ return 0;
+ }
/* Used by constant folding to eliminate some builtin calls early. EXP is
the CALL_EXPR of a call to a builtin function. */
*************** fold_builtin (exp)
*** 4574,4579 ****
--- 4600,4622 ----
case BUILT_IN_NANSF:
case BUILT_IN_NANSL:
return fold_builtin_nan (arglist, TREE_TYPE (TREE_TYPE (fndecl)), false);
+
+ case BUILT_IN_FLOOR:
+ case BUILT_IN_FLOORF:
+ case BUILT_IN_FLOORL:
+ case BUILT_IN_CEIL:
+ case BUILT_IN_CEILF:
+ case BUILT_IN_CEILL:
+ case BUILT_IN_TRUNC:
+ case BUILT_IN_TRUNCF:
+ case BUILT_IN_TRUNCL:
+ case BUILT_IN_ROUND:
+ case BUILT_IN_ROUNDF:
+ case BUILT_IN_ROUNDL:
+ case BUILT_IN_NEARBYINT:
+ case BUILT_IN_NEARBYINTF:
+ case BUILT_IN_NEARBYINTL:
+ return fold_trunc_transparent_mathfn (exp);
default:
break;
Index: convert.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/convert.c,v
retrieving revision 1.26
diff -c -3 -p -r1.26 convert.c
*** convert.c 18 Jan 2003 22:32:06 -0000 1.26
--- convert.c 24 Jan 2003 22:52:18 -0000
*************** tree
*** 127,139 ****
convert_to_real (type, expr)
tree type, expr;
{
tree itype = TREE_TYPE (expr);
/* Disable until we figure out how to decide whether the functions are
present in runtime. */
- #if 0
- enum built_in_function fcode = builtin_mathfn_code (expr);
-
/* Convert (float)sqrt((double)x) where x is float into sqrtf(x) */
if ((fcode == BUILT_IN_SQRT
|| fcode == BUILT_IN_SQRTL
--- 127,137 ----
convert_to_real (type, expr)
tree type, expr;
{
+ enum built_in_function fcode = builtin_mathfn_code (expr);
tree itype = TREE_TYPE (expr);
/* Disable until we figure out how to decide whether the functions are
present in runtime. */
/* Convert (float)sqrt((double)x) where x is float into sqrtf(x) */
if ((fcode == BUILT_IN_SQRT
|| fcode == BUILT_IN_SQRTL
*************** convert_to_real (type, expr)
*** 155,226 ****
if (TYPE_PRECISION (TREE_TYPE (arg0)) > TYPE_PRECISION (type))
newtype = TREE_TYPE (arg0);
! /* Be careful about integer to fp conversions.
These may overflow still. */
if (FLOAT_TYPE_P (TREE_TYPE (arg0))
! && TYPE_PRECISION (newtype) <= TYPE_PRECISION (itype)
&& (TYPE_MODE (newtype) == TYPE_MODE (double_type_node)
|| TYPE_MODE (newtype) == TYPE_MODE (float_type_node)))
{
tree arglist;
! if (TYPE_MODE (type) == TYPE_MODE (float_type_node))
! switch (fcode)
! {
! case BUILT_IN_SQRT:
! case BUILT_IN_SQRTL:
! fcode = BUILT_IN_SQRTF;
! break;
! case BUILT_IN_SIN:
! case BUILT_IN_SINL:
! fcode = BUILT_IN_SINF;
! break;
! case BUILT_IN_COS:
! case BUILT_IN_COSL:
! fcode = BUILT_IN_COSF;
! break;
! case BUILT_IN_EXP:
! case BUILT_IN_EXPL:
! fcode = BUILT_IN_EXPF;
! break;
! default:
! abort ();
! }
! else
! switch (fcode)
! {
! case BUILT_IN_SQRT:
! case BUILT_IN_SQRTL:
! fcode = BUILT_IN_SQRT;
! break;
! case BUILT_IN_SIN:
! case BUILT_IN_SINL:
! fcode = BUILT_IN_SIN;
! break;
! case BUILT_IN_COS:
! case BUILT_IN_COSL:
! fcode = BUILT_IN_COS;
! break;
! case BUILT_IN_EXP:
! case BUILT_IN_EXPL:
! fcode = BUILT_IN_EXP;
! break;
! default:
! abort ();
! }
! /* ??? Fortran frontend does not initialize built_in_decls.
! For some reason creating the decl using builtin_function does not
! work as it should. */
! if (built_in_decls [fcode])
{
arglist = build_tree_list (NULL_TREE, fold (convert_to_real (newtype, arg0)));
! expr = build_function_call_expr (built_in_decls [fcode], arglist);
if (newtype == type)
return expr;
}
}
}
! #endif
/* Propagate the cast into the operation. */
if (itype != type && FLOAT_TYPE_P (type))
--- 153,204 ----
if (TYPE_PRECISION (TREE_TYPE (arg0)) > TYPE_PRECISION (type))
newtype = TREE_TYPE (arg0);
! /* Be curefull about integer to fp conversions.
These may overflow still. */
if (FLOAT_TYPE_P (TREE_TYPE (arg0))
! && TYPE_PRECISION (newtype) < TYPE_PRECISION (itype)
&& (TYPE_MODE (newtype) == TYPE_MODE (double_type_node)
|| TYPE_MODE (newtype) == TYPE_MODE (float_type_node)))
{
tree arglist;
! tree fn = mathfn_built_in (newtype, fcode);
! if (fn)
{
arglist = build_tree_list (NULL_TREE, fold (convert_to_real (newtype, arg0)));
! expr = build_function_call_expr (fn, arglist);
if (newtype == type)
return expr;
}
}
}
! if (optimize
! && (((fcode == BUILT_IN_FLOORL
! || fcode == BUILT_IN_CEILL
! || fcode == BUILT_IN_ROUND
! || fcode == BUILT_IN_TRUNC
! || fcode == BUILT_IN_NEARBYINT)
! && (TYPE_MODE (type) == TYPE_MODE (double_type_node)
! || TYPE_MODE (type) == TYPE_MODE (float_type_node)))
! || ((fcode == BUILT_IN_FLOOR
! || fcode == BUILT_IN_CEIL
! || fcode == BUILT_IN_ROUND
! || fcode == BUILT_IN_TRUNC
! || fcode == BUILT_IN_NEARBYINT)
! && (TYPE_MODE (type) == TYPE_MODE (float_type_node)))))
! {
! tree arg0 = strip_float_extensions (TREE_VALUE (TREE_OPERAND (expr, 1)));
! tree newtype = type;
! tree arglist;
! tree fn = mathfn_built_in (type, fcode);
! if (fn)
! {
! arglist = build_tree_list (NULL_TREE, fold (convert_to_real (newtype, arg0)));
! expr = build_function_call_expr (fn, arglist);
! if (newtype == type)
! return expr;
! }
! }
/* Propagate the cast into the operation. */
if (itype != type && FLOAT_TYPE_P (type))