1 /* Miscellaneous SSA utility functions.
2 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009
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"
31 #include "langhooks.h"
32 #include "hard-reg-set.h"
33 #include "basic-block.h"
37 #include "diagnostic.h"
39 #include "pointer-set.h"
40 #include "tree-flow.h"
42 #include "tree-inline.h"
46 #include "tree-dump.h"
47 #include "tree-pass.h"
50 /* Pointer map of variable mappings, keyed by edge. */
51 static struct pointer_map_t
*edge_var_maps
;
54 /* Add a mapping with PHI RESULT and PHI DEF associated with edge E. */
57 redirect_edge_var_map_add (edge e
, tree result
, tree def
, source_location locus
)
60 edge_var_map_vector old_head
, head
;
61 edge_var_map new_node
;
63 if (edge_var_maps
== NULL
)
64 edge_var_maps
= pointer_map_create ();
66 slot
= pointer_map_insert (edge_var_maps
, e
);
67 old_head
= head
= (edge_var_map_vector
) *slot
;
70 head
= VEC_alloc (edge_var_map
, heap
, 5);
74 new_node
.result
= result
;
75 new_node
.locus
= locus
;
77 VEC_safe_push (edge_var_map
, heap
, head
, &new_node
);
80 /* The push did some reallocation. Update the pointer map. */
86 /* Clear the var mappings in edge E. */
89 redirect_edge_var_map_clear (edge e
)
92 edge_var_map_vector head
;
97 slot
= pointer_map_contains (edge_var_maps
, e
);
101 head
= (edge_var_map_vector
) *slot
;
102 VEC_free (edge_var_map
, heap
, head
);
108 /* Duplicate the redirected var mappings in OLDE in NEWE.
110 Since we can't remove a mapping, let's just duplicate it. This assumes a
111 pointer_map can have multiple edges mapping to the same var_map (many to
112 one mapping), since we don't remove the previous mappings. */
115 redirect_edge_var_map_dup (edge newe
, edge olde
)
117 void **new_slot
, **old_slot
;
118 edge_var_map_vector head
;
123 new_slot
= pointer_map_insert (edge_var_maps
, newe
);
124 old_slot
= pointer_map_contains (edge_var_maps
, olde
);
127 head
= (edge_var_map_vector
) *old_slot
;
130 *new_slot
= VEC_copy (edge_var_map
, heap
, head
);
132 *new_slot
= VEC_alloc (edge_var_map
, heap
, 5);
136 /* Return the variable mappings for a given edge. If there is none, return
140 redirect_edge_var_map_vector (edge e
)
144 /* Hey, what kind of idiot would... you'd be surprised. */
148 slot
= pointer_map_contains (edge_var_maps
, e
);
152 return (edge_var_map_vector
) *slot
;
155 /* Used by redirect_edge_var_map_destroy to free all memory. */
158 free_var_map_entry (const void *key ATTRIBUTE_UNUSED
,
160 void *data ATTRIBUTE_UNUSED
)
162 edge_var_map_vector head
= (edge_var_map_vector
) *value
;
163 VEC_free (edge_var_map
, heap
, head
);
167 /* Clear the edge variable mappings. */
170 redirect_edge_var_map_destroy (void)
174 pointer_map_traverse (edge_var_maps
, free_var_map_entry
, NULL
);
175 pointer_map_destroy (edge_var_maps
);
176 edge_var_maps
= NULL
;
181 /* Remove the corresponding arguments from the PHI nodes in E's
182 destination block and redirect it to DEST. Return redirected edge.
183 The list of removed arguments is stored in a vector accessed
184 through edge_var_maps. */
187 ssa_redirect_edge (edge e
, basic_block dest
)
189 gimple_stmt_iterator gsi
;
192 redirect_edge_var_map_clear (e
);
194 /* Remove the appropriate PHI arguments in E's destination block. */
195 for (gsi
= gsi_start_phis (e
->dest
); !gsi_end_p (gsi
); gsi_next (&gsi
))
198 source_location locus
;
200 phi
= gsi_stmt (gsi
);
201 def
= gimple_phi_arg_def (phi
, e
->dest_idx
);
202 locus
= gimple_phi_arg_location (phi
, e
->dest_idx
);
204 if (def
== NULL_TREE
)
207 redirect_edge_var_map_add (e
, gimple_phi_result (phi
), def
, locus
);
210 e
= redirect_edge_succ_nodup (e
, dest
);
216 /* Add PHI arguments queued in PENDING_STMT list on edge E to edge
220 flush_pending_stmts (edge e
)
223 edge_var_map_vector v
;
226 gimple_stmt_iterator gsi
;
228 v
= redirect_edge_var_map_vector (e
);
232 for (gsi
= gsi_start_phis (e
->dest
), i
= 0;
233 !gsi_end_p (gsi
) && VEC_iterate (edge_var_map
, v
, i
, vm
);
234 gsi_next (&gsi
), i
++)
238 phi
= gsi_stmt (gsi
);
239 def
= redirect_edge_var_map_def (vm
);
240 add_phi_arg (phi
, def
, e
, redirect_edge_var_map_location (vm
));
243 redirect_edge_var_map_clear (e
);
246 /* Return true if SSA_NAME is malformed and mark it visited.
248 IS_VIRTUAL is true if this SSA_NAME was found inside a virtual
252 verify_ssa_name (tree ssa_name
, bool is_virtual
)
254 if (TREE_CODE (ssa_name
) != SSA_NAME
)
256 error ("expected an SSA_NAME object");
260 if (TREE_TYPE (ssa_name
) != TREE_TYPE (SSA_NAME_VAR (ssa_name
)))
262 error ("type mismatch between an SSA_NAME and its symbol");
266 if (SSA_NAME_IN_FREE_LIST (ssa_name
))
268 error ("found an SSA_NAME that had been released into the free pool");
272 if (is_virtual
&& is_gimple_reg (ssa_name
))
274 error ("found a virtual definition for a GIMPLE register");
278 if (is_virtual
&& SSA_NAME_VAR (ssa_name
) != gimple_vop (cfun
))
280 error ("virtual SSA name for non-VOP decl");
284 if (!is_virtual
&& !is_gimple_reg (ssa_name
))
286 error ("found a real definition for a non-register");
290 if (SSA_NAME_IS_DEFAULT_DEF (ssa_name
)
291 && !gimple_nop_p (SSA_NAME_DEF_STMT (ssa_name
)))
293 error ("found a default name with a non-empty defining statement");
301 /* Return true if the definition of SSA_NAME at block BB is malformed.
303 STMT is the statement where SSA_NAME is created.
305 DEFINITION_BLOCK is an array of basic blocks indexed by SSA_NAME
306 version numbers. If DEFINITION_BLOCK[SSA_NAME_VERSION] is set,
307 it means that the block in that array slot contains the
308 definition of SSA_NAME.
310 IS_VIRTUAL is true if SSA_NAME is created by a VDEF. */
313 verify_def (basic_block bb
, basic_block
*definition_block
, tree ssa_name
,
314 gimple stmt
, bool is_virtual
)
316 if (verify_ssa_name (ssa_name
, is_virtual
))
319 if (definition_block
[SSA_NAME_VERSION (ssa_name
)])
321 error ("SSA_NAME created in two different blocks %i and %i",
322 definition_block
[SSA_NAME_VERSION (ssa_name
)]->index
, bb
->index
);
326 definition_block
[SSA_NAME_VERSION (ssa_name
)] = bb
;
328 if (SSA_NAME_DEF_STMT (ssa_name
) != stmt
)
330 error ("SSA_NAME_DEF_STMT is wrong");
331 fprintf (stderr
, "Expected definition statement:\n");
332 print_gimple_stmt (stderr
, SSA_NAME_DEF_STMT (ssa_name
), 4, TDF_VOPS
);
333 fprintf (stderr
, "\nActual definition statement:\n");
334 print_gimple_stmt (stderr
, stmt
, 4, TDF_VOPS
);
341 fprintf (stderr
, "while verifying SSA_NAME ");
342 print_generic_expr (stderr
, ssa_name
, 0);
343 fprintf (stderr
, " in statement\n");
344 print_gimple_stmt (stderr
, stmt
, 4, TDF_VOPS
);
350 /* Return true if the use of SSA_NAME at statement STMT in block BB is
353 DEF_BB is the block where SSA_NAME was found to be created.
355 IDOM contains immediate dominator information for the flowgraph.
357 CHECK_ABNORMAL is true if the caller wants to check whether this use
358 is flowing through an abnormal edge (only used when checking PHI
361 If NAMES_DEFINED_IN_BB is not NULL, it contains a bitmap of ssa names
362 that are defined before STMT in basic block BB. */
365 verify_use (basic_block bb
, basic_block def_bb
, use_operand_p use_p
,
366 gimple stmt
, bool check_abnormal
, bitmap names_defined_in_bb
)
369 tree ssa_name
= USE_FROM_PTR (use_p
);
371 if (!TREE_VISITED (ssa_name
))
372 if (verify_imm_links (stderr
, ssa_name
))
375 TREE_VISITED (ssa_name
) = 1;
377 if (gimple_nop_p (SSA_NAME_DEF_STMT (ssa_name
))
378 && SSA_NAME_IS_DEFAULT_DEF (ssa_name
))
379 ; /* Default definitions have empty statements. Nothing to do. */
382 error ("missing definition");
385 else if (bb
!= def_bb
386 && !dominated_by_p (CDI_DOMINATORS
, bb
, def_bb
))
388 error ("definition in block %i does not dominate use in block %i",
389 def_bb
->index
, bb
->index
);
392 else if (bb
== def_bb
393 && names_defined_in_bb
!= NULL
394 && !bitmap_bit_p (names_defined_in_bb
, SSA_NAME_VERSION (ssa_name
)))
396 error ("definition in block %i follows the use", def_bb
->index
);
401 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ssa_name
))
403 error ("SSA_NAME_OCCURS_IN_ABNORMAL_PHI should be set");
407 /* Make sure the use is in an appropriate list by checking the previous
408 element to make sure it's the same. */
409 if (use_p
->prev
== NULL
)
411 error ("no immediate_use list");
417 if (use_p
->prev
->use
== NULL
)
418 listvar
= use_p
->prev
->loc
.ssa_name
;
420 listvar
= USE_FROM_PTR (use_p
->prev
);
421 if (listvar
!= ssa_name
)
423 error ("wrong immediate use list");
430 fprintf (stderr
, "for SSA_NAME: ");
431 print_generic_expr (stderr
, ssa_name
, TDF_VOPS
);
432 fprintf (stderr
, " in statement:\n");
433 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
);
440 /* Return true if any of the arguments for PHI node PHI at block BB is
443 DEFINITION_BLOCK is an array of basic blocks indexed by SSA_NAME
444 version numbers. If DEFINITION_BLOCK[SSA_NAME_VERSION] is set,
445 it means that the block in that array slot contains the
446 definition of SSA_NAME. */
449 verify_phi_args (gimple phi
, basic_block bb
, basic_block
*definition_block
)
453 size_t i
, phi_num_args
= gimple_phi_num_args (phi
);
455 if (EDGE_COUNT (bb
->preds
) != phi_num_args
)
457 error ("incoming edge count does not match number of PHI arguments");
462 for (i
= 0; i
< phi_num_args
; i
++)
464 use_operand_p op_p
= gimple_phi_arg_imm_use_ptr (phi
, i
);
465 tree op
= USE_FROM_PTR (op_p
);
467 e
= EDGE_PRED (bb
, i
);
471 error ("PHI argument is missing for edge %d->%d",
478 if (TREE_CODE (op
) != SSA_NAME
&& !is_gimple_min_invariant (op
))
480 error ("PHI argument is not SSA_NAME, or invariant");
484 if (TREE_CODE (op
) == SSA_NAME
)
486 err
= verify_ssa_name (op
, !is_gimple_reg (gimple_phi_result (phi
)));
487 err
|= verify_use (e
->src
, definition_block
[SSA_NAME_VERSION (op
)],
488 op_p
, phi
, e
->flags
& EDGE_ABNORMAL
, NULL
);
491 if (TREE_CODE (op
) == ADDR_EXPR
)
493 tree base
= TREE_OPERAND (op
, 0);
494 while (handled_component_p (base
))
495 base
= TREE_OPERAND (base
, 0);
496 if ((TREE_CODE (base
) == VAR_DECL
497 || TREE_CODE (base
) == PARM_DECL
498 || TREE_CODE (base
) == RESULT_DECL
)
499 && !TREE_ADDRESSABLE (base
))
501 error ("address taken, but ADDRESSABLE bit not set");
508 error ("wrong edge %d->%d for PHI argument",
509 e
->src
->index
, e
->dest
->index
);
515 fprintf (stderr
, "PHI argument\n");
516 print_generic_stmt (stderr
, op
, TDF_VOPS
);
524 fprintf (stderr
, "for PHI node\n");
525 print_gimple_stmt (stderr
, phi
, 0, TDF_VOPS
|TDF_MEMSYMS
);
533 /* Verify common invariants in the SSA web.
534 TODO: verify the variable annotations. */
537 verify_ssa (bool check_modified_stmt
)
541 basic_block
*definition_block
= XCNEWVEC (basic_block
, num_ssa_names
);
544 enum dom_state orig_dom_state
= dom_info_state (CDI_DOMINATORS
);
545 bitmap names_defined_in_bb
= BITMAP_ALLOC (NULL
);
547 gcc_assert (!need_ssa_update_p (cfun
));
551 timevar_push (TV_TREE_SSA_VERIFY
);
553 /* Keep track of SSA names present in the IL. */
554 for (i
= 1; i
< num_ssa_names
; i
++)
556 tree name
= ssa_name (i
);
560 TREE_VISITED (name
) = 0;
562 stmt
= SSA_NAME_DEF_STMT (name
);
563 if (!gimple_nop_p (stmt
))
565 basic_block bb
= gimple_bb (stmt
);
566 verify_def (bb
, definition_block
,
567 name
, stmt
, !is_gimple_reg (name
));
573 calculate_dominance_info (CDI_DOMINATORS
);
575 /* Now verify all the uses and make sure they agree with the definitions
576 found in the previous pass. */
582 gimple_stmt_iterator gsi
;
584 /* Make sure that all edges have a clear 'aux' field. */
585 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
589 error ("AUX pointer initialized for edge %d->%d", e
->src
->index
,
595 /* Verify the arguments for every PHI node in the block. */
596 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
598 phi
= gsi_stmt (gsi
);
599 if (verify_phi_args (phi
, bb
, definition_block
))
602 bitmap_set_bit (names_defined_in_bb
,
603 SSA_NAME_VERSION (gimple_phi_result (phi
)));
606 /* Now verify all the uses and vuses in every statement of the block. */
607 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
609 gimple stmt
= gsi_stmt (gsi
);
613 if (check_modified_stmt
&& gimple_modified_p (stmt
))
615 error ("stmt (%p) marked modified after optimization pass: ",
617 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
);
621 if (is_gimple_assign (stmt
)
622 && TREE_CODE (gimple_assign_lhs (stmt
)) != SSA_NAME
)
624 tree lhs
, base_address
;
626 lhs
= gimple_assign_lhs (stmt
);
627 base_address
= get_base_address (lhs
);
630 && SSA_VAR_P (base_address
)
631 && !gimple_vdef (stmt
)
634 error ("statement makes a memory store, but has no VDEFS");
635 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
);
640 /* Verify the single virtual operand and its constraints. */
642 if (gimple_vdef (stmt
))
644 if (gimple_vdef_op (stmt
) == NULL_DEF_OPERAND_P
)
646 error ("statement has VDEF operand not in defs list");
649 if (!gimple_vuse (stmt
))
651 error ("statement has VDEF but no VUSE operand");
654 else if (SSA_NAME_VAR (gimple_vdef (stmt
))
655 != SSA_NAME_VAR (gimple_vuse (stmt
)))
657 error ("VDEF and VUSE do not use the same symbol");
660 has_err
|= verify_ssa_name (gimple_vdef (stmt
), true);
662 if (gimple_vuse (stmt
))
664 if (gimple_vuse_op (stmt
) == NULL_USE_OPERAND_P
)
666 error ("statement has VUSE operand not in uses list");
669 has_err
|= verify_ssa_name (gimple_vuse (stmt
), true);
673 error ("in statement");
674 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
|TDF_MEMSYMS
);
678 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, iter
, SSA_OP_USE
|SSA_OP_DEF
)
680 if (verify_ssa_name (op
, false))
682 error ("in statement");
683 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
|TDF_MEMSYMS
);
688 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_USE
|SSA_OP_VUSE
)
690 op
= USE_FROM_PTR (use_p
);
691 if (verify_use (bb
, definition_block
[SSA_NAME_VERSION (op
)],
692 use_p
, stmt
, false, names_defined_in_bb
))
696 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, iter
, SSA_OP_ALL_DEFS
)
698 if (SSA_NAME_DEF_STMT (op
) != stmt
)
700 error ("SSA_NAME_DEF_STMT is wrong");
701 fprintf (stderr
, "Expected definition statement:\n");
702 print_gimple_stmt (stderr
, stmt
, 4, TDF_VOPS
);
703 fprintf (stderr
, "\nActual definition statement:\n");
704 print_gimple_stmt (stderr
, SSA_NAME_DEF_STMT (op
),
708 bitmap_set_bit (names_defined_in_bb
, SSA_NAME_VERSION (op
));
712 bitmap_clear (names_defined_in_bb
);
715 free (definition_block
);
717 /* Restore the dominance information to its prior known state, so
718 that we do not perturb the compiler's subsequent behavior. */
719 if (orig_dom_state
== DOM_NONE
)
720 free_dominance_info (CDI_DOMINATORS
);
722 set_dom_info_availability (CDI_DOMINATORS
, orig_dom_state
);
724 BITMAP_FREE (names_defined_in_bb
);
725 timevar_pop (TV_TREE_SSA_VERIFY
);
729 internal_error ("verify_ssa failed");
732 /* Return true if the uid in both int tree maps are equal. */
735 int_tree_map_eq (const void *va
, const void *vb
)
737 const struct int_tree_map
*a
= (const struct int_tree_map
*) va
;
738 const struct int_tree_map
*b
= (const struct int_tree_map
*) vb
;
739 return (a
->uid
== b
->uid
);
742 /* Hash a UID in a int_tree_map. */
745 int_tree_map_hash (const void *item
)
747 return ((const struct int_tree_map
*)item
)->uid
;
750 /* Return true if the DECL_UID in both trees are equal. */
753 uid_decl_map_eq (const void *va
, const void *vb
)
755 const_tree a
= (const_tree
) va
;
756 const_tree b
= (const_tree
) vb
;
757 return (a
->decl_minimal
.uid
== b
->decl_minimal
.uid
);
760 /* Hash a tree in a uid_decl_map. */
763 uid_decl_map_hash (const void *item
)
765 return ((const_tree
)item
)->decl_minimal
.uid
;
768 /* Return true if the DECL_UID in both trees are equal. */
771 uid_ssaname_map_eq (const void *va
, const void *vb
)
773 const_tree a
= (const_tree
) va
;
774 const_tree b
= (const_tree
) vb
;
775 return (a
->ssa_name
.var
->decl_minimal
.uid
== b
->ssa_name
.var
->decl_minimal
.uid
);
778 /* Hash a tree in a uid_decl_map. */
781 uid_ssaname_map_hash (const void *item
)
783 return ((const_tree
)item
)->ssa_name
.var
->decl_minimal
.uid
;
787 /* Initialize global DFA and SSA structures. */
790 init_tree_ssa (struct function
*fn
)
792 fn
->gimple_df
= GGC_CNEW (struct gimple_df
);
793 fn
->gimple_df
->referenced_vars
= htab_create_ggc (20, uid_decl_map_hash
,
794 uid_decl_map_eq
, NULL
);
795 fn
->gimple_df
->default_defs
= htab_create_ggc (20, uid_ssaname_map_hash
,
796 uid_ssaname_map_eq
, NULL
);
797 pt_solution_reset (&fn
->gimple_df
->escaped
);
798 pt_solution_reset (&fn
->gimple_df
->callused
);
799 init_ssanames (fn
, 0);
804 /* Deallocate memory associated with SSA data structures for FNDECL. */
807 delete_tree_ssa (void)
809 referenced_var_iterator rvi
;
812 /* Remove annotations from every referenced local variable. */
813 FOR_EACH_REFERENCED_VAR (var
, rvi
)
815 if (is_global_var (var
))
818 ggc_free (var
->base
.ann
);
819 var
->base
.ann
= NULL
;
821 htab_delete (gimple_referenced_vars (cfun
));
822 cfun
->gimple_df
->referenced_vars
= NULL
;
827 /* We no longer maintain the SSA operand cache at this point. */
828 if (ssa_operands_active ())
829 fini_ssa_operands ();
831 delete_alias_heapvars ();
833 htab_delete (cfun
->gimple_df
->default_defs
);
834 cfun
->gimple_df
->default_defs
= NULL
;
835 pt_solution_reset (&cfun
->gimple_df
->escaped
);
836 pt_solution_reset (&cfun
->gimple_df
->callused
);
837 if (cfun
->gimple_df
->decls_to_pointers
!= NULL
)
838 pointer_map_destroy (cfun
->gimple_df
->decls_to_pointers
);
839 cfun
->gimple_df
->decls_to_pointers
= NULL
;
840 cfun
->gimple_df
->modified_noreturn_calls
= NULL
;
841 cfun
->gimple_df
= NULL
;
843 /* We no longer need the edge variable maps. */
844 redirect_edge_var_map_destroy ();
847 /* Return true if the conversion from INNER_TYPE to OUTER_TYPE is a
848 useless type conversion, otherwise return false.
850 This function implicitly defines the middle-end type system. With
851 the notion of 'a < b' meaning that useless_type_conversion_p (a, b)
852 holds and 'a > b' meaning that useless_type_conversion_p (b, a) holds,
853 the following invariants shall be fulfilled:
855 1) useless_type_conversion_p is transitive.
856 If a < b and b < c then a < c.
858 2) useless_type_conversion_p is not symmetric.
859 From a < b does not follow a > b.
861 3) Types define the available set of operations applicable to values.
862 A type conversion is useless if the operations for the target type
863 is a subset of the operations for the source type. For example
864 casts to void* are useless, casts from void* are not (void* can't
865 be dereferenced or offsetted, but copied, hence its set of operations
866 is a strict subset of that of all other data pointer types). Casts
867 to const T* are useless (can't be written to), casts from const T*
871 useless_type_conversion_p (tree outer_type
, tree inner_type
)
873 /* Do the following before stripping toplevel qualifiers. */
874 if (POINTER_TYPE_P (inner_type
)
875 && POINTER_TYPE_P (outer_type
))
877 /* If the outer type is (void *) or a pointer to an incomplete
878 record type or a pointer to an unprototyped function,
879 then the conversion is not necessary. */
880 if (VOID_TYPE_P (TREE_TYPE (outer_type
))
881 || (AGGREGATE_TYPE_P (TREE_TYPE (outer_type
))
882 && TREE_CODE (TREE_TYPE (outer_type
)) != ARRAY_TYPE
883 && (TREE_CODE (TREE_TYPE (outer_type
))
884 == TREE_CODE (TREE_TYPE (inner_type
)))
885 && !COMPLETE_TYPE_P (TREE_TYPE (outer_type
)))
886 || ((TREE_CODE (TREE_TYPE (outer_type
)) == FUNCTION_TYPE
887 || TREE_CODE (TREE_TYPE (outer_type
)) == METHOD_TYPE
)
888 && (TREE_CODE (TREE_TYPE (outer_type
))
889 == TREE_CODE (TREE_TYPE (inner_type
)))
890 && !TYPE_ARG_TYPES (TREE_TYPE (outer_type
))
891 && useless_type_conversion_p (TREE_TYPE (TREE_TYPE (outer_type
)),
892 TREE_TYPE (TREE_TYPE (inner_type
)))))
895 /* Do not lose casts to restrict qualified pointers. */
896 if ((TYPE_RESTRICT (outer_type
)
897 != TYPE_RESTRICT (inner_type
))
898 && TYPE_RESTRICT (outer_type
))
902 /* From now on qualifiers on value types do not matter. */
903 inner_type
= TYPE_MAIN_VARIANT (inner_type
);
904 outer_type
= TYPE_MAIN_VARIANT (outer_type
);
906 if (inner_type
== outer_type
)
909 /* If we know the canonical types, compare them. */
910 if (TYPE_CANONICAL (inner_type
)
911 && TYPE_CANONICAL (inner_type
) == TYPE_CANONICAL (outer_type
))
914 /* Changes in machine mode are never useless conversions unless we
915 deal with aggregate types in which case we defer to later checks. */
916 if (TYPE_MODE (inner_type
) != TYPE_MODE (outer_type
)
917 && !AGGREGATE_TYPE_P (inner_type
))
920 /* If both the inner and outer types are integral types, then the
921 conversion is not necessary if they have the same mode and
922 signedness and precision, and both or neither are boolean. */
923 if (INTEGRAL_TYPE_P (inner_type
)
924 && INTEGRAL_TYPE_P (outer_type
))
926 /* Preserve changes in signedness or precision. */
927 if (TYPE_UNSIGNED (inner_type
) != TYPE_UNSIGNED (outer_type
)
928 || TYPE_PRECISION (inner_type
) != TYPE_PRECISION (outer_type
))
931 /* We don't need to preserve changes in the types minimum or
932 maximum value in general as these do not generate code
933 unless the types precisions are different. */
937 /* Scalar floating point types with the same mode are compatible. */
938 else if (SCALAR_FLOAT_TYPE_P (inner_type
)
939 && SCALAR_FLOAT_TYPE_P (outer_type
))
942 /* Fixed point types with the same mode are compatible. */
943 else if (FIXED_POINT_TYPE_P (inner_type
)
944 && FIXED_POINT_TYPE_P (outer_type
))
947 /* We need to take special care recursing to pointed-to types. */
948 else if (POINTER_TYPE_P (inner_type
)
949 && POINTER_TYPE_P (outer_type
))
951 /* Don't lose casts between pointers to volatile and non-volatile
952 qualified types. Doing so would result in changing the semantics
953 of later accesses. For function types the volatile qualifier
954 is used to indicate noreturn functions. */
955 if (TREE_CODE (TREE_TYPE (outer_type
)) != FUNCTION_TYPE
956 && TREE_CODE (TREE_TYPE (outer_type
)) != METHOD_TYPE
957 && TREE_CODE (TREE_TYPE (inner_type
)) != FUNCTION_TYPE
958 && TREE_CODE (TREE_TYPE (inner_type
)) != METHOD_TYPE
959 && (TYPE_VOLATILE (TREE_TYPE (outer_type
))
960 != TYPE_VOLATILE (TREE_TYPE (inner_type
)))
961 && TYPE_VOLATILE (TREE_TYPE (outer_type
)))
964 /* We require explicit conversions from incomplete target types. */
965 if (!COMPLETE_TYPE_P (TREE_TYPE (inner_type
))
966 && COMPLETE_TYPE_P (TREE_TYPE (outer_type
)))
969 /* Do not lose casts between pointers that when dereferenced access
970 memory with different alias sets. */
971 if (get_deref_alias_set (inner_type
) != get_deref_alias_set (outer_type
))
974 /* We do not care for const qualification of the pointed-to types
975 as const qualification has no semantic value to the middle-end. */
977 /* Otherwise pointers/references are equivalent if their pointed
978 to types are effectively the same. We can strip qualifiers
979 on pointed-to types for further comparison, which is done in
980 the callee. Note we have to use true compatibility here
981 because addresses are subject to propagation into dereferences
982 and thus might get the original type exposed which is equivalent
983 to a reverse conversion. */
984 return types_compatible_p (TREE_TYPE (outer_type
),
985 TREE_TYPE (inner_type
));
988 /* Recurse for complex types. */
989 else if (TREE_CODE (inner_type
) == COMPLEX_TYPE
990 && TREE_CODE (outer_type
) == COMPLEX_TYPE
)
991 return useless_type_conversion_p (TREE_TYPE (outer_type
),
992 TREE_TYPE (inner_type
));
994 /* Recurse for vector types with the same number of subparts. */
995 else if (TREE_CODE (inner_type
) == VECTOR_TYPE
996 && TREE_CODE (outer_type
) == VECTOR_TYPE
997 && TYPE_PRECISION (inner_type
) == TYPE_PRECISION (outer_type
))
998 return useless_type_conversion_p (TREE_TYPE (outer_type
),
999 TREE_TYPE (inner_type
));
1001 else if (TREE_CODE (inner_type
) == ARRAY_TYPE
1002 && TREE_CODE (outer_type
) == ARRAY_TYPE
)
1004 /* Preserve string attributes. */
1005 if (TYPE_STRING_FLAG (inner_type
) != TYPE_STRING_FLAG (outer_type
))
1008 /* Conversions from array types with unknown extent to
1009 array types with known extent are not useless. */
1010 if (!TYPE_DOMAIN (inner_type
)
1011 && TYPE_DOMAIN (outer_type
))
1014 /* Nor are conversions from array types with non-constant size to
1015 array types with constant size or to different size. */
1016 if (TYPE_SIZE (outer_type
)
1017 && TREE_CODE (TYPE_SIZE (outer_type
)) == INTEGER_CST
1018 && (!TYPE_SIZE (inner_type
)
1019 || TREE_CODE (TYPE_SIZE (inner_type
)) != INTEGER_CST
1020 || !tree_int_cst_equal (TYPE_SIZE (outer_type
),
1021 TYPE_SIZE (inner_type
))))
1024 /* Check conversions between arrays with partially known extents.
1025 If the array min/max values are constant they have to match.
1026 Otherwise allow conversions to unknown and variable extents.
1027 In particular this declares conversions that may change the
1028 mode to BLKmode as useless. */
1029 if (TYPE_DOMAIN (inner_type
)
1030 && TYPE_DOMAIN (outer_type
)
1031 && TYPE_DOMAIN (inner_type
) != TYPE_DOMAIN (outer_type
))
1033 tree inner_min
= TYPE_MIN_VALUE (TYPE_DOMAIN (inner_type
));
1034 tree outer_min
= TYPE_MIN_VALUE (TYPE_DOMAIN (outer_type
));
1035 tree inner_max
= TYPE_MAX_VALUE (TYPE_DOMAIN (inner_type
));
1036 tree outer_max
= TYPE_MAX_VALUE (TYPE_DOMAIN (outer_type
));
1038 /* After gimplification a variable min/max value carries no
1039 additional information compared to a NULL value. All that
1040 matters has been lowered to be part of the IL. */
1041 if (inner_min
&& TREE_CODE (inner_min
) != INTEGER_CST
)
1042 inner_min
= NULL_TREE
;
1043 if (outer_min
&& TREE_CODE (outer_min
) != INTEGER_CST
)
1044 outer_min
= NULL_TREE
;
1045 if (inner_max
&& TREE_CODE (inner_max
) != INTEGER_CST
)
1046 inner_max
= NULL_TREE
;
1047 if (outer_max
&& TREE_CODE (outer_max
) != INTEGER_CST
)
1048 outer_max
= NULL_TREE
;
1050 /* Conversions NULL / variable <- cst are useless, but not
1051 the other way around. */
1054 || !tree_int_cst_equal (inner_min
, outer_min
)))
1058 || !tree_int_cst_equal (inner_max
, outer_max
)))
1062 /* Recurse on the element check. */
1063 return useless_type_conversion_p (TREE_TYPE (outer_type
),
1064 TREE_TYPE (inner_type
));
1067 else if ((TREE_CODE (inner_type
) == FUNCTION_TYPE
1068 || TREE_CODE (inner_type
) == METHOD_TYPE
)
1069 && TREE_CODE (inner_type
) == TREE_CODE (outer_type
))
1071 tree outer_parm
, inner_parm
;
1073 /* If the return types are not compatible bail out. */
1074 if (!useless_type_conversion_p (TREE_TYPE (outer_type
),
1075 TREE_TYPE (inner_type
)))
1078 /* Method types should belong to a compatible base class. */
1079 if (TREE_CODE (inner_type
) == METHOD_TYPE
1080 && !useless_type_conversion_p (TYPE_METHOD_BASETYPE (outer_type
),
1081 TYPE_METHOD_BASETYPE (inner_type
)))
1084 /* A conversion to an unprototyped argument list is ok. */
1085 if (!TYPE_ARG_TYPES (outer_type
))
1088 /* If the argument types are compatible the conversion is useless. */
1089 if (TYPE_ARG_TYPES (outer_type
) == TYPE_ARG_TYPES (inner_type
))
1092 for (outer_parm
= TYPE_ARG_TYPES (outer_type
),
1093 inner_parm
= TYPE_ARG_TYPES (inner_type
);
1094 outer_parm
&& inner_parm
;
1095 outer_parm
= TREE_CHAIN (outer_parm
),
1096 inner_parm
= TREE_CHAIN (inner_parm
))
1097 if (!useless_type_conversion_p (TREE_VALUE (outer_parm
),
1098 TREE_VALUE (inner_parm
)))
1101 /* If there is a mismatch in the number of arguments the functions
1102 are not compatible. */
1103 if (outer_parm
|| inner_parm
)
1106 /* Defer to the target if necessary. */
1107 if (TYPE_ATTRIBUTES (inner_type
) || TYPE_ATTRIBUTES (outer_type
))
1108 return targetm
.comp_type_attributes (outer_type
, inner_type
) != 0;
1113 /* For aggregates we rely on TYPE_CANONICAL exclusively and require
1114 explicit conversions for types involving to be structurally
1116 else if (AGGREGATE_TYPE_P (inner_type
)
1117 && TREE_CODE (inner_type
) == TREE_CODE (outer_type
))
1123 /* Return true if a conversion from either type of TYPE1 and TYPE2
1124 to the other is not required. Otherwise return false. */
1127 types_compatible_p (tree type1
, tree type2
)
1129 return (type1
== type2
1130 || (useless_type_conversion_p (type1
, type2
)
1131 && useless_type_conversion_p (type2
, type1
)));
1134 /* Return true if EXPR is a useless type conversion, otherwise return
1138 tree_ssa_useless_type_conversion (tree expr
)
1140 /* If we have an assignment that merely uses a NOP_EXPR to change
1141 the top of the RHS to the type of the LHS and the type conversion
1142 is "safe", then strip away the type conversion so that we can
1143 enter LHS = RHS into the const_and_copies table. */
1144 if (CONVERT_EXPR_P (expr
)
1145 || TREE_CODE (expr
) == VIEW_CONVERT_EXPR
1146 || TREE_CODE (expr
) == NON_LVALUE_EXPR
)
1147 return useless_type_conversion_p
1149 TREE_TYPE (TREE_OPERAND (expr
, 0)));
1154 /* Strip conversions from EXP according to
1155 tree_ssa_useless_type_conversion and return the resulting
1159 tree_ssa_strip_useless_type_conversions (tree exp
)
1161 while (tree_ssa_useless_type_conversion (exp
))
1162 exp
= TREE_OPERAND (exp
, 0);
1167 /* Internal helper for walk_use_def_chains. VAR, FN and DATA are as
1168 described in walk_use_def_chains.
1170 VISITED is a pointer set used to mark visited SSA_NAMEs to avoid
1171 infinite loops. We used to have a bitmap for this to just mark
1172 SSA versions we had visited. But non-sparse bitmaps are way too
1173 expensive, while sparse bitmaps may cause quadratic behavior.
1175 IS_DFS is true if the caller wants to perform a depth-first search
1176 when visiting PHI nodes. A DFS will visit each PHI argument and
1177 call FN after each one. Otherwise, all the arguments are
1178 visited first and then FN is called with each of the visited
1179 arguments in a separate pass. */
1182 walk_use_def_chains_1 (tree var
, walk_use_def_chains_fn fn
, void *data
,
1183 struct pointer_set_t
*visited
, bool is_dfs
)
1187 if (pointer_set_insert (visited
, var
))
1190 def_stmt
= SSA_NAME_DEF_STMT (var
);
1192 if (gimple_code (def_stmt
) != GIMPLE_PHI
)
1194 /* If we reached the end of the use-def chain, call FN. */
1195 return fn (var
, def_stmt
, data
);
1201 /* When doing a breadth-first search, call FN before following the
1202 use-def links for each argument. */
1204 for (i
= 0; i
< gimple_phi_num_args (def_stmt
); i
++)
1205 if (fn (gimple_phi_arg_def (def_stmt
, i
), def_stmt
, data
))
1208 /* Follow use-def links out of each PHI argument. */
1209 for (i
= 0; i
< gimple_phi_num_args (def_stmt
); i
++)
1211 tree arg
= gimple_phi_arg_def (def_stmt
, i
);
1213 /* ARG may be NULL for newly introduced PHI nodes. */
1215 && TREE_CODE (arg
) == SSA_NAME
1216 && walk_use_def_chains_1 (arg
, fn
, data
, visited
, is_dfs
))
1220 /* When doing a depth-first search, call FN after following the
1221 use-def links for each argument. */
1223 for (i
= 0; i
< gimple_phi_num_args (def_stmt
); i
++)
1224 if (fn (gimple_phi_arg_def (def_stmt
, i
), def_stmt
, data
))
1233 /* Walk use-def chains starting at the SSA variable VAR. Call
1234 function FN at each reaching definition found. FN takes three
1235 arguments: VAR, its defining statement (DEF_STMT) and a generic
1236 pointer to whatever state information that FN may want to maintain
1237 (DATA). FN is able to stop the walk by returning true, otherwise
1238 in order to continue the walk, FN should return false.
1240 Note, that if DEF_STMT is a PHI node, the semantics are slightly
1241 different. The first argument to FN is no longer the original
1242 variable VAR, but the PHI argument currently being examined. If FN
1243 wants to get at VAR, it should call PHI_RESULT (PHI).
1245 If IS_DFS is true, this function will:
1247 1- walk the use-def chains for all the PHI arguments, and,
1248 2- call (*FN) (ARG, PHI, DATA) on all the PHI arguments.
1250 If IS_DFS is false, the two steps above are done in reverse order
1251 (i.e., a breadth-first search). */
1254 walk_use_def_chains (tree var
, walk_use_def_chains_fn fn
, void *data
,
1259 gcc_assert (TREE_CODE (var
) == SSA_NAME
);
1261 def_stmt
= SSA_NAME_DEF_STMT (var
);
1263 /* We only need to recurse if the reaching definition comes from a PHI
1265 if (gimple_code (def_stmt
) != GIMPLE_PHI
)
1266 (*fn
) (var
, def_stmt
, data
);
1269 struct pointer_set_t
*visited
= pointer_set_create ();
1270 walk_use_def_chains_1 (var
, fn
, data
, visited
, is_dfs
);
1271 pointer_set_destroy (visited
);
1276 /* Return true if T, an SSA_NAME, has an undefined value. */
1279 ssa_undefined_value_p (tree t
)
1281 tree var
= SSA_NAME_VAR (t
);
1283 /* Parameters get their initial value from the function entry. */
1284 if (TREE_CODE (var
) == PARM_DECL
)
1287 /* Hard register variables get their initial value from the ether. */
1288 if (TREE_CODE (var
) == VAR_DECL
&& DECL_HARD_REGISTER (var
))
1291 /* The value is undefined iff its definition statement is empty. */
1292 return gimple_nop_p (SSA_NAME_DEF_STMT (t
));
1295 /* Emit warnings for uninitialized variables. This is done in two passes.
1297 The first pass notices real uses of SSA names with undefined values.
1298 Such uses are unconditionally uninitialized, and we can be certain that
1299 such a use is a mistake. This pass is run before most optimizations,
1300 so that we catch as many as we can.
1302 The second pass follows PHI nodes to find uses that are potentially
1303 uninitialized. In this case we can't necessarily prove that the use
1304 is really uninitialized. This pass is run after most optimizations,
1305 so that we thread as many jumps and possible, and delete as much dead
1306 code as possible, in order to reduce false positives. We also look
1307 again for plain uninitialized variables, since optimization may have
1308 changed conditionally uninitialized to unconditionally uninitialized. */
1310 /* Emit a warning for T, an SSA_NAME, being uninitialized. The exact
1311 warning text is in MSGID and LOCUS may contain a location or be null. */
1314 warn_uninit (tree t
, const char *gmsgid
, void *data
)
1316 tree var
= SSA_NAME_VAR (t
);
1317 gimple context
= (gimple
) data
;
1318 location_t location
;
1319 expanded_location xloc
, floc
;
1321 if (!ssa_undefined_value_p (t
))
1324 /* TREE_NO_WARNING either means we already warned, or the front end
1325 wishes to suppress the warning. */
1326 if (TREE_NO_WARNING (var
))
1329 /* Do not warn if it can be initialized outside this module. */
1330 if (is_global_var (var
))
1333 location
= (context
!= NULL
&& gimple_has_location (context
))
1334 ? gimple_location (context
)
1335 : DECL_SOURCE_LOCATION (var
);
1336 xloc
= expand_location (location
);
1337 floc
= expand_location (DECL_SOURCE_LOCATION (cfun
->decl
));
1338 if (warning_at (location
, OPT_Wuninitialized
, gmsgid
, var
))
1340 TREE_NO_WARNING (var
) = 1;
1342 if (xloc
.file
!= floc
.file
1343 || xloc
.line
< floc
.line
1344 || xloc
.line
> LOCATION_LINE (cfun
->function_end_locus
))
1345 inform (DECL_SOURCE_LOCATION (var
), "%qD was declared here", var
);
1351 bool always_executed
;
1352 bool warn_possibly_uninitialized
;
1355 /* Called via walk_tree, look for SSA_NAMEs that have empty definitions
1356 and warn about them. */
1359 warn_uninitialized_var (tree
*tp
, int *walk_subtrees
, void *data_
)
1361 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data_
;
1362 struct walk_data
*data
= (struct walk_data
*) wi
->info
;
1365 /* We do not care about LHS. */
1368 /* Except for operands of INDIRECT_REF. */
1369 if (!INDIRECT_REF_P (t
))
1371 t
= TREE_OPERAND (t
, 0);
1374 switch (TREE_CODE (t
))
1377 /* Taking the address of an uninitialized variable does not
1378 count as using it. */
1384 /* A VAR_DECL in the RHS of a gimple statement may mean that
1385 this variable is loaded from memory. */
1389 /* If there is not gimple stmt,
1390 or alias information has not been computed,
1391 then we cannot check VUSE ops. */
1392 if (data
->stmt
== NULL
)
1395 /* If the load happens as part of a call do not warn about it. */
1396 if (is_gimple_call (data
->stmt
))
1399 vuse
= gimple_vuse_op (data
->stmt
);
1400 if (vuse
== NULL_USE_OPERAND_P
)
1403 op
= USE_FROM_PTR (vuse
);
1404 if (t
!= SSA_NAME_VAR (op
)
1405 || !SSA_NAME_IS_DEFAULT_DEF (op
))
1407 /* If this is a VUSE of t and it is the default definition,
1408 then warn about op. */
1410 /* Fall through into SSA_NAME. */
1414 /* We only do data flow with SSA_NAMEs, so that's all we
1416 if (data
->always_executed
)
1417 warn_uninit (t
, "%qD is used uninitialized in this function",
1419 else if (data
->warn_possibly_uninitialized
)
1420 warn_uninit (t
, "%qD may be used uninitialized in this function",
1427 /* The total store transformation performed during gimplification
1428 creates uninitialized variable uses. If all is well, these will
1429 be optimized away, so don't warn now. */
1430 if (TREE_CODE (TREE_OPERAND (t
, 0)) == SSA_NAME
)
1435 if (IS_TYPE_OR_DECL_P (t
))
1443 /* Look for inputs to PHI that are SSA_NAMEs that have empty definitions
1444 and warn about them. */
1447 warn_uninitialized_phi (gimple phi
)
1449 size_t i
, n
= gimple_phi_num_args (phi
);
1451 /* Don't look at memory tags. */
1452 if (!is_gimple_reg (gimple_phi_result (phi
)))
1455 for (i
= 0; i
< n
; ++i
)
1457 tree op
= gimple_phi_arg_def (phi
, i
);
1458 if (TREE_CODE (op
) == SSA_NAME
)
1459 warn_uninit (op
, "%qD may be used uninitialized in this function",
1465 warn_uninitialized_vars (bool warn_possibly_uninitialized
)
1467 gimple_stmt_iterator gsi
;
1469 struct walk_data data
;
1471 data
.warn_possibly_uninitialized
= warn_possibly_uninitialized
;
1473 calculate_dominance_info (CDI_POST_DOMINATORS
);
1477 data
.always_executed
= dominated_by_p (CDI_POST_DOMINATORS
,
1478 single_succ (ENTRY_BLOCK_PTR
), bb
);
1479 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1481 struct walk_stmt_info wi
;
1482 data
.stmt
= gsi_stmt (gsi
);
1483 memset (&wi
, 0, sizeof (wi
));
1485 walk_gimple_op (gsi_stmt (gsi
), warn_uninitialized_var
, &wi
);
1489 /* Post-dominator information can not be reliably updated. Free it
1492 free_dominance_info (CDI_POST_DOMINATORS
);
1497 execute_early_warn_uninitialized (void)
1499 /* Currently, this pass runs always but
1500 execute_late_warn_uninitialized only runs with optimization. With
1501 optimization we want to warn about possible uninitialized as late
1502 as possible, thus don't do it here. However, without
1503 optimization we need to warn here about "may be uninitialized".
1505 warn_uninitialized_vars (/*warn_possibly_uninitialized=*/!optimize
);
1510 execute_late_warn_uninitialized (void)
1513 gimple_stmt_iterator gsi
;
1515 /* Re-do the plain uninitialized variable check, as optimization may have
1516 straightened control flow. Do this first so that we don't accidentally
1517 get a "may be" warning when we'd have seen an "is" warning later. */
1518 warn_uninitialized_vars (/*warn_possibly_uninitialized=*/1);
1521 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1522 warn_uninitialized_phi (gsi_stmt (gsi
));
1528 gate_warn_uninitialized (void)
1530 return warn_uninitialized
!= 0;
1533 struct gimple_opt_pass pass_early_warn_uninitialized
=
1538 gate_warn_uninitialized
, /* gate */
1539 execute_early_warn_uninitialized
, /* execute */
1542 0, /* static_pass_number */
1543 TV_NONE
, /* tv_id */
1544 PROP_ssa
, /* properties_required */
1545 0, /* properties_provided */
1546 0, /* properties_destroyed */
1547 0, /* todo_flags_start */
1548 0 /* todo_flags_finish */
1552 struct gimple_opt_pass pass_late_warn_uninitialized
=
1557 gate_warn_uninitialized
, /* gate */
1558 execute_late_warn_uninitialized
, /* execute */
1561 0, /* static_pass_number */
1562 TV_NONE
, /* tv_id */
1563 PROP_ssa
, /* properties_required */
1564 0, /* properties_provided */
1565 0, /* properties_destroyed */
1566 0, /* todo_flags_start */
1567 0 /* todo_flags_finish */
1571 /* Compute TREE_ADDRESSABLE and DECL_GIMPLE_REG_P for local variables. */
1574 execute_update_addresses_taken (bool do_optimize
)
1577 referenced_var_iterator rvi
;
1578 gimple_stmt_iterator gsi
;
1580 bitmap addresses_taken
= BITMAP_ALLOC (NULL
);
1581 bitmap not_reg_needs
= BITMAP_ALLOC (NULL
);
1582 bool update_vops
= false;
1584 /* Collect into ADDRESSES_TAKEN all variables whose address is taken within
1585 the function body. */
1588 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1590 gimple stmt
= gsi_stmt (gsi
);
1591 enum gimple_code code
= gimple_code (stmt
);
1593 /* Note all addresses taken by the stmt. */
1594 gimple_ior_addresses_taken (addresses_taken
, stmt
);
1596 /* If we have a call or an assignment, see if the lhs contains
1597 a local decl that requires not to be a gimple register. */
1598 if (code
== GIMPLE_ASSIGN
|| code
== GIMPLE_CALL
)
1600 tree lhs
= gimple_get_lhs (stmt
);
1602 /* We may not rewrite TMR_SYMBOL to SSA. */
1603 if (lhs
&& TREE_CODE (lhs
) == TARGET_MEM_REF
1604 && TMR_SYMBOL (lhs
))
1605 bitmap_set_bit (not_reg_needs
, DECL_UID (TMR_SYMBOL (lhs
)));
1607 /* A plain decl does not need it set. */
1608 else if (lhs
&& handled_component_p (lhs
))
1610 var
= get_base_address (lhs
);
1612 bitmap_set_bit (not_reg_needs
, DECL_UID (var
));
1617 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1620 gimple phi
= gsi_stmt (gsi
);
1622 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
1624 tree op
= PHI_ARG_DEF (phi
, i
), var
;
1625 if (TREE_CODE (op
) == ADDR_EXPR
1626 && (var
= get_base_address (TREE_OPERAND (op
, 0))) != NULL
1628 bitmap_set_bit (addresses_taken
, DECL_UID (var
));
1633 /* When possible, clear ADDRESSABLE bit or set the REGISTER bit
1634 and mark variable for conversion into SSA. */
1635 if (optimize
&& do_optimize
)
1636 FOR_EACH_REFERENCED_VAR (var
, rvi
)
1638 /* Global Variables, result decls cannot be changed. */
1639 if (is_global_var (var
)
1640 || TREE_CODE (var
) == RESULT_DECL
1641 || bitmap_bit_p (addresses_taken
, DECL_UID (var
)))
1644 if (TREE_ADDRESSABLE (var
)
1645 /* Do not change TREE_ADDRESSABLE if we need to preserve var as
1646 a non-register. Otherwise we are confused and forget to
1647 add virtual operands for it. */
1648 && (!is_gimple_reg_type (TREE_TYPE (var
))
1649 || !bitmap_bit_p (not_reg_needs
, DECL_UID (var
))))
1651 TREE_ADDRESSABLE (var
) = 0;
1652 if (is_gimple_reg (var
))
1653 mark_sym_for_renaming (var
);
1657 fprintf (dump_file
, "No longer having address taken ");
1658 print_generic_expr (dump_file
, var
, 0);
1659 fprintf (dump_file
, "\n");
1662 if (!DECL_GIMPLE_REG_P (var
)
1663 && !bitmap_bit_p (not_reg_needs
, DECL_UID (var
))
1664 && (TREE_CODE (TREE_TYPE (var
)) == COMPLEX_TYPE
1665 || TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
)
1666 && !TREE_THIS_VOLATILE (var
)
1667 && (TREE_CODE (var
) != VAR_DECL
|| !DECL_HARD_REGISTER (var
)))
1669 DECL_GIMPLE_REG_P (var
) = 1;
1670 mark_sym_for_renaming (var
);
1674 fprintf (dump_file
, "Decl is now a gimple register ");
1675 print_generic_expr (dump_file
, var
, 0);
1676 fprintf (dump_file
, "\n");
1681 /* Operand caches needs to be recomputed for operands referencing the updated
1686 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1688 gimple stmt
= gsi_stmt (gsi
);
1690 if (gimple_references_memory_p (stmt
))
1694 /* Update SSA form here, we are called as non-pass as well. */
1695 update_ssa (TODO_update_ssa
);
1698 BITMAP_FREE (not_reg_needs
);
1699 BITMAP_FREE (addresses_taken
);
1702 struct gimple_opt_pass pass_update_address_taken
=
1706 "addressables", /* name */
1711 0, /* static_pass_number */
1712 TV_NONE
, /* tv_id */
1713 PROP_ssa
, /* properties_required */
1714 0, /* properties_provided */
1715 0, /* properties_destroyed */
1716 0, /* todo_flags_start */
1717 TODO_update_address_taken
1718 | TODO_dump_func
/* todo_flags_finish */