1 /* Miscellaneous SSA utility functions.
2 Copyright (C) 2001-2016 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"
27 #include "tree-pass.h"
29 #include "gimple-pretty-print.h"
30 #include "diagnostic-core.h"
31 #include "fold-const.h"
32 #include "stor-layout.h"
33 #include "gimple-fold.h"
35 #include "gimple-iterator.h"
36 #include "gimple-walk.h"
37 #include "tree-ssa-loop-manip.h"
38 #include "tree-into-ssa.h"
41 #include "cfgexpand.h"
45 /* Pointer map of variable mappings, keyed by edge. */
46 static hash_map
<edge
, auto_vec
<edge_var_map
> > *edge_var_maps
;
49 /* Add a mapping with PHI RESULT and PHI DEF associated with edge E. */
52 redirect_edge_var_map_add (edge e
, tree result
, tree def
, source_location locus
)
54 edge_var_map new_node
;
56 if (edge_var_maps
== NULL
)
57 edge_var_maps
= new hash_map
<edge
, auto_vec
<edge_var_map
> >;
59 auto_vec
<edge_var_map
> &slot
= edge_var_maps
->get_or_insert (e
);
61 new_node
.result
= result
;
62 new_node
.locus
= locus
;
64 slot
.safe_push (new_node
);
68 /* Clear the var mappings in edge E. */
71 redirect_edge_var_map_clear (edge e
)
76 auto_vec
<edge_var_map
> *head
= edge_var_maps
->get (e
);
83 /* Duplicate the redirected var mappings in OLDE in NEWE.
85 This assumes a hash_map can have multiple edges mapping to the same
86 var_map (many to one mapping), since we don't remove the previous mappings.
90 redirect_edge_var_map_dup (edge newe
, edge olde
)
95 auto_vec
<edge_var_map
> *new_head
= &edge_var_maps
->get_or_insert (newe
);
96 auto_vec
<edge_var_map
> *old_head
= edge_var_maps
->get (olde
);
100 new_head
->safe_splice (*old_head
);
104 /* Return the variable mappings for a given edge. If there is none, return
108 redirect_edge_var_map_vector (edge e
)
110 /* Hey, what kind of idiot would... you'd be surprised. */
114 auto_vec
<edge_var_map
> *slot
= edge_var_maps
->get (e
);
121 /* Clear the edge variable mappings. */
124 redirect_edge_var_map_empty (void)
127 edge_var_maps
->empty ();
131 /* Remove the corresponding arguments from the PHI nodes in E's
132 destination block and redirect it to DEST. Return redirected edge.
133 The list of removed arguments is stored in a vector accessed
134 through edge_var_maps. */
137 ssa_redirect_edge (edge e
, basic_block dest
)
142 redirect_edge_var_map_clear (e
);
144 /* Remove the appropriate PHI arguments in E's destination block. */
145 for (gsi
= gsi_start_phis (e
->dest
); !gsi_end_p (gsi
); gsi_next (&gsi
))
148 source_location locus
;
151 def
= gimple_phi_arg_def (phi
, e
->dest_idx
);
152 locus
= gimple_phi_arg_location (phi
, e
->dest_idx
);
154 if (def
== NULL_TREE
)
157 redirect_edge_var_map_add (e
, gimple_phi_result (phi
), def
, locus
);
160 e
= redirect_edge_succ_nodup (e
, dest
);
166 /* Add PHI arguments queued in PENDING_STMT list on edge E to edge
170 flush_pending_stmts (edge e
)
177 vec
<edge_var_map
> *v
= redirect_edge_var_map_vector (e
);
181 for (gsi
= gsi_start_phis (e
->dest
), i
= 0;
182 !gsi_end_p (gsi
) && v
->iterate (i
, &vm
);
183 gsi_next (&gsi
), i
++)
188 def
= redirect_edge_var_map_def (vm
);
189 add_phi_arg (phi
, def
, e
, redirect_edge_var_map_location (vm
));
192 redirect_edge_var_map_clear (e
);
195 /* Replace the LHS of STMT, an assignment, either a GIMPLE_ASSIGN or a
196 GIMPLE_CALL, with NLHS, in preparation for modifying the RHS to an
197 expression with a different value.
199 This will update any annotations (say debug bind stmts) referring
200 to the original LHS, so that they use the RHS instead. This is
201 done even if NLHS and LHS are the same, for it is understood that
202 the RHS will be modified afterwards, and NLHS will not be assigned
205 Adjusting any non-annotation uses of the LHS, if needed, is a
206 responsibility of the caller.
208 The effect of this call should be pretty much the same as that of
209 inserting a copy of STMT before STMT, and then removing the
210 original stmt, at which time gsi_remove() would have update
211 annotations, but using this function saves all the inserting,
212 copying and removing. */
215 gimple_replace_ssa_lhs (gimple
*stmt
, tree nlhs
)
217 if (MAY_HAVE_DEBUG_STMTS
)
219 tree lhs
= gimple_get_lhs (stmt
);
221 gcc_assert (SSA_NAME_DEF_STMT (lhs
) == stmt
);
223 insert_debug_temp_for_var_def (NULL
, lhs
);
226 gimple_set_lhs (stmt
, nlhs
);
230 /* Given a tree for an expression for which we might want to emit
231 locations or values in debug information (generally a variable, but
232 we might deal with other kinds of trees in the future), return the
233 tree that should be used as the variable of a DEBUG_BIND STMT or
234 VAR_LOCATION INSN or NOTE. Return NULL if VAR is not to be tracked. */
237 target_for_debug_bind (tree var
)
239 if (!MAY_HAVE_DEBUG_STMTS
)
242 if (TREE_CODE (var
) == SSA_NAME
)
244 var
= SSA_NAME_VAR (var
);
245 if (var
== NULL_TREE
)
249 if ((TREE_CODE (var
) != VAR_DECL
250 || VAR_DECL_IS_VIRTUAL_OPERAND (var
))
251 && TREE_CODE (var
) != PARM_DECL
)
254 if (DECL_HAS_VALUE_EXPR_P (var
))
255 return target_for_debug_bind (DECL_VALUE_EXPR (var
));
257 if (DECL_IGNORED_P (var
))
260 /* var-tracking only tracks registers. */
261 if (!is_gimple_reg_type (TREE_TYPE (var
)))
267 /* Called via walk_tree, look for SSA_NAMEs that have already been
271 find_released_ssa_name (tree
*tp
, int *walk_subtrees
, void *data_
)
273 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data_
;
275 if (wi
&& wi
->is_lhs
)
278 if (TREE_CODE (*tp
) == SSA_NAME
)
280 if (SSA_NAME_IN_FREE_LIST (*tp
))
285 else if (IS_TYPE_OR_DECL_P (*tp
))
291 /* Insert a DEBUG BIND stmt before the DEF of VAR if VAR is referenced
292 by other DEBUG stmts, and replace uses of the DEF with the
293 newly-created debug temp. */
296 insert_debug_temp_for_var_def (gimple_stmt_iterator
*gsi
, tree var
)
298 imm_use_iterator imm_iter
;
301 gimple
*def_stmt
= NULL
;
305 if (!MAY_HAVE_DEBUG_STMTS
)
308 /* If this name has already been registered for replacement, do nothing
309 as anything that uses this name isn't in SSA form. */
310 if (name_registered_for_update_p (var
))
313 /* Check whether there are debug stmts that reference this variable and,
314 if there are, decide whether we should use a debug temp. */
315 FOR_EACH_IMM_USE_FAST (use_p
, imm_iter
, var
)
317 stmt
= USE_STMT (use_p
);
319 if (!gimple_debug_bind_p (stmt
))
325 if (gimple_debug_bind_get_value (stmt
) != var
)
327 /* Count this as an additional use, so as to make sure we
328 use a temp unless VAR's definition has a SINGLE_RHS that
339 def_stmt
= gsi_stmt (*gsi
);
341 def_stmt
= SSA_NAME_DEF_STMT (var
);
343 /* If we didn't get an insertion point, and the stmt has already
344 been removed, we won't be able to insert the debug bind stmt, so
345 we'll have to drop debug information. */
346 if (gimple_code (def_stmt
) == GIMPLE_PHI
)
348 value
= degenerate_phi_result (as_a
<gphi
*> (def_stmt
));
349 if (value
&& walk_tree (&value
, find_released_ssa_name
, NULL
, NULL
))
351 /* error_mark_node is what fixup_noreturn_call changes PHI arguments
353 else if (value
== error_mark_node
)
356 else if (is_gimple_assign (def_stmt
))
358 bool no_value
= false;
360 if (!dom_info_available_p (CDI_DOMINATORS
))
362 struct walk_stmt_info wi
;
364 memset (&wi
, 0, sizeof (wi
));
366 /* When removing blocks without following reverse dominance
367 order, we may sometimes encounter SSA_NAMEs that have
368 already been released, referenced in other SSA_DEFs that
369 we're about to release. Consider:
378 If we deleted BB X first, propagating the value of w_2
379 won't do us any good. It's too late to recover their
380 original definition of v_1: when it was deleted, it was
381 only referenced in other DEFs, it couldn't possibly know
382 it should have been retained, and propagating every
383 single DEF just in case it might have to be propagated
384 into a DEBUG STMT would probably be too wasteful.
386 When dominator information is not readily available, we
387 check for and accept some loss of debug information. But
388 if it is available, there's no excuse for us to remove
389 blocks in the wrong order, so we don't even check for
390 dead SSA NAMEs. SSA verification shall catch any
392 if ((!gsi
&& !gimple_bb (def_stmt
))
393 || walk_gimple_op (def_stmt
, find_released_ssa_name
, &wi
))
398 value
= gimple_assign_rhs_to_tree (def_stmt
);
403 /* If there's a single use of VAR, and VAR is the entire debug
404 expression (usecount would have been incremented again
405 otherwise), and the definition involves only constants and
406 SSA names, then we can propagate VALUE into this single use,
409 We can also avoid using a temp if VALUE can be shared and
410 propagated into all uses, without generating expressions that
411 wouldn't be valid gimple RHSs.
413 Other cases that would require unsharing or non-gimple RHSs
414 are deferred to a debug temp, although we could avoid temps
415 at the expense of duplication of expressions. */
417 if (CONSTANT_CLASS_P (value
)
418 || gimple_code (def_stmt
) == GIMPLE_PHI
420 && (!gimple_assign_single_p (def_stmt
)
421 || is_gimple_min_invariant (value
)))
422 || is_gimple_reg (value
))
427 tree vexpr
= make_node (DEBUG_EXPR_DECL
);
429 def_temp
= gimple_build_debug_bind (vexpr
,
430 unshare_expr (value
),
433 DECL_ARTIFICIAL (vexpr
) = 1;
434 TREE_TYPE (vexpr
) = TREE_TYPE (value
);
436 DECL_MODE (vexpr
) = DECL_MODE (value
);
438 DECL_MODE (vexpr
) = TYPE_MODE (TREE_TYPE (value
));
441 gsi_insert_before (gsi
, def_temp
, GSI_SAME_STMT
);
444 gimple_stmt_iterator ngsi
= gsi_for_stmt (def_stmt
);
445 gsi_insert_before (&ngsi
, def_temp
, GSI_SAME_STMT
);
452 FOR_EACH_IMM_USE_STMT (stmt
, imm_iter
, var
)
454 if (!gimple_debug_bind_p (stmt
))
459 FOR_EACH_IMM_USE_ON_STMT (use_p
, imm_iter
)
460 /* unshare_expr is not needed here. vexpr is either a
461 SINGLE_RHS, that can be safely shared, some other RHS
462 that was unshared when we found it had a single debug
463 use, or a DEBUG_EXPR_DECL, that can be safely
465 SET_USE (use_p
, unshare_expr (value
));
466 /* If we didn't replace uses with a debug decl fold the
467 resulting expression. Otherwise we end up with invalid IL. */
468 if (TREE_CODE (value
) != DEBUG_EXPR_DECL
)
470 gimple_stmt_iterator gsi
= gsi_for_stmt (stmt
);
471 fold_stmt_inplace (&gsi
);
475 gimple_debug_bind_reset_value (stmt
);
482 /* Insert a DEBUG BIND stmt before STMT for each DEF referenced by
483 other DEBUG stmts, and replace uses of the DEF with the
484 newly-created debug temp. */
487 insert_debug_temps_for_defs (gimple_stmt_iterator
*gsi
)
493 if (!MAY_HAVE_DEBUG_STMTS
)
496 stmt
= gsi_stmt (*gsi
);
498 FOR_EACH_PHI_OR_STMT_DEF (def_p
, stmt
, op_iter
, SSA_OP_DEF
)
500 tree var
= DEF_FROM_PTR (def_p
);
502 if (TREE_CODE (var
) != SSA_NAME
)
505 insert_debug_temp_for_var_def (gsi
, var
);
509 /* Reset all debug stmts that use SSA_NAME(s) defined in STMT. */
512 reset_debug_uses (gimple
*stmt
)
516 imm_use_iterator imm_iter
;
519 if (!MAY_HAVE_DEBUG_STMTS
)
522 FOR_EACH_PHI_OR_STMT_DEF (def_p
, stmt
, op_iter
, SSA_OP_DEF
)
524 tree var
= DEF_FROM_PTR (def_p
);
526 if (TREE_CODE (var
) != SSA_NAME
)
529 FOR_EACH_IMM_USE_STMT (use_stmt
, imm_iter
, var
)
531 if (!gimple_debug_bind_p (use_stmt
))
534 gimple_debug_bind_reset_value (use_stmt
);
535 update_stmt (use_stmt
);
540 /* Delete SSA DEFs for SSA versions in the TOREMOVE bitmap, removing
541 dominated stmts before their dominators, so that release_ssa_defs
542 stands a chance of propagating DEFs into debug bind stmts. */
545 release_defs_bitset (bitmap toremove
)
550 /* Performing a topological sort is probably overkill, this will
551 most likely run in slightly superlinear time, rather than the
552 pathological quadratic worst case. */
553 while (!bitmap_empty_p (toremove
))
554 EXECUTE_IF_SET_IN_BITMAP (toremove
, 0, j
, bi
)
556 bool remove_now
= true;
557 tree var
= ssa_name (j
);
559 imm_use_iterator uit
;
561 FOR_EACH_IMM_USE_STMT (stmt
, uit
, var
)
566 /* We can't propagate PHI nodes into debug stmts. */
567 if (gimple_code (stmt
) == GIMPLE_PHI
568 || is_gimple_debug (stmt
))
571 /* If we find another definition to remove that uses
572 the one we're looking at, defer the removal of this
573 one, so that it can be propagated into debug stmts
574 after the other is. */
575 FOR_EACH_SSA_DEF_OPERAND (def_p
, stmt
, dit
, SSA_OP_DEF
)
577 tree odef
= DEF_FROM_PTR (def_p
);
579 if (bitmap_bit_p (toremove
, SSA_NAME_VERSION (odef
)))
587 BREAK_FROM_IMM_USE_STMT (uit
);
592 gimple
*def
= SSA_NAME_DEF_STMT (var
);
593 gimple_stmt_iterator gsi
= gsi_for_stmt (def
);
595 if (gimple_code (def
) == GIMPLE_PHI
)
596 remove_phi_node (&gsi
, true);
599 gsi_remove (&gsi
, true);
603 bitmap_clear_bit (toremove
, j
);
608 /* Verify virtual SSA form. */
611 verify_vssa (basic_block bb
, tree current_vdef
, sbitmap visited
)
615 if (bitmap_bit_p (visited
, bb
->index
))
618 bitmap_set_bit (visited
, bb
->index
);
620 /* Pick up the single virtual PHI def. */
622 for (gphi_iterator si
= gsi_start_phis (bb
); !gsi_end_p (si
);
625 tree res
= gimple_phi_result (si
.phi ());
626 if (virtual_operand_p (res
))
630 error ("multiple virtual PHI nodes in BB %d", bb
->index
);
631 print_gimple_stmt (stderr
, phi
, 0, 0);
632 print_gimple_stmt (stderr
, si
.phi (), 0, 0);
641 current_vdef
= gimple_phi_result (phi
);
642 if (TREE_CODE (current_vdef
) != SSA_NAME
)
644 error ("virtual definition is not an SSA name");
645 print_gimple_stmt (stderr
, phi
, 0, 0);
651 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
);
654 gimple
*stmt
= gsi_stmt (gsi
);
655 tree vuse
= gimple_vuse (stmt
);
658 if (vuse
!= current_vdef
)
660 error ("stmt with wrong VUSE");
661 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
);
662 fprintf (stderr
, "expected ");
663 print_generic_expr (stderr
, current_vdef
, 0);
664 fprintf (stderr
, "\n");
667 tree vdef
= gimple_vdef (stmt
);
671 if (TREE_CODE (current_vdef
) != SSA_NAME
)
673 error ("virtual definition is not an SSA name");
674 print_gimple_stmt (stderr
, phi
, 0, 0);
681 /* Verify destination PHI uses and recurse. */
684 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
686 gphi
*phi
= get_virtual_phi (e
->dest
);
688 && PHI_ARG_DEF_FROM_EDGE (phi
, e
) != current_vdef
)
690 error ("PHI node with wrong VUSE on edge from BB %d",
692 print_gimple_stmt (stderr
, phi
, 0, TDF_VOPS
);
693 fprintf (stderr
, "expected ");
694 print_generic_expr (stderr
, current_vdef
, 0);
695 fprintf (stderr
, "\n");
700 err
|= verify_vssa (e
->dest
, current_vdef
, visited
);
706 /* Return true if SSA_NAME is malformed and mark it visited.
708 IS_VIRTUAL is true if this SSA_NAME was found inside a virtual
712 verify_ssa_name (tree ssa_name
, bool is_virtual
)
714 if (TREE_CODE (ssa_name
) != SSA_NAME
)
716 error ("expected an SSA_NAME object");
720 if (SSA_NAME_IN_FREE_LIST (ssa_name
))
722 error ("found an SSA_NAME that had been released into the free pool");
726 if (SSA_NAME_VAR (ssa_name
) != NULL_TREE
727 && TREE_TYPE (ssa_name
) != TREE_TYPE (SSA_NAME_VAR (ssa_name
)))
729 error ("type mismatch between an SSA_NAME and its symbol");
733 if (is_virtual
&& !virtual_operand_p (ssa_name
))
735 error ("found a virtual definition for a GIMPLE register");
739 if (is_virtual
&& SSA_NAME_VAR (ssa_name
) != gimple_vop (cfun
))
741 error ("virtual SSA name for non-VOP decl");
745 if (!is_virtual
&& virtual_operand_p (ssa_name
))
747 error ("found a real definition for a non-register");
751 if (SSA_NAME_IS_DEFAULT_DEF (ssa_name
)
752 && !gimple_nop_p (SSA_NAME_DEF_STMT (ssa_name
)))
754 error ("found a default name with a non-empty defining statement");
762 /* Return true if the definition of SSA_NAME at block BB is malformed.
764 STMT is the statement where SSA_NAME is created.
766 DEFINITION_BLOCK is an array of basic blocks indexed by SSA_NAME
767 version numbers. If DEFINITION_BLOCK[SSA_NAME_VERSION] is set,
768 it means that the block in that array slot contains the
769 definition of SSA_NAME.
771 IS_VIRTUAL is true if SSA_NAME is created by a VDEF. */
774 verify_def (basic_block bb
, basic_block
*definition_block
, tree ssa_name
,
775 gimple
*stmt
, bool is_virtual
)
777 if (verify_ssa_name (ssa_name
, is_virtual
))
780 if (SSA_NAME_VAR (ssa_name
)
781 && TREE_CODE (SSA_NAME_VAR (ssa_name
)) == RESULT_DECL
782 && DECL_BY_REFERENCE (SSA_NAME_VAR (ssa_name
)))
784 error ("RESULT_DECL should be read only when DECL_BY_REFERENCE is set");
788 if (definition_block
[SSA_NAME_VERSION (ssa_name
)])
790 error ("SSA_NAME created in two different blocks %i and %i",
791 definition_block
[SSA_NAME_VERSION (ssa_name
)]->index
, bb
->index
);
795 definition_block
[SSA_NAME_VERSION (ssa_name
)] = bb
;
797 if (SSA_NAME_DEF_STMT (ssa_name
) != stmt
)
799 error ("SSA_NAME_DEF_STMT is wrong");
800 fprintf (stderr
, "Expected definition statement:\n");
801 print_gimple_stmt (stderr
, SSA_NAME_DEF_STMT (ssa_name
), 4, TDF_VOPS
);
802 fprintf (stderr
, "\nActual definition statement:\n");
803 print_gimple_stmt (stderr
, stmt
, 4, TDF_VOPS
);
810 fprintf (stderr
, "while verifying SSA_NAME ");
811 print_generic_expr (stderr
, ssa_name
, 0);
812 fprintf (stderr
, " in statement\n");
813 print_gimple_stmt (stderr
, stmt
, 4, TDF_VOPS
);
819 /* Return true if the use of SSA_NAME at statement STMT in block BB is
822 DEF_BB is the block where SSA_NAME was found to be created.
824 IDOM contains immediate dominator information for the flowgraph.
826 CHECK_ABNORMAL is true if the caller wants to check whether this use
827 is flowing through an abnormal edge (only used when checking PHI
830 If NAMES_DEFINED_IN_BB is not NULL, it contains a bitmap of ssa names
831 that are defined before STMT in basic block BB. */
834 verify_use (basic_block bb
, basic_block def_bb
, use_operand_p use_p
,
835 gimple
*stmt
, bool check_abnormal
, bitmap names_defined_in_bb
)
838 tree ssa_name
= USE_FROM_PTR (use_p
);
840 if (!TREE_VISITED (ssa_name
))
841 if (verify_imm_links (stderr
, ssa_name
))
844 TREE_VISITED (ssa_name
) = 1;
846 if (gimple_nop_p (SSA_NAME_DEF_STMT (ssa_name
))
847 && SSA_NAME_IS_DEFAULT_DEF (ssa_name
))
848 ; /* Default definitions have empty statements. Nothing to do. */
851 error ("missing definition");
854 else if (bb
!= def_bb
855 && !dominated_by_p (CDI_DOMINATORS
, bb
, def_bb
))
857 error ("definition in block %i does not dominate use in block %i",
858 def_bb
->index
, bb
->index
);
861 else if (bb
== def_bb
862 && names_defined_in_bb
!= NULL
863 && !bitmap_bit_p (names_defined_in_bb
, SSA_NAME_VERSION (ssa_name
)))
865 error ("definition in block %i follows the use", def_bb
->index
);
870 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ssa_name
))
872 error ("SSA_NAME_OCCURS_IN_ABNORMAL_PHI should be set");
876 /* Make sure the use is in an appropriate list by checking the previous
877 element to make sure it's the same. */
878 if (use_p
->prev
== NULL
)
880 error ("no immediate_use list");
886 if (use_p
->prev
->use
== NULL
)
887 listvar
= use_p
->prev
->loc
.ssa_name
;
889 listvar
= USE_FROM_PTR (use_p
->prev
);
890 if (listvar
!= ssa_name
)
892 error ("wrong immediate use list");
899 fprintf (stderr
, "for SSA_NAME: ");
900 print_generic_expr (stderr
, ssa_name
, TDF_VOPS
);
901 fprintf (stderr
, " in statement:\n");
902 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
);
909 /* Return true if any of the arguments for PHI node PHI at block BB is
912 DEFINITION_BLOCK is an array of basic blocks indexed by SSA_NAME
913 version numbers. If DEFINITION_BLOCK[SSA_NAME_VERSION] is set,
914 it means that the block in that array slot contains the
915 definition of SSA_NAME. */
918 verify_phi_args (gphi
*phi
, basic_block bb
, basic_block
*definition_block
)
922 size_t i
, phi_num_args
= gimple_phi_num_args (phi
);
924 if (EDGE_COUNT (bb
->preds
) != phi_num_args
)
926 error ("incoming edge count does not match number of PHI arguments");
931 for (i
= 0; i
< phi_num_args
; i
++)
933 use_operand_p op_p
= gimple_phi_arg_imm_use_ptr (phi
, i
);
934 tree op
= USE_FROM_PTR (op_p
);
936 e
= EDGE_PRED (bb
, i
);
940 error ("PHI argument is missing for edge %d->%d",
947 if (TREE_CODE (op
) != SSA_NAME
&& !is_gimple_min_invariant (op
))
949 error ("PHI argument is not SSA_NAME, or invariant");
953 if (TREE_CODE (op
) == SSA_NAME
)
955 err
= verify_ssa_name (op
, virtual_operand_p (gimple_phi_result (phi
)));
956 err
|= verify_use (e
->src
, definition_block
[SSA_NAME_VERSION (op
)],
957 op_p
, phi
, e
->flags
& EDGE_ABNORMAL
, NULL
);
960 if (TREE_CODE (op
) == ADDR_EXPR
)
962 tree base
= TREE_OPERAND (op
, 0);
963 while (handled_component_p (base
))
964 base
= TREE_OPERAND (base
, 0);
965 if ((TREE_CODE (base
) == VAR_DECL
966 || TREE_CODE (base
) == PARM_DECL
967 || TREE_CODE (base
) == RESULT_DECL
)
968 && !TREE_ADDRESSABLE (base
))
970 error ("address taken, but ADDRESSABLE bit not set");
977 error ("wrong edge %d->%d for PHI argument",
978 e
->src
->index
, e
->dest
->index
);
984 fprintf (stderr
, "PHI argument\n");
985 print_generic_stmt (stderr
, op
, TDF_VOPS
);
993 fprintf (stderr
, "for PHI node\n");
994 print_gimple_stmt (stderr
, phi
, 0, TDF_VOPS
|TDF_MEMSYMS
);
1002 /* Verify common invariants in the SSA web.
1003 TODO: verify the variable annotations. */
1006 verify_ssa (bool check_modified_stmt
, bool check_ssa_operands
)
1010 basic_block
*definition_block
= XCNEWVEC (basic_block
, num_ssa_names
);
1013 enum dom_state orig_dom_state
= dom_info_state (CDI_DOMINATORS
);
1014 bitmap names_defined_in_bb
= BITMAP_ALLOC (NULL
);
1016 gcc_assert (!need_ssa_update_p (cfun
));
1018 timevar_push (TV_TREE_SSA_VERIFY
);
1020 /* Keep track of SSA names present in the IL. */
1021 for (i
= 1; i
< num_ssa_names
; i
++)
1023 tree name
= ssa_name (i
);
1027 TREE_VISITED (name
) = 0;
1029 verify_ssa_name (name
, virtual_operand_p (name
));
1031 stmt
= SSA_NAME_DEF_STMT (name
);
1032 if (!gimple_nop_p (stmt
))
1034 basic_block bb
= gimple_bb (stmt
);
1035 if (verify_def (bb
, definition_block
,
1036 name
, stmt
, virtual_operand_p (name
)))
1042 calculate_dominance_info (CDI_DOMINATORS
);
1044 /* Now verify all the uses and make sure they agree with the definitions
1045 found in the previous pass. */
1046 FOR_EACH_BB_FN (bb
, cfun
)
1051 /* Make sure that all edges have a clear 'aux' field. */
1052 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
1056 error ("AUX pointer initialized for edge %d->%d", e
->src
->index
,
1062 /* Verify the arguments for every PHI node in the block. */
1063 for (gphi_iterator gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1065 gphi
*phi
= gsi
.phi ();
1066 if (verify_phi_args (phi
, bb
, definition_block
))
1069 bitmap_set_bit (names_defined_in_bb
,
1070 SSA_NAME_VERSION (gimple_phi_result (phi
)));
1073 /* Now verify all the uses and vuses in every statement of the block. */
1074 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
);
1077 gimple
*stmt
= gsi_stmt (gsi
);
1078 use_operand_p use_p
;
1080 if (check_modified_stmt
&& gimple_modified_p (stmt
))
1082 error ("stmt (%p) marked modified after optimization pass: ",
1084 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
);
1088 if (check_ssa_operands
&& verify_ssa_operands (cfun
, stmt
))
1090 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
);
1094 if (gimple_debug_bind_p (stmt
)
1095 && !gimple_debug_bind_has_value_p (stmt
))
1098 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_USE
|SSA_OP_VUSE
)
1100 op
= USE_FROM_PTR (use_p
);
1101 if (verify_use (bb
, definition_block
[SSA_NAME_VERSION (op
)],
1102 use_p
, stmt
, false, names_defined_in_bb
))
1106 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, iter
, SSA_OP_ALL_DEFS
)
1108 if (SSA_NAME_DEF_STMT (op
) != stmt
)
1110 error ("SSA_NAME_DEF_STMT is wrong");
1111 fprintf (stderr
, "Expected definition statement:\n");
1112 print_gimple_stmt (stderr
, stmt
, 4, TDF_VOPS
);
1113 fprintf (stderr
, "\nActual definition statement:\n");
1114 print_gimple_stmt (stderr
, SSA_NAME_DEF_STMT (op
),
1118 bitmap_set_bit (names_defined_in_bb
, SSA_NAME_VERSION (op
));
1122 bitmap_clear (names_defined_in_bb
);
1125 free (definition_block
);
1127 if (gimple_vop (cfun
)
1128 && ssa_default_def (cfun
, gimple_vop (cfun
)))
1130 auto_sbitmap
visited (last_basic_block_for_fn (cfun
) + 1);
1131 bitmap_clear (visited
);
1132 if (verify_vssa (ENTRY_BLOCK_PTR_FOR_FN (cfun
),
1133 ssa_default_def (cfun
, gimple_vop (cfun
)), visited
))
1137 /* Restore the dominance information to its prior known state, so
1138 that we do not perturb the compiler's subsequent behavior. */
1139 if (orig_dom_state
== DOM_NONE
)
1140 free_dominance_info (CDI_DOMINATORS
);
1142 set_dom_info_availability (CDI_DOMINATORS
, orig_dom_state
);
1144 BITMAP_FREE (names_defined_in_bb
);
1145 timevar_pop (TV_TREE_SSA_VERIFY
);
1149 internal_error ("verify_ssa failed");
1153 /* Initialize global DFA and SSA structures. */
1156 init_tree_ssa (struct function
*fn
)
1158 fn
->gimple_df
= ggc_cleared_alloc
<gimple_df
> ();
1159 fn
->gimple_df
->default_defs
= hash_table
<ssa_name_hasher
>::create_ggc (20);
1160 pt_solution_reset (&fn
->gimple_df
->escaped
);
1161 init_ssanames (fn
, 0);
1164 /* Deallocate memory associated with SSA data structures for FNDECL. */
1167 delete_tree_ssa (struct function
*fn
)
1171 /* We no longer maintain the SSA operand cache at this point. */
1172 if (ssa_operands_active (fn
))
1173 fini_ssa_operands (fn
);
1175 fn
->gimple_df
->default_defs
->empty ();
1176 fn
->gimple_df
->default_defs
= NULL
;
1177 pt_solution_reset (&fn
->gimple_df
->escaped
);
1178 if (fn
->gimple_df
->decls_to_pointers
!= NULL
)
1179 delete fn
->gimple_df
->decls_to_pointers
;
1180 fn
->gimple_df
->decls_to_pointers
= NULL
;
1181 fn
->gimple_df
= NULL
;
1183 /* We no longer need the edge variable maps. */
1184 redirect_edge_var_map_empty ();
1187 /* Return true if EXPR is a useless type conversion, otherwise return
1191 tree_ssa_useless_type_conversion (tree expr
)
1193 /* If we have an assignment that merely uses a NOP_EXPR to change
1194 the top of the RHS to the type of the LHS and the type conversion
1195 is "safe", then strip away the type conversion so that we can
1196 enter LHS = RHS into the const_and_copies table. */
1197 if (CONVERT_EXPR_P (expr
)
1198 || TREE_CODE (expr
) == VIEW_CONVERT_EXPR
1199 || TREE_CODE (expr
) == NON_LVALUE_EXPR
)
1200 return useless_type_conversion_p
1202 TREE_TYPE (TREE_OPERAND (expr
, 0)));
1207 /* Strip conversions from EXP according to
1208 tree_ssa_useless_type_conversion and return the resulting
1212 tree_ssa_strip_useless_type_conversions (tree exp
)
1214 while (tree_ssa_useless_type_conversion (exp
))
1215 exp
= TREE_OPERAND (exp
, 0);
1220 /* Return true if T, an SSA_NAME, has an undefined value. PARTIAL is what
1221 should be returned if the value is only partially undefined. */
1224 ssa_undefined_value_p (tree t
, bool partial
)
1227 tree var
= SSA_NAME_VAR (t
);
1231 /* Parameters get their initial value from the function entry. */
1232 else if (TREE_CODE (var
) == PARM_DECL
)
1234 /* When returning by reference the return address is actually a hidden
1236 else if (TREE_CODE (var
) == RESULT_DECL
&& DECL_BY_REFERENCE (var
))
1238 /* Hard register variables get their initial value from the ether. */
1239 else if (TREE_CODE (var
) == VAR_DECL
&& DECL_HARD_REGISTER (var
))
1242 /* The value is undefined iff its definition statement is empty. */
1243 def_stmt
= SSA_NAME_DEF_STMT (t
);
1244 if (gimple_nop_p (def_stmt
))
1247 /* Check if the complex was not only partially defined. */
1248 if (partial
&& is_gimple_assign (def_stmt
)
1249 && gimple_assign_rhs_code (def_stmt
) == COMPLEX_EXPR
)
1253 rhs1
= gimple_assign_rhs1 (def_stmt
);
1254 rhs2
= gimple_assign_rhs2 (def_stmt
);
1255 return (TREE_CODE (rhs1
) == SSA_NAME
&& ssa_undefined_value_p (rhs1
))
1256 || (TREE_CODE (rhs2
) == SSA_NAME
&& ssa_undefined_value_p (rhs2
));
1262 /* Return TRUE iff STMT, a gimple statement, references an undefined
1266 gimple_uses_undefined_value_p (gimple
*stmt
)
1271 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, iter
, SSA_OP_USE
)
1272 if (ssa_undefined_value_p (op
))
1280 /* If necessary, rewrite the base of the reference tree *TP from
1281 a MEM_REF to a plain or converted symbol. */
1284 maybe_rewrite_mem_ref_base (tree
*tp
, bitmap suitable_for_renaming
)
1288 while (handled_component_p (*tp
))
1289 tp
= &TREE_OPERAND (*tp
, 0);
1290 if (TREE_CODE (*tp
) == MEM_REF
1291 && TREE_CODE (TREE_OPERAND (*tp
, 0)) == ADDR_EXPR
1292 && (sym
= TREE_OPERAND (TREE_OPERAND (*tp
, 0), 0))
1294 && !TREE_ADDRESSABLE (sym
)
1295 && bitmap_bit_p (suitable_for_renaming
, DECL_UID (sym
)))
1297 if (TREE_CODE (TREE_TYPE (sym
)) == VECTOR_TYPE
1298 && useless_type_conversion_p (TREE_TYPE (*tp
),
1299 TREE_TYPE (TREE_TYPE (sym
)))
1300 && multiple_of_p (sizetype
, TREE_OPERAND (*tp
, 1),
1301 TYPE_SIZE_UNIT (TREE_TYPE (*tp
))))
1303 *tp
= build3 (BIT_FIELD_REF
, TREE_TYPE (*tp
), sym
,
1304 TYPE_SIZE (TREE_TYPE (*tp
)),
1305 int_const_binop (MULT_EXPR
,
1306 bitsize_int (BITS_PER_UNIT
),
1307 TREE_OPERAND (*tp
, 1)));
1309 else if (TREE_CODE (TREE_TYPE (sym
)) == COMPLEX_TYPE
1310 && useless_type_conversion_p (TREE_TYPE (*tp
),
1311 TREE_TYPE (TREE_TYPE (sym
))))
1313 *tp
= build1 (integer_zerop (TREE_OPERAND (*tp
, 1))
1314 ? REALPART_EXPR
: IMAGPART_EXPR
,
1315 TREE_TYPE (*tp
), sym
);
1317 else if (integer_zerop (TREE_OPERAND (*tp
, 1)))
1319 if (!useless_type_conversion_p (TREE_TYPE (*tp
),
1321 *tp
= build1 (VIEW_CONVERT_EXPR
,
1322 TREE_TYPE (*tp
), sym
);
1329 /* For a tree REF return its base if it is the base of a MEM_REF
1330 that cannot be rewritten into SSA form. Otherwise return NULL_TREE. */
1333 non_rewritable_mem_ref_base (tree ref
)
1337 /* A plain decl does not need it set. */
1341 if (! (base
= CONST_CAST_TREE (strip_invariant_refs (ref
))))
1343 base
= get_base_address (ref
);
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 /* We can re-write REALPART_EXPR and IMAGPART_EXPR sets in
1387 a reasonably efficient manner... */
1388 if ((TREE_CODE (lhs
) == REALPART_EXPR
1389 || TREE_CODE (lhs
) == IMAGPART_EXPR
)
1390 && DECL_P (TREE_OPERAND (lhs
, 0)))
1393 /* ??? The following could be relaxed allowing component
1394 references that do not change the access size. */
1395 if (TREE_CODE (lhs
) == MEM_REF
1396 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == ADDR_EXPR
)
1398 tree decl
= TREE_OPERAND (TREE_OPERAND (lhs
, 0), 0);
1400 /* A decl that is wrapped inside a MEM-REF that covers
1401 it full is also rewritable. */
1402 if (integer_zerop (TREE_OPERAND (lhs
, 1))
1404 && DECL_SIZE (decl
) == TYPE_SIZE (TREE_TYPE (lhs
))
1405 /* If the dynamic type of the decl has larger precision than
1406 the decl itself we can't use the decls type for SSA rewriting. */
1407 && ((! INTEGRAL_TYPE_P (TREE_TYPE (decl
))
1408 || compare_tree_int (DECL_SIZE (decl
),
1409 TYPE_PRECISION (TREE_TYPE (decl
))) == 0)
1410 || (INTEGRAL_TYPE_P (TREE_TYPE (lhs
))
1411 && (TYPE_PRECISION (TREE_TYPE (decl
))
1412 >= TYPE_PRECISION (TREE_TYPE (lhs
)))))
1413 /* Make sure we are not re-writing non-float copying into float
1414 copying as that can incur normalization. */
1415 && (! FLOAT_TYPE_P (TREE_TYPE (decl
))
1416 || types_compatible_p (TREE_TYPE (lhs
), TREE_TYPE (decl
)))
1417 && (TREE_THIS_VOLATILE (decl
) == TREE_THIS_VOLATILE (lhs
)))
1420 /* A vector-insert using a MEM_REF or ARRAY_REF is rewritable
1421 using a BIT_INSERT_EXPR. */
1423 && VECTOR_TYPE_P (TREE_TYPE (decl
))
1424 && TYPE_MODE (TREE_TYPE (decl
)) != BLKmode
1425 && types_compatible_p (TREE_TYPE (lhs
),
1426 TREE_TYPE (TREE_TYPE (decl
)))
1427 && tree_fits_uhwi_p (TREE_OPERAND (lhs
, 1))
1428 && tree_int_cst_lt (TREE_OPERAND (lhs
, 1),
1429 TYPE_SIZE_UNIT (TREE_TYPE (decl
)))
1430 && (tree_to_uhwi (TREE_OPERAND (lhs
, 1))
1431 % tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (lhs
)))) == 0)
1435 /* A vector-insert using a BIT_FIELD_REF is rewritable using
1437 if (TREE_CODE (lhs
) == BIT_FIELD_REF
1438 && DECL_P (TREE_OPERAND (lhs
, 0))
1439 && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (lhs
, 0)))
1440 && TYPE_MODE (TREE_TYPE (TREE_OPERAND (lhs
, 0))) != BLKmode
1441 && types_compatible_p (TREE_TYPE (lhs
),
1442 TREE_TYPE (TREE_TYPE (TREE_OPERAND (lhs
, 0))))
1443 && (tree_to_uhwi (TREE_OPERAND (lhs
, 2))
1444 % tree_to_uhwi (TYPE_SIZE (TREE_TYPE (lhs
)))) == 0)
1450 /* When possible, clear TREE_ADDRESSABLE bit or set DECL_GIMPLE_REG_P bit and
1451 mark the variable VAR for conversion into SSA. Return true when updating
1452 stmts is required. */
1455 maybe_optimize_var (tree var
, bitmap addresses_taken
, bitmap not_reg_needs
,
1456 bitmap suitable_for_renaming
)
1458 /* Global Variables, result decls cannot be changed. */
1459 if (is_global_var (var
)
1460 || TREE_CODE (var
) == RESULT_DECL
1461 || bitmap_bit_p (addresses_taken
, DECL_UID (var
)))
1464 if (TREE_ADDRESSABLE (var
)
1465 /* Do not change TREE_ADDRESSABLE if we need to preserve var as
1466 a non-register. Otherwise we are confused and forget to
1467 add virtual operands for it. */
1468 && (!is_gimple_reg_type (TREE_TYPE (var
))
1469 || TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
1470 || TREE_CODE (TREE_TYPE (var
)) == COMPLEX_TYPE
1471 || !bitmap_bit_p (not_reg_needs
, DECL_UID (var
))))
1473 TREE_ADDRESSABLE (var
) = 0;
1474 if (is_gimple_reg (var
))
1475 bitmap_set_bit (suitable_for_renaming
, DECL_UID (var
));
1478 fprintf (dump_file
, "No longer having address taken: ");
1479 print_generic_expr (dump_file
, var
, 0);
1480 fprintf (dump_file
, "\n");
1484 if (!DECL_GIMPLE_REG_P (var
)
1485 && !bitmap_bit_p (not_reg_needs
, DECL_UID (var
))
1486 && (TREE_CODE (TREE_TYPE (var
)) == COMPLEX_TYPE
1487 || TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
)
1488 && !TREE_THIS_VOLATILE (var
)
1489 && (TREE_CODE (var
) != VAR_DECL
|| !DECL_HARD_REGISTER (var
)))
1491 DECL_GIMPLE_REG_P (var
) = 1;
1492 bitmap_set_bit (suitable_for_renaming
, DECL_UID (var
));
1495 fprintf (dump_file
, "Now a gimple register: ");
1496 print_generic_expr (dump_file
, var
, 0);
1497 fprintf (dump_file
, "\n");
1502 /* Compute TREE_ADDRESSABLE and DECL_GIMPLE_REG_P for local variables. */
1505 execute_update_addresses_taken (void)
1508 bitmap addresses_taken
= BITMAP_ALLOC (NULL
);
1509 bitmap not_reg_needs
= BITMAP_ALLOC (NULL
);
1510 bitmap suitable_for_renaming
= BITMAP_ALLOC (NULL
);
1514 timevar_push (TV_ADDRESS_TAKEN
);
1516 /* Collect into ADDRESSES_TAKEN all variables whose address is taken within
1517 the function body. */
1518 FOR_EACH_BB_FN (bb
, cfun
)
1520 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
);
1523 gimple
*stmt
= gsi_stmt (gsi
);
1524 enum gimple_code code
= gimple_code (stmt
);
1527 if (code
== GIMPLE_CALL
1528 && optimize_atomic_compare_exchange_p (stmt
))
1530 /* For __atomic_compare_exchange_N if the second argument
1531 is &var, don't mark var addressable;
1532 if it becomes non-addressable, we'll rewrite it into
1533 ATOMIC_COMPARE_EXCHANGE call. */
1534 tree arg
= gimple_call_arg (stmt
, 1);
1535 gimple_call_set_arg (stmt
, 1, null_pointer_node
);
1536 gimple_ior_addresses_taken (addresses_taken
, stmt
);
1537 gimple_call_set_arg (stmt
, 1, arg
);
1540 /* Note all addresses taken by the stmt. */
1541 gimple_ior_addresses_taken (addresses_taken
, stmt
);
1543 /* If we have a call or an assignment, see if the lhs contains
1544 a local decl that requires not to be a gimple register. */
1545 if (code
== GIMPLE_ASSIGN
|| code
== GIMPLE_CALL
)
1547 tree lhs
= gimple_get_lhs (stmt
);
1549 && TREE_CODE (lhs
) != SSA_NAME
1550 && ((code
== GIMPLE_CALL
&& ! DECL_P (lhs
))
1551 || non_rewritable_lvalue_p (lhs
)))
1553 decl
= get_base_address (lhs
);
1555 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1559 if (gimple_assign_single_p (stmt
))
1561 tree rhs
= gimple_assign_rhs1 (stmt
);
1562 if ((decl
= non_rewritable_mem_ref_base (rhs
)))
1563 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1566 else if (code
== GIMPLE_CALL
)
1568 for (i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
1570 tree arg
= gimple_call_arg (stmt
, i
);
1571 if ((decl
= non_rewritable_mem_ref_base (arg
)))
1572 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1576 else if (code
== GIMPLE_ASM
)
1578 gasm
*asm_stmt
= as_a
<gasm
*> (stmt
);
1579 for (i
= 0; i
< gimple_asm_noutputs (asm_stmt
); ++i
)
1581 tree link
= gimple_asm_output_op (asm_stmt
, i
);
1582 tree lhs
= TREE_VALUE (link
);
1583 if (TREE_CODE (lhs
) != SSA_NAME
)
1585 decl
= get_base_address (lhs
);
1587 && (non_rewritable_lvalue_p (lhs
)
1588 /* We cannot move required conversions from
1589 the lhs to the rhs in asm statements, so
1590 require we do not need any. */
1591 || !useless_type_conversion_p
1592 (TREE_TYPE (lhs
), TREE_TYPE (decl
))))
1593 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1596 for (i
= 0; i
< gimple_asm_ninputs (asm_stmt
); ++i
)
1598 tree link
= gimple_asm_input_op (asm_stmt
, i
);
1599 if ((decl
= non_rewritable_mem_ref_base (TREE_VALUE (link
))))
1600 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1605 for (gphi_iterator gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
);
1609 gphi
*phi
= gsi
.phi ();
1611 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
1613 tree op
= PHI_ARG_DEF (phi
, i
), var
;
1614 if (TREE_CODE (op
) == ADDR_EXPR
1615 && (var
= get_base_address (TREE_OPERAND (op
, 0))) != NULL
1617 bitmap_set_bit (addresses_taken
, DECL_UID (var
));
1622 /* We cannot iterate over all referenced vars because that can contain
1623 unused vars from BLOCK trees, which causes code generation differences
1625 for (var
= DECL_ARGUMENTS (cfun
->decl
); var
; var
= DECL_CHAIN (var
))
1626 maybe_optimize_var (var
, addresses_taken
, not_reg_needs
,
1627 suitable_for_renaming
);
1629 FOR_EACH_VEC_SAFE_ELT (cfun
->local_decls
, i
, var
)
1630 maybe_optimize_var (var
, addresses_taken
, not_reg_needs
,
1631 suitable_for_renaming
);
1633 /* Operand caches need to be recomputed for operands referencing the updated
1634 variables and operands need to be rewritten to expose bare symbols. */
1635 if (!bitmap_empty_p (suitable_for_renaming
))
1637 FOR_EACH_BB_FN (bb
, cfun
)
1638 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
);)
1640 gimple
*stmt
= gsi_stmt (gsi
);
1642 /* Re-write TARGET_MEM_REFs of symbols we want to
1643 rewrite into SSA form. */
1644 if (gimple_assign_single_p (stmt
))
1646 tree lhs
= gimple_assign_lhs (stmt
);
1647 tree rhs
, *rhsp
= gimple_assign_rhs1_ptr (stmt
);
1650 /* Rewrite LHS IMAG/REALPART_EXPR similar to
1651 gimplify_modify_expr_complex_part. */
1652 if ((TREE_CODE (lhs
) == IMAGPART_EXPR
1653 || TREE_CODE (lhs
) == REALPART_EXPR
)
1654 && DECL_P (TREE_OPERAND (lhs
, 0))
1655 && bitmap_bit_p (suitable_for_renaming
,
1656 DECL_UID (TREE_OPERAND (lhs
, 0))))
1658 tree other
= make_ssa_name (TREE_TYPE (lhs
));
1659 tree lrhs
= build1 (TREE_CODE (lhs
) == IMAGPART_EXPR
1660 ? REALPART_EXPR
: IMAGPART_EXPR
,
1662 TREE_OPERAND (lhs
, 0));
1663 gimple
*load
= gimple_build_assign (other
, lrhs
);
1664 location_t loc
= gimple_location (stmt
);
1665 gimple_set_location (load
, loc
);
1666 gimple_set_vuse (load
, gimple_vuse (stmt
));
1667 gsi_insert_before (&gsi
, load
, GSI_SAME_STMT
);
1668 gimple_assign_set_lhs (stmt
, TREE_OPERAND (lhs
, 0));
1669 gimple_assign_set_rhs_with_ops
1670 (&gsi
, COMPLEX_EXPR
,
1671 TREE_CODE (lhs
) == IMAGPART_EXPR
1672 ? other
: gimple_assign_rhs1 (stmt
),
1673 TREE_CODE (lhs
) == IMAGPART_EXPR
1674 ? gimple_assign_rhs1 (stmt
) : other
, NULL_TREE
);
1675 stmt
= gsi_stmt (gsi
);
1676 unlink_stmt_vdef (stmt
);
1681 /* Rewrite a vector insert via a BIT_FIELD_REF on the LHS
1682 into a BIT_INSERT_EXPR. */
1683 if (TREE_CODE (lhs
) == BIT_FIELD_REF
1684 && DECL_P (TREE_OPERAND (lhs
, 0))
1685 && bitmap_bit_p (suitable_for_renaming
,
1686 DECL_UID (TREE_OPERAND (lhs
, 0)))
1687 && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (lhs
, 0)))
1688 && TYPE_MODE (TREE_TYPE (TREE_OPERAND (lhs
, 0))) != BLKmode
1689 && types_compatible_p (TREE_TYPE (lhs
),
1690 TREE_TYPE (TREE_TYPE
1691 (TREE_OPERAND (lhs
, 0))))
1692 && (tree_to_uhwi (TREE_OPERAND (lhs
, 2))
1693 % tree_to_uhwi (TYPE_SIZE (TREE_TYPE (lhs
))) == 0))
1695 tree var
= TREE_OPERAND (lhs
, 0);
1696 tree val
= gimple_assign_rhs1 (stmt
);
1697 tree bitpos
= TREE_OPERAND (lhs
, 2);
1698 gimple_assign_set_lhs (stmt
, var
);
1699 gimple_assign_set_rhs_with_ops
1700 (&gsi
, BIT_INSERT_EXPR
, var
, val
, bitpos
);
1701 stmt
= gsi_stmt (gsi
);
1702 unlink_stmt_vdef (stmt
);
1707 /* Rewrite a vector insert using a MEM_REF on the LHS
1708 into a BIT_INSERT_EXPR. */
1709 if (TREE_CODE (lhs
) == MEM_REF
1710 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == ADDR_EXPR
1711 && (sym
= TREE_OPERAND (TREE_OPERAND (lhs
, 0), 0))
1713 && bitmap_bit_p (suitable_for_renaming
, DECL_UID (sym
))
1714 && VECTOR_TYPE_P (TREE_TYPE (sym
))
1715 && TYPE_MODE (TREE_TYPE (sym
)) != BLKmode
1716 && types_compatible_p (TREE_TYPE (lhs
),
1717 TREE_TYPE (TREE_TYPE (sym
)))
1718 && tree_fits_uhwi_p (TREE_OPERAND (lhs
, 1))
1719 && tree_int_cst_lt (TREE_OPERAND (lhs
, 1),
1720 TYPE_SIZE_UNIT (TREE_TYPE (sym
)))
1721 && (tree_to_uhwi (TREE_OPERAND (lhs
, 1))
1722 % tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (lhs
)))) == 0)
1724 tree val
= gimple_assign_rhs1 (stmt
);
1726 = wide_int_to_tree (bitsizetype
,
1727 mem_ref_offset (lhs
) * BITS_PER_UNIT
);
1728 gimple_assign_set_lhs (stmt
, sym
);
1729 gimple_assign_set_rhs_with_ops
1730 (&gsi
, BIT_INSERT_EXPR
, sym
, val
, bitpos
);
1731 stmt
= gsi_stmt (gsi
);
1732 unlink_stmt_vdef (stmt
);
1737 /* We shouldn't have any fancy wrapping of
1738 component-refs on the LHS, but look through
1739 VIEW_CONVERT_EXPRs as that is easy. */
1740 while (TREE_CODE (lhs
) == VIEW_CONVERT_EXPR
)
1741 lhs
= TREE_OPERAND (lhs
, 0);
1742 if (TREE_CODE (lhs
) == MEM_REF
1743 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == ADDR_EXPR
1744 && integer_zerop (TREE_OPERAND (lhs
, 1))
1745 && (sym
= TREE_OPERAND (TREE_OPERAND (lhs
, 0), 0))
1747 && !TREE_ADDRESSABLE (sym
)
1748 && bitmap_bit_p (suitable_for_renaming
, DECL_UID (sym
)))
1751 lhs
= gimple_assign_lhs (stmt
);
1753 /* Rewrite the RHS and make sure the resulting assignment
1754 is validly typed. */
1755 maybe_rewrite_mem_ref_base (rhsp
, suitable_for_renaming
);
1756 rhs
= gimple_assign_rhs1 (stmt
);
1757 if (gimple_assign_lhs (stmt
) != lhs
1758 && !useless_type_conversion_p (TREE_TYPE (lhs
),
1761 if (gimple_clobber_p (stmt
))
1763 rhs
= build_constructor (TREE_TYPE (lhs
), NULL
);
1764 TREE_THIS_VOLATILE (rhs
) = 1;
1767 rhs
= fold_build1 (VIEW_CONVERT_EXPR
,
1768 TREE_TYPE (lhs
), rhs
);
1770 if (gimple_assign_lhs (stmt
) != lhs
)
1771 gimple_assign_set_lhs (stmt
, lhs
);
1773 if (gimple_assign_rhs1 (stmt
) != rhs
)
1775 gimple_stmt_iterator gsi
= gsi_for_stmt (stmt
);
1776 gimple_assign_set_rhs_from_tree (&gsi
, rhs
);
1780 else if (gimple_code (stmt
) == GIMPLE_CALL
)
1783 if (optimize_atomic_compare_exchange_p (stmt
))
1785 tree expected
= gimple_call_arg (stmt
, 1);
1786 if (bitmap_bit_p (suitable_for_renaming
,
1787 DECL_UID (TREE_OPERAND (expected
, 0))))
1789 fold_builtin_atomic_compare_exchange (&gsi
);
1793 for (i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
1795 tree
*argp
= gimple_call_arg_ptr (stmt
, i
);
1796 maybe_rewrite_mem_ref_base (argp
, suitable_for_renaming
);
1800 else if (gimple_code (stmt
) == GIMPLE_ASM
)
1802 gasm
*asm_stmt
= as_a
<gasm
*> (stmt
);
1804 for (i
= 0; i
< gimple_asm_noutputs (asm_stmt
); ++i
)
1806 tree link
= gimple_asm_output_op (asm_stmt
, i
);
1807 maybe_rewrite_mem_ref_base (&TREE_VALUE (link
),
1808 suitable_for_renaming
);
1810 for (i
= 0; i
< gimple_asm_ninputs (asm_stmt
); ++i
)
1812 tree link
= gimple_asm_input_op (asm_stmt
, i
);
1813 maybe_rewrite_mem_ref_base (&TREE_VALUE (link
),
1814 suitable_for_renaming
);
1818 else if (gimple_debug_bind_p (stmt
)
1819 && gimple_debug_bind_has_value_p (stmt
))
1821 tree
*valuep
= gimple_debug_bind_get_value_ptr (stmt
);
1823 maybe_rewrite_mem_ref_base (valuep
, suitable_for_renaming
);
1824 decl
= non_rewritable_mem_ref_base (*valuep
);
1826 && bitmap_bit_p (suitable_for_renaming
, DECL_UID (decl
)))
1827 gimple_debug_bind_reset_value (stmt
);
1830 if (gimple_references_memory_p (stmt
)
1831 || is_gimple_debug (stmt
))
1837 /* Update SSA form here, we are called as non-pass as well. */
1838 if (number_of_loops (cfun
) > 1
1839 && loops_state_satisfies_p (LOOP_CLOSED_SSA
))
1840 rewrite_into_loop_closed_ssa (NULL
, TODO_update_ssa
);
1842 update_ssa (TODO_update_ssa
);
1845 BITMAP_FREE (not_reg_needs
);
1846 BITMAP_FREE (addresses_taken
);
1847 BITMAP_FREE (suitable_for_renaming
);
1848 timevar_pop (TV_ADDRESS_TAKEN
);
1853 const pass_data pass_data_update_address_taken
=
1855 GIMPLE_PASS
, /* type */
1856 "addressables", /* name */
1857 OPTGROUP_NONE
, /* optinfo_flags */
1858 TV_ADDRESS_TAKEN
, /* tv_id */
1859 PROP_ssa
, /* properties_required */
1860 0, /* properties_provided */
1861 0, /* properties_destroyed */
1862 0, /* todo_flags_start */
1863 TODO_update_address_taken
, /* todo_flags_finish */
1866 class pass_update_address_taken
: public gimple_opt_pass
1869 pass_update_address_taken (gcc::context
*ctxt
)
1870 : gimple_opt_pass (pass_data_update_address_taken
, ctxt
)
1873 /* opt_pass methods: */
1875 }; // class pass_update_address_taken
1880 make_pass_update_address_taken (gcc::context
*ctxt
)
1882 return new pass_update_address_taken (ctxt
);