1 /* Miscellaneous SSA utility functions.
2 Copyright (C) 2001-2020 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"
44 #include "stringpool.h"
48 /* Pointer map of variable mappings, keyed by edge. */
49 static hash_map
<edge
, auto_vec
<edge_var_map
> > *edge_var_maps
;
52 /* Add a mapping with PHI RESULT and PHI DEF associated with edge E. */
55 redirect_edge_var_map_add (edge e
, tree result
, tree def
, location_t locus
)
57 edge_var_map new_node
;
59 if (edge_var_maps
== NULL
)
60 edge_var_maps
= new hash_map
<edge
, auto_vec
<edge_var_map
> >;
62 auto_vec
<edge_var_map
> &slot
= edge_var_maps
->get_or_insert (e
);
64 new_node
.result
= result
;
65 new_node
.locus
= locus
;
67 slot
.safe_push (new_node
);
71 /* Clear the var mappings in edge E. */
74 redirect_edge_var_map_clear (edge e
)
79 auto_vec
<edge_var_map
> *head
= edge_var_maps
->get (e
);
86 /* Duplicate the redirected var mappings in OLDE in NEWE.
88 This assumes a hash_map can have multiple edges mapping to the same
89 var_map (many to one mapping), since we don't remove the previous mappings.
93 redirect_edge_var_map_dup (edge newe
, edge olde
)
98 auto_vec
<edge_var_map
> *new_head
= &edge_var_maps
->get_or_insert (newe
);
99 auto_vec
<edge_var_map
> *old_head
= edge_var_maps
->get (olde
);
103 new_head
->safe_splice (*old_head
);
107 /* Return the variable mappings for a given edge. If there is none, return
111 redirect_edge_var_map_vector (edge e
)
113 /* Hey, what kind of idiot would... you'd be surprised. */
117 auto_vec
<edge_var_map
> *slot
= edge_var_maps
->get (e
);
124 /* Clear the edge variable mappings. */
127 redirect_edge_var_map_empty (void)
130 edge_var_maps
->empty ();
134 /* Remove the corresponding arguments from the PHI nodes in E's
135 destination block and redirect it to DEST. Return redirected edge.
136 The list of removed arguments is stored in a vector accessed
137 through edge_var_maps. */
140 ssa_redirect_edge (edge e
, basic_block dest
)
145 redirect_edge_var_map_clear (e
);
147 /* Remove the appropriate PHI arguments in E's destination block.
148 If we are redirecting a copied edge the destination has not
149 got PHI argument space reserved nor an interesting argument. */
150 if (! (e
->dest
->flags
& BB_DUPLICATED
))
151 for (gsi
= gsi_start_phis (e
->dest
); !gsi_end_p (gsi
); gsi_next (&gsi
))
157 def
= gimple_phi_arg_def (phi
, e
->dest_idx
);
158 locus
= gimple_phi_arg_location (phi
, e
->dest_idx
);
160 if (def
== NULL_TREE
)
163 redirect_edge_var_map_add (e
, gimple_phi_result (phi
), def
, locus
);
166 e
= redirect_edge_succ_nodup (e
, dest
);
172 /* Add PHI arguments queued in PENDING_STMT list on edge E to edge
176 flush_pending_stmts (edge e
)
183 vec
<edge_var_map
> *v
= redirect_edge_var_map_vector (e
);
187 for (gsi
= gsi_start_phis (e
->dest
), i
= 0;
188 !gsi_end_p (gsi
) && v
->iterate (i
, &vm
);
189 gsi_next (&gsi
), i
++)
194 def
= redirect_edge_var_map_def (vm
);
195 add_phi_arg (phi
, def
, e
, redirect_edge_var_map_location (vm
));
198 redirect_edge_var_map_clear (e
);
201 /* Replace the LHS of STMT, an assignment, either a GIMPLE_ASSIGN or a
202 GIMPLE_CALL, with NLHS, in preparation for modifying the RHS to an
203 expression with a different value.
205 This will update any annotations (say debug bind stmts) referring
206 to the original LHS, so that they use the RHS instead. This is
207 done even if NLHS and LHS are the same, for it is understood that
208 the RHS will be modified afterwards, and NLHS will not be assigned
211 Adjusting any non-annotation uses of the LHS, if needed, is a
212 responsibility of the caller.
214 The effect of this call should be pretty much the same as that of
215 inserting a copy of STMT before STMT, and then removing the
216 original stmt, at which time gsi_remove() would have update
217 annotations, but using this function saves all the inserting,
218 copying and removing. */
221 gimple_replace_ssa_lhs (gimple
*stmt
, tree nlhs
)
223 if (MAY_HAVE_DEBUG_BIND_STMTS
)
225 tree lhs
= gimple_get_lhs (stmt
);
227 gcc_assert (SSA_NAME_DEF_STMT (lhs
) == stmt
);
229 insert_debug_temp_for_var_def (NULL
, lhs
);
232 gimple_set_lhs (stmt
, nlhs
);
236 /* Given a tree for an expression for which we might want to emit
237 locations or values in debug information (generally a variable, but
238 we might deal with other kinds of trees in the future), return the
239 tree that should be used as the variable of a DEBUG_BIND STMT or
240 VAR_LOCATION INSN or NOTE. Return NULL if VAR is not to be tracked. */
243 target_for_debug_bind (tree var
)
245 if (!MAY_HAVE_DEBUG_BIND_STMTS
)
248 if (TREE_CODE (var
) == SSA_NAME
)
250 var
= SSA_NAME_VAR (var
);
251 if (var
== NULL_TREE
)
255 if ((!VAR_P (var
) || VAR_DECL_IS_VIRTUAL_OPERAND (var
))
256 && TREE_CODE (var
) != PARM_DECL
)
259 if (DECL_HAS_VALUE_EXPR_P (var
))
260 return target_for_debug_bind (DECL_VALUE_EXPR (var
));
262 if (DECL_IGNORED_P (var
))
265 /* var-tracking only tracks registers. */
266 if (!is_gimple_reg_type (TREE_TYPE (var
)))
272 /* Called via walk_tree, look for SSA_NAMEs that have already been
276 find_released_ssa_name (tree
*tp
, int *walk_subtrees
, void *data_
)
278 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data_
;
280 if (wi
&& wi
->is_lhs
)
283 if (TREE_CODE (*tp
) == SSA_NAME
)
285 if (SSA_NAME_IN_FREE_LIST (*tp
))
290 else if (IS_TYPE_OR_DECL_P (*tp
))
296 /* Insert a DEBUG BIND stmt before the DEF of VAR if VAR is referenced
297 by other DEBUG stmts, and replace uses of the DEF with the
298 newly-created debug temp. */
301 insert_debug_temp_for_var_def (gimple_stmt_iterator
*gsi
, tree var
)
303 imm_use_iterator imm_iter
;
306 gimple
*def_stmt
= NULL
;
310 if (!MAY_HAVE_DEBUG_BIND_STMTS
)
313 /* If this name has already been registered for replacement, do nothing
314 as anything that uses this name isn't in SSA form. */
315 if (name_registered_for_update_p (var
))
318 /* Check whether there are debug stmts that reference this variable and,
319 if there are, decide whether we should use a debug temp. */
320 FOR_EACH_IMM_USE_FAST (use_p
, imm_iter
, var
)
322 stmt
= USE_STMT (use_p
);
324 if (!gimple_debug_bind_p (stmt
))
330 if (gimple_debug_bind_get_value (stmt
) != var
)
332 /* Count this as an additional use, so as to make sure we
333 use a temp unless VAR's definition has a SINGLE_RHS that
344 def_stmt
= gsi_stmt (*gsi
);
346 def_stmt
= SSA_NAME_DEF_STMT (var
);
348 /* If we didn't get an insertion point, and the stmt has already
349 been removed, we won't be able to insert the debug bind stmt, so
350 we'll have to drop debug information. */
351 if (gimple_code (def_stmt
) == GIMPLE_PHI
)
353 value
= degenerate_phi_result (as_a
<gphi
*> (def_stmt
));
354 if (value
&& walk_tree (&value
, find_released_ssa_name
, NULL
, NULL
))
356 /* error_mark_node is what fixup_noreturn_call changes PHI arguments
358 else if (value
== error_mark_node
)
361 else if (gimple_clobber_p (def_stmt
))
362 /* We can end up here when rewriting a decl into SSA and coming
363 along a clobber for the original decl. Turn that into
364 # DEBUG decl => NULL */
366 else if (is_gimple_assign (def_stmt
))
368 bool no_value
= false;
370 if (!dom_info_available_p (CDI_DOMINATORS
))
372 struct walk_stmt_info wi
;
374 memset (&wi
, 0, sizeof (wi
));
376 /* When removing blocks without following reverse dominance
377 order, we may sometimes encounter SSA_NAMEs that have
378 already been released, referenced in other SSA_DEFs that
379 we're about to release. Consider:
388 If we deleted BB X first, propagating the value of w_2
389 won't do us any good. It's too late to recover their
390 original definition of v_1: when it was deleted, it was
391 only referenced in other DEFs, it couldn't possibly know
392 it should have been retained, and propagating every
393 single DEF just in case it might have to be propagated
394 into a DEBUG STMT would probably be too wasteful.
396 When dominator information is not readily available, we
397 check for and accept some loss of debug information. But
398 if it is available, there's no excuse for us to remove
399 blocks in the wrong order, so we don't even check for
400 dead SSA NAMEs. SSA verification shall catch any
402 if ((!gsi
&& !gimple_bb (def_stmt
))
403 || walk_gimple_op (def_stmt
, find_released_ssa_name
, &wi
))
408 value
= gimple_assign_rhs_to_tree (def_stmt
);
413 /* If there's a single use of VAR, and VAR is the entire debug
414 expression (usecount would have been incremented again
415 otherwise), and the definition involves only constants and
416 SSA names, then we can propagate VALUE into this single use,
419 We can also avoid using a temp if VALUE can be shared and
420 propagated into all uses, without generating expressions that
421 wouldn't be valid gimple RHSs.
423 Other cases that would require unsharing or non-gimple RHSs
424 are deferred to a debug temp, although we could avoid temps
425 at the expense of duplication of expressions. */
427 if (CONSTANT_CLASS_P (value
)
428 || gimple_code (def_stmt
) == GIMPLE_PHI
430 && (!gimple_assign_single_p (def_stmt
)
431 || is_gimple_min_invariant (value
)))
432 || is_gimple_reg (value
))
437 tree vexpr
= make_node (DEBUG_EXPR_DECL
);
439 def_temp
= gimple_build_debug_bind (vexpr
,
440 unshare_expr (value
),
443 DECL_ARTIFICIAL (vexpr
) = 1;
444 TREE_TYPE (vexpr
) = TREE_TYPE (value
);
446 SET_DECL_MODE (vexpr
, DECL_MODE (value
));
448 SET_DECL_MODE (vexpr
, TYPE_MODE (TREE_TYPE (value
)));
451 gsi_insert_before (gsi
, def_temp
, GSI_SAME_STMT
);
454 gimple_stmt_iterator ngsi
= gsi_for_stmt (def_stmt
);
455 gsi_insert_before (&ngsi
, def_temp
, GSI_SAME_STMT
);
462 FOR_EACH_IMM_USE_STMT (stmt
, imm_iter
, var
)
464 if (!gimple_debug_bind_p (stmt
))
469 FOR_EACH_IMM_USE_ON_STMT (use_p
, imm_iter
)
470 /* unshare_expr is not needed here. vexpr is either a
471 SINGLE_RHS, that can be safely shared, some other RHS
472 that was unshared when we found it had a single debug
473 use, or a DEBUG_EXPR_DECL, that can be safely
475 SET_USE (use_p
, unshare_expr (value
));
476 /* If we didn't replace uses with a debug decl fold the
477 resulting expression. Otherwise we end up with invalid IL. */
478 if (TREE_CODE (value
) != DEBUG_EXPR_DECL
)
480 gimple_stmt_iterator gsi
= gsi_for_stmt (stmt
);
481 fold_stmt_inplace (&gsi
);
485 gimple_debug_bind_reset_value (stmt
);
492 /* Insert a DEBUG BIND stmt before STMT for each DEF referenced by
493 other DEBUG stmts, and replace uses of the DEF with the
494 newly-created debug temp. */
497 insert_debug_temps_for_defs (gimple_stmt_iterator
*gsi
)
503 if (!MAY_HAVE_DEBUG_BIND_STMTS
)
506 stmt
= gsi_stmt (*gsi
);
508 FOR_EACH_PHI_OR_STMT_DEF (def_p
, stmt
, op_iter
, SSA_OP_DEF
)
510 tree var
= DEF_FROM_PTR (def_p
);
512 if (TREE_CODE (var
) != SSA_NAME
)
515 insert_debug_temp_for_var_def (gsi
, var
);
519 /* Reset all debug stmts that use SSA_NAME(s) defined in STMT. */
522 reset_debug_uses (gimple
*stmt
)
526 imm_use_iterator imm_iter
;
529 if (!MAY_HAVE_DEBUG_BIND_STMTS
)
532 FOR_EACH_PHI_OR_STMT_DEF (def_p
, stmt
, op_iter
, SSA_OP_DEF
)
534 tree var
= DEF_FROM_PTR (def_p
);
536 if (TREE_CODE (var
) != SSA_NAME
)
539 FOR_EACH_IMM_USE_STMT (use_stmt
, imm_iter
, var
)
541 if (!gimple_debug_bind_p (use_stmt
))
544 gimple_debug_bind_reset_value (use_stmt
);
545 update_stmt (use_stmt
);
550 /* Delete SSA DEFs for SSA versions in the TOREMOVE bitmap, removing
551 dominated stmts before their dominators, so that release_ssa_defs
552 stands a chance of propagating DEFs into debug bind stmts. */
555 release_defs_bitset (bitmap toremove
)
560 /* Performing a topological sort is probably overkill, this will
561 most likely run in slightly superlinear time, rather than the
562 pathological quadratic worst case.
563 But iterate from max SSA name version to min one because
564 that mimics allocation order during code generation behavior best.
565 Use an array for this which we compact on-the-fly with a NULL
566 marker moving towards the end of the vector. */
567 auto_vec
<tree
, 16> names
;
568 names
.reserve (bitmap_count_bits (toremove
) + 1);
569 names
.quick_push (NULL_TREE
);
570 EXECUTE_IF_SET_IN_BITMAP (toremove
, 0, j
, bi
)
571 names
.quick_push (ssa_name (j
));
573 bitmap_tree_view (toremove
);
574 while (!bitmap_empty_p (toremove
))
576 j
= names
.length () - 1;
577 for (unsigned i
= names
.length () - 1; names
[i
];)
579 bool remove_now
= true;
582 imm_use_iterator uit
;
584 FOR_EACH_IMM_USE_STMT (stmt
, uit
, var
)
589 /* We can't propagate PHI nodes into debug stmts. */
590 if (gimple_code (stmt
) == GIMPLE_PHI
591 || is_gimple_debug (stmt
))
594 /* If we find another definition to remove that uses
595 the one we're looking at, defer the removal of this
596 one, so that it can be propagated into debug stmts
597 after the other is. */
598 FOR_EACH_SSA_DEF_OPERAND (def_p
, stmt
, dit
, SSA_OP_DEF
)
600 tree odef
= DEF_FROM_PTR (def_p
);
602 if (bitmap_bit_p (toremove
, SSA_NAME_VERSION (odef
)))
610 BREAK_FROM_IMM_USE_STMT (uit
);
615 gimple
*def
= SSA_NAME_DEF_STMT (var
);
616 gimple_stmt_iterator gsi
= gsi_for_stmt (def
);
618 if (gimple_code (def
) == GIMPLE_PHI
)
619 remove_phi_node (&gsi
, true);
622 gsi_remove (&gsi
, true);
625 bitmap_clear_bit (toremove
, SSA_NAME_VERSION (var
));
633 bitmap_list_view (toremove
);
636 /* Disable warnings about missing quoting in GCC diagnostics for
637 the verification errors. Their format strings don't follow GCC
638 diagnostic conventions and the calls are ultimately followed by
639 one to internal_error. */
641 # pragma GCC diagnostic push
642 # pragma GCC diagnostic ignored "-Wformat-diag"
645 /* Verify virtual SSA form. */
648 verify_vssa (basic_block bb
, tree current_vdef
, sbitmap visited
)
652 if (bitmap_bit_p (visited
, bb
->index
))
655 bitmap_set_bit (visited
, bb
->index
);
657 /* Pick up the single virtual PHI def. */
659 for (gphi_iterator si
= gsi_start_phis (bb
); !gsi_end_p (si
);
662 tree res
= gimple_phi_result (si
.phi ());
663 if (virtual_operand_p (res
))
667 error ("multiple virtual PHI nodes in BB %d", bb
->index
);
668 print_gimple_stmt (stderr
, phi
, 0);
669 print_gimple_stmt (stderr
, si
.phi (), 0);
678 current_vdef
= gimple_phi_result (phi
);
679 if (TREE_CODE (current_vdef
) != SSA_NAME
)
681 error ("virtual definition is not an SSA name");
682 print_gimple_stmt (stderr
, phi
, 0);
688 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
);
691 gimple
*stmt
= gsi_stmt (gsi
);
692 tree vuse
= gimple_vuse (stmt
);
695 if (vuse
!= current_vdef
)
697 error ("stmt with wrong VUSE");
698 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
);
699 fprintf (stderr
, "expected ");
700 print_generic_expr (stderr
, current_vdef
);
701 fprintf (stderr
, "\n");
704 tree vdef
= gimple_vdef (stmt
);
708 if (TREE_CODE (current_vdef
) != SSA_NAME
)
710 error ("virtual definition is not an SSA name");
711 print_gimple_stmt (stderr
, phi
, 0);
718 /* Verify destination PHI uses and recurse. */
721 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
723 gphi
*phi
= get_virtual_phi (e
->dest
);
725 && PHI_ARG_DEF_FROM_EDGE (phi
, e
) != current_vdef
)
727 error ("PHI node with wrong VUSE on edge from BB %d",
729 print_gimple_stmt (stderr
, phi
, 0, TDF_VOPS
);
730 fprintf (stderr
, "expected ");
731 print_generic_expr (stderr
, current_vdef
);
732 fprintf (stderr
, "\n");
737 err
|= verify_vssa (e
->dest
, current_vdef
, visited
);
743 /* Return true if SSA_NAME is malformed and mark it visited.
745 IS_VIRTUAL is true if this SSA_NAME was found inside a virtual
749 verify_ssa_name (tree ssa_name
, bool is_virtual
)
751 if (TREE_CODE (ssa_name
) != SSA_NAME
)
753 error ("expected an SSA_NAME object");
757 if (SSA_NAME_IN_FREE_LIST (ssa_name
))
759 error ("found an SSA_NAME that had been released into the free pool");
763 if (SSA_NAME_VAR (ssa_name
) != NULL_TREE
764 && TREE_TYPE (ssa_name
) != TREE_TYPE (SSA_NAME_VAR (ssa_name
)))
766 error ("type mismatch between an SSA_NAME and its symbol");
770 if (is_virtual
&& !virtual_operand_p (ssa_name
))
772 error ("found a virtual definition for a GIMPLE register");
776 if (is_virtual
&& SSA_NAME_VAR (ssa_name
) != gimple_vop (cfun
))
778 error ("virtual SSA name for non-VOP decl");
782 if (!is_virtual
&& virtual_operand_p (ssa_name
))
784 error ("found a real definition for a non-register");
788 if (SSA_NAME_IS_DEFAULT_DEF (ssa_name
)
789 && !gimple_nop_p (SSA_NAME_DEF_STMT (ssa_name
)))
791 error ("found a default name with a non-empty defining statement");
799 /* Return true if the definition of SSA_NAME at block BB is malformed.
801 STMT is the statement where SSA_NAME is created.
803 DEFINITION_BLOCK is an array of basic blocks indexed by SSA_NAME
804 version numbers. If DEFINITION_BLOCK[SSA_NAME_VERSION] is set,
805 it means that the block in that array slot contains the
806 definition of SSA_NAME.
808 IS_VIRTUAL is true if SSA_NAME is created by a VDEF. */
811 verify_def (basic_block bb
, basic_block
*definition_block
, tree ssa_name
,
812 gimple
*stmt
, bool is_virtual
)
814 if (verify_ssa_name (ssa_name
, is_virtual
))
817 if (SSA_NAME_VAR (ssa_name
)
818 && TREE_CODE (SSA_NAME_VAR (ssa_name
)) == RESULT_DECL
819 && DECL_BY_REFERENCE (SSA_NAME_VAR (ssa_name
)))
821 error ("RESULT_DECL should be read only when DECL_BY_REFERENCE is set");
825 if (definition_block
[SSA_NAME_VERSION (ssa_name
)])
827 error ("SSA_NAME created in two different blocks %i and %i",
828 definition_block
[SSA_NAME_VERSION (ssa_name
)]->index
, bb
->index
);
832 definition_block
[SSA_NAME_VERSION (ssa_name
)] = bb
;
834 if (SSA_NAME_DEF_STMT (ssa_name
) != stmt
)
836 error ("SSA_NAME_DEF_STMT is wrong");
837 fprintf (stderr
, "Expected definition statement:\n");
838 print_gimple_stmt (stderr
, SSA_NAME_DEF_STMT (ssa_name
), 4, TDF_VOPS
);
839 fprintf (stderr
, "\nActual definition statement:\n");
840 print_gimple_stmt (stderr
, stmt
, 4, TDF_VOPS
);
847 fprintf (stderr
, "while verifying SSA_NAME ");
848 print_generic_expr (stderr
, ssa_name
);
849 fprintf (stderr
, " in statement\n");
850 print_gimple_stmt (stderr
, stmt
, 4, TDF_VOPS
);
856 /* Return true if the use of SSA_NAME at statement STMT in block BB is
859 DEF_BB is the block where SSA_NAME was found to be created.
861 IDOM contains immediate dominator information for the flowgraph.
863 CHECK_ABNORMAL is true if the caller wants to check whether this use
864 is flowing through an abnormal edge (only used when checking PHI
867 If NAMES_DEFINED_IN_BB is not NULL, it contains a bitmap of ssa names
868 that are defined before STMT in basic block BB. */
871 verify_use (basic_block bb
, basic_block def_bb
, use_operand_p use_p
,
872 gimple
*stmt
, bool check_abnormal
, bitmap names_defined_in_bb
)
875 tree ssa_name
= USE_FROM_PTR (use_p
);
877 if (!TREE_VISITED (ssa_name
))
878 if (verify_imm_links (stderr
, ssa_name
))
881 TREE_VISITED (ssa_name
) = 1;
883 if (gimple_nop_p (SSA_NAME_DEF_STMT (ssa_name
))
884 && SSA_NAME_IS_DEFAULT_DEF (ssa_name
))
885 ; /* Default definitions have empty statements. Nothing to do. */
888 error ("missing definition");
891 else if (bb
!= def_bb
892 && !dominated_by_p (CDI_DOMINATORS
, bb
, def_bb
))
894 error ("definition in block %i does not dominate use in block %i",
895 def_bb
->index
, bb
->index
);
898 else if (bb
== def_bb
899 && names_defined_in_bb
!= NULL
900 && !bitmap_bit_p (names_defined_in_bb
, SSA_NAME_VERSION (ssa_name
)))
902 error ("definition in block %i follows the use", def_bb
->index
);
907 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ssa_name
))
909 error ("SSA_NAME_OCCURS_IN_ABNORMAL_PHI should be set");
913 /* Make sure the use is in an appropriate list by checking the previous
914 element to make sure it's the same. */
915 if (use_p
->prev
== NULL
)
917 error ("no immediate_use list");
923 if (use_p
->prev
->use
== NULL
)
924 listvar
= use_p
->prev
->loc
.ssa_name
;
926 listvar
= USE_FROM_PTR (use_p
->prev
);
927 if (listvar
!= ssa_name
)
929 error ("wrong immediate use list");
936 fprintf (stderr
, "for SSA_NAME: ");
937 print_generic_expr (stderr
, ssa_name
, TDF_VOPS
);
938 fprintf (stderr
, " in statement:\n");
939 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
);
946 /* Return true if any of the arguments for PHI node PHI at block BB is
949 DEFINITION_BLOCK is an array of basic blocks indexed by SSA_NAME
950 version numbers. If DEFINITION_BLOCK[SSA_NAME_VERSION] is set,
951 it means that the block in that array slot contains the
952 definition of SSA_NAME. */
955 verify_phi_args (gphi
*phi
, basic_block bb
, basic_block
*definition_block
)
959 size_t i
, phi_num_args
= gimple_phi_num_args (phi
);
961 if (EDGE_COUNT (bb
->preds
) != phi_num_args
)
963 error ("incoming edge count does not match number of PHI arguments");
968 for (i
= 0; i
< phi_num_args
; i
++)
970 use_operand_p op_p
= gimple_phi_arg_imm_use_ptr (phi
, i
);
971 tree op
= USE_FROM_PTR (op_p
);
973 e
= EDGE_PRED (bb
, i
);
977 error ("PHI argument is missing for edge %d->%d",
984 if (TREE_CODE (op
) != SSA_NAME
&& !is_gimple_min_invariant (op
))
986 error ("PHI argument is not SSA_NAME, or invariant");
990 if (TREE_CODE (op
) == SSA_NAME
)
992 err
= verify_ssa_name (op
, virtual_operand_p (gimple_phi_result (phi
)));
993 err
|= verify_use (e
->src
, definition_block
[SSA_NAME_VERSION (op
)],
994 op_p
, phi
, e
->flags
& EDGE_ABNORMAL
, NULL
);
997 if (TREE_CODE (op
) == ADDR_EXPR
)
999 tree base
= TREE_OPERAND (op
, 0);
1000 while (handled_component_p (base
))
1001 base
= TREE_OPERAND (base
, 0);
1003 || TREE_CODE (base
) == PARM_DECL
1004 || TREE_CODE (base
) == RESULT_DECL
)
1005 && !TREE_ADDRESSABLE (base
))
1007 error ("address taken, but ADDRESSABLE bit not set");
1014 error ("wrong edge %d->%d for PHI argument",
1015 e
->src
->index
, e
->dest
->index
);
1021 fprintf (stderr
, "PHI argument\n");
1022 print_generic_stmt (stderr
, op
, TDF_VOPS
);
1030 fprintf (stderr
, "for PHI node\n");
1031 print_gimple_stmt (stderr
, phi
, 0, TDF_VOPS
|TDF_MEMSYMS
);
1039 /* Verify common invariants in the SSA web.
1040 TODO: verify the variable annotations. */
1043 verify_ssa (bool check_modified_stmt
, bool check_ssa_operands
)
1046 basic_block
*definition_block
= XCNEWVEC (basic_block
, num_ssa_names
);
1049 enum dom_state orig_dom_state
= dom_info_state (CDI_DOMINATORS
);
1050 auto_bitmap names_defined_in_bb
;
1052 gcc_assert (!need_ssa_update_p (cfun
));
1054 timevar_push (TV_TREE_SSA_VERIFY
);
1057 /* Keep track of SSA names present in the IL. */
1060 hash_map
<void *, tree
> ssa_info
;
1062 FOR_EACH_SSA_NAME (i
, name
, cfun
)
1065 TREE_VISITED (name
) = 0;
1067 verify_ssa_name (name
, virtual_operand_p (name
));
1069 stmt
= SSA_NAME_DEF_STMT (name
);
1070 if (!gimple_nop_p (stmt
))
1072 basic_block bb
= gimple_bb (stmt
);
1073 if (verify_def (bb
, definition_block
,
1074 name
, stmt
, virtual_operand_p (name
)))
1079 if (POINTER_TYPE_P (TREE_TYPE (name
)))
1080 info
= SSA_NAME_PTR_INFO (name
);
1081 else if (INTEGRAL_TYPE_P (TREE_TYPE (name
)))
1082 info
= SSA_NAME_RANGE_INFO (name
);
1086 tree
&val
= ssa_info
.get_or_insert (info
, &existed
);
1089 error ("shared SSA name info");
1090 print_generic_expr (stderr
, val
);
1091 fprintf (stderr
, " and ");
1092 print_generic_expr (stderr
, name
);
1093 fprintf (stderr
, "\n");
1102 calculate_dominance_info (CDI_DOMINATORS
);
1104 /* Now verify all the uses and make sure they agree with the definitions
1105 found in the previous pass. */
1106 FOR_EACH_BB_FN (bb
, cfun
)
1111 /* Make sure that all edges have a clear 'aux' field. */
1112 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
1116 error ("AUX pointer initialized for edge %d->%d", e
->src
->index
,
1122 /* Verify the arguments for every PHI node in the block. */
1123 for (gphi_iterator gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1125 gphi
*phi
= gsi
.phi ();
1126 if (verify_phi_args (phi
, bb
, definition_block
))
1129 bitmap_set_bit (names_defined_in_bb
,
1130 SSA_NAME_VERSION (gimple_phi_result (phi
)));
1133 /* Now verify all the uses and vuses in every statement of the block. */
1134 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
);
1137 gimple
*stmt
= gsi_stmt (gsi
);
1138 use_operand_p use_p
;
1140 if (check_modified_stmt
&& gimple_modified_p (stmt
))
1142 error ("stmt (%p) marked modified after optimization pass: ",
1144 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
);
1148 if (check_ssa_operands
&& verify_ssa_operands (cfun
, stmt
))
1150 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
);
1154 if (gimple_debug_bind_p (stmt
)
1155 && !gimple_debug_bind_has_value_p (stmt
))
1158 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_USE
|SSA_OP_VUSE
)
1160 op
= USE_FROM_PTR (use_p
);
1161 if (verify_use (bb
, definition_block
[SSA_NAME_VERSION (op
)],
1162 use_p
, stmt
, false, names_defined_in_bb
))
1166 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, iter
, SSA_OP_ALL_DEFS
)
1168 if (SSA_NAME_DEF_STMT (op
) != stmt
)
1170 error ("SSA_NAME_DEF_STMT is wrong");
1171 fprintf (stderr
, "Expected definition statement:\n");
1172 print_gimple_stmt (stderr
, stmt
, 4, TDF_VOPS
);
1173 fprintf (stderr
, "\nActual definition statement:\n");
1174 print_gimple_stmt (stderr
, SSA_NAME_DEF_STMT (op
),
1178 bitmap_set_bit (names_defined_in_bb
, SSA_NAME_VERSION (op
));
1182 bitmap_clear (names_defined_in_bb
);
1185 free (definition_block
);
1187 if (gimple_vop (cfun
)
1188 && ssa_default_def (cfun
, gimple_vop (cfun
)))
1190 auto_sbitmap
visited (last_basic_block_for_fn (cfun
) + 1);
1191 bitmap_clear (visited
);
1192 if (verify_vssa (ENTRY_BLOCK_PTR_FOR_FN (cfun
),
1193 ssa_default_def (cfun
, gimple_vop (cfun
)), visited
))
1197 /* Restore the dominance information to its prior known state, so
1198 that we do not perturb the compiler's subsequent behavior. */
1199 if (orig_dom_state
== DOM_NONE
)
1200 free_dominance_info (CDI_DOMINATORS
);
1202 set_dom_info_availability (CDI_DOMINATORS
, orig_dom_state
);
1204 timevar_pop (TV_TREE_SSA_VERIFY
);
1208 internal_error ("verify_ssa failed");
1212 # pragma GCC diagnostic pop
1215 /* Initialize global DFA and SSA structures. */
1218 init_tree_ssa (struct function
*fn
)
1220 fn
->gimple_df
= ggc_cleared_alloc
<gimple_df
> ();
1221 fn
->gimple_df
->default_defs
= hash_table
<ssa_name_hasher
>::create_ggc (20);
1222 pt_solution_reset (&fn
->gimple_df
->escaped
);
1223 init_ssanames (fn
, 0);
1226 /* Deallocate memory associated with SSA data structures for FNDECL. */
1229 delete_tree_ssa (struct function
*fn
)
1233 /* We no longer maintain the SSA operand cache at this point. */
1234 if (ssa_operands_active (fn
))
1235 fini_ssa_operands (fn
);
1237 fn
->gimple_df
->default_defs
->empty ();
1238 fn
->gimple_df
->default_defs
= NULL
;
1239 pt_solution_reset (&fn
->gimple_df
->escaped
);
1240 if (fn
->gimple_df
->decls_to_pointers
!= NULL
)
1241 delete fn
->gimple_df
->decls_to_pointers
;
1242 fn
->gimple_df
->decls_to_pointers
= NULL
;
1243 fn
->gimple_df
= NULL
;
1245 /* We no longer need the edge variable maps. */
1246 redirect_edge_var_map_empty ();
1249 /* Return true if EXPR is a useless type conversion, otherwise return
1253 tree_ssa_useless_type_conversion (tree expr
)
1255 /* If we have an assignment that merely uses a NOP_EXPR to change
1256 the top of the RHS to the type of the LHS and the type conversion
1257 is "safe", then strip away the type conversion so that we can
1258 enter LHS = RHS into the const_and_copies table. */
1259 if (CONVERT_EXPR_P (expr
)
1260 || TREE_CODE (expr
) == VIEW_CONVERT_EXPR
1261 || TREE_CODE (expr
) == NON_LVALUE_EXPR
)
1262 return useless_type_conversion_p
1264 TREE_TYPE (TREE_OPERAND (expr
, 0)));
1269 /* Strip conversions from EXP according to
1270 tree_ssa_useless_type_conversion and return the resulting
1274 tree_ssa_strip_useless_type_conversions (tree exp
)
1276 while (tree_ssa_useless_type_conversion (exp
))
1277 exp
= TREE_OPERAND (exp
, 0);
1281 /* Return true if T, as SSA_NAME, has an implicit default defined value. */
1284 ssa_defined_default_def_p (tree t
)
1286 tree var
= SSA_NAME_VAR (t
);
1290 /* Parameters get their initial value from the function entry. */
1291 else if (TREE_CODE (var
) == PARM_DECL
)
1293 /* When returning by reference the return address is actually a hidden
1295 else if (TREE_CODE (var
) == RESULT_DECL
&& DECL_BY_REFERENCE (var
))
1297 /* Hard register variables get their initial value from the ether. */
1298 else if (VAR_P (var
) && DECL_HARD_REGISTER (var
))
1305 /* Return true if T, an SSA_NAME, has an undefined value. PARTIAL is what
1306 should be returned if the value is only partially undefined. */
1309 ssa_undefined_value_p (tree t
, bool partial
)
1313 if (ssa_defined_default_def_p (t
))
1316 /* The value is undefined iff its definition statement is empty. */
1317 def_stmt
= SSA_NAME_DEF_STMT (t
);
1318 if (gimple_nop_p (def_stmt
))
1321 /* Check if the complex was not only partially defined. */
1322 if (partial
&& is_gimple_assign (def_stmt
)
1323 && gimple_assign_rhs_code (def_stmt
) == COMPLEX_EXPR
)
1327 rhs1
= gimple_assign_rhs1 (def_stmt
);
1328 rhs2
= gimple_assign_rhs2 (def_stmt
);
1329 return (TREE_CODE (rhs1
) == SSA_NAME
&& ssa_undefined_value_p (rhs1
))
1330 || (TREE_CODE (rhs2
) == SSA_NAME
&& ssa_undefined_value_p (rhs2
));
1336 /* Return TRUE iff STMT, a gimple statement, references an undefined
1340 gimple_uses_undefined_value_p (gimple
*stmt
)
1345 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, iter
, SSA_OP_USE
)
1346 if (ssa_undefined_value_p (op
))
1354 /* If necessary, rewrite the base of the reference tree *TP from
1355 a MEM_REF to a plain or converted symbol. */
1358 maybe_rewrite_mem_ref_base (tree
*tp
, bitmap suitable_for_renaming
)
1362 while (handled_component_p (*tp
))
1363 tp
= &TREE_OPERAND (*tp
, 0);
1364 if (TREE_CODE (*tp
) == MEM_REF
1365 && TREE_CODE (TREE_OPERAND (*tp
, 0)) == ADDR_EXPR
1366 && (sym
= TREE_OPERAND (TREE_OPERAND (*tp
, 0), 0))
1368 && !TREE_ADDRESSABLE (sym
)
1369 && bitmap_bit_p (suitable_for_renaming
, DECL_UID (sym
))
1370 && is_gimple_reg_type (TREE_TYPE (*tp
))
1371 && ! VOID_TYPE_P (TREE_TYPE (*tp
)))
1373 if (TREE_CODE (TREE_TYPE (sym
)) == VECTOR_TYPE
1374 && useless_type_conversion_p (TREE_TYPE (*tp
),
1375 TREE_TYPE (TREE_TYPE (sym
)))
1376 && multiple_of_p (sizetype
, TREE_OPERAND (*tp
, 1),
1377 TYPE_SIZE_UNIT (TREE_TYPE (*tp
))))
1379 *tp
= build3 (BIT_FIELD_REF
, TREE_TYPE (*tp
), sym
,
1380 TYPE_SIZE (TREE_TYPE (*tp
)),
1381 int_const_binop (MULT_EXPR
,
1382 bitsize_int (BITS_PER_UNIT
),
1383 TREE_OPERAND (*tp
, 1)));
1385 else if (TREE_CODE (TREE_TYPE (sym
)) == COMPLEX_TYPE
1386 && useless_type_conversion_p (TREE_TYPE (*tp
),
1387 TREE_TYPE (TREE_TYPE (sym
))))
1389 *tp
= build1 (integer_zerop (TREE_OPERAND (*tp
, 1))
1390 ? REALPART_EXPR
: IMAGPART_EXPR
,
1391 TREE_TYPE (*tp
), sym
);
1393 else if (integer_zerop (TREE_OPERAND (*tp
, 1))
1394 && DECL_SIZE (sym
) == TYPE_SIZE (TREE_TYPE (*tp
)))
1396 if (!useless_type_conversion_p (TREE_TYPE (*tp
),
1398 *tp
= build1 (VIEW_CONVERT_EXPR
,
1399 TREE_TYPE (*tp
), sym
);
1403 else if (DECL_SIZE (sym
)
1404 && TREE_CODE (DECL_SIZE (sym
)) == INTEGER_CST
1405 && (known_subrange_p
1406 (mem_ref_offset (*tp
),
1407 wi::to_offset (TYPE_SIZE_UNIT (TREE_TYPE (*tp
))),
1408 0, wi::to_offset (DECL_SIZE_UNIT (sym
))))
1409 && (! INTEGRAL_TYPE_P (TREE_TYPE (*tp
))
1410 || (wi::to_offset (TYPE_SIZE (TREE_TYPE (*tp
)))
1411 == TYPE_PRECISION (TREE_TYPE (*tp
))))
1412 && wi::umod_trunc (wi::to_offset (TYPE_SIZE (TREE_TYPE (*tp
))),
1413 BITS_PER_UNIT
) == 0)
1415 *tp
= build3 (BIT_FIELD_REF
, TREE_TYPE (*tp
), sym
,
1416 TYPE_SIZE (TREE_TYPE (*tp
)),
1417 wide_int_to_tree (bitsizetype
,
1418 mem_ref_offset (*tp
)
1419 << LOG2_BITS_PER_UNIT
));
1424 /* For a tree REF return its base if it is the base of a MEM_REF
1425 that cannot be rewritten into SSA form. Otherwise return NULL_TREE. */
1428 non_rewritable_mem_ref_base (tree ref
)
1432 /* A plain decl does not need it set. */
1436 if (! (base
= CONST_CAST_TREE (strip_invariant_refs (ref
))))
1438 base
= get_base_address (ref
);
1444 /* But watch out for MEM_REFs we cannot lower to a
1445 VIEW_CONVERT_EXPR or a BIT_FIELD_REF. */
1446 if (TREE_CODE (base
) == MEM_REF
1447 && TREE_CODE (TREE_OPERAND (base
, 0)) == ADDR_EXPR
)
1449 tree decl
= TREE_OPERAND (TREE_OPERAND (base
, 0), 0);
1450 if (! DECL_P (decl
))
1452 if (! is_gimple_reg_type (TREE_TYPE (base
))
1453 || VOID_TYPE_P (TREE_TYPE (base
))
1454 || TREE_THIS_VOLATILE (decl
) != TREE_THIS_VOLATILE (base
))
1456 if ((TREE_CODE (TREE_TYPE (decl
)) == VECTOR_TYPE
1457 || TREE_CODE (TREE_TYPE (decl
)) == COMPLEX_TYPE
)
1458 && useless_type_conversion_p (TREE_TYPE (base
),
1459 TREE_TYPE (TREE_TYPE (decl
)))
1460 && known_ge (mem_ref_offset (base
), 0)
1461 && known_gt (wi::to_poly_offset (TYPE_SIZE_UNIT (TREE_TYPE (decl
))),
1462 mem_ref_offset (base
))
1463 && multiple_of_p (sizetype
, TREE_OPERAND (base
, 1),
1464 TYPE_SIZE_UNIT (TREE_TYPE (base
))))
1466 /* For same sizes and zero offset we can use a VIEW_CONVERT_EXPR. */
1467 if (integer_zerop (TREE_OPERAND (base
, 1))
1468 && DECL_SIZE (decl
) == TYPE_SIZE (TREE_TYPE (base
)))
1470 /* For integral typed extracts we can use a BIT_FIELD_REF. */
1471 if (DECL_SIZE (decl
)
1472 && TREE_CODE (DECL_SIZE_UNIT (decl
)) == INTEGER_CST
1473 && (known_subrange_p
1474 (mem_ref_offset (base
),
1475 wi::to_poly_offset (TYPE_SIZE_UNIT (TREE_TYPE (base
))),
1476 0, wi::to_poly_offset (DECL_SIZE_UNIT (decl
))))
1477 /* ??? We can't handle bitfield precision extracts without
1478 either using an alternate type for the BIT_FIELD_REF and
1479 then doing a conversion or possibly adjusting the offset
1480 according to endianness. */
1481 && (! INTEGRAL_TYPE_P (TREE_TYPE (base
))
1482 || (wi::to_offset (TYPE_SIZE (TREE_TYPE (base
)))
1483 == TYPE_PRECISION (TREE_TYPE (base
))))
1484 && wi::umod_trunc (wi::to_offset (TYPE_SIZE (TREE_TYPE (base
))),
1485 BITS_PER_UNIT
) == 0)
1493 /* For an lvalue tree LHS return true if it cannot be rewritten into SSA form.
1494 Otherwise return true. */
1497 non_rewritable_lvalue_p (tree lhs
)
1499 /* A plain decl is always rewritable. */
1503 /* We can re-write REALPART_EXPR and IMAGPART_EXPR sets in
1504 a reasonably efficient manner... */
1505 if ((TREE_CODE (lhs
) == REALPART_EXPR
1506 || TREE_CODE (lhs
) == IMAGPART_EXPR
)
1507 && DECL_P (TREE_OPERAND (lhs
, 0)))
1510 /* ??? The following could be relaxed allowing component
1511 references that do not change the access size. */
1512 if (TREE_CODE (lhs
) == MEM_REF
1513 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == ADDR_EXPR
)
1515 tree decl
= TREE_OPERAND (TREE_OPERAND (lhs
, 0), 0);
1517 /* A decl that is wrapped inside a MEM-REF that covers
1518 it full is also rewritable. */
1519 if (integer_zerop (TREE_OPERAND (lhs
, 1))
1521 && DECL_SIZE (decl
) == TYPE_SIZE (TREE_TYPE (lhs
))
1522 /* If the dynamic type of the decl has larger precision than
1523 the decl itself we can't use the decls type for SSA rewriting. */
1524 && ((! INTEGRAL_TYPE_P (TREE_TYPE (decl
))
1525 || compare_tree_int (DECL_SIZE (decl
),
1526 TYPE_PRECISION (TREE_TYPE (decl
))) == 0)
1527 || (INTEGRAL_TYPE_P (TREE_TYPE (lhs
))
1528 && (TYPE_PRECISION (TREE_TYPE (decl
))
1529 >= TYPE_PRECISION (TREE_TYPE (lhs
)))))
1530 /* Make sure we are not re-writing non-float copying into float
1531 copying as that can incur normalization. */
1532 && (! FLOAT_TYPE_P (TREE_TYPE (decl
))
1533 || types_compatible_p (TREE_TYPE (lhs
), TREE_TYPE (decl
)))
1534 && (TREE_THIS_VOLATILE (decl
) == TREE_THIS_VOLATILE (lhs
)))
1537 /* A vector-insert using a MEM_REF or ARRAY_REF is rewritable
1538 using a BIT_INSERT_EXPR. */
1540 && VECTOR_TYPE_P (TREE_TYPE (decl
))
1541 && TYPE_MODE (TREE_TYPE (decl
)) != BLKmode
1542 && known_ge (mem_ref_offset (lhs
), 0)
1543 && known_gt (wi::to_poly_offset (TYPE_SIZE_UNIT (TREE_TYPE (decl
))),
1544 mem_ref_offset (lhs
))
1545 && multiple_of_p (sizetype
, TREE_OPERAND (lhs
, 1),
1546 TYPE_SIZE_UNIT (TREE_TYPE (lhs
))))
1548 poly_uint64 lhs_bits
, nelts
;
1549 if (poly_int_tree_p (TYPE_SIZE (TREE_TYPE (lhs
)), &lhs_bits
)
1550 && multiple_p (lhs_bits
,
1552 (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl
)))),
1555 if (known_eq (nelts
, 1u))
1557 /* For sub-vector inserts the insert vector mode has to be
1559 tree vtype
= build_vector_type (TREE_TYPE (TREE_TYPE (decl
)),
1561 if (TYPE_MODE (vtype
) != BLKmode
)
1567 /* A vector-insert using a BIT_FIELD_REF is rewritable using
1569 if (TREE_CODE (lhs
) == BIT_FIELD_REF
1570 && DECL_P (TREE_OPERAND (lhs
, 0))
1571 && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (lhs
, 0)))
1572 && TYPE_MODE (TREE_TYPE (TREE_OPERAND (lhs
, 0))) != BLKmode
1573 && operand_equal_p (TYPE_SIZE_UNIT (TREE_TYPE (lhs
)),
1575 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (lhs
, 0)))), 0)
1576 && (tree_to_uhwi (TREE_OPERAND (lhs
, 2))
1577 % tree_to_uhwi (TYPE_SIZE (TREE_TYPE (lhs
)))) == 0)
1583 /* When possible, clear TREE_ADDRESSABLE bit or set DECL_GIMPLE_REG_P bit and
1584 mark the variable VAR for conversion into SSA. Return true when updating
1585 stmts is required. */
1588 maybe_optimize_var (tree var
, bitmap addresses_taken
, bitmap not_reg_needs
,
1589 bitmap suitable_for_renaming
)
1591 /* Global Variables, result decls cannot be changed. */
1592 if (is_global_var (var
)
1593 || TREE_CODE (var
) == RESULT_DECL
1594 || bitmap_bit_p (addresses_taken
, DECL_UID (var
)))
1597 if (TREE_ADDRESSABLE (var
)
1598 /* Do not change TREE_ADDRESSABLE if we need to preserve var as
1599 a non-register. Otherwise we are confused and forget to
1600 add virtual operands for it. */
1601 && (!is_gimple_reg_type (TREE_TYPE (var
))
1602 || TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
1603 || TREE_CODE (TREE_TYPE (var
)) == COMPLEX_TYPE
1604 || !bitmap_bit_p (not_reg_needs
, DECL_UID (var
))))
1606 TREE_ADDRESSABLE (var
) = 0;
1607 /* If we cleared TREE_ADDRESSABLE make sure DECL_GIMPLE_REG_P
1608 is unset if we cannot rewrite the var into SSA. */
1609 if ((TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
1610 || TREE_CODE (TREE_TYPE (var
)) == COMPLEX_TYPE
)
1611 && bitmap_bit_p (not_reg_needs
, DECL_UID (var
)))
1612 DECL_GIMPLE_REG_P (var
) = 0;
1613 if (is_gimple_reg (var
))
1614 bitmap_set_bit (suitable_for_renaming
, DECL_UID (var
));
1617 fprintf (dump_file
, "No longer having address taken: ");
1618 print_generic_expr (dump_file
, var
);
1619 fprintf (dump_file
, "\n");
1623 if (!DECL_GIMPLE_REG_P (var
)
1624 && !bitmap_bit_p (not_reg_needs
, DECL_UID (var
))
1625 && (TREE_CODE (TREE_TYPE (var
)) == COMPLEX_TYPE
1626 || TREE_CODE (TREE_TYPE (var
)) == VECTOR_TYPE
)
1627 && !TREE_THIS_VOLATILE (var
)
1628 && (!VAR_P (var
) || !DECL_HARD_REGISTER (var
)))
1630 DECL_GIMPLE_REG_P (var
) = 1;
1631 bitmap_set_bit (suitable_for_renaming
, DECL_UID (var
));
1634 fprintf (dump_file
, "Now a gimple register: ");
1635 print_generic_expr (dump_file
, var
);
1636 fprintf (dump_file
, "\n");
1641 /* Return true when STMT is ASAN mark where second argument is an address
1642 of a local variable. */
1645 is_asan_mark_p (gimple
*stmt
)
1647 if (!gimple_call_internal_p (stmt
, IFN_ASAN_MARK
))
1650 tree addr
= get_base_address (gimple_call_arg (stmt
, 1));
1651 if (TREE_CODE (addr
) == ADDR_EXPR
1652 && VAR_P (TREE_OPERAND (addr
, 0)))
1654 tree var
= TREE_OPERAND (addr
, 0);
1655 if (lookup_attribute (ASAN_USE_AFTER_SCOPE_ATTRIBUTE
,
1656 DECL_ATTRIBUTES (var
)))
1659 unsigned addressable
= TREE_ADDRESSABLE (var
);
1660 TREE_ADDRESSABLE (var
) = 0;
1661 bool r
= is_gimple_reg (var
);
1662 TREE_ADDRESSABLE (var
) = addressable
;
1669 /* Compute TREE_ADDRESSABLE and DECL_GIMPLE_REG_P for local variables. */
1672 execute_update_addresses_taken (void)
1675 auto_bitmap addresses_taken
;
1676 auto_bitmap not_reg_needs
;
1677 auto_bitmap suitable_for_renaming
;
1681 timevar_push (TV_ADDRESS_TAKEN
);
1683 /* Collect into ADDRESSES_TAKEN all variables whose address is taken within
1684 the function body. */
1685 FOR_EACH_BB_FN (bb
, cfun
)
1687 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
);
1690 gimple
*stmt
= gsi_stmt (gsi
);
1691 enum gimple_code code
= gimple_code (stmt
);
1694 if (code
== GIMPLE_CALL
)
1696 if (optimize_atomic_compare_exchange_p (stmt
))
1698 /* For __atomic_compare_exchange_N if the second argument
1699 is &var, don't mark var addressable;
1700 if it becomes non-addressable, we'll rewrite it into
1701 ATOMIC_COMPARE_EXCHANGE call. */
1702 tree arg
= gimple_call_arg (stmt
, 1);
1703 gimple_call_set_arg (stmt
, 1, null_pointer_node
);
1704 gimple_ior_addresses_taken (addresses_taken
, stmt
);
1705 gimple_call_set_arg (stmt
, 1, arg
);
1707 else if (is_asan_mark_p (stmt
)
1708 || gimple_call_internal_p (stmt
, IFN_GOMP_SIMT_ENTER
))
1711 gimple_ior_addresses_taken (addresses_taken
, stmt
);
1714 /* Note all addresses taken by the stmt. */
1715 gimple_ior_addresses_taken (addresses_taken
, stmt
);
1717 /* If we have a call or an assignment, see if the lhs contains
1718 a local decl that requires not to be a gimple register. */
1719 if (code
== GIMPLE_ASSIGN
|| code
== GIMPLE_CALL
)
1721 tree lhs
= gimple_get_lhs (stmt
);
1723 && TREE_CODE (lhs
) != SSA_NAME
1724 && ((code
== GIMPLE_CALL
&& ! DECL_P (lhs
))
1725 || non_rewritable_lvalue_p (lhs
)))
1727 decl
= get_base_address (lhs
);
1729 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1733 if (gimple_assign_single_p (stmt
))
1735 tree rhs
= gimple_assign_rhs1 (stmt
);
1736 if ((decl
= non_rewritable_mem_ref_base (rhs
)))
1737 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1740 else if (code
== GIMPLE_CALL
)
1742 for (i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
1744 tree arg
= gimple_call_arg (stmt
, i
);
1745 if ((decl
= non_rewritable_mem_ref_base (arg
)))
1746 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1750 else if (code
== GIMPLE_ASM
)
1752 gasm
*asm_stmt
= as_a
<gasm
*> (stmt
);
1753 for (i
= 0; i
< gimple_asm_noutputs (asm_stmt
); ++i
)
1755 tree link
= gimple_asm_output_op (asm_stmt
, i
);
1756 tree lhs
= TREE_VALUE (link
);
1757 if (TREE_CODE (lhs
) != SSA_NAME
)
1759 decl
= get_base_address (lhs
);
1761 && (non_rewritable_lvalue_p (lhs
)
1762 /* We cannot move required conversions from
1763 the lhs to the rhs in asm statements, so
1764 require we do not need any. */
1765 || !useless_type_conversion_p
1766 (TREE_TYPE (lhs
), TREE_TYPE (decl
))))
1767 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1770 for (i
= 0; i
< gimple_asm_ninputs (asm_stmt
); ++i
)
1772 tree link
= gimple_asm_input_op (asm_stmt
, i
);
1773 if ((decl
= non_rewritable_mem_ref_base (TREE_VALUE (link
))))
1774 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1779 for (gphi_iterator gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
);
1783 gphi
*phi
= gsi
.phi ();
1785 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
1787 tree op
= PHI_ARG_DEF (phi
, i
), var
;
1788 if (TREE_CODE (op
) == ADDR_EXPR
1789 && (var
= get_base_address (TREE_OPERAND (op
, 0))) != NULL
1791 bitmap_set_bit (addresses_taken
, DECL_UID (var
));
1796 /* We cannot iterate over all referenced vars because that can contain
1797 unused vars from BLOCK trees, which causes code generation differences
1799 for (var
= DECL_ARGUMENTS (cfun
->decl
); var
; var
= DECL_CHAIN (var
))
1800 maybe_optimize_var (var
, addresses_taken
, not_reg_needs
,
1801 suitable_for_renaming
);
1803 FOR_EACH_VEC_SAFE_ELT (cfun
->local_decls
, i
, var
)
1804 maybe_optimize_var (var
, addresses_taken
, not_reg_needs
,
1805 suitable_for_renaming
);
1807 /* Operand caches need to be recomputed for operands referencing the updated
1808 variables and operands need to be rewritten to expose bare symbols. */
1809 if (!bitmap_empty_p (suitable_for_renaming
))
1811 FOR_EACH_BB_FN (bb
, cfun
)
1812 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
);)
1814 gimple
*stmt
= gsi_stmt (gsi
);
1816 /* Re-write TARGET_MEM_REFs of symbols we want to
1817 rewrite into SSA form. */
1818 if (gimple_assign_single_p (stmt
))
1820 tree lhs
= gimple_assign_lhs (stmt
);
1821 tree rhs
, *rhsp
= gimple_assign_rhs1_ptr (stmt
);
1824 /* Rewrite LHS IMAG/REALPART_EXPR similar to
1825 gimplify_modify_expr_complex_part. */
1826 if ((TREE_CODE (lhs
) == IMAGPART_EXPR
1827 || TREE_CODE (lhs
) == REALPART_EXPR
)
1828 && DECL_P (TREE_OPERAND (lhs
, 0))
1829 && bitmap_bit_p (suitable_for_renaming
,
1830 DECL_UID (TREE_OPERAND (lhs
, 0))))
1832 tree other
= make_ssa_name (TREE_TYPE (lhs
));
1833 tree lrhs
= build1 (TREE_CODE (lhs
) == IMAGPART_EXPR
1834 ? REALPART_EXPR
: IMAGPART_EXPR
,
1836 TREE_OPERAND (lhs
, 0));
1837 gimple
*load
= gimple_build_assign (other
, lrhs
);
1838 location_t loc
= gimple_location (stmt
);
1839 gimple_set_location (load
, loc
);
1840 gimple_set_vuse (load
, gimple_vuse (stmt
));
1841 gsi_insert_before (&gsi
, load
, GSI_SAME_STMT
);
1842 gimple_assign_set_lhs (stmt
, TREE_OPERAND (lhs
, 0));
1843 gimple_assign_set_rhs_with_ops
1844 (&gsi
, COMPLEX_EXPR
,
1845 TREE_CODE (lhs
) == IMAGPART_EXPR
1846 ? other
: gimple_assign_rhs1 (stmt
),
1847 TREE_CODE (lhs
) == IMAGPART_EXPR
1848 ? gimple_assign_rhs1 (stmt
) : other
, NULL_TREE
);
1849 stmt
= gsi_stmt (gsi
);
1850 unlink_stmt_vdef (stmt
);
1855 /* Rewrite a vector insert via a BIT_FIELD_REF on the LHS
1856 into a BIT_INSERT_EXPR. */
1857 if (TREE_CODE (lhs
) == BIT_FIELD_REF
1858 && DECL_P (TREE_OPERAND (lhs
, 0))
1859 && bitmap_bit_p (suitable_for_renaming
,
1860 DECL_UID (TREE_OPERAND (lhs
, 0)))
1861 && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (lhs
, 0)))
1862 && TYPE_MODE (TREE_TYPE (TREE_OPERAND (lhs
, 0))) != BLKmode
1863 && operand_equal_p (TYPE_SIZE_UNIT (TREE_TYPE (lhs
)),
1864 TYPE_SIZE_UNIT (TREE_TYPE
1865 (TREE_TYPE (TREE_OPERAND (lhs
, 0)))),
1867 && (tree_to_uhwi (TREE_OPERAND (lhs
, 2))
1868 % tree_to_uhwi (TYPE_SIZE (TREE_TYPE (lhs
))) == 0))
1870 tree var
= TREE_OPERAND (lhs
, 0);
1871 tree val
= gimple_assign_rhs1 (stmt
);
1872 if (! types_compatible_p (TREE_TYPE (TREE_TYPE (var
)),
1875 tree tem
= make_ssa_name (TREE_TYPE (TREE_TYPE (var
)));
1877 = gimple_build_assign (tem
,
1878 build1 (VIEW_CONVERT_EXPR
,
1879 TREE_TYPE (tem
), val
));
1880 gsi_insert_before (&gsi
, pun
, GSI_SAME_STMT
);
1883 tree bitpos
= TREE_OPERAND (lhs
, 2);
1884 gimple_assign_set_lhs (stmt
, var
);
1885 gimple_assign_set_rhs_with_ops
1886 (&gsi
, BIT_INSERT_EXPR
, var
, val
, bitpos
);
1887 stmt
= gsi_stmt (gsi
);
1888 unlink_stmt_vdef (stmt
);
1893 /* Rewrite a vector insert using a MEM_REF on the LHS
1894 into a BIT_INSERT_EXPR. */
1895 if (TREE_CODE (lhs
) == MEM_REF
1896 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == ADDR_EXPR
1897 && (sym
= TREE_OPERAND (TREE_OPERAND (lhs
, 0), 0))
1899 && bitmap_bit_p (suitable_for_renaming
, DECL_UID (sym
))
1900 && VECTOR_TYPE_P (TREE_TYPE (sym
))
1901 && TYPE_MODE (TREE_TYPE (sym
)) != BLKmode
1902 /* If it is a full replacement we can do better below. */
1903 && maybe_ne (wi::to_poly_offset
1904 (TYPE_SIZE_UNIT (TREE_TYPE (lhs
))),
1906 (TYPE_SIZE_UNIT (TREE_TYPE (sym
))))
1907 && known_ge (mem_ref_offset (lhs
), 0)
1908 && known_gt (wi::to_poly_offset
1909 (TYPE_SIZE_UNIT (TREE_TYPE (sym
))),
1910 mem_ref_offset (lhs
))
1911 && multiple_of_p (sizetype
,
1912 TREE_OPERAND (lhs
, 1),
1913 TYPE_SIZE_UNIT (TREE_TYPE (lhs
))))
1915 tree val
= gimple_assign_rhs1 (stmt
);
1916 if (! types_compatible_p (TREE_TYPE (val
),
1917 TREE_TYPE (TREE_TYPE (sym
))))
1919 poly_uint64 lhs_bits
, nelts
;
1920 tree temtype
= TREE_TYPE (TREE_TYPE (sym
));
1921 if (poly_int_tree_p (TYPE_SIZE (TREE_TYPE (lhs
)),
1923 && multiple_p (lhs_bits
,
1925 (TYPE_SIZE (TREE_TYPE
1926 (TREE_TYPE (sym
)))),
1928 && maybe_ne (nelts
, 1u))
1929 temtype
= build_vector_type (temtype
, nelts
);
1930 tree tem
= make_ssa_name (temtype
);
1932 = gimple_build_assign (tem
,
1933 build1 (VIEW_CONVERT_EXPR
,
1934 TREE_TYPE (tem
), val
));
1935 gsi_insert_before (&gsi
, pun
, GSI_SAME_STMT
);
1939 = wide_int_to_tree (bitsizetype
,
1940 mem_ref_offset (lhs
) * BITS_PER_UNIT
);
1941 gimple_assign_set_lhs (stmt
, sym
);
1942 gimple_assign_set_rhs_with_ops
1943 (&gsi
, BIT_INSERT_EXPR
, sym
, val
, bitpos
);
1944 stmt
= gsi_stmt (gsi
);
1945 unlink_stmt_vdef (stmt
);
1950 /* We shouldn't have any fancy wrapping of
1951 component-refs on the LHS, but look through
1952 VIEW_CONVERT_EXPRs as that is easy. */
1953 while (TREE_CODE (lhs
) == VIEW_CONVERT_EXPR
)
1954 lhs
= TREE_OPERAND (lhs
, 0);
1955 if (TREE_CODE (lhs
) == MEM_REF
1956 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == ADDR_EXPR
1957 && integer_zerop (TREE_OPERAND (lhs
, 1))
1958 && (sym
= TREE_OPERAND (TREE_OPERAND (lhs
, 0), 0))
1960 && !TREE_ADDRESSABLE (sym
)
1961 && bitmap_bit_p (suitable_for_renaming
, DECL_UID (sym
)))
1964 lhs
= gimple_assign_lhs (stmt
);
1966 /* Rewrite the RHS and make sure the resulting assignment
1967 is validly typed. */
1968 maybe_rewrite_mem_ref_base (rhsp
, suitable_for_renaming
);
1969 rhs
= gimple_assign_rhs1 (stmt
);
1970 if (gimple_assign_lhs (stmt
) != lhs
1971 && !useless_type_conversion_p (TREE_TYPE (lhs
),
1974 if (gimple_clobber_p (stmt
))
1976 rhs
= build_constructor (TREE_TYPE (lhs
), NULL
);
1977 TREE_THIS_VOLATILE (rhs
) = 1;
1980 rhs
= fold_build1 (VIEW_CONVERT_EXPR
,
1981 TREE_TYPE (lhs
), rhs
);
1983 if (gimple_assign_lhs (stmt
) != lhs
)
1984 gimple_assign_set_lhs (stmt
, lhs
);
1986 if (gimple_assign_rhs1 (stmt
) != rhs
)
1988 gimple_stmt_iterator gsi
= gsi_for_stmt (stmt
);
1989 gimple_assign_set_rhs_from_tree (&gsi
, rhs
);
1993 else if (gimple_code (stmt
) == GIMPLE_CALL
)
1996 if (optimize_atomic_compare_exchange_p (stmt
))
1998 tree expected
= gimple_call_arg (stmt
, 1);
1999 if (bitmap_bit_p (suitable_for_renaming
,
2000 DECL_UID (TREE_OPERAND (expected
, 0))))
2002 fold_builtin_atomic_compare_exchange (&gsi
);
2006 else if (is_asan_mark_p (stmt
))
2008 tree var
= TREE_OPERAND (gimple_call_arg (stmt
, 1), 0);
2009 if (bitmap_bit_p (suitable_for_renaming
, DECL_UID (var
)))
2011 unlink_stmt_vdef (stmt
);
2012 if (asan_mark_p (stmt
, ASAN_MARK_POISON
))
2015 = gimple_build_call_internal (IFN_ASAN_POISON
, 0);
2016 gimple_call_set_lhs (call
, var
);
2017 gsi_replace (&gsi
, call
, GSI_SAME_STMT
);
2021 /* In ASAN_MARK (UNPOISON, &b, ...) the variable
2022 is uninitialized. Avoid dependencies on
2023 previous out of scope value. */
2024 tree clobber
= build_clobber (TREE_TYPE (var
));
2025 gimple
*g
= gimple_build_assign (var
, clobber
);
2026 gsi_replace (&gsi
, g
, GSI_SAME_STMT
);
2031 else if (gimple_call_internal_p (stmt
, IFN_GOMP_SIMT_ENTER
))
2032 for (i
= 1; i
< gimple_call_num_args (stmt
); i
++)
2034 tree
*argp
= gimple_call_arg_ptr (stmt
, i
);
2035 if (*argp
== null_pointer_node
)
2037 gcc_assert (TREE_CODE (*argp
) == ADDR_EXPR
2038 && VAR_P (TREE_OPERAND (*argp
, 0)));
2039 tree var
= TREE_OPERAND (*argp
, 0);
2040 if (bitmap_bit_p (suitable_for_renaming
, DECL_UID (var
)))
2041 *argp
= null_pointer_node
;
2043 for (i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
2045 tree
*argp
= gimple_call_arg_ptr (stmt
, i
);
2046 maybe_rewrite_mem_ref_base (argp
, suitable_for_renaming
);
2050 else if (gimple_code (stmt
) == GIMPLE_ASM
)
2052 gasm
*asm_stmt
= as_a
<gasm
*> (stmt
);
2054 for (i
= 0; i
< gimple_asm_noutputs (asm_stmt
); ++i
)
2056 tree link
= gimple_asm_output_op (asm_stmt
, i
);
2057 maybe_rewrite_mem_ref_base (&TREE_VALUE (link
),
2058 suitable_for_renaming
);
2060 for (i
= 0; i
< gimple_asm_ninputs (asm_stmt
); ++i
)
2062 tree link
= gimple_asm_input_op (asm_stmt
, i
);
2063 maybe_rewrite_mem_ref_base (&TREE_VALUE (link
),
2064 suitable_for_renaming
);
2068 else if (gimple_debug_bind_p (stmt
)
2069 && gimple_debug_bind_has_value_p (stmt
))
2071 tree
*valuep
= gimple_debug_bind_get_value_ptr (stmt
);
2073 maybe_rewrite_mem_ref_base (valuep
, suitable_for_renaming
);
2074 decl
= non_rewritable_mem_ref_base (*valuep
);
2076 && bitmap_bit_p (suitable_for_renaming
, DECL_UID (decl
)))
2077 gimple_debug_bind_reset_value (stmt
);
2080 if (gimple_references_memory_p (stmt
)
2081 || is_gimple_debug (stmt
))
2087 /* Update SSA form here, we are called as non-pass as well. */
2088 if (number_of_loops (cfun
) > 1
2089 && loops_state_satisfies_p (LOOP_CLOSED_SSA
))
2090 rewrite_into_loop_closed_ssa (NULL
, TODO_update_ssa
);
2092 update_ssa (TODO_update_ssa
);
2095 timevar_pop (TV_ADDRESS_TAKEN
);
2100 const pass_data pass_data_update_address_taken
=
2102 GIMPLE_PASS
, /* type */
2103 "addressables", /* name */
2104 OPTGROUP_NONE
, /* optinfo_flags */
2105 TV_ADDRESS_TAKEN
, /* tv_id */
2106 PROP_ssa
, /* properties_required */
2107 0, /* properties_provided */
2108 0, /* properties_destroyed */
2109 0, /* todo_flags_start */
2110 TODO_update_address_taken
, /* todo_flags_finish */
2113 class pass_update_address_taken
: public gimple_opt_pass
2116 pass_update_address_taken (gcc::context
*ctxt
)
2117 : gimple_opt_pass (pass_data_update_address_taken
, ctxt
)
2120 /* opt_pass methods: */
2122 }; // class pass_update_address_taken
2127 make_pass_update_address_taken (gcc::context
*ctxt
)
2129 return new pass_update_address_taken (ctxt
);