1 /* Data flow functions for trees. 2 Copyright (C) 2001-2013 Free Software Foundation, Inc. 3 Contributed by Diego Novillo <dnovillo@redhat.com> 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 "hashtab.h" 26 #include "pointer-set.h" 27 #include "tree.h" 28 #include "tm_p.h" 29 #include "basic-block.h" 30 #include "ggc.h" 31 #include "langhooks.h" 32 #include "flags.h" 33 #include "function.h" 34 #include "tree-pretty-print.h" 35 #include "gimple.h" 36 #include "tree-flow.h" 37 #include "tree-inline.h" 38 #include "tree-pass.h" 39 #include "convert.h" 40 #include "params.h" 41 #include "cgraph.h" 42 43 /* Build and maintain data flow information for trees. */ 44 45 /* Counters used to display DFA and SSA statistics. */ 46 struct dfa_stats_d 47 { 48 long num_defs; 49 long num_uses; 50 long num_phis; 51 long num_phi_args; 52 size_t max_num_phi_args; 53 long num_vdefs; 54 long num_vuses; 55 }; 56 57 58 /* Local functions. */ 59 static void collect_dfa_stats (struct dfa_stats_d *); 60 61 62 /*--------------------------------------------------------------------------- 63 Dataflow analysis (DFA) routines 64 ---------------------------------------------------------------------------*/ 65 66 /* Renumber all of the gimple stmt uids. */ 67 68 void 69 renumber_gimple_stmt_uids (void) 70 { 71 basic_block bb; 72 73 set_gimple_stmt_max_uid (cfun, 0); 74 FOR_ALL_BB (bb) 75 { 76 gimple_stmt_iterator bsi; 77 for (bsi = gsi_start_phis (bb); !gsi_end_p (bsi); gsi_next (&bsi)) 78 { 79 gimple stmt = gsi_stmt (bsi); 80 gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun)); 81 } 82 for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi)) 83 { 84 gimple stmt = gsi_stmt (bsi); 85 gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun)); 86 } 87 } 88 } 89 90 /* Like renumber_gimple_stmt_uids, but only do work on the basic blocks 91 in BLOCKS, of which there are N_BLOCKS. Also renumbers PHIs. */ 92 93 void 94 renumber_gimple_stmt_uids_in_blocks (basic_block *blocks, int n_blocks) 95 { 96 int i; 97 98 set_gimple_stmt_max_uid (cfun, 0); 99 for (i = 0; i < n_blocks; i++) 100 { 101 basic_block bb = blocks[i]; 102 gimple_stmt_iterator bsi; 103 for (bsi = gsi_start_phis (bb); !gsi_end_p (bsi); gsi_next (&bsi)) 104 { 105 gimple stmt = gsi_stmt (bsi); 106 gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun)); 107 } 108 for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi)) 109 { 110 gimple stmt = gsi_stmt (bsi); 111 gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun)); 112 } 113 } 114 } 115 116 117 118 /*--------------------------------------------------------------------------- 119 Debugging functions 120 ---------------------------------------------------------------------------*/ 121 122 /* Dump variable VAR and its may-aliases to FILE. */ 123 124 void 125 dump_variable (FILE *file, tree var) 126 { 127 if (TREE_CODE (var) == SSA_NAME) 128 { 129 if (POINTER_TYPE_P (TREE_TYPE (var))) 130 dump_points_to_info_for (file, var); 131 var = SSA_NAME_VAR (var); 132 } 133 134 if (var == NULL_TREE) 135 { 136 fprintf (file, "<nil>"); 137 return; 138 } 139 140 print_generic_expr (file, var, dump_flags); 141 142 fprintf (file, ", UID D.%u", (unsigned) DECL_UID (var)); 143 if (DECL_PT_UID (var) != DECL_UID (var)) 144 fprintf (file, ", PT-UID D.%u", (unsigned) DECL_PT_UID (var)); 145 146 fprintf (file, ", "); 147 print_generic_expr (file, TREE_TYPE (var), dump_flags); 148 149 if (TREE_ADDRESSABLE (var)) 150 fprintf (file, ", is addressable"); 151 152 if (is_global_var (var)) 153 fprintf (file, ", is global"); 154 155 if (TREE_THIS_VOLATILE (var)) 156 fprintf (file, ", is volatile"); 157 158 if (cfun && ssa_default_def (cfun, var)) 159 { 160 fprintf (file, ", default def: "); 161 print_generic_expr (file, ssa_default_def (cfun, var), dump_flags); 162 } 163 164 if (DECL_INITIAL (var)) 165 { 166 fprintf (file, ", initial: "); 167 print_generic_expr (file, DECL_INITIAL (var), dump_flags); 168 } 169 170 fprintf (file, "\n"); 171 } 172 173 174 /* Dump variable VAR and its may-aliases to stderr. */ 175 176 DEBUG_FUNCTION void 177 debug_variable (tree var) 178 { 179 dump_variable (stderr, var); 180 } 181 182 183 /* Dump various DFA statistics to FILE. */ 184 185 void 186 dump_dfa_stats (FILE *file) 187 { 188 struct dfa_stats_d dfa_stats; 189 190 unsigned long size, total = 0; 191 const char * const fmt_str = "%-30s%-13s%12s\n"; 192 const char * const fmt_str_1 = "%-30s%13lu%11lu%c\n"; 193 const char * const fmt_str_3 = "%-43s%11lu%c\n"; 194 const char *funcname 195 = lang_hooks.decl_printable_name (current_function_decl, 2); 196 197 collect_dfa_stats (&dfa_stats); 198 199 fprintf (file, "\nDFA Statistics for %s\n\n", funcname); 200 201 fprintf (file, "---------------------------------------------------------\n"); 202 fprintf (file, fmt_str, "", " Number of ", "Memory"); 203 fprintf (file, fmt_str, "", " instances ", "used "); 204 fprintf (file, "---------------------------------------------------------\n"); 205 206 size = dfa_stats.num_uses * sizeof (tree *); 207 total += size; 208 fprintf (file, fmt_str_1, "USE operands", dfa_stats.num_uses, 209 SCALE (size), LABEL (size)); 210 211 size = dfa_stats.num_defs * sizeof (tree *); 212 total += size; 213 fprintf (file, fmt_str_1, "DEF operands", dfa_stats.num_defs, 214 SCALE (size), LABEL (size)); 215 216 size = dfa_stats.num_vuses * sizeof (tree *); 217 total += size; 218 fprintf (file, fmt_str_1, "VUSE operands", dfa_stats.num_vuses, 219 SCALE (size), LABEL (size)); 220 221 size = dfa_stats.num_vdefs * sizeof (tree *); 222 total += size; 223 fprintf (file, fmt_str_1, "VDEF operands", dfa_stats.num_vdefs, 224 SCALE (size), LABEL (size)); 225 226 size = dfa_stats.num_phis * sizeof (struct gimple_statement_phi); 227 total += size; 228 fprintf (file, fmt_str_1, "PHI nodes", dfa_stats.num_phis, 229 SCALE (size), LABEL (size)); 230 231 size = dfa_stats.num_phi_args * sizeof (struct phi_arg_d); 232 total += size; 233 fprintf (file, fmt_str_1, "PHI arguments", dfa_stats.num_phi_args, 234 SCALE (size), LABEL (size)); 235 236 fprintf (file, "---------------------------------------------------------\n"); 237 fprintf (file, fmt_str_3, "Total memory used by DFA/SSA data", SCALE (total), 238 LABEL (total)); 239 fprintf (file, "---------------------------------------------------------\n"); 240 fprintf (file, "\n"); 241 242 if (dfa_stats.num_phis) 243 fprintf (file, "Average number of arguments per PHI node: %.1f (max: %ld)\n", 244 (float) dfa_stats.num_phi_args / (float) dfa_stats.num_phis, 245 (long) dfa_stats.max_num_phi_args); 246 247 fprintf (file, "\n"); 248 } 249 250 251 /* Dump DFA statistics on stderr. */ 252 253 DEBUG_FUNCTION void 254 debug_dfa_stats (void) 255 { 256 dump_dfa_stats (stderr); 257 } 258 259 260 /* Collect DFA statistics and store them in the structure pointed to by 261 DFA_STATS_P. */ 262 263 static void 264 collect_dfa_stats (struct dfa_stats_d *dfa_stats_p ATTRIBUTE_UNUSED) 265 { 266 basic_block bb; 267 268 gcc_assert (dfa_stats_p); 269 270 memset ((void *)dfa_stats_p, 0, sizeof (struct dfa_stats_d)); 271 272 /* Walk all the statements in the function counting references. */ 273 FOR_EACH_BB (bb) 274 { 275 gimple_stmt_iterator si; 276 277 for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si)) 278 { 279 gimple phi = gsi_stmt (si); 280 dfa_stats_p->num_phis++; 281 dfa_stats_p->num_phi_args += gimple_phi_num_args (phi); 282 if (gimple_phi_num_args (phi) > dfa_stats_p->max_num_phi_args) 283 dfa_stats_p->max_num_phi_args = gimple_phi_num_args (phi); 284 } 285 286 for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si)) 287 { 288 gimple stmt = gsi_stmt (si); 289 dfa_stats_p->num_defs += NUM_SSA_OPERANDS (stmt, SSA_OP_DEF); 290 dfa_stats_p->num_uses += NUM_SSA_OPERANDS (stmt, SSA_OP_USE); 291 dfa_stats_p->num_vdefs += gimple_vdef (stmt) ? 1 : 0; 292 dfa_stats_p->num_vuses += gimple_vuse (stmt) ? 1 : 0; 293 } 294 } 295 } 296 297 298 /*--------------------------------------------------------------------------- 299 Miscellaneous helpers 300 ---------------------------------------------------------------------------*/ 301 302 /* Lookup VAR UID in the default_defs hashtable and return the associated 303 variable. */ 304 305 tree 306 ssa_default_def (struct function *fn, tree var) 307 { 308 struct tree_decl_minimal ind; 309 struct tree_ssa_name in; 310 gcc_assert (TREE_CODE (var) == VAR_DECL 311 || TREE_CODE (var) == PARM_DECL 312 || TREE_CODE (var) == RESULT_DECL); 313 in.var = (tree)&ind; 314 ind.uid = DECL_UID (var); 315 return (tree) htab_find_with_hash (DEFAULT_DEFS (fn), &in, DECL_UID (var)); 316 } 317 318 /* Insert the pair VAR's UID, DEF into the default_defs hashtable 319 of function FN. */ 320 321 void 322 set_ssa_default_def (struct function *fn, tree var, tree def) 323 { 324 struct tree_decl_minimal ind; 325 struct tree_ssa_name in; 326 void **loc; 327 328 gcc_assert (TREE_CODE (var) == VAR_DECL 329 || TREE_CODE (var) == PARM_DECL 330 || TREE_CODE (var) == RESULT_DECL); 331 in.var = (tree)&ind; 332 ind.uid = DECL_UID (var); 333 if (!def) 334 { 335 loc = htab_find_slot_with_hash (DEFAULT_DEFS (fn), &in, 336 DECL_UID (var), NO_INSERT); 337 if (*loc) 338 { 339 SSA_NAME_IS_DEFAULT_DEF (*(tree *)loc) = false; 340 htab_clear_slot (DEFAULT_DEFS (fn), loc); 341 } 342 return; 343 } 344 gcc_assert (TREE_CODE (def) == SSA_NAME && SSA_NAME_VAR (def) == var); 345 loc = htab_find_slot_with_hash (DEFAULT_DEFS (fn), &in, 346 DECL_UID (var), INSERT); 347 348 /* Default definition might be changed by tail call optimization. */ 349 if (*loc) 350 SSA_NAME_IS_DEFAULT_DEF (*(tree *) loc) = false; 351 352 /* Mark DEF as the default definition for VAR. */ 353 *(tree *) loc = def; 354 SSA_NAME_IS_DEFAULT_DEF (def) = true; 355 } 356 357 /* Retrieve or create a default definition for VAR. */ 358 359 tree 360 get_or_create_ssa_default_def (struct function *fn, tree var) 361 { 362 tree ddef = ssa_default_def (fn, var); 363 if (ddef == NULL_TREE) 364 { 365 ddef = make_ssa_name_fn (fn, var, gimple_build_nop ()); 366 set_ssa_default_def (fn, var, ddef); 367 } 368 return ddef; 369 } 370 371 372 /* If EXP is a handled component reference for a structure, return the 373 base variable. The access range is delimited by bit positions *POFFSET and 374 *POFFSET + *PMAX_SIZE. The access size is *PSIZE bits. If either 375 *PSIZE or *PMAX_SIZE is -1, they could not be determined. If *PSIZE 376 and *PMAX_SIZE are equal, the access is non-variable. */ 377 378 tree 379 get_ref_base_and_extent (tree exp, HOST_WIDE_INT *poffset, 380 HOST_WIDE_INT *psize, 381 HOST_WIDE_INT *pmax_size) 382 { 383 HOST_WIDE_INT bitsize = -1; 384 HOST_WIDE_INT maxsize = -1; 385 tree size_tree = NULL_TREE; 386 double_int bit_offset = double_int_zero; 387 HOST_WIDE_INT hbit_offset; 388 bool seen_variable_array_ref = false; 389 390 /* First get the final access size from just the outermost expression. */ 391 if (TREE_CODE (exp) == COMPONENT_REF) 392 size_tree = DECL_SIZE (TREE_OPERAND (exp, 1)); 393 else if (TREE_CODE (exp) == BIT_FIELD_REF) 394 size_tree = TREE_OPERAND (exp, 1); 395 else if (!VOID_TYPE_P (TREE_TYPE (exp))) 396 { 397 enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp)); 398 if (mode == BLKmode) 399 size_tree = TYPE_SIZE (TREE_TYPE (exp)); 400 else 401 bitsize = GET_MODE_BITSIZE (mode); 402 } 403 if (size_tree != NULL_TREE) 404 { 405 if (! host_integerp (size_tree, 1)) 406 bitsize = -1; 407 else 408 bitsize = TREE_INT_CST_LOW (size_tree); 409 } 410 411 /* Initially, maxsize is the same as the accessed element size. 412 In the following it will only grow (or become -1). */ 413 maxsize = bitsize; 414 415 /* Compute cumulative bit-offset for nested component-refs and array-refs, 416 and find the ultimate containing object. */ 417 while (1) 418 { 419 switch (TREE_CODE (exp)) 420 { 421 case BIT_FIELD_REF: 422 bit_offset += tree_to_double_int (TREE_OPERAND (exp, 2)); 423 break; 424 425 case COMPONENT_REF: 426 { 427 tree field = TREE_OPERAND (exp, 1); 428 tree this_offset = component_ref_field_offset (exp); 429 430 if (this_offset && TREE_CODE (this_offset) == INTEGER_CST) 431 { 432 double_int doffset = tree_to_double_int (this_offset); 433 doffset = doffset.alshift (BITS_PER_UNIT == 8 434 ? 3 : exact_log2 (BITS_PER_UNIT), 435 HOST_BITS_PER_DOUBLE_INT); 436 doffset += tree_to_double_int (DECL_FIELD_BIT_OFFSET (field)); 437 bit_offset = bit_offset + doffset; 438 439 /* If we had seen a variable array ref already and we just 440 referenced the last field of a struct or a union member 441 then we have to adjust maxsize by the padding at the end 442 of our field. */ 443 if (seen_variable_array_ref && maxsize != -1) 444 { 445 tree stype = TREE_TYPE (TREE_OPERAND (exp, 0)); 446 tree next = DECL_CHAIN (field); 447 while (next && TREE_CODE (next) != FIELD_DECL) 448 next = DECL_CHAIN (next); 449 if (!next 450 || TREE_CODE (stype) != RECORD_TYPE) 451 { 452 tree fsize = DECL_SIZE_UNIT (field); 453 tree ssize = TYPE_SIZE_UNIT (stype); 454 if (host_integerp (fsize, 0) 455 && host_integerp (ssize, 0) 456 && doffset.fits_shwi ()) 457 maxsize += ((TREE_INT_CST_LOW (ssize) 458 - TREE_INT_CST_LOW (fsize)) 459 * BITS_PER_UNIT 460 - doffset.to_shwi ()); 461 else 462 maxsize = -1; 463 } 464 } 465 } 466 else 467 { 468 tree csize = TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp, 0))); 469 /* We need to adjust maxsize to the whole structure bitsize. 470 But we can subtract any constant offset seen so far, 471 because that would get us out of the structure otherwise. */ 472 if (maxsize != -1 473 && csize 474 && host_integerp (csize, 1) 475 && bit_offset.fits_shwi ()) 476 maxsize = TREE_INT_CST_LOW (csize) 477 - bit_offset.to_shwi (); 478 else 479 maxsize = -1; 480 } 481 } 482 break; 483 484 case ARRAY_REF: 485 case ARRAY_RANGE_REF: 486 { 487 tree index = TREE_OPERAND (exp, 1); 488 tree low_bound, unit_size; 489 490 /* If the resulting bit-offset is constant, track it. */ 491 if (TREE_CODE (index) == INTEGER_CST 492 && (low_bound = array_ref_low_bound (exp), 493 TREE_CODE (low_bound) == INTEGER_CST) 494 && (unit_size = array_ref_element_size (exp), 495 TREE_CODE (unit_size) == INTEGER_CST)) 496 { 497 double_int doffset 498 = (TREE_INT_CST (index) - TREE_INT_CST (low_bound)) 499 .sext (TYPE_PRECISION (TREE_TYPE (index))); 500 doffset *= tree_to_double_int (unit_size); 501 doffset = doffset.alshift (BITS_PER_UNIT == 8 502 ? 3 : exact_log2 (BITS_PER_UNIT), 503 HOST_BITS_PER_DOUBLE_INT); 504 bit_offset = bit_offset + doffset; 505 506 /* An array ref with a constant index up in the structure 507 hierarchy will constrain the size of any variable array ref 508 lower in the access hierarchy. */ 509 seen_variable_array_ref = false; 510 } 511 else 512 { 513 tree asize = TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp, 0))); 514 /* We need to adjust maxsize to the whole array bitsize. 515 But we can subtract any constant offset seen so far, 516 because that would get us outside of the array otherwise. */ 517 if (maxsize != -1 518 && asize 519 && host_integerp (asize, 1) 520 && bit_offset.fits_shwi ()) 521 maxsize = TREE_INT_CST_LOW (asize) 522 - bit_offset.to_shwi (); 523 else 524 maxsize = -1; 525 526 /* Remember that we have seen an array ref with a variable 527 index. */ 528 seen_variable_array_ref = true; 529 } 530 } 531 break; 532 533 case REALPART_EXPR: 534 break; 535 536 case IMAGPART_EXPR: 537 bit_offset += double_int::from_uhwi (bitsize); 538 break; 539 540 case VIEW_CONVERT_EXPR: 541 break; 542 543 case TARGET_MEM_REF: 544 /* Via the variable index or index2 we can reach the 545 whole object. Still hand back the decl here. */ 546 if (TREE_CODE (TMR_BASE (exp)) == ADDR_EXPR 547 && (TMR_INDEX (exp) || TMR_INDEX2 (exp))) 548 { 549 exp = TREE_OPERAND (TMR_BASE (exp), 0); 550 bit_offset = double_int_zero; 551 maxsize = -1; 552 goto done; 553 } 554 /* Fallthru. */ 555 case MEM_REF: 556 /* We need to deal with variable arrays ending structures such as 557 struct { int length; int a[1]; } x; x.a[d] 558 struct { struct { int a; int b; } a[1]; } x; x.a[d].a 559 struct { struct { int a[1]; } a[1]; } x; x.a[0][d], x.a[d][0] 560 struct { int len; union { int a[1]; struct X x; } u; } x; x.u.a[d] 561 where we do not know maxsize for variable index accesses to 562 the array. The simplest way to conservatively deal with this 563 is to punt in the case that offset + maxsize reaches the 564 base type boundary. This needs to include possible trailing 565 padding that is there for alignment purposes. */ 566 if (seen_variable_array_ref 567 && maxsize != -1 568 && (!bit_offset.fits_shwi () 569 || !host_integerp (TYPE_SIZE (TREE_TYPE (exp)), 1) 570 || (bit_offset.to_shwi () + maxsize 571 == (HOST_WIDE_INT) TREE_INT_CST_LOW 572 (TYPE_SIZE (TREE_TYPE (exp)))))) 573 maxsize = -1; 574 575 /* Hand back the decl for MEM[&decl, off]. */ 576 if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR) 577 { 578 if (integer_zerop (TREE_OPERAND (exp, 1))) 579 exp = TREE_OPERAND (TREE_OPERAND (exp, 0), 0); 580 else 581 { 582 double_int off = mem_ref_offset (exp); 583 off = off.alshift (BITS_PER_UNIT == 8 584 ? 3 : exact_log2 (BITS_PER_UNIT), 585 HOST_BITS_PER_DOUBLE_INT); 586 off = off + bit_offset; 587 if (off.fits_shwi ()) 588 { 589 bit_offset = off; 590 exp = TREE_OPERAND (TREE_OPERAND (exp, 0), 0); 591 } 592 } 593 } 594 goto done; 595 596 default: 597 goto done; 598 } 599 600 exp = TREE_OPERAND (exp, 0); 601 } 602 603 /* We need to deal with variable arrays ending structures. */ 604 if (seen_variable_array_ref 605 && maxsize != -1 606 && (!bit_offset.fits_shwi () 607 || !host_integerp (TYPE_SIZE (TREE_TYPE (exp)), 1) 608 || (bit_offset.to_shwi () + maxsize 609 == (HOST_WIDE_INT) 610 TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (exp)))))) 611 maxsize = -1; 612 613 done: 614 if (!bit_offset.fits_shwi ()) 615 { 616 *poffset = 0; 617 *psize = bitsize; 618 *pmax_size = -1; 619 620 return exp; 621 } 622 623 hbit_offset = bit_offset.to_shwi (); 624 625 /* In case of a decl or constant base object we can do better. */ 626 627 if (DECL_P (exp)) 628 { 629 /* If maxsize is unknown adjust it according to the size of the 630 base decl. */ 631 if (maxsize == -1 632 && host_integerp (DECL_SIZE (exp), 1)) 633 maxsize = TREE_INT_CST_LOW (DECL_SIZE (exp)) - hbit_offset; 634 } 635 else if (CONSTANT_CLASS_P (exp)) 636 { 637 /* If maxsize is unknown adjust it according to the size of the 638 base type constant. */ 639 if (maxsize == -1 640 && host_integerp (TYPE_SIZE (TREE_TYPE (exp)), 1)) 641 maxsize = TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (exp))) - hbit_offset; 642 } 643 644 /* ??? Due to negative offsets in ARRAY_REF we can end up with 645 negative bit_offset here. We might want to store a zero offset 646 in this case. */ 647 *poffset = hbit_offset; 648 *psize = bitsize; 649 *pmax_size = maxsize; 650 651 return exp; 652 } 653 654 /* Returns the base object and a constant BITS_PER_UNIT offset in *POFFSET that 655 denotes the starting address of the memory access EXP. 656 Returns NULL_TREE if the offset is not constant or any component 657 is not BITS_PER_UNIT-aligned. */ 658 659 tree 660 get_addr_base_and_unit_offset (tree exp, HOST_WIDE_INT *poffset) 661 { 662 return get_addr_base_and_unit_offset_1 (exp, poffset, NULL); 663 } 664 665 /* Returns true if STMT references an SSA_NAME that has 666 SSA_NAME_OCCURS_IN_ABNORMAL_PHI set, otherwise false. */ 667 668 bool 669 stmt_references_abnormal_ssa_name (gimple stmt) 670 { 671 ssa_op_iter oi; 672 use_operand_p use_p; 673 674 FOR_EACH_SSA_USE_OPERAND (use_p, stmt, oi, SSA_OP_USE) 675 { 676 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (USE_FROM_PTR (use_p))) 677 return true; 678 } 679 680 return false; 681 } 682 683 /* Pair of tree and a sorting index, for dump_enumerated_decls. */ 684 struct GTY(()) numbered_tree_d 685 { 686 tree t; 687 int num; 688 }; 689 typedef struct numbered_tree_d numbered_tree; 690 691 692 /* Compare two declarations references by their DECL_UID / sequence number. 693 Called via qsort. */ 694 695 static int 696 compare_decls_by_uid (const void *pa, const void *pb) 697 { 698 const numbered_tree *nt_a = ((const numbered_tree *)pa); 699 const numbered_tree *nt_b = ((const numbered_tree *)pb); 700 701 if (DECL_UID (nt_a->t) != DECL_UID (nt_b->t)) 702 return DECL_UID (nt_a->t) - DECL_UID (nt_b->t); 703 return nt_a->num - nt_b->num; 704 } 705 706 /* Called via walk_gimple_stmt / walk_gimple_op by dump_enumerated_decls. */ 707 static tree 708 dump_enumerated_decls_push (tree *tp, int *walk_subtrees, void *data) 709 { 710 struct walk_stmt_info *wi = (struct walk_stmt_info *) data; 711 vec<numbered_tree> *list = (vec<numbered_tree> *) wi->info; 712 numbered_tree nt; 713 714 if (!DECL_P (*tp)) 715 return NULL_TREE; 716 nt.t = *tp; 717 nt.num = list->length (); 718 list->safe_push (nt); 719 *walk_subtrees = 0; 720 return NULL_TREE; 721 } 722 723 /* Find all the declarations used by the current function, sort them by uid, 724 and emit the sorted list. Each declaration is tagged with a sequence 725 number indicating when it was found during statement / tree walking, 726 so that TDF_NOUID comparisons of anonymous declarations are still 727 meaningful. Where a declaration was encountered more than once, we 728 emit only the sequence number of the first encounter. 729 FILE is the dump file where to output the list and FLAGS is as in 730 print_generic_expr. */ 731 void 732 dump_enumerated_decls (FILE *file, int flags) 733 { 734 basic_block bb; 735 struct walk_stmt_info wi; 736 vec<numbered_tree> decl_list; 737 decl_list.create (40); 738 739 memset (&wi, '\0', sizeof (wi)); 740 wi.info = (void *) &decl_list; 741 FOR_EACH_BB (bb) 742 { 743 gimple_stmt_iterator gsi; 744 745 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) 746 if (!is_gimple_debug (gsi_stmt (gsi))) 747 walk_gimple_stmt (&gsi, NULL, dump_enumerated_decls_push, &wi); 748 } 749 decl_list.qsort (compare_decls_by_uid); 750 if (decl_list.length ()) 751 { 752 unsigned ix; 753 numbered_tree *ntp; 754 tree last = NULL_TREE; 755 756 fprintf (file, "Declarations used by %s, sorted by DECL_UID:\n", 757 current_function_name ()); 758 FOR_EACH_VEC_ELT (decl_list, ix, ntp) 759 { 760 if (ntp->t == last) 761 continue; 762 fprintf (file, "%d: ", ntp->num); 763 print_generic_decl (file, ntp->t, flags); 764 fprintf (file, "\n"); 765 last = ntp->t; 766 } 767 } 768 decl_list.release (); 769 } 770