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
)
152 gimple_phi_iterator gsi
;
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
)
188 gimple_phi_iterator gsi
;
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 (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
))
439 gimple_debug def_temp
;
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 (gimple 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 gimple_stmt_iterator gsi
;
968 /* Make sure that all edges have a clear 'aux' field. */
969 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
973 error ("AUX pointer initialized for edge %d->%d", e
->src
->index
,
979 /* Verify the arguments for every PHI node in the block. */
980 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
982 phi
= gsi_stmt (gsi
);
983 if (verify_phi_args (phi
, bb
, definition_block
))
986 bitmap_set_bit (names_defined_in_bb
,
987 SSA_NAME_VERSION (gimple_phi_result (phi
)));
990 /* Now verify all the uses and vuses in every statement of the block. */
991 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
993 gimple stmt
= gsi_stmt (gsi
);
996 if (check_modified_stmt
&& gimple_modified_p (stmt
))
998 error ("stmt (%p) marked modified after optimization pass: ",
1000 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
);
1004 if (check_ssa_operands
&& verify_ssa_operands (cfun
, stmt
))
1006 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
);
1010 if (gimple_debug_bind_p (stmt
)
1011 && !gimple_debug_bind_has_value_p (stmt
))
1014 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_USE
|SSA_OP_VUSE
)
1016 op
= USE_FROM_PTR (use_p
);
1017 if (verify_use (bb
, definition_block
[SSA_NAME_VERSION (op
)],
1018 use_p
, stmt
, false, names_defined_in_bb
))
1022 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, iter
, SSA_OP_ALL_DEFS
)
1024 if (SSA_NAME_DEF_STMT (op
) != stmt
)
1026 error ("SSA_NAME_DEF_STMT is wrong");
1027 fprintf (stderr
, "Expected definition statement:\n");
1028 print_gimple_stmt (stderr
, stmt
, 4, TDF_VOPS
);
1029 fprintf (stderr
, "\nActual definition statement:\n");
1030 print_gimple_stmt (stderr
, SSA_NAME_DEF_STMT (op
),
1034 bitmap_set_bit (names_defined_in_bb
, SSA_NAME_VERSION (op
));
1038 bitmap_clear (names_defined_in_bb
);
1041 free (definition_block
);
1043 /* Restore the dominance information to its prior known state, so
1044 that we do not perturb the compiler's subsequent behavior. */
1045 if (orig_dom_state
== DOM_NONE
)
1046 free_dominance_info (CDI_DOMINATORS
);
1048 set_dom_info_availability (CDI_DOMINATORS
, orig_dom_state
);
1050 BITMAP_FREE (names_defined_in_bb
);
1051 timevar_pop (TV_TREE_SSA_VERIFY
);
1055 internal_error ("verify_ssa failed");
1059 /* Initialize global DFA and SSA structures. */
1062 init_tree_ssa (struct function
*fn
)
1064 fn
->gimple_df
= ggc_cleared_alloc
<gimple_df
> ();
1065 fn
->gimple_df
->default_defs
= hash_table
<ssa_name_hasher
>::create_ggc (20);
1066 pt_solution_reset (&fn
->gimple_df
->escaped
);
1067 init_ssanames (fn
, 0);
1070 /* Do the actions required to initialize internal data structures used
1071 in tree-ssa optimization passes. */
1074 execute_init_datastructures (void)
1076 /* Allocate hash tables, arrays and other structures. */
1077 gcc_assert (!cfun
->gimple_df
);
1078 init_tree_ssa (cfun
);
1084 const pass_data pass_data_init_datastructures
=
1086 GIMPLE_PASS
, /* type */
1087 "*init_datastructures", /* name */
1088 OPTGROUP_NONE
, /* optinfo_flags */
1089 TV_NONE
, /* tv_id */
1090 PROP_cfg
, /* properties_required */
1091 0, /* properties_provided */
1092 0, /* properties_destroyed */
1093 0, /* todo_flags_start */
1094 0, /* todo_flags_finish */
1097 class pass_init_datastructures
: public gimple_opt_pass
1100 pass_init_datastructures (gcc::context
*ctxt
)
1101 : gimple_opt_pass (pass_data_init_datastructures
, ctxt
)
1104 /* opt_pass methods: */
1105 virtual bool gate (function
*fun
)
1107 /* Do nothing for funcions that was produced already in SSA form. */
1108 return !(fun
->curr_properties
& PROP_ssa
);
1111 virtual unsigned int execute (function
*)
1113 return execute_init_datastructures ();
1116 }; // class pass_init_datastructures
1121 make_pass_init_datastructures (gcc::context
*ctxt
)
1123 return new pass_init_datastructures (ctxt
);
1126 /* Deallocate memory associated with SSA data structures for FNDECL. */
1129 delete_tree_ssa (void)
1133 /* We no longer maintain the SSA operand cache at this point. */
1134 if (ssa_operands_active (cfun
))
1135 fini_ssa_operands (cfun
);
1137 cfun
->gimple_df
->default_defs
->empty ();
1138 cfun
->gimple_df
->default_defs
= NULL
;
1139 pt_solution_reset (&cfun
->gimple_df
->escaped
);
1140 if (cfun
->gimple_df
->decls_to_pointers
!= NULL
)
1141 delete cfun
->gimple_df
->decls_to_pointers
;
1142 cfun
->gimple_df
->decls_to_pointers
= NULL
;
1143 cfun
->gimple_df
->modified_noreturn_calls
= NULL
;
1144 cfun
->gimple_df
= NULL
;
1146 /* We no longer need the edge variable maps. */
1147 redirect_edge_var_map_destroy ();
1150 /* Return true if EXPR is a useless type conversion, otherwise return
1154 tree_ssa_useless_type_conversion (tree expr
)
1156 /* If we have an assignment that merely uses a NOP_EXPR to change
1157 the top of the RHS to the type of the LHS and the type conversion
1158 is "safe", then strip away the type conversion so that we can
1159 enter LHS = RHS into the const_and_copies table. */
1160 if (CONVERT_EXPR_P (expr
)
1161 || TREE_CODE (expr
) == VIEW_CONVERT_EXPR
1162 || TREE_CODE (expr
) == NON_LVALUE_EXPR
)
1163 return useless_type_conversion_p
1165 TREE_TYPE (TREE_OPERAND (expr
, 0)));
1170 /* Strip conversions from EXP according to
1171 tree_ssa_useless_type_conversion and return the resulting
1175 tree_ssa_strip_useless_type_conversions (tree exp
)
1177 while (tree_ssa_useless_type_conversion (exp
))
1178 exp
= TREE_OPERAND (exp
, 0);
1183 /* Return true if T, an SSA_NAME, has an undefined value. */
1186 ssa_undefined_value_p (tree t
)
1189 tree var
= SSA_NAME_VAR (t
);
1193 /* Parameters get their initial value from the function entry. */
1194 else if (TREE_CODE (var
) == PARM_DECL
)
1196 /* When returning by reference the return address is actually a hidden
1198 else if (TREE_CODE (var
) == RESULT_DECL
&& DECL_BY_REFERENCE (var
))
1200 /* Hard register variables get their initial value from the ether. */
1201 else if (TREE_CODE (var
) == VAR_DECL
&& DECL_HARD_REGISTER (var
))
1204 /* The value is undefined iff its definition statement is empty. */
1205 def_stmt
= SSA_NAME_DEF_STMT (t
);
1206 if (gimple_nop_p (def_stmt
))
1209 /* Check if the complex was not only partially defined. */
1210 if (is_gimple_assign (def_stmt
)
1211 && gimple_assign_rhs_code (def_stmt
) == COMPLEX_EXPR
)
1215 rhs1
= gimple_assign_rhs1 (def_stmt
);
1216 rhs2
= gimple_assign_rhs2 (def_stmt
);
1217 return (TREE_CODE (rhs1
) == SSA_NAME
&& ssa_undefined_value_p (rhs1
))
1218 || (TREE_CODE (rhs2
) == SSA_NAME
&& ssa_undefined_value_p (rhs2
));
1224 /* If necessary, rewrite the base of the reference tree *TP from
1225 a MEM_REF to a plain or converted symbol. */
1228 maybe_rewrite_mem_ref_base (tree
*tp
, bitmap suitable_for_renaming
)
1232 while (handled_component_p (*tp
))
1233 tp
= &TREE_OPERAND (*tp
, 0);
1234 if (TREE_CODE (*tp
) == MEM_REF
1235 && TREE_CODE (TREE_OPERAND (*tp
, 0)) == ADDR_EXPR
1236 && (sym
= TREE_OPERAND (TREE_OPERAND (*tp
, 0), 0))
1238 && !TREE_ADDRESSABLE (sym
)
1239 && bitmap_bit_p (suitable_for_renaming
, DECL_UID (sym
)))
1241 if (TREE_CODE (TREE_TYPE (sym
)) == VECTOR_TYPE
1242 && useless_type_conversion_p (TREE_TYPE (*tp
),
1243 TREE_TYPE (TREE_TYPE (sym
)))
1244 && multiple_of_p (sizetype
, TREE_OPERAND (*tp
, 1),
1245 TYPE_SIZE_UNIT (TREE_TYPE (*tp
))))
1247 *tp
= build3 (BIT_FIELD_REF
, TREE_TYPE (*tp
), sym
,
1248 TYPE_SIZE (TREE_TYPE (*tp
)),
1249 int_const_binop (MULT_EXPR
,
1250 bitsize_int (BITS_PER_UNIT
),
1251 TREE_OPERAND (*tp
, 1)));
1253 else if (TREE_CODE (TREE_TYPE (sym
)) == COMPLEX_TYPE
1254 && useless_type_conversion_p (TREE_TYPE (*tp
),
1255 TREE_TYPE (TREE_TYPE (sym
))))
1257 *tp
= build1 (integer_zerop (TREE_OPERAND (*tp
, 1))
1258 ? REALPART_EXPR
: IMAGPART_EXPR
,
1259 TREE_TYPE (*tp
), sym
);
1261 else if (integer_zerop (TREE_OPERAND (*tp
, 1)))
1263 if (!useless_type_conversion_p (TREE_TYPE (*tp
),
1265 *tp
= build1 (VIEW_CONVERT_EXPR
,
1266 TREE_TYPE (*tp
), sym
);
1273 /* For a tree REF return its base if it is the base of a MEM_REF
1274 that cannot be rewritten into SSA form. Otherwise return NULL_TREE. */
1277 non_rewritable_mem_ref_base (tree ref
)
1281 /* A plain decl does not need it set. */
1285 while (handled_component_p (base
))
1286 base
= TREE_OPERAND (base
, 0);
1288 /* But watch out for MEM_REFs we cannot lower to a
1289 VIEW_CONVERT_EXPR or a BIT_FIELD_REF. */
1290 if (TREE_CODE (base
) == MEM_REF
1291 && TREE_CODE (TREE_OPERAND (base
, 0)) == ADDR_EXPR
)
1293 tree decl
= TREE_OPERAND (TREE_OPERAND (base
, 0), 0);
1294 if ((TREE_CODE (TREE_TYPE (decl
)) == VECTOR_TYPE
1295 || TREE_CODE (TREE_TYPE (decl
)) == COMPLEX_TYPE
)
1296 && useless_type_conversion_p (TREE_TYPE (base
),
1297 TREE_TYPE (TREE_TYPE (decl
)))
1298 && wi::fits_uhwi_p (mem_ref_offset (base
))
1299 && wi::gtu_p (wi::to_offset (TYPE_SIZE_UNIT (TREE_TYPE (decl
))),
1300 mem_ref_offset (base
))
1301 && multiple_of_p (sizetype
, TREE_OPERAND (base
, 1),
1302 TYPE_SIZE_UNIT (TREE_TYPE (base
))))
1305 && (!integer_zerop (TREE_OPERAND (base
, 1))
1306 || (DECL_SIZE (decl
)
1307 != TYPE_SIZE (TREE_TYPE (base
)))
1308 || TREE_THIS_VOLATILE (decl
) != TREE_THIS_VOLATILE (base
)))
1315 /* For an lvalue tree LHS return true if it cannot be rewritten into SSA form.
1316 Otherwise return true. */
1319 non_rewritable_lvalue_p (tree lhs
)
1321 /* A plain decl is always rewritable. */
1325 /* A decl that is wrapped inside a MEM-REF that covers
1326 it full is also rewritable.
1327 ??? The following could be relaxed allowing component
1328 references that do not change the access size. */
1329 if (TREE_CODE (lhs
) == MEM_REF
1330 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == ADDR_EXPR
1331 && integer_zerop (TREE_OPERAND (lhs
, 1)))
1333 tree decl
= TREE_OPERAND (TREE_OPERAND (lhs
, 0), 0);
1335 && DECL_SIZE (decl
) == TYPE_SIZE (TREE_TYPE (lhs
))
1336 && (TREE_THIS_VOLATILE (decl
) == TREE_THIS_VOLATILE (lhs
)))
1343 /* When possible, clear TREE_ADDRESSABLE bit or set DECL_GIMPLE_REG_P bit and
1344 mark the variable VAR for conversion into SSA. Return true when updating
1345 stmts is required. */
1348 maybe_optimize_var (tree var
, bitmap addresses_taken
, bitmap not_reg_needs
,
1349 bitmap suitable_for_renaming
)
1351 /* Global Variables, result decls cannot be changed. */
1352 if (is_global_var (var
)
1353 || TREE_CODE (var
) == RESULT_DECL
1354 || bitmap_bit_p (addresses_taken
, DECL_UID (var
)))
1357 if (TREE_ADDRESSABLE (var
)
1358 /* Do not change TREE_ADDRESSABLE if we need to preserve var as
1359 a non-register. Otherwise we are confused and forget to
1360 add virtual operands for it. */
1361 && (!is_gimple_reg_type (TREE_TYPE (var
))
1362 || TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
1363 || TREE_CODE (TREE_TYPE (var
)) == COMPLEX_TYPE
1364 || !bitmap_bit_p (not_reg_needs
, DECL_UID (var
))))
1366 TREE_ADDRESSABLE (var
) = 0;
1367 if (is_gimple_reg (var
))
1368 bitmap_set_bit (suitable_for_renaming
, DECL_UID (var
));
1371 fprintf (dump_file
, "No longer having address taken: ");
1372 print_generic_expr (dump_file
, var
, 0);
1373 fprintf (dump_file
, "\n");
1377 if (!DECL_GIMPLE_REG_P (var
)
1378 && !bitmap_bit_p (not_reg_needs
, DECL_UID (var
))
1379 && (TREE_CODE (TREE_TYPE (var
)) == COMPLEX_TYPE
1380 || TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
)
1381 && !TREE_THIS_VOLATILE (var
)
1382 && (TREE_CODE (var
) != VAR_DECL
|| !DECL_HARD_REGISTER (var
)))
1384 DECL_GIMPLE_REG_P (var
) = 1;
1385 bitmap_set_bit (suitable_for_renaming
, DECL_UID (var
));
1388 fprintf (dump_file
, "Now a gimple register: ");
1389 print_generic_expr (dump_file
, var
, 0);
1390 fprintf (dump_file
, "\n");
1395 /* Compute TREE_ADDRESSABLE and DECL_GIMPLE_REG_P for local variables. */
1398 execute_update_addresses_taken (void)
1400 gimple_stmt_iterator gsi
;
1402 bitmap addresses_taken
= BITMAP_ALLOC (NULL
);
1403 bitmap not_reg_needs
= BITMAP_ALLOC (NULL
);
1404 bitmap suitable_for_renaming
= BITMAP_ALLOC (NULL
);
1408 timevar_push (TV_ADDRESS_TAKEN
);
1410 /* Collect into ADDRESSES_TAKEN all variables whose address is taken within
1411 the function body. */
1412 FOR_EACH_BB_FN (bb
, cfun
)
1414 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1416 gimple stmt
= gsi_stmt (gsi
);
1417 enum gimple_code code
= gimple_code (stmt
);
1420 /* Note all addresses taken by the stmt. */
1421 gimple_ior_addresses_taken (addresses_taken
, stmt
);
1423 /* If we have a call or an assignment, see if the lhs contains
1424 a local decl that requires not to be a gimple register. */
1425 if (code
== GIMPLE_ASSIGN
|| code
== GIMPLE_CALL
)
1427 tree lhs
= gimple_get_lhs (stmt
);
1429 && TREE_CODE (lhs
) != SSA_NAME
1430 && non_rewritable_lvalue_p (lhs
))
1432 decl
= get_base_address (lhs
);
1434 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1438 if (gimple_assign_single_p (stmt
))
1440 tree rhs
= gimple_assign_rhs1 (stmt
);
1441 if ((decl
= non_rewritable_mem_ref_base (rhs
)))
1442 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1445 else if (code
== GIMPLE_CALL
)
1447 for (i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
1449 tree arg
= gimple_call_arg (stmt
, i
);
1450 if ((decl
= non_rewritable_mem_ref_base (arg
)))
1451 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1455 else if (code
== GIMPLE_ASM
)
1457 gimple_asm asm_stmt
= as_a
<gimple_asm
> (stmt
);
1458 for (i
= 0; i
< gimple_asm_noutputs (asm_stmt
); ++i
)
1460 tree link
= gimple_asm_output_op (asm_stmt
, i
);
1461 tree lhs
= TREE_VALUE (link
);
1462 if (TREE_CODE (lhs
) != SSA_NAME
)
1464 decl
= get_base_address (lhs
);
1466 && (non_rewritable_lvalue_p (lhs
)
1467 /* We cannot move required conversions from
1468 the lhs to the rhs in asm statements, so
1469 require we do not need any. */
1470 || !useless_type_conversion_p
1471 (TREE_TYPE (lhs
), TREE_TYPE (decl
))))
1472 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1475 for (i
= 0; i
< gimple_asm_ninputs (asm_stmt
); ++i
)
1477 tree link
= gimple_asm_input_op (asm_stmt
, i
);
1478 if ((decl
= non_rewritable_mem_ref_base (TREE_VALUE (link
))))
1479 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1484 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1487 gimple phi
= gsi_stmt (gsi
);
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 (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 gimple_asm asm_stmt
= as_a
<gimple_asm
> (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
);