/* Calculate branch probabilities, and basic block execution counts.
- Copyright (C) 1990-2016 Free Software Foundation, Inc.
+ Copyright (C) 1990-2017 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.
#include "profile.h"
#include "tree-cfgcleanup.h"
#include "params.h"
+#include "stringpool.h"
+#include "attribs.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_time_profiler_fn;
static GTY(()) tree tree_average_profiler_fn;
static GTY(()) tree tree_ior_profiler_fn;
+static GTY(()) tree tree_time_profiler_counter;
static GTY(()) tree ic_void_ptr_var;
static void
init_ic_make_global_vars (void)
{
- tree gcov_type_ptr;
+ tree gcov_type_ptr;
ptr_void = build_pointer_type (void_type_node);
if (targetm.have_tls)
set_decl_tls_model (ic_void_ptr_var, decl_default_tls_model (ic_void_ptr_var));
- varpool_node::finalize_decl (ic_void_ptr_var);
-
gcov_type_ptr = build_pointer_type (get_gcov_type ());
ic_gcov_type_ptr_var
DECL_INITIAL (ic_gcov_type_ptr_var) = NULL;
if (targetm.have_tls)
set_decl_tls_model (ic_gcov_type_ptr_var, decl_default_tls_model (ic_gcov_type_ptr_var));
-
- varpool_node::finalize_decl (ic_gcov_type_ptr_var);
}
/* Create the type and function decls for the interface with gcov. */
void
-gimple_init_edge_profiler (void)
+gimple_init_gcov_profiler (void)
{
tree interval_profiler_fn_type;
tree pow2_profiler_fn_type;
tree gcov_type_ptr;
tree ic_profiler_fn_type;
tree average_profiler_fn_type;
- tree time_profiler_fn_type;
const char *profiler_fn_name;
const char *fn_name;
= tree_cons (get_identifier ("leaf"), NULL,
DECL_ATTRIBUTES (tree_indirect_call_profiler_fn));
- /* void (*) (gcov_type *, gcov_type, void *) */
- time_profiler_fn_type
- = build_function_type_list (void_type_node,
- gcov_type_ptr, NULL_TREE);
- fn_name = concat ("__gcov_time_profiler", fn_suffix, NULL);
- tree_time_profiler_fn = build_fn_decl (fn_name, time_profiler_fn_type);
- free (CONST_CAST (char *, fn_name));
- TREE_NOTHROW (tree_time_profiler_fn) = 1;
- DECL_ATTRIBUTES (tree_time_profiler_fn)
- = tree_cons (get_identifier ("leaf"), NULL,
- DECL_ATTRIBUTES (tree_time_profiler_fn));
+ tree_time_profiler_counter
+ = build_decl (UNKNOWN_LOCATION, VAR_DECL,
+ get_identifier ("__gcov_time_profiler_counter"),
+ get_gcov_type ());
+ TREE_PUBLIC (tree_time_profiler_counter) = 1;
+ DECL_EXTERNAL (tree_time_profiler_counter) = 1;
+ TREE_STATIC (tree_time_profiler_counter) = 1;
+ DECL_ARTIFICIAL (tree_time_profiler_counter) = 1;
+ DECL_INITIAL (tree_time_profiler_counter) = NULL;
/* void (*) (gcov_type *, gcov_type) */
average_profiler_fn_type
DECL_ASSEMBLER_NAME (tree_pow2_profiler_fn);
DECL_ASSEMBLER_NAME (tree_one_value_profiler_fn);
DECL_ASSEMBLER_NAME (tree_indirect_call_profiler_fn);
- DECL_ASSEMBLER_NAME (tree_time_profiler_fn);
DECL_ASSEMBLER_NAME (tree_average_profiler_fn);
DECL_ASSEMBLER_NAME (tree_ior_profiler_fn);
}
stmt1: __gcov_indirect_call_counters = get_relevant_counter_ptr ();
stmt2: tmp1 = (void *) (indirect call argument value)
stmt3: __gcov_indirect_call_callee = tmp1;
+
+ Example:
+ f_1 = foo;
+ __gcov_indirect_call_counters = &__gcov4.main[0];
+ PROF_9 = f_1;
+ __gcov_indirect_call_callee = PROF_9;
+ _4 = f_1 ();
*/
stmt1 = gimple_build_assign (ic_gcov_type_ptr_var, ref_ptr);
gimple_gen_ic_func_profiler (void)
{
struct cgraph_node * c_node = cgraph_node::get (current_function_decl);
- gimple_stmt_iterator gsi;
gcall *stmt1;
- gassign *stmt2;
tree tree_uid, cur_func, void0;
if (c_node->only_called_directly_p ())
return;
- gimple_init_edge_profiler ();
+ gimple_init_gcov_profiler ();
+
+ basic_block entry = ENTRY_BLOCK_PTR_FOR_FN (cfun);
+ basic_block cond_bb = split_edge (single_succ_edge (entry));
+ basic_block update_bb = split_edge (single_succ_edge (cond_bb));
+
+ /* We need to do an extra split in order to not create an input
+ for a possible PHI node. */
+ split_edge (single_succ_edge (update_bb));
+
+ edge true_edge = single_succ_edge (cond_bb);
+ true_edge->flags = EDGE_TRUE_VALUE;
+
+ profile_probability probability;
+ if (DECL_VIRTUAL_P (current_function_decl))
+ probability = profile_probability::very_likely ();
+ else
+ probability = profile_probability::unlikely ();
+
+ true_edge->probability = probability;
+ edge e = make_edge (cond_bb, single_succ_edge (update_bb)->dest,
+ EDGE_FALSE_VALUE);
+ e->probability = true_edge->probability.invert ();
/* Insert code:
- stmt1: __gcov_indirect_call_profiler_v2 (profile_id,
- ¤t_function_decl)
- */
- gsi = gsi_after_labels (split_edge (single_succ_edge
- (ENTRY_BLOCK_PTR_FOR_FN (cfun))));
+ if (__gcov_indirect_call_callee != NULL)
+ __gcov_indirect_call_profiler_v2 (profile_id, ¤t_function_decl);
+
+ The function __gcov_indirect_call_profiler_v2 is responsible for
+ resetting __gcov_indirect_call_callee to NULL. */
+
+ gimple_stmt_iterator gsi = gsi_start_bb (cond_bb);
+ void0 = build_int_cst (build_pointer_type (void_type_node), 0);
+
+ tree ref = force_gimple_operand_gsi (&gsi, ic_void_ptr_var, true, NULL_TREE,
+ true, GSI_SAME_STMT);
+
+ gcond *cond = gimple_build_cond (NE_EXPR, ref,
+ void0, NULL, NULL);
+ gsi_insert_before (&gsi, cond, GSI_NEW_STMT);
+
+ gsi = gsi_after_labels (update_bb);
cur_func = force_gimple_operand_gsi (&gsi,
build_addr (current_function_decl),
stmt1 = gimple_build_call (tree_indirect_call_profiler_fn, 2,
tree_uid, cur_func);
gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
-
- /* Set __gcov_indirect_call_callee to 0,
- so that calls from other modules won't get misattributed
- to the last caller of the current callee. */
- void0 = build_int_cst (build_pointer_type (void_type_node), 0);
- stmt2 = gimple_build_assign (ic_void_ptr_var, void0);
- gsi_insert_before (&gsi, stmt2, GSI_SAME_STMT);
}
/* Output instructions as GIMPLE tree at the beginning for each function.
counter position and GSI is the iterator we place the counter. */
void
-gimple_gen_time_profiler (unsigned tag, unsigned base,
- gimple_stmt_iterator &gsi)
+gimple_gen_time_profiler (unsigned tag, unsigned base)
{
- tree ref_ptr = tree_coverage_counter_addr (tag, base);
- gcall *call;
+ tree type = get_gcov_type ();
+ basic_block entry = ENTRY_BLOCK_PTR_FOR_FN (cfun);
+ basic_block cond_bb = split_edge (single_succ_edge (entry));
+ basic_block update_bb = split_edge (single_succ_edge (cond_bb));
+
+ /* We need to do an extra split in order to not create an input
+ for a possible PHI node. */
+ split_edge (single_succ_edge (update_bb));
+
+ edge true_edge = single_succ_edge (cond_bb);
+ true_edge->flags = EDGE_TRUE_VALUE;
+ true_edge->probability = profile_probability::unlikely ();
+ edge e
+ = make_edge (cond_bb, single_succ_edge (update_bb)->dest, EDGE_FALSE_VALUE);
+ e->probability = true_edge->probability.invert ();
+
+ gimple_stmt_iterator gsi = gsi_start_bb (cond_bb);
+ tree original_ref = tree_coverage_counter_ref (tag, base);
+ tree ref = force_gimple_operand_gsi (&gsi, original_ref, true, NULL_TREE,
+ true, GSI_SAME_STMT);
+ tree one = build_int_cst (type, 1);
- ref_ptr = force_gimple_operand_gsi (&gsi, ref_ptr,
- true, NULL_TREE, true, GSI_SAME_STMT);
- call = gimple_build_call (tree_time_profiler_fn, 1, ref_ptr);
- gsi_insert_before (&gsi, call, GSI_NEW_STMT);
+ /* Emit: if (counters[0] != 0). */
+ gcond *cond = gimple_build_cond (EQ_EXPR, ref, build_int_cst (type, 0),
+ NULL, NULL);
+ gsi_insert_before (&gsi, cond, GSI_NEW_STMT);
+
+ gsi = gsi_start_bb (update_bb);
+
+ /* Emit: counters[0] = ++__gcov_time_profiler_counter. */
+ if (flag_profile_update == PROFILE_UPDATE_ATOMIC)
+ {
+ tree ptr = make_temp_ssa_name (build_pointer_type (type), NULL,
+ "time_profiler_counter_ptr");
+ tree addr = build1 (ADDR_EXPR, TREE_TYPE (ptr),
+ tree_time_profiler_counter);
+ gassign *assign = gimple_build_assign (ptr, NOP_EXPR, addr);
+ gsi_insert_before (&gsi, assign, GSI_NEW_STMT);
+ tree f = builtin_decl_explicit (LONG_LONG_TYPE_SIZE > 32
+ ? BUILT_IN_ATOMIC_ADD_FETCH_8:
+ BUILT_IN_ATOMIC_ADD_FETCH_4);
+ gcall *stmt = gimple_build_call (f, 3, ptr, one,
+ build_int_cst (integer_type_node,
+ MEMMODEL_RELAXED));
+ tree result_type = TREE_TYPE (TREE_TYPE (f));
+ tree tmp = make_temp_ssa_name (result_type, NULL, "time_profile");
+ gimple_set_lhs (stmt, tmp);
+ gsi_insert_after (&gsi, stmt, GSI_NEW_STMT);
+ tmp = make_temp_ssa_name (type, NULL, "time_profile");
+ assign = gimple_build_assign (tmp, NOP_EXPR,
+ gimple_call_lhs (stmt));
+ gsi_insert_after (&gsi, assign, GSI_NEW_STMT);
+ assign = gimple_build_assign (original_ref, tmp);
+ gsi_insert_after (&gsi, assign, GSI_NEW_STMT);
+ }
+ else
+ {
+ tree tmp = make_temp_ssa_name (type, NULL, "time_profile");
+ gassign *assign = gimple_build_assign (tmp, tree_time_profiler_counter);
+ gsi_insert_before (&gsi, assign, GSI_NEW_STMT);
+
+ tmp = make_temp_ssa_name (type, NULL, "time_profile");
+ assign = gimple_build_assign (tmp, PLUS_EXPR, gimple_assign_lhs (assign),
+ one);
+ gsi_insert_after (&gsi, assign, GSI_NEW_STMT);
+ assign = gimple_build_assign (original_ref, tmp);
+ gsi_insert_after (&gsi, assign, GSI_NEW_STMT);
+ assign = gimple_build_assign (tree_time_profiler_counter, tmp);
+ gsi_insert_after (&gsi, assign, GSI_NEW_STMT);
+ }
}
/* Output instructions as GIMPLE trees to increment the average histogram
struct cgraph_node *node;
/* Verify whether we can utilize atomic update operations. */
- if (flag_profile_update == PROFILE_UPDATE_ATOMIC)
+ bool can_support_atomic = false;
+ unsigned HOST_WIDE_INT gcov_type_size
+ = tree_to_uhwi (TYPE_SIZE_UNIT (get_gcov_type ()));
+ if (gcov_type_size == 4)
+ can_support_atomic
+ = HAVE_sync_compare_and_swapsi || HAVE_atomic_compare_and_swapsi;
+ else if (gcov_type_size == 8)
+ can_support_atomic
+ = HAVE_sync_compare_and_swapdi || HAVE_atomic_compare_and_swapdi;
+
+ if (flag_profile_update == PROFILE_UPDATE_ATOMIC
+ && !can_support_atomic)
{
- bool can_support = false;
- unsigned HOST_WIDE_INT gcov_type_size
- = tree_to_uhwi (TYPE_SIZE_UNIT (get_gcov_type ()));
- if (gcov_type_size == 4)
- can_support
- = HAVE_sync_compare_and_swapsi || HAVE_atomic_compare_and_swapsi;
- else if (gcov_type_size == 8)
- can_support
- = HAVE_sync_compare_and_swapdi || HAVE_atomic_compare_and_swapdi;
-
- if (!can_support)
- {
- warning (0, "target does not support atomic profile update, "
- "single mode is selected");
- flag_profile_update = PROFILE_UPDATE_SINGLE;
- }
+ warning (0, "target does not support atomic profile update, "
+ "single mode is selected");
+ flag_profile_update = PROFILE_UPDATE_SINGLE;
}
+ else if (flag_profile_update == PROFILE_UPDATE_PREFER_ATOMIC)
+ flag_profile_update = can_support_atomic
+ ? PROFILE_UPDATE_ATOMIC : PROFILE_UPDATE_SINGLE;
/* This is a small-ipa pass that gets called only once, from
cgraphunit.c:ipa_passes(). */
projects / gcc.git / blobdiff