X-Git-Url: http://git.sourceforge.jp/view?p=pf3gnuchains%2Fgcc-fork.git;a=blobdiff_plain;f=gcc%2Ftree-profile.c;h=0fe370e0abc9c3c323760bee3171e0956a3d06a1;hp=329ebcd4b6e7e4e4751243ca2db6825a62354601;hb=1fbe0481397081ff11e438dbfaadc9b69fbfc679;hpb=35cc02b5c80ac6738c1a3362a822e3d7e4d0c587 diff --git a/gcc/tree-profile.c b/gcc/tree-profile.c index 329ebcd4b6e..0fe370e0abc 100644 --- a/gcc/tree-profile.c +++ b/gcc/tree-profile.c @@ -1,6 +1,7 @@ /* Calculate branch probabilities, and basic block execution counts. Copyright (C) 1990, 1991, 1992, 1993, 1994, 1996, 1997, 1998, 1999, - 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc. + 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 + Free Software Foundation, Inc. Contributed by James E. Wilson, UC Berkeley/Cygnus Support; based on some ideas from Dain Samples of UC Berkeley. Further mangling by Bob Manson, Cygnus Support. @@ -10,7 +11,7 @@ This file is part of GCC. GCC is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free -Software Foundation; either version 2, or (at your option) any later +Software Foundation; either version 3, or (at your option) any later version. GCC is distributed in the hope that it will be useful, but WITHOUT ANY @@ -19,9 +20,8 @@ FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License -along with GCC; see the file COPYING. If not, write to the Free -Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA -02110-1301, USA. */ +along with GCC; see the file COPYING3. If not see +. */ /* Generate basic block profile instrumentation and auxiliary files. Tree-based version. See profile.c for overview. */ @@ -45,15 +45,56 @@ Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA #include "timevar.h" #include "value-prof.h" #include "ggc.h" +#include "cgraph.h" static GTY(()) tree gcov_type_node; static GTY(()) tree tree_interval_profiler_fn; static GTY(()) tree tree_pow2_profiler_fn; static GTY(()) tree tree_one_value_profiler_fn; +static GTY(()) tree tree_indirect_call_profiler_fn; +static GTY(()) tree tree_average_profiler_fn; +static GTY(()) tree tree_ior_profiler_fn; +static GTY(()) tree ic_void_ptr_var; +static GTY(()) tree ic_gcov_type_ptr_var; +static GTY(()) tree ptr_void; + /* Do initialization work for the edge profiler. */ +/* Add code: + static gcov* __gcov_indirect_call_counters; // pointer to actual counter + static void* __gcov_indirect_call_callee; // actual callee addres +*/ +static void +tree_init_ic_make_global_vars (void) +{ + tree gcov_type_ptr; + + ptr_void = build_pointer_type (void_type_node); + + ic_void_ptr_var + = build_decl (VAR_DECL, + get_identifier ("__gcov_indirect_call_callee"), + ptr_void); + TREE_STATIC (ic_void_ptr_var) = 1; + TREE_PUBLIC (ic_void_ptr_var) = 0; + DECL_ARTIFICIAL (ic_void_ptr_var) = 1; + DECL_INITIAL (ic_void_ptr_var) = NULL; + assemble_variable (ic_void_ptr_var, 0, 0, 0); + + gcov_type_ptr = build_pointer_type (get_gcov_type ()); + ic_gcov_type_ptr_var + = build_decl (VAR_DECL, + get_identifier ("__gcov_indirect_call_counters"), + gcov_type_ptr); + TREE_STATIC (ic_gcov_type_ptr_var) = 1; + TREE_PUBLIC (ic_gcov_type_ptr_var) = 0; + DECL_ARTIFICIAL (ic_gcov_type_ptr_var) = 1; + DECL_INITIAL (ic_gcov_type_ptr_var) = NULL; + assemble_variable (ic_gcov_type_ptr_var, 0, 0, 0); +} + static void tree_init_edge_profiler (void) { @@ -61,6 +102,8 @@ tree_init_edge_profiler (void) tree pow2_profiler_fn_type; tree one_value_profiler_fn_type; tree gcov_type_ptr; + tree ic_profiler_fn_type; + tree average_profiler_fn_type; if (!gcov_type_node) { @@ -93,6 +136,28 @@ tree_init_edge_profiler (void) tree_one_value_profiler_fn = build_fn_decl ("__gcov_one_value_profiler", one_value_profiler_fn_type); + + tree_init_ic_make_global_vars (); + + /* void (*) (gcov_type *, gcov_type, void *, void *) */ + ic_profiler_fn_type + = build_function_type_list (void_type_node, + gcov_type_ptr, gcov_type_node, + ptr_void, + ptr_void, NULL_TREE); + tree_indirect_call_profiler_fn + = build_fn_decl ("__gcov_indirect_call_profiler", + ic_profiler_fn_type); + /* void (*) (gcov_type *, gcov_type) */ + average_profiler_fn_type + = build_function_type_list (void_type_node, + gcov_type_ptr, gcov_type_node, NULL_TREE); + tree_average_profiler_fn + = build_fn_decl ("__gcov_average_profiler", + average_profiler_fn_type); + tree_ior_profiler_fn + = build_fn_decl ("__gcov_ior_profiler", + average_profiler_fn_type); } } @@ -106,11 +171,12 @@ tree_gen_edge_profiler (int edgeno, edge e) tree tmp1 = create_tmp_var (gcov_type_node, "PROF"); tree tmp2 = create_tmp_var (gcov_type_node, "PROF"); tree ref = tree_coverage_counter_ref (GCOV_COUNTER_ARCS, edgeno); - tree stmt1 = build2 (GIMPLE_MODIFY_STMT, gcov_type_node, tmp1, ref); - tree stmt2 = build2 (GIMPLE_MODIFY_STMT, gcov_type_node, tmp2, - build2 (PLUS_EXPR, gcov_type_node, - tmp1, integer_one_node)); - tree stmt3 = build2 (GIMPLE_MODIFY_STMT, gcov_type_node, ref, tmp2); + tree one = build_int_cst (gcov_type_node, 1); + tree stmt1 = build_gimple_modify_stmt (tmp1, ref); + tree stmt2 = build_gimple_modify_stmt (tmp2, + build2 (PLUS_EXPR, gcov_type_node, + tmp1, one)); + tree stmt3 = build_gimple_modify_stmt (ref, tmp2); bsi_insert_on_edge (e, stmt1); bsi_insert_on_edge (e, stmt2); bsi_insert_on_edge (e, stmt3); @@ -125,7 +191,7 @@ prepare_instrumented_value (block_stmt_iterator *bsi, { tree val = value->hvalue.value; return force_gimple_operand_bsi (bsi, fold_convert (gcov_type_node, val), - true, NULL_TREE); + true, NULL_TREE, true, BSI_SAME_STMT); } /* Output instructions as GIMPLE trees to increment the interval histogram @@ -138,20 +204,16 @@ tree_gen_interval_profiler (histogram_value value, unsigned tag, unsigned base) tree stmt = value->hvalue.stmt; block_stmt_iterator bsi = bsi_for_stmt (stmt); tree ref = tree_coverage_counter_ref (tag, base), ref_ptr; - tree args, call, val; + tree call, val; tree start = build_int_cst_type (integer_type_node, value->hdata.intvl.int_start); tree steps = build_int_cst_type (unsigned_type_node, value->hdata.intvl.steps); ref_ptr = force_gimple_operand_bsi (&bsi, build_addr (ref, current_function_decl), - true, NULL_TREE); + true, NULL_TREE, true, BSI_SAME_STMT); val = prepare_instrumented_value (&bsi, value); - args = tree_cons (NULL_TREE, ref_ptr, - tree_cons (NULL_TREE, val, - tree_cons (NULL_TREE, start, - tree_cons (NULL_TREE, steps, - NULL_TREE)))); - call = build_function_call_expr (tree_interval_profiler_fn, args); + call = build_call_expr (tree_interval_profiler_fn, 4, + ref_ptr, val, start, steps); bsi_insert_before (&bsi, call, BSI_SAME_STMT); } @@ -165,16 +227,13 @@ tree_gen_pow2_profiler (histogram_value value, unsigned tag, unsigned base) tree stmt = value->hvalue.stmt; block_stmt_iterator bsi = bsi_for_stmt (stmt); tree ref = tree_coverage_counter_ref (tag, base), ref_ptr; - tree args, call, val; + tree call, val; ref_ptr = force_gimple_operand_bsi (&bsi, build_addr (ref, current_function_decl), - true, NULL_TREE); + true, NULL_TREE, true, BSI_SAME_STMT); val = prepare_instrumented_value (&bsi, value); - args = tree_cons (NULL_TREE, ref_ptr, - tree_cons (NULL_TREE, val, - NULL_TREE)); - call = build_function_call_expr (tree_pow2_profiler_fn, args); + call = build_call_expr (tree_pow2_profiler_fn, 2, ref_ptr, val); bsi_insert_before (&bsi, call, BSI_SAME_STMT); } @@ -188,19 +247,95 @@ tree_gen_one_value_profiler (histogram_value value, unsigned tag, unsigned base) tree stmt = value->hvalue.stmt; block_stmt_iterator bsi = bsi_for_stmt (stmt); tree ref = tree_coverage_counter_ref (tag, base), ref_ptr; - tree args, call, val; + tree call, val; ref_ptr = force_gimple_operand_bsi (&bsi, build_addr (ref, current_function_decl), - true, NULL_TREE); + true, NULL_TREE, true, BSI_SAME_STMT); val = prepare_instrumented_value (&bsi, value); - args = tree_cons (NULL_TREE, ref_ptr, - tree_cons (NULL_TREE, val, - NULL_TREE)); - call = build_function_call_expr (tree_one_value_profiler_fn, args); + call = build_call_expr (tree_one_value_profiler_fn, 2, ref_ptr, val); bsi_insert_before (&bsi, call, BSI_SAME_STMT); } + +/* Output instructions as GIMPLE trees for code to find the most + common called function in indirect call. + VALUE is the call expression whose indirect callee is profiled. + TAG is the tag of the section for counters, BASE is offset of the + counter position. */ + +static void +tree_gen_ic_profiler (histogram_value value, unsigned tag, unsigned base) +{ + tree tmp1, stmt1, stmt2, stmt3; + tree stmt = value->hvalue.stmt; + block_stmt_iterator bsi = bsi_for_stmt (stmt); + tree ref = tree_coverage_counter_ref (tag, base), ref_ptr; + + ref_ptr = force_gimple_operand_bsi (&bsi, + build_addr (ref, current_function_decl), + true, NULL_TREE, true, BSI_SAME_STMT); + + /* Insert code: + + __gcov_indirect_call_counters = get_relevant_counter_ptr (); + __gcov_indirect_call_callee = (void *) indirect call argument; + */ + + tmp1 = create_tmp_var (ptr_void, "PROF"); + stmt1 = build_gimple_modify_stmt (ic_gcov_type_ptr_var, ref_ptr); + stmt2 = build_gimple_modify_stmt (tmp1, unshare_expr (value->hvalue.value)); + stmt3 = build_gimple_modify_stmt (ic_void_ptr_var, tmp1); + + bsi_insert_before (&bsi, stmt1, BSI_SAME_STMT); + bsi_insert_before (&bsi, stmt2, BSI_SAME_STMT); + bsi_insert_before (&bsi, stmt3, BSI_SAME_STMT); +} + + +/* Output instructions as GIMPLE trees for code to find the most + common called function in indirect call. Insert instructions at the + beginning of every possible called function. + */ + +static void +tree_gen_ic_func_profiler (void) +{ + struct cgraph_node * c_node = cgraph_node (current_function_decl); + block_stmt_iterator bsi; + edge e; + basic_block bb; + edge_iterator ei; + tree stmt1; + tree tree_uid, cur_func; + + if (flag_unit_at_a_time) + { + if (!c_node->needed) + return; + } + + tree_init_edge_profiler (); + + FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR->succs) + { + bb = split_edge (e); + bsi = bsi_start (bb); + cur_func = force_gimple_operand_bsi (&bsi, + build_addr (current_function_decl, + current_function_decl), + true, NULL_TREE, + true, BSI_SAME_STMT); + tree_uid = build_int_cst (gcov_type_node, c_node->pid); + stmt1 = build_call_expr (tree_indirect_call_profiler_fn, 4, + ic_gcov_type_ptr_var, + tree_uid, + cur_func, + ic_void_ptr_var); + bsi_insert_after (&bsi, stmt1, BSI_NEW_STMT); + } +} + /* Output instructions as GIMPLE trees for code to find the most common value of a difference between two evaluations of an expression. VALUE is the expression whose value is profiled. TAG is the tag of the @@ -218,6 +353,47 @@ tree_gen_const_delta_profiler (histogram_value value ATTRIBUTE_UNUSED, gcc_unreachable (); } +/* Output instructions as GIMPLE trees to increment the average histogram + counter. VALUE is the expression whose value is profiled. TAG is the + tag of the section for counters, BASE is offset of the counter position. */ + +static void +tree_gen_average_profiler (histogram_value value, unsigned tag, unsigned base) +{ + tree stmt = value->hvalue.stmt; + block_stmt_iterator bsi = bsi_for_stmt (stmt); + tree ref = tree_coverage_counter_ref (tag, base), ref_ptr; + tree call, val; + + ref_ptr = force_gimple_operand_bsi (&bsi, + build_addr (ref, current_function_decl), + true, NULL_TREE, + true, BSI_SAME_STMT); + val = prepare_instrumented_value (&bsi, value); + call = build_call_expr (tree_average_profiler_fn, 2, ref_ptr, val); + bsi_insert_before (&bsi, call, BSI_SAME_STMT); +} + +/* Output instructions as GIMPLE trees to increment the ior histogram + counter. VALUE is the expression whose value is profiled. TAG is the + tag of the section for counters, BASE is offset of the counter position. */ + +static void +tree_gen_ior_profiler (histogram_value value, unsigned tag, unsigned base) +{ + tree stmt = value->hvalue.stmt; + block_stmt_iterator bsi = bsi_for_stmt (stmt); + tree ref = tree_coverage_counter_ref (tag, base), ref_ptr; + tree call, val; + + ref_ptr = force_gimple_operand_bsi (&bsi, + build_addr (ref, current_function_decl), + true, NULL_TREE, true, BSI_SAME_STMT); + val = prepare_instrumented_value (&bsi, value); + call = build_call_expr (tree_ior_profiler_fn, 2, ref_ptr, val); + bsi_insert_before (&bsi, call, BSI_SAME_STMT); +} + /* Return 1 if tree-based profiling is in effect, else 0. If it is, set up hooks for tree-based profiling. Gate for pass_tree_profile. */ @@ -237,7 +413,16 @@ do_tree_profiling (void) static unsigned int tree_profiling (void) { + /* Don't profile functions produced at destruction time, particularly + the gcov datastructure initializer. */ + if (cgraph_state == CGRAPH_STATE_FINISHED) + return 0; branch_prob (); + + if (! flag_branch_probabilities + && flag_profile_values) + tree_gen_ic_func_profiler (); + if (flag_branch_probabilities && flag_profile_values && flag_value_profile_transformations) @@ -263,45 +448,21 @@ struct tree_opt_pass pass_tree_profile = PROP_gimple_leh | PROP_cfg, /* properties_provided */ 0, /* properties_destroyed */ 0, /* todo_flags_start */ - TODO_verify_stmts, /* todo_flags_finish */ - 0 /* letter */ -}; - -/* Return 1 if tree-based profiling is in effect, else 0. - If it is, set up hooks for tree-based profiling. - Gate for pass_tree_profile. */ - -static bool -do_early_tree_profiling (void) -{ - return (do_tree_profiling () && (!flag_unit_at_a_time || !optimize)); -} - -struct tree_opt_pass pass_early_tree_profile = -{ - "early_tree_profile", /* name */ - do_early_tree_profiling, /* gate */ - tree_profiling, /* execute */ - NULL, /* sub */ - NULL, /* next */ - 0, /* static_pass_number */ - TV_BRANCH_PROB, /* tv_id */ - PROP_gimple_leh | PROP_cfg, /* properties_required */ - PROP_gimple_leh | PROP_cfg, /* properties_provided */ - 0, /* properties_destroyed */ - 0, /* todo_flags_start */ - TODO_verify_stmts, /* todo_flags_finish */ + TODO_verify_stmts | TODO_dump_func, /* todo_flags_finish */ 0 /* letter */ }; struct profile_hooks tree_profile_hooks = { - tree_init_edge_profiler, /* init_edge_profiler */ - tree_gen_edge_profiler, /* gen_edge_profiler */ - tree_gen_interval_profiler, /* gen_interval_profiler */ - tree_gen_pow2_profiler, /* gen_pow2_profiler */ - tree_gen_one_value_profiler, /* gen_one_value_profiler */ - tree_gen_const_delta_profiler /* gen_const_delta_profiler */ + tree_init_edge_profiler, /* init_edge_profiler */ + tree_gen_edge_profiler, /* gen_edge_profiler */ + tree_gen_interval_profiler, /* gen_interval_profiler */ + tree_gen_pow2_profiler, /* gen_pow2_profiler */ + tree_gen_one_value_profiler, /* gen_one_value_profiler */ + tree_gen_const_delta_profiler, /* gen_const_delta_profiler */ + tree_gen_ic_profiler, /* gen_ic_profiler */ + tree_gen_average_profiler, /* gen_average_profiler */ + tree_gen_ior_profiler /* gen_ior_profiler */ }; #include "gt-tree-profile.h"