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, 2006 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             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     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_profile.static_pass_number, NULL);
 220       end_branch_prob ();
 221       if (dump_file)
 222         dump_end (pass_profile.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 properties)
 308 {
 309   char *dot_name, *flag_name, *glob_name;
 310   const char *prefix;
 311   char num[10];
 312   int flags;
 313
 314   /* See below in next_pass_1.  */
 315   num[0] = '\0';
 316   if (pass->static_pass_number != -1)
 317     sprintf (num, "%d", ((int) pass->static_pass_number < 0
 318                          ? 1 : pass->static_pass_number));
 319
 320   dot_name = concat (".", pass->name, num, NULL);
 321   if (ipa)
 322     prefix = "ipa-", flags = TDF_IPA;
 323   else if (properties & PROP_trees)
 324     prefix = "tree-", flags = TDF_TREE;
 325   else
 326     prefix = "rtl-", flags = TDF_RTL;
 327
 328   flag_name = concat (prefix, pass->name, num, NULL);
 329   glob_name = concat (prefix, pass->name, NULL);
 330   pass->static_pass_number = dump_register (dot_name, flag_name, glob_name,
 331                                             flags, pass->letter);
 332 }
 333
 334 /* Recursive worker function for register_dump_files.  */
 335
 336 static int
 337 register_dump_files_1 (struct tree_opt_pass *pass, bool ipa, int properties)
 338 {
 339   do
 340     {
 341       int new_properties = (properties | pass->properties_provided)
 342                            & ~pass->properties_destroyed;
 343
 344       if (pass->name)
 345         register_one_dump_file (pass, ipa, new_properties);
 346
 347       if (pass->sub)
 348         new_properties = register_dump_files_1 (pass->sub, false,
 349                                                 new_properties);
 350
 351       /* If we have a gate, combine the properties that we could have with
 352          and without the pass being examined.  */
 353       if (pass->gate)
 354         properties &= new_properties;
 355       else
 356         properties = new_properties;
 357
 358       pass = pass->next;
 359     }
 360   while (pass);
 361
 362   return properties;
 363 }
 364
 365 /* Register the dump files for the pipeline starting at PASS.  IPA is
 366    true if the pass is inter-procedural, and PROPERTIES reflects the
 367    properties that are guaranteed to be available at the beginning of
 368    the pipeline.  */
 369
 370 static void
 371 register_dump_files (struct tree_opt_pass *pass, bool ipa, int properties)
 372 {
 373   pass->properties_required |= properties;
 374   register_dump_files_1 (pass, ipa, properties);
 375 }
 376
 377 /* Add a pass to the pass list. Duplicate the pass if it's already
 378    in the list.  */
 379
 380 static struct tree_opt_pass **
 381 next_pass_1 (struct tree_opt_pass **list, struct tree_opt_pass *pass)
 382 {
 383   /* A nonzero static_pass_number indicates that the
 384      pass is already in the list.  */
 385   if (pass->static_pass_number)
 386     {
 387       struct tree_opt_pass *new;
 388
 389       new = xmalloc (sizeof (*new));
 390       memcpy (new, pass, sizeof (*new));
 391
 392       /* Indicate to register_dump_files that this pass has duplicates,
 393          and so it should rename the dump file.  The first instance will
 394          be -1, and be number of duplicates = -static_pass_number - 1.
 395          Subsequent instances will be > 0 and just the duplicate number.  */
 396       if (pass->name)
 397         {
 398           pass->static_pass_number -= 1;
 399           new->static_pass_number = -pass->static_pass_number;
 400         }
 401
 402       *list = new;
 403     }
 404   else
 405     {
 406       pass->static_pass_number = -1;
 407       *list = pass;
 408     }
 409
 410   return &(*list)->next;
 411
 412 }
 413
 414 /* Construct the pass tree.  The sequencing of passes is driven by
 415    the cgraph routines:
 416
 417    cgraph_finalize_compilation_unit ()
 418        for each node N in the cgraph
 419            cgraph_analyze_function (N)
 420                cgraph_lower_function (N) -> all_lowering_passes
 421
 422    If we are optimizing, cgraph_optimize is then invoked:
 423
 424    cgraph_optimize ()
 425        ipa_passes ()                    -> all_ipa_passes
 426        cgraph_expand_all_functions ()
 427            for each node N in the cgraph
 428                cgraph_expand_function (N)
 429                    cgraph_lower_function (N)    -> Now a NOP.
 430                    lang_hooks.callgraph.expand_function (DECL (N))
 431                         tree_rest_of_compilation (DECL (N))  -> all_passes
 432 */
 433
 434 void
 435 init_optimization_passes (void)
 436 {
 437   struct tree_opt_pass **p;
 438
 439 #define NEXT_PASS(PASS)  (p = next_pass_1 (p, &PASS))
 440
 441   /* Interprocedural optimization passes.  */
 442   p = &all_ipa_passes;
 443   NEXT_PASS (pass_ipa_function_and_variable_visibility);
 444   NEXT_PASS (pass_ipa_early_inline);
 445   NEXT_PASS (pass_early_local_passes);
 446   NEXT_PASS (pass_ipa_increase_alignment);
 447   NEXT_PASS (pass_ipa_cp);
 448   NEXT_PASS (pass_ipa_inline);
 449   NEXT_PASS (pass_ipa_reference);
 450   NEXT_PASS (pass_ipa_pure_const);
 451   NEXT_PASS (pass_ipa_type_escape);
 452   NEXT_PASS (pass_ipa_pta);
 453   *p = NULL;
 454
 455   p = &pass_ipa_early_inline.sub;
 456   NEXT_PASS (pass_early_inline);
 457   NEXT_PASS (pass_inline_parameters);
 458   NEXT_PASS (pass_rebuild_cgraph_edges);
 459   *p = NULL;
 460
 461   /* All passes needed to lower the function into shape optimizers can
 462      operate on.  */
 463   p = &all_lowering_passes;
 464   NEXT_PASS (pass_remove_useless_stmts);
 465   NEXT_PASS (pass_mudflap_1);
 466   NEXT_PASS (pass_lower_omp);
 467   NEXT_PASS (pass_lower_cf);
 468   NEXT_PASS (pass_lower_eh);
 469   NEXT_PASS (pass_build_cfg);
 470   NEXT_PASS (pass_lower_complex_O0);
 471   NEXT_PASS (pass_lower_vector);
 472   NEXT_PASS (pass_warn_function_return);
 473   NEXT_PASS (pass_build_cgraph_edges);
 474   NEXT_PASS (pass_inline_parameters);
 475   *p = NULL;
 476
 477   p = &pass_early_local_passes.sub;
 478   NEXT_PASS (pass_tree_profile);
 479   NEXT_PASS (pass_cleanup_cfg);
 480   NEXT_PASS (pass_init_datastructures);
 481   NEXT_PASS (pass_expand_omp);
 482   NEXT_PASS (pass_all_early_optimizations);
 483   NEXT_PASS (pass_rebuild_cgraph_edges);
 484   NEXT_PASS (pass_inline_parameters);
 485   *p = NULL;
 486
 487   p = &pass_all_early_optimizations.sub;
 488   NEXT_PASS (pass_referenced_vars);
 489   NEXT_PASS (pass_reset_cc_flags);
 490   NEXT_PASS (pass_build_ssa);
 491   NEXT_PASS (pass_early_warn_uninitialized);
 492   NEXT_PASS (pass_rebuild_cgraph_edges);
 493   NEXT_PASS (pass_early_inline);
 494   NEXT_PASS (pass_cleanup_cfg);
 495   NEXT_PASS (pass_rename_ssa_copies);
 496   NEXT_PASS (pass_ccp);
 497
 498   NEXT_PASS (pass_forwprop);
 499   NEXT_PASS (pass_copy_prop);
 500   NEXT_PASS (pass_merge_phi);
 501   NEXT_PASS (pass_dce);
 502   NEXT_PASS (pass_tail_recursion);
 503   NEXT_PASS (pass_release_ssa_names);
 504
 505   *p = NULL;
 506
 507   p = &all_passes;
 508   NEXT_PASS (pass_apply_inline);
 509   NEXT_PASS (pass_all_optimizations);
 510   NEXT_PASS (pass_warn_function_noreturn);
 511   NEXT_PASS (pass_free_datastructures);
 512   NEXT_PASS (pass_mudflap_2);
 513   NEXT_PASS (pass_free_cfg_annotations);
 514   NEXT_PASS (pass_expand);
 515   NEXT_PASS (pass_rest_of_compilation);
 516   NEXT_PASS (pass_clean_state);
 517   *p = NULL;
 518
 519   p = &pass_all_optimizations.sub;
 520   NEXT_PASS (pass_create_structure_vars);
 521   NEXT_PASS (pass_may_alias);
 522   NEXT_PASS (pass_return_slot);
 523   NEXT_PASS (pass_rename_ssa_copies);
 524   NEXT_PASS (pass_early_warn_uninitialized);
 525
 526   /* Initial scalar cleanups.  */
 527   NEXT_PASS (pass_ccp);
 528   NEXT_PASS (pass_fre);
 529   NEXT_PASS (pass_dce);
 530   NEXT_PASS (pass_forwprop);
 531   NEXT_PASS (pass_copy_prop);
 532   NEXT_PASS (pass_merge_phi);
 533   NEXT_PASS (pass_vrp);
 534   NEXT_PASS (pass_dce);
 535   NEXT_PASS (pass_dominator);
 536
 537   /* The only const/copy propagation opportunities left after
 538      DOM should be due to degenerate PHI nodes.  So rather than
 539      run the full propagators, run a specialized pass which
 540      only examines PHIs to discover const/copy propagation
 541      opportunities.  */
 542   NEXT_PASS (pass_phi_only_cprop);
 543
 544   NEXT_PASS (pass_phiopt);
 545   NEXT_PASS (pass_may_alias);
 546   NEXT_PASS (pass_tail_recursion);
 547   NEXT_PASS (pass_profile);
 548   NEXT_PASS (pass_ch);
 549   NEXT_PASS (pass_stdarg);
 550   NEXT_PASS (pass_lower_complex);
 551   NEXT_PASS (pass_sra);
 552   /* FIXME: SRA may generate arbitrary gimple code, exposing new
 553      aliased and call-clobbered variables.  As mentioned below,
 554      pass_may_alias should be a TODO item.  */
 555   NEXT_PASS (pass_may_alias);
 556   NEXT_PASS (pass_rename_ssa_copies);
 557   NEXT_PASS (pass_dominator);
 558
 559   /* The only const/copy propagation opportunities left after
 560      DOM should be due to degenerate PHI nodes.  So rather than
 561      run the full propagators, run a specialized pass which
 562      only examines PHIs to discover const/copy propagation
 563      opportunities.  */
 564   NEXT_PASS (pass_phi_only_cprop);
 565
 566   NEXT_PASS (pass_reassoc);
 567   NEXT_PASS (pass_dce);
 568   NEXT_PASS (pass_dse);
 569   NEXT_PASS (pass_may_alias);
 570   NEXT_PASS (pass_forwprop);
 571   NEXT_PASS (pass_phiopt);
 572   NEXT_PASS (pass_object_sizes);
 573   NEXT_PASS (pass_store_ccp);
 574   NEXT_PASS (pass_store_copy_prop);
 575   NEXT_PASS (pass_fold_builtins);
 576   NEXT_PASS (pass_cse_sincos);
 577   /* FIXME: May alias should a TODO but for 4.0.0,
 578      we add may_alias right after fold builtins
 579      which can create arbitrary GIMPLE.  */
 580   NEXT_PASS (pass_may_alias);
 581   NEXT_PASS (pass_split_crit_edges);
 582   NEXT_PASS (pass_pre);
 583   NEXT_PASS (pass_may_alias);
 584   NEXT_PASS (pass_sink_code);
 585   NEXT_PASS (pass_tree_loop);
 586   NEXT_PASS (pass_cse_reciprocals);
 587   NEXT_PASS (pass_reassoc);
 588   NEXT_PASS (pass_vrp);
 589   NEXT_PASS (pass_dominator);
 590
 591   /* The only const/copy propagation opportunities left after
 592      DOM should be due to degenerate PHI nodes.  So rather than
 593      run the full propagators, run a specialized pass which
 594      only examines PHIs to discover const/copy propagation
 595      opportunities.  */
 596   NEXT_PASS (pass_phi_only_cprop);
 597
 598   NEXT_PASS (pass_cd_dce);
 599
 600   /* FIXME: If DCE is not run before checking for uninitialized uses,
 601      we may get false warnings (e.g., testsuite/gcc.dg/uninit-5.c).
 602      However, this also causes us to misdiagnose cases that should be
 603      real warnings (e.g., testsuite/gcc.dg/pr18501.c).
 604
 605      To fix the false positives in uninit-5.c, we would have to
 606      account for the predicates protecting the set and the use of each
 607      variable.  Using a representation like Gated Single Assignment
 608      may help.  */
 609   NEXT_PASS (pass_late_warn_uninitialized);
 610   NEXT_PASS (pass_dse);
 611   NEXT_PASS (pass_forwprop);
 612   NEXT_PASS (pass_phiopt);
 613   NEXT_PASS (pass_tail_calls);
 614   NEXT_PASS (pass_rename_ssa_copies);
 615   NEXT_PASS (pass_uncprop);
 616   NEXT_PASS (pass_del_ssa);
 617   NEXT_PASS (pass_nrv);
 618   NEXT_PASS (pass_mark_used_blocks);
 619   NEXT_PASS (pass_cleanup_cfg_post_optimizing);
 620   *p = NULL;
 621
 622   p = &pass_tree_loop.sub;
 623   NEXT_PASS (pass_tree_loop_init);
 624   NEXT_PASS (pass_copy_prop);
 625   NEXT_PASS (pass_lim);
 626   NEXT_PASS (pass_tree_unswitch);
 627   NEXT_PASS (pass_scev_cprop);
 628   NEXT_PASS (pass_empty_loop);
 629   NEXT_PASS (pass_record_bounds);
 630   NEXT_PASS (pass_linear_transform);
 631   NEXT_PASS (pass_iv_canon);
 632   NEXT_PASS (pass_if_conversion);
 633   NEXT_PASS (pass_vectorize);
 634   /* NEXT_PASS (pass_may_alias) cannot be done again because the
 635      vectorizer creates alias relations that are not supported by
 636      pass_may_alias.  */
 637   NEXT_PASS (pass_complete_unroll);
 638   NEXT_PASS (pass_loop_prefetch);
 639   NEXT_PASS (pass_iv_optimize);
 640   NEXT_PASS (pass_tree_loop_done);
 641   *p = NULL;
 642
 643   p = &pass_vectorize.sub;
 644   NEXT_PASS (pass_lower_vector_ssa);
 645   NEXT_PASS (pass_dce_loop);
 646   *p = NULL;
 647
 648   p = &pass_loop2.sub;
 649   NEXT_PASS (pass_rtl_loop_init);
 650   NEXT_PASS (pass_rtl_move_loop_invariants);
 651   NEXT_PASS (pass_rtl_unswitch);
 652   NEXT_PASS (pass_rtl_unroll_and_peel_loops);
 653   NEXT_PASS (pass_rtl_doloop);
 654   NEXT_PASS (pass_rtl_loop_done);
 655   *p = NULL;
 656
 657   p = &pass_rest_of_compilation.sub;
 658   NEXT_PASS (pass_init_function);
 659   NEXT_PASS (pass_jump);
 660   NEXT_PASS (pass_insn_locators_initialize);
 661   NEXT_PASS (pass_rtl_eh);
 662   NEXT_PASS (pass_initial_value_sets);
 663   NEXT_PASS (pass_unshare_all_rtl);
 664   NEXT_PASS (pass_instantiate_virtual_regs);
 665   NEXT_PASS (pass_jump2);
 666   NEXT_PASS (pass_cse);
 667   NEXT_PASS (pass_rtl_fwprop);
 668   NEXT_PASS (pass_gcse);
 669   NEXT_PASS (pass_jump_bypass);
 670   NEXT_PASS (pass_rtl_ifcvt);
 671   NEXT_PASS (pass_tracer);
 672   /* Perform loop optimizations.  It might be better to do them a bit
 673      sooner, but we want the profile feedback to work more
 674      efficiently.  */
 675   NEXT_PASS (pass_loop2);
 676   NEXT_PASS (pass_web);
 677   NEXT_PASS (pass_cse2);
 678   NEXT_PASS (pass_rtl_fwprop_addr);
 679   NEXT_PASS (pass_life);
 680   NEXT_PASS (pass_combine);
 681   NEXT_PASS (pass_if_after_combine);
 682   NEXT_PASS (pass_partition_blocks);
 683   NEXT_PASS (pass_regmove);
 684   NEXT_PASS (pass_split_all_insns);
 685   NEXT_PASS (pass_mode_switching);
 686   NEXT_PASS (pass_see);
 687   NEXT_PASS (pass_recompute_reg_usage);
 688   NEXT_PASS (pass_sms);
 689   NEXT_PASS (pass_sched);
 690   NEXT_PASS (pass_local_alloc);
 691   NEXT_PASS (pass_global_alloc);
 692   NEXT_PASS (pass_postreload);
 693   *p = NULL;
 694
 695   p = &pass_postreload.sub;
 696   NEXT_PASS (pass_postreload_cse);
 697   NEXT_PASS (pass_gcse2);
 698   NEXT_PASS (pass_flow2);
 699   NEXT_PASS (pass_rtl_seqabstr);
 700   NEXT_PASS (pass_stack_adjustments);
 701   NEXT_PASS (pass_peephole2);
 702   NEXT_PASS (pass_if_after_reload);
 703   NEXT_PASS (pass_regrename);
 704   NEXT_PASS (pass_reorder_blocks);
 705   NEXT_PASS (pass_branch_target_load_optimize);
 706   NEXT_PASS (pass_leaf_regs);
 707   NEXT_PASS (pass_sched2);
 708   NEXT_PASS (pass_split_before_regstack);
 709   NEXT_PASS (pass_stack_regs);
 710   NEXT_PASS (pass_compute_alignments);
 711   NEXT_PASS (pass_duplicate_computed_gotos);
 712   NEXT_PASS (pass_variable_tracking);
 713   NEXT_PASS (pass_free_cfg);
 714   NEXT_PASS (pass_machine_reorg);
 715   NEXT_PASS (pass_cleanup_barriers);
 716   NEXT_PASS (pass_delay_slots);
 717   NEXT_PASS (pass_split_for_shorten_branches);
 718   NEXT_PASS (pass_convert_to_eh_region_ranges);
 719   NEXT_PASS (pass_shorten_branches);
 720   NEXT_PASS (pass_set_nothrow_function_flags);
 721   NEXT_PASS (pass_final);
 722   *p = NULL;
 723
 724 #undef NEXT_PASS
 725
 726   /* Register the passes with the tree dump code.  */
 727   register_dump_files (all_lowering_passes, false, PROP_gimple_any);
 728   all_lowering_passes->todo_flags_start |= TODO_set_props;
 729   register_dump_files (all_ipa_passes, true,
 730                        PROP_gimple_any | PROP_gimple_lcf | PROP_gimple_leh
 731                        | PROP_cfg);
 732   register_dump_files (all_passes, false,
 733                        PROP_gimple_any | PROP_gimple_lcf | PROP_gimple_leh
 734                        | PROP_cfg);
 735 }
 736
 737 /* If we are in IPA mode (i.e., current_function_decl is NULL), call
 738    function CALLBACK for every function in the call graph.  Otherwise,
 739    call CALLBACK on the current function.  */
 740
 741 static void
 742 do_per_function (void (*callback) (void *data), void *data)
 743 {
 744   if (current_function_decl)
 745     callback (data);
 746   else
 747     {
 748       struct cgraph_node *node;
 749       for (node = cgraph_nodes; node; node = node->next)
 750         if (node->analyzed)
 751           {
 752             push_cfun (DECL_STRUCT_FUNCTION (node->decl));
 753             current_function_decl = node->decl;
 754             callback (data);
 755             free_dominance_info (CDI_DOMINATORS);
 756             free_dominance_info (CDI_POST_DOMINATORS);
 757             current_function_decl = NULL;
 758             pop_cfun ();
 759             ggc_collect ();
 760           }
 761     }
 762 }
 763
 764 /* Because inlining might remove no-longer reachable nodes, we need to
 765    keep the array visible to garbage collector to avoid reading collected
 766    out nodes.  */
 767 static int nnodes;
 768 static GTY ((length ("nnodes"))) struct cgraph_node **order;
 769
 770 /* If we are in IPA mode (i.e., current_function_decl is NULL), call
 771    function CALLBACK for every function in the call graph.  Otherwise,
 772    call CALLBACK on the current function.  */
 773
 774 static void
 775 do_per_function_toporder (void (*callback) (void *data), void *data)
 776 {
 777   int i;
 778
 779   if (current_function_decl)
 780     callback (data);
 781   else
 782     {
 783       gcc_assert (!order);
 784       order = ggc_alloc (sizeof (*order) * cgraph_n_nodes);
 785       nnodes = cgraph_postorder (order);
 786       for (i = nnodes - 1; i >= 0; i--)
 787         {
 788           struct cgraph_node *node = order[i];
 789
 790           /* Allow possibly removed nodes to be garbage collected.  */
 791           order[i] = NULL;
 792           if (node->analyzed && (node->needed || node->reachable))
 793             {
 794               push_cfun (DECL_STRUCT_FUNCTION (node->decl));
 795               current_function_decl = node->decl;
 796               callback (data);
 797               free_dominance_info (CDI_DOMINATORS);
 798               free_dominance_info (CDI_POST_DOMINATORS);
 799               current_function_decl = NULL;
 800               pop_cfun ();
 801               ggc_collect ();
 802             }
 803         }
 804     }
 805   ggc_free (order);
 806   order = NULL;
 807   nnodes = 0;
 808 }
 809
 810 /* Perform all TODO actions that ought to be done on each function.  */
 811
 812 static void
 813 execute_function_todo (void *data)
 814 {
 815   unsigned int flags = (size_t)data;
 816   if (cfun->curr_properties & PROP_ssa)
 817     flags |= TODO_verify_ssa;
 818   flags &= ~cfun->last_verified;
 819   if (!flags)
 820     return;
 821
 822   /* Always cleanup the CFG before trying to update SSA.  */
 823   if (flags & TODO_cleanup_cfg)
 824     {
 825       bool cleanup;
 826
 827       if (current_loops)
 828         cleanup = cleanup_tree_cfg_loop ();
 829       else
 830         cleanup = cleanup_tree_cfg ();
 831
 832       if (cleanup && (cfun->curr_properties & PROP_ssa))
 833         flags |= TODO_remove_unused_locals;
 834
 835       /* When cleanup_tree_cfg merges consecutive blocks, it may
 836          perform some simplistic propagation when removing single
 837          valued PHI nodes.  This propagation may, in turn, cause the
 838          SSA form to become out-of-date (see PR 22037).  So, even
 839          if the parent pass had not scheduled an SSA update, we may
 840          still need to do one.  */
 841       if (!(flags & TODO_update_ssa_any) && need_ssa_update_p ())
 842         flags |= TODO_update_ssa;
 843     }
 844
 845   if (flags & TODO_update_ssa_any)
 846     {
 847       unsigned update_flags = flags & TODO_update_ssa_any;
 848       update_ssa (update_flags);
 849       cfun->last_verified &= ~TODO_verify_ssa;
 850     }
 851
 852   if (flags & TODO_remove_unused_locals)
 853     remove_unused_locals ();
 854
 855   if ((flags & TODO_dump_func)
 856       && dump_file && current_function_decl)
 857     {
 858       if (cfun->curr_properties & PROP_trees)
 859         dump_function_to_file (current_function_decl,
 860                                dump_file, dump_flags);
 861       else
 862         {
 863           if (dump_flags & TDF_SLIM)
 864             print_rtl_slim_with_bb (dump_file, get_insns (), dump_flags);
 865           else if ((cfun->curr_properties & PROP_cfg)
 866                    && (dump_flags & TDF_BLOCKS))
 867             print_rtl_with_bb (dump_file, get_insns ());
 868           else
 869             print_rtl (dump_file, get_insns ());
 870
 871           if (cfun->curr_properties & PROP_cfg
 872               && graph_dump_format != no_graph
 873               && (dump_flags & TDF_GRAPH))
 874             print_rtl_graph_with_bb (dump_file_name, get_insns ());
 875         }
 876
 877       /* Flush the file.  If verification fails, we won't be able to
 878          close the file before aborting.  */
 879       fflush (dump_file);
 880     }
 881
 882 #if defined ENABLE_CHECKING
 883   if (flags & TODO_verify_ssa)
 884     verify_ssa (true);
 885   if (flags & TODO_verify_flow)
 886     verify_flow_info ();
 887   if (flags & TODO_verify_stmts)
 888     verify_stmts ();
 889   if (flags & TODO_verify_loops)
 890     verify_loop_closed_ssa ();
 891 #endif
 892
 893   cfun->last_verified = flags & TODO_verify_all;
 894 }
 895
 896 /* Perform all TODO actions.  */
 897 static void
 898 execute_todo (unsigned int flags)
 899 {
 900 #if defined ENABLE_CHECKING
 901   if (need_ssa_update_p ())
 902     gcc_assert (flags & TODO_update_ssa_any);
 903 #endif
 904
 905   do_per_function (execute_function_todo, (void *)(size_t) flags);
 906
 907   /* Always remove functions just as before inlining: IPA passes might be
 908      interested to see bodies of extern inline functions that are not inlined
 909      to analyze side effects.  The full removal is done just at the end
 910      of IPA pass queue.  */
 911   if (flags & TODO_remove_functions)
 912     cgraph_remove_unreachable_nodes (true, dump_file);
 913
 914   if ((flags & TODO_dump_cgraph)
 915       && dump_file && !current_function_decl)
 916     {
 917       dump_cgraph (dump_file);
 918       /* Flush the file.  If verification fails, we won't be able to
 919          close the file before aborting.  */
 920       fflush (dump_file);
 921     }
 922
 923   if (flags & TODO_ggc_collect)
 924     {
 925       ggc_collect ();
 926     }
 927 }
 928
 929 /* Clear the last verified flag.  */
 930
 931 static void
 932 clear_last_verified (void *data ATTRIBUTE_UNUSED)
 933 {
 934   cfun->last_verified = 0;
 935 }
 936
 937 /* Helper function. Verify that the properties has been turn into the
 938    properties expected by the pass.  */
 939
 940 #ifdef ENABLE_CHECKING
 941 static void
 942 verify_curr_properties (void *data)
 943 {
 944   unsigned int props = (size_t)data;
 945   gcc_assert ((cfun->curr_properties & props) == props);
 946 }
 947 #endif
 948
 949 /* After executing the pass, apply expected changes to the function
 950    properties. */
 951 static void
 952 update_properties_after_pass (void *data)
 953 {
 954   struct tree_opt_pass *pass = data;
 955   cfun->curr_properties = (cfun->curr_properties | pass->properties_provided)
 956                            & ~pass->properties_destroyed;
 957 }
 958
 959 static bool
 960 execute_one_pass (struct tree_opt_pass *pass)
 961 {
 962   bool initializing_dump;
 963   unsigned int todo_after = 0;
 964
 965   /* See if we're supposed to run this pass.  */
 966   if (pass->gate && !pass->gate ())
 967     return false;
 968
 969   if (!quiet_flag && !cfun)
 970     fprintf (stderr, " <%s>", pass->name ? pass->name : "");
 971
 972   if (pass->todo_flags_start & TODO_set_props)
 973     cfun->curr_properties = pass->properties_required;
 974
 975   /* Note that the folders should only create gimple expressions.
 976      This is a hack until the new folder is ready.  */
 977   in_gimple_form = (cfun && (cfun->curr_properties & PROP_trees)) != 0;
 978
 979   /* Run pre-pass verification.  */
 980   execute_todo (pass->todo_flags_start);
 981
 982 #ifdef ENABLE_CHECKING
 983   do_per_function (verify_curr_properties,
 984                    (void *)(size_t)pass->properties_required);
 985 #endif
 986
 987   /* If a dump file name is present, open it if enabled.  */
 988   if (pass->static_pass_number != -1)
 989     {
 990       initializing_dump = !dump_initialized_p (pass->static_pass_number);
 991       dump_file_name = get_dump_file_name (pass->static_pass_number);
 992       dump_file = dump_begin (pass->static_pass_number, &dump_flags);
 993       if (dump_file && current_function_decl)
 994         {
 995           const char *dname, *aname;
 996           dname = lang_hooks.decl_printable_name (current_function_decl, 2);
 997           aname = (IDENTIFIER_POINTER
 998                    (DECL_ASSEMBLER_NAME (current_function_decl)));
 999           fprintf (dump_file, "\n;; Function %s (%s)%s\n\n", dname, aname,
1000              cfun->function_frequency == FUNCTION_FREQUENCY_HOT
1001              ? " (hot)"
1002              : cfun->function_frequency == FUNCTION_FREQUENCY_UNLIKELY_EXECUTED
1003              ? " (unlikely executed)"
1004              : "");
1005         }
1006     }
1007   else
1008     initializing_dump = false;
1009
1010   /* If a timevar is present, start it.  */
1011   if (pass->tv_id)
1012     timevar_push (pass->tv_id);
1013
1014   /* Do it!  */
1015   if (pass->execute)
1016     {
1017       todo_after = pass->execute ();
1018       do_per_function (clear_last_verified, NULL);
1019     }
1020
1021   /* Stop timevar.  */
1022   if (pass->tv_id)
1023     timevar_pop (pass->tv_id);
1024
1025   do_per_function (update_properties_after_pass, pass);
1026
1027   if (initializing_dump
1028       && dump_file
1029       && graph_dump_format != no_graph
1030       && (cfun->curr_properties & (PROP_cfg | PROP_rtl))
1031           == (PROP_cfg | PROP_rtl))
1032     {
1033       get_dump_file_info (pass->static_pass_number)->flags |= TDF_GRAPH;
1034       dump_flags |= TDF_GRAPH;
1035       clean_graph_dump_file (dump_file_name);
1036     }
1037
1038   /* Run post-pass cleanup and verification.  */
1039   execute_todo (todo_after | pass->todo_flags_finish);
1040
1041   if (!current_function_decl)
1042     cgraph_process_new_functions ();
1043
1044   /* Flush and close dump file.  */
1045   if (dump_file_name)
1046     {
1047       free ((char *) dump_file_name);
1048       dump_file_name = NULL;
1049     }
1050
1051   if (dump_file)
1052     {
1053       dump_end (pass->static_pass_number, dump_file);
1054       dump_file = NULL;
1055     }
1056
1057   return true;
1058 }
1059
1060 void
1061 execute_pass_list (struct tree_opt_pass *pass)
1062 {
1063   do
1064     {
1065       if (execute_one_pass (pass) && pass->sub)
1066         execute_pass_list (pass->sub);
1067       pass = pass->next;
1068     }
1069   while (pass);
1070 }
1071
1072 /* Same as execute_pass_list but assume that subpasses of IPA passes
1073    are local passes.  */
1074 void
1075 execute_ipa_pass_list (struct tree_opt_pass *pass)
1076 {
1077   do
1078     {
1079       gcc_assert (!current_function_decl);
1080       gcc_assert (!cfun);
1081       if (execute_one_pass (pass) && pass->sub)
1082         do_per_function_toporder ((void (*)(void *))execute_pass_list,
1083                                   pass->sub);
1084       if (!current_function_decl)
1085         cgraph_process_new_functions ();
1086       pass = pass->next;
1087     }
1088   while (pass);
1089 }
1090 #include "gt-passes.h"