1 /* SSA operands management for trees.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
3 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
28 #include "tree-pretty-print.h"
29 #include "gimple-pretty-print.h"
30 #include "tree-flow.h"
31 #include "tree-inline.h"
32 #include "tree-pass.h"
36 #include "langhooks.h"
37 #include "ipa-reference.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 The operand tree is the parsed by the various get_* routines which look
55 through the stmt tree for the occurrence of operands which may be of
56 interest, and calls are made to the append_* routines whenever one is
57 found. There are 4 of these routines, each representing one of the
58 4 types of operands. Defs, Uses, Virtual Uses, and Virtual May Defs.
60 The append_* routines check for duplication, and simply keep a list of
61 unique objects for each operand type in the build_* extendable vectors.
63 Once the stmt tree is completely parsed, the finalize_ssa_operands()
64 routine is called, which proceeds to perform the finalization routine
65 on each of the 4 operand vectors which have been built up.
67 If the stmt had a previous operand cache, the finalization routines
68 attempt to match up the new operands with the old ones. If it's a perfect
69 match, the old vector is simply reused. If it isn't a perfect match, then
70 a new vector is created and the new operands are placed there. For
71 virtual operands, if the previous cache had SSA_NAME version of a
72 variable, and that same variable occurs in the same operands cache, then
73 the new cache vector will also get the same SSA_NAME.
75 i.e., if a stmt had a VUSE of 'a_5', and 'a' occurs in the new
76 operand vector for VUSE, then the new vector will also be modified
77 such that it contains 'a_5' rather than 'a'. */
79 /* Structure storing statistics on how many call clobbers we have, and
80 how many where avoided. */
84 /* Number of call-clobbered ops we attempt to add to calls in
85 add_call_clobbered_mem_symbols. */
86 unsigned int clobbered_vars
;
88 /* Number of write-clobbers (VDEFs) avoided by using
89 not_written information. */
90 unsigned int static_write_clobbers_avoided
;
92 /* Number of reads (VUSEs) avoided by using not_read information. */
93 unsigned int static_read_clobbers_avoided
;
95 /* Number of write-clobbers avoided because the variable can't escape to
97 unsigned int unescapable_clobbers_avoided
;
99 /* Number of read-only uses we attempt to add to calls in
100 add_call_read_mem_symbols. */
101 unsigned int readonly_clobbers
;
103 /* Number of read-only uses we avoid using not_read information. */
104 unsigned int static_readonly_clobbers_avoided
;
108 /* Flags to describe operand properties in helpers. */
110 /* By default, operands are loaded. */
113 /* Operand is the target of an assignment expression or a
114 call-clobbered variable. */
115 #define opf_def (1 << 0)
117 /* No virtual operands should be created in the expression. This is used
118 when traversing ADDR_EXPR nodes which have different semantics than
119 other expressions. Inside an ADDR_EXPR node, the only operands that we
120 need to consider are indices into arrays. For instance, &a.b[i] should
121 generate a USE of 'i' but it should not generate a VUSE for 'a' nor a
123 #define opf_no_vops (1 << 1)
125 /* Operand is an implicit reference. This is used to distinguish
126 explicit assignments in the form of MODIFY_EXPR from
127 clobbering sites like function calls or ASM_EXPRs. */
128 #define opf_implicit (1 << 2)
130 /* Operand is in a place where address-taken does not imply addressable. */
131 #define opf_non_addressable (1 << 3)
133 /* Operand is in a place where opf_non_addressable does not apply. */
134 #define opf_not_non_addressable (1 << 4)
136 /* Array for building all the def operands. */
137 static VEC(tree
,heap
) *build_defs
;
139 /* Array for building all the use operands. */
140 static VEC(tree
,heap
) *build_uses
;
142 /* The built VDEF operand. */
143 static tree build_vdef
;
145 /* The built VUSE operand. */
146 static tree build_vuse
;
148 /* Bitmap obstack for our datastructures that needs to survive across
149 compilations of multiple functions. */
150 static bitmap_obstack operands_bitmap_obstack
;
152 static void get_expr_operands (gimple
, tree
*, int);
154 /* Number of functions with initialized ssa_operands. */
155 static int n_initialized
= 0;
157 /* Return the DECL_UID of the base variable of T. */
159 static inline unsigned
160 get_name_decl (const_tree t
)
162 if (TREE_CODE (t
) != SSA_NAME
)
165 return DECL_UID (SSA_NAME_VAR (t
));
169 /* Return true if the SSA operands cache is active. */
172 ssa_operands_active (void)
174 /* This function may be invoked from contexts where CFUN is NULL
175 (IPA passes), return false for now. FIXME: operands may be
176 active in each individual function, maybe this function should
177 take CFUN as a parameter. */
181 return cfun
->gimple_df
&& gimple_ssa_operands (cfun
)->ops_active
;
185 /* Create the VOP variable, an artificial global variable to act as a
186 representative of all of the virtual operands FUD chain. */
189 create_vop_var (void)
193 gcc_assert (cfun
->gimple_df
->vop
== NULL_TREE
);
195 global_var
= build_decl (BUILTINS_LOCATION
, VAR_DECL
,
196 get_identifier (".MEM"),
198 DECL_ARTIFICIAL (global_var
) = 1;
199 TREE_READONLY (global_var
) = 0;
200 DECL_EXTERNAL (global_var
) = 1;
201 TREE_STATIC (global_var
) = 1;
202 TREE_USED (global_var
) = 1;
203 DECL_CONTEXT (global_var
) = NULL_TREE
;
204 TREE_THIS_VOLATILE (global_var
) = 0;
205 TREE_ADDRESSABLE (global_var
) = 0;
207 create_var_ann (global_var
);
208 add_referenced_var (global_var
);
209 cfun
->gimple_df
->vop
= global_var
;
212 /* These are the sizes of the operand memory buffer in bytes which gets
213 allocated each time more operands space is required. The final value is
214 the amount that is allocated every time after that.
215 In 1k we can fit 25 use operands (or 63 def operands) on a host with
216 8 byte pointers, that would be 10 statements each with 1 def and 2
219 #define OP_SIZE_INIT 0
220 #define OP_SIZE_1 (1024 - sizeof (void *))
221 #define OP_SIZE_2 (1024 * 4 - sizeof (void *))
222 #define OP_SIZE_3 (1024 * 16 - sizeof (void *))
224 /* Initialize the operand cache routines. */
227 init_ssa_operands (void)
229 if (!n_initialized
++)
231 build_defs
= VEC_alloc (tree
, heap
, 5);
232 build_uses
= VEC_alloc (tree
, heap
, 10);
233 build_vuse
= NULL_TREE
;
234 build_vdef
= NULL_TREE
;
235 bitmap_obstack_initialize (&operands_bitmap_obstack
);
238 gcc_assert (gimple_ssa_operands (cfun
)->operand_memory
== NULL
);
239 gimple_ssa_operands (cfun
)->operand_memory_index
240 = gimple_ssa_operands (cfun
)->ssa_operand_mem_size
;
241 gimple_ssa_operands (cfun
)->ops_active
= true;
242 memset (&clobber_stats
, 0, sizeof (clobber_stats
));
243 gimple_ssa_operands (cfun
)->ssa_operand_mem_size
= OP_SIZE_INIT
;
248 /* Dispose of anything required by the operand routines. */
251 fini_ssa_operands (void)
253 struct ssa_operand_memory_d
*ptr
;
255 if (!--n_initialized
)
257 VEC_free (tree
, heap
, build_defs
);
258 VEC_free (tree
, heap
, build_uses
);
259 build_vdef
= NULL_TREE
;
260 build_vuse
= NULL_TREE
;
263 gimple_ssa_operands (cfun
)->free_defs
= NULL
;
264 gimple_ssa_operands (cfun
)->free_uses
= NULL
;
266 while ((ptr
= gimple_ssa_operands (cfun
)->operand_memory
) != NULL
)
268 gimple_ssa_operands (cfun
)->operand_memory
269 = gimple_ssa_operands (cfun
)->operand_memory
->next
;
273 gimple_ssa_operands (cfun
)->ops_active
= false;
276 bitmap_obstack_release (&operands_bitmap_obstack
);
278 cfun
->gimple_df
->vop
= NULL_TREE
;
280 if (dump_file
&& (dump_flags
& TDF_STATS
))
282 fprintf (dump_file
, "Original clobbered vars: %d\n",
283 clobber_stats
.clobbered_vars
);
284 fprintf (dump_file
, "Static write clobbers avoided: %d\n",
285 clobber_stats
.static_write_clobbers_avoided
);
286 fprintf (dump_file
, "Static read clobbers avoided: %d\n",
287 clobber_stats
.static_read_clobbers_avoided
);
288 fprintf (dump_file
, "Unescapable clobbers avoided: %d\n",
289 clobber_stats
.unescapable_clobbers_avoided
);
290 fprintf (dump_file
, "Original read-only clobbers: %d\n",
291 clobber_stats
.readonly_clobbers
);
292 fprintf (dump_file
, "Static read-only clobbers avoided: %d\n",
293 clobber_stats
.static_readonly_clobbers_avoided
);
298 /* Return memory for an operand of size SIZE. */
301 ssa_operand_alloc (unsigned size
)
305 gcc_assert (size
== sizeof (struct use_optype_d
)
306 || size
== sizeof (struct def_optype_d
));
308 if (gimple_ssa_operands (cfun
)->operand_memory_index
+ size
309 >= gimple_ssa_operands (cfun
)->ssa_operand_mem_size
)
311 struct ssa_operand_memory_d
*ptr
;
313 switch (gimple_ssa_operands (cfun
)->ssa_operand_mem_size
)
316 gimple_ssa_operands (cfun
)->ssa_operand_mem_size
= OP_SIZE_1
;
319 gimple_ssa_operands (cfun
)->ssa_operand_mem_size
= OP_SIZE_2
;
323 gimple_ssa_operands (cfun
)->ssa_operand_mem_size
= OP_SIZE_3
;
330 ptr
= ggc_alloc_ssa_operand_memory_d (sizeof (void *)
331 + gimple_ssa_operands (cfun
)->ssa_operand_mem_size
);
333 ptr
->next
= gimple_ssa_operands (cfun
)->operand_memory
;
334 gimple_ssa_operands (cfun
)->operand_memory
= ptr
;
335 gimple_ssa_operands (cfun
)->operand_memory_index
= 0;
338 ptr
= &(gimple_ssa_operands (cfun
)->operand_memory
339 ->mem
[gimple_ssa_operands (cfun
)->operand_memory_index
]);
340 gimple_ssa_operands (cfun
)->operand_memory_index
+= size
;
345 /* Allocate a DEF operand. */
347 static inline struct def_optype_d
*
350 struct def_optype_d
*ret
;
351 if (gimple_ssa_operands (cfun
)->free_defs
)
353 ret
= gimple_ssa_operands (cfun
)->free_defs
;
354 gimple_ssa_operands (cfun
)->free_defs
355 = gimple_ssa_operands (cfun
)->free_defs
->next
;
358 ret
= (struct def_optype_d
*)
359 ssa_operand_alloc (sizeof (struct def_optype_d
));
364 /* Allocate a USE operand. */
366 static inline struct use_optype_d
*
369 struct use_optype_d
*ret
;
370 if (gimple_ssa_operands (cfun
)->free_uses
)
372 ret
= gimple_ssa_operands (cfun
)->free_uses
;
373 gimple_ssa_operands (cfun
)->free_uses
374 = gimple_ssa_operands (cfun
)->free_uses
->next
;
377 ret
= (struct use_optype_d
*)
378 ssa_operand_alloc (sizeof (struct use_optype_d
));
383 /* Adds OP to the list of defs after LAST. */
385 static inline def_optype_p
386 add_def_op (tree
*op
, def_optype_p last
)
388 def_optype_p new_def
;
390 new_def
= alloc_def ();
391 DEF_OP_PTR (new_def
) = op
;
392 last
->next
= new_def
;
393 new_def
->next
= NULL
;
398 /* Adds OP to the list of uses of statement STMT after LAST. */
400 static inline use_optype_p
401 add_use_op (gimple stmt
, tree
*op
, use_optype_p last
)
403 use_optype_p new_use
;
405 new_use
= alloc_use ();
406 USE_OP_PTR (new_use
)->use
= op
;
407 link_imm_use_stmt (USE_OP_PTR (new_use
), *op
, stmt
);
408 last
->next
= new_use
;
409 new_use
->next
= NULL
;
415 /* Takes elements from build_defs and turns them into def operands of STMT.
416 TODO -- Make build_defs VEC of tree *. */
419 finalize_ssa_defs (gimple stmt
)
422 struct def_optype_d new_list
;
423 def_optype_p old_ops
, last
;
424 unsigned int num
= VEC_length (tree
, build_defs
);
426 /* There should only be a single real definition per assignment. */
427 gcc_assert ((stmt
&& gimple_code (stmt
) != GIMPLE_ASSIGN
) || num
<= 1);
429 /* Pre-pend the vdef we may have built. */
430 if (build_vdef
!= NULL_TREE
)
432 tree oldvdef
= gimple_vdef (stmt
);
434 && TREE_CODE (oldvdef
) == SSA_NAME
)
435 oldvdef
= SSA_NAME_VAR (oldvdef
);
436 if (oldvdef
!= build_vdef
)
437 gimple_set_vdef (stmt
, build_vdef
);
438 VEC_safe_insert (tree
, heap
, build_defs
, 0, (tree
)gimple_vdef_ptr (stmt
));
442 new_list
.next
= NULL
;
445 old_ops
= gimple_def_ops (stmt
);
449 /* Clear and unlink a no longer necessary VDEF. */
450 if (build_vdef
== NULL_TREE
451 && gimple_vdef (stmt
) != NULL_TREE
)
453 if (TREE_CODE (gimple_vdef (stmt
)) == SSA_NAME
)
455 unlink_stmt_vdef (stmt
);
456 release_ssa_name (gimple_vdef (stmt
));
458 gimple_set_vdef (stmt
, NULL_TREE
);
461 /* If we have a non-SSA_NAME VDEF, mark it for renaming. */
462 if (gimple_vdef (stmt
)
463 && TREE_CODE (gimple_vdef (stmt
)) != SSA_NAME
)
464 mark_sym_for_renaming (gimple_vdef (stmt
));
466 /* Check for the common case of 1 def that hasn't changed. */
467 if (old_ops
&& old_ops
->next
== NULL
&& num
== 1
468 && (tree
*) VEC_index (tree
, build_defs
, 0) == DEF_OP_PTR (old_ops
))
471 /* If there is anything in the old list, free it. */
474 old_ops
->next
= gimple_ssa_operands (cfun
)->free_defs
;
475 gimple_ssa_operands (cfun
)->free_defs
= old_ops
;
478 /* If there is anything remaining in the build_defs list, simply emit it. */
479 for ( ; new_i
< num
; new_i
++)
480 last
= add_def_op ((tree
*) VEC_index (tree
, build_defs
, new_i
), last
);
482 /* Now set the stmt's operands. */
483 gimple_set_def_ops (stmt
, new_list
.next
);
487 /* Takes elements from build_uses and turns them into use operands of STMT.
488 TODO -- Make build_uses VEC of tree *. */
491 finalize_ssa_uses (gimple stmt
)
494 struct use_optype_d new_list
;
495 use_optype_p old_ops
, ptr
, last
;
497 /* Pre-pend the VUSE we may have built. */
498 if (build_vuse
!= NULL_TREE
)
500 tree oldvuse
= gimple_vuse (stmt
);
502 && TREE_CODE (oldvuse
) == SSA_NAME
)
503 oldvuse
= SSA_NAME_VAR (oldvuse
);
504 if (oldvuse
!= (build_vuse
!= NULL_TREE
505 ? build_vuse
: build_vdef
))
506 gimple_set_vuse (stmt
, NULL_TREE
);
507 VEC_safe_insert (tree
, heap
, build_uses
, 0, (tree
)gimple_vuse_ptr (stmt
));
510 new_list
.next
= NULL
;
513 old_ops
= gimple_use_ops (stmt
);
515 /* Clear a no longer necessary VUSE. */
516 if (build_vuse
== NULL_TREE
517 && gimple_vuse (stmt
) != NULL_TREE
)
518 gimple_set_vuse (stmt
, NULL_TREE
);
520 /* If there is anything in the old list, free it. */
523 for (ptr
= old_ops
; ptr
; ptr
= ptr
->next
)
524 delink_imm_use (USE_OP_PTR (ptr
));
525 old_ops
->next
= gimple_ssa_operands (cfun
)->free_uses
;
526 gimple_ssa_operands (cfun
)->free_uses
= old_ops
;
529 /* If we added a VUSE, make sure to set the operand if it is not already
530 present and mark it for renaming. */
531 if (build_vuse
!= NULL_TREE
532 && gimple_vuse (stmt
) == NULL_TREE
)
534 gimple_set_vuse (stmt
, gimple_vop (cfun
));
535 mark_sym_for_renaming (gimple_vop (cfun
));
538 /* Now create nodes for all the new nodes. */
539 for (new_i
= 0; new_i
< VEC_length (tree
, build_uses
); new_i
++)
540 last
= add_use_op (stmt
,
541 (tree
*) VEC_index (tree
, build_uses
, new_i
),
544 /* Now set the stmt's operands. */
545 gimple_set_use_ops (stmt
, new_list
.next
);
549 /* Clear the in_list bits and empty the build array for VDEFs and
553 cleanup_build_arrays (void)
555 build_vdef
= NULL_TREE
;
556 build_vuse
= NULL_TREE
;
557 VEC_truncate (tree
, build_defs
, 0);
558 VEC_truncate (tree
, build_uses
, 0);
562 /* Finalize all the build vectors, fill the new ones into INFO. */
565 finalize_ssa_stmt_operands (gimple stmt
)
567 finalize_ssa_defs (stmt
);
568 finalize_ssa_uses (stmt
);
569 cleanup_build_arrays ();
573 /* Start the process of building up operands vectors in INFO. */
576 start_ssa_stmt_operands (void)
578 gcc_assert (VEC_length (tree
, build_defs
) == 0);
579 gcc_assert (VEC_length (tree
, build_uses
) == 0);
580 gcc_assert (build_vuse
== NULL_TREE
);
581 gcc_assert (build_vdef
== NULL_TREE
);
585 /* Add DEF_P to the list of pointers to operands. */
588 append_def (tree
*def_p
)
590 VEC_safe_push (tree
, heap
, build_defs
, (tree
) def_p
);
594 /* Add USE_P to the list of pointers to operands. */
597 append_use (tree
*use_p
)
599 VEC_safe_push (tree
, heap
, build_uses
, (tree
) use_p
);
603 /* Add VAR to the set of variables that require a VDEF operator. */
606 append_vdef (tree var
)
611 gcc_assert ((build_vdef
== NULL_TREE
612 || build_vdef
== var
)
613 && (build_vuse
== NULL_TREE
614 || build_vuse
== var
));
621 /* Add VAR to the set of variables that require a VUSE operator. */
624 append_vuse (tree var
)
629 gcc_assert (build_vuse
== NULL_TREE
630 || build_vuse
== var
);
635 /* Add virtual operands for STMT. FLAGS is as in get_expr_operands. */
638 add_virtual_operand (gimple stmt ATTRIBUTE_UNUSED
, int flags
)
640 /* Add virtual operands to the stmt, unless the caller has specifically
641 requested not to do that (used when adding operands inside an
642 ADDR_EXPR expression). */
643 if (flags
& opf_no_vops
)
646 gcc_assert (!is_gimple_debug (stmt
));
649 append_vdef (gimple_vop (cfun
));
651 append_vuse (gimple_vop (cfun
));
655 /* Add *VAR_P to the appropriate operand array for statement STMT.
656 FLAGS is as in get_expr_operands. If *VAR_P is a GIMPLE register,
657 it will be added to the statement's real operands, otherwise it is
658 added to virtual operands. */
661 add_stmt_operand (tree
*var_p
, gimple stmt
, int flags
)
665 gcc_assert (SSA_VAR_P (*var_p
));
668 sym
= (TREE_CODE (var
) == SSA_NAME
? SSA_NAME_VAR (var
) : var
);
670 /* Mark statements with volatile operands. */
671 if (TREE_THIS_VOLATILE (sym
))
672 gimple_set_has_volatile_ops (stmt
, true);
674 if (is_gimple_reg (sym
))
676 /* The variable is a GIMPLE register. Add it to real operands. */
683 add_virtual_operand (stmt
, flags
);
686 /* Mark the base address of REF as having its address taken.
687 REF may be a single variable whose address has been taken or any
688 other valid GIMPLE memory reference (structure reference, array,
692 mark_address_taken (tree ref
)
696 /* Note that it is *NOT OKAY* to use the target of a COMPONENT_REF
697 as the only thing we take the address of. If VAR is a structure,
698 taking the address of a field means that the whole structure may
699 be referenced using pointer arithmetic. See PR 21407 and the
700 ensuing mailing list discussion. */
701 var
= get_base_address (ref
);
705 TREE_ADDRESSABLE (var
) = 1;
706 else if (TREE_CODE (var
) == MEM_REF
707 && TREE_CODE (TREE_OPERAND (var
, 0)) == ADDR_EXPR
708 && DECL_P (TREE_OPERAND (TREE_OPERAND (var
, 0), 0)))
709 TREE_ADDRESSABLE (TREE_OPERAND (TREE_OPERAND (var
, 0), 0)) = 1;
714 /* A subroutine of get_expr_operands to handle MEM_REF.
716 STMT is the statement being processed, EXPR is the MEM_REF
719 FLAGS is as in get_expr_operands.
721 RECURSE_ON_BASE should be set to true if we want to continue
722 calling get_expr_operands on the base pointer, and false if
723 something else will do it for us. */
726 get_indirect_ref_operands (gimple stmt
, tree expr
, int flags
,
727 bool recurse_on_base
)
729 tree
*pptr
= &TREE_OPERAND (expr
, 0);
731 if (TREE_THIS_VOLATILE (expr
))
732 gimple_set_has_volatile_ops (stmt
, true);
735 add_virtual_operand (stmt
, flags
);
737 /* If requested, add a USE operand for the base pointer. */
739 get_expr_operands (stmt
, pptr
,
740 opf_non_addressable
| opf_use
741 | (flags
& (opf_no_vops
|opf_not_non_addressable
)));
745 /* A subroutine of get_expr_operands to handle TARGET_MEM_REF. */
748 get_tmr_operands (gimple stmt
, tree expr
, int flags
)
750 if (TREE_THIS_VOLATILE (expr
))
751 gimple_set_has_volatile_ops (stmt
, true);
753 /* First record the real operands. */
754 get_expr_operands (stmt
, &TMR_BASE (expr
), opf_use
| (flags
& opf_no_vops
));
755 get_expr_operands (stmt
, &TMR_INDEX (expr
), opf_use
| (flags
& opf_no_vops
));
756 get_expr_operands (stmt
, &TMR_INDEX2 (expr
), opf_use
| (flags
& opf_no_vops
));
758 add_virtual_operand (stmt
, flags
);
762 /* If STMT is a call that may clobber globals and other symbols that
763 escape, add them to the VDEF/VUSE lists for it. */
766 maybe_add_call_vops (gimple stmt
)
768 int call_flags
= gimple_call_flags (stmt
);
770 /* If aliases have been computed already, add VDEF or VUSE
771 operands for all the symbols that have been found to be
773 if (!(call_flags
& ECF_NOVOPS
))
775 /* A 'pure' or a 'const' function never call-clobbers anything.
776 A 'noreturn' function might, but since we don't return anyway
777 there is no point in recording that. */
778 if (!(call_flags
& (ECF_PURE
| ECF_CONST
| ECF_NORETURN
)))
779 add_virtual_operand (stmt
, opf_def
);
780 else if (!(call_flags
& ECF_CONST
))
781 add_virtual_operand (stmt
, opf_use
);
786 /* Scan operands in the ASM_EXPR stmt referred to in INFO. */
789 get_asm_expr_operands (gimple stmt
)
792 const char **oconstraints
;
793 const char *constraint
;
794 bool allows_mem
, allows_reg
, is_inout
;
796 noutputs
= gimple_asm_noutputs (stmt
);
797 oconstraints
= (const char **) alloca ((noutputs
) * sizeof (const char *));
799 /* Gather all output operands. */
800 for (i
= 0; i
< gimple_asm_noutputs (stmt
); i
++)
802 tree link
= gimple_asm_output_op (stmt
, i
);
803 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link
)));
804 oconstraints
[i
] = constraint
;
805 parse_output_constraint (&constraint
, i
, 0, 0, &allows_mem
,
806 &allows_reg
, &is_inout
);
808 /* This should have been split in gimplify_asm_expr. */
809 gcc_assert (!allows_reg
|| !is_inout
);
811 /* Memory operands are addressable. Note that STMT needs the
812 address of this operand. */
813 if (!allows_reg
&& allows_mem
)
814 mark_address_taken (TREE_VALUE (link
));
816 get_expr_operands (stmt
, &TREE_VALUE (link
), opf_def
| opf_not_non_addressable
);
819 /* Gather all input operands. */
820 for (i
= 0; i
< gimple_asm_ninputs (stmt
); i
++)
822 tree link
= gimple_asm_input_op (stmt
, i
);
823 constraint
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link
)));
824 parse_input_constraint (&constraint
, 0, 0, noutputs
, 0, oconstraints
,
825 &allows_mem
, &allows_reg
);
827 /* Memory operands are addressable. Note that STMT needs the
828 address of this operand. */
829 if (!allows_reg
&& allows_mem
)
830 mark_address_taken (TREE_VALUE (link
));
832 get_expr_operands (stmt
, &TREE_VALUE (link
), opf_not_non_addressable
);
835 /* Clobber all memory and addressable symbols for asm ("" : : : "memory"); */
836 for (i
= 0; i
< gimple_asm_nclobbers (stmt
); i
++)
838 tree link
= gimple_asm_clobber_op (stmt
, i
);
839 if (strcmp (TREE_STRING_POINTER (TREE_VALUE (link
)), "memory") == 0)
841 add_virtual_operand (stmt
, opf_def
);
848 /* Recursively scan the expression pointed to by EXPR_P in statement
849 STMT. FLAGS is one of the OPF_* constants modifying how to
850 interpret the operands found. */
853 get_expr_operands (gimple stmt
, tree
*expr_p
, int flags
)
856 enum tree_code_class codeclass
;
858 int uflags
= opf_use
;
863 if (is_gimple_debug (stmt
))
864 uflags
|= (flags
& opf_no_vops
);
866 code
= TREE_CODE (expr
);
867 codeclass
= TREE_CODE_CLASS (code
);
872 /* Taking the address of a variable does not represent a
873 reference to it, but the fact that the statement takes its
874 address will be of interest to some passes (e.g. alias
876 if ((!(flags
& opf_non_addressable
)
877 || (flags
& opf_not_non_addressable
))
878 && !is_gimple_debug (stmt
))
879 mark_address_taken (TREE_OPERAND (expr
, 0));
881 /* If the address is invariant, there may be no interesting
882 variable references inside. */
883 if (is_gimple_min_invariant (expr
))
886 /* Otherwise, there may be variables referenced inside but there
887 should be no VUSEs created, since the referenced objects are
888 not really accessed. The only operands that we should find
889 here are ARRAY_REF indices which will always be real operands
890 (GIMPLE does not allow non-registers as array indices). */
891 flags
|= opf_no_vops
;
892 get_expr_operands (stmt
, &TREE_OPERAND (expr
, 0),
893 flags
| opf_not_non_addressable
);
897 add_stmt_operand (expr_p
, stmt
, flags
);
903 add_stmt_operand (expr_p
, stmt
, flags
);
906 case DEBUG_EXPR_DECL
:
907 gcc_assert (gimple_debug_bind_p (stmt
));
911 get_indirect_ref_operands (stmt
, expr
, flags
, true);
915 get_tmr_operands (stmt
, expr
, flags
);
919 case ARRAY_RANGE_REF
:
924 if (TREE_THIS_VOLATILE (expr
))
925 gimple_set_has_volatile_ops (stmt
, true);
927 get_expr_operands (stmt
, &TREE_OPERAND (expr
, 0), flags
);
929 if (code
== COMPONENT_REF
)
931 if (TREE_THIS_VOLATILE (TREE_OPERAND (expr
, 1)))
932 gimple_set_has_volatile_ops (stmt
, true);
933 get_expr_operands (stmt
, &TREE_OPERAND (expr
, 2), uflags
);
935 else if (code
== ARRAY_REF
|| code
== ARRAY_RANGE_REF
)
937 get_expr_operands (stmt
, &TREE_OPERAND (expr
, 1), uflags
);
938 get_expr_operands (stmt
, &TREE_OPERAND (expr
, 2), uflags
);
939 get_expr_operands (stmt
, &TREE_OPERAND (expr
, 3), uflags
);
946 /* WITH_SIZE_EXPR is a pass-through reference to its first argument,
947 and an rvalue reference to its second argument. */
948 get_expr_operands (stmt
, &TREE_OPERAND (expr
, 1), uflags
);
949 get_expr_operands (stmt
, &TREE_OPERAND (expr
, 0), flags
);
954 get_expr_operands (stmt
, &TREE_OPERAND (expr
, 0), uflags
);
955 get_expr_operands (stmt
, &TREE_OPERAND (expr
, 1), uflags
);
956 get_expr_operands (stmt
, &TREE_OPERAND (expr
, 2), uflags
);
961 /* General aggregate CONSTRUCTORs have been decomposed, but they
962 are still in use as the COMPLEX_EXPR equivalent for vectors. */
964 unsigned HOST_WIDE_INT idx
;
967 VEC_iterate (constructor_elt
, CONSTRUCTOR_ELTS (expr
), idx
, ce
);
969 get_expr_operands (stmt
, &ce
->value
, uflags
);
975 if (TREE_THIS_VOLATILE (expr
))
976 gimple_set_has_volatile_ops (stmt
, true);
980 case VIEW_CONVERT_EXPR
:
982 get_expr_operands (stmt
, &TREE_OPERAND (expr
, 0), flags
);
993 get_expr_operands (stmt
, &TREE_OPERAND (expr
, 0), flags
);
994 get_expr_operands (stmt
, &TREE_OPERAND (expr
, 1), flags
);
999 case REALIGN_LOAD_EXPR
:
1000 case WIDEN_MULT_PLUS_EXPR
:
1001 case WIDEN_MULT_MINUS_EXPR
:
1003 get_expr_operands (stmt
, &TREE_OPERAND (expr
, 0), flags
);
1004 get_expr_operands (stmt
, &TREE_OPERAND (expr
, 1), flags
);
1005 get_expr_operands (stmt
, &TREE_OPERAND (expr
, 2), flags
);
1012 case CASE_LABEL_EXPR
:
1013 /* Expressions that make no memory references. */
1017 if (codeclass
== tcc_unary
)
1019 if (codeclass
== tcc_binary
|| codeclass
== tcc_comparison
)
1021 if (codeclass
== tcc_constant
|| codeclass
== tcc_type
)
1025 /* If we get here, something has gone wrong. */
1026 #ifdef ENABLE_CHECKING
1027 fprintf (stderr
, "unhandled expression in get_expr_operands():\n");
1029 fputs ("\n", stderr
);
1035 /* Parse STMT looking for operands. When finished, the various
1036 build_* operand vectors will have potential operands in them. */
1039 parse_ssa_operands (gimple stmt
)
1041 enum gimple_code code
= gimple_code (stmt
);
1043 if (code
== GIMPLE_ASM
)
1044 get_asm_expr_operands (stmt
);
1045 else if (is_gimple_debug (stmt
))
1047 if (gimple_debug_bind_p (stmt
)
1048 && gimple_debug_bind_has_value_p (stmt
))
1049 get_expr_operands (stmt
, gimple_debug_bind_get_value_ptr (stmt
),
1050 opf_use
| opf_no_vops
);
1054 size_t i
, start
= 0;
1056 if (code
== GIMPLE_ASSIGN
|| code
== GIMPLE_CALL
)
1058 get_expr_operands (stmt
, gimple_op_ptr (stmt
, 0), opf_def
);
1062 for (i
= start
; i
< gimple_num_ops (stmt
); i
++)
1063 get_expr_operands (stmt
, gimple_op_ptr (stmt
, i
), opf_use
);
1065 /* Add call-clobbered operands, if needed. */
1066 if (code
== GIMPLE_CALL
)
1067 maybe_add_call_vops (stmt
);
1072 /* Create an operands cache for STMT. */
1075 build_ssa_operands (gimple stmt
)
1077 /* Initially assume that the statement has no volatile operands. */
1078 gimple_set_has_volatile_ops (stmt
, false);
1080 start_ssa_stmt_operands ();
1081 parse_ssa_operands (stmt
);
1082 finalize_ssa_stmt_operands (stmt
);
1086 /* Releases the operands of STMT back to their freelists, and clears
1087 the stmt operand lists. */
1090 free_stmt_operands (gimple stmt
)
1092 def_optype_p defs
= gimple_def_ops (stmt
), last_def
;
1093 use_optype_p uses
= gimple_use_ops (stmt
), last_use
;
1097 for (last_def
= defs
; last_def
->next
; last_def
= last_def
->next
)
1099 last_def
->next
= gimple_ssa_operands (cfun
)->free_defs
;
1100 gimple_ssa_operands (cfun
)->free_defs
= defs
;
1101 gimple_set_def_ops (stmt
, NULL
);
1106 for (last_use
= uses
; last_use
->next
; last_use
= last_use
->next
)
1107 delink_imm_use (USE_OP_PTR (last_use
));
1108 delink_imm_use (USE_OP_PTR (last_use
));
1109 last_use
->next
= gimple_ssa_operands (cfun
)->free_uses
;
1110 gimple_ssa_operands (cfun
)->free_uses
= uses
;
1111 gimple_set_use_ops (stmt
, NULL
);
1114 if (gimple_has_mem_ops (stmt
))
1116 gimple_set_vuse (stmt
, NULL_TREE
);
1117 gimple_set_vdef (stmt
, NULL_TREE
);
1122 /* Get the operands of statement STMT. */
1125 update_stmt_operands (gimple stmt
)
1127 /* If update_stmt_operands is called before SSA is initialized, do
1129 if (!ssa_operands_active ())
1132 timevar_push (TV_TREE_OPS
);
1134 gcc_assert (gimple_modified_p (stmt
));
1135 build_ssa_operands (stmt
);
1136 gimple_set_modified (stmt
, false);
1138 timevar_pop (TV_TREE_OPS
);
1142 /* Swap operands EXP0 and EXP1 in statement STMT. No attempt is done
1143 to test the validity of the swap operation. */
1146 swap_tree_operands (gimple stmt
, tree
*exp0
, tree
*exp1
)
1152 /* If the operand cache is active, attempt to preserve the relative
1153 positions of these two operands in their respective immediate use
1155 if (ssa_operands_active () && op0
!= op1
)
1157 use_optype_p use0
, use1
, ptr
;
1160 /* Find the 2 operands in the cache, if they are there. */
1161 for (ptr
= gimple_use_ops (stmt
); ptr
; ptr
= ptr
->next
)
1162 if (USE_OP_PTR (ptr
)->use
== exp0
)
1168 for (ptr
= gimple_use_ops (stmt
); ptr
; ptr
= ptr
->next
)
1169 if (USE_OP_PTR (ptr
)->use
== exp1
)
1175 /* If both uses don't have operand entries, there isn't much we can do
1176 at this point. Presumably we don't need to worry about it. */
1179 tree
*tmp
= USE_OP_PTR (use1
)->use
;
1180 USE_OP_PTR (use1
)->use
= USE_OP_PTR (use0
)->use
;
1181 USE_OP_PTR (use0
)->use
= tmp
;
1185 /* Now swap the data. */
1191 /* Scan the immediate_use list for VAR making sure its linked properly.
1192 Return TRUE if there is a problem and emit an error message to F. */
1195 verify_imm_links (FILE *f
, tree var
)
1197 use_operand_p ptr
, prev
, list
;
1200 gcc_assert (TREE_CODE (var
) == SSA_NAME
);
1202 list
= &(SSA_NAME_IMM_USE_NODE (var
));
1203 gcc_assert (list
->use
== NULL
);
1205 if (list
->prev
== NULL
)
1207 gcc_assert (list
->next
== NULL
);
1213 for (ptr
= list
->next
; ptr
!= list
; )
1215 if (prev
!= ptr
->prev
)
1218 if (ptr
->use
== NULL
)
1219 goto error
; /* 2 roots, or SAFE guard node. */
1220 else if (*(ptr
->use
) != var
)
1226 /* Avoid infinite loops. 50,000,000 uses probably indicates a
1228 if (count
++ > 50000000)
1232 /* Verify list in the other direction. */
1234 for (ptr
= list
->prev
; ptr
!= list
; )
1236 if (prev
!= ptr
->next
)
1250 if (ptr
->loc
.stmt
&& gimple_modified_p (ptr
->loc
.stmt
))
1252 fprintf (f
, " STMT MODIFIED. - <%p> ", (void *)ptr
->loc
.stmt
);
1253 print_gimple_stmt (f
, ptr
->loc
.stmt
, 0, TDF_SLIM
);
1255 fprintf (f
, " IMM ERROR : (use_p : tree - %p:%p)", (void *)ptr
,
1257 print_generic_expr (f
, USE_FROM_PTR (ptr
), TDF_SLIM
);
1263 /* Dump all the immediate uses to FILE. */
1266 dump_immediate_uses_for (FILE *file
, tree var
)
1268 imm_use_iterator iter
;
1269 use_operand_p use_p
;
1271 gcc_assert (var
&& TREE_CODE (var
) == SSA_NAME
);
1273 print_generic_expr (file
, var
, TDF_SLIM
);
1274 fprintf (file
, " : -->");
1275 if (has_zero_uses (var
))
1276 fprintf (file
, " no uses.\n");
1278 if (has_single_use (var
))
1279 fprintf (file
, " single use.\n");
1281 fprintf (file
, "%d uses.\n", num_imm_uses (var
));
1283 FOR_EACH_IMM_USE_FAST (use_p
, iter
, var
)
1285 if (use_p
->loc
.stmt
== NULL
&& use_p
->use
== NULL
)
1286 fprintf (file
, "***end of stmt iterator marker***\n");
1288 if (!is_gimple_reg (USE_FROM_PTR (use_p
)))
1289 print_gimple_stmt (file
, USE_STMT (use_p
), 0, TDF_VOPS
|TDF_MEMSYMS
);
1291 print_gimple_stmt (file
, USE_STMT (use_p
), 0, TDF_SLIM
);
1293 fprintf(file
, "\n");
1297 /* Dump all the immediate uses to FILE. */
1300 dump_immediate_uses (FILE *file
)
1305 fprintf (file
, "Immediate_uses: \n\n");
1306 for (x
= 1; x
< num_ssa_names
; x
++)
1311 dump_immediate_uses_for (file
, var
);
1316 /* Dump def-use edges on stderr. */
1319 debug_immediate_uses (void)
1321 dump_immediate_uses (stderr
);
1325 /* Dump def-use edges on stderr. */
1328 debug_immediate_uses_for (tree var
)
1330 dump_immediate_uses_for (stderr
, var
);
1334 /* Unlink STMTs virtual definition from the IL by propagating its use. */
1337 unlink_stmt_vdef (gimple stmt
)
1339 use_operand_p use_p
;
1340 imm_use_iterator iter
;
1342 tree vdef
= gimple_vdef (stmt
);
1345 || TREE_CODE (vdef
) != SSA_NAME
)
1348 FOR_EACH_IMM_USE_STMT (use_stmt
, iter
, gimple_vdef (stmt
))
1350 FOR_EACH_IMM_USE_ON_STMT (use_p
, iter
)
1351 SET_USE (use_p
, gimple_vuse (stmt
));
1354 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (gimple_vdef (stmt
)))
1355 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (gimple_vuse (stmt
)) = 1;