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