1 /* Miscellaneous SSA utility functions.
2 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011
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"
33 #include "gimple-pretty-print.h"
35 #include "pointer-set.h"
36 #include "tree-flow.h"
38 #include "tree-inline.h"
40 #include "tree-pass.h"
41 #include "diagnostic-core.h"
44 /* Pointer map of variable mappings, keyed by edge. */
45 static struct pointer_map_t
*edge_var_maps
;
48 /* Add a mapping with PHI RESULT and PHI DEF associated with edge E. */
51 redirect_edge_var_map_add (edge e
, tree result
, tree def
, source_location locus
)
54 edge_var_map_vector old_head
, head
;
55 edge_var_map new_node
;
57 if (edge_var_maps
== NULL
)
58 edge_var_maps
= pointer_map_create ();
60 slot
= pointer_map_insert (edge_var_maps
, e
);
61 old_head
= head
= (edge_var_map_vector
) *slot
;
64 head
= VEC_alloc (edge_var_map
, heap
, 5);
68 new_node
.result
= result
;
69 new_node
.locus
= locus
;
71 VEC_safe_push (edge_var_map
, heap
, head
, &new_node
);
74 /* The push did some reallocation. Update the pointer map. */
80 /* Clear the var mappings in edge E. */
83 redirect_edge_var_map_clear (edge e
)
86 edge_var_map_vector head
;
91 slot
= pointer_map_contains (edge_var_maps
, e
);
95 head
= (edge_var_map_vector
) *slot
;
96 VEC_free (edge_var_map
, heap
, head
);
102 /* Duplicate the redirected var mappings in OLDE in NEWE.
104 Since we can't remove a mapping, let's just duplicate it. This assumes a
105 pointer_map can have multiple edges mapping to the same var_map (many to
106 one mapping), since we don't remove the previous mappings. */
109 redirect_edge_var_map_dup (edge newe
, edge olde
)
111 void **new_slot
, **old_slot
;
112 edge_var_map_vector head
;
117 new_slot
= pointer_map_insert (edge_var_maps
, newe
);
118 old_slot
= pointer_map_contains (edge_var_maps
, olde
);
121 head
= (edge_var_map_vector
) *old_slot
;
124 *new_slot
= VEC_copy (edge_var_map
, heap
, head
);
126 *new_slot
= VEC_alloc (edge_var_map
, heap
, 5);
130 /* Return the variable mappings for a given edge. If there is none, return
134 redirect_edge_var_map_vector (edge e
)
138 /* Hey, what kind of idiot would... you'd be surprised. */
142 slot
= pointer_map_contains (edge_var_maps
, e
);
146 return (edge_var_map_vector
) *slot
;
149 /* Used by redirect_edge_var_map_destroy to free all memory. */
152 free_var_map_entry (const void *key ATTRIBUTE_UNUSED
,
154 void *data ATTRIBUTE_UNUSED
)
156 edge_var_map_vector head
= (edge_var_map_vector
) *value
;
157 VEC_free (edge_var_map
, heap
, head
);
161 /* Clear the edge variable mappings. */
164 redirect_edge_var_map_destroy (void)
168 pointer_map_traverse (edge_var_maps
, free_var_map_entry
, NULL
);
169 pointer_map_destroy (edge_var_maps
);
170 edge_var_maps
= NULL
;
175 /* Remove the corresponding arguments from the PHI nodes in E's
176 destination block and redirect it to DEST. Return redirected edge.
177 The list of removed arguments is stored in a vector accessed
178 through edge_var_maps. */
181 ssa_redirect_edge (edge e
, basic_block dest
)
183 gimple_stmt_iterator gsi
;
186 redirect_edge_var_map_clear (e
);
188 /* Remove the appropriate PHI arguments in E's destination block. */
189 for (gsi
= gsi_start_phis (e
->dest
); !gsi_end_p (gsi
); gsi_next (&gsi
))
192 source_location locus
;
194 phi
= gsi_stmt (gsi
);
195 def
= gimple_phi_arg_def (phi
, e
->dest_idx
);
196 locus
= gimple_phi_arg_location (phi
, e
->dest_idx
);
198 if (def
== NULL_TREE
)
201 redirect_edge_var_map_add (e
, gimple_phi_result (phi
), def
, locus
);
204 e
= redirect_edge_succ_nodup (e
, dest
);
210 /* Add PHI arguments queued in PENDING_STMT list on edge E to edge
214 flush_pending_stmts (edge e
)
217 edge_var_map_vector v
;
220 gimple_stmt_iterator gsi
;
222 v
= redirect_edge_var_map_vector (e
);
226 for (gsi
= gsi_start_phis (e
->dest
), i
= 0;
227 !gsi_end_p (gsi
) && VEC_iterate (edge_var_map
, v
, i
, vm
);
228 gsi_next (&gsi
), i
++)
232 phi
= gsi_stmt (gsi
);
233 def
= redirect_edge_var_map_def (vm
);
234 add_phi_arg (phi
, def
, e
, redirect_edge_var_map_location (vm
));
237 redirect_edge_var_map_clear (e
);
240 /* Given a tree for an expression for which we might want to emit
241 locations or values in debug information (generally a variable, but
242 we might deal with other kinds of trees in the future), return the
243 tree that should be used as the variable of a DEBUG_BIND STMT or
244 VAR_LOCATION INSN or NOTE. Return NULL if VAR is not to be tracked. */
247 target_for_debug_bind (tree var
)
249 if (!MAY_HAVE_DEBUG_STMTS
)
252 if (TREE_CODE (var
) == SSA_NAME
)
254 var
= SSA_NAME_VAR (var
);
255 if (var
== NULL_TREE
)
259 if ((TREE_CODE (var
) != VAR_DECL
260 || VAR_DECL_IS_VIRTUAL_OPERAND (var
))
261 && TREE_CODE (var
) != PARM_DECL
)
264 if (DECL_HAS_VALUE_EXPR_P (var
))
265 return target_for_debug_bind (DECL_VALUE_EXPR (var
));
267 if (DECL_IGNORED_P (var
))
270 /* var-tracking only tracks registers. */
271 if (!is_gimple_reg_type (TREE_TYPE (var
)))
277 /* Called via walk_tree, look for SSA_NAMEs that have already been
281 find_released_ssa_name (tree
*tp
, int *walk_subtrees
, void *data_
)
283 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data_
;
285 if (wi
&& wi
->is_lhs
)
288 if (TREE_CODE (*tp
) == SSA_NAME
)
290 if (SSA_NAME_IN_FREE_LIST (*tp
))
295 else if (IS_TYPE_OR_DECL_P (*tp
))
301 /* Insert a DEBUG BIND stmt before the DEF of VAR if VAR is referenced
302 by other DEBUG stmts, and replace uses of the DEF with the
303 newly-created debug temp. */
306 insert_debug_temp_for_var_def (gimple_stmt_iterator
*gsi
, tree var
)
308 imm_use_iterator imm_iter
;
311 gimple def_stmt
= NULL
;
315 if (!MAY_HAVE_DEBUG_STMTS
)
318 /* If this name has already been registered for replacement, do nothing
319 as anything that uses this name isn't in SSA form. */
320 if (name_registered_for_update_p (var
))
323 /* Check whether there are debug stmts that reference this variable and,
324 if there are, decide whether we should use a debug temp. */
325 FOR_EACH_IMM_USE_FAST (use_p
, imm_iter
, var
)
327 stmt
= USE_STMT (use_p
);
329 if (!gimple_debug_bind_p (stmt
))
335 if (gimple_debug_bind_get_value (stmt
) != var
)
337 /* Count this as an additional use, so as to make sure we
338 use a temp unless VAR's definition has a SINGLE_RHS that
349 def_stmt
= gsi_stmt (*gsi
);
351 def_stmt
= SSA_NAME_DEF_STMT (var
);
353 /* If we didn't get an insertion point, and the stmt has already
354 been removed, we won't be able to insert the debug bind stmt, so
355 we'll have to drop debug information. */
356 if (gimple_code (def_stmt
) == GIMPLE_PHI
)
358 value
= degenerate_phi_result (def_stmt
);
359 if (value
&& walk_tree (&value
, find_released_ssa_name
, NULL
, NULL
))
361 /* error_mark_node is what fixup_noreturn_call changes PHI arguments
363 else if (value
== error_mark_node
)
366 else if (is_gimple_assign (def_stmt
))
368 bool no_value
= false;
370 if (!dom_info_available_p (CDI_DOMINATORS
))
372 struct walk_stmt_info wi
;
374 memset (&wi
, 0, sizeof (wi
));
376 /* When removing blocks without following reverse dominance
377 order, we may sometimes encounter SSA_NAMEs that have
378 already been released, referenced in other SSA_DEFs that
379 we're about to release. Consider:
388 If we deleted BB X first, propagating the value of w_2
389 won't do us any good. It's too late to recover their
390 original definition of v_1: when it was deleted, it was
391 only referenced in other DEFs, it couldn't possibly know
392 it should have been retained, and propagating every
393 single DEF just in case it might have to be propagated
394 into a DEBUG STMT would probably be too wasteful.
396 When dominator information is not readily available, we
397 check for and accept some loss of debug information. But
398 if it is available, there's no excuse for us to remove
399 blocks in the wrong order, so we don't even check for
400 dead SSA NAMEs. SSA verification shall catch any
402 if ((!gsi
&& !gimple_bb (def_stmt
))
403 || walk_gimple_op (def_stmt
, find_released_ssa_name
, &wi
))
408 value
= gimple_assign_rhs_to_tree (def_stmt
);
413 /* If there's a single use of VAR, and VAR is the entire debug
414 expression (usecount would have been incremented again
415 otherwise), and the definition involves only constants and
416 SSA names, then we can propagate VALUE into this single use,
419 We can also avoid using a temp if VALUE can be shared and
420 propagated into all uses, without generating expressions that
421 wouldn't be valid gimple RHSs.
423 Other cases that would require unsharing or non-gimple RHSs
424 are deferred to a debug temp, although we could avoid temps
425 at the expense of duplication of expressions. */
427 if (CONSTANT_CLASS_P (value
)
428 || gimple_code (def_stmt
) == GIMPLE_PHI
430 && (!gimple_assign_single_p (def_stmt
)
431 || is_gimple_min_invariant (value
)))
432 || is_gimple_reg (value
))
433 value
= unshare_expr (value
);
437 tree vexpr
= make_node (DEBUG_EXPR_DECL
);
439 def_temp
= gimple_build_debug_bind (vexpr
,
440 unshare_expr (value
),
443 DECL_ARTIFICIAL (vexpr
) = 1;
444 TREE_TYPE (vexpr
) = TREE_TYPE (value
);
446 DECL_MODE (vexpr
) = DECL_MODE (value
);
448 DECL_MODE (vexpr
) = TYPE_MODE (TREE_TYPE (value
));
451 gsi_insert_before (gsi
, def_temp
, GSI_SAME_STMT
);
454 gimple_stmt_iterator ngsi
= gsi_for_stmt (def_stmt
);
455 gsi_insert_before (&ngsi
, def_temp
, GSI_SAME_STMT
);
462 FOR_EACH_IMM_USE_STMT (stmt
, imm_iter
, var
)
464 if (!gimple_debug_bind_p (stmt
))
469 FOR_EACH_IMM_USE_ON_STMT (use_p
, imm_iter
)
470 /* unshare_expr is not needed here. vexpr is either a
471 SINGLE_RHS, that can be safely shared, some other RHS
472 that was unshared when we found it had a single debug
473 use, or a DEBUG_EXPR_DECL, that can be safely
475 SET_USE (use_p
, value
);
476 /* If we didn't replace uses with a debug decl fold the
477 resulting expression. Otherwise we end up with invalid IL. */
478 if (TREE_CODE (value
) != DEBUG_EXPR_DECL
)
480 gimple_stmt_iterator gsi
= gsi_for_stmt (stmt
);
481 fold_stmt_inplace (&gsi
);
485 gimple_debug_bind_reset_value (stmt
);
492 /* Insert a DEBUG BIND stmt before STMT for each DEF referenced by
493 other DEBUG stmts, and replace uses of the DEF with the
494 newly-created debug temp. */
497 insert_debug_temps_for_defs (gimple_stmt_iterator
*gsi
)
503 if (!MAY_HAVE_DEBUG_STMTS
)
506 stmt
= gsi_stmt (*gsi
);
508 FOR_EACH_PHI_OR_STMT_DEF (def_p
, stmt
, op_iter
, SSA_OP_DEF
)
510 tree var
= DEF_FROM_PTR (def_p
);
512 if (TREE_CODE (var
) != SSA_NAME
)
515 insert_debug_temp_for_var_def (gsi
, var
);
519 /* Reset all debug stmts that use SSA_NAME(s) defined in STMT. */
522 reset_debug_uses (gimple stmt
)
526 imm_use_iterator imm_iter
;
529 if (!MAY_HAVE_DEBUG_STMTS
)
532 FOR_EACH_PHI_OR_STMT_DEF (def_p
, stmt
, op_iter
, SSA_OP_DEF
)
534 tree var
= DEF_FROM_PTR (def_p
);
536 if (TREE_CODE (var
) != SSA_NAME
)
539 FOR_EACH_IMM_USE_STMT (use_stmt
, imm_iter
, var
)
541 if (!gimple_debug_bind_p (use_stmt
))
544 gimple_debug_bind_reset_value (use_stmt
);
545 update_stmt (use_stmt
);
550 /* Delete SSA DEFs for SSA versions in the TOREMOVE bitmap, removing
551 dominated stmts before their dominators, so that release_ssa_defs
552 stands a chance of propagating DEFs into debug bind stmts. */
555 release_defs_bitset (bitmap toremove
)
560 /* Performing a topological sort is probably overkill, this will
561 most likely run in slightly superlinear time, rather than the
562 pathological quadratic worst case. */
563 while (!bitmap_empty_p (toremove
))
564 EXECUTE_IF_SET_IN_BITMAP (toremove
, 0, j
, bi
)
566 bool remove_now
= true;
567 tree var
= ssa_name (j
);
569 imm_use_iterator uit
;
571 FOR_EACH_IMM_USE_STMT (stmt
, uit
, var
)
576 /* We can't propagate PHI nodes into debug stmts. */
577 if (gimple_code (stmt
) == GIMPLE_PHI
578 || is_gimple_debug (stmt
))
581 /* If we find another definition to remove that uses
582 the one we're looking at, defer the removal of this
583 one, so that it can be propagated into debug stmts
584 after the other is. */
585 FOR_EACH_SSA_DEF_OPERAND (def_p
, stmt
, dit
, SSA_OP_DEF
)
587 tree odef
= DEF_FROM_PTR (def_p
);
589 if (bitmap_bit_p (toremove
, SSA_NAME_VERSION (odef
)))
597 BREAK_FROM_IMM_USE_STMT (uit
);
602 gimple def
= SSA_NAME_DEF_STMT (var
);
603 gimple_stmt_iterator gsi
= gsi_for_stmt (def
);
605 if (gimple_code (def
) == GIMPLE_PHI
)
606 remove_phi_node (&gsi
, true);
609 gsi_remove (&gsi
, true);
613 bitmap_clear_bit (toremove
, j
);
618 /* Return true if SSA_NAME is malformed and mark it visited.
620 IS_VIRTUAL is true if this SSA_NAME was found inside a virtual
624 verify_ssa_name (tree ssa_name
, bool is_virtual
)
626 if (TREE_CODE (ssa_name
) != SSA_NAME
)
628 error ("expected an SSA_NAME object");
632 if (SSA_NAME_VAR (ssa_name
) != NULL_TREE
633 && TREE_TYPE (ssa_name
) != TREE_TYPE (ssa_name
))
635 error ("type mismatch between an SSA_NAME and its symbol");
639 if (SSA_NAME_IN_FREE_LIST (ssa_name
))
641 error ("found an SSA_NAME that had been released into the free pool");
645 if (is_virtual
&& !virtual_operand_p (ssa_name
))
647 error ("found a virtual definition for a GIMPLE register");
651 if (is_virtual
&& SSA_NAME_VAR (ssa_name
) != gimple_vop (cfun
))
653 error ("virtual SSA name for non-VOP decl");
657 if (!is_virtual
&& virtual_operand_p (ssa_name
))
659 error ("found a real definition for a non-register");
663 if (SSA_NAME_IS_DEFAULT_DEF (ssa_name
)
664 && !gimple_nop_p (SSA_NAME_DEF_STMT (ssa_name
)))
666 error ("found a default name with a non-empty defining statement");
674 /* Return true if the definition of SSA_NAME at block BB is malformed.
676 STMT is the statement where SSA_NAME is created.
678 DEFINITION_BLOCK is an array of basic blocks indexed by SSA_NAME
679 version numbers. If DEFINITION_BLOCK[SSA_NAME_VERSION] is set,
680 it means that the block in that array slot contains the
681 definition of SSA_NAME.
683 IS_VIRTUAL is true if SSA_NAME is created by a VDEF. */
686 verify_def (basic_block bb
, basic_block
*definition_block
, tree ssa_name
,
687 gimple stmt
, bool is_virtual
)
689 if (verify_ssa_name (ssa_name
, is_virtual
))
692 if (SSA_NAME_VAR (ssa_name
)
693 && TREE_CODE (SSA_NAME_VAR (ssa_name
)) == RESULT_DECL
694 && DECL_BY_REFERENCE (SSA_NAME_VAR (ssa_name
)))
696 error ("RESULT_DECL should be read only when DECL_BY_REFERENCE is set");
700 if (definition_block
[SSA_NAME_VERSION (ssa_name
)])
702 error ("SSA_NAME created in two different blocks %i and %i",
703 definition_block
[SSA_NAME_VERSION (ssa_name
)]->index
, bb
->index
);
707 definition_block
[SSA_NAME_VERSION (ssa_name
)] = bb
;
709 if (SSA_NAME_DEF_STMT (ssa_name
) != stmt
)
711 error ("SSA_NAME_DEF_STMT is wrong");
712 fprintf (stderr
, "Expected definition statement:\n");
713 print_gimple_stmt (stderr
, SSA_NAME_DEF_STMT (ssa_name
), 4, TDF_VOPS
);
714 fprintf (stderr
, "\nActual definition statement:\n");
715 print_gimple_stmt (stderr
, stmt
, 4, TDF_VOPS
);
722 fprintf (stderr
, "while verifying SSA_NAME ");
723 print_generic_expr (stderr
, ssa_name
, 0);
724 fprintf (stderr
, " in statement\n");
725 print_gimple_stmt (stderr
, stmt
, 4, TDF_VOPS
);
731 /* Return true if the use of SSA_NAME at statement STMT in block BB is
734 DEF_BB is the block where SSA_NAME was found to be created.
736 IDOM contains immediate dominator information for the flowgraph.
738 CHECK_ABNORMAL is true if the caller wants to check whether this use
739 is flowing through an abnormal edge (only used when checking PHI
742 If NAMES_DEFINED_IN_BB is not NULL, it contains a bitmap of ssa names
743 that are defined before STMT in basic block BB. */
746 verify_use (basic_block bb
, basic_block def_bb
, use_operand_p use_p
,
747 gimple stmt
, bool check_abnormal
, bitmap names_defined_in_bb
)
750 tree ssa_name
= USE_FROM_PTR (use_p
);
752 if (!TREE_VISITED (ssa_name
))
753 if (verify_imm_links (stderr
, ssa_name
))
756 TREE_VISITED (ssa_name
) = 1;
758 if (gimple_nop_p (SSA_NAME_DEF_STMT (ssa_name
))
759 && SSA_NAME_IS_DEFAULT_DEF (ssa_name
))
760 ; /* Default definitions have empty statements. Nothing to do. */
763 error ("missing definition");
766 else if (bb
!= def_bb
767 && !dominated_by_p (CDI_DOMINATORS
, bb
, def_bb
))
769 error ("definition in block %i does not dominate use in block %i",
770 def_bb
->index
, bb
->index
);
773 else if (bb
== def_bb
774 && names_defined_in_bb
!= NULL
775 && !bitmap_bit_p (names_defined_in_bb
, SSA_NAME_VERSION (ssa_name
)))
777 error ("definition in block %i follows the use", def_bb
->index
);
782 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ssa_name
))
784 error ("SSA_NAME_OCCURS_IN_ABNORMAL_PHI should be set");
788 /* Make sure the use is in an appropriate list by checking the previous
789 element to make sure it's the same. */
790 if (use_p
->prev
== NULL
)
792 error ("no immediate_use list");
798 if (use_p
->prev
->use
== NULL
)
799 listvar
= use_p
->prev
->loc
.ssa_name
;
801 listvar
= USE_FROM_PTR (use_p
->prev
);
802 if (listvar
!= ssa_name
)
804 error ("wrong immediate use list");
811 fprintf (stderr
, "for SSA_NAME: ");
812 print_generic_expr (stderr
, ssa_name
, TDF_VOPS
);
813 fprintf (stderr
, " in statement:\n");
814 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
);
821 /* Return true if any of the arguments for PHI node PHI at block BB is
824 DEFINITION_BLOCK is an array of basic blocks indexed by SSA_NAME
825 version numbers. If DEFINITION_BLOCK[SSA_NAME_VERSION] is set,
826 it means that the block in that array slot contains the
827 definition of SSA_NAME. */
830 verify_phi_args (gimple phi
, basic_block bb
, basic_block
*definition_block
)
834 size_t i
, phi_num_args
= gimple_phi_num_args (phi
);
836 if (EDGE_COUNT (bb
->preds
) != phi_num_args
)
838 error ("incoming edge count does not match number of PHI arguments");
843 for (i
= 0; i
< phi_num_args
; i
++)
845 use_operand_p op_p
= gimple_phi_arg_imm_use_ptr (phi
, i
);
846 tree op
= USE_FROM_PTR (op_p
);
848 e
= EDGE_PRED (bb
, i
);
852 error ("PHI argument is missing for edge %d->%d",
859 if (TREE_CODE (op
) != SSA_NAME
&& !is_gimple_min_invariant (op
))
861 error ("PHI argument is not SSA_NAME, or invariant");
865 if (TREE_CODE (op
) == SSA_NAME
)
867 err
= verify_ssa_name (op
, virtual_operand_p (gimple_phi_result (phi
)));
868 err
|= verify_use (e
->src
, definition_block
[SSA_NAME_VERSION (op
)],
869 op_p
, phi
, e
->flags
& EDGE_ABNORMAL
, NULL
);
872 if (TREE_CODE (op
) == ADDR_EXPR
)
874 tree base
= TREE_OPERAND (op
, 0);
875 while (handled_component_p (base
))
876 base
= TREE_OPERAND (base
, 0);
877 if ((TREE_CODE (base
) == VAR_DECL
878 || TREE_CODE (base
) == PARM_DECL
879 || TREE_CODE (base
) == RESULT_DECL
)
880 && !TREE_ADDRESSABLE (base
))
882 error ("address taken, but ADDRESSABLE bit not set");
889 error ("wrong edge %d->%d for PHI argument",
890 e
->src
->index
, e
->dest
->index
);
896 fprintf (stderr
, "PHI argument\n");
897 print_generic_stmt (stderr
, op
, TDF_VOPS
);
905 fprintf (stderr
, "for PHI node\n");
906 print_gimple_stmt (stderr
, phi
, 0, TDF_VOPS
|TDF_MEMSYMS
);
914 /* Verify common invariants in the SSA web.
915 TODO: verify the variable annotations. */
918 verify_ssa (bool check_modified_stmt
)
922 basic_block
*definition_block
= XCNEWVEC (basic_block
, num_ssa_names
);
925 enum dom_state orig_dom_state
= dom_info_state (CDI_DOMINATORS
);
926 bitmap names_defined_in_bb
= BITMAP_ALLOC (NULL
);
928 gcc_assert (!need_ssa_update_p (cfun
));
930 timevar_push (TV_TREE_SSA_VERIFY
);
932 /* Keep track of SSA names present in the IL. */
933 for (i
= 1; i
< num_ssa_names
; i
++)
935 tree name
= ssa_name (i
);
939 TREE_VISITED (name
) = 0;
941 verify_ssa_name (name
, virtual_operand_p (name
));
943 stmt
= SSA_NAME_DEF_STMT (name
);
944 if (!gimple_nop_p (stmt
))
946 basic_block bb
= gimple_bb (stmt
);
947 verify_def (bb
, definition_block
,
948 name
, stmt
, virtual_operand_p (name
));
954 calculate_dominance_info (CDI_DOMINATORS
);
956 /* Now verify all the uses and make sure they agree with the definitions
957 found in the previous pass. */
963 gimple_stmt_iterator gsi
;
965 /* Make sure that all edges have a clear 'aux' field. */
966 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
970 error ("AUX pointer initialized for edge %d->%d", e
->src
->index
,
976 /* Verify the arguments for every PHI node in the block. */
977 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
979 phi
= gsi_stmt (gsi
);
980 if (verify_phi_args (phi
, bb
, definition_block
))
983 bitmap_set_bit (names_defined_in_bb
,
984 SSA_NAME_VERSION (gimple_phi_result (phi
)));
987 /* Now verify all the uses and vuses in every statement of the block. */
988 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
990 gimple stmt
= gsi_stmt (gsi
);
993 if (check_modified_stmt
&& gimple_modified_p (stmt
))
995 error ("stmt (%p) marked modified after optimization pass: ",
997 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
);
1001 if (verify_ssa_operands (stmt
))
1003 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
);
1007 if (gimple_debug_bind_p (stmt
)
1008 && !gimple_debug_bind_has_value_p (stmt
))
1011 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_USE
|SSA_OP_VUSE
)
1013 op
= USE_FROM_PTR (use_p
);
1014 if (verify_use (bb
, definition_block
[SSA_NAME_VERSION (op
)],
1015 use_p
, stmt
, false, names_defined_in_bb
))
1019 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, iter
, SSA_OP_ALL_DEFS
)
1021 if (SSA_NAME_DEF_STMT (op
) != stmt
)
1023 error ("SSA_NAME_DEF_STMT is wrong");
1024 fprintf (stderr
, "Expected definition statement:\n");
1025 print_gimple_stmt (stderr
, stmt
, 4, TDF_VOPS
);
1026 fprintf (stderr
, "\nActual definition statement:\n");
1027 print_gimple_stmt (stderr
, SSA_NAME_DEF_STMT (op
),
1031 bitmap_set_bit (names_defined_in_bb
, SSA_NAME_VERSION (op
));
1035 bitmap_clear (names_defined_in_bb
);
1038 free (definition_block
);
1040 /* Restore the dominance information to its prior known state, so
1041 that we do not perturb the compiler's subsequent behavior. */
1042 if (orig_dom_state
== DOM_NONE
)
1043 free_dominance_info (CDI_DOMINATORS
);
1045 set_dom_info_availability (CDI_DOMINATORS
, orig_dom_state
);
1047 BITMAP_FREE (names_defined_in_bb
);
1048 timevar_pop (TV_TREE_SSA_VERIFY
);
1052 internal_error ("verify_ssa failed");
1055 /* Return true if the uid in both int tree maps are equal. */
1058 int_tree_map_eq (const void *va
, const void *vb
)
1060 const struct int_tree_map
*a
= (const struct int_tree_map
*) va
;
1061 const struct int_tree_map
*b
= (const struct int_tree_map
*) vb
;
1062 return (a
->uid
== b
->uid
);
1065 /* Hash a UID in a int_tree_map. */
1068 int_tree_map_hash (const void *item
)
1070 return ((const struct int_tree_map
*)item
)->uid
;
1073 /* Return true if the DECL_UID in both trees are equal. */
1076 uid_decl_map_eq (const void *va
, const void *vb
)
1078 const_tree a
= (const_tree
) va
;
1079 const_tree b
= (const_tree
) vb
;
1080 return (a
->decl_minimal
.uid
== b
->decl_minimal
.uid
);
1083 /* Hash a tree in a uid_decl_map. */
1086 uid_decl_map_hash (const void *item
)
1088 return ((const_tree
)item
)->decl_minimal
.uid
;
1091 /* Return true if the DECL_UID in both trees are equal. */
1094 uid_ssaname_map_eq (const void *va
, const void *vb
)
1096 const_tree a
= (const_tree
) va
;
1097 const_tree b
= (const_tree
) vb
;
1098 return (a
->ssa_name
.var
->decl_minimal
.uid
== b
->ssa_name
.var
->decl_minimal
.uid
);
1101 /* Hash a tree in a uid_decl_map. */
1104 uid_ssaname_map_hash (const void *item
)
1106 return ((const_tree
)item
)->ssa_name
.var
->decl_minimal
.uid
;
1110 /* Initialize global DFA and SSA structures. */
1113 init_tree_ssa (struct function
*fn
)
1115 fn
->gimple_df
= ggc_alloc_cleared_gimple_df ();
1116 fn
->gimple_df
->default_defs
= htab_create_ggc (20, uid_ssaname_map_hash
,
1117 uid_ssaname_map_eq
, NULL
);
1118 pt_solution_reset (&fn
->gimple_df
->escaped
);
1119 init_ssanames (fn
, 0);
1122 /* Do the actions required to initialize internal data structures used
1123 in tree-ssa optimization passes. */
1126 execute_init_datastructures (void)
1128 /* Allocate hash tables, arrays and other structures. */
1129 init_tree_ssa (cfun
);
1133 struct gimple_opt_pass pass_init_datastructures
=
1137 "*init_datastructures", /* name */
1139 execute_init_datastructures
, /* execute */
1142 0, /* static_pass_number */
1143 TV_NONE
, /* tv_id */
1144 PROP_cfg
, /* properties_required */
1145 0, /* properties_provided */
1146 0, /* properties_destroyed */
1147 0, /* todo_flags_start */
1148 0 /* todo_flags_finish */
1152 /* Deallocate memory associated with SSA data structures for FNDECL. */
1155 delete_tree_ssa (void)
1159 /* We no longer maintain the SSA operand cache at this point. */
1160 if (ssa_operands_active (cfun
))
1161 fini_ssa_operands ();
1163 htab_delete (cfun
->gimple_df
->default_defs
);
1164 cfun
->gimple_df
->default_defs
= NULL
;
1165 pt_solution_reset (&cfun
->gimple_df
->escaped
);
1166 if (cfun
->gimple_df
->decls_to_pointers
!= NULL
)
1167 pointer_map_destroy (cfun
->gimple_df
->decls_to_pointers
);
1168 cfun
->gimple_df
->decls_to_pointers
= NULL
;
1169 cfun
->gimple_df
->modified_noreturn_calls
= NULL
;
1170 cfun
->gimple_df
= NULL
;
1172 /* We no longer need the edge variable maps. */
1173 redirect_edge_var_map_destroy ();
1176 /* Return true if the conversion from INNER_TYPE to OUTER_TYPE is a
1177 useless type conversion, otherwise return false.
1179 This function implicitly defines the middle-end type system. With
1180 the notion of 'a < b' meaning that useless_type_conversion_p (a, b)
1181 holds and 'a > b' meaning that useless_type_conversion_p (b, a) holds,
1182 the following invariants shall be fulfilled:
1184 1) useless_type_conversion_p is transitive.
1185 If a < b and b < c then a < c.
1187 2) useless_type_conversion_p is not symmetric.
1188 From a < b does not follow a > b.
1190 3) Types define the available set of operations applicable to values.
1191 A type conversion is useless if the operations for the target type
1192 is a subset of the operations for the source type. For example
1193 casts to void* are useless, casts from void* are not (void* can't
1194 be dereferenced or offsetted, but copied, hence its set of operations
1195 is a strict subset of that of all other data pointer types). Casts
1196 to const T* are useless (can't be written to), casts from const T*
1200 useless_type_conversion_p (tree outer_type
, tree inner_type
)
1202 /* Do the following before stripping toplevel qualifiers. */
1203 if (POINTER_TYPE_P (inner_type
)
1204 && POINTER_TYPE_P (outer_type
))
1206 /* Do not lose casts between pointers to different address spaces. */
1207 if (TYPE_ADDR_SPACE (TREE_TYPE (outer_type
))
1208 != TYPE_ADDR_SPACE (TREE_TYPE (inner_type
)))
1212 /* From now on qualifiers on value types do not matter. */
1213 inner_type
= TYPE_MAIN_VARIANT (inner_type
);
1214 outer_type
= TYPE_MAIN_VARIANT (outer_type
);
1216 if (inner_type
== outer_type
)
1219 /* If we know the canonical types, compare them. */
1220 if (TYPE_CANONICAL (inner_type
)
1221 && TYPE_CANONICAL (inner_type
) == TYPE_CANONICAL (outer_type
))
1224 /* Changes in machine mode are never useless conversions unless we
1225 deal with aggregate types in which case we defer to later checks. */
1226 if (TYPE_MODE (inner_type
) != TYPE_MODE (outer_type
)
1227 && !AGGREGATE_TYPE_P (inner_type
))
1230 /* If both the inner and outer types are integral types, then the
1231 conversion is not necessary if they have the same mode and
1232 signedness and precision, and both or neither are boolean. */
1233 if (INTEGRAL_TYPE_P (inner_type
)
1234 && INTEGRAL_TYPE_P (outer_type
))
1236 /* Preserve changes in signedness or precision. */
1237 if (TYPE_UNSIGNED (inner_type
) != TYPE_UNSIGNED (outer_type
)
1238 || TYPE_PRECISION (inner_type
) != TYPE_PRECISION (outer_type
))
1241 /* Preserve conversions to/from BOOLEAN_TYPE if types are not
1242 of precision one. */
1243 if (((TREE_CODE (inner_type
) == BOOLEAN_TYPE
)
1244 != (TREE_CODE (outer_type
) == BOOLEAN_TYPE
))
1245 && TYPE_PRECISION (outer_type
) != 1)
1248 /* We don't need to preserve changes in the types minimum or
1249 maximum value in general as these do not generate code
1250 unless the types precisions are different. */
1254 /* Scalar floating point types with the same mode are compatible. */
1255 else if (SCALAR_FLOAT_TYPE_P (inner_type
)
1256 && SCALAR_FLOAT_TYPE_P (outer_type
))
1259 /* Fixed point types with the same mode are compatible. */
1260 else if (FIXED_POINT_TYPE_P (inner_type
)
1261 && FIXED_POINT_TYPE_P (outer_type
))
1264 /* We need to take special care recursing to pointed-to types. */
1265 else if (POINTER_TYPE_P (inner_type
)
1266 && POINTER_TYPE_P (outer_type
))
1268 /* Do not lose casts to function pointer types. */
1269 if ((TREE_CODE (TREE_TYPE (outer_type
)) == FUNCTION_TYPE
1270 || TREE_CODE (TREE_TYPE (outer_type
)) == METHOD_TYPE
)
1271 && !(TREE_CODE (TREE_TYPE (inner_type
)) == FUNCTION_TYPE
1272 || TREE_CODE (TREE_TYPE (inner_type
)) == METHOD_TYPE
))
1275 /* We do not care for const qualification of the pointed-to types
1276 as const qualification has no semantic value to the middle-end. */
1278 /* Otherwise pointers/references are equivalent. */
1282 /* Recurse for complex types. */
1283 else if (TREE_CODE (inner_type
) == COMPLEX_TYPE
1284 && TREE_CODE (outer_type
) == COMPLEX_TYPE
)
1285 return useless_type_conversion_p (TREE_TYPE (outer_type
),
1286 TREE_TYPE (inner_type
));
1288 /* Recurse for vector types with the same number of subparts. */
1289 else if (TREE_CODE (inner_type
) == VECTOR_TYPE
1290 && TREE_CODE (outer_type
) == VECTOR_TYPE
1291 && TYPE_PRECISION (inner_type
) == TYPE_PRECISION (outer_type
))
1292 return useless_type_conversion_p (TREE_TYPE (outer_type
),
1293 TREE_TYPE (inner_type
));
1295 else if (TREE_CODE (inner_type
) == ARRAY_TYPE
1296 && TREE_CODE (outer_type
) == ARRAY_TYPE
)
1298 /* Preserve string attributes. */
1299 if (TYPE_STRING_FLAG (inner_type
) != TYPE_STRING_FLAG (outer_type
))
1302 /* Conversions from array types with unknown extent to
1303 array types with known extent are not useless. */
1304 if (!TYPE_DOMAIN (inner_type
)
1305 && TYPE_DOMAIN (outer_type
))
1308 /* Nor are conversions from array types with non-constant size to
1309 array types with constant size or to different size. */
1310 if (TYPE_SIZE (outer_type
)
1311 && TREE_CODE (TYPE_SIZE (outer_type
)) == INTEGER_CST
1312 && (!TYPE_SIZE (inner_type
)
1313 || TREE_CODE (TYPE_SIZE (inner_type
)) != INTEGER_CST
1314 || !tree_int_cst_equal (TYPE_SIZE (outer_type
),
1315 TYPE_SIZE (inner_type
))))
1318 /* Check conversions between arrays with partially known extents.
1319 If the array min/max values are constant they have to match.
1320 Otherwise allow conversions to unknown and variable extents.
1321 In particular this declares conversions that may change the
1322 mode to BLKmode as useless. */
1323 if (TYPE_DOMAIN (inner_type
)
1324 && TYPE_DOMAIN (outer_type
)
1325 && TYPE_DOMAIN (inner_type
) != TYPE_DOMAIN (outer_type
))
1327 tree inner_min
= TYPE_MIN_VALUE (TYPE_DOMAIN (inner_type
));
1328 tree outer_min
= TYPE_MIN_VALUE (TYPE_DOMAIN (outer_type
));
1329 tree inner_max
= TYPE_MAX_VALUE (TYPE_DOMAIN (inner_type
));
1330 tree outer_max
= TYPE_MAX_VALUE (TYPE_DOMAIN (outer_type
));
1332 /* After gimplification a variable min/max value carries no
1333 additional information compared to a NULL value. All that
1334 matters has been lowered to be part of the IL. */
1335 if (inner_min
&& TREE_CODE (inner_min
) != INTEGER_CST
)
1336 inner_min
= NULL_TREE
;
1337 if (outer_min
&& TREE_CODE (outer_min
) != INTEGER_CST
)
1338 outer_min
= NULL_TREE
;
1339 if (inner_max
&& TREE_CODE (inner_max
) != INTEGER_CST
)
1340 inner_max
= NULL_TREE
;
1341 if (outer_max
&& TREE_CODE (outer_max
) != INTEGER_CST
)
1342 outer_max
= NULL_TREE
;
1344 /* Conversions NULL / variable <- cst are useless, but not
1345 the other way around. */
1348 || !tree_int_cst_equal (inner_min
, outer_min
)))
1352 || !tree_int_cst_equal (inner_max
, outer_max
)))
1356 /* Recurse on the element check. */
1357 return useless_type_conversion_p (TREE_TYPE (outer_type
),
1358 TREE_TYPE (inner_type
));
1361 else if ((TREE_CODE (inner_type
) == FUNCTION_TYPE
1362 || TREE_CODE (inner_type
) == METHOD_TYPE
)
1363 && TREE_CODE (inner_type
) == TREE_CODE (outer_type
))
1365 tree outer_parm
, inner_parm
;
1367 /* If the return types are not compatible bail out. */
1368 if (!useless_type_conversion_p (TREE_TYPE (outer_type
),
1369 TREE_TYPE (inner_type
)))
1372 /* Method types should belong to a compatible base class. */
1373 if (TREE_CODE (inner_type
) == METHOD_TYPE
1374 && !useless_type_conversion_p (TYPE_METHOD_BASETYPE (outer_type
),
1375 TYPE_METHOD_BASETYPE (inner_type
)))
1378 /* A conversion to an unprototyped argument list is ok. */
1379 if (!prototype_p (outer_type
))
1382 /* If the unqualified argument types are compatible the conversion
1384 if (TYPE_ARG_TYPES (outer_type
) == TYPE_ARG_TYPES (inner_type
))
1387 for (outer_parm
= TYPE_ARG_TYPES (outer_type
),
1388 inner_parm
= TYPE_ARG_TYPES (inner_type
);
1389 outer_parm
&& inner_parm
;
1390 outer_parm
= TREE_CHAIN (outer_parm
),
1391 inner_parm
= TREE_CHAIN (inner_parm
))
1392 if (!useless_type_conversion_p
1393 (TYPE_MAIN_VARIANT (TREE_VALUE (outer_parm
)),
1394 TYPE_MAIN_VARIANT (TREE_VALUE (inner_parm
))))
1397 /* If there is a mismatch in the number of arguments the functions
1398 are not compatible. */
1399 if (outer_parm
|| inner_parm
)
1402 /* Defer to the target if necessary. */
1403 if (TYPE_ATTRIBUTES (inner_type
) || TYPE_ATTRIBUTES (outer_type
))
1404 return comp_type_attributes (outer_type
, inner_type
) != 0;
1409 /* For aggregates we rely on TYPE_CANONICAL exclusively and require
1410 explicit conversions for types involving to be structurally
1412 else if (AGGREGATE_TYPE_P (inner_type
)
1413 && TREE_CODE (inner_type
) == TREE_CODE (outer_type
))
1419 /* Return true if a conversion from either type of TYPE1 and TYPE2
1420 to the other is not required. Otherwise return false. */
1423 types_compatible_p (tree type1
, tree type2
)
1425 return (type1
== type2
1426 || (useless_type_conversion_p (type1
, type2
)
1427 && useless_type_conversion_p (type2
, type1
)));
1430 /* Return true if EXPR is a useless type conversion, otherwise return
1434 tree_ssa_useless_type_conversion (tree expr
)
1436 /* If we have an assignment that merely uses a NOP_EXPR to change
1437 the top of the RHS to the type of the LHS and the type conversion
1438 is "safe", then strip away the type conversion so that we can
1439 enter LHS = RHS into the const_and_copies table. */
1440 if (CONVERT_EXPR_P (expr
)
1441 || TREE_CODE (expr
) == VIEW_CONVERT_EXPR
1442 || TREE_CODE (expr
) == NON_LVALUE_EXPR
)
1443 return useless_type_conversion_p
1445 TREE_TYPE (TREE_OPERAND (expr
, 0)));
1450 /* Strip conversions from EXP according to
1451 tree_ssa_useless_type_conversion and return the resulting
1455 tree_ssa_strip_useless_type_conversions (tree exp
)
1457 while (tree_ssa_useless_type_conversion (exp
))
1458 exp
= TREE_OPERAND (exp
, 0);
1463 /* Internal helper for walk_use_def_chains. VAR, FN and DATA are as
1464 described in walk_use_def_chains.
1466 VISITED is a pointer set used to mark visited SSA_NAMEs to avoid
1467 infinite loops. We used to have a bitmap for this to just mark
1468 SSA versions we had visited. But non-sparse bitmaps are way too
1469 expensive, while sparse bitmaps may cause quadratic behavior.
1471 IS_DFS is true if the caller wants to perform a depth-first search
1472 when visiting PHI nodes. A DFS will visit each PHI argument and
1473 call FN after each one. Otherwise, all the arguments are
1474 visited first and then FN is called with each of the visited
1475 arguments in a separate pass. */
1478 walk_use_def_chains_1 (tree var
, walk_use_def_chains_fn fn
, void *data
,
1479 struct pointer_set_t
*visited
, bool is_dfs
)
1483 if (pointer_set_insert (visited
, var
))
1486 def_stmt
= SSA_NAME_DEF_STMT (var
);
1488 if (gimple_code (def_stmt
) != GIMPLE_PHI
)
1490 /* If we reached the end of the use-def chain, call FN. */
1491 return fn (var
, def_stmt
, data
);
1497 /* When doing a breadth-first search, call FN before following the
1498 use-def links for each argument. */
1500 for (i
= 0; i
< gimple_phi_num_args (def_stmt
); i
++)
1501 if (fn (gimple_phi_arg_def (def_stmt
, i
), def_stmt
, data
))
1504 /* Follow use-def links out of each PHI argument. */
1505 for (i
= 0; i
< gimple_phi_num_args (def_stmt
); i
++)
1507 tree arg
= gimple_phi_arg_def (def_stmt
, i
);
1509 /* ARG may be NULL for newly introduced PHI nodes. */
1511 && TREE_CODE (arg
) == SSA_NAME
1512 && walk_use_def_chains_1 (arg
, fn
, data
, visited
, is_dfs
))
1516 /* When doing a depth-first search, call FN after following the
1517 use-def links for each argument. */
1519 for (i
= 0; i
< gimple_phi_num_args (def_stmt
); i
++)
1520 if (fn (gimple_phi_arg_def (def_stmt
, i
), def_stmt
, data
))
1529 /* Walk use-def chains starting at the SSA variable VAR. Call
1530 function FN at each reaching definition found. FN takes three
1531 arguments: VAR, its defining statement (DEF_STMT) and a generic
1532 pointer to whatever state information that FN may want to maintain
1533 (DATA). FN is able to stop the walk by returning true, otherwise
1534 in order to continue the walk, FN should return false.
1536 Note, that if DEF_STMT is a PHI node, the semantics are slightly
1537 different. The first argument to FN is no longer the original
1538 variable VAR, but the PHI argument currently being examined. If FN
1539 wants to get at VAR, it should call PHI_RESULT (PHI).
1541 If IS_DFS is true, this function will:
1543 1- walk the use-def chains for all the PHI arguments, and,
1544 2- call (*FN) (ARG, PHI, DATA) on all the PHI arguments.
1546 If IS_DFS is false, the two steps above are done in reverse order
1547 (i.e., a breadth-first search). */
1550 walk_use_def_chains (tree var
, walk_use_def_chains_fn fn
, void *data
,
1555 gcc_assert (TREE_CODE (var
) == SSA_NAME
);
1557 def_stmt
= SSA_NAME_DEF_STMT (var
);
1559 /* We only need to recurse if the reaching definition comes from a PHI
1561 if (gimple_code (def_stmt
) != GIMPLE_PHI
)
1562 (*fn
) (var
, def_stmt
, data
);
1565 struct pointer_set_t
*visited
= pointer_set_create ();
1566 walk_use_def_chains_1 (var
, fn
, data
, visited
, is_dfs
);
1567 pointer_set_destroy (visited
);
1572 /* Emit warnings for uninitialized variables. This is done in two passes.
1574 The first pass notices real uses of SSA names with undefined values.
1575 Such uses are unconditionally uninitialized, and we can be certain that
1576 such a use is a mistake. This pass is run before most optimizations,
1577 so that we catch as many as we can.
1579 The second pass follows PHI nodes to find uses that are potentially
1580 uninitialized. In this case we can't necessarily prove that the use
1581 is really uninitialized. This pass is run after most optimizations,
1582 so that we thread as many jumps and possible, and delete as much dead
1583 code as possible, in order to reduce false positives. We also look
1584 again for plain uninitialized variables, since optimization may have
1585 changed conditionally uninitialized to unconditionally uninitialized. */
1587 /* Emit a warning for EXPR based on variable VAR at the point in the
1588 program T, an SSA_NAME, is used being uninitialized. The exact
1589 warning text is in MSGID and LOCUS may contain a location or be null.
1590 WC is the warning code. */
1593 warn_uninit (enum opt_code wc
, tree t
,
1594 tree expr
, tree var
, const char *gmsgid
, void *data
)
1596 gimple context
= (gimple
) data
;
1597 location_t location
, cfun_loc
;
1598 expanded_location xloc
, floc
;
1600 if (!ssa_undefined_value_p (t
))
1603 /* TREE_NO_WARNING either means we already warned, or the front end
1604 wishes to suppress the warning. */
1606 && (gimple_no_warning_p (context
)
1607 || (gimple_assign_single_p (context
)
1608 && TREE_NO_WARNING (gimple_assign_rhs1 (context
)))))
1609 || TREE_NO_WARNING (expr
))
1612 location
= (context
!= NULL
&& gimple_has_location (context
))
1613 ? gimple_location (context
)
1614 : DECL_SOURCE_LOCATION (var
);
1615 location
= linemap_resolve_location (line_table
, location
,
1616 LRK_SPELLING_LOCATION
,
1618 cfun_loc
= DECL_SOURCE_LOCATION (cfun
->decl
);
1619 xloc
= expand_location (location
);
1620 floc
= expand_location (cfun_loc
);
1621 if (warning_at (location
, wc
, gmsgid
, expr
))
1623 TREE_NO_WARNING (expr
) = 1;
1625 if (location
== DECL_SOURCE_LOCATION (var
))
1627 if (xloc
.file
!= floc
.file
1628 || linemap_location_before_p (line_table
,
1630 || linemap_location_before_p (line_table
,
1631 cfun
->function_end_locus
,
1633 inform (DECL_SOURCE_LOCATION (var
), "%qD was declared here", var
);
1638 warn_uninitialized_vars (bool warn_possibly_uninitialized
)
1640 gimple_stmt_iterator gsi
;
1645 bool always_executed
= dominated_by_p (CDI_POST_DOMINATORS
,
1646 single_succ (ENTRY_BLOCK_PTR
), bb
);
1647 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1649 gimple stmt
= gsi_stmt (gsi
);
1650 use_operand_p use_p
;
1651 ssa_op_iter op_iter
;
1654 if (is_gimple_debug (stmt
))
1657 /* We only do data flow with SSA_NAMEs, so that's all we
1659 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, op_iter
, SSA_OP_USE
)
1661 use
= USE_FROM_PTR (use_p
);
1662 if (always_executed
)
1663 warn_uninit (OPT_Wuninitialized
, use
,
1664 SSA_NAME_VAR (use
), SSA_NAME_VAR (use
),
1665 "%qD is used uninitialized in this function",
1667 else if (warn_possibly_uninitialized
)
1668 warn_uninit (OPT_Wuninitialized
, use
,
1669 SSA_NAME_VAR (use
), SSA_NAME_VAR (use
),
1670 "%qD may be used uninitialized in this function",
1674 /* For memory the only cheap thing we can do is see if we
1675 have a use of the default def of the virtual operand.
1676 ??? Note that at -O0 we do not have virtual operands.
1677 ??? Not so cheap would be to use the alias oracle via
1678 walk_aliased_vdefs, if we don't find any aliasing vdef
1679 warn as is-used-uninitialized, if we don't find an aliasing
1680 vdef that kills our use (stmt_kills_ref_p), warn as
1681 may-be-used-uninitialized. But this walk is quadratic and
1682 so must be limited which means we would miss warning
1684 use
= gimple_vuse (stmt
);
1686 && gimple_assign_single_p (stmt
)
1687 && !gimple_vdef (stmt
)
1688 && SSA_NAME_IS_DEFAULT_DEF (use
))
1690 tree rhs
= gimple_assign_rhs1 (stmt
);
1691 tree base
= get_base_address (rhs
);
1693 /* Do not warn if it can be initialized outside this function. */
1694 if (TREE_CODE (base
) != VAR_DECL
1695 || DECL_HARD_REGISTER (base
)
1696 || is_global_var (base
))
1699 if (always_executed
)
1700 warn_uninit (OPT_Wuninitialized
, use
, gimple_assign_rhs1 (stmt
),
1702 "%qE is used uninitialized in this function",
1704 else if (warn_possibly_uninitialized
)
1705 warn_uninit (OPT_Wuninitialized
, use
, gimple_assign_rhs1 (stmt
),
1707 "%qE may be used uninitialized in this function",
1717 execute_early_warn_uninitialized (void)
1719 /* Currently, this pass runs always but
1720 execute_late_warn_uninitialized only runs with optimization. With
1721 optimization we want to warn about possible uninitialized as late
1722 as possible, thus don't do it here. However, without
1723 optimization we need to warn here about "may be uninitialized".
1725 calculate_dominance_info (CDI_POST_DOMINATORS
);
1727 warn_uninitialized_vars (/*warn_possibly_uninitialized=*/!optimize
);
1729 /* Post-dominator information can not be reliably updated. Free it
1732 free_dominance_info (CDI_POST_DOMINATORS
);
1737 gate_warn_uninitialized (void)
1739 return warn_uninitialized
!= 0;
1742 struct gimple_opt_pass pass_early_warn_uninitialized
=
1746 "*early_warn_uninitialized", /* name */
1747 gate_warn_uninitialized
, /* gate */
1748 execute_early_warn_uninitialized
, /* execute */
1751 0, /* static_pass_number */
1752 TV_TREE_UNINIT
, /* tv_id */
1753 PROP_ssa
, /* properties_required */
1754 0, /* properties_provided */
1755 0, /* properties_destroyed */
1756 0, /* todo_flags_start */
1757 0 /* todo_flags_finish */
1762 /* If necessary, rewrite the base of the reference tree *TP from
1763 a MEM_REF to a plain or converted symbol. */
1766 maybe_rewrite_mem_ref_base (tree
*tp
, bitmap suitable_for_renaming
)
1770 while (handled_component_p (*tp
))
1771 tp
= &TREE_OPERAND (*tp
, 0);
1772 if (TREE_CODE (*tp
) == MEM_REF
1773 && TREE_CODE (TREE_OPERAND (*tp
, 0)) == ADDR_EXPR
1774 && (sym
= TREE_OPERAND (TREE_OPERAND (*tp
, 0), 0))
1776 && !TREE_ADDRESSABLE (sym
)
1777 && bitmap_bit_p (suitable_for_renaming
, DECL_UID (sym
)))
1779 if (TREE_CODE (TREE_TYPE (sym
)) == VECTOR_TYPE
1780 && useless_type_conversion_p (TREE_TYPE (*tp
),
1781 TREE_TYPE (TREE_TYPE (sym
)))
1782 && multiple_of_p (sizetype
, TREE_OPERAND (*tp
, 1),
1783 TYPE_SIZE_UNIT (TREE_TYPE (*tp
))))
1785 *tp
= build3 (BIT_FIELD_REF
, TREE_TYPE (*tp
), sym
,
1786 TYPE_SIZE (TREE_TYPE (*tp
)),
1787 int_const_binop (MULT_EXPR
,
1788 bitsize_int (BITS_PER_UNIT
),
1789 TREE_OPERAND (*tp
, 1)));
1791 else if (TREE_CODE (TREE_TYPE (sym
)) == COMPLEX_TYPE
1792 && useless_type_conversion_p (TREE_TYPE (*tp
),
1793 TREE_TYPE (TREE_TYPE (sym
))))
1795 *tp
= build1 (integer_zerop (TREE_OPERAND (*tp
, 1))
1796 ? REALPART_EXPR
: IMAGPART_EXPR
,
1797 TREE_TYPE (*tp
), sym
);
1799 else if (integer_zerop (TREE_OPERAND (*tp
, 1)))
1801 if (!useless_type_conversion_p (TREE_TYPE (*tp
),
1803 *tp
= build1 (VIEW_CONVERT_EXPR
,
1804 TREE_TYPE (*tp
), sym
);
1811 /* For a tree REF return its base if it is the base of a MEM_REF
1812 that cannot be rewritten into SSA form. Otherwise return NULL_TREE. */
1815 non_rewritable_mem_ref_base (tree ref
)
1819 /* A plain decl does not need it set. */
1823 while (handled_component_p (base
))
1824 base
= TREE_OPERAND (base
, 0);
1826 /* But watch out for MEM_REFs we cannot lower to a
1827 VIEW_CONVERT_EXPR or a BIT_FIELD_REF. */
1828 if (TREE_CODE (base
) == MEM_REF
1829 && TREE_CODE (TREE_OPERAND (base
, 0)) == ADDR_EXPR
)
1831 tree decl
= TREE_OPERAND (TREE_OPERAND (base
, 0), 0);
1832 if ((TREE_CODE (TREE_TYPE (decl
)) == VECTOR_TYPE
1833 || TREE_CODE (TREE_TYPE (decl
)) == COMPLEX_TYPE
)
1834 && useless_type_conversion_p (TREE_TYPE (base
),
1835 TREE_TYPE (TREE_TYPE (decl
)))
1836 && double_int_fits_in_uhwi_p (mem_ref_offset (base
))
1838 (tree_to_double_int (TYPE_SIZE_UNIT (TREE_TYPE (decl
))),
1839 mem_ref_offset (base
)) == 1
1840 && multiple_of_p (sizetype
, TREE_OPERAND (base
, 1),
1841 TYPE_SIZE_UNIT (TREE_TYPE (base
))))
1844 && (!integer_zerop (TREE_OPERAND (base
, 1))
1845 || (DECL_SIZE (decl
)
1846 != TYPE_SIZE (TREE_TYPE (base
)))
1847 || TREE_THIS_VOLATILE (decl
) != TREE_THIS_VOLATILE (base
)))
1854 /* For an lvalue tree LHS return true if it cannot be rewritten into SSA form.
1855 Otherwise return true. */
1858 non_rewritable_lvalue_p (tree lhs
)
1860 /* A plain decl is always rewritable. */
1864 /* A decl that is wrapped inside a MEM-REF that covers
1865 it full is also rewritable.
1866 ??? The following could be relaxed allowing component
1867 references that do not change the access size. */
1868 if (TREE_CODE (lhs
) == MEM_REF
1869 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == ADDR_EXPR
1870 && integer_zerop (TREE_OPERAND (lhs
, 1)))
1872 tree decl
= TREE_OPERAND (TREE_OPERAND (lhs
, 0), 0);
1874 && DECL_SIZE (decl
) == TYPE_SIZE (TREE_TYPE (lhs
))
1875 && (TREE_THIS_VOLATILE (decl
) == TREE_THIS_VOLATILE (lhs
)))
1882 /* When possible, clear TREE_ADDRESSABLE bit or set DECL_GIMPLE_REG_P bit and
1883 mark the variable VAR for conversion into SSA. Return true when updating
1884 stmts is required. */
1887 maybe_optimize_var (tree var
, bitmap addresses_taken
, bitmap not_reg_needs
,
1888 bitmap suitable_for_renaming
)
1890 /* Global Variables, result decls cannot be changed. */
1891 if (is_global_var (var
)
1892 || TREE_CODE (var
) == RESULT_DECL
1893 || bitmap_bit_p (addresses_taken
, DECL_UID (var
)))
1896 if (TREE_ADDRESSABLE (var
)
1897 /* Do not change TREE_ADDRESSABLE if we need to preserve var as
1898 a non-register. Otherwise we are confused and forget to
1899 add virtual operands for it. */
1900 && (!is_gimple_reg_type (TREE_TYPE (var
))
1901 || TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
1902 || TREE_CODE (TREE_TYPE (var
)) == COMPLEX_TYPE
1903 || !bitmap_bit_p (not_reg_needs
, DECL_UID (var
))))
1905 TREE_ADDRESSABLE (var
) = 0;
1906 if (is_gimple_reg (var
))
1907 bitmap_set_bit (suitable_for_renaming
, DECL_UID (var
));
1910 fprintf (dump_file
, "No longer having address taken: ");
1911 print_generic_expr (dump_file
, var
, 0);
1912 fprintf (dump_file
, "\n");
1916 if (!DECL_GIMPLE_REG_P (var
)
1917 && !bitmap_bit_p (not_reg_needs
, DECL_UID (var
))
1918 && (TREE_CODE (TREE_TYPE (var
)) == COMPLEX_TYPE
1919 || TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
)
1920 && !TREE_THIS_VOLATILE (var
)
1921 && (TREE_CODE (var
) != VAR_DECL
|| !DECL_HARD_REGISTER (var
)))
1923 DECL_GIMPLE_REG_P (var
) = 1;
1924 bitmap_set_bit (suitable_for_renaming
, DECL_UID (var
));
1927 fprintf (dump_file
, "Now a gimple register: ");
1928 print_generic_expr (dump_file
, var
, 0);
1929 fprintf (dump_file
, "\n");
1934 /* Compute TREE_ADDRESSABLE and DECL_GIMPLE_REG_P for local variables. */
1937 execute_update_addresses_taken (void)
1939 gimple_stmt_iterator gsi
;
1941 bitmap addresses_taken
= BITMAP_ALLOC (NULL
);
1942 bitmap not_reg_needs
= BITMAP_ALLOC (NULL
);
1943 bitmap suitable_for_renaming
= BITMAP_ALLOC (NULL
);
1947 timevar_push (TV_ADDRESS_TAKEN
);
1949 /* Collect into ADDRESSES_TAKEN all variables whose address is taken within
1950 the function body. */
1953 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1955 gimple stmt
= gsi_stmt (gsi
);
1956 enum gimple_code code
= gimple_code (stmt
);
1959 /* Note all addresses taken by the stmt. */
1960 gimple_ior_addresses_taken (addresses_taken
, stmt
);
1962 /* If we have a call or an assignment, see if the lhs contains
1963 a local decl that requires not to be a gimple register. */
1964 if (code
== GIMPLE_ASSIGN
|| code
== GIMPLE_CALL
)
1966 tree lhs
= gimple_get_lhs (stmt
);
1968 && TREE_CODE (lhs
) != SSA_NAME
1969 && non_rewritable_lvalue_p (lhs
))
1971 decl
= get_base_address (lhs
);
1973 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1977 if (gimple_assign_single_p (stmt
))
1979 tree rhs
= gimple_assign_rhs1 (stmt
);
1980 if ((decl
= non_rewritable_mem_ref_base (rhs
)))
1981 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1984 else if (code
== GIMPLE_CALL
)
1986 for (i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
1988 tree arg
= gimple_call_arg (stmt
, i
);
1989 if ((decl
= non_rewritable_mem_ref_base (arg
)))
1990 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1994 else if (code
== GIMPLE_ASM
)
1996 for (i
= 0; i
< gimple_asm_noutputs (stmt
); ++i
)
1998 tree link
= gimple_asm_output_op (stmt
, i
);
1999 tree lhs
= TREE_VALUE (link
);
2000 if (TREE_CODE (lhs
) != SSA_NAME
)
2002 decl
= get_base_address (lhs
);
2004 && (non_rewritable_lvalue_p (lhs
)
2005 /* We cannot move required conversions from
2006 the lhs to the rhs in asm statements, so
2007 require we do not need any. */
2008 || !useless_type_conversion_p
2009 (TREE_TYPE (lhs
), TREE_TYPE (decl
))))
2010 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
2013 for (i
= 0; i
< gimple_asm_ninputs (stmt
); ++i
)
2015 tree link
= gimple_asm_input_op (stmt
, i
);
2016 if ((decl
= non_rewritable_mem_ref_base (TREE_VALUE (link
))))
2017 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
2022 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
2025 gimple phi
= gsi_stmt (gsi
);
2027 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
2029 tree op
= PHI_ARG_DEF (phi
, i
), var
;
2030 if (TREE_CODE (op
) == ADDR_EXPR
2031 && (var
= get_base_address (TREE_OPERAND (op
, 0))) != NULL
2033 bitmap_set_bit (addresses_taken
, DECL_UID (var
));
2038 /* We cannot iterate over all referenced vars because that can contain
2039 unused vars from BLOCK trees, which causes code generation differences
2041 for (var
= DECL_ARGUMENTS (cfun
->decl
); var
; var
= DECL_CHAIN (var
))
2042 maybe_optimize_var (var
, addresses_taken
, not_reg_needs
,
2043 suitable_for_renaming
);
2045 FOR_EACH_VEC_ELT (tree
, cfun
->local_decls
, i
, var
)
2046 maybe_optimize_var (var
, addresses_taken
, not_reg_needs
,
2047 suitable_for_renaming
);
2049 /* Operand caches need to be recomputed for operands referencing the updated
2050 variables and operands need to be rewritten to expose bare symbols. */
2051 if (!bitmap_empty_p (suitable_for_renaming
))
2054 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
);)
2056 gimple stmt
= gsi_stmt (gsi
);
2058 /* Re-write TARGET_MEM_REFs of symbols we want to
2059 rewrite into SSA form. */
2060 if (gimple_assign_single_p (stmt
))
2062 tree lhs
= gimple_assign_lhs (stmt
);
2063 tree rhs
, *rhsp
= gimple_assign_rhs1_ptr (stmt
);
2066 /* We shouldn't have any fancy wrapping of
2067 component-refs on the LHS, but look through
2068 VIEW_CONVERT_EXPRs as that is easy. */
2069 while (TREE_CODE (lhs
) == VIEW_CONVERT_EXPR
)
2070 lhs
= TREE_OPERAND (lhs
, 0);
2071 if (TREE_CODE (lhs
) == MEM_REF
2072 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == ADDR_EXPR
2073 && integer_zerop (TREE_OPERAND (lhs
, 1))
2074 && (sym
= TREE_OPERAND (TREE_OPERAND (lhs
, 0), 0))
2076 && !TREE_ADDRESSABLE (sym
)
2077 && bitmap_bit_p (suitable_for_renaming
, DECL_UID (sym
)))
2080 lhs
= gimple_assign_lhs (stmt
);
2082 /* Rewrite the RHS and make sure the resulting assignment
2083 is validly typed. */
2084 maybe_rewrite_mem_ref_base (rhsp
, suitable_for_renaming
);
2085 rhs
= gimple_assign_rhs1 (stmt
);
2086 if (gimple_assign_lhs (stmt
) != lhs
2087 && !useless_type_conversion_p (TREE_TYPE (lhs
),
2089 rhs
= fold_build1 (VIEW_CONVERT_EXPR
,
2090 TREE_TYPE (lhs
), rhs
);
2092 if (gimple_assign_lhs (stmt
) != lhs
)
2093 gimple_assign_set_lhs (stmt
, lhs
);
2095 /* For var ={v} {CLOBBER}; where var lost
2096 TREE_ADDRESSABLE just remove the stmt. */
2098 && TREE_CLOBBER_P (rhs
)
2099 && bitmap_bit_p (suitable_for_renaming
, DECL_UID (lhs
)))
2101 unlink_stmt_vdef (stmt
);
2102 gsi_remove (&gsi
, true);
2103 release_defs (stmt
);
2107 if (gimple_assign_rhs1 (stmt
) != rhs
)
2109 gimple_stmt_iterator gsi
= gsi_for_stmt (stmt
);
2110 gimple_assign_set_rhs_from_tree (&gsi
, rhs
);
2114 else if (gimple_code (stmt
) == GIMPLE_CALL
)
2117 for (i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
2119 tree
*argp
= gimple_call_arg_ptr (stmt
, i
);
2120 maybe_rewrite_mem_ref_base (argp
, suitable_for_renaming
);
2124 else if (gimple_code (stmt
) == GIMPLE_ASM
)
2127 for (i
= 0; i
< gimple_asm_noutputs (stmt
); ++i
)
2129 tree link
= gimple_asm_output_op (stmt
, i
);
2130 maybe_rewrite_mem_ref_base (&TREE_VALUE (link
),
2131 suitable_for_renaming
);
2133 for (i
= 0; i
< gimple_asm_ninputs (stmt
); ++i
)
2135 tree link
= gimple_asm_input_op (stmt
, i
);
2136 maybe_rewrite_mem_ref_base (&TREE_VALUE (link
),
2137 suitable_for_renaming
);
2141 else if (gimple_debug_bind_p (stmt
)
2142 && gimple_debug_bind_has_value_p (stmt
))
2144 tree
*valuep
= gimple_debug_bind_get_value_ptr (stmt
);
2146 maybe_rewrite_mem_ref_base (valuep
, suitable_for_renaming
);
2147 decl
= non_rewritable_mem_ref_base (*valuep
);
2149 && bitmap_bit_p (suitable_for_renaming
, DECL_UID (decl
)))
2150 gimple_debug_bind_reset_value (stmt
);
2153 if (gimple_references_memory_p (stmt
)
2154 || is_gimple_debug (stmt
))
2160 /* Update SSA form here, we are called as non-pass as well. */
2161 if (number_of_loops () > 1 && loops_state_satisfies_p (LOOP_CLOSED_SSA
))
2162 rewrite_into_loop_closed_ssa (NULL
, TODO_update_ssa
);
2164 update_ssa (TODO_update_ssa
);
2167 BITMAP_FREE (not_reg_needs
);
2168 BITMAP_FREE (addresses_taken
);
2169 BITMAP_FREE (suitable_for_renaming
);
2170 timevar_pop (TV_ADDRESS_TAKEN
);
2173 struct gimple_opt_pass pass_update_address_taken
=
2177 "addressables", /* name */
2182 0, /* static_pass_number */
2183 TV_ADDRESS_TAKEN
, /* tv_id */
2184 PROP_ssa
, /* properties_required */
2185 0, /* properties_provided */
2186 0, /* properties_destroyed */
2187 0, /* todo_flags_start */
2188 TODO_update_address_taken
/* todo_flags_finish */