static void estimate_loops_at_level (struct loop *loop);
static void propagate_freq (struct loop *);
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);
{
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. */
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,
{
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
/* 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.
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)
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);
{
int header_found = 0;
edge e;
+ edge_iterator ei;
bb = bbs[j];
/* 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)
{
/* 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
}
if (!rtlsimpleloops)
- scev_reset ();
+ scev_finalize ();
}
/* Attempt to predict probabilities of BB outgoing edges using local
{
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)
/* 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)
return TREE_VALUE (TREE_CHAIN (TREE_OPERAND (expr, 1)));
}
}
- if (TREE_CODE_CLASS (TREE_CODE (expr)) == '2'
- || TREE_CODE_CLASS (TREE_CODE (expr)) == '<')
+ if (BINARY_CLASS_P (expr) || COMPARISON_CLASS_P (expr))
{
tree op0, op1, res;
op0 = expr_expected_value (TREE_OPERAND (expr, 0), visited);
return res;
return NULL;
}
- if (TREE_CODE_CLASS (TREE_CODE (expr)) == '1')
+ if (UNARY_CLASS_P (expr))
{
tree op0, res;
op0 = expr_expected_value (TREE_OPERAND (expr, 0), visited);
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);
}
}
+/* 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)
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). */
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);
}
\f
/* This is used to carry information about basic blocks. It is
{
if (BLOCK_INFO (bb)->tovisit)
{
+ edge_iterator ei;
int count = 0;
- for (e = bb->pred; e; e = e->pred_next)
+ FOR_EACH_EDGE (e, ei, bb->preds)
if (BLOCK_INFO (e->src)->tovisit && !(e->flags & EDGE_DFS_BACK))
count++;
else if (BLOCK_INFO (e->src)->tovisit
last = head;
for (bb = head; bb; bb = nextbb)
{
+ edge_iterator ei;
sreal cyclic_probability, frequency;
memcpy (&cyclic_probability, &real_zero, sizeof (real_zero));
if (bb != head)
{
#ifdef ENABLE_CHECKING
- for (e = bb->pred; e; e = e->pred_next)
+ FOR_EACH_EDGE (e, ei, bb->preds)
if (BLOCK_INFO (e->src)->tovisit && !(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,
BLOCK_INFO (bb)->tovisit = 0;
/* 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,
}
/* 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)
{
nextbb = e->dest;
else
BLOCK_INFO (last)->next = e->dest;
-
+
last = e->dest;
}
- }
+ }
}
}
estimate_loops_at_level (loop->inner);
- 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);
/* 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;
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. */
alloc_aux_for_blocks (sizeof (struct block_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,