OSDN Git Service

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