#include "tree-inline.h"
#include "tree-mudflap.h"
#include "tree-pass.h"
-#include "tree-alias-common.h"
#include "ggc.h"
#include "cgraph.h"
+#include "graph.h"
/* Global variables used to communicate with passes. */
PROP_gimple_any, /* properties_provided */
0, /* properties_destroyed */
0, /* todo_flags_start */
- TODO_dump_func /* todo_flags_finish */
+ TODO_dump_func, /* todo_flags_finish */
+ 0 /* letter */
};
/* Gate: execute, or not, all of the non-trivial optimizations. */
0, /* properties_provided */
0, /* properties_destroyed */
0, /* todo_flags_start */
- 0 /* todo_flags_finish */
+ 0, /* todo_flags_finish */
+ 0 /* letter */
};
/* Pass: cleanup the CFG just before expanding trees to RTL.
static struct tree_opt_pass pass_cleanup_cfg_post_optimizing =
{
- NULL, /* name */
+ "final_cleanup", /* name */
NULL, /* gate */
execute_cleanup_cfg_post_optimizing, /* execute */
NULL, /* sub */
0, /* properties_provided */
0, /* properties_destroyed */
0, /* todo_flags_start */
- 0 /* todo_flags_finish */
+ TODO_dump_func, /* todo_flags_finish */
+ 0 /* letter */
};
/* Pass: do the actions required to finish with tree-ssa optimization
0, /* properties_provided */
0, /* properties_destroyed */
0, /* todo_flags_start */
- 0 /* todo_flags_finish */
+ 0, /* todo_flags_finish */
+ 0 /* letter */
};
0, /* properties_provided */
0, /* properties_destroyed */
0, /* todo_flags_start */
- 0 /* todo_flags_finish */
+ 0, /* todo_flags_finish */
+ 0 /* letter */
};
/* Iterate over the pass tree allocating dump file numbers. We want
enabled or not. */
static void
-register_one_dump_file (struct tree_opt_pass *pass)
+register_one_dump_file (struct tree_opt_pass *pass, int n)
{
char *dot_name, *flag_name;
char num[10];
- if (!pass->name)
- return;
-
/* See below in next_pass_1. */
num[0] = '\0';
if (pass->static_pass_number != -1)
? 1 : pass->static_pass_number));
dot_name = concat (".", pass->name, num, NULL);
- flag_name = concat ("tree-", pass->name, num, NULL);
-
- pass->static_pass_number = dump_register (dot_name, flag_name);
+ if (pass->properties_provided & PROP_trees)
+ {
+ flag_name = concat ("tree-", pass->name, num, NULL);
+ pass->static_pass_number = dump_register (dot_name, flag_name,
+ TDF_TREE, n + TDI_tree_all, 0);
+ }
+ else
+ {
+ flag_name = concat ("rtl-", pass->name, num, NULL);
+ pass->static_pass_number = dump_register (dot_name, flag_name,
+ TDF_RTL, n, pass->letter);
+ }
}
static int
register_dump_files (struct tree_opt_pass *pass, int properties)
{
+ static int n = 0;
do
{
- /* Verify that all required properties are present. */
- if (pass->properties_required & ~properties)
- abort ();
-
- if (pass->properties_destroyed & pass->properties_provided)
- abort ();
+ int new_properties;
+ int pass_number;
pass->properties_required = properties;
- pass->properties_provided = properties =
+ new_properties =
(properties | pass->properties_provided) & ~pass->properties_destroyed;
- if (properties & PROP_trees)
- register_one_dump_file (pass);
+ /* Reset the counter when we reach RTL-based passes. */
+ if ((pass->properties_provided ^ pass->properties_required) & PROP_rtl)
+ n = 0;
+
+ pass_number = n;
+ if (pass->name)
+ n++;
+
if (pass->sub)
- properties = register_dump_files (pass->sub, properties);
+ new_properties = register_dump_files (pass->sub, new_properties);
+
+ /* If we have a gate, combine the properties that we could have with
+ and without the pass being examined. */
+ if (pass->gate)
+ properties &= new_properties;
+ else
+ properties = new_properties;
+
+ pass->properties_provided = properties;
+ if (pass->name)
+ register_one_dump_file (pass, pass_number);
+
pass = pass->next;
}
while (pass);
next_pass_1 (struct tree_opt_pass **list, struct tree_opt_pass *pass)
{
- /* A non-zero static_pass_number indicates that the
- pass is already in the list. */
+ /* A nonzero static_pass_number indicates that the
+ pass is already in the list. */
if (pass->static_pass_number)
{
struct tree_opt_pass *new;
p = &pass_all_optimizations.sub;
NEXT_PASS (pass_referenced_vars);
- NEXT_PASS (pass_build_pta);
+ NEXT_PASS (pass_maybe_create_global_var);
NEXT_PASS (pass_build_ssa);
+ NEXT_PASS (pass_may_alias);
NEXT_PASS (pass_rename_ssa_copies);
NEXT_PASS (pass_early_warn_uninitialized);
NEXT_PASS (pass_dce);
NEXT_PASS (pass_ccp);
NEXT_PASS (pass_redundant_phi);
NEXT_PASS (pass_fold_builtins);
+ /* FIXME: May alias should a TODO but for 4.0.0,
+ we add may_alias right after fold builtins
+ which can create arbitrary GIMPLE. */
+ NEXT_PASS (pass_may_alias);
NEXT_PASS (pass_split_crit_edges);
NEXT_PASS (pass_pre);
NEXT_PASS (pass_loop);
NEXT_PASS (pass_phiopt);
NEXT_PASS (pass_tail_calls);
NEXT_PASS (pass_late_warn_uninitialized);
- NEXT_PASS (pass_del_pta);
NEXT_PASS (pass_del_ssa);
NEXT_PASS (pass_nrv);
NEXT_PASS (pass_remove_useless_vars);
p = &pass_loop.sub;
NEXT_PASS (pass_loop_init);
NEXT_PASS (pass_lim);
+ NEXT_PASS (pass_unswitch);
+ NEXT_PASS (pass_record_bounds);
+ NEXT_PASS (pass_linear_transform);
+ NEXT_PASS (pass_iv_canon);
+ NEXT_PASS (pass_if_conversion);
+ NEXT_PASS (pass_vectorize);
+ NEXT_PASS (pass_complete_unroll);
+ NEXT_PASS (pass_iv_optimize);
NEXT_PASS (pass_loop_done);
*p = NULL;
static unsigned int last_verified;
static void
-execute_todo (unsigned int flags)
+execute_todo (int properties, unsigned int flags)
{
if (flags & TODO_rename_vars)
{
rewrite_into_ssa (false);
bitmap_clear (vars_to_rename);
}
+ if (flags & TODO_fix_def_def_chains)
+ {
+ rewrite_def_def_chains ();
+ bitmap_clear (vars_to_rename);
+ }
+
+ if (flags & TODO_cleanup_cfg)
+ cleanup_tree_cfg ();
if ((flags & TODO_dump_func) && dump_file)
{
- dump_function_to_file (current_function_decl,
- dump_file, dump_flags);
+ if (properties & PROP_trees)
+ dump_function_to_file (current_function_decl,
+ dump_file, dump_flags);
+ else if (properties & PROP_cfg)
+ print_rtl_with_bb (dump_file, get_insns ());
+ else
+ print_rtl (dump_file, get_insns ());
/* Flush the file. If verification fails, we won't be able to
close the file before aborting. */
/* Run pre-pass verification. */
todo = pass->todo_flags_start & ~last_verified;
if (todo)
- execute_todo (todo);
+ execute_todo (pass->properties_required, todo);
/* If a dump file name is present, open it if enabled. */
if (pass->static_pass_number != -1)
{
+ 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)
{
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)\n\n", dname, aname);
+ 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
+ && graph_dump_format != no_graph
+ && (pass->properties_provided & (PROP_cfg | PROP_rtl))
+ == (PROP_cfg | PROP_rtl))
+ clean_graph_dump_file (dump_file_name);
}
/* If a timevar is present, start it. */
if (pass->execute)
pass->execute ();
+ /* Stop timevar. */
+ if (pass->tv_id)
+ timevar_pop (pass->tv_id);
+
+ if (dump_file
+ && (pass->properties_provided & (PROP_cfg | PROP_rtl))
+ == (PROP_cfg | PROP_rtl))
+ print_rtl_with_bb (dump_file, get_insns ());
+
/* Run post-pass cleanup and verification. */
todo = pass->todo_flags_finish;
last_verified = todo & TODO_verify_all;
if (todo)
- execute_todo (todo);
+ execute_todo (pass->properties_provided, todo);
- /* Close down timevar and dump file. */
- if (pass->tv_id)
- timevar_pop (pass->tv_id);
+ /* Flush and close dump file. */
+ if (dump_file_name)
+ {
+ free ((char *) dump_file_name);
+ dump_file_name = NULL;
+ }
if (dump_file)
{
dump_end (pass->static_pass_number, dump_file);
}
while (pass);
}
+\f
+
+/* Update recursively all inlined_to pointers of functions
+ inlined into NODE to INLINED_TO. */
+static void
+update_inlined_to_pointers (struct cgraph_node *node,
+ struct cgraph_node *inlined_to)
+{
+ struct cgraph_edge *e;
+ for (e = node->callees; e; e = e->next_callee)
+ {
+ if (e->callee->global.inlined_to)
+ {
+ e->callee->global.inlined_to = inlined_to;
+ update_inlined_to_pointers (e->callee, inlined_to);
+ }
+ }
+}
\f
/* For functions-as-trees languages, this performs all optimization and
compilation for FNDECL. */
void
-tree_rest_of_compilation (tree fndecl, bool nested_p)
+tree_rest_of_compilation (tree fndecl)
{
location_t saved_loc;
struct cgraph_node *saved_node = NULL, *node;
timevar_push (TV_EXPAND);
- if (flag_unit_at_a_time && !cgraph_global_info_ready)
- abort ();
+ gcc_assert (!flag_unit_at_a_time || cgraph_global_info_ready);
/* Initialize the RTL code for the function. */
current_function_decl = fndecl;
}
}
- if (!vars_to_rename)
- vars_to_rename = BITMAP_XMALLOC ();
+ /* We are not going to maintain the cgraph edges up to date.
+ Kill it so it won't confuse us. */
+ while (node->callees)
+ cgraph_remove_edge (node->callees);
- /* If this is a nested function, protect the local variables in the stack
- above us from being collected while we're compiling this function. */
- if (nested_p)
- ggc_push_context ();
+ /* Initialize the default bitmap obstack. */
+ bitmap_obstack_initialize (NULL);
+ bitmap_obstack_initialize (®_obstack); /* FIXME, only at RTL generation*/
+
+ vars_to_rename = BITMAP_XMALLOC ();
+
/* Perform all tree transforms and optimizations. */
execute_pass_list (all_passes);
+
+ bitmap_obstack_release (®_obstack);
+ /* Release the default bitmap obstack. */
+ bitmap_obstack_release (NULL);
+
/* Restore original body if still needed. */
if (cfun->saved_tree)
{
if (!flag_unit_at_a_time)
{
struct cgraph_edge *e;
+
while (node->callees)
cgraph_remove_edge (node->callees);
node->callees = saved_node->callees;
saved_node->callees = NULL;
- for (e = saved_node->callees; e; e = e->next_callee)
+ update_inlined_to_pointers (node, node);
+ for (e = node->callees; e; e = e->next_callee)
e->caller = node;
cgraph_remove_node (saved_node);
}
= TREE_INT_CST_LOW (TYPE_SIZE_UNIT (ret_type));
if (compare_tree_int (TYPE_SIZE_UNIT (ret_type), size_as_int) == 0)
- warning ("%Jsize of return value of '%D' is %u bytes",
+ warning ("%Jsize of return value of %qD is %u bytes",
fndecl, fndecl, size_as_int);
else
- warning ("%Jsize of return value of '%D' is larger than %wd bytes",
+ warning ("%Jsize of return value of %qD is larger than %wd bytes",
fndecl, fndecl, larger_than_size);
}
}
- if (!nested_p && !flag_inline_trees)
+ if (!flag_inline_trees)
{
DECL_SAVED_TREE (fndecl) = NULL;
if (DECL_STRUCT_FUNCTION (fndecl) == 0
input_location = saved_loc;
ggc_collect ();
-
- /* Undo the GC context switch. */
- if (nested_p)
- ggc_pop_context ();
timevar_pop (TV_EXPAND);
}