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, 2010, 4 2011, 2012 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 #include "system.h" 29 #include "coretypes.h" 30 #include "tm.h" 31 #include "line-map.h" 32 #include "input.h" 33 #include "tree.h" 34 #include "rtl.h" 35 #include "tm_p.h" 36 #include "flags.h" 37 #include "insn-attr.h" 38 #include "insn-config.h" 39 #include "insn-flags.h" 40 #include "hard-reg-set.h" 41 #include "recog.h" 42 #include "output.h" 43 #include "except.h" 44 #include "function.h" 45 #include "toplev.h" 46 #include "expr.h" 47 #include "basic-block.h" 48 #include "intl.h" 49 #include "ggc.h" 50 #include "graph.h" 51 #include "regs.h" 52 #include "timevar.h" 53 #include "diagnostic-core.h" 54 #include "params.h" 55 #include "reload.h" 56 #include "dwarf2asm.h" 57 #include "integrate.h" 58 #include "debug.h" 59 #include "target.h" 60 #include "langhooks.h" 61 #include "cfglayout.h" 62 #include "cfgloop.h" 63 #include "hosthooks.h" 64 #include "cgraph.h" 65 #include "opts.h" 66 #include "coverage.h" 67 #include "value-prof.h" 68 #include "tree-inline.h" 69 #include "tree-flow.h" 70 #include "tree-pass.h" 71 #include "tree-dump.h" 72 #include "df.h" 73 #include "predict.h" 74 #include "lto-streamer.h" 75 #include "plugin.h" 76 #include "ipa-utils.h" 77 #include "tree-pretty-print.h" 78 79 #if defined (DWARF2_UNWIND_INFO) || defined (DWARF2_DEBUGGING_INFO) 80 #include "dwarf2out.h" 81 #endif 82 83 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO) 84 #include "dbxout.h" 85 #endif 86 87 #ifdef SDB_DEBUGGING_INFO 88 #include "sdbout.h" 89 #endif 90 91 #ifdef XCOFF_DEBUGGING_INFO 92 #include "xcoffout.h" /* Needed for external data 93 declarations for e.g. AIX 4.x. */ 94 #endif 95 96 /* This is used for debugging. It allows the current pass to printed 97 from anywhere in compilation. 98 The variable current_pass is also used for statistics and plugins. */ 99 struct opt_pass *current_pass; 100 101 static void register_pass_name (struct opt_pass *, const char *); 102 103 /* Call from anywhere to find out what pass this is. Useful for 104 printing out debugging information deep inside an service 105 routine. */ 106 void 107 print_current_pass (FILE *file) 108 { 109 if (current_pass) 110 fprintf (file, "current pass = %s (%d)\n", 111 current_pass->name, current_pass->static_pass_number); 112 else 113 fprintf (file, "no current pass.\n"); 114 } 115 116 117 /* Call from the debugger to get the current pass name. */ 118 DEBUG_FUNCTION void 119 debug_pass (void) 120 { 121 print_current_pass (stderr); 122 } 123 124 125 126 /* Global variables used to communicate with passes. */ 127 int dump_flags; 128 bool in_gimple_form; 129 bool first_pass_instance; 130 131 132 /* This is called from various places for FUNCTION_DECL, VAR_DECL, 133 and TYPE_DECL nodes. 134 135 This does nothing for local (non-static) variables, unless the 136 variable is a register variable with DECL_ASSEMBLER_NAME set. In 137 that case, or if the variable is not an automatic, it sets up the 138 RTL and outputs any assembler code (label definition, storage 139 allocation and initialization). 140 141 DECL is the declaration. TOP_LEVEL is nonzero 142 if this declaration is not within a function. */ 143 144 void 145 rest_of_decl_compilation (tree decl, 146 int top_level, 147 int at_end) 148 { 149 /* We deferred calling assemble_alias so that we could collect 150 other attributes such as visibility. Emit the alias now. */ 151 if (!in_lto_p) 152 { 153 tree alias; 154 alias = lookup_attribute ("alias", DECL_ATTRIBUTES (decl)); 155 if (alias) 156 { 157 alias = TREE_VALUE (TREE_VALUE (alias)); 158 alias = get_identifier (TREE_STRING_POINTER (alias)); 159 /* A quirk of the initial implementation of aliases required that the 160 user add "extern" to all of them. Which is silly, but now 161 historical. Do note that the symbol is in fact locally defined. */ 162 if (!lookup_attribute ("weakref", DECL_ATTRIBUTES (decl))) 163 DECL_EXTERNAL (decl) = 0; 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 /* When reading LTO unit, we also read varpool, so do not 192 rebuild it. */ 193 if (in_lto_p && !at_end) 194 ; 195 else if (TREE_CODE (decl) != FUNCTION_DECL) 196 varpool_finalize_decl (decl); 197 } 198 199 #ifdef ASM_FINISH_DECLARE_OBJECT 200 if (decl == last_assemble_variable_decl) 201 { 202 ASM_FINISH_DECLARE_OBJECT (asm_out_file, decl, 203 top_level, at_end); 204 } 205 #endif 206 207 timevar_pop (TV_VARCONST); 208 } 209 else if (TREE_CODE (decl) == TYPE_DECL 210 /* Like in rest_of_type_compilation, avoid confusing the debug 211 information machinery when there are errors. */ 212 && !seen_error ()) 213 { 214 timevar_push (TV_SYMOUT); 215 debug_hooks->type_decl (decl, !top_level); 216 timevar_pop (TV_SYMOUT); 217 } 218 219 /* Let cgraph know about the existence of variables. */ 220 if (in_lto_p && !at_end) 221 ; 222 else if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl) 223 && TREE_STATIC (decl)) 224 varpool_node (decl); 225 } 226 227 /* Called after finishing a record, union or enumeral type. */ 228 229 void 230 rest_of_type_compilation (tree type, int toplev) 231 { 232 /* Avoid confusing the debug information machinery when there are 233 errors. */ 234 if (seen_error ()) 235 return; 236 237 timevar_push (TV_SYMOUT); 238 debug_hooks->type_decl (TYPE_STUB_DECL (type), !toplev); 239 timevar_pop (TV_SYMOUT); 240 } 241 242 243 244 void 245 finish_optimization_passes (void) 246 { 247 int i; 248 struct dump_file_info *dfi; 249 char *name; 250 251 timevar_push (TV_DUMP); 252 if (profile_arc_flag || flag_test_coverage || flag_branch_probabilities) 253 { 254 dump_file = dump_begin (pass_profile.pass.static_pass_number, NULL); 255 end_branch_prob (); 256 if (dump_file) 257 dump_end (pass_profile.pass.static_pass_number, dump_file); 258 } 259 260 if (optimize > 0) 261 { 262 dump_file = dump_begin (pass_combine.pass.static_pass_number, NULL); 263 if (dump_file) 264 { 265 dump_combine_total_stats (dump_file); 266 dump_end (pass_combine.pass.static_pass_number, dump_file); 267 } 268 } 269 270 /* Do whatever is necessary to finish printing the graphs. */ 271 if (graph_dump_format != no_graph) 272 for (i = TDI_end; (dfi = get_dump_file_info (i)) != NULL; ++i) 273 if (dump_initialized_p (i) 274 && (dfi->flags & TDF_GRAPH) != 0 275 && (name = get_dump_file_name (i)) != NULL) 276 { 277 finish_graph_dump_file (name); 278 free (name); 279 } 280 281 timevar_pop (TV_DUMP); 282 } 283 284 static bool 285 gate_rest_of_compilation (void) 286 { 287 /* Early return if there were errors. We can run afoul of our 288 consistency checks, and there's not really much point in fixing them. */ 289 return !(rtl_dump_and_exit || flag_syntax_only || seen_error ()); 290 } 291 292 struct gimple_opt_pass pass_rest_of_compilation = 293 { 294 { 295 GIMPLE_PASS, 296 "*rest_of_compilation", /* name */ 297 gate_rest_of_compilation, /* gate */ 298 NULL, /* execute */ 299 NULL, /* sub */ 300 NULL, /* next */ 301 0, /* static_pass_number */ 302 TV_REST_OF_COMPILATION, /* tv_id */ 303 PROP_rtl, /* properties_required */ 304 0, /* properties_provided */ 305 0, /* properties_destroyed */ 306 0, /* todo_flags_start */ 307 TODO_ggc_collect /* todo_flags_finish */ 308 } 309 }; 310 311 static bool 312 gate_postreload (void) 313 { 314 return reload_completed; 315 } 316 317 struct rtl_opt_pass pass_postreload = 318 { 319 { 320 RTL_PASS, 321 "*all-postreload", /* name */ 322 gate_postreload, /* gate */ 323 NULL, /* execute */ 324 NULL, /* sub */ 325 NULL, /* next */ 326 0, /* static_pass_number */ 327 TV_POSTRELOAD, /* tv_id */ 328 PROP_rtl, /* properties_required */ 329 0, /* properties_provided */ 330 0, /* properties_destroyed */ 331 0, /* todo_flags_start */ 332 TODO_ggc_collect | TODO_verify_rtl_sharing /* todo_flags_finish */ 333 } 334 }; 335 336 337 338 /* The root of the compilation pass tree, once constructed. */ 339 struct opt_pass *all_passes, *all_small_ipa_passes, *all_lowering_passes, 340 *all_regular_ipa_passes, *all_late_ipa_passes, *all_lto_gen_passes; 341 342 /* This is used by plugins, and should also be used in register_pass. */ 343 #define DEF_PASS_LIST(LIST) &LIST, 344 struct opt_pass **gcc_pass_lists[] = { GCC_PASS_LISTS NULL }; 345 #undef DEF_PASS_LIST 346 347 /* A map from static pass id to optimization pass. */ 348 struct opt_pass **passes_by_id; 349 int passes_by_id_size; 350 351 /* Set the static pass number of pass PASS to ID and record that 352 in the mapping from static pass number to pass. */ 353 354 static void 355 set_pass_for_id (int id, struct opt_pass *pass) 356 { 357 pass->static_pass_number = id; 358 if (passes_by_id_size <= id) 359 { 360 passes_by_id = XRESIZEVEC (struct opt_pass *, passes_by_id, id + 1); 361 memset (passes_by_id + passes_by_id_size, 0, 362 (id + 1 - passes_by_id_size) * sizeof (void *)); 363 passes_by_id_size = id + 1; 364 } 365 passes_by_id[id] = pass; 366 } 367 368 /* Return the pass with the static pass number ID. */ 369 370 struct opt_pass * 371 get_pass_for_id (int id) 372 { 373 if (id >= passes_by_id_size) 374 return NULL; 375 return passes_by_id[id]; 376 } 377 378 /* Iterate over the pass tree allocating dump file numbers. We want 379 to do this depth first, and independent of whether the pass is 380 enabled or not. */ 381 382 void 383 register_one_dump_file (struct opt_pass *pass) 384 { 385 char *dot_name, *flag_name, *glob_name; 386 const char *name, *full_name, *prefix; 387 char num[10]; 388 int flags, id; 389 390 /* See below in next_pass_1. */ 391 num[0] = '\0'; 392 if (pass->static_pass_number != -1) 393 sprintf (num, "%d", ((int) pass->static_pass_number < 0 394 ? 1 : pass->static_pass_number)); 395 396 /* The name is both used to identify the pass for the purposes of plugins, 397 and to specify dump file name and option. 398 The latter two might want something short which is not quite unique; for 399 that reason, we may have a disambiguating prefix, followed by a space 400 to mark the start of the following dump file name / option string. */ 401 name = strchr (pass->name, ' '); 402 name = name ? name + 1 : pass->name; 403 dot_name = concat (".", name, num, NULL); 404 if (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS) 405 prefix = "ipa-", flags = TDF_IPA; 406 else if (pass->type == GIMPLE_PASS) 407 prefix = "tree-", flags = TDF_TREE; 408 else 409 prefix = "rtl-", flags = TDF_RTL; 410 411 flag_name = concat (prefix, name, num, NULL); 412 glob_name = concat (prefix, name, NULL); 413 id = dump_register (dot_name, flag_name, glob_name, flags); 414 set_pass_for_id (id, pass); 415 full_name = concat (prefix, pass->name, num, NULL); 416 register_pass_name (pass, full_name); 417 free (CONST_CAST (char *, full_name)); 418 } 419 420 /* Recursive worker function for register_dump_files. */ 421 422 static int 423 register_dump_files_1 (struct opt_pass *pass, int properties) 424 { 425 do 426 { 427 int new_properties = (properties | pass->properties_provided) 428 & ~pass->properties_destroyed; 429 430 if (pass->name && pass->name[0] != '*') 431 register_one_dump_file (pass); 432 433 if (pass->sub) 434 new_properties = register_dump_files_1 (pass->sub, new_properties); 435 436 /* If we have a gate, combine the properties that we could have with 437 and without the pass being examined. */ 438 if (pass->gate) 439 properties &= new_properties; 440 else 441 properties = new_properties; 442 443 pass = pass->next; 444 } 445 while (pass); 446 447 return properties; 448 } 449 450 /* Register the dump files for the pipeline starting at PASS. 451 PROPERTIES reflects the properties that are guaranteed to be available at 452 the beginning of the pipeline. */ 453 454 static void 455 register_dump_files (struct opt_pass *pass,int properties) 456 { 457 pass->properties_required |= properties; 458 register_dump_files_1 (pass, properties); 459 } 460 461 struct pass_registry 462 { 463 const char* unique_name; 464 struct opt_pass *pass; 465 }; 466 467 /* Pass registry hash function. */ 468 469 static hashval_t 470 passr_hash (const void *p) 471 { 472 const struct pass_registry *const s = (const struct pass_registry *const) p; 473 return htab_hash_string (s->unique_name); 474 } 475 476 /* Hash equal function */ 477 478 static int 479 passr_eq (const void *p1, const void *p2) 480 { 481 const struct pass_registry *const s1 = (const struct pass_registry *const) p1; 482 const struct pass_registry *const s2 = (const struct pass_registry *const) p2; 483 484 return !strcmp (s1->unique_name, s2->unique_name); 485 } 486 487 static htab_t name_to_pass_map = NULL; 488 489 /* Register PASS with NAME. */ 490 491 static void 492 register_pass_name (struct opt_pass *pass, const char *name) 493 { 494 struct pass_registry **slot; 495 struct pass_registry pr; 496 497 if (!name_to_pass_map) 498 name_to_pass_map = htab_create (256, passr_hash, passr_eq, NULL); 499 500 pr.unique_name = name; 501 slot = (struct pass_registry **) htab_find_slot (name_to_pass_map, &pr, INSERT); 502 if (!*slot) 503 { 504 struct pass_registry *new_pr; 505 506 new_pr = XCNEW (struct pass_registry); 507 new_pr->unique_name = xstrdup (name); 508 new_pr->pass = pass; 509 *slot = new_pr; 510 } 511 else 512 return; /* Ignore plugin passes. */ 513 } 514 515 /* Map from pass id to canonicalized pass name. */ 516 517 typedef const char *char_ptr; 518 DEF_VEC_P(char_ptr); 519 DEF_VEC_ALLOC_P(char_ptr, heap); 520 static VEC(char_ptr, heap) *pass_tab = NULL; 521 522 /* Callback function for traversing NAME_TO_PASS_MAP. */ 523 524 static int 525 pass_traverse (void **slot, void *data ATTRIBUTE_UNUSED) 526 { 527 struct pass_registry **p = (struct pass_registry **)slot; 528 struct opt_pass *pass = (*p)->pass; 529 530 gcc_assert (pass->static_pass_number > 0); 531 gcc_assert (pass_tab); 532 533 VEC_replace (char_ptr, pass_tab, pass->static_pass_number, 534 (*p)->unique_name); 535 536 return 1; 537 } 538 539 /* The function traverses NAME_TO_PASS_MAP and creates a pass info 540 table for dumping purpose. */ 541 542 static void 543 create_pass_tab (void) 544 { 545 if (!flag_dump_passes) 546 return; 547 548 VEC_safe_grow_cleared (char_ptr, heap, 549 pass_tab, passes_by_id_size + 1); 550 htab_traverse (name_to_pass_map, pass_traverse, NULL); 551 } 552 553 static bool override_gate_status (struct opt_pass *, tree, bool); 554 555 /* Dump the instantiated name for PASS. IS_ON indicates if PASS 556 is turned on or not. */ 557 558 static void 559 dump_one_pass (struct opt_pass *pass, int pass_indent) 560 { 561 int indent = 3 * pass_indent; 562 const char *pn; 563 bool is_on, is_really_on; 564 565 is_on = (pass->gate == NULL) ? true : pass->gate(); 566 is_really_on = override_gate_status (pass, current_function_decl, is_on); 567 568 if (pass->static_pass_number <= 0) 569 pn = pass->name; 570 else 571 pn = VEC_index (char_ptr, pass_tab, pass->static_pass_number); 572 573 fprintf (stderr, "%*s%-40s%*s:%s%s\n", indent, " ", pn, 574 (15 - indent < 0 ? 0 : 15 - indent), " ", 575 is_on ? " ON" : " OFF", 576 ((!is_on) == (!is_really_on) ? "" 577 : (is_really_on ? " (FORCED_ON)" : " (FORCED_OFF)"))); 578 } 579 580 /* Dump pass list PASS with indentation INDENT. */ 581 582 static void 583 dump_pass_list (struct opt_pass *pass, int indent) 584 { 585 do 586 { 587 dump_one_pass (pass, indent); 588 if (pass->sub) 589 dump_pass_list (pass->sub, indent + 1); 590 pass = pass->next; 591 } 592 while (pass); 593 } 594 595 /* Dump all optimization passes. */ 596 597 void 598 dump_passes (void) 599 { 600 struct cgraph_node *n, *node = NULL; 601 tree save_fndecl = current_function_decl; 602 603 create_pass_tab(); 604 605 n = cgraph_nodes; 606 while (n) 607 { 608 if (DECL_STRUCT_FUNCTION (n->decl)) 609 { 610 node = n; 611 break; 612 } 613 n = n->next; 614 } 615 616 if (!node) 617 return; 618 619 push_cfun (DECL_STRUCT_FUNCTION (node->decl)); 620 current_function_decl = node->decl; 621 622 dump_pass_list (all_lowering_passes, 1); 623 dump_pass_list (all_small_ipa_passes, 1); 624 dump_pass_list (all_regular_ipa_passes, 1); 625 dump_pass_list (all_lto_gen_passes, 1); 626 dump_pass_list (all_late_ipa_passes, 1); 627 dump_pass_list (all_passes, 1); 628 629 pop_cfun (); 630 current_function_decl = save_fndecl; 631 } 632 633 634 /* Returns the pass with NAME. */ 635 636 static struct opt_pass * 637 get_pass_by_name (const char *name) 638 { 639 struct pass_registry **slot, pr; 640 641 pr.unique_name = name; 642 slot = (struct pass_registry **) htab_find_slot (name_to_pass_map, 643 &pr, NO_INSERT); 644 645 if (!slot || !*slot) 646 return NULL; 647 648 return (*slot)->pass; 649 } 650 651 652 /* Range [start, last]. */ 653 654 struct uid_range 655 { 656 unsigned int start; 657 unsigned int last; 658 const char *assem_name; 659 struct uid_range *next; 660 }; 661 662 typedef struct uid_range *uid_range_p; 663 664 DEF_VEC_P(uid_range_p); 665 DEF_VEC_ALLOC_P(uid_range_p, heap); 666 667 static VEC(uid_range_p, heap) *enabled_pass_uid_range_tab = NULL; 668 static VEC(uid_range_p, heap) *disabled_pass_uid_range_tab = NULL; 669 670 671 /* Parse option string for -fdisable- and -fenable- 672 The syntax of the options: 673 674 -fenable-<pass_name> 675 -fdisable-<pass_name> 676 677 -fenable-<pass_name>=s1:e1,s2:e2,... 678 -fdisable-<pass_name>=s1:e1,s2:e2,... 679 */ 680 681 static void 682 enable_disable_pass (const char *arg, bool is_enable) 683 { 684 struct opt_pass *pass; 685 char *range_str, *phase_name; 686 char *argstr = xstrdup (arg); 687 VEC(uid_range_p, heap) **tab = 0; 688 689 range_str = strchr (argstr,'='); 690 if (range_str) 691 { 692 *range_str = '\0'; 693 range_str++; 694 } 695 696 phase_name = argstr; 697 if (!*phase_name) 698 { 699 if (is_enable) 700 error ("unrecognized option -fenable"); 701 else 702 error ("unrecognized option -fdisable"); 703 free (argstr); 704 return; 705 } 706 pass = get_pass_by_name (phase_name); 707 if (!pass || pass->static_pass_number == -1) 708 { 709 if (is_enable) 710 error ("unknown pass %s specified in -fenable", phase_name); 711 else 712 error ("unknown pass %s specified in -fdisable", phase_name); 713 free (argstr); 714 return; 715 } 716 717 if (is_enable) 718 tab = &enabled_pass_uid_range_tab; 719 else 720 tab = &disabled_pass_uid_range_tab; 721 722 if ((unsigned) pass->static_pass_number >= VEC_length (uid_range_p, *tab)) 723 VEC_safe_grow_cleared (uid_range_p, heap, 724 *tab, pass->static_pass_number + 1); 725 726 if (!range_str) 727 { 728 uid_range_p slot; 729 uid_range_p new_range = XCNEW (struct uid_range); 730 731 new_range->start = 0; 732 new_range->last = (unsigned)-1; 733 734 slot = VEC_index (uid_range_p, *tab, pass->static_pass_number); 735 new_range->next = slot; 736 VEC_replace (uid_range_p, *tab, pass->static_pass_number, 737 new_range); 738 if (is_enable) 739 inform (UNKNOWN_LOCATION, "enable pass %s for functions in the range " 740 "of [%u, %u]", phase_name, new_range->start, new_range->last); 741 else 742 inform (UNKNOWN_LOCATION, "disable pass %s for functions in the range " 743 "of [%u, %u]", phase_name, new_range->start, new_range->last); 744 } 745 else 746 { 747 char *next_range = NULL; 748 char *one_range = range_str; 749 char *end_val = NULL; 750 751 do 752 { 753 uid_range_p slot; 754 uid_range_p new_range; 755 char *invalid = NULL; 756 long start; 757 char *func_name = NULL; 758 759 next_range = strchr (one_range, ','); 760 if (next_range) 761 { 762 *next_range = '\0'; 763 next_range++; 764 } 765 766 end_val = strchr (one_range, ':'); 767 if (end_val) 768 { 769 *end_val = '\0'; 770 end_val++; 771 } 772 start = strtol (one_range, &invalid, 10); 773 if (*invalid || start < 0) 774 { 775 if (end_val || (one_range[0] >= '0' 776 && one_range[0] <= '9')) 777 { 778 error ("Invalid range %s in option %s", 779 one_range, 780 is_enable ? "-fenable" : "-fdisable"); 781 free (argstr); 782 return; 783 } 784 func_name = one_range; 785 } 786 if (!end_val) 787 { 788 new_range = XCNEW (struct uid_range); 789 if (!func_name) 790 { 791 new_range->start = (unsigned) start; 792 new_range->last = (unsigned) start; 793 } 794 else 795 { 796 new_range->start = (unsigned) -1; 797 new_range->last = (unsigned) -1; 798 new_range->assem_name = xstrdup (func_name); 799 } 800 } 801 else 802 { 803 long last = strtol (end_val, &invalid, 10); 804 if (*invalid || last < start) 805 { 806 error ("Invalid range %s in option %s", 807 end_val, 808 is_enable ? "-fenable" : "-fdisable"); 809 free (argstr); 810 return; 811 } 812 new_range = XCNEW (struct uid_range); 813 new_range->start = (unsigned) start; 814 new_range->last = (unsigned) last; 815 } 816 817 slot = VEC_index (uid_range_p, *tab, pass->static_pass_number); 818 new_range->next = slot; 819 VEC_replace (uid_range_p, *tab, pass->static_pass_number, 820 new_range); 821 if (is_enable) 822 { 823 if (new_range->assem_name) 824 inform (UNKNOWN_LOCATION, 825 "enable pass %s for function %s", 826 phase_name, new_range->assem_name); 827 else 828 inform (UNKNOWN_LOCATION, 829 "enable pass %s for functions in the range of [%u, %u]", 830 phase_name, new_range->start, new_range->last); 831 } 832 else 833 { 834 if (new_range->assem_name) 835 inform (UNKNOWN_LOCATION, 836 "disable pass %s for function %s", 837 phase_name, new_range->assem_name); 838 else 839 inform (UNKNOWN_LOCATION, 840 "disable pass %s for functions in the range of [%u, %u]", 841 phase_name, new_range->start, new_range->last); 842 } 843 844 one_range = next_range; 845 } while (next_range); 846 } 847 848 free (argstr); 849 } 850 851 /* Enable pass specified by ARG. */ 852 853 void 854 enable_pass (const char *arg) 855 { 856 enable_disable_pass (arg, true); 857 } 858 859 /* Disable pass specified by ARG. */ 860 861 void 862 disable_pass (const char *arg) 863 { 864 enable_disable_pass (arg, false); 865 } 866 867 /* Returns true if PASS is explicitly enabled/disabled for FUNC. */ 868 869 static bool 870 is_pass_explicitly_enabled_or_disabled (struct opt_pass *pass, 871 tree func, 872 VEC(uid_range_p, heap) *tab) 873 { 874 uid_range_p slot, range; 875 int cgraph_uid; 876 const char *aname = NULL; 877 878 if (!tab 879 || (unsigned) pass->static_pass_number >= VEC_length (uid_range_p, tab) 880 || pass->static_pass_number == -1) 881 return false; 882 883 slot = VEC_index (uid_range_p, tab, pass->static_pass_number); 884 if (!slot) 885 return false; 886 887 cgraph_uid = func ? cgraph_get_node (func)->uid : 0; 888 if (func && DECL_ASSEMBLER_NAME_SET_P (func)) 889 aname = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (func)); 890 891 range = slot; 892 while (range) 893 { 894 if ((unsigned) cgraph_uid >= range->start 895 && (unsigned) cgraph_uid <= range->last) 896 return true; 897 if (range->assem_name && aname 898 && !strcmp (range->assem_name, aname)) 899 return true; 900 range = range->next; 901 } 902 903 return false; 904 } 905 906 /* Look at the static_pass_number and duplicate the pass 907 if it is already added to a list. */ 908 909 static struct opt_pass * 910 make_pass_instance (struct opt_pass *pass, bool track_duplicates) 911 { 912 /* A nonzero static_pass_number indicates that the 913 pass is already in the list. */ 914 if (pass->static_pass_number) 915 { 916 struct opt_pass *new_pass; 917 918 if (pass->type == GIMPLE_PASS 919 || pass->type == RTL_PASS 920 || pass->type == SIMPLE_IPA_PASS) 921 { 922 new_pass = XNEW (struct opt_pass); 923 memcpy (new_pass, pass, sizeof (struct opt_pass)); 924 } 925 else if (pass->type == IPA_PASS) 926 { 927 new_pass = (struct opt_pass *)XNEW (struct ipa_opt_pass_d); 928 memcpy (new_pass, pass, sizeof (struct ipa_opt_pass_d)); 929 } 930 else 931 gcc_unreachable (); 932 933 new_pass->next = NULL; 934 935 new_pass->todo_flags_start &= ~TODO_mark_first_instance; 936 937 /* Indicate to register_dump_files that this pass has duplicates, 938 and so it should rename the dump file. The first instance will 939 be -1, and be number of duplicates = -static_pass_number - 1. 940 Subsequent instances will be > 0 and just the duplicate number. */ 941 if ((pass->name && pass->name[0] != '*') || track_duplicates) 942 { 943 pass->static_pass_number -= 1; 944 new_pass->static_pass_number = -pass->static_pass_number; 945 } 946 return new_pass; 947 } 948 else 949 { 950 pass->todo_flags_start |= TODO_mark_first_instance; 951 pass->static_pass_number = -1; 952 953 invoke_plugin_callbacks (PLUGIN_NEW_PASS, pass); 954 } 955 return pass; 956 } 957 958 /* Add a pass to the pass list. Duplicate the pass if it's already 959 in the list. */ 960 961 static struct opt_pass ** 962 next_pass_1 (struct opt_pass **list, struct opt_pass *pass) 963 { 964 /* Every pass should have a name so that plugins can refer to them. */ 965 gcc_assert (pass->name != NULL); 966 967 *list = make_pass_instance (pass, false); 968 969 return &(*list)->next; 970 } 971 972 /* List node for an inserted pass instance. We need to keep track of all 973 the newly-added pass instances (with 'added_pass_nodes' defined below) 974 so that we can register their dump files after pass-positioning is finished. 975 Registering dumping files needs to be post-processed or the 976 static_pass_number of the opt_pass object would be modified and mess up 977 the dump file names of future pass instances to be added. */ 978 979 struct pass_list_node 980 { 981 struct opt_pass *pass; 982 struct pass_list_node *next; 983 }; 984 985 static struct pass_list_node *added_pass_nodes = NULL; 986 static struct pass_list_node *prev_added_pass_node; 987 988 /* Insert the pass at the proper position. Return true if the pass 989 is successfully added. 990 991 NEW_PASS_INFO - new pass to be inserted 992 PASS_LIST - root of the pass list to insert the new pass to */ 993 994 static bool 995 position_pass (struct register_pass_info *new_pass_info, 996 struct opt_pass **pass_list) 997 { 998 struct opt_pass *pass = *pass_list, *prev_pass = NULL; 999 bool success = false; 1000 1001 for ( ; pass; prev_pass = pass, pass = pass->next) 1002 { 1003 /* Check if the current pass is of the same type as the new pass and 1004 matches the name and the instance number of the reference pass. */ 1005 if (pass->type == new_pass_info->pass->type 1006 && pass->name 1007 && !strcmp (pass->name, new_pass_info->reference_pass_name) 1008 && ((new_pass_info->ref_pass_instance_number == 0) 1009 || (new_pass_info->ref_pass_instance_number == 1010 pass->static_pass_number) 1011 || (new_pass_info->ref_pass_instance_number == 1 1012 && pass->todo_flags_start & TODO_mark_first_instance))) 1013 { 1014 struct opt_pass *new_pass; 1015 struct pass_list_node *new_pass_node; 1016 1017 new_pass = make_pass_instance (new_pass_info->pass, true); 1018 1019 /* Insert the new pass instance based on the positioning op. */ 1020 switch (new_pass_info->pos_op) 1021 { 1022 case PASS_POS_INSERT_AFTER: 1023 new_pass->next = pass->next; 1024 pass->next = new_pass; 1025 1026 /* Skip newly inserted pass to avoid repeated 1027 insertions in the case where the new pass and the 1028 existing one have the same name. */ 1029 pass = new_pass; 1030 break; 1031 case PASS_POS_INSERT_BEFORE: 1032 new_pass->next = pass; 1033 if (prev_pass) 1034 prev_pass->next = new_pass; 1035 else 1036 *pass_list = new_pass; 1037 break; 1038 case PASS_POS_REPLACE: 1039 new_pass->next = pass->next; 1040 if (prev_pass) 1041 prev_pass->next = new_pass; 1042 else 1043 *pass_list = new_pass; 1044 new_pass->sub = pass->sub; 1045 new_pass->tv_id = pass->tv_id; 1046 pass = new_pass; 1047 break; 1048 default: 1049 error ("invalid pass positioning operation"); 1050 return false; 1051 } 1052 1053 /* Save the newly added pass (instance) in the added_pass_nodes 1054 list so that we can register its dump file later. Note that 1055 we cannot register the dump file now because doing so will modify 1056 the static_pass_number of the opt_pass object and therefore 1057 mess up the dump file name of future instances. */ 1058 new_pass_node = XCNEW (struct pass_list_node); 1059 new_pass_node->pass = new_pass; 1060 if (!added_pass_nodes) 1061 added_pass_nodes = new_pass_node; 1062 else 1063 prev_added_pass_node->next = new_pass_node; 1064 prev_added_pass_node = new_pass_node; 1065 1066 success = true; 1067 } 1068 1069 if (pass->sub && position_pass (new_pass_info, &pass->sub)) 1070 success = true; 1071 } 1072 1073 return success; 1074 } 1075 1076 /* Hooks a new pass into the pass lists. 1077 1078 PASS_INFO - pass information that specifies the opt_pass object, 1079 reference pass, instance number, and how to position 1080 the pass */ 1081 1082 void 1083 register_pass (struct register_pass_info *pass_info) 1084 { 1085 bool all_instances, success; 1086 1087 /* The checks below could fail in buggy plugins. Existing GCC 1088 passes should never fail these checks, so we mention plugin in 1089 the messages. */ 1090 if (!pass_info->pass) 1091 fatal_error ("plugin cannot register a missing pass"); 1092 1093 if (!pass_info->pass->name) 1094 fatal_error ("plugin cannot register an unnamed pass"); 1095 1096 if (!pass_info->reference_pass_name) 1097 fatal_error 1098 ("plugin cannot register pass %qs without reference pass name", 1099 pass_info->pass->name); 1100 1101 /* Try to insert the new pass to the pass lists. We need to check 1102 all five lists as the reference pass could be in one (or all) of 1103 them. */ 1104 all_instances = pass_info->ref_pass_instance_number == 0; 1105 success = position_pass (pass_info, &all_lowering_passes); 1106 if (!success || all_instances) 1107 success |= position_pass (pass_info, &all_small_ipa_passes); 1108 if (!success || all_instances) 1109 success |= position_pass (pass_info, &all_regular_ipa_passes); 1110 if (!success || all_instances) 1111 success |= position_pass (pass_info, &all_lto_gen_passes); 1112 if (!success || all_instances) 1113 success |= position_pass (pass_info, &all_late_ipa_passes); 1114 if (!success || all_instances) 1115 success |= position_pass (pass_info, &all_passes); 1116 if (!success) 1117 fatal_error 1118 ("pass %qs not found but is referenced by new pass %qs", 1119 pass_info->reference_pass_name, pass_info->pass->name); 1120 1121 /* OK, we have successfully inserted the new pass. We need to register 1122 the dump files for the newly added pass and its duplicates (if any). 1123 Because the registration of plugin/backend passes happens after the 1124 command-line options are parsed, the options that specify single 1125 pass dumping (e.g. -fdump-tree-PASSNAME) cannot be used for new 1126 passes. Therefore we currently can only enable dumping of 1127 new passes when the 'dump-all' flags (e.g. -fdump-tree-all) 1128 are specified. While doing so, we also delete the pass_list_node 1129 objects created during pass positioning. */ 1130 while (added_pass_nodes) 1131 { 1132 struct pass_list_node *next_node = added_pass_nodes->next; 1133 enum tree_dump_index tdi; 1134 register_one_dump_file (added_pass_nodes->pass); 1135 if (added_pass_nodes->pass->type == SIMPLE_IPA_PASS 1136 || added_pass_nodes->pass->type == IPA_PASS) 1137 tdi = TDI_ipa_all; 1138 else if (added_pass_nodes->pass->type == GIMPLE_PASS) 1139 tdi = TDI_tree_all; 1140 else 1141 tdi = TDI_rtl_all; 1142 /* Check if dump-all flag is specified. */ 1143 if (get_dump_file_info (tdi)->state) 1144 get_dump_file_info (added_pass_nodes->pass->static_pass_number) 1145 ->state = get_dump_file_info (tdi)->state; 1146 XDELETE (added_pass_nodes); 1147 added_pass_nodes = next_node; 1148 } 1149 } 1150 1151 /* Construct the pass tree. The sequencing of passes is driven by 1152 the cgraph routines: 1153 1154 cgraph_finalize_compilation_unit () 1155 for each node N in the cgraph 1156 cgraph_analyze_function (N) 1157 cgraph_lower_function (N) -> all_lowering_passes 1158 1159 If we are optimizing, cgraph_optimize is then invoked: 1160 1161 cgraph_optimize () 1162 ipa_passes () -> all_small_ipa_passes 1163 cgraph_expand_all_functions () 1164 for each node N in the cgraph 1165 cgraph_expand_function (N) 1166 tree_rest_of_compilation (DECL (N)) -> all_passes 1167 */ 1168 1169 void 1170 init_optimization_passes (void) 1171 { 1172 struct opt_pass **p; 1173 1174 #define NEXT_PASS(PASS) (p = next_pass_1 (p, &((PASS).pass))) 1175 1176 /* All passes needed to lower the function into shape optimizers can 1177 operate on. These passes are always run first on the function, but 1178 backend might produce already lowered functions that are not processed 1179 by these passes. */ 1180 p = &all_lowering_passes; 1181 NEXT_PASS (pass_warn_unused_result); 1182 NEXT_PASS (pass_diagnose_omp_blocks); 1183 NEXT_PASS (pass_diagnose_tm_blocks); 1184 NEXT_PASS (pass_mudflap_1); 1185 NEXT_PASS (pass_lower_omp); 1186 NEXT_PASS (pass_lower_cf); 1187 NEXT_PASS (pass_lower_tm); 1188 NEXT_PASS (pass_refactor_eh); 1189 NEXT_PASS (pass_lower_eh); 1190 NEXT_PASS (pass_build_cfg); 1191 NEXT_PASS (pass_warn_function_return); 1192 NEXT_PASS (pass_build_cgraph_edges); 1193 *p = NULL; 1194 1195 /* Interprocedural optimization passes. */ 1196 p = &all_small_ipa_passes; 1197 NEXT_PASS (pass_ipa_free_lang_data); 1198 NEXT_PASS (pass_ipa_function_and_variable_visibility); 1199 NEXT_PASS (pass_early_local_passes); 1200 { 1201 struct opt_pass **p = &pass_early_local_passes.pass.sub; 1202 NEXT_PASS (pass_fixup_cfg); 1203 NEXT_PASS (pass_init_datastructures); 1204 NEXT_PASS (pass_expand_omp); 1205 1206 NEXT_PASS (pass_referenced_vars); 1207 NEXT_PASS (pass_build_ssa); 1208 NEXT_PASS (pass_lower_vector); 1209 NEXT_PASS (pass_early_warn_uninitialized); 1210 NEXT_PASS (pass_rebuild_cgraph_edges); 1211 NEXT_PASS (pass_inline_parameters); 1212 NEXT_PASS (pass_early_inline); 1213 NEXT_PASS (pass_all_early_optimizations); 1214 { 1215 struct opt_pass **p = &pass_all_early_optimizations.pass.sub; 1216 NEXT_PASS (pass_remove_cgraph_callee_edges); 1217 NEXT_PASS (pass_rename_ssa_copies); 1218 NEXT_PASS (pass_ccp); 1219 NEXT_PASS (pass_forwprop); 1220 /* pass_build_ealias is a dummy pass that ensures that we 1221 execute TODO_rebuild_alias at this point. Re-building 1222 alias information also rewrites no longer addressed 1223 locals into SSA form if possible. */ 1224 NEXT_PASS (pass_build_ealias); 1225 NEXT_PASS (pass_sra_early); 1226 NEXT_PASS (pass_fre); 1227 NEXT_PASS (pass_copy_prop); 1228 NEXT_PASS (pass_merge_phi); 1229 NEXT_PASS (pass_cd_dce); 1230 NEXT_PASS (pass_early_ipa_sra); 1231 NEXT_PASS (pass_tail_recursion); 1232 NEXT_PASS (pass_convert_switch); 1233 NEXT_PASS (pass_cleanup_eh); 1234 NEXT_PASS (pass_profile); 1235 NEXT_PASS (pass_local_pure_const); 1236 /* Split functions creates parts that are not run through 1237 early optimizations again. It is thus good idea to do this 1238 late. */ 1239 NEXT_PASS (pass_split_functions); 1240 } 1241 NEXT_PASS (pass_release_ssa_names); 1242 NEXT_PASS (pass_rebuild_cgraph_edges); 1243 NEXT_PASS (pass_inline_parameters); 1244 } 1245 NEXT_PASS (pass_ipa_tree_profile); 1246 { 1247 struct opt_pass **p = &pass_ipa_tree_profile.pass.sub; 1248 NEXT_PASS (pass_feedback_split_functions); 1249 } 1250 NEXT_PASS (pass_ipa_increase_alignment); 1251 NEXT_PASS (pass_ipa_matrix_reorg); 1252 NEXT_PASS (pass_ipa_tm); 1253 NEXT_PASS (pass_ipa_lower_emutls); 1254 *p = NULL; 1255 1256 p = &all_regular_ipa_passes; 1257 NEXT_PASS (pass_ipa_whole_program_visibility); 1258 NEXT_PASS (pass_ipa_profile); 1259 NEXT_PASS (pass_ipa_cp); 1260 NEXT_PASS (pass_ipa_cdtor_merge); 1261 NEXT_PASS (pass_ipa_inline); 1262 NEXT_PASS (pass_ipa_pure_const); 1263 NEXT_PASS (pass_ipa_reference); 1264 *p = NULL; 1265 1266 p = &all_lto_gen_passes; 1267 NEXT_PASS (pass_ipa_lto_gimple_out); 1268 NEXT_PASS (pass_ipa_lto_finish_out); /* This must be the last LTO pass. */ 1269 *p = NULL; 1270 1271 /* Simple IPA passes executed after the regular passes. In WHOPR mode the 1272 passes are executed after partitioning and thus see just parts of the 1273 compiled unit. */ 1274 p = &all_late_ipa_passes; 1275 NEXT_PASS (pass_ipa_pta); 1276 *p = NULL; 1277 /* These passes are run after IPA passes on every function that is being 1278 output to the assembler file. */ 1279 p = &all_passes; 1280 NEXT_PASS (pass_fixup_cfg); 1281 NEXT_PASS (pass_lower_eh_dispatch); 1282 NEXT_PASS (pass_all_optimizations); 1283 { 1284 struct opt_pass **p = &pass_all_optimizations.pass.sub; 1285 NEXT_PASS (pass_remove_cgraph_callee_edges); 1286 /* Initial scalar cleanups before alias computation. 1287 They ensure memory accesses are not indirect wherever possible. */ 1288 NEXT_PASS (pass_strip_predict_hints); 1289 NEXT_PASS (pass_rename_ssa_copies); 1290 NEXT_PASS (pass_complete_unrolli); 1291 NEXT_PASS (pass_ccp); 1292 NEXT_PASS (pass_forwprop); 1293 NEXT_PASS (pass_call_cdce); 1294 /* pass_build_alias is a dummy pass that ensures that we 1295 execute TODO_rebuild_alias at this point. Re-building 1296 alias information also rewrites no longer addressed 1297 locals into SSA form if possible. */ 1298 NEXT_PASS (pass_build_alias); 1299 NEXT_PASS (pass_return_slot); 1300 NEXT_PASS (pass_phiprop); 1301 NEXT_PASS (pass_fre); 1302 NEXT_PASS (pass_copy_prop); 1303 NEXT_PASS (pass_merge_phi); 1304 NEXT_PASS (pass_vrp); 1305 NEXT_PASS (pass_dce); 1306 NEXT_PASS (pass_cselim); 1307 NEXT_PASS (pass_tree_ifcombine); 1308 NEXT_PASS (pass_phiopt); 1309 NEXT_PASS (pass_tail_recursion); 1310 NEXT_PASS (pass_ch); 1311 NEXT_PASS (pass_stdarg); 1312 NEXT_PASS (pass_lower_complex); 1313 NEXT_PASS (pass_sra); 1314 NEXT_PASS (pass_rename_ssa_copies); 1315 /* The dom pass will also resolve all __builtin_constant_p calls 1316 that are still there to 0. This has to be done after some 1317 propagations have already run, but before some more dead code 1318 is removed, and this place fits nicely. Remember this when 1319 trying to move or duplicate pass_dominator somewhere earlier. */ 1320 NEXT_PASS (pass_dominator); 1321 /* The only const/copy propagation opportunities left after 1322 DOM should be due to degenerate PHI nodes. So rather than 1323 run the full propagators, run a specialized pass which 1324 only examines PHIs to discover const/copy propagation 1325 opportunities. */ 1326 NEXT_PASS (pass_phi_only_cprop); 1327 NEXT_PASS (pass_dse); 1328 NEXT_PASS (pass_reassoc); 1329 NEXT_PASS (pass_dce); 1330 NEXT_PASS (pass_forwprop); 1331 NEXT_PASS (pass_phiopt); 1332 NEXT_PASS (pass_object_sizes); 1333 NEXT_PASS (pass_strlen); 1334 NEXT_PASS (pass_ccp); 1335 NEXT_PASS (pass_copy_prop); 1336 NEXT_PASS (pass_cse_sincos); 1337 NEXT_PASS (pass_optimize_bswap); 1338 NEXT_PASS (pass_split_crit_edges); 1339 NEXT_PASS (pass_pre); 1340 NEXT_PASS (pass_sink_code); 1341 NEXT_PASS (pass_tree_loop); 1342 { 1343 struct opt_pass **p = &pass_tree_loop.pass.sub; 1344 NEXT_PASS (pass_tree_loop_init); 1345 NEXT_PASS (pass_lim); 1346 NEXT_PASS (pass_copy_prop); 1347 NEXT_PASS (pass_dce_loop); 1348 NEXT_PASS (pass_tree_unswitch); 1349 NEXT_PASS (pass_scev_cprop); 1350 NEXT_PASS (pass_record_bounds); 1351 NEXT_PASS (pass_check_data_deps); 1352 NEXT_PASS (pass_loop_distribution); 1353 NEXT_PASS (pass_copy_prop); 1354 NEXT_PASS (pass_graphite); 1355 { 1356 struct opt_pass **p = &pass_graphite.pass.sub; 1357 NEXT_PASS (pass_graphite_transforms); 1358 NEXT_PASS (pass_lim); 1359 NEXT_PASS (pass_copy_prop); 1360 NEXT_PASS (pass_dce_loop); 1361 } 1362 NEXT_PASS (pass_iv_canon); 1363 NEXT_PASS (pass_if_conversion); 1364 NEXT_PASS (pass_vectorize); 1365 { 1366 struct opt_pass **p = &pass_vectorize.pass.sub; 1367 NEXT_PASS (pass_dce_loop); 1368 } 1369 NEXT_PASS (pass_predcom); 1370 NEXT_PASS (pass_complete_unroll); 1371 NEXT_PASS (pass_slp_vectorize); 1372 NEXT_PASS (pass_parallelize_loops); 1373 NEXT_PASS (pass_loop_prefetch); 1374 NEXT_PASS (pass_iv_optimize); 1375 NEXT_PASS (pass_lim); 1376 NEXT_PASS (pass_tree_loop_done); 1377 } 1378 NEXT_PASS (pass_lower_vector_ssa); 1379 NEXT_PASS (pass_cse_reciprocals); 1380 NEXT_PASS (pass_reassoc); 1381 NEXT_PASS (pass_vrp); 1382 NEXT_PASS (pass_dominator); 1383 /* The only const/copy propagation opportunities left after 1384 DOM should be due to degenerate PHI nodes. So rather than 1385 run the full propagators, run a specialized pass which 1386 only examines PHIs to discover const/copy propagation 1387 opportunities. */ 1388 NEXT_PASS (pass_phi_only_cprop); 1389 NEXT_PASS (pass_cd_dce); 1390 NEXT_PASS (pass_tracer); 1391 1392 /* FIXME: If DCE is not run before checking for uninitialized uses, 1393 we may get false warnings (e.g., testsuite/gcc.dg/uninit-5.c). 1394 However, this also causes us to misdiagnose cases that should be 1395 real warnings (e.g., testsuite/gcc.dg/pr18501.c). 1396 1397 To fix the false positives in uninit-5.c, we would have to 1398 account for the predicates protecting the set and the use of each 1399 variable. Using a representation like Gated Single Assignment 1400 may help. */ 1401 NEXT_PASS (pass_late_warn_uninitialized); 1402 NEXT_PASS (pass_dse); 1403 NEXT_PASS (pass_forwprop); 1404 NEXT_PASS (pass_phiopt); 1405 NEXT_PASS (pass_fold_builtins); 1406 NEXT_PASS (pass_optimize_widening_mul); 1407 NEXT_PASS (pass_tail_calls); 1408 NEXT_PASS (pass_rename_ssa_copies); 1409 NEXT_PASS (pass_uncprop); 1410 NEXT_PASS (pass_local_pure_const); 1411 } 1412 NEXT_PASS (pass_tm_init); 1413 { 1414 struct opt_pass **p = &pass_tm_init.pass.sub; 1415 NEXT_PASS (pass_tm_mark); 1416 NEXT_PASS (pass_tm_memopt); 1417 NEXT_PASS (pass_tm_edges); 1418 } 1419 NEXT_PASS (pass_lower_complex_O0); 1420 NEXT_PASS (pass_cleanup_eh); 1421 NEXT_PASS (pass_lower_resx); 1422 NEXT_PASS (pass_nrv); 1423 NEXT_PASS (pass_mudflap_2); 1424 NEXT_PASS (pass_cleanup_cfg_post_optimizing); 1425 NEXT_PASS (pass_warn_function_noreturn); 1426 1427 NEXT_PASS (pass_expand); 1428 1429 NEXT_PASS (pass_rest_of_compilation); 1430 { 1431 struct opt_pass **p = &pass_rest_of_compilation.pass.sub; 1432 NEXT_PASS (pass_init_function); 1433 NEXT_PASS (pass_jump); 1434 NEXT_PASS (pass_rtl_eh); 1435 NEXT_PASS (pass_initial_value_sets); 1436 NEXT_PASS (pass_unshare_all_rtl); 1437 NEXT_PASS (pass_instantiate_virtual_regs); 1438 NEXT_PASS (pass_into_cfg_layout_mode); 1439 NEXT_PASS (pass_jump2); 1440 NEXT_PASS (pass_lower_subreg); 1441 NEXT_PASS (pass_df_initialize_opt); 1442 NEXT_PASS (pass_cse); 1443 NEXT_PASS (pass_rtl_fwprop); 1444 NEXT_PASS (pass_rtl_cprop); 1445 NEXT_PASS (pass_rtl_pre); 1446 NEXT_PASS (pass_rtl_hoist); 1447 NEXT_PASS (pass_rtl_cprop); 1448 NEXT_PASS (pass_rtl_store_motion); 1449 NEXT_PASS (pass_cse_after_global_opts); 1450 NEXT_PASS (pass_rtl_ifcvt); 1451 NEXT_PASS (pass_reginfo_init); 1452 /* Perform loop optimizations. It might be better to do them a bit 1453 sooner, but we want the profile feedback to work more 1454 efficiently. */ 1455 NEXT_PASS (pass_loop2); 1456 { 1457 struct opt_pass **p = &pass_loop2.pass.sub; 1458 NEXT_PASS (pass_rtl_loop_init); 1459 NEXT_PASS (pass_rtl_move_loop_invariants); 1460 NEXT_PASS (pass_rtl_unswitch); 1461 NEXT_PASS (pass_rtl_unroll_and_peel_loops); 1462 NEXT_PASS (pass_rtl_doloop); 1463 NEXT_PASS (pass_rtl_loop_done); 1464 *p = NULL; 1465 } 1466 NEXT_PASS (pass_web); 1467 NEXT_PASS (pass_rtl_cprop); 1468 NEXT_PASS (pass_cse2); 1469 NEXT_PASS (pass_rtl_dse1); 1470 NEXT_PASS (pass_rtl_fwprop_addr); 1471 NEXT_PASS (pass_inc_dec); 1472 NEXT_PASS (pass_initialize_regs); 1473 NEXT_PASS (pass_ud_rtl_dce); 1474 NEXT_PASS (pass_combine); 1475 NEXT_PASS (pass_if_after_combine); 1476 NEXT_PASS (pass_partition_blocks); 1477 NEXT_PASS (pass_regmove); 1478 NEXT_PASS (pass_outof_cfg_layout_mode); 1479 NEXT_PASS (pass_split_all_insns); 1480 NEXT_PASS (pass_lower_subreg2); 1481 NEXT_PASS (pass_df_initialize_no_opt); 1482 NEXT_PASS (pass_stack_ptr_mod); 1483 NEXT_PASS (pass_mode_switching); 1484 NEXT_PASS (pass_match_asm_constraints); 1485 NEXT_PASS (pass_sms); 1486 NEXT_PASS (pass_sched); 1487 NEXT_PASS (pass_ira); 1488 NEXT_PASS (pass_reload); 1489 NEXT_PASS (pass_postreload); 1490 { 1491 struct opt_pass **p = &pass_postreload.pass.sub; 1492 NEXT_PASS (pass_postreload_cse); 1493 NEXT_PASS (pass_gcse2); 1494 NEXT_PASS (pass_split_after_reload); 1495 NEXT_PASS (pass_ree); 1496 NEXT_PASS (pass_compare_elim_after_reload); 1497 NEXT_PASS (pass_branch_target_load_optimize1); 1498 NEXT_PASS (pass_thread_prologue_and_epilogue); 1499 NEXT_PASS (pass_rtl_dse2); 1500 NEXT_PASS (pass_stack_adjustments); 1501 NEXT_PASS (pass_peephole2); 1502 NEXT_PASS (pass_if_after_reload); 1503 NEXT_PASS (pass_regrename); 1504 NEXT_PASS (pass_cprop_hardreg); 1505 NEXT_PASS (pass_fast_rtl_dce); 1506 NEXT_PASS (pass_reorder_blocks); 1507 NEXT_PASS (pass_branch_target_load_optimize2); 1508 NEXT_PASS (pass_leaf_regs); 1509 NEXT_PASS (pass_split_before_sched2); 1510 NEXT_PASS (pass_sched2); 1511 NEXT_PASS (pass_stack_regs); 1512 { 1513 struct opt_pass **p = &pass_stack_regs.pass.sub; 1514 NEXT_PASS (pass_split_before_regstack); 1515 NEXT_PASS (pass_stack_regs_run); 1516 } 1517 NEXT_PASS (pass_compute_alignments); 1518 NEXT_PASS (pass_duplicate_computed_gotos); 1519 NEXT_PASS (pass_variable_tracking); 1520 NEXT_PASS (pass_free_cfg); 1521 NEXT_PASS (pass_machine_reorg); 1522 NEXT_PASS (pass_cleanup_barriers); 1523 NEXT_PASS (pass_delay_slots); 1524 NEXT_PASS (pass_split_for_shorten_branches); 1525 NEXT_PASS (pass_convert_to_eh_region_ranges); 1526 NEXT_PASS (pass_shorten_branches); 1527 NEXT_PASS (pass_set_nothrow_function_flags); 1528 NEXT_PASS (pass_dwarf2_frame); 1529 NEXT_PASS (pass_final); 1530 } 1531 NEXT_PASS (pass_df_finish); 1532 } 1533 NEXT_PASS (pass_clean_state); 1534 *p = NULL; 1535 1536 #undef NEXT_PASS 1537 1538 /* Register the passes with the tree dump code. */ 1539 register_dump_files (all_lowering_passes, PROP_gimple_any); 1540 register_dump_files (all_small_ipa_passes, 1541 PROP_gimple_any | PROP_gimple_lcf | PROP_gimple_leh 1542 | PROP_cfg); 1543 register_dump_files (all_regular_ipa_passes, 1544 PROP_gimple_any | PROP_gimple_lcf | PROP_gimple_leh 1545 | PROP_cfg); 1546 register_dump_files (all_lto_gen_passes, 1547 PROP_gimple_any | PROP_gimple_lcf | PROP_gimple_leh 1548 | PROP_cfg); 1549 register_dump_files (all_late_ipa_passes, 1550 PROP_gimple_any | PROP_gimple_lcf | PROP_gimple_leh 1551 | PROP_cfg); 1552 register_dump_files (all_passes, 1553 PROP_gimple_any | PROP_gimple_lcf | PROP_gimple_leh 1554 | PROP_cfg); 1555 } 1556 1557 /* If we are in IPA mode (i.e., current_function_decl is NULL), call 1558 function CALLBACK for every function in the call graph. Otherwise, 1559 call CALLBACK on the current function. */ 1560 1561 static void 1562 do_per_function (void (*callback) (void *data), void *data) 1563 { 1564 if (current_function_decl) 1565 callback (data); 1566 else 1567 { 1568 struct cgraph_node *node; 1569 for (node = cgraph_nodes; node; node = node->next) 1570 if (node->analyzed && gimple_has_body_p (node->decl) 1571 && (!node->clone_of || node->decl != node->clone_of->decl)) 1572 { 1573 push_cfun (DECL_STRUCT_FUNCTION (node->decl)); 1574 current_function_decl = node->decl; 1575 callback (data); 1576 if (!flag_wpa) 1577 { 1578 free_dominance_info (CDI_DOMINATORS); 1579 free_dominance_info (CDI_POST_DOMINATORS); 1580 } 1581 current_function_decl = NULL; 1582 pop_cfun (); 1583 ggc_collect (); 1584 } 1585 } 1586 } 1587 1588 /* Because inlining might remove no-longer reachable nodes, we need to 1589 keep the array visible to garbage collector to avoid reading collected 1590 out nodes. */ 1591 static int nnodes; 1592 static GTY ((length ("nnodes"))) cgraph_node_ptr *order; 1593 1594 /* If we are in IPA mode (i.e., current_function_decl is NULL), call 1595 function CALLBACK for every function in the call graph. Otherwise, 1596 call CALLBACK on the current function. 1597 This function is global so that plugins can use it. */ 1598 void 1599 do_per_function_toporder (void (*callback) (void *data), void *data) 1600 { 1601 int i; 1602 1603 if (current_function_decl) 1604 callback (data); 1605 else 1606 { 1607 gcc_assert (!order); 1608 order = ggc_alloc_vec_cgraph_node_ptr (cgraph_n_nodes); 1609 nnodes = ipa_reverse_postorder (order); 1610 for (i = nnodes - 1; i >= 0; i--) 1611 order[i]->process = 1; 1612 for (i = nnodes - 1; i >= 0; i--) 1613 { 1614 struct cgraph_node *node = order[i]; 1615 1616 /* Allow possibly removed nodes to be garbage collected. */ 1617 order[i] = NULL; 1618 node->process = 0; 1619 if (cgraph_function_with_gimple_body_p (node)) 1620 { 1621 push_cfun (DECL_STRUCT_FUNCTION (node->decl)); 1622 current_function_decl = node->decl; 1623 callback (data); 1624 free_dominance_info (CDI_DOMINATORS); 1625 free_dominance_info (CDI_POST_DOMINATORS); 1626 current_function_decl = NULL; 1627 pop_cfun (); 1628 ggc_collect (); 1629 } 1630 } 1631 } 1632 ggc_free (order); 1633 order = NULL; 1634 nnodes = 0; 1635 } 1636 1637 /* Helper function to perform function body dump. */ 1638 1639 static void 1640 execute_function_dump (void *data ATTRIBUTE_UNUSED) 1641 { 1642 if (dump_file && current_function_decl) 1643 { 1644 if (cfun->curr_properties & PROP_trees) 1645 dump_function_to_file (current_function_decl, dump_file, dump_flags); 1646 else 1647 { 1648 if (dump_flags & TDF_SLIM) 1649 print_rtl_slim_with_bb (dump_file, get_insns (), dump_flags); 1650 else if ((cfun->curr_properties & PROP_cfg) 1651 && (dump_flags & TDF_BLOCKS)) 1652 print_rtl_with_bb (dump_file, get_insns ()); 1653 else 1654 print_rtl (dump_file, get_insns ()); 1655 1656 if ((cfun->curr_properties & PROP_cfg) 1657 && graph_dump_format != no_graph 1658 && (dump_flags & TDF_GRAPH)) 1659 print_rtl_graph_with_bb (dump_file_name, get_insns ()); 1660 } 1661 1662 /* Flush the file. If verification fails, we won't be able to 1663 close the file before aborting. */ 1664 fflush (dump_file); 1665 } 1666 } 1667 1668 /* Perform all TODO actions that ought to be done on each function. */ 1669 1670 static void 1671 execute_function_todo (void *data) 1672 { 1673 unsigned int flags = (size_t)data; 1674 flags &= ~cfun->last_verified; 1675 if (!flags) 1676 return; 1677 1678 /* Always cleanup the CFG before trying to update SSA. */ 1679 if (flags & TODO_cleanup_cfg) 1680 { 1681 bool cleanup = cleanup_tree_cfg (); 1682 1683 if (cleanup && (cfun->curr_properties & PROP_ssa)) 1684 flags |= TODO_remove_unused_locals; 1685 1686 /* When cleanup_tree_cfg merges consecutive blocks, it may 1687 perform some simplistic propagation when removing single 1688 valued PHI nodes. This propagation may, in turn, cause the 1689 SSA form to become out-of-date (see PR 22037). So, even 1690 if the parent pass had not scheduled an SSA update, we may 1691 still need to do one. */ 1692 if (!(flags & TODO_update_ssa_any) && need_ssa_update_p (cfun)) 1693 flags |= TODO_update_ssa; 1694 } 1695 1696 if (flags & TODO_update_ssa_any) 1697 { 1698 unsigned update_flags = flags & TODO_update_ssa_any; 1699 update_ssa (update_flags); 1700 cfun->last_verified &= ~TODO_verify_ssa; 1701 } 1702 1703 if (flags & TODO_rebuild_alias) 1704 { 1705 execute_update_addresses_taken (); 1706 compute_may_aliases (); 1707 } 1708 else if (optimize && (flags & TODO_update_address_taken)) 1709 execute_update_addresses_taken (); 1710 1711 if (flags & TODO_remove_unused_locals) 1712 remove_unused_locals (); 1713 1714 if (flags & TODO_rebuild_frequencies) 1715 rebuild_frequencies (); 1716 1717 if (flags & TODO_rebuild_cgraph_edges) 1718 rebuild_cgraph_edges (); 1719 1720 /* If we've seen errors do not bother running any verifiers. */ 1721 if (seen_error ()) 1722 return; 1723 1724 #if defined ENABLE_CHECKING 1725 if (flags & TODO_verify_ssa 1726 || (current_loops && loops_state_satisfies_p (LOOP_CLOSED_SSA))) 1727 { 1728 verify_gimple_in_cfg (cfun); 1729 verify_ssa (true); 1730 } 1731 else if (flags & TODO_verify_stmts) 1732 verify_gimple_in_cfg (cfun); 1733 if (flags & TODO_verify_flow) 1734 verify_flow_info (); 1735 if (current_loops && loops_state_satisfies_p (LOOP_CLOSED_SSA)) 1736 verify_loop_closed_ssa (false); 1737 if (flags & TODO_verify_rtl_sharing) 1738 verify_rtl_sharing (); 1739 #endif 1740 1741 cfun->last_verified = flags & TODO_verify_all; 1742 } 1743 1744 /* Perform all TODO actions. */ 1745 static void 1746 execute_todo (unsigned int flags) 1747 { 1748 #if defined ENABLE_CHECKING 1749 if (cfun 1750 && need_ssa_update_p (cfun)) 1751 gcc_assert (flags & TODO_update_ssa_any); 1752 #endif 1753 1754 timevar_push (TV_TODO); 1755 1756 /* Inform the pass whether it is the first time it is run. */ 1757 first_pass_instance = (flags & TODO_mark_first_instance) != 0; 1758 1759 statistics_fini_pass (); 1760 1761 do_per_function (execute_function_todo, (void *)(size_t) flags); 1762 1763 /* Always remove functions just as before inlining: IPA passes might be 1764 interested to see bodies of extern inline functions that are not inlined 1765 to analyze side effects. The full removal is done just at the end 1766 of IPA pass queue. */ 1767 if (flags & TODO_remove_functions) 1768 { 1769 gcc_assert (!cfun); 1770 cgraph_remove_unreachable_nodes (true, dump_file); 1771 } 1772 1773 if ((flags & TODO_dump_cgraph) && dump_file && !current_function_decl) 1774 { 1775 gcc_assert (!cfun); 1776 dump_cgraph (dump_file); 1777 /* Flush the file. If verification fails, we won't be able to 1778 close the file before aborting. */ 1779 fflush (dump_file); 1780 } 1781 1782 if (flags & TODO_ggc_collect) 1783 ggc_collect (); 1784 1785 /* Now that the dumping has been done, we can get rid of the optional 1786 df problems. */ 1787 if (flags & TODO_df_finish) 1788 df_finish_pass ((flags & TODO_df_verify) != 0); 1789 1790 timevar_pop (TV_TODO); 1791 } 1792 1793 /* Verify invariants that should hold between passes. This is a place 1794 to put simple sanity checks. */ 1795 1796 static void 1797 verify_interpass_invariants (void) 1798 { 1799 gcc_checking_assert (!fold_deferring_overflow_warnings_p ()); 1800 } 1801 1802 /* Clear the last verified flag. */ 1803 1804 static void 1805 clear_last_verified (void *data ATTRIBUTE_UNUSED) 1806 { 1807 cfun->last_verified = 0; 1808 } 1809 1810 /* Helper function. Verify that the properties has been turn into the 1811 properties expected by the pass. */ 1812 1813 #ifdef ENABLE_CHECKING 1814 static void 1815 verify_curr_properties (void *data) 1816 { 1817 unsigned int props = (size_t)data; 1818 gcc_assert ((cfun->curr_properties & props) == props); 1819 } 1820 #endif 1821 1822 /* Initialize pass dump file. */ 1823 /* This is non-static so that the plugins can use it. */ 1824 1825 bool 1826 pass_init_dump_file (struct opt_pass *pass) 1827 { 1828 /* If a dump file name is present, open it if enabled. */ 1829 if (pass->static_pass_number != -1) 1830 { 1831 bool initializing_dump = !dump_initialized_p (pass->static_pass_number); 1832 dump_file_name = get_dump_file_name (pass->static_pass_number); 1833 dump_file = dump_begin (pass->static_pass_number, &dump_flags); 1834 if (dump_file && current_function_decl) 1835 dump_function_header (dump_file, current_function_decl, dump_flags); 1836 return initializing_dump; 1837 } 1838 else 1839 return false; 1840 } 1841 1842 /* Flush PASS dump file. */ 1843 /* This is non-static so that plugins can use it. */ 1844 1845 void 1846 pass_fini_dump_file (struct opt_pass *pass) 1847 { 1848 /* Flush and close dump file. */ 1849 if (dump_file_name) 1850 { 1851 free (CONST_CAST (char *, dump_file_name)); 1852 dump_file_name = NULL; 1853 } 1854 1855 if (dump_file) 1856 { 1857 dump_end (pass->static_pass_number, dump_file); 1858 dump_file = NULL; 1859 } 1860 } 1861 1862 /* After executing the pass, apply expected changes to the function 1863 properties. */ 1864 1865 static void 1866 update_properties_after_pass (void *data) 1867 { 1868 struct opt_pass *pass = (struct opt_pass *) data; 1869 cfun->curr_properties = (cfun->curr_properties | pass->properties_provided) 1870 & ~pass->properties_destroyed; 1871 } 1872 1873 /* Execute summary generation for all of the passes in IPA_PASS. */ 1874 1875 void 1876 execute_ipa_summary_passes (struct ipa_opt_pass_d *ipa_pass) 1877 { 1878 while (ipa_pass) 1879 { 1880 struct opt_pass *pass = &ipa_pass->pass; 1881 1882 /* Execute all of the IPA_PASSes in the list. */ 1883 if (ipa_pass->pass.type == IPA_PASS 1884 && (!pass->gate || pass->gate ()) 1885 && ipa_pass->generate_summary) 1886 { 1887 pass_init_dump_file (pass); 1888 1889 /* If a timevar is present, start it. */ 1890 if (pass->tv_id) 1891 timevar_push (pass->tv_id); 1892 1893 ipa_pass->generate_summary (); 1894 1895 /* Stop timevar. */ 1896 if (pass->tv_id) 1897 timevar_pop (pass->tv_id); 1898 1899 pass_fini_dump_file (pass); 1900 } 1901 ipa_pass = (struct ipa_opt_pass_d *)ipa_pass->pass.next; 1902 } 1903 } 1904 1905 /* Execute IPA_PASS function transform on NODE. */ 1906 1907 static void 1908 execute_one_ipa_transform_pass (struct cgraph_node *node, 1909 struct ipa_opt_pass_d *ipa_pass) 1910 { 1911 struct opt_pass *pass = &ipa_pass->pass; 1912 unsigned int todo_after = 0; 1913 1914 current_pass = pass; 1915 if (!ipa_pass->function_transform) 1916 return; 1917 1918 /* Note that the folders should only create gimple expressions. 1919 This is a hack until the new folder is ready. */ 1920 in_gimple_form = (cfun && (cfun->curr_properties & PROP_trees)) != 0; 1921 1922 pass_init_dump_file (pass); 1923 1924 /* Run pre-pass verification. */ 1925 execute_todo (ipa_pass->function_transform_todo_flags_start); 1926 1927 /* If a timevar is present, start it. */ 1928 if (pass->tv_id != TV_NONE) 1929 timevar_push (pass->tv_id); 1930 1931 /* Do it! */ 1932 todo_after = ipa_pass->function_transform (node); 1933 1934 /* Stop timevar. */ 1935 if (pass->tv_id != TV_NONE) 1936 timevar_pop (pass->tv_id); 1937 1938 /* Run post-pass cleanup and verification. */ 1939 execute_todo (todo_after); 1940 verify_interpass_invariants (); 1941 1942 do_per_function (execute_function_dump, NULL); 1943 pass_fini_dump_file (pass); 1944 1945 current_pass = NULL; 1946 } 1947 1948 /* For the current function, execute all ipa transforms. */ 1949 1950 void 1951 execute_all_ipa_transforms (void) 1952 { 1953 struct cgraph_node *node; 1954 if (!cfun) 1955 return; 1956 node = cgraph_get_node (current_function_decl); 1957 1958 if (node->ipa_transforms_to_apply) 1959 { 1960 unsigned int i; 1961 1962 for (i = 0; i < VEC_length (ipa_opt_pass, node->ipa_transforms_to_apply); 1963 i++) 1964 execute_one_ipa_transform_pass (node, 1965 VEC_index (ipa_opt_pass, 1966 node->ipa_transforms_to_apply, 1967 i)); 1968 VEC_free (ipa_opt_pass, heap, node->ipa_transforms_to_apply); 1969 node->ipa_transforms_to_apply = NULL; 1970 } 1971 } 1972 1973 /* Callback for do_per_function to apply all IPA transforms. */ 1974 1975 static void 1976 apply_ipa_transforms (void *data) 1977 { 1978 struct cgraph_node *node = cgraph_get_node (current_function_decl); 1979 if (!node->global.inlined_to && node->ipa_transforms_to_apply) 1980 { 1981 *(bool *)data = true; 1982 execute_all_ipa_transforms(); 1983 rebuild_cgraph_edges (); 1984 } 1985 } 1986 1987 /* Check if PASS is explicitly disabled or enabled and return 1988 the gate status. FUNC is the function to be processed, and 1989 GATE_STATUS is the gate status determined by pass manager by 1990 default. */ 1991 1992 static bool 1993 override_gate_status (struct opt_pass *pass, tree func, bool gate_status) 1994 { 1995 bool explicitly_enabled = false; 1996 bool explicitly_disabled = false; 1997 1998 explicitly_enabled 1999 = is_pass_explicitly_enabled_or_disabled (pass, func, 2000 enabled_pass_uid_range_tab); 2001 explicitly_disabled 2002 = is_pass_explicitly_enabled_or_disabled (pass, func, 2003 disabled_pass_uid_range_tab); 2004 2005 gate_status = !explicitly_disabled && (gate_status || explicitly_enabled); 2006 2007 return gate_status; 2008 } 2009 2010 2011 /* Execute PASS. */ 2012 2013 bool 2014 execute_one_pass (struct opt_pass *pass) 2015 { 2016 bool initializing_dump; 2017 unsigned int todo_after = 0; 2018 2019 bool gate_status; 2020 2021 /* IPA passes are executed on whole program, so cfun should be NULL. 2022 Other passes need function context set. */ 2023 if (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS) 2024 gcc_assert (!cfun && !current_function_decl); 2025 else 2026 gcc_assert (cfun && current_function_decl); 2027 2028 current_pass = pass; 2029 2030 /* Check whether gate check should be avoided. 2031 User controls the value of the gate through the parameter "gate_status". */ 2032 gate_status = (pass->gate == NULL) ? true : pass->gate(); 2033 gate_status = override_gate_status (pass, current_function_decl, gate_status); 2034 2035 /* Override gate with plugin. */ 2036 invoke_plugin_callbacks (PLUGIN_OVERRIDE_GATE, &gate_status); 2037 2038 if (!gate_status) 2039 { 2040 current_pass = NULL; 2041 return false; 2042 } 2043 2044 /* Pass execution event trigger: useful to identify passes being 2045 executed. */ 2046 invoke_plugin_callbacks (PLUGIN_PASS_EXECUTION, pass); 2047 2048 /* SIPLE IPA passes do not handle callgraphs with IPA transforms in it. 2049 Apply all trnasforms first. */ 2050 if (pass->type == SIMPLE_IPA_PASS) 2051 { 2052 bool applied = false; 2053 do_per_function (apply_ipa_transforms, (void *)&applied); 2054 if (applied) 2055 cgraph_remove_unreachable_nodes (true, dump_file); 2056 /* Restore current_pass. */ 2057 current_pass = pass; 2058 } 2059 2060 if (!quiet_flag && !cfun) 2061 fprintf (stderr, " <%s>", pass->name ? pass->name : ""); 2062 2063 /* Note that the folders should only create gimple expressions. 2064 This is a hack until the new folder is ready. */ 2065 in_gimple_form = (cfun && (cfun->curr_properties & PROP_trees)) != 0; 2066 2067 initializing_dump = pass_init_dump_file (pass); 2068 2069 /* Run pre-pass verification. */ 2070 execute_todo (pass->todo_flags_start); 2071 2072 #ifdef ENABLE_CHECKING 2073 do_per_function (verify_curr_properties, 2074 (void *)(size_t)pass->properties_required); 2075 #endif 2076 2077 /* If a timevar is present, start it. */ 2078 if (pass->tv_id != TV_NONE) 2079 timevar_push (pass->tv_id); 2080 2081 /* Do it! */ 2082 if (pass->execute) 2083 { 2084 todo_after = pass->execute (); 2085 do_per_function (clear_last_verified, NULL); 2086 } 2087 2088 /* Stop timevar. */ 2089 if (pass->tv_id != TV_NONE) 2090 timevar_pop (pass->tv_id); 2091 2092 do_per_function (update_properties_after_pass, pass); 2093 2094 if (initializing_dump 2095 && dump_file 2096 && graph_dump_format != no_graph 2097 && cfun 2098 && (cfun->curr_properties & (PROP_cfg | PROP_rtl)) 2099 == (PROP_cfg | PROP_rtl)) 2100 { 2101 get_dump_file_info (pass->static_pass_number)->flags |= TDF_GRAPH; 2102 dump_flags |= TDF_GRAPH; 2103 clean_graph_dump_file (dump_file_name); 2104 } 2105 2106 /* Run post-pass cleanup and verification. */ 2107 execute_todo (todo_after | pass->todo_flags_finish); 2108 verify_interpass_invariants (); 2109 do_per_function (execute_function_dump, NULL); 2110 if (pass->type == IPA_PASS) 2111 { 2112 struct cgraph_node *node; 2113 FOR_EACH_FUNCTION_WITH_GIMPLE_BODY (node) 2114 VEC_safe_push (ipa_opt_pass, heap, node->ipa_transforms_to_apply, 2115 (struct ipa_opt_pass_d *)pass); 2116 } 2117 2118 if (!current_function_decl) 2119 cgraph_process_new_functions (); 2120 2121 pass_fini_dump_file (pass); 2122 2123 if (pass->type != SIMPLE_IPA_PASS && pass->type != IPA_PASS) 2124 gcc_assert (!(cfun->curr_properties & PROP_trees) 2125 || pass->type != RTL_PASS); 2126 2127 current_pass = NULL; 2128 2129 return true; 2130 } 2131 2132 void 2133 execute_pass_list (struct opt_pass *pass) 2134 { 2135 do 2136 { 2137 gcc_assert (pass->type == GIMPLE_PASS 2138 || pass->type == RTL_PASS); 2139 if (execute_one_pass (pass) && pass->sub) 2140 execute_pass_list (pass->sub); 2141 pass = pass->next; 2142 } 2143 while (pass); 2144 } 2145 2146 /* Same as execute_pass_list but assume that subpasses of IPA passes 2147 are local passes. If SET is not NULL, write out summaries of only 2148 those node in SET. */ 2149 2150 static void 2151 ipa_write_summaries_2 (struct opt_pass *pass, cgraph_node_set set, 2152 varpool_node_set vset, 2153 struct lto_out_decl_state *state) 2154 { 2155 while (pass) 2156 { 2157 struct ipa_opt_pass_d *ipa_pass = (struct ipa_opt_pass_d *)pass; 2158 gcc_assert (!current_function_decl); 2159 gcc_assert (!cfun); 2160 gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS); 2161 if (pass->type == IPA_PASS 2162 && ipa_pass->write_summary 2163 && (!pass->gate || pass->gate ())) 2164 { 2165 /* If a timevar is present, start it. */ 2166 if (pass->tv_id) 2167 timevar_push (pass->tv_id); 2168 2169 pass_init_dump_file (pass); 2170 2171 ipa_pass->write_summary (set,vset); 2172 2173 pass_fini_dump_file (pass); 2174 2175 /* If a timevar is present, start it. */ 2176 if (pass->tv_id) 2177 timevar_pop (pass->tv_id); 2178 } 2179 2180 if (pass->sub && pass->sub->type != GIMPLE_PASS) 2181 ipa_write_summaries_2 (pass->sub, set, vset, state); 2182 2183 pass = pass->next; 2184 } 2185 } 2186 2187 /* Helper function of ipa_write_summaries. Creates and destroys the 2188 decl state and calls ipa_write_summaries_2 for all passes that have 2189 summaries. SET is the set of nodes to be written. */ 2190 2191 static void 2192 ipa_write_summaries_1 (cgraph_node_set set, varpool_node_set vset) 2193 { 2194 struct lto_out_decl_state *state = lto_new_out_decl_state (); 2195 compute_ltrans_boundary (state, set, vset); 2196 2197 lto_push_out_decl_state (state); 2198 2199 gcc_assert (!flag_wpa); 2200 ipa_write_summaries_2 (all_regular_ipa_passes, set, vset, state); 2201 ipa_write_summaries_2 (all_lto_gen_passes, set, vset, state); 2202 2203 gcc_assert (lto_get_out_decl_state () == state); 2204 lto_pop_out_decl_state (); 2205 lto_delete_out_decl_state (state); 2206 } 2207 2208 /* Write out summaries for all the nodes in the callgraph. */ 2209 2210 void 2211 ipa_write_summaries (void) 2212 { 2213 cgraph_node_set set; 2214 varpool_node_set vset; 2215 struct cgraph_node **order; 2216 struct varpool_node *vnode; 2217 int i, order_pos; 2218 2219 if (!flag_generate_lto || seen_error ()) 2220 return; 2221 2222 set = cgraph_node_set_new (); 2223 2224 /* Create the callgraph set in the same order used in 2225 cgraph_expand_all_functions. This mostly facilitates debugging, 2226 since it causes the gimple file to be processed in the same order 2227 as the source code. */ 2228 order = XCNEWVEC (struct cgraph_node *, cgraph_n_nodes); 2229 order_pos = ipa_reverse_postorder (order); 2230 gcc_assert (order_pos == cgraph_n_nodes); 2231 2232 for (i = order_pos - 1; i >= 0; i--) 2233 { 2234 struct cgraph_node *node = order[i]; 2235 2236 if (cgraph_function_with_gimple_body_p (node)) 2237 { 2238 /* When streaming out references to statements as part of some IPA 2239 pass summary, the statements need to have uids assigned and the 2240 following does that for all the IPA passes here. Naturally, this 2241 ordering then matches the one IPA-passes get in their stmt_fixup 2242 hooks. */ 2243 2244 push_cfun (DECL_STRUCT_FUNCTION (node->decl)); 2245 renumber_gimple_stmt_uids (); 2246 pop_cfun (); 2247 } 2248 if (node->analyzed) 2249 cgraph_node_set_add (set, node); 2250 } 2251 vset = varpool_node_set_new (); 2252 2253 for (vnode = varpool_nodes; vnode; vnode = vnode->next) 2254 if (vnode->needed && (!vnode->alias || vnode->alias_of)) 2255 varpool_node_set_add (vset, vnode); 2256 2257 ipa_write_summaries_1 (set, vset); 2258 2259 free (order); 2260 free_cgraph_node_set (set); 2261 free_varpool_node_set (vset); 2262 } 2263 2264 /* Same as execute_pass_list but assume that subpasses of IPA passes 2265 are local passes. If SET is not NULL, write out optimization summaries of 2266 only those node in SET. */ 2267 2268 static void 2269 ipa_write_optimization_summaries_1 (struct opt_pass *pass, cgraph_node_set set, 2270 varpool_node_set vset, 2271 struct lto_out_decl_state *state) 2272 { 2273 while (pass) 2274 { 2275 struct ipa_opt_pass_d *ipa_pass = (struct ipa_opt_pass_d *)pass; 2276 gcc_assert (!current_function_decl); 2277 gcc_assert (!cfun); 2278 gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS); 2279 if (pass->type == IPA_PASS 2280 && ipa_pass->write_optimization_summary 2281 && (!pass->gate || pass->gate ())) 2282 { 2283 /* If a timevar is present, start it. */ 2284 if (pass->tv_id) 2285 timevar_push (pass->tv_id); 2286 2287 pass_init_dump_file (pass); 2288 2289 ipa_pass->write_optimization_summary (set, vset); 2290 2291 pass_fini_dump_file (pass); 2292 2293 /* If a timevar is present, start it. */ 2294 if (pass->tv_id) 2295 timevar_pop (pass->tv_id); 2296 } 2297 2298 if (pass->sub && pass->sub->type != GIMPLE_PASS) 2299 ipa_write_optimization_summaries_1 (pass->sub, set, vset, state); 2300 2301 pass = pass->next; 2302 } 2303 } 2304 2305 /* Write all the optimization summaries for the cgraph nodes in SET. If SET is 2306 NULL, write out all summaries of all nodes. */ 2307 2308 void 2309 ipa_write_optimization_summaries (cgraph_node_set set, varpool_node_set vset) 2310 { 2311 struct lto_out_decl_state *state = lto_new_out_decl_state (); 2312 cgraph_node_set_iterator csi; 2313 compute_ltrans_boundary (state, set, vset); 2314 2315 lto_push_out_decl_state (state); 2316 for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi)) 2317 { 2318 struct cgraph_node *node = csi_node (csi); 2319 /* When streaming out references to statements as part of some IPA 2320 pass summary, the statements need to have uids assigned. 2321 2322 For functions newly born at WPA stage we need to initialize 2323 the uids here. */ 2324 if (node->analyzed 2325 && gimple_has_body_p (node->decl)) 2326 { 2327 push_cfun (DECL_STRUCT_FUNCTION (node->decl)); 2328 renumber_gimple_stmt_uids (); 2329 pop_cfun (); 2330 } 2331 } 2332 2333 gcc_assert (flag_wpa); 2334 ipa_write_optimization_summaries_1 (all_regular_ipa_passes, set, vset, state); 2335 ipa_write_optimization_summaries_1 (all_lto_gen_passes, set, vset, state); 2336 2337 gcc_assert (lto_get_out_decl_state () == state); 2338 lto_pop_out_decl_state (); 2339 lto_delete_out_decl_state (state); 2340 } 2341 2342 /* Same as execute_pass_list but assume that subpasses of IPA passes 2343 are local passes. */ 2344 2345 static void 2346 ipa_read_summaries_1 (struct opt_pass *pass) 2347 { 2348 while (pass) 2349 { 2350 struct ipa_opt_pass_d *ipa_pass = (struct ipa_opt_pass_d *) pass; 2351 2352 gcc_assert (!current_function_decl); 2353 gcc_assert (!cfun); 2354 gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS); 2355 2356 if (pass->gate == NULL || pass->gate ()) 2357 { 2358 if (pass->type == IPA_PASS && ipa_pass->read_summary) 2359 { 2360 /* If a timevar is present, start it. */ 2361 if (pass->tv_id) 2362 timevar_push (pass->tv_id); 2363 2364 pass_init_dump_file (pass); 2365 2366 ipa_pass->read_summary (); 2367 2368 pass_fini_dump_file (pass); 2369 2370 /* Stop timevar. */ 2371 if (pass->tv_id) 2372 timevar_pop (pass->tv_id); 2373 } 2374 2375 if (pass->sub && pass->sub->type != GIMPLE_PASS) 2376 ipa_read_summaries_1 (pass->sub); 2377 } 2378 pass = pass->next; 2379 } 2380 } 2381 2382 2383 /* Read all the summaries for all_regular_ipa_passes and all_lto_gen_passes. */ 2384 2385 void 2386 ipa_read_summaries (void) 2387 { 2388 ipa_read_summaries_1 (all_regular_ipa_passes); 2389 ipa_read_summaries_1 (all_lto_gen_passes); 2390 } 2391 2392 /* Same as execute_pass_list but assume that subpasses of IPA passes 2393 are local passes. */ 2394 2395 static void 2396 ipa_read_optimization_summaries_1 (struct opt_pass *pass) 2397 { 2398 while (pass) 2399 { 2400 struct ipa_opt_pass_d *ipa_pass = (struct ipa_opt_pass_d *) pass; 2401 2402 gcc_assert (!current_function_decl); 2403 gcc_assert (!cfun); 2404 gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS); 2405 2406 if (pass->gate == NULL || pass->gate ()) 2407 { 2408 if (pass->type == IPA_PASS && ipa_pass->read_optimization_summary) 2409 { 2410 /* If a timevar is present, start it. */ 2411 if (pass->tv_id) 2412 timevar_push (pass->tv_id); 2413 2414 pass_init_dump_file (pass); 2415 2416 ipa_pass->read_optimization_summary (); 2417 2418 pass_fini_dump_file (pass); 2419 2420 /* Stop timevar. */ 2421 if (pass->tv_id) 2422 timevar_pop (pass->tv_id); 2423 } 2424 2425 if (pass->sub && pass->sub->type != GIMPLE_PASS) 2426 ipa_read_optimization_summaries_1 (pass->sub); 2427 } 2428 pass = pass->next; 2429 } 2430 } 2431 2432 /* Read all the summaries for all_regular_ipa_passes and all_lto_gen_passes. */ 2433 2434 void 2435 ipa_read_optimization_summaries (void) 2436 { 2437 ipa_read_optimization_summaries_1 (all_regular_ipa_passes); 2438 ipa_read_optimization_summaries_1 (all_lto_gen_passes); 2439 } 2440 2441 /* Same as execute_pass_list but assume that subpasses of IPA passes 2442 are local passes. */ 2443 void 2444 execute_ipa_pass_list (struct opt_pass *pass) 2445 { 2446 do 2447 { 2448 gcc_assert (!current_function_decl); 2449 gcc_assert (!cfun); 2450 gcc_assert (pass->type == SIMPLE_IPA_PASS || pass->type == IPA_PASS); 2451 if (execute_one_pass (pass) && pass->sub) 2452 { 2453 if (pass->sub->type == GIMPLE_PASS) 2454 { 2455 invoke_plugin_callbacks (PLUGIN_EARLY_GIMPLE_PASSES_START, NULL); 2456 do_per_function_toporder ((void (*)(void *))execute_pass_list, 2457 pass->sub); 2458 invoke_plugin_callbacks (PLUGIN_EARLY_GIMPLE_PASSES_END, NULL); 2459 } 2460 else if (pass->sub->type == SIMPLE_IPA_PASS 2461 || pass->sub->type == IPA_PASS) 2462 execute_ipa_pass_list (pass->sub); 2463 else 2464 gcc_unreachable (); 2465 } 2466 gcc_assert (!current_function_decl); 2467 cgraph_process_new_functions (); 2468 pass = pass->next; 2469 } 2470 while (pass); 2471 } 2472 2473 /* Execute stmt fixup hooks of all passes in PASS for NODE and STMTS. */ 2474 2475 static void 2476 execute_ipa_stmt_fixups (struct opt_pass *pass, 2477 struct cgraph_node *node, gimple *stmts) 2478 { 2479 while (pass) 2480 { 2481 /* Execute all of the IPA_PASSes in the list. */ 2482 if (pass->type == IPA_PASS 2483 && (!pass->gate || pass->gate ())) 2484 { 2485 struct ipa_opt_pass_d *ipa_pass = (struct ipa_opt_pass_d *) pass; 2486 2487 if (ipa_pass->stmt_fixup) 2488 { 2489 pass_init_dump_file (pass); 2490 /* If a timevar is present, start it. */ 2491 if (pass->tv_id) 2492 timevar_push (pass->tv_id); 2493 2494 ipa_pass->stmt_fixup (node, stmts); 2495 2496 /* Stop timevar. */ 2497 if (pass->tv_id) 2498 timevar_pop (pass->tv_id); 2499 pass_fini_dump_file (pass); 2500 } 2501 if (pass->sub) 2502 execute_ipa_stmt_fixups (pass->sub, node, stmts); 2503 } 2504 pass = pass->next; 2505 } 2506 } 2507 2508 /* Execute stmt fixup hooks of all IPA passes for NODE and STMTS. */ 2509 2510 void 2511 execute_all_ipa_stmt_fixups (struct cgraph_node *node, gimple *stmts) 2512 { 2513 execute_ipa_stmt_fixups (all_regular_ipa_passes, node, stmts); 2514 } 2515 2516 2517 extern void debug_properties (unsigned int); 2518 extern void dump_properties (FILE *, unsigned int); 2519 2520 DEBUG_FUNCTION void 2521 dump_properties (FILE *dump, unsigned int props) 2522 { 2523 fprintf (dump, "Properties:\n"); 2524 if (props & PROP_gimple_any) 2525 fprintf (dump, "PROP_gimple_any\n"); 2526 if (props & PROP_gimple_lcf) 2527 fprintf (dump, "PROP_gimple_lcf\n"); 2528 if (props & PROP_gimple_leh) 2529 fprintf (dump, "PROP_gimple_leh\n"); 2530 if (props & PROP_cfg) 2531 fprintf (dump, "PROP_cfg\n"); 2532 if (props & PROP_referenced_vars) 2533 fprintf (dump, "PROP_referenced_vars\n"); 2534 if (props & PROP_ssa) 2535 fprintf (dump, "PROP_ssa\n"); 2536 if (props & PROP_no_crit_edges) 2537 fprintf (dump, "PROP_no_crit_edges\n"); 2538 if (props & PROP_rtl) 2539 fprintf (dump, "PROP_rtl\n"); 2540 if (props & PROP_gimple_lomp) 2541 fprintf (dump, "PROP_gimple_lomp\n"); 2542 if (props & PROP_gimple_lcx) 2543 fprintf (dump, "PROP_gimple_lcx\n"); 2544 if (props & PROP_cfglayout) 2545 fprintf (dump, "PROP_cfglayout\n"); 2546 } 2547 2548 DEBUG_FUNCTION void 2549 debug_properties (unsigned int props) 2550 { 2551 dump_properties (stderr, props); 2552 } 2553 2554 /* Called by local passes to see if function is called by already processed nodes. 2555 Because we process nodes in topological order, this means that function is 2556 in recursive cycle or we introduced new direct calls. */ 2557 bool 2558 function_called_by_processed_nodes_p (void) 2559 { 2560 struct cgraph_edge *e; 2561 for (e = cgraph_get_node (current_function_decl)->callers; 2562 e; 2563 e = e->next_caller) 2564 { 2565 if (e->caller->decl == current_function_decl) 2566 continue; 2567 if (!cgraph_function_with_gimple_body_p (e->caller)) 2568 continue; 2569 if (TREE_ASM_WRITTEN (e->caller->decl)) 2570 continue; 2571 if (!e->caller->process && !e->caller->global.inlined_to) 2572 break; 2573 } 2574 if (dump_file && e) 2575 { 2576 fprintf (dump_file, "Already processed call to:\n"); 2577 dump_cgraph_node (dump_file, e->caller); 2578 } 2579 return e != NULL; 2580 } 2581 2582 #include "gt-passes.h" 2583