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 Free Software Foundation, Inc. 4 5This file is part of GCC. 6 7GCC is free software; you can redistribute it and/or modify it under 8the terms of the GNU General Public License as published by the Free 9Software Foundation; either version 2, or (at your option) any later 10version. 11 12GCC is distributed in the hope that it will be useful, but WITHOUT ANY 13WARRANTY; without even the implied warranty of MERCHANTABILITY or 14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 15for more details. 16 17You should have received a copy of the GNU General Public License 18along with GCC; see the file COPYING. If not, write to the Free 19Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 2002110-1301, USA. */ 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 86#if defined (DWARF2_UNWIND_INFO) || defined (DWARF2_DEBUGGING_INFO) 87#include "dwarf2out.h" 88#endif 89 90#if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO) 91#include "dbxout.h" 92#endif 93 94#ifdef SDB_DEBUGGING_INFO 95#include "sdbout.h" 96#endif 97 98#ifdef XCOFF_DEBUGGING_INFO 99#include "xcoffout.h" /* Needed for external data 100 declarations for e.g. AIX 4.x. */ 101#endif 102 103/* Global variables used to communicate with passes. */ 104int dump_flags; 105bool in_gimple_form; 106 107 108/* This is called from various places for FUNCTION_DECL, VAR_DECL, 109 and TYPE_DECL nodes. 110 111 This does nothing for local (non-static) variables, unless the 112 variable is a register variable with DECL_ASSEMBLER_NAME set. In 113 that case, or if the variable is not an automatic, it sets up the 114 RTL and outputs any assembler code (label definition, storage 115 allocation and initialization). 116 117 DECL is the declaration. TOP_LEVEL is nonzero 118 if this declaration is not within a function. */ 119 120void 121rest_of_decl_compilation (tree decl, 122 int top_level, 123 int at_end) 124{ 125 /* We deferred calling assemble_alias so that we could collect 126 other attributes such as visibility. Emit the alias now. */ 127 { 128 tree alias; 129 alias = lookup_attribute ("alias", DECL_ATTRIBUTES (decl)); 130 if (alias) 131 { 132 alias = TREE_VALUE (TREE_VALUE (alias)); 133 alias = get_identifier (TREE_STRING_POINTER (alias)); 134 assemble_alias (decl, alias); 135 } 136 } 137 138 /* Can't defer this, because it needs to happen before any 139 later function definitions are processed. */ 140 if (DECL_ASSEMBLER_NAME_SET_P (decl) && DECL_REGISTER (decl)) 141 make_decl_rtl (decl); 142 143 /* Forward declarations for nested functions are not "external", 144 but we need to treat them as if they were. */ 145 if (TREE_STATIC (decl) || DECL_EXTERNAL (decl) 146 || TREE_CODE (decl) == FUNCTION_DECL) 147 { 148 timevar_push (TV_VARCONST); 149 150 /* Don't output anything when a tentative file-scope definition 151 is seen. But at end of compilation, do output code for them. 152 153 We do output all variables when unit-at-a-time is active and rely on 154 callgraph code to defer them except for forward declarations 155 (see gcc.c-torture/compile/920624-1.c) */ 156 if ((at_end 157 || !DECL_DEFER_OUTPUT (decl) 158 || DECL_INITIAL (decl)) 159 && !DECL_EXTERNAL (decl)) 160 { 161 if (TREE_CODE (decl) != FUNCTION_DECL) 162 cgraph_varpool_finalize_decl (decl); 163 else 164 assemble_variable (decl, top_level, at_end, 0); 165 } 166 167#ifdef ASM_FINISH_DECLARE_OBJECT 168 if (decl == last_assemble_variable_decl) 169 { 170 ASM_FINISH_DECLARE_OBJECT (asm_out_file, decl, 171 top_level, at_end); 172 } 173#endif 174 175 timevar_pop (TV_VARCONST); 176 } 177 else if (TREE_CODE (decl) == TYPE_DECL 178 /* Like in rest_of_type_compilation, avoid confusing the debug 179 information machinery when there are errors. */ 180 && !(sorrycount || errorcount)) 181 { 182 timevar_push (TV_SYMOUT); 183 debug_hooks->type_decl (decl, !top_level); 184 timevar_pop (TV_SYMOUT); 185 } 186 187 /* Let cgraph know about the existence of variables. */ 188 if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl)) 189 cgraph_varpool_node (decl); 190} 191 192/* Called after finishing a record, union or enumeral type. */ 193 194void 195rest_of_type_compilation (tree type, int toplev) 196{ 197 /* Avoid confusing the debug information machinery when there are 198 errors. */ 199 if (errorcount != 0 || sorrycount != 0) 200 return; 201 202 timevar_push (TV_SYMOUT); 203 debug_hooks->type_decl (TYPE_STUB_DECL (type), !toplev); 204 timevar_pop (TV_SYMOUT); 205} 206 207 208 209void 210finish_optimization_passes (void) 211{ 212 enum tree_dump_index i; 213 struct dump_file_info *dfi; 214 char *name; 215 216 timevar_push (TV_DUMP); 217 if (profile_arc_flag || flag_test_coverage || flag_branch_probabilities) 218 { 219 dump_file = dump_begin (pass_branch_prob.static_pass_number, NULL); 220 end_branch_prob (); 221 if (dump_file) 222 dump_end (pass_branch_prob.static_pass_number, dump_file); 223 } 224 225 if (optimize > 0) 226 { 227 dump_file = dump_begin (pass_combine.static_pass_number, NULL); 228 if (dump_file) 229 { 230 dump_combine_total_stats (dump_file); 231 dump_end (pass_combine.static_pass_number, dump_file); 232 } 233 } 234 235 /* Do whatever is necessary to finish printing the graphs. */ 236 if (graph_dump_format != no_graph) 237 for (i = TDI_end; (dfi = get_dump_file_info (i)) != NULL; ++i) 238 if (dump_initialized_p (i) 239 && (dfi->flags & TDF_GRAPH) != 0 240 && (name = get_dump_file_name (i)) != NULL) 241 { 242 finish_graph_dump_file (name); 243 free (name); 244 } 245 246 timevar_pop (TV_DUMP); 247} 248 249static bool 250gate_rest_of_compilation (void) 251{ 252 /* Early return if there were errors. We can run afoul of our 253 consistency checks, and there's not really much point in fixing them. */ 254 return !(rtl_dump_and_exit || flag_syntax_only || errorcount || sorrycount); 255} 256 257struct tree_opt_pass pass_rest_of_compilation = 258{ 259 NULL, /* name */ 260 gate_rest_of_compilation, /* gate */ 261 NULL, /* execute */ 262 NULL, /* sub */ 263 NULL, /* next */ 264 0, /* static_pass_number */ 265 TV_REST_OF_COMPILATION, /* tv_id */ 266 PROP_rtl, /* properties_required */ 267 0, /* properties_provided */ 268 0, /* properties_destroyed */ 269 0, /* todo_flags_start */ 270 TODO_ggc_collect, /* todo_flags_finish */ 271 0 /* letter */ 272}; 273 274static bool 275gate_postreload (void) 276{ 277 return reload_completed; 278} 279 280struct tree_opt_pass pass_postreload = 281{ 282 NULL, /* name */ 283 gate_postreload, /* gate */ 284 NULL, /* execute */ 285 NULL, /* sub */ 286 NULL, /* next */ 287 0, /* static_pass_number */ 288 0, /* tv_id */ 289 PROP_rtl, /* properties_required */ 290 0, /* properties_provided */ 291 0, /* properties_destroyed */ 292 0, /* todo_flags_start */ 293 TODO_ggc_collect, /* todo_flags_finish */ 294 0 /* letter */ 295}; 296 297 298 299/* The root of the compilation pass tree, once constructed. */ 300struct tree_opt_pass *all_passes, *all_ipa_passes, *all_lowering_passes; 301 302/* Iterate over the pass tree allocating dump file numbers. We want 303 to do this depth first, and independent of whether the pass is 304 enabled or not. */ 305 306static void 307register_one_dump_file (struct tree_opt_pass *pass, bool ipa, int n) 308{ 309 char *dot_name, *flag_name, *glob_name; 310 char num[10]; 311 312 /* See below in next_pass_1. */ 313 num[0] = '\0'; 314 if (pass->static_pass_number != -1) 315 sprintf (num, "%d", ((int) pass->static_pass_number < 0 316 ? 1 : pass->static_pass_number)); 317 318 dot_name = concat (".", pass->name, num, NULL); 319 if (ipa) 320 { 321 flag_name = concat ("ipa-", pass->name, num, NULL); 322 glob_name = concat ("ipa-", pass->name, NULL); 323 /* First IPA dump is cgraph that is dumped via separate channels. */ 324 pass->static_pass_number = dump_register (dot_name, flag_name, glob_name, 325 TDF_IPA, n + 1, 0); 326 } 327 else if (pass->properties_provided & PROP_trees) 328 { 329 flag_name = concat ("tree-", pass->name, num, NULL); 330 glob_name = concat ("tree-", pass->name, NULL); 331 pass->static_pass_number = dump_register (dot_name, flag_name, glob_name, 332 TDF_TREE, n + TDI_tree_all, 0); 333 } 334 else 335 { 336 flag_name = concat ("rtl-", pass->name, num, NULL); 337 glob_name = concat ("rtl-", pass->name, NULL); 338 pass->static_pass_number = dump_register (dot_name, flag_name, glob_name, 339 TDF_RTL, n, pass->letter); 340 } 341} 342 343static int 344register_dump_files (struct tree_opt_pass *pass, bool ipa, int properties) 345{ 346 static int n = 0; 347 do 348 { 349 int new_properties; 350 int pass_number; 351 352 pass->properties_required = properties; 353 new_properties = 354 (properties | pass->properties_provided) & ~pass->properties_destroyed; 355 356 /* Reset the counter when we reach RTL-based passes. */ 357 if ((new_properties ^ pass->properties_required) & PROP_rtl) 358 n = 0; 359 360 pass_number = n; 361 if (pass->name) 362 n++; 363 364 if (pass->sub) 365 new_properties = register_dump_files (pass->sub, false, new_properties); 366 367 /* If we have a gate, combine the properties that we could have with 368 and without the pass being examined. */ 369 if (pass->gate) 370 properties &= new_properties; 371 else 372 properties = new_properties; 373 374 pass->properties_provided = properties; 375 if (pass->name) 376 register_one_dump_file (pass, ipa, pass_number); 377 378 pass = pass->next; 379 } 380 while (pass); 381 382 return properties; 383} 384 385/* Add a pass to the pass list. Duplicate the pass if it's already 386 in the list. */ 387 388static struct tree_opt_pass ** 389next_pass_1 (struct tree_opt_pass **list, struct tree_opt_pass *pass) 390{ 391 392 /* A nonzero static_pass_number indicates that the 393 pass is already in the list. */ 394 if (pass->static_pass_number) 395 { 396 struct tree_opt_pass *new; 397 398 new = xmalloc (sizeof (*new)); 399 memcpy (new, pass, sizeof (*new)); 400 401 /* Indicate to register_dump_files that this pass has duplicates, 402 and so it should rename the dump file. The first instance will 403 be -1, and be number of duplicates = -static_pass_number - 1. 404 Subsequent instances will be > 0 and just the duplicate number. */ 405 if (pass->name) 406 { 407 pass->static_pass_number -= 1; 408 new->static_pass_number = -pass->static_pass_number; 409 } 410 411 *list = new; 412 } 413 else 414 { 415 pass->static_pass_number = -1; 416 *list = pass; 417 } 418 419 return &(*list)->next; 420 421} 422 423/* Construct the pass tree. */ 424 425void 426init_optimization_passes (void) 427{ 428 struct tree_opt_pass **p; 429 430#define NEXT_PASS(PASS) (p = next_pass_1 (p, &PASS)) 431 /* Interprocedural optimization passes. */ 432 p = &all_ipa_passes; 433 NEXT_PASS (pass_early_ipa_inline); 434 NEXT_PASS (pass_early_local_passes); 435 NEXT_PASS (pass_ipa_cp); 436 NEXT_PASS (pass_ipa_inline); 437 NEXT_PASS (pass_ipa_reference); 438 NEXT_PASS (pass_ipa_pure_const); 439 NEXT_PASS (pass_ipa_type_escape); 440 *p = NULL; 441 442 /* All passes needed to lower the function into shape optimizers can operate 443 on. These passes are performed before interprocedural passes, unlike rest 444 of local passes (all_passes). */ 445 p = &all_lowering_passes; 446 NEXT_PASS (pass_remove_useless_stmts); 447 NEXT_PASS (pass_mudflap_1); 448 NEXT_PASS (pass_lower_cf); 449 NEXT_PASS (pass_lower_eh); 450 NEXT_PASS (pass_build_cfg); 451 NEXT_PASS (pass_lower_complex_O0); 452 NEXT_PASS (pass_lower_vector); 453 NEXT_PASS (pass_warn_function_return); 454 NEXT_PASS (pass_early_tree_profile); 455 *p = NULL; 456 457 p = &pass_early_local_passes.sub; 458 NEXT_PASS (pass_tree_profile); 459 NEXT_PASS (pass_cleanup_cfg); 460 NEXT_PASS (pass_rebuild_cgraph_edges); 461 *p = NULL; 462 463 p = &all_passes; 464 NEXT_PASS (pass_fixup_cfg); 465 NEXT_PASS (pass_init_datastructures); 466 NEXT_PASS (pass_all_optimizations); 467 NEXT_PASS (pass_warn_function_noreturn); 468 NEXT_PASS (pass_mudflap_2); 469 NEXT_PASS (pass_free_datastructures); 470 NEXT_PASS (pass_free_cfg_annotations); 471 NEXT_PASS (pass_expand); 472 NEXT_PASS (pass_rest_of_compilation); 473 NEXT_PASS (pass_clean_state); 474 *p = NULL; 475 476 p = &pass_all_optimizations.sub; 477 NEXT_PASS (pass_referenced_vars); 478 NEXT_PASS (pass_create_structure_vars); 479 NEXT_PASS (pass_build_ssa); 480 NEXT_PASS (pass_may_alias); 481 NEXT_PASS (pass_return_slot); 482 NEXT_PASS (pass_rename_ssa_copies); 483 NEXT_PASS (pass_early_warn_uninitialized); 484 NEXT_PASS (pass_eliminate_useless_stores); 485 486 /* Initial scalar cleanups. */ 487 NEXT_PASS (pass_ccp); 488 NEXT_PASS (pass_fre); 489 NEXT_PASS (pass_dce); 490 NEXT_PASS (pass_forwprop); 491 NEXT_PASS (pass_copy_prop); 492 NEXT_PASS (pass_vrp); 493 NEXT_PASS (pass_dce); 494 NEXT_PASS (pass_merge_phi); 495 NEXT_PASS (pass_dominator); 496 497 /* The only copy propagation opportunities left after DOM 498 should be due to degenerate PHI nodes. So rather than 499 run the full copy propagator, just discover and copy 500 propagate away the degenerate PHI nodes. */ 501 NEXT_PASS (pass_phi_only_copy_prop); 502 503 NEXT_PASS (pass_phiopt); 504 NEXT_PASS (pass_may_alias); 505 NEXT_PASS (pass_tail_recursion); 506 NEXT_PASS (pass_profile); 507 NEXT_PASS (pass_ch); 508 NEXT_PASS (pass_stdarg); 509 NEXT_PASS (pass_lower_complex); 510 NEXT_PASS (pass_sra); 511 /* FIXME: SRA may generate arbitrary gimple code, exposing new 512 aliased and call-clobbered variables. As mentioned below, 513 pass_may_alias should be a TODO item. */ 514 NEXT_PASS (pass_may_alias); 515 NEXT_PASS (pass_rename_ssa_copies); 516 NEXT_PASS (pass_dominator); 517 518 /* The only copy propagation opportunities left after DOM 519 should be due to degenerate PHI nodes. So rather than 520 run the full copy propagator, just discover and copy 521 propagate away the degenerate PHI nodes. */ 522 NEXT_PASS (pass_phi_only_copy_prop); 523 524 NEXT_PASS (pass_dce); 525 NEXT_PASS (pass_dse); 526 NEXT_PASS (pass_may_alias); 527 NEXT_PASS (pass_forwprop); 528 NEXT_PASS (pass_phiopt); 529 NEXT_PASS (pass_object_sizes); 530 NEXT_PASS (pass_store_ccp); 531 NEXT_PASS (pass_store_copy_prop); 532 NEXT_PASS (pass_fold_builtins); 533 /* FIXME: May alias should a TODO but for 4.0.0, 534 we add may_alias right after fold builtins 535 which can create arbitrary GIMPLE. */ 536 NEXT_PASS (pass_may_alias); 537 NEXT_PASS (pass_split_crit_edges); 538 NEXT_PASS (pass_reassoc); 539 NEXT_PASS (pass_pre); 540 NEXT_PASS (pass_sink_code); 541 NEXT_PASS (pass_tree_loop); 542 NEXT_PASS (pass_cse_reciprocals); 543 NEXT_PASS (pass_dominator); 544 545 /* The only copy propagation opportunities left after DOM 546 should be due to degenerate PHI nodes. So rather than 547 run the full copy propagator, just discover and copy 548 propagate away the degenerate PHI nodes. */ 549 NEXT_PASS (pass_phi_only_copy_prop); 550 551 NEXT_PASS (pass_cd_dce); 552 553 /* FIXME: If DCE is not run before checking for uninitialized uses, 554 we may get false warnings (e.g., testsuite/gcc.dg/uninit-5.c). 555 However, this also causes us to misdiagnose cases that should be 556 real warnings (e.g., testsuite/gcc.dg/pr18501.c). 557 558 To fix the false positives in uninit-5.c, we would have to 559 account for the predicates protecting the set and the use of each 560 variable. Using a representation like Gated Single Assignment 561 may help. */ 562 NEXT_PASS (pass_late_warn_uninitialized); 563 NEXT_PASS (pass_dse); 564 NEXT_PASS (pass_forwprop); 565 NEXT_PASS (pass_phiopt); 566 NEXT_PASS (pass_tail_calls); 567 NEXT_PASS (pass_rename_ssa_copies); 568 NEXT_PASS (pass_uncprop); 569 NEXT_PASS (pass_del_ssa); 570 NEXT_PASS (pass_nrv); 571 NEXT_PASS (pass_remove_useless_vars); 572 NEXT_PASS (pass_mark_used_blocks); 573 NEXT_PASS (pass_cleanup_cfg_post_optimizing); 574 *p = NULL; 575 576 p = &pass_tree_loop.sub; 577 NEXT_PASS (pass_tree_loop_init); 578 NEXT_PASS (pass_copy_prop); 579 NEXT_PASS (pass_lim); 580 NEXT_PASS (pass_tree_unswitch); 581 NEXT_PASS (pass_scev_cprop); 582 NEXT_PASS (pass_empty_loop); 583 NEXT_PASS (pass_record_bounds); 584 NEXT_PASS (pass_linear_transform); 585 NEXT_PASS (pass_iv_canon); 586 NEXT_PASS (pass_if_conversion); 587 NEXT_PASS (pass_vectorize); 588 /* NEXT_PASS (pass_may_alias) cannot be done again because the 589 vectorizer creates alias relations that are not supported by 590 pass_may_alias. */ 591 NEXT_PASS (pass_complete_unroll); 592 NEXT_PASS (pass_iv_optimize); 593 NEXT_PASS (pass_tree_loop_done); 594 *p = NULL; 595 596 p = &pass_vectorize.sub; 597 NEXT_PASS (pass_lower_vector_ssa); 598 NEXT_PASS (pass_dce_loop); 599 *p = NULL; 600 601 p = &pass_loop2.sub; 602 NEXT_PASS (pass_rtl_loop_init); 603 NEXT_PASS (pass_rtl_move_loop_invariants); 604 NEXT_PASS (pass_rtl_unswitch); 605 NEXT_PASS (pass_rtl_unroll_and_peel_loops); 606 NEXT_PASS (pass_rtl_doloop); 607 NEXT_PASS (pass_rtl_loop_done); 608 *p = NULL; 609 610 p = &pass_rest_of_compilation.sub; 611 NEXT_PASS (pass_remove_unnecessary_notes); 612 NEXT_PASS (pass_init_function); 613 NEXT_PASS (pass_jump); 614 NEXT_PASS (pass_insn_locators_initialize); 615 NEXT_PASS (pass_rtl_eh); 616 NEXT_PASS (pass_initial_value_sets); 617 NEXT_PASS (pass_unshare_all_rtl); 618 NEXT_PASS (pass_instantiate_virtual_regs); 619 NEXT_PASS (pass_jump2); 620 NEXT_PASS (pass_cse); 621 NEXT_PASS (pass_gcse); 622 NEXT_PASS (pass_loop_optimize); 623 NEXT_PASS (pass_jump_bypass); 624 NEXT_PASS (pass_cfg); 625 NEXT_PASS (pass_branch_prob); 626 NEXT_PASS (pass_rtl_ifcvt); 627 NEXT_PASS (pass_tracer); 628 /* Perform loop optimizations. It might be better to do them a bit 629 sooner, but we want the profile feedback to work more 630 efficiently. */ 631 NEXT_PASS (pass_loop2); 632 NEXT_PASS (pass_web); 633 NEXT_PASS (pass_cse2); 634 NEXT_PASS (pass_life); 635 NEXT_PASS (pass_combine); 636 NEXT_PASS (pass_if_after_combine); 637 NEXT_PASS (pass_partition_blocks); 638 NEXT_PASS (pass_regmove); 639 NEXT_PASS (pass_split_all_insns); 640 NEXT_PASS (pass_mode_switching); 641 NEXT_PASS (pass_recompute_reg_usage); 642 NEXT_PASS (pass_sms); 643 NEXT_PASS (pass_sched); 644 NEXT_PASS (pass_local_alloc); 645 NEXT_PASS (pass_global_alloc); 646 NEXT_PASS (pass_postreload); 647 *p = NULL; 648 649 p = &pass_postreload.sub; 650 NEXT_PASS (pass_postreload_cse); 651 NEXT_PASS (pass_gcse2); 652 NEXT_PASS (pass_flow2); 653 NEXT_PASS (pass_stack_adjustments); 654 NEXT_PASS (pass_peephole2); 655 NEXT_PASS (pass_if_after_reload); 656 NEXT_PASS (pass_regrename); 657 NEXT_PASS (pass_reorder_blocks); 658 NEXT_PASS (pass_branch_target_load_optimize); 659 NEXT_PASS (pass_leaf_regs); 660 NEXT_PASS (pass_sched2); 661 NEXT_PASS (pass_split_before_regstack); 662 NEXT_PASS (pass_stack_regs); 663 NEXT_PASS (pass_compute_alignments); 664 NEXT_PASS (pass_duplicate_computed_gotos); 665 NEXT_PASS (pass_variable_tracking); 666 NEXT_PASS (pass_free_cfg); 667 NEXT_PASS (pass_machine_reorg); 668 NEXT_PASS (pass_purge_lineno_notes); 669 NEXT_PASS (pass_cleanup_barriers); 670 NEXT_PASS (pass_delay_slots); 671 NEXT_PASS (pass_split_for_shorten_branches); 672 NEXT_PASS (pass_convert_to_eh_region_ranges); 673 NEXT_PASS (pass_shorten_branches); 674 NEXT_PASS (pass_set_nothrow_function_flags); 675 NEXT_PASS (pass_final); 676 *p = NULL; 677 678#undef NEXT_PASS 679 680 /* Register the passes with the tree dump code. */ 681 register_dump_files (all_ipa_passes, true, PROP_gimple_leh | PROP_cfg); 682 register_dump_files (all_lowering_passes, false, PROP_gimple_any); 683 register_dump_files (all_passes, false, PROP_gimple_leh | PROP_cfg); 684} 685 686static unsigned int last_verified; 687 688static void 689execute_todo (struct tree_opt_pass *pass, unsigned int flags, bool use_required) 690{ 691 int properties 692 = use_required ? pass->properties_required : pass->properties_provided; 693 694#if defined ENABLE_CHECKING 695 if (need_ssa_update_p ()) 696 gcc_assert (flags & TODO_update_ssa_any); 697#endif 698 699 /* Always cleanup the CFG before doing anything else. */ 700 if (flags & TODO_cleanup_cfg) 701 { 702 if (current_loops) 703 cleanup_tree_cfg_loop (); 704 else 705 cleanup_tree_cfg (); 706 707 /* When cleanup_tree_cfg merges consecutive blocks, it may 708 perform some simplistic propagation when removing single 709 valued PHI nodes. This propagation may, in turn, cause the 710 SSA form to become out-of-date (see PR 22037). So, even 711 if the parent pass had not scheduled an SSA update, we may 712 still need to do one. */ 713 if (!(flags & TODO_update_ssa_any) && need_ssa_update_p ()) 714 flags |= TODO_update_ssa; 715 } 716 717 if (flags & TODO_update_ssa_any) 718 { 719 unsigned update_flags = flags & TODO_update_ssa_any; 720 update_ssa (update_flags); 721 } 722 723 if ((flags & TODO_dump_func) 724 && dump_file && current_function_decl) 725 { 726 if (properties & PROP_trees) 727 dump_function_to_file (current_function_decl, 728 dump_file, dump_flags); 729 else if (properties & PROP_cfg) 730 { 731 print_rtl_with_bb (dump_file, get_insns ()); 732 733 if (graph_dump_format != no_graph 734 && (dump_flags & TDF_GRAPH)) 735 print_rtl_graph_with_bb (dump_file_name, get_insns ()); 736 } 737 else 738 print_rtl (dump_file, get_insns ()); 739 740 /* Flush the file. If verification fails, we won't be able to 741 close the file before aborting. */ 742 fflush (dump_file); 743 } 744 if ((flags & TODO_dump_cgraph) 745 && dump_file && !current_function_decl) 746 { 747 dump_cgraph (dump_file); 748 /* Flush the file. If verification fails, we won't be able to 749 close the file before aborting. */ 750 fflush (dump_file); 751 } 752 753 if (flags & TODO_ggc_collect) 754 { 755 ggc_collect (); 756 } 757 758#if defined ENABLE_CHECKING 759 if ((pass->properties_required & PROP_ssa) 760 && !(pass->properties_destroyed & PROP_ssa)) 761 verify_ssa (true); 762 if (flags & TODO_verify_flow) 763 verify_flow_info (); 764 if (flags & TODO_verify_stmts) 765 verify_stmts (); 766 if (flags & TODO_verify_loops) 767 verify_loop_closed_ssa (); 768#endif 769} 770 771static bool 772execute_one_pass (struct tree_opt_pass *pass) 773{ 774 unsigned int todo; 775 776 /* See if we're supposed to run this pass. */ 777 if (pass->gate && !pass->gate ()) 778 return false; 779 780 /* Note that the folders should only create gimple expressions. 781 This is a hack until the new folder is ready. */ 782 in_gimple_form = (pass->properties_provided & PROP_trees) != 0; 783 784 /* Run pre-pass verification. */ 785 todo = pass->todo_flags_start & ~last_verified; 786 if (todo) 787 execute_todo (pass, todo, true); 788 789 /* If a dump file name is present, open it if enabled. */ 790 if (pass->static_pass_number != -1) 791 { 792 bool initializing_dump = !dump_initialized_p (pass->static_pass_number); 793 dump_file_name = get_dump_file_name (pass->static_pass_number); 794 dump_file = dump_begin (pass->static_pass_number, &dump_flags); 795 if (dump_file && current_function_decl) 796 { 797 const char *dname, *aname; 798 dname = lang_hooks.decl_printable_name (current_function_decl, 2); 799 aname = (IDENTIFIER_POINTER 800 (DECL_ASSEMBLER_NAME (current_function_decl))); 801 fprintf (dump_file, "\n;; Function %s (%s)%s\n\n", dname, aname, 802 cfun->function_frequency == FUNCTION_FREQUENCY_HOT 803 ? " (hot)" 804 : cfun->function_frequency == FUNCTION_FREQUENCY_UNLIKELY_EXECUTED 805 ? " (unlikely executed)" 806 : ""); 807 } 808 809 if (initializing_dump 810 && dump_file 811 && graph_dump_format != no_graph 812 && (pass->properties_provided & (PROP_cfg | PROP_rtl)) 813 == (PROP_cfg | PROP_rtl)) 814 { 815 get_dump_file_info (pass->static_pass_number)->flags |= TDF_GRAPH; 816 dump_flags |= TDF_GRAPH; 817 clean_graph_dump_file (dump_file_name); 818 } 819 } 820 821 /* If a timevar is present, start it. */ 822 if (pass->tv_id) 823 timevar_push (pass->tv_id); 824 825 /* Do it! */ 826 if (pass->execute) 827 pass->execute (); 828 829 /* Stop timevar. */ 830 if (pass->tv_id) 831 timevar_pop (pass->tv_id); 832 833 /* Run post-pass cleanup and verification. */ 834 todo = pass->todo_flags_finish; 835 last_verified = todo & TODO_verify_all; 836 if (todo) 837 execute_todo (pass, todo, false); 838 839 /* Flush and close dump file. */ 840 if (dump_file_name) 841 { 842 free ((char *) dump_file_name); 843 dump_file_name = NULL; 844 } 845 if (dump_file) 846 { 847 dump_end (pass->static_pass_number, dump_file); 848 dump_file = NULL; 849 } 850 851 /* Reset in_gimple_form to not break non-unit-at-a-time mode. */ 852 in_gimple_form = false; 853 854 return true; 855} 856 857void 858execute_pass_list (struct tree_opt_pass *pass) 859{ 860 do 861 { 862 if (execute_one_pass (pass) && pass->sub) 863 execute_pass_list (pass->sub); 864 pass = pass->next; 865 } 866 while (pass); 867} 868 869/* Same as execute_pass_list but assume that subpasses of IPA passes 870 are local passes. */ 871void 872execute_ipa_pass_list (struct tree_opt_pass *pass) 873{ 874 do 875 { 876 if (execute_one_pass (pass) && pass->sub) 877 { 878 struct cgraph_node *node; 879 for (node = cgraph_nodes; node; node = node->next) 880 if (node->analyzed) 881 { 882 push_cfun (DECL_STRUCT_FUNCTION (node->decl)); 883 current_function_decl = node->decl; 884 execute_pass_list (pass->sub); 885 free_dominance_info (CDI_DOMINATORS); 886 free_dominance_info (CDI_POST_DOMINATORS); 887 current_function_decl = NULL; 888 pop_cfun (); 889 ggc_collect (); 890 } 891 } 892 pass = pass->next; 893 } 894 while (pass); 895} 896