1 /* Liveness for SSA trees. 2 Copyright (C) 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011 3 Free Software Foundation, Inc. 4 Contributed by Andrew MacLeod <amacleod@redhat.com> 5 6 This file is part of GCC. 7 8 GCC is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 3, or (at your option) 11 any later version. 12 13 GCC is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License 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 #include "config.h" 23 #include "system.h" 24 #include "coretypes.h" 25 #include "tm.h" 26 #include "tree.h" 27 #include "tree-pretty-print.h" 28 #include "gimple-pretty-print.h" 29 #include "bitmap.h" 30 #include "tree-flow.h" 31 #include "tree-dump.h" 32 #include "tree-ssa-live.h" 33 #include "diagnostic-core.h" 34 #include "debug.h" 35 #include "flags.h" 36 #include "gimple.h" 37 38 #ifdef ENABLE_CHECKING 39 static void verify_live_on_entry (tree_live_info_p); 40 #endif 41 42 43 /* VARMAP maintains a mapping from SSA version number to real variables. 44 45 All SSA_NAMES are divided into partitions. Initially each ssa_name is the 46 only member of it's own partition. Coalescing will attempt to group any 47 ssa_names which occur in a copy or in a PHI node into the same partition. 48 49 At the end of out-of-ssa, each partition becomes a "real" variable and is 50 rewritten as a compiler variable. 51 52 The var_map data structure is used to manage these partitions. It allows 53 partitions to be combined, and determines which partition belongs to what 54 ssa_name or variable, and vice versa. */ 55 56 57 /* This routine will initialize the basevar fields of MAP. */ 58 59 static void 60 var_map_base_init (var_map map) 61 { 62 int x, num_part, num; 63 tree var; 64 var_ann_t ann; 65 66 num = 0; 67 num_part = num_var_partitions (map); 68 69 /* If a base table already exists, clear it, otherwise create it. */ 70 if (map->partition_to_base_index != NULL) 71 { 72 free (map->partition_to_base_index); 73 VEC_truncate (tree, map->basevars, 0); 74 } 75 else 76 map->basevars = VEC_alloc (tree, heap, MAX (40, (num_part / 10))); 77 78 map->partition_to_base_index = (int *) xmalloc (sizeof (int) * num_part); 79 80 /* Build the base variable list, and point partitions at their bases. */ 81 for (x = 0; x < num_part; x++) 82 { 83 var = partition_to_var (map, x); 84 if (TREE_CODE (var) == SSA_NAME) 85 var = SSA_NAME_VAR (var); 86 ann = var_ann (var); 87 /* If base variable hasn't been seen, set it up. */ 88 if (!ann->base_var_processed) 89 { 90 ann->base_var_processed = 1; 91 VAR_ANN_BASE_INDEX (ann) = num++; 92 VEC_safe_push (tree, heap, map->basevars, var); 93 } 94 map->partition_to_base_index[x] = VAR_ANN_BASE_INDEX (ann); 95 } 96 97 map->num_basevars = num; 98 99 /* Now clear the processed bit. */ 100 for (x = 0; x < num; x++) 101 { 102 var = VEC_index (tree, map->basevars, x); 103 var_ann (var)->base_var_processed = 0; 104 } 105 106 #ifdef ENABLE_CHECKING 107 for (x = 0; x < num_part; x++) 108 { 109 tree var2; 110 var = SSA_NAME_VAR (partition_to_var (map, x)); 111 var2 = VEC_index (tree, map->basevars, basevar_index (map, x)); 112 gcc_assert (var == var2); 113 } 114 #endif 115 } 116 117 118 /* Remove the base table in MAP. */ 119 120 static void 121 var_map_base_fini (var_map map) 122 { 123 /* Free the basevar info if it is present. */ 124 if (map->partition_to_base_index != NULL) 125 { 126 VEC_free (tree, heap, map->basevars); 127 free (map->partition_to_base_index); 128 map->partition_to_base_index = NULL; 129 map->num_basevars = 0; 130 } 131 } 132 /* Create a variable partition map of SIZE, initialize and return it. */ 133 134 var_map 135 init_var_map (int size) 136 { 137 var_map map; 138 139 map = (var_map) xmalloc (sizeof (struct _var_map)); 140 map->var_partition = partition_new (size); 141 142 map->partition_to_view = NULL; 143 map->view_to_partition = NULL; 144 map->num_partitions = size; 145 map->partition_size = size; 146 map->num_basevars = 0; 147 map->partition_to_base_index = NULL; 148 map->basevars = NULL; 149 return map; 150 } 151 152 153 /* Free memory associated with MAP. */ 154 155 void 156 delete_var_map (var_map map) 157 { 158 var_map_base_fini (map); 159 partition_delete (map->var_partition); 160 free (map->partition_to_view); 161 free (map->view_to_partition); 162 free (map); 163 } 164 165 166 /* This function will combine the partitions in MAP for VAR1 and VAR2. It 167 Returns the partition which represents the new partition. If the two 168 partitions cannot be combined, NO_PARTITION is returned. */ 169 170 int 171 var_union (var_map map, tree var1, tree var2) 172 { 173 int p1, p2, p3; 174 175 gcc_assert (TREE_CODE (var1) == SSA_NAME); 176 gcc_assert (TREE_CODE (var2) == SSA_NAME); 177 178 /* This is independent of partition_to_view. If partition_to_view is 179 on, then whichever one of these partitions is absorbed will never have a 180 dereference into the partition_to_view array any more. */ 181 182 p1 = partition_find (map->var_partition, SSA_NAME_VERSION (var1)); 183 p2 = partition_find (map->var_partition, SSA_NAME_VERSION (var2)); 184 185 gcc_assert (p1 != NO_PARTITION); 186 gcc_assert (p2 != NO_PARTITION); 187 188 if (p1 == p2) 189 p3 = p1; 190 else 191 p3 = partition_union (map->var_partition, p1, p2); 192 193 if (map->partition_to_view) 194 p3 = map->partition_to_view[p3]; 195 196 return p3; 197 } 198 199 200 /* Compress the partition numbers in MAP such that they fall in the range 201 0..(num_partitions-1) instead of wherever they turned out during 202 the partitioning exercise. This removes any references to unused 203 partitions, thereby allowing bitmaps and other vectors to be much 204 denser. 205 206 This is implemented such that compaction doesn't affect partitioning. 207 Ie., once partitions are created and possibly merged, running one 208 or more different kind of compaction will not affect the partitions 209 themselves. Their index might change, but all the same variables will 210 still be members of the same partition group. This allows work on reduced 211 sets, and no loss of information when a larger set is later desired. 212 213 In particular, coalescing can work on partitions which have 2 or more 214 definitions, and then 'recompact' later to include all the single 215 definitions for assignment to program variables. */ 216 217 218 /* Set MAP back to the initial state of having no partition view. Return a 219 bitmap which has a bit set for each partition number which is in use in the 220 varmap. */ 221 222 static bitmap 223 partition_view_init (var_map map) 224 { 225 bitmap used; 226 int tmp; 227 unsigned int x; 228 229 used = BITMAP_ALLOC (NULL); 230 231 /* Already in a view? Abandon the old one. */ 232 if (map->partition_to_view) 233 { 234 free (map->partition_to_view); 235 map->partition_to_view = NULL; 236 } 237 if (map->view_to_partition) 238 { 239 free (map->view_to_partition); 240 map->view_to_partition = NULL; 241 } 242 243 /* Find out which partitions are actually referenced. */ 244 for (x = 0; x < map->partition_size; x++) 245 { 246 tmp = partition_find (map->var_partition, x); 247 if (ssa_name (tmp) != NULL_TREE && is_gimple_reg (ssa_name (tmp)) 248 && (!has_zero_uses (ssa_name (tmp)) 249 || !SSA_NAME_IS_DEFAULT_DEF (ssa_name (tmp)))) 250 bitmap_set_bit (used, tmp); 251 } 252 253 map->num_partitions = map->partition_size; 254 return used; 255 } 256 257 258 /* This routine will finalize the view data for MAP based on the partitions 259 set in SELECTED. This is either the same bitmap returned from 260 partition_view_init, or a trimmed down version if some of those partitions 261 were not desired in this view. SELECTED is freed before returning. */ 262 263 static void 264 partition_view_fini (var_map map, bitmap selected) 265 { 266 bitmap_iterator bi; 267 unsigned count, i, x, limit; 268 269 gcc_assert (selected); 270 271 count = bitmap_count_bits (selected); 272 limit = map->partition_size; 273 274 /* If its a one-to-one ratio, we don't need any view compaction. */ 275 if (count < limit) 276 { 277 map->partition_to_view = (int *)xmalloc (limit * sizeof (int)); 278 memset (map->partition_to_view, 0xff, (limit * sizeof (int))); 279 map->view_to_partition = (int *)xmalloc (count * sizeof (int)); 280 281 i = 0; 282 /* Give each selected partition an index. */ 283 EXECUTE_IF_SET_IN_BITMAP (selected, 0, x, bi) 284 { 285 map->partition_to_view[x] = i; 286 map->view_to_partition[i] = x; 287 i++; 288 } 289 gcc_assert (i == count); 290 map->num_partitions = i; 291 } 292 293 BITMAP_FREE (selected); 294 } 295 296 297 /* Create a partition view which includes all the used partitions in MAP. If 298 WANT_BASES is true, create the base variable map as well. */ 299 300 extern void 301 partition_view_normal (var_map map, bool want_bases) 302 { 303 bitmap used; 304 305 used = partition_view_init (map); 306 partition_view_fini (map, used); 307 308 if (want_bases) 309 var_map_base_init (map); 310 else 311 var_map_base_fini (map); 312 } 313 314 315 /* Create a partition view in MAP which includes just partitions which occur in 316 the bitmap ONLY. If WANT_BASES is true, create the base variable map 317 as well. */ 318 319 extern void 320 partition_view_bitmap (var_map map, bitmap only, bool want_bases) 321 { 322 bitmap used; 323 bitmap new_partitions = BITMAP_ALLOC (NULL); 324 unsigned x, p; 325 bitmap_iterator bi; 326 327 used = partition_view_init (map); 328 EXECUTE_IF_SET_IN_BITMAP (only, 0, x, bi) 329 { 330 p = partition_find (map->var_partition, x); 331 gcc_assert (bitmap_bit_p (used, p)); 332 bitmap_set_bit (new_partitions, p); 333 } 334 partition_view_fini (map, new_partitions); 335 336 BITMAP_FREE (used); 337 if (want_bases) 338 var_map_base_init (map); 339 else 340 var_map_base_fini (map); 341 } 342 343 344 static inline void mark_all_vars_used (tree *, void *data); 345 346 /* Helper function for mark_all_vars_used, called via walk_tree. */ 347 348 static tree 349 mark_all_vars_used_1 (tree *tp, int *walk_subtrees, void *data) 350 { 351 tree t = *tp; 352 enum tree_code_class c = TREE_CODE_CLASS (TREE_CODE (t)); 353 tree b; 354 355 if (TREE_CODE (t) == SSA_NAME) 356 t = SSA_NAME_VAR (t); 357 358 if (IS_EXPR_CODE_CLASS (c) 359 && (b = TREE_BLOCK (t)) != NULL) 360 TREE_USED (b) = true; 361 362 /* Ignore TMR_OFFSET and TMR_STEP for TARGET_MEM_REFS, as those 363 fields do not contain vars. */ 364 if (TREE_CODE (t) == TARGET_MEM_REF) 365 { 366 mark_all_vars_used (&TMR_BASE (t), data); 367 mark_all_vars_used (&TMR_INDEX (t), data); 368 mark_all_vars_used (&TMR_INDEX2 (t), data); 369 *walk_subtrees = 0; 370 return NULL; 371 } 372 373 /* Only need to mark VAR_DECLS; parameters and return results are not 374 eliminated as unused. */ 375 if (TREE_CODE (t) == VAR_DECL) 376 { 377 if (data != NULL && bitmap_clear_bit ((bitmap) data, DECL_UID (t)) 378 && DECL_CONTEXT (t) == current_function_decl) 379 mark_all_vars_used (&DECL_INITIAL (t), data); 380 set_is_used (t); 381 } 382 /* remove_unused_scope_block_p requires information about labels 383 which are not DECL_IGNORED_P to tell if they might be used in the IL. */ 384 if (TREE_CODE (t) == LABEL_DECL) 385 /* Although the TREE_USED values that the frontend uses would be 386 acceptable (albeit slightly over-conservative) for our purposes, 387 init_vars_expansion clears TREE_USED for LABEL_DECLs too, so we 388 must re-compute it here. */ 389 TREE_USED (t) = 1; 390 391 if (IS_TYPE_OR_DECL_P (t)) 392 *walk_subtrees = 0; 393 394 return NULL; 395 } 396 397 /* Mark the scope block SCOPE and its subblocks unused when they can be 398 possibly eliminated if dead. */ 399 400 static void 401 mark_scope_block_unused (tree scope) 402 { 403 tree t; 404 TREE_USED (scope) = false; 405 if (!(*debug_hooks->ignore_block) (scope)) 406 TREE_USED (scope) = true; 407 for (t = BLOCK_SUBBLOCKS (scope); t ; t = BLOCK_CHAIN (t)) 408 mark_scope_block_unused (t); 409 } 410 411 /* Look if the block is dead (by possibly eliminating its dead subblocks) 412 and return true if so. 413 Block is declared dead if: 414 1) No statements are associated with it. 415 2) Declares no live variables 416 3) All subblocks are dead 417 or there is precisely one subblocks and the block 418 has same abstract origin as outer block and declares 419 no variables, so it is pure wrapper. 420 When we are not outputting full debug info, we also eliminate dead variables 421 out of scope blocks to let them to be recycled by GGC and to save copying work 422 done by the inliner. */ 423 424 static bool 425 remove_unused_scope_block_p (tree scope) 426 { 427 tree *t, *next; 428 bool unused = !TREE_USED (scope); 429 int nsubblocks = 0; 430 431 for (t = &BLOCK_VARS (scope); *t; t = next) 432 { 433 next = &DECL_CHAIN (*t); 434 435 /* Debug info of nested function refers to the block of the 436 function. We might stil call it even if all statements 437 of function it was nested into was elliminated. 438 439 TODO: We can actually look into cgraph to see if function 440 will be output to file. */ 441 if (TREE_CODE (*t) == FUNCTION_DECL) 442 unused = false; 443 444 /* If a decl has a value expr, we need to instantiate it 445 regardless of debug info generation, to avoid codegen 446 differences in memory overlap tests. update_equiv_regs() may 447 indirectly call validate_equiv_mem() to test whether a 448 SET_DEST overlaps with others, and if the value expr changes 449 by virtual register instantiation, we may get end up with 450 different results. */ 451 else if (TREE_CODE (*t) == VAR_DECL && DECL_HAS_VALUE_EXPR_P (*t)) 452 unused = false; 453 454 /* Remove everything we don't generate debug info for. */ 455 else if (DECL_IGNORED_P (*t)) 456 { 457 *t = DECL_CHAIN (*t); 458 next = t; 459 } 460 461 /* When we are outputting debug info, we usually want to output 462 info about optimized-out variables in the scope blocks. 463 Exception are the scope blocks not containing any instructions 464 at all so user can't get into the scopes at first place. */ 465 else if (var_ann (*t) != NULL && is_used_p (*t)) 466 unused = false; 467 else if (TREE_CODE (*t) == LABEL_DECL && TREE_USED (*t)) 468 /* For labels that are still used in the IL, the decision to 469 preserve them must not depend DEBUG_INFO_LEVEL, otherwise we 470 risk having different ordering in debug vs. non-debug builds 471 during inlining or versioning. 472 A label appearing here (we have already checked DECL_IGNORED_P) 473 should not be used in the IL unless it has been explicitly used 474 before, so we use TREE_USED as an approximation. */ 475 /* In principle, we should do the same here as for the debug case 476 below, however, when debugging, there might be additional nested 477 levels that keep an upper level with a label live, so we have to 478 force this block to be considered used, too. */ 479 unused = false; 480 481 /* When we are not doing full debug info, we however can keep around 482 only the used variables for cfgexpand's memory packing saving quite 483 a lot of memory. 484 485 For sake of -g3, we keep around those vars but we don't count this as 486 use of block, so innermost block with no used vars and no instructions 487 can be considered dead. We only want to keep around blocks user can 488 breakpoint into and ask about value of optimized out variables. 489 490 Similarly we need to keep around types at least until all 491 variables of all nested blocks are gone. We track no 492 information on whether given type is used or not, so we have 493 to keep them even when not emitting debug information, 494 otherwise we may end up remapping variables and their (local) 495 types in different orders depending on whether debug 496 information is being generated. */ 497 498 else if (TREE_CODE (*t) == TYPE_DECL 499 || debug_info_level == DINFO_LEVEL_NORMAL 500 || debug_info_level == DINFO_LEVEL_VERBOSE) 501 ; 502 else 503 { 504 *t = DECL_CHAIN (*t); 505 next = t; 506 } 507 } 508 509 for (t = &BLOCK_SUBBLOCKS (scope); *t ;) 510 if (remove_unused_scope_block_p (*t)) 511 { 512 if (BLOCK_SUBBLOCKS (*t)) 513 { 514 tree next = BLOCK_CHAIN (*t); 515 tree supercontext = BLOCK_SUPERCONTEXT (*t); 516 517 *t = BLOCK_SUBBLOCKS (*t); 518 while (BLOCK_CHAIN (*t)) 519 { 520 BLOCK_SUPERCONTEXT (*t) = supercontext; 521 t = &BLOCK_CHAIN (*t); 522 } 523 BLOCK_CHAIN (*t) = next; 524 BLOCK_SUPERCONTEXT (*t) = supercontext; 525 t = &BLOCK_CHAIN (*t); 526 nsubblocks ++; 527 } 528 else 529 *t = BLOCK_CHAIN (*t); 530 } 531 else 532 { 533 t = &BLOCK_CHAIN (*t); 534 nsubblocks ++; 535 } 536 537 538 if (!unused) 539 ; 540 /* Outer scope is always used. */ 541 else if (!BLOCK_SUPERCONTEXT (scope) 542 || TREE_CODE (BLOCK_SUPERCONTEXT (scope)) == FUNCTION_DECL) 543 unused = false; 544 /* Innermost blocks with no live variables nor statements can be always 545 eliminated. */ 546 else if (!nsubblocks) 547 ; 548 /* For terse debug info we can eliminate info on unused variables. */ 549 else if (debug_info_level == DINFO_LEVEL_NONE 550 || debug_info_level == DINFO_LEVEL_TERSE) 551 { 552 /* Even for -g0/-g1 don't prune outer scopes from artificial 553 functions, otherwise diagnostics using tree_nonartificial_location 554 will not be emitted properly. */ 555 if (inlined_function_outer_scope_p (scope)) 556 { 557 tree ao = scope; 558 559 while (ao 560 && TREE_CODE (ao) == BLOCK 561 && BLOCK_ABSTRACT_ORIGIN (ao) != ao) 562 ao = BLOCK_ABSTRACT_ORIGIN (ao); 563 if (ao 564 && TREE_CODE (ao) == FUNCTION_DECL 565 && DECL_DECLARED_INLINE_P (ao) 566 && lookup_attribute ("artificial", DECL_ATTRIBUTES (ao))) 567 unused = false; 568 } 569 } 570 else if (BLOCK_VARS (scope) || BLOCK_NUM_NONLOCALIZED_VARS (scope)) 571 unused = false; 572 /* See if this block is important for representation of inlined function. 573 Inlined functions are always represented by block with 574 block_ultimate_origin being set to FUNCTION_DECL and DECL_SOURCE_LOCATION 575 set... */ 576 else if (inlined_function_outer_scope_p (scope)) 577 unused = false; 578 else 579 /* Verfify that only blocks with source location set 580 are entry points to the inlined functions. */ 581 gcc_assert (BLOCK_SOURCE_LOCATION (scope) == UNKNOWN_LOCATION); 582 583 TREE_USED (scope) = !unused; 584 return unused; 585 } 586 587 /* Mark all VAR_DECLS under *EXPR_P as used, so that they won't be 588 eliminated during the tree->rtl conversion process. */ 589 590 static inline void 591 mark_all_vars_used (tree *expr_p, void *data) 592 { 593 walk_tree (expr_p, mark_all_vars_used_1, data, NULL); 594 } 595 596 597 /* Dump scope blocks starting at SCOPE to FILE. INDENT is the 598 indentation level and FLAGS is as in print_generic_expr. */ 599 600 static void 601 dump_scope_block (FILE *file, int indent, tree scope, int flags) 602 { 603 tree var, t; 604 unsigned int i; 605 606 fprintf (file, "\n%*s{ Scope block #%i%s%s",indent, "" , BLOCK_NUMBER (scope), 607 TREE_USED (scope) ? "" : " (unused)", 608 BLOCK_ABSTRACT (scope) ? " (abstract)": ""); 609 if (BLOCK_SOURCE_LOCATION (scope) != UNKNOWN_LOCATION) 610 { 611 expanded_location s = expand_location (BLOCK_SOURCE_LOCATION (scope)); 612 fprintf (file, " %s:%i", s.file, s.line); 613 } 614 if (BLOCK_ABSTRACT_ORIGIN (scope)) 615 { 616 tree origin = block_ultimate_origin (scope); 617 if (origin) 618 { 619 fprintf (file, " Originating from :"); 620 if (DECL_P (origin)) 621 print_generic_decl (file, origin, flags); 622 else 623 fprintf (file, "#%i", BLOCK_NUMBER (origin)); 624 } 625 } 626 fprintf (file, " \n"); 627 for (var = BLOCK_VARS (scope); var; var = DECL_CHAIN (var)) 628 { 629 bool used = false; 630 631 if (var_ann (var)) 632 used = is_used_p (var); 633 634 fprintf (file, "%*s", indent, ""); 635 print_generic_decl (file, var, flags); 636 fprintf (file, "%s\n", used ? "" : " (unused)"); 637 } 638 for (i = 0; i < BLOCK_NUM_NONLOCALIZED_VARS (scope); i++) 639 { 640 fprintf (file, "%*s",indent, ""); 641 print_generic_decl (file, BLOCK_NONLOCALIZED_VAR (scope, i), 642 flags); 643 fprintf (file, " (nonlocalized)\n"); 644 } 645 for (t = BLOCK_SUBBLOCKS (scope); t ; t = BLOCK_CHAIN (t)) 646 dump_scope_block (file, indent + 2, t, flags); 647 fprintf (file, "\n%*s}\n",indent, ""); 648 } 649 650 /* Dump the tree of lexical scopes starting at SCOPE to stderr. FLAGS 651 is as in print_generic_expr. */ 652 653 DEBUG_FUNCTION void 654 debug_scope_block (tree scope, int flags) 655 { 656 dump_scope_block (stderr, 0, scope, flags); 657 } 658 659 660 /* Dump the tree of lexical scopes of current_function_decl to FILE. 661 FLAGS is as in print_generic_expr. */ 662 663 void 664 dump_scope_blocks (FILE *file, int flags) 665 { 666 dump_scope_block (file, 0, DECL_INITIAL (current_function_decl), flags); 667 } 668 669 670 /* Dump the tree of lexical scopes of current_function_decl to stderr. 671 FLAGS is as in print_generic_expr. */ 672 673 DEBUG_FUNCTION void 674 debug_scope_blocks (int flags) 675 { 676 dump_scope_blocks (stderr, flags); 677 } 678 679 /* Remove local variables that are not referenced in the IL. */ 680 681 void 682 remove_unused_locals (void) 683 { 684 basic_block bb; 685 tree var, t; 686 referenced_var_iterator rvi; 687 bitmap global_unused_vars = NULL; 688 unsigned srcidx, dstidx, num; 689 bool have_local_clobbers = false; 690 691 /* Removing declarations from lexical blocks when not optimizing is 692 not only a waste of time, it actually causes differences in stack 693 layout. */ 694 if (!optimize) 695 return; 696 697 timevar_push (TV_REMOVE_UNUSED); 698 699 mark_scope_block_unused (DECL_INITIAL (current_function_decl)); 700 701 /* Assume all locals are unused. */ 702 FOR_EACH_REFERENCED_VAR (cfun, t, rvi) 703 clear_is_used (t); 704 705 /* Walk the CFG marking all referenced symbols. */ 706 FOR_EACH_BB (bb) 707 { 708 gimple_stmt_iterator gsi; 709 size_t i; 710 edge_iterator ei; 711 edge e; 712 713 /* Walk the statements. */ 714 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) 715 { 716 gimple stmt = gsi_stmt (gsi); 717 tree b = gimple_block (stmt); 718 719 if (is_gimple_debug (stmt)) 720 continue; 721 722 if (gimple_clobber_p (stmt)) 723 { 724 have_local_clobbers = true; 725 continue; 726 } 727 728 if (b) 729 TREE_USED (b) = true; 730 731 for (i = 0; i < gimple_num_ops (stmt); i++) 732 mark_all_vars_used (gimple_op_ptr (gsi_stmt (gsi), i), NULL); 733 } 734 735 for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi)) 736 { 737 use_operand_p arg_p; 738 ssa_op_iter i; 739 tree def; 740 gimple phi = gsi_stmt (gsi); 741 742 /* No point processing globals. */ 743 if (is_global_var (SSA_NAME_VAR (gimple_phi_result (phi)))) 744 continue; 745 746 def = gimple_phi_result (phi); 747 mark_all_vars_used (&def, NULL); 748 749 FOR_EACH_PHI_ARG (arg_p, phi, i, SSA_OP_ALL_USES) 750 { 751 tree arg = USE_FROM_PTR (arg_p); 752 mark_all_vars_used (&arg, NULL); 753 } 754 } 755 756 FOR_EACH_EDGE (e, ei, bb->succs) 757 if (e->goto_locus) 758 TREE_USED (e->goto_block) = true; 759 } 760 761 /* We do a two-pass approach about the out-of-scope clobbers. We want 762 to remove them if they are the only references to a local variable, 763 but we want to retain them when there's any other. So the first pass 764 ignores them, and the second pass (if there were any) tries to remove 765 them. */ 766 if (have_local_clobbers) 767 FOR_EACH_BB (bb) 768 { 769 gimple_stmt_iterator gsi; 770 771 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi);) 772 { 773 gimple stmt = gsi_stmt (gsi); 774 tree b = gimple_block (stmt); 775 776 if (gimple_clobber_p (stmt)) 777 { 778 tree lhs = gimple_assign_lhs (stmt); 779 lhs = get_base_address (lhs); 780 if (TREE_CODE (lhs) == SSA_NAME) 781 lhs = SSA_NAME_VAR (lhs); 782 if (DECL_P (lhs) && (!var_ann (lhs) || !is_used_p (lhs))) 783 { 784 unlink_stmt_vdef (stmt); 785 gsi_remove (&gsi, true); 786 release_defs (stmt); 787 continue; 788 } 789 if (b) 790 TREE_USED (b) = true; 791 } 792 gsi_next (&gsi); 793 } 794 } 795 796 cfun->has_local_explicit_reg_vars = false; 797 798 /* Remove unmarked local vars from local_decls. */ 799 num = VEC_length (tree, cfun->local_decls); 800 for (srcidx = 0, dstidx = 0; srcidx < num; srcidx++) 801 { 802 var = VEC_index (tree, cfun->local_decls, srcidx); 803 if (TREE_CODE (var) != FUNCTION_DECL 804 && (!var_ann (var) 805 || !is_used_p (var))) 806 { 807 if (is_global_var (var)) 808 { 809 if (global_unused_vars == NULL) 810 global_unused_vars = BITMAP_ALLOC (NULL); 811 bitmap_set_bit (global_unused_vars, DECL_UID (var)); 812 } 813 else 814 continue; 815 } 816 else if (TREE_CODE (var) == VAR_DECL 817 && DECL_HARD_REGISTER (var) 818 && !is_global_var (var)) 819 cfun->has_local_explicit_reg_vars = true; 820 821 if (srcidx != dstidx) 822 VEC_replace (tree, cfun->local_decls, dstidx, var); 823 dstidx++; 824 } 825 if (dstidx != num) 826 VEC_truncate (tree, cfun->local_decls, dstidx); 827 828 /* Remove unmarked global vars from local_decls. */ 829 if (global_unused_vars != NULL) 830 { 831 tree var; 832 unsigned ix; 833 FOR_EACH_LOCAL_DECL (cfun, ix, var) 834 if (TREE_CODE (var) == VAR_DECL 835 && is_global_var (var) 836 && var_ann (var) != NULL 837 && is_used_p (var) 838 && DECL_CONTEXT (var) == current_function_decl) 839 mark_all_vars_used (&DECL_INITIAL (var), global_unused_vars); 840 841 num = VEC_length (tree, cfun->local_decls); 842 for (srcidx = 0, dstidx = 0; srcidx < num; srcidx++) 843 { 844 var = VEC_index (tree, cfun->local_decls, srcidx); 845 if (TREE_CODE (var) == VAR_DECL 846 && is_global_var (var) 847 && bitmap_bit_p (global_unused_vars, DECL_UID (var))) 848 continue; 849 850 if (srcidx != dstidx) 851 VEC_replace (tree, cfun->local_decls, dstidx, var); 852 dstidx++; 853 } 854 if (dstidx != num) 855 VEC_truncate (tree, cfun->local_decls, dstidx); 856 BITMAP_FREE (global_unused_vars); 857 } 858 859 /* Remove unused variables from REFERENCED_VARs. */ 860 FOR_EACH_REFERENCED_VAR (cfun, t, rvi) 861 if (!is_global_var (t) 862 && TREE_CODE (t) != PARM_DECL 863 && TREE_CODE (t) != RESULT_DECL 864 && !is_used_p (t)) 865 remove_referenced_var (t); 866 remove_unused_scope_block_p (DECL_INITIAL (current_function_decl)); 867 if (dump_file && (dump_flags & TDF_DETAILS)) 868 { 869 fprintf (dump_file, "Scope blocks after cleanups:\n"); 870 dump_scope_blocks (dump_file, dump_flags); 871 } 872 873 timevar_pop (TV_REMOVE_UNUSED); 874 } 875 876 877 /* Allocate and return a new live range information object base on MAP. */ 878 879 static tree_live_info_p 880 new_tree_live_info (var_map map) 881 { 882 tree_live_info_p live; 883 unsigned x; 884 885 live = (tree_live_info_p) xmalloc (sizeof (struct tree_live_info_d)); 886 live->map = map; 887 live->num_blocks = last_basic_block; 888 889 live->livein = (bitmap *)xmalloc (last_basic_block * sizeof (bitmap)); 890 for (x = 0; x < (unsigned)last_basic_block; x++) 891 live->livein[x] = BITMAP_ALLOC (NULL); 892 893 live->liveout = (bitmap *)xmalloc (last_basic_block * sizeof (bitmap)); 894 for (x = 0; x < (unsigned)last_basic_block; x++) 895 live->liveout[x] = BITMAP_ALLOC (NULL); 896 897 live->work_stack = XNEWVEC (int, last_basic_block); 898 live->stack_top = live->work_stack; 899 900 live->global = BITMAP_ALLOC (NULL); 901 return live; 902 } 903 904 905 /* Free storage for live range info object LIVE. */ 906 907 void 908 delete_tree_live_info (tree_live_info_p live) 909 { 910 int x; 911 912 BITMAP_FREE (live->global); 913 free (live->work_stack); 914 915 for (x = live->num_blocks - 1; x >= 0; x--) 916 BITMAP_FREE (live->liveout[x]); 917 free (live->liveout); 918 919 for (x = live->num_blocks - 1; x >= 0; x--) 920 BITMAP_FREE (live->livein[x]); 921 free (live->livein); 922 923 free (live); 924 } 925 926 927 /* Visit basic block BB and propagate any required live on entry bits from 928 LIVE into the predecessors. VISITED is the bitmap of visited blocks. 929 TMP is a temporary work bitmap which is passed in to avoid reallocating 930 it each time. */ 931 932 static void 933 loe_visit_block (tree_live_info_p live, basic_block bb, sbitmap visited, 934 bitmap tmp) 935 { 936 edge e; 937 bool change; 938 edge_iterator ei; 939 basic_block pred_bb; 940 bitmap loe; 941 gcc_assert (!TEST_BIT (visited, bb->index)); 942 943 SET_BIT (visited, bb->index); 944 loe = live_on_entry (live, bb); 945 946 FOR_EACH_EDGE (e, ei, bb->preds) 947 { 948 pred_bb = e->src; 949 if (pred_bb == ENTRY_BLOCK_PTR) 950 continue; 951 /* TMP is variables live-on-entry from BB that aren't defined in the 952 predecessor block. This should be the live on entry vars to pred. 953 Note that liveout is the DEFs in a block while live on entry is 954 being calculated. */ 955 bitmap_and_compl (tmp, loe, live->liveout[pred_bb->index]); 956 957 /* Add these bits to live-on-entry for the pred. if there are any 958 changes, and pred_bb has been visited already, add it to the 959 revisit stack. */ 960 change = bitmap_ior_into (live_on_entry (live, pred_bb), tmp); 961 if (TEST_BIT (visited, pred_bb->index) && change) 962 { 963 RESET_BIT (visited, pred_bb->index); 964 *(live->stack_top)++ = pred_bb->index; 965 } 966 } 967 } 968 969 970 /* Using LIVE, fill in all the live-on-entry blocks between the defs and uses 971 of all the variables. */ 972 973 static void 974 live_worklist (tree_live_info_p live) 975 { 976 unsigned b; 977 basic_block bb; 978 sbitmap visited = sbitmap_alloc (last_basic_block + 1); 979 bitmap tmp = BITMAP_ALLOC (NULL); 980 981 sbitmap_zero (visited); 982 983 /* Visit all the blocks in reverse order and propagate live on entry values 984 into the predecessors blocks. */ 985 FOR_EACH_BB_REVERSE (bb) 986 loe_visit_block (live, bb, visited, tmp); 987 988 /* Process any blocks which require further iteration. */ 989 while (live->stack_top != live->work_stack) 990 { 991 b = *--(live->stack_top); 992 loe_visit_block (live, BASIC_BLOCK (b), visited, tmp); 993 } 994 995 BITMAP_FREE (tmp); 996 sbitmap_free (visited); 997 } 998 999 1000 /* Calculate the initial live on entry vector for SSA_NAME using immediate_use 1001 links. Set the live on entry fields in LIVE. Def's are marked temporarily 1002 in the liveout vector. */ 1003 1004 static void 1005 set_var_live_on_entry (tree ssa_name, tree_live_info_p live) 1006 { 1007 int p; 1008 gimple stmt; 1009 use_operand_p use; 1010 basic_block def_bb = NULL; 1011 imm_use_iterator imm_iter; 1012 bool global = false; 1013 1014 p = var_to_partition (live->map, ssa_name); 1015 if (p == NO_PARTITION) 1016 return; 1017 1018 stmt = SSA_NAME_DEF_STMT (ssa_name); 1019 if (stmt) 1020 { 1021 def_bb = gimple_bb (stmt); 1022 /* Mark defs in liveout bitmap temporarily. */ 1023 if (def_bb) 1024 bitmap_set_bit (live->liveout[def_bb->index], p); 1025 } 1026 else 1027 def_bb = ENTRY_BLOCK_PTR; 1028 1029 /* Visit each use of SSA_NAME and if it isn't in the same block as the def, 1030 add it to the list of live on entry blocks. */ 1031 FOR_EACH_IMM_USE_FAST (use, imm_iter, ssa_name) 1032 { 1033 gimple use_stmt = USE_STMT (use); 1034 basic_block add_block = NULL; 1035 1036 if (gimple_code (use_stmt) == GIMPLE_PHI) 1037 { 1038 /* Uses in PHI's are considered to be live at exit of the SRC block 1039 as this is where a copy would be inserted. Check to see if it is 1040 defined in that block, or whether its live on entry. */ 1041 int index = PHI_ARG_INDEX_FROM_USE (use); 1042 edge e = gimple_phi_arg_edge (use_stmt, index); 1043 if (e->src != ENTRY_BLOCK_PTR) 1044 { 1045 if (e->src != def_bb) 1046 add_block = e->src; 1047 } 1048 } 1049 else if (is_gimple_debug (use_stmt)) 1050 continue; 1051 else 1052 { 1053 /* If its not defined in this block, its live on entry. */ 1054 basic_block use_bb = gimple_bb (use_stmt); 1055 if (use_bb != def_bb) 1056 add_block = use_bb; 1057 } 1058 1059 /* If there was a live on entry use, set the bit. */ 1060 if (add_block) 1061 { 1062 global = true; 1063 bitmap_set_bit (live->livein[add_block->index], p); 1064 } 1065 } 1066 1067 /* If SSA_NAME is live on entry to at least one block, fill in all the live 1068 on entry blocks between the def and all the uses. */ 1069 if (global) 1070 bitmap_set_bit (live->global, p); 1071 } 1072 1073 1074 /* Calculate the live on exit vectors based on the entry info in LIVEINFO. */ 1075 1076 void 1077 calculate_live_on_exit (tree_live_info_p liveinfo) 1078 { 1079 basic_block bb; 1080 edge e; 1081 edge_iterator ei; 1082 1083 /* live on entry calculations used liveout vectors for defs, clear them. */ 1084 FOR_EACH_BB (bb) 1085 bitmap_clear (liveinfo->liveout[bb->index]); 1086 1087 /* Set all the live-on-exit bits for uses in PHIs. */ 1088 FOR_EACH_BB (bb) 1089 { 1090 gimple_stmt_iterator gsi; 1091 size_t i; 1092 1093 /* Mark the PHI arguments which are live on exit to the pred block. */ 1094 for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi)) 1095 { 1096 gimple phi = gsi_stmt (gsi); 1097 for (i = 0; i < gimple_phi_num_args (phi); i++) 1098 { 1099 tree t = PHI_ARG_DEF (phi, i); 1100 int p; 1101 1102 if (TREE_CODE (t) != SSA_NAME) 1103 continue; 1104 1105 p = var_to_partition (liveinfo->map, t); 1106 if (p == NO_PARTITION) 1107 continue; 1108 e = gimple_phi_arg_edge (phi, i); 1109 if (e->src != ENTRY_BLOCK_PTR) 1110 bitmap_set_bit (liveinfo->liveout[e->src->index], p); 1111 } 1112 } 1113 1114 /* Add each successors live on entry to this bock live on exit. */ 1115 FOR_EACH_EDGE (e, ei, bb->succs) 1116 if (e->dest != EXIT_BLOCK_PTR) 1117 bitmap_ior_into (liveinfo->liveout[bb->index], 1118 live_on_entry (liveinfo, e->dest)); 1119 } 1120 } 1121 1122 1123 /* Given partition map MAP, calculate all the live on entry bitmaps for 1124 each partition. Return a new live info object. */ 1125 1126 tree_live_info_p 1127 calculate_live_ranges (var_map map) 1128 { 1129 tree var; 1130 unsigned i; 1131 tree_live_info_p live; 1132 1133 live = new_tree_live_info (map); 1134 for (i = 0; i < num_var_partitions (map); i++) 1135 { 1136 var = partition_to_var (map, i); 1137 if (var != NULL_TREE) 1138 set_var_live_on_entry (var, live); 1139 } 1140 1141 live_worklist (live); 1142 1143 #ifdef ENABLE_CHECKING 1144 verify_live_on_entry (live); 1145 #endif 1146 1147 calculate_live_on_exit (live); 1148 return live; 1149 } 1150 1151 1152 /* Output partition map MAP to file F. */ 1153 1154 void 1155 dump_var_map (FILE *f, var_map map) 1156 { 1157 int t; 1158 unsigned x, y; 1159 int p; 1160 1161 fprintf (f, "\nPartition map \n\n"); 1162 1163 for (x = 0; x < map->num_partitions; x++) 1164 { 1165 if (map->view_to_partition != NULL) 1166 p = map->view_to_partition[x]; 1167 else 1168 p = x; 1169 1170 if (ssa_name (p) == NULL_TREE) 1171 continue; 1172 1173 t = 0; 1174 for (y = 1; y < num_ssa_names; y++) 1175 { 1176 p = partition_find (map->var_partition, y); 1177 if (map->partition_to_view) 1178 p = map->partition_to_view[p]; 1179 if (p == (int)x) 1180 { 1181 if (t++ == 0) 1182 { 1183 fprintf(f, "Partition %d (", x); 1184 print_generic_expr (f, partition_to_var (map, p), TDF_SLIM); 1185 fprintf (f, " - "); 1186 } 1187 fprintf (f, "%d ", y); 1188 } 1189 } 1190 if (t != 0) 1191 fprintf (f, ")\n"); 1192 } 1193 fprintf (f, "\n"); 1194 } 1195 1196 1197 /* Output live range info LIVE to file F, controlled by FLAG. */ 1198 1199 void 1200 dump_live_info (FILE *f, tree_live_info_p live, int flag) 1201 { 1202 basic_block bb; 1203 unsigned i; 1204 var_map map = live->map; 1205 bitmap_iterator bi; 1206 1207 if ((flag & LIVEDUMP_ENTRY) && live->livein) 1208 { 1209 FOR_EACH_BB (bb) 1210 { 1211 fprintf (f, "\nLive on entry to BB%d : ", bb->index); 1212 EXECUTE_IF_SET_IN_BITMAP (live->livein[bb->index], 0, i, bi) 1213 { 1214 print_generic_expr (f, partition_to_var (map, i), TDF_SLIM); 1215 fprintf (f, " "); 1216 } 1217 fprintf (f, "\n"); 1218 } 1219 } 1220 1221 if ((flag & LIVEDUMP_EXIT) && live->liveout) 1222 { 1223 FOR_EACH_BB (bb) 1224 { 1225 fprintf (f, "\nLive on exit from BB%d : ", bb->index); 1226 EXECUTE_IF_SET_IN_BITMAP (live->liveout[bb->index], 0, i, bi) 1227 { 1228 print_generic_expr (f, partition_to_var (map, i), TDF_SLIM); 1229 fprintf (f, " "); 1230 } 1231 fprintf (f, "\n"); 1232 } 1233 } 1234 } 1235 1236 struct GTY(()) numbered_tree_d 1237 { 1238 tree t; 1239 int num; 1240 }; 1241 typedef struct numbered_tree_d numbered_tree; 1242 1243 DEF_VEC_O (numbered_tree); 1244 DEF_VEC_ALLOC_O (numbered_tree, heap); 1245 1246 /* Compare two declarations references by their DECL_UID / sequence number. 1247 Called via qsort. */ 1248 1249 static int 1250 compare_decls_by_uid (const void *pa, const void *pb) 1251 { 1252 const numbered_tree *nt_a = ((const numbered_tree *)pa); 1253 const numbered_tree *nt_b = ((const numbered_tree *)pb); 1254 1255 if (DECL_UID (nt_a->t) != DECL_UID (nt_b->t)) 1256 return DECL_UID (nt_a->t) - DECL_UID (nt_b->t); 1257 return nt_a->num - nt_b->num; 1258 } 1259 1260 /* Called via walk_gimple_stmt / walk_gimple_op by dump_enumerated_decls. */ 1261 static tree 1262 dump_enumerated_decls_push (tree *tp, int *walk_subtrees, void *data) 1263 { 1264 struct walk_stmt_info *wi = (struct walk_stmt_info *) data; 1265 VEC (numbered_tree, heap) **list = (VEC (numbered_tree, heap) **) &wi->info; 1266 numbered_tree nt; 1267 1268 if (!DECL_P (*tp)) 1269 return NULL_TREE; 1270 nt.t = *tp; 1271 nt.num = VEC_length (numbered_tree, *list); 1272 VEC_safe_push (numbered_tree, heap, *list, &nt); 1273 *walk_subtrees = 0; 1274 return NULL_TREE; 1275 } 1276 1277 /* Find all the declarations used by the current function, sort them by uid, 1278 and emit the sorted list. Each declaration is tagged with a sequence 1279 number indicating when it was found during statement / tree walking, 1280 so that TDF_NOUID comparisons of anonymous declarations are still 1281 meaningful. Where a declaration was encountered more than once, we 1282 emit only the sequence number of the first encounter. 1283 FILE is the dump file where to output the list and FLAGS is as in 1284 print_generic_expr. */ 1285 void 1286 dump_enumerated_decls (FILE *file, int flags) 1287 { 1288 basic_block bb; 1289 struct walk_stmt_info wi; 1290 VEC (numbered_tree, heap) *decl_list = VEC_alloc (numbered_tree, heap, 40); 1291 1292 memset (&wi, '\0', sizeof (wi)); 1293 wi.info = (void*) decl_list; 1294 FOR_EACH_BB (bb) 1295 { 1296 gimple_stmt_iterator gsi; 1297 1298 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) 1299 if (!is_gimple_debug (gsi_stmt (gsi))) 1300 walk_gimple_stmt (&gsi, NULL, dump_enumerated_decls_push, &wi); 1301 } 1302 decl_list = (VEC (numbered_tree, heap) *) wi.info; 1303 VEC_qsort (numbered_tree, decl_list, compare_decls_by_uid); 1304 if (VEC_length (numbered_tree, decl_list)) 1305 { 1306 unsigned ix; 1307 numbered_tree *ntp; 1308 tree last = NULL_TREE; 1309 1310 fprintf (file, "Declarations used by %s, sorted by DECL_UID:\n", 1311 current_function_name ()); 1312 FOR_EACH_VEC_ELT (numbered_tree, decl_list, ix, ntp) 1313 { 1314 if (ntp->t == last) 1315 continue; 1316 fprintf (file, "%d: ", ntp->num); 1317 print_generic_decl (file, ntp->t, flags); 1318 fprintf (file, "\n"); 1319 last = ntp->t; 1320 } 1321 } 1322 VEC_free (numbered_tree, heap, decl_list); 1323 } 1324 1325 #ifdef ENABLE_CHECKING 1326 /* Verify that SSA_VAR is a non-virtual SSA_NAME. */ 1327 1328 void 1329 register_ssa_partition_check (tree ssa_var) 1330 { 1331 gcc_assert (TREE_CODE (ssa_var) == SSA_NAME); 1332 if (!is_gimple_reg (SSA_NAME_VAR (ssa_var))) 1333 { 1334 fprintf (stderr, "Illegally registering a virtual SSA name :"); 1335 print_generic_expr (stderr, ssa_var, TDF_SLIM); 1336 fprintf (stderr, " in the SSA->Normal phase.\n"); 1337 internal_error ("SSA corruption"); 1338 } 1339 } 1340 1341 1342 /* Verify that the info in LIVE matches the current cfg. */ 1343 1344 static void 1345 verify_live_on_entry (tree_live_info_p live) 1346 { 1347 unsigned i; 1348 tree var; 1349 gimple stmt; 1350 basic_block bb; 1351 edge e; 1352 int num; 1353 edge_iterator ei; 1354 var_map map = live->map; 1355 1356 /* Check for live on entry partitions and report those with a DEF in 1357 the program. This will typically mean an optimization has done 1358 something wrong. */ 1359 bb = ENTRY_BLOCK_PTR; 1360 num = 0; 1361 FOR_EACH_EDGE (e, ei, bb->succs) 1362 { 1363 int entry_block = e->dest->index; 1364 if (e->dest == EXIT_BLOCK_PTR) 1365 continue; 1366 for (i = 0; i < (unsigned)num_var_partitions (map); i++) 1367 { 1368 basic_block tmp; 1369 tree d; 1370 bitmap loe; 1371 var = partition_to_var (map, i); 1372 stmt = SSA_NAME_DEF_STMT (var); 1373 tmp = gimple_bb (stmt); 1374 d = gimple_default_def (cfun, SSA_NAME_VAR (var)); 1375 1376 loe = live_on_entry (live, e->dest); 1377 if (loe && bitmap_bit_p (loe, i)) 1378 { 1379 if (!gimple_nop_p (stmt)) 1380 { 1381 num++; 1382 print_generic_expr (stderr, var, TDF_SLIM); 1383 fprintf (stderr, " is defined "); 1384 if (tmp) 1385 fprintf (stderr, " in BB%d, ", tmp->index); 1386 fprintf (stderr, "by:\n"); 1387 print_gimple_stmt (stderr, stmt, 0, TDF_SLIM); 1388 fprintf (stderr, "\nIt is also live-on-entry to entry BB %d", 1389 entry_block); 1390 fprintf (stderr, " So it appears to have multiple defs.\n"); 1391 } 1392 else 1393 { 1394 if (d != var) 1395 { 1396 num++; 1397 print_generic_expr (stderr, var, TDF_SLIM); 1398 fprintf (stderr, " is live-on-entry to BB%d ", 1399 entry_block); 1400 if (d) 1401 { 1402 fprintf (stderr, " but is not the default def of "); 1403 print_generic_expr (stderr, d, TDF_SLIM); 1404 fprintf (stderr, "\n"); 1405 } 1406 else 1407 fprintf (stderr, " and there is no default def.\n"); 1408 } 1409 } 1410 } 1411 else 1412 if (d == var) 1413 { 1414 /* The only way this var shouldn't be marked live on entry is 1415 if it occurs in a PHI argument of the block. */ 1416 size_t z; 1417 bool ok = false; 1418 gimple_stmt_iterator gsi; 1419 for (gsi = gsi_start_phis (e->dest); 1420 !gsi_end_p (gsi) && !ok; 1421 gsi_next (&gsi)) 1422 { 1423 gimple phi = gsi_stmt (gsi); 1424 for (z = 0; z < gimple_phi_num_args (phi); z++) 1425 if (var == gimple_phi_arg_def (phi, z)) 1426 { 1427 ok = true; 1428 break; 1429 } 1430 } 1431 if (ok) 1432 continue; 1433 num++; 1434 print_generic_expr (stderr, var, TDF_SLIM); 1435 fprintf (stderr, " is not marked live-on-entry to entry BB%d ", 1436 entry_block); 1437 fprintf (stderr, "but it is a default def so it should be.\n"); 1438 } 1439 } 1440 } 1441 gcc_assert (num <= 0); 1442 } 1443 #endif 1444