Daily bump.
[official-gcc.git] / gcc / tree-ssa-operands.c
blob47b4f1b930fd0a72289c75971ed4db28467f413c
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)
9 any later version.
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, 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
21 #include "config.h"
22 #include "system.h"
23 #include "coretypes.h"
24 #include "tm.h"
25 #include "tree.h"
26 #include "flags.h"
27 #include "function.h"
28 #include "diagnostic.h"
29 #include "errors.h"
30 #include "tree-flow.h"
31 #include "tree-inline.h"
32 #include "tree-pass.h"
33 #include "ggc.h"
34 #include "timevar.h"
36 #include "langhooks.h"
38 /* This file contains the code required to manage the operands cache of the
39 SSA optimizer. For every stmt, we maintain an operand cache in the stmt
40 annotation. This cache contains operands that will be of interest to
41 optimizers and other passes wishing to manipulate the IL.
43 The operand type are broken up into REAL and VIRTUAL operands. The real
44 operands are represented as pointers into the stmt's operand tree. Thus
45 any manipulation of the real operands will be reflected in the actual tree.
46 Virtual operands are represented solely in the cache, although the base
47 variable for the SSA_NAME may, or may not occur in the stmt's tree.
48 Manipulation of the virtual operands will not be reflected in the stmt tree.
50 The routines in this file are concerned with creating this operand cache
51 from a stmt tree.
53 get_stmt_operands() in the primary entry point.
55 The operand tree is the parsed by the various get_* routines which look
56 through the stmt tree for the occurrence of operands which may be of
57 interest, and calls are made to the append_* routines whenever one is
58 found. There are 5 of these routines, each representing one of the
59 5 types of operands. Defs, Uses, Virtual Uses, Virtual May Defs, and
60 Virtual Must Defs.
62 The append_* routines check for duplication, and simply keep a list of
63 unique objects for each operand type in the build_* extendable vectors.
65 Once the stmt tree is completely parsed, the finalize_ssa_operands()
66 routine is called, which proceeds to perform the finalization routine
67 on each of the 5 operand vectors which have been built up.
69 If the stmt had a previous operand cache, the finalization routines
70 attempt to match up the new operands with the old ones. If its a perfect
71 match, the old vector is simply reused. If it isn't a perfect match, then
72 a new vector is created and the new operands are placed there. For
73 virtual operands, if the previous cache had SSA_NAME version of a
74 variable, and that same variable occurs in the same operands cache, then
75 the new cache vector will also get the same SSA_NAME.
77 i.e., if a stmt had a VUSE of 'a_5', and 'a' occurs in the new operand
78 vector for VUSE, then the new vector will also be modified such that
79 it contains 'a_5' rather than 'a'.
84 /* Flags to describe operand properties in get_stmt_operands and helpers. */
86 /* By default, operands are loaded. */
87 #define opf_none 0
89 /* Operand is the target of an assignment expression or a
90 call-clobbered variable */
91 #define opf_is_def (1 << 0)
93 /* Operand is the target of an assignment expression. */
94 #define opf_kill_def (1 << 1)
96 /* No virtual operands should be created in the expression. This is used
97 when traversing ADDR_EXPR nodes which have different semantics than
98 other expressions. Inside an ADDR_EXPR node, the only operands that we
99 need to consider are indices into arrays. For instance, &a.b[i] should
100 generate a USE of 'i' but it should not generate a VUSE for 'a' nor a
101 VUSE for 'b'. */
102 #define opf_no_vops (1 << 2)
104 /* Array for building all the def operands. */
105 static GTY (()) varray_type build_defs;
107 /* Array for building all the use operands. */
108 static GTY (()) varray_type build_uses;
110 /* Array for building all the v_may_def operands. */
111 static GTY (()) varray_type build_v_may_defs;
113 /* Array for building all the vuse operands. */
114 static GTY (()) varray_type build_vuses;
116 /* Array for building all the v_must_def operands. */
117 static GTY (()) varray_type build_v_must_defs;
119 /* True if the operands for call clobbered vars are cached and valid. */
120 bool ssa_call_clobbered_cache_valid;
121 bool ssa_ro_call_cache_valid;
123 /* These arrays are the cached operand vectors for call clobbered calls. */
124 static GTY (()) varray_type clobbered_v_may_defs;
125 static GTY (()) varray_type clobbered_vuses;
126 static GTY (()) varray_type ro_call_vuses;
127 static bool clobbered_aliased_loads;
128 static bool clobbered_aliased_stores;
129 static bool ro_call_aliased_loads;
131 def_operand_p NULL_DEF_OPERAND_P = { NULL };
132 use_operand_p NULL_USE_OPERAND_P = { NULL };
134 static void note_addressable (tree, stmt_ann_t);
135 static void get_expr_operands (tree, tree *, int);
136 static void get_asm_expr_operands (tree);
137 static void get_indirect_ref_operands (tree, tree, int);
138 static void get_call_expr_operands (tree, tree);
139 static inline void append_def (tree *);
140 static inline void append_use (tree *);
141 static void append_v_may_def (tree);
142 static void append_v_must_def (tree);
143 static void add_call_clobber_ops (tree);
144 static void add_call_read_ops (tree);
145 static void add_stmt_operand (tree *, stmt_ann_t, int);
147 /* Return a vector of contiguous memory for NUM def operands. */
149 static inline def_optype
150 allocate_def_optype (unsigned num)
152 def_optype def_ops;
153 unsigned size;
154 size = sizeof (struct def_optype_d) + sizeof (tree *) * (num - 1);
155 def_ops = ggc_alloc (size);
156 def_ops->num_defs = num;
157 return def_ops;
161 /* Return a vector of contiguous memory for NUM use operands. */
163 static inline use_optype
164 allocate_use_optype (unsigned num)
166 use_optype use_ops;
167 unsigned size;
168 size = sizeof (struct use_optype_d) + sizeof (tree *) * (num - 1);
169 use_ops = ggc_alloc (size);
170 use_ops->num_uses = num;
171 return use_ops;
175 /* Return a vector of contiguous memory for NUM v_may_def operands. */
177 static inline v_may_def_optype
178 allocate_v_may_def_optype (unsigned num)
180 v_may_def_optype v_may_def_ops;
181 unsigned size;
182 size = sizeof (struct v_may_def_optype_d)
183 + sizeof (v_def_use_operand_type_t) * (num - 1);
184 v_may_def_ops = ggc_alloc (size);
185 v_may_def_ops->num_v_may_defs = num;
186 return v_may_def_ops;
190 /* Return a vector of contiguous memory for NUM v_use operands. */
192 static inline vuse_optype
193 allocate_vuse_optype (unsigned num)
195 vuse_optype vuse_ops;
196 unsigned size;
197 size = sizeof (struct vuse_optype_d) + sizeof (tree) * (num - 1);
198 vuse_ops = ggc_alloc (size);
199 vuse_ops->num_vuses = num;
200 return vuse_ops;
204 /* Return a vector of contiguous memory for NUM v_must_def operands. */
206 static inline v_must_def_optype
207 allocate_v_must_def_optype (unsigned num)
209 v_must_def_optype v_must_def_ops;
210 unsigned size;
211 size = sizeof (struct v_must_def_optype_d) + sizeof (v_def_use_operand_type_t) * (num - 1);
212 v_must_def_ops = ggc_alloc (size);
213 v_must_def_ops->num_v_must_defs = num;
214 return v_must_def_ops;
218 /* Free memory for USES. */
220 static inline void
221 free_uses (use_optype *uses)
223 if (*uses)
225 ggc_free (*uses);
226 *uses = NULL;
231 /* Free memory for DEFS. */
233 static inline void
234 free_defs (def_optype *defs)
236 if (*defs)
238 ggc_free (*defs);
239 *defs = NULL;
244 /* Free memory for VUSES. */
246 static inline void
247 free_vuses (vuse_optype *vuses)
249 if (*vuses)
251 ggc_free (*vuses);
252 *vuses = NULL;
257 /* Free memory for V_MAY_DEFS. */
259 static inline void
260 free_v_may_defs (v_may_def_optype *v_may_defs)
262 if (*v_may_defs)
264 ggc_free (*v_may_defs);
265 *v_may_defs = NULL;
270 /* Free memory for V_MUST_DEFS. */
272 static inline void
273 free_v_must_defs (v_must_def_optype *v_must_defs)
275 if (*v_must_defs)
277 ggc_free (*v_must_defs);
278 *v_must_defs = NULL;
283 /* Initialize the operand cache routines. */
285 void
286 init_ssa_operands (void)
288 VARRAY_TREE_PTR_INIT (build_defs, 5, "build defs");
289 VARRAY_TREE_PTR_INIT (build_uses, 10, "build uses");
290 VARRAY_TREE_INIT (build_v_may_defs, 10, "build v_may_defs");
291 VARRAY_TREE_INIT (build_vuses, 10, "build vuses");
292 VARRAY_TREE_INIT (build_v_must_defs, 10, "build v_must_defs");
296 /* Dispose of anything required by the operand routines. */
298 void
299 fini_ssa_operands (void)
301 ggc_free (build_defs);
302 ggc_free (build_uses);
303 ggc_free (build_v_may_defs);
304 ggc_free (build_vuses);
305 ggc_free (build_v_must_defs);
306 build_defs = NULL;
307 build_uses = NULL;
308 build_v_may_defs = NULL;
309 build_vuses = NULL;
310 build_v_must_defs = NULL;
311 if (clobbered_v_may_defs)
313 ggc_free (clobbered_v_may_defs);
314 ggc_free (clobbered_vuses);
315 clobbered_v_may_defs = NULL;
316 clobbered_vuses = NULL;
318 if (ro_call_vuses)
320 ggc_free (ro_call_vuses);
321 ro_call_vuses = NULL;
326 /* All the finalize_ssa_* routines do the work required to turn the build_
327 VARRAY into an operand_vector of the appropriate type. The original vector,
328 if any, is passed in for comparison and virtual SSA_NAME reuse. If the
329 old vector is reused, the pointer passed in is set to NULL so that
330 the memory is not freed when the old operands are freed. */
332 /* Return a new def operand vector for STMT, comparing to OLD_OPS_P. */
334 static def_optype
335 finalize_ssa_defs (def_optype *old_ops_p, tree stmt ATTRIBUTE_UNUSED)
337 unsigned num, x;
338 def_optype def_ops, old_ops;
339 bool build_diff;
341 num = VARRAY_ACTIVE_SIZE (build_defs);
342 if (num == 0)
343 return NULL;
345 /* There should only be a single real definition per assignment. */
346 gcc_assert (TREE_CODE (stmt) != MODIFY_EXPR || num <= 1);
348 old_ops = *old_ops_p;
350 /* Compare old vector and new array. */
351 build_diff = true;
352 if (old_ops && old_ops->num_defs == num)
354 build_diff = false;
355 for (x = 0; x < num; x++)
356 if (old_ops->defs[x].def != VARRAY_TREE_PTR (build_defs, x))
358 build_diff = true;
359 break;
363 if (!build_diff)
365 def_ops = old_ops;
366 *old_ops_p = NULL;
368 else
370 def_ops = allocate_def_optype (num);
371 for (x = 0; x < num ; x++)
372 def_ops->defs[x].def = VARRAY_TREE_PTR (build_defs, x);
375 VARRAY_POP_ALL (build_defs);
377 return def_ops;
381 /* Return a new use operand vector for STMT, comparing to OLD_OPS_P. */
383 static use_optype
384 finalize_ssa_uses (use_optype *old_ops_p, tree stmt ATTRIBUTE_UNUSED)
386 unsigned num, x;
387 use_optype use_ops, old_ops;
388 bool build_diff;
390 num = VARRAY_ACTIVE_SIZE (build_uses);
391 if (num == 0)
392 return NULL;
394 #ifdef ENABLE_CHECKING
396 unsigned x;
397 /* If the pointer to the operand is the statement itself, something is
398 wrong. It means that we are pointing to a local variable (the
399 initial call to get_stmt_operands does not pass a pointer to a
400 statement). */
401 for (x = 0; x < num; x++)
402 gcc_assert (*(VARRAY_TREE_PTR (build_uses, x)) != stmt);
404 #endif
405 old_ops = *old_ops_p;
407 /* Check if the old vector and the new array are the same. */
408 build_diff = true;
409 if (old_ops && old_ops->num_uses == num)
411 build_diff = false;
412 for (x = 0; x < num; x++)
413 if (old_ops->uses[x].use != VARRAY_TREE_PTR (build_uses, x))
415 build_diff = true;
416 break;
420 if (!build_diff)
422 use_ops = old_ops;
423 *old_ops_p = NULL;
425 else
427 use_ops = allocate_use_optype (num);
428 for (x = 0; x < num ; x++)
429 use_ops->uses[x].use = VARRAY_TREE_PTR (build_uses, x);
431 VARRAY_POP_ALL (build_uses);
433 return use_ops;
437 /* Return a new v_may_def operand vector for STMT, comparing to OLD_OPS_P. */
439 static v_may_def_optype
440 finalize_ssa_v_may_defs (v_may_def_optype *old_ops_p)
442 unsigned num, x, i, old_num;
443 v_may_def_optype v_may_def_ops, old_ops;
444 tree result, var;
445 bool build_diff;
447 num = VARRAY_ACTIVE_SIZE (build_v_may_defs);
448 if (num == 0)
449 return NULL;
451 old_ops = *old_ops_p;
453 /* Check if the old vector and the new array are the same. */
454 build_diff = true;
455 if (old_ops && old_ops->num_v_may_defs == num)
457 old_num = num;
458 build_diff = false;
459 for (x = 0; x < num; x++)
461 var = old_ops->v_may_defs[x].def;
462 if (TREE_CODE (var) == SSA_NAME)
463 var = SSA_NAME_VAR (var);
464 if (var != VARRAY_TREE (build_v_may_defs, x))
466 build_diff = true;
467 break;
471 else
472 old_num = (old_ops ? old_ops->num_v_may_defs : 0);
474 if (!build_diff)
476 v_may_def_ops = old_ops;
477 *old_ops_p = NULL;
479 else
481 v_may_def_ops = allocate_v_may_def_optype (num);
482 for (x = 0; x < num; x++)
484 var = VARRAY_TREE (build_v_may_defs, x);
485 /* Look for VAR in the old operands vector. */
486 for (i = 0; i < old_num; i++)
488 result = old_ops->v_may_defs[i].def;
489 if (TREE_CODE (result) == SSA_NAME)
490 result = SSA_NAME_VAR (result);
491 if (result == var)
493 v_may_def_ops->v_may_defs[x] = old_ops->v_may_defs[i];
494 break;
497 if (i == old_num)
499 v_may_def_ops->v_may_defs[x].def = var;
500 v_may_def_ops->v_may_defs[x].use = var;
505 /* Empty the V_MAY_DEF build vector after VUSES have been processed. */
507 return v_may_def_ops;
511 /* Clear the in_list bits and empty the build array for v_may_defs. */
513 static inline void
514 cleanup_v_may_defs (void)
516 unsigned x, num;
517 num = VARRAY_ACTIVE_SIZE (build_v_may_defs);
519 for (x = 0; x < num; x++)
521 tree t = VARRAY_TREE (build_v_may_defs, x);
522 var_ann_t ann = var_ann (t);
523 ann->in_v_may_def_list = 0;
525 VARRAY_POP_ALL (build_v_may_defs);
528 /* Return a new vuse operand vector, comparing to OLD_OPS_P. */
530 static vuse_optype
531 finalize_ssa_vuses (vuse_optype *old_ops_p)
533 unsigned num, x, i, num_v_may_defs, old_num;
534 vuse_optype vuse_ops, old_ops;
535 bool build_diff;
537 num = VARRAY_ACTIVE_SIZE (build_vuses);
538 if (num == 0)
540 cleanup_v_may_defs ();
541 return NULL;
544 /* Remove superfluous VUSE operands. If the statement already has a
545 V_MAY_DEF operation for a variable 'a', then a VUSE for 'a' is not
546 needed because V_MAY_DEFs imply a VUSE of the variable. For instance,
547 suppose that variable 'a' is aliased:
549 # VUSE <a_2>
550 # a_3 = V_MAY_DEF <a_2>
551 a = a + 1;
553 The VUSE <a_2> is superfluous because it is implied by the V_MAY_DEF
554 operation. */
556 num_v_may_defs = VARRAY_ACTIVE_SIZE (build_v_may_defs);
558 if (num_v_may_defs > 0)
560 size_t i;
561 tree vuse;
562 for (i = 0; i < VARRAY_ACTIVE_SIZE (build_vuses); i++)
564 vuse = VARRAY_TREE (build_vuses, i);
565 if (TREE_CODE (vuse) != SSA_NAME)
567 var_ann_t ann = var_ann (vuse);
568 ann->in_vuse_list = 0;
569 if (ann->in_v_may_def_list)
571 /* If we found a useless VUSE operand, remove it from the
572 operand array by replacing it with the last active element
573 in the operand array (unless the useless VUSE was the
574 last operand, in which case we simply remove it. */
575 if (i != VARRAY_ACTIVE_SIZE (build_vuses) - 1)
577 VARRAY_TREE (build_vuses, i)
578 = VARRAY_TREE (build_vuses,
579 VARRAY_ACTIVE_SIZE (build_vuses) - 1);
581 VARRAY_POP (build_vuses);
583 /* We want to rescan the element at this index, unless
584 this was the last element, in which case the loop
585 terminates. */
586 i--;
591 else
592 /* Clear out the in_list bits. */
593 for (x = 0; x < num; x++)
595 tree t = VARRAY_TREE (build_vuses, x);
596 if (TREE_CODE (t) != SSA_NAME)
598 var_ann_t ann = var_ann (t);
599 ann->in_vuse_list = 0;
604 num = VARRAY_ACTIVE_SIZE (build_vuses);
605 /* We could have reduced the size to zero now, however. */
606 if (num == 0)
608 cleanup_v_may_defs ();
609 return NULL;
612 old_ops = *old_ops_p;
614 /* Determine whether vuses is the same as the old vector. */
615 build_diff = true;
616 if (old_ops && old_ops->num_vuses == num)
618 old_num = num;
619 build_diff = false;
620 for (x = 0; x < num ; x++)
622 tree v;
623 v = old_ops->vuses[x];
624 if (TREE_CODE (v) == SSA_NAME)
625 v = SSA_NAME_VAR (v);
626 if (v != VARRAY_TREE (build_vuses, x))
628 build_diff = true;
629 break;
633 else
634 old_num = (old_ops ? old_ops->num_vuses : 0);
636 if (!build_diff)
638 vuse_ops = old_ops;
639 *old_ops_p = NULL;
641 else
643 vuse_ops = allocate_vuse_optype (num);
644 for (x = 0; x < num; x++)
646 tree result, var = VARRAY_TREE (build_vuses, x);
647 /* Look for VAR in the old vector, and use that SSA_NAME. */
648 for (i = 0; i < old_num; i++)
650 result = old_ops->vuses[i];
651 if (TREE_CODE (result) == SSA_NAME)
652 result = SSA_NAME_VAR (result);
653 if (result == var)
655 vuse_ops->vuses[x] = old_ops->vuses[i];
656 break;
659 if (i == old_num)
660 vuse_ops->vuses[x] = var;
664 /* The v_may_def build vector wasn't freed because we needed it here.
665 Free it now with the vuses build vector. */
666 VARRAY_POP_ALL (build_vuses);
667 cleanup_v_may_defs ();
669 return vuse_ops;
672 /* Return a new v_must_def operand vector for STMT, comparing to OLD_OPS_P. */
674 static v_must_def_optype
675 finalize_ssa_v_must_defs (v_must_def_optype *old_ops_p,
676 tree stmt ATTRIBUTE_UNUSED)
678 unsigned num, x, i, old_num = 0;
679 v_must_def_optype v_must_def_ops, old_ops;
680 bool build_diff;
682 num = VARRAY_ACTIVE_SIZE (build_v_must_defs);
683 if (num == 0)
684 return NULL;
686 /* There should only be a single V_MUST_DEF per assignment. */
687 gcc_assert (TREE_CODE (stmt) != MODIFY_EXPR || num <= 1);
689 old_ops = *old_ops_p;
691 /* Check if the old vector and the new array are the same. */
692 build_diff = true;
693 if (old_ops && old_ops->num_v_must_defs == num)
695 old_num = num;
696 build_diff = false;
697 for (x = 0; x < num; x++)
699 tree var = old_ops->v_must_defs[x].def;
700 if (TREE_CODE (var) == SSA_NAME)
701 var = SSA_NAME_VAR (var);
702 if (var != VARRAY_TREE (build_v_must_defs, x))
704 build_diff = true;
705 break;
709 else
710 old_num = (old_ops ? old_ops->num_v_must_defs : 0);
712 if (!build_diff)
714 v_must_def_ops = old_ops;
715 *old_ops_p = NULL;
717 else
719 v_must_def_ops = allocate_v_must_def_optype (num);
720 for (x = 0; x < num ; x++)
722 tree result, var = VARRAY_TREE (build_v_must_defs, x);
723 /* Look for VAR in the original vector. */
724 for (i = 0; i < old_num; i++)
726 result = old_ops->v_must_defs[i].def;
727 if (TREE_CODE (result) == SSA_NAME)
728 result = SSA_NAME_VAR (result);
729 if (result == var)
731 v_must_def_ops->v_must_defs[x].def = old_ops->v_must_defs[i].def;
732 v_must_def_ops->v_must_defs[x].use = old_ops->v_must_defs[i].use;
733 break;
736 if (i == old_num)
738 v_must_def_ops->v_must_defs[x].def = var;
739 v_must_def_ops->v_must_defs[x].use = var;
743 VARRAY_POP_ALL (build_v_must_defs);
745 return v_must_def_ops;
749 /* Finalize all the build vectors, fill the new ones into INFO. */
751 static inline void
752 finalize_ssa_stmt_operands (tree stmt, stmt_operands_p old_ops,
753 stmt_operands_p new_ops)
755 new_ops->def_ops = finalize_ssa_defs (&(old_ops->def_ops), stmt);
756 new_ops->use_ops = finalize_ssa_uses (&(old_ops->use_ops), stmt);
757 new_ops->v_must_def_ops
758 = finalize_ssa_v_must_defs (&(old_ops->v_must_def_ops), stmt);
759 new_ops->v_may_def_ops = finalize_ssa_v_may_defs (&(old_ops->v_may_def_ops));
760 new_ops->vuse_ops = finalize_ssa_vuses (&(old_ops->vuse_ops));
764 /* Start the process of building up operands vectors in INFO. */
766 static inline void
767 start_ssa_stmt_operands (void)
769 gcc_assert (VARRAY_ACTIVE_SIZE (build_defs) == 0);
770 gcc_assert (VARRAY_ACTIVE_SIZE (build_uses) == 0);
771 gcc_assert (VARRAY_ACTIVE_SIZE (build_vuses) == 0);
772 gcc_assert (VARRAY_ACTIVE_SIZE (build_v_may_defs) == 0);
773 gcc_assert (VARRAY_ACTIVE_SIZE (build_v_must_defs) == 0);
777 /* Add DEF_P to the list of pointers to operands. */
779 static inline void
780 append_def (tree *def_p)
782 VARRAY_PUSH_TREE_PTR (build_defs, def_p);
786 /* Add USE_P to the list of pointers to operands. */
788 static inline void
789 append_use (tree *use_p)
791 VARRAY_PUSH_TREE_PTR (build_uses, use_p);
795 /* Add a new virtual may def for variable VAR to the build array. */
797 static inline void
798 append_v_may_def (tree var)
800 var_ann_t ann = get_var_ann (var);
802 /* Don't allow duplicate entries. */
803 if (ann->in_v_may_def_list)
804 return;
805 ann->in_v_may_def_list = 1;
807 VARRAY_PUSH_TREE (build_v_may_defs, var);
811 /* Add VAR to the list of virtual uses. */
813 static inline void
814 append_vuse (tree var)
817 /* Don't allow duplicate entries. */
818 if (TREE_CODE (var) != SSA_NAME)
820 var_ann_t ann = get_var_ann (var);
822 if (ann->in_vuse_list || ann->in_v_may_def_list)
823 return;
824 ann->in_vuse_list = 1;
827 VARRAY_PUSH_TREE (build_vuses, var);
831 /* Add VAR to the list of virtual must definitions for INFO. */
833 static inline void
834 append_v_must_def (tree var)
836 unsigned i;
838 /* Don't allow duplicate entries. */
839 for (i = 0; i < VARRAY_ACTIVE_SIZE (build_v_must_defs); i++)
840 if (var == VARRAY_TREE (build_v_must_defs, i))
841 return;
843 VARRAY_PUSH_TREE (build_v_must_defs, var);
846 /* Create an operands cache for STMT, returning it in NEW_OPS. OLD_OPS are the
847 original operands, and if ANN is non-null, appropriate stmt flags are set
848 in the stmt's annotation. Note that some fields in old_ops may
849 change to NULL, although none of the memory they originally pointed to
850 will be destroyed. It is appropriate to call free_stmt_operands() on
851 the value returned in old_ops.
853 The rationale for this: Certain optimizations wish to examine the difference
854 between new_ops and old_ops after processing. If a set of operands don't
855 change, new_ops will simply assume the pointer in old_ops, and the old_ops
856 pointer will be set to NULL, indicating no memory needs to be cleared.
857 Usage might appear something like:
859 old_ops_copy = old_ops = stmt_ann(stmt)->operands;
860 build_ssa_operands (stmt, NULL, &old_ops, &new_ops);
861 <* compare old_ops_copy and new_ops *>
862 free_ssa_operands (old_ops); */
864 static void
865 build_ssa_operands (tree stmt, stmt_ann_t ann, stmt_operands_p old_ops,
866 stmt_operands_p new_ops)
868 enum tree_code code;
869 tree_ann_t saved_ann = stmt->common.ann;
871 /* Replace stmt's annotation with the one passed in for the duration
872 of the operand building process. This allows "fake" stmts to be built
873 and not be included in other data structures which can be built here. */
874 stmt->common.ann = (tree_ann_t) ann;
876 /* Initially assume that the statement has no volatile operands, nor
877 makes aliased loads or stores. */
878 if (ann)
880 ann->has_volatile_ops = false;
881 ann->makes_aliased_stores = false;
882 ann->makes_aliased_loads = false;
885 start_ssa_stmt_operands ();
887 code = TREE_CODE (stmt);
888 switch (code)
890 case MODIFY_EXPR:
891 /* First get operands from the RHS. For the LHS, we use a V_MAY_DEF if
892 either only part of LHS is modified or if the RHS might throw,
893 otherwise, use V_MUST_DEF.
895 ??? If it might throw, we should represent somehow that it is killed
896 on the fallthrough path. */
898 tree lhs = TREE_OPERAND (stmt, 0);
899 int lhs_flags = opf_is_def;
901 get_expr_operands (stmt, &TREE_OPERAND (stmt, 1), opf_none);
903 /* If the LHS is a VIEW_CONVERT_EXPR, it isn't changing whether
904 or not the entire LHS is modified; that depends on what's
905 inside the VIEW_CONVERT_EXPR. */
906 if (TREE_CODE (lhs) == VIEW_CONVERT_EXPR)
907 lhs = TREE_OPERAND (lhs, 0);
909 if (TREE_CODE (lhs) != ARRAY_REF && TREE_CODE (lhs) != ARRAY_RANGE_REF
910 && TREE_CODE (lhs) != COMPONENT_REF
911 && TREE_CODE (lhs) != BIT_FIELD_REF
912 && TREE_CODE (lhs) != REALPART_EXPR
913 && TREE_CODE (lhs) != IMAGPART_EXPR)
914 lhs_flags |= opf_kill_def;
916 get_expr_operands (stmt, &TREE_OPERAND (stmt, 0), lhs_flags);
918 break;
920 case COND_EXPR:
921 get_expr_operands (stmt, &COND_EXPR_COND (stmt), opf_none);
922 break;
924 case SWITCH_EXPR:
925 get_expr_operands (stmt, &SWITCH_COND (stmt), opf_none);
926 break;
928 case ASM_EXPR:
929 get_asm_expr_operands (stmt);
930 break;
932 case RETURN_EXPR:
933 get_expr_operands (stmt, &TREE_OPERAND (stmt, 0), opf_none);
934 break;
936 case GOTO_EXPR:
937 get_expr_operands (stmt, &GOTO_DESTINATION (stmt), opf_none);
938 break;
940 case LABEL_EXPR:
941 get_expr_operands (stmt, &LABEL_EXPR_LABEL (stmt), opf_none);
942 break;
944 /* These nodes contain no variable references. */
945 case BIND_EXPR:
946 case CASE_LABEL_EXPR:
947 case TRY_CATCH_EXPR:
948 case TRY_FINALLY_EXPR:
949 case EH_FILTER_EXPR:
950 case CATCH_EXPR:
951 case RESX_EXPR:
952 break;
954 default:
955 /* Notice that if get_expr_operands tries to use &STMT as the operand
956 pointer (which may only happen for USE operands), we will abort in
957 append_use. This default will handle statements like empty
958 statements, or CALL_EXPRs that may appear on the RHS of a statement
959 or as statements themselves. */
960 get_expr_operands (stmt, &stmt, opf_none);
961 break;
964 finalize_ssa_stmt_operands (stmt, old_ops, new_ops);
965 stmt->common.ann = saved_ann;
969 /* Free any operands vectors in OPS. */
971 static void
972 free_ssa_operands (stmt_operands_p ops)
974 if (ops->def_ops)
975 free_defs (&(ops->def_ops));
976 if (ops->use_ops)
977 free_uses (&(ops->use_ops));
978 if (ops->vuse_ops)
979 free_vuses (&(ops->vuse_ops));
980 if (ops->v_may_def_ops)
981 free_v_may_defs (&(ops->v_may_def_ops));
982 if (ops->v_must_def_ops)
983 free_v_must_defs (&(ops->v_must_def_ops));
987 /* Get the operands of statement STMT. Note that repeated calls to
988 get_stmt_operands for the same statement will do nothing until the
989 statement is marked modified by a call to modify_stmt(). */
991 void
992 get_stmt_operands (tree stmt)
994 stmt_ann_t ann;
995 stmt_operands_t old_operands;
997 /* The optimizers cannot handle statements that are nothing but a
998 _DECL. This indicates a bug in the gimplifier. */
999 gcc_assert (!SSA_VAR_P (stmt));
1001 ann = get_stmt_ann (stmt);
1003 /* If the statement has not been modified, the operands are still valid. */
1004 if (!ann->modified)
1005 return;
1007 timevar_push (TV_TREE_OPS);
1009 old_operands = ann->operands;
1010 memset (&(ann->operands), 0, sizeof (stmt_operands_t));
1012 build_ssa_operands (stmt, ann, &old_operands, &(ann->operands));
1013 free_ssa_operands (&old_operands);
1015 /* Clear the modified bit for STMT. Subsequent calls to
1016 get_stmt_operands for this statement will do nothing until the
1017 statement is marked modified by a call to modify_stmt(). */
1018 ann->modified = 0;
1020 timevar_pop (TV_TREE_OPS);
1024 /* Recursively scan the expression pointed by EXPR_P in statement referred to
1025 by INFO. FLAGS is one of the OPF_* constants modifying how to interpret the
1026 operands found. */
1028 static void
1029 get_expr_operands (tree stmt, tree *expr_p, int flags)
1031 enum tree_code code;
1032 enum tree_code_class class;
1033 tree expr = *expr_p;
1034 stmt_ann_t s_ann = stmt_ann (stmt);
1036 if (expr == NULL)
1037 return;
1039 code = TREE_CODE (expr);
1040 class = TREE_CODE_CLASS (code);
1042 switch (code)
1044 case ADDR_EXPR:
1045 /* We could have the address of a component, array member,
1046 etc which has interesting variable references. */
1047 /* Taking the address of a variable does not represent a
1048 reference to it, but the fact that the stmt takes its address will be
1049 of interest to some passes (e.g. alias resolution). */
1050 add_stmt_operand (expr_p, s_ann, 0);
1052 /* If the address is invariant, there may be no interesting variable
1053 references inside. */
1054 if (is_gimple_min_invariant (expr))
1055 return;
1057 /* There should be no VUSEs created, since the referenced objects are
1058 not really accessed. The only operands that we should find here
1059 are ARRAY_REF indices which will always be real operands (GIMPLE
1060 does not allow non-registers as array indices). */
1061 flags |= opf_no_vops;
1063 get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags);
1064 return;
1066 case SSA_NAME:
1067 case VAR_DECL:
1068 case PARM_DECL:
1069 case RESULT_DECL:
1070 case CONST_DECL:
1071 /* If we found a variable, add it to DEFS or USES depending
1072 on the operand flags. */
1073 add_stmt_operand (expr_p, s_ann, flags);
1074 return;
1076 case MISALIGNED_INDIRECT_REF:
1077 get_expr_operands (stmt, &TREE_OPERAND (expr, 1), flags);
1078 /* fall through */
1080 case ALIGN_INDIRECT_REF:
1081 case INDIRECT_REF:
1082 get_indirect_ref_operands (stmt, expr, flags);
1083 return;
1085 case ARRAY_REF:
1086 case ARRAY_RANGE_REF:
1087 /* Treat array references as references to the virtual variable
1088 representing the array. The virtual variable for an ARRAY_REF
1089 is the VAR_DECL for the array. */
1091 /* Add the virtual variable for the ARRAY_REF to VDEFS or VUSES
1092 according to the value of IS_DEF. Recurse if the LHS of the
1093 ARRAY_REF node is not a regular variable. */
1094 if (SSA_VAR_P (TREE_OPERAND (expr, 0)))
1095 add_stmt_operand (expr_p, s_ann, flags);
1096 else
1097 get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags);
1099 get_expr_operands (stmt, &TREE_OPERAND (expr, 1), opf_none);
1100 get_expr_operands (stmt, &TREE_OPERAND (expr, 2), opf_none);
1101 get_expr_operands (stmt, &TREE_OPERAND (expr, 3), opf_none);
1102 return;
1104 case COMPONENT_REF:
1105 case REALPART_EXPR:
1106 case IMAGPART_EXPR:
1107 /* Similarly to arrays, references to compound variables (complex
1108 types and structures/unions) are globbed.
1110 FIXME: This means that
1112 a.x = 6;
1113 a.y = 7;
1114 foo (a.x, a.y);
1116 will not be constant propagated because the two partial
1117 definitions to 'a' will kill each other. Note that SRA may be
1118 able to fix this problem if 'a' can be scalarized. */
1120 /* If the LHS of the compound reference is not a regular variable,
1121 recurse to keep looking for more operands in the subexpression. */
1122 if (SSA_VAR_P (TREE_OPERAND (expr, 0)))
1123 add_stmt_operand (expr_p, s_ann, flags);
1124 else
1125 get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags);
1127 if (code == COMPONENT_REF)
1128 get_expr_operands (stmt, &TREE_OPERAND (expr, 2), opf_none);
1129 return;
1131 case WITH_SIZE_EXPR:
1132 /* WITH_SIZE_EXPR is a pass-through reference to its first argument,
1133 and an rvalue reference to its second argument. */
1134 get_expr_operands (stmt, &TREE_OPERAND (expr, 1), opf_none);
1135 get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags);
1136 return;
1138 case CALL_EXPR:
1139 get_call_expr_operands (stmt, expr);
1140 return;
1142 case COND_EXPR:
1143 case VEC_COND_EXPR:
1144 get_expr_operands (stmt, &TREE_OPERAND (expr, 0), opf_none);
1145 get_expr_operands (stmt, &TREE_OPERAND (expr, 1), opf_none);
1146 get_expr_operands (stmt, &TREE_OPERAND (expr, 2), opf_none);
1147 return;
1149 case MODIFY_EXPR:
1151 int subflags;
1152 tree op;
1154 get_expr_operands (stmt, &TREE_OPERAND (expr, 1), opf_none);
1156 op = TREE_OPERAND (expr, 0);
1157 if (TREE_CODE (op) == WITH_SIZE_EXPR)
1158 op = TREE_OPERAND (expr, 0);
1159 if (TREE_CODE (op) == ARRAY_REF
1160 || TREE_CODE (op) == ARRAY_RANGE_REF
1161 || TREE_CODE (op) == COMPONENT_REF
1162 || TREE_CODE (op) == REALPART_EXPR
1163 || TREE_CODE (op) == IMAGPART_EXPR)
1164 subflags = opf_is_def;
1165 else
1166 subflags = opf_is_def | opf_kill_def;
1168 get_expr_operands (stmt, &TREE_OPERAND (expr, 0), subflags);
1169 return;
1172 case CONSTRUCTOR:
1174 /* General aggregate CONSTRUCTORs have been decomposed, but they
1175 are still in use as the COMPLEX_EXPR equivalent for vectors. */
1177 tree t;
1178 for (t = TREE_OPERAND (expr, 0); t ; t = TREE_CHAIN (t))
1179 get_expr_operands (stmt, &TREE_VALUE (t), opf_none);
1181 return;
1184 case TRUTH_NOT_EXPR:
1185 case BIT_FIELD_REF:
1186 case VIEW_CONVERT_EXPR:
1187 do_unary:
1188 get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags);
1189 return;
1191 case TRUTH_AND_EXPR:
1192 case TRUTH_OR_EXPR:
1193 case TRUTH_XOR_EXPR:
1194 case COMPOUND_EXPR:
1195 case OBJ_TYPE_REF:
1196 do_binary:
1198 tree op0 = TREE_OPERAND (expr, 0);
1199 tree op1 = TREE_OPERAND (expr, 1);
1201 /* If it would be profitable to swap the operands, then do so to
1202 canonicalize the statement, enabling better optimization.
1204 By placing canonicalization of such expressions here we
1205 transparently keep statements in canonical form, even
1206 when the statement is modified. */
1207 if (tree_swap_operands_p (op0, op1, false))
1209 /* For relationals we need to swap the operands
1210 and change the code. */
1211 if (code == LT_EXPR
1212 || code == GT_EXPR
1213 || code == LE_EXPR
1214 || code == GE_EXPR)
1216 TREE_SET_CODE (expr, swap_tree_comparison (code));
1217 TREE_OPERAND (expr, 0) = op1;
1218 TREE_OPERAND (expr, 1) = op0;
1221 /* For a commutative operator we can just swap the operands. */
1222 else if (commutative_tree_code (code))
1224 TREE_OPERAND (expr, 0) = op1;
1225 TREE_OPERAND (expr, 1) = op0;
1229 get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags);
1230 get_expr_operands (stmt, &TREE_OPERAND (expr, 1), flags);
1231 return;
1234 case REALIGN_LOAD_EXPR:
1236 get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags);
1237 get_expr_operands (stmt, &TREE_OPERAND (expr, 1), flags);
1238 get_expr_operands (stmt, &TREE_OPERAND (expr, 2), flags);
1239 return;
1242 case BLOCK:
1243 case FUNCTION_DECL:
1244 case EXC_PTR_EXPR:
1245 case FILTER_EXPR:
1246 case LABEL_DECL:
1247 /* Expressions that make no memory references. */
1248 return;
1250 default:
1251 if (class == tcc_unary)
1252 goto do_unary;
1253 if (class == tcc_binary || class == tcc_comparison)
1254 goto do_binary;
1255 if (class == tcc_constant || class == tcc_type)
1256 return;
1259 /* If we get here, something has gone wrong. */
1260 #ifdef ENABLE_CHECKING
1261 fprintf (stderr, "unhandled expression in get_expr_operands():\n");
1262 debug_tree (expr);
1263 fputs ("\n", stderr);
1264 internal_error ("internal error");
1265 #endif
1266 gcc_unreachable ();
1270 /* Scan operands in the ASM_EXPR stmt referred to in INFO. */
1272 static void
1273 get_asm_expr_operands (tree stmt)
1275 stmt_ann_t s_ann = stmt_ann (stmt);
1276 int noutputs = list_length (ASM_OUTPUTS (stmt));
1277 const char **oconstraints
1278 = (const char **) alloca ((noutputs) * sizeof (const char *));
1279 int i;
1280 tree link;
1281 const char *constraint;
1282 bool allows_mem, allows_reg, is_inout;
1284 for (i=0, link = ASM_OUTPUTS (stmt); link; ++i, link = TREE_CHAIN (link))
1286 oconstraints[i] = constraint
1287 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
1288 parse_output_constraint (&constraint, i, 0, 0,
1289 &allows_mem, &allows_reg, &is_inout);
1291 /* This should have been split in gimplify_asm_expr. */
1292 gcc_assert (!allows_reg || !is_inout);
1294 /* Memory operands are addressable. Note that STMT needs the
1295 address of this operand. */
1296 if (!allows_reg && allows_mem)
1298 tree t = get_base_address (TREE_VALUE (link));
1299 if (t && DECL_P (t))
1300 note_addressable (t, s_ann);
1303 get_expr_operands (stmt, &TREE_VALUE (link), opf_is_def);
1306 for (link = ASM_INPUTS (stmt); link; link = TREE_CHAIN (link))
1308 constraint
1309 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
1310 parse_input_constraint (&constraint, 0, 0, noutputs, 0,
1311 oconstraints, &allows_mem, &allows_reg);
1313 /* Memory operands are addressable. Note that STMT needs the
1314 address of this operand. */
1315 if (!allows_reg && allows_mem)
1317 tree t = get_base_address (TREE_VALUE (link));
1318 if (t && DECL_P (t))
1319 note_addressable (t, s_ann);
1322 get_expr_operands (stmt, &TREE_VALUE (link), 0);
1326 /* Clobber memory for asm ("" : : : "memory"); */
1327 for (link = ASM_CLOBBERS (stmt); link; link = TREE_CHAIN (link))
1328 if (strcmp (TREE_STRING_POINTER (TREE_VALUE (link)), "memory") == 0)
1330 unsigned i;
1331 bitmap_iterator bi;
1333 /* Clobber all call-clobbered variables (or .GLOBAL_VAR if we
1334 decided to group them). */
1335 if (global_var)
1336 add_stmt_operand (&global_var, s_ann, opf_is_def);
1337 else
1338 EXECUTE_IF_SET_IN_BITMAP (call_clobbered_vars, 0, i, bi)
1340 tree var = referenced_var (i);
1341 add_stmt_operand (&var, s_ann, opf_is_def);
1344 /* Now clobber all addressables. */
1345 EXECUTE_IF_SET_IN_BITMAP (addressable_vars, 0, i, bi)
1347 tree var = referenced_var (i);
1348 add_stmt_operand (&var, s_ann, opf_is_def);
1351 break;
1355 /* A subroutine of get_expr_operands to handle INDIRECT_REF,
1356 ALIGN_INDIRECT_REF and MISALIGNED_INDIRECT_REF. */
1358 static void
1359 get_indirect_ref_operands (tree stmt, tree expr, int flags)
1361 tree *pptr = &TREE_OPERAND (expr, 0);
1362 tree ptr = *pptr;
1363 stmt_ann_t s_ann = stmt_ann (stmt);
1365 /* Stores into INDIRECT_REF operands are never killing definitions. */
1366 flags &= ~opf_kill_def;
1368 if (SSA_VAR_P (ptr))
1370 struct ptr_info_def *pi = NULL;
1372 /* If PTR has flow-sensitive points-to information, use it. */
1373 if (TREE_CODE (ptr) == SSA_NAME
1374 && (pi = SSA_NAME_PTR_INFO (ptr)) != NULL
1375 && pi->name_mem_tag)
1377 /* PTR has its own memory tag. Use it. */
1378 add_stmt_operand (&pi->name_mem_tag, s_ann, flags);
1380 else
1382 /* If PTR is not an SSA_NAME or it doesn't have a name
1383 tag, use its type memory tag. */
1384 var_ann_t v_ann;
1386 /* If we are emitting debugging dumps, display a warning if
1387 PTR is an SSA_NAME with no flow-sensitive alias
1388 information. That means that we may need to compute
1389 aliasing again. */
1390 if (dump_file
1391 && TREE_CODE (ptr) == SSA_NAME
1392 && pi == NULL)
1394 fprintf (dump_file,
1395 "NOTE: no flow-sensitive alias info for ");
1396 print_generic_expr (dump_file, ptr, dump_flags);
1397 fprintf (dump_file, " in ");
1398 print_generic_stmt (dump_file, stmt, dump_flags);
1401 if (TREE_CODE (ptr) == SSA_NAME)
1402 ptr = SSA_NAME_VAR (ptr);
1403 v_ann = var_ann (ptr);
1404 if (v_ann->type_mem_tag)
1405 add_stmt_operand (&v_ann->type_mem_tag, s_ann, flags);
1409 /* If a constant is used as a pointer, we can't generate a real
1410 operand for it but we mark the statement volatile to prevent
1411 optimizations from messing things up. */
1412 else if (TREE_CODE (ptr) == INTEGER_CST)
1414 if (s_ann)
1415 s_ann->has_volatile_ops = true;
1416 return;
1419 /* Everything else *should* have been folded elsewhere, but users
1420 are smarter than we in finding ways to write invalid code. We
1421 cannot just abort here. If we were absolutely certain that we
1422 do handle all valid cases, then we could just do nothing here.
1423 That seems optimistic, so attempt to do something logical... */
1424 else if ((TREE_CODE (ptr) == PLUS_EXPR || TREE_CODE (ptr) == MINUS_EXPR)
1425 && TREE_CODE (TREE_OPERAND (ptr, 0)) == ADDR_EXPR
1426 && TREE_CODE (TREE_OPERAND (ptr, 1)) == INTEGER_CST)
1428 /* Make sure we know the object is addressable. */
1429 pptr = &TREE_OPERAND (ptr, 0);
1430 add_stmt_operand (pptr, s_ann, 0);
1432 /* Mark the object itself with a VUSE. */
1433 pptr = &TREE_OPERAND (*pptr, 0);
1434 get_expr_operands (stmt, pptr, flags);
1435 return;
1438 /* Ok, this isn't even is_gimple_min_invariant. Something's broke. */
1439 else
1440 gcc_unreachable ();
1442 /* Add a USE operand for the base pointer. */
1443 get_expr_operands (stmt, pptr, opf_none);
1446 /* A subroutine of get_expr_operands to handle CALL_EXPR. */
1448 static void
1449 get_call_expr_operands (tree stmt, tree expr)
1451 tree op;
1452 int call_flags = call_expr_flags (expr);
1454 /* If aliases have been computed already, add V_MAY_DEF or V_USE
1455 operands for all the symbols that have been found to be
1456 call-clobbered.
1458 Note that if aliases have not been computed, the global effects
1459 of calls will not be included in the SSA web. This is fine
1460 because no optimizer should run before aliases have been
1461 computed. By not bothering with virtual operands for CALL_EXPRs
1462 we avoid adding superfluous virtual operands, which can be a
1463 significant compile time sink (See PR 15855). */
1464 if (aliases_computed_p && !bitmap_empty_p (call_clobbered_vars))
1466 /* A 'pure' or a 'const' functions never call clobber anything.
1467 A 'noreturn' function might, but since we don't return anyway
1468 there is no point in recording that. */
1469 if (TREE_SIDE_EFFECTS (expr)
1470 && !(call_flags & (ECF_PURE | ECF_CONST | ECF_NORETURN)))
1471 add_call_clobber_ops (stmt);
1472 else if (!(call_flags & ECF_CONST))
1473 add_call_read_ops (stmt);
1476 /* Find uses in the called function. */
1477 get_expr_operands (stmt, &TREE_OPERAND (expr, 0), opf_none);
1479 for (op = TREE_OPERAND (expr, 1); op; op = TREE_CHAIN (op))
1480 get_expr_operands (stmt, &TREE_VALUE (op), opf_none);
1482 get_expr_operands (stmt, &TREE_OPERAND (expr, 2), opf_none);
1487 /* Add *VAR_P to the appropriate operand array for INFO. FLAGS is as in
1488 get_expr_operands. If *VAR_P is a GIMPLE register, it will be added to
1489 the statement's real operands, otherwise it is added to virtual
1490 operands. */
1492 static void
1493 add_stmt_operand (tree *var_p, stmt_ann_t s_ann, int flags)
1495 bool is_real_op;
1496 tree var, sym;
1497 var_ann_t v_ann;
1499 var = *var_p;
1500 STRIP_NOPS (var);
1502 /* If the operand is an ADDR_EXPR, add its operand to the list of
1503 variables that have had their address taken in this statement. */
1504 if (TREE_CODE (var) == ADDR_EXPR)
1506 note_addressable (TREE_OPERAND (var, 0), s_ann);
1507 return;
1510 /* If the original variable is not a scalar, it will be added to the list
1511 of virtual operands. In that case, use its base symbol as the virtual
1512 variable representing it. */
1513 is_real_op = is_gimple_reg (var);
1514 if (!is_real_op && !DECL_P (var))
1515 var = get_virtual_var (var);
1517 /* If VAR is not a variable that we care to optimize, do nothing. */
1518 if (var == NULL_TREE || !SSA_VAR_P (var))
1519 return;
1521 sym = (TREE_CODE (var) == SSA_NAME ? SSA_NAME_VAR (var) : var);
1522 v_ann = var_ann (sym);
1524 /* Mark statements with volatile operands. Optimizers should back
1525 off from statements having volatile operands. */
1526 if (TREE_THIS_VOLATILE (sym) && s_ann)
1527 s_ann->has_volatile_ops = true;
1529 if (is_real_op)
1531 /* The variable is a GIMPLE register. Add it to real operands. */
1532 if (flags & opf_is_def)
1533 append_def (var_p);
1534 else
1535 append_use (var_p);
1537 else
1539 varray_type aliases;
1541 /* The variable is not a GIMPLE register. Add it (or its aliases) to
1542 virtual operands, unless the caller has specifically requested
1543 not to add virtual operands (used when adding operands inside an
1544 ADDR_EXPR expression). */
1545 if (flags & opf_no_vops)
1546 return;
1548 aliases = v_ann->may_aliases;
1550 if (aliases == NULL)
1552 /* The variable is not aliased or it is an alias tag. */
1553 if (flags & opf_is_def)
1555 if (flags & opf_kill_def)
1557 /* Only regular variables may get a V_MUST_DEF
1558 operand. */
1559 gcc_assert (v_ann->mem_tag_kind == NOT_A_TAG);
1560 /* V_MUST_DEF for non-aliased, non-GIMPLE register
1561 variable definitions. */
1562 append_v_must_def (var);
1564 else
1566 /* Add a V_MAY_DEF for call-clobbered variables and
1567 memory tags. */
1568 append_v_may_def (var);
1571 else
1573 append_vuse (var);
1574 if (s_ann && v_ann->is_alias_tag)
1575 s_ann->makes_aliased_loads = 1;
1578 else
1580 size_t i;
1582 /* The variable is aliased. Add its aliases to the virtual
1583 operands. */
1584 gcc_assert (VARRAY_ACTIVE_SIZE (aliases) != 0);
1586 if (flags & opf_is_def)
1588 /* If the variable is also an alias tag, add a virtual
1589 operand for it, otherwise we will miss representing
1590 references to the members of the variable's alias set.
1591 This fixes the bug in gcc.c-torture/execute/20020503-1.c. */
1592 if (v_ann->is_alias_tag)
1593 append_v_may_def (var);
1595 for (i = 0; i < VARRAY_ACTIVE_SIZE (aliases); i++)
1596 append_v_may_def (VARRAY_TREE (aliases, i));
1598 if (s_ann)
1599 s_ann->makes_aliased_stores = 1;
1601 else
1603 /* Similarly, append a virtual uses for VAR itself, when
1604 it is an alias tag. */
1605 if (v_ann->is_alias_tag)
1606 append_vuse (var);
1608 for (i = 0; i < VARRAY_ACTIVE_SIZE (aliases); i++)
1609 append_vuse (VARRAY_TREE (aliases, i));
1611 if (s_ann)
1612 s_ann->makes_aliased_loads = 1;
1619 /* Record that VAR had its address taken in the statement with annotations
1620 S_ANN. */
1622 static void
1623 note_addressable (tree var, stmt_ann_t s_ann)
1625 if (!s_ann)
1626 return;
1628 var = get_base_address (var);
1629 if (var && SSA_VAR_P (var))
1631 if (s_ann->addresses_taken == NULL)
1632 s_ann->addresses_taken = BITMAP_GGC_ALLOC ();
1633 bitmap_set_bit (s_ann->addresses_taken, var_ann (var)->uid);
1638 /* Add clobbering definitions for .GLOBAL_VAR or for each of the call
1639 clobbered variables in the function. */
1641 static void
1642 add_call_clobber_ops (tree stmt)
1644 unsigned i;
1645 tree t;
1646 bitmap_iterator bi;
1647 stmt_ann_t s_ann = stmt_ann (stmt);
1648 struct stmt_ann_d empty_ann;
1650 /* Functions that are not const, pure or never return may clobber
1651 call-clobbered variables. */
1652 if (s_ann)
1653 s_ann->makes_clobbering_call = true;
1655 /* If we created .GLOBAL_VAR earlier, just use it. See compute_may_aliases
1656 for the heuristic used to decide whether to create .GLOBAL_VAR or not. */
1657 if (global_var)
1659 add_stmt_operand (&global_var, s_ann, opf_is_def);
1660 return;
1663 /* If cache is valid, copy the elements into the build vectors. */
1664 if (ssa_call_clobbered_cache_valid)
1666 for (i = 0; i < VARRAY_ACTIVE_SIZE (clobbered_vuses); i++)
1668 t = VARRAY_TREE (clobbered_vuses, i);
1669 gcc_assert (TREE_CODE (t) != SSA_NAME);
1670 var_ann (t)->in_vuse_list = 1;
1671 VARRAY_PUSH_TREE (build_vuses, t);
1673 for (i = 0; i < VARRAY_ACTIVE_SIZE (clobbered_v_may_defs); i++)
1675 t = VARRAY_TREE (clobbered_v_may_defs, i);
1676 gcc_assert (TREE_CODE (t) != SSA_NAME);
1677 var_ann (t)->in_v_may_def_list = 1;
1678 VARRAY_PUSH_TREE (build_v_may_defs, t);
1680 if (s_ann)
1682 s_ann->makes_aliased_loads = clobbered_aliased_loads;
1683 s_ann->makes_aliased_stores = clobbered_aliased_stores;
1685 return;
1688 memset (&empty_ann, 0, sizeof (struct stmt_ann_d));
1690 /* Add a V_MAY_DEF operand for every call clobbered variable. */
1691 EXECUTE_IF_SET_IN_BITMAP (call_clobbered_vars, 0, i, bi)
1693 tree var = referenced_var (i);
1694 if (TREE_READONLY (var)
1695 && (TREE_STATIC (var) || DECL_EXTERNAL (var)))
1696 add_stmt_operand (&var, &empty_ann, opf_none);
1697 else
1698 add_stmt_operand (&var, &empty_ann, opf_is_def);
1701 clobbered_aliased_loads = empty_ann.makes_aliased_loads;
1702 clobbered_aliased_stores = empty_ann.makes_aliased_stores;
1704 /* Set the flags for a stmt's annotation. */
1705 if (s_ann)
1707 s_ann->makes_aliased_loads = empty_ann.makes_aliased_loads;
1708 s_ann->makes_aliased_stores = empty_ann.makes_aliased_stores;
1711 /* Prepare empty cache vectors. */
1712 if (clobbered_v_may_defs)
1714 VARRAY_POP_ALL (clobbered_vuses);
1715 VARRAY_POP_ALL (clobbered_v_may_defs);
1717 else
1719 VARRAY_TREE_INIT (clobbered_v_may_defs, 10, "clobbered_v_may_defs");
1720 VARRAY_TREE_INIT (clobbered_vuses, 10, "clobbered_vuses");
1723 /* Now fill the clobbered cache with the values that have been found. */
1724 for (i = 0; i < VARRAY_ACTIVE_SIZE (build_vuses); i++)
1725 VARRAY_PUSH_TREE (clobbered_vuses, VARRAY_TREE (build_vuses, i));
1726 for (i = 0; i < VARRAY_ACTIVE_SIZE (build_v_may_defs); i++)
1727 VARRAY_PUSH_TREE (clobbered_v_may_defs, VARRAY_TREE (build_v_may_defs, i));
1729 ssa_call_clobbered_cache_valid = true;
1733 /* Add VUSE operands for .GLOBAL_VAR or all call clobbered variables in the
1734 function. */
1736 static void
1737 add_call_read_ops (tree stmt)
1739 unsigned i;
1740 tree t;
1741 bitmap_iterator bi;
1742 stmt_ann_t s_ann = stmt_ann (stmt);
1743 struct stmt_ann_d empty_ann;
1745 /* if the function is not pure, it may reference memory. Add
1746 a VUSE for .GLOBAL_VAR if it has been created. See add_referenced_var
1747 for the heuristic used to decide whether to create .GLOBAL_VAR. */
1748 if (global_var)
1750 add_stmt_operand (&global_var, s_ann, opf_none);
1751 return;
1754 /* If cache is valid, copy the elements into the build vector. */
1755 if (ssa_ro_call_cache_valid)
1757 for (i = 0; i < VARRAY_ACTIVE_SIZE (ro_call_vuses); i++)
1759 t = VARRAY_TREE (ro_call_vuses, i);
1760 gcc_assert (TREE_CODE (t) != SSA_NAME);
1761 var_ann (t)->in_vuse_list = 1;
1762 VARRAY_PUSH_TREE (build_vuses, t);
1764 if (s_ann)
1765 s_ann->makes_aliased_loads = ro_call_aliased_loads;
1766 return;
1769 memset (&empty_ann, 0, sizeof (struct stmt_ann_d));
1771 /* Add a VUSE for each call-clobbered variable. */
1772 EXECUTE_IF_SET_IN_BITMAP (call_clobbered_vars, 0, i, bi)
1774 tree var = referenced_var (i);
1775 add_stmt_operand (&var, &empty_ann, opf_none);
1778 ro_call_aliased_loads = empty_ann.makes_aliased_loads;
1779 if (s_ann)
1780 s_ann->makes_aliased_loads = empty_ann.makes_aliased_loads;
1782 /* Prepare empty cache vectors. */
1783 if (ro_call_vuses)
1784 VARRAY_POP_ALL (ro_call_vuses);
1785 else
1786 VARRAY_TREE_INIT (ro_call_vuses, 10, "ro_call_vuses");
1788 /* Now fill the clobbered cache with the values that have been found. */
1789 for (i = 0; i < VARRAY_ACTIVE_SIZE (build_vuses); i++)
1790 VARRAY_PUSH_TREE (ro_call_vuses, VARRAY_TREE (build_vuses, i));
1792 ssa_ro_call_cache_valid = true;
1795 /* Copies virtual operands from SRC to DST. */
1797 void
1798 copy_virtual_operands (tree dst, tree src)
1800 unsigned i;
1801 vuse_optype vuses = STMT_VUSE_OPS (src);
1802 v_may_def_optype v_may_defs = STMT_V_MAY_DEF_OPS (src);
1803 v_must_def_optype v_must_defs = STMT_V_MUST_DEF_OPS (src);
1804 vuse_optype *vuses_new = &stmt_ann (dst)->operands.vuse_ops;
1805 v_may_def_optype *v_may_defs_new = &stmt_ann (dst)->operands.v_may_def_ops;
1806 v_must_def_optype *v_must_defs_new = &stmt_ann (dst)->operands.v_must_def_ops;
1808 if (vuses)
1810 *vuses_new = allocate_vuse_optype (NUM_VUSES (vuses));
1811 for (i = 0; i < NUM_VUSES (vuses); i++)
1812 SET_VUSE_OP (*vuses_new, i, VUSE_OP (vuses, i));
1815 if (v_may_defs)
1817 *v_may_defs_new = allocate_v_may_def_optype (NUM_V_MAY_DEFS (v_may_defs));
1818 for (i = 0; i < NUM_V_MAY_DEFS (v_may_defs); i++)
1820 SET_V_MAY_DEF_OP (*v_may_defs_new, i, V_MAY_DEF_OP (v_may_defs, i));
1821 SET_V_MAY_DEF_RESULT (*v_may_defs_new, i,
1822 V_MAY_DEF_RESULT (v_may_defs, i));
1826 if (v_must_defs)
1828 *v_must_defs_new = allocate_v_must_def_optype (NUM_V_MUST_DEFS (v_must_defs));
1829 for (i = 0; i < NUM_V_MUST_DEFS (v_must_defs); i++)
1831 SET_V_MUST_DEF_RESULT (*v_must_defs_new, i, V_MUST_DEF_RESULT (v_must_defs, i));
1832 SET_V_MUST_DEF_KILL (*v_must_defs_new, i, V_MUST_DEF_KILL (v_must_defs, i));
1838 /* Specifically for use in DOM's expression analysis. Given a store, we
1839 create an artificial stmt which looks like a load from the store, this can
1840 be used to eliminate redundant loads. OLD_OPS are the operands from the
1841 store stmt, and NEW_STMT is the new load which represents a load of the
1842 values stored. */
1844 void
1845 create_ssa_artficial_load_stmt (stmt_operands_p old_ops, tree new_stmt)
1847 stmt_ann_t ann;
1848 tree op;
1849 stmt_operands_t tmp;
1850 unsigned j;
1852 memset (&tmp, 0, sizeof (stmt_operands_t));
1853 ann = get_stmt_ann (new_stmt);
1855 /* Free operands just in case is was an existing stmt. */
1856 free_ssa_operands (&(ann->operands));
1858 build_ssa_operands (new_stmt, NULL, &tmp, &(ann->operands));
1859 free_vuses (&(ann->operands.vuse_ops));
1860 free_v_may_defs (&(ann->operands.v_may_def_ops));
1861 free_v_must_defs (&(ann->operands.v_must_def_ops));
1863 /* For each VDEF on the original statement, we want to create a
1864 VUSE of the V_MAY_DEF result or V_MUST_DEF op on the new
1865 statement. */
1866 for (j = 0; j < NUM_V_MAY_DEFS (old_ops->v_may_def_ops); j++)
1868 op = V_MAY_DEF_RESULT (old_ops->v_may_def_ops, j);
1869 append_vuse (op);
1872 for (j = 0; j < NUM_V_MUST_DEFS (old_ops->v_must_def_ops); j++)
1874 op = V_MUST_DEF_RESULT (old_ops->v_must_def_ops, j);
1875 append_vuse (op);
1878 /* Now set the vuses for this new stmt. */
1879 ann->operands.vuse_ops = finalize_ssa_vuses (&(tmp.vuse_ops));
1882 #include "gt-tree-ssa-operands.h"