OSDN Git Service

d8b57a556af2d62936b6df02da2886a7e13fe2ac
[pf3gnuchains/gcc-fork.git] / gcc / tree-flow-inline.h
1 /* Inline functions for tree-flow.h
2    Copyright (C) 2001, 2003, 2005 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, 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, 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 /* Initialize the hashtable iterator HTI to point to hashtable TABLE */
29
30 static inline void *
31 first_htab_element (htab_iterator *hti, htab_t table)
32 {
33   hti->htab = table;
34   hti->slot = table->entries;
35   hti->limit = hti->slot + htab_size (table);
36   do
37     {
38       PTR x = *(hti->slot);
39       if (x != HTAB_EMPTY_ENTRY && x != HTAB_DELETED_ENTRY)
40         break;
41     } while (++(hti->slot) < hti->limit);
42   
43   if (hti->slot < hti->limit)
44     return *(hti->slot);
45   return NULL;
46 }
47
48 /* Return current non-empty/deleted slot of the hashtable pointed to by HTI,
49    or NULL if we have  reached the end.  */
50
51 static inline bool
52 end_htab_p (htab_iterator *hti)
53 {
54   if (hti->slot >= hti->limit)
55     return true;
56   return false;
57 }
58
59 /* Advance the hashtable iterator pointed to by HTI to the next element of the
60    hashtable.  */
61
62 static inline void *
63 next_htab_element (htab_iterator *hti)
64 {
65   while (++(hti->slot) < hti->limit)
66     {
67       PTR x = *(hti->slot);
68       if (x != HTAB_EMPTY_ENTRY && x != HTAB_DELETED_ENTRY)
69         return x;
70     };
71   return NULL;
72 }
73
74 /* Initialize ITER to point to the first referenced variable in the
75    referenced_vars hashtable, and return that variable.  */
76
77 static inline tree
78 first_referenced_var (referenced_var_iterator *iter)
79 {
80   struct int_tree_map *itm;
81   itm = first_htab_element (&iter->hti, referenced_vars);
82   if (!itm) 
83     return NULL;
84   return itm->to;
85 }
86
87 /* Return true if we have hit the end of the referenced variables ITER is
88    iterating through.  */
89
90 static inline bool
91 end_referenced_vars_p (referenced_var_iterator *iter)
92 {
93   return end_htab_p (&iter->hti);
94 }
95
96 /* Make ITER point to the next referenced_var in the referenced_var hashtable,
97    and return that variable.  */
98
99 static inline tree
100 next_referenced_var (referenced_var_iterator *iter)
101 {
102   struct int_tree_map *itm;
103   itm = next_htab_element (&iter->hti);
104   if (!itm) 
105     return NULL;
106   return itm->to;
107
108
109 /* Fill up VEC with the variables in the referenced vars hashtable.  */
110
111 static inline void
112 fill_referenced_var_vec (VEC (tree, heap) **vec)
113 {
114   referenced_var_iterator rvi;
115   tree var;
116   *vec = NULL;
117   FOR_EACH_REFERENCED_VAR (var, rvi)
118     VEC_safe_push (tree, heap, *vec, var);
119 }
120
121 /* Return the variable annotation for T, which must be a _DECL node.
122    Return NULL if the variable annotation doesn't already exist.  */
123 static inline var_ann_t
124 var_ann (tree t)
125 {
126   gcc_assert (t);
127   gcc_assert (DECL_P (t));
128   gcc_assert (!t->common.ann || t->common.ann->common.type == VAR_ANN);
129
130   return (var_ann_t) t->common.ann;
131 }
132
133 /* Return the variable annotation for T, which must be a _DECL node.
134    Create the variable annotation if it doesn't exist.  */
135 static inline var_ann_t
136 get_var_ann (tree var)
137 {
138   var_ann_t ann = var_ann (var);
139   return (ann) ? ann : create_var_ann (var);
140 }
141
142 /* Return the statement annotation for T, which must be a statement
143    node.  Return NULL if the statement annotation doesn't exist.  */
144 static inline stmt_ann_t
145 stmt_ann (tree t)
146 {
147 #ifdef ENABLE_CHECKING
148   gcc_assert (is_gimple_stmt (t));
149 #endif
150   return (stmt_ann_t) t->common.ann;
151 }
152
153 /* Return the statement annotation for T, which must be a statement
154    node.  Create the statement annotation if it doesn't exist.  */
155 static inline stmt_ann_t
156 get_stmt_ann (tree stmt)
157 {
158   stmt_ann_t ann = stmt_ann (stmt);
159   return (ann) ? ann : create_stmt_ann (stmt);
160 }
161
162 /* Return the annotation type for annotation ANN.  */
163 static inline enum tree_ann_type
164 ann_type (tree_ann_t ann)
165 {
166   return ann->common.type;
167 }
168
169 /* Return the basic block for statement T.  */
170 static inline basic_block
171 bb_for_stmt (tree t)
172 {
173   stmt_ann_t ann;
174
175   if (TREE_CODE (t) == PHI_NODE)
176     return PHI_BB (t);
177
178   ann = stmt_ann (t);
179   return ann ? ann->bb : NULL;
180 }
181
182 /* Return the may_aliases varray for variable VAR, or NULL if it has
183    no may aliases.  */
184 static inline varray_type
185 may_aliases (tree var)
186 {
187   var_ann_t ann = var_ann (var);
188   return ann ? ann->may_aliases : NULL;
189 }
190
191 /* Return the line number for EXPR, or return -1 if we have no line
192    number information for it.  */
193 static inline int
194 get_lineno (tree expr)
195 {
196   if (expr == NULL_TREE)
197     return -1;
198
199   if (TREE_CODE (expr) == COMPOUND_EXPR)
200     expr = TREE_OPERAND (expr, 0);
201
202   if (! EXPR_HAS_LOCATION (expr))
203     return -1;
204
205   return EXPR_LINENO (expr);
206 }
207
208 /* Return the file name for EXPR, or return "???" if we have no
209    filename information.  */
210 static inline const char *
211 get_filename (tree expr)
212 {
213   const char *filename;
214   if (expr == NULL_TREE)
215     return "???";
216
217   if (TREE_CODE (expr) == COMPOUND_EXPR)
218     expr = TREE_OPERAND (expr, 0);
219
220   if (EXPR_HAS_LOCATION (expr) && (filename = EXPR_FILENAME (expr)))
221     return filename;
222   else
223     return "???";
224 }
225
226 /* Return true if T is a noreturn call.  */
227 static inline bool
228 noreturn_call_p (tree t)
229 {
230   tree call = get_call_expr_in (t);
231   return call != 0 && (call_expr_flags (call) & ECF_NORETURN) != 0;
232 }
233
234 /* Mark statement T as modified.  */
235 static inline void
236 mark_stmt_modified (tree t)
237 {
238   stmt_ann_t ann;
239   if (TREE_CODE (t) == PHI_NODE)
240     return;
241
242   ann = stmt_ann (t);
243   if (ann == NULL)
244     ann = create_stmt_ann (t);
245   else if (noreturn_call_p (t))
246     VEC_safe_push (tree, gc, modified_noreturn_calls, t);
247   ann->modified = 1;
248 }
249
250 /* Mark statement T as modified, and update it.  */
251 static inline void
252 update_stmt (tree t)
253 {
254   if (TREE_CODE (t) == PHI_NODE)
255     return;
256   mark_stmt_modified (t);
257   update_stmt_operands (t);
258 }
259
260 static inline void
261 update_stmt_if_modified (tree t)
262 {
263   if (stmt_modified_p (t))
264     update_stmt_operands (t);
265 }
266
267 /* Return true if T is marked as modified, false otherwise.  */
268 static inline bool
269 stmt_modified_p (tree t)
270 {
271   stmt_ann_t ann = stmt_ann (t);
272
273   /* Note that if the statement doesn't yet have an annotation, we consider it
274      modified.  This will force the next call to update_stmt_operands to scan 
275      the statement.  */
276   return ann ? ann->modified : true;
277 }
278
279 /* Delink an immediate_uses node from its chain.  */
280 static inline void
281 delink_imm_use (ssa_use_operand_t *linknode)
282 {
283   /* Return if this node is not in a list.  */
284   if (linknode->prev == NULL)
285     return;
286
287   linknode->prev->next = linknode->next;
288   linknode->next->prev = linknode->prev;
289   linknode->prev = NULL;
290   linknode->next = NULL;
291 }
292
293 /* Link ssa_imm_use node LINKNODE into the chain for LIST.  */
294 static inline void
295 link_imm_use_to_list (ssa_use_operand_t *linknode, ssa_use_operand_t *list)
296 {
297   /* Link the new node at the head of the list.  If we are in the process of 
298      traversing the list, we won't visit any new nodes added to it.  */
299   linknode->prev = list;
300   linknode->next = list->next;
301   list->next->prev = linknode;
302   list->next = linknode;
303 }
304
305 /* Link ssa_imm_use node LINKNODE into the chain for DEF.  */
306 static inline void
307 link_imm_use (ssa_use_operand_t *linknode, tree def)
308 {
309   ssa_use_operand_t *root;
310
311   if (!def || TREE_CODE (def) != SSA_NAME)
312     linknode->prev = NULL;
313   else
314     {
315       root = &(SSA_NAME_IMM_USE_NODE (def));
316 #ifdef ENABLE_CHECKING
317       if (linknode->use)
318         gcc_assert (*(linknode->use) == def);
319 #endif
320       link_imm_use_to_list (linknode, root);
321     }
322 }
323
324 /* Set the value of a use pointed to by USE to VAL.  */
325 static inline void
326 set_ssa_use_from_ptr (use_operand_p use, tree val)
327 {
328   delink_imm_use (use);
329   *(use->use) = val;
330   link_imm_use (use, val);
331 }
332
333 /* Link ssa_imm_use node LINKNODE into the chain for DEF, with use occurring 
334    in STMT.  */
335 static inline void
336 link_imm_use_stmt (ssa_use_operand_t *linknode, tree def, tree stmt)
337 {
338   if (stmt)
339     link_imm_use (linknode, def);
340   else
341     link_imm_use (linknode, NULL);
342   linknode->stmt = stmt;
343 }
344
345 /* Relink a new node in place of an old node in the list.  */
346 static inline void
347 relink_imm_use (ssa_use_operand_t *node, ssa_use_operand_t *old)
348 {
349   /* The node one had better be in the same list.  */
350   gcc_assert (*(old->use) == *(node->use));
351   node->prev = old->prev;
352   node->next = old->next;
353   if (old->prev)
354     {
355       old->prev->next = node;
356       old->next->prev = node;
357       /* Remove the old node from the list.  */
358       old->prev = NULL;
359     }
360 }
361
362 /* Relink ssa_imm_use node LINKNODE into the chain for OLD, with use occurring 
363    in STMT.  */
364 static inline void
365 relink_imm_use_stmt (ssa_use_operand_t *linknode, ssa_use_operand_t *old, tree stmt)
366 {
367   if (stmt)
368     relink_imm_use (linknode, old);
369   else
370     link_imm_use (linknode, NULL);
371   linknode->stmt = stmt;
372 }
373
374 /* Finished the traverse of an immediate use list IMM by removing it from 
375    the list.  */
376 static inline void
377 end_safe_imm_use_traverse (imm_use_iterator *imm)
378 {
379  delink_imm_use (&(imm->iter_node));
380 }
381
382 /* Return true if IMM is at the end of the list.  */
383 static inline bool
384 end_safe_imm_use_p (imm_use_iterator *imm)
385 {
386   return (imm->imm_use == imm->end_p);
387 }
388
389 /* Initialize iterator IMM to process the list for VAR.  */
390 static inline use_operand_p
391 first_safe_imm_use (imm_use_iterator *imm, tree var)
392 {
393   /* Set up and link the iterator node into the linked list for VAR.  */
394   imm->iter_node.use = NULL;
395   imm->iter_node.stmt = NULL_TREE;
396   imm->end_p = &(SSA_NAME_IMM_USE_NODE (var));
397   /* Check if there are 0 elements.  */
398   if (imm->end_p->next == imm->end_p)
399     {
400       imm->imm_use = imm->end_p;
401       return NULL_USE_OPERAND_P;
402     }
403
404   link_imm_use (&(imm->iter_node), var);
405   imm->imm_use = imm->iter_node.next;
406   return imm->imm_use;
407 }
408
409 /* Bump IMM to the next use in the list.  */
410 static inline use_operand_p
411 next_safe_imm_use (imm_use_iterator *imm)
412 {
413   ssa_use_operand_t *ptr;
414   use_operand_p old;
415
416   old = imm->imm_use;
417   /* If the next node following the iter_node is still the one referred to by
418      imm_use, then the list hasn't changed, go to the next node.  */
419   if (imm->iter_node.next == imm->imm_use)
420     {
421       ptr = &(imm->iter_node);
422       /* Remove iternode from the list.  */
423       delink_imm_use (ptr);
424       imm->imm_use = imm->imm_use->next;
425       if (! end_safe_imm_use_p (imm))
426         {
427           /* This isn't the end, link iternode before the next use.  */
428           ptr->prev = imm->imm_use->prev;
429           ptr->next = imm->imm_use;
430           imm->imm_use->prev->next = ptr;
431           imm->imm_use->prev = ptr;
432         }
433       else
434         return old;
435     }
436   else
437     {
438       /* If the 'next' value after the iterator isn't the same as it was, then
439          a node has been deleted, so we simply proceed to the node following 
440          where the iterator is in the list.  */
441       imm->imm_use = imm->iter_node.next;
442       if (end_safe_imm_use_p (imm))
443         {
444           end_safe_imm_use_traverse (imm);
445           return old;
446         }
447     }
448
449   return imm->imm_use;
450 }
451
452 /* Return true is IMM has reached the end of the immediate use list.  */
453 static inline bool
454 end_readonly_imm_use_p (imm_use_iterator *imm)
455 {
456   return (imm->imm_use == imm->end_p);
457 }
458
459 /* Initialize iterator IMM to process the list for VAR.  */
460 static inline use_operand_p
461 first_readonly_imm_use (imm_use_iterator *imm, tree var)
462 {
463   gcc_assert (TREE_CODE (var) == SSA_NAME);
464
465   imm->end_p = &(SSA_NAME_IMM_USE_NODE (var));
466   imm->imm_use = imm->end_p->next;
467 #ifdef ENABLE_CHECKING
468   imm->iter_node.next = imm->imm_use->next;
469 #endif
470   if (end_readonly_imm_use_p (imm))
471     return NULL_USE_OPERAND_P;
472   return imm->imm_use;
473 }
474
475 /* Bump IMM to the next use in the list.  */
476 static inline use_operand_p
477 next_readonly_imm_use (imm_use_iterator *imm)
478 {
479   use_operand_p old = imm->imm_use;
480
481 #ifdef ENABLE_CHECKING
482   /* If this assertion fails, it indicates the 'next' pointer has changed 
483      since we the last bump.  This indicates that the list is being modified
484      via stmt changes, or SET_USE, or somesuch thing, and you need to be
485      using the SAFE version of the iterator.  */
486   gcc_assert (imm->iter_node.next == old->next);
487   imm->iter_node.next = old->next->next;
488 #endif
489
490   imm->imm_use = old->next;
491   if (end_readonly_imm_use_p (imm))
492     return old;
493   return imm->imm_use;
494 }
495
496 /* Return true if VAR has no uses.  */
497 static inline bool
498 has_zero_uses (tree var)
499 {
500   ssa_use_operand_t *ptr;
501   ptr = &(SSA_NAME_IMM_USE_NODE (var));
502   /* A single use means there is no items in the list.  */
503   return (ptr == ptr->next);
504 }
505
506 /* Return true if VAR has a single use.  */
507 static inline bool
508 has_single_use (tree var)
509 {
510   ssa_use_operand_t *ptr;
511   ptr = &(SSA_NAME_IMM_USE_NODE (var));
512   /* A single use means there is one item in the list.  */
513   return (ptr != ptr->next && ptr == ptr->next->next);
514 }
515
516 /* If VAR has only a single immediate use, return true, and set USE_P and STMT
517    to the use pointer and stmt of occurrence.  */
518 static inline bool
519 single_imm_use (tree var, use_operand_p *use_p, tree *stmt)
520 {
521   ssa_use_operand_t *ptr;
522
523   ptr = &(SSA_NAME_IMM_USE_NODE (var));
524   if (ptr != ptr->next && ptr == ptr->next->next)
525     {
526       *use_p = ptr->next;
527       *stmt = ptr->next->stmt;
528       return true;
529     }
530   *use_p = NULL_USE_OPERAND_P;
531   *stmt = NULL_TREE;
532   return false;
533 }
534
535 /* Return the number of immediate uses of VAR.  */
536 static inline unsigned int
537 num_imm_uses (tree var)
538 {
539   ssa_use_operand_t *ptr, *start;
540   unsigned int num;
541
542   start = &(SSA_NAME_IMM_USE_NODE (var));
543   num = 0;
544   for (ptr = start->next; ptr != start; ptr = ptr->next)
545      num++;
546
547   return num;
548 }
549
550
551 /* Return the tree pointer to by USE.  */ 
552 static inline tree
553 get_use_from_ptr (use_operand_p use)
554
555   return *(use->use);
556
557
558 /* Return the tree pointer to by DEF.  */
559 static inline tree
560 get_def_from_ptr (def_operand_p def)
561 {
562   return *def;
563 }
564
565 /* Return a def_operand_p pointer for the result of PHI.  */
566 static inline def_operand_p
567 get_phi_result_ptr (tree phi)
568 {
569   return &(PHI_RESULT_TREE (phi));
570 }
571
572 /* Return a use_operand_p pointer for argument I of phinode PHI.  */
573 static inline use_operand_p
574 get_phi_arg_def_ptr (tree phi, int i)
575 {
576   return &(PHI_ARG_IMM_USE_NODE (phi,i));
577 }
578
579
580 /* Return the bitmap of addresses taken by STMT, or NULL if it takes
581    no addresses.  */
582 static inline bitmap
583 addresses_taken (tree stmt)
584 {
585   stmt_ann_t ann = stmt_ann (stmt);
586   return ann ? ann->addresses_taken : NULL;
587 }
588
589 /* Return the PHI nodes for basic block BB, or NULL if there are no
590    PHI nodes.  */
591 static inline tree
592 phi_nodes (basic_block bb)
593 {
594   return bb->phi_nodes;
595 }
596
597 /* Set list of phi nodes of a basic block BB to L.  */
598
599 static inline void
600 set_phi_nodes (basic_block bb, tree l)
601 {
602   tree phi;
603
604   bb->phi_nodes = l;
605   for (phi = l; phi; phi = PHI_CHAIN (phi))
606     set_bb_for_stmt (phi, bb);
607 }
608
609 /* Return the phi argument which contains the specified use.  */
610
611 static inline int
612 phi_arg_index_from_use (use_operand_p use)
613 {
614   struct phi_arg_d *element, *root;
615   int index;
616   tree phi;
617
618   /* Since the use is the first thing in a PHI argument element, we can
619      calculate its index based on casting it to an argument, and performing
620      pointer arithmetic.  */
621
622   phi = USE_STMT (use);
623   gcc_assert (TREE_CODE (phi) == PHI_NODE);
624
625   element = (struct phi_arg_d *)use;
626   root = &(PHI_ARG_ELT (phi, 0));
627   index = element - root;
628
629 #ifdef ENABLE_CHECKING
630   /* Make sure the calculation doesn't have any leftover bytes.  If it does, 
631      then imm_use is likely not the first element in phi_arg_d.  */
632   gcc_assert (
633           (((char *)element - (char *)root) % sizeof (struct phi_arg_d)) == 0);
634   gcc_assert (index >= 0 && index < PHI_ARG_CAPACITY (phi));
635 #endif
636  
637  return index;
638 }
639
640 /* Mark VAR as used, so that it'll be preserved during rtl expansion.  */
641
642 static inline void
643 set_is_used (tree var)
644 {
645   var_ann_t ann = get_var_ann (var);
646   ann->used = 1;
647 }
648
649
650 /*  -----------------------------------------------------------------------  */
651
652 /* Return true if T is an executable statement.  */
653 static inline bool
654 is_exec_stmt (tree t)
655 {
656   return (t && !IS_EMPTY_STMT (t) && t != error_mark_node);
657 }
658
659
660 /* Return true if this stmt can be the target of a control transfer stmt such
661    as a goto.  */
662 static inline bool
663 is_label_stmt (tree t)
664 {
665   if (t)
666     switch (TREE_CODE (t))
667       {
668         case LABEL_DECL:
669         case LABEL_EXPR:
670         case CASE_LABEL_EXPR:
671           return true;
672         default:
673           return false;
674       }
675   return false;
676 }
677
678 /* Set the default definition for VAR to DEF.  */
679 static inline void
680 set_default_def (tree var, tree def)
681 {
682   var_ann_t ann = get_var_ann (var);
683   ann->default_def = def;
684 }
685
686 /* Return the default definition for variable VAR, or NULL if none
687    exists.  */
688 static inline tree
689 default_def (tree var)
690 {
691   var_ann_t ann = var_ann (var);
692   return ann ? ann->default_def : NULL_TREE;
693 }
694
695 /* PHI nodes should contain only ssa_names and invariants.  A test
696    for ssa_name is definitely simpler; don't let invalid contents
697    slip in in the meantime.  */
698
699 static inline bool
700 phi_ssa_name_p (tree t)
701 {
702   if (TREE_CODE (t) == SSA_NAME)
703     return true;
704 #ifdef ENABLE_CHECKING
705   gcc_assert (is_gimple_min_invariant (t));
706 #endif
707   return false;
708 }
709
710 /*  -----------------------------------------------------------------------  */
711
712 /* Return a block_stmt_iterator that points to beginning of basic
713    block BB.  */
714 static inline block_stmt_iterator
715 bsi_start (basic_block bb)
716 {
717   block_stmt_iterator bsi;
718   if (bb->stmt_list)
719     bsi.tsi = tsi_start (bb->stmt_list);
720   else
721     {
722       gcc_assert (bb->index < 0);
723       bsi.tsi.ptr = NULL;
724       bsi.tsi.container = NULL;
725     }
726   bsi.bb = bb;
727   return bsi;
728 }
729
730 /* Return a block statement iterator that points to the first non-label
731    block BB.  */
732
733 static inline block_stmt_iterator
734 bsi_after_labels (basic_block bb)
735 {
736   block_stmt_iterator bsi;
737   tree_stmt_iterator next;
738
739   bsi.bb = bb;
740
741   if (!bb->stmt_list)
742     {
743       gcc_assert (bb->index < 0);
744       bsi.tsi.ptr = NULL;
745       bsi.tsi.container = NULL;
746       return bsi;
747     }
748
749   bsi.tsi = tsi_start (bb->stmt_list);
750   if (tsi_end_p (bsi.tsi))
751     return bsi;
752
753   next = bsi.tsi;
754   tsi_next (&next);
755
756   while (!tsi_end_p (next)
757          && TREE_CODE (tsi_stmt (next)) == LABEL_EXPR)
758     {
759       bsi.tsi = next;
760       tsi_next (&next);
761     }
762
763   return bsi;
764 }
765
766 /* Return a block statement iterator that points to the end of basic
767    block BB.  */
768 static inline block_stmt_iterator
769 bsi_last (basic_block bb)
770 {
771   block_stmt_iterator bsi;
772   if (bb->stmt_list)
773     bsi.tsi = tsi_last (bb->stmt_list);
774   else
775     {
776       gcc_assert (bb->index < 0);
777       bsi.tsi.ptr = NULL;
778       bsi.tsi.container = NULL;
779     }
780   bsi.bb = bb;
781   return bsi;
782 }
783
784 /* Return true if block statement iterator I has reached the end of
785    the basic block.  */
786 static inline bool
787 bsi_end_p (block_stmt_iterator i)
788 {
789   return tsi_end_p (i.tsi);
790 }
791
792 /* Modify block statement iterator I so that it is at the next
793    statement in the basic block.  */
794 static inline void
795 bsi_next (block_stmt_iterator *i)
796 {
797   tsi_next (&i->tsi);
798 }
799
800 /* Modify block statement iterator I so that it is at the previous
801    statement in the basic block.  */
802 static inline void
803 bsi_prev (block_stmt_iterator *i)
804 {
805   tsi_prev (&i->tsi);
806 }
807
808 /* Return the statement that block statement iterator I is currently
809    at.  */
810 static inline tree
811 bsi_stmt (block_stmt_iterator i)
812 {
813   return tsi_stmt (i.tsi);
814 }
815
816 /* Return a pointer to the statement that block statement iterator I
817    is currently at.  */
818 static inline tree *
819 bsi_stmt_ptr (block_stmt_iterator i)
820 {
821   return tsi_stmt_ptr (i.tsi);
822 }
823
824 /* Returns the loop of the statement STMT.  */
825
826 static inline struct loop *
827 loop_containing_stmt (tree stmt)
828 {
829   basic_block bb = bb_for_stmt (stmt);
830   if (!bb)
831     return NULL;
832
833   return bb->loop_father;
834 }
835
836 /* Return true if VAR is a clobbered by function calls.  */
837 static inline bool
838 is_call_clobbered (tree var)
839 {
840   return is_global_var (var)
841     || bitmap_bit_p (call_clobbered_vars, DECL_UID (var));
842 }
843
844 /* Mark variable VAR as being clobbered by function calls.  */
845 static inline void
846 mark_call_clobbered (tree var)
847 {
848   var_ann_t ann = var_ann (var);
849   /* If VAR is a memory tag, then we need to consider it a global
850      variable.  This is because the pointer that VAR represents has
851      been found to point to either an arbitrary location or to a known
852      location in global memory.  */
853   if (ann->mem_tag_kind != NOT_A_TAG && ann->mem_tag_kind != STRUCT_FIELD)
854     DECL_EXTERNAL (var) = 1;
855   bitmap_set_bit (call_clobbered_vars, DECL_UID (var));
856   ssa_call_clobbered_cache_valid = false;
857   ssa_ro_call_cache_valid = false;
858 }
859
860 /* Clear the call-clobbered attribute from variable VAR.  */
861 static inline void
862 clear_call_clobbered (tree var)
863 {
864   var_ann_t ann = var_ann (var);
865   if (ann->mem_tag_kind != NOT_A_TAG && ann->mem_tag_kind != STRUCT_FIELD)
866     DECL_EXTERNAL (var) = 0;
867   bitmap_clear_bit (call_clobbered_vars, DECL_UID (var));
868   ssa_call_clobbered_cache_valid = false;
869   ssa_ro_call_cache_valid = false;
870 }
871
872 /* Mark variable VAR as being non-addressable.  */
873 static inline void
874 mark_non_addressable (tree var)
875 {
876   bitmap_clear_bit (call_clobbered_vars, DECL_UID (var));
877   TREE_ADDRESSABLE (var) = 0;
878   ssa_call_clobbered_cache_valid = false;
879   ssa_ro_call_cache_valid = false;
880 }
881
882 /* Return the common annotation for T.  Return NULL if the annotation
883    doesn't already exist.  */
884 static inline tree_ann_t
885 tree_ann (tree t)
886 {
887   return t->common.ann;
888 }
889
890 /* Return a common annotation for T.  Create the constant annotation if it
891    doesn't exist.  */
892 static inline tree_ann_t
893 get_tree_ann (tree t)
894 {
895   tree_ann_t ann = tree_ann (t);
896   return (ann) ? ann : create_tree_ann (t);
897 }
898
899 /*  -----------------------------------------------------------------------  */
900
901 /* The following set of routines are used to iterator over various type of
902    SSA operands.  */
903
904 /* Return true if PTR is finished iterating.  */
905 static inline bool
906 op_iter_done (ssa_op_iter *ptr)
907 {
908   return ptr->done;
909 }
910
911 /* Get the next iterator use value for PTR.  */
912 static inline use_operand_p
913 op_iter_next_use (ssa_op_iter *ptr)
914 {
915   use_operand_p use_p;
916 #ifdef ENABLE_CHECKING
917   gcc_assert (ptr->iter_type == ssa_op_iter_use);
918 #endif
919   if (ptr->uses)
920     {
921       use_p = USE_OP_PTR (ptr->uses);
922       ptr->uses = ptr->uses->next;
923       return use_p;
924     }
925   if (ptr->vuses)
926     {
927       use_p = VUSE_OP_PTR (ptr->vuses);
928       ptr->vuses = ptr->vuses->next;
929       return use_p;
930     }
931   if (ptr->mayuses)
932     {
933       use_p = MAYDEF_OP_PTR (ptr->mayuses);
934       ptr->mayuses = ptr->mayuses->next;
935       return use_p;
936     }
937   if (ptr->mustkills)
938     {
939       use_p = MUSTDEF_KILL_PTR (ptr->mustkills);
940       ptr->mustkills = ptr->mustkills->next;
941       return use_p;
942     }
943   if (ptr->phi_i < ptr->num_phi)
944     {
945       return PHI_ARG_DEF_PTR (ptr->phi_stmt, (ptr->phi_i)++);
946     }
947   ptr->done = true;
948   return NULL_USE_OPERAND_P;
949 }
950
951 /* Get the next iterator def value for PTR.  */
952 static inline def_operand_p
953 op_iter_next_def (ssa_op_iter *ptr)
954 {
955   def_operand_p def_p;
956 #ifdef ENABLE_CHECKING
957   gcc_assert (ptr->iter_type == ssa_op_iter_def);
958 #endif
959   if (ptr->defs)
960     {
961       def_p = DEF_OP_PTR (ptr->defs);
962       ptr->defs = ptr->defs->next;
963       return def_p;
964     }
965   if (ptr->mustdefs)
966     {
967       def_p = MUSTDEF_RESULT_PTR (ptr->mustdefs);
968       ptr->mustdefs = ptr->mustdefs->next;
969       return def_p;
970     }
971   if (ptr->maydefs)
972     {
973       def_p = MAYDEF_RESULT_PTR (ptr->maydefs);
974       ptr->maydefs = ptr->maydefs->next;
975       return def_p;
976     }
977   ptr->done = true;
978   return NULL_DEF_OPERAND_P;
979 }
980
981 /* Get the next iterator tree value for PTR.  */
982 static inline tree
983 op_iter_next_tree (ssa_op_iter *ptr)
984 {
985   tree val;
986 #ifdef ENABLE_CHECKING
987   gcc_assert (ptr->iter_type == ssa_op_iter_tree);
988 #endif
989   if (ptr->uses)
990     {
991       val = USE_OP (ptr->uses);
992       ptr->uses = ptr->uses->next;
993       return val;
994     }
995   if (ptr->vuses)
996     {
997       val = VUSE_OP (ptr->vuses);
998       ptr->vuses = ptr->vuses->next;
999       return val;
1000     }
1001   if (ptr->mayuses)
1002     {
1003       val = MAYDEF_OP (ptr->mayuses);
1004       ptr->mayuses = ptr->mayuses->next;
1005       return val;
1006     }
1007   if (ptr->mustkills)
1008     {
1009       val = MUSTDEF_KILL (ptr->mustkills);
1010       ptr->mustkills = ptr->mustkills->next;
1011       return val;
1012     }
1013   if (ptr->defs)
1014     {
1015       val = DEF_OP (ptr->defs);
1016       ptr->defs = ptr->defs->next;
1017       return val;
1018     }
1019   if (ptr->mustdefs)
1020     {
1021       val = MUSTDEF_RESULT (ptr->mustdefs);
1022       ptr->mustdefs = ptr->mustdefs->next;
1023       return val;
1024     }
1025   if (ptr->maydefs)
1026     {
1027       val = MAYDEF_RESULT (ptr->maydefs);
1028       ptr->maydefs = ptr->maydefs->next;
1029       return val;
1030     }
1031
1032   ptr->done = true;
1033   return NULL_TREE;
1034
1035 }
1036
1037
1038 /* This functions clears the iterator PTR, and marks it done.  This is normally
1039    used to prevent warnings in the compile about might be uninitailzied
1040    components.  */
1041
1042 static inline void
1043 clear_and_done_ssa_iter (ssa_op_iter *ptr)
1044 {
1045   ptr->defs = NULL;
1046   ptr->uses = NULL;
1047   ptr->vuses = NULL;
1048   ptr->maydefs = NULL;
1049   ptr->mayuses = NULL;
1050   ptr->mustdefs = NULL;
1051   ptr->mustkills = NULL;
1052   ptr->iter_type = ssa_op_iter_none;
1053   ptr->phi_i = 0;
1054   ptr->num_phi = 0;
1055   ptr->phi_stmt = NULL_TREE;
1056   ptr->done = true;
1057 }
1058
1059 /* Initialize the iterator PTR to the virtual defs in STMT.  */
1060 static inline void
1061 op_iter_init (ssa_op_iter *ptr, tree stmt, int flags)
1062 {
1063 #ifdef ENABLE_CHECKING
1064   gcc_assert (stmt_ann (stmt));
1065 #endif
1066
1067   ptr->defs = (flags & SSA_OP_DEF) ? DEF_OPS (stmt) : NULL;
1068   ptr->uses = (flags & SSA_OP_USE) ? USE_OPS (stmt) : NULL;
1069   ptr->vuses = (flags & SSA_OP_VUSE) ? VUSE_OPS (stmt) : NULL;
1070   ptr->maydefs = (flags & SSA_OP_VMAYDEF) ? MAYDEF_OPS (stmt) : NULL;
1071   ptr->mayuses = (flags & SSA_OP_VMAYUSE) ? MAYDEF_OPS (stmt) : NULL;
1072   ptr->mustdefs = (flags & SSA_OP_VMUSTDEF) ? MUSTDEF_OPS (stmt) : NULL;
1073   ptr->mustkills = (flags & SSA_OP_VMUSTKILL) ? MUSTDEF_OPS (stmt) : NULL;
1074   ptr->done = false;
1075
1076   ptr->phi_i = 0;
1077   ptr->num_phi = 0;
1078   ptr->phi_stmt = NULL_TREE;
1079 }
1080
1081 /* Initialize iterator PTR to the use operands in STMT based on FLAGS. Return
1082    the first use.  */
1083 static inline use_operand_p
1084 op_iter_init_use (ssa_op_iter *ptr, tree stmt, int flags)
1085 {
1086   gcc_assert ((flags & SSA_OP_ALL_DEFS) == 0);
1087   op_iter_init (ptr, stmt, flags);
1088   ptr->iter_type = ssa_op_iter_use;
1089   return op_iter_next_use (ptr);
1090 }
1091
1092 /* Initialize iterator PTR to the def operands in STMT based on FLAGS. Return
1093    the first def.  */
1094 static inline def_operand_p
1095 op_iter_init_def (ssa_op_iter *ptr, tree stmt, int flags)
1096 {
1097   gcc_assert ((flags & (SSA_OP_ALL_USES | SSA_OP_VIRTUAL_KILLS)) == 0);
1098   op_iter_init (ptr, stmt, flags);
1099   ptr->iter_type = ssa_op_iter_def;
1100   return op_iter_next_def (ptr);
1101 }
1102
1103 /* Initialize iterator PTR to the operands in STMT based on FLAGS. Return
1104    the first operand as a tree.  */
1105 static inline tree
1106 op_iter_init_tree (ssa_op_iter *ptr, tree stmt, int flags)
1107 {
1108   op_iter_init (ptr, stmt, flags);
1109   ptr->iter_type = ssa_op_iter_tree;
1110   return op_iter_next_tree (ptr);
1111 }
1112
1113 /* Get the next iterator mustdef value for PTR, returning the mustdef values in
1114    KILL and DEF.  */
1115 static inline void
1116 op_iter_next_maymustdef (use_operand_p *use, def_operand_p *def, 
1117                          ssa_op_iter *ptr)
1118 {
1119 #ifdef ENABLE_CHECKING
1120   gcc_assert (ptr->iter_type == ssa_op_iter_maymustdef);
1121 #endif
1122   if (ptr->mayuses)
1123     {
1124       *def = MAYDEF_RESULT_PTR (ptr->mayuses);
1125       *use = MAYDEF_OP_PTR (ptr->mayuses);
1126       ptr->mayuses = ptr->mayuses->next;
1127       return;
1128     }
1129
1130   if (ptr->mustkills)
1131     {
1132       *def = MUSTDEF_RESULT_PTR (ptr->mustkills);
1133       *use = MUSTDEF_KILL_PTR (ptr->mustkills);
1134       ptr->mustkills = ptr->mustkills->next;
1135       return;
1136     }
1137
1138   *def = NULL_DEF_OPERAND_P;
1139   *use = NULL_USE_OPERAND_P;
1140   ptr->done = true;
1141   return;
1142 }
1143
1144
1145 /* Initialize iterator PTR to the operands in STMT.  Return the first operands
1146    in USE and DEF.  */
1147 static inline void
1148 op_iter_init_maydef (ssa_op_iter *ptr, tree stmt, use_operand_p *use, 
1149                      def_operand_p *def)
1150 {
1151   gcc_assert (TREE_CODE (stmt) != PHI_NODE);
1152
1153   op_iter_init (ptr, stmt, SSA_OP_VMAYUSE);
1154   ptr->iter_type = ssa_op_iter_maymustdef;
1155   op_iter_next_maymustdef (use, def, ptr);
1156 }
1157
1158
1159 /* Initialize iterator PTR to the operands in STMT.  Return the first operands
1160    in KILL and DEF.  */
1161 static inline void
1162 op_iter_init_mustdef (ssa_op_iter *ptr, tree stmt, use_operand_p *kill, 
1163                      def_operand_p *def)
1164 {
1165   gcc_assert (TREE_CODE (stmt) != PHI_NODE);
1166
1167   op_iter_init (ptr, stmt, SSA_OP_VMUSTKILL);
1168   ptr->iter_type = ssa_op_iter_maymustdef;
1169   op_iter_next_maymustdef (kill, def, ptr);
1170 }
1171
1172 /* Initialize iterator PTR to the operands in STMT.  Return the first operands
1173    in KILL and DEF.  */
1174 static inline void
1175 op_iter_init_must_and_may_def (ssa_op_iter *ptr, tree stmt,
1176                                use_operand_p *kill, def_operand_p *def)
1177 {
1178   gcc_assert (TREE_CODE (stmt) != PHI_NODE);
1179
1180   op_iter_init (ptr, stmt, SSA_OP_VMUSTKILL|SSA_OP_VMAYUSE);
1181   ptr->iter_type = ssa_op_iter_maymustdef;
1182   op_iter_next_maymustdef (kill, def, ptr);
1183 }
1184
1185
1186 /* If there is a single operand in STMT matching FLAGS, return it.  Otherwise
1187    return NULL.  */
1188 static inline tree
1189 single_ssa_tree_operand (tree stmt, int flags)
1190 {
1191   tree var;
1192   ssa_op_iter iter;
1193
1194   var = op_iter_init_tree (&iter, stmt, flags);
1195   if (op_iter_done (&iter))
1196     return NULL_TREE;
1197   op_iter_next_tree (&iter);
1198   if (op_iter_done (&iter))
1199     return var;
1200   return NULL_TREE;
1201 }
1202
1203
1204 /* If there is a single operand in STMT matching FLAGS, return it.  Otherwise
1205    return NULL.  */
1206 static inline use_operand_p
1207 single_ssa_use_operand (tree stmt, int flags)
1208 {
1209   use_operand_p var;
1210   ssa_op_iter iter;
1211
1212   var = op_iter_init_use (&iter, stmt, flags);
1213   if (op_iter_done (&iter))
1214     return NULL_USE_OPERAND_P;
1215   op_iter_next_use (&iter);
1216   if (op_iter_done (&iter))
1217     return var;
1218   return NULL_USE_OPERAND_P;
1219 }
1220
1221
1222
1223 /* If there is a single operand in STMT matching FLAGS, return it.  Otherwise
1224    return NULL.  */
1225 static inline def_operand_p
1226 single_ssa_def_operand (tree stmt, int flags)
1227 {
1228   def_operand_p var;
1229   ssa_op_iter iter;
1230
1231   var = op_iter_init_def (&iter, stmt, flags);
1232   if (op_iter_done (&iter))
1233     return NULL_DEF_OPERAND_P;
1234   op_iter_next_def (&iter);
1235   if (op_iter_done (&iter))
1236     return var;
1237   return NULL_DEF_OPERAND_P;
1238 }
1239
1240
1241 /* If there is a single operand in STMT matching FLAGS, return it.  Otherwise
1242    return NULL.  */
1243 static inline bool
1244 zero_ssa_operands (tree stmt, int flags)
1245 {
1246   ssa_op_iter iter;
1247
1248   op_iter_init_tree (&iter, stmt, flags);
1249   return op_iter_done (&iter);
1250 }
1251
1252
1253 /* Return the number of operands matching FLAGS in STMT.  */
1254 static inline int
1255 num_ssa_operands (tree stmt, int flags)
1256 {
1257   ssa_op_iter iter;
1258   tree t;
1259   int num = 0;
1260
1261   FOR_EACH_SSA_TREE_OPERAND (t, stmt, iter, flags)
1262     num++;
1263   return num;
1264 }
1265
1266
1267 /* Delink all immediate_use information for STMT.  */
1268 static inline void
1269 delink_stmt_imm_use (tree stmt)
1270 {
1271    ssa_op_iter iter;
1272    use_operand_p use_p;
1273
1274    if (ssa_operands_active ())
1275      FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter,
1276                                (SSA_OP_ALL_USES | SSA_OP_ALL_KILLS))
1277        delink_imm_use (use_p);
1278 }
1279
1280
1281 /* This routine will compare all the operands matching FLAGS in STMT1 to those
1282    in STMT2.  TRUE is returned if they are the same.  STMTs can be NULL.  */
1283 static inline bool
1284 compare_ssa_operands_equal (tree stmt1, tree stmt2, int flags)
1285 {
1286   ssa_op_iter iter1, iter2;
1287   tree op1 = NULL_TREE;
1288   tree op2 = NULL_TREE;
1289   bool look1, look2;
1290
1291   if (stmt1 == stmt2)
1292     return true;
1293
1294   look1 = stmt1 && stmt_ann (stmt1);
1295   look2 = stmt2 && stmt_ann (stmt2);
1296
1297   if (look1)
1298     {
1299       op1 = op_iter_init_tree (&iter1, stmt1, flags);
1300       if (!look2)
1301         return op_iter_done (&iter1);
1302     }
1303   else
1304     clear_and_done_ssa_iter (&iter1);
1305
1306   if (look2)
1307     {
1308       op2 = op_iter_init_tree (&iter2, stmt2, flags);
1309       if (!look1)
1310         return op_iter_done (&iter2);
1311     }
1312   else
1313     clear_and_done_ssa_iter (&iter2);
1314
1315   while (!op_iter_done (&iter1) && !op_iter_done (&iter2))
1316     {
1317       if (op1 != op2)
1318         return false;
1319       op1 = op_iter_next_tree (&iter1);
1320       op2 = op_iter_next_tree (&iter2);
1321     }
1322
1323   return (op_iter_done (&iter1) && op_iter_done (&iter2));
1324 }
1325
1326
1327 /* If there is a single DEF in the PHI node which matches FLAG, return it.
1328    Otherwise return NULL_DEF_OPERAND_P.  */
1329 static inline tree
1330 single_phi_def (tree stmt, int flags)
1331 {
1332   tree def = PHI_RESULT (stmt);
1333   if ((flags & SSA_OP_DEF) && is_gimple_reg (def)) 
1334     return def;
1335   if ((flags & SSA_OP_VIRTUAL_DEFS) && !is_gimple_reg (def))
1336     return def;
1337   return NULL_TREE;
1338 }
1339
1340 /* Initialize the iterator PTR for uses matching FLAGS in PHI.  FLAGS should
1341    be either SSA_OP_USES or SAS_OP_VIRTUAL_USES.  */
1342 static inline use_operand_p
1343 op_iter_init_phiuse (ssa_op_iter *ptr, tree phi, int flags)
1344 {
1345   tree phi_def = PHI_RESULT (phi);
1346   int comp;
1347
1348   clear_and_done_ssa_iter (ptr);
1349   ptr->done = false;
1350
1351   gcc_assert ((flags & (SSA_OP_USE | SSA_OP_VIRTUAL_USES)) != 0);
1352
1353   comp = (is_gimple_reg (phi_def) ? SSA_OP_USE : SSA_OP_VIRTUAL_USES);
1354     
1355   /* If the PHI node doesn't the operand type we care about, we're done.  */
1356   if ((flags & comp) == 0)
1357     {
1358       ptr->done = true;
1359       return NULL_USE_OPERAND_P;
1360     }
1361
1362   ptr->phi_stmt = phi;
1363   ptr->num_phi = PHI_NUM_ARGS (phi);
1364   ptr->iter_type = ssa_op_iter_use;
1365   return op_iter_next_use (ptr);
1366 }
1367
1368
1369 /* Start an iterator for a PHI definition.  */
1370
1371 static inline def_operand_p
1372 op_iter_init_phidef (ssa_op_iter *ptr, tree phi, int flags)
1373 {
1374   tree phi_def = PHI_RESULT (phi);
1375   int comp;
1376
1377   clear_and_done_ssa_iter (ptr);
1378   ptr->done = false;
1379
1380   gcc_assert ((flags & (SSA_OP_DEF | SSA_OP_VIRTUAL_DEFS)) != 0);
1381
1382   comp = (is_gimple_reg (phi_def) ? SSA_OP_DEF : SSA_OP_VIRTUAL_DEFS);
1383     
1384   /* If the PHI node doesn't the operand type we care about, we're done.  */
1385   if ((flags & comp) == 0)
1386     {
1387       ptr->done = true;
1388       return NULL_USE_OPERAND_P;
1389     }
1390
1391   ptr->iter_type = ssa_op_iter_def;
1392   /* The first call to op_iter_next_def will terminate the iterator since
1393      all the fields are NULL.  Simply return the result here as the first and
1394      therefore only result.  */
1395   return PHI_RESULT_PTR (phi);
1396 }
1397
1398
1399
1400 /* Return true if VAR cannot be modified by the program.  */
1401
1402 static inline bool
1403 unmodifiable_var_p (tree var)
1404 {
1405   if (TREE_CODE (var) == SSA_NAME)
1406     var = SSA_NAME_VAR (var);
1407   return TREE_READONLY (var) && (TREE_STATIC (var) || DECL_EXTERNAL (var));
1408 }
1409
1410 /* Return true if REF, an ARRAY_REF, has an INDIRECT_REF somewhere in
1411    it.  */
1412
1413 static inline bool
1414 ref_contains_indirect_ref (tree ref)
1415 {
1416   while (handled_component_p (ref))
1417     {
1418       if (TREE_CODE (ref) == INDIRECT_REF)
1419         return true;
1420       ref = TREE_OPERAND (ref, 0);
1421     }
1422   return false;
1423 }
1424
1425 /* Return true if REF, a COMPONENT_REF, has an ARRAY_REF somewhere in it.  */
1426
1427 static inline bool
1428 ref_contains_array_ref (tree ref)
1429 {
1430   while (handled_component_p (ref))
1431     {
1432       if (TREE_CODE (ref) == ARRAY_REF)
1433         return true;
1434       ref = TREE_OPERAND (ref, 0);
1435     }
1436   return false;
1437 }
1438
1439 /* Given a variable VAR, lookup and return a pointer to the list of
1440    subvariables for it.  */
1441
1442 static inline subvar_t *
1443 lookup_subvars_for_var (tree var)
1444 {
1445   var_ann_t ann = var_ann (var);
1446   gcc_assert (ann);
1447   return &ann->subvars;
1448 }
1449
1450 /* Given a variable VAR, return a linked list of subvariables for VAR, or
1451    NULL, if there are no subvariables.  */
1452
1453 static inline subvar_t
1454 get_subvars_for_var (tree var)
1455 {
1456   subvar_t subvars;
1457
1458   gcc_assert (SSA_VAR_P (var));  
1459   
1460   if (TREE_CODE (var) == SSA_NAME)
1461     subvars = *(lookup_subvars_for_var (SSA_NAME_VAR (var)));
1462   else
1463     subvars = *(lookup_subvars_for_var (var));
1464   return subvars;
1465 }
1466
1467 /* Return the subvariable of VAR at offset OFFSET.  */
1468
1469 static inline tree
1470 get_subvar_at (tree var, unsigned HOST_WIDE_INT offset)
1471 {
1472   subvar_t sv;
1473
1474   for (sv = get_subvars_for_var (var); sv; sv = sv->next)
1475     if (sv->offset == offset)
1476       return sv->var;
1477
1478   return NULL_TREE;
1479 }
1480
1481 /* Return true if V is a tree that we can have subvars for.
1482    Normally, this is any aggregate type, however, due to implementation
1483    limitations ATM, we exclude array types as well.  */
1484
1485 static inline bool
1486 var_can_have_subvars (tree v)
1487 {
1488   return (AGGREGATE_TYPE_P (TREE_TYPE (v)) &&
1489           TREE_CODE (TREE_TYPE (v)) != ARRAY_TYPE);
1490 }
1491
1492   
1493 /* Return true if OFFSET and SIZE define a range that overlaps with some
1494    portion of the range of SV, a subvar.  If there was an exact overlap,
1495    *EXACT will be set to true upon return. */
1496
1497 static inline bool
1498 overlap_subvar (unsigned HOST_WIDE_INT offset, unsigned HOST_WIDE_INT size,
1499                 subvar_t sv,  bool *exact)
1500 {
1501   /* There are three possible cases of overlap.
1502      1. We can have an exact overlap, like so:   
1503      |offset, offset + size             |
1504      |sv->offset, sv->offset + sv->size |
1505      
1506      2. We can have offset starting after sv->offset, like so:
1507      
1508            |offset, offset + size              |
1509      |sv->offset, sv->offset + sv->size  |
1510
1511      3. We can have offset starting before sv->offset, like so:
1512      
1513      |offset, offset + size    |
1514        |sv->offset, sv->offset + sv->size|
1515   */
1516
1517   if (exact)
1518     *exact = false;
1519   if (offset == sv->offset && size == sv->size)
1520     {
1521       if (exact)
1522         *exact = true;
1523       return true;
1524     }
1525   else if (offset >= sv->offset && offset < (sv->offset + sv->size))
1526     {
1527       return true;
1528     }
1529   else if (offset < sv->offset && (size > sv->offset - offset))
1530     {
1531       return true;
1532     }
1533   return false;
1534
1535 }
1536
1537 #endif /* _TREE_FLOW_INLINE_H  */