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

cfgloop.h (estimated_loop_iterations_int): Ditch 'conservative' parameter. 

2012-04-12  Richard Guenther  <rguenther@suse.de>

	* cfgloop.h (estimated_loop_iterations_int): Ditch
	'conservative' parameter.
	(max_stmt_executions_int): Likewise.
	(estimated_loop_iterations): Likewise.
	(max_stmt_executions): Likewise.
	(max_loop_iterations): Declare.
	(max_loop_iterations_int): Likewise.
	(estimated_stmt_executions): Likewise.
	(estimated_stmt_executions_int): Likewise.
	* tree-ssa-loop-niter.c (estimated_loop_iterations):
	Split parts to ...
	(max_loop_iterations): ... this.
	(estimated_loop_iterations_int): Split parts to ...
	(max_loop_iterations_int): ... this.
	(max_stmt_executions_int): Split parts to ...
	(estimated_stmt_executions_int): ... this.
	(max_stmt_executions): Split parts to ...
	(estimated_stmt_executions): ... this.
	* graphite-sese-to-poly.c (build_loop_iteration_domains): Adjust.
	* predict.c (predict_loops): Likewise.
	* tree-data-ref.c (max_stmt_executions_tree): Likewise.
	(analyze_siv_subscript_cst_affine): Likewise.
	(compute_overlap_steps_for_affine_1_2): Likewise.
	(analyze_subscript_affine_affine): Likewise.
	(init_omega_for_ddr_1): Likewise.
	* tree-parloops.c (parallelize_loops): Likewise.
	* tree-ssa-loop-ivopts.c (avg_loop_niter): Likewise.
	(may_eliminate_iv): Likewise.
	* tree-ssa-loop-prefetch.c (determine_loop_nest_reuse): Likewise.
	(loop_prefetch_arrays): Likewise.
	* tree-vrp.c (adjust_range_with_scev): Likewise.

From-SVN: r186372
This commit is contained in:
Richard Guenther 2012-04-12 08:35:01 +00:00 committed by Richard Biener
parent 0c924efa4b
commit 652c4c71a1
10 changed files with 147 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
gcc/ChangeLog
View File

@ -1,3 +1,37 @@
2012-04-12 Richard Guenther <rguenther@suse.de>
* cfgloop.h (estimated_loop_iterations_int): Ditch
'conservative' parameter.
(max_stmt_executions_int): Likewise.
(estimated_loop_iterations): Likewise.
(max_stmt_executions): Likewise.
(max_loop_iterations): Declare.
(max_loop_iterations_int): Likewise.
(estimated_stmt_executions): Likewise.
(estimated_stmt_executions_int): Likewise.
* tree-ssa-loop-niter.c (estimated_loop_iterations):
Split parts to ...
(max_loop_iterations): ... this.
(estimated_loop_iterations_int): Split parts to ...
(max_loop_iterations_int): ... this.
(max_stmt_executions_int): Split parts to ...
(estimated_stmt_executions_int): ... this.
(max_stmt_executions): Split parts to ...
(estimated_stmt_executions): ... this.
* graphite-sese-to-poly.c (build_loop_iteration_domains): Adjust.
* predict.c (predict_loops): Likewise.
* tree-data-ref.c (max_stmt_executions_tree): Likewise.
(analyze_siv_subscript_cst_affine): Likewise.
(compute_overlap_steps_for_affine_1_2): Likewise.
(analyze_subscript_affine_affine): Likewise.
(init_omega_for_ddr_1): Likewise.
* tree-parloops.c (parallelize_loops): Likewise.
* tree-ssa-loop-ivopts.c (avg_loop_niter): Likewise.
(may_eliminate_iv): Likewise.
* tree-ssa-loop-prefetch.c (determine_loop_nest_reuse): Likewise.
(loop_prefetch_arrays): Likewise.
* tree-vrp.c (adjust_range_with_scev): Likewise.
2012-04-12 Oleg Endo <olegendo@gcc.gnu.org>
* config/sh/sh.h (RETURN_ADDR_RTX): Use NULL_RTX instead of 0.

12
gcc/cfgloop.h
View File

@ -279,10 +279,14 @@ extern unsigned expected_loop_iterations (const struct loop *);
extern rtx doloop_condition_get (rtx);
void estimate_numbers_of_iterations_loop (struct loop *, bool);
HOST_WIDE_INT estimated_loop_iterations_int (struct loop *, bool);
HOST_WIDE_INT max_stmt_executions_int (struct loop *, bool);
bool estimated_loop_iterations (struct loop *, bool, double_int *);
bool max_stmt_executions (struct loop *, bool, double_int *);
bool estimated_loop_iterations (struct loop *, double_int *);
bool max_loop_iterations (struct loop *, double_int *);
HOST_WIDE_INT estimated_loop_iterations_int (struct loop *);
HOST_WIDE_INT max_loop_iterations_int (struct loop *);
bool max_stmt_executions (struct loop *, double_int *);
bool estimated_stmt_executions (struct loop *, double_int *);
HOST_WIDE_INT max_stmt_executions_int (struct loop *);
HOST_WIDE_INT estimated_stmt_executions_int (struct loop *);
/* Loop manipulation. */
extern bool can_duplicate_loop_p (const struct loop *loop);

2
gcc/graphite-sese-to-poly.c
View File

@ -1092,7 +1092,7 @@ build_loop_iteration_domains (scop_p scop, struct loop *loop,
scan_tree_for_params (SCOP_REGION (scop), nb_iters, ub_expr, one);
mpz_clear (one);
if (max_stmt_executions (loop, true, &nit))
if (max_stmt_executions (loop, &nit))
add_upper_bounds_from_estimated_nit (scop, nit, dim, ub_expr);
/* loop_i <= expr_nb_iters */

2
gcc/predict.c
View File

@ -994,7 +994,7 @@ predict_loops (void)
the loop, use it to predict this exit. */
else if (n_exits == 1)
{
nitercst = max_stmt_executions_int (loop, false);
nitercst = estimated_stmt_executions_int (loop);
if (nitercst < 0)
continue;
if (nitercst > max)

27
gcc/tree-data-ref.c
View File

@ -1709,7 +1709,7 @@ max_stmt_executions_tree (struct loop *loop)
{
double_int nit;
if (!max_stmt_executions (loop, true, &nit))
if (!max_stmt_executions (loop, &nit))
return chrec_dont_know;
if (!double_int_fits_to_tree_p (unsigned_type_node, nit))
@ -1791,7 +1791,7 @@ analyze_siv_subscript_cst_affine (tree chrec_a,
/* Perform weak-zero siv test to see if overlap is
outside the loop bounds. */
numiter = max_stmt_executions_int (loop, true);
numiter = max_stmt_executions_int (loop);
if (numiter >= 0
&& compare_tree_int (tmp, numiter) > 0)
@ -1869,7 +1869,7 @@ analyze_siv_subscript_cst_affine (tree chrec_a,
/* Perform weak-zero siv test to see if overlap is
outside the loop bounds. */
numiter = max_stmt_executions_int (loop, true);
numiter = max_stmt_executions_int (loop);
if (numiter >= 0
&& compare_tree_int (tmp, numiter) > 0)
@ -2049,10 +2049,9 @@ compute_overlap_steps_for_affine_1_2 (tree chrec_a, tree chrec_b,
step_y = int_cst_value (CHREC_RIGHT (chrec_a));
step_z = int_cst_value (CHREC_RIGHT (chrec_b));
niter_x =
max_stmt_executions_int (get_chrec_loop (CHREC_LEFT (chrec_a)), true);
niter_y = max_stmt_executions_int (get_chrec_loop (chrec_a), true);
niter_z = max_stmt_executions_int (get_chrec_loop (chrec_b), true);
niter_x = max_stmt_executions_int (get_chrec_loop (CHREC_LEFT (chrec_a)));
niter_y = max_stmt_executions_int (get_chrec_loop (chrec_a));
niter_z = max_stmt_executions_int (get_chrec_loop (chrec_b));
if (niter_x < 0 || niter_y < 0 || niter_z < 0)
{
@ -2377,8 +2376,8 @@ analyze_subscript_affine_affine (tree chrec_a,
HOST_WIDE_INT niter, niter_a, niter_b;
affine_fn ova, ovb;
niter_a = max_stmt_executions_int (get_chrec_loop (chrec_a), true);
niter_b = max_stmt_executions_int (get_chrec_loop (chrec_b), true);
niter_a = max_stmt_executions_int (get_chrec_loop (chrec_a));
niter_b = max_stmt_executions_int (get_chrec_loop (chrec_b));
niter = MIN (niter_a, niter_b);
step_a = int_cst_value (CHREC_RIGHT (chrec_a));
step_b = int_cst_value (CHREC_RIGHT (chrec_b));
@ -2485,10 +2484,10 @@ analyze_subscript_affine_affine (tree chrec_a,
if (i1 > 0 && j1 > 0)
{
HOST_WIDE_INT niter_a = max_stmt_executions_int
(get_chrec_loop (chrec_a), true);
HOST_WIDE_INT niter_b = max_stmt_executions_int
(get_chrec_loop (chrec_b), true);
HOST_WIDE_INT niter_a
= max_stmt_executions_int (get_chrec_loop (chrec_a));
HOST_WIDE_INT niter_b
= max_stmt_executions_int (get_chrec_loop (chrec_b));
HOST_WIDE_INT niter = MIN (niter_a, niter_b);
/* (X0, Y0) is a solution of the Diophantine equation:
@ -3782,7 +3781,7 @@ init_omega_for_ddr_1 (struct data_reference *dra, struct data_reference *drb,
for (i = 0; i <= DDR_INNER_LOOP (ddr)
&& VEC_iterate (loop_p, DDR_LOOP_NEST (ddr), i, loopi); i++)
{
HOST_WIDE_INT nbi = max_stmt_executions_int (loopi, true);
HOST_WIDE_INT nbi = max_stmt_executions_int (loopi);
/* 0 <= loop_x */
ineq = omega_add_zero_geq (pb, omega_black);

2
gcc/tree-parloops.c
View File

@ -2192,7 +2192,7 @@ parallelize_loops (void)
header-copied loops correctly - see PR46886. */
|| !do_while_loop_p (loop))
continue;
estimated = max_stmt_executions_int (loop, false);
estimated = estimated_stmt_executions_int (loop);
/* FIXME: Bypass this check as graphite doesn't update the
count and frequency correctly now. */
if (!flag_loop_parallelize_all

4
gcc/tree-ssa-loop-ivopts.c
View File

@ -115,7 +115,7 @@ along with GCC; see the file COPYING3. If not see
static inline HOST_WIDE_INT
avg_loop_niter (struct loop *loop)
{
HOST_WIDE_INT niter = max_stmt_executions_int (loop, false);
HOST_WIDE_INT niter = estimated_stmt_executions_int (loop);
if (niter == -1)
return AVG_LOOP_NITER (loop);
@ -4694,7 +4694,7 @@ may_eliminate_iv (struct ivopts_data *data,
/* See if we can take advantage of infered loop bound information. */
if (data->loop_single_exit_p)
{
if (!estimated_loop_iterations (loop, true, &max_niter))
if (!max_loop_iterations (loop, &max_niter))
return false;
/* The loop bound is already adjusted by adding 1. */
if (double_int_ucmp (max_niter, period_value) > 0)

108
gcc/tree-ssa-loop-niter.c
View File

@ -3052,25 +3052,28 @@ estimate_numbers_of_iterations_loop (struct loop *loop, bool use_undefined_p)
the function returns false, otherwise returns true. */
bool
estimated_loop_iterations (struct loop *loop, bool conservative,
double_int *nit)
estimated_loop_iterations (struct loop *loop, double_int *nit)
{
estimate_numbers_of_iterations_loop (loop, true);
if (conservative)
{
if (!loop->any_upper_bound)
return false;
if (!loop->any_estimate)
return false;
*nit = loop->nb_iterations_upper_bound;
}
else
{
if (!loop->any_estimate)
return false;
*nit = loop->nb_iterations_estimate;
return true;
}
*nit = loop->nb_iterations_estimate;
}
/* Sets NIT to an upper bound for the maximum number of executions of the
latch of the LOOP. If we have no reliable estimate, the function returns
false, otherwise returns true. */
bool
max_loop_iterations (struct loop *loop, double_int *nit)
{
estimate_numbers_of_iterations_loop (loop, true);
if (!loop->any_upper_bound)
return false;
*nit = loop->nb_iterations_upper_bound;
return true;
}
@ -3079,12 +3082,32 @@ estimated_loop_iterations (struct loop *loop, bool conservative,
on the number of iterations of LOOP could not be derived, returns -1. */
HOST_WIDE_INT
estimated_loop_iterations_int (struct loop *loop, bool conservative)
estimated_loop_iterations_int (struct loop *loop)
{
double_int nit;
HOST_WIDE_INT hwi_nit;
if (!estimated_loop_iterations (loop, conservative, &nit))
if (!estimated_loop_iterations (loop, &nit))
return -1;
if (!double_int_fits_in_shwi_p (nit))
return -1;
hwi_nit = double_int_to_shwi (nit);
return hwi_nit < 0 ? -1 : hwi_nit;
}
/* Similar to max_loop_iterations, but returns the estimate only
if it fits to HOST_WIDE_INT. If this is not the case, or the estimate
on the number of iterations of LOOP could not be derived, returns -1. */
HOST_WIDE_INT
max_loop_iterations_int (struct loop *loop)
{
double_int nit;
HOST_WIDE_INT hwi_nit;
if (!max_loop_iterations (loop, &nit))
return -1;
if (!double_int_fits_in_shwi_p (nit))
@ -3099,9 +3122,9 @@ estimated_loop_iterations_int (struct loop *loop, bool conservative)
the number of execution of the latch by one. */
HOST_WIDE_INT
max_stmt_executions_int (struct loop *loop, bool conservative)
max_stmt_executions_int (struct loop *loop)
{
HOST_WIDE_INT nit = estimated_loop_iterations_int (loop, conservative);
HOST_WIDE_INT nit = max_loop_iterations_int (loop);
HOST_WIDE_INT snit;
if (nit == -1)
@ -3113,17 +3136,54 @@ max_stmt_executions_int (struct loop *loop, bool conservative)
return snit < 0 ? -1 : snit;
}
/* Sets NIT to the estimated number of executions of the latch of the
LOOP, plus one. If CONSERVATIVE is true, we must be sure that NIT is at
least as large as the number of iterations. If we have no reliable
estimate, the function returns false, otherwise returns true. */
/* Returns an estimate for the number of executions of statements
in the LOOP. For statements before the loop exit, this exceeds
the number of execution of the latch by one. */
HOST_WIDE_INT
estimated_stmt_executions_int (struct loop *loop)
{
HOST_WIDE_INT nit = estimated_loop_iterations_int (loop);
HOST_WIDE_INT snit;
if (nit == -1)
return -1;
snit = (HOST_WIDE_INT) ((unsigned HOST_WIDE_INT) nit + 1);
/* If the computation overflows, return -1. */
return snit < 0 ? -1 : snit;
}
/* Sets NIT to the estimated maximum number of executions of the latch of the
LOOP, plus one. If we have no reliable estimate, the function returns
false, otherwise returns true. */
bool
max_stmt_executions (struct loop *loop, bool conservative, double_int *nit)
max_stmt_executions (struct loop *loop, double_int *nit)
{
double_int nit_minus_one;
if (!estimated_loop_iterations (loop, conservative, nit))
if (!max_loop_iterations (loop, nit))
return false;
nit_minus_one = *nit;
*nit = double_int_add (*nit, double_int_one);
return double_int_ucmp (*nit, nit_minus_one) > 0;
}
/* Sets NIT to the estimated number of executions of the latch of the
LOOP, plus one. If we have no reliable estimate, the function returns
false, otherwise returns true. */
bool
estimated_stmt_executions (struct loop *loop, double_int *nit)
{
double_int nit_minus_one;
if (!estimated_loop_iterations (loop, nit))
return false;
nit_minus_one = *nit;

4
gcc/tree-ssa-loop-prefetch.c
View File

@ -1548,7 +1548,7 @@ determine_loop_nest_reuse (struct loop *loop, struct mem_ref_group *refs,
continue;
aloop = VEC_index (loop_p, vloops, i);
vol = max_stmt_executions_int (aloop, false);
vol = estimated_stmt_executions_int (aloop);
if (vol < 0)
vol = expected_loop_iterations (aloop);
volume *= vol;
@ -1800,7 +1800,7 @@ loop_prefetch_arrays (struct loop *loop)
return false;
ahead = (PREFETCH_LATENCY + time - 1) / time;
est_niter = max_stmt_executions_int (loop, false);
est_niter = estimated_stmt_executions_int (loop);
/* Prefetching is not likely to be profitable if the trip count to ahead
ratio is too small. */

2
gcc/tree-vrp.c
View File

@ -3420,7 +3420,7 @@ adjust_range_with_scev (value_range_t *vr, struct loop *loop,
{
double_int nit;
if (estimated_loop_iterations (loop, true, &nit))
if (max_loop_iterations (loop, &nit))
{
value_range_t maxvr = { VR_UNDEFINED, NULL_TREE, NULL_TREE, NULL };
double_int dtmp;