gcc/passes.def

   1 /* Description of pass structure
   2    Copyright (C) 1987-2013 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify it under
   7 the terms of the GNU General Public License as published by the Free
   8 Software Foundation; either version 3, or (at your option) any later
   9 version.
  10
  11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GCC; see the file COPYING3.  If not see
  18 <http://www.gnu.org/licenses/>.  */
  19
  20 /*
  21  Macros that should be defined when using this file:
  22    INSERT_PASSES_AFTER (PASS)
  23    PUSH_INSERT_PASSES_WITHIN (PASS)
  24    POP_INSERT_PASSES ()
  25    NEXT_PASS (PASS)
  26    TERMINATE_PASS_LIST ()
  27  */
  28
  29  /* All passes needed to lower the function into shape optimizers can
  30     operate on.  These passes are always run first on the function, but
  31     backend might produce already lowered functions that are not processed
  32     by these passes.  */
  33   INSERT_PASSES_AFTER (all_lowering_passes)
  34   NEXT_PASS (pass_warn_unused_result);
  35   NEXT_PASS (pass_diagnose_omp_blocks);
  36   NEXT_PASS (pass_diagnose_tm_blocks);
  37   NEXT_PASS (pass_lower_omp);
  38   NEXT_PASS (pass_lower_cf);
  39   NEXT_PASS (pass_lower_tm);
  40   NEXT_PASS (pass_refactor_eh);
  41   NEXT_PASS (pass_lower_eh);
  42   NEXT_PASS (pass_build_cfg);
  43   NEXT_PASS (pass_warn_function_return);
  44   NEXT_PASS (pass_expand_omp);
  45   NEXT_PASS (pass_build_cgraph_edges);
  46   TERMINATE_PASS_LIST ()
  47
  48   /* Interprocedural optimization passes.  */
  49   INSERT_PASSES_AFTER (all_small_ipa_passes)
  50   NEXT_PASS (pass_ipa_free_lang_data);
  51   NEXT_PASS (pass_ipa_function_and_variable_visibility);
  52   NEXT_PASS (pass_early_local_passes);
  53   PUSH_INSERT_PASSES_WITHIN (pass_early_local_passes)
  54       NEXT_PASS (pass_fixup_cfg);
  55       NEXT_PASS (pass_init_datastructures);
  56
  57       NEXT_PASS (pass_build_ssa);
  58       NEXT_PASS (pass_early_warn_uninitialized);
  59       NEXT_PASS (pass_rebuild_cgraph_edges);
  60       NEXT_PASS (pass_inline_parameters);
  61       NEXT_PASS (pass_early_inline);
  62       NEXT_PASS (pass_all_early_optimizations);
  63       PUSH_INSERT_PASSES_WITHIN (pass_all_early_optimizations)
  64           NEXT_PASS (pass_remove_cgraph_callee_edges);
  65           NEXT_PASS (pass_rename_ssa_copies);
  66           NEXT_PASS (pass_ccp);
  67           /* After CCP we rewrite no longer addressed locals into SSA
  68              form if possible.  */
  69           NEXT_PASS (pass_forwprop);
  70           /* pass_build_ealias is a dummy pass that ensures that we
  71              execute TODO_rebuild_alias at this point.  */
  72           NEXT_PASS (pass_build_ealias);
  73           NEXT_PASS (pass_sra_early);
  74           NEXT_PASS (pass_fre);
  75           NEXT_PASS (pass_copy_prop);
  76           NEXT_PASS (pass_merge_phi);
  77           NEXT_PASS (pass_cd_dce);
  78           NEXT_PASS (pass_early_ipa_sra);
  79           NEXT_PASS (pass_tail_recursion);
  80           NEXT_PASS (pass_convert_switch);
  81           NEXT_PASS (pass_cleanup_eh);
  82           NEXT_PASS (pass_profile);
  83           NEXT_PASS (pass_local_pure_const);
  84           /* Split functions creates parts that are not run through
  85              early optimizations again.  It is thus good idea to do this
  86              late.  */
  87           NEXT_PASS (pass_split_functions);
  88       POP_INSERT_PASSES ()
  89       NEXT_PASS (pass_release_ssa_names);
  90       NEXT_PASS (pass_rebuild_cgraph_edges);
  91       NEXT_PASS (pass_inline_parameters);
  92   POP_INSERT_PASSES ()
  93   NEXT_PASS (pass_ipa_free_inline_summary);
  94   NEXT_PASS (pass_ipa_tree_profile);
  95   PUSH_INSERT_PASSES_WITHIN (pass_ipa_tree_profile)
  96       NEXT_PASS (pass_feedback_split_functions);
  97   POP_INSERT_PASSES ()
  98   NEXT_PASS (pass_ipa_increase_alignment);
  99   NEXT_PASS (pass_ipa_tm);
 100   NEXT_PASS (pass_ipa_lower_emutls);
 101   TERMINATE_PASS_LIST ()
 102
 103   INSERT_PASSES_AFTER (all_regular_ipa_passes)
 104   NEXT_PASS (pass_ipa_whole_program_visibility);
 105   NEXT_PASS (pass_ipa_profile);
 106   NEXT_PASS (pass_ipa_devirt);
 107   NEXT_PASS (pass_ipa_cp);
 108   NEXT_PASS (pass_ipa_cdtor_merge);
 109   NEXT_PASS (pass_ipa_inline);
 110   NEXT_PASS (pass_ipa_pure_const);
 111   NEXT_PASS (pass_ipa_reference);
 112   TERMINATE_PASS_LIST ()
 113
 114   INSERT_PASSES_AFTER (all_lto_gen_passes)
 115   NEXT_PASS (pass_ipa_lto_gimple_out);
 116   NEXT_PASS (pass_ipa_lto_finish_out);  /* This must be the last LTO pass.  */
 117   TERMINATE_PASS_LIST ()
 118
 119   /* Simple IPA passes executed after the regular passes.  In WHOPR mode the
 120      passes are executed after partitioning and thus see just parts of the
 121      compiled unit.  */
 122   INSERT_PASSES_AFTER (all_late_ipa_passes)
 123   NEXT_PASS (pass_ipa_pta);
 124   TERMINATE_PASS_LIST ()
 125
 126   /* These passes are run after IPA passes on every function that is being
 127      output to the assembler file.  */
 128   INSERT_PASSES_AFTER (all_passes)
 129   NEXT_PASS (pass_lower_eh_dispatch);
 130   NEXT_PASS (pass_all_optimizations);
 131   PUSH_INSERT_PASSES_WITHIN (pass_all_optimizations)
 132       NEXT_PASS (pass_remove_cgraph_callee_edges);
 133       /* Initial scalar cleanups before alias computation.
 134          They ensure memory accesses are not indirect wherever possible.  */
 135       NEXT_PASS (pass_strip_predict_hints);
 136       NEXT_PASS (pass_rename_ssa_copies);
 137       NEXT_PASS (pass_copy_prop);
 138       NEXT_PASS (pass_complete_unrolli);
 139       NEXT_PASS (pass_ccp);
 140       /* After CCP we rewrite no longer addressed locals into SSA
 141          form if possible.  */
 142       NEXT_PASS (pass_phiprop);
 143       NEXT_PASS (pass_forwprop);
 144       /* pass_build_alias is a dummy pass that ensures that we
 145          execute TODO_rebuild_alias at this point.  */
 146       NEXT_PASS (pass_build_alias);
 147       NEXT_PASS (pass_return_slot);
 148       NEXT_PASS (pass_fre);
 149       NEXT_PASS (pass_copy_prop);
 150       NEXT_PASS (pass_merge_phi);
 151       NEXT_PASS (pass_vrp);
 152       NEXT_PASS (pass_dce);
 153       NEXT_PASS (pass_call_cdce);
 154       NEXT_PASS (pass_cselim);
 155       NEXT_PASS (pass_tree_ifcombine);
 156       NEXT_PASS (pass_phiopt);
 157       NEXT_PASS (pass_tail_recursion);
 158       NEXT_PASS (pass_ch);
 159       NEXT_PASS (pass_stdarg);
 160       NEXT_PASS (pass_lower_complex);
 161       NEXT_PASS (pass_sra);
 162       NEXT_PASS (pass_rename_ssa_copies);
 163       /* The dom pass will also resolve all __builtin_constant_p calls
 164          that are still there to 0.  This has to be done after some
 165          propagations have already run, but before some more dead code
 166          is removed, and this place fits nicely.  Remember this when
 167          trying to move or duplicate pass_dominator somewhere earlier.  */
 168       NEXT_PASS (pass_dominator);
 169       /* The only const/copy propagation opportunities left after
 170          DOM should be due to degenerate PHI nodes.  So rather than
 171          run the full propagators, run a specialized pass which
 172          only examines PHIs to discover const/copy propagation
 173          opportunities.  */
 174       NEXT_PASS (pass_phi_only_cprop);
 175       NEXT_PASS (pass_dse);
 176       NEXT_PASS (pass_reassoc);
 177       NEXT_PASS (pass_dce);
 178       NEXT_PASS (pass_forwprop);
 179       NEXT_PASS (pass_phiopt);
 180       NEXT_PASS (pass_object_sizes);
 181       NEXT_PASS (pass_strlen);
 182       NEXT_PASS (pass_ccp);
 183       /* After CCP we rewrite no longer addressed locals into SSA
 184          form if possible.  */
 185       NEXT_PASS (pass_copy_prop);
 186       NEXT_PASS (pass_cse_sincos);
 187       NEXT_PASS (pass_optimize_bswap);
 188       NEXT_PASS (pass_split_crit_edges);
 189       NEXT_PASS (pass_pre);
 190       NEXT_PASS (pass_sink_code);
 191       NEXT_PASS (pass_asan);
 192       NEXT_PASS (pass_tsan);
 193       NEXT_PASS (pass_tree_loop);
 194       PUSH_INSERT_PASSES_WITHIN (pass_tree_loop)
 195           NEXT_PASS (pass_tree_loop_init);
 196           NEXT_PASS (pass_lim);
 197           NEXT_PASS (pass_copy_prop);
 198           NEXT_PASS (pass_dce_loop);
 199           NEXT_PASS (pass_tree_unswitch);
 200           NEXT_PASS (pass_scev_cprop);
 201           NEXT_PASS (pass_record_bounds);
 202           NEXT_PASS (pass_check_data_deps);
 203           NEXT_PASS (pass_loop_distribution);
 204           NEXT_PASS (pass_copy_prop);
 205           NEXT_PASS (pass_graphite);
 206           PUSH_INSERT_PASSES_WITHIN (pass_graphite)
 207               NEXT_PASS (pass_graphite_transforms);
 208               NEXT_PASS (pass_lim);
 209               NEXT_PASS (pass_copy_prop);
 210               NEXT_PASS (pass_dce_loop);
 211           POP_INSERT_PASSES ()
 212           NEXT_PASS (pass_iv_canon);
 213           NEXT_PASS (pass_parallelize_loops);
 214           NEXT_PASS (pass_if_conversion);
 215           NEXT_PASS (pass_vectorize);
 216           PUSH_INSERT_PASSES_WITHIN (pass_vectorize)
 217               NEXT_PASS (pass_dce_loop);
 218           POP_INSERT_PASSES ()
 219           NEXT_PASS (pass_predcom);
 220           NEXT_PASS (pass_complete_unroll);
 221           NEXT_PASS (pass_slp_vectorize);
 222           NEXT_PASS (pass_loop_prefetch);
 223           NEXT_PASS (pass_iv_optimize);
 224           NEXT_PASS (pass_lim);
 225           NEXT_PASS (pass_tree_loop_done);
 226       POP_INSERT_PASSES ()
 227       NEXT_PASS (pass_lower_vector_ssa);
 228       NEXT_PASS (pass_cse_reciprocals);
 229       NEXT_PASS (pass_reassoc);
 230       NEXT_PASS (pass_strength_reduction);
 231       NEXT_PASS (pass_dominator);
 232       /* The only const/copy propagation opportunities left after
 233          DOM should be due to degenerate PHI nodes.  So rather than
 234          run the full propagators, run a specialized pass which
 235          only examines PHIs to discover const/copy propagation
 236          opportunities.  */
 237       NEXT_PASS (pass_phi_only_cprop);
 238       NEXT_PASS (pass_vrp);
 239       NEXT_PASS (pass_cd_dce);
 240       NEXT_PASS (pass_tracer);
 241       NEXT_PASS (pass_dse);
 242       NEXT_PASS (pass_forwprop);
 243       NEXT_PASS (pass_phiopt);
 244       NEXT_PASS (pass_fold_builtins);
 245       NEXT_PASS (pass_optimize_widening_mul);
 246       NEXT_PASS (pass_tail_calls);
 247       NEXT_PASS (pass_rename_ssa_copies);
 248       /* FIXME: If DCE is not run before checking for uninitialized uses,
 249          we may get false warnings (e.g., testsuite/gcc.dg/uninit-5.c).
 250          However, this also causes us to misdiagnose cases that should be
 251          real warnings (e.g., testsuite/gcc.dg/pr18501.c).
 252
 253          To fix the false positives in uninit-5.c, we would have to
 254          account for the predicates protecting the set and the use of each
 255          variable.  Using a representation like Gated Single Assignment
 256          may help.  */
 257       /* Split critical edges before late uninit warning to reduce the
 258          number of false positives from it.  */
 259       NEXT_PASS (pass_split_crit_edges);
 260       NEXT_PASS (pass_late_warn_uninitialized);
 261       NEXT_PASS (pass_uncprop);
 262       NEXT_PASS (pass_local_pure_const);
 263   POP_INSERT_PASSES ()
 264   NEXT_PASS (pass_all_optimizations_g);
 265   PUSH_INSERT_PASSES_WITHIN (pass_all_optimizations_g)
 266       NEXT_PASS (pass_remove_cgraph_callee_edges);
 267       NEXT_PASS (pass_strip_predict_hints);
 268       /* Lower remaining pieces of GIMPLE.  */
 269       NEXT_PASS (pass_lower_complex);
 270       NEXT_PASS (pass_lower_vector_ssa);
 271       /* Perform simple scalar cleanup which is constant/copy propagation.  */
 272       NEXT_PASS (pass_ccp);
 273       NEXT_PASS (pass_object_sizes);
 274       /* Fold remaining builtins.  */
 275       NEXT_PASS (pass_fold_builtins);
 276       /* Copy propagation also copy-propagates constants, this is necessary
 277          to forward object-size and builtin folding results properly.  */
 278       NEXT_PASS (pass_copy_prop);
 279       NEXT_PASS (pass_dce);
 280       NEXT_PASS (pass_asan);
 281       NEXT_PASS (pass_tsan);
 282       NEXT_PASS (pass_rename_ssa_copies);
 283       /* ???  We do want some kind of loop invariant motion, but we possibly
 284          need to adjust LIM to be more friendly towards preserving accurate
 285          debug information here.  */
 286       /* Split critical edges before late uninit warning to reduce the
 287          number of false positives from it.  */
 288       NEXT_PASS (pass_split_crit_edges);
 289       NEXT_PASS (pass_late_warn_uninitialized);
 290       NEXT_PASS (pass_uncprop);
 291       NEXT_PASS (pass_local_pure_const);
 292   POP_INSERT_PASSES ()
 293   NEXT_PASS (pass_tm_init);
 294   PUSH_INSERT_PASSES_WITHIN (pass_tm_init)
 295       NEXT_PASS (pass_tm_mark);
 296       NEXT_PASS (pass_tm_memopt);
 297       NEXT_PASS (pass_tm_edges);
 298   POP_INSERT_PASSES ()
 299   NEXT_PASS (pass_vtable_verify);
 300   NEXT_PASS (pass_lower_vector);
 301   NEXT_PASS (pass_lower_complex_O0);
 302   NEXT_PASS (pass_asan_O0);
 303   NEXT_PASS (pass_tsan_O0);
 304   NEXT_PASS (pass_cleanup_eh);
 305   NEXT_PASS (pass_lower_resx);
 306   NEXT_PASS (pass_nrv);
 307   NEXT_PASS (pass_cleanup_cfg_post_optimizing);
 308   NEXT_PASS (pass_warn_function_noreturn);
 309
 310   NEXT_PASS (pass_expand);
 311
 312   NEXT_PASS (pass_rest_of_compilation);
 313   PUSH_INSERT_PASSES_WITHIN (pass_rest_of_compilation)
 314       NEXT_PASS (pass_instantiate_virtual_regs);
 315       NEXT_PASS (pass_into_cfg_layout_mode);
 316       NEXT_PASS (pass_jump);
 317       NEXT_PASS (pass_lower_subreg);
 318       NEXT_PASS (pass_df_initialize_opt);
 319       NEXT_PASS (pass_cse);
 320       NEXT_PASS (pass_rtl_fwprop);
 321       NEXT_PASS (pass_rtl_cprop);
 322       NEXT_PASS (pass_rtl_pre);
 323       NEXT_PASS (pass_rtl_hoist);
 324       NEXT_PASS (pass_rtl_cprop);
 325       NEXT_PASS (pass_rtl_store_motion);
 326       NEXT_PASS (pass_cse_after_global_opts);
 327       NEXT_PASS (pass_rtl_ifcvt);
 328       NEXT_PASS (pass_reginfo_init);
 329       /* Perform loop optimizations.  It might be better to do them a bit
 330          sooner, but we want the profile feedback to work more
 331          efficiently.  */
 332       NEXT_PASS (pass_loop2);
 333       PUSH_INSERT_PASSES_WITHIN (pass_loop2)
 334           NEXT_PASS (pass_rtl_loop_init);
 335           NEXT_PASS (pass_rtl_move_loop_invariants);
 336           NEXT_PASS (pass_rtl_unswitch);
 337           NEXT_PASS (pass_rtl_unroll_and_peel_loops);
 338           NEXT_PASS (pass_rtl_doloop);
 339           NEXT_PASS (pass_rtl_loop_done);
 340           TERMINATE_PASS_LIST ()
 341       POP_INSERT_PASSES ()
 342       NEXT_PASS (pass_web);
 343       NEXT_PASS (pass_rtl_cprop);
 344       NEXT_PASS (pass_cse2);
 345       NEXT_PASS (pass_rtl_dse1);
 346       NEXT_PASS (pass_rtl_fwprop_addr);
 347       NEXT_PASS (pass_inc_dec);
 348       NEXT_PASS (pass_initialize_regs);
 349       NEXT_PASS (pass_ud_rtl_dce);
 350       NEXT_PASS (pass_combine);
 351       NEXT_PASS (pass_if_after_combine);
 352       NEXT_PASS (pass_partition_blocks);
 353       NEXT_PASS (pass_regmove);
 354       NEXT_PASS (pass_outof_cfg_layout_mode);
 355       NEXT_PASS (pass_split_all_insns);
 356       NEXT_PASS (pass_lower_subreg2);
 357       NEXT_PASS (pass_df_initialize_no_opt);
 358       NEXT_PASS (pass_stack_ptr_mod);
 359       NEXT_PASS (pass_mode_switching);
 360       NEXT_PASS (pass_match_asm_constraints);
 361       NEXT_PASS (pass_sms);
 362       NEXT_PASS (pass_sched);
 363       NEXT_PASS (pass_ira);
 364       NEXT_PASS (pass_reload);
 365       NEXT_PASS (pass_postreload);
 366       PUSH_INSERT_PASSES_WITHIN (pass_postreload)
 367           NEXT_PASS (pass_postreload_cse);
 368           NEXT_PASS (pass_gcse2);
 369           NEXT_PASS (pass_split_after_reload);
 370           NEXT_PASS (pass_ree);
 371           NEXT_PASS (pass_compare_elim_after_reload);
 372           NEXT_PASS (pass_branch_target_load_optimize1);
 373           NEXT_PASS (pass_thread_prologue_and_epilogue);
 374           NEXT_PASS (pass_rtl_dse2);
 375           NEXT_PASS (pass_stack_adjustments);
 376           NEXT_PASS (pass_jump2);
 377           NEXT_PASS (pass_peephole2);
 378           NEXT_PASS (pass_if_after_reload);
 379           NEXT_PASS (pass_regrename);
 380           NEXT_PASS (pass_cprop_hardreg);
 381           NEXT_PASS (pass_fast_rtl_dce);
 382           NEXT_PASS (pass_reorder_blocks);
 383           NEXT_PASS (pass_branch_target_load_optimize2);
 384           NEXT_PASS (pass_leaf_regs);
 385           NEXT_PASS (pass_split_before_sched2);
 386           NEXT_PASS (pass_sched2);
 387           NEXT_PASS (pass_stack_regs);
 388           PUSH_INSERT_PASSES_WITHIN (pass_stack_regs)
 389               NEXT_PASS (pass_split_before_regstack);
 390               NEXT_PASS (pass_stack_regs_run);
 391           POP_INSERT_PASSES ()
 392           NEXT_PASS (pass_compute_alignments);
 393           NEXT_PASS (pass_duplicate_computed_gotos);
 394           NEXT_PASS (pass_variable_tracking);
 395           NEXT_PASS (pass_free_cfg);
 396           NEXT_PASS (pass_machine_reorg);
 397           NEXT_PASS (pass_cleanup_barriers);
 398           NEXT_PASS (pass_delay_slots);
 399           NEXT_PASS (pass_split_for_shorten_branches);
 400           NEXT_PASS (pass_convert_to_eh_region_ranges);
 401           NEXT_PASS (pass_shorten_branches);
 402           NEXT_PASS (pass_set_nothrow_function_flags);
 403           NEXT_PASS (pass_dwarf2_frame);
 404           NEXT_PASS (pass_final);
 405       POP_INSERT_PASSES ()
 406       NEXT_PASS (pass_df_finish);
 407   POP_INSERT_PASSES ()
 408   NEXT_PASS (pass_clean_state);
 409   TERMINATE_PASS_LIST ()