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