1 /* Miscellaneous SSA utility functions.
2 Copyright (C) 2001, 2002, 2003, 2004, 2005 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 2, 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 COPYING. If not, write to
18 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
19 Boston, MA 02110-1301, USA. */
23 #include "coretypes.h"
30 #include "langhooks.h"
31 #include "hard-reg-set.h"
32 #include "basic-block.h"
36 #include "diagnostic.h"
38 #include "pointer-set.h"
39 #include "tree-flow.h"
40 #include "tree-gimple.h"
41 #include "tree-inline.h"
45 #include "tree-dump.h"
46 #include "tree-pass.h"
49 /* Remove the corresponding arguments from the PHI nodes in E's
50 destination block and redirect it to DEST. Return redirected edge.
51 The list of removed arguments is stored in PENDING_STMT (e). */
54 ssa_redirect_edge (edge e
, basic_block dest
)
57 tree list
= NULL
, *last
= &list
;
60 /* Remove the appropriate PHI arguments in E's destination block. */
61 for (phi
= phi_nodes (e
->dest
); phi
; phi
= PHI_CHAIN (phi
))
63 if (PHI_ARG_DEF (phi
, e
->dest_idx
) == NULL_TREE
)
66 src
= PHI_ARG_DEF (phi
, e
->dest_idx
);
67 dst
= PHI_RESULT (phi
);
68 node
= build_tree_list (dst
, src
);
70 last
= &TREE_CHAIN (node
);
73 e
= redirect_edge_succ_nodup (e
, dest
);
74 PENDING_STMT (e
) = list
;
79 /* Add PHI arguments queued in PENDING_STMT list on edge E to edge
83 flush_pending_stmts (edge e
)
87 if (!PENDING_STMT (e
))
90 for (phi
= phi_nodes (e
->dest
), arg
= PENDING_STMT (e
);
92 phi
= PHI_CHAIN (phi
), arg
= TREE_CHAIN (arg
))
94 tree def
= TREE_VALUE (arg
);
95 add_phi_arg (phi
, def
, e
);
98 PENDING_STMT (e
) = NULL
;
101 /* Return true if SSA_NAME is malformed and mark it visited.
103 IS_VIRTUAL is true if this SSA_NAME was found inside a virtual
107 verify_ssa_name (tree ssa_name
, bool is_virtual
)
109 if (TREE_CODE (ssa_name
) != SSA_NAME
)
111 error ("expected an SSA_NAME object");
115 if (TREE_TYPE (ssa_name
) != TREE_TYPE (SSA_NAME_VAR (ssa_name
)))
117 error ("type mismatch between an SSA_NAME and its symbol");
121 if (SSA_NAME_IN_FREE_LIST (ssa_name
))
123 error ("found an SSA_NAME that had been released into the free pool");
127 if (is_virtual
&& is_gimple_reg (ssa_name
))
129 error ("found a virtual definition for a GIMPLE register");
133 if (!is_virtual
&& !is_gimple_reg (ssa_name
))
135 error ("found a real definition for a non-register");
139 if (is_virtual
&& var_ann (SSA_NAME_VAR (ssa_name
))
140 && get_subvars_for_var (SSA_NAME_VAR (ssa_name
)) != NULL
)
142 error ("found real variable when subvariables should have appeared");
146 if (SSA_NAME_IS_DEFAULT_DEF (ssa_name
)
147 && !IS_EMPTY_STMT (SSA_NAME_DEF_STMT (ssa_name
)))
149 error ("found a default name with a non-empty defining statement");
157 /* Return true if the definition of SSA_NAME at block BB is malformed.
159 STMT is the statement where SSA_NAME is created.
161 DEFINITION_BLOCK is an array of basic blocks indexed by SSA_NAME
162 version numbers. If DEFINITION_BLOCK[SSA_NAME_VERSION] is set,
163 it means that the block in that array slot contains the
164 definition of SSA_NAME.
166 IS_VIRTUAL is true if SSA_NAME is created by a VDEF. */
169 verify_def (basic_block bb
, basic_block
*definition_block
, tree ssa_name
,
170 tree stmt
, bool is_virtual
)
172 if (verify_ssa_name (ssa_name
, is_virtual
))
175 if (definition_block
[SSA_NAME_VERSION (ssa_name
)])
177 error ("SSA_NAME created in two different blocks %i and %i",
178 definition_block
[SSA_NAME_VERSION (ssa_name
)]->index
, bb
->index
);
182 definition_block
[SSA_NAME_VERSION (ssa_name
)] = bb
;
184 if (SSA_NAME_DEF_STMT (ssa_name
) != stmt
)
186 error ("SSA_NAME_DEF_STMT is wrong");
187 fprintf (stderr
, "Expected definition statement:\n");
188 print_generic_stmt (stderr
, SSA_NAME_DEF_STMT (ssa_name
), TDF_VOPS
);
189 fprintf (stderr
, "\nActual definition statement:\n");
190 print_generic_stmt (stderr
, stmt
, TDF_VOPS
);
197 fprintf (stderr
, "while verifying SSA_NAME ");
198 print_generic_expr (stderr
, ssa_name
, 0);
199 fprintf (stderr
, " in statement\n");
200 print_generic_stmt (stderr
, stmt
, TDF_VOPS
);
206 /* Return true if the use of SSA_NAME at statement STMT in block BB is
209 DEF_BB is the block where SSA_NAME was found to be created.
211 IDOM contains immediate dominator information for the flowgraph.
213 CHECK_ABNORMAL is true if the caller wants to check whether this use
214 is flowing through an abnormal edge (only used when checking PHI
217 If NAMES_DEFINED_IN_BB is not NULL, it contains a bitmap of ssa names
218 that are defined before STMT in basic block BB. */
221 verify_use (basic_block bb
, basic_block def_bb
, use_operand_p use_p
,
222 tree stmt
, bool check_abnormal
, bitmap names_defined_in_bb
)
225 tree ssa_name
= USE_FROM_PTR (use_p
);
227 if (!TREE_VISITED (ssa_name
))
228 if (verify_imm_links (stderr
, ssa_name
))
231 TREE_VISITED (ssa_name
) = 1;
233 if (IS_EMPTY_STMT (SSA_NAME_DEF_STMT (ssa_name
))
234 && SSA_NAME_IS_DEFAULT_DEF (ssa_name
))
235 ; /* Default definitions have empty statements. Nothing to do. */
238 error ("missing definition");
241 else if (bb
!= def_bb
242 && !dominated_by_p (CDI_DOMINATORS
, bb
, def_bb
))
244 error ("definition in block %i does not dominate use in block %i",
245 def_bb
->index
, bb
->index
);
248 else if (bb
== def_bb
249 && names_defined_in_bb
!= NULL
250 && !bitmap_bit_p (names_defined_in_bb
, SSA_NAME_VERSION (ssa_name
)))
252 error ("definition in block %i follows the use", def_bb
->index
);
257 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ssa_name
))
259 error ("SSA_NAME_OCCURS_IN_ABNORMAL_PHI should be set");
263 /* Make sure the use is in an appropriate list by checking the previous
264 element to make sure it's the same. */
265 if (use_p
->prev
== NULL
)
267 error ("no immediate_use list");
273 if (use_p
->prev
->use
== NULL
)
274 listvar
= use_p
->prev
->stmt
;
276 listvar
= USE_FROM_PTR (use_p
->prev
);
277 if (listvar
!= ssa_name
)
279 error ("wrong immediate use list");
286 fprintf (stderr
, "for SSA_NAME: ");
287 print_generic_expr (stderr
, ssa_name
, TDF_VOPS
);
288 fprintf (stderr
, " in statement:\n");
289 print_generic_stmt (stderr
, stmt
, TDF_VOPS
);
296 /* Return true if any of the arguments for PHI node PHI at block BB is
299 DEFINITION_BLOCK is an array of basic blocks indexed by SSA_NAME
300 version numbers. If DEFINITION_BLOCK[SSA_NAME_VERSION] is set,
301 it means that the block in that array slot contains the
302 definition of SSA_NAME. */
305 verify_phi_args (tree phi
, basic_block bb
, basic_block
*definition_block
)
309 unsigned i
, phi_num_args
= PHI_NUM_ARGS (phi
);
311 if (EDGE_COUNT (bb
->preds
) != phi_num_args
)
313 error ("incoming edge count does not match number of PHI arguments");
318 for (i
= 0; i
< phi_num_args
; i
++)
320 use_operand_p op_p
= PHI_ARG_DEF_PTR (phi
, i
);
321 tree op
= USE_FROM_PTR (op_p
);
323 e
= EDGE_PRED (bb
, i
);
327 error ("PHI argument is missing for edge %d->%d",
334 if (TREE_CODE (op
) != SSA_NAME
&& !is_gimple_min_invariant (op
))
336 error ("PHI argument is not SSA_NAME, or invariant");
340 if (TREE_CODE (op
) == SSA_NAME
)
342 err
= verify_ssa_name (op
, !is_gimple_reg (PHI_RESULT (phi
)));
343 err
|= verify_use (e
->src
, definition_block
[SSA_NAME_VERSION (op
)],
344 op_p
, phi
, e
->flags
& EDGE_ABNORMAL
, NULL
);
349 error ("wrong edge %d->%d for PHI argument",
350 e
->src
->index
, e
->dest
->index
);
356 fprintf (stderr
, "PHI argument\n");
357 print_generic_stmt (stderr
, op
, TDF_VOPS
);
365 fprintf (stderr
, "for PHI node\n");
366 print_generic_stmt (stderr
, phi
, TDF_VOPS
|TDF_MEMSYMS
);
375 verify_flow_insensitive_alias_info (void)
378 referenced_var_iterator rvi
;
380 FOR_EACH_REFERENCED_VAR (var
, rvi
)
387 if (!MTAG_P (var
) || !MTAG_ALIASES (var
))
390 aliases
= MTAG_ALIASES (var
);
392 EXECUTE_IF_SET_IN_BITMAP (aliases
, 0, j
, bi
)
394 alias
= referenced_var (j
);
396 if (TREE_CODE (alias
) != MEMORY_PARTITION_TAG
397 && !may_be_aliased (alias
))
399 error ("non-addressable variable inside an alias set");
400 debug_variable (alias
);
409 debug_variable (var
);
410 internal_error ("verify_flow_insensitive_alias_info failed");
415 verify_flow_sensitive_alias_info (void)
420 for (i
= 1; i
< num_ssa_names
; i
++)
424 struct ptr_info_def
*pi
;
431 /* We only care for pointers that are actually referenced in the
433 if (!POINTER_TYPE_P (TREE_TYPE (ptr
)) || !TREE_VISITED (ptr
))
436 /* RESULT_DECL is special. If it's a GIMPLE register, then it
437 is only written-to only once in the return statement.
438 Otherwise, aggregate RESULT_DECLs may be written-to more than
439 once in virtual operands. */
440 var
= SSA_NAME_VAR (ptr
);
441 if (TREE_CODE (var
) == RESULT_DECL
442 && is_gimple_reg (ptr
))
445 pi
= SSA_NAME_PTR_INFO (ptr
);
450 if (pi
->is_dereferenced
&& !pi
->name_mem_tag
&& !ann
->symbol_mem_tag
)
452 error ("dereferenced pointers should have a name or a symbol tag");
457 && (pi
->pt_vars
== NULL
|| bitmap_empty_p (pi
->pt_vars
)))
459 error ("pointers with a memory tag, should have points-to sets");
463 if (pi
->value_escapes_p
&& pi
->name_mem_tag
)
465 tree t
= memory_partition (pi
->name_mem_tag
);
467 t
= pi
->name_mem_tag
;
469 if (!is_call_clobbered (t
))
471 error ("pointer escapes but its name tag is not call-clobbered");
480 debug_variable (ptr
);
481 internal_error ("verify_flow_sensitive_alias_info failed");
485 /* Verify the consistency of call clobbering information. */
488 verify_call_clobbering (void)
493 referenced_var_iterator rvi
;
495 /* At all times, the result of the call_clobbered flag should
496 match the result of the call_clobbered_vars bitmap. Verify both
497 that everything in call_clobbered_vars is marked
498 call_clobbered, and that everything marked
499 call_clobbered is in call_clobbered_vars. */
500 EXECUTE_IF_SET_IN_BITMAP (gimple_call_clobbered_vars (cfun
), 0, i
, bi
)
502 var
= referenced_var (i
);
504 if (memory_partition (var
))
505 var
= memory_partition (var
);
507 if (!MTAG_P (var
) && !var_ann (var
)->call_clobbered
)
509 error ("variable in call_clobbered_vars but not marked "
511 debug_variable (var
);
516 FOR_EACH_REFERENCED_VAR (var
, rvi
)
518 if (is_gimple_reg (var
))
521 if (memory_partition (var
))
522 var
= memory_partition (var
);
525 && var_ann (var
)->call_clobbered
526 && !bitmap_bit_p (gimple_call_clobbered_vars (cfun
), DECL_UID (var
)))
528 error ("variable marked call_clobbered but not in "
529 "call_clobbered_vars bitmap.");
530 debug_variable (var
);
538 internal_error ("verify_call_clobbering failed");
542 /* Verify invariants in memory partitions. */
545 verify_memory_partitions (void)
549 VEC(tree
,heap
) *mpt_table
= gimple_ssa_operands (cfun
)->mpt_table
;
550 struct pointer_set_t
*partitioned_syms
= pointer_set_create ();
552 for (i
= 0; VEC_iterate (tree
, mpt_table
, i
, mpt
); i
++)
557 if (MPT_SYMBOLS (mpt
) == NULL
)
559 error ("Memory partitions should have at least one symbol");
560 debug_variable (mpt
);
564 EXECUTE_IF_SET_IN_BITMAP (MPT_SYMBOLS (mpt
), 0, j
, bj
)
566 tree var
= referenced_var (j
);
567 if (pointer_set_insert (partitioned_syms
, var
))
569 error ("Partitioned symbols should belong to exactly one "
571 debug_variable (var
);
577 pointer_set_destroy (partitioned_syms
);
582 internal_error ("verify_memory_partitions failed");
586 /* Verify the consistency of aliasing information. */
589 verify_alias_info (void)
591 verify_flow_sensitive_alias_info ();
592 verify_call_clobbering ();
593 verify_flow_insensitive_alias_info ();
594 verify_memory_partitions ();
598 /* Verify common invariants in the SSA web.
599 TODO: verify the variable annotations. */
602 verify_ssa (bool check_modified_stmt
)
606 basic_block
*definition_block
= XCNEWVEC (basic_block
, num_ssa_names
);
609 enum dom_state orig_dom_state
= dom_info_state (CDI_DOMINATORS
);
610 bitmap names_defined_in_bb
= BITMAP_ALLOC (NULL
);
612 gcc_assert (!need_ssa_update_p ());
616 timevar_push (TV_TREE_SSA_VERIFY
);
618 /* Keep track of SSA names present in the IL. */
619 for (i
= 1; i
< num_ssa_names
; i
++)
621 tree name
= ssa_name (i
);
625 TREE_VISITED (name
) = 0;
627 stmt
= SSA_NAME_DEF_STMT (name
);
628 if (!IS_EMPTY_STMT (stmt
))
630 basic_block bb
= bb_for_stmt (stmt
);
631 verify_def (bb
, definition_block
,
632 name
, stmt
, !is_gimple_reg (name
));
638 calculate_dominance_info (CDI_DOMINATORS
);
640 /* Now verify all the uses and make sure they agree with the definitions
641 found in the previous pass. */
647 block_stmt_iterator bsi
;
649 /* Make sure that all edges have a clear 'aux' field. */
650 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
654 error ("AUX pointer initialized for edge %d->%d", e
->src
->index
,
660 /* Verify the arguments for every PHI node in the block. */
661 for (phi
= phi_nodes (bb
); phi
; phi
= PHI_CHAIN (phi
))
663 if (verify_phi_args (phi
, bb
, definition_block
))
666 bitmap_set_bit (names_defined_in_bb
,
667 SSA_NAME_VERSION (PHI_RESULT (phi
)));
670 /* Now verify all the uses and vuses in every statement of the block. */
671 for (bsi
= bsi_start (bb
); !bsi_end_p (bsi
); bsi_next (&bsi
))
673 tree stmt
= bsi_stmt (bsi
);
676 if (check_modified_stmt
&& stmt_modified_p (stmt
))
678 error ("stmt (%p) marked modified after optimization pass: ",
680 print_generic_stmt (stderr
, stmt
, TDF_VOPS
);
684 if (TREE_CODE (stmt
) == GIMPLE_MODIFY_STMT
685 && TREE_CODE (GIMPLE_STMT_OPERAND (stmt
, 0)) != SSA_NAME
)
687 tree lhs
, base_address
;
689 lhs
= GIMPLE_STMT_OPERAND (stmt
, 0);
690 base_address
= get_base_address (lhs
);
693 && gimple_aliases_computed_p (cfun
)
694 && SSA_VAR_P (base_address
)
695 && !stmt_ann (stmt
)->has_volatile_ops
696 && ZERO_SSA_OPERANDS (stmt
, SSA_OP_VDEF
))
698 error ("statement makes a memory store, but has no VDEFS");
699 print_generic_stmt (stderr
, stmt
, TDF_VOPS
);
704 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, iter
, SSA_OP_ALL_VIRTUALS
)
706 if (verify_ssa_name (op
, true))
708 error ("in statement");
709 print_generic_stmt (stderr
, stmt
, TDF_VOPS
|TDF_MEMSYMS
);
714 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, iter
, SSA_OP_USE
|SSA_OP_DEF
)
716 if (verify_ssa_name (op
, false))
718 error ("in statement");
719 print_generic_stmt (stderr
, stmt
, TDF_VOPS
|TDF_MEMSYMS
);
724 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_USE
|SSA_OP_VUSE
)
726 op
= USE_FROM_PTR (use_p
);
727 if (verify_use (bb
, definition_block
[SSA_NAME_VERSION (op
)],
728 use_p
, stmt
, false, names_defined_in_bb
))
732 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, iter
, SSA_OP_ALL_DEFS
)
733 bitmap_set_bit (names_defined_in_bb
, SSA_NAME_VERSION (op
));
736 bitmap_clear (names_defined_in_bb
);
739 /* Finally, verify alias information. */
740 if (gimple_aliases_computed_p (cfun
))
741 verify_alias_info ();
743 free (definition_block
);
745 /* Restore the dominance information to its prior known state, so
746 that we do not perturb the compiler's subsequent behavior. */
747 if (orig_dom_state
== DOM_NONE
)
748 free_dominance_info (CDI_DOMINATORS
);
750 set_dom_info_availability (CDI_DOMINATORS
, orig_dom_state
);
752 BITMAP_FREE (names_defined_in_bb
);
753 timevar_pop (TV_TREE_SSA_VERIFY
);
757 internal_error ("verify_ssa failed");
760 /* Return true if the uid in both int tree maps are equal. */
763 int_tree_map_eq (const void *va
, const void *vb
)
765 const struct int_tree_map
*a
= (const struct int_tree_map
*) va
;
766 const struct int_tree_map
*b
= (const struct int_tree_map
*) vb
;
767 return (a
->uid
== b
->uid
);
770 /* Hash a UID in a int_tree_map. */
773 int_tree_map_hash (const void *item
)
775 return ((const struct int_tree_map
*)item
)->uid
;
778 /* Return true if the uid in both int tree maps are equal. */
781 var_ann_eq (const void *va
, const void *vb
)
783 const struct static_var_ann_d
*a
= (const struct static_var_ann_d
*) va
;
785 return (a
->uid
== DECL_UID (b
));
788 /* Hash a UID in a int_tree_map. */
791 var_ann_hash (const void *item
)
793 return ((const struct static_var_ann_d
*)item
)->uid
;
797 /* Initialize global DFA and SSA structures. */
802 cfun
->gimple_df
= GGC_CNEW (struct gimple_df
);
803 cfun
->gimple_df
->referenced_vars
= htab_create_ggc (20, int_tree_map_hash
,
804 int_tree_map_eq
, NULL
);
805 cfun
->gimple_df
->default_defs
= htab_create_ggc (20, int_tree_map_hash
,
806 int_tree_map_eq
, NULL
);
807 cfun
->gimple_df
->var_anns
= htab_create_ggc (20, var_ann_hash
,
809 cfun
->gimple_df
->call_clobbered_vars
= BITMAP_GGC_ALLOC ();
810 cfun
->gimple_df
->addressable_vars
= BITMAP_GGC_ALLOC ();
816 /* Deallocate memory associated with SSA data structures for FNDECL. */
819 delete_tree_ssa (void)
823 block_stmt_iterator bsi
;
824 referenced_var_iterator rvi
;
827 /* Release any ssa_names still in use. */
828 for (i
= 0; i
< num_ssa_names
; i
++)
830 tree var
= ssa_name (i
);
831 if (var
&& TREE_CODE (var
) == SSA_NAME
)
833 SSA_NAME_IMM_USE_NODE (var
).prev
= &(SSA_NAME_IMM_USE_NODE (var
));
834 SSA_NAME_IMM_USE_NODE (var
).next
= &(SSA_NAME_IMM_USE_NODE (var
));
836 release_ssa_name (var
);
839 /* Remove annotations from every tree in the function. */
842 for (bsi
= bsi_start (bb
); !bsi_end_p (bsi
); bsi_next (&bsi
))
844 tree stmt
= bsi_stmt (bsi
);
845 stmt_ann_t ann
= get_stmt_ann (stmt
);
847 free_ssa_operands (&ann
->operands
);
848 ann
->addresses_taken
= 0;
849 mark_stmt_modified (stmt
);
851 set_phi_nodes (bb
, NULL
);
854 /* Remove annotations from every referenced variable. */
855 FOR_EACH_REFERENCED_VAR (var
, rvi
)
858 ggc_free (var
->base
.ann
);
859 var
->base
.ann
= NULL
;
861 htab_delete (gimple_referenced_vars (cfun
));
862 cfun
->gimple_df
->referenced_vars
= NULL
;
866 /* we no longer maintain the SSA operand cache at this point. */
867 fini_ssa_operands ();
869 cfun
->gimple_df
->global_var
= NULL_TREE
;
871 htab_delete (cfun
->gimple_df
->default_defs
);
872 cfun
->gimple_df
->default_defs
= NULL
;
873 htab_delete (cfun
->gimple_df
->var_anns
);
874 cfun
->gimple_df
->var_anns
= NULL
;
875 cfun
->gimple_df
->call_clobbered_vars
= NULL
;
876 cfun
->gimple_df
->addressable_vars
= NULL
;
877 cfun
->gimple_df
->modified_noreturn_calls
= NULL
;
878 if (gimple_aliases_computed_p (cfun
))
880 delete_alias_heapvars ();
881 gcc_assert (!need_ssa_update_p ());
883 cfun
->gimple_df
->aliases_computed_p
= false;
884 delete_mem_ref_stats (cfun
);
886 cfun
->gimple_df
= NULL
;
890 /* Return true if the conversion from INNER_TYPE to OUTER_TYPE is a
891 useless type conversion, otherwise return false.
893 This function implicitly defines the middle-end type system. With
894 the notion of 'a < b' meaning that useless_type_conversion_p (a, b)
895 holds and 'a > b' meaning that useless_type_conversion_p (b, a) holds,
896 the following invariants shall be fulfilled:
898 1) useless_type_conversion_p is transitive.
899 If a < b and b < c then a < c.
901 2) useless_type_conversion_p is not symmetric.
902 From a < b does not follow a > b.
904 3) Types define the available set of operations applicable to values.
905 A type conversion is useless if the operations for the target type
906 is a subset of the operations for the source type. For example
907 casts to void* are useless, casts from void* are not (void* can't
908 be dereferenced or offsetted, but copied, hence its set of operations
909 is a strict subset of that of all other data pointer types). Casts
910 to const T* are useless (can't be written to), casts from const T*
913 ??? The above do not hold currently. */
916 useless_type_conversion_p (tree outer_type
, tree inner_type
)
918 if (inner_type
== outer_type
)
921 /* Changes in machine mode are never useless conversions. */
922 if (TYPE_MODE (inner_type
) != TYPE_MODE (outer_type
))
925 /* If both the inner and outer types are integral types, then the
926 conversion is not necessary if they have the same mode and
927 signedness and precision, and both or neither are boolean. */
928 if (INTEGRAL_TYPE_P (inner_type
)
929 && INTEGRAL_TYPE_P (outer_type
))
931 /* Preserve changes in signedness or precision. */
932 if (TYPE_UNSIGNED (inner_type
) != TYPE_UNSIGNED (outer_type
)
933 || TYPE_PRECISION (inner_type
) != TYPE_PRECISION (outer_type
))
936 /* Preserve booleanness. Some code assumes an invariant that boolean
937 types stay boolean and do not become 1-bit bit-field types. */
938 if ((TREE_CODE (inner_type
) == BOOLEAN_TYPE
)
939 != (TREE_CODE (outer_type
) == BOOLEAN_TYPE
))
942 /* Preserve changes in the types minimum or maximum value.
943 ??? Due to the way we handle sizetype as signed we need
944 to jump through hoops here to make sizetype and size_type_node
946 if (!tree_int_cst_equal (fold_convert (outer_type
,
947 TYPE_MIN_VALUE (inner_type
)),
948 TYPE_MIN_VALUE (outer_type
))
949 || !tree_int_cst_equal (fold_convert (outer_type
,
950 TYPE_MAX_VALUE (inner_type
)),
951 TYPE_MAX_VALUE (outer_type
)))
954 /* ??? We might want to preserve base type changes because of
955 TBAA. Or we need to be extra careful below. */
960 /* We need to take special care recursing to pointed-to types. */
961 else if (POINTER_TYPE_P (inner_type
)
962 && POINTER_TYPE_P (outer_type
))
964 /* Don't lose casts between pointers to volatile and non-volatile
965 qualified types. Doing so would result in changing the semantics
966 of later accesses. */
967 if (TYPE_VOLATILE (TREE_TYPE (outer_type
))
968 != TYPE_VOLATILE (TREE_TYPE (inner_type
)))
971 /* Do not lose casts between pointers with different
972 TYPE_REF_CAN_ALIAS_ALL setting. */
973 if (TYPE_REF_CAN_ALIAS_ALL (inner_type
)
974 != TYPE_REF_CAN_ALIAS_ALL (outer_type
))
977 /* If the outer type is (void *), then the conversion is not
979 ??? Together with calling the langhook below this makes
980 useless_type_conversion_p not transitive. */
981 if (TREE_CODE (TREE_TYPE (outer_type
)) == VOID_TYPE
)
984 /* Otherwise pointers/references are equivalent if their pointed
985 to types are effectively the same. This allows to strip conversions
986 between pointer types with different type qualifiers.
987 ??? We should recurse here with
988 useless_type_conversion_p. */
989 return lang_hooks
.types_compatible_p (TREE_TYPE (inner_type
),
990 TREE_TYPE (outer_type
));
993 /* Recurse for complex types. */
994 else if (TREE_CODE (inner_type
) == COMPLEX_TYPE
995 && TREE_CODE (outer_type
) == COMPLEX_TYPE
)
996 return useless_type_conversion_p (TREE_TYPE (outer_type
),
997 TREE_TYPE (inner_type
));
999 /* Fall back to what the frontend thinks of type compatibility.
1000 ??? This should eventually just return false. */
1001 return lang_hooks
.types_compatible_p (inner_type
, outer_type
);
1004 /* Return true if a conversion from either type of TYPE1 and TYPE2
1005 to the other is not required. Otherwise return false. */
1008 types_compatible_p (tree type1
, tree type2
)
1010 return (type1
== type2
1011 || (useless_type_conversion_p (type1
, type2
)
1012 && useless_type_conversion_p (type2
, type1
)));
1015 /* Return true if EXPR is a useless type conversion, otherwise return
1019 tree_ssa_useless_type_conversion (tree expr
)
1021 /* If we have an assignment that merely uses a NOP_EXPR to change
1022 the top of the RHS to the type of the LHS and the type conversion
1023 is "safe", then strip away the type conversion so that we can
1024 enter LHS = RHS into the const_and_copies table. */
1025 if (TREE_CODE (expr
) == NOP_EXPR
|| TREE_CODE (expr
) == CONVERT_EXPR
1026 || TREE_CODE (expr
) == VIEW_CONVERT_EXPR
1027 || TREE_CODE (expr
) == NON_LVALUE_EXPR
)
1028 /* FIXME: Use of GENERIC_TREE_TYPE here is a temporary measure to work
1029 around known bugs with GIMPLE_MODIFY_STMTs appearing in places
1030 they shouldn't. See PR 30391. */
1031 return useless_type_conversion_p
1033 GENERIC_TREE_TYPE (TREE_OPERAND (expr
, 0)));
1039 /* Internal helper for walk_use_def_chains. VAR, FN and DATA are as
1040 described in walk_use_def_chains.
1042 VISITED is a pointer set used to mark visited SSA_NAMEs to avoid
1043 infinite loops. We used to have a bitmap for this to just mark
1044 SSA versions we had visited. But non-sparse bitmaps are way too
1045 expensive, while sparse bitmaps may cause quadratic behavior.
1047 IS_DFS is true if the caller wants to perform a depth-first search
1048 when visiting PHI nodes. A DFS will visit each PHI argument and
1049 call FN after each one. Otherwise, all the arguments are
1050 visited first and then FN is called with each of the visited
1051 arguments in a separate pass. */
1054 walk_use_def_chains_1 (tree var
, walk_use_def_chains_fn fn
, void *data
,
1055 struct pointer_set_t
*visited
, bool is_dfs
)
1059 if (pointer_set_insert (visited
, var
))
1062 def_stmt
= SSA_NAME_DEF_STMT (var
);
1064 if (TREE_CODE (def_stmt
) != PHI_NODE
)
1066 /* If we reached the end of the use-def chain, call FN. */
1067 return fn (var
, def_stmt
, data
);
1073 /* When doing a breadth-first search, call FN before following the
1074 use-def links for each argument. */
1076 for (i
= 0; i
< PHI_NUM_ARGS (def_stmt
); i
++)
1077 if (fn (PHI_ARG_DEF (def_stmt
, i
), def_stmt
, data
))
1080 /* Follow use-def links out of each PHI argument. */
1081 for (i
= 0; i
< PHI_NUM_ARGS (def_stmt
); i
++)
1083 tree arg
= PHI_ARG_DEF (def_stmt
, i
);
1085 /* ARG may be NULL for newly introduced PHI nodes. */
1087 && TREE_CODE (arg
) == SSA_NAME
1088 && walk_use_def_chains_1 (arg
, fn
, data
, visited
, is_dfs
))
1092 /* When doing a depth-first search, call FN after following the
1093 use-def links for each argument. */
1095 for (i
= 0; i
< PHI_NUM_ARGS (def_stmt
); i
++)
1096 if (fn (PHI_ARG_DEF (def_stmt
, i
), def_stmt
, data
))
1105 /* Walk use-def chains starting at the SSA variable VAR. Call
1106 function FN at each reaching definition found. FN takes three
1107 arguments: VAR, its defining statement (DEF_STMT) and a generic
1108 pointer to whatever state information that FN may want to maintain
1109 (DATA). FN is able to stop the walk by returning true, otherwise
1110 in order to continue the walk, FN should return false.
1112 Note, that if DEF_STMT is a PHI node, the semantics are slightly
1113 different. The first argument to FN is no longer the original
1114 variable VAR, but the PHI argument currently being examined. If FN
1115 wants to get at VAR, it should call PHI_RESULT (PHI).
1117 If IS_DFS is true, this function will:
1119 1- walk the use-def chains for all the PHI arguments, and,
1120 2- call (*FN) (ARG, PHI, DATA) on all the PHI arguments.
1122 If IS_DFS is false, the two steps above are done in reverse order
1123 (i.e., a breadth-first search). */
1126 walk_use_def_chains (tree var
, walk_use_def_chains_fn fn
, void *data
,
1131 gcc_assert (TREE_CODE (var
) == SSA_NAME
);
1133 def_stmt
= SSA_NAME_DEF_STMT (var
);
1135 /* We only need to recurse if the reaching definition comes from a PHI
1137 if (TREE_CODE (def_stmt
) != PHI_NODE
)
1138 (*fn
) (var
, def_stmt
, data
);
1141 struct pointer_set_t
*visited
= pointer_set_create ();
1142 walk_use_def_chains_1 (var
, fn
, data
, visited
, is_dfs
);
1143 pointer_set_destroy (visited
);
1148 /* Emit warnings for uninitialized variables. This is done in two passes.
1150 The first pass notices real uses of SSA names with default definitions.
1151 Such uses are unconditionally uninitialized, and we can be certain that
1152 such a use is a mistake. This pass is run before most optimizations,
1153 so that we catch as many as we can.
1155 The second pass follows PHI nodes to find uses that are potentially
1156 uninitialized. In this case we can't necessarily prove that the use
1157 is really uninitialized. This pass is run after most optimizations,
1158 so that we thread as many jumps and possible, and delete as much dead
1159 code as possible, in order to reduce false positives. We also look
1160 again for plain uninitialized variables, since optimization may have
1161 changed conditionally uninitialized to unconditionally uninitialized. */
1163 /* Emit a warning for T, an SSA_NAME, being uninitialized. The exact
1164 warning text is in MSGID and LOCUS may contain a location or be null. */
1167 warn_uninit (tree t
, const char *gmsgid
, void *data
)
1169 tree var
= SSA_NAME_VAR (t
);
1170 tree def
= SSA_NAME_DEF_STMT (t
);
1171 tree context
= (tree
) data
;
1173 expanded_location xloc
, floc
;
1175 /* Default uses (indicated by an empty definition statement),
1176 are uninitialized. */
1177 if (!IS_EMPTY_STMT (def
))
1180 /* Except for PARMs of course, which are always initialized. */
1181 if (TREE_CODE (var
) == PARM_DECL
)
1184 /* Hard register variables get their initial value from the ether. */
1185 if (TREE_CODE (var
) == VAR_DECL
&& DECL_HARD_REGISTER (var
))
1188 /* TREE_NO_WARNING either means we already warned, or the front end
1189 wishes to suppress the warning. */
1190 if (TREE_NO_WARNING (var
))
1193 locus
= (context
!= NULL
&& EXPR_HAS_LOCATION (context
)
1194 ? EXPR_LOCUS (context
)
1195 : &DECL_SOURCE_LOCATION (var
));
1196 warning (OPT_Wuninitialized
, gmsgid
, locus
, var
);
1197 xloc
= expand_location (*locus
);
1198 floc
= expand_location (DECL_SOURCE_LOCATION (cfun
->decl
));
1199 if (xloc
.file
!= floc
.file
1200 || xloc
.line
< floc
.line
1201 || xloc
.line
> LOCATION_LINE (cfun
->function_end_locus
))
1202 inform ("%J%qD was declared here", var
, var
);
1204 TREE_NO_WARNING (var
) = 1;
1207 /* Called via walk_tree, look for SSA_NAMEs that have empty definitions
1208 and warn about them. */
1211 warn_uninitialized_var (tree
*tp
, int *walk_subtrees
, void *data
)
1215 switch (TREE_CODE (t
))
1218 /* We only do data flow with SSA_NAMEs, so that's all we
1220 warn_uninit (t
, "%H%qD is used uninitialized in this function", data
);
1226 /* The total store transformation performed during gimplification
1227 creates uninitialized variable uses. If all is well, these will
1228 be optimized away, so don't warn now. */
1229 if (TREE_CODE (TREE_OPERAND (t
, 0)) == SSA_NAME
)
1234 if (IS_TYPE_OR_DECL_P (t
))
1242 /* Look for inputs to PHI that are SSA_NAMEs that have empty definitions
1243 and warn about them. */
1246 warn_uninitialized_phi (tree phi
)
1248 int i
, n
= PHI_NUM_ARGS (phi
);
1250 /* Don't look at memory tags. */
1251 if (!is_gimple_reg (PHI_RESULT (phi
)))
1254 for (i
= 0; i
< n
; ++i
)
1256 tree op
= PHI_ARG_DEF (phi
, i
);
1257 if (TREE_CODE (op
) == SSA_NAME
)
1258 warn_uninit (op
, "%H%qD may be used uninitialized in this function",
1264 execute_early_warn_uninitialized (void)
1266 block_stmt_iterator bsi
;
1270 for (bsi
= bsi_start (bb
); !bsi_end_p (bsi
); bsi_next (&bsi
))
1272 tree context
= bsi_stmt (bsi
);
1273 walk_tree (bsi_stmt_ptr (bsi
), warn_uninitialized_var
,
1280 execute_late_warn_uninitialized (void)
1285 /* Re-do the plain uninitialized variable check, as optimization may have
1286 straightened control flow. Do this first so that we don't accidentally
1287 get a "may be" warning when we'd have seen an "is" warning later. */
1288 execute_early_warn_uninitialized ();
1291 for (phi
= phi_nodes (bb
); phi
; phi
= PHI_CHAIN (phi
))
1292 warn_uninitialized_phi (phi
);
1297 gate_warn_uninitialized (void)
1299 return warn_uninitialized
!= 0;
1302 struct tree_opt_pass pass_early_warn_uninitialized
=
1305 gate_warn_uninitialized
, /* gate */
1306 execute_early_warn_uninitialized
, /* execute */
1309 0, /* static_pass_number */
1311 PROP_ssa
, /* properties_required */
1312 0, /* properties_provided */
1313 0, /* properties_destroyed */
1314 0, /* todo_flags_start */
1315 0, /* todo_flags_finish */
1319 struct tree_opt_pass pass_late_warn_uninitialized
=
1322 gate_warn_uninitialized
, /* gate */
1323 execute_late_warn_uninitialized
, /* execute */
1326 0, /* static_pass_number */
1328 PROP_ssa
, /* properties_required */
1329 0, /* properties_provided */
1330 0, /* properties_destroyed */
1331 0, /* todo_flags_start */
1332 0, /* todo_flags_finish */