From: rakdver Date: Sat, 23 Dec 2006 23:05:52 +0000 (+0000) Subject: * tree-ssa-loop-niter.c (number_of_iterations_lt_to_ne, X-Git-Url: http://git.sourceforge.jp/view?p=pf3gnuchains%2Fgcc-fork.git;a=commitdiff_plain;h=7a973feb0b850958e0913736a0ddad9f576792dd;ds=sidebyside * tree-ssa-loop-niter.c (number_of_iterations_lt_to_ne, assert_no_overflow_lt, assert_loop_rolls_lt, number_of_iterations_lt, number_of_iterations_le, number_of_iterations_cond, number_of_iterations_exit): Use integer_zerop/integer_nonzerop instead of null_or_integer_zerop/nonnull_and_integer_nonzerop. * tree.h (null_or_integer_zerop, nonnull_and_integer_nonzerop): Removed. * tree-scalar-evolution.c (simple_iv): Return zero for step of an invariant. * tree-ssa-loop-ivopts.c (alloc_iv): Do not set step of invariants to zero. (get_iv): Return NULL for non-scalar types. Use zero as a step of an invariant. (determine_biv_step, find_interesting_uses_op, find_interesting_uses_cond, find_interesting_uses_stmt, add_old_ivs_candidates, determine_use_iv_cost_condition, rewrite_use_compare, remove_unused_ivs): Use integer_zerop instead of null_or_integer_zerop. (struct ifs_ivopts_data): Replace step_p field with step field. (idx_find_step): Use zero as a step of an invariant. Modify step instead of *step_p. (find_interesting_uses_address): Use zero as a step of an invariant. Use integer_zerop instead of null_or_integer_zerop. (find_interesting_uses_outside): Call find_interesting_uses_op only for phi nodes for real operands. (add_candidate_1): Expect step to be non-NULL. * tree-ssa-loop-prefetch.c (idx_analyze_ref): Expect step to be non-NULL. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@120179 138bc75d-0d04-0410-961f-82ee72b054a4 --- diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 921163cc13a..e026399476d 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,35 @@ +2006-12-23 Zdenek Dvorak + + * tree-ssa-loop-niter.c (number_of_iterations_lt_to_ne, + assert_no_overflow_lt, assert_loop_rolls_lt, + number_of_iterations_lt, number_of_iterations_le, + number_of_iterations_cond, number_of_iterations_exit): + Use integer_zerop/integer_nonzerop instead of + null_or_integer_zerop/nonnull_and_integer_nonzerop. + * tree.h (null_or_integer_zerop, nonnull_and_integer_nonzerop): + Removed. + * tree-scalar-evolution.c (simple_iv): Return zero for step of + an invariant. + * tree-ssa-loop-ivopts.c (alloc_iv): Do not set step of invariants + to zero. + (get_iv): Return NULL for non-scalar types. Use zero as a step + of an invariant. + (determine_biv_step, find_interesting_uses_op, + find_interesting_uses_cond, find_interesting_uses_stmt, + add_old_ivs_candidates, determine_use_iv_cost_condition, + rewrite_use_compare, remove_unused_ivs): + Use integer_zerop instead of null_or_integer_zerop. + (struct ifs_ivopts_data): Replace step_p field with step field. + (idx_find_step): Use zero as a step of an invariant. Modify + step instead of *step_p. + (find_interesting_uses_address): Use zero as a step of an invariant. + Use integer_zerop instead of null_or_integer_zerop. + (find_interesting_uses_outside): Call find_interesting_uses_op only + for phi nodes for real operands. + (add_candidate_1): Expect step to be non-NULL. + * tree-ssa-loop-prefetch.c (idx_analyze_ref): Expect step to be + non-NULL. + 2006-12-23 Andrew Pinski * vec.c: Don't include tree.h. diff --git a/gcc/tree-scalar-evolution.c b/gcc/tree-scalar-evolution.c index 9ce6f6bd2e8..194690185cc 100644 --- a/gcc/tree-scalar-evolution.c +++ b/gcc/tree-scalar-evolution.c @@ -2813,6 +2813,7 @@ simple_iv (struct loop *loop, tree stmt, tree op, affine_iv *iv, && !chrec_contains_symbols_defined_in_loop (ev, loop->num)) { iv->base = ev; + iv->step = build_int_cst (TREE_TYPE (ev), 0); iv->no_overflow = true; return true; } diff --git a/gcc/tree-ssa-loop-ivopts.c b/gcc/tree-ssa-loop-ivopts.c index 5e70937a6f7..411cad22544 100644 --- a/gcc/tree-ssa-loop-ivopts.c +++ b/gcc/tree-ssa-loop-ivopts.c @@ -840,9 +840,7 @@ static struct iv * alloc_iv (tree base, tree step) { struct iv *iv = XCNEW (struct iv); - - if (step && integer_zerop (step)) - step = NULL_TREE; + gcc_assert (step != NULL_TREE); iv->base = base; iv->base_object = determine_base_object (base); @@ -875,14 +873,19 @@ static struct iv * get_iv (struct ivopts_data *data, tree var) { basic_block bb; - + tree type = TREE_TYPE (var); + + if (!POINTER_TYPE_P (type) + && !INTEGRAL_TYPE_P (type)) + return NULL; + if (!name_info (data, var)->iv) { bb = bb_for_stmt (SSA_NAME_DEF_STMT (var)); if (!bb || !flow_bb_inside_loop_p (data->current_loop, bb)) - set_iv (data, var, var, NULL_TREE); + set_iv (data, var, var, build_int_cst (type, 0)); } return name_info (data, var)->iv; @@ -904,7 +907,7 @@ determine_biv_step (tree phi) if (!simple_iv (loop, phi, name, &iv, true)) return NULL_TREE; - return (null_or_integer_zerop (iv.step) ? NULL_TREE : iv.step); + return integer_zerop (iv.step) ? NULL_TREE : iv.step; } /* Finds basic ivs. */ @@ -1160,7 +1163,7 @@ find_interesting_uses_op (struct ivopts_data *data, tree op) return use; } - if (null_or_integer_zerop (iv->step)) + if (integer_zerop (iv->step)) { record_invariant (data, op, true); return NULL; @@ -1192,7 +1195,7 @@ find_interesting_uses_cond (struct ivopts_data *data, tree stmt, tree *cond_p) struct iv const_iv; tree zero = integer_zero_node; - const_iv.step = NULL_TREE; + const_iv.step = integer_zero_node; if (TREE_CODE (*cond_p) != SSA_NAME && !COMPARISON_CLASS_P (*cond_p)) @@ -1224,23 +1227,23 @@ find_interesting_uses_cond (struct ivopts_data *data, tree stmt, tree *cond_p) (!iv0 || !iv1) /* Eliminating condition based on two ivs would be nontrivial. ??? TODO -- it is not really important to handle this case. */ - || (!null_or_integer_zerop (iv0->step) - && !null_or_integer_zerop (iv1->step))) + || (!integer_zerop (iv0->step) + && !integer_zerop (iv1->step))) { find_interesting_uses_op (data, *op0_p); find_interesting_uses_op (data, *op1_p); return; } - if (null_or_integer_zerop (iv0->step) - && null_or_integer_zerop (iv1->step)) + if (integer_zerop (iv0->step) + && integer_zerop (iv1->step)) { /* If both are invariants, this is a work for unswitching. */ return; } civ = XNEW (struct iv); - *civ = null_or_integer_zerop (iv0->step) ? *iv1: *iv0; + *civ = integer_zerop (iv0->step) ? *iv1: *iv0; record_use (data, cond_p, civ, stmt, USE_COMPARE); } @@ -1285,7 +1288,7 @@ struct ifs_ivopts_data { struct ivopts_data *ivopts_data; tree stmt; - tree *step_p; + tree step; }; static bool @@ -1334,7 +1337,7 @@ idx_find_step (tree base, tree *idx, void *data) ARRAY_REF path below. */ *idx = iv->base; - if (!iv->step) + if (integer_zerop (iv->step)) return true; if (TREE_CODE (base) == ARRAY_REF) @@ -1360,11 +1363,7 @@ idx_find_step (tree base, tree *idx, void *data) } step = fold_build2 (MULT_EXPR, sizetype, step, iv_step); - - if (!*dta->step_p) - *dta->step_p = step; - else - *dta->step_p = fold_build2 (PLUS_EXPR, sizetype, *dta->step_p, step); + dta->step = fold_build2 (PLUS_EXPR, sizetype, dta->step, step); return true; } @@ -1456,7 +1455,7 @@ may_be_nonaddressable_p (tree expr) static void find_interesting_uses_address (struct ivopts_data *data, tree stmt, tree *op_p) { - tree base = *op_p, step = NULL; + tree base = *op_p, step = build_int_cst (sizetype, 0); struct iv *civ; struct ifs_ivopts_data ifs_ivopts_data; @@ -1509,14 +1508,11 @@ find_interesting_uses_address (struct ivopts_data *data, tree stmt, tree *op_p) if (TMR_STEP (base)) astep = fold_build2 (MULT_EXPR, type, TMR_STEP (base), astep); - if (step) - step = fold_build2 (PLUS_EXPR, type, step, astep); - else - step = astep; + step = fold_build2 (PLUS_EXPR, type, step, astep); } } - if (null_or_integer_zerop (step)) + if (integer_zerop (step)) goto fail; base = tree_mem_ref_addr (type, base); } @@ -1524,10 +1520,11 @@ find_interesting_uses_address (struct ivopts_data *data, tree stmt, tree *op_p) { ifs_ivopts_data.ivopts_data = data; ifs_ivopts_data.stmt = stmt; - ifs_ivopts_data.step_p = &step; + ifs_ivopts_data.step = build_int_cst (sizetype, 0); if (!for_each_index (&base, idx_find_step, &ifs_ivopts_data) - || null_or_integer_zerop (step)) + || integer_zerop (ifs_ivopts_data.step)) goto fail; + step = ifs_ivopts_data.step; gcc_assert (TREE_CODE (base) != ALIGN_INDIRECT_REF); gcc_assert (TREE_CODE (base) != MISALIGNED_INDIRECT_REF); @@ -1600,7 +1597,7 @@ find_interesting_uses_stmt (struct ivopts_data *data, tree stmt) iv = get_iv (data, lhs); - if (iv && !null_or_integer_zerop (iv->step)) + if (iv && !integer_zerop (iv->step)) return; } @@ -1646,7 +1643,7 @@ find_interesting_uses_stmt (struct ivopts_data *data, tree stmt) lhs = PHI_RESULT (stmt); iv = get_iv (data, lhs); - if (iv && !null_or_integer_zerop (iv->step)) + if (iv && !integer_zerop (iv->step)) return; } @@ -1676,7 +1673,8 @@ find_interesting_uses_outside (struct ivopts_data *data, edge exit) for (phi = phi_nodes (exit->dest); phi; phi = PHI_CHAIN (phi)) { def = PHI_ARG_DEF_FROM_EDGE (phi, exit); - find_interesting_uses_op (data, def); + if (is_gimple_reg (def)) + find_interesting_uses_op (data, def); } } @@ -1944,8 +1942,7 @@ add_candidate_1 (struct ivopts_data *data, if (type != orig_type) { base = fold_convert (type, base); - if (step) - step = fold_convert (type, step); + step = fold_convert (type, step); } } @@ -1970,19 +1967,9 @@ add_candidate_1 (struct ivopts_data *data, if (!base && !step) continue; - if (!operand_equal_p (base, cand->iv->base, 0)) - continue; - - if (null_or_integer_zerop (cand->iv->step)) - { - if (null_or_integer_zerop (step)) - break; - } - else - { - if (step && operand_equal_p (step, cand->iv->step, 0)) - break; - } + if (operand_equal_p (base, cand->iv->base, 0) + && operand_equal_p (step, cand->iv->step, 0)) + break; } if (i == n_iv_cands (data)) @@ -2136,7 +2123,7 @@ add_old_ivs_candidates (struct ivopts_data *data) EXECUTE_IF_SET_IN_BITMAP (data->relevant, 0, i, bi) { iv = ver_info (data, i)->iv; - if (iv && iv->biv_p && !null_or_integer_zerop (iv->step)) + if (iv && iv->biv_p && !integer_zerop (iv->step)) add_old_iv_candidates (data, iv); } } @@ -3733,7 +3720,7 @@ determine_use_iv_cost_condition (struct ivopts_data *data, { op = TREE_OPERAND (cond, 0); if (TREE_CODE (op) == SSA_NAME - && !null_or_integer_zerop (get_iv (data, op)->step)) + && !integer_zerop (get_iv (data, op)->step)) op = TREE_OPERAND (cond, 1); if (TREE_CODE (op) == SSA_NAME) { @@ -5151,7 +5138,7 @@ rewrite_use_compare (struct ivopts_data *data, cond = *use->op_p; op_p = &TREE_OPERAND (cond, 0); if (TREE_CODE (*op_p) != SSA_NAME - || null_or_integer_zerop (get_iv (data, *op_p)->step)) + || integer_zerop (get_iv (data, *op_p)->step)) op_p = &TREE_OPERAND (cond, 1); op = force_gimple_operand (comp, &stmts, true, SSA_NAME_VAR (*op_p)); @@ -5222,7 +5209,7 @@ remove_unused_ivs (struct ivopts_data *data) info = ver_info (data, j); if (info->iv - && !null_or_integer_zerop (info->iv->step) + && !integer_zerop (info->iv->step) && !info->inv_id && !info->iv->have_use_for && !info->preserve_biv) diff --git a/gcc/tree-ssa-loop-niter.c b/gcc/tree-ssa-loop-niter.c index 2187c2f332d..affb47d3b1c 100644 --- a/gcc/tree-ssa-loop-niter.c +++ b/gcc/tree-ssa-loop-niter.c @@ -193,7 +193,7 @@ number_of_iterations_lt_to_ne (tree type, affine_iv *iv0, affine_iv *iv1, mod = fold_build2 (MINUS_EXPR, niter_type, step, mod); tmod = fold_convert (type, mod); - if (nonnull_and_integer_nonzerop (iv0->step)) + if (integer_nonzerop (iv0->step)) { /* The final value of the iv is iv1->base + MOD, assuming that this computation does not overflow, and that @@ -256,7 +256,7 @@ assert_no_overflow_lt (tree type, affine_iv *iv0, affine_iv *iv1, tree bound, d, assumption, diff; tree niter_type = TREE_TYPE (step); - if (nonnull_and_integer_nonzerop (iv0->step)) + if (integer_nonzerop (iv0->step)) { /* for (i = iv0->base; i < iv1->base; i += iv0->step) */ if (iv0->no_overflow) @@ -324,7 +324,7 @@ assert_loop_rolls_lt (tree type, affine_iv *iv0, affine_iv *iv1, tree assumption = boolean_true_node, bound, diff; tree mbz, mbzl, mbzr; - if (nonnull_and_integer_nonzerop (iv0->step)) + if (integer_nonzerop (iv0->step)) { diff = fold_build2 (MINUS_EXPR, type, iv0->step, build_int_cst (type, 1)); @@ -384,7 +384,7 @@ number_of_iterations_lt (tree type, affine_iv *iv0, affine_iv *iv1, tree niter_type = unsigned_type_for (type); tree delta, step, s; - if (nonnull_and_integer_nonzerop (iv0->step)) + if (integer_nonzerop (iv0->step)) { niter->control = *iv0; niter->cmp = LT_EXPR; @@ -402,10 +402,8 @@ number_of_iterations_lt (tree type, affine_iv *iv0, affine_iv *iv1, fold_convert (niter_type, iv0->base)); /* First handle the special case that the step is +-1. */ - if ((iv0->step && integer_onep (iv0->step) - && null_or_integer_zerop (iv1->step)) - || (iv1->step && integer_all_onesp (iv1->step) - && null_or_integer_zerop (iv0->step))) + if ((integer_onep (iv0->step) && integer_zerop (iv1->step)) + || (integer_all_onesp (iv1->step) && integer_zerop (iv0->step))) { /* for (i = iv0->base; i < iv1->base; i++) @@ -421,7 +419,7 @@ number_of_iterations_lt (tree type, affine_iv *iv0, affine_iv *iv1, return true; } - if (nonnull_and_integer_nonzerop (iv0->step)) + if (integer_nonzerop (iv0->step)) step = fold_convert (niter_type, iv0->step); else step = fold_convert (niter_type, @@ -479,7 +477,7 @@ number_of_iterations_le (tree type, affine_iv *iv0, affine_iv *iv1, if (!never_infinite) { - if (nonnull_and_integer_nonzerop (iv0->step)) + if (integer_nonzerop (iv0->step)) assumption = fold_build2 (NE_EXPR, boolean_type_node, iv1->base, TYPE_MAX_VALUE (type)); else @@ -493,7 +491,7 @@ number_of_iterations_le (tree type, affine_iv *iv0, affine_iv *iv1, niter->assumptions, assumption); } - if (nonnull_and_integer_nonzerop (iv0->step)) + if (integer_nonzerop (iv0->step)) iv1->base = fold_build2 (PLUS_EXPR, type, iv1->base, build_int_cst (type, 1)); else @@ -542,7 +540,7 @@ number_of_iterations_cond (tree type, affine_iv *iv0, enum tree_code code, /* Make < comparison from > ones, and for NE_EXPR comparisons, ensure that the control variable is on lhs. */ if (code == GE_EXPR || code == GT_EXPR - || (code == NE_EXPR && null_or_integer_zerop (iv0->step))) + || (code == NE_EXPR && integer_zerop (iv0->step))) { SWAP (iv0, iv1); code = swap_tree_comparison (code); @@ -578,9 +576,9 @@ number_of_iterations_cond (tree type, affine_iv *iv0, enum tree_code code, /* If the control induction variable does not overflow, the loop obviously cannot be infinite. */ - if (!null_or_integer_zerop (iv0->step) && iv0->no_overflow) + if (!integer_zerop (iv0->step) && iv0->no_overflow) never_infinite = true; - else if (!null_or_integer_zerop (iv1->step) && iv1->no_overflow) + else if (!integer_zerop (iv1->step) && iv1->no_overflow) never_infinite = true; else never_infinite = false; @@ -588,7 +586,7 @@ number_of_iterations_cond (tree type, affine_iv *iv0, enum tree_code code, /* We can handle the case when neither of the sides of the comparison is invariant, provided that the test is NE_EXPR. This rarely occurs in practice, but it is simple enough to manage. */ - if (!null_or_integer_zerop (iv0->step) && !null_or_integer_zerop (iv1->step)) + if (!integer_zerop (iv0->step) && !integer_zerop (iv1->step)) { if (code != NE_EXPR) return false; @@ -596,14 +594,14 @@ number_of_iterations_cond (tree type, affine_iv *iv0, enum tree_code code, iv0->step = fold_binary_to_constant (MINUS_EXPR, type, iv0->step, iv1->step); iv0->no_overflow = false; - iv1->step = NULL_TREE; + iv1->step = build_int_cst (type, 0); iv1->no_overflow = true; } /* If the result of the comparison is a constant, the loop is weird. More precise handling would be possible, but the situation is not common enough to waste time on it. */ - if (null_or_integer_zerop (iv0->step) && null_or_integer_zerop (iv1->step)) + if (integer_zerop (iv0->step) && integer_zerop (iv1->step)) return false; /* Ignore loops of while (i-- < 10) type. */ @@ -612,7 +610,7 @@ number_of_iterations_cond (tree type, affine_iv *iv0, enum tree_code code, if (iv0->step && tree_int_cst_sign_bit (iv0->step)) return false; - if (!null_or_integer_zerop (iv1->step) && !tree_int_cst_sign_bit (iv1->step)) + if (!integer_zerop (iv1->step) && !tree_int_cst_sign_bit (iv1->step)) return false; } @@ -628,7 +626,7 @@ number_of_iterations_cond (tree type, affine_iv *iv0, enum tree_code code, switch (code) { case NE_EXPR: - gcc_assert (null_or_integer_zerop (iv1->step)); + gcc_assert (integer_zerop (iv1->step)); return number_of_iterations_ne (type, iv0, iv1->base, niter, never_infinite); case LT_EXPR: return number_of_iterations_lt (type, iv0, iv1, niter, never_infinite); @@ -1099,11 +1097,10 @@ number_of_iterations_exit (struct loop *loop, edge exit, /* We can provide a more specific warning if one of the operator is constant and the other advances by +1 or -1. */ - if (!null_or_integer_zerop (iv1.step) - ? (null_or_integer_zerop (iv0.step) + if (!integer_zerop (iv1.step) + ? (integer_zerop (iv0.step) && (integer_onep (iv1.step) || integer_all_onesp (iv1.step))) - : (iv0.step - && (integer_onep (iv0.step) || integer_all_onesp (iv0.step)))) + : (integer_onep (iv0.step) || integer_all_onesp (iv0.step))) wording = flag_unsafe_loop_optimizations ? N_("assuming that the loop is not infinite") diff --git a/gcc/tree-ssa-loop-prefetch.c b/gcc/tree-ssa-loop-prefetch.c index c8e69226844..198c2342ac1 100644 --- a/gcc/tree-ssa-loop-prefetch.c +++ b/gcc/tree-ssa-loop-prefetch.c @@ -337,14 +337,9 @@ idx_analyze_ref (tree base, tree *index, void *data) ibase = iv.base; step = iv.step; - if (null_or_integer_zerop (step)) - istep = 0; - else - { - if (!cst_and_fits_in_hwi (step)) - return false; - istep = int_cst_value (step); - } + if (!cst_and_fits_in_hwi (step)) + return false; + istep = int_cst_value (step); if (TREE_CODE (ibase) == PLUS_EXPR && cst_and_fits_in_hwi (TREE_OPERAND (ibase, 1))) diff --git a/gcc/tree.h b/gcc/tree.h index 87bce8b0d72..b7ec8035b3c 100644 --- a/gcc/tree.h +++ b/gcc/tree.h @@ -4075,22 +4075,6 @@ extern int integer_pow2p (tree); extern int integer_nonzerop (tree); -/* Returns true if X is either NULL or zero. */ - -static inline bool -null_or_integer_zerop (tree x) -{ - return x == NULL_TREE || integer_zerop (x); -} - -/* Returns true if X is non-NULL and non-zero. */ - -static inline bool -nonnull_and_integer_nonzerop (tree x) -{ - return x != NULL_TREE && integer_nonzerop (x); -} - extern bool cst_and_fits_in_hwi (tree); extern tree num_ending_zeros (tree);