gcc/tree-flow-inline.h

   1 /* Inline functions for tree-flow.h
   2    Copyright (C) 2001, 2003, 2005, 2006, 2007, 2008 Free Software
   3    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 /* 'true' after aliases have been computed (see compute_may_aliases).  */
  39 static inline bool
  40 gimple_aliases_computed_p (const struct function *fun)
  41 {
  42   gcc_assert (fun && fun->gimple_df);
  43   return fun->gimple_df->aliases_computed_p;
  44 }
  45
  46 /* Addressable variables in the function.  If bit I is set, then
  47    REFERENCED_VARS (I) has had its address taken.  Note that
  48    CALL_CLOBBERED_VARS and ADDRESSABLE_VARS are not related.  An
  49    addressable variable is not necessarily call-clobbered (e.g., a
  50    local addressable whose address does not escape) and not all
  51    call-clobbered variables are addressable (e.g., a local static
  52    variable).  */
  53 static inline bitmap
  54 gimple_addressable_vars (const struct function *fun)
  55 {
  56   gcc_assert (fun && fun->gimple_df);
  57   return fun->gimple_df->addressable_vars;
  58 }
  59
  60 /* Call clobbered variables in the function.  If bit I is set, then
  61    REFERENCED_VARS (I) is call-clobbered.  */
  62 static inline bitmap
  63 gimple_call_clobbered_vars (const struct function *fun)
  64 {
  65   gcc_assert (fun && fun->gimple_df);
  66   return fun->gimple_df->call_clobbered_vars;
  67 }
  68
  69 /* Call-used variables in the function.  If bit I is set, then
  70    REFERENCED_VARS (I) is call-used at pure function call-sites.  */
  71 static inline bitmap
  72 gimple_call_used_vars (const struct function *fun)
  73 {
  74   gcc_assert (fun && fun->gimple_df);
  75   return fun->gimple_df->call_used_vars;
  76 }
  77
  78 /* Array of all variables referenced in the function.  */
  79 static inline htab_t
  80 gimple_referenced_vars (const struct function *fun)
  81 {
  82   if (!fun->gimple_df)
  83     return NULL;
  84   return fun->gimple_df->referenced_vars;
  85 }
  86
  87 /* Artificial variable used to model the effects of function calls.  */
  88 static inline tree
  89 gimple_global_var (const struct function *fun)
  90 {
  91   gcc_assert (fun && fun->gimple_df);
  92   return fun->gimple_df->global_var;
  93 }
  94
  95 /* Artificial variable used to model the effects of nonlocal
  96    variables.  */
  97 static inline tree
  98 gimple_nonlocal_all (const struct function *fun)
  99 {
 100   gcc_assert (fun && fun->gimple_df);
 101   return fun->gimple_df->nonlocal_all;
 102 }
 103
 104 /* Initialize the hashtable iterator HTI to point to hashtable TABLE */
 105
 106 static inline void *
 107 first_htab_element (htab_iterator *hti, htab_t table)
 108 {
 109   hti->htab = table;
 110   hti->slot = table->entries;
 111   hti->limit = hti->slot + htab_size (table);
 112   do
 113     {
 114       PTR x = *(hti->slot);
 115       if (x != HTAB_EMPTY_ENTRY && x != HTAB_DELETED_ENTRY)
 116         break;
 117     } while (++(hti->slot) < hti->limit);
 118
 119   if (hti->slot < hti->limit)
 120     return *(hti->slot);
 121   return NULL;
 122 }
 123
 124 /* Return current non-empty/deleted slot of the hashtable pointed to by HTI,
 125    or NULL if we have  reached the end.  */
 126
 127 static inline bool
 128 end_htab_p (const htab_iterator *hti)
 129 {
 130   if (hti->slot >= hti->limit)
 131     return true;
 132   return false;
 133 }
 134
 135 /* Advance the hashtable iterator pointed to by HTI to the next element of the
 136    hashtable.  */
 137
 138 static inline void *
 139 next_htab_element (htab_iterator *hti)
 140 {
 141   while (++(hti->slot) < hti->limit)
 142     {
 143       PTR x = *(hti->slot);
 144       if (x != HTAB_EMPTY_ENTRY && x != HTAB_DELETED_ENTRY)
 145         return x;
 146     };
 147   return NULL;
 148 }
 149
 150 /* Initialize ITER to point to the first referenced variable in the
 151    referenced_vars hashtable, and return that variable.  */
 152
 153 static inline tree
 154 first_referenced_var (referenced_var_iterator *iter)
 155 {
 156   return (tree) first_htab_element (&iter->hti,
 157                                     gimple_referenced_vars (cfun));
 158 }
 159
 160 /* Return true if we have hit the end of the referenced variables ITER is
 161    iterating through.  */
 162
 163 static inline bool
 164 end_referenced_vars_p (const referenced_var_iterator *iter)
 165 {
 166   return end_htab_p (&iter->hti);
 167 }
 168
 169 /* Make ITER point to the next referenced_var in the referenced_var hashtable,
 170    and return that variable.  */
 171
 172 static inline tree
 173 next_referenced_var (referenced_var_iterator *iter)
 174 {
 175   return (tree) next_htab_element (&iter->hti);
 176 }
 177
 178 /* Fill up VEC with the variables in the referenced vars hashtable.  */
 179
 180 static inline void
 181 fill_referenced_var_vec (VEC (tree, heap) **vec)
 182 {
 183   referenced_var_iterator rvi;
 184   tree var;
 185   *vec = NULL;
 186   FOR_EACH_REFERENCED_VAR (var, rvi)
 187     VEC_safe_push (tree, heap, *vec, var);
 188 }
 189
 190 /* Return the variable annotation for T, which must be a _DECL node.
 191    Return NULL if the variable annotation doesn't already exist.  */
 192 static inline var_ann_t
 193 var_ann (const_tree t)
 194 {
 195   var_ann_t ann;
 196
 197   if (!t->base.ann)
 198     return NULL;
 199   ann = (var_ann_t) t->base.ann;
 200
 201   gcc_assert (ann->common.type == VAR_ANN);
 202
 203   return ann;
 204 }
 205
 206 /* Return the variable annotation for T, which must be a _DECL node.
 207    Create the variable annotation if it doesn't exist.  */
 208 static inline var_ann_t
 209 get_var_ann (tree var)
 210 {
 211   var_ann_t ann = var_ann (var);
 212   return (ann) ? ann : create_var_ann (var);
 213 }
 214
 215 /* Return the function annotation for T, which must be a FUNCTION_DECL node.
 216    Return NULL if the function annotation doesn't already exist.  */
 217 static inline function_ann_t
 218 function_ann (const_tree t)
 219 {
 220   gcc_assert (t);
 221   gcc_assert (TREE_CODE (t) == FUNCTION_DECL);
 222   gcc_assert (!t->base.ann
 223               || t->base.ann->common.type == FUNCTION_ANN);
 224
 225   return (function_ann_t) t->base.ann;
 226 }
 227
 228 /* Return the function annotation for T, which must be a FUNCTION_DECL node.
 229    Create the function annotation if it doesn't exist.  */
 230 static inline function_ann_t
 231 get_function_ann (tree var)
 232 {
 233   function_ann_t ann = function_ann (var);
 234   gcc_assert (!var->base.ann || var->base.ann->common.type == FUNCTION_ANN);
 235   return (ann) ? ann : create_function_ann (var);
 236 }
 237
 238 /* Get the number of the next statement uid to be allocated.  */
 239 static inline unsigned int
 240 gimple_stmt_max_uid (struct function *fn)
 241 {
 242   return fn->last_stmt_uid;
 243 }
 244
 245 /* Set the number of the next statement uid to be allocated.  */
 246 static inline void
 247 set_gimple_stmt_max_uid (struct function *fn, unsigned int maxid)
 248 {
 249   fn->last_stmt_uid = maxid;
 250 }
 251
 252 /* Set the number of the next statement uid to be allocated.  */
 253 static inline unsigned int
 254 inc_gimple_stmt_max_uid (struct function *fn)
 255 {
 256   return fn->last_stmt_uid++;
 257 }
 258
 259 /* Return the annotation type for annotation ANN.  */
 260 static inline enum tree_ann_type
 261 ann_type (tree_ann_t ann)
 262 {
 263   return ann->common.type;
 264 }
 265
 266 /* Return the may_aliases bitmap for variable VAR, or NULL if it has
 267    no may aliases.  */
 268 static inline bitmap
 269 may_aliases (const_tree var)
 270 {
 271   return MTAG_ALIASES (var);
 272 }
 273
 274 /* Return the line number for EXPR, or return -1 if we have no line
 275    number information for it.  */
 276 static inline int
 277 get_lineno (const_gimple stmt)
 278 {
 279   location_t loc;
 280
 281   if (!stmt)
 282     return -1;
 283
 284   loc = gimple_location (stmt);
 285   if (loc != UNKNOWN_LOCATION)
 286     return -1;
 287
 288   return LOCATION_LINE (loc);
 289 }
 290
 291 /* Delink an immediate_uses node from its chain.  */
 292 static inline void
 293 delink_imm_use (ssa_use_operand_t *linknode)
 294 {
 295   /* Return if this node is not in a list.  */
 296   if (linknode->prev == NULL)
 297     return;
 298
 299   linknode->prev->next = linknode->next;
 300   linknode->next->prev = linknode->prev;
 301   linknode->prev = NULL;
 302   linknode->next = NULL;
 303 }
 304
 305 /* Link ssa_imm_use node LINKNODE into the chain for LIST.  */
 306 static inline void
 307 link_imm_use_to_list (ssa_use_operand_t *linknode, ssa_use_operand_t *list)
 308 {
 309   /* Link the new node at the head of the list.  If we are in the process of
 310      traversing the list, we won't visit any new nodes added to it.  */
 311   linknode->prev = list;
 312   linknode->next = list->next;
 313   list->next->prev = linknode;
 314   list->next = linknode;
 315 }
 316
 317 /* Link ssa_imm_use node LINKNODE into the chain for DEF.  */
 318 static inline void
 319 link_imm_use (ssa_use_operand_t *linknode, tree def)
 320 {
 321   ssa_use_operand_t *root;
 322
 323   if (!def || TREE_CODE (def) != SSA_NAME)
 324     linknode->prev = NULL;
 325   else
 326     {
 327       root = &(SSA_NAME_IMM_USE_NODE (def));
 328 #ifdef ENABLE_CHECKING
 329       if (linknode->use)
 330         gcc_assert (*(linknode->use) == def);
 331 #endif
 332       link_imm_use_to_list (linknode, root);
 333     }
 334 }
 335
 336 /* Set the value of a use pointed to by USE to VAL.  */
 337 static inline void
 338 set_ssa_use_from_ptr (use_operand_p use, tree val)
 339 {
 340   delink_imm_use (use);
 341   *(use->use) = val;
 342   link_imm_use (use, val);
 343 }
 344
 345 /* Link ssa_imm_use node LINKNODE into the chain for DEF, with use occurring
 346    in STMT.  */
 347 static inline void
 348 link_imm_use_stmt (ssa_use_operand_t *linknode, tree def, gimple stmt)
 349 {
 350   if (stmt)
 351     link_imm_use (linknode, def);
 352   else
 353     link_imm_use (linknode, NULL);
 354   linknode->loc.stmt = stmt;
 355 }
 356
 357 /* Relink a new node in place of an old node in the list.  */
 358 static inline void
 359 relink_imm_use (ssa_use_operand_t *node, ssa_use_operand_t *old)
 360 {
 361   /* The node one had better be in the same list.  */
 362   gcc_assert (*(old->use) == *(node->use));
 363   node->prev = old->prev;
 364   node->next = old->next;
 365   if (old->prev)
 366     {
 367       old->prev->next = node;
 368       old->next->prev = node;
 369       /* Remove the old node from the list.  */
 370       old->prev = NULL;
 371     }
 372 }
 373
 374 /* Relink ssa_imm_use node LINKNODE into the chain for OLD, with use occurring
 375    in STMT.  */
 376 static inline void
 377 relink_imm_use_stmt (ssa_use_operand_t *linknode, ssa_use_operand_t *old,
 378                      gimple stmt)
 379 {
 380   if (stmt)
 381     relink_imm_use (linknode, old);
 382   else
 383     link_imm_use (linknode, NULL);
 384   linknode->loc.stmt = stmt;
 385 }
 386
 387
 388 /* Return true is IMM has reached the end of the immediate use list.  */
 389 static inline bool
 390 end_readonly_imm_use_p (const imm_use_iterator *imm)
 391 {
 392   return (imm->imm_use == imm->end_p);
 393 }
 394
 395 /* Initialize iterator IMM to process the list for VAR.  */
 396 static inline use_operand_p
 397 first_readonly_imm_use (imm_use_iterator *imm, tree var)
 398 {
 399   gcc_assert (TREE_CODE (var) == SSA_NAME);
 400
 401   imm->end_p = &(SSA_NAME_IMM_USE_NODE (var));
 402   imm->imm_use = imm->end_p->next;
 403 #ifdef ENABLE_CHECKING
 404   imm->iter_node.next = imm->imm_use->next;
 405 #endif
 406   if (end_readonly_imm_use_p (imm))
 407     return NULL_USE_OPERAND_P;
 408   return imm->imm_use;
 409 }
 410
 411 /* Bump IMM to the next use in the list.  */
 412 static inline use_operand_p
 413 next_readonly_imm_use (imm_use_iterator *imm)
 414 {
 415   use_operand_p old = imm->imm_use;
 416
 417 #ifdef ENABLE_CHECKING
 418   /* If this assertion fails, it indicates the 'next' pointer has changed
 419      since the last bump.  This indicates that the list is being modified
 420      via stmt changes, or SET_USE, or somesuch thing, and you need to be
 421      using the SAFE version of the iterator.  */
 422   gcc_assert (imm->iter_node.next == old->next);
 423   imm->iter_node.next = old->next->next;
 424 #endif
 425
 426   imm->imm_use = old->next;
 427   if (end_readonly_imm_use_p (imm))
 428     return NULL_USE_OPERAND_P;
 429   return imm->imm_use;
 430 }
 431
 432 /* Return true if VAR has no uses.  */
 433 static inline bool
 434 has_zero_uses (const_tree var)
 435 {
 436   const ssa_use_operand_t *const ptr = &(SSA_NAME_IMM_USE_NODE (var));
 437   /* A single use means there is no items in the list.  */
 438   return (ptr == ptr->next);
 439 }
 440
 441 /* Return true if VAR has a single use.  */
 442 static inline bool
 443 has_single_use (const_tree var)
 444 {
 445   const ssa_use_operand_t *const ptr = &(SSA_NAME_IMM_USE_NODE (var));
 446   /* A single use means there is one item in the list.  */
 447   return (ptr != ptr->next && ptr == ptr->next->next);
 448 }
 449
 450
 451 /* If VAR has only a single immediate use, return true, and set USE_P and STMT
 452    to the use pointer and stmt of occurrence.  */
 453 static inline bool
 454 single_imm_use (const_tree var, use_operand_p *use_p, gimple *stmt)
 455 {
 456   const ssa_use_operand_t *const ptr = &(SSA_NAME_IMM_USE_NODE (var));
 457   if (ptr != ptr->next && ptr == ptr->next->next)
 458     {
 459       *use_p = ptr->next;
 460       *stmt = ptr->next->loc.stmt;
 461       return true;
 462     }
 463   *use_p = NULL_USE_OPERAND_P;
 464   *stmt = NULL;
 465   return false;
 466 }
 467
 468 /* Return the number of immediate uses of VAR.  */
 469 static inline unsigned int
 470 num_imm_uses (const_tree var)
 471 {
 472   const ssa_use_operand_t *const start = &(SSA_NAME_IMM_USE_NODE (var));
 473   const ssa_use_operand_t *ptr;
 474   unsigned int num = 0;
 475
 476   for (ptr = start->next; ptr != start; ptr = ptr->next)
 477      num++;
 478
 479   return num;
 480 }
 481
 482 /* Return the tree pointed-to by USE.  */
 483 static inline tree
 484 get_use_from_ptr (use_operand_p use)
 485 {
 486   return *(use->use);
 487 }
 488
 489 /* Return the tree pointed-to by DEF.  */
 490 static inline tree
 491 get_def_from_ptr (def_operand_p def)
 492 {
 493   return *def;
 494 }
 495
 496 /* Return a use_operand_p pointer for argument I of PHI node GS.  */
 497
 498 static inline use_operand_p
 499 gimple_phi_arg_imm_use_ptr (gimple gs, int i)
 500 {
 501   return &gimple_phi_arg (gs, i)->imm_use;
 502 }
 503
 504 /* Return the tree operand for argument I of PHI node GS.  */
 505
 506 static inline tree
 507 gimple_phi_arg_def (gimple gs, size_t index)
 508 {
 509   struct phi_arg_d *pd = gimple_phi_arg (gs, index);
 510   return get_use_from_ptr (&pd->imm_use);
 511 }
 512
 513 /* Return a pointer to the tree operand for argument I of PHI node GS.  */
 514
 515 static inline tree *
 516 gimple_phi_arg_def_ptr (gimple gs, size_t index)
 517 {
 518   return &gimple_phi_arg (gs, index)->def;
 519 }
 520
 521 /* Return the edge associated with argument I of phi node GS.  */
 522
 523 static inline edge
 524 gimple_phi_arg_edge (gimple gs, size_t i)
 525 {
 526   return EDGE_PRED (gimple_bb (gs), i);
 527 }
 528
 529 /* Return the PHI nodes for basic block BB, or NULL if there are no
 530    PHI nodes.  */
 531 static inline gimple_seq
 532 phi_nodes (const_basic_block bb)
 533 {
 534   gcc_assert (!(bb->flags & BB_RTL));
 535   if (!bb->il.gimple)
 536     return NULL;
 537   return bb->il.gimple->phi_nodes;
 538 }
 539
 540 /* Set PHI nodes of a basic block BB to SEQ.  */
 541
 542 static inline void
 543 set_phi_nodes (basic_block bb, gimple_seq seq)
 544 {
 545   gimple_stmt_iterator i;
 546
 547   gcc_assert (!(bb->flags & BB_RTL));
 548   bb->il.gimple->phi_nodes = seq;
 549   if (seq)
 550     for (i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i))
 551       gimple_set_bb (gsi_stmt (i), bb);
 552 }
 553
 554 /* Return the phi argument which contains the specified use.  */
 555
 556 static inline int
 557 phi_arg_index_from_use (use_operand_p use)
 558 {
 559   struct phi_arg_d *element, *root;
 560   size_t index;
 561   gimple phi;
 562
 563   /* Since the use is the first thing in a PHI argument element, we can
 564      calculate its index based on casting it to an argument, and performing
 565      pointer arithmetic.  */
 566
 567   phi = USE_STMT (use);
 568   gcc_assert (gimple_code (phi) == GIMPLE_PHI);
 569
 570   element = (struct phi_arg_d *)use;
 571   root = gimple_phi_arg (phi, 0);
 572   index = element - root;
 573
 574 #ifdef ENABLE_CHECKING
 575   /* Make sure the calculation doesn't have any leftover bytes.  If it does,
 576      then imm_use is likely not the first element in phi_arg_d.  */
 577   gcc_assert (
 578           (((char *)element - (char *)root) % sizeof (struct phi_arg_d)) == 0);
 579   gcc_assert (index < gimple_phi_capacity (phi));
 580 #endif
 581
 582  return index;
 583 }
 584
 585 /* Mark VAR as used, so that it'll be preserved during rtl expansion.  */
 586
 587 static inline void
 588 set_is_used (tree var)
 589 {
 590   var_ann_t ann = get_var_ann (var);
 591   ann->used = 1;
 592 }
 593
 594
 595 /* Return true if T (assumed to be a DECL) is a global variable.  */
 596
 597 static inline bool
 598 is_global_var (const_tree t)
 599 {
 600   if (MTAG_P (t))
 601     return MTAG_GLOBAL (t);
 602   else
 603     return (TREE_STATIC (t) || DECL_EXTERNAL (t));
 604 }
 605
 606 /* PHI nodes should contain only ssa_names and invariants.  A test
 607    for ssa_name is definitely simpler; don't let invalid contents
 608    slip in in the meantime.  */
 609
 610 static inline bool
 611 phi_ssa_name_p (const_tree t)
 612 {
 613   if (TREE_CODE (t) == SSA_NAME)
 614     return true;
 615 #ifdef ENABLE_CHECKING
 616   gcc_assert (is_gimple_min_invariant (t));
 617 #endif
 618   return false;
 619 }
 620
 621
 622 /* Returns the loop of the statement STMT.  */
 623
 624 static inline struct loop *
 625 loop_containing_stmt (gimple stmt)
 626 {
 627   basic_block bb = gimple_bb (stmt);
 628   if (!bb)
 629     return NULL;
 630
 631   return bb->loop_father;
 632 }
 633
 634
 635 /* Return the memory partition tag associated with symbol SYM.  */
 636
 637 static inline tree
 638 memory_partition (tree sym)
 639 {
 640   tree tag;
 641
 642   /* MPTs belong to their own partition.  */
 643   if (TREE_CODE (sym) == MEMORY_PARTITION_TAG)
 644     return sym;
 645
 646   gcc_assert (!is_gimple_reg (sym));
 647   tag = get_var_ann (sym)->mpt;
 648
 649 #if defined ENABLE_CHECKING
 650   if (tag)
 651     gcc_assert (TREE_CODE (tag) == MEMORY_PARTITION_TAG);
 652 #endif
 653
 654   return tag;
 655 }
 656
 657 /* Return true if NAME is a memory factoring SSA name (i.e., an SSA
 658    name for a memory partition.  */
 659
 660 static inline bool
 661 factoring_name_p (const_tree name)
 662 {
 663   return TREE_CODE (SSA_NAME_VAR (name)) == MEMORY_PARTITION_TAG;
 664 }
 665
 666 /* Return true if VAR is used by function calls.  */
 667 static inline bool
 668 is_call_used (const_tree var)
 669 {
 670   return (var_ann (var)->call_clobbered
 671           || bitmap_bit_p (gimple_call_used_vars (cfun), DECL_UID (var)));
 672 }
 673
 674 /* Return true if VAR is clobbered by function calls.  */
 675 static inline bool
 676 is_call_clobbered (const_tree var)
 677 {
 678   return var_ann (var)->call_clobbered;
 679 }
 680
 681 /* Mark variable VAR as being clobbered by function calls.  */
 682 static inline void
 683 mark_call_clobbered (tree var, unsigned int escape_type)
 684 {
 685   var_ann (var)->escape_mask |= escape_type;
 686   var_ann (var)->call_clobbered = true;
 687   bitmap_set_bit (gimple_call_clobbered_vars (cfun), DECL_UID (var));
 688 }
 689
 690 /* Clear the call-clobbered attribute from variable VAR.  */
 691 static inline void
 692 clear_call_clobbered (tree var)
 693 {
 694   var_ann_t ann = var_ann (var);
 695   ann->escape_mask = 0;
 696   if (MTAG_P (var))
 697     MTAG_GLOBAL (var) = 0;
 698   var_ann (var)->call_clobbered = false;
 699   bitmap_clear_bit (gimple_call_clobbered_vars (cfun), DECL_UID (var));
 700 }
 701
 702 /* Return the common annotation for T.  Return NULL if the annotation
 703    doesn't already exist.  */
 704 static inline tree_ann_common_t
 705 tree_common_ann (const_tree t)
 706 {
 707   /* Watch out static variables with unshared annotations.  */
 708   if (DECL_P (t) && TREE_CODE (t) == VAR_DECL)
 709     return &var_ann (t)->common;
 710   return &t->base.ann->common;
 711 }
 712
 713 /* Return a common annotation for T.  Create the constant annotation if it
 714    doesn't exist.  */
 715 static inline tree_ann_common_t
 716 get_tree_common_ann (tree t)
 717 {
 718   tree_ann_common_t ann = tree_common_ann (t);
 719   return (ann) ? ann : create_tree_common_ann (t);
 720 }
 721
 722 /*  -----------------------------------------------------------------------  */
 723
 724 /* The following set of routines are used to iterator over various type of
 725    SSA operands.  */
 726
 727 /* Return true if PTR is finished iterating.  */
 728 static inline bool
 729 op_iter_done (const ssa_op_iter *ptr)
 730 {
 731   return ptr->done;
 732 }
 733
 734 /* Get the next iterator use value for PTR.  */
 735 static inline use_operand_p
 736 op_iter_next_use (ssa_op_iter *ptr)
 737 {
 738   use_operand_p use_p;
 739 #ifdef ENABLE_CHECKING
 740   gcc_assert (ptr->iter_type == ssa_op_iter_use);
 741 #endif
 742   if (ptr->uses)
 743     {
 744       use_p = USE_OP_PTR (ptr->uses);
 745       ptr->uses = ptr->uses->next;
 746       return use_p;
 747     }
 748   if (ptr->vuses)
 749     {
 750       use_p = VUSE_OP_PTR (ptr->vuses, ptr->vuse_index);
 751       if (++(ptr->vuse_index) >= VUSE_NUM (ptr->vuses))
 752         {
 753           ptr->vuse_index = 0;
 754           ptr->vuses = ptr->vuses->next;
 755         }
 756       return use_p;
 757     }
 758   if (ptr->mayuses)
 759     {
 760       use_p = VDEF_OP_PTR (ptr->mayuses, ptr->mayuse_index);
 761       if (++(ptr->mayuse_index) >= VDEF_NUM (ptr->mayuses))
 762         {
 763           ptr->mayuse_index = 0;
 764           ptr->mayuses = ptr->mayuses->next;
 765         }
 766       return use_p;
 767     }
 768   if (ptr->phi_i < ptr->num_phi)
 769     {
 770       return PHI_ARG_DEF_PTR (ptr->phi_stmt, (ptr->phi_i)++);
 771     }
 772   ptr->done = true;
 773   return NULL_USE_OPERAND_P;
 774 }
 775
 776 /* Get the next iterator def value for PTR.  */
 777 static inline def_operand_p
 778 op_iter_next_def (ssa_op_iter *ptr)
 779 {
 780   def_operand_p def_p;
 781 #ifdef ENABLE_CHECKING
 782   gcc_assert (ptr->iter_type == ssa_op_iter_def);
 783 #endif
 784   if (ptr->defs)
 785     {
 786       def_p = DEF_OP_PTR (ptr->defs);
 787       ptr->defs = ptr->defs->next;
 788       return def_p;
 789     }
 790   if (ptr->vdefs)
 791     {
 792       def_p = VDEF_RESULT_PTR (ptr->vdefs);
 793       ptr->vdefs = ptr->vdefs->next;
 794       return def_p;
 795     }
 796   ptr->done = true;
 797   return NULL_DEF_OPERAND_P;
 798 }
 799
 800 /* Get the next iterator tree value for PTR.  */
 801 static inline tree
 802 op_iter_next_tree (ssa_op_iter *ptr)
 803 {
 804   tree val;
 805 #ifdef ENABLE_CHECKING
 806   gcc_assert (ptr->iter_type == ssa_op_iter_tree);
 807 #endif
 808   if (ptr->uses)
 809     {
 810       val = USE_OP (ptr->uses);
 811       ptr->uses = ptr->uses->next;
 812       return val;
 813     }
 814   if (ptr->vuses)
 815     {
 816       val = VUSE_OP (ptr->vuses, ptr->vuse_index);
 817       if (++(ptr->vuse_index) >= VUSE_NUM (ptr->vuses))
 818         {
 819           ptr->vuse_index = 0;
 820           ptr->vuses = ptr->vuses->next;
 821         }
 822       return val;
 823     }
 824   if (ptr->mayuses)
 825     {
 826       val = VDEF_OP (ptr->mayuses, ptr->mayuse_index);
 827       if (++(ptr->mayuse_index) >= VDEF_NUM (ptr->mayuses))
 828         {
 829           ptr->mayuse_index = 0;
 830           ptr->mayuses = ptr->mayuses->next;
 831         }
 832       return val;
 833     }
 834   if (ptr->defs)
 835     {
 836       val = DEF_OP (ptr->defs);
 837       ptr->defs = ptr->defs->next;
 838       return val;
 839     }
 840   if (ptr->vdefs)
 841     {
 842       val = VDEF_RESULT (ptr->vdefs);
 843       ptr->vdefs = ptr->vdefs->next;
 844       return val;
 845     }
 846
 847   ptr->done = true;
 848   return NULL_TREE;
 849
 850 }
 851
 852
 853 /* This functions clears the iterator PTR, and marks it done.  This is normally
 854    used to prevent warnings in the compile about might be uninitialized
 855    components.  */
 856
 857 static inline void
 858 clear_and_done_ssa_iter (ssa_op_iter *ptr)
 859 {
 860   ptr->defs = NULL;
 861   ptr->uses = NULL;
 862   ptr->vuses = NULL;
 863   ptr->vdefs = NULL;
 864   ptr->mayuses = NULL;
 865   ptr->iter_type = ssa_op_iter_none;
 866   ptr->phi_i = 0;
 867   ptr->num_phi = 0;
 868   ptr->phi_stmt = NULL;
 869   ptr->done = true;
 870   ptr->vuse_index = 0;
 871   ptr->mayuse_index = 0;
 872 }
 873
 874 /* Initialize the iterator PTR to the virtual defs in STMT.  */
 875 static inline void
 876 op_iter_init (ssa_op_iter *ptr, gimple stmt, int flags)
 877 {
 878   ptr->defs = (flags & SSA_OP_DEF) ? gimple_def_ops (stmt) : NULL;
 879   ptr->uses = (flags & SSA_OP_USE) ? gimple_use_ops (stmt) : NULL;
 880   ptr->vuses = (flags & SSA_OP_VUSE) ? gimple_vuse_ops (stmt) : NULL;
 881   ptr->vdefs = (flags & SSA_OP_VDEF) ? gimple_vdef_ops (stmt) : NULL;
 882   ptr->mayuses = (flags & SSA_OP_VMAYUSE) ? gimple_vdef_ops (stmt) : NULL;
 883   ptr->done = false;
 884
 885   ptr->phi_i = 0;
 886   ptr->num_phi = 0;
 887   ptr->phi_stmt = NULL;
 888   ptr->vuse_index = 0;
 889   ptr->mayuse_index = 0;
 890 }
 891
 892 /* Initialize iterator PTR to the use operands in STMT based on FLAGS. Return
 893    the first use.  */
 894 static inline use_operand_p
 895 op_iter_init_use (ssa_op_iter *ptr, gimple stmt, int flags)
 896 {
 897   gcc_assert ((flags & SSA_OP_ALL_DEFS) == 0);
 898   op_iter_init (ptr, stmt, flags);
 899   ptr->iter_type = ssa_op_iter_use;
 900   return op_iter_next_use (ptr);
 901 }
 902
 903 /* Initialize iterator PTR to the def operands in STMT based on FLAGS. Return
 904    the first def.  */
 905 static inline def_operand_p
 906 op_iter_init_def (ssa_op_iter *ptr, gimple stmt, int flags)
 907 {
 908   gcc_assert ((flags & SSA_OP_ALL_USES) == 0);
 909   op_iter_init (ptr, stmt, flags);
 910   ptr->iter_type = ssa_op_iter_def;
 911   return op_iter_next_def (ptr);
 912 }
 913
 914 /* Initialize iterator PTR to the operands in STMT based on FLAGS. Return
 915    the first operand as a tree.  */
 916 static inline tree
 917 op_iter_init_tree (ssa_op_iter *ptr, gimple stmt, int flags)
 918 {
 919   op_iter_init (ptr, stmt, flags);
 920   ptr->iter_type = ssa_op_iter_tree;
 921   return op_iter_next_tree (ptr);
 922 }
 923
 924 /* Get the next iterator mustdef value for PTR, returning the mustdef values in
 925    KILL and DEF.  */
 926 static inline void
 927 op_iter_next_vdef (vuse_vec_p *use, def_operand_p *def,
 928                          ssa_op_iter *ptr)
 929 {
 930 #ifdef ENABLE_CHECKING
 931   gcc_assert (ptr->iter_type == ssa_op_iter_vdef);
 932 #endif
 933   if (ptr->mayuses)
 934     {
 935       *def = VDEF_RESULT_PTR (ptr->mayuses);
 936       *use = VDEF_VECT (ptr->mayuses);
 937       ptr->mayuses = ptr->mayuses->next;
 938       return;
 939     }
 940
 941   *def = NULL_DEF_OPERAND_P;
 942   *use = NULL;
 943   ptr->done = true;
 944   return;
 945 }
 946
 947
 948 static inline void
 949 op_iter_next_mustdef (use_operand_p *use, def_operand_p *def,
 950                          ssa_op_iter *ptr)
 951 {
 952   vuse_vec_p vp;
 953   op_iter_next_vdef (&vp, def, ptr);
 954   if (vp != NULL)
 955     {
 956       gcc_assert (VUSE_VECT_NUM_ELEM (*vp) == 1);
 957       *use = VUSE_ELEMENT_PTR (*vp, 0);
 958     }
 959   else
 960     *use = NULL_USE_OPERAND_P;
 961 }
 962
 963 /* Initialize iterator PTR to the operands in STMT.  Return the first operands
 964    in USE and DEF.  */
 965 static inline void
 966 op_iter_init_vdef (ssa_op_iter *ptr, gimple stmt, vuse_vec_p *use,
 967                      def_operand_p *def)
 968 {
 969   gcc_assert (gimple_code (stmt) != GIMPLE_PHI);
 970
 971   op_iter_init (ptr, stmt, SSA_OP_VMAYUSE);
 972   ptr->iter_type = ssa_op_iter_vdef;
 973   op_iter_next_vdef (use, def, ptr);
 974 }
 975
 976
 977 /* If there is a single operand in STMT matching FLAGS, return it.  Otherwise
 978    return NULL.  */
 979 static inline tree
 980 single_ssa_tree_operand (gimple stmt, int flags)
 981 {
 982   tree var;
 983   ssa_op_iter iter;
 984
 985   var = op_iter_init_tree (&iter, stmt, flags);
 986   if (op_iter_done (&iter))
 987     return NULL_TREE;
 988   op_iter_next_tree (&iter);
 989   if (op_iter_done (&iter))
 990     return var;
 991   return NULL_TREE;
 992 }
 993
 994
 995 /* If there is a single operand in STMT matching FLAGS, return it.  Otherwise
 996    return NULL.  */
 997 static inline use_operand_p
 998 single_ssa_use_operand (gimple stmt, int flags)
 999 {
1000   use_operand_p var;
1001   ssa_op_iter iter;
1002
1003   var = op_iter_init_use (&iter, stmt, flags);
1004   if (op_iter_done (&iter))
1005     return NULL_USE_OPERAND_P;
1006   op_iter_next_use (&iter);
1007   if (op_iter_done (&iter))
1008     return var;
1009   return NULL_USE_OPERAND_P;
1010 }
1011
1012
1013
1014 /* If there is a single operand in STMT matching FLAGS, return it.  Otherwise
1015    return NULL.  */
1016 static inline def_operand_p
1017 single_ssa_def_operand (gimple stmt, int flags)
1018 {
1019   def_operand_p var;
1020   ssa_op_iter iter;
1021
1022   var = op_iter_init_def (&iter, stmt, flags);
1023   if (op_iter_done (&iter))
1024     return NULL_DEF_OPERAND_P;
1025   op_iter_next_def (&iter);
1026   if (op_iter_done (&iter))
1027     return var;
1028   return NULL_DEF_OPERAND_P;
1029 }
1030
1031
1032 /* Return true if there are zero operands in STMT matching the type
1033    given in FLAGS.  */
1034 static inline bool
1035 zero_ssa_operands (gimple stmt, int flags)
1036 {
1037   ssa_op_iter iter;
1038
1039   op_iter_init_tree (&iter, stmt, flags);
1040   return op_iter_done (&iter);
1041 }
1042
1043
1044 /* Return the number of operands matching FLAGS in STMT.  */
1045 static inline int
1046 num_ssa_operands (gimple stmt, int flags)
1047 {
1048   ssa_op_iter iter;
1049   tree t;
1050   int num = 0;
1051
1052   FOR_EACH_SSA_TREE_OPERAND (t, stmt, iter, flags)
1053     num++;
1054   return num;
1055 }
1056
1057
1058 /* Delink all immediate_use information for STMT.  */
1059 static inline void
1060 delink_stmt_imm_use (gimple stmt)
1061 {
1062    ssa_op_iter iter;
1063    use_operand_p use_p;
1064
1065    if (ssa_operands_active ())
1066      FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_ALL_USES)
1067        delink_imm_use (use_p);
1068 }
1069
1070
1071 /* This routine will compare all the operands matching FLAGS in STMT1 to those
1072    in STMT2.  TRUE is returned if they are the same.  STMTs can be NULL.  */
1073 static inline bool
1074 compare_ssa_operands_equal (gimple stmt1, gimple stmt2, int flags)
1075 {
1076   ssa_op_iter iter1, iter2;
1077   tree op1 = NULL_TREE;
1078   tree op2 = NULL_TREE;
1079   bool look1, look2;
1080
1081   if (stmt1 == stmt2)
1082     return true;
1083
1084   look1 = stmt1 != NULL;
1085   look2 = stmt2 != NULL;
1086
1087   if (look1)
1088     {
1089       op1 = op_iter_init_tree (&iter1, stmt1, flags);
1090       if (!look2)
1091         return op_iter_done (&iter1);
1092     }
1093   else
1094     clear_and_done_ssa_iter (&iter1);
1095
1096   if (look2)
1097     {
1098       op2 = op_iter_init_tree (&iter2, stmt2, flags);
1099       if (!look1)
1100         return op_iter_done (&iter2);
1101     }
1102   else
1103     clear_and_done_ssa_iter (&iter2);
1104
1105   while (!op_iter_done (&iter1) && !op_iter_done (&iter2))
1106     {
1107       if (op1 != op2)
1108         return false;
1109       op1 = op_iter_next_tree (&iter1);
1110       op2 = op_iter_next_tree (&iter2);
1111     }
1112
1113   return (op_iter_done (&iter1) && op_iter_done (&iter2));
1114 }
1115
1116
1117 /* If there is a single DEF in the PHI node which matches FLAG, return it.
1118    Otherwise return NULL_DEF_OPERAND_P.  */
1119 static inline tree
1120 single_phi_def (gimple stmt, int flags)
1121 {
1122   tree def = PHI_RESULT (stmt);
1123   if ((flags & SSA_OP_DEF) && is_gimple_reg (def))
1124     return def;
1125   if ((flags & SSA_OP_VIRTUAL_DEFS) && !is_gimple_reg (def))
1126     return def;
1127   return NULL_TREE;
1128 }
1129
1130 /* Initialize the iterator PTR for uses matching FLAGS in PHI.  FLAGS should
1131    be either SSA_OP_USES or SSA_OP_VIRTUAL_USES.  */
1132 static inline use_operand_p
1133 op_iter_init_phiuse (ssa_op_iter *ptr, gimple phi, int flags)
1134 {
1135   tree phi_def = gimple_phi_result (phi);
1136   int comp;
1137
1138   clear_and_done_ssa_iter (ptr);
1139   ptr->done = false;
1140
1141   gcc_assert ((flags & (SSA_OP_USE | SSA_OP_VIRTUAL_USES)) != 0);
1142
1143   comp = (is_gimple_reg (phi_def) ? SSA_OP_USE : SSA_OP_VIRTUAL_USES);
1144
1145   /* If the PHI node doesn't the operand type we care about, we're done.  */
1146   if ((flags & comp) == 0)
1147     {
1148       ptr->done = true;
1149       return NULL_USE_OPERAND_P;
1150     }
1151
1152   ptr->phi_stmt = phi;
1153   ptr->num_phi = gimple_phi_num_args (phi);
1154   ptr->iter_type = ssa_op_iter_use;
1155   return op_iter_next_use (ptr);
1156 }
1157
1158
1159 /* Start an iterator for a PHI definition.  */
1160
1161 static inline def_operand_p
1162 op_iter_init_phidef (ssa_op_iter *ptr, gimple phi, int flags)
1163 {
1164   tree phi_def = PHI_RESULT (phi);
1165   int comp;
1166
1167   clear_and_done_ssa_iter (ptr);
1168   ptr->done = false;
1169
1170   gcc_assert ((flags & (SSA_OP_DEF | SSA_OP_VIRTUAL_DEFS)) != 0);
1171
1172   comp = (is_gimple_reg (phi_def) ? SSA_OP_DEF : SSA_OP_VIRTUAL_DEFS);
1173
1174   /* If the PHI node doesn't the operand type we care about, we're done.  */
1175   if ((flags & comp) == 0)
1176     {
1177       ptr->done = true;
1178       return NULL_USE_OPERAND_P;
1179     }
1180
1181   ptr->iter_type = ssa_op_iter_def;
1182   /* The first call to op_iter_next_def will terminate the iterator since
1183      all the fields are NULL.  Simply return the result here as the first and
1184      therefore only result.  */
1185   return PHI_RESULT_PTR (phi);
1186 }
1187
1188 /* Return true is IMM has reached the end of the immediate use stmt list.  */
1189
1190 static inline bool
1191 end_imm_use_stmt_p (const imm_use_iterator *imm)
1192 {
1193   return (imm->imm_use == imm->end_p);
1194 }
1195
1196 /* Finished the traverse of an immediate use stmt list IMM by removing the
1197    placeholder node from the list.  */
1198
1199 static inline void
1200 end_imm_use_stmt_traverse (imm_use_iterator *imm)
1201 {
1202   delink_imm_use (&(imm->iter_node));
1203 }
1204
1205 /* Immediate use traversal of uses within a stmt require that all the
1206    uses on a stmt be sequentially listed.  This routine is used to build up
1207    this sequential list by adding USE_P to the end of the current list
1208    currently delimited by HEAD and LAST_P.  The new LAST_P value is
1209    returned.  */
1210
1211 static inline use_operand_p
1212 move_use_after_head (use_operand_p use_p, use_operand_p head,
1213                       use_operand_p last_p)
1214 {
1215   gcc_assert (USE_FROM_PTR (use_p) == USE_FROM_PTR (head));
1216   /* Skip head when we find it.  */
1217   if (use_p != head)
1218     {
1219       /* If use_p is already linked in after last_p, continue.  */
1220       if (last_p->next == use_p)
1221         last_p = use_p;
1222       else
1223         {
1224           /* Delink from current location, and link in at last_p.  */
1225           delink_imm_use (use_p);
1226           link_imm_use_to_list (use_p, last_p);
1227           last_p = use_p;
1228         }
1229     }
1230   return last_p;
1231 }
1232
1233
1234 /* This routine will relink all uses with the same stmt as HEAD into the list
1235    immediately following HEAD for iterator IMM.  */
1236
1237 static inline void
1238 link_use_stmts_after (use_operand_p head, imm_use_iterator *imm)
1239 {
1240   use_operand_p use_p;
1241   use_operand_p last_p = head;
1242   gimple head_stmt = USE_STMT (head);
1243   tree use = USE_FROM_PTR (head);
1244   ssa_op_iter op_iter;
1245   int flag;
1246
1247   /* Only look at virtual or real uses, depending on the type of HEAD.  */
1248   flag = (is_gimple_reg (use) ? SSA_OP_USE : SSA_OP_VIRTUAL_USES);
1249
1250   if (gimple_code (head_stmt) == GIMPLE_PHI)
1251     {
1252       FOR_EACH_PHI_ARG (use_p, head_stmt, op_iter, flag)
1253         if (USE_FROM_PTR (use_p) == use)
1254           last_p = move_use_after_head (use_p, head, last_p);
1255     }
1256   else
1257     {
1258       FOR_EACH_SSA_USE_OPERAND (use_p, head_stmt, op_iter, flag)
1259         if (USE_FROM_PTR (use_p) == use)
1260           last_p = move_use_after_head (use_p, head, last_p);
1261     }
1262   /* Link iter node in after last_p.  */
1263   if (imm->iter_node.prev != NULL)
1264     delink_imm_use (&imm->iter_node);
1265   link_imm_use_to_list (&(imm->iter_node), last_p);
1266 }
1267
1268 /* Initialize IMM to traverse over uses of VAR.  Return the first statement.  */
1269 static inline gimple
1270 first_imm_use_stmt (imm_use_iterator *imm, tree var)
1271 {
1272   gcc_assert (TREE_CODE (var) == SSA_NAME);
1273
1274   imm->end_p = &(SSA_NAME_IMM_USE_NODE (var));
1275   imm->imm_use = imm->end_p->next;
1276   imm->next_imm_name = NULL_USE_OPERAND_P;
1277
1278   /* iter_node is used as a marker within the immediate use list to indicate
1279      where the end of the current stmt's uses are.  Initialize it to NULL
1280      stmt and use, which indicates a marker node.  */
1281   imm->iter_node.prev = NULL_USE_OPERAND_P;
1282   imm->iter_node.next = NULL_USE_OPERAND_P;
1283   imm->iter_node.loc.stmt = NULL;
1284   imm->iter_node.use = NULL_USE_OPERAND_P;
1285
1286   if (end_imm_use_stmt_p (imm))
1287     return NULL;
1288
1289   link_use_stmts_after (imm->imm_use, imm);
1290
1291   return USE_STMT (imm->imm_use);
1292 }
1293
1294 /* Bump IMM to the next stmt which has a use of var.  */
1295
1296 static inline gimple
1297 next_imm_use_stmt (imm_use_iterator *imm)
1298 {
1299   imm->imm_use = imm->iter_node.next;
1300   if (end_imm_use_stmt_p (imm))
1301     {
1302       if (imm->iter_node.prev != NULL)
1303         delink_imm_use (&imm->iter_node);
1304       return NULL;
1305     }
1306
1307   link_use_stmts_after (imm->imm_use, imm);
1308   return USE_STMT (imm->imm_use);
1309 }
1310
1311 /* This routine will return the first use on the stmt IMM currently refers
1312    to.  */
1313
1314 static inline use_operand_p
1315 first_imm_use_on_stmt (imm_use_iterator *imm)
1316 {
1317   imm->next_imm_name = imm->imm_use->next;
1318   return imm->imm_use;
1319 }
1320
1321 /*  Return TRUE if the last use on the stmt IMM refers to has been visited.  */
1322
1323 static inline bool
1324 end_imm_use_on_stmt_p (const imm_use_iterator *imm)
1325 {
1326   return (imm->imm_use == &(imm->iter_node));
1327 }
1328
1329 /* Bump to the next use on the stmt IMM refers to, return NULL if done.  */
1330
1331 static inline use_operand_p
1332 next_imm_use_on_stmt (imm_use_iterator *imm)
1333 {
1334   imm->imm_use = imm->next_imm_name;
1335   if (end_imm_use_on_stmt_p (imm))
1336     return NULL_USE_OPERAND_P;
1337   else
1338     {
1339       imm->next_imm_name = imm->imm_use->next;
1340       return imm->imm_use;
1341     }
1342 }
1343
1344 /* Return true if VAR cannot be modified by the program.  */
1345
1346 static inline bool
1347 unmodifiable_var_p (const_tree var)
1348 {
1349   if (TREE_CODE (var) == SSA_NAME)
1350     var = SSA_NAME_VAR (var);
1351
1352   if (MTAG_P (var))
1353     return false;
1354
1355   return TREE_READONLY (var) && (TREE_STATIC (var) || DECL_EXTERNAL (var));
1356 }
1357
1358 /* Return true if REF, an ARRAY_REF, has an INDIRECT_REF somewhere in it.  */
1359
1360 static inline bool
1361 array_ref_contains_indirect_ref (const_tree ref)
1362 {
1363   gcc_assert (TREE_CODE (ref) == ARRAY_REF);
1364
1365   do {
1366     ref = TREE_OPERAND (ref, 0);
1367   } while (handled_component_p (ref));
1368
1369   return TREE_CODE (ref) == INDIRECT_REF;
1370 }
1371
1372 /* Return true if REF, a handled component reference, has an ARRAY_REF
1373    somewhere in it.  */
1374
1375 static inline bool
1376 ref_contains_array_ref (const_tree ref)
1377 {
1378   gcc_assert (handled_component_p (ref));
1379
1380   do {
1381     if (TREE_CODE (ref) == ARRAY_REF)
1382       return true;
1383     ref = TREE_OPERAND (ref, 0);
1384   } while (handled_component_p (ref));
1385
1386   return false;
1387 }
1388
1389 /* Return true, if the two ranges [POS1, SIZE1] and [POS2, SIZE2]
1390    overlap.  SIZE1 and/or SIZE2 can be (unsigned)-1 in which case the
1391    range is open-ended.  Otherwise return false.  */
1392
1393 static inline bool
1394 ranges_overlap_p (unsigned HOST_WIDE_INT pos1,
1395                   unsigned HOST_WIDE_INT size1,
1396                   unsigned HOST_WIDE_INT pos2,
1397                   unsigned HOST_WIDE_INT size2)
1398 {
1399   if (pos1 >= pos2
1400       && (size2 == (unsigned HOST_WIDE_INT)-1
1401           || pos1 < (pos2 + size2)))
1402     return true;
1403   if (pos2 >= pos1
1404       && (size1 == (unsigned HOST_WIDE_INT)-1
1405           || pos2 < (pos1 + size1)))
1406     return true;
1407
1408   return false;
1409 }
1410
1411 /* Return the memory tag associated with symbol SYM.  */
1412
1413 static inline tree
1414 symbol_mem_tag (tree sym)
1415 {
1416   tree tag = get_var_ann (sym)->symbol_mem_tag;
1417
1418 #if defined ENABLE_CHECKING
1419   if (tag)
1420     gcc_assert (TREE_CODE (tag) == SYMBOL_MEMORY_TAG);
1421 #endif
1422
1423   return tag;
1424 }
1425
1426
1427 /* Set the memory tag associated with symbol SYM.  */
1428
1429 static inline void
1430 set_symbol_mem_tag (tree sym, tree tag)
1431 {
1432 #if defined ENABLE_CHECKING
1433   if (tag)
1434     gcc_assert (TREE_CODE (tag) == SYMBOL_MEMORY_TAG);
1435 #endif
1436
1437   get_var_ann (sym)->symbol_mem_tag = tag;
1438 }
1439
1440 /* Accessor to tree-ssa-operands.c caches.  */
1441 static inline struct ssa_operands *
1442 gimple_ssa_operands (const struct function *fun)
1443 {
1444   return &fun->gimple_df->ssa_operands;
1445 }
1446
1447 /* Map describing reference statistics for function FN.  */
1448 static inline struct mem_ref_stats_d *
1449 gimple_mem_ref_stats (const struct function *fn)
1450 {
1451   return &fn->gimple_df->mem_ref_stats;
1452 }
1453
1454 /* Given an edge_var_map V, return the PHI arg definition.  */
1455
1456 static inline tree
1457 redirect_edge_var_map_def (edge_var_map *v)
1458 {
1459   return v->def;
1460 }
1461
1462 /* Given an edge_var_map V, return the PHI result.  */
1463
1464 static inline tree
1465 redirect_edge_var_map_result (edge_var_map *v)
1466 {
1467   return v->result;
1468 }
1469
1470
1471 /* Return an SSA_NAME node for variable VAR defined in statement STMT
1472    in function cfun.  */
1473
1474 static inline tree
1475 make_ssa_name (tree var, gimple stmt)
1476 {
1477   return make_ssa_name_fn (cfun, var, stmt);
1478 }
1479
1480 #endif /* _TREE_FLOW_INLINE_H  */