1 /* Miscellaneous SSA utility functions.
2 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009
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"
31 #include "langhooks.h"
32 #include "hard-reg-set.h"
33 #include "basic-block.h"
37 #include "diagnostic.h"
39 #include "pointer-set.h"
40 #include "tree-flow.h"
42 #include "tree-inline.h"
46 #include "tree-dump.h"
47 #include "tree-pass.h"
50 /* Pointer map of variable mappings, keyed by edge. */
51 static struct pointer_map_t
*edge_var_maps
;
54 /* Add a mapping with PHI RESULT and PHI DEF associated with edge E. */
57 redirect_edge_var_map_add (edge e
, tree result
, tree def
, source_location locus
)
60 edge_var_map_vector old_head
, head
;
61 edge_var_map new_node
;
63 if (edge_var_maps
== NULL
)
64 edge_var_maps
= pointer_map_create ();
66 slot
= pointer_map_insert (edge_var_maps
, e
);
67 old_head
= head
= (edge_var_map_vector
) *slot
;
70 head
= VEC_alloc (edge_var_map
, heap
, 5);
74 new_node
.result
= result
;
75 new_node
.locus
= locus
;
77 VEC_safe_push (edge_var_map
, heap
, head
, &new_node
);
80 /* The push did some reallocation. Update the pointer map. */
86 /* Clear the var mappings in edge E. */
89 redirect_edge_var_map_clear (edge e
)
92 edge_var_map_vector head
;
97 slot
= pointer_map_contains (edge_var_maps
, e
);
101 head
= (edge_var_map_vector
) *slot
;
102 VEC_free (edge_var_map
, heap
, head
);
108 /* Duplicate the redirected var mappings in OLDE in NEWE.
110 Since we can't remove a mapping, let's just duplicate it. This assumes a
111 pointer_map can have multiple edges mapping to the same var_map (many to
112 one mapping), since we don't remove the previous mappings. */
115 redirect_edge_var_map_dup (edge newe
, edge olde
)
117 void **new_slot
, **old_slot
;
118 edge_var_map_vector head
;
123 new_slot
= pointer_map_insert (edge_var_maps
, newe
);
124 old_slot
= pointer_map_contains (edge_var_maps
, olde
);
127 head
= (edge_var_map_vector
) *old_slot
;
130 *new_slot
= VEC_copy (edge_var_map
, heap
, head
);
132 *new_slot
= VEC_alloc (edge_var_map
, heap
, 5);
136 /* Return the variable mappings for a given edge. If there is none, return
140 redirect_edge_var_map_vector (edge e
)
144 /* Hey, what kind of idiot would... you'd be surprised. */
148 slot
= pointer_map_contains (edge_var_maps
, e
);
152 return (edge_var_map_vector
) *slot
;
155 /* Used by redirect_edge_var_map_destroy to free all memory. */
158 free_var_map_entry (const void *key ATTRIBUTE_UNUSED
,
160 void *data ATTRIBUTE_UNUSED
)
162 edge_var_map_vector head
= (edge_var_map_vector
) *value
;
163 VEC_free (edge_var_map
, heap
, head
);
167 /* Clear the edge variable mappings. */
170 redirect_edge_var_map_destroy (void)
174 pointer_map_traverse (edge_var_maps
, free_var_map_entry
, NULL
);
175 pointer_map_destroy (edge_var_maps
);
176 edge_var_maps
= NULL
;
181 /* Remove the corresponding arguments from the PHI nodes in E's
182 destination block and redirect it to DEST. Return redirected edge.
183 The list of removed arguments is stored in a vector accessed
184 through edge_var_maps. */
187 ssa_redirect_edge (edge e
, basic_block dest
)
189 gimple_stmt_iterator gsi
;
192 redirect_edge_var_map_clear (e
);
194 /* Remove the appropriate PHI arguments in E's destination block. */
195 for (gsi
= gsi_start_phis (e
->dest
); !gsi_end_p (gsi
); gsi_next (&gsi
))
198 source_location locus
;
200 phi
= gsi_stmt (gsi
);
201 def
= gimple_phi_arg_def (phi
, e
->dest_idx
);
202 locus
= gimple_phi_arg_location (phi
, e
->dest_idx
);
204 if (def
== NULL_TREE
)
207 redirect_edge_var_map_add (e
, gimple_phi_result (phi
), def
, locus
);
210 e
= redirect_edge_succ_nodup (e
, dest
);
216 /* Add PHI arguments queued in PENDING_STMT list on edge E to edge
220 flush_pending_stmts (edge e
)
223 edge_var_map_vector v
;
226 gimple_stmt_iterator gsi
;
228 v
= redirect_edge_var_map_vector (e
);
232 for (gsi
= gsi_start_phis (e
->dest
), i
= 0;
233 !gsi_end_p (gsi
) && VEC_iterate (edge_var_map
, v
, i
, vm
);
234 gsi_next (&gsi
), i
++)
238 phi
= gsi_stmt (gsi
);
239 def
= redirect_edge_var_map_def (vm
);
240 add_phi_arg (phi
, def
, e
, redirect_edge_var_map_location (vm
));
243 redirect_edge_var_map_clear (e
);
246 /* Given a tree for an expression for which we might want to emit
247 locations or values in debug information (generally a variable, but
248 we might deal with other kinds of trees in the future), return the
249 tree that should be used as the variable of a DEBUG_BIND STMT or
250 VAR_LOCATION INSN or NOTE. Return NULL if VAR is not to be tracked. */
253 target_for_debug_bind (tree var
)
255 if (!MAY_HAVE_DEBUG_STMTS
)
258 if (TREE_CODE (var
) != VAR_DECL
259 && TREE_CODE (var
) != PARM_DECL
)
262 if (DECL_HAS_VALUE_EXPR_P (var
))
263 return target_for_debug_bind (DECL_VALUE_EXPR (var
));
265 if (DECL_IGNORED_P (var
))
268 if (!is_gimple_reg (var
))
274 /* Called via walk_tree, look for SSA_NAMEs that have already been
278 find_released_ssa_name (tree
*tp
, int *walk_subtrees
, void *data_
)
280 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data_
;
285 if (TREE_CODE (*tp
) == SSA_NAME
)
287 if (SSA_NAME_IN_FREE_LIST (*tp
))
292 else if (IS_TYPE_OR_DECL_P (*tp
))
298 /* Insert a DEBUG BIND stmt before the DEF of VAR if VAR is referenced
299 by other DEBUG stmts, and replace uses of the DEF with the
300 newly-created debug temp. */
303 insert_debug_temp_for_var_def (gimple_stmt_iterator
*gsi
, tree var
)
305 imm_use_iterator imm_iter
;
308 gimple def_stmt
= NULL
;
312 if (!MAY_HAVE_DEBUG_STMTS
)
315 /* First of all, check whether there are debug stmts that reference
316 this variable and, if there are, decide whether we should use a
318 FOR_EACH_IMM_USE_FAST (use_p
, imm_iter
, var
)
320 stmt
= USE_STMT (use_p
);
322 if (!gimple_debug_bind_p (stmt
))
328 if (gimple_debug_bind_get_value (stmt
) != var
)
330 /* Count this as an additional use, so as to make sure we
331 use a temp unless VAR's definition has a SINGLE_RHS that
342 def_stmt
= gsi_stmt (*gsi
);
344 def_stmt
= SSA_NAME_DEF_STMT (var
);
346 /* If we didn't get an insertion point, and the stmt has already
347 been removed, we won't be able to insert the debug bind stmt, so
348 we'll have to drop debug information. */
349 if (is_gimple_assign (def_stmt
))
351 bool no_value
= false;
353 if (!dom_info_available_p (CDI_DOMINATORS
))
355 struct walk_stmt_info wi
;
357 memset (&wi
, 0, sizeof (wi
));
359 /* When removing blocks without following reverse dominance
360 order, we may sometimes encounter SSA_NAMEs that have
361 already been released, referenced in other SSA_DEFs that
362 we're about to release. Consider:
371 If we deleted BB X first, propagating the value of w_2
372 won't do us any good. It's too late to recover their
373 original definition of v_1: when it was deleted, it was
374 only referenced in other DEFs, it couldn't possibly know
375 it should have been retained, and propagating every
376 single DEF just in case it might have to be propagated
377 into a DEBUG STMT would probably be too wasteful.
379 When dominator information is not readily available, we
380 check for and accept some loss of debug information. But
381 if it is available, there's no excuse for us to remove
382 blocks in the wrong order, so we don't even check for
383 dead SSA NAMEs. SSA verification shall catch any
385 if ((!gsi
&& !gimple_bb (def_stmt
))
386 || !walk_gimple_op (def_stmt
, find_released_ssa_name
,
392 value
= gimple_assign_rhs_to_tree (def_stmt
);
397 /* If there's a single use of VAR, and VAR is the entire debug
398 expression (usecount would have been incremented again
399 otherwise), and the definition involves only constants and
400 SSA names, then we can propagate VALUE into this single use,
403 We can also avoid using a temp if VALUE can be shared and
404 propagated into all uses, without generating expressions that
405 wouldn't be valid gimple RHSs.
407 Other cases that would require unsharing or non-gimple RHSs
408 are deferred to a debug temp, although we could avoid temps
409 at the expense of duplication of expressions. */
411 if (CONSTANT_CLASS_P (value
)
413 && (!gimple_assign_single_p (def_stmt
)
414 || is_gimple_min_invariant (value
)))
415 || is_gimple_reg (value
))
416 value
= unshare_expr (value
);
420 tree vexpr
= make_node (DEBUG_EXPR_DECL
);
422 def_temp
= gimple_build_debug_bind (vexpr
,
423 unshare_expr (value
),
426 DECL_ARTIFICIAL (vexpr
) = 1;
427 TREE_TYPE (vexpr
) = TREE_TYPE (value
);
429 DECL_MODE (vexpr
) = DECL_MODE (value
);
431 DECL_MODE (vexpr
) = TYPE_MODE (TREE_TYPE (value
));
434 gsi_insert_before (gsi
, def_temp
, GSI_SAME_STMT
);
437 gimple_stmt_iterator ngsi
= gsi_for_stmt (def_stmt
);
438 gsi_insert_before (&ngsi
, def_temp
, GSI_SAME_STMT
);
445 FOR_EACH_IMM_USE_STMT (stmt
, imm_iter
, var
)
447 if (!gimple_debug_bind_p (stmt
))
451 FOR_EACH_IMM_USE_ON_STMT (use_p
, imm_iter
)
452 /* unshare_expr is not needed here. vexpr is either a
453 SINGLE_RHS, that can be safely shared, some other RHS
454 that was unshared when we found it had a single debug
455 use, or a DEBUG_EXPR_DECL, that can be safely
457 SET_USE (use_p
, value
);
459 gimple_debug_bind_reset_value (stmt
);
466 /* Insert a DEBUG BIND stmt before STMT for each DEF referenced by
467 other DEBUG stmts, and replace uses of the DEF with the
468 newly-created debug temp. */
471 insert_debug_temps_for_defs (gimple_stmt_iterator
*gsi
)
477 if (!MAY_HAVE_DEBUG_STMTS
)
480 stmt
= gsi_stmt (*gsi
);
482 FOR_EACH_SSA_DEF_OPERAND (def_p
, stmt
, op_iter
, SSA_OP_DEF
)
484 tree var
= DEF_FROM_PTR (def_p
);
486 if (TREE_CODE (var
) != SSA_NAME
)
489 insert_debug_temp_for_var_def (gsi
, var
);
493 /* Delete SSA DEFs for SSA versions in the TOREMOVE bitmap, removing
494 dominated stmts before their dominators, so that release_ssa_defs
495 stands a chance of propagating DEFs into debug bind stmts. */
498 release_defs_bitset (bitmap toremove
)
503 /* Performing a topological sort is probably overkill, this will
504 most likely run in slightly superlinear time, rather than the
505 pathological quadratic worst case. */
506 while (!bitmap_empty_p (toremove
))
507 EXECUTE_IF_SET_IN_BITMAP (toremove
, 0, j
, bi
)
509 bool remove_now
= true;
510 tree var
= ssa_name (j
);
512 imm_use_iterator uit
;
514 FOR_EACH_IMM_USE_STMT (stmt
, uit
, var
)
519 /* We can't propagate PHI nodes into debug stmts. */
520 if (gimple_code (stmt
) == GIMPLE_PHI
521 || is_gimple_debug (stmt
))
524 /* If we find another definition to remove that uses
525 the one we're looking at, defer the removal of this
526 one, so that it can be propagated into debug stmts
527 after the other is. */
528 FOR_EACH_SSA_DEF_OPERAND (def_p
, stmt
, dit
, SSA_OP_DEF
)
530 tree odef
= DEF_FROM_PTR (def_p
);
532 if (bitmap_bit_p (toremove
, SSA_NAME_VERSION (odef
)))
540 BREAK_FROM_IMM_USE_STMT (uit
);
545 gimple def
= SSA_NAME_DEF_STMT (var
);
546 gimple_stmt_iterator gsi
= gsi_for_stmt (def
);
548 if (gimple_code (def
) == GIMPLE_PHI
)
549 remove_phi_node (&gsi
, true);
552 gsi_remove (&gsi
, true);
556 bitmap_clear_bit (toremove
, j
);
561 /* Return true if SSA_NAME is malformed and mark it visited.
563 IS_VIRTUAL is true if this SSA_NAME was found inside a virtual
567 verify_ssa_name (tree ssa_name
, bool is_virtual
)
569 if (TREE_CODE (ssa_name
) != SSA_NAME
)
571 error ("expected an SSA_NAME object");
575 if (TREE_TYPE (ssa_name
) != TREE_TYPE (SSA_NAME_VAR (ssa_name
)))
577 error ("type mismatch between an SSA_NAME and its symbol");
581 if (SSA_NAME_IN_FREE_LIST (ssa_name
))
583 error ("found an SSA_NAME that had been released into the free pool");
587 if (is_virtual
&& is_gimple_reg (ssa_name
))
589 error ("found a virtual definition for a GIMPLE register");
593 if (is_virtual
&& SSA_NAME_VAR (ssa_name
) != gimple_vop (cfun
))
595 error ("virtual SSA name for non-VOP decl");
599 if (!is_virtual
&& !is_gimple_reg (ssa_name
))
601 error ("found a real definition for a non-register");
605 if (SSA_NAME_IS_DEFAULT_DEF (ssa_name
)
606 && !gimple_nop_p (SSA_NAME_DEF_STMT (ssa_name
)))
608 error ("found a default name with a non-empty defining statement");
616 /* Return true if the definition of SSA_NAME at block BB is malformed.
618 STMT is the statement where SSA_NAME is created.
620 DEFINITION_BLOCK is an array of basic blocks indexed by SSA_NAME
621 version numbers. If DEFINITION_BLOCK[SSA_NAME_VERSION] is set,
622 it means that the block in that array slot contains the
623 definition of SSA_NAME.
625 IS_VIRTUAL is true if SSA_NAME is created by a VDEF. */
628 verify_def (basic_block bb
, basic_block
*definition_block
, tree ssa_name
,
629 gimple stmt
, bool is_virtual
)
631 if (verify_ssa_name (ssa_name
, is_virtual
))
634 if (definition_block
[SSA_NAME_VERSION (ssa_name
)])
636 error ("SSA_NAME created in two different blocks %i and %i",
637 definition_block
[SSA_NAME_VERSION (ssa_name
)]->index
, bb
->index
);
641 definition_block
[SSA_NAME_VERSION (ssa_name
)] = bb
;
643 if (SSA_NAME_DEF_STMT (ssa_name
) != stmt
)
645 error ("SSA_NAME_DEF_STMT is wrong");
646 fprintf (stderr
, "Expected definition statement:\n");
647 print_gimple_stmt (stderr
, SSA_NAME_DEF_STMT (ssa_name
), 4, TDF_VOPS
);
648 fprintf (stderr
, "\nActual definition statement:\n");
649 print_gimple_stmt (stderr
, stmt
, 4, TDF_VOPS
);
656 fprintf (stderr
, "while verifying SSA_NAME ");
657 print_generic_expr (stderr
, ssa_name
, 0);
658 fprintf (stderr
, " in statement\n");
659 print_gimple_stmt (stderr
, stmt
, 4, TDF_VOPS
);
665 /* Return true if the use of SSA_NAME at statement STMT in block BB is
668 DEF_BB is the block where SSA_NAME was found to be created.
670 IDOM contains immediate dominator information for the flowgraph.
672 CHECK_ABNORMAL is true if the caller wants to check whether this use
673 is flowing through an abnormal edge (only used when checking PHI
676 If NAMES_DEFINED_IN_BB is not NULL, it contains a bitmap of ssa names
677 that are defined before STMT in basic block BB. */
680 verify_use (basic_block bb
, basic_block def_bb
, use_operand_p use_p
,
681 gimple stmt
, bool check_abnormal
, bitmap names_defined_in_bb
)
684 tree ssa_name
= USE_FROM_PTR (use_p
);
686 if (!TREE_VISITED (ssa_name
))
687 if (verify_imm_links (stderr
, ssa_name
))
690 TREE_VISITED (ssa_name
) = 1;
692 if (gimple_nop_p (SSA_NAME_DEF_STMT (ssa_name
))
693 && SSA_NAME_IS_DEFAULT_DEF (ssa_name
))
694 ; /* Default definitions have empty statements. Nothing to do. */
697 error ("missing definition");
700 else if (bb
!= def_bb
701 && !dominated_by_p (CDI_DOMINATORS
, bb
, def_bb
))
703 error ("definition in block %i does not dominate use in block %i",
704 def_bb
->index
, bb
->index
);
707 else if (bb
== def_bb
708 && names_defined_in_bb
!= NULL
709 && !bitmap_bit_p (names_defined_in_bb
, SSA_NAME_VERSION (ssa_name
)))
711 error ("definition in block %i follows the use", def_bb
->index
);
716 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ssa_name
))
718 error ("SSA_NAME_OCCURS_IN_ABNORMAL_PHI should be set");
722 /* Make sure the use is in an appropriate list by checking the previous
723 element to make sure it's the same. */
724 if (use_p
->prev
== NULL
)
726 error ("no immediate_use list");
732 if (use_p
->prev
->use
== NULL
)
733 listvar
= use_p
->prev
->loc
.ssa_name
;
735 listvar
= USE_FROM_PTR (use_p
->prev
);
736 if (listvar
!= ssa_name
)
738 error ("wrong immediate use list");
745 fprintf (stderr
, "for SSA_NAME: ");
746 print_generic_expr (stderr
, ssa_name
, TDF_VOPS
);
747 fprintf (stderr
, " in statement:\n");
748 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
);
755 /* Return true if any of the arguments for PHI node PHI at block BB is
758 DEFINITION_BLOCK is an array of basic blocks indexed by SSA_NAME
759 version numbers. If DEFINITION_BLOCK[SSA_NAME_VERSION] is set,
760 it means that the block in that array slot contains the
761 definition of SSA_NAME. */
764 verify_phi_args (gimple phi
, basic_block bb
, basic_block
*definition_block
)
768 size_t i
, phi_num_args
= gimple_phi_num_args (phi
);
770 if (EDGE_COUNT (bb
->preds
) != phi_num_args
)
772 error ("incoming edge count does not match number of PHI arguments");
777 for (i
= 0; i
< phi_num_args
; i
++)
779 use_operand_p op_p
= gimple_phi_arg_imm_use_ptr (phi
, i
);
780 tree op
= USE_FROM_PTR (op_p
);
782 e
= EDGE_PRED (bb
, i
);
786 error ("PHI argument is missing for edge %d->%d",
793 if (TREE_CODE (op
) != SSA_NAME
&& !is_gimple_min_invariant (op
))
795 error ("PHI argument is not SSA_NAME, or invariant");
799 if (TREE_CODE (op
) == SSA_NAME
)
801 err
= verify_ssa_name (op
, !is_gimple_reg (gimple_phi_result (phi
)));
802 err
|= verify_use (e
->src
, definition_block
[SSA_NAME_VERSION (op
)],
803 op_p
, phi
, e
->flags
& EDGE_ABNORMAL
, NULL
);
806 if (TREE_CODE (op
) == ADDR_EXPR
)
808 tree base
= TREE_OPERAND (op
, 0);
809 while (handled_component_p (base
))
810 base
= TREE_OPERAND (base
, 0);
811 if ((TREE_CODE (base
) == VAR_DECL
812 || TREE_CODE (base
) == PARM_DECL
813 || TREE_CODE (base
) == RESULT_DECL
)
814 && !TREE_ADDRESSABLE (base
))
816 error ("address taken, but ADDRESSABLE bit not set");
823 error ("wrong edge %d->%d for PHI argument",
824 e
->src
->index
, e
->dest
->index
);
830 fprintf (stderr
, "PHI argument\n");
831 print_generic_stmt (stderr
, op
, TDF_VOPS
);
839 fprintf (stderr
, "for PHI node\n");
840 print_gimple_stmt (stderr
, phi
, 0, TDF_VOPS
|TDF_MEMSYMS
);
848 /* Verify common invariants in the SSA web.
849 TODO: verify the variable annotations. */
852 verify_ssa (bool check_modified_stmt
)
856 basic_block
*definition_block
= XCNEWVEC (basic_block
, num_ssa_names
);
859 enum dom_state orig_dom_state
= dom_info_state (CDI_DOMINATORS
);
860 bitmap names_defined_in_bb
= BITMAP_ALLOC (NULL
);
862 gcc_assert (!need_ssa_update_p (cfun
));
866 timevar_push (TV_TREE_SSA_VERIFY
);
868 /* Keep track of SSA names present in the IL. */
869 for (i
= 1; i
< num_ssa_names
; i
++)
871 tree name
= ssa_name (i
);
875 TREE_VISITED (name
) = 0;
877 stmt
= SSA_NAME_DEF_STMT (name
);
878 if (!gimple_nop_p (stmt
))
880 basic_block bb
= gimple_bb (stmt
);
881 verify_def (bb
, definition_block
,
882 name
, stmt
, !is_gimple_reg (name
));
888 calculate_dominance_info (CDI_DOMINATORS
);
890 /* Now verify all the uses and make sure they agree with the definitions
891 found in the previous pass. */
897 gimple_stmt_iterator gsi
;
899 /* Make sure that all edges have a clear 'aux' field. */
900 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
904 error ("AUX pointer initialized for edge %d->%d", e
->src
->index
,
910 /* Verify the arguments for every PHI node in the block. */
911 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
913 phi
= gsi_stmt (gsi
);
914 if (verify_phi_args (phi
, bb
, definition_block
))
917 bitmap_set_bit (names_defined_in_bb
,
918 SSA_NAME_VERSION (gimple_phi_result (phi
)));
921 /* Now verify all the uses and vuses in every statement of the block. */
922 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
924 gimple stmt
= gsi_stmt (gsi
);
928 if (check_modified_stmt
&& gimple_modified_p (stmt
))
930 error ("stmt (%p) marked modified after optimization pass: ",
932 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
);
936 if (is_gimple_assign (stmt
)
937 && TREE_CODE (gimple_assign_lhs (stmt
)) != SSA_NAME
)
939 tree lhs
, base_address
;
941 lhs
= gimple_assign_lhs (stmt
);
942 base_address
= get_base_address (lhs
);
945 && SSA_VAR_P (base_address
)
946 && !gimple_vdef (stmt
)
949 error ("statement makes a memory store, but has no VDEFS");
950 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
);
954 else if (gimple_debug_bind_p (stmt
)
955 && !gimple_debug_bind_has_value_p (stmt
))
958 /* Verify the single virtual operand and its constraints. */
960 if (gimple_vdef (stmt
))
962 if (gimple_vdef_op (stmt
) == NULL_DEF_OPERAND_P
)
964 error ("statement has VDEF operand not in defs list");
967 if (!gimple_vuse (stmt
))
969 error ("statement has VDEF but no VUSE operand");
972 else if (SSA_NAME_VAR (gimple_vdef (stmt
))
973 != SSA_NAME_VAR (gimple_vuse (stmt
)))
975 error ("VDEF and VUSE do not use the same symbol");
978 has_err
|= verify_ssa_name (gimple_vdef (stmt
), true);
980 if (gimple_vuse (stmt
))
982 if (gimple_vuse_op (stmt
) == NULL_USE_OPERAND_P
)
984 error ("statement has VUSE operand not in uses list");
987 has_err
|= verify_ssa_name (gimple_vuse (stmt
), true);
991 error ("in statement");
992 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
|TDF_MEMSYMS
);
996 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, iter
, SSA_OP_USE
|SSA_OP_DEF
)
998 if (verify_ssa_name (op
, false))
1000 error ("in statement");
1001 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
|TDF_MEMSYMS
);
1006 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_USE
|SSA_OP_VUSE
)
1008 op
= USE_FROM_PTR (use_p
);
1009 if (verify_use (bb
, definition_block
[SSA_NAME_VERSION (op
)],
1010 use_p
, stmt
, false, names_defined_in_bb
))
1014 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, iter
, SSA_OP_ALL_DEFS
)
1016 if (SSA_NAME_DEF_STMT (op
) != stmt
)
1018 error ("SSA_NAME_DEF_STMT is wrong");
1019 fprintf (stderr
, "Expected definition statement:\n");
1020 print_gimple_stmt (stderr
, stmt
, 4, TDF_VOPS
);
1021 fprintf (stderr
, "\nActual definition statement:\n");
1022 print_gimple_stmt (stderr
, SSA_NAME_DEF_STMT (op
),
1026 bitmap_set_bit (names_defined_in_bb
, SSA_NAME_VERSION (op
));
1030 bitmap_clear (names_defined_in_bb
);
1033 free (definition_block
);
1035 /* Restore the dominance information to its prior known state, so
1036 that we do not perturb the compiler's subsequent behavior. */
1037 if (orig_dom_state
== DOM_NONE
)
1038 free_dominance_info (CDI_DOMINATORS
);
1040 set_dom_info_availability (CDI_DOMINATORS
, orig_dom_state
);
1042 BITMAP_FREE (names_defined_in_bb
);
1043 timevar_pop (TV_TREE_SSA_VERIFY
);
1047 internal_error ("verify_ssa failed");
1050 /* Return true if the uid in both int tree maps are equal. */
1053 int_tree_map_eq (const void *va
, const void *vb
)
1055 const struct int_tree_map
*a
= (const struct int_tree_map
*) va
;
1056 const struct int_tree_map
*b
= (const struct int_tree_map
*) vb
;
1057 return (a
->uid
== b
->uid
);
1060 /* Hash a UID in a int_tree_map. */
1063 int_tree_map_hash (const void *item
)
1065 return ((const struct int_tree_map
*)item
)->uid
;
1068 /* Return true if the DECL_UID in both trees are equal. */
1071 uid_decl_map_eq (const void *va
, const void *vb
)
1073 const_tree a
= (const_tree
) va
;
1074 const_tree b
= (const_tree
) vb
;
1075 return (a
->decl_minimal
.uid
== b
->decl_minimal
.uid
);
1078 /* Hash a tree in a uid_decl_map. */
1081 uid_decl_map_hash (const void *item
)
1083 return ((const_tree
)item
)->decl_minimal
.uid
;
1086 /* Return true if the DECL_UID in both trees are equal. */
1089 uid_ssaname_map_eq (const void *va
, const void *vb
)
1091 const_tree a
= (const_tree
) va
;
1092 const_tree b
= (const_tree
) vb
;
1093 return (a
->ssa_name
.var
->decl_minimal
.uid
== b
->ssa_name
.var
->decl_minimal
.uid
);
1096 /* Hash a tree in a uid_decl_map. */
1099 uid_ssaname_map_hash (const void *item
)
1101 return ((const_tree
)item
)->ssa_name
.var
->decl_minimal
.uid
;
1105 /* Initialize global DFA and SSA structures. */
1108 init_tree_ssa (struct function
*fn
)
1110 fn
->gimple_df
= GGC_CNEW (struct gimple_df
);
1111 fn
->gimple_df
->referenced_vars
= htab_create_ggc (20, uid_decl_map_hash
,
1112 uid_decl_map_eq
, NULL
);
1113 fn
->gimple_df
->default_defs
= htab_create_ggc (20, uid_ssaname_map_hash
,
1114 uid_ssaname_map_eq
, NULL
);
1115 pt_solution_reset (&fn
->gimple_df
->escaped
);
1116 pt_solution_reset (&fn
->gimple_df
->callused
);
1117 init_ssanames (fn
, 0);
1122 /* Deallocate memory associated with SSA data structures for FNDECL. */
1125 delete_tree_ssa (void)
1127 referenced_var_iterator rvi
;
1130 /* Remove annotations from every referenced local variable. */
1131 FOR_EACH_REFERENCED_VAR (var
, rvi
)
1133 if (is_global_var (var
))
1136 ggc_free (var
->base
.ann
);
1137 var
->base
.ann
= NULL
;
1139 htab_delete (gimple_referenced_vars (cfun
));
1140 cfun
->gimple_df
->referenced_vars
= NULL
;
1145 /* We no longer maintain the SSA operand cache at this point. */
1146 if (ssa_operands_active ())
1147 fini_ssa_operands ();
1149 delete_alias_heapvars ();
1151 htab_delete (cfun
->gimple_df
->default_defs
);
1152 cfun
->gimple_df
->default_defs
= NULL
;
1153 pt_solution_reset (&cfun
->gimple_df
->escaped
);
1154 pt_solution_reset (&cfun
->gimple_df
->callused
);
1155 if (cfun
->gimple_df
->decls_to_pointers
!= NULL
)
1156 pointer_map_destroy (cfun
->gimple_df
->decls_to_pointers
);
1157 cfun
->gimple_df
->decls_to_pointers
= NULL
;
1158 cfun
->gimple_df
->modified_noreturn_calls
= NULL
;
1159 cfun
->gimple_df
= NULL
;
1161 /* We no longer need the edge variable maps. */
1162 redirect_edge_var_map_destroy ();
1165 /* Return true if the conversion from INNER_TYPE to OUTER_TYPE is a
1166 useless type conversion, otherwise return false.
1168 This function implicitly defines the middle-end type system. With
1169 the notion of 'a < b' meaning that useless_type_conversion_p (a, b)
1170 holds and 'a > b' meaning that useless_type_conversion_p (b, a) holds,
1171 the following invariants shall be fulfilled:
1173 1) useless_type_conversion_p is transitive.
1174 If a < b and b < c then a < c.
1176 2) useless_type_conversion_p is not symmetric.
1177 From a < b does not follow a > b.
1179 3) Types define the available set of operations applicable to values.
1180 A type conversion is useless if the operations for the target type
1181 is a subset of the operations for the source type. For example
1182 casts to void* are useless, casts from void* are not (void* can't
1183 be dereferenced or offsetted, but copied, hence its set of operations
1184 is a strict subset of that of all other data pointer types). Casts
1185 to const T* are useless (can't be written to), casts from const T*
1189 useless_type_conversion_p (tree outer_type
, tree inner_type
)
1191 /* Do the following before stripping toplevel qualifiers. */
1192 if (POINTER_TYPE_P (inner_type
)
1193 && POINTER_TYPE_P (outer_type
))
1195 /* Do not lose casts between pointers to different address spaces. */
1196 if (TYPE_ADDR_SPACE (TREE_TYPE (outer_type
))
1197 != TYPE_ADDR_SPACE (TREE_TYPE (inner_type
)))
1200 /* If the outer type is (void *) or a pointer to an incomplete
1201 record type or a pointer to an unprototyped function,
1202 then the conversion is not necessary. */
1203 if (VOID_TYPE_P (TREE_TYPE (outer_type
))
1204 || ((TREE_CODE (TREE_TYPE (outer_type
)) == FUNCTION_TYPE
1205 || TREE_CODE (TREE_TYPE (outer_type
)) == METHOD_TYPE
)
1206 && (TREE_CODE (TREE_TYPE (outer_type
))
1207 == TREE_CODE (TREE_TYPE (inner_type
)))
1208 && !TYPE_ARG_TYPES (TREE_TYPE (outer_type
))
1209 && useless_type_conversion_p (TREE_TYPE (TREE_TYPE (outer_type
)),
1210 TREE_TYPE (TREE_TYPE (inner_type
)))))
1213 /* Do not lose casts to restrict qualified pointers. */
1214 if ((TYPE_RESTRICT (outer_type
)
1215 != TYPE_RESTRICT (inner_type
))
1216 && TYPE_RESTRICT (outer_type
))
1220 /* From now on qualifiers on value types do not matter. */
1221 inner_type
= TYPE_MAIN_VARIANT (inner_type
);
1222 outer_type
= TYPE_MAIN_VARIANT (outer_type
);
1224 if (inner_type
== outer_type
)
1227 /* If we know the canonical types, compare them. */
1228 if (TYPE_CANONICAL (inner_type
)
1229 && TYPE_CANONICAL (inner_type
) == TYPE_CANONICAL (outer_type
))
1232 /* Changes in machine mode are never useless conversions unless we
1233 deal with aggregate types in which case we defer to later checks. */
1234 if (TYPE_MODE (inner_type
) != TYPE_MODE (outer_type
)
1235 && !AGGREGATE_TYPE_P (inner_type
))
1238 /* If both the inner and outer types are integral types, then the
1239 conversion is not necessary if they have the same mode and
1240 signedness and precision, and both or neither are boolean. */
1241 if (INTEGRAL_TYPE_P (inner_type
)
1242 && INTEGRAL_TYPE_P (outer_type
))
1244 /* Preserve changes in signedness or precision. */
1245 if (TYPE_UNSIGNED (inner_type
) != TYPE_UNSIGNED (outer_type
)
1246 || TYPE_PRECISION (inner_type
) != TYPE_PRECISION (outer_type
))
1249 /* We don't need to preserve changes in the types minimum or
1250 maximum value in general as these do not generate code
1251 unless the types precisions are different. */
1255 /* Scalar floating point types with the same mode are compatible. */
1256 else if (SCALAR_FLOAT_TYPE_P (inner_type
)
1257 && SCALAR_FLOAT_TYPE_P (outer_type
))
1260 /* Fixed point types with the same mode are compatible. */
1261 else if (FIXED_POINT_TYPE_P (inner_type
)
1262 && FIXED_POINT_TYPE_P (outer_type
))
1265 /* We need to take special care recursing to pointed-to types. */
1266 else if (POINTER_TYPE_P (inner_type
)
1267 && POINTER_TYPE_P (outer_type
))
1269 /* Don't lose casts between pointers to volatile and non-volatile
1270 qualified types. Doing so would result in changing the semantics
1271 of later accesses. For function types the volatile qualifier
1272 is used to indicate noreturn functions. */
1273 if (TREE_CODE (TREE_TYPE (outer_type
)) != FUNCTION_TYPE
1274 && TREE_CODE (TREE_TYPE (outer_type
)) != METHOD_TYPE
1275 && TREE_CODE (TREE_TYPE (inner_type
)) != FUNCTION_TYPE
1276 && TREE_CODE (TREE_TYPE (inner_type
)) != METHOD_TYPE
1277 && (TYPE_VOLATILE (TREE_TYPE (outer_type
))
1278 != TYPE_VOLATILE (TREE_TYPE (inner_type
)))
1279 && TYPE_VOLATILE (TREE_TYPE (outer_type
)))
1282 /* We require explicit conversions from incomplete target types. */
1283 if (!COMPLETE_TYPE_P (TREE_TYPE (inner_type
))
1284 && COMPLETE_TYPE_P (TREE_TYPE (outer_type
)))
1287 /* Do not lose casts between pointers that when dereferenced access
1288 memory with different alias sets. */
1289 if (get_deref_alias_set (inner_type
) != get_deref_alias_set (outer_type
))
1292 /* We do not care for const qualification of the pointed-to types
1293 as const qualification has no semantic value to the middle-end. */
1295 /* Otherwise pointers/references are equivalent if their pointed
1296 to types are effectively the same. We can strip qualifiers
1297 on pointed-to types for further comparison, which is done in
1298 the callee. Note we have to use true compatibility here
1299 because addresses are subject to propagation into dereferences
1300 and thus might get the original type exposed which is equivalent
1301 to a reverse conversion. */
1302 return types_compatible_p (TREE_TYPE (outer_type
),
1303 TREE_TYPE (inner_type
));
1306 /* Recurse for complex types. */
1307 else if (TREE_CODE (inner_type
) == COMPLEX_TYPE
1308 && TREE_CODE (outer_type
) == COMPLEX_TYPE
)
1309 return useless_type_conversion_p (TREE_TYPE (outer_type
),
1310 TREE_TYPE (inner_type
));
1312 /* Recurse for vector types with the same number of subparts. */
1313 else if (TREE_CODE (inner_type
) == VECTOR_TYPE
1314 && TREE_CODE (outer_type
) == VECTOR_TYPE
1315 && TYPE_PRECISION (inner_type
) == TYPE_PRECISION (outer_type
))
1316 return useless_type_conversion_p (TREE_TYPE (outer_type
),
1317 TREE_TYPE (inner_type
));
1319 else if (TREE_CODE (inner_type
) == ARRAY_TYPE
1320 && TREE_CODE (outer_type
) == ARRAY_TYPE
)
1322 /* Preserve string attributes. */
1323 if (TYPE_STRING_FLAG (inner_type
) != TYPE_STRING_FLAG (outer_type
))
1326 /* Conversions from array types with unknown extent to
1327 array types with known extent are not useless. */
1328 if (!TYPE_DOMAIN (inner_type
)
1329 && TYPE_DOMAIN (outer_type
))
1332 /* Nor are conversions from array types with non-constant size to
1333 array types with constant size or to different size. */
1334 if (TYPE_SIZE (outer_type
)
1335 && TREE_CODE (TYPE_SIZE (outer_type
)) == INTEGER_CST
1336 && (!TYPE_SIZE (inner_type
)
1337 || TREE_CODE (TYPE_SIZE (inner_type
)) != INTEGER_CST
1338 || !tree_int_cst_equal (TYPE_SIZE (outer_type
),
1339 TYPE_SIZE (inner_type
))))
1342 /* Check conversions between arrays with partially known extents.
1343 If the array min/max values are constant they have to match.
1344 Otherwise allow conversions to unknown and variable extents.
1345 In particular this declares conversions that may change the
1346 mode to BLKmode as useless. */
1347 if (TYPE_DOMAIN (inner_type
)
1348 && TYPE_DOMAIN (outer_type
)
1349 && TYPE_DOMAIN (inner_type
) != TYPE_DOMAIN (outer_type
))
1351 tree inner_min
= TYPE_MIN_VALUE (TYPE_DOMAIN (inner_type
));
1352 tree outer_min
= TYPE_MIN_VALUE (TYPE_DOMAIN (outer_type
));
1353 tree inner_max
= TYPE_MAX_VALUE (TYPE_DOMAIN (inner_type
));
1354 tree outer_max
= TYPE_MAX_VALUE (TYPE_DOMAIN (outer_type
));
1356 /* After gimplification a variable min/max value carries no
1357 additional information compared to a NULL value. All that
1358 matters has been lowered to be part of the IL. */
1359 if (inner_min
&& TREE_CODE (inner_min
) != INTEGER_CST
)
1360 inner_min
= NULL_TREE
;
1361 if (outer_min
&& TREE_CODE (outer_min
) != INTEGER_CST
)
1362 outer_min
= NULL_TREE
;
1363 if (inner_max
&& TREE_CODE (inner_max
) != INTEGER_CST
)
1364 inner_max
= NULL_TREE
;
1365 if (outer_max
&& TREE_CODE (outer_max
) != INTEGER_CST
)
1366 outer_max
= NULL_TREE
;
1368 /* Conversions NULL / variable <- cst are useless, but not
1369 the other way around. */
1372 || !tree_int_cst_equal (inner_min
, outer_min
)))
1376 || !tree_int_cst_equal (inner_max
, outer_max
)))
1380 /* Recurse on the element check. */
1381 return useless_type_conversion_p (TREE_TYPE (outer_type
),
1382 TREE_TYPE (inner_type
));
1385 else if ((TREE_CODE (inner_type
) == FUNCTION_TYPE
1386 || TREE_CODE (inner_type
) == METHOD_TYPE
)
1387 && TREE_CODE (inner_type
) == TREE_CODE (outer_type
))
1389 tree outer_parm
, inner_parm
;
1391 /* If the return types are not compatible bail out. */
1392 if (!useless_type_conversion_p (TREE_TYPE (outer_type
),
1393 TREE_TYPE (inner_type
)))
1396 /* Method types should belong to a compatible base class. */
1397 if (TREE_CODE (inner_type
) == METHOD_TYPE
1398 && !useless_type_conversion_p (TYPE_METHOD_BASETYPE (outer_type
),
1399 TYPE_METHOD_BASETYPE (inner_type
)))
1402 /* A conversion to an unprototyped argument list is ok. */
1403 if (!TYPE_ARG_TYPES (outer_type
))
1406 /* If the unqualified argument types are compatible the conversion
1408 if (TYPE_ARG_TYPES (outer_type
) == TYPE_ARG_TYPES (inner_type
))
1411 for (outer_parm
= TYPE_ARG_TYPES (outer_type
),
1412 inner_parm
= TYPE_ARG_TYPES (inner_type
);
1413 outer_parm
&& inner_parm
;
1414 outer_parm
= TREE_CHAIN (outer_parm
),
1415 inner_parm
= TREE_CHAIN (inner_parm
))
1416 if (!useless_type_conversion_p
1417 (TYPE_MAIN_VARIANT (TREE_VALUE (outer_parm
)),
1418 TYPE_MAIN_VARIANT (TREE_VALUE (inner_parm
))))
1421 /* If there is a mismatch in the number of arguments the functions
1422 are not compatible. */
1423 if (outer_parm
|| inner_parm
)
1426 /* Defer to the target if necessary. */
1427 if (TYPE_ATTRIBUTES (inner_type
) || TYPE_ATTRIBUTES (outer_type
))
1428 return targetm
.comp_type_attributes (outer_type
, inner_type
) != 0;
1433 /* For aggregates we rely on TYPE_CANONICAL exclusively and require
1434 explicit conversions for types involving to be structurally
1436 else if (AGGREGATE_TYPE_P (inner_type
)
1437 && TREE_CODE (inner_type
) == TREE_CODE (outer_type
))
1443 /* Return true if a conversion from either type of TYPE1 and TYPE2
1444 to the other is not required. Otherwise return false. */
1447 types_compatible_p (tree type1
, tree type2
)
1449 return (type1
== type2
1450 || (useless_type_conversion_p (type1
, type2
)
1451 && useless_type_conversion_p (type2
, type1
)));
1454 /* Return true if EXPR is a useless type conversion, otherwise return
1458 tree_ssa_useless_type_conversion (tree expr
)
1460 /* If we have an assignment that merely uses a NOP_EXPR to change
1461 the top of the RHS to the type of the LHS and the type conversion
1462 is "safe", then strip away the type conversion so that we can
1463 enter LHS = RHS into the const_and_copies table. */
1464 if (CONVERT_EXPR_P (expr
)
1465 || TREE_CODE (expr
) == VIEW_CONVERT_EXPR
1466 || TREE_CODE (expr
) == NON_LVALUE_EXPR
)
1467 return useless_type_conversion_p
1469 TREE_TYPE (TREE_OPERAND (expr
, 0)));
1474 /* Strip conversions from EXP according to
1475 tree_ssa_useless_type_conversion and return the resulting
1479 tree_ssa_strip_useless_type_conversions (tree exp
)
1481 while (tree_ssa_useless_type_conversion (exp
))
1482 exp
= TREE_OPERAND (exp
, 0);
1487 /* Internal helper for walk_use_def_chains. VAR, FN and DATA are as
1488 described in walk_use_def_chains.
1490 VISITED is a pointer set used to mark visited SSA_NAMEs to avoid
1491 infinite loops. We used to have a bitmap for this to just mark
1492 SSA versions we had visited. But non-sparse bitmaps are way too
1493 expensive, while sparse bitmaps may cause quadratic behavior.
1495 IS_DFS is true if the caller wants to perform a depth-first search
1496 when visiting PHI nodes. A DFS will visit each PHI argument and
1497 call FN after each one. Otherwise, all the arguments are
1498 visited first and then FN is called with each of the visited
1499 arguments in a separate pass. */
1502 walk_use_def_chains_1 (tree var
, walk_use_def_chains_fn fn
, void *data
,
1503 struct pointer_set_t
*visited
, bool is_dfs
)
1507 if (pointer_set_insert (visited
, var
))
1510 def_stmt
= SSA_NAME_DEF_STMT (var
);
1512 if (gimple_code (def_stmt
) != GIMPLE_PHI
)
1514 /* If we reached the end of the use-def chain, call FN. */
1515 return fn (var
, def_stmt
, data
);
1521 /* When doing a breadth-first search, call FN before following the
1522 use-def links for each argument. */
1524 for (i
= 0; i
< gimple_phi_num_args (def_stmt
); i
++)
1525 if (fn (gimple_phi_arg_def (def_stmt
, i
), def_stmt
, data
))
1528 /* Follow use-def links out of each PHI argument. */
1529 for (i
= 0; i
< gimple_phi_num_args (def_stmt
); i
++)
1531 tree arg
= gimple_phi_arg_def (def_stmt
, i
);
1533 /* ARG may be NULL for newly introduced PHI nodes. */
1535 && TREE_CODE (arg
) == SSA_NAME
1536 && walk_use_def_chains_1 (arg
, fn
, data
, visited
, is_dfs
))
1540 /* When doing a depth-first search, call FN after following the
1541 use-def links for each argument. */
1543 for (i
= 0; i
< gimple_phi_num_args (def_stmt
); i
++)
1544 if (fn (gimple_phi_arg_def (def_stmt
, i
), def_stmt
, data
))
1553 /* Walk use-def chains starting at the SSA variable VAR. Call
1554 function FN at each reaching definition found. FN takes three
1555 arguments: VAR, its defining statement (DEF_STMT) and a generic
1556 pointer to whatever state information that FN may want to maintain
1557 (DATA). FN is able to stop the walk by returning true, otherwise
1558 in order to continue the walk, FN should return false.
1560 Note, that if DEF_STMT is a PHI node, the semantics are slightly
1561 different. The first argument to FN is no longer the original
1562 variable VAR, but the PHI argument currently being examined. If FN
1563 wants to get at VAR, it should call PHI_RESULT (PHI).
1565 If IS_DFS is true, this function will:
1567 1- walk the use-def chains for all the PHI arguments, and,
1568 2- call (*FN) (ARG, PHI, DATA) on all the PHI arguments.
1570 If IS_DFS is false, the two steps above are done in reverse order
1571 (i.e., a breadth-first search). */
1574 walk_use_def_chains (tree var
, walk_use_def_chains_fn fn
, void *data
,
1579 gcc_assert (TREE_CODE (var
) == SSA_NAME
);
1581 def_stmt
= SSA_NAME_DEF_STMT (var
);
1583 /* We only need to recurse if the reaching definition comes from a PHI
1585 if (gimple_code (def_stmt
) != GIMPLE_PHI
)
1586 (*fn
) (var
, def_stmt
, data
);
1589 struct pointer_set_t
*visited
= pointer_set_create ();
1590 walk_use_def_chains_1 (var
, fn
, data
, visited
, is_dfs
);
1591 pointer_set_destroy (visited
);
1596 /* Return true if T, an SSA_NAME, has an undefined value. */
1599 ssa_undefined_value_p (tree t
)
1601 tree var
= SSA_NAME_VAR (t
);
1603 /* Parameters get their initial value from the function entry. */
1604 if (TREE_CODE (var
) == PARM_DECL
)
1607 /* Hard register variables get their initial value from the ether. */
1608 if (TREE_CODE (var
) == VAR_DECL
&& DECL_HARD_REGISTER (var
))
1611 /* The value is undefined iff its definition statement is empty. */
1612 return gimple_nop_p (SSA_NAME_DEF_STMT (t
));
1615 /* Emit warnings for uninitialized variables. This is done in two passes.
1617 The first pass notices real uses of SSA names with undefined values.
1618 Such uses are unconditionally uninitialized, and we can be certain that
1619 such a use is a mistake. This pass is run before most optimizations,
1620 so that we catch as many as we can.
1622 The second pass follows PHI nodes to find uses that are potentially
1623 uninitialized. In this case we can't necessarily prove that the use
1624 is really uninitialized. This pass is run after most optimizations,
1625 so that we thread as many jumps and possible, and delete as much dead
1626 code as possible, in order to reduce false positives. We also look
1627 again for plain uninitialized variables, since optimization may have
1628 changed conditionally uninitialized to unconditionally uninitialized. */
1630 /* Emit a warning for T, an SSA_NAME, being uninitialized. The exact
1631 warning text is in MSGID and LOCUS may contain a location or be null. */
1634 warn_uninit (tree t
, const char *gmsgid
, void *data
)
1636 tree var
= SSA_NAME_VAR (t
);
1637 gimple context
= (gimple
) data
;
1638 location_t location
;
1639 expanded_location xloc
, floc
;
1641 if (!ssa_undefined_value_p (t
))
1644 /* TREE_NO_WARNING either means we already warned, or the front end
1645 wishes to suppress the warning. */
1646 if (TREE_NO_WARNING (var
))
1649 /* Do not warn if it can be initialized outside this module. */
1650 if (is_global_var (var
))
1653 location
= (context
!= NULL
&& gimple_has_location (context
))
1654 ? gimple_location (context
)
1655 : DECL_SOURCE_LOCATION (var
);
1656 xloc
= expand_location (location
);
1657 floc
= expand_location (DECL_SOURCE_LOCATION (cfun
->decl
));
1658 if (warning_at (location
, OPT_Wuninitialized
, gmsgid
, var
))
1660 TREE_NO_WARNING (var
) = 1;
1662 if (xloc
.file
!= floc
.file
1663 || xloc
.line
< floc
.line
1664 || xloc
.line
> LOCATION_LINE (cfun
->function_end_locus
))
1665 inform (DECL_SOURCE_LOCATION (var
), "%qD was declared here", var
);
1671 bool always_executed
;
1672 bool warn_possibly_uninitialized
;
1675 /* Called via walk_tree, look for SSA_NAMEs that have empty definitions
1676 and warn about them. */
1679 warn_uninitialized_var (tree
*tp
, int *walk_subtrees
, void *data_
)
1681 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data_
;
1682 struct walk_data
*data
= (struct walk_data
*) wi
->info
;
1685 /* We do not care about LHS. */
1688 /* Except for operands of INDIRECT_REF. */
1689 if (!INDIRECT_REF_P (t
))
1691 t
= TREE_OPERAND (t
, 0);
1694 switch (TREE_CODE (t
))
1697 /* Taking the address of an uninitialized variable does not
1698 count as using it. */
1704 /* A VAR_DECL in the RHS of a gimple statement may mean that
1705 this variable is loaded from memory. */
1709 /* If there is not gimple stmt,
1710 or alias information has not been computed,
1711 then we cannot check VUSE ops. */
1712 if (data
->stmt
== NULL
)
1715 /* If the load happens as part of a call do not warn about it. */
1716 if (is_gimple_call (data
->stmt
))
1719 vuse
= gimple_vuse_op (data
->stmt
);
1720 if (vuse
== NULL_USE_OPERAND_P
)
1723 op
= USE_FROM_PTR (vuse
);
1724 if (t
!= SSA_NAME_VAR (op
)
1725 || !SSA_NAME_IS_DEFAULT_DEF (op
))
1727 /* If this is a VUSE of t and it is the default definition,
1728 then warn about op. */
1730 /* Fall through into SSA_NAME. */
1734 /* We only do data flow with SSA_NAMEs, so that's all we
1736 if (data
->always_executed
)
1737 warn_uninit (t
, "%qD is used uninitialized in this function",
1739 else if (data
->warn_possibly_uninitialized
)
1740 warn_uninit (t
, "%qD may be used uninitialized in this function",
1747 /* The total store transformation performed during gimplification
1748 creates uninitialized variable uses. If all is well, these will
1749 be optimized away, so don't warn now. */
1750 if (TREE_CODE (TREE_OPERAND (t
, 0)) == SSA_NAME
)
1755 if (IS_TYPE_OR_DECL_P (t
))
1763 /* Look for inputs to PHI that are SSA_NAMEs that have empty definitions
1764 and warn about them. */
1767 warn_uninitialized_phi (gimple phi
)
1769 size_t i
, n
= gimple_phi_num_args (phi
);
1771 /* Don't look at memory tags. */
1772 if (!is_gimple_reg (gimple_phi_result (phi
)))
1775 for (i
= 0; i
< n
; ++i
)
1777 tree op
= gimple_phi_arg_def (phi
, i
);
1778 if (TREE_CODE (op
) == SSA_NAME
)
1779 warn_uninit (op
, "%qD may be used uninitialized in this function",
1785 warn_uninitialized_vars (bool warn_possibly_uninitialized
)
1787 gimple_stmt_iterator gsi
;
1789 struct walk_data data
;
1791 data
.warn_possibly_uninitialized
= warn_possibly_uninitialized
;
1793 calculate_dominance_info (CDI_POST_DOMINATORS
);
1797 data
.always_executed
= dominated_by_p (CDI_POST_DOMINATORS
,
1798 single_succ (ENTRY_BLOCK_PTR
), bb
);
1799 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1801 struct walk_stmt_info wi
;
1802 data
.stmt
= gsi_stmt (gsi
);
1803 if (is_gimple_debug (data
.stmt
))
1805 memset (&wi
, 0, sizeof (wi
));
1807 walk_gimple_op (gsi_stmt (gsi
), warn_uninitialized_var
, &wi
);
1811 /* Post-dominator information can not be reliably updated. Free it
1814 free_dominance_info (CDI_POST_DOMINATORS
);
1819 execute_early_warn_uninitialized (void)
1821 /* Currently, this pass runs always but
1822 execute_late_warn_uninitialized only runs with optimization. With
1823 optimization we want to warn about possible uninitialized as late
1824 as possible, thus don't do it here. However, without
1825 optimization we need to warn here about "may be uninitialized".
1827 warn_uninitialized_vars (/*warn_possibly_uninitialized=*/!optimize
);
1832 execute_late_warn_uninitialized (void)
1835 gimple_stmt_iterator gsi
;
1837 /* Re-do the plain uninitialized variable check, as optimization may have
1838 straightened control flow. Do this first so that we don't accidentally
1839 get a "may be" warning when we'd have seen an "is" warning later. */
1840 warn_uninitialized_vars (/*warn_possibly_uninitialized=*/1);
1843 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1844 warn_uninitialized_phi (gsi_stmt (gsi
));
1850 gate_warn_uninitialized (void)
1852 return warn_uninitialized
!= 0;
1855 struct gimple_opt_pass pass_early_warn_uninitialized
=
1859 "*early_warn_uninitialized", /* name */
1860 gate_warn_uninitialized
, /* gate */
1861 execute_early_warn_uninitialized
, /* execute */
1864 0, /* static_pass_number */
1865 TV_NONE
, /* tv_id */
1866 PROP_ssa
, /* properties_required */
1867 0, /* properties_provided */
1868 0, /* properties_destroyed */
1869 0, /* todo_flags_start */
1870 0 /* todo_flags_finish */
1874 struct gimple_opt_pass pass_late_warn_uninitialized
=
1878 "*late_warn_uninitialized", /* name */
1879 gate_warn_uninitialized
, /* gate */
1880 execute_late_warn_uninitialized
, /* execute */
1883 0, /* static_pass_number */
1884 TV_NONE
, /* tv_id */
1885 PROP_ssa
, /* properties_required */
1886 0, /* properties_provided */
1887 0, /* properties_destroyed */
1888 0, /* todo_flags_start */
1889 0 /* todo_flags_finish */
1893 /* Compute TREE_ADDRESSABLE and DECL_GIMPLE_REG_P for local variables. */
1896 execute_update_addresses_taken (bool do_optimize
)
1899 referenced_var_iterator rvi
;
1900 gimple_stmt_iterator gsi
;
1902 bitmap addresses_taken
= BITMAP_ALLOC (NULL
);
1903 bitmap not_reg_needs
= BITMAP_ALLOC (NULL
);
1904 bool update_vops
= false;
1906 /* Collect into ADDRESSES_TAKEN all variables whose address is taken within
1907 the function body. */
1910 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1912 gimple stmt
= gsi_stmt (gsi
);
1913 enum gimple_code code
= gimple_code (stmt
);
1915 /* Note all addresses taken by the stmt. */
1916 gimple_ior_addresses_taken (addresses_taken
, stmt
);
1918 /* If we have a call or an assignment, see if the lhs contains
1919 a local decl that requires not to be a gimple register. */
1920 if (code
== GIMPLE_ASSIGN
|| code
== GIMPLE_CALL
)
1922 tree lhs
= gimple_get_lhs (stmt
);
1924 /* We may not rewrite TMR_SYMBOL to SSA. */
1925 if (lhs
&& TREE_CODE (lhs
) == TARGET_MEM_REF
1926 && TMR_SYMBOL (lhs
))
1927 bitmap_set_bit (not_reg_needs
, DECL_UID (TMR_SYMBOL (lhs
)));
1929 /* A plain decl does not need it set. */
1930 else if (lhs
&& handled_component_p (lhs
))
1932 var
= get_base_address (lhs
);
1934 bitmap_set_bit (not_reg_needs
, DECL_UID (var
));
1939 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1942 gimple phi
= gsi_stmt (gsi
);
1944 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
1946 tree op
= PHI_ARG_DEF (phi
, i
), var
;
1947 if (TREE_CODE (op
) == ADDR_EXPR
1948 && (var
= get_base_address (TREE_OPERAND (op
, 0))) != NULL
1950 bitmap_set_bit (addresses_taken
, DECL_UID (var
));
1955 /* When possible, clear ADDRESSABLE bit or set the REGISTER bit
1956 and mark variable for conversion into SSA. */
1957 if (optimize
&& do_optimize
)
1958 FOR_EACH_REFERENCED_VAR (var
, rvi
)
1960 /* Global Variables, result decls cannot be changed. */
1961 if (is_global_var (var
)
1962 || TREE_CODE (var
) == RESULT_DECL
1963 || bitmap_bit_p (addresses_taken
, DECL_UID (var
)))
1966 if (TREE_ADDRESSABLE (var
)
1967 /* Do not change TREE_ADDRESSABLE if we need to preserve var as
1968 a non-register. Otherwise we are confused and forget to
1969 add virtual operands for it. */
1970 && (!is_gimple_reg_type (TREE_TYPE (var
))
1971 || !bitmap_bit_p (not_reg_needs
, DECL_UID (var
))))
1973 TREE_ADDRESSABLE (var
) = 0;
1974 if (is_gimple_reg (var
))
1975 mark_sym_for_renaming (var
);
1979 fprintf (dump_file
, "No longer having address taken ");
1980 print_generic_expr (dump_file
, var
, 0);
1981 fprintf (dump_file
, "\n");
1984 if (!DECL_GIMPLE_REG_P (var
)
1985 && !bitmap_bit_p (not_reg_needs
, DECL_UID (var
))
1986 && (TREE_CODE (TREE_TYPE (var
)) == COMPLEX_TYPE
1987 || TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
)
1988 && !TREE_THIS_VOLATILE (var
)
1989 && (TREE_CODE (var
) != VAR_DECL
|| !DECL_HARD_REGISTER (var
)))
1991 DECL_GIMPLE_REG_P (var
) = 1;
1992 mark_sym_for_renaming (var
);
1996 fprintf (dump_file
, "Decl is now a gimple register ");
1997 print_generic_expr (dump_file
, var
, 0);
1998 fprintf (dump_file
, "\n");
2003 /* Operand caches needs to be recomputed for operands referencing the updated
2008 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
2010 gimple stmt
= gsi_stmt (gsi
);
2012 if (gimple_references_memory_p (stmt
)
2013 || is_gimple_debug (stmt
))
2017 /* Update SSA form here, we are called as non-pass as well. */
2018 update_ssa (TODO_update_ssa
);
2021 BITMAP_FREE (not_reg_needs
);
2022 BITMAP_FREE (addresses_taken
);
2025 struct gimple_opt_pass pass_update_address_taken
=
2029 "addressables", /* name */
2034 0, /* static_pass_number */
2035 TV_NONE
, /* tv_id */
2036 PROP_ssa
, /* properties_required */
2037 0, /* properties_provided */
2038 0, /* properties_destroyed */
2039 0, /* todo_flags_start */
2040 TODO_update_address_taken
2041 | TODO_dump_func
/* todo_flags_finish */