#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.
+ This is just a round of label cleanups and case node grouping
+ because after the tree optimizers have run such cleanups may
+ be necessary. */
+
+static void
+execute_cleanup_cfg_post_optimizing (void)
+{
+ cleanup_tree_cfg ();
+ cleanup_dead_labels ();
+ group_case_labels ();
+}
+
+static struct tree_opt_pass pass_cleanup_cfg_post_optimizing =
+{
+ "final_cleanup", /* name */
+ NULL, /* gate */
+ execute_cleanup_cfg_post_optimizing, /* execute */
+ NULL, /* sub */
+ NULL, /* next */
+ 0, /* static_pass_number */
+ 0, /* tv_id */
+ PROP_cfg, /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ 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 dup_pass_1. */
+ /* See below in next_pass_1. */
num[0] = '\0';
- if (pass->static_pass_number)
+ if (pass->static_pass_number != -1)
sprintf (num, "%d", ((int) pass->static_pass_number < 0
? 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);
return properties;
}
-/* Duplicate a pass that's to be run more than once. */
+/* Add a pass to the pass list. Duplicate the pass if it's already
+ in the list. */
-static struct tree_opt_pass *
-dup_pass_1 (struct tree_opt_pass *pass)
+static struct tree_opt_pass **
+next_pass_1 (struct tree_opt_pass **list, struct tree_opt_pass *pass)
{
- struct tree_opt_pass *new;
-
- new = xmalloc (sizeof (*new));
- memcpy (new, pass, sizeof (*new));
- /* Indicate to register_dump_files that this pass has duplicates,
- and so it should rename the dump file. The first instance will
- be < 0, and be number of duplicates = -static_pass_number + 1.
- Subsequent instances will be > 0 and just the duplicate number. */
- if (pass->name)
+ /* A nonzero static_pass_number indicates that the
+ pass is already in the list. */
+ if (pass->static_pass_number)
{
- int n, p = pass->static_pass_number;
-
- if (p)
- n = -(--p) + 1;
- else
- n = 2, p = -1;
-
- pass->static_pass_number = p;
- new->static_pass_number = n;
+ struct tree_opt_pass *new;
+
+ new = xmalloc (sizeof (*new));
+ memcpy (new, pass, sizeof (*new));
+
+ /* Indicate to register_dump_files that this pass has duplicates,
+ and so it should rename the dump file. The first instance will
+ be -1, and be number of duplicates = -static_pass_number - 1.
+ Subsequent instances will be > 0 and just the duplicate number. */
+ if (pass->name)
+ {
+ pass->static_pass_number -= 1;
+ new->static_pass_number = -pass->static_pass_number;
+ }
+
+ *list = new;
}
-
- return new;
+ else
+ {
+ pass->static_pass_number = -1;
+ *list = pass;
+ }
+
+ return &(*list)->next;
+
}
/* Construct the pass tree. */
{
struct tree_opt_pass **p;
-#define NEXT_PASS(PASS) (*p = &PASS, p = &(*p)->next)
-#define DUP_PASS(PASS) (*dup_pass_1 (&PASS))
+#define NEXT_PASS(PASS) (p = next_pass_1 (p, &PASS))
p = &all_passes;
NEXT_PASS (pass_gimple);
NEXT_PASS (pass_lower_cf);
NEXT_PASS (pass_lower_eh);
NEXT_PASS (pass_build_cfg);
+ NEXT_PASS (pass_pre_expand);
NEXT_PASS (pass_tree_profile);
NEXT_PASS (pass_init_datastructures);
NEXT_PASS (pass_all_optimizations);
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_dominator);
NEXT_PASS (pass_redundant_phi);
- NEXT_PASS (DUP_PASS (pass_dce));
+ NEXT_PASS (pass_dce);
NEXT_PASS (pass_forwprop);
NEXT_PASS (pass_phiopt);
NEXT_PASS (pass_may_alias);
NEXT_PASS (pass_tail_recursion);
NEXT_PASS (pass_ch);
NEXT_PASS (pass_profile);
- NEXT_PASS (pass_lower_complex);
NEXT_PASS (pass_sra);
- NEXT_PASS (DUP_PASS (pass_rename_ssa_copies));
- NEXT_PASS (DUP_PASS (pass_dominator));
- NEXT_PASS (DUP_PASS (pass_redundant_phi));
- NEXT_PASS (DUP_PASS (pass_dce));
+ NEXT_PASS (pass_rename_ssa_copies);
+ NEXT_PASS (pass_dominator);
+ NEXT_PASS (pass_redundant_phi);
+ NEXT_PASS (pass_dce);
NEXT_PASS (pass_dse);
- NEXT_PASS (DUP_PASS (pass_may_alias));
- NEXT_PASS (DUP_PASS (pass_forwprop));
- NEXT_PASS (DUP_PASS (pass_phiopt));
+ NEXT_PASS (pass_may_alias);
+ NEXT_PASS (pass_forwprop);
+ NEXT_PASS (pass_phiopt);
NEXT_PASS (pass_ccp);
- NEXT_PASS (DUP_PASS (pass_redundant_phi));
+ 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 (DUP_PASS (pass_dominator));
- NEXT_PASS (DUP_PASS (pass_redundant_phi));
+ NEXT_PASS (pass_dominator);
+ NEXT_PASS (pass_redundant_phi);
+ /* FIXME: If DCE is not run before checking for uninitialized uses,
+ we may get false warnings (e.g., testsuite/gcc.dg/uninit-5.c).
+ However, this also causes us to misdiagnose cases that should be
+ real warnings (e.g., testsuite/gcc.dg/pr18501.c).
+
+ To fix the false positives in uninit-5.c, we would have to
+ account for the predicates protecting the set and the use of each
+ variable. Using a representation like Gated Single Assignment
+ may help. */
+ NEXT_PASS (pass_late_warn_uninitialized);
NEXT_PASS (pass_cd_dce);
- NEXT_PASS (DUP_PASS (pass_dse));
- NEXT_PASS (DUP_PASS (pass_forwprop));
- NEXT_PASS (DUP_PASS (pass_phiopt));
+ NEXT_PASS (pass_dse);
+ NEXT_PASS (pass_forwprop);
+ 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);
+ NEXT_PASS (pass_mark_used_blocks);
+ NEXT_PASS (pass_cleanup_cfg_post_optimizing);
*p = NULL;
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;
#undef NEXT_PASS
-#undef DUP_PASS
/* Register the passes with the tree dump code. */
register_dump_files (all_passes, 0);
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)
+ 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 (!e->inline_failed)
cgraph_clone_inlined_nodes (e, true);
}
- cfun->saved_tree = save_body (fndecl, &cfun->saved_args);
+ cfun->saved_static_chain_decl = cfun->static_chain_decl;
+ cfun->saved_tree = save_body (fndecl, &cfun->saved_args,
+ &cfun->saved_static_chain_decl);
}
if (flag_inline_trees)
}
}
- 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)
{
DECL_SAVED_TREE (fndecl) = cfun->saved_tree;
DECL_ARGUMENTS (fndecl) = cfun->saved_args;
+ cfun->static_chain_decl = cfun->saved_static_chain_decl;
/* When not in unit-at-a-time mode, we must preserve out of line copy
representing node before inlining. Restore original outgoing edges
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);
}
OSDN Git Service
