Warning: That file was not part of the compilation database. It may have many parsing errors.

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

Warning: That file was not part of the compilation database. It may have many parsing errors.