+2005-04-21 Jan Hubicka <jh@suse.cz>
+
+ * cgraphunit.c: Include tree-pass.h
+ (cgraph_decide_recursive_inlining,
+ cgraph_decide_inlining_of_small_function, cgraph_set_inline_failed,
+ cgraph_decide_inlining): Dump goes to dump_file.
+ (cgraph_optimize): Call ipa passes instead of inliner.
+ (cgraph_gate_inlining, pass_ipa_inline): New.
+ * tree-optimize.c (all_ipa_passes): New static variable.
+ (register_one_dump_file): Dead with IPA passes.
+ (register_dump_files): Likewise.
+ (init_tree_optimization_passes): Initialize IPA passes.
+ (execute_todo): Do cgraph dump when asked to, do not dump function body
+ for IPA pass.
+ * tree-pass.h (TODO_dump_cgraph): New macro.
+ (ipa_passes): Declare.
+ * Makefile.in (cgraphunit.o): Add dependency on cgraphunit.h
+
2005-04-21 Nathan Sidwell <nathan@codesourcery.com>
* config/i386/i386.c (type_natural_mode): Use gcc_unreachable and
output.h intl.h
cgraphunit.o : cgraphunit.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(TREE_H) \
langhooks.h tree-inline.h toplev.h $(FLAGS_H) $(GGC_H) $(TARGET_H) $(CGRAPH_H) intl.h \
- pointer-set.h function.h $(TREE_GIMPLE_H) $(TREE_FLOW_H)
+ pointer-set.h function.h $(TREE_GIMPLE_H) $(TREE_FLOW_H) tree-pass.h
coverage.o : coverage.c gcov-io.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \
$(TM_H) $(RTL_H) $(TREE_H) $(FLAGS_H) output.h $(REGS_H) $(EXPR_H) function.h \
toplev.h $(GGC_H) $(TARGET_H) langhooks.h $(COVERAGE_H) libfuncs.h \
#include "intl.h"
#include "function.h"
#include "tree-gimple.h"
+#include "tree-pass.h"
#include "output.h"
static void cgraph_expand_all_functions (void);
if (!first_call)
return;
- if (cgraph_dump_file)
- fprintf (cgraph_dump_file,
+ if (dump_file)
+ fprintf (dump_file,
"\nPerforming recursive inlining on %s\n",
cgraph_node_name (node));
first_call->aux = NULL;
first_call = next;
}
- if (cgraph_dump_file)
- fprintf (cgraph_dump_file,
+ if (dump_file)
+ fprintf (dump_file,
"\n Inlined %i times, body grown from %i to %i insns\n", n,
master_clone->global.insns, node->global.insns);
{
struct cgraph_edge *e;
- if (cgraph_dump_file)
- fprintf (cgraph_dump_file, "Inlining failed: %s\n", reason);
+ if (dump_file)
+ fprintf (dump_file, "Inlining failed: %s\n", reason);
for (e = node->callers; e; e = e->next_caller)
if (e->inline_failed)
e->inline_failed = reason;
fibheap_insert (heap, cgraph_estimate_growth (node), node);
}
- if (cgraph_dump_file)
- fprintf (cgraph_dump_file, "\nDeciding on smaller functions:\n");
+ if (dump_file)
+ fprintf (dump_file, "\nDeciding on smaller functions:\n");
while (overall_insns <= max_insns && (node = fibheap_extract_min (heap)))
{
struct cgraph_edge *e, *next;
int old_insns = overall_insns;
heap_node[node->uid] = NULL;
- if (cgraph_dump_file)
- fprintf (cgraph_dump_file,
+ if (dump_file)
+ fprintf (dump_file,
"\nConsidering %s with %i insns\n"
" Estimated growth is %+i insns.\n",
cgraph_node_name (node), node->global.insns,
|| !cgraph_check_inline_limits (e->caller, e->callee,
&e->inline_failed))
{
- if (cgraph_dump_file)
- fprintf (cgraph_dump_file, " Not inlining into %s:%s.\n",
+ if (dump_file)
+ fprintf (dump_file, " Not inlining into %s:%s.\n",
cgraph_node_name (e->caller), e->inline_failed);
continue;
}
fibheap_replace_key (heap, heap_node[where->uid],
cgraph_estimate_growth (where));
- if (cgraph_dump_file)
- fprintf (cgraph_dump_file,
+ if (dump_file)
+ fprintf (dump_file,
" Inlined into %s which now has %i insns.\n",
cgraph_node_name (e->caller),
e->caller->global.insns);
are now called more times; update keys. */
update_callee_keys (heap, heap_node, node);
- if (cgraph_dump_file)
- fprintf (cgraph_dump_file,
+ if (dump_file)
+ fprintf (dump_file,
" Inlined for a net change of %+i insns.\n",
overall_insns - old_insns);
}
nnodes = cgraph_postorder (order);
- if (cgraph_dump_file)
- fprintf (cgraph_dump_file,
+ if (dump_file)
+ fprintf (dump_file,
"\nDeciding on inlining. Starting with %i insns.\n",
initial_insns);
for (node = cgraph_nodes; node; node = node->next)
node->aux = 0;
- if (cgraph_dump_file)
- fprintf (cgraph_dump_file, "\nInlining always_inline functions:\n");
+ if (dump_file)
+ fprintf (dump_file, "\nInlining always_inline functions:\n");
/* In the first pass mark all always_inline edges. Do this with a priority
so none of our later choices will make this impossible. */
if (!node->local.disregard_inline_limits)
continue;
- if (cgraph_dump_file)
- fprintf (cgraph_dump_file,
+ if (dump_file)
+ fprintf (dump_file,
"\nConsidering %s %i insns (always inline)\n",
cgraph_node_name (node), node->global.insns);
old_insns = overall_insns;
&e->inline_failed))
continue;
cgraph_mark_inline_edge (e);
- if (cgraph_dump_file)
- fprintf (cgraph_dump_file,
+ if (dump_file)
+ fprintf (dump_file,
" Inlined into %s which now has %i insns.\n",
cgraph_node_name (e->caller),
e->caller->global.insns);
}
- if (cgraph_dump_file)
- fprintf (cgraph_dump_file,
+ if (dump_file)
+ fprintf (dump_file,
" Inlined for a net change of %+i insns.\n",
overall_insns - old_insns);
}
{
cgraph_decide_inlining_of_small_functions ();
- if (cgraph_dump_file)
- fprintf (cgraph_dump_file, "\nDeciding on functions called once:\n");
+ if (dump_file)
+ fprintf (dump_file, "\nDeciding on functions called once:\n");
/* And finally decide what functions are called once. */
ok = false;
if (ok)
{
- if (cgraph_dump_file)
- fprintf (cgraph_dump_file,
+ if (dump_file)
+ fprintf (dump_file,
"\nConsidering %s %i insns.\n"
" Called once from %s %i insns.\n",
cgraph_node_name (node), node->global.insns,
NULL))
{
cgraph_mark_inline (node->callers);
- if (cgraph_dump_file)
- fprintf (cgraph_dump_file,
+ if (dump_file)
+ fprintf (dump_file,
" Inlined into %s which now has %i insns"
" for a net change of %+i insns.\n",
cgraph_node_name (node->callers->caller),
}
else
{
- if (cgraph_dump_file)
- fprintf (cgraph_dump_file,
+ if (dump_file)
+ fprintf (dump_file,
" Inline limit reached, not inlined.\n");
}
}
inline functions. */
cgraph_remove_unreachable_nodes ();
- if (cgraph_dump_file)
- fprintf (cgraph_dump_file,
+ if (dump_file)
+ fprintf (dump_file,
"\nInlined %i calls, eliminated %i functions, "
"%i insns turned to %i insns.\n\n",
ncalls_inlined, nfunctions_inlined, initial_insns,
fprintf (cgraph_dump_file, "Marked ");
dump_cgraph (cgraph_dump_file);
}
-
- if (flag_inline_trees)
- cgraph_decide_inlining ();
+ ipa_passes ();
cgraph_global_info_ready = true;
if (cgraph_dump_file)
{
{
cgraph_dump_file = dump_begin (TDI_cgraph, NULL);
}
+
+/* When inlining shall be performed. */
+static bool
+cgraph_gate_inlining (void)
+{
+ return flag_inline_trees;
+}
+
+struct tree_opt_pass pass_ipa_inline =
+{
+ "inline", /* name */
+ cgraph_gate_inlining, /* gate */
+ cgraph_decide_inlining, /* execute */
+ NULL, /* sub */
+ NULL, /* next */
+ 0, /* static_pass_number */
+ TV_INTEGRATION, /* tv_id */
+ 0, /* properties_required */
+ PROP_trees, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ TODO_dump_cgraph | TODO_dump_func, /* todo_flags_finish */
+ 0 /* letter */
+};
bool in_gimple_form;
/* The root of the compilation pass tree, once constructed. */
-static struct tree_opt_pass *all_passes;
+static struct tree_opt_pass *all_passes, *all_ipa_passes;
/* Pass: dump the gimplified, inlined, functions. */
enabled or not. */
static void
-register_one_dump_file (struct tree_opt_pass *pass, int n)
+register_one_dump_file (struct tree_opt_pass *pass, bool ipa, int n)
{
char *dot_name, *flag_name, *glob_name;
char num[10];
? 1 : pass->static_pass_number));
dot_name = concat (".", pass->name, num, NULL);
- if (pass->properties_provided & PROP_trees)
+ if (ipa)
+ {
+ flag_name = concat ("ipa-", pass->name, num, NULL);
+ glob_name = concat ("ipa-", pass->name, NULL);
+ /* First IPA dump is cgraph that is dumped via separate channels. */
+ pass->static_pass_number = dump_register (dot_name, flag_name, glob_name,
+ TDF_IPA, n + 1, 0);
+ }
+ else if (pass->properties_provided & PROP_trees)
{
flag_name = concat ("tree-", pass->name, num, NULL);
glob_name = concat ("tree-", pass->name, NULL);
}
static int
-register_dump_files (struct tree_opt_pass *pass, int properties)
+register_dump_files (struct tree_opt_pass *pass, bool ipa, int properties)
{
static int n = 0;
do
n++;
if (pass->sub)
- new_properties = register_dump_files (pass->sub, new_properties);
+ new_properties = register_dump_files (pass->sub, ipa, new_properties);
/* If we have a gate, combine the properties that we could have with
and without the pass being examined. */
pass->properties_provided = properties;
if (pass->name)
- register_one_dump_file (pass, pass_number);
+ register_one_dump_file (pass, ipa, pass_number);
pass = pass->next;
}
struct tree_opt_pass **p;
#define NEXT_PASS(PASS) (p = next_pass_1 (p, &PASS))
+ /* Intraprocedural optimization passes. */
+ p = &all_ipa_passes;
+ NEXT_PASS (pass_ipa_inline);
+ *p = NULL;
p = &all_passes;
NEXT_PASS (pass_gimple);
#undef NEXT_PASS
- /* Register the passes with the tree dump code. */
- register_dump_files (all_passes, 0);
+ register_dump_files (all_passes, false, PROP_gimple_any
+ | PROP_gimple_lcf
+ | PROP_gimple_leh
+ | PROP_cfg);
+ register_dump_files (all_ipa_passes, true, PROP_gimple_any
+ | PROP_gimple_lcf
+ | PROP_gimple_leh
+ | PROP_cfg);
}
-static void execute_pass_list (struct tree_opt_pass *);
-
static unsigned int last_verified;
static void
cleanup_tree_cfg ();
}
- if ((flags & TODO_dump_func) && dump_file)
+ if ((flags & TODO_dump_func)
+ && dump_file && current_function_decl)
{
if (properties & PROP_trees)
dump_function_to_file (current_function_decl,
close the file before aborting. */
fflush (dump_file);
}
+ if ((flags & TODO_dump_cgraph)
+ && dump_file && !current_function_decl)
+ {
+ dump_cgraph (dump_file);
+ /* Flush the file. If verification fails, we won't be able to
+ close the file before aborting. */
+ fflush (dump_file);
+ }
if (flags & TODO_ggc_collect)
{
bool initializing_dump = !dump_initialized_p (pass->static_pass_number);
dump_file_name = get_dump_file_name (pass->static_pass_number);
dump_file = dump_begin (pass->static_pass_number, &dump_flags);
- if (dump_file)
+ if (dump_file && current_function_decl)
{
const char *dname, *aname;
dname = lang_hooks.decl_printable_name (current_function_decl, 2);
aname = (IDENTIFIER_POINTER
(DECL_ASSEMBLER_NAME (current_function_decl)));
- fprintf (dump_file, "\n;; Function %s (%s)%s\n\n", dname, aname,
- cfun->function_frequency == FUNCTION_FREQUENCY_HOT
- ? " (hot)"
- : cfun->function_frequency == FUNCTION_FREQUENCY_UNLIKELY_EXECUTED
- ? " (unlikely executed)"
- : "");
+ fprintf (dump_file, "\n;; Function %s (%s)%s\n\n", dname, aname,
+ cfun->function_frequency == FUNCTION_FREQUENCY_HOT
+ ? " (hot)"
+ : cfun->function_frequency == FUNCTION_FREQUENCY_UNLIKELY_EXECUTED
+ ? " (unlikely executed)"
+ : "");
}
if (initializing_dump
}
while (pass);
}
+
+/* Execute all IPA passes. */
+void
+ipa_passes (void)
+{
+ execute_pass_list (all_ipa_passes);
+}
\f
/* Update recursively all inlined_to pointers of functions
#define TODO_verify_stmts (1 << 4)
#define TODO_cleanup_cfg (1 << 5)
#define TODO_verify_loops (1 << 6)
+#define TODO_dump_cgraph (1 << 7)
/* To-do flags for calls to update_ssa. */
#define TODO_verify_all \
(TODO_verify_ssa | TODO_verify_flow | TODO_verify_stmts)
+extern void ipa_passes (void);
+
extern struct tree_opt_pass pass_mudflap_1;
extern struct tree_opt_pass pass_mudflap_2;
extern struct tree_opt_pass pass_remove_useless_stmts;
extern struct tree_opt_pass pass_create_structure_vars;
extern struct tree_opt_pass pass_uncprop;
+extern struct tree_opt_pass pass_ipa_inline;
+
#endif /* GCC_TREE_PASS_H */
projects / gcc.git / commitdiff