1 /* Header file for SSA iterators.
2 Copyright (C) 2013-2014 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
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
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
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
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) \
92 end_imm_use_stmt_traverse (&(ITER)); \
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);
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 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
);
122 enum ssa_op_iter_type
{
123 ssa_op_iter_none
= 0,
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. */
136 enum ssa_op_iter_type iter_type
;
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)
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))))
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)))
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)))
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)))
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), STMT, FLAGS) \
198 : op_iter_init_use (&(ITER), STMT, FLAGS)); \
199 !op_iter_done (&(ITER)); \
200 (USEVAR) = op_iter_next_use (&(ITER)))
202 /* This macro will execute a loop over a stmt, regardless of whether it is
203 a real stmt or a PHI node, looking at the DEF nodes matching FLAGS. */
204 #define FOR_EACH_PHI_OR_STMT_DEF(DEFVAR, STMT, ITER, FLAGS) \
205 for ((DEFVAR) = (gimple_code (STMT) == GIMPLE_PHI \
206 ? op_iter_init_phidef (&(ITER), STMT, FLAGS) \
207 : op_iter_init_def (&(ITER), STMT, FLAGS)); \
208 !op_iter_done (&(ITER)); \
209 (DEFVAR) = op_iter_next_def (&(ITER)))
211 /* This macro returns an operand in STMT as a tree if it is the ONLY
212 operand matching FLAGS. If there are 0 or more than 1 operand matching
213 FLAGS, then NULL_TREE is returned. */
214 #define SINGLE_SSA_TREE_OPERAND(STMT, FLAGS) \
215 single_ssa_tree_operand (STMT, FLAGS)
217 /* This macro returns an operand in STMT as a use_operand_p if it is the ONLY
218 operand matching FLAGS. If there are 0 or more than 1 operand matching
219 FLAGS, then NULL_USE_OPERAND_P is returned. */
220 #define SINGLE_SSA_USE_OPERAND(STMT, FLAGS) \
221 single_ssa_use_operand (STMT, FLAGS)
223 /* This macro returns an operand in STMT as a def_operand_p if it is the ONLY
224 operand matching FLAGS. If there are 0 or more than 1 operand matching
225 FLAGS, then NULL_DEF_OPERAND_P is returned. */
226 #define SINGLE_SSA_DEF_OPERAND(STMT, FLAGS) \
227 single_ssa_def_operand (STMT, FLAGS)
229 /* This macro returns TRUE if there are no operands matching FLAGS in STMT. */
230 #define ZERO_SSA_OPERANDS(STMT, FLAGS) zero_ssa_operands (STMT, FLAGS)
232 /* This macro counts the number of operands in STMT matching FLAGS. */
233 #define NUM_SSA_OPERANDS(STMT, FLAGS) num_ssa_operands (STMT, FLAGS)
236 /* Delink an immediate_uses node from its chain. */
238 delink_imm_use (ssa_use_operand_t
*linknode
)
240 /* Return if this node is not in a list. */
241 if (linknode
->prev
== NULL
)
244 linknode
->prev
->next
= linknode
->next
;
245 linknode
->next
->prev
= linknode
->prev
;
246 linknode
->prev
= NULL
;
247 linknode
->next
= NULL
;
250 /* Link ssa_imm_use node LINKNODE into the chain for LIST. */
252 link_imm_use_to_list (ssa_use_operand_t
*linknode
, ssa_use_operand_t
*list
)
254 /* Link the new node at the head of the list. If we are in the process of
255 traversing the list, we won't visit any new nodes added to it. */
256 linknode
->prev
= list
;
257 linknode
->next
= list
->next
;
258 list
->next
->prev
= linknode
;
259 list
->next
= linknode
;
262 /* Link ssa_imm_use node LINKNODE into the chain for DEF. */
264 link_imm_use (ssa_use_operand_t
*linknode
, tree def
)
266 ssa_use_operand_t
*root
;
268 if (!def
|| TREE_CODE (def
) != SSA_NAME
)
269 linknode
->prev
= NULL
;
272 root
= &(SSA_NAME_IMM_USE_NODE (def
));
274 gcc_checking_assert (*(linknode
->use
) == def
);
275 link_imm_use_to_list (linknode
, root
);
279 /* Set the value of a use pointed to by USE to VAL. */
281 set_ssa_use_from_ptr (use_operand_p use
, tree val
)
283 delink_imm_use (use
);
285 link_imm_use (use
, val
);
288 /* Link ssa_imm_use node LINKNODE into the chain for DEF, with use occurring
291 link_imm_use_stmt (ssa_use_operand_t
*linknode
, tree def
, gimple stmt
)
294 link_imm_use (linknode
, def
);
296 link_imm_use (linknode
, NULL
);
297 linknode
->loc
.stmt
= stmt
;
300 /* Relink a new node in place of an old node in the list. */
302 relink_imm_use (ssa_use_operand_t
*node
, ssa_use_operand_t
*old
)
304 /* The node one had better be in the same list. */
305 gcc_checking_assert (*(old
->use
) == *(node
->use
));
306 node
->prev
= old
->prev
;
307 node
->next
= old
->next
;
310 old
->prev
->next
= node
;
311 old
->next
->prev
= node
;
312 /* Remove the old node from the list. */
317 /* Relink ssa_imm_use node LINKNODE into the chain for OLD, with use occurring
320 relink_imm_use_stmt (ssa_use_operand_t
*linknode
, ssa_use_operand_t
*old
,
324 relink_imm_use (linknode
, old
);
326 link_imm_use (linknode
, NULL
);
327 linknode
->loc
.stmt
= stmt
;
331 /* Return true is IMM has reached the end of the immediate use list. */
333 end_readonly_imm_use_p (const imm_use_iterator
*imm
)
335 return (imm
->imm_use
== imm
->end_p
);
338 /* Initialize iterator IMM to process the list for VAR. */
339 static inline use_operand_p
340 first_readonly_imm_use (imm_use_iterator
*imm
, tree var
)
342 imm
->end_p
= &(SSA_NAME_IMM_USE_NODE (var
));
343 imm
->imm_use
= imm
->end_p
->next
;
344 #ifdef ENABLE_CHECKING
345 imm
->iter_node
.next
= imm
->imm_use
->next
;
347 if (end_readonly_imm_use_p (imm
))
348 return NULL_USE_OPERAND_P
;
352 /* Bump IMM to the next use in the list. */
353 static inline use_operand_p
354 next_readonly_imm_use (imm_use_iterator
*imm
)
356 use_operand_p old
= imm
->imm_use
;
358 #ifdef ENABLE_CHECKING
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 gcc_assert (imm
->iter_node
.next
== old
->next
);
364 imm
->iter_node
.next
= old
->next
->next
;
367 imm
->imm_use
= old
->next
;
368 if (end_readonly_imm_use_p (imm
))
369 return NULL_USE_OPERAND_P
;
374 /* Return true if VAR has no nondebug uses. */
376 has_zero_uses (const_tree var
)
378 const ssa_use_operand_t
*const ptr
= &(SSA_NAME_IMM_USE_NODE (var
));
380 /* A single use_operand means there is no items in the list. */
381 if (ptr
== ptr
->next
)
384 /* If there are debug stmts, we have to look at each use and see
385 whether there are any nondebug uses. */
386 if (!MAY_HAVE_DEBUG_STMTS
)
389 return has_zero_uses_1 (ptr
);
392 /* Return true if VAR has a single nondebug use. */
394 has_single_use (const_tree var
)
396 const ssa_use_operand_t
*const ptr
= &(SSA_NAME_IMM_USE_NODE (var
));
398 /* If there aren't any uses whatsoever, we're done. */
399 if (ptr
== ptr
->next
)
402 /* If there's a single use, check that it's not a debug stmt. */
403 if (ptr
== ptr
->next
->next
)
404 return !is_gimple_debug (USE_STMT (ptr
->next
));
406 /* If there are debug stmts, we have to look at each of them. */
407 if (!MAY_HAVE_DEBUG_STMTS
)
410 return single_imm_use_1 (ptr
, NULL
, NULL
);
414 /* If VAR has only a single immediate nondebug use, return true, and
415 set USE_P and STMT to the use pointer and stmt of occurrence. */
417 single_imm_use (const_tree var
, use_operand_p
*use_p
, gimple
*stmt
)
419 const ssa_use_operand_t
*const ptr
= &(SSA_NAME_IMM_USE_NODE (var
));
421 /* If there aren't any uses whatsoever, we're done. */
422 if (ptr
== ptr
->next
)
425 *use_p
= NULL_USE_OPERAND_P
;
430 /* If there's a single use, check that it's not a debug stmt. */
431 if (ptr
== ptr
->next
->next
)
433 if (!is_gimple_debug (USE_STMT (ptr
->next
)))
436 *stmt
= ptr
->next
->loc
.stmt
;
443 /* If there are debug stmts, we have to look at each of them. */
444 if (!MAY_HAVE_DEBUG_STMTS
)
447 return single_imm_use_1 (ptr
, use_p
, stmt
);
450 /* Return the number of nondebug immediate uses of VAR. */
451 static inline unsigned int
452 num_imm_uses (const_tree var
)
454 const ssa_use_operand_t
*const start
= &(SSA_NAME_IMM_USE_NODE (var
));
455 const ssa_use_operand_t
*ptr
;
456 unsigned int num
= 0;
458 if (!MAY_HAVE_DEBUG_STMTS
)
459 for (ptr
= start
->next
; ptr
!= start
; ptr
= ptr
->next
)
462 for (ptr
= start
->next
; ptr
!= start
; ptr
= ptr
->next
)
463 if (!is_gimple_debug (USE_STMT (ptr
)))
469 /* ----------------------------------------------------------------------- */
471 /* The following set of routines are used to iterator over various type of
474 /* Return true if PTR is finished iterating. */
476 op_iter_done (const ssa_op_iter
*ptr
)
481 /* Get the next iterator use value for PTR. */
482 static inline use_operand_p
483 op_iter_next_use (ssa_op_iter
*ptr
)
486 gcc_checking_assert (ptr
->iter_type
== ssa_op_iter_use
);
489 use_p
= USE_OP_PTR (ptr
->uses
);
490 ptr
->uses
= ptr
->uses
->next
;
493 if (ptr
->i
< ptr
->numops
)
495 return PHI_ARG_DEF_PTR (ptr
->stmt
, (ptr
->i
)++);
498 return NULL_USE_OPERAND_P
;
501 /* Get the next iterator def value for PTR. */
502 static inline def_operand_p
503 op_iter_next_def (ssa_op_iter
*ptr
)
505 gcc_checking_assert (ptr
->iter_type
== ssa_op_iter_def
);
506 if (ptr
->flags
& SSA_OP_VDEF
)
509 ptr
->flags
&= ~SSA_OP_VDEF
;
510 p
= gimple_vdef_ptr (ptr
->stmt
);
514 if (ptr
->flags
& SSA_OP_DEF
)
516 while (ptr
->i
< ptr
->numops
)
518 tree
*val
= gimple_op_ptr (ptr
->stmt
, ptr
->i
);
522 if (TREE_CODE (*val
) == TREE_LIST
)
523 val
= &TREE_VALUE (*val
);
524 if (TREE_CODE (*val
) == SSA_NAME
525 || is_gimple_reg (*val
))
529 ptr
->flags
&= ~SSA_OP_DEF
;
533 return NULL_DEF_OPERAND_P
;
536 /* Get the next iterator tree value for PTR. */
538 op_iter_next_tree (ssa_op_iter
*ptr
)
541 gcc_checking_assert (ptr
->iter_type
== ssa_op_iter_tree
);
544 val
= USE_OP (ptr
->uses
);
545 ptr
->uses
= ptr
->uses
->next
;
548 if (ptr
->flags
& SSA_OP_VDEF
)
550 ptr
->flags
&= ~SSA_OP_VDEF
;
551 if ((val
= gimple_vdef (ptr
->stmt
)))
554 if (ptr
->flags
& SSA_OP_DEF
)
556 while (ptr
->i
< ptr
->numops
)
558 val
= gimple_op (ptr
->stmt
, ptr
->i
);
562 if (TREE_CODE (val
) == TREE_LIST
)
563 val
= TREE_VALUE (val
);
564 if (TREE_CODE (val
) == SSA_NAME
565 || is_gimple_reg (val
))
569 ptr
->flags
&= ~SSA_OP_DEF
;
577 /* This functions clears the iterator PTR, and marks it done. This is normally
578 used to prevent warnings in the compile about might be uninitialized
582 clear_and_done_ssa_iter (ssa_op_iter
*ptr
)
587 ptr
->iter_type
= ssa_op_iter_none
;
593 /* Initialize the iterator PTR to the virtual defs in STMT. */
595 op_iter_init (ssa_op_iter
*ptr
, gimple stmt
, int flags
)
597 /* PHI nodes require a different iterator initialization path. We
598 do not support iterating over virtual defs or uses without
599 iterating over defs or uses at the same time. */
600 gcc_checking_assert (gimple_code (stmt
) != GIMPLE_PHI
601 && (!(flags
& SSA_OP_VDEF
) || (flags
& SSA_OP_DEF
))
602 && (!(flags
& SSA_OP_VUSE
) || (flags
& SSA_OP_USE
)));
604 if (flags
& (SSA_OP_DEF
| SSA_OP_VDEF
))
606 switch (gimple_code (stmt
))
613 ptr
->numops
= gimple_asm_noutputs (stmt
);
617 flags
&= ~(SSA_OP_DEF
| SSA_OP_VDEF
);
621 ptr
->uses
= (flags
& (SSA_OP_USE
|SSA_OP_VUSE
)) ? gimple_use_ops (stmt
) : NULL
;
622 if (!(flags
& SSA_OP_VUSE
)
624 && gimple_vuse (stmt
) != NULL_TREE
)
625 ptr
->uses
= ptr
->uses
->next
;
633 /* Initialize iterator PTR to the use operands in STMT based on FLAGS. Return
635 static inline use_operand_p
636 op_iter_init_use (ssa_op_iter
*ptr
, gimple stmt
, int flags
)
638 gcc_checking_assert ((flags
& SSA_OP_ALL_DEFS
) == 0
639 && (flags
& SSA_OP_USE
));
640 op_iter_init (ptr
, stmt
, flags
);
641 ptr
->iter_type
= ssa_op_iter_use
;
642 return op_iter_next_use (ptr
);
645 /* Initialize iterator PTR to the def operands in STMT based on FLAGS. Return
647 static inline def_operand_p
648 op_iter_init_def (ssa_op_iter
*ptr
, gimple stmt
, int flags
)
650 gcc_checking_assert ((flags
& SSA_OP_ALL_USES
) == 0
651 && (flags
& SSA_OP_DEF
));
652 op_iter_init (ptr
, stmt
, flags
);
653 ptr
->iter_type
= ssa_op_iter_def
;
654 return op_iter_next_def (ptr
);
657 /* Initialize iterator PTR to the operands in STMT based on FLAGS. Return
658 the first operand as a tree. */
660 op_iter_init_tree (ssa_op_iter
*ptr
, gimple stmt
, int flags
)
662 op_iter_init (ptr
, stmt
, flags
);
663 ptr
->iter_type
= ssa_op_iter_tree
;
664 return op_iter_next_tree (ptr
);
668 /* If there is a single operand in STMT matching FLAGS, return it. Otherwise
671 single_ssa_tree_operand (gimple stmt
, int flags
)
676 var
= op_iter_init_tree (&iter
, stmt
, flags
);
677 if (op_iter_done (&iter
))
679 op_iter_next_tree (&iter
);
680 if (op_iter_done (&iter
))
686 /* If there is a single operand in STMT matching FLAGS, return it. Otherwise
688 static inline use_operand_p
689 single_ssa_use_operand (gimple stmt
, int flags
)
694 var
= op_iter_init_use (&iter
, stmt
, flags
);
695 if (op_iter_done (&iter
))
696 return NULL_USE_OPERAND_P
;
697 op_iter_next_use (&iter
);
698 if (op_iter_done (&iter
))
700 return NULL_USE_OPERAND_P
;
705 /* If there is a single operand in STMT matching FLAGS, return it. Otherwise
707 static inline def_operand_p
708 single_ssa_def_operand (gimple stmt
, int flags
)
713 var
= op_iter_init_def (&iter
, stmt
, flags
);
714 if (op_iter_done (&iter
))
715 return NULL_DEF_OPERAND_P
;
716 op_iter_next_def (&iter
);
717 if (op_iter_done (&iter
))
719 return NULL_DEF_OPERAND_P
;
723 /* Return true if there are zero operands in STMT matching the type
726 zero_ssa_operands (gimple stmt
, int flags
)
730 op_iter_init_tree (&iter
, stmt
, flags
);
731 return op_iter_done (&iter
);
735 /* Return the number of operands matching FLAGS in STMT. */
737 num_ssa_operands (gimple stmt
, int flags
)
743 gcc_checking_assert (gimple_code (stmt
) != GIMPLE_PHI
);
744 FOR_EACH_SSA_TREE_OPERAND (t
, stmt
, iter
, flags
)
749 /* If there is a single DEF in the PHI node which matches FLAG, return it.
750 Otherwise return NULL_DEF_OPERAND_P. */
752 single_phi_def (gimple stmt
, int flags
)
754 tree def
= PHI_RESULT (stmt
);
755 if ((flags
& SSA_OP_DEF
) && is_gimple_reg (def
))
757 if ((flags
& SSA_OP_VIRTUAL_DEFS
) && !is_gimple_reg (def
))
762 /* Initialize the iterator PTR for uses matching FLAGS in PHI. FLAGS should
763 be either SSA_OP_USES or SSA_OP_VIRTUAL_USES. */
764 static inline use_operand_p
765 op_iter_init_phiuse (ssa_op_iter
*ptr
, gimple phi
, int flags
)
767 tree phi_def
= gimple_phi_result (phi
);
770 clear_and_done_ssa_iter (ptr
);
773 gcc_checking_assert ((flags
& (SSA_OP_USE
| SSA_OP_VIRTUAL_USES
)) != 0);
775 comp
= (is_gimple_reg (phi_def
) ? SSA_OP_USE
: SSA_OP_VIRTUAL_USES
);
777 /* If the PHI node doesn't the operand type we care about, we're done. */
778 if ((flags
& comp
) == 0)
781 return NULL_USE_OPERAND_P
;
785 ptr
->numops
= gimple_phi_num_args (phi
);
786 ptr
->iter_type
= ssa_op_iter_use
;
788 return op_iter_next_use (ptr
);
792 /* Start an iterator for a PHI definition. */
794 static inline def_operand_p
795 op_iter_init_phidef (ssa_op_iter
*ptr
, gimple phi
, int flags
)
797 tree phi_def
= PHI_RESULT (phi
);
800 clear_and_done_ssa_iter (ptr
);
803 gcc_checking_assert ((flags
& (SSA_OP_DEF
| SSA_OP_VIRTUAL_DEFS
)) != 0);
805 comp
= (is_gimple_reg (phi_def
) ? SSA_OP_DEF
: SSA_OP_VIRTUAL_DEFS
);
807 /* If the PHI node doesn't have the operand type we care about,
809 if ((flags
& comp
) == 0)
812 return NULL_DEF_OPERAND_P
;
815 ptr
->iter_type
= ssa_op_iter_def
;
816 /* The first call to op_iter_next_def will terminate the iterator since
817 all the fields are NULL. Simply return the result here as the first and
818 therefore only result. */
819 return PHI_RESULT_PTR (phi
);
822 /* Return true is IMM has reached the end of the immediate use stmt list. */
825 end_imm_use_stmt_p (const imm_use_iterator
*imm
)
827 return (imm
->imm_use
== imm
->end_p
);
830 /* Finished the traverse of an immediate use stmt list IMM by removing the
831 placeholder node from the list. */
834 end_imm_use_stmt_traverse (imm_use_iterator
*imm
)
836 delink_imm_use (&(imm
->iter_node
));
839 /* Immediate use traversal of uses within a stmt require that all the
840 uses on a stmt be sequentially listed. This routine is used to build up
841 this sequential list by adding USE_P to the end of the current list
842 currently delimited by HEAD and LAST_P. The new LAST_P value is
845 static inline use_operand_p
846 move_use_after_head (use_operand_p use_p
, use_operand_p head
,
847 use_operand_p last_p
)
849 gcc_checking_assert (USE_FROM_PTR (use_p
) == USE_FROM_PTR (head
));
850 /* Skip head when we find it. */
853 /* If use_p is already linked in after last_p, continue. */
854 if (last_p
->next
== use_p
)
858 /* Delink from current location, and link in at last_p. */
859 delink_imm_use (use_p
);
860 link_imm_use_to_list (use_p
, last_p
);
868 /* This routine will relink all uses with the same stmt as HEAD into the list
869 immediately following HEAD for iterator IMM. */
872 link_use_stmts_after (use_operand_p head
, imm_use_iterator
*imm
)
875 use_operand_p last_p
= head
;
876 gimple head_stmt
= USE_STMT (head
);
877 tree use
= USE_FROM_PTR (head
);
881 /* Only look at virtual or real uses, depending on the type of HEAD. */
882 flag
= (is_gimple_reg (use
) ? SSA_OP_USE
: SSA_OP_VIRTUAL_USES
);
884 if (gimple_code (head_stmt
) == GIMPLE_PHI
)
886 FOR_EACH_PHI_ARG (use_p
, head_stmt
, op_iter
, flag
)
887 if (USE_FROM_PTR (use_p
) == use
)
888 last_p
= move_use_after_head (use_p
, head
, last_p
);
892 if (flag
== SSA_OP_USE
)
894 FOR_EACH_SSA_USE_OPERAND (use_p
, head_stmt
, op_iter
, flag
)
895 if (USE_FROM_PTR (use_p
) == use
)
896 last_p
= move_use_after_head (use_p
, head
, last_p
);
898 else if ((use_p
= gimple_vuse_op (head_stmt
)) != NULL_USE_OPERAND_P
)
900 if (USE_FROM_PTR (use_p
) == use
)
901 last_p
= move_use_after_head (use_p
, head
, last_p
);
904 /* Link iter node in after last_p. */
905 if (imm
->iter_node
.prev
!= NULL
)
906 delink_imm_use (&imm
->iter_node
);
907 link_imm_use_to_list (&(imm
->iter_node
), last_p
);
910 /* Initialize IMM to traverse over uses of VAR. Return the first statement. */
912 first_imm_use_stmt (imm_use_iterator
*imm
, tree var
)
914 imm
->end_p
= &(SSA_NAME_IMM_USE_NODE (var
));
915 imm
->imm_use
= imm
->end_p
->next
;
916 imm
->next_imm_name
= NULL_USE_OPERAND_P
;
918 /* iter_node is used as a marker within the immediate use list to indicate
919 where the end of the current stmt's uses are. Initialize it to NULL
920 stmt and use, which indicates a marker node. */
921 imm
->iter_node
.prev
= NULL_USE_OPERAND_P
;
922 imm
->iter_node
.next
= NULL_USE_OPERAND_P
;
923 imm
->iter_node
.loc
.stmt
= NULL
;
924 imm
->iter_node
.use
= NULL
;
926 if (end_imm_use_stmt_p (imm
))
929 link_use_stmts_after (imm
->imm_use
, imm
);
931 return USE_STMT (imm
->imm_use
);
934 /* Bump IMM to the next stmt which has a use of var. */
937 next_imm_use_stmt (imm_use_iterator
*imm
)
939 imm
->imm_use
= imm
->iter_node
.next
;
940 if (end_imm_use_stmt_p (imm
))
942 if (imm
->iter_node
.prev
!= NULL
)
943 delink_imm_use (&imm
->iter_node
);
947 link_use_stmts_after (imm
->imm_use
, imm
);
948 return USE_STMT (imm
->imm_use
);
951 /* This routine will return the first use on the stmt IMM currently refers
954 static inline use_operand_p
955 first_imm_use_on_stmt (imm_use_iterator
*imm
)
957 imm
->next_imm_name
= imm
->imm_use
->next
;
961 /* Return TRUE if the last use on the stmt IMM refers to has been visited. */
964 end_imm_use_on_stmt_p (const imm_use_iterator
*imm
)
966 return (imm
->imm_use
== &(imm
->iter_node
));
969 /* Bump to the next use on the stmt IMM refers to, return NULL if done. */
971 static inline use_operand_p
972 next_imm_use_on_stmt (imm_use_iterator
*imm
)
974 imm
->imm_use
= imm
->next_imm_name
;
975 if (end_imm_use_on_stmt_p (imm
))
976 return NULL_USE_OPERAND_P
;
979 imm
->next_imm_name
= imm
->imm_use
->next
;
984 /* Delink all immediate_use information for STMT. */
986 delink_stmt_imm_use (gimple stmt
)
991 if (ssa_operands_active (cfun
))
992 FOR_EACH_PHI_OR_STMT_USE (use_p
, stmt
, iter
, SSA_OP_ALL_USES
)
993 delink_imm_use (use_p
);
996 #endif /* GCC_TREE_SSA_ITERATORS_H */