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
, bool check_ssa_operands
)
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 (check_ssa_operands
&& 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
);
1144 const pass_data pass_data_init_datastructures
=
1146 GIMPLE_PASS
, /* type */
1147 "*init_datastructures", /* name */
1148 OPTGROUP_NONE
, /* optinfo_flags */
1149 true, /* has_execute */
1150 TV_NONE
, /* tv_id */
1151 PROP_cfg
, /* properties_required */
1152 0, /* properties_provided */
1153 0, /* properties_destroyed */
1154 0, /* todo_flags_start */
1155 0, /* todo_flags_finish */
1158 class pass_init_datastructures
: public gimple_opt_pass
1161 pass_init_datastructures (gcc::context
*ctxt
)
1162 : gimple_opt_pass (pass_data_init_datastructures
, ctxt
)
1165 /* opt_pass methods: */
1166 virtual bool gate (function
*fun
)
1168 /* Do nothing for funcions that was produced already in SSA form. */
1169 return !(fun
->curr_properties
& PROP_ssa
);
1172 virtual unsigned int execute (function
*)
1174 return execute_init_datastructures ();
1177 }; // class pass_init_datastructures
1182 make_pass_init_datastructures (gcc::context
*ctxt
)
1184 return new pass_init_datastructures (ctxt
);
1187 /* Deallocate memory associated with SSA data structures for FNDECL. */
1190 delete_tree_ssa (void)
1194 /* We no longer maintain the SSA operand cache at this point. */
1195 if (ssa_operands_active (cfun
))
1196 fini_ssa_operands (cfun
);
1198 htab_delete (cfun
->gimple_df
->default_defs
);
1199 cfun
->gimple_df
->default_defs
= NULL
;
1200 pt_solution_reset (&cfun
->gimple_df
->escaped
);
1201 if (cfun
->gimple_df
->decls_to_pointers
!= NULL
)
1202 pointer_map_destroy (cfun
->gimple_df
->decls_to_pointers
);
1203 cfun
->gimple_df
->decls_to_pointers
= NULL
;
1204 cfun
->gimple_df
->modified_noreturn_calls
= NULL
;
1205 cfun
->gimple_df
= NULL
;
1207 /* We no longer need the edge variable maps. */
1208 redirect_edge_var_map_destroy ();
1211 /* Return true if EXPR is a useless type conversion, otherwise return
1215 tree_ssa_useless_type_conversion (tree expr
)
1217 /* If we have an assignment that merely uses a NOP_EXPR to change
1218 the top of the RHS to the type of the LHS and the type conversion
1219 is "safe", then strip away the type conversion so that we can
1220 enter LHS = RHS into the const_and_copies table. */
1221 if (CONVERT_EXPR_P (expr
)
1222 || TREE_CODE (expr
) == VIEW_CONVERT_EXPR
1223 || TREE_CODE (expr
) == NON_LVALUE_EXPR
)
1224 return useless_type_conversion_p
1226 TREE_TYPE (TREE_OPERAND (expr
, 0)));
1231 /* Strip conversions from EXP according to
1232 tree_ssa_useless_type_conversion and return the resulting
1236 tree_ssa_strip_useless_type_conversions (tree exp
)
1238 while (tree_ssa_useless_type_conversion (exp
))
1239 exp
= TREE_OPERAND (exp
, 0);
1244 /* Return true if T, an SSA_NAME, has an undefined value. */
1247 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 def_stmt
= SSA_NAME_DEF_STMT (t
);
1267 if (gimple_nop_p (def_stmt
))
1270 /* Check if the complex was not only partially defined. */
1271 if (is_gimple_assign (def_stmt
)
1272 && gimple_assign_rhs_code (def_stmt
) == COMPLEX_EXPR
)
1276 rhs1
= gimple_assign_rhs1 (def_stmt
);
1277 rhs2
= gimple_assign_rhs2 (def_stmt
);
1278 return (TREE_CODE (rhs1
) == SSA_NAME
&& ssa_undefined_value_p (rhs1
))
1279 || (TREE_CODE (rhs2
) == SSA_NAME
&& ssa_undefined_value_p (rhs2
));
1285 /* If necessary, rewrite the base of the reference tree *TP from
1286 a MEM_REF to a plain or converted symbol. */
1289 maybe_rewrite_mem_ref_base (tree
*tp
, bitmap suitable_for_renaming
)
1293 while (handled_component_p (*tp
))
1294 tp
= &TREE_OPERAND (*tp
, 0);
1295 if (TREE_CODE (*tp
) == MEM_REF
1296 && TREE_CODE (TREE_OPERAND (*tp
, 0)) == ADDR_EXPR
1297 && (sym
= TREE_OPERAND (TREE_OPERAND (*tp
, 0), 0))
1299 && !TREE_ADDRESSABLE (sym
)
1300 && bitmap_bit_p (suitable_for_renaming
, DECL_UID (sym
)))
1302 if (TREE_CODE (TREE_TYPE (sym
)) == VECTOR_TYPE
1303 && useless_type_conversion_p (TREE_TYPE (*tp
),
1304 TREE_TYPE (TREE_TYPE (sym
)))
1305 && multiple_of_p (sizetype
, TREE_OPERAND (*tp
, 1),
1306 TYPE_SIZE_UNIT (TREE_TYPE (*tp
))))
1308 *tp
= build3 (BIT_FIELD_REF
, TREE_TYPE (*tp
), sym
,
1309 TYPE_SIZE (TREE_TYPE (*tp
)),
1310 int_const_binop (MULT_EXPR
,
1311 bitsize_int (BITS_PER_UNIT
),
1312 TREE_OPERAND (*tp
, 1)));
1314 else if (TREE_CODE (TREE_TYPE (sym
)) == COMPLEX_TYPE
1315 && useless_type_conversion_p (TREE_TYPE (*tp
),
1316 TREE_TYPE (TREE_TYPE (sym
))))
1318 *tp
= build1 (integer_zerop (TREE_OPERAND (*tp
, 1))
1319 ? REALPART_EXPR
: IMAGPART_EXPR
,
1320 TREE_TYPE (*tp
), sym
);
1322 else if (integer_zerop (TREE_OPERAND (*tp
, 1)))
1324 if (!useless_type_conversion_p (TREE_TYPE (*tp
),
1326 *tp
= build1 (VIEW_CONVERT_EXPR
,
1327 TREE_TYPE (*tp
), sym
);
1334 /* For a tree REF return its base if it is the base of a MEM_REF
1335 that cannot be rewritten into SSA form. Otherwise return NULL_TREE. */
1338 non_rewritable_mem_ref_base (tree ref
)
1342 /* A plain decl does not need it set. */
1346 while (handled_component_p (base
))
1347 base
= TREE_OPERAND (base
, 0);
1349 /* But watch out for MEM_REFs we cannot lower to a
1350 VIEW_CONVERT_EXPR or a BIT_FIELD_REF. */
1351 if (TREE_CODE (base
) == MEM_REF
1352 && TREE_CODE (TREE_OPERAND (base
, 0)) == ADDR_EXPR
)
1354 tree decl
= TREE_OPERAND (TREE_OPERAND (base
, 0), 0);
1355 if ((TREE_CODE (TREE_TYPE (decl
)) == VECTOR_TYPE
1356 || TREE_CODE (TREE_TYPE (decl
)) == COMPLEX_TYPE
)
1357 && useless_type_conversion_p (TREE_TYPE (base
),
1358 TREE_TYPE (TREE_TYPE (decl
)))
1359 && wi::fits_uhwi_p (mem_ref_offset (base
))
1360 && wi::gtu_p (wi::to_offset (TYPE_SIZE_UNIT (TREE_TYPE (decl
))),
1361 mem_ref_offset (base
))
1362 && multiple_of_p (sizetype
, TREE_OPERAND (base
, 1),
1363 TYPE_SIZE_UNIT (TREE_TYPE (base
))))
1366 && (!integer_zerop (TREE_OPERAND (base
, 1))
1367 || (DECL_SIZE (decl
)
1368 != TYPE_SIZE (TREE_TYPE (base
)))
1369 || TREE_THIS_VOLATILE (decl
) != TREE_THIS_VOLATILE (base
)))
1376 /* For an lvalue tree LHS return true if it cannot be rewritten into SSA form.
1377 Otherwise return true. */
1380 non_rewritable_lvalue_p (tree lhs
)
1382 /* A plain decl is always rewritable. */
1386 /* A decl that is wrapped inside a MEM-REF that covers
1387 it full is also rewritable.
1388 ??? The following could be relaxed allowing component
1389 references that do not change the access size. */
1390 if (TREE_CODE (lhs
) == MEM_REF
1391 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == ADDR_EXPR
1392 && integer_zerop (TREE_OPERAND (lhs
, 1)))
1394 tree decl
= TREE_OPERAND (TREE_OPERAND (lhs
, 0), 0);
1396 && DECL_SIZE (decl
) == TYPE_SIZE (TREE_TYPE (lhs
))
1397 && (TREE_THIS_VOLATILE (decl
) == TREE_THIS_VOLATILE (lhs
)))
1404 /* When possible, clear TREE_ADDRESSABLE bit or set DECL_GIMPLE_REG_P bit and
1405 mark the variable VAR for conversion into SSA. Return true when updating
1406 stmts is required. */
1409 maybe_optimize_var (tree var
, bitmap addresses_taken
, bitmap not_reg_needs
,
1410 bitmap suitable_for_renaming
)
1412 /* Global Variables, result decls cannot be changed. */
1413 if (is_global_var (var
)
1414 || TREE_CODE (var
) == RESULT_DECL
1415 || bitmap_bit_p (addresses_taken
, DECL_UID (var
)))
1418 if (TREE_ADDRESSABLE (var
)
1419 /* Do not change TREE_ADDRESSABLE if we need to preserve var as
1420 a non-register. Otherwise we are confused and forget to
1421 add virtual operands for it. */
1422 && (!is_gimple_reg_type (TREE_TYPE (var
))
1423 || TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
1424 || TREE_CODE (TREE_TYPE (var
)) == COMPLEX_TYPE
1425 || !bitmap_bit_p (not_reg_needs
, DECL_UID (var
))))
1427 TREE_ADDRESSABLE (var
) = 0;
1428 if (is_gimple_reg (var
))
1429 bitmap_set_bit (suitable_for_renaming
, DECL_UID (var
));
1432 fprintf (dump_file
, "No longer having address taken: ");
1433 print_generic_expr (dump_file
, var
, 0);
1434 fprintf (dump_file
, "\n");
1438 if (!DECL_GIMPLE_REG_P (var
)
1439 && !bitmap_bit_p (not_reg_needs
, DECL_UID (var
))
1440 && (TREE_CODE (TREE_TYPE (var
)) == COMPLEX_TYPE
1441 || TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
)
1442 && !TREE_THIS_VOLATILE (var
)
1443 && (TREE_CODE (var
) != VAR_DECL
|| !DECL_HARD_REGISTER (var
)))
1445 DECL_GIMPLE_REG_P (var
) = 1;
1446 bitmap_set_bit (suitable_for_renaming
, DECL_UID (var
));
1449 fprintf (dump_file
, "Now a gimple register: ");
1450 print_generic_expr (dump_file
, var
, 0);
1451 fprintf (dump_file
, "\n");
1456 /* Compute TREE_ADDRESSABLE and DECL_GIMPLE_REG_P for local variables. */
1459 execute_update_addresses_taken (void)
1461 gimple_stmt_iterator gsi
;
1463 bitmap addresses_taken
= BITMAP_ALLOC (NULL
);
1464 bitmap not_reg_needs
= BITMAP_ALLOC (NULL
);
1465 bitmap suitable_for_renaming
= BITMAP_ALLOC (NULL
);
1469 timevar_push (TV_ADDRESS_TAKEN
);
1471 /* Collect into ADDRESSES_TAKEN all variables whose address is taken within
1472 the function body. */
1473 FOR_EACH_BB_FN (bb
, cfun
)
1475 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1477 gimple stmt
= gsi_stmt (gsi
);
1478 enum gimple_code code
= gimple_code (stmt
);
1481 /* Note all addresses taken by the stmt. */
1482 gimple_ior_addresses_taken (addresses_taken
, stmt
);
1484 /* If we have a call or an assignment, see if the lhs contains
1485 a local decl that requires not to be a gimple register. */
1486 if (code
== GIMPLE_ASSIGN
|| code
== GIMPLE_CALL
)
1488 tree lhs
= gimple_get_lhs (stmt
);
1490 && TREE_CODE (lhs
) != SSA_NAME
1491 && non_rewritable_lvalue_p (lhs
))
1493 decl
= get_base_address (lhs
);
1495 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1499 if (gimple_assign_single_p (stmt
))
1501 tree rhs
= gimple_assign_rhs1 (stmt
);
1502 if ((decl
= non_rewritable_mem_ref_base (rhs
)))
1503 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1506 else if (code
== GIMPLE_CALL
)
1508 for (i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
1510 tree arg
= gimple_call_arg (stmt
, i
);
1511 if ((decl
= non_rewritable_mem_ref_base (arg
)))
1512 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1516 else if (code
== GIMPLE_ASM
)
1518 for (i
= 0; i
< gimple_asm_noutputs (stmt
); ++i
)
1520 tree link
= gimple_asm_output_op (stmt
, i
);
1521 tree lhs
= TREE_VALUE (link
);
1522 if (TREE_CODE (lhs
) != SSA_NAME
)
1524 decl
= get_base_address (lhs
);
1526 && (non_rewritable_lvalue_p (lhs
)
1527 /* We cannot move required conversions from
1528 the lhs to the rhs in asm statements, so
1529 require we do not need any. */
1530 || !useless_type_conversion_p
1531 (TREE_TYPE (lhs
), TREE_TYPE (decl
))))
1532 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1535 for (i
= 0; i
< gimple_asm_ninputs (stmt
); ++i
)
1537 tree link
= gimple_asm_input_op (stmt
, i
);
1538 if ((decl
= non_rewritable_mem_ref_base (TREE_VALUE (link
))))
1539 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1544 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1547 gimple phi
= gsi_stmt (gsi
);
1549 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
1551 tree op
= PHI_ARG_DEF (phi
, i
), var
;
1552 if (TREE_CODE (op
) == ADDR_EXPR
1553 && (var
= get_base_address (TREE_OPERAND (op
, 0))) != NULL
1555 bitmap_set_bit (addresses_taken
, DECL_UID (var
));
1560 /* We cannot iterate over all referenced vars because that can contain
1561 unused vars from BLOCK trees, which causes code generation differences
1563 for (var
= DECL_ARGUMENTS (cfun
->decl
); var
; var
= DECL_CHAIN (var
))
1564 maybe_optimize_var (var
, addresses_taken
, not_reg_needs
,
1565 suitable_for_renaming
);
1567 FOR_EACH_VEC_SAFE_ELT (cfun
->local_decls
, i
, var
)
1568 maybe_optimize_var (var
, addresses_taken
, not_reg_needs
,
1569 suitable_for_renaming
);
1571 /* Operand caches need to be recomputed for operands referencing the updated
1572 variables and operands need to be rewritten to expose bare symbols. */
1573 if (!bitmap_empty_p (suitable_for_renaming
))
1575 FOR_EACH_BB_FN (bb
, cfun
)
1576 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
);)
1578 gimple stmt
= gsi_stmt (gsi
);
1580 /* Re-write TARGET_MEM_REFs of symbols we want to
1581 rewrite into SSA form. */
1582 if (gimple_assign_single_p (stmt
))
1584 tree lhs
= gimple_assign_lhs (stmt
);
1585 tree rhs
, *rhsp
= gimple_assign_rhs1_ptr (stmt
);
1588 /* We shouldn't have any fancy wrapping of
1589 component-refs on the LHS, but look through
1590 VIEW_CONVERT_EXPRs as that is easy. */
1591 while (TREE_CODE (lhs
) == VIEW_CONVERT_EXPR
)
1592 lhs
= TREE_OPERAND (lhs
, 0);
1593 if (TREE_CODE (lhs
) == MEM_REF
1594 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == ADDR_EXPR
1595 && integer_zerop (TREE_OPERAND (lhs
, 1))
1596 && (sym
= TREE_OPERAND (TREE_OPERAND (lhs
, 0), 0))
1598 && !TREE_ADDRESSABLE (sym
)
1599 && bitmap_bit_p (suitable_for_renaming
, DECL_UID (sym
)))
1602 lhs
= gimple_assign_lhs (stmt
);
1604 /* Rewrite the RHS and make sure the resulting assignment
1605 is validly typed. */
1606 maybe_rewrite_mem_ref_base (rhsp
, suitable_for_renaming
);
1607 rhs
= gimple_assign_rhs1 (stmt
);
1608 if (gimple_assign_lhs (stmt
) != lhs
1609 && !useless_type_conversion_p (TREE_TYPE (lhs
),
1611 rhs
= fold_build1 (VIEW_CONVERT_EXPR
,
1612 TREE_TYPE (lhs
), rhs
);
1614 if (gimple_assign_lhs (stmt
) != lhs
)
1615 gimple_assign_set_lhs (stmt
, lhs
);
1617 /* For var ={v} {CLOBBER}; where var lost
1618 TREE_ADDRESSABLE just remove the stmt. */
1620 && TREE_CLOBBER_P (rhs
)
1621 && bitmap_bit_p (suitable_for_renaming
, DECL_UID (lhs
)))
1623 unlink_stmt_vdef (stmt
);
1624 gsi_remove (&gsi
, true);
1625 release_defs (stmt
);
1629 if (gimple_assign_rhs1 (stmt
) != rhs
)
1631 gimple_stmt_iterator gsi
= gsi_for_stmt (stmt
);
1632 gimple_assign_set_rhs_from_tree (&gsi
, rhs
);
1636 else if (gimple_code (stmt
) == GIMPLE_CALL
)
1639 for (i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
1641 tree
*argp
= gimple_call_arg_ptr (stmt
, i
);
1642 maybe_rewrite_mem_ref_base (argp
, suitable_for_renaming
);
1646 else if (gimple_code (stmt
) == GIMPLE_ASM
)
1649 for (i
= 0; i
< gimple_asm_noutputs (stmt
); ++i
)
1651 tree link
= gimple_asm_output_op (stmt
, i
);
1652 maybe_rewrite_mem_ref_base (&TREE_VALUE (link
),
1653 suitable_for_renaming
);
1655 for (i
= 0; i
< gimple_asm_ninputs (stmt
); ++i
)
1657 tree link
= gimple_asm_input_op (stmt
, i
);
1658 maybe_rewrite_mem_ref_base (&TREE_VALUE (link
),
1659 suitable_for_renaming
);
1663 else if (gimple_debug_bind_p (stmt
)
1664 && gimple_debug_bind_has_value_p (stmt
))
1666 tree
*valuep
= gimple_debug_bind_get_value_ptr (stmt
);
1668 maybe_rewrite_mem_ref_base (valuep
, suitable_for_renaming
);
1669 decl
= non_rewritable_mem_ref_base (*valuep
);
1671 && bitmap_bit_p (suitable_for_renaming
, DECL_UID (decl
)))
1672 gimple_debug_bind_reset_value (stmt
);
1675 if (gimple_references_memory_p (stmt
)
1676 || is_gimple_debug (stmt
))
1682 /* Update SSA form here, we are called as non-pass as well. */
1683 if (number_of_loops (cfun
) > 1
1684 && loops_state_satisfies_p (LOOP_CLOSED_SSA
))
1685 rewrite_into_loop_closed_ssa (NULL
, TODO_update_ssa
);
1687 update_ssa (TODO_update_ssa
);
1690 BITMAP_FREE (not_reg_needs
);
1691 BITMAP_FREE (addresses_taken
);
1692 BITMAP_FREE (suitable_for_renaming
);
1693 timevar_pop (TV_ADDRESS_TAKEN
);
1698 const pass_data pass_data_update_address_taken
=
1700 GIMPLE_PASS
, /* type */
1701 "addressables", /* name */
1702 OPTGROUP_NONE
, /* optinfo_flags */
1703 false, /* has_execute */
1704 TV_ADDRESS_TAKEN
, /* tv_id */
1705 PROP_ssa
, /* properties_required */
1706 0, /* properties_provided */
1707 0, /* properties_destroyed */
1708 0, /* todo_flags_start */
1709 TODO_update_address_taken
, /* todo_flags_finish */
1712 class pass_update_address_taken
: public gimple_opt_pass
1715 pass_update_address_taken (gcc::context
*ctxt
)
1716 : gimple_opt_pass (pass_data_update_address_taken
, ctxt
)
1719 /* opt_pass methods: */
1721 }; // class pass_update_address_taken
1726 make_pass_update_address_taken (gcc::context
*ctxt
)
1728 return new pass_update_address_taken (ctxt
);