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 3, 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 COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  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 #include "df.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 /* This is used for debugging.  It allows the current pass to printed
 106    from anywhere in compilation.  */
 107 struct opt_pass *current_pass;
 108
 109 /* Call from anywhere to find out what pass this is.  Useful for
 110    printing out debugging information deep inside an service
 111    routine.  */
 112 void
 113 print_current_pass (FILE *file)
 114 {
 115   if (current_pass)
 116     fprintf (file, "current pass = %s (%d)\n",
 117              current_pass->name, current_pass->static_pass_number);
 118   else
 119     fprintf (file, "no current pass.\n");
 120 }
 121
 122
 123 /* Call from the debugger to get the current pass name.  */
 124 void
 125 debug_pass (void)
 126 {
 127   print_current_pass (stderr);
 128 }
 129
 130
 131
 132 /* Global variables used to communicate with passes.  */
 133 int dump_flags;
 134 bool in_gimple_form;
 135 bool first_pass_instance;
 136
 137
 138 /* This is called from various places for FUNCTION_DECL, VAR_DECL,
 139    and TYPE_DECL nodes.
 140
 141    This does nothing for local (non-static) variables, unless the
 142    variable is a register variable with DECL_ASSEMBLER_NAME set.  In
 143    that case, or if the variable is not an automatic, it sets up the
 144    RTL and outputs any assembler code (label definition, storage
 145    allocation and initialization).
 146
 147    DECL is the declaration.  TOP_LEVEL is nonzero
 148    if this declaration is not within a function.  */
 149
 150 void
 151 rest_of_decl_compilation (tree decl,
 152                           int top_level,
 153                           int at_end)
 154 {
 155   /* We deferred calling assemble_alias so that we could collect
 156      other attributes such as visibility.  Emit the alias now.  */
 157   {
 158     tree alias;
 159     alias = lookup_attribute ("alias", DECL_ATTRIBUTES (decl));
 160     if (alias)
 161       {
 162         alias = TREE_VALUE (TREE_VALUE (alias));
 163         alias = get_identifier (TREE_STRING_POINTER (alias));
 164         assemble_alias (decl, alias);
 165       }
 166   }
 167
 168   /* Can't defer this, because it needs to happen before any
 169      later function definitions are processed.  */
 170   if (DECL_ASSEMBLER_NAME_SET_P (decl) && DECL_REGISTER (decl))
 171     make_decl_rtl (decl);
 172
 173   /* Forward declarations for nested functions are not "external",
 174      but we need to treat them as if they were.  */
 175   if (TREE_STATIC (decl) || DECL_EXTERNAL (decl)
 176       || TREE_CODE (decl) == FUNCTION_DECL)
 177     {
 178       timevar_push (TV_VARCONST);
 179
 180       /* Don't output anything when a tentative file-scope definition
 181          is seen.  But at end of compilation, do output code for them.
 182
 183          We do output all variables when unit-at-a-time is active and rely on
 184          callgraph code to defer them except for forward declarations
 185          (see gcc.c-torture/compile/920624-1.c) */
 186       if ((at_end
 187            || !DECL_DEFER_OUTPUT (decl)
 188            || DECL_INITIAL (decl))
 189           && !DECL_EXTERNAL (decl))
 190         {
 191           if (TREE_CODE (decl) != FUNCTION_DECL)
 192             varpool_finalize_decl (decl);
 193           else
 194             assemble_variable (decl, top_level, at_end, 0);
 195         }
 196
 197 #ifdef ASM_FINISH_DECLARE_OBJECT
 198       if (decl == last_assemble_variable_decl)
 199         {
 200           ASM_FINISH_DECLARE_OBJECT (asm_out_file, decl,
 201                                      top_level, at_end);
 202         }
 203 #endif
 204
 205       timevar_pop (TV_VARCONST);
 206     }
 207   else if (TREE_CODE (decl) == TYPE_DECL
 208            /* Like in rest_of_type_compilation, avoid confusing the debug
 209               information machinery when there are errors.  */
 210            && !(sorrycount || errorcount))
 211     {
 212       timevar_push (TV_SYMOUT);
 213       debug_hooks->type_decl (decl, !top_level);
 214       timevar_pop (TV_SYMOUT);
 215     }
 216
 217   /* Let cgraph know about the existence of variables.  */
 218   if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl))
 219     varpool_node (decl);
 220 }
 221
 222 /* Called after finishing a record, union or enumeral type.  */
 223
 224 void
 225 rest_of_type_compilation (tree type, int toplev)
 226 {
 227   /* Avoid confusing the debug information machinery when there are
 228      errors.  */
 229   if (errorcount != 0 || sorrycount != 0)
 230     return;
 231
 232   timevar_push (TV_SYMOUT);
 233   debug_hooks->type_decl (TYPE_STUB_DECL (type), !toplev);
 234   timevar_pop (TV_SYMOUT);
 235 }
 236
 237 \f
 238
 239 void
 240 finish_optimization_passes (void)
 241 {
 242   enum tree_dump_index i;
 243   struct dump_file_info *dfi;
 244   char *name;
 245
 246   timevar_push (TV_DUMP);
 247   if (profile_arc_flag || flag_test_coverage || flag_branch_probabilities)
 248     {
 249       dump_file = dump_begin (pass_profile.pass.static_pass_number, NULL);
 250       end_branch_prob ();
 251       if (dump_file)
 252         dump_end (pass_profile.pass.static_pass_number, dump_file);
 253     }
 254
 255   if (optimize > 0)
 256     {
 257       dump_file = dump_begin (pass_combine.pass.static_pass_number, NULL);
 258       if (dump_file)
 259         {
 260           dump_combine_total_stats (dump_file);
 261           dump_end (pass_combine.pass.static_pass_number, dump_file);
 262         }
 263     }
 264
 265   /* Do whatever is necessary to finish printing the graphs.  */
 266   if (graph_dump_format != no_graph)
 267     for (i = TDI_end; (dfi = get_dump_file_info (i)) != NULL; ++i)
 268       if (dump_initialized_p (i)
 269           && (dfi->flags & TDF_GRAPH) != 0
 270           && (name = get_dump_file_name (i)) != NULL)
 271         {
 272           finish_graph_dump_file (name);
 273           free (name);
 274         }
 275
 276   timevar_pop (TV_DUMP);
 277 }
 278
 279 static bool
 280 gate_rest_of_compilation (void)
 281 {
 282   /* Early return if there were errors.  We can run afoul of our
 283      consistency checks, and there's not really much point in fixing them.  */
 284   return !(rtl_dump_and_exit || flag_syntax_only || errorcount || sorrycount);
 285 }
 286
 287 struct gimple_opt_pass pass_rest_of_compilation =
 288 {
 289  {
 290   GIMPLE_PASS,
 291   NULL,                                 /* name */
 292   gate_rest_of_compilation,             /* gate */
 293   NULL,                                 /* execute */
 294   NULL,                                 /* sub */
 295   NULL,                                 /* next */
 296   0,                                    /* static_pass_number */
 297   TV_REST_OF_COMPILATION,               /* tv_id */
 298   PROP_rtl,                             /* properties_required */
 299   0,                                    /* properties_provided */
 300   0,                                    /* properties_destroyed */
 301   0,                                    /* todo_flags_start */
 302   TODO_ggc_collect                      /* todo_flags_finish */
 303  }
 304 };
 305
 306 static bool
 307 gate_postreload (void)
 308 {
 309   return reload_completed;
 310 }
 311
 312 struct rtl_opt_pass pass_postreload =
 313 {
 314  {
 315   RTL_PASS,
 316   NULL,                                 /* name */
 317   gate_postreload,                      /* gate */
 318   NULL,                                 /* execute */
 319   NULL,                                 /* sub */
 320   NULL,                                 /* next */
 321   0,                                    /* static_pass_number */
 322   0,                                    /* tv_id */
 323   PROP_rtl,                             /* properties_required */
 324   0,                                    /* properties_provided */
 325   0,                                    /* properties_destroyed */
 326   0,                                    /* todo_flags_start */
 327   TODO_ggc_collect | TODO_verify_rtl_sharing /* todo_flags_finish */
 328  }
 329 };
 330
 331
 332
 333 /* The root of the compilation pass tree, once constructed.  */
 334 struct opt_pass *all_passes, *all_ipa_passes, *all_lowering_passes;
 335
 336 /* Iterate over the pass tree allocating dump file numbers.  We want
 337    to do this depth first, and independent of whether the pass is
 338    enabled or not.  */
 339
 340 static void
 341 register_one_dump_file (struct opt_pass *pass)
 342 {
 343   char *dot_name, *flag_name, *glob_name;
 344   const char *prefix;
 345   char num[10];
 346   int flags;
 347
 348   /* See below in next_pass_1.  */
 349   num[0] = '\0';
 350   if (pass->static_pass_number != -1)
 351     sprintf (num, "%d", ((int) pass->static_pass_number < 0
 352                          ? 1 : pass->static_pass_number));
 353
 354   dot_name = concat (".", pass->name, num, NULL);
 355   if (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS)
 356     prefix = "ipa-", flags = TDF_IPA;
 357   else if (pass->type == GIMPLE_PASS)
 358     prefix = "tree-", flags = TDF_TREE;
 359   else
 360     prefix = "rtl-", flags = TDF_RTL;
 361
 362   flag_name = concat (prefix, pass->name, num, NULL);
 363   glob_name = concat (prefix, pass->name, NULL);
 364   pass->static_pass_number = dump_register (dot_name, flag_name, glob_name,
 365                                             flags);
 366 }
 367
 368 /* Recursive worker function for register_dump_files.  */
 369
 370 static int
 371 register_dump_files_1 (struct opt_pass *pass, int properties)
 372 {
 373   do
 374     {
 375       int new_properties = (properties | pass->properties_provided)
 376                            & ~pass->properties_destroyed;
 377
 378       if (pass->name)
 379         register_one_dump_file (pass);
 380
 381       if (pass->sub)
 382         new_properties = register_dump_files_1 (pass->sub, new_properties);
 383
 384       /* If we have a gate, combine the properties that we could have with
 385          and without the pass being examined.  */
 386       if (pass->gate)
 387         properties &= new_properties;
 388       else
 389         properties = new_properties;
 390
 391       pass = pass->next;
 392     }
 393   while (pass);
 394
 395   return properties;
 396 }
 397
 398 /* Register the dump files for the pipeline starting at PASS.
 399    PROPERTIES reflects the properties that are guaranteed to be available at
 400    the beginning of the pipeline.  */
 401
 402 static void
 403 register_dump_files (struct opt_pass *pass,int properties)
 404 {
 405   pass->properties_required |= properties;
 406   register_dump_files_1 (pass, properties);
 407 }
 408
 409 /* Add a pass to the pass list. Duplicate the pass if it's already
 410    in the list.  */
 411
 412 static struct opt_pass **
 413 next_pass_1 (struct opt_pass **list, struct opt_pass *pass)
 414 {
 415   /* A nonzero static_pass_number indicates that the
 416      pass is already in the list.  */
 417   if (pass->static_pass_number)
 418     {
 419       struct opt_pass *new;
 420
 421       new = xmalloc (sizeof (*new));
 422       memcpy (new, pass, sizeof (*new));
 423       new->next = NULL;
 424
 425       new->todo_flags_start &= ~TODO_mark_first_instance;
 426
 427       /* Indicate to register_dump_files that this pass has duplicates,
 428          and so it should rename the dump file.  The first instance will
 429          be -1, and be number of duplicates = -static_pass_number - 1.
 430          Subsequent instances will be > 0 and just the duplicate number.  */
 431       if (pass->name)
 432         {
 433           pass->static_pass_number -= 1;
 434           new->static_pass_number = -pass->static_pass_number;
 435         }
 436
 437       *list = new;
 438     }
 439   else
 440     {
 441       pass->todo_flags_start |= TODO_mark_first_instance;
 442       pass->static_pass_number = -1;
 443       *list = pass;
 444     }
 445
 446   return &(*list)->next;
 447
 448 }
 449
 450
 451 /* Construct the pass tree.  The sequencing of passes is driven by
 452    the cgraph routines:
 453
 454    cgraph_finalize_compilation_unit ()
 455        for each node N in the cgraph
 456            cgraph_analyze_function (N)
 457                cgraph_lower_function (N) -> all_lowering_passes
 458
 459    If we are optimizing, cgraph_optimize is then invoked:
 460
 461    cgraph_optimize ()
 462        ipa_passes ()                    -> all_ipa_passes
 463        cgraph_expand_all_functions ()
 464            for each node N in the cgraph
 465                cgraph_expand_function (N)
 466                   tree_rest_of_compilation (DECL (N))  -> all_passes
 467 */
 468
 469 void
 470 init_optimization_passes (void)
 471 {
 472   struct opt_pass **p;
 473
 474 #define NEXT_PASS(PASS)  (p = next_pass_1 (p, &((PASS).pass)))
 475
 476  /* All passes needed to lower the function into shape optimizers can
 477     operate on.  These passes are always run first on the function, but
 478     backend might produce already lowered functions that are not processed
 479     by these passes.  */
 480   p = &all_lowering_passes;
 481   NEXT_PASS (pass_remove_useless_stmts);
 482   NEXT_PASS (pass_mudflap_1);
 483   NEXT_PASS (pass_lower_omp);
 484   NEXT_PASS (pass_lower_cf);
 485   NEXT_PASS (pass_refactor_eh);
 486   NEXT_PASS (pass_lower_eh);
 487   NEXT_PASS (pass_build_cfg);
 488   NEXT_PASS (pass_lower_complex_O0);
 489   NEXT_PASS (pass_lower_vector);
 490   NEXT_PASS (pass_warn_function_return);
 491   NEXT_PASS (pass_build_cgraph_edges);
 492   NEXT_PASS (pass_inline_parameters);
 493   *p = NULL;
 494
 495   /* Interprocedural optimization passes.
 496      All these passes are ignored in -fno-unit-at-a-time
 497      except for subpasses of early_local_passes.  */
 498   p = &all_ipa_passes;
 499   NEXT_PASS (pass_ipa_function_and_variable_visibility);
 500   NEXT_PASS (pass_ipa_early_inline);
 501     {
 502       struct opt_pass **p = &pass_ipa_early_inline.pass.sub;
 503       NEXT_PASS (pass_early_inline);
 504       NEXT_PASS (pass_inline_parameters);
 505       NEXT_PASS (pass_rebuild_cgraph_edges);
 506     }
 507   NEXT_PASS (pass_early_local_passes);
 508     {
 509       struct opt_pass **p = &pass_early_local_passes.pass.sub;
 510       NEXT_PASS (pass_tree_profile);
 511       NEXT_PASS (pass_cleanup_cfg);
 512       NEXT_PASS (pass_init_datastructures);
 513       NEXT_PASS (pass_expand_omp);
 514       NEXT_PASS (pass_all_early_optimizations);
 515         {
 516           struct opt_pass **p = &pass_all_early_optimizations.pass.sub;
 517           NEXT_PASS (pass_referenced_vars);
 518           NEXT_PASS (pass_reset_cc_flags);
 519           NEXT_PASS (pass_build_ssa);
 520           NEXT_PASS (pass_expand_omp_ssa);
 521           NEXT_PASS (pass_early_warn_uninitialized);
 522           NEXT_PASS (pass_rebuild_cgraph_edges);
 523           NEXT_PASS (pass_early_inline);
 524           NEXT_PASS (pass_cleanup_cfg);
 525           NEXT_PASS (pass_rename_ssa_copies);
 526           NEXT_PASS (pass_ccp);
 527           NEXT_PASS (pass_forwprop);
 528           NEXT_PASS (pass_update_address_taken);
 529           NEXT_PASS (pass_simple_dse);
 530           NEXT_PASS (pass_sra_early);
 531           NEXT_PASS (pass_copy_prop);
 532           NEXT_PASS (pass_merge_phi);
 533           NEXT_PASS (pass_dce);
 534           NEXT_PASS (pass_update_address_taken);
 535           NEXT_PASS (pass_simple_dse);
 536           NEXT_PASS (pass_tail_recursion);
 537           NEXT_PASS (pass_profile);
 538           NEXT_PASS (pass_release_ssa_names);
 539         }
 540       NEXT_PASS (pass_rebuild_cgraph_edges);
 541     }
 542   NEXT_PASS (pass_ipa_increase_alignment);
 543   NEXT_PASS (pass_ipa_matrix_reorg);
 544   NEXT_PASS (pass_ipa_cp);
 545   NEXT_PASS (pass_ipa_inline);
 546   NEXT_PASS (pass_ipa_reference);
 547   NEXT_PASS (pass_ipa_pure_const);
 548   NEXT_PASS (pass_ipa_type_escape);
 549   NEXT_PASS (pass_ipa_pta);
 550   NEXT_PASS (pass_ipa_struct_reorg);
 551   *p = NULL;
 552
 553   /* These passes are run after IPA passes on every function that is being
 554      output to the assembler file.  */
 555   p = &all_passes;
 556   NEXT_PASS (pass_O0_always_inline);
 557   NEXT_PASS (pass_all_optimizations);
 558     {
 559       struct opt_pass **p = &pass_all_optimizations.pass.sub;
 560       NEXT_PASS (pass_create_structure_vars);
 561       /* ??? pass_build_alias is a dummy pass that ensures that we
 562          execute TODO_rebuild_alias at this point even if
 563          pass_create_structure_vars was disabled.  */
 564       NEXT_PASS (pass_build_alias);
 565       NEXT_PASS (pass_return_slot);
 566       NEXT_PASS (pass_rename_ssa_copies);
 567
 568       /* Initial scalar cleanups.  */
 569       NEXT_PASS (pass_complete_unrolli);
 570       NEXT_PASS (pass_ccp);
 571       NEXT_PASS (pass_phiprop);
 572       NEXT_PASS (pass_fre);
 573       NEXT_PASS (pass_dce);
 574       NEXT_PASS (pass_forwprop);
 575       NEXT_PASS (pass_copy_prop);
 576       NEXT_PASS (pass_merge_phi);
 577       NEXT_PASS (pass_vrp);
 578       NEXT_PASS (pass_dce);
 579       NEXT_PASS (pass_cselim);
 580       NEXT_PASS (pass_dominator);
 581       /* The only const/copy propagation opportunities left after
 582          DOM should be due to degenerate PHI nodes.  So rather than
 583          run the full propagators, run a specialized pass which
 584          only examines PHIs to discover const/copy propagation
 585          opportunities.  */
 586       NEXT_PASS (pass_phi_only_cprop);
 587       NEXT_PASS (pass_tree_ifcombine);
 588       NEXT_PASS (pass_phiopt);
 589       NEXT_PASS (pass_tail_recursion);
 590       NEXT_PASS (pass_ch);
 591       NEXT_PASS (pass_stdarg);
 592       NEXT_PASS (pass_lower_complex);
 593       NEXT_PASS (pass_sra);
 594       NEXT_PASS (pass_rename_ssa_copies);
 595       NEXT_PASS (pass_dominator);
 596
 597       /* The only const/copy propagation opportunities left after
 598          DOM should be due to degenerate PHI nodes.  So rather than
 599          run the full propagators, run a specialized pass which
 600          only examines PHIs to discover const/copy propagation
 601          opportunities.  */
 602       NEXT_PASS (pass_phi_only_cprop);
 603
 604       NEXT_PASS (pass_reassoc);
 605       NEXT_PASS (pass_dce);
 606       NEXT_PASS (pass_dse);
 607       NEXT_PASS (pass_forwprop);
 608       NEXT_PASS (pass_phiopt);
 609       NEXT_PASS (pass_object_sizes);
 610       NEXT_PASS (pass_store_ccp);
 611       NEXT_PASS (pass_copy_prop);
 612       NEXT_PASS (pass_fold_builtins);
 613       NEXT_PASS (pass_cse_sincos);
 614       NEXT_PASS (pass_split_crit_edges);
 615       NEXT_PASS (pass_pre);
 616       NEXT_PASS (pass_sink_code);
 617       NEXT_PASS (pass_tree_loop);
 618         {
 619           struct opt_pass **p = &pass_tree_loop.pass.sub;
 620           NEXT_PASS (pass_tree_loop_init);
 621           NEXT_PASS (pass_copy_prop);
 622           NEXT_PASS (pass_dce_loop);
 623           NEXT_PASS (pass_lim);
 624           NEXT_PASS (pass_predcom);
 625           NEXT_PASS (pass_tree_unswitch);
 626           NEXT_PASS (pass_scev_cprop);
 627           NEXT_PASS (pass_empty_loop);
 628           NEXT_PASS (pass_record_bounds);
 629           NEXT_PASS (pass_check_data_deps);
 630           NEXT_PASS (pass_loop_distribution);
 631           NEXT_PASS (pass_linear_transform);
 632           NEXT_PASS (pass_iv_canon);
 633           NEXT_PASS (pass_if_conversion);
 634           NEXT_PASS (pass_vectorize);
 635             {
 636               struct opt_pass **p = &pass_vectorize.pass.sub;
 637               NEXT_PASS (pass_lower_vector_ssa);
 638               NEXT_PASS (pass_dce_loop);
 639             }
 640           NEXT_PASS (pass_complete_unroll);
 641           NEXT_PASS (pass_parallelize_loops);
 642           NEXT_PASS (pass_loop_prefetch);
 643           NEXT_PASS (pass_iv_optimize);
 644           NEXT_PASS (pass_tree_loop_done);
 645         }
 646       NEXT_PASS (pass_cse_reciprocals);
 647       NEXT_PASS (pass_convert_to_rsqrt);
 648       NEXT_PASS (pass_reassoc);
 649       NEXT_PASS (pass_vrp);
 650       NEXT_PASS (pass_dominator);
 651
 652       /* The only const/copy propagation opportunities left after
 653          DOM should be due to degenerate PHI nodes.  So rather than
 654          run the full propagators, run a specialized pass which
 655          only examines PHIs to discover const/copy propagation
 656          opportunities.  */
 657       NEXT_PASS (pass_phi_only_cprop);
 658
 659       NEXT_PASS (pass_cd_dce);
 660       NEXT_PASS (pass_tracer);
 661
 662       /* FIXME: If DCE is not run before checking for uninitialized uses,
 663          we may get false warnings (e.g., testsuite/gcc.dg/uninit-5.c).
 664          However, this also causes us to misdiagnose cases that should be
 665          real warnings (e.g., testsuite/gcc.dg/pr18501.c).
 666
 667          To fix the false positives in uninit-5.c, we would have to
 668          account for the predicates protecting the set and the use of each
 669          variable.  Using a representation like Gated Single Assignment
 670          may help.  */
 671       NEXT_PASS (pass_late_warn_uninitialized);
 672       NEXT_PASS (pass_dse);
 673       NEXT_PASS (pass_forwprop);
 674       NEXT_PASS (pass_phiopt);
 675       NEXT_PASS (pass_tail_calls);
 676       NEXT_PASS (pass_rename_ssa_copies);
 677       NEXT_PASS (pass_uncprop);
 678       NEXT_PASS (pass_del_ssa);
 679       NEXT_PASS (pass_nrv);
 680       NEXT_PASS (pass_mark_used_blocks);
 681       NEXT_PASS (pass_cleanup_cfg_post_optimizing);
 682     }
 683   NEXT_PASS (pass_warn_function_noreturn);
 684   NEXT_PASS (pass_free_datastructures);
 685   NEXT_PASS (pass_mudflap_2);
 686   NEXT_PASS (pass_free_cfg_annotations);
 687   NEXT_PASS (pass_expand);
 688   NEXT_PASS (pass_rest_of_compilation);
 689     {
 690       struct opt_pass **p = &pass_rest_of_compilation.pass.sub;
 691       NEXT_PASS (pass_init_function);
 692       NEXT_PASS (pass_jump);
 693       NEXT_PASS (pass_rtl_eh);
 694       NEXT_PASS (pass_initial_value_sets);
 695       NEXT_PASS (pass_unshare_all_rtl);
 696       NEXT_PASS (pass_instantiate_virtual_regs);
 697       NEXT_PASS (pass_into_cfg_layout_mode);
 698       NEXT_PASS (pass_jump2);
 699       NEXT_PASS (pass_lower_subreg);
 700       NEXT_PASS (pass_df_initialize_opt);
 701       NEXT_PASS (pass_cse);
 702       NEXT_PASS (pass_rtl_fwprop);
 703       NEXT_PASS (pass_gcse);
 704       NEXT_PASS (pass_rtl_ifcvt);
 705       /* Perform loop optimizations.  It might be better to do them a bit
 706          sooner, but we want the profile feedback to work more
 707          efficiently.  */
 708       NEXT_PASS (pass_loop2);
 709         {
 710           struct opt_pass **p = &pass_loop2.pass.sub;
 711           NEXT_PASS (pass_rtl_loop_init);
 712           NEXT_PASS (pass_rtl_move_loop_invariants);
 713           NEXT_PASS (pass_rtl_unswitch);
 714           NEXT_PASS (pass_rtl_unroll_and_peel_loops);
 715           NEXT_PASS (pass_rtl_doloop);
 716           NEXT_PASS (pass_rtl_loop_done);
 717           *p = NULL;
 718         }
 719       NEXT_PASS (pass_web);
 720       NEXT_PASS (pass_jump_bypass);
 721       NEXT_PASS (pass_cse2);
 722       NEXT_PASS (pass_rtl_dse1);
 723       NEXT_PASS (pass_rtl_fwprop_addr);
 724       NEXT_PASS (pass_regclass_init);
 725       NEXT_PASS (pass_inc_dec);
 726       NEXT_PASS (pass_initialize_regs);
 727       NEXT_PASS (pass_outof_cfg_layout_mode);
 728       NEXT_PASS (pass_ud_rtl_dce);
 729       NEXT_PASS (pass_combine);
 730       NEXT_PASS (pass_if_after_combine);
 731       NEXT_PASS (pass_partition_blocks);
 732       NEXT_PASS (pass_regmove);
 733       NEXT_PASS (pass_split_all_insns);
 734       NEXT_PASS (pass_lower_subreg2);
 735       NEXT_PASS (pass_df_initialize_no_opt);
 736       NEXT_PASS (pass_stack_ptr_mod);
 737       NEXT_PASS (pass_mode_switching);
 738       NEXT_PASS (pass_see);
 739       NEXT_PASS (pass_match_asm_constraints);
 740       NEXT_PASS (pass_sms);
 741       NEXT_PASS (pass_sched);
 742       NEXT_PASS (pass_subregs_of_mode_init);
 743       NEXT_PASS (pass_local_alloc);
 744       NEXT_PASS (pass_global_alloc);
 745       NEXT_PASS (pass_subregs_of_mode_finish);
 746       NEXT_PASS (pass_postreload);
 747         {
 748           struct opt_pass **p = &pass_postreload.pass.sub;
 749           NEXT_PASS (pass_postreload_cse);
 750           NEXT_PASS (pass_gcse2);
 751           NEXT_PASS (pass_split_after_reload);
 752           NEXT_PASS (pass_branch_target_load_optimize1);
 753           NEXT_PASS (pass_thread_prologue_and_epilogue);
 754           NEXT_PASS (pass_rtl_dse2);
 755           NEXT_PASS (pass_rtl_seqabstr);
 756           NEXT_PASS (pass_stack_adjustments);
 757           NEXT_PASS (pass_peephole2);
 758           NEXT_PASS (pass_if_after_reload);
 759           NEXT_PASS (pass_regrename);
 760           NEXT_PASS (pass_cprop_hardreg);
 761           NEXT_PASS (pass_fast_rtl_dce);
 762           NEXT_PASS (pass_reorder_blocks);
 763           NEXT_PASS (pass_branch_target_load_optimize2);
 764           NEXT_PASS (pass_leaf_regs);
 765           NEXT_PASS (pass_split_before_sched2);
 766           NEXT_PASS (pass_sched2);
 767           NEXT_PASS (pass_stack_regs);
 768             {
 769               struct opt_pass **p = &pass_stack_regs.pass.sub;
 770               NEXT_PASS (pass_split_before_regstack);
 771               NEXT_PASS (pass_stack_regs_run);
 772             }
 773           NEXT_PASS (pass_compute_alignments);
 774           NEXT_PASS (pass_duplicate_computed_gotos);
 775           NEXT_PASS (pass_variable_tracking);
 776           NEXT_PASS (pass_free_cfg);
 777           NEXT_PASS (pass_machine_reorg);
 778           NEXT_PASS (pass_cleanup_barriers);
 779           NEXT_PASS (pass_delay_slots);
 780           NEXT_PASS (pass_split_for_shorten_branches);
 781           NEXT_PASS (pass_convert_to_eh_region_ranges);
 782           NEXT_PASS (pass_shorten_branches);
 783           NEXT_PASS (pass_set_nothrow_function_flags);
 784           NEXT_PASS (pass_final);
 785         }
 786       NEXT_PASS (pass_df_finish);
 787     }
 788   NEXT_PASS (pass_clean_state);
 789   *p = NULL;
 790
 791 #undef NEXT_PASS
 792
 793   /* Register the passes with the tree dump code.  */
 794   register_dump_files (all_lowering_passes, PROP_gimple_any);
 795   all_lowering_passes->todo_flags_start |= TODO_set_props;
 796   register_dump_files (all_ipa_passes,
 797                        PROP_gimple_any | PROP_gimple_lcf | PROP_gimple_leh
 798                        | PROP_cfg);
 799   register_dump_files (all_passes,
 800                        PROP_gimple_any | PROP_gimple_lcf | PROP_gimple_leh
 801                        | PROP_cfg);
 802 }
 803
 804 /* If we are in IPA mode (i.e., current_function_decl is NULL), call
 805    function CALLBACK for every function in the call graph.  Otherwise,
 806    call CALLBACK on the current function.  */
 807
 808 static void
 809 do_per_function (void (*callback) (void *data), void *data)
 810 {
 811   if (current_function_decl)
 812     callback (data);
 813   else
 814     {
 815       struct cgraph_node *node;
 816       for (node = cgraph_nodes; node; node = node->next)
 817         if (node->analyzed)
 818           {
 819             push_cfun (DECL_STRUCT_FUNCTION (node->decl));
 820             current_function_decl = node->decl;
 821             callback (data);
 822             free_dominance_info (CDI_DOMINATORS);
 823             free_dominance_info (CDI_POST_DOMINATORS);
 824             current_function_decl = NULL;
 825             pop_cfun ();
 826             ggc_collect ();
 827           }
 828     }
 829 }
 830
 831 /* Because inlining might remove no-longer reachable nodes, we need to
 832    keep the array visible to garbage collector to avoid reading collected
 833    out nodes.  */
 834 static int nnodes;
 835 static GTY ((length ("nnodes"))) struct cgraph_node **order;
 836
 837 /* If we are in IPA mode (i.e., current_function_decl is NULL), call
 838    function CALLBACK for every function in the call graph.  Otherwise,
 839    call CALLBACK on the current function.  */
 840
 841 static void
 842 do_per_function_toporder (void (*callback) (void *data), void *data)
 843 {
 844   int i;
 845
 846   if (current_function_decl)
 847     callback (data);
 848   else
 849     {
 850       gcc_assert (!order);
 851       order = ggc_alloc (sizeof (*order) * cgraph_n_nodes);
 852       nnodes = cgraph_postorder (order);
 853       for (i = nnodes - 1; i >= 0; i--)
 854         {
 855           struct cgraph_node *node = order[i];
 856
 857           /* Allow possibly removed nodes to be garbage collected.  */
 858           order[i] = NULL;
 859           if (node->analyzed && (node->needed || node->reachable))
 860             {
 861               push_cfun (DECL_STRUCT_FUNCTION (node->decl));
 862               current_function_decl = node->decl;
 863               callback (data);
 864               free_dominance_info (CDI_DOMINATORS);
 865               free_dominance_info (CDI_POST_DOMINATORS);
 866               current_function_decl = NULL;
 867               pop_cfun ();
 868               ggc_collect ();
 869             }
 870         }
 871     }
 872   ggc_free (order);
 873   order = NULL;
 874   nnodes = 0;
 875 }
 876
 877 /* Perform all TODO actions that ought to be done on each function.  */
 878
 879 static void
 880 execute_function_todo (void *data)
 881 {
 882   unsigned int flags = (size_t)data;
 883   if (cfun->curr_properties & PROP_ssa)
 884     flags |= TODO_verify_ssa;
 885   flags &= ~cfun->last_verified;
 886   if (!flags)
 887     return;
 888
 889   /* Always cleanup the CFG before trying to update SSA.  */
 890   if (flags & TODO_cleanup_cfg)
 891     {
 892       bool cleanup = cleanup_tree_cfg ();
 893
 894       if (cleanup && (cfun->curr_properties & PROP_ssa))
 895         flags |= TODO_remove_unused_locals;
 896
 897       /* When cleanup_tree_cfg merges consecutive blocks, it may
 898          perform some simplistic propagation when removing single
 899          valued PHI nodes.  This propagation may, in turn, cause the
 900          SSA form to become out-of-date (see PR 22037).  So, even
 901          if the parent pass had not scheduled an SSA update, we may
 902          still need to do one.  */
 903       if (!(flags & TODO_update_ssa_any) && need_ssa_update_p ())
 904         flags |= TODO_update_ssa;
 905     }
 906
 907   if (flags & TODO_update_ssa_any)
 908     {
 909       unsigned update_flags = flags & TODO_update_ssa_any;
 910       update_ssa (update_flags);
 911       cfun->last_verified &= ~TODO_verify_ssa;
 912     }
 913
 914   if (flags & TODO_rebuild_alias)
 915     {
 916       compute_may_aliases ();
 917       cfun->curr_properties |= PROP_alias;
 918     }
 919
 920   if (flags & TODO_remove_unused_locals)
 921     remove_unused_locals ();
 922
 923   if ((flags & TODO_dump_func)
 924       && dump_file && current_function_decl)
 925     {
 926       if (cfun->curr_properties & PROP_trees)
 927         dump_function_to_file (current_function_decl,
 928                                dump_file, dump_flags);
 929       else
 930         {
 931           if (dump_flags & TDF_SLIM)
 932             print_rtl_slim_with_bb (dump_file, get_insns (), dump_flags);
 933           else if ((cfun->curr_properties & PROP_cfg)
 934                    && (dump_flags & TDF_BLOCKS))
 935             print_rtl_with_bb (dump_file, get_insns ());
 936           else
 937             print_rtl (dump_file, get_insns ());
 938
 939           if (cfun->curr_properties & PROP_cfg
 940               && graph_dump_format != no_graph
 941               && (dump_flags & TDF_GRAPH))
 942             print_rtl_graph_with_bb (dump_file_name, get_insns ());
 943         }
 944
 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_rebuild_frequencies)
 951     {
 952       if (profile_status == PROFILE_GUESSED)
 953         {
 954           loop_optimizer_init (0);
 955           add_noreturn_fake_exit_edges ();
 956           mark_irreducible_loops ();
 957           connect_infinite_loops_to_exit ();
 958           estimate_bb_frequencies ();
 959           remove_fake_exit_edges ();
 960           loop_optimizer_finalize ();
 961         }
 962       else if (profile_status == PROFILE_READ)
 963         counts_to_freqs ();
 964       else
 965         gcc_unreachable ();
 966     }
 967
 968 #if defined ENABLE_CHECKING
 969   if (flags & TODO_verify_ssa)
 970     verify_ssa (true);
 971   if (flags & TODO_verify_flow)
 972     verify_flow_info ();
 973   if (flags & TODO_verify_stmts)
 974     verify_stmts ();
 975   if (flags & TODO_verify_loops)
 976     verify_loop_closed_ssa ();
 977   if (flags & TODO_verify_rtl_sharing)
 978     verify_rtl_sharing ();
 979 #endif
 980
 981   cfun->last_verified = flags & TODO_verify_all;
 982 }
 983
 984 /* Perform all TODO actions.  */
 985 static void
 986 execute_todo (unsigned int flags)
 987 {
 988 #if defined ENABLE_CHECKING
 989   if (need_ssa_update_p ())
 990     gcc_assert (flags & TODO_update_ssa_any);
 991 #endif
 992
 993   /* Inform the pass whether it is the first time it is run.  */
 994   first_pass_instance = (flags & TODO_mark_first_instance) != 0;
 995
 996   do_per_function (execute_function_todo, (void *)(size_t) flags);
 997
 998   /* Always remove functions just as before inlining: IPA passes might be
 999      interested to see bodies of extern inline functions that are not inlined
1000      to analyze side effects.  The full removal is done just at the end
1001      of IPA pass queue.  */
1002   if (flags & TODO_remove_functions)
1003     {
1004       gcc_assert (!cfun);
1005       cgraph_remove_unreachable_nodes (true, dump_file);
1006     }
1007
1008   if ((flags & TODO_dump_cgraph)
1009       && dump_file && !current_function_decl)
1010     {
1011       gcc_assert (!cfun);
1012       dump_cgraph (dump_file);
1013       /* Flush the file.  If verification fails, we won't be able to
1014          close the file before aborting.  */
1015       fflush (dump_file);
1016     }
1017
1018   if (flags & TODO_ggc_collect)
1019     {
1020       ggc_collect ();
1021     }
1022
1023   /* Now that the dumping has been done, we can get rid of the optional
1024      df problems.  */
1025   if (flags & TODO_df_finish)
1026     df_finish_pass ((flags & TODO_df_verify) != 0);
1027 }
1028
1029 /* Verify invariants that should hold between passes.  This is a place
1030    to put simple sanity checks.  */
1031
1032 static void
1033 verify_interpass_invariants (void)
1034 {
1035 #ifdef ENABLE_CHECKING
1036   gcc_assert (!fold_deferring_overflow_warnings_p ());
1037 #endif
1038 }
1039
1040 /* Clear the last verified flag.  */
1041
1042 static void
1043 clear_last_verified (void *data ATTRIBUTE_UNUSED)
1044 {
1045   cfun->last_verified = 0;
1046 }
1047
1048 /* Helper function. Verify that the properties has been turn into the
1049    properties expected by the pass.  */
1050
1051 #ifdef ENABLE_CHECKING
1052 static void
1053 verify_curr_properties (void *data)
1054 {
1055   unsigned int props = (size_t)data;
1056   gcc_assert ((cfun->curr_properties & props) == props);
1057 }
1058 #endif
1059
1060 /* Initialize pass dump file.  */
1061
1062 static bool
1063 pass_init_dump_file (struct opt_pass *pass)
1064 {
1065   /* If a dump file name is present, open it if enabled.  */
1066   if (pass->static_pass_number != -1)
1067     {
1068       bool initializing_dump = !dump_initialized_p (pass->static_pass_number);
1069       dump_file_name = get_dump_file_name (pass->static_pass_number);
1070       dump_file = dump_begin (pass->static_pass_number, &dump_flags);
1071       if (dump_file && current_function_decl)
1072         {
1073           const char *dname, *aname;
1074           dname = lang_hooks.decl_printable_name (current_function_decl, 2);
1075           aname = (IDENTIFIER_POINTER
1076                    (DECL_ASSEMBLER_NAME (current_function_decl)));
1077           fprintf (dump_file, "\n;; Function %s (%s)%s\n\n", dname, aname,
1078              cfun->function_frequency == FUNCTION_FREQUENCY_HOT
1079              ? " (hot)"
1080              : cfun->function_frequency == FUNCTION_FREQUENCY_UNLIKELY_EXECUTED
1081              ? " (unlikely executed)"
1082              : "");
1083         }
1084       return initializing_dump;
1085     }
1086   else
1087     return false;
1088 }
1089
1090 /* Flush PASS dump file.  */
1091
1092 static void
1093 pass_fini_dump_file (struct opt_pass *pass)
1094 {
1095   /* Flush and close dump file.  */
1096   if (dump_file_name)
1097     {
1098       free (CONST_CAST (char *, dump_file_name));
1099       dump_file_name = NULL;
1100     }
1101
1102   if (dump_file)
1103     {
1104       dump_end (pass->static_pass_number, dump_file);
1105       dump_file = NULL;
1106     }
1107 }
1108
1109 /* After executing the pass, apply expected changes to the function
1110    properties. */
1111
1112 static void
1113 update_properties_after_pass (void *data)
1114 {
1115   struct opt_pass *pass = data;
1116   cfun->curr_properties = (cfun->curr_properties | pass->properties_provided)
1117                            & ~pass->properties_destroyed;
1118 }
1119
1120 /* Schedule IPA transform pass DATA for CFUN.  */
1121
1122 static void
1123 add_ipa_transform_pass (void *data)
1124 {
1125   struct ipa_opt_pass *ipa_pass = (struct ipa_opt_pass *) data;
1126   VEC_safe_push (ipa_opt_pass, heap, cfun->ipa_transforms_to_apply, ipa_pass);
1127 }
1128
1129 /* Execute IPA pass function summary generation. DATA is pointer to
1130    pass list to execute.  */
1131
1132 static void
1133 execute_ipa_summary_passes (void *data)
1134 {
1135   struct ipa_opt_pass *ipa_pass = (struct ipa_opt_pass *)data;
1136   struct cgraph_node *node = cgraph_node (cfun->decl);
1137   while (ipa_pass && ipa_pass->pass.type == IPA_PASS)
1138     {
1139       struct opt_pass *pass = &ipa_pass->pass;
1140       if (!pass->gate || pass->gate ())
1141         {
1142           pass_init_dump_file (pass);
1143           ipa_pass->function_generate_summary (node);
1144           pass_fini_dump_file (pass);
1145         }
1146       ipa_pass = (struct ipa_opt_pass *)ipa_pass->pass.next;
1147     }
1148 }
1149
1150 /* Execute IPA_PASS function transform on NODE.  */
1151
1152 static void
1153 execute_one_ipa_transform_pass (struct cgraph_node *node,
1154                                 struct ipa_opt_pass *ipa_pass)
1155 {
1156   struct opt_pass *pass = &ipa_pass->pass;
1157   unsigned int todo_after = 0;
1158
1159   current_pass = pass;
1160   if (!ipa_pass->function_transform)
1161     return;
1162
1163   /* Note that the folders should only create gimple expressions.
1164      This is a hack until the new folder is ready.  */
1165   in_gimple_form = (cfun && (cfun->curr_properties & PROP_trees)) != 0;
1166
1167   pass_init_dump_file (pass);
1168
1169   /* Run pre-pass verification.  */
1170   execute_todo (ipa_pass->function_transform_todo_flags_start);
1171
1172   /* If a timevar is present, start it.  */
1173   if (pass->tv_id)
1174     timevar_push (pass->tv_id);
1175
1176   /* Do it!  */
1177   todo_after = ipa_pass->function_transform (node);
1178
1179   /* Stop timevar.  */
1180   if (pass->tv_id)
1181     timevar_pop (pass->tv_id);
1182
1183   /* Run post-pass cleanup and verification.  */
1184   execute_todo (todo_after);
1185   verify_interpass_invariants ();
1186
1187   pass_fini_dump_file (pass);
1188
1189   current_pass = NULL;
1190   /* Reset in_gimple_form to not break non-unit-at-a-time mode.  */
1191   in_gimple_form = false;
1192 }
1193
1194 static bool
1195 execute_one_pass (struct opt_pass *pass)
1196 {
1197   bool initializing_dump;
1198   unsigned int todo_after = 0;
1199
1200   /* IPA passes are executed on whole program, so cfun should be NULL.
1201      Ohter passes needs function context set.  */
1202   if (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS)
1203     gcc_assert (!cfun && !current_function_decl);
1204   else
1205     gcc_assert (cfun && current_function_decl);
1206
1207   if (cfun && cfun->ipa_transforms_to_apply)
1208     {
1209       unsigned int i;
1210       struct cgraph_node *node = cgraph_node (current_function_decl);
1211
1212       for (i = 0; i < VEC_length (ipa_opt_pass, cfun->ipa_transforms_to_apply);
1213            i++)
1214         execute_one_ipa_transform_pass (node,
1215                                         VEC_index (ipa_opt_pass,
1216                                                    cfun->ipa_transforms_to_apply,
1217                                                    i));
1218       VEC_free (ipa_opt_pass, heap, cfun->ipa_transforms_to_apply);
1219       cfun->ipa_transforms_to_apply = NULL;
1220     }
1221
1222   current_pass = pass;
1223   /* See if we're supposed to run this pass.  */
1224   if (pass->gate && !pass->gate ())
1225     return false;
1226
1227   if (!quiet_flag && !cfun)
1228     fprintf (stderr, " <%s>", pass->name ? pass->name : "");
1229
1230   if (pass->todo_flags_start & TODO_set_props)
1231     cfun->curr_properties = pass->properties_required;
1232
1233   /* Note that the folders should only create gimple expressions.
1234      This is a hack until the new folder is ready.  */
1235   in_gimple_form = (cfun && (cfun->curr_properties & PROP_trees)) != 0;
1236
1237   /* Run pre-pass verification.  */
1238   execute_todo (pass->todo_flags_start);
1239
1240 #ifdef ENABLE_CHECKING
1241   do_per_function (verify_curr_properties,
1242                    (void *)(size_t)pass->properties_required);
1243 #endif
1244
1245   initializing_dump = pass_init_dump_file (pass);
1246
1247   /* If a timevar is present, start it.  */
1248   if (pass->tv_id)
1249     timevar_push (pass->tv_id);
1250
1251   /* Do it!  */
1252   if (pass->execute)
1253     {
1254       todo_after = pass->execute ();
1255       do_per_function (clear_last_verified, NULL);
1256     }
1257
1258   /* Stop timevar.  */
1259   if (pass->tv_id)
1260     timevar_pop (pass->tv_id);
1261
1262   do_per_function (update_properties_after_pass, pass);
1263
1264   if (initializing_dump
1265       && dump_file
1266       && graph_dump_format != no_graph
1267       && (cfun->curr_properties & (PROP_cfg | PROP_rtl))
1268           == (PROP_cfg | PROP_rtl))
1269     {
1270       get_dump_file_info (pass->static_pass_number)->flags |= TDF_GRAPH;
1271       dump_flags |= TDF_GRAPH;
1272       clean_graph_dump_file (dump_file_name);
1273     }
1274
1275   /* Run post-pass cleanup and verification.  */
1276   execute_todo (todo_after | pass->todo_flags_finish);
1277   verify_interpass_invariants ();
1278   if (pass->type == IPA_PASS)
1279     do_per_function (add_ipa_transform_pass, pass);
1280
1281   if (!current_function_decl)
1282     cgraph_process_new_functions ();
1283
1284   pass_fini_dump_file (pass);
1285
1286   if (pass->type != SIMPLE_IPA_PASS && pass->type != IPA_PASS)
1287     gcc_assert (!(cfun->curr_properties & PROP_trees)
1288                 || pass->type != RTL_PASS);
1289
1290   current_pass = NULL;
1291   /* Reset in_gimple_form to not break non-unit-at-a-time mode.  */
1292   in_gimple_form = false;
1293
1294   return true;
1295 }
1296
1297 void
1298 execute_pass_list (struct opt_pass *pass)
1299 {
1300   do
1301     {
1302       gcc_assert (pass->type == GIMPLE_PASS
1303                   || pass->type == RTL_PASS);
1304       if (execute_one_pass (pass) && pass->sub)
1305         execute_pass_list (pass->sub);
1306       pass = pass->next;
1307     }
1308   while (pass);
1309 }
1310
1311 /* Same as execute_pass_list but assume that subpasses of IPA passes
1312    are local passes.  */
1313 void
1314 execute_ipa_pass_list (struct opt_pass *pass)
1315 {
1316   bool summaries_generated = false;
1317   do
1318     {
1319       gcc_assert (!current_function_decl);
1320       gcc_assert (!cfun);
1321       gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS);
1322       if (pass->type == IPA_PASS && (!pass->gate || pass->gate ()))
1323         {
1324           if (!summaries_generated)
1325             {
1326               if (!quiet_flag && !cfun)
1327                 fprintf (stderr, " <summary generate>");
1328               do_per_function_toporder (execute_ipa_summary_passes, pass);
1329             }
1330           summaries_generated = true;
1331         }
1332       else
1333         summaries_generated = false;
1334       if (execute_one_pass (pass) && pass->sub)
1335         {
1336           if (pass->sub->type == GIMPLE_PASS)
1337             do_per_function_toporder ((void (*)(void *))execute_pass_list,
1338                                       pass->sub);
1339           else if (pass->sub->type == SIMPLE_IPA_PASS
1340                    || pass->sub->type == IPA_PASS)
1341             execute_ipa_pass_list (pass->sub);
1342           else
1343             gcc_unreachable ();
1344         }
1345       if (!current_function_decl)
1346         cgraph_process_new_functions ();
1347       pass = pass->next;
1348     }
1349   while (pass);
1350 }
1351 #include "gt-passes.h"