GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
-Software Foundation; either version 2, or (at your option) any later
+Software Foundation; either version 3, or (at your option) any later
version.
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
for more details.
You should have received a copy of the GNU General Public License
-along with GCC; see the file COPYING. If not, write to the Free
-Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
-02110-1301, USA. */
+along with GCC; see the file COPYING3. If not see
+<http://www.gnu.org/licenses/>. */
/* This is the top level of cc1/c++.
It parses command args, opens files, invokes the various passes
#include "tree-flow.h"
#include "tree-pass.h"
#include "tree-dump.h"
+#include "df.h"
#include "predict.h"
#if defined (DWARF2_UNWIND_INFO) || defined (DWARF2_DEBUGGING_INFO)
declarations for e.g. AIX 4.x. */
#endif
+/* This is used for debugging. It allows the current pass to printed
+ from anywhere in compilation. */
+struct tree_opt_pass *current_pass;
+
+/* Call from anywhere to find out what pass this is. Useful for
+ printing out debugging information deep inside an service
+ routine. */
+void
+print_current_pass (FILE *file)
+{
+ if (current_pass)
+ fprintf (file, "current pass = %s (%d)\n",
+ current_pass->name, current_pass->static_pass_number);
+ else
+ fprintf (file, "no current pass.\n");
+}
+
+
+/* Call from the debugger to get the current pass name. */
+void
+debug_pass (void)
+{
+ print_current_pass (stderr);
+}
+
+
+
/* Global variables used to communicate with passes. */
int dump_flags;
bool in_gimple_form;
+bool first_pass_instance;
/* This is called from various places for FUNCTION_DECL, VAR_DECL,
memcpy (new, pass, sizeof (*new));
new->next = NULL;
+ new->todo_flags_start &= ~TODO_mark_first_instance;
+
/* 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.
}
else
{
+ pass->todo_flags_start |= TODO_mark_first_instance;
pass->static_pass_number = -1;
*list = pass;
}
}
+
/* Construct the pass tree. The sequencing of passes is driven by
the cgraph routines:
NEXT_PASS (pass_inline_parameters);
}
NEXT_PASS (pass_ipa_increase_alignment);
+ NEXT_PASS (pass_ipa_matrix_reorg);
NEXT_PASS (pass_ipa_cp);
NEXT_PASS (pass_ipa_inline);
NEXT_PASS (pass_ipa_reference);
opportunities. */
NEXT_PASS (pass_phi_only_cprop);
+ NEXT_PASS (pass_tree_ifcombine);
NEXT_PASS (pass_phiopt);
NEXT_PASS (pass_may_alias);
NEXT_PASS (pass_tail_recursion);
struct tree_opt_pass **p = &pass_tree_loop.sub;
NEXT_PASS (pass_tree_loop_init);
NEXT_PASS (pass_copy_prop);
+ NEXT_PASS (pass_dce_loop);
NEXT_PASS (pass_lim);
+ NEXT_PASS (pass_predcom);
NEXT_PASS (pass_tree_unswitch);
NEXT_PASS (pass_scev_cprop);
NEXT_PASS (pass_empty_loop);
NEXT_PASS (pass_tree_loop_done);
}
NEXT_PASS (pass_cse_reciprocals);
+ NEXT_PASS (pass_convert_to_rsqrt);
NEXT_PASS (pass_reassoc);
NEXT_PASS (pass_vrp);
NEXT_PASS (pass_dominator);
NEXT_PASS (pass_into_cfg_layout_mode);
NEXT_PASS (pass_jump2);
NEXT_PASS (pass_lower_subreg);
+ NEXT_PASS (pass_df_initialize_opt);
NEXT_PASS (pass_cse);
NEXT_PASS (pass_rtl_fwprop);
NEXT_PASS (pass_gcse);
- NEXT_PASS (pass_jump_bypass);
NEXT_PASS (pass_rtl_ifcvt);
NEXT_PASS (pass_tracer);
/* Perform loop optimizations. It might be better to do them a bit
*p = NULL;
}
NEXT_PASS (pass_web);
+ NEXT_PASS (pass_jump_bypass);
NEXT_PASS (pass_cse2);
+ NEXT_PASS (pass_rtl_dse1);
NEXT_PASS (pass_rtl_fwprop_addr);
+ NEXT_PASS (pass_regclass_init);
+ NEXT_PASS (pass_inc_dec);
+ NEXT_PASS (pass_initialize_regs);
NEXT_PASS (pass_outof_cfg_layout_mode);
- NEXT_PASS (pass_life);
+ NEXT_PASS (pass_ud_rtl_dce);
NEXT_PASS (pass_combine);
NEXT_PASS (pass_if_after_combine);
NEXT_PASS (pass_partition_blocks);
NEXT_PASS (pass_regmove);
NEXT_PASS (pass_split_all_insns);
NEXT_PASS (pass_lower_subreg2);
+ NEXT_PASS (pass_df_initialize_no_opt);
+ NEXT_PASS (pass_stack_ptr_mod);
NEXT_PASS (pass_mode_switching);
NEXT_PASS (pass_see);
- NEXT_PASS (pass_recompute_reg_usage);
+ NEXT_PASS (pass_match_asm_constraints);
NEXT_PASS (pass_sms);
NEXT_PASS (pass_sched);
+ NEXT_PASS (pass_subregs_of_mode_init);
NEXT_PASS (pass_local_alloc);
NEXT_PASS (pass_global_alloc);
+ NEXT_PASS (pass_subregs_of_mode_finish);
NEXT_PASS (pass_postreload);
{
struct tree_opt_pass **p = &pass_postreload.sub;
NEXT_PASS (pass_postreload_cse);
NEXT_PASS (pass_gcse2);
- NEXT_PASS (pass_flow2);
+ NEXT_PASS (pass_split_after_reload);
+ NEXT_PASS (pass_branch_target_load_optimize1);
+ NEXT_PASS (pass_thread_prologue_and_epilogue);
+ NEXT_PASS (pass_rtl_dse2);
NEXT_PASS (pass_rtl_seqabstr);
NEXT_PASS (pass_stack_adjustments);
NEXT_PASS (pass_peephole2);
NEXT_PASS (pass_if_after_reload);
NEXT_PASS (pass_regrename);
+ NEXT_PASS (pass_cprop_hardreg);
+ NEXT_PASS (pass_fast_rtl_dce);
NEXT_PASS (pass_reorder_blocks);
- NEXT_PASS (pass_branch_target_load_optimize);
+ NEXT_PASS (pass_branch_target_load_optimize2);
NEXT_PASS (pass_leaf_regs);
+ NEXT_PASS (pass_split_before_sched2);
NEXT_PASS (pass_sched2);
- NEXT_PASS (pass_split_before_regstack);
NEXT_PASS (pass_stack_regs);
+ {
+ struct tree_opt_pass **p = &pass_stack_regs.sub;
+ NEXT_PASS (pass_split_before_regstack);
+ NEXT_PASS (pass_stack_regs_run);
+ }
NEXT_PASS (pass_compute_alignments);
NEXT_PASS (pass_duplicate_computed_gotos);
NEXT_PASS (pass_variable_tracking);
NEXT_PASS (pass_machine_reorg);
NEXT_PASS (pass_cleanup_barriers);
NEXT_PASS (pass_delay_slots);
+ NEXT_PASS (pass_df_finish);
NEXT_PASS (pass_split_for_shorten_branches);
NEXT_PASS (pass_convert_to_eh_region_ranges);
NEXT_PASS (pass_shorten_branches);
/* Always cleanup the CFG before trying to update SSA. */
if (flags & TODO_cleanup_cfg)
{
- bool cleanup;
-
- if (current_loops)
- cleanup = cleanup_tree_cfg_loop ();
- else
- cleanup = cleanup_tree_cfg ();
+ bool cleanup = cleanup_tree_cfg ();
if (cleanup && (cfun->curr_properties & PROP_ssa))
flags |= TODO_remove_unused_locals;
gcc_assert (flags & TODO_update_ssa_any);
#endif
+ /* Inform the pass whether it is the first time it is run. */
+ first_pass_instance = (flags & TODO_mark_first_instance) != 0;
+
do_per_function (execute_function_todo, (void *)(size_t) flags);
/* Always remove functions just as before inlining: IPA passes might be
{
ggc_collect ();
}
+
+ /* Now that the dumping has been done, we can get rid of the optional
+ df problems. */
+ if (flags & TODO_df_finish)
+ df_finish_pass ((flags & TODO_df_verify) != 0);
}
/* Verify invariants that should hold between passes. This is a place
bool initializing_dump;
unsigned int todo_after = 0;
+ current_pass = pass;
/* See if we're supposed to run this pass. */
if (pass->gate && !pass->gate ())
return false;
/* Flush and close dump file. */
if (dump_file_name)
{
- free ((char *) dump_file_name);
+ free (CONST_CAST (dump_file_name));
dump_file_name = NULL;
}
dump_file = NULL;
}
+ current_pass = NULL;
/* Reset in_gimple_form to not break non-unit-at-a-time mode. */
in_gimple_form = false;
OSDN Git Service
