2004-07-09 05:19:14 +02:00
|
|
|
/* Functions to determine/estimate number of iterations of a loop.
|
2005-02-10 19:59:07 +01:00
|
|
|
Copyright (C) 2004, 2005 Free Software Foundation, Inc.
|
2004-07-09 05:19:14 +02:00
|
|
|
|
|
|
|
This file is part of GCC.
|
|
|
|
|
|
|
|
GCC is free software; you can redistribute it and/or modify it
|
|
|
|
under the terms of the GNU General Public License as published by the
|
|
|
|
Free Software Foundation; either version 2, or (at your option) any
|
|
|
|
later version.
|
|
|
|
|
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT
|
|
|
|
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
|
for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with GCC; see the file COPYING. If not, write to the Free
|
|
|
|
Software Foundation, 59 Temple Place - Suite 330, Boston, MA
|
|
|
|
02111-1307, USA. */
|
|
|
|
|
|
|
|
#include "config.h"
|
|
|
|
#include "system.h"
|
|
|
|
#include "coretypes.h"
|
|
|
|
#include "tm.h"
|
|
|
|
#include "tree.h"
|
|
|
|
#include "rtl.h"
|
|
|
|
#include "tm_p.h"
|
|
|
|
#include "hard-reg-set.h"
|
|
|
|
#include "basic-block.h"
|
|
|
|
#include "output.h"
|
|
|
|
#include "diagnostic.h"
|
|
|
|
#include "tree-flow.h"
|
|
|
|
#include "tree-dump.h"
|
|
|
|
#include "cfgloop.h"
|
|
|
|
#include "tree-pass.h"
|
|
|
|
#include "ggc.h"
|
|
|
|
#include "tree-chrec.h"
|
|
|
|
#include "tree-scalar-evolution.h"
|
Makefile.in (tree-ssa-loop-niter.o): Depends on tree-data-ref.h.
2004-10-11 Sebastian Pop <pop@cri.ensmp.fr>
* Makefile.in (tree-ssa-loop-niter.o): Depends on tree-data-ref.h.
* cfgloop.c (initialize_loops_parallel_p): New.
(flow_loops_find): Initialize the parallel_p field to true for all
the loops.
* tree-ssa-loop-niter.c: Include "tree-data-ref.h".
(estimate_numbers_of_iterations_loop): Infers the loop bounds from
the size of the data accessed in the loop.
(struct nb_iter_bound): Moved...
* cfgloop.h (struct nb_iter_bound): ... here.
(estimated_nb_iterations, parallel_p): New fields in struct loop.
(record_estimate): Declare extern here.
* tree-chrec.c: Fix comments.
(nb_vars_in_chrec): New function.
* tree-chrec.h (nb_vars_in_chrec): Declared here.
* tree-data-ref.c: Don't include lambda.h, that is already included
in tree-data-ref.h.
(tree_fold_divides_p): Don't check for integer_onep.
(tree_fold_bezout): Removed.
(gcd): New static duplicated function.
(int_divides_p, dump_subscript): New.
(dump_data_dependence_relation): Use dump_subscript.
(dump_dist_dir_vectors, dump_ddrs, compute_estimated_nb_iterations,
estimate_niter_from_size_of_data): New.
(analyze_array_indexes, analyze_array): Call
estimate_niter_from_size_of_data during the detection of array
references. Pass in a pointer to the statement that contains the
array reference.
(all_chrecs_equal_p): New.
(compute_distance_vector): Renamed compute_subscript_distance.
Deal with multivariate conflict functions.
(initialize_data_dependence_relation): Initialize DDR_AFFINE_P,
DDR_SIZE_VECT, DDR_DIST_VECT, and DDR_DIR_VECT.
(non_affine_dependence_relation): New.
(analyze_ziv_subscript, analyze_siv_subscript_cst_affine,
analyze_siv_subscript, analyze_miv_subscript,
analyze_overlapping_iterations, subscript_dependence_tester):
Initialize and return last_conflicts function.
(initialize_matrix_A, FLOOR, compute_overlap_steps_for_affine_univar,
compute_overlap_steps_for_affine_1_2): New.
(analyze_siv_subscript_affine_cst): Removed.
(analyze_subscript_affine_affine): Disprove dependences based on the
iteration domains. Solve the univariate dependence case as before,
but use lambda_matrix_right_hermite instead of tree_fold_bezout.
Implement the multivariate case of 2 versus 1 variables.
(build_classic_dist_vector, build_classic_dir_vector): Implement some
unhandled cases.
(find_data_references_in_loop): Compute and initialize
loop->estimated_nb_iterations and loop->parallel_p.
(analyze_all_data_dependences): Modify the debug dump order.
* tree-data-ref.h (SUB_LAST_CONFLICT_IN_A, SUB_LAST_CONFLICT_IN_B,
subscript->last_conflict_in_a, subscript->last_conflict_in_b): Removed.
(SUB_LAST_CONFLICT, subscript->last_conflict,
data_dependence_relation->affine_p, data_dependence_relation->size_vect,
DDR_AFFINE_P, DDR_SIZE_VECT): New.
(find_data_references_in_loop, initialize_data_dependence_relation,
dump_subscript, dump_ddrs, dump_dist_dir_vectors): Declared here.
From-SVN: r88965
2004-10-13 05:48:03 +02:00
|
|
|
#include "tree-data-ref.h"
|
2004-07-09 05:19:14 +02:00
|
|
|
#include "params.h"
|
|
|
|
#include "flags.h"
|
|
|
|
#include "tree-inline.h"
|
|
|
|
|
|
|
|
#define SWAP(X, Y) do { void *tmp = (X); (X) = (Y); (Y) = tmp; } while (0)
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
|
|
|
Analysis of number of iterations of an affine exit test.
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
tree-chrec.c (chrec_fold_plus_poly_poly, [...]): Use fold_convert or build_int_cst_type instead od fonvert.
* tree-chrec.c (chrec_fold_plus_poly_poly, chrec_fold_plus_1,
chrec_fold_multiply): Use fold_convert or build_int_cst_type instead
od fonvert.
* tree-scalar-evolution.c (compute_overall_effect_of_inner_loop,
add_to_evolution, set_nb_iterations_in_loop, follow_ssa_edge_in_rhs,
follow_ssa_edge_in_rhs): Ditto.
* tree-ssa-loop-ivopts.c (struct iv): Add base_object field.
(dump_iv): Dump base_object.
(dump_use, dump_cand): Use dump_iv.
(determine_base_object): New function.
(alloc_iv): Initialize base_object field.
(record_use): Clear the ssa_name field of iv.
(get_computation_cost_at): Do not use difference of addresses of
two different objects.
(may_eliminate_iv): Do not require the loop to have just single exit.
* tree-ssa-loop-niter.c (zero_p): Do not check for overflows.
(nonzero_p): New function.
(inverse, number_of_iterations_cond, simplify_using_outer_evolutions,
tree_simplify_using_condition, simplify_using_initial_conditions,
loop_niter_by_eval, find_loop_niter_by_eval,
estimate_numbers_of_iterations_loop, compare_trees,
upper_bound_in_type, lower_bound_in_type,
can_count_iv_in_wider_type_bound): Use buildN instead of build. Use
fold_convert or build_int_cst_type instead of convert. Use (non)zero_p
instead of integer_(non)zerop.
From-SVN: r88388
2004-10-01 11:06:06 +02:00
|
|
|
/* Returns true if ARG is either NULL_TREE or constant zero. Unlike
|
alias.c, [...]: Fix comment formatting.
* alias.c, basic-block.h, cgraphunit.c, combine.c, domwalk.h,
final.c, gengtype.c, genpreds.c, ggc-page.c, insn-notes.def,
lambda-code.c, loop-unroll.c, modulo-sched.c, pointer-set.c,
pretty-print.c, ra-colorize.c, sbitmap.c, tree-complex.c,
tree-data-ref.c, tree-dfa.c, tree-inline.c, tree-into-ssa.c,
tree-scalar-evolution.c, tree-ssa-dom.c,
tree-ssa-loop-manip.c, tree-ssa-loop-niter.c,
tree-ssa-phiopt.c, tree-ssa-pre.c, tree-ssa-threadupdate.c,
tree-vectorizer.c, vec.h: Fix comment formatting.
From-SVN: r89453
2004-10-22 19:05:11 +02:00
|
|
|
integer_zerop, it does not care about overflow flags. */
|
2004-07-09 05:19:14 +02:00
|
|
|
|
tree-ssa-loop-ivopts.c: New file.
* tree-ssa-loop-ivopts.c: New file.
* Makefile.in (tree-ssa-loop-ivopts.c): Add.
* cfgloop.h (target_avail_regs, target_res_regs, target_small_cost,
target_pres_cost, target_spill_cost): Declare.
* cfgloopanal.c (avail_regs, res_regs, small_cost, pres_cost,
spill_cost): Renamed to ...
(target_avail_regs, target_res_regs, target_small_cost,
target_pres_cost, target_spill_cost): ... and exported.
(init_set_costs, global_cost_for_size): Work with renamed variables.
* common.opt (flag_ivopts): New flag.
* expr.c (expand_expr_real_1): Handle SSA_NAME case. Handle
REF_ORIGINAL.
* gimplify.c (struct gimplify_ctx): Add into_ssa field.
(internal_get_tmp_var, gimplify_modify_expr, gimplify_expr): Support
generating SSA form.
(force_gimple_operand): New function.
* timevar.def (TV_TREE_LOOP_IVOPTS): New timevar.
* tree-cfg.c (stmt_bsi): New function.
* params.def (PARAM_IV_CONSIDER_ALL_CANDIDATES_BOUND,
PARAM_IV_MAX_CONSIDERED_USES): New.
* tree-flow.h (stmt_bsi, tree_ssa_iv_optimize, split_loop_exit_edge,
bsi_insert_on_edge_immediate_loop. standard_iv_increment_position,
ip_end_pos, ip_normal_pos, force_gimple_operand): Declare.
* tree-gimple.c (is_gimple_formal_tmp_var): Accept ssa names.
* tree-nested.c (build_addr): Export.
* tree-optimize.c (init_tree_optimization_passes): Add
pass_iv_optimize.
* tree-pass.h (pass_iv_optimize): Declare.
* tree-ssa-loop-im.c (for_each_index): Handle REALPART_EXPR and
IMAGPART_EXPR.
* tree-ssa-loop-manip.c (create_iv): Force the base to be acceptable
as a phi node argument.
(split_loop_exit_edge, bsi_insert_on_edge_immediate_loop,
ip_end_pos, ip_normal_pos, standard_iv_increment_position): New
functions.
* tree-ssa-loop-niter.c (zero_p, unsigned_type_for): Export.
* tree-ssa-loop.c (tree_ssa_loop_ivopts, gate_tree_ssa_loop_ivopts,
pass_iv_optimize): New pass.
* tree-ssa-operands.c (get_indirect_ref_operands): Handle REF_ORIGINAL.
* tree-ssanames.c (release_ssa_name): Allow calling with var = NULL.
* tree.c (build_int_cst_type, cst_and_fits_in_hwi): New functions.
* tree.h (REF_ORIGINAL): New macro.
(build_int_cst_type, unsigned_type_for, zero_p,
cst_and_fits_in_hwi, build_addr): Declare.
* doc/invoke.texi (-fivopts): Document.
(PARAM_IV_CONSIDER_ALL_CANDIDATES_BOUND,
PARAM_IV_MAX_CONSIDERED_USES): Document.
* doc/passes.texi: Document induction variable optimizations pass.
* gcc.dg/tree-ssa/loop-2.c: New test.
* gcc.dg/tree-ssa/loop-3.c: New test.
* gcc.dg/tree-ssa/loop-4.c: New test.
* gcc.dg/tree-ssa/loop-5.c: New test.
From-SVN: r87100
2004-09-05 11:25:37 +02:00
|
|
|
bool
|
2004-07-09 05:19:14 +02:00
|
|
|
zero_p (tree arg)
|
|
|
|
{
|
|
|
|
if (!arg)
|
|
|
|
return true;
|
|
|
|
|
tree-chrec.c (chrec_fold_plus_poly_poly, [...]): Use fold_convert or build_int_cst_type instead od fonvert.
* tree-chrec.c (chrec_fold_plus_poly_poly, chrec_fold_plus_1,
chrec_fold_multiply): Use fold_convert or build_int_cst_type instead
od fonvert.
* tree-scalar-evolution.c (compute_overall_effect_of_inner_loop,
add_to_evolution, set_nb_iterations_in_loop, follow_ssa_edge_in_rhs,
follow_ssa_edge_in_rhs): Ditto.
* tree-ssa-loop-ivopts.c (struct iv): Add base_object field.
(dump_iv): Dump base_object.
(dump_use, dump_cand): Use dump_iv.
(determine_base_object): New function.
(alloc_iv): Initialize base_object field.
(record_use): Clear the ssa_name field of iv.
(get_computation_cost_at): Do not use difference of addresses of
two different objects.
(may_eliminate_iv): Do not require the loop to have just single exit.
* tree-ssa-loop-niter.c (zero_p): Do not check for overflows.
(nonzero_p): New function.
(inverse, number_of_iterations_cond, simplify_using_outer_evolutions,
tree_simplify_using_condition, simplify_using_initial_conditions,
loop_niter_by_eval, find_loop_niter_by_eval,
estimate_numbers_of_iterations_loop, compare_trees,
upper_bound_in_type, lower_bound_in_type,
can_count_iv_in_wider_type_bound): Use buildN instead of build. Use
fold_convert or build_int_cst_type instead of convert. Use (non)zero_p
instead of integer_(non)zerop.
From-SVN: r88388
2004-10-01 11:06:06 +02:00
|
|
|
if (TREE_CODE (arg) != INTEGER_CST)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return (TREE_INT_CST_LOW (arg) == 0 && TREE_INT_CST_HIGH (arg) == 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Returns true if ARG a nonzero constant. Unlike integer_nonzerop, it does
|
alias.c, [...]: Fix comment formatting.
* alias.c, basic-block.h, cgraphunit.c, combine.c, domwalk.h,
final.c, gengtype.c, genpreds.c, ggc-page.c, insn-notes.def,
lambda-code.c, loop-unroll.c, modulo-sched.c, pointer-set.c,
pretty-print.c, ra-colorize.c, sbitmap.c, tree-complex.c,
tree-data-ref.c, tree-dfa.c, tree-inline.c, tree-into-ssa.c,
tree-scalar-evolution.c, tree-ssa-dom.c,
tree-ssa-loop-manip.c, tree-ssa-loop-niter.c,
tree-ssa-phiopt.c, tree-ssa-pre.c, tree-ssa-threadupdate.c,
tree-vectorizer.c, vec.h: Fix comment formatting.
From-SVN: r89453
2004-10-22 19:05:11 +02:00
|
|
|
not care about overflow flags. */
|
tree-chrec.c (chrec_fold_plus_poly_poly, [...]): Use fold_convert or build_int_cst_type instead od fonvert.
* tree-chrec.c (chrec_fold_plus_poly_poly, chrec_fold_plus_1,
chrec_fold_multiply): Use fold_convert or build_int_cst_type instead
od fonvert.
* tree-scalar-evolution.c (compute_overall_effect_of_inner_loop,
add_to_evolution, set_nb_iterations_in_loop, follow_ssa_edge_in_rhs,
follow_ssa_edge_in_rhs): Ditto.
* tree-ssa-loop-ivopts.c (struct iv): Add base_object field.
(dump_iv): Dump base_object.
(dump_use, dump_cand): Use dump_iv.
(determine_base_object): New function.
(alloc_iv): Initialize base_object field.
(record_use): Clear the ssa_name field of iv.
(get_computation_cost_at): Do not use difference of addresses of
two different objects.
(may_eliminate_iv): Do not require the loop to have just single exit.
* tree-ssa-loop-niter.c (zero_p): Do not check for overflows.
(nonzero_p): New function.
(inverse, number_of_iterations_cond, simplify_using_outer_evolutions,
tree_simplify_using_condition, simplify_using_initial_conditions,
loop_niter_by_eval, find_loop_niter_by_eval,
estimate_numbers_of_iterations_loop, compare_trees,
upper_bound_in_type, lower_bound_in_type,
can_count_iv_in_wider_type_bound): Use buildN instead of build. Use
fold_convert or build_int_cst_type instead of convert. Use (non)zero_p
instead of integer_(non)zerop.
From-SVN: r88388
2004-10-01 11:06:06 +02:00
|
|
|
|
|
|
|
static bool
|
|
|
|
nonzero_p (tree arg)
|
|
|
|
{
|
|
|
|
if (!arg)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (TREE_CODE (arg) != INTEGER_CST)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return (TREE_INT_CST_LOW (arg) != 0 || TREE_INT_CST_HIGH (arg) != 0);
|
2004-07-09 05:19:14 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Returns inverse of X modulo 2^s, where MASK = 2^s-1. */
|
|
|
|
|
|
|
|
static tree
|
|
|
|
inverse (tree x, tree mask)
|
|
|
|
{
|
|
|
|
tree type = TREE_TYPE (x);
|
2004-10-22 12:31:23 +02:00
|
|
|
tree rslt;
|
|
|
|
unsigned ctr = tree_floor_log2 (mask);
|
|
|
|
|
|
|
|
if (TYPE_PRECISION (type) <= HOST_BITS_PER_WIDE_INT)
|
|
|
|
{
|
|
|
|
unsigned HOST_WIDE_INT ix;
|
|
|
|
unsigned HOST_WIDE_INT imask;
|
|
|
|
unsigned HOST_WIDE_INT irslt = 1;
|
|
|
|
|
|
|
|
gcc_assert (cst_and_fits_in_hwi (x));
|
|
|
|
gcc_assert (cst_and_fits_in_hwi (mask));
|
|
|
|
|
|
|
|
ix = int_cst_value (x);
|
|
|
|
imask = int_cst_value (mask);
|
|
|
|
|
|
|
|
for (; ctr; ctr--)
|
|
|
|
{
|
|
|
|
irslt *= ix;
|
|
|
|
ix *= ix;
|
|
|
|
}
|
|
|
|
irslt &= imask;
|
2004-07-09 05:19:14 +02:00
|
|
|
|
2004-10-22 12:31:23 +02:00
|
|
|
rslt = build_int_cst_type (type, irslt);
|
|
|
|
}
|
|
|
|
else
|
2004-07-09 05:19:14 +02:00
|
|
|
{
|
2004-10-22 12:31:23 +02:00
|
|
|
rslt = build_int_cst_type (type, 1);
|
|
|
|
for (; ctr; ctr--)
|
|
|
|
{
|
2004-11-23 02:27:42 +01:00
|
|
|
rslt = fold_binary_to_constant (MULT_EXPR, type, rslt, x);
|
|
|
|
x = fold_binary_to_constant (MULT_EXPR, type, x, x);
|
2004-10-22 12:31:23 +02:00
|
|
|
}
|
2004-11-23 02:27:42 +01:00
|
|
|
rslt = fold_binary_to_constant (BIT_AND_EXPR, type, rslt, mask);
|
2004-07-09 05:19:14 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return rslt;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Determine the number of iterations according to condition (for staying
|
|
|
|
inside loop) which compares two induction variables using comparison
|
|
|
|
operator CODE. The induction variable on left side of the comparison
|
|
|
|
has base BASE0 and step STEP0. the right-hand side one has base
|
|
|
|
BASE1 and step STEP1. Both induction variables must have type TYPE,
|
|
|
|
which must be an integer or pointer type. STEP0 and STEP1 must be
|
|
|
|
constants (or NULL_TREE, which is interpreted as constant zero).
|
|
|
|
|
|
|
|
The results (number of iterations and assumptions as described in
|
|
|
|
comments at struct tree_niter_desc in tree-flow.h) are stored to NITER.
|
|
|
|
In case we are unable to determine number of iterations, contents of
|
|
|
|
this structure is unchanged. */
|
|
|
|
|
2005-04-06 01:52:41 +02:00
|
|
|
static void
|
2004-07-09 05:19:14 +02:00
|
|
|
number_of_iterations_cond (tree type, tree base0, tree step0,
|
|
|
|
enum tree_code code, tree base1, tree step1,
|
|
|
|
struct tree_niter_desc *niter)
|
|
|
|
{
|
|
|
|
tree step, delta, mmin, mmax;
|
|
|
|
tree may_xform, bound, s, d, tmp;
|
|
|
|
bool was_sharp = false;
|
|
|
|
tree assumption;
|
|
|
|
tree assumptions = boolean_true_node;
|
|
|
|
tree noloop_assumptions = boolean_false_node;
|
|
|
|
tree niter_type, signed_niter_type;
|
2004-10-22 12:31:23 +02:00
|
|
|
tree bits;
|
2004-07-09 05:19:14 +02:00
|
|
|
|
|
|
|
/* The meaning of these assumptions is this:
|
|
|
|
if !assumptions
|
|
|
|
then the rest of information does not have to be valid
|
|
|
|
if noloop_assumptions then the loop does not have to roll
|
|
|
|
(but it is only conservative approximation, i.e. it only says that
|
|
|
|
if !noloop_assumptions, then the loop does not end before the computed
|
|
|
|
number of iterations) */
|
|
|
|
|
|
|
|
/* Make < comparison from > ones. */
|
|
|
|
if (code == GE_EXPR
|
|
|
|
|| code == GT_EXPR)
|
|
|
|
{
|
|
|
|
SWAP (base0, base1);
|
|
|
|
SWAP (step0, step1);
|
|
|
|
code = swap_tree_comparison (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 (!zero_p (step0) && !zero_p (step1))
|
|
|
|
{
|
|
|
|
if (code != NE_EXPR)
|
|
|
|
return;
|
|
|
|
|
2004-11-23 02:27:42 +01:00
|
|
|
step0 = fold_binary_to_constant (MINUS_EXPR, type, step0, step1);
|
2004-07-09 05:19:14 +02:00
|
|
|
step1 = NULL_TREE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If the result 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 (zero_p (step0) && zero_p (step1))
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* Ignore loops of while (i-- < 10) type. */
|
|
|
|
if (code != NE_EXPR)
|
|
|
|
{
|
|
|
|
if (step0 && !tree_expr_nonnegative_p (step0))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!zero_p (step1) && tree_expr_nonnegative_p (step1))
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2004-08-24 22:50:42 +02:00
|
|
|
if (POINTER_TYPE_P (type))
|
2004-07-09 05:19:14 +02:00
|
|
|
{
|
|
|
|
/* We assume pointer arithmetic never overflows. */
|
|
|
|
mmin = mmax = NULL_TREE;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
mmin = TYPE_MIN_VALUE (type);
|
|
|
|
mmax = TYPE_MAX_VALUE (type);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Some more condition normalization. We must record some assumptions
|
|
|
|
due to overflows. */
|
|
|
|
|
|
|
|
if (code == LT_EXPR)
|
|
|
|
{
|
|
|
|
/* We want to take care only of <=; this is easy,
|
|
|
|
as in cases the overflow would make the transformation unsafe the loop
|
|
|
|
does not roll. Seemingly it would make more sense to want to take
|
c-common.c, [...]: Fix comment typos.
* c-common.c, cfgexpand.c, cgraphunit.c, defaults.h,
et-forest.c, expr.c, gimplify.c, global.c, gthr-lynx.h,
hard-reg-set.h, modulo-sched.c, optabs.c, postreload-gcse.c,
tree-data-ref.c, tree-flow.h, tree-if-conv.c, tree-inline.c,
tree-sra.c, tree-ssa-loop-im.c, tree-ssa-loop-ivopts.c,
tree-ssa-loop-niter.c, tree-ssa-operands.c,
tree-ssa-operands.h, tree-ssa-propagate.c,
tree-ssa-propagate.h, tree-ssa-threadupdate.c, value-prof.c,
vec.c, vec.h: Fix comment typos. Follow spelling conventions.
From-SVN: r87104
2004-09-05 17:24:15 +02:00
|
|
|
care of <, as NE is more similar to it, but the problem is that here
|
2004-07-09 05:19:14 +02:00
|
|
|
the transformation would be more difficult due to possibly infinite
|
|
|
|
loops. */
|
|
|
|
if (zero_p (step0))
|
|
|
|
{
|
|
|
|
if (mmax)
|
2005-04-06 01:52:41 +02:00
|
|
|
assumption = fold_build2 (EQ_EXPR, boolean_type_node, base0, mmax);
|
2004-07-09 05:19:14 +02:00
|
|
|
else
|
|
|
|
assumption = boolean_false_node;
|
tree-chrec.c (chrec_fold_plus_poly_poly, [...]): Use fold_convert or build_int_cst_type instead od fonvert.
* tree-chrec.c (chrec_fold_plus_poly_poly, chrec_fold_plus_1,
chrec_fold_multiply): Use fold_convert or build_int_cst_type instead
od fonvert.
* tree-scalar-evolution.c (compute_overall_effect_of_inner_loop,
add_to_evolution, set_nb_iterations_in_loop, follow_ssa_edge_in_rhs,
follow_ssa_edge_in_rhs): Ditto.
* tree-ssa-loop-ivopts.c (struct iv): Add base_object field.
(dump_iv): Dump base_object.
(dump_use, dump_cand): Use dump_iv.
(determine_base_object): New function.
(alloc_iv): Initialize base_object field.
(record_use): Clear the ssa_name field of iv.
(get_computation_cost_at): Do not use difference of addresses of
two different objects.
(may_eliminate_iv): Do not require the loop to have just single exit.
* tree-ssa-loop-niter.c (zero_p): Do not check for overflows.
(nonzero_p): New function.
(inverse, number_of_iterations_cond, simplify_using_outer_evolutions,
tree_simplify_using_condition, simplify_using_initial_conditions,
loop_niter_by_eval, find_loop_niter_by_eval,
estimate_numbers_of_iterations_loop, compare_trees,
upper_bound_in_type, lower_bound_in_type,
can_count_iv_in_wider_type_bound): Use buildN instead of build. Use
fold_convert or build_int_cst_type instead of convert. Use (non)zero_p
instead of integer_(non)zerop.
From-SVN: r88388
2004-10-01 11:06:06 +02:00
|
|
|
if (nonzero_p (assumption))
|
2004-07-09 05:19:14 +02:00
|
|
|
goto zero_iter;
|
2005-04-06 01:52:41 +02:00
|
|
|
base0 = fold_build2 (PLUS_EXPR, type, base0,
|
|
|
|
build_int_cst_type (type, 1));
|
2004-07-09 05:19:14 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (mmin)
|
2005-04-06 01:52:41 +02:00
|
|
|
assumption = fold_build2 (EQ_EXPR, boolean_type_node, base1, mmin);
|
2004-07-09 05:19:14 +02:00
|
|
|
else
|
|
|
|
assumption = boolean_false_node;
|
tree-chrec.c (chrec_fold_plus_poly_poly, [...]): Use fold_convert or build_int_cst_type instead od fonvert.
* tree-chrec.c (chrec_fold_plus_poly_poly, chrec_fold_plus_1,
chrec_fold_multiply): Use fold_convert or build_int_cst_type instead
od fonvert.
* tree-scalar-evolution.c (compute_overall_effect_of_inner_loop,
add_to_evolution, set_nb_iterations_in_loop, follow_ssa_edge_in_rhs,
follow_ssa_edge_in_rhs): Ditto.
* tree-ssa-loop-ivopts.c (struct iv): Add base_object field.
(dump_iv): Dump base_object.
(dump_use, dump_cand): Use dump_iv.
(determine_base_object): New function.
(alloc_iv): Initialize base_object field.
(record_use): Clear the ssa_name field of iv.
(get_computation_cost_at): Do not use difference of addresses of
two different objects.
(may_eliminate_iv): Do not require the loop to have just single exit.
* tree-ssa-loop-niter.c (zero_p): Do not check for overflows.
(nonzero_p): New function.
(inverse, number_of_iterations_cond, simplify_using_outer_evolutions,
tree_simplify_using_condition, simplify_using_initial_conditions,
loop_niter_by_eval, find_loop_niter_by_eval,
estimate_numbers_of_iterations_loop, compare_trees,
upper_bound_in_type, lower_bound_in_type,
can_count_iv_in_wider_type_bound): Use buildN instead of build. Use
fold_convert or build_int_cst_type instead of convert. Use (non)zero_p
instead of integer_(non)zerop.
From-SVN: r88388
2004-10-01 11:06:06 +02:00
|
|
|
if (nonzero_p (assumption))
|
2004-07-09 05:19:14 +02:00
|
|
|
goto zero_iter;
|
2005-04-06 01:52:41 +02:00
|
|
|
base1 = fold_build2 (MINUS_EXPR, type, base1,
|
|
|
|
build_int_cst_type (type, 1));
|
2004-07-09 05:19:14 +02:00
|
|
|
}
|
|
|
|
noloop_assumptions = assumption;
|
|
|
|
code = LE_EXPR;
|
|
|
|
|
|
|
|
/* It will be useful to be able to tell the difference once more in
|
|
|
|
<= -> != reduction. */
|
|
|
|
was_sharp = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Take care of trivially infinite loops. */
|
|
|
|
if (code != NE_EXPR)
|
|
|
|
{
|
|
|
|
if (zero_p (step0)
|
|
|
|
&& mmin
|
|
|
|
&& operand_equal_p (base0, mmin, 0))
|
|
|
|
return;
|
|
|
|
if (zero_p (step1)
|
|
|
|
&& mmax
|
|
|
|
&& operand_equal_p (base1, mmax, 0))
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If we can we want to take care of NE conditions instead of size
|
|
|
|
comparisons, as they are much more friendly (most importantly
|
|
|
|
this takes care of special handling of loops with step 1). We can
|
|
|
|
do it if we first check that upper bound is greater or equal to
|
|
|
|
lower bound, their difference is constant c modulo step and that
|
|
|
|
there is not an overflow. */
|
|
|
|
if (code != NE_EXPR)
|
|
|
|
{
|
|
|
|
if (zero_p (step0))
|
2004-11-23 02:27:42 +01:00
|
|
|
step = fold_unary_to_constant (NEGATE_EXPR, type, step1);
|
2004-07-09 05:19:14 +02:00
|
|
|
else
|
|
|
|
step = step0;
|
tree-chrec.c (chrec_fold_plus_poly_poly, [...]): Use fold_convert or build_int_cst_type instead od fonvert.
* tree-chrec.c (chrec_fold_plus_poly_poly, chrec_fold_plus_1,
chrec_fold_multiply): Use fold_convert or build_int_cst_type instead
od fonvert.
* tree-scalar-evolution.c (compute_overall_effect_of_inner_loop,
add_to_evolution, set_nb_iterations_in_loop, follow_ssa_edge_in_rhs,
follow_ssa_edge_in_rhs): Ditto.
* tree-ssa-loop-ivopts.c (struct iv): Add base_object field.
(dump_iv): Dump base_object.
(dump_use, dump_cand): Use dump_iv.
(determine_base_object): New function.
(alloc_iv): Initialize base_object field.
(record_use): Clear the ssa_name field of iv.
(get_computation_cost_at): Do not use difference of addresses of
two different objects.
(may_eliminate_iv): Do not require the loop to have just single exit.
* tree-ssa-loop-niter.c (zero_p): Do not check for overflows.
(nonzero_p): New function.
(inverse, number_of_iterations_cond, simplify_using_outer_evolutions,
tree_simplify_using_condition, simplify_using_initial_conditions,
loop_niter_by_eval, find_loop_niter_by_eval,
estimate_numbers_of_iterations_loop, compare_trees,
upper_bound_in_type, lower_bound_in_type,
can_count_iv_in_wider_type_bound): Use buildN instead of build. Use
fold_convert or build_int_cst_type instead of convert. Use (non)zero_p
instead of integer_(non)zerop.
From-SVN: r88388
2004-10-01 11:06:06 +02:00
|
|
|
delta = build2 (MINUS_EXPR, type, base1, base0);
|
2005-04-06 01:52:41 +02:00
|
|
|
delta = fold_build2 (FLOOR_MOD_EXPR, type, delta, step);
|
2004-07-09 05:19:14 +02:00
|
|
|
may_xform = boolean_false_node;
|
|
|
|
|
|
|
|
if (TREE_CODE (delta) == INTEGER_CST)
|
|
|
|
{
|
2004-11-23 02:27:42 +01:00
|
|
|
tmp = fold_binary_to_constant (MINUS_EXPR, type, step,
|
|
|
|
build_int_cst_type (type, 1));
|
2004-07-09 05:19:14 +02:00
|
|
|
if (was_sharp
|
|
|
|
&& operand_equal_p (delta, tmp, 0))
|
|
|
|
{
|
|
|
|
/* A special case. We have transformed condition of type
|
|
|
|
for (i = 0; i < 4; i += 4)
|
|
|
|
into
|
|
|
|
for (i = 0; i <= 3; i += 4)
|
|
|
|
obviously if the test for overflow during that transformation
|
|
|
|
passed, we cannot overflow here. Most importantly any
|
|
|
|
loop with sharp end condition and step 1 falls into this
|
c-common.c, [...]: Fix comment typos.
* c-common.c, cfgexpand.c, cgraphunit.c, defaults.h,
et-forest.c, expr.c, gimplify.c, global.c, gthr-lynx.h,
hard-reg-set.h, modulo-sched.c, optabs.c, postreload-gcse.c,
tree-data-ref.c, tree-flow.h, tree-if-conv.c, tree-inline.c,
tree-sra.c, tree-ssa-loop-im.c, tree-ssa-loop-ivopts.c,
tree-ssa-loop-niter.c, tree-ssa-operands.c,
tree-ssa-operands.h, tree-ssa-propagate.c,
tree-ssa-propagate.h, tree-ssa-threadupdate.c, value-prof.c,
vec.c, vec.h: Fix comment typos. Follow spelling conventions.
From-SVN: r87104
2004-09-05 17:24:15 +02:00
|
|
|
category, so handling this case specially is definitely
|
2004-07-09 05:19:14 +02:00
|
|
|
worth the troubles. */
|
|
|
|
may_xform = boolean_true_node;
|
|
|
|
}
|
|
|
|
else if (zero_p (step0))
|
|
|
|
{
|
|
|
|
if (!mmin)
|
|
|
|
may_xform = boolean_true_node;
|
|
|
|
else
|
|
|
|
{
|
2004-11-23 02:27:42 +01:00
|
|
|
bound = fold_binary_to_constant (PLUS_EXPR, type,
|
|
|
|
mmin, step);
|
|
|
|
bound = fold_binary_to_constant (MINUS_EXPR, type,
|
|
|
|
bound, delta);
|
2005-04-06 01:52:41 +02:00
|
|
|
may_xform = fold_build2 (LE_EXPR, boolean_type_node,
|
|
|
|
bound, base0);
|
2004-07-09 05:19:14 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (!mmax)
|
|
|
|
may_xform = boolean_true_node;
|
|
|
|
else
|
|
|
|
{
|
2004-11-23 02:27:42 +01:00
|
|
|
bound = fold_binary_to_constant (MINUS_EXPR, type,
|
|
|
|
mmax, step);
|
|
|
|
bound = fold_binary_to_constant (PLUS_EXPR, type,
|
|
|
|
bound, delta);
|
2005-04-06 01:52:41 +02:00
|
|
|
may_xform = fold_build2 (LE_EXPR, boolean_type_node,
|
|
|
|
base1, bound);
|
2004-07-09 05:19:14 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
tree-chrec.c (chrec_fold_plus_poly_poly, [...]): Use fold_convert or build_int_cst_type instead od fonvert.
* tree-chrec.c (chrec_fold_plus_poly_poly, chrec_fold_plus_1,
chrec_fold_multiply): Use fold_convert or build_int_cst_type instead
od fonvert.
* tree-scalar-evolution.c (compute_overall_effect_of_inner_loop,
add_to_evolution, set_nb_iterations_in_loop, follow_ssa_edge_in_rhs,
follow_ssa_edge_in_rhs): Ditto.
* tree-ssa-loop-ivopts.c (struct iv): Add base_object field.
(dump_iv): Dump base_object.
(dump_use, dump_cand): Use dump_iv.
(determine_base_object): New function.
(alloc_iv): Initialize base_object field.
(record_use): Clear the ssa_name field of iv.
(get_computation_cost_at): Do not use difference of addresses of
two different objects.
(may_eliminate_iv): Do not require the loop to have just single exit.
* tree-ssa-loop-niter.c (zero_p): Do not check for overflows.
(nonzero_p): New function.
(inverse, number_of_iterations_cond, simplify_using_outer_evolutions,
tree_simplify_using_condition, simplify_using_initial_conditions,
loop_niter_by_eval, find_loop_niter_by_eval,
estimate_numbers_of_iterations_loop, compare_trees,
upper_bound_in_type, lower_bound_in_type,
can_count_iv_in_wider_type_bound): Use buildN instead of build. Use
fold_convert or build_int_cst_type instead of convert. Use (non)zero_p
instead of integer_(non)zerop.
From-SVN: r88388
2004-10-01 11:06:06 +02:00
|
|
|
if (!zero_p (may_xform))
|
2004-07-09 05:19:14 +02:00
|
|
|
{
|
|
|
|
/* We perform the transformation always provided that it is not
|
|
|
|
completely senseless. This is OK, as we would need this assumption
|
|
|
|
to determine the number of iterations anyway. */
|
tree-chrec.c (chrec_fold_plus_poly_poly, [...]): Use fold_convert or build_int_cst_type instead od fonvert.
* tree-chrec.c (chrec_fold_plus_poly_poly, chrec_fold_plus_1,
chrec_fold_multiply): Use fold_convert or build_int_cst_type instead
od fonvert.
* tree-scalar-evolution.c (compute_overall_effect_of_inner_loop,
add_to_evolution, set_nb_iterations_in_loop, follow_ssa_edge_in_rhs,
follow_ssa_edge_in_rhs): Ditto.
* tree-ssa-loop-ivopts.c (struct iv): Add base_object field.
(dump_iv): Dump base_object.
(dump_use, dump_cand): Use dump_iv.
(determine_base_object): New function.
(alloc_iv): Initialize base_object field.
(record_use): Clear the ssa_name field of iv.
(get_computation_cost_at): Do not use difference of addresses of
two different objects.
(may_eliminate_iv): Do not require the loop to have just single exit.
* tree-ssa-loop-niter.c (zero_p): Do not check for overflows.
(nonzero_p): New function.
(inverse, number_of_iterations_cond, simplify_using_outer_evolutions,
tree_simplify_using_condition, simplify_using_initial_conditions,
loop_niter_by_eval, find_loop_niter_by_eval,
estimate_numbers_of_iterations_loop, compare_trees,
upper_bound_in_type, lower_bound_in_type,
can_count_iv_in_wider_type_bound): Use buildN instead of build. Use
fold_convert or build_int_cst_type instead of convert. Use (non)zero_p
instead of integer_(non)zerop.
From-SVN: r88388
2004-10-01 11:06:06 +02:00
|
|
|
if (!nonzero_p (may_xform))
|
2004-07-09 05:19:14 +02:00
|
|
|
assumptions = may_xform;
|
|
|
|
|
|
|
|
if (zero_p (step0))
|
|
|
|
{
|
2005-04-06 01:52:41 +02:00
|
|
|
base0 = fold_build2 (PLUS_EXPR, type, base0, delta);
|
|
|
|
base0 = fold_build2 (MINUS_EXPR, type, base0, step);
|
2004-07-09 05:19:14 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2005-04-06 01:52:41 +02:00
|
|
|
base1 = fold_build2 (MINUS_EXPR, type, base1, delta);
|
|
|
|
base1 = fold_build2 (PLUS_EXPR, type, base1, step);
|
2004-07-09 05:19:14 +02:00
|
|
|
}
|
|
|
|
|
2005-04-06 01:52:41 +02:00
|
|
|
assumption = fold_build2 (GT_EXPR, boolean_type_node, base0, base1);
|
|
|
|
noloop_assumptions = fold_build2 (TRUTH_OR_EXPR, boolean_type_node,
|
|
|
|
noloop_assumptions, assumption);
|
2004-07-09 05:19:14 +02:00
|
|
|
code = NE_EXPR;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Count the number of iterations. */
|
|
|
|
niter_type = unsigned_type_for (type);
|
|
|
|
signed_niter_type = signed_type_for (type);
|
|
|
|
|
|
|
|
if (code == NE_EXPR)
|
|
|
|
{
|
|
|
|
/* Everything we do here is just arithmetics modulo size of mode. This
|
|
|
|
makes us able to do more involved computations of number of iterations
|
|
|
|
than in other cases. First transform the condition into shape
|
|
|
|
s * i <> c, with s positive. */
|
2005-04-06 01:52:41 +02:00
|
|
|
base1 = fold_build2 (MINUS_EXPR, type, base1, base0);
|
2004-07-09 05:19:14 +02:00
|
|
|
base0 = NULL_TREE;
|
|
|
|
if (!zero_p (step1))
|
2004-11-23 02:27:42 +01:00
|
|
|
step0 = fold_unary_to_constant (NEGATE_EXPR, type, step1);
|
2004-07-09 05:19:14 +02:00
|
|
|
step1 = NULL_TREE;
|
tree-chrec.c (chrec_fold_plus_poly_poly, [...]): Use fold_convert or build_int_cst_type instead od fonvert.
* tree-chrec.c (chrec_fold_plus_poly_poly, chrec_fold_plus_1,
chrec_fold_multiply): Use fold_convert or build_int_cst_type instead
od fonvert.
* tree-scalar-evolution.c (compute_overall_effect_of_inner_loop,
add_to_evolution, set_nb_iterations_in_loop, follow_ssa_edge_in_rhs,
follow_ssa_edge_in_rhs): Ditto.
* tree-ssa-loop-ivopts.c (struct iv): Add base_object field.
(dump_iv): Dump base_object.
(dump_use, dump_cand): Use dump_iv.
(determine_base_object): New function.
(alloc_iv): Initialize base_object field.
(record_use): Clear the ssa_name field of iv.
(get_computation_cost_at): Do not use difference of addresses of
two different objects.
(may_eliminate_iv): Do not require the loop to have just single exit.
* tree-ssa-loop-niter.c (zero_p): Do not check for overflows.
(nonzero_p): New function.
(inverse, number_of_iterations_cond, simplify_using_outer_evolutions,
tree_simplify_using_condition, simplify_using_initial_conditions,
loop_niter_by_eval, find_loop_niter_by_eval,
estimate_numbers_of_iterations_loop, compare_trees,
upper_bound_in_type, lower_bound_in_type,
can_count_iv_in_wider_type_bound): Use buildN instead of build. Use
fold_convert or build_int_cst_type instead of convert. Use (non)zero_p
instead of integer_(non)zerop.
From-SVN: r88388
2004-10-01 11:06:06 +02:00
|
|
|
if (!tree_expr_nonnegative_p (fold_convert (signed_niter_type, step0)))
|
2004-07-09 05:19:14 +02:00
|
|
|
{
|
2004-11-23 02:27:42 +01:00
|
|
|
step0 = fold_unary_to_constant (NEGATE_EXPR, type, step0);
|
2005-04-06 01:52:41 +02:00
|
|
|
base1 = fold_build1 (NEGATE_EXPR, type, base1);
|
2004-07-09 05:19:14 +02:00
|
|
|
}
|
|
|
|
|
tree-chrec.c (chrec_fold_plus_poly_poly, [...]): Use fold_convert or build_int_cst_type instead od fonvert.
* tree-chrec.c (chrec_fold_plus_poly_poly, chrec_fold_plus_1,
chrec_fold_multiply): Use fold_convert or build_int_cst_type instead
od fonvert.
* tree-scalar-evolution.c (compute_overall_effect_of_inner_loop,
add_to_evolution, set_nb_iterations_in_loop, follow_ssa_edge_in_rhs,
follow_ssa_edge_in_rhs): Ditto.
* tree-ssa-loop-ivopts.c (struct iv): Add base_object field.
(dump_iv): Dump base_object.
(dump_use, dump_cand): Use dump_iv.
(determine_base_object): New function.
(alloc_iv): Initialize base_object field.
(record_use): Clear the ssa_name field of iv.
(get_computation_cost_at): Do not use difference of addresses of
two different objects.
(may_eliminate_iv): Do not require the loop to have just single exit.
* tree-ssa-loop-niter.c (zero_p): Do not check for overflows.
(nonzero_p): New function.
(inverse, number_of_iterations_cond, simplify_using_outer_evolutions,
tree_simplify_using_condition, simplify_using_initial_conditions,
loop_niter_by_eval, find_loop_niter_by_eval,
estimate_numbers_of_iterations_loop, compare_trees,
upper_bound_in_type, lower_bound_in_type,
can_count_iv_in_wider_type_bound): Use buildN instead of build. Use
fold_convert or build_int_cst_type instead of convert. Use (non)zero_p
instead of integer_(non)zerop.
From-SVN: r88388
2004-10-01 11:06:06 +02:00
|
|
|
base1 = fold_convert (niter_type, base1);
|
|
|
|
step0 = fold_convert (niter_type, step0);
|
2004-07-09 05:19:14 +02:00
|
|
|
|
2004-10-22 12:31:23 +02:00
|
|
|
/* Let nsd (step, size of mode) = d. If d does not divide c, the loop
|
2004-07-09 05:19:14 +02:00
|
|
|
is infinite. Otherwise, the number of iterations is
|
|
|
|
(inverse(s/d) * (c/d)) mod (size of mode/d). */
|
2004-10-22 12:31:23 +02:00
|
|
|
bits = num_ending_zeros (step0);
|
2004-11-23 02:27:42 +01:00
|
|
|
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);
|
2004-10-27 22:27:20 +02:00
|
|
|
|
|
|
|
bound = build_low_bits_mask (niter_type,
|
|
|
|
(TYPE_PRECISION (niter_type)
|
|
|
|
- tree_low_cst (bits, 1)));
|
2004-07-09 05:19:14 +02:00
|
|
|
|
2005-04-06 01:52:41 +02:00
|
|
|
assumption = fold_build2 (FLOOR_MOD_EXPR, niter_type, base1, d);
|
|
|
|
assumption = fold_build2 (EQ_EXPR, boolean_type_node,
|
|
|
|
assumption,
|
|
|
|
build_int_cst (niter_type, 0));
|
|
|
|
assumptions = fold_build2 (TRUTH_AND_EXPR, boolean_type_node,
|
|
|
|
assumptions, assumption);
|
tree-ssa-loop-ivcanon.c: New file.
* tree-ssa-loop-ivcanon.c: New file.
* tree-ssa-loop-manip.c (create_iv): New function.
* Makefile.in (tree-ssa-loop-ivcanon.o): Add.
(tree-ssa-loop.o, tree-ssa-loop-manip.o): Add SCEV_H dependency.
* cfgloop.c (mark_single_exit_loops): New function.
(verify_loop_structure): Verify single-exit loops.
* cfgloop.h (struct loop): Add single_exit field.
(LOOPS_HAVE_MARKED_SINGLE_EXITS): New constant.
(mark_single_exit_loops): Declare.
(tree_num_loop_insns): Declare.
* cfgloopmanip.c (update_single_exits_after_duplication): New function.
(duplicate_loop_to_header_edge): Use it.
* common.opt (fivcanon): New flag.
* timevar.def (TV_TREE_LOOP_IVCANON, TV_COMPLETE_UNROLL): New timevars.
* tree-cfg.c (tree_find_edge_insert_loc): Return newly created block.
(bsi_commit_edge_inserts_1): Pass null to tree_find_edge_insert_loc.
(bsi_insert_on_edge_immediate): New function.
* tree-flow.h (bsi_insert_on_edge_immediate,
canonicalize_induction_variables, tree_unroll_loops_completely,
create_iv): Declare.
* tree-optimize.c (init_tree_optimization_passes): Add
pass_iv_canon and pass_complete_unroll.
* tree-pass.h (pass_iv_canon, pass_complete_unroll): Declare.
* tree-scalar-evolution.c (get_loop_exit_condition,
get_exit_conditions_rec, number_of_iterations_in_loop,
scev_initialize): Use single_exit information.
* tree-ssa-loop-niter.c (number_of_iterations_cond): Record
missing assumptions.
(loop_niter_by_eval): Return number of iterations as unsigned
int.
* tree-ssa-loop.c (tree_ssa_loop_init): Mark single exit loops.
(tree_ssa_loop_ivcanon, gate_tree_ssa_loop_ivcanon, pass_iv_canon,
tree_complete_unroll, gate_tree_complete_unroll, pass_complete_unroll):
New passes.
(tree_ssa_loop_done): Call free_numbers_of_iterations_estimates.
* tree-ssanames.c (make_ssa_name): Allow creating ssa name before
the defining statement is ready.
* tree-vectorizer.c (vect_create_iv_simple): Removed.
(vect_create_index_for_array_ref, vect_transform_loop_bound):
Use create_iv.
(vect_transform_loop_bound): Use single_exit information.
(vect_analyze_loop_form): Cleanup bogus tests.
(vectorize_loops): Do not call flow_loop_scan.
* tree.h (may_negate_without_overflow_p): Declare.
* fold-const.c (may_negate_without_overflow_p): Split out from ...
(negate_expr_p): ... this function.
(tree_expr_nonzero_p): Handle overflowed constants correctly.
* doc/invoke.texi (-fivcanon): Document.
* doc/passes.texi: Document canonical induction variable creation.
* gcc.dg/tree-ssa/loop-1.c: New test.
From-SVN: r86516
2004-08-24 22:48:23 +02:00
|
|
|
|
2005-04-06 01:52:41 +02:00
|
|
|
tmp = fold_build2 (EXACT_DIV_EXPR, niter_type, base1, d);
|
|
|
|
tmp = fold_build2 (MULT_EXPR, niter_type, tmp, inverse (s, bound));
|
|
|
|
niter->niter = fold_build2 (BIT_AND_EXPR, niter_type, tmp, bound);
|
2004-07-09 05:19:14 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (zero_p (step1))
|
|
|
|
/* Condition in shape a + s * i <= b
|
|
|
|
We must know that b + s does not overflow and a <= b + s and then we
|
|
|
|
can compute number of iterations as (b + s - a) / s. (It might
|
|
|
|
seem that we in fact could be more clever about testing the b + s
|
|
|
|
overflow condition using some information about b - a mod s,
|
|
|
|
but it was already taken into account during LE -> NE transform). */
|
|
|
|
{
|
|
|
|
if (mmax)
|
|
|
|
{
|
2004-11-23 02:27:42 +01:00
|
|
|
bound = fold_binary_to_constant (MINUS_EXPR, type, mmax, step0);
|
2005-04-06 01:52:41 +02:00
|
|
|
assumption = fold_build2 (LE_EXPR, boolean_type_node,
|
|
|
|
base1, bound);
|
|
|
|
assumptions = fold_build2 (TRUTH_AND_EXPR, boolean_type_node,
|
|
|
|
assumptions, assumption);
|
2004-07-09 05:19:14 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
step = step0;
|
2005-04-06 01:52:41 +02:00
|
|
|
tmp = fold_build2 (PLUS_EXPR, type, base1, step0);
|
|
|
|
assumption = fold_build2 (GT_EXPR, boolean_type_node, base0, tmp);
|
|
|
|
delta = fold_build2 (PLUS_EXPR, type, base1, step);
|
|
|
|
delta = fold_build2 (MINUS_EXPR, type, delta, base0);
|
tree-chrec.c (chrec_fold_plus_poly_poly, [...]): Use fold_convert or build_int_cst_type instead od fonvert.
* tree-chrec.c (chrec_fold_plus_poly_poly, chrec_fold_plus_1,
chrec_fold_multiply): Use fold_convert or build_int_cst_type instead
od fonvert.
* tree-scalar-evolution.c (compute_overall_effect_of_inner_loop,
add_to_evolution, set_nb_iterations_in_loop, follow_ssa_edge_in_rhs,
follow_ssa_edge_in_rhs): Ditto.
* tree-ssa-loop-ivopts.c (struct iv): Add base_object field.
(dump_iv): Dump base_object.
(dump_use, dump_cand): Use dump_iv.
(determine_base_object): New function.
(alloc_iv): Initialize base_object field.
(record_use): Clear the ssa_name field of iv.
(get_computation_cost_at): Do not use difference of addresses of
two different objects.
(may_eliminate_iv): Do not require the loop to have just single exit.
* tree-ssa-loop-niter.c (zero_p): Do not check for overflows.
(nonzero_p): New function.
(inverse, number_of_iterations_cond, simplify_using_outer_evolutions,
tree_simplify_using_condition, simplify_using_initial_conditions,
loop_niter_by_eval, find_loop_niter_by_eval,
estimate_numbers_of_iterations_loop, compare_trees,
upper_bound_in_type, lower_bound_in_type,
can_count_iv_in_wider_type_bound): Use buildN instead of build. Use
fold_convert or build_int_cst_type instead of convert. Use (non)zero_p
instead of integer_(non)zerop.
From-SVN: r88388
2004-10-01 11:06:06 +02:00
|
|
|
delta = fold_convert (niter_type, delta);
|
2004-07-09 05:19:14 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Condition in shape a <= b - s * i
|
|
|
|
We must know that a - s does not overflow and a - s <= b and then
|
|
|
|
we can again compute number of iterations as (b - (a - s)) / s. */
|
|
|
|
if (mmin)
|
|
|
|
{
|
2004-11-23 02:27:42 +01:00
|
|
|
bound = fold_binary_to_constant (MINUS_EXPR, type, mmin, step1);
|
2005-04-06 01:52:41 +02:00
|
|
|
assumption = fold_build2 (LE_EXPR, boolean_type_node,
|
|
|
|
bound, base0);
|
|
|
|
assumptions = fold_build2 (TRUTH_AND_EXPR, boolean_type_node,
|
|
|
|
assumptions, assumption);
|
2004-07-09 05:19:14 +02:00
|
|
|
}
|
2005-04-06 01:52:41 +02:00
|
|
|
step = fold_build1 (NEGATE_EXPR, type, step1);
|
|
|
|
tmp = fold_build2 (PLUS_EXPR, type, base0, step1);
|
|
|
|
assumption = fold_build2 (GT_EXPR, boolean_type_node, tmp, base1);
|
|
|
|
delta = fold_build2 (MINUS_EXPR, type, base0, step);
|
|
|
|
delta = fold_build2 (MINUS_EXPR, type, base1, delta);
|
tree-chrec.c (chrec_fold_plus_poly_poly, [...]): Use fold_convert or build_int_cst_type instead od fonvert.
* tree-chrec.c (chrec_fold_plus_poly_poly, chrec_fold_plus_1,
chrec_fold_multiply): Use fold_convert or build_int_cst_type instead
od fonvert.
* tree-scalar-evolution.c (compute_overall_effect_of_inner_loop,
add_to_evolution, set_nb_iterations_in_loop, follow_ssa_edge_in_rhs,
follow_ssa_edge_in_rhs): Ditto.
* tree-ssa-loop-ivopts.c (struct iv): Add base_object field.
(dump_iv): Dump base_object.
(dump_use, dump_cand): Use dump_iv.
(determine_base_object): New function.
(alloc_iv): Initialize base_object field.
(record_use): Clear the ssa_name field of iv.
(get_computation_cost_at): Do not use difference of addresses of
two different objects.
(may_eliminate_iv): Do not require the loop to have just single exit.
* tree-ssa-loop-niter.c (zero_p): Do not check for overflows.
(nonzero_p): New function.
(inverse, number_of_iterations_cond, simplify_using_outer_evolutions,
tree_simplify_using_condition, simplify_using_initial_conditions,
loop_niter_by_eval, find_loop_niter_by_eval,
estimate_numbers_of_iterations_loop, compare_trees,
upper_bound_in_type, lower_bound_in_type,
can_count_iv_in_wider_type_bound): Use buildN instead of build. Use
fold_convert or build_int_cst_type instead of convert. Use (non)zero_p
instead of integer_(non)zerop.
From-SVN: r88388
2004-10-01 11:06:06 +02:00
|
|
|
delta = fold_convert (niter_type, delta);
|
2004-07-09 05:19:14 +02:00
|
|
|
}
|
2005-04-06 01:52:41 +02:00
|
|
|
noloop_assumptions = fold_build2 (TRUTH_OR_EXPR, boolean_type_node,
|
|
|
|
noloop_assumptions, assumption);
|
|
|
|
delta = fold_build2 (FLOOR_DIV_EXPR, niter_type, delta,
|
|
|
|
fold_convert (niter_type, step));
|
2004-07-09 05:19:14 +02:00
|
|
|
niter->niter = delta;
|
|
|
|
}
|
|
|
|
|
|
|
|
niter->assumptions = assumptions;
|
|
|
|
niter->may_be_zero = noloop_assumptions;
|
|
|
|
return;
|
|
|
|
|
|
|
|
zero_iter:
|
|
|
|
niter->assumptions = boolean_true_node;
|
|
|
|
niter->may_be_zero = boolean_true_node;
|
tree-chrec.c (chrec_fold_plus_poly_poly, [...]): Use fold_convert or build_int_cst_type instead od fonvert.
* tree-chrec.c (chrec_fold_plus_poly_poly, chrec_fold_plus_1,
chrec_fold_multiply): Use fold_convert or build_int_cst_type instead
od fonvert.
* tree-scalar-evolution.c (compute_overall_effect_of_inner_loop,
add_to_evolution, set_nb_iterations_in_loop, follow_ssa_edge_in_rhs,
follow_ssa_edge_in_rhs): Ditto.
* tree-ssa-loop-ivopts.c (struct iv): Add base_object field.
(dump_iv): Dump base_object.
(dump_use, dump_cand): Use dump_iv.
(determine_base_object): New function.
(alloc_iv): Initialize base_object field.
(record_use): Clear the ssa_name field of iv.
(get_computation_cost_at): Do not use difference of addresses of
two different objects.
(may_eliminate_iv): Do not require the loop to have just single exit.
* tree-ssa-loop-niter.c (zero_p): Do not check for overflows.
(nonzero_p): New function.
(inverse, number_of_iterations_cond, simplify_using_outer_evolutions,
tree_simplify_using_condition, simplify_using_initial_conditions,
loop_niter_by_eval, find_loop_niter_by_eval,
estimate_numbers_of_iterations_loop, compare_trees,
upper_bound_in_type, lower_bound_in_type,
can_count_iv_in_wider_type_bound): Use buildN instead of build. Use
fold_convert or build_int_cst_type instead of convert. Use (non)zero_p
instead of integer_(non)zerop.
From-SVN: r88388
2004-10-01 11:06:06 +02:00
|
|
|
niter->niter = build_int_cst_type (type, 0);
|
2004-07-09 05:19:14 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-04-06 01:52:41 +02:00
|
|
|
/* Similar to number_of_iterations_cond, but only handles the special
|
|
|
|
case of loops with step 1 or -1. The meaning of the arguments
|
|
|
|
is the same as in number_of_iterations_cond. The function
|
|
|
|
returns true if the special case was recognized, false otherwise. */
|
|
|
|
|
|
|
|
static bool
|
|
|
|
number_of_iterations_special (tree type, tree base0, tree step0,
|
|
|
|
enum tree_code code, tree base1, tree step1,
|
|
|
|
struct tree_niter_desc *niter)
|
2004-07-09 05:19:14 +02:00
|
|
|
{
|
2005-04-06 01:52:41 +02:00
|
|
|
tree niter_type = unsigned_type_for (type), mmax, mmin;
|
2004-07-09 05:19:14 +02:00
|
|
|
|
2005-04-06 01:52:41 +02:00
|
|
|
/* Make < comparison from > ones. */
|
|
|
|
if (code == GE_EXPR
|
|
|
|
|| code == GT_EXPR)
|
|
|
|
{
|
|
|
|
SWAP (base0, base1);
|
|
|
|
SWAP (step0, step1);
|
|
|
|
code = swap_tree_comparison (code);
|
|
|
|
}
|
2004-07-09 05:19:14 +02:00
|
|
|
|
2005-04-06 01:52:41 +02:00
|
|
|
switch (code)
|
2004-07-09 05:19:14 +02:00
|
|
|
{
|
2005-04-06 01:52:41 +02:00
|
|
|
case NE_EXPR:
|
|
|
|
if (zero_p (step0))
|
|
|
|
{
|
|
|
|
if (zero_p (step1))
|
|
|
|
return false;
|
|
|
|
SWAP (base0, base1);
|
|
|
|
SWAP (step0, step1);
|
|
|
|
}
|
|
|
|
else if (!zero_p (step1))
|
|
|
|
return false;
|
2004-07-09 05:19:14 +02:00
|
|
|
|
2005-04-06 01:52:41 +02:00
|
|
|
if (integer_onep (step0))
|
|
|
|
{
|
|
|
|
/* for (i = base0; i != base1; i++) */
|
|
|
|
niter->assumptions = boolean_true_node;
|
|
|
|
niter->may_be_zero = boolean_false_node;
|
|
|
|
niter->niter = fold_build2 (MINUS_EXPR, type, base1, base0);
|
|
|
|
niter->additional_info = boolean_true_node;
|
|
|
|
}
|
|
|
|
else if (integer_all_onesp (step0))
|
|
|
|
{
|
|
|
|
/* for (i = base0; i != base1; i--) */
|
|
|
|
niter->assumptions = boolean_true_node;
|
|
|
|
niter->may_be_zero = boolean_false_node;
|
|
|
|
niter->niter = fold_build2 (MINUS_EXPR, type, base0, base1);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
return false;
|
2004-07-09 05:19:14 +02:00
|
|
|
|
2005-04-06 01:52:41 +02:00
|
|
|
break;
|
2004-07-09 05:19:14 +02:00
|
|
|
|
2005-04-06 01:52:41 +02:00
|
|
|
case LT_EXPR:
|
|
|
|
if ((step0 && integer_onep (step0) && zero_p (step1))
|
|
|
|
|| (step1 && integer_all_onesp (step1) && zero_p (step0)))
|
2004-07-09 05:19:14 +02:00
|
|
|
{
|
2005-04-06 01:52:41 +02:00
|
|
|
/* for (i = base0; i < base1; i++)
|
|
|
|
|
|
|
|
or
|
|
|
|
|
|
|
|
for (i = base1; i > base0; i--).
|
|
|
|
|
|
|
|
In both cases # of iterations is base1 - base0. */
|
|
|
|
|
|
|
|
niter->assumptions = boolean_true_node;
|
|
|
|
niter->may_be_zero = fold_build2 (GT_EXPR, boolean_type_node,
|
|
|
|
base0, base1);
|
|
|
|
niter->niter = fold_build2 (MINUS_EXPR, type, base1, base0);
|
2004-07-09 05:19:14 +02:00
|
|
|
}
|
|
|
|
else
|
2005-04-06 01:52:41 +02:00
|
|
|
return false;
|
|
|
|
break;
|
2004-07-09 05:19:14 +02:00
|
|
|
|
2005-04-06 01:52:41 +02:00
|
|
|
case LE_EXPR:
|
|
|
|
if (POINTER_TYPE_P (type))
|
2004-07-09 05:19:14 +02:00
|
|
|
{
|
2005-04-06 01:52:41 +02:00
|
|
|
/* We assume pointer arithmetic never overflows. */
|
|
|
|
mmin = mmax = NULL_TREE;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
mmin = TYPE_MIN_VALUE (type);
|
|
|
|
mmax = TYPE_MAX_VALUE (type);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (step0 && integer_onep (step0) && zero_p (step1))
|
|
|
|
{
|
|
|
|
/* for (i = base0; i <= base1; i++) */
|
|
|
|
if (mmax)
|
|
|
|
niter->assumptions = fold_build2 (NE_EXPR, boolean_type_node,
|
|
|
|
base1, mmax);
|
2004-07-09 05:19:14 +02:00
|
|
|
else
|
2005-04-06 01:52:41 +02:00
|
|
|
niter->assumptions = boolean_true_node;
|
|
|
|
base1 = fold_build2 (PLUS_EXPR, type, base1,
|
|
|
|
build_int_cst_type (type, 1));
|
2004-07-09 05:19:14 +02:00
|
|
|
}
|
2005-04-06 01:52:41 +02:00
|
|
|
else if (step1 && integer_all_onesp (step1) && zero_p (step0))
|
|
|
|
{
|
|
|
|
/* for (i = base1; i >= base0; i--) */
|
|
|
|
if (mmin)
|
|
|
|
niter->assumptions = fold_build2 (NE_EXPR, boolean_type_node,
|
|
|
|
base0, mmin);
|
|
|
|
else
|
|
|
|
niter->assumptions = boolean_true_node;
|
|
|
|
base0 = fold_build2 (MINUS_EXPR, type, base0,
|
|
|
|
build_int_cst_type (type, 1));
|
|
|
|
}
|
|
|
|
else
|
|
|
|
return false;
|
2004-07-09 05:19:14 +02:00
|
|
|
|
2005-04-06 01:52:41 +02:00
|
|
|
niter->may_be_zero = fold_build2 (GT_EXPR, boolean_type_node,
|
|
|
|
base0, base1);
|
|
|
|
niter->niter = fold_build2 (MINUS_EXPR, type, base1, base0);
|
|
|
|
break;
|
2004-07-09 05:19:14 +02:00
|
|
|
|
2005-04-06 01:52:41 +02:00
|
|
|
default:
|
|
|
|
gcc_unreachable ();
|
|
|
|
}
|
2004-07-09 05:19:14 +02:00
|
|
|
|
2005-04-06 01:52:41 +02:00
|
|
|
niter->niter = fold_convert (niter_type, niter->niter);
|
|
|
|
niter->additional_info = boolean_true_node;
|
|
|
|
return true;
|
2004-07-09 05:19:14 +02:00
|
|
|
}
|
|
|
|
|
2004-11-22 22:33:47 +01:00
|
|
|
/* Substitute NEW for OLD in EXPR and fold the result. */
|
|
|
|
|
|
|
|
static tree
|
|
|
|
simplify_replace_tree (tree expr, tree old, tree new)
|
|
|
|
{
|
|
|
|
unsigned i, n;
|
|
|
|
tree ret = NULL_TREE, e, se;
|
|
|
|
|
|
|
|
if (!expr)
|
|
|
|
return NULL_TREE;
|
|
|
|
|
|
|
|
if (expr == old
|
|
|
|
|| operand_equal_p (expr, old, 0))
|
|
|
|
return unshare_expr (new);
|
|
|
|
|
|
|
|
if (!EXPR_P (expr))
|
|
|
|
return expr;
|
|
|
|
|
|
|
|
n = TREE_CODE_LENGTH (TREE_CODE (expr));
|
|
|
|
for (i = 0; i < n; i++)
|
|
|
|
{
|
|
|
|
e = TREE_OPERAND (expr, i);
|
|
|
|
se = simplify_replace_tree (e, old, new);
|
|
|
|
if (e == se)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!ret)
|
|
|
|
ret = copy_node (expr);
|
|
|
|
|
|
|
|
TREE_OPERAND (ret, i) = se;
|
|
|
|
}
|
|
|
|
|
|
|
|
return (ret ? fold (ret) : expr);
|
|
|
|
}
|
|
|
|
|
2004-07-09 05:19:14 +02:00
|
|
|
/* Tries to simplify EXPR using the condition COND. Returns the simplified
|
|
|
|
expression (or EXPR unchanged, if no simplification was possible).*/
|
|
|
|
|
|
|
|
static tree
|
|
|
|
tree_simplify_using_condition (tree cond, tree expr)
|
|
|
|
{
|
|
|
|
bool changed;
|
|
|
|
tree e, e0, e1, e2, notcond;
|
|
|
|
enum tree_code code = TREE_CODE (expr);
|
|
|
|
|
|
|
|
if (code == INTEGER_CST)
|
|
|
|
return expr;
|
|
|
|
|
|
|
|
if (code == TRUTH_OR_EXPR
|
|
|
|
|| code == TRUTH_AND_EXPR
|
|
|
|
|| code == COND_EXPR)
|
|
|
|
{
|
|
|
|
changed = false;
|
|
|
|
|
|
|
|
e0 = tree_simplify_using_condition (cond, TREE_OPERAND (expr, 0));
|
|
|
|
if (TREE_OPERAND (expr, 0) != e0)
|
|
|
|
changed = true;
|
|
|
|
|
|
|
|
e1 = tree_simplify_using_condition (cond, TREE_OPERAND (expr, 1));
|
|
|
|
if (TREE_OPERAND (expr, 1) != e1)
|
|
|
|
changed = true;
|
|
|
|
|
|
|
|
if (code == COND_EXPR)
|
|
|
|
{
|
|
|
|
e2 = tree_simplify_using_condition (cond, TREE_OPERAND (expr, 2));
|
|
|
|
if (TREE_OPERAND (expr, 2) != e2)
|
|
|
|
changed = true;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
e2 = NULL_TREE;
|
|
|
|
|
|
|
|
if (changed)
|
|
|
|
{
|
|
|
|
if (code == COND_EXPR)
|
2005-04-06 01:52:41 +02:00
|
|
|
expr = fold_build3 (code, boolean_type_node, e0, e1, e2);
|
2004-07-09 05:19:14 +02:00
|
|
|
else
|
2005-04-06 01:52:41 +02:00
|
|
|
expr = fold_build2 (code, boolean_type_node, e0, e1);
|
2004-07-09 05:19:14 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return expr;
|
|
|
|
}
|
|
|
|
|
2004-11-22 22:33:47 +01:00
|
|
|
/* In case COND is equality, we may be able to simplify EXPR by copy/constant
|
|
|
|
propagation, and vice versa. Fold does not handle this, since it is
|
|
|
|
considered too expensive. */
|
|
|
|
if (TREE_CODE (cond) == EQ_EXPR)
|
|
|
|
{
|
|
|
|
e0 = TREE_OPERAND (cond, 0);
|
|
|
|
e1 = TREE_OPERAND (cond, 1);
|
|
|
|
|
|
|
|
/* We know that e0 == e1. Check whether we cannot simplify expr
|
|
|
|
using this fact. */
|
|
|
|
e = simplify_replace_tree (expr, e0, e1);
|
|
|
|
if (zero_p (e) || nonzero_p (e))
|
|
|
|
return e;
|
|
|
|
|
|
|
|
e = simplify_replace_tree (expr, e1, e0);
|
|
|
|
if (zero_p (e) || nonzero_p (e))
|
|
|
|
return e;
|
|
|
|
}
|
|
|
|
if (TREE_CODE (expr) == EQ_EXPR)
|
|
|
|
{
|
|
|
|
e0 = TREE_OPERAND (expr, 0);
|
|
|
|
e1 = TREE_OPERAND (expr, 1);
|
|
|
|
|
|
|
|
/* If e0 == e1 (EXPR) implies !COND, then EXPR cannot be true. */
|
|
|
|
e = simplify_replace_tree (cond, e0, e1);
|
|
|
|
if (zero_p (e))
|
|
|
|
return e;
|
|
|
|
e = simplify_replace_tree (cond, e1, e0);
|
|
|
|
if (zero_p (e))
|
|
|
|
return e;
|
|
|
|
}
|
|
|
|
if (TREE_CODE (expr) == NE_EXPR)
|
|
|
|
{
|
|
|
|
e0 = TREE_OPERAND (expr, 0);
|
|
|
|
e1 = TREE_OPERAND (expr, 1);
|
|
|
|
|
|
|
|
/* If e0 == e1 (!EXPR) implies !COND, then EXPR must be true. */
|
|
|
|
e = simplify_replace_tree (cond, e0, e1);
|
|
|
|
if (zero_p (e))
|
|
|
|
return boolean_true_node;
|
|
|
|
e = simplify_replace_tree (cond, e1, e0);
|
|
|
|
if (zero_p (e))
|
|
|
|
return boolean_true_node;
|
|
|
|
}
|
|
|
|
|
2004-07-09 05:19:14 +02:00
|
|
|
/* Check whether COND ==> EXPR. */
|
|
|
|
notcond = invert_truthvalue (cond);
|
2005-04-06 01:52:41 +02:00
|
|
|
e = fold_build2 (TRUTH_OR_EXPR, boolean_type_node,
|
|
|
|
notcond, expr);
|
tree-chrec.c (chrec_fold_plus_poly_poly, [...]): Use fold_convert or build_int_cst_type instead od fonvert.
* tree-chrec.c (chrec_fold_plus_poly_poly, chrec_fold_plus_1,
chrec_fold_multiply): Use fold_convert or build_int_cst_type instead
od fonvert.
* tree-scalar-evolution.c (compute_overall_effect_of_inner_loop,
add_to_evolution, set_nb_iterations_in_loop, follow_ssa_edge_in_rhs,
follow_ssa_edge_in_rhs): Ditto.
* tree-ssa-loop-ivopts.c (struct iv): Add base_object field.
(dump_iv): Dump base_object.
(dump_use, dump_cand): Use dump_iv.
(determine_base_object): New function.
(alloc_iv): Initialize base_object field.
(record_use): Clear the ssa_name field of iv.
(get_computation_cost_at): Do not use difference of addresses of
two different objects.
(may_eliminate_iv): Do not require the loop to have just single exit.
* tree-ssa-loop-niter.c (zero_p): Do not check for overflows.
(nonzero_p): New function.
(inverse, number_of_iterations_cond, simplify_using_outer_evolutions,
tree_simplify_using_condition, simplify_using_initial_conditions,
loop_niter_by_eval, find_loop_niter_by_eval,
estimate_numbers_of_iterations_loop, compare_trees,
upper_bound_in_type, lower_bound_in_type,
can_count_iv_in_wider_type_bound): Use buildN instead of build. Use
fold_convert or build_int_cst_type instead of convert. Use (non)zero_p
instead of integer_(non)zerop.
From-SVN: r88388
2004-10-01 11:06:06 +02:00
|
|
|
if (nonzero_p (e))
|
2004-07-09 05:19:14 +02:00
|
|
|
return e;
|
|
|
|
|
|
|
|
/* Check whether COND ==> not EXPR. */
|
2005-04-06 01:52:41 +02:00
|
|
|
e = fold_build2 (TRUTH_AND_EXPR, boolean_type_node,
|
|
|
|
cond, expr);
|
tree-chrec.c (chrec_fold_plus_poly_poly, [...]): Use fold_convert or build_int_cst_type instead od fonvert.
* tree-chrec.c (chrec_fold_plus_poly_poly, chrec_fold_plus_1,
chrec_fold_multiply): Use fold_convert or build_int_cst_type instead
od fonvert.
* tree-scalar-evolution.c (compute_overall_effect_of_inner_loop,
add_to_evolution, set_nb_iterations_in_loop, follow_ssa_edge_in_rhs,
follow_ssa_edge_in_rhs): Ditto.
* tree-ssa-loop-ivopts.c (struct iv): Add base_object field.
(dump_iv): Dump base_object.
(dump_use, dump_cand): Use dump_iv.
(determine_base_object): New function.
(alloc_iv): Initialize base_object field.
(record_use): Clear the ssa_name field of iv.
(get_computation_cost_at): Do not use difference of addresses of
two different objects.
(may_eliminate_iv): Do not require the loop to have just single exit.
* tree-ssa-loop-niter.c (zero_p): Do not check for overflows.
(nonzero_p): New function.
(inverse, number_of_iterations_cond, simplify_using_outer_evolutions,
tree_simplify_using_condition, simplify_using_initial_conditions,
loop_niter_by_eval, find_loop_niter_by_eval,
estimate_numbers_of_iterations_loop, compare_trees,
upper_bound_in_type, lower_bound_in_type,
can_count_iv_in_wider_type_bound): Use buildN instead of build. Use
fold_convert or build_int_cst_type instead of convert. Use (non)zero_p
instead of integer_(non)zerop.
From-SVN: r88388
2004-10-01 11:06:06 +02:00
|
|
|
if (zero_p (e))
|
2004-07-09 05:19:14 +02:00
|
|
|
return e;
|
|
|
|
|
|
|
|
return expr;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Tries to simplify EXPR using the conditions on entry to LOOP.
|
|
|
|
Record the conditions used for simplification to CONDS_USED.
|
|
|
|
Returns the simplified expression (or EXPR unchanged, if no
|
|
|
|
simplification was possible).*/
|
|
|
|
|
|
|
|
static tree
|
|
|
|
simplify_using_initial_conditions (struct loop *loop, tree expr,
|
|
|
|
tree *conds_used)
|
|
|
|
{
|
|
|
|
edge e;
|
|
|
|
basic_block bb;
|
|
|
|
tree exp, cond;
|
|
|
|
|
|
|
|
if (TREE_CODE (expr) == INTEGER_CST)
|
|
|
|
return expr;
|
|
|
|
|
|
|
|
for (bb = loop->header;
|
|
|
|
bb != ENTRY_BLOCK_PTR;
|
|
|
|
bb = get_immediate_dominator (CDI_DOMINATORS, bb))
|
|
|
|
{
|
basic-block.h (single_succ_p, [...]): New inline functions.
* basic-block.h (single_succ_p, single_pred_p, single_succ_edge,
single_pred_edge, single_succ, single_pred): New inline functions.
* bb-reorder.c (rotate_loop, find_traces_1_round,
add_labels_and_missing_jumps, fix_up_fall_thru_edges,
duplicate_computed_gotos): Use the single_succ/pred functions.
* cfganal.c (forwarder_block_p): Ditto.
* cfgbuild.c (compute_outgoing_frequencies): Ditto.
* cfgcleanup.c (try_simplify_condjump, try_forward_edges,
outgoing_edges_match, try_crossjump_to_edge, try_optimize_cfg,
merge_seq_blocks): Ditto.
* cfghooks.c (split_edge, tidy_fallthru_edges): Ditto.
* cfglayout.c (fixup_reorder_chain): Ditto.
* cfgloop.c (mark_single_exit_loops, update_latch_info,
canonicalize_loop_headers, verify_loop_structure): Ditto.
* cfgloopmanip.c (remove_path, unloop, loop_delete_branch_edge,
mfb_update_loops, create_preheader, force_single_succ_latches,
create_loop_notes): Ditto.
* cfgrtl.c (rtl_can_merge_blocks, try_redirect_by_replacing_jump,
force_nonfallthru_and_redirect, rtl_tidy_fallthru_edge,
commit_one_edge_insertion, purge_dead_edges,
cfg_layout_can_merge_blocks_p): Ditto.
* except.c (sjlj_emit_function_enter): Ditto.
* flow.c (init_propagate_block_info): Ditto.
* function.c (thread_prologue_and_epilogue_insns): Ditto.
* gcse.c (find_implicit_sets, bypass_conditional_jumps,
insert_insn_end_bb): Ditto.
* ifcvt.c (merge_if_block, find_if_block, find_if_case_1,
find_if_case_2): Ditto.
* lambda-code.c (perfect_nestify): Ditto.
* lcm.c (optimize_mode_switching): Ditto.
* loop-doloop.c (doloop_modify): Ditto.
* loop-init.c (loop_optimizer_init): Ditto.
* loop-iv.c (simplify_using_initial_values): Ditto.
* loop-unroll.c (unroll_loop_runtime_iterations): Ditto.
* loop-unswitch.c (unswitch_loop): Ditto.
* modulo-sched.c (generate_prolog_epilog): Ditto.
* predict.c (combine_predictions_for_insn, estimate_probability,
tree_estimate_probability, last_basic_block_p,
estimate_bb_frequencies): Ditto.
* profile.c (branch_prob): Ditto.
* regrename.c (copyprop_hardreg_forward): Ditto.
* sched-rgn.c (is_cfg_nonregular, find_rgns, update_live): Ditto.
* tracer.c (layout_superblocks): Ditto.
* tree-cfg.c (tree_can_merge_blocks_p, tree_merge_blocks,
cfg_remove_useless_stmts_bb, cleanup_control_flow,
cleanup_control_expr_graph, disband_implicit_edges,
tree_find_edge_insert_loc, bsi_commit_edge_inserts,
tree_verify_flow_info, tree_make_forwarder_block,
tree_forwarder_block_p, remove_forwarder_block,
remove_forwarder_block_with_phi, merge_phi_nodes): Ditto.
* tree-if-conv.c (tree_if_conversion): Ditto.
* tree-mudflap.c (mf_build_check_statement_for): Ditto.
* tree-ssa-dce.c (remove_dead_stmt): Ditto.
* tree-ssa-dom.c (dom_opt_finalize_block): Ditto.
* tree-ssa-loop-ch.c (should_duplicate_loop_header_p,
copy_loop_headers): Ditto.
* tree-ssa-loop-im.c (loop_commit_inserts): Ditto.
* tree-ssa-loop-ivopts.c (compute_phi_arg_on_exit): Ditto.
* tree-ssa-loop-manip.c (split_loop_exit_edge, ip_normal_pos,
lv_adjust_loop_entry_edge, tree_ssa_loop_version): Ditto.
* tree-ssa-loop-niter.c (simplify_using_initial_conditions): Ditto.
* tree-ssa-loop-unswitch.c (simplify_using_entry_checks): Ditto.
* tree-ssa-phiopt.c (tree_ssa_phiopt, value_replacement): Ditto.
* tree-ssa-pre.c (compute_antic_aux, insert_aux, init_pre): Ditto.
* tree-ssa-threadupdate.c (redirect_edges): Ditto.
* tree-tailcall.c (independent_of_stmt_p, find_tail_calls,
eliminate_tail_call, tree_optimize_tail_calls_1): Ditto.
* tree-vect-analyze.c (vect_analyze_loop_form): Ditto.
* tree-vect-transform.c (vect_update_ivs_after_vectorizer): Ditto.
* tree-vectorizer.c (slpeel_update_phi_nodes_for_guard,
slpeel_add_loop_guard): Ditto.
From-SVN: r96292
2005-03-11 10:05:12 +01:00
|
|
|
if (!single_pred_p (bb))
|
2004-07-09 05:19:14 +02:00
|
|
|
continue;
|
basic-block.h (single_succ_p, [...]): New inline functions.
* basic-block.h (single_succ_p, single_pred_p, single_succ_edge,
single_pred_edge, single_succ, single_pred): New inline functions.
* bb-reorder.c (rotate_loop, find_traces_1_round,
add_labels_and_missing_jumps, fix_up_fall_thru_edges,
duplicate_computed_gotos): Use the single_succ/pred functions.
* cfganal.c (forwarder_block_p): Ditto.
* cfgbuild.c (compute_outgoing_frequencies): Ditto.
* cfgcleanup.c (try_simplify_condjump, try_forward_edges,
outgoing_edges_match, try_crossjump_to_edge, try_optimize_cfg,
merge_seq_blocks): Ditto.
* cfghooks.c (split_edge, tidy_fallthru_edges): Ditto.
* cfglayout.c (fixup_reorder_chain): Ditto.
* cfgloop.c (mark_single_exit_loops, update_latch_info,
canonicalize_loop_headers, verify_loop_structure): Ditto.
* cfgloopmanip.c (remove_path, unloop, loop_delete_branch_edge,
mfb_update_loops, create_preheader, force_single_succ_latches,
create_loop_notes): Ditto.
* cfgrtl.c (rtl_can_merge_blocks, try_redirect_by_replacing_jump,
force_nonfallthru_and_redirect, rtl_tidy_fallthru_edge,
commit_one_edge_insertion, purge_dead_edges,
cfg_layout_can_merge_blocks_p): Ditto.
* except.c (sjlj_emit_function_enter): Ditto.
* flow.c (init_propagate_block_info): Ditto.
* function.c (thread_prologue_and_epilogue_insns): Ditto.
* gcse.c (find_implicit_sets, bypass_conditional_jumps,
insert_insn_end_bb): Ditto.
* ifcvt.c (merge_if_block, find_if_block, find_if_case_1,
find_if_case_2): Ditto.
* lambda-code.c (perfect_nestify): Ditto.
* lcm.c (optimize_mode_switching): Ditto.
* loop-doloop.c (doloop_modify): Ditto.
* loop-init.c (loop_optimizer_init): Ditto.
* loop-iv.c (simplify_using_initial_values): Ditto.
* loop-unroll.c (unroll_loop_runtime_iterations): Ditto.
* loop-unswitch.c (unswitch_loop): Ditto.
* modulo-sched.c (generate_prolog_epilog): Ditto.
* predict.c (combine_predictions_for_insn, estimate_probability,
tree_estimate_probability, last_basic_block_p,
estimate_bb_frequencies): Ditto.
* profile.c (branch_prob): Ditto.
* regrename.c (copyprop_hardreg_forward): Ditto.
* sched-rgn.c (is_cfg_nonregular, find_rgns, update_live): Ditto.
* tracer.c (layout_superblocks): Ditto.
* tree-cfg.c (tree_can_merge_blocks_p, tree_merge_blocks,
cfg_remove_useless_stmts_bb, cleanup_control_flow,
cleanup_control_expr_graph, disband_implicit_edges,
tree_find_edge_insert_loc, bsi_commit_edge_inserts,
tree_verify_flow_info, tree_make_forwarder_block,
tree_forwarder_block_p, remove_forwarder_block,
remove_forwarder_block_with_phi, merge_phi_nodes): Ditto.
* tree-if-conv.c (tree_if_conversion): Ditto.
* tree-mudflap.c (mf_build_check_statement_for): Ditto.
* tree-ssa-dce.c (remove_dead_stmt): Ditto.
* tree-ssa-dom.c (dom_opt_finalize_block): Ditto.
* tree-ssa-loop-ch.c (should_duplicate_loop_header_p,
copy_loop_headers): Ditto.
* tree-ssa-loop-im.c (loop_commit_inserts): Ditto.
* tree-ssa-loop-ivopts.c (compute_phi_arg_on_exit): Ditto.
* tree-ssa-loop-manip.c (split_loop_exit_edge, ip_normal_pos,
lv_adjust_loop_entry_edge, tree_ssa_loop_version): Ditto.
* tree-ssa-loop-niter.c (simplify_using_initial_conditions): Ditto.
* tree-ssa-loop-unswitch.c (simplify_using_entry_checks): Ditto.
* tree-ssa-phiopt.c (tree_ssa_phiopt, value_replacement): Ditto.
* tree-ssa-pre.c (compute_antic_aux, insert_aux, init_pre): Ditto.
* tree-ssa-threadupdate.c (redirect_edges): Ditto.
* tree-tailcall.c (independent_of_stmt_p, find_tail_calls,
eliminate_tail_call, tree_optimize_tail_calls_1): Ditto.
* tree-vect-analyze.c (vect_analyze_loop_form): Ditto.
* tree-vect-transform.c (vect_update_ivs_after_vectorizer): Ditto.
* tree-vectorizer.c (slpeel_update_phi_nodes_for_guard,
slpeel_add_loop_guard): Ditto.
From-SVN: r96292
2005-03-11 10:05:12 +01:00
|
|
|
e = single_pred_edge (bb);
|
2004-07-09 05:19:14 +02:00
|
|
|
|
|
|
|
if (!(e->flags & (EDGE_TRUE_VALUE | EDGE_FALSE_VALUE)))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
cond = COND_EXPR_COND (last_stmt (e->src));
|
|
|
|
if (e->flags & EDGE_FALSE_VALUE)
|
|
|
|
cond = invert_truthvalue (cond);
|
|
|
|
exp = tree_simplify_using_condition (cond, expr);
|
|
|
|
|
|
|
|
if (exp != expr)
|
2005-04-06 01:52:41 +02:00
|
|
|
*conds_used = fold_build2 (TRUTH_AND_EXPR,
|
2004-07-09 05:19:14 +02:00
|
|
|
boolean_type_node,
|
|
|
|
*conds_used,
|
2005-04-06 01:52:41 +02:00
|
|
|
cond);
|
2004-07-09 05:19:14 +02:00
|
|
|
|
|
|
|
expr = exp;
|
|
|
|
}
|
|
|
|
|
|
|
|
return expr;
|
|
|
|
}
|
|
|
|
|
2005-04-06 01:52:41 +02:00
|
|
|
/* Tries to simplify EXPR using the evolutions of the loop invariants
|
|
|
|
in the superloops of LOOP. Returns the simplified expression
|
|
|
|
(or EXPR unchanged, if no simplification was possible). */
|
|
|
|
|
|
|
|
static tree
|
|
|
|
simplify_using_outer_evolutions (struct loop *loop, tree expr)
|
|
|
|
{
|
|
|
|
enum tree_code code = TREE_CODE (expr);
|
|
|
|
bool changed;
|
|
|
|
tree e, e0, e1, e2;
|
|
|
|
|
|
|
|
if (is_gimple_min_invariant (expr))
|
|
|
|
return expr;
|
|
|
|
|
|
|
|
if (code == TRUTH_OR_EXPR
|
|
|
|
|| code == TRUTH_AND_EXPR
|
|
|
|
|| code == COND_EXPR)
|
|
|
|
{
|
|
|
|
changed = false;
|
|
|
|
|
|
|
|
e0 = simplify_using_outer_evolutions (loop, TREE_OPERAND (expr, 0));
|
|
|
|
if (TREE_OPERAND (expr, 0) != e0)
|
|
|
|
changed = true;
|
|
|
|
|
|
|
|
e1 = simplify_using_outer_evolutions (loop, TREE_OPERAND (expr, 1));
|
|
|
|
if (TREE_OPERAND (expr, 1) != e1)
|
|
|
|
changed = true;
|
|
|
|
|
|
|
|
if (code == COND_EXPR)
|
|
|
|
{
|
|
|
|
e2 = simplify_using_outer_evolutions (loop, TREE_OPERAND (expr, 2));
|
|
|
|
if (TREE_OPERAND (expr, 2) != e2)
|
|
|
|
changed = true;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
e2 = NULL_TREE;
|
|
|
|
|
|
|
|
if (changed)
|
|
|
|
{
|
|
|
|
if (code == COND_EXPR)
|
|
|
|
expr = fold_build3 (code, boolean_type_node, e0, e1, e2);
|
|
|
|
else
|
|
|
|
expr = fold_build2 (code, boolean_type_node, e0, e1);
|
|
|
|
}
|
|
|
|
|
|
|
|
return expr;
|
|
|
|
}
|
|
|
|
|
|
|
|
e = instantiate_parameters (loop, expr);
|
|
|
|
if (is_gimple_min_invariant (e))
|
|
|
|
return e;
|
|
|
|
|
|
|
|
return expr;
|
|
|
|
}
|
|
|
|
|
2004-07-09 05:19:14 +02:00
|
|
|
/* Stores description of number of iterations of LOOP derived from
|
|
|
|
EXIT (an exit edge of the LOOP) in NITER. Returns true if some
|
|
|
|
useful information could be derived (and fields of NITER has
|
|
|
|
meaning described in comments at struct tree_niter_desc
|
|
|
|
declaration), false otherwise. */
|
|
|
|
|
|
|
|
bool
|
|
|
|
number_of_iterations_exit (struct loop *loop, edge exit,
|
|
|
|
struct tree_niter_desc *niter)
|
|
|
|
{
|
|
|
|
tree stmt, cond, type;
|
|
|
|
tree op0, base0, step0;
|
|
|
|
tree op1, base1, step1;
|
|
|
|
enum tree_code code;
|
|
|
|
|
|
|
|
if (!dominated_by_p (CDI_DOMINATORS, loop->latch, exit->src))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
niter->assumptions = boolean_false_node;
|
|
|
|
stmt = last_stmt (exit->src);
|
|
|
|
if (!stmt || TREE_CODE (stmt) != COND_EXPR)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/* We want the condition for staying inside loop. */
|
|
|
|
cond = COND_EXPR_COND (stmt);
|
|
|
|
if (exit->flags & EDGE_TRUE_VALUE)
|
|
|
|
cond = invert_truthvalue (cond);
|
|
|
|
|
|
|
|
code = TREE_CODE (cond);
|
|
|
|
switch (code)
|
|
|
|
{
|
|
|
|
case GT_EXPR:
|
|
|
|
case GE_EXPR:
|
|
|
|
case NE_EXPR:
|
|
|
|
case LT_EXPR:
|
|
|
|
case LE_EXPR:
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
op0 = TREE_OPERAND (cond, 0);
|
|
|
|
op1 = TREE_OPERAND (cond, 1);
|
|
|
|
type = TREE_TYPE (op0);
|
|
|
|
|
|
|
|
if (TREE_CODE (type) != INTEGER_TYPE
|
2004-08-24 22:50:42 +02:00
|
|
|
&& !POINTER_TYPE_P (type))
|
2004-07-09 05:19:14 +02:00
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!simple_iv (loop, stmt, op0, &base0, &step0))
|
|
|
|
return false;
|
|
|
|
if (!simple_iv (loop, stmt, op1, &base1, &step1))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
niter->niter = NULL_TREE;
|
|
|
|
|
2005-04-06 01:52:41 +02:00
|
|
|
/* Handle common special cases first, so that we do not need to use
|
|
|
|
generic (and slow) analysis very often. */
|
|
|
|
if (!number_of_iterations_special (type, base0, step0, code, base1, step1,
|
|
|
|
niter))
|
|
|
|
{
|
|
|
|
|
|
|
|
number_of_iterations_cond (type, base0, step0, code, base1, step1,
|
|
|
|
niter);
|
|
|
|
|
|
|
|
if (!niter->niter)
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (optimize >= 3)
|
|
|
|
{
|
|
|
|
niter->assumptions = simplify_using_outer_evolutions (loop,
|
|
|
|
niter->assumptions);
|
|
|
|
niter->may_be_zero = simplify_using_outer_evolutions (loop,
|
|
|
|
niter->may_be_zero);
|
|
|
|
niter->niter = simplify_using_outer_evolutions (loop, niter->niter);
|
|
|
|
}
|
2004-07-09 05:19:14 +02:00
|
|
|
|
|
|
|
niter->additional_info = boolean_true_node;
|
|
|
|
niter->assumptions
|
|
|
|
= simplify_using_initial_conditions (loop,
|
|
|
|
niter->assumptions,
|
|
|
|
&niter->additional_info);
|
|
|
|
niter->may_be_zero
|
|
|
|
= simplify_using_initial_conditions (loop,
|
|
|
|
niter->may_be_zero,
|
|
|
|
&niter->additional_info);
|
|
|
|
return integer_onep (niter->assumptions);
|
|
|
|
}
|
|
|
|
|
2005-02-10 01:32:47 +01:00
|
|
|
/* Try to determine the number of iterations of LOOP. If we succeed,
|
|
|
|
expression giving number of iterations is returned and *EXIT is
|
|
|
|
set to the edge from that the information is obtained. Otherwise
|
|
|
|
chrec_dont_know is returned. */
|
|
|
|
|
|
|
|
tree
|
|
|
|
find_loop_niter (struct loop *loop, edge *exit)
|
|
|
|
{
|
|
|
|
unsigned n_exits, i;
|
|
|
|
edge *exits = get_loop_exit_edges (loop, &n_exits);
|
|
|
|
edge ex;
|
|
|
|
tree niter = NULL_TREE, aniter;
|
|
|
|
struct tree_niter_desc desc;
|
|
|
|
|
|
|
|
*exit = NULL;
|
|
|
|
for (i = 0; i < n_exits; i++)
|
|
|
|
{
|
|
|
|
ex = exits[i];
|
|
|
|
if (!just_once_each_iteration_p (loop, ex->src))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!number_of_iterations_exit (loop, ex, &desc))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (nonzero_p (desc.may_be_zero))
|
|
|
|
{
|
|
|
|
/* We exit in the first iteration through this exit.
|
|
|
|
We won't find anything better. */
|
|
|
|
niter = build_int_cst_type (unsigned_type_node, 0);
|
|
|
|
*exit = ex;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!zero_p (desc.may_be_zero))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
aniter = desc.niter;
|
|
|
|
|
|
|
|
if (!niter)
|
|
|
|
{
|
|
|
|
/* Nothing recorded yet. */
|
|
|
|
niter = aniter;
|
|
|
|
*exit = ex;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Prefer constants, the lower the better. */
|
|
|
|
if (TREE_CODE (aniter) != INTEGER_CST)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (TREE_CODE (niter) != INTEGER_CST)
|
|
|
|
{
|
|
|
|
niter = aniter;
|
|
|
|
*exit = ex;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (tree_int_cst_lt (aniter, niter))
|
|
|
|
{
|
|
|
|
niter = aniter;
|
|
|
|
*exit = ex;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free (exits);
|
|
|
|
|
|
|
|
return niter ? niter : chrec_dont_know;
|
|
|
|
}
|
|
|
|
|
2004-07-09 05:19:14 +02:00
|
|
|
/*
|
|
|
|
|
|
|
|
Analysis of a number of iterations of a loop by a brute-force evaluation.
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* Bound on the number of iterations we try to evaluate. */
|
|
|
|
|
|
|
|
#define MAX_ITERATIONS_TO_TRACK \
|
|
|
|
((unsigned) PARAM_VALUE (PARAM_MAX_ITERATIONS_TO_TRACK))
|
|
|
|
|
|
|
|
/* Returns the loop phi node of LOOP such that ssa name X is derived from its
|
|
|
|
result by a chain of operations such that all but exactly one of their
|
|
|
|
operands are constants. */
|
|
|
|
|
|
|
|
static tree
|
|
|
|
chain_of_csts_start (struct loop *loop, tree x)
|
|
|
|
{
|
|
|
|
tree stmt = SSA_NAME_DEF_STMT (x);
|
|
|
|
basic_block bb = bb_for_stmt (stmt);
|
|
|
|
use_optype uses;
|
|
|
|
|
|
|
|
if (!bb
|
|
|
|
|| !flow_bb_inside_loop_p (loop, bb))
|
|
|
|
return NULL_TREE;
|
|
|
|
|
|
|
|
if (TREE_CODE (stmt) == PHI_NODE)
|
|
|
|
{
|
|
|
|
if (bb == loop->header)
|
|
|
|
return stmt;
|
|
|
|
|
|
|
|
return NULL_TREE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (TREE_CODE (stmt) != MODIFY_EXPR)
|
|
|
|
return NULL_TREE;
|
|
|
|
|
|
|
|
if (NUM_VUSES (STMT_VUSE_OPS (stmt)) > 0)
|
|
|
|
return NULL_TREE;
|
|
|
|
if (NUM_V_MAY_DEFS (STMT_V_MAY_DEF_OPS (stmt)) > 0)
|
|
|
|
return NULL_TREE;
|
|
|
|
if (NUM_V_MUST_DEFS (STMT_V_MUST_DEF_OPS (stmt)) > 0)
|
|
|
|
return NULL_TREE;
|
|
|
|
if (NUM_DEFS (STMT_DEF_OPS (stmt)) > 1)
|
|
|
|
return NULL_TREE;
|
|
|
|
uses = STMT_USE_OPS (stmt);
|
|
|
|
if (NUM_USES (uses) != 1)
|
|
|
|
return NULL_TREE;
|
|
|
|
|
|
|
|
return chain_of_csts_start (loop, USE_OP (uses, 0));
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Determines whether the expression X is derived from a result of a phi node
|
|
|
|
in header of LOOP such that
|
|
|
|
|
|
|
|
* the derivation of X consists only from operations with constants
|
|
|
|
* the initial value of the phi node is constant
|
|
|
|
* the value of the phi node in the next iteration can be derived from the
|
|
|
|
value in the current iteration by a chain of operations with constants.
|
|
|
|
|
|
|
|
If such phi node exists, it is returned. If X is a constant, X is returned
|
|
|
|
unchanged. Otherwise NULL_TREE is returned. */
|
|
|
|
|
|
|
|
static tree
|
|
|
|
get_base_for (struct loop *loop, tree x)
|
|
|
|
{
|
|
|
|
tree phi, init, next;
|
|
|
|
|
|
|
|
if (is_gimple_min_invariant (x))
|
|
|
|
return x;
|
|
|
|
|
|
|
|
phi = chain_of_csts_start (loop, x);
|
|
|
|
if (!phi)
|
|
|
|
return NULL_TREE;
|
|
|
|
|
|
|
|
init = PHI_ARG_DEF_FROM_EDGE (phi, loop_preheader_edge (loop));
|
|
|
|
next = PHI_ARG_DEF_FROM_EDGE (phi, loop_latch_edge (loop));
|
|
|
|
|
|
|
|
if (TREE_CODE (next) != SSA_NAME)
|
|
|
|
return NULL_TREE;
|
|
|
|
|
|
|
|
if (!is_gimple_min_invariant (init))
|
|
|
|
return NULL_TREE;
|
|
|
|
|
|
|
|
if (chain_of_csts_start (loop, next) != phi)
|
|
|
|
return NULL_TREE;
|
|
|
|
|
|
|
|
return phi;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Given an expression X, then
|
|
|
|
|
|
|
|
* if BASE is NULL_TREE, X must be a constant and we return X.
|
|
|
|
* otherwise X is a SSA name, whose value in the considered loop is derived
|
|
|
|
by a chain of operations with constant from a result of a phi node in
|
|
|
|
the header of the loop. Then we return value of X when the value of the
|
|
|
|
result of this phi node is given by the constant BASE. */
|
|
|
|
|
|
|
|
static tree
|
|
|
|
get_val_for (tree x, tree base)
|
|
|
|
{
|
|
|
|
tree stmt, nx, val;
|
|
|
|
use_optype uses;
|
|
|
|
use_operand_p op;
|
|
|
|
|
|
|
|
if (!x)
|
|
|
|
return base;
|
|
|
|
|
|
|
|
stmt = SSA_NAME_DEF_STMT (x);
|
|
|
|
if (TREE_CODE (stmt) == PHI_NODE)
|
|
|
|
return base;
|
|
|
|
|
|
|
|
uses = STMT_USE_OPS (stmt);
|
|
|
|
op = USE_OP_PTR (uses, 0);
|
|
|
|
|
|
|
|
nx = USE_FROM_PTR (op);
|
|
|
|
val = get_val_for (nx, base);
|
|
|
|
SET_USE (op, val);
|
|
|
|
val = fold (TREE_OPERAND (stmt, 1));
|
|
|
|
SET_USE (op, nx);
|
|
|
|
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Tries to count the number of iterations of LOOP till it exits by EXIT
|
|
|
|
by brute force -- i.e. by determining the value of the operands of the
|
|
|
|
condition at EXIT in first few iterations of the loop (assuming that
|
|
|
|
these values are constant) and determining the first one in that the
|
|
|
|
condition is not satisfied. Returns the constant giving the number
|
|
|
|
of the iterations of LOOP if successful, chrec_dont_know otherwise. */
|
|
|
|
|
|
|
|
tree
|
|
|
|
loop_niter_by_eval (struct loop *loop, edge exit)
|
|
|
|
{
|
|
|
|
tree cond, cnd, acnd;
|
|
|
|
tree op[2], val[2], next[2], aval[2], phi[2];
|
|
|
|
unsigned i, j;
|
|
|
|
enum tree_code cmp;
|
|
|
|
|
|
|
|
cond = last_stmt (exit->src);
|
|
|
|
if (!cond || TREE_CODE (cond) != COND_EXPR)
|
|
|
|
return chrec_dont_know;
|
|
|
|
|
|
|
|
cnd = COND_EXPR_COND (cond);
|
|
|
|
if (exit->flags & EDGE_TRUE_VALUE)
|
|
|
|
cnd = invert_truthvalue (cnd);
|
|
|
|
|
|
|
|
cmp = TREE_CODE (cnd);
|
|
|
|
switch (cmp)
|
|
|
|
{
|
|
|
|
case EQ_EXPR:
|
|
|
|
case NE_EXPR:
|
|
|
|
case GT_EXPR:
|
|
|
|
case GE_EXPR:
|
|
|
|
case LT_EXPR:
|
|
|
|
case LE_EXPR:
|
|
|
|
for (j = 0; j < 2; j++)
|
|
|
|
op[j] = TREE_OPERAND (cnd, j);
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
return chrec_dont_know;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (j = 0; j < 2; j++)
|
|
|
|
{
|
|
|
|
phi[j] = get_base_for (loop, op[j]);
|
|
|
|
if (!phi[j])
|
|
|
|
return chrec_dont_know;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (j = 0; j < 2; j++)
|
|
|
|
{
|
|
|
|
if (TREE_CODE (phi[j]) == PHI_NODE)
|
|
|
|
{
|
|
|
|
val[j] = PHI_ARG_DEF_FROM_EDGE (phi[j], loop_preheader_edge (loop));
|
|
|
|
next[j] = PHI_ARG_DEF_FROM_EDGE (phi[j], loop_latch_edge (loop));
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
val[j] = phi[j];
|
|
|
|
next[j] = NULL_TREE;
|
|
|
|
op[j] = NULL_TREE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < MAX_ITERATIONS_TO_TRACK; i++)
|
|
|
|
{
|
|
|
|
for (j = 0; j < 2; j++)
|
|
|
|
aval[j] = get_val_for (op[j], val[j]);
|
|
|
|
|
2005-04-06 01:52:41 +02:00
|
|
|
acnd = fold_build2 (cmp, boolean_type_node, aval[0], aval[1]);
|
tree-chrec.c (chrec_fold_plus_poly_poly, [...]): Use fold_convert or build_int_cst_type instead od fonvert.
* tree-chrec.c (chrec_fold_plus_poly_poly, chrec_fold_plus_1,
chrec_fold_multiply): Use fold_convert or build_int_cst_type instead
od fonvert.
* tree-scalar-evolution.c (compute_overall_effect_of_inner_loop,
add_to_evolution, set_nb_iterations_in_loop, follow_ssa_edge_in_rhs,
follow_ssa_edge_in_rhs): Ditto.
* tree-ssa-loop-ivopts.c (struct iv): Add base_object field.
(dump_iv): Dump base_object.
(dump_use, dump_cand): Use dump_iv.
(determine_base_object): New function.
(alloc_iv): Initialize base_object field.
(record_use): Clear the ssa_name field of iv.
(get_computation_cost_at): Do not use difference of addresses of
two different objects.
(may_eliminate_iv): Do not require the loop to have just single exit.
* tree-ssa-loop-niter.c (zero_p): Do not check for overflows.
(nonzero_p): New function.
(inverse, number_of_iterations_cond, simplify_using_outer_evolutions,
tree_simplify_using_condition, simplify_using_initial_conditions,
loop_niter_by_eval, find_loop_niter_by_eval,
estimate_numbers_of_iterations_loop, compare_trees,
upper_bound_in_type, lower_bound_in_type,
can_count_iv_in_wider_type_bound): Use buildN instead of build. Use
fold_convert or build_int_cst_type instead of convert. Use (non)zero_p
instead of integer_(non)zerop.
From-SVN: r88388
2004-10-01 11:06:06 +02:00
|
|
|
if (zero_p (acnd))
|
2004-07-09 05:19:14 +02:00
|
|
|
{
|
|
|
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
|
|
|
fprintf (dump_file,
|
|
|
|
"Proved that loop %d iterates %d times using brute force.\n",
|
|
|
|
loop->num, i);
|
tree.h (build_int_cst): New, sign extended constant.
* tree.h (build_int_cst): New, sign extended constant.
(build_int_cstu): New, zero extended constant.
(build_int_cst_wide): Renamed from build_int_cst.
* tree.c (build_int_cst, build_int_cstu): New.
(build_int_cst_wide): Renamed from build_int_cst.
(make_vector_type, build_common_tree_nodes,
build_common_tree_nodes_2): Adjust build_int_cst calls.
* builtins.c (expand_builtin_prefetch, expand_builtin_strstr,
expand_builtin_strpbrk, expand_builtin_fputs,
build_string_literal, expand_builtin_printf,
expand_builtin_sprintf, fold_builtin_classify_type,
fold_builtin_lround, fold_builtin_bitop, fold_builtin_isascii,
fold_builtin_toascii, fold_builtin_isdigit,
simplify_builtin_strstr, simplify_builtin_strpbrk,
fold_builtin_fputs, simplify_builtin_sprintf): Likewise.
* c-common.c (start_fname_decls, fix_string_type, shorten_compare,
DEF_ATTR_INT): Likewise.
* c-decl.c (complete_array_type, check_bitfield_type_and_width):
Likewise.
* c-lex.c (interpret_integer, lex_charconst): Likewise.
* c-parse.in (primary) <TYPES_COMPATIBLE_P> Likewise.
* c-pretty-print.c (pp_c_integer_constant): Likewise.
* c-typeck.c (really_start_incremental_init, push_init_level,
set_nonincremental_init_from_string): Likewise.
* calls.c (load_register_parameters): Likewise.
convert.c (convert_to_pointer): Likewise.
coverage.c (coverage_counter_alloc, tree_coverage_counter_ref,
build_fn_info_type, build_fn_info_value, build_ctr_info_value,
build_gcov_info): Likewise.
* except.c (init_eh, assign_filter_values): Likewise.
* expmed.c (store_fixed_bit_field, extract_bit_field,
extract_fixed_bit_field, extract_split_bit_field, expand_shift,
expand_mult_const, expand_mult_highpart_adjust, extract_high_half,
expand_sdiv_pow2, expand_divmod, make_tree): Likewise.
* expr.c (convert_move, emit_group_load, emit_group_store,
expand_assignment, store_constructor, store_field,
expand_expr_real_1, reduce_to_bit_field_precision): Likewise.
fold-const.c (force_fit_type, int_const_binop, fold_convert_const,
invert_truthvalue, optimize_bit_field_compare,
decode_field_reference, all_ones_mask_p, constant_boolean_node,
fold_div_compare, fold, fold_read_from_constant_string,
fold_negate_const, fold_abs_const, fold_not_const, round_up,
round_down): Likewise.
* function.c (assign_parm_setup_block): Likewise.
* stmt.c (shift_return_value, expand_case, estimate_case_costs):
Likewise.
* stor-layout.c (layout_type, initialize_sizetypes,
set_min_and_max_values_for_integral_type): Likewise.
* tree-chrec.c (chrec_fold_multiply_poly_poly,
reset_evolution_in_loop): Likewise.
* tree-chrec.h (build_polynomial_chrec): Likewise.
* tree-complex.c (build_replicated_const): Likewise.
* tree-eh.c (honor_protect_cleanup_actions,
lower_try_finally_onedest, lower_try_finally_copy,
lower_try_finally_switch): Likewise.
* tree-mudflap.c (mf_build_string, mx_register_decls,
mudflap_register_call, mudflap_enqueue_constant): Likewise.
* tree-nested.c (get_trampoline_type, get_nl_goto_field): Likewise.
* tree-pretty-print.c (dump_generic_node): Likewise.
* tree-ssa-ccp.c (widen_bitfield, maybe_fold_offset_to_array_ref):
Likewise.
* tree-ssa-dom.c (simplify_rhs_and_lookup_avail_expr): Likewise.
* tree-ssa-loop-niter.c (number_of_iterations_cond,
loop_niter_by_eval, upper_bound_in_type, lower_bound_in_type):
Likewise.
* tree-ssa-loop-ivcanon.c (create_canonical_iv,
canonicalize_loop_induction_variables): Likewise.
* tree-vectorizer.c (vect_create_index_for_array_ref,
vect_transform_loop_bound, vect_compute_data_ref_alignment):
Likewise.
* config/alpha/alpha.c (alpha_initialize_trampoline, alpha_va_start,
alpha_gimplify_va_arg_1): Likewise.
* config/arm/arm.c (arm_get_cookie_size): Likewise.
* config/c4x/c4x.c (c4x_gimplify_va_arg_expr): Likewise.
* config/i386/i386.c (ix86_va_start, ix86_gimplify_va_arg): Likewise.
* config/ia64/ia64.c (ia64_gimplify_va_arg): Likewise.
* config/mips/mips.c (mips_build_builtin_va_list, mips_va_start,
mips_gimplify_va_arg_expr): Likewise.
* config/pa/pa.c (hppa_gimplify_va_arg_expr): Likewise.
* config/rs6000/rs6000.c (rs6000_va_start, rs6000_gimplify_va_arg,
add_compiler_branch_island): Likewise.
* config/s390/s390.c (s390_va_start): Likewise.
* config/sh/sh.c (sh_va_start): Likewise.
* config/stormy16/stormy16.c (xstormy16_expand_builtin_va_start):
Likewise.
* config/xtensa/xtensa.c (xtensa_va_start,
xtensa_gimplify_va_arg_expr): Likewise.
* objc/objc-act.c (build_objc_string_object,
build_objc_symtab_template, init_def_list, init_objc_symtab,
init_module_descriptor, generate_static_references,
build_selector_translation_table, get_proto_encoding,
build_typed_selector_reference, build_selector_reference,
build_next_objc_exception_stuff,
build_method_prototype_list_template, generate_descriptor_table,
generate_protocols, build_protocol_initializer,
build_ivar_list_template, build_method_list_template,
build_ivar_list_initializer, generate_ivars_list,
generate_dispatch_table, generate_protocol_list,
build_category_initializer, build_shared_structure_initializer,
generate_shared_structures, handle_impent,
generate_objc_image_info): Likewise.
2004-04-25 Paolo Bonzini <bonzini@gnu.org>
* cfglayout.c (duplicate_insn_chain): Remove references to
NOTE_INSN_LOOP_VTOP and NOTE_INSN_LOOP_CONT.
* cfgloop.h (struct loop): Remove fields vtop, cont and cont_dominator.
* cfgrtl.c (rtl_delete_block): Remove handling of NOTE_INSN_LOOP_CONT.
* final.c (final_scan_insn): Remove references to NOTE_INSN_LOOP_VTOP
and NOTE_INSN_LOOP_CONT.
* insn-notes.def (NOTE_INSN_LOOP_VTOP, NOTE_INSN_LOOP_CONT): Remove.
* jump.c (squeeze_notes): Remove references to NOTE_INSN_LOOP_VTOP
and NOTE_INSN_LOOP_CONT.
* loop.c (scan_loops, find_and_verify_loops, for_each_insn_in_loop,
check_dbra_loop, loop_dump_aux): Remove references to removed notes
and fields.
* reorg.c (mostly_true_jump): Do not rely on NOTE_INSN_LOOP_VTOPs.
* unroll.c (unroll_loop, copy_loop_body, loop_iterations): Remove
references to removed notes and fields.
(subtract_reg_term, ujump_to_loop_cont): Remove.
From-SVN: r86544
2004-08-25 11:52:54 +02:00
|
|
|
return build_int_cst (unsigned_type_node, i);
|
2004-07-09 05:19:14 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
for (j = 0; j < 2; j++)
|
|
|
|
val[j] = get_val_for (next[j], val[j]);
|
|
|
|
}
|
|
|
|
|
|
|
|
return chrec_dont_know;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Finds the exit of the LOOP by that the loop exits after a constant
|
|
|
|
number of iterations and stores the exit edge to *EXIT. The constant
|
|
|
|
giving the number of iterations of LOOP is returned. The number of
|
|
|
|
iterations is determined using loop_niter_by_eval (i.e. by brute force
|
|
|
|
evaluation). If we are unable to find the exit for that loop_niter_by_eval
|
|
|
|
determines the number of iterations, chrec_dont_know is returned. */
|
|
|
|
|
|
|
|
tree
|
|
|
|
find_loop_niter_by_eval (struct loop *loop, edge *exit)
|
|
|
|
{
|
|
|
|
unsigned n_exits, i;
|
|
|
|
edge *exits = get_loop_exit_edges (loop, &n_exits);
|
|
|
|
edge ex;
|
|
|
|
tree niter = NULL_TREE, aniter;
|
|
|
|
|
|
|
|
*exit = NULL;
|
|
|
|
for (i = 0; i < n_exits; i++)
|
|
|
|
{
|
|
|
|
ex = exits[i];
|
|
|
|
if (!just_once_each_iteration_p (loop, ex->src))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
aniter = loop_niter_by_eval (loop, ex);
|
2005-02-10 01:32:47 +01:00
|
|
|
if (chrec_contains_undetermined (aniter))
|
2004-07-09 05:19:14 +02:00
|
|
|
continue;
|
|
|
|
|
|
|
|
if (niter
|
2005-02-10 01:32:47 +01:00
|
|
|
&& !tree_int_cst_lt (aniter, niter))
|
2004-07-09 05:19:14 +02:00
|
|
|
continue;
|
|
|
|
|
|
|
|
niter = aniter;
|
|
|
|
*exit = ex;
|
|
|
|
}
|
|
|
|
free (exits);
|
|
|
|
|
|
|
|
return niter ? niter : chrec_dont_know;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
|
|
|
Analysis of upper bounds on number of iterations of a loop.
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* Records that AT_STMT is executed at most BOUND times in LOOP. The
|
|
|
|
additional condition ADDITIONAL is recorded with the bound. */
|
|
|
|
|
Makefile.in (tree-ssa-loop-niter.o): Depends on tree-data-ref.h.
2004-10-11 Sebastian Pop <pop@cri.ensmp.fr>
* Makefile.in (tree-ssa-loop-niter.o): Depends on tree-data-ref.h.
* cfgloop.c (initialize_loops_parallel_p): New.
(flow_loops_find): Initialize the parallel_p field to true for all
the loops.
* tree-ssa-loop-niter.c: Include "tree-data-ref.h".
(estimate_numbers_of_iterations_loop): Infers the loop bounds from
the size of the data accessed in the loop.
(struct nb_iter_bound): Moved...
* cfgloop.h (struct nb_iter_bound): ... here.
(estimated_nb_iterations, parallel_p): New fields in struct loop.
(record_estimate): Declare extern here.
* tree-chrec.c: Fix comments.
(nb_vars_in_chrec): New function.
* tree-chrec.h (nb_vars_in_chrec): Declared here.
* tree-data-ref.c: Don't include lambda.h, that is already included
in tree-data-ref.h.
(tree_fold_divides_p): Don't check for integer_onep.
(tree_fold_bezout): Removed.
(gcd): New static duplicated function.
(int_divides_p, dump_subscript): New.
(dump_data_dependence_relation): Use dump_subscript.
(dump_dist_dir_vectors, dump_ddrs, compute_estimated_nb_iterations,
estimate_niter_from_size_of_data): New.
(analyze_array_indexes, analyze_array): Call
estimate_niter_from_size_of_data during the detection of array
references. Pass in a pointer to the statement that contains the
array reference.
(all_chrecs_equal_p): New.
(compute_distance_vector): Renamed compute_subscript_distance.
Deal with multivariate conflict functions.
(initialize_data_dependence_relation): Initialize DDR_AFFINE_P,
DDR_SIZE_VECT, DDR_DIST_VECT, and DDR_DIR_VECT.
(non_affine_dependence_relation): New.
(analyze_ziv_subscript, analyze_siv_subscript_cst_affine,
analyze_siv_subscript, analyze_miv_subscript,
analyze_overlapping_iterations, subscript_dependence_tester):
Initialize and return last_conflicts function.
(initialize_matrix_A, FLOOR, compute_overlap_steps_for_affine_univar,
compute_overlap_steps_for_affine_1_2): New.
(analyze_siv_subscript_affine_cst): Removed.
(analyze_subscript_affine_affine): Disprove dependences based on the
iteration domains. Solve the univariate dependence case as before,
but use lambda_matrix_right_hermite instead of tree_fold_bezout.
Implement the multivariate case of 2 versus 1 variables.
(build_classic_dist_vector, build_classic_dir_vector): Implement some
unhandled cases.
(find_data_references_in_loop): Compute and initialize
loop->estimated_nb_iterations and loop->parallel_p.
(analyze_all_data_dependences): Modify the debug dump order.
* tree-data-ref.h (SUB_LAST_CONFLICT_IN_A, SUB_LAST_CONFLICT_IN_B,
subscript->last_conflict_in_a, subscript->last_conflict_in_b): Removed.
(SUB_LAST_CONFLICT, subscript->last_conflict,
data_dependence_relation->affine_p, data_dependence_relation->size_vect,
DDR_AFFINE_P, DDR_SIZE_VECT): New.
(find_data_references_in_loop, initialize_data_dependence_relation,
dump_subscript, dump_ddrs, dump_dist_dir_vectors): Declared here.
From-SVN: r88965
2004-10-13 05:48:03 +02:00
|
|
|
void
|
2004-07-09 05:19:14 +02:00
|
|
|
record_estimate (struct loop *loop, tree bound, tree additional, tree at_stmt)
|
|
|
|
{
|
|
|
|
struct nb_iter_bound *elt = xmalloc (sizeof (struct nb_iter_bound));
|
|
|
|
|
|
|
|
if (dump_file && (dump_flags & TDF_DETAILS))
|
|
|
|
{
|
|
|
|
fprintf (dump_file, "Statements after ");
|
|
|
|
print_generic_expr (dump_file, at_stmt, TDF_SLIM);
|
|
|
|
fprintf (dump_file, " are executed at most ");
|
|
|
|
print_generic_expr (dump_file, bound, TDF_SLIM);
|
|
|
|
fprintf (dump_file, " times in loop %d.\n", loop->num);
|
|
|
|
}
|
|
|
|
|
|
|
|
elt->bound = bound;
|
|
|
|
elt->at_stmt = at_stmt;
|
|
|
|
elt->additional = additional;
|
|
|
|
elt->next = loop->bounds;
|
|
|
|
loop->bounds = elt;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Records estimates on numbers of iterations of LOOP. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
estimate_numbers_of_iterations_loop (struct loop *loop)
|
|
|
|
{
|
|
|
|
edge *exits;
|
|
|
|
tree niter, type;
|
|
|
|
unsigned i, n_exits;
|
|
|
|
struct tree_niter_desc niter_desc;
|
|
|
|
|
|
|
|
exits = get_loop_exit_edges (loop, &n_exits);
|
|
|
|
for (i = 0; i < n_exits; i++)
|
|
|
|
{
|
|
|
|
if (!number_of_iterations_exit (loop, exits[i], &niter_desc))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
niter = niter_desc.niter;
|
|
|
|
type = TREE_TYPE (niter);
|
tree-chrec.c (chrec_fold_plus_poly_poly, [...]): Use fold_convert or build_int_cst_type instead od fonvert.
* tree-chrec.c (chrec_fold_plus_poly_poly, chrec_fold_plus_1,
chrec_fold_multiply): Use fold_convert or build_int_cst_type instead
od fonvert.
* tree-scalar-evolution.c (compute_overall_effect_of_inner_loop,
add_to_evolution, set_nb_iterations_in_loop, follow_ssa_edge_in_rhs,
follow_ssa_edge_in_rhs): Ditto.
* tree-ssa-loop-ivopts.c (struct iv): Add base_object field.
(dump_iv): Dump base_object.
(dump_use, dump_cand): Use dump_iv.
(determine_base_object): New function.
(alloc_iv): Initialize base_object field.
(record_use): Clear the ssa_name field of iv.
(get_computation_cost_at): Do not use difference of addresses of
two different objects.
(may_eliminate_iv): Do not require the loop to have just single exit.
* tree-ssa-loop-niter.c (zero_p): Do not check for overflows.
(nonzero_p): New function.
(inverse, number_of_iterations_cond, simplify_using_outer_evolutions,
tree_simplify_using_condition, simplify_using_initial_conditions,
loop_niter_by_eval, find_loop_niter_by_eval,
estimate_numbers_of_iterations_loop, compare_trees,
upper_bound_in_type, lower_bound_in_type,
can_count_iv_in_wider_type_bound): Use buildN instead of build. Use
fold_convert or build_int_cst_type instead of convert. Use (non)zero_p
instead of integer_(non)zerop.
From-SVN: r88388
2004-10-01 11:06:06 +02:00
|
|
|
if (!zero_p (niter_desc.may_be_zero)
|
|
|
|
&& !nonzero_p (niter_desc.may_be_zero))
|
|
|
|
niter = build3 (COND_EXPR, type, niter_desc.may_be_zero,
|
|
|
|
build_int_cst_type (type, 0),
|
|
|
|
niter);
|
2004-07-09 05:19:14 +02:00
|
|
|
record_estimate (loop, niter,
|
|
|
|
niter_desc.additional_info,
|
|
|
|
last_stmt (exits[i]->src));
|
|
|
|
}
|
|
|
|
free (exits);
|
|
|
|
|
Makefile.in (tree-ssa-loop-niter.o): Depends on tree-data-ref.h.
2004-10-11 Sebastian Pop <pop@cri.ensmp.fr>
* Makefile.in (tree-ssa-loop-niter.o): Depends on tree-data-ref.h.
* cfgloop.c (initialize_loops_parallel_p): New.
(flow_loops_find): Initialize the parallel_p field to true for all
the loops.
* tree-ssa-loop-niter.c: Include "tree-data-ref.h".
(estimate_numbers_of_iterations_loop): Infers the loop bounds from
the size of the data accessed in the loop.
(struct nb_iter_bound): Moved...
* cfgloop.h (struct nb_iter_bound): ... here.
(estimated_nb_iterations, parallel_p): New fields in struct loop.
(record_estimate): Declare extern here.
* tree-chrec.c: Fix comments.
(nb_vars_in_chrec): New function.
* tree-chrec.h (nb_vars_in_chrec): Declared here.
* tree-data-ref.c: Don't include lambda.h, that is already included
in tree-data-ref.h.
(tree_fold_divides_p): Don't check for integer_onep.
(tree_fold_bezout): Removed.
(gcd): New static duplicated function.
(int_divides_p, dump_subscript): New.
(dump_data_dependence_relation): Use dump_subscript.
(dump_dist_dir_vectors, dump_ddrs, compute_estimated_nb_iterations,
estimate_niter_from_size_of_data): New.
(analyze_array_indexes, analyze_array): Call
estimate_niter_from_size_of_data during the detection of array
references. Pass in a pointer to the statement that contains the
array reference.
(all_chrecs_equal_p): New.
(compute_distance_vector): Renamed compute_subscript_distance.
Deal with multivariate conflict functions.
(initialize_data_dependence_relation): Initialize DDR_AFFINE_P,
DDR_SIZE_VECT, DDR_DIST_VECT, and DDR_DIR_VECT.
(non_affine_dependence_relation): New.
(analyze_ziv_subscript, analyze_siv_subscript_cst_affine,
analyze_siv_subscript, analyze_miv_subscript,
analyze_overlapping_iterations, subscript_dependence_tester):
Initialize and return last_conflicts function.
(initialize_matrix_A, FLOOR, compute_overlap_steps_for_affine_univar,
compute_overlap_steps_for_affine_1_2): New.
(analyze_siv_subscript_affine_cst): Removed.
(analyze_subscript_affine_affine): Disprove dependences based on the
iteration domains. Solve the univariate dependence case as before,
but use lambda_matrix_right_hermite instead of tree_fold_bezout.
Implement the multivariate case of 2 versus 1 variables.
(build_classic_dist_vector, build_classic_dir_vector): Implement some
unhandled cases.
(find_data_references_in_loop): Compute and initialize
loop->estimated_nb_iterations and loop->parallel_p.
(analyze_all_data_dependences): Modify the debug dump order.
* tree-data-ref.h (SUB_LAST_CONFLICT_IN_A, SUB_LAST_CONFLICT_IN_B,
subscript->last_conflict_in_a, subscript->last_conflict_in_b): Removed.
(SUB_LAST_CONFLICT, subscript->last_conflict,
data_dependence_relation->affine_p, data_dependence_relation->size_vect,
DDR_AFFINE_P, DDR_SIZE_VECT): New.
(find_data_references_in_loop, initialize_data_dependence_relation,
dump_subscript, dump_ddrs, dump_dist_dir_vectors): Declared here.
From-SVN: r88965
2004-10-13 05:48:03 +02:00
|
|
|
/* Analyzes the bounds of arrays accessed in the loop. */
|
|
|
|
if (loop->estimated_nb_iterations == NULL_TREE)
|
|
|
|
{
|
|
|
|
varray_type datarefs;
|
|
|
|
VARRAY_GENERIC_PTR_INIT (datarefs, 3, "datarefs");
|
|
|
|
find_data_references_in_loop (loop, &datarefs);
|
|
|
|
free_data_refs (datarefs);
|
|
|
|
}
|
2004-07-09 05:19:14 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Records estimates on numbers of iterations of LOOPS. */
|
|
|
|
|
|
|
|
void
|
|
|
|
estimate_numbers_of_iterations (struct loops *loops)
|
|
|
|
{
|
|
|
|
unsigned i;
|
|
|
|
struct loop *loop;
|
|
|
|
|
|
|
|
for (i = 1; i < loops->num; i++)
|
|
|
|
{
|
|
|
|
loop = loops->parray[i];
|
|
|
|
if (loop)
|
|
|
|
estimate_numbers_of_iterations_loop (loop);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If A > B, returns -1. If A == B, returns 0. If A < B, returns 1.
|
|
|
|
If neither of these relations can be proved, returns 2. */
|
|
|
|
|
|
|
|
static int
|
|
|
|
compare_trees (tree a, tree b)
|
|
|
|
{
|
|
|
|
tree typea = TREE_TYPE (a), typeb = TREE_TYPE (b);
|
|
|
|
tree type;
|
|
|
|
|
|
|
|
if (TYPE_PRECISION (typea) > TYPE_PRECISION (typeb))
|
|
|
|
type = typea;
|
|
|
|
else
|
|
|
|
type = typeb;
|
|
|
|
|
tree-chrec.c (chrec_fold_plus_poly_poly, [...]): Use fold_convert or build_int_cst_type instead od fonvert.
* tree-chrec.c (chrec_fold_plus_poly_poly, chrec_fold_plus_1,
chrec_fold_multiply): Use fold_convert or build_int_cst_type instead
od fonvert.
* tree-scalar-evolution.c (compute_overall_effect_of_inner_loop,
add_to_evolution, set_nb_iterations_in_loop, follow_ssa_edge_in_rhs,
follow_ssa_edge_in_rhs): Ditto.
* tree-ssa-loop-ivopts.c (struct iv): Add base_object field.
(dump_iv): Dump base_object.
(dump_use, dump_cand): Use dump_iv.
(determine_base_object): New function.
(alloc_iv): Initialize base_object field.
(record_use): Clear the ssa_name field of iv.
(get_computation_cost_at): Do not use difference of addresses of
two different objects.
(may_eliminate_iv): Do not require the loop to have just single exit.
* tree-ssa-loop-niter.c (zero_p): Do not check for overflows.
(nonzero_p): New function.
(inverse, number_of_iterations_cond, simplify_using_outer_evolutions,
tree_simplify_using_condition, simplify_using_initial_conditions,
loop_niter_by_eval, find_loop_niter_by_eval,
estimate_numbers_of_iterations_loop, compare_trees,
upper_bound_in_type, lower_bound_in_type,
can_count_iv_in_wider_type_bound): Use buildN instead of build. Use
fold_convert or build_int_cst_type instead of convert. Use (non)zero_p
instead of integer_(non)zerop.
From-SVN: r88388
2004-10-01 11:06:06 +02:00
|
|
|
a = fold_convert (type, a);
|
|
|
|
b = fold_convert (type, b);
|
2004-07-09 05:19:14 +02:00
|
|
|
|
2005-04-06 01:52:41 +02:00
|
|
|
if (nonzero_p (fold_build2 (EQ_EXPR, boolean_type_node, a, b)))
|
2004-07-09 05:19:14 +02:00
|
|
|
return 0;
|
2005-04-06 01:52:41 +02:00
|
|
|
if (nonzero_p (fold_build2 (LT_EXPR, boolean_type_node, a, b)))
|
2004-07-09 05:19:14 +02:00
|
|
|
return 1;
|
2005-04-06 01:52:41 +02:00
|
|
|
if (nonzero_p (fold_build2 (GT_EXPR, boolean_type_node, a, b)))
|
2004-07-09 05:19:14 +02:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
return 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Returns true if statement S1 dominates statement S2. */
|
|
|
|
|
|
|
|
static bool
|
|
|
|
stmt_dominates_stmt_p (tree s1, tree s2)
|
|
|
|
{
|
|
|
|
basic_block bb1 = bb_for_stmt (s1), bb2 = bb_for_stmt (s2);
|
|
|
|
|
|
|
|
if (!bb1
|
|
|
|
|| s1 == s2)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if (bb1 == bb2)
|
|
|
|
{
|
|
|
|
block_stmt_iterator bsi;
|
|
|
|
|
|
|
|
for (bsi = bsi_start (bb1); bsi_stmt (bsi) != s2; bsi_next (&bsi))
|
|
|
|
if (bsi_stmt (bsi) == s1)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return dominated_by_p (CDI_DOMINATORS, bb2, bb1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Checks whether it is correct to count the induction variable BASE + STEP * I
|
|
|
|
at AT_STMT in wider TYPE, using the fact that statement OF is executed at
|
|
|
|
most BOUND times in the loop. If it is possible, return the value of step
|
|
|
|
of the induction variable in the TYPE, otherwise return NULL_TREE.
|
|
|
|
|
|
|
|
ADDITIONAL is the additional condition recorded for operands of the bound.
|
|
|
|
This is useful in the following case, created by loop header copying:
|
|
|
|
|
|
|
|
i = 0;
|
|
|
|
if (n > 0)
|
|
|
|
do
|
|
|
|
{
|
|
|
|
something;
|
|
|
|
} while (++i < n)
|
|
|
|
|
|
|
|
If the n > 0 condition is taken into account, the number of iterations of the
|
|
|
|
loop can be expressed as n - 1. If the type of n is signed, the ADDITIONAL
|
|
|
|
assumption "n > 0" says us that the value of the number of iterations is at
|
|
|
|
most MAX_TYPE - 1 (without this assumption, it might overflow). */
|
|
|
|
|
|
|
|
static tree
|
|
|
|
can_count_iv_in_wider_type_bound (tree type, tree base, tree step,
|
|
|
|
tree at_stmt,
|
|
|
|
tree bound,
|
|
|
|
tree additional,
|
|
|
|
tree of)
|
|
|
|
{
|
|
|
|
tree inner_type = TREE_TYPE (base), b, bplusstep, new_step, new_step_abs;
|
|
|
|
tree valid_niter, extreme, unsigned_type, delta, bound_type;
|
|
|
|
tree cond;
|
|
|
|
|
tree-chrec.c (chrec_fold_plus_poly_poly, [...]): Use fold_convert or build_int_cst_type instead od fonvert.
* tree-chrec.c (chrec_fold_plus_poly_poly, chrec_fold_plus_1,
chrec_fold_multiply): Use fold_convert or build_int_cst_type instead
od fonvert.
* tree-scalar-evolution.c (compute_overall_effect_of_inner_loop,
add_to_evolution, set_nb_iterations_in_loop, follow_ssa_edge_in_rhs,
follow_ssa_edge_in_rhs): Ditto.
* tree-ssa-loop-ivopts.c (struct iv): Add base_object field.
(dump_iv): Dump base_object.
(dump_use, dump_cand): Use dump_iv.
(determine_base_object): New function.
(alloc_iv): Initialize base_object field.
(record_use): Clear the ssa_name field of iv.
(get_computation_cost_at): Do not use difference of addresses of
two different objects.
(may_eliminate_iv): Do not require the loop to have just single exit.
* tree-ssa-loop-niter.c (zero_p): Do not check for overflows.
(nonzero_p): New function.
(inverse, number_of_iterations_cond, simplify_using_outer_evolutions,
tree_simplify_using_condition, simplify_using_initial_conditions,
loop_niter_by_eval, find_loop_niter_by_eval,
estimate_numbers_of_iterations_loop, compare_trees,
upper_bound_in_type, lower_bound_in_type,
can_count_iv_in_wider_type_bound): Use buildN instead of build. Use
fold_convert or build_int_cst_type instead of convert. Use (non)zero_p
instead of integer_(non)zerop.
From-SVN: r88388
2004-10-01 11:06:06 +02:00
|
|
|
b = fold_convert (type, base);
|
|
|
|
bplusstep = fold_convert (type,
|
2005-04-06 01:52:41 +02:00
|
|
|
fold_build2 (PLUS_EXPR, inner_type, base, step));
|
|
|
|
new_step = fold_build2 (MINUS_EXPR, type, bplusstep, b);
|
2004-07-09 05:19:14 +02:00
|
|
|
if (TREE_CODE (new_step) != INTEGER_CST)
|
|
|
|
return NULL_TREE;
|
|
|
|
|
|
|
|
switch (compare_trees (bplusstep, b))
|
|
|
|
{
|
|
|
|
case -1:
|
|
|
|
extreme = upper_bound_in_type (type, inner_type);
|
2005-04-06 01:52:41 +02:00
|
|
|
delta = fold_build2 (MINUS_EXPR, type, extreme, b);
|
2004-07-09 05:19:14 +02:00
|
|
|
new_step_abs = new_step;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 1:
|
|
|
|
extreme = lower_bound_in_type (type, inner_type);
|
2005-04-06 01:52:41 +02:00
|
|
|
new_step_abs = fold_build1 (NEGATE_EXPR, type, new_step);
|
|
|
|
delta = fold_build2 (MINUS_EXPR, type, b, extreme);
|
2004-07-09 05:19:14 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
case 0:
|
|
|
|
return new_step;
|
|
|
|
|
|
|
|
default:
|
|
|
|
return NULL_TREE;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned_type = unsigned_type_for (type);
|
tree-chrec.c (chrec_fold_plus_poly_poly, [...]): Use fold_convert or build_int_cst_type instead od fonvert.
* tree-chrec.c (chrec_fold_plus_poly_poly, chrec_fold_plus_1,
chrec_fold_multiply): Use fold_convert or build_int_cst_type instead
od fonvert.
* tree-scalar-evolution.c (compute_overall_effect_of_inner_loop,
add_to_evolution, set_nb_iterations_in_loop, follow_ssa_edge_in_rhs,
follow_ssa_edge_in_rhs): Ditto.
* tree-ssa-loop-ivopts.c (struct iv): Add base_object field.
(dump_iv): Dump base_object.
(dump_use, dump_cand): Use dump_iv.
(determine_base_object): New function.
(alloc_iv): Initialize base_object field.
(record_use): Clear the ssa_name field of iv.
(get_computation_cost_at): Do not use difference of addresses of
two different objects.
(may_eliminate_iv): Do not require the loop to have just single exit.
* tree-ssa-loop-niter.c (zero_p): Do not check for overflows.
(nonzero_p): New function.
(inverse, number_of_iterations_cond, simplify_using_outer_evolutions,
tree_simplify_using_condition, simplify_using_initial_conditions,
loop_niter_by_eval, find_loop_niter_by_eval,
estimate_numbers_of_iterations_loop, compare_trees,
upper_bound_in_type, lower_bound_in_type,
can_count_iv_in_wider_type_bound): Use buildN instead of build. Use
fold_convert or build_int_cst_type instead of convert. Use (non)zero_p
instead of integer_(non)zerop.
From-SVN: r88388
2004-10-01 11:06:06 +02:00
|
|
|
delta = fold_convert (unsigned_type, delta);
|
|
|
|
new_step_abs = fold_convert (unsigned_type, new_step_abs);
|
2005-04-06 01:52:41 +02:00
|
|
|
valid_niter = fold_build2 (FLOOR_DIV_EXPR, unsigned_type,
|
|
|
|
delta, new_step_abs);
|
2004-07-09 05:19:14 +02:00
|
|
|
|
|
|
|
bound_type = TREE_TYPE (bound);
|
|
|
|
if (TYPE_PRECISION (type) > TYPE_PRECISION (bound_type))
|
tree-chrec.c (chrec_fold_plus_poly_poly, [...]): Use fold_convert or build_int_cst_type instead od fonvert.
* tree-chrec.c (chrec_fold_plus_poly_poly, chrec_fold_plus_1,
chrec_fold_multiply): Use fold_convert or build_int_cst_type instead
od fonvert.
* tree-scalar-evolution.c (compute_overall_effect_of_inner_loop,
add_to_evolution, set_nb_iterations_in_loop, follow_ssa_edge_in_rhs,
follow_ssa_edge_in_rhs): Ditto.
* tree-ssa-loop-ivopts.c (struct iv): Add base_object field.
(dump_iv): Dump base_object.
(dump_use, dump_cand): Use dump_iv.
(determine_base_object): New function.
(alloc_iv): Initialize base_object field.
(record_use): Clear the ssa_name field of iv.
(get_computation_cost_at): Do not use difference of addresses of
two different objects.
(may_eliminate_iv): Do not require the loop to have just single exit.
* tree-ssa-loop-niter.c (zero_p): Do not check for overflows.
(nonzero_p): New function.
(inverse, number_of_iterations_cond, simplify_using_outer_evolutions,
tree_simplify_using_condition, simplify_using_initial_conditions,
loop_niter_by_eval, find_loop_niter_by_eval,
estimate_numbers_of_iterations_loop, compare_trees,
upper_bound_in_type, lower_bound_in_type,
can_count_iv_in_wider_type_bound): Use buildN instead of build. Use
fold_convert or build_int_cst_type instead of convert. Use (non)zero_p
instead of integer_(non)zerop.
From-SVN: r88388
2004-10-01 11:06:06 +02:00
|
|
|
bound = fold_convert (unsigned_type, bound);
|
2004-07-09 05:19:14 +02:00
|
|
|
else
|
tree-chrec.c (chrec_fold_plus_poly_poly, [...]): Use fold_convert or build_int_cst_type instead od fonvert.
* tree-chrec.c (chrec_fold_plus_poly_poly, chrec_fold_plus_1,
chrec_fold_multiply): Use fold_convert or build_int_cst_type instead
od fonvert.
* tree-scalar-evolution.c (compute_overall_effect_of_inner_loop,
add_to_evolution, set_nb_iterations_in_loop, follow_ssa_edge_in_rhs,
follow_ssa_edge_in_rhs): Ditto.
* tree-ssa-loop-ivopts.c (struct iv): Add base_object field.
(dump_iv): Dump base_object.
(dump_use, dump_cand): Use dump_iv.
(determine_base_object): New function.
(alloc_iv): Initialize base_object field.
(record_use): Clear the ssa_name field of iv.
(get_computation_cost_at): Do not use difference of addresses of
two different objects.
(may_eliminate_iv): Do not require the loop to have just single exit.
* tree-ssa-loop-niter.c (zero_p): Do not check for overflows.
(nonzero_p): New function.
(inverse, number_of_iterations_cond, simplify_using_outer_evolutions,
tree_simplify_using_condition, simplify_using_initial_conditions,
loop_niter_by_eval, find_loop_niter_by_eval,
estimate_numbers_of_iterations_loop, compare_trees,
upper_bound_in_type, lower_bound_in_type,
can_count_iv_in_wider_type_bound): Use buildN instead of build. Use
fold_convert or build_int_cst_type instead of convert. Use (non)zero_p
instead of integer_(non)zerop.
From-SVN: r88388
2004-10-01 11:06:06 +02:00
|
|
|
valid_niter = fold_convert (bound_type, valid_niter);
|
2004-07-09 05:19:14 +02:00
|
|
|
|
|
|
|
if (at_stmt && stmt_dominates_stmt_p (of, at_stmt))
|
|
|
|
{
|
|
|
|
/* After the statement OF we know that anything is executed at most
|
|
|
|
BOUND times. */
|
2005-04-06 01:52:41 +02:00
|
|
|
cond = fold_build2 (GE_EXPR, boolean_type_node, valid_niter, bound);
|
2004-07-09 05:19:14 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Before the statement OF we know that anything is executed at most
|
|
|
|
BOUND + 1 times. */
|
2005-04-06 01:52:41 +02:00
|
|
|
cond = fold_build2 (GT_EXPR, boolean_type_node, valid_niter, bound);
|
2004-07-09 05:19:14 +02:00
|
|
|
}
|
|
|
|
|
tree-chrec.c (chrec_fold_plus_poly_poly, [...]): Use fold_convert or build_int_cst_type instead od fonvert.
* tree-chrec.c (chrec_fold_plus_poly_poly, chrec_fold_plus_1,
chrec_fold_multiply): Use fold_convert or build_int_cst_type instead
od fonvert.
* tree-scalar-evolution.c (compute_overall_effect_of_inner_loop,
add_to_evolution, set_nb_iterations_in_loop, follow_ssa_edge_in_rhs,
follow_ssa_edge_in_rhs): Ditto.
* tree-ssa-loop-ivopts.c (struct iv): Add base_object field.
(dump_iv): Dump base_object.
(dump_use, dump_cand): Use dump_iv.
(determine_base_object): New function.
(alloc_iv): Initialize base_object field.
(record_use): Clear the ssa_name field of iv.
(get_computation_cost_at): Do not use difference of addresses of
two different objects.
(may_eliminate_iv): Do not require the loop to have just single exit.
* tree-ssa-loop-niter.c (zero_p): Do not check for overflows.
(nonzero_p): New function.
(inverse, number_of_iterations_cond, simplify_using_outer_evolutions,
tree_simplify_using_condition, simplify_using_initial_conditions,
loop_niter_by_eval, find_loop_niter_by_eval,
estimate_numbers_of_iterations_loop, compare_trees,
upper_bound_in_type, lower_bound_in_type,
can_count_iv_in_wider_type_bound): Use buildN instead of build. Use
fold_convert or build_int_cst_type instead of convert. Use (non)zero_p
instead of integer_(non)zerop.
From-SVN: r88388
2004-10-01 11:06:06 +02:00
|
|
|
if (nonzero_p (cond))
|
2004-07-09 05:19:14 +02:00
|
|
|
return new_step;
|
|
|
|
|
|
|
|
/* Try taking additional conditions into account. */
|
2005-04-06 01:52:41 +02:00
|
|
|
cond = fold_build2 (TRUTH_OR_EXPR, boolean_type_node,
|
|
|
|
invert_truthvalue (additional),
|
|
|
|
cond);
|
tree-chrec.c (chrec_fold_plus_poly_poly, [...]): Use fold_convert or build_int_cst_type instead od fonvert.
* tree-chrec.c (chrec_fold_plus_poly_poly, chrec_fold_plus_1,
chrec_fold_multiply): Use fold_convert or build_int_cst_type instead
od fonvert.
* tree-scalar-evolution.c (compute_overall_effect_of_inner_loop,
add_to_evolution, set_nb_iterations_in_loop, follow_ssa_edge_in_rhs,
follow_ssa_edge_in_rhs): Ditto.
* tree-ssa-loop-ivopts.c (struct iv): Add base_object field.
(dump_iv): Dump base_object.
(dump_use, dump_cand): Use dump_iv.
(determine_base_object): New function.
(alloc_iv): Initialize base_object field.
(record_use): Clear the ssa_name field of iv.
(get_computation_cost_at): Do not use difference of addresses of
two different objects.
(may_eliminate_iv): Do not require the loop to have just single exit.
* tree-ssa-loop-niter.c (zero_p): Do not check for overflows.
(nonzero_p): New function.
(inverse, number_of_iterations_cond, simplify_using_outer_evolutions,
tree_simplify_using_condition, simplify_using_initial_conditions,
loop_niter_by_eval, find_loop_niter_by_eval,
estimate_numbers_of_iterations_loop, compare_trees,
upper_bound_in_type, lower_bound_in_type,
can_count_iv_in_wider_type_bound): Use buildN instead of build. Use
fold_convert or build_int_cst_type instead of convert. Use (non)zero_p
instead of integer_(non)zerop.
From-SVN: r88388
2004-10-01 11:06:06 +02:00
|
|
|
if (nonzero_p (cond))
|
2004-07-09 05:19:14 +02:00
|
|
|
return new_step;
|
|
|
|
|
|
|
|
return NULL_TREE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Checks whether it is correct to count the induction variable BASE + STEP * I
|
|
|
|
at AT_STMT in wider TYPE, using the bounds on numbers of iterations of a
|
|
|
|
LOOP. If it is possible, return the value of step of the induction variable
|
|
|
|
in the TYPE, otherwise return NULL_TREE. */
|
|
|
|
|
|
|
|
tree
|
|
|
|
can_count_iv_in_wider_type (struct loop *loop, tree type, tree base, tree step,
|
|
|
|
tree at_stmt)
|
|
|
|
{
|
|
|
|
struct nb_iter_bound *bound;
|
|
|
|
tree new_step;
|
|
|
|
|
|
|
|
for (bound = loop->bounds; bound; bound = bound->next)
|
|
|
|
{
|
|
|
|
new_step = can_count_iv_in_wider_type_bound (type, base, step,
|
|
|
|
at_stmt,
|
|
|
|
bound->bound,
|
|
|
|
bound->additional,
|
|
|
|
bound->at_stmt);
|
|
|
|
|
|
|
|
if (new_step)
|
|
|
|
return new_step;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL_TREE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Frees the information on upper bounds on numbers of iterations of LOOP. */
|
|
|
|
|
|
|
|
static void
|
|
|
|
free_numbers_of_iterations_estimates_loop (struct loop *loop)
|
|
|
|
{
|
|
|
|
struct nb_iter_bound *bound, *next;
|
|
|
|
|
|
|
|
for (bound = loop->bounds; bound; bound = next)
|
|
|
|
{
|
|
|
|
next = bound->next;
|
|
|
|
free (bound);
|
|
|
|
}
|
|
|
|
|
|
|
|
loop->bounds = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Frees the information on upper bounds on numbers of iterations of LOOPS. */
|
|
|
|
|
|
|
|
void
|
|
|
|
free_numbers_of_iterations_estimates (struct loops *loops)
|
|
|
|
{
|
|
|
|
unsigned i;
|
|
|
|
struct loop *loop;
|
|
|
|
|
|
|
|
for (i = 1; i < loops->num; i++)
|
|
|
|
{
|
|
|
|
loop = loops->parray[i];
|
|
|
|
if (loop)
|
|
|
|
free_numbers_of_iterations_estimates_loop (loop);
|
|
|
|
}
|
|
|
|
}
|