/* 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, 2006, 2007, 2008, 2010
- Free Software Foundation, Inc.
+ Copyright (C) 1990-2015 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 "coretypes.h"
#include "tm.h"
#include "flags.h"
-#include "regs.h"
+#include "hard-reg-set.h"
#include "function.h"
+#include "predict.h"
+#include "dominance.h"
+#include "cfg.h"
#include "basic-block.h"
#include "diagnostic-core.h"
#include "coverage.h"
+#include "alias.h"
+#include "symtab.h"
#include "tree.h"
-#include "tree-flow.h"
-#include "tree-dump.h"
+#include "fold-const.h"
+#include "tree-ssa-alias.h"
+#include "internal-fn.h"
+#include "gimple-expr.h"
+#include "gimple.h"
+#include "varasm.h"
+#include "tree-nested.h"
+#include "gimplify.h"
+#include "gimple-iterator.h"
+#include "gimplify-me.h"
+#include "gimple-ssa.h"
+#include "cgraph.h"
+#include "tree-cfg.h"
+#include "stringpool.h"
+#include "tree-ssanames.h"
+#include "tree-into-ssa.h"
#include "tree-pass.h"
-#include "timevar.h"
#include "value-prof.h"
-#include "cgraph.h"
#include "profile.h"
#include "target.h"
-#include "output.h"
+#include "tree-cfgcleanup.h"
+#include "tree-nested.h"
+#include "params.h"
static GTY(()) tree gcov_type_node;
-static GTY(()) tree gcov_type_tmp_var;
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;
-\f
+
static GTY(()) tree ic_void_ptr_var;
static GTY(()) tree ic_gcov_type_ptr_var;
/* 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 address
+ __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)
ic_void_ptr_var
= build_decl (UNKNOWN_LOCATION, VAR_DECL,
- get_identifier ("__gcov_indirect_call_callee"),
+ get_identifier (
+ (PARAM_VALUE (PARAM_INDIR_CALL_TOPN_PROFILE) ?
+ "__gcov_indirect_call_topn_callee" :
+ "__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;
- TREE_PUBLIC (ic_void_ptr_var) = 0;
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);
+ set_decl_tls_model (ic_void_ptr_var, decl_default_tls_model (ic_void_ptr_var));
- varpool_finalize_decl (ic_void_ptr_var);
- varpool_mark_needed_node (varpool_node (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
= build_decl (UNKNOWN_LOCATION, VAR_DECL,
- get_identifier ("__gcov_indirect_call_counters"),
+ get_identifier (
+ (PARAM_VALUE (PARAM_INDIR_CALL_TOPN_PROFILE) ?
+ "__gcov_indirect_call_topn_counters" :
+ "__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;
- TREE_PUBLIC (ic_gcov_type_ptr_var) = 0;
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);
+ set_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);
- varpool_mark_needed_node (varpool_node (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)
{
tree gcov_type_ptr;
tree ic_profiler_fn_type;
tree average_profiler_fn_type;
+ tree time_profiler_fn_type;
if (!gcov_type_node)
{
init_ic_make_global_vars ();
- /* void (*) (gcov_type *, gcov_type, void *, void *) */
+ /* void (*) (gcov_type, void *) */
ic_profiler_fn_type
= build_function_type_list (void_type_node,
- gcov_type_ptr, gcov_type_node,
+ gcov_type_node,
ptr_void,
- ptr_void, NULL_TREE);
+ NULL_TREE);
tree_indirect_call_profiler_fn
- = build_fn_decl ("__gcov_indirect_call_profiler",
- ic_profiler_fn_type);
+ = build_fn_decl ( (PARAM_VALUE (PARAM_INDIR_CALL_TOPN_PROFILE) ?
+ "__gcov_indirect_call_topn_profiler":
+ "__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,
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);
}
void
gimple_gen_edge_profiler (int edgeno, edge e)
{
- tree ref, one;
- gimple stmt1, stmt2, stmt3;
+ tree ref, one, gcov_type_tmp_var;
+ gassign *stmt1, *stmt2, *stmt3;
- /* We share one temporary variable declaration per function. This
- gets re-set in tree_profiling. */
- if (gcov_type_tmp_var == NULL_TREE)
- gcov_type_tmp_var = create_tmp_reg (gcov_type_node, "PROF_edge_counter");
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);
- gimple_assign_set_lhs (stmt1, make_ssa_name (gcov_type_tmp_var, stmt1));
- find_referenced_vars_in (stmt1);
- stmt2 = gimple_build_assign_with_ops (PLUS_EXPR, gcov_type_tmp_var,
- gimple_assign_lhs (stmt1), one);
- gimple_assign_set_lhs (stmt2, make_ssa_name (gcov_type_tmp_var, stmt2));
+ gcov_type_tmp_var = make_temp_ssa_name (gcov_type_node,
+ NULL, "PROF_edge_counter");
+ stmt2 = gimple_build_assign (gcov_type_tmp_var, PLUS_EXPR,
+ 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);
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;
+ gcall *call;
tree val;
tree start = build_int_cst_type (integer_type_node,
value->hdata.intvl.int_start);
val = prepare_instrumented_value (&gsi, value);
call = gimple_build_call (tree_interval_profiler_fn, 4,
ref_ptr, val, start, steps);
- find_referenced_vars_in (call);
gsi_insert_before (&gsi, call, GSI_NEW_STMT);
}
gimple stmt = value->hvalue.stmt;
gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
tree ref_ptr = tree_coverage_counter_addr (tag, base);
- gimple call;
+ gcall *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);
- find_referenced_vars_in (call);
gsi_insert_before (&gsi, call, GSI_NEW_STMT);
}
gimple stmt = value->hvalue.stmt;
gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
tree ref_ptr = tree_coverage_counter_addr (tag, base);
- gimple call;
+ gcall *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);
- find_referenced_vars_in (call);
gsi_insert_before (&gsi, call, GSI_NEW_STMT);
}
gimple_gen_ic_profiler (histogram_value value, unsigned tag, unsigned base)
{
tree tmp1;
- gimple stmt1, stmt2, stmt3;
+ gassign *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);
+ if ( (PARAM_VALUE (PARAM_INDIR_CALL_TOPN_PROFILE) &&
+ tag == GCOV_COUNTER_V_INDIR) ||
+ (!PARAM_VALUE (PARAM_INDIR_CALL_TOPN_PROFILE) &&
+ tag == GCOV_COUNTER_ICALL_TOPNV))
+ return;
+
ref_ptr = force_gimple_operand_gsi (&gsi, ref_ptr,
true, NULL_TREE, true, GSI_SAME_STMT);
/* Insert code:
- __gcov_indirect_call_counters = get_relevant_counter_ptr ();
- __gcov_indirect_call_callee = (void *) indirect call argument;
+ stmt1: __gcov_indirect_call_counters = get_relevant_counter_ptr ();
+ stmt2: tmp1 = (void *) (indirect call argument value)
+ stmt3: __gcov_indirect_call_callee = tmp1;
*/
- tmp1 = create_tmp_reg (ptr_void, "PROF");
stmt1 = gimple_build_assign (ic_gcov_type_ptr_var, ref_ptr);
- find_referenced_vars_in (stmt1);
+ tmp1 = make_temp_ssa_name (ptr_void, NULL, "PROF");
stmt2 = gimple_build_assign (tmp1, unshare_expr (value->hvalue.value));
- gimple_assign_set_lhs (stmt2, make_ssa_name (tmp1, stmt2));
- find_referenced_vars_in (stmt2);
stmt3 = gimple_build_assign (ic_void_ptr_var, gimple_assign_lhs (stmt2));
- add_referenced_var (ic_void_ptr_var);
gsi_insert_before (&gsi, stmt1, GSI_SAME_STMT);
gsi_insert_before (&gsi, stmt2, GSI_SAME_STMT);
void
gimple_gen_ic_func_profiler (void)
{
- struct cgraph_node * c_node = cgraph_get_node (current_function_decl);
+ struct cgraph_node * c_node = cgraph_node::get (current_function_decl);
gimple_stmt_iterator gsi;
- gimple stmt1, stmt2;
- tree tree_uid, cur_func, counter_ptr, ptr_var, void0;
+ gcall *stmt1;
+ gassign *stmt2;
+ tree tree_uid, cur_func, void0;
- if (cgraph_only_called_directly_p (c_node))
+ if (c_node->only_called_directly_p ())
return;
gimple_init_edge_profiler ();
- gsi = gsi_after_labels (single_succ (ENTRY_BLOCK_PTR));
+ /* 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))));
cur_func = force_gimple_operand_gsi (&gsi,
build_addr (current_function_decl,
current_function_decl),
true, NULL_TREE,
true, GSI_SAME_STMT);
- counter_ptr = force_gimple_operand_gsi (&gsi, ic_gcov_type_ptr_var,
- true, NULL_TREE, true,
- GSI_SAME_STMT);
- add_referenced_var (ic_gcov_type_ptr_var);
- ptr_var = force_gimple_operand_gsi (&gsi, ic_void_ptr_var,
- true, NULL_TREE, true,
- GSI_SAME_STMT);
- add_referenced_var (ic_void_ptr_var);
- tree_uid = build_int_cst (gcov_type_node, current_function_funcdef_no);
- stmt1 = gimple_build_call (tree_indirect_call_profiler_fn, 4,
- counter_ptr, tree_uid, cur_func, ptr_var);
+ tree_uid = build_int_cst
+ (gcov_type_node,
+ cgraph_node::get (current_function_decl)->profile_id);
+ 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,
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);
+ gcall *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
gimple stmt = value->hvalue.stmt;
gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
tree ref_ptr = tree_coverage_counter_addr (tag, base);
- gimple call;
+ gcall *call;
tree val;
ref_ptr = force_gimple_operand_gsi (&gsi, ref_ptr,
true, GSI_SAME_STMT);
val = prepare_instrumented_value (&gsi, value);
call = gimple_build_call (tree_average_profiler_fn, 2, ref_ptr, val);
- find_referenced_vars_in (call);
gsi_insert_before (&gsi, call, GSI_NEW_STMT);
}
gimple stmt = value->hvalue.stmt;
gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
tree ref_ptr = tree_coverage_counter_addr (tag, base);
- gimple call;
+ gcall *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);
- find_referenced_vars_in (call);
gsi_insert_before (&gsi, call, GSI_NEW_STMT);
}
{
struct cgraph_node *node;
- /* Don't profile functions produced at destruction time, particularly
- the gcov datastructure initializer. Don't profile if it has been
- already instrumented either (when OpenMP expansion creates
- child function from already instrumented body). */
- if (cgraph_state == CGRAPH_STATE_FINISHED)
- return 0;
+ /* This is a small-ipa pass that gets called only once, from
+ cgraphunit.c:ipa_passes(). */
+ gcc_assert (symtab->state == IPA_SSA);
- init_node_map();
+ init_node_map (true);
- for (node = cgraph_nodes; node; node = node->next)
+ FOR_EACH_DEFINED_FUNCTION (node)
{
- if (!node->analyzed
- || !gimple_has_body_p (node->symbol.decl))
+ if (!gimple_has_body_p (node->decl))
continue;
/* Don't profile functions produced for builtin stuff. */
- if (DECL_SOURCE_LOCATION (node->symbol.decl) == BUILTINS_LOCATION
- || DECL_STRUCT_FUNCTION (node->symbol.decl)->after_tree_profile)
+ if (DECL_SOURCE_LOCATION (node->decl) == BUILTINS_LOCATION)
continue;
- push_cfun (DECL_STRUCT_FUNCTION (node->symbol.decl));
- current_function_decl = node->symbol.decl;
+ /* Do not instrument extern inline functions when testing coverage.
+ While this is not perfectly consistent (early inlined extern inlines
+ will get acocunted), testsuite expects that. */
+ if (DECL_EXTERNAL (node->decl)
+ && flag_test_coverage)
+ continue;
- /* Re-set global shared temporary variable for edge-counters. */
- gcov_type_tmp_var = NULL_TREE;
+ push_cfun (DECL_STRUCT_FUNCTION (node->decl));
/* Local pure-const may imply need to fixup the cfg. */
- execute_fixup_cfg ();
+ if (execute_fixup_cfg () & TODO_cleanup_cfg)
+ cleanup_tree_cfg ();
+
branch_prob ();
if (! flag_branch_probabilities
easy to adjust it, if and when there is some. */
free_dominance_info (CDI_DOMINATORS);
free_dominance_info (CDI_POST_DOMINATORS);
-
- current_function_decl = NULL;
pop_cfun ();
}
/* Drop pure/const flags from instrumented functions. */
- for (node = cgraph_nodes; node; node = node->next)
+ FOR_EACH_DEFINED_FUNCTION (node)
{
- if (!node->analyzed
- || !gimple_has_body_p (node->symbol.decl)
+ if (!gimple_has_body_p (node->decl)
|| !(!node->clone_of
- || node->symbol.decl != node->clone_of->symbol.decl))
+ || node->decl != node->clone_of->decl))
continue;
/* Don't profile functions produced for builtin stuff. */
- if (DECL_SOURCE_LOCATION (node->symbol.decl) == BUILTINS_LOCATION
- || DECL_STRUCT_FUNCTION (node->symbol.decl)->after_tree_profile)
+ if (DECL_SOURCE_LOCATION (node->decl) == BUILTINS_LOCATION)
continue;
- cgraph_set_const_flag (node, false, false);
- cgraph_set_pure_flag (node, false, false);
+ node->set_const_flag (false, false);
+ node->set_pure_flag (false, false);
}
/* Update call statements and rebuild the cgraph. */
- for (node = cgraph_nodes; node; node = node->next)
+ FOR_EACH_DEFINED_FUNCTION (node)
{
basic_block bb;
- if (!node->analyzed
- || !gimple_has_body_p (node->symbol.decl)
+ if (!gimple_has_body_p (node->decl)
|| !(!node->clone_of
- || node->symbol.decl != node->clone_of->symbol.decl))
+ || node->decl != node->clone_of->decl))
continue;
/* Don't profile functions produced for builtin stuff. */
- if (DECL_SOURCE_LOCATION (node->symbol.decl) == BUILTINS_LOCATION
- || DECL_STRUCT_FUNCTION (node->symbol.decl)->after_tree_profile)
+ if (DECL_SOURCE_LOCATION (node->decl) == BUILTINS_LOCATION)
continue;
- push_cfun (DECL_STRUCT_FUNCTION (node->symbol.decl));
- current_function_decl = node->symbol.decl;
+ push_cfun (DECL_STRUCT_FUNCTION (node->decl));
- FOR_EACH_BB (bb)
+ FOR_EACH_BB_FN (bb, cfun)
{
gimple_stmt_iterator gsi;
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
}
}
- cfun->after_tree_profile = 1;
+ /* re-merge split blocks. */
+ cleanup_tree_cfg ();
update_ssa (TODO_update_ssa);
- rebuild_cgraph_edges ();
+ cgraph_edge::rebuild_edges ();
- current_function_decl = NULL;
pop_cfun ();
}
- del_node_map();
+ handle_missing_profiles ();
+
+ del_node_map ();
return 0;
}
-/* When profile instrumentation, use or test coverage shall be performed. */
+namespace {
-static bool
-gate_tree_profile_ipa (void)
+const pass_data pass_data_ipa_tree_profile =
{
- return (!in_lto_p
+ SIMPLE_IPA_PASS, /* type */
+ "profile", /* name */
+ OPTGROUP_NONE, /* optinfo_flags */
+ 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: */
+ virtual bool gate (function *);
+ virtual unsigned int execute (function *) { return tree_profiling (); }
+
+}; // class pass_ipa_tree_profile
+
+bool
+pass_ipa_tree_profile::gate (function *)
+{
+ /* When profile instrumentation, use or test coverage shall be performed.
+ But for AutoFDO, this there is no instrumentation, thus this pass is
+ diabled. */
+ return (!in_lto_p && !flag_auto_profile
&& (flag_branch_probabilities || flag_test_coverage
|| profile_arc_flag));
}
-struct simple_ipa_opt_pass pass_ipa_tree_profile =
+} // anon namespace
+
+simple_ipa_opt_pass *
+make_pass_ipa_tree_profile (gcc::context *ctxt)
{
- {
- SIMPLE_IPA_PASS,
- "profile", /* name */
- gate_tree_profile_ipa, /* gate */
- tree_profiling, /* execute */
- NULL, /* sub */
- NULL, /* next */
- 0, /* static_pass_number */
- TV_IPA_PROFILE, /* tv_id */
- 0, /* properties_required */
- 0, /* properties_provided */
- 0, /* properties_destroyed */
- 0, /* todo_flags_start */
- 0 /* todo_flags_finish */
- }
-};
+ return new pass_ipa_tree_profile (ctxt);
+}
#include "gt-tree-profile.h"