gcc/ssa-iterators.h

   1 /* Header file for SSA iterators.
   2    Copyright (C) 2013-2016 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify it under
   7 the terms of the GNU General Public License as published by the Free
   8 Software Foundation; either version 3, or (at your option) any later
   9 version.
  10
  11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GCC; see the file COPYING3.  If not see
  18 <http://www.gnu.org/licenses/>.  */
  19
  20 #ifndef GCC_SSA_ITERATORS_H
  21 #define GCC_SSA_ITERATORS_H
  22
  23 /* Immediate use lists are used to directly access all uses for an SSA
  24    name and get pointers to the statement for each use.
  25
  26    The structure ssa_use_operand_t consists of PREV and NEXT pointers
  27    to maintain the list.  A USE pointer, which points to address where
  28    the use is located and a LOC pointer which can point to the
  29    statement where the use is located, or, in the case of the root
  30    node, it points to the SSA name itself.
  31
  32    The list is anchored by an occurrence of ssa_operand_d *in* the
  33    ssa_name node itself (named 'imm_uses').  This node is uniquely
  34    identified by having a NULL USE pointer. and the LOC pointer
  35    pointing back to the ssa_name node itself.  This node forms the
  36    base for a circular list, and initially this is the only node in
  37    the list.
  38
  39    Fast iteration allows each use to be examined, but does not allow
  40    any modifications to the uses or stmts.
  41
  42    Normal iteration allows insertion, deletion, and modification. the
  43    iterator manages this by inserting a marker node into the list
  44    immediately before the node currently being examined in the list.
  45    this marker node is uniquely identified by having null stmt *and* a
  46    null use pointer.
  47
  48    When iterating to the next use, the iteration routines check to see
  49    if the node after the marker has changed. if it has, then the node
  50    following the marker is now the next one to be visited. if not, the
  51    marker node is moved past that node in the list (visualize it as
  52    bumping the marker node through the list).  this continues until
  53    the marker node is moved to the original anchor position. the
  54    marker node is then removed from the list.
  55
  56    If iteration is halted early, the marker node must be removed from
  57    the list before continuing.  */
  58 struct imm_use_iterator
  59 {
  60   /* This is the current use the iterator is processing.  */
  61   ssa_use_operand_t *imm_use;
  62   /* This marks the last use in the list (use node from SSA_NAME)  */
  63   ssa_use_operand_t *end_p;
  64   /* This node is inserted and used to mark the end of the uses for a stmt.  */
  65   ssa_use_operand_t iter_node;
  66   /* This is the next ssa_name to visit.  IMM_USE may get removed before
  67      the next one is traversed to, so it must be cached early.  */
  68   ssa_use_operand_t *next_imm_name;
  69 };
  70
  71
  72 /* Use this iterator when simply looking at stmts.  Adding, deleting or
  73    modifying stmts will cause this iterator to malfunction.  */
  74
  75 #define FOR_EACH_IMM_USE_FAST(DEST, ITER, SSAVAR)               \
  76   for ((DEST) = first_readonly_imm_use (&(ITER), (SSAVAR));     \
  77        !end_readonly_imm_use_p (&(ITER));                       \
  78        (void) ((DEST) = next_readonly_imm_use (&(ITER))))
  79
  80 /* Use this iterator to visit each stmt which has a use of SSAVAR.  */
  81
  82 #define FOR_EACH_IMM_USE_STMT(STMT, ITER, SSAVAR)               \
  83   for ((STMT) = first_imm_use_stmt (&(ITER), (SSAVAR));         \
  84        !end_imm_use_stmt_p (&(ITER));                           \
  85        (void) ((STMT) = next_imm_use_stmt (&(ITER))))
  86
  87 /* Use this to terminate the FOR_EACH_IMM_USE_STMT loop early.  Failure to
  88    do so will result in leaving a iterator marker node in the immediate
  89    use list, and nothing good will come from that.   */
  90 #define BREAK_FROM_IMM_USE_STMT(ITER)                           \
  91    {                                                            \
  92      end_imm_use_stmt_traverse (&(ITER));                       \
  93      break;                                                     \
  94    }
  95
  96
  97 /* Use this iterator in combination with FOR_EACH_IMM_USE_STMT to
  98    get access to each occurrence of ssavar on the stmt returned by
  99    that iterator..  for instance:
 100
 101      FOR_EACH_IMM_USE_STMT (stmt, iter, ssavar)
 102        {
 103          FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
 104            {
 105              SET_USE (use_p, blah);
 106            }
 107          update_stmt (stmt);
 108        }                                                         */
 109
 110 #define FOR_EACH_IMM_USE_ON_STMT(DEST, ITER)                    \
 111   for ((DEST) = first_imm_use_on_stmt (&(ITER));                \
 112        !end_imm_use_on_stmt_p (&(ITER));                        \
 113        (void) ((DEST) = next_imm_use_on_stmt (&(ITER))))
 114
 115
 116
 117 extern bool single_imm_use_1 (const ssa_use_operand_t *head,
 118                               use_operand_p *use_p, gimple **stmt);
 119
 120
 121 enum ssa_op_iter_type {
 122   ssa_op_iter_none = 0,
 123   ssa_op_iter_tree,
 124   ssa_op_iter_use,
 125   ssa_op_iter_def
 126 };
 127
 128 /* This structure is used in the operand iterator loops.  It contains the
 129    items required to determine which operand is retrieved next.  During
 130    optimization, this structure is scalarized, and any unused fields are
 131    optimized away, resulting in little overhead.  */
 132
 133 struct ssa_op_iter
 134 {
 135   enum ssa_op_iter_type iter_type;
 136   bool done;
 137   int flags;
 138   unsigned i;
 139   unsigned numops;
 140   use_optype_p uses;
 141   gimple *stmt;
 142 };
 143
 144 /* NOTE: Keep these in sync with doc/tree-ssa.texi.  */
 145 /* These flags are used to determine which operands are returned during
 146    execution of the loop.  */
 147 #define SSA_OP_USE              0x01    /* Real USE operands.  */
 148 #define SSA_OP_DEF              0x02    /* Real DEF operands.  */
 149 #define SSA_OP_VUSE             0x04    /* VUSE operands.  */
 150 #define SSA_OP_VDEF             0x08    /* VDEF operands.  */
 151 /* These are commonly grouped operand flags.  */
 152 #define SSA_OP_VIRTUAL_USES     (SSA_OP_VUSE)
 153 #define SSA_OP_VIRTUAL_DEFS     (SSA_OP_VDEF)
 154 #define SSA_OP_ALL_VIRTUALS     (SSA_OP_VIRTUAL_USES | SSA_OP_VIRTUAL_DEFS)
 155 #define SSA_OP_ALL_USES         (SSA_OP_VIRTUAL_USES | SSA_OP_USE)
 156 #define SSA_OP_ALL_DEFS         (SSA_OP_VIRTUAL_DEFS | SSA_OP_DEF)
 157 #define SSA_OP_ALL_OPERANDS     (SSA_OP_ALL_USES | SSA_OP_ALL_DEFS)
 158
 159 /* This macro executes a loop over the operands of STMT specified in FLAG,
 160    returning each operand as a 'tree' in the variable TREEVAR.  ITER is an
 161    ssa_op_iter structure used to control the loop.  */
 162 #define FOR_EACH_SSA_TREE_OPERAND(TREEVAR, STMT, ITER, FLAGS)   \
 163   for (TREEVAR = op_iter_init_tree (&(ITER), STMT, FLAGS);      \
 164        !op_iter_done (&(ITER));                                 \
 165        (void) (TREEVAR = op_iter_next_tree (&(ITER))))
 166
 167 /* This macro executes a loop over the operands of STMT specified in FLAG,
 168    returning each operand as a 'use_operand_p' in the variable USEVAR.
 169    ITER is an ssa_op_iter structure used to control the loop.  */
 170 #define FOR_EACH_SSA_USE_OPERAND(USEVAR, STMT, ITER, FLAGS)     \
 171   for (USEVAR = op_iter_init_use (&(ITER), STMT, FLAGS);        \
 172        !op_iter_done (&(ITER));                                 \
 173        USEVAR = op_iter_next_use (&(ITER)))
 174
 175 /* This macro executes a loop over the operands of STMT specified in FLAG,
 176    returning each operand as a 'def_operand_p' in the variable DEFVAR.
 177    ITER is an ssa_op_iter structure used to control the loop.  */
 178 #define FOR_EACH_SSA_DEF_OPERAND(DEFVAR, STMT, ITER, FLAGS)     \
 179   for (DEFVAR = op_iter_init_def (&(ITER), STMT, FLAGS);        \
 180        !op_iter_done (&(ITER));                                 \
 181        DEFVAR = op_iter_next_def (&(ITER)))
 182
 183 /* This macro will execute a loop over all the arguments of a PHI which
 184    match FLAGS.   A use_operand_p is always returned via USEVAR.  FLAGS
 185    can be either SSA_OP_USE or SSA_OP_VIRTUAL_USES or SSA_OP_ALL_USES.  */
 186 #define FOR_EACH_PHI_ARG(USEVAR, STMT, ITER, FLAGS)             \
 187   for ((USEVAR) = op_iter_init_phiuse (&(ITER), STMT, FLAGS);   \
 188        !op_iter_done (&(ITER));                                 \
 189        (USEVAR) = op_iter_next_use (&(ITER)))
 190
 191
 192 /* This macro will execute a loop over a stmt, regardless of whether it is
 193    a real stmt or a PHI node, looking at the USE nodes matching FLAGS.  */
 194 #define FOR_EACH_PHI_OR_STMT_USE(USEVAR, STMT, ITER, FLAGS)     \
 195   for ((USEVAR) = (gimple_code (STMT) == GIMPLE_PHI             \
 196                    ? op_iter_init_phiuse (&(ITER),              \
 197                                           as_a <gphi *> (STMT), \
 198                                           FLAGS)                \
 199                    : op_iter_init_use (&(ITER), STMT, FLAGS));  \
 200        !op_iter_done (&(ITER));                                 \
 201        (USEVAR) = op_iter_next_use (&(ITER)))
 202
 203 /* This macro will execute a loop over a stmt, regardless of whether it is
 204    a real stmt or a PHI node, looking at the DEF nodes matching FLAGS.  */
 205 #define FOR_EACH_PHI_OR_STMT_DEF(DEFVAR, STMT, ITER, FLAGS)     \
 206   for ((DEFVAR) = (gimple_code (STMT) == GIMPLE_PHI             \
 207                    ? op_iter_init_phidef (&(ITER),              \
 208                                           as_a <gphi *> (STMT), \
 209                                           FLAGS)                \
 210                    : op_iter_init_def (&(ITER), STMT, FLAGS));  \
 211        !op_iter_done (&(ITER));                                 \
 212        (DEFVAR) = op_iter_next_def (&(ITER)))
 213
 214 /* This macro returns an operand in STMT as a tree if it is the ONLY
 215    operand matching FLAGS.  If there are 0 or more than 1 operand matching
 216    FLAGS, then NULL_TREE is returned.  */
 217 #define SINGLE_SSA_TREE_OPERAND(STMT, FLAGS)                    \
 218   single_ssa_tree_operand (STMT, FLAGS)
 219
 220 /* This macro returns an operand in STMT as a use_operand_p if it is the ONLY
 221    operand matching FLAGS.  If there are 0 or more than 1 operand matching
 222    FLAGS, then NULL_USE_OPERAND_P is returned.  */
 223 #define SINGLE_SSA_USE_OPERAND(STMT, FLAGS)                     \
 224   single_ssa_use_operand (STMT, FLAGS)
 225
 226 /* This macro returns an operand in STMT as a def_operand_p if it is the ONLY
 227    operand matching FLAGS.  If there are 0 or more than 1 operand matching
 228    FLAGS, then NULL_DEF_OPERAND_P is returned.  */
 229 #define SINGLE_SSA_DEF_OPERAND(STMT, FLAGS)                     \
 230   single_ssa_def_operand (STMT, FLAGS)
 231
 232 /* This macro returns TRUE if there are no operands matching FLAGS in STMT.  */
 233 #define ZERO_SSA_OPERANDS(STMT, FLAGS)  zero_ssa_operands (STMT, FLAGS)
 234
 235 /* This macro counts the number of operands in STMT matching FLAGS.  */
 236 #define NUM_SSA_OPERANDS(STMT, FLAGS)   num_ssa_operands (STMT, FLAGS)
 237
 238
 239 /* Delink an immediate_uses node from its chain.  */
 240 static inline void
 241 delink_imm_use (ssa_use_operand_t *linknode)
 242 {
 243   /* Return if this node is not in a list.  */
 244   if (linknode->prev == NULL)
 245     return;
 246
 247   linknode->prev->next = linknode->next;
 248   linknode->next->prev = linknode->prev;
 249   linknode->prev = NULL;
 250   linknode->next = NULL;
 251 }
 252
 253 /* Link ssa_imm_use node LINKNODE into the chain for LIST.  */
 254 static inline void
 255 link_imm_use_to_list (ssa_use_operand_t *linknode, ssa_use_operand_t *list)
 256 {
 257   /* Link the new node at the head of the list.  If we are in the process of
 258      traversing the list, we won't visit any new nodes added to it.  */
 259   linknode->prev = list;
 260   linknode->next = list->next;
 261   list->next->prev = linknode;
 262   list->next = linknode;
 263 }
 264
 265 /* Link ssa_imm_use node LINKNODE into the chain for DEF.  */
 266 static inline void
 267 link_imm_use (ssa_use_operand_t *linknode, tree def)
 268 {
 269   ssa_use_operand_t *root;
 270
 271   if (!def || TREE_CODE (def) != SSA_NAME)
 272     linknode->prev = NULL;
 273   else
 274     {
 275       root = &(SSA_NAME_IMM_USE_NODE (def));
 276       if (linknode->use)
 277         gcc_checking_assert (*(linknode->use) == def);
 278       link_imm_use_to_list (linknode, root);
 279     }
 280 }
 281
 282 /* Set the value of a use pointed to by USE to VAL.  */
 283 static inline void
 284 set_ssa_use_from_ptr (use_operand_p use, tree val)
 285 {
 286   delink_imm_use (use);
 287   *(use->use) = val;
 288   link_imm_use (use, val);
 289 }
 290
 291 /* Link ssa_imm_use node LINKNODE into the chain for DEF, with use occurring
 292    in STMT.  */
 293 static inline void
 294 link_imm_use_stmt (ssa_use_operand_t *linknode, tree def, gimple *stmt)
 295 {
 296   if (stmt)
 297     link_imm_use (linknode, def);
 298   else
 299     link_imm_use (linknode, NULL);
 300   linknode->loc.stmt = stmt;
 301 }
 302
 303 /* Relink a new node in place of an old node in the list.  */
 304 static inline void
 305 relink_imm_use (ssa_use_operand_t *node, ssa_use_operand_t *old)
 306 {
 307   /* The node one had better be in the same list.  */
 308   gcc_checking_assert (*(old->use) == *(node->use));
 309   node->prev = old->prev;
 310   node->next = old->next;
 311   if (old->prev)
 312     {
 313       old->prev->next = node;
 314       old->next->prev = node;
 315       /* Remove the old node from the list.  */
 316       old->prev = NULL;
 317     }
 318 }
 319
 320 /* Relink ssa_imm_use node LINKNODE into the chain for OLD, with use occurring
 321    in STMT.  */
 322 static inline void
 323 relink_imm_use_stmt (ssa_use_operand_t *linknode, ssa_use_operand_t *old,
 324                      gimple *stmt)
 325 {
 326   if (stmt)
 327     relink_imm_use (linknode, old);
 328   else
 329     link_imm_use (linknode, NULL);
 330   linknode->loc.stmt = stmt;
 331 }
 332
 333
 334 /* Return true is IMM has reached the end of the immediate use list.  */
 335 static inline bool
 336 end_readonly_imm_use_p (const imm_use_iterator *imm)
 337 {
 338   return (imm->imm_use == imm->end_p);
 339 }
 340
 341 /* Initialize iterator IMM to process the list for VAR.  */
 342 static inline use_operand_p
 343 first_readonly_imm_use (imm_use_iterator *imm, tree var)
 344 {
 345   imm->end_p = &(SSA_NAME_IMM_USE_NODE (var));
 346   imm->imm_use = imm->end_p->next;
 347   imm->iter_node.next = imm->imm_use->next;
 348   if (end_readonly_imm_use_p (imm))
 349     return NULL_USE_OPERAND_P;
 350   return imm->imm_use;
 351 }
 352
 353 /* Bump IMM to the next use in the list.  */
 354 static inline use_operand_p
 355 next_readonly_imm_use (imm_use_iterator *imm)
 356 {
 357   use_operand_p old = imm->imm_use;
 358
 359   /* If this assertion fails, it indicates the 'next' pointer has changed
 360      since the last bump.  This indicates that the list is being modified
 361      via stmt changes, or SET_USE, or somesuch thing, and you need to be
 362      using the SAFE version of the iterator.  */
 363   if (flag_checking)
 364     {
 365       gcc_assert (imm->iter_node.next == old->next);
 366       imm->iter_node.next = old->next->next;
 367     }
 368
 369   imm->imm_use = old->next;
 370   if (end_readonly_imm_use_p (imm))
 371     return NULL_USE_OPERAND_P;
 372   return imm->imm_use;
 373 }
 374
 375
 376 /* Return true if VAR has no nondebug uses.  */
 377 static inline bool
 378 has_zero_uses (const_tree var)
 379 {
 380   const ssa_use_operand_t *const head = &(SSA_NAME_IMM_USE_NODE (var));
 381   const ssa_use_operand_t *ptr;
 382
 383   for (ptr = head->next; ptr != head; ptr = ptr->next)
 384     if (USE_STMT (ptr) && !is_gimple_debug (USE_STMT (ptr)))
 385       return false;
 386
 387   return true;
 388 }
 389
 390 /* Return true if VAR has a single nondebug use.  */
 391 static inline bool
 392 has_single_use (const_tree var)
 393 {
 394   const ssa_use_operand_t *const head = &(SSA_NAME_IMM_USE_NODE (var));
 395   const ssa_use_operand_t *ptr;
 396   bool single = false;
 397
 398   for (ptr = head->next; ptr != head; ptr = ptr->next)
 399     if (USE_STMT(ptr) && !is_gimple_debug (USE_STMT (ptr)))
 400       {
 401         if (single)
 402           return false;
 403         else
 404           single = true;
 405       }
 406
 407   return single;
 408 }
 409
 410 /* If VAR has only a single immediate nondebug use, return true, and
 411    set USE_P and STMT to the use pointer and stmt of occurrence.  */
 412 static inline bool
 413 single_imm_use (const_tree var, use_operand_p *use_p, gimple **stmt)
 414 {
 415   const ssa_use_operand_t *const ptr = &(SSA_NAME_IMM_USE_NODE (var));
 416
 417   /* If there aren't any uses whatsoever, we're done.  */
 418   if (ptr == ptr->next)
 419     {
 420     return_false:
 421       *use_p = NULL_USE_OPERAND_P;
 422       *stmt = NULL;
 423       return false;
 424     }
 425
 426   /* If there's a single use, check that it's not a debug stmt.  */
 427   if (ptr == ptr->next->next)
 428     {
 429       if (USE_STMT (ptr->next) && !is_gimple_debug (USE_STMT (ptr->next)))
 430         {
 431           *use_p = ptr->next;
 432           *stmt = ptr->next->loc.stmt;
 433           return true;
 434         }
 435       else
 436         goto return_false;
 437     }
 438
 439   return single_imm_use_1 (ptr, use_p, stmt);
 440 }
 441
 442 /* Return the number of nondebug immediate uses of VAR.  */
 443 static inline unsigned int
 444 num_imm_uses (const_tree var)
 445 {
 446   const ssa_use_operand_t *const start = &(SSA_NAME_IMM_USE_NODE (var));
 447   const ssa_use_operand_t *ptr;
 448   unsigned int num = 0;
 449
 450   if (!MAY_HAVE_DEBUG_STMTS)
 451     {
 452       for (ptr = start->next; ptr != start; ptr = ptr->next)
 453         if (USE_STMT (ptr))
 454           num++;
 455     }
 456   else
 457     for (ptr = start->next; ptr != start; ptr = ptr->next)
 458       if (USE_STMT (ptr) && !is_gimple_debug (USE_STMT (ptr)))
 459         num++;
 460
 461   return num;
 462 }
 463
 464 /*  -----------------------------------------------------------------------  */
 465
 466 /* The following set of routines are used to iterator over various type of
 467    SSA operands.  */
 468
 469 /* Return true if PTR is finished iterating.  */
 470 static inline bool
 471 op_iter_done (const ssa_op_iter *ptr)
 472 {
 473   return ptr->done;
 474 }
 475
 476 /* Get the next iterator use value for PTR.  */
 477 static inline use_operand_p
 478 op_iter_next_use (ssa_op_iter *ptr)
 479 {
 480   use_operand_p use_p;
 481   gcc_checking_assert (ptr->iter_type == ssa_op_iter_use);
 482   if (ptr->uses)
 483     {
 484       use_p = USE_OP_PTR (ptr->uses);
 485       ptr->uses = ptr->uses->next;
 486       return use_p;
 487     }
 488   if (ptr->i < ptr->numops)
 489     {
 490       return PHI_ARG_DEF_PTR (ptr->stmt, (ptr->i)++);
 491     }
 492   ptr->done = true;
 493   return NULL_USE_OPERAND_P;
 494 }
 495
 496 /* Get the next iterator def value for PTR.  */
 497 static inline def_operand_p
 498 op_iter_next_def (ssa_op_iter *ptr)
 499 {
 500   gcc_checking_assert (ptr->iter_type == ssa_op_iter_def);
 501   if (ptr->flags & SSA_OP_VDEF)
 502     {
 503       tree *p;
 504       ptr->flags &= ~SSA_OP_VDEF;
 505       p = gimple_vdef_ptr (ptr->stmt);
 506       if (p && *p)
 507         return p;
 508     }
 509   if (ptr->flags & SSA_OP_DEF)
 510     {
 511       while (ptr->i < ptr->numops)
 512         {
 513           tree *val = gimple_op_ptr (ptr->stmt, ptr->i);
 514           ptr->i++;
 515           if (*val)
 516             {
 517               if (TREE_CODE (*val) == TREE_LIST)
 518                 val = &TREE_VALUE (*val);
 519               if (TREE_CODE (*val) == SSA_NAME
 520                   || is_gimple_reg (*val))
 521                 return val;
 522             }
 523         }
 524       ptr->flags &= ~SSA_OP_DEF;
 525     }
 526
 527   ptr->done = true;
 528   return NULL_DEF_OPERAND_P;
 529 }
 530
 531 /* Get the next iterator tree value for PTR.  */
 532 static inline tree
 533 op_iter_next_tree (ssa_op_iter *ptr)
 534 {
 535   tree val;
 536   gcc_checking_assert (ptr->iter_type == ssa_op_iter_tree);
 537   if (ptr->uses)
 538     {
 539       val = USE_OP (ptr->uses);
 540       ptr->uses = ptr->uses->next;
 541       return val;
 542     }
 543   if (ptr->flags & SSA_OP_VDEF)
 544     {
 545       ptr->flags &= ~SSA_OP_VDEF;
 546       if ((val = gimple_vdef (ptr->stmt)))
 547         return val;
 548     }
 549   if (ptr->flags & SSA_OP_DEF)
 550     {
 551       while (ptr->i < ptr->numops)
 552         {
 553           val = gimple_op (ptr->stmt, ptr->i);
 554           ptr->i++;
 555           if (val)
 556             {
 557               if (TREE_CODE (val) == TREE_LIST)
 558                 val = TREE_VALUE (val);
 559               if (TREE_CODE (val) == SSA_NAME
 560                   || is_gimple_reg (val))
 561                 return val;
 562             }
 563         }
 564       ptr->flags &= ~SSA_OP_DEF;
 565     }
 566
 567   ptr->done = true;
 568   return NULL_TREE;
 569 }
 570
 571
 572 /* This functions clears the iterator PTR, and marks it done.  This is normally
 573    used to prevent warnings in the compile about might be uninitialized
 574    components.  */
 575
 576 static inline void
 577 clear_and_done_ssa_iter (ssa_op_iter *ptr)
 578 {
 579   ptr->i = 0;
 580   ptr->numops = 0;
 581   ptr->uses = NULL;
 582   ptr->iter_type = ssa_op_iter_none;
 583   ptr->stmt = NULL;
 584   ptr->done = true;
 585   ptr->flags = 0;
 586 }
 587
 588 /* Initialize the iterator PTR to the virtual defs in STMT.  */
 589 static inline void
 590 op_iter_init (ssa_op_iter *ptr, gimple *stmt, int flags)
 591 {
 592   /* PHI nodes require a different iterator initialization path.  We
 593      do not support iterating over virtual defs or uses without
 594      iterating over defs or uses at the same time.  */
 595   gcc_checking_assert (gimple_code (stmt) != GIMPLE_PHI
 596                        && (!(flags & SSA_OP_VDEF) || (flags & SSA_OP_DEF))
 597                        && (!(flags & SSA_OP_VUSE) || (flags & SSA_OP_USE)));
 598   ptr->numops = 0;
 599   if (flags & (SSA_OP_DEF | SSA_OP_VDEF))
 600     {
 601       switch (gimple_code (stmt))
 602         {
 603           case GIMPLE_ASSIGN:
 604           case GIMPLE_CALL:
 605             ptr->numops = 1;
 606             break;
 607           case GIMPLE_ASM:
 608             ptr->numops = gimple_asm_noutputs (as_a <gasm *> (stmt));
 609             break;
 610           default:
 611             ptr->numops = 0;
 612             flags &= ~(SSA_OP_DEF | SSA_OP_VDEF);
 613             break;
 614         }
 615     }
 616   ptr->uses = (flags & (SSA_OP_USE|SSA_OP_VUSE)) ? gimple_use_ops (stmt) : NULL;
 617   if (!(flags & SSA_OP_VUSE)
 618       && ptr->uses
 619       && gimple_vuse (stmt) != NULL_TREE)
 620     ptr->uses = ptr->uses->next;
 621   ptr->done = false;
 622   ptr->i = 0;
 623
 624   ptr->stmt = stmt;
 625   ptr->flags = flags;
 626 }
 627
 628 /* Initialize iterator PTR to the use operands in STMT based on FLAGS. Return
 629    the first use.  */
 630 static inline use_operand_p
 631 op_iter_init_use (ssa_op_iter *ptr, gimple *stmt, int flags)
 632 {
 633   gcc_checking_assert ((flags & SSA_OP_ALL_DEFS) == 0
 634                        && (flags & SSA_OP_USE));
 635   op_iter_init (ptr, stmt, flags);
 636   ptr->iter_type = ssa_op_iter_use;
 637   return op_iter_next_use (ptr);
 638 }
 639
 640 /* Initialize iterator PTR to the def operands in STMT based on FLAGS. Return
 641    the first def.  */
 642 static inline def_operand_p
 643 op_iter_init_def (ssa_op_iter *ptr, gimple *stmt, int flags)
 644 {
 645   gcc_checking_assert ((flags & SSA_OP_ALL_USES) == 0
 646                        && (flags & SSA_OP_DEF));
 647   op_iter_init (ptr, stmt, flags);
 648   ptr->iter_type = ssa_op_iter_def;
 649   return op_iter_next_def (ptr);
 650 }
 651
 652 /* Initialize iterator PTR to the operands in STMT based on FLAGS. Return
 653    the first operand as a tree.  */
 654 static inline tree
 655 op_iter_init_tree (ssa_op_iter *ptr, gimple *stmt, int flags)
 656 {
 657   op_iter_init (ptr, stmt, flags);
 658   ptr->iter_type = ssa_op_iter_tree;
 659   return op_iter_next_tree (ptr);
 660 }
 661
 662
 663 /* If there is a single operand in STMT matching FLAGS, return it.  Otherwise
 664    return NULL.  */
 665 static inline tree
 666 single_ssa_tree_operand (gimple *stmt, int flags)
 667 {
 668   tree var;
 669   ssa_op_iter iter;
 670
 671   var = op_iter_init_tree (&iter, stmt, flags);
 672   if (op_iter_done (&iter))
 673     return NULL_TREE;
 674   op_iter_next_tree (&iter);
 675   if (op_iter_done (&iter))
 676     return var;
 677   return NULL_TREE;
 678 }
 679
 680
 681 /* If there is a single operand in STMT matching FLAGS, return it.  Otherwise
 682    return NULL.  */
 683 static inline use_operand_p
 684 single_ssa_use_operand (gimple *stmt, int flags)
 685 {
 686   use_operand_p var;
 687   ssa_op_iter iter;
 688
 689   var = op_iter_init_use (&iter, stmt, flags);
 690   if (op_iter_done (&iter))
 691     return NULL_USE_OPERAND_P;
 692   op_iter_next_use (&iter);
 693   if (op_iter_done (&iter))
 694     return var;
 695   return NULL_USE_OPERAND_P;
 696 }
 697
 698
 699
 700 /* If there is a single operand in STMT matching FLAGS, return it.  Otherwise
 701    return NULL.  */
 702 static inline def_operand_p
 703 single_ssa_def_operand (gimple *stmt, int flags)
 704 {
 705   def_operand_p var;
 706   ssa_op_iter iter;
 707
 708   var = op_iter_init_def (&iter, stmt, flags);
 709   if (op_iter_done (&iter))
 710     return NULL_DEF_OPERAND_P;
 711   op_iter_next_def (&iter);
 712   if (op_iter_done (&iter))
 713     return var;
 714   return NULL_DEF_OPERAND_P;
 715 }
 716
 717
 718 /* Return true if there are zero operands in STMT matching the type
 719    given in FLAGS.  */
 720 static inline bool
 721 zero_ssa_operands (gimple *stmt, int flags)
 722 {
 723   ssa_op_iter iter;
 724
 725   op_iter_init_tree (&iter, stmt, flags);
 726   return op_iter_done (&iter);
 727 }
 728
 729
 730 /* Return the number of operands matching FLAGS in STMT.  */
 731 static inline int
 732 num_ssa_operands (gimple *stmt, int flags)
 733 {
 734   ssa_op_iter iter;
 735   tree t;
 736   int num = 0;
 737
 738   gcc_checking_assert (gimple_code (stmt) != GIMPLE_PHI);
 739   FOR_EACH_SSA_TREE_OPERAND (t, stmt, iter, flags)
 740     num++;
 741   return num;
 742 }
 743
 744 /* If there is a single DEF in the PHI node which matches FLAG, return it.
 745    Otherwise return NULL_DEF_OPERAND_P.  */
 746 static inline tree
 747 single_phi_def (gphi *stmt, int flags)
 748 {
 749   tree def = PHI_RESULT (stmt);
 750   if ((flags & SSA_OP_DEF) && is_gimple_reg (def))
 751     return def;
 752   if ((flags & SSA_OP_VIRTUAL_DEFS) && !is_gimple_reg (def))
 753     return def;
 754   return NULL_TREE;
 755 }
 756
 757 /* Initialize the iterator PTR for uses matching FLAGS in PHI.  FLAGS should
 758    be either SSA_OP_USES or SSA_OP_VIRTUAL_USES.  */
 759 static inline use_operand_p
 760 op_iter_init_phiuse (ssa_op_iter *ptr, gphi *phi, int flags)
 761 {
 762   tree phi_def = gimple_phi_result (phi);
 763   int comp;
 764
 765   clear_and_done_ssa_iter (ptr);
 766   ptr->done = false;
 767
 768   gcc_checking_assert ((flags & (SSA_OP_USE | SSA_OP_VIRTUAL_USES)) != 0);
 769
 770   comp = (is_gimple_reg (phi_def) ? SSA_OP_USE : SSA_OP_VIRTUAL_USES);
 771
 772   /* If the PHI node doesn't the operand type we care about, we're done.  */
 773   if ((flags & comp) == 0)
 774     {
 775       ptr->done = true;
 776       return NULL_USE_OPERAND_P;
 777     }
 778
 779   ptr->stmt = phi;
 780   ptr->numops = gimple_phi_num_args (phi);
 781   ptr->iter_type = ssa_op_iter_use;
 782   ptr->flags = flags;
 783   return op_iter_next_use (ptr);
 784 }
 785
 786
 787 /* Start an iterator for a PHI definition.  */
 788
 789 static inline def_operand_p
 790 op_iter_init_phidef (ssa_op_iter *ptr, gphi *phi, int flags)
 791 {
 792   tree phi_def = PHI_RESULT (phi);
 793   int comp;
 794
 795   clear_and_done_ssa_iter (ptr);
 796   ptr->done = false;
 797
 798   gcc_checking_assert ((flags & (SSA_OP_DEF | SSA_OP_VIRTUAL_DEFS)) != 0);
 799
 800   comp = (is_gimple_reg (phi_def) ? SSA_OP_DEF : SSA_OP_VIRTUAL_DEFS);
 801
 802   /* If the PHI node doesn't have the operand type we care about,
 803      we're done.  */
 804   if ((flags & comp) == 0)
 805     {
 806       ptr->done = true;
 807       return NULL_DEF_OPERAND_P;
 808     }
 809
 810   ptr->iter_type = ssa_op_iter_def;
 811   /* The first call to op_iter_next_def will terminate the iterator since
 812      all the fields are NULL.  Simply return the result here as the first and
 813      therefore only result.  */
 814   return PHI_RESULT_PTR (phi);
 815 }
 816
 817 /* Return true is IMM has reached the end of the immediate use stmt list.  */
 818
 819 static inline bool
 820 end_imm_use_stmt_p (const imm_use_iterator *imm)
 821 {
 822   return (imm->imm_use == imm->end_p);
 823 }
 824
 825 /* Finished the traverse of an immediate use stmt list IMM by removing the
 826    placeholder node from the list.  */
 827
 828 static inline void
 829 end_imm_use_stmt_traverse (imm_use_iterator *imm)
 830 {
 831   delink_imm_use (&(imm->iter_node));
 832 }
 833
 834 /* Immediate use traversal of uses within a stmt require that all the
 835    uses on a stmt be sequentially listed.  This routine is used to build up
 836    this sequential list by adding USE_P to the end of the current list
 837    currently delimited by HEAD and LAST_P.  The new LAST_P value is
 838    returned.  */
 839
 840 static inline use_operand_p
 841 move_use_after_head (use_operand_p use_p, use_operand_p head,
 842                       use_operand_p last_p)
 843 {
 844   gcc_checking_assert (USE_FROM_PTR (use_p) == USE_FROM_PTR (head));
 845   /* Skip head when we find it.  */
 846   if (use_p != head)
 847     {
 848       /* If use_p is already linked in after last_p, continue.  */
 849       if (last_p->next == use_p)
 850         last_p = use_p;
 851       else
 852         {
 853           /* Delink from current location, and link in at last_p.  */
 854           delink_imm_use (use_p);
 855           link_imm_use_to_list (use_p, last_p);
 856           last_p = use_p;
 857         }
 858     }
 859   return last_p;
 860 }
 861
 862
 863 /* This routine will relink all uses with the same stmt as HEAD into the list
 864    immediately following HEAD for iterator IMM.  */
 865
 866 static inline void
 867 link_use_stmts_after (use_operand_p head, imm_use_iterator *imm)
 868 {
 869   use_operand_p use_p;
 870   use_operand_p last_p = head;
 871   gimple *head_stmt = USE_STMT (head);
 872   tree use = USE_FROM_PTR (head);
 873   ssa_op_iter op_iter;
 874   int flag;
 875
 876   /* Only look at virtual or real uses, depending on the type of HEAD.  */
 877   flag = (is_gimple_reg (use) ? SSA_OP_USE : SSA_OP_VIRTUAL_USES);
 878
 879   if (gphi *phi = dyn_cast <gphi *> (head_stmt))
 880     {
 881       FOR_EACH_PHI_ARG (use_p, phi, op_iter, flag)
 882         if (USE_FROM_PTR (use_p) == use)
 883           last_p = move_use_after_head (use_p, head, last_p);
 884     }
 885   else
 886     {
 887       if (flag == SSA_OP_USE)
 888         {
 889           FOR_EACH_SSA_USE_OPERAND (use_p, head_stmt, op_iter, flag)
 890             if (USE_FROM_PTR (use_p) == use)
 891               last_p = move_use_after_head (use_p, head, last_p);
 892         }
 893       else if ((use_p = gimple_vuse_op (head_stmt)) != NULL_USE_OPERAND_P)
 894         {
 895           if (USE_FROM_PTR (use_p) == use)
 896             last_p = move_use_after_head (use_p, head, last_p);
 897         }
 898     }
 899   /* Link iter node in after last_p.  */
 900   if (imm->iter_node.prev != NULL)
 901     delink_imm_use (&imm->iter_node);
 902   link_imm_use_to_list (&(imm->iter_node), last_p);
 903 }
 904
 905 /* Initialize IMM to traverse over uses of VAR.  Return the first statement.  */
 906 static inline gimple *
 907 first_imm_use_stmt (imm_use_iterator *imm, tree var)
 908 {
 909   imm->end_p = &(SSA_NAME_IMM_USE_NODE (var));
 910   imm->imm_use = imm->end_p->next;
 911   imm->next_imm_name = NULL_USE_OPERAND_P;
 912
 913   /* iter_node is used as a marker within the immediate use list to indicate
 914      where the end of the current stmt's uses are.  Initialize it to NULL
 915      stmt and use, which indicates a marker node.  */
 916   imm->iter_node.prev = NULL_USE_OPERAND_P;
 917   imm->iter_node.next = NULL_USE_OPERAND_P;
 918   imm->iter_node.loc.stmt = NULL;
 919   imm->iter_node.use = NULL;
 920
 921   if (end_imm_use_stmt_p (imm))
 922     return NULL;
 923
 924   link_use_stmts_after (imm->imm_use, imm);
 925
 926   return USE_STMT (imm->imm_use);
 927 }
 928
 929 /* Bump IMM to the next stmt which has a use of var.  */
 930
 931 static inline gimple *
 932 next_imm_use_stmt (imm_use_iterator *imm)
 933 {
 934   imm->imm_use = imm->iter_node.next;
 935   if (end_imm_use_stmt_p (imm))
 936     {
 937       if (imm->iter_node.prev != NULL)
 938         delink_imm_use (&imm->iter_node);
 939       return NULL;
 940     }
 941
 942   link_use_stmts_after (imm->imm_use, imm);
 943   return USE_STMT (imm->imm_use);
 944 }
 945
 946 /* This routine will return the first use on the stmt IMM currently refers
 947    to.  */
 948
 949 static inline use_operand_p
 950 first_imm_use_on_stmt (imm_use_iterator *imm)
 951 {
 952   imm->next_imm_name = imm->imm_use->next;
 953   return imm->imm_use;
 954 }
 955
 956 /*  Return TRUE if the last use on the stmt IMM refers to has been visited.  */
 957
 958 static inline bool
 959 end_imm_use_on_stmt_p (const imm_use_iterator *imm)
 960 {
 961   return (imm->imm_use == &(imm->iter_node));
 962 }
 963
 964 /* Bump to the next use on the stmt IMM refers to, return NULL if done.  */
 965
 966 static inline use_operand_p
 967 next_imm_use_on_stmt (imm_use_iterator *imm)
 968 {
 969   imm->imm_use = imm->next_imm_name;
 970   if (end_imm_use_on_stmt_p (imm))
 971     return NULL_USE_OPERAND_P;
 972   else
 973     {
 974       imm->next_imm_name = imm->imm_use->next;
 975       return imm->imm_use;
 976     }
 977 }
 978
 979 /* Delink all immediate_use information for STMT.  */
 980 static inline void
 981 delink_stmt_imm_use (gimple *stmt)
 982 {
 983    ssa_op_iter iter;
 984    use_operand_p use_p;
 985
 986    if (ssa_operands_active (cfun))
 987      FOR_EACH_PHI_OR_STMT_USE (use_p, stmt, iter, SSA_OP_ALL_USES)
 988        delink_imm_use (use_p);
 989 }
 990
 991 #endif /* GCC_TREE_SSA_ITERATORS_H */