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
) != VAR_DECL
253 && TREE_CODE (var
) != PARM_DECL
)
256 if (DECL_HAS_VALUE_EXPR_P (var
))
257 return target_for_debug_bind (DECL_VALUE_EXPR (var
));
259 if (DECL_IGNORED_P (var
))
262 if (!is_gimple_reg (var
))
264 if (is_gimple_reg_type (TREE_TYPE (var
))
265 && referenced_var_lookup (cfun
, DECL_UID (var
)) == NULL_TREE
)
273 /* Called via walk_tree, look for SSA_NAMEs that have already been
277 find_released_ssa_name (tree
*tp
, int *walk_subtrees
, void *data_
)
279 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data_
;
281 if (wi
&& wi
->is_lhs
)
284 if (TREE_CODE (*tp
) == SSA_NAME
)
286 if (SSA_NAME_IN_FREE_LIST (*tp
))
291 else if (IS_TYPE_OR_DECL_P (*tp
))
297 /* Insert a DEBUG BIND stmt before the DEF of VAR if VAR is referenced
298 by other DEBUG stmts, and replace uses of the DEF with the
299 newly-created debug temp. */
302 insert_debug_temp_for_var_def (gimple_stmt_iterator
*gsi
, tree var
)
304 imm_use_iterator imm_iter
;
307 gimple def_stmt
= NULL
;
311 if (!MAY_HAVE_DEBUG_STMTS
)
314 /* If this name has already been registered for replacement, do nothing
315 as anything that uses this name isn't in SSA form. */
316 if (name_registered_for_update_p (var
))
319 /* Check whether there are debug stmts that reference this variable and,
320 if there are, decide whether we should use a debug temp. */
321 FOR_EACH_IMM_USE_FAST (use_p
, imm_iter
, var
)
323 stmt
= USE_STMT (use_p
);
325 if (!gimple_debug_bind_p (stmt
))
331 if (gimple_debug_bind_get_value (stmt
) != var
)
333 /* Count this as an additional use, so as to make sure we
334 use a temp unless VAR's definition has a SINGLE_RHS that
345 def_stmt
= gsi_stmt (*gsi
);
347 def_stmt
= SSA_NAME_DEF_STMT (var
);
349 /* If we didn't get an insertion point, and the stmt has already
350 been removed, we won't be able to insert the debug bind stmt, so
351 we'll have to drop debug information. */
352 if (gimple_code (def_stmt
) == GIMPLE_PHI
)
354 value
= degenerate_phi_result (def_stmt
);
355 if (value
&& walk_tree (&value
, find_released_ssa_name
, NULL
, NULL
))
357 /* error_mark_node is what fixup_noreturn_call changes PHI arguments
359 else if (value
== error_mark_node
)
362 else if (is_gimple_assign (def_stmt
))
364 bool no_value
= false;
366 if (!dom_info_available_p (CDI_DOMINATORS
))
368 struct walk_stmt_info wi
;
370 memset (&wi
, 0, sizeof (wi
));
372 /* When removing blocks without following reverse dominance
373 order, we may sometimes encounter SSA_NAMEs that have
374 already been released, referenced in other SSA_DEFs that
375 we're about to release. Consider:
384 If we deleted BB X first, propagating the value of w_2
385 won't do us any good. It's too late to recover their
386 original definition of v_1: when it was deleted, it was
387 only referenced in other DEFs, it couldn't possibly know
388 it should have been retained, and propagating every
389 single DEF just in case it might have to be propagated
390 into a DEBUG STMT would probably be too wasteful.
392 When dominator information is not readily available, we
393 check for and accept some loss of debug information. But
394 if it is available, there's no excuse for us to remove
395 blocks in the wrong order, so we don't even check for
396 dead SSA NAMEs. SSA verification shall catch any
398 if ((!gsi
&& !gimple_bb (def_stmt
))
399 || walk_gimple_op (def_stmt
, find_released_ssa_name
, &wi
))
404 value
= gimple_assign_rhs_to_tree (def_stmt
);
409 /* If there's a single use of VAR, and VAR is the entire debug
410 expression (usecount would have been incremented again
411 otherwise), and the definition involves only constants and
412 SSA names, then we can propagate VALUE into this single use,
415 We can also avoid using a temp if VALUE can be shared and
416 propagated into all uses, without generating expressions that
417 wouldn't be valid gimple RHSs.
419 Other cases that would require unsharing or non-gimple RHSs
420 are deferred to a debug temp, although we could avoid temps
421 at the expense of duplication of expressions. */
423 if (CONSTANT_CLASS_P (value
)
424 || gimple_code (def_stmt
) == GIMPLE_PHI
426 && (!gimple_assign_single_p (def_stmt
)
427 || is_gimple_min_invariant (value
)))
428 || is_gimple_reg (value
))
429 value
= unshare_expr (value
);
433 tree vexpr
= make_node (DEBUG_EXPR_DECL
);
435 def_temp
= gimple_build_debug_bind (vexpr
,
436 unshare_expr (value
),
439 DECL_ARTIFICIAL (vexpr
) = 1;
440 TREE_TYPE (vexpr
) = TREE_TYPE (value
);
442 DECL_MODE (vexpr
) = DECL_MODE (value
);
444 DECL_MODE (vexpr
) = TYPE_MODE (TREE_TYPE (value
));
447 gsi_insert_before (gsi
, def_temp
, GSI_SAME_STMT
);
450 gimple_stmt_iterator ngsi
= gsi_for_stmt (def_stmt
);
451 gsi_insert_before (&ngsi
, def_temp
, GSI_SAME_STMT
);
458 FOR_EACH_IMM_USE_STMT (stmt
, imm_iter
, var
)
460 if (!gimple_debug_bind_p (stmt
))
465 FOR_EACH_IMM_USE_ON_STMT (use_p
, imm_iter
)
466 /* unshare_expr is not needed here. vexpr is either a
467 SINGLE_RHS, that can be safely shared, some other RHS
468 that was unshared when we found it had a single debug
469 use, or a DEBUG_EXPR_DECL, that can be safely
471 SET_USE (use_p
, value
);
472 /* If we didn't replace uses with a debug decl fold the
473 resulting expression. Otherwise we end up with invalid IL. */
474 if (TREE_CODE (value
) != DEBUG_EXPR_DECL
)
476 gimple_stmt_iterator gsi
= gsi_for_stmt (stmt
);
477 fold_stmt_inplace (&gsi
);
481 gimple_debug_bind_reset_value (stmt
);
488 /* Insert a DEBUG BIND stmt before STMT for each DEF referenced by
489 other DEBUG stmts, and replace uses of the DEF with the
490 newly-created debug temp. */
493 insert_debug_temps_for_defs (gimple_stmt_iterator
*gsi
)
499 if (!MAY_HAVE_DEBUG_STMTS
)
502 stmt
= gsi_stmt (*gsi
);
504 FOR_EACH_PHI_OR_STMT_DEF (def_p
, stmt
, op_iter
, SSA_OP_DEF
)
506 tree var
= DEF_FROM_PTR (def_p
);
508 if (TREE_CODE (var
) != SSA_NAME
)
511 insert_debug_temp_for_var_def (gsi
, var
);
515 /* Reset all debug stmts that use SSA_NAME(s) defined in STMT. */
518 reset_debug_uses (gimple stmt
)
522 imm_use_iterator imm_iter
;
525 if (!MAY_HAVE_DEBUG_STMTS
)
528 FOR_EACH_PHI_OR_STMT_DEF (def_p
, stmt
, op_iter
, SSA_OP_DEF
)
530 tree var
= DEF_FROM_PTR (def_p
);
532 if (TREE_CODE (var
) != SSA_NAME
)
535 FOR_EACH_IMM_USE_STMT (use_stmt
, imm_iter
, var
)
537 if (!gimple_debug_bind_p (use_stmt
))
540 gimple_debug_bind_reset_value (use_stmt
);
541 update_stmt (use_stmt
);
546 /* Delete SSA DEFs for SSA versions in the TOREMOVE bitmap, removing
547 dominated stmts before their dominators, so that release_ssa_defs
548 stands a chance of propagating DEFs into debug bind stmts. */
551 release_defs_bitset (bitmap toremove
)
556 /* Performing a topological sort is probably overkill, this will
557 most likely run in slightly superlinear time, rather than the
558 pathological quadratic worst case. */
559 while (!bitmap_empty_p (toremove
))
560 EXECUTE_IF_SET_IN_BITMAP (toremove
, 0, j
, bi
)
562 bool remove_now
= true;
563 tree var
= ssa_name (j
);
565 imm_use_iterator uit
;
567 FOR_EACH_IMM_USE_STMT (stmt
, uit
, var
)
572 /* We can't propagate PHI nodes into debug stmts. */
573 if (gimple_code (stmt
) == GIMPLE_PHI
574 || is_gimple_debug (stmt
))
577 /* If we find another definition to remove that uses
578 the one we're looking at, defer the removal of this
579 one, so that it can be propagated into debug stmts
580 after the other is. */
581 FOR_EACH_SSA_DEF_OPERAND (def_p
, stmt
, dit
, SSA_OP_DEF
)
583 tree odef
= DEF_FROM_PTR (def_p
);
585 if (bitmap_bit_p (toremove
, SSA_NAME_VERSION (odef
)))
593 BREAK_FROM_IMM_USE_STMT (uit
);
598 gimple def
= SSA_NAME_DEF_STMT (var
);
599 gimple_stmt_iterator gsi
= gsi_for_stmt (def
);
601 if (gimple_code (def
) == GIMPLE_PHI
)
602 remove_phi_node (&gsi
, true);
605 gsi_remove (&gsi
, true);
609 bitmap_clear_bit (toremove
, j
);
614 /* Return true if SSA_NAME is malformed and mark it visited.
616 IS_VIRTUAL is true if this SSA_NAME was found inside a virtual
620 verify_ssa_name (tree ssa_name
, bool is_virtual
)
622 if (TREE_CODE (ssa_name
) != SSA_NAME
)
624 error ("expected an SSA_NAME object");
628 if (TREE_TYPE (ssa_name
) != TREE_TYPE (SSA_NAME_VAR (ssa_name
)))
630 error ("type mismatch between an SSA_NAME and its symbol");
634 if (SSA_NAME_IN_FREE_LIST (ssa_name
))
636 error ("found an SSA_NAME that had been released into the free pool");
640 if (is_virtual
&& is_gimple_reg (ssa_name
))
642 error ("found a virtual definition for a GIMPLE register");
646 if (is_virtual
&& SSA_NAME_VAR (ssa_name
) != gimple_vop (cfun
))
648 error ("virtual SSA name for non-VOP decl");
652 if (!is_virtual
&& !is_gimple_reg (ssa_name
))
654 error ("found a real definition for a non-register");
658 if (SSA_NAME_IS_DEFAULT_DEF (ssa_name
)
659 && !gimple_nop_p (SSA_NAME_DEF_STMT (ssa_name
)))
661 error ("found a default name with a non-empty defining statement");
669 /* Return true if the definition of SSA_NAME at block BB is malformed.
671 STMT is the statement where SSA_NAME is created.
673 DEFINITION_BLOCK is an array of basic blocks indexed by SSA_NAME
674 version numbers. If DEFINITION_BLOCK[SSA_NAME_VERSION] is set,
675 it means that the block in that array slot contains the
676 definition of SSA_NAME.
678 IS_VIRTUAL is true if SSA_NAME is created by a VDEF. */
681 verify_def (basic_block bb
, basic_block
*definition_block
, tree ssa_name
,
682 gimple stmt
, bool is_virtual
)
684 if (verify_ssa_name (ssa_name
, is_virtual
))
687 if (TREE_CODE (SSA_NAME_VAR (ssa_name
)) == RESULT_DECL
688 && DECL_BY_REFERENCE (SSA_NAME_VAR (ssa_name
)))
690 error ("RESULT_DECL should be read only when DECL_BY_REFERENCE is set");
694 if (definition_block
[SSA_NAME_VERSION (ssa_name
)])
696 error ("SSA_NAME created in two different blocks %i and %i",
697 definition_block
[SSA_NAME_VERSION (ssa_name
)]->index
, bb
->index
);
701 definition_block
[SSA_NAME_VERSION (ssa_name
)] = bb
;
703 if (SSA_NAME_DEF_STMT (ssa_name
) != stmt
)
705 error ("SSA_NAME_DEF_STMT is wrong");
706 fprintf (stderr
, "Expected definition statement:\n");
707 print_gimple_stmt (stderr
, SSA_NAME_DEF_STMT (ssa_name
), 4, TDF_VOPS
);
708 fprintf (stderr
, "\nActual definition statement:\n");
709 print_gimple_stmt (stderr
, stmt
, 4, TDF_VOPS
);
716 fprintf (stderr
, "while verifying SSA_NAME ");
717 print_generic_expr (stderr
, ssa_name
, 0);
718 fprintf (stderr
, " in statement\n");
719 print_gimple_stmt (stderr
, stmt
, 4, TDF_VOPS
);
725 /* Return true if the use of SSA_NAME at statement STMT in block BB is
728 DEF_BB is the block where SSA_NAME was found to be created.
730 IDOM contains immediate dominator information for the flowgraph.
732 CHECK_ABNORMAL is true if the caller wants to check whether this use
733 is flowing through an abnormal edge (only used when checking PHI
736 If NAMES_DEFINED_IN_BB is not NULL, it contains a bitmap of ssa names
737 that are defined before STMT in basic block BB. */
740 verify_use (basic_block bb
, basic_block def_bb
, use_operand_p use_p
,
741 gimple stmt
, bool check_abnormal
, bitmap names_defined_in_bb
)
744 tree ssa_name
= USE_FROM_PTR (use_p
);
746 if (!TREE_VISITED (ssa_name
))
747 if (verify_imm_links (stderr
, ssa_name
))
750 TREE_VISITED (ssa_name
) = 1;
752 if (gimple_nop_p (SSA_NAME_DEF_STMT (ssa_name
))
753 && SSA_NAME_IS_DEFAULT_DEF (ssa_name
))
754 ; /* Default definitions have empty statements. Nothing to do. */
757 error ("missing definition");
760 else if (bb
!= def_bb
761 && !dominated_by_p (CDI_DOMINATORS
, bb
, def_bb
))
763 error ("definition in block %i does not dominate use in block %i",
764 def_bb
->index
, bb
->index
);
767 else if (bb
== def_bb
768 && names_defined_in_bb
!= NULL
769 && !bitmap_bit_p (names_defined_in_bb
, SSA_NAME_VERSION (ssa_name
)))
771 error ("definition in block %i follows the use", def_bb
->index
);
776 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ssa_name
))
778 error ("SSA_NAME_OCCURS_IN_ABNORMAL_PHI should be set");
782 /* Make sure the use is in an appropriate list by checking the previous
783 element to make sure it's the same. */
784 if (use_p
->prev
== NULL
)
786 error ("no immediate_use list");
792 if (use_p
->prev
->use
== NULL
)
793 listvar
= use_p
->prev
->loc
.ssa_name
;
795 listvar
= USE_FROM_PTR (use_p
->prev
);
796 if (listvar
!= ssa_name
)
798 error ("wrong immediate use list");
805 fprintf (stderr
, "for SSA_NAME: ");
806 print_generic_expr (stderr
, ssa_name
, TDF_VOPS
);
807 fprintf (stderr
, " in statement:\n");
808 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
);
815 /* Return true if any of the arguments for PHI node PHI at block BB is
818 DEFINITION_BLOCK is an array of basic blocks indexed by SSA_NAME
819 version numbers. If DEFINITION_BLOCK[SSA_NAME_VERSION] is set,
820 it means that the block in that array slot contains the
821 definition of SSA_NAME. */
824 verify_phi_args (gimple phi
, basic_block bb
, basic_block
*definition_block
)
828 size_t i
, phi_num_args
= gimple_phi_num_args (phi
);
830 if (EDGE_COUNT (bb
->preds
) != phi_num_args
)
832 error ("incoming edge count does not match number of PHI arguments");
837 for (i
= 0; i
< phi_num_args
; i
++)
839 use_operand_p op_p
= gimple_phi_arg_imm_use_ptr (phi
, i
);
840 tree op
= USE_FROM_PTR (op_p
);
842 e
= EDGE_PRED (bb
, i
);
846 error ("PHI argument is missing for edge %d->%d",
853 if (TREE_CODE (op
) != SSA_NAME
&& !is_gimple_min_invariant (op
))
855 error ("PHI argument is not SSA_NAME, or invariant");
859 if (TREE_CODE (op
) == SSA_NAME
)
861 err
= verify_ssa_name (op
, !is_gimple_reg (gimple_phi_result (phi
)));
862 err
|= verify_use (e
->src
, definition_block
[SSA_NAME_VERSION (op
)],
863 op_p
, phi
, e
->flags
& EDGE_ABNORMAL
, NULL
);
866 if (TREE_CODE (op
) == ADDR_EXPR
)
868 tree base
= TREE_OPERAND (op
, 0);
869 while (handled_component_p (base
))
870 base
= TREE_OPERAND (base
, 0);
871 if ((TREE_CODE (base
) == VAR_DECL
872 || TREE_CODE (base
) == PARM_DECL
873 || TREE_CODE (base
) == RESULT_DECL
)
874 && !TREE_ADDRESSABLE (base
))
876 error ("address taken, but ADDRESSABLE bit not set");
883 error ("wrong edge %d->%d for PHI argument",
884 e
->src
->index
, e
->dest
->index
);
890 fprintf (stderr
, "PHI argument\n");
891 print_generic_stmt (stderr
, op
, TDF_VOPS
);
899 fprintf (stderr
, "for PHI node\n");
900 print_gimple_stmt (stderr
, phi
, 0, TDF_VOPS
|TDF_MEMSYMS
);
908 /* Verify common invariants in the SSA web.
909 TODO: verify the variable annotations. */
912 verify_ssa (bool check_modified_stmt
)
916 basic_block
*definition_block
= XCNEWVEC (basic_block
, num_ssa_names
);
919 enum dom_state orig_dom_state
= dom_info_state (CDI_DOMINATORS
);
920 bitmap names_defined_in_bb
= BITMAP_ALLOC (NULL
);
922 gcc_assert (!need_ssa_update_p (cfun
));
924 timevar_push (TV_TREE_SSA_VERIFY
);
926 /* Keep track of SSA names present in the IL. */
927 for (i
= 1; i
< num_ssa_names
; i
++)
929 tree name
= ssa_name (i
);
933 TREE_VISITED (name
) = 0;
935 verify_ssa_name (name
, !is_gimple_reg (name
));
937 stmt
= SSA_NAME_DEF_STMT (name
);
938 if (!gimple_nop_p (stmt
))
940 basic_block bb
= gimple_bb (stmt
);
941 verify_def (bb
, definition_block
,
942 name
, stmt
, !is_gimple_reg (name
));
948 calculate_dominance_info (CDI_DOMINATORS
);
950 /* Now verify all the uses and make sure they agree with the definitions
951 found in the previous pass. */
957 gimple_stmt_iterator gsi
;
959 /* Make sure that all edges have a clear 'aux' field. */
960 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
964 error ("AUX pointer initialized for edge %d->%d", e
->src
->index
,
970 /* Verify the arguments for every PHI node in the block. */
971 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
973 phi
= gsi_stmt (gsi
);
974 if (verify_phi_args (phi
, bb
, definition_block
))
977 bitmap_set_bit (names_defined_in_bb
,
978 SSA_NAME_VERSION (gimple_phi_result (phi
)));
981 /* Now verify all the uses and vuses in every statement of the block. */
982 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
984 gimple stmt
= gsi_stmt (gsi
);
987 if (check_modified_stmt
&& gimple_modified_p (stmt
))
989 error ("stmt (%p) marked modified after optimization pass: ",
991 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
);
995 if (verify_ssa_operands (stmt
))
997 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
);
1001 if (gimple_debug_bind_p (stmt
)
1002 && !gimple_debug_bind_has_value_p (stmt
))
1005 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_USE
|SSA_OP_VUSE
)
1007 op
= USE_FROM_PTR (use_p
);
1008 if (verify_use (bb
, definition_block
[SSA_NAME_VERSION (op
)],
1009 use_p
, stmt
, false, names_defined_in_bb
))
1013 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, iter
, SSA_OP_ALL_DEFS
)
1015 if (SSA_NAME_DEF_STMT (op
) != stmt
)
1017 error ("SSA_NAME_DEF_STMT is wrong");
1018 fprintf (stderr
, "Expected definition statement:\n");
1019 print_gimple_stmt (stderr
, stmt
, 4, TDF_VOPS
);
1020 fprintf (stderr
, "\nActual definition statement:\n");
1021 print_gimple_stmt (stderr
, SSA_NAME_DEF_STMT (op
),
1025 bitmap_set_bit (names_defined_in_bb
, SSA_NAME_VERSION (op
));
1029 bitmap_clear (names_defined_in_bb
);
1032 free (definition_block
);
1034 /* Restore the dominance information to its prior known state, so
1035 that we do not perturb the compiler's subsequent behavior. */
1036 if (orig_dom_state
== DOM_NONE
)
1037 free_dominance_info (CDI_DOMINATORS
);
1039 set_dom_info_availability (CDI_DOMINATORS
, orig_dom_state
);
1041 BITMAP_FREE (names_defined_in_bb
);
1042 timevar_pop (TV_TREE_SSA_VERIFY
);
1046 internal_error ("verify_ssa failed");
1049 /* Return true if the uid in both int tree maps are equal. */
1052 int_tree_map_eq (const void *va
, const void *vb
)
1054 const struct int_tree_map
*a
= (const struct int_tree_map
*) va
;
1055 const struct int_tree_map
*b
= (const struct int_tree_map
*) vb
;
1056 return (a
->uid
== b
->uid
);
1059 /* Hash a UID in a int_tree_map. */
1062 int_tree_map_hash (const void *item
)
1064 return ((const struct int_tree_map
*)item
)->uid
;
1067 /* Return true if the DECL_UID in both trees are equal. */
1070 uid_decl_map_eq (const void *va
, const void *vb
)
1072 const_tree a
= (const_tree
) va
;
1073 const_tree b
= (const_tree
) vb
;
1074 return (a
->decl_minimal
.uid
== b
->decl_minimal
.uid
);
1077 /* Hash a tree in a uid_decl_map. */
1080 uid_decl_map_hash (const void *item
)
1082 return ((const_tree
)item
)->decl_minimal
.uid
;
1085 /* Return true if the DECL_UID in both trees are equal. */
1088 uid_ssaname_map_eq (const void *va
, const void *vb
)
1090 const_tree a
= (const_tree
) va
;
1091 const_tree b
= (const_tree
) vb
;
1092 return (a
->ssa_name
.var
->decl_minimal
.uid
== b
->ssa_name
.var
->decl_minimal
.uid
);
1095 /* Hash a tree in a uid_decl_map. */
1098 uid_ssaname_map_hash (const void *item
)
1100 return ((const_tree
)item
)->ssa_name
.var
->decl_minimal
.uid
;
1104 /* Initialize global DFA and SSA structures. */
1107 init_tree_ssa (struct function
*fn
)
1109 fn
->gimple_df
= ggc_alloc_cleared_gimple_df ();
1110 fn
->gimple_df
->referenced_vars
= htab_create_ggc (20, uid_decl_map_hash
,
1111 uid_decl_map_eq
, NULL
);
1112 fn
->gimple_df
->default_defs
= htab_create_ggc (20, uid_ssaname_map_hash
,
1113 uid_ssaname_map_eq
, NULL
);
1114 pt_solution_reset (&fn
->gimple_df
->escaped
);
1115 init_ssanames (fn
, 0);
1118 /* Do the actions required to initialize internal data structures used
1119 in tree-ssa optimization passes. */
1122 execute_init_datastructures (void)
1124 /* Allocate hash tables, arrays and other structures. */
1125 init_tree_ssa (cfun
);
1129 struct gimple_opt_pass pass_init_datastructures
=
1133 "*init_datastructures", /* name */
1135 execute_init_datastructures
, /* execute */
1138 0, /* static_pass_number */
1139 TV_NONE
, /* tv_id */
1140 PROP_cfg
, /* properties_required */
1141 0, /* properties_provided */
1142 0, /* properties_destroyed */
1143 0, /* todo_flags_start */
1144 0 /* todo_flags_finish */
1148 /* Deallocate memory associated with SSA data structures for FNDECL. */
1151 delete_tree_ssa (void)
1153 referenced_var_iterator rvi
;
1156 /* Remove annotations from every referenced local variable. */
1157 FOR_EACH_REFERENCED_VAR (cfun
, var
, rvi
)
1159 if (is_global_var (var
))
1163 ggc_free (var_ann (var
));
1164 *DECL_VAR_ANN_PTR (var
) = NULL
;
1167 htab_delete (gimple_referenced_vars (cfun
));
1168 cfun
->gimple_df
->referenced_vars
= NULL
;
1172 /* We no longer maintain the SSA operand cache at this point. */
1173 if (ssa_operands_active ())
1174 fini_ssa_operands ();
1176 htab_delete (cfun
->gimple_df
->default_defs
);
1177 cfun
->gimple_df
->default_defs
= NULL
;
1178 pt_solution_reset (&cfun
->gimple_df
->escaped
);
1179 if (cfun
->gimple_df
->decls_to_pointers
!= NULL
)
1180 pointer_map_destroy (cfun
->gimple_df
->decls_to_pointers
);
1181 cfun
->gimple_df
->decls_to_pointers
= NULL
;
1182 cfun
->gimple_df
->modified_noreturn_calls
= NULL
;
1183 cfun
->gimple_df
= NULL
;
1185 /* We no longer need the edge variable maps. */
1186 redirect_edge_var_map_destroy ();
1189 /* Return true if the conversion from INNER_TYPE to OUTER_TYPE is a
1190 useless type conversion, otherwise return false.
1192 This function implicitly defines the middle-end type system. With
1193 the notion of 'a < b' meaning that useless_type_conversion_p (a, b)
1194 holds and 'a > b' meaning that useless_type_conversion_p (b, a) holds,
1195 the following invariants shall be fulfilled:
1197 1) useless_type_conversion_p is transitive.
1198 If a < b and b < c then a < c.
1200 2) useless_type_conversion_p is not symmetric.
1201 From a < b does not follow a > b.
1203 3) Types define the available set of operations applicable to values.
1204 A type conversion is useless if the operations for the target type
1205 is a subset of the operations for the source type. For example
1206 casts to void* are useless, casts from void* are not (void* can't
1207 be dereferenced or offsetted, but copied, hence its set of operations
1208 is a strict subset of that of all other data pointer types). Casts
1209 to const T* are useless (can't be written to), casts from const T*
1213 useless_type_conversion_p (tree outer_type
, tree inner_type
)
1215 /* Do the following before stripping toplevel qualifiers. */
1216 if (POINTER_TYPE_P (inner_type
)
1217 && POINTER_TYPE_P (outer_type
))
1219 /* Do not lose casts between pointers to different address spaces. */
1220 if (TYPE_ADDR_SPACE (TREE_TYPE (outer_type
))
1221 != TYPE_ADDR_SPACE (TREE_TYPE (inner_type
)))
1225 /* From now on qualifiers on value types do not matter. */
1226 inner_type
= TYPE_MAIN_VARIANT (inner_type
);
1227 outer_type
= TYPE_MAIN_VARIANT (outer_type
);
1229 if (inner_type
== outer_type
)
1232 /* If we know the canonical types, compare them. */
1233 if (TYPE_CANONICAL (inner_type
)
1234 && TYPE_CANONICAL (inner_type
) == TYPE_CANONICAL (outer_type
))
1237 /* Changes in machine mode are never useless conversions unless we
1238 deal with aggregate types in which case we defer to later checks. */
1239 if (TYPE_MODE (inner_type
) != TYPE_MODE (outer_type
)
1240 && !AGGREGATE_TYPE_P (inner_type
))
1243 /* If both the inner and outer types are integral types, then the
1244 conversion is not necessary if they have the same mode and
1245 signedness and precision, and both or neither are boolean. */
1246 if (INTEGRAL_TYPE_P (inner_type
)
1247 && INTEGRAL_TYPE_P (outer_type
))
1249 /* Preserve changes in signedness or precision. */
1250 if (TYPE_UNSIGNED (inner_type
) != TYPE_UNSIGNED (outer_type
)
1251 || TYPE_PRECISION (inner_type
) != TYPE_PRECISION (outer_type
))
1254 /* Preserve conversions to/from BOOLEAN_TYPE if types are not
1255 of precision one. */
1256 if (((TREE_CODE (inner_type
) == BOOLEAN_TYPE
)
1257 != (TREE_CODE (outer_type
) == BOOLEAN_TYPE
))
1258 && TYPE_PRECISION (outer_type
) != 1)
1261 /* We don't need to preserve changes in the types minimum or
1262 maximum value in general as these do not generate code
1263 unless the types precisions are different. */
1267 /* Scalar floating point types with the same mode are compatible. */
1268 else if (SCALAR_FLOAT_TYPE_P (inner_type
)
1269 && SCALAR_FLOAT_TYPE_P (outer_type
))
1272 /* Fixed point types with the same mode are compatible. */
1273 else if (FIXED_POINT_TYPE_P (inner_type
)
1274 && FIXED_POINT_TYPE_P (outer_type
))
1277 /* We need to take special care recursing to pointed-to types. */
1278 else if (POINTER_TYPE_P (inner_type
)
1279 && POINTER_TYPE_P (outer_type
))
1281 /* Do not lose casts to function pointer types. */
1282 if ((TREE_CODE (TREE_TYPE (outer_type
)) == FUNCTION_TYPE
1283 || TREE_CODE (TREE_TYPE (outer_type
)) == METHOD_TYPE
)
1284 && !(TREE_CODE (TREE_TYPE (inner_type
)) == FUNCTION_TYPE
1285 || TREE_CODE (TREE_TYPE (inner_type
)) == METHOD_TYPE
))
1288 /* We do not care for const qualification of the pointed-to types
1289 as const qualification has no semantic value to the middle-end. */
1291 /* Otherwise pointers/references are equivalent. */
1295 /* Recurse for complex types. */
1296 else if (TREE_CODE (inner_type
) == COMPLEX_TYPE
1297 && TREE_CODE (outer_type
) == COMPLEX_TYPE
)
1298 return useless_type_conversion_p (TREE_TYPE (outer_type
),
1299 TREE_TYPE (inner_type
));
1301 /* Recurse for vector types with the same number of subparts. */
1302 else if (TREE_CODE (inner_type
) == VECTOR_TYPE
1303 && TREE_CODE (outer_type
) == VECTOR_TYPE
1304 && TYPE_PRECISION (inner_type
) == TYPE_PRECISION (outer_type
))
1305 return useless_type_conversion_p (TREE_TYPE (outer_type
),
1306 TREE_TYPE (inner_type
));
1308 else if (TREE_CODE (inner_type
) == ARRAY_TYPE
1309 && TREE_CODE (outer_type
) == ARRAY_TYPE
)
1311 /* Preserve string attributes. */
1312 if (TYPE_STRING_FLAG (inner_type
) != TYPE_STRING_FLAG (outer_type
))
1315 /* Conversions from array types with unknown extent to
1316 array types with known extent are not useless. */
1317 if (!TYPE_DOMAIN (inner_type
)
1318 && TYPE_DOMAIN (outer_type
))
1321 /* Nor are conversions from array types with non-constant size to
1322 array types with constant size or to different size. */
1323 if (TYPE_SIZE (outer_type
)
1324 && TREE_CODE (TYPE_SIZE (outer_type
)) == INTEGER_CST
1325 && (!TYPE_SIZE (inner_type
)
1326 || TREE_CODE (TYPE_SIZE (inner_type
)) != INTEGER_CST
1327 || !tree_int_cst_equal (TYPE_SIZE (outer_type
),
1328 TYPE_SIZE (inner_type
))))
1331 /* Check conversions between arrays with partially known extents.
1332 If the array min/max values are constant they have to match.
1333 Otherwise allow conversions to unknown and variable extents.
1334 In particular this declares conversions that may change the
1335 mode to BLKmode as useless. */
1336 if (TYPE_DOMAIN (inner_type
)
1337 && TYPE_DOMAIN (outer_type
)
1338 && TYPE_DOMAIN (inner_type
) != TYPE_DOMAIN (outer_type
))
1340 tree inner_min
= TYPE_MIN_VALUE (TYPE_DOMAIN (inner_type
));
1341 tree outer_min
= TYPE_MIN_VALUE (TYPE_DOMAIN (outer_type
));
1342 tree inner_max
= TYPE_MAX_VALUE (TYPE_DOMAIN (inner_type
));
1343 tree outer_max
= TYPE_MAX_VALUE (TYPE_DOMAIN (outer_type
));
1345 /* After gimplification a variable min/max value carries no
1346 additional information compared to a NULL value. All that
1347 matters has been lowered to be part of the IL. */
1348 if (inner_min
&& TREE_CODE (inner_min
) != INTEGER_CST
)
1349 inner_min
= NULL_TREE
;
1350 if (outer_min
&& TREE_CODE (outer_min
) != INTEGER_CST
)
1351 outer_min
= NULL_TREE
;
1352 if (inner_max
&& TREE_CODE (inner_max
) != INTEGER_CST
)
1353 inner_max
= NULL_TREE
;
1354 if (outer_max
&& TREE_CODE (outer_max
) != INTEGER_CST
)
1355 outer_max
= NULL_TREE
;
1357 /* Conversions NULL / variable <- cst are useless, but not
1358 the other way around. */
1361 || !tree_int_cst_equal (inner_min
, outer_min
)))
1365 || !tree_int_cst_equal (inner_max
, outer_max
)))
1369 /* Recurse on the element check. */
1370 return useless_type_conversion_p (TREE_TYPE (outer_type
),
1371 TREE_TYPE (inner_type
));
1374 else if ((TREE_CODE (inner_type
) == FUNCTION_TYPE
1375 || TREE_CODE (inner_type
) == METHOD_TYPE
)
1376 && TREE_CODE (inner_type
) == TREE_CODE (outer_type
))
1378 tree outer_parm
, inner_parm
;
1380 /* If the return types are not compatible bail out. */
1381 if (!useless_type_conversion_p (TREE_TYPE (outer_type
),
1382 TREE_TYPE (inner_type
)))
1385 /* Method types should belong to a compatible base class. */
1386 if (TREE_CODE (inner_type
) == METHOD_TYPE
1387 && !useless_type_conversion_p (TYPE_METHOD_BASETYPE (outer_type
),
1388 TYPE_METHOD_BASETYPE (inner_type
)))
1391 /* A conversion to an unprototyped argument list is ok. */
1392 if (!prototype_p (outer_type
))
1395 /* If the unqualified argument types are compatible the conversion
1397 if (TYPE_ARG_TYPES (outer_type
) == TYPE_ARG_TYPES (inner_type
))
1400 for (outer_parm
= TYPE_ARG_TYPES (outer_type
),
1401 inner_parm
= TYPE_ARG_TYPES (inner_type
);
1402 outer_parm
&& inner_parm
;
1403 outer_parm
= TREE_CHAIN (outer_parm
),
1404 inner_parm
= TREE_CHAIN (inner_parm
))
1405 if (!useless_type_conversion_p
1406 (TYPE_MAIN_VARIANT (TREE_VALUE (outer_parm
)),
1407 TYPE_MAIN_VARIANT (TREE_VALUE (inner_parm
))))
1410 /* If there is a mismatch in the number of arguments the functions
1411 are not compatible. */
1412 if (outer_parm
|| inner_parm
)
1415 /* Defer to the target if necessary. */
1416 if (TYPE_ATTRIBUTES (inner_type
) || TYPE_ATTRIBUTES (outer_type
))
1417 return comp_type_attributes (outer_type
, inner_type
) != 0;
1422 /* For aggregates we rely on TYPE_CANONICAL exclusively and require
1423 explicit conversions for types involving to be structurally
1425 else if (AGGREGATE_TYPE_P (inner_type
)
1426 && TREE_CODE (inner_type
) == TREE_CODE (outer_type
))
1432 /* Return true if a conversion from either type of TYPE1 and TYPE2
1433 to the other is not required. Otherwise return false. */
1436 types_compatible_p (tree type1
, tree type2
)
1438 return (type1
== type2
1439 || (useless_type_conversion_p (type1
, type2
)
1440 && useless_type_conversion_p (type2
, type1
)));
1443 /* Return true if EXPR is a useless type conversion, otherwise return
1447 tree_ssa_useless_type_conversion (tree expr
)
1449 /* If we have an assignment that merely uses a NOP_EXPR to change
1450 the top of the RHS to the type of the LHS and the type conversion
1451 is "safe", then strip away the type conversion so that we can
1452 enter LHS = RHS into the const_and_copies table. */
1453 if (CONVERT_EXPR_P (expr
)
1454 || TREE_CODE (expr
) == VIEW_CONVERT_EXPR
1455 || TREE_CODE (expr
) == NON_LVALUE_EXPR
)
1456 return useless_type_conversion_p
1458 TREE_TYPE (TREE_OPERAND (expr
, 0)));
1463 /* Strip conversions from EXP according to
1464 tree_ssa_useless_type_conversion and return the resulting
1468 tree_ssa_strip_useless_type_conversions (tree exp
)
1470 while (tree_ssa_useless_type_conversion (exp
))
1471 exp
= TREE_OPERAND (exp
, 0);
1476 /* Internal helper for walk_use_def_chains. VAR, FN and DATA are as
1477 described in walk_use_def_chains.
1479 VISITED is a pointer set used to mark visited SSA_NAMEs to avoid
1480 infinite loops. We used to have a bitmap for this to just mark
1481 SSA versions we had visited. But non-sparse bitmaps are way too
1482 expensive, while sparse bitmaps may cause quadratic behavior.
1484 IS_DFS is true if the caller wants to perform a depth-first search
1485 when visiting PHI nodes. A DFS will visit each PHI argument and
1486 call FN after each one. Otherwise, all the arguments are
1487 visited first and then FN is called with each of the visited
1488 arguments in a separate pass. */
1491 walk_use_def_chains_1 (tree var
, walk_use_def_chains_fn fn
, void *data
,
1492 struct pointer_set_t
*visited
, bool is_dfs
)
1496 if (pointer_set_insert (visited
, var
))
1499 def_stmt
= SSA_NAME_DEF_STMT (var
);
1501 if (gimple_code (def_stmt
) != GIMPLE_PHI
)
1503 /* If we reached the end of the use-def chain, call FN. */
1504 return fn (var
, def_stmt
, data
);
1510 /* When doing a breadth-first search, call FN before following the
1511 use-def links for each argument. */
1513 for (i
= 0; i
< gimple_phi_num_args (def_stmt
); i
++)
1514 if (fn (gimple_phi_arg_def (def_stmt
, i
), def_stmt
, data
))
1517 /* Follow use-def links out of each PHI argument. */
1518 for (i
= 0; i
< gimple_phi_num_args (def_stmt
); i
++)
1520 tree arg
= gimple_phi_arg_def (def_stmt
, i
);
1522 /* ARG may be NULL for newly introduced PHI nodes. */
1524 && TREE_CODE (arg
) == SSA_NAME
1525 && walk_use_def_chains_1 (arg
, fn
, data
, visited
, is_dfs
))
1529 /* When doing a depth-first search, call FN after following the
1530 use-def links for each argument. */
1532 for (i
= 0; i
< gimple_phi_num_args (def_stmt
); i
++)
1533 if (fn (gimple_phi_arg_def (def_stmt
, i
), def_stmt
, data
))
1542 /* Walk use-def chains starting at the SSA variable VAR. Call
1543 function FN at each reaching definition found. FN takes three
1544 arguments: VAR, its defining statement (DEF_STMT) and a generic
1545 pointer to whatever state information that FN may want to maintain
1546 (DATA). FN is able to stop the walk by returning true, otherwise
1547 in order to continue the walk, FN should return false.
1549 Note, that if DEF_STMT is a PHI node, the semantics are slightly
1550 different. The first argument to FN is no longer the original
1551 variable VAR, but the PHI argument currently being examined. If FN
1552 wants to get at VAR, it should call PHI_RESULT (PHI).
1554 If IS_DFS is true, this function will:
1556 1- walk the use-def chains for all the PHI arguments, and,
1557 2- call (*FN) (ARG, PHI, DATA) on all the PHI arguments.
1559 If IS_DFS is false, the two steps above are done in reverse order
1560 (i.e., a breadth-first search). */
1563 walk_use_def_chains (tree var
, walk_use_def_chains_fn fn
, void *data
,
1568 gcc_assert (TREE_CODE (var
) == SSA_NAME
);
1570 def_stmt
= SSA_NAME_DEF_STMT (var
);
1572 /* We only need to recurse if the reaching definition comes from a PHI
1574 if (gimple_code (def_stmt
) != GIMPLE_PHI
)
1575 (*fn
) (var
, def_stmt
, data
);
1578 struct pointer_set_t
*visited
= pointer_set_create ();
1579 walk_use_def_chains_1 (var
, fn
, data
, visited
, is_dfs
);
1580 pointer_set_destroy (visited
);
1585 /* Emit warnings for uninitialized variables. This is done in two passes.
1587 The first pass notices real uses of SSA names with undefined values.
1588 Such uses are unconditionally uninitialized, and we can be certain that
1589 such a use is a mistake. This pass is run before most optimizations,
1590 so that we catch as many as we can.
1592 The second pass follows PHI nodes to find uses that are potentially
1593 uninitialized. In this case we can't necessarily prove that the use
1594 is really uninitialized. This pass is run after most optimizations,
1595 so that we thread as many jumps and possible, and delete as much dead
1596 code as possible, in order to reduce false positives. We also look
1597 again for plain uninitialized variables, since optimization may have
1598 changed conditionally uninitialized to unconditionally uninitialized. */
1600 /* Emit a warning for EXPR based on variable VAR at the point in the
1601 program T, an SSA_NAME, is used being uninitialized. The exact
1602 warning text is in MSGID and LOCUS may contain a location or be null.
1603 WC is the warning code. */
1606 warn_uninit (enum opt_code wc
, tree t
,
1607 tree expr
, tree var
, const char *gmsgid
, void *data
)
1609 gimple context
= (gimple
) data
;
1610 location_t location
, cfun_loc
;
1611 expanded_location xloc
, floc
;
1613 if (!ssa_undefined_value_p (t
))
1616 /* TREE_NO_WARNING either means we already warned, or the front end
1617 wishes to suppress the warning. */
1619 && (gimple_no_warning_p (context
)
1620 || (gimple_assign_single_p (context
)
1621 && TREE_NO_WARNING (gimple_assign_rhs1 (context
)))))
1622 || TREE_NO_WARNING (expr
))
1625 location
= (context
!= NULL
&& gimple_has_location (context
))
1626 ? gimple_location (context
)
1627 : DECL_SOURCE_LOCATION (var
);
1628 location
= linemap_resolve_location (line_table
, location
,
1629 LRK_SPELLING_LOCATION
,
1631 cfun_loc
= DECL_SOURCE_LOCATION (cfun
->decl
);
1632 xloc
= expand_location (location
);
1633 floc
= expand_location (cfun_loc
);
1634 if (warning_at (location
, wc
, gmsgid
, expr
))
1636 TREE_NO_WARNING (expr
) = 1;
1638 if (location
== DECL_SOURCE_LOCATION (var
))
1640 if (xloc
.file
!= floc
.file
1641 || linemap_location_before_p (line_table
,
1643 || linemap_location_before_p (line_table
,
1644 cfun
->function_end_locus
,
1646 inform (DECL_SOURCE_LOCATION (var
), "%qD was declared here", var
);
1651 warn_uninitialized_vars (bool warn_possibly_uninitialized
)
1653 gimple_stmt_iterator gsi
;
1658 bool always_executed
= dominated_by_p (CDI_POST_DOMINATORS
,
1659 single_succ (ENTRY_BLOCK_PTR
), bb
);
1660 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1662 gimple stmt
= gsi_stmt (gsi
);
1663 use_operand_p use_p
;
1664 ssa_op_iter op_iter
;
1667 if (is_gimple_debug (stmt
))
1670 /* We only do data flow with SSA_NAMEs, so that's all we
1672 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, op_iter
, SSA_OP_USE
)
1674 use
= USE_FROM_PTR (use_p
);
1675 if (always_executed
)
1676 warn_uninit (OPT_Wuninitialized
, use
,
1677 SSA_NAME_VAR (use
), SSA_NAME_VAR (use
),
1678 "%qD is used uninitialized in this function",
1680 else if (warn_possibly_uninitialized
)
1681 warn_uninit (OPT_Wuninitialized
, use
,
1682 SSA_NAME_VAR (use
), SSA_NAME_VAR (use
),
1683 "%qD may be used uninitialized in this function",
1687 /* For memory the only cheap thing we can do is see if we
1688 have a use of the default def of the virtual operand.
1689 ??? Note that at -O0 we do not have virtual operands.
1690 ??? Not so cheap would be to use the alias oracle via
1691 walk_aliased_vdefs, if we don't find any aliasing vdef
1692 warn as is-used-uninitialized, if we don't find an aliasing
1693 vdef that kills our use (stmt_kills_ref_p), warn as
1694 may-be-used-uninitialized. But this walk is quadratic and
1695 so must be limited which means we would miss warning
1697 use
= gimple_vuse (stmt
);
1699 && gimple_assign_single_p (stmt
)
1700 && !gimple_vdef (stmt
)
1701 && SSA_NAME_IS_DEFAULT_DEF (use
))
1703 tree rhs
= gimple_assign_rhs1 (stmt
);
1704 tree base
= get_base_address (rhs
);
1706 /* Do not warn if it can be initialized outside this function. */
1707 if (TREE_CODE (base
) != VAR_DECL
1708 || DECL_HARD_REGISTER (base
)
1709 || is_global_var (base
))
1712 if (always_executed
)
1713 warn_uninit (OPT_Wuninitialized
, use
, gimple_assign_rhs1 (stmt
),
1715 "%qE is used uninitialized in this function",
1717 else if (warn_possibly_uninitialized
)
1718 warn_uninit (OPT_Wuninitialized
, use
, gimple_assign_rhs1 (stmt
),
1720 "%qE may be used uninitialized in this function",
1730 execute_early_warn_uninitialized (void)
1732 /* Currently, this pass runs always but
1733 execute_late_warn_uninitialized only runs with optimization. With
1734 optimization we want to warn about possible uninitialized as late
1735 as possible, thus don't do it here. However, without
1736 optimization we need to warn here about "may be uninitialized".
1738 calculate_dominance_info (CDI_POST_DOMINATORS
);
1740 warn_uninitialized_vars (/*warn_possibly_uninitialized=*/!optimize
);
1742 /* Post-dominator information can not be reliably updated. Free it
1745 free_dominance_info (CDI_POST_DOMINATORS
);
1750 gate_warn_uninitialized (void)
1752 return warn_uninitialized
!= 0;
1755 struct gimple_opt_pass pass_early_warn_uninitialized
=
1759 "*early_warn_uninitialized", /* name */
1760 gate_warn_uninitialized
, /* gate */
1761 execute_early_warn_uninitialized
, /* execute */
1764 0, /* static_pass_number */
1765 TV_TREE_UNINIT
, /* tv_id */
1766 PROP_ssa
, /* properties_required */
1767 0, /* properties_provided */
1768 0, /* properties_destroyed */
1769 0, /* todo_flags_start */
1770 0 /* todo_flags_finish */
1775 /* If necessary, rewrite the base of the reference tree *TP from
1776 a MEM_REF to a plain or converted symbol. */
1779 maybe_rewrite_mem_ref_base (tree
*tp
)
1783 while (handled_component_p (*tp
))
1784 tp
= &TREE_OPERAND (*tp
, 0);
1785 if (TREE_CODE (*tp
) == MEM_REF
1786 && TREE_CODE (TREE_OPERAND (*tp
, 0)) == ADDR_EXPR
1787 && (sym
= TREE_OPERAND (TREE_OPERAND (*tp
, 0), 0))
1789 && !TREE_ADDRESSABLE (sym
)
1790 && symbol_marked_for_renaming (sym
))
1792 if (TREE_CODE (TREE_TYPE (sym
)) == VECTOR_TYPE
1793 && useless_type_conversion_p (TREE_TYPE (*tp
),
1794 TREE_TYPE (TREE_TYPE (sym
)))
1795 && multiple_of_p (sizetype
, TREE_OPERAND (*tp
, 1),
1796 TYPE_SIZE_UNIT (TREE_TYPE (*tp
))))
1798 *tp
= build3 (BIT_FIELD_REF
, TREE_TYPE (*tp
), sym
,
1799 TYPE_SIZE (TREE_TYPE (*tp
)),
1800 int_const_binop (MULT_EXPR
,
1801 bitsize_int (BITS_PER_UNIT
),
1802 TREE_OPERAND (*tp
, 1)));
1804 else if (TREE_CODE (TREE_TYPE (sym
)) == COMPLEX_TYPE
1805 && useless_type_conversion_p (TREE_TYPE (*tp
),
1806 TREE_TYPE (TREE_TYPE (sym
))))
1808 *tp
= build1 (integer_zerop (TREE_OPERAND (*tp
, 1))
1809 ? REALPART_EXPR
: IMAGPART_EXPR
,
1810 TREE_TYPE (*tp
), sym
);
1812 else if (integer_zerop (TREE_OPERAND (*tp
, 1)))
1814 if (!useless_type_conversion_p (TREE_TYPE (*tp
),
1816 *tp
= build1 (VIEW_CONVERT_EXPR
,
1817 TREE_TYPE (*tp
), sym
);
1824 /* For a tree REF return its base if it is the base of a MEM_REF
1825 that cannot be rewritten into SSA form. Otherwise return NULL_TREE. */
1828 non_rewritable_mem_ref_base (tree ref
)
1832 /* A plain decl does not need it set. */
1836 while (handled_component_p (base
))
1837 base
= TREE_OPERAND (base
, 0);
1839 /* But watch out for MEM_REFs we cannot lower to a
1840 VIEW_CONVERT_EXPR or a BIT_FIELD_REF. */
1841 if (TREE_CODE (base
) == MEM_REF
1842 && TREE_CODE (TREE_OPERAND (base
, 0)) == ADDR_EXPR
)
1844 tree decl
= TREE_OPERAND (TREE_OPERAND (base
, 0), 0);
1845 if ((TREE_CODE (TREE_TYPE (decl
)) == VECTOR_TYPE
1846 || TREE_CODE (TREE_TYPE (decl
)) == COMPLEX_TYPE
)
1847 && useless_type_conversion_p (TREE_TYPE (base
),
1848 TREE_TYPE (TREE_TYPE (decl
)))
1849 && double_int_fits_in_uhwi_p (mem_ref_offset (base
))
1851 (tree_to_double_int (TYPE_SIZE_UNIT (TREE_TYPE (decl
))),
1852 mem_ref_offset (base
)) == 1
1853 && multiple_of_p (sizetype
, TREE_OPERAND (base
, 1),
1854 TYPE_SIZE_UNIT (TREE_TYPE (base
))))
1857 && (!integer_zerop (TREE_OPERAND (base
, 1))
1858 || (DECL_SIZE (decl
)
1859 != TYPE_SIZE (TREE_TYPE (base
)))
1860 || TREE_THIS_VOLATILE (decl
) != TREE_THIS_VOLATILE (base
)))
1867 /* For an lvalue tree LHS return true if it cannot be rewritten into SSA form.
1868 Otherwise return true. */
1871 non_rewritable_lvalue_p (tree lhs
)
1873 /* A plain decl is always rewritable. */
1877 /* A decl that is wrapped inside a MEM-REF that covers
1878 it full is also rewritable.
1879 ??? The following could be relaxed allowing component
1880 references that do not change the access size. */
1881 if (TREE_CODE (lhs
) == MEM_REF
1882 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == ADDR_EXPR
1883 && integer_zerop (TREE_OPERAND (lhs
, 1)))
1885 tree decl
= TREE_OPERAND (TREE_OPERAND (lhs
, 0), 0);
1887 && DECL_SIZE (decl
) == TYPE_SIZE (TREE_TYPE (lhs
))
1888 && (TREE_THIS_VOLATILE (decl
) == TREE_THIS_VOLATILE (lhs
)))
1895 /* When possible, clear TREE_ADDRESSABLE bit or set DECL_GIMPLE_REG_P bit and
1896 mark the variable VAR for conversion into SSA. Return true when updating
1897 stmts is required. */
1900 maybe_optimize_var (tree var
, bitmap addresses_taken
, bitmap not_reg_needs
)
1902 bool update_vops
= false;
1904 /* Global Variables, result decls cannot be changed. */
1905 if (is_global_var (var
)
1906 || TREE_CODE (var
) == RESULT_DECL
1907 || bitmap_bit_p (addresses_taken
, DECL_UID (var
)))
1910 /* If the variable is not in the list of referenced vars then we
1911 do not need to touch it nor can we rename it. */
1912 if (!referenced_var_lookup (cfun
, DECL_UID (var
)))
1915 if (TREE_ADDRESSABLE (var
)
1916 /* Do not change TREE_ADDRESSABLE if we need to preserve var as
1917 a non-register. Otherwise we are confused and forget to
1918 add virtual operands for it. */
1919 && (!is_gimple_reg_type (TREE_TYPE (var
))
1920 || TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
1921 || TREE_CODE (TREE_TYPE (var
)) == COMPLEX_TYPE
1922 || !bitmap_bit_p (not_reg_needs
, DECL_UID (var
))))
1924 TREE_ADDRESSABLE (var
) = 0;
1925 if (is_gimple_reg (var
))
1926 mark_sym_for_renaming (var
);
1930 fprintf (dump_file
, "No longer having address taken: ");
1931 print_generic_expr (dump_file
, var
, 0);
1932 fprintf (dump_file
, "\n");
1936 if (!DECL_GIMPLE_REG_P (var
)
1937 && !bitmap_bit_p (not_reg_needs
, DECL_UID (var
))
1938 && (TREE_CODE (TREE_TYPE (var
)) == COMPLEX_TYPE
1939 || TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
)
1940 && !TREE_THIS_VOLATILE (var
)
1941 && (TREE_CODE (var
) != VAR_DECL
|| !DECL_HARD_REGISTER (var
)))
1943 DECL_GIMPLE_REG_P (var
) = 1;
1944 mark_sym_for_renaming (var
);
1948 fprintf (dump_file
, "Now a gimple register: ");
1949 print_generic_expr (dump_file
, var
, 0);
1950 fprintf (dump_file
, "\n");
1957 /* Compute TREE_ADDRESSABLE and DECL_GIMPLE_REG_P for local variables. */
1960 execute_update_addresses_taken (void)
1962 gimple_stmt_iterator gsi
;
1964 bitmap addresses_taken
= BITMAP_ALLOC (NULL
);
1965 bitmap not_reg_needs
= BITMAP_ALLOC (NULL
);
1966 bool update_vops
= false;
1970 timevar_push (TV_ADDRESS_TAKEN
);
1972 /* Collect into ADDRESSES_TAKEN all variables whose address is taken within
1973 the function body. */
1976 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1978 gimple stmt
= gsi_stmt (gsi
);
1979 enum gimple_code code
= gimple_code (stmt
);
1982 /* Note all addresses taken by the stmt. */
1983 gimple_ior_addresses_taken (addresses_taken
, stmt
);
1985 /* If we have a call or an assignment, see if the lhs contains
1986 a local decl that requires not to be a gimple register. */
1987 if (code
== GIMPLE_ASSIGN
|| code
== GIMPLE_CALL
)
1989 tree lhs
= gimple_get_lhs (stmt
);
1991 && TREE_CODE (lhs
) != SSA_NAME
1992 && non_rewritable_lvalue_p (lhs
))
1994 decl
= get_base_address (lhs
);
1996 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
2000 if (gimple_assign_single_p (stmt
))
2002 tree rhs
= gimple_assign_rhs1 (stmt
);
2003 if ((decl
= non_rewritable_mem_ref_base (rhs
)))
2004 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
2007 else if (code
== GIMPLE_CALL
)
2009 for (i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
2011 tree arg
= gimple_call_arg (stmt
, i
);
2012 if ((decl
= non_rewritable_mem_ref_base (arg
)))
2013 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
2017 else if (code
== GIMPLE_ASM
)
2019 for (i
= 0; i
< gimple_asm_noutputs (stmt
); ++i
)
2021 tree link
= gimple_asm_output_op (stmt
, i
);
2022 tree lhs
= TREE_VALUE (link
);
2023 if (TREE_CODE (lhs
) != SSA_NAME
)
2025 decl
= get_base_address (lhs
);
2027 && (non_rewritable_lvalue_p (lhs
)
2028 /* We cannot move required conversions from
2029 the lhs to the rhs in asm statements, so
2030 require we do not need any. */
2031 || !useless_type_conversion_p
2032 (TREE_TYPE (lhs
), TREE_TYPE (decl
))))
2033 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
2036 for (i
= 0; i
< gimple_asm_ninputs (stmt
); ++i
)
2038 tree link
= gimple_asm_input_op (stmt
, i
);
2039 if ((decl
= non_rewritable_mem_ref_base (TREE_VALUE (link
))))
2040 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
2045 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
2048 gimple phi
= gsi_stmt (gsi
);
2050 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
2052 tree op
= PHI_ARG_DEF (phi
, i
), var
;
2053 if (TREE_CODE (op
) == ADDR_EXPR
2054 && (var
= get_base_address (TREE_OPERAND (op
, 0))) != NULL
2056 bitmap_set_bit (addresses_taken
, DECL_UID (var
));
2061 /* We cannot iterate over all referenced vars because that can contain
2062 unused vars from BLOCK trees, which causes code generation differences
2064 for (var
= DECL_ARGUMENTS (cfun
->decl
); var
; var
= DECL_CHAIN (var
))
2065 update_vops
|= maybe_optimize_var (var
, addresses_taken
, not_reg_needs
);
2067 FOR_EACH_VEC_ELT (tree
, cfun
->local_decls
, i
, var
)
2068 update_vops
|= maybe_optimize_var (var
, addresses_taken
, not_reg_needs
);
2070 /* Operand caches need to be recomputed for operands referencing the updated
2075 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
);)
2077 gimple stmt
= gsi_stmt (gsi
);
2079 /* Re-write TARGET_MEM_REFs of symbols we want to
2080 rewrite into SSA form. */
2081 if (gimple_assign_single_p (stmt
))
2083 tree lhs
= gimple_assign_lhs (stmt
);
2084 tree rhs
, *rhsp
= gimple_assign_rhs1_ptr (stmt
);
2087 /* We shouldn't have any fancy wrapping of
2088 component-refs on the LHS, but look through
2089 VIEW_CONVERT_EXPRs as that is easy. */
2090 while (TREE_CODE (lhs
) == VIEW_CONVERT_EXPR
)
2091 lhs
= TREE_OPERAND (lhs
, 0);
2092 if (TREE_CODE (lhs
) == MEM_REF
2093 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == ADDR_EXPR
2094 && integer_zerop (TREE_OPERAND (lhs
, 1))
2095 && (sym
= TREE_OPERAND (TREE_OPERAND (lhs
, 0), 0))
2097 && !TREE_ADDRESSABLE (sym
)
2098 && symbol_marked_for_renaming (sym
))
2101 lhs
= gimple_assign_lhs (stmt
);
2103 /* Rewrite the RHS and make sure the resulting assignment
2104 is validly typed. */
2105 maybe_rewrite_mem_ref_base (rhsp
);
2106 rhs
= gimple_assign_rhs1 (stmt
);
2107 if (gimple_assign_lhs (stmt
) != lhs
2108 && !useless_type_conversion_p (TREE_TYPE (lhs
),
2110 rhs
= fold_build1 (VIEW_CONVERT_EXPR
,
2111 TREE_TYPE (lhs
), rhs
);
2113 if (gimple_assign_lhs (stmt
) != lhs
)
2114 gimple_assign_set_lhs (stmt
, lhs
);
2116 /* For var ={v} {CLOBBER}; where var lost
2117 TREE_ADDRESSABLE just remove the stmt. */
2119 && TREE_CLOBBER_P (rhs
)
2120 && symbol_marked_for_renaming (lhs
))
2122 unlink_stmt_vdef (stmt
);
2123 gsi_remove (&gsi
, true);
2124 release_defs (stmt
);
2128 if (gimple_assign_rhs1 (stmt
) != rhs
)
2130 gimple_stmt_iterator gsi
= gsi_for_stmt (stmt
);
2131 gimple_assign_set_rhs_from_tree (&gsi
, rhs
);
2135 else if (gimple_code (stmt
) == GIMPLE_CALL
)
2138 for (i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
2140 tree
*argp
= gimple_call_arg_ptr (stmt
, i
);
2141 maybe_rewrite_mem_ref_base (argp
);
2145 else if (gimple_code (stmt
) == GIMPLE_ASM
)
2148 for (i
= 0; i
< gimple_asm_noutputs (stmt
); ++i
)
2150 tree link
= gimple_asm_output_op (stmt
, i
);
2151 maybe_rewrite_mem_ref_base (&TREE_VALUE (link
));
2153 for (i
= 0; i
< gimple_asm_ninputs (stmt
); ++i
)
2155 tree link
= gimple_asm_input_op (stmt
, i
);
2156 maybe_rewrite_mem_ref_base (&TREE_VALUE (link
));
2160 else if (gimple_debug_bind_p (stmt
)
2161 && gimple_debug_bind_has_value_p (stmt
))
2163 tree
*valuep
= gimple_debug_bind_get_value_ptr (stmt
);
2165 maybe_rewrite_mem_ref_base (valuep
);
2166 decl
= non_rewritable_mem_ref_base (*valuep
);
2167 if (decl
&& symbol_marked_for_renaming (decl
))
2168 gimple_debug_bind_reset_value (stmt
);
2171 if (gimple_references_memory_p (stmt
)
2172 || is_gimple_debug (stmt
))
2178 /* Update SSA form here, we are called as non-pass as well. */
2179 if (number_of_loops () > 1 && loops_state_satisfies_p (LOOP_CLOSED_SSA
))
2180 rewrite_into_loop_closed_ssa (NULL
, TODO_update_ssa
);
2182 update_ssa (TODO_update_ssa
);
2185 BITMAP_FREE (not_reg_needs
);
2186 BITMAP_FREE (addresses_taken
);
2187 timevar_pop (TV_ADDRESS_TAKEN
);
2190 struct gimple_opt_pass pass_update_address_taken
=
2194 "addressables", /* name */
2199 0, /* static_pass_number */
2200 TV_ADDRESS_TAKEN
, /* tv_id */
2201 PROP_ssa
, /* properties_required */
2202 0, /* properties_provided */
2203 0, /* properties_destroyed */
2204 0, /* todo_flags_start */
2205 TODO_update_address_taken
/* todo_flags_finish */