OSDN Git Service

PR tree-optimization/22236
[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 last label in
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   /* Ensure that there are some labels.  The rationale is that we want
754      to insert after the bsi that is returned, and these insertions should
755      be placed at the start of the basic block.  This would not work if the
756      first statement was not label; rather fail here than enable the user
757      proceed in wrong way.  */
758   gcc_assert (TREE_CODE (tsi_stmt (bsi.tsi)) == LABEL_EXPR);
759
760   next = bsi.tsi;
761   tsi_next (&next);
762
763   while (!tsi_end_p (next)
764          && TREE_CODE (tsi_stmt (next)) == LABEL_EXPR)
765     {
766       bsi.tsi = next;
767       tsi_next (&next);
768     }
769
770   return bsi;
771 }
772
773 /* Return a block statement iterator that points to the end of basic
774    block BB.  */
775 static inline block_stmt_iterator
776 bsi_last (basic_block bb)
777 {
778   block_stmt_iterator bsi;
779   if (bb->stmt_list)
780     bsi.tsi = tsi_last (bb->stmt_list);
781   else
782     {
783       gcc_assert (bb->index < 0);
784       bsi.tsi.ptr = NULL;
785       bsi.tsi.container = NULL;
786     }
787   bsi.bb = bb;
788   return bsi;
789 }
790
791 /* Return true if block statement iterator I has reached the end of
792    the basic block.  */
793 static inline bool
794 bsi_end_p (block_stmt_iterator i)
795 {
796   return tsi_end_p (i.tsi);
797 }
798
799 /* Modify block statement iterator I so that it is at the next
800    statement in the basic block.  */
801 static inline void
802 bsi_next (block_stmt_iterator *i)
803 {
804   tsi_next (&i->tsi);
805 }
806
807 /* Modify block statement iterator I so that it is at the previous
808    statement in the basic block.  */
809 static inline void
810 bsi_prev (block_stmt_iterator *i)
811 {
812   tsi_prev (&i->tsi);
813 }
814
815 /* Return the statement that block statement iterator I is currently
816    at.  */
817 static inline tree
818 bsi_stmt (block_stmt_iterator i)
819 {
820   return tsi_stmt (i.tsi);
821 }
822
823 /* Return a pointer to the statement that block statement iterator I
824    is currently at.  */
825 static inline tree *
826 bsi_stmt_ptr (block_stmt_iterator i)
827 {
828   return tsi_stmt_ptr (i.tsi);
829 }
830
831 /* Returns the loop of the statement STMT.  */
832
833 static inline struct loop *
834 loop_containing_stmt (tree stmt)
835 {
836   basic_block bb = bb_for_stmt (stmt);
837   if (!bb)
838     return NULL;
839
840   return bb->loop_father;
841 }
842
843 /* Return true if VAR is a clobbered by function calls.  */
844 static inline bool
845 is_call_clobbered (tree var)
846 {
847   return is_global_var (var)
848     || bitmap_bit_p (call_clobbered_vars, DECL_UID (var));
849 }
850
851 /* Mark variable VAR as being clobbered by function calls.  */
852 static inline void
853 mark_call_clobbered (tree var)
854 {
855   var_ann_t ann = var_ann (var);
856   /* If VAR is a memory tag, then we need to consider it a global
857      variable.  This is because the pointer that VAR represents has
858      been found to point to either an arbitrary location or to a known
859      location in global memory.  */
860   if (ann->mem_tag_kind != NOT_A_TAG && ann->mem_tag_kind != STRUCT_FIELD)
861     DECL_EXTERNAL (var) = 1;
862   bitmap_set_bit (call_clobbered_vars, DECL_UID (var));
863   ssa_call_clobbered_cache_valid = false;
864   ssa_ro_call_cache_valid = false;
865 }
866
867 /* Clear the call-clobbered attribute from variable VAR.  */
868 static inline void
869 clear_call_clobbered (tree var)
870 {
871   var_ann_t ann = var_ann (var);
872   if (ann->mem_tag_kind != NOT_A_TAG && ann->mem_tag_kind != STRUCT_FIELD)
873     DECL_EXTERNAL (var) = 0;
874   bitmap_clear_bit (call_clobbered_vars, DECL_UID (var));
875   ssa_call_clobbered_cache_valid = false;
876   ssa_ro_call_cache_valid = false;
877 }
878
879 /* Mark variable VAR as being non-addressable.  */
880 static inline void
881 mark_non_addressable (tree var)
882 {
883   bitmap_clear_bit (call_clobbered_vars, DECL_UID (var));
884   TREE_ADDRESSABLE (var) = 0;
885   ssa_call_clobbered_cache_valid = false;
886   ssa_ro_call_cache_valid = false;
887 }
888
889 /* Return the common annotation for T.  Return NULL if the annotation
890    doesn't already exist.  */
891 static inline tree_ann_t
892 tree_ann (tree t)
893 {
894   return t->common.ann;
895 }
896
897 /* Return a common annotation for T.  Create the constant annotation if it
898    doesn't exist.  */
899 static inline tree_ann_t
900 get_tree_ann (tree t)
901 {
902   tree_ann_t ann = tree_ann (t);
903   return (ann) ? ann : create_tree_ann (t);
904 }
905
906 /*  -----------------------------------------------------------------------  */
907
908 /* The following set of routines are used to iterator over various type of
909    SSA operands.  */
910
911 /* Return true if PTR is finished iterating.  */
912 static inline bool
913 op_iter_done (ssa_op_iter *ptr)
914 {
915   return ptr->done;
916 }
917
918 /* Get the next iterator use value for PTR.  */
919 static inline use_operand_p
920 op_iter_next_use (ssa_op_iter *ptr)
921 {
922   use_operand_p use_p;
923 #ifdef ENABLE_CHECKING
924   gcc_assert (ptr->iter_type == ssa_op_iter_use);
925 #endif
926   if (ptr->uses)
927     {
928       use_p = USE_OP_PTR (ptr->uses);
929       ptr->uses = ptr->uses->next;
930       return use_p;
931     }
932   if (ptr->vuses)
933     {
934       use_p = VUSE_OP_PTR (ptr->vuses);
935       ptr->vuses = ptr->vuses->next;
936       return use_p;
937     }
938   if (ptr->mayuses)
939     {
940       use_p = MAYDEF_OP_PTR (ptr->mayuses);
941       ptr->mayuses = ptr->mayuses->next;
942       return use_p;
943     }
944   if (ptr->mustkills)
945     {
946       use_p = MUSTDEF_KILL_PTR (ptr->mustkills);
947       ptr->mustkills = ptr->mustkills->next;
948       return use_p;
949     }
950   if (ptr->phi_i < ptr->num_phi)
951     {
952       return PHI_ARG_DEF_PTR (ptr->phi_stmt, (ptr->phi_i)++);
953     }
954   ptr->done = true;
955   return NULL_USE_OPERAND_P;
956 }
957
958 /* Get the next iterator def value for PTR.  */
959 static inline def_operand_p
960 op_iter_next_def (ssa_op_iter *ptr)
961 {
962   def_operand_p def_p;
963 #ifdef ENABLE_CHECKING
964   gcc_assert (ptr->iter_type == ssa_op_iter_def);
965 #endif
966   if (ptr->defs)
967     {
968       def_p = DEF_OP_PTR (ptr->defs);
969       ptr->defs = ptr->defs->next;
970       return def_p;
971     }
972   if (ptr->mustdefs)
973     {
974       def_p = MUSTDEF_RESULT_PTR (ptr->mustdefs);
975       ptr->mustdefs = ptr->mustdefs->next;
976       return def_p;
977     }
978   if (ptr->maydefs)
979     {
980       def_p = MAYDEF_RESULT_PTR (ptr->maydefs);
981       ptr->maydefs = ptr->maydefs->next;
982       return def_p;
983     }
984   ptr->done = true;
985   return NULL_DEF_OPERAND_P;
986 }
987
988 /* Get the next iterator tree value for PTR.  */
989 static inline tree
990 op_iter_next_tree (ssa_op_iter *ptr)
991 {
992   tree val;
993 #ifdef ENABLE_CHECKING
994   gcc_assert (ptr->iter_type == ssa_op_iter_tree);
995 #endif
996   if (ptr->uses)
997     {
998       val = USE_OP (ptr->uses);
999       ptr->uses = ptr->uses->next;
1000       return val;
1001     }
1002   if (ptr->vuses)
1003     {
1004       val = VUSE_OP (ptr->vuses);
1005       ptr->vuses = ptr->vuses->next;
1006       return val;
1007     }
1008   if (ptr->mayuses)
1009     {
1010       val = MAYDEF_OP (ptr->mayuses);
1011       ptr->mayuses = ptr->mayuses->next;
1012       return val;
1013     }
1014   if (ptr->mustkills)
1015     {
1016       val = MUSTDEF_KILL (ptr->mustkills);
1017       ptr->mustkills = ptr->mustkills->next;
1018       return val;
1019     }
1020   if (ptr->defs)
1021     {
1022       val = DEF_OP (ptr->defs);
1023       ptr->defs = ptr->defs->next;
1024       return val;
1025     }
1026   if (ptr->mustdefs)
1027     {
1028       val = MUSTDEF_RESULT (ptr->mustdefs);
1029       ptr->mustdefs = ptr->mustdefs->next;
1030       return val;
1031     }
1032   if (ptr->maydefs)
1033     {
1034       val = MAYDEF_RESULT (ptr->maydefs);
1035       ptr->maydefs = ptr->maydefs->next;
1036       return val;
1037     }
1038
1039   ptr->done = true;
1040   return NULL_TREE;
1041
1042 }
1043
1044
1045 /* This functions clears the iterator PTR, and marks it done.  This is normally
1046    used to prevent warnings in the compile about might be uninitailzied
1047    components.  */
1048
1049 static inline void
1050 clear_and_done_ssa_iter (ssa_op_iter *ptr)
1051 {
1052   ptr->defs = NULL;
1053   ptr->uses = NULL;
1054   ptr->vuses = NULL;
1055   ptr->maydefs = NULL;
1056   ptr->mayuses = NULL;
1057   ptr->mustdefs = NULL;
1058   ptr->mustkills = NULL;
1059   ptr->iter_type = ssa_op_iter_none;
1060   ptr->phi_i = 0;
1061   ptr->num_phi = 0;
1062   ptr->phi_stmt = NULL_TREE;
1063   ptr->done = true;
1064 }
1065
1066 /* Initialize the iterator PTR to the virtual defs in STMT.  */
1067 static inline void
1068 op_iter_init (ssa_op_iter *ptr, tree stmt, int flags)
1069 {
1070 #ifdef ENABLE_CHECKING
1071   gcc_assert (stmt_ann (stmt));
1072 #endif
1073
1074   ptr->defs = (flags & SSA_OP_DEF) ? DEF_OPS (stmt) : NULL;
1075   ptr->uses = (flags & SSA_OP_USE) ? USE_OPS (stmt) : NULL;
1076   ptr->vuses = (flags & SSA_OP_VUSE) ? VUSE_OPS (stmt) : NULL;
1077   ptr->maydefs = (flags & SSA_OP_VMAYDEF) ? MAYDEF_OPS (stmt) : NULL;
1078   ptr->mayuses = (flags & SSA_OP_VMAYUSE) ? MAYDEF_OPS (stmt) : NULL;
1079   ptr->mustdefs = (flags & SSA_OP_VMUSTDEF) ? MUSTDEF_OPS (stmt) : NULL;
1080   ptr->mustkills = (flags & SSA_OP_VMUSTKILL) ? MUSTDEF_OPS (stmt) : NULL;
1081   ptr->done = false;
1082
1083   ptr->phi_i = 0;
1084   ptr->num_phi = 0;
1085   ptr->phi_stmt = NULL_TREE;
1086 }
1087
1088 /* Initialize iterator PTR to the use operands in STMT based on FLAGS. Return
1089    the first use.  */
1090 static inline use_operand_p
1091 op_iter_init_use (ssa_op_iter *ptr, tree stmt, int flags)
1092 {
1093   gcc_assert ((flags & SSA_OP_ALL_DEFS) == 0);
1094   op_iter_init (ptr, stmt, flags);
1095   ptr->iter_type = ssa_op_iter_use;
1096   return op_iter_next_use (ptr);
1097 }
1098
1099 /* Initialize iterator PTR to the def operands in STMT based on FLAGS. Return
1100    the first def.  */
1101 static inline def_operand_p
1102 op_iter_init_def (ssa_op_iter *ptr, tree stmt, int flags)
1103 {
1104   gcc_assert ((flags & (SSA_OP_ALL_USES | SSA_OP_VIRTUAL_KILLS)) == 0);
1105   op_iter_init (ptr, stmt, flags);
1106   ptr->iter_type = ssa_op_iter_def;
1107   return op_iter_next_def (ptr);
1108 }
1109
1110 /* Initialize iterator PTR to the operands in STMT based on FLAGS. Return
1111    the first operand as a tree.  */
1112 static inline tree
1113 op_iter_init_tree (ssa_op_iter *ptr, tree stmt, int flags)
1114 {
1115   op_iter_init (ptr, stmt, flags);
1116   ptr->iter_type = ssa_op_iter_tree;
1117   return op_iter_next_tree (ptr);
1118 }
1119
1120 /* Get the next iterator mustdef value for PTR, returning the mustdef values in
1121    KILL and DEF.  */
1122 static inline void
1123 op_iter_next_maymustdef (use_operand_p *use, def_operand_p *def, 
1124                          ssa_op_iter *ptr)
1125 {
1126 #ifdef ENABLE_CHECKING
1127   gcc_assert (ptr->iter_type == ssa_op_iter_maymustdef);
1128 #endif
1129   if (ptr->mayuses)
1130     {
1131       *def = MAYDEF_RESULT_PTR (ptr->mayuses);
1132       *use = MAYDEF_OP_PTR (ptr->mayuses);
1133       ptr->mayuses = ptr->mayuses->next;
1134       return;
1135     }
1136
1137   if (ptr->mustkills)
1138     {
1139       *def = MUSTDEF_RESULT_PTR (ptr->mustkills);
1140       *use = MUSTDEF_KILL_PTR (ptr->mustkills);
1141       ptr->mustkills = ptr->mustkills->next;
1142       return;
1143     }
1144
1145   *def = NULL_DEF_OPERAND_P;
1146   *use = NULL_USE_OPERAND_P;
1147   ptr->done = true;
1148   return;
1149 }
1150
1151
1152 /* Initialize iterator PTR to the operands in STMT.  Return the first operands
1153    in USE and DEF.  */
1154 static inline void
1155 op_iter_init_maydef (ssa_op_iter *ptr, tree stmt, use_operand_p *use, 
1156                      def_operand_p *def)
1157 {
1158   gcc_assert (TREE_CODE (stmt) != PHI_NODE);
1159
1160   op_iter_init (ptr, stmt, SSA_OP_VMAYUSE);
1161   ptr->iter_type = ssa_op_iter_maymustdef;
1162   op_iter_next_maymustdef (use, def, ptr);
1163 }
1164
1165
1166 /* Initialize iterator PTR to the operands in STMT.  Return the first operands
1167    in KILL and DEF.  */
1168 static inline void
1169 op_iter_init_mustdef (ssa_op_iter *ptr, tree stmt, use_operand_p *kill, 
1170                      def_operand_p *def)
1171 {
1172   gcc_assert (TREE_CODE (stmt) != PHI_NODE);
1173
1174   op_iter_init (ptr, stmt, SSA_OP_VMUSTKILL);
1175   ptr->iter_type = ssa_op_iter_maymustdef;
1176   op_iter_next_maymustdef (kill, def, ptr);
1177 }
1178
1179 /* Initialize iterator PTR to the operands in STMT.  Return the first operands
1180    in KILL and DEF.  */
1181 static inline void
1182 op_iter_init_must_and_may_def (ssa_op_iter *ptr, tree stmt,
1183                                use_operand_p *kill, def_operand_p *def)
1184 {
1185   gcc_assert (TREE_CODE (stmt) != PHI_NODE);
1186
1187   op_iter_init (ptr, stmt, SSA_OP_VMUSTKILL|SSA_OP_VMAYUSE);
1188   ptr->iter_type = ssa_op_iter_maymustdef;
1189   op_iter_next_maymustdef (kill, def, ptr);
1190 }
1191
1192
1193 /* If there is a single operand in STMT matching FLAGS, return it.  Otherwise
1194    return NULL.  */
1195 static inline tree
1196 single_ssa_tree_operand (tree stmt, int flags)
1197 {
1198   tree var;
1199   ssa_op_iter iter;
1200
1201   var = op_iter_init_tree (&iter, stmt, flags);
1202   if (op_iter_done (&iter))
1203     return NULL_TREE;
1204   op_iter_next_tree (&iter);
1205   if (op_iter_done (&iter))
1206     return var;
1207   return NULL_TREE;
1208 }
1209
1210
1211 /* If there is a single operand in STMT matching FLAGS, return it.  Otherwise
1212    return NULL.  */
1213 static inline use_operand_p
1214 single_ssa_use_operand (tree stmt, int flags)
1215 {
1216   use_operand_p var;
1217   ssa_op_iter iter;
1218
1219   var = op_iter_init_use (&iter, stmt, flags);
1220   if (op_iter_done (&iter))
1221     return NULL_USE_OPERAND_P;
1222   op_iter_next_use (&iter);
1223   if (op_iter_done (&iter))
1224     return var;
1225   return NULL_USE_OPERAND_P;
1226 }
1227
1228
1229
1230 /* If there is a single operand in STMT matching FLAGS, return it.  Otherwise
1231    return NULL.  */
1232 static inline def_operand_p
1233 single_ssa_def_operand (tree stmt, int flags)
1234 {
1235   def_operand_p var;
1236   ssa_op_iter iter;
1237
1238   var = op_iter_init_def (&iter, stmt, flags);
1239   if (op_iter_done (&iter))
1240     return NULL_DEF_OPERAND_P;
1241   op_iter_next_def (&iter);
1242   if (op_iter_done (&iter))
1243     return var;
1244   return NULL_DEF_OPERAND_P;
1245 }
1246
1247
1248 /* If there is a single operand in STMT matching FLAGS, return it.  Otherwise
1249    return NULL.  */
1250 static inline bool
1251 zero_ssa_operands (tree stmt, int flags)
1252 {
1253   ssa_op_iter iter;
1254
1255   op_iter_init_tree (&iter, stmt, flags);
1256   return op_iter_done (&iter);
1257 }
1258
1259
1260 /* Return the number of operands matching FLAGS in STMT.  */
1261 static inline int
1262 num_ssa_operands (tree stmt, int flags)
1263 {
1264   ssa_op_iter iter;
1265   tree t;
1266   int num = 0;
1267
1268   FOR_EACH_SSA_TREE_OPERAND (t, stmt, iter, flags)
1269     num++;
1270   return num;
1271 }
1272
1273
1274 /* Delink all immediate_use information for STMT.  */
1275 static inline void
1276 delink_stmt_imm_use (tree stmt)
1277 {
1278    ssa_op_iter iter;
1279    use_operand_p use_p;
1280
1281    if (ssa_operands_active ())
1282      FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter,
1283                                (SSA_OP_ALL_USES | SSA_OP_ALL_KILLS))
1284        delink_imm_use (use_p);
1285 }
1286
1287
1288 /* This routine will compare all the operands matching FLAGS in STMT1 to those
1289    in STMT2.  TRUE is returned if they are the same.  STMTs can be NULL.  */
1290 static inline bool
1291 compare_ssa_operands_equal (tree stmt1, tree stmt2, int flags)
1292 {
1293   ssa_op_iter iter1, iter2;
1294   tree op1 = NULL_TREE;
1295   tree op2 = NULL_TREE;
1296   bool look1, look2;
1297
1298   if (stmt1 == stmt2)
1299     return true;
1300
1301   look1 = stmt1 && stmt_ann (stmt1);
1302   look2 = stmt2 && stmt_ann (stmt2);
1303
1304   if (look1)
1305     {
1306       op1 = op_iter_init_tree (&iter1, stmt1, flags);
1307       if (!look2)
1308         return op_iter_done (&iter1);
1309     }
1310   else
1311     clear_and_done_ssa_iter (&iter1);
1312
1313   if (look2)
1314     {
1315       op2 = op_iter_init_tree (&iter2, stmt2, flags);
1316       if (!look1)
1317         return op_iter_done (&iter2);
1318     }
1319   else
1320     clear_and_done_ssa_iter (&iter2);
1321
1322   while (!op_iter_done (&iter1) && !op_iter_done (&iter2))
1323     {
1324       if (op1 != op2)
1325         return false;
1326       op1 = op_iter_next_tree (&iter1);
1327       op2 = op_iter_next_tree (&iter2);
1328     }
1329
1330   return (op_iter_done (&iter1) && op_iter_done (&iter2));
1331 }
1332
1333
1334 /* If there is a single DEF in the PHI node which matches FLAG, return it.
1335    Otherwise return NULL_DEF_OPERAND_P.  */
1336 static inline tree
1337 single_phi_def (tree stmt, int flags)
1338 {
1339   tree def = PHI_RESULT (stmt);
1340   if ((flags & SSA_OP_DEF) && is_gimple_reg (def)) 
1341     return def;
1342   if ((flags & SSA_OP_VIRTUAL_DEFS) && !is_gimple_reg (def))
1343     return def;
1344   return NULL_TREE;
1345 }
1346
1347 /* Initialize the iterator PTR for uses matching FLAGS in PHI.  FLAGS should
1348    be either SSA_OP_USES or SAS_OP_VIRTUAL_USES.  */
1349 static inline use_operand_p
1350 op_iter_init_phiuse (ssa_op_iter *ptr, tree phi, int flags)
1351 {
1352   tree phi_def = PHI_RESULT (phi);
1353   int comp;
1354
1355   clear_and_done_ssa_iter (ptr);
1356   ptr->done = false;
1357
1358   gcc_assert ((flags & (SSA_OP_USE | SSA_OP_VIRTUAL_USES)) != 0);
1359
1360   comp = (is_gimple_reg (phi_def) ? SSA_OP_USE : SSA_OP_VIRTUAL_USES);
1361     
1362   /* If the PHI node doesn't the operand type we care about, we're done.  */
1363   if ((flags & comp) == 0)
1364     {
1365       ptr->done = true;
1366       return NULL_USE_OPERAND_P;
1367     }
1368
1369   ptr->phi_stmt = phi;
1370   ptr->num_phi = PHI_NUM_ARGS (phi);
1371   ptr->iter_type = ssa_op_iter_use;
1372   return op_iter_next_use (ptr);
1373 }
1374
1375
1376 /* Start an iterator for a PHI definition.  */
1377
1378 static inline def_operand_p
1379 op_iter_init_phidef (ssa_op_iter *ptr, tree phi, int flags)
1380 {
1381   tree phi_def = PHI_RESULT (phi);
1382   int comp;
1383
1384   clear_and_done_ssa_iter (ptr);
1385   ptr->done = false;
1386
1387   gcc_assert ((flags & (SSA_OP_DEF | SSA_OP_VIRTUAL_DEFS)) != 0);
1388
1389   comp = (is_gimple_reg (phi_def) ? SSA_OP_DEF : SSA_OP_VIRTUAL_DEFS);
1390     
1391   /* If the PHI node doesn't the operand type we care about, we're done.  */
1392   if ((flags & comp) == 0)
1393     {
1394       ptr->done = true;
1395       return NULL_USE_OPERAND_P;
1396     }
1397
1398   ptr->iter_type = ssa_op_iter_def;
1399   /* The first call to op_iter_next_def will terminate the iterator since
1400      all the fields are NULL.  Simply return the result here as the first and
1401      therefore only result.  */
1402   return PHI_RESULT_PTR (phi);
1403 }
1404
1405
1406
1407 /* Return true if VAR cannot be modified by the program.  */
1408
1409 static inline bool
1410 unmodifiable_var_p (tree var)
1411 {
1412   if (TREE_CODE (var) == SSA_NAME)
1413     var = SSA_NAME_VAR (var);
1414   return TREE_READONLY (var) && (TREE_STATIC (var) || DECL_EXTERNAL (var));
1415 }
1416
1417 /* Return true if REF, a COMPONENT_REF, has an ARRAY_REF somewhere in it.  */
1418
1419 static inline bool
1420 ref_contains_array_ref (tree ref)
1421 {
1422   while (handled_component_p (ref))
1423     {
1424       if (TREE_CODE (ref) == ARRAY_REF)
1425         return true;
1426       ref = TREE_OPERAND (ref, 0);
1427     }
1428   return false;
1429 }
1430
1431 /* Given a variable VAR, lookup and return a pointer to the list of
1432    subvariables for it.  */
1433
1434 static inline subvar_t *
1435 lookup_subvars_for_var (tree var)
1436 {
1437   var_ann_t ann = var_ann (var);
1438   gcc_assert (ann);
1439   return &ann->subvars;
1440 }
1441
1442 /* Given a variable VAR, return a linked list of subvariables for VAR, or
1443    NULL, if there are no subvariables.  */
1444
1445 static inline subvar_t
1446 get_subvars_for_var (tree var)
1447 {
1448   subvar_t subvars;
1449
1450   gcc_assert (SSA_VAR_P (var));  
1451   
1452   if (TREE_CODE (var) == SSA_NAME)
1453     subvars = *(lookup_subvars_for_var (SSA_NAME_VAR (var)));
1454   else
1455     subvars = *(lookup_subvars_for_var (var));
1456   return subvars;
1457 }
1458
1459 /* Return the subvariable of VAR at offset OFFSET.  */
1460
1461 static inline tree
1462 get_subvar_at (tree var, unsigned HOST_WIDE_INT offset)
1463 {
1464   subvar_t sv;
1465
1466   for (sv = get_subvars_for_var (var); sv; sv = sv->next)
1467     if (sv->offset == offset)
1468       return sv->var;
1469
1470   return NULL_TREE;
1471 }
1472
1473 /* Return true if V is a tree that we can have subvars for.
1474    Normally, this is any aggregate type, however, due to implementation
1475    limitations ATM, we exclude array types as well.  */
1476
1477 static inline bool
1478 var_can_have_subvars (tree v)
1479 {
1480   return (AGGREGATE_TYPE_P (TREE_TYPE (v)) &&
1481           TREE_CODE (TREE_TYPE (v)) != ARRAY_TYPE);
1482 }
1483
1484   
1485 /* Return true if OFFSET and SIZE define a range that overlaps with some
1486    portion of the range of SV, a subvar.  If there was an exact overlap,
1487    *EXACT will be set to true upon return. */
1488
1489 static inline bool
1490 overlap_subvar (unsigned HOST_WIDE_INT offset, unsigned HOST_WIDE_INT size,
1491                 subvar_t sv,  bool *exact)
1492 {
1493   /* There are three possible cases of overlap.
1494      1. We can have an exact overlap, like so:   
1495      |offset, offset + size             |
1496      |sv->offset, sv->offset + sv->size |
1497      
1498      2. We can have offset starting after sv->offset, like so:
1499      
1500            |offset, offset + size              |
1501      |sv->offset, sv->offset + sv->size  |
1502
1503      3. We can have offset starting before sv->offset, like so:
1504      
1505      |offset, offset + size    |
1506        |sv->offset, sv->offset + sv->size|
1507   */
1508
1509   if (exact)
1510     *exact = false;
1511   if (offset == sv->offset && size == sv->size)
1512     {
1513       if (exact)
1514         *exact = true;
1515       return true;
1516     }
1517   else if (offset >= sv->offset && offset < (sv->offset + sv->size))
1518     {
1519       return true;
1520     }
1521   else if (offset < sv->offset && (size > sv->offset - offset))
1522     {
1523       return true;
1524     }
1525   return false;
1526
1527 }
1528
1529 #endif /* _TREE_FLOW_INLINE_H  */