1 /* Miscellaneous SSA utility functions. 2 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009 3 Free Software Foundation, Inc. 4 5 This file is part of GCC. 6 7 GCC is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3, or (at your option) 10 any later version. 11 12 GCC is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with GCC; see the file COPYING3. If not see 19 <http://www.gnu.org/licenses/>. */ 20 21 #include "config.h" 22 #include "system.h" 23 #include "coretypes.h" 24 #include "tm.h" 25 #include "tree.h" 26 #include "flags.h" 27 #include "rtl.h" 28 #include "tm_p.h" 29 #include "target.h" 30 #include "ggc.h" 31 #include "langhooks.h" 32 #include "hard-reg-set.h" 33 #include "basic-block.h" 34 #include "output.h" 35 #include "expr.h" 36 #include "function.h" 37 #include "diagnostic.h" 38 #include "bitmap.h" 39 #include "pointer-set.h" 40 #include "tree-flow.h" 41 #include "gimple.h" 42 #include "tree-inline.h" 43 #include "varray.h" 44 #include "timevar.h" 45 #include "hashtab.h" 46 #include "tree-dump.h" 47 #include "tree-pass.h" 48 #include "toplev.h" 49 50 /* Pointer map of variable mappings, keyed by edge. */ 51 static struct pointer_map_t *edge_var_maps; 52 53 54 /* Add a mapping with PHI RESULT and PHI DEF associated with edge E. */ 55 56 void 57 redirect_edge_var_map_add (edge e, tree result, tree def, source_location locus) 58 { 59 void **slot; 60 edge_var_map_vector old_head, head; 61 edge_var_map new_node; 62 63 if (edge_var_maps == NULL) 64 edge_var_maps = pointer_map_create (); 65 66 slot = pointer_map_insert (edge_var_maps, e); 67 old_head = head = (edge_var_map_vector) *slot; 68 if (!head) 69 { 70 head = VEC_alloc (edge_var_map, heap, 5); 71 *slot = head; 72 } 73 new_node.def = def; 74 new_node.result = result; 75 new_node.locus = locus; 76 77 VEC_safe_push (edge_var_map, heap, head, &new_node); 78 if (old_head != head) 79 { 80 /* The push did some reallocation. Update the pointer map. */ 81 *slot = head; 82 } 83 } 84 85 86 /* Clear the var mappings in edge E. */ 87 88 void 89 redirect_edge_var_map_clear (edge e) 90 { 91 void **slot; 92 edge_var_map_vector head; 93 94 if (!edge_var_maps) 95 return; 96 97 slot = pointer_map_contains (edge_var_maps, e); 98 99 if (slot) 100 { 101 head = (edge_var_map_vector) *slot; 102 VEC_free (edge_var_map, heap, head); 103 *slot = NULL; 104 } 105 } 106 107 108 /* Duplicate the redirected var mappings in OLDE in NEWE. 109 110 Since we can't remove a mapping, let's just duplicate it. This assumes a 111 pointer_map can have multiple edges mapping to the same var_map (many to 112 one mapping), since we don't remove the previous mappings. */ 113 114 void 115 redirect_edge_var_map_dup (edge newe, edge olde) 116 { 117 void **new_slot, **old_slot; 118 edge_var_map_vector head; 119 120 if (!edge_var_maps) 121 return; 122 123 new_slot = pointer_map_insert (edge_var_maps, newe); 124 old_slot = pointer_map_contains (edge_var_maps, olde); 125 if (!old_slot) 126 return; 127 head = (edge_var_map_vector) *old_slot; 128 129 if (head) 130 *new_slot = VEC_copy (edge_var_map, heap, head); 131 else 132 *new_slot = VEC_alloc (edge_var_map, heap, 5); 133 } 134 135 136 /* Return the variable mappings for a given edge. If there is none, return 137 NULL. */ 138 139 edge_var_map_vector 140 redirect_edge_var_map_vector (edge e) 141 { 142 void **slot; 143 144 /* Hey, what kind of idiot would... you'd be surprised. */ 145 if (!edge_var_maps) 146 return NULL; 147 148 slot = pointer_map_contains (edge_var_maps, e); 149 if (!slot) 150 return NULL; 151 152 return (edge_var_map_vector) *slot; 153 } 154 155 /* Used by redirect_edge_var_map_destroy to free all memory. */ 156 157 static bool 158 free_var_map_entry (const void *key ATTRIBUTE_UNUSED, 159 void **value, 160 void *data ATTRIBUTE_UNUSED) 161 { 162 edge_var_map_vector head = (edge_var_map_vector) *value; 163 VEC_free (edge_var_map, heap, head); 164 return true; 165 } 166 167 /* Clear the edge variable mappings. */ 168 169 void 170 redirect_edge_var_map_destroy (void) 171 { 172 if (edge_var_maps) 173 { 174 pointer_map_traverse (edge_var_maps, free_var_map_entry, NULL); 175 pointer_map_destroy (edge_var_maps); 176 edge_var_maps = NULL; 177 } 178 } 179 180 181 /* Remove the corresponding arguments from the PHI nodes in E's 182 destination block and redirect it to DEST. Return redirected edge. 183 The list of removed arguments is stored in a vector accessed 184 through edge_var_maps. */ 185 186 edge 187 ssa_redirect_edge (edge e, basic_block dest) 188 { 189 gimple_stmt_iterator gsi; 190 gimple phi; 191 192 redirect_edge_var_map_clear (e); 193 194 /* Remove the appropriate PHI arguments in E's destination block. */ 195 for (gsi = gsi_start_phis (e->dest); !gsi_end_p (gsi); gsi_next (&gsi)) 196 { 197 tree def; 198 source_location locus ; 199 200 phi = gsi_stmt (gsi); 201 def = gimple_phi_arg_def (phi, e->dest_idx); 202 locus = gimple_phi_arg_location (phi, e->dest_idx); 203 204 if (def == NULL_TREE) 205 continue; 206 207 redirect_edge_var_map_add (e, gimple_phi_result (phi), def, locus); 208 } 209 210 e = redirect_edge_succ_nodup (e, dest); 211 212 return e; 213 } 214 215 216 /* Add PHI arguments queued in PENDING_STMT list on edge E to edge 217 E->dest. */ 218 219 void 220 flush_pending_stmts (edge e) 221 { 222 gimple phi; 223 edge_var_map_vector v; 224 edge_var_map *vm; 225 int i; 226 gimple_stmt_iterator gsi; 227 228 v = redirect_edge_var_map_vector (e); 229 if (!v) 230 return; 231 232 for (gsi = gsi_start_phis (e->dest), i = 0; 233 !gsi_end_p (gsi) && VEC_iterate (edge_var_map, v, i, vm); 234 gsi_next (&gsi), i++) 235 { 236 tree def; 237 238 phi = gsi_stmt (gsi); 239 def = redirect_edge_var_map_def (vm); 240 add_phi_arg (phi, def, e, redirect_edge_var_map_location (vm)); 241 } 242 243 redirect_edge_var_map_clear (e); 244 } 245 246 /* Given a tree for an expression for which we might want to emit 247 locations or values in debug information (generally a variable, but 248 we might deal with other kinds of trees in the future), return the 249 tree that should be used as the variable of a DEBUG_BIND STMT or 250 VAR_LOCATION INSN or NOTE. Return NULL if VAR is not to be tracked. */ 251 252 tree 253 target_for_debug_bind (tree var) 254 { 255 if (!MAY_HAVE_DEBUG_STMTS) 256 return NULL_TREE; 257 258 if (TREE_CODE (var) != VAR_DECL 259 && TREE_CODE (var) != PARM_DECL) 260 return NULL_TREE; 261 262 if (DECL_HAS_VALUE_EXPR_P (var)) 263 return target_for_debug_bind (DECL_VALUE_EXPR (var)); 264 265 if (DECL_IGNORED_P (var)) 266 return NULL_TREE; 267 268 if (!is_gimple_reg (var)) 269 return NULL_TREE; 270 271 return var; 272 } 273 274 /* Called via walk_tree, look for SSA_NAMEs that have already been 275 released. */ 276 277 static tree 278 find_released_ssa_name (tree *tp, int *walk_subtrees, void *data_) 279 { 280 struct walk_stmt_info *wi = (struct walk_stmt_info *) data_; 281 282 if (wi && wi->is_lhs) 283 return NULL_TREE; 284 285 if (TREE_CODE (*tp) == SSA_NAME) 286 { 287 if (SSA_NAME_IN_FREE_LIST (*tp)) 288 return *tp; 289 290 *walk_subtrees = 0; 291 } 292 else if (IS_TYPE_OR_DECL_P (*tp)) 293 *walk_subtrees = 0; 294 295 return NULL_TREE; 296 } 297 298 /* Insert a DEBUG BIND stmt before the DEF of VAR if VAR is referenced 299 by other DEBUG stmts, and replace uses of the DEF with the 300 newly-created debug temp. */ 301 302 void 303 insert_debug_temp_for_var_def (gimple_stmt_iterator *gsi, tree var) 304 { 305 imm_use_iterator imm_iter; 306 use_operand_p use_p; 307 gimple stmt; 308 gimple def_stmt = NULL; 309 int usecount = 0; 310 tree value = NULL; 311 312 if (!MAY_HAVE_DEBUG_STMTS) 313 return; 314 315 /* If this name has already been registered for replacement, do nothing 316 as anything that uses this name isn't in SSA form. */ 317 if (name_registered_for_update_p (var)) 318 return; 319 320 /* Check whether there are debug stmts that reference this variable and, 321 if there are, decide whether we should use a debug temp. */ 322 FOR_EACH_IMM_USE_FAST (use_p, imm_iter, var) 323 { 324 stmt = USE_STMT (use_p); 325 326 if (!gimple_debug_bind_p (stmt)) 327 continue; 328 329 if (usecount++) 330 break; 331 332 if (gimple_debug_bind_get_value (stmt) != var) 333 { 334 /* Count this as an additional use, so as to make sure we 335 use a temp unless VAR's definition has a SINGLE_RHS that 336 can be shared. */ 337 usecount++; 338 break; 339 } 340 } 341 342 if (!usecount) 343 return; 344 345 if (gsi) 346 def_stmt = gsi_stmt (*gsi); 347 else 348 def_stmt = SSA_NAME_DEF_STMT (var); 349 350 /* If we didn't get an insertion point, and the stmt has already 351 been removed, we won't be able to insert the debug bind stmt, so 352 we'll have to drop debug information. */ 353 if (gimple_code (def_stmt) == GIMPLE_PHI) 354 { 355 value = degenerate_phi_result (def_stmt); 356 if (value && walk_tree (&value, find_released_ssa_name, NULL, NULL)) 357 value = NULL; 358 } 359 else if (is_gimple_assign (def_stmt)) 360 { 361 bool no_value = false; 362 363 if (!dom_info_available_p (CDI_DOMINATORS)) 364 { 365 struct walk_stmt_info wi; 366 367 memset (&wi, 0, sizeof (wi)); 368 369 /* When removing blocks without following reverse dominance 370 order, we may sometimes encounter SSA_NAMEs that have 371 already been released, referenced in other SSA_DEFs that 372 we're about to release. Consider: 373 374 <bb X>: 375 v_1 = foo; 376 377 <bb Y>: 378 w_2 = v_1 + bar; 379 # DEBUG w => w_2 380 381 If we deleted BB X first, propagating the value of w_2 382 won't do us any good. It's too late to recover their 383 original definition of v_1: when it was deleted, it was 384 only referenced in other DEFs, it couldn't possibly know 385 it should have been retained, and propagating every 386 single DEF just in case it might have to be propagated 387 into a DEBUG STMT would probably be too wasteful. 388 389 When dominator information is not readily available, we 390 check for and accept some loss of debug information. But 391 if it is available, there's no excuse for us to remove 392 blocks in the wrong order, so we don't even check for 393 dead SSA NAMEs. SSA verification shall catch any 394 errors. */ 395 if ((!gsi && !gimple_bb (def_stmt)) 396 || walk_gimple_op (def_stmt, find_released_ssa_name, &wi)) 397 no_value = true; 398 } 399 400 if (!no_value) 401 value = gimple_assign_rhs_to_tree (def_stmt); 402 } 403 404 if (value) 405 { 406 /* If there's a single use of VAR, and VAR is the entire debug 407 expression (usecount would have been incremented again 408 otherwise), and the definition involves only constants and 409 SSA names, then we can propagate VALUE into this single use, 410 avoiding the temp. 411 412 We can also avoid using a temp if VALUE can be shared and 413 propagated into all uses, without generating expressions that 414 wouldn't be valid gimple RHSs. 415 416 Other cases that would require unsharing or non-gimple RHSs 417 are deferred to a debug temp, although we could avoid temps 418 at the expense of duplication of expressions. */ 419 420 if (CONSTANT_CLASS_P (value) 421 || gimple_code (def_stmt) == GIMPLE_PHI 422 || (usecount == 1 423 && (!gimple_assign_single_p (def_stmt) 424 || is_gimple_min_invariant (value))) 425 || is_gimple_reg (value)) 426 value = unshare_expr (value); 427 else 428 { 429 gimple def_temp; 430 tree vexpr = make_node (DEBUG_EXPR_DECL); 431 432 def_temp = gimple_build_debug_bind (vexpr, 433 unshare_expr (value), 434 def_stmt); 435 436 DECL_ARTIFICIAL (vexpr) = 1; 437 TREE_TYPE (vexpr) = TREE_TYPE (value); 438 if (DECL_P (value)) 439 DECL_MODE (vexpr) = DECL_MODE (value); 440 else 441 DECL_MODE (vexpr) = TYPE_MODE (TREE_TYPE (value)); 442 443 if (gsi) 444 gsi_insert_before (gsi, def_temp, GSI_SAME_STMT); 445 else 446 { 447 gimple_stmt_iterator ngsi = gsi_for_stmt (def_stmt); 448 gsi_insert_before (&ngsi, def_temp, GSI_SAME_STMT); 449 } 450 451 value = vexpr; 452 } 453 } 454 455 FOR_EACH_IMM_USE_STMT (stmt, imm_iter, var) 456 { 457 if (!gimple_debug_bind_p (stmt)) 458 continue; 459 460 if (value) 461 FOR_EACH_IMM_USE_ON_STMT (use_p, imm_iter) 462 /* unshare_expr is not needed here. vexpr is either a 463 SINGLE_RHS, that can be safely shared, some other RHS 464 that was unshared when we found it had a single debug 465 use, or a DEBUG_EXPR_DECL, that can be safely 466 shared. */ 467 SET_USE (use_p, value); 468 else 469 gimple_debug_bind_reset_value (stmt); 470 471 update_stmt (stmt); 472 } 473 } 474 475 476 /* Insert a DEBUG BIND stmt before STMT for each DEF referenced by 477 other DEBUG stmts, and replace uses of the DEF with the 478 newly-created debug temp. */ 479 480 void 481 insert_debug_temps_for_defs (gimple_stmt_iterator *gsi) 482 { 483 gimple stmt; 484 ssa_op_iter op_iter; 485 def_operand_p def_p; 486 487 if (!MAY_HAVE_DEBUG_STMTS) 488 return; 489 490 stmt = gsi_stmt (*gsi); 491 492 FOR_EACH_PHI_OR_STMT_DEF (def_p, stmt, op_iter, SSA_OP_DEF) 493 { 494 tree var = DEF_FROM_PTR (def_p); 495 496 if (TREE_CODE (var) != SSA_NAME) 497 continue; 498 499 insert_debug_temp_for_var_def (gsi, var); 500 } 501 } 502 503 /* Delete SSA DEFs for SSA versions in the TOREMOVE bitmap, removing 504 dominated stmts before their dominators, so that release_ssa_defs 505 stands a chance of propagating DEFs into debug bind stmts. */ 506 507 void 508 release_defs_bitset (bitmap toremove) 509 { 510 unsigned j; 511 bitmap_iterator bi; 512 513 /* Performing a topological sort is probably overkill, this will 514 most likely run in slightly superlinear time, rather than the 515 pathological quadratic worst case. */ 516 while (!bitmap_empty_p (toremove)) 517 EXECUTE_IF_SET_IN_BITMAP (toremove, 0, j, bi) 518 { 519 bool remove_now = true; 520 tree var = ssa_name (j); 521 gimple stmt; 522 imm_use_iterator uit; 523 524 FOR_EACH_IMM_USE_STMT (stmt, uit, var) 525 { 526 ssa_op_iter dit; 527 def_operand_p def_p; 528 529 /* We can't propagate PHI nodes into debug stmts. */ 530 if (gimple_code (stmt) == GIMPLE_PHI 531 || is_gimple_debug (stmt)) 532 continue; 533 534 /* If we find another definition to remove that uses 535 the one we're looking at, defer the removal of this 536 one, so that it can be propagated into debug stmts 537 after the other is. */ 538 FOR_EACH_SSA_DEF_OPERAND (def_p, stmt, dit, SSA_OP_DEF) 539 { 540 tree odef = DEF_FROM_PTR (def_p); 541 542 if (bitmap_bit_p (toremove, SSA_NAME_VERSION (odef))) 543 { 544 remove_now = false; 545 break; 546 } 547 } 548 549 if (!remove_now) 550 BREAK_FROM_IMM_USE_STMT (uit); 551 } 552 553 if (remove_now) 554 { 555 gimple def = SSA_NAME_DEF_STMT (var); 556 gimple_stmt_iterator gsi = gsi_for_stmt (def); 557 558 if (gimple_code (def) == GIMPLE_PHI) 559 remove_phi_node (&gsi, true); 560 else 561 { 562 gsi_remove (&gsi, true); 563 release_defs (def); 564 } 565 566 bitmap_clear_bit (toremove, j); 567 } 568 } 569 } 570 571 /* Return true if SSA_NAME is malformed and mark it visited. 572 573 IS_VIRTUAL is true if this SSA_NAME was found inside a virtual 574 operand. */ 575 576 static bool 577 verify_ssa_name (tree ssa_name, bool is_virtual) 578 { 579 if (TREE_CODE (ssa_name) != SSA_NAME) 580 { 581 error ("expected an SSA_NAME object"); 582 return true; 583 } 584 585 if (TREE_TYPE (ssa_name) != TREE_TYPE (SSA_NAME_VAR (ssa_name))) 586 { 587 error ("type mismatch between an SSA_NAME and its symbol"); 588 return true; 589 } 590 591 if (SSA_NAME_IN_FREE_LIST (ssa_name)) 592 { 593 error ("found an SSA_NAME that had been released into the free pool"); 594 return true; 595 } 596 597 if (is_virtual && is_gimple_reg (ssa_name)) 598 { 599 error ("found a virtual definition for a GIMPLE register"); 600 return true; 601 } 602 603 if (is_virtual && SSA_NAME_VAR (ssa_name) != gimple_vop (cfun)) 604 { 605 error ("virtual SSA name for non-VOP decl"); 606 return true; 607 } 608 609 if (!is_virtual && !is_gimple_reg (ssa_name)) 610 { 611 error ("found a real definition for a non-register"); 612 return true; 613 } 614 615 if (SSA_NAME_IS_DEFAULT_DEF (ssa_name) 616 && !gimple_nop_p (SSA_NAME_DEF_STMT (ssa_name))) 617 { 618 error ("found a default name with a non-empty defining statement"); 619 return true; 620 } 621 622 return false; 623 } 624 625 626 /* Return true if the definition of SSA_NAME at block BB is malformed. 627 628 STMT is the statement where SSA_NAME is created. 629 630 DEFINITION_BLOCK is an array of basic blocks indexed by SSA_NAME 631 version numbers. If DEFINITION_BLOCK[SSA_NAME_VERSION] is set, 632 it means that the block in that array slot contains the 633 definition of SSA_NAME. 634 635 IS_VIRTUAL is true if SSA_NAME is created by a VDEF. */ 636 637 static bool 638 verify_def (basic_block bb, basic_block *definition_block, tree ssa_name, 639 gimple stmt, bool is_virtual) 640 { 641 if (verify_ssa_name (ssa_name, is_virtual)) 642 goto err; 643 644 if (definition_block[SSA_NAME_VERSION (ssa_name)]) 645 { 646 error ("SSA_NAME created in two different blocks %i and %i", 647 definition_block[SSA_NAME_VERSION (ssa_name)]->index, bb->index); 648 goto err; 649 } 650 651 definition_block[SSA_NAME_VERSION (ssa_name)] = bb; 652 653 if (SSA_NAME_DEF_STMT (ssa_name) != stmt) 654 { 655 error ("SSA_NAME_DEF_STMT is wrong"); 656 fprintf (stderr, "Expected definition statement:\n"); 657 print_gimple_stmt (stderr, SSA_NAME_DEF_STMT (ssa_name), 4, TDF_VOPS); 658 fprintf (stderr, "\nActual definition statement:\n"); 659 print_gimple_stmt (stderr, stmt, 4, TDF_VOPS); 660 goto err; 661 } 662 663 return false; 664 665 err: 666 fprintf (stderr, "while verifying SSA_NAME "); 667 print_generic_expr (stderr, ssa_name, 0); 668 fprintf (stderr, " in statement\n"); 669 print_gimple_stmt (stderr, stmt, 4, TDF_VOPS); 670 671 return true; 672 } 673 674 675 /* Return true if the use of SSA_NAME at statement STMT in block BB is 676 malformed. 677 678 DEF_BB is the block where SSA_NAME was found to be created. 679 680 IDOM contains immediate dominator information for the flowgraph. 681 682 CHECK_ABNORMAL is true if the caller wants to check whether this use 683 is flowing through an abnormal edge (only used when checking PHI 684 arguments). 685 686 If NAMES_DEFINED_IN_BB is not NULL, it contains a bitmap of ssa names 687 that are defined before STMT in basic block BB. */ 688 689 static bool 690 verify_use (basic_block bb, basic_block def_bb, use_operand_p use_p, 691 gimple stmt, bool check_abnormal, bitmap names_defined_in_bb) 692 { 693 bool err = false; 694 tree ssa_name = USE_FROM_PTR (use_p); 695 696 if (!TREE_VISITED (ssa_name)) 697 if (verify_imm_links (stderr, ssa_name)) 698 err = true; 699 700 TREE_VISITED (ssa_name) = 1; 701 702 if (gimple_nop_p (SSA_NAME_DEF_STMT (ssa_name)) 703 && SSA_NAME_IS_DEFAULT_DEF (ssa_name)) 704 ; /* Default definitions have empty statements. Nothing to do. */ 705 else if (!def_bb) 706 { 707 error ("missing definition"); 708 err = true; 709 } 710 else if (bb != def_bb 711 && !dominated_by_p (CDI_DOMINATORS, bb, def_bb)) 712 { 713 error ("definition in block %i does not dominate use in block %i", 714 def_bb->index, bb->index); 715 err = true; 716 } 717 else if (bb == def_bb 718 && names_defined_in_bb != NULL 719 && !bitmap_bit_p (names_defined_in_bb, SSA_NAME_VERSION (ssa_name))) 720 { 721 error ("definition in block %i follows the use", def_bb->index); 722 err = true; 723 } 724 725 if (check_abnormal 726 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ssa_name)) 727 { 728 error ("SSA_NAME_OCCURS_IN_ABNORMAL_PHI should be set"); 729 err = true; 730 } 731 732 /* Make sure the use is in an appropriate list by checking the previous 733 element to make sure it's the same. */ 734 if (use_p->prev == NULL) 735 { 736 error ("no immediate_use list"); 737 err = true; 738 } 739 else 740 { 741 tree listvar; 742 if (use_p->prev->use == NULL) 743 listvar = use_p->prev->loc.ssa_name; 744 else 745 listvar = USE_FROM_PTR (use_p->prev); 746 if (listvar != ssa_name) 747 { 748 error ("wrong immediate use list"); 749 err = true; 750 } 751 } 752 753 if (err) 754 { 755 fprintf (stderr, "for SSA_NAME: "); 756 print_generic_expr (stderr, ssa_name, TDF_VOPS); 757 fprintf (stderr, " in statement:\n"); 758 print_gimple_stmt (stderr, stmt, 0, TDF_VOPS); 759 } 760 761 return err; 762 } 763 764 765 /* Return true if any of the arguments for PHI node PHI at block BB is 766 malformed. 767 768 DEFINITION_BLOCK is an array of basic blocks indexed by SSA_NAME 769 version numbers. If DEFINITION_BLOCK[SSA_NAME_VERSION] is set, 770 it means that the block in that array slot contains the 771 definition of SSA_NAME. */ 772 773 static bool 774 verify_phi_args (gimple phi, basic_block bb, basic_block *definition_block) 775 { 776 edge e; 777 bool err = false; 778 size_t i, phi_num_args = gimple_phi_num_args (phi); 779 780 if (EDGE_COUNT (bb->preds) != phi_num_args) 781 { 782 error ("incoming edge count does not match number of PHI arguments"); 783 err = true; 784 goto error; 785 } 786 787 for (i = 0; i < phi_num_args; i++) 788 { 789 use_operand_p op_p = gimple_phi_arg_imm_use_ptr (phi, i); 790 tree op = USE_FROM_PTR (op_p); 791 792 e = EDGE_PRED (bb, i); 793 794 if (op == NULL_TREE) 795 { 796 error ("PHI argument is missing for edge %d->%d", 797 e->src->index, 798 e->dest->index); 799 err = true; 800 goto error; 801 } 802 803 if (TREE_CODE (op) != SSA_NAME && !is_gimple_min_invariant (op)) 804 { 805 error ("PHI argument is not SSA_NAME, or invariant"); 806 err = true; 807 } 808 809 if (TREE_CODE (op) == SSA_NAME) 810 { 811 err = verify_ssa_name (op, !is_gimple_reg (gimple_phi_result (phi))); 812 err |= verify_use (e->src, definition_block[SSA_NAME_VERSION (op)], 813 op_p, phi, e->flags & EDGE_ABNORMAL, NULL); 814 } 815 816 if (TREE_CODE (op) == ADDR_EXPR) 817 { 818 tree base = TREE_OPERAND (op, 0); 819 while (handled_component_p (base)) 820 base = TREE_OPERAND (base, 0); 821 if ((TREE_CODE (base) == VAR_DECL 822 || TREE_CODE (base) == PARM_DECL 823 || TREE_CODE (base) == RESULT_DECL) 824 && !TREE_ADDRESSABLE (base)) 825 { 826 error ("address taken, but ADDRESSABLE bit not set"); 827 err = true; 828 } 829 } 830 831 if (e->dest != bb) 832 { 833 error ("wrong edge %d->%d for PHI argument", 834 e->src->index, e->dest->index); 835 err = true; 836 } 837 838 if (err) 839 { 840 fprintf (stderr, "PHI argument\n"); 841 print_generic_stmt (stderr, op, TDF_VOPS); 842 goto error; 843 } 844 } 845 846 error: 847 if (err) 848 { 849 fprintf (stderr, "for PHI node\n"); 850 print_gimple_stmt (stderr, phi, 0, TDF_VOPS|TDF_MEMSYMS); 851 } 852 853 854 return err; 855 } 856 857 858 /* Verify common invariants in the SSA web. 859 TODO: verify the variable annotations. */ 860 861 void 862 verify_ssa (bool check_modified_stmt) 863 { 864 size_t i; 865 basic_block bb; 866 basic_block *definition_block = XCNEWVEC (basic_block, num_ssa_names); 867 ssa_op_iter iter; 868 tree op; 869 enum dom_state orig_dom_state = dom_info_state (CDI_DOMINATORS); 870 bitmap names_defined_in_bb = BITMAP_ALLOC (NULL); 871 872 gcc_assert (!need_ssa_update_p (cfun)); 873 874 verify_stmts (); 875 876 timevar_push (TV_TREE_SSA_VERIFY); 877 878 /* Keep track of SSA names present in the IL. */ 879 for (i = 1; i < num_ssa_names; i++) 880 { 881 tree name = ssa_name (i); 882 if (name) 883 { 884 gimple stmt; 885 TREE_VISITED (name) = 0; 886 887 stmt = SSA_NAME_DEF_STMT (name); 888 if (!gimple_nop_p (stmt)) 889 { 890 basic_block bb = gimple_bb (stmt); 891 verify_def (bb, definition_block, 892 name, stmt, !is_gimple_reg (name)); 893 894 } 895 } 896 } 897 898 calculate_dominance_info (CDI_DOMINATORS); 899 900 /* Now verify all the uses and make sure they agree with the definitions 901 found in the previous pass. */ 902 FOR_EACH_BB (bb) 903 { 904 edge e; 905 gimple phi; 906 edge_iterator ei; 907 gimple_stmt_iterator gsi; 908 909 /* Make sure that all edges have a clear 'aux' field. */ 910 FOR_EACH_EDGE (e, ei, bb->preds) 911 { 912 if (e->aux) 913 { 914 error ("AUX pointer initialized for edge %d->%d", e->src->index, 915 e->dest->index); 916 goto err; 917 } 918 } 919 920 /* Verify the arguments for every PHI node in the block. */ 921 for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi)) 922 { 923 phi = gsi_stmt (gsi); 924 if (verify_phi_args (phi, bb, definition_block)) 925 goto err; 926 927 bitmap_set_bit (names_defined_in_bb, 928 SSA_NAME_VERSION (gimple_phi_result (phi))); 929 } 930 931 /* Now verify all the uses and vuses in every statement of the block. */ 932 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) 933 { 934 gimple stmt = gsi_stmt (gsi); 935 use_operand_p use_p; 936 bool has_err; 937 938 if (check_modified_stmt && gimple_modified_p (stmt)) 939 { 940 error ("stmt (%p) marked modified after optimization pass: ", 941 (void *)stmt); 942 print_gimple_stmt (stderr, stmt, 0, TDF_VOPS); 943 goto err; 944 } 945 946 if (is_gimple_assign (stmt) 947 && TREE_CODE (gimple_assign_lhs (stmt)) != SSA_NAME) 948 { 949 tree lhs, base_address; 950 951 lhs = gimple_assign_lhs (stmt); 952 base_address = get_base_address (lhs); 953 954 if (base_address 955 && SSA_VAR_P (base_address) 956 && !gimple_vdef (stmt) 957 && optimize > 0) 958 { 959 error ("statement makes a memory store, but has no VDEFS"); 960 print_gimple_stmt (stderr, stmt, 0, TDF_VOPS); 961 goto err; 962 } 963 } 964 else if (gimple_debug_bind_p (stmt) 965 && !gimple_debug_bind_has_value_p (stmt)) 966 continue; 967 968 /* Verify the single virtual operand and its constraints. */ 969 has_err = false; 970 if (gimple_vdef (stmt)) 971 { 972 if (gimple_vdef_op (stmt) == NULL_DEF_OPERAND_P) 973 { 974 error ("statement has VDEF operand not in defs list"); 975 has_err = true; 976 } 977 if (!gimple_vuse (stmt)) 978 { 979 error ("statement has VDEF but no VUSE operand"); 980 has_err = true; 981 } 982 else if (SSA_NAME_VAR (gimple_vdef (stmt)) 983 != SSA_NAME_VAR (gimple_vuse (stmt))) 984 { 985 error ("VDEF and VUSE do not use the same symbol"); 986 has_err = true; 987 } 988 has_err |= verify_ssa_name (gimple_vdef (stmt), true); 989 } 990 if (gimple_vuse (stmt)) 991 { 992 if (gimple_vuse_op (stmt) == NULL_USE_OPERAND_P) 993 { 994 error ("statement has VUSE operand not in uses list"); 995 has_err = true; 996 } 997 has_err |= verify_ssa_name (gimple_vuse (stmt), true); 998 } 999 if (has_err) 1000 { 1001 error ("in statement"); 1002 print_gimple_stmt (stderr, stmt, 0, TDF_VOPS|TDF_MEMSYMS); 1003 goto err; 1004 } 1005 1006 FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_USE|SSA_OP_DEF) 1007 { 1008 if (verify_ssa_name (op, false)) 1009 { 1010 error ("in statement"); 1011 print_gimple_stmt (stderr, stmt, 0, TDF_VOPS|TDF_MEMSYMS); 1012 goto err; 1013 } 1014 } 1015 1016 FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_USE|SSA_OP_VUSE) 1017 { 1018 op = USE_FROM_PTR (use_p); 1019 if (verify_use (bb, definition_block[SSA_NAME_VERSION (op)], 1020 use_p, stmt, false, names_defined_in_bb)) 1021 goto err; 1022 } 1023 1024 FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_ALL_DEFS) 1025 { 1026 if (SSA_NAME_DEF_STMT (op) != stmt) 1027 { 1028 error ("SSA_NAME_DEF_STMT is wrong"); 1029 fprintf (stderr, "Expected definition statement:\n"); 1030 print_gimple_stmt (stderr, stmt, 4, TDF_VOPS); 1031 fprintf (stderr, "\nActual definition statement:\n"); 1032 print_gimple_stmt (stderr, SSA_NAME_DEF_STMT (op), 1033 4, TDF_VOPS); 1034 goto err; 1035 } 1036 bitmap_set_bit (names_defined_in_bb, SSA_NAME_VERSION (op)); 1037 } 1038 } 1039 1040 bitmap_clear (names_defined_in_bb); 1041 } 1042 1043 free (definition_block); 1044 1045 /* Restore the dominance information to its prior known state, so 1046 that we do not perturb the compiler's subsequent behavior. */ 1047 if (orig_dom_state == DOM_NONE) 1048 free_dominance_info (CDI_DOMINATORS); 1049 else 1050 set_dom_info_availability (CDI_DOMINATORS, orig_dom_state); 1051 1052 BITMAP_FREE (names_defined_in_bb); 1053 timevar_pop (TV_TREE_SSA_VERIFY); 1054 return; 1055 1056 err: 1057 internal_error ("verify_ssa failed"); 1058 } 1059 1060 /* Return true if the uid in both int tree maps are equal. */ 1061 1062 int 1063 int_tree_map_eq (const void *va, const void *vb) 1064 { 1065 const struct int_tree_map *a = (const struct int_tree_map *) va; 1066 const struct int_tree_map *b = (const struct int_tree_map *) vb; 1067 return (a->uid == b->uid); 1068 } 1069 1070 /* Hash a UID in a int_tree_map. */ 1071 1072 unsigned int 1073 int_tree_map_hash (const void *item) 1074 { 1075 return ((const struct int_tree_map *)item)->uid; 1076 } 1077 1078 /* Return true if the DECL_UID in both trees are equal. */ 1079 1080 int 1081 uid_decl_map_eq (const void *va, const void *vb) 1082 { 1083 const_tree a = (const_tree) va; 1084 const_tree b = (const_tree) vb; 1085 return (a->decl_minimal.uid == b->decl_minimal.uid); 1086 } 1087 1088 /* Hash a tree in a uid_decl_map. */ 1089 1090 unsigned int 1091 uid_decl_map_hash (const void *item) 1092 { 1093 return ((const_tree)item)->decl_minimal.uid; 1094 } 1095 1096 /* Return true if the DECL_UID in both trees are equal. */ 1097 1098 static int 1099 uid_ssaname_map_eq (const void *va, const void *vb) 1100 { 1101 const_tree a = (const_tree) va; 1102 const_tree b = (const_tree) vb; 1103 return (a->ssa_name.var->decl_minimal.uid == b->ssa_name.var->decl_minimal.uid); 1104 } 1105 1106 /* Hash a tree in a uid_decl_map. */ 1107 1108 static unsigned int 1109 uid_ssaname_map_hash (const void *item) 1110 { 1111 return ((const_tree)item)->ssa_name.var->decl_minimal.uid; 1112 } 1113 1114 1115 /* Initialize global DFA and SSA structures. */ 1116 1117 void 1118 init_tree_ssa (struct function *fn) 1119 { 1120 fn->gimple_df = GGC_CNEW (struct gimple_df); 1121 fn->gimple_df->referenced_vars = htab_create_ggc (20, uid_decl_map_hash, 1122 uid_decl_map_eq, NULL); 1123 fn->gimple_df->default_defs = htab_create_ggc (20, uid_ssaname_map_hash, 1124 uid_ssaname_map_eq, NULL); 1125 pt_solution_reset (&fn->gimple_df->escaped); 1126 pt_solution_reset (&fn->gimple_df->callused); 1127 init_ssanames (fn, 0); 1128 init_phinodes (); 1129 } 1130 1131 1132 /* Deallocate memory associated with SSA data structures for FNDECL. */ 1133 1134 void 1135 delete_tree_ssa (void) 1136 { 1137 referenced_var_iterator rvi; 1138 tree var; 1139 1140 /* Remove annotations from every referenced local variable. */ 1141 FOR_EACH_REFERENCED_VAR (var, rvi) 1142 { 1143 if (is_global_var (var)) 1144 continue; 1145 if (var_ann (var)) 1146 { 1147 ggc_free (var_ann (var)); 1148 *DECL_VAR_ANN_PTR (var) = NULL; 1149 } 1150 } 1151 htab_delete (gimple_referenced_vars (cfun)); 1152 cfun->gimple_df->referenced_vars = NULL; 1153 1154 fini_ssanames (); 1155 fini_phinodes (); 1156 1157 /* We no longer maintain the SSA operand cache at this point. */ 1158 if (ssa_operands_active ()) 1159 fini_ssa_operands (); 1160 1161 delete_alias_heapvars (); 1162 1163 htab_delete (cfun->gimple_df->default_defs); 1164 cfun->gimple_df->default_defs = NULL; 1165 pt_solution_reset (&cfun->gimple_df->escaped); 1166 pt_solution_reset (&cfun->gimple_df->callused); 1167 if (cfun->gimple_df->decls_to_pointers != NULL) 1168 pointer_map_destroy (cfun->gimple_df->decls_to_pointers); 1169 cfun->gimple_df->decls_to_pointers = NULL; 1170 cfun->gimple_df->modified_noreturn_calls = NULL; 1171 cfun->gimple_df = NULL; 1172 1173 /* We no longer need the edge variable maps. */ 1174 redirect_edge_var_map_destroy (); 1175 } 1176 1177 /* Return true if the conversion from INNER_TYPE to OUTER_TYPE is a 1178 useless type conversion, otherwise return false. 1179 1180 This function implicitly defines the middle-end type system. With 1181 the notion of 'a < b' meaning that useless_type_conversion_p (a, b) 1182 holds and 'a > b' meaning that useless_type_conversion_p (b, a) holds, 1183 the following invariants shall be fulfilled: 1184 1185 1) useless_type_conversion_p is transitive. 1186 If a < b and b < c then a < c. 1187 1188 2) useless_type_conversion_p is not symmetric. 1189 From a < b does not follow a > b. 1190 1191 3) Types define the available set of operations applicable to values. 1192 A type conversion is useless if the operations for the target type 1193 is a subset of the operations for the source type. For example 1194 casts to void* are useless, casts from void* are not (void* can't 1195 be dereferenced or offsetted, but copied, hence its set of operations 1196 is a strict subset of that of all other data pointer types). Casts 1197 to const T* are useless (can't be written to), casts from const T* 1198 to T* are not. */ 1199 1200 bool 1201 useless_type_conversion_p (tree outer_type, tree inner_type) 1202 { 1203 /* Do the following before stripping toplevel qualifiers. */ 1204 if (POINTER_TYPE_P (inner_type) 1205 && POINTER_TYPE_P (outer_type)) 1206 { 1207 /* Do not lose casts between pointers to different address spaces. */ 1208 if (TYPE_ADDR_SPACE (TREE_TYPE (outer_type)) 1209 != TYPE_ADDR_SPACE (TREE_TYPE (inner_type))) 1210 return false; 1211 1212 /* If the outer type is (void *) or a pointer to an incomplete 1213 record type or a pointer to an unprototyped function, 1214 then the conversion is not necessary. */ 1215 if (VOID_TYPE_P (TREE_TYPE (outer_type)) 1216 || ((TREE_CODE (TREE_TYPE (outer_type)) == FUNCTION_TYPE 1217 || TREE_CODE (TREE_TYPE (outer_type)) == METHOD_TYPE) 1218 && (TREE_CODE (TREE_TYPE (outer_type)) 1219 == TREE_CODE (TREE_TYPE (inner_type))) 1220 && !TYPE_ARG_TYPES (TREE_TYPE (outer_type)) 1221 && useless_type_conversion_p (TREE_TYPE (TREE_TYPE (outer_type)), 1222 TREE_TYPE (TREE_TYPE (inner_type))))) 1223 return true; 1224 1225 /* Do not lose casts to restrict qualified pointers. */ 1226 if ((TYPE_RESTRICT (outer_type) 1227 != TYPE_RESTRICT (inner_type)) 1228 && TYPE_RESTRICT (outer_type)) 1229 return false; 1230 } 1231 1232 /* From now on qualifiers on value types do not matter. */ 1233 inner_type = TYPE_MAIN_VARIANT (inner_type); 1234 outer_type = TYPE_MAIN_VARIANT (outer_type); 1235 1236 if (inner_type == outer_type) 1237 return true; 1238 1239 /* If we know the canonical types, compare them. */ 1240 if (TYPE_CANONICAL (inner_type) 1241 && TYPE_CANONICAL (inner_type) == TYPE_CANONICAL (outer_type)) 1242 return true; 1243 1244 /* Changes in machine mode are never useless conversions unless we 1245 deal with aggregate types in which case we defer to later checks. */ 1246 if (TYPE_MODE (inner_type) != TYPE_MODE (outer_type) 1247 && !AGGREGATE_TYPE_P (inner_type)) 1248 return false; 1249 1250 /* If both the inner and outer types are integral types, then the 1251 conversion is not necessary if they have the same mode and 1252 signedness and precision, and both or neither are boolean. */ 1253 if (INTEGRAL_TYPE_P (inner_type) 1254 && INTEGRAL_TYPE_P (outer_type)) 1255 { 1256 /* Preserve changes in signedness or precision. */ 1257 if (TYPE_UNSIGNED (inner_type) != TYPE_UNSIGNED (outer_type) 1258 || TYPE_PRECISION (inner_type) != TYPE_PRECISION (outer_type)) 1259 return false; 1260 1261 /* We don't need to preserve changes in the types minimum or 1262 maximum value in general as these do not generate code 1263 unless the types precisions are different. */ 1264 return true; 1265 } 1266 1267 /* Scalar floating point types with the same mode are compatible. */ 1268 else if (SCALAR_FLOAT_TYPE_P (inner_type) 1269 && SCALAR_FLOAT_TYPE_P (outer_type)) 1270 return true; 1271 1272 /* Fixed point types with the same mode are compatible. */ 1273 else if (FIXED_POINT_TYPE_P (inner_type) 1274 && FIXED_POINT_TYPE_P (outer_type)) 1275 return true; 1276 1277 /* We need to take special care recursing to pointed-to types. */ 1278 else if (POINTER_TYPE_P (inner_type) 1279 && POINTER_TYPE_P (outer_type)) 1280 { 1281 /* Don't lose casts between pointers to volatile and non-volatile 1282 qualified types. Doing so would result in changing the semantics 1283 of later accesses. For function types the volatile qualifier 1284 is used to indicate noreturn functions. */ 1285 if (TREE_CODE (TREE_TYPE (outer_type)) != FUNCTION_TYPE 1286 && TREE_CODE (TREE_TYPE (outer_type)) != METHOD_TYPE 1287 && TREE_CODE (TREE_TYPE (inner_type)) != FUNCTION_TYPE 1288 && TREE_CODE (TREE_TYPE (inner_type)) != METHOD_TYPE 1289 && (TYPE_VOLATILE (TREE_TYPE (outer_type)) 1290 != TYPE_VOLATILE (TREE_TYPE (inner_type))) 1291 && TYPE_VOLATILE (TREE_TYPE (outer_type))) 1292 return false; 1293 1294 /* We require explicit conversions from incomplete target types. */ 1295 if (!COMPLETE_TYPE_P (TREE_TYPE (inner_type)) 1296 && COMPLETE_TYPE_P (TREE_TYPE (outer_type))) 1297 return false; 1298 1299 /* Do not lose casts between pointers that when dereferenced access 1300 memory with different alias sets. */ 1301 if (get_deref_alias_set (inner_type) != get_deref_alias_set (outer_type)) 1302 return false; 1303 1304 /* We do not care for const qualification of the pointed-to types 1305 as const qualification has no semantic value to the middle-end. */ 1306 1307 /* Otherwise pointers/references are equivalent if their pointed 1308 to types are effectively the same. We can strip qualifiers 1309 on pointed-to types for further comparison, which is done in 1310 the callee. Note we have to use true compatibility here 1311 because addresses are subject to propagation into dereferences 1312 and thus might get the original type exposed which is equivalent 1313 to a reverse conversion. */ 1314 return types_compatible_p (TREE_TYPE (outer_type), 1315 TREE_TYPE (inner_type)); 1316 } 1317 1318 /* Recurse for complex types. */ 1319 else if (TREE_CODE (inner_type) == COMPLEX_TYPE 1320 && TREE_CODE (outer_type) == COMPLEX_TYPE) 1321 return useless_type_conversion_p (TREE_TYPE (outer_type), 1322 TREE_TYPE (inner_type)); 1323 1324 /* Recurse for vector types with the same number of subparts. */ 1325 else if (TREE_CODE (inner_type) == VECTOR_TYPE 1326 && TREE_CODE (outer_type) == VECTOR_TYPE 1327 && TYPE_PRECISION (inner_type) == TYPE_PRECISION (outer_type)) 1328 return useless_type_conversion_p (TREE_TYPE (outer_type), 1329 TREE_TYPE (inner_type)); 1330 1331 else if (TREE_CODE (inner_type) == ARRAY_TYPE 1332 && TREE_CODE (outer_type) == ARRAY_TYPE) 1333 { 1334 /* Preserve string attributes. */ 1335 if (TYPE_STRING_FLAG (inner_type) != TYPE_STRING_FLAG (outer_type)) 1336 return false; 1337 1338 /* Conversions from array types with unknown extent to 1339 array types with known extent are not useless. */ 1340 if (!TYPE_DOMAIN (inner_type) 1341 && TYPE_DOMAIN (outer_type)) 1342 return false; 1343 1344 /* Nor are conversions from array types with non-constant size to 1345 array types with constant size or to different size. */ 1346 if (TYPE_SIZE (outer_type) 1347 && TREE_CODE (TYPE_SIZE (outer_type)) == INTEGER_CST 1348 && (!TYPE_SIZE (inner_type) 1349 || TREE_CODE (TYPE_SIZE (inner_type)) != INTEGER_CST 1350 || !tree_int_cst_equal (TYPE_SIZE (outer_type), 1351 TYPE_SIZE (inner_type)))) 1352 return false; 1353 1354 /* Check conversions between arrays with partially known extents. 1355 If the array min/max values are constant they have to match. 1356 Otherwise allow conversions to unknown and variable extents. 1357 In particular this declares conversions that may change the 1358 mode to BLKmode as useless. */ 1359 if (TYPE_DOMAIN (inner_type) 1360 && TYPE_DOMAIN (outer_type) 1361 && TYPE_DOMAIN (inner_type) != TYPE_DOMAIN (outer_type)) 1362 { 1363 tree inner_min = TYPE_MIN_VALUE (TYPE_DOMAIN (inner_type)); 1364 tree outer_min = TYPE_MIN_VALUE (TYPE_DOMAIN (outer_type)); 1365 tree inner_max = TYPE_MAX_VALUE (TYPE_DOMAIN (inner_type)); 1366 tree outer_max = TYPE_MAX_VALUE (TYPE_DOMAIN (outer_type)); 1367 1368 /* After gimplification a variable min/max value carries no 1369 additional information compared to a NULL value. All that 1370 matters has been lowered to be part of the IL. */ 1371 if (inner_min && TREE_CODE (inner_min) != INTEGER_CST) 1372 inner_min = NULL_TREE; 1373 if (outer_min && TREE_CODE (outer_min) != INTEGER_CST) 1374 outer_min = NULL_TREE; 1375 if (inner_max && TREE_CODE (inner_max) != INTEGER_CST) 1376 inner_max = NULL_TREE; 1377 if (outer_max && TREE_CODE (outer_max) != INTEGER_CST) 1378 outer_max = NULL_TREE; 1379 1380 /* Conversions NULL / variable <- cst are useless, but not 1381 the other way around. */ 1382 if (outer_min 1383 && (!inner_min 1384 || !tree_int_cst_equal (inner_min, outer_min))) 1385 return false; 1386 if (outer_max 1387 && (!inner_max 1388 || !tree_int_cst_equal (inner_max, outer_max))) 1389 return false; 1390 } 1391 1392 /* Recurse on the element check. */ 1393 return useless_type_conversion_p (TREE_TYPE (outer_type), 1394 TREE_TYPE (inner_type)); 1395 } 1396 1397 else if ((TREE_CODE (inner_type) == FUNCTION_TYPE 1398 || TREE_CODE (inner_type) == METHOD_TYPE) 1399 && TREE_CODE (inner_type) == TREE_CODE (outer_type)) 1400 { 1401 tree outer_parm, inner_parm; 1402 1403 /* If the return types are not compatible bail out. */ 1404 if (!useless_type_conversion_p (TREE_TYPE (outer_type), 1405 TREE_TYPE (inner_type))) 1406 return false; 1407 1408 /* Method types should belong to a compatible base class. */ 1409 if (TREE_CODE (inner_type) == METHOD_TYPE 1410 && !useless_type_conversion_p (TYPE_METHOD_BASETYPE (outer_type), 1411 TYPE_METHOD_BASETYPE (inner_type))) 1412 return false; 1413 1414 /* A conversion to an unprototyped argument list is ok. */ 1415 if (!TYPE_ARG_TYPES (outer_type)) 1416 return true; 1417 1418 /* If the unqualified argument types are compatible the conversion 1419 is useless. */ 1420 if (TYPE_ARG_TYPES (outer_type) == TYPE_ARG_TYPES (inner_type)) 1421 return true; 1422 1423 for (outer_parm = TYPE_ARG_TYPES (outer_type), 1424 inner_parm = TYPE_ARG_TYPES (inner_type); 1425 outer_parm && inner_parm; 1426 outer_parm = TREE_CHAIN (outer_parm), 1427 inner_parm = TREE_CHAIN (inner_parm)) 1428 if (!useless_type_conversion_p 1429 (TYPE_MAIN_VARIANT (TREE_VALUE (outer_parm)), 1430 TYPE_MAIN_VARIANT (TREE_VALUE (inner_parm)))) 1431 return false; 1432 1433 /* If there is a mismatch in the number of arguments the functions 1434 are not compatible. */ 1435 if (outer_parm || inner_parm) 1436 return false; 1437 1438 /* Defer to the target if necessary. */ 1439 if (TYPE_ATTRIBUTES (inner_type) || TYPE_ATTRIBUTES (outer_type)) 1440 return targetm.comp_type_attributes (outer_type, inner_type) != 0; 1441 1442 return true; 1443 } 1444 1445 /* For aggregates we rely on TYPE_CANONICAL exclusively and require 1446 explicit conversions for types involving to be structurally 1447 compared types. */ 1448 else if (AGGREGATE_TYPE_P (inner_type) 1449 && TREE_CODE (inner_type) == TREE_CODE (outer_type)) 1450 return false; 1451 1452 return false; 1453 } 1454 1455 /* Return true if a conversion from either type of TYPE1 and TYPE2 1456 to the other is not required. Otherwise return false. */ 1457 1458 bool 1459 types_compatible_p (tree type1, tree type2) 1460 { 1461 return (type1 == type2 1462 || (useless_type_conversion_p (type1, type2) 1463 && useless_type_conversion_p (type2, type1))); 1464 } 1465 1466 /* Return true if EXPR is a useless type conversion, otherwise return 1467 false. */ 1468 1469 bool 1470 tree_ssa_useless_type_conversion (tree expr) 1471 { 1472 /* If we have an assignment that merely uses a NOP_EXPR to change 1473 the top of the RHS to the type of the LHS and the type conversion 1474 is "safe", then strip away the type conversion so that we can 1475 enter LHS = RHS into the const_and_copies table. */ 1476 if (CONVERT_EXPR_P (expr) 1477 || TREE_CODE (expr) == VIEW_CONVERT_EXPR 1478 || TREE_CODE (expr) == NON_LVALUE_EXPR) 1479 return useless_type_conversion_p 1480 (TREE_TYPE (expr), 1481 TREE_TYPE (TREE_OPERAND (expr, 0))); 1482 1483 return false; 1484 } 1485 1486 /* Strip conversions from EXP according to 1487 tree_ssa_useless_type_conversion and return the resulting 1488 expression. */ 1489 1490 tree 1491 tree_ssa_strip_useless_type_conversions (tree exp) 1492 { 1493 while (tree_ssa_useless_type_conversion (exp)) 1494 exp = TREE_OPERAND (exp, 0); 1495 return exp; 1496 } 1497 1498 1499 /* Internal helper for walk_use_def_chains. VAR, FN and DATA are as 1500 described in walk_use_def_chains. 1501 1502 VISITED is a pointer set used to mark visited SSA_NAMEs to avoid 1503 infinite loops. We used to have a bitmap for this to just mark 1504 SSA versions we had visited. But non-sparse bitmaps are way too 1505 expensive, while sparse bitmaps may cause quadratic behavior. 1506 1507 IS_DFS is true if the caller wants to perform a depth-first search 1508 when visiting PHI nodes. A DFS will visit each PHI argument and 1509 call FN after each one. Otherwise, all the arguments are 1510 visited first and then FN is called with each of the visited 1511 arguments in a separate pass. */ 1512 1513 static bool 1514 walk_use_def_chains_1 (tree var, walk_use_def_chains_fn fn, void *data, 1515 struct pointer_set_t *visited, bool is_dfs) 1516 { 1517 gimple def_stmt; 1518 1519 if (pointer_set_insert (visited, var)) 1520 return false; 1521 1522 def_stmt = SSA_NAME_DEF_STMT (var); 1523 1524 if (gimple_code (def_stmt) != GIMPLE_PHI) 1525 { 1526 /* If we reached the end of the use-def chain, call FN. */ 1527 return fn (var, def_stmt, data); 1528 } 1529 else 1530 { 1531 size_t i; 1532 1533 /* When doing a breadth-first search, call FN before following the 1534 use-def links for each argument. */ 1535 if (!is_dfs) 1536 for (i = 0; i < gimple_phi_num_args (def_stmt); i++) 1537 if (fn (gimple_phi_arg_def (def_stmt, i), def_stmt, data)) 1538 return true; 1539 1540 /* Follow use-def links out of each PHI argument. */ 1541 for (i = 0; i < gimple_phi_num_args (def_stmt); i++) 1542 { 1543 tree arg = gimple_phi_arg_def (def_stmt, i); 1544 1545 /* ARG may be NULL for newly introduced PHI nodes. */ 1546 if (arg 1547 && TREE_CODE (arg) == SSA_NAME 1548 && walk_use_def_chains_1 (arg, fn, data, visited, is_dfs)) 1549 return true; 1550 } 1551 1552 /* When doing a depth-first search, call FN after following the 1553 use-def links for each argument. */ 1554 if (is_dfs) 1555 for (i = 0; i < gimple_phi_num_args (def_stmt); i++) 1556 if (fn (gimple_phi_arg_def (def_stmt, i), def_stmt, data)) 1557 return true; 1558 } 1559 1560 return false; 1561 } 1562 1563 1564 1565 /* Walk use-def chains starting at the SSA variable VAR. Call 1566 function FN at each reaching definition found. FN takes three 1567 arguments: VAR, its defining statement (DEF_STMT) and a generic 1568 pointer to whatever state information that FN may want to maintain 1569 (DATA). FN is able to stop the walk by returning true, otherwise 1570 in order to continue the walk, FN should return false. 1571 1572 Note, that if DEF_STMT is a PHI node, the semantics are slightly 1573 different. The first argument to FN is no longer the original 1574 variable VAR, but the PHI argument currently being examined. If FN 1575 wants to get at VAR, it should call PHI_RESULT (PHI). 1576 1577 If IS_DFS is true, this function will: 1578 1579 1- walk the use-def chains for all the PHI arguments, and, 1580 2- call (*FN) (ARG, PHI, DATA) on all the PHI arguments. 1581 1582 If IS_DFS is false, the two steps above are done in reverse order 1583 (i.e., a breadth-first search). */ 1584 1585 void 1586 walk_use_def_chains (tree var, walk_use_def_chains_fn fn, void *data, 1587 bool is_dfs) 1588 { 1589 gimple def_stmt; 1590 1591 gcc_assert (TREE_CODE (var) == SSA_NAME); 1592 1593 def_stmt = SSA_NAME_DEF_STMT (var); 1594 1595 /* We only need to recurse if the reaching definition comes from a PHI 1596 node. */ 1597 if (gimple_code (def_stmt) != GIMPLE_PHI) 1598 (*fn) (var, def_stmt, data); 1599 else 1600 { 1601 struct pointer_set_t *visited = pointer_set_create (); 1602 walk_use_def_chains_1 (var, fn, data, visited, is_dfs); 1603 pointer_set_destroy (visited); 1604 } 1605 } 1606 1607 1608 /* Return true if T, an SSA_NAME, has an undefined value. */ 1609 1610 bool 1611 ssa_undefined_value_p (tree t) 1612 { 1613 tree var = SSA_NAME_VAR (t); 1614 1615 /* Parameters get their initial value from the function entry. */ 1616 if (TREE_CODE (var) == PARM_DECL) 1617 return false; 1618 1619 /* Hard register variables get their initial value from the ether. */ 1620 if (TREE_CODE (var) == VAR_DECL && DECL_HARD_REGISTER (var)) 1621 return false; 1622 1623 /* The value is undefined iff its definition statement is empty. */ 1624 return gimple_nop_p (SSA_NAME_DEF_STMT (t)); 1625 } 1626 1627 /* Emit warnings for uninitialized variables. This is done in two passes. 1628 1629 The first pass notices real uses of SSA names with undefined values. 1630 Such uses are unconditionally uninitialized, and we can be certain that 1631 such a use is a mistake. This pass is run before most optimizations, 1632 so that we catch as many as we can. 1633 1634 The second pass follows PHI nodes to find uses that are potentially 1635 uninitialized. In this case we can't necessarily prove that the use 1636 is really uninitialized. This pass is run after most optimizations, 1637 so that we thread as many jumps and possible, and delete as much dead 1638 code as possible, in order to reduce false positives. We also look 1639 again for plain uninitialized variables, since optimization may have 1640 changed conditionally uninitialized to unconditionally uninitialized. */ 1641 1642 /* Emit a warning for T, an SSA_NAME, being uninitialized. The exact 1643 warning text is in MSGID and LOCUS may contain a location or be null. */ 1644 1645 static void 1646 warn_uninit (tree t, const char *gmsgid, void *data) 1647 { 1648 tree var = SSA_NAME_VAR (t); 1649 gimple context = (gimple) data; 1650 location_t location; 1651 expanded_location xloc, floc; 1652 1653 if (!ssa_undefined_value_p (t)) 1654 return; 1655 1656 /* TREE_NO_WARNING either means we already warned, or the front end 1657 wishes to suppress the warning. */ 1658 if (TREE_NO_WARNING (var)) 1659 return; 1660 1661 /* Do not warn if it can be initialized outside this module. */ 1662 if (is_global_var (var)) 1663 return; 1664 1665 location = (context != NULL && gimple_has_location (context)) 1666 ? gimple_location (context) 1667 : DECL_SOURCE_LOCATION (var); 1668 xloc = expand_location (location); 1669 floc = expand_location (DECL_SOURCE_LOCATION (cfun->decl)); 1670 if (warning_at (location, OPT_Wuninitialized, gmsgid, var)) 1671 { 1672 TREE_NO_WARNING (var) = 1; 1673 1674 if (xloc.file != floc.file 1675 || xloc.line < floc.line 1676 || xloc.line > LOCATION_LINE (cfun->function_end_locus)) 1677 inform (DECL_SOURCE_LOCATION (var), "%qD was declared here", var); 1678 } 1679 } 1680 1681 struct walk_data { 1682 gimple stmt; 1683 bool always_executed; 1684 bool warn_possibly_uninitialized; 1685 }; 1686 1687 /* Called via walk_tree, look for SSA_NAMEs that have empty definitions 1688 and warn about them. */ 1689 1690 static tree 1691 warn_uninitialized_var (tree *tp, int *walk_subtrees, void *data_) 1692 { 1693 struct walk_stmt_info *wi = (struct walk_stmt_info *) data_; 1694 struct walk_data *data = (struct walk_data *) wi->info; 1695 tree t = *tp; 1696 1697 /* We do not care about LHS. */ 1698 if (wi->is_lhs) 1699 { 1700 /* Except for operands of INDIRECT_REF. */ 1701 if (!INDIRECT_REF_P (t)) 1702 return NULL_TREE; 1703 t = TREE_OPERAND (t, 0); 1704 } 1705 1706 switch (TREE_CODE (t)) 1707 { 1708 case ADDR_EXPR: 1709 /* Taking the address of an uninitialized variable does not 1710 count as using it. */ 1711 *walk_subtrees = 0; 1712 break; 1713 1714 case VAR_DECL: 1715 { 1716 /* A VAR_DECL in the RHS of a gimple statement may mean that 1717 this variable is loaded from memory. */ 1718 use_operand_p vuse; 1719 tree op; 1720 1721 /* If there is not gimple stmt, 1722 or alias information has not been computed, 1723 then we cannot check VUSE ops. */ 1724 if (data->stmt == NULL) 1725 return NULL_TREE; 1726 1727 /* If the load happens as part of a call do not warn about it. */ 1728 if (is_gimple_call (data->stmt)) 1729 return NULL_TREE; 1730 1731 vuse = gimple_vuse_op (data->stmt); 1732 if (vuse == NULL_USE_OPERAND_P) 1733 return NULL_TREE; 1734 1735 op = USE_FROM_PTR (vuse); 1736 if (t != SSA_NAME_VAR (op) 1737 || !SSA_NAME_IS_DEFAULT_DEF (op)) 1738 return NULL_TREE; 1739 /* If this is a VUSE of t and it is the default definition, 1740 then warn about op. */ 1741 t = op; 1742 /* Fall through into SSA_NAME. */ 1743 } 1744 1745 case SSA_NAME: 1746 /* We only do data flow with SSA_NAMEs, so that's all we 1747 can warn about. */ 1748 if (data->always_executed) 1749 warn_uninit (t, "%qD is used uninitialized in this function", 1750 data->stmt); 1751 else if (data->warn_possibly_uninitialized) 1752 warn_uninit (t, "%qD may be used uninitialized in this function", 1753 data->stmt); 1754 *walk_subtrees = 0; 1755 break; 1756 1757 case REALPART_EXPR: 1758 case IMAGPART_EXPR: 1759 /* The total store transformation performed during gimplification 1760 creates uninitialized variable uses. If all is well, these will 1761 be optimized away, so don't warn now. */ 1762 if (TREE_CODE (TREE_OPERAND (t, 0)) == SSA_NAME) 1763 *walk_subtrees = 0; 1764 break; 1765 1766 default: 1767 if (IS_TYPE_OR_DECL_P (t)) 1768 *walk_subtrees = 0; 1769 break; 1770 } 1771 1772 return NULL_TREE; 1773 } 1774 1775 /* Look for inputs to PHI that are SSA_NAMEs that have empty definitions 1776 and warn about them. */ 1777 1778 static void 1779 warn_uninitialized_phi (gimple phi) 1780 { 1781 size_t i, n = gimple_phi_num_args (phi); 1782 1783 /* Don't look at memory tags. */ 1784 if (!is_gimple_reg (gimple_phi_result (phi))) 1785 return; 1786 1787 for (i = 0; i < n; ++i) 1788 { 1789 tree op = gimple_phi_arg_def (phi, i); 1790 if (TREE_CODE (op) == SSA_NAME) 1791 warn_uninit (op, "%qD may be used uninitialized in this function", 1792 NULL); 1793 } 1794 } 1795 1796 static unsigned int 1797 warn_uninitialized_vars (bool warn_possibly_uninitialized) 1798 { 1799 gimple_stmt_iterator gsi; 1800 basic_block bb; 1801 struct walk_data data; 1802 1803 data.warn_possibly_uninitialized = warn_possibly_uninitialized; 1804 1805 calculate_dominance_info (CDI_POST_DOMINATORS); 1806 1807 FOR_EACH_BB (bb) 1808 { 1809 data.always_executed = dominated_by_p (CDI_POST_DOMINATORS, 1810 single_succ (ENTRY_BLOCK_PTR), bb); 1811 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) 1812 { 1813 struct walk_stmt_info wi; 1814 data.stmt = gsi_stmt (gsi); 1815 if (is_gimple_debug (data.stmt)) 1816 continue; 1817 memset (&wi, 0, sizeof (wi)); 1818 wi.info = &data; 1819 walk_gimple_op (gsi_stmt (gsi), warn_uninitialized_var, &wi); 1820 } 1821 } 1822 1823 /* Post-dominator information can not be reliably updated. Free it 1824 after the use. */ 1825 1826 free_dominance_info (CDI_POST_DOMINATORS); 1827 return 0; 1828 } 1829 1830 static unsigned int 1831 execute_early_warn_uninitialized (void) 1832 { 1833 /* Currently, this pass runs always but 1834 execute_late_warn_uninitialized only runs with optimization. With 1835 optimization we want to warn about possible uninitialized as late 1836 as possible, thus don't do it here. However, without 1837 optimization we need to warn here about "may be uninitialized". 1838 */ 1839 warn_uninitialized_vars (/*warn_possibly_uninitialized=*/!optimize); 1840 return 0; 1841 } 1842 1843 static unsigned int 1844 execute_late_warn_uninitialized (void) 1845 { 1846 basic_block bb; 1847 gimple_stmt_iterator gsi; 1848 1849 /* Re-do the plain uninitialized variable check, as optimization may have 1850 straightened control flow. Do this first so that we don't accidentally 1851 get a "may be" warning when we'd have seen an "is" warning later. */ 1852 warn_uninitialized_vars (/*warn_possibly_uninitialized=*/1); 1853 1854 FOR_EACH_BB (bb) 1855 for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi)) 1856 warn_uninitialized_phi (gsi_stmt (gsi)); 1857 1858 return 0; 1859 } 1860 1861 static bool 1862 gate_warn_uninitialized (void) 1863 { 1864 return warn_uninitialized != 0; 1865 } 1866 1867 struct gimple_opt_pass pass_early_warn_uninitialized = 1868 { 1869 { 1870 GIMPLE_PASS, 1871 "*early_warn_uninitialized", /* name */ 1872 gate_warn_uninitialized, /* gate */ 1873 execute_early_warn_uninitialized, /* execute */ 1874 NULL, /* sub */ 1875 NULL, /* next */ 1876 0, /* static_pass_number */ 1877 TV_NONE, /* tv_id */ 1878 PROP_ssa, /* properties_required */ 1879 0, /* properties_provided */ 1880 0, /* properties_destroyed */ 1881 0, /* todo_flags_start */ 1882 0 /* todo_flags_finish */ 1883 } 1884 }; 1885 1886 struct gimple_opt_pass pass_late_warn_uninitialized = 1887 { 1888 { 1889 GIMPLE_PASS, 1890 "*late_warn_uninitialized", /* name */ 1891 gate_warn_uninitialized, /* gate */ 1892 execute_late_warn_uninitialized, /* execute */ 1893 NULL, /* sub */ 1894 NULL, /* next */ 1895 0, /* static_pass_number */ 1896 TV_NONE, /* tv_id */ 1897 PROP_ssa, /* properties_required */ 1898 0, /* properties_provided */ 1899 0, /* properties_destroyed */ 1900 0, /* todo_flags_start */ 1901 0 /* todo_flags_finish */ 1902 } 1903 }; 1904 1905 /* Compute TREE_ADDRESSABLE and DECL_GIMPLE_REG_P for local variables. */ 1906 1907 void 1908 execute_update_addresses_taken (bool do_optimize) 1909 { 1910 tree var; 1911 referenced_var_iterator rvi; 1912 gimple_stmt_iterator gsi; 1913 basic_block bb; 1914 bitmap addresses_taken = BITMAP_ALLOC (NULL); 1915 bitmap not_reg_needs = BITMAP_ALLOC (NULL); 1916 bool update_vops = false; 1917 1918 /* Collect into ADDRESSES_TAKEN all variables whose address is taken within 1919 the function body. */ 1920 FOR_EACH_BB (bb) 1921 { 1922 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) 1923 { 1924 gimple stmt = gsi_stmt (gsi); 1925 enum gimple_code code = gimple_code (stmt); 1926 1927 /* Note all addresses taken by the stmt. */ 1928 gimple_ior_addresses_taken (addresses_taken, stmt); 1929 1930 /* If we have a call or an assignment, see if the lhs contains 1931 a local decl that requires not to be a gimple register. */ 1932 if (code == GIMPLE_ASSIGN || code == GIMPLE_CALL) 1933 { 1934 tree lhs = gimple_get_lhs (stmt); 1935 1936 /* We may not rewrite TMR_SYMBOL to SSA. */ 1937 if (lhs && TREE_CODE (lhs) == TARGET_MEM_REF 1938 && TMR_SYMBOL (lhs)) 1939 bitmap_set_bit (not_reg_needs, DECL_UID (TMR_SYMBOL (lhs))); 1940 1941 /* A plain decl does not need it set. */ 1942 else if (lhs && handled_component_p (lhs)) 1943 { 1944 var = get_base_address (lhs); 1945 if (DECL_P (var)) 1946 bitmap_set_bit (not_reg_needs, DECL_UID (var)); 1947 } 1948 } 1949 } 1950 1951 for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi)) 1952 { 1953 size_t i; 1954 gimple phi = gsi_stmt (gsi); 1955 1956 for (i = 0; i < gimple_phi_num_args (phi); i++) 1957 { 1958 tree op = PHI_ARG_DEF (phi, i), var; 1959 if (TREE_CODE (op) == ADDR_EXPR 1960 && (var = get_base_address (TREE_OPERAND (op, 0))) != NULL 1961 && DECL_P (var)) 1962 bitmap_set_bit (addresses_taken, DECL_UID (var)); 1963 } 1964 } 1965 } 1966 1967 /* When possible, clear ADDRESSABLE bit or set the REGISTER bit 1968 and mark variable for conversion into SSA. */ 1969 if (optimize && do_optimize) 1970 FOR_EACH_REFERENCED_VAR (var, rvi) 1971 { 1972 /* Global Variables, result decls cannot be changed. */ 1973 if (is_global_var (var) 1974 || TREE_CODE (var) == RESULT_DECL 1975 || bitmap_bit_p (addresses_taken, DECL_UID (var))) 1976 continue; 1977 1978 if (TREE_ADDRESSABLE (var) 1979 /* Do not change TREE_ADDRESSABLE if we need to preserve var as 1980 a non-register. Otherwise we are confused and forget to 1981 add virtual operands for it. */ 1982 && (!is_gimple_reg_type (TREE_TYPE (var)) 1983 || !bitmap_bit_p (not_reg_needs, DECL_UID (var)))) 1984 { 1985 TREE_ADDRESSABLE (var) = 0; 1986 if (is_gimple_reg (var)) 1987 mark_sym_for_renaming (var); 1988 update_vops = true; 1989 if (dump_file) 1990 { 1991 fprintf (dump_file, "No longer having address taken "); 1992 print_generic_expr (dump_file, var, 0); 1993 fprintf (dump_file, "\n"); 1994 } 1995 } 1996 if (!DECL_GIMPLE_REG_P (var) 1997 && !bitmap_bit_p (not_reg_needs, DECL_UID (var)) 1998 && (TREE_CODE (TREE_TYPE (var)) == COMPLEX_TYPE 1999 || TREE_CODE (TREE_TYPE (var)) == VECTOR_TYPE) 2000 && !TREE_THIS_VOLATILE (var) 2001 && (TREE_CODE (var) != VAR_DECL || !DECL_HARD_REGISTER (var))) 2002 { 2003 DECL_GIMPLE_REG_P (var) = 1; 2004 mark_sym_for_renaming (var); 2005 update_vops = true; 2006 if (dump_file) 2007 { 2008 fprintf (dump_file, "Decl is now a gimple register "); 2009 print_generic_expr (dump_file, var, 0); 2010 fprintf (dump_file, "\n"); 2011 } 2012 } 2013 } 2014 2015 /* Operand caches needs to be recomputed for operands referencing the updated 2016 variables. */ 2017 if (update_vops) 2018 { 2019 FOR_EACH_BB (bb) 2020 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) 2021 { 2022 gimple stmt = gsi_stmt (gsi); 2023 2024 if (gimple_references_memory_p (stmt) 2025 || is_gimple_debug (stmt)) 2026 update_stmt (stmt); 2027 } 2028 2029 /* Update SSA form here, we are called as non-pass as well. */ 2030 update_ssa (TODO_update_ssa); 2031 } 2032 2033 BITMAP_FREE (not_reg_needs); 2034 BITMAP_FREE (addresses_taken); 2035 } 2036 2037 struct gimple_opt_pass pass_update_address_taken = 2038 { 2039 { 2040 GIMPLE_PASS, 2041 "addressables", /* name */ 2042 NULL, /* gate */ 2043 NULL, /* execute */ 2044 NULL, /* sub */ 2045 NULL, /* next */ 2046 0, /* static_pass_number */ 2047 TV_NONE, /* tv_id */ 2048 PROP_ssa, /* properties_required */ 2049 0, /* properties_provided */ 2050 0, /* properties_destroyed */ 2051 0, /* todo_flags_start */ 2052 TODO_update_address_taken 2053 | TODO_dump_func /* todo_flags_finish */ 2054 } 2055 }; 2056