X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Fpredict.c;h=7be6b90fc3b807c95a4f27be997c42b0281af064;hb=b98c35c607c0cac7532f0a03c16415c9a950bdf7;hp=fbbc1579b39349fe6ee06f33fa9c61423eb3b068;hpb=7edd21a5e41f37f04a18533a5f015e494f42b5c5;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/predict.c b/gcc/predict.c index fbbc1579b39..7be6b90fc3b 100644 --- a/gcc/predict.c +++ b/gcc/predict.c @@ -51,13 +51,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. */ @@ -72,10 +73,10 @@ static sreal real_zero, real_one, real_almost_one, real_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); @@ -247,7 +248,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. */ @@ -286,13 +287,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, @@ -320,11 +323,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 @@ -429,13 +433,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 (EDGE_COUNT (bb->succs) > 1) { BRANCH_EDGE (bb)->probability = combined_probability; FALLTHRU_EDGE (bb)->probability = REG_BR_PROB_BASE - combined_probability; } } + else if (EDGE_COUNT (bb->succs) > 1) + { + int prob = INTVAL (XEXP (prob_note, 0)); + + BRANCH_EDGE (bb)->probability = prob; + FALLTHRU_EDGE (bb)->probability = REG_BR_PROB_BASE - prob; + } + else + EDGE_SUCC (bb, 0)->probability = REG_BR_PROB_BASE; } /* Combine predictions into single probability and store them into CFG. @@ -453,11 +466,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) @@ -537,7 +551,7 @@ combine_predictions_for_bb (FILE *file, basic_block bb) 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); @@ -552,13 +566,16 @@ 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++) @@ -573,7 +590,7 @@ predict_loops (struct loops *loops_info, bool simpleloops) flow_loop_scan (loop, LOOP_EXIT_EDGES); exits = loop->num_exits; - if (simpleloops) + if (rtlsimpleloops) { iv_analysis_loop_init (loop); find_simple_exit (loop, &desc); @@ -595,6 +612,42 @@ predict_loops (struct loops *loops_info, bool simpleloops) prob); } } + else + { + edge *exits; + unsigned j, n_exits; + struct tree_niter_desc niter_desc; + + exits = get_loop_exit_edges (loop, &n_exits); + for (j = 0; j < n_exits; j++) + { + tree niter = NULL; + + if (number_of_iterations_exit (loop, exits[j], &niter_desc)) + 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; + if (host_integerp (niter, 1) + && tree_int_cst_lt (niter, + build_int_cstu (NULL_TREE, + REG_BR_PROB_BASE - 1))) + { + HOST_WIDE_INT nitercst = tree_low_cst (niter, 1) + 1; + probability = (REG_BR_PROB_BASE + nitercst / 2) / nitercst; + } + else + probability = 1; + + predict_edge (exits[j], PRED_LOOP_ITERATIONS, probability); + } + } + + free (exits); + } bbs = get_loop_body (loop); @@ -602,6 +655,7 @@ predict_loops (struct loops *loops_info, bool simpleloops) { int header_found = 0; edge e; + edge_iterator ei; bb = bbs[j]; @@ -609,13 +663,13 @@ 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) + FOR_EACH_EDGE (e, ei, bb->succs) if (e->dest == loop->header && e->src == loop->latch) { @@ -626,7 +680,7 @@ predict_loops (struct loops *loops_info, bool simpleloops) /* 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 @@ -639,6 +693,9 @@ predict_loops (struct loops *loops_info, bool simpleloops) /* Free basic blocks from get_loop_body. */ free (bbs); } + + if (!rtlsimpleloops) + scev_finalize (); } /* Attempt to predict probabilities of BB outgoing edges using local @@ -762,25 +819,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)) + || (EDGE_COUNT (e->dest->succs) == 1 + && EDGE_SUCC (e->dest, 0)->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) @@ -809,37 +867,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) @@ -854,7 +884,138 @@ 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 a 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 (decl) && 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 (build (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 (fndecl) + && 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); + modify_stmt (stmt); + } + } + } +} + /* Predict using opcode of the last statement in basic block. */ static void tree_predict_by_opcode (basic_block bb) @@ -864,17 +1025,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_XMALLOC (); + val = expr_expected_value (cond, visited); + BITMAP_XFREE (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. */ @@ -960,6 +1135,153 @@ 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; + 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; + phi = SSA_NAME_DEF_STMT (return_val); + while (phi) + { + tree next = PHI_CHAIN (phi); + if (PHI_RESULT (phi) == return_val) + break; + phi = next; + } + 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) @@ -971,29 +1293,40 @@ tree_estimate_probability (void) 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 + && EDGE_COUNT (bb->preds) > 1) + { + 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). */ @@ -1029,6 +1362,8 @@ tree_estimate_probability (void) FOR_EACH_BB (bb) combine_predictions_for_bb (dump_file, bb); + if (0) /* FIXME: Enable once we are pass down the profile to RTL level. */ + strip_builtin_expect (); estimate_bb_frequencies (&loops_info); free_dominance_info (CDI_POST_DOMINATORS); remove_fake_exit_edges (); @@ -1123,8 +1458,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)); + && EDGE_COUNT (bb->succs) == 1 + && EDGE_SUCC (bb, 0)->dest->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 @@ -1138,9 +1530,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; @@ -1163,38 +1552,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)); @@ -1207,12 +1610,13 @@ propagate_freq (struct loop *loop) if (bb != head) { #ifdef ENABLE_CHECKING - for (e = bb->pred; e; e = e->pred_next) - if (BLOCK_INFO (e->src)->tovisit && !(e->flags & EDGE_DFS_BACK)) + FOR_EACH_EDGE (e, ei, bb->preds) + if (bitmap_bit_p (tovisit, e->src->index) + && !(e->flags & EDGE_DFS_BACK)) abort (); #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, @@ -1254,18 +1658,18 @@ propagate_freq (struct loop *loop) } } - BLOCK_INFO (bb)->tovisit = 0; + bitmap_clear_bit (tovisit, bb->index); /* Compute back edge frequencies. */ - for (e = bb->succ; e; e = e->succ_next) + FOR_EACH_EDGE (e, ei, bb->succs) if (e->dest == head) { sreal tmp; - + /* EDGE_INFO (e)->back_edge_prob - = ((e->probability * BLOCK_INFO (bb)->frequency) - / REG_BR_PROB_BASE); */ - + = ((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, @@ -1273,7 +1677,7 @@ propagate_freq (struct loop *loop) } /* 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) { @@ -1284,17 +1688,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; @@ -1304,9 +1708,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); @@ -1315,16 +1720,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; @@ -1392,6 +1797,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) { @@ -1407,17 +1813,18 @@ estimate_bb_frequencies (struct loops *loops) mark_dfs_back_edges (); - ENTRY_BLOCK_PTR->succ->probability = REG_BR_PROB_BASE; + EDGE_SUCC (ENTRY_BLOCK_PTR, 0)->probability = REG_BR_PROB_BASE; /* Set up block info for each basic block. */ + tovisit = BITMAP_XMALLOC (); 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, @@ -1428,7 +1835,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) @@ -1447,6 +1854,7 @@ estimate_bb_frequencies (struct loops *loops) free_aux_for_blocks (); free_aux_for_edges (); + BITMAP_XFREE (tovisit); } compute_function_frequency (); if (flag_reorder_functions)