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:
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;
static void
predict_insn (rtx insn, enum br_predictor predictor, int probability)
{
- if (!any_condjump_p (insn))
- abort ();
+ gcc_assert (any_condjump_p (insn));
if (!flag_guess_branch_prob)
return;
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.
{
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);
/* 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;
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;
dump_prediction (file, predictor, probability, bb,
!first_match || best_predictor == predictor);
}
- bb_ann (bb)->predictions = NULL;
+ bb->predictions = NULL;
if (!bb->count)
{
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);
{
tree niter = NULL;
- if (number_of_iterations_exit (loop, exits[j], &niter_desc))
+ 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,
- REG_BR_PROB_BASE - 1)))
+ 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;
+ probability = ((REG_BR_PROB_BASE + nitercst / 2)
+ / nitercst);
}
else
- probability = 1;
+ probability = ((REG_BR_PROB_BASE + max / 2) / max);
predict_edge (exits[j], PRED_LOOP_ITERATIONS, probability);
}
op1 = expr_expected_value (TREE_OPERAND (expr, 1), visited);
if (!op1)
return NULL;
- res = fold (build (TREE_CODE (expr), TREE_TYPE (expr), op0, op1));
+ res = fold_build2 (TREE_CODE (expr), TREE_TYPE (expr), op0, op1);
if (TREE_CONSTANT (res))
return res;
return NULL;
op0 = expr_expected_value (TREE_OPERAND (expr, 0), visited);
if (!op0)
return NULL;
- res = fold (build1 (TREE_CODE (expr), TREE_TYPE (expr), op0));
+ res = fold_build1 (TREE_CODE (expr), TREE_TYPE (expr), op0);
if (TREE_CONSTANT (res))
return res;
return NULL;
&& TREE_CHAIN (arglist))
{
TREE_OPERAND (stmt, 1) = TREE_VALUE (arglist);
- modify_stmt (stmt);
+ update_stmt (stmt);
}
}
}
static void
apply_return_prediction (int *heads)
{
- tree return_stmt;
+ tree return_stmt = NULL;
tree return_val;
edge e;
tree phi;
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. */
+ if (!flag_loop_optimize)
strip_builtin_expect ();
estimate_bb_frequencies (&loops_info);
free_dominance_info (CDI_POST_DOMINATORS);
cond = simplify_rtx (cond);
/* Turn the condition into a scaled branch probability. */
- if (cond != const_true_rtx && cond != const0_rtx)
- abort ();
+ gcc_assert (cond == const_true_rtx || cond == const0_rtx);
predict_insn_def (insn, PRED_BUILTIN_EXPECT,
cond == const_true_rtx ? TAKEN : NOT_TAKEN);
}
/* 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;
{
#ifdef ENABLE_CHECKING
FOR_EACH_EDGE (e, ei, bb->preds)
- if (bitmap_bit_p (tovisit, e->src->index)
- && !(e->flags & EDGE_DFS_BACK))
- abort ();
+ gcc_assert (!bitmap_bit_p (tovisit, e->src->index)
+ || (e->flags & EDGE_DFS_BACK));
#endif
FOR_EACH_EDGE (e, ei, bb->preds)
/* We can not compute accurately for large thresholds due to scaled
frequencies. */
- if (threshold > BB_FREQ_MAX)
- abort ();
+ 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
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 */
OSDN Git Service
