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>
5 This file is part of GCC.
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)
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.
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. */
22 #ifndef _TREE_FLOW_INLINE_H
23 #define _TREE_FLOW_INLINE_H 1
25 /* Inline functions for manipulating various data structures defined in
26 tree-flow.h. See tree-flow.h for documentation. */
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
34 gcc_assert (DECL_P (t));
35 gcc_assert (!t->common.ann || t->common.ann->common.type == VAR_ANN);
37 return (var_ann_t) t->common.ann;
40 /* Return the variable annotation for T, which must be a _DECL node.
41 Create the variable annotation if it doesn't exist. */
42 static inline var_ann_t
43 get_var_ann (tree var)
45 var_ann_t ann = var_ann (var);
46 return (ann) ? ann : create_var_ann (var);
49 /* Return the statement annotation for T, which must be a statement
50 node. Return NULL if the statement annotation doesn't exist. */
51 static inline stmt_ann_t
54 #ifdef ENABLE_CHECKING
55 gcc_assert (is_gimple_stmt (t));
57 return (stmt_ann_t) t->common.ann;
60 /* Return the statement annotation for T, which must be a statement
61 node. Create the statement annotation if it doesn't exist. */
62 static inline stmt_ann_t
63 get_stmt_ann (tree stmt)
65 stmt_ann_t ann = stmt_ann (stmt);
66 return (ann) ? ann : create_stmt_ann (stmt);
70 /* Return the annotation type for annotation ANN. */
71 static inline enum tree_ann_type
72 ann_type (tree_ann_t ann)
74 return ann->common.type;
77 /* Return the basic block for statement T. */
78 static inline basic_block
83 if (TREE_CODE (t) == PHI_NODE)
87 return ann ? ann->bb : NULL;
90 /* Return the may_aliases varray for variable VAR, or NULL if it has
92 static inline varray_type
93 may_aliases (tree var)
95 var_ann_t ann = var_ann (var);
96 return ann ? ann->may_aliases : NULL;
99 /* Return the line number for EXPR, or return -1 if we have no line
100 number information for it. */
102 get_lineno (tree expr)
104 if (expr == NULL_TREE)
107 if (TREE_CODE (expr) == COMPOUND_EXPR)
108 expr = TREE_OPERAND (expr, 0);
110 if (! EXPR_HAS_LOCATION (expr))
113 return EXPR_LINENO (expr);
116 /* Return the file name for EXPR, or return "???" if we have no
117 filename information. */
118 static inline const char *
119 get_filename (tree expr)
121 const char *filename;
122 if (expr == NULL_TREE)
125 if (TREE_CODE (expr) == COMPOUND_EXPR)
126 expr = TREE_OPERAND (expr, 0);
128 if (EXPR_HAS_LOCATION (expr) && (filename = EXPR_FILENAME (expr)))
134 /* Return true if T is a noreturn call. */
136 noreturn_call_p (tree t)
138 tree call = get_call_expr_in (t);
139 return call != 0 && (call_expr_flags (call) & ECF_NORETURN) != 0;
142 /* Mark statement T as modified. */
144 mark_stmt_modified (tree t)
147 if (TREE_CODE (t) == PHI_NODE)
152 ann = create_stmt_ann (t);
153 else if (noreturn_call_p (t))
154 VEC_safe_push (tree, gc, modified_noreturn_calls, t);
158 /* Mark statement T as modified, and update it. */
162 if (TREE_CODE (t) == PHI_NODE)
164 mark_stmt_modified (t);
165 update_stmt_operands (t);
169 update_stmt_if_modified (tree t)
171 if (stmt_modified_p (t))
172 update_stmt_operands (t);
175 /* Return true if T is marked as modified, false otherwise. */
177 stmt_modified_p (tree t)
179 stmt_ann_t ann = stmt_ann (t);
181 /* Note that if the statement doesn't yet have an annotation, we consider it
182 modified. This will force the next call to update_stmt_operands to scan
184 return ann ? ann->modified : true;
187 /* Delink an immediate_uses node from its chain. */
189 delink_imm_use (ssa_use_operand_t *linknode)
191 /* Return if this node is not in a list. */
192 if (linknode->prev == NULL)
195 linknode->prev->next = linknode->next;
196 linknode->next->prev = linknode->prev;
197 linknode->prev = NULL;
198 linknode->next = NULL;
201 /* Link ssa_imm_use node LINKNODE into the chain for LIST. */
203 link_imm_use_to_list (ssa_use_operand_t *linknode, ssa_use_operand_t *list)
205 /* Link the new node at the head of the list. If we are in the process of
206 traversing the list, we won't visit any new nodes added to it. */
207 linknode->prev = list;
208 linknode->next = list->next;
209 list->next->prev = linknode;
210 list->next = linknode;
213 /* Link ssa_imm_use node LINKNODE into the chain for DEF. */
215 link_imm_use (ssa_use_operand_t *linknode, tree def)
217 ssa_use_operand_t *root;
219 if (!def || TREE_CODE (def) != SSA_NAME)
220 linknode->prev = NULL;
223 root = &(SSA_NAME_IMM_USE_NODE (def));
224 #ifdef ENABLE_CHECKING
226 gcc_assert (*(linknode->use) == def);
228 link_imm_use_to_list (linknode, root);
232 /* Set the value of a use pointed by USE to VAL. */
234 set_ssa_use_from_ptr (use_operand_p use, tree val)
236 delink_imm_use (use);
238 link_imm_use (use, val);
241 /* Link ssa_imm_use node LINKNODE into the chain for DEF, with use occuring
244 link_imm_use_stmt (ssa_use_operand_t *linknode, tree def, tree stmt)
247 link_imm_use (linknode, def);
249 link_imm_use (linknode, NULL);
250 linknode->stmt = stmt;
253 /* Relink a new node in place of an old node in the list. */
255 relink_imm_use (ssa_use_operand_t *node, ssa_use_operand_t *old)
257 /* The node one had better be in the same list. */
258 gcc_assert (*(old->use) == *(node->use));
259 node->prev = old->prev;
260 node->next = old->next;
263 old->prev->next = node;
264 old->next->prev = node;
265 /* Remove the old node from the list. */
270 /* Relink ssa_imm_use node LINKNODE into the chain for OLD, with use occuring
273 relink_imm_use_stmt (ssa_use_operand_t *linknode, ssa_use_operand_t *old, tree stmt)
276 relink_imm_use (linknode, old);
278 link_imm_use (linknode, NULL);
279 linknode->stmt = stmt;
282 /* Finished the traverse of an immediate use list IMM by removing it from
285 end_safe_imm_use_traverse (imm_use_iterator *imm)
287 delink_imm_use (&(imm->iter_node));
290 /* Return true if IMM is at the end of the list. */
292 end_safe_imm_use_p (imm_use_iterator *imm)
294 return (imm->imm_use == imm->end_p);
297 /* Initialize iterator IMM to process the list for VAR. */
298 static inline use_operand_p
299 first_safe_imm_use (imm_use_iterator *imm, tree var)
301 /* Set up and link the iterator node into the linked list for VAR. */
302 imm->iter_node.use = NULL;
303 imm->iter_node.stmt = NULL_TREE;
304 imm->end_p = &(SSA_NAME_IMM_USE_NODE (var));
305 /* Check if there are 0 elements. */
306 if (imm->end_p->next == imm->end_p)
308 imm->imm_use = imm->end_p;
309 return NULL_USE_OPERAND_P;
312 link_imm_use (&(imm->iter_node), var);
313 imm->imm_use = imm->iter_node.next;
317 /* Bump IMM to the next use in the list. */
318 static inline use_operand_p
319 next_safe_imm_use (imm_use_iterator *imm)
321 ssa_use_operand_t *ptr;
325 /* If the next node following the iter_node is still the one referred to by
326 imm_use, then the list hasn't changed, go to the next node. */
327 if (imm->iter_node.next == imm->imm_use)
329 ptr = &(imm->iter_node);
330 /* Remove iternode from the list. */
331 delink_imm_use (ptr);
332 imm->imm_use = imm->imm_use->next;
333 if (! end_safe_imm_use_p (imm))
335 /* This isn't the end, link iternode before the next use. */
336 ptr->prev = imm->imm_use->prev;
337 ptr->next = imm->imm_use;
338 imm->imm_use->prev->next = ptr;
339 imm->imm_use->prev = ptr;
346 /* If the 'next' value after the iterator isn't the same as it was, then
347 a node has been deleted, so we simply proceed to the node following
348 where the iterator is in the list. */
349 imm->imm_use = imm->iter_node.next;
350 if (end_safe_imm_use_p (imm))
352 end_safe_imm_use_traverse (imm);
360 /* Return true is IMM has reached the end of the immediate use list. */
362 end_readonly_imm_use_p (imm_use_iterator *imm)
364 return (imm->imm_use == imm->end_p);
367 /* Initialize iterator IMM to process the list for VAR. */
368 static inline use_operand_p
369 first_readonly_imm_use (imm_use_iterator *imm, tree var)
371 gcc_assert (TREE_CODE (var) == SSA_NAME);
373 imm->end_p = &(SSA_NAME_IMM_USE_NODE (var));
374 imm->imm_use = imm->end_p->next;
375 #ifdef ENABLE_CHECKING
376 imm->iter_node.next = imm->imm_use->next;
378 if (end_readonly_imm_use_p (imm))
379 return NULL_USE_OPERAND_P;
383 /* Bump IMM to the next use in the list. */
384 static inline use_operand_p
385 next_readonly_imm_use (imm_use_iterator *imm)
387 use_operand_p old = imm->imm_use;
389 #ifdef ENABLE_CHECKING
390 /* If this assertion fails, it indicates the 'next' pointer has changed
391 since we the last bump. This indicates that the list is being modified
392 via stmt changes, or SET_USE, or somesuch thing, and you need to be
393 using the SAFE version of the iterator. */
394 gcc_assert (imm->iter_node.next == old->next);
395 imm->iter_node.next = old->next->next;
398 imm->imm_use = old->next;
399 if (end_readonly_imm_use_p (imm))
404 /* Return true if VAR has no uses. */
406 has_zero_uses (tree var)
408 ssa_use_operand_t *ptr;
409 ptr = &(SSA_NAME_IMM_USE_NODE (var));
410 /* A single use means there is no items in the list. */
411 return (ptr == ptr->next);
414 /* Return true if VAR has a single use. */
416 has_single_use (tree var)
418 ssa_use_operand_t *ptr;
419 ptr = &(SSA_NAME_IMM_USE_NODE (var));
420 /* A single use means there is one item in the list. */
421 return (ptr != ptr->next && ptr == ptr->next->next);
424 /* If VAR has only a single immediate use, return true, and set USE_P and STMT
425 to the use pointer and stmt of occurrence. */
427 single_imm_use (tree var, use_operand_p *use_p, tree *stmt)
429 ssa_use_operand_t *ptr;
431 ptr = &(SSA_NAME_IMM_USE_NODE (var));
432 if (ptr != ptr->next && ptr == ptr->next->next)
435 *stmt = ptr->next->stmt;
438 *use_p = NULL_USE_OPERAND_P;
443 /* Return the number of immediate uses of VAR. */
444 static inline unsigned int
445 num_imm_uses (tree var)
447 ssa_use_operand_t *ptr, *start;
450 start = &(SSA_NAME_IMM_USE_NODE (var));
452 for (ptr = start->next; ptr != start; ptr = ptr->next)
459 /* Return the tree pointer to by USE. */
461 get_use_from_ptr (use_operand_p use)
466 /* Return the tree pointer to by DEF. */
468 get_def_from_ptr (def_operand_p def)
473 /* Return a def_operand_p pointer for the result of PHI. */
474 static inline def_operand_p
475 get_phi_result_ptr (tree phi)
477 return &(PHI_RESULT_TREE (phi));
480 /* Return a use_operand_p pointer for argument I of phinode PHI. */
481 static inline use_operand_p
482 get_phi_arg_def_ptr (tree phi, int i)
484 return &(PHI_ARG_IMM_USE_NODE (phi,i));
488 /* Return the bitmap of addresses taken by STMT, or NULL if it takes
491 addresses_taken (tree stmt)
493 stmt_ann_t ann = stmt_ann (stmt);
494 return ann ? ann->addresses_taken : NULL;
497 /* Return the basic_block annotation for BB. */
498 static inline bb_ann_t
499 bb_ann (basic_block bb)
501 return (bb_ann_t)bb->tree_annotations;
504 /* Return the PHI nodes for basic block BB, or NULL if there are no
507 phi_nodes (basic_block bb)
509 return bb_ann (bb)->phi_nodes;
512 /* Set list of phi nodes of a basic block BB to L. */
515 set_phi_nodes (basic_block bb, tree l)
519 bb_ann (bb)->phi_nodes = l;
520 for (phi = l; phi; phi = PHI_CHAIN (phi))
521 set_bb_for_stmt (phi, bb);
524 /* Return the phi argument which contains the specified use. */
527 phi_arg_index_from_use (use_operand_p use)
529 struct phi_arg_d *element, *root;
533 /* Since the use is the first thing in a PHI argument element, we can
534 calculate its index based on casting it to an argument, and performing
535 pointer arithmetic. */
537 phi = USE_STMT (use);
538 gcc_assert (TREE_CODE (phi) == PHI_NODE);
540 element = (struct phi_arg_d *)use;
541 root = &(PHI_ARG_ELT (phi, 0));
542 index = element - root;
544 #ifdef ENABLE_CHECKING
545 /* Make sure the calculation doesn't have any leftover bytes. If it does,
546 then imm_use is likely not the first element in phi_arg_d. */
548 (((char *)element - (char *)root) % sizeof (struct phi_arg_d)) == 0);
549 gcc_assert (index >= 0 && index < PHI_ARG_CAPACITY (phi));
555 /* Mark VAR as used, so that it'll be preserved during rtl expansion. */
558 set_is_used (tree var)
560 var_ann_t ann = get_var_ann (var);
565 /* ----------------------------------------------------------------------- */
567 /* Return true if T is an executable statement. */
569 is_exec_stmt (tree t)
571 return (t && !IS_EMPTY_STMT (t) && t != error_mark_node);
575 /* Return true if this stmt can be the target of a control transfer stmt such
578 is_label_stmt (tree t)
581 switch (TREE_CODE (t))
585 case CASE_LABEL_EXPR:
593 /* Set the default definition for VAR to DEF. */
595 set_default_def (tree var, tree def)
597 var_ann_t ann = get_var_ann (var);
598 ann->default_def = def;
601 /* Return the default definition for variable VAR, or NULL if none
604 default_def (tree var)
606 var_ann_t ann = var_ann (var);
607 return ann ? ann->default_def : NULL_TREE;
610 /* PHI nodes should contain only ssa_names and invariants. A test
611 for ssa_name is definitely simpler; don't let invalid contents
612 slip in in the meantime. */
615 phi_ssa_name_p (tree t)
617 if (TREE_CODE (t) == SSA_NAME)
619 #ifdef ENABLE_CHECKING
620 gcc_assert (is_gimple_min_invariant (t));
625 /* ----------------------------------------------------------------------- */
627 /* Return a block_stmt_iterator that points to beginning of basic
629 static inline block_stmt_iterator
630 bsi_start (basic_block bb)
632 block_stmt_iterator bsi;
634 bsi.tsi = tsi_start (bb->stmt_list);
637 gcc_assert (bb->index < 0);
639 bsi.tsi.container = NULL;
645 /* Return a block statement iterator that points to the last label in
648 static inline block_stmt_iterator
649 bsi_after_labels (basic_block bb)
651 block_stmt_iterator bsi;
652 tree_stmt_iterator next;
658 gcc_assert (bb->index < 0);
660 bsi.tsi.container = NULL;
664 bsi.tsi = tsi_start (bb->stmt_list);
665 if (tsi_end_p (bsi.tsi))
668 /* Ensure that there are some labels. The rationale is that we want
669 to insert after the bsi that is returned, and these insertions should
670 be placed at the start of the basic block. This would not work if the
671 first statement was not label; rather fail here than enable the user
672 proceed in wrong way. */
673 gcc_assert (TREE_CODE (tsi_stmt (bsi.tsi)) == LABEL_EXPR);
678 while (!tsi_end_p (next)
679 && TREE_CODE (tsi_stmt (next)) == LABEL_EXPR)
688 /* Return a block statement iterator that points to the end of basic
690 static inline block_stmt_iterator
691 bsi_last (basic_block bb)
693 block_stmt_iterator bsi;
695 bsi.tsi = tsi_last (bb->stmt_list);
698 gcc_assert (bb->index < 0);
700 bsi.tsi.container = NULL;
706 /* Return true if block statement iterator I has reached the end of
709 bsi_end_p (block_stmt_iterator i)
711 return tsi_end_p (i.tsi);
714 /* Modify block statement iterator I so that it is at the next
715 statement in the basic block. */
717 bsi_next (block_stmt_iterator *i)
722 /* Modify block statement iterator I so that it is at the previous
723 statement in the basic block. */
725 bsi_prev (block_stmt_iterator *i)
730 /* Return the statement that block statement iterator I is currently
733 bsi_stmt (block_stmt_iterator i)
735 return tsi_stmt (i.tsi);
738 /* Return a pointer to the statement that block statement iterator I
741 bsi_stmt_ptr (block_stmt_iterator i)
743 return tsi_stmt_ptr (i.tsi);
746 /* Returns the loop of the statement STMT. */
748 static inline struct loop *
749 loop_containing_stmt (tree stmt)
751 basic_block bb = bb_for_stmt (stmt);
755 return bb->loop_father;
758 /* Return true if VAR is a clobbered by function calls. */
760 is_call_clobbered (tree var)
762 return is_global_var (var)
763 || bitmap_bit_p (call_clobbered_vars, var_ann (var)->uid);
766 /* Mark variable VAR as being clobbered by function calls. */
768 mark_call_clobbered (tree var)
770 var_ann_t ann = var_ann (var);
771 /* If VAR is a memory tag, then we need to consider it a global
772 variable. This is because the pointer that VAR represents has
773 been found to point to either an arbitrary location or to a known
774 location in global memory. */
775 if (ann->mem_tag_kind != NOT_A_TAG && ann->mem_tag_kind != STRUCT_FIELD)
776 DECL_EXTERNAL (var) = 1;
777 bitmap_set_bit (call_clobbered_vars, ann->uid);
778 ssa_call_clobbered_cache_valid = false;
779 ssa_ro_call_cache_valid = false;
782 /* Clear the call-clobbered attribute from variable VAR. */
784 clear_call_clobbered (tree var)
786 var_ann_t ann = var_ann (var);
787 if (ann->mem_tag_kind != NOT_A_TAG && ann->mem_tag_kind != STRUCT_FIELD)
788 DECL_EXTERNAL (var) = 0;
789 bitmap_clear_bit (call_clobbered_vars, ann->uid);
790 ssa_call_clobbered_cache_valid = false;
791 ssa_ro_call_cache_valid = false;
794 /* Mark variable VAR as being non-addressable. */
796 mark_non_addressable (tree var)
798 bitmap_clear_bit (call_clobbered_vars, var_ann (var)->uid);
799 TREE_ADDRESSABLE (var) = 0;
800 ssa_call_clobbered_cache_valid = false;
801 ssa_ro_call_cache_valid = false;
804 /* Return the common annotation for T. Return NULL if the annotation
805 doesn't already exist. */
806 static inline tree_ann_t
809 return t->common.ann;
812 /* Return a common annotation for T. Create the constant annotation if it
814 static inline tree_ann_t
815 get_tree_ann (tree t)
817 tree_ann_t ann = tree_ann (t);
818 return (ann) ? ann : create_tree_ann (t);
821 /* ----------------------------------------------------------------------- */
823 /* The following set of routines are used to iterator over various type of
826 /* Return true if PTR is finished iterating. */
828 op_iter_done (ssa_op_iter *ptr)
833 /* Get the next iterator use value for PTR. */
834 static inline use_operand_p
835 op_iter_next_use (ssa_op_iter *ptr)
838 #ifdef ENABLE_CHECKING
839 gcc_assert (ptr->iter_type == ssa_op_iter_use);
843 use_p = USE_OP_PTR (ptr->uses);
844 ptr->uses = ptr->uses->next;
849 use_p = VUSE_OP_PTR (ptr->vuses);
850 ptr->vuses = ptr->vuses->next;
855 use_p = MAYDEF_OP_PTR (ptr->mayuses);
856 ptr->mayuses = ptr->mayuses->next;
861 use_p = MUSTDEF_KILL_PTR (ptr->mustkills);
862 ptr->mustkills = ptr->mustkills->next;
865 if (ptr->phi_i < ptr->num_phi)
867 return PHI_ARG_DEF_PTR (ptr->phi_stmt, (ptr->phi_i)++);
870 return NULL_USE_OPERAND_P;
873 /* Get the next iterator def value for PTR. */
874 static inline def_operand_p
875 op_iter_next_def (ssa_op_iter *ptr)
878 #ifdef ENABLE_CHECKING
879 gcc_assert (ptr->iter_type == ssa_op_iter_def);
883 def_p = DEF_OP_PTR (ptr->defs);
884 ptr->defs = ptr->defs->next;
889 def_p = MUSTDEF_RESULT_PTR (ptr->mustdefs);
890 ptr->mustdefs = ptr->mustdefs->next;
895 def_p = MAYDEF_RESULT_PTR (ptr->maydefs);
896 ptr->maydefs = ptr->maydefs->next;
900 return NULL_DEF_OPERAND_P;
903 /* Get the next iterator tree value for PTR. */
905 op_iter_next_tree (ssa_op_iter *ptr)
908 #ifdef ENABLE_CHECKING
909 gcc_assert (ptr->iter_type == ssa_op_iter_tree);
913 val = USE_OP (ptr->uses);
914 ptr->uses = ptr->uses->next;
919 val = VUSE_OP (ptr->vuses);
920 ptr->vuses = ptr->vuses->next;
925 val = MAYDEF_OP (ptr->mayuses);
926 ptr->mayuses = ptr->mayuses->next;
931 val = MUSTDEF_KILL (ptr->mustkills);
932 ptr->mustkills = ptr->mustkills->next;
937 val = DEF_OP (ptr->defs);
938 ptr->defs = ptr->defs->next;
943 val = MUSTDEF_RESULT (ptr->mustdefs);
944 ptr->mustdefs = ptr->mustdefs->next;
949 val = MAYDEF_RESULT (ptr->maydefs);
950 ptr->maydefs = ptr->maydefs->next;
960 /* This functiins clears the iterator PTR, and marks it done. This is normally
961 used to prevent warnings in the compile about might be uninitailzied
965 clear_and_done_ssa_iter (ssa_op_iter *ptr)
972 ptr->mustdefs = NULL;
973 ptr->mustkills = NULL;
974 ptr->iter_type = ssa_op_iter_none;
977 ptr->phi_stmt = NULL_TREE;
981 /* Initialize the iterator PTR to the virtual defs in STMT. */
983 op_iter_init (ssa_op_iter *ptr, tree stmt, int flags)
985 #ifdef ENABLE_CHECKING
986 gcc_assert (stmt_ann (stmt));
989 ptr->defs = (flags & SSA_OP_DEF) ? DEF_OPS (stmt) : NULL;
990 ptr->uses = (flags & SSA_OP_USE) ? USE_OPS (stmt) : NULL;
991 ptr->vuses = (flags & SSA_OP_VUSE) ? VUSE_OPS (stmt) : NULL;
992 ptr->maydefs = (flags & SSA_OP_VMAYDEF) ? MAYDEF_OPS (stmt) : NULL;
993 ptr->mayuses = (flags & SSA_OP_VMAYUSE) ? MAYDEF_OPS (stmt) : NULL;
994 ptr->mustdefs = (flags & SSA_OP_VMUSTDEF) ? MUSTDEF_OPS (stmt) : NULL;
995 ptr->mustkills = (flags & SSA_OP_VMUSTKILL) ? MUSTDEF_OPS (stmt) : NULL;
1000 ptr->phi_stmt = NULL_TREE;
1003 /* Initialize iterator PTR to the use operands in STMT based on FLAGS. Return
1005 static inline use_operand_p
1006 op_iter_init_use (ssa_op_iter *ptr, tree stmt, int flags)
1008 op_iter_init (ptr, stmt, flags);
1009 ptr->iter_type = ssa_op_iter_use;
1010 return op_iter_next_use (ptr);
1013 /* Initialize iterator PTR to the def operands in STMT based on FLAGS. Return
1015 static inline def_operand_p
1016 op_iter_init_def (ssa_op_iter *ptr, tree stmt, int flags)
1018 op_iter_init (ptr, stmt, flags);
1019 ptr->iter_type = ssa_op_iter_def;
1020 return op_iter_next_def (ptr);
1023 /* Initialize iterator PTR to the operands in STMT based on FLAGS. Return
1024 the first operand as a tree. */
1026 op_iter_init_tree (ssa_op_iter *ptr, tree stmt, int flags)
1028 op_iter_init (ptr, stmt, flags);
1029 ptr->iter_type = ssa_op_iter_tree;
1030 return op_iter_next_tree (ptr);
1033 /* Get the next iterator mustdef value for PTR, returning the mustdef values in
1036 op_iter_next_maymustdef (use_operand_p *use, def_operand_p *def,
1039 #ifdef ENABLE_CHECKING
1040 gcc_assert (ptr->iter_type == ssa_op_iter_maymustdef);
1044 *def = MAYDEF_RESULT_PTR (ptr->mayuses);
1045 *use = MAYDEF_OP_PTR (ptr->mayuses);
1046 ptr->mayuses = ptr->mayuses->next;
1052 *def = MUSTDEF_RESULT_PTR (ptr->mustkills);
1053 *use = MUSTDEF_KILL_PTR (ptr->mustkills);
1054 ptr->mustkills = ptr->mustkills->next;
1058 *def = NULL_DEF_OPERAND_P;
1059 *use = NULL_USE_OPERAND_P;
1065 /* Initialize iterator PTR to the operands in STMT. Return the first operands
1068 op_iter_init_maydef (ssa_op_iter *ptr, tree stmt, use_operand_p *use,
1071 gcc_assert (TREE_CODE (stmt) != PHI_NODE);
1073 op_iter_init (ptr, stmt, SSA_OP_VMAYUSE);
1074 ptr->iter_type = ssa_op_iter_maymustdef;
1075 op_iter_next_maymustdef (use, def, ptr);
1079 /* Initialize iterator PTR to the operands in STMT. Return the first operands
1082 op_iter_init_mustdef (ssa_op_iter *ptr, tree stmt, use_operand_p *kill,
1085 gcc_assert (TREE_CODE (stmt) != PHI_NODE);
1087 op_iter_init (ptr, stmt, SSA_OP_VMUSTKILL);
1088 ptr->iter_type = ssa_op_iter_maymustdef;
1089 op_iter_next_maymustdef (kill, def, ptr);
1092 /* Initialize iterator PTR to the operands in STMT. Return the first operands
1095 op_iter_init_must_and_may_def (ssa_op_iter *ptr, tree stmt,
1096 use_operand_p *kill, def_operand_p *def)
1098 gcc_assert (TREE_CODE (stmt) != PHI_NODE);
1100 op_iter_init (ptr, stmt, SSA_OP_VMUSTKILL|SSA_OP_VMAYUSE);
1101 ptr->iter_type = ssa_op_iter_maymustdef;
1102 op_iter_next_maymustdef (kill, def, ptr);
1106 /* If there is a single opernad in STMT matching FLAGS, return it. Otherwise
1107 return NULL. PTR is the iterator to use. */
1109 single_ssa_tree_operand (tree stmt, int flags)
1114 var = op_iter_init_tree (&iter, stmt, flags);
1115 if (op_iter_done (&iter))
1117 op_iter_next_tree (&iter);
1118 if (op_iter_done (&iter))
1124 /* If there is a single opernad in STMT matching FLAGS, return it. Otherwise
1125 return NULL. PTR is the iterator to use. */
1126 static inline use_operand_p
1127 single_ssa_use_operand (tree stmt, int flags)
1132 var = op_iter_init_use (&iter, stmt, flags);
1133 if (op_iter_done (&iter))
1134 return NULL_USE_OPERAND_P;
1135 op_iter_next_use (&iter);
1136 if (op_iter_done (&iter))
1138 return NULL_USE_OPERAND_P;
1143 /* If there is a single opernad in STMT matching FLAGS, return it. Otherwise
1144 return NULL. PTR is the iterator to use. */
1145 static inline def_operand_p
1146 single_ssa_def_operand (tree stmt, int flags)
1151 var = op_iter_init_def (&iter, stmt, flags);
1152 if (op_iter_done (&iter))
1153 return NULL_DEF_OPERAND_P;
1154 op_iter_next_def (&iter);
1155 if (op_iter_done (&iter))
1157 return NULL_DEF_OPERAND_P;
1161 /* If there is a single opernad in STMT matching FLAGS, return it. Otherwise
1162 return NULL. PTR is the iterator to use. */
1164 zero_ssa_operands (tree stmt, int flags)
1168 op_iter_init_tree (&iter, stmt, flags);
1169 return op_iter_done (&iter);
1173 /* Return the number of opernads mathcing FLAGS in STMT. */
1175 num_ssa_operands (tree stmt, int flags)
1180 op_iter_init (&iter, stmt, flags);
1181 for ( ; iter.defs; iter.defs = iter.defs->next)
1183 for ( ; iter.uses; iter.uses = iter.uses->next)
1185 for ( ; iter.vuses; iter.vuses = iter.vuses->next)
1187 for ( ; iter.maydefs; iter.maydefs = iter.maydefs->next)
1189 for ( ; iter.mayuses; iter.mayuses = iter.mayuses->next)
1191 for ( ; iter.mustdefs; iter.mustdefs = iter.mustdefs->next)
1193 for ( ; iter.mustkills; iter.mustkills = iter.mustkills->next)
1200 /* Delink all immediate_use information for STMT. */
1202 delink_stmt_imm_use (tree stmt)
1205 use_operand_p use_p;
1207 if (ssa_operands_active ())
1208 FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter,
1209 (SSA_OP_ALL_USES | SSA_OP_ALL_KILLS))
1210 delink_imm_use (use_p);
1214 /* This routine will compare all the operands matching FLAGS in STMT1 to those
1215 in STMT2. TRUE is returned if they are the same. STMTs can be NULL. */
1217 compare_ssa_operands_equal (tree stmt1, tree stmt2, int flags)
1219 ssa_op_iter iter1, iter2;
1220 tree op1 = NULL_TREE;
1221 tree op2 = NULL_TREE;
1227 look1 = stmt1 && stmt_ann (stmt1);
1228 look2 = stmt2 && stmt_ann (stmt2);
1232 op1 = op_iter_init_tree (&iter1, stmt1, flags);
1234 return op_iter_done (&iter1);
1237 clear_and_done_ssa_iter (&iter1);
1241 op2 = op_iter_init_tree (&iter2, stmt2, flags);
1243 return op_iter_done (&iter2);
1246 clear_and_done_ssa_iter (&iter2);
1248 while (!op_iter_done (&iter1) && !op_iter_done (&iter2))
1252 op1 = op_iter_next_tree (&iter1);
1253 op2 = op_iter_next_tree (&iter2);
1256 return (op_iter_done (&iter1) && op_iter_done (&iter2));
1260 /* If there is a single DEF in the PHI node which matches FLAG, return it.
1261 Otherwise return NULL_DEF_OPERAND_P. */
1263 single_phi_def (tree stmt, int flags)
1265 tree def = PHI_RESULT (stmt);
1266 if ((flags & SSA_OP_DEF) && is_gimple_reg (def))
1268 if ((flags & SSA_OP_VIRTUAL_DEFS) && !is_gimple_reg (def))
1273 /* Initialize the iterator PTR for uses matching FLAGS in PHI. FLAGS should
1274 be either SSA_OP_USES or SAS_OP_VIRTUAL_USES. */
1275 static inline use_operand_p
1276 op_iter_init_phiuse (ssa_op_iter *ptr, tree phi, int flags)
1278 tree phi_def = PHI_RESULT (phi);
1281 clear_and_done_ssa_iter (ptr);
1284 gcc_assert ((flags & (SSA_OP_USE | SSA_OP_VIRTUAL_USES)) != 0);
1286 comp = (is_gimple_reg (phi_def) ? SSA_OP_USE : SSA_OP_VIRTUAL_USES);
1288 /* if the PHI node deosn't the operand type we care about, we're done. */
1289 if ((flags & comp) == 0)
1292 return NULL_USE_OPERAND_P;
1295 ptr->phi_stmt = phi;
1296 ptr->num_phi = PHI_NUM_ARGS (phi);
1297 ptr->iter_type = ssa_op_iter_use;
1298 return op_iter_next_use (ptr);
1302 /* Start an iterator for a PHI defintion. */
1304 static inline def_operand_p
1305 op_iter_init_phidef (ssa_op_iter *ptr, tree phi, int flags)
1307 tree phi_def = PHI_RESULT (phi);
1310 clear_and_done_ssa_iter (ptr);
1313 gcc_assert ((flags & (SSA_OP_DEF | SSA_OP_VIRTUAL_DEFS)) != 0);
1315 comp = (is_gimple_reg (phi_def) ? SSA_OP_DEF : SSA_OP_VIRTUAL_DEFS);
1317 /* if the PHI node deosn't the operand type we care about, we're done. */
1318 if ((flags & comp) == 0)
1321 return NULL_USE_OPERAND_P;
1324 ptr->iter_type = ssa_op_iter_def;
1325 /* The first call to op_iter_next_def will terminate the iterator since
1326 all the fields are NULL. Simply return the result here as the first and
1327 therefore only result. */
1328 return PHI_RESULT_PTR (phi);
1333 /* Return true if VAR cannot be modified by the program. */
1336 unmodifiable_var_p (tree var)
1338 if (TREE_CODE (var) == SSA_NAME)
1339 var = SSA_NAME_VAR (var);
1340 return TREE_READONLY (var) && (TREE_STATIC (var) || DECL_EXTERNAL (var));
1343 /* Return true if REF, a COMPONENT_REF, has an ARRAY_REF somewhere in it. */
1346 ref_contains_array_ref (tree ref)
1348 while (handled_component_p (ref))
1350 if (TREE_CODE (ref) == ARRAY_REF)
1352 ref = TREE_OPERAND (ref, 0);
1357 /* Given a variable VAR, lookup and return a pointer to the list of
1358 subvariables for it. */
1360 static inline subvar_t *
1361 lookup_subvars_for_var (tree var)
1363 var_ann_t ann = var_ann (var);
1365 return &ann->subvars;
1368 /* Given a variable VAR, return a linked list of subvariables for VAR, or
1369 NULL, if there are no subvariables. */
1371 static inline subvar_t
1372 get_subvars_for_var (tree var)
1376 gcc_assert (SSA_VAR_P (var));
1378 if (TREE_CODE (var) == SSA_NAME)
1379 subvars = *(lookup_subvars_for_var (SSA_NAME_VAR (var)));
1381 subvars = *(lookup_subvars_for_var (var));
1385 /* Return true if V is a tree that we can have subvars for.
1386 Normally, this is any aggregate type, however, due to implementation
1387 limitations ATM, we exclude array types as well. */
1390 var_can_have_subvars (tree v)
1392 return (AGGREGATE_TYPE_P (TREE_TYPE (v)) &&
1393 TREE_CODE (TREE_TYPE (v)) != ARRAY_TYPE);
1397 /* Return true if OFFSET and SIZE define a range that overlaps with some
1398 portion of the range of SV, a subvar. If there was an exact overlap,
1399 *EXACT will be set to true upon return. */
1402 overlap_subvar (HOST_WIDE_INT offset, HOST_WIDE_INT size,
1403 subvar_t sv, bool *exact)
1405 /* There are three possible cases of overlap.
1406 1. We can have an exact overlap, like so:
1407 |offset, offset + size |
1408 |sv->offset, sv->offset + sv->size |
1410 2. We can have offset starting after sv->offset, like so:
1412 |offset, offset + size |
1413 |sv->offset, sv->offset + sv->size |
1415 3. We can have offset starting before sv->offset, like so:
1417 |offset, offset + size |
1418 |sv->offset, sv->offset + sv->size|
1423 if (offset == sv->offset && size == sv->size)
1429 else if (offset >= sv->offset && offset < (sv->offset + sv->size))
1433 else if (offset < sv->offset && (offset + size > sv->offset))
1441 #endif /* _TREE_FLOW_INLINE_H */