1 /* Miscellaneous SSA utility functions.
2 Copyright (C) 2001, 2002, 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"
30 #include "langhooks.h"
31 #include "hard-reg-set.h"
32 #include "basic-block.h"
37 #include "diagnostic.h"
39 #include "tree-flow.h"
40 #include "tree-gimple.h"
41 #include "tree-inline.h"
44 #include "tree-alias-common.h"
46 #include "tree-dump.h"
47 #include "tree-pass.h"
50 /* Remove edge E and remove the corresponding arguments from the PHI nodes
51 in E's destination block. */
54 ssa_remove_edge (edge e
)
58 /* Remove the appropriate PHI arguments in E's destination block. */
59 for (phi
= phi_nodes (e
->dest
); phi
; phi
= next
)
61 next
= TREE_CHAIN (phi
);
62 remove_phi_arg (phi
, e
->src
);
68 /* Remove remove the corresponding arguments from the PHI nodes
69 in E's destination block and redirect it to DEST. Return redirected edge.
70 The list of removed arguments is stored in PENDING_STMT (e). */
73 ssa_redirect_edge (edge e
, basic_block dest
)
76 tree list
= NULL
, *last
= &list
;
80 /* Remove the appropriate PHI arguments in E's destination block. */
81 for (phi
= phi_nodes (e
->dest
); phi
; phi
= next
)
83 next
= TREE_CHAIN (phi
);
85 i
= phi_arg_from_edge (phi
, e
);
89 src
= PHI_ARG_DEF (phi
, i
);
90 dst
= PHI_RESULT (phi
);
91 node
= build_tree_list (dst
, src
);
93 last
= &TREE_CHAIN (node
);
95 remove_phi_arg_num (phi
, i
);
98 e
= redirect_edge_succ_nodup (e
, dest
);
99 PENDING_STMT (e
) = list
;
105 /* Return true if the definition of SSA_NAME at block BB is malformed.
107 STMT is the statement where SSA_NAME is created.
109 DEFINITION_BLOCK is an array of basic blocks indexed by SSA_NAME version
110 numbers. If DEFINITION_BLOCK[SSA_NAME_VERSION] is set, it means that the
111 block in that array slot contains the definition of SSA_NAME. */
114 verify_def (basic_block bb
, basic_block
*definition_block
, tree ssa_name
,
119 if (TREE_CODE (ssa_name
) != SSA_NAME
)
121 error ("Expected an SSA_NAME object");
122 debug_generic_stmt (ssa_name
);
123 debug_generic_stmt (stmt
);
126 if (definition_block
[SSA_NAME_VERSION (ssa_name
)])
128 error ("SSA_NAME created in two different blocks %i and %i",
129 definition_block
[SSA_NAME_VERSION (ssa_name
)]->index
, bb
->index
);
130 fprintf (stderr
, "SSA_NAME: ");
131 debug_generic_stmt (ssa_name
);
132 debug_generic_stmt (stmt
);
136 definition_block
[SSA_NAME_VERSION (ssa_name
)] = bb
;
138 if (SSA_NAME_DEF_STMT (ssa_name
) != stmt
)
140 error ("SSA_NAME_DEF_STMT is wrong");
141 fprintf (stderr
, "SSA_NAME: ");
142 debug_generic_stmt (ssa_name
);
143 fprintf (stderr
, "Expected definition statement:\n");
144 debug_generic_stmt (SSA_NAME_DEF_STMT (ssa_name
));
145 fprintf (stderr
, "\nActual definition statement:\n");
146 debug_generic_stmt (stmt
);
154 /* Return true if the use of SSA_NAME at statement STMT in block BB is
157 DEF_BB is the block where SSA_NAME was found to be created.
159 IDOM contains immediate dominator information for the flowgraph.
161 CHECK_ABNORMAL is true if the caller wants to check whether this use
162 is flowing through an abnormal edge (only used when checking PHI
166 verify_use (basic_block bb
, basic_block def_bb
, tree ssa_name
,
167 tree stmt
, bool check_abnormal
)
171 if (IS_EMPTY_STMT (SSA_NAME_DEF_STMT (ssa_name
)))
172 ; /* Nothing to do. */
175 error ("Missing definition");
178 else if (bb
!= def_bb
179 && !dominated_by_p (CDI_DOMINATORS
, bb
, def_bb
))
181 error ("Definition in block %i does not dominate use in block %i",
182 def_bb
->index
, bb
->index
);
187 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ssa_name
))
189 error ("SSA_NAME_OCCURS_IN_ABNORMAL_PHI should be set");
195 fprintf (stderr
, "for SSA_NAME: ");
196 debug_generic_stmt (ssa_name
);
197 fprintf (stderr
, "in statement:\n");
198 debug_generic_stmt (stmt
);
205 /* Return true if any of the arguments for PHI node PHI at block BB is
208 IDOM contains immediate dominator information for the flowgraph.
210 DEFINITION_BLOCK is an array of basic blocks indexed by SSA_NAME version
211 numbers. If DEFINITION_BLOCK[SSA_NAME_VERSION] is set, it means that the
212 block in that array slot contains the definition of SSA_NAME. */
215 verify_phi_args (tree phi
, basic_block bb
, basic_block
*definition_block
)
219 int i
, phi_num_args
= PHI_NUM_ARGS (phi
);
221 /* Mark all the incoming edges. */
222 for (e
= bb
->pred
; e
; e
= e
->pred_next
)
225 for (i
= 0; i
< phi_num_args
; i
++)
227 tree op
= PHI_ARG_DEF (phi
, i
);
229 e
= PHI_ARG_EDGE (phi
, i
);
231 if (TREE_CODE (op
) == SSA_NAME
)
232 err
|= verify_use (e
->src
, definition_block
[SSA_NAME_VERSION (op
)], op
,
233 phi
, e
->flags
& EDGE_ABNORMAL
);
237 error ("Wrong edge %d->%d for PHI argument\n",
238 e
->src
->index
, e
->dest
->index
, bb
->index
);
242 if (e
->aux
== (void *) 0)
244 error ("PHI argument flowing through dead edge %d->%d\n",
245 e
->src
->index
, e
->dest
->index
);
249 if (e
->aux
== (void *) 2)
251 error ("PHI argument duplicated for edge %d->%d\n", e
->src
->index
,
258 fprintf (stderr
, "PHI argument\n");
259 debug_generic_stmt (op
);
265 for (e
= bb
->pred
; e
; e
= e
->pred_next
)
267 if (e
->aux
!= (void *) 2)
269 error ("No argument flowing through edge %d->%d\n", e
->src
->index
,
278 fprintf (stderr
, "for PHI node\n");
279 debug_generic_stmt (phi
);
287 /* Verify common invariants in the SSA web.
288 TODO: verify the variable annotations. */
295 basic_block
*definition_block
= xcalloc (highest_ssa_version
,
296 sizeof (basic_block
));
298 timevar_push (TV_TREE_SSA_VERIFY
);
300 calculate_dominance_info (CDI_DOMINATORS
);
302 /* Verify and register all the SSA_NAME definitions found in the
307 block_stmt_iterator bsi
;
309 for (phi
= phi_nodes (bb
); phi
; phi
= TREE_CHAIN (phi
))
310 err
|= verify_def (bb
, definition_block
, PHI_RESULT (phi
), phi
);
312 for (bsi
= bsi_start (bb
); !bsi_end_p (bsi
); bsi_next (&bsi
))
317 v_may_def_optype v_may_defs
;
318 v_must_def_optype v_must_defs
;
321 stmt
= bsi_stmt (bsi
);
322 ann
= stmt_ann (stmt
);
323 get_stmt_operands (stmt
);
325 v_may_defs
= V_MAY_DEF_OPS (ann
);
326 if (ann
->makes_aliased_stores
&& NUM_V_MAY_DEFS (v_may_defs
) == 0)
327 error ("Makes aliased stores, but no V_MAY_DEFS");
329 for (j
= 0; j
< NUM_V_MAY_DEFS (v_may_defs
); j
++)
331 tree op
= V_MAY_DEF_RESULT (v_may_defs
, j
);
332 if (is_gimple_reg (op
))
334 error ("Found a virtual definition for a GIMPLE register");
335 debug_generic_stmt (op
);
336 debug_generic_stmt (stmt
);
339 err
|= verify_def (bb
, definition_block
, op
, stmt
);
342 v_must_defs
= STMT_V_MUST_DEF_OPS (stmt
);
343 for (j
= 0; j
< NUM_V_MUST_DEFS (v_must_defs
); j
++)
345 tree op
= V_MUST_DEF_OP (v_must_defs
, j
);
346 if (is_gimple_reg (op
))
348 error ("Found a virtual must-def for a GIMPLE register");
349 debug_generic_stmt (op
);
350 debug_generic_stmt (stmt
);
353 err
|= verify_def (bb
, definition_block
, op
, stmt
);
356 defs
= DEF_OPS (ann
);
357 for (j
= 0; j
< NUM_DEFS (defs
); j
++)
359 tree op
= DEF_OP (defs
, j
);
360 if (TREE_CODE (op
) == SSA_NAME
&& !is_gimple_reg (op
))
362 error ("Found a real definition for a non-GIMPLE register");
363 debug_generic_stmt (op
);
364 debug_generic_stmt (stmt
);
367 err
|= verify_def (bb
, definition_block
, op
, stmt
);
373 /* Now verify all the uses and make sure they agree with the definitions
374 found in the previous pass. */
379 block_stmt_iterator bsi
;
381 /* Make sure that all edges have a clear 'aux' field. */
382 for (e
= bb
->pred
; e
; e
= e
->pred_next
)
386 error ("AUX pointer initialized for edge %d->%d\n", e
->src
->index
,
392 /* Verify the arguments for every PHI node in the block. */
393 for (phi
= phi_nodes (bb
); phi
; phi
= TREE_CHAIN (phi
))
394 err
|= verify_phi_args (phi
, bb
, definition_block
);
396 /* Now verify all the uses and vuses in every statement of the block.
398 Remember, the RHS of a V_MAY_DEF is a use as well. */
399 for (bsi
= bsi_start (bb
); !bsi_end_p (bsi
); bsi_next (&bsi
))
401 tree stmt
= bsi_stmt (bsi
);
402 stmt_ann_t ann
= stmt_ann (stmt
);
405 v_may_def_optype v_may_defs
;
408 vuses
= VUSE_OPS (ann
);
409 for (j
= 0; j
< NUM_VUSES (vuses
); j
++)
411 tree op
= VUSE_OP (vuses
, j
);
413 if (is_gimple_reg (op
))
415 error ("Found a virtual use for a GIMPLE register");
416 debug_generic_stmt (op
);
417 debug_generic_stmt (stmt
);
420 err
|= verify_use (bb
, definition_block
[SSA_NAME_VERSION (op
)],
424 v_may_defs
= V_MAY_DEF_OPS (ann
);
425 for (j
= 0; j
< NUM_V_MAY_DEFS (v_may_defs
); j
++)
427 tree op
= V_MAY_DEF_OP (v_may_defs
, j
);
429 if (is_gimple_reg (op
))
431 error ("Found a virtual use for a GIMPLE register");
432 debug_generic_stmt (op
);
433 debug_generic_stmt (stmt
);
436 err
|= verify_use (bb
, definition_block
[SSA_NAME_VERSION (op
)],
440 uses
= USE_OPS (ann
);
441 for (j
= 0; j
< NUM_USES (uses
); j
++)
443 tree op
= USE_OP (uses
, j
);
445 if (TREE_CODE (op
) == SSA_NAME
&& !is_gimple_reg (op
))
447 error ("Found a real use of a non-GIMPLE register");
448 debug_generic_stmt (op
);
449 debug_generic_stmt (stmt
);
452 err
|= verify_use (bb
, definition_block
[SSA_NAME_VERSION (op
)],
458 free (definition_block
);
460 timevar_pop (TV_TREE_SSA_VERIFY
);
463 internal_error ("verify_ssa failed.");
467 /* Set the USED bit in the annotation for T. */
477 switch (TREE_CODE (t
))
485 t
= TREE_OPERAND (t
, 0);
493 if (TREE_CODE (t
) == SSA_NAME
)
494 t
= SSA_NAME_VAR (t
);
496 var_ann (t
)->used
= 1;
500 /* Initialize global DFA and SSA structures. */
505 VARRAY_TREE_INIT (referenced_vars
, 20, "referenced_vars");
506 call_clobbered_vars
= BITMAP_XMALLOC ();
507 init_ssa_operands ();
510 global_var
= NULL_TREE
;
511 aliases_computed_p
= false;
515 /* Deallocate memory associated with SSA data structures for FNDECL. */
518 delete_tree_ssa (void)
522 block_stmt_iterator bsi
;
524 /* Remove annotations from every tree in the function. */
526 for (bsi
= bsi_start (bb
); !bsi_end_p (bsi
); bsi_next (&bsi
))
527 bsi_stmt (bsi
)->common
.ann
= NULL
;
529 /* Remove annotations from every referenced variable. */
532 for (i
= 0; i
< num_referenced_vars
; i
++)
533 referenced_var (i
)->common
.ann
= NULL
;
534 referenced_vars
= NULL
;
539 fini_ssa_operands ();
541 global_var
= NULL_TREE
;
542 BITMAP_XFREE (call_clobbered_vars
);
543 call_clobbered_vars
= NULL
;
544 aliases_computed_p
= false;
548 /* Return true if EXPR is a useless type conversion, otherwise return
552 tree_ssa_useless_type_conversion_1 (tree outer_type
, tree inner_type
)
554 /* If the inner and outer types are effectively the same, then
555 strip the type conversion and enter the equivalence into
557 if (inner_type
== outer_type
558 || (lang_hooks
.types_compatible_p (inner_type
, outer_type
)))
561 /* If both types are pointers and the outer type is a (void *), then
562 the conversion is not necessary. The opposite is not true since
563 that conversion would result in a loss of information if the
564 equivalence was used. Consider an indirect function call where
565 we need to know the exact type of the function to correctly
566 implement the ABI. */
567 else if (POINTER_TYPE_P (inner_type
)
568 && POINTER_TYPE_P (outer_type
)
569 && TREE_CODE (TREE_TYPE (outer_type
)) == VOID_TYPE
)
572 /* Pointers and references are equivalent once we get to GENERIC,
573 so strip conversions that just switch between them. */
574 else if (POINTER_TYPE_P (inner_type
)
575 && POINTER_TYPE_P (outer_type
)
576 && lang_hooks
.types_compatible_p (TREE_TYPE (inner_type
),
577 TREE_TYPE (outer_type
)))
580 /* If both the inner and outer types are integral types, then the
581 conversion is not necessary if they have the same mode and
582 signedness and precision. Note that type _Bool can have size of
583 4 (only happens on powerpc-darwin right now but can happen on any
584 target that defines BOOL_TYPE_SIZE to be INT_TYPE_SIZE) and a
585 precision of 1 while unsigned int is the same expect for a
586 precision of 4 so testing of precision is necessary. */
587 else if (INTEGRAL_TYPE_P (inner_type
)
588 && INTEGRAL_TYPE_P (outer_type
)
589 && TYPE_MODE (inner_type
) == TYPE_MODE (outer_type
)
590 && TYPE_UNSIGNED (inner_type
) == TYPE_UNSIGNED (outer_type
)
591 && TYPE_PRECISION (inner_type
) == TYPE_PRECISION (outer_type
))
594 /* Recurse for complex types. */
595 else if (TREE_CODE (inner_type
) == COMPLEX_TYPE
596 && TREE_CODE (outer_type
) == COMPLEX_TYPE
597 && tree_ssa_useless_type_conversion_1 (TREE_TYPE (outer_type
),
598 TREE_TYPE (inner_type
)))
604 /* Return true if EXPR is a useless type conversion, otherwise return
608 tree_ssa_useless_type_conversion (tree expr
)
610 /* If we have an assignment that merely uses a NOP_EXPR to change
611 the top of the RHS to the type of the LHS and the type conversion
612 is "safe", then strip away the type conversion so that we can
613 enter LHS = RHS into the const_and_copies table. */
614 if (TREE_CODE (expr
) == NOP_EXPR
|| TREE_CODE (expr
) == CONVERT_EXPR
)
615 return tree_ssa_useless_type_conversion_1 (TREE_TYPE (expr
),
616 TREE_TYPE (TREE_OPERAND (expr
,
624 /* Internal helper for walk_use_def_chains. VAR, FN and DATA are as
625 described in walk_use_def_chains. VISITED is a bitmap used to mark
626 visited SSA_NAMEs to avoid infinite loops. */
629 walk_use_def_chains_1 (tree var
, walk_use_def_chains_fn fn
, void *data
,
634 if (bitmap_bit_p (visited
, SSA_NAME_VERSION (var
)))
637 bitmap_set_bit (visited
, SSA_NAME_VERSION (var
));
639 def_stmt
= SSA_NAME_DEF_STMT (var
);
641 if (TREE_CODE (def_stmt
) != PHI_NODE
)
643 /* If we reached the end of the use-def chain, call FN. */
644 return (*fn
) (var
, def_stmt
, data
);
650 /* Otherwise, follow use-def links out of each PHI argument and call
651 FN after visiting each one. */
652 for (i
= 0; i
< PHI_NUM_ARGS (def_stmt
); i
++)
654 tree arg
= PHI_ARG_DEF (def_stmt
, i
);
655 if (TREE_CODE (arg
) == SSA_NAME
656 && walk_use_def_chains_1 (arg
, fn
, data
, visited
))
659 if ((*fn
) (arg
, def_stmt
, data
))
668 /* Walk use-def chains starting at the SSA variable VAR. Call function FN
669 at each reaching definition found. FN takes three arguments: VAR, its
670 defining statement (DEF_STMT) and a generic pointer to whatever state
671 information that FN may want to maintain (DATA). FN is able to stop the
672 walk by returning true, otherwise in order to continue the walk, FN
675 Note, that if DEF_STMT is a PHI node, the semantics are slightly
676 different. For each argument ARG of the PHI node, this function will:
678 1- Walk the use-def chains for ARG.
679 2- Call (*FN) (ARG, PHI, DATA).
681 Note how the first argument to FN is no longer the original variable
682 VAR, but the PHI argument currently being examined. If FN wants to get
683 at VAR, it should call PHI_RESULT (PHI). */
686 walk_use_def_chains (tree var
, walk_use_def_chains_fn fn
, void *data
)
690 #if defined ENABLE_CHECKING
691 if (TREE_CODE (var
) != SSA_NAME
)
695 def_stmt
= SSA_NAME_DEF_STMT (var
);
697 /* We only need to recurse if the reaching definition comes from a PHI
699 if (TREE_CODE (def_stmt
) != PHI_NODE
)
700 (*fn
) (var
, def_stmt
, data
);
703 bitmap visited
= BITMAP_XMALLOC ();
704 walk_use_def_chains_1 (var
, fn
, data
, visited
);
705 BITMAP_XFREE (visited
);
710 /* Replaces immediate uses of VAR by REPL. */
713 replace_immediate_uses (tree var
, tree repl
)
717 v_may_def_optype v_may_defs
;
723 df
= get_immediate_uses (SSA_NAME_DEF_STMT (var
));
724 n
= num_immediate_uses (df
);
726 for (i
= 0; i
< n
; i
++)
728 stmt
= immediate_use (df
, i
);
729 ann
= stmt_ann (stmt
);
731 if (TREE_CODE (stmt
) == PHI_NODE
)
733 for (j
= 0; j
< PHI_NUM_ARGS (stmt
); j
++)
734 if (PHI_ARG_DEF (stmt
, j
) == var
)
736 PHI_ARG_DEF (stmt
, j
) = repl
;
737 if (TREE_CODE (repl
) == SSA_NAME
738 && PHI_ARG_EDGE (stmt
, j
)->flags
& EDGE_ABNORMAL
)
739 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (repl
) = 1;
745 get_stmt_operands (stmt
);
746 if (is_gimple_reg (SSA_NAME_VAR (var
)))
748 uses
= USE_OPS (ann
);
749 for (j
= 0; j
< (int) NUM_USES (uses
); j
++)
750 if (USE_OP (uses
, j
) == var
)
751 propagate_value (USE_OP_PTR (uses
, j
), repl
);
755 vuses
= VUSE_OPS (ann
);
756 for (j
= 0; j
< (int) NUM_VUSES (vuses
); j
++)
757 if (VUSE_OP (vuses
, j
) == var
)
758 propagate_value (VUSE_OP_PTR (vuses
, j
), repl
);
760 v_may_defs
= V_MAY_DEF_OPS (ann
);
761 for (j
= 0; j
< (int) NUM_V_MAY_DEFS (v_may_defs
); j
++)
762 if (V_MAY_DEF_OP (v_may_defs
, j
) == var
)
763 propagate_value (V_MAY_DEF_OP_PTR (v_may_defs
, j
), repl
);
768 /* If REPL is a pointer, it may have different memory tags associated
769 with it. For instance, VAR may have had a name tag while REPL
770 only had a type tag. In these cases, the virtual operands (if
771 any) in the statement will refer to different symbols which need
773 if (POINTER_TYPE_P (TREE_TYPE (repl
)))
774 mark_new_vars_to_rename (stmt
, vars_to_rename
);
778 /* Raises value of phi node PHI by joining it with VAL. Processes immediate
779 uses of PHI recursively. */
782 raise_value (tree phi
, tree val
, tree
*eq_to
)
785 tree var
= PHI_RESULT (phi
), stmt
;
786 int ver
= SSA_NAME_VERSION (var
);
789 if (eq_to
[ver
] == var
)
792 switch (TREE_CODE (val
))
799 if (TREE_CODE (TREE_TYPE (var
)) != POINTER_TYPE
)
803 /* Do not propagate pointer constants. This might require folding
804 things like *&foo and rewriting the ssa, which is not worth the
811 if (operand_equal_p (eq_to
[ver
], val
, 0))
819 df
= get_immediate_uses (SSA_NAME_DEF_STMT (var
));
820 n
= num_immediate_uses (df
);
822 for (i
= 0; i
< n
; i
++)
824 stmt
= immediate_use (df
, i
);
826 if (TREE_CODE (stmt
) != PHI_NODE
)
829 raise_value (stmt
, eq_to
[ver
], eq_to
);
833 /* Removes redundant phi nodes.
835 A redundant PHI node is a PHI node where all of its PHI arguments
836 are the same value, excluding any PHI arguments which are the same
839 A redundant PHI node is effectively a copy, so we forward copy propagate
840 which removes all uses of the destination of the PHI node then
841 finally we delete the redundant PHI node.
843 Note that if we can not copy propagate the PHI node, then the PHI
844 will not be removed. Thus we do not have to worry about dependencies
845 between PHIs and the problems serializing PHIs into copies creates.
847 The most important effect of this pass is to remove degenerate PHI
848 nodes created by removing unreachable code. */
851 kill_redundant_phi_nodes (void)
853 tree
*eq_to
, *ssa_names
;
854 unsigned i
, ver
, aver
;
856 tree phi
, t
, stmt
, var
;
858 /* The EQ_TO array holds the current value of the ssa name in the
867 Bottom is represented by NULL and top by the variable itself.
869 Once the dataflow stabilizes, we know that the phi nodes we need to keep
870 are exactly those with top as their result.
872 The remaining phi nodes have their uses replaced with their value
873 in the lattice and the phi node itself is removed. */
874 eq_to
= xcalloc (highest_ssa_version
, sizeof (tree
));
876 /* The SSA_NAMES array holds each SSA_NAME node we encounter
877 in a PHI node (indexed by ssa version number).
879 One could argue that the SSA_NAME manager ought to provide a
880 generic interface to get at the SSA_NAME node for a given
881 ssa version number. */
882 ssa_names
= xcalloc (highest_ssa_version
, sizeof (tree
));
884 /* We have had cases where computing immediate uses takes a
885 significant amount of compile time. If we run into such
886 problems here, we may want to only compute immediate uses for
887 a subset of all the SSA_NAMEs instead of computing it for
888 all of the SSA_NAMEs. */
889 compute_immediate_uses (TDFA_USE_OPS
| TDFA_USE_VOPS
, NULL
);
893 for (phi
= phi_nodes (bb
); phi
; phi
= TREE_CHAIN (phi
))
895 var
= PHI_RESULT (phi
);
896 ver
= SSA_NAME_VERSION (var
);
897 ssa_names
[ver
] = var
;
899 for (i
= 0; i
< (unsigned) PHI_NUM_ARGS (phi
); i
++)
901 t
= PHI_ARG_DEF (phi
, i
);
903 if (TREE_CODE (t
) != SSA_NAME
)
905 raise_value (phi
, t
, eq_to
);
909 stmt
= SSA_NAME_DEF_STMT (t
);
910 aver
= SSA_NAME_VERSION (t
);
913 /* If the defining statement for this argument is not a
914 phi node or the argument is associated with an abnormal
915 edge, then we need to recursively start the forward
916 dataflow starting with PHI. */
917 if (TREE_CODE (stmt
) != PHI_NODE
918 || SSA_NAME_OCCURS_IN_ABNORMAL_PHI (t
))
921 raise_value (phi
, t
, eq_to
);
927 /* Now propagate the values. */
928 for (i
= 0; i
< highest_ssa_version
; i
++)
930 && eq_to
[i
] != ssa_names
[i
])
931 replace_immediate_uses (ssa_names
[i
], eq_to
[i
]);
933 /* And remove the dead phis. */
934 for (i
= 0; i
< highest_ssa_version
; i
++)
936 && eq_to
[i
] != ssa_names
[i
])
938 stmt
= SSA_NAME_DEF_STMT (ssa_names
[i
]);
939 remove_phi_node (stmt
, 0, bb_for_stmt (stmt
));
947 struct tree_opt_pass pass_redundant_phi
=
951 kill_redundant_phi_nodes
, /* execute */
954 0, /* static_pass_number */
956 PROP_cfg
| PROP_ssa
, /* properties_required */
957 0, /* properties_provided */
958 0, /* properties_destroyed */
959 0, /* todo_flags_start */
960 TODO_dump_func
| TODO_rename_vars
961 | TODO_ggc_collect
| TODO_verify_ssa
/* todo_flags_finish */
964 /* Emit warnings for uninitialized variables. This is done in two passes.
966 The first pass notices real uses of SSA names with default definitions.
967 Such uses are unconditionally uninitialized, and we can be certain that
968 such a use is a mistake. This pass is run before most optimizations,
969 so that we catch as many as we can.
971 The second pass follows PHI nodes to find uses that are potentially
972 uninitialized. In this case we can't necessarily prove that the use
973 is really uninitialized. This pass is run after most optimizations,
974 so that we thread as many jumps and possible, and delete as much dead
975 code as possible, in order to reduce false positives. We also look
976 again for plain uninitialized variables, since optimization may have
977 changed conditionally uninitialized to unconditionally uninitialized. */
979 /* Emit a warning for T, an SSA_NAME, being uninitialized. The exact
980 warning text is in MSGID and LOCUS may contain a location or be null. */
983 warn_uninit (tree t
, const char *msgid
, location_t
*locus
)
985 tree var
= SSA_NAME_VAR (t
);
986 tree def
= SSA_NAME_DEF_STMT (t
);
988 /* Default uses (indicated by an empty definition statement),
989 are uninitialized. */
990 if (!IS_EMPTY_STMT (def
))
993 /* Except for PARMs of course, which are always initialized. */
994 if (TREE_CODE (var
) == PARM_DECL
)
997 /* Hard register variables get their initial value from the ether. */
998 if (DECL_HARD_REGISTER (var
))
1001 /* TREE_NO_WARNING either means we already warned, or the front end
1002 wishes to suppress the warning. */
1003 if (TREE_NO_WARNING (var
))
1007 locus
= &DECL_SOURCE_LOCATION (var
);
1008 warning (msgid
, locus
, var
);
1009 TREE_NO_WARNING (var
) = 1;
1012 /* Called via walk_tree, look for SSA_NAMEs that have empty definitions
1013 and warn about them. */
1016 warn_uninitialized_var (tree
*tp
, int *walk_subtrees
, void *data
)
1018 location_t
*locus
= data
;
1021 /* We only do data flow with SSA_NAMEs, so that's all we can warn about. */
1022 if (TREE_CODE (t
) == SSA_NAME
)
1024 warn_uninit (t
, "%H'%D' is used uninitialized in this function", locus
);
1027 else if (DECL_P (t
) || TYPE_P (t
))
1033 /* Look for inputs to PHI that are SSA_NAMEs that have empty definitions
1034 and warn about them. */
1037 warn_uninitialized_phi (tree phi
)
1039 int i
, n
= PHI_NUM_ARGS (phi
);
1041 /* Don't look at memory tags. */
1042 if (!is_gimple_reg (PHI_RESULT (phi
)))
1045 for (i
= 0; i
< n
; ++i
)
1047 tree op
= PHI_ARG_DEF (phi
, i
);
1048 if (TREE_CODE (op
) == SSA_NAME
)
1049 warn_uninit (op
, "%H'%D' may be used uninitialized in this function",
1055 execute_early_warn_uninitialized (void)
1057 block_stmt_iterator bsi
;
1061 for (bsi
= bsi_start (bb
); !bsi_end_p (bsi
); bsi_next (&bsi
))
1062 walk_tree (bsi_stmt_ptr (bsi
), warn_uninitialized_var
,
1063 EXPR_LOCUS (bsi_stmt (bsi
)), NULL
);
1067 execute_late_warn_uninitialized (void)
1072 /* Re-do the plain uninitialized variable check, as optimization may have
1073 straightened control flow. Do this first so that we don't accidentally
1074 get a "may be" warning when we'd have seen an "is" warning later. */
1075 execute_early_warn_uninitialized ();
1078 for (phi
= phi_nodes (bb
); phi
; phi
= TREE_CHAIN (phi
))
1079 warn_uninitialized_phi (phi
);
1083 gate_warn_uninitialized (void)
1085 return warn_uninitialized
!= 0;
1088 struct tree_opt_pass pass_early_warn_uninitialized
=
1091 gate_warn_uninitialized
, /* gate */
1092 execute_early_warn_uninitialized
, /* execute */
1095 0, /* static_pass_number */
1097 PROP_ssa
, /* properties_required */
1098 0, /* properties_provided */
1099 0, /* properties_destroyed */
1100 0, /* todo_flags_start */
1101 0 /* todo_flags_finish */
1104 struct tree_opt_pass pass_late_warn_uninitialized
=
1107 gate_warn_uninitialized
, /* gate */
1108 execute_late_warn_uninitialized
, /* execute */
1111 0, /* static_pass_number */
1113 PROP_ssa
, /* properties_required */
1114 0, /* properties_provided */
1115 0, /* properties_destroyed */
1116 0, /* todo_flags_start */
1117 0 /* todo_flags_finish */