1 /* Data flow functions for trees.
2 Copyright (C) 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
3 Contributed by Diego Novillo <dnovillo@redhat.com>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
24 #include "coretypes.h"
30 #include "hard-reg-set.h"
31 #include "basic-block.h"
37 #include "langhooks.h"
40 #include "diagnostic.h"
41 #include "tree-dump.h"
42 #include "tree-gimple.h"
43 #include "tree-flow.h"
44 #include "tree-inline.h"
45 #include "tree-pass.h"
49 /* Build and maintain data flow information for trees. */
51 /* Counters used to display DFA and SSA statistics. */
67 /* State information for find_vars_r. */
70 /* Hash table used to avoid adding the same variable more than once. */
75 /* Local functions. */
76 static void collect_dfa_stats (struct dfa_stats_d
*);
77 static tree
collect_dfa_stats_r (tree
*, int *, void *);
78 static void add_immediate_use (tree
, tree
);
79 static tree
find_vars_r (tree
*, int *, void *);
80 static void add_referenced_var (tree
, struct walk_state
*);
81 static void compute_immediate_uses_for_phi (tree
, bool (*)(tree
));
82 static void compute_immediate_uses_for_stmt (tree
, int, bool (*)(tree
));
85 /* Global declarations. */
87 /* Array of all variables referenced in the function. */
88 varray_type referenced_vars
;
91 /*---------------------------------------------------------------------------
92 Dataflow analysis (DFA) routines
93 ---------------------------------------------------------------------------*/
94 /* Find all the variables referenced in the function. This function
95 builds the global arrays REFERENCED_VARS and CALL_CLOBBERED_VARS.
97 Note that this function does not look for statement operands, it simply
98 determines what variables are referenced in the program and detects
99 various attributes for each variable used by alias analysis and the
103 find_referenced_vars (void)
107 block_stmt_iterator si
;
108 struct walk_state walk_state
;
110 vars_found
= htab_create (50, htab_hash_pointer
, htab_eq_pointer
, NULL
);
111 memset (&walk_state
, 0, sizeof (walk_state
));
112 walk_state
.vars_found
= vars_found
;
115 for (si
= bsi_start (bb
); !bsi_end_p (si
); bsi_next (&si
))
117 tree
*stmt_p
= bsi_stmt_ptr (si
);
118 walk_tree (stmt_p
, find_vars_r
, &walk_state
, NULL
);
121 htab_delete (vars_found
);
124 struct tree_opt_pass pass_referenced_vars
=
128 find_referenced_vars
, /* execute */
131 0, /* static_pass_number */
133 PROP_gimple_leh
| PROP_cfg
, /* properties_required */
134 PROP_referenced_vars
, /* properties_provided */
135 0, /* properties_destroyed */
136 0, /* todo_flags_start */
137 0, /* todo_flags_finish */
142 /* Compute immediate uses.
144 CALC_FOR is an optional function pointer which indicates whether
145 immediate uses information should be calculated for a given SSA
146 variable. If NULL, then information is computed for all
149 FLAGS is one of {TDFA_USE_OPS, TDFA_USE_VOPS}. It is used by
150 compute_immediate_uses_for_stmt to determine whether to look at
151 virtual and/or real operands while computing def-use chains. */
154 compute_immediate_uses (int flags
, bool (*calc_for
)(tree
))
157 block_stmt_iterator si
;
163 for (phi
= phi_nodes (bb
); phi
; phi
= PHI_CHAIN (phi
))
165 if (is_gimple_reg (PHI_RESULT (phi
)))
167 if (!(flags
& TDFA_USE_OPS
))
172 if (!(flags
& TDFA_USE_VOPS
))
176 compute_immediate_uses_for_phi (phi
, calc_for
);
179 for (si
= bsi_start (bb
); !bsi_end_p (si
); bsi_next (&si
))
181 tree stmt
= bsi_stmt (si
);
182 get_stmt_operands (stmt
);
183 compute_immediate_uses_for_stmt (stmt
, flags
, calc_for
);
189 /* Invalidates dataflow information for a statement STMT. */
192 free_df_for_stmt (tree stmt
)
196 if (TREE_CODE (stmt
) == PHI_NODE
)
200 stmt_ann_t ann
= stmt_ann (stmt
);
211 /* If we have a varray of immediate uses, then go ahead and release
213 if ((*df
)->immediate_uses
)
214 ggc_free ((*df
)->immediate_uses
);
216 /* Similarly for the main dataflow structure. */
222 /* Invalidate dataflow information for the whole function. */
228 block_stmt_iterator si
;
234 for (phi
= phi_nodes (bb
); phi
; phi
= PHI_CHAIN (phi
))
235 free_df_for_stmt (phi
);
237 for (si
= bsi_start (bb
); !bsi_end_p (si
); bsi_next (&si
))
239 tree stmt
= bsi_stmt (si
);
240 free_df_for_stmt (stmt
);
246 /* Helper for compute_immediate_uses. Check all the USE and/or VUSE
247 operands in phi node PHI and add a def-use edge between their
248 defining statement and PHI. CALC_FOR is as in
249 compute_immediate_uses.
251 PHI nodes are easy, we only need to look at their arguments. */
254 compute_immediate_uses_for_phi (tree phi
, bool (*calc_for
)(tree
))
258 gcc_assert (TREE_CODE (phi
) == PHI_NODE
);
260 for (i
= 0; i
< PHI_NUM_ARGS (phi
); i
++)
262 tree arg
= PHI_ARG_DEF (phi
, i
);
264 if (TREE_CODE (arg
) == SSA_NAME
&& (!calc_for
|| calc_for (arg
)))
266 tree imm_rdef_stmt
= SSA_NAME_DEF_STMT (PHI_ARG_DEF (phi
, i
));
267 if (!IS_EMPTY_STMT (imm_rdef_stmt
))
268 add_immediate_use (imm_rdef_stmt
, phi
);
274 /* Another helper for compute_immediate_uses. Depending on the value
275 of FLAGS, check all the USE and/or VUSE operands in STMT and add a
276 def-use edge between their defining statement and STMT. CALC_FOR
277 is as in compute_immediate_uses. */
280 compute_immediate_uses_for_stmt (tree stmt
, int flags
, bool (*calc_for
)(tree
))
285 /* PHI nodes are handled elsewhere. */
286 gcc_assert (TREE_CODE (stmt
) != PHI_NODE
);
288 /* Look at USE_OPS or VUSE_OPS according to FLAGS. */
289 if (flags
& TDFA_USE_OPS
)
291 FOR_EACH_SSA_TREE_OPERAND (use
, stmt
, iter
, SSA_OP_USE
)
293 tree imm_stmt
= SSA_NAME_DEF_STMT (use
);
294 if (!IS_EMPTY_STMT (imm_stmt
) && (!calc_for
|| calc_for (use
)))
295 add_immediate_use (imm_stmt
, stmt
);
299 if (flags
& TDFA_USE_VOPS
)
301 FOR_EACH_SSA_TREE_OPERAND (use
, stmt
, iter
, SSA_OP_VIRTUAL_USES
)
303 tree imm_rdef_stmt
= SSA_NAME_DEF_STMT (use
);
304 if (!IS_EMPTY_STMT (imm_rdef_stmt
) && (!calc_for
|| calc_for (use
)))
305 add_immediate_use (imm_rdef_stmt
, stmt
);
311 /* Add statement USE_STMT to the list of statements that use definitions
315 add_immediate_use (tree stmt
, tree use_stmt
)
317 struct dataflow_d
**df
;
319 if (TREE_CODE (stmt
) == PHI_NODE
)
323 stmt_ann_t ann
= get_stmt_ann (stmt
);
329 *df
= ggc_alloc (sizeof (struct dataflow_d
));
330 memset ((void *) *df
, 0, sizeof (struct dataflow_d
));
331 (*df
)->uses
[0] = use_stmt
;
337 (*df
)->uses
[1] = use_stmt
;
341 if ((*df
)->immediate_uses
== NULL
)
342 VARRAY_TREE_INIT ((*df
)->immediate_uses
, 4, "immediate_uses");
344 VARRAY_PUSH_TREE ((*df
)->immediate_uses
, use_stmt
);
348 /* If the immediate use of USE points to OLD, then redirect it to NEW. */
351 redirect_immediate_use (tree use
, tree old
, tree
new)
353 tree imm_stmt
= SSA_NAME_DEF_STMT (use
);
354 struct dataflow_d
*df
= get_immediate_uses (imm_stmt
);
355 unsigned int num_uses
= num_immediate_uses (df
);
358 for (i
= 0; i
< num_uses
; i
++)
360 if (immediate_use (df
, i
) == old
)
362 if (i
== 0 || i
== 1)
365 VARRAY_TREE (df
->immediate_uses
, i
- 2) = new;
371 /* Redirect all immediate uses for operands in OLD so that they point
372 to NEW. This routine should have no knowledge of how immediate
376 redirect_immediate_uses (tree old
, tree
new)
381 FOR_EACH_SSA_TREE_OPERAND (val
, old
, iter
, SSA_OP_ALL_USES
)
382 redirect_immediate_use (val
, old
, new);
386 /*---------------------------------------------------------------------------
388 ---------------------------------------------------------------------------*/
389 /* Create a new annotation for a _DECL node T. */
392 create_var_ann (tree t
)
397 gcc_assert (DECL_P (t
));
398 gcc_assert (!t
->common
.ann
|| t
->common
.ann
->common
.type
== VAR_ANN
);
400 ann
= ggc_alloc (sizeof (*ann
));
401 memset ((void *) ann
, 0, sizeof (*ann
));
403 ann
->common
.type
= VAR_ANN
;
405 t
->common
.ann
= (tree_ann_t
) ann
;
411 /* Create a new annotation for a statement node T. */
414 create_stmt_ann (tree t
)
418 gcc_assert (is_gimple_stmt (t
));
419 gcc_assert (!t
->common
.ann
|| t
->common
.ann
->common
.type
== STMT_ANN
);
421 ann
= ggc_alloc (sizeof (*ann
));
422 memset ((void *) ann
, 0, sizeof (*ann
));
424 ann
->common
.type
= STMT_ANN
;
426 /* Since we just created the annotation, mark the statement modified. */
427 ann
->modified
= true;
429 t
->common
.ann
= (tree_ann_t
) ann
;
435 /* Create a new annotation for a tree T. */
438 create_tree_ann (tree t
)
443 gcc_assert (!t
->common
.ann
|| t
->common
.ann
->common
.type
== TREE_ANN_COMMON
);
445 ann
= ggc_alloc (sizeof (*ann
));
446 memset ((void *) ann
, 0, sizeof (*ann
));
448 ann
->common
.type
= TREE_ANN_COMMON
;
454 /* Build a temporary. Make sure and register it to be renamed. */
457 make_rename_temp (tree type
, const char *prefix
)
459 tree t
= create_tmp_var (type
, prefix
);
462 add_referenced_tmp_var (t
);
463 bitmap_set_bit (vars_to_rename
, var_ann (t
)->uid
);
470 /*---------------------------------------------------------------------------
472 ---------------------------------------------------------------------------*/
473 /* Dump the list of all the referenced variables in the current function to
477 dump_referenced_vars (FILE *file
)
481 fprintf (file
, "\nReferenced variables in %s: %u\n\n",
482 get_name (current_function_decl
), (unsigned) num_referenced_vars
);
484 for (i
= 0; i
< num_referenced_vars
; i
++)
486 tree var
= referenced_var (i
);
487 fprintf (file
, "Variable: ");
488 dump_variable (file
, var
);
489 fprintf (file
, "\n");
494 /* Dump the list of all the referenced variables to stderr. */
497 debug_referenced_vars (void)
499 dump_referenced_vars (stderr
);
503 /* Dump variable VAR and its may-aliases to FILE. */
506 dump_variable (FILE *file
, tree var
)
510 if (TREE_CODE (var
) == SSA_NAME
)
512 if (POINTER_TYPE_P (TREE_TYPE (var
)))
513 dump_points_to_info_for (file
, var
);
514 var
= SSA_NAME_VAR (var
);
517 if (var
== NULL_TREE
)
519 fprintf (file
, "<nil>");
523 print_generic_expr (file
, var
, dump_flags
);
527 fprintf (file
, ", UID %u", (unsigned) ann
->uid
);
529 if (ann
->type_mem_tag
)
531 fprintf (file
, ", type memory tag: ");
532 print_generic_expr (file
, ann
->type_mem_tag
, dump_flags
);
535 if (ann
->is_alias_tag
)
536 fprintf (file
, ", is an alias tag");
538 if (TREE_ADDRESSABLE (var
))
539 fprintf (file
, ", is addressable");
541 if (is_global_var (var
))
542 fprintf (file
, ", is global");
544 if (is_call_clobbered (var
))
545 fprintf (file
, ", call clobbered");
547 if (ann
->default_def
)
549 fprintf (file
, ", default def: ");
550 print_generic_expr (file
, ann
->default_def
, dump_flags
);
553 if (ann
->may_aliases
)
555 fprintf (file
, ", may aliases: ");
556 dump_may_aliases_for (file
, var
);
559 fprintf (file
, "\n");
563 /* Dump variable VAR and its may-aliases to stderr. */
566 debug_variable (tree var
)
568 dump_variable (stderr
, var
);
572 /* Dump def-use edges on FILE. */
575 dump_immediate_uses (FILE *file
)
578 block_stmt_iterator si
;
580 = lang_hooks
.decl_printable_name (current_function_decl
, 2);
582 fprintf (file
, "\nDef-use edges for function %s\n", funcname
);
588 for (phi
= phi_nodes (bb
); phi
; phi
= PHI_CHAIN (phi
))
589 dump_immediate_uses_for (file
, phi
);
591 for (si
= bsi_start (bb
); !bsi_end_p (si
); bsi_next (&si
))
592 dump_immediate_uses_for (file
, bsi_stmt (si
));
595 fprintf (file
, "\n");
599 /* Dump def-use edges on stderr. */
602 debug_immediate_uses (void)
604 dump_immediate_uses (stderr
);
608 /* Dump all immediate uses for STMT on FILE. */
611 dump_immediate_uses_for (FILE *file
, tree stmt
)
613 dataflow_t df
= get_immediate_uses (stmt
);
614 int num_imm_uses
= num_immediate_uses (df
);
616 if (num_imm_uses
> 0)
620 fprintf (file
, "-> ");
621 print_generic_stmt (file
, stmt
, TDF_SLIM
);
622 fprintf (file
, "\n");
624 for (i
= 0; i
< num_imm_uses
; i
++)
626 fprintf (file
, "\t");
627 print_generic_stmt (file
, immediate_use (df
, i
), TDF_SLIM
);
628 fprintf (file
, "\n");
631 fprintf (file
, "\n");
636 /* Dump immediate uses for STMT on stderr. */
639 debug_immediate_uses_for (tree stmt
)
641 dump_immediate_uses_for (stderr
, stmt
);
645 /* Dump various DFA statistics to FILE. */
648 dump_dfa_stats (FILE *file
)
650 struct dfa_stats_d dfa_stats
;
652 unsigned long size
, total
= 0;
653 const char * const fmt_str
= "%-30s%-13s%12s\n";
654 const char * const fmt_str_1
= "%-30s%13lu%11lu%c\n";
655 const char * const fmt_str_3
= "%-43s%11lu%c\n";
657 = lang_hooks
.decl_printable_name (current_function_decl
, 2);
659 collect_dfa_stats (&dfa_stats
);
661 fprintf (file
, "\nDFA Statistics for %s\n\n", funcname
);
663 fprintf (file
, "---------------------------------------------------------\n");
664 fprintf (file
, fmt_str
, "", " Number of ", "Memory");
665 fprintf (file
, fmt_str
, "", " instances ", "used ");
666 fprintf (file
, "---------------------------------------------------------\n");
668 size
= num_referenced_vars
* sizeof (tree
);
670 fprintf (file
, fmt_str_1
, "Referenced variables", num_referenced_vars
,
671 SCALE (size
), LABEL (size
));
673 size
= dfa_stats
.num_stmt_anns
* sizeof (struct stmt_ann_d
);
675 fprintf (file
, fmt_str_1
, "Statements annotated", dfa_stats
.num_stmt_anns
,
676 SCALE (size
), LABEL (size
));
678 size
= dfa_stats
.num_var_anns
* sizeof (struct var_ann_d
);
680 fprintf (file
, fmt_str_1
, "Variables annotated", dfa_stats
.num_var_anns
,
681 SCALE (size
), LABEL (size
));
683 size
= dfa_stats
.num_uses
* sizeof (tree
*);
685 fprintf (file
, fmt_str_1
, "USE operands", dfa_stats
.num_uses
,
686 SCALE (size
), LABEL (size
));
688 size
= dfa_stats
.num_defs
* sizeof (tree
*);
690 fprintf (file
, fmt_str_1
, "DEF operands", dfa_stats
.num_defs
,
691 SCALE (size
), LABEL (size
));
693 size
= dfa_stats
.num_vuses
* sizeof (tree
*);
695 fprintf (file
, fmt_str_1
, "VUSE operands", dfa_stats
.num_vuses
,
696 SCALE (size
), LABEL (size
));
698 size
= dfa_stats
.num_v_may_defs
* sizeof (tree
*);
700 fprintf (file
, fmt_str_1
, "V_MAY_DEF operands", dfa_stats
.num_v_may_defs
,
701 SCALE (size
), LABEL (size
));
703 size
= dfa_stats
.num_v_must_defs
* sizeof (tree
*);
705 fprintf (file
, fmt_str_1
, "V_MUST_DEF operands", dfa_stats
.num_v_must_defs
,
706 SCALE (size
), LABEL (size
));
708 size
= dfa_stats
.num_phis
* sizeof (struct tree_phi_node
);
710 fprintf (file
, fmt_str_1
, "PHI nodes", dfa_stats
.num_phis
,
711 SCALE (size
), LABEL (size
));
713 size
= dfa_stats
.num_phi_args
* sizeof (struct phi_arg_d
);
715 fprintf (file
, fmt_str_1
, "PHI arguments", dfa_stats
.num_phi_args
,
716 SCALE (size
), LABEL (size
));
718 fprintf (file
, "---------------------------------------------------------\n");
719 fprintf (file
, fmt_str_3
, "Total memory used by DFA/SSA data", SCALE (total
),
721 fprintf (file
, "---------------------------------------------------------\n");
722 fprintf (file
, "\n");
724 if (dfa_stats
.num_phis
)
725 fprintf (file
, "Average number of arguments per PHI node: %.1f (max: %d)\n",
726 (float) dfa_stats
.num_phi_args
/ (float) dfa_stats
.num_phis
,
727 dfa_stats
.max_num_phi_args
);
729 fprintf (file
, "\n");
733 /* Dump DFA statistics on stderr. */
736 debug_dfa_stats (void)
738 dump_dfa_stats (stderr
);
742 /* Collect DFA statistics and store them in the structure pointed by
746 collect_dfa_stats (struct dfa_stats_d
*dfa_stats_p
)
750 block_stmt_iterator i
;
752 gcc_assert (dfa_stats_p
);
754 memset ((void *)dfa_stats_p
, 0, sizeof (struct dfa_stats_d
));
756 /* Walk all the trees in the function counting references. Start at
757 basic block 0, but don't stop at block boundaries. */
758 htab
= htab_create (30, htab_hash_pointer
, htab_eq_pointer
, NULL
);
760 for (i
= bsi_start (BASIC_BLOCK (0)); !bsi_end_p (i
); bsi_next (&i
))
761 walk_tree (bsi_stmt_ptr (i
), collect_dfa_stats_r
, (void *) dfa_stats_p
,
769 for (phi
= phi_nodes (bb
); phi
; phi
= PHI_CHAIN (phi
))
771 dfa_stats_p
->num_phis
++;
772 dfa_stats_p
->num_phi_args
+= PHI_NUM_ARGS (phi
);
773 if (PHI_NUM_ARGS (phi
) > dfa_stats_p
->max_num_phi_args
)
774 dfa_stats_p
->max_num_phi_args
= PHI_NUM_ARGS (phi
);
780 /* Callback for walk_tree to collect DFA statistics for a tree and its
784 collect_dfa_stats_r (tree
*tp
, int *walk_subtrees ATTRIBUTE_UNUSED
,
788 struct dfa_stats_d
*dfa_stats_p
= (struct dfa_stats_d
*)data
;
792 switch (ann_type (t
->common
.ann
))
796 stmt_ann_t ann
= (stmt_ann_t
) t
->common
.ann
;
797 dfa_stats_p
->num_stmt_anns
++;
798 dfa_stats_p
->num_defs
+= NUM_DEFS (DEF_OPS (ann
));
799 dfa_stats_p
->num_uses
+= NUM_USES (USE_OPS (ann
));
800 dfa_stats_p
->num_v_may_defs
+=
801 NUM_V_MAY_DEFS (V_MAY_DEF_OPS (ann
));
802 dfa_stats_p
->num_vuses
+= NUM_VUSES (VUSE_OPS (ann
));
803 dfa_stats_p
->num_v_must_defs
+=
804 NUM_V_MUST_DEFS (V_MUST_DEF_OPS (ann
));
809 dfa_stats_p
->num_var_anns
++;
821 /*---------------------------------------------------------------------------
822 Miscellaneous helpers
823 ---------------------------------------------------------------------------*/
824 /* Callback for walk_tree. Used to collect variables referenced in
828 find_vars_r (tree
*tp
, int *walk_subtrees
, void *data
)
830 struct walk_state
*walk_state
= (struct walk_state
*) data
;
832 /* If T is a regular variable that the optimizers are interested
833 in, add it to the list of variables. */
835 add_referenced_var (*tp
, walk_state
);
837 /* Type, _DECL and constant nodes have no interesting children.
839 else if (DECL_P (*tp
)
841 || TREE_CODE_CLASS (TREE_CODE (*tp
)) == 'c')
848 /* Add VAR to the list of dereferenced variables.
850 WALK_STATE contains a hash table used to avoid adding the same
851 variable more than once. Note that this function assumes that
852 VAR is a valid SSA variable. If WALK_STATE is NULL, no
853 duplicate checking is done. */
856 add_referenced_var (tree var
, struct walk_state
*walk_state
)
861 v_ann
= get_var_ann (var
);
864 slot
= htab_find_slot (walk_state
->vars_found
, (void *) var
, INSERT
);
868 if (slot
== NULL
|| *slot
== NULL
)
870 /* This is the first time we find this variable, add it to the
871 REFERENCED_VARS array and annotate it with attributes that are
872 intrinsic to the variable. */
874 *slot
= (void *) var
;
875 v_ann
->uid
= num_referenced_vars
;
876 VARRAY_PUSH_TREE (referenced_vars
, var
);
878 /* Global variables are always call-clobbered. */
879 if (is_global_var (var
))
880 mark_call_clobbered (var
);
882 /* If an initialized global variable then register the initializer
884 if (POINTER_TYPE_P (TREE_TYPE (var
))
885 && TREE_READONLY (var
)
886 && DECL_INITIAL (var
)
887 && TREE_CODE (DECL_INITIAL (var
)) == ADDR_EXPR
)
888 walk_tree (&DECL_INITIAL (var
), find_vars_r
, walk_state
, 0);
893 /* Return the virtual variable associated to the non-scalar variable VAR. */
896 get_virtual_var (tree var
)
900 if (TREE_CODE (var
) == SSA_NAME
)
901 var
= SSA_NAME_VAR (var
);
903 while (TREE_CODE (var
) == REALPART_EXPR
|| TREE_CODE (var
) == IMAGPART_EXPR
904 || handled_component_p (var
))
905 var
= TREE_OPERAND (var
, 0);
907 /* Treating GIMPLE registers as virtual variables makes no sense.
908 Also complain if we couldn't extract a _DECL out of the original
910 gcc_assert (SSA_VAR_P (var
));
911 gcc_assert (!is_gimple_reg (var
));
916 /* Add a temporary variable to REFERENCED_VARS. This is similar to
917 add_referenced_var, but is used by passes that need to add new temps to
918 the REFERENCED_VARS array after the program has been scanned for
919 variables. The variable will just receive a new UID and be added
920 to the REFERENCED_VARS array without checking for duplicates. */
923 add_referenced_tmp_var (tree var
)
925 add_referenced_var (var
, NULL
);
929 /* Add all the non-SSA variables found in STMT's operands to the bitmap
933 mark_new_vars_to_rename (tree stmt
, bitmap vars_to_rename
)
937 bitmap vars_in_vops_to_rename
;
938 bool found_exposed_symbol
= false;
939 int v_may_defs_before
, v_may_defs_after
;
940 int v_must_defs_before
, v_must_defs_after
;
942 vars_in_vops_to_rename
= BITMAP_XMALLOC ();
944 /* Before re-scanning the statement for operands, mark the existing
945 virtual operands to be renamed again. We do this because when new
946 symbols are exposed, the virtual operands that were here before due to
947 aliasing will probably be removed by the call to get_stmt_operand.
948 Therefore, we need to flag them to be renamed beforehand.
950 We flag them in a separate bitmap because we don't really want to
951 rename them if there are not any newly exposed symbols in the
952 statement operands. */
953 v_may_defs_before
= NUM_V_MAY_DEFS (STMT_V_MAY_DEF_OPS (stmt
));
954 v_must_defs_before
= NUM_V_MUST_DEFS (STMT_V_MUST_DEF_OPS (stmt
));
956 FOR_EACH_SSA_TREE_OPERAND (val
, stmt
, iter
,
957 SSA_OP_VMAYDEF
| SSA_OP_VUSE
| SSA_OP_VMUSTDEF
)
960 val
= SSA_NAME_VAR (val
);
961 bitmap_set_bit (vars_in_vops_to_rename
, var_ann (val
)->uid
);
964 /* Now force an operand re-scan on the statement and mark any newly
965 exposed variables. */
967 get_stmt_operands (stmt
);
969 v_may_defs_after
= NUM_V_MAY_DEFS (STMT_V_MAY_DEF_OPS (stmt
));
970 v_must_defs_after
= NUM_V_MUST_DEFS (STMT_V_MUST_DEF_OPS (stmt
));
972 FOR_EACH_SSA_TREE_OPERAND (val
, stmt
, iter
,
973 SSA_OP_VMAYDEF
| SSA_OP_VUSE
| SSA_OP_VMUSTDEF
)
978 found_exposed_symbol
= true;
979 bitmap_set_bit (vars_to_rename
, var_ann (val
)->uid
);
983 /* If we found any newly exposed symbols, or if there are fewer VDEF
984 operands in the statement, add the variables we had set in
985 VARS_IN_VOPS_TO_RENAME to VARS_TO_RENAME. We need to check for
986 vanishing VDEFs because in those cases, the names that were formerly
987 generated by this statement are not going to be available anymore. */
988 if (found_exposed_symbol
989 || v_may_defs_before
> v_may_defs_after
990 || v_must_defs_before
> v_must_defs_after
)
991 bitmap_a_or_b (vars_to_rename
, vars_to_rename
, vars_in_vops_to_rename
);
993 BITMAP_XFREE (vars_in_vops_to_rename
);