X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Fpredict.c;h=8f50ba0287b0ef733ce22bc9a71c562d9c1dd504;hb=d4b16cebcdc61fcee2e26f9bc09abf7c40cffc39;hp=2d1be03f1aaaeeb19a107c809a3a1a49631f3c99;hpb=b690c0a33b1f18112b01f6213f82678d7aa9fe42;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/predict.c b/gcc/predict.c index 2d1be03f1aa..8f50ba0287b 100644 --- a/gcc/predict.c +++ b/gcc/predict.c @@ -1,5 +1,6 @@ /* Branch prediction routines for the GNU compiler. - Copyright (C) 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc. + Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005 + Free Software Foundation, Inc. This file is part of GCC. @@ -15,8 +16,8 @@ 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. */ +Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301, USA. */ /* References: @@ -51,13 +52,14 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #include "sreal.h" #include "params.h" #include "target.h" -#include "loop.h" #include "cfgloop.h" #include "tree-flow.h" #include "ggc.h" #include "tree-dump.h" #include "tree-pass.h" #include "timevar.h" +#include "tree-scalar-evolution.h" +#include "cfgloop.h" /* real constants: 0, 1, 1-1/REG_BR_PROB_BASE, REG_BR_PROB_BASE, 1/REG_BR_PROB_BASE, 0.5, BB_FREQ_MAX. */ @@ -65,17 +67,17 @@ static sreal real_zero, real_one, real_almost_one, real_br_prob_base, real_inv_br_prob_base, real_one_half, real_bb_freq_max; /* Random guesstimation given names. */ -#define PROB_VERY_UNLIKELY (REG_BR_PROB_BASE / 10 - 1) +#define PROB_VERY_UNLIKELY (REG_BR_PROB_BASE / 100 - 1) #define PROB_EVEN (REG_BR_PROB_BASE / 2) #define PROB_VERY_LIKELY (REG_BR_PROB_BASE - PROB_VERY_UNLIKELY) #define PROB_ALWAYS (REG_BR_PROB_BASE) static void combine_predictions_for_insn (rtx, basic_block); static void dump_prediction (FILE *, enum br_predictor, int, basic_block, int); -static void estimate_loops_at_level (struct loop *loop); -static void propagate_freq (struct loop *); +static void estimate_loops_at_level (struct loop *, bitmap); +static void propagate_freq (struct loop *, bitmap); static void estimate_bb_frequencies (struct loops *); -static int counts_to_freqs (void); +static void predict_paths_leading_to (basic_block, int *, enum br_predictor, enum prediction); static bool last_basic_block_p (basic_block); static void compute_function_frequency (void); static void choose_function_section (void); @@ -169,14 +171,14 @@ rtl_predicted_by_p (basic_block bb, enum br_predictor predictor) bool tree_predicted_by_p (basic_block bb, enum br_predictor predictor) { - struct edge_prediction *i = bb_ann (bb)->predictions; - for (i = bb_ann (bb)->predictions; i; i = i->next) + struct edge_prediction *i; + for (i = bb->predictions; i; i = i->next) if (i->predictor == predictor) return true; return false; } -void +static void predict_insn (rtx insn, enum br_predictor predictor, int probability) { gcc_assert (any_condjump_p (insn)); @@ -229,13 +231,36 @@ rtl_predict_edge (edge e, enum br_predictor predictor, int probability) void tree_predict_edge (edge e, enum br_predictor predictor, int probability) { - struct edge_prediction *i = ggc_alloc (sizeof (struct edge_prediction)); + gcc_assert (profile_status != PROFILE_GUESSED); + if ((e->src != ENTRY_BLOCK_PTR && EDGE_COUNT (e->src->succs) > 1) + && flag_guess_branch_prob && optimize) + { + struct edge_prediction *i = ggc_alloc (sizeof (struct edge_prediction)); + + i->next = e->src->predictions; + e->src->predictions = i; + i->probability = probability; + i->predictor = predictor; + i->edge = e; + } +} - i->next = bb_ann (e->src)->predictions; - bb_ann (e->src)->predictions = i; - i->probability = probability; - i->predictor = predictor; - i->edge = e; +/* Remove all predictions on given basic block that are attached + to edge E. */ +void +remove_predictions_associated_with_edge (edge e) +{ + if (e->src->predictions) + { + struct edge_prediction **prediction = &e->src->predictions; + while (*prediction) + { + if ((*prediction)->edge == e) + *prediction = (*prediction)->next; + else + prediction = &((*prediction)->next); + } + } } /* Return true when we can store prediction on insn INSN. @@ -246,7 +271,7 @@ can_predict_insn_p (rtx insn) { return (JUMP_P (insn) && any_condjump_p (insn) - && BLOCK_FOR_INSN (insn)->succ->succ_next); + && EDGE_COUNT (BLOCK_FOR_INSN (insn)->succs) >= 2); } /* Predict edge E by given predictor if possible. */ @@ -285,13 +310,15 @@ static void dump_prediction (FILE *file, enum br_predictor predictor, int probability, basic_block bb, int used) { - edge e = bb->succ; + edge e; + edge_iterator ei; if (!file) return; - while (e && (e->flags & EDGE_FALLTHRU)) - e = e->succ_next; + FOR_EACH_EDGE (e, ei, bb->succs) + if (! (e->flags & EDGE_FALLTHRU)) + break; fprintf (file, " %s heuristics%s: %.1f%%", predictor_info[predictor].name, @@ -319,11 +346,12 @@ set_even_probabilities (basic_block bb) { int nedges = 0; edge e; + edge_iterator ei; - for (e = bb->succ; e; e = e->succ_next) + FOR_EACH_EDGE (e, ei, bb->succs) if (!(e->flags & (EDGE_EH | EDGE_FAKE))) nedges ++; - for (e = bb->succ; e; e = e->succ_next) + FOR_EACH_EDGE (e, ei, bb->succs) if (!(e->flags & (EDGE_EH | EDGE_FAKE))) e->probability = (REG_BR_PROB_BASE + nedges / 2) / nedges; else @@ -428,13 +456,22 @@ combine_predictions_for_insn (rtx insn, basic_block bb) /* Save the prediction into CFG in case we are seeing non-degenerated conditional jump. */ - if (bb->succ->succ_next) + if (!single_succ_p (bb)) { BRANCH_EDGE (bb)->probability = combined_probability; FALLTHRU_EDGE (bb)->probability = REG_BR_PROB_BASE - combined_probability; } } + else if (!single_succ_p (bb)) + { + int prob = INTVAL (XEXP (prob_note, 0)); + + BRANCH_EDGE (bb)->probability = prob; + FALLTHRU_EDGE (bb)->probability = REG_BR_PROB_BASE - prob; + } + else + single_succ_edge (bb)->probability = REG_BR_PROB_BASE; } /* Combine predictions into single probability and store them into CFG. @@ -452,11 +489,12 @@ combine_predictions_for_bb (FILE *file, basic_block bb) struct edge_prediction *pred; int nedges = 0; edge e, first = NULL, second = NULL; + edge_iterator ei; - for (e = bb->succ; e; e = e->succ_next) + FOR_EACH_EDGE (e, ei, bb->succs) if (!(e->flags & (EDGE_EH | EDGE_FAKE))) { - nedges ++; + nedges ++; if (first && !second) second = e; if (!first) @@ -473,7 +511,7 @@ combine_predictions_for_bb (FILE *file, basic_block bb) { if (!bb->count) set_even_probabilities (bb); - bb_ann (bb)->predictions = NULL; + bb->predictions = NULL; if (file) fprintf (file, "%i edges in bb %i predicted to even probabilities\n", nedges, bb->index); @@ -485,7 +523,7 @@ combine_predictions_for_bb (FILE *file, basic_block bb) /* We implement "first match" heuristics and use probability guessed by predictor with smallest index. */ - for (pred = bb_ann (bb)->predictions; pred; pred = pred->next) + for (pred = bb->predictions; pred; pred = pred->next) { int predictor = pred->predictor; int probability = pred->probability; @@ -531,17 +569,17 @@ combine_predictions_for_bb (FILE *file, basic_block bb) combined_probability = best_probability; dump_prediction (file, PRED_COMBINED, combined_probability, bb, true); - for (pred = bb_ann (bb)->predictions; pred; pred = pred->next) + for (pred = bb->predictions; pred; pred = pred->next) { int predictor = pred->predictor; int probability = pred->probability; - if (pred->edge != bb->succ) + if (pred->edge != EDGE_SUCC (bb, 0)) probability = REG_BR_PROB_BASE - probability; dump_prediction (file, predictor, probability, bb, !first_match || best_predictor == predictor); } - bb_ann (bb)->predictions = NULL; + bb->predictions = NULL; if (!bb->count) { @@ -551,28 +589,31 @@ combine_predictions_for_bb (FILE *file, basic_block bb) } /* Predict edge probabilities by exploiting loop structure. - When SIMPLELOOPS is set, attempt to count number of iterations by analyzing - RTL. */ + When RTLSIMPLELOOPS is set, attempt to count number of iterations by analyzing + RTL otherwise use tree based approach. */ static void -predict_loops (struct loops *loops_info, bool simpleloops) +predict_loops (struct loops *loops_info, bool rtlsimpleloops) { unsigned i; + if (!rtlsimpleloops) + scev_initialize (loops_info); + /* Try to predict out blocks in a loop that are not part of a natural loop. */ for (i = 1; i < loops_info->num; i++) { basic_block bb, *bbs; unsigned j; - int exits; + unsigned n_exits; struct loop *loop = loops_info->parray[i]; struct niter_desc desc; unsigned HOST_WIDE_INT niter; + edge *exits; - flow_loop_scan (loop, LOOP_EXIT_EDGES); - exits = loop->num_exits; + exits = get_loop_exit_edges (loop, &n_exits); - if (simpleloops) + if (rtlsimpleloops) { iv_analysis_loop_init (loop); find_simple_exit (loop, &desc); @@ -583,6 +624,9 @@ predict_loops (struct loops *loops_info, bool simpleloops) niter = desc.niter + 1; if (niter == 0) /* We might overflow here. */ niter = desc.niter; + if (niter + > (unsigned int) PARAM_VALUE (PARAM_MAX_PREDICTED_ITERATIONS)) + niter = PARAM_VALUE (PARAM_MAX_PREDICTED_ITERATIONS); prob = (REG_BR_PROB_BASE - (REG_BR_PROB_BASE + niter /2) / niter); @@ -594,6 +638,40 @@ predict_loops (struct loops *loops_info, bool simpleloops) prob); } } + else + { + struct tree_niter_desc niter_desc; + + for (j = 0; j < n_exits; j++) + { + tree niter = NULL; + + if (number_of_iterations_exit (loop, exits[j], &niter_desc, false)) + niter = niter_desc.niter; + if (!niter || TREE_CODE (niter_desc.niter) != INTEGER_CST) + niter = loop_niter_by_eval (loop, exits[j]); + + if (TREE_CODE (niter) == INTEGER_CST) + { + int probability; + int max = PARAM_VALUE (PARAM_MAX_PREDICTED_ITERATIONS); + if (host_integerp (niter, 1) + && tree_int_cst_lt (niter, + build_int_cstu (NULL_TREE, max - 1))) + { + HOST_WIDE_INT nitercst = tree_low_cst (niter, 1) + 1; + probability = ((REG_BR_PROB_BASE + nitercst / 2) + / nitercst); + } + else + probability = ((REG_BR_PROB_BASE + max / 2) / max); + + predict_edge (exits[j], PRED_LOOP_ITERATIONS, probability); + } + } + + } + free (exits); bbs = get_loop_body (loop); @@ -601,6 +679,7 @@ predict_loops (struct loops *loops_info, bool simpleloops) { int header_found = 0; edge e; + edge_iterator ei; bb = bbs[j]; @@ -608,36 +687,44 @@ predict_loops (struct loops *loops_info, bool simpleloops) statements construct loops via "non-loop" constructs in the source language and are better to be handled separately. */ - if ((simpleloops && !can_predict_insn_p (BB_END (bb))) + if ((rtlsimpleloops && !can_predict_insn_p (BB_END (bb))) || predicted_by_p (bb, PRED_CONTINUE)) continue; /* Loop branch heuristics - predict an edge back to a loop's head as taken. */ - for (e = bb->succ; e; e = e->succ_next) - if (e->dest == loop->header - && e->src == loop->latch) - { - header_found = 1; - predict_edge_def (e, PRED_LOOP_BRANCH, TAKEN); - } + if (bb == loop->latch) + { + e = find_edge (loop->latch, loop->header); + if (e) + { + header_found = 1; + predict_edge_def (e, PRED_LOOP_BRANCH, TAKEN); + } + } /* Loop exit heuristics - predict an edge exiting the loop if the conditional has no loop header successors as not taken. */ if (!header_found) - for (e = bb->succ; e; e = e->succ_next) + FOR_EACH_EDGE (e, ei, bb->succs) if (e->dest->index < 0 || !flow_bb_inside_loop_p (loop, e->dest)) predict_edge (e, PRED_LOOP_EXIT, (REG_BR_PROB_BASE - predictor_info [(int) PRED_LOOP_EXIT].hitrate) - / exits); + / n_exits); } /* Free basic blocks from get_loop_body. */ free (bbs); } + + if (!rtlsimpleloops) + { + scev_finalize (); + current_loops = NULL; + } } /* Attempt to predict probabilities of BB outgoing edges using local @@ -761,25 +848,26 @@ estimate_probability (struct loops *loops_info) { rtx last_insn = BB_END (bb); edge e; + edge_iterator ei; if (! can_predict_insn_p (last_insn)) continue; - for (e = bb->succ; e; e = e->succ_next) + FOR_EACH_EDGE (e, ei, bb->succs) { /* Predict early returns to be probable, as we've already taken care for error returns and other are often used for fast paths trought function. */ if ((e->dest == EXIT_BLOCK_PTR - || (e->dest->succ && !e->dest->succ->succ_next - && e->dest->succ->dest == EXIT_BLOCK_PTR)) + || (single_succ_p (e->dest) + && single_succ (e->dest) == EXIT_BLOCK_PTR)) && !predicted_by_p (bb, PRED_NULL_RETURN) && !predicted_by_p (bb, PRED_CONST_RETURN) && !predicted_by_p (bb, PRED_NEGATIVE_RETURN) && !last_basic_block_p (e->dest)) predict_edge_def (e, PRED_EARLY_RETURN, TAKEN); - /* Look for block we are guarding (ie we dominate it, + /* Look for block we are guarding (i.e. we dominate it, but it doesn't postdominate us). */ if (e->dest != EXIT_BLOCK_PTR && e->dest != bb && dominated_by_p (CDI_DOMINATORS, e->dest, e->src) @@ -808,37 +896,9 @@ estimate_probability (struct loops *loops_info) /* Attach the combined probability to each conditional jump. */ FOR_EACH_BB (bb) - if (JUMP_P (BB_END (bb)) - && any_condjump_p (BB_END (bb)) - && bb->succ->succ_next != NULL) - combine_predictions_for_insn (BB_END (bb), bb); - - remove_fake_exit_edges (); - /* Fill in the probability values in flowgraph based on the REG_BR_PROB - notes. */ - FOR_EACH_BB (bb) - { - rtx last_insn = BB_END (bb); - - if (!can_predict_insn_p (last_insn)) - { - /* We can predict only conditional jumps at the moment. - Expect each edge to be equally probable. - ?? In the future we want to make abnormal edges improbable. */ - int nedges = 0; - edge e; + combine_predictions_for_insn (BB_END (bb), bb); - for (e = bb->succ; e; e = e->succ_next) - { - nedges++; - if (e->probability != 0) - break; - } - if (!e) - for (e = bb->succ; e; e = e->succ_next) - e->probability = (REG_BR_PROB_BASE + nedges / 2) / nedges; - } - } + remove_fake_edges (); estimate_bb_frequencies (loops_info); free_dominance_info (CDI_POST_DOMINATORS); if (profile_status == PROFILE_ABSENT) @@ -853,7 +913,139 @@ guess_outgoing_edge_probabilities (basic_block bb) combine_predictions_for_insn (BB_END (bb), bb); } +/* Return constant EXPR will likely have at execution time, NULL if unknown. + The function is used by builtin_expect branch predictor so the evidence + must come from this construct and additional possible constant folding. + + We may want to implement more involved value guess (such as value range + propagation based prediction), but such tricks shall go to new + implementation. */ + +static tree +expr_expected_value (tree expr, bitmap visited) +{ + if (TREE_CONSTANT (expr)) + return expr; + else if (TREE_CODE (expr) == SSA_NAME) + { + tree def = SSA_NAME_DEF_STMT (expr); + /* If we were already here, break the infinite cycle. */ + if (bitmap_bit_p (visited, SSA_NAME_VERSION (expr))) + return NULL; + bitmap_set_bit (visited, SSA_NAME_VERSION (expr)); + + if (TREE_CODE (def) == PHI_NODE) + { + /* All the arguments of the PHI node must have the same constant + length. */ + int i; + tree val = NULL, new_val; + + for (i = 0; i < PHI_NUM_ARGS (def); i++) + { + tree arg = PHI_ARG_DEF (def, i); + + /* If this PHI has itself as an argument, we cannot + determine the string length of this argument. However, + if we can find an expected constant value for the other + PHI args then we can still be sure that this is + likely a constant. So be optimistic and just + continue with the next argument. */ + if (arg == PHI_RESULT (def)) + continue; + + new_val = expr_expected_value (arg, visited); + if (!new_val) + return NULL; + if (!val) + val = new_val; + else if (!operand_equal_p (val, new_val, false)) + return NULL; + } + return val; + } + if (TREE_CODE (def) != MODIFY_EXPR || TREE_OPERAND (def, 0) != expr) + return NULL; + return expr_expected_value (TREE_OPERAND (def, 1), visited); + } + else if (TREE_CODE (expr) == CALL_EXPR) + { + tree decl = get_callee_fndecl (expr); + if (!decl) + return NULL; + if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL + && DECL_FUNCTION_CODE (decl) == BUILT_IN_EXPECT) + { + tree arglist = TREE_OPERAND (expr, 1); + tree val; + + if (arglist == NULL_TREE + || TREE_CHAIN (arglist) == NULL_TREE) + return NULL; + val = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (expr, 1))); + if (TREE_CONSTANT (val)) + return val; + return TREE_VALUE (TREE_CHAIN (TREE_OPERAND (expr, 1))); + } + } + if (BINARY_CLASS_P (expr) || COMPARISON_CLASS_P (expr)) + { + tree op0, op1, res; + op0 = expr_expected_value (TREE_OPERAND (expr, 0), visited); + if (!op0) + return NULL; + op1 = expr_expected_value (TREE_OPERAND (expr, 1), visited); + if (!op1) + return NULL; + res = fold_build2 (TREE_CODE (expr), TREE_TYPE (expr), op0, op1); + if (TREE_CONSTANT (res)) + return res; + return NULL; + } + if (UNARY_CLASS_P (expr)) + { + tree op0, res; + op0 = expr_expected_value (TREE_OPERAND (expr, 0), visited); + if (!op0) + return NULL; + res = fold_build1 (TREE_CODE (expr), TREE_TYPE (expr), op0); + if (TREE_CONSTANT (res)) + return res; + return NULL; + } + return NULL; +} + +/* Get rid of all builtin_expect calls we no longer need. */ +static void +strip_builtin_expect (void) +{ + basic_block bb; + FOR_EACH_BB (bb) + { + block_stmt_iterator bi; + for (bi = bsi_start (bb); !bsi_end_p (bi); bsi_next (&bi)) + { + tree stmt = bsi_stmt (bi); + tree fndecl; + tree arglist; + + if (TREE_CODE (stmt) == MODIFY_EXPR + && TREE_CODE (TREE_OPERAND (stmt, 1)) == CALL_EXPR + && (fndecl = get_callee_fndecl (TREE_OPERAND (stmt, 1))) + && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL + && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_EXPECT + && (arglist = TREE_OPERAND (TREE_OPERAND (stmt, 1), 1)) + && TREE_CHAIN (arglist)) + { + TREE_OPERAND (stmt, 1) = TREE_VALUE (arglist); + update_stmt (stmt); + } + } + } +} + /* Predict using opcode of the last statement in basic block. */ static void tree_predict_by_opcode (basic_block bb) @@ -863,17 +1055,31 @@ tree_predict_by_opcode (basic_block bb) tree cond; tree op0; tree type; + tree val; + bitmap visited; + edge_iterator ei; if (!stmt || TREE_CODE (stmt) != COND_EXPR) return; - for (then_edge = bb->succ; then_edge; then_edge = then_edge->succ_next) + FOR_EACH_EDGE (then_edge, ei, bb->succs) if (then_edge->flags & EDGE_TRUE_VALUE) - break; + break; cond = TREE_OPERAND (stmt, 0); - if (TREE_CODE_CLASS (TREE_CODE (cond)) != '<') + if (!COMPARISON_CLASS_P (cond)) return; op0 = TREE_OPERAND (cond, 0); type = TREE_TYPE (op0); + visited = BITMAP_ALLOC (NULL); + val = expr_expected_value (cond, visited); + BITMAP_FREE (visited); + if (val) + { + if (integer_zerop (val)) + predict_edge_def (then_edge, PRED_BUILTIN_EXPECT, NOT_TAKEN); + else + predict_edge_def (then_edge, PRED_BUILTIN_EXPECT, TAKEN); + return; + } /* Try "pointer heuristic." A comparison ptr == 0 is predicted as false. Similarly, a comparison ptr1 == ptr2 is predicted as false. */ @@ -959,6 +1165,148 @@ tree_predict_by_opcode (basic_block bb) } } +/* Try to guess whether the value of return means error code. */ +static enum br_predictor +return_prediction (tree val, enum prediction *prediction) +{ + /* VOID. */ + if (!val) + return PRED_NO_PREDICTION; + /* Different heuristics for pointers and scalars. */ + if (POINTER_TYPE_P (TREE_TYPE (val))) + { + /* NULL is usually not returned. */ + if (integer_zerop (val)) + { + *prediction = NOT_TAKEN; + return PRED_NULL_RETURN; + } + } + else if (INTEGRAL_TYPE_P (TREE_TYPE (val))) + { + /* Negative return values are often used to indicate + errors. */ + if (TREE_CODE (val) == INTEGER_CST + && tree_int_cst_sgn (val) < 0) + { + *prediction = NOT_TAKEN; + return PRED_NEGATIVE_RETURN; + } + /* Constant return values seems to be commonly taken. + Zero/one often represent booleans so exclude them from the + heuristics. */ + if (TREE_CONSTANT (val) + && (!integer_zerop (val) && !integer_onep (val))) + { + *prediction = TAKEN; + return PRED_NEGATIVE_RETURN; + } + } + return PRED_NO_PREDICTION; +} + +/* Find the basic block with return expression and look up for possible + return value trying to apply RETURN_PREDICTION heuristics. */ +static void +apply_return_prediction (int *heads) +{ + tree return_stmt = NULL; + tree return_val; + edge e; + tree phi; + int phi_num_args, i; + enum br_predictor pred; + enum prediction direction; + edge_iterator ei; + + FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR->preds) + { + return_stmt = last_stmt (e->src); + if (TREE_CODE (return_stmt) == RETURN_EXPR) + break; + } + if (!e) + return; + return_val = TREE_OPERAND (return_stmt, 0); + if (!return_val) + return; + if (TREE_CODE (return_val) == MODIFY_EXPR) + return_val = TREE_OPERAND (return_val, 1); + if (TREE_CODE (return_val) != SSA_NAME + || !SSA_NAME_DEF_STMT (return_val) + || TREE_CODE (SSA_NAME_DEF_STMT (return_val)) != PHI_NODE) + return; + for (phi = SSA_NAME_DEF_STMT (return_val); phi; phi = PHI_CHAIN (phi)) + if (PHI_RESULT (phi) == return_val) + break; + if (!phi) + return; + phi_num_args = PHI_NUM_ARGS (phi); + pred = return_prediction (PHI_ARG_DEF (phi, 0), &direction); + + /* Avoid the degenerate case where all return values form the function + belongs to same category (ie they are all positive constants) + so we can hardly say something about them. */ + for (i = 1; i < phi_num_args; i++) + if (pred != return_prediction (PHI_ARG_DEF (phi, i), &direction)) + break; + if (i != phi_num_args) + for (i = 0; i < phi_num_args; i++) + { + pred = return_prediction (PHI_ARG_DEF (phi, i), &direction); + if (pred != PRED_NO_PREDICTION) + predict_paths_leading_to (PHI_ARG_EDGE (phi, i)->src, heads, pred, + direction); + } +} + +/* Look for basic block that contains unlikely to happen events + (such as noreturn calls) and mark all paths leading to execution + of this basic blocks as unlikely. */ + +static void +tree_bb_level_predictions (void) +{ + basic_block bb; + int *heads; + + heads = xmalloc (sizeof (int) * last_basic_block); + memset (heads, -1, sizeof (int) * last_basic_block); + heads[ENTRY_BLOCK_PTR->next_bb->index] = last_basic_block; + + apply_return_prediction (heads); + + FOR_EACH_BB (bb) + { + block_stmt_iterator bsi = bsi_last (bb); + + for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi)) + { + tree stmt = bsi_stmt (bsi); + switch (TREE_CODE (stmt)) + { + case MODIFY_EXPR: + if (TREE_CODE (TREE_OPERAND (stmt, 1)) == CALL_EXPR) + { + stmt = TREE_OPERAND (stmt, 1); + goto call_expr; + } + break; + case CALL_EXPR: +call_expr:; + if (call_expr_flags (stmt) & ECF_NORETURN) + predict_paths_leading_to (bb, heads, PRED_NORETURN, + NOT_TAKEN); + break; + default: + break; + } + } + } + + free (heads); +} + /* Predict branch probabilities and estimate profile of the tree CFG. */ static void tree_estimate_probability (void) @@ -966,33 +1314,44 @@ tree_estimate_probability (void) basic_block bb; struct loops loops_info; - flow_loops_find (&loops_info, LOOP_TREE); + flow_loops_find (&loops_info); if (dump_file && (dump_flags & TDF_DETAILS)) flow_loops_dump (&loops_info, dump_file, NULL, 0); + add_noreturn_fake_exit_edges (); connect_infinite_loops_to_exit (); calculate_dominance_info (CDI_DOMINATORS); calculate_dominance_info (CDI_POST_DOMINATORS); + tree_bb_level_predictions (); + + mark_irreducible_loops (&loops_info); predict_loops (&loops_info, false); FOR_EACH_BB (bb) { edge e; + edge_iterator ei; - for (e = bb->succ; e; e = e->succ_next) + FOR_EACH_EDGE (e, ei, bb->succs) { /* Predict early returns to be probable, as we've already taken - care for error returns and other are often used for fast paths - trought function. */ - if ((e->dest == EXIT_BLOCK_PTR - || (e->dest->succ && !e->dest->succ->succ_next - && e->dest->succ->dest == EXIT_BLOCK_PTR)) - && !predicted_by_p (bb, PRED_NULL_RETURN) - && !predicted_by_p (bb, PRED_CONST_RETURN) - && !predicted_by_p (bb, PRED_NEGATIVE_RETURN) - && !last_basic_block_p (e->dest)) - predict_edge_def (e, PRED_EARLY_RETURN, TAKEN); + care for error returns and other cases are often used for + fast paths trought function. */ + if (e->dest == EXIT_BLOCK_PTR + && TREE_CODE (last_stmt (bb)) == RETURN_EXPR + && !single_pred_p (bb)) + { + edge e1; + edge_iterator ei1; + + FOR_EACH_EDGE (e1, ei1, bb->preds) + if (!predicted_by_p (e1->src, PRED_NULL_RETURN) + && !predicted_by_p (e1->src, PRED_CONST_RETURN) + && !predicted_by_p (e1->src, PRED_NEGATIVE_RETURN) + && !last_basic_block_p (e1->src)) + predict_edge_def (e1, PRED_TREE_EARLY_RETURN, NOT_TAKEN); + } /* Look for block we are guarding (ie we dominate it, but it doesn't postdominate us). */ @@ -1028,6 +1387,8 @@ tree_estimate_probability (void) FOR_EACH_BB (bb) combine_predictions_for_bb (dump_file, bb); + if (!flag_loop_optimize) + strip_builtin_expect (); estimate_bb_frequencies (&loops_info); free_dominance_info (CDI_POST_DOMINATORS); remove_fake_exit_edges (); @@ -1121,8 +1482,65 @@ last_basic_block_p (basic_block bb) return (bb->next_bb == EXIT_BLOCK_PTR || (bb->next_bb->next_bb == EXIT_BLOCK_PTR - && bb->succ && !bb->succ->succ_next - && bb->succ->dest->next_bb == EXIT_BLOCK_PTR)); + && single_succ_p (bb) + && single_succ (bb)->next_bb == EXIT_BLOCK_PTR)); +} + +/* Sets branch probabilities according to PREDiction and + FLAGS. HEADS[bb->index] should be index of basic block in that we + need to alter branch predictions (i.e. the first of our dominators + such that we do not post-dominate it) (but we fill this information + on demand, so -1 may be there in case this was not needed yet). */ + +static void +predict_paths_leading_to (basic_block bb, int *heads, enum br_predictor pred, + enum prediction taken) +{ + edge e; + edge_iterator ei; + int y; + + if (heads[bb->index] < 0) + { + /* This is first time we need this field in heads array; so + find first dominator that we do not post-dominate (we are + using already known members of heads array). */ + basic_block ai = bb; + basic_block next_ai = get_immediate_dominator (CDI_DOMINATORS, bb); + int head; + + while (heads[next_ai->index] < 0) + { + if (!dominated_by_p (CDI_POST_DOMINATORS, next_ai, bb)) + break; + heads[next_ai->index] = ai->index; + ai = next_ai; + next_ai = get_immediate_dominator (CDI_DOMINATORS, next_ai); + } + if (!dominated_by_p (CDI_POST_DOMINATORS, next_ai, bb)) + head = next_ai->index; + else + head = heads[next_ai->index]; + while (next_ai != bb) + { + next_ai = ai; + if (heads[ai->index] == ENTRY_BLOCK) + ai = ENTRY_BLOCK_PTR; + else + ai = BASIC_BLOCK (heads[ai->index]); + heads[next_ai->index] = head; + } + } + y = heads[bb->index]; + + /* Now find the edge that leads to our branch and aply the prediction. */ + + if (y == last_basic_block) + return; + FOR_EACH_EDGE (e, ei, BASIC_BLOCK (y)->succs) + if (e->dest->index >= 0 + && dominated_by_p (CDI_POST_DOMINATORS, e->dest, bb)) + predict_edge_def (e, pred, taken); } /* This is used to carry information about basic blocks. It is @@ -1136,9 +1554,6 @@ typedef struct block_info_def /* To keep queue of basic blocks to process. */ basic_block next; - /* True if block needs to be visited in propagate_freq. */ - unsigned int tovisit:1; - /* Number of predecessors we need to visit first. */ int npredecessors; } *block_info; @@ -1146,11 +1561,11 @@ typedef struct block_info_def /* Similar information for edges. */ typedef struct edge_info_def { - /* In case edge is an loopback edge, the probability edge will be reached + /* In case edge is a loopback edge, the probability edge will be reached in case header is. Estimated number of iterations of the loop can be then computed as 1 / (1 - back_edge_prob). */ sreal back_edge_prob; - /* True if the edge is an loopback edge in the natural loop. */ + /* True if the edge is a loopback edge in the natural loop. */ unsigned int back_edge:1; } *edge_info; @@ -1161,38 +1576,52 @@ typedef struct edge_info_def Propagate the frequencies for LOOP. */ static void -propagate_freq (struct loop *loop) +propagate_freq (struct loop *loop, bitmap tovisit) { basic_block head = loop->header; basic_block bb; basic_block last; + unsigned i; edge e; basic_block nextbb; + bitmap_iterator bi; /* For each basic block we need to visit count number of his predecessors we need to visit first. */ - FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb) + EXECUTE_IF_SET_IN_BITMAP (tovisit, 0, i, bi) { - if (BLOCK_INFO (bb)->tovisit) + edge_iterator ei; + int count = 0; + + /* The outermost "loop" includes the exit block, which we can not + look up via BASIC_BLOCK. Detect this and use EXIT_BLOCK_PTR + directly. Do the same for the entry block. */ + if (i == (unsigned)ENTRY_BLOCK) + bb = ENTRY_BLOCK_PTR; + else if (i == (unsigned)EXIT_BLOCK) + bb = EXIT_BLOCK_PTR; + else + bb = BASIC_BLOCK (i); + + FOR_EACH_EDGE (e, ei, bb->preds) { - int count = 0; - - for (e = bb->pred; e; e = e->pred_next) - if (BLOCK_INFO (e->src)->tovisit && !(e->flags & EDGE_DFS_BACK)) - count++; - else if (BLOCK_INFO (e->src)->tovisit - && dump_file && !EDGE_INFO (e)->back_edge) - fprintf (dump_file, - "Irreducible region hit, ignoring edge to %i->%i\n", - e->src->index, bb->index); - BLOCK_INFO (bb)->npredecessors = count; + bool visit = bitmap_bit_p (tovisit, e->src->index); + + if (visit && !(e->flags & EDGE_DFS_BACK)) + count++; + else if (visit && dump_file && !EDGE_INFO (e)->back_edge) + fprintf (dump_file, + "Irreducible region hit, ignoring edge to %i->%i\n", + e->src->index, bb->index); } + BLOCK_INFO (bb)->npredecessors = count; } memcpy (&BLOCK_INFO (head)->frequency, &real_one, sizeof (real_one)); last = head; for (bb = head; bb; bb = nextbb) { + edge_iterator ei; sreal cyclic_probability, frequency; memcpy (&cyclic_probability, &real_zero, sizeof (real_zero)); @@ -1205,12 +1634,12 @@ propagate_freq (struct loop *loop) if (bb != head) { #ifdef ENABLE_CHECKING - for (e = bb->pred; e; e = e->pred_next) - gcc_assert (!BLOCK_INFO (e->src)->tovisit + FOR_EACH_EDGE (e, ei, bb->preds) + gcc_assert (!bitmap_bit_p (tovisit, e->src->index) || (e->flags & EDGE_DFS_BACK)); #endif - for (e = bb->pred; e; e = e->pred_next) + FOR_EACH_EDGE (e, ei, bb->preds) if (EDGE_INFO (e)->back_edge) { sreal_add (&cyclic_probability, &cyclic_probability, @@ -1252,26 +1681,25 @@ propagate_freq (struct loop *loop) } } - BLOCK_INFO (bb)->tovisit = 0; - - /* Compute back edge frequencies. */ - for (e = bb->succ; e; e = e->succ_next) - if (e->dest == head) - { - sreal tmp; + bitmap_clear_bit (tovisit, bb->index); - /* EDGE_INFO (e)->back_edge_prob - = ((e->probability * BLOCK_INFO (bb)->frequency) - / REG_BR_PROB_BASE); */ - - sreal_init (&tmp, e->probability, 0); - sreal_mul (&tmp, &tmp, &BLOCK_INFO (bb)->frequency); - sreal_mul (&EDGE_INFO (e)->back_edge_prob, - &tmp, &real_inv_br_prob_base); - } + e = find_edge (bb, head); + if (e) + { + sreal tmp; + + /* EDGE_INFO (e)->back_edge_prob + = ((e->probability * BLOCK_INFO (bb)->frequency) + / REG_BR_PROB_BASE); */ + + sreal_init (&tmp, e->probability, 0); + sreal_mul (&tmp, &tmp, &BLOCK_INFO (bb)->frequency); + sreal_mul (&EDGE_INFO (e)->back_edge_prob, + &tmp, &real_inv_br_prob_base); + } /* Propagate to successor blocks. */ - for (e = bb->succ; e; e = e->succ_next) + FOR_EACH_EDGE (e, ei, bb->succs) if (!(e->flags & EDGE_DFS_BACK) && BLOCK_INFO (e->dest)->npredecessors) { @@ -1282,17 +1710,17 @@ propagate_freq (struct loop *loop) nextbb = e->dest; else BLOCK_INFO (last)->next = e->dest; - + last = e->dest; } - } + } } } /* Estimate probabilities of loopback edges in loops at same nest level. */ static void -estimate_loops_at_level (struct loop *first_loop) +estimate_loops_at_level (struct loop *first_loop, bitmap tovisit) { struct loop *loop; @@ -1302,9 +1730,10 @@ estimate_loops_at_level (struct loop *first_loop) basic_block *bbs; unsigned i; - estimate_loops_at_level (loop->inner); + estimate_loops_at_level (loop->inner, tovisit); - if (loop->latch->succ) /* Do not do this for dummy function loop. */ + /* Do not do this for dummy function loop. */ + if (EDGE_COUNT (loop->latch->succs) > 0) { /* Find current loop back edge and mark it. */ e = loop_latch_edge (loop); @@ -1313,16 +1742,16 @@ estimate_loops_at_level (struct loop *first_loop) bbs = get_loop_body (loop); for (i = 0; i < loop->num_nodes; i++) - BLOCK_INFO (bbs[i])->tovisit = 1; + bitmap_set_bit (tovisit, bbs[i]->index); free (bbs); - propagate_freq (loop); + propagate_freq (loop, tovisit); } } /* Convert counts measured by profile driven feedback to frequencies. Return nonzero iff there was any nonzero execution count. */ -static int +int counts_to_freqs (void) { gcov_type count_max, true_count_max = 0; @@ -1351,7 +1780,7 @@ expensive_function_p (int threshold) /* We can not compute accurately for large thresholds due to scaled frequencies. */ - gcc_assert (threshold < BB_FREQ_MAX); + gcc_assert (threshold <= BB_FREQ_MAX); /* Frequencies are out of range. This either means that function contains internal loop executing more than BB_FREQ_MAX times or profile feedback @@ -1389,6 +1818,7 @@ estimate_bb_frequencies (struct loops *loops) if (!flag_branch_probabilities || !counts_to_freqs ()) { static int real_values_initialized = 0; + bitmap tovisit; if (!real_values_initialized) { @@ -1404,17 +1834,18 @@ estimate_bb_frequencies (struct loops *loops) mark_dfs_back_edges (); - ENTRY_BLOCK_PTR->succ->probability = REG_BR_PROB_BASE; + single_succ_edge (ENTRY_BLOCK_PTR)->probability = REG_BR_PROB_BASE; /* Set up block info for each basic block. */ + tovisit = BITMAP_ALLOC (NULL); alloc_aux_for_blocks (sizeof (struct block_info_def)); alloc_aux_for_edges (sizeof (struct edge_info_def)); FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb) { edge e; + edge_iterator ei; - BLOCK_INFO (bb)->tovisit = 0; - for (e = bb->succ; e; e = e->succ_next) + FOR_EACH_EDGE (e, ei, bb->succs) { sreal_init (&EDGE_INFO (e)->back_edge_prob, e->probability, 0); sreal_mul (&EDGE_INFO (e)->back_edge_prob, @@ -1425,7 +1856,7 @@ estimate_bb_frequencies (struct loops *loops) /* First compute probabilities locally for each loop from innermost to outermost to examine probabilities for back edges. */ - estimate_loops_at_level (loops->tree_root); + estimate_loops_at_level (loops->tree_root, tovisit); memcpy (&freq_max, &real_zero, sizeof (real_zero)); FOR_EACH_BB (bb) @@ -1444,6 +1875,7 @@ estimate_bb_frequencies (struct loops *loops) free_aux_for_blocks (); free_aux_for_edges (); + BITMAP_FREE (tovisit); } compute_function_frequency (); if (flag_reorder_functions) @@ -1499,11 +1931,16 @@ choose_function_section (void) UNLIKELY_EXECUTED_TEXT_SECTION_NAME); } +static bool +gate_estimate_probability (void) +{ + return flag_guess_branch_prob; +} struct tree_opt_pass pass_profile = { "profile", /* name */ - NULL, /* gate */ + gate_estimate_probability, /* gate */ tree_estimate_probability, /* execute */ NULL, /* sub */ NULL, /* next */