gcc/passes.def

   1 /* Description of pass structure
   2    Copyright (C) 1987-2014 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_ubsan);
  59       NEXT_PASS (pass_early_warn_uninitialized);
  60       NEXT_PASS (pass_rebuild_cgraph_edges);
  61       NEXT_PASS (pass_inline_parameters);
  62       NEXT_PASS (pass_early_inline);
  63       NEXT_PASS (pass_all_early_optimizations);
  64       PUSH_INSERT_PASSES_WITHIN (pass_all_early_optimizations)
  65           NEXT_PASS (pass_remove_cgraph_callee_edges);
  66           NEXT_PASS (pass_rename_ssa_copies);
  67           NEXT_PASS (pass_ccp);
  68           /* After CCP we rewrite no longer addressed locals into SSA
  69              form if possible.  */
  70           NEXT_PASS (pass_forwprop);
  71           NEXT_PASS (pass_sra_early);
  72           /* pass_build_ealias is a dummy pass that ensures that we
  73              execute TODO_rebuild_alias at this point.  */
  74           NEXT_PASS (pass_build_ealias);
  75           NEXT_PASS (pass_fre);
  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   /* Comdat privatization come last, as direct references to comdat local
 113      symbols are not allowed outside of the comdat group.  Privatizing early
 114      would result in missed optimizations due to this restriction.  */
 115   NEXT_PASS (pass_ipa_comdats);
 116   TERMINATE_PASS_LIST ()
 117
 118   /* Simple IPA passes executed after the regular passes.  In WHOPR mode the
 119      passes are executed after partitioning and thus see just parts of the
 120      compiled unit.  */
 121   INSERT_PASSES_AFTER (all_late_ipa_passes)
 122   NEXT_PASS (pass_ipa_pta);
 123   NEXT_PASS (pass_omp_simd_clone);
 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_fixup_cfg);
 130   NEXT_PASS (pass_lower_eh_dispatch);
 131   NEXT_PASS (pass_all_optimizations);
 132   PUSH_INSERT_PASSES_WITHIN (pass_all_optimizations)
 133       NEXT_PASS (pass_remove_cgraph_callee_edges);
 134       /* Initial scalar cleanups before alias computation.
 135          They ensure memory accesses are not indirect wherever possible.  */
 136       NEXT_PASS (pass_strip_predict_hints);
 137       NEXT_PASS (pass_rename_ssa_copies);
 138       NEXT_PASS (pass_ccp);
 139       /* After CCP we rewrite no longer addressed locals into SSA
 140          form if possible.  */
 141       NEXT_PASS (pass_copy_prop);
 142       NEXT_PASS (pass_complete_unrolli);
 143       NEXT_PASS (pass_phiprop);
 144       NEXT_PASS (pass_forwprop);
 145       NEXT_PASS (pass_object_sizes);
 146       /* pass_build_alias is a dummy pass that ensures that we
 147          execute TODO_rebuild_alias at this point.  */
 148       NEXT_PASS (pass_build_alias);
 149       NEXT_PASS (pass_return_slot);
 150       NEXT_PASS (pass_fre);
 151       NEXT_PASS (pass_merge_phi);
 152       NEXT_PASS (pass_vrp);
 153       NEXT_PASS (pass_dce);
 154       NEXT_PASS (pass_call_cdce);
 155       NEXT_PASS (pass_cselim);
 156       NEXT_PASS (pass_copy_prop);
 157       NEXT_PASS (pass_tree_ifcombine);
 158       NEXT_PASS (pass_phiopt);
 159       NEXT_PASS (pass_tail_recursion);
 160       NEXT_PASS (pass_ch);
 161       NEXT_PASS (pass_stdarg);
 162       NEXT_PASS (pass_lower_complex);
 163       NEXT_PASS (pass_sra);
 164       NEXT_PASS (pass_rename_ssa_copies);
 165       /* The dom pass will also resolve all __builtin_constant_p calls
 166          that are still there to 0.  This has to be done after some
 167          propagations have already run, but before some more dead code
 168          is removed, and this place fits nicely.  Remember this when
 169          trying to move or duplicate pass_dominator somewhere earlier.  */
 170       NEXT_PASS (pass_dominator);
 171       /* At this point the majority of const/copy propagations
 172          are exposed.  Go ahead and identify paths that should never
 173          be executed in a conforming program and isolate those paths.
 174
 175          This will expose more degenerate PHIs in the main path and
 176          expose more PRE/DOM optimization opportunities.  */
 177       NEXT_PASS (pass_isolate_erroneous_paths);
 178       /* The only const/copy propagation opportunities left after
 179          DOM and erroneous path isolation should be due to degenerate PHI nodes.
 180          So rather than run the full propagators, run a specialized pass which
 181          only examines PHIs to discover const/copy propagation
 182          opportunities.  */
 183       NEXT_PASS (pass_phi_only_cprop);
 184       NEXT_PASS (pass_dse);
 185       NEXT_PASS (pass_reassoc);
 186       NEXT_PASS (pass_dce);
 187       NEXT_PASS (pass_forwprop);
 188       NEXT_PASS (pass_phiopt);
 189       NEXT_PASS (pass_strlen);
 190       NEXT_PASS (pass_ccp);
 191       /* After CCP we rewrite no longer addressed locals into SSA
 192          form if possible.  */
 193       NEXT_PASS (pass_copy_prop);
 194       NEXT_PASS (pass_cse_sincos);
 195       NEXT_PASS (pass_optimize_bswap);
 196       NEXT_PASS (pass_split_crit_edges);
 197       NEXT_PASS (pass_pre);
 198       NEXT_PASS (pass_sink_code);
 199       NEXT_PASS (pass_asan);
 200       NEXT_PASS (pass_tsan);
 201       NEXT_PASS (pass_tree_loop);
 202       PUSH_INSERT_PASSES_WITHIN (pass_tree_loop)
 203           NEXT_PASS (pass_tree_loop_init);
 204           NEXT_PASS (pass_lim);
 205           NEXT_PASS (pass_copy_prop);
 206           NEXT_PASS (pass_dce_loop);
 207           NEXT_PASS (pass_tree_unswitch);
 208           NEXT_PASS (pass_scev_cprop);
 209           NEXT_PASS (pass_record_bounds);
 210           NEXT_PASS (pass_check_data_deps);
 211           NEXT_PASS (pass_loop_distribution);
 212           NEXT_PASS (pass_copy_prop);
 213           NEXT_PASS (pass_graphite);
 214           PUSH_INSERT_PASSES_WITHIN (pass_graphite)
 215               NEXT_PASS (pass_graphite_transforms);
 216               NEXT_PASS (pass_lim);
 217               NEXT_PASS (pass_copy_prop);
 218               NEXT_PASS (pass_dce_loop);
 219           POP_INSERT_PASSES ()
 220           NEXT_PASS (pass_iv_canon);
 221           NEXT_PASS (pass_parallelize_loops);
 222           NEXT_PASS (pass_if_conversion);
 223           /* pass_vectorize must immediately follow pass_if_conversion.
 224              Please do not add any other passes in between.  */
 225           NEXT_PASS (pass_vectorize);
 226           PUSH_INSERT_PASSES_WITHIN (pass_vectorize)
 227               NEXT_PASS (pass_dce_loop);
 228           POP_INSERT_PASSES ()
 229           NEXT_PASS (pass_predcom);
 230           NEXT_PASS (pass_complete_unroll);
 231           NEXT_PASS (pass_slp_vectorize);
 232           NEXT_PASS (pass_loop_prefetch);
 233           NEXT_PASS (pass_iv_optimize);
 234           NEXT_PASS (pass_lim);
 235           NEXT_PASS (pass_tree_loop_done);
 236       POP_INSERT_PASSES ()
 237       NEXT_PASS (pass_lower_vector_ssa);
 238       NEXT_PASS (pass_cse_reciprocals);
 239       NEXT_PASS (pass_reassoc);
 240       NEXT_PASS (pass_strength_reduction);
 241       NEXT_PASS (pass_dominator);
 242       NEXT_PASS (pass_vrp);
 243       /* The only const/copy propagation opportunities left after
 244          DOM and VRP should be due to degenerate PHI nodes.  So rather than
 245          run the full propagators, run a specialized pass which
 246          only examines PHIs to discover const/copy propagation
 247          opportunities.  */
 248       NEXT_PASS (pass_phi_only_cprop);
 249       NEXT_PASS (pass_cd_dce);
 250       NEXT_PASS (pass_tracer);
 251       NEXT_PASS (pass_dse);
 252       NEXT_PASS (pass_forwprop);
 253       NEXT_PASS (pass_phiopt);
 254       NEXT_PASS (pass_fold_builtins);
 255       NEXT_PASS (pass_optimize_widening_mul);
 256       NEXT_PASS (pass_tail_calls);
 257       NEXT_PASS (pass_rename_ssa_copies);
 258       /* FIXME: If DCE is not run before checking for uninitialized uses,
 259          we may get false warnings (e.g., testsuite/gcc.dg/uninit-5.c).
 260          However, this also causes us to misdiagnose cases that should be
 261          real warnings (e.g., testsuite/gcc.dg/pr18501.c).
 262
 263          To fix the false positives in uninit-5.c, we would have to
 264          account for the predicates protecting the set and the use of each
 265          variable.  Using a representation like Gated Single Assignment
 266          may help.  */
 267       /* Split critical edges before late uninit warning to reduce the
 268          number of false positives from it.  */
 269       NEXT_PASS (pass_split_crit_edges);
 270       NEXT_PASS (pass_late_warn_uninitialized);
 271       NEXT_PASS (pass_uncprop);
 272       NEXT_PASS (pass_local_pure_const);
 273   POP_INSERT_PASSES ()
 274   NEXT_PASS (pass_all_optimizations_g);
 275   PUSH_INSERT_PASSES_WITHIN (pass_all_optimizations_g)
 276       NEXT_PASS (pass_remove_cgraph_callee_edges);
 277       NEXT_PASS (pass_strip_predict_hints);
 278       /* Lower remaining pieces of GIMPLE.  */
 279       NEXT_PASS (pass_lower_complex);
 280       NEXT_PASS (pass_lower_vector_ssa);
 281       /* Perform simple scalar cleanup which is constant/copy propagation.  */
 282       NEXT_PASS (pass_ccp);
 283       NEXT_PASS (pass_object_sizes);
 284       /* Fold remaining builtins.  */
 285       NEXT_PASS (pass_fold_builtins);
 286       /* Copy propagation also copy-propagates constants, this is necessary
 287          to forward object-size and builtin folding results properly.  */
 288       NEXT_PASS (pass_copy_prop);
 289       NEXT_PASS (pass_dce);
 290       NEXT_PASS (pass_asan);
 291       NEXT_PASS (pass_tsan);
 292       NEXT_PASS (pass_rename_ssa_copies);
 293       /* ???  We do want some kind of loop invariant motion, but we possibly
 294          need to adjust LIM to be more friendly towards preserving accurate
 295          debug information here.  */
 296       /* Split critical edges before late uninit warning to reduce the
 297          number of false positives from it.  */
 298       NEXT_PASS (pass_split_crit_edges);
 299       NEXT_PASS (pass_late_warn_uninitialized);
 300       NEXT_PASS (pass_uncprop);
 301       NEXT_PASS (pass_local_pure_const);
 302   POP_INSERT_PASSES ()
 303   NEXT_PASS (pass_tm_init);
 304   PUSH_INSERT_PASSES_WITHIN (pass_tm_init)
 305       NEXT_PASS (pass_tm_mark);
 306       NEXT_PASS (pass_tm_memopt);
 307       NEXT_PASS (pass_tm_edges);
 308   POP_INSERT_PASSES ()
 309   NEXT_PASS (pass_vtable_verify);
 310   NEXT_PASS (pass_lower_vector);
 311   NEXT_PASS (pass_lower_complex_O0);
 312   NEXT_PASS (pass_asan_O0);
 313   NEXT_PASS (pass_tsan_O0);
 314   NEXT_PASS (pass_sanopt);
 315   NEXT_PASS (pass_cleanup_eh);
 316   NEXT_PASS (pass_lower_resx);
 317   NEXT_PASS (pass_nrv);
 318   NEXT_PASS (pass_cleanup_cfg_post_optimizing);
 319   NEXT_PASS (pass_warn_function_noreturn);
 320
 321   NEXT_PASS (pass_expand);
 322
 323   NEXT_PASS (pass_rest_of_compilation);
 324   PUSH_INSERT_PASSES_WITHIN (pass_rest_of_compilation)
 325       NEXT_PASS (pass_instantiate_virtual_regs);
 326       NEXT_PASS (pass_into_cfg_layout_mode);
 327       NEXT_PASS (pass_jump);
 328       NEXT_PASS (pass_lower_subreg);
 329       NEXT_PASS (pass_df_initialize_opt);
 330       NEXT_PASS (pass_cse);
 331       NEXT_PASS (pass_rtl_fwprop);
 332       NEXT_PASS (pass_rtl_cprop);
 333       NEXT_PASS (pass_rtl_pre);
 334       NEXT_PASS (pass_rtl_hoist);
 335       NEXT_PASS (pass_rtl_cprop);
 336       NEXT_PASS (pass_rtl_store_motion);
 337       NEXT_PASS (pass_cse_after_global_opts);
 338       NEXT_PASS (pass_rtl_ifcvt);
 339       NEXT_PASS (pass_reginfo_init);
 340       /* Perform loop optimizations.  It might be better to do them a bit
 341          sooner, but we want the profile feedback to work more
 342          efficiently.  */
 343       NEXT_PASS (pass_loop2);
 344       PUSH_INSERT_PASSES_WITHIN (pass_loop2)
 345           NEXT_PASS (pass_rtl_loop_init);
 346           NEXT_PASS (pass_rtl_move_loop_invariants);
 347           NEXT_PASS (pass_rtl_unroll_and_peel_loops);
 348           NEXT_PASS (pass_rtl_doloop);
 349           NEXT_PASS (pass_rtl_loop_done);
 350           TERMINATE_PASS_LIST ()
 351       POP_INSERT_PASSES ()
 352       NEXT_PASS (pass_web);
 353       NEXT_PASS (pass_rtl_cprop);
 354       NEXT_PASS (pass_cse2);
 355       NEXT_PASS (pass_rtl_dse1);
 356       NEXT_PASS (pass_rtl_fwprop_addr);
 357       NEXT_PASS (pass_inc_dec);
 358       NEXT_PASS (pass_initialize_regs);
 359       NEXT_PASS (pass_ud_rtl_dce);
 360       NEXT_PASS (pass_combine);
 361       NEXT_PASS (pass_if_after_combine);
 362       NEXT_PASS (pass_partition_blocks);
 363       NEXT_PASS (pass_outof_cfg_layout_mode);
 364       NEXT_PASS (pass_split_all_insns);
 365       NEXT_PASS (pass_lower_subreg2);
 366       NEXT_PASS (pass_df_initialize_no_opt);
 367       NEXT_PASS (pass_stack_ptr_mod);
 368       NEXT_PASS (pass_mode_switching);
 369       NEXT_PASS (pass_match_asm_constraints);
 370       NEXT_PASS (pass_sms);
 371       NEXT_PASS (pass_live_range_shrinkage);
 372       NEXT_PASS (pass_sched);
 373       NEXT_PASS (pass_ira);
 374       NEXT_PASS (pass_reload);
 375       NEXT_PASS (pass_postreload);
 376       PUSH_INSERT_PASSES_WITHIN (pass_postreload)
 377           NEXT_PASS (pass_postreload_cse);
 378           NEXT_PASS (pass_gcse2);
 379           NEXT_PASS (pass_split_after_reload);
 380           NEXT_PASS (pass_ree);
 381           NEXT_PASS (pass_compare_elim_after_reload);
 382           NEXT_PASS (pass_branch_target_load_optimize1);
 383           NEXT_PASS (pass_thread_prologue_and_epilogue);
 384           NEXT_PASS (pass_rtl_dse2);
 385           NEXT_PASS (pass_stack_adjustments);
 386           NEXT_PASS (pass_jump2);
 387           NEXT_PASS (pass_peephole2);
 388           NEXT_PASS (pass_if_after_reload);
 389           NEXT_PASS (pass_regrename);
 390           NEXT_PASS (pass_cprop_hardreg);
 391           NEXT_PASS (pass_fast_rtl_dce);
 392           NEXT_PASS (pass_duplicate_computed_gotos);
 393           NEXT_PASS (pass_reorder_blocks);
 394           NEXT_PASS (pass_branch_target_load_optimize2);
 395           NEXT_PASS (pass_leaf_regs);
 396           NEXT_PASS (pass_split_before_sched2);
 397           NEXT_PASS (pass_sched2);
 398           NEXT_PASS (pass_stack_regs);
 399           PUSH_INSERT_PASSES_WITHIN (pass_stack_regs)
 400               NEXT_PASS (pass_split_before_regstack);
 401               NEXT_PASS (pass_stack_regs_run);
 402           POP_INSERT_PASSES ()
 403           NEXT_PASS (pass_compute_alignments);
 404           NEXT_PASS (pass_variable_tracking);
 405           NEXT_PASS (pass_free_cfg);
 406           NEXT_PASS (pass_machine_reorg);
 407           NEXT_PASS (pass_cleanup_barriers);
 408           NEXT_PASS (pass_delay_slots);
 409           NEXT_PASS (pass_split_for_shorten_branches);
 410           NEXT_PASS (pass_convert_to_eh_region_ranges);
 411           NEXT_PASS (pass_shorten_branches);
 412           NEXT_PASS (pass_set_nothrow_function_flags);
 413           NEXT_PASS (pass_dwarf2_frame);
 414           NEXT_PASS (pass_final);
 415       POP_INSERT_PASSES ()
 416       NEXT_PASS (pass_df_finish);
 417   POP_INSERT_PASSES ()
 418   NEXT_PASS (pass_clean_state);
 419   TERMINATE_PASS_LIST ()