Skip to content

R
riscv-gcc-1
Commit 1f1e8527 by Dale Johannesen Committed by Jan Hubicka
Options

Makefile.in (value-prof.o): New dependencies on $(DIAGNOSTIC_H) $(TREE_H) and $(COVERAGE_H). 

	* Makefile.in (value-prof.o): New dependencies on $(DIAGNOSTIC_H)
	$(TREE_H) and $(COVERAGE_H).
	* coverage.c (compute_checksum): Use DECL_NAME not DECL_ASSEMBLER_NAME.
	* opts.c (common_handle_option): Enable tree-based value transforms.
	* toplev.c (process_options): Ditto.
	* value-prof.h (struct histogram_value_t): Redefine. "Adjust" below
	refers to references to this type.
	* tree-flow.h: (struct stmt_ann_d): Add histograms field.
	* rtl-profile.c (rtl_gen_interval_profiler): Adjust. Remove checks
	for may_be_more, may_be_less.
	(rtl_gen_pow2_profiler): Adjust.
	(rtl_gen_one_value_profiler_no_edge_manip): Adjust.
	(rtl_gen_one_value_profiler): Adjust.
	(rtl_gen_const_delta_profiler): Adjust.
	* tree-profile.c (tree_gen_interval_profiler): Implement.
	(tree_gen_pow2_profiler): Ditto.
	(tree_gen_one_value_profiler): Ditto.
	(tree_profiling): New.
	(pass_tree_profile): Reference it.
	* value-prof.c: Include tree-flow.h, tree-flow-inline.h, diagnostic.h,
	tree.h, gcov-io.h.
	(insn_divmod_values_to_profile): Rename to
	rtl_divmod_values_to_profile. Adjust.
	(insn_values_to_profile): Rename to rtl_values_to_profile. Adjust.
	(insn_prefetch_values_to_profile): Adjust.
	(rtl_value_profile_transformations): Adjust.
	(gen_divmod_fixed_value): Rename to rtl_divmod_fixed_value.
	(gen_mod_pow2): Rename to rtl_mod_pow2.
	(gen_mod_subtract): Rename to rtl_mod_subtract.
	(divmod_fixed_value_transform): Rename to
	rtl_divmod_fixed_value_transform.
	(mod_pow2_value_transform): Rename to rtl_mod_pow2_value_transform.
	(mod_subtract_transform): Rename to rtl_mod_subtract_transform.
	(rtl_find_values_to_profile): Adjust.
	(tree_value_profile_transformations): Implement.
	(tree_divmod_values_to_profile): New.
	(tree_values_to_profile): New.
	(tree_divmod_fixed_value): New.
	(tree_mod_pow2): New.
	(tree_mod_subtract): New.
	(tree_divmod_fixed_value_transform): New.
	(tree_mod_pow2_value_transform): New.
	(tree_mod_subtract_transform): New.
	(tree_find_values_to_profile): Implement.
	* profile.c (instrument_values):  Free histograms.
	(compute_value_histograms): Adjust. Implement tree version.

From-SVN: r97156
parent 82498ed4
Showing with 1435 additions and 232 deletions
gcc/ChangeLog
2005-03-29 Dale Johannesen <dalej@apple.com>
* Makefile.in (value-prof.o): New dependencies on $(DIAGNOSTIC_H)
$(TREE_H) and $(COVERAGE_H).
* coverage.c (compute_checksum): Use DECL_NAME not DECL_ASSEMBLER_NAME.
* opts.c (common_handle_option): Enable tree-based value transforms.
* toplev.c (process_options): Ditto.
* value-prof.h (struct histogram_value_t): Redefine. "Adjust" below
refers to references to this type.
* tree-flow.h: (struct stmt_ann_d): Add histograms field.
* rtl-profile.c (rtl_gen_interval_profiler): Adjust. Remove checks
for may_be_more, may_be_less.
(rtl_gen_pow2_profiler): Adjust.
(rtl_gen_one_value_profiler_no_edge_manip): Adjust.
(rtl_gen_one_value_profiler): Adjust.
(rtl_gen_const_delta_profiler): Adjust.
* tree-profile.c (tree_gen_interval_profiler): Implement.
(tree_gen_pow2_profiler): Ditto.
(tree_gen_one_value_profiler): Ditto.
(tree_profiling): New.
(pass_tree_profile): Reference it.
* value-prof.c: Include tree-flow.h, tree-flow-inline.h, diagnostic.h,
tree.h, gcov-io.h.
(insn_divmod_values_to_profile): Rename to
rtl_divmod_values_to_profile. Adjust.
(insn_values_to_profile): Rename to rtl_values_to_profile. Adjust.
(insn_prefetch_values_to_profile): Adjust.
(rtl_value_profile_transformations): Adjust.
(gen_divmod_fixed_value): Rename to rtl_divmod_fixed_value.
(gen_mod_pow2): Rename to rtl_mod_pow2.
(gen_mod_subtract): Rename to rtl_mod_subtract.
(divmod_fixed_value_transform): Rename to
rtl_divmod_fixed_value_transform.
(mod_pow2_value_transform): Rename to rtl_mod_pow2_value_transform.
(mod_subtract_transform): Rename to rtl_mod_subtract_transform.
(rtl_find_values_to_profile): Adjust.
(tree_value_profile_transformations): Implement.
(tree_divmod_values_to_profile): New.
(tree_values_to_profile): New.
(tree_divmod_fixed_value): New.
(tree_mod_pow2): New.
(tree_mod_subtract): New.
(tree_divmod_fixed_value_transform): New.
(tree_mod_pow2_value_transform): New.
(tree_mod_subtract_transform): New.
(tree_find_values_to_profile): Implement.
* profile.c (instrument_values): Free histograms.
(compute_value_histograms): Adjust. Implement tree version.
2005-03-29 Uros Bizjak <uros@kss-loka.si> 2005-03-29 Uros Bizjak <uros@kss-loka.si>
* reg-stack.c (subst_stack_regs_pat): Handle <UNSPEC_FIST> case. * reg-stack.c (subst_stack_regs_pat): Handle <UNSPEC_FIST> case.
......
gcc/Makefile.in
...@@ -2023,7 +2023,8 @@ rtl-profile.o : tree-profile.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \ ...@@ -2023,7 +2023,8 @@ rtl-profile.o : tree-profile.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \
toplev.h $(BASIC_BLOCK_H) $(COVERAGE_H) $(TREE_FLOW_H) value-prof.h $(GGC_H) toplev.h $(BASIC_BLOCK_H) $(COVERAGE_H) $(TREE_FLOW_H) value-prof.h $(GGC_H)
value-prof.o : value-prof.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(RTL_H) \ value-prof.o : value-prof.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(RTL_H) \
$(BASIC_BLOCK_H) hard-reg-set.h value-prof.h $(EXPR_H) output.h $(FLAGS_H) \ $(BASIC_BLOCK_H) hard-reg-set.h value-prof.h $(EXPR_H) output.h $(FLAGS_H) \
$(RECOG_H) insn-config.h $(OPTABS_H) $(REGS_H) $(GGC_H) $(RECOG_H) insn-config.h $(OPTABS_H) $(REGS_H) $(GGC_H) $(DIAGNOSTIC_H) \
$(TREE_H) $(COVERAGE_H)
loop.o : loop.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(RTL_H) $(FLAGS_H) \ loop.o : loop.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(RTL_H) $(FLAGS_H) \
insn-config.h $(REGS_H) hard-reg-set.h $(RECOG_H) $(EXPR_H) \ insn-config.h $(REGS_H) hard-reg-set.h $(RECOG_H) $(EXPR_H) \
real.h $(PREDICT_H) $(BASIC_BLOCK_H) function.h $(CFGLOOP_H) \ real.h $(PREDICT_H) $(BASIC_BLOCK_H) function.h $(CFGLOOP_H) \
......
gcc/profile.c
...@@ -224,6 +224,7 @@ instrument_values (histogram_values values) ...@@ -224,6 +224,7 @@ instrument_values (histogram_values values)
abort (); abort ();
} }
} }
VEC_free (histogram_value, values);
} }
...@@ -641,7 +642,7 @@ compute_branch_probabilities (void) ...@@ -641,7 +642,7 @@ compute_branch_probabilities (void)
} }
/* Load value histograms values whose description is stored in VALUES array /* Load value histograms values whose description is stored in VALUES array
from .da file. */ from .gcda file. */
static void static void
compute_value_histograms (histogram_values values) compute_value_histograms (histogram_values values)
...@@ -688,21 +689,32 @@ compute_value_histograms (histogram_values values) ...@@ -688,21 +689,32 @@ compute_value_histograms (histogram_values values)
hist = VEC_index (histogram_value, values, i); hist = VEC_index (histogram_value, values, i);
t = (int) hist->type; t = (int) hist->type;
/* FIXME: make this work for trees. */ aact_count = act_count[t];
act_count[t] += hist->n_counters;
if (!ir_type ()) if (!ir_type ())
{ {
aact_count = act_count[t];
act_count[t] += hist->n_counters;
for (j = hist->n_counters; j > 0; j--) for (j = hist->n_counters; j > 0; j--)
hist_list = alloc_EXPR_LIST (0, GEN_INT (aact_count[j - 1]), hist_list = alloc_EXPR_LIST (0, GEN_INT (aact_count[j - 1]),
hist_list); hist_list);
hist_list = alloc_EXPR_LIST (0, hist_list = alloc_EXPR_LIST (0,
copy_rtx ((rtx) hist->value), hist_list); copy_rtx (hist->hvalue.rtl.value), hist_list);
hist_list = alloc_EXPR_LIST (0, GEN_INT (hist->type), hist_list); hist_list = alloc_EXPR_LIST (0, GEN_INT (hist->type), hist_list);
REG_NOTES ((rtx) hist->insn) = REG_NOTES (hist->hvalue.rtl.insn) =
alloc_EXPR_LIST (REG_VALUE_PROFILE, hist_list, alloc_EXPR_LIST (REG_VALUE_PROFILE, hist_list,
REG_NOTES ((rtx) hist->insn)); REG_NOTES (hist->hvalue.rtl.insn));
} }
else
{
tree stmt = hist->hvalue.tree.stmt;
stmt_ann_t ann = get_stmt_ann (stmt);
hist->hvalue.tree.next = ann->histograms;
ann->histograms = hist;
hist->hvalue.tree.counters =
xmalloc (sizeof (gcov_type) * hist->n_counters);
for (j = 0; j < hist->n_counters; j++)
hist->hvalue.tree.counters[j] = aact_count[j];
}
} }
for (t = 0; t < GCOV_N_VALUE_COUNTERS; t++) for (t = 0; t < GCOV_N_VALUE_COUNTERS; t++)
......
gcc/rtl-profile.c
...@@ -23,30 +23,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA ...@@ -23,30 +23,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA. */ 02111-1307, USA. */
/* Generate basic block profile instrumentation and auxiliary files. /* Generate basic block profile instrumentation and auxiliary files.
Profile generation is optimized, so that not all arcs in the basic RTL-based version. See profile.c for overview. */
block graph need instrumenting. First, the BB graph is closed with
one entry (function start), and one exit (function exit). Any
ABNORMAL_EDGE cannot be instrumented (because there is no control
path to place the code). We close the graph by inserting fake
EDGE_FAKE edges to the EXIT_BLOCK, from the sources of abnormal
edges that do not go to the exit_block. We ignore such abnormal
edges. Naturally these fake edges are never directly traversed,
and so *cannot* be directly instrumented. Some other graph
massaging is done. To optimize the instrumentation we generate the
BB minimal span tree, only edges that are not on the span tree
(plus the entry point) need instrumenting. From that information
all other edge counts can be deduced. By construction all fake
edges must be on the spanning tree. We also attempt to place
EDGE_CRITICAL edges on the spanning tree.
The auxiliary file generated is <dumpbase>.bbg. The format is
described in full in gcov-io.h. */
/* ??? Register allocation should use basic block execution counts to
give preference to the most commonly executed blocks. */
/* ??? Should calculate branch probabilities before instrumenting code, since
then we can use arc counts to help decide which arcs to instrument. */
#include "config.h" #include "config.h"
#include "system.h" #include "system.h"
...@@ -114,33 +91,33 @@ rtl_gen_interval_profiler (histogram_value value, unsigned tag, unsigned base) ...@@ -114,33 +91,33 @@ rtl_gen_interval_profiler (histogram_value value, unsigned tag, unsigned base)
rtx less_label = gen_label_rtx (); rtx less_label = gen_label_rtx ();
rtx end_of_code_label = gen_label_rtx (); rtx end_of_code_label = gen_label_rtx ();
int per_counter = gcov_size / BITS_PER_UNIT; int per_counter = gcov_size / BITS_PER_UNIT;
edge e = split_block (BLOCK_FOR_INSN ((rtx)value->insn), edge e = split_block (BLOCK_FOR_INSN (value->hvalue.rtl.insn),
PREV_INSN ((rtx)value->insn)); PREV_INSN (value->hvalue.rtl.insn));
start_sequence (); start_sequence ();
if (value->seq) if (value->hvalue.rtl.seq)
emit_insn (value->seq); emit_insn (value->hvalue.rtl.seq);
mr = gen_reg_rtx (Pmode); mr = gen_reg_rtx (Pmode);
tmp = rtl_coverage_counter_ref (tag, base); tmp = rtl_coverage_counter_ref (tag, base);
tmp = force_reg (Pmode, XEXP (tmp, 0)); tmp = force_reg (Pmode, XEXP (tmp, 0));
val = expand_simple_binop (value->mode, MINUS, val = expand_simple_binop (value->hvalue.rtl.mode, MINUS,
copy_rtx (value->value), copy_rtx (value->hvalue.rtl.value),
GEN_INT (value->hdata.intvl.int_start), GEN_INT (value->hdata.intvl.int_start),
NULL_RTX, 0, OPTAB_WIDEN); NULL_RTX, 0, OPTAB_WIDEN);
if (value->hdata.intvl.may_be_more)
do_compare_rtx_and_jump (copy_rtx (val), GEN_INT (value->hdata.intvl.steps), do_compare_rtx_and_jump (copy_rtx (val), GEN_INT (value->hdata.intvl.steps),
GE, 0, value->mode, NULL_RTX, NULL_RTX, more_label); GE, 0, value->hvalue.rtl.mode, NULL_RTX, NULL_RTX,
if (value->hdata.intvl.may_be_less) more_label);
do_compare_rtx_and_jump (copy_rtx (val), const0_rtx, LT, 0, value->mode, do_compare_rtx_and_jump (copy_rtx (val), const0_rtx, LT, 0,
value->hvalue.rtl.mode,
NULL_RTX, NULL_RTX, less_label); NULL_RTX, NULL_RTX, less_label);
/* We are in range. */ /* We are in range. */
tmp1 = expand_simple_binop (value->mode, MULT, tmp1 = expand_simple_binop (value->hvalue.rtl.mode, MULT,
copy_rtx (val), GEN_INT (per_counter), copy_rtx (val), GEN_INT (per_counter),
NULL_RTX, 0, OPTAB_WIDEN); NULL_RTX, 0, OPTAB_WIDEN);
tmp1 = expand_simple_binop (Pmode, PLUS, copy_rtx (tmp), tmp1, mr, tmp1 = expand_simple_binop (Pmode, PLUS, copy_rtx (tmp), tmp1, mr,
...@@ -148,43 +125,27 @@ rtl_gen_interval_profiler (histogram_value value, unsigned tag, unsigned base) ...@@ -148,43 +125,27 @@ rtl_gen_interval_profiler (histogram_value value, unsigned tag, unsigned base)
if (tmp1 != mr) if (tmp1 != mr)
emit_move_insn (copy_rtx (mr), tmp1); emit_move_insn (copy_rtx (mr), tmp1);
if (value->hdata.intvl.may_be_more
|| value->hdata.intvl.may_be_less)
{
emit_jump_insn (gen_jump (end_of_code_label)); emit_jump_insn (gen_jump (end_of_code_label));
emit_barrier (); emit_barrier ();
}
/* Above the interval. */ /* Above the interval. */
if (value->hdata.intvl.may_be_more)
{
emit_label (more_label); emit_label (more_label);
tmp1 = expand_simple_binop (Pmode, PLUS, copy_rtx (tmp), tmp1 = expand_simple_binop (Pmode, PLUS, copy_rtx (tmp),
GEN_INT (per_counter * value->hdata.intvl.steps), GEN_INT (per_counter * value->hdata.intvl.steps),
mr, 0, OPTAB_WIDEN); mr, 0, OPTAB_WIDEN);
if (tmp1 != mr) if (tmp1 != mr)
emit_move_insn (copy_rtx (mr), tmp1); emit_move_insn (copy_rtx (mr), tmp1);
if (value->hdata.intvl.may_be_less)
{
emit_jump_insn (gen_jump (end_of_code_label)); emit_jump_insn (gen_jump (end_of_code_label));
emit_barrier (); emit_barrier ();
}
}
/* Below the interval. */ /* Below the interval. */
if (value->hdata.intvl.may_be_less)
{
emit_label (less_label); emit_label (less_label);
tmp1 = expand_simple_binop (Pmode, PLUS, copy_rtx (tmp), tmp1 = expand_simple_binop (Pmode, PLUS, copy_rtx (tmp),
GEN_INT (per_counter * (value->hdata.intvl.steps GEN_INT (per_counter * (value->hdata.intvl.steps +1)),
+ (value->hdata.intvl.may_be_more ? 1 : 0))),
mr, 0, OPTAB_WIDEN); mr, 0, OPTAB_WIDEN);
if (tmp1 != mr) if (tmp1 != mr)
emit_move_insn (copy_rtx (mr), tmp1); emit_move_insn (copy_rtx (mr), tmp1);
}
if (value->hdata.intvl.may_be_more
|| value->hdata.intvl.may_be_less)
emit_label (end_of_code_label); emit_label (end_of_code_label);
mem_ref = validize_mem (gen_rtx_MEM (mode, mr)); mem_ref = validize_mem (gen_rtx_MEM (mode, mr));
...@@ -215,32 +176,32 @@ rtl_gen_pow2_profiler (histogram_value value, unsigned tag, unsigned base) ...@@ -215,32 +176,32 @@ rtl_gen_pow2_profiler (histogram_value value, unsigned tag, unsigned base)
rtx end_of_code_label = gen_label_rtx (); rtx end_of_code_label = gen_label_rtx ();
rtx loop_label = gen_label_rtx (); rtx loop_label = gen_label_rtx ();
int per_counter = gcov_size / BITS_PER_UNIT; int per_counter = gcov_size / BITS_PER_UNIT;
edge e = split_block (BLOCK_FOR_INSN ((rtx)value->insn), edge e = split_block (BLOCK_FOR_INSN (value->hvalue.rtl.insn),
PREV_INSN ((rtx)value->insn)); PREV_INSN (value->hvalue.rtl.insn));
start_sequence (); start_sequence ();
if (value->seq) if (value->hvalue.rtl.seq)
emit_insn (value->seq); emit_insn (value->hvalue.rtl.seq);
mr = gen_reg_rtx (Pmode); mr = gen_reg_rtx (Pmode);
tmp = rtl_coverage_counter_ref (tag, base); tmp = rtl_coverage_counter_ref (tag, base);
tmp = force_reg (Pmode, XEXP (tmp, 0)); tmp = force_reg (Pmode, XEXP (tmp, 0));
emit_move_insn (mr, tmp); emit_move_insn (mr, tmp);
uval = gen_reg_rtx (value->mode); uval = gen_reg_rtx (value->hvalue.rtl.mode);
emit_move_insn (uval, copy_rtx (value->value)); emit_move_insn (uval, copy_rtx (value->hvalue.rtl.value));
/* Check for non-power of 2. */ /* Check for non-power of 2. */
if (value->hdata.pow2.may_be_other) if (value->hdata.pow2.may_be_other)
{ {
do_compare_rtx_and_jump (copy_rtx (uval), const0_rtx, LE, 0, value->mode, do_compare_rtx_and_jump (copy_rtx (uval), const0_rtx, LE, 0, value->hvalue.rtl.mode,
NULL_RTX, NULL_RTX, end_of_code_label); NULL_RTX, NULL_RTX, end_of_code_label);
tmp = expand_simple_binop (value->mode, PLUS, copy_rtx (uval), tmp = expand_simple_binop (value->hvalue.rtl.mode, PLUS, copy_rtx (uval),
constm1_rtx, NULL_RTX, 0, OPTAB_WIDEN); constm1_rtx, NULL_RTX, 0, OPTAB_WIDEN);
tmp = expand_simple_binop (value->mode, AND, copy_rtx (uval), tmp, tmp = expand_simple_binop (value->hvalue.rtl.mode, AND, copy_rtx (uval), tmp,
NULL_RTX, 0, OPTAB_WIDEN); NULL_RTX, 0, OPTAB_WIDEN);
do_compare_rtx_and_jump (tmp, const0_rtx, NE, 0, value->mode, NULL_RTX, do_compare_rtx_and_jump (tmp, const0_rtx, NE, 0, value->hvalue.rtl.mode, NULL_RTX,
NULL_RTX, end_of_code_label); NULL_RTX, end_of_code_label);
} }
...@@ -251,12 +212,12 @@ rtl_gen_pow2_profiler (histogram_value value, unsigned tag, unsigned base) ...@@ -251,12 +212,12 @@ rtl_gen_pow2_profiler (histogram_value value, unsigned tag, unsigned base)
if (tmp != mr) if (tmp != mr)
emit_move_insn (copy_rtx (mr), tmp); emit_move_insn (copy_rtx (mr), tmp);
tmp = expand_simple_binop (value->mode, ASHIFTRT, copy_rtx (uval), const1_rtx, tmp = expand_simple_binop (value->hvalue.rtl.mode, ASHIFTRT, copy_rtx (uval), const1_rtx,
uval, 0, OPTAB_WIDEN); uval, 0, OPTAB_WIDEN);
if (tmp != uval) if (tmp != uval)
emit_move_insn (copy_rtx (uval), tmp); emit_move_insn (copy_rtx (uval), tmp);
do_compare_rtx_and_jump (copy_rtx (uval), const0_rtx, NE, 0, value->mode, do_compare_rtx_and_jump (copy_rtx (uval), const0_rtx, NE, 0, value->hvalue.rtl.mode,
NULL_RTX, NULL_RTX, loop_label); NULL_RTX, NULL_RTX, loop_label);
/* Increase the counter. */ /* Increase the counter. */
...@@ -295,8 +256,8 @@ rtl_gen_one_value_profiler_no_edge_manipulation (histogram_value value, ...@@ -295,8 +256,8 @@ rtl_gen_one_value_profiler_no_edge_manipulation (histogram_value value,
start_sequence (); start_sequence ();
if (value->seq) if (value->hvalue.rtl.seq)
emit_insn (value->seq); emit_insn (value->hvalue.rtl.seq);
stored_value_ref = rtl_coverage_counter_ref (tag, base); stored_value_ref = rtl_coverage_counter_ref (tag, base);
counter_ref = rtl_coverage_counter_ref (tag, base + 1); counter_ref = rtl_coverage_counter_ref (tag, base + 1);
...@@ -306,7 +267,7 @@ rtl_gen_one_value_profiler_no_edge_manipulation (histogram_value value, ...@@ -306,7 +267,7 @@ rtl_gen_one_value_profiler_no_edge_manipulation (histogram_value value,
all = validize_mem (all_ref); all = validize_mem (all_ref);
uval = gen_reg_rtx (mode); uval = gen_reg_rtx (mode);
convert_move (uval, copy_rtx (value->value), 0); convert_move (uval, copy_rtx (value->hvalue.rtl.value), 0);
/* Check if the stored value matches. */ /* Check if the stored value matches. */
do_compare_rtx_and_jump (copy_rtx (uval), copy_rtx (stored_value), EQ, do_compare_rtx_and_jump (copy_rtx (uval), copy_rtx (stored_value), EQ,
...@@ -362,8 +323,8 @@ rtl_gen_one_value_profiler_no_edge_manipulation (histogram_value value, ...@@ -362,8 +323,8 @@ rtl_gen_one_value_profiler_no_edge_manipulation (histogram_value value,
static void static void
rtl_gen_one_value_profiler (histogram_value value, unsigned tag, unsigned base) rtl_gen_one_value_profiler (histogram_value value, unsigned tag, unsigned base)
{ {
edge e = split_block (BLOCK_FOR_INSN ((rtx)value->insn), edge e = split_block (BLOCK_FOR_INSN (value->hvalue.rtl.insn),
PREV_INSN ((rtx)value->insn)); PREV_INSN (value->hvalue.rtl.insn));
rtx sequence = rtl_gen_one_value_profiler_no_edge_manipulation (value, rtx sequence = rtl_gen_one_value_profiler_no_edge_manipulation (value,
tag, base); tag, base);
rebuild_jump_labels (sequence); rebuild_jump_labels (sequence);
...@@ -383,28 +344,28 @@ rtl_gen_const_delta_profiler (histogram_value value, unsigned tag, unsigned base ...@@ -383,28 +344,28 @@ rtl_gen_const_delta_profiler (histogram_value value, unsigned tag, unsigned base
enum machine_mode mode = mode_for_size (gcov_size, MODE_INT, 0); enum machine_mode mode = mode_for_size (gcov_size, MODE_INT, 0);
rtx stored_value_ref, stored_value, tmp, uval; rtx stored_value_ref, stored_value, tmp, uval;
rtx sequence; rtx sequence;
edge e = split_block (BLOCK_FOR_INSN ((rtx)value->insn), edge e = split_block (BLOCK_FOR_INSN (value->hvalue.rtl.insn),
PREV_INSN ((rtx)value->insn)); PREV_INSN (value->hvalue.rtl.insn));
start_sequence (); start_sequence ();
if (value->seq) if (value->hvalue.rtl.seq)
emit_insn (value->seq); emit_insn (value->hvalue.rtl.seq);
stored_value_ref = rtl_coverage_counter_ref (tag, base); stored_value_ref = rtl_coverage_counter_ref (tag, base);
stored_value = validize_mem (stored_value_ref); stored_value = validize_mem (stored_value_ref);
uval = gen_reg_rtx (mode); uval = gen_reg_rtx (mode);
convert_move (uval, copy_rtx (value->value), 0); convert_move (uval, copy_rtx (value->hvalue.rtl.value), 0);
tmp = expand_simple_binop (mode, MINUS, tmp = expand_simple_binop (mode, MINUS,
copy_rtx (uval), copy_rtx (stored_value), copy_rtx (uval), copy_rtx (stored_value),
NULL_RTX, 0, OPTAB_WIDEN); NULL_RTX, 0, OPTAB_WIDEN);
one_value_delta = ggc_alloc (sizeof (*one_value_delta)); one_value_delta = ggc_alloc (sizeof (*one_value_delta));
one_value_delta->value = tmp; one_value_delta->hvalue.rtl.value = tmp;
one_value_delta->mode = mode; one_value_delta->hvalue.rtl.mode = mode;
one_value_delta->seq = NULL_RTX; one_value_delta->hvalue.rtl.seq = NULL_RTX;
one_value_delta->insn = value->insn; one_value_delta->hvalue.rtl.insn = value->hvalue.rtl.insn;
one_value_delta->type = HIST_TYPE_SINGLE_VALUE; one_value_delta->type = HIST_TYPE_SINGLE_VALUE;
emit_insn (rtl_gen_one_value_profiler_no_edge_manipulation (one_value_delta, emit_insn (rtl_gen_one_value_profiler_no_edge_manipulation (one_value_delta,
tag, base + 1)); tag, base + 1));
......
gcc/toplev.c
...@@ -1773,9 +1773,6 @@ process_options (void) ...@@ -1773,9 +1773,6 @@ process_options (void)
warning ("this target machine does not have delayed branches"); warning ("this target machine does not have delayed branches");
#endif #endif
if (flag_tree_based_profiling && flag_profile_values)
sorry ("value-based profiling not yet implemented in trees.");
user_label_prefix = USER_LABEL_PREFIX; user_label_prefix = USER_LABEL_PREFIX;
if (flag_leading_underscore != -1) if (flag_leading_underscore != -1)
{ {
......
gcc/tree-flow.h
...@@ -309,6 +309,12 @@ struct stmt_ann_d GTY(()) ...@@ -309,6 +309,12 @@ struct stmt_ann_d GTY(())
by each pass on an as-needed basis in any order convenient for the by each pass on an as-needed basis in any order convenient for the
pass which needs statement UIDs. */ pass which needs statement UIDs. */
unsigned int uid; unsigned int uid;
/* Linked list of histograms for value-based profiling. This is really a
struct histogram_value*. We use void* to avoid having to export that
everywhere, and to avoid having to put it in GC memory. */
void * GTY ((skip (""))) histograms;
}; };
union tree_ann_d GTY((desc ("ann_type ((tree_ann_t)&%h)"))) union tree_ann_d GTY((desc ("ann_type ((tree_ann_t)&%h)")))
......
gcc/tree-profile.c
...@@ -24,30 +24,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA ...@@ -24,30 +24,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA. */ 02111-1307, USA. */
/* Generate basic block profile instrumentation and auxiliary files. /* Generate basic block profile instrumentation and auxiliary files.
Profile generation is optimized, so that not all arcs in the basic Tree-based version. See profile.c for overview. */
block graph need instrumenting. First, the BB graph is closed with
one entry (function start), and one exit (function exit). Any
ABNORMAL_EDGE cannot be instrumented (because there is no control
path to place the code). We close the graph by inserting fake
EDGE_FAKE edges to the EXIT_BLOCK, from the sources of abnormal
edges that do not go to the exit_block. We ignore such abnormal
edges. Naturally these fake edges are never directly traversed,
and so *cannot* be directly instrumented. Some other graph
massaging is done. To optimize the instrumentation we generate the
BB minimal span tree, only edges that are not on the span tree
(plus the entry point) need instrumenting. From that information
all other edge counts can be deduced. By construction all fake
edges must be on the spanning tree. We also attempt to place
EDGE_CRITICAL edges on the spanning tree.
The auxiliary file generated is <dumpbase>.bbg. The format is
described in full in gcov-io.h. */
/* ??? Register allocation should use basic block execution counts to
give preference to the most commonly executed blocks. */
/* ??? Should calculate branch probabilities before instrumenting code, since
then we can use arc counts to help decide which arcs to instrument. */
#include "config.h" #include "config.h"
#include "system.h" #include "system.h"
...@@ -102,15 +79,163 @@ tree_gen_edge_profiler (int edgeno, edge e) ...@@ -102,15 +79,163 @@ tree_gen_edge_profiler (int edgeno, edge e)
tag of the section for counters, BASE is offset of the counter position. */ tag of the section for counters, BASE is offset of the counter position. */
static void static void
tree_gen_interval_profiler (histogram_value value ATTRIBUTE_UNUSED, tree_gen_interval_profiler (histogram_value value, unsigned tag, unsigned base)
unsigned tag ATTRIBUTE_UNUSED,
unsigned base ATTRIBUTE_UNUSED)
{ {
/* FIXME implement this. */ tree op, op1, op2, op1copy, op2copy;
#ifdef ENABLE_CHECKING tree tmp1, tmp2, tmp3, val, index;
internal_error ("unimplemented functionality"); tree label_decl2, label_decl3, label_decl4, label_decl5, label_decl6;
#endif edge e12, e23, e34, e45, e56;
gcc_unreachable (); tree label2, label3, label4, label5, label6;
tree stmt1, stmt2, stmt3, stmt4;
/* Initializations are to prevent bogus uninitialized warnings. */
tree bb1end = NULL_TREE, bb2end = NULL_TREE, bb3end = NULL_TREE;
tree bb4end = NULL_TREE, bb5end = NULL_TREE;
tree ref = tree_coverage_counter_ref (tag, base), ref2;
basic_block bb2, bb3, bb4, bb5, bb6;
tree stmt = value->hvalue.tree.stmt;
block_stmt_iterator bsi = bsi_for_stmt (stmt);
basic_block bb = bb_for_stmt (stmt);
tree optype;
op = stmt;
if (TREE_CODE (stmt) == RETURN_EXPR
&& TREE_OPERAND (stmt, 0)
&& TREE_CODE (TREE_OPERAND (stmt, 0)) == MODIFY_EXPR)
op = TREE_OPERAND (stmt, 0);
/* op == MODIFY_EXPR */
op = TREE_OPERAND (op, 1);
/* op == TRUNC_DIV or TRUNC_MOD */
op1 = TREE_OPERAND (op, 0);
op2 = TREE_OPERAND (op, 1);
optype = TREE_TYPE (op);
/* Blocks:
Original = 1
For 2nd compare = 2
Normal case, neither more nor less = 3
More = 4
Less = 5
End = 6 */
label_decl2 = create_artificial_label ();
label_decl3 = create_artificial_label ();
label_decl4 = create_artificial_label ();
label_decl5 = create_artificial_label ();
label_decl6 = create_artificial_label ();
/* Do not evaluate op1 or op2 more than once. Probably
volatile loads are the only things that could cause
a problem, but this is harmless in any case. */
op1copy = create_tmp_var (optype, "PROF");
op2copy = create_tmp_var (optype, "PROF");
stmt1 = build2 (MODIFY_EXPR, optype, op1copy, op1);
stmt2 = build2 (MODIFY_EXPR, optype, op2copy, op2);
TREE_OPERAND (op, 0) = op1copy;
TREE_OPERAND (op, 1) = op2copy;
val = create_tmp_var (optype, "PROF");
stmt3 = build2 (MODIFY_EXPR, optype, val,
build2 (TRUNC_DIV_EXPR, optype, op1copy, op2copy));
stmt4 = build2 (MODIFY_EXPR, optype, val,
build2 (MINUS_EXPR, optype, val,
build_int_cst (optype, value->hdata.intvl.int_start)));
bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt2, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt3, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt4, BSI_SAME_STMT);
index = create_tmp_var (GCOV_TYPE_NODE, "PROF");
/* Check for too big. */
stmt1 = build3 (COND_EXPR, void_type_node,
build2 (GE_EXPR, boolean_type_node, val,
build_int_cst (optype, value->hdata.intvl.steps)),
build1 (GOTO_EXPR, void_type_node, label_decl4),
build1 (GOTO_EXPR, void_type_node, label_decl2));
bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
bb1end = stmt1;
/* Check for too small. */
label2 = build1 (LABEL_EXPR, void_type_node, label_decl2);
bsi_insert_before (&bsi, label2, BSI_SAME_STMT);
stmt1 = build3 (COND_EXPR, void_type_node,
build2 (LT_EXPR, boolean_type_node, val, integer_zero_node),
build1 (GOTO_EXPR, void_type_node, label_decl5),
build1 (GOTO_EXPR, void_type_node, label_decl3));
bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
bb2end = stmt1;
/* Normal case, within range. */
label3 = build1 (LABEL_EXPR, void_type_node, label_decl3);
bsi_insert_before (&bsi, label3, BSI_SAME_STMT);
stmt1 = build2 (MODIFY_EXPR, GCOV_TYPE_NODE, index,
build1 (NOP_EXPR, GCOV_TYPE_NODE, val));
bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
bb3end = stmt1;
/* Too big */
label4 = build1 (LABEL_EXPR, void_type_node, label_decl4);
stmt1 = build2 (MODIFY_EXPR, GCOV_TYPE_NODE, index,
build_int_cst (GCOV_TYPE_NODE, value->hdata.intvl.steps));
bsi_insert_before (&bsi, label4, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
bb4end = stmt1;
/* Too small */
label5 = build1 (LABEL_EXPR, void_type_node, label_decl5);
stmt1 = build2 (MODIFY_EXPR, GCOV_TYPE_NODE, index,
build_int_cst (GCOV_TYPE_NODE, value->hdata.intvl.steps + 1));
bsi_insert_before (&bsi, label5, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
bb5end = stmt1;
/* Increment appropriate counter. */
label6 = build1 (LABEL_EXPR, void_type_node, label_decl6);
bsi_insert_before (&bsi, label6, BSI_SAME_STMT);
tmp1 = create_tmp_var (GCOV_TYPE_NODE, "PROF");
tmp2 = create_tmp_var (GCOV_TYPE_NODE, "PROF");
tmp3 = create_tmp_var (GCOV_TYPE_NODE, "PROF");
stmt1 = build2 (MODIFY_EXPR, GCOV_TYPE_NODE, tmp1,
build2 (PLUS_EXPR, GCOV_TYPE_NODE, index,
TREE_OPERAND (ref, 1)));
TREE_OPERAND (ref, 1) = tmp1;
/* Make a copy to avoid sharing complaints. */
ref2 = build4 (ARRAY_REF, TREE_TYPE (ref), TREE_OPERAND (ref, 0),
TREE_OPERAND (ref, 1), TREE_OPERAND (ref, 2),
TREE_OPERAND (ref, 3));
stmt2 = build2 (MODIFY_EXPR, GCOV_TYPE_NODE, tmp2, ref);
stmt3 = build2 (MODIFY_EXPR, GCOV_TYPE_NODE, tmp3,
build2 (PLUS_EXPR, GCOV_TYPE_NODE, tmp2, integer_one_node));
stmt4 = build2 (MODIFY_EXPR, GCOV_TYPE_NODE, ref2, tmp3);
bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt2, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt3, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt4, BSI_SAME_STMT);
/* Now fix up the CFG. */
/* 1->2,4; 2->3,5; 3->6; 4->6; 5->6 */
e12 = split_block (bb, bb1end);
bb2 = e12->dest;
e23 = split_block (bb2, bb2end);
bb3 = e23->dest;
e34 = split_block (bb3, bb3end);
bb4 = e34->dest;
e45 = split_block (bb4, bb4end);
bb5 = e45->dest;
e56 = split_block (bb5, bb5end);
bb6 = e56->dest;
e12->flags &= ~EDGE_FALLTHRU;
e12->flags |= EDGE_FALSE_VALUE;
make_edge (bb, bb4, EDGE_TRUE_VALUE);
e23->flags &= ~EDGE_FALLTHRU;
e23->flags |= EDGE_FALSE_VALUE;
make_edge (bb2, bb5, EDGE_TRUE_VALUE);
remove_edge (e34);
make_edge (bb3, bb6, EDGE_FALLTHRU);
remove_edge (e45);
make_edge (bb4, bb6, EDGE_FALLTHRU);
} }
/* Output instructions as GIMPLE trees to increment the power of two histogram /* Output instructions as GIMPLE trees to increment the power of two histogram
...@@ -118,15 +243,162 @@ tree_gen_interval_profiler (histogram_value value ATTRIBUTE_UNUSED, ...@@ -118,15 +243,162 @@ tree_gen_interval_profiler (histogram_value value ATTRIBUTE_UNUSED,
of the section for counters, BASE is offset of the counter position. */ of the section for counters, BASE is offset of the counter position. */
static void static void
tree_gen_pow2_profiler (histogram_value value ATTRIBUTE_UNUSED, tree_gen_pow2_profiler (histogram_value value, unsigned tag, unsigned base)
unsigned tag ATTRIBUTE_UNUSED,
unsigned base ATTRIBUTE_UNUSED)
{ {
/* FIXME implement this. */ tree op;
#ifdef ENABLE_CHECKING tree tmp1, tmp2, tmp3;
internal_error ("unimplemented functionality"); tree index, denom;
#endif tree label_decl1 = create_artificial_label ();
gcc_unreachable (); tree label_decl2 = create_artificial_label ();
tree label_decl3 = create_artificial_label ();
tree label1, label2, label3;
tree stmt1, stmt2, stmt3, stmt4;
tree bb1end, bb2end, bb3end;
tree ref = tree_coverage_counter_ref (tag, base), ref2;
basic_block bb2, bb3, bb4;
tree stmt = value->hvalue.tree.stmt;
block_stmt_iterator bsi = bsi_for_stmt (stmt);
basic_block bb = bb_for_stmt (stmt);
tree optype, optypesigned, optypeunsigned;
op = stmt;
if (TREE_CODE (stmt) == RETURN_EXPR
&& TREE_OPERAND (stmt, 0)
&& TREE_CODE (TREE_OPERAND (stmt, 0)) == MODIFY_EXPR)
op = TREE_OPERAND (stmt, 0);
/* op == MODIFY_EXPR */
op = TREE_OPERAND (op, 1);
/* op == TRUNC_DIV or TRUNC_MOD */
op = TREE_OPERAND (op, 1);
/* op == denominator */
optype = TREE_TYPE (op);
if (TYPE_UNSIGNED (optype))
{
/* Right shift must be unsigned. */
optypeunsigned = optype;
optypesigned = build_distinct_type_copy (optype);
TYPE_UNSIGNED (optypesigned) = false;
}
else
{
/* Compare to zero must be signed. */
optypesigned = optype;
optypeunsigned = build_distinct_type_copy (optype);
TYPE_UNSIGNED (optypeunsigned) = true;
}
/* Set up variables and check if denominator is negative when considered
as signed. */
index = create_tmp_var (GCOV_TYPE_NODE, "PROF");
denom = create_tmp_var (optype, "PROF");
stmt1 = build2 (MODIFY_EXPR, GCOV_TYPE_NODE, index, integer_zero_node);
stmt2 = build2 (MODIFY_EXPR, optype, denom, op);
if (optypesigned == optype)
{
tmp1 = denom;
stmt3 = NULL_TREE;
}
else
{
tmp1 = create_tmp_var (optypesigned, "PROF");
stmt3 = build2 (MODIFY_EXPR, optypesigned, tmp1,
build1 (NOP_EXPR, optypesigned, denom));
}
stmt4 = build3 (COND_EXPR, void_type_node,
build2 (LE_EXPR, boolean_type_node, tmp1, integer_zero_node),
build1 (GOTO_EXPR, void_type_node, label_decl3),
build1 (GOTO_EXPR, void_type_node, label_decl1));
bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt2, BSI_SAME_STMT);
if (stmt3)
bsi_insert_before (&bsi, stmt3, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt4, BSI_SAME_STMT);
bb1end = stmt4;
/* Nonnegative. Check if denominator is power of 2. */
label1 = build1 (LABEL_EXPR, void_type_node, label_decl1);
tmp1 = create_tmp_var (optype, "PROF");
tmp2 = create_tmp_var (optype, "PROF");
stmt1 = build2 (MODIFY_EXPR, optype, tmp1,
build2 (PLUS_EXPR, optype, denom, integer_minus_one_node));
stmt2 = build2 (MODIFY_EXPR, optype, tmp2,
build2 (BIT_AND_EXPR, optype, tmp1, denom));
stmt3 = build3 (COND_EXPR, void_type_node,
build2 (NE_EXPR, boolean_type_node, tmp2, integer_zero_node),
build1 (GOTO_EXPR, void_type_node, label_decl3),
build1 (GOTO_EXPR, void_type_node, label_decl2));
bsi_insert_before (&bsi, label1, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt2, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt3, BSI_SAME_STMT);
bb2end = stmt3;
/* Loop. Increment index, shift denominator, repeat if denominator nonzero. */
label2 = build1 (LABEL_EXPR, void_type_node, label_decl2);
stmt1 = build2 (MODIFY_EXPR, GCOV_TYPE_NODE, index,
build2 (PLUS_EXPR, GCOV_TYPE_NODE, index, integer_one_node));
if (optypeunsigned == optype)
{
tmp1 = denom;
stmt2 = NULL_TREE;
}
else
{
tmp1 = create_tmp_var (optypeunsigned, "PROF");
stmt2 = build2 (MODIFY_EXPR, optypeunsigned, tmp1,
build1 (NOP_EXPR, optypeunsigned, denom));
}
stmt3 = build2 (MODIFY_EXPR, optype, denom,
build2 (RSHIFT_EXPR, optype, tmp1, integer_one_node));
stmt4 = build3 (COND_EXPR, void_type_node,
build2 (NE_EXPR, boolean_type_node, denom, integer_zero_node),
build1 (GOTO_EXPR, void_type_node, label_decl2),
build1 (GOTO_EXPR, void_type_node, label_decl3));
bsi_insert_before (&bsi, label2, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
if (stmt2)
bsi_insert_before (&bsi, stmt2, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt3, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt4, BSI_SAME_STMT);
bb3end = stmt4;
/* Increment the appropriate counter. */
label3 = build1 (LABEL_EXPR, void_type_node, label_decl3);
tmp1 = create_tmp_var (GCOV_TYPE_NODE, "PROF");
tmp2 = create_tmp_var (GCOV_TYPE_NODE, "PROF");
tmp3 = create_tmp_var (GCOV_TYPE_NODE, "PROF");
stmt1 = build2 (MODIFY_EXPR, GCOV_TYPE_NODE, tmp1,
build2 (PLUS_EXPR, GCOV_TYPE_NODE, index, TREE_OPERAND (ref, 1)));
TREE_OPERAND (ref, 1) = tmp1;
/* Make a copy to avoid sharing complaints. */
ref2 = build4 (ARRAY_REF, TREE_TYPE (ref), TREE_OPERAND (ref, 0),
TREE_OPERAND (ref, 1), TREE_OPERAND (ref, 2), TREE_OPERAND (ref, 3));
stmt2 = build2 (MODIFY_EXPR, GCOV_TYPE_NODE, tmp2, ref);
stmt3 = build2 (MODIFY_EXPR, GCOV_TYPE_NODE, tmp3,
build2 (PLUS_EXPR, GCOV_TYPE_NODE, tmp2, integer_one_node));
stmt4 = build2 (MODIFY_EXPR, GCOV_TYPE_NODE, ref2, tmp3);
bsi_insert_before (&bsi, label3, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt2, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt3, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt4, BSI_SAME_STMT);
/* Now fix up the CFG. */
bb2 = (split_block (bb, bb1end))->dest;
bb3 = (split_block (bb2, bb2end))->dest;
bb4 = (split_block (bb3, bb3end))->dest;
EDGE_SUCC (bb, 0)->flags &= ~EDGE_FALLTHRU;
EDGE_SUCC (bb, 0)->flags |= EDGE_FALSE_VALUE;
make_edge (bb, bb4, EDGE_TRUE_VALUE);
EDGE_SUCC (bb2, 0)->flags &= ~EDGE_FALLTHRU;
EDGE_SUCC (bb2, 0)->flags |= EDGE_FALSE_VALUE;
make_edge (bb2, bb4, EDGE_TRUE_VALUE);
EDGE_SUCC (bb3, 0)->flags &= ~EDGE_FALLTHRU;
EDGE_SUCC (bb3, 0)->flags |= EDGE_FALSE_VALUE;
make_edge (bb3, bb3, EDGE_TRUE_VALUE);
} }
/* Output instructions as GIMPLE trees for code to find the most common value. /* Output instructions as GIMPLE trees for code to find the most common value.
...@@ -134,15 +406,150 @@ tree_gen_pow2_profiler (histogram_value value ATTRIBUTE_UNUSED, ...@@ -134,15 +406,150 @@ tree_gen_pow2_profiler (histogram_value value ATTRIBUTE_UNUSED,
section for counters, BASE is offset of the counter position. */ section for counters, BASE is offset of the counter position. */
static void static void
tree_gen_one_value_profiler (histogram_value value ATTRIBUTE_UNUSED, tree_gen_one_value_profiler (histogram_value value, unsigned tag, unsigned base)
unsigned tag ATTRIBUTE_UNUSED,
unsigned base ATTRIBUTE_UNUSED)
{ {
/* FIXME implement this. */ tree op;
#ifdef ENABLE_CHECKING tree tmp1, tmp2, tmp3;
internal_error ("unimplemented functionality"); tree label_decl1 = create_artificial_label ();
#endif tree label_decl2 = create_artificial_label ();
gcc_unreachable (); tree label_decl3 = create_artificial_label ();
tree label_decl4 = create_artificial_label ();
tree label_decl5 = create_artificial_label ();
tree label1, label2, label3, label4, label5;
tree stmt1, stmt2, stmt3, stmt4;
tree bb1end, bb2end, bb3end, bb4end, bb5end;
tree ref1 = tree_coverage_counter_ref (tag, base);
tree ref2 = tree_coverage_counter_ref (tag, base + 1);
tree ref3 = tree_coverage_counter_ref (tag, base + 2);
basic_block bb2, bb3, bb4, bb5, bb6;
tree stmt = value->hvalue.tree.stmt;
block_stmt_iterator bsi = bsi_for_stmt (stmt);
basic_block bb = bb_for_stmt (stmt);
tree optype;
op = stmt;
if (TREE_CODE (stmt) == RETURN_EXPR
&& TREE_OPERAND (stmt, 0)
&& TREE_CODE (TREE_OPERAND (stmt, 0)) == MODIFY_EXPR)
op = TREE_OPERAND (stmt, 0);
/* op == MODIFY_EXPR */
op = TREE_OPERAND (op, 1);
/* op == TRUNC_DIV or TRUNC_MOD */
op = TREE_OPERAND (op, 1);
/* op == denominator */
optype = TREE_TYPE (op);
/* Check if the stored value matches. */
tmp1 = create_tmp_var (GCOV_TYPE_NODE, "PROF");
tmp2 = create_tmp_var (optype, "PROF");
tmp3 = create_tmp_var (optype, "PROF");
stmt1 = build2 (MODIFY_EXPR, GCOV_TYPE_NODE, tmp1, ref1);
stmt2 = build2 (MODIFY_EXPR, optype, tmp2,
build1 (NOP_EXPR, optype, tmp1));
stmt3 = build2 (MODIFY_EXPR, optype, tmp3, op);
stmt4 = build3 (COND_EXPR, void_type_node,
build2 (EQ_EXPR, boolean_type_node, tmp2, tmp3),
build1 (GOTO_EXPR, void_type_node, label_decl4),
build1 (GOTO_EXPR, void_type_node, label_decl1));
bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt2, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt3, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt4, BSI_SAME_STMT);
bb1end = stmt4;
/* Does not match; check whether the counter is zero. */
label1 = build1 (LABEL_EXPR, void_type_node, label_decl1);
tmp1 = create_tmp_var (GCOV_TYPE_NODE, "PROF");
stmt1 = build2 (MODIFY_EXPR, GCOV_TYPE_NODE, tmp1, ref2);
stmt2 = build3 (COND_EXPR, void_type_node,
build2 (EQ_EXPR, boolean_type_node, tmp1, integer_zero_node),
build1 (GOTO_EXPR, void_type_node, label_decl3),
build1 (GOTO_EXPR, void_type_node, label_decl2));
bsi_insert_before (&bsi, label1, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt2, BSI_SAME_STMT);
bb2end = stmt2;
/* Counter is not zero yet, decrement. */
label2 = build1 (LABEL_EXPR, void_type_node, label_decl2);
tmp1 = create_tmp_var (GCOV_TYPE_NODE, "PROF");
tmp2 = create_tmp_var (GCOV_TYPE_NODE, "PROF");
stmt1 = build2 (MODIFY_EXPR, GCOV_TYPE_NODE, tmp1, ref2);
stmt2 = build2 (MODIFY_EXPR, GCOV_TYPE_NODE, tmp2,
build (MINUS_EXPR, GCOV_TYPE_NODE,
tmp1, integer_one_node));
stmt3 = build2 (MODIFY_EXPR, GCOV_TYPE_NODE, ref2, tmp2);
bsi_insert_before (&bsi, label2, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt2, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt3, BSI_SAME_STMT);
bb3end = stmt3;
/* Counter was zero, store new value. */
label3 = build1 (LABEL_EXPR, void_type_node, label_decl3);
tmp1 = create_tmp_var (optype, "PROF");
tmp2 = create_tmp_var (GCOV_TYPE_NODE, "PROF");
stmt1 = build2 (MODIFY_EXPR, optype, tmp1, op);
stmt2 = build2 (MODIFY_EXPR, GCOV_TYPE_NODE, tmp2,
build1 (NOP_EXPR, GCOV_TYPE_NODE, tmp1));
stmt3 = build2 (MODIFY_EXPR, GCOV_TYPE_NODE, ref1, tmp2);
bsi_insert_before (&bsi, label3, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt2, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt3, BSI_SAME_STMT);
bb4end = stmt3;
/* (fall through) */
/* Increment counter. */
label4 = build1 (LABEL_EXPR, void_type_node, label_decl4);
tmp1 = create_tmp_var (GCOV_TYPE_NODE, "PROF");
tmp2 = create_tmp_var (GCOV_TYPE_NODE, "PROF");
stmt1 = build2 (MODIFY_EXPR, GCOV_TYPE_NODE, tmp1, ref2);
stmt2 = build2 (MODIFY_EXPR, GCOV_TYPE_NODE, tmp2,
build (PLUS_EXPR, GCOV_TYPE_NODE,
tmp1, integer_one_node));
stmt3 = build2 (MODIFY_EXPR, GCOV_TYPE_NODE, ref2, tmp2);
bsi_insert_before (&bsi, label4, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt2, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt3, BSI_SAME_STMT);
bb5end = stmt3;
/* Increment the counter of all executions; this seems redundant given
that we have counts for edges in cfg, but it may happen that some
optimization will change the counts for the block (either because
it is unable to update them correctly, or because it will duplicate
the block or its part). */
label5 = build1 (LABEL_EXPR, void_type_node, label_decl5);
tmp1 = create_tmp_var (GCOV_TYPE_NODE, "PROF");
tmp2 = create_tmp_var (GCOV_TYPE_NODE, "PROF");
stmt1 = build2 (MODIFY_EXPR, GCOV_TYPE_NODE, tmp1, ref3);
stmt2 = build2 (MODIFY_EXPR, GCOV_TYPE_NODE, tmp2,
build (PLUS_EXPR, GCOV_TYPE_NODE,
tmp1, integer_one_node));
stmt3 = build2 (MODIFY_EXPR, GCOV_TYPE_NODE, ref3, tmp2);
bsi_insert_before (&bsi, label5, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt2, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt3, BSI_SAME_STMT);
/* Now fix up the CFG. */
bb2 = (split_block (bb, bb1end))->dest;
bb3 = (split_block (bb2, bb2end))->dest;
bb4 = (split_block (bb3, bb3end))->dest;
bb5 = (split_block (bb4, bb4end))->dest;
bb6 = (split_block (bb5, bb5end))->dest;
EDGE_SUCC (bb, 0)->flags &= ~EDGE_FALLTHRU;
EDGE_SUCC (bb, 0)->flags |= EDGE_FALSE_VALUE;
make_edge (bb, bb5, EDGE_TRUE_VALUE);
EDGE_SUCC (bb2, 0)->flags &= ~EDGE_FALLTHRU;
EDGE_SUCC (bb2, 0)->flags |= EDGE_FALSE_VALUE;
make_edge (bb2, bb4, EDGE_TRUE_VALUE);
remove_edge (EDGE_SUCC (bb3, 0));
make_edge (bb3, bb6, EDGE_FALLTHRU);
} }
/* Output instructions as GIMPLE trees for code to find the most common value /* Output instructions as GIMPLE trees for code to find the most common value
...@@ -166,7 +573,8 @@ tree_gen_const_delta_profiler (histogram_value value ATTRIBUTE_UNUSED, ...@@ -166,7 +573,8 @@ tree_gen_const_delta_profiler (histogram_value value ATTRIBUTE_UNUSED,
If it is, set up hooks for tree-based profiling. If it is, set up hooks for tree-based profiling.
Gate for pass_tree_profile. */ Gate for pass_tree_profile. */
static bool do_tree_profiling (void) static bool
do_tree_profiling (void)
{ {
if (flag_tree_based_profiling if (flag_tree_based_profiling
&& (profile_arc_flag || flag_test_coverage || flag_branch_probabilities)) && (profile_arc_flag || flag_test_coverage || flag_branch_probabilities))
...@@ -184,11 +592,26 @@ static FILE *tree_profile_dump_file (void) { ...@@ -184,11 +592,26 @@ static FILE *tree_profile_dump_file (void) {
return dump_file; return dump_file;
} }
static void
tree_profiling (void)
{
branch_prob ();
if (flag_branch_probabilities
&& flag_profile_values
&& flag_value_profile_transformations)
value_profile_transformations ();
/* The above could hose dominator info. Currently there is
none coming in, this is a safety valve. It should be
easy to adjust it, if and when there is some. */
free_dominance_info (CDI_DOMINATORS);
free_dominance_info (CDI_POST_DOMINATORS);
}
struct tree_opt_pass pass_tree_profile = struct tree_opt_pass pass_tree_profile =
{ {
"tree_profile", /* name */ "tree_profile", /* name */
do_tree_profiling, /* gate */ do_tree_profiling, /* gate */
branch_prob, /* execute */ tree_profiling, /* execute */
NULL, /* sub */ NULL, /* sub */
NULL, /* next */ NULL, /* next */
0, /* static_pass_number */ 0, /* static_pass_number */
......
gcc/value-prof.c
...@@ -34,9 +34,20 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA ...@@ -34,9 +34,20 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
#include "optabs.h" #include "optabs.h"
#include "regs.h" #include "regs.h"
#include "ggc.h" #include "ggc.h"
#include "tree-flow.h"
#include "tree-flow-inline.h"
#include "diagnostic.h"
#include "tree.h"
#include "gcov-io.h"
static struct value_prof_hooks *value_prof_hooks; static struct value_prof_hooks *value_prof_hooks;
/* This is the vector of histograms. Created in find_values_to_profile.
During profile generation, freed by instrument_values.
During profile use, freed by value_profile_transformations. */
static histogram_values static_values = NULL;
/* In this file value profile based optimizations are placed. Currently the /* In this file value profile based optimizations are placed. Currently the
following optimizations are implemented (for more detailed descriptions following optimizations are implemented (for more detailed descriptions
see comments at value_profile_transformations): see comments at value_profile_transformations):
...@@ -53,19 +64,38 @@ static struct value_prof_hooks *value_prof_hooks; ...@@ -53,19 +64,38 @@ static struct value_prof_hooks *value_prof_hooks;
in profile.c and the requested values are instrumented by it in the first in profile.c and the requested values are instrumented by it in the first
compilation with -fprofile-arcs. The optimization may then read the compilation with -fprofile-arcs. The optimization may then read the
gathered data in the second compilation with -fbranch-probabilities. gathered data in the second compilation with -fbranch-probabilities.
The measured data is appended as REG_VALUE_PROFILE note to the instrumented
insn. The argument to the note consists of an EXPR_LIST where its There are currently two versions, RTL-based and tree-based. Over time
members have the following meaning (from the first to the last): the RTL-based version may go away.
In the RTL-based version, the measured data is appended as REG_VALUE_PROFILE
note to the instrumented insn. The argument to the note consists of an
EXPR_LIST where its members have the following meaning (from the first to
the last):
-- type of information gathered (HIST_TYPE*) -- type of information gathered (HIST_TYPE*)
-- the expression that is profiled -- the expression that is profiled
-- list of counters starting from the first one. */ -- list of counters starting from the first one.
In the tree-based version, the measured data is pointed to from the histograms
field of the statement annotation of the instrumented insns. It is
kept as a linked list of struct histogram_value_t's, which contain the
same information as above. */
/* For speculative prefetching, the range in that we do not prefetch (because /* For speculative prefetching, the range in that we do not prefetch (because
we assume that it will be in cache anyway). The asymmetry between min and we assume that it will be in cache anyway). The asymmetry between min and
max range is trying to reflect the fact that the sequential prefetching max range is trying to reflect the fact that the sequential prefetching
of the data is commonly done directly by hardware. Nevertheless, these of the data is commonly done directly by hardware. Nevertheless, these
values are just a guess and should of course be target-specific. */ values are just a guess and should of course be target-specific.
FIXME: There is no tree form of speculative prefetching as yet.
FIXME: A better approach to instrumentation in the profile-generation
pass is to generate calls to magic library functions (to be added to
libgcc) rather than inline code. This approach will probably be
necessary to get tree-based speculative prefetching working in a useful
fashion, as inline code bloats things so much the rest of the compiler has
serious problems dealing with it (judging from the rtl behavior). */
#ifndef NOPREFETCH_RANGE_MIN #ifndef NOPREFETCH_RANGE_MIN
#define NOPREFETCH_RANGE_MIN (-16) #define NOPREFETCH_RANGE_MIN (-16)
...@@ -74,7 +104,7 @@ static struct value_prof_hooks *value_prof_hooks; ...@@ -74,7 +104,7 @@ static struct value_prof_hooks *value_prof_hooks;
#define NOPREFETCH_RANGE_MAX 32 #define NOPREFETCH_RANGE_MAX 32
#endif #endif
static void insn_divmod_values_to_profile (rtx, histogram_values *); static void rtl_divmod_values_to_profile (rtx, histogram_values *);
#ifdef HAVE_prefetch #ifdef HAVE_prefetch
static bool insn_prefetch_values_to_profile (rtx, histogram_values *); static bool insn_prefetch_values_to_profile (rtx, histogram_values *);
static int find_mem_reference_1 (rtx *, void *); static int find_mem_reference_1 (rtx *, void *);
...@@ -82,26 +112,37 @@ static void find_mem_reference_2 (rtx, rtx, void *); ...@@ -82,26 +112,37 @@ static void find_mem_reference_2 (rtx, rtx, void *);
static bool find_mem_reference (rtx, rtx *, int *); static bool find_mem_reference (rtx, rtx *, int *);
#endif #endif
static void insn_values_to_profile (rtx, histogram_values *); static void rtl_values_to_profile (rtx, histogram_values *);
static rtx gen_divmod_fixed_value (enum machine_mode, enum rtx_code, rtx, rtx, static rtx rtl_divmod_fixed_value (enum machine_mode, enum rtx_code, rtx, rtx,
rtx, gcov_type, int); rtx, gcov_type, int);
static rtx gen_mod_pow2 (enum machine_mode, enum rtx_code, rtx, rtx, rtx, int); static rtx rtl_mod_pow2 (enum machine_mode, enum rtx_code, rtx, rtx, rtx, int);
static rtx gen_mod_subtract (enum machine_mode, enum rtx_code, rtx, rtx, rtx, static rtx rtl_mod_subtract (enum machine_mode, enum rtx_code, rtx, rtx, rtx,
int, int, int); int, int, int);
#ifdef HAVE_prefetch #ifdef HAVE_prefetch
static rtx gen_speculative_prefetch (rtx, gcov_type, int); static rtx gen_speculative_prefetch (rtx, gcov_type, int);
#endif #endif
static bool divmod_fixed_value_transform (rtx insn); static bool rtl_divmod_fixed_value_transform (rtx);
static bool mod_pow2_value_transform (rtx); static bool rtl_mod_pow2_value_transform (rtx);
static bool mod_subtract_transform (rtx); static bool rtl_mod_subtract_transform (rtx);
#ifdef HAVE_prefetch #ifdef HAVE_prefetch
static bool speculative_prefetching_transform (rtx); static bool speculative_prefetching_transform (rtx);
#endif #endif
static void tree_divmod_values_to_profile (tree, histogram_values *);
static void tree_values_to_profile (tree, histogram_values *);
static tree tree_divmod_fixed_value (tree, tree, tree, tree,
tree, int, gcov_type, gcov_type);
static tree tree_mod_pow2 (tree, tree, tree, tree, int, gcov_type, gcov_type);
static tree tree_mod_subtract (tree, tree, tree, tree, int, int, int,
gcov_type, gcov_type, gcov_type);
static bool tree_divmod_fixed_value_transform (tree);
static bool tree_mod_pow2_value_transform (tree);
static bool tree_mod_subtract_transform (tree);
/* Find values inside INSN for that we want to measure histograms for /* Find values inside INSN for that we want to measure histograms for
division/modulo optimization and stores them to VALUES. */ division/modulo optimization and stores them to VALUES. */
static void static void
insn_divmod_values_to_profile (rtx insn, histogram_values *values) rtl_divmod_values_to_profile (rtx insn, histogram_values *values)
{ {
rtx set, set_src, op1, op2; rtx set, set_src, op1, op2;
enum machine_mode mode; enum machine_mode mode;
...@@ -134,10 +175,10 @@ insn_divmod_values_to_profile (rtx insn, histogram_values *values) ...@@ -134,10 +175,10 @@ insn_divmod_values_to_profile (rtx insn, histogram_values *values)
if ((GET_CODE (set_src) == UMOD) && !CONSTANT_P (op2)) if ((GET_CODE (set_src) == UMOD) && !CONSTANT_P (op2))
{ {
hist = ggc_alloc (sizeof (*hist)); hist = ggc_alloc (sizeof (*hist));
hist->value = op2; hist->hvalue.rtl.value = op2;
hist->seq = NULL_RTX; hist->hvalue.rtl.seq = NULL_RTX;
hist->mode = mode; hist->hvalue.rtl.mode = mode;
hist->insn = insn; hist->hvalue.rtl.insn = insn;
hist->type = HIST_TYPE_POW2; hist->type = HIST_TYPE_POW2;
hist->hdata.pow2.may_be_other = 1; hist->hdata.pow2.may_be_other = 1;
VEC_safe_push (histogram_value, *values, hist); VEC_safe_push (histogram_value, *values, hist);
...@@ -147,10 +188,10 @@ insn_divmod_values_to_profile (rtx insn, histogram_values *values) ...@@ -147,10 +188,10 @@ insn_divmod_values_to_profile (rtx insn, histogram_values *values)
if (!CONSTANT_P (op2)) if (!CONSTANT_P (op2))
{ {
hist = ggc_alloc (sizeof (*hist)); hist = ggc_alloc (sizeof (*hist));
hist->value = op2; hist->hvalue.rtl.value = op2;
hist->mode = mode; hist->hvalue.rtl.mode = mode;
hist->seq = NULL_RTX; hist->hvalue.rtl.seq = NULL_RTX;
hist->insn = insn; hist->hvalue.rtl.insn = insn;
hist->type = HIST_TYPE_SINGLE_VALUE; hist->type = HIST_TYPE_SINGLE_VALUE;
VEC_safe_push (histogram_value, *values, hist); VEC_safe_push (histogram_value, *values, hist);
} }
...@@ -164,16 +205,14 @@ insn_divmod_values_to_profile (rtx insn, histogram_values *values) ...@@ -164,16 +205,14 @@ insn_divmod_values_to_profile (rtx insn, histogram_values *values)
hist = ggc_alloc (sizeof (*hist)); hist = ggc_alloc (sizeof (*hist));
start_sequence (); start_sequence ();
tmp = simplify_gen_binary (DIV, mode, copy_rtx (op1), copy_rtx (op2)); tmp = simplify_gen_binary (DIV, mode, copy_rtx (op1), copy_rtx (op2));
hist->value = force_operand (tmp, NULL_RTX); hist->hvalue.rtl.value = force_operand (tmp, NULL_RTX);
hist->seq = get_insns (); hist->hvalue.rtl.seq = get_insns ();
end_sequence (); end_sequence ();
hist->mode = mode; hist->hvalue.rtl.mode = mode;
hist->insn = insn; hist->hvalue.rtl.insn = insn;
hist->type = HIST_TYPE_INTERVAL; hist->type = HIST_TYPE_INTERVAL;
hist->hdata.intvl.int_start = 0; hist->hdata.intvl.int_start = 0;
hist->hdata.intvl.steps = 2; hist->hdata.intvl.steps = 2;
hist->hdata.intvl.may_be_less = 1;
hist->hdata.intvl.may_be_more = 1;
VEC_safe_push (histogram_value, *values, hist); VEC_safe_push (histogram_value, *values, hist);
} }
return; return;
...@@ -239,7 +278,7 @@ find_mem_reference (rtx insn, rtx *mem, int *write) ...@@ -239,7 +278,7 @@ find_mem_reference (rtx insn, rtx *mem, int *write)
Returns true if such we found any such value, false otherwise. */ Returns true if such we found any such value, false otherwise. */
static bool static bool
insn_prefetch_values_to_profile (rtx insn, histogram_values *values) insn_prefetch_values_to_profile (rtx insn, histogram_values* values)
{ {
rtx mem, address; rtx mem, address;
int write; int write;
...@@ -260,10 +299,10 @@ insn_prefetch_values_to_profile (rtx insn, histogram_values *values) ...@@ -260,10 +299,10 @@ insn_prefetch_values_to_profile (rtx insn, histogram_values *values)
return false; return false;
hist = ggc_alloc (sizeof (*hist)); hist = ggc_alloc (sizeof (*hist));
hist->value = address; hist->hvalue.rtl.value = address;
hist->mode = GET_MODE (address); hist->hvalue.rtl.mode = GET_MODE (address);
hist->seq = NULL_RTX; hist->hvalue.rtl.seq = NULL_RTX;
hist->insn = insn; hist->hvalue.rtl.insn = insn;
hist->type = HIST_TYPE_CONST_DELTA; hist->type = HIST_TYPE_CONST_DELTA;
VEC_safe_push (histogram_value, *values, hist); VEC_safe_push (histogram_value, *values, hist);
...@@ -273,10 +312,10 @@ insn_prefetch_values_to_profile (rtx insn, histogram_values *values) ...@@ -273,10 +312,10 @@ insn_prefetch_values_to_profile (rtx insn, histogram_values *values)
/* Find values inside INSN for that we want to measure histograms and adds /* Find values inside INSN for that we want to measure histograms and adds
them to list VALUES (increasing the record of its length in N_VALUES). */ them to list VALUES (increasing the record of its length in N_VALUES). */
static void static void
insn_values_to_profile (rtx insn, histogram_values *values) rtl_values_to_profile (rtx insn, histogram_values *values)
{ {
if (flag_value_profile_transformations) if (flag_value_profile_transformations)
insn_divmod_values_to_profile (insn, values); rtl_divmod_values_to_profile (insn, values);
#ifdef HAVE_prefetch #ifdef HAVE_prefetch
if (flag_speculative_prefetching) if (flag_speculative_prefetching)
...@@ -296,23 +335,8 @@ rtl_find_values_to_profile (histogram_values *values) ...@@ -296,23 +335,8 @@ rtl_find_values_to_profile (histogram_values *values)
*values = VEC_alloc (histogram_value, 0); *values = VEC_alloc (histogram_value, 0);
libcall_level = 0; libcall_level = 0;
for (insn = get_insns (); insn; insn = NEXT_INSN (insn)) for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
{ rtl_values_to_profile (insn, values);
if (find_reg_note (insn, REG_LIBCALL, NULL_RTX)) static_values = *values;
libcall_level++;
/* Do not instrument values inside libcalls (we are going to split block
due to instrumentation, and libcall blocks should be local to a single
basic block). */
if (!libcall_level)
insn_values_to_profile (insn, values);
if (find_reg_note (insn, REG_RETVAL, NULL_RTX))
{
gcc_assert (libcall_level > 0);
libcall_level--;
}
}
gcc_assert (libcall_level == 0);
for (i = 0; i < VEC_length (histogram_value, *values); i++) for (i = 0; i < VEC_length (histogram_value, *values); i++)
{ {
...@@ -324,22 +348,20 @@ rtl_find_values_to_profile (histogram_values *values) ...@@ -324,22 +348,20 @@ rtl_find_values_to_profile (histogram_values *values)
if (dump_file) if (dump_file)
fprintf (dump_file, fprintf (dump_file,
"Interval counter for insn %d, range %d -- %d.\n", "Interval counter for insn %d, range %d -- %d.\n",
INSN_UID ((rtx)hist->insn), INSN_UID ((rtx)hist->hvalue.rtl.insn),
hist->hdata.intvl.int_start, hist->hdata.intvl.int_start,
(hist->hdata.intvl.int_start (hist->hdata.intvl.int_start
+ hist->hdata.intvl.steps - 1)); + hist->hdata.intvl.steps - 1));
hist->n_counters = hist->hdata.intvl.steps + hist->n_counters = hist->hdata.intvl.steps + 2;
(hist->hdata.intvl.may_be_less ? 1 : 0) +
(hist->hdata.intvl.may_be_more ? 1 : 0);
break; break;
case HIST_TYPE_POW2: case HIST_TYPE_POW2:
if (dump_file) if (dump_file)
fprintf (dump_file, fprintf (dump_file,
"Pow2 counter for insn %d.\n", "Pow2 counter for insn %d.\n",
INSN_UID ((rtx)hist->insn)); INSN_UID ((rtx)hist->hvalue.rtl.insn));
hist->n_counters hist->n_counters
= GET_MODE_BITSIZE (hist->mode) = GET_MODE_BITSIZE (hist->hvalue.rtl.mode)
+ (hist->hdata.pow2.may_be_other ? 1 : 0); + (hist->hdata.pow2.may_be_other ? 1 : 0);
break; break;
...@@ -347,7 +369,7 @@ rtl_find_values_to_profile (histogram_values *values) ...@@ -347,7 +369,7 @@ rtl_find_values_to_profile (histogram_values *values)
if (dump_file) if (dump_file)
fprintf (dump_file, fprintf (dump_file,
"Single value counter for insn %d.\n", "Single value counter for insn %d.\n",
INSN_UID ((rtx)hist->insn)); INSN_UID ((rtx)hist->hvalue.rtl.insn));
hist->n_counters = 3; hist->n_counters = 3;
break; break;
...@@ -355,7 +377,7 @@ rtl_find_values_to_profile (histogram_values *values) ...@@ -355,7 +377,7 @@ rtl_find_values_to_profile (histogram_values *values)
if (dump_file) if (dump_file)
fprintf (dump_file, fprintf (dump_file,
"Constant delta counter for insn %d.\n", "Constant delta counter for insn %d.\n",
INSN_UID ((rtx)hist->insn)); INSN_UID ((rtx)hist->hvalue.rtl.insn));
hist->n_counters = 4; hist->n_counters = 4;
break; break;
...@@ -493,9 +515,9 @@ rtl_value_profile_transformations (void) ...@@ -493,9 +515,9 @@ rtl_value_profile_transformations (void)
/* Transformations: */ /* Transformations: */
if (flag_value_profile_transformations if (flag_value_profile_transformations
&& (mod_subtract_transform (insn) && (rtl_mod_subtract_transform (insn)
|| divmod_fixed_value_transform (insn) || rtl_divmod_fixed_value_transform (insn)
|| mod_pow2_value_transform (insn))) || rtl_mod_pow2_value_transform (insn)))
changed = true; changed = true;
#ifdef HAVE_prefetch #ifdef HAVE_prefetch
if (flag_speculative_prefetching if (flag_speculative_prefetching
...@@ -517,7 +539,7 @@ rtl_value_profile_transformations (void) ...@@ -517,7 +539,7 @@ rtl_value_profile_transformations (void)
and OP2, whose value is expected to be VALUE, result TARGET and and OP2, whose value is expected to be VALUE, result TARGET and
probability of taking the optimal path PROB). */ probability of taking the optimal path PROB). */
static rtx static rtx
gen_divmod_fixed_value (enum machine_mode mode, enum rtx_code operation, rtl_divmod_fixed_value (enum machine_mode mode, enum rtx_code operation,
rtx target, rtx op1, rtx op2, gcov_type value, rtx target, rtx op1, rtx op2, gcov_type value,
int prob) int prob)
{ {
...@@ -571,7 +593,7 @@ gen_divmod_fixed_value (enum machine_mode mode, enum rtx_code operation, ...@@ -571,7 +593,7 @@ gen_divmod_fixed_value (enum machine_mode mode, enum rtx_code operation,
/* Do transform 1) on INSN if applicable. */ /* Do transform 1) on INSN if applicable. */
static bool static bool
divmod_fixed_value_transform (rtx insn) rtl_divmod_fixed_value_transform (rtx insn)
{ {
rtx set, set_src, set_dest, op1, op2, value, histogram; rtx set, set_src, set_dest, op1, op2, value, histogram;
enum rtx_code code; enum rtx_code code;
...@@ -630,7 +652,7 @@ divmod_fixed_value_transform (rtx insn) ...@@ -630,7 +652,7 @@ divmod_fixed_value_transform (rtx insn)
delete_insn (insn); delete_insn (insn);
insert_insn_on_edge ( insert_insn_on_edge (
gen_divmod_fixed_value (mode, code, set_dest, rtl_divmod_fixed_value (mode, code, set_dest,
op1, op2, val, prob), e); op1, op2, val, prob), e);
return true; return true;
...@@ -639,7 +661,7 @@ divmod_fixed_value_transform (rtx insn) ...@@ -639,7 +661,7 @@ divmod_fixed_value_transform (rtx insn)
/* Generate code for transformation 2 (with MODE and OPERATION, operands OP1 /* Generate code for transformation 2 (with MODE and OPERATION, operands OP1
and OP2, result TARGET and probability of taking the optimal path PROB). */ and OP2, result TARGET and probability of taking the optimal path PROB). */
static rtx static rtx
gen_mod_pow2 (enum machine_mode mode, enum rtx_code operation, rtx target, rtl_mod_pow2 (enum machine_mode mode, enum rtx_code operation, rtx target,
rtx op1, rtx op2, int prob) rtx op1, rtx op2, int prob)
{ {
rtx tmp, tmp1, tmp2, tmp3, jump; rtx tmp, tmp1, tmp2, tmp3, jump;
...@@ -693,7 +715,7 @@ gen_mod_pow2 (enum machine_mode mode, enum rtx_code operation, rtx target, ...@@ -693,7 +715,7 @@ gen_mod_pow2 (enum machine_mode mode, enum rtx_code operation, rtx target,
/* Do transform 2) on INSN if applicable. */ /* Do transform 2) on INSN if applicable. */
static bool static bool
mod_pow2_value_transform (rtx insn) rtl_mod_pow2_value_transform (rtx insn)
{ {
rtx set, set_src, set_dest, op1, op2, value, histogram; rtx set, set_src, set_dest, op1, op2, value, histogram;
enum rtx_code code; enum rtx_code code;
...@@ -758,7 +780,7 @@ mod_pow2_value_transform (rtx insn) ...@@ -758,7 +780,7 @@ mod_pow2_value_transform (rtx insn)
delete_insn (insn); delete_insn (insn);
insert_insn_on_edge ( insert_insn_on_edge (
gen_mod_pow2 (mode, code, set_dest, op1, op2, prob), e); rtl_mod_pow2 (mode, code, set_dest, op1, op2, prob), e);
return true; return true;
} }
...@@ -767,7 +789,7 @@ mod_pow2_value_transform (rtx insn) ...@@ -767,7 +789,7 @@ mod_pow2_value_transform (rtx insn)
operands OP1 and OP2, result TARGET, at most SUB subtractions, and operands OP1 and OP2, result TARGET, at most SUB subtractions, and
probability of taking the optimal path(s) PROB1 and PROB2). */ probability of taking the optimal path(s) PROB1 and PROB2). */
static rtx static rtx
gen_mod_subtract (enum machine_mode mode, enum rtx_code operation, rtl_mod_subtract (enum machine_mode mode, enum rtx_code operation,
rtx target, rtx op1, rtx op2, int sub, int prob1, int prob2) rtx target, rtx op1, rtx op2, int sub, int prob1, int prob2)
{ {
rtx tmp, tmp1, jump; rtx tmp, tmp1, jump;
...@@ -824,7 +846,7 @@ gen_mod_subtract (enum machine_mode mode, enum rtx_code operation, ...@@ -824,7 +846,7 @@ gen_mod_subtract (enum machine_mode mode, enum rtx_code operation,
/* Do transforms 3) and 4) on INSN if applicable. */ /* Do transforms 3) and 4) on INSN if applicable. */
static bool static bool
mod_subtract_transform (rtx insn) rtl_mod_subtract_transform (rtx insn)
{ {
rtx set, set_src, set_dest, op1, op2, histogram; rtx set, set_src, set_dest, op1, op2, histogram;
enum rtx_code code; enum rtx_code code;
...@@ -897,7 +919,7 @@ mod_subtract_transform (rtx insn) ...@@ -897,7 +919,7 @@ mod_subtract_transform (rtx insn)
delete_insn (insn); delete_insn (insn);
insert_insn_on_edge ( insert_insn_on_edge (
gen_mod_subtract (mode, code, set_dest, rtl_mod_subtract (mode, code, set_dest,
op1, op2, i, prob1, prob2), e); op1, op2, i, prob1, prob2), e);
return true; return true;
...@@ -1008,6 +1030,586 @@ speculative_prefetching_transform (rtx insn) ...@@ -1008,6 +1030,586 @@ speculative_prefetching_transform (rtx insn)
return true; return true;
} }
#endif /* HAVE_prefetch */ #endif /* HAVE_prefetch */
/* Tree based transformations. */
static bool
tree_value_profile_transformations (void)
{
basic_block bb;
block_stmt_iterator bsi;
bool changed = false;
FOR_EACH_BB (bb)
{
/* Ignore cold areas -- we are enlarging the code. */
if (!maybe_hot_bb_p (bb))
continue;
for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
{
tree stmt = bsi_stmt (bsi);
stmt_ann_t ann = get_stmt_ann (stmt);
histogram_value th = ann->histograms;
if (!th)
continue;
if (dump_file)
{
fprintf (dump_file, "Trying transformations on insn ");
print_generic_stmt (dump_file, stmt, TDF_SLIM);
}
/* Transformations: */
/* The order of things in this conditional controls which
transformation is used when more than one is applicable. */
/* It is expected that any code added by the transformations
will be added before the current statement, and that the
current statement remain valid (although possibly
modified) upon return. */
if (flag_value_profile_transformations
&& (tree_mod_subtract_transform (stmt)
|| tree_divmod_fixed_value_transform (stmt)
|| tree_mod_pow2_value_transform (stmt)))
{
changed = true;
/* Original statement may no longer be in the same block. */
bb = bb_for_stmt (stmt);
}
/* Free extra storage from compute_value_histograms. */
while (th)
{
free (th->hvalue.tree.counters);
th = th->hvalue.tree.next;
}
ann->histograms = 0;
}
}
if (changed)
{
counts_to_freqs ();
}
return changed;
}
/* Generate code for transformation 1 (with OPERATION, operands OP1
and OP2, whose value is expected to be VALUE, parent modify-expr 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
the temp; it does not replace or alter the original STMT. */
static tree
tree_divmod_fixed_value (tree stmt, tree operation,
tree op1, tree op2, tree value, int prob, gcov_type count,
gcov_type all)
{
tree stmt1, stmt2, stmt3;
tree tmp1, tmp2, tmpv;
tree label_decl1 = create_artificial_label ();
tree label_decl2 = create_artificial_label ();
tree label_decl3 = create_artificial_label ();
tree label1, label2, label3;
tree bb1end, bb2end, bb3end;
basic_block bb, bb2, bb3, bb4;
tree optype = TREE_TYPE (operation);
edge e12, e13, e23, e24, e34;
block_stmt_iterator bsi;
bb = bb_for_stmt (stmt);
bsi = bsi_for_stmt (stmt);
tmpv = create_tmp_var (optype, "PROF");
tmp1 = create_tmp_var (optype, "PROF");
stmt1 = build2 (MODIFY_EXPR, optype, tmpv, fold_convert (optype, value));
stmt2 = build2 (MODIFY_EXPR, optype, tmp1, op2);
stmt3 = build3 (COND_EXPR, void_type_node,
build2 (NE_EXPR, boolean_type_node, tmp1, tmpv),
build1 (GOTO_EXPR, void_type_node, label_decl2),
build1 (GOTO_EXPR, void_type_node, label_decl1));
bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt2, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt3, BSI_SAME_STMT);
bb1end = stmt3;
tmp2 = create_tmp_var (optype, "PROF");
label1 = build1 (LABEL_EXPR, void_type_node, label_decl1);
stmt1 = build2 (MODIFY_EXPR, optype, tmp2,
build2 (TREE_CODE (operation), optype, op1, tmpv));
bsi_insert_before (&bsi, label1, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
bb2end = stmt1;
label2 = build1 (LABEL_EXPR, void_type_node, label_decl2);
stmt1 = build2 (MODIFY_EXPR, optype, tmp2,
build2 (TREE_CODE (operation), optype, op1, op2));
bsi_insert_before (&bsi, label2, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
bb3end = stmt1;
label3 = build1 (LABEL_EXPR, void_type_node, label_decl3);
bsi_insert_before (&bsi, label3, BSI_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;
e12->flags &= ~EDGE_FALLTHRU;
e12->flags |= EDGE_FALSE_VALUE;
e12->probability = prob;
e12->count = count;
e13 = make_edge (bb, bb3, EDGE_TRUE_VALUE);
e13->probability = REG_BR_PROB_BASE - prob;
e13->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;
return tmp2;
}
/* Do transform 1) on INSN if applicable. */
static bool
tree_divmod_fixed_value_transform (tree stmt)
{
stmt_ann_t ann = get_stmt_ann (stmt);
histogram_value histogram;
enum tree_code code;
gcov_type val, count, all;
tree modify, op, op1, op2, result, value, tree_val;
int prob;
modify = stmt;
if (TREE_CODE (stmt) == RETURN_EXPR
&& TREE_OPERAND (stmt, 0)
&& TREE_CODE (TREE_OPERAND (stmt, 0)) == MODIFY_EXPR)
modify = TREE_OPERAND (stmt, 0);
if (TREE_CODE (modify) != MODIFY_EXPR)
return false;
op = TREE_OPERAND (modify, 1);
if (!INTEGRAL_TYPE_P (TREE_TYPE (op)))
return false;
code = TREE_CODE (op);
if (code != TRUNC_DIV_EXPR && code != TRUNC_MOD_EXPR)
return false;
op1 = TREE_OPERAND (op, 0);
op2 = TREE_OPERAND (op, 1);
if (!ann->histograms)
return false;
for (histogram = ann->histograms; histogram; histogram = histogram->hvalue.tree.next)
if (histogram->type == HIST_TYPE_SINGLE_VALUE)
break;
if (!histogram)
return false;
value = histogram->hvalue.tree.value;
val = histogram->hvalue.tree.counters[0];
count = histogram->hvalue.tree.counters[1];
all = histogram->hvalue.tree.counters[2];
/* We require that count is at least half of all; this means
that for the transformation to fire the value must be constant
at least 50% of time (and 75% gives the guarantee of usage). */
if (simple_cst_equal (op2, value) != 1 || 2 * count < all)
return false;
if (dump_file)
{
fprintf (dump_file, "Div/mod by constant transformation on insn ");
print_generic_stmt (dump_file, stmt, TDF_SLIM);
}
/* Compute probability of taking the optimal path. */
prob = (count * REG_BR_PROB_BASE + all / 2) / all;
tree_val = build_int_cst_wide (GCOV_TYPE_NODE, val & 0xffffffffull, val >> 32);
result = tree_divmod_fixed_value (stmt, op, op1, op2, tree_val, prob, count, all);
TREE_OPERAND (modify, 1) = result;
return true;
}
/* Generate code for transformation 2 (with OPERATION, operands OP1
and OP2, parent modify-expr 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
the temp; it does not replace or alter the original STMT. */
static tree
tree_mod_pow2 (tree stmt, tree operation, tree op1, tree op2, int prob,
gcov_type count, gcov_type all)
{
tree stmt1, stmt2, stmt3, stmt4;
tree tmp1, tmp2, tmp3;
tree label_decl1 = create_artificial_label ();
tree label_decl2 = create_artificial_label ();
tree label_decl3 = create_artificial_label ();
tree label1, label2, label3;
tree bb1end, bb2end, bb3end;
basic_block bb, bb2, bb3, bb4;
tree optype = TREE_TYPE (operation);
edge e12, e13, e23, e24, e34;
block_stmt_iterator bsi;
tree result = create_tmp_var (optype, "PROF");
bb = bb_for_stmt (stmt);
bsi = bsi_for_stmt (stmt);
tmp1 = create_tmp_var (optype, "PROF");
tmp2 = create_tmp_var (optype, "PROF");
tmp3 = create_tmp_var (optype, "PROF");
stmt1 = build2 (MODIFY_EXPR, optype, tmp1, fold_convert (optype, op2));
stmt2 = build2 (MODIFY_EXPR, optype, tmp2,
build2 (PLUS_EXPR, optype, op2, integer_minus_one_node));
stmt3 = build2 (MODIFY_EXPR, optype, tmp3,
build2 (BIT_AND_EXPR, optype, tmp2, tmp1));
stmt4 = build3 (COND_EXPR, void_type_node,
build2 (NE_EXPR, boolean_type_node, tmp3, integer_zero_node),
build1 (GOTO_EXPR, void_type_node, label_decl2),
build1 (GOTO_EXPR, void_type_node, label_decl1));
bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt2, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt3, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt4, BSI_SAME_STMT);
bb1end = stmt4;
/* tmp2 == op2-1 inherited from previous block */
label1 = build1 (LABEL_EXPR, void_type_node, label_decl1);
stmt1 = build2 (MODIFY_EXPR, optype, result,
build2 (BIT_AND_EXPR, optype, op1, tmp2));
bsi_insert_before (&bsi, label1, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
bb2end = stmt1;
label2 = build1 (LABEL_EXPR, void_type_node, label_decl2);
stmt1 = build2 (MODIFY_EXPR, optype, result,
build2 (TREE_CODE (operation), optype, op1, op2));
bsi_insert_before (&bsi, label2, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
bb3end = stmt1;
label3 = build1 (LABEL_EXPR, void_type_node, label_decl3);
bsi_insert_before (&bsi, label3, BSI_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;
e12->flags &= ~EDGE_FALLTHRU;
e12->flags |= EDGE_FALSE_VALUE;
e12->probability = prob;
e12->count = count;
e13 = make_edge (bb, bb3, EDGE_TRUE_VALUE);
e13->probability = REG_BR_PROB_BASE - prob;
e13->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;
return result;
}
/* Do transform 2) on INSN if applicable. */
static bool
tree_mod_pow2_value_transform (tree stmt)
{
stmt_ann_t ann = get_stmt_ann (stmt);
histogram_value histogram;
enum tree_code code;
gcov_type count, wrong_values, all;
tree modify, op, op1, op2, result, value;
int prob;
unsigned int i;
modify = stmt;
if (TREE_CODE (stmt) == RETURN_EXPR
&& TREE_OPERAND (stmt, 0)
&& TREE_CODE (TREE_OPERAND (stmt, 0)) == MODIFY_EXPR)
modify = TREE_OPERAND (stmt, 0);
if (TREE_CODE (modify) != MODIFY_EXPR)
return false;
op = TREE_OPERAND (modify, 1);
if (!INTEGRAL_TYPE_P (TREE_TYPE (op)))
return false;
code = TREE_CODE (op);
if (code != TRUNC_MOD_EXPR || !TYPE_UNSIGNED (TREE_TYPE (op)))
return false;
op1 = TREE_OPERAND (op, 0);
op2 = TREE_OPERAND (op, 1);
if (!ann->histograms)
return false;
for (histogram = ann->histograms; histogram; histogram = histogram->hvalue.tree.next)
if (histogram->type == HIST_TYPE_POW2)
break;
if (!histogram)
return false;
value = histogram->hvalue.tree.value;
wrong_values = histogram->hvalue.tree.counters[0];
count = 0;
for (i = 1; i <= TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (stmt))); i++)
count += histogram->hvalue.tree.counters[i];
/* We require that we hit a power of 2 at least half of all evaluations. */
if (simple_cst_equal (op2, value) != 1 || count < wrong_values)
return false;
if (dump_file)
{
fprintf (dump_file, "Mod power of 2 transformation on insn ");
print_generic_stmt (dump_file, stmt, TDF_SLIM);
}
/* Compute probability of taking the optimal path. */
all = count + wrong_values;
prob = (count * REG_BR_PROB_BASE + all / 2) / all;
result = tree_mod_pow2 (stmt, op, op1, op2, prob, count, all);
TREE_OPERAND (modify, 1) = result;
return true;
}
/* Generate code for transformations 3 and 4 (with OPERATION, operands OP1
and OP2, parent modify-expr STMT, and 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
the original STMT. */
/* FIXME: Generalize the interface to handle NCOUNTS > 1. */
static tree
tree_mod_subtract (tree stmt, tree operation, tree op1, tree op2,
int prob1, int prob2, int ncounts,
gcov_type count1, gcov_type count2, gcov_type all)
{
tree stmt1, stmt2, stmt3;
tree tmp1;
tree label_decl1 = create_artificial_label ();
tree label_decl2 = create_artificial_label ();
tree label_decl3 = create_artificial_label ();
tree label1, label2, label3;
tree bb1end, bb2end = NULL_TREE, bb3end;
basic_block bb, bb2, bb3, bb4;
tree optype = TREE_TYPE (operation);
edge e12, e23 = 0, e24, e34, e14;
block_stmt_iterator bsi;
tree result = create_tmp_var (optype, "PROF");
bb = bb_for_stmt (stmt);
bsi = bsi_for_stmt (stmt);
tmp1 = create_tmp_var (optype, "PROF");
stmt1 = build2 (MODIFY_EXPR, optype, result, op1);
stmt2 = build2 (MODIFY_EXPR, optype, tmp1, op2);
stmt3 = build3 (COND_EXPR, void_type_node,
build2 (LT_EXPR, boolean_type_node, result, tmp1),
build1 (GOTO_EXPR, void_type_node, label_decl3),
build1 (GOTO_EXPR, void_type_node,
ncounts ? label_decl1 : label_decl2));
bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt2, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt3, BSI_SAME_STMT);
bb1end = stmt3;
if (ncounts) /* Assumed to be 0 or 1 */
{
label1 = build1 (LABEL_EXPR, void_type_node, label_decl1);
stmt1 = build2 (MODIFY_EXPR, optype, result,
build2 (MINUS_EXPR, optype, result, tmp1));
stmt2 = build3 (COND_EXPR, void_type_node,
build2 (LT_EXPR, boolean_type_node, result, tmp1),
build1 (GOTO_EXPR, void_type_node, label_decl3),
build1 (GOTO_EXPR, void_type_node, label_decl2));
bsi_insert_before (&bsi, label1, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt2, BSI_SAME_STMT);
bb2end = stmt2;
}
/* Fallback case. */
label2 = build1 (LABEL_EXPR, void_type_node, label_decl2);
stmt1 = build2 (MODIFY_EXPR, optype, result,
build2 (TREE_CODE (operation), optype, result, tmp1));
bsi_insert_before (&bsi, label2, BSI_SAME_STMT);
bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT);
bb3end = stmt1;
label3 = build1 (LABEL_EXPR, void_type_node, label_decl3);
bsi_insert_before (&bsi, label3, BSI_SAME_STMT);
/* Fix CFG. */
/* Edge e23 connects bb2 to bb3, etc. */
/* However block 3 is optional; if it is not there, references
to 3 really refer to block 2. */
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);
bb3 = e23->dest;
bb3->count = all - count1 - count2;
}
e34 = split_block (ncounts ? bb3 : bb2, bb3end);
bb4 = e34->dest;
bb4->count = all;
e12->flags &= ~EDGE_FALLTHRU;
e12->flags |= EDGE_FALSE_VALUE;
e12->probability = REG_BR_PROB_BASE - prob1;
e12->count = count1;
e14 = make_edge (bb, bb4, EDGE_TRUE_VALUE);
e14->probability = prob1;
e14->count = all - count1;
if (ncounts) /* Assumed to be 0 or 1. */
{
e23->flags &= ~EDGE_FALLTHRU;
e23->flags |= EDGE_FALSE_VALUE;
e23->count = all - count1 - count2;
e23->probability = REG_BR_PROB_BASE - prob2;
e24 = make_edge (bb2, bb4, EDGE_TRUE_VALUE);
e24->probability = prob2;
e24->count = count2;
}
e34->probability = REG_BR_PROB_BASE;
e34->count = all - count1 - count2;
return result;
}
/* Do transforms 3) and 4) on INSN if applicable. */
static bool
tree_mod_subtract_transform (tree stmt)
{
stmt_ann_t ann = get_stmt_ann (stmt);
histogram_value histogram;
enum tree_code code;
gcov_type count, wrong_values, all;
tree modify, op, op1, op2, result, value;
int prob1, prob2;
unsigned int i;
modify = stmt;
if (TREE_CODE (stmt) == RETURN_EXPR
&& TREE_OPERAND (stmt, 0)
&& TREE_CODE (TREE_OPERAND (stmt, 0)) == MODIFY_EXPR)
modify = TREE_OPERAND (stmt, 0);
if (TREE_CODE (modify) != MODIFY_EXPR)
return false;
op = TREE_OPERAND (modify, 1);
if (!INTEGRAL_TYPE_P (TREE_TYPE (op)))
return false;
code = TREE_CODE (op);
if (code != TRUNC_MOD_EXPR || !TYPE_UNSIGNED (TREE_TYPE (op)))
return false;
op1 = TREE_OPERAND (op, 0);
op2 = TREE_OPERAND (op, 1);
if (!ann->histograms)
return false;
for (histogram = ann->histograms; histogram; histogram = histogram->hvalue.tree.next)
if (histogram->type == HIST_TYPE_INTERVAL)
break;
if (!histogram)
return false;
value = histogram->hvalue.tree.value;
all = 0;
wrong_values = 0;
for (i = 0; i < histogram->hdata.intvl.steps; i++)
all += histogram->hvalue.tree.counters[i];
wrong_values += histogram->hvalue.tree.counters[i];
wrong_values += histogram->hvalue.tree.counters[i+1];
all += wrong_values;
/* Sanity check. */
if (simple_cst_equal (op2, value) != 1)
return false;
/* We require that we use just subtractions in at least 50% of all
evaluations. */
count = 0;
for (i = 0; i < histogram->hdata.intvl.steps; i++)
{
count += histogram->hvalue.tree.counters[i];
if (count * 2 >= all)
break;
}
if (i == histogram->hdata.intvl.steps)
return false;
if (dump_file)
{
fprintf (dump_file, "Mod subtract transformation on insn ");
print_generic_stmt (dump_file, stmt, TDF_SLIM);
}
/* Compute probability of taking the optimal path(s). */
prob1 = (histogram->hvalue.tree.counters[0] * REG_BR_PROB_BASE + all / 2) / all;
prob2 = (histogram->hvalue.tree.counters[1] * REG_BR_PROB_BASE + all / 2) / all;
/* In practice, "steps" is always 2. This interface reflects this,
and will need to be changed if "steps" can change. */
result = tree_mod_subtract (stmt, op, op1, op2, prob1, prob2, i,
histogram->hvalue.tree.counters[0],
histogram->hvalue.tree.counters[1], all);
TREE_OPERAND (modify, 1) = result;
return true;
}
/* Connection to the outside world. */ /* Connection to the outside world. */
/* Struct for IR-dependent hooks. */ /* Struct for IR-dependent hooks. */
...@@ -1034,17 +1636,159 @@ rtl_register_value_prof_hooks (void) ...@@ -1034,17 +1636,159 @@ rtl_register_value_prof_hooks (void)
gcc_assert (!ir_type ()); gcc_assert (!ir_type ());
} }
/* Tree-based versions are stubs for now. */ /* Find values inside INSN for that we want to measure histograms for
division/modulo optimization. */
static void
tree_divmod_values_to_profile (tree stmt, histogram_values *values)
{
tree op, op1, op2;
histogram_value hist;
op = stmt;
if (TREE_CODE (stmt) == RETURN_EXPR
&& TREE_OPERAND (stmt, 0)
&& TREE_CODE (TREE_OPERAND (stmt, 0)) == MODIFY_EXPR)
op = TREE_OPERAND (stmt, 0);
if (TREE_CODE (op) != MODIFY_EXPR)
return;
if (!INTEGRAL_TYPE_P (TREE_TYPE (op)))
return;
op = TREE_OPERAND (op, 1);
switch (TREE_CODE (op))
{
case TRUNC_DIV_EXPR:
case TRUNC_MOD_EXPR:
op1 = TREE_OPERAND (op, 0);
op2 = TREE_OPERAND (op, 1);
/* Check for a special case where the divisor is power(s) of 2.
This is more aggressive than the RTL version, under the
assumption that later phases will reduce / or % by power of 2
to something clever most of the time. Signed or unsigned. */
if (TREE_CODE (op2) != INTEGER_CST)
{
hist = ggc_alloc (sizeof (*hist));
hist->hvalue.tree.value = op2;
hist->hvalue.tree.stmt = stmt;
hist->type = HIST_TYPE_POW2;
hist->hdata.pow2.may_be_other = 1;
VEC_safe_push (histogram_value, *values, hist);
}
/* Check for the case where the divisor is the same value most
of the time. */
if (TREE_CODE (op2) != INTEGER_CST)
{
hist = ggc_alloc (sizeof (*hist));
hist->hvalue.tree.value = op2;
hist->hvalue.tree.stmt = stmt;
hist->type = HIST_TYPE_SINGLE_VALUE;
VEC_safe_push (histogram_value, *values, hist);
}
/* For mod, check whether it is not often a noop (or replaceable by
a few subtractions). */
if (TREE_CODE (op) == TRUNC_MOD_EXPR && TYPE_UNSIGNED (TREE_TYPE (op)))
{
hist = ggc_alloc (sizeof (*hist));
hist->hvalue.tree.stmt = stmt;
hist->hvalue.tree.value = op2;
hist->type = HIST_TYPE_INTERVAL;
hist->hdata.intvl.int_start = 0;
hist->hdata.intvl.steps = 2;
VEC_safe_push (histogram_value, *values, hist);
}
return;
default:
return;
}
}
/* Find values inside INSN for that we want to measure histograms and adds
them to list VALUES (increasing the record of its length in N_VALUES). */
static void static void
tree_find_values_to_profile (histogram_values *values ATTRIBUTE_UNUSED) tree_values_to_profile (tree stmt, histogram_values *values)
{ {
gcc_unreachable (); if (flag_value_profile_transformations)
tree_divmod_values_to_profile (stmt, values);
} }
static bool static void
tree_value_profile_transformations (void) tree_find_values_to_profile (histogram_values *values)
{ {
gcc_unreachable (); basic_block bb;
block_stmt_iterator bsi;
tree stmt;
unsigned int i;
*values = VEC_alloc (histogram_value, 0);
FOR_EACH_BB (bb)
for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
{
tree stmt = bsi_stmt (bsi);
tree_values_to_profile (stmt, values);
}
static_values = *values;
for (i = 0; i < VEC_length (histogram_value, *values); i++)
{
histogram_value hist = VEC_index (histogram_value, *values, i);
switch (hist->type)
{
case HIST_TYPE_INTERVAL:
if (dump_file)
{
fprintf (dump_file, "Interval counter for tree ");
print_generic_expr (dump_file, hist->hvalue.tree.stmt,
TDF_SLIM);
fprintf (dump_file, ", range %d -- %d.\n",
hist->hdata.intvl.int_start,
(hist->hdata.intvl.int_start
+ hist->hdata.intvl.steps - 1));
}
hist->n_counters = hist->hdata.intvl.steps + 2;
break;
case HIST_TYPE_POW2:
if (dump_file)
{
fprintf (dump_file, "Pow2 counter for insn ");
print_generic_expr (dump_file, hist->hvalue.tree.stmt, TDF_SLIM);
fprintf (dump_file, ".\n");
}
stmt = hist->hvalue.tree.stmt;
hist->n_counters
= TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (stmt)))
+ (hist->hdata.pow2.may_be_other ? 1 : 0);
break;
case HIST_TYPE_SINGLE_VALUE:
if (dump_file)
{
fprintf (dump_file, "Single value counter for insn ");
print_generic_expr (dump_file, hist->hvalue.tree.stmt, TDF_SLIM);
fprintf (dump_file, ".\n");
}
hist->n_counters = 3;
break;
case HIST_TYPE_CONST_DELTA:
if (dump_file)
{
fprintf (dump_file, "Constant delta counter for insn ");
print_generic_expr (dump_file, hist->hvalue.tree.stmt, TDF_SLIM);
fprintf (dump_file, ".\n");
}
hist->n_counters = 4;
break;
default:
abort ();
}
}
} }
static struct value_prof_hooks tree_value_prof_hooks = { static struct value_prof_hooks tree_value_prof_hooks = {
...@@ -1069,6 +1813,7 @@ find_values_to_profile (histogram_values *values) ...@@ -1069,6 +1813,7 @@ find_values_to_profile (histogram_values *values)
bool bool
value_profile_transformations (void) value_profile_transformations (void)
{ {
return (value_prof_hooks->value_profile_transformations) (); bool retval = (value_prof_hooks->value_profile_transformations) ();
VEC_free (histogram_value, static_values);
return retval;
} }
gcc/value-prof.h
...@@ -38,14 +38,25 @@ enum hist_type ...@@ -38,14 +38,25 @@ enum hist_type
((enum hist_type) ((COUNTER) - GCOV_FIRST_VALUE_COUNTER)) ((enum hist_type) ((COUNTER) - GCOV_FIRST_VALUE_COUNTER))
/* The value to measure. */ /* The value to measure. */
/* The void *'s are either rtx or tree, depending on which IR is in use. */ struct histogram_value_t
struct histogram_value_t GTY(())
{ {
PTR GTY ((skip (""))) value; /* The value to profile. */ union
enum machine_mode mode; /* And its mode. */ {
PTR GTY ((skip (""))) seq; /* Insns required to count the struct
profiled value. */ {
PTR GTY ((skip (""))) insn; /* Insn before that to measure. */ rtx value; /* The value to profile. */
rtx seq; /* Insns required to count the profiled value. */
rtx insn; /* Insn before that to measure. */
enum machine_mode mode; /* Mode of value to profile. */
} rtl;
struct
{
tree value; /* The value to profile. */
tree stmt; /* Insn containing the value. */
gcov_type *counters; /* Pointer to first counter. */
struct histogram_value_t *next; /* Linked list pointer. */
} tree;
} hvalue;
enum hist_type type; /* Type of information to measure. */ enum hist_type type; /* Type of information to measure. */
unsigned n_counters; /* Number of required counters. */ unsigned n_counters; /* Number of required counters. */
union union
...@@ -53,9 +64,7 @@ struct histogram_value_t GTY(()) ...@@ -53,9 +64,7 @@ struct histogram_value_t GTY(())
struct struct
{ {
int int_start; /* First value in interval. */ int int_start; /* First value in interval. */
int steps; /* Number of values in it. */ unsigned int steps; /* Number of values in it. */
int may_be_less; /* May the value be below? */
int may_be_more; /* Or above. */
} intvl; /* Interval histogram data. */ } intvl; /* Interval histogram data. */
struct struct
{ {
...@@ -66,7 +75,7 @@ struct histogram_value_t GTY(()) ...@@ -66,7 +75,7 @@ struct histogram_value_t GTY(())
typedef struct histogram_value_t *histogram_value; typedef struct histogram_value_t *histogram_value;
DEF_VEC_GC_P(histogram_value); DEF_VEC_MALLOC_P(histogram_value);
typedef VEC(histogram_value) *histogram_values; typedef VEC(histogram_value) *histogram_values;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment