gcc/passes.c

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