From 946e1bc7575f0676faf87b8f9937e3a2a8b828af Mon Sep 17 00:00:00 2001 From: Zdenek Dvorak Date: Sun, 12 Nov 2006 20:58:05 +0100 Subject: Makefile.in (tree-data-ref.o): Add langhooks.h dependency. * Makefile.in (tree-data-ref.o): Add langhooks.h dependency. * tree-ssa-loop-niter.c (derive_constant_upper_bound): Follow ud-chains. Handle AND_EXPR. (record_estimate): Record whether the estimate is realistic and whether it is derived from a loop exit. (record_nonwrapping_iv, idx_infer_loop_bounds, infer_loop_bounds_from_ref, infer_loop_bounds_from_array, infer_loop_bounds_from_signedness): New functions. (compute_estimated_nb_iterations): Take only realistic bounds into account. Set estimate_state. Use double_ints. (infer_loop_bounds_from_undefined): Call infer_loop_bounds_from_array and infer_loop_bounds_from_signedness. Do not consider basic blocks that do not have to be always executed. (estimate_numbers_of_iterations_loop): Set estimate_state, and use it to determine whether to call infer_loop_bounds_from_undefined and compute_estimated_nb_iterations. (n_of_executions_at_most): Use double_ints. (free_numbers_of_iterations_estimates_loop): Set estimate_state. (substitute_in_loop_info): Do not replace in estimated_nb_iterations. * double-int.c (double_int_to_tree): Improve comment. (double_int_fits_to_tree_p): New function. * double-int.h (double_int_fits_to_tree_p): Declare. * tree-data-ref.c: Include langhooks.h. (estimate_niter_from_size_of_data, estimate_iters_using_array): Removed. (analyze_array_indexes): Do not call estimate_niter_from_size_of_data. (analyze_array): Do not pass estimate_only argument to analyze_array_indexes. (get_number_of_iters_for_loop): Build tree from the stored double_int value. (get_references_in_stmt, find_data_references_in_stmt): New functions. (find_data_references_in_loop): Use find_data_references_in_stmt. * tree-data-ref.h (struct data_ref_loc_d): New. (get_references_in_stmt): Declare. (estimate_iters_using_array): Declaration removed. * cfgloop.h (struct nb_iter_bound): Change type of bound to double_int. Improve comments. Add is_exit and realistic fields. (struct loop): Changed type of estimated_nb_iterations to double_int. Added estimate_state field. (record_estimate): Declaration removed. From-SVN: r118729 --- gcc/cfgloop.h | 45 ++++++++++++++++++++++++++++++++++++--------- 1 file changed, 36 insertions(+), 9 deletions(-) (limited to 'gcc/cfgloop.h') diff --git a/gcc/cfgloop.h b/gcc/cfgloop.h index 6838677..311c43e 100644 --- a/gcc/cfgloop.h +++ b/gcc/cfgloop.h @@ -47,12 +47,31 @@ struct lpt_decision struct nb_iter_bound { - tree bound; /* The constant expression whose value is an upper - bound on the number of executions of ... */ - tree at_stmt; /* ... this statement during one execution of - a loop. */ + /* The statement STMT is executed at most ... */ + tree stmt; + + /* ... BOUND + 1 times (BOUND must be an unsigned constant). + The + 1 is added for the following reasons: + + a) 0 would otherwise be unused, while we would need to care more about + overflows (as MAX + 1 is sometimes produced as the estimate on number + of executions of STMT). + b) it is consistent with the result of number_of_iterations_exit. */ + double_int bound; + + /* True if the statement will cause the loop to be leaved the (at most) + BOUND + 1-st time it is executed, that is, all the statements after it + are executed at most BOUND times. */ + bool is_exit; + + /* True if the bound is "realistic" -- i.e., most likely the loop really has + number of iterations close to the bound. Exact bounds (if the number of + iterations of a loop is a constant) and bounds derived from the size of + data accessed in the loop are considered realistic. */ + bool realistic; + + /* The next bound in the list. */ struct nb_iter_bound *next; - /* The next bound in a list. */ }; /* Structure to hold information for each natural loop. */ @@ -111,9 +130,18 @@ struct loop information in this field. */ tree nb_iterations; - /* An INTEGER_CST estimation of the number of iterations. NULL_TREE - if there is no estimation. */ - tree estimated_nb_iterations; + /* An integer estimation of the number of iterations. Estimate_state + describes what is the state of the estimation. */ + enum + { + /* Estimate was not computed yet. */ + EST_NOT_COMPUTED, + /* Estimate was computed, but we could derive no useful bound. */ + EST_NOT_AVAILABLE, + /* Estimate is ready. */ + EST_AVAILABLE + } estimate_state; + double_int estimated_nb_iterations; /* Upper bound on number of iterations of a loop. */ struct nb_iter_bound *bounds; @@ -398,6 +426,5 @@ enum extern void unroll_and_peel_loops (struct loops *, int); extern void doloop_optimize_loops (struct loops *); extern void move_loop_invariants (struct loops *); -extern void record_estimate (struct loop *, tree, tree, tree); #endif /* GCC_CFGLOOP_H */ -- cgit v1.1