gcc/tree-flow-inline.h

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