1 /* Miscellaneous SSA utility functions.
2 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
3 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
30 #include "langhooks.h"
31 #include "basic-block.h"
34 #include "tree-pretty-print.h"
35 #include "gimple-pretty-print.h"
37 #include "pointer-set.h"
38 #include "tree-flow.h"
40 #include "tree-inline.h"
43 #include "tree-dump.h"
44 #include "tree-pass.h"
45 #include "diagnostic-core.h"
47 /* Pointer map of variable mappings, keyed by edge. */
48 static struct pointer_map_t
*edge_var_maps
;
51 /* Add a mapping with PHI RESULT and PHI DEF associated with edge E. */
54 redirect_edge_var_map_add (edge e
, tree result
, tree def
, source_location locus
)
57 edge_var_map_vector old_head
, head
;
58 edge_var_map new_node
;
60 if (edge_var_maps
== NULL
)
61 edge_var_maps
= pointer_map_create ();
63 slot
= pointer_map_insert (edge_var_maps
, e
);
64 old_head
= head
= (edge_var_map_vector
) *slot
;
67 head
= VEC_alloc (edge_var_map
, heap
, 5);
71 new_node
.result
= result
;
72 new_node
.locus
= locus
;
74 VEC_safe_push (edge_var_map
, heap
, head
, &new_node
);
77 /* The push did some reallocation. Update the pointer map. */
83 /* Clear the var mappings in edge E. */
86 redirect_edge_var_map_clear (edge e
)
89 edge_var_map_vector head
;
94 slot
= pointer_map_contains (edge_var_maps
, e
);
98 head
= (edge_var_map_vector
) *slot
;
99 VEC_free (edge_var_map
, heap
, head
);
105 /* Duplicate the redirected var mappings in OLDE in NEWE.
107 Since we can't remove a mapping, let's just duplicate it. This assumes a
108 pointer_map can have multiple edges mapping to the same var_map (many to
109 one mapping), since we don't remove the previous mappings. */
112 redirect_edge_var_map_dup (edge newe
, edge olde
)
114 void **new_slot
, **old_slot
;
115 edge_var_map_vector head
;
120 new_slot
= pointer_map_insert (edge_var_maps
, newe
);
121 old_slot
= pointer_map_contains (edge_var_maps
, olde
);
124 head
= (edge_var_map_vector
) *old_slot
;
127 *new_slot
= VEC_copy (edge_var_map
, heap
, head
);
129 *new_slot
= VEC_alloc (edge_var_map
, heap
, 5);
133 /* Return the variable mappings for a given edge. If there is none, return
137 redirect_edge_var_map_vector (edge e
)
141 /* Hey, what kind of idiot would... you'd be surprised. */
145 slot
= pointer_map_contains (edge_var_maps
, e
);
149 return (edge_var_map_vector
) *slot
;
152 /* Used by redirect_edge_var_map_destroy to free all memory. */
155 free_var_map_entry (const void *key ATTRIBUTE_UNUSED
,
157 void *data ATTRIBUTE_UNUSED
)
159 edge_var_map_vector head
= (edge_var_map_vector
) *value
;
160 VEC_free (edge_var_map
, heap
, head
);
164 /* Clear the edge variable mappings. */
167 redirect_edge_var_map_destroy (void)
171 pointer_map_traverse (edge_var_maps
, free_var_map_entry
, NULL
);
172 pointer_map_destroy (edge_var_maps
);
173 edge_var_maps
= NULL
;
178 /* Remove the corresponding arguments from the PHI nodes in E's
179 destination block and redirect it to DEST. Return redirected edge.
180 The list of removed arguments is stored in a vector accessed
181 through edge_var_maps. */
184 ssa_redirect_edge (edge e
, basic_block dest
)
186 gimple_stmt_iterator gsi
;
189 redirect_edge_var_map_clear (e
);
191 /* Remove the appropriate PHI arguments in E's destination block. */
192 for (gsi
= gsi_start_phis (e
->dest
); !gsi_end_p (gsi
); gsi_next (&gsi
))
195 source_location locus
;
197 phi
= gsi_stmt (gsi
);
198 def
= gimple_phi_arg_def (phi
, e
->dest_idx
);
199 locus
= gimple_phi_arg_location (phi
, e
->dest_idx
);
201 if (def
== NULL_TREE
)
204 redirect_edge_var_map_add (e
, gimple_phi_result (phi
), def
, locus
);
207 e
= redirect_edge_succ_nodup (e
, dest
);
213 /* Add PHI arguments queued in PENDING_STMT list on edge E to edge
217 flush_pending_stmts (edge e
)
220 edge_var_map_vector v
;
223 gimple_stmt_iterator gsi
;
225 v
= redirect_edge_var_map_vector (e
);
229 for (gsi
= gsi_start_phis (e
->dest
), i
= 0;
230 !gsi_end_p (gsi
) && VEC_iterate (edge_var_map
, v
, i
, vm
);
231 gsi_next (&gsi
), i
++)
235 phi
= gsi_stmt (gsi
);
236 def
= redirect_edge_var_map_def (vm
);
237 add_phi_arg (phi
, def
, e
, redirect_edge_var_map_location (vm
));
240 redirect_edge_var_map_clear (e
);
243 /* Given a tree for an expression for which we might want to emit
244 locations or values in debug information (generally a variable, but
245 we might deal with other kinds of trees in the future), return the
246 tree that should be used as the variable of a DEBUG_BIND STMT or
247 VAR_LOCATION INSN or NOTE. Return NULL if VAR is not to be tracked. */
250 target_for_debug_bind (tree var
)
252 if (!MAY_HAVE_DEBUG_STMTS
)
255 if (TREE_CODE (var
) != VAR_DECL
256 && TREE_CODE (var
) != PARM_DECL
)
259 if (DECL_HAS_VALUE_EXPR_P (var
))
260 return target_for_debug_bind (DECL_VALUE_EXPR (var
));
262 if (DECL_IGNORED_P (var
))
265 if (!is_gimple_reg (var
))
271 /* Called via walk_tree, look for SSA_NAMEs that have already been
275 find_released_ssa_name (tree
*tp
, int *walk_subtrees
, void *data_
)
277 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data_
;
279 if (wi
&& wi
->is_lhs
)
282 if (TREE_CODE (*tp
) == SSA_NAME
)
284 if (SSA_NAME_IN_FREE_LIST (*tp
))
289 else if (IS_TYPE_OR_DECL_P (*tp
))
295 /* Insert a DEBUG BIND stmt before the DEF of VAR if VAR is referenced
296 by other DEBUG stmts, and replace uses of the DEF with the
297 newly-created debug temp. */
300 insert_debug_temp_for_var_def (gimple_stmt_iterator
*gsi
, tree var
)
302 imm_use_iterator imm_iter
;
305 gimple def_stmt
= NULL
;
309 if (!MAY_HAVE_DEBUG_STMTS
)
312 /* If this name has already been registered for replacement, do nothing
313 as anything that uses this name isn't in SSA form. */
314 if (name_registered_for_update_p (var
))
317 /* Check whether there are debug stmts that reference this variable and,
318 if there are, decide whether we should use a debug temp. */
319 FOR_EACH_IMM_USE_FAST (use_p
, imm_iter
, var
)
321 stmt
= USE_STMT (use_p
);
323 if (!gimple_debug_bind_p (stmt
))
329 if (gimple_debug_bind_get_value (stmt
) != var
)
331 /* Count this as an additional use, so as to make sure we
332 use a temp unless VAR's definition has a SINGLE_RHS that
343 def_stmt
= gsi_stmt (*gsi
);
345 def_stmt
= SSA_NAME_DEF_STMT (var
);
347 /* If we didn't get an insertion point, and the stmt has already
348 been removed, we won't be able to insert the debug bind stmt, so
349 we'll have to drop debug information. */
350 if (gimple_code (def_stmt
) == GIMPLE_PHI
)
352 value
= degenerate_phi_result (def_stmt
);
353 if (value
&& walk_tree (&value
, find_released_ssa_name
, NULL
, NULL
))
356 else if (is_gimple_assign (def_stmt
))
358 bool no_value
= false;
360 if (!dom_info_available_p (CDI_DOMINATORS
))
362 struct walk_stmt_info wi
;
364 memset (&wi
, 0, sizeof (wi
));
366 /* When removing blocks without following reverse dominance
367 order, we may sometimes encounter SSA_NAMEs that have
368 already been released, referenced in other SSA_DEFs that
369 we're about to release. Consider:
378 If we deleted BB X first, propagating the value of w_2
379 won't do us any good. It's too late to recover their
380 original definition of v_1: when it was deleted, it was
381 only referenced in other DEFs, it couldn't possibly know
382 it should have been retained, and propagating every
383 single DEF just in case it might have to be propagated
384 into a DEBUG STMT would probably be too wasteful.
386 When dominator information is not readily available, we
387 check for and accept some loss of debug information. But
388 if it is available, there's no excuse for us to remove
389 blocks in the wrong order, so we don't even check for
390 dead SSA NAMEs. SSA verification shall catch any
392 if ((!gsi
&& !gimple_bb (def_stmt
))
393 || walk_gimple_op (def_stmt
, find_released_ssa_name
, &wi
))
398 value
= gimple_assign_rhs_to_tree (def_stmt
);
403 /* If there's a single use of VAR, and VAR is the entire debug
404 expression (usecount would have been incremented again
405 otherwise), and the definition involves only constants and
406 SSA names, then we can propagate VALUE into this single use,
409 We can also avoid using a temp if VALUE can be shared and
410 propagated into all uses, without generating expressions that
411 wouldn't be valid gimple RHSs.
413 Other cases that would require unsharing or non-gimple RHSs
414 are deferred to a debug temp, although we could avoid temps
415 at the expense of duplication of expressions. */
417 if (CONSTANT_CLASS_P (value
)
418 || gimple_code (def_stmt
) == GIMPLE_PHI
420 && (!gimple_assign_single_p (def_stmt
)
421 || is_gimple_min_invariant (value
)))
422 || is_gimple_reg (value
))
423 value
= unshare_expr (value
);
427 tree vexpr
= make_node (DEBUG_EXPR_DECL
);
429 def_temp
= gimple_build_debug_bind (vexpr
,
430 unshare_expr (value
),
433 DECL_ARTIFICIAL (vexpr
) = 1;
434 TREE_TYPE (vexpr
) = TREE_TYPE (value
);
436 DECL_MODE (vexpr
) = DECL_MODE (value
);
438 DECL_MODE (vexpr
) = TYPE_MODE (TREE_TYPE (value
));
441 gsi_insert_before (gsi
, def_temp
, GSI_SAME_STMT
);
444 gimple_stmt_iterator ngsi
= gsi_for_stmt (def_stmt
);
445 gsi_insert_before (&ngsi
, def_temp
, GSI_SAME_STMT
);
452 FOR_EACH_IMM_USE_STMT (stmt
, imm_iter
, var
)
454 if (!gimple_debug_bind_p (stmt
))
458 FOR_EACH_IMM_USE_ON_STMT (use_p
, imm_iter
)
459 /* unshare_expr is not needed here. vexpr is either a
460 SINGLE_RHS, that can be safely shared, some other RHS
461 that was unshared when we found it had a single debug
462 use, or a DEBUG_EXPR_DECL, that can be safely
464 SET_USE (use_p
, value
);
466 gimple_debug_bind_reset_value (stmt
);
473 /* Insert a DEBUG BIND stmt before STMT for each DEF referenced by
474 other DEBUG stmts, and replace uses of the DEF with the
475 newly-created debug temp. */
478 insert_debug_temps_for_defs (gimple_stmt_iterator
*gsi
)
484 if (!MAY_HAVE_DEBUG_STMTS
)
487 stmt
= gsi_stmt (*gsi
);
489 FOR_EACH_PHI_OR_STMT_DEF (def_p
, stmt
, op_iter
, SSA_OP_DEF
)
491 tree var
= DEF_FROM_PTR (def_p
);
493 if (TREE_CODE (var
) != SSA_NAME
)
496 insert_debug_temp_for_var_def (gsi
, var
);
500 /* Delete SSA DEFs for SSA versions in the TOREMOVE bitmap, removing
501 dominated stmts before their dominators, so that release_ssa_defs
502 stands a chance of propagating DEFs into debug bind stmts. */
505 release_defs_bitset (bitmap toremove
)
510 /* Performing a topological sort is probably overkill, this will
511 most likely run in slightly superlinear time, rather than the
512 pathological quadratic worst case. */
513 while (!bitmap_empty_p (toremove
))
514 EXECUTE_IF_SET_IN_BITMAP (toremove
, 0, j
, bi
)
516 bool remove_now
= true;
517 tree var
= ssa_name (j
);
519 imm_use_iterator uit
;
521 FOR_EACH_IMM_USE_STMT (stmt
, uit
, var
)
526 /* We can't propagate PHI nodes into debug stmts. */
527 if (gimple_code (stmt
) == GIMPLE_PHI
528 || is_gimple_debug (stmt
))
531 /* If we find another definition to remove that uses
532 the one we're looking at, defer the removal of this
533 one, so that it can be propagated into debug stmts
534 after the other is. */
535 FOR_EACH_SSA_DEF_OPERAND (def_p
, stmt
, dit
, SSA_OP_DEF
)
537 tree odef
= DEF_FROM_PTR (def_p
);
539 if (bitmap_bit_p (toremove
, SSA_NAME_VERSION (odef
)))
547 BREAK_FROM_IMM_USE_STMT (uit
);
552 gimple def
= SSA_NAME_DEF_STMT (var
);
553 gimple_stmt_iterator gsi
= gsi_for_stmt (def
);
555 if (gimple_code (def
) == GIMPLE_PHI
)
556 remove_phi_node (&gsi
, true);
559 gsi_remove (&gsi
, true);
563 bitmap_clear_bit (toremove
, j
);
568 /* Return true if SSA_NAME is malformed and mark it visited.
570 IS_VIRTUAL is true if this SSA_NAME was found inside a virtual
574 verify_ssa_name (tree ssa_name
, bool is_virtual
)
576 if (TREE_CODE (ssa_name
) != SSA_NAME
)
578 error ("expected an SSA_NAME object");
582 if (TREE_TYPE (ssa_name
) != TREE_TYPE (SSA_NAME_VAR (ssa_name
)))
584 error ("type mismatch between an SSA_NAME and its symbol");
588 if (SSA_NAME_IN_FREE_LIST (ssa_name
))
590 error ("found an SSA_NAME that had been released into the free pool");
594 if (is_virtual
&& is_gimple_reg (ssa_name
))
596 error ("found a virtual definition for a GIMPLE register");
600 if (is_virtual
&& SSA_NAME_VAR (ssa_name
) != gimple_vop (cfun
))
602 error ("virtual SSA name for non-VOP decl");
606 if (!is_virtual
&& !is_gimple_reg (ssa_name
))
608 error ("found a real definition for a non-register");
612 if (SSA_NAME_IS_DEFAULT_DEF (ssa_name
)
613 && !gimple_nop_p (SSA_NAME_DEF_STMT (ssa_name
)))
615 error ("found a default name with a non-empty defining statement");
623 /* Return true if the definition of SSA_NAME at block BB is malformed.
625 STMT is the statement where SSA_NAME is created.
627 DEFINITION_BLOCK is an array of basic blocks indexed by SSA_NAME
628 version numbers. If DEFINITION_BLOCK[SSA_NAME_VERSION] is set,
629 it means that the block in that array slot contains the
630 definition of SSA_NAME.
632 IS_VIRTUAL is true if SSA_NAME is created by a VDEF. */
635 verify_def (basic_block bb
, basic_block
*definition_block
, tree ssa_name
,
636 gimple stmt
, bool is_virtual
)
638 if (verify_ssa_name (ssa_name
, is_virtual
))
641 if (TREE_CODE (SSA_NAME_VAR (ssa_name
)) == RESULT_DECL
642 && DECL_BY_REFERENCE (SSA_NAME_VAR (ssa_name
)))
644 error ("RESULT_DECL should be read only when DECL_BY_REFERENCE is set");
648 if (definition_block
[SSA_NAME_VERSION (ssa_name
)])
650 error ("SSA_NAME created in two different blocks %i and %i",
651 definition_block
[SSA_NAME_VERSION (ssa_name
)]->index
, bb
->index
);
655 definition_block
[SSA_NAME_VERSION (ssa_name
)] = bb
;
657 if (SSA_NAME_DEF_STMT (ssa_name
) != stmt
)
659 error ("SSA_NAME_DEF_STMT is wrong");
660 fprintf (stderr
, "Expected definition statement:\n");
661 print_gimple_stmt (stderr
, SSA_NAME_DEF_STMT (ssa_name
), 4, TDF_VOPS
);
662 fprintf (stderr
, "\nActual definition statement:\n");
663 print_gimple_stmt (stderr
, stmt
, 4, TDF_VOPS
);
670 fprintf (stderr
, "while verifying SSA_NAME ");
671 print_generic_expr (stderr
, ssa_name
, 0);
672 fprintf (stderr
, " in statement\n");
673 print_gimple_stmt (stderr
, stmt
, 4, TDF_VOPS
);
679 /* Return true if the use of SSA_NAME at statement STMT in block BB is
682 DEF_BB is the block where SSA_NAME was found to be created.
684 IDOM contains immediate dominator information for the flowgraph.
686 CHECK_ABNORMAL is true if the caller wants to check whether this use
687 is flowing through an abnormal edge (only used when checking PHI
690 If NAMES_DEFINED_IN_BB is not NULL, it contains a bitmap of ssa names
691 that are defined before STMT in basic block BB. */
694 verify_use (basic_block bb
, basic_block def_bb
, use_operand_p use_p
,
695 gimple stmt
, bool check_abnormal
, bitmap names_defined_in_bb
)
698 tree ssa_name
= USE_FROM_PTR (use_p
);
700 if (!TREE_VISITED (ssa_name
))
701 if (verify_imm_links (stderr
, ssa_name
))
704 TREE_VISITED (ssa_name
) = 1;
706 if (gimple_nop_p (SSA_NAME_DEF_STMT (ssa_name
))
707 && SSA_NAME_IS_DEFAULT_DEF (ssa_name
))
708 ; /* Default definitions have empty statements. Nothing to do. */
711 error ("missing definition");
714 else if (bb
!= def_bb
715 && !dominated_by_p (CDI_DOMINATORS
, bb
, def_bb
))
717 error ("definition in block %i does not dominate use in block %i",
718 def_bb
->index
, bb
->index
);
721 else if (bb
== def_bb
722 && names_defined_in_bb
!= NULL
723 && !bitmap_bit_p (names_defined_in_bb
, SSA_NAME_VERSION (ssa_name
)))
725 error ("definition in block %i follows the use", def_bb
->index
);
730 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ssa_name
))
732 error ("SSA_NAME_OCCURS_IN_ABNORMAL_PHI should be set");
736 /* Make sure the use is in an appropriate list by checking the previous
737 element to make sure it's the same. */
738 if (use_p
->prev
== NULL
)
740 error ("no immediate_use list");
746 if (use_p
->prev
->use
== NULL
)
747 listvar
= use_p
->prev
->loc
.ssa_name
;
749 listvar
= USE_FROM_PTR (use_p
->prev
);
750 if (listvar
!= ssa_name
)
752 error ("wrong immediate use list");
759 fprintf (stderr
, "for SSA_NAME: ");
760 print_generic_expr (stderr
, ssa_name
, TDF_VOPS
);
761 fprintf (stderr
, " in statement:\n");
762 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
);
769 /* Return true if any of the arguments for PHI node PHI at block BB is
772 DEFINITION_BLOCK is an array of basic blocks indexed by SSA_NAME
773 version numbers. If DEFINITION_BLOCK[SSA_NAME_VERSION] is set,
774 it means that the block in that array slot contains the
775 definition of SSA_NAME. */
778 verify_phi_args (gimple phi
, basic_block bb
, basic_block
*definition_block
)
782 size_t i
, phi_num_args
= gimple_phi_num_args (phi
);
784 if (EDGE_COUNT (bb
->preds
) != phi_num_args
)
786 error ("incoming edge count does not match number of PHI arguments");
791 for (i
= 0; i
< phi_num_args
; i
++)
793 use_operand_p op_p
= gimple_phi_arg_imm_use_ptr (phi
, i
);
794 tree op
= USE_FROM_PTR (op_p
);
796 e
= EDGE_PRED (bb
, i
);
800 error ("PHI argument is missing for edge %d->%d",
807 if (TREE_CODE (op
) != SSA_NAME
&& !is_gimple_min_invariant (op
))
809 error ("PHI argument is not SSA_NAME, or invariant");
813 if (TREE_CODE (op
) == SSA_NAME
)
815 err
= verify_ssa_name (op
, !is_gimple_reg (gimple_phi_result (phi
)));
816 err
|= verify_use (e
->src
, definition_block
[SSA_NAME_VERSION (op
)],
817 op_p
, phi
, e
->flags
& EDGE_ABNORMAL
, NULL
);
820 if (TREE_CODE (op
) == ADDR_EXPR
)
822 tree base
= TREE_OPERAND (op
, 0);
823 while (handled_component_p (base
))
824 base
= TREE_OPERAND (base
, 0);
825 if ((TREE_CODE (base
) == VAR_DECL
826 || TREE_CODE (base
) == PARM_DECL
827 || TREE_CODE (base
) == RESULT_DECL
)
828 && !TREE_ADDRESSABLE (base
))
830 error ("address taken, but ADDRESSABLE bit not set");
837 error ("wrong edge %d->%d for PHI argument",
838 e
->src
->index
, e
->dest
->index
);
844 fprintf (stderr
, "PHI argument\n");
845 print_generic_stmt (stderr
, op
, TDF_VOPS
);
853 fprintf (stderr
, "for PHI node\n");
854 print_gimple_stmt (stderr
, phi
, 0, TDF_VOPS
|TDF_MEMSYMS
);
862 /* Verify common invariants in the SSA web.
863 TODO: verify the variable annotations. */
866 verify_ssa (bool check_modified_stmt
)
870 basic_block
*definition_block
= XCNEWVEC (basic_block
, num_ssa_names
);
873 enum dom_state orig_dom_state
= dom_info_state (CDI_DOMINATORS
);
874 bitmap names_defined_in_bb
= BITMAP_ALLOC (NULL
);
876 gcc_assert (!need_ssa_update_p (cfun
));
880 timevar_push (TV_TREE_SSA_VERIFY
);
882 /* Keep track of SSA names present in the IL. */
883 for (i
= 1; i
< num_ssa_names
; i
++)
885 tree name
= ssa_name (i
);
889 TREE_VISITED (name
) = 0;
891 stmt
= SSA_NAME_DEF_STMT (name
);
892 if (!gimple_nop_p (stmt
))
894 basic_block bb
= gimple_bb (stmt
);
895 verify_def (bb
, definition_block
,
896 name
, stmt
, !is_gimple_reg (name
));
902 calculate_dominance_info (CDI_DOMINATORS
);
904 /* Now verify all the uses and make sure they agree with the definitions
905 found in the previous pass. */
911 gimple_stmt_iterator gsi
;
913 /* Make sure that all edges have a clear 'aux' field. */
914 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
918 error ("AUX pointer initialized for edge %d->%d", e
->src
->index
,
924 /* Verify the arguments for every PHI node in the block. */
925 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
927 phi
= gsi_stmt (gsi
);
928 if (verify_phi_args (phi
, bb
, definition_block
))
931 bitmap_set_bit (names_defined_in_bb
,
932 SSA_NAME_VERSION (gimple_phi_result (phi
)));
935 /* Now verify all the uses and vuses in every statement of the block. */
936 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
938 gimple stmt
= gsi_stmt (gsi
);
944 if (check_modified_stmt
&& gimple_modified_p (stmt
))
946 error ("stmt (%p) marked modified after optimization pass: ",
948 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
);
952 if (is_gimple_assign (stmt
)
953 && TREE_CODE (gimple_assign_lhs (stmt
)) != SSA_NAME
)
955 tree lhs
, base_address
;
957 lhs
= gimple_assign_lhs (stmt
);
958 base_address
= get_base_address (lhs
);
961 && SSA_VAR_P (base_address
)
962 && !gimple_vdef (stmt
)
965 error ("statement makes a memory store, but has no VDEFS");
966 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
);
970 else if (gimple_debug_bind_p (stmt
)
971 && !gimple_debug_bind_has_value_p (stmt
))
974 /* Verify the single virtual operand and its constraints. */
976 if (gimple_vdef (stmt
))
978 if (gimple_vdef_op (stmt
) == NULL_DEF_OPERAND_P
)
980 error ("statement has VDEF operand not in defs list");
983 if (!gimple_vuse (stmt
))
985 error ("statement has VDEF but no VUSE operand");
988 else if (SSA_NAME_VAR (gimple_vdef (stmt
))
989 != SSA_NAME_VAR (gimple_vuse (stmt
)))
991 error ("VDEF and VUSE do not use the same symbol");
994 has_err
|= verify_ssa_name (gimple_vdef (stmt
), true);
996 if (gimple_vuse (stmt
))
998 if (gimple_vuse_op (stmt
) == NULL_USE_OPERAND_P
)
1000 error ("statement has VUSE operand not in uses list");
1003 has_err
|= verify_ssa_name (gimple_vuse (stmt
), true);
1007 error ("in statement");
1008 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
|TDF_MEMSYMS
);
1013 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, iter
, SSA_OP_USE
|SSA_OP_DEF
)
1015 if (verify_ssa_name (op
, false))
1017 error ("in statement");
1018 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
|TDF_MEMSYMS
);
1024 for (i
= 0; i
< gimple_num_ops (stmt
); i
++)
1026 op
= gimple_op (stmt
, i
);
1027 if (op
&& TREE_CODE (op
) == SSA_NAME
&& --count
< 0)
1029 error ("number of operands and imm-links don%'t agree"
1031 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
|TDF_MEMSYMS
);
1036 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_USE
|SSA_OP_VUSE
)
1038 op
= USE_FROM_PTR (use_p
);
1039 if (verify_use (bb
, definition_block
[SSA_NAME_VERSION (op
)],
1040 use_p
, stmt
, false, names_defined_in_bb
))
1044 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, iter
, SSA_OP_ALL_DEFS
)
1046 if (SSA_NAME_DEF_STMT (op
) != stmt
)
1048 error ("SSA_NAME_DEF_STMT is wrong");
1049 fprintf (stderr
, "Expected definition statement:\n");
1050 print_gimple_stmt (stderr
, stmt
, 4, TDF_VOPS
);
1051 fprintf (stderr
, "\nActual definition statement:\n");
1052 print_gimple_stmt (stderr
, SSA_NAME_DEF_STMT (op
),
1056 bitmap_set_bit (names_defined_in_bb
, SSA_NAME_VERSION (op
));
1060 bitmap_clear (names_defined_in_bb
);
1063 free (definition_block
);
1065 /* Restore the dominance information to its prior known state, so
1066 that we do not perturb the compiler's subsequent behavior. */
1067 if (orig_dom_state
== DOM_NONE
)
1068 free_dominance_info (CDI_DOMINATORS
);
1070 set_dom_info_availability (CDI_DOMINATORS
, orig_dom_state
);
1072 BITMAP_FREE (names_defined_in_bb
);
1073 timevar_pop (TV_TREE_SSA_VERIFY
);
1077 internal_error ("verify_ssa failed");
1080 /* Return true if the uid in both int tree maps are equal. */
1083 int_tree_map_eq (const void *va
, const void *vb
)
1085 const struct int_tree_map
*a
= (const struct int_tree_map
*) va
;
1086 const struct int_tree_map
*b
= (const struct int_tree_map
*) vb
;
1087 return (a
->uid
== b
->uid
);
1090 /* Hash a UID in a int_tree_map. */
1093 int_tree_map_hash (const void *item
)
1095 return ((const struct int_tree_map
*)item
)->uid
;
1098 /* Return true if the DECL_UID in both trees are equal. */
1101 uid_decl_map_eq (const void *va
, const void *vb
)
1103 const_tree a
= (const_tree
) va
;
1104 const_tree b
= (const_tree
) vb
;
1105 return (a
->decl_minimal
.uid
== b
->decl_minimal
.uid
);
1108 /* Hash a tree in a uid_decl_map. */
1111 uid_decl_map_hash (const void *item
)
1113 return ((const_tree
)item
)->decl_minimal
.uid
;
1116 /* Return true if the DECL_UID in both trees are equal. */
1119 uid_ssaname_map_eq (const void *va
, const void *vb
)
1121 const_tree a
= (const_tree
) va
;
1122 const_tree b
= (const_tree
) vb
;
1123 return (a
->ssa_name
.var
->decl_minimal
.uid
== b
->ssa_name
.var
->decl_minimal
.uid
);
1126 /* Hash a tree in a uid_decl_map. */
1129 uid_ssaname_map_hash (const void *item
)
1131 return ((const_tree
)item
)->ssa_name
.var
->decl_minimal
.uid
;
1135 /* Initialize global DFA and SSA structures. */
1138 init_tree_ssa (struct function
*fn
)
1140 fn
->gimple_df
= ggc_alloc_cleared_gimple_df ();
1141 fn
->gimple_df
->referenced_vars
= htab_create_ggc (20, uid_decl_map_hash
,
1142 uid_decl_map_eq
, NULL
);
1143 fn
->gimple_df
->default_defs
= htab_create_ggc (20, uid_ssaname_map_hash
,
1144 uid_ssaname_map_eq
, NULL
);
1145 pt_solution_reset (&fn
->gimple_df
->escaped
);
1146 init_ssanames (fn
, 0);
1151 /* Deallocate memory associated with SSA data structures for FNDECL. */
1154 delete_tree_ssa (void)
1156 referenced_var_iterator rvi
;
1159 /* Remove annotations from every referenced local variable. */
1160 FOR_EACH_REFERENCED_VAR (var
, rvi
)
1162 if (is_global_var (var
))
1166 ggc_free (var_ann (var
));
1167 *DECL_VAR_ANN_PTR (var
) = NULL
;
1170 htab_delete (gimple_referenced_vars (cfun
));
1171 cfun
->gimple_df
->referenced_vars
= NULL
;
1176 /* We no longer maintain the SSA operand cache at this point. */
1177 if (ssa_operands_active ())
1178 fini_ssa_operands ();
1180 delete_alias_heapvars ();
1182 htab_delete (cfun
->gimple_df
->default_defs
);
1183 cfun
->gimple_df
->default_defs
= NULL
;
1184 pt_solution_reset (&cfun
->gimple_df
->escaped
);
1185 if (cfun
->gimple_df
->decls_to_pointers
!= NULL
)
1186 pointer_map_destroy (cfun
->gimple_df
->decls_to_pointers
);
1187 cfun
->gimple_df
->decls_to_pointers
= NULL
;
1188 cfun
->gimple_df
->modified_noreturn_calls
= NULL
;
1189 cfun
->gimple_df
= NULL
;
1191 /* We no longer need the edge variable maps. */
1192 redirect_edge_var_map_destroy ();
1195 /* Return true if the conversion from INNER_TYPE to OUTER_TYPE is a
1196 useless type conversion, otherwise return false.
1198 This function implicitly defines the middle-end type system. With
1199 the notion of 'a < b' meaning that useless_type_conversion_p (a, b)
1200 holds and 'a > b' meaning that useless_type_conversion_p (b, a) holds,
1201 the following invariants shall be fulfilled:
1203 1) useless_type_conversion_p is transitive.
1204 If a < b and b < c then a < c.
1206 2) useless_type_conversion_p is not symmetric.
1207 From a < b does not follow a > b.
1209 3) Types define the available set of operations applicable to values.
1210 A type conversion is useless if the operations for the target type
1211 is a subset of the operations for the source type. For example
1212 casts to void* are useless, casts from void* are not (void* can't
1213 be dereferenced or offsetted, but copied, hence its set of operations
1214 is a strict subset of that of all other data pointer types). Casts
1215 to const T* are useless (can't be written to), casts from const T*
1219 useless_type_conversion_p (tree outer_type
, tree inner_type
)
1221 /* Do the following before stripping toplevel qualifiers. */
1222 if (POINTER_TYPE_P (inner_type
)
1223 && POINTER_TYPE_P (outer_type
))
1225 /* Do not lose casts between pointers to different address spaces. */
1226 if (TYPE_ADDR_SPACE (TREE_TYPE (outer_type
))
1227 != TYPE_ADDR_SPACE (TREE_TYPE (inner_type
)))
1230 /* Do not lose casts to restrict qualified pointers. */
1231 if ((TYPE_RESTRICT (outer_type
)
1232 != TYPE_RESTRICT (inner_type
))
1233 && TYPE_RESTRICT (outer_type
))
1236 /* If the outer type is (void *) or a pointer to an incomplete
1237 record type or a pointer to an unprototyped function,
1238 then the conversion is not necessary. */
1239 if (VOID_TYPE_P (TREE_TYPE (outer_type
))
1240 || ((TREE_CODE (TREE_TYPE (outer_type
)) == FUNCTION_TYPE
1241 || TREE_CODE (TREE_TYPE (outer_type
)) == METHOD_TYPE
)
1242 && (TREE_CODE (TREE_TYPE (outer_type
))
1243 == TREE_CODE (TREE_TYPE (inner_type
)))
1244 && !prototype_p (TREE_TYPE (outer_type
))
1245 && useless_type_conversion_p (TREE_TYPE (TREE_TYPE (outer_type
)),
1246 TREE_TYPE (TREE_TYPE (inner_type
)))))
1250 /* From now on qualifiers on value types do not matter. */
1251 inner_type
= TYPE_MAIN_VARIANT (inner_type
);
1252 outer_type
= TYPE_MAIN_VARIANT (outer_type
);
1254 if (inner_type
== outer_type
)
1257 /* If we know the canonical types, compare them. */
1258 if (TYPE_CANONICAL (inner_type
)
1259 && TYPE_CANONICAL (inner_type
) == TYPE_CANONICAL (outer_type
))
1262 /* Changes in machine mode are never useless conversions unless we
1263 deal with aggregate types in which case we defer to later checks. */
1264 if (TYPE_MODE (inner_type
) != TYPE_MODE (outer_type
)
1265 && !AGGREGATE_TYPE_P (inner_type
))
1268 /* If both the inner and outer types are integral types, then the
1269 conversion is not necessary if they have the same mode and
1270 signedness and precision, and both or neither are boolean. */
1271 if (INTEGRAL_TYPE_P (inner_type
)
1272 && INTEGRAL_TYPE_P (outer_type
))
1274 /* Preserve changes in signedness or precision. */
1275 if (TYPE_UNSIGNED (inner_type
) != TYPE_UNSIGNED (outer_type
)
1276 || TYPE_PRECISION (inner_type
) != TYPE_PRECISION (outer_type
))
1279 /* We don't need to preserve changes in the types minimum or
1280 maximum value in general as these do not generate code
1281 unless the types precisions are different. */
1285 /* Scalar floating point types with the same mode are compatible. */
1286 else if (SCALAR_FLOAT_TYPE_P (inner_type
)
1287 && SCALAR_FLOAT_TYPE_P (outer_type
))
1290 /* Fixed point types with the same mode are compatible. */
1291 else if (FIXED_POINT_TYPE_P (inner_type
)
1292 && FIXED_POINT_TYPE_P (outer_type
))
1295 /* We need to take special care recursing to pointed-to types. */
1296 else if (POINTER_TYPE_P (inner_type
)
1297 && POINTER_TYPE_P (outer_type
))
1299 /* Do not lose casts to function pointer types. */
1300 if ((TREE_CODE (TREE_TYPE (outer_type
)) == FUNCTION_TYPE
1301 || TREE_CODE (TREE_TYPE (outer_type
)) == METHOD_TYPE
)
1302 && !useless_type_conversion_p (TREE_TYPE (outer_type
),
1303 TREE_TYPE (inner_type
)))
1306 /* We do not care for const qualification of the pointed-to types
1307 as const qualification has no semantic value to the middle-end. */
1309 /* Otherwise pointers/references are equivalent. */
1313 /* Recurse for complex types. */
1314 else if (TREE_CODE (inner_type
) == COMPLEX_TYPE
1315 && TREE_CODE (outer_type
) == COMPLEX_TYPE
)
1316 return useless_type_conversion_p (TREE_TYPE (outer_type
),
1317 TREE_TYPE (inner_type
));
1319 /* Recurse for vector types with the same number of subparts. */
1320 else if (TREE_CODE (inner_type
) == VECTOR_TYPE
1321 && TREE_CODE (outer_type
) == VECTOR_TYPE
1322 && TYPE_PRECISION (inner_type
) == TYPE_PRECISION (outer_type
))
1323 return useless_type_conversion_p (TREE_TYPE (outer_type
),
1324 TREE_TYPE (inner_type
));
1326 else if (TREE_CODE (inner_type
) == ARRAY_TYPE
1327 && TREE_CODE (outer_type
) == ARRAY_TYPE
)
1329 /* Preserve string attributes. */
1330 if (TYPE_STRING_FLAG (inner_type
) != TYPE_STRING_FLAG (outer_type
))
1333 /* Conversions from array types with unknown extent to
1334 array types with known extent are not useless. */
1335 if (!TYPE_DOMAIN (inner_type
)
1336 && TYPE_DOMAIN (outer_type
))
1339 /* Nor are conversions from array types with non-constant size to
1340 array types with constant size or to different size. */
1341 if (TYPE_SIZE (outer_type
)
1342 && TREE_CODE (TYPE_SIZE (outer_type
)) == INTEGER_CST
1343 && (!TYPE_SIZE (inner_type
)
1344 || TREE_CODE (TYPE_SIZE (inner_type
)) != INTEGER_CST
1345 || !tree_int_cst_equal (TYPE_SIZE (outer_type
),
1346 TYPE_SIZE (inner_type
))))
1349 /* Check conversions between arrays with partially known extents.
1350 If the array min/max values are constant they have to match.
1351 Otherwise allow conversions to unknown and variable extents.
1352 In particular this declares conversions that may change the
1353 mode to BLKmode as useless. */
1354 if (TYPE_DOMAIN (inner_type
)
1355 && TYPE_DOMAIN (outer_type
)
1356 && TYPE_DOMAIN (inner_type
) != TYPE_DOMAIN (outer_type
))
1358 tree inner_min
= TYPE_MIN_VALUE (TYPE_DOMAIN (inner_type
));
1359 tree outer_min
= TYPE_MIN_VALUE (TYPE_DOMAIN (outer_type
));
1360 tree inner_max
= TYPE_MAX_VALUE (TYPE_DOMAIN (inner_type
));
1361 tree outer_max
= TYPE_MAX_VALUE (TYPE_DOMAIN (outer_type
));
1363 /* After gimplification a variable min/max value carries no
1364 additional information compared to a NULL value. All that
1365 matters has been lowered to be part of the IL. */
1366 if (inner_min
&& TREE_CODE (inner_min
) != INTEGER_CST
)
1367 inner_min
= NULL_TREE
;
1368 if (outer_min
&& TREE_CODE (outer_min
) != INTEGER_CST
)
1369 outer_min
= NULL_TREE
;
1370 if (inner_max
&& TREE_CODE (inner_max
) != INTEGER_CST
)
1371 inner_max
= NULL_TREE
;
1372 if (outer_max
&& TREE_CODE (outer_max
) != INTEGER_CST
)
1373 outer_max
= NULL_TREE
;
1375 /* Conversions NULL / variable <- cst are useless, but not
1376 the other way around. */
1379 || !tree_int_cst_equal (inner_min
, outer_min
)))
1383 || !tree_int_cst_equal (inner_max
, outer_max
)))
1387 /* Recurse on the element check. */
1388 return useless_type_conversion_p (TREE_TYPE (outer_type
),
1389 TREE_TYPE (inner_type
));
1392 else if ((TREE_CODE (inner_type
) == FUNCTION_TYPE
1393 || TREE_CODE (inner_type
) == METHOD_TYPE
)
1394 && TREE_CODE (inner_type
) == TREE_CODE (outer_type
))
1396 tree outer_parm
, inner_parm
;
1398 /* If the return types are not compatible bail out. */
1399 if (!useless_type_conversion_p (TREE_TYPE (outer_type
),
1400 TREE_TYPE (inner_type
)))
1403 /* Method types should belong to a compatible base class. */
1404 if (TREE_CODE (inner_type
) == METHOD_TYPE
1405 && !useless_type_conversion_p (TYPE_METHOD_BASETYPE (outer_type
),
1406 TYPE_METHOD_BASETYPE (inner_type
)))
1409 /* A conversion to an unprototyped argument list is ok. */
1410 if (!prototype_p (outer_type
))
1413 /* If the unqualified argument types are compatible the conversion
1415 if (TYPE_ARG_TYPES (outer_type
) == TYPE_ARG_TYPES (inner_type
))
1418 for (outer_parm
= TYPE_ARG_TYPES (outer_type
),
1419 inner_parm
= TYPE_ARG_TYPES (inner_type
);
1420 outer_parm
&& inner_parm
;
1421 outer_parm
= TREE_CHAIN (outer_parm
),
1422 inner_parm
= TREE_CHAIN (inner_parm
))
1423 if (!useless_type_conversion_p
1424 (TYPE_MAIN_VARIANT (TREE_VALUE (outer_parm
)),
1425 TYPE_MAIN_VARIANT (TREE_VALUE (inner_parm
))))
1428 /* If there is a mismatch in the number of arguments the functions
1429 are not compatible. */
1430 if (outer_parm
|| inner_parm
)
1433 /* Defer to the target if necessary. */
1434 if (TYPE_ATTRIBUTES (inner_type
) || TYPE_ATTRIBUTES (outer_type
))
1435 return targetm
.comp_type_attributes (outer_type
, inner_type
) != 0;
1440 /* For aggregates we rely on TYPE_CANONICAL exclusively and require
1441 explicit conversions for types involving to be structurally
1443 else if (AGGREGATE_TYPE_P (inner_type
)
1444 && TREE_CODE (inner_type
) == TREE_CODE (outer_type
))
1450 /* Return true if a conversion from either type of TYPE1 and TYPE2
1451 to the other is not required. Otherwise return false. */
1454 types_compatible_p (tree type1
, tree type2
)
1456 return (type1
== type2
1457 || (useless_type_conversion_p (type1
, type2
)
1458 && useless_type_conversion_p (type2
, type1
)));
1461 /* Return true if EXPR is a useless type conversion, otherwise return
1465 tree_ssa_useless_type_conversion (tree expr
)
1467 /* If we have an assignment that merely uses a NOP_EXPR to change
1468 the top of the RHS to the type of the LHS and the type conversion
1469 is "safe", then strip away the type conversion so that we can
1470 enter LHS = RHS into the const_and_copies table. */
1471 if (CONVERT_EXPR_P (expr
)
1472 || TREE_CODE (expr
) == VIEW_CONVERT_EXPR
1473 || TREE_CODE (expr
) == NON_LVALUE_EXPR
)
1474 return useless_type_conversion_p
1476 TREE_TYPE (TREE_OPERAND (expr
, 0)));
1481 /* Strip conversions from EXP according to
1482 tree_ssa_useless_type_conversion and return the resulting
1486 tree_ssa_strip_useless_type_conversions (tree exp
)
1488 while (tree_ssa_useless_type_conversion (exp
))
1489 exp
= TREE_OPERAND (exp
, 0);
1494 /* Internal helper for walk_use_def_chains. VAR, FN and DATA are as
1495 described in walk_use_def_chains.
1497 VISITED is a pointer set used to mark visited SSA_NAMEs to avoid
1498 infinite loops. We used to have a bitmap for this to just mark
1499 SSA versions we had visited. But non-sparse bitmaps are way too
1500 expensive, while sparse bitmaps may cause quadratic behavior.
1502 IS_DFS is true if the caller wants to perform a depth-first search
1503 when visiting PHI nodes. A DFS will visit each PHI argument and
1504 call FN after each one. Otherwise, all the arguments are
1505 visited first and then FN is called with each of the visited
1506 arguments in a separate pass. */
1509 walk_use_def_chains_1 (tree var
, walk_use_def_chains_fn fn
, void *data
,
1510 struct pointer_set_t
*visited
, bool is_dfs
)
1514 if (pointer_set_insert (visited
, var
))
1517 def_stmt
= SSA_NAME_DEF_STMT (var
);
1519 if (gimple_code (def_stmt
) != GIMPLE_PHI
)
1521 /* If we reached the end of the use-def chain, call FN. */
1522 return fn (var
, def_stmt
, data
);
1528 /* When doing a breadth-first search, call FN before following the
1529 use-def links for each argument. */
1531 for (i
= 0; i
< gimple_phi_num_args (def_stmt
); i
++)
1532 if (fn (gimple_phi_arg_def (def_stmt
, i
), def_stmt
, data
))
1535 /* Follow use-def links out of each PHI argument. */
1536 for (i
= 0; i
< gimple_phi_num_args (def_stmt
); i
++)
1538 tree arg
= gimple_phi_arg_def (def_stmt
, i
);
1540 /* ARG may be NULL for newly introduced PHI nodes. */
1542 && TREE_CODE (arg
) == SSA_NAME
1543 && walk_use_def_chains_1 (arg
, fn
, data
, visited
, is_dfs
))
1547 /* When doing a depth-first search, call FN after following the
1548 use-def links for each argument. */
1550 for (i
= 0; i
< gimple_phi_num_args (def_stmt
); i
++)
1551 if (fn (gimple_phi_arg_def (def_stmt
, i
), def_stmt
, data
))
1560 /* Walk use-def chains starting at the SSA variable VAR. Call
1561 function FN at each reaching definition found. FN takes three
1562 arguments: VAR, its defining statement (DEF_STMT) and a generic
1563 pointer to whatever state information that FN may want to maintain
1564 (DATA). FN is able to stop the walk by returning true, otherwise
1565 in order to continue the walk, FN should return false.
1567 Note, that if DEF_STMT is a PHI node, the semantics are slightly
1568 different. The first argument to FN is no longer the original
1569 variable VAR, but the PHI argument currently being examined. If FN
1570 wants to get at VAR, it should call PHI_RESULT (PHI).
1572 If IS_DFS is true, this function will:
1574 1- walk the use-def chains for all the PHI arguments, and,
1575 2- call (*FN) (ARG, PHI, DATA) on all the PHI arguments.
1577 If IS_DFS is false, the two steps above are done in reverse order
1578 (i.e., a breadth-first search). */
1581 walk_use_def_chains (tree var
, walk_use_def_chains_fn fn
, void *data
,
1586 gcc_assert (TREE_CODE (var
) == SSA_NAME
);
1588 def_stmt
= SSA_NAME_DEF_STMT (var
);
1590 /* We only need to recurse if the reaching definition comes from a PHI
1592 if (gimple_code (def_stmt
) != GIMPLE_PHI
)
1593 (*fn
) (var
, def_stmt
, data
);
1596 struct pointer_set_t
*visited
= pointer_set_create ();
1597 walk_use_def_chains_1 (var
, fn
, data
, visited
, is_dfs
);
1598 pointer_set_destroy (visited
);
1603 /* Emit warnings for uninitialized variables. This is done in two passes.
1605 The first pass notices real uses of SSA names with undefined values.
1606 Such uses are unconditionally uninitialized, and we can be certain that
1607 such a use is a mistake. This pass is run before most optimizations,
1608 so that we catch as many as we can.
1610 The second pass follows PHI nodes to find uses that are potentially
1611 uninitialized. In this case we can't necessarily prove that the use
1612 is really uninitialized. This pass is run after most optimizations,
1613 so that we thread as many jumps and possible, and delete as much dead
1614 code as possible, in order to reduce false positives. We also look
1615 again for plain uninitialized variables, since optimization may have
1616 changed conditionally uninitialized to unconditionally uninitialized. */
1618 /* Emit a warning for T, an SSA_NAME, being uninitialized. The exact
1619 warning text is in MSGID and LOCUS may contain a location or be null. */
1622 warn_uninit (tree t
, const char *gmsgid
, void *data
)
1624 tree var
= SSA_NAME_VAR (t
);
1625 gimple context
= (gimple
) data
;
1626 location_t location
;
1627 expanded_location xloc
, floc
;
1629 if (!ssa_undefined_value_p (t
))
1632 /* TREE_NO_WARNING either means we already warned, or the front end
1633 wishes to suppress the warning. */
1634 if (TREE_NO_WARNING (var
))
1637 /* Do not warn if it can be initialized outside this module. */
1638 if (is_global_var (var
))
1641 location
= (context
!= NULL
&& gimple_has_location (context
))
1642 ? gimple_location (context
)
1643 : DECL_SOURCE_LOCATION (var
);
1644 xloc
= expand_location (location
);
1645 floc
= expand_location (DECL_SOURCE_LOCATION (cfun
->decl
));
1646 if (warning_at (location
, OPT_Wuninitialized
, gmsgid
, var
))
1648 TREE_NO_WARNING (var
) = 1;
1650 if (location
== DECL_SOURCE_LOCATION (var
))
1652 if (xloc
.file
!= floc
.file
1653 || xloc
.line
< floc
.line
1654 || xloc
.line
> LOCATION_LINE (cfun
->function_end_locus
))
1655 inform (DECL_SOURCE_LOCATION (var
), "%qD was declared here", var
);
1661 bool always_executed
;
1662 bool warn_possibly_uninitialized
;
1665 /* Called via walk_tree, look for SSA_NAMEs that have empty definitions
1666 and warn about them. */
1669 warn_uninitialized_var (tree
*tp
, int *walk_subtrees
, void *data_
)
1671 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data_
;
1672 struct walk_data
*data
= (struct walk_data
*) wi
->info
;
1675 /* We do not care about LHS. */
1678 /* Except for operands of dereferences. */
1679 if (!INDIRECT_REF_P (t
)
1680 && TREE_CODE (t
) != MEM_REF
)
1682 t
= TREE_OPERAND (t
, 0);
1685 switch (TREE_CODE (t
))
1688 /* Taking the address of an uninitialized variable does not
1689 count as using it. */
1695 /* A VAR_DECL in the RHS of a gimple statement may mean that
1696 this variable is loaded from memory. */
1700 /* If there is not gimple stmt,
1701 or alias information has not been computed,
1702 then we cannot check VUSE ops. */
1703 if (data
->stmt
== NULL
)
1706 /* If the load happens as part of a call do not warn about it. */
1707 if (is_gimple_call (data
->stmt
))
1710 vuse
= gimple_vuse_op (data
->stmt
);
1711 if (vuse
== NULL_USE_OPERAND_P
)
1714 op
= USE_FROM_PTR (vuse
);
1715 if (t
!= SSA_NAME_VAR (op
)
1716 || !SSA_NAME_IS_DEFAULT_DEF (op
))
1718 /* If this is a VUSE of t and it is the default definition,
1719 then warn about op. */
1721 /* Fall through into SSA_NAME. */
1725 /* We only do data flow with SSA_NAMEs, so that's all we
1727 if (data
->always_executed
)
1728 warn_uninit (t
, "%qD is used uninitialized in this function",
1730 else if (data
->warn_possibly_uninitialized
)
1731 warn_uninit (t
, "%qD may be used uninitialized in this function",
1738 /* The total store transformation performed during gimplification
1739 creates uninitialized variable uses. If all is well, these will
1740 be optimized away, so don't warn now. */
1741 if (TREE_CODE (TREE_OPERAND (t
, 0)) == SSA_NAME
)
1746 if (IS_TYPE_OR_DECL_P (t
))
1755 warn_uninitialized_vars (bool warn_possibly_uninitialized
)
1757 gimple_stmt_iterator gsi
;
1759 struct walk_data data
;
1761 data
.warn_possibly_uninitialized
= warn_possibly_uninitialized
;
1766 data
.always_executed
= dominated_by_p (CDI_POST_DOMINATORS
,
1767 single_succ (ENTRY_BLOCK_PTR
), bb
);
1768 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1770 struct walk_stmt_info wi
;
1771 data
.stmt
= gsi_stmt (gsi
);
1772 if (is_gimple_debug (data
.stmt
))
1774 memset (&wi
, 0, sizeof (wi
));
1776 walk_gimple_op (gsi_stmt (gsi
), warn_uninitialized_var
, &wi
);
1784 execute_early_warn_uninitialized (void)
1786 /* Currently, this pass runs always but
1787 execute_late_warn_uninitialized only runs with optimization. With
1788 optimization we want to warn about possible uninitialized as late
1789 as possible, thus don't do it here. However, without
1790 optimization we need to warn here about "may be uninitialized".
1792 calculate_dominance_info (CDI_POST_DOMINATORS
);
1794 warn_uninitialized_vars (/*warn_possibly_uninitialized=*/!optimize
);
1796 /* Post-dominator information can not be reliably updated. Free it
1799 free_dominance_info (CDI_POST_DOMINATORS
);
1804 gate_warn_uninitialized (void)
1806 return warn_uninitialized
!= 0;
1809 struct gimple_opt_pass pass_early_warn_uninitialized
=
1813 "*early_warn_uninitialized", /* name */
1814 gate_warn_uninitialized
, /* gate */
1815 execute_early_warn_uninitialized
, /* execute */
1818 0, /* static_pass_number */
1819 TV_TREE_UNINIT
, /* tv_id */
1820 PROP_ssa
, /* properties_required */
1821 0, /* properties_provided */
1822 0, /* properties_destroyed */
1823 0, /* todo_flags_start */
1824 0 /* todo_flags_finish */
1829 /* If necessary, rewrite the base of the reference tree *TP from
1830 a MEM_REF to a plain or converted symbol. */
1833 maybe_rewrite_mem_ref_base (tree
*tp
)
1837 while (handled_component_p (*tp
))
1838 tp
= &TREE_OPERAND (*tp
, 0);
1839 if (TREE_CODE (*tp
) == MEM_REF
1840 && TREE_CODE (TREE_OPERAND (*tp
, 0)) == ADDR_EXPR
1841 && integer_zerop (TREE_OPERAND (*tp
, 1))
1842 && (sym
= TREE_OPERAND (TREE_OPERAND (*tp
, 0), 0))
1844 && !TREE_ADDRESSABLE (sym
)
1845 && symbol_marked_for_renaming (sym
))
1847 if (!useless_type_conversion_p (TREE_TYPE (*tp
),
1849 *tp
= build1 (VIEW_CONVERT_EXPR
,
1850 TREE_TYPE (*tp
), sym
);
1856 /* For a tree REF return its base if it is the base of a MEM_REF
1857 that cannot be rewritten into SSA form. Otherwise return NULL_TREE. */
1860 non_rewritable_mem_ref_base (tree ref
)
1864 /* A plain decl does not need it set. */
1868 while (handled_component_p (base
))
1869 base
= TREE_OPERAND (base
, 0);
1871 /* But watch out for MEM_REFs we cannot lower to a
1872 VIEW_CONVERT_EXPR. */
1873 if (TREE_CODE (base
) == MEM_REF
1874 && TREE_CODE (TREE_OPERAND (base
, 0)) == ADDR_EXPR
)
1876 tree decl
= TREE_OPERAND (TREE_OPERAND (base
, 0), 0);
1878 && (!integer_zerop (TREE_OPERAND (base
, 1))
1879 || (DECL_SIZE (decl
)
1880 != TYPE_SIZE (TREE_TYPE (base
)))
1881 || TREE_THIS_VOLATILE (decl
) != TREE_THIS_VOLATILE (base
)))
1888 /* When possible, clear TREE_ADDRESSABLE bit or set DECL_GIMPLE_REG_P bit and
1889 mark the variable VAR for conversion into SSA. Return true when updating
1890 stmts is required. */
1893 maybe_optimize_var (tree var
, bitmap addresses_taken
, bitmap not_reg_needs
)
1895 bool update_vops
= false;
1897 /* Global Variables, result decls cannot be changed. */
1898 if (is_global_var (var
)
1899 || TREE_CODE (var
) == RESULT_DECL
1900 || bitmap_bit_p (addresses_taken
, DECL_UID (var
)))
1903 /* If the variable is not in the list of referenced vars then we
1904 do not need to touch it nor can we rename it. */
1905 if (!referenced_var_lookup (DECL_UID (var
)))
1908 if (TREE_ADDRESSABLE (var
)
1909 /* Do not change TREE_ADDRESSABLE if we need to preserve var as
1910 a non-register. Otherwise we are confused and forget to
1911 add virtual operands for it. */
1912 && (!is_gimple_reg_type (TREE_TYPE (var
))
1913 || !bitmap_bit_p (not_reg_needs
, DECL_UID (var
))))
1915 TREE_ADDRESSABLE (var
) = 0;
1916 if (is_gimple_reg (var
))
1917 mark_sym_for_renaming (var
);
1921 fprintf (dump_file
, "No longer having address taken: ");
1922 print_generic_expr (dump_file
, var
, 0);
1923 fprintf (dump_file
, "\n");
1927 if (!DECL_GIMPLE_REG_P (var
)
1928 && !bitmap_bit_p (not_reg_needs
, DECL_UID (var
))
1929 && (TREE_CODE (TREE_TYPE (var
)) == COMPLEX_TYPE
1930 || TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
)
1931 && !TREE_THIS_VOLATILE (var
)
1932 && (TREE_CODE (var
) != VAR_DECL
|| !DECL_HARD_REGISTER (var
)))
1934 DECL_GIMPLE_REG_P (var
) = 1;
1935 mark_sym_for_renaming (var
);
1939 fprintf (dump_file
, "Now a gimple register: ");
1940 print_generic_expr (dump_file
, var
, 0);
1941 fprintf (dump_file
, "\n");
1948 /* Compute TREE_ADDRESSABLE and DECL_GIMPLE_REG_P for local variables. */
1951 execute_update_addresses_taken (void)
1953 gimple_stmt_iterator gsi
;
1955 bitmap addresses_taken
= BITMAP_ALLOC (NULL
);
1956 bitmap not_reg_needs
= BITMAP_ALLOC (NULL
);
1957 bool update_vops
= false;
1961 timevar_push (TV_ADDRESS_TAKEN
);
1963 /* Collect into ADDRESSES_TAKEN all variables whose address is taken within
1964 the function body. */
1967 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1969 gimple stmt
= gsi_stmt (gsi
);
1970 enum gimple_code code
= gimple_code (stmt
);
1973 /* Note all addresses taken by the stmt. */
1974 gimple_ior_addresses_taken (addresses_taken
, stmt
);
1976 /* If we have a call or an assignment, see if the lhs contains
1977 a local decl that requires not to be a gimple register. */
1978 if (code
== GIMPLE_ASSIGN
|| code
== GIMPLE_CALL
)
1980 tree lhs
= gimple_get_lhs (stmt
);
1982 /* A plain decl does not need it set. */
1983 if (lhs
&& !DECL_P (lhs
))
1985 tree orig_lhs
= lhs
;
1987 while (handled_component_p (lhs
))
1988 lhs
= TREE_OPERAND (lhs
, 0);
1991 bitmap_set_bit (not_reg_needs
, DECL_UID (lhs
));
1992 else if (TREE_CODE (lhs
) == MEM_REF
1993 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == ADDR_EXPR
)
1995 decl
= TREE_OPERAND (TREE_OPERAND (lhs
, 0), 0);
1997 && (!integer_zerop (TREE_OPERAND (lhs
, 1))
1998 || (DECL_SIZE (decl
)
1999 != TYPE_SIZE (TREE_TYPE (orig_lhs
)))
2000 || (TREE_THIS_VOLATILE (lhs
)
2001 != TREE_THIS_VOLATILE (decl
))))
2002 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
2007 if (gimple_assign_single_p (stmt
))
2009 tree rhs
= gimple_assign_rhs1 (stmt
);
2010 if ((decl
= non_rewritable_mem_ref_base (rhs
)))
2011 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
2014 else if (code
== GIMPLE_CALL
)
2016 for (i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
2018 tree arg
= gimple_call_arg (stmt
, i
);
2019 if ((decl
= non_rewritable_mem_ref_base (arg
)))
2020 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
2024 else if (code
== GIMPLE_ASM
)
2026 for (i
= 0; i
< gimple_asm_noutputs (stmt
); ++i
)
2028 tree link
= gimple_asm_output_op (stmt
, i
);
2029 tree lhs
= TREE_VALUE (link
);
2031 /* A plain decl does not need it set. */
2034 tree orig_lhs
= lhs
;
2036 while (handled_component_p (lhs
))
2037 lhs
= TREE_OPERAND (lhs
, 0);
2040 bitmap_set_bit (not_reg_needs
, DECL_UID (lhs
));
2041 else if (TREE_CODE (lhs
) == MEM_REF
2042 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == ADDR_EXPR
)
2044 decl
= TREE_OPERAND (TREE_OPERAND (lhs
, 0), 0);
2046 && (!integer_zerop (TREE_OPERAND (lhs
, 1))
2047 || (TYPE_MAIN_VARIANT (TREE_TYPE (decl
))
2048 != TYPE_MAIN_VARIANT (TREE_TYPE (orig_lhs
)))
2049 || (TREE_THIS_VOLATILE (lhs
)
2050 != TREE_THIS_VOLATILE (decl
))))
2051 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
2055 for (i
= 0; i
< gimple_asm_ninputs (stmt
); ++i
)
2057 tree link
= gimple_asm_input_op (stmt
, i
);
2058 if ((decl
= non_rewritable_mem_ref_base (TREE_VALUE (link
))))
2059 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
2064 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
2067 gimple phi
= gsi_stmt (gsi
);
2069 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
2071 tree op
= PHI_ARG_DEF (phi
, i
), var
;
2072 if (TREE_CODE (op
) == ADDR_EXPR
2073 && (var
= get_base_address (TREE_OPERAND (op
, 0))) != NULL
2075 bitmap_set_bit (addresses_taken
, DECL_UID (var
));
2080 /* We cannot iterate over all referenced vars because that can contain
2081 unused vars from BLOCK trees, which causes code generation differences
2083 for (var
= DECL_ARGUMENTS (cfun
->decl
); var
; var
= DECL_CHAIN (var
))
2084 update_vops
|= maybe_optimize_var (var
, addresses_taken
, not_reg_needs
);
2086 FOR_EACH_VEC_ELT (tree
, cfun
->local_decls
, i
, var
)
2087 update_vops
|= maybe_optimize_var (var
, addresses_taken
, not_reg_needs
);
2089 /* Operand caches need to be recomputed for operands referencing the updated
2094 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
2096 gimple stmt
= gsi_stmt (gsi
);
2098 /* Re-write TARGET_MEM_REFs of symbols we want to
2099 rewrite into SSA form. */
2100 if (gimple_assign_single_p (stmt
))
2102 tree lhs
= gimple_assign_lhs (stmt
);
2103 tree rhs
, *rhsp
= gimple_assign_rhs1_ptr (stmt
);
2106 /* We shouldn't have any fancy wrapping of
2107 component-refs on the LHS, but look through
2108 VIEW_CONVERT_EXPRs as that is easy. */
2109 while (TREE_CODE (lhs
) == VIEW_CONVERT_EXPR
)
2110 lhs
= TREE_OPERAND (lhs
, 0);
2111 if (TREE_CODE (lhs
) == MEM_REF
2112 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == ADDR_EXPR
2113 && integer_zerop (TREE_OPERAND (lhs
, 1))
2114 && (sym
= TREE_OPERAND (TREE_OPERAND (lhs
, 0), 0))
2116 && !TREE_ADDRESSABLE (sym
)
2117 && symbol_marked_for_renaming (sym
))
2120 lhs
= gimple_assign_lhs (stmt
);
2122 /* Rewrite the RHS and make sure the resulting assignment
2123 is validly typed. */
2124 maybe_rewrite_mem_ref_base (rhsp
);
2125 rhs
= gimple_assign_rhs1 (stmt
);
2126 if (gimple_assign_lhs (stmt
) != lhs
2127 && !useless_type_conversion_p (TREE_TYPE (lhs
),
2129 rhs
= fold_build1 (VIEW_CONVERT_EXPR
,
2130 TREE_TYPE (lhs
), rhs
);
2132 if (gimple_assign_lhs (stmt
) != lhs
)
2133 gimple_assign_set_lhs (stmt
, lhs
);
2135 if (gimple_assign_rhs1 (stmt
) != rhs
)
2137 gimple_stmt_iterator gsi
= gsi_for_stmt (stmt
);
2138 gimple_assign_set_rhs_from_tree (&gsi
, rhs
);
2142 else if (gimple_code (stmt
) == GIMPLE_CALL
)
2145 for (i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
2147 tree
*argp
= gimple_call_arg_ptr (stmt
, i
);
2148 maybe_rewrite_mem_ref_base (argp
);
2152 else if (gimple_code (stmt
) == GIMPLE_ASM
)
2155 for (i
= 0; i
< gimple_asm_noutputs (stmt
); ++i
)
2157 tree link
= gimple_asm_output_op (stmt
, i
);
2158 maybe_rewrite_mem_ref_base (&TREE_VALUE (link
));
2160 for (i
= 0; i
< gimple_asm_ninputs (stmt
); ++i
)
2162 tree link
= gimple_asm_input_op (stmt
, i
);
2163 maybe_rewrite_mem_ref_base (&TREE_VALUE (link
));
2167 if (gimple_references_memory_p (stmt
)
2168 || is_gimple_debug (stmt
))
2172 /* Update SSA form here, we are called as non-pass as well. */
2173 update_ssa (TODO_update_ssa
);
2176 BITMAP_FREE (not_reg_needs
);
2177 BITMAP_FREE (addresses_taken
);
2178 timevar_pop (TV_ADDRESS_TAKEN
);
2181 struct gimple_opt_pass pass_update_address_taken
=
2185 "addressables", /* name */
2190 0, /* static_pass_number */
2191 TV_ADDRESS_TAKEN
, /* tv_id */
2192 PROP_ssa
, /* properties_required */
2193 0, /* properties_provided */
2194 0, /* properties_destroyed */
2195 0, /* todo_flags_start */
2196 TODO_update_address_taken
2197 | TODO_dump_func
/* todo_flags_finish */