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 (TREE_CODE (decl) != FUNCTION_DECL)
 162             cgraph_varpool_finalize_decl (decl);
 163           else
 164             assemble_variable (decl, top_level, at_end, 0);
 165         }
 166
 167 #ifdef ASM_FINISH_DECLARE_OBJECT
 168       if (decl == last_assemble_variable_decl)
 169         {
 170           ASM_FINISH_DECLARE_OBJECT (asm_out_file, decl,
 171                                      top_level, at_end);
 172         }
 173 #endif
 174
 175       timevar_pop (TV_VARCONST);
 176     }
 177   else if (TREE_CODE (decl) == TYPE_DECL
 178            /* Like in rest_of_type_compilation, avoid confusing the debug
 179               information machinery when there are errors.  */
 180            && !(sorrycount || errorcount))
 181     {
 182       timevar_push (TV_SYMOUT);
 183       debug_hooks->type_decl (decl, !top_level);
 184       timevar_pop (TV_SYMOUT);
 185     }
 186
 187   /* Let cgraph know about the existence of variables.  */
 188   if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl))
 189     cgraph_varpool_node (decl);
 190 }
 191
 192 /* Called after finishing a record, union or enumeral type.  */
 193
 194 void
 195 rest_of_type_compilation (tree type, int toplev)
 196 {
 197   /* Avoid confusing the debug information machinery when there are
 198      errors.  */
 199   if (errorcount != 0 || sorrycount != 0)
 200     return;
 201
 202   timevar_push (TV_SYMOUT);
 203   debug_hooks->type_decl (TYPE_STUB_DECL (type), !toplev);
 204   timevar_pop (TV_SYMOUT);
 205 }
 206
 207 \f
 208
 209 void
 210 finish_optimization_passes (void)
 211 {
 212   enum tree_dump_index i;
 213   struct dump_file_info *dfi;
 214   char *name;
 215
 216   timevar_push (TV_DUMP);
 217   if (profile_arc_flag || flag_test_coverage || flag_branch_probabilities)
 218     {
 219       dump_file = dump_begin (pass_branch_prob.static_pass_number, NULL);
 220       end_branch_prob ();
 221       if (dump_file)
 222         dump_end (pass_branch_prob.static_pass_number, dump_file);
 223     }
 224
 225   if (optimize > 0)
 226     {
 227       dump_file = dump_begin (pass_combine.static_pass_number, NULL);
 228       if (dump_file)
 229         {
 230           dump_combine_total_stats (dump_file);
 231           dump_end (pass_combine.static_pass_number, dump_file);
 232         }
 233     }
 234
 235   /* Do whatever is necessary to finish printing the graphs.  */
 236   if (graph_dump_format != no_graph)
 237     for (i = TDI_end; (dfi = get_dump_file_info (i)) != NULL; ++i)
 238       if (dump_initialized_p (i)
 239           && (dfi->flags & TDF_GRAPH) != 0
 240           && (name = get_dump_file_name (i)) != NULL)
 241         {
 242           finish_graph_dump_file (name);
 243           free (name);
 244         }
 245
 246   timevar_pop (TV_DUMP);
 247 }
 248
 249 static bool
 250 gate_rest_of_compilation (void)
 251 {
 252   /* Early return if there were errors.  We can run afoul of our
 253      consistency checks, and there's not really much point in fixing them.  */
 254   return !(rtl_dump_and_exit || flag_syntax_only || errorcount || sorrycount);
 255 }
 256
 257 struct tree_opt_pass pass_rest_of_compilation =
 258 {
 259   NULL,                                 /* name */
 260   gate_rest_of_compilation,             /* gate */
 261   NULL,                                 /* execute */
 262   NULL,                                 /* sub */
 263   NULL,                                 /* next */
 264   0,                                    /* static_pass_number */
 265   TV_REST_OF_COMPILATION,               /* tv_id */
 266   PROP_rtl,                             /* properties_required */
 267   0,                                    /* properties_provided */
 268   0,                                    /* properties_destroyed */
 269   0,                                    /* todo_flags_start */
 270   TODO_ggc_collect,                     /* todo_flags_finish */
 271   0                                     /* letter */
 272 };
 273
 274 static bool
 275 gate_postreload (void)
 276 {
 277   return reload_completed;
 278 }
 279
 280 struct tree_opt_pass pass_postreload =
 281 {
 282   NULL,                                 /* name */
 283   gate_postreload,                      /* gate */
 284   NULL,                                 /* execute */
 285   NULL,                                 /* sub */
 286   NULL,                                 /* next */
 287   0,                                    /* static_pass_number */
 288   0,                                    /* tv_id */
 289   PROP_rtl,                             /* properties_required */
 290   0,                                    /* properties_provided */
 291   0,                                    /* properties_destroyed */
 292   0,                                    /* todo_flags_start */
 293   TODO_ggc_collect,                     /* todo_flags_finish */
 294   0                                     /* letter */
 295 };
 296
 297
 298
 299 /* The root of the compilation pass tree, once constructed.  */
 300 struct tree_opt_pass *all_passes, *all_ipa_passes, *all_lowering_passes;
 301
 302 /* Iterate over the pass tree allocating dump file numbers.  We want
 303    to do this depth first, and independent of whether the pass is
 304    enabled or not.  */
 305
 306 static void
 307 register_one_dump_file (struct tree_opt_pass *pass, bool ipa, int n)
 308 {
 309   char *dot_name, *flag_name, *glob_name;
 310   char num[10];
 311
 312   /* See below in next_pass_1.  */
 313   num[0] = '\0';
 314   if (pass->static_pass_number != -1)
 315     sprintf (num, "%d", ((int) pass->static_pass_number < 0
 316                          ? 1 : pass->static_pass_number));
 317
 318   dot_name = concat (".", pass->name, num, NULL);
 319   if (ipa)
 320     {
 321       flag_name = concat ("ipa-", pass->name, num, NULL);
 322       glob_name = concat ("ipa-", pass->name, NULL);
 323       /* First IPA dump is cgraph that is dumped via separate channels.  */
 324       pass->static_pass_number = dump_register (dot_name, flag_name, glob_name,
 325                                                 TDF_IPA, n + 1, 0);
 326     }
 327   else if (pass->properties_provided & PROP_trees)
 328     {
 329       flag_name = concat ("tree-", pass->name, num, NULL);
 330       glob_name = concat ("tree-", pass->name, NULL);
 331       pass->static_pass_number = dump_register (dot_name, flag_name, glob_name,
 332                                                 TDF_TREE, n + TDI_tree_all, 0);
 333     }
 334   else
 335     {
 336       flag_name = concat ("rtl-", pass->name, num, NULL);
 337       glob_name = concat ("rtl-", pass->name, NULL);
 338       pass->static_pass_number = dump_register (dot_name, flag_name, glob_name,
 339                                                 TDF_RTL, n, pass->letter);
 340     }
 341 }
 342
 343 static int
 344 register_dump_files (struct tree_opt_pass *pass, bool ipa, int properties)
 345 {
 346   static int n = 0;
 347   do
 348     {
 349       int new_properties;
 350       int pass_number;
 351
 352       pass->properties_required = properties;
 353       new_properties =
 354         (properties | pass->properties_provided) & ~pass->properties_destroyed;
 355
 356       /* Reset the counter when we reach RTL-based passes.  */
 357       if ((new_properties ^ pass->properties_required) & PROP_rtl)
 358         n = 0;
 359
 360       pass_number = n;
 361       if (pass->name)
 362         n++;
 363
 364       if (pass->sub)
 365         new_properties = register_dump_files (pass->sub, false, new_properties);
 366
 367       /* If we have a gate, combine the properties that we could have with
 368          and without the pass being examined.  */
 369       if (pass->gate)
 370         properties &= new_properties;
 371       else
 372         properties = new_properties;
 373
 374       pass->properties_provided = properties;
 375       if (pass->name)
 376         register_one_dump_file (pass, ipa, pass_number);
 377
 378       pass = pass->next;
 379     }
 380   while (pass);
 381
 382   return properties;
 383 }
 384
 385 /* Add a pass to the pass list. Duplicate the pass if it's already
 386    in the list.  */
 387
 388 static struct tree_opt_pass **
 389 next_pass_1 (struct tree_opt_pass **list, struct tree_opt_pass *pass)
 390 {
 391
 392   /* A nonzero static_pass_number indicates that the
 393      pass is already in the list.  */
 394   if (pass->static_pass_number)
 395     {
 396       struct tree_opt_pass *new;
 397
 398       new = xmalloc (sizeof (*new));
 399       memcpy (new, pass, sizeof (*new));
 400
 401       /* Indicate to register_dump_files that this pass has duplicates,
 402          and so it should rename the dump file.  The first instance will
 403          be -1, and be number of duplicates = -static_pass_number - 1.
 404          Subsequent instances will be > 0 and just the duplicate number.  */
 405       if (pass->name)
 406         {
 407           pass->static_pass_number -= 1;
 408           new->static_pass_number = -pass->static_pass_number;
 409         }
 410
 411       *list = new;
 412     }
 413   else
 414     {
 415       pass->static_pass_number = -1;
 416       *list = pass;
 417     }
 418
 419   return &(*list)->next;
 420
 421 }
 422
 423 /* Construct the pass tree.  */
 424
 425 void
 426 init_optimization_passes (void)
 427 {
 428   struct tree_opt_pass **p;
 429
 430 #define NEXT_PASS(PASS)  (p = next_pass_1 (p, &PASS))
 431   /* Interprocedural optimization passes.  */
 432   p = &all_ipa_passes;
 433   NEXT_PASS (pass_early_ipa_inline);
 434   NEXT_PASS (pass_early_local_passes);
 435   NEXT_PASS (pass_ipa_cp);
 436   NEXT_PASS (pass_ipa_inline);
 437   NEXT_PASS (pass_ipa_reference);
 438   NEXT_PASS (pass_ipa_pure_const);
 439   NEXT_PASS (pass_ipa_type_escape);
 440   *p = NULL;
 441
 442   /* All passes needed to lower the function into shape optimizers can operate
 443      on.  These passes are performed before interprocedural passes, unlike rest
 444      of local passes (all_passes).  */
 445   p = &all_lowering_passes;
 446   NEXT_PASS (pass_remove_useless_stmts);
 447   NEXT_PASS (pass_mudflap_1);
 448   NEXT_PASS (pass_lower_cf);
 449   NEXT_PASS (pass_lower_eh);
 450   NEXT_PASS (pass_build_cfg);
 451   NEXT_PASS (pass_lower_complex_O0);
 452   NEXT_PASS (pass_lower_vector);
 453   NEXT_PASS (pass_warn_function_return);
 454   NEXT_PASS (pass_early_tree_profile);
 455   *p = NULL;
 456
 457   p = &pass_early_local_passes.sub;
 458   NEXT_PASS (pass_tree_profile);
 459   NEXT_PASS (pass_cleanup_cfg);
 460   NEXT_PASS (pass_rebuild_cgraph_edges);
 461   *p = NULL;
 462
 463   p = &all_passes;
 464   NEXT_PASS (pass_fixup_cfg);
 465   NEXT_PASS (pass_init_datastructures);
 466   NEXT_PASS (pass_all_optimizations);
 467   NEXT_PASS (pass_warn_function_noreturn);
 468   NEXT_PASS (pass_mudflap_2);
 469   NEXT_PASS (pass_free_datastructures);
 470   NEXT_PASS (pass_free_cfg_annotations);
 471   NEXT_PASS (pass_expand);
 472   NEXT_PASS (pass_rest_of_compilation);
 473   NEXT_PASS (pass_clean_state);
 474   *p = NULL;
 475
 476   p = &pass_all_optimizations.sub;
 477   NEXT_PASS (pass_referenced_vars);
 478   NEXT_PASS (pass_create_structure_vars);
 479   NEXT_PASS (pass_build_ssa);
 480   NEXT_PASS (pass_may_alias);
 481   NEXT_PASS (pass_return_slot);
 482   NEXT_PASS (pass_rename_ssa_copies);
 483   NEXT_PASS (pass_early_warn_uninitialized);
 484   NEXT_PASS (pass_eliminate_useless_stores);
 485
 486   /* Initial scalar cleanups.  */
 487   NEXT_PASS (pass_ccp);
 488   NEXT_PASS (pass_fre);
 489   NEXT_PASS (pass_dce);
 490   NEXT_PASS (pass_forwprop);
 491   NEXT_PASS (pass_copy_prop);
 492   NEXT_PASS (pass_vrp);
 493   NEXT_PASS (pass_dce);
 494   NEXT_PASS (pass_merge_phi);
 495   NEXT_PASS (pass_dominator);
 496
 497   /* The only copy propagation opportunities left after DOM
 498      should be due to degenerate PHI nodes.  So rather than
 499      run the full copy propagator, just discover and copy
 500      propagate away the degenerate PHI nodes.  */
 501   NEXT_PASS (pass_phi_only_copy_prop);
 502
 503   NEXT_PASS (pass_phiopt);
 504   NEXT_PASS (pass_may_alias);
 505   NEXT_PASS (pass_tail_recursion);
 506   NEXT_PASS (pass_profile);
 507   NEXT_PASS (pass_ch);
 508   NEXT_PASS (pass_stdarg);
 509   NEXT_PASS (pass_lower_complex);
 510   NEXT_PASS (pass_sra);
 511   /* FIXME: SRA may generate arbitrary gimple code, exposing new
 512      aliased and call-clobbered variables.  As mentioned below,
 513      pass_may_alias should be a TODO item.  */
 514   NEXT_PASS (pass_may_alias);
 515   NEXT_PASS (pass_rename_ssa_copies);
 516   NEXT_PASS (pass_dominator);
 517
 518   /* The only copy propagation opportunities left after DOM
 519      should be due to degenerate PHI nodes.  So rather than
 520      run the full copy propagator, just discover and copy
 521      propagate away the degenerate PHI nodes.  */
 522   NEXT_PASS (pass_phi_only_copy_prop);
 523
 524   NEXT_PASS (pass_dce);
 525   NEXT_PASS (pass_dse);
 526   NEXT_PASS (pass_may_alias);
 527   NEXT_PASS (pass_forwprop);
 528   NEXT_PASS (pass_phiopt);
 529   NEXT_PASS (pass_object_sizes);
 530   NEXT_PASS (pass_store_ccp);
 531   NEXT_PASS (pass_store_copy_prop);
 532   NEXT_PASS (pass_fold_builtins);
 533   /* FIXME: May alias should a TODO but for 4.0.0,
 534      we add may_alias right after fold builtins
 535      which can create arbitrary GIMPLE.  */
 536   NEXT_PASS (pass_may_alias);
 537   NEXT_PASS (pass_cse_reciprocals);
 538   NEXT_PASS (pass_split_crit_edges);
 539   NEXT_PASS (pass_reassoc);
 540   NEXT_PASS (pass_pre);
 541   NEXT_PASS (pass_sink_code);
 542   NEXT_PASS (pass_tree_loop);
 543   NEXT_PASS (pass_dominator);
 544
 545   /* The only copy propagation opportunities left after DOM
 546      should be due to degenerate PHI nodes.  So rather than
 547      run the full copy propagator, just discover and copy
 548      propagate away the degenerate PHI nodes.  */
 549   NEXT_PASS (pass_phi_only_copy_prop);
 550
 551   NEXT_PASS (pass_cd_dce);
 552
 553   /* FIXME: If DCE is not run before checking for uninitialized uses,
 554      we may get false warnings (e.g., testsuite/gcc.dg/uninit-5.c).
 555      However, this also causes us to misdiagnose cases that should be
 556      real warnings (e.g., testsuite/gcc.dg/pr18501.c).
 557
 558      To fix the false positives in uninit-5.c, we would have to
 559      account for the predicates protecting the set and the use of each
 560      variable.  Using a representation like Gated Single Assignment
 561      may help.  */
 562   NEXT_PASS (pass_late_warn_uninitialized);
 563   NEXT_PASS (pass_dse);
 564   NEXT_PASS (pass_forwprop);
 565   NEXT_PASS (pass_phiopt);
 566   NEXT_PASS (pass_tail_calls);
 567   NEXT_PASS (pass_rename_ssa_copies);
 568   NEXT_PASS (pass_uncprop);
 569   NEXT_PASS (pass_del_ssa);
 570   NEXT_PASS (pass_nrv);
 571   NEXT_PASS (pass_remove_useless_vars);
 572   NEXT_PASS (pass_mark_used_blocks);
 573   NEXT_PASS (pass_cleanup_cfg_post_optimizing);
 574   *p = NULL;
 575
 576   p = &pass_tree_loop.sub;
 577   NEXT_PASS (pass_tree_loop_init);
 578   NEXT_PASS (pass_copy_prop);
 579   NEXT_PASS (pass_lim);
 580   NEXT_PASS (pass_tree_unswitch);
 581   NEXT_PASS (pass_scev_cprop);
 582   NEXT_PASS (pass_empty_loop);
 583   NEXT_PASS (pass_record_bounds);
 584   NEXT_PASS (pass_linear_transform);
 585   NEXT_PASS (pass_iv_canon);
 586   NEXT_PASS (pass_if_conversion);
 587   NEXT_PASS (pass_vectorize);
 588   /* NEXT_PASS (pass_may_alias) cannot be done again because the
 589      vectorizer creates alias relations that are not supported by
 590      pass_may_alias.  */
 591   NEXT_PASS (pass_complete_unroll);
 592   NEXT_PASS (pass_iv_optimize);
 593   NEXT_PASS (pass_tree_loop_done);
 594   *p = NULL;
 595
 596   p = &pass_vectorize.sub;
 597   NEXT_PASS (pass_lower_vector_ssa);
 598   /* ??? The loop optimizers are not GC safe.  See PR 21805.
 599      Turn off GC while registering this pass.  */
 600   pass_dce.todo_flags_finish &= ~TODO_ggc_collect;
 601   NEXT_PASS (pass_dce);
 602   pass_dce.todo_flags_finish |= TODO_ggc_collect;
 603   gcc_assert (p != &pass_dce.next);
 604   *p = NULL;
 605
 606   p = &pass_loop2.sub;
 607   NEXT_PASS (pass_rtl_loop_init);
 608   NEXT_PASS (pass_rtl_move_loop_invariants);
 609   NEXT_PASS (pass_rtl_unswitch);
 610   NEXT_PASS (pass_rtl_unroll_and_peel_loops);
 611   NEXT_PASS (pass_rtl_doloop);
 612   NEXT_PASS (pass_rtl_loop_done);
 613   *p = NULL;
 614
 615   p = &pass_rest_of_compilation.sub;
 616   NEXT_PASS (pass_remove_unnecessary_notes);
 617   NEXT_PASS (pass_init_function);
 618   NEXT_PASS (pass_jump);
 619   NEXT_PASS (pass_insn_locators_initialize);
 620   NEXT_PASS (pass_rtl_eh);
 621   NEXT_PASS (pass_initial_value_sets);
 622   NEXT_PASS (pass_unshare_all_rtl);
 623   NEXT_PASS (pass_instantiate_virtual_regs);
 624   NEXT_PASS (pass_jump2);
 625   NEXT_PASS (pass_cse);
 626   NEXT_PASS (pass_gcse);
 627   NEXT_PASS (pass_loop_optimize);
 628   NEXT_PASS (pass_jump_bypass);
 629   NEXT_PASS (pass_cfg);
 630   NEXT_PASS (pass_branch_prob);
 631   NEXT_PASS (pass_rtl_ifcvt);
 632   NEXT_PASS (pass_tracer);
 633   /* Perform loop optimizations.  It might be better to do them a bit
 634      sooner, but we want the profile feedback to work more
 635      efficiently.  */
 636   NEXT_PASS (pass_loop2);
 637   NEXT_PASS (pass_web);
 638   NEXT_PASS (pass_cse2);
 639   NEXT_PASS (pass_life);
 640   NEXT_PASS (pass_combine);
 641   NEXT_PASS (pass_if_after_combine);
 642   NEXT_PASS (pass_partition_blocks);
 643   NEXT_PASS (pass_regmove);
 644   NEXT_PASS (pass_split_all_insns);
 645   NEXT_PASS (pass_mode_switching);
 646   NEXT_PASS (pass_recompute_reg_usage);
 647   NEXT_PASS (pass_sms);
 648   NEXT_PASS (pass_sched);
 649   NEXT_PASS (pass_local_alloc);
 650   NEXT_PASS (pass_global_alloc);
 651   NEXT_PASS (pass_postreload);
 652   *p = NULL;
 653
 654   p = &pass_postreload.sub;
 655   NEXT_PASS (pass_postreload_cse);
 656   NEXT_PASS (pass_gcse2);
 657   NEXT_PASS (pass_flow2);
 658   NEXT_PASS (pass_stack_adjustments);
 659   NEXT_PASS (pass_peephole2);
 660   NEXT_PASS (pass_if_after_reload);
 661   NEXT_PASS (pass_regrename);
 662   NEXT_PASS (pass_reorder_blocks);
 663   NEXT_PASS (pass_branch_target_load_optimize);
 664   NEXT_PASS (pass_leaf_regs);
 665   NEXT_PASS (pass_sched2);
 666   NEXT_PASS (pass_split_before_regstack);
 667   NEXT_PASS (pass_stack_regs);
 668   NEXT_PASS (pass_compute_alignments);
 669   NEXT_PASS (pass_duplicate_computed_gotos);
 670   NEXT_PASS (pass_variable_tracking);
 671   NEXT_PASS (pass_free_cfg);
 672   NEXT_PASS (pass_machine_reorg);
 673   NEXT_PASS (pass_purge_lineno_notes);
 674   NEXT_PASS (pass_cleanup_barriers);
 675   NEXT_PASS (pass_delay_slots);
 676   NEXT_PASS (pass_split_for_shorten_branches);
 677   NEXT_PASS (pass_convert_to_eh_region_ranges);
 678   NEXT_PASS (pass_shorten_branches);
 679   NEXT_PASS (pass_set_nothrow_function_flags);
 680   NEXT_PASS (pass_final);
 681   *p = NULL;
 682
 683 #undef NEXT_PASS
 684
 685   /* Register the passes with the tree dump code.  */
 686   register_dump_files (all_ipa_passes, true, PROP_gimple_leh | PROP_cfg);
 687   register_dump_files (all_lowering_passes, false, PROP_gimple_any);
 688   register_dump_files (all_passes, false, PROP_gimple_leh | PROP_cfg);
 689 }
 690
 691 static unsigned int last_verified;
 692
 693 static void
 694 execute_todo (struct tree_opt_pass *pass, unsigned int flags, bool use_required)
 695 {
 696   int properties
 697     = use_required ? pass->properties_required : pass->properties_provided;
 698
 699 #if defined ENABLE_CHECKING
 700   if (need_ssa_update_p ())
 701     gcc_assert (flags & TODO_update_ssa_any);
 702 #endif
 703
 704   /* Always cleanup the CFG before doing anything else.  */
 705   if (flags & TODO_cleanup_cfg)
 706     {
 707       if (current_loops)
 708         cleanup_tree_cfg_loop ();
 709       else
 710         cleanup_tree_cfg ();
 711
 712       /* When cleanup_tree_cfg merges consecutive blocks, it may
 713          perform some simplistic propagation when removing single
 714          valued PHI nodes.  This propagation may, in turn, cause the
 715          SSA form to become out-of-date (see PR 22037).  So, even
 716          if the parent pass had not scheduled an SSA update, we may
 717          still need to do one.  */
 718       if (!(flags & TODO_update_ssa_any) && need_ssa_update_p ())
 719         flags |= TODO_update_ssa;
 720     }
 721
 722   if (flags & TODO_update_ssa_any)
 723     {
 724       unsigned update_flags = flags & TODO_update_ssa_any;
 725       update_ssa (update_flags);
 726     }
 727
 728   if ((flags & TODO_dump_func)
 729       && dump_file && current_function_decl)
 730     {
 731       if (properties & PROP_trees)
 732         dump_function_to_file (current_function_decl,
 733                                dump_file, dump_flags);
 734       else if (properties & PROP_cfg)
 735         {
 736           print_rtl_with_bb (dump_file, get_insns ());
 737
 738           if (graph_dump_format != no_graph
 739               && (dump_flags & TDF_GRAPH))
 740             print_rtl_graph_with_bb (dump_file_name, get_insns ());
 741         }
 742       else
 743         print_rtl (dump_file, get_insns ());
 744
 745       /* Flush the file.  If verification fails, we won't be able to
 746          close the file before aborting.  */
 747       fflush (dump_file);
 748     }
 749   if ((flags & TODO_dump_cgraph)
 750       && dump_file && !current_function_decl)
 751     {
 752       dump_cgraph (dump_file);
 753       /* Flush the file.  If verification fails, we won't be able to
 754          close the file before aborting.  */
 755       fflush (dump_file);
 756     }
 757
 758   if (flags & TODO_ggc_collect)
 759     {
 760       ggc_collect ();
 761     }
 762
 763 #if defined ENABLE_CHECKING
 764   if ((pass->properties_required & PROP_ssa)
 765       && !(pass->properties_destroyed & PROP_ssa))
 766     verify_ssa (true);
 767   if (flags & TODO_verify_flow)
 768     verify_flow_info ();
 769   if (flags & TODO_verify_stmts)
 770     verify_stmts ();
 771   if (flags & TODO_verify_loops)
 772     verify_loop_closed_ssa ();
 773 #endif
 774 }
 775
 776 static bool
 777 execute_one_pass (struct tree_opt_pass *pass)
 778 {
 779   unsigned int todo;
 780
 781   /* See if we're supposed to run this pass.  */
 782   if (pass->gate && !pass->gate ())
 783     return false;
 784
 785   /* Note that the folders should only create gimple expressions.
 786      This is a hack until the new folder is ready.  */
 787   in_gimple_form = (pass->properties_provided & PROP_trees) != 0;
 788
 789   /* Run pre-pass verification.  */
 790   todo = pass->todo_flags_start & ~last_verified;
 791   if (todo)
 792     execute_todo (pass, todo, true);
 793
 794   /* If a dump file name is present, open it if enabled.  */
 795   if (pass->static_pass_number != -1)
 796     {
 797       bool initializing_dump = !dump_initialized_p (pass->static_pass_number);
 798       dump_file_name = get_dump_file_name (pass->static_pass_number);
 799       dump_file = dump_begin (pass->static_pass_number, &dump_flags);
 800       if (dump_file && current_function_decl)
 801         {
 802           const char *dname, *aname;
 803           dname = lang_hooks.decl_printable_name (current_function_decl, 2);
 804           aname = (IDENTIFIER_POINTER
 805                    (DECL_ASSEMBLER_NAME (current_function_decl)));
 806           fprintf (dump_file, "\n;; Function %s (%s)%s\n\n", dname, aname,
 807              cfun->function_frequency == FUNCTION_FREQUENCY_HOT
 808              ? " (hot)"
 809              : cfun->function_frequency == FUNCTION_FREQUENCY_UNLIKELY_EXECUTED
 810              ? " (unlikely executed)"
 811              : "");
 812         }
 813
 814       if (initializing_dump
 815           && dump_file
 816           && graph_dump_format != no_graph
 817           && (pass->properties_provided & (PROP_cfg | PROP_rtl))
 818               == (PROP_cfg | PROP_rtl))
 819         {
 820           get_dump_file_info (pass->static_pass_number)->flags |= TDF_GRAPH;
 821           dump_flags |= TDF_GRAPH;
 822           clean_graph_dump_file (dump_file_name);
 823         }
 824     }
 825
 826   /* If a timevar is present, start it.  */
 827   if (pass->tv_id)
 828     timevar_push (pass->tv_id);
 829
 830   /* Do it!  */
 831   if (pass->execute)
 832     pass->execute ();
 833
 834   /* Stop timevar.  */
 835   if (pass->tv_id)
 836     timevar_pop (pass->tv_id);
 837
 838   /* Run post-pass cleanup and verification.  */
 839   todo = pass->todo_flags_finish;
 840   last_verified = todo & TODO_verify_all;
 841   if (todo)
 842     execute_todo (pass, todo, false);
 843
 844   /* Flush and close dump file.  */
 845   if (dump_file_name)
 846     {
 847       free ((char *) dump_file_name);
 848       dump_file_name = NULL;
 849     }
 850   if (dump_file)
 851     {
 852       dump_end (pass->static_pass_number, dump_file);
 853       dump_file = NULL;
 854     }
 855
 856   return true;
 857 }
 858
 859 void
 860 execute_pass_list (struct tree_opt_pass *pass)
 861 {
 862   do
 863     {
 864       if (execute_one_pass (pass) && pass->sub)
 865         execute_pass_list (pass->sub);
 866       pass = pass->next;
 867     }
 868   while (pass);
 869 }
 870
 871 /* Same as execute_pass_list but assume that subpasses of IPA passes
 872    are local passes.  */
 873 void
 874 execute_ipa_pass_list (struct tree_opt_pass *pass)
 875 {
 876   do
 877     {
 878       if (execute_one_pass (pass) && pass->sub)
 879         {
 880           struct cgraph_node *node;
 881           for (node = cgraph_nodes; node; node = node->next)
 882             if (node->analyzed)
 883               {
 884                 push_cfun (DECL_STRUCT_FUNCTION (node->decl));
 885                 current_function_decl = node->decl;
 886                 execute_pass_list (pass->sub);
 887                 free_dominance_info (CDI_DOMINATORS);
 888                 free_dominance_info (CDI_POST_DOMINATORS);
 889                 current_function_decl = NULL;
 890                 pop_cfun ();
 891                 ggc_collect ();
 892               }
 893         }
 894       pass = pass->next;
 895     }
 896   while (pass);
 897 }