1 /* SSA operands management for trees.
2 Copyright (C) 2003, 2004 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, 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
23 #include "coretypes.h"
28 #include "diagnostic.h"
30 #include "tree-flow.h"
31 #include "tree-inline.h"
32 #include "tree-pass.h"
37 #include "langhooks.h"
39 /* This file contains the code required to manage the operands cache of the
40 SSA optimizer. For every stmt, we maintain an operand cache in the stmt
41 annotation. This cache contains operands that will be of interest to
42 optimizers and other passes wishing to manipulate the IL.
44 The operand type are broken up into REAL and VIRTUAL operands. The real
45 operands are represented as pointers into the stmt's operand tree. Thus
46 any manipulation of the real operands will be reflected in the actual tree.
47 Virtual operands are represented solely in the cache, although the base
48 variable for the SSA_NAME may, or may not occur in the stmt's tree.
49 Manipulation of the virtual operands will not be reflected in the stmt tree.
51 The routines in this file are concerned with creating this operand cache
54 get_stmt_operands() in the primary entry point.
56 The operand tree is the parsed by the various get_* routines which look
57 through the stmt tree for the occurrence of operands which may be of
58 interest, and calls are made to the append_* routines whenever one is
59 found. There are 5 of these routines, each representing one of the
60 5 types of operands. Defs, Uses, Virtual Uses, Virtual May Defs, and
63 The append_* routines check for duplication, and simply keep a list of
64 unique objects for each operand type in the build_* extendable vectors.
66 Once the stmt tree is completely parsed, the finalize_ssa_operands()
67 routine is called, which proceeds to perform the finalization routine
68 on each of the 5 operand vectors which have been built up.
70 If the stmt had a previous operand cache, the finalization routines
71 attempt to match up the new operands with the old ones. If its a perfect
72 match, the old vector is simply reused. If it isn't a perfect match, then
73 a new vector is created and the new operands are placed there. For
74 virtual operands, if the previous cache had SSA_NAME version of a
75 variable, and that same variable occurs in the same operands cache, then
76 the new cache vector will also get the same SSA_NAME.
78 i.e., if a stmt had a VUSE of 'a_5', and 'a' occurs in the new operand
79 vector for VUSE, then the new vector will also be modified such that
80 it contains 'a_5' rather than 'a'.
85 /* Flags to describe operand properties in get_stmt_operands and helpers. */
87 /* By default, operands are loaded. */
90 /* Operand is the target of an assignment expression or a
91 call-clobbered variable */
92 #define opf_is_def (1 << 0)
94 /* Operand is the target of an assignment expression. */
95 #define opf_kill_def (1 << 1)
97 /* No virtual operands should be created in the expression. This is used
98 when traversing ADDR_EXPR nodes which have different semantics than
99 other expressions. Inside an ADDR_EXPR node, the only operands that we
100 need to consider are indices into arrays. For instance, &a.b[i] should
101 generate a USE of 'i' but it should not generate a VUSE for 'a' nor a
103 #define opf_no_vops (1 << 2)
105 /* Array for building all the def operands. */
106 static GTY (()) varray_type build_defs
;
108 /* Array for building all the use operands. */
109 static GTY (()) varray_type build_uses
;
111 /* Array for building all the v_may_def operands. */
112 static GTY (()) varray_type build_v_may_defs
;
114 /* Array for building all the vuse operands. */
115 static GTY (()) varray_type build_vuses
;
117 /* Array for building all the v_must_def operands. */
118 static GTY (()) varray_type build_v_must_defs
;
121 #ifdef ENABLE_CHECKING
122 /* Used to make sure operand construction is working on the proper stmt. */
123 tree check_build_stmt
;
126 def_operand_p NULL_DEF_OPERAND_P
= { NULL
};
127 use_operand_p NULL_USE_OPERAND_P
= { NULL
};
129 static void note_addressable (tree
, stmt_ann_t
);
130 static void get_expr_operands (tree
, tree
*, int);
131 static void get_asm_expr_operands (tree
);
132 static void get_indirect_ref_operands (tree
, tree
, int);
133 static void get_call_expr_operands (tree
, tree
);
134 static inline void append_def (tree
*);
135 static inline void append_use (tree
*);
136 static void append_v_may_def (tree
);
137 static void append_v_must_def (tree
);
138 static void add_call_clobber_ops (tree
, tree
);
139 static void add_call_read_ops (tree
, tree
);
140 static void add_stmt_operand (tree
*, tree
, int);
142 /* Return a vector of contiguous memory for NUM def operands. */
144 static inline def_optype
145 allocate_def_optype (unsigned num
)
149 size
= sizeof (struct def_optype_d
) + sizeof (tree
*) * (num
- 1);
150 def_ops
= ggc_alloc (size
);
151 def_ops
->num_defs
= num
;
156 /* Return a vector of contiguous memory for NUM use operands. */
158 static inline use_optype
159 allocate_use_optype (unsigned num
)
163 size
= sizeof (struct use_optype_d
) + sizeof (tree
*) * (num
- 1);
164 use_ops
= ggc_alloc (size
);
165 use_ops
->num_uses
= num
;
170 /* Return a vector of contiguous memory for NUM v_may_def operands. */
172 static inline v_may_def_optype
173 allocate_v_may_def_optype (unsigned num
)
175 v_may_def_optype v_may_def_ops
;
177 size
= sizeof (struct v_may_def_optype_d
)
178 + sizeof (v_may_def_operand_type_t
) * (num
- 1);
179 v_may_def_ops
= ggc_alloc (size
);
180 v_may_def_ops
->num_v_may_defs
= num
;
181 return v_may_def_ops
;
185 /* Return a vector of contiguous memory for NUM v_use operands. */
187 static inline vuse_optype
188 allocate_vuse_optype (unsigned num
)
190 vuse_optype vuse_ops
;
192 size
= sizeof (struct vuse_optype_d
) + sizeof (tree
) * (num
- 1);
193 vuse_ops
= ggc_alloc (size
);
194 vuse_ops
->num_vuses
= num
;
199 /* Return a vector of contiguous memory for NUM v_must_def operands. */
201 static inline v_must_def_optype
202 allocate_v_must_def_optype (unsigned num
)
204 v_must_def_optype v_must_def_ops
;
206 size
= sizeof (struct v_must_def_optype_d
) + sizeof (tree
) * (num
- 1);
207 v_must_def_ops
= ggc_alloc (size
);
208 v_must_def_ops
->num_v_must_defs
= num
;
209 return v_must_def_ops
;
213 /* Free memory for USES. */
216 free_uses (use_optype
*uses
)
226 /* Free memory for DEFS. */
229 free_defs (def_optype
*defs
)
239 /* Free memory for VUSES. */
242 free_vuses (vuse_optype
*vuses
)
252 /* Free memory for V_MAY_DEFS. */
255 free_v_may_defs (v_may_def_optype
*v_may_defs
)
259 ggc_free (*v_may_defs
);
265 /* Free memory for V_MUST_DEFS. */
268 free_v_must_defs (v_must_def_optype
*v_must_defs
)
272 ggc_free (*v_must_defs
);
278 /* Initialize the operand cache routines. */
281 init_ssa_operands (void)
283 VARRAY_TREE_PTR_INIT (build_defs
, 5, "build defs");
284 VARRAY_TREE_PTR_INIT (build_uses
, 10, "build uses");
285 VARRAY_TREE_INIT (build_v_may_defs
, 10, "build v_may_defs");
286 VARRAY_TREE_INIT (build_vuses
, 10, "build vuses");
287 VARRAY_TREE_INIT (build_v_must_defs
, 10, "build v_must_defs");
291 /* Dispose of anything required by the operand routines. */
294 fini_ssa_operands (void)
296 ggc_free (build_defs
);
297 ggc_free (build_uses
);
298 ggc_free (build_v_may_defs
);
299 ggc_free (build_vuses
);
300 ggc_free (build_v_must_defs
);
303 build_v_may_defs
= NULL
;
305 build_v_must_defs
= NULL
;
309 /* All the finalize_ssa_* routines do the work required to turn the build_
310 VARRAY into an operand_vector of the appropriate type. The original vector,
311 if any, is passed in for comparison and virtual SSA_NAME reuse. If the
312 old vector is reused, the pointer passed in is set to NULL so that
313 the memory is not freed when the old operands are freed. */
315 /* Return a new def operand vector for STMT, comparing to OLD_OPS_P. */
318 finalize_ssa_defs (def_optype
*old_ops_p
, tree stmt ATTRIBUTE_UNUSED
)
321 def_optype def_ops
, old_ops
;
324 num
= VARRAY_ACTIVE_SIZE (build_defs
);
328 /* There should only be a single real definition per assignment. */
329 gcc_assert (TREE_CODE (stmt
) != MODIFY_EXPR
|| num
<= 1);
331 old_ops
= *old_ops_p
;
333 /* Compare old vector and new array. */
335 if (old_ops
&& old_ops
->num_defs
== num
)
338 for (x
= 0; x
< num
; x
++)
339 if (old_ops
->defs
[x
].def
!= VARRAY_TREE_PTR (build_defs
, x
))
353 def_ops
= allocate_def_optype (num
);
354 for (x
= 0; x
< num
; x
++)
355 def_ops
->defs
[x
].def
= VARRAY_TREE_PTR (build_defs
, x
);
358 VARRAY_POP_ALL (build_defs
);
364 /* Return a new use operand vector for STMT, comparing to OLD_OPS_P. */
367 finalize_ssa_uses (use_optype
*old_ops_p
, tree stmt ATTRIBUTE_UNUSED
)
370 use_optype use_ops
, old_ops
;
373 num
= VARRAY_ACTIVE_SIZE (build_uses
);
377 #ifdef ENABLE_CHECKING
380 /* If the pointer to the operand is the statement itself, something is
381 wrong. It means that we are pointing to a local variable (the
382 initial call to get_stmt_operands does not pass a pointer to a
384 for (x
= 0; x
< num
; x
++)
385 gcc_assert (*(VARRAY_TREE_PTR (build_uses
, x
)) != stmt
);
388 old_ops
= *old_ops_p
;
390 /* Check if the old vector and the new array are the same. */
392 if (old_ops
&& old_ops
->num_uses
== num
)
395 for (x
= 0; x
< num
; x
++)
396 if (old_ops
->uses
[x
].use
!= VARRAY_TREE_PTR (build_uses
, x
))
410 use_ops
= allocate_use_optype (num
);
411 for (x
= 0; x
< num
; x
++)
412 use_ops
->uses
[x
].use
= VARRAY_TREE_PTR (build_uses
, x
);
414 VARRAY_POP_ALL (build_uses
);
420 /* Return a new v_may_def operand vector for STMT, comparing to OLD_OPS_P. */
422 static v_may_def_optype
423 finalize_ssa_v_may_defs (v_may_def_optype
*old_ops_p
)
425 unsigned num
, x
, i
, old_num
;
426 v_may_def_optype v_may_def_ops
, old_ops
;
430 num
= VARRAY_ACTIVE_SIZE (build_v_may_defs
);
434 old_ops
= *old_ops_p
;
436 /* Check if the old vector and the new array are the same. */
438 if (old_ops
&& old_ops
->num_v_may_defs
== num
)
442 for (x
= 0; x
< num
; x
++)
444 var
= old_ops
->v_may_defs
[x
].def
;
445 if (TREE_CODE (var
) == SSA_NAME
)
446 var
= SSA_NAME_VAR (var
);
447 if (var
!= VARRAY_TREE (build_v_may_defs
, x
))
455 old_num
= (old_ops
? old_ops
->num_v_may_defs
: 0);
459 v_may_def_ops
= old_ops
;
464 v_may_def_ops
= allocate_v_may_def_optype (num
);
465 for (x
= 0; x
< num
; x
++)
467 var
= VARRAY_TREE (build_v_may_defs
, x
);
468 /* Look for VAR in the old operands vector. */
469 for (i
= 0; i
< old_num
; i
++)
471 result
= old_ops
->v_may_defs
[i
].def
;
472 if (TREE_CODE (result
) == SSA_NAME
)
473 result
= SSA_NAME_VAR (result
);
476 v_may_def_ops
->v_may_defs
[x
] = old_ops
->v_may_defs
[i
];
482 v_may_def_ops
->v_may_defs
[x
].def
= var
;
483 v_may_def_ops
->v_may_defs
[x
].use
= var
;
488 /* Empty the V_MAY_DEF build vector after VUSES have been processed. */
490 return v_may_def_ops
;
494 /* Return a new vuse operand vector, comparing to OLD_OPS_P. */
497 finalize_ssa_vuses (vuse_optype
*old_ops_p
)
499 unsigned num
, x
, i
, num_v_may_defs
, old_num
;
500 vuse_optype vuse_ops
, old_ops
;
503 num
= VARRAY_ACTIVE_SIZE (build_vuses
);
506 VARRAY_POP_ALL (build_v_may_defs
);
510 /* Remove superfluous VUSE operands. If the statement already has a
511 V_MAY_DEF operation for a variable 'a', then a VUSE for 'a' is not
512 needed because V_MAY_DEFs imply a VUSE of the variable. For instance,
513 suppose that variable 'a' is aliased:
516 # a_3 = V_MAY_DEF <a_2>
519 The VUSE <a_2> is superfluous because it is implied by the V_MAY_DEF
522 num_v_may_defs
= VARRAY_ACTIVE_SIZE (build_v_may_defs
);
524 if (num_v_may_defs
> 0)
528 for (i
= 0; i
< VARRAY_ACTIVE_SIZE (build_vuses
); i
++)
530 vuse
= VARRAY_TREE (build_vuses
, i
);
531 for (j
= 0; j
< num_v_may_defs
; j
++)
533 if (vuse
== VARRAY_TREE (build_v_may_defs
, j
))
537 /* If we found a useless VUSE operand, remove it from the
538 operand array by replacing it with the last active element
539 in the operand array (unless the useless VUSE was the
540 last operand, in which case we simply remove it. */
541 if (j
!= num_v_may_defs
)
543 if (i
!= VARRAY_ACTIVE_SIZE (build_vuses
) - 1)
545 VARRAY_TREE (build_vuses
, i
)
546 = VARRAY_TREE (build_vuses
,
547 VARRAY_ACTIVE_SIZE (build_vuses
) - 1);
549 VARRAY_POP (build_vuses
);
551 /* We want to rescan the element at this index, unless
552 this was the last element, in which case the loop
559 num
= VARRAY_ACTIVE_SIZE (build_vuses
);
560 /* We could have reduced the size to zero now, however. */
563 VARRAY_POP_ALL (build_v_may_defs
);
567 old_ops
= *old_ops_p
;
569 /* Determine whether vuses is the same as the old vector. */
571 if (old_ops
&& old_ops
->num_vuses
== num
)
575 for (x
= 0; x
< num
; x
++)
578 v
= old_ops
->vuses
[x
];
579 if (TREE_CODE (v
) == SSA_NAME
)
580 v
= SSA_NAME_VAR (v
);
581 if (v
!= VARRAY_TREE (build_vuses
, x
))
589 old_num
= (old_ops
? old_ops
->num_vuses
: 0);
598 vuse_ops
= allocate_vuse_optype (num
);
599 for (x
= 0; x
< num
; x
++)
601 tree result
, var
= VARRAY_TREE (build_vuses
, x
);
602 /* Look for VAR in the old vector, and use that SSA_NAME. */
603 for (i
= 0; i
< old_num
; i
++)
605 result
= old_ops
->vuses
[i
];
606 if (TREE_CODE (result
) == SSA_NAME
)
607 result
= SSA_NAME_VAR (result
);
610 vuse_ops
->vuses
[x
] = old_ops
->vuses
[i
];
615 vuse_ops
->vuses
[x
] = var
;
619 /* The v_may_def build vector wasn't freed because we needed it here.
620 Free it now with the vuses build vector. */
621 VARRAY_POP_ALL (build_vuses
);
622 VARRAY_POP_ALL (build_v_may_defs
);
627 /* Return a new v_must_def operand vector for STMT, comparing to OLD_OPS_P. */
629 static v_must_def_optype
630 finalize_ssa_v_must_defs (v_must_def_optype
*old_ops_p
,
631 tree stmt ATTRIBUTE_UNUSED
)
633 unsigned num
, x
, i
, old_num
= 0;
634 v_must_def_optype v_must_def_ops
, old_ops
;
637 num
= VARRAY_ACTIVE_SIZE (build_v_must_defs
);
641 /* There should only be a single V_MUST_DEF per assignment. */
642 gcc_assert (TREE_CODE (stmt
) != MODIFY_EXPR
|| num
<= 1);
644 old_ops
= *old_ops_p
;
646 /* Check if the old vector and the new array are the same. */
648 if (old_ops
&& old_ops
->num_v_must_defs
== num
)
652 for (x
= 0; x
< num
; x
++)
654 tree var
= old_ops
->v_must_defs
[x
];
655 if (TREE_CODE (var
) == SSA_NAME
)
656 var
= SSA_NAME_VAR (var
);
657 if (var
!= VARRAY_TREE (build_v_must_defs
, x
))
665 old_num
= (old_ops
? old_ops
->num_v_must_defs
: 0);
669 v_must_def_ops
= old_ops
;
674 v_must_def_ops
= allocate_v_must_def_optype (num
);
675 for (x
= 0; x
< num
; x
++)
677 tree result
, var
= VARRAY_TREE (build_v_must_defs
, x
);
678 /* Look for VAR in the original vector. */
679 for (i
= 0; i
< old_num
; i
++)
681 result
= old_ops
->v_must_defs
[i
];
682 if (TREE_CODE (result
) == SSA_NAME
)
683 result
= SSA_NAME_VAR (result
);
686 v_must_def_ops
->v_must_defs
[x
] = old_ops
->v_must_defs
[i
];
691 v_must_def_ops
->v_must_defs
[x
] = var
;
694 VARRAY_POP_ALL (build_v_must_defs
);
696 return v_must_def_ops
;
700 /* Finalize all the build vectors, fill the new ones into INFO. */
703 finalize_ssa_stmt_operands (tree stmt
, stmt_operands_p old_ops
,
704 stmt_operands_p new_ops
)
706 new_ops
->def_ops
= finalize_ssa_defs (&(old_ops
->def_ops
), stmt
);
707 new_ops
->use_ops
= finalize_ssa_uses (&(old_ops
->use_ops
), stmt
);
708 new_ops
->v_must_def_ops
709 = finalize_ssa_v_must_defs (&(old_ops
->v_must_def_ops
), stmt
);
710 new_ops
->v_may_def_ops
= finalize_ssa_v_may_defs (&(old_ops
->v_may_def_ops
));
711 new_ops
->vuse_ops
= finalize_ssa_vuses (&(old_ops
->vuse_ops
));
715 /* Start the process of building up operands vectors in INFO. */
718 start_ssa_stmt_operands (void)
720 gcc_assert (VARRAY_ACTIVE_SIZE (build_defs
) == 0);
721 gcc_assert (VARRAY_ACTIVE_SIZE (build_uses
) == 0);
722 gcc_assert (VARRAY_ACTIVE_SIZE (build_vuses
) == 0);
723 gcc_assert (VARRAY_ACTIVE_SIZE (build_v_may_defs
) == 0);
724 gcc_assert (VARRAY_ACTIVE_SIZE (build_v_must_defs
) == 0);
728 /* Add DEF_P to the list of pointers to operands. */
731 append_def (tree
*def_p
)
733 VARRAY_PUSH_TREE_PTR (build_defs
, def_p
);
737 /* Add USE_P to the list of pointers to operands. */
740 append_use (tree
*use_p
)
742 VARRAY_PUSH_TREE_PTR (build_uses
, use_p
);
746 /* Add a new virtual may def for variable VAR to the build array. */
749 append_v_may_def (tree var
)
753 /* Don't allow duplicate entries. */
754 for (i
= 0; i
< VARRAY_ACTIVE_SIZE (build_v_may_defs
); i
++)
755 if (var
== VARRAY_TREE (build_v_may_defs
, i
))
758 VARRAY_PUSH_TREE (build_v_may_defs
, var
);
762 /* Add VAR to the list of virtual uses. */
765 append_vuse (tree var
)
769 /* Don't allow duplicate entries. */
770 for (i
= 0; i
< VARRAY_ACTIVE_SIZE (build_vuses
); i
++)
771 if (var
== VARRAY_TREE (build_vuses
, i
))
774 VARRAY_PUSH_TREE (build_vuses
, var
);
778 /* Add VAR to the list of virtual must definitions for INFO. */
781 append_v_must_def (tree var
)
785 /* Don't allow duplicate entries. */
786 for (i
= 0; i
< VARRAY_ACTIVE_SIZE (build_v_must_defs
); i
++)
787 if (var
== VARRAY_TREE (build_v_must_defs
, i
))
790 VARRAY_PUSH_TREE (build_v_must_defs
, var
);
793 /* Create an operands cache for STMT, returning it in NEW_OPS. OLD_OPS are the
794 original operands, and if ANN is non-null, appropriate stmt flags are set
795 in the stmt's annotation. Note that some fields in old_ops may
796 change to NULL, although none of the memory they originally pointed to
797 will be destroyed. It is appropriate to call free_stmt_operands() on
798 the value returned in old_ops.
800 The rationale for this: Certain optimizations wish to examine the difference
801 between new_ops and old_ops after processing. If a set of operands don't
802 change, new_ops will simply assume the pointer in old_ops, and the old_ops
803 pointer will be set to NULL, indicating no memory needs to be cleared.
804 Usage might appear something like:
806 old_ops_copy = old_ops = stmt_ann(stmt)->operands;
807 build_ssa_operands (stmt, NULL, &old_ops, &new_ops);
808 <* compare old_ops_copy and new_ops *>
809 free_ssa_operands (old_ops); */
812 build_ssa_operands (tree stmt
, stmt_ann_t ann
, stmt_operands_p old_ops
,
813 stmt_operands_p new_ops
)
816 tree_ann_t saved_ann
= stmt
->common
.ann
;
818 /* Replace stmt's annotation with the one passed in for the duration
819 of the operand building process. This allows "fake" stmts to be built
820 and not be included in other data structures which can be built here. */
821 stmt
->common
.ann
= (tree_ann_t
) ann
;
823 /* Initially assume that the statement has no volatile operands, nor
824 makes aliased loads or stores. */
827 ann
->has_volatile_ops
= false;
828 ann
->makes_aliased_stores
= false;
829 ann
->makes_aliased_loads
= false;
832 start_ssa_stmt_operands ();
834 code
= TREE_CODE (stmt
);
838 get_expr_operands (stmt
, &TREE_OPERAND (stmt
, 1), opf_none
);
839 if (TREE_CODE (TREE_OPERAND (stmt
, 0)) == ARRAY_REF
840 || TREE_CODE (TREE_OPERAND (stmt
, 0)) == ARRAY_RANGE_REF
841 || TREE_CODE (TREE_OPERAND (stmt
, 0)) == COMPONENT_REF
842 || TREE_CODE (TREE_OPERAND (stmt
, 0)) == REALPART_EXPR
843 || TREE_CODE (TREE_OPERAND (stmt
, 0)) == IMAGPART_EXPR
844 /* Use a V_MAY_DEF if the RHS might throw, as the LHS won't be
845 modified in that case. FIXME we should represent somehow
846 that it is killed on the fallthrough path. */
847 || tree_could_throw_p (TREE_OPERAND (stmt
, 1)))
848 get_expr_operands (stmt
, &TREE_OPERAND (stmt
, 0), opf_is_def
);
850 get_expr_operands (stmt
, &TREE_OPERAND (stmt
, 0),
851 opf_is_def
| opf_kill_def
);
855 get_expr_operands (stmt
, &COND_EXPR_COND (stmt
), opf_none
);
859 get_expr_operands (stmt
, &SWITCH_COND (stmt
), opf_none
);
863 get_asm_expr_operands (stmt
);
867 get_expr_operands (stmt
, &TREE_OPERAND (stmt
, 0), opf_none
);
871 get_expr_operands (stmt
, &GOTO_DESTINATION (stmt
), opf_none
);
875 get_expr_operands (stmt
, &LABEL_EXPR_LABEL (stmt
), opf_none
);
878 /* These nodes contain no variable references. */
880 case CASE_LABEL_EXPR
:
882 case TRY_FINALLY_EXPR
:
889 /* Notice that if get_expr_operands tries to use &STMT as the operand
890 pointer (which may only happen for USE operands), we will abort in
891 append_use. This default will handle statements like empty
892 statements, or CALL_EXPRs that may appear on the RHS of a statement
893 or as statements themselves. */
894 get_expr_operands (stmt
, &stmt
, opf_none
);
898 finalize_ssa_stmt_operands (stmt
, old_ops
, new_ops
);
899 stmt
->common
.ann
= saved_ann
;
903 /* Free any operands vectors in OPS. */
906 free_ssa_operands (stmt_operands_p ops
)
909 free_defs (&(ops
->def_ops
));
911 free_uses (&(ops
->use_ops
));
913 free_vuses (&(ops
->vuse_ops
));
914 if (ops
->v_may_def_ops
)
915 free_v_may_defs (&(ops
->v_may_def_ops
));
916 if (ops
->v_must_def_ops
)
917 free_v_must_defs (&(ops
->v_must_def_ops
));
921 /* Get the operands of statement STMT. Note that repeated calls to
922 get_stmt_operands for the same statement will do nothing until the
923 statement is marked modified by a call to modify_stmt(). */
926 get_stmt_operands (tree stmt
)
929 stmt_operands_t old_operands
;
931 /* The optimizers cannot handle statements that are nothing but a
932 _DECL. This indicates a bug in the gimplifier. */
933 gcc_assert (!SSA_VAR_P (stmt
));
935 /* Ignore error statements. */
936 if (TREE_CODE (stmt
) == ERROR_MARK
)
939 ann
= get_stmt_ann (stmt
);
941 /* If the statement has not been modified, the operands are still valid. */
945 timevar_push (TV_TREE_OPS
);
947 old_operands
= ann
->operands
;
948 memset (&(ann
->operands
), 0, sizeof (stmt_operands_t
));
950 build_ssa_operands (stmt
, ann
, &old_operands
, &(ann
->operands
));
951 free_ssa_operands (&old_operands
);
953 /* Clear the modified bit for STMT. Subsequent calls to
954 get_stmt_operands for this statement will do nothing until the
955 statement is marked modified by a call to modify_stmt(). */
958 timevar_pop (TV_TREE_OPS
);
962 /* Recursively scan the expression pointed by EXPR_P in statement referred to
963 by INFO. FLAGS is one of the OPF_* constants modifying how to interpret the
967 get_expr_operands (tree stmt
, tree
*expr_p
, int flags
)
970 enum tree_code_class
class;
973 if (expr
== NULL
|| expr
== error_mark_node
)
976 code
= TREE_CODE (expr
);
977 class = TREE_CODE_CLASS (code
);
982 /* We could have the address of a component, array member,
983 etc which has interesting variable references. */
984 /* Taking the address of a variable does not represent a
985 reference to it, but the fact that the stmt takes its address will be
986 of interest to some passes (e.g. alias resolution). */
987 add_stmt_operand (expr_p
, stmt
, 0);
989 /* If the address is invariant, there may be no interesting variable
990 references inside. */
991 if (is_gimple_min_invariant (expr
))
994 /* There should be no VUSEs created, since the referenced objects are
995 not really accessed. The only operands that we should find here
996 are ARRAY_REF indices which will always be real operands (GIMPLE
997 does not allow non-registers as array indices). */
998 flags
|= opf_no_vops
;
1000 get_expr_operands (stmt
, &TREE_OPERAND (expr
, 0), flags
);
1007 /* If we found a variable, add it to DEFS or USES depending
1008 on the operand flags. */
1009 add_stmt_operand (expr_p
, stmt
, flags
);
1013 get_indirect_ref_operands (stmt
, expr
, flags
);
1017 case ARRAY_RANGE_REF
:
1018 /* Treat array references as references to the virtual variable
1019 representing the array. The virtual variable for an ARRAY_REF
1020 is the VAR_DECL for the array. */
1022 /* Add the virtual variable for the ARRAY_REF to VDEFS or VUSES
1023 according to the value of IS_DEF. Recurse if the LHS of the
1024 ARRAY_REF node is not a regular variable. */
1025 if (SSA_VAR_P (TREE_OPERAND (expr
, 0)))
1026 add_stmt_operand (expr_p
, stmt
, flags
);
1028 get_expr_operands (stmt
, &TREE_OPERAND (expr
, 0), flags
);
1030 get_expr_operands (stmt
, &TREE_OPERAND (expr
, 1), opf_none
);
1031 get_expr_operands (stmt
, &TREE_OPERAND (expr
, 2), opf_none
);
1032 get_expr_operands (stmt
, &TREE_OPERAND (expr
, 3), opf_none
);
1038 /* Similarly to arrays, references to compound variables (complex
1039 types and structures/unions) are globbed.
1041 FIXME: This means that
1047 will not be constant propagated because the two partial
1048 definitions to 'a' will kill each other. Note that SRA may be
1049 able to fix this problem if 'a' can be scalarized. */
1051 /* If the LHS of the compound reference is not a regular variable,
1052 recurse to keep looking for more operands in the subexpression. */
1053 if (SSA_VAR_P (TREE_OPERAND (expr
, 0)))
1054 add_stmt_operand (expr_p
, stmt
, flags
);
1056 get_expr_operands (stmt
, &TREE_OPERAND (expr
, 0), flags
);
1058 if (code
== COMPONENT_REF
)
1059 get_expr_operands (stmt
, &TREE_OPERAND (expr
, 2), opf_none
);
1062 case WITH_SIZE_EXPR
:
1063 /* WITH_SIZE_EXPR is a pass-through reference to its first argument,
1064 and an rvalue reference to its second argument. */
1065 get_expr_operands (stmt
, &TREE_OPERAND (expr
, 1), opf_none
);
1066 get_expr_operands (stmt
, &TREE_OPERAND (expr
, 0), flags
);
1070 get_call_expr_operands (stmt
, expr
);
1075 get_expr_operands (stmt
, &TREE_OPERAND (expr
, 0), opf_none
);
1076 get_expr_operands (stmt
, &TREE_OPERAND (expr
, 1), opf_none
);
1077 get_expr_operands (stmt
, &TREE_OPERAND (expr
, 2), opf_none
);
1085 get_expr_operands (stmt
, &TREE_OPERAND (expr
, 1), opf_none
);
1087 op
= TREE_OPERAND (expr
, 0);
1088 if (TREE_CODE (op
) == WITH_SIZE_EXPR
)
1089 op
= TREE_OPERAND (expr
, 0);
1090 if (TREE_CODE (op
) == ARRAY_REF
1091 || TREE_CODE (op
) == ARRAY_RANGE_REF
1092 || TREE_CODE (op
) == COMPONENT_REF
1093 || TREE_CODE (op
) == REALPART_EXPR
1094 || TREE_CODE (op
) == IMAGPART_EXPR
)
1095 subflags
= opf_is_def
;
1097 subflags
= opf_is_def
| opf_kill_def
;
1099 get_expr_operands (stmt
, &TREE_OPERAND (expr
, 0), subflags
);
1105 /* General aggregate CONSTRUCTORs have been decomposed, but they
1106 are still in use as the COMPLEX_EXPR equivalent for vectors. */
1109 for (t
= TREE_OPERAND (expr
, 0); t
; t
= TREE_CHAIN (t
))
1110 get_expr_operands (stmt
, &TREE_VALUE (t
), opf_none
);
1115 case TRUTH_NOT_EXPR
:
1117 case VIEW_CONVERT_EXPR
:
1119 get_expr_operands (stmt
, &TREE_OPERAND (expr
, 0), flags
);
1122 case TRUTH_AND_EXPR
:
1124 case TRUTH_XOR_EXPR
:
1129 tree op0
= TREE_OPERAND (expr
, 0);
1130 tree op1
= TREE_OPERAND (expr
, 1);
1132 /* If it would be profitable to swap the operands, then do so to
1133 canonicalize the statement, enabling better optimization.
1135 By placing canonicalization of such expressions here we
1136 transparently keep statements in canonical form, even
1137 when the statement is modified. */
1138 if (tree_swap_operands_p (op0
, op1
, false))
1140 /* For relationals we need to swap the operands
1141 and change the code. */
1147 TREE_SET_CODE (expr
, swap_tree_comparison (code
));
1148 TREE_OPERAND (expr
, 0) = op1
;
1149 TREE_OPERAND (expr
, 1) = op0
;
1152 /* For a commutative operator we can just swap the operands. */
1153 else if (commutative_tree_code (code
))
1155 TREE_OPERAND (expr
, 0) = op1
;
1156 TREE_OPERAND (expr
, 1) = op0
;
1160 get_expr_operands (stmt
, &TREE_OPERAND (expr
, 0), flags
);
1161 get_expr_operands (stmt
, &TREE_OPERAND (expr
, 1), flags
);
1170 /* Expressions that make no memory references. */
1174 if (class == tcc_unary
)
1176 if (class == tcc_binary
|| class == tcc_comparison
)
1178 if (class == tcc_constant
|| class == tcc_type
)
1182 /* If we get here, something has gone wrong. */
1183 #ifdef ENABLE_CHECKING
1184 fprintf (stderr
, "unhandled expression in get_expr_operands():\n");
1186 fputs ("\n", stderr
);
1187 internal_error ("internal error");
1193 /* Scan operands in the ASM_EXPR stmt referred to in INFO. */
1196 get_asm_expr_operands (tree stmt
)
1198 stmt_ann_t s_ann
= stmt_ann (stmt
);
1199 int noutputs
= list_length (ASM_OUTPUTS (stmt
));
1200 const char **oconstraints
1201 = (const char **) alloca ((noutputs
) * sizeof (const char *));
1204 const char *constraint
;
1205 bool allows_mem
, allows_reg
, is_inout
;
1207 for (i
=0, link
= ASM_OUTPUTS (stmt
); link
; ++i
, link
= TREE_CHAIN (link
))
1209 oconstraints
[i
] = constraint
1210 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link
)));
1211 parse_output_constraint (&constraint
, i
, 0, 0,
1212 &allows_mem
, &allows_reg
, &is_inout
);
1214 /* This should have been split in gimplify_asm_expr. */
1215 gcc_assert (!allows_reg
|| !is_inout
);
1217 /* Memory operands are addressable. Note that STMT needs the
1218 address of this operand. */
1219 if (!allows_reg
&& allows_mem
)
1221 tree t
= get_base_address (TREE_VALUE (link
));
1222 if (t
&& DECL_P (t
))
1223 note_addressable (t
, s_ann
);
1226 get_expr_operands (stmt
, &TREE_VALUE (link
), opf_is_def
);
1229 for (link
= ASM_INPUTS (stmt
); link
; link
= TREE_CHAIN (link
))
1232 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link
)));
1233 parse_input_constraint (&constraint
, 0, 0, noutputs
, 0,
1234 oconstraints
, &allows_mem
, &allows_reg
);
1236 /* Memory operands are addressable. Note that STMT needs the
1237 address of this operand. */
1238 if (!allows_reg
&& allows_mem
)
1240 tree t
= get_base_address (TREE_VALUE (link
));
1241 if (t
&& DECL_P (t
))
1242 note_addressable (t
, s_ann
);
1245 get_expr_operands (stmt
, &TREE_VALUE (link
), 0);
1249 /* Clobber memory for asm ("" : : : "memory"); */
1250 for (link
= ASM_CLOBBERS (stmt
); link
; link
= TREE_CHAIN (link
))
1251 if (strcmp (TREE_STRING_POINTER (TREE_VALUE (link
)), "memory") == 0)
1255 /* Clobber all call-clobbered variables (or .GLOBAL_VAR if we
1256 decided to group them). */
1258 add_stmt_operand (&global_var
, stmt
, opf_is_def
);
1260 EXECUTE_IF_SET_IN_BITMAP (call_clobbered_vars
, 0, i
,
1262 tree var
= referenced_var (i
);
1263 add_stmt_operand (&var
, stmt
, opf_is_def
);
1266 /* Now clobber all addressables. */
1267 EXECUTE_IF_SET_IN_BITMAP (addressable_vars
, 0, i
,
1269 tree var
= referenced_var (i
);
1270 add_stmt_operand (&var
, stmt
, opf_is_def
);
1277 /* A subroutine of get_expr_operands to handle INDIRECT_REF. */
1280 get_indirect_ref_operands (tree stmt
, tree expr
, int flags
)
1282 tree
*pptr
= &TREE_OPERAND (expr
, 0);
1284 stmt_ann_t ann
= stmt_ann (stmt
);
1286 /* Stores into INDIRECT_REF operands are never killing definitions. */
1287 flags
&= ~opf_kill_def
;
1289 if (REF_ORIGINAL (expr
))
1291 enum tree_code ocode
= TREE_CODE (REF_ORIGINAL (expr
));
1293 /* If we originally accessed part of a structure, we do it still. */
1294 if (ocode
== ARRAY_REF
1295 || ocode
== COMPONENT_REF
1296 || ocode
== REALPART_EXPR
1297 || ocode
== IMAGPART_EXPR
)
1298 flags
&= ~opf_kill_def
;
1301 if (SSA_VAR_P (ptr
))
1303 struct ptr_info_def
*pi
= NULL
;
1305 /* If PTR has flow-sensitive points-to information, use it. */
1306 if (TREE_CODE (ptr
) == SSA_NAME
1307 && (pi
= SSA_NAME_PTR_INFO (ptr
)) != NULL
1308 && pi
->name_mem_tag
)
1310 /* PTR has its own memory tag. Use it. */
1311 add_stmt_operand (&pi
->name_mem_tag
, stmt
, flags
);
1315 /* If PTR is not an SSA_NAME or it doesn't have a name
1316 tag, use its type memory tag. */
1319 /* If we are emitting debugging dumps, display a warning if
1320 PTR is an SSA_NAME with no flow-sensitive alias
1321 information. That means that we may need to compute
1324 && TREE_CODE (ptr
) == SSA_NAME
1328 "NOTE: no flow-sensitive alias info for ");
1329 print_generic_expr (dump_file
, ptr
, dump_flags
);
1330 fprintf (dump_file
, " in ");
1331 print_generic_stmt (dump_file
, stmt
, dump_flags
);
1334 if (TREE_CODE (ptr
) == SSA_NAME
)
1335 ptr
= SSA_NAME_VAR (ptr
);
1336 ann
= var_ann (ptr
);
1337 if (ann
->type_mem_tag
)
1338 add_stmt_operand (&ann
->type_mem_tag
, stmt
, flags
);
1342 /* If a constant is used as a pointer, we can't generate a real
1343 operand for it but we mark the statement volatile to prevent
1344 optimizations from messing things up. */
1345 else if (TREE_CODE (ptr
) == INTEGER_CST
)
1348 ann
->has_volatile_ops
= true;
1352 /* Everything else *should* have been folded elsewhere, but users
1353 are smarter than we in finding ways to write invalid code. We
1354 cannot just abort here. If we were absolutely certain that we
1355 do handle all valid cases, then we could just do nothing here.
1356 That seems optimistic, so attempt to do something logical... */
1357 else if ((TREE_CODE (ptr
) == PLUS_EXPR
|| TREE_CODE (ptr
) == MINUS_EXPR
)
1358 && TREE_CODE (TREE_OPERAND (ptr
, 0)) == ADDR_EXPR
1359 && TREE_CODE (TREE_OPERAND (ptr
, 1)) == INTEGER_CST
)
1361 /* Make sure we know the object is addressable. */
1362 pptr
= &TREE_OPERAND (ptr
, 0);
1363 add_stmt_operand (pptr
, stmt
, 0);
1365 /* Mark the object itself with a VUSE. */
1366 pptr
= &TREE_OPERAND (*pptr
, 0);
1367 get_expr_operands (stmt
, pptr
, flags
);
1371 /* Ok, this isn't even is_gimple_min_invariant. Something's broke. */
1375 /* Add a USE operand for the base pointer. */
1376 get_expr_operands (stmt
, pptr
, opf_none
);
1379 /* A subroutine of get_expr_operands to handle CALL_EXPR. */
1382 get_call_expr_operands (tree stmt
, tree expr
)
1385 int call_flags
= call_expr_flags (expr
);
1386 tree callee
= get_callee_fndecl (expr
);
1388 /* Find uses in the called function. */
1389 get_expr_operands (stmt
, &TREE_OPERAND (expr
, 0), opf_none
);
1391 for (op
= TREE_OPERAND (expr
, 1); op
; op
= TREE_CHAIN (op
))
1392 get_expr_operands (stmt
, &TREE_VALUE (op
), opf_none
);
1394 get_expr_operands (stmt
, &TREE_OPERAND (expr
, 2), opf_none
);
1396 if (bitmap_first_set_bit (call_clobbered_vars
) >= 0)
1398 /* A 'pure' or a 'const' functions never call clobber anything.
1399 A 'noreturn' function might, but since we don't return anyway
1400 there is no point in recording that. */
1401 if (TREE_SIDE_EFFECTS (expr
)
1402 && !(call_flags
& (ECF_PURE
| ECF_CONST
| ECF_NORETURN
)))
1403 add_call_clobber_ops (stmt
, callee
);
1404 else if (!(call_flags
& ECF_CONST
))
1405 add_call_read_ops (stmt
, callee
);
1410 /* Add *VAR_P to the appropriate operand array for INFO. FLAGS is as in
1411 get_expr_operands. If *VAR_P is a GIMPLE register, it will be added to
1412 the statement's real operands, otherwise it is added to virtual
1416 add_stmt_operand (tree
*var_p
, tree stmt
, int flags
)
1420 stmt_ann_t s_ann
= stmt_ann (stmt
);
1426 /* If the operand is an ADDR_EXPR, add its operand to the list of
1427 variables that have had their address taken in this statement. */
1428 if (TREE_CODE (var
) == ADDR_EXPR
)
1430 note_addressable (TREE_OPERAND (var
, 0), s_ann
);
1434 /* If the original variable is not a scalar, it will be added to the list
1435 of virtual operands. In that case, use its base symbol as the virtual
1436 variable representing it. */
1437 is_real_op
= is_gimple_reg (var
);
1438 if (!is_real_op
&& !DECL_P (var
))
1439 var
= get_virtual_var (var
);
1441 /* If VAR is not a variable that we care to optimize, do nothing. */
1442 if (var
== NULL_TREE
|| !SSA_VAR_P (var
))
1445 sym
= (TREE_CODE (var
) == SSA_NAME
? SSA_NAME_VAR (var
) : var
);
1446 v_ann
= var_ann (sym
);
1448 /* Don't expose volatile variables to the optimizers. */
1449 if (TREE_THIS_VOLATILE (sym
))
1452 s_ann
->has_volatile_ops
= true;
1458 /* The variable is a GIMPLE register. Add it to real operands. */
1459 if (flags
& opf_is_def
)
1466 varray_type aliases
;
1468 /* The variable is not a GIMPLE register. Add it (or its aliases) to
1469 virtual operands, unless the caller has specifically requested
1470 not to add virtual operands (used when adding operands inside an
1471 ADDR_EXPR expression). */
1472 if (flags
& opf_no_vops
)
1475 aliases
= v_ann
->may_aliases
;
1477 if (aliases
== NULL
)
1479 /* The variable is not aliased or it is an alias tag. */
1480 if (flags
& opf_is_def
)
1482 if (flags
& opf_kill_def
)
1484 /* Only regular variables may get a V_MUST_DEF
1486 gcc_assert (v_ann
->mem_tag_kind
== NOT_A_TAG
);
1487 /* V_MUST_DEF for non-aliased, non-GIMPLE register
1488 variable definitions. */
1489 append_v_must_def (var
);
1493 /* Add a V_MAY_DEF for call-clobbered variables and
1495 append_v_may_def (var
);
1501 if (s_ann
&& v_ann
->is_alias_tag
)
1502 s_ann
->makes_aliased_loads
= 1;
1509 /* The variable is aliased. Add its aliases to the virtual
1511 gcc_assert (VARRAY_ACTIVE_SIZE (aliases
) != 0);
1513 if (flags
& opf_is_def
)
1515 /* If the variable is also an alias tag, add a virtual
1516 operand for it, otherwise we will miss representing
1517 references to the members of the variable's alias set.
1518 This fixes the bug in gcc.c-torture/execute/20020503-1.c. */
1519 if (v_ann
->is_alias_tag
)
1520 append_v_may_def (var
);
1522 for (i
= 0; i
< VARRAY_ACTIVE_SIZE (aliases
); i
++)
1523 append_v_may_def (VARRAY_TREE (aliases
, i
));
1526 s_ann
->makes_aliased_stores
= 1;
1530 /* Similarly, append a virtual uses for VAR itself, when
1531 it is an alias tag. */
1532 if (v_ann
->is_alias_tag
)
1535 for (i
= 0; i
< VARRAY_ACTIVE_SIZE (aliases
); i
++)
1536 append_vuse (VARRAY_TREE (aliases
, i
));
1539 s_ann
->makes_aliased_loads
= 1;
1546 /* Record that VAR had its address taken in the statement with annotations
1550 note_addressable (tree var
, stmt_ann_t s_ann
)
1555 var
= get_base_address (var
);
1556 if (var
&& SSA_VAR_P (var
))
1558 if (s_ann
->addresses_taken
== NULL
)
1559 s_ann
->addresses_taken
= BITMAP_GGC_ALLOC ();
1560 bitmap_set_bit (s_ann
->addresses_taken
, var_ann (var
)->uid
);
1565 /* Add clobbering definitions for .GLOBAL_VAR or for each of the call
1566 clobbered variables in the function. */
1569 add_call_clobber_ops (tree stmt
, tree callee
)
1571 /* Functions that are not const, pure or never return may clobber
1572 call-clobbered variables. */
1573 if (stmt_ann (stmt
))
1574 stmt_ann (stmt
)->makes_clobbering_call
= true;
1576 /* If we had created .GLOBAL_VAR earlier, use it. Otherwise, add
1577 a V_MAY_DEF operand for every call clobbered variable. See
1578 compute_may_aliases for the heuristic used to decide whether
1579 to create .GLOBAL_VAR or not. */
1581 add_stmt_operand (&global_var
, stmt
, opf_is_def
);
1585 bitmap not_read_b
= NULL
, not_written_b
= NULL
;
1587 /* Get info for module level statics. There is a bit set for
1588 each static if the call being processed does not read or
1589 write that variable. */
1591 /* ??? Turn off the optimization until it gets fixed. */
1594 not_read_b
= get_global_statics_not_read (callee
);
1595 not_written_b
= get_global_statics_not_written (callee
);
1598 EXECUTE_IF_SET_IN_BITMAP (call_clobbered_vars
, 0, i
,
1600 tree var
= referenced_var (i
);
1603 = not_read_b
? bitmap_bit_p (not_read_b
, i
) : false;
1605 = not_written_b
? bitmap_bit_p (not_written_b
, i
) : false;
1609 /* The var is not read during the call. */
1611 add_stmt_operand (&var
, stmt
, opf_is_def
);
1615 /* The var is read during the call. */
1617 add_stmt_operand (&var
, stmt
, opf_none
);
1619 /* The not_read and not_written bits are only set for module
1620 static variables. Neither is set here, so we may be dealing
1621 with a module static or we may not. So we still must look
1622 anywhere else we can (such as the TREE_READONLY) to get
1625 /* If VAR is read-only, don't add a V_MAY_DEF, just a
1626 VUSE operand. FIXME, this is quirky. TREE_READONLY
1627 by itself is not enough here. We can only decide
1628 that the call will not affect VAR if all these
1629 conditions are met. One would think that
1630 TREE_READONLY should be sufficient. */
1631 else if (TREE_READONLY (var
)
1632 && (TREE_STATIC (var
) || DECL_EXTERNAL (var
)))
1633 add_stmt_operand (&var
, stmt
, opf_none
);
1635 add_stmt_operand (&var
, stmt
, opf_is_def
);
1642 /* Add VUSE operands for .GLOBAL_VAR or all call clobbered variables in the
1646 add_call_read_ops (tree stmt
, tree callee
)
1648 /* Otherwise, if the function is not pure, it may reference memory. Add
1649 a VUSE for .GLOBAL_VAR if it has been created. Otherwise, add a VUSE
1650 for each call-clobbered variable. See add_referenced_var for the
1651 heuristic used to decide whether to create .GLOBAL_VAR. */
1653 add_stmt_operand (&global_var
, stmt
, opf_none
);
1657 bitmap not_read_b
= callee
1658 ? get_global_statics_not_read (callee
) : NULL
;
1660 EXECUTE_IF_SET_IN_BITMAP (call_clobbered_vars
, 0, i
,
1662 tree var
= referenced_var (i
);
1663 bool not_read
= not_read_b
1664 ? bitmap_bit_p(not_read_b
, i
) : false;
1666 add_stmt_operand (&var
, stmt
, opf_none
);
1671 /* Copies virtual operands from SRC to DST. */
1674 copy_virtual_operands (tree dst
, tree src
)
1677 vuse_optype vuses
= STMT_VUSE_OPS (src
);
1678 v_may_def_optype v_may_defs
= STMT_V_MAY_DEF_OPS (src
);
1679 v_must_def_optype v_must_defs
= STMT_V_MUST_DEF_OPS (src
);
1680 vuse_optype
*vuses_new
= &stmt_ann (dst
)->operands
.vuse_ops
;
1681 v_may_def_optype
*v_may_defs_new
= &stmt_ann (dst
)->operands
.v_may_def_ops
;
1682 v_must_def_optype
*v_must_defs_new
= &stmt_ann (dst
)->operands
.v_must_def_ops
;
1686 *vuses_new
= allocate_vuse_optype (NUM_VUSES (vuses
));
1687 for (i
= 0; i
< NUM_VUSES (vuses
); i
++)
1688 SET_VUSE_OP (*vuses_new
, i
, VUSE_OP (vuses
, i
));
1693 *v_may_defs_new
= allocate_v_may_def_optype (NUM_V_MAY_DEFS (v_may_defs
));
1694 for (i
= 0; i
< NUM_V_MAY_DEFS (v_may_defs
); i
++)
1696 SET_V_MAY_DEF_OP (*v_may_defs_new
, i
, V_MAY_DEF_OP (v_may_defs
, i
));
1697 SET_V_MAY_DEF_RESULT (*v_may_defs_new
, i
,
1698 V_MAY_DEF_RESULT (v_may_defs
, i
));
1704 *v_must_defs_new
= allocate_v_must_def_optype (NUM_V_MUST_DEFS (v_must_defs
));
1705 for (i
= 0; i
< NUM_V_MUST_DEFS (v_must_defs
); i
++)
1706 SET_V_MUST_DEF_OP (*v_must_defs_new
, i
, V_MUST_DEF_OP (v_must_defs
, i
));
1711 /* Specifically for use in DOM's expression analysis. Given a store, we
1712 create an artificial stmt which looks like a load from the store, this can
1713 be used to eliminate redundant loads. OLD_OPS are the operands from the
1714 store stmt, and NEW_STMT is the new load which represents a load of the
1718 create_ssa_artficial_load_stmt (stmt_operands_p old_ops
, tree new_stmt
)
1722 stmt_operands_t tmp
;
1725 memset (&tmp
, 0, sizeof (stmt_operands_t
));
1726 ann
= get_stmt_ann (new_stmt
);
1728 /* Free operands just in case is was an existing stmt. */
1729 free_ssa_operands (&(ann
->operands
));
1731 build_ssa_operands (new_stmt
, NULL
, &tmp
, &(ann
->operands
));
1732 free_vuses (&(ann
->operands
.vuse_ops
));
1733 free_v_may_defs (&(ann
->operands
.v_may_def_ops
));
1734 free_v_must_defs (&(ann
->operands
.v_must_def_ops
));
1736 /* For each VDEF on the original statement, we want to create a
1737 VUSE of the V_MAY_DEF result or V_MUST_DEF op on the new
1739 for (j
= 0; j
< NUM_V_MAY_DEFS (old_ops
->v_may_def_ops
); j
++)
1741 op
= V_MAY_DEF_RESULT (old_ops
->v_may_def_ops
, j
);
1745 for (j
= 0; j
< NUM_V_MUST_DEFS (old_ops
->v_must_def_ops
); j
++)
1747 op
= V_MUST_DEF_OP (old_ops
->v_must_def_ops
, j
);
1751 /* Now set the vuses for this new stmt. */
1752 ann
->operands
.vuse_ops
= finalize_ssa_vuses (&(tmp
.vuse_ops
));
1755 #include "gt-tree-ssa-operands.h"