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 /* Given a tree for an expression for which we might want to emit
247 locations or values in debug information (generally a variable, but
248 we might deal with other kinds of trees in the future), return the
249 tree that should be used as the variable of a DEBUG_BIND STMT or
250 VAR_LOCATION INSN or NOTE. Return NULL if VAR is not to be tracked. */
253 target_for_debug_bind (tree var)
255 if (!MAY_HAVE_DEBUG_STMTS)
258 if (TREE_CODE (var) != VAR_DECL
259 && TREE_CODE (var) != PARM_DECL)
262 if (DECL_HAS_VALUE_EXPR_P (var))
263 return target_for_debug_bind (DECL_VALUE_EXPR (var));
265 if (DECL_IGNORED_P (var))
268 if (!is_gimple_reg (var))
274 /* Called via walk_tree, look for SSA_NAMEs that have already been
278 find_released_ssa_name (tree *tp, int *walk_subtrees, void *data_)
280 struct walk_stmt_info *wi = (struct walk_stmt_info *) data_;
285 if (TREE_CODE (*tp) == SSA_NAME)
287 if (SSA_NAME_IN_FREE_LIST (*tp))
292 else if (IS_TYPE_OR_DECL_P (*tp))
298 /* Given a VAR whose definition STMT is to be moved to the iterator
299 position TOGSIP in the TOBB basic block, verify whether we're
300 moving it across any of the debug statements that use it, and
301 adjust them as needed. If TOBB is NULL, then the definition is
302 understood as being removed, and TOGSIP is unused. */
304 propagate_var_def_into_debug_stmts (tree var,
306 const gimple_stmt_iterator *togsip)
308 imm_use_iterator imm_iter;
312 bool no_value = false;
314 if (!MAY_HAVE_DEBUG_STMTS)
317 FOR_EACH_IMM_USE_STMT (stmt, imm_iter, var)
320 gimple_stmt_iterator si;
322 if (!is_gimple_debug (stmt))
327 bb = gimple_bb (stmt);
331 gcc_assert (dom_info_available_p (CDI_DOMINATORS));
332 if (dominated_by_p (CDI_DOMINATORS, bb, tobb))
348 while (gsi_stmt (si) != stmt);
355 /* Here we compute (lazily) the value assigned to VAR, but we
356 remember if we tried before and failed, so that we don't try
358 if (!value && !no_value)
360 gimple def_stmt = SSA_NAME_DEF_STMT (var);
362 if (is_gimple_assign (def_stmt))
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
371 dominance order, we may sometimes encounter SSA_NAMEs
372 that have already been released, referenced in other
373 SSA_DEFs that we're about to release. Consider:
382 If we deleted BB X first, propagating the value of
383 w_2 won't do us any good. It's too late to recover
384 their original definition of v_1: when it was
385 deleted, it was only referenced in other DEFs, it
386 couldn't possibly know it should have been retained,
387 and propagating every single DEF just in case it
388 might have to be propagated into a DEBUG STMT would
389 probably be too wasteful.
391 When dominator information is not readily
392 available, we check for and accept some loss of
393 debug information. But if it is available,
394 there's no excuse for us to remove blocks in the
395 wrong order, so we don't even check for dead SSA
396 NAMEs. SSA verification shall catch any
398 if (!walk_gimple_op (def_stmt, find_released_ssa_name, &wi))
403 value = gimple_assign_rhs_to_tree (def_stmt);
411 gimple_debug_bind_reset_value (stmt);
413 FOR_EACH_IMM_USE_ON_STMT (use_p, imm_iter)
414 SET_USE (use_p, unshare_expr (value));
421 /* Given a STMT to be moved to the iterator position TOBSIP in the
422 TOBB basic block, verify whether we're moving it across any of the
423 debug statements that use it. If TOBB is NULL, then the definition
424 is understood as being removed, and TOBSIP is unused. */
427 propagate_defs_into_debug_stmts (gimple def, basic_block tobb,
428 const gimple_stmt_iterator *togsip)
433 if (!MAY_HAVE_DEBUG_STMTS)
436 FOR_EACH_SSA_DEF_OPERAND (def_p, def, op_iter, SSA_OP_DEF)
438 tree var = DEF_FROM_PTR (def_p);
440 if (TREE_CODE (var) != SSA_NAME)
443 propagate_var_def_into_debug_stmts (var, tobb, togsip);
447 /* Return true if SSA_NAME is malformed and mark it visited.
449 IS_VIRTUAL is true if this SSA_NAME was found inside a virtual
453 verify_ssa_name (tree ssa_name, bool is_virtual)
455 if (TREE_CODE (ssa_name) != SSA_NAME)
457 error ("expected an SSA_NAME object");
461 if (TREE_TYPE (ssa_name) != TREE_TYPE (SSA_NAME_VAR (ssa_name)))
463 error ("type mismatch between an SSA_NAME and its symbol");
467 if (SSA_NAME_IN_FREE_LIST (ssa_name))
469 error ("found an SSA_NAME that had been released into the free pool");
473 if (is_virtual && is_gimple_reg (ssa_name))
475 error ("found a virtual definition for a GIMPLE register");
479 if (is_virtual && SSA_NAME_VAR (ssa_name) != gimple_vop (cfun))
481 error ("virtual SSA name for non-VOP decl");
485 if (!is_virtual && !is_gimple_reg (ssa_name))
487 error ("found a real definition for a non-register");
491 if (SSA_NAME_IS_DEFAULT_DEF (ssa_name)
492 && !gimple_nop_p (SSA_NAME_DEF_STMT (ssa_name)))
494 error ("found a default name with a non-empty defining statement");
502 /* Return true if the definition of SSA_NAME at block BB is malformed.
504 STMT is the statement where SSA_NAME is created.
506 DEFINITION_BLOCK is an array of basic blocks indexed by SSA_NAME
507 version numbers. If DEFINITION_BLOCK[SSA_NAME_VERSION] is set,
508 it means that the block in that array slot contains the
509 definition of SSA_NAME.
511 IS_VIRTUAL is true if SSA_NAME is created by a VDEF. */
514 verify_def (basic_block bb, basic_block *definition_block, tree ssa_name,
515 gimple stmt, bool is_virtual)
517 if (verify_ssa_name (ssa_name, is_virtual))
520 if (definition_block[SSA_NAME_VERSION (ssa_name)])
522 error ("SSA_NAME created in two different blocks %i and %i",
523 definition_block[SSA_NAME_VERSION (ssa_name)]->index, bb->index);
527 definition_block[SSA_NAME_VERSION (ssa_name)] = bb;
529 if (SSA_NAME_DEF_STMT (ssa_name) != stmt)
531 error ("SSA_NAME_DEF_STMT is wrong");
532 fprintf (stderr, "Expected definition statement:\n");
533 print_gimple_stmt (stderr, SSA_NAME_DEF_STMT (ssa_name), 4, TDF_VOPS);
534 fprintf (stderr, "\nActual definition statement:\n");
535 print_gimple_stmt (stderr, stmt, 4, TDF_VOPS);
542 fprintf (stderr, "while verifying SSA_NAME ");
543 print_generic_expr (stderr, ssa_name, 0);
544 fprintf (stderr, " in statement\n");
545 print_gimple_stmt (stderr, stmt, 4, TDF_VOPS);
551 /* Return true if the use of SSA_NAME at statement STMT in block BB is
554 DEF_BB is the block where SSA_NAME was found to be created.
556 IDOM contains immediate dominator information for the flowgraph.
558 CHECK_ABNORMAL is true if the caller wants to check whether this use
559 is flowing through an abnormal edge (only used when checking PHI
562 If NAMES_DEFINED_IN_BB is not NULL, it contains a bitmap of ssa names
563 that are defined before STMT in basic block BB. */
566 verify_use (basic_block bb, basic_block def_bb, use_operand_p use_p,
567 gimple stmt, bool check_abnormal, bitmap names_defined_in_bb)
570 tree ssa_name = USE_FROM_PTR (use_p);
572 if (!TREE_VISITED (ssa_name))
573 if (verify_imm_links (stderr, ssa_name))
576 TREE_VISITED (ssa_name) = 1;
578 if (gimple_nop_p (SSA_NAME_DEF_STMT (ssa_name))
579 && SSA_NAME_IS_DEFAULT_DEF (ssa_name))
580 ; /* Default definitions have empty statements. Nothing to do. */
583 error ("missing definition");
586 else if (bb != def_bb
587 && !dominated_by_p (CDI_DOMINATORS, bb, def_bb))
589 error ("definition in block %i does not dominate use in block %i",
590 def_bb->index, bb->index);
593 else if (bb == def_bb
594 && names_defined_in_bb != NULL
595 && !bitmap_bit_p (names_defined_in_bb, SSA_NAME_VERSION (ssa_name)))
597 error ("definition in block %i follows the use", def_bb->index);
602 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ssa_name))
604 error ("SSA_NAME_OCCURS_IN_ABNORMAL_PHI should be set");
608 /* Make sure the use is in an appropriate list by checking the previous
609 element to make sure it's the same. */
610 if (use_p->prev == NULL)
612 error ("no immediate_use list");
618 if (use_p->prev->use == NULL)
619 listvar = use_p->prev->loc.ssa_name;
621 listvar = USE_FROM_PTR (use_p->prev);
622 if (listvar != ssa_name)
624 error ("wrong immediate use list");
631 fprintf (stderr, "for SSA_NAME: ");
632 print_generic_expr (stderr, ssa_name, TDF_VOPS);
633 fprintf (stderr, " in statement:\n");
634 print_gimple_stmt (stderr, stmt, 0, TDF_VOPS);
641 /* Return true if any of the arguments for PHI node PHI at block BB is
644 DEFINITION_BLOCK is an array of basic blocks indexed by SSA_NAME
645 version numbers. If DEFINITION_BLOCK[SSA_NAME_VERSION] is set,
646 it means that the block in that array slot contains the
647 definition of SSA_NAME. */
650 verify_phi_args (gimple phi, basic_block bb, basic_block *definition_block)
654 size_t i, phi_num_args = gimple_phi_num_args (phi);
656 if (EDGE_COUNT (bb->preds) != phi_num_args)
658 error ("incoming edge count does not match number of PHI arguments");
663 for (i = 0; i < phi_num_args; i++)
665 use_operand_p op_p = gimple_phi_arg_imm_use_ptr (phi, i);
666 tree op = USE_FROM_PTR (op_p);
668 e = EDGE_PRED (bb, i);
672 error ("PHI argument is missing for edge %d->%d",
679 if (TREE_CODE (op) != SSA_NAME && !is_gimple_min_invariant (op))
681 error ("PHI argument is not SSA_NAME, or invariant");
685 if (TREE_CODE (op) == SSA_NAME)
687 err = verify_ssa_name (op, !is_gimple_reg (gimple_phi_result (phi)));
688 err |= verify_use (e->src, definition_block[SSA_NAME_VERSION (op)],
689 op_p, phi, e->flags & EDGE_ABNORMAL, NULL);
692 if (TREE_CODE (op) == ADDR_EXPR)
694 tree base = TREE_OPERAND (op, 0);
695 while (handled_component_p (base))
696 base = TREE_OPERAND (base, 0);
697 if ((TREE_CODE (base) == VAR_DECL
698 || TREE_CODE (base) == PARM_DECL
699 || TREE_CODE (base) == RESULT_DECL)
700 && !TREE_ADDRESSABLE (base))
702 error ("address taken, but ADDRESSABLE bit not set");
709 error ("wrong edge %d->%d for PHI argument",
710 e->src->index, e->dest->index);
716 fprintf (stderr, "PHI argument\n");
717 print_generic_stmt (stderr, op, TDF_VOPS);
725 fprintf (stderr, "for PHI node\n");
726 print_gimple_stmt (stderr, phi, 0, TDF_VOPS|TDF_MEMSYMS);
734 /* Verify common invariants in the SSA web.
735 TODO: verify the variable annotations. */
738 verify_ssa (bool check_modified_stmt)
742 basic_block *definition_block = XCNEWVEC (basic_block, num_ssa_names);
745 enum dom_state orig_dom_state = dom_info_state (CDI_DOMINATORS);
746 bitmap names_defined_in_bb = BITMAP_ALLOC (NULL);
748 gcc_assert (!need_ssa_update_p (cfun));
752 timevar_push (TV_TREE_SSA_VERIFY);
754 /* Keep track of SSA names present in the IL. */
755 for (i = 1; i < num_ssa_names; i++)
757 tree name = ssa_name (i);
761 TREE_VISITED (name) = 0;
763 stmt = SSA_NAME_DEF_STMT (name);
764 if (!gimple_nop_p (stmt))
766 basic_block bb = gimple_bb (stmt);
767 verify_def (bb, definition_block,
768 name, stmt, !is_gimple_reg (name));
774 calculate_dominance_info (CDI_DOMINATORS);
776 /* Now verify all the uses and make sure they agree with the definitions
777 found in the previous pass. */
783 gimple_stmt_iterator gsi;
785 /* Make sure that all edges have a clear 'aux' field. */
786 FOR_EACH_EDGE (e, ei, bb->preds)
790 error ("AUX pointer initialized for edge %d->%d", e->src->index,
796 /* Verify the arguments for every PHI node in the block. */
797 for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
799 phi = gsi_stmt (gsi);
800 if (verify_phi_args (phi, bb, definition_block))
803 bitmap_set_bit (names_defined_in_bb,
804 SSA_NAME_VERSION (gimple_phi_result (phi)));
807 /* Now verify all the uses and vuses in every statement of the block. */
808 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
810 gimple stmt = gsi_stmt (gsi);
814 if (check_modified_stmt && gimple_modified_p (stmt))
816 error ("stmt (%p) marked modified after optimization pass: ",
818 print_gimple_stmt (stderr, stmt, 0, TDF_VOPS);
822 if (is_gimple_assign (stmt)
823 && TREE_CODE (gimple_assign_lhs (stmt)) != SSA_NAME)
825 tree lhs, base_address;
827 lhs = gimple_assign_lhs (stmt);
828 base_address = get_base_address (lhs);
831 && SSA_VAR_P (base_address)
832 && !gimple_vdef (stmt)
835 error ("statement makes a memory store, but has no VDEFS");
836 print_gimple_stmt (stderr, stmt, 0, TDF_VOPS);
840 else if (gimple_debug_bind_p (stmt)
841 && !gimple_debug_bind_has_value_p (stmt))
844 /* Verify the single virtual operand and its constraints. */
846 if (gimple_vdef (stmt))
848 if (gimple_vdef_op (stmt) == NULL_DEF_OPERAND_P)
850 error ("statement has VDEF operand not in defs list");
853 if (!gimple_vuse (stmt))
855 error ("statement has VDEF but no VUSE operand");
858 else if (SSA_NAME_VAR (gimple_vdef (stmt))
859 != SSA_NAME_VAR (gimple_vuse (stmt)))
861 error ("VDEF and VUSE do not use the same symbol");
864 has_err |= verify_ssa_name (gimple_vdef (stmt), true);
866 if (gimple_vuse (stmt))
868 if (gimple_vuse_op (stmt) == NULL_USE_OPERAND_P)
870 error ("statement has VUSE operand not in uses list");
873 has_err |= verify_ssa_name (gimple_vuse (stmt), true);
877 error ("in statement");
878 print_gimple_stmt (stderr, stmt, 0, TDF_VOPS|TDF_MEMSYMS);
882 FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_USE|SSA_OP_DEF)
884 if (verify_ssa_name (op, false))
886 error ("in statement");
887 print_gimple_stmt (stderr, stmt, 0, TDF_VOPS|TDF_MEMSYMS);
892 FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_USE|SSA_OP_VUSE)
894 op = USE_FROM_PTR (use_p);
895 if (verify_use (bb, definition_block[SSA_NAME_VERSION (op)],
896 use_p, stmt, false, names_defined_in_bb))
900 FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_ALL_DEFS)
902 if (SSA_NAME_DEF_STMT (op) != stmt)
904 error ("SSA_NAME_DEF_STMT is wrong");
905 fprintf (stderr, "Expected definition statement:\n");
906 print_gimple_stmt (stderr, stmt, 4, TDF_VOPS);
907 fprintf (stderr, "\nActual definition statement:\n");
908 print_gimple_stmt (stderr, SSA_NAME_DEF_STMT (op),
912 bitmap_set_bit (names_defined_in_bb, SSA_NAME_VERSION (op));
916 bitmap_clear (names_defined_in_bb);
919 free (definition_block);
921 /* Restore the dominance information to its prior known state, so
922 that we do not perturb the compiler's subsequent behavior. */
923 if (orig_dom_state == DOM_NONE)
924 free_dominance_info (CDI_DOMINATORS);
926 set_dom_info_availability (CDI_DOMINATORS, orig_dom_state);
928 BITMAP_FREE (names_defined_in_bb);
929 timevar_pop (TV_TREE_SSA_VERIFY);
933 internal_error ("verify_ssa failed");
936 /* Return true if the uid in both int tree maps are equal. */
939 int_tree_map_eq (const void *va, const void *vb)
941 const struct int_tree_map *a = (const struct int_tree_map *) va;
942 const struct int_tree_map *b = (const struct int_tree_map *) vb;
943 return (a->uid == b->uid);
946 /* Hash a UID in a int_tree_map. */
949 int_tree_map_hash (const void *item)
951 return ((const struct int_tree_map *)item)->uid;
954 /* Return true if the DECL_UID in both trees are equal. */
957 uid_decl_map_eq (const void *va, const void *vb)
959 const_tree a = (const_tree) va;
960 const_tree b = (const_tree) vb;
961 return (a->decl_minimal.uid == b->decl_minimal.uid);
964 /* Hash a tree in a uid_decl_map. */
967 uid_decl_map_hash (const void *item)
969 return ((const_tree)item)->decl_minimal.uid;
972 /* Return true if the DECL_UID in both trees are equal. */
975 uid_ssaname_map_eq (const void *va, const void *vb)
977 const_tree a = (const_tree) va;
978 const_tree b = (const_tree) vb;
979 return (a->ssa_name.var->decl_minimal.uid == b->ssa_name.var->decl_minimal.uid);
982 /* Hash a tree in a uid_decl_map. */
985 uid_ssaname_map_hash (const void *item)
987 return ((const_tree)item)->ssa_name.var->decl_minimal.uid;
991 /* Initialize global DFA and SSA structures. */
994 init_tree_ssa (struct function *fn)
996 fn->gimple_df = GGC_CNEW (struct gimple_df);
997 fn->gimple_df->referenced_vars = htab_create_ggc (20, uid_decl_map_hash,
998 uid_decl_map_eq, NULL);
999 fn->gimple_df->default_defs = htab_create_ggc (20, uid_ssaname_map_hash,
1000 uid_ssaname_map_eq, NULL);
1001 pt_solution_reset (&fn->gimple_df->escaped);
1002 pt_solution_reset (&fn->gimple_df->callused);
1003 init_ssanames (fn, 0);
1008 /* Deallocate memory associated with SSA data structures for FNDECL. */
1011 delete_tree_ssa (void)
1013 referenced_var_iterator rvi;
1016 /* Remove annotations from every referenced local variable. */
1017 FOR_EACH_REFERENCED_VAR (var, rvi)
1019 if (is_global_var (var))
1022 ggc_free (var->base.ann);
1023 var->base.ann = NULL;
1025 htab_delete (gimple_referenced_vars (cfun));
1026 cfun->gimple_df->referenced_vars = NULL;
1031 /* We no longer maintain the SSA operand cache at this point. */
1032 if (ssa_operands_active ())
1033 fini_ssa_operands ();
1035 delete_alias_heapvars ();
1037 htab_delete (cfun->gimple_df->default_defs);
1038 cfun->gimple_df->default_defs = NULL;
1039 pt_solution_reset (&cfun->gimple_df->escaped);
1040 pt_solution_reset (&cfun->gimple_df->callused);
1041 if (cfun->gimple_df->decls_to_pointers != NULL)
1042 pointer_map_destroy (cfun->gimple_df->decls_to_pointers);
1043 cfun->gimple_df->decls_to_pointers = NULL;
1044 cfun->gimple_df->modified_noreturn_calls = NULL;
1045 cfun->gimple_df = NULL;
1047 /* We no longer need the edge variable maps. */
1048 redirect_edge_var_map_destroy ();
1051 /* Return true if the conversion from INNER_TYPE to OUTER_TYPE is a
1052 useless type conversion, otherwise return false.
1054 This function implicitly defines the middle-end type system. With
1055 the notion of 'a < b' meaning that useless_type_conversion_p (a, b)
1056 holds and 'a > b' meaning that useless_type_conversion_p (b, a) holds,
1057 the following invariants shall be fulfilled:
1059 1) useless_type_conversion_p is transitive.
1060 If a < b and b < c then a < c.
1062 2) useless_type_conversion_p is not symmetric.
1063 From a < b does not follow a > b.
1065 3) Types define the available set of operations applicable to values.
1066 A type conversion is useless if the operations for the target type
1067 is a subset of the operations for the source type. For example
1068 casts to void* are useless, casts from void* are not (void* can't
1069 be dereferenced or offsetted, but copied, hence its set of operations
1070 is a strict subset of that of all other data pointer types). Casts
1071 to const T* are useless (can't be written to), casts from const T*
1075 useless_type_conversion_p (tree outer_type, tree inner_type)
1077 /* Do the following before stripping toplevel qualifiers. */
1078 if (POINTER_TYPE_P (inner_type)
1079 && POINTER_TYPE_P (outer_type))
1081 /* If the outer type is (void *) or a pointer to an incomplete
1082 record type or a pointer to an unprototyped function,
1083 then the conversion is not necessary. */
1084 if (VOID_TYPE_P (TREE_TYPE (outer_type))
1085 || (AGGREGATE_TYPE_P (TREE_TYPE (outer_type))
1086 && TREE_CODE (TREE_TYPE (outer_type)) != ARRAY_TYPE
1087 && (TREE_CODE (TREE_TYPE (outer_type))
1088 == TREE_CODE (TREE_TYPE (inner_type)))
1089 && !COMPLETE_TYPE_P (TREE_TYPE (outer_type)))
1090 || ((TREE_CODE (TREE_TYPE (outer_type)) == FUNCTION_TYPE
1091 || TREE_CODE (TREE_TYPE (outer_type)) == METHOD_TYPE)
1092 && (TREE_CODE (TREE_TYPE (outer_type))
1093 == TREE_CODE (TREE_TYPE (inner_type)))
1094 && !TYPE_ARG_TYPES (TREE_TYPE (outer_type))
1095 && useless_type_conversion_p (TREE_TYPE (TREE_TYPE (outer_type)),
1096 TREE_TYPE (TREE_TYPE (inner_type)))))
1099 /* Do not lose casts to restrict qualified pointers. */
1100 if ((TYPE_RESTRICT (outer_type)
1101 != TYPE_RESTRICT (inner_type))
1102 && TYPE_RESTRICT (outer_type))
1106 /* From now on qualifiers on value types do not matter. */
1107 inner_type = TYPE_MAIN_VARIANT (inner_type);
1108 outer_type = TYPE_MAIN_VARIANT (outer_type);
1110 if (inner_type == outer_type)
1113 /* If we know the canonical types, compare them. */
1114 if (TYPE_CANONICAL (inner_type)
1115 && TYPE_CANONICAL (inner_type) == TYPE_CANONICAL (outer_type))
1118 /* Changes in machine mode are never useless conversions unless we
1119 deal with aggregate types in which case we defer to later checks. */
1120 if (TYPE_MODE (inner_type) != TYPE_MODE (outer_type)
1121 && !AGGREGATE_TYPE_P (inner_type))
1124 /* If both the inner and outer types are integral types, then the
1125 conversion is not necessary if they have the same mode and
1126 signedness and precision, and both or neither are boolean. */
1127 if (INTEGRAL_TYPE_P (inner_type)
1128 && INTEGRAL_TYPE_P (outer_type))
1130 /* Preserve changes in signedness or precision. */
1131 if (TYPE_UNSIGNED (inner_type) != TYPE_UNSIGNED (outer_type)
1132 || TYPE_PRECISION (inner_type) != TYPE_PRECISION (outer_type))
1135 /* We don't need to preserve changes in the types minimum or
1136 maximum value in general as these do not generate code
1137 unless the types precisions are different. */
1141 /* Scalar floating point types with the same mode are compatible. */
1142 else if (SCALAR_FLOAT_TYPE_P (inner_type)
1143 && SCALAR_FLOAT_TYPE_P (outer_type))
1146 /* Fixed point types with the same mode are compatible. */
1147 else if (FIXED_POINT_TYPE_P (inner_type)
1148 && FIXED_POINT_TYPE_P (outer_type))
1151 /* We need to take special care recursing to pointed-to types. */
1152 else if (POINTER_TYPE_P (inner_type)
1153 && POINTER_TYPE_P (outer_type))
1155 /* Don't lose casts between pointers to volatile and non-volatile
1156 qualified types. Doing so would result in changing the semantics
1157 of later accesses. For function types the volatile qualifier
1158 is used to indicate noreturn functions. */
1159 if (TREE_CODE (TREE_TYPE (outer_type)) != FUNCTION_TYPE
1160 && TREE_CODE (TREE_TYPE (outer_type)) != METHOD_TYPE
1161 && TREE_CODE (TREE_TYPE (inner_type)) != FUNCTION_TYPE
1162 && TREE_CODE (TREE_TYPE (inner_type)) != METHOD_TYPE
1163 && (TYPE_VOLATILE (TREE_TYPE (outer_type))
1164 != TYPE_VOLATILE (TREE_TYPE (inner_type)))
1165 && TYPE_VOLATILE (TREE_TYPE (outer_type)))
1168 /* We require explicit conversions from incomplete target types. */
1169 if (!COMPLETE_TYPE_P (TREE_TYPE (inner_type))
1170 && COMPLETE_TYPE_P (TREE_TYPE (outer_type)))
1173 /* Do not lose casts between pointers that when dereferenced access
1174 memory with different alias sets. */
1175 if (get_deref_alias_set (inner_type) != get_deref_alias_set (outer_type))
1178 /* We do not care for const qualification of the pointed-to types
1179 as const qualification has no semantic value to the middle-end. */
1181 /* Otherwise pointers/references are equivalent if their pointed
1182 to types are effectively the same. We can strip qualifiers
1183 on pointed-to types for further comparison, which is done in
1184 the callee. Note we have to use true compatibility here
1185 because addresses are subject to propagation into dereferences
1186 and thus might get the original type exposed which is equivalent
1187 to a reverse conversion. */
1188 return types_compatible_p (TREE_TYPE (outer_type),
1189 TREE_TYPE (inner_type));
1192 /* Recurse for complex types. */
1193 else if (TREE_CODE (inner_type) == COMPLEX_TYPE
1194 && TREE_CODE (outer_type) == COMPLEX_TYPE)
1195 return useless_type_conversion_p (TREE_TYPE (outer_type),
1196 TREE_TYPE (inner_type));
1198 /* Recurse for vector types with the same number of subparts. */
1199 else if (TREE_CODE (inner_type) == VECTOR_TYPE
1200 && TREE_CODE (outer_type) == VECTOR_TYPE
1201 && TYPE_PRECISION (inner_type) == TYPE_PRECISION (outer_type))
1202 return useless_type_conversion_p (TREE_TYPE (outer_type),
1203 TREE_TYPE (inner_type));
1205 else if (TREE_CODE (inner_type) == ARRAY_TYPE
1206 && TREE_CODE (outer_type) == ARRAY_TYPE)
1208 /* Preserve string attributes. */
1209 if (TYPE_STRING_FLAG (inner_type) != TYPE_STRING_FLAG (outer_type))
1212 /* Conversions from array types with unknown extent to
1213 array types with known extent are not useless. */
1214 if (!TYPE_DOMAIN (inner_type)
1215 && TYPE_DOMAIN (outer_type))
1218 /* Nor are conversions from array types with non-constant size to
1219 array types with constant size or to different size. */
1220 if (TYPE_SIZE (outer_type)
1221 && TREE_CODE (TYPE_SIZE (outer_type)) == INTEGER_CST
1222 && (!TYPE_SIZE (inner_type)
1223 || TREE_CODE (TYPE_SIZE (inner_type)) != INTEGER_CST
1224 || !tree_int_cst_equal (TYPE_SIZE (outer_type),
1225 TYPE_SIZE (inner_type))))
1228 /* Check conversions between arrays with partially known extents.
1229 If the array min/max values are constant they have to match.
1230 Otherwise allow conversions to unknown and variable extents.
1231 In particular this declares conversions that may change the
1232 mode to BLKmode as useless. */
1233 if (TYPE_DOMAIN (inner_type)
1234 && TYPE_DOMAIN (outer_type)
1235 && TYPE_DOMAIN (inner_type) != TYPE_DOMAIN (outer_type))
1237 tree inner_min = TYPE_MIN_VALUE (TYPE_DOMAIN (inner_type));
1238 tree outer_min = TYPE_MIN_VALUE (TYPE_DOMAIN (outer_type));
1239 tree inner_max = TYPE_MAX_VALUE (TYPE_DOMAIN (inner_type));
1240 tree outer_max = TYPE_MAX_VALUE (TYPE_DOMAIN (outer_type));
1242 /* After gimplification a variable min/max value carries no
1243 additional information compared to a NULL value. All that
1244 matters has been lowered to be part of the IL. */
1245 if (inner_min && TREE_CODE (inner_min) != INTEGER_CST)
1246 inner_min = NULL_TREE;
1247 if (outer_min && TREE_CODE (outer_min) != INTEGER_CST)
1248 outer_min = NULL_TREE;
1249 if (inner_max && TREE_CODE (inner_max) != INTEGER_CST)
1250 inner_max = NULL_TREE;
1251 if (outer_max && TREE_CODE (outer_max) != INTEGER_CST)
1252 outer_max = NULL_TREE;
1254 /* Conversions NULL / variable <- cst are useless, but not
1255 the other way around. */
1258 || !tree_int_cst_equal (inner_min, outer_min)))
1262 || !tree_int_cst_equal (inner_max, outer_max)))
1266 /* Recurse on the element check. */
1267 return useless_type_conversion_p (TREE_TYPE (outer_type),
1268 TREE_TYPE (inner_type));
1271 else if ((TREE_CODE (inner_type) == FUNCTION_TYPE
1272 || TREE_CODE (inner_type) == METHOD_TYPE)
1273 && TREE_CODE (inner_type) == TREE_CODE (outer_type))
1275 tree outer_parm, inner_parm;
1277 /* If the return types are not compatible bail out. */
1278 if (!useless_type_conversion_p (TREE_TYPE (outer_type),
1279 TREE_TYPE (inner_type)))
1282 /* Method types should belong to a compatible base class. */
1283 if (TREE_CODE (inner_type) == METHOD_TYPE
1284 && !useless_type_conversion_p (TYPE_METHOD_BASETYPE (outer_type),
1285 TYPE_METHOD_BASETYPE (inner_type)))
1288 /* A conversion to an unprototyped argument list is ok. */
1289 if (!TYPE_ARG_TYPES (outer_type))
1292 /* If the argument types are compatible the conversion is useless. */
1293 if (TYPE_ARG_TYPES (outer_type) == TYPE_ARG_TYPES (inner_type))
1296 for (outer_parm = TYPE_ARG_TYPES (outer_type),
1297 inner_parm = TYPE_ARG_TYPES (inner_type);
1298 outer_parm && inner_parm;
1299 outer_parm = TREE_CHAIN (outer_parm),
1300 inner_parm = TREE_CHAIN (inner_parm))
1301 if (!useless_type_conversion_p (TREE_VALUE (outer_parm),
1302 TREE_VALUE (inner_parm)))
1305 /* If there is a mismatch in the number of arguments the functions
1306 are not compatible. */
1307 if (outer_parm || inner_parm)
1310 /* Defer to the target if necessary. */
1311 if (TYPE_ATTRIBUTES (inner_type) || TYPE_ATTRIBUTES (outer_type))
1312 return targetm.comp_type_attributes (outer_type, inner_type) != 0;
1317 /* For aggregates we rely on TYPE_CANONICAL exclusively and require
1318 explicit conversions for types involving to be structurally
1320 else if (AGGREGATE_TYPE_P (inner_type)
1321 && TREE_CODE (inner_type) == TREE_CODE (outer_type))
1327 /* Return true if a conversion from either type of TYPE1 and TYPE2
1328 to the other is not required. Otherwise return false. */
1331 types_compatible_p (tree type1, tree type2)
1333 return (type1 == type2
1334 || (useless_type_conversion_p (type1, type2)
1335 && useless_type_conversion_p (type2, type1)));
1338 /* Return true if EXPR is a useless type conversion, otherwise return
1342 tree_ssa_useless_type_conversion (tree expr)
1344 /* If we have an assignment that merely uses a NOP_EXPR to change
1345 the top of the RHS to the type of the LHS and the type conversion
1346 is "safe", then strip away the type conversion so that we can
1347 enter LHS = RHS into the const_and_copies table. */
1348 if (CONVERT_EXPR_P (expr)
1349 || TREE_CODE (expr) == VIEW_CONVERT_EXPR
1350 || TREE_CODE (expr) == NON_LVALUE_EXPR)
1351 return useless_type_conversion_p
1353 TREE_TYPE (TREE_OPERAND (expr, 0)));
1358 /* Strip conversions from EXP according to
1359 tree_ssa_useless_type_conversion and return the resulting
1363 tree_ssa_strip_useless_type_conversions (tree exp)
1365 while (tree_ssa_useless_type_conversion (exp))
1366 exp = TREE_OPERAND (exp, 0);
1371 /* Internal helper for walk_use_def_chains. VAR, FN and DATA are as
1372 described in walk_use_def_chains.
1374 VISITED is a pointer set used to mark visited SSA_NAMEs to avoid
1375 infinite loops. We used to have a bitmap for this to just mark
1376 SSA versions we had visited. But non-sparse bitmaps are way too
1377 expensive, while sparse bitmaps may cause quadratic behavior.
1379 IS_DFS is true if the caller wants to perform a depth-first search
1380 when visiting PHI nodes. A DFS will visit each PHI argument and
1381 call FN after each one. Otherwise, all the arguments are
1382 visited first and then FN is called with each of the visited
1383 arguments in a separate pass. */
1386 walk_use_def_chains_1 (tree var, walk_use_def_chains_fn fn, void *data,
1387 struct pointer_set_t *visited, bool is_dfs)
1391 if (pointer_set_insert (visited, var))
1394 def_stmt = SSA_NAME_DEF_STMT (var);
1396 if (gimple_code (def_stmt) != GIMPLE_PHI)
1398 /* If we reached the end of the use-def chain, call FN. */
1399 return fn (var, def_stmt, data);
1405 /* When doing a breadth-first search, call FN before following the
1406 use-def links for each argument. */
1408 for (i = 0; i < gimple_phi_num_args (def_stmt); i++)
1409 if (fn (gimple_phi_arg_def (def_stmt, i), def_stmt, data))
1412 /* Follow use-def links out of each PHI argument. */
1413 for (i = 0; i < gimple_phi_num_args (def_stmt); i++)
1415 tree arg = gimple_phi_arg_def (def_stmt, i);
1417 /* ARG may be NULL for newly introduced PHI nodes. */
1419 && TREE_CODE (arg) == SSA_NAME
1420 && walk_use_def_chains_1 (arg, fn, data, visited, is_dfs))
1424 /* When doing a depth-first search, call FN after following the
1425 use-def links for each argument. */
1427 for (i = 0; i < gimple_phi_num_args (def_stmt); i++)
1428 if (fn (gimple_phi_arg_def (def_stmt, i), def_stmt, data))
1437 /* Walk use-def chains starting at the SSA variable VAR. Call
1438 function FN at each reaching definition found. FN takes three
1439 arguments: VAR, its defining statement (DEF_STMT) and a generic
1440 pointer to whatever state information that FN may want to maintain
1441 (DATA). FN is able to stop the walk by returning true, otherwise
1442 in order to continue the walk, FN should return false.
1444 Note, that if DEF_STMT is a PHI node, the semantics are slightly
1445 different. The first argument to FN is no longer the original
1446 variable VAR, but the PHI argument currently being examined. If FN
1447 wants to get at VAR, it should call PHI_RESULT (PHI).
1449 If IS_DFS is true, this function will:
1451 1- walk the use-def chains for all the PHI arguments, and,
1452 2- call (*FN) (ARG, PHI, DATA) on all the PHI arguments.
1454 If IS_DFS is false, the two steps above are done in reverse order
1455 (i.e., a breadth-first search). */
1458 walk_use_def_chains (tree var, walk_use_def_chains_fn fn, void *data,
1463 gcc_assert (TREE_CODE (var) == SSA_NAME);
1465 def_stmt = SSA_NAME_DEF_STMT (var);
1467 /* We only need to recurse if the reaching definition comes from a PHI
1469 if (gimple_code (def_stmt) != GIMPLE_PHI)
1470 (*fn) (var, def_stmt, data);
1473 struct pointer_set_t *visited = pointer_set_create ();
1474 walk_use_def_chains_1 (var, fn, data, visited, is_dfs);
1475 pointer_set_destroy (visited);
1480 /* Return true if T, an SSA_NAME, has an undefined value. */
1483 ssa_undefined_value_p (tree t)
1485 tree var = SSA_NAME_VAR (t);
1487 /* Parameters get their initial value from the function entry. */
1488 if (TREE_CODE (var) == PARM_DECL)
1491 /* Hard register variables get their initial value from the ether. */
1492 if (TREE_CODE (var) == VAR_DECL && DECL_HARD_REGISTER (var))
1495 /* The value is undefined iff its definition statement is empty. */
1496 return gimple_nop_p (SSA_NAME_DEF_STMT (t));
1499 /* Emit warnings for uninitialized variables. This is done in two passes.
1501 The first pass notices real uses of SSA names with undefined values.
1502 Such uses are unconditionally uninitialized, and we can be certain that
1503 such a use is a mistake. This pass is run before most optimizations,
1504 so that we catch as many as we can.
1506 The second pass follows PHI nodes to find uses that are potentially
1507 uninitialized. In this case we can't necessarily prove that the use
1508 is really uninitialized. This pass is run after most optimizations,
1509 so that we thread as many jumps and possible, and delete as much dead
1510 code as possible, in order to reduce false positives. We also look
1511 again for plain uninitialized variables, since optimization may have
1512 changed conditionally uninitialized to unconditionally uninitialized. */
1514 /* Emit a warning for T, an SSA_NAME, being uninitialized. The exact
1515 warning text is in MSGID and LOCUS may contain a location or be null. */
1518 warn_uninit (tree t, const char *gmsgid, void *data)
1520 tree var = SSA_NAME_VAR (t);
1521 gimple context = (gimple) data;
1522 location_t location;
1523 expanded_location xloc, floc;
1525 if (!ssa_undefined_value_p (t))
1528 /* TREE_NO_WARNING either means we already warned, or the front end
1529 wishes to suppress the warning. */
1530 if (TREE_NO_WARNING (var))
1533 /* Do not warn if it can be initialized outside this module. */
1534 if (is_global_var (var))
1537 location = (context != NULL && gimple_has_location (context))
1538 ? gimple_location (context)
1539 : DECL_SOURCE_LOCATION (var);
1540 xloc = expand_location (location);
1541 floc = expand_location (DECL_SOURCE_LOCATION (cfun->decl));
1542 if (warning_at (location, OPT_Wuninitialized, gmsgid, var))
1544 TREE_NO_WARNING (var) = 1;
1546 if (xloc.file != floc.file
1547 || xloc.line < floc.line
1548 || xloc.line > LOCATION_LINE (cfun->function_end_locus))
1549 inform (DECL_SOURCE_LOCATION (var), "%qD was declared here", var);
1555 bool always_executed;
1556 bool warn_possibly_uninitialized;
1559 /* Called via walk_tree, look for SSA_NAMEs that have empty definitions
1560 and warn about them. */
1563 warn_uninitialized_var (tree *tp, int *walk_subtrees, void *data_)
1565 struct walk_stmt_info *wi = (struct walk_stmt_info *) data_;
1566 struct walk_data *data = (struct walk_data *) wi->info;
1569 /* We do not care about LHS. */
1572 /* Except for operands of INDIRECT_REF. */
1573 if (!INDIRECT_REF_P (t))
1575 t = TREE_OPERAND (t, 0);
1578 switch (TREE_CODE (t))
1581 /* Taking the address of an uninitialized variable does not
1582 count as using it. */
1588 /* A VAR_DECL in the RHS of a gimple statement may mean that
1589 this variable is loaded from memory. */
1593 /* If there is not gimple stmt,
1594 or alias information has not been computed,
1595 then we cannot check VUSE ops. */
1596 if (data->stmt == NULL)
1599 /* If the load happens as part of a call do not warn about it. */
1600 if (is_gimple_call (data->stmt))
1603 vuse = gimple_vuse_op (data->stmt);
1604 if (vuse == NULL_USE_OPERAND_P)
1607 op = USE_FROM_PTR (vuse);
1608 if (t != SSA_NAME_VAR (op)
1609 || !SSA_NAME_IS_DEFAULT_DEF (op))
1611 /* If this is a VUSE of t and it is the default definition,
1612 then warn about op. */
1614 /* Fall through into SSA_NAME. */
1618 /* We only do data flow with SSA_NAMEs, so that's all we
1620 if (data->always_executed)
1621 warn_uninit (t, "%qD is used uninitialized in this function",
1623 else if (data->warn_possibly_uninitialized)
1624 warn_uninit (t, "%qD may be used uninitialized in this function",
1631 /* The total store transformation performed during gimplification
1632 creates uninitialized variable uses. If all is well, these will
1633 be optimized away, so don't warn now. */
1634 if (TREE_CODE (TREE_OPERAND (t, 0)) == SSA_NAME)
1639 if (IS_TYPE_OR_DECL_P (t))
1647 /* Look for inputs to PHI that are SSA_NAMEs that have empty definitions
1648 and warn about them. */
1651 warn_uninitialized_phi (gimple phi)
1653 size_t i, n = gimple_phi_num_args (phi);
1655 /* Don't look at memory tags. */
1656 if (!is_gimple_reg (gimple_phi_result (phi)))
1659 for (i = 0; i < n; ++i)
1661 tree op = gimple_phi_arg_def (phi, i);
1662 if (TREE_CODE (op) == SSA_NAME)
1663 warn_uninit (op, "%qD may be used uninitialized in this function",
1669 warn_uninitialized_vars (bool warn_possibly_uninitialized)
1671 gimple_stmt_iterator gsi;
1673 struct walk_data data;
1675 data.warn_possibly_uninitialized = warn_possibly_uninitialized;
1677 calculate_dominance_info (CDI_POST_DOMINATORS);
1681 data.always_executed = dominated_by_p (CDI_POST_DOMINATORS,
1682 single_succ (ENTRY_BLOCK_PTR), bb);
1683 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1685 struct walk_stmt_info wi;
1686 data.stmt = gsi_stmt (gsi);
1687 if (is_gimple_debug (data.stmt))
1689 memset (&wi, 0, sizeof (wi));
1691 walk_gimple_op (gsi_stmt (gsi), warn_uninitialized_var, &wi);
1695 /* Post-dominator information can not be reliably updated. Free it
1698 free_dominance_info (CDI_POST_DOMINATORS);
1703 execute_early_warn_uninitialized (void)
1705 /* Currently, this pass runs always but
1706 execute_late_warn_uninitialized only runs with optimization. With
1707 optimization we want to warn about possible uninitialized as late
1708 as possible, thus don't do it here. However, without
1709 optimization we need to warn here about "may be uninitialized".
1711 warn_uninitialized_vars (/*warn_possibly_uninitialized=*/!optimize);
1716 execute_late_warn_uninitialized (void)
1719 gimple_stmt_iterator gsi;
1721 /* Re-do the plain uninitialized variable check, as optimization may have
1722 straightened control flow. Do this first so that we don't accidentally
1723 get a "may be" warning when we'd have seen an "is" warning later. */
1724 warn_uninitialized_vars (/*warn_possibly_uninitialized=*/1);
1727 for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1728 warn_uninitialized_phi (gsi_stmt (gsi));
1734 gate_warn_uninitialized (void)
1736 return warn_uninitialized != 0;
1739 struct gimple_opt_pass pass_early_warn_uninitialized =
1744 gate_warn_uninitialized, /* gate */
1745 execute_early_warn_uninitialized, /* execute */
1748 0, /* static_pass_number */
1749 TV_NONE, /* tv_id */
1750 PROP_ssa, /* properties_required */
1751 0, /* properties_provided */
1752 0, /* properties_destroyed */
1753 0, /* todo_flags_start */
1754 0 /* todo_flags_finish */
1758 struct gimple_opt_pass pass_late_warn_uninitialized =
1763 gate_warn_uninitialized, /* gate */
1764 execute_late_warn_uninitialized, /* execute */
1767 0, /* static_pass_number */
1768 TV_NONE, /* tv_id */
1769 PROP_ssa, /* properties_required */
1770 0, /* properties_provided */
1771 0, /* properties_destroyed */
1772 0, /* todo_flags_start */
1773 0 /* todo_flags_finish */
1777 /* Compute TREE_ADDRESSABLE and DECL_GIMPLE_REG_P for local variables. */
1780 execute_update_addresses_taken (bool do_optimize)
1783 referenced_var_iterator rvi;
1784 gimple_stmt_iterator gsi;
1786 bitmap addresses_taken = BITMAP_ALLOC (NULL);
1787 bitmap not_reg_needs = BITMAP_ALLOC (NULL);
1788 bool update_vops = false;
1790 /* Collect into ADDRESSES_TAKEN all variables whose address is taken within
1791 the function body. */
1794 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1796 gimple stmt = gsi_stmt (gsi);
1797 enum gimple_code code = gimple_code (stmt);
1799 /* Note all addresses taken by the stmt. */
1800 gimple_ior_addresses_taken (addresses_taken, stmt);
1802 /* If we have a call or an assignment, see if the lhs contains
1803 a local decl that requires not to be a gimple register. */
1804 if (code == GIMPLE_ASSIGN || code == GIMPLE_CALL)
1806 tree lhs = gimple_get_lhs (stmt);
1808 /* We may not rewrite TMR_SYMBOL to SSA. */
1809 if (lhs && TREE_CODE (lhs) == TARGET_MEM_REF
1810 && TMR_SYMBOL (lhs))
1811 bitmap_set_bit (not_reg_needs, DECL_UID (TMR_SYMBOL (lhs)));
1813 /* A plain decl does not need it set. */
1814 else if (lhs && handled_component_p (lhs))
1816 var = get_base_address (lhs);
1818 bitmap_set_bit (not_reg_needs, DECL_UID (var));
1823 for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1826 gimple phi = gsi_stmt (gsi);
1828 for (i = 0; i < gimple_phi_num_args (phi); i++)
1830 tree op = PHI_ARG_DEF (phi, i), var;
1831 if (TREE_CODE (op) == ADDR_EXPR
1832 && (var = get_base_address (TREE_OPERAND (op, 0))) != NULL
1834 bitmap_set_bit (addresses_taken, DECL_UID (var));
1839 /* When possible, clear ADDRESSABLE bit or set the REGISTER bit
1840 and mark variable for conversion into SSA. */
1841 if (optimize && do_optimize)
1842 FOR_EACH_REFERENCED_VAR (var, rvi)
1844 /* Global Variables, result decls cannot be changed. */
1845 if (is_global_var (var)
1846 || TREE_CODE (var) == RESULT_DECL
1847 || bitmap_bit_p (addresses_taken, DECL_UID (var)))
1850 if (TREE_ADDRESSABLE (var)
1851 /* Do not change TREE_ADDRESSABLE if we need to preserve var as
1852 a non-register. Otherwise we are confused and forget to
1853 add virtual operands for it. */
1854 && (!is_gimple_reg_type (TREE_TYPE (var))
1855 || !bitmap_bit_p (not_reg_needs, DECL_UID (var))))
1857 TREE_ADDRESSABLE (var) = 0;
1858 if (is_gimple_reg (var))
1859 mark_sym_for_renaming (var);
1863 fprintf (dump_file, "No longer having address taken ");
1864 print_generic_expr (dump_file, var, 0);
1865 fprintf (dump_file, "\n");
1868 if (!DECL_GIMPLE_REG_P (var)
1869 && !bitmap_bit_p (not_reg_needs, DECL_UID (var))
1870 && (TREE_CODE (TREE_TYPE (var)) == COMPLEX_TYPE
1871 || TREE_CODE (TREE_TYPE (var)) == VECTOR_TYPE)
1872 && !TREE_THIS_VOLATILE (var)
1873 && (TREE_CODE (var) != VAR_DECL || !DECL_HARD_REGISTER (var)))
1875 DECL_GIMPLE_REG_P (var) = 1;
1876 mark_sym_for_renaming (var);
1880 fprintf (dump_file, "Decl is now a gimple register ");
1881 print_generic_expr (dump_file, var, 0);
1882 fprintf (dump_file, "\n");
1887 /* Operand caches needs to be recomputed for operands referencing the updated
1892 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1894 gimple stmt = gsi_stmt (gsi);
1896 if (gimple_references_memory_p (stmt))
1900 /* Update SSA form here, we are called as non-pass as well. */
1901 update_ssa (TODO_update_ssa);
1904 BITMAP_FREE (not_reg_needs);
1905 BITMAP_FREE (addresses_taken);
1908 struct gimple_opt_pass pass_update_address_taken =
1912 "addressables", /* name */
1917 0, /* static_pass_number */
1918 TV_NONE, /* tv_id */
1919 PROP_ssa, /* properties_required */
1920 0, /* properties_provided */
1921 0, /* properties_destroyed */
1922 0, /* todo_flags_start */
1923 TODO_update_address_taken
1924 | TODO_dump_func /* todo_flags_finish */