procyberian/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

fold-const.c (nondestructive_fold_binary_to_constant): Rename to fold_binary_to_constant.

Browse source 
* fold-const.c (nondestructive_fold_binary_to_constant): Rename
	to fold_binary_to_constant.
	(nondestructive_fold_unary_to_constant): Likewise, rename to
	fold_unary_to_constant.
	(fold_relational_hi_lo): Update call to fold_binary_to_constant.
	* tree.h (nondestructive_fold_binary_to_constant): Update prototype.
	(nondestructive_fold_unary_to_constant): Likewise.
	* tree-ssa-ccp.c (ccp_fold): Update calls to fold_unary_to_constant
	and fold_binary_to_constant.
	* tree-ssa-loop-niter.c (EXEC_BINARY, EXEC_UNARY): Delete macros.
	(inverse, number_of_iterations_cond): Replace uses of EXEC_BINARY
	and EXEC_UNARY with calls to fold_*nary_to_constant.
	* tree-ssa-loop-ivopts.c (EXEC_BINARY, EXEC_UNARY): Delete macros.
	(idx_find_step): Replace uses of EXEC_BINARY with calls to
	fold_binary_to_constant.

From-SVN: r91063
This commit is contained in:
Roger Sayle 2004-11-23 01:27:42 +00:00 • committed by Roger Sayle
parent ba2baa55a3
commit b52d5eaa44
6 changed files with 53 additions and 43 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

18
gcc/ChangeLog
View file

@ -1,3 +1,21 @@
2004-11-22 Roger Sayle <roger@eyesopen.com>
* fold-const.c (nondestructive_fold_binary_to_constant): Rename
to fold_binary_to_constant.
(nondestructive_fold_unary_to_constant): Likewise, rename to
fold_unary_to_constant.
(fold_relational_hi_lo): Update call to fold_binary_to_constant.
* tree.h (nondestructive_fold_binary_to_constant): Update prototype.
(nondestructive_fold_unary_to_constant): Likewise.
* tree-ssa-ccp.c (ccp_fold): Update calls to fold_unary_to_constant
and fold_binary_to_constant.
* tree-ssa-loop-niter.c (EXEC_BINARY, EXEC_UNARY): Delete macros.
(inverse, number_of_iterations_cond): Replace uses of EXEC_BINARY
and EXEC_UNARY with calls to fold_*nary_to_constant.
* tree-ssa-loop-ivopts.c (EXEC_BINARY, EXEC_UNARY): Delete macros.
(idx_find_step): Replace uses of EXEC_BINARY with calls to
fold_binary_to_constant.
2004-11-22 Roger Sayle <roger@eyesopen.com>
* config/i386/i386.h (TARGET_USE_FANCY_MATH_387): New macro.

15
gcc/fold-const.c
View file

@ -10110,11 +10110,10 @@ fold_relational_hi_lo (enum tree_code *code_p, const tree type, tree *op0_p,
fold_convert (st0, op0),
fold_convert (st1, integer_zero_node));
retval
= nondestructive_fold_binary_to_constant (TREE_CODE (exp),
TREE_TYPE (exp),
TREE_OPERAND (exp, 0),
TREE_OPERAND (exp, 1));
retval = fold_binary_to_constant (TREE_CODE (exp),
TREE_TYPE (exp),
TREE_OPERAND (exp, 0),
TREE_OPERAND (exp, 1));
/* If we are in gimple form, then returning EXP would create
non-gimple expressions. Clearing it is safe and insures
@ -10145,8 +10144,7 @@ fold_relational_hi_lo (enum tree_code *code_p, const tree type, tree *op0_p,
simpler than the generic fold routine. */
tree
nondestructive_fold_binary_to_constant (enum tree_code code, tree type,
tree op0, tree op1)
fold_binary_to_constant (enum tree_code code, tree type, tree op0, tree op1)
{
int wins = 1;
tree subop0;
@ -10440,8 +10438,7 @@ nondestructive_fold_binary_to_constant (enum tree_code code, tree type,
the generic fold routine. */
tree
nondestructive_fold_unary_to_constant (enum tree_code code, tree type,
tree op0)
fold_unary_to_constant (enum tree_code code, tree type, tree op0)
{
/* Make sure we have a suitable constant argument. */
if (code == NOP_EXPR || code == FLOAT_EXPR || code == CONVERT_EXPR)

8
gcc/tree-ssa-ccp.c
View file

@ -847,9 +847,7 @@ ccp_fold (tree stmt)
op0 = get_value (op0)->const_val;
}
retval = nondestructive_fold_unary_to_constant (code,
TREE_TYPE (rhs),
op0);
retval = fold_unary_to_constant (code, TREE_TYPE (rhs), op0);
/* If we folded, but did not create an invariant, then we can not
use this expression. */
@ -900,9 +898,7 @@ ccp_fold (tree stmt)
op1 = val->const_val;
}
retval = nondestructive_fold_binary_to_constant (code,
TREE_TYPE (rhs),
op0, op1);
retval = fold_binary_to_constant (code, TREE_TYPE (rhs), op0, op1);
/* If we folded, but did not create an invariant, then we can not
use this expression. */

8
gcc/tree-ssa-loop-ivopts.c
View file

@ -96,9 +96,6 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
this. */
#define AVG_LOOP_NITER(LOOP) 5
/* Just to shorten the ugly names. */
#define EXEC_BINARY nondestructive_fold_binary_to_constant
#define EXEC_UNARY nondestructive_fold_unary_to_constant
/* Representation of the induction variable. */
struct iv
@ -1364,12 +1361,13 @@ idx_find_step (tree base, tree *idx, void *data)
return false;
}
step = EXEC_BINARY (MULT_EXPR, type, step, iv_step);
step = fold_binary_to_constant (MULT_EXPR, type, step, iv_step);
if (!*dta->step_p)
*dta->step_p = step;
else
*dta->step_p = EXEC_BINARY (PLUS_EXPR, type, *dta->step_p, step);
*dta->step_p = fold_binary_to_constant (PLUS_EXPR, type,
*dta->step_p, step);
return true;
}

43
gcc/tree-ssa-loop-niter.c
View file

@ -43,9 +43,6 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
#define SWAP(X, Y) do { void *tmp = (X); (X) = (Y); (Y) = tmp; } while (0)
/* Just to shorten the ugly names. */
#define EXEC_BINARY nondestructive_fold_binary_to_constant
#define EXEC_UNARY nondestructive_fold_unary_to_constant
/*
@ -156,10 +153,10 @@ inverse (tree x, tree mask)
rslt = build_int_cst_type (type, 1);
for (; ctr; ctr--)
{
rslt = EXEC_BINARY (MULT_EXPR, type, rslt, x);
x = EXEC_BINARY (MULT_EXPR, type, x, x);
rslt = fold_binary_to_constant (MULT_EXPR, type, rslt, x);
x = fold_binary_to_constant (MULT_EXPR, type, x, x);
}
rslt = EXEC_BINARY (BIT_AND_EXPR, type, rslt, mask);
rslt = fold_binary_to_constant (BIT_AND_EXPR, type, rslt, mask);
}
return rslt;
@ -217,7 +214,7 @@ number_of_iterations_cond (tree type, tree base0, tree step0,
if (code != NE_EXPR)
return;
step0 = EXEC_BINARY (MINUS_EXPR, type, step0, step1);
step0 = fold_binary_to_constant (MINUS_EXPR, type, step0, step1);
step1 = NULL_TREE;
}
@ -311,7 +308,7 @@ number_of_iterations_cond (tree type, tree base0, tree step0,
if (code != NE_EXPR)
{
if (zero_p (step0))
step = EXEC_UNARY (NEGATE_EXPR, type, step1);
step = fold_unary_to_constant (NEGATE_EXPR, type, step1);
else
step = step0;
delta = build2 (MINUS_EXPR, type, base1, base0);
@ -320,8 +317,8 @@ number_of_iterations_cond (tree type, tree base0, tree step0,
if (TREE_CODE (delta) == INTEGER_CST)
{
tmp = EXEC_BINARY (MINUS_EXPR, type, step,
build_int_cst_type (type, 1));
tmp = fold_binary_to_constant (MINUS_EXPR, type, step,
build_int_cst_type (type, 1));
if (was_sharp
&& operand_equal_p (delta, tmp, 0))
{
@ -342,8 +339,10 @@ number_of_iterations_cond (tree type, tree base0, tree step0,
may_xform = boolean_true_node;
else
{
bound = EXEC_BINARY (PLUS_EXPR, type, mmin, step);
bound = EXEC_BINARY (MINUS_EXPR, type, bound, delta);
bound = fold_binary_to_constant (PLUS_EXPR, type,
mmin, step);
bound = fold_binary_to_constant (MINUS_EXPR, type,
bound, delta);
may_xform = fold (build2 (LE_EXPR, boolean_type_node,
bound, base0));
}
@ -354,8 +353,10 @@ number_of_iterations_cond (tree type, tree base0, tree step0,
may_xform = boolean_true_node;
else
{
bound = EXEC_BINARY (MINUS_EXPR, type, mmax, step);
bound = EXEC_BINARY (PLUS_EXPR, type, bound, delta);
bound = fold_binary_to_constant (MINUS_EXPR, type,
mmax, step);
bound = fold_binary_to_constant (PLUS_EXPR, type,
bound, delta);
may_xform = fold (build2 (LE_EXPR, boolean_type_node,
base1, bound));
}
@ -401,11 +402,11 @@ number_of_iterations_cond (tree type, tree base0, tree step0,
base1 = fold (build2 (MINUS_EXPR, type, base1, base0));
base0 = NULL_TREE;
if (!zero_p (step1))
step0 = EXEC_UNARY (NEGATE_EXPR, type, step1);
step0 = fold_unary_to_constant (NEGATE_EXPR, type, step1);
step1 = NULL_TREE;
if (!tree_expr_nonnegative_p (fold_convert (signed_niter_type, step0)))
{
step0 = EXEC_UNARY (NEGATE_EXPR, type, step0);
step0 = fold_unary_to_constant (NEGATE_EXPR, type, step0);
base1 = fold (build1 (NEGATE_EXPR, type, base1));
}
@ -416,9 +417,9 @@ number_of_iterations_cond (tree type, tree base0, tree step0,
is infinite. Otherwise, the number of iterations is
(inverse(s/d) * (c/d)) mod (size of mode/d). */
bits = num_ending_zeros (step0);
d = EXEC_BINARY (LSHIFT_EXPR, niter_type,
build_int_cst_type (niter_type, 1), bits);
s = EXEC_BINARY (RSHIFT_EXPR, niter_type, step0, bits);
d = fold_binary_to_constant (LSHIFT_EXPR, niter_type,
build_int_cst_type (niter_type, 1), bits);
s = fold_binary_to_constant (RSHIFT_EXPR, niter_type, step0, bits);
bound = build_low_bits_mask (niter_type,
(TYPE_PRECISION (niter_type)
@ -447,7 +448,7 @@ number_of_iterations_cond (tree type, tree base0, tree step0,
{
if (mmax)
{
bound = EXEC_BINARY (MINUS_EXPR, type, mmax, step0);
bound = fold_binary_to_constant (MINUS_EXPR, type, mmax, step0);
assumption = fold (build2 (LE_EXPR, boolean_type_node,
base1, bound));
assumptions = fold (build2 (TRUTH_AND_EXPR, boolean_type_node,
@ -468,7 +469,7 @@ number_of_iterations_cond (tree type, tree base0, tree step0,
we can again compute number of iterations as (b - (a - s)) / s. */
if (mmin)
{
bound = EXEC_BINARY (MINUS_EXPR, type, mmin, step1);
bound = fold_binary_to_constant (MINUS_EXPR, type, mmin, step1);
assumption = fold (build2 (LE_EXPR, boolean_type_node,
bound, base0));
assumptions = fold (build2 (TRUTH_AND_EXPR, boolean_type_node,

4
gcc/tree.h
View file

@ -3525,8 +3525,8 @@ extern int operand_equal_p (tree, tree, unsigned int);
extern tree omit_one_operand (tree, tree, tree);
extern tree omit_two_operands (tree, tree, tree, tree);
extern tree invert_truthvalue (tree);
extern tree nondestructive_fold_unary_to_constant (enum tree_code, tree, tree);
extern tree nondestructive_fold_binary_to_constant (enum tree_code, tree, tree, tree);
extern tree fold_unary_to_constant (enum tree_code, tree, tree);
extern tree fold_binary_to_constant (enum tree_code, tree, tree, tree);
extern tree fold_read_from_constant_string (tree);
extern tree int_const_binop (enum tree_code, tree, tree, int);
extern tree build_fold_addr_expr (tree);