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