OpenE2K
/
gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

fold-const.c (negate_expr_p): MULT_EXPRs and RDIV_EXPRs are easy to negate if either operand is easy to negate... 

* fold-const.c (negate_expr_p): MULT_EXPRs and RDIV_EXPRs are easy
	to negate if either operand is easy to negate, if we don't care
	about sign-dependent rounding.
	(negate_expr): Make the logic to negate a REAL_CST explicit.
	Attempt to negate a MULT_EXPR or RDIV_EXPR by negating an operand
	that's easy to negate, if we don't honor sign-dependent rounding.
	(fold <MULT_EXPR>): Optimize -A * B as A * -B if B is easy to
	negate, and the symmetric A * -B as -A * B if A is easy to negate.
	(fold <RDIV_EXPR>): Likewise, optimize -A/B and C/-D as A/-B and
	-C/D if B and C are cheap to negate.  Add an explicit rule to
	optimize X/-1.0 as -X when we don't care about signaling NaNs.

From-SVN: r70455
This commit is contained in:
Roger Sayle 2003-08-14 20:53:26 +00:00 committed by Roger Sayle
parent 74bed51bf6
commit 8ab49fef1f
2 changed files with 76 additions and 5 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
gcc/ChangeLog
View File

@ -1,3 +1,17 @@
2003-08-14 Roger Sayle <roger@eyesopen.com>
* fold-const.c (negate_expr_p): MULT_EXPRs and RDIV_EXPRs are easy
to negate if either operand is easy to negate, if we don't care
about sign-dependent rounding.
(negate_expr): Make the logic to negate a REAL_CST explicit.
Attempt to negate a MULT_EXPR or RDIV_EXPR by negating an operand
that's easy to negate, if we don't honor sign-dependent rounding.
(fold <MULT_EXPR>): Optimize -A * B as A * -B if B is easy to
negate, and the symmetric A * -B as -A * B if A is easy to negate.
(fold <RDIV_EXPR>): Likewise, optimize -A/B and C/-D as A/-B and
-C/D if B and C are cheap to negate. Add an explicit rule to
optimize X/-1.0 as -X when we don't care about signaling NaNs.
2003-08-14 Zack Weinberg <zack@codesourcery.com>
* Makefile.in (tm_file): Rename tm_include_list.

67
gcc/fold-const.c
View File

@ -847,6 +847,18 @@ negate_expr_p (tree t)
/* We can't turn -(A-B) into B-A when we honor signed zeros. */
return ! FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations;
case MULT_EXPR:
if (TREE_UNSIGNED (TREE_TYPE (t)))
break;
/* Fall through. */
case RDIV_EXPR:
if (! HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (TREE_TYPE (t))))
return negate_expr_p (TREE_OPERAND (t, 1))
|| negate_expr_p (TREE_OPERAND (t, 0));
break;
default:
break;
}
@ -871,13 +883,19 @@ negate_expr (tree t)
switch (TREE_CODE (t))
{
case INTEGER_CST:
case REAL_CST:
if (! TREE_UNSIGNED (type)
&& 0 != (tem = fold (build1 (NEGATE_EXPR, type, t)))
&& ! TREE_OVERFLOW (tem))
return tem;
break;
case REAL_CST:
tem = build_real (type, REAL_VALUE_NEGATE (TREE_REAL_CST (t)));
/* Two's complement FP formats, such as c4x, may overflow. */
if (! TREE_OVERFLOW (tem))
return convert (type, tem);
break;
case NEGATE_EXPR:
return convert (type, TREE_OPERAND (t, 0));
@ -890,6 +908,30 @@ negate_expr (tree t)
TREE_OPERAND (t, 0))));
break;
case MULT_EXPR:
if (TREE_UNSIGNED (TREE_TYPE (t)))
break;
/* Fall through. */
case RDIV_EXPR:
if (! HONOR_SIGN_DEPENDENT_ROUNDING (TYPE_MODE (TREE_TYPE (t))))
{
tem = TREE_OPERAND (t, 1);
if (negate_expr_p (tem))
return convert (type,
fold (build (TREE_CODE (t), TREE_TYPE (t),
TREE_OPERAND (t, 0),
negate_expr (tem))));
tem = TREE_OPERAND (t, 0);
if (negate_expr_p (tem))
return convert (type,
fold (build (TREE_CODE (t), TREE_TYPE (t),
negate_expr (tem),
TREE_OPERAND (t, 1))));
}
break;
default:
break;
}
@ -5965,8 +6007,13 @@ fold (tree expr)
case MULT_EXPR:
/* (-A) * (-B) -> A * B */
if (TREE_CODE (arg0) == NEGATE_EXPR && TREE_CODE (arg1) == NEGATE_EXPR)
return fold (build (MULT_EXPR, type, TREE_OPERAND (arg0, 0),
if (TREE_CODE (arg0) == NEGATE_EXPR && negate_expr_p (arg1))
return fold (build (MULT_EXPR, type,
TREE_OPERAND (arg0, 0),
negate_expr (arg1)));
if (TREE_CODE (arg1) == NEGATE_EXPR && negate_expr_p (arg0))
return fold (build (MULT_EXPR, type,
negate_expr (arg0),
TREE_OPERAND (arg1, 0)));
if (! FLOAT_TYPE_P (type))
@ -6315,8 +6362,13 @@ fold (tree expr)
return t;
/* (-A) / (-B) -> A / B */
if (TREE_CODE (arg0) == NEGATE_EXPR && TREE_CODE (arg1) == NEGATE_EXPR)
return fold (build (RDIV_EXPR, type, TREE_OPERAND (arg0, 0),
if (TREE_CODE (arg0) == NEGATE_EXPR && negate_expr_p (arg1))
return fold (build (RDIV_EXPR, type,
TREE_OPERAND (arg0, 0),
negate_expr (arg1)));
if (TREE_CODE (arg1) == NEGATE_EXPR && negate_expr_p (arg0))
return fold (build (RDIV_EXPR, type,
negate_expr (arg0),
TREE_OPERAND (arg1, 0)));
/* In IEEE floating point, x/1 is not equivalent to x for snans. */
@ -6324,6 +6376,11 @@ fold (tree expr)
&& real_onep (arg1))
return non_lvalue (convert (type, arg0));
/* In IEEE floating point, x/-1 is not equivalent to -x for snans. */
if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
&& real_minus_onep (arg1))
return non_lvalue (convert (type, negate_expr (arg0)));
/* If ARG1 is a constant, we can convert this to a multiply by the
reciprocal. This does not have the same rounding properties,
so only do this if -funsafe-math-optimizations. We can actually