comparison gcc/ssa-iterators.h @ 16:04ced10e8804

gcc 7
author kono
date Fri, 27 Oct 2017 22:46:09 +0900
parents
children 84e7813d76e9
comparison
equal deleted inserted replaced
15:561a7518be6b 16:04ced10e8804
1 /* Header file for SSA iterators.
2 Copyright (C) 2013-2017 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 case GIMPLE_TRANSACTION:
611 ptr->numops = 0;
612 flags &= ~SSA_OP_DEF;
613 break;
614 default:
615 ptr->numops = 0;
616 flags &= ~(SSA_OP_DEF | SSA_OP_VDEF);
617 break;
618 }
619 }
620 ptr->uses = (flags & (SSA_OP_USE|SSA_OP_VUSE)) ? gimple_use_ops (stmt) : NULL;
621 if (!(flags & SSA_OP_VUSE)
622 && ptr->uses
623 && gimple_vuse (stmt) != NULL_TREE)
624 ptr->uses = ptr->uses->next;
625 ptr->done = false;
626 ptr->i = 0;
627
628 ptr->stmt = stmt;
629 ptr->flags = flags;
630 }
631
632 /* Initialize iterator PTR to the use operands in STMT based on FLAGS. Return
633 the first use. */
634 static inline use_operand_p
635 op_iter_init_use (ssa_op_iter *ptr, gimple *stmt, int flags)
636 {
637 gcc_checking_assert ((flags & SSA_OP_ALL_DEFS) == 0
638 && (flags & SSA_OP_USE));
639 op_iter_init (ptr, stmt, flags);
640 ptr->iter_type = ssa_op_iter_use;
641 return op_iter_next_use (ptr);
642 }
643
644 /* Initialize iterator PTR to the def operands in STMT based on FLAGS. Return
645 the first def. */
646 static inline def_operand_p
647 op_iter_init_def (ssa_op_iter *ptr, gimple *stmt, int flags)
648 {
649 gcc_checking_assert ((flags & SSA_OP_ALL_USES) == 0
650 && (flags & SSA_OP_DEF));
651 op_iter_init (ptr, stmt, flags);
652 ptr->iter_type = ssa_op_iter_def;
653 return op_iter_next_def (ptr);
654 }
655
656 /* Initialize iterator PTR to the operands in STMT based on FLAGS. Return
657 the first operand as a tree. */
658 static inline tree
659 op_iter_init_tree (ssa_op_iter *ptr, gimple *stmt, int flags)
660 {
661 op_iter_init (ptr, stmt, flags);
662 ptr->iter_type = ssa_op_iter_tree;
663 return op_iter_next_tree (ptr);
664 }
665
666
667 /* If there is a single operand in STMT matching FLAGS, return it. Otherwise
668 return NULL. */
669 static inline tree
670 single_ssa_tree_operand (gimple *stmt, int flags)
671 {
672 tree var;
673 ssa_op_iter iter;
674
675 var = op_iter_init_tree (&iter, stmt, flags);
676 if (op_iter_done (&iter))
677 return NULL_TREE;
678 op_iter_next_tree (&iter);
679 if (op_iter_done (&iter))
680 return var;
681 return NULL_TREE;
682 }
683
684
685 /* If there is a single operand in STMT matching FLAGS, return it. Otherwise
686 return NULL. */
687 static inline use_operand_p
688 single_ssa_use_operand (gimple *stmt, int flags)
689 {
690 use_operand_p var;
691 ssa_op_iter iter;
692
693 var = op_iter_init_use (&iter, stmt, flags);
694 if (op_iter_done (&iter))
695 return NULL_USE_OPERAND_P;
696 op_iter_next_use (&iter);
697 if (op_iter_done (&iter))
698 return var;
699 return NULL_USE_OPERAND_P;
700 }
701
702 /* Return the single virtual use operand in STMT if present. Otherwise
703 return NULL. */
704 static inline use_operand_p
705 ssa_vuse_operand (gimple *stmt)
706 {
707 if (! gimple_vuse (stmt))
708 return NULL_USE_OPERAND_P;
709 return USE_OP_PTR (gimple_use_ops (stmt));
710 }
711
712
713 /* If there is a single operand in STMT matching FLAGS, return it. Otherwise
714 return NULL. */
715 static inline def_operand_p
716 single_ssa_def_operand (gimple *stmt, int flags)
717 {
718 def_operand_p var;
719 ssa_op_iter iter;
720
721 var = op_iter_init_def (&iter, stmt, flags);
722 if (op_iter_done (&iter))
723 return NULL_DEF_OPERAND_P;
724 op_iter_next_def (&iter);
725 if (op_iter_done (&iter))
726 return var;
727 return NULL_DEF_OPERAND_P;
728 }
729
730
731 /* Return true if there are zero operands in STMT matching the type
732 given in FLAGS. */
733 static inline bool
734 zero_ssa_operands (gimple *stmt, int flags)
735 {
736 ssa_op_iter iter;
737
738 op_iter_init_tree (&iter, stmt, flags);
739 return op_iter_done (&iter);
740 }
741
742
743 /* Return the number of operands matching FLAGS in STMT. */
744 static inline int
745 num_ssa_operands (gimple *stmt, int flags)
746 {
747 ssa_op_iter iter;
748 tree t;
749 int num = 0;
750
751 gcc_checking_assert (gimple_code (stmt) != GIMPLE_PHI);
752 FOR_EACH_SSA_TREE_OPERAND (t, stmt, iter, flags)
753 num++;
754 return num;
755 }
756
757 /* If there is a single DEF in the PHI node which matches FLAG, return it.
758 Otherwise return NULL_DEF_OPERAND_P. */
759 static inline tree
760 single_phi_def (gphi *stmt, int flags)
761 {
762 tree def = PHI_RESULT (stmt);
763 if ((flags & SSA_OP_DEF) && is_gimple_reg (def))
764 return def;
765 if ((flags & SSA_OP_VIRTUAL_DEFS) && !is_gimple_reg (def))
766 return def;
767 return NULL_TREE;
768 }
769
770 /* Initialize the iterator PTR for uses matching FLAGS in PHI. FLAGS should
771 be either SSA_OP_USES or SSA_OP_VIRTUAL_USES. */
772 static inline use_operand_p
773 op_iter_init_phiuse (ssa_op_iter *ptr, gphi *phi, int flags)
774 {
775 tree phi_def = gimple_phi_result (phi);
776 int comp;
777
778 clear_and_done_ssa_iter (ptr);
779 ptr->done = false;
780
781 gcc_checking_assert ((flags & (SSA_OP_USE | SSA_OP_VIRTUAL_USES)) != 0);
782
783 comp = (is_gimple_reg (phi_def) ? SSA_OP_USE : SSA_OP_VIRTUAL_USES);
784
785 /* If the PHI node doesn't the operand type we care about, we're done. */
786 if ((flags & comp) == 0)
787 {
788 ptr->done = true;
789 return NULL_USE_OPERAND_P;
790 }
791
792 ptr->stmt = phi;
793 ptr->numops = gimple_phi_num_args (phi);
794 ptr->iter_type = ssa_op_iter_use;
795 ptr->flags = flags;
796 return op_iter_next_use (ptr);
797 }
798
799
800 /* Start an iterator for a PHI definition. */
801
802 static inline def_operand_p
803 op_iter_init_phidef (ssa_op_iter *ptr, gphi *phi, int flags)
804 {
805 tree phi_def = PHI_RESULT (phi);
806 int comp;
807
808 clear_and_done_ssa_iter (ptr);
809 ptr->done = false;
810
811 gcc_checking_assert ((flags & (SSA_OP_DEF | SSA_OP_VIRTUAL_DEFS)) != 0);
812
813 comp = (is_gimple_reg (phi_def) ? SSA_OP_DEF : SSA_OP_VIRTUAL_DEFS);
814
815 /* If the PHI node doesn't have the operand type we care about,
816 we're done. */
817 if ((flags & comp) == 0)
818 {
819 ptr->done = true;
820 return NULL_DEF_OPERAND_P;
821 }
822
823 ptr->iter_type = ssa_op_iter_def;
824 /* The first call to op_iter_next_def will terminate the iterator since
825 all the fields are NULL. Simply return the result here as the first and
826 therefore only result. */
827 return PHI_RESULT_PTR (phi);
828 }
829
830 /* Return true is IMM has reached the end of the immediate use stmt list. */
831
832 static inline bool
833 end_imm_use_stmt_p (const imm_use_iterator *imm)
834 {
835 return (imm->imm_use == imm->end_p);
836 }
837
838 /* Finished the traverse of an immediate use stmt list IMM by removing the
839 placeholder node from the list. */
840
841 static inline void
842 end_imm_use_stmt_traverse (imm_use_iterator *imm)
843 {
844 delink_imm_use (&(imm->iter_node));
845 }
846
847 /* Immediate use traversal of uses within a stmt require that all the
848 uses on a stmt be sequentially listed. This routine is used to build up
849 this sequential list by adding USE_P to the end of the current list
850 currently delimited by HEAD and LAST_P. The new LAST_P value is
851 returned. */
852
853 static inline use_operand_p
854 move_use_after_head (use_operand_p use_p, use_operand_p head,
855 use_operand_p last_p)
856 {
857 gcc_checking_assert (USE_FROM_PTR (use_p) == USE_FROM_PTR (head));
858 /* Skip head when we find it. */
859 if (use_p != head)
860 {
861 /* If use_p is already linked in after last_p, continue. */
862 if (last_p->next == use_p)
863 last_p = use_p;
864 else
865 {
866 /* Delink from current location, and link in at last_p. */
867 delink_imm_use (use_p);
868 link_imm_use_to_list (use_p, last_p);
869 last_p = use_p;
870 }
871 }
872 return last_p;
873 }
874
875
876 /* This routine will relink all uses with the same stmt as HEAD into the list
877 immediately following HEAD for iterator IMM. */
878
879 static inline void
880 link_use_stmts_after (use_operand_p head, imm_use_iterator *imm)
881 {
882 use_operand_p use_p;
883 use_operand_p last_p = head;
884 gimple *head_stmt = USE_STMT (head);
885 tree use = USE_FROM_PTR (head);
886 ssa_op_iter op_iter;
887 int flag;
888
889 /* Only look at virtual or real uses, depending on the type of HEAD. */
890 flag = (is_gimple_reg (use) ? SSA_OP_USE : SSA_OP_VIRTUAL_USES);
891
892 if (gphi *phi = dyn_cast <gphi *> (head_stmt))
893 {
894 FOR_EACH_PHI_ARG (use_p, phi, op_iter, flag)
895 if (USE_FROM_PTR (use_p) == use)
896 last_p = move_use_after_head (use_p, head, last_p);
897 }
898 else
899 {
900 if (flag == SSA_OP_USE)
901 {
902 FOR_EACH_SSA_USE_OPERAND (use_p, head_stmt, op_iter, flag)
903 if (USE_FROM_PTR (use_p) == use)
904 last_p = move_use_after_head (use_p, head, last_p);
905 }
906 else if ((use_p = gimple_vuse_op (head_stmt)) != NULL_USE_OPERAND_P)
907 {
908 if (USE_FROM_PTR (use_p) == use)
909 last_p = move_use_after_head (use_p, head, last_p);
910 }
911 }
912 /* Link iter node in after last_p. */
913 if (imm->iter_node.prev != NULL)
914 delink_imm_use (&imm->iter_node);
915 link_imm_use_to_list (&(imm->iter_node), last_p);
916 }
917
918 /* Initialize IMM to traverse over uses of VAR. Return the first statement. */
919 static inline gimple *
920 first_imm_use_stmt (imm_use_iterator *imm, tree var)
921 {
922 imm->end_p = &(SSA_NAME_IMM_USE_NODE (var));
923 imm->imm_use = imm->end_p->next;
924 imm->next_imm_name = NULL_USE_OPERAND_P;
925
926 /* iter_node is used as a marker within the immediate use list to indicate
927 where the end of the current stmt's uses are. Initialize it to NULL
928 stmt and use, which indicates a marker node. */
929 imm->iter_node.prev = NULL_USE_OPERAND_P;
930 imm->iter_node.next = NULL_USE_OPERAND_P;
931 imm->iter_node.loc.stmt = NULL;
932 imm->iter_node.use = NULL;
933
934 if (end_imm_use_stmt_p (imm))
935 return NULL;
936
937 link_use_stmts_after (imm->imm_use, imm);
938
939 return USE_STMT (imm->imm_use);
940 }
941
942 /* Bump IMM to the next stmt which has a use of var. */
943
944 static inline gimple *
945 next_imm_use_stmt (imm_use_iterator *imm)
946 {
947 imm->imm_use = imm->iter_node.next;
948 if (end_imm_use_stmt_p (imm))
949 {
950 if (imm->iter_node.prev != NULL)
951 delink_imm_use (&imm->iter_node);
952 return NULL;
953 }
954
955 link_use_stmts_after (imm->imm_use, imm);
956 return USE_STMT (imm->imm_use);
957 }
958
959 /* This routine will return the first use on the stmt IMM currently refers
960 to. */
961
962 static inline use_operand_p
963 first_imm_use_on_stmt (imm_use_iterator *imm)
964 {
965 imm->next_imm_name = imm->imm_use->next;
966 return imm->imm_use;
967 }
968
969 /* Return TRUE if the last use on the stmt IMM refers to has been visited. */
970
971 static inline bool
972 end_imm_use_on_stmt_p (const imm_use_iterator *imm)
973 {
974 return (imm->imm_use == &(imm->iter_node));
975 }
976
977 /* Bump to the next use on the stmt IMM refers to, return NULL if done. */
978
979 static inline use_operand_p
980 next_imm_use_on_stmt (imm_use_iterator *imm)
981 {
982 imm->imm_use = imm->next_imm_name;
983 if (end_imm_use_on_stmt_p (imm))
984 return NULL_USE_OPERAND_P;
985 else
986 {
987 imm->next_imm_name = imm->imm_use->next;
988 return imm->imm_use;
989 }
990 }
991
992 /* Delink all immediate_use information for STMT. */
993 static inline void
994 delink_stmt_imm_use (gimple *stmt)
995 {
996 ssa_op_iter iter;
997 use_operand_p use_p;
998
999 if (ssa_operands_active (cfun))
1000 FOR_EACH_PHI_OR_STMT_USE (use_p, stmt, iter, SSA_OP_ALL_USES)
1001 delink_imm_use (use_p);
1002 }
1003
1004 #endif /* GCC_TREE_SSA_ITERATORS_H */