contrib/gcc-5.0/gcc/passes.def

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