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"
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"
48 /* Pointer map of variable mappings, keyed by edge. */
49 static struct pointer_map_t
*edge_var_maps
;
52 /* Add a mapping with PHI RESULT and PHI DEF associated with edge E. */
55 redirect_edge_var_map_add (edge e
, tree result
, tree def
, source_location locus
)
58 edge_var_map_vector old_head
, head
;
59 edge_var_map new_node
;
61 if (edge_var_maps
== NULL
)
62 edge_var_maps
= pointer_map_create ();
64 slot
= pointer_map_insert (edge_var_maps
, e
);
65 old_head
= head
= (edge_var_map_vector
) *slot
;
68 head
= VEC_alloc (edge_var_map
, heap
, 5);
72 new_node
.result
= result
;
73 new_node
.locus
= locus
;
75 VEC_safe_push (edge_var_map
, heap
, head
, &new_node
);
78 /* The push did some reallocation. Update the pointer map. */
84 /* Clear the var mappings in edge E. */
87 redirect_edge_var_map_clear (edge e
)
90 edge_var_map_vector head
;
95 slot
= pointer_map_contains (edge_var_maps
, e
);
99 head
= (edge_var_map_vector
) *slot
;
100 VEC_free (edge_var_map
, heap
, head
);
106 /* Duplicate the redirected var mappings in OLDE in NEWE.
108 Since we can't remove a mapping, let's just duplicate it. This assumes a
109 pointer_map can have multiple edges mapping to the same var_map (many to
110 one mapping), since we don't remove the previous mappings. */
113 redirect_edge_var_map_dup (edge newe
, edge olde
)
115 void **new_slot
, **old_slot
;
116 edge_var_map_vector head
;
121 new_slot
= pointer_map_insert (edge_var_maps
, newe
);
122 old_slot
= pointer_map_contains (edge_var_maps
, olde
);
125 head
= (edge_var_map_vector
) *old_slot
;
128 *new_slot
= VEC_copy (edge_var_map
, heap
, head
);
130 *new_slot
= VEC_alloc (edge_var_map
, heap
, 5);
134 /* Return the variable mappings for a given edge. If there is none, return
138 redirect_edge_var_map_vector (edge e
)
142 /* Hey, what kind of idiot would... you'd be surprised. */
146 slot
= pointer_map_contains (edge_var_maps
, e
);
150 return (edge_var_map_vector
) *slot
;
153 /* Used by redirect_edge_var_map_destroy to free all memory. */
156 free_var_map_entry (const void *key ATTRIBUTE_UNUSED
,
158 void *data ATTRIBUTE_UNUSED
)
160 edge_var_map_vector head
= (edge_var_map_vector
) *value
;
161 VEC_free (edge_var_map
, heap
, head
);
165 /* Clear the edge variable mappings. */
168 redirect_edge_var_map_destroy (void)
172 pointer_map_traverse (edge_var_maps
, free_var_map_entry
, NULL
);
173 pointer_map_destroy (edge_var_maps
);
174 edge_var_maps
= NULL
;
179 /* Remove the corresponding arguments from the PHI nodes in E's
180 destination block and redirect it to DEST. Return redirected edge.
181 The list of removed arguments is stored in a vector accessed
182 through edge_var_maps. */
185 ssa_redirect_edge (edge e
, basic_block dest
)
187 gimple_stmt_iterator gsi
;
190 redirect_edge_var_map_clear (e
);
192 /* Remove the appropriate PHI arguments in E's destination block. */
193 for (gsi
= gsi_start_phis (e
->dest
); !gsi_end_p (gsi
); gsi_next (&gsi
))
196 source_location locus
;
198 phi
= gsi_stmt (gsi
);
199 def
= gimple_phi_arg_def (phi
, e
->dest_idx
);
200 locus
= gimple_phi_arg_location (phi
, e
->dest_idx
);
202 if (def
== NULL_TREE
)
205 redirect_edge_var_map_add (e
, gimple_phi_result (phi
), def
, locus
);
208 e
= redirect_edge_succ_nodup (e
, dest
);
214 /* Add PHI arguments queued in PENDING_STMT list on edge E to edge
218 flush_pending_stmts (edge e
)
221 edge_var_map_vector v
;
224 gimple_stmt_iterator gsi
;
226 v
= redirect_edge_var_map_vector (e
);
230 for (gsi
= gsi_start_phis (e
->dest
), i
= 0;
231 !gsi_end_p (gsi
) && VEC_iterate (edge_var_map
, v
, i
, vm
);
232 gsi_next (&gsi
), i
++)
236 phi
= gsi_stmt (gsi
);
237 def
= redirect_edge_var_map_def (vm
);
238 add_phi_arg (phi
, def
, e
, redirect_edge_var_map_location (vm
));
241 redirect_edge_var_map_clear (e
);
244 /* Given a tree for an expression for which we might want to emit
245 locations or values in debug information (generally a variable, but
246 we might deal with other kinds of trees in the future), return the
247 tree that should be used as the variable of a DEBUG_BIND STMT or
248 VAR_LOCATION INSN or NOTE. Return NULL if VAR is not to be tracked. */
251 target_for_debug_bind (tree var
)
253 if (!MAY_HAVE_DEBUG_STMTS
)
256 if (TREE_CODE (var
) != VAR_DECL
257 && TREE_CODE (var
) != PARM_DECL
)
260 if (DECL_HAS_VALUE_EXPR_P (var
))
261 return target_for_debug_bind (DECL_VALUE_EXPR (var
));
263 if (DECL_IGNORED_P (var
))
266 if (!is_gimple_reg (var
))
268 if (is_gimple_reg_type (TREE_TYPE (var
))
269 && referenced_var_lookup (cfun
, DECL_UID (var
)) == NULL_TREE
)
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 (TREE_TYPE (ssa_name
) != TREE_TYPE (SSA_NAME_VAR (ssa_name
)))
634 error ("type mismatch between an SSA_NAME and its symbol");
638 if (SSA_NAME_IN_FREE_LIST (ssa_name
))
640 error ("found an SSA_NAME that had been released into the free pool");
644 if (is_virtual
&& is_gimple_reg (ssa_name
))
646 error ("found a virtual definition for a GIMPLE register");
650 if (is_virtual
&& SSA_NAME_VAR (ssa_name
) != gimple_vop (cfun
))
652 error ("virtual SSA name for non-VOP decl");
656 if (!is_virtual
&& !is_gimple_reg (ssa_name
))
658 error ("found a real definition for a non-register");
662 if (SSA_NAME_IS_DEFAULT_DEF (ssa_name
)
663 && !gimple_nop_p (SSA_NAME_DEF_STMT (ssa_name
)))
665 error ("found a default name with a non-empty defining statement");
673 /* Return true if the definition of SSA_NAME at block BB is malformed.
675 STMT is the statement where SSA_NAME is created.
677 DEFINITION_BLOCK is an array of basic blocks indexed by SSA_NAME
678 version numbers. If DEFINITION_BLOCK[SSA_NAME_VERSION] is set,
679 it means that the block in that array slot contains the
680 definition of SSA_NAME.
682 IS_VIRTUAL is true if SSA_NAME is created by a VDEF. */
685 verify_def (basic_block bb
, basic_block
*definition_block
, tree ssa_name
,
686 gimple stmt
, bool is_virtual
)
688 if (verify_ssa_name (ssa_name
, is_virtual
))
691 if (TREE_CODE (SSA_NAME_VAR (ssa_name
)) == RESULT_DECL
692 && DECL_BY_REFERENCE (SSA_NAME_VAR (ssa_name
)))
694 error ("RESULT_DECL should be read only when DECL_BY_REFERENCE is set");
698 if (definition_block
[SSA_NAME_VERSION (ssa_name
)])
700 error ("SSA_NAME created in two different blocks %i and %i",
701 definition_block
[SSA_NAME_VERSION (ssa_name
)]->index
, bb
->index
);
705 definition_block
[SSA_NAME_VERSION (ssa_name
)] = bb
;
707 if (SSA_NAME_DEF_STMT (ssa_name
) != stmt
)
709 error ("SSA_NAME_DEF_STMT is wrong");
710 fprintf (stderr
, "Expected definition statement:\n");
711 print_gimple_stmt (stderr
, SSA_NAME_DEF_STMT (ssa_name
), 4, TDF_VOPS
);
712 fprintf (stderr
, "\nActual definition statement:\n");
713 print_gimple_stmt (stderr
, stmt
, 4, TDF_VOPS
);
720 fprintf (stderr
, "while verifying SSA_NAME ");
721 print_generic_expr (stderr
, ssa_name
, 0);
722 fprintf (stderr
, " in statement\n");
723 print_gimple_stmt (stderr
, stmt
, 4, TDF_VOPS
);
729 /* Return true if the use of SSA_NAME at statement STMT in block BB is
732 DEF_BB is the block where SSA_NAME was found to be created.
734 IDOM contains immediate dominator information for the flowgraph.
736 CHECK_ABNORMAL is true if the caller wants to check whether this use
737 is flowing through an abnormal edge (only used when checking PHI
740 If NAMES_DEFINED_IN_BB is not NULL, it contains a bitmap of ssa names
741 that are defined before STMT in basic block BB. */
744 verify_use (basic_block bb
, basic_block def_bb
, use_operand_p use_p
,
745 gimple stmt
, bool check_abnormal
, bitmap names_defined_in_bb
)
748 tree ssa_name
= USE_FROM_PTR (use_p
);
750 if (!TREE_VISITED (ssa_name
))
751 if (verify_imm_links (stderr
, ssa_name
))
754 TREE_VISITED (ssa_name
) = 1;
756 if (gimple_nop_p (SSA_NAME_DEF_STMT (ssa_name
))
757 && SSA_NAME_IS_DEFAULT_DEF (ssa_name
))
758 ; /* Default definitions have empty statements. Nothing to do. */
761 error ("missing definition");
764 else if (bb
!= def_bb
765 && !dominated_by_p (CDI_DOMINATORS
, bb
, def_bb
))
767 error ("definition in block %i does not dominate use in block %i",
768 def_bb
->index
, bb
->index
);
771 else if (bb
== def_bb
772 && names_defined_in_bb
!= NULL
773 && !bitmap_bit_p (names_defined_in_bb
, SSA_NAME_VERSION (ssa_name
)))
775 error ("definition in block %i follows the use", def_bb
->index
);
780 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ssa_name
))
782 error ("SSA_NAME_OCCURS_IN_ABNORMAL_PHI should be set");
786 /* Make sure the use is in an appropriate list by checking the previous
787 element to make sure it's the same. */
788 if (use_p
->prev
== NULL
)
790 error ("no immediate_use list");
796 if (use_p
->prev
->use
== NULL
)
797 listvar
= use_p
->prev
->loc
.ssa_name
;
799 listvar
= USE_FROM_PTR (use_p
->prev
);
800 if (listvar
!= ssa_name
)
802 error ("wrong immediate use list");
809 fprintf (stderr
, "for SSA_NAME: ");
810 print_generic_expr (stderr
, ssa_name
, TDF_VOPS
);
811 fprintf (stderr
, " in statement:\n");
812 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
);
819 /* Return true if any of the arguments for PHI node PHI at block BB is
822 DEFINITION_BLOCK is an array of basic blocks indexed by SSA_NAME
823 version numbers. If DEFINITION_BLOCK[SSA_NAME_VERSION] is set,
824 it means that the block in that array slot contains the
825 definition of SSA_NAME. */
828 verify_phi_args (gimple phi
, basic_block bb
, basic_block
*definition_block
)
832 size_t i
, phi_num_args
= gimple_phi_num_args (phi
);
834 if (EDGE_COUNT (bb
->preds
) != phi_num_args
)
836 error ("incoming edge count does not match number of PHI arguments");
841 for (i
= 0; i
< phi_num_args
; i
++)
843 use_operand_p op_p
= gimple_phi_arg_imm_use_ptr (phi
, i
);
844 tree op
= USE_FROM_PTR (op_p
);
846 e
= EDGE_PRED (bb
, i
);
850 error ("PHI argument is missing for edge %d->%d",
857 if (TREE_CODE (op
) != SSA_NAME
&& !is_gimple_min_invariant (op
))
859 error ("PHI argument is not SSA_NAME, or invariant");
863 if (TREE_CODE (op
) == SSA_NAME
)
865 err
= verify_ssa_name (op
, !is_gimple_reg (gimple_phi_result (phi
)));
866 err
|= verify_use (e
->src
, definition_block
[SSA_NAME_VERSION (op
)],
867 op_p
, phi
, e
->flags
& EDGE_ABNORMAL
, NULL
);
870 if (TREE_CODE (op
) == ADDR_EXPR
)
872 tree base
= TREE_OPERAND (op
, 0);
873 while (handled_component_p (base
))
874 base
= TREE_OPERAND (base
, 0);
875 if ((TREE_CODE (base
) == VAR_DECL
876 || TREE_CODE (base
) == PARM_DECL
877 || TREE_CODE (base
) == RESULT_DECL
)
878 && !TREE_ADDRESSABLE (base
))
880 error ("address taken, but ADDRESSABLE bit not set");
887 error ("wrong edge %d->%d for PHI argument",
888 e
->src
->index
, e
->dest
->index
);
894 fprintf (stderr
, "PHI argument\n");
895 print_generic_stmt (stderr
, op
, TDF_VOPS
);
903 fprintf (stderr
, "for PHI node\n");
904 print_gimple_stmt (stderr
, phi
, 0, TDF_VOPS
|TDF_MEMSYMS
);
912 /* Verify common invariants in the SSA web.
913 TODO: verify the variable annotations. */
916 verify_ssa (bool check_modified_stmt
)
920 basic_block
*definition_block
= XCNEWVEC (basic_block
, num_ssa_names
);
923 enum dom_state orig_dom_state
= dom_info_state (CDI_DOMINATORS
);
924 bitmap names_defined_in_bb
= BITMAP_ALLOC (NULL
);
926 gcc_assert (!need_ssa_update_p (cfun
));
928 timevar_push (TV_TREE_SSA_VERIFY
);
930 /* Keep track of SSA names present in the IL. */
931 for (i
= 1; i
< num_ssa_names
; i
++)
933 tree name
= ssa_name (i
);
937 TREE_VISITED (name
) = 0;
939 verify_ssa_name (name
, !is_gimple_reg (name
));
941 stmt
= SSA_NAME_DEF_STMT (name
);
942 if (!gimple_nop_p (stmt
))
944 basic_block bb
= gimple_bb (stmt
);
945 verify_def (bb
, definition_block
,
946 name
, stmt
, !is_gimple_reg (name
));
952 calculate_dominance_info (CDI_DOMINATORS
);
954 /* Now verify all the uses and make sure they agree with the definitions
955 found in the previous pass. */
961 gimple_stmt_iterator gsi
;
963 /* Make sure that all edges have a clear 'aux' field. */
964 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
968 error ("AUX pointer initialized for edge %d->%d", e
->src
->index
,
974 /* Verify the arguments for every PHI node in the block. */
975 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
977 phi
= gsi_stmt (gsi
);
978 if (verify_phi_args (phi
, bb
, definition_block
))
981 bitmap_set_bit (names_defined_in_bb
,
982 SSA_NAME_VERSION (gimple_phi_result (phi
)));
985 /* Now verify all the uses and vuses in every statement of the block. */
986 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
988 gimple stmt
= gsi_stmt (gsi
);
991 if (check_modified_stmt
&& gimple_modified_p (stmt
))
993 error ("stmt (%p) marked modified after optimization pass: ",
995 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
);
999 if (verify_ssa_operands (stmt
))
1001 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
);
1005 if (gimple_debug_bind_p (stmt
)
1006 && !gimple_debug_bind_has_value_p (stmt
))
1009 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_USE
|SSA_OP_VUSE
)
1011 op
= USE_FROM_PTR (use_p
);
1012 if (verify_use (bb
, definition_block
[SSA_NAME_VERSION (op
)],
1013 use_p
, stmt
, false, names_defined_in_bb
))
1017 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, iter
, SSA_OP_ALL_DEFS
)
1019 if (SSA_NAME_DEF_STMT (op
) != stmt
)
1021 error ("SSA_NAME_DEF_STMT is wrong");
1022 fprintf (stderr
, "Expected definition statement:\n");
1023 print_gimple_stmt (stderr
, stmt
, 4, TDF_VOPS
);
1024 fprintf (stderr
, "\nActual definition statement:\n");
1025 print_gimple_stmt (stderr
, SSA_NAME_DEF_STMT (op
),
1029 bitmap_set_bit (names_defined_in_bb
, SSA_NAME_VERSION (op
));
1033 bitmap_clear (names_defined_in_bb
);
1036 free (definition_block
);
1038 /* Restore the dominance information to its prior known state, so
1039 that we do not perturb the compiler's subsequent behavior. */
1040 if (orig_dom_state
== DOM_NONE
)
1041 free_dominance_info (CDI_DOMINATORS
);
1043 set_dom_info_availability (CDI_DOMINATORS
, orig_dom_state
);
1045 BITMAP_FREE (names_defined_in_bb
);
1046 timevar_pop (TV_TREE_SSA_VERIFY
);
1050 internal_error ("verify_ssa failed");
1053 /* Return true if the uid in both int tree maps are equal. */
1056 int_tree_map_eq (const void *va
, const void *vb
)
1058 const struct int_tree_map
*a
= (const struct int_tree_map
*) va
;
1059 const struct int_tree_map
*b
= (const struct int_tree_map
*) vb
;
1060 return (a
->uid
== b
->uid
);
1063 /* Hash a UID in a int_tree_map. */
1066 int_tree_map_hash (const void *item
)
1068 return ((const struct int_tree_map
*)item
)->uid
;
1071 /* Return true if the DECL_UID in both trees are equal. */
1074 uid_decl_map_eq (const void *va
, const void *vb
)
1076 const_tree a
= (const_tree
) va
;
1077 const_tree b
= (const_tree
) vb
;
1078 return (a
->decl_minimal
.uid
== b
->decl_minimal
.uid
);
1081 /* Hash a tree in a uid_decl_map. */
1084 uid_decl_map_hash (const void *item
)
1086 return ((const_tree
)item
)->decl_minimal
.uid
;
1089 /* Return true if the DECL_UID in both trees are equal. */
1092 uid_ssaname_map_eq (const void *va
, const void *vb
)
1094 const_tree a
= (const_tree
) va
;
1095 const_tree b
= (const_tree
) vb
;
1096 return (a
->ssa_name
.var
->decl_minimal
.uid
== b
->ssa_name
.var
->decl_minimal
.uid
);
1099 /* Hash a tree in a uid_decl_map. */
1102 uid_ssaname_map_hash (const void *item
)
1104 return ((const_tree
)item
)->ssa_name
.var
->decl_minimal
.uid
;
1108 /* Initialize global DFA and SSA structures. */
1111 init_tree_ssa (struct function
*fn
)
1113 fn
->gimple_df
= ggc_alloc_cleared_gimple_df ();
1114 fn
->gimple_df
->referenced_vars
= htab_create_ggc (20, uid_decl_map_hash
,
1115 uid_decl_map_eq
, NULL
);
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)
1157 referenced_var_iterator rvi
;
1160 /* Remove annotations from every referenced local variable. */
1161 FOR_EACH_REFERENCED_VAR (cfun
, var
, rvi
)
1163 if (is_global_var (var
))
1167 ggc_free (var_ann (var
));
1168 *DECL_VAR_ANN_PTR (var
) = NULL
;
1171 htab_delete (gimple_referenced_vars (cfun
));
1172 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 htab_delete (cfun
->gimple_df
->default_defs
);
1181 cfun
->gimple_df
->default_defs
= NULL
;
1182 pt_solution_reset (&cfun
->gimple_df
->escaped
);
1183 if (cfun
->gimple_df
->decls_to_pointers
!= NULL
)
1184 pointer_map_destroy (cfun
->gimple_df
->decls_to_pointers
);
1185 cfun
->gimple_df
->decls_to_pointers
= NULL
;
1186 cfun
->gimple_df
->modified_noreturn_calls
= NULL
;
1187 cfun
->gimple_df
= NULL
;
1189 /* We no longer need the edge variable maps. */
1190 redirect_edge_var_map_destroy ();
1193 /* Return true if the conversion from INNER_TYPE to OUTER_TYPE is a
1194 useless type conversion, otherwise return false.
1196 This function implicitly defines the middle-end type system. With
1197 the notion of 'a < b' meaning that useless_type_conversion_p (a, b)
1198 holds and 'a > b' meaning that useless_type_conversion_p (b, a) holds,
1199 the following invariants shall be fulfilled:
1201 1) useless_type_conversion_p is transitive.
1202 If a < b and b < c then a < c.
1204 2) useless_type_conversion_p is not symmetric.
1205 From a < b does not follow a > b.
1207 3) Types define the available set of operations applicable to values.
1208 A type conversion is useless if the operations for the target type
1209 is a subset of the operations for the source type. For example
1210 casts to void* are useless, casts from void* are not (void* can't
1211 be dereferenced or offsetted, but copied, hence its set of operations
1212 is a strict subset of that of all other data pointer types). Casts
1213 to const T* are useless (can't be written to), casts from const T*
1217 useless_type_conversion_p (tree outer_type
, tree inner_type
)
1219 /* Do the following before stripping toplevel qualifiers. */
1220 if (POINTER_TYPE_P (inner_type
)
1221 && POINTER_TYPE_P (outer_type
))
1223 /* Do not lose casts between pointers to different address spaces. */
1224 if (TYPE_ADDR_SPACE (TREE_TYPE (outer_type
))
1225 != TYPE_ADDR_SPACE (TREE_TYPE (inner_type
)))
1229 /* From now on qualifiers on value types do not matter. */
1230 inner_type
= TYPE_MAIN_VARIANT (inner_type
);
1231 outer_type
= TYPE_MAIN_VARIANT (outer_type
);
1233 if (inner_type
== outer_type
)
1236 /* If we know the canonical types, compare them. */
1237 if (TYPE_CANONICAL (inner_type
)
1238 && TYPE_CANONICAL (inner_type
) == TYPE_CANONICAL (outer_type
))
1241 /* Changes in machine mode are never useless conversions unless we
1242 deal with aggregate types in which case we defer to later checks. */
1243 if (TYPE_MODE (inner_type
) != TYPE_MODE (outer_type
)
1244 && !AGGREGATE_TYPE_P (inner_type
))
1247 /* If both the inner and outer types are integral types, then the
1248 conversion is not necessary if they have the same mode and
1249 signedness and precision, and both or neither are boolean. */
1250 if (INTEGRAL_TYPE_P (inner_type
)
1251 && INTEGRAL_TYPE_P (outer_type
))
1253 /* Preserve changes in signedness or precision. */
1254 if (TYPE_UNSIGNED (inner_type
) != TYPE_UNSIGNED (outer_type
)
1255 || TYPE_PRECISION (inner_type
) != TYPE_PRECISION (outer_type
))
1258 /* Preserve conversions to/from BOOLEAN_TYPE if types are not
1259 of precision one. */
1260 if (((TREE_CODE (inner_type
) == BOOLEAN_TYPE
)
1261 != (TREE_CODE (outer_type
) == BOOLEAN_TYPE
))
1262 && TYPE_PRECISION (outer_type
) != 1)
1265 /* We don't need to preserve changes in the types minimum or
1266 maximum value in general as these do not generate code
1267 unless the types precisions are different. */
1271 /* Scalar floating point types with the same mode are compatible. */
1272 else if (SCALAR_FLOAT_TYPE_P (inner_type
)
1273 && SCALAR_FLOAT_TYPE_P (outer_type
))
1276 /* Fixed point types with the same mode are compatible. */
1277 else if (FIXED_POINT_TYPE_P (inner_type
)
1278 && FIXED_POINT_TYPE_P (outer_type
))
1281 /* We need to take special care recursing to pointed-to types. */
1282 else if (POINTER_TYPE_P (inner_type
)
1283 && POINTER_TYPE_P (outer_type
))
1285 /* Do not lose casts to function pointer types. */
1286 if ((TREE_CODE (TREE_TYPE (outer_type
)) == FUNCTION_TYPE
1287 || TREE_CODE (TREE_TYPE (outer_type
)) == METHOD_TYPE
)
1288 && !(TREE_CODE (TREE_TYPE (inner_type
)) == FUNCTION_TYPE
1289 || TREE_CODE (TREE_TYPE (inner_type
)) == METHOD_TYPE
))
1292 /* We do not care for const qualification of the pointed-to types
1293 as const qualification has no semantic value to the middle-end. */
1295 /* Otherwise pointers/references are equivalent. */
1299 /* Recurse for complex types. */
1300 else if (TREE_CODE (inner_type
) == COMPLEX_TYPE
1301 && TREE_CODE (outer_type
) == COMPLEX_TYPE
)
1302 return useless_type_conversion_p (TREE_TYPE (outer_type
),
1303 TREE_TYPE (inner_type
));
1305 /* Recurse for vector types with the same number of subparts. */
1306 else if (TREE_CODE (inner_type
) == VECTOR_TYPE
1307 && TREE_CODE (outer_type
) == VECTOR_TYPE
1308 && TYPE_PRECISION (inner_type
) == TYPE_PRECISION (outer_type
))
1309 return useless_type_conversion_p (TREE_TYPE (outer_type
),
1310 TREE_TYPE (inner_type
));
1312 else if (TREE_CODE (inner_type
) == ARRAY_TYPE
1313 && TREE_CODE (outer_type
) == ARRAY_TYPE
)
1315 /* Preserve string attributes. */
1316 if (TYPE_STRING_FLAG (inner_type
) != TYPE_STRING_FLAG (outer_type
))
1319 /* Conversions from array types with unknown extent to
1320 array types with known extent are not useless. */
1321 if (!TYPE_DOMAIN (inner_type
)
1322 && TYPE_DOMAIN (outer_type
))
1325 /* Nor are conversions from array types with non-constant size to
1326 array types with constant size or to different size. */
1327 if (TYPE_SIZE (outer_type
)
1328 && TREE_CODE (TYPE_SIZE (outer_type
)) == INTEGER_CST
1329 && (!TYPE_SIZE (inner_type
)
1330 || TREE_CODE (TYPE_SIZE (inner_type
)) != INTEGER_CST
1331 || !tree_int_cst_equal (TYPE_SIZE (outer_type
),
1332 TYPE_SIZE (inner_type
))))
1335 /* Check conversions between arrays with partially known extents.
1336 If the array min/max values are constant they have to match.
1337 Otherwise allow conversions to unknown and variable extents.
1338 In particular this declares conversions that may change the
1339 mode to BLKmode as useless. */
1340 if (TYPE_DOMAIN (inner_type
)
1341 && TYPE_DOMAIN (outer_type
)
1342 && TYPE_DOMAIN (inner_type
) != TYPE_DOMAIN (outer_type
))
1344 tree inner_min
= TYPE_MIN_VALUE (TYPE_DOMAIN (inner_type
));
1345 tree outer_min
= TYPE_MIN_VALUE (TYPE_DOMAIN (outer_type
));
1346 tree inner_max
= TYPE_MAX_VALUE (TYPE_DOMAIN (inner_type
));
1347 tree outer_max
= TYPE_MAX_VALUE (TYPE_DOMAIN (outer_type
));
1349 /* After gimplification a variable min/max value carries no
1350 additional information compared to a NULL value. All that
1351 matters has been lowered to be part of the IL. */
1352 if (inner_min
&& TREE_CODE (inner_min
) != INTEGER_CST
)
1353 inner_min
= NULL_TREE
;
1354 if (outer_min
&& TREE_CODE (outer_min
) != INTEGER_CST
)
1355 outer_min
= NULL_TREE
;
1356 if (inner_max
&& TREE_CODE (inner_max
) != INTEGER_CST
)
1357 inner_max
= NULL_TREE
;
1358 if (outer_max
&& TREE_CODE (outer_max
) != INTEGER_CST
)
1359 outer_max
= NULL_TREE
;
1361 /* Conversions NULL / variable <- cst are useless, but not
1362 the other way around. */
1365 || !tree_int_cst_equal (inner_min
, outer_min
)))
1369 || !tree_int_cst_equal (inner_max
, outer_max
)))
1373 /* Recurse on the element check. */
1374 return useless_type_conversion_p (TREE_TYPE (outer_type
),
1375 TREE_TYPE (inner_type
));
1378 else if ((TREE_CODE (inner_type
) == FUNCTION_TYPE
1379 || TREE_CODE (inner_type
) == METHOD_TYPE
)
1380 && TREE_CODE (inner_type
) == TREE_CODE (outer_type
))
1382 tree outer_parm
, inner_parm
;
1384 /* If the return types are not compatible bail out. */
1385 if (!useless_type_conversion_p (TREE_TYPE (outer_type
),
1386 TREE_TYPE (inner_type
)))
1389 /* Method types should belong to a compatible base class. */
1390 if (TREE_CODE (inner_type
) == METHOD_TYPE
1391 && !useless_type_conversion_p (TYPE_METHOD_BASETYPE (outer_type
),
1392 TYPE_METHOD_BASETYPE (inner_type
)))
1395 /* A conversion to an unprototyped argument list is ok. */
1396 if (!prototype_p (outer_type
))
1399 /* If the unqualified argument types are compatible the conversion
1401 if (TYPE_ARG_TYPES (outer_type
) == TYPE_ARG_TYPES (inner_type
))
1404 for (outer_parm
= TYPE_ARG_TYPES (outer_type
),
1405 inner_parm
= TYPE_ARG_TYPES (inner_type
);
1406 outer_parm
&& inner_parm
;
1407 outer_parm
= TREE_CHAIN (outer_parm
),
1408 inner_parm
= TREE_CHAIN (inner_parm
))
1409 if (!useless_type_conversion_p
1410 (TYPE_MAIN_VARIANT (TREE_VALUE (outer_parm
)),
1411 TYPE_MAIN_VARIANT (TREE_VALUE (inner_parm
))))
1414 /* If there is a mismatch in the number of arguments the functions
1415 are not compatible. */
1416 if (outer_parm
|| inner_parm
)
1419 /* Defer to the target if necessary. */
1420 if (TYPE_ATTRIBUTES (inner_type
) || TYPE_ATTRIBUTES (outer_type
))
1421 return comp_type_attributes (outer_type
, inner_type
) != 0;
1426 /* For aggregates we rely on TYPE_CANONICAL exclusively and require
1427 explicit conversions for types involving to be structurally
1429 else if (AGGREGATE_TYPE_P (inner_type
)
1430 && TREE_CODE (inner_type
) == TREE_CODE (outer_type
))
1436 /* Return true if a conversion from either type of TYPE1 and TYPE2
1437 to the other is not required. Otherwise return false. */
1440 types_compatible_p (tree type1
, tree type2
)
1442 return (type1
== type2
1443 || (useless_type_conversion_p (type1
, type2
)
1444 && useless_type_conversion_p (type2
, type1
)));
1447 /* Return true if EXPR is a useless type conversion, otherwise return
1451 tree_ssa_useless_type_conversion (tree expr
)
1453 /* If we have an assignment that merely uses a NOP_EXPR to change
1454 the top of the RHS to the type of the LHS and the type conversion
1455 is "safe", then strip away the type conversion so that we can
1456 enter LHS = RHS into the const_and_copies table. */
1457 if (CONVERT_EXPR_P (expr
)
1458 || TREE_CODE (expr
) == VIEW_CONVERT_EXPR
1459 || TREE_CODE (expr
) == NON_LVALUE_EXPR
)
1460 return useless_type_conversion_p
1462 TREE_TYPE (TREE_OPERAND (expr
, 0)));
1467 /* Strip conversions from EXP according to
1468 tree_ssa_useless_type_conversion and return the resulting
1472 tree_ssa_strip_useless_type_conversions (tree exp
)
1474 while (tree_ssa_useless_type_conversion (exp
))
1475 exp
= TREE_OPERAND (exp
, 0);
1480 /* Internal helper for walk_use_def_chains. VAR, FN and DATA are as
1481 described in walk_use_def_chains.
1483 VISITED is a pointer set used to mark visited SSA_NAMEs to avoid
1484 infinite loops. We used to have a bitmap for this to just mark
1485 SSA versions we had visited. But non-sparse bitmaps are way too
1486 expensive, while sparse bitmaps may cause quadratic behavior.
1488 IS_DFS is true if the caller wants to perform a depth-first search
1489 when visiting PHI nodes. A DFS will visit each PHI argument and
1490 call FN after each one. Otherwise, all the arguments are
1491 visited first and then FN is called with each of the visited
1492 arguments in a separate pass. */
1495 walk_use_def_chains_1 (tree var
, walk_use_def_chains_fn fn
, void *data
,
1496 struct pointer_set_t
*visited
, bool is_dfs
)
1500 if (pointer_set_insert (visited
, var
))
1503 def_stmt
= SSA_NAME_DEF_STMT (var
);
1505 if (gimple_code (def_stmt
) != GIMPLE_PHI
)
1507 /* If we reached the end of the use-def chain, call FN. */
1508 return fn (var
, def_stmt
, data
);
1514 /* When doing a breadth-first search, call FN before following the
1515 use-def links for each argument. */
1517 for (i
= 0; i
< gimple_phi_num_args (def_stmt
); i
++)
1518 if (fn (gimple_phi_arg_def (def_stmt
, i
), def_stmt
, data
))
1521 /* Follow use-def links out of each PHI argument. */
1522 for (i
= 0; i
< gimple_phi_num_args (def_stmt
); i
++)
1524 tree arg
= gimple_phi_arg_def (def_stmt
, i
);
1526 /* ARG may be NULL for newly introduced PHI nodes. */
1528 && TREE_CODE (arg
) == SSA_NAME
1529 && walk_use_def_chains_1 (arg
, fn
, data
, visited
, is_dfs
))
1533 /* When doing a depth-first search, call FN after following the
1534 use-def links for each argument. */
1536 for (i
= 0; i
< gimple_phi_num_args (def_stmt
); i
++)
1537 if (fn (gimple_phi_arg_def (def_stmt
, i
), def_stmt
, data
))
1546 /* Walk use-def chains starting at the SSA variable VAR. Call
1547 function FN at each reaching definition found. FN takes three
1548 arguments: VAR, its defining statement (DEF_STMT) and a generic
1549 pointer to whatever state information that FN may want to maintain
1550 (DATA). FN is able to stop the walk by returning true, otherwise
1551 in order to continue the walk, FN should return false.
1553 Note, that if DEF_STMT is a PHI node, the semantics are slightly
1554 different. The first argument to FN is no longer the original
1555 variable VAR, but the PHI argument currently being examined. If FN
1556 wants to get at VAR, it should call PHI_RESULT (PHI).
1558 If IS_DFS is true, this function will:
1560 1- walk the use-def chains for all the PHI arguments, and,
1561 2- call (*FN) (ARG, PHI, DATA) on all the PHI arguments.
1563 If IS_DFS is false, the two steps above are done in reverse order
1564 (i.e., a breadth-first search). */
1567 walk_use_def_chains (tree var
, walk_use_def_chains_fn fn
, void *data
,
1572 gcc_assert (TREE_CODE (var
) == SSA_NAME
);
1574 def_stmt
= SSA_NAME_DEF_STMT (var
);
1576 /* We only need to recurse if the reaching definition comes from a PHI
1578 if (gimple_code (def_stmt
) != GIMPLE_PHI
)
1579 (*fn
) (var
, def_stmt
, data
);
1582 struct pointer_set_t
*visited
= pointer_set_create ();
1583 walk_use_def_chains_1 (var
, fn
, data
, visited
, is_dfs
);
1584 pointer_set_destroy (visited
);
1589 /* Emit warnings for uninitialized variables. This is done in two passes.
1591 The first pass notices real uses of SSA names with undefined values.
1592 Such uses are unconditionally uninitialized, and we can be certain that
1593 such a use is a mistake. This pass is run before most optimizations,
1594 so that we catch as many as we can.
1596 The second pass follows PHI nodes to find uses that are potentially
1597 uninitialized. In this case we can't necessarily prove that the use
1598 is really uninitialized. This pass is run after most optimizations,
1599 so that we thread as many jumps and possible, and delete as much dead
1600 code as possible, in order to reduce false positives. We also look
1601 again for plain uninitialized variables, since optimization may have
1602 changed conditionally uninitialized to unconditionally uninitialized. */
1604 /* Emit a warning for EXPR based on variable VAR at the point in the
1605 program T, an SSA_NAME, is used being uninitialized. The exact
1606 warning text is in MSGID and LOCUS may contain a location or be null.
1607 WC is the warning code. */
1610 warn_uninit (enum opt_code wc
, tree t
,
1611 tree expr
, tree var
, const char *gmsgid
, void *data
)
1613 gimple context
= (gimple
) data
;
1614 location_t location
, cfun_loc
;
1615 expanded_location xloc
, floc
;
1617 if (!ssa_undefined_value_p (t
))
1620 /* TREE_NO_WARNING either means we already warned, or the front end
1621 wishes to suppress the warning. */
1623 && (gimple_no_warning_p (context
)
1624 || (gimple_assign_single_p (context
)
1625 && TREE_NO_WARNING (gimple_assign_rhs1 (context
)))))
1626 || TREE_NO_WARNING (expr
))
1629 location
= (context
!= NULL
&& gimple_has_location (context
))
1630 ? gimple_location (context
)
1631 : DECL_SOURCE_LOCATION (var
);
1632 location
= linemap_resolve_location (line_table
, location
,
1633 LRK_SPELLING_LOCATION
,
1635 cfun_loc
= DECL_SOURCE_LOCATION (cfun
->decl
);
1636 xloc
= expand_location (location
);
1637 floc
= expand_location (cfun_loc
);
1638 if (warning_at (location
, wc
, gmsgid
, expr
))
1640 TREE_NO_WARNING (expr
) = 1;
1642 if (location
== DECL_SOURCE_LOCATION (var
))
1644 if (xloc
.file
!= floc
.file
1645 || linemap_location_before_p (line_table
,
1647 || linemap_location_before_p (line_table
,
1648 cfun
->function_end_locus
,
1650 inform (DECL_SOURCE_LOCATION (var
), "%qD was declared here", var
);
1655 warn_uninitialized_vars (bool warn_possibly_uninitialized
)
1657 gimple_stmt_iterator gsi
;
1662 bool always_executed
= dominated_by_p (CDI_POST_DOMINATORS
,
1663 single_succ (ENTRY_BLOCK_PTR
), bb
);
1664 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1666 gimple stmt
= gsi_stmt (gsi
);
1667 use_operand_p use_p
;
1668 ssa_op_iter op_iter
;
1671 if (is_gimple_debug (stmt
))
1674 /* We only do data flow with SSA_NAMEs, so that's all we
1676 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, op_iter
, SSA_OP_USE
)
1678 use
= USE_FROM_PTR (use_p
);
1679 if (always_executed
)
1680 warn_uninit (OPT_Wuninitialized
, use
,
1681 SSA_NAME_VAR (use
), SSA_NAME_VAR (use
),
1682 "%qD is used uninitialized in this function",
1684 else if (warn_possibly_uninitialized
)
1685 warn_uninit (OPT_Wuninitialized
, use
,
1686 SSA_NAME_VAR (use
), SSA_NAME_VAR (use
),
1687 "%qD may be used uninitialized in this function",
1691 /* For memory the only cheap thing we can do is see if we
1692 have a use of the default def of the virtual operand.
1693 ??? Note that at -O0 we do not have virtual operands.
1694 ??? Not so cheap would be to use the alias oracle via
1695 walk_aliased_vdefs, if we don't find any aliasing vdef
1696 warn as is-used-uninitialized, if we don't find an aliasing
1697 vdef that kills our use (stmt_kills_ref_p), warn as
1698 may-be-used-uninitialized. But this walk is quadratic and
1699 so must be limited which means we would miss warning
1701 use
= gimple_vuse (stmt
);
1703 && gimple_assign_single_p (stmt
)
1704 && !gimple_vdef (stmt
)
1705 && SSA_NAME_IS_DEFAULT_DEF (use
))
1707 tree rhs
= gimple_assign_rhs1 (stmt
);
1708 tree base
= get_base_address (rhs
);
1710 /* Do not warn if it can be initialized outside this function. */
1711 if (TREE_CODE (base
) != VAR_DECL
1712 || DECL_HARD_REGISTER (base
)
1713 || is_global_var (base
))
1716 if (always_executed
)
1717 warn_uninit (OPT_Wuninitialized
, use
, gimple_assign_rhs1 (stmt
),
1719 "%qE is used uninitialized in this function",
1721 else if (warn_possibly_uninitialized
)
1722 warn_uninit (OPT_Wuninitialized
, use
, gimple_assign_rhs1 (stmt
),
1724 "%qE may be used uninitialized in this function",
1734 execute_early_warn_uninitialized (void)
1736 /* Currently, this pass runs always but
1737 execute_late_warn_uninitialized only runs with optimization. With
1738 optimization we want to warn about possible uninitialized as late
1739 as possible, thus don't do it here. However, without
1740 optimization we need to warn here about "may be uninitialized".
1742 calculate_dominance_info (CDI_POST_DOMINATORS
);
1744 warn_uninitialized_vars (/*warn_possibly_uninitialized=*/!optimize
);
1746 /* Post-dominator information can not be reliably updated. Free it
1749 free_dominance_info (CDI_POST_DOMINATORS
);
1754 gate_warn_uninitialized (void)
1756 return warn_uninitialized
!= 0;
1759 struct gimple_opt_pass pass_early_warn_uninitialized
=
1763 "*early_warn_uninitialized", /* name */
1764 gate_warn_uninitialized
, /* gate */
1765 execute_early_warn_uninitialized
, /* execute */
1768 0, /* static_pass_number */
1769 TV_TREE_UNINIT
, /* tv_id */
1770 PROP_ssa
, /* properties_required */
1771 0, /* properties_provided */
1772 0, /* properties_destroyed */
1773 0, /* todo_flags_start */
1774 0 /* todo_flags_finish */
1779 /* If necessary, rewrite the base of the reference tree *TP from
1780 a MEM_REF to a plain or converted symbol. */
1783 maybe_rewrite_mem_ref_base (tree
*tp
)
1787 while (handled_component_p (*tp
))
1788 tp
= &TREE_OPERAND (*tp
, 0);
1789 if (TREE_CODE (*tp
) == MEM_REF
1790 && TREE_CODE (TREE_OPERAND (*tp
, 0)) == ADDR_EXPR
1791 && (sym
= TREE_OPERAND (TREE_OPERAND (*tp
, 0), 0))
1793 && !TREE_ADDRESSABLE (sym
)
1794 && symbol_marked_for_renaming (sym
))
1796 if (TREE_CODE (TREE_TYPE (sym
)) == VECTOR_TYPE
1797 && useless_type_conversion_p (TREE_TYPE (*tp
),
1798 TREE_TYPE (TREE_TYPE (sym
)))
1799 && multiple_of_p (sizetype
, TREE_OPERAND (*tp
, 1),
1800 TYPE_SIZE_UNIT (TREE_TYPE (*tp
))))
1802 *tp
= build3 (BIT_FIELD_REF
, TREE_TYPE (*tp
), sym
,
1803 TYPE_SIZE (TREE_TYPE (*tp
)),
1804 int_const_binop (MULT_EXPR
,
1805 bitsize_int (BITS_PER_UNIT
),
1806 TREE_OPERAND (*tp
, 1)));
1808 else if (TREE_CODE (TREE_TYPE (sym
)) == COMPLEX_TYPE
1809 && useless_type_conversion_p (TREE_TYPE (*tp
),
1810 TREE_TYPE (TREE_TYPE (sym
))))
1812 *tp
= build1 (integer_zerop (TREE_OPERAND (*tp
, 1))
1813 ? REALPART_EXPR
: IMAGPART_EXPR
,
1814 TREE_TYPE (*tp
), sym
);
1816 else if (integer_zerop (TREE_OPERAND (*tp
, 1)))
1818 if (!useless_type_conversion_p (TREE_TYPE (*tp
),
1820 *tp
= build1 (VIEW_CONVERT_EXPR
,
1821 TREE_TYPE (*tp
), sym
);
1828 /* For a tree REF return its base if it is the base of a MEM_REF
1829 that cannot be rewritten into SSA form. Otherwise return NULL_TREE. */
1832 non_rewritable_mem_ref_base (tree ref
)
1836 /* A plain decl does not need it set. */
1840 while (handled_component_p (base
))
1841 base
= TREE_OPERAND (base
, 0);
1843 /* But watch out for MEM_REFs we cannot lower to a
1844 VIEW_CONVERT_EXPR or a BIT_FIELD_REF. */
1845 if (TREE_CODE (base
) == MEM_REF
1846 && TREE_CODE (TREE_OPERAND (base
, 0)) == ADDR_EXPR
)
1848 tree decl
= TREE_OPERAND (TREE_OPERAND (base
, 0), 0);
1849 if ((TREE_CODE (TREE_TYPE (decl
)) == VECTOR_TYPE
1850 || TREE_CODE (TREE_TYPE (decl
)) == COMPLEX_TYPE
)
1851 && useless_type_conversion_p (TREE_TYPE (base
),
1852 TREE_TYPE (TREE_TYPE (decl
)))
1853 && double_int_fits_in_uhwi_p (mem_ref_offset (base
))
1855 (tree_to_double_int (TYPE_SIZE_UNIT (TREE_TYPE (decl
))),
1856 mem_ref_offset (base
)) == 1
1857 && multiple_of_p (sizetype
, TREE_OPERAND (base
, 1),
1858 TYPE_SIZE_UNIT (TREE_TYPE (base
))))
1861 && (!integer_zerop (TREE_OPERAND (base
, 1))
1862 || (DECL_SIZE (decl
)
1863 != TYPE_SIZE (TREE_TYPE (base
)))
1864 || TREE_THIS_VOLATILE (decl
) != TREE_THIS_VOLATILE (base
)))
1871 /* For an lvalue tree LHS return true if it cannot be rewritten into SSA form.
1872 Otherwise return true. */
1875 non_rewritable_lvalue_p (tree lhs
)
1877 /* A plain decl is always rewritable. */
1881 /* A decl that is wrapped inside a MEM-REF that covers
1882 it full is also rewritable.
1883 ??? The following could be relaxed allowing component
1884 references that do not change the access size. */
1885 if (TREE_CODE (lhs
) == MEM_REF
1886 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == ADDR_EXPR
1887 && integer_zerop (TREE_OPERAND (lhs
, 1)))
1889 tree decl
= TREE_OPERAND (TREE_OPERAND (lhs
, 0), 0);
1891 && DECL_SIZE (decl
) == TYPE_SIZE (TREE_TYPE (lhs
))
1892 && (TREE_THIS_VOLATILE (decl
) == TREE_THIS_VOLATILE (lhs
)))
1899 /* When possible, clear TREE_ADDRESSABLE bit or set DECL_GIMPLE_REG_P bit and
1900 mark the variable VAR for conversion into SSA. Return true when updating
1901 stmts is required. */
1904 maybe_optimize_var (tree var
, bitmap addresses_taken
, bitmap not_reg_needs
)
1906 bool update_vops
= false;
1908 /* Global Variables, result decls cannot be changed. */
1909 if (is_global_var (var
)
1910 || TREE_CODE (var
) == RESULT_DECL
1911 || bitmap_bit_p (addresses_taken
, DECL_UID (var
)))
1914 /* If the variable is not in the list of referenced vars then we
1915 do not need to touch it nor can we rename it. */
1916 if (!referenced_var_lookup (cfun
, DECL_UID (var
)))
1919 if (TREE_ADDRESSABLE (var
)
1920 /* Do not change TREE_ADDRESSABLE if we need to preserve var as
1921 a non-register. Otherwise we are confused and forget to
1922 add virtual operands for it. */
1923 && (!is_gimple_reg_type (TREE_TYPE (var
))
1924 || TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
1925 || TREE_CODE (TREE_TYPE (var
)) == COMPLEX_TYPE
1926 || !bitmap_bit_p (not_reg_needs
, DECL_UID (var
))))
1928 TREE_ADDRESSABLE (var
) = 0;
1929 if (is_gimple_reg (var
))
1930 mark_sym_for_renaming (var
);
1934 fprintf (dump_file
, "No longer having address taken: ");
1935 print_generic_expr (dump_file
, var
, 0);
1936 fprintf (dump_file
, "\n");
1940 if (!DECL_GIMPLE_REG_P (var
)
1941 && !bitmap_bit_p (not_reg_needs
, DECL_UID (var
))
1942 && (TREE_CODE (TREE_TYPE (var
)) == COMPLEX_TYPE
1943 || TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
)
1944 && !TREE_THIS_VOLATILE (var
)
1945 && (TREE_CODE (var
) != VAR_DECL
|| !DECL_HARD_REGISTER (var
)))
1947 DECL_GIMPLE_REG_P (var
) = 1;
1948 mark_sym_for_renaming (var
);
1952 fprintf (dump_file
, "Now a gimple register: ");
1953 print_generic_expr (dump_file
, var
, 0);
1954 fprintf (dump_file
, "\n");
1961 /* Compute TREE_ADDRESSABLE and DECL_GIMPLE_REG_P for local variables. */
1964 execute_update_addresses_taken (void)
1966 gimple_stmt_iterator gsi
;
1968 bitmap addresses_taken
= BITMAP_ALLOC (NULL
);
1969 bitmap not_reg_needs
= BITMAP_ALLOC (NULL
);
1970 bool update_vops
= false;
1974 timevar_push (TV_ADDRESS_TAKEN
);
1976 /* Collect into ADDRESSES_TAKEN all variables whose address is taken within
1977 the function body. */
1980 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1982 gimple stmt
= gsi_stmt (gsi
);
1983 enum gimple_code code
= gimple_code (stmt
);
1986 /* Note all addresses taken by the stmt. */
1987 gimple_ior_addresses_taken (addresses_taken
, stmt
);
1989 /* If we have a call or an assignment, see if the lhs contains
1990 a local decl that requires not to be a gimple register. */
1991 if (code
== GIMPLE_ASSIGN
|| code
== GIMPLE_CALL
)
1993 tree lhs
= gimple_get_lhs (stmt
);
1995 && TREE_CODE (lhs
) != SSA_NAME
1996 && non_rewritable_lvalue_p (lhs
))
1998 decl
= get_base_address (lhs
);
2000 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
2004 if (gimple_assign_single_p (stmt
))
2006 tree rhs
= gimple_assign_rhs1 (stmt
);
2007 if ((decl
= non_rewritable_mem_ref_base (rhs
)))
2008 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
2011 else if (code
== GIMPLE_CALL
)
2013 for (i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
2015 tree arg
= gimple_call_arg (stmt
, i
);
2016 if ((decl
= non_rewritable_mem_ref_base (arg
)))
2017 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
2021 else if (code
== GIMPLE_ASM
)
2023 for (i
= 0; i
< gimple_asm_noutputs (stmt
); ++i
)
2025 tree link
= gimple_asm_output_op (stmt
, i
);
2026 tree lhs
= TREE_VALUE (link
);
2027 if (TREE_CODE (lhs
) != SSA_NAME
)
2029 decl
= get_base_address (lhs
);
2031 && (non_rewritable_lvalue_p (lhs
)
2032 /* We cannot move required conversions from
2033 the lhs to the rhs in asm statements, so
2034 require we do not need any. */
2035 || !useless_type_conversion_p
2036 (TREE_TYPE (lhs
), TREE_TYPE (decl
))))
2037 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
2040 for (i
= 0; i
< gimple_asm_ninputs (stmt
); ++i
)
2042 tree link
= gimple_asm_input_op (stmt
, i
);
2043 if ((decl
= non_rewritable_mem_ref_base (TREE_VALUE (link
))))
2044 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
2049 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
2052 gimple phi
= gsi_stmt (gsi
);
2054 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
2056 tree op
= PHI_ARG_DEF (phi
, i
), var
;
2057 if (TREE_CODE (op
) == ADDR_EXPR
2058 && (var
= get_base_address (TREE_OPERAND (op
, 0))) != NULL
2060 bitmap_set_bit (addresses_taken
, DECL_UID (var
));
2065 /* We cannot iterate over all referenced vars because that can contain
2066 unused vars from BLOCK trees, which causes code generation differences
2068 for (var
= DECL_ARGUMENTS (cfun
->decl
); var
; var
= DECL_CHAIN (var
))
2069 update_vops
|= maybe_optimize_var (var
, addresses_taken
, not_reg_needs
);
2071 FOR_EACH_VEC_ELT (tree
, cfun
->local_decls
, i
, var
)
2072 update_vops
|= maybe_optimize_var (var
, addresses_taken
, not_reg_needs
);
2074 /* Operand caches need to be recomputed for operands referencing the updated
2079 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
);)
2081 gimple stmt
= gsi_stmt (gsi
);
2083 /* Re-write TARGET_MEM_REFs of symbols we want to
2084 rewrite into SSA form. */
2085 if (gimple_assign_single_p (stmt
))
2087 tree lhs
= gimple_assign_lhs (stmt
);
2088 tree rhs
, *rhsp
= gimple_assign_rhs1_ptr (stmt
);
2091 /* We shouldn't have any fancy wrapping of
2092 component-refs on the LHS, but look through
2093 VIEW_CONVERT_EXPRs as that is easy. */
2094 while (TREE_CODE (lhs
) == VIEW_CONVERT_EXPR
)
2095 lhs
= TREE_OPERAND (lhs
, 0);
2096 if (TREE_CODE (lhs
) == MEM_REF
2097 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == ADDR_EXPR
2098 && integer_zerop (TREE_OPERAND (lhs
, 1))
2099 && (sym
= TREE_OPERAND (TREE_OPERAND (lhs
, 0), 0))
2101 && !TREE_ADDRESSABLE (sym
)
2102 && symbol_marked_for_renaming (sym
))
2105 lhs
= gimple_assign_lhs (stmt
);
2107 /* Rewrite the RHS and make sure the resulting assignment
2108 is validly typed. */
2109 maybe_rewrite_mem_ref_base (rhsp
);
2110 rhs
= gimple_assign_rhs1 (stmt
);
2111 if (gimple_assign_lhs (stmt
) != lhs
2112 && !useless_type_conversion_p (TREE_TYPE (lhs
),
2114 rhs
= fold_build1 (VIEW_CONVERT_EXPR
,
2115 TREE_TYPE (lhs
), rhs
);
2117 if (gimple_assign_lhs (stmt
) != lhs
)
2118 gimple_assign_set_lhs (stmt
, lhs
);
2120 /* For var ={v} {CLOBBER}; where var lost
2121 TREE_ADDRESSABLE just remove the stmt. */
2123 && TREE_CLOBBER_P (rhs
)
2124 && symbol_marked_for_renaming (lhs
))
2126 unlink_stmt_vdef (stmt
);
2127 gsi_remove (&gsi
, true);
2128 release_defs (stmt
);
2132 if (gimple_assign_rhs1 (stmt
) != rhs
)
2134 gimple_stmt_iterator gsi
= gsi_for_stmt (stmt
);
2135 gimple_assign_set_rhs_from_tree (&gsi
, rhs
);
2139 else if (gimple_code (stmt
) == GIMPLE_CALL
)
2142 for (i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
2144 tree
*argp
= gimple_call_arg_ptr (stmt
, i
);
2145 maybe_rewrite_mem_ref_base (argp
);
2149 else if (gimple_code (stmt
) == GIMPLE_ASM
)
2152 for (i
= 0; i
< gimple_asm_noutputs (stmt
); ++i
)
2154 tree link
= gimple_asm_output_op (stmt
, i
);
2155 maybe_rewrite_mem_ref_base (&TREE_VALUE (link
));
2157 for (i
= 0; i
< gimple_asm_ninputs (stmt
); ++i
)
2159 tree link
= gimple_asm_input_op (stmt
, i
);
2160 maybe_rewrite_mem_ref_base (&TREE_VALUE (link
));
2164 else if (gimple_debug_bind_p (stmt
)
2165 && gimple_debug_bind_has_value_p (stmt
))
2167 tree
*valuep
= gimple_debug_bind_get_value_ptr (stmt
);
2169 maybe_rewrite_mem_ref_base (valuep
);
2170 decl
= non_rewritable_mem_ref_base (*valuep
);
2171 if (decl
&& symbol_marked_for_renaming (decl
))
2172 gimple_debug_bind_reset_value (stmt
);
2175 if (gimple_references_memory_p (stmt
)
2176 || is_gimple_debug (stmt
))
2182 /* Update SSA form here, we are called as non-pass as well. */
2183 if (number_of_loops () > 1 && loops_state_satisfies_p (LOOP_CLOSED_SSA
))
2184 rewrite_into_loop_closed_ssa (NULL
, TODO_update_ssa
);
2186 update_ssa (TODO_update_ssa
);
2189 BITMAP_FREE (not_reg_needs
);
2190 BITMAP_FREE (addresses_taken
);
2191 timevar_pop (TV_ADDRESS_TAKEN
);
2194 struct gimple_opt_pass pass_update_address_taken
=
2198 "addressables", /* name */
2203 0, /* static_pass_number */
2204 TV_ADDRESS_TAKEN
, /* tv_id */
2205 PROP_ssa
, /* properties_required */
2206 0, /* properties_provided */
2207 0, /* properties_destroyed */
2208 0, /* todo_flags_start */
2209 TODO_update_address_taken
/* todo_flags_finish */