/* Transformations based on profile information for values.
- Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008 Free Software
- Foundation, Inc.
+ Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
+ Free Software Foundation, Inc.
This file is part of GCC.
#include "tree-flow.h"
#include "tree-flow-inline.h"
#include "diagnostic.h"
+#include "tree-pretty-print.h"
+#include "gimple-pretty-print.h"
#include "coverage.h"
#include "tree.h"
#include "gcov-io.h"
#include "cgraph.h"
#include "timevar.h"
#include "tree-pass.h"
-#include "toplev.h"
#include "pointer-set.h"
-
-static struct value_prof_hooks *value_prof_hooks;
+#include "profile.h"
/* In this file value profile based optimizations are placed. Currently the
following optimizations are implemented (for more detailed descriptions
histogram_value hist = *(histogram_value *) slot;
if (!pointer_set_contains (visited, hist))
{
- error ("Dead histogram");
+ error ("dead histogram");
dump_histogram_value (stderr, hist);
debug_gimple_stmt (hist->hvalue.stmt);
error_found = true;
/* Verify sanity of the histograms. */
-void
+DEBUG_FUNCTION void
verify_histograms (void)
{
basic_block bb;
: DECL_SOURCE_LOCATION (current_function_decl);
if (flag_profile_correction)
{
- inform (locus, "Correcting inconsistent value profile: "
+ inform (locus, "correcting inconsistent value profile: "
"%s profiler overall count (%d) does not match BB count "
"(%d)", name, (int)*all, (int)bb_count);
*all = bb_count;
}
else
{
- error ("%HCorrupted value profile: %s profiler overall count (%d) "
- "does not match BB count (%d)", &locus, name, (int)*all,
- (int)bb_count);
+ error_at (locus, "corrupted value profile: %s "
+ "profile counter (%d out of %d) inconsistent with "
+ "basic-block count (%d)",
+ name,
+ (int) *count,
+ (int) *all,
+ (int) bb_count);
return true;
}
}
/* GIMPLE based transformations. */
-static bool
+bool
gimple_value_profile_transformations (void)
{
basic_block bb;
gcov_type all)
{
gimple stmt1, stmt2, stmt3;
- tree tmp1, tmp2, tmpv;
+ tree tmp0, tmp1, tmp2, tmpv;
gimple bb1end, bb2end, bb3end;
basic_block bb, bb2, bb3, bb4;
tree optype, op1, op2;
bb = gimple_bb (stmt);
gsi = gsi_for_stmt (stmt);
- tmpv = create_tmp_var (optype, "PROF");
- tmp1 = create_tmp_var (optype, "PROF");
- stmt1 = gimple_build_assign (tmpv, fold_convert (optype, value));
+ tmpv = create_tmp_reg (optype, "PROF");
+ tmp0 = make_ssa_name (tmpv, NULL);
+ tmp1 = make_ssa_name (tmpv, NULL);
+ stmt1 = gimple_build_assign (tmp0, fold_convert (optype, value));
+ SSA_NAME_DEF_STMT (tmp0) = stmt1;
stmt2 = gimple_build_assign (tmp1, op2);
- stmt3 = gimple_build_cond (NE_EXPR, tmp1, tmpv, NULL_TREE, NULL_TREE);
+ SSA_NAME_DEF_STMT (tmp1) = stmt2;
+ stmt3 = gimple_build_cond (NE_EXPR, tmp1, tmp0, NULL_TREE, NULL_TREE);
gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
gsi_insert_before (&gsi, stmt2, GSI_SAME_STMT);
gsi_insert_before (&gsi, stmt3, GSI_SAME_STMT);
bb1end = stmt3;
- tmp2 = create_tmp_var (optype, "PROF");
+ tmp2 = make_rename_temp (optype, "PROF");
stmt1 = gimple_build_assign_with_ops (gimple_assign_rhs_code (stmt), tmp2,
- op1, tmpv);
+ op1, tmp0);
gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
bb2end = stmt1;
e13->count = all - count;
remove_edge (e23);
-
+
e24 = make_edge (bb2, bb4, EDGE_FALLTHRU);
e24->probability = REG_BR_PROB_BASE;
e24->count = count;
return false;
code = gimple_assign_rhs_code (stmt);
-
+
if (code != TRUNC_DIV_EXPR && code != TRUNC_MOD_EXPR)
return false;
}
gimple_assign_set_rhs_from_tree (si, result);
+ update_stmt (gsi_stmt (*si));
return true;
}
/* Generate code for transformation 2 (with parent gimple assign STMT and
probability of taking the optimal path PROB, which is equivalent to COUNT/ALL
- within roundoff error). This generates the result into a temp and returns
+ within roundoff error). This generates the result into a temp and returns
the temp; it does not replace or alter the original STMT. */
static tree
gimple_mod_pow2 (gimple stmt, int prob, gcov_type count, gcov_type all)
{
gimple stmt1, stmt2, stmt3, stmt4;
- tree tmp2, tmp3;
+ tree tmp2, tmp3, tmpv;
gimple bb1end, bb2end, bb3end;
basic_block bb, bb2, bb3, bb4;
tree optype, op1, op2;
bb = gimple_bb (stmt);
gsi = gsi_for_stmt (stmt);
- result = create_tmp_var (optype, "PROF");
- tmp2 = create_tmp_var (optype, "PROF");
- tmp3 = create_tmp_var (optype, "PROF");
+ result = make_rename_temp (optype, "PROF");
+ tmpv = create_tmp_var (optype, "PROF");
+ tmp2 = make_ssa_name (tmpv, NULL);
+ tmp3 = make_ssa_name (tmpv, NULL);
stmt2 = gimple_build_assign_with_ops (PLUS_EXPR, tmp2, op2,
build_int_cst (optype, -1));
+ SSA_NAME_DEF_STMT (tmp2) = stmt2;
stmt3 = gimple_build_assign_with_ops (BIT_AND_EXPR, tmp3, tmp2, op2);
+ SSA_NAME_DEF_STMT (tmp3) = stmt3;
stmt4 = gimple_build_cond (NE_EXPR, tmp3, build_int_cst (optype, 0),
NULL_TREE, NULL_TREE);
gsi_insert_before (&gsi, stmt2, GSI_SAME_STMT);
e13->count = all - count;
remove_edge (e23);
-
+
e24 = make_edge (bb2, bb4, EDGE_FALLTHRU);
e24->probability = REG_BR_PROB_BASE;
e24->count = count;
return false;
code = gimple_assign_rhs_code (stmt);
-
+
if (code != TRUNC_MOD_EXPR || !TYPE_UNSIGNED (lhs_type))
return false;
result = gimple_mod_pow2 (stmt, prob, count, all);
gimple_assign_set_rhs_from_tree (si, result);
+ update_stmt (gsi_stmt (*si));
return true;
}
NCOUNTS the number of cases to support. Currently only NCOUNTS==0 or 1 is
supported and this is built into this interface. The probabilities of taking
the optimal paths are PROB1 and PROB2, which are equivalent to COUNT1/ALL and
- COUNT2/ALL respectively within roundoff error). This generates the
- result into a temp and returns the temp; it does not replace or alter
+ COUNT2/ALL respectively within roundoff error). This generates the
+ result into a temp and returns the temp; it does not replace or alter
the original STMT. */
/* FIXME: Generalize the interface to handle NCOUNTS > 1. */
bb = gimple_bb (stmt);
gsi = gsi_for_stmt (stmt);
- result = create_tmp_var (optype, "PROF");
- tmp1 = create_tmp_var (optype, "PROF");
+ result = make_rename_temp (optype, "PROF");
+ tmp1 = make_ssa_name (create_tmp_var (optype, "PROF"), NULL);
stmt1 = gimple_build_assign (result, op1);
stmt2 = gimple_build_assign (tmp1, op2);
+ SSA_NAME_DEF_STMT (tmp1) = stmt2;
stmt3 = gimple_build_cond (LT_EXPR, result, tmp1, NULL_TREE, NULL_TREE);
gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
gsi_insert_before (&gsi, stmt2, GSI_SAME_STMT);
e12 = split_block (bb, bb1end);
bb2 = e12->dest;
bb2->count = all - count1;
-
+
if (ncounts) /* Assumed to be 0 or 1. */
{
e23 = split_block (bb2, bb2end);
histogram_value histogram;
enum tree_code code;
gcov_type count, wrong_values, all;
- tree lhs_type, result, value;
+ tree lhs_type, result;
gcov_type prob1, prob2;
unsigned int i, steps;
gcov_type count1, count2;
return false;
code = gimple_assign_rhs_code (stmt);
-
+
if (code != TRUNC_MOD_EXPR || !TYPE_UNSIGNED (lhs_type))
return false;
if (!histogram)
return false;
- value = histogram->hvalue.value;
all = 0;
wrong_values = 0;
for (i = 0; i < histogram->hdata.intvl.steps; i++)
result = gimple_mod_subtract (stmt, prob1, prob2, i, count1, count2, all);
gimple_assign_set_rhs_from_tree (si, result);
+ update_stmt (gsi_stmt (*si));
return true;
}
-static struct cgraph_node** pid_map = NULL;
+static VEC(cgraph_node_ptr, heap) *cgraph_node_map = NULL;
-/* Initialize map of pids (pid -> cgraph node) */
+/* Initialize map from FUNCDEF_NO to CGRAPH_NODE. */
-static void
-init_pid_map (void)
+void
+init_node_map (void)
{
struct cgraph_node *n;
- if (pid_map != NULL)
- return;
-
- pid_map
- = (struct cgraph_node**) xmalloc (sizeof (struct cgraph_node*) * cgraph_max_pid);
+ if (get_last_funcdef_no ())
+ VEC_safe_grow_cleared (cgraph_node_ptr, heap,
+ cgraph_node_map, get_last_funcdef_no ());
for (n = cgraph_nodes; n; n = n->next)
{
- if (n->pid != -1)
- pid_map [n->pid] = n;
+ if (DECL_STRUCT_FUNCTION (n->decl))
+ VEC_replace (cgraph_node_ptr, cgraph_node_map,
+ DECL_STRUCT_FUNCTION (n->decl)->funcdef_no, n);
}
}
+/* Delete the CGRAPH_NODE_MAP. */
+
+void
+del_node_map (void)
+{
+ VEC_free (cgraph_node_ptr, heap, cgraph_node_map);
+ cgraph_node_map = NULL;
+}
+
/* Return cgraph node for function with pid */
static inline struct cgraph_node*
-find_func_by_pid (int pid)
+find_func_by_funcdef_no (int func_id)
{
- init_pid_map ();
+ int max_id = get_last_funcdef_no ();
+ if (func_id >= max_id || VEC_index (cgraph_node_ptr,
+ cgraph_node_map,
+ func_id) == NULL)
+ {
+ if (flag_profile_correction)
+ inform (DECL_SOURCE_LOCATION (current_function_decl),
+ "Inconsistent profile: indirect call target (%d) does not exist", func_id);
+ else
+ error ("Inconsistent profile: indirect call target (%d) does not exist", func_id);
- return pid_map [pid];
+ return NULL;
+ }
+
+ return VEC_index (cgraph_node_ptr, cgraph_node_map, func_id);
+}
+
+/* Perform sanity check on the indirect call target. Due to race conditions,
+ false function target may be attributed to an indirect call site. If the
+ call expression type mismatches with the target function's type, expand_call
+ may ICE. Here we only do very minimal sanity check just to make compiler happy.
+ Returns true if TARGET is considered ok for call CALL_STMT. */
+
+static bool
+check_ic_target (gimple call_stmt, struct cgraph_node *target)
+{
+ location_t locus;
+ if (gimple_check_call_matching_types (call_stmt, target->decl))
+ return true;
+
+ locus = gimple_location (call_stmt);
+ inform (locus, "Skipping target %s with mismatching types for icall ",
+ cgraph_node_name (target));
+ return false;
}
/* Do transformation
*/
static gimple
-gimple_ic (gimple stmt, gimple call, struct cgraph_node *direct_call,
+gimple_ic (gimple icall_stmt, struct cgraph_node *direct_call,
int prob, gcov_type count, gcov_type all)
{
- gimple stmt1, stmt2, stmt3;
- tree tmp1, tmpv, tmp;
- gimple bb1end, bb2end, bb3end;
- basic_block bb, bb2, bb3, bb4;
+ gimple dcall_stmt, load_stmt, cond_stmt;
+ tree tmp0, tmp1, tmpv, tmp;
+ basic_block cond_bb, dcall_bb, icall_bb, join_bb = NULL;
tree optype = build_pointer_type (void_type_node);
- edge e12, e13, e23, e24, e34;
+ edge e_cd, e_ci, e_di, e_dj = NULL, e_ij;
gimple_stmt_iterator gsi;
- int region;
+ int lp_nr, dflags;
- bb = gimple_bb (stmt);
- gsi = gsi_for_stmt (stmt);
+ cond_bb = gimple_bb (icall_stmt);
+ gsi = gsi_for_stmt (icall_stmt);
- tmpv = create_tmp_var (optype, "PROF");
- tmp1 = create_tmp_var (optype, "PROF");
- stmt1 = gimple_build_assign (tmpv, unshare_expr (gimple_call_fn (call)));
+ tmpv = create_tmp_reg (optype, "PROF");
+ tmp0 = make_ssa_name (tmpv, NULL);
+ tmp1 = make_ssa_name (tmpv, NULL);
+ tmp = unshare_expr (gimple_call_fn (icall_stmt));
+ load_stmt = gimple_build_assign (tmp0, tmp);
+ SSA_NAME_DEF_STMT (tmp0) = load_stmt;
+ gsi_insert_before (&gsi, load_stmt, GSI_SAME_STMT);
- tmp = fold_convert (optype, build_addr (direct_call->decl,
+ tmp = fold_convert (optype, build_addr (direct_call->decl,
current_function_decl));
- stmt2 = gimple_build_assign (tmp1, tmp);
- stmt3 = gimple_build_cond (NE_EXPR, tmp1, tmpv, NULL_TREE, NULL_TREE);
- gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
- gsi_insert_before (&gsi, stmt2, GSI_SAME_STMT);
- gsi_insert_before (&gsi, stmt3, GSI_SAME_STMT);
- bb1end = stmt3;
-
- stmt1 = gimple_copy (stmt);
- gimple_call_set_fndecl (stmt1, direct_call->decl);
- gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
- bb2end = stmt1;
- bb3end = stmt;
+ load_stmt = gimple_build_assign (tmp1, tmp);
+ SSA_NAME_DEF_STMT (tmp1) = load_stmt;
+ gsi_insert_before (&gsi, load_stmt, GSI_SAME_STMT);
+
+ cond_stmt = gimple_build_cond (EQ_EXPR, tmp1, tmp0, NULL_TREE, NULL_TREE);
+ gsi_insert_before (&gsi, cond_stmt, GSI_SAME_STMT);
+
+ gimple_set_vdef (icall_stmt, NULL_TREE);
+ gimple_set_vuse (icall_stmt, NULL_TREE);
+ update_stmt (icall_stmt);
+ dcall_stmt = gimple_copy (icall_stmt);
+ gimple_call_set_fndecl (dcall_stmt, direct_call->decl);
+ dflags = flags_from_decl_or_type (direct_call->decl);
+ if ((dflags & ECF_NORETURN) != 0)
+ gimple_call_set_lhs (dcall_stmt, NULL_TREE);
+ gsi_insert_before (&gsi, dcall_stmt, GSI_SAME_STMT);
/* Fix CFG. */
- /* Edge e23 connects bb2 to bb3, etc. */
- e12 = split_block (bb, bb1end);
- bb2 = e12->dest;
- bb2->count = count;
- e23 = split_block (bb2, bb2end);
- bb3 = e23->dest;
- bb3->count = all - count;
- e34 = split_block (bb3, bb3end);
- bb4 = e34->dest;
- bb4->count = all;
+ /* Edge e_cd connects cond_bb to dcall_bb, etc; note the first letters. */
+ e_cd = split_block (cond_bb, cond_stmt);
+ dcall_bb = e_cd->dest;
+ dcall_bb->count = count;
+
+ e_di = split_block (dcall_bb, dcall_stmt);
+ icall_bb = e_di->dest;
+ icall_bb->count = all - count;
+
+ /* Do not disturb existing EH edges from the indirect call. */
+ if (!stmt_ends_bb_p (icall_stmt))
+ e_ij = split_block (icall_bb, icall_stmt);
+ else
+ {
+ e_ij = find_fallthru_edge (icall_bb->succs);
+ /* The indirect call might be noreturn. */
+ if (e_ij != NULL)
+ {
+ e_ij->probability = REG_BR_PROB_BASE;
+ e_ij->count = all - count;
+ e_ij = single_pred_edge (split_edge (e_ij));
+ }
+ }
+ if (e_ij != NULL)
+ {
+ join_bb = e_ij->dest;
+ join_bb->count = all;
+ }
- e12->flags &= ~EDGE_FALLTHRU;
- e12->flags |= EDGE_FALSE_VALUE;
- e12->probability = prob;
- e12->count = count;
+ e_cd->flags = (e_cd->flags & ~EDGE_FALLTHRU) | EDGE_TRUE_VALUE;
+ e_cd->probability = prob;
+ e_cd->count = count;
- e13 = make_edge (bb, bb3, EDGE_TRUE_VALUE);
- e13->probability = REG_BR_PROB_BASE - prob;
- e13->count = all - count;
+ e_ci = make_edge (cond_bb, icall_bb, EDGE_FALSE_VALUE);
+ e_ci->probability = REG_BR_PROB_BASE - prob;
+ e_ci->count = all - count;
- remove_edge (e23);
-
- e24 = make_edge (bb2, bb4, EDGE_FALLTHRU);
- e24->probability = REG_BR_PROB_BASE;
- e24->count = count;
- e34->probability = REG_BR_PROB_BASE;
- e34->count = all - count;
+ remove_edge (e_di);
- /* Fix eh edges */
- region = lookup_stmt_eh_region (stmt);
- if (region >= 0 && stmt_could_throw_p (stmt1))
+ if (e_ij != NULL)
{
- add_stmt_to_eh_region (stmt1, region);
- make_eh_edges (stmt1);
+ if ((dflags & ECF_NORETURN) != 0)
+ e_ij->count = all;
+ else
+ {
+ e_dj = make_edge (dcall_bb, join_bb, EDGE_FALLTHRU);
+ e_dj->probability = REG_BR_PROB_BASE;
+ e_dj->count = count;
+
+ e_ij->count = all - count;
+ }
+ e_ij->probability = REG_BR_PROB_BASE;
}
- if (region >= 0 && stmt_could_throw_p (stmt))
+ /* Insert PHI node for the call result if necessary. */
+ if (gimple_call_lhs (icall_stmt)
+ && TREE_CODE (gimple_call_lhs (icall_stmt)) == SSA_NAME
+ && (dflags & ECF_NORETURN) == 0)
{
- gimple_purge_dead_eh_edges (bb4);
- make_eh_edges (stmt);
+ tree result = gimple_call_lhs (icall_stmt);
+ gimple phi = create_phi_node (result, join_bb);
+ SSA_NAME_DEF_STMT (result) = phi;
+ gimple_call_set_lhs (icall_stmt,
+ make_ssa_name (SSA_NAME_VAR (result), icall_stmt));
+ add_phi_arg (phi, gimple_call_lhs (icall_stmt), e_ij, UNKNOWN_LOCATION);
+ gimple_call_set_lhs (dcall_stmt,
+ make_ssa_name (SSA_NAME_VAR (result), dcall_stmt));
+ add_phi_arg (phi, gimple_call_lhs (dcall_stmt), e_dj, UNKNOWN_LOCATION);
}
- return stmt1;
+ /* Build an EH edge for the direct call if necessary. */
+ lp_nr = lookup_stmt_eh_lp (icall_stmt);
+ if (lp_nr != 0
+ && stmt_could_throw_p (dcall_stmt))
+ {
+ edge e_eh, e;
+ edge_iterator ei;
+ gimple_stmt_iterator psi;
+
+ add_stmt_to_eh_lp (dcall_stmt, lp_nr);
+ FOR_EACH_EDGE (e_eh, ei, icall_bb->succs)
+ if (e_eh->flags & EDGE_EH)
+ break;
+ e = make_edge (dcall_bb, e_eh->dest, EDGE_EH);
+ for (psi = gsi_start_phis (e_eh->dest);
+ !gsi_end_p (psi); gsi_next (&psi))
+ {
+ gimple phi = gsi_stmt (psi);
+ SET_USE (PHI_ARG_DEF_PTR_FROM_EDGE (phi, e),
+ PHI_ARG_DEF_FROM_EDGE (phi, e_eh));
+ }
+ }
+
+ return dcall_stmt;
}
/*
histogram_value histogram;
gcov_type val, count, all, bb_all;
gcov_type prob;
- tree callee;
gimple modify;
struct cgraph_node *direct_call;
-
+
if (gimple_code (stmt) != GIMPLE_CALL)
return false;
- callee = gimple_call_fn (stmt);
+ if (gimple_call_fndecl (stmt) != NULL_TREE)
+ return false;
- if (TREE_CODE (callee) == FUNCTION_DECL)
+ if (gimple_call_internal_p (stmt))
return false;
histogram = gimple_histogram_value_of_type (cfun, stmt, HIST_TYPE_INDIR_CALL);
return false;
bb_all = gimple_bb (stmt)->count;
- /* The order of CHECK_COUNTER calls is important -
+ /* The order of CHECK_COUNTER calls is important -
since check_counter can correct the third parameter
and we want to make count <= all <= bb_all. */
if ( check_counter (stmt, "ic", &all, &bb_all, bb_all)
prob = (count * REG_BR_PROB_BASE + all / 2) / all;
else
prob = 0;
- direct_call = find_func_by_pid ((int)val);
+ direct_call = find_func_by_funcdef_no ((int)val);
if (direct_call == NULL)
return false;
- modify = gimple_ic (stmt, stmt, direct_call, prob, count, all);
+ if (!check_ic_target (stmt, direct_call))
+ return false;
+
+ modify = gimple_ic (stmt, direct_call, prob, count, all);
if (dump_file)
{
return true;
}
-/* Return true if the stringop CALL with FNDECL shall be profiled. */
+/* Return true if the stringop CALL with FNDECL shall be profiled.
+ SIZE_ARG be set to the argument index for the size of the string
+ operation.
+*/
static bool
-interesting_stringop_to_profile_p (tree fndecl, gimple call)
+interesting_stringop_to_profile_p (tree fndecl, gimple call, int *size_arg)
{
enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
{
case BUILT_IN_MEMCPY:
case BUILT_IN_MEMPCPY:
+ *size_arg = 2;
return validate_gimple_arglist (call, POINTER_TYPE, POINTER_TYPE,
INTEGER_TYPE, VOID_TYPE);
case BUILT_IN_MEMSET:
+ *size_arg = 2;
return validate_gimple_arglist (call, POINTER_TYPE, INTEGER_TYPE,
INTEGER_TYPE, VOID_TYPE);
case BUILT_IN_BZERO:
+ *size_arg = 1;
return validate_gimple_arglist (call, POINTER_TYPE, INTEGER_TYPE,
VOID_TYPE);
default:
}
}
-/* Convert stringop (..., size)
- into
- if (size == VALUE)
- stringop (...., VALUE);
+/* Convert stringop (..., vcall_size)
+ into
+ if (vcall_size == icall_size)
+ stringop (..., icall_size);
else
- stringop (...., size);
- assuming constant propagation of VALUE will happen later.
-*/
+ stringop (..., vcall_size);
+ assuming we'll propagate a true constant into ICALL_SIZE later. */
+
static void
-gimple_stringop_fixed_value (gimple stmt, tree value, int prob, gcov_type count,
- gcov_type all)
+gimple_stringop_fixed_value (gimple vcall_stmt, tree icall_size, int prob,
+ gcov_type count, gcov_type all)
{
- gimple stmt1, stmt2, stmt3;
- tree tmp1, tmpv;
- gimple bb1end, bb2end;
- basic_block bb, bb2, bb3, bb4;
- edge e12, e13, e23, e24, e34;
+ gimple tmp_stmt, cond_stmt, icall_stmt;
+ tree tmp0, tmp1, tmpv, vcall_size, optype;
+ basic_block cond_bb, icall_bb, vcall_bb, join_bb;
+ edge e_ci, e_cv, e_iv, e_ij, e_vj;
gimple_stmt_iterator gsi;
- tree blck_size = gimple_call_arg (stmt, 2);
- tree optype = TREE_TYPE (blck_size);
- int region;
+ tree fndecl;
+ int size_arg;
- bb = gimple_bb (stmt);
- gsi = gsi_for_stmt (stmt);
+ fndecl = gimple_call_fndecl (vcall_stmt);
+ if (!interesting_stringop_to_profile_p (fndecl, vcall_stmt, &size_arg))
+ gcc_unreachable();
- if (gsi_end_p (gsi))
- {
- edge_iterator ei;
- for (ei = ei_start (bb->succs); (e34 = ei_safe_edge (ei)); )
- if (!e34->flags & EDGE_ABNORMAL)
- break;
- }
- else
- {
- e34 = split_block (bb, stmt);
- gsi = gsi_for_stmt (stmt);
- }
- bb4 = e34->dest;
+ cond_bb = gimple_bb (vcall_stmt);
+ gsi = gsi_for_stmt (vcall_stmt);
- tmpv = create_tmp_var (optype, "PROF");
- tmp1 = create_tmp_var (optype, "PROF");
- stmt1 = gimple_build_assign (tmpv, fold_convert (optype, value));
- stmt2 = gimple_build_assign (tmp1, blck_size);
- stmt3 = gimple_build_cond (NE_EXPR, tmp1, tmpv, NULL_TREE, NULL_TREE);
- gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
- gsi_insert_before (&gsi, stmt2, GSI_SAME_STMT);
- gsi_insert_before (&gsi, stmt3, GSI_SAME_STMT);
- bb1end = stmt3;
+ vcall_size = gimple_call_arg (vcall_stmt, size_arg);
+ optype = TREE_TYPE (vcall_size);
- stmt1 = gimple_copy (stmt);
- gimple_call_set_arg (stmt1, 2, value);
- gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
- region = lookup_stmt_eh_region (stmt);
- if (region >= 0)
- add_stmt_to_eh_region (stmt1, region);
- bb2end = stmt1;
+ tmpv = create_tmp_var (optype, "PROF");
+ tmp0 = make_ssa_name (tmpv, NULL);
+ tmp1 = make_ssa_name (tmpv, NULL);
+ tmp_stmt = gimple_build_assign (tmp0, fold_convert (optype, icall_size));
+ SSA_NAME_DEF_STMT (tmp0) = tmp_stmt;
+ gsi_insert_before (&gsi, tmp_stmt, GSI_SAME_STMT);
+
+ tmp_stmt = gimple_build_assign (tmp1, vcall_size);
+ SSA_NAME_DEF_STMT (tmp1) = tmp_stmt;
+ gsi_insert_before (&gsi, tmp_stmt, GSI_SAME_STMT);
+
+ cond_stmt = gimple_build_cond (EQ_EXPR, tmp1, tmp0, NULL_TREE, NULL_TREE);
+ gsi_insert_before (&gsi, cond_stmt, GSI_SAME_STMT);
+
+ gimple_set_vdef (vcall_stmt, NULL);
+ gimple_set_vuse (vcall_stmt, NULL);
+ update_stmt (vcall_stmt);
+ icall_stmt = gimple_copy (vcall_stmt);
+ gimple_call_set_arg (icall_stmt, size_arg, icall_size);
+ gsi_insert_before (&gsi, icall_stmt, GSI_SAME_STMT);
/* Fix CFG. */
- /* Edge e23 connects bb2 to bb3, etc. */
- e12 = split_block (bb, bb1end);
- bb2 = e12->dest;
- bb2->count = count;
- e23 = split_block (bb2, bb2end);
- bb3 = e23->dest;
- bb3->count = all - count;
+ /* Edge e_ci connects cond_bb to icall_bb, etc. */
+ e_ci = split_block (cond_bb, cond_stmt);
+ icall_bb = e_ci->dest;
+ icall_bb->count = count;
- e12->flags &= ~EDGE_FALLTHRU;
- e12->flags |= EDGE_FALSE_VALUE;
- e12->probability = prob;
- e12->count = count;
+ e_iv = split_block (icall_bb, icall_stmt);
+ vcall_bb = e_iv->dest;
+ vcall_bb->count = all - count;
- e13 = make_edge (bb, bb3, EDGE_TRUE_VALUE);
- e13->probability = REG_BR_PROB_BASE - prob;
- e13->count = all - count;
+ e_vj = split_block (vcall_bb, vcall_stmt);
+ join_bb = e_vj->dest;
+ join_bb->count = all;
- remove_edge (e23);
-
- e24 = make_edge (bb2, bb4, EDGE_FALLTHRU);
- e24->probability = REG_BR_PROB_BASE;
- e24->count = count;
+ e_ci->flags = (e_ci->flags & ~EDGE_FALLTHRU) | EDGE_TRUE_VALUE;
+ e_ci->probability = prob;
+ e_ci->count = count;
- e34->probability = REG_BR_PROB_BASE;
- e34->count = all - count;
+ e_cv = make_edge (cond_bb, vcall_bb, EDGE_FALSE_VALUE);
+ e_cv->probability = REG_BR_PROB_BASE - prob;
+ e_cv->count = all - count;
+
+ remove_edge (e_iv);
+
+ e_ij = make_edge (icall_bb, join_bb, EDGE_FALLTHRU);
+ e_ij->probability = REG_BR_PROB_BASE;
+ e_ij->count = count;
+
+ e_vj->probability = REG_BR_PROB_BASE;
+ e_vj->count = all - count;
+
+ /* Insert PHI node for the call result if necessary. */
+ if (gimple_call_lhs (vcall_stmt)
+ && TREE_CODE (gimple_call_lhs (vcall_stmt)) == SSA_NAME)
+ {
+ tree result = gimple_call_lhs (vcall_stmt);
+ gimple phi = create_phi_node (result, join_bb);
+ SSA_NAME_DEF_STMT (result) = phi;
+ gimple_call_set_lhs (vcall_stmt,
+ make_ssa_name (SSA_NAME_VAR (result), vcall_stmt));
+ add_phi_arg (phi, gimple_call_lhs (vcall_stmt), e_vj, UNKNOWN_LOCATION);
+ gimple_call_set_lhs (icall_stmt,
+ make_ssa_name (SSA_NAME_VAR (result), icall_stmt));
+ add_phi_arg (phi, gimple_call_lhs (icall_stmt), e_ij, UNKNOWN_LOCATION);
+ }
+
+ /* Because these are all string op builtins, they're all nothrow. */
+ gcc_assert (!stmt_could_throw_p (vcall_stmt));
+ gcc_assert (!stmt_could_throw_p (icall_stmt));
}
/* Find values inside STMT for that we want to measure histograms for
enum built_in_function fcode;
histogram_value histogram;
gcov_type count, all, val;
- tree value;
tree dest, src;
unsigned int dest_align, src_align;
gcov_type prob;
tree tree_val;
+ int size_arg;
if (gimple_code (stmt) != GIMPLE_CALL)
return false;
if (!fndecl)
return false;
fcode = DECL_FUNCTION_CODE (fndecl);
- if (!interesting_stringop_to_profile_p (fndecl, stmt))
+ if (!interesting_stringop_to_profile_p (fndecl, stmt, &size_arg))
return false;
- if (fcode == BUILT_IN_BZERO)
- blck_size = gimple_call_arg (stmt, 1);
- else
- blck_size = gimple_call_arg (stmt, 2);
+ blck_size = gimple_call_arg (stmt, size_arg);
if (TREE_CODE (blck_size) == INTEGER_CST)
return false;
histogram = gimple_histogram_value_of_type (cfun, stmt, HIST_TYPE_SINGLE_VALUE);
if (!histogram)
return false;
- value = histogram->hvalue.value;
val = histogram->hvalue.counters[0];
count = histogram->hvalue.counters[1];
all = histogram->hvalue.counters[2];
else
prob = 0;
dest = gimple_call_arg (stmt, 0);
- dest_align = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
+ dest_align = get_pointer_alignment (dest);
switch (fcode)
{
case BUILT_IN_MEMCPY:
case BUILT_IN_MEMPCPY:
src = gimple_call_arg (stmt, 1);
- src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
+ src_align = get_pointer_alignment (src);
if (!can_move_by_pieces (val, MIN (dest_align, src_align)))
return false;
break;
print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
}
gimple_stringop_fixed_value (stmt, tree_val, prob, count, all);
-
+
return true;
}
}
}
-struct value_prof_hooks {
- /* Find list of values for which we want to measure histograms. */
- void (*find_values_to_profile) (histogram_values *);
-
- /* Identify and exploit properties of values that are hard to analyze
- statically. See value-prof.c for more detail. */
- bool (*value_profile_transformations) (void);
-};
\f
/* Find values inside STMT for that we want to measure histograms for
division/modulo optimization. */
}
}
-/* Find calls inside STMT for that we want to measure histograms for
- indirect/virtual call optimization. */
+/* Find calls inside STMT for that we want to measure histograms for
+ indirect/virtual call optimization. */
static void
gimple_indirect_call_to_profile (gimple stmt, histogram_values *values)
tree callee;
if (gimple_code (stmt) != GIMPLE_CALL
+ || gimple_call_internal_p (stmt)
|| gimple_call_fndecl (stmt) != NULL_TREE)
return;
VEC_reserve (histogram_value, heap, *values, 3);
- VEC_quick_push (histogram_value, *values,
+ VEC_quick_push (histogram_value, *values,
gimple_alloc_histogram_value (cfun, HIST_TYPE_INDIR_CALL,
stmt, callee));
tree fndecl;
tree blck_size;
tree dest;
- enum built_in_function fcode;
+ int size_arg;
if (gimple_code (stmt) != GIMPLE_CALL)
return;
fndecl = gimple_call_fndecl (stmt);
if (!fndecl)
return;
- fcode = DECL_FUNCTION_CODE (fndecl);
- if (!interesting_stringop_to_profile_p (fndecl, stmt))
+ if (!interesting_stringop_to_profile_p (fndecl, stmt, &size_arg))
return;
dest = gimple_call_arg (stmt, 0);
- if (fcode == BUILT_IN_BZERO)
- blck_size = gimple_call_arg (stmt, 1);
- else
- blck_size = gimple_call_arg (stmt, 2);
+ blck_size = gimple_call_arg (stmt, size_arg);
if (TREE_CODE (blck_size) != INTEGER_CST)
{
}
}
-static void
+void
gimple_find_values_to_profile (histogram_values *values)
{
basic_block bb;
FOR_EACH_BB (bb)
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
gimple_values_to_profile (gsi_stmt (gsi), values);
-
- for (i = 0; VEC_iterate (histogram_value, *values, i, hist); i++)
+
+ FOR_EACH_VEC_ELT (histogram_value, *values, i, hist)
{
switch (hist->type)
{
}
}
}
-
-static struct value_prof_hooks gimple_value_prof_hooks = {
- gimple_find_values_to_profile,
- gimple_value_profile_transformations
-};
-
-void
-gimple_register_value_prof_hooks (void)
-{
- gcc_assert (current_ir_type () == IR_GIMPLE);
- value_prof_hooks = &gimple_value_prof_hooks;
-}
-\f
-/* IR-independent entry points. */
-void
-find_values_to_profile (histogram_values *values)
-{
- (value_prof_hooks->find_values_to_profile) (values);
-}
-
-bool
-value_profile_transformations (void)
-{
- return (value_prof_hooks->value_profile_transformations) ();
-}
-\f