2016-05-04 Thomas Preud'homme <thomas.preudhomme@arm.com>
[official-gcc.git] / gcc / ssa-iterators.h
bloba7d75d6d47e682bf22ae7a5479e58ba997a7fa2b
1 /* Header file for SSA iterators.
2 Copyright (C) 2013-2016 Free Software Foundation, Inc.
4 This file is part of GCC.
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.
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.
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/>. */
20 #ifndef GCC_SSA_ITERATORS_H
21 #define GCC_SSA_ITERATORS_H
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.
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.
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.
39 Fast iteration allows each use to be examined, but does not allow
40 any modifications to the uses or stmts.
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.
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.
56 If iteration is halted early, the marker node must be removed from
57 the list before continuing. */
58 struct imm_use_iterator
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;
72 /* Use this iterator when simply looking at stmts. Adding, deleting or
73 modifying stmts will cause this iterator to malfunction. */
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))))
80 /* Use this iterator to visit each stmt which has a use of SSAVAR. */
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))))
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; \
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:
101 FOR_EACH_IMM_USE_STMT (stmt, iter, ssavar)
103 FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
105 SET_USE (use_p, blah);
107 update_stmt (stmt);
108 } */
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))))
117 extern bool single_imm_use_1 (const ssa_use_operand_t *head,
118 use_operand_p *use_p, gimple **stmt);
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
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. */
133 struct ssa_op_iter
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;
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)
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))))
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)))
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)))
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)))
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)))
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)))
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)
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)
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)
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)
235 /* This macro counts the number of operands in STMT matching FLAGS. */
236 #define NUM_SSA_OPERANDS(STMT, FLAGS) num_ssa_operands (STMT, FLAGS)
239 /* Delink an immediate_uses node from its chain. */
240 static inline void
241 delink_imm_use (ssa_use_operand_t *linknode)
243 /* Return if this node is not in a list. */
244 if (linknode->prev == NULL)
245 return;
247 linknode->prev->next = linknode->next;
248 linknode->next->prev = linknode->prev;
249 linknode->prev = NULL;
250 linknode->next = NULL;
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)
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;
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)
269 ssa_use_operand_t *root;
271 if (!def || TREE_CODE (def) != SSA_NAME)
272 linknode->prev = NULL;
273 else
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);
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)
286 delink_imm_use (use);
287 *(use->use) = val;
288 link_imm_use (use, val);
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)
296 if (stmt)
297 link_imm_use (linknode, def);
298 else
299 link_imm_use (linknode, NULL);
300 linknode->loc.stmt = stmt;
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)
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)
313 old->prev->next = node;
314 old->next->prev = node;
315 /* Remove the old node from the list. */
316 old->prev = NULL;
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)
326 if (stmt)
327 relink_imm_use (linknode, old);
328 else
329 link_imm_use (linknode, NULL);
330 linknode->loc.stmt = stmt;
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)
338 return (imm->imm_use == imm->end_p);
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)
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;
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)
357 use_operand_p old = imm->imm_use;
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)
365 gcc_assert (imm->iter_node.next == old->next);
366 imm->iter_node.next = old->next->next;
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;
376 /* Return true if VAR has no nondebug uses. */
377 static inline bool
378 has_zero_uses (const_tree var)
380 const ssa_use_operand_t *const head = &(SSA_NAME_IMM_USE_NODE (var));
381 const ssa_use_operand_t *ptr;
383 for (ptr = head->next; ptr != head; ptr = ptr->next)
384 if (USE_STMT (ptr) && !is_gimple_debug (USE_STMT (ptr)))
385 return false;
387 return true;
390 /* Return true if VAR has a single nondebug use. */
391 static inline bool
392 has_single_use (const_tree var)
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;
398 for (ptr = head->next; ptr != head; ptr = ptr->next)
399 if (USE_STMT(ptr) && !is_gimple_debug (USE_STMT (ptr)))
401 if (single)
402 return false;
403 else
404 single = true;
407 return single;
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)
415 const ssa_use_operand_t *const ptr = &(SSA_NAME_IMM_USE_NODE (var));
417 /* If there aren't any uses whatsoever, we're done. */
418 if (ptr == ptr->next)
420 return_false:
421 *use_p = NULL_USE_OPERAND_P;
422 *stmt = NULL;
423 return false;
426 /* If there's a single use, check that it's not a debug stmt. */
427 if (ptr == ptr->next->next)
429 if (USE_STMT (ptr->next) && !is_gimple_debug (USE_STMT (ptr->next)))
431 *use_p = ptr->next;
432 *stmt = ptr->next->loc.stmt;
433 return true;
435 else
436 goto return_false;
439 return single_imm_use_1 (ptr, use_p, stmt);
442 /* Return the number of nondebug immediate uses of VAR. */
443 static inline unsigned int
444 num_imm_uses (const_tree var)
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;
450 if (!MAY_HAVE_DEBUG_STMTS)
452 for (ptr = start->next; ptr != start; ptr = ptr->next)
453 if (USE_STMT (ptr))
454 num++;
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++;
461 return num;
464 /* ----------------------------------------------------------------------- */
466 /* The following set of routines are used to iterator over various type of
467 SSA operands. */
469 /* Return true if PTR is finished iterating. */
470 static inline bool
471 op_iter_done (const ssa_op_iter *ptr)
473 return ptr->done;
476 /* Get the next iterator use value for PTR. */
477 static inline use_operand_p
478 op_iter_next_use (ssa_op_iter *ptr)
480 use_operand_p use_p;
481 gcc_checking_assert (ptr->iter_type == ssa_op_iter_use);
482 if (ptr->uses)
484 use_p = USE_OP_PTR (ptr->uses);
485 ptr->uses = ptr->uses->next;
486 return use_p;
488 if (ptr->i < ptr->numops)
490 return PHI_ARG_DEF_PTR (ptr->stmt, (ptr->i)++);
492 ptr->done = true;
493 return NULL_USE_OPERAND_P;
496 /* Get the next iterator def value for PTR. */
497 static inline def_operand_p
498 op_iter_next_def (ssa_op_iter *ptr)
500 gcc_checking_assert (ptr->iter_type == ssa_op_iter_def);
501 if (ptr->flags & SSA_OP_VDEF)
503 tree *p;
504 ptr->flags &= ~SSA_OP_VDEF;
505 p = gimple_vdef_ptr (ptr->stmt);
506 if (p && *p)
507 return p;
509 if (ptr->flags & SSA_OP_DEF)
511 while (ptr->i < ptr->numops)
513 tree *val = gimple_op_ptr (ptr->stmt, ptr->i);
514 ptr->i++;
515 if (*val)
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;
524 ptr->flags &= ~SSA_OP_DEF;
527 ptr->done = true;
528 return NULL_DEF_OPERAND_P;
531 /* Get the next iterator tree value for PTR. */
532 static inline tree
533 op_iter_next_tree (ssa_op_iter *ptr)
535 tree val;
536 gcc_checking_assert (ptr->iter_type == ssa_op_iter_tree);
537 if (ptr->uses)
539 val = USE_OP (ptr->uses);
540 ptr->uses = ptr->uses->next;
541 return val;
543 if (ptr->flags & SSA_OP_VDEF)
545 ptr->flags &= ~SSA_OP_VDEF;
546 if ((val = gimple_vdef (ptr->stmt)))
547 return val;
549 if (ptr->flags & SSA_OP_DEF)
551 while (ptr->i < ptr->numops)
553 val = gimple_op (ptr->stmt, ptr->i);
554 ptr->i++;
555 if (val)
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;
564 ptr->flags &= ~SSA_OP_DEF;
567 ptr->done = true;
568 return NULL_TREE;
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. */
576 static inline void
577 clear_and_done_ssa_iter (ssa_op_iter *ptr)
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;
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)
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))
601 switch (gimple_code (stmt))
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;
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;
624 ptr->stmt = stmt;
625 ptr->flags = flags;
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)
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);
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)
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);
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)
657 op_iter_init (ptr, stmt, flags);
658 ptr->iter_type = ssa_op_iter_tree;
659 return op_iter_next_tree (ptr);
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)
668 tree var;
669 ssa_op_iter iter;
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;
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)
686 use_operand_p var;
687 ssa_op_iter iter;
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;
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)
705 def_operand_p var;
706 ssa_op_iter iter;
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;
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)
723 ssa_op_iter iter;
725 op_iter_init_tree (&iter, stmt, flags);
726 return op_iter_done (&iter);
730 /* Return the number of operands matching FLAGS in STMT. */
731 static inline int
732 num_ssa_operands (gimple *stmt, int flags)
734 ssa_op_iter iter;
735 tree t;
736 int num = 0;
738 gcc_checking_assert (gimple_code (stmt) != GIMPLE_PHI);
739 FOR_EACH_SSA_TREE_OPERAND (t, stmt, iter, flags)
740 num++;
741 return num;
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)
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;
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)
762 tree phi_def = gimple_phi_result (phi);
763 int comp;
765 clear_and_done_ssa_iter (ptr);
766 ptr->done = false;
768 gcc_checking_assert ((flags & (SSA_OP_USE | SSA_OP_VIRTUAL_USES)) != 0);
770 comp = (is_gimple_reg (phi_def) ? SSA_OP_USE : SSA_OP_VIRTUAL_USES);
772 /* If the PHI node doesn't the operand type we care about, we're done. */
773 if ((flags & comp) == 0)
775 ptr->done = true;
776 return NULL_USE_OPERAND_P;
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);
787 /* Start an iterator for a PHI definition. */
789 static inline def_operand_p
790 op_iter_init_phidef (ssa_op_iter *ptr, gphi *phi, int flags)
792 tree phi_def = PHI_RESULT (phi);
793 int comp;
795 clear_and_done_ssa_iter (ptr);
796 ptr->done = false;
798 gcc_checking_assert ((flags & (SSA_OP_DEF | SSA_OP_VIRTUAL_DEFS)) != 0);
800 comp = (is_gimple_reg (phi_def) ? SSA_OP_DEF : SSA_OP_VIRTUAL_DEFS);
802 /* If the PHI node doesn't have the operand type we care about,
803 we're done. */
804 if ((flags & comp) == 0)
806 ptr->done = true;
807 return NULL_DEF_OPERAND_P;
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);
817 /* Return true is IMM has reached the end of the immediate use stmt list. */
819 static inline bool
820 end_imm_use_stmt_p (const imm_use_iterator *imm)
822 return (imm->imm_use == imm->end_p);
825 /* Finished the traverse of an immediate use stmt list IMM by removing the
826 placeholder node from the list. */
828 static inline void
829 end_imm_use_stmt_traverse (imm_use_iterator *imm)
831 delink_imm_use (&(imm->iter_node));
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. */
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)
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)
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
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;
859 return last_p;
863 /* This routine will relink all uses with the same stmt as HEAD into the list
864 immediately following HEAD for iterator IMM. */
866 static inline void
867 link_use_stmts_after (use_operand_p head, imm_use_iterator *imm)
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;
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);
879 if (gphi *phi = dyn_cast <gphi *> (head_stmt))
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);
885 else
887 if (flag == SSA_OP_USE)
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);
893 else if ((use_p = gimple_vuse_op (head_stmt)) != NULL_USE_OPERAND_P)
895 if (USE_FROM_PTR (use_p) == use)
896 last_p = move_use_after_head (use_p, head, last_p);
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);
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)
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;
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;
921 if (end_imm_use_stmt_p (imm))
922 return NULL;
924 link_use_stmts_after (imm->imm_use, imm);
926 return USE_STMT (imm->imm_use);
929 /* Bump IMM to the next stmt which has a use of var. */
931 static inline gimple *
932 next_imm_use_stmt (imm_use_iterator *imm)
934 imm->imm_use = imm->iter_node.next;
935 if (end_imm_use_stmt_p (imm))
937 if (imm->iter_node.prev != NULL)
938 delink_imm_use (&imm->iter_node);
939 return NULL;
942 link_use_stmts_after (imm->imm_use, imm);
943 return USE_STMT (imm->imm_use);
946 /* This routine will return the first use on the stmt IMM currently refers
947 to. */
949 static inline use_operand_p
950 first_imm_use_on_stmt (imm_use_iterator *imm)
952 imm->next_imm_name = imm->imm_use->next;
953 return imm->imm_use;
956 /* Return TRUE if the last use on the stmt IMM refers to has been visited. */
958 static inline bool
959 end_imm_use_on_stmt_p (const imm_use_iterator *imm)
961 return (imm->imm_use == &(imm->iter_node));
964 /* Bump to the next use on the stmt IMM refers to, return NULL if done. */
966 static inline use_operand_p
967 next_imm_use_on_stmt (imm_use_iterator *imm)
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
974 imm->next_imm_name = imm->imm_use->next;
975 return imm->imm_use;
979 /* Delink all immediate_use information for STMT. */
980 static inline void
981 delink_stmt_imm_use (gimple *stmt)
983 ssa_op_iter iter;
984 use_operand_p use_p;
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);
991 #endif /* GCC_TREE_SSA_ITERATORS_H */