1 /* Miscellaneous SSA utility functions.
2 Copyright (C) 2001-2014 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 GCC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
25 #include "stor-layout.h"
29 #include "langhooks.h"
30 #include "basic-block.h"
32 #include "gimple-pretty-print.h"
33 #include "pointer-set.h"
34 #include "tree-ssa-alias.h"
35 #include "internal-fn.h"
36 #include "gimple-fold.h"
37 #include "gimple-expr.h"
41 #include "gimple-iterator.h"
42 #include "gimple-walk.h"
43 #include "gimple-ssa.h"
44 #include "tree-phinodes.h"
45 #include "ssa-iterators.h"
46 #include "stringpool.h"
47 #include "tree-ssanames.h"
48 #include "tree-ssa-loop-manip.h"
49 #include "tree-into-ssa.h"
51 #include "tree-inline.h"
53 #include "tree-pass.h"
54 #include "diagnostic-core.h"
56 #include "cfgexpand.h"
58 /* Pointer map of variable mappings, keyed by edge. */
59 static struct pointer_map_t
*edge_var_maps
;
62 /* Add a mapping with PHI RESULT and PHI DEF associated with edge E. */
65 redirect_edge_var_map_add (edge e
, tree result
, tree def
, source_location locus
)
68 edge_var_map_vector
*head
;
69 edge_var_map new_node
;
71 if (edge_var_maps
== NULL
)
72 edge_var_maps
= pointer_map_create ();
74 slot
= pointer_map_insert (edge_var_maps
, e
);
75 head
= (edge_var_map_vector
*) *slot
;
77 vec_safe_reserve (head
, 5);
79 new_node
.result
= result
;
80 new_node
.locus
= locus
;
82 vec_safe_push (head
, new_node
);
87 /* Clear the var mappings in edge E. */
90 redirect_edge_var_map_clear (edge e
)
93 edge_var_map_vector
*head
;
98 slot
= pointer_map_contains (edge_var_maps
, e
);
102 head
= (edge_var_map_vector
*) *slot
;
109 /* Duplicate the redirected var mappings in OLDE in NEWE.
111 Since we can't remove a mapping, let's just duplicate it. This assumes a
112 pointer_map can have multiple edges mapping to the same var_map (many to
113 one mapping), since we don't remove the previous mappings. */
116 redirect_edge_var_map_dup (edge newe
, edge olde
)
118 void **new_slot
, **old_slot
;
119 edge_var_map_vector
*head
;
124 new_slot
= pointer_map_insert (edge_var_maps
, newe
);
125 old_slot
= pointer_map_contains (edge_var_maps
, olde
);
128 head
= (edge_var_map_vector
*) *old_slot
;
130 edge_var_map_vector
*new_head
= NULL
;
132 new_head
= vec_safe_copy (head
);
134 vec_safe_reserve (new_head
, 5);
135 *new_slot
= new_head
;
139 /* Return the variable mappings for a given edge. If there is none, return
142 edge_var_map_vector
*
143 redirect_edge_var_map_vector (edge e
)
147 /* Hey, what kind of idiot would... you'd be surprised. */
151 slot
= pointer_map_contains (edge_var_maps
, e
);
155 return (edge_var_map_vector
*) *slot
;
158 /* Used by redirect_edge_var_map_destroy to free all memory. */
161 free_var_map_entry (const void *key ATTRIBUTE_UNUSED
,
163 void *data ATTRIBUTE_UNUSED
)
165 edge_var_map_vector
*head
= (edge_var_map_vector
*) *value
;
170 /* Clear the edge variable mappings. */
173 redirect_edge_var_map_destroy (void)
177 pointer_map_traverse (edge_var_maps
, free_var_map_entry
, NULL
);
178 pointer_map_destroy (edge_var_maps
);
179 edge_var_maps
= NULL
;
184 /* Remove the corresponding arguments from the PHI nodes in E's
185 destination block and redirect it to DEST. Return redirected edge.
186 The list of removed arguments is stored in a vector accessed
187 through edge_var_maps. */
190 ssa_redirect_edge (edge e
, basic_block dest
)
192 gimple_stmt_iterator gsi
;
195 redirect_edge_var_map_clear (e
);
197 /* Remove the appropriate PHI arguments in E's destination block. */
198 for (gsi
= gsi_start_phis (e
->dest
); !gsi_end_p (gsi
); gsi_next (&gsi
))
201 source_location locus
;
203 phi
= gsi_stmt (gsi
);
204 def
= gimple_phi_arg_def (phi
, e
->dest_idx
);
205 locus
= gimple_phi_arg_location (phi
, e
->dest_idx
);
207 if (def
== NULL_TREE
)
210 redirect_edge_var_map_add (e
, gimple_phi_result (phi
), def
, locus
);
213 e
= redirect_edge_succ_nodup (e
, dest
);
219 /* Add PHI arguments queued in PENDING_STMT list on edge E to edge
223 flush_pending_stmts (edge e
)
226 edge_var_map_vector
*v
;
229 gimple_stmt_iterator gsi
;
231 v
= redirect_edge_var_map_vector (e
);
235 for (gsi
= gsi_start_phis (e
->dest
), i
= 0;
236 !gsi_end_p (gsi
) && v
->iterate (i
, &vm
);
237 gsi_next (&gsi
), i
++)
241 phi
= gsi_stmt (gsi
);
242 def
= redirect_edge_var_map_def (vm
);
243 add_phi_arg (phi
, def
, e
, redirect_edge_var_map_location (vm
));
246 redirect_edge_var_map_clear (e
);
249 /* Replace the LHS of STMT, an assignment, either a GIMPLE_ASSIGN or a
250 GIMPLE_CALL, with NLHS, in preparation for modifying the RHS to an
251 expression with a different value.
253 This will update any annotations (say debug bind stmts) referring
254 to the original LHS, so that they use the RHS instead. This is
255 done even if NLHS and LHS are the same, for it is understood that
256 the RHS will be modified afterwards, and NLHS will not be assigned
259 Adjusting any non-annotation uses of the LHS, if needed, is a
260 responsibility of the caller.
262 The effect of this call should be pretty much the same as that of
263 inserting a copy of STMT before STMT, and then removing the
264 original stmt, at which time gsi_remove() would have update
265 annotations, but using this function saves all the inserting,
266 copying and removing. */
269 gimple_replace_ssa_lhs (gimple stmt
, tree nlhs
)
271 if (MAY_HAVE_DEBUG_STMTS
)
273 tree lhs
= gimple_get_lhs (stmt
);
275 gcc_assert (SSA_NAME_DEF_STMT (lhs
) == stmt
);
277 insert_debug_temp_for_var_def (NULL
, lhs
);
280 gimple_set_lhs (stmt
, nlhs
);
284 /* Given a tree for an expression for which we might want to emit
285 locations or values in debug information (generally a variable, but
286 we might deal with other kinds of trees in the future), return the
287 tree that should be used as the variable of a DEBUG_BIND STMT or
288 VAR_LOCATION INSN or NOTE. Return NULL if VAR is not to be tracked. */
291 target_for_debug_bind (tree var
)
293 if (!MAY_HAVE_DEBUG_STMTS
)
296 if (TREE_CODE (var
) == SSA_NAME
)
298 var
= SSA_NAME_VAR (var
);
299 if (var
== NULL_TREE
)
303 if ((TREE_CODE (var
) != VAR_DECL
304 || VAR_DECL_IS_VIRTUAL_OPERAND (var
))
305 && TREE_CODE (var
) != PARM_DECL
)
308 if (DECL_HAS_VALUE_EXPR_P (var
))
309 return target_for_debug_bind (DECL_VALUE_EXPR (var
));
311 if (DECL_IGNORED_P (var
))
314 /* var-tracking only tracks registers. */
315 if (!is_gimple_reg_type (TREE_TYPE (var
)))
321 /* Called via walk_tree, look for SSA_NAMEs that have already been
325 find_released_ssa_name (tree
*tp
, int *walk_subtrees
, void *data_
)
327 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data_
;
329 if (wi
&& wi
->is_lhs
)
332 if (TREE_CODE (*tp
) == SSA_NAME
)
334 if (SSA_NAME_IN_FREE_LIST (*tp
))
339 else if (IS_TYPE_OR_DECL_P (*tp
))
345 /* Insert a DEBUG BIND stmt before the DEF of VAR if VAR is referenced
346 by other DEBUG stmts, and replace uses of the DEF with the
347 newly-created debug temp. */
350 insert_debug_temp_for_var_def (gimple_stmt_iterator
*gsi
, tree var
)
352 imm_use_iterator imm_iter
;
355 gimple def_stmt
= NULL
;
359 if (!MAY_HAVE_DEBUG_STMTS
)
362 /* If this name has already been registered for replacement, do nothing
363 as anything that uses this name isn't in SSA form. */
364 if (name_registered_for_update_p (var
))
367 /* Check whether there are debug stmts that reference this variable and,
368 if there are, decide whether we should use a debug temp. */
369 FOR_EACH_IMM_USE_FAST (use_p
, imm_iter
, var
)
371 stmt
= USE_STMT (use_p
);
373 if (!gimple_debug_bind_p (stmt
))
379 if (gimple_debug_bind_get_value (stmt
) != var
)
381 /* Count this as an additional use, so as to make sure we
382 use a temp unless VAR's definition has a SINGLE_RHS that
393 def_stmt
= gsi_stmt (*gsi
);
395 def_stmt
= SSA_NAME_DEF_STMT (var
);
397 /* If we didn't get an insertion point, and the stmt has already
398 been removed, we won't be able to insert the debug bind stmt, so
399 we'll have to drop debug information. */
400 if (gimple_code (def_stmt
) == GIMPLE_PHI
)
402 value
= degenerate_phi_result (def_stmt
);
403 if (value
&& walk_tree (&value
, find_released_ssa_name
, NULL
, NULL
))
405 /* error_mark_node is what fixup_noreturn_call changes PHI arguments
407 else if (value
== error_mark_node
)
410 else if (is_gimple_assign (def_stmt
))
412 bool no_value
= false;
414 if (!dom_info_available_p (CDI_DOMINATORS
))
416 struct walk_stmt_info wi
;
418 memset (&wi
, 0, sizeof (wi
));
420 /* When removing blocks without following reverse dominance
421 order, we may sometimes encounter SSA_NAMEs that have
422 already been released, referenced in other SSA_DEFs that
423 we're about to release. Consider:
432 If we deleted BB X first, propagating the value of w_2
433 won't do us any good. It's too late to recover their
434 original definition of v_1: when it was deleted, it was
435 only referenced in other DEFs, it couldn't possibly know
436 it should have been retained, and propagating every
437 single DEF just in case it might have to be propagated
438 into a DEBUG STMT would probably be too wasteful.
440 When dominator information is not readily available, we
441 check for and accept some loss of debug information. But
442 if it is available, there's no excuse for us to remove
443 blocks in the wrong order, so we don't even check for
444 dead SSA NAMEs. SSA verification shall catch any
446 if ((!gsi
&& !gimple_bb (def_stmt
))
447 || walk_gimple_op (def_stmt
, find_released_ssa_name
, &wi
))
452 value
= gimple_assign_rhs_to_tree (def_stmt
);
457 /* If there's a single use of VAR, and VAR is the entire debug
458 expression (usecount would have been incremented again
459 otherwise), and the definition involves only constants and
460 SSA names, then we can propagate VALUE into this single use,
463 We can also avoid using a temp if VALUE can be shared and
464 propagated into all uses, without generating expressions that
465 wouldn't be valid gimple RHSs.
467 Other cases that would require unsharing or non-gimple RHSs
468 are deferred to a debug temp, although we could avoid temps
469 at the expense of duplication of expressions. */
471 if (CONSTANT_CLASS_P (value
)
472 || gimple_code (def_stmt
) == GIMPLE_PHI
474 && (!gimple_assign_single_p (def_stmt
)
475 || is_gimple_min_invariant (value
)))
476 || is_gimple_reg (value
))
481 tree vexpr
= make_node (DEBUG_EXPR_DECL
);
483 def_temp
= gimple_build_debug_bind (vexpr
,
484 unshare_expr (value
),
487 DECL_ARTIFICIAL (vexpr
) = 1;
488 TREE_TYPE (vexpr
) = TREE_TYPE (value
);
490 DECL_MODE (vexpr
) = DECL_MODE (value
);
492 DECL_MODE (vexpr
) = TYPE_MODE (TREE_TYPE (value
));
495 gsi_insert_before (gsi
, def_temp
, GSI_SAME_STMT
);
498 gimple_stmt_iterator ngsi
= gsi_for_stmt (def_stmt
);
499 gsi_insert_before (&ngsi
, def_temp
, GSI_SAME_STMT
);
506 FOR_EACH_IMM_USE_STMT (stmt
, imm_iter
, var
)
508 if (!gimple_debug_bind_p (stmt
))
513 FOR_EACH_IMM_USE_ON_STMT (use_p
, imm_iter
)
514 /* unshare_expr is not needed here. vexpr is either a
515 SINGLE_RHS, that can be safely shared, some other RHS
516 that was unshared when we found it had a single debug
517 use, or a DEBUG_EXPR_DECL, that can be safely
519 SET_USE (use_p
, unshare_expr (value
));
520 /* If we didn't replace uses with a debug decl fold the
521 resulting expression. Otherwise we end up with invalid IL. */
522 if (TREE_CODE (value
) != DEBUG_EXPR_DECL
)
524 gimple_stmt_iterator gsi
= gsi_for_stmt (stmt
);
525 fold_stmt_inplace (&gsi
);
529 gimple_debug_bind_reset_value (stmt
);
536 /* Insert a DEBUG BIND stmt before STMT for each DEF referenced by
537 other DEBUG stmts, and replace uses of the DEF with the
538 newly-created debug temp. */
541 insert_debug_temps_for_defs (gimple_stmt_iterator
*gsi
)
547 if (!MAY_HAVE_DEBUG_STMTS
)
550 stmt
= gsi_stmt (*gsi
);
552 FOR_EACH_PHI_OR_STMT_DEF (def_p
, stmt
, op_iter
, SSA_OP_DEF
)
554 tree var
= DEF_FROM_PTR (def_p
);
556 if (TREE_CODE (var
) != SSA_NAME
)
559 insert_debug_temp_for_var_def (gsi
, var
);
563 /* Reset all debug stmts that use SSA_NAME(s) defined in STMT. */
566 reset_debug_uses (gimple stmt
)
570 imm_use_iterator imm_iter
;
573 if (!MAY_HAVE_DEBUG_STMTS
)
576 FOR_EACH_PHI_OR_STMT_DEF (def_p
, stmt
, op_iter
, SSA_OP_DEF
)
578 tree var
= DEF_FROM_PTR (def_p
);
580 if (TREE_CODE (var
) != SSA_NAME
)
583 FOR_EACH_IMM_USE_STMT (use_stmt
, imm_iter
, var
)
585 if (!gimple_debug_bind_p (use_stmt
))
588 gimple_debug_bind_reset_value (use_stmt
);
589 update_stmt (use_stmt
);
594 /* Delete SSA DEFs for SSA versions in the TOREMOVE bitmap, removing
595 dominated stmts before their dominators, so that release_ssa_defs
596 stands a chance of propagating DEFs into debug bind stmts. */
599 release_defs_bitset (bitmap toremove
)
604 /* Performing a topological sort is probably overkill, this will
605 most likely run in slightly superlinear time, rather than the
606 pathological quadratic worst case. */
607 while (!bitmap_empty_p (toremove
))
608 EXECUTE_IF_SET_IN_BITMAP (toremove
, 0, j
, bi
)
610 bool remove_now
= true;
611 tree var
= ssa_name (j
);
613 imm_use_iterator uit
;
615 FOR_EACH_IMM_USE_STMT (stmt
, uit
, var
)
620 /* We can't propagate PHI nodes into debug stmts. */
621 if (gimple_code (stmt
) == GIMPLE_PHI
622 || is_gimple_debug (stmt
))
625 /* If we find another definition to remove that uses
626 the one we're looking at, defer the removal of this
627 one, so that it can be propagated into debug stmts
628 after the other is. */
629 FOR_EACH_SSA_DEF_OPERAND (def_p
, stmt
, dit
, SSA_OP_DEF
)
631 tree odef
= DEF_FROM_PTR (def_p
);
633 if (bitmap_bit_p (toremove
, SSA_NAME_VERSION (odef
)))
641 BREAK_FROM_IMM_USE_STMT (uit
);
646 gimple def
= SSA_NAME_DEF_STMT (var
);
647 gimple_stmt_iterator gsi
= gsi_for_stmt (def
);
649 if (gimple_code (def
) == GIMPLE_PHI
)
650 remove_phi_node (&gsi
, true);
653 gsi_remove (&gsi
, true);
657 bitmap_clear_bit (toremove
, j
);
662 /* Return true if SSA_NAME is malformed and mark it visited.
664 IS_VIRTUAL is true if this SSA_NAME was found inside a virtual
668 verify_ssa_name (tree ssa_name
, bool is_virtual
)
670 if (TREE_CODE (ssa_name
) != SSA_NAME
)
672 error ("expected an SSA_NAME object");
676 if (SSA_NAME_IN_FREE_LIST (ssa_name
))
678 error ("found an SSA_NAME that had been released into the free pool");
682 if (SSA_NAME_VAR (ssa_name
) != NULL_TREE
683 && TREE_TYPE (ssa_name
) != TREE_TYPE (SSA_NAME_VAR (ssa_name
)))
685 error ("type mismatch between an SSA_NAME and its symbol");
689 if (is_virtual
&& !virtual_operand_p (ssa_name
))
691 error ("found a virtual definition for a GIMPLE register");
695 if (is_virtual
&& SSA_NAME_VAR (ssa_name
) != gimple_vop (cfun
))
697 error ("virtual SSA name for non-VOP decl");
701 if (!is_virtual
&& virtual_operand_p (ssa_name
))
703 error ("found a real definition for a non-register");
707 if (SSA_NAME_IS_DEFAULT_DEF (ssa_name
)
708 && !gimple_nop_p (SSA_NAME_DEF_STMT (ssa_name
)))
710 error ("found a default name with a non-empty defining statement");
718 /* Return true if the definition of SSA_NAME at block BB is malformed.
720 STMT is the statement where SSA_NAME is created.
722 DEFINITION_BLOCK is an array of basic blocks indexed by SSA_NAME
723 version numbers. If DEFINITION_BLOCK[SSA_NAME_VERSION] is set,
724 it means that the block in that array slot contains the
725 definition of SSA_NAME.
727 IS_VIRTUAL is true if SSA_NAME is created by a VDEF. */
730 verify_def (basic_block bb
, basic_block
*definition_block
, tree ssa_name
,
731 gimple stmt
, bool is_virtual
)
733 if (verify_ssa_name (ssa_name
, is_virtual
))
736 if (SSA_NAME_VAR (ssa_name
)
737 && TREE_CODE (SSA_NAME_VAR (ssa_name
)) == RESULT_DECL
738 && DECL_BY_REFERENCE (SSA_NAME_VAR (ssa_name
)))
740 error ("RESULT_DECL should be read only when DECL_BY_REFERENCE is set");
744 if (definition_block
[SSA_NAME_VERSION (ssa_name
)])
746 error ("SSA_NAME created in two different blocks %i and %i",
747 definition_block
[SSA_NAME_VERSION (ssa_name
)]->index
, bb
->index
);
751 definition_block
[SSA_NAME_VERSION (ssa_name
)] = bb
;
753 if (SSA_NAME_DEF_STMT (ssa_name
) != stmt
)
755 error ("SSA_NAME_DEF_STMT is wrong");
756 fprintf (stderr
, "Expected definition statement:\n");
757 print_gimple_stmt (stderr
, SSA_NAME_DEF_STMT (ssa_name
), 4, TDF_VOPS
);
758 fprintf (stderr
, "\nActual definition statement:\n");
759 print_gimple_stmt (stderr
, stmt
, 4, TDF_VOPS
);
766 fprintf (stderr
, "while verifying SSA_NAME ");
767 print_generic_expr (stderr
, ssa_name
, 0);
768 fprintf (stderr
, " in statement\n");
769 print_gimple_stmt (stderr
, stmt
, 4, TDF_VOPS
);
775 /* Return true if the use of SSA_NAME at statement STMT in block BB is
778 DEF_BB is the block where SSA_NAME was found to be created.
780 IDOM contains immediate dominator information for the flowgraph.
782 CHECK_ABNORMAL is true if the caller wants to check whether this use
783 is flowing through an abnormal edge (only used when checking PHI
786 If NAMES_DEFINED_IN_BB is not NULL, it contains a bitmap of ssa names
787 that are defined before STMT in basic block BB. */
790 verify_use (basic_block bb
, basic_block def_bb
, use_operand_p use_p
,
791 gimple stmt
, bool check_abnormal
, bitmap names_defined_in_bb
)
794 tree ssa_name
= USE_FROM_PTR (use_p
);
796 if (!TREE_VISITED (ssa_name
))
797 if (verify_imm_links (stderr
, ssa_name
))
800 TREE_VISITED (ssa_name
) = 1;
802 if (gimple_nop_p (SSA_NAME_DEF_STMT (ssa_name
))
803 && SSA_NAME_IS_DEFAULT_DEF (ssa_name
))
804 ; /* Default definitions have empty statements. Nothing to do. */
807 error ("missing definition");
810 else if (bb
!= def_bb
811 && !dominated_by_p (CDI_DOMINATORS
, bb
, def_bb
))
813 error ("definition in block %i does not dominate use in block %i",
814 def_bb
->index
, bb
->index
);
817 else if (bb
== def_bb
818 && names_defined_in_bb
!= NULL
819 && !bitmap_bit_p (names_defined_in_bb
, SSA_NAME_VERSION (ssa_name
)))
821 error ("definition in block %i follows the use", def_bb
->index
);
826 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ssa_name
))
828 error ("SSA_NAME_OCCURS_IN_ABNORMAL_PHI should be set");
832 /* Make sure the use is in an appropriate list by checking the previous
833 element to make sure it's the same. */
834 if (use_p
->prev
== NULL
)
836 error ("no immediate_use list");
842 if (use_p
->prev
->use
== NULL
)
843 listvar
= use_p
->prev
->loc
.ssa_name
;
845 listvar
= USE_FROM_PTR (use_p
->prev
);
846 if (listvar
!= ssa_name
)
848 error ("wrong immediate use list");
855 fprintf (stderr
, "for SSA_NAME: ");
856 print_generic_expr (stderr
, ssa_name
, TDF_VOPS
);
857 fprintf (stderr
, " in statement:\n");
858 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
);
865 /* Return true if any of the arguments for PHI node PHI at block BB is
868 DEFINITION_BLOCK is an array of basic blocks indexed by SSA_NAME
869 version numbers. If DEFINITION_BLOCK[SSA_NAME_VERSION] is set,
870 it means that the block in that array slot contains the
871 definition of SSA_NAME. */
874 verify_phi_args (gimple phi
, basic_block bb
, basic_block
*definition_block
)
878 size_t i
, phi_num_args
= gimple_phi_num_args (phi
);
880 if (EDGE_COUNT (bb
->preds
) != phi_num_args
)
882 error ("incoming edge count does not match number of PHI arguments");
887 for (i
= 0; i
< phi_num_args
; i
++)
889 use_operand_p op_p
= gimple_phi_arg_imm_use_ptr (phi
, i
);
890 tree op
= USE_FROM_PTR (op_p
);
892 e
= EDGE_PRED (bb
, i
);
896 error ("PHI argument is missing for edge %d->%d",
903 if (TREE_CODE (op
) != SSA_NAME
&& !is_gimple_min_invariant (op
))
905 error ("PHI argument is not SSA_NAME, or invariant");
909 if (TREE_CODE (op
) == SSA_NAME
)
911 err
= verify_ssa_name (op
, virtual_operand_p (gimple_phi_result (phi
)));
912 err
|= verify_use (e
->src
, definition_block
[SSA_NAME_VERSION (op
)],
913 op_p
, phi
, e
->flags
& EDGE_ABNORMAL
, NULL
);
916 if (TREE_CODE (op
) == ADDR_EXPR
)
918 tree base
= TREE_OPERAND (op
, 0);
919 while (handled_component_p (base
))
920 base
= TREE_OPERAND (base
, 0);
921 if ((TREE_CODE (base
) == VAR_DECL
922 || TREE_CODE (base
) == PARM_DECL
923 || TREE_CODE (base
) == RESULT_DECL
)
924 && !TREE_ADDRESSABLE (base
))
926 error ("address taken, but ADDRESSABLE bit not set");
933 error ("wrong edge %d->%d for PHI argument",
934 e
->src
->index
, e
->dest
->index
);
940 fprintf (stderr
, "PHI argument\n");
941 print_generic_stmt (stderr
, op
, TDF_VOPS
);
949 fprintf (stderr
, "for PHI node\n");
950 print_gimple_stmt (stderr
, phi
, 0, TDF_VOPS
|TDF_MEMSYMS
);
958 /* Verify common invariants in the SSA web.
959 TODO: verify the variable annotations. */
962 verify_ssa (bool check_modified_stmt
)
966 basic_block
*definition_block
= XCNEWVEC (basic_block
, num_ssa_names
);
969 enum dom_state orig_dom_state
= dom_info_state (CDI_DOMINATORS
);
970 bitmap names_defined_in_bb
= BITMAP_ALLOC (NULL
);
972 gcc_assert (!need_ssa_update_p (cfun
));
974 timevar_push (TV_TREE_SSA_VERIFY
);
976 /* Keep track of SSA names present in the IL. */
977 for (i
= 1; i
< num_ssa_names
; i
++)
979 tree name
= ssa_name (i
);
983 TREE_VISITED (name
) = 0;
985 verify_ssa_name (name
, virtual_operand_p (name
));
987 stmt
= SSA_NAME_DEF_STMT (name
);
988 if (!gimple_nop_p (stmt
))
990 basic_block bb
= gimple_bb (stmt
);
991 if (verify_def (bb
, definition_block
,
992 name
, stmt
, virtual_operand_p (name
)))
998 calculate_dominance_info (CDI_DOMINATORS
);
1000 /* Now verify all the uses and make sure they agree with the definitions
1001 found in the previous pass. */
1002 FOR_EACH_BB_FN (bb
, cfun
)
1007 gimple_stmt_iterator gsi
;
1009 /* Make sure that all edges have a clear 'aux' field. */
1010 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
1014 error ("AUX pointer initialized for edge %d->%d", e
->src
->index
,
1020 /* Verify the arguments for every PHI node in the block. */
1021 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1023 phi
= gsi_stmt (gsi
);
1024 if (verify_phi_args (phi
, bb
, definition_block
))
1027 bitmap_set_bit (names_defined_in_bb
,
1028 SSA_NAME_VERSION (gimple_phi_result (phi
)));
1031 /* Now verify all the uses and vuses in every statement of the block. */
1032 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1034 gimple stmt
= gsi_stmt (gsi
);
1035 use_operand_p use_p
;
1037 if (check_modified_stmt
&& gimple_modified_p (stmt
))
1039 error ("stmt (%p) marked modified after optimization pass: ",
1041 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
);
1045 if (verify_ssa_operands (cfun
, stmt
))
1047 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
);
1051 if (gimple_debug_bind_p (stmt
)
1052 && !gimple_debug_bind_has_value_p (stmt
))
1055 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_USE
|SSA_OP_VUSE
)
1057 op
= USE_FROM_PTR (use_p
);
1058 if (verify_use (bb
, definition_block
[SSA_NAME_VERSION (op
)],
1059 use_p
, stmt
, false, names_defined_in_bb
))
1063 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, iter
, SSA_OP_ALL_DEFS
)
1065 if (SSA_NAME_DEF_STMT (op
) != stmt
)
1067 error ("SSA_NAME_DEF_STMT is wrong");
1068 fprintf (stderr
, "Expected definition statement:\n");
1069 print_gimple_stmt (stderr
, stmt
, 4, TDF_VOPS
);
1070 fprintf (stderr
, "\nActual definition statement:\n");
1071 print_gimple_stmt (stderr
, SSA_NAME_DEF_STMT (op
),
1075 bitmap_set_bit (names_defined_in_bb
, SSA_NAME_VERSION (op
));
1079 bitmap_clear (names_defined_in_bb
);
1082 free (definition_block
);
1084 /* Restore the dominance information to its prior known state, so
1085 that we do not perturb the compiler's subsequent behavior. */
1086 if (orig_dom_state
== DOM_NONE
)
1087 free_dominance_info (CDI_DOMINATORS
);
1089 set_dom_info_availability (CDI_DOMINATORS
, orig_dom_state
);
1091 BITMAP_FREE (names_defined_in_bb
);
1092 timevar_pop (TV_TREE_SSA_VERIFY
);
1096 internal_error ("verify_ssa failed");
1099 /* Return true if the DECL_UID in both trees are equal. */
1102 uid_ssaname_map_eq (const void *va
, const void *vb
)
1104 const_tree a
= (const_tree
) va
;
1105 const_tree b
= (const_tree
) vb
;
1106 return (a
->ssa_name
.var
->decl_minimal
.uid
== b
->ssa_name
.var
->decl_minimal
.uid
);
1109 /* Hash a tree in a uid_decl_map. */
1112 uid_ssaname_map_hash (const void *item
)
1114 return ((const_tree
)item
)->ssa_name
.var
->decl_minimal
.uid
;
1118 /* Initialize global DFA and SSA structures. */
1121 init_tree_ssa (struct function
*fn
)
1123 fn
->gimple_df
= ggc_alloc_cleared_gimple_df ();
1124 fn
->gimple_df
->default_defs
= htab_create_ggc (20, uid_ssaname_map_hash
,
1125 uid_ssaname_map_eq
, NULL
);
1126 pt_solution_reset (&fn
->gimple_df
->escaped
);
1127 init_ssanames (fn
, 0);
1130 /* Do the actions required to initialize internal data structures used
1131 in tree-ssa optimization passes. */
1134 execute_init_datastructures (void)
1136 /* Allocate hash tables, arrays and other structures. */
1137 gcc_assert (!cfun
->gimple_df
);
1138 init_tree_ssa (cfun
);
1142 /* Gate for IPCP optimization. */
1145 gate_init_datastructures (void)
1147 /* Do nothing for funcions that was produced already in SSA form. */
1148 return !(cfun
->curr_properties
& PROP_ssa
);
1153 const pass_data pass_data_init_datastructures
=
1155 GIMPLE_PASS
, /* type */
1156 "*init_datastructures", /* name */
1157 OPTGROUP_NONE
, /* optinfo_flags */
1158 true, /* has_execute */
1159 TV_NONE
, /* tv_id */
1160 PROP_cfg
, /* properties_required */
1161 0, /* properties_provided */
1162 0, /* properties_destroyed */
1163 0, /* todo_flags_start */
1164 0, /* todo_flags_finish */
1167 class pass_init_datastructures
: public gimple_opt_pass
1170 pass_init_datastructures (gcc::context
*ctxt
)
1171 : gimple_opt_pass (pass_data_init_datastructures
, ctxt
)
1174 /* opt_pass methods: */
1175 bool gate () { return gate_init_datastructures (); }
1176 unsigned int execute () { return execute_init_datastructures (); }
1178 }; // class pass_init_datastructures
1183 make_pass_init_datastructures (gcc::context
*ctxt
)
1185 return new pass_init_datastructures (ctxt
);
1188 /* Deallocate memory associated with SSA data structures for FNDECL. */
1191 delete_tree_ssa (void)
1195 /* We no longer maintain the SSA operand cache at this point. */
1196 if (ssa_operands_active (cfun
))
1197 fini_ssa_operands (cfun
);
1199 htab_delete (cfun
->gimple_df
->default_defs
);
1200 cfun
->gimple_df
->default_defs
= NULL
;
1201 pt_solution_reset (&cfun
->gimple_df
->escaped
);
1202 if (cfun
->gimple_df
->decls_to_pointers
!= NULL
)
1203 pointer_map_destroy (cfun
->gimple_df
->decls_to_pointers
);
1204 cfun
->gimple_df
->decls_to_pointers
= NULL
;
1205 cfun
->gimple_df
->modified_noreturn_calls
= NULL
;
1206 cfun
->gimple_df
= NULL
;
1208 /* We no longer need the edge variable maps. */
1209 redirect_edge_var_map_destroy ();
1212 /* Return true if EXPR is a useless type conversion, otherwise return
1216 tree_ssa_useless_type_conversion (tree expr
)
1218 /* If we have an assignment that merely uses a NOP_EXPR to change
1219 the top of the RHS to the type of the LHS and the type conversion
1220 is "safe", then strip away the type conversion so that we can
1221 enter LHS = RHS into the const_and_copies table. */
1222 if (CONVERT_EXPR_P (expr
)
1223 || TREE_CODE (expr
) == VIEW_CONVERT_EXPR
1224 || TREE_CODE (expr
) == NON_LVALUE_EXPR
)
1225 return useless_type_conversion_p
1227 TREE_TYPE (TREE_OPERAND (expr
, 0)));
1232 /* Strip conversions from EXP according to
1233 tree_ssa_useless_type_conversion and return the resulting
1237 tree_ssa_strip_useless_type_conversions (tree exp
)
1239 while (tree_ssa_useless_type_conversion (exp
))
1240 exp
= TREE_OPERAND (exp
, 0);
1245 /* Return true if T, an SSA_NAME, has an undefined value. */
1248 ssa_undefined_value_p (tree t
)
1250 tree var
= SSA_NAME_VAR (t
);
1254 /* Parameters get their initial value from the function entry. */
1255 else if (TREE_CODE (var
) == PARM_DECL
)
1257 /* When returning by reference the return address is actually a hidden
1259 else if (TREE_CODE (var
) == RESULT_DECL
&& DECL_BY_REFERENCE (var
))
1261 /* Hard register variables get their initial value from the ether. */
1262 else if (TREE_CODE (var
) == VAR_DECL
&& DECL_HARD_REGISTER (var
))
1265 /* The value is undefined iff its definition statement is empty. */
1266 return gimple_nop_p (SSA_NAME_DEF_STMT (t
));
1270 /* If necessary, rewrite the base of the reference tree *TP from
1271 a MEM_REF to a plain or converted symbol. */
1274 maybe_rewrite_mem_ref_base (tree
*tp
, bitmap suitable_for_renaming
)
1278 while (handled_component_p (*tp
))
1279 tp
= &TREE_OPERAND (*tp
, 0);
1280 if (TREE_CODE (*tp
) == MEM_REF
1281 && TREE_CODE (TREE_OPERAND (*tp
, 0)) == ADDR_EXPR
1282 && (sym
= TREE_OPERAND (TREE_OPERAND (*tp
, 0), 0))
1284 && !TREE_ADDRESSABLE (sym
)
1285 && bitmap_bit_p (suitable_for_renaming
, DECL_UID (sym
)))
1287 if (TREE_CODE (TREE_TYPE (sym
)) == VECTOR_TYPE
1288 && useless_type_conversion_p (TREE_TYPE (*tp
),
1289 TREE_TYPE (TREE_TYPE (sym
)))
1290 && multiple_of_p (sizetype
, TREE_OPERAND (*tp
, 1),
1291 TYPE_SIZE_UNIT (TREE_TYPE (*tp
))))
1293 *tp
= build3 (BIT_FIELD_REF
, TREE_TYPE (*tp
), sym
,
1294 TYPE_SIZE (TREE_TYPE (*tp
)),
1295 int_const_binop (MULT_EXPR
,
1296 bitsize_int (BITS_PER_UNIT
),
1297 TREE_OPERAND (*tp
, 1)));
1299 else if (TREE_CODE (TREE_TYPE (sym
)) == COMPLEX_TYPE
1300 && useless_type_conversion_p (TREE_TYPE (*tp
),
1301 TREE_TYPE (TREE_TYPE (sym
))))
1303 *tp
= build1 (integer_zerop (TREE_OPERAND (*tp
, 1))
1304 ? REALPART_EXPR
: IMAGPART_EXPR
,
1305 TREE_TYPE (*tp
), sym
);
1307 else if (integer_zerop (TREE_OPERAND (*tp
, 1)))
1309 if (!useless_type_conversion_p (TREE_TYPE (*tp
),
1311 *tp
= build1 (VIEW_CONVERT_EXPR
,
1312 TREE_TYPE (*tp
), sym
);
1319 /* For a tree REF return its base if it is the base of a MEM_REF
1320 that cannot be rewritten into SSA form. Otherwise return NULL_TREE. */
1323 non_rewritable_mem_ref_base (tree ref
)
1327 /* A plain decl does not need it set. */
1331 while (handled_component_p (base
))
1332 base
= TREE_OPERAND (base
, 0);
1334 /* But watch out for MEM_REFs we cannot lower to a
1335 VIEW_CONVERT_EXPR or a BIT_FIELD_REF. */
1336 if (TREE_CODE (base
) == MEM_REF
1337 && TREE_CODE (TREE_OPERAND (base
, 0)) == ADDR_EXPR
)
1339 tree decl
= TREE_OPERAND (TREE_OPERAND (base
, 0), 0);
1340 if ((TREE_CODE (TREE_TYPE (decl
)) == VECTOR_TYPE
1341 || TREE_CODE (TREE_TYPE (decl
)) == COMPLEX_TYPE
)
1342 && useless_type_conversion_p (TREE_TYPE (base
),
1343 TREE_TYPE (TREE_TYPE (decl
)))
1344 && mem_ref_offset (base
).fits_uhwi ()
1345 && tree_to_double_int (TYPE_SIZE_UNIT (TREE_TYPE (decl
)))
1346 .ugt (mem_ref_offset (base
))
1347 && multiple_of_p (sizetype
, TREE_OPERAND (base
, 1),
1348 TYPE_SIZE_UNIT (TREE_TYPE (base
))))
1351 && (!integer_zerop (TREE_OPERAND (base
, 1))
1352 || (DECL_SIZE (decl
)
1353 != TYPE_SIZE (TREE_TYPE (base
)))
1354 || TREE_THIS_VOLATILE (decl
) != TREE_THIS_VOLATILE (base
)))
1361 /* For an lvalue tree LHS return true if it cannot be rewritten into SSA form.
1362 Otherwise return true. */
1365 non_rewritable_lvalue_p (tree lhs
)
1367 /* A plain decl is always rewritable. */
1371 /* A decl that is wrapped inside a MEM-REF that covers
1372 it full is also rewritable.
1373 ??? The following could be relaxed allowing component
1374 references that do not change the access size. */
1375 if (TREE_CODE (lhs
) == MEM_REF
1376 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == ADDR_EXPR
1377 && integer_zerop (TREE_OPERAND (lhs
, 1)))
1379 tree decl
= TREE_OPERAND (TREE_OPERAND (lhs
, 0), 0);
1381 && DECL_SIZE (decl
) == TYPE_SIZE (TREE_TYPE (lhs
))
1382 && (TREE_THIS_VOLATILE (decl
) == TREE_THIS_VOLATILE (lhs
)))
1389 /* When possible, clear TREE_ADDRESSABLE bit or set DECL_GIMPLE_REG_P bit and
1390 mark the variable VAR for conversion into SSA. Return true when updating
1391 stmts is required. */
1394 maybe_optimize_var (tree var
, bitmap addresses_taken
, bitmap not_reg_needs
,
1395 bitmap suitable_for_renaming
)
1397 /* Global Variables, result decls cannot be changed. */
1398 if (is_global_var (var
)
1399 || TREE_CODE (var
) == RESULT_DECL
1400 || bitmap_bit_p (addresses_taken
, DECL_UID (var
)))
1403 if (TREE_ADDRESSABLE (var
)
1404 /* Do not change TREE_ADDRESSABLE if we need to preserve var as
1405 a non-register. Otherwise we are confused and forget to
1406 add virtual operands for it. */
1407 && (!is_gimple_reg_type (TREE_TYPE (var
))
1408 || TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
1409 || TREE_CODE (TREE_TYPE (var
)) == COMPLEX_TYPE
1410 || !bitmap_bit_p (not_reg_needs
, DECL_UID (var
))))
1412 TREE_ADDRESSABLE (var
) = 0;
1413 if (is_gimple_reg (var
))
1414 bitmap_set_bit (suitable_for_renaming
, DECL_UID (var
));
1417 fprintf (dump_file
, "No longer having address taken: ");
1418 print_generic_expr (dump_file
, var
, 0);
1419 fprintf (dump_file
, "\n");
1423 if (!DECL_GIMPLE_REG_P (var
)
1424 && !bitmap_bit_p (not_reg_needs
, DECL_UID (var
))
1425 && (TREE_CODE (TREE_TYPE (var
)) == COMPLEX_TYPE
1426 || TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
)
1427 && !TREE_THIS_VOLATILE (var
)
1428 && (TREE_CODE (var
) != VAR_DECL
|| !DECL_HARD_REGISTER (var
)))
1430 DECL_GIMPLE_REG_P (var
) = 1;
1431 bitmap_set_bit (suitable_for_renaming
, DECL_UID (var
));
1434 fprintf (dump_file
, "Now a gimple register: ");
1435 print_generic_expr (dump_file
, var
, 0);
1436 fprintf (dump_file
, "\n");
1441 /* Compute TREE_ADDRESSABLE and DECL_GIMPLE_REG_P for local variables. */
1444 execute_update_addresses_taken (void)
1446 gimple_stmt_iterator gsi
;
1448 bitmap addresses_taken
= BITMAP_ALLOC (NULL
);
1449 bitmap not_reg_needs
= BITMAP_ALLOC (NULL
);
1450 bitmap suitable_for_renaming
= BITMAP_ALLOC (NULL
);
1454 timevar_push (TV_ADDRESS_TAKEN
);
1456 /* Collect into ADDRESSES_TAKEN all variables whose address is taken within
1457 the function body. */
1458 FOR_EACH_BB_FN (bb
, cfun
)
1460 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1462 gimple stmt
= gsi_stmt (gsi
);
1463 enum gimple_code code
= gimple_code (stmt
);
1466 /* Note all addresses taken by the stmt. */
1467 gimple_ior_addresses_taken (addresses_taken
, stmt
);
1469 /* If we have a call or an assignment, see if the lhs contains
1470 a local decl that requires not to be a gimple register. */
1471 if (code
== GIMPLE_ASSIGN
|| code
== GIMPLE_CALL
)
1473 tree lhs
= gimple_get_lhs (stmt
);
1475 && TREE_CODE (lhs
) != SSA_NAME
1476 && non_rewritable_lvalue_p (lhs
))
1478 decl
= get_base_address (lhs
);
1480 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1484 if (gimple_assign_single_p (stmt
))
1486 tree rhs
= gimple_assign_rhs1 (stmt
);
1487 if ((decl
= non_rewritable_mem_ref_base (rhs
)))
1488 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1491 else if (code
== GIMPLE_CALL
)
1493 for (i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
1495 tree arg
= gimple_call_arg (stmt
, i
);
1496 if ((decl
= non_rewritable_mem_ref_base (arg
)))
1497 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1501 else if (code
== GIMPLE_ASM
)
1503 for (i
= 0; i
< gimple_asm_noutputs (stmt
); ++i
)
1505 tree link
= gimple_asm_output_op (stmt
, i
);
1506 tree lhs
= TREE_VALUE (link
);
1507 if (TREE_CODE (lhs
) != SSA_NAME
)
1509 decl
= get_base_address (lhs
);
1511 && (non_rewritable_lvalue_p (lhs
)
1512 /* We cannot move required conversions from
1513 the lhs to the rhs in asm statements, so
1514 require we do not need any. */
1515 || !useless_type_conversion_p
1516 (TREE_TYPE (lhs
), TREE_TYPE (decl
))))
1517 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1520 for (i
= 0; i
< gimple_asm_ninputs (stmt
); ++i
)
1522 tree link
= gimple_asm_input_op (stmt
, i
);
1523 if ((decl
= non_rewritable_mem_ref_base (TREE_VALUE (link
))))
1524 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1529 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1532 gimple phi
= gsi_stmt (gsi
);
1534 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
1536 tree op
= PHI_ARG_DEF (phi
, i
), var
;
1537 if (TREE_CODE (op
) == ADDR_EXPR
1538 && (var
= get_base_address (TREE_OPERAND (op
, 0))) != NULL
1540 bitmap_set_bit (addresses_taken
, DECL_UID (var
));
1545 /* We cannot iterate over all referenced vars because that can contain
1546 unused vars from BLOCK trees, which causes code generation differences
1548 for (var
= DECL_ARGUMENTS (cfun
->decl
); var
; var
= DECL_CHAIN (var
))
1549 maybe_optimize_var (var
, addresses_taken
, not_reg_needs
,
1550 suitable_for_renaming
);
1552 FOR_EACH_VEC_SAFE_ELT (cfun
->local_decls
, i
, var
)
1553 maybe_optimize_var (var
, addresses_taken
, not_reg_needs
,
1554 suitable_for_renaming
);
1556 /* Operand caches need to be recomputed for operands referencing the updated
1557 variables and operands need to be rewritten to expose bare symbols. */
1558 if (!bitmap_empty_p (suitable_for_renaming
))
1560 FOR_EACH_BB_FN (bb
, cfun
)
1561 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
);)
1563 gimple stmt
= gsi_stmt (gsi
);
1565 /* Re-write TARGET_MEM_REFs of symbols we want to
1566 rewrite into SSA form. */
1567 if (gimple_assign_single_p (stmt
))
1569 tree lhs
= gimple_assign_lhs (stmt
);
1570 tree rhs
, *rhsp
= gimple_assign_rhs1_ptr (stmt
);
1573 /* We shouldn't have any fancy wrapping of
1574 component-refs on the LHS, but look through
1575 VIEW_CONVERT_EXPRs as that is easy. */
1576 while (TREE_CODE (lhs
) == VIEW_CONVERT_EXPR
)
1577 lhs
= TREE_OPERAND (lhs
, 0);
1578 if (TREE_CODE (lhs
) == MEM_REF
1579 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == ADDR_EXPR
1580 && integer_zerop (TREE_OPERAND (lhs
, 1))
1581 && (sym
= TREE_OPERAND (TREE_OPERAND (lhs
, 0), 0))
1583 && !TREE_ADDRESSABLE (sym
)
1584 && bitmap_bit_p (suitable_for_renaming
, DECL_UID (sym
)))
1587 lhs
= gimple_assign_lhs (stmt
);
1589 /* Rewrite the RHS and make sure the resulting assignment
1590 is validly typed. */
1591 maybe_rewrite_mem_ref_base (rhsp
, suitable_for_renaming
);
1592 rhs
= gimple_assign_rhs1 (stmt
);
1593 if (gimple_assign_lhs (stmt
) != lhs
1594 && !useless_type_conversion_p (TREE_TYPE (lhs
),
1596 rhs
= fold_build1 (VIEW_CONVERT_EXPR
,
1597 TREE_TYPE (lhs
), rhs
);
1599 if (gimple_assign_lhs (stmt
) != lhs
)
1600 gimple_assign_set_lhs (stmt
, lhs
);
1602 /* For var ={v} {CLOBBER}; where var lost
1603 TREE_ADDRESSABLE just remove the stmt. */
1605 && TREE_CLOBBER_P (rhs
)
1606 && bitmap_bit_p (suitable_for_renaming
, DECL_UID (lhs
)))
1608 unlink_stmt_vdef (stmt
);
1609 gsi_remove (&gsi
, true);
1610 release_defs (stmt
);
1614 if (gimple_assign_rhs1 (stmt
) != rhs
)
1616 gimple_stmt_iterator gsi
= gsi_for_stmt (stmt
);
1617 gimple_assign_set_rhs_from_tree (&gsi
, rhs
);
1621 else if (gimple_code (stmt
) == GIMPLE_CALL
)
1624 for (i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
1626 tree
*argp
= gimple_call_arg_ptr (stmt
, i
);
1627 maybe_rewrite_mem_ref_base (argp
, suitable_for_renaming
);
1631 else if (gimple_code (stmt
) == GIMPLE_ASM
)
1634 for (i
= 0; i
< gimple_asm_noutputs (stmt
); ++i
)
1636 tree link
= gimple_asm_output_op (stmt
, i
);
1637 maybe_rewrite_mem_ref_base (&TREE_VALUE (link
),
1638 suitable_for_renaming
);
1640 for (i
= 0; i
< gimple_asm_ninputs (stmt
); ++i
)
1642 tree link
= gimple_asm_input_op (stmt
, i
);
1643 maybe_rewrite_mem_ref_base (&TREE_VALUE (link
),
1644 suitable_for_renaming
);
1648 else if (gimple_debug_bind_p (stmt
)
1649 && gimple_debug_bind_has_value_p (stmt
))
1651 tree
*valuep
= gimple_debug_bind_get_value_ptr (stmt
);
1653 maybe_rewrite_mem_ref_base (valuep
, suitable_for_renaming
);
1654 decl
= non_rewritable_mem_ref_base (*valuep
);
1656 && bitmap_bit_p (suitable_for_renaming
, DECL_UID (decl
)))
1657 gimple_debug_bind_reset_value (stmt
);
1660 if (gimple_references_memory_p (stmt
)
1661 || is_gimple_debug (stmt
))
1667 /* Update SSA form here, we are called as non-pass as well. */
1668 if (number_of_loops (cfun
) > 1
1669 && loops_state_satisfies_p (LOOP_CLOSED_SSA
))
1670 rewrite_into_loop_closed_ssa (NULL
, TODO_update_ssa
);
1672 update_ssa (TODO_update_ssa
);
1675 BITMAP_FREE (not_reg_needs
);
1676 BITMAP_FREE (addresses_taken
);
1677 BITMAP_FREE (suitable_for_renaming
);
1678 timevar_pop (TV_ADDRESS_TAKEN
);
1683 const pass_data pass_data_update_address_taken
=
1685 GIMPLE_PASS
, /* type */
1686 "addressables", /* name */
1687 OPTGROUP_NONE
, /* optinfo_flags */
1688 false, /* has_execute */
1689 TV_ADDRESS_TAKEN
, /* tv_id */
1690 PROP_ssa
, /* properties_required */
1691 0, /* properties_provided */
1692 0, /* properties_destroyed */
1693 0, /* todo_flags_start */
1694 TODO_update_address_taken
, /* todo_flags_finish */
1697 class pass_update_address_taken
: public gimple_opt_pass
1700 pass_update_address_taken (gcc::context
*ctxt
)
1701 : gimple_opt_pass (pass_data_update_address_taken
, ctxt
)
1704 /* opt_pass methods: */
1706 }; // class pass_update_address_taken
1711 make_pass_update_address_taken (gcc::context
*ctxt
)
1713 return new pass_update_address_taken (ctxt
);