gcc/passes.c

   1 /* Top level of GCC compilers (cc1, cc1plus, etc.)
   2    Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
  20 02110-1301, USA.  */
  21
  22 /* This is the top level of cc1/c++.
  23    It parses command args, opens files, invokes the various passes
  24    in the proper order, and counts the time used by each.
  25    Error messages and low-level interface to malloc also handled here.  */
  26
  27 #include "config.h"
  28 #undef FLOAT /* This is for hpux. They should change hpux.  */
  29 #undef FFS  /* Some systems define this in param.h.  */
  30 #include "system.h"
  31 #include "coretypes.h"
  32 #include "tm.h"
  33 #include <signal.h>
  34
  35 #ifdef HAVE_SYS_RESOURCE_H
  36 # include <sys/resource.h>
  37 #endif
  38
  39 #ifdef HAVE_SYS_TIMES_H
  40 # include <sys/times.h>
  41 #endif
  42
  43 #include "line-map.h"
  44 #include "input.h"
  45 #include "tree.h"
  46 #include "rtl.h"
  47 #include "tm_p.h"
  48 #include "flags.h"
  49 #include "insn-attr.h"
  50 #include "insn-config.h"
  51 #include "insn-flags.h"
  52 #include "hard-reg-set.h"
  53 #include "recog.h"
  54 #include "output.h"
  55 #include "except.h"
  56 #include "function.h"
  57 #include "toplev.h"
  58 #include "expr.h"
  59 #include "basic-block.h"
  60 #include "intl.h"
  61 #include "ggc.h"
  62 #include "graph.h"
  63 #include "regs.h"
  64 #include "timevar.h"
  65 #include "diagnostic.h"
  66 #include "params.h"
  67 #include "reload.h"
  68 #include "dwarf2asm.h"
  69 #include "integrate.h"
  70 #include "real.h"
  71 #include "debug.h"
  72 #include "target.h"
  73 #include "langhooks.h"
  74 #include "cfglayout.h"
  75 #include "cfgloop.h"
  76 #include "hosthooks.h"
  77 #include "cgraph.h"
  78 #include "opts.h"
  79 #include "coverage.h"
  80 #include "value-prof.h"
  81 #include "tree-inline.h"
  82 #include "tree-flow.h"
  83 #include "tree-pass.h"
  84 #include "tree-dump.h"
  85
  86 #if defined (DWARF2_UNWIND_INFO) || defined (DWARF2_DEBUGGING_INFO)
  87 #include "dwarf2out.h"
  88 #endif
  89
  90 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
  91 #include "dbxout.h"
  92 #endif
  93
  94 #ifdef SDB_DEBUGGING_INFO
  95 #include "sdbout.h"
  96 #endif
  97
  98 #ifdef XCOFF_DEBUGGING_INFO
  99 #include "xcoffout.h"           /* Needed for external data
 100                                    declarations for e.g. AIX 4.x.  */
 101 #endif
 102
 103 /* Global variables used to communicate with passes.  */
 104 int dump_flags;
 105 bool in_gimple_form;
 106
 107
 108 /* This is called from various places for FUNCTION_DECL, VAR_DECL,
 109    and TYPE_DECL nodes.
 110
 111    This does nothing for local (non-static) variables, unless the
 112    variable is a register variable with DECL_ASSEMBLER_NAME set.  In
 113    that case, or if the variable is not an automatic, it sets up the
 114    RTL and outputs any assembler code (label definition, storage
 115    allocation and initialization).
 116
 117    DECL is the declaration.  TOP_LEVEL is nonzero
 118    if this declaration is not within a function.  */
 119
 120 void
 121 rest_of_decl_compilation (tree decl,
 122                           int top_level,
 123                           int at_end)
 124 {
 125   /* We deferred calling assemble_alias so that we could collect
 126      other attributes such as visibility.  Emit the alias now.  */
 127   {
 128     tree alias;
 129     alias = lookup_attribute ("alias", DECL_ATTRIBUTES (decl));
 130     if (alias)
 131       {
 132         alias = TREE_VALUE (TREE_VALUE (alias));
 133         alias = get_identifier (TREE_STRING_POINTER (alias));
 134         assemble_alias (decl, alias);
 135       }
 136   }
 137
 138   /* Can't defer this, because it needs to happen before any
 139      later function definitions are processed.  */
 140   if (DECL_ASSEMBLER_NAME_SET_P (decl) && DECL_REGISTER (decl))
 141     make_decl_rtl (decl);
 142
 143   /* Forward declarations for nested functions are not "external",
 144      but we need to treat them as if they were.  */
 145   if (TREE_STATIC (decl) || DECL_EXTERNAL (decl)
 146       || TREE_CODE (decl) == FUNCTION_DECL)
 147     {
 148       timevar_push (TV_VARCONST);
 149
 150       /* Don't output anything when a tentative file-scope definition
 151          is seen.  But at end of compilation, do output code for them.
 152
 153          We do output all variables when unit-at-a-time is active and rely on
 154          callgraph code to defer them except for forward declarations
 155          (see gcc.c-torture/compile/920624-1.c) */
 156       if ((at_end
 157            || !DECL_DEFER_OUTPUT (decl)
 158            || DECL_INITIAL (decl))
 159           && !DECL_EXTERNAL (decl))
 160         {
 161           if (flag_unit_at_a_time && !cgraph_global_info_ready
 162               && TREE_CODE (decl) != FUNCTION_DECL)
 163             cgraph_varpool_finalize_decl (decl);
 164           else
 165             assemble_variable (decl, top_level, at_end, 0);
 166         }
 167
 168 #ifdef ASM_FINISH_DECLARE_OBJECT
 169       if (decl == last_assemble_variable_decl)
 170         {
 171           ASM_FINISH_DECLARE_OBJECT (asm_out_file, decl,
 172                                      top_level, at_end);
 173         }
 174 #endif
 175
 176       timevar_pop (TV_VARCONST);
 177     }
 178   else if (TREE_CODE (decl) == TYPE_DECL)
 179     {
 180       timevar_push (TV_SYMOUT);
 181       debug_hooks->type_decl (decl, !top_level);
 182       timevar_pop (TV_SYMOUT);
 183     }
 184
 185   /* Let cgraph know about the existence of variables.  */
 186   if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl))
 187     cgraph_varpool_node (decl);
 188 }
 189
 190 /* Called after finishing a record, union or enumeral type.  */
 191
 192 void
 193 rest_of_type_compilation (tree type, int toplev)
 194 {
 195   /* Avoid confusing the debug information machinery when there are
 196      errors.  */
 197   if (errorcount != 0 || sorrycount != 0)
 198     return;
 199
 200   timevar_push (TV_SYMOUT);
 201   debug_hooks->type_decl (TYPE_STUB_DECL (type), !toplev);
 202   timevar_pop (TV_SYMOUT);
 203 }
 204
 205 \f
 206
 207 void
 208 finish_optimization_passes (void)
 209 {
 210   enum tree_dump_index i;
 211   struct dump_file_info *dfi;
 212   char *name;
 213
 214   timevar_push (TV_DUMP);
 215   if (profile_arc_flag || flag_test_coverage || flag_branch_probabilities)
 216     {
 217       dump_file = dump_begin (pass_branch_prob.static_pass_number, NULL);
 218       end_branch_prob ();
 219       if (dump_file)
 220         dump_end (pass_branch_prob.static_pass_number, dump_file);
 221     }
 222
 223   if (optimize > 0)
 224     {
 225       dump_file = dump_begin (pass_combine.static_pass_number, NULL);
 226       if (dump_file)
 227         {
 228           dump_combine_total_stats (dump_file);
 229           dump_end (pass_combine.static_pass_number, dump_file);
 230         }
 231     }
 232
 233   /* Do whatever is necessary to finish printing the graphs.  */
 234   if (graph_dump_format != no_graph)
 235     for (i = TDI_end; (dfi = get_dump_file_info (i)) != NULL; ++i)
 236       if (dump_initialized_p (i)
 237           && (dfi->flags & TDF_RTL) != 0
 238           && (name = get_dump_file_name (i)) != NULL)
 239         {
 240           finish_graph_dump_file (name);
 241           free (name);
 242         }
 243
 244   timevar_pop (TV_DUMP);
 245 }
 246
 247 static bool
 248 gate_rest_of_compilation (void)
 249 {
 250   /* Early return if there were errors.  We can run afoul of our
 251      consistency checks, and there's not really much point in fixing them.  */
 252   return !(rtl_dump_and_exit || flag_syntax_only || errorcount || sorrycount);
 253 }
 254
 255 struct tree_opt_pass pass_rest_of_compilation =
 256 {
 257   NULL,                                 /* name */
 258   gate_rest_of_compilation,             /* gate */
 259   NULL,                                 /* execute */
 260   NULL,                                 /* sub */
 261   NULL,                                 /* next */
 262   0,                                    /* static_pass_number */
 263   TV_REST_OF_COMPILATION,               /* tv_id */
 264   PROP_rtl,                             /* properties_required */
 265   0,                                    /* properties_provided */
 266   0,                                    /* properties_destroyed */
 267   0,                                    /* todo_flags_start */
 268   TODO_ggc_collect,                     /* todo_flags_finish */
 269   0                                     /* letter */
 270 };
 271
 272 static bool
 273 gate_postreload (void)
 274 {
 275   return reload_completed;
 276 }
 277
 278 struct tree_opt_pass pass_postreload =
 279 {
 280   NULL,                                 /* name */
 281   gate_postreload,                      /* gate */
 282   NULL,                                 /* execute */
 283   NULL,                                 /* sub */
 284   NULL,                                 /* next */
 285   0,                                    /* static_pass_number */
 286   0,                                    /* tv_id */
 287   PROP_rtl,                             /* properties_required */
 288   0,                                    /* properties_provided */
 289   0,                                    /* properties_destroyed */
 290   0,                                    /* todo_flags_start */
 291   TODO_ggc_collect,                     /* todo_flags_finish */
 292   0                                     /* letter */
 293 };
 294
 295
 296
 297 /* The root of the compilation pass tree, once constructed.  */
 298 struct tree_opt_pass *all_passes, *all_ipa_passes, *all_lowering_passes;
 299
 300 /* Iterate over the pass tree allocating dump file numbers.  We want
 301    to do this depth first, and independent of whether the pass is
 302    enabled or not.  */
 303
 304 static void
 305 register_one_dump_file (struct tree_opt_pass *pass, bool ipa, int n)
 306 {
 307   char *dot_name, *flag_name, *glob_name;
 308   char num[10];
 309
 310   /* See below in next_pass_1.  */
 311   num[0] = '\0';
 312   if (pass->static_pass_number != -1)
 313     sprintf (num, "%d", ((int) pass->static_pass_number < 0
 314                          ? 1 : pass->static_pass_number));
 315
 316   dot_name = concat (".", pass->name, num, NULL);
 317   if (ipa)
 318     {
 319       flag_name = concat ("ipa-", pass->name, num, NULL);
 320       glob_name = concat ("ipa-", pass->name, NULL);
 321       /* First IPA dump is cgraph that is dumped via separate channels.  */
 322       pass->static_pass_number = dump_register (dot_name, flag_name, glob_name,
 323                                                 TDF_IPA, n + 1, 0);
 324     }
 325   else if (pass->properties_provided & PROP_trees)
 326     {
 327       flag_name = concat ("tree-", pass->name, num, NULL);
 328       glob_name = concat ("tree-", pass->name, NULL);
 329       pass->static_pass_number = dump_register (dot_name, flag_name, glob_name,
 330                                                 TDF_TREE, n + TDI_tree_all, 0);
 331     }
 332   else
 333     {
 334       flag_name = concat ("rtl-", pass->name, num, NULL);
 335       glob_name = concat ("rtl-", pass->name, NULL);
 336       pass->static_pass_number = dump_register (dot_name, flag_name, glob_name,
 337                                                 TDF_RTL, n, pass->letter);
 338     }
 339 }
 340
 341 static int
 342 register_dump_files (struct tree_opt_pass *pass, bool ipa, int properties)
 343 {
 344   static int n = 0;
 345   do
 346     {
 347       int new_properties;
 348       int pass_number;
 349
 350       pass->properties_required = properties;
 351       new_properties =
 352         (properties | pass->properties_provided) & ~pass->properties_destroyed;
 353
 354       /* Reset the counter when we reach RTL-based passes.  */
 355       if ((new_properties ^ pass->properties_required) & PROP_rtl)
 356         n = 0;
 357
 358       pass_number = n;
 359       if (pass->name)
 360         n++;
 361
 362       if (pass->sub)
 363         new_properties = register_dump_files (pass->sub, false, new_properties);
 364
 365       /* If we have a gate, combine the properties that we could have with
 366          and without the pass being examined.  */
 367       if (pass->gate)
 368         properties &= new_properties;
 369       else
 370         properties = new_properties;
 371
 372       pass->properties_provided = properties;
 373       if (pass->name)
 374         register_one_dump_file (pass, ipa, pass_number);
 375
 376       pass = pass->next;
 377     }
 378   while (pass);
 379
 380   return properties;
 381 }
 382
 383 /* Add a pass to the pass list. Duplicate the pass if it's already
 384    in the list.  */
 385
 386 static struct tree_opt_pass **
 387 next_pass_1 (struct tree_opt_pass **list, struct tree_opt_pass *pass)
 388 {
 389
 390   /* A nonzero static_pass_number indicates that the
 391      pass is already in the list.  */
 392   if (pass->static_pass_number)
 393     {
 394       struct tree_opt_pass *new;
 395
 396       new = xmalloc (sizeof (*new));
 397       memcpy (new, pass, sizeof (*new));
 398
 399       /* Indicate to register_dump_files that this pass has duplicates,
 400          and so it should rename the dump file.  The first instance will
 401          be -1, and be number of duplicates = -static_pass_number - 1.
 402          Subsequent instances will be > 0 and just the duplicate number.  */
 403       if (pass->name)
 404         {
 405           pass->static_pass_number -= 1;
 406           new->static_pass_number = -pass->static_pass_number;
 407         }
 408
 409       *list = new;
 410     }
 411   else
 412     {
 413       pass->static_pass_number = -1;
 414       *list = pass;
 415     }
 416
 417   return &(*list)->next;
 418
 419 }
 420
 421 /* Construct the pass tree.  */
 422
 423 void
 424 init_optimization_passes (void)
 425 {
 426   struct tree_opt_pass **p;
 427
 428 #define NEXT_PASS(PASS)  (p = next_pass_1 (p, &PASS))
 429   /* Interprocedural optimization passes.  */
 430   p = &all_ipa_passes;
 431   NEXT_PASS (pass_early_ipa_inline);
 432   NEXT_PASS (pass_early_local_passes);
 433   NEXT_PASS (pass_ipa_inline);
 434   NEXT_PASS (pass_ipa_reference);
 435   NEXT_PASS (pass_ipa_pure_const);
 436   NEXT_PASS (pass_ipa_type_escape);
 437   *p = NULL;
 438
 439   /* All passes needed to lower the function into shape optimizers can operate
 440      on.  These passes are performed before interprocedural passes, unlike rest
 441      of local passes (all_passes).  */
 442   p = &all_lowering_passes;
 443   NEXT_PASS (pass_remove_useless_stmts);
 444   NEXT_PASS (pass_mudflap_1);
 445   NEXT_PASS (pass_lower_cf);
 446   NEXT_PASS (pass_lower_eh);
 447   NEXT_PASS (pass_build_cfg);
 448   NEXT_PASS (pass_lower_complex_O0);
 449   NEXT_PASS (pass_lower_vector);
 450   NEXT_PASS (pass_warn_function_return);
 451   NEXT_PASS (pass_early_tree_profile);
 452   *p = NULL;
 453
 454   p = &pass_early_local_passes.sub;
 455   NEXT_PASS (pass_tree_profile);
 456   NEXT_PASS (pass_cleanup_cfg);
 457   NEXT_PASS (pass_rebuild_cgraph_edges);
 458   *p = NULL;
 459
 460   p = &all_passes;
 461   NEXT_PASS (pass_fixup_cfg);
 462   NEXT_PASS (pass_init_datastructures);
 463   NEXT_PASS (pass_all_optimizations);
 464   NEXT_PASS (pass_warn_function_noreturn);
 465   NEXT_PASS (pass_mudflap_2);
 466   NEXT_PASS (pass_free_datastructures);
 467   NEXT_PASS (pass_free_cfg_annotations);
 468   NEXT_PASS (pass_expand);
 469   NEXT_PASS (pass_rest_of_compilation);
 470   NEXT_PASS (pass_clean_state);
 471   *p = NULL;
 472
 473   p = &pass_all_optimizations.sub;
 474   NEXT_PASS (pass_referenced_vars);
 475   NEXT_PASS (pass_create_structure_vars);
 476   NEXT_PASS (pass_build_ssa);
 477   NEXT_PASS (pass_may_alias);
 478   NEXT_PASS (pass_return_slot);
 479   NEXT_PASS (pass_rename_ssa_copies);
 480   NEXT_PASS (pass_early_warn_uninitialized);
 481   NEXT_PASS (pass_eliminate_useless_stores);
 482
 483   /* Initial scalar cleanups.  */
 484   NEXT_PASS (pass_ccp);
 485   NEXT_PASS (pass_fre);
 486   NEXT_PASS (pass_dce);
 487   NEXT_PASS (pass_forwprop);
 488   NEXT_PASS (pass_copy_prop);
 489   NEXT_PASS (pass_vrp);
 490   NEXT_PASS (pass_dce);
 491   NEXT_PASS (pass_merge_phi);
 492   NEXT_PASS (pass_dominator);
 493
 494   NEXT_PASS (pass_phiopt);
 495   NEXT_PASS (pass_may_alias);
 496   NEXT_PASS (pass_tail_recursion);
 497   NEXT_PASS (pass_profile);
 498   NEXT_PASS (pass_ch);
 499   NEXT_PASS (pass_stdarg);
 500   NEXT_PASS (pass_lower_complex);
 501   NEXT_PASS (pass_sra);
 502   /* FIXME: SRA may generate arbitrary gimple code, exposing new
 503      aliased and call-clobbered variables.  As mentioned below,
 504      pass_may_alias should be a TODO item.  */
 505   NEXT_PASS (pass_may_alias);
 506   NEXT_PASS (pass_rename_ssa_copies);
 507   NEXT_PASS (pass_dominator);
 508   NEXT_PASS (pass_copy_prop);
 509   NEXT_PASS (pass_dce);
 510   NEXT_PASS (pass_dse);
 511   NEXT_PASS (pass_may_alias);
 512   NEXT_PASS (pass_forwprop);
 513   NEXT_PASS (pass_phiopt);
 514   NEXT_PASS (pass_object_sizes);
 515   NEXT_PASS (pass_store_ccp);
 516   NEXT_PASS (pass_store_copy_prop);
 517   NEXT_PASS (pass_fold_builtins);
 518   /* FIXME: May alias should a TODO but for 4.0.0,
 519      we add may_alias right after fold builtins
 520      which can create arbitrary GIMPLE.  */
 521   NEXT_PASS (pass_may_alias);
 522   NEXT_PASS (pass_cse_reciprocals);
 523   NEXT_PASS (pass_split_crit_edges);
 524   NEXT_PASS (pass_reassoc);
 525   NEXT_PASS (pass_pre);
 526   NEXT_PASS (pass_sink_code);
 527   NEXT_PASS (pass_tree_loop);
 528   NEXT_PASS (pass_dominator);
 529   NEXT_PASS (pass_copy_prop);
 530   NEXT_PASS (pass_cd_dce);
 531
 532   /* FIXME: If DCE is not run before checking for uninitialized uses,
 533      we may get false warnings (e.g., testsuite/gcc.dg/uninit-5.c).
 534      However, this also causes us to misdiagnose cases that should be
 535      real warnings (e.g., testsuite/gcc.dg/pr18501.c).
 536
 537      To fix the false positives in uninit-5.c, we would have to
 538      account for the predicates protecting the set and the use of each
 539      variable.  Using a representation like Gated Single Assignment
 540      may help.  */
 541   NEXT_PASS (pass_late_warn_uninitialized);
 542   NEXT_PASS (pass_dse);
 543   NEXT_PASS (pass_forwprop);
 544   NEXT_PASS (pass_phiopt);
 545   NEXT_PASS (pass_tail_calls);
 546   NEXT_PASS (pass_rename_ssa_copies);
 547   NEXT_PASS (pass_uncprop);
 548   NEXT_PASS (pass_del_ssa);
 549   NEXT_PASS (pass_nrv);
 550   NEXT_PASS (pass_remove_useless_vars);
 551   NEXT_PASS (pass_mark_used_blocks);
 552   NEXT_PASS (pass_cleanup_cfg_post_optimizing);
 553   *p = NULL;
 554
 555   p = &pass_tree_loop.sub;
 556   NEXT_PASS (pass_tree_loop_init);
 557   NEXT_PASS (pass_copy_prop);
 558   NEXT_PASS (pass_lim);
 559   NEXT_PASS (pass_tree_unswitch);
 560   NEXT_PASS (pass_scev_cprop);
 561   NEXT_PASS (pass_empty_loop);
 562   NEXT_PASS (pass_record_bounds);
 563   NEXT_PASS (pass_linear_transform);
 564   NEXT_PASS (pass_iv_canon);
 565   NEXT_PASS (pass_if_conversion);
 566   NEXT_PASS (pass_vectorize);
 567   /* NEXT_PASS (pass_may_alias) cannot be done again because the
 568      vectorizer creates alias relations that are not supported by
 569      pass_may_alias.  */
 570   NEXT_PASS (pass_lower_vector_ssa);
 571   NEXT_PASS (pass_complete_unroll);
 572   NEXT_PASS (pass_iv_optimize);
 573   NEXT_PASS (pass_tree_loop_done);
 574   *p = NULL;
 575
 576   p = &pass_loop2.sub;
 577   NEXT_PASS (pass_rtl_loop_init);
 578   NEXT_PASS (pass_rtl_move_loop_invariants);
 579   NEXT_PASS (pass_rtl_unswitch);
 580   NEXT_PASS (pass_rtl_unroll_and_peel_loops);
 581   NEXT_PASS (pass_rtl_doloop);
 582   NEXT_PASS (pass_rtl_loop_done);
 583   *p = NULL;
 584
 585   p = &pass_rest_of_compilation.sub;
 586   NEXT_PASS (pass_remove_unnecessary_notes);
 587   NEXT_PASS (pass_init_function);
 588   NEXT_PASS (pass_jump);
 589   NEXT_PASS (pass_insn_locators_initialize);
 590   NEXT_PASS (pass_rtl_eh);
 591   NEXT_PASS (pass_initial_value_sets);
 592   NEXT_PASS (pass_unshare_all_rtl);
 593   NEXT_PASS (pass_instantiate_virtual_regs);
 594   NEXT_PASS (pass_jump2);
 595   NEXT_PASS (pass_cse);
 596   NEXT_PASS (pass_gcse);
 597   NEXT_PASS (pass_loop_optimize);
 598   NEXT_PASS (pass_jump_bypass);
 599   NEXT_PASS (pass_cfg);
 600   NEXT_PASS (pass_profiling);
 601   NEXT_PASS (pass_rtl_ifcvt);
 602   NEXT_PASS (pass_tracer);
 603   /* Perform loop optimizations.  It might be better to do them a bit
 604      sooner, but we want the profile feedback to work more
 605      efficiently.  */
 606   NEXT_PASS (pass_loop2);
 607   NEXT_PASS (pass_web);
 608   NEXT_PASS (pass_cse2);
 609   NEXT_PASS (pass_life);
 610   NEXT_PASS (pass_combine);
 611   NEXT_PASS (pass_if_after_combine);
 612   NEXT_PASS (pass_partition_blocks);
 613   NEXT_PASS (pass_regmove);
 614   NEXT_PASS (pass_split_all_insns);
 615   NEXT_PASS (pass_mode_switching);
 616   NEXT_PASS (pass_recompute_reg_usage);
 617   NEXT_PASS (pass_sms);
 618   NEXT_PASS (pass_sched);
 619   NEXT_PASS (pass_local_alloc);
 620   NEXT_PASS (pass_global_alloc);
 621   NEXT_PASS (pass_postreload);
 622   *p = NULL;
 623
 624   p = &pass_profiling.sub;
 625   NEXT_PASS (pass_branch_prob);
 626   NEXT_PASS (pass_value_profile_transformations);
 627   NEXT_PASS (pass_remove_death_notes);
 628   *p = NULL;
 629
 630   p = &pass_postreload.sub;
 631   NEXT_PASS (pass_postreload_cse);
 632   NEXT_PASS (pass_gcse2);
 633   NEXT_PASS (pass_flow2);
 634   NEXT_PASS (pass_stack_adjustments);
 635   NEXT_PASS (pass_peephole2);
 636   NEXT_PASS (pass_if_after_reload);
 637   NEXT_PASS (pass_regrename);
 638   NEXT_PASS (pass_reorder_blocks);
 639   NEXT_PASS (pass_branch_target_load_optimize);
 640   NEXT_PASS (pass_leaf_regs);
 641   NEXT_PASS (pass_sched2);
 642   NEXT_PASS (pass_split_before_regstack);
 643   NEXT_PASS (pass_stack_regs);
 644   NEXT_PASS (pass_compute_alignments);
 645   NEXT_PASS (pass_duplicate_computed_gotos);
 646   NEXT_PASS (pass_variable_tracking);
 647   NEXT_PASS (pass_free_cfg);
 648   NEXT_PASS (pass_machine_reorg);
 649   NEXT_PASS (pass_purge_lineno_notes);
 650   NEXT_PASS (pass_cleanup_barriers);
 651   NEXT_PASS (pass_delay_slots);
 652   NEXT_PASS (pass_split_for_shorten_branches);
 653   NEXT_PASS (pass_convert_to_eh_region_ranges);
 654   NEXT_PASS (pass_shorten_branches);
 655   NEXT_PASS (pass_set_nothrow_function_flags);
 656   NEXT_PASS (pass_final);
 657   *p = NULL;
 658
 659 #undef NEXT_PASS
 660
 661   /* Register the passes with the tree dump code.  */
 662   register_dump_files (all_lowering_passes, false, PROP_gimple_any);
 663   register_dump_files (all_passes, false, PROP_gimple_leh
 664                                           | PROP_cfg);
 665   register_dump_files (all_ipa_passes, true, PROP_gimple_leh
 666                                              | PROP_cfg);
 667 }
 668
 669 static unsigned int last_verified;
 670
 671 static void
 672 execute_todo (struct tree_opt_pass *pass, unsigned int flags, bool use_required)
 673 {
 674   int properties
 675     = use_required ? pass->properties_required : pass->properties_provided;
 676
 677 #if defined ENABLE_CHECKING
 678   if (need_ssa_update_p ())
 679     gcc_assert (flags & TODO_update_ssa_any);
 680 #endif
 681
 682   /* Always cleanup the CFG before doing anything else.  */
 683   if (flags & TODO_cleanup_cfg)
 684     {
 685       if (current_loops)
 686         cleanup_tree_cfg_loop ();
 687       else
 688         cleanup_tree_cfg ();
 689     }
 690
 691   if (flags & TODO_update_ssa_any)
 692     {
 693       unsigned update_flags = flags & TODO_update_ssa_any;
 694       update_ssa (update_flags);
 695     }
 696
 697   if ((flags & TODO_dump_func)
 698       && dump_file && current_function_decl)
 699     {
 700       if (properties & PROP_trees)
 701         dump_function_to_file (current_function_decl,
 702                                dump_file, dump_flags);
 703       else if (properties & PROP_cfg)
 704         print_rtl_with_bb (dump_file, get_insns ());
 705       else
 706         print_rtl (dump_file, get_insns ());
 707
 708       /* Flush the file.  If verification fails, we won't be able to
 709          close the file before aborting.  */
 710       fflush (dump_file);
 711     }
 712   if ((flags & TODO_dump_cgraph)
 713       && dump_file && !current_function_decl)
 714     {
 715       dump_cgraph (dump_file);
 716       /* Flush the file.  If verification fails, we won't be able to
 717          close the file before aborting.  */
 718       fflush (dump_file);
 719     }
 720
 721   if (flags & TODO_ggc_collect)
 722     {
 723       ggc_collect ();
 724     }
 725
 726 #if defined ENABLE_CHECKING
 727   if ((pass->properties_required & PROP_ssa)
 728       && !(pass->properties_destroyed & PROP_ssa))
 729     verify_ssa (true);
 730   if (flags & TODO_verify_flow)
 731     verify_flow_info ();
 732   if (flags & TODO_verify_stmts)
 733     verify_stmts ();
 734   if (flags & TODO_verify_loops)
 735     verify_loop_closed_ssa ();
 736 #endif
 737 }
 738
 739 static bool
 740 execute_one_pass (struct tree_opt_pass *pass)
 741 {
 742   unsigned int todo;
 743
 744   /* See if we're supposed to run this pass.  */
 745   if (pass->gate && !pass->gate ())
 746     return false;
 747
 748   /* Note that the folders should only create gimple expressions.
 749      This is a hack until the new folder is ready.  */
 750   in_gimple_form = (pass->properties_provided & PROP_trees) != 0;
 751
 752   /* Run pre-pass verification.  */
 753   todo = pass->todo_flags_start & ~last_verified;
 754   if (todo)
 755     execute_todo (pass, todo, true);
 756
 757   /* If a dump file name is present, open it if enabled.  */
 758   if (pass->static_pass_number != -1)
 759     {
 760       bool initializing_dump = !dump_initialized_p (pass->static_pass_number);
 761       dump_file_name = get_dump_file_name (pass->static_pass_number);
 762       dump_file = dump_begin (pass->static_pass_number, &dump_flags);
 763       if (dump_file && current_function_decl)
 764         {
 765           const char *dname, *aname;
 766           dname = lang_hooks.decl_printable_name (current_function_decl, 2);
 767           aname = (IDENTIFIER_POINTER
 768                    (DECL_ASSEMBLER_NAME (current_function_decl)));
 769           fprintf (dump_file, "\n;; Function %s (%s)%s\n\n", dname, aname,
 770              cfun->function_frequency == FUNCTION_FREQUENCY_HOT
 771              ? " (hot)"
 772              : cfun->function_frequency == FUNCTION_FREQUENCY_UNLIKELY_EXECUTED
 773              ? " (unlikely executed)"
 774              : "");
 775         }
 776
 777       if (initializing_dump
 778           && graph_dump_format != no_graph
 779           && (pass->properties_provided & (PROP_cfg | PROP_rtl))
 780               == (PROP_cfg | PROP_rtl))
 781         clean_graph_dump_file (dump_file_name);
 782     }
 783
 784   /* If a timevar is present, start it.  */
 785   if (pass->tv_id)
 786     timevar_push (pass->tv_id);
 787
 788   /* Do it!  */
 789   if (pass->execute)
 790     pass->execute ();
 791
 792   /* Stop timevar.  */
 793   if (pass->tv_id)
 794     timevar_pop (pass->tv_id);
 795
 796   /* Run post-pass cleanup and verification.  */
 797   todo = pass->todo_flags_finish;
 798   last_verified = todo & TODO_verify_all;
 799   if (todo)
 800     execute_todo (pass, todo, false);
 801
 802   /* Flush and close dump file.  */
 803   if (dump_file_name)
 804     {
 805       free ((char *) dump_file_name);
 806       dump_file_name = NULL;
 807     }
 808   if (dump_file)
 809     {
 810       dump_end (pass->static_pass_number, dump_file);
 811       dump_file = NULL;
 812     }
 813
 814   return true;
 815 }
 816
 817 void
 818 execute_pass_list (struct tree_opt_pass *pass)
 819 {
 820   do
 821     {
 822       if (execute_one_pass (pass) && pass->sub)
 823         execute_pass_list (pass->sub);
 824       pass = pass->next;
 825     }
 826   while (pass);
 827 }
 828
 829 /* Same as execute_pass_list but assume that subpasses of IPA passes
 830    are local passes.  */
 831 void
 832 execute_ipa_pass_list (struct tree_opt_pass *pass)
 833 {
 834   do
 835     {
 836       if (execute_one_pass (pass) && pass->sub)
 837         {
 838           struct cgraph_node *node;
 839           for (node = cgraph_nodes; node; node = node->next)
 840             if (node->analyzed)
 841               {
 842                 push_cfun (DECL_STRUCT_FUNCTION (node->decl));
 843                 current_function_decl = node->decl;
 844                 execute_pass_list (pass->sub);
 845                 free_dominance_info (CDI_DOMINATORS);
 846                 free_dominance_info (CDI_POST_DOMINATORS);
 847                 current_function_decl = NULL;
 848                 pop_cfun ();
 849                 ggc_collect ();
 850               }
 851         }
 852       pass = pass->next;
 853     }
 854   while (pass);
 855 }