/* Top level of GCC compilers (cc1, cc1plus, etc.)
Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
- 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
+ 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
Free Software Foundation, Inc.
This file is part of GCC.
Error messages and low-level interface to malloc also handled here. */
#include "config.h"
-#undef FLOAT /* This is for hpux. They should change hpux. */
-#undef FFS /* Some systems define this in param.h. */
#include "system.h"
#include "coretypes.h"
#include "tm.h"
-#include <signal.h>
-
-#ifdef HAVE_SYS_RESOURCE_H
-# include <sys/resource.h>
-#endif
-
-#ifdef HAVE_SYS_TIMES_H
-# include <sys/times.h>
-#endif
-
#include "line-map.h"
#include "input.h"
#include "tree.h"
#include "graph.h"
#include "regs.h"
#include "timevar.h"
-#include "diagnostic.h"
+#include "diagnostic-core.h"
#include "params.h"
#include "reload.h"
#include "dwarf2asm.h"
#include "integrate.h"
-#include "real.h"
#include "debug.h"
#include "target.h"
#include "langhooks.h"
#include "predict.h"
#include "lto-streamer.h"
#include "plugin.h"
+#include "ipa-utils.h"
#if defined (DWARF2_UNWIND_INFO) || defined (DWARF2_DEBUGGING_INFO)
#include "dwarf2out.h"
/* Call from the debugger to get the current pass name. */
-void
+DEBUG_FUNCTION void
debug_pass (void)
{
print_current_pass (stderr);
{
/* We deferred calling assemble_alias so that we could collect
other attributes such as visibility. Emit the alias now. */
+ if (!in_lto_p)
{
tree alias;
alias = lookup_attribute ("alias", DECL_ATTRIBUTES (decl));
|| DECL_INITIAL (decl))
&& !DECL_EXTERNAL (decl))
{
- if (TREE_CODE (decl) != FUNCTION_DECL)
+ /* When reading LTO unit, we also read varpool, so do not
+ rebuild it. */
+ if (in_lto_p && !at_end)
+ ;
+ else if (TREE_CODE (decl) != FUNCTION_DECL)
varpool_finalize_decl (decl);
- else
- assemble_variable (decl, top_level, at_end, 0);
}
#ifdef ASM_FINISH_DECLARE_OBJECT
else if (TREE_CODE (decl) == TYPE_DECL
/* Like in rest_of_type_compilation, avoid confusing the debug
information machinery when there are errors. */
- && !(sorrycount || errorcount))
+ && !seen_error ())
{
timevar_push (TV_SYMOUT);
debug_hooks->type_decl (decl, !top_level);
}
/* Let cgraph know about the existence of variables. */
- if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl))
+ if (in_lto_p && !at_end)
+ ;
+ else if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl)
+ && TREE_STATIC (decl))
varpool_node (decl);
}
{
/* Avoid confusing the debug information machinery when there are
errors. */
- if (errorcount != 0 || sorrycount != 0)
+ if (seen_error ())
return;
timevar_push (TV_SYMOUT);
{
/* Early return if there were errors. We can run afoul of our
consistency checks, and there's not really much point in fixing them. */
- return !(rtl_dump_and_exit || flag_syntax_only || errorcount || sorrycount);
+ return !(rtl_dump_and_exit || flag_syntax_only || seen_error ());
}
struct gimple_opt_pass pass_rest_of_compilation =
NULL, /* sub */
NULL, /* next */
0, /* static_pass_number */
- TV_NONE, /* tv_id */
+ TV_POSTRELOAD, /* tv_id */
PROP_rtl, /* properties_required */
0, /* properties_provided */
0, /* properties_destroyed */
pass = new_pass;
break;
default:
- error ("Invalid pass positioning operation");
+ error ("invalid pass positioning operation");
return false;
}
NEXT_PASS (pass_refactor_eh);
NEXT_PASS (pass_lower_eh);
NEXT_PASS (pass_build_cfg);
- NEXT_PASS (pass_lower_vector);
NEXT_PASS (pass_warn_function_return);
NEXT_PASS (pass_build_cgraph_edges);
- NEXT_PASS (pass_inline_parameters);
*p = NULL;
/* Interprocedural optimization passes. */
p = &all_small_ipa_passes;
- NEXT_PASS (pass_ipa_function_and_variable_visibility);
- NEXT_PASS (pass_ipa_early_inline);
- {
- struct opt_pass **p = &pass_ipa_early_inline.pass.sub;
- NEXT_PASS (pass_early_inline);
- NEXT_PASS (pass_inline_parameters);
- NEXT_PASS (pass_rebuild_cgraph_edges);
- }
NEXT_PASS (pass_ipa_free_lang_data);
+ NEXT_PASS (pass_ipa_function_and_variable_visibility);
NEXT_PASS (pass_early_local_passes);
{
struct opt_pass **p = &pass_early_local_passes.pass.sub;
NEXT_PASS (pass_fixup_cfg);
- NEXT_PASS (pass_tree_profile);
- NEXT_PASS (pass_cleanup_cfg);
NEXT_PASS (pass_init_datastructures);
NEXT_PASS (pass_expand_omp);
NEXT_PASS (pass_referenced_vars);
NEXT_PASS (pass_build_ssa);
+ NEXT_PASS (pass_lower_vector);
NEXT_PASS (pass_early_warn_uninitialized);
- /* Note that it is not strictly necessary to schedule an early
- inline pass here. However, some test cases (e.g.,
- g++.dg/other/p334435.C g++.dg/other/i386-1.C) expect extern
- inline functions to be inlined even at -O0. This does not
- happen during the first early inline pass. */
NEXT_PASS (pass_rebuild_cgraph_edges);
+ NEXT_PASS (pass_inline_parameters);
NEXT_PASS (pass_early_inline);
NEXT_PASS (pass_all_early_optimizations);
{
locals into SSA form if possible. */
NEXT_PASS (pass_build_ealias);
NEXT_PASS (pass_sra_early);
+ NEXT_PASS (pass_fre);
NEXT_PASS (pass_copy_prop);
NEXT_PASS (pass_merge_phi);
NEXT_PASS (pass_cd_dce);
NEXT_PASS (pass_cleanup_eh);
NEXT_PASS (pass_profile);
NEXT_PASS (pass_local_pure_const);
+ /* Split functions creates parts that are not run through
+ early optimizations again. It is thus good idea to do this
+ late. */
+ NEXT_PASS (pass_split_functions);
}
NEXT_PASS (pass_release_ssa_names);
NEXT_PASS (pass_rebuild_cgraph_edges);
NEXT_PASS (pass_inline_parameters);
}
+ NEXT_PASS (pass_ipa_tree_profile);
+ {
+ struct opt_pass **p = &pass_ipa_tree_profile.pass.sub;
+ NEXT_PASS (pass_feedback_split_functions);
+ }
NEXT_PASS (pass_ipa_increase_alignment);
NEXT_PASS (pass_ipa_matrix_reorg);
+ NEXT_PASS (pass_ipa_lower_emutls);
*p = NULL;
p = &all_regular_ipa_passes;
NEXT_PASS (pass_ipa_whole_program_visibility);
+ NEXT_PASS (pass_ipa_profile);
NEXT_PASS (pass_ipa_cp);
+ NEXT_PASS (pass_ipa_cdtor_merge);
NEXT_PASS (pass_ipa_inline);
- NEXT_PASS (pass_ipa_reference);
NEXT_PASS (pass_ipa_pure_const);
- NEXT_PASS (pass_ipa_type_escape);
+ NEXT_PASS (pass_ipa_reference);
NEXT_PASS (pass_ipa_pta);
- NEXT_PASS (pass_ipa_struct_reorg);
*p = NULL;
p = &all_lto_gen_passes;
NEXT_PASS (pass_ipa_lto_gimple_out);
- NEXT_PASS (pass_ipa_lto_wpa_fixup);
NEXT_PASS (pass_ipa_lto_finish_out); /* This must be the last LTO pass. */
*p = NULL;
/* Initial scalar cleanups before alias computation.
They ensure memory accesses are not indirect wherever possible. */
NEXT_PASS (pass_strip_predict_hints);
- NEXT_PASS (pass_update_address_taken);
NEXT_PASS (pass_rename_ssa_copies);
NEXT_PASS (pass_complete_unrolli);
NEXT_PASS (pass_ccp);
{
struct opt_pass **p = &pass_tree_loop.pass.sub;
NEXT_PASS (pass_tree_loop_init);
+ NEXT_PASS (pass_lim);
NEXT_PASS (pass_copy_prop);
NEXT_PASS (pass_dce_loop);
- NEXT_PASS (pass_lim);
NEXT_PASS (pass_tree_unswitch);
NEXT_PASS (pass_scev_cprop);
NEXT_PASS (pass_record_bounds);
NEXT_PASS (pass_check_data_deps);
NEXT_PASS (pass_loop_distribution);
- NEXT_PASS (pass_linear_transform);
- NEXT_PASS (pass_graphite_transforms);
+ NEXT_PASS (pass_copy_prop);
+ NEXT_PASS (pass_graphite);
{
- struct opt_pass **p = &pass_graphite_transforms.pass.sub;
+ struct opt_pass **p = &pass_graphite.pass.sub;
+ NEXT_PASS (pass_graphite_transforms);
+ NEXT_PASS (pass_lim);
NEXT_PASS (pass_copy_prop);
NEXT_PASS (pass_dce_loop);
- NEXT_PASS (pass_lim);
}
NEXT_PASS (pass_iv_canon);
NEXT_PASS (pass_if_conversion);
NEXT_PASS (pass_forwprop);
NEXT_PASS (pass_phiopt);
NEXT_PASS (pass_fold_builtins);
+ NEXT_PASS (pass_optimize_widening_mul);
NEXT_PASS (pass_tail_calls);
NEXT_PASS (pass_rename_ssa_copies);
NEXT_PASS (pass_uncprop);
NEXT_PASS (pass_postreload_cse);
NEXT_PASS (pass_gcse2);
NEXT_PASS (pass_split_after_reload);
+ NEXT_PASS (pass_implicit_zee);
+ NEXT_PASS (pass_compare_elim_after_reload);
NEXT_PASS (pass_branch_target_load_optimize1);
NEXT_PASS (pass_thread_prologue_and_epilogue);
NEXT_PASS (pass_rtl_dse2);
keep the array visible to garbage collector to avoid reading collected
out nodes. */
static int nnodes;
-static GTY ((length ("nnodes"))) struct cgraph_node **order;
+static GTY ((length ("nnodes"))) cgraph_node_ptr *order;
/* If we are in IPA mode (i.e., current_function_decl is NULL), call
function CALLBACK for every function in the call graph. Otherwise,
else
{
gcc_assert (!order);
- order = GGC_NEWVEC (struct cgraph_node *, cgraph_n_nodes);
- nnodes = cgraph_postorder (order);
+ order = ggc_alloc_vec_cgraph_node_ptr (cgraph_n_nodes);
+ nnodes = ipa_reverse_postorder (order);
for (i = nnodes - 1; i >= 0; i--)
order[i]->process = 1;
for (i = nnodes - 1; i >= 0; i--)
/* Allow possibly removed nodes to be garbage collected. */
order[i] = NULL;
node->process = 0;
- if (node->analyzed)
+ if (cgraph_function_with_gimple_body_p (node))
{
push_cfun (DECL_STRUCT_FUNCTION (node->decl));
current_function_decl = node->decl;
execute_function_todo (void *data)
{
unsigned int flags = (size_t)data;
- if (cfun->curr_properties & PROP_ssa)
- flags |= TODO_verify_ssa;
flags &= ~cfun->last_verified;
if (!flags)
return;
- statistics_fini_pass ();
-
/* Always cleanup the CFG before trying to update SSA. */
if (flags & TODO_cleanup_cfg)
{
cfun->last_verified &= ~TODO_verify_ssa;
}
- if (flags & TODO_update_address_taken)
- execute_update_addresses_taken (true);
-
if (flags & TODO_rebuild_alias)
{
- if (!(flags & TODO_update_address_taken))
- execute_update_addresses_taken (true);
+ execute_update_addresses_taken ();
compute_may_aliases ();
}
+ else if (optimize && (flags & TODO_update_address_taken))
+ execute_update_addresses_taken ();
if (flags & TODO_remove_unused_locals)
remove_unused_locals ();
}
if (flags & TODO_rebuild_frequencies)
- {
- if (profile_status == PROFILE_GUESSED)
- {
- loop_optimizer_init (0);
- add_noreturn_fake_exit_edges ();
- mark_irreducible_loops ();
- connect_infinite_loops_to_exit ();
- estimate_bb_frequencies ();
- remove_fake_exit_edges ();
- loop_optimizer_finalize ();
- }
- else if (profile_status == PROFILE_READ)
- counts_to_freqs ();
- else
- gcc_unreachable ();
- }
+ rebuild_frequencies ();
+
+ if (flags & TODO_rebuild_cgraph_edges)
+ rebuild_cgraph_edges ();
+
+ /* If we've seen errors do not bother running any verifiers. */
+ if (seen_error ())
+ return;
#if defined ENABLE_CHECKING
- if (flags & TODO_verify_ssa)
+ if (flags & TODO_verify_ssa
+ || (current_loops && loops_state_satisfies_p (LOOP_CLOSED_SSA)))
verify_ssa (true);
if (flags & TODO_verify_flow)
verify_flow_info ();
if (flags & TODO_verify_stmts)
- verify_stmts ();
- if (flags & TODO_verify_loops)
- verify_loop_closed_ssa ();
+ verify_gimple_in_cfg (cfun);
+ if (current_loops && loops_state_satisfies_p (LOOP_CLOSED_SSA))
+ verify_loop_closed_ssa (false);
if (flags & TODO_verify_rtl_sharing)
verify_rtl_sharing ();
#endif
gcc_assert (flags & TODO_update_ssa_any);
#endif
+ timevar_push (TV_TODO);
+
/* Inform the pass whether it is the first time it is run. */
first_pass_instance = (flags & TODO_mark_first_instance) != 0;
+ statistics_fini_pass ();
+
do_per_function (execute_function_todo, (void *)(size_t) flags);
/* Always remove functions just as before inlining: IPA passes might be
df problems. */
if (flags & TODO_df_finish)
df_finish_pass ((flags & TODO_df_verify) != 0);
+
+ timevar_pop (TV_TODO);
}
/* Verify invariants that should hold between passes. This is a place
static void
verify_interpass_invariants (void)
{
-#ifdef ENABLE_CHECKING
- gcc_assert (!fold_deferring_overflow_warnings_p ());
-#endif
+ gcc_checking_assert (!fold_deferring_overflow_warnings_p ());
}
/* Clear the last verified flag. */
if (dump_file && current_function_decl)
{
const char *dname, *aname;
+ struct cgraph_node *node = cgraph_get_node (current_function_decl);
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
+ node->frequency == NODE_FREQUENCY_HOT
? " (hot)"
- : cfun->function_frequency == FUNCTION_FREQUENCY_UNLIKELY_EXECUTED
+ : node->frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED
? " (unlikely executed)"
+ : node->frequency == NODE_FREQUENCY_EXECUTED_ONCE
+ ? " (executed once)"
: "");
}
return initializing_dump;
struct cgraph_node *node;
if (!cfun)
return;
- node = cgraph_node (current_function_decl);
+ node = cgraph_get_node (current_function_decl);
+
if (node->ipa_transforms_to_apply)
{
unsigned int i;
if (pass->type == IPA_PASS)
{
struct cgraph_node *node;
- for (node = cgraph_nodes; node; node = node->next)
- if (node->analyzed)
- VEC_safe_push (ipa_opt_pass, heap, node->ipa_transforms_to_apply,
- (struct ipa_opt_pass_d *)pass);
+ FOR_EACH_FUNCTION_WITH_GIMPLE_BODY (node)
+ VEC_safe_push (ipa_opt_pass, heap, node->ipa_transforms_to_apply,
+ (struct ipa_opt_pass_d *)pass);
}
if (!current_function_decl)
static void
ipa_write_summaries_2 (struct opt_pass *pass, cgraph_node_set set,
+ varpool_node_set vset,
struct lto_out_decl_state *state)
{
while (pass)
if (pass->tv_id)
timevar_push (pass->tv_id);
- ipa_pass->write_summary (set);
+ pass_init_dump_file (pass);
+
+ ipa_pass->write_summary (set,vset);
+
+ pass_fini_dump_file (pass);
/* If a timevar is present, start it. */
if (pass->tv_id)
}
if (pass->sub && pass->sub->type != GIMPLE_PASS)
- ipa_write_summaries_2 (pass->sub, set, state);
+ ipa_write_summaries_2 (pass->sub, set, vset, state);
pass = pass->next;
}
summaries. SET is the set of nodes to be written. */
static void
-ipa_write_summaries_1 (cgraph_node_set set)
+ipa_write_summaries_1 (cgraph_node_set set, varpool_node_set vset)
{
struct lto_out_decl_state *state = lto_new_out_decl_state ();
+ compute_ltrans_boundary (state, set, vset);
+
lto_push_out_decl_state (state);
- if (!flag_wpa)
- ipa_write_summaries_2 (all_regular_ipa_passes, set, state);
- ipa_write_summaries_2 (all_lto_gen_passes, set, state);
+ gcc_assert (!flag_wpa);
+ ipa_write_summaries_2 (all_regular_ipa_passes, set, vset, state);
+ ipa_write_summaries_2 (all_lto_gen_passes, set, vset, state);
gcc_assert (lto_get_out_decl_state () == state);
lto_pop_out_decl_state ();
ipa_write_summaries (void)
{
cgraph_node_set set;
+ varpool_node_set vset;
struct cgraph_node **order;
+ struct varpool_node *vnode;
int i, order_pos;
- if (!flag_generate_lto || errorcount || sorrycount)
+ if (!flag_generate_lto || seen_error ())
return;
- lto_new_extern_inline_states ();
set = cgraph_node_set_new ();
/* Create the callgraph set in the same order used in
since it causes the gimple file to be processed in the same order
as the source code. */
order = XCNEWVEC (struct cgraph_node *, cgraph_n_nodes);
- order_pos = cgraph_postorder (order);
+ order_pos = ipa_reverse_postorder (order);
gcc_assert (order_pos == cgraph_n_nodes);
for (i = order_pos - 1; i >= 0; i--)
{
struct cgraph_node *node = order[i];
- if (node->analyzed)
+ if (cgraph_function_with_gimple_body_p (node))
{
/* When streaming out references to statements as part of some IPA
pass summary, the statements need to have uids assigned and the
renumber_gimple_stmt_uids ();
pop_cfun ();
}
- cgraph_node_set_add (set, node);
+ if (node->analyzed)
+ cgraph_node_set_add (set, node);
}
+ vset = varpool_node_set_new ();
- ipa_write_summaries_1 (set);
- lto_delete_extern_inline_states ();
+ for (vnode = varpool_nodes; vnode; vnode = vnode->next)
+ if (vnode->needed && !vnode->alias)
+ varpool_node_set_add (vset, vnode);
+
+ ipa_write_summaries_1 (set, vset);
free (order);
- ggc_free (set);
+ free_cgraph_node_set (set);
+ free_varpool_node_set (vset);
}
+/* Same as execute_pass_list but assume that subpasses of IPA passes
+ are local passes. If SET is not NULL, write out optimization summaries of
+ only those node in SET. */
+
+static void
+ipa_write_optimization_summaries_1 (struct opt_pass *pass, cgraph_node_set set,
+ varpool_node_set vset,
+ struct lto_out_decl_state *state)
+{
+ while (pass)
+ {
+ struct ipa_opt_pass_d *ipa_pass = (struct ipa_opt_pass_d *)pass;
+ gcc_assert (!current_function_decl);
+ gcc_assert (!cfun);
+ gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS);
+ if (pass->type == IPA_PASS
+ && ipa_pass->write_optimization_summary
+ && (!pass->gate || pass->gate ()))
+ {
+ /* If a timevar is present, start it. */
+ if (pass->tv_id)
+ timevar_push (pass->tv_id);
+
+ pass_init_dump_file (pass);
+
+ ipa_pass->write_optimization_summary (set, vset);
-/* Write all the summaries for the cgraph nodes in SET. If SET is
+ pass_fini_dump_file (pass);
+
+ /* If a timevar is present, start it. */
+ if (pass->tv_id)
+ timevar_pop (pass->tv_id);
+ }
+
+ if (pass->sub && pass->sub->type != GIMPLE_PASS)
+ ipa_write_optimization_summaries_1 (pass->sub, set, vset, state);
+
+ pass = pass->next;
+ }
+}
+
+/* Write all the optimization summaries for the cgraph nodes in SET. If SET is
NULL, write out all summaries of all nodes. */
void
-ipa_write_summaries_of_cgraph_node_set (cgraph_node_set set)
+ipa_write_optimization_summaries (cgraph_node_set set, varpool_node_set vset)
{
- if (flag_generate_lto && !(errorcount || sorrycount))
- ipa_write_summaries_1 (set);
+ struct lto_out_decl_state *state = lto_new_out_decl_state ();
+ cgraph_node_set_iterator csi;
+ compute_ltrans_boundary (state, set, vset);
+
+ lto_push_out_decl_state (state);
+ for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
+ {
+ struct cgraph_node *node = csi_node (csi);
+ /* When streaming out references to statements as part of some IPA
+ pass summary, the statements need to have uids assigned.
+
+ For functions newly born at WPA stage we need to initialize
+ the uids here. */
+ if (node->analyzed
+ && gimple_has_body_p (node->decl))
+ {
+ push_cfun (DECL_STRUCT_FUNCTION (node->decl));
+ renumber_gimple_stmt_uids ();
+ pop_cfun ();
+ }
+ }
+
+ gcc_assert (flag_wpa);
+ ipa_write_optimization_summaries_1 (all_regular_ipa_passes, set, vset, state);
+ ipa_write_optimization_summaries_1 (all_lto_gen_passes, set, vset, state);
+
+ gcc_assert (lto_get_out_decl_state () == state);
+ lto_pop_out_decl_state ();
+ lto_delete_out_decl_state (state);
}
/* Same as execute_pass_list but assume that subpasses of IPA passes
if (pass->tv_id)
timevar_push (pass->tv_id);
+ pass_init_dump_file (pass);
+
ipa_pass->read_summary ();
+ pass_fini_dump_file (pass);
+
/* Stop timevar. */
if (pass->tv_id)
timevar_pop (pass->tv_id);
void
ipa_read_summaries (void)
{
- if (!flag_ltrans)
- ipa_read_summaries_1 (all_regular_ipa_passes);
+ ipa_read_summaries_1 (all_regular_ipa_passes);
ipa_read_summaries_1 (all_lto_gen_passes);
}
/* Same as execute_pass_list but assume that subpasses of IPA passes
are local passes. */
+
+static void
+ipa_read_optimization_summaries_1 (struct opt_pass *pass)
+{
+ while (pass)
+ {
+ struct ipa_opt_pass_d *ipa_pass = (struct ipa_opt_pass_d *) pass;
+
+ gcc_assert (!current_function_decl);
+ gcc_assert (!cfun);
+ gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS);
+
+ if (pass->gate == NULL || pass->gate ())
+ {
+ if (pass->type == IPA_PASS && ipa_pass->read_optimization_summary)
+ {
+ /* If a timevar is present, start it. */
+ if (pass->tv_id)
+ timevar_push (pass->tv_id);
+
+ pass_init_dump_file (pass);
+
+ ipa_pass->read_optimization_summary ();
+
+ pass_fini_dump_file (pass);
+
+ /* Stop timevar. */
+ if (pass->tv_id)
+ timevar_pop (pass->tv_id);
+ }
+
+ if (pass->sub && pass->sub->type != GIMPLE_PASS)
+ ipa_read_optimization_summaries_1 (pass->sub);
+ }
+ pass = pass->next;
+ }
+}
+
+/* Read all the summaries for all_regular_ipa_passes and all_lto_gen_passes. */
+
+void
+ipa_read_optimization_summaries (void)
+{
+ ipa_read_optimization_summaries_1 (all_regular_ipa_passes);
+ ipa_read_optimization_summaries_1 (all_lto_gen_passes);
+}
+
+/* Same as execute_pass_list but assume that subpasses of IPA passes
+ are local passes. */
void
execute_ipa_pass_list (struct opt_pass *pass)
{
extern void debug_properties (unsigned int);
extern void dump_properties (FILE *, unsigned int);
-void
+DEBUG_FUNCTION void
dump_properties (FILE *dump, unsigned int props)
{
fprintf (dump, "Properties:\n");
fprintf (dump, "PROP_gimple_lomp\n");
if (props & PROP_gimple_lcx)
fprintf (dump, "PROP_gimple_lcx\n");
+ if (props & PROP_cfglayout)
+ fprintf (dump, "PROP_cfglayout\n");
}
-void
+DEBUG_FUNCTION void
debug_properties (unsigned int props)
{
dump_properties (stderr, props);
function_called_by_processed_nodes_p (void)
{
struct cgraph_edge *e;
- for (e = cgraph_node (current_function_decl)->callers; e; e = e->next_caller)
+ for (e = cgraph_get_node (current_function_decl)->callers;
+ e;
+ e = e->next_caller)
{
if (e->caller->decl == current_function_decl)
continue;
- if (!e->caller->analyzed)
+ if (!cgraph_function_with_gimple_body_p (e->caller))
continue;
if (TREE_ASM_WRITTEN (e->caller->decl))
continue;
OSDN Git Service
