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 "tree-ssa-alias.h"
34 #include "internal-fn.h"
35 #include "gimple-fold.h"
36 #include "gimple-expr.h"
40 #include "gimple-iterator.h"
41 #include "gimple-walk.h"
42 #include "gimple-ssa.h"
43 #include "tree-phinodes.h"
44 #include "ssa-iterators.h"
45 #include "stringpool.h"
46 #include "tree-ssanames.h"
47 #include "tree-ssa-loop-manip.h"
48 #include "tree-into-ssa.h"
50 #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 hash_map
<edge
, auto_vec
<edge_var_map
> > *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
)
67 edge_var_map new_node
;
69 if (edge_var_maps
== NULL
)
70 edge_var_maps
= new hash_map
<edge
, auto_vec
<edge_var_map
> >;
72 auto_vec
<edge_var_map
> &slot
= edge_var_maps
->get_or_insert (e
);
74 new_node
.result
= result
;
75 new_node
.locus
= locus
;
77 slot
.safe_push (new_node
);
81 /* Clear the var mappings in edge E. */
84 redirect_edge_var_map_clear (edge e
)
89 auto_vec
<edge_var_map
> *head
= edge_var_maps
->get (e
);
96 /* Duplicate the redirected var mappings in OLDE in NEWE.
98 This assumes a hash_map can have multiple edges mapping to the same
99 var_map (many to one mapping), since we don't remove the previous mappings.
103 redirect_edge_var_map_dup (edge newe
, edge olde
)
108 auto_vec
<edge_var_map
> *new_head
= &edge_var_maps
->get_or_insert (newe
);
109 auto_vec
<edge_var_map
> *old_head
= edge_var_maps
->get (olde
);
113 new_head
->safe_splice (*old_head
);
117 /* Return the variable mappings for a given edge. If there is none, return
121 redirect_edge_var_map_vector (edge e
)
123 /* Hey, what kind of idiot would... you'd be surprised. */
127 auto_vec
<edge_var_map
> *slot
= edge_var_maps
->get (e
);
134 /* Clear the edge variable mappings. */
137 redirect_edge_var_map_destroy (void)
139 delete edge_var_maps
;
140 edge_var_maps
= NULL
;
144 /* Remove the corresponding arguments from the PHI nodes in E's
145 destination block and redirect it to DEST. Return redirected edge.
146 The list of removed arguments is stored in a vector accessed
147 through edge_var_maps. */
150 ssa_redirect_edge (edge e
, basic_block dest
)
155 redirect_edge_var_map_clear (e
);
157 /* Remove the appropriate PHI arguments in E's destination block. */
158 for (gsi
= gsi_start_phis (e
->dest
); !gsi_end_p (gsi
); gsi_next (&gsi
))
161 source_location locus
;
164 def
= gimple_phi_arg_def (phi
, e
->dest_idx
);
165 locus
= gimple_phi_arg_location (phi
, e
->dest_idx
);
167 if (def
== NULL_TREE
)
170 redirect_edge_var_map_add (e
, gimple_phi_result (phi
), def
, locus
);
173 e
= redirect_edge_succ_nodup (e
, dest
);
179 /* Add PHI arguments queued in PENDING_STMT list on edge E to edge
183 flush_pending_stmts (edge e
)
190 vec
<edge_var_map
> *v
= redirect_edge_var_map_vector (e
);
194 for (gsi
= gsi_start_phis (e
->dest
), i
= 0;
195 !gsi_end_p (gsi
) && v
->iterate (i
, &vm
);
196 gsi_next (&gsi
), i
++)
201 def
= redirect_edge_var_map_def (vm
);
202 add_phi_arg (phi
, def
, e
, redirect_edge_var_map_location (vm
));
205 redirect_edge_var_map_clear (e
);
208 /* Replace the LHS of STMT, an assignment, either a GIMPLE_ASSIGN or a
209 GIMPLE_CALL, with NLHS, in preparation for modifying the RHS to an
210 expression with a different value.
212 This will update any annotations (say debug bind stmts) referring
213 to the original LHS, so that they use the RHS instead. This is
214 done even if NLHS and LHS are the same, for it is understood that
215 the RHS will be modified afterwards, and NLHS will not be assigned
218 Adjusting any non-annotation uses of the LHS, if needed, is a
219 responsibility of the caller.
221 The effect of this call should be pretty much the same as that of
222 inserting a copy of STMT before STMT, and then removing the
223 original stmt, at which time gsi_remove() would have update
224 annotations, but using this function saves all the inserting,
225 copying and removing. */
228 gimple_replace_ssa_lhs (gimple stmt
, tree nlhs
)
230 if (MAY_HAVE_DEBUG_STMTS
)
232 tree lhs
= gimple_get_lhs (stmt
);
234 gcc_assert (SSA_NAME_DEF_STMT (lhs
) == stmt
);
236 insert_debug_temp_for_var_def (NULL
, lhs
);
239 gimple_set_lhs (stmt
, nlhs
);
243 /* Given a tree for an expression for which we might want to emit
244 locations or values in debug information (generally a variable, but
245 we might deal with other kinds of trees in the future), return the
246 tree that should be used as the variable of a DEBUG_BIND STMT or
247 VAR_LOCATION INSN or NOTE. Return NULL if VAR is not to be tracked. */
250 target_for_debug_bind (tree var
)
252 if (!MAY_HAVE_DEBUG_STMTS
)
255 if (TREE_CODE (var
) == SSA_NAME
)
257 var
= SSA_NAME_VAR (var
);
258 if (var
== NULL_TREE
)
262 if ((TREE_CODE (var
) != VAR_DECL
263 || VAR_DECL_IS_VIRTUAL_OPERAND (var
))
264 && TREE_CODE (var
) != PARM_DECL
)
267 if (DECL_HAS_VALUE_EXPR_P (var
))
268 return target_for_debug_bind (DECL_VALUE_EXPR (var
));
270 if (DECL_IGNORED_P (var
))
273 /* var-tracking only tracks registers. */
274 if (!is_gimple_reg_type (TREE_TYPE (var
)))
280 /* Called via walk_tree, look for SSA_NAMEs that have already been
284 find_released_ssa_name (tree
*tp
, int *walk_subtrees
, void *data_
)
286 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data_
;
288 if (wi
&& wi
->is_lhs
)
291 if (TREE_CODE (*tp
) == SSA_NAME
)
293 if (SSA_NAME_IN_FREE_LIST (*tp
))
298 else if (IS_TYPE_OR_DECL_P (*tp
))
304 /* Insert a DEBUG BIND stmt before the DEF of VAR if VAR is referenced
305 by other DEBUG stmts, and replace uses of the DEF with the
306 newly-created debug temp. */
309 insert_debug_temp_for_var_def (gimple_stmt_iterator
*gsi
, tree var
)
311 imm_use_iterator imm_iter
;
314 gimple def_stmt
= NULL
;
318 if (!MAY_HAVE_DEBUG_STMTS
)
321 /* If this name has already been registered for replacement, do nothing
322 as anything that uses this name isn't in SSA form. */
323 if (name_registered_for_update_p (var
))
326 /* Check whether there are debug stmts that reference this variable and,
327 if there are, decide whether we should use a debug temp. */
328 FOR_EACH_IMM_USE_FAST (use_p
, imm_iter
, var
)
330 stmt
= USE_STMT (use_p
);
332 if (!gimple_debug_bind_p (stmt
))
338 if (gimple_debug_bind_get_value (stmt
) != var
)
340 /* Count this as an additional use, so as to make sure we
341 use a temp unless VAR's definition has a SINGLE_RHS that
352 def_stmt
= gsi_stmt (*gsi
);
354 def_stmt
= SSA_NAME_DEF_STMT (var
);
356 /* If we didn't get an insertion point, and the stmt has already
357 been removed, we won't be able to insert the debug bind stmt, so
358 we'll have to drop debug information. */
359 if (gimple_code (def_stmt
) == GIMPLE_PHI
)
361 value
= degenerate_phi_result (as_a
<gphi
*> (def_stmt
));
362 if (value
&& walk_tree (&value
, find_released_ssa_name
, NULL
, NULL
))
364 /* error_mark_node is what fixup_noreturn_call changes PHI arguments
366 else if (value
== error_mark_node
)
369 else if (is_gimple_assign (def_stmt
))
371 bool no_value
= false;
373 if (!dom_info_available_p (CDI_DOMINATORS
))
375 struct walk_stmt_info wi
;
377 memset (&wi
, 0, sizeof (wi
));
379 /* When removing blocks without following reverse dominance
380 order, we may sometimes encounter SSA_NAMEs that have
381 already been released, referenced in other SSA_DEFs that
382 we're about to release. Consider:
391 If we deleted BB X first, propagating the value of w_2
392 won't do us any good. It's too late to recover their
393 original definition of v_1: when it was deleted, it was
394 only referenced in other DEFs, it couldn't possibly know
395 it should have been retained, and propagating every
396 single DEF just in case it might have to be propagated
397 into a DEBUG STMT would probably be too wasteful.
399 When dominator information is not readily available, we
400 check for and accept some loss of debug information. But
401 if it is available, there's no excuse for us to remove
402 blocks in the wrong order, so we don't even check for
403 dead SSA NAMEs. SSA verification shall catch any
405 if ((!gsi
&& !gimple_bb (def_stmt
))
406 || walk_gimple_op (def_stmt
, find_released_ssa_name
, &wi
))
411 value
= gimple_assign_rhs_to_tree (def_stmt
);
416 /* If there's a single use of VAR, and VAR is the entire debug
417 expression (usecount would have been incremented again
418 otherwise), and the definition involves only constants and
419 SSA names, then we can propagate VALUE into this single use,
422 We can also avoid using a temp if VALUE can be shared and
423 propagated into all uses, without generating expressions that
424 wouldn't be valid gimple RHSs.
426 Other cases that would require unsharing or non-gimple RHSs
427 are deferred to a debug temp, although we could avoid temps
428 at the expense of duplication of expressions. */
430 if (CONSTANT_CLASS_P (value
)
431 || gimple_code (def_stmt
) == GIMPLE_PHI
433 && (!gimple_assign_single_p (def_stmt
)
434 || is_gimple_min_invariant (value
)))
435 || is_gimple_reg (value
))
440 tree vexpr
= make_node (DEBUG_EXPR_DECL
);
442 def_temp
= gimple_build_debug_bind (vexpr
,
443 unshare_expr (value
),
446 DECL_ARTIFICIAL (vexpr
) = 1;
447 TREE_TYPE (vexpr
) = TREE_TYPE (value
);
449 DECL_MODE (vexpr
) = DECL_MODE (value
);
451 DECL_MODE (vexpr
) = TYPE_MODE (TREE_TYPE (value
));
454 gsi_insert_before (gsi
, def_temp
, GSI_SAME_STMT
);
457 gimple_stmt_iterator ngsi
= gsi_for_stmt (def_stmt
);
458 gsi_insert_before (&ngsi
, def_temp
, GSI_SAME_STMT
);
465 FOR_EACH_IMM_USE_STMT (stmt
, imm_iter
, var
)
467 if (!gimple_debug_bind_p (stmt
))
472 FOR_EACH_IMM_USE_ON_STMT (use_p
, imm_iter
)
473 /* unshare_expr is not needed here. vexpr is either a
474 SINGLE_RHS, that can be safely shared, some other RHS
475 that was unshared when we found it had a single debug
476 use, or a DEBUG_EXPR_DECL, that can be safely
478 SET_USE (use_p
, unshare_expr (value
));
479 /* If we didn't replace uses with a debug decl fold the
480 resulting expression. Otherwise we end up with invalid IL. */
481 if (TREE_CODE (value
) != DEBUG_EXPR_DECL
)
483 gimple_stmt_iterator gsi
= gsi_for_stmt (stmt
);
484 fold_stmt_inplace (&gsi
);
488 gimple_debug_bind_reset_value (stmt
);
495 /* Insert a DEBUG BIND stmt before STMT for each DEF referenced by
496 other DEBUG stmts, and replace uses of the DEF with the
497 newly-created debug temp. */
500 insert_debug_temps_for_defs (gimple_stmt_iterator
*gsi
)
506 if (!MAY_HAVE_DEBUG_STMTS
)
509 stmt
= gsi_stmt (*gsi
);
511 FOR_EACH_PHI_OR_STMT_DEF (def_p
, stmt
, op_iter
, SSA_OP_DEF
)
513 tree var
= DEF_FROM_PTR (def_p
);
515 if (TREE_CODE (var
) != SSA_NAME
)
518 insert_debug_temp_for_var_def (gsi
, var
);
522 /* Reset all debug stmts that use SSA_NAME(s) defined in STMT. */
525 reset_debug_uses (gimple stmt
)
529 imm_use_iterator imm_iter
;
532 if (!MAY_HAVE_DEBUG_STMTS
)
535 FOR_EACH_PHI_OR_STMT_DEF (def_p
, stmt
, op_iter
, SSA_OP_DEF
)
537 tree var
= DEF_FROM_PTR (def_p
);
539 if (TREE_CODE (var
) != SSA_NAME
)
542 FOR_EACH_IMM_USE_STMT (use_stmt
, imm_iter
, var
)
544 if (!gimple_debug_bind_p (use_stmt
))
547 gimple_debug_bind_reset_value (use_stmt
);
548 update_stmt (use_stmt
);
553 /* Delete SSA DEFs for SSA versions in the TOREMOVE bitmap, removing
554 dominated stmts before their dominators, so that release_ssa_defs
555 stands a chance of propagating DEFs into debug bind stmts. */
558 release_defs_bitset (bitmap toremove
)
563 /* Performing a topological sort is probably overkill, this will
564 most likely run in slightly superlinear time, rather than the
565 pathological quadratic worst case. */
566 while (!bitmap_empty_p (toremove
))
567 EXECUTE_IF_SET_IN_BITMAP (toremove
, 0, j
, bi
)
569 bool remove_now
= true;
570 tree var
= ssa_name (j
);
572 imm_use_iterator uit
;
574 FOR_EACH_IMM_USE_STMT (stmt
, uit
, var
)
579 /* We can't propagate PHI nodes into debug stmts. */
580 if (gimple_code (stmt
) == GIMPLE_PHI
581 || is_gimple_debug (stmt
))
584 /* If we find another definition to remove that uses
585 the one we're looking at, defer the removal of this
586 one, so that it can be propagated into debug stmts
587 after the other is. */
588 FOR_EACH_SSA_DEF_OPERAND (def_p
, stmt
, dit
, SSA_OP_DEF
)
590 tree odef
= DEF_FROM_PTR (def_p
);
592 if (bitmap_bit_p (toremove
, SSA_NAME_VERSION (odef
)))
600 BREAK_FROM_IMM_USE_STMT (uit
);
605 gimple def
= SSA_NAME_DEF_STMT (var
);
606 gimple_stmt_iterator gsi
= gsi_for_stmt (def
);
608 if (gimple_code (def
) == GIMPLE_PHI
)
609 remove_phi_node (&gsi
, true);
612 gsi_remove (&gsi
, true);
616 bitmap_clear_bit (toremove
, j
);
621 /* Return true if SSA_NAME is malformed and mark it visited.
623 IS_VIRTUAL is true if this SSA_NAME was found inside a virtual
627 verify_ssa_name (tree ssa_name
, bool is_virtual
)
629 if (TREE_CODE (ssa_name
) != SSA_NAME
)
631 error ("expected an SSA_NAME object");
635 if (SSA_NAME_IN_FREE_LIST (ssa_name
))
637 error ("found an SSA_NAME that had been released into the free pool");
641 if (SSA_NAME_VAR (ssa_name
) != NULL_TREE
642 && TREE_TYPE (ssa_name
) != TREE_TYPE (SSA_NAME_VAR (ssa_name
)))
644 error ("type mismatch between an SSA_NAME and its symbol");
648 if (is_virtual
&& !virtual_operand_p (ssa_name
))
650 error ("found a virtual definition for a GIMPLE register");
654 if (is_virtual
&& SSA_NAME_VAR (ssa_name
) != gimple_vop (cfun
))
656 error ("virtual SSA name for non-VOP decl");
660 if (!is_virtual
&& virtual_operand_p (ssa_name
))
662 error ("found a real definition for a non-register");
666 if (SSA_NAME_IS_DEFAULT_DEF (ssa_name
)
667 && !gimple_nop_p (SSA_NAME_DEF_STMT (ssa_name
)))
669 error ("found a default name with a non-empty defining statement");
677 /* Return true if the definition of SSA_NAME at block BB is malformed.
679 STMT is the statement where SSA_NAME is created.
681 DEFINITION_BLOCK is an array of basic blocks indexed by SSA_NAME
682 version numbers. If DEFINITION_BLOCK[SSA_NAME_VERSION] is set,
683 it means that the block in that array slot contains the
684 definition of SSA_NAME.
686 IS_VIRTUAL is true if SSA_NAME is created by a VDEF. */
689 verify_def (basic_block bb
, basic_block
*definition_block
, tree ssa_name
,
690 gimple stmt
, bool is_virtual
)
692 if (verify_ssa_name (ssa_name
, is_virtual
))
695 if (SSA_NAME_VAR (ssa_name
)
696 && TREE_CODE (SSA_NAME_VAR (ssa_name
)) == RESULT_DECL
697 && DECL_BY_REFERENCE (SSA_NAME_VAR (ssa_name
)))
699 error ("RESULT_DECL should be read only when DECL_BY_REFERENCE is set");
703 if (definition_block
[SSA_NAME_VERSION (ssa_name
)])
705 error ("SSA_NAME created in two different blocks %i and %i",
706 definition_block
[SSA_NAME_VERSION (ssa_name
)]->index
, bb
->index
);
710 definition_block
[SSA_NAME_VERSION (ssa_name
)] = bb
;
712 if (SSA_NAME_DEF_STMT (ssa_name
) != stmt
)
714 error ("SSA_NAME_DEF_STMT is wrong");
715 fprintf (stderr
, "Expected definition statement:\n");
716 print_gimple_stmt (stderr
, SSA_NAME_DEF_STMT (ssa_name
), 4, TDF_VOPS
);
717 fprintf (stderr
, "\nActual definition statement:\n");
718 print_gimple_stmt (stderr
, stmt
, 4, TDF_VOPS
);
725 fprintf (stderr
, "while verifying SSA_NAME ");
726 print_generic_expr (stderr
, ssa_name
, 0);
727 fprintf (stderr
, " in statement\n");
728 print_gimple_stmt (stderr
, stmt
, 4, TDF_VOPS
);
734 /* Return true if the use of SSA_NAME at statement STMT in block BB is
737 DEF_BB is the block where SSA_NAME was found to be created.
739 IDOM contains immediate dominator information for the flowgraph.
741 CHECK_ABNORMAL is true if the caller wants to check whether this use
742 is flowing through an abnormal edge (only used when checking PHI
745 If NAMES_DEFINED_IN_BB is not NULL, it contains a bitmap of ssa names
746 that are defined before STMT in basic block BB. */
749 verify_use (basic_block bb
, basic_block def_bb
, use_operand_p use_p
,
750 gimple stmt
, bool check_abnormal
, bitmap names_defined_in_bb
)
753 tree ssa_name
= USE_FROM_PTR (use_p
);
755 if (!TREE_VISITED (ssa_name
))
756 if (verify_imm_links (stderr
, ssa_name
))
759 TREE_VISITED (ssa_name
) = 1;
761 if (gimple_nop_p (SSA_NAME_DEF_STMT (ssa_name
))
762 && SSA_NAME_IS_DEFAULT_DEF (ssa_name
))
763 ; /* Default definitions have empty statements. Nothing to do. */
766 error ("missing definition");
769 else if (bb
!= def_bb
770 && !dominated_by_p (CDI_DOMINATORS
, bb
, def_bb
))
772 error ("definition in block %i does not dominate use in block %i",
773 def_bb
->index
, bb
->index
);
776 else if (bb
== def_bb
777 && names_defined_in_bb
!= NULL
778 && !bitmap_bit_p (names_defined_in_bb
, SSA_NAME_VERSION (ssa_name
)))
780 error ("definition in block %i follows the use", def_bb
->index
);
785 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ssa_name
))
787 error ("SSA_NAME_OCCURS_IN_ABNORMAL_PHI should be set");
791 /* Make sure the use is in an appropriate list by checking the previous
792 element to make sure it's the same. */
793 if (use_p
->prev
== NULL
)
795 error ("no immediate_use list");
801 if (use_p
->prev
->use
== NULL
)
802 listvar
= use_p
->prev
->loc
.ssa_name
;
804 listvar
= USE_FROM_PTR (use_p
->prev
);
805 if (listvar
!= ssa_name
)
807 error ("wrong immediate use list");
814 fprintf (stderr
, "for SSA_NAME: ");
815 print_generic_expr (stderr
, ssa_name
, TDF_VOPS
);
816 fprintf (stderr
, " in statement:\n");
817 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
);
824 /* Return true if any of the arguments for PHI node PHI at block BB is
827 DEFINITION_BLOCK is an array of basic blocks indexed by SSA_NAME
828 version numbers. If DEFINITION_BLOCK[SSA_NAME_VERSION] is set,
829 it means that the block in that array slot contains the
830 definition of SSA_NAME. */
833 verify_phi_args (gphi
*phi
, basic_block bb
, basic_block
*definition_block
)
837 size_t i
, phi_num_args
= gimple_phi_num_args (phi
);
839 if (EDGE_COUNT (bb
->preds
) != phi_num_args
)
841 error ("incoming edge count does not match number of PHI arguments");
846 for (i
= 0; i
< phi_num_args
; i
++)
848 use_operand_p op_p
= gimple_phi_arg_imm_use_ptr (phi
, i
);
849 tree op
= USE_FROM_PTR (op_p
);
851 e
= EDGE_PRED (bb
, i
);
855 error ("PHI argument is missing for edge %d->%d",
862 if (TREE_CODE (op
) != SSA_NAME
&& !is_gimple_min_invariant (op
))
864 error ("PHI argument is not SSA_NAME, or invariant");
868 if (TREE_CODE (op
) == SSA_NAME
)
870 err
= verify_ssa_name (op
, virtual_operand_p (gimple_phi_result (phi
)));
871 err
|= verify_use (e
->src
, definition_block
[SSA_NAME_VERSION (op
)],
872 op_p
, phi
, e
->flags
& EDGE_ABNORMAL
, NULL
);
875 if (TREE_CODE (op
) == ADDR_EXPR
)
877 tree base
= TREE_OPERAND (op
, 0);
878 while (handled_component_p (base
))
879 base
= TREE_OPERAND (base
, 0);
880 if ((TREE_CODE (base
) == VAR_DECL
881 || TREE_CODE (base
) == PARM_DECL
882 || TREE_CODE (base
) == RESULT_DECL
)
883 && !TREE_ADDRESSABLE (base
))
885 error ("address taken, but ADDRESSABLE bit not set");
892 error ("wrong edge %d->%d for PHI argument",
893 e
->src
->index
, e
->dest
->index
);
899 fprintf (stderr
, "PHI argument\n");
900 print_generic_stmt (stderr
, op
, TDF_VOPS
);
908 fprintf (stderr
, "for PHI node\n");
909 print_gimple_stmt (stderr
, phi
, 0, TDF_VOPS
|TDF_MEMSYMS
);
917 /* Verify common invariants in the SSA web.
918 TODO: verify the variable annotations. */
921 verify_ssa (bool check_modified_stmt
, bool check_ssa_operands
)
925 basic_block
*definition_block
= XCNEWVEC (basic_block
, num_ssa_names
);
928 enum dom_state orig_dom_state
= dom_info_state (CDI_DOMINATORS
);
929 bitmap names_defined_in_bb
= BITMAP_ALLOC (NULL
);
931 gcc_assert (!need_ssa_update_p (cfun
));
933 timevar_push (TV_TREE_SSA_VERIFY
);
935 /* Keep track of SSA names present in the IL. */
936 for (i
= 1; i
< num_ssa_names
; i
++)
938 tree name
= ssa_name (i
);
942 TREE_VISITED (name
) = 0;
944 verify_ssa_name (name
, virtual_operand_p (name
));
946 stmt
= SSA_NAME_DEF_STMT (name
);
947 if (!gimple_nop_p (stmt
))
949 basic_block bb
= gimple_bb (stmt
);
950 if (verify_def (bb
, definition_block
,
951 name
, stmt
, virtual_operand_p (name
)))
957 calculate_dominance_info (CDI_DOMINATORS
);
959 /* Now verify all the uses and make sure they agree with the definitions
960 found in the previous pass. */
961 FOR_EACH_BB_FN (bb
, cfun
)
966 /* Make sure that all edges have a clear 'aux' field. */
967 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
971 error ("AUX pointer initialized for edge %d->%d", e
->src
->index
,
977 /* Verify the arguments for every PHI node in the block. */
978 for (gphi_iterator gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
980 gphi
*phi
= gsi
.phi ();
981 if (verify_phi_args (phi
, bb
, definition_block
))
984 bitmap_set_bit (names_defined_in_bb
,
985 SSA_NAME_VERSION (gimple_phi_result (phi
)));
988 /* Now verify all the uses and vuses in every statement of the block. */
989 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
);
992 gimple stmt
= gsi_stmt (gsi
);
995 if (check_modified_stmt
&& gimple_modified_p (stmt
))
997 error ("stmt (%p) marked modified after optimization pass: ",
999 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
);
1003 if (check_ssa_operands
&& verify_ssa_operands (cfun
, stmt
))
1005 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
);
1009 if (gimple_debug_bind_p (stmt
)
1010 && !gimple_debug_bind_has_value_p (stmt
))
1013 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_USE
|SSA_OP_VUSE
)
1015 op
= USE_FROM_PTR (use_p
);
1016 if (verify_use (bb
, definition_block
[SSA_NAME_VERSION (op
)],
1017 use_p
, stmt
, false, names_defined_in_bb
))
1021 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, iter
, SSA_OP_ALL_DEFS
)
1023 if (SSA_NAME_DEF_STMT (op
) != stmt
)
1025 error ("SSA_NAME_DEF_STMT is wrong");
1026 fprintf (stderr
, "Expected definition statement:\n");
1027 print_gimple_stmt (stderr
, stmt
, 4, TDF_VOPS
);
1028 fprintf (stderr
, "\nActual definition statement:\n");
1029 print_gimple_stmt (stderr
, SSA_NAME_DEF_STMT (op
),
1033 bitmap_set_bit (names_defined_in_bb
, SSA_NAME_VERSION (op
));
1037 bitmap_clear (names_defined_in_bb
);
1040 free (definition_block
);
1042 /* Restore the dominance information to its prior known state, so
1043 that we do not perturb the compiler's subsequent behavior. */
1044 if (orig_dom_state
== DOM_NONE
)
1045 free_dominance_info (CDI_DOMINATORS
);
1047 set_dom_info_availability (CDI_DOMINATORS
, orig_dom_state
);
1049 BITMAP_FREE (names_defined_in_bb
);
1050 timevar_pop (TV_TREE_SSA_VERIFY
);
1054 internal_error ("verify_ssa failed");
1058 /* Initialize global DFA and SSA structures. */
1061 init_tree_ssa (struct function
*fn
)
1063 fn
->gimple_df
= ggc_cleared_alloc
<gimple_df
> ();
1064 fn
->gimple_df
->default_defs
= hash_table
<ssa_name_hasher
>::create_ggc (20);
1065 pt_solution_reset (&fn
->gimple_df
->escaped
);
1066 init_ssanames (fn
, 0);
1069 /* Do the actions required to initialize internal data structures used
1070 in tree-ssa optimization passes. */
1073 execute_init_datastructures (void)
1075 /* Allocate hash tables, arrays and other structures. */
1076 gcc_assert (!cfun
->gimple_df
);
1077 init_tree_ssa (cfun
);
1083 const pass_data pass_data_init_datastructures
=
1085 GIMPLE_PASS
, /* type */
1086 "*init_datastructures", /* name */
1087 OPTGROUP_NONE
, /* optinfo_flags */
1088 TV_NONE
, /* tv_id */
1089 PROP_cfg
, /* properties_required */
1090 0, /* properties_provided */
1091 0, /* properties_destroyed */
1092 0, /* todo_flags_start */
1093 0, /* todo_flags_finish */
1096 class pass_init_datastructures
: public gimple_opt_pass
1099 pass_init_datastructures (gcc::context
*ctxt
)
1100 : gimple_opt_pass (pass_data_init_datastructures
, ctxt
)
1103 /* opt_pass methods: */
1104 virtual bool gate (function
*fun
)
1106 /* Do nothing for funcions that was produced already in SSA form. */
1107 return !(fun
->curr_properties
& PROP_ssa
);
1110 virtual unsigned int execute (function
*)
1112 return execute_init_datastructures ();
1115 }; // class pass_init_datastructures
1120 make_pass_init_datastructures (gcc::context
*ctxt
)
1122 return new pass_init_datastructures (ctxt
);
1125 /* Deallocate memory associated with SSA data structures for FNDECL. */
1128 delete_tree_ssa (void)
1132 /* We no longer maintain the SSA operand cache at this point. */
1133 if (ssa_operands_active (cfun
))
1134 fini_ssa_operands (cfun
);
1136 cfun
->gimple_df
->default_defs
->empty ();
1137 cfun
->gimple_df
->default_defs
= NULL
;
1138 pt_solution_reset (&cfun
->gimple_df
->escaped
);
1139 if (cfun
->gimple_df
->decls_to_pointers
!= NULL
)
1140 delete cfun
->gimple_df
->decls_to_pointers
;
1141 cfun
->gimple_df
->decls_to_pointers
= NULL
;
1142 cfun
->gimple_df
->modified_noreturn_calls
= NULL
;
1143 cfun
->gimple_df
= NULL
;
1145 /* We no longer need the edge variable maps. */
1146 redirect_edge_var_map_destroy ();
1149 /* Return true if EXPR is a useless type conversion, otherwise return
1153 tree_ssa_useless_type_conversion (tree expr
)
1155 /* If we have an assignment that merely uses a NOP_EXPR to change
1156 the top of the RHS to the type of the LHS and the type conversion
1157 is "safe", then strip away the type conversion so that we can
1158 enter LHS = RHS into the const_and_copies table. */
1159 if (CONVERT_EXPR_P (expr
)
1160 || TREE_CODE (expr
) == VIEW_CONVERT_EXPR
1161 || TREE_CODE (expr
) == NON_LVALUE_EXPR
)
1162 return useless_type_conversion_p
1164 TREE_TYPE (TREE_OPERAND (expr
, 0)));
1169 /* Strip conversions from EXP according to
1170 tree_ssa_useless_type_conversion and return the resulting
1174 tree_ssa_strip_useless_type_conversions (tree exp
)
1176 while (tree_ssa_useless_type_conversion (exp
))
1177 exp
= TREE_OPERAND (exp
, 0);
1182 /* Return true if T, an SSA_NAME, has an undefined value. */
1185 ssa_undefined_value_p (tree t
)
1188 tree var
= SSA_NAME_VAR (t
);
1192 /* Parameters get their initial value from the function entry. */
1193 else if (TREE_CODE (var
) == PARM_DECL
)
1195 /* When returning by reference the return address is actually a hidden
1197 else if (TREE_CODE (var
) == RESULT_DECL
&& DECL_BY_REFERENCE (var
))
1199 /* Hard register variables get their initial value from the ether. */
1200 else if (TREE_CODE (var
) == VAR_DECL
&& DECL_HARD_REGISTER (var
))
1203 /* The value is undefined iff its definition statement is empty. */
1204 def_stmt
= SSA_NAME_DEF_STMT (t
);
1205 if (gimple_nop_p (def_stmt
))
1208 /* Check if the complex was not only partially defined. */
1209 if (is_gimple_assign (def_stmt
)
1210 && gimple_assign_rhs_code (def_stmt
) == COMPLEX_EXPR
)
1214 rhs1
= gimple_assign_rhs1 (def_stmt
);
1215 rhs2
= gimple_assign_rhs2 (def_stmt
);
1216 return (TREE_CODE (rhs1
) == SSA_NAME
&& ssa_undefined_value_p (rhs1
))
1217 || (TREE_CODE (rhs2
) == SSA_NAME
&& ssa_undefined_value_p (rhs2
));
1223 /* If necessary, rewrite the base of the reference tree *TP from
1224 a MEM_REF to a plain or converted symbol. */
1227 maybe_rewrite_mem_ref_base (tree
*tp
, bitmap suitable_for_renaming
)
1231 while (handled_component_p (*tp
))
1232 tp
= &TREE_OPERAND (*tp
, 0);
1233 if (TREE_CODE (*tp
) == MEM_REF
1234 && TREE_CODE (TREE_OPERAND (*tp
, 0)) == ADDR_EXPR
1235 && (sym
= TREE_OPERAND (TREE_OPERAND (*tp
, 0), 0))
1237 && !TREE_ADDRESSABLE (sym
)
1238 && bitmap_bit_p (suitable_for_renaming
, DECL_UID (sym
)))
1240 if (TREE_CODE (TREE_TYPE (sym
)) == VECTOR_TYPE
1241 && useless_type_conversion_p (TREE_TYPE (*tp
),
1242 TREE_TYPE (TREE_TYPE (sym
)))
1243 && multiple_of_p (sizetype
, TREE_OPERAND (*tp
, 1),
1244 TYPE_SIZE_UNIT (TREE_TYPE (*tp
))))
1246 *tp
= build3 (BIT_FIELD_REF
, TREE_TYPE (*tp
), sym
,
1247 TYPE_SIZE (TREE_TYPE (*tp
)),
1248 int_const_binop (MULT_EXPR
,
1249 bitsize_int (BITS_PER_UNIT
),
1250 TREE_OPERAND (*tp
, 1)));
1252 else if (TREE_CODE (TREE_TYPE (sym
)) == COMPLEX_TYPE
1253 && useless_type_conversion_p (TREE_TYPE (*tp
),
1254 TREE_TYPE (TREE_TYPE (sym
))))
1256 *tp
= build1 (integer_zerop (TREE_OPERAND (*tp
, 1))
1257 ? REALPART_EXPR
: IMAGPART_EXPR
,
1258 TREE_TYPE (*tp
), sym
);
1260 else if (integer_zerop (TREE_OPERAND (*tp
, 1)))
1262 if (!useless_type_conversion_p (TREE_TYPE (*tp
),
1264 *tp
= build1 (VIEW_CONVERT_EXPR
,
1265 TREE_TYPE (*tp
), sym
);
1272 /* For a tree REF return its base if it is the base of a MEM_REF
1273 that cannot be rewritten into SSA form. Otherwise return NULL_TREE. */
1276 non_rewritable_mem_ref_base (tree ref
)
1280 /* A plain decl does not need it set. */
1284 while (handled_component_p (base
))
1285 base
= TREE_OPERAND (base
, 0);
1287 /* But watch out for MEM_REFs we cannot lower to a
1288 VIEW_CONVERT_EXPR or a BIT_FIELD_REF. */
1289 if (TREE_CODE (base
) == MEM_REF
1290 && TREE_CODE (TREE_OPERAND (base
, 0)) == ADDR_EXPR
)
1292 tree decl
= TREE_OPERAND (TREE_OPERAND (base
, 0), 0);
1293 if ((TREE_CODE (TREE_TYPE (decl
)) == VECTOR_TYPE
1294 || TREE_CODE (TREE_TYPE (decl
)) == COMPLEX_TYPE
)
1295 && useless_type_conversion_p (TREE_TYPE (base
),
1296 TREE_TYPE (TREE_TYPE (decl
)))
1297 && wi::fits_uhwi_p (mem_ref_offset (base
))
1298 && wi::gtu_p (wi::to_offset (TYPE_SIZE_UNIT (TREE_TYPE (decl
))),
1299 mem_ref_offset (base
))
1300 && multiple_of_p (sizetype
, TREE_OPERAND (base
, 1),
1301 TYPE_SIZE_UNIT (TREE_TYPE (base
))))
1304 && (!integer_zerop (TREE_OPERAND (base
, 1))
1305 || (DECL_SIZE (decl
)
1306 != TYPE_SIZE (TREE_TYPE (base
)))
1307 || TREE_THIS_VOLATILE (decl
) != TREE_THIS_VOLATILE (base
)))
1314 /* For an lvalue tree LHS return true if it cannot be rewritten into SSA form.
1315 Otherwise return true. */
1318 non_rewritable_lvalue_p (tree lhs
)
1320 /* A plain decl is always rewritable. */
1324 /* A decl that is wrapped inside a MEM-REF that covers
1325 it full is also rewritable.
1326 ??? The following could be relaxed allowing component
1327 references that do not change the access size. */
1328 if (TREE_CODE (lhs
) == MEM_REF
1329 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == ADDR_EXPR
1330 && integer_zerop (TREE_OPERAND (lhs
, 1)))
1332 tree decl
= TREE_OPERAND (TREE_OPERAND (lhs
, 0), 0);
1334 && DECL_SIZE (decl
) == TYPE_SIZE (TREE_TYPE (lhs
))
1335 && (TREE_THIS_VOLATILE (decl
) == TREE_THIS_VOLATILE (lhs
)))
1342 /* When possible, clear TREE_ADDRESSABLE bit or set DECL_GIMPLE_REG_P bit and
1343 mark the variable VAR for conversion into SSA. Return true when updating
1344 stmts is required. */
1347 maybe_optimize_var (tree var
, bitmap addresses_taken
, bitmap not_reg_needs
,
1348 bitmap suitable_for_renaming
)
1350 /* Global Variables, result decls cannot be changed. */
1351 if (is_global_var (var
)
1352 || TREE_CODE (var
) == RESULT_DECL
1353 || bitmap_bit_p (addresses_taken
, DECL_UID (var
)))
1356 if (TREE_ADDRESSABLE (var
)
1357 /* Do not change TREE_ADDRESSABLE if we need to preserve var as
1358 a non-register. Otherwise we are confused and forget to
1359 add virtual operands for it. */
1360 && (!is_gimple_reg_type (TREE_TYPE (var
))
1361 || TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
1362 || TREE_CODE (TREE_TYPE (var
)) == COMPLEX_TYPE
1363 || !bitmap_bit_p (not_reg_needs
, DECL_UID (var
))))
1365 TREE_ADDRESSABLE (var
) = 0;
1366 if (is_gimple_reg (var
))
1367 bitmap_set_bit (suitable_for_renaming
, DECL_UID (var
));
1370 fprintf (dump_file
, "No longer having address taken: ");
1371 print_generic_expr (dump_file
, var
, 0);
1372 fprintf (dump_file
, "\n");
1376 if (!DECL_GIMPLE_REG_P (var
)
1377 && !bitmap_bit_p (not_reg_needs
, DECL_UID (var
))
1378 && (TREE_CODE (TREE_TYPE (var
)) == COMPLEX_TYPE
1379 || TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
)
1380 && !TREE_THIS_VOLATILE (var
)
1381 && (TREE_CODE (var
) != VAR_DECL
|| !DECL_HARD_REGISTER (var
)))
1383 DECL_GIMPLE_REG_P (var
) = 1;
1384 bitmap_set_bit (suitable_for_renaming
, DECL_UID (var
));
1387 fprintf (dump_file
, "Now a gimple register: ");
1388 print_generic_expr (dump_file
, var
, 0);
1389 fprintf (dump_file
, "\n");
1394 /* Compute TREE_ADDRESSABLE and DECL_GIMPLE_REG_P for local variables. */
1397 execute_update_addresses_taken (void)
1400 bitmap addresses_taken
= BITMAP_ALLOC (NULL
);
1401 bitmap not_reg_needs
= BITMAP_ALLOC (NULL
);
1402 bitmap suitable_for_renaming
= BITMAP_ALLOC (NULL
);
1406 timevar_push (TV_ADDRESS_TAKEN
);
1408 /* Collect into ADDRESSES_TAKEN all variables whose address is taken within
1409 the function body. */
1410 FOR_EACH_BB_FN (bb
, cfun
)
1412 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
);
1415 gimple stmt
= gsi_stmt (gsi
);
1416 enum gimple_code code
= gimple_code (stmt
);
1419 /* Note all addresses taken by the stmt. */
1420 gimple_ior_addresses_taken (addresses_taken
, stmt
);
1422 /* If we have a call or an assignment, see if the lhs contains
1423 a local decl that requires not to be a gimple register. */
1424 if (code
== GIMPLE_ASSIGN
|| code
== GIMPLE_CALL
)
1426 tree lhs
= gimple_get_lhs (stmt
);
1428 && TREE_CODE (lhs
) != SSA_NAME
1429 && non_rewritable_lvalue_p (lhs
))
1431 decl
= get_base_address (lhs
);
1433 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1437 if (gimple_assign_single_p (stmt
))
1439 tree rhs
= gimple_assign_rhs1 (stmt
);
1440 if ((decl
= non_rewritable_mem_ref_base (rhs
)))
1441 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1444 else if (code
== GIMPLE_CALL
)
1446 for (i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
1448 tree arg
= gimple_call_arg (stmt
, i
);
1449 if ((decl
= non_rewritable_mem_ref_base (arg
)))
1450 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1454 else if (code
== GIMPLE_ASM
)
1456 gasm
*asm_stmt
= as_a
<gasm
*> (stmt
);
1457 for (i
= 0; i
< gimple_asm_noutputs (asm_stmt
); ++i
)
1459 tree link
= gimple_asm_output_op (asm_stmt
, i
);
1460 tree lhs
= TREE_VALUE (link
);
1461 if (TREE_CODE (lhs
) != SSA_NAME
)
1463 decl
= get_base_address (lhs
);
1465 && (non_rewritable_lvalue_p (lhs
)
1466 /* We cannot move required conversions from
1467 the lhs to the rhs in asm statements, so
1468 require we do not need any. */
1469 || !useless_type_conversion_p
1470 (TREE_TYPE (lhs
), TREE_TYPE (decl
))))
1471 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1474 for (i
= 0; i
< gimple_asm_ninputs (asm_stmt
); ++i
)
1476 tree link
= gimple_asm_input_op (asm_stmt
, i
);
1477 if ((decl
= non_rewritable_mem_ref_base (TREE_VALUE (link
))))
1478 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1483 for (gphi_iterator gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
);
1487 gphi
*phi
= gsi
.phi ();
1489 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
1491 tree op
= PHI_ARG_DEF (phi
, i
), var
;
1492 if (TREE_CODE (op
) == ADDR_EXPR
1493 && (var
= get_base_address (TREE_OPERAND (op
, 0))) != NULL
1495 bitmap_set_bit (addresses_taken
, DECL_UID (var
));
1500 /* We cannot iterate over all referenced vars because that can contain
1501 unused vars from BLOCK trees, which causes code generation differences
1503 for (var
= DECL_ARGUMENTS (cfun
->decl
); var
; var
= DECL_CHAIN (var
))
1504 maybe_optimize_var (var
, addresses_taken
, not_reg_needs
,
1505 suitable_for_renaming
);
1507 FOR_EACH_VEC_SAFE_ELT (cfun
->local_decls
, i
, var
)
1508 maybe_optimize_var (var
, addresses_taken
, not_reg_needs
,
1509 suitable_for_renaming
);
1511 /* Operand caches need to be recomputed for operands referencing the updated
1512 variables and operands need to be rewritten to expose bare symbols. */
1513 if (!bitmap_empty_p (suitable_for_renaming
))
1515 FOR_EACH_BB_FN (bb
, cfun
)
1516 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
);)
1518 gimple stmt
= gsi_stmt (gsi
);
1520 /* Re-write TARGET_MEM_REFs of symbols we want to
1521 rewrite into SSA form. */
1522 if (gimple_assign_single_p (stmt
))
1524 tree lhs
= gimple_assign_lhs (stmt
);
1525 tree rhs
, *rhsp
= gimple_assign_rhs1_ptr (stmt
);
1528 /* We shouldn't have any fancy wrapping of
1529 component-refs on the LHS, but look through
1530 VIEW_CONVERT_EXPRs as that is easy. */
1531 while (TREE_CODE (lhs
) == VIEW_CONVERT_EXPR
)
1532 lhs
= TREE_OPERAND (lhs
, 0);
1533 if (TREE_CODE (lhs
) == MEM_REF
1534 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == ADDR_EXPR
1535 && integer_zerop (TREE_OPERAND (lhs
, 1))
1536 && (sym
= TREE_OPERAND (TREE_OPERAND (lhs
, 0), 0))
1538 && !TREE_ADDRESSABLE (sym
)
1539 && bitmap_bit_p (suitable_for_renaming
, DECL_UID (sym
)))
1542 lhs
= gimple_assign_lhs (stmt
);
1544 /* Rewrite the RHS and make sure the resulting assignment
1545 is validly typed. */
1546 maybe_rewrite_mem_ref_base (rhsp
, suitable_for_renaming
);
1547 rhs
= gimple_assign_rhs1 (stmt
);
1548 if (gimple_assign_lhs (stmt
) != lhs
1549 && !useless_type_conversion_p (TREE_TYPE (lhs
),
1551 rhs
= fold_build1 (VIEW_CONVERT_EXPR
,
1552 TREE_TYPE (lhs
), rhs
);
1554 if (gimple_assign_lhs (stmt
) != lhs
)
1555 gimple_assign_set_lhs (stmt
, lhs
);
1557 /* For var ={v} {CLOBBER}; where var lost
1558 TREE_ADDRESSABLE just remove the stmt. */
1560 && TREE_CLOBBER_P (rhs
)
1561 && bitmap_bit_p (suitable_for_renaming
, DECL_UID (lhs
)))
1563 unlink_stmt_vdef (stmt
);
1564 gsi_remove (&gsi
, true);
1565 release_defs (stmt
);
1569 if (gimple_assign_rhs1 (stmt
) != rhs
)
1571 gimple_stmt_iterator gsi
= gsi_for_stmt (stmt
);
1572 gimple_assign_set_rhs_from_tree (&gsi
, rhs
);
1576 else if (gimple_code (stmt
) == GIMPLE_CALL
)
1579 for (i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
1581 tree
*argp
= gimple_call_arg_ptr (stmt
, i
);
1582 maybe_rewrite_mem_ref_base (argp
, suitable_for_renaming
);
1586 else if (gimple_code (stmt
) == GIMPLE_ASM
)
1588 gasm
*asm_stmt
= as_a
<gasm
*> (stmt
);
1590 for (i
= 0; i
< gimple_asm_noutputs (asm_stmt
); ++i
)
1592 tree link
= gimple_asm_output_op (asm_stmt
, i
);
1593 maybe_rewrite_mem_ref_base (&TREE_VALUE (link
),
1594 suitable_for_renaming
);
1596 for (i
= 0; i
< gimple_asm_ninputs (asm_stmt
); ++i
)
1598 tree link
= gimple_asm_input_op (asm_stmt
, i
);
1599 maybe_rewrite_mem_ref_base (&TREE_VALUE (link
),
1600 suitable_for_renaming
);
1604 else if (gimple_debug_bind_p (stmt
)
1605 && gimple_debug_bind_has_value_p (stmt
))
1607 tree
*valuep
= gimple_debug_bind_get_value_ptr (stmt
);
1609 maybe_rewrite_mem_ref_base (valuep
, suitable_for_renaming
);
1610 decl
= non_rewritable_mem_ref_base (*valuep
);
1612 && bitmap_bit_p (suitable_for_renaming
, DECL_UID (decl
)))
1613 gimple_debug_bind_reset_value (stmt
);
1616 if (gimple_references_memory_p (stmt
)
1617 || is_gimple_debug (stmt
))
1623 /* Update SSA form here, we are called as non-pass as well. */
1624 if (number_of_loops (cfun
) > 1
1625 && loops_state_satisfies_p (LOOP_CLOSED_SSA
))
1626 rewrite_into_loop_closed_ssa (NULL
, TODO_update_ssa
);
1628 update_ssa (TODO_update_ssa
);
1631 BITMAP_FREE (not_reg_needs
);
1632 BITMAP_FREE (addresses_taken
);
1633 BITMAP_FREE (suitable_for_renaming
);
1634 timevar_pop (TV_ADDRESS_TAKEN
);
1639 const pass_data pass_data_update_address_taken
=
1641 GIMPLE_PASS
, /* type */
1642 "addressables", /* name */
1643 OPTGROUP_NONE
, /* optinfo_flags */
1644 TV_ADDRESS_TAKEN
, /* tv_id */
1645 PROP_ssa
, /* properties_required */
1646 0, /* properties_provided */
1647 0, /* properties_destroyed */
1648 0, /* todo_flags_start */
1649 TODO_update_address_taken
, /* todo_flags_finish */
1652 class pass_update_address_taken
: public gimple_opt_pass
1655 pass_update_address_taken (gcc::context
*ctxt
)
1656 : gimple_opt_pass (pass_data_update_address_taken
, ctxt
)
1659 /* opt_pass methods: */
1661 }; // class pass_update_address_taken
1666 make_pass_update_address_taken (gcc::context
*ctxt
)
1668 return new pass_update_address_taken (ctxt
);