1 /* Inline functions for tree-flow.h 2 Copyright (C) 2001-2013 Free Software Foundation, Inc. 3 Contributed by Diego Novillo <dnovillo (at) 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 #ifndef _TREE_FLOW_INLINE_H 22 #define _TREE_FLOW_INLINE_H 1 23 24 /* Inline functions for manipulating various data structures defined in 25 tree-flow.h. See tree-flow.h for documentation. */ 26 27 /* Return true when gimple SSA form was built. 28 gimple_in_ssa_p is queried by gimplifier in various early stages before SSA 29 infrastructure is initialized. Check for presence of the datastructures 30 at first place. */ 31 static inline bool 32 gimple_in_ssa_p (const struct function *fun) 33 { 34 return fun && fun->gimple_df && fun->gimple_df->in_ssa_p; 35 } 36 37 /* Artificial variable used for the virtual operand FUD chain. */ 38 static inline tree 39 gimple_vop (const struct function *fun) 40 { 41 gcc_checking_assert (fun && fun->gimple_df); 42 return fun->gimple_df->vop; 43 } 44 45 /* Initialize the hashtable iterator HTI to point to hashtable TABLE */ 46 47 static inline void * 48 first_htab_element (htab_iterator *hti, htab_t table) 49 { 50 hti->htab = table; 51 hti->slot = table->entries; 52 hti->limit = hti->slot + htab_size (table); 53 do 54 { 55 PTR x = *(hti->slot); 56 if (x != HTAB_EMPTY_ENTRY && x != HTAB_DELETED_ENTRY) 57 break; 58 } while (++(hti->slot) < hti->limit); 59 60 if (hti->slot < hti->limit) 61 return *(hti->slot); 62 return NULL; 63 } 64 65 /* Return current non-empty/deleted slot of the hashtable pointed to by HTI, 66 or NULL if we have reached the end. */ 67 68 static inline bool 69 end_htab_p (const htab_iterator *hti) 70 { 71 if (hti->slot >= hti->limit) 72 return true; 73 return false; 74 } 75 76 /* Advance the hashtable iterator pointed to by HTI to the next element of the 77 hashtable. */ 78 79 static inline void * 80 next_htab_element (htab_iterator *hti) 81 { 82 while (++(hti->slot) < hti->limit) 83 { 84 PTR x = *(hti->slot); 85 if (x != HTAB_EMPTY_ENTRY && x != HTAB_DELETED_ENTRY) 86 return x; 87 }; 88 return NULL; 89 } 90 91 /* Get the number of the next statement uid to be allocated. */ 92 static inline unsigned int 93 gimple_stmt_max_uid (struct function *fn) 94 { 95 return fn->last_stmt_uid; 96 } 97 98 /* Set the number of the next statement uid to be allocated. */ 99 static inline void 100 set_gimple_stmt_max_uid (struct function *fn, unsigned int maxid) 101 { 102 fn->last_stmt_uid = maxid; 103 } 104 105 /* Set the number of the next statement uid to be allocated. */ 106 static inline unsigned int 107 inc_gimple_stmt_max_uid (struct function *fn) 108 { 109 return fn->last_stmt_uid++; 110 } 111 112 /* Return the line number for EXPR, or return -1 if we have no line 113 number information for it. */ 114 static inline int 115 get_lineno (const_gimple stmt) 116 { 117 location_t loc; 118 119 if (!stmt) 120 return -1; 121 122 loc = gimple_location (stmt); 123 if (loc == UNKNOWN_LOCATION) 124 return -1; 125 126 return LOCATION_LINE (loc); 127 } 128 129 /* Delink an immediate_uses node from its chain. */ 130 static inline void 131 delink_imm_use (ssa_use_operand_t *linknode) 132 { 133 /* Return if this node is not in a list. */ 134 if (linknode->prev == NULL) 135 return; 136 137 linknode->prev->next = linknode->next; 138 linknode->next->prev = linknode->prev; 139 linknode->prev = NULL; 140 linknode->next = NULL; 141 } 142 143 /* Link ssa_imm_use node LINKNODE into the chain for LIST. */ 144 static inline void 145 link_imm_use_to_list (ssa_use_operand_t *linknode, ssa_use_operand_t *list) 146 { 147 /* Link the new node at the head of the list. If we are in the process of 148 traversing the list, we won't visit any new nodes added to it. */ 149 linknode->prev = list; 150 linknode->next = list->next; 151 list->next->prev = linknode; 152 list->next = linknode; 153 } 154 155 /* Link ssa_imm_use node LINKNODE into the chain for DEF. */ 156 static inline void 157 link_imm_use (ssa_use_operand_t *linknode, tree def) 158 { 159 ssa_use_operand_t *root; 160 161 if (!def || TREE_CODE (def) != SSA_NAME) 162 linknode->prev = NULL; 163 else 164 { 165 root = &(SSA_NAME_IMM_USE_NODE (def)); 166 if (linknode->use) 167 gcc_checking_assert (*(linknode->use) == def); 168 link_imm_use_to_list (linknode, root); 169 } 170 } 171 172 /* Set the value of a use pointed to by USE to VAL. */ 173 static inline void 174 set_ssa_use_from_ptr (use_operand_p use, tree val) 175 { 176 delink_imm_use (use); 177 *(use->use) = val; 178 link_imm_use (use, val); 179 } 180 181 /* Link ssa_imm_use node LINKNODE into the chain for DEF, with use occurring 182 in STMT. */ 183 static inline void 184 link_imm_use_stmt (ssa_use_operand_t *linknode, tree def, gimple stmt) 185 { 186 if (stmt) 187 link_imm_use (linknode, def); 188 else 189 link_imm_use (linknode, NULL); 190 linknode->loc.stmt = stmt; 191 } 192 193 /* Relink a new node in place of an old node in the list. */ 194 static inline void 195 relink_imm_use (ssa_use_operand_t *node, ssa_use_operand_t *old) 196 { 197 /* The node one had better be in the same list. */ 198 gcc_checking_assert (*(old->use) == *(node->use)); 199 node->prev = old->prev; 200 node->next = old->next; 201 if (old->prev) 202 { 203 old->prev->next = node; 204 old->next->prev = node; 205 /* Remove the old node from the list. */ 206 old->prev = NULL; 207 } 208 } 209 210 /* Relink ssa_imm_use node LINKNODE into the chain for OLD, with use occurring 211 in STMT. */ 212 static inline void 213 relink_imm_use_stmt (ssa_use_operand_t *linknode, ssa_use_operand_t *old, 214 gimple stmt) 215 { 216 if (stmt) 217 relink_imm_use (linknode, old); 218 else 219 link_imm_use (linknode, NULL); 220 linknode->loc.stmt = stmt; 221 } 222 223 224 /* Return true is IMM has reached the end of the immediate use list. */ 225 static inline bool 226 end_readonly_imm_use_p (const imm_use_iterator *imm) 227 { 228 return (imm->imm_use == imm->end_p); 229 } 230 231 /* Initialize iterator IMM to process the list for VAR. */ 232 static inline use_operand_p 233 first_readonly_imm_use (imm_use_iterator *imm, tree var) 234 { 235 imm->end_p = &(SSA_NAME_IMM_USE_NODE (var)); 236 imm->imm_use = imm->end_p->next; 237 #ifdef ENABLE_CHECKING 238 imm->iter_node.next = imm->imm_use->next; 239 #endif 240 if (end_readonly_imm_use_p (imm)) 241 return NULL_USE_OPERAND_P; 242 return imm->imm_use; 243 } 244 245 /* Bump IMM to the next use in the list. */ 246 static inline use_operand_p 247 next_readonly_imm_use (imm_use_iterator *imm) 248 { 249 use_operand_p old = imm->imm_use; 250 251 #ifdef ENABLE_CHECKING 252 /* If this assertion fails, it indicates the 'next' pointer has changed 253 since the last bump. This indicates that the list is being modified 254 via stmt changes, or SET_USE, or somesuch thing, and you need to be 255 using the SAFE version of the iterator. */ 256 gcc_assert (imm->iter_node.next == old->next); 257 imm->iter_node.next = old->next->next; 258 #endif 259 260 imm->imm_use = old->next; 261 if (end_readonly_imm_use_p (imm)) 262 return NULL_USE_OPERAND_P; 263 return imm->imm_use; 264 } 265 266 /* tree-cfg.c */ 267 extern bool has_zero_uses_1 (const ssa_use_operand_t *head); 268 extern bool single_imm_use_1 (const ssa_use_operand_t *head, 269 use_operand_p *use_p, gimple *stmt); 270 271 /* Return true if VAR has no nondebug uses. */ 272 static inline bool 273 has_zero_uses (const_tree var) 274 { 275 const ssa_use_operand_t *const ptr = &(SSA_NAME_IMM_USE_NODE (var)); 276 277 /* A single use_operand means there is no items in the list. */ 278 if (ptr == ptr->next) 279 return true; 280 281 /* If there are debug stmts, we have to look at each use and see 282 whether there are any nondebug uses. */ 283 if (!MAY_HAVE_DEBUG_STMTS) 284 return false; 285 286 return has_zero_uses_1 (ptr); 287 } 288 289 /* Return true if VAR has a single nondebug use. */ 290 static inline bool 291 has_single_use (const_tree var) 292 { 293 const ssa_use_operand_t *const ptr = &(SSA_NAME_IMM_USE_NODE (var)); 294 295 /* If there aren't any uses whatsoever, we're done. */ 296 if (ptr == ptr->next) 297 return false; 298 299 /* If there's a single use, check that it's not a debug stmt. */ 300 if (ptr == ptr->next->next) 301 return !is_gimple_debug (USE_STMT (ptr->next)); 302 303 /* If there are debug stmts, we have to look at each of them. */ 304 if (!MAY_HAVE_DEBUG_STMTS) 305 return false; 306 307 return single_imm_use_1 (ptr, NULL, NULL); 308 } 309 310 311 /* If VAR has only a single immediate nondebug use, return true, and 312 set USE_P and STMT to the use pointer and stmt of occurrence. */ 313 static inline bool 314 single_imm_use (const_tree var, use_operand_p *use_p, gimple *stmt) 315 { 316 const ssa_use_operand_t *const ptr = &(SSA_NAME_IMM_USE_NODE (var)); 317 318 /* If there aren't any uses whatsoever, we're done. */ 319 if (ptr == ptr->next) 320 { 321 return_false: 322 *use_p = NULL_USE_OPERAND_P; 323 *stmt = NULL; 324 return false; 325 } 326 327 /* If there's a single use, check that it's not a debug stmt. */ 328 if (ptr == ptr->next->next) 329 { 330 if (!is_gimple_debug (USE_STMT (ptr->next))) 331 { 332 *use_p = ptr->next; 333 *stmt = ptr->next->loc.stmt; 334 return true; 335 } 336 else 337 goto return_false; 338 } 339 340 /* If there are debug stmts, we have to look at each of them. */ 341 if (!MAY_HAVE_DEBUG_STMTS) 342 goto return_false; 343 344 return single_imm_use_1 (ptr, use_p, stmt); 345 } 346 347 /* Return the number of nondebug immediate uses of VAR. */ 348 static inline unsigned int 349 num_imm_uses (const_tree var) 350 { 351 const ssa_use_operand_t *const start = &(SSA_NAME_IMM_USE_NODE (var)); 352 const ssa_use_operand_t *ptr; 353 unsigned int num = 0; 354 355 if (!MAY_HAVE_DEBUG_STMTS) 356 for (ptr = start->next; ptr != start; ptr = ptr->next) 357 num++; 358 else 359 for (ptr = start->next; ptr != start; ptr = ptr->next) 360 if (!is_gimple_debug (USE_STMT (ptr))) 361 num++; 362 363 return num; 364 } 365 366 /* Return the tree pointed-to by USE. */ 367 static inline tree 368 get_use_from_ptr (use_operand_p use) 369 { 370 return *(use->use); 371 } 372 373 /* Return the tree pointed-to by DEF. */ 374 static inline tree 375 get_def_from_ptr (def_operand_p def) 376 { 377 return *def; 378 } 379 380 /* Return a use_operand_p pointer for argument I of PHI node GS. */ 381 382 static inline use_operand_p 383 gimple_phi_arg_imm_use_ptr (gimple gs, int i) 384 { 385 return &gimple_phi_arg (gs, i)->imm_use; 386 } 387 388 /* Return the tree operand for argument I of PHI node GS. */ 389 390 static inline tree 391 gimple_phi_arg_def (gimple gs, size_t index) 392 { 393 struct phi_arg_d *pd = gimple_phi_arg (gs, index); 394 return get_use_from_ptr (&pd->imm_use); 395 } 396 397 /* Return a pointer to the tree operand for argument I of PHI node GS. */ 398 399 static inline tree * 400 gimple_phi_arg_def_ptr (gimple gs, size_t index) 401 { 402 return &gimple_phi_arg (gs, index)->def; 403 } 404 405 /* Return the edge associated with argument I of phi node GS. */ 406 407 static inline edge 408 gimple_phi_arg_edge (gimple gs, size_t i) 409 { 410 return EDGE_PRED (gimple_bb (gs), i); 411 } 412 413 /* Return the source location of gimple argument I of phi node GS. */ 414 415 static inline source_location 416 gimple_phi_arg_location (gimple gs, size_t i) 417 { 418 return gimple_phi_arg (gs, i)->locus; 419 } 420 421 /* Return the source location of the argument on edge E of phi node GS. */ 422 423 static inline source_location 424 gimple_phi_arg_location_from_edge (gimple gs, edge e) 425 { 426 return gimple_phi_arg (gs, e->dest_idx)->locus; 427 } 428 429 /* Set the source location of gimple argument I of phi node GS to LOC. */ 430 431 static inline void 432 gimple_phi_arg_set_location (gimple gs, size_t i, source_location loc) 433 { 434 gimple_phi_arg (gs, i)->locus = loc; 435 } 436 437 /* Return TRUE if argument I of phi node GS has a location record. */ 438 439 static inline bool 440 gimple_phi_arg_has_location (gimple gs, size_t i) 441 { 442 return gimple_phi_arg_location (gs, i) != UNKNOWN_LOCATION; 443 } 444 445 446 /* Return the PHI nodes for basic block BB, or NULL if there are no 447 PHI nodes. */ 448 static inline gimple_seq 449 phi_nodes (const_basic_block bb) 450 { 451 gcc_checking_assert (!(bb->flags & BB_RTL)); 452 return bb->il.gimple.phi_nodes; 453 } 454 455 static inline gimple_seq * 456 phi_nodes_ptr (basic_block bb) 457 { 458 gcc_checking_assert (!(bb->flags & BB_RTL)); 459 return &bb->il.gimple.phi_nodes; 460 } 461 462 /* Set PHI nodes of a basic block BB to SEQ. */ 463 464 static inline void 465 set_phi_nodes (basic_block bb, gimple_seq seq) 466 { 467 gimple_stmt_iterator i; 468 469 gcc_checking_assert (!(bb->flags & BB_RTL)); 470 bb->il.gimple.phi_nodes = seq; 471 if (seq) 472 for (i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i)) 473 gimple_set_bb (gsi_stmt (i), bb); 474 } 475 476 /* Return the phi argument which contains the specified use. */ 477 478 static inline int 479 phi_arg_index_from_use (use_operand_p use) 480 { 481 struct phi_arg_d *element, *root; 482 size_t index; 483 gimple phi; 484 485 /* Since the use is the first thing in a PHI argument element, we can 486 calculate its index based on casting it to an argument, and performing 487 pointer arithmetic. */ 488 489 phi = USE_STMT (use); 490 491 element = (struct phi_arg_d *)use; 492 root = gimple_phi_arg (phi, 0); 493 index = element - root; 494 495 /* Make sure the calculation doesn't have any leftover bytes. If it does, 496 then imm_use is likely not the first element in phi_arg_d. */ 497 gcc_checking_assert ((((char *)element - (char *)root) 498 % sizeof (struct phi_arg_d)) == 0 499 && index < gimple_phi_capacity (phi)); 500 501 return index; 502 } 503 504 /* Return true if T (assumed to be a DECL) is a global variable. 505 A variable is considered global if its storage is not automatic. */ 506 507 static inline bool 508 is_global_var (const_tree t) 509 { 510 return (TREE_STATIC (t) || DECL_EXTERNAL (t)); 511 } 512 513 514 /* Return true if VAR may be aliased. A variable is considered as 515 maybe aliased if it has its address taken by the local TU 516 or possibly by another TU and might be modified through a pointer. */ 517 518 static inline bool 519 may_be_aliased (const_tree var) 520 { 521 return (TREE_CODE (var) != CONST_DECL 522 && !((TREE_STATIC (var) || TREE_PUBLIC (var) || DECL_EXTERNAL (var)) 523 && TREE_READONLY (var) 524 && !TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (var))) 525 && (TREE_PUBLIC (var) 526 || DECL_EXTERNAL (var) 527 || TREE_ADDRESSABLE (var))); 528 } 529 530 531 /* PHI nodes should contain only ssa_names and invariants. A test 532 for ssa_name is definitely simpler; don't let invalid contents 533 slip in in the meantime. */ 534 535 static inline bool 536 phi_ssa_name_p (const_tree t) 537 { 538 if (TREE_CODE (t) == SSA_NAME) 539 return true; 540 gcc_checking_assert (is_gimple_min_invariant (t)); 541 return false; 542 } 543 544 545 /* Returns the loop of the statement STMT. */ 546 547 static inline struct loop * 548 loop_containing_stmt (gimple stmt) 549 { 550 basic_block bb = gimple_bb (stmt); 551 if (!bb) 552 return NULL; 553 554 return bb->loop_father; 555 } 556 557 558 /* ----------------------------------------------------------------------- */ 559 560 /* The following set of routines are used to iterator over various type of 561 SSA operands. */ 562 563 /* Return true if PTR is finished iterating. */ 564 static inline bool 565 op_iter_done (const ssa_op_iter *ptr) 566 { 567 return ptr->done; 568 } 569 570 /* Get the next iterator use value for PTR. */ 571 static inline use_operand_p 572 op_iter_next_use (ssa_op_iter *ptr) 573 { 574 use_operand_p use_p; 575 gcc_checking_assert (ptr->iter_type == ssa_op_iter_use); 576 if (ptr->uses) 577 { 578 use_p = USE_OP_PTR (ptr->uses); 579 ptr->uses = ptr->uses->next; 580 return use_p; 581 } 582 if (ptr->i < ptr->numops) 583 { 584 return PHI_ARG_DEF_PTR (ptr->stmt, (ptr->i)++); 585 } 586 ptr->done = true; 587 return NULL_USE_OPERAND_P; 588 } 589 590 /* Get the next iterator def value for PTR. */ 591 static inline def_operand_p 592 op_iter_next_def (ssa_op_iter *ptr) 593 { 594 gcc_checking_assert (ptr->iter_type == ssa_op_iter_def); 595 if (ptr->flags & SSA_OP_VDEF) 596 { 597 tree *p; 598 ptr->flags &= ~SSA_OP_VDEF; 599 p = gimple_vdef_ptr (ptr->stmt); 600 if (p && *p) 601 return p; 602 } 603 if (ptr->flags & SSA_OP_DEF) 604 { 605 while (ptr->i < ptr->numops) 606 { 607 tree *val = gimple_op_ptr (ptr->stmt, ptr->i); 608 ptr->i++; 609 if (*val) 610 { 611 if (TREE_CODE (*val) == TREE_LIST) 612 val = &TREE_VALUE (*val); 613 if (TREE_CODE (*val) == SSA_NAME 614 || is_gimple_reg (*val)) 615 return val; 616 } 617 } 618 ptr->flags &= ~SSA_OP_DEF; 619 } 620 621 ptr->done = true; 622 return NULL_DEF_OPERAND_P; 623 } 624 625 /* Get the next iterator tree value for PTR. */ 626 static inline tree 627 op_iter_next_tree (ssa_op_iter *ptr) 628 { 629 tree val; 630 gcc_checking_assert (ptr->iter_type == ssa_op_iter_tree); 631 if (ptr->uses) 632 { 633 val = USE_OP (ptr->uses); 634 ptr->uses = ptr->uses->next; 635 return val; 636 } 637 if (ptr->flags & SSA_OP_VDEF) 638 { 639 ptr->flags &= ~SSA_OP_VDEF; 640 if ((val = gimple_vdef (ptr->stmt))) 641 return val; 642 } 643 if (ptr->flags & SSA_OP_DEF) 644 { 645 while (ptr->i < ptr->numops) 646 { 647 val = gimple_op (ptr->stmt, ptr->i); 648 ptr->i++; 649 if (val) 650 { 651 if (TREE_CODE (val) == TREE_LIST) 652 val = TREE_VALUE (val); 653 if (TREE_CODE (val) == SSA_NAME 654 || is_gimple_reg (val)) 655 return val; 656 } 657 } 658 ptr->flags &= ~SSA_OP_DEF; 659 } 660 661 ptr->done = true; 662 return NULL_TREE; 663 } 664 665 666 /* This functions clears the iterator PTR, and marks it done. This is normally 667 used to prevent warnings in the compile about might be uninitialized 668 components. */ 669 670 static inline void 671 clear_and_done_ssa_iter (ssa_op_iter *ptr) 672 { 673 ptr->i = 0; 674 ptr->numops = 0; 675 ptr->uses = NULL; 676 ptr->iter_type = ssa_op_iter_none; 677 ptr->stmt = NULL; 678 ptr->done = true; 679 ptr->flags = 0; 680 } 681 682 /* Initialize the iterator PTR to the virtual defs in STMT. */ 683 static inline void 684 op_iter_init (ssa_op_iter *ptr, gimple stmt, int flags) 685 { 686 /* PHI nodes require a different iterator initialization path. We 687 do not support iterating over virtual defs or uses without 688 iterating over defs or uses at the same time. */ 689 gcc_checking_assert (gimple_code (stmt) != GIMPLE_PHI 690 && (!(flags & SSA_OP_VDEF) || (flags & SSA_OP_DEF)) 691 && (!(flags & SSA_OP_VUSE) || (flags & SSA_OP_USE))); 692 ptr->numops = 0; 693 if (flags & (SSA_OP_DEF | SSA_OP_VDEF)) 694 { 695 switch (gimple_code (stmt)) 696 { 697 case GIMPLE_ASSIGN: 698 case GIMPLE_CALL: 699 ptr->numops = 1; 700 break; 701 case GIMPLE_ASM: 702 ptr->numops = gimple_asm_noutputs (stmt); 703 break; 704 default: 705 ptr->numops = 0; 706 flags &= ~(SSA_OP_DEF | SSA_OP_VDEF); 707 break; 708 } 709 } 710 ptr->uses = (flags & (SSA_OP_USE|SSA_OP_VUSE)) ? gimple_use_ops (stmt) : NULL; 711 if (!(flags & SSA_OP_VUSE) 712 && ptr->uses 713 && gimple_vuse (stmt) != NULL_TREE) 714 ptr->uses = ptr->uses->next; 715 ptr->done = false; 716 ptr->i = 0; 717 718 ptr->stmt = stmt; 719 ptr->flags = flags; 720 } 721 722 /* Initialize iterator PTR to the use operands in STMT based on FLAGS. Return 723 the first use. */ 724 static inline use_operand_p 725 op_iter_init_use (ssa_op_iter *ptr, gimple stmt, int flags) 726 { 727 gcc_checking_assert ((flags & SSA_OP_ALL_DEFS) == 0 728 && (flags & SSA_OP_USE)); 729 op_iter_init (ptr, stmt, flags); 730 ptr->iter_type = ssa_op_iter_use; 731 return op_iter_next_use (ptr); 732 } 733 734 /* Initialize iterator PTR to the def operands in STMT based on FLAGS. Return 735 the first def. */ 736 static inline def_operand_p 737 op_iter_init_def (ssa_op_iter *ptr, gimple stmt, int flags) 738 { 739 gcc_checking_assert ((flags & SSA_OP_ALL_USES) == 0 740 && (flags & SSA_OP_DEF)); 741 op_iter_init (ptr, stmt, flags); 742 ptr->iter_type = ssa_op_iter_def; 743 return op_iter_next_def (ptr); 744 } 745 746 /* Initialize iterator PTR to the operands in STMT based on FLAGS. Return 747 the first operand as a tree. */ 748 static inline tree 749 op_iter_init_tree (ssa_op_iter *ptr, gimple stmt, int flags) 750 { 751 op_iter_init (ptr, stmt, flags); 752 ptr->iter_type = ssa_op_iter_tree; 753 return op_iter_next_tree (ptr); 754 } 755 756 757 /* If there is a single operand in STMT matching FLAGS, return it. Otherwise 758 return NULL. */ 759 static inline tree 760 single_ssa_tree_operand (gimple stmt, int flags) 761 { 762 tree var; 763 ssa_op_iter iter; 764 765 var = op_iter_init_tree (&iter, stmt, flags); 766 if (op_iter_done (&iter)) 767 return NULL_TREE; 768 op_iter_next_tree (&iter); 769 if (op_iter_done (&iter)) 770 return var; 771 return NULL_TREE; 772 } 773 774 775 /* If there is a single operand in STMT matching FLAGS, return it. Otherwise 776 return NULL. */ 777 static inline use_operand_p 778 single_ssa_use_operand (gimple stmt, int flags) 779 { 780 use_operand_p var; 781 ssa_op_iter iter; 782 783 var = op_iter_init_use (&iter, stmt, flags); 784 if (op_iter_done (&iter)) 785 return NULL_USE_OPERAND_P; 786 op_iter_next_use (&iter); 787 if (op_iter_done (&iter)) 788 return var; 789 return NULL_USE_OPERAND_P; 790 } 791 792 793 794 /* If there is a single operand in STMT matching FLAGS, return it. Otherwise 795 return NULL. */ 796 static inline def_operand_p 797 single_ssa_def_operand (gimple stmt, int flags) 798 { 799 def_operand_p var; 800 ssa_op_iter iter; 801 802 var = op_iter_init_def (&iter, stmt, flags); 803 if (op_iter_done (&iter)) 804 return NULL_DEF_OPERAND_P; 805 op_iter_next_def (&iter); 806 if (op_iter_done (&iter)) 807 return var; 808 return NULL_DEF_OPERAND_P; 809 } 810 811 812 /* Return true if there are zero operands in STMT matching the type 813 given in FLAGS. */ 814 static inline bool 815 zero_ssa_operands (gimple stmt, int flags) 816 { 817 ssa_op_iter iter; 818 819 op_iter_init_tree (&iter, stmt, flags); 820 return op_iter_done (&iter); 821 } 822 823 824 /* Return the number of operands matching FLAGS in STMT. */ 825 static inline int 826 num_ssa_operands (gimple stmt, int flags) 827 { 828 ssa_op_iter iter; 829 tree t; 830 int num = 0; 831 832 gcc_checking_assert (gimple_code (stmt) != GIMPLE_PHI); 833 FOR_EACH_SSA_TREE_OPERAND (t, stmt, iter, flags) 834 num++; 835 return num; 836 } 837 838 static inline use_operand_p 839 op_iter_init_phiuse (ssa_op_iter *ptr, gimple phi, int flags); 840 841 /* Delink all immediate_use information for STMT. */ 842 static inline void 843 delink_stmt_imm_use (gimple stmt) 844 { 845 ssa_op_iter iter; 846 use_operand_p use_p; 847 848 if (ssa_operands_active (cfun)) 849 FOR_EACH_PHI_OR_STMT_USE (use_p, stmt, iter, SSA_OP_ALL_USES) 850 delink_imm_use (use_p); 851 } 852 853 854 /* If there is a single DEF in the PHI node which matches FLAG, return it. 855 Otherwise return NULL_DEF_OPERAND_P. */ 856 static inline tree 857 single_phi_def (gimple stmt, int flags) 858 { 859 tree def = PHI_RESULT (stmt); 860 if ((flags & SSA_OP_DEF) && is_gimple_reg (def)) 861 return def; 862 if ((flags & SSA_OP_VIRTUAL_DEFS) && !is_gimple_reg (def)) 863 return def; 864 return NULL_TREE; 865 } 866 867 /* Initialize the iterator PTR for uses matching FLAGS in PHI. FLAGS should 868 be either SSA_OP_USES or SSA_OP_VIRTUAL_USES. */ 869 static inline use_operand_p 870 op_iter_init_phiuse (ssa_op_iter *ptr, gimple phi, int flags) 871 { 872 tree phi_def = gimple_phi_result (phi); 873 int comp; 874 875 clear_and_done_ssa_iter (ptr); 876 ptr->done = false; 877 878 gcc_checking_assert ((flags & (SSA_OP_USE | SSA_OP_VIRTUAL_USES)) != 0); 879 880 comp = (is_gimple_reg (phi_def) ? SSA_OP_USE : SSA_OP_VIRTUAL_USES); 881 882 /* If the PHI node doesn't the operand type we care about, we're done. */ 883 if ((flags & comp) == 0) 884 { 885 ptr->done = true; 886 return NULL_USE_OPERAND_P; 887 } 888 889 ptr->stmt = phi; 890 ptr->numops = gimple_phi_num_args (phi); 891 ptr->iter_type = ssa_op_iter_use; 892 ptr->flags = flags; 893 return op_iter_next_use (ptr); 894 } 895 896 897 /* Start an iterator for a PHI definition. */ 898 899 static inline def_operand_p 900 op_iter_init_phidef (ssa_op_iter *ptr, gimple phi, int flags) 901 { 902 tree phi_def = PHI_RESULT (phi); 903 int comp; 904 905 clear_and_done_ssa_iter (ptr); 906 ptr->done = false; 907 908 gcc_checking_assert ((flags & (SSA_OP_DEF | SSA_OP_VIRTUAL_DEFS)) != 0); 909 910 comp = (is_gimple_reg (phi_def) ? SSA_OP_DEF : SSA_OP_VIRTUAL_DEFS); 911 912 /* If the PHI node doesn't have the operand type we care about, 913 we're done. */ 914 if ((flags & comp) == 0) 915 { 916 ptr->done = true; 917 return NULL_DEF_OPERAND_P; 918 } 919 920 ptr->iter_type = ssa_op_iter_def; 921 /* The first call to op_iter_next_def will terminate the iterator since 922 all the fields are NULL. Simply return the result here as the first and 923 therefore only result. */ 924 return PHI_RESULT_PTR (phi); 925 } 926 927 /* Return true is IMM has reached the end of the immediate use stmt list. */ 928 929 static inline bool 930 end_imm_use_stmt_p (const imm_use_iterator *imm) 931 { 932 return (imm->imm_use == imm->end_p); 933 } 934 935 /* Finished the traverse of an immediate use stmt list IMM by removing the 936 placeholder node from the list. */ 937 938 static inline void 939 end_imm_use_stmt_traverse (imm_use_iterator *imm) 940 { 941 delink_imm_use (&(imm->iter_node)); 942 } 943 944 /* Immediate use traversal of uses within a stmt require that all the 945 uses on a stmt be sequentially listed. This routine is used to build up 946 this sequential list by adding USE_P to the end of the current list 947 currently delimited by HEAD and LAST_P. The new LAST_P value is 948 returned. */ 949 950 static inline use_operand_p 951 move_use_after_head (use_operand_p use_p, use_operand_p head, 952 use_operand_p last_p) 953 { 954 gcc_checking_assert (USE_FROM_PTR (use_p) == USE_FROM_PTR (head)); 955 /* Skip head when we find it. */ 956 if (use_p != head) 957 { 958 /* If use_p is already linked in after last_p, continue. */ 959 if (last_p->next == use_p) 960 last_p = use_p; 961 else 962 { 963 /* Delink from current location, and link in at last_p. */ 964 delink_imm_use (use_p); 965 link_imm_use_to_list (use_p, last_p); 966 last_p = use_p; 967 } 968 } 969 return last_p; 970 } 971 972 973 /* This routine will relink all uses with the same stmt as HEAD into the list 974 immediately following HEAD for iterator IMM. */ 975 976 static inline void 977 link_use_stmts_after (use_operand_p head, imm_use_iterator *imm) 978 { 979 use_operand_p use_p; 980 use_operand_p last_p = head; 981 gimple head_stmt = USE_STMT (head); 982 tree use = USE_FROM_PTR (head); 983 ssa_op_iter op_iter; 984 int flag; 985 986 /* Only look at virtual or real uses, depending on the type of HEAD. */ 987 flag = (is_gimple_reg (use) ? SSA_OP_USE : SSA_OP_VIRTUAL_USES); 988 989 if (gimple_code (head_stmt) == GIMPLE_PHI) 990 { 991 FOR_EACH_PHI_ARG (use_p, head_stmt, op_iter, flag) 992 if (USE_FROM_PTR (use_p) == use) 993 last_p = move_use_after_head (use_p, head, last_p); 994 } 995 else 996 { 997 if (flag == SSA_OP_USE) 998 { 999 FOR_EACH_SSA_USE_OPERAND (use_p, head_stmt, op_iter, flag) 1000 if (USE_FROM_PTR (use_p) == use) 1001 last_p = move_use_after_head (use_p, head, last_p); 1002 } 1003 else if ((use_p = gimple_vuse_op (head_stmt)) != NULL_USE_OPERAND_P) 1004 { 1005 if (USE_FROM_PTR (use_p) == use) 1006 last_p = move_use_after_head (use_p, head, last_p); 1007 } 1008 } 1009 /* Link iter node in after last_p. */ 1010 if (imm->iter_node.prev != NULL) 1011 delink_imm_use (&imm->iter_node); 1012 link_imm_use_to_list (&(imm->iter_node), last_p); 1013 } 1014 1015 /* Initialize IMM to traverse over uses of VAR. Return the first statement. */ 1016 static inline gimple 1017 first_imm_use_stmt (imm_use_iterator *imm, tree var) 1018 { 1019 imm->end_p = &(SSA_NAME_IMM_USE_NODE (var)); 1020 imm->imm_use = imm->end_p->next; 1021 imm->next_imm_name = NULL_USE_OPERAND_P; 1022 1023 /* iter_node is used as a marker within the immediate use list to indicate 1024 where the end of the current stmt's uses are. Initialize it to NULL 1025 stmt and use, which indicates a marker node. */ 1026 imm->iter_node.prev = NULL_USE_OPERAND_P; 1027 imm->iter_node.next = NULL_USE_OPERAND_P; 1028 imm->iter_node.loc.stmt = NULL; 1029 imm->iter_node.use = NULL; 1030 1031 if (end_imm_use_stmt_p (imm)) 1032 return NULL; 1033 1034 link_use_stmts_after (imm->imm_use, imm); 1035 1036 return USE_STMT (imm->imm_use); 1037 } 1038 1039 /* Bump IMM to the next stmt which has a use of var. */ 1040 1041 static inline gimple 1042 next_imm_use_stmt (imm_use_iterator *imm) 1043 { 1044 imm->imm_use = imm->iter_node.next; 1045 if (end_imm_use_stmt_p (imm)) 1046 { 1047 if (imm->iter_node.prev != NULL) 1048 delink_imm_use (&imm->iter_node); 1049 return NULL; 1050 } 1051 1052 link_use_stmts_after (imm->imm_use, imm); 1053 return USE_STMT (imm->imm_use); 1054 } 1055 1056 /* This routine will return the first use on the stmt IMM currently refers 1057 to. */ 1058 1059 static inline use_operand_p 1060 first_imm_use_on_stmt (imm_use_iterator *imm) 1061 { 1062 imm->next_imm_name = imm->imm_use->next; 1063 return imm->imm_use; 1064 } 1065 1066 /* Return TRUE if the last use on the stmt IMM refers to has been visited. */ 1067 1068 static inline bool 1069 end_imm_use_on_stmt_p (const imm_use_iterator *imm) 1070 { 1071 return (imm->imm_use == &(imm->iter_node)); 1072 } 1073 1074 /* Bump to the next use on the stmt IMM refers to, return NULL if done. */ 1075 1076 static inline use_operand_p 1077 next_imm_use_on_stmt (imm_use_iterator *imm) 1078 { 1079 imm->imm_use = imm->next_imm_name; 1080 if (end_imm_use_on_stmt_p (imm)) 1081 return NULL_USE_OPERAND_P; 1082 else 1083 { 1084 imm->next_imm_name = imm->imm_use->next; 1085 return imm->imm_use; 1086 } 1087 } 1088 1089 /* Return true if VAR cannot be modified by the program. */ 1090 1091 static inline bool 1092 unmodifiable_var_p (const_tree var) 1093 { 1094 if (TREE_CODE (var) == SSA_NAME) 1095 var = SSA_NAME_VAR (var); 1096 1097 return TREE_READONLY (var) && (TREE_STATIC (var) || DECL_EXTERNAL (var)); 1098 } 1099 1100 /* Return true if REF, a handled component reference, has an ARRAY_REF 1101 somewhere in it. */ 1102 1103 static inline bool 1104 ref_contains_array_ref (const_tree ref) 1105 { 1106 gcc_checking_assert (handled_component_p (ref)); 1107 1108 do { 1109 if (TREE_CODE (ref) == ARRAY_REF) 1110 return true; 1111 ref = TREE_OPERAND (ref, 0); 1112 } while (handled_component_p (ref)); 1113 1114 return false; 1115 } 1116 1117 /* Return true if REF has an VIEW_CONVERT_EXPR somewhere in it. */ 1118 1119 static inline bool 1120 contains_view_convert_expr_p (const_tree ref) 1121 { 1122 while (handled_component_p (ref)) 1123 { 1124 if (TREE_CODE (ref) == VIEW_CONVERT_EXPR) 1125 return true; 1126 ref = TREE_OPERAND (ref, 0); 1127 } 1128 1129 return false; 1130 } 1131 1132 /* Return true, if the two ranges [POS1, SIZE1] and [POS2, SIZE2] 1133 overlap. SIZE1 and/or SIZE2 can be (unsigned)-1 in which case the 1134 range is open-ended. Otherwise return false. */ 1135 1136 static inline bool 1137 ranges_overlap_p (unsigned HOST_WIDE_INT pos1, 1138 unsigned HOST_WIDE_INT size1, 1139 unsigned HOST_WIDE_INT pos2, 1140 unsigned HOST_WIDE_INT size2) 1141 { 1142 if (pos1 >= pos2 1143 && (size2 == (unsigned HOST_WIDE_INT)-1 1144 || pos1 < (pos2 + size2))) 1145 return true; 1146 if (pos2 >= pos1 1147 && (size1 == (unsigned HOST_WIDE_INT)-1 1148 || pos2 < (pos1 + size1))) 1149 return true; 1150 1151 return false; 1152 } 1153 1154 /* Accessor to tree-ssa-operands.c caches. */ 1155 static inline struct ssa_operands * 1156 gimple_ssa_operands (const struct function *fun) 1157 { 1158 return &fun->gimple_df->ssa_operands; 1159 } 1160 1161 /* Given an edge_var_map V, return the PHI arg definition. */ 1162 1163 static inline tree 1164 redirect_edge_var_map_def (edge_var_map *v) 1165 { 1166 return v->def; 1167 } 1168 1169 /* Given an edge_var_map V, return the PHI result. */ 1170 1171 static inline tree 1172 redirect_edge_var_map_result (edge_var_map *v) 1173 { 1174 return v->result; 1175 } 1176 1177 /* Given an edge_var_map V, return the PHI arg location. */ 1178 1179 static inline source_location 1180 redirect_edge_var_map_location (edge_var_map *v) 1181 { 1182 return v->locus; 1183 } 1184 1185 1186 /* Return an SSA_NAME node for variable VAR defined in statement STMT 1187 in function cfun. */ 1188 1189 static inline tree 1190 make_ssa_name (tree var, gimple stmt) 1191 { 1192 return make_ssa_name_fn (cfun, var, stmt); 1193 } 1194 1195 /* Return an SSA_NAME node using the template SSA name NAME defined in 1196 statement STMT in function cfun. */ 1197 1198 static inline tree 1199 copy_ssa_name (tree var, gimple stmt) 1200 { 1201 return copy_ssa_name_fn (cfun, var, stmt); 1202 } 1203 1204 /* Creates a duplicate of a SSA name NAME tobe defined by statement STMT 1205 in function cfun. */ 1206 1207 static inline tree 1208 duplicate_ssa_name (tree var, gimple stmt) 1209 { 1210 return duplicate_ssa_name_fn (cfun, var, stmt); 1211 } 1212 1213 /* Return an anonymous SSA_NAME node for type TYPE defined in statement STMT 1214 in function cfun. Arrange so that it uses NAME in dumps. */ 1215 1216 static inline tree 1217 make_temp_ssa_name (tree type, gimple stmt, const char *name) 1218 { 1219 tree ssa_name; 1220 gcc_checking_assert (TYPE_P (type)); 1221 ssa_name = make_ssa_name_fn (cfun, type, stmt); 1222 SET_SSA_NAME_VAR_OR_IDENTIFIER (ssa_name, get_identifier (name)); 1223 return ssa_name; 1224 } 1225 1226 /* Returns the base object and a constant BITS_PER_UNIT offset in *POFFSET that 1227 denotes the starting address of the memory access EXP. 1228 Returns NULL_TREE if the offset is not constant or any component 1229 is not BITS_PER_UNIT-aligned. 1230 VALUEIZE if non-NULL is used to valueize SSA names. It should return 1231 its argument or a constant if the argument is known to be constant. */ 1232 /* ??? This is a static inline here to avoid the overhead of the indirect calls 1233 to VALUEIZE. But is this overhead really that significant? And should we 1234 perhaps just rely on WHOPR to specialize the function? */ 1235 1236 static inline tree 1237 get_addr_base_and_unit_offset_1 (tree exp, HOST_WIDE_INT *poffset, 1238 tree (*valueize) (tree)) 1239 { 1240 HOST_WIDE_INT byte_offset = 0; 1241 1242 /* Compute cumulative byte-offset for nested component-refs and array-refs, 1243 and find the ultimate containing object. */ 1244 while (1) 1245 { 1246 switch (TREE_CODE (exp)) 1247 { 1248 case BIT_FIELD_REF: 1249 return NULL_TREE; 1250 1251 case COMPONENT_REF: 1252 { 1253 tree field = TREE_OPERAND (exp, 1); 1254 tree this_offset = component_ref_field_offset (exp); 1255 HOST_WIDE_INT hthis_offset; 1256 1257 if (!this_offset 1258 || TREE_CODE (this_offset) != INTEGER_CST 1259 || (TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (field)) 1260 % BITS_PER_UNIT)) 1261 return NULL_TREE; 1262 1263 hthis_offset = TREE_INT_CST_LOW (this_offset); 1264 hthis_offset += (TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (field)) 1265 / BITS_PER_UNIT); 1266 byte_offset += hthis_offset; 1267 } 1268 break; 1269 1270 case ARRAY_REF: 1271 case ARRAY_RANGE_REF: 1272 { 1273 tree index = TREE_OPERAND (exp, 1); 1274 tree low_bound, unit_size; 1275 1276 if (valueize 1277 && TREE_CODE (index) == SSA_NAME) 1278 index = (*valueize) (index); 1279 1280 /* If the resulting bit-offset is constant, track it. */ 1281 if (TREE_CODE (index) == INTEGER_CST 1282 && (low_bound = array_ref_low_bound (exp), 1283 TREE_CODE (low_bound) == INTEGER_CST) 1284 && (unit_size = array_ref_element_size (exp), 1285 TREE_CODE (unit_size) == INTEGER_CST)) 1286 { 1287 HOST_WIDE_INT hindex = TREE_INT_CST_LOW (index); 1288 1289 hindex -= TREE_INT_CST_LOW (low_bound); 1290 hindex *= TREE_INT_CST_LOW (unit_size); 1291 byte_offset += hindex; 1292 } 1293 else 1294 return NULL_TREE; 1295 } 1296 break; 1297 1298 case REALPART_EXPR: 1299 break; 1300 1301 case IMAGPART_EXPR: 1302 byte_offset += TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (exp))); 1303 break; 1304 1305 case VIEW_CONVERT_EXPR: 1306 break; 1307 1308 case MEM_REF: 1309 { 1310 tree base = TREE_OPERAND (exp, 0); 1311 if (valueize 1312 && TREE_CODE (base) == SSA_NAME) 1313 base = (*valueize) (base); 1314 1315 /* Hand back the decl for MEM[&decl, off]. */ 1316 if (TREE_CODE (base) == ADDR_EXPR) 1317 { 1318 if (!integer_zerop (TREE_OPERAND (exp, 1))) 1319 { 1320 double_int off = mem_ref_offset (exp); 1321 gcc_assert (off.high == -1 || off.high == 0); 1322 byte_offset += off.to_shwi (); 1323 } 1324 exp = TREE_OPERAND (base, 0); 1325 } 1326 goto done; 1327 } 1328 1329 case TARGET_MEM_REF: 1330 { 1331 tree base = TREE_OPERAND (exp, 0); 1332 if (valueize 1333 && TREE_CODE (base) == SSA_NAME) 1334 base = (*valueize) (base); 1335 1336 /* Hand back the decl for MEM[&decl, off]. */ 1337 if (TREE_CODE (base) == ADDR_EXPR) 1338 { 1339 if (TMR_INDEX (exp) || TMR_INDEX2 (exp)) 1340 return NULL_TREE; 1341 if (!integer_zerop (TMR_OFFSET (exp))) 1342 { 1343 double_int off = mem_ref_offset (exp); 1344 gcc_assert (off.high == -1 || off.high == 0); 1345 byte_offset += off.to_shwi (); 1346 } 1347 exp = TREE_OPERAND (base, 0); 1348 } 1349 goto done; 1350 } 1351 1352 default: 1353 goto done; 1354 } 1355 1356 exp = TREE_OPERAND (exp, 0); 1357 } 1358 done: 1359 1360 *poffset = byte_offset; 1361 return exp; 1362 } 1363 1364 #endif /* _TREE_FLOW_INLINE_H */ 1365
