OSDN Git Service

* tree-phinode.c (resize_phi_node): Abort when LEN is strictly
[pf3gnuchains/gcc-fork.git] / gcc / tree-flow-inline.h
1 /* Inline functions for tree-flow.h
2    Copyright (C) 2001, 2003 Free Software Foundation, Inc.
3    Contributed by Diego Novillo <dnovillo@redhat.com>
4
5 This file is part of GCC.
6
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
10 any later version.
11
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING.  If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA.  */
21
22 #ifndef _TREE_FLOW_INLINE_H
23 #define _TREE_FLOW_INLINE_H 1
24
25 /* Inline functions for manipulating various data structures defined in
26    tree-flow.h.  See tree-flow.h for documentation.  */
27
28 /* Return the variable annotation for T, which must be a _DECL node.
29    Return NULL if the variable annotation doesn't already exist.  */
30 static inline var_ann_t
31 var_ann (tree t)
32 {
33   gcc_assert (t);
34   gcc_assert (DECL_P (t));
35   gcc_assert (!t->common.ann || t->common.ann->common.type == VAR_ANN);
36
37   return (var_ann_t) t->common.ann;
38 }
39
40 /* Return the variable annotation for T, which must be a _DECL node.
41    Create the variable annotation if it doesn't exist.  */
42 static inline var_ann_t
43 get_var_ann (tree var)
44 {
45   var_ann_t ann = var_ann (var);
46   return (ann) ? ann : create_var_ann (var);
47 }
48
49 /* Return the statement annotation for T, which must be a statement
50    node.  Return NULL if the statement annotation doesn't exist.  */
51 static inline stmt_ann_t
52 stmt_ann (tree t)
53 {
54 #ifdef ENABLE_CHECKING
55   gcc_assert (is_gimple_stmt (t));
56 #endif
57   return (stmt_ann_t) t->common.ann;
58 }
59
60 /* Return the statement annotation for T, which must be a statement
61    node.  Create the statement annotation if it doesn't exist.  */
62 static inline stmt_ann_t
63 get_stmt_ann (tree stmt)
64 {
65   stmt_ann_t ann = stmt_ann (stmt);
66   return (ann) ? ann : create_stmt_ann (stmt);
67 }
68
69
70 /* Return the annotation type for annotation ANN.  */
71 static inline enum tree_ann_type
72 ann_type (tree_ann_t ann)
73 {
74   return ann->common.type;
75 }
76
77 /* Return the basic block for statement T.  */
78 static inline basic_block
79 bb_for_stmt (tree t)
80 {
81   stmt_ann_t ann;
82
83   if (TREE_CODE (t) == PHI_NODE)
84     return PHI_BB (t);
85
86   ann = stmt_ann (t);
87   return ann ? ann->bb : NULL;
88 }
89
90 /* Return the may_aliases varray for variable VAR, or NULL if it has
91    no may aliases.  */
92 static inline varray_type
93 may_aliases (tree var)
94 {
95   var_ann_t ann = var_ann (var);
96   return ann ? ann->may_aliases : NULL;
97 }
98
99 /* Return the line number for EXPR, or return -1 if we have no line
100    number information for it.  */
101 static inline int
102 get_lineno (tree expr)
103 {
104   if (expr == NULL_TREE)
105     return -1;
106
107   if (TREE_CODE (expr) == COMPOUND_EXPR)
108     expr = TREE_OPERAND (expr, 0);
109
110   if (! EXPR_HAS_LOCATION (expr))
111     return -1;
112
113   return EXPR_LINENO (expr);
114 }
115
116 /* Return the file name for EXPR, or return "???" if we have no
117    filename information.  */
118 static inline const char *
119 get_filename (tree expr)
120 {
121   const char *filename;
122   if (expr == NULL_TREE)
123     return "???";
124
125   if (TREE_CODE (expr) == COMPOUND_EXPR)
126     expr = TREE_OPERAND (expr, 0);
127
128   if (EXPR_HAS_LOCATION (expr) && (filename = EXPR_FILENAME (expr)))
129     return filename;
130   else
131     return "???";
132 }
133
134 /* Mark statement T as modified.  */
135 static inline void
136 modify_stmt (tree t)
137 {
138   stmt_ann_t ann = stmt_ann (t);
139   if (ann == NULL)
140     ann = create_stmt_ann (t);
141   ann->modified = 1;
142 }
143
144 /* Mark statement T as unmodified.  */
145 static inline void
146 unmodify_stmt (tree t)
147 {
148   stmt_ann_t ann = stmt_ann (t);
149   if (ann == NULL)
150     ann = create_stmt_ann (t);
151   ann->modified = 0;
152 }
153
154 /* Return true if T is marked as modified, false otherwise.  */
155 static inline bool
156 stmt_modified_p (tree t)
157 {
158   stmt_ann_t ann = stmt_ann (t);
159
160   /* Note that if the statement doesn't yet have an annotation, we consider it
161      modified.  This will force the next call to get_stmt_operands to scan the
162      statement.  */
163   return ann ? ann->modified : true;
164 }
165
166 /* Return the definitions present in ANN, a statement annotation.
167    Return NULL if this annotation contains no definitions.  */
168 static inline def_optype
169 get_def_ops (stmt_ann_t ann)
170 {
171   return ann ? ann->operands.def_ops : NULL;
172 }
173
174 /* Return the uses present in ANN, a statement annotation.
175    Return NULL if this annotation contains no uses.  */
176 static inline use_optype
177 get_use_ops (stmt_ann_t ann)
178 {
179   return ann ? ann->operands.use_ops : NULL;
180 }
181
182 /* Return the virtual may-defs present in ANN, a statement
183    annotation.
184    Return NULL if this annotation contains no virtual may-defs.  */
185 static inline v_may_def_optype
186 get_v_may_def_ops (stmt_ann_t ann)
187 {
188   return ann ? ann->operands.v_may_def_ops : NULL;
189 }
190
191 /* Return the virtual uses present in ANN, a statement annotation.
192    Return NULL if this annotation contains no virtual uses.  */
193 static inline vuse_optype
194 get_vuse_ops (stmt_ann_t ann)
195 {
196   return ann ? ann->operands.vuse_ops : NULL;
197 }
198
199 /* Return the virtual must-defs present in ANN, a statement
200    annotation.  Return NULL if this annotation contains no must-defs.*/
201 static inline v_must_def_optype
202 get_v_must_def_ops (stmt_ann_t ann)
203 {
204   return ann ? ann->operands.v_must_def_ops : NULL;
205 }
206
207 /* Return the tree pointer to by USE.  */ 
208 static inline tree
209 get_use_from_ptr (use_operand_p use)
210
211   return *(use.use);
212
213
214 /* Return the tree pointer to by DEF.  */
215 static inline tree
216 get_def_from_ptr (def_operand_p def)
217 {
218   return *(def.def);
219 }
220
221 /* Return a pointer to the tree that is at INDEX in the USES array.  */
222 static inline use_operand_p
223 get_use_op_ptr (use_optype uses, unsigned int index)
224 {
225   gcc_assert (index < uses->num_uses);
226   return uses->uses[index];
227 }
228
229 /* Return a def_operand_p pointer for element INDEX of DEFS.  */
230 static inline def_operand_p
231 get_def_op_ptr (def_optype defs, unsigned int index)
232 {
233   gcc_assert (index < defs->num_defs);
234   return defs->defs[index];
235 }
236
237
238 /* Return the def_operand_p that is the V_MAY_DEF_RESULT for the V_MAY_DEF
239    at INDEX in the V_MAY_DEFS array.  */
240 static inline def_operand_p
241 get_v_may_def_result_ptr(v_may_def_optype v_may_defs, unsigned int index)
242 {
243   def_operand_p op;
244   gcc_assert (index < v_may_defs->num_v_may_defs);
245   op.def = &(v_may_defs->v_may_defs[index].def);
246   return op;
247 }
248
249 /* Return a use_operand_p that is the V_MAY_DEF_OP for the V_MAY_DEF at
250    INDEX in the V_MAY_DEFS array.  */
251 static inline use_operand_p
252 get_v_may_def_op_ptr(v_may_def_optype v_may_defs, unsigned int index)
253 {
254   use_operand_p op;
255   gcc_assert (index < v_may_defs->num_v_may_defs);
256   op.use = &(v_may_defs->v_may_defs[index].use);
257   return op;
258 }
259
260 /* Return a use_operand_p that is at INDEX in the VUSES array.  */
261 static inline use_operand_p
262 get_vuse_op_ptr(vuse_optype vuses, unsigned int index)
263 {
264   use_operand_p op;
265   gcc_assert (index < vuses->num_vuses);
266   op.use = &(vuses->vuses[index]);
267   return op;
268 }
269
270 /* Return a def_operand_p that is the V_MUST_DEF_RESULT for the
271    V_MUST_DEF at INDEX in the V_MUST_DEFS array.  */
272 static inline def_operand_p
273 get_v_must_def_result_ptr (v_must_def_optype v_must_defs, unsigned int index)
274 {
275   def_operand_p op;
276   gcc_assert (index < v_must_defs->num_v_must_defs);
277   op.def = &(v_must_defs->v_must_defs[index].def);
278   return op;
279 }
280
281 /* Return a use_operand_p that is the V_MUST_DEF_KILL for the 
282    V_MUST_DEF at INDEX in the V_MUST_DEFS array.  */
283 static inline use_operand_p
284 get_v_must_def_kill_ptr (v_must_def_optype v_must_defs, unsigned int index)
285 {
286   use_operand_p op;
287   gcc_assert (index < v_must_defs->num_v_must_defs);
288   op.use = &(v_must_defs->v_must_defs[index].use);
289   return op;
290 }
291
292 /* Return a def_operand_p pointer for the result of PHI.  */
293 static inline def_operand_p
294 get_phi_result_ptr (tree phi)
295 {
296   def_operand_p op;
297   op.def = &(PHI_RESULT_TREE (phi));
298   return op;
299 }
300
301 /* Return a use_operand_p pointer for argument I of phinode PHI.  */
302 static inline use_operand_p
303 get_phi_arg_def_ptr (tree phi, int i)
304 {
305   use_operand_p op;
306   op.use = &(PHI_ARG_DEF_TREE (phi, i));
307   return op;
308 }
309  
310 /* Return the bitmap of addresses taken by STMT, or NULL if it takes
311    no addresses.  */
312 static inline bitmap
313 addresses_taken (tree stmt)
314 {
315   stmt_ann_t ann = stmt_ann (stmt);
316   return ann ? ann->addresses_taken : NULL;
317 }
318
319 /* Return the immediate uses of STMT, or NULL if this information is
320    not computed.  */
321 static dataflow_t
322 get_immediate_uses (tree stmt)
323 {
324   stmt_ann_t ann;
325
326   if (TREE_CODE (stmt) == PHI_NODE)
327     return PHI_DF (stmt);
328
329   ann = stmt_ann (stmt);
330   return ann ? ann->df : NULL;
331 }
332
333 /* Return the number of immediate uses present in the dataflow
334    information at DF.  */
335 static inline int
336 num_immediate_uses (dataflow_t df)
337 {
338   varray_type imm;
339
340   if (!df)
341     return 0;
342
343   imm = df->immediate_uses;
344   if (!imm)
345     return df->uses[1] ? 2 : 1;
346
347   return VARRAY_ACTIVE_SIZE (imm) + 2;
348 }
349
350 /* Return the tree that is at NUM in the immediate use DF array.  */
351 static inline tree
352 immediate_use (dataflow_t df, int num)
353 {
354   if (!df)
355     return NULL_TREE;
356
357 #ifdef ENABLE_CHECKING
358   gcc_assert (num < num_immediate_uses (df));
359 #endif
360   if (num < 2)
361     return df->uses[num];
362   return VARRAY_TREE (df->immediate_uses, num - 2);
363 }
364
365 /* Return the basic_block annotation for BB.  */
366 static inline bb_ann_t
367 bb_ann (basic_block bb)
368 {
369   return (bb_ann_t)bb->tree_annotations;
370 }
371
372 /* Return the PHI nodes for basic block BB, or NULL if there are no
373    PHI nodes.  */
374 static inline tree
375 phi_nodes (basic_block bb)
376 {
377   return bb_ann (bb)->phi_nodes;
378 }
379
380 /* Set list of phi nodes of a basic block BB to L.  */
381
382 static inline void
383 set_phi_nodes (basic_block bb, tree l)
384 {
385   tree phi;
386
387   bb_ann (bb)->phi_nodes = l;
388   for (phi = l; phi; phi = PHI_CHAIN (phi))
389     set_bb_for_stmt (phi, bb);
390 }
391
392 /* Return the phi index number for an edge.  */
393 static inline int
394 phi_arg_from_edge (tree phi, edge e)
395 {
396   gcc_assert (phi);
397   gcc_assert (TREE_CODE (phi) == PHI_NODE);
398   return e->dest_idx;
399 }
400
401 /* Mark VAR as used, so that it'll be preserved during rtl expansion.  */
402
403 static inline void
404 set_is_used (tree var)
405 {
406   var_ann_t ann = get_var_ann (var);
407   ann->used = 1;
408 }
409
410
411 /*  -----------------------------------------------------------------------  */
412
413 /* Return true if T is an executable statement.  */
414 static inline bool
415 is_exec_stmt (tree t)
416 {
417   return (t && !IS_EMPTY_STMT (t) && t != error_mark_node);
418 }
419
420
421 /* Return true if this stmt can be the target of a control transfer stmt such
422    as a goto.  */
423 static inline bool
424 is_label_stmt (tree t)
425 {
426   if (t)
427     switch (TREE_CODE (t))
428       {
429         case LABEL_DECL:
430         case LABEL_EXPR:
431         case CASE_LABEL_EXPR:
432           return true;
433         default:
434           return false;
435       }
436   return false;
437 }
438
439 /* Set the default definition for VAR to DEF.  */
440 static inline void
441 set_default_def (tree var, tree def)
442 {
443   var_ann_t ann = get_var_ann (var);
444   ann->default_def = def;
445 }
446
447 /* Return the default definition for variable VAR, or NULL if none
448    exists.  */
449 static inline tree
450 default_def (tree var)
451 {
452   var_ann_t ann = var_ann (var);
453   return ann ? ann->default_def : NULL_TREE;
454 }
455
456 /* PHI nodes should contain only ssa_names and invariants.  A test
457    for ssa_name is definitely simpler; don't let invalid contents
458    slip in in the meantime.  */
459
460 static inline bool
461 phi_ssa_name_p (tree t)
462 {
463   if (TREE_CODE (t) == SSA_NAME)
464     return true;
465 #ifdef ENABLE_CHECKING
466   gcc_assert (is_gimple_min_invariant (t));
467 #endif
468   return false;
469 }
470
471 /*  -----------------------------------------------------------------------  */
472
473 /* Return a block_stmt_iterator that points to beginning of basic
474    block BB.  */
475 static inline block_stmt_iterator
476 bsi_start (basic_block bb)
477 {
478   block_stmt_iterator bsi;
479   if (bb->stmt_list)
480     bsi.tsi = tsi_start (bb->stmt_list);
481   else
482     {
483       gcc_assert (bb->index < 0);
484       bsi.tsi.ptr = NULL;
485       bsi.tsi.container = NULL;
486     }
487   bsi.bb = bb;
488   return bsi;
489 }
490
491 /* Return a block statement iterator that points to the last label in
492    block BB.  */
493
494 static inline block_stmt_iterator
495 bsi_after_labels (basic_block bb)
496 {
497   block_stmt_iterator bsi;
498   tree_stmt_iterator next;
499
500   bsi.bb = bb;
501
502   if (!bb->stmt_list)
503     {
504       gcc_assert (bb->index < 0);
505       bsi.tsi.ptr = NULL;
506       bsi.tsi.container = NULL;
507       return bsi;
508     }
509
510   bsi.tsi = tsi_start (bb->stmt_list);
511   if (tsi_end_p (bsi.tsi))
512     return bsi;
513
514   /* Ensure that there are some labels.  The rationale is that we want
515      to insert after the bsi that is returned, and these insertions should
516      be placed at the start of the basic block.  This would not work if the
517      first statement was not label; rather fail here than enable the user
518      proceed in wrong way.  */
519   gcc_assert (TREE_CODE (tsi_stmt (bsi.tsi)) == LABEL_EXPR);
520
521   next = bsi.tsi;
522   tsi_next (&next);
523
524   while (!tsi_end_p (next)
525          && TREE_CODE (tsi_stmt (next)) == LABEL_EXPR)
526     {
527       bsi.tsi = next;
528       tsi_next (&next);
529     }
530
531   return bsi;
532 }
533
534 /* Return a block statement iterator that points to the end of basic
535    block BB.  */
536 static inline block_stmt_iterator
537 bsi_last (basic_block bb)
538 {
539   block_stmt_iterator bsi;
540   if (bb->stmt_list)
541     bsi.tsi = tsi_last (bb->stmt_list);
542   else
543     {
544       gcc_assert (bb->index < 0);
545       bsi.tsi.ptr = NULL;
546       bsi.tsi.container = NULL;
547     }
548   bsi.bb = bb;
549   return bsi;
550 }
551
552 /* Return true if block statement iterator I has reached the end of
553    the basic block.  */
554 static inline bool
555 bsi_end_p (block_stmt_iterator i)
556 {
557   return tsi_end_p (i.tsi);
558 }
559
560 /* Modify block statement iterator I so that it is at the next
561    statement in the basic block.  */
562 static inline void
563 bsi_next (block_stmt_iterator *i)
564 {
565   tsi_next (&i->tsi);
566 }
567
568 /* Modify block statement iterator I so that it is at the previous
569    statement in the basic block.  */
570 static inline void
571 bsi_prev (block_stmt_iterator *i)
572 {
573   tsi_prev (&i->tsi);
574 }
575
576 /* Return the statement that block statement iterator I is currently
577    at.  */
578 static inline tree
579 bsi_stmt (block_stmt_iterator i)
580 {
581   return tsi_stmt (i.tsi);
582 }
583
584 /* Return a pointer to the statement that block statement iterator I
585    is currently at.  */
586 static inline tree *
587 bsi_stmt_ptr (block_stmt_iterator i)
588 {
589   return tsi_stmt_ptr (i.tsi);
590 }
591
592 /* Returns the loop of the statement STMT.  */
593
594 static inline struct loop *
595 loop_containing_stmt (tree stmt)
596 {
597   basic_block bb = bb_for_stmt (stmt);
598   if (!bb)
599     return NULL;
600
601   return bb->loop_father;
602 }
603
604 /* Return true if VAR is a clobbered by function calls.  */
605 static inline bool
606 is_call_clobbered (tree var)
607 {
608   return is_global_var (var)
609          || bitmap_bit_p (call_clobbered_vars, var_ann (var)->uid);
610 }
611
612 /* Mark variable VAR as being clobbered by function calls.  */
613 static inline void
614 mark_call_clobbered (tree var)
615 {
616   var_ann_t ann = var_ann (var);
617   /* If VAR is a memory tag, then we need to consider it a global
618      variable.  This is because the pointer that VAR represents has
619      been found to point to either an arbitrary location or to a known
620      location in global memory.  */
621   if (ann->mem_tag_kind != NOT_A_TAG)
622     DECL_EXTERNAL (var) = 1;
623   bitmap_set_bit (call_clobbered_vars, ann->uid);
624 }
625
626 /* Mark variable VAR as being non-addressable.  */
627 static inline void
628 mark_non_addressable (tree var)
629 {
630   bitmap_clear_bit (call_clobbered_vars, var_ann (var)->uid);
631   TREE_ADDRESSABLE (var) = 0;
632 }
633
634 /* Return the common annotation for T.  Return NULL if the annotation
635    doesn't already exist.  */
636 static inline tree_ann_t
637 tree_ann (tree t)
638 {
639   return t->common.ann;
640 }
641
642 /* Return a common annotation for T.  Create the constant annotation if it
643    doesn't exist.  */
644 static inline tree_ann_t
645 get_tree_ann (tree t)
646 {
647   tree_ann_t ann = tree_ann (t);
648   return (ann) ? ann : create_tree_ann (t);
649 }
650
651 /*  -----------------------------------------------------------------------  */
652
653 /* The following set of routines are used to iterator over various type of
654    SSA operands.  */
655
656 /* Return true if PTR is finished iterating.  */
657 static inline bool
658 op_iter_done (ssa_op_iter *ptr)
659 {
660   return ptr->done;
661 }
662
663 /* Get the next iterator use value for PTR.  */
664 static inline use_operand_p
665 op_iter_next_use (ssa_op_iter *ptr)
666 {
667   if (ptr->use_i < ptr->num_use)
668     {
669       return USE_OP_PTR (ptr->ops->use_ops, (ptr->use_i)++);
670     }
671   if (ptr->vuse_i < ptr->num_vuse)
672     {
673       return VUSE_OP_PTR (ptr->ops->vuse_ops, (ptr->vuse_i)++);
674     }
675   if (ptr->v_mayu_i < ptr->num_v_mayu)
676     {
677       return V_MAY_DEF_OP_PTR (ptr->ops->v_may_def_ops,
678                                (ptr->v_mayu_i)++);
679     }
680   if (ptr->v_mustu_i < ptr->num_v_mustu)
681     {
682       return V_MUST_DEF_KILL_PTR (ptr->ops->v_must_def_ops,
683                                   (ptr->v_mustu_i)++);
684     }
685   ptr->done = true;
686   return NULL_USE_OPERAND_P;
687 }
688
689 /* Get the next iterator def value for PTR.  */
690 static inline def_operand_p
691 op_iter_next_def (ssa_op_iter *ptr)
692 {
693   if (ptr->def_i < ptr->num_def)
694     {
695       return DEF_OP_PTR (ptr->ops->def_ops, (ptr->def_i)++);
696     }
697   if (ptr->v_mustd_i < ptr->num_v_mustd)
698     {
699       return V_MUST_DEF_RESULT_PTR (ptr->ops->v_must_def_ops, 
700                                         (ptr->v_mustd_i)++);
701     }
702   if (ptr->v_mayd_i < ptr->num_v_mayd)
703     {
704       return V_MAY_DEF_RESULT_PTR (ptr->ops->v_may_def_ops,
705                                            (ptr->v_mayd_i)++);
706     }
707   ptr->done = true;
708   return NULL_DEF_OPERAND_P;
709 }
710
711 /* Get the next iterator tree value for PTR.  */
712 static inline tree
713 op_iter_next_tree (ssa_op_iter *ptr)
714 {
715   if (ptr->use_i < ptr->num_use)
716     {
717       return USE_OP (ptr->ops->use_ops, (ptr->use_i)++);
718     }
719   if (ptr->vuse_i < ptr->num_vuse)
720     {
721       return VUSE_OP (ptr->ops->vuse_ops, (ptr->vuse_i)++);
722     }
723   if (ptr->v_mayu_i < ptr->num_v_mayu)
724     {
725       return V_MAY_DEF_OP (ptr->ops->v_may_def_ops, (ptr->v_mayu_i)++);
726     }
727   if (ptr->v_mustu_i < ptr->num_v_mustu)
728     {
729       return V_MUST_DEF_KILL (ptr->ops->v_must_def_ops, (ptr->v_mustu_i)++);
730     }
731   if (ptr->def_i < ptr->num_def)
732     {
733       return DEF_OP (ptr->ops->def_ops, (ptr->def_i)++);
734     }
735   if (ptr->v_mustd_i < ptr->num_v_mustd)
736     {
737       return V_MUST_DEF_RESULT (ptr->ops->v_must_def_ops, 
738                                         (ptr->v_mustd_i)++);
739     }
740   if (ptr->v_mayd_i < ptr->num_v_mayd)
741     {
742       return V_MAY_DEF_RESULT (ptr->ops->v_may_def_ops,
743                                            (ptr->v_mayd_i)++);
744     }
745   ptr->done = true;
746   return NULL;
747 }
748
749 /* Initialize the iterator PTR to the virtual defs in STMT.  */
750 static inline void
751 op_iter_init (ssa_op_iter *ptr, tree stmt, int flags)
752 {
753   stmt_operands_p ops;
754   stmt_ann_t ann = get_stmt_ann (stmt);
755
756   ops = &(ann->operands);
757   ptr->done = false;
758   ptr->ops = ops;
759   ptr->num_def = (flags & SSA_OP_DEF) ? NUM_DEFS (ops->def_ops) : 0;
760   ptr->num_use = (flags & SSA_OP_USE) ? NUM_USES (ops->use_ops) : 0;
761   ptr->num_vuse = (flags & SSA_OP_VUSE) ? NUM_VUSES (ops->vuse_ops) : 0;
762   ptr->num_v_mayu = (flags & SSA_OP_VMAYUSE)
763                      ?  NUM_V_MAY_DEFS (ops->v_may_def_ops) : 0;
764   ptr->num_v_mayd = (flags & SSA_OP_VMAYDEF) 
765                      ?  NUM_V_MAY_DEFS (ops->v_may_def_ops) : 0;
766   ptr->num_v_mustu = (flags & SSA_OP_VMUSTDEFKILL)
767                      ? NUM_V_MUST_DEFS (ops->v_must_def_ops) : 0;
768   ptr->num_v_mustd = (flags & SSA_OP_VMUSTDEF) 
769                      ? NUM_V_MUST_DEFS (ops->v_must_def_ops) : 0;
770   ptr->def_i = 0;
771   ptr->use_i = 0;
772   ptr->vuse_i = 0;
773   ptr->v_mayu_i = 0;
774   ptr->v_mayd_i = 0;
775   ptr->v_mustu_i = 0;
776   ptr->v_mustd_i = 0;
777 }
778
779 /* Initialize iterator PTR to the use operands in STMT based on FLAGS. Return
780    the first use.  */
781 static inline use_operand_p
782 op_iter_init_use (ssa_op_iter *ptr, tree stmt, int flags)
783 {
784   op_iter_init (ptr, stmt, flags);
785   return op_iter_next_use (ptr);
786 }
787
788 /* Initialize iterator PTR to the def operands in STMT based on FLAGS. Return
789    the first def.  */
790 static inline def_operand_p
791 op_iter_init_def (ssa_op_iter *ptr, tree stmt, int flags)
792 {
793   op_iter_init (ptr, stmt, flags);
794   return op_iter_next_def (ptr);
795 }
796
797 /* Initialize iterator PTR to the operands in STMT based on FLAGS. Return
798    the first operand as a tree.  */
799 static inline tree
800 op_iter_init_tree (ssa_op_iter *ptr, tree stmt, int flags)
801 {
802   op_iter_init (ptr, stmt, flags);
803   return op_iter_next_tree (ptr);
804 }
805
806 /* Get the next iterator mustdef value for PTR, returning the mustdef values in
807    KILL and DEF.  */
808 static inline void
809 op_iter_next_mustdef (use_operand_p *kill, def_operand_p *def, ssa_op_iter *ptr)
810 {
811   if (ptr->v_mustu_i < ptr->num_v_mustu)
812     {
813       *def = V_MUST_DEF_RESULT_PTR (ptr->ops->v_must_def_ops, ptr->v_mustu_i);
814       *kill = V_MUST_DEF_KILL_PTR (ptr->ops->v_must_def_ops, (ptr->v_mustu_i)++);
815       return;
816     }
817   else
818     {
819       *def = NULL_DEF_OPERAND_P;
820       *kill = NULL_USE_OPERAND_P;
821     }
822   ptr->done = true;
823   return;
824 }
825 /* Get the next iterator maydef value for PTR, returning the maydef values in
826    USE and DEF.  */
827 static inline void
828 op_iter_next_maydef (use_operand_p *use, def_operand_p *def, ssa_op_iter *ptr)
829 {
830   if (ptr->v_mayu_i < ptr->num_v_mayu)
831     {
832       *def = V_MAY_DEF_RESULT_PTR (ptr->ops->v_may_def_ops, ptr->v_mayu_i);
833       *use = V_MAY_DEF_OP_PTR (ptr->ops->v_may_def_ops, (ptr->v_mayu_i)++);
834       return;
835     }
836   else
837     {
838       *def = NULL_DEF_OPERAND_P;
839       *use = NULL_USE_OPERAND_P;
840     }
841   ptr->done = true;
842   return;
843 }
844
845 /* Initialize iterator PTR to the operands in STMT.  Return the first operands
846    in USE and DEF.  */
847 static inline void
848 op_iter_init_maydef (ssa_op_iter *ptr, tree stmt, use_operand_p *use, 
849                      def_operand_p *def)
850 {
851   op_iter_init (ptr, stmt, SSA_OP_VMAYUSE);
852   op_iter_next_maydef (use, def, ptr);
853 }
854
855 /* Initialize iterator PTR to the operands in STMT.  Return the first operands
856    in KILL and DEF.  */
857 static inline void
858 op_iter_init_mustdef (ssa_op_iter *ptr, tree stmt, use_operand_p *kill, 
859                      def_operand_p *def)
860 {
861   op_iter_init (ptr, stmt, SSA_OP_VMUSTDEFKILL);
862   op_iter_next_mustdef (kill, def, ptr);
863 }
864 #endif /* _TREE_FLOW_INLINE_H  */