1 /* Miscellaneous SSA utility functions.
2 Copyright (C) 2001-2013 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 GCC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
29 #include "langhooks.h"
30 #include "basic-block.h"
32 #include "gimple-pretty-print.h"
34 #include "pointer-set.h"
35 #include "tree-flow.h"
37 #include "tree-inline.h"
39 #include "tree-pass.h"
40 #include "diagnostic-core.h"
43 /* Pointer map of variable mappings, keyed by edge. */
44 static struct pointer_map_t
*edge_var_maps
;
47 /* Add a mapping with PHI RESULT and PHI DEF associated with edge E. */
50 redirect_edge_var_map_add (edge e
, tree result
, tree def
, source_location locus
)
53 edge_var_map_vector
*head
;
54 edge_var_map new_node
;
56 if (edge_var_maps
== NULL
)
57 edge_var_maps
= pointer_map_create ();
59 slot
= pointer_map_insert (edge_var_maps
, e
);
60 head
= (edge_var_map_vector
*) *slot
;
62 vec_safe_reserve (head
, 5);
64 new_node
.result
= result
;
65 new_node
.locus
= locus
;
67 vec_safe_push (head
, new_node
);
72 /* Clear the var mappings in edge E. */
75 redirect_edge_var_map_clear (edge e
)
78 edge_var_map_vector
*head
;
83 slot
= pointer_map_contains (edge_var_maps
, e
);
87 head
= (edge_var_map_vector
*) *slot
;
94 /* Duplicate the redirected var mappings in OLDE in NEWE.
96 Since we can't remove a mapping, let's just duplicate it. This assumes a
97 pointer_map can have multiple edges mapping to the same var_map (many to
98 one mapping), since we don't remove the previous mappings. */
101 redirect_edge_var_map_dup (edge newe
, edge olde
)
103 void **new_slot
, **old_slot
;
104 edge_var_map_vector
*head
;
109 new_slot
= pointer_map_insert (edge_var_maps
, newe
);
110 old_slot
= pointer_map_contains (edge_var_maps
, olde
);
113 head
= (edge_var_map_vector
*) *old_slot
;
115 edge_var_map_vector
*new_head
= NULL
;
117 new_head
= vec_safe_copy (head
);
119 vec_safe_reserve (new_head
, 5);
120 *new_slot
= new_head
;
124 /* Return the variable mappings for a given edge. If there is none, return
127 edge_var_map_vector
*
128 redirect_edge_var_map_vector (edge e
)
132 /* Hey, what kind of idiot would... you'd be surprised. */
136 slot
= pointer_map_contains (edge_var_maps
, e
);
140 return (edge_var_map_vector
*) *slot
;
143 /* Used by redirect_edge_var_map_destroy to free all memory. */
146 free_var_map_entry (const void *key ATTRIBUTE_UNUSED
,
148 void *data ATTRIBUTE_UNUSED
)
150 edge_var_map_vector
*head
= (edge_var_map_vector
*) *value
;
155 /* Clear the edge variable mappings. */
158 redirect_edge_var_map_destroy (void)
162 pointer_map_traverse (edge_var_maps
, free_var_map_entry
, NULL
);
163 pointer_map_destroy (edge_var_maps
);
164 edge_var_maps
= NULL
;
169 /* Remove the corresponding arguments from the PHI nodes in E's
170 destination block and redirect it to DEST. Return redirected edge.
171 The list of removed arguments is stored in a vector accessed
172 through edge_var_maps. */
175 ssa_redirect_edge (edge e
, basic_block dest
)
177 gimple_stmt_iterator gsi
;
180 redirect_edge_var_map_clear (e
);
182 /* Remove the appropriate PHI arguments in E's destination block. */
183 for (gsi
= gsi_start_phis (e
->dest
); !gsi_end_p (gsi
); gsi_next (&gsi
))
186 source_location locus
;
188 phi
= gsi_stmt (gsi
);
189 def
= gimple_phi_arg_def (phi
, e
->dest_idx
);
190 locus
= gimple_phi_arg_location (phi
, e
->dest_idx
);
192 if (def
== NULL_TREE
)
195 redirect_edge_var_map_add (e
, gimple_phi_result (phi
), def
, locus
);
198 e
= redirect_edge_succ_nodup (e
, dest
);
204 /* Add PHI arguments queued in PENDING_STMT list on edge E to edge
208 flush_pending_stmts (edge e
)
211 edge_var_map_vector
*v
;
214 gimple_stmt_iterator gsi
;
216 v
= redirect_edge_var_map_vector (e
);
220 for (gsi
= gsi_start_phis (e
->dest
), i
= 0;
221 !gsi_end_p (gsi
) && v
->iterate (i
, &vm
);
222 gsi_next (&gsi
), i
++)
226 phi
= gsi_stmt (gsi
);
227 def
= redirect_edge_var_map_def (vm
);
228 add_phi_arg (phi
, def
, e
, redirect_edge_var_map_location (vm
));
231 redirect_edge_var_map_clear (e
);
234 /* Given a tree for an expression for which we might want to emit
235 locations or values in debug information (generally a variable, but
236 we might deal with other kinds of trees in the future), return the
237 tree that should be used as the variable of a DEBUG_BIND STMT or
238 VAR_LOCATION INSN or NOTE. Return NULL if VAR is not to be tracked. */
241 target_for_debug_bind (tree var
)
243 if (!MAY_HAVE_DEBUG_STMTS
)
246 if (TREE_CODE (var
) == SSA_NAME
)
248 var
= SSA_NAME_VAR (var
);
249 if (var
== NULL_TREE
)
253 if ((TREE_CODE (var
) != VAR_DECL
254 || VAR_DECL_IS_VIRTUAL_OPERAND (var
))
255 && TREE_CODE (var
) != PARM_DECL
)
258 if (DECL_HAS_VALUE_EXPR_P (var
))
259 return target_for_debug_bind (DECL_VALUE_EXPR (var
));
261 if (DECL_IGNORED_P (var
))
264 /* var-tracking only tracks registers. */
265 if (!is_gimple_reg_type (TREE_TYPE (var
)))
271 /* Called via walk_tree, look for SSA_NAMEs that have already been
275 find_released_ssa_name (tree
*tp
, int *walk_subtrees
, void *data_
)
277 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data_
;
279 if (wi
&& wi
->is_lhs
)
282 if (TREE_CODE (*tp
) == SSA_NAME
)
284 if (SSA_NAME_IN_FREE_LIST (*tp
))
289 else if (IS_TYPE_OR_DECL_P (*tp
))
295 /* Insert a DEBUG BIND stmt before the DEF of VAR if VAR is referenced
296 by other DEBUG stmts, and replace uses of the DEF with the
297 newly-created debug temp. */
300 insert_debug_temp_for_var_def (gimple_stmt_iterator
*gsi
, tree var
)
302 imm_use_iterator imm_iter
;
305 gimple def_stmt
= NULL
;
309 if (!MAY_HAVE_DEBUG_STMTS
)
312 /* If this name has already been registered for replacement, do nothing
313 as anything that uses this name isn't in SSA form. */
314 if (name_registered_for_update_p (var
))
317 /* Check whether there are debug stmts that reference this variable and,
318 if there are, decide whether we should use a debug temp. */
319 FOR_EACH_IMM_USE_FAST (use_p
, imm_iter
, var
)
321 stmt
= USE_STMT (use_p
);
323 if (!gimple_debug_bind_p (stmt
))
329 if (gimple_debug_bind_get_value (stmt
) != var
)
331 /* Count this as an additional use, so as to make sure we
332 use a temp unless VAR's definition has a SINGLE_RHS that
343 def_stmt
= gsi_stmt (*gsi
);
345 def_stmt
= SSA_NAME_DEF_STMT (var
);
347 /* If we didn't get an insertion point, and the stmt has already
348 been removed, we won't be able to insert the debug bind stmt, so
349 we'll have to drop debug information. */
350 if (gimple_code (def_stmt
) == GIMPLE_PHI
)
352 value
= degenerate_phi_result (def_stmt
);
353 if (value
&& walk_tree (&value
, find_released_ssa_name
, NULL
, NULL
))
355 /* error_mark_node is what fixup_noreturn_call changes PHI arguments
357 else if (value
== error_mark_node
)
360 else if (is_gimple_assign (def_stmt
))
362 bool no_value
= false;
364 if (!dom_info_available_p (CDI_DOMINATORS
))
366 struct walk_stmt_info wi
;
368 memset (&wi
, 0, sizeof (wi
));
370 /* When removing blocks without following reverse dominance
371 order, we may sometimes encounter SSA_NAMEs that have
372 already been released, referenced in other SSA_DEFs that
373 we're about to release. Consider:
382 If we deleted BB X first, propagating the value of w_2
383 won't do us any good. It's too late to recover their
384 original definition of v_1: when it was deleted, it was
385 only referenced in other DEFs, it couldn't possibly know
386 it should have been retained, and propagating every
387 single DEF just in case it might have to be propagated
388 into a DEBUG STMT would probably be too wasteful.
390 When dominator information is not readily available, we
391 check for and accept some loss of debug information. But
392 if it is available, there's no excuse for us to remove
393 blocks in the wrong order, so we don't even check for
394 dead SSA NAMEs. SSA verification shall catch any
396 if ((!gsi
&& !gimple_bb (def_stmt
))
397 || walk_gimple_op (def_stmt
, find_released_ssa_name
, &wi
))
402 value
= gimple_assign_rhs_to_tree (def_stmt
);
407 /* If there's a single use of VAR, and VAR is the entire debug
408 expression (usecount would have been incremented again
409 otherwise), and the definition involves only constants and
410 SSA names, then we can propagate VALUE into this single use,
413 We can also avoid using a temp if VALUE can be shared and
414 propagated into all uses, without generating expressions that
415 wouldn't be valid gimple RHSs.
417 Other cases that would require unsharing or non-gimple RHSs
418 are deferred to a debug temp, although we could avoid temps
419 at the expense of duplication of expressions. */
421 if (CONSTANT_CLASS_P (value
)
422 || gimple_code (def_stmt
) == GIMPLE_PHI
424 && (!gimple_assign_single_p (def_stmt
)
425 || is_gimple_min_invariant (value
)))
426 || is_gimple_reg (value
))
431 tree vexpr
= make_node (DEBUG_EXPR_DECL
);
433 def_temp
= gimple_build_debug_bind (vexpr
,
434 unshare_expr (value
),
437 DECL_ARTIFICIAL (vexpr
) = 1;
438 TREE_TYPE (vexpr
) = TREE_TYPE (value
);
440 DECL_MODE (vexpr
) = DECL_MODE (value
);
442 DECL_MODE (vexpr
) = TYPE_MODE (TREE_TYPE (value
));
445 gsi_insert_before (gsi
, def_temp
, GSI_SAME_STMT
);
448 gimple_stmt_iterator ngsi
= gsi_for_stmt (def_stmt
);
449 gsi_insert_before (&ngsi
, def_temp
, GSI_SAME_STMT
);
456 FOR_EACH_IMM_USE_STMT (stmt
, imm_iter
, var
)
458 if (!gimple_debug_bind_p (stmt
))
463 FOR_EACH_IMM_USE_ON_STMT (use_p
, imm_iter
)
464 /* unshare_expr is not needed here. vexpr is either a
465 SINGLE_RHS, that can be safely shared, some other RHS
466 that was unshared when we found it had a single debug
467 use, or a DEBUG_EXPR_DECL, that can be safely
469 SET_USE (use_p
, unshare_expr (value
));
470 /* If we didn't replace uses with a debug decl fold the
471 resulting expression. Otherwise we end up with invalid IL. */
472 if (TREE_CODE (value
) != DEBUG_EXPR_DECL
)
474 gimple_stmt_iterator gsi
= gsi_for_stmt (stmt
);
475 fold_stmt_inplace (&gsi
);
479 gimple_debug_bind_reset_value (stmt
);
486 /* Insert a DEBUG BIND stmt before STMT for each DEF referenced by
487 other DEBUG stmts, and replace uses of the DEF with the
488 newly-created debug temp. */
491 insert_debug_temps_for_defs (gimple_stmt_iterator
*gsi
)
497 if (!MAY_HAVE_DEBUG_STMTS
)
500 stmt
= gsi_stmt (*gsi
);
502 FOR_EACH_PHI_OR_STMT_DEF (def_p
, stmt
, op_iter
, SSA_OP_DEF
)
504 tree var
= DEF_FROM_PTR (def_p
);
506 if (TREE_CODE (var
) != SSA_NAME
)
509 insert_debug_temp_for_var_def (gsi
, var
);
513 /* Reset all debug stmts that use SSA_NAME(s) defined in STMT. */
516 reset_debug_uses (gimple stmt
)
520 imm_use_iterator imm_iter
;
523 if (!MAY_HAVE_DEBUG_STMTS
)
526 FOR_EACH_PHI_OR_STMT_DEF (def_p
, stmt
, op_iter
, SSA_OP_DEF
)
528 tree var
= DEF_FROM_PTR (def_p
);
530 if (TREE_CODE (var
) != SSA_NAME
)
533 FOR_EACH_IMM_USE_STMT (use_stmt
, imm_iter
, var
)
535 if (!gimple_debug_bind_p (use_stmt
))
538 gimple_debug_bind_reset_value (use_stmt
);
539 update_stmt (use_stmt
);
544 /* Delete SSA DEFs for SSA versions in the TOREMOVE bitmap, removing
545 dominated stmts before their dominators, so that release_ssa_defs
546 stands a chance of propagating DEFs into debug bind stmts. */
549 release_defs_bitset (bitmap toremove
)
554 /* Performing a topological sort is probably overkill, this will
555 most likely run in slightly superlinear time, rather than the
556 pathological quadratic worst case. */
557 while (!bitmap_empty_p (toremove
))
558 EXECUTE_IF_SET_IN_BITMAP (toremove
, 0, j
, bi
)
560 bool remove_now
= true;
561 tree var
= ssa_name (j
);
563 imm_use_iterator uit
;
565 FOR_EACH_IMM_USE_STMT (stmt
, uit
, var
)
570 /* We can't propagate PHI nodes into debug stmts. */
571 if (gimple_code (stmt
) == GIMPLE_PHI
572 || is_gimple_debug (stmt
))
575 /* If we find another definition to remove that uses
576 the one we're looking at, defer the removal of this
577 one, so that it can be propagated into debug stmts
578 after the other is. */
579 FOR_EACH_SSA_DEF_OPERAND (def_p
, stmt
, dit
, SSA_OP_DEF
)
581 tree odef
= DEF_FROM_PTR (def_p
);
583 if (bitmap_bit_p (toremove
, SSA_NAME_VERSION (odef
)))
591 BREAK_FROM_IMM_USE_STMT (uit
);
596 gimple def
= SSA_NAME_DEF_STMT (var
);
597 gimple_stmt_iterator gsi
= gsi_for_stmt (def
);
599 if (gimple_code (def
) == GIMPLE_PHI
)
600 remove_phi_node (&gsi
, true);
603 gsi_remove (&gsi
, true);
607 bitmap_clear_bit (toremove
, j
);
612 /* Return true if SSA_NAME is malformed and mark it visited.
614 IS_VIRTUAL is true if this SSA_NAME was found inside a virtual
618 verify_ssa_name (tree ssa_name
, bool is_virtual
)
620 if (TREE_CODE (ssa_name
) != SSA_NAME
)
622 error ("expected an SSA_NAME object");
626 if (SSA_NAME_IN_FREE_LIST (ssa_name
))
628 error ("found an SSA_NAME that had been released into the free pool");
632 if (SSA_NAME_VAR (ssa_name
) != NULL_TREE
633 && TREE_TYPE (ssa_name
) != TREE_TYPE (SSA_NAME_VAR (ssa_name
)))
635 error ("type mismatch between an SSA_NAME and its symbol");
639 if (is_virtual
&& !virtual_operand_p (ssa_name
))
641 error ("found a virtual definition for a GIMPLE register");
645 if (is_virtual
&& SSA_NAME_VAR (ssa_name
) != gimple_vop (cfun
))
647 error ("virtual SSA name for non-VOP decl");
651 if (!is_virtual
&& virtual_operand_p (ssa_name
))
653 error ("found a real definition for a non-register");
657 if (SSA_NAME_IS_DEFAULT_DEF (ssa_name
)
658 && !gimple_nop_p (SSA_NAME_DEF_STMT (ssa_name
)))
660 error ("found a default name with a non-empty defining statement");
668 /* Return true if the definition of SSA_NAME at block BB is malformed.
670 STMT is the statement where SSA_NAME is created.
672 DEFINITION_BLOCK is an array of basic blocks indexed by SSA_NAME
673 version numbers. If DEFINITION_BLOCK[SSA_NAME_VERSION] is set,
674 it means that the block in that array slot contains the
675 definition of SSA_NAME.
677 IS_VIRTUAL is true if SSA_NAME is created by a VDEF. */
680 verify_def (basic_block bb
, basic_block
*definition_block
, tree ssa_name
,
681 gimple stmt
, bool is_virtual
)
683 if (verify_ssa_name (ssa_name
, is_virtual
))
686 if (SSA_NAME_VAR (ssa_name
)
687 && 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
, virtual_operand_p (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
, virtual_operand_p (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
, virtual_operand_p (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 DECL_UID in both trees are equal. */
1052 uid_ssaname_map_eq (const void *va
, const void *vb
)
1054 const_tree a
= (const_tree
) va
;
1055 const_tree b
= (const_tree
) vb
;
1056 return (a
->ssa_name
.var
->decl_minimal
.uid
== b
->ssa_name
.var
->decl_minimal
.uid
);
1059 /* Hash a tree in a uid_decl_map. */
1062 uid_ssaname_map_hash (const void *item
)
1064 return ((const_tree
)item
)->ssa_name
.var
->decl_minimal
.uid
;
1068 /* Initialize global DFA and SSA structures. */
1071 init_tree_ssa (struct function
*fn
)
1073 fn
->gimple_df
= ggc_alloc_cleared_gimple_df ();
1074 fn
->gimple_df
->default_defs
= htab_create_ggc (20, uid_ssaname_map_hash
,
1075 uid_ssaname_map_eq
, NULL
);
1076 pt_solution_reset (&fn
->gimple_df
->escaped
);
1077 init_ssanames (fn
, 0);
1080 /* Do the actions required to initialize internal data structures used
1081 in tree-ssa optimization passes. */
1084 execute_init_datastructures (void)
1086 /* Allocate hash tables, arrays and other structures. */
1087 init_tree_ssa (cfun
);
1093 const pass_data pass_data_init_datastructures
=
1095 GIMPLE_PASS
, /* type */
1096 "*init_datastructures", /* name */
1097 OPTGROUP_NONE
, /* optinfo_flags */
1098 false, /* has_gate */
1099 true, /* has_execute */
1100 TV_NONE
, /* tv_id */
1101 PROP_cfg
, /* properties_required */
1102 0, /* properties_provided */
1103 0, /* properties_destroyed */
1104 0, /* todo_flags_start */
1105 0, /* todo_flags_finish */
1108 class pass_init_datastructures
: public gimple_opt_pass
1111 pass_init_datastructures(gcc::context
*ctxt
)
1112 : gimple_opt_pass(pass_data_init_datastructures
, ctxt
)
1115 /* opt_pass methods: */
1116 unsigned int execute () { return execute_init_datastructures (); }
1118 }; // class pass_init_datastructures
1123 make_pass_init_datastructures (gcc::context
*ctxt
)
1125 return new pass_init_datastructures (ctxt
);
1128 /* Deallocate memory associated with SSA data structures for FNDECL. */
1131 delete_tree_ssa (void)
1135 /* We no longer maintain the SSA operand cache at this point. */
1136 if (ssa_operands_active (cfun
))
1137 fini_ssa_operands ();
1139 htab_delete (cfun
->gimple_df
->default_defs
);
1140 cfun
->gimple_df
->default_defs
= NULL
;
1141 pt_solution_reset (&cfun
->gimple_df
->escaped
);
1142 if (cfun
->gimple_df
->decls_to_pointers
!= NULL
)
1143 pointer_map_destroy (cfun
->gimple_df
->decls_to_pointers
);
1144 cfun
->gimple_df
->decls_to_pointers
= NULL
;
1145 cfun
->gimple_df
->modified_noreturn_calls
= NULL
;
1146 cfun
->gimple_df
= NULL
;
1148 /* We no longer need the edge variable maps. */
1149 redirect_edge_var_map_destroy ();
1152 /* Return true if the conversion from INNER_TYPE to OUTER_TYPE is a
1153 useless type conversion, otherwise return false.
1155 This function implicitly defines the middle-end type system. With
1156 the notion of 'a < b' meaning that useless_type_conversion_p (a, b)
1157 holds and 'a > b' meaning that useless_type_conversion_p (b, a) holds,
1158 the following invariants shall be fulfilled:
1160 1) useless_type_conversion_p is transitive.
1161 If a < b and b < c then a < c.
1163 2) useless_type_conversion_p is not symmetric.
1164 From a < b does not follow a > b.
1166 3) Types define the available set of operations applicable to values.
1167 A type conversion is useless if the operations for the target type
1168 is a subset of the operations for the source type. For example
1169 casts to void* are useless, casts from void* are not (void* can't
1170 be dereferenced or offsetted, but copied, hence its set of operations
1171 is a strict subset of that of all other data pointer types). Casts
1172 to const T* are useless (can't be written to), casts from const T*
1176 useless_type_conversion_p (tree outer_type
, tree inner_type
)
1178 /* Do the following before stripping toplevel qualifiers. */
1179 if (POINTER_TYPE_P (inner_type
)
1180 && POINTER_TYPE_P (outer_type
))
1182 /* Do not lose casts between pointers to different address spaces. */
1183 if (TYPE_ADDR_SPACE (TREE_TYPE (outer_type
))
1184 != TYPE_ADDR_SPACE (TREE_TYPE (inner_type
)))
1188 /* From now on qualifiers on value types do not matter. */
1189 inner_type
= TYPE_MAIN_VARIANT (inner_type
);
1190 outer_type
= TYPE_MAIN_VARIANT (outer_type
);
1192 if (inner_type
== outer_type
)
1195 /* If we know the canonical types, compare them. */
1196 if (TYPE_CANONICAL (inner_type
)
1197 && TYPE_CANONICAL (inner_type
) == TYPE_CANONICAL (outer_type
))
1200 /* Changes in machine mode are never useless conversions unless we
1201 deal with aggregate types in which case we defer to later checks. */
1202 if (TYPE_MODE (inner_type
) != TYPE_MODE (outer_type
)
1203 && !AGGREGATE_TYPE_P (inner_type
))
1206 /* If both the inner and outer types are integral types, then the
1207 conversion is not necessary if they have the same mode and
1208 signedness and precision, and both or neither are boolean. */
1209 if (INTEGRAL_TYPE_P (inner_type
)
1210 && INTEGRAL_TYPE_P (outer_type
))
1212 /* Preserve changes in signedness or precision. */
1213 if (TYPE_UNSIGNED (inner_type
) != TYPE_UNSIGNED (outer_type
)
1214 || TYPE_PRECISION (inner_type
) != TYPE_PRECISION (outer_type
))
1217 /* Preserve conversions to/from BOOLEAN_TYPE if types are not
1218 of precision one. */
1219 if (((TREE_CODE (inner_type
) == BOOLEAN_TYPE
)
1220 != (TREE_CODE (outer_type
) == BOOLEAN_TYPE
))
1221 && TYPE_PRECISION (outer_type
) != 1)
1224 /* We don't need to preserve changes in the types minimum or
1225 maximum value in general as these do not generate code
1226 unless the types precisions are different. */
1230 /* Scalar floating point types with the same mode are compatible. */
1231 else if (SCALAR_FLOAT_TYPE_P (inner_type
)
1232 && SCALAR_FLOAT_TYPE_P (outer_type
))
1235 /* Fixed point types with the same mode are compatible. */
1236 else if (FIXED_POINT_TYPE_P (inner_type
)
1237 && FIXED_POINT_TYPE_P (outer_type
))
1240 /* We need to take special care recursing to pointed-to types. */
1241 else if (POINTER_TYPE_P (inner_type
)
1242 && POINTER_TYPE_P (outer_type
))
1244 /* Do not lose casts to function pointer types. */
1245 if ((TREE_CODE (TREE_TYPE (outer_type
)) == FUNCTION_TYPE
1246 || TREE_CODE (TREE_TYPE (outer_type
)) == METHOD_TYPE
)
1247 && !(TREE_CODE (TREE_TYPE (inner_type
)) == FUNCTION_TYPE
1248 || TREE_CODE (TREE_TYPE (inner_type
)) == METHOD_TYPE
))
1251 /* We do not care for const qualification of the pointed-to types
1252 as const qualification has no semantic value to the middle-end. */
1254 /* Otherwise pointers/references are equivalent. */
1258 /* Recurse for complex types. */
1259 else if (TREE_CODE (inner_type
) == COMPLEX_TYPE
1260 && TREE_CODE (outer_type
) == COMPLEX_TYPE
)
1261 return useless_type_conversion_p (TREE_TYPE (outer_type
),
1262 TREE_TYPE (inner_type
));
1264 /* Recurse for vector types with the same number of subparts. */
1265 else if (TREE_CODE (inner_type
) == VECTOR_TYPE
1266 && TREE_CODE (outer_type
) == VECTOR_TYPE
1267 && TYPE_PRECISION (inner_type
) == TYPE_PRECISION (outer_type
))
1268 return useless_type_conversion_p (TREE_TYPE (outer_type
),
1269 TREE_TYPE (inner_type
));
1271 else if (TREE_CODE (inner_type
) == ARRAY_TYPE
1272 && TREE_CODE (outer_type
) == ARRAY_TYPE
)
1274 /* Preserve string attributes. */
1275 if (TYPE_STRING_FLAG (inner_type
) != TYPE_STRING_FLAG (outer_type
))
1278 /* Conversions from array types with unknown extent to
1279 array types with known extent are not useless. */
1280 if (!TYPE_DOMAIN (inner_type
)
1281 && TYPE_DOMAIN (outer_type
))
1284 /* Nor are conversions from array types with non-constant size to
1285 array types with constant size or to different size. */
1286 if (TYPE_SIZE (outer_type
)
1287 && TREE_CODE (TYPE_SIZE (outer_type
)) == INTEGER_CST
1288 && (!TYPE_SIZE (inner_type
)
1289 || TREE_CODE (TYPE_SIZE (inner_type
)) != INTEGER_CST
1290 || !tree_int_cst_equal (TYPE_SIZE (outer_type
),
1291 TYPE_SIZE (inner_type
))))
1294 /* Check conversions between arrays with partially known extents.
1295 If the array min/max values are constant they have to match.
1296 Otherwise allow conversions to unknown and variable extents.
1297 In particular this declares conversions that may change the
1298 mode to BLKmode as useless. */
1299 if (TYPE_DOMAIN (inner_type
)
1300 && TYPE_DOMAIN (outer_type
)
1301 && TYPE_DOMAIN (inner_type
) != TYPE_DOMAIN (outer_type
))
1303 tree inner_min
= TYPE_MIN_VALUE (TYPE_DOMAIN (inner_type
));
1304 tree outer_min
= TYPE_MIN_VALUE (TYPE_DOMAIN (outer_type
));
1305 tree inner_max
= TYPE_MAX_VALUE (TYPE_DOMAIN (inner_type
));
1306 tree outer_max
= TYPE_MAX_VALUE (TYPE_DOMAIN (outer_type
));
1308 /* After gimplification a variable min/max value carries no
1309 additional information compared to a NULL value. All that
1310 matters has been lowered to be part of the IL. */
1311 if (inner_min
&& TREE_CODE (inner_min
) != INTEGER_CST
)
1312 inner_min
= NULL_TREE
;
1313 if (outer_min
&& TREE_CODE (outer_min
) != INTEGER_CST
)
1314 outer_min
= NULL_TREE
;
1315 if (inner_max
&& TREE_CODE (inner_max
) != INTEGER_CST
)
1316 inner_max
= NULL_TREE
;
1317 if (outer_max
&& TREE_CODE (outer_max
) != INTEGER_CST
)
1318 outer_max
= NULL_TREE
;
1320 /* Conversions NULL / variable <- cst are useless, but not
1321 the other way around. */
1324 || !tree_int_cst_equal (inner_min
, outer_min
)))
1328 || !tree_int_cst_equal (inner_max
, outer_max
)))
1332 /* Recurse on the element check. */
1333 return useless_type_conversion_p (TREE_TYPE (outer_type
),
1334 TREE_TYPE (inner_type
));
1337 else if ((TREE_CODE (inner_type
) == FUNCTION_TYPE
1338 || TREE_CODE (inner_type
) == METHOD_TYPE
)
1339 && TREE_CODE (inner_type
) == TREE_CODE (outer_type
))
1341 tree outer_parm
, inner_parm
;
1343 /* If the return types are not compatible bail out. */
1344 if (!useless_type_conversion_p (TREE_TYPE (outer_type
),
1345 TREE_TYPE (inner_type
)))
1348 /* Method types should belong to a compatible base class. */
1349 if (TREE_CODE (inner_type
) == METHOD_TYPE
1350 && !useless_type_conversion_p (TYPE_METHOD_BASETYPE (outer_type
),
1351 TYPE_METHOD_BASETYPE (inner_type
)))
1354 /* A conversion to an unprototyped argument list is ok. */
1355 if (!prototype_p (outer_type
))
1358 /* If the unqualified argument types are compatible the conversion
1360 if (TYPE_ARG_TYPES (outer_type
) == TYPE_ARG_TYPES (inner_type
))
1363 for (outer_parm
= TYPE_ARG_TYPES (outer_type
),
1364 inner_parm
= TYPE_ARG_TYPES (inner_type
);
1365 outer_parm
&& inner_parm
;
1366 outer_parm
= TREE_CHAIN (outer_parm
),
1367 inner_parm
= TREE_CHAIN (inner_parm
))
1368 if (!useless_type_conversion_p
1369 (TYPE_MAIN_VARIANT (TREE_VALUE (outer_parm
)),
1370 TYPE_MAIN_VARIANT (TREE_VALUE (inner_parm
))))
1373 /* If there is a mismatch in the number of arguments the functions
1374 are not compatible. */
1375 if (outer_parm
|| inner_parm
)
1378 /* Defer to the target if necessary. */
1379 if (TYPE_ATTRIBUTES (inner_type
) || TYPE_ATTRIBUTES (outer_type
))
1380 return comp_type_attributes (outer_type
, inner_type
) != 0;
1385 /* For aggregates we rely on TYPE_CANONICAL exclusively and require
1386 explicit conversions for types involving to be structurally
1388 else if (AGGREGATE_TYPE_P (inner_type
)
1389 && TREE_CODE (inner_type
) == TREE_CODE (outer_type
))
1395 /* Return true if a conversion from either type of TYPE1 and TYPE2
1396 to the other is not required. Otherwise return false. */
1399 types_compatible_p (tree type1
, tree type2
)
1401 return (type1
== type2
1402 || (useless_type_conversion_p (type1
, type2
)
1403 && useless_type_conversion_p (type2
, type1
)));
1406 /* Return true if EXPR is a useless type conversion, otherwise return
1410 tree_ssa_useless_type_conversion (tree expr
)
1412 /* If we have an assignment that merely uses a NOP_EXPR to change
1413 the top of the RHS to the type of the LHS and the type conversion
1414 is "safe", then strip away the type conversion so that we can
1415 enter LHS = RHS into the const_and_copies table. */
1416 if (CONVERT_EXPR_P (expr
)
1417 || TREE_CODE (expr
) == VIEW_CONVERT_EXPR
1418 || TREE_CODE (expr
) == NON_LVALUE_EXPR
)
1419 return useless_type_conversion_p
1421 TREE_TYPE (TREE_OPERAND (expr
, 0)));
1426 /* Strip conversions from EXP according to
1427 tree_ssa_useless_type_conversion and return the resulting
1431 tree_ssa_strip_useless_type_conversions (tree exp
)
1433 while (tree_ssa_useless_type_conversion (exp
))
1434 exp
= TREE_OPERAND (exp
, 0);
1439 /* Internal helper for walk_use_def_chains. VAR, FN and DATA are as
1440 described in walk_use_def_chains.
1442 VISITED is a pointer set used to mark visited SSA_NAMEs to avoid
1443 infinite loops. We used to have a bitmap for this to just mark
1444 SSA versions we had visited. But non-sparse bitmaps are way too
1445 expensive, while sparse bitmaps may cause quadratic behavior.
1447 IS_DFS is true if the caller wants to perform a depth-first search
1448 when visiting PHI nodes. A DFS will visit each PHI argument and
1449 call FN after each one. Otherwise, all the arguments are
1450 visited first and then FN is called with each of the visited
1451 arguments in a separate pass. */
1454 walk_use_def_chains_1 (tree var
, walk_use_def_chains_fn fn
, void *data
,
1455 struct pointer_set_t
*visited
, bool is_dfs
)
1459 if (pointer_set_insert (visited
, var
))
1462 def_stmt
= SSA_NAME_DEF_STMT (var
);
1464 if (gimple_code (def_stmt
) != GIMPLE_PHI
)
1466 /* If we reached the end of the use-def chain, call FN. */
1467 return fn (var
, def_stmt
, data
);
1473 /* When doing a breadth-first search, call FN before following the
1474 use-def links for each argument. */
1476 for (i
= 0; i
< gimple_phi_num_args (def_stmt
); i
++)
1477 if (fn (gimple_phi_arg_def (def_stmt
, i
), def_stmt
, data
))
1480 /* Follow use-def links out of each PHI argument. */
1481 for (i
= 0; i
< gimple_phi_num_args (def_stmt
); i
++)
1483 tree arg
= gimple_phi_arg_def (def_stmt
, i
);
1485 /* ARG may be NULL for newly introduced PHI nodes. */
1487 && TREE_CODE (arg
) == SSA_NAME
1488 && walk_use_def_chains_1 (arg
, fn
, data
, visited
, is_dfs
))
1492 /* When doing a depth-first search, call FN after following the
1493 use-def links for each argument. */
1495 for (i
= 0; i
< gimple_phi_num_args (def_stmt
); i
++)
1496 if (fn (gimple_phi_arg_def (def_stmt
, i
), def_stmt
, data
))
1505 /* Walk use-def chains starting at the SSA variable VAR. Call
1506 function FN at each reaching definition found. FN takes three
1507 arguments: VAR, its defining statement (DEF_STMT) and a generic
1508 pointer to whatever state information that FN may want to maintain
1509 (DATA). FN is able to stop the walk by returning true, otherwise
1510 in order to continue the walk, FN should return false.
1512 Note, that if DEF_STMT is a PHI node, the semantics are slightly
1513 different. The first argument to FN is no longer the original
1514 variable VAR, but the PHI argument currently being examined. If FN
1515 wants to get at VAR, it should call PHI_RESULT (PHI).
1517 If IS_DFS is true, this function will:
1519 1- walk the use-def chains for all the PHI arguments, and,
1520 2- call (*FN) (ARG, PHI, DATA) on all the PHI arguments.
1522 If IS_DFS is false, the two steps above are done in reverse order
1523 (i.e., a breadth-first search). */
1526 walk_use_def_chains (tree var
, walk_use_def_chains_fn fn
, void *data
,
1531 gcc_assert (TREE_CODE (var
) == SSA_NAME
);
1533 def_stmt
= SSA_NAME_DEF_STMT (var
);
1535 /* We only need to recurse if the reaching definition comes from a PHI
1537 if (gimple_code (def_stmt
) != GIMPLE_PHI
)
1538 (*fn
) (var
, def_stmt
, data
);
1541 struct pointer_set_t
*visited
= pointer_set_create ();
1542 walk_use_def_chains_1 (var
, fn
, data
, visited
, is_dfs
);
1543 pointer_set_destroy (visited
);
1548 /* Emit warnings for uninitialized variables. This is done in two passes.
1550 The first pass notices real uses of SSA names with undefined values.
1551 Such uses are unconditionally uninitialized, and we can be certain that
1552 such a use is a mistake. This pass is run before most optimizations,
1553 so that we catch as many as we can.
1555 The second pass follows PHI nodes to find uses that are potentially
1556 uninitialized. In this case we can't necessarily prove that the use
1557 is really uninitialized. This pass is run after most optimizations,
1558 so that we thread as many jumps and possible, and delete as much dead
1559 code as possible, in order to reduce false positives. We also look
1560 again for plain uninitialized variables, since optimization may have
1561 changed conditionally uninitialized to unconditionally uninitialized. */
1563 /* Emit a warning for EXPR based on variable VAR at the point in the
1564 program T, an SSA_NAME, is used being uninitialized. The exact
1565 warning text is in MSGID and LOCUS may contain a location or be null.
1566 WC is the warning code. */
1569 warn_uninit (enum opt_code wc
, tree t
,
1570 tree expr
, tree var
, const char *gmsgid
, void *data
)
1572 gimple context
= (gimple
) data
;
1573 location_t location
, cfun_loc
;
1574 expanded_location xloc
, floc
;
1576 if (!ssa_undefined_value_p (t
))
1579 /* TREE_NO_WARNING either means we already warned, or the front end
1580 wishes to suppress the warning. */
1582 && (gimple_no_warning_p (context
)
1583 || (gimple_assign_single_p (context
)
1584 && TREE_NO_WARNING (gimple_assign_rhs1 (context
)))))
1585 || TREE_NO_WARNING (expr
))
1588 location
= (context
!= NULL
&& gimple_has_location (context
))
1589 ? gimple_location (context
)
1590 : DECL_SOURCE_LOCATION (var
);
1591 location
= linemap_resolve_location (line_table
, location
,
1592 LRK_SPELLING_LOCATION
,
1594 cfun_loc
= DECL_SOURCE_LOCATION (cfun
->decl
);
1595 xloc
= expand_location (location
);
1596 floc
= expand_location (cfun_loc
);
1597 if (warning_at (location
, wc
, gmsgid
, expr
))
1599 TREE_NO_WARNING (expr
) = 1;
1601 if (location
== DECL_SOURCE_LOCATION (var
))
1603 if (xloc
.file
!= floc
.file
1604 || linemap_location_before_p (line_table
,
1606 || linemap_location_before_p (line_table
,
1607 cfun
->function_end_locus
,
1609 inform (DECL_SOURCE_LOCATION (var
), "%qD was declared here", var
);
1614 warn_uninitialized_vars (bool warn_possibly_uninitialized
)
1616 gimple_stmt_iterator gsi
;
1621 bool always_executed
= dominated_by_p (CDI_POST_DOMINATORS
,
1622 single_succ (ENTRY_BLOCK_PTR
), bb
);
1623 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1625 gimple stmt
= gsi_stmt (gsi
);
1626 use_operand_p use_p
;
1627 ssa_op_iter op_iter
;
1630 if (is_gimple_debug (stmt
))
1633 /* We only do data flow with SSA_NAMEs, so that's all we
1635 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, op_iter
, SSA_OP_USE
)
1637 use
= USE_FROM_PTR (use_p
);
1638 if (always_executed
)
1639 warn_uninit (OPT_Wuninitialized
, use
,
1640 SSA_NAME_VAR (use
), SSA_NAME_VAR (use
),
1641 "%qD is used uninitialized in this function",
1643 else if (warn_possibly_uninitialized
)
1644 warn_uninit (OPT_Wmaybe_uninitialized
, use
,
1645 SSA_NAME_VAR (use
), SSA_NAME_VAR (use
),
1646 "%qD may be used uninitialized in this function",
1650 /* For memory the only cheap thing we can do is see if we
1651 have a use of the default def of the virtual operand.
1652 ??? Note that at -O0 we do not have virtual operands.
1653 ??? Not so cheap would be to use the alias oracle via
1654 walk_aliased_vdefs, if we don't find any aliasing vdef
1655 warn as is-used-uninitialized, if we don't find an aliasing
1656 vdef that kills our use (stmt_kills_ref_p), warn as
1657 may-be-used-uninitialized. But this walk is quadratic and
1658 so must be limited which means we would miss warning
1660 use
= gimple_vuse (stmt
);
1662 && gimple_assign_single_p (stmt
)
1663 && !gimple_vdef (stmt
)
1664 && SSA_NAME_IS_DEFAULT_DEF (use
))
1666 tree rhs
= gimple_assign_rhs1 (stmt
);
1667 tree base
= get_base_address (rhs
);
1669 /* Do not warn if it can be initialized outside this function. */
1670 if (TREE_CODE (base
) != VAR_DECL
1671 || DECL_HARD_REGISTER (base
)
1672 || is_global_var (base
))
1675 if (always_executed
)
1676 warn_uninit (OPT_Wuninitialized
, use
,
1677 gimple_assign_rhs1 (stmt
), base
,
1678 "%qE is used uninitialized in this function",
1680 else if (warn_possibly_uninitialized
)
1681 warn_uninit (OPT_Wmaybe_uninitialized
, use
,
1682 gimple_assign_rhs1 (stmt
), base
,
1683 "%qE may be used uninitialized in this function",
1693 execute_early_warn_uninitialized (void)
1695 /* Currently, this pass runs always but
1696 execute_late_warn_uninitialized only runs with optimization. With
1697 optimization we want to warn about possible uninitialized as late
1698 as possible, thus don't do it here. However, without
1699 optimization we need to warn here about "may be uninitialized".
1701 calculate_dominance_info (CDI_POST_DOMINATORS
);
1703 warn_uninitialized_vars (/*warn_possibly_uninitialized=*/!optimize
);
1705 /* Post-dominator information can not be reliably updated. Free it
1708 free_dominance_info (CDI_POST_DOMINATORS
);
1713 gate_warn_uninitialized (void)
1715 return warn_uninitialized
!= 0;
1720 const pass_data pass_data_early_warn_uninitialized
=
1722 GIMPLE_PASS
, /* type */
1723 "*early_warn_uninitialized", /* name */
1724 OPTGROUP_NONE
, /* optinfo_flags */
1725 true, /* has_gate */
1726 true, /* has_execute */
1727 TV_TREE_UNINIT
, /* tv_id */
1728 PROP_ssa
, /* properties_required */
1729 0, /* properties_provided */
1730 0, /* properties_destroyed */
1731 0, /* todo_flags_start */
1732 0, /* todo_flags_finish */
1735 class pass_early_warn_uninitialized
: public gimple_opt_pass
1738 pass_early_warn_uninitialized(gcc::context
*ctxt
)
1739 : gimple_opt_pass(pass_data_early_warn_uninitialized
, ctxt
)
1742 /* opt_pass methods: */
1743 bool gate () { return gate_warn_uninitialized (); }
1744 unsigned int execute () { return execute_early_warn_uninitialized (); }
1746 }; // class pass_early_warn_uninitialized
1751 make_pass_early_warn_uninitialized (gcc::context
*ctxt
)
1753 return new pass_early_warn_uninitialized (ctxt
);
1757 /* If necessary, rewrite the base of the reference tree *TP from
1758 a MEM_REF to a plain or converted symbol. */
1761 maybe_rewrite_mem_ref_base (tree
*tp
, bitmap suitable_for_renaming
)
1765 while (handled_component_p (*tp
))
1766 tp
= &TREE_OPERAND (*tp
, 0);
1767 if (TREE_CODE (*tp
) == MEM_REF
1768 && TREE_CODE (TREE_OPERAND (*tp
, 0)) == ADDR_EXPR
1769 && (sym
= TREE_OPERAND (TREE_OPERAND (*tp
, 0), 0))
1771 && !TREE_ADDRESSABLE (sym
)
1772 && bitmap_bit_p (suitable_for_renaming
, DECL_UID (sym
)))
1774 if (TREE_CODE (TREE_TYPE (sym
)) == VECTOR_TYPE
1775 && useless_type_conversion_p (TREE_TYPE (*tp
),
1776 TREE_TYPE (TREE_TYPE (sym
)))
1777 && multiple_of_p (sizetype
, TREE_OPERAND (*tp
, 1),
1778 TYPE_SIZE_UNIT (TREE_TYPE (*tp
))))
1780 *tp
= build3 (BIT_FIELD_REF
, TREE_TYPE (*tp
), sym
,
1781 TYPE_SIZE (TREE_TYPE (*tp
)),
1782 int_const_binop (MULT_EXPR
,
1783 bitsize_int (BITS_PER_UNIT
),
1784 TREE_OPERAND (*tp
, 1)));
1786 else if (TREE_CODE (TREE_TYPE (sym
)) == COMPLEX_TYPE
1787 && useless_type_conversion_p (TREE_TYPE (*tp
),
1788 TREE_TYPE (TREE_TYPE (sym
))))
1790 *tp
= build1 (integer_zerop (TREE_OPERAND (*tp
, 1))
1791 ? REALPART_EXPR
: IMAGPART_EXPR
,
1792 TREE_TYPE (*tp
), sym
);
1794 else if (integer_zerop (TREE_OPERAND (*tp
, 1)))
1796 if (!useless_type_conversion_p (TREE_TYPE (*tp
),
1798 *tp
= build1 (VIEW_CONVERT_EXPR
,
1799 TREE_TYPE (*tp
), sym
);
1806 /* For a tree REF return its base if it is the base of a MEM_REF
1807 that cannot be rewritten into SSA form. Otherwise return NULL_TREE. */
1810 non_rewritable_mem_ref_base (tree ref
)
1814 /* A plain decl does not need it set. */
1818 while (handled_component_p (base
))
1819 base
= TREE_OPERAND (base
, 0);
1821 /* But watch out for MEM_REFs we cannot lower to a
1822 VIEW_CONVERT_EXPR or a BIT_FIELD_REF. */
1823 if (TREE_CODE (base
) == MEM_REF
1824 && TREE_CODE (TREE_OPERAND (base
, 0)) == ADDR_EXPR
)
1826 tree decl
= TREE_OPERAND (TREE_OPERAND (base
, 0), 0);
1827 if ((TREE_CODE (TREE_TYPE (decl
)) == VECTOR_TYPE
1828 || TREE_CODE (TREE_TYPE (decl
)) == COMPLEX_TYPE
)
1829 && useless_type_conversion_p (TREE_TYPE (base
),
1830 TREE_TYPE (TREE_TYPE (decl
)))
1831 && mem_ref_offset (base
).fits_uhwi ()
1832 && tree_to_double_int (TYPE_SIZE_UNIT (TREE_TYPE (decl
)))
1833 .ugt (mem_ref_offset (base
))
1834 && multiple_of_p (sizetype
, TREE_OPERAND (base
, 1),
1835 TYPE_SIZE_UNIT (TREE_TYPE (base
))))
1838 && (!integer_zerop (TREE_OPERAND (base
, 1))
1839 || (DECL_SIZE (decl
)
1840 != TYPE_SIZE (TREE_TYPE (base
)))
1841 || TREE_THIS_VOLATILE (decl
) != TREE_THIS_VOLATILE (base
)))
1848 /* For an lvalue tree LHS return true if it cannot be rewritten into SSA form.
1849 Otherwise return true. */
1852 non_rewritable_lvalue_p (tree lhs
)
1854 /* A plain decl is always rewritable. */
1858 /* A decl that is wrapped inside a MEM-REF that covers
1859 it full is also rewritable.
1860 ??? The following could be relaxed allowing component
1861 references that do not change the access size. */
1862 if (TREE_CODE (lhs
) == MEM_REF
1863 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == ADDR_EXPR
1864 && integer_zerop (TREE_OPERAND (lhs
, 1)))
1866 tree decl
= TREE_OPERAND (TREE_OPERAND (lhs
, 0), 0);
1868 && DECL_SIZE (decl
) == TYPE_SIZE (TREE_TYPE (lhs
))
1869 && (TREE_THIS_VOLATILE (decl
) == TREE_THIS_VOLATILE (lhs
)))
1876 /* When possible, clear TREE_ADDRESSABLE bit or set DECL_GIMPLE_REG_P bit and
1877 mark the variable VAR for conversion into SSA. Return true when updating
1878 stmts is required. */
1881 maybe_optimize_var (tree var
, bitmap addresses_taken
, bitmap not_reg_needs
,
1882 bitmap suitable_for_renaming
)
1884 /* Global Variables, result decls cannot be changed. */
1885 if (is_global_var (var
)
1886 || TREE_CODE (var
) == RESULT_DECL
1887 || bitmap_bit_p (addresses_taken
, DECL_UID (var
)))
1890 if (TREE_ADDRESSABLE (var
)
1891 /* Do not change TREE_ADDRESSABLE if we need to preserve var as
1892 a non-register. Otherwise we are confused and forget to
1893 add virtual operands for it. */
1894 && (!is_gimple_reg_type (TREE_TYPE (var
))
1895 || TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
1896 || TREE_CODE (TREE_TYPE (var
)) == COMPLEX_TYPE
1897 || !bitmap_bit_p (not_reg_needs
, DECL_UID (var
))))
1899 TREE_ADDRESSABLE (var
) = 0;
1900 if (is_gimple_reg (var
))
1901 bitmap_set_bit (suitable_for_renaming
, DECL_UID (var
));
1904 fprintf (dump_file
, "No longer having address taken: ");
1905 print_generic_expr (dump_file
, var
, 0);
1906 fprintf (dump_file
, "\n");
1910 if (!DECL_GIMPLE_REG_P (var
)
1911 && !bitmap_bit_p (not_reg_needs
, DECL_UID (var
))
1912 && (TREE_CODE (TREE_TYPE (var
)) == COMPLEX_TYPE
1913 || TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
)
1914 && !TREE_THIS_VOLATILE (var
)
1915 && (TREE_CODE (var
) != VAR_DECL
|| !DECL_HARD_REGISTER (var
)))
1917 DECL_GIMPLE_REG_P (var
) = 1;
1918 bitmap_set_bit (suitable_for_renaming
, DECL_UID (var
));
1921 fprintf (dump_file
, "Now a gimple register: ");
1922 print_generic_expr (dump_file
, var
, 0);
1923 fprintf (dump_file
, "\n");
1928 /* Compute TREE_ADDRESSABLE and DECL_GIMPLE_REG_P for local variables. */
1931 execute_update_addresses_taken (void)
1933 gimple_stmt_iterator gsi
;
1935 bitmap addresses_taken
= BITMAP_ALLOC (NULL
);
1936 bitmap not_reg_needs
= BITMAP_ALLOC (NULL
);
1937 bitmap suitable_for_renaming
= BITMAP_ALLOC (NULL
);
1941 timevar_push (TV_ADDRESS_TAKEN
);
1943 /* Collect into ADDRESSES_TAKEN all variables whose address is taken within
1944 the function body. */
1947 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1949 gimple stmt
= gsi_stmt (gsi
);
1950 enum gimple_code code
= gimple_code (stmt
);
1953 /* Note all addresses taken by the stmt. */
1954 gimple_ior_addresses_taken (addresses_taken
, stmt
);
1956 /* If we have a call or an assignment, see if the lhs contains
1957 a local decl that requires not to be a gimple register. */
1958 if (code
== GIMPLE_ASSIGN
|| code
== GIMPLE_CALL
)
1960 tree lhs
= gimple_get_lhs (stmt
);
1962 && TREE_CODE (lhs
) != SSA_NAME
1963 && non_rewritable_lvalue_p (lhs
))
1965 decl
= get_base_address (lhs
);
1967 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1971 if (gimple_assign_single_p (stmt
))
1973 tree rhs
= gimple_assign_rhs1 (stmt
);
1974 if ((decl
= non_rewritable_mem_ref_base (rhs
)))
1975 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1978 else if (code
== GIMPLE_CALL
)
1980 for (i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
1982 tree arg
= gimple_call_arg (stmt
, i
);
1983 if ((decl
= non_rewritable_mem_ref_base (arg
)))
1984 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1988 else if (code
== GIMPLE_ASM
)
1990 for (i
= 0; i
< gimple_asm_noutputs (stmt
); ++i
)
1992 tree link
= gimple_asm_output_op (stmt
, i
);
1993 tree lhs
= TREE_VALUE (link
);
1994 if (TREE_CODE (lhs
) != SSA_NAME
)
1996 decl
= get_base_address (lhs
);
1998 && (non_rewritable_lvalue_p (lhs
)
1999 /* We cannot move required conversions from
2000 the lhs to the rhs in asm statements, so
2001 require we do not need any. */
2002 || !useless_type_conversion_p
2003 (TREE_TYPE (lhs
), TREE_TYPE (decl
))))
2004 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
2007 for (i
= 0; i
< gimple_asm_ninputs (stmt
); ++i
)
2009 tree link
= gimple_asm_input_op (stmt
, i
);
2010 if ((decl
= non_rewritable_mem_ref_base (TREE_VALUE (link
))))
2011 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
2016 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
2019 gimple phi
= gsi_stmt (gsi
);
2021 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
2023 tree op
= PHI_ARG_DEF (phi
, i
), var
;
2024 if (TREE_CODE (op
) == ADDR_EXPR
2025 && (var
= get_base_address (TREE_OPERAND (op
, 0))) != NULL
2027 bitmap_set_bit (addresses_taken
, DECL_UID (var
));
2032 /* We cannot iterate over all referenced vars because that can contain
2033 unused vars from BLOCK trees, which causes code generation differences
2035 for (var
= DECL_ARGUMENTS (cfun
->decl
); var
; var
= DECL_CHAIN (var
))
2036 maybe_optimize_var (var
, addresses_taken
, not_reg_needs
,
2037 suitable_for_renaming
);
2039 FOR_EACH_VEC_SAFE_ELT (cfun
->local_decls
, i
, var
)
2040 maybe_optimize_var (var
, addresses_taken
, not_reg_needs
,
2041 suitable_for_renaming
);
2043 /* Operand caches need to be recomputed for operands referencing the updated
2044 variables and operands need to be rewritten to expose bare symbols. */
2045 if (!bitmap_empty_p (suitable_for_renaming
))
2048 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
);)
2050 gimple stmt
= gsi_stmt (gsi
);
2052 /* Re-write TARGET_MEM_REFs of symbols we want to
2053 rewrite into SSA form. */
2054 if (gimple_assign_single_p (stmt
))
2056 tree lhs
= gimple_assign_lhs (stmt
);
2057 tree rhs
, *rhsp
= gimple_assign_rhs1_ptr (stmt
);
2060 /* We shouldn't have any fancy wrapping of
2061 component-refs on the LHS, but look through
2062 VIEW_CONVERT_EXPRs as that is easy. */
2063 while (TREE_CODE (lhs
) == VIEW_CONVERT_EXPR
)
2064 lhs
= TREE_OPERAND (lhs
, 0);
2065 if (TREE_CODE (lhs
) == MEM_REF
2066 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == ADDR_EXPR
2067 && integer_zerop (TREE_OPERAND (lhs
, 1))
2068 && (sym
= TREE_OPERAND (TREE_OPERAND (lhs
, 0), 0))
2070 && !TREE_ADDRESSABLE (sym
)
2071 && bitmap_bit_p (suitable_for_renaming
, DECL_UID (sym
)))
2074 lhs
= gimple_assign_lhs (stmt
);
2076 /* Rewrite the RHS and make sure the resulting assignment
2077 is validly typed. */
2078 maybe_rewrite_mem_ref_base (rhsp
, suitable_for_renaming
);
2079 rhs
= gimple_assign_rhs1 (stmt
);
2080 if (gimple_assign_lhs (stmt
) != lhs
2081 && !useless_type_conversion_p (TREE_TYPE (lhs
),
2083 rhs
= fold_build1 (VIEW_CONVERT_EXPR
,
2084 TREE_TYPE (lhs
), rhs
);
2086 if (gimple_assign_lhs (stmt
) != lhs
)
2087 gimple_assign_set_lhs (stmt
, lhs
);
2089 /* For var ={v} {CLOBBER}; where var lost
2090 TREE_ADDRESSABLE just remove the stmt. */
2092 && TREE_CLOBBER_P (rhs
)
2093 && bitmap_bit_p (suitable_for_renaming
, DECL_UID (lhs
)))
2095 unlink_stmt_vdef (stmt
);
2096 gsi_remove (&gsi
, true);
2097 release_defs (stmt
);
2101 if (gimple_assign_rhs1 (stmt
) != rhs
)
2103 gimple_stmt_iterator gsi
= gsi_for_stmt (stmt
);
2104 gimple_assign_set_rhs_from_tree (&gsi
, rhs
);
2108 else if (gimple_code (stmt
) == GIMPLE_CALL
)
2111 for (i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
2113 tree
*argp
= gimple_call_arg_ptr (stmt
, i
);
2114 maybe_rewrite_mem_ref_base (argp
, suitable_for_renaming
);
2118 else if (gimple_code (stmt
) == GIMPLE_ASM
)
2121 for (i
= 0; i
< gimple_asm_noutputs (stmt
); ++i
)
2123 tree link
= gimple_asm_output_op (stmt
, i
);
2124 maybe_rewrite_mem_ref_base (&TREE_VALUE (link
),
2125 suitable_for_renaming
);
2127 for (i
= 0; i
< gimple_asm_ninputs (stmt
); ++i
)
2129 tree link
= gimple_asm_input_op (stmt
, i
);
2130 maybe_rewrite_mem_ref_base (&TREE_VALUE (link
),
2131 suitable_for_renaming
);
2135 else if (gimple_debug_bind_p (stmt
)
2136 && gimple_debug_bind_has_value_p (stmt
))
2138 tree
*valuep
= gimple_debug_bind_get_value_ptr (stmt
);
2140 maybe_rewrite_mem_ref_base (valuep
, suitable_for_renaming
);
2141 decl
= non_rewritable_mem_ref_base (*valuep
);
2143 && bitmap_bit_p (suitable_for_renaming
, DECL_UID (decl
)))
2144 gimple_debug_bind_reset_value (stmt
);
2147 if (gimple_references_memory_p (stmt
)
2148 || is_gimple_debug (stmt
))
2154 /* Update SSA form here, we are called as non-pass as well. */
2155 if (number_of_loops (cfun
) > 1
2156 && loops_state_satisfies_p (LOOP_CLOSED_SSA
))
2157 rewrite_into_loop_closed_ssa (NULL
, TODO_update_ssa
);
2159 update_ssa (TODO_update_ssa
);
2162 BITMAP_FREE (not_reg_needs
);
2163 BITMAP_FREE (addresses_taken
);
2164 BITMAP_FREE (suitable_for_renaming
);
2165 timevar_pop (TV_ADDRESS_TAKEN
);
2170 const pass_data pass_data_update_address_taken
=
2172 GIMPLE_PASS
, /* type */
2173 "addressables", /* name */
2174 OPTGROUP_NONE
, /* optinfo_flags */
2175 false, /* has_gate */
2176 false, /* has_execute */
2177 TV_ADDRESS_TAKEN
, /* tv_id */
2178 PROP_ssa
, /* properties_required */
2179 0, /* properties_provided */
2180 0, /* properties_destroyed */
2181 0, /* todo_flags_start */
2182 TODO_update_address_taken
, /* todo_flags_finish */
2185 class pass_update_address_taken
: public gimple_opt_pass
2188 pass_update_address_taken(gcc::context
*ctxt
)
2189 : gimple_opt_pass(pass_data_update_address_taken
, ctxt
)
2192 /* opt_pass methods: */
2194 }; // class pass_update_address_taken
2199 make_pass_update_address_taken (gcc::context
*ctxt
)
2201 return new pass_update_address_taken (ctxt
);