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, 2008, 2009
   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 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   int 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   "*rest_of_compilation",               /* 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   TV_NONE,                              /* 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 /* A map from static pass id to optimization pass.  */
 337 struct opt_pass **passes_by_id;
 338 int passes_by_id_size;
 339
 340 /* Set the static pass number of pass PASS to ID and record that
 341    in the mapping from static pass number to pass.  */
 342
 343 static void
 344 set_pass_for_id (int id, struct opt_pass *pass)
 345 {
 346   pass->static_pass_number = id;
 347   if (passes_by_id_size <= id)
 348     {
 349       passes_by_id = XRESIZEVEC (struct opt_pass *, passes_by_id, id + 1);
 350       memset (passes_by_id + passes_by_id_size, 0,
 351               (id + 1 - passes_by_id_size) * sizeof (void *));
 352       passes_by_id_size = id + 1;
 353     }
 354   passes_by_id[id] = pass;
 355 }
 356
 357 /* Return the pass with the static pass number ID.  */
 358
 359 struct opt_pass *
 360 get_pass_for_id (int id)
 361 {
 362   if (id >= passes_by_id_size)
 363     return NULL;
 364   return passes_by_id[id];
 365 }
 366
 367 /* Iterate over the pass tree allocating dump file numbers.  We want
 368    to do this depth first, and independent of whether the pass is
 369    enabled or not.  */
 370
 371 void
 372 register_one_dump_file (struct opt_pass *pass)
 373 {
 374   char *dot_name, *flag_name, *glob_name;
 375   const char *prefix;
 376   char num[10];
 377   int flags, id;
 378
 379   /* See below in next_pass_1.  */
 380   num[0] = '\0';
 381   if (pass->static_pass_number != -1)
 382     sprintf (num, "%d", ((int) pass->static_pass_number < 0
 383                          ? 1 : pass->static_pass_number));
 384
 385   dot_name = concat (".", pass->name, num, NULL);
 386   if (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS)
 387     prefix = "ipa-", flags = TDF_IPA;
 388   else if (pass->type == GIMPLE_PASS)
 389     prefix = "tree-", flags = TDF_TREE;
 390   else
 391     prefix = "rtl-", flags = TDF_RTL;
 392
 393   flag_name = concat (prefix, pass->name, num, NULL);
 394   glob_name = concat (prefix, pass->name, NULL);
 395   id = dump_register (dot_name, flag_name, glob_name, flags);
 396   set_pass_for_id (id, pass);
 397 }
 398
 399 /* Recursive worker function for register_dump_files.  */
 400
 401 static int
 402 register_dump_files_1 (struct opt_pass *pass, int properties)
 403 {
 404   do
 405     {
 406       int new_properties = (properties | pass->properties_provided)
 407                            & ~pass->properties_destroyed;
 408
 409       if (pass->name && pass->name[0] != '*')
 410         register_one_dump_file (pass);
 411
 412       if (pass->sub)
 413         new_properties = register_dump_files_1 (pass->sub, new_properties);
 414
 415       /* If we have a gate, combine the properties that we could have with
 416          and without the pass being examined.  */
 417       if (pass->gate)
 418         properties &= new_properties;
 419       else
 420         properties = new_properties;
 421
 422       pass = pass->next;
 423     }
 424   while (pass);
 425
 426   return properties;
 427 }
 428
 429 /* Register the dump files for the pipeline starting at PASS.
 430    PROPERTIES reflects the properties that are guaranteed to be available at
 431    the beginning of the pipeline.  */
 432
 433 static void
 434 register_dump_files (struct opt_pass *pass,int properties)
 435 {
 436   pass->properties_required |= properties;
 437   register_dump_files_1 (pass, properties);
 438 }
 439
 440 /* Add a pass to the pass list. Duplicate the pass if it's already
 441    in the list.  */
 442
 443 static struct opt_pass **
 444 next_pass_1 (struct opt_pass **list, struct opt_pass *pass)
 445 {
 446   /* A nonzero static_pass_number indicates that the
 447      pass is already in the list.  */
 448   if (pass->static_pass_number)
 449     {
 450       struct opt_pass *new_pass;
 451
 452       new_pass = XNEW (struct opt_pass);
 453       memcpy (new_pass, pass, sizeof (*new_pass));
 454       new_pass->next = NULL;
 455
 456       new_pass->todo_flags_start &= ~TODO_mark_first_instance;
 457
 458       /* Indicate to register_dump_files that this pass has duplicates,
 459          and so it should rename the dump file.  The first instance will
 460          be -1, and be number of duplicates = -static_pass_number - 1.
 461          Subsequent instances will be > 0 and just the duplicate number.  */
 462       if (pass->name)
 463         {
 464           pass->static_pass_number -= 1;
 465           new_pass->static_pass_number = -pass->static_pass_number;
 466         }
 467
 468       *list = new_pass;
 469     }
 470   else
 471     {
 472       pass->todo_flags_start |= TODO_mark_first_instance;
 473       pass->static_pass_number = -1;
 474       *list = pass;
 475     }
 476
 477   return &(*list)->next;
 478
 479 }
 480
 481
 482 /* Construct the pass tree.  The sequencing of passes is driven by
 483    the cgraph routines:
 484
 485    cgraph_finalize_compilation_unit ()
 486        for each node N in the cgraph
 487            cgraph_analyze_function (N)
 488                cgraph_lower_function (N) -> all_lowering_passes
 489
 490    If we are optimizing, cgraph_optimize is then invoked:
 491
 492    cgraph_optimize ()
 493        ipa_passes ()                    -> all_ipa_passes
 494        cgraph_expand_all_functions ()
 495            for each node N in the cgraph
 496                cgraph_expand_function (N)
 497                   tree_rest_of_compilation (DECL (N))  -> all_passes
 498 */
 499
 500 void
 501 init_optimization_passes (void)
 502 {
 503   struct opt_pass **p;
 504
 505 #define NEXT_PASS(PASS)  (p = next_pass_1 (p, &((PASS).pass)))
 506
 507  /* All passes needed to lower the function into shape optimizers can
 508     operate on.  These passes are always run first on the function, but
 509     backend might produce already lowered functions that are not processed
 510     by these passes.  */
 511   p = &all_lowering_passes;
 512   NEXT_PASS (pass_warn_unused_result);
 513   NEXT_PASS (pass_diagnose_omp_blocks);
 514   NEXT_PASS (pass_remove_useless_stmts);
 515   NEXT_PASS (pass_mudflap_1);
 516   NEXT_PASS (pass_lower_omp);
 517   NEXT_PASS (pass_lower_cf);
 518   NEXT_PASS (pass_refactor_eh);
 519   NEXT_PASS (pass_lower_eh);
 520   NEXT_PASS (pass_build_cfg);
 521   NEXT_PASS (pass_lower_complex_O0);
 522   NEXT_PASS (pass_lower_vector);
 523   NEXT_PASS (pass_warn_function_return);
 524   NEXT_PASS (pass_build_cgraph_edges);
 525   NEXT_PASS (pass_inline_parameters);
 526   *p = NULL;
 527
 528   /* Interprocedural optimization passes.  */
 529   p = &all_ipa_passes;
 530   NEXT_PASS (pass_ipa_function_and_variable_visibility);
 531   NEXT_PASS (pass_ipa_early_inline);
 532     {
 533       struct opt_pass **p = &pass_ipa_early_inline.pass.sub;
 534       NEXT_PASS (pass_early_inline);
 535       NEXT_PASS (pass_inline_parameters);
 536       NEXT_PASS (pass_rebuild_cgraph_edges);
 537     }
 538   NEXT_PASS (pass_ipa_free_lang_data);
 539   NEXT_PASS (pass_early_local_passes);
 540     {
 541       struct opt_pass **p = &pass_early_local_passes.pass.sub;
 542       NEXT_PASS (pass_fixup_cfg);
 543       NEXT_PASS (pass_tree_profile);
 544       NEXT_PASS (pass_cleanup_cfg);
 545       NEXT_PASS (pass_init_datastructures);
 546       NEXT_PASS (pass_expand_omp);
 547
 548       NEXT_PASS (pass_referenced_vars);
 549       NEXT_PASS (pass_build_ssa);
 550       NEXT_PASS (pass_early_warn_uninitialized);
 551       NEXT_PASS (pass_all_early_optimizations);
 552         {
 553           struct opt_pass **p = &pass_all_early_optimizations.pass.sub;
 554           NEXT_PASS (pass_rebuild_cgraph_edges);
 555           NEXT_PASS (pass_early_inline);
 556           NEXT_PASS (pass_remove_cgraph_callee_edges);
 557           NEXT_PASS (pass_rename_ssa_copies);
 558           NEXT_PASS (pass_ccp);
 559           NEXT_PASS (pass_forwprop);
 560           /* pass_build_ealias is a dummy pass that ensures that we
 561              execute TODO_rebuild_alias at this point.  Re-building
 562              alias information also rewrites no longer addressed
 563              locals into SSA form if possible.  */
 564           NEXT_PASS (pass_build_ealias);
 565           NEXT_PASS (pass_sra_early);
 566           NEXT_PASS (pass_copy_prop);
 567           NEXT_PASS (pass_merge_phi);
 568           NEXT_PASS (pass_cd_dce);
 569           NEXT_PASS (pass_early_ipa_sra);
 570           NEXT_PASS (pass_tail_recursion);
 571           NEXT_PASS (pass_convert_switch);
 572           NEXT_PASS (pass_cleanup_eh);
 573           NEXT_PASS (pass_profile);
 574           NEXT_PASS (pass_local_pure_const);
 575         }
 576       NEXT_PASS (pass_release_ssa_names);
 577       NEXT_PASS (pass_rebuild_cgraph_edges);
 578       NEXT_PASS (pass_inline_parameters);
 579     }
 580   NEXT_PASS (pass_ipa_increase_alignment);
 581   NEXT_PASS (pass_ipa_matrix_reorg);
 582   NEXT_PASS (pass_ipa_cp);
 583   NEXT_PASS (pass_ipa_inline);
 584   NEXT_PASS (pass_ipa_reference);
 585   NEXT_PASS (pass_ipa_pure_const);
 586   NEXT_PASS (pass_ipa_type_escape);
 587   NEXT_PASS (pass_ipa_pta);
 588   NEXT_PASS (pass_ipa_struct_reorg);
 589   *p = NULL;
 590
 591   /* These passes are run after IPA passes on every function that is being
 592      output to the assembler file.  */
 593   p = &all_passes;
 594   NEXT_PASS (pass_lower_eh_dispatch);
 595   NEXT_PASS (pass_all_optimizations);
 596     {
 597       struct opt_pass **p = &pass_all_optimizations.pass.sub;
 598       NEXT_PASS (pass_remove_cgraph_callee_edges);
 599       /* Initial scalar cleanups before alias computation.
 600          They ensure memory accesses are not indirect wherever possible.  */
 601       NEXT_PASS (pass_strip_predict_hints);
 602       NEXT_PASS (pass_update_address_taken);
 603       NEXT_PASS (pass_rename_ssa_copies);
 604       NEXT_PASS (pass_complete_unrolli);
 605       NEXT_PASS (pass_ccp);
 606       NEXT_PASS (pass_forwprop);
 607       NEXT_PASS (pass_call_cdce);
 608       /* pass_build_alias is a dummy pass that ensures that we
 609          execute TODO_rebuild_alias at this point.  Re-building
 610          alias information also rewrites no longer addressed
 611          locals into SSA form if possible.  */
 612       NEXT_PASS (pass_build_alias);
 613       NEXT_PASS (pass_return_slot);
 614       NEXT_PASS (pass_phiprop);
 615       NEXT_PASS (pass_fre);
 616       NEXT_PASS (pass_copy_prop);
 617       NEXT_PASS (pass_merge_phi);
 618       NEXT_PASS (pass_vrp);
 619       NEXT_PASS (pass_dce);
 620       NEXT_PASS (pass_cselim);
 621       NEXT_PASS (pass_tree_ifcombine);
 622       NEXT_PASS (pass_phiopt);
 623       NEXT_PASS (pass_tail_recursion);
 624       NEXT_PASS (pass_ch);
 625       NEXT_PASS (pass_stdarg);
 626       NEXT_PASS (pass_lower_complex);
 627       NEXT_PASS (pass_sra);
 628       NEXT_PASS (pass_rename_ssa_copies);
 629       /* The dom pass will also resolve all __builtin_constant_p calls
 630          that are still there to 0.  This has to be done after some
 631          propagations have already run, but before some more dead code
 632          is removed, and this place fits nicely.  Remember this when
 633          trying to move or duplicate pass_dominator somewhere earlier.  */
 634       NEXT_PASS (pass_dominator);
 635       /* The only const/copy propagation opportunities left after
 636          DOM should be due to degenerate PHI nodes.  So rather than
 637          run the full propagators, run a specialized pass which
 638          only examines PHIs to discover const/copy propagation
 639          opportunities.  */
 640       NEXT_PASS (pass_phi_only_cprop);
 641       NEXT_PASS (pass_dse);
 642       NEXT_PASS (pass_reassoc);
 643       NEXT_PASS (pass_dce);
 644       NEXT_PASS (pass_forwprop);
 645       NEXT_PASS (pass_phiopt);
 646       NEXT_PASS (pass_object_sizes);
 647       NEXT_PASS (pass_ccp);
 648       NEXT_PASS (pass_copy_prop);
 649       NEXT_PASS (pass_cse_sincos);
 650       NEXT_PASS (pass_optimize_bswap);
 651       NEXT_PASS (pass_split_crit_edges);
 652       NEXT_PASS (pass_pre);
 653       NEXT_PASS (pass_sink_code);
 654       NEXT_PASS (pass_tree_loop);
 655         {
 656           struct opt_pass **p = &pass_tree_loop.pass.sub;
 657           NEXT_PASS (pass_tree_loop_init);
 658           NEXT_PASS (pass_copy_prop);
 659           NEXT_PASS (pass_dce_loop);
 660           NEXT_PASS (pass_lim);
 661           NEXT_PASS (pass_tree_unswitch);
 662           NEXT_PASS (pass_scev_cprop);
 663           NEXT_PASS (pass_record_bounds);
 664           NEXT_PASS (pass_check_data_deps);
 665           NEXT_PASS (pass_loop_distribution);
 666           NEXT_PASS (pass_linear_transform);
 667           NEXT_PASS (pass_graphite_transforms);
 668             {
 669               struct opt_pass **p = &pass_graphite_transforms.pass.sub;
 670               NEXT_PASS (pass_dce_loop);
 671               NEXT_PASS (pass_lim);
 672             }
 673           NEXT_PASS (pass_iv_canon);
 674           NEXT_PASS (pass_if_conversion);
 675           NEXT_PASS (pass_vectorize);
 676             {
 677               struct opt_pass **p = &pass_vectorize.pass.sub;
 678               NEXT_PASS (pass_lower_vector_ssa);
 679               NEXT_PASS (pass_dce_loop);
 680             }
 681           NEXT_PASS (pass_predcom);
 682           NEXT_PASS (pass_complete_unroll);
 683           NEXT_PASS (pass_slp_vectorize);
 684           NEXT_PASS (pass_parallelize_loops);
 685           NEXT_PASS (pass_loop_prefetch);
 686           NEXT_PASS (pass_iv_optimize);
 687           NEXT_PASS (pass_tree_loop_done);
 688         }
 689       NEXT_PASS (pass_cse_reciprocals);
 690       NEXT_PASS (pass_convert_to_rsqrt);
 691       NEXT_PASS (pass_reassoc);
 692       NEXT_PASS (pass_vrp);
 693       NEXT_PASS (pass_dominator);
 694       /* The only const/copy propagation opportunities left after
 695          DOM should be due to degenerate PHI nodes.  So rather than
 696          run the full propagators, run a specialized pass which
 697          only examines PHIs to discover const/copy propagation
 698          opportunities.  */
 699       NEXT_PASS (pass_phi_only_cprop);
 700       NEXT_PASS (pass_cd_dce);
 701       NEXT_PASS (pass_tracer);
 702
 703       /* FIXME: If DCE is not run before checking for uninitialized uses,
 704          we may get false warnings (e.g., testsuite/gcc.dg/uninit-5.c).
 705          However, this also causes us to misdiagnose cases that should be
 706          real warnings (e.g., testsuite/gcc.dg/pr18501.c).
 707
 708          To fix the false positives in uninit-5.c, we would have to
 709          account for the predicates protecting the set and the use of each
 710          variable.  Using a representation like Gated Single Assignment
 711          may help.  */
 712       NEXT_PASS (pass_late_warn_uninitialized);
 713       NEXT_PASS (pass_dse);
 714       NEXT_PASS (pass_forwprop);
 715       NEXT_PASS (pass_phiopt);
 716       NEXT_PASS (pass_fold_builtins);
 717       NEXT_PASS (pass_tail_calls);
 718       NEXT_PASS (pass_rename_ssa_copies);
 719       NEXT_PASS (pass_uncprop);
 720       NEXT_PASS (pass_local_pure_const);
 721     }
 722   NEXT_PASS (pass_cleanup_eh);
 723   NEXT_PASS (pass_lower_resx);
 724   NEXT_PASS (pass_nrv);
 725   NEXT_PASS (pass_mudflap_2);
 726   NEXT_PASS (pass_cleanup_cfg_post_optimizing);
 727   NEXT_PASS (pass_warn_function_noreturn);
 728
 729   NEXT_PASS (pass_expand);
 730
 731   NEXT_PASS (pass_rest_of_compilation);
 732     {
 733       struct opt_pass **p = &pass_rest_of_compilation.pass.sub;
 734       NEXT_PASS (pass_init_function);
 735       NEXT_PASS (pass_jump);
 736       NEXT_PASS (pass_rtl_eh);
 737       NEXT_PASS (pass_initial_value_sets);
 738       NEXT_PASS (pass_unshare_all_rtl);
 739       NEXT_PASS (pass_instantiate_virtual_regs);
 740       NEXT_PASS (pass_into_cfg_layout_mode);
 741       NEXT_PASS (pass_jump2);
 742       NEXT_PASS (pass_lower_subreg);
 743       NEXT_PASS (pass_df_initialize_opt);
 744       NEXT_PASS (pass_cse);
 745       NEXT_PASS (pass_rtl_fwprop);
 746       NEXT_PASS (pass_rtl_cprop);
 747       NEXT_PASS (pass_rtl_pre);
 748       NEXT_PASS (pass_rtl_hoist);
 749       NEXT_PASS (pass_rtl_cprop);
 750       NEXT_PASS (pass_rtl_store_motion);
 751       NEXT_PASS (pass_cse_after_global_opts);
 752       NEXT_PASS (pass_rtl_ifcvt);
 753       /* Perform loop optimizations.  It might be better to do them a bit
 754          sooner, but we want the profile feedback to work more
 755          efficiently.  */
 756       NEXT_PASS (pass_loop2);
 757         {
 758           struct opt_pass **p = &pass_loop2.pass.sub;
 759           NEXT_PASS (pass_rtl_loop_init);
 760           NEXT_PASS (pass_rtl_move_loop_invariants);
 761           NEXT_PASS (pass_rtl_unswitch);
 762           NEXT_PASS (pass_rtl_unroll_and_peel_loops);
 763           NEXT_PASS (pass_rtl_doloop);
 764           NEXT_PASS (pass_rtl_loop_done);
 765           *p = NULL;
 766         }
 767       NEXT_PASS (pass_web);
 768       NEXT_PASS (pass_rtl_cprop);
 769       NEXT_PASS (pass_cse2);
 770       NEXT_PASS (pass_rtl_dse1);
 771       NEXT_PASS (pass_rtl_fwprop_addr);
 772       NEXT_PASS (pass_reginfo_init);
 773       NEXT_PASS (pass_inc_dec);
 774       NEXT_PASS (pass_initialize_regs);
 775       NEXT_PASS (pass_ud_rtl_dce);
 776       NEXT_PASS (pass_combine);
 777       NEXT_PASS (pass_if_after_combine);
 778       NEXT_PASS (pass_partition_blocks);
 779       NEXT_PASS (pass_regmove);
 780       NEXT_PASS (pass_outof_cfg_layout_mode);
 781       NEXT_PASS (pass_split_all_insns);
 782       NEXT_PASS (pass_lower_subreg2);
 783       NEXT_PASS (pass_df_initialize_no_opt);
 784       NEXT_PASS (pass_stack_ptr_mod);
 785       NEXT_PASS (pass_mode_switching);
 786       NEXT_PASS (pass_match_asm_constraints);
 787       NEXT_PASS (pass_sms);
 788       NEXT_PASS (pass_subregs_of_mode_init);
 789       NEXT_PASS (pass_sched);
 790       NEXT_PASS (pass_ira);
 791       NEXT_PASS (pass_subregs_of_mode_finish);
 792       NEXT_PASS (pass_postreload);
 793         {
 794           struct opt_pass **p = &pass_postreload.pass.sub;
 795           NEXT_PASS (pass_postreload_cse);
 796           NEXT_PASS (pass_gcse2);
 797           NEXT_PASS (pass_split_after_reload);
 798           NEXT_PASS (pass_branch_target_load_optimize1);
 799           NEXT_PASS (pass_thread_prologue_and_epilogue);
 800           NEXT_PASS (pass_rtl_dse2);
 801           NEXT_PASS (pass_stack_adjustments);
 802           NEXT_PASS (pass_peephole2);
 803           NEXT_PASS (pass_if_after_reload);
 804           NEXT_PASS (pass_regrename);
 805           NEXT_PASS (pass_cprop_hardreg);
 806           NEXT_PASS (pass_fast_rtl_dce);
 807           NEXT_PASS (pass_reorder_blocks);
 808           NEXT_PASS (pass_branch_target_load_optimize2);
 809           NEXT_PASS (pass_leaf_regs);
 810           NEXT_PASS (pass_split_before_sched2);
 811           NEXT_PASS (pass_sched2);
 812           NEXT_PASS (pass_stack_regs);
 813             {
 814               struct opt_pass **p = &pass_stack_regs.pass.sub;
 815               NEXT_PASS (pass_split_before_regstack);
 816               NEXT_PASS (pass_stack_regs_run);
 817             }
 818           NEXT_PASS (pass_compute_alignments);
 819           NEXT_PASS (pass_duplicate_computed_gotos);
 820           NEXT_PASS (pass_variable_tracking);
 821           NEXT_PASS (pass_free_cfg);
 822           NEXT_PASS (pass_machine_reorg);
 823           NEXT_PASS (pass_cleanup_barriers);
 824           NEXT_PASS (pass_delay_slots);
 825           NEXT_PASS (pass_split_for_shorten_branches);
 826           NEXT_PASS (pass_convert_to_eh_region_ranges);
 827           NEXT_PASS (pass_shorten_branches);
 828           NEXT_PASS (pass_set_nothrow_function_flags);
 829           NEXT_PASS (pass_final);
 830         }
 831       NEXT_PASS (pass_df_finish);
 832     }
 833   NEXT_PASS (pass_clean_state);
 834   *p = NULL;
 835
 836 #undef NEXT_PASS
 837
 838   /* Register the passes with the tree dump code.  */
 839   register_dump_files (all_lowering_passes, PROP_gimple_any);
 840   register_dump_files (all_ipa_passes,
 841                        PROP_gimple_any | PROP_gimple_lcf | PROP_gimple_leh
 842                        | PROP_cfg);
 843   register_dump_files (all_passes,
 844                        PROP_gimple_any | PROP_gimple_lcf | PROP_gimple_leh
 845                        | PROP_cfg);
 846 }
 847
 848 /* If we are in IPA mode (i.e., current_function_decl is NULL), call
 849    function CALLBACK for every function in the call graph.  Otherwise,
 850    call CALLBACK on the current function.  */
 851
 852 static void
 853 do_per_function (void (*callback) (void *data), void *data)
 854 {
 855   if (current_function_decl)
 856     callback (data);
 857   else
 858     {
 859       struct cgraph_node *node;
 860       for (node = cgraph_nodes; node; node = node->next)
 861         if (node->analyzed && gimple_has_body_p (node->decl)
 862             && (!node->clone_of || node->decl != node->clone_of->decl))
 863           {
 864             push_cfun (DECL_STRUCT_FUNCTION (node->decl));
 865             current_function_decl = node->decl;
 866             callback (data);
 867             free_dominance_info (CDI_DOMINATORS);
 868             free_dominance_info (CDI_POST_DOMINATORS);
 869             current_function_decl = NULL;
 870             pop_cfun ();
 871             ggc_collect ();
 872           }
 873     }
 874 }
 875
 876 /* Because inlining might remove no-longer reachable nodes, we need to
 877    keep the array visible to garbage collector to avoid reading collected
 878    out nodes.  */
 879 static int nnodes;
 880 static GTY ((length ("nnodes"))) struct cgraph_node **order;
 881
 882 /* If we are in IPA mode (i.e., current_function_decl is NULL), call
 883    function CALLBACK for every function in the call graph.  Otherwise,
 884    call CALLBACK on the current function.  */
 885
 886 static void
 887 do_per_function_toporder (void (*callback) (void *data), void *data)
 888 {
 889   int i;
 890
 891   if (current_function_decl)
 892     callback (data);
 893   else
 894     {
 895       gcc_assert (!order);
 896       order = GGC_NEWVEC (struct cgraph_node *, cgraph_n_nodes);
 897       nnodes = cgraph_postorder (order);
 898       for (i = nnodes - 1; i >= 0; i--)
 899         order[i]->process = 1;
 900       for (i = nnodes - 1; i >= 0; i--)
 901         {
 902           struct cgraph_node *node = order[i];
 903
 904           /* Allow possibly removed nodes to be garbage collected.  */
 905           order[i] = NULL;
 906           node->process = 0;
 907           if (node->analyzed && (node->needed || node->reachable))
 908             {
 909               push_cfun (DECL_STRUCT_FUNCTION (node->decl));
 910               current_function_decl = node->decl;
 911               callback (data);
 912               free_dominance_info (CDI_DOMINATORS);
 913               free_dominance_info (CDI_POST_DOMINATORS);
 914               current_function_decl = NULL;
 915               pop_cfun ();
 916               ggc_collect ();
 917             }
 918         }
 919     }
 920   ggc_free (order);
 921   order = NULL;
 922   nnodes = 0;
 923 }
 924
 925 /* Perform all TODO actions that ought to be done on each function.  */
 926
 927 static void
 928 execute_function_todo (void *data)
 929 {
 930   unsigned int flags = (size_t)data;
 931   if (cfun->curr_properties & PROP_ssa)
 932     flags |= TODO_verify_ssa;
 933   flags &= ~cfun->last_verified;
 934   if (!flags)
 935     return;
 936
 937   statistics_fini_pass ();
 938
 939   /* Always cleanup the CFG before trying to update SSA.  */
 940   if (flags & TODO_cleanup_cfg)
 941     {
 942       bool cleanup = cleanup_tree_cfg ();
 943
 944       if (cleanup && (cfun->curr_properties & PROP_ssa))
 945         flags |= TODO_remove_unused_locals;
 946
 947       /* When cleanup_tree_cfg merges consecutive blocks, it may
 948          perform some simplistic propagation when removing single
 949          valued PHI nodes.  This propagation may, in turn, cause the
 950          SSA form to become out-of-date (see PR 22037).  So, even
 951          if the parent pass had not scheduled an SSA update, we may
 952          still need to do one.  */
 953       if (!(flags & TODO_update_ssa_any) && need_ssa_update_p (cfun))
 954         flags |= TODO_update_ssa;
 955     }
 956
 957   if (flags & TODO_update_ssa_any)
 958     {
 959       unsigned update_flags = flags & TODO_update_ssa_any;
 960       update_ssa (update_flags);
 961       cfun->last_verified &= ~TODO_verify_ssa;
 962     }
 963
 964   if (flags & TODO_update_address_taken)
 965     execute_update_addresses_taken (true);
 966
 967   if (flags & TODO_rebuild_alias)
 968     {
 969       if (!(flags & TODO_update_address_taken))
 970         execute_update_addresses_taken (true);
 971       compute_may_aliases ();
 972     }
 973
 974   if (flags & TODO_remove_unused_locals)
 975     remove_unused_locals ();
 976
 977   if ((flags & TODO_dump_func) && dump_file && current_function_decl)
 978     {
 979       if (cfun->curr_properties & PROP_trees)
 980         dump_function_to_file (current_function_decl, dump_file, dump_flags);
 981       else
 982         {
 983           if (dump_flags & TDF_SLIM)
 984             print_rtl_slim_with_bb (dump_file, get_insns (), dump_flags);
 985           else if ((cfun->curr_properties & PROP_cfg)
 986                    && (dump_flags & TDF_BLOCKS))
 987             print_rtl_with_bb (dump_file, get_insns ());
 988           else
 989             print_rtl (dump_file, get_insns ());
 990
 991           if ((cfun->curr_properties & PROP_cfg)
 992               && graph_dump_format != no_graph
 993               && (dump_flags & TDF_GRAPH))
 994             print_rtl_graph_with_bb (dump_file_name, get_insns ());
 995         }
 996
 997       /* Flush the file.  If verification fails, we won't be able to
 998          close the file before aborting.  */
 999       fflush (dump_file);
1000     }
1001
1002   if (flags & TODO_rebuild_frequencies)
1003     {
1004       if (profile_status == PROFILE_GUESSED)
1005         {
1006           loop_optimizer_init (0);
1007           add_noreturn_fake_exit_edges ();
1008           mark_irreducible_loops ();
1009           connect_infinite_loops_to_exit ();
1010           estimate_bb_frequencies ();
1011           remove_fake_exit_edges ();
1012           loop_optimizer_finalize ();
1013         }
1014       else if (profile_status == PROFILE_READ)
1015         counts_to_freqs ();
1016       else
1017         gcc_unreachable ();
1018     }
1019
1020 #if defined ENABLE_CHECKING
1021   if (flags & TODO_verify_ssa)
1022     verify_ssa (true);
1023   if (flags & TODO_verify_flow)
1024     verify_flow_info ();
1025   if (flags & TODO_verify_stmts)
1026     verify_stmts ();
1027   if (flags & TODO_verify_loops)
1028     verify_loop_closed_ssa ();
1029   if (flags & TODO_verify_rtl_sharing)
1030     verify_rtl_sharing ();
1031 #endif
1032
1033   cfun->last_verified = flags & TODO_verify_all;
1034 }
1035
1036 /* Perform all TODO actions.  */
1037 static void
1038 execute_todo (unsigned int flags)
1039 {
1040 #if defined ENABLE_CHECKING
1041   if (cfun
1042       && need_ssa_update_p (cfun))
1043     gcc_assert (flags & TODO_update_ssa_any);
1044 #endif
1045
1046   /* Inform the pass whether it is the first time it is run.  */
1047   first_pass_instance = (flags & TODO_mark_first_instance) != 0;
1048
1049   do_per_function (execute_function_todo, (void *)(size_t) flags);
1050
1051   /* Always remove functions just as before inlining: IPA passes might be
1052      interested to see bodies of extern inline functions that are not inlined
1053      to analyze side effects.  The full removal is done just at the end
1054      of IPA pass queue.  */
1055   if (flags & TODO_remove_functions)
1056     {
1057       gcc_assert (!cfun);
1058       cgraph_remove_unreachable_nodes (true, dump_file);
1059     }
1060
1061   if ((flags & TODO_dump_cgraph) && dump_file && !current_function_decl)
1062     {
1063       gcc_assert (!cfun);
1064       dump_cgraph (dump_file);
1065       /* Flush the file.  If verification fails, we won't be able to
1066          close the file before aborting.  */
1067       fflush (dump_file);
1068     }
1069
1070   if (flags & TODO_ggc_collect)
1071     ggc_collect ();
1072
1073   /* Now that the dumping has been done, we can get rid of the optional
1074      df problems.  */
1075   if (flags & TODO_df_finish)
1076     df_finish_pass ((flags & TODO_df_verify) != 0);
1077 }
1078
1079 /* Verify invariants that should hold between passes.  This is a place
1080    to put simple sanity checks.  */
1081
1082 static void
1083 verify_interpass_invariants (void)
1084 {
1085 #ifdef ENABLE_CHECKING
1086   gcc_assert (!fold_deferring_overflow_warnings_p ());
1087 #endif
1088 }
1089
1090 /* Clear the last verified flag.  */
1091
1092 static void
1093 clear_last_verified (void *data ATTRIBUTE_UNUSED)
1094 {
1095   cfun->last_verified = 0;
1096 }
1097
1098 /* Helper function. Verify that the properties has been turn into the
1099    properties expected by the pass.  */
1100
1101 #ifdef ENABLE_CHECKING
1102 static void
1103 verify_curr_properties (void *data)
1104 {
1105   unsigned int props = (size_t)data;
1106   gcc_assert ((cfun->curr_properties & props) == props);
1107 }
1108 #endif
1109
1110 /* Initialize pass dump file.  */
1111
1112 static bool
1113 pass_init_dump_file (struct opt_pass *pass)
1114 {
1115   /* If a dump file name is present, open it if enabled.  */
1116   if (pass->static_pass_number != -1)
1117     {
1118       bool initializing_dump = !dump_initialized_p (pass->static_pass_number);
1119       dump_file_name = get_dump_file_name (pass->static_pass_number);
1120       dump_file = dump_begin (pass->static_pass_number, &dump_flags);
1121       if (dump_file && current_function_decl)
1122         {
1123           const char *dname, *aname;
1124           dname = lang_hooks.decl_printable_name (current_function_decl, 2);
1125           aname = (IDENTIFIER_POINTER
1126                    (DECL_ASSEMBLER_NAME (current_function_decl)));
1127           fprintf (dump_file, "\n;; Function %s (%s)%s\n\n", dname, aname,
1128              cfun->function_frequency == FUNCTION_FREQUENCY_HOT
1129              ? " (hot)"
1130              : cfun->function_frequency == FUNCTION_FREQUENCY_UNLIKELY_EXECUTED
1131              ? " (unlikely executed)"
1132              : "");
1133         }
1134       return initializing_dump;
1135     }
1136   else
1137     return false;
1138 }
1139
1140 /* Flush PASS dump file.  */
1141
1142 static void
1143 pass_fini_dump_file (struct opt_pass *pass)
1144 {
1145   /* Flush and close dump file.  */
1146   if (dump_file_name)
1147     {
1148       free (CONST_CAST (char *, dump_file_name));
1149       dump_file_name = NULL;
1150     }
1151
1152   if (dump_file)
1153     {
1154       dump_end (pass->static_pass_number, dump_file);
1155       dump_file = NULL;
1156     }
1157 }
1158
1159 /* After executing the pass, apply expected changes to the function
1160    properties. */
1161
1162 static void
1163 update_properties_after_pass (void *data)
1164 {
1165   struct opt_pass *pass = (struct opt_pass *) data;
1166   cfun->curr_properties = (cfun->curr_properties | pass->properties_provided)
1167                            & ~pass->properties_destroyed;
1168 }
1169
1170 /* Schedule IPA transform pass DATA for CFUN.  */
1171
1172 static void
1173 add_ipa_transform_pass (void *data)
1174 {
1175   struct ipa_opt_pass_d *ipa_pass = (struct ipa_opt_pass_d *) data;
1176   VEC_safe_push (ipa_opt_pass, heap, cfun->ipa_transforms_to_apply, ipa_pass);
1177 }
1178
1179 /* Execute summary generation for all of the passes in IPA_PASS.  */
1180
1181 static void
1182 execute_ipa_summary_passes (struct ipa_opt_pass_d *ipa_pass)
1183 {
1184   while (ipa_pass)
1185     {
1186       struct opt_pass *pass = &ipa_pass->pass;
1187
1188       /* Execute all of the IPA_PASSes in the list.  */
1189       if (ipa_pass->pass.type == IPA_PASS
1190           && (!pass->gate || pass->gate ()))
1191         {
1192           pass_init_dump_file (pass);
1193           ipa_pass->generate_summary ();
1194           pass_fini_dump_file (pass);
1195         }
1196       ipa_pass = (struct ipa_opt_pass_d *)ipa_pass->pass.next;
1197     }
1198 }
1199
1200 /* Execute IPA_PASS function transform on NODE.  */
1201
1202 static void
1203 execute_one_ipa_transform_pass (struct cgraph_node *node,
1204                                 struct ipa_opt_pass_d *ipa_pass)
1205 {
1206   struct opt_pass *pass = &ipa_pass->pass;
1207   unsigned int todo_after = 0;
1208
1209   current_pass = pass;
1210   if (!ipa_pass->function_transform)
1211     return;
1212
1213   /* Note that the folders should only create gimple expressions.
1214      This is a hack until the new folder is ready.  */
1215   in_gimple_form = (cfun && (cfun->curr_properties & PROP_trees)) != 0;
1216
1217   pass_init_dump_file (pass);
1218
1219   /* Run pre-pass verification.  */
1220   execute_todo (ipa_pass->function_transform_todo_flags_start);
1221
1222   /* If a timevar is present, start it.  */
1223   if (pass->tv_id != TV_NONE)
1224     timevar_push (pass->tv_id);
1225
1226   /* Do it!  */
1227   todo_after = ipa_pass->function_transform (node);
1228
1229   /* Stop timevar.  */
1230   if (pass->tv_id != TV_NONE)
1231     timevar_pop (pass->tv_id);
1232
1233   /* Run post-pass cleanup and verification.  */
1234   execute_todo (todo_after);
1235   verify_interpass_invariants ();
1236
1237   pass_fini_dump_file (pass);
1238
1239   current_pass = NULL;
1240 }
1241
1242 static bool
1243 execute_one_pass (struct opt_pass *pass)
1244 {
1245   bool initializing_dump;
1246   unsigned int todo_after = 0;
1247
1248   /* IPA passes are executed on whole program, so cfun should be NULL.
1249      Other passes need function context set.  */
1250   if (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS)
1251     gcc_assert (!cfun && !current_function_decl);
1252   else
1253     gcc_assert (cfun && current_function_decl);
1254
1255   if (cfun && cfun->ipa_transforms_to_apply)
1256     {
1257       unsigned int i;
1258       struct cgraph_node *node = cgraph_node (current_function_decl);
1259
1260       for (i = 0; i < VEC_length (ipa_opt_pass, cfun->ipa_transforms_to_apply);
1261            i++)
1262         execute_one_ipa_transform_pass (node,
1263                                         VEC_index (ipa_opt_pass,
1264                                                    cfun->ipa_transforms_to_apply,
1265                                                    i));
1266       VEC_free (ipa_opt_pass, heap, cfun->ipa_transforms_to_apply);
1267       cfun->ipa_transforms_to_apply = NULL;
1268     }
1269
1270   current_pass = pass;
1271
1272   /* See if we're supposed to run this pass.  */
1273   if (pass->gate && !pass->gate ())
1274     return false;
1275
1276   if (!quiet_flag && !cfun)
1277     fprintf (stderr, " <%s>", pass->name ? pass->name : "");
1278
1279   /* Note that the folders should only create gimple expressions.
1280      This is a hack until the new folder is ready.  */
1281   in_gimple_form = (cfun && (cfun->curr_properties & PROP_trees)) != 0;
1282
1283   initializing_dump = pass_init_dump_file (pass);
1284
1285   /* Run pre-pass verification.  */
1286   execute_todo (pass->todo_flags_start);
1287
1288 #ifdef ENABLE_CHECKING
1289   do_per_function (verify_curr_properties,
1290                    (void *)(size_t)pass->properties_required);
1291 #endif
1292
1293   /* If a timevar is present, start it.  */
1294   if (pass->tv_id != TV_NONE)
1295     timevar_push (pass->tv_id);
1296
1297   /* Do it!  */
1298   if (pass->execute)
1299     {
1300       todo_after = pass->execute ();
1301       do_per_function (clear_last_verified, NULL);
1302     }
1303
1304   /* Stop timevar.  */
1305   if (pass->tv_id != TV_NONE)
1306     timevar_pop (pass->tv_id);
1307
1308   do_per_function (update_properties_after_pass, pass);
1309
1310   if (initializing_dump
1311       && dump_file
1312       && graph_dump_format != no_graph
1313       && cfun
1314       && (cfun->curr_properties & (PROP_cfg | PROP_rtl))
1315           == (PROP_cfg | PROP_rtl))
1316     {
1317       get_dump_file_info (pass->static_pass_number)->flags |= TDF_GRAPH;
1318       dump_flags |= TDF_GRAPH;
1319       clean_graph_dump_file (dump_file_name);
1320     }
1321
1322   /* Run post-pass cleanup and verification.  */
1323   execute_todo (todo_after | pass->todo_flags_finish);
1324   verify_interpass_invariants ();
1325   if (pass->type == IPA_PASS)
1326     do_per_function (add_ipa_transform_pass, pass);
1327
1328   if (!current_function_decl)
1329     cgraph_process_new_functions ();
1330
1331   pass_fini_dump_file (pass);
1332
1333   if (pass->type != SIMPLE_IPA_PASS && pass->type != IPA_PASS)
1334     gcc_assert (!(cfun->curr_properties & PROP_trees)
1335                 || pass->type != RTL_PASS);
1336
1337   current_pass = NULL;
1338
1339   return true;
1340 }
1341
1342 void
1343 execute_pass_list (struct opt_pass *pass)
1344 {
1345   do
1346     {
1347       gcc_assert (pass->type == GIMPLE_PASS
1348                   || pass->type == RTL_PASS);
1349       if (execute_one_pass (pass) && pass->sub)
1350         execute_pass_list (pass->sub);
1351       pass = pass->next;
1352     }
1353   while (pass);
1354 }
1355
1356 /* Same as execute_pass_list but assume that subpasses of IPA passes
1357    are local passes.  */
1358 void
1359 execute_ipa_pass_list (struct opt_pass *pass)
1360 {
1361   bool summaries_generated = false;
1362   do
1363     {
1364       gcc_assert (!current_function_decl);
1365       gcc_assert (!cfun);
1366       gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS);
1367       if (pass->type == IPA_PASS && (!pass->gate || pass->gate ()))
1368         {
1369           if (!summaries_generated)
1370             {
1371               if (!quiet_flag && !cfun)
1372                 fprintf (stderr, " <summary generate>");
1373               execute_ipa_summary_passes ((struct ipa_opt_pass_d *) pass);
1374             }
1375           summaries_generated = true;
1376         }
1377       if (execute_one_pass (pass) && pass->sub)
1378         {
1379           if (pass->sub->type == GIMPLE_PASS)
1380             do_per_function_toporder ((void (*)(void *))execute_pass_list,
1381                                       pass->sub);
1382           else if (pass->sub->type == SIMPLE_IPA_PASS
1383                    || pass->sub->type == IPA_PASS)
1384             execute_ipa_pass_list (pass->sub);
1385           else
1386             gcc_unreachable ();
1387         }
1388       if (!current_function_decl)
1389         cgraph_process_new_functions ();
1390       pass = pass->next;
1391     }
1392   while (pass);
1393 }
1394
1395 /* Called by local passes to see if function is called by already processed nodes.
1396    Because we process nodes in topological order, this means that function is
1397    in recursive cycle or we introduced new direct calls.  */
1398 bool
1399 function_called_by_processed_nodes_p (void)
1400 {
1401   struct cgraph_edge *e;
1402   for (e = cgraph_node (current_function_decl)->callers; e; e = e->next_caller)
1403     {
1404       if (e->caller->decl == current_function_decl)
1405         continue;
1406       if (!e->caller->analyzed || (!e->caller->needed && !e->caller->reachable))
1407         continue;
1408       if (TREE_ASM_WRITTEN (e->caller->decl))
1409         continue;
1410       if (!e->caller->process && !e->caller->global.inlined_to)
1411         break;
1412     }
1413   if (dump_file && e)
1414     {
1415       fprintf (dump_file, "Already processed call to:\n");
1416       dump_cgraph_node (dump_file, e->caller);
1417     }
1418   return e != NULL;
1419 }
1420
1421 #include "gt-passes.h"