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, 2007
   4    Free Software Foundation, Inc.
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 2, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING.  If not, write to the Free
  20 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
  21 02110-1301, USA.  */
  22
  23 /* This is the top level of cc1/c++.
  24    It parses command args, opens files, invokes the various passes
  25    in the proper order, and counts the time used by each.
  26    Error messages and low-level interface to malloc also handled here.  */
  27
  28 #include "config.h"
  29 #undef FLOAT /* This is for hpux. They should change hpux.  */
  30 #undef FFS  /* Some systems define this in param.h.  */
  31 #include "system.h"
  32 #include "coretypes.h"
  33 #include "tm.h"
  34 #include <signal.h>
  35
  36 #ifdef HAVE_SYS_RESOURCE_H
  37 # include <sys/resource.h>
  38 #endif
  39
  40 #ifdef HAVE_SYS_TIMES_H
  41 # include <sys/times.h>
  42 #endif
  43
  44 #include "line-map.h"
  45 #include "input.h"
  46 #include "tree.h"
  47 #include "rtl.h"
  48 #include "tm_p.h"
  49 #include "flags.h"
  50 #include "insn-attr.h"
  51 #include "insn-config.h"
  52 #include "insn-flags.h"
  53 #include "hard-reg-set.h"
  54 #include "recog.h"
  55 #include "output.h"
  56 #include "except.h"
  57 #include "function.h"
  58 #include "toplev.h"
  59 #include "expr.h"
  60 #include "basic-block.h"
  61 #include "intl.h"
  62 #include "ggc.h"
  63 #include "graph.h"
  64 #include "regs.h"
  65 #include "timevar.h"
  66 #include "diagnostic.h"
  67 #include "params.h"
  68 #include "reload.h"
  69 #include "dwarf2asm.h"
  70 #include "integrate.h"
  71 #include "real.h"
  72 #include "debug.h"
  73 #include "target.h"
  74 #include "langhooks.h"
  75 #include "cfglayout.h"
  76 #include "cfgloop.h"
  77 #include "hosthooks.h"
  78 #include "cgraph.h"
  79 #include "opts.h"
  80 #include "coverage.h"
  81 #include "value-prof.h"
  82 #include "tree-inline.h"
  83 #include "tree-flow.h"
  84 #include "tree-pass.h"
  85 #include "tree-dump.h"
  86 #include "predict.h"
  87
  88 #if defined (DWARF2_UNWIND_INFO) || defined (DWARF2_DEBUGGING_INFO)
  89 #include "dwarf2out.h"
  90 #endif
  91
  92 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
  93 #include "dbxout.h"
  94 #endif
  95
  96 #ifdef SDB_DEBUGGING_INFO
  97 #include "sdbout.h"
  98 #endif
  99
 100 #ifdef XCOFF_DEBUGGING_INFO
 101 #include "xcoffout.h"           /* Needed for external data
 102                                    declarations for e.g. AIX 4.x.  */
 103 #endif
 104
 105 /* Global variables used to communicate with passes.  */
 106 int dump_flags;
 107 bool in_gimple_form;
 108
 109
 110 /* This is called from various places for FUNCTION_DECL, VAR_DECL,
 111    and TYPE_DECL nodes.
 112
 113    This does nothing for local (non-static) variables, unless the
 114    variable is a register variable with DECL_ASSEMBLER_NAME set.  In
 115    that case, or if the variable is not an automatic, it sets up the
 116    RTL and outputs any assembler code (label definition, storage
 117    allocation and initialization).
 118
 119    DECL is the declaration.  TOP_LEVEL is nonzero
 120    if this declaration is not within a function.  */
 121
 122 void
 123 rest_of_decl_compilation (tree decl,
 124                           int top_level,
 125                           int at_end)
 126 {
 127   /* We deferred calling assemble_alias so that we could collect
 128      other attributes such as visibility.  Emit the alias now.  */
 129   {
 130     tree alias;
 131     alias = lookup_attribute ("alias", DECL_ATTRIBUTES (decl));
 132     if (alias)
 133       {
 134         alias = TREE_VALUE (TREE_VALUE (alias));
 135         alias = get_identifier (TREE_STRING_POINTER (alias));
 136         assemble_alias (decl, alias);
 137       }
 138   }
 139
 140   /* Can't defer this, because it needs to happen before any
 141      later function definitions are processed.  */
 142   if (DECL_ASSEMBLER_NAME_SET_P (decl) && DECL_REGISTER (decl))
 143     make_decl_rtl (decl);
 144
 145   /* Forward declarations for nested functions are not "external",
 146      but we need to treat them as if they were.  */
 147   if (TREE_STATIC (decl) || DECL_EXTERNAL (decl)
 148       || TREE_CODE (decl) == FUNCTION_DECL)
 149     {
 150       timevar_push (TV_VARCONST);
 151
 152       /* Don't output anything when a tentative file-scope definition
 153          is seen.  But at end of compilation, do output code for them.
 154
 155          We do output all variables when unit-at-a-time is active and rely on
 156          callgraph code to defer them except for forward declarations
 157          (see gcc.c-torture/compile/920624-1.c) */
 158       if ((at_end
 159            || !DECL_DEFER_OUTPUT (decl)
 160            || DECL_INITIAL (decl))
 161           && !DECL_EXTERNAL (decl))
 162         {
 163           if (TREE_CODE (decl) != FUNCTION_DECL)
 164             varpool_finalize_decl (decl);
 165           else
 166             assemble_variable (decl, top_level, at_end, 0);
 167         }
 168
 169 #ifdef ASM_FINISH_DECLARE_OBJECT
 170       if (decl == last_assemble_variable_decl)
 171         {
 172           ASM_FINISH_DECLARE_OBJECT (asm_out_file, decl,
 173                                      top_level, at_end);
 174         }
 175 #endif
 176
 177       timevar_pop (TV_VARCONST);
 178     }
 179   else if (TREE_CODE (decl) == TYPE_DECL
 180            /* Like in rest_of_type_compilation, avoid confusing the debug
 181               information machinery when there are errors.  */
 182            && !(sorrycount || errorcount))
 183     {
 184       timevar_push (TV_SYMOUT);
 185       debug_hooks->type_decl (decl, !top_level);
 186       timevar_pop (TV_SYMOUT);
 187     }
 188
 189   /* Let cgraph know about the existence of variables.  */
 190   if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl))
 191     varpool_node (decl);
 192 }
 193
 194 /* Called after finishing a record, union or enumeral type.  */
 195
 196 void
 197 rest_of_type_compilation (tree type, int toplev)
 198 {
 199   /* Avoid confusing the debug information machinery when there are
 200      errors.  */
 201   if (errorcount != 0 || sorrycount != 0)
 202     return;
 203
 204   timevar_push (TV_SYMOUT);
 205   debug_hooks->type_decl (TYPE_STUB_DECL (type), !toplev);
 206   timevar_pop (TV_SYMOUT);
 207 }
 208
 209 \f
 210
 211 void
 212 finish_optimization_passes (void)
 213 {
 214   enum tree_dump_index i;
 215   struct dump_file_info *dfi;
 216   char *name;
 217
 218   timevar_push (TV_DUMP);
 219   if (profile_arc_flag || flag_test_coverage || flag_branch_probabilities)
 220     {
 221       dump_file = dump_begin (pass_profile.static_pass_number, NULL);
 222       end_branch_prob ();
 223       if (dump_file)
 224         dump_end (pass_profile.static_pass_number, dump_file);
 225     }
 226
 227   if (optimize > 0)
 228     {
 229       dump_file = dump_begin (pass_combine.static_pass_number, NULL);
 230       if (dump_file)
 231         {
 232           dump_combine_total_stats (dump_file);
 233           dump_end (pass_combine.static_pass_number, dump_file);
 234         }
 235     }
 236
 237   /* Do whatever is necessary to finish printing the graphs.  */
 238   if (graph_dump_format != no_graph)
 239     for (i = TDI_end; (dfi = get_dump_file_info (i)) != NULL; ++i)
 240       if (dump_initialized_p (i)
 241           && (dfi->flags & TDF_GRAPH) != 0
 242           && (name = get_dump_file_name (i)) != NULL)
 243         {
 244           finish_graph_dump_file (name);
 245           free (name);
 246         }
 247
 248   timevar_pop (TV_DUMP);
 249 }
 250
 251 static bool
 252 gate_rest_of_compilation (void)
 253 {
 254   /* Early return if there were errors.  We can run afoul of our
 255      consistency checks, and there's not really much point in fixing them.  */
 256   return !(rtl_dump_and_exit || flag_syntax_only || errorcount || sorrycount);
 257 }
 258
 259 struct tree_opt_pass pass_rest_of_compilation =
 260 {
 261   NULL,                                 /* name */
 262   gate_rest_of_compilation,             /* gate */
 263   NULL,                                 /* execute */
 264   NULL,                                 /* sub */
 265   NULL,                                 /* next */
 266   0,                                    /* static_pass_number */
 267   TV_REST_OF_COMPILATION,               /* tv_id */
 268   PROP_rtl,                             /* properties_required */
 269   0,                                    /* properties_provided */
 270   0,                                    /* properties_destroyed */
 271   0,                                    /* todo_flags_start */
 272   TODO_ggc_collect,                     /* todo_flags_finish */
 273   0                                     /* letter */
 274 };
 275
 276 static bool
 277 gate_postreload (void)
 278 {
 279   return reload_completed;
 280 }
 281
 282 struct tree_opt_pass pass_postreload =
 283 {
 284   NULL,                                 /* name */
 285   gate_postreload,                      /* gate */
 286   NULL,                                 /* execute */
 287   NULL,                                 /* sub */
 288   NULL,                                 /* next */
 289   0,                                    /* static_pass_number */
 290   0,                                    /* tv_id */
 291   PROP_rtl,                             /* properties_required */
 292   0,                                    /* properties_provided */
 293   0,                                    /* properties_destroyed */
 294   0,                                    /* todo_flags_start */
 295   TODO_ggc_collect,                     /* todo_flags_finish */
 296   0                                     /* letter */
 297 };
 298
 299
 300
 301 /* The root of the compilation pass tree, once constructed.  */
 302 struct tree_opt_pass *all_passes, *all_ipa_passes, *all_lowering_passes;
 303
 304 /* Iterate over the pass tree allocating dump file numbers.  We want
 305    to do this depth first, and independent of whether the pass is
 306    enabled or not.  */
 307
 308 static void
 309 register_one_dump_file (struct tree_opt_pass *pass, bool ipa, int properties)
 310 {
 311   char *dot_name, *flag_name, *glob_name;
 312   const char *prefix;
 313   char num[10];
 314   int flags;
 315
 316   /* See below in next_pass_1.  */
 317   num[0] = '\0';
 318   if (pass->static_pass_number != -1)
 319     sprintf (num, "%d", ((int) pass->static_pass_number < 0
 320                          ? 1 : pass->static_pass_number));
 321
 322   dot_name = concat (".", pass->name, num, NULL);
 323   if (ipa)
 324     prefix = "ipa-", flags = TDF_IPA;
 325   else if (properties & PROP_trees)
 326     prefix = "tree-", flags = TDF_TREE;
 327   else
 328     prefix = "rtl-", flags = TDF_RTL;
 329
 330   flag_name = concat (prefix, pass->name, num, NULL);
 331   glob_name = concat (prefix, pass->name, NULL);
 332   pass->static_pass_number = dump_register (dot_name, flag_name, glob_name,
 333                                             flags, pass->letter);
 334 }
 335
 336 /* Recursive worker function for register_dump_files.  */
 337
 338 static int
 339 register_dump_files_1 (struct tree_opt_pass *pass, bool ipa, int properties)
 340 {
 341   do
 342     {
 343       int new_properties = (properties | pass->properties_provided)
 344                            & ~pass->properties_destroyed;
 345
 346       if (pass->name)
 347         register_one_dump_file (pass, ipa, new_properties);
 348
 349       if (pass->sub)
 350         new_properties = register_dump_files_1 (pass->sub, false,
 351                                                 new_properties);
 352
 353       /* If we have a gate, combine the properties that we could have with
 354          and without the pass being examined.  */
 355       if (pass->gate)
 356         properties &= new_properties;
 357       else
 358         properties = new_properties;
 359
 360       pass = pass->next;
 361     }
 362   while (pass);
 363
 364   return properties;
 365 }
 366
 367 /* Register the dump files for the pipeline starting at PASS.  IPA is
 368    true if the pass is inter-procedural, and PROPERTIES reflects the
 369    properties that are guaranteed to be available at the beginning of
 370    the pipeline.  */
 371
 372 static void
 373 register_dump_files (struct tree_opt_pass *pass, bool ipa, int properties)
 374 {
 375   pass->properties_required |= properties;
 376   register_dump_files_1 (pass, ipa, properties);
 377 }
 378
 379 /* Add a pass to the pass list. Duplicate the pass if it's already
 380    in the list.  */
 381
 382 static struct tree_opt_pass **
 383 next_pass_1 (struct tree_opt_pass **list, struct tree_opt_pass *pass)
 384 {
 385   /* A nonzero static_pass_number indicates that the
 386      pass is already in the list.  */
 387   if (pass->static_pass_number)
 388     {
 389       struct tree_opt_pass *new;
 390
 391       new = xmalloc (sizeof (*new));
 392       memcpy (new, pass, sizeof (*new));
 393       new->next = NULL;
 394
 395       /* Indicate to register_dump_files that this pass has duplicates,
 396          and so it should rename the dump file.  The first instance will
 397          be -1, and be number of duplicates = -static_pass_number - 1.
 398          Subsequent instances will be > 0 and just the duplicate number.  */
 399       if (pass->name)
 400         {
 401           pass->static_pass_number -= 1;
 402           new->static_pass_number = -pass->static_pass_number;
 403         }
 404
 405       *list = new;
 406     }
 407   else
 408     {
 409       pass->static_pass_number = -1;
 410       *list = pass;
 411     }
 412
 413   return &(*list)->next;
 414
 415 }
 416
 417 /* Construct the pass tree.  The sequencing of passes is driven by
 418    the cgraph routines:
 419
 420    cgraph_finalize_compilation_unit ()
 421        for each node N in the cgraph
 422            cgraph_analyze_function (N)
 423                cgraph_lower_function (N) -> all_lowering_passes
 424
 425    If we are optimizing, cgraph_optimize is then invoked:
 426
 427    cgraph_optimize ()
 428        ipa_passes ()                    -> all_ipa_passes
 429        cgraph_expand_all_functions ()
 430            for each node N in the cgraph
 431                cgraph_expand_function (N)
 432                    lang_hooks.callgraph.expand_function (DECL (N))
 433                         tree_rest_of_compilation (DECL (N))  -> all_passes
 434 */
 435
 436 void
 437 init_optimization_passes (void)
 438 {
 439   struct tree_opt_pass **p;
 440
 441 #define NEXT_PASS(PASS)  (p = next_pass_1 (p, &PASS))
 442
 443  /* All passes needed to lower the function into shape optimizers can
 444     operate on.  These passes are always run first on the function, but
 445     backend might produce already lowered functions that are not processed
 446     by these passes.  */
 447   p = &all_lowering_passes;
 448   NEXT_PASS (pass_remove_useless_stmts);
 449   NEXT_PASS (pass_mudflap_1);
 450   NEXT_PASS (pass_lower_omp);
 451   NEXT_PASS (pass_lower_cf);
 452   NEXT_PASS (pass_lower_eh);
 453   NEXT_PASS (pass_build_cfg);
 454   NEXT_PASS (pass_lower_complex_O0);
 455   NEXT_PASS (pass_lower_vector);
 456   NEXT_PASS (pass_warn_function_return);
 457   NEXT_PASS (pass_build_cgraph_edges);
 458   NEXT_PASS (pass_inline_parameters);
 459   *p = NULL;
 460
 461   /* Interprocedural optimization passes.
 462      All these passes are ignored in -fno-unit-at-a-time
 463      except for subpases of early_local_pases.  */
 464   p = &all_ipa_passes;
 465   NEXT_PASS (pass_ipa_function_and_variable_visibility);
 466   NEXT_PASS (pass_ipa_early_inline);
 467     {
 468       struct tree_opt_pass **p = &pass_ipa_early_inline.sub;
 469       NEXT_PASS (pass_early_inline);
 470       NEXT_PASS (pass_inline_parameters);
 471       NEXT_PASS (pass_rebuild_cgraph_edges);
 472     }
 473   NEXT_PASS (pass_early_local_passes);
 474     {
 475       struct tree_opt_pass **p = &pass_early_local_passes.sub;
 476       NEXT_PASS (pass_tree_profile);
 477       NEXT_PASS (pass_cleanup_cfg);
 478       NEXT_PASS (pass_init_datastructures);
 479       NEXT_PASS (pass_expand_omp);
 480       NEXT_PASS (pass_all_early_optimizations);
 481         {
 482           struct tree_opt_pass **p = &pass_all_early_optimizations.sub;
 483           NEXT_PASS (pass_referenced_vars);
 484           NEXT_PASS (pass_reset_cc_flags);
 485           NEXT_PASS (pass_build_ssa);
 486           NEXT_PASS (pass_early_warn_uninitialized);
 487           NEXT_PASS (pass_rebuild_cgraph_edges);
 488           NEXT_PASS (pass_early_inline);
 489           NEXT_PASS (pass_cleanup_cfg);
 490           NEXT_PASS (pass_rename_ssa_copies);
 491           NEXT_PASS (pass_ccp);
 492           NEXT_PASS (pass_forwprop);
 493           NEXT_PASS (pass_sra_early);
 494           NEXT_PASS (pass_copy_prop);
 495           NEXT_PASS (pass_merge_phi);
 496           NEXT_PASS (pass_dce);
 497           NEXT_PASS (pass_tail_recursion);
 498           NEXT_PASS (pass_profile);
 499           NEXT_PASS (pass_release_ssa_names);
 500         }
 501       NEXT_PASS (pass_rebuild_cgraph_edges);
 502       NEXT_PASS (pass_inline_parameters);
 503     }
 504   NEXT_PASS (pass_ipa_increase_alignment);
 505   NEXT_PASS (pass_ipa_cp);
 506   NEXT_PASS (pass_ipa_inline);
 507   NEXT_PASS (pass_ipa_reference);
 508   NEXT_PASS (pass_ipa_pure_const);
 509   NEXT_PASS (pass_ipa_type_escape);
 510   NEXT_PASS (pass_ipa_pta);
 511   *p = NULL;
 512
 513   /* These passes are run after IPA passes on every function that is being
 514      output to the assembler file.  */
 515   p = &all_passes;
 516   NEXT_PASS (pass_apply_inline);
 517   NEXT_PASS (pass_all_optimizations);
 518     {
 519       struct tree_opt_pass **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
 525       /* Initial scalar cleanups.  */
 526       NEXT_PASS (pass_ccp);
 527       NEXT_PASS (pass_fre);
 528       NEXT_PASS (pass_dce);
 529       NEXT_PASS (pass_forwprop);
 530       NEXT_PASS (pass_copy_prop);
 531       NEXT_PASS (pass_merge_phi);
 532       NEXT_PASS (pass_vrp);
 533       NEXT_PASS (pass_dce);
 534       NEXT_PASS (pass_dominator);
 535
 536       /* The only const/copy propagation opportunities left after
 537          DOM should be due to degenerate PHI nodes.  So rather than
 538          run the full propagators, run a specialized pass which
 539          only examines PHIs to discover const/copy propagation
 540          opportunities.  */
 541       NEXT_PASS (pass_phi_only_cprop);
 542
 543       NEXT_PASS (pass_phiopt);
 544       NEXT_PASS (pass_may_alias);
 545       NEXT_PASS (pass_tail_recursion);
 546       NEXT_PASS (pass_ch);
 547       NEXT_PASS (pass_stdarg);
 548       NEXT_PASS (pass_lower_complex);
 549       NEXT_PASS (pass_sra);
 550       /* FIXME: SRA may generate arbitrary gimple code, exposing new
 551          aliased and call-clobbered variables.  As mentioned below,
 552          pass_may_alias should be a TODO item.  */
 553       NEXT_PASS (pass_may_alias);
 554       NEXT_PASS (pass_rename_ssa_copies);
 555       NEXT_PASS (pass_dominator);
 556
 557       /* The only const/copy propagation opportunities left after
 558          DOM should be due to degenerate PHI nodes.  So rather than
 559          run the full propagators, run a specialized pass which
 560          only examines PHIs to discover const/copy propagation
 561          opportunities.  */
 562       NEXT_PASS (pass_phi_only_cprop);
 563
 564       NEXT_PASS (pass_reassoc);
 565       NEXT_PASS (pass_dce);
 566       NEXT_PASS (pass_dse);
 567       NEXT_PASS (pass_may_alias);
 568       NEXT_PASS (pass_forwprop);
 569       NEXT_PASS (pass_phiopt);
 570       NEXT_PASS (pass_object_sizes);
 571       NEXT_PASS (pass_store_ccp);
 572       NEXT_PASS (pass_store_copy_prop);
 573       NEXT_PASS (pass_fold_builtins);
 574       NEXT_PASS (pass_cse_sincos);
 575       /* FIXME: May alias should a TODO but for 4.0.0,
 576          we add may_alias right after fold builtins
 577          which can create arbitrary GIMPLE.  */
 578       NEXT_PASS (pass_may_alias);
 579       NEXT_PASS (pass_split_crit_edges);
 580       NEXT_PASS (pass_pre);
 581       NEXT_PASS (pass_may_alias);
 582       NEXT_PASS (pass_sink_code);
 583       NEXT_PASS (pass_tree_loop);
 584         {
 585           struct tree_opt_pass **p = &pass_tree_loop.sub;
 586           NEXT_PASS (pass_tree_loop_init);
 587           NEXT_PASS (pass_copy_prop);
 588           NEXT_PASS (pass_lim);
 589           NEXT_PASS (pass_tree_unswitch);
 590           NEXT_PASS (pass_scev_cprop);
 591           NEXT_PASS (pass_empty_loop);
 592           NEXT_PASS (pass_record_bounds);
 593           NEXT_PASS (pass_linear_transform);
 594           NEXT_PASS (pass_iv_canon);
 595           NEXT_PASS (pass_if_conversion);
 596           NEXT_PASS (pass_vectorize);
 597             {
 598               struct tree_opt_pass **p = &pass_vectorize.sub;
 599               NEXT_PASS (pass_lower_vector_ssa);
 600               NEXT_PASS (pass_dce_loop);
 601             }
 602           /* NEXT_PASS (pass_may_alias) cannot be done again because the
 603              vectorizer creates alias relations that are not supported by
 604              pass_may_alias.  */
 605           NEXT_PASS (pass_complete_unroll);
 606           NEXT_PASS (pass_loop_prefetch);
 607           NEXT_PASS (pass_iv_optimize);
 608           NEXT_PASS (pass_tree_loop_done);
 609         }
 610       NEXT_PASS (pass_cse_reciprocals);
 611       NEXT_PASS (pass_reassoc);
 612       NEXT_PASS (pass_vrp);
 613       NEXT_PASS (pass_dominator);
 614
 615       /* The only const/copy propagation opportunities left after
 616          DOM should be due to degenerate PHI nodes.  So rather than
 617          run the full propagators, run a specialized pass which
 618          only examines PHIs to discover const/copy propagation
 619          opportunities.  */
 620       NEXT_PASS (pass_phi_only_cprop);
 621
 622       NEXT_PASS (pass_cd_dce);
 623
 624       /* FIXME: If DCE is not run before checking for uninitialized uses,
 625          we may get false warnings (e.g., testsuite/gcc.dg/uninit-5.c).
 626          However, this also causes us to misdiagnose cases that should be
 627          real warnings (e.g., testsuite/gcc.dg/pr18501.c).
 628
 629          To fix the false positives in uninit-5.c, we would have to
 630          account for the predicates protecting the set and the use of each
 631          variable.  Using a representation like Gated Single Assignment
 632          may help.  */
 633       NEXT_PASS (pass_late_warn_uninitialized);
 634       NEXT_PASS (pass_dse);
 635       NEXT_PASS (pass_forwprop);
 636       NEXT_PASS (pass_phiopt);
 637       NEXT_PASS (pass_tail_calls);
 638       NEXT_PASS (pass_rename_ssa_copies);
 639       NEXT_PASS (pass_uncprop);
 640       NEXT_PASS (pass_del_ssa);
 641       NEXT_PASS (pass_nrv);
 642       NEXT_PASS (pass_mark_used_blocks);
 643       NEXT_PASS (pass_cleanup_cfg_post_optimizing);
 644     }
 645   NEXT_PASS (pass_warn_function_noreturn);
 646   NEXT_PASS (pass_free_datastructures);
 647   NEXT_PASS (pass_mudflap_2);
 648   NEXT_PASS (pass_free_cfg_annotations);
 649   NEXT_PASS (pass_expand);
 650   NEXT_PASS (pass_rest_of_compilation);
 651     {
 652       struct tree_opt_pass **p = &pass_rest_of_compilation.sub;
 653       NEXT_PASS (pass_init_function);
 654       NEXT_PASS (pass_jump);
 655       NEXT_PASS (pass_insn_locators_initialize);
 656       NEXT_PASS (pass_rtl_eh);
 657       NEXT_PASS (pass_initial_value_sets);
 658       NEXT_PASS (pass_unshare_all_rtl);
 659       NEXT_PASS (pass_instantiate_virtual_regs);
 660       NEXT_PASS (pass_jump2);
 661       NEXT_PASS (pass_lower_subreg);
 662       NEXT_PASS (pass_cse);
 663       NEXT_PASS (pass_rtl_fwprop);
 664       NEXT_PASS (pass_gcse);
 665       NEXT_PASS (pass_jump_bypass);
 666       NEXT_PASS (pass_rtl_ifcvt);
 667       NEXT_PASS (pass_tracer);
 668       /* Perform loop optimizations.  It might be better to do them a bit
 669          sooner, but we want the profile feedback to work more
 670          efficiently.  */
 671       NEXT_PASS (pass_loop2);
 672         {
 673           struct tree_opt_pass **p = &pass_loop2.sub;
 674           NEXT_PASS (pass_rtl_loop_init);
 675           NEXT_PASS (pass_rtl_move_loop_invariants);
 676           NEXT_PASS (pass_rtl_unswitch);
 677           NEXT_PASS (pass_rtl_unroll_and_peel_loops);
 678           NEXT_PASS (pass_rtl_doloop);
 679           NEXT_PASS (pass_rtl_loop_done);
 680           *p = NULL;
 681         }
 682       NEXT_PASS (pass_web);
 683       NEXT_PASS (pass_cse2);
 684       NEXT_PASS (pass_rtl_fwprop_addr);
 685       NEXT_PASS (pass_life);
 686       NEXT_PASS (pass_combine);
 687       NEXT_PASS (pass_if_after_combine);
 688       NEXT_PASS (pass_partition_blocks);
 689       NEXT_PASS (pass_regmove);
 690       NEXT_PASS (pass_split_all_insns);
 691       NEXT_PASS (pass_lower_subreg2);
 692       NEXT_PASS (pass_mode_switching);
 693       NEXT_PASS (pass_see);
 694       NEXT_PASS (pass_recompute_reg_usage);
 695       NEXT_PASS (pass_sms);
 696       NEXT_PASS (pass_sched);
 697       NEXT_PASS (pass_local_alloc);
 698       NEXT_PASS (pass_global_alloc);
 699       NEXT_PASS (pass_postreload);
 700         {
 701           struct tree_opt_pass **p = &pass_postreload.sub;
 702           NEXT_PASS (pass_postreload_cse);
 703           NEXT_PASS (pass_gcse2);
 704           NEXT_PASS (pass_flow2);
 705           NEXT_PASS (pass_rtl_seqabstr);
 706           NEXT_PASS (pass_stack_adjustments);
 707           NEXT_PASS (pass_peephole2);
 708           NEXT_PASS (pass_if_after_reload);
 709           NEXT_PASS (pass_regrename);
 710           NEXT_PASS (pass_reorder_blocks);
 711           NEXT_PASS (pass_branch_target_load_optimize);
 712           NEXT_PASS (pass_leaf_regs);
 713           NEXT_PASS (pass_sched2);
 714           NEXT_PASS (pass_split_before_regstack);
 715           NEXT_PASS (pass_stack_regs);
 716           NEXT_PASS (pass_compute_alignments);
 717           NEXT_PASS (pass_duplicate_computed_gotos);
 718           NEXT_PASS (pass_variable_tracking);
 719           NEXT_PASS (pass_free_cfg);
 720           NEXT_PASS (pass_machine_reorg);
 721           NEXT_PASS (pass_cleanup_barriers);
 722           NEXT_PASS (pass_delay_slots);
 723           NEXT_PASS (pass_split_for_shorten_branches);
 724           NEXT_PASS (pass_convert_to_eh_region_ranges);
 725           NEXT_PASS (pass_shorten_branches);
 726           NEXT_PASS (pass_set_nothrow_function_flags);
 727           NEXT_PASS (pass_final);
 728         }
 729     }
 730   NEXT_PASS (pass_clean_state);
 731   *p = NULL;
 732
 733 #undef NEXT_PASS
 734
 735   /* Register the passes with the tree dump code.  */
 736   register_dump_files (all_lowering_passes, false, PROP_gimple_any);
 737   all_lowering_passes->todo_flags_start |= TODO_set_props;
 738   register_dump_files (all_ipa_passes, true,
 739                        PROP_gimple_any | PROP_gimple_lcf | PROP_gimple_leh
 740                        | PROP_cfg);
 741   register_dump_files (all_passes, false,
 742                        PROP_gimple_any | PROP_gimple_lcf | PROP_gimple_leh
 743                        | PROP_cfg);
 744 }
 745
 746 /* If we are in IPA mode (i.e., current_function_decl is NULL), call
 747    function CALLBACK for every function in the call graph.  Otherwise,
 748    call CALLBACK on the current function.  */
 749
 750 static void
 751 do_per_function (void (*callback) (void *data), void *data)
 752 {
 753   if (current_function_decl)
 754     callback (data);
 755   else
 756     {
 757       struct cgraph_node *node;
 758       for (node = cgraph_nodes; node; node = node->next)
 759         if (node->analyzed)
 760           {
 761             push_cfun (DECL_STRUCT_FUNCTION (node->decl));
 762             current_function_decl = node->decl;
 763             callback (data);
 764             free_dominance_info (CDI_DOMINATORS);
 765             free_dominance_info (CDI_POST_DOMINATORS);
 766             current_function_decl = NULL;
 767             pop_cfun ();
 768             ggc_collect ();
 769           }
 770     }
 771 }
 772
 773 /* Because inlining might remove no-longer reachable nodes, we need to
 774    keep the array visible to garbage collector to avoid reading collected
 775    out nodes.  */
 776 static int nnodes;
 777 static GTY ((length ("nnodes"))) struct cgraph_node **order;
 778
 779 /* If we are in IPA mode (i.e., current_function_decl is NULL), call
 780    function CALLBACK for every function in the call graph.  Otherwise,
 781    call CALLBACK on the current function.  */
 782
 783 static void
 784 do_per_function_toporder (void (*callback) (void *data), void *data)
 785 {
 786   int i;
 787
 788   if (current_function_decl)
 789     callback (data);
 790   else
 791     {
 792       gcc_assert (!order);
 793       order = ggc_alloc (sizeof (*order) * cgraph_n_nodes);
 794       nnodes = cgraph_postorder (order);
 795       for (i = nnodes - 1; i >= 0; i--)
 796         {
 797           struct cgraph_node *node = order[i];
 798
 799           /* Allow possibly removed nodes to be garbage collected.  */
 800           order[i] = NULL;
 801           if (node->analyzed && (node->needed || node->reachable))
 802             {
 803               push_cfun (DECL_STRUCT_FUNCTION (node->decl));
 804               current_function_decl = node->decl;
 805               callback (data);
 806               free_dominance_info (CDI_DOMINATORS);
 807               free_dominance_info (CDI_POST_DOMINATORS);
 808               current_function_decl = NULL;
 809               pop_cfun ();
 810               ggc_collect ();
 811             }
 812         }
 813     }
 814   ggc_free (order);
 815   order = NULL;
 816   nnodes = 0;
 817 }
 818
 819 /* Perform all TODO actions that ought to be done on each function.  */
 820
 821 static void
 822 execute_function_todo (void *data)
 823 {
 824   unsigned int flags = (size_t)data;
 825   if (cfun->curr_properties & PROP_ssa)
 826     flags |= TODO_verify_ssa;
 827   flags &= ~cfun->last_verified;
 828   if (!flags)
 829     return;
 830
 831   /* Always cleanup the CFG before trying to update SSA.  */
 832   if (flags & TODO_cleanup_cfg)
 833     {
 834       bool cleanup;
 835
 836       if (current_loops)
 837         cleanup = cleanup_tree_cfg_loop ();
 838       else
 839         cleanup = cleanup_tree_cfg ();
 840
 841       if (cleanup && (cfun->curr_properties & PROP_ssa))
 842         flags |= TODO_remove_unused_locals;
 843
 844       /* When cleanup_tree_cfg merges consecutive blocks, it may
 845          perform some simplistic propagation when removing single
 846          valued PHI nodes.  This propagation may, in turn, cause the
 847          SSA form to become out-of-date (see PR 22037).  So, even
 848          if the parent pass had not scheduled an SSA update, we may
 849          still need to do one.  */
 850       if (!(flags & TODO_update_ssa_any) && need_ssa_update_p ())
 851         flags |= TODO_update_ssa;
 852     }
 853
 854   if (flags & TODO_update_ssa_any)
 855     {
 856       unsigned update_flags = flags & TODO_update_ssa_any;
 857       update_ssa (update_flags);
 858       cfun->last_verified &= ~TODO_verify_ssa;
 859     }
 860
 861   if (flags & TODO_remove_unused_locals)
 862     remove_unused_locals ();
 863
 864   if ((flags & TODO_dump_func)
 865       && dump_file && current_function_decl)
 866     {
 867       if (cfun->curr_properties & PROP_trees)
 868         dump_function_to_file (current_function_decl,
 869                                dump_file, dump_flags);
 870       else
 871         {
 872           if (dump_flags & TDF_SLIM)
 873             print_rtl_slim_with_bb (dump_file, get_insns (), dump_flags);
 874           else if ((cfun->curr_properties & PROP_cfg)
 875                    && (dump_flags & TDF_BLOCKS))
 876             print_rtl_with_bb (dump_file, get_insns ());
 877           else
 878             print_rtl (dump_file, get_insns ());
 879
 880           if (cfun->curr_properties & PROP_cfg
 881               && graph_dump_format != no_graph
 882               && (dump_flags & TDF_GRAPH))
 883             print_rtl_graph_with_bb (dump_file_name, get_insns ());
 884         }
 885
 886       /* Flush the file.  If verification fails, we won't be able to
 887          close the file before aborting.  */
 888       fflush (dump_file);
 889     }
 890
 891   if (flags & TODO_rebuild_frequencies)
 892     {
 893       if (profile_status == PROFILE_GUESSED)
 894         {
 895           loop_optimizer_init (0);
 896           add_noreturn_fake_exit_edges ();
 897           mark_irreducible_loops ();
 898           connect_infinite_loops_to_exit ();
 899           estimate_bb_frequencies ();
 900           remove_fake_exit_edges ();
 901           loop_optimizer_finalize ();
 902         }
 903       else if (profile_status == PROFILE_READ)
 904         counts_to_freqs ();
 905       else
 906         gcc_unreachable ();
 907     }
 908
 909 #if defined ENABLE_CHECKING
 910   if (flags & TODO_verify_ssa)
 911     verify_ssa (true);
 912   if (flags & TODO_verify_flow)
 913     verify_flow_info ();
 914   if (flags & TODO_verify_stmts)
 915     verify_stmts ();
 916   if (flags & TODO_verify_loops)
 917     verify_loop_closed_ssa ();
 918 #endif
 919
 920   cfun->last_verified = flags & TODO_verify_all;
 921 }
 922
 923 /* Perform all TODO actions.  */
 924 static void
 925 execute_todo (unsigned int flags)
 926 {
 927 #if defined ENABLE_CHECKING
 928   if (need_ssa_update_p ())
 929     gcc_assert (flags & TODO_update_ssa_any);
 930 #endif
 931
 932   do_per_function (execute_function_todo, (void *)(size_t) flags);
 933
 934   /* Always remove functions just as before inlining: IPA passes might be
 935      interested to see bodies of extern inline functions that are not inlined
 936      to analyze side effects.  The full removal is done just at the end
 937      of IPA pass queue.  */
 938   if (flags & TODO_remove_functions)
 939     cgraph_remove_unreachable_nodes (true, dump_file);
 940
 941   if ((flags & TODO_dump_cgraph)
 942       && dump_file && !current_function_decl)
 943     {
 944       dump_cgraph (dump_file);
 945       /* Flush the file.  If verification fails, we won't be able to
 946          close the file before aborting.  */
 947       fflush (dump_file);
 948     }
 949
 950   if (flags & TODO_ggc_collect)
 951     {
 952       ggc_collect ();
 953     }
 954 }
 955
 956 /* Verify invariants that should hold between passes.  This is a place
 957    to put simple sanity checks.  */
 958
 959 static void
 960 verify_interpass_invariants (void)
 961 {
 962 #ifdef ENABLE_CHECKING
 963   gcc_assert (!fold_deferring_overflow_warnings_p ());
 964 #endif
 965 }
 966
 967 /* Clear the last verified flag.  */
 968
 969 static void
 970 clear_last_verified (void *data ATTRIBUTE_UNUSED)
 971 {
 972   cfun->last_verified = 0;
 973 }
 974
 975 /* Helper function. Verify that the properties has been turn into the
 976    properties expected by the pass.  */
 977
 978 #ifdef ENABLE_CHECKING
 979 static void
 980 verify_curr_properties (void *data)
 981 {
 982   unsigned int props = (size_t)data;
 983   gcc_assert ((cfun->curr_properties & props) == props);
 984 }
 985 #endif
 986
 987 /* After executing the pass, apply expected changes to the function
 988    properties. */
 989 static void
 990 update_properties_after_pass (void *data)
 991 {
 992   struct tree_opt_pass *pass = data;
 993   cfun->curr_properties = (cfun->curr_properties | pass->properties_provided)
 994                            & ~pass->properties_destroyed;
 995 }
 996
 997 static bool
 998 execute_one_pass (struct tree_opt_pass *pass)
 999 {
1000   bool initializing_dump;
1001   unsigned int todo_after = 0;
1002
1003   /* See if we're supposed to run this pass.  */
1004   if (pass->gate && !pass->gate ())
1005     return false;
1006
1007   if (!quiet_flag && !cfun)
1008     fprintf (stderr, " <%s>", pass->name ? pass->name : "");
1009
1010   if (pass->todo_flags_start & TODO_set_props)
1011     cfun->curr_properties = pass->properties_required;
1012
1013   /* Note that the folders should only create gimple expressions.
1014      This is a hack until the new folder is ready.  */
1015   in_gimple_form = (cfun && (cfun->curr_properties & PROP_trees)) != 0;
1016
1017   /* Run pre-pass verification.  */
1018   execute_todo (pass->todo_flags_start);
1019
1020 #ifdef ENABLE_CHECKING
1021   do_per_function (verify_curr_properties,
1022                    (void *)(size_t)pass->properties_required);
1023 #endif
1024
1025   /* If a dump file name is present, open it if enabled.  */
1026   if (pass->static_pass_number != -1)
1027     {
1028       initializing_dump = !dump_initialized_p (pass->static_pass_number);
1029       dump_file_name = get_dump_file_name (pass->static_pass_number);
1030       dump_file = dump_begin (pass->static_pass_number, &dump_flags);
1031       if (dump_file && current_function_decl)
1032         {
1033           const char *dname, *aname;
1034           dname = lang_hooks.decl_printable_name (current_function_decl, 2);
1035           aname = (IDENTIFIER_POINTER
1036                    (DECL_ASSEMBLER_NAME (current_function_decl)));
1037           fprintf (dump_file, "\n;; Function %s (%s)%s\n\n", dname, aname,
1038              cfun->function_frequency == FUNCTION_FREQUENCY_HOT
1039              ? " (hot)"
1040              : cfun->function_frequency == FUNCTION_FREQUENCY_UNLIKELY_EXECUTED
1041              ? " (unlikely executed)"
1042              : "");
1043         }
1044     }
1045   else
1046     initializing_dump = false;
1047
1048   /* If a timevar is present, start it.  */
1049   if (pass->tv_id)
1050     timevar_push (pass->tv_id);
1051
1052   /* Do it!  */
1053   if (pass->execute)
1054     {
1055       todo_after = pass->execute ();
1056       do_per_function (clear_last_verified, NULL);
1057     }
1058
1059   /* Stop timevar.  */
1060   if (pass->tv_id)
1061     timevar_pop (pass->tv_id);
1062
1063   do_per_function (update_properties_after_pass, pass);
1064
1065   if (initializing_dump
1066       && dump_file
1067       && graph_dump_format != no_graph
1068       && (cfun->curr_properties & (PROP_cfg | PROP_rtl))
1069           == (PROP_cfg | PROP_rtl))
1070     {
1071       get_dump_file_info (pass->static_pass_number)->flags |= TDF_GRAPH;
1072       dump_flags |= TDF_GRAPH;
1073       clean_graph_dump_file (dump_file_name);
1074     }
1075
1076   /* Run post-pass cleanup and verification.  */
1077   execute_todo (todo_after | pass->todo_flags_finish);
1078   verify_interpass_invariants ();
1079
1080   if (!current_function_decl)
1081     cgraph_process_new_functions ();
1082
1083   /* Flush and close dump file.  */
1084   if (dump_file_name)
1085     {
1086       free ((char *) dump_file_name);
1087       dump_file_name = NULL;
1088     }
1089
1090   if (dump_file)
1091     {
1092       dump_end (pass->static_pass_number, dump_file);
1093       dump_file = NULL;
1094     }
1095
1096   /* Reset in_gimple_form to not break non-unit-at-a-time mode.  */
1097   in_gimple_form = false;
1098
1099   return true;
1100 }
1101
1102 void
1103 execute_pass_list (struct tree_opt_pass *pass)
1104 {
1105   do
1106     {
1107       if (execute_one_pass (pass) && pass->sub)
1108         execute_pass_list (pass->sub);
1109       pass = pass->next;
1110     }
1111   while (pass);
1112 }
1113
1114 /* Same as execute_pass_list but assume that subpasses of IPA passes
1115    are local passes.  */
1116 void
1117 execute_ipa_pass_list (struct tree_opt_pass *pass)
1118 {
1119   do
1120     {
1121       gcc_assert (!current_function_decl);
1122       gcc_assert (!cfun);
1123       if (execute_one_pass (pass) && pass->sub)
1124         do_per_function_toporder ((void (*)(void *))execute_pass_list,
1125                                   pass->sub);
1126       if (!current_function_decl)
1127         cgraph_process_new_functions ();
1128       pass = pass->next;
1129     }
1130   while (pass);
1131 }
1132 #include "gt-passes.h"