From b52d5eaa44789d6c9593c12d7d1c1419fe59b0c1 Mon Sep 17 00:00:00 2001 From: Roger Sayle Date: Tue, 23 Nov 2004 01:27:42 +0000 Subject: fold-const.c (nondestructive_fold_binary_to_constant): Rename to fold_binary_to_constant. * 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 --- gcc/ChangeLog | 18 ++++++++++++++++++ gcc/fold-const.c | 15 ++++++--------- gcc/tree-ssa-ccp.c | 8 ++------ gcc/tree-ssa-loop-ivopts.c | 8 +++----- gcc/tree-ssa-loop-niter.c | 43 ++++++++++++++++++++++--------------------- gcc/tree.h | 4 ++-- 6 files changed, 53 insertions(+), 43 deletions(-) (limited to 'gcc') diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 8a0ec62..4604a92 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,5 +1,23 @@ 2004-11-22 Roger Sayle + * 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 + * config/i386/i386.h (TARGET_USE_FANCY_MATH_387): New macro. * config/i386/i386.c (override_options): Set MASK_NO_FANCY_MATH_387 automatically for targets without TARGET_80387. diff --git a/gcc/fold-const.c b/gcc/fold-const.c index 611ac14..0a7b7d2 100644 --- a/gcc/fold-const.c +++ b/gcc/fold-const.c @@ -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) diff --git a/gcc/tree-ssa-ccp.c b/gcc/tree-ssa-ccp.c index 1815ebd..31807fe 100644 --- a/gcc/tree-ssa-ccp.c +++ b/gcc/tree-ssa-ccp.c @@ -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. */ diff --git a/gcc/tree-ssa-loop-ivopts.c b/gcc/tree-ssa-loop-ivopts.c index 833cbf8..1de1e82 100644 --- a/gcc/tree-ssa-loop-ivopts.c +++ b/gcc/tree-ssa-loop-ivopts.c @@ -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; } diff --git a/gcc/tree-ssa-loop-niter.c b/gcc/tree-ssa-loop-niter.c index c831134..6a429b7 100644 --- a/gcc/tree-ssa-loop-niter.c +++ b/gcc/tree-ssa-loop-niter.c @@ -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, diff --git a/gcc/tree.h b/gcc/tree.h index 9785a53..c95c84d 100644 --- a/gcc/tree.h +++ b/gcc/tree.h @@ -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); -- cgit v1.1