706 lines
23 KiB
C
706 lines
23 KiB
C
/* Calculate branch probabilities, and basic block execution counts.
|
|
Copyright (C) 1990-2013 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.
|
|
Converted to use trees by Dale Johannesen, Apple Computer.
|
|
|
|
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 3, or (at your option) any later
|
|
version.
|
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
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 COPYING3. If not see
|
|
<http://www.gnu.org/licenses/>. */
|
|
|
|
/* Generate basic block profile instrumentation and auxiliary files.
|
|
Tree-based version. See profile.c for overview. */
|
|
|
|
#include "config.h"
|
|
#include "system.h"
|
|
#include "coretypes.h"
|
|
#include "tm.h"
|
|
#include "flags.h"
|
|
#include "function.h"
|
|
#include "basic-block.h"
|
|
#include "diagnostic-core.h"
|
|
#include "coverage.h"
|
|
#include "tree.h"
|
|
#include "gimple.h"
|
|
#include "gimplify.h"
|
|
#include "gimple-iterator.h"
|
|
#include "gimplify-me.h"
|
|
#include "gimple-ssa.h"
|
|
#include "cgraph.h"
|
|
#include "tree-cfg.h"
|
|
#include "tree-ssanames.h"
|
|
#include "tree-into-ssa.h"
|
|
#include "tree-pass.h"
|
|
#include "value-prof.h"
|
|
#include "profile.h"
|
|
#include "target.h"
|
|
#include "tree-cfgcleanup.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 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:
|
|
__thread gcov* __gcov_indirect_call_counters; // pointer to actual counter
|
|
__thread void* __gcov_indirect_call_callee; // actual callee address
|
|
__thread int __gcov_function_counter; // time profiler function counter
|
|
*/
|
|
static void
|
|
init_ic_make_global_vars (void)
|
|
{
|
|
tree gcov_type_ptr;
|
|
|
|
ptr_void = build_pointer_type (void_type_node);
|
|
|
|
/* Workaround for binutils bug 14342. Once it is fixed, remove lto path. */
|
|
if (flag_lto)
|
|
{
|
|
ic_void_ptr_var
|
|
= build_decl (UNKNOWN_LOCATION, VAR_DECL,
|
|
get_identifier ("__gcov_indirect_call_callee_ltopriv"),
|
|
ptr_void);
|
|
TREE_PUBLIC (ic_void_ptr_var) = 1;
|
|
DECL_COMMON (ic_void_ptr_var) = 1;
|
|
DECL_VISIBILITY (ic_void_ptr_var) = VISIBILITY_HIDDEN;
|
|
DECL_VISIBILITY_SPECIFIED (ic_void_ptr_var) = true;
|
|
}
|
|
else
|
|
{
|
|
ic_void_ptr_var
|
|
= build_decl (UNKNOWN_LOCATION, VAR_DECL,
|
|
get_identifier ("__gcov_indirect_call_callee"),
|
|
ptr_void);
|
|
TREE_PUBLIC (ic_void_ptr_var) = 1;
|
|
DECL_EXTERNAL (ic_void_ptr_var) = 1;
|
|
}
|
|
TREE_STATIC (ic_void_ptr_var) = 1;
|
|
DECL_ARTIFICIAL (ic_void_ptr_var) = 1;
|
|
DECL_INITIAL (ic_void_ptr_var) = NULL;
|
|
if (targetm.have_tls)
|
|
DECL_TLS_MODEL (ic_void_ptr_var) =
|
|
decl_default_tls_model (ic_void_ptr_var);
|
|
|
|
varpool_finalize_decl (ic_void_ptr_var);
|
|
|
|
gcov_type_ptr = build_pointer_type (get_gcov_type ());
|
|
/* Workaround for binutils bug 14342. Once it is fixed, remove lto path. */
|
|
if (flag_lto)
|
|
{
|
|
ic_gcov_type_ptr_var
|
|
= build_decl (UNKNOWN_LOCATION, VAR_DECL,
|
|
get_identifier ("__gcov_indirect_call_counters_ltopriv"),
|
|
gcov_type_ptr);
|
|
TREE_PUBLIC (ic_gcov_type_ptr_var) = 1;
|
|
DECL_COMMON (ic_gcov_type_ptr_var) = 1;
|
|
DECL_VISIBILITY (ic_gcov_type_ptr_var) = VISIBILITY_HIDDEN;
|
|
DECL_VISIBILITY_SPECIFIED (ic_gcov_type_ptr_var) = true;
|
|
}
|
|
else
|
|
{
|
|
ic_gcov_type_ptr_var
|
|
= build_decl (UNKNOWN_LOCATION, VAR_DECL,
|
|
get_identifier ("__gcov_indirect_call_counters"),
|
|
gcov_type_ptr);
|
|
TREE_PUBLIC (ic_gcov_type_ptr_var) = 1;
|
|
DECL_EXTERNAL (ic_gcov_type_ptr_var) = 1;
|
|
}
|
|
TREE_STATIC (ic_gcov_type_ptr_var) = 1;
|
|
DECL_ARTIFICIAL (ic_gcov_type_ptr_var) = 1;
|
|
DECL_INITIAL (ic_gcov_type_ptr_var) = NULL;
|
|
if (targetm.have_tls)
|
|
DECL_TLS_MODEL (ic_gcov_type_ptr_var) =
|
|
decl_default_tls_model (ic_gcov_type_ptr_var);
|
|
|
|
varpool_finalize_decl (ic_gcov_type_ptr_var);
|
|
}
|
|
|
|
/* Create the type and function decls for the interface with gcov. */
|
|
|
|
void
|
|
gimple_init_edge_profiler (void)
|
|
{
|
|
tree interval_profiler_fn_type;
|
|
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;
|
|
tree time_profiler_fn_type;
|
|
|
|
if (!gcov_type_node)
|
|
{
|
|
gcov_type_node = get_gcov_type ();
|
|
gcov_type_ptr = build_pointer_type (gcov_type_node);
|
|
|
|
/* void (*) (gcov_type *, gcov_type, int, unsigned) */
|
|
interval_profiler_fn_type
|
|
= build_function_type_list (void_type_node,
|
|
gcov_type_ptr, gcov_type_node,
|
|
integer_type_node,
|
|
unsigned_type_node, NULL_TREE);
|
|
tree_interval_profiler_fn
|
|
= build_fn_decl ("__gcov_interval_profiler",
|
|
interval_profiler_fn_type);
|
|
TREE_NOTHROW (tree_interval_profiler_fn) = 1;
|
|
DECL_ATTRIBUTES (tree_interval_profiler_fn)
|
|
= tree_cons (get_identifier ("leaf"), NULL,
|
|
DECL_ATTRIBUTES (tree_interval_profiler_fn));
|
|
|
|
/* void (*) (gcov_type *, gcov_type) */
|
|
pow2_profiler_fn_type
|
|
= build_function_type_list (void_type_node,
|
|
gcov_type_ptr, gcov_type_node,
|
|
NULL_TREE);
|
|
tree_pow2_profiler_fn = build_fn_decl ("__gcov_pow2_profiler",
|
|
pow2_profiler_fn_type);
|
|
TREE_NOTHROW (tree_pow2_profiler_fn) = 1;
|
|
DECL_ATTRIBUTES (tree_pow2_profiler_fn)
|
|
= tree_cons (get_identifier ("leaf"), NULL,
|
|
DECL_ATTRIBUTES (tree_pow2_profiler_fn));
|
|
|
|
/* void (*) (gcov_type *, gcov_type) */
|
|
one_value_profiler_fn_type
|
|
= build_function_type_list (void_type_node,
|
|
gcov_type_ptr, gcov_type_node,
|
|
NULL_TREE);
|
|
tree_one_value_profiler_fn
|
|
= build_fn_decl ("__gcov_one_value_profiler",
|
|
one_value_profiler_fn_type);
|
|
TREE_NOTHROW (tree_one_value_profiler_fn) = 1;
|
|
DECL_ATTRIBUTES (tree_one_value_profiler_fn)
|
|
= tree_cons (get_identifier ("leaf"), NULL,
|
|
DECL_ATTRIBUTES (tree_one_value_profiler_fn));
|
|
|
|
init_ic_make_global_vars ();
|
|
|
|
/* Workaround for binutils bug 14342. Once it is fixed, remove lto path. */
|
|
if (flag_lto)
|
|
{
|
|
/* void (*) (gcov_type, 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);
|
|
}
|
|
else
|
|
{
|
|
/* void (*) (gcov_type, void *) */
|
|
ic_profiler_fn_type
|
|
= build_function_type_list (void_type_node,
|
|
gcov_type_node,
|
|
ptr_void,
|
|
NULL_TREE);
|
|
tree_indirect_call_profiler_fn
|
|
= build_fn_decl ("__gcov_indirect_call_profiler_v2",
|
|
ic_profiler_fn_type);
|
|
}
|
|
TREE_NOTHROW (tree_indirect_call_profiler_fn) = 1;
|
|
DECL_ATTRIBUTES (tree_indirect_call_profiler_fn)
|
|
= 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);
|
|
tree_time_profiler_fn
|
|
= build_fn_decl ("__gcov_time_profiler",
|
|
time_profiler_fn_type);
|
|
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));
|
|
|
|
/* 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_NOTHROW (tree_average_profiler_fn) = 1;
|
|
DECL_ATTRIBUTES (tree_average_profiler_fn)
|
|
= tree_cons (get_identifier ("leaf"), NULL,
|
|
DECL_ATTRIBUTES (tree_average_profiler_fn));
|
|
tree_ior_profiler_fn
|
|
= build_fn_decl ("__gcov_ior_profiler",
|
|
average_profiler_fn_type);
|
|
TREE_NOTHROW (tree_ior_profiler_fn) = 1;
|
|
DECL_ATTRIBUTES (tree_ior_profiler_fn)
|
|
= tree_cons (get_identifier ("leaf"), NULL,
|
|
DECL_ATTRIBUTES (tree_ior_profiler_fn));
|
|
|
|
/* LTO streamer needs assembler names. Because we create these decls
|
|
late, we need to initialize them by hand. */
|
|
DECL_ASSEMBLER_NAME (tree_interval_profiler_fn);
|
|
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);
|
|
}
|
|
}
|
|
|
|
/* Output instructions as GIMPLE trees to increment the edge
|
|
execution count, and insert them on E. We rely on
|
|
gsi_insert_on_edge to preserve the order. */
|
|
|
|
void
|
|
gimple_gen_edge_profiler (int edgeno, edge e)
|
|
{
|
|
tree ref, one, gcov_type_tmp_var;
|
|
gimple stmt1, stmt2, stmt3;
|
|
|
|
ref = tree_coverage_counter_ref (GCOV_COUNTER_ARCS, edgeno);
|
|
one = build_int_cst (gcov_type_node, 1);
|
|
gcov_type_tmp_var = make_temp_ssa_name (gcov_type_node,
|
|
NULL, "PROF_edge_counter");
|
|
stmt1 = gimple_build_assign (gcov_type_tmp_var, ref);
|
|
gcov_type_tmp_var = make_temp_ssa_name (gcov_type_node,
|
|
NULL, "PROF_edge_counter");
|
|
stmt2 = gimple_build_assign_with_ops (PLUS_EXPR, gcov_type_tmp_var,
|
|
gimple_assign_lhs (stmt1), one);
|
|
stmt3 = gimple_build_assign (unshare_expr (ref), gimple_assign_lhs (stmt2));
|
|
gsi_insert_on_edge (e, stmt1);
|
|
gsi_insert_on_edge (e, stmt2);
|
|
gsi_insert_on_edge (e, stmt3);
|
|
}
|
|
|
|
/* Emits code to get VALUE to instrument at GSI, and returns the
|
|
variable containing the value. */
|
|
|
|
static tree
|
|
prepare_instrumented_value (gimple_stmt_iterator *gsi, histogram_value value)
|
|
{
|
|
tree val = value->hvalue.value;
|
|
if (POINTER_TYPE_P (TREE_TYPE (val)))
|
|
val = fold_convert (build_nonstandard_integer_type
|
|
(TYPE_PRECISION (TREE_TYPE (val)), 1), val);
|
|
return force_gimple_operand_gsi (gsi, fold_convert (gcov_type_node, val),
|
|
true, NULL_TREE, true, GSI_SAME_STMT);
|
|
}
|
|
|
|
/* Output instructions as GIMPLE trees to increment the interval 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. */
|
|
|
|
void
|
|
gimple_gen_interval_profiler (histogram_value value, unsigned tag, unsigned base)
|
|
{
|
|
gimple stmt = value->hvalue.stmt;
|
|
gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
|
|
tree ref = tree_coverage_counter_ref (tag, base), ref_ptr;
|
|
gimple call;
|
|
tree 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_gsi (&gsi,
|
|
build_addr (ref, current_function_decl),
|
|
true, NULL_TREE, true, GSI_SAME_STMT);
|
|
val = prepare_instrumented_value (&gsi, value);
|
|
call = gimple_build_call (tree_interval_profiler_fn, 4,
|
|
ref_ptr, val, start, steps);
|
|
gsi_insert_before (&gsi, call, GSI_NEW_STMT);
|
|
}
|
|
|
|
/* Output instructions as GIMPLE trees to increment the power of two 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. */
|
|
|
|
void
|
|
gimple_gen_pow2_profiler (histogram_value value, unsigned tag, unsigned base)
|
|
{
|
|
gimple stmt = value->hvalue.stmt;
|
|
gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
|
|
tree ref_ptr = tree_coverage_counter_addr (tag, base);
|
|
gimple call;
|
|
tree val;
|
|
|
|
ref_ptr = force_gimple_operand_gsi (&gsi, ref_ptr,
|
|
true, NULL_TREE, true, GSI_SAME_STMT);
|
|
val = prepare_instrumented_value (&gsi, value);
|
|
call = gimple_build_call (tree_pow2_profiler_fn, 2, ref_ptr, val);
|
|
gsi_insert_before (&gsi, call, GSI_NEW_STMT);
|
|
}
|
|
|
|
/* Output instructions as GIMPLE trees for code to find the most common value.
|
|
VALUE is the expression whose value is profiled. TAG is the tag of the
|
|
section for counters, BASE is offset of the counter position. */
|
|
|
|
void
|
|
gimple_gen_one_value_profiler (histogram_value value, unsigned tag, unsigned base)
|
|
{
|
|
gimple stmt = value->hvalue.stmt;
|
|
gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
|
|
tree ref_ptr = tree_coverage_counter_addr (tag, base);
|
|
gimple call;
|
|
tree val;
|
|
|
|
ref_ptr = force_gimple_operand_gsi (&gsi, ref_ptr,
|
|
true, NULL_TREE, true, GSI_SAME_STMT);
|
|
val = prepare_instrumented_value (&gsi, value);
|
|
call = gimple_build_call (tree_one_value_profiler_fn, 2, ref_ptr, val);
|
|
gsi_insert_before (&gsi, call, GSI_NEW_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. */
|
|
|
|
void
|
|
gimple_gen_ic_profiler (histogram_value value, unsigned tag, unsigned base)
|
|
{
|
|
tree tmp1;
|
|
gimple stmt1, stmt2, stmt3;
|
|
gimple stmt = value->hvalue.stmt;
|
|
gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
|
|
tree ref_ptr = tree_coverage_counter_addr (tag, base);
|
|
|
|
ref_ptr = force_gimple_operand_gsi (&gsi, ref_ptr,
|
|
true, NULL_TREE, true, GSI_SAME_STMT);
|
|
|
|
/* Insert code:
|
|
|
|
stmt1: __gcov_indirect_call_counters = get_relevant_counter_ptr ();
|
|
stmt2: tmp1 = (void *) (indirect call argument value)
|
|
stmt3: __gcov_indirect_call_callee = tmp1;
|
|
*/
|
|
|
|
stmt1 = gimple_build_assign (ic_gcov_type_ptr_var, ref_ptr);
|
|
tmp1 = make_temp_ssa_name (ptr_void, NULL, "PROF");
|
|
stmt2 = gimple_build_assign (tmp1, unshare_expr (value->hvalue.value));
|
|
stmt3 = gimple_build_assign (ic_void_ptr_var, gimple_assign_lhs (stmt2));
|
|
|
|
gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
|
|
gsi_insert_before (&gsi, stmt2, GSI_SAME_STMT);
|
|
gsi_insert_before (&gsi, stmt3, GSI_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.
|
|
*/
|
|
|
|
void
|
|
gimple_gen_ic_func_profiler (void)
|
|
{
|
|
struct cgraph_node * c_node = cgraph_get_node (current_function_decl);
|
|
gimple_stmt_iterator gsi;
|
|
gimple stmt1, stmt2;
|
|
tree tree_uid, cur_func, void0;
|
|
|
|
if (cgraph_only_called_directly_p (c_node))
|
|
return;
|
|
|
|
gimple_init_edge_profiler ();
|
|
|
|
/* 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)));
|
|
|
|
cur_func = force_gimple_operand_gsi (&gsi,
|
|
build_addr (current_function_decl,
|
|
current_function_decl),
|
|
true, NULL_TREE,
|
|
true, GSI_SAME_STMT);
|
|
tree_uid = build_int_cst
|
|
(gcov_type_node, cgraph_get_node (current_function_decl)->profile_id);
|
|
/* Workaround for binutils bug 14342. Once it is fixed, remove lto path. */
|
|
if (flag_lto)
|
|
{
|
|
tree counter_ptr, ptr_var;
|
|
counter_ptr = force_gimple_operand_gsi (&gsi, ic_gcov_type_ptr_var,
|
|
true, NULL_TREE, true,
|
|
GSI_SAME_STMT);
|
|
ptr_var = force_gimple_operand_gsi (&gsi, ic_void_ptr_var,
|
|
true, NULL_TREE, true,
|
|
GSI_SAME_STMT);
|
|
|
|
stmt1 = gimple_build_call (tree_indirect_call_profiler_fn, 4,
|
|
counter_ptr, tree_uid, cur_func, ptr_var);
|
|
}
|
|
else
|
|
{
|
|
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.
|
|
TAG is the tag of the section for counters, BASE is offset of the
|
|
counter position and GSI is the iterator we place the counter. */
|
|
|
|
void
|
|
gimple_gen_time_profiler (unsigned tag, unsigned base,
|
|
gimple_stmt_iterator &gsi)
|
|
{
|
|
tree ref_ptr = tree_coverage_counter_addr (tag, base);
|
|
gimple call;
|
|
|
|
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);
|
|
}
|
|
|
|
/* 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
|
|
section for counters, BASE is offset of the counter position. */
|
|
|
|
void
|
|
gimple_gen_const_delta_profiler (histogram_value value ATTRIBUTE_UNUSED,
|
|
unsigned tag ATTRIBUTE_UNUSED,
|
|
unsigned base ATTRIBUTE_UNUSED)
|
|
{
|
|
/* FIXME implement this. */
|
|
#ifdef ENABLE_CHECKING
|
|
internal_error ("unimplemented functionality");
|
|
#endif
|
|
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. */
|
|
|
|
void
|
|
gimple_gen_average_profiler (histogram_value value, unsigned tag, unsigned base)
|
|
{
|
|
gimple stmt = value->hvalue.stmt;
|
|
gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
|
|
tree ref_ptr = tree_coverage_counter_addr (tag, base);
|
|
gimple call;
|
|
tree val;
|
|
|
|
ref_ptr = force_gimple_operand_gsi (&gsi, ref_ptr,
|
|
true, NULL_TREE,
|
|
true, GSI_SAME_STMT);
|
|
val = prepare_instrumented_value (&gsi, value);
|
|
call = gimple_build_call (tree_average_profiler_fn, 2, ref_ptr, val);
|
|
gsi_insert_before (&gsi, call, GSI_NEW_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. */
|
|
|
|
void
|
|
gimple_gen_ior_profiler (histogram_value value, unsigned tag, unsigned base)
|
|
{
|
|
gimple stmt = value->hvalue.stmt;
|
|
gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
|
|
tree ref_ptr = tree_coverage_counter_addr (tag, base);
|
|
gimple call;
|
|
tree val;
|
|
|
|
ref_ptr = force_gimple_operand_gsi (&gsi, ref_ptr,
|
|
true, NULL_TREE, true, GSI_SAME_STMT);
|
|
val = prepare_instrumented_value (&gsi, value);
|
|
call = gimple_build_call (tree_ior_profiler_fn, 2, ref_ptr, val);
|
|
gsi_insert_before (&gsi, call, GSI_NEW_STMT);
|
|
}
|
|
|
|
/* Profile all functions in the callgraph. */
|
|
|
|
static unsigned int
|
|
tree_profiling (void)
|
|
{
|
|
struct cgraph_node *node;
|
|
|
|
/* This is a small-ipa pass that gets called only once, from
|
|
cgraphunit.c:ipa_passes(). */
|
|
gcc_assert (cgraph_state == CGRAPH_STATE_IPA_SSA);
|
|
|
|
init_node_map (true);
|
|
|
|
FOR_EACH_DEFINED_FUNCTION (node)
|
|
{
|
|
if (!gimple_has_body_p (node->decl))
|
|
continue;
|
|
|
|
/* Don't profile functions produced for builtin stuff. */
|
|
if (DECL_SOURCE_LOCATION (node->decl) == BUILTINS_LOCATION)
|
|
continue;
|
|
|
|
push_cfun (DECL_STRUCT_FUNCTION (node->decl));
|
|
|
|
/* Local pure-const may imply need to fixup the cfg. */
|
|
if (execute_fixup_cfg () & TODO_cleanup_cfg)
|
|
cleanup_tree_cfg ();
|
|
|
|
branch_prob ();
|
|
|
|
if (! flag_branch_probabilities
|
|
&& flag_profile_values)
|
|
gimple_gen_ic_func_profiler ();
|
|
|
|
if (flag_branch_probabilities
|
|
&& flag_profile_values
|
|
&& flag_value_profile_transformations)
|
|
gimple_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);
|
|
pop_cfun ();
|
|
}
|
|
|
|
/* Drop pure/const flags from instrumented functions. */
|
|
FOR_EACH_DEFINED_FUNCTION (node)
|
|
{
|
|
if (!gimple_has_body_p (node->decl)
|
|
|| !(!node->clone_of
|
|
|| node->decl != node->clone_of->decl))
|
|
continue;
|
|
|
|
/* Don't profile functions produced for builtin stuff. */
|
|
if (DECL_SOURCE_LOCATION (node->decl) == BUILTINS_LOCATION)
|
|
continue;
|
|
|
|
cgraph_set_const_flag (node, false, false);
|
|
cgraph_set_pure_flag (node, false, false);
|
|
}
|
|
|
|
/* Update call statements and rebuild the cgraph. */
|
|
FOR_EACH_DEFINED_FUNCTION (node)
|
|
{
|
|
basic_block bb;
|
|
|
|
if (!gimple_has_body_p (node->decl)
|
|
|| !(!node->clone_of
|
|
|| node->decl != node->clone_of->decl))
|
|
continue;
|
|
|
|
/* Don't profile functions produced for builtin stuff. */
|
|
if (DECL_SOURCE_LOCATION (node->decl) == BUILTINS_LOCATION)
|
|
continue;
|
|
|
|
push_cfun (DECL_STRUCT_FUNCTION (node->decl));
|
|
|
|
FOR_EACH_BB (bb)
|
|
{
|
|
gimple_stmt_iterator gsi;
|
|
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
|
|
{
|
|
gimple stmt = gsi_stmt (gsi);
|
|
if (is_gimple_call (stmt))
|
|
update_stmt (stmt);
|
|
}
|
|
}
|
|
|
|
/* re-merge split blocks. */
|
|
cleanup_tree_cfg ();
|
|
update_ssa (TODO_update_ssa);
|
|
|
|
rebuild_cgraph_edges ();
|
|
|
|
pop_cfun ();
|
|
}
|
|
|
|
handle_missing_profiles ();
|
|
|
|
del_node_map ();
|
|
return 0;
|
|
}
|
|
|
|
/* When profile instrumentation, use or test coverage shall be performed. */
|
|
|
|
static bool
|
|
gate_tree_profile_ipa (void)
|
|
{
|
|
return (!in_lto_p
|
|
&& (flag_branch_probabilities || flag_test_coverage
|
|
|| profile_arc_flag));
|
|
}
|
|
|
|
namespace {
|
|
|
|
const pass_data pass_data_ipa_tree_profile =
|
|
{
|
|
SIMPLE_IPA_PASS, /* type */
|
|
"profile", /* name */
|
|
OPTGROUP_NONE, /* optinfo_flags */
|
|
true, /* has_gate */
|
|
true, /* has_execute */
|
|
TV_IPA_PROFILE, /* tv_id */
|
|
0, /* properties_required */
|
|
0, /* properties_provided */
|
|
0, /* properties_destroyed */
|
|
0, /* todo_flags_start */
|
|
0, /* todo_flags_finish */
|
|
};
|
|
|
|
class pass_ipa_tree_profile : public simple_ipa_opt_pass
|
|
{
|
|
public:
|
|
pass_ipa_tree_profile (gcc::context *ctxt)
|
|
: simple_ipa_opt_pass (pass_data_ipa_tree_profile, ctxt)
|
|
{}
|
|
|
|
/* opt_pass methods: */
|
|
bool gate () { return gate_tree_profile_ipa (); }
|
|
unsigned int execute () { return tree_profiling (); }
|
|
|
|
}; // class pass_ipa_tree_profile
|
|
|
|
} // anon namespace
|
|
|
|
simple_ipa_opt_pass *
|
|
make_pass_ipa_tree_profile (gcc::context *ctxt)
|
|
{
|
|
return new pass_ipa_tree_profile (ctxt);
|
|
}
|
|
|
|
#include "gt-tree-profile.h"
|