1 /* SSA operands management for trees.
2 Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GCC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING. If not, write to
18 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
19 Boston, MA 02110-1301, USA. */
23 #include "coretypes.h"
28 #include "diagnostic.h"
29 #include "tree-flow.h"
30 #include "tree-inline.h"
31 #include "tree-pass.h"
35 #include "langhooks.h"
37 /* This file contains the code required to manage the operands cache of the
38 SSA optimizer. For every stmt, we maintain an operand cache in the stmt
39 annotation. This cache contains operands that will be of interest to
40 optimizers and other passes wishing to manipulate the IL.
42 The operand type are broken up into REAL and VIRTUAL operands. The real
43 operands are represented as pointers into the stmt's operand tree. Thus
44 any manipulation of the real operands will be reflected in the actual tree.
45 Virtual operands are represented solely in the cache, although the base
46 variable for the SSA_NAME may, or may not occur in the stmt's tree.
47 Manipulation of the virtual operands will not be reflected in the stmt tree.
49 The routines in this file are concerned with creating this operand cache
52 The operand tree is the parsed by the various get_* routines which look
53 through the stmt tree for the occurrence of operands which may be of
54 interest, and calls are made to the append_* routines whenever one is
55 found. There are 5 of these routines, each representing one of the
56 5 types of operands. Defs, Uses, Virtual Uses, Virtual May Defs, and
59 The append_* routines check for duplication, and simply keep a list of
60 unique objects for each operand type in the build_* extendable vectors.
62 Once the stmt tree is completely parsed, the finalize_ssa_operands()
63 routine is called, which proceeds to perform the finalization routine
64 on each of the 5 operand vectors which have been built up.
66 If the stmt had a previous operand cache, the finalization routines
67 attempt to match up the new operands with the old ones. If it's a perfect
68 match, the old vector is simply reused. If it isn't a perfect match, then
69 a new vector is created and the new operands are placed there. For
70 virtual operands, if the previous cache had SSA_NAME version of a
71 variable, and that same variable occurs in the same operands cache, then
72 the new cache vector will also get the same SSA_NAME.
74 i.e., if a stmt had a VUSE of 'a_5', and 'a' occurs in the new operand
75 vector for VUSE, then the new vector will also be modified such that
76 it contains 'a_5' rather than 'a'.
81 /* Flags to describe operand properties in helpers. */
83 /* By default, operands are loaded. */
86 /* Operand is the target of an assignment expression or a
87 call-clobbered variable */
88 #define opf_is_def (1 << 0)
90 /* Operand is the target of an assignment expression. */
91 #define opf_kill_def (1 << 1)
93 /* No virtual operands should be created in the expression. This is used
94 when traversing ADDR_EXPR nodes which have different semantics than
95 other expressions. Inside an ADDR_EXPR node, the only operands that we
96 need to consider are indices into arrays. For instance, &a.b[i] should
97 generate a USE of 'i' but it should not generate a VUSE for 'a' nor a
99 #define opf_no_vops (1 << 2)
101 /* Operand is a "non-specific" kill for call-clobbers and such. This is used
102 to distinguish "reset the world" events from explicit MODIFY_EXPRs. */
103 #define opf_non_specific (1 << 3)
105 /* This structure maintain a sorted list of operands which is created by
106 parse_ssa_operand. */
107 struct opbuild_list_d GTY (())
109 varray_type vars; /* The VAR_DECLS tree. */
110 varray_type uid; /* The sort value for virtual symbols. */
111 varray_type next; /* The next index in the sorted list. */
112 int first; /* First element in list. */
113 unsigned num; /* Number of elements. */
116 #define OPBUILD_LAST -1
119 /* Array for building all the def operands. */
120 static GTY (()) struct opbuild_list_d build_defs;
122 /* Array for building all the use operands. */
123 static GTY (()) struct opbuild_list_d build_uses;
125 /* Array for building all the v_may_def operands. */
126 static GTY (()) struct opbuild_list_d build_v_may_defs;
128 /* Array for building all the vuse operands. */
129 static GTY (()) struct opbuild_list_d build_vuses;
131 /* Array for building all the v_must_def operands. */
132 static GTY (()) struct opbuild_list_d build_v_must_defs;
134 /* True if the operands for call clobbered vars are cached and valid. */
135 bool ssa_call_clobbered_cache_valid;
136 bool ssa_ro_call_cache_valid;
138 /* These arrays are the cached operand vectors for call clobbered calls. */
139 static VEC(tree,heap) *clobbered_v_may_defs;
140 static VEC(tree,heap) *clobbered_vuses;
141 static VEC(tree,heap) *ro_call_vuses;
142 static bool clobbered_aliased_loads;
143 static bool clobbered_aliased_stores;
144 static bool ro_call_aliased_loads;
145 static bool ops_active = false;
147 static GTY (()) struct ssa_operand_memory_d *operand_memory = NULL;
148 static unsigned operand_memory_index;
150 static void get_expr_operands (tree, tree *, int);
151 static void get_asm_expr_operands (tree);
152 static void get_indirect_ref_operands (tree, tree, int);
153 static void get_tmr_operands (tree, tree, int);
154 static void get_call_expr_operands (tree, tree);
155 static inline void append_def (tree *);
156 static inline void append_use (tree *);
157 static void append_v_may_def (tree);
158 static void append_v_must_def (tree);
159 static void add_call_clobber_ops (tree);
160 static void add_call_read_ops (tree);
161 static void add_stmt_operand (tree *, stmt_ann_t, int);
162 static void build_ssa_operands (tree stmt);
164 static def_optype_p free_defs = NULL;
165 static use_optype_p free_uses = NULL;
166 static vuse_optype_p free_vuses = NULL;
167 static maydef_optype_p free_maydefs = NULL;
168 static mustdef_optype_p free_mustdefs = NULL;
170 /* Initialize a virtual operand build LIST called NAME with NUM elements. */
173 opbuild_initialize_virtual (struct opbuild_list_d *list, int num,
176 list->first = OPBUILD_LAST;
178 VARRAY_TREE_INIT (list->vars, num, name);
179 VARRAY_UINT_INIT (list->uid, num, "List UID");
180 VARRAY_INT_INIT (list->next, num, "List NEXT");
184 /* Initialize a real operand build LIST called NAME with NUM elements. */
187 opbuild_initialize_real (struct opbuild_list_d *list, int num, const char *name)
189 list->first = OPBUILD_LAST;
191 VARRAY_TREE_PTR_INIT (list->vars, num, name);
192 VARRAY_INT_INIT (list->next, num, "List NEXT");
193 /* The UID field is not needed since we sort based on the pointer value. */
198 /* Free memory used in virtual operand build object LIST. */
201 opbuild_free (struct opbuild_list_d *list)
209 /* Number of elements in an opbuild list. */
211 static inline unsigned
212 opbuild_num_elems (struct opbuild_list_d *list)
218 /* Add VAR to the real operand list LIST, keeping it sorted and avoiding
219 duplicates. The actual sort value is the tree pointer value. */
222 opbuild_append_real (struct opbuild_list_d *list, tree *var)
226 #ifdef ENABLE_CHECKING
227 /* Ensure the real operand doesn't exist already. */
228 for (index = list->first;
229 index != OPBUILD_LAST;
230 index = VARRAY_INT (list->next, index))
231 gcc_assert (VARRAY_TREE_PTR (list->vars, index) != var);
234 /* First item in the list. */
235 index = VARRAY_ACTIVE_SIZE (list->vars);
239 VARRAY_INT (list->next, index - 1) = index;
240 VARRAY_PUSH_INT (list->next, OPBUILD_LAST);
241 VARRAY_PUSH_TREE_PTR (list->vars, var);
246 /* Add VAR to the virtual operand list LIST, keeping it sorted and avoiding
247 duplicates. The actual sort value is the DECL UID of the base variable. */
250 opbuild_append_virtual (struct opbuild_list_d *list, tree var)
252 int index, curr, last;
253 unsigned int var_uid;
255 if (TREE_CODE (var) != SSA_NAME)
256 var_uid = DECL_UID (var);
258 var_uid = DECL_UID (SSA_NAME_VAR (var));
260 index = VARRAY_ACTIVE_SIZE (list->vars);
264 VARRAY_PUSH_TREE (list->vars, var);
265 VARRAY_PUSH_UINT (list->uid, var_uid);
266 VARRAY_PUSH_INT (list->next, OPBUILD_LAST);
273 /* Find the correct spot in the sorted list. */
274 for (curr = list->first;
275 curr != OPBUILD_LAST;
276 last = curr, curr = VARRAY_INT (list->next, curr))
278 if (VARRAY_UINT (list->uid, curr) > var_uid)
282 if (last == OPBUILD_LAST)
284 /* First item in the list. */
285 VARRAY_PUSH_INT (list->next, list->first);
290 /* Don't enter duplicates at all. */
291 if (VARRAY_UINT (list->uid, last) == var_uid)
294 VARRAY_PUSH_INT (list->next, VARRAY_INT (list->next, last));
295 VARRAY_INT (list->next, last) = index;
297 VARRAY_PUSH_TREE (list->vars, var);
298 VARRAY_PUSH_UINT (list->uid, var_uid);
303 /* Return the first element index in LIST. OPBUILD_LAST means there are no
307 opbuild_first (struct opbuild_list_d *list)
316 /* Return the next element after PREV in LIST. */
319 opbuild_next (struct opbuild_list_d *list, int prev)
321 return VARRAY_INT (list->next, prev);
325 /* Return the real element at index ELEM in LIST. */
328 opbuild_elem_real (struct opbuild_list_d *list, int elem)
330 return VARRAY_TREE_PTR (list->vars, elem);
334 /* Return the virtual element at index ELEM in LIST. */
337 opbuild_elem_virtual (struct opbuild_list_d *list, int elem)
339 return VARRAY_TREE (list->vars, elem);
343 /* Return the virtual element uid at index ELEM in LIST. */
344 static inline unsigned int
345 opbuild_elem_uid (struct opbuild_list_d *list, int elem)
347 return VARRAY_UINT (list->uid, elem);
351 /* Reset an operand build list. */
354 opbuild_clear (struct opbuild_list_d *list)
356 list->first = OPBUILD_LAST;
357 VARRAY_POP_ALL (list->vars);
358 VARRAY_POP_ALL (list->next);
360 VARRAY_POP_ALL (list->uid);
365 /* Remove ELEM from LIST where PREV is the previous element. Return the next
369 opbuild_remove_elem (struct opbuild_list_d *list, int elem, int prev)
372 if (prev != OPBUILD_LAST)
374 gcc_assert (VARRAY_INT (list->next, prev) == elem);
375 ret = VARRAY_INT (list->next, prev) = VARRAY_INT (list->next, elem);
379 gcc_assert (list->first == elem);
380 ret = list->first = VARRAY_INT (list->next, elem);
387 /* Return true if the ssa operands cache is active. */
390 ssa_operands_active (void)
396 /* Initialize the operand cache routines. */
399 init_ssa_operands (void)
401 opbuild_initialize_real (&build_defs, 5, "build defs");
402 opbuild_initialize_real (&build_uses, 10, "build uses");
403 opbuild_initialize_virtual (&build_vuses, 25, "build_vuses");
404 opbuild_initialize_virtual (&build_v_may_defs, 25, "build_v_may_defs");
405 opbuild_initialize_virtual (&build_v_must_defs, 25, "build_v_must_defs");
406 gcc_assert (operand_memory == NULL);
407 operand_memory_index = SSA_OPERAND_MEMORY_SIZE;
412 /* Dispose of anything required by the operand routines. */
415 fini_ssa_operands (void)
417 struct ssa_operand_memory_d *ptr;
418 opbuild_free (&build_defs);
419 opbuild_free (&build_uses);
420 opbuild_free (&build_v_must_defs);
421 opbuild_free (&build_v_may_defs);
422 opbuild_free (&build_vuses);
427 free_mustdefs = NULL;
428 while ((ptr = operand_memory) != NULL)
430 operand_memory = operand_memory->next;
434 VEC_free (tree, heap, clobbered_v_may_defs);
435 VEC_free (tree, heap, clobbered_vuses);
436 VEC_free (tree, heap, ro_call_vuses);
441 /* Return memory for operands of SIZE chunks. */
444 ssa_operand_alloc (unsigned size)
447 if (operand_memory_index + size >= SSA_OPERAND_MEMORY_SIZE)
449 struct ssa_operand_memory_d *ptr;
450 ptr = ggc_alloc (sizeof (struct ssa_operand_memory_d));
451 ptr->next = operand_memory;
452 operand_memory = ptr;
453 operand_memory_index = 0;
455 ptr = &(operand_memory->mem[operand_memory_index]);
456 operand_memory_index += size;
461 /* Make sure PTR is inn the correct immediate use list. Since uses are simply
462 pointers into the stmt TREE, there is no way of telling if anyone has
463 changed what this pointer points to via TREE_OPERANDS (exp, 0) = <...>.
464 THe contents are different, but the the pointer is still the same. This
465 routine will check to make sure PTR is in the correct list, and if it isn't
466 put it in the correct list. We cannot simply check the previous node
467 because all nodes in the same stmt might have be changed. */
470 correct_use_link (use_operand_p ptr, tree stmt)
475 /* Fold_stmt () may have changed the stmt pointers. */
476 if (ptr->stmt != stmt)
482 bool stmt_mod = true;
483 /* Find the first element which isn't a SAFE iterator, is in a different
484 stmt, and is not a a modified stmt, That node is in the correct list,
485 see if we are too. */
489 while (prev->stmt == stmt || prev->stmt == NULL)
491 if (prev->use == NULL)
494 if ((stmt_mod = stmt_modified_p (prev->stmt)))
498 /* Get the ssa_name of the list the node is in. */
499 if (prev->use == NULL)
503 /* If it's the right list, simply return. */
504 if (root == *(ptr->use))
507 /* Its in the wrong list if we reach here. */
508 delink_imm_use (ptr);
509 link_imm_use (ptr, *(ptr->use));
513 #define FINALIZE_OPBUILD build_defs
514 #define FINALIZE_OPBUILD_BASE(I) opbuild_elem_real (&build_defs, (I))
515 #define FINALIZE_OPBUILD_ELEM(I) opbuild_elem_real (&build_defs, (I))
516 #define FINALIZE_FUNC finalize_ssa_def_ops
517 #define FINALIZE_ALLOC alloc_def
518 #define FINALIZE_FREE free_defs
519 #define FINALIZE_TYPE struct def_optype_d
520 #define FINALIZE_ELEM(PTR) ((PTR)->def_ptr)
521 #define FINALIZE_OPS DEF_OPS
522 #define FINALIZE_BASE(VAR) VAR
523 #define FINALIZE_BASE_TYPE tree *
524 #define FINALIZE_BASE_ZERO NULL
525 #define FINALIZE_INITIALIZE(PTR, VAL, STMT) FINALIZE_ELEM (PTR) = (VAL)
526 #include "tree-ssa-opfinalize.h"
529 /* This routine will create stmt operands for STMT from the def build list. */
532 finalize_ssa_defs (tree stmt)
534 unsigned int num = opbuild_num_elems (&build_defs);
535 /* There should only be a single real definition per assignment. */
536 gcc_assert ((stmt && TREE_CODE (stmt) != MODIFY_EXPR) || num <= 1);
538 /* If there is an old list, often the new list is identical, or close, so
539 find the elements at the beginning that are the same as the vector. */
541 finalize_ssa_def_ops (stmt);
542 opbuild_clear (&build_defs);
545 #define FINALIZE_OPBUILD build_uses
546 #define FINALIZE_OPBUILD_BASE(I) opbuild_elem_real (&build_uses, (I))
547 #define FINALIZE_OPBUILD_ELEM(I) opbuild_elem_real (&build_uses, (I))
548 #define FINALIZE_FUNC finalize_ssa_use_ops
549 #define FINALIZE_ALLOC alloc_use
550 #define FINALIZE_FREE free_uses
551 #define FINALIZE_TYPE struct use_optype_d
552 #define FINALIZE_ELEM(PTR) ((PTR)->use_ptr.use)
553 #define FINALIZE_OPS USE_OPS
554 #define FINALIZE_USE_PTR(PTR) USE_OP_PTR (PTR)
555 #define FINALIZE_BASE(VAR) VAR
556 #define FINALIZE_BASE_TYPE tree *
557 #define FINALIZE_BASE_ZERO NULL
558 #define FINALIZE_INITIALIZE(PTR, VAL, STMT) \
559 (PTR)->use_ptr.use = (VAL); \
560 link_imm_use_stmt (&((PTR)->use_ptr), \
562 #include "tree-ssa-opfinalize.h"
564 /* Return a new use operand vector for STMT, comparing to OLD_OPS_P. */
567 finalize_ssa_uses (tree stmt)
569 #ifdef ENABLE_CHECKING
572 unsigned num = opbuild_num_elems (&build_uses);
574 /* If the pointer to the operand is the statement itself, something is
575 wrong. It means that we are pointing to a local variable (the
576 initial call to get_stmt_operands does not pass a pointer to a
578 for (x = 0; x < num; x++)
579 gcc_assert (*(opbuild_elem_real (&build_uses, x)) != stmt);
582 finalize_ssa_use_ops (stmt);
583 opbuild_clear (&build_uses);
587 /* Return a new v_may_def operand vector for STMT, comparing to OLD_OPS_P. */
588 #define FINALIZE_OPBUILD build_v_may_defs
589 #define FINALIZE_OPBUILD_ELEM(I) opbuild_elem_virtual (&build_v_may_defs, (I))
590 #define FINALIZE_OPBUILD_BASE(I) opbuild_elem_uid (&build_v_may_defs, (I))
591 #define FINALIZE_FUNC finalize_ssa_v_may_def_ops
592 #define FINALIZE_ALLOC alloc_maydef
593 #define FINALIZE_FREE free_maydefs
594 #define FINALIZE_TYPE struct maydef_optype_d
595 #define FINALIZE_ELEM(PTR) MAYDEF_RESULT (PTR)
596 #define FINALIZE_OPS MAYDEF_OPS
597 #define FINALIZE_USE_PTR(PTR) MAYDEF_OP_PTR (PTR)
598 #define FINALIZE_BASE_ZERO 0
599 #define FINALIZE_BASE(VAR) ((TREE_CODE (VAR) == SSA_NAME) \
600 ? DECL_UID (SSA_NAME_VAR (VAR)) : DECL_UID ((VAR)))
601 #define FINALIZE_BASE_TYPE unsigned
602 #define FINALIZE_INITIALIZE(PTR, VAL, STMT) \
603 (PTR)->def_var = (VAL); \
604 (PTR)->use_var = (VAL); \
605 (PTR)->use_ptr.use = &((PTR)->use_var); \
606 link_imm_use_stmt (&((PTR)->use_ptr), \
608 #include "tree-ssa-opfinalize.h"
612 finalize_ssa_v_may_defs (tree stmt)
614 finalize_ssa_v_may_def_ops (stmt);
618 /* Clear the in_list bits and empty the build array for v_may_defs. */
621 cleanup_v_may_defs (void)
624 num = opbuild_num_elems (&build_v_may_defs);
626 for (x = 0; x < num; x++)
628 tree t = opbuild_elem_virtual (&build_v_may_defs, x);
629 if (TREE_CODE (t) != SSA_NAME)
631 var_ann_t ann = var_ann (t);
632 ann->in_v_may_def_list = 0;
635 opbuild_clear (&build_v_may_defs);
639 #define FINALIZE_OPBUILD build_vuses
640 #define FINALIZE_OPBUILD_ELEM(I) opbuild_elem_virtual (&build_vuses, (I))
641 #define FINALIZE_OPBUILD_BASE(I) opbuild_elem_uid (&build_vuses, (I))
642 #define FINALIZE_FUNC finalize_ssa_vuse_ops
643 #define FINALIZE_ALLOC alloc_vuse
644 #define FINALIZE_FREE free_vuses
645 #define FINALIZE_TYPE struct vuse_optype_d
646 #define FINALIZE_ELEM(PTR) VUSE_OP (PTR)
647 #define FINALIZE_OPS VUSE_OPS
648 #define FINALIZE_USE_PTR(PTR) VUSE_OP_PTR (PTR)
649 #define FINALIZE_BASE_ZERO 0
650 #define FINALIZE_BASE(VAR) ((TREE_CODE (VAR) == SSA_NAME) \
651 ? DECL_UID (SSA_NAME_VAR (VAR)) : DECL_UID ((VAR)))
652 #define FINALIZE_BASE_TYPE unsigned
653 #define FINALIZE_INITIALIZE(PTR, VAL, STMT) \
654 (PTR)->use_var = (VAL); \
655 (PTR)->use_ptr.use = &((PTR)->use_var); \
656 link_imm_use_stmt (&((PTR)->use_ptr), \
658 #include "tree-ssa-opfinalize.h"
661 /* Return a new vuse operand vector, comparing to OLD_OPS_P. */
664 finalize_ssa_vuses (tree stmt)
666 unsigned num, num_v_may_defs;
669 /* Remove superfluous VUSE operands. If the statement already has a
670 V_MAY_DEF operation for a variable 'a', then a VUSE for 'a' is not
671 needed because V_MAY_DEFs imply a VUSE of the variable. For instance,
672 suppose that variable 'a' is aliased:
675 # a_3 = V_MAY_DEF <a_2>
678 The VUSE <a_2> is superfluous because it is implied by the V_MAY_DEF
681 num = opbuild_num_elems (&build_vuses);
682 num_v_may_defs = opbuild_num_elems (&build_v_may_defs);
684 if (num > 0 && num_v_may_defs > 0)
686 int last = OPBUILD_LAST;
687 vuse_index = opbuild_first (&build_vuses);
688 for ( ; vuse_index != OPBUILD_LAST; )
691 vuse = opbuild_elem_virtual (&build_vuses, vuse_index);
692 if (TREE_CODE (vuse) != SSA_NAME)
694 var_ann_t ann = var_ann (vuse);
695 ann->in_vuse_list = 0;
696 if (ann->in_v_may_def_list)
698 vuse_index = opbuild_remove_elem (&build_vuses, vuse_index,
704 vuse_index = opbuild_next (&build_vuses, vuse_index);
708 /* Clear out the in_list bits. */
709 for (vuse_index = opbuild_first (&build_vuses);
710 vuse_index != OPBUILD_LAST;
711 vuse_index = opbuild_next (&build_vuses, vuse_index))
713 tree t = opbuild_elem_virtual (&build_vuses, vuse_index);
714 if (TREE_CODE (t) != SSA_NAME)
716 var_ann_t ann = var_ann (t);
717 ann->in_vuse_list = 0;
721 finalize_ssa_vuse_ops (stmt);
722 /* The v_may_def build vector wasn't cleaned up because we needed it. */
723 cleanup_v_may_defs ();
725 /* Free the vuses build vector. */
726 opbuild_clear (&build_vuses);
730 /* Return a new v_must_def operand vector for STMT, comparing to OLD_OPS_P. */
732 #define FINALIZE_OPBUILD build_v_must_defs
733 #define FINALIZE_OPBUILD_ELEM(I) opbuild_elem_virtual (&build_v_must_defs, (I))
734 #define FINALIZE_OPBUILD_BASE(I) opbuild_elem_uid (&build_v_must_defs, (I))
735 #define FINALIZE_FUNC finalize_ssa_v_must_def_ops
736 #define FINALIZE_ALLOC alloc_mustdef
737 #define FINALIZE_FREE free_mustdefs
738 #define FINALIZE_TYPE struct mustdef_optype_d
739 #define FINALIZE_ELEM(PTR) MUSTDEF_RESULT (PTR)
740 #define FINALIZE_OPS MUSTDEF_OPS
741 #define FINALIZE_USE_PTR(PTR) MUSTDEF_KILL_PTR (PTR)
742 #define FINALIZE_BASE_ZERO 0
743 #define FINALIZE_BASE(VAR) ((TREE_CODE (VAR) == SSA_NAME) \
744 ? DECL_UID (SSA_NAME_VAR (VAR)) : DECL_UID ((VAR)))
745 #define FINALIZE_BASE_TYPE unsigned
746 #define FINALIZE_INITIALIZE(PTR, VAL, STMT) \
747 (PTR)->def_var = (VAL); \
748 (PTR)->kill_var = (VAL); \
749 (PTR)->use_ptr.use = &((PTR)->kill_var);\
750 link_imm_use_stmt (&((PTR)->use_ptr), \
752 #include "tree-ssa-opfinalize.h"
756 finalize_ssa_v_must_defs (tree stmt)
758 /* In the presence of subvars, there may be more than one V_MUST_DEF per
759 statement (one for each subvar). It is a bit expensive to verify that
760 all must-defs in a statement belong to subvars if there is more than one
761 MUST-def, so we don't do it. Suffice to say, if you reach here without
762 having subvars, and have num >1, you have hit a bug. */
764 finalize_ssa_v_must_def_ops (stmt);
765 opbuild_clear (&build_v_must_defs);
769 /* Finalize all the build vectors, fill the new ones into INFO. */
772 finalize_ssa_stmt_operands (tree stmt)
774 finalize_ssa_defs (stmt);
775 finalize_ssa_uses (stmt);
776 finalize_ssa_v_must_defs (stmt);
777 finalize_ssa_v_may_defs (stmt);
778 finalize_ssa_vuses (stmt);
782 /* Start the process of building up operands vectors in INFO. */
785 start_ssa_stmt_operands (void)
787 gcc_assert (opbuild_num_elems (&build_defs) == 0);
788 gcc_assert (opbuild_num_elems (&build_uses) == 0);
789 gcc_assert (opbuild_num_elems (&build_vuses) == 0);
790 gcc_assert (opbuild_num_elems (&build_v_may_defs) == 0);
791 gcc_assert (opbuild_num_elems (&build_v_must_defs) == 0);
795 /* Add DEF_P to the list of pointers to operands. */
798 append_def (tree *def_p)
800 opbuild_append_real (&build_defs, def_p);
804 /* Add USE_P to the list of pointers to operands. */
807 append_use (tree *use_p)
809 opbuild_append_real (&build_uses, use_p);
813 /* Add a new virtual may def for variable VAR to the build array. */
816 append_v_may_def (tree var)
818 if (TREE_CODE (var) != SSA_NAME)
820 var_ann_t ann = get_var_ann (var);
822 /* Don't allow duplicate entries. */
823 if (ann->in_v_may_def_list)
825 ann->in_v_may_def_list = 1;
828 opbuild_append_virtual (&build_v_may_defs, var);
832 /* Add VAR to the list of virtual uses. */
835 append_vuse (tree var)
838 /* Don't allow duplicate entries. */
839 if (TREE_CODE (var) != SSA_NAME)
841 var_ann_t ann = get_var_ann (var);
843 if (ann->in_vuse_list || ann->in_v_may_def_list)
845 ann->in_vuse_list = 1;
848 opbuild_append_virtual (&build_vuses, var);
852 /* Add VAR to the list of virtual must definitions for INFO. */
855 append_v_must_def (tree var)
859 /* Don't allow duplicate entries. */
860 for (i = 0; i < opbuild_num_elems (&build_v_must_defs); i++)
861 if (var == opbuild_elem_virtual (&build_v_must_defs, i))
864 opbuild_append_virtual (&build_v_must_defs, var);
868 /* Parse STMT looking for operands. OLD_OPS is the original stmt operand
869 cache for STMT, if it existed before. When finished, the various build_*
870 operand vectors will have potential operands. in them. */
873 parse_ssa_operands (tree stmt)
877 code = TREE_CODE (stmt);
881 /* First get operands from the RHS. For the LHS, we use a V_MAY_DEF if
882 either only part of LHS is modified or if the RHS might throw,
883 otherwise, use V_MUST_DEF.
885 ??? If it might throw, we should represent somehow that it is killed
886 on the fallthrough path. */
888 tree lhs = TREE_OPERAND (stmt, 0);
889 int lhs_flags = opf_is_def;
891 get_expr_operands (stmt, &TREE_OPERAND (stmt, 1), opf_none);
893 /* If the LHS is a VIEW_CONVERT_EXPR, it isn't changing whether
894 or not the entire LHS is modified; that depends on what's
895 inside the VIEW_CONVERT_EXPR. */
896 if (TREE_CODE (lhs) == VIEW_CONVERT_EXPR)
897 lhs = TREE_OPERAND (lhs, 0);
899 if (TREE_CODE (lhs) != ARRAY_REF && TREE_CODE (lhs) != ARRAY_RANGE_REF
900 && TREE_CODE (lhs) != BIT_FIELD_REF
901 && TREE_CODE (lhs) != REALPART_EXPR
902 && TREE_CODE (lhs) != IMAGPART_EXPR)
903 lhs_flags |= opf_kill_def;
905 get_expr_operands (stmt, &TREE_OPERAND (stmt, 0), lhs_flags);
910 get_expr_operands (stmt, &COND_EXPR_COND (stmt), opf_none);
914 get_expr_operands (stmt, &SWITCH_COND (stmt), opf_none);
918 get_asm_expr_operands (stmt);
922 get_expr_operands (stmt, &TREE_OPERAND (stmt, 0), opf_none);
926 get_expr_operands (stmt, &GOTO_DESTINATION (stmt), opf_none);
930 get_expr_operands (stmt, &LABEL_EXPR_LABEL (stmt), opf_none);
933 /* These nodes contain no variable references. */
935 case CASE_LABEL_EXPR:
937 case TRY_FINALLY_EXPR:
944 /* Notice that if get_expr_operands tries to use &STMT as the operand
945 pointer (which may only happen for USE operands), we will fail in
946 append_use. This default will handle statements like empty
947 statements, or CALL_EXPRs that may appear on the RHS of a statement
948 or as statements themselves. */
949 get_expr_operands (stmt, &stmt, opf_none);
954 /* Create an operands cache for STMT, returning it in NEW_OPS. OLD_OPS are the
955 original operands, and if ANN is non-null, appropriate stmt flags are set
956 in the stmt's annotation. If ANN is NULL, this is not considered a "real"
957 stmt, and none of the operands will be entered into their respective
958 immediate uses tables. This is to allow stmts to be processed when they
959 are not actually in the CFG.
961 Note that some fields in old_ops may change to NULL, although none of the
962 memory they originally pointed to will be destroyed. It is appropriate
963 to call free_stmt_operands() on the value returned in old_ops.
965 The rationale for this: Certain optimizations wish to examine the difference
966 between new_ops and old_ops after processing. If a set of operands don't
967 change, new_ops will simply assume the pointer in old_ops, and the old_ops
968 pointer will be set to NULL, indicating no memory needs to be cleared.
969 Usage might appear something like:
971 old_ops_copy = old_ops = stmt_ann(stmt)->operands;
972 build_ssa_operands (stmt, NULL, &old_ops, &new_ops);
973 <* compare old_ops_copy and new_ops *>
974 free_ssa_operands (old_ops); */
977 build_ssa_operands (tree stmt)
979 stmt_ann_t ann = get_stmt_ann (stmt);
981 /* Initially assume that the statement has no volatile operands, nor
982 makes aliased loads or stores. */
985 ann->has_volatile_ops = false;
986 ann->makes_aliased_stores = false;
987 ann->makes_aliased_loads = false;
990 start_ssa_stmt_operands ();
992 parse_ssa_operands (stmt);
994 finalize_ssa_stmt_operands (stmt);
998 /* Free any operands vectors in OPS. */
1000 free_ssa_operands (stmt_operands_p ops)
1002 ops->def_ops = NULL;
1003 ops->use_ops = NULL;
1004 ops->maydef_ops = NULL;
1005 ops->mustdef_ops = NULL;
1006 ops->vuse_ops = NULL;
1010 /* Get the operands of statement STMT. Note that repeated calls to
1011 get_stmt_operands for the same statement will do nothing until the
1012 statement is marked modified by a call to mark_stmt_modified(). */
1015 update_stmt_operands (tree stmt)
1017 stmt_ann_t ann = get_stmt_ann (stmt);
1018 /* If get_stmt_operands is called before SSA is initialized, dont
1020 if (!ssa_operands_active ())
1022 /* The optimizers cannot handle statements that are nothing but a
1023 _DECL. This indicates a bug in the gimplifier. */
1024 gcc_assert (!SSA_VAR_P (stmt));
1026 gcc_assert (ann->modified);
1028 timevar_push (TV_TREE_OPS);
1030 build_ssa_operands (stmt);
1032 /* Clear the modified bit for STMT. Subsequent calls to
1033 get_stmt_operands for this statement will do nothing until the
1034 statement is marked modified by a call to mark_stmt_modified(). */
1037 timevar_pop (TV_TREE_OPS);
1041 /* Copies virtual operands from SRC to DST. */
1044 copy_virtual_operands (tree dest, tree src)
1047 ssa_op_iter iter, old_iter;
1048 use_operand_p use_p, u2;
1049 def_operand_p def_p, d2;
1051 build_ssa_operands (dest);
1053 /* Copy all the virtual fields. */
1054 FOR_EACH_SSA_TREE_OPERAND (t, src, iter, SSA_OP_VUSE)
1056 FOR_EACH_SSA_TREE_OPERAND (t, src, iter, SSA_OP_VMAYDEF)
1057 append_v_may_def (t);
1058 FOR_EACH_SSA_TREE_OPERAND (t, src, iter, SSA_OP_VMUSTDEF)
1059 append_v_must_def (t);
1061 if (opbuild_num_elems (&build_vuses) == 0
1062 && opbuild_num_elems (&build_v_may_defs) == 0
1063 && opbuild_num_elems (&build_v_must_defs) == 0)
1066 /* Now commit the virtual operands to this stmt. */
1067 finalize_ssa_v_must_defs (dest);
1068 finalize_ssa_v_may_defs (dest);
1069 finalize_ssa_vuses (dest);
1071 /* Finally, set the field to the same values as then originals. */
1074 t = op_iter_init_tree (&old_iter, src, SSA_OP_VUSE);
1075 FOR_EACH_SSA_USE_OPERAND (use_p, dest, iter, SSA_OP_VUSE)
1077 gcc_assert (!op_iter_done (&old_iter));
1079 t = op_iter_next_tree (&old_iter);
1081 gcc_assert (op_iter_done (&old_iter));
1083 op_iter_init_maydef (&old_iter, src, &u2, &d2);
1084 FOR_EACH_SSA_MAYDEF_OPERAND (def_p, use_p, dest, iter)
1086 gcc_assert (!op_iter_done (&old_iter));
1087 SET_USE (use_p, USE_FROM_PTR (u2));
1088 SET_DEF (def_p, DEF_FROM_PTR (d2));
1089 op_iter_next_maymustdef (&u2, &d2, &old_iter);
1091 gcc_assert (op_iter_done (&old_iter));
1093 op_iter_init_mustdef (&old_iter, src, &u2, &d2);
1094 FOR_EACH_SSA_MUSTDEF_OPERAND (def_p, use_p, dest, iter)
1096 gcc_assert (!op_iter_done (&old_iter));
1097 SET_USE (use_p, USE_FROM_PTR (u2));
1098 SET_DEF (def_p, DEF_FROM_PTR (d2));
1099 op_iter_next_maymustdef (&u2, &d2, &old_iter);
1101 gcc_assert (op_iter_done (&old_iter));
1106 /* Specifically for use in DOM's expression analysis. Given a store, we
1107 create an artificial stmt which looks like a load from the store, this can
1108 be used to eliminate redundant loads. OLD_OPS are the operands from the
1109 store stmt, and NEW_STMT is the new load which represents a load of the
1113 create_ssa_artficial_load_stmt (tree new_stmt, tree old_stmt)
1118 use_operand_p use_p;
1121 ann = get_stmt_ann (new_stmt);
1123 /* process the stmt looking for operands. */
1124 start_ssa_stmt_operands ();
1125 parse_ssa_operands (new_stmt);
1127 for (x = 0; x < opbuild_num_elems (&build_vuses); x++)
1129 tree t = opbuild_elem_virtual (&build_vuses, x);
1130 if (TREE_CODE (t) != SSA_NAME)
1132 var_ann_t ann = var_ann (t);
1133 ann->in_vuse_list = 0;
1137 for (x = 0; x < opbuild_num_elems (&build_v_may_defs); x++)
1139 tree t = opbuild_elem_virtual (&build_v_may_defs, x);
1140 if (TREE_CODE (t) != SSA_NAME)
1142 var_ann_t ann = var_ann (t);
1143 ann->in_v_may_def_list = 0;
1146 /* Remove any virtual operands that were found. */
1147 opbuild_clear (&build_v_may_defs);
1148 opbuild_clear (&build_v_must_defs);
1149 opbuild_clear (&build_vuses);
1151 /* For each VDEF on the original statement, we want to create a
1152 VUSE of the V_MAY_DEF result or V_MUST_DEF op on the new
1154 FOR_EACH_SSA_TREE_OPERAND (op, old_stmt, iter,
1155 (SSA_OP_VMAYDEF | SSA_OP_VMUSTDEF))
1158 /* Now build the operands for this new stmt. */
1159 finalize_ssa_stmt_operands (new_stmt);
1161 /* All uses in this fake stmt must not be in the immediate use lists. */
1162 FOR_EACH_SSA_USE_OPERAND (use_p, new_stmt, iter, SSA_OP_ALL_USES)
1163 delink_imm_use (use_p);
1167 swap_tree_operands (tree stmt, tree *exp0, tree *exp1)
1173 /* If the operand cache is active, attempt to preserve the relative positions
1174 of these two operands in their respective immediate use lists. */
1175 if (ssa_operands_active () && op0 != op1)
1177 use_optype_p use0, use1, ptr;
1179 /* Find the 2 operands in the cache, if they are there. */
1180 for (ptr = USE_OPS (stmt); ptr; ptr = ptr->next)
1181 if (USE_OP_PTR (ptr)->use == exp0)
1186 for (ptr = USE_OPS (stmt); ptr; ptr = ptr->next)
1187 if (USE_OP_PTR (ptr)->use == exp1)
1192 /* If both uses don't have operand entries, there isn't much we can do
1193 at this point. Presumably we dont need to worry about it. */
1196 tree *tmp = USE_OP_PTR (use1)->use;
1197 USE_OP_PTR (use1)->use = USE_OP_PTR (use0)->use;
1198 USE_OP_PTR (use0)->use = tmp;
1202 /* Now swap the data. */
1208 /* Recursively scan the expression pointed by EXPR_P in statement referred to
1209 by INFO. FLAGS is one of the OPF_* constants modifying how to interpret the
1213 get_expr_operands (tree stmt, tree *expr_p, int flags)
1215 enum tree_code code;
1216 enum tree_code_class class;
1217 tree expr = *expr_p;
1218 stmt_ann_t s_ann = stmt_ann (stmt);
1223 code = TREE_CODE (expr);
1224 class = TREE_CODE_CLASS (code);
1229 /* We could have the address of a component, array member,
1230 etc which has interesting variable references. */
1231 /* Taking the address of a variable does not represent a
1232 reference to it, but the fact that the stmt takes its address will be
1233 of interest to some passes (e.g. alias resolution). */
1234 add_stmt_operand (expr_p, s_ann, 0);
1236 /* If the address is invariant, there may be no interesting variable
1237 references inside. */
1238 if (is_gimple_min_invariant (expr))
1241 /* There should be no VUSEs created, since the referenced objects are
1242 not really accessed. The only operands that we should find here
1243 are ARRAY_REF indices which will always be real operands (GIMPLE
1244 does not allow non-registers as array indices). */
1245 flags |= opf_no_vops;
1247 get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags);
1258 /* Add the subvars for a variable if it has subvars, to DEFS or USES.
1259 Otherwise, add the variable itself.
1260 Whether it goes to USES or DEFS depends on the operand flags. */
1261 if (var_can_have_subvars (expr)
1262 && (svars = get_subvars_for_var (expr)))
1265 for (sv = svars; sv; sv = sv->next)
1266 add_stmt_operand (&sv->var, s_ann, flags);
1270 add_stmt_operand (expr_p, s_ann, flags);
1274 case MISALIGNED_INDIRECT_REF:
1275 get_expr_operands (stmt, &TREE_OPERAND (expr, 1), flags);
1278 case ALIGN_INDIRECT_REF:
1280 get_indirect_ref_operands (stmt, expr, flags);
1283 case TARGET_MEM_REF:
1284 get_tmr_operands (stmt, expr, flags);
1288 case ARRAY_RANGE_REF:
1289 /* Treat array references as references to the virtual variable
1290 representing the array. The virtual variable for an ARRAY_REF
1291 is the VAR_DECL for the array. */
1293 /* Add the virtual variable for the ARRAY_REF to VDEFS or VUSES
1294 according to the value of IS_DEF. Recurse if the LHS of the
1295 ARRAY_REF node is not a regular variable. */
1296 if (SSA_VAR_P (TREE_OPERAND (expr, 0)))
1297 add_stmt_operand (expr_p, s_ann, flags);
1299 get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags);
1301 get_expr_operands (stmt, &TREE_OPERAND (expr, 1), opf_none);
1302 get_expr_operands (stmt, &TREE_OPERAND (expr, 2), opf_none);
1303 get_expr_operands (stmt, &TREE_OPERAND (expr, 3), opf_none);
1311 unsigned HOST_WIDE_INT offset, size;
1312 /* This component ref becomes an access to all of the subvariables
1313 it can touch, if we can determine that, but *NOT* the real one.
1314 If we can't determine which fields we could touch, the recursion
1315 will eventually get to a variable and add *all* of its subvars, or
1316 whatever is the minimum correct subset. */
1318 ref = okay_component_ref_for_subvars (expr, &offset, &size);
1321 subvar_t svars = get_subvars_for_var (ref);
1323 for (sv = svars; sv; sv = sv->next)
1326 if (overlap_subvar (offset, size, sv, &exact))
1329 flags &= ~opf_kill_def;
1330 add_stmt_operand (&sv->var, s_ann, flags);
1335 get_expr_operands (stmt, &TREE_OPERAND (expr, 0),
1336 flags & ~opf_kill_def);
1338 if (code == COMPONENT_REF)
1340 if (s_ann && TREE_THIS_VOLATILE (TREE_OPERAND (expr, 1)))
1341 s_ann->has_volatile_ops = true;
1342 get_expr_operands (stmt, &TREE_OPERAND (expr, 2), opf_none);
1346 case WITH_SIZE_EXPR:
1347 /* WITH_SIZE_EXPR is a pass-through reference to its first argument,
1348 and an rvalue reference to its second argument. */
1349 get_expr_operands (stmt, &TREE_OPERAND (expr, 1), opf_none);
1350 get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags);
1354 get_call_expr_operands (stmt, expr);
1359 get_expr_operands (stmt, &TREE_OPERAND (expr, 0), opf_none);
1360 get_expr_operands (stmt, &TREE_OPERAND (expr, 1), opf_none);
1361 get_expr_operands (stmt, &TREE_OPERAND (expr, 2), opf_none);
1369 get_expr_operands (stmt, &TREE_OPERAND (expr, 1), opf_none);
1371 op = TREE_OPERAND (expr, 0);
1372 if (TREE_CODE (op) == WITH_SIZE_EXPR)
1373 op = TREE_OPERAND (expr, 0);
1374 if (TREE_CODE (op) == ARRAY_REF
1375 || TREE_CODE (op) == ARRAY_RANGE_REF
1376 || TREE_CODE (op) == REALPART_EXPR
1377 || TREE_CODE (op) == IMAGPART_EXPR)
1378 subflags = opf_is_def;
1380 subflags = opf_is_def | opf_kill_def;
1382 get_expr_operands (stmt, &TREE_OPERAND (expr, 0), subflags);
1388 /* General aggregate CONSTRUCTORs have been decomposed, but they
1389 are still in use as the COMPLEX_EXPR equivalent for vectors. */
1392 for (t = TREE_OPERAND (expr, 0); t ; t = TREE_CHAIN (t))
1393 get_expr_operands (stmt, &TREE_VALUE (t), opf_none);
1398 case TRUTH_NOT_EXPR:
1400 case VIEW_CONVERT_EXPR:
1402 get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags);
1405 case TRUTH_AND_EXPR:
1407 case TRUTH_XOR_EXPR:
1413 tree op0 = TREE_OPERAND (expr, 0);
1414 tree op1 = TREE_OPERAND (expr, 1);
1416 /* If it would be profitable to swap the operands, then do so to
1417 canonicalize the statement, enabling better optimization.
1419 By placing canonicalization of such expressions here we
1420 transparently keep statements in canonical form, even
1421 when the statement is modified. */
1422 if (tree_swap_operands_p (op0, op1, false))
1424 /* For relationals we need to swap the operands
1425 and change the code. */
1431 TREE_SET_CODE (expr, swap_tree_comparison (code));
1432 swap_tree_operands (stmt,
1433 &TREE_OPERAND (expr, 0),
1434 &TREE_OPERAND (expr, 1));
1437 /* For a commutative operator we can just swap the operands. */
1438 else if (commutative_tree_code (code))
1440 swap_tree_operands (stmt,
1441 &TREE_OPERAND (expr, 0),
1442 &TREE_OPERAND (expr, 1));
1446 get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags);
1447 get_expr_operands (stmt, &TREE_OPERAND (expr, 1), flags);
1451 case REALIGN_LOAD_EXPR:
1453 get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags);
1454 get_expr_operands (stmt, &TREE_OPERAND (expr, 1), flags);
1455 get_expr_operands (stmt, &TREE_OPERAND (expr, 2), flags);
1464 /* Expressions that make no memory references. */
1468 if (class == tcc_unary)
1470 if (class == tcc_binary || class == tcc_comparison)
1472 if (class == tcc_constant || class == tcc_type)
1476 /* If we get here, something has gone wrong. */
1477 #ifdef ENABLE_CHECKING
1478 fprintf (stderr, "unhandled expression in get_expr_operands():\n");
1480 fputs ("\n", stderr);
1481 internal_error ("internal error");
1487 /* Scan operands in the ASM_EXPR stmt referred to in INFO. */
1490 get_asm_expr_operands (tree stmt)
1492 stmt_ann_t s_ann = stmt_ann (stmt);
1493 int noutputs = list_length (ASM_OUTPUTS (stmt));
1494 const char **oconstraints
1495 = (const char **) alloca ((noutputs) * sizeof (const char *));
1498 const char *constraint;
1499 bool allows_mem, allows_reg, is_inout;
1501 for (i=0, link = ASM_OUTPUTS (stmt); link; ++i, link = TREE_CHAIN (link))
1503 oconstraints[i] = constraint
1504 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
1505 parse_output_constraint (&constraint, i, 0, 0,
1506 &allows_mem, &allows_reg, &is_inout);
1508 /* This should have been split in gimplify_asm_expr. */
1509 gcc_assert (!allows_reg || !is_inout);
1511 /* Memory operands are addressable. Note that STMT needs the
1512 address of this operand. */
1513 if (!allows_reg && allows_mem)
1515 tree t = get_base_address (TREE_VALUE (link));
1516 if (t && DECL_P (t) && s_ann)
1517 add_to_addressable_set (t, &s_ann->addresses_taken);
1520 get_expr_operands (stmt, &TREE_VALUE (link), opf_is_def);
1523 for (link = ASM_INPUTS (stmt); link; link = TREE_CHAIN (link))
1526 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
1527 parse_input_constraint (&constraint, 0, 0, noutputs, 0,
1528 oconstraints, &allows_mem, &allows_reg);
1530 /* Memory operands are addressable. Note that STMT needs the
1531 address of this operand. */
1532 if (!allows_reg && allows_mem)
1534 tree t = get_base_address (TREE_VALUE (link));
1535 if (t && DECL_P (t) && s_ann)
1536 add_to_addressable_set (t, &s_ann->addresses_taken);
1539 get_expr_operands (stmt, &TREE_VALUE (link), 0);
1543 /* Clobber memory for asm ("" : : : "memory"); */
1544 for (link = ASM_CLOBBERS (stmt); link; link = TREE_CHAIN (link))
1545 if (strcmp (TREE_STRING_POINTER (TREE_VALUE (link)), "memory") == 0)
1550 /* Clobber all call-clobbered variables (or .GLOBAL_VAR if we
1551 decided to group them). */
1553 add_stmt_operand (&global_var, s_ann, opf_is_def);
1555 EXECUTE_IF_SET_IN_BITMAP (call_clobbered_vars, 0, i, bi)
1557 tree var = referenced_var (i);
1558 add_stmt_operand (&var, s_ann, opf_is_def | opf_non_specific);
1561 /* Now clobber all addressables. */
1562 EXECUTE_IF_SET_IN_BITMAP (addressable_vars, 0, i, bi)
1564 tree var = referenced_var (i);
1566 /* Subvars are explicitly represented in this list, so
1567 we don't need the original to be added to the clobber
1568 ops, but the original *will* be in this list because
1569 we keep the addressability of the original
1570 variable up-to-date so we don't screw up the rest of
1572 if (var_can_have_subvars (var)
1573 && get_subvars_for_var (var) != NULL)
1576 add_stmt_operand (&var, s_ann, opf_is_def | opf_non_specific);
1583 /* A subroutine of get_expr_operands to handle INDIRECT_REF,
1584 ALIGN_INDIRECT_REF and MISALIGNED_INDIRECT_REF. */
1587 get_indirect_ref_operands (tree stmt, tree expr, int flags)
1589 tree *pptr = &TREE_OPERAND (expr, 0);
1591 stmt_ann_t s_ann = stmt_ann (stmt);
1593 /* Stores into INDIRECT_REF operands are never killing definitions. */
1594 flags &= ~opf_kill_def;
1596 if (SSA_VAR_P (ptr))
1598 struct ptr_info_def *pi = NULL;
1600 /* If PTR has flow-sensitive points-to information, use it. */
1601 if (TREE_CODE (ptr) == SSA_NAME
1602 && (pi = SSA_NAME_PTR_INFO (ptr)) != NULL
1603 && pi->name_mem_tag)
1605 /* PTR has its own memory tag. Use it. */
1606 add_stmt_operand (&pi->name_mem_tag, s_ann, flags);
1610 /* If PTR is not an SSA_NAME or it doesn't have a name
1611 tag, use its type memory tag. */
1614 /* If we are emitting debugging dumps, display a warning if
1615 PTR is an SSA_NAME with no flow-sensitive alias
1616 information. That means that we may need to compute
1619 && TREE_CODE (ptr) == SSA_NAME
1623 "NOTE: no flow-sensitive alias info for ");
1624 print_generic_expr (dump_file, ptr, dump_flags);
1625 fprintf (dump_file, " in ");
1626 print_generic_stmt (dump_file, stmt, dump_flags);
1629 if (TREE_CODE (ptr) == SSA_NAME)
1630 ptr = SSA_NAME_VAR (ptr);
1631 v_ann = var_ann (ptr);
1632 if (v_ann->type_mem_tag)
1633 add_stmt_operand (&v_ann->type_mem_tag, s_ann, flags);
1637 /* If a constant is used as a pointer, we can't generate a real
1638 operand for it but we mark the statement volatile to prevent
1639 optimizations from messing things up. */
1640 else if (TREE_CODE (ptr) == INTEGER_CST)
1643 s_ann->has_volatile_ops = true;
1647 /* Everything else *should* have been folded elsewhere, but users
1648 are smarter than we in finding ways to write invalid code. We
1649 cannot just assert here. If we were absolutely certain that we
1650 do handle all valid cases, then we could just do nothing here.
1651 That seems optimistic, so attempt to do something logical... */
1652 else if ((TREE_CODE (ptr) == PLUS_EXPR || TREE_CODE (ptr) == MINUS_EXPR)
1653 && TREE_CODE (TREE_OPERAND (ptr, 0)) == ADDR_EXPR
1654 && TREE_CODE (TREE_OPERAND (ptr, 1)) == INTEGER_CST)
1656 /* Make sure we know the object is addressable. */
1657 pptr = &TREE_OPERAND (ptr, 0);
1658 add_stmt_operand (pptr, s_ann, 0);
1660 /* Mark the object itself with a VUSE. */
1661 pptr = &TREE_OPERAND (*pptr, 0);
1662 get_expr_operands (stmt, pptr, flags);
1666 /* Ok, this isn't even is_gimple_min_invariant. Something's broke. */
1670 /* Add a USE operand for the base pointer. */
1671 get_expr_operands (stmt, pptr, opf_none);
1674 /* A subroutine of get_expr_operands to handle TARGET_MEM_REF. */
1677 get_tmr_operands (tree stmt, tree expr, int flags)
1679 tree tag = TMR_TAG (expr);
1681 /* First record the real operands. */
1682 get_expr_operands (stmt, &TMR_BASE (expr), opf_none);
1683 get_expr_operands (stmt, &TMR_INDEX (expr), opf_none);
1685 /* MEM_REFs should never be killing. */
1686 flags &= ~opf_kill_def;
1688 if (TMR_SYMBOL (expr))
1690 stmt_ann_t ann = stmt_ann (stmt);
1691 add_to_addressable_set (TMR_SYMBOL (expr), &ann->addresses_taken);
1695 add_stmt_operand (&tag, stmt_ann (stmt), flags);
1697 /* Something weird, so ensure that we will be careful. */
1698 stmt_ann (stmt)->has_volatile_ops = true;
1701 /* A subroutine of get_expr_operands to handle CALL_EXPR. */
1704 get_call_expr_operands (tree stmt, tree expr)
1707 int call_flags = call_expr_flags (expr);
1709 /* If aliases have been computed already, add V_MAY_DEF or V_USE
1710 operands for all the symbols that have been found to be
1713 Note that if aliases have not been computed, the global effects
1714 of calls will not be included in the SSA web. This is fine
1715 because no optimizer should run before aliases have been
1716 computed. By not bothering with virtual operands for CALL_EXPRs
1717 we avoid adding superfluous virtual operands, which can be a
1718 significant compile time sink (See PR 15855). */
1719 if (aliases_computed_p
1720 && !bitmap_empty_p (call_clobbered_vars)
1721 && !(call_flags & ECF_NOVOPS))
1723 /* A 'pure' or a 'const' function never call-clobbers anything.
1724 A 'noreturn' function might, but since we don't return anyway
1725 there is no point in recording that. */
1726 if (TREE_SIDE_EFFECTS (expr)
1727 && !(call_flags & (ECF_PURE | ECF_CONST | ECF_NORETURN)))
1728 add_call_clobber_ops (stmt);
1729 else if (!(call_flags & ECF_CONST))
1730 add_call_read_ops (stmt);
1733 /* Find uses in the called function. */
1734 get_expr_operands (stmt, &TREE_OPERAND (expr, 0), opf_none);
1736 for (op = TREE_OPERAND (expr, 1); op; op = TREE_CHAIN (op))
1737 get_expr_operands (stmt, &TREE_VALUE (op), opf_none);
1739 get_expr_operands (stmt, &TREE_OPERAND (expr, 2), opf_none);
1744 /* Add *VAR_P to the appropriate operand array for INFO. FLAGS is as in
1745 get_expr_operands. If *VAR_P is a GIMPLE register, it will be added to
1746 the statement's real operands, otherwise it is added to virtual
1750 add_stmt_operand (tree *var_p, stmt_ann_t s_ann, int flags)
1759 /* If the operand is an ADDR_EXPR, add its operand to the list of
1760 variables that have had their address taken in this statement. */
1761 if (TREE_CODE (var) == ADDR_EXPR && s_ann)
1763 add_to_addressable_set (TREE_OPERAND (var, 0), &s_ann->addresses_taken);
1767 /* If the original variable is not a scalar, it will be added to the list
1768 of virtual operands. In that case, use its base symbol as the virtual
1769 variable representing it. */
1770 is_real_op = is_gimple_reg (var);
1771 if (!is_real_op && !DECL_P (var))
1772 var = get_virtual_var (var);
1774 /* If VAR is not a variable that we care to optimize, do nothing. */
1775 if (var == NULL_TREE || !SSA_VAR_P (var))
1778 sym = (TREE_CODE (var) == SSA_NAME ? SSA_NAME_VAR (var) : var);
1779 v_ann = var_ann (sym);
1781 /* Mark statements with volatile operands. Optimizers should back
1782 off from statements having volatile operands. */
1783 if (TREE_THIS_VOLATILE (sym) && s_ann)
1784 s_ann->has_volatile_ops = true;
1786 /* If the variable cannot be modified and this is a V_MAY_DEF change
1787 it into a VUSE. This happens when read-only variables are marked
1788 call-clobbered and/or aliased to writable variables. So we only
1789 check that this only happens on non-specific stores.
1791 Note that if this is a specific store, i.e. associated with a
1792 modify_expr, then we can't suppress the V_DEF, lest we run into
1793 validation problems.
1795 This can happen when programs cast away const, leaving us with a
1796 store to read-only memory. If the statement is actually executed
1797 at runtime, then the program is ill formed. If the statement is
1798 not executed then all is well. At the very least, we cannot ICE. */
1799 if ((flags & opf_non_specific) && unmodifiable_var_p (var))
1801 gcc_assert (!is_real_op);
1802 flags &= ~(opf_is_def | opf_kill_def);
1807 /* The variable is a GIMPLE register. Add it to real operands. */
1808 if (flags & opf_is_def)
1815 varray_type aliases;
1817 /* The variable is not a GIMPLE register. Add it (or its aliases) to
1818 virtual operands, unless the caller has specifically requested
1819 not to add virtual operands (used when adding operands inside an
1820 ADDR_EXPR expression). */
1821 if (flags & opf_no_vops)
1824 aliases = v_ann->may_aliases;
1826 if (aliases == NULL)
1828 /* The variable is not aliased or it is an alias tag. */
1829 if (flags & opf_is_def)
1831 if (flags & opf_kill_def)
1833 /* Only regular variables or struct fields may get a
1834 V_MUST_DEF operand. */
1835 gcc_assert (v_ann->mem_tag_kind == NOT_A_TAG
1836 || v_ann->mem_tag_kind == STRUCT_FIELD);
1837 /* V_MUST_DEF for non-aliased, non-GIMPLE register
1838 variable definitions. */
1839 append_v_must_def (var);
1843 /* Add a V_MAY_DEF for call-clobbered variables and
1845 append_v_may_def (var);
1851 if (s_ann && v_ann->is_alias_tag)
1852 s_ann->makes_aliased_loads = 1;
1859 /* The variable is aliased. Add its aliases to the virtual
1861 gcc_assert (VARRAY_ACTIVE_SIZE (aliases) != 0);
1863 if (flags & opf_is_def)
1865 /* If the variable is also an alias tag, add a virtual
1866 operand for it, otherwise we will miss representing
1867 references to the members of the variable's alias set.
1868 This fixes the bug in gcc.c-torture/execute/20020503-1.c. */
1869 if (v_ann->is_alias_tag)
1870 append_v_may_def (var);
1872 for (i = 0; i < VARRAY_ACTIVE_SIZE (aliases); i++)
1873 append_v_may_def (VARRAY_TREE (aliases, i));
1876 s_ann->makes_aliased_stores = 1;
1880 /* Similarly, append a virtual uses for VAR itself, when
1881 it is an alias tag. */
1882 if (v_ann->is_alias_tag)
1885 for (i = 0; i < VARRAY_ACTIVE_SIZE (aliases); i++)
1886 append_vuse (VARRAY_TREE (aliases, i));
1889 s_ann->makes_aliased_loads = 1;
1896 /* Add the base address of REF to the set *ADDRESSES_TAKEN. If
1897 *ADDRESSES_TAKEN is NULL, a new set is created. REF may be
1898 a single variable whose address has been taken or any other valid
1899 GIMPLE memory reference (structure reference, array, etc). If the
1900 base address of REF is a decl that has sub-variables, also add all
1901 of its sub-variables. */
1904 add_to_addressable_set (tree ref, bitmap *addresses_taken)
1909 gcc_assert (addresses_taken);
1911 /* Note that it is *NOT OKAY* to use the target of a COMPONENT_REF
1912 as the only thing we take the address of. If VAR is a structure,
1913 taking the address of a field means that the whole structure may
1914 be referenced using pointer arithmetic. See PR 21407 and the
1915 ensuing mailing list discussion. */
1916 var = get_base_address (ref);
1917 if (var && SSA_VAR_P (var))
1919 if (*addresses_taken == NULL)
1920 *addresses_taken = BITMAP_GGC_ALLOC ();
1922 if (var_can_have_subvars (var)
1923 && (svars = get_subvars_for_var (var)))
1926 for (sv = svars; sv; sv = sv->next)
1928 bitmap_set_bit (*addresses_taken, DECL_UID (sv->var));
1929 TREE_ADDRESSABLE (sv->var) = 1;
1934 bitmap_set_bit (*addresses_taken, DECL_UID (var));
1935 TREE_ADDRESSABLE (var) = 1;
1941 /* Add clobbering definitions for .GLOBAL_VAR or for each of the call
1942 clobbered variables in the function. */
1945 add_call_clobber_ops (tree stmt)
1951 stmt_ann_t s_ann = stmt_ann (stmt);
1952 struct stmt_ann_d empty_ann;
1954 /* Functions that are not const, pure or never return may clobber
1955 call-clobbered variables. */
1957 s_ann->makes_clobbering_call = true;
1959 /* If we created .GLOBAL_VAR earlier, just use it. See compute_may_aliases
1960 for the heuristic used to decide whether to create .GLOBAL_VAR or not. */
1963 add_stmt_operand (&global_var, s_ann, opf_is_def);
1967 /* If cache is valid, copy the elements into the build vectors. */
1968 if (ssa_call_clobbered_cache_valid)
1970 /* Process the caches in reverse order so we are always inserting at
1971 the head of the list. */
1972 for (i = VEC_length (tree, clobbered_vuses) - 1; i >=0; i--)
1974 t = VEC_index (tree, clobbered_vuses, i);
1975 gcc_assert (TREE_CODE (t) != SSA_NAME);
1976 var_ann (t)->in_vuse_list = 1;
1977 opbuild_append_virtual (&build_vuses, t);
1979 for (i = VEC_length (tree, clobbered_v_may_defs) - 1; i >= 0; i--)
1981 t = VEC_index (tree, clobbered_v_may_defs, i);
1982 gcc_assert (TREE_CODE (t) != SSA_NAME);
1983 var_ann (t)->in_v_may_def_list = 1;
1984 opbuild_append_virtual (&build_v_may_defs, t);
1988 s_ann->makes_aliased_loads = clobbered_aliased_loads;
1989 s_ann->makes_aliased_stores = clobbered_aliased_stores;
1994 memset (&empty_ann, 0, sizeof (struct stmt_ann_d));
1996 /* Add a V_MAY_DEF operand for every call clobbered variable. */
1997 EXECUTE_IF_SET_IN_BITMAP (call_clobbered_vars, 0, u, bi)
1999 tree var = referenced_var (u);
2000 if (unmodifiable_var_p (var))
2001 add_stmt_operand (&var, &empty_ann, opf_none);
2003 add_stmt_operand (&var, &empty_ann, opf_is_def | opf_non_specific);
2006 clobbered_aliased_loads = empty_ann.makes_aliased_loads;
2007 clobbered_aliased_stores = empty_ann.makes_aliased_stores;
2009 /* Set the flags for a stmt's annotation. */
2012 s_ann->makes_aliased_loads = empty_ann.makes_aliased_loads;
2013 s_ann->makes_aliased_stores = empty_ann.makes_aliased_stores;
2016 /* Prepare empty cache vectors. */
2017 VEC_truncate (tree, clobbered_vuses, 0);
2018 VEC_truncate (tree, clobbered_v_may_defs, 0);
2020 /* Now fill the clobbered cache with the values that have been found. */
2021 for (i = opbuild_first (&build_vuses);
2023 i = opbuild_next (&build_vuses, i))
2024 VEC_safe_push (tree, heap, clobbered_vuses,
2025 opbuild_elem_virtual (&build_vuses, i));
2027 gcc_assert (opbuild_num_elems (&build_vuses)
2028 == VEC_length (tree, clobbered_vuses));
2030 for (i = opbuild_first (&build_v_may_defs);
2032 i = opbuild_next (&build_v_may_defs, i))
2033 VEC_safe_push (tree, heap, clobbered_v_may_defs,
2034 opbuild_elem_virtual (&build_v_may_defs, i));
2036 gcc_assert (opbuild_num_elems (&build_v_may_defs)
2037 == VEC_length (tree, clobbered_v_may_defs));
2039 ssa_call_clobbered_cache_valid = true;
2043 /* Add VUSE operands for .GLOBAL_VAR or all call clobbered variables in the
2047 add_call_read_ops (tree stmt)
2053 stmt_ann_t s_ann = stmt_ann (stmt);
2054 struct stmt_ann_d empty_ann;
2056 /* if the function is not pure, it may reference memory. Add
2057 a VUSE for .GLOBAL_VAR if it has been created. See add_referenced_var
2058 for the heuristic used to decide whether to create .GLOBAL_VAR. */
2061 add_stmt_operand (&global_var, s_ann, opf_none);
2065 /* If cache is valid, copy the elements into the build vector. */
2066 if (ssa_ro_call_cache_valid)
2068 for (i = VEC_length (tree, ro_call_vuses) - 1; i >=0 ; i--)
2070 /* Process the caches in reverse order so we are always inserting at
2071 the head of the list. */
2072 t = VEC_index (tree, ro_call_vuses, i);
2073 gcc_assert (TREE_CODE (t) != SSA_NAME);
2074 var_ann (t)->in_vuse_list = 1;
2075 opbuild_append_virtual (&build_vuses, t);
2078 s_ann->makes_aliased_loads = ro_call_aliased_loads;
2082 memset (&empty_ann, 0, sizeof (struct stmt_ann_d));
2084 /* Add a VUSE for each call-clobbered variable. */
2085 EXECUTE_IF_SET_IN_BITMAP (call_clobbered_vars, 0, u, bi)
2087 tree var = referenced_var (u);
2088 add_stmt_operand (&var, &empty_ann, opf_none | opf_non_specific);
2091 ro_call_aliased_loads = empty_ann.makes_aliased_loads;
2093 s_ann->makes_aliased_loads = empty_ann.makes_aliased_loads;
2095 /* Prepare empty cache vectors. */
2096 VEC_truncate (tree, ro_call_vuses, 0);
2098 /* Now fill the clobbered cache with the values that have been found. */
2099 for (i = opbuild_first (&build_vuses);
2101 i = opbuild_next (&build_vuses, i))
2102 VEC_safe_push (tree, heap, ro_call_vuses,
2103 opbuild_elem_virtual (&build_vuses, i));
2105 gcc_assert (opbuild_num_elems (&build_vuses)
2106 == VEC_length (tree, ro_call_vuses));
2108 ssa_ro_call_cache_valid = true;
2112 /* Scan the immediate_use list for VAR making sure its linked properly.
2113 return RTUE iof there is a problem. */
2116 verify_imm_links (FILE *f, tree var)
2118 use_operand_p ptr, prev, list;
2121 gcc_assert (TREE_CODE (var) == SSA_NAME);
2123 list = &(SSA_NAME_IMM_USE_NODE (var));
2124 gcc_assert (list->use == NULL);
2126 if (list->prev == NULL)
2128 gcc_assert (list->next == NULL);
2134 for (ptr = list->next; ptr != list; )
2136 if (prev != ptr->prev)
2139 if (ptr->use == NULL)
2140 goto error; /* 2 roots, or SAFE guard node. */
2141 else if (*(ptr->use) != var)
2146 /* Avoid infinite loops. */
2147 if (count++ > 30000)
2151 /* Verify list in the other direction. */
2153 for (ptr = list->prev; ptr != list; )
2155 if (prev != ptr->next)
2169 if (ptr->stmt && stmt_modified_p (ptr->stmt))
2171 fprintf (f, " STMT MODIFIED. - <%p> ", (void *)ptr->stmt);
2172 print_generic_stmt (f, ptr->stmt, TDF_SLIM);
2174 fprintf (f, " IMM ERROR : (use_p : tree - %p:%p)", (void *)ptr,
2176 print_generic_expr (f, USE_FROM_PTR (ptr), TDF_SLIM);
2182 /* Dump all the immediate uses to FILE. */
2185 dump_immediate_uses_for (FILE *file, tree var)
2187 imm_use_iterator iter;
2188 use_operand_p use_p;
2190 gcc_assert (var && TREE_CODE (var) == SSA_NAME);
2192 print_generic_expr (file, var, TDF_SLIM);
2193 fprintf (file, " : -->");
2194 if (has_zero_uses (var))
2195 fprintf (file, " no uses.\n");
2197 if (has_single_use (var))
2198 fprintf (file, " single use.\n");
2200 fprintf (file, "%d uses.\n", num_imm_uses (var));
2202 FOR_EACH_IMM_USE_FAST (use_p, iter, var)
2204 if (!is_gimple_reg (USE_FROM_PTR (use_p)))
2205 print_generic_stmt (file, USE_STMT (use_p), TDF_VOPS);
2207 print_generic_stmt (file, USE_STMT (use_p), TDF_SLIM);
2209 fprintf(file, "\n");
2212 /* Dump all the immediate uses to FILE. */
2215 dump_immediate_uses (FILE *file)
2220 fprintf (file, "Immediate_uses: \n\n");
2221 for (x = 1; x < num_ssa_names; x++)
2226 dump_immediate_uses_for (file, var);
2231 /* Dump def-use edges on stderr. */
2234 debug_immediate_uses (void)
2236 dump_immediate_uses (stderr);
2239 /* Dump def-use edges on stderr. */
2242 debug_immediate_uses_for (tree var)
2244 dump_immediate_uses_for (stderr, var);
2246 #include "gt-tree-ssa-operands.h"