#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "tree.h"
#include "rtl.h"
#include "tm_p.h"
#include "hard-reg-set.h"
#include "basic-block.h"
#include "output.h"
#include "expr.h"
#include "diagnostic.h"
#include "basic-block.h"
#include "flags.h"
#include "tree-flow.h"
#include "tree-dump.h"
#include "timevar.h"
#include "function.h"
#include "langhooks.h"
#include "toplev.h"
#include "flags.h"
#include "cgraph.h"
#include "tree-inline.h"
#include "tree-mudflap.h"
#include "tree-pass.h"
#include "ggc.h"
#include "cgraph.h"
#include "graph.h"
#include "opts.h"
int dump_flags;
bitmap vars_to_rename;
bool in_gimple_form;
static struct tree_opt_pass *all_passes;
static struct tree_opt_pass pass_gimple =
{
"gimple",
NULL,
NULL,
NULL,
NULL,
0,
0,
0,
PROP_gimple_any,
0,
0,
TODO_dump_func,
0
};
static bool
gate_all_optimizations (void)
{
return (optimize >= 1
&& !(errorcount || sorrycount));
}
static struct tree_opt_pass pass_all_optimizations =
{
NULL,
gate_all_optimizations,
NULL,
NULL,
NULL,
0,
0,
0,
0,
0,
0,
0,
0
};
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",
NULL,
execute_cleanup_cfg_post_optimizing,
NULL,
NULL,
0,
0,
PROP_cfg,
0,
0,
0,
TODO_dump_func,
0
};
static void
execute_free_datastructures (void)
{
tree *chain;
free_dominance_info (CDI_DOMINATORS);
disband_implicit_edges ();
delete_tree_ssa ();
chain = &DECL_SAVED_TREE (current_function_decl);
*chain = alloc_stmt_list ();
delete_tree_cfg_annotations ();
}
static struct tree_opt_pass pass_free_datastructures =
{
NULL,
NULL,
execute_free_datastructures,
NULL,
NULL,
0,
0,
PROP_cfg,
0,
0,
0,
0,
0
};
static void
execute_init_datastructures (void)
{
init_tree_ssa ();
}
static struct tree_opt_pass pass_init_datastructures =
{
NULL,
NULL,
execute_init_datastructures,
NULL,
NULL,
0,
0,
PROP_cfg,
0,
0,
0,
0,
0
};
static void
register_one_dump_file (struct tree_opt_pass *pass, int n)
{
char *dot_name, *flag_name, *glob_name;
char num[10];
num[0] = '\0';
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);
if (pass->properties_provided & PROP_trees)
{
flag_name = concat ("tree-", pass->name, num, NULL);
glob_name = concat ("tree-", pass->name, NULL);
pass->static_pass_number = dump_register (dot_name, flag_name, glob_name,
TDF_TREE, n + TDI_tree_all, 0);
}
else
{
flag_name = concat ("rtl-", pass->name, num, NULL);
glob_name = concat ("rtl-", pass->name, NULL);
pass->static_pass_number = dump_register (dot_name, flag_name, glob_name,
TDF_RTL, n, pass->letter);
}
}
static int
register_dump_files (struct tree_opt_pass *pass, int properties)
{
static int n = 0;
do
{
int new_properties;
int pass_number;
pass->properties_required = properties;
new_properties =
(properties | pass->properties_provided) & ~pass->properties_destroyed;
if ((pass->properties_provided ^ pass->properties_required) & PROP_rtl)
n = 0;
pass_number = n;
if (pass->name)
n++;
if (pass->sub)
new_properties = register_dump_files (pass->sub, new_properties);
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;
}
static struct tree_opt_pass **
next_pass_1 (struct tree_opt_pass **list, struct tree_opt_pass *pass)
{
if (pass->static_pass_number)
{
struct tree_opt_pass *new;
new = xmalloc (sizeof (*new));
memcpy (new, pass, sizeof (*new));
if (pass->name)
{
pass->static_pass_number -= 1;
new->static_pass_number = -pass->static_pass_number;
}
*list = new;
}
else
{
pass->static_pass_number = -1;
*list = pass;
}
return &(*list)->next;
}
void
init_tree_optimization_passes (void)
{
struct tree_opt_pass **p;
#define NEXT_PASS(PASS) (p = next_pass_1 (p, &PASS))
p = &all_passes;
NEXT_PASS (pass_gimple);
NEXT_PASS (pass_remove_useless_stmts);
NEXT_PASS (pass_mudflap_1);
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);
NEXT_PASS (pass_warn_function_return);
NEXT_PASS (pass_mudflap_2);
NEXT_PASS (pass_free_datastructures);
NEXT_PASS (pass_expand);
NEXT_PASS (pass_rest_of_compilation);
*p = NULL;
p = &pass_all_optimizations.sub;
NEXT_PASS (pass_referenced_vars);
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 (pass_dce);
NEXT_PASS (pass_merge_phi);
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_sra);
NEXT_PASS (pass_may_alias);
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 (pass_may_alias);
NEXT_PASS (pass_forwprop);
NEXT_PASS (pass_phiopt);
NEXT_PASS (pass_ccp);
NEXT_PASS (pass_redundant_phi);
NEXT_PASS (pass_fold_builtins);
NEXT_PASS (pass_may_alias);
NEXT_PASS (pass_split_crit_edges);
NEXT_PASS (pass_pre);
NEXT_PASS (pass_loop);
NEXT_PASS (pass_dominator);
NEXT_PASS (pass_redundant_phi);
NEXT_PASS (pass_late_warn_uninitialized);
NEXT_PASS (pass_cd_dce);
NEXT_PASS (pass_dse);
NEXT_PASS (pass_forwprop);
NEXT_PASS (pass_phiopt);
NEXT_PASS (pass_tail_calls);
NEXT_PASS (pass_rename_ssa_copies);
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_memset);
NEXT_PASS (pass_loop_test);
NEXT_PASS (pass_mark_maybe_inf_loops);
NEXT_PASS (pass_if_conversion);
NEXT_PASS (pass_vectorize);
NEXT_PASS (pass_complete_unroll);
NEXT_PASS (pass_loop_prefetch);
NEXT_PASS (pass_iv_optimize);
NEXT_PASS (pass_loop_done);
*p = NULL;
#undef NEXT_PASS
register_dump_files (all_passes, 0);
}
static void execute_pass_list (struct tree_opt_pass *);
static unsigned int last_verified;
static void
execute_todo (int properties, unsigned int flags)
{
if (flags & TODO_rename_vars)
{
rewrite_into_ssa (false);
bitmap_clear (vars_to_rename);
}
if (flags & TODO_write_loop_closed)
{
rewrite_into_ssa (false);
rewrite_into_loop_closed_ssa ();
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)
{
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 ());
fflush (dump_file);
}
if (flags & TODO_ggc_collect)
ggc_collect ();
#ifdef ENABLE_CHECKING
if (flags & TODO_verify_ssa)
verify_ssa ();
if (flags & TODO_verify_flow)
verify_flow_info ();
if (flags & TODO_verify_stmts)
verify_stmts ();
#endif
}
static bool
execute_one_pass (struct tree_opt_pass *pass)
{
unsigned int todo;
if (pass->gate && !pass->gate ())
return false;
in_gimple_form = (pass->properties_provided & PROP_trees) != 0;
todo = pass->todo_flags_start & ~last_verified;
if (todo)
execute_todo (pass->properties_required, todo);
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)
{
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)"
: "");
}
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 (pass->tv_id)
timevar_push (pass->tv_id);
if (pass->execute)
pass->execute ();
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 ());
todo = pass->todo_flags_finish;
last_verified = todo & TODO_verify_all;
if (todo)
execute_todo (pass->properties_provided, todo);
if (dump_file_name)
{
free ((char *) dump_file_name);
dump_file_name = NULL;
}
if (dump_file)
{
dump_end (pass->static_pass_number, dump_file);
dump_file = NULL;
}
return true;
}
static void
execute_pass_list (struct tree_opt_pass *pass)
{
do
{
if (execute_one_pass (pass) && pass->sub)
execute_pass_list (pass->sub);
pass = pass->next;
}
while (pass);
}
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);
}
}
}
void
tree_rest_of_compilation (tree fndecl)
{
location_t saved_loc;
struct cgraph_node *saved_node = NULL, *node;
restore_func_cl_pf_opts_mapping (fndecl);
timevar_push (TV_EXPAND);
gcc_assert (!flag_unit_at_a_time || cgraph_global_info_ready);
current_function_decl = fndecl;
saved_loc = input_location;
input_location = DECL_SOURCE_LOCATION (fndecl);
init_function_start (fndecl);
cfun->x_dont_save_pending_sizes_p = 1;
node = cgraph_node (fndecl);
if (cgraph_preserve_function_body_p (fndecl))
{
if (!flag_unit_at_a_time)
{
struct cgraph_edge *e;
saved_node = cgraph_clone_node (node);
for (e = saved_node->callees; e; e = e->next_callee)
if (!e->inline_failed)
cgraph_clone_inlined_nodes (e, true);
}
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)
{
struct cgraph_edge *e;
for (e = node->callees; e; e = e->next_callee)
if (!e->inline_failed || warn_inline)
break;
if (e)
{
timevar_push (TV_INTEGRATION);
optimize_inline_calls (fndecl);
timevar_pop (TV_INTEGRATION);
}
}
cgraph_node_remove_callees (node);
bitmap_obstack_initialize (NULL);
bitmap_obstack_initialize (®_obstack);
vars_to_rename = BITMAP_ALLOC (NULL);
execute_pass_list (all_passes);
bitmap_obstack_release (®_obstack);
bitmap_obstack_release (NULL);
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;
if (!flag_unit_at_a_time)
{
struct cgraph_edge *e;
cgraph_node_remove_callees (node);
node->callees = saved_node->callees;
saved_node->callees = NULL;
update_inlined_to_pointers (node, node);
for (e = node->callees; e; e = e->next_callee)
e->caller = node;
cgraph_remove_node (saved_node);
}
}
else
DECL_SAVED_TREE (fndecl) = NULL;
cfun = 0;
if (warn_larger_than && !DECL_EXTERNAL (fndecl) && TREE_TYPE (fndecl))
{
tree ret_type = TREE_TYPE (TREE_TYPE (fndecl));
if (ret_type && TYPE_SIZE_UNIT (ret_type)
&& TREE_CODE (TYPE_SIZE_UNIT (ret_type)) == INTEGER_CST
&& 0 < compare_tree_int (TYPE_SIZE_UNIT (ret_type),
larger_than_size))
{
unsigned int size_as_int
= 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 %qD is %u bytes",
fndecl, fndecl, size_as_int);
else
warning ("%Jsize of return value of %qD is larger than %wd bytes",
fndecl, fndecl, larger_than_size);
}
}
if (!flag_inline_trees)
{
DECL_SAVED_TREE (fndecl) = NULL;
if (DECL_STRUCT_FUNCTION (fndecl) == 0
&& !cgraph_node (fndecl)->origin)
{
if (DECL_INITIAL (fndecl) != 0)
DECL_INITIAL (fndecl) = error_mark_node;
}
}
input_location = saved_loc;
ggc_collect ();
timevar_pop (TV_EXPAND);
}