1 /* Miscellaneous SSA utility functions.
2 Copyright (C) 2001-2021 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
)))
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_set_bit (visited
, bb
->index
))
655 /* Pick up the single virtual PHI def. */
657 for (gphi_iterator si
= gsi_start_phis (bb
); !gsi_end_p (si
);
660 tree res
= gimple_phi_result (si
.phi ());
661 if (virtual_operand_p (res
))
665 error ("multiple virtual PHI nodes in BB %d", bb
->index
);
666 print_gimple_stmt (stderr
, phi
, 0);
667 print_gimple_stmt (stderr
, si
.phi (), 0);
676 current_vdef
= gimple_phi_result (phi
);
677 if (TREE_CODE (current_vdef
) != SSA_NAME
)
679 error ("virtual definition is not an SSA name");
680 print_gimple_stmt (stderr
, phi
, 0);
686 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
);
689 gimple
*stmt
= gsi_stmt (gsi
);
690 tree vuse
= gimple_vuse (stmt
);
693 if (vuse
!= current_vdef
)
695 error ("stmt with wrong VUSE");
696 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
);
697 fprintf (stderr
, "expected ");
698 print_generic_expr (stderr
, current_vdef
);
699 fprintf (stderr
, "\n");
702 tree vdef
= gimple_vdef (stmt
);
706 if (TREE_CODE (current_vdef
) != SSA_NAME
)
708 error ("virtual definition is not an SSA name");
709 print_gimple_stmt (stderr
, phi
, 0);
716 /* Verify destination PHI uses and recurse. */
719 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
721 gphi
*phi
= get_virtual_phi (e
->dest
);
723 && PHI_ARG_DEF_FROM_EDGE (phi
, e
) != current_vdef
)
725 error ("PHI node with wrong VUSE on edge from BB %d",
727 print_gimple_stmt (stderr
, phi
, 0, TDF_VOPS
);
728 fprintf (stderr
, "expected ");
729 print_generic_expr (stderr
, current_vdef
);
730 fprintf (stderr
, "\n");
735 err
|= verify_vssa (e
->dest
, current_vdef
, visited
);
741 /* Return true if SSA_NAME is malformed and mark it visited.
743 IS_VIRTUAL is true if this SSA_NAME was found inside a virtual
747 verify_ssa_name (tree ssa_name
, bool is_virtual
)
749 if (TREE_CODE (ssa_name
) != SSA_NAME
)
751 error ("expected an SSA_NAME object");
755 if (SSA_NAME_IN_FREE_LIST (ssa_name
))
757 error ("found an SSA_NAME that had been released into the free pool");
761 if (SSA_NAME_VAR (ssa_name
) != NULL_TREE
762 && TREE_TYPE (ssa_name
) != TREE_TYPE (SSA_NAME_VAR (ssa_name
)))
764 error ("type mismatch between an SSA_NAME and its symbol");
768 if (is_virtual
&& !virtual_operand_p (ssa_name
))
770 error ("found a virtual definition for a GIMPLE register");
774 if (is_virtual
&& SSA_NAME_VAR (ssa_name
) != gimple_vop (cfun
))
776 error ("virtual SSA name for non-VOP decl");
780 if (!is_virtual
&& virtual_operand_p (ssa_name
))
782 error ("found a real definition for a non-register");
786 if (SSA_NAME_IS_DEFAULT_DEF (ssa_name
)
787 && !gimple_nop_p (SSA_NAME_DEF_STMT (ssa_name
)))
789 error ("found a default name with a non-empty defining statement");
797 /* Return true if the definition of SSA_NAME at block BB is malformed.
799 STMT is the statement where SSA_NAME is created.
801 DEFINITION_BLOCK is an array of basic blocks indexed by SSA_NAME
802 version numbers. If DEFINITION_BLOCK[SSA_NAME_VERSION] is set,
803 it means that the block in that array slot contains the
804 definition of SSA_NAME.
806 IS_VIRTUAL is true if SSA_NAME is created by a VDEF. */
809 verify_def (basic_block bb
, basic_block
*definition_block
, tree ssa_name
,
810 gimple
*stmt
, bool is_virtual
)
812 if (verify_ssa_name (ssa_name
, is_virtual
))
815 if (SSA_NAME_VAR (ssa_name
)
816 && TREE_CODE (SSA_NAME_VAR (ssa_name
)) == RESULT_DECL
817 && DECL_BY_REFERENCE (SSA_NAME_VAR (ssa_name
)))
819 error ("RESULT_DECL should be read only when DECL_BY_REFERENCE is set");
823 if (definition_block
[SSA_NAME_VERSION (ssa_name
)])
825 error ("SSA_NAME created in two different blocks %i and %i",
826 definition_block
[SSA_NAME_VERSION (ssa_name
)]->index
, bb
->index
);
830 definition_block
[SSA_NAME_VERSION (ssa_name
)] = bb
;
832 if (SSA_NAME_DEF_STMT (ssa_name
) != stmt
)
834 error ("SSA_NAME_DEF_STMT is wrong");
835 fprintf (stderr
, "Expected definition statement:\n");
836 print_gimple_stmt (stderr
, SSA_NAME_DEF_STMT (ssa_name
), 4, TDF_VOPS
);
837 fprintf (stderr
, "\nActual definition statement:\n");
838 print_gimple_stmt (stderr
, stmt
, 4, TDF_VOPS
);
845 fprintf (stderr
, "while verifying SSA_NAME ");
846 print_generic_expr (stderr
, ssa_name
);
847 fprintf (stderr
, " in statement\n");
848 print_gimple_stmt (stderr
, stmt
, 4, TDF_VOPS
);
854 /* Return true if the use of SSA_NAME at statement STMT in block BB is
857 DEF_BB is the block where SSA_NAME was found to be created.
859 IDOM contains immediate dominator information for the flowgraph.
861 CHECK_ABNORMAL is true if the caller wants to check whether this use
862 is flowing through an abnormal edge (only used when checking PHI
865 If NAMES_DEFINED_IN_BB is not NULL, it contains a bitmap of ssa names
866 that are defined before STMT in basic block BB. */
869 verify_use (basic_block bb
, basic_block def_bb
, use_operand_p use_p
,
870 gimple
*stmt
, bool check_abnormal
, bitmap names_defined_in_bb
)
873 tree ssa_name
= USE_FROM_PTR (use_p
);
875 if (!TREE_VISITED (ssa_name
))
876 if (verify_imm_links (stderr
, ssa_name
))
879 TREE_VISITED (ssa_name
) = 1;
881 if (gimple_nop_p (SSA_NAME_DEF_STMT (ssa_name
))
882 && SSA_NAME_IS_DEFAULT_DEF (ssa_name
))
883 ; /* Default definitions have empty statements. Nothing to do. */
886 error ("missing definition");
889 else if (bb
!= def_bb
890 && !dominated_by_p (CDI_DOMINATORS
, bb
, def_bb
))
892 error ("definition in block %i does not dominate use in block %i",
893 def_bb
->index
, bb
->index
);
896 else if (bb
== def_bb
897 && names_defined_in_bb
!= NULL
898 && !bitmap_bit_p (names_defined_in_bb
, SSA_NAME_VERSION (ssa_name
)))
900 error ("definition in block %i follows the use", def_bb
->index
);
905 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ssa_name
))
907 error ("SSA_NAME_OCCURS_IN_ABNORMAL_PHI should be set");
911 /* Make sure the use is in an appropriate list by checking the previous
912 element to make sure it's the same. */
913 if (use_p
->prev
== NULL
)
915 error ("no immediate_use list");
921 if (use_p
->prev
->use
== NULL
)
922 listvar
= use_p
->prev
->loc
.ssa_name
;
924 listvar
= USE_FROM_PTR (use_p
->prev
);
925 if (listvar
!= ssa_name
)
927 error ("wrong immediate use list");
934 fprintf (stderr
, "for SSA_NAME: ");
935 print_generic_expr (stderr
, ssa_name
, TDF_VOPS
);
936 fprintf (stderr
, " in statement:\n");
937 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
);
944 /* Return true if any of the arguments for PHI node PHI at block BB is
947 DEFINITION_BLOCK is an array of basic blocks indexed by SSA_NAME
948 version numbers. If DEFINITION_BLOCK[SSA_NAME_VERSION] is set,
949 it means that the block in that array slot contains the
950 definition of SSA_NAME. */
953 verify_phi_args (gphi
*phi
, basic_block bb
, basic_block
*definition_block
)
957 size_t i
, phi_num_args
= gimple_phi_num_args (phi
);
959 if (EDGE_COUNT (bb
->preds
) != phi_num_args
)
961 error ("incoming edge count does not match number of PHI arguments");
966 for (i
= 0; i
< phi_num_args
; i
++)
968 use_operand_p op_p
= gimple_phi_arg_imm_use_ptr (phi
, i
);
969 tree op
= USE_FROM_PTR (op_p
);
971 e
= EDGE_PRED (bb
, i
);
975 error ("PHI argument is missing for edge %d->%d",
982 if (TREE_CODE (op
) != SSA_NAME
&& !is_gimple_min_invariant (op
))
984 error ("PHI argument is not SSA_NAME, or invariant");
988 if ((e
->flags
& EDGE_ABNORMAL
) && TREE_CODE (op
) != SSA_NAME
)
990 error ("PHI argument on abnormal edge is not SSA_NAME");
994 if (TREE_CODE (op
) == SSA_NAME
)
996 err
= verify_ssa_name (op
, virtual_operand_p (gimple_phi_result (phi
)));
997 err
|= verify_use (e
->src
, definition_block
[SSA_NAME_VERSION (op
)],
998 op_p
, phi
, e
->flags
& EDGE_ABNORMAL
, NULL
);
1001 if (TREE_CODE (op
) == ADDR_EXPR
)
1003 tree base
= TREE_OPERAND (op
, 0);
1004 while (handled_component_p (base
))
1005 base
= TREE_OPERAND (base
, 0);
1007 || TREE_CODE (base
) == PARM_DECL
1008 || TREE_CODE (base
) == RESULT_DECL
)
1009 && !TREE_ADDRESSABLE (base
))
1011 error ("address taken, but ADDRESSABLE bit not set");
1018 error ("wrong edge %d->%d for PHI argument",
1019 e
->src
->index
, e
->dest
->index
);
1025 fprintf (stderr
, "PHI argument\n");
1026 print_generic_stmt (stderr
, op
, TDF_VOPS
);
1034 fprintf (stderr
, "for PHI node\n");
1035 print_gimple_stmt (stderr
, phi
, 0, TDF_VOPS
|TDF_MEMSYMS
);
1043 /* Verify common invariants in the SSA web.
1044 TODO: verify the variable annotations. */
1047 verify_ssa (bool check_modified_stmt
, bool check_ssa_operands
)
1050 basic_block
*definition_block
= XCNEWVEC (basic_block
, num_ssa_names
);
1053 enum dom_state orig_dom_state
= dom_info_state (CDI_DOMINATORS
);
1054 auto_bitmap names_defined_in_bb
;
1056 gcc_assert (!need_ssa_update_p (cfun
));
1058 timevar_push (TV_TREE_SSA_VERIFY
);
1061 /* Keep track of SSA names present in the IL. */
1064 hash_map
<void *, tree
> ssa_info
;
1066 FOR_EACH_SSA_NAME (i
, name
, cfun
)
1069 TREE_VISITED (name
) = 0;
1071 verify_ssa_name (name
, virtual_operand_p (name
));
1073 stmt
= SSA_NAME_DEF_STMT (name
);
1074 if (!gimple_nop_p (stmt
))
1076 basic_block bb
= gimple_bb (stmt
);
1077 if (verify_def (bb
, definition_block
,
1078 name
, stmt
, virtual_operand_p (name
)))
1083 if (POINTER_TYPE_P (TREE_TYPE (name
)))
1084 info
= SSA_NAME_PTR_INFO (name
);
1085 else if (INTEGRAL_TYPE_P (TREE_TYPE (name
)))
1086 info
= SSA_NAME_RANGE_INFO (name
);
1090 tree
&val
= ssa_info
.get_or_insert (info
, &existed
);
1093 error ("shared SSA name info");
1094 print_generic_expr (stderr
, val
);
1095 fprintf (stderr
, " and ");
1096 print_generic_expr (stderr
, name
);
1097 fprintf (stderr
, "\n");
1106 calculate_dominance_info (CDI_DOMINATORS
);
1108 /* Now verify all the uses and make sure they agree with the definitions
1109 found in the previous pass. */
1110 FOR_EACH_BB_FN (bb
, cfun
)
1115 /* Make sure that all edges have a clear 'aux' field. */
1116 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
1120 error ("AUX pointer initialized for edge %d->%d", e
->src
->index
,
1126 /* Verify the arguments for every PHI node in the block. */
1127 for (gphi_iterator gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1129 gphi
*phi
= gsi
.phi ();
1130 if (verify_phi_args (phi
, bb
, definition_block
))
1133 bitmap_set_bit (names_defined_in_bb
,
1134 SSA_NAME_VERSION (gimple_phi_result (phi
)));
1137 /* Now verify all the uses and vuses in every statement of the block. */
1138 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
);
1141 gimple
*stmt
= gsi_stmt (gsi
);
1142 use_operand_p use_p
;
1144 if (check_modified_stmt
&& gimple_modified_p (stmt
))
1146 error ("stmt (%p) marked modified after optimization pass: ",
1148 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
);
1152 if (check_ssa_operands
&& verify_ssa_operands (cfun
, stmt
))
1154 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
);
1158 if (gimple_debug_bind_p (stmt
)
1159 && !gimple_debug_bind_has_value_p (stmt
))
1162 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_USE
|SSA_OP_VUSE
)
1164 op
= USE_FROM_PTR (use_p
);
1165 if (verify_use (bb
, definition_block
[SSA_NAME_VERSION (op
)],
1166 use_p
, stmt
, false, names_defined_in_bb
))
1170 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, iter
, SSA_OP_ALL_DEFS
)
1172 if (SSA_NAME_DEF_STMT (op
) != stmt
)
1174 error ("SSA_NAME_DEF_STMT is wrong");
1175 fprintf (stderr
, "Expected definition statement:\n");
1176 print_gimple_stmt (stderr
, stmt
, 4, TDF_VOPS
);
1177 fprintf (stderr
, "\nActual definition statement:\n");
1178 print_gimple_stmt (stderr
, SSA_NAME_DEF_STMT (op
),
1182 bitmap_set_bit (names_defined_in_bb
, SSA_NAME_VERSION (op
));
1186 bitmap_clear (names_defined_in_bb
);
1189 free (definition_block
);
1191 if (gimple_vop (cfun
)
1192 && ssa_default_def (cfun
, gimple_vop (cfun
)))
1194 auto_sbitmap
visited (last_basic_block_for_fn (cfun
) + 1);
1195 bitmap_clear (visited
);
1196 if (verify_vssa (ENTRY_BLOCK_PTR_FOR_FN (cfun
),
1197 ssa_default_def (cfun
, gimple_vop (cfun
)), visited
))
1201 /* Restore the dominance information to its prior known state, so
1202 that we do not perturb the compiler's subsequent behavior. */
1203 if (orig_dom_state
== DOM_NONE
)
1204 free_dominance_info (CDI_DOMINATORS
);
1206 set_dom_info_availability (CDI_DOMINATORS
, orig_dom_state
);
1208 timevar_pop (TV_TREE_SSA_VERIFY
);
1212 internal_error ("verify_ssa failed");
1216 # pragma GCC diagnostic pop
1219 /* Initialize global DFA and SSA structures.
1220 If SIZE is non-zero allocated ssa names array of a given size. */
1223 init_tree_ssa (struct function
*fn
, int size
)
1225 fn
->gimple_df
= ggc_cleared_alloc
<gimple_df
> ();
1226 fn
->gimple_df
->default_defs
= hash_table
<ssa_name_hasher
>::create_ggc (20);
1227 pt_solution_reset (&fn
->gimple_df
->escaped
);
1228 init_ssanames (fn
, size
);
1231 /* Deallocate memory associated with SSA data structures for FNDECL. */
1234 delete_tree_ssa (struct function
*fn
)
1238 /* We no longer maintain the SSA operand cache at this point. */
1239 if (ssa_operands_active (fn
))
1240 fini_ssa_operands (fn
);
1242 fn
->gimple_df
->default_defs
->empty ();
1243 fn
->gimple_df
->default_defs
= NULL
;
1244 pt_solution_reset (&fn
->gimple_df
->escaped
);
1245 if (fn
->gimple_df
->decls_to_pointers
!= NULL
)
1246 delete fn
->gimple_df
->decls_to_pointers
;
1247 fn
->gimple_df
->decls_to_pointers
= NULL
;
1248 fn
->gimple_df
= NULL
;
1250 /* We no longer need the edge variable maps. */
1251 redirect_edge_var_map_empty ();
1254 /* Return true if EXPR is a useless type conversion, otherwise return
1258 tree_ssa_useless_type_conversion (tree expr
)
1260 /* If we have an assignment that merely uses a NOP_EXPR to change
1261 the top of the RHS to the type of the LHS and the type conversion
1262 is "safe", then strip away the type conversion so that we can
1263 enter LHS = RHS into the const_and_copies table. */
1264 if (CONVERT_EXPR_P (expr
)
1265 || TREE_CODE (expr
) == VIEW_CONVERT_EXPR
1266 || TREE_CODE (expr
) == NON_LVALUE_EXPR
)
1267 return useless_type_conversion_p
1269 TREE_TYPE (TREE_OPERAND (expr
, 0)));
1274 /* Strip conversions from EXP according to
1275 tree_ssa_useless_type_conversion and return the resulting
1279 tree_ssa_strip_useless_type_conversions (tree exp
)
1281 while (tree_ssa_useless_type_conversion (exp
))
1282 exp
= TREE_OPERAND (exp
, 0);
1286 /* Return true if T, as SSA_NAME, has an implicit default defined value. */
1289 ssa_defined_default_def_p (tree t
)
1291 tree var
= SSA_NAME_VAR (t
);
1295 /* Parameters get their initial value from the function entry. */
1296 else if (TREE_CODE (var
) == PARM_DECL
)
1298 /* When returning by reference the return address is actually a hidden
1300 else if (TREE_CODE (var
) == RESULT_DECL
&& DECL_BY_REFERENCE (var
))
1302 /* Hard register variables get their initial value from the ether. */
1303 else if (VAR_P (var
) && DECL_HARD_REGISTER (var
))
1310 /* Return true if T, an SSA_NAME, has an undefined value. PARTIAL is what
1311 should be returned if the value is only partially undefined. */
1314 ssa_undefined_value_p (tree t
, bool partial
)
1318 if (ssa_defined_default_def_p (t
))
1321 /* The value is undefined iff its definition statement is empty. */
1322 def_stmt
= SSA_NAME_DEF_STMT (t
);
1323 if (gimple_nop_p (def_stmt
))
1326 /* The value is undefined if the definition statement is a call
1327 to .DEFERRED_INIT function. */
1328 if (gimple_call_internal_p (def_stmt
, IFN_DEFERRED_INIT
))
1331 /* The value is partially undefined if the definition statement is
1332 a REALPART_EXPR or IMAGPART_EXPR and its operand is defined by
1333 the call to .DEFERRED_INIT function. This is for handling the
1336 1 typedef _Complex float C;
1349 with -ftrivial-auto-var-init, compiler will insert the following
1350 artificial initialization:
1351 f = .DEFERRED_INIT (f, 2);
1352 _1 = REALPART_EXPR <f>;
1354 we should treat the definition _1 = REALPART_EXPR <f> as undefined. */
1355 if (partial
&& is_gimple_assign (def_stmt
)
1356 && (gimple_assign_rhs_code (def_stmt
) == REALPART_EXPR
1357 || gimple_assign_rhs_code (def_stmt
) == IMAGPART_EXPR
))
1359 tree real_imag_part
= TREE_OPERAND (gimple_assign_rhs1 (def_stmt
), 0);
1360 if (TREE_CODE (real_imag_part
) == SSA_NAME
1361 && gimple_call_internal_p (SSA_NAME_DEF_STMT (real_imag_part
),
1366 /* Check if the complex was not only partially defined. */
1367 if (partial
&& is_gimple_assign (def_stmt
)
1368 && gimple_assign_rhs_code (def_stmt
) == COMPLEX_EXPR
)
1372 rhs1
= gimple_assign_rhs1 (def_stmt
);
1373 rhs2
= gimple_assign_rhs2 (def_stmt
);
1374 return (TREE_CODE (rhs1
) == SSA_NAME
&& ssa_undefined_value_p (rhs1
))
1375 || (TREE_CODE (rhs2
) == SSA_NAME
&& ssa_undefined_value_p (rhs2
));
1381 /* Return TRUE iff STMT, a gimple statement, references an undefined
1385 gimple_uses_undefined_value_p (gimple
*stmt
)
1390 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, iter
, SSA_OP_USE
)
1391 if (ssa_undefined_value_p (op
))
1399 /* If necessary, rewrite the base of the reference tree *TP from
1400 a MEM_REF to a plain or converted symbol. */
1403 maybe_rewrite_mem_ref_base (tree
*tp
, bitmap suitable_for_renaming
)
1407 while (handled_component_p (*tp
))
1408 tp
= &TREE_OPERAND (*tp
, 0);
1409 if (TREE_CODE (*tp
) == MEM_REF
1410 && TREE_CODE (TREE_OPERAND (*tp
, 0)) == ADDR_EXPR
1411 && (sym
= TREE_OPERAND (TREE_OPERAND (*tp
, 0), 0))
1413 && !TREE_ADDRESSABLE (sym
)
1414 && bitmap_bit_p (suitable_for_renaming
, DECL_UID (sym
))
1415 && is_gimple_reg_type (TREE_TYPE (*tp
))
1416 && ! VOID_TYPE_P (TREE_TYPE (*tp
)))
1418 if (TREE_CODE (TREE_TYPE (sym
)) == VECTOR_TYPE
1419 && useless_type_conversion_p (TREE_TYPE (*tp
),
1420 TREE_TYPE (TREE_TYPE (sym
)))
1421 && multiple_of_p (sizetype
, TREE_OPERAND (*tp
, 1),
1422 TYPE_SIZE_UNIT (TREE_TYPE (*tp
))))
1424 *tp
= build3 (BIT_FIELD_REF
, TREE_TYPE (*tp
), sym
,
1425 TYPE_SIZE (TREE_TYPE (*tp
)),
1426 int_const_binop (MULT_EXPR
,
1427 bitsize_int (BITS_PER_UNIT
),
1428 TREE_OPERAND (*tp
, 1)));
1430 else if (TREE_CODE (TREE_TYPE (sym
)) == COMPLEX_TYPE
1431 && useless_type_conversion_p (TREE_TYPE (*tp
),
1432 TREE_TYPE (TREE_TYPE (sym
))))
1434 *tp
= build1 (integer_zerop (TREE_OPERAND (*tp
, 1))
1435 ? REALPART_EXPR
: IMAGPART_EXPR
,
1436 TREE_TYPE (*tp
), sym
);
1438 else if (integer_zerop (TREE_OPERAND (*tp
, 1))
1439 && DECL_SIZE (sym
) == TYPE_SIZE (TREE_TYPE (*tp
)))
1441 if (!useless_type_conversion_p (TREE_TYPE (*tp
),
1443 *tp
= build1 (VIEW_CONVERT_EXPR
,
1444 TREE_TYPE (*tp
), sym
);
1448 else if (DECL_SIZE (sym
)
1449 && TREE_CODE (DECL_SIZE (sym
)) == INTEGER_CST
1450 && (known_subrange_p
1451 (mem_ref_offset (*tp
),
1452 wi::to_offset (TYPE_SIZE_UNIT (TREE_TYPE (*tp
))),
1453 0, wi::to_offset (DECL_SIZE_UNIT (sym
))))
1454 && (! INTEGRAL_TYPE_P (TREE_TYPE (*tp
))
1455 || (wi::to_offset (TYPE_SIZE (TREE_TYPE (*tp
)))
1456 == TYPE_PRECISION (TREE_TYPE (*tp
))))
1457 && wi::umod_trunc (wi::to_offset (TYPE_SIZE (TREE_TYPE (*tp
))),
1458 BITS_PER_UNIT
) == 0)
1460 *tp
= build3 (BIT_FIELD_REF
, TREE_TYPE (*tp
), sym
,
1461 TYPE_SIZE (TREE_TYPE (*tp
)),
1462 wide_int_to_tree (bitsizetype
,
1463 mem_ref_offset (*tp
)
1464 << LOG2_BITS_PER_UNIT
));
1469 /* For a tree REF return its base if it is the base of a MEM_REF
1470 that cannot be rewritten into SSA form. Otherwise return NULL_TREE. */
1473 non_rewritable_mem_ref_base (tree ref
)
1477 /* A plain decl does not need it set. */
1481 if (! (base
= CONST_CAST_TREE (strip_invariant_refs (ref
))))
1483 base
= get_base_address (ref
);
1489 /* But watch out for MEM_REFs we cannot lower to a
1490 VIEW_CONVERT_EXPR or a BIT_FIELD_REF. */
1491 if (TREE_CODE (base
) == MEM_REF
1492 && TREE_CODE (TREE_OPERAND (base
, 0)) == ADDR_EXPR
)
1494 tree decl
= TREE_OPERAND (TREE_OPERAND (base
, 0), 0);
1495 if (! DECL_P (decl
))
1497 if (! is_gimple_reg_type (TREE_TYPE (base
))
1498 || VOID_TYPE_P (TREE_TYPE (base
))
1499 || TREE_THIS_VOLATILE (decl
) != TREE_THIS_VOLATILE (base
))
1501 if ((TREE_CODE (TREE_TYPE (decl
)) == VECTOR_TYPE
1502 || TREE_CODE (TREE_TYPE (decl
)) == COMPLEX_TYPE
)
1503 && useless_type_conversion_p (TREE_TYPE (base
),
1504 TREE_TYPE (TREE_TYPE (decl
)))
1505 && known_ge (mem_ref_offset (base
), 0)
1506 && known_gt (wi::to_poly_offset (TYPE_SIZE_UNIT (TREE_TYPE (decl
))),
1507 mem_ref_offset (base
))
1508 && multiple_of_p (sizetype
, TREE_OPERAND (base
, 1),
1509 TYPE_SIZE_UNIT (TREE_TYPE (base
))))
1511 /* For same sizes and zero offset we can use a VIEW_CONVERT_EXPR. */
1512 if (integer_zerop (TREE_OPERAND (base
, 1))
1513 && DECL_SIZE (decl
) == TYPE_SIZE (TREE_TYPE (base
)))
1515 /* For integral typed extracts we can use a BIT_FIELD_REF. */
1516 if (DECL_SIZE (decl
)
1517 && TREE_CODE (DECL_SIZE_UNIT (decl
)) == INTEGER_CST
1518 && (known_subrange_p
1519 (mem_ref_offset (base
),
1520 wi::to_poly_offset (TYPE_SIZE_UNIT (TREE_TYPE (base
))),
1521 0, wi::to_poly_offset (DECL_SIZE_UNIT (decl
))))
1522 /* ??? We can't handle bitfield precision extracts without
1523 either using an alternate type for the BIT_FIELD_REF and
1524 then doing a conversion or possibly adjusting the offset
1525 according to endianness. */
1526 && (! INTEGRAL_TYPE_P (TREE_TYPE (base
))
1527 || (wi::to_offset (TYPE_SIZE (TREE_TYPE (base
)))
1528 == TYPE_PRECISION (TREE_TYPE (base
))))
1529 && wi::umod_trunc (wi::to_offset (TYPE_SIZE (TREE_TYPE (base
))),
1530 BITS_PER_UNIT
) == 0)
1535 /* We cannot rewrite TARGET_MEM_REFs. */
1536 if (TREE_CODE (base
) == TARGET_MEM_REF
1537 && TREE_CODE (TREE_OPERAND (base
, 0)) == ADDR_EXPR
)
1539 tree decl
= TREE_OPERAND (TREE_OPERAND (base
, 0), 0);
1540 if (! DECL_P (decl
))
1548 /* For an lvalue tree LHS return true if it cannot be rewritten into SSA form.
1549 Otherwise return true. */
1552 non_rewritable_lvalue_p (tree lhs
)
1554 /* A plain decl is always rewritable. */
1558 /* We can re-write REALPART_EXPR and IMAGPART_EXPR sets in
1559 a reasonably efficient manner... */
1560 if ((TREE_CODE (lhs
) == REALPART_EXPR
1561 || TREE_CODE (lhs
) == IMAGPART_EXPR
)
1562 && DECL_P (TREE_OPERAND (lhs
, 0)))
1565 /* ??? The following could be relaxed allowing component
1566 references that do not change the access size. */
1567 if (TREE_CODE (lhs
) == MEM_REF
1568 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == ADDR_EXPR
)
1570 tree decl
= TREE_OPERAND (TREE_OPERAND (lhs
, 0), 0);
1572 /* A decl that is wrapped inside a MEM-REF that covers
1573 it full is also rewritable. */
1574 if (integer_zerop (TREE_OPERAND (lhs
, 1))
1576 && DECL_SIZE (decl
) == TYPE_SIZE (TREE_TYPE (lhs
))
1577 /* If the dynamic type of the decl has larger precision than
1578 the decl itself we can't use the decls type for SSA rewriting. */
1579 && ((! INTEGRAL_TYPE_P (TREE_TYPE (decl
))
1580 || compare_tree_int (DECL_SIZE (decl
),
1581 TYPE_PRECISION (TREE_TYPE (decl
))) == 0)
1582 || (INTEGRAL_TYPE_P (TREE_TYPE (lhs
))
1583 && (TYPE_PRECISION (TREE_TYPE (decl
))
1584 >= TYPE_PRECISION (TREE_TYPE (lhs
)))))
1585 /* Make sure we are not re-writing non-float copying into float
1586 copying as that can incur normalization. */
1587 && (! FLOAT_TYPE_P (TREE_TYPE (decl
))
1588 || types_compatible_p (TREE_TYPE (lhs
), TREE_TYPE (decl
)))
1589 && (TREE_THIS_VOLATILE (decl
) == TREE_THIS_VOLATILE (lhs
)))
1592 /* A vector-insert using a MEM_REF or ARRAY_REF is rewritable
1593 using a BIT_INSERT_EXPR. */
1595 && VECTOR_TYPE_P (TREE_TYPE (decl
))
1596 && TYPE_MODE (TREE_TYPE (decl
)) != BLKmode
1597 && known_ge (mem_ref_offset (lhs
), 0)
1598 && known_gt (wi::to_poly_offset (TYPE_SIZE_UNIT (TREE_TYPE (decl
))),
1599 mem_ref_offset (lhs
))
1600 && multiple_of_p (sizetype
, TREE_OPERAND (lhs
, 1),
1601 TYPE_SIZE_UNIT (TREE_TYPE (lhs
)))
1602 && known_ge (wi::to_poly_offset (TYPE_SIZE (TREE_TYPE (decl
))),
1603 wi::to_poly_offset (TYPE_SIZE (TREE_TYPE (lhs
)))))
1605 poly_uint64 lhs_bits
, nelts
;
1606 if (poly_int_tree_p (TYPE_SIZE (TREE_TYPE (lhs
)), &lhs_bits
)
1607 && multiple_p (lhs_bits
,
1609 (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl
)))),
1611 && valid_vector_subparts_p (nelts
))
1613 if (known_eq (nelts
, 1u))
1615 /* For sub-vector inserts the insert vector mode has to be
1617 tree vtype
= build_vector_type (TREE_TYPE (TREE_TYPE (decl
)),
1619 if (TYPE_MODE (vtype
) != BLKmode
)
1625 /* A vector-insert using a BIT_FIELD_REF is rewritable using
1627 if (TREE_CODE (lhs
) == BIT_FIELD_REF
1628 && DECL_P (TREE_OPERAND (lhs
, 0))
1629 && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (lhs
, 0)))
1630 && TYPE_MODE (TREE_TYPE (TREE_OPERAND (lhs
, 0))) != BLKmode
1631 && operand_equal_p (TYPE_SIZE_UNIT (TREE_TYPE (lhs
)),
1633 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (lhs
, 0)))), 0)
1634 && (tree_to_uhwi (TREE_OPERAND (lhs
, 2))
1635 % tree_to_uhwi (TYPE_SIZE (TREE_TYPE (lhs
)))) == 0)
1641 /* When possible, clear TREE_ADDRESSABLE bit, set or clear DECL_NOT_GIMPLE_REG_P
1642 and mark the variable VAR for conversion into SSA. Return true when updating
1643 stmts is required. */
1646 maybe_optimize_var (tree var
, bitmap addresses_taken
, bitmap not_reg_needs
,
1647 bitmap suitable_for_renaming
)
1649 /* Global Variables, result decls cannot be changed. */
1650 if (is_global_var (var
)
1651 || TREE_CODE (var
) == RESULT_DECL
1652 || bitmap_bit_p (addresses_taken
, DECL_UID (var
)))
1655 bool maybe_reg
= false;
1656 if (TREE_ADDRESSABLE (var
))
1658 TREE_ADDRESSABLE (var
) = 0;
1662 fprintf (dump_file
, "No longer having address taken: ");
1663 print_generic_expr (dump_file
, var
);
1664 fprintf (dump_file
, "\n");
1668 /* For register type decls if we do not have any partial defs
1669 we cannot express in SSA form mark them as DECL_NOT_GIMPLE_REG_P
1670 as to avoid SSA rewrite. For the others go ahead and mark
1671 them for renaming. */
1672 if (is_gimple_reg_type (TREE_TYPE (var
)))
1674 if (bitmap_bit_p (not_reg_needs
, DECL_UID (var
)))
1676 DECL_NOT_GIMPLE_REG_P (var
) = 1;
1679 fprintf (dump_file
, "Has partial defs: ");
1680 print_generic_expr (dump_file
, var
);
1681 fprintf (dump_file
, "\n");
1684 else if (DECL_NOT_GIMPLE_REG_P (var
))
1687 DECL_NOT_GIMPLE_REG_P (var
) = 0;
1689 if (maybe_reg
&& is_gimple_reg (var
))
1693 fprintf (dump_file
, "Now a gimple register: ");
1694 print_generic_expr (dump_file
, var
);
1695 fprintf (dump_file
, "\n");
1697 bitmap_set_bit (suitable_for_renaming
, DECL_UID (var
));
1702 /* Return true when STMT is ASAN mark where second argument is an address
1703 of a local variable. */
1706 is_asan_mark_p (gimple
*stmt
)
1708 if (!gimple_call_internal_p (stmt
, IFN_ASAN_MARK
))
1711 tree addr
= get_base_address (gimple_call_arg (stmt
, 1));
1712 if (TREE_CODE (addr
) == ADDR_EXPR
1713 && VAR_P (TREE_OPERAND (addr
, 0)))
1715 tree var
= TREE_OPERAND (addr
, 0);
1716 if (lookup_attribute (ASAN_USE_AFTER_SCOPE_ATTRIBUTE
,
1717 DECL_ATTRIBUTES (var
)))
1720 unsigned addressable
= TREE_ADDRESSABLE (var
);
1721 TREE_ADDRESSABLE (var
) = 0;
1722 bool r
= is_gimple_reg (var
);
1723 TREE_ADDRESSABLE (var
) = addressable
;
1730 /* Compute TREE_ADDRESSABLE and whether we have unhandled partial defs
1731 for local variables. */
1734 execute_update_addresses_taken (void)
1737 auto_bitmap addresses_taken
;
1738 auto_bitmap not_reg_needs
;
1739 auto_bitmap suitable_for_renaming
;
1743 timevar_push (TV_ADDRESS_TAKEN
);
1745 /* Collect into ADDRESSES_TAKEN all variables whose address is taken within
1746 the function body. */
1747 FOR_EACH_BB_FN (bb
, cfun
)
1749 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
);
1752 gimple
*stmt
= gsi_stmt (gsi
);
1753 enum gimple_code code
= gimple_code (stmt
);
1756 if (code
== GIMPLE_CALL
)
1758 if (optimize_atomic_compare_exchange_p (stmt
))
1760 /* For __atomic_compare_exchange_N if the second argument
1761 is &var, don't mark var addressable;
1762 if it becomes non-addressable, we'll rewrite it into
1763 ATOMIC_COMPARE_EXCHANGE call. */
1764 tree arg
= gimple_call_arg (stmt
, 1);
1765 gimple_call_set_arg (stmt
, 1, null_pointer_node
);
1766 gimple_ior_addresses_taken (addresses_taken
, stmt
);
1767 gimple_call_set_arg (stmt
, 1, arg
);
1769 else if (is_asan_mark_p (stmt
)
1770 || gimple_call_internal_p (stmt
, IFN_GOMP_SIMT_ENTER
))
1773 gimple_ior_addresses_taken (addresses_taken
, stmt
);
1776 /* Note all addresses taken by the stmt. */
1777 gimple_ior_addresses_taken (addresses_taken
, stmt
);
1779 /* If we have a call or an assignment, see if the lhs contains
1780 a local decl that requires not to be a gimple register. */
1781 if (code
== GIMPLE_ASSIGN
|| code
== GIMPLE_CALL
)
1783 tree lhs
= gimple_get_lhs (stmt
);
1785 && TREE_CODE (lhs
) != SSA_NAME
1786 && ((code
== GIMPLE_CALL
&& ! DECL_P (lhs
))
1787 || non_rewritable_lvalue_p (lhs
)))
1789 decl
= get_base_address (lhs
);
1791 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1795 if (gimple_assign_single_p (stmt
))
1797 tree rhs
= gimple_assign_rhs1 (stmt
);
1798 if ((decl
= non_rewritable_mem_ref_base (rhs
)))
1799 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1802 else if (code
== GIMPLE_CALL
)
1804 for (i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
1806 tree arg
= gimple_call_arg (stmt
, i
);
1807 if ((decl
= non_rewritable_mem_ref_base (arg
)))
1808 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1812 else if (code
== GIMPLE_ASM
)
1814 gasm
*asm_stmt
= as_a
<gasm
*> (stmt
);
1815 for (i
= 0; i
< gimple_asm_noutputs (asm_stmt
); ++i
)
1817 tree link
= gimple_asm_output_op (asm_stmt
, i
);
1818 tree lhs
= TREE_VALUE (link
);
1819 if (TREE_CODE (lhs
) != SSA_NAME
)
1821 decl
= get_base_address (lhs
);
1823 && (non_rewritable_lvalue_p (lhs
)
1824 /* We cannot move required conversions from
1825 the lhs to the rhs in asm statements, so
1826 require we do not need any. */
1827 || !useless_type_conversion_p
1828 (TREE_TYPE (lhs
), TREE_TYPE (decl
))))
1829 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1832 for (i
= 0; i
< gimple_asm_ninputs (asm_stmt
); ++i
)
1834 tree link
= gimple_asm_input_op (asm_stmt
, i
);
1835 if ((decl
= non_rewritable_mem_ref_base (TREE_VALUE (link
))))
1836 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1841 for (gphi_iterator gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
);
1845 gphi
*phi
= gsi
.phi ();
1847 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
1849 tree op
= PHI_ARG_DEF (phi
, i
), var
;
1850 if (TREE_CODE (op
) == ADDR_EXPR
1851 && (var
= get_base_address (TREE_OPERAND (op
, 0))) != NULL
1853 bitmap_set_bit (addresses_taken
, DECL_UID (var
));
1858 /* We cannot iterate over all referenced vars because that can contain
1859 unused vars from BLOCK trees, which causes code generation differences
1861 for (var
= DECL_ARGUMENTS (cfun
->decl
); var
; var
= DECL_CHAIN (var
))
1862 maybe_optimize_var (var
, addresses_taken
, not_reg_needs
,
1863 suitable_for_renaming
);
1865 FOR_EACH_VEC_SAFE_ELT (cfun
->local_decls
, i
, var
)
1866 maybe_optimize_var (var
, addresses_taken
, not_reg_needs
,
1867 suitable_for_renaming
);
1869 /* Operand caches need to be recomputed for operands referencing the updated
1870 variables and operands need to be rewritten to expose bare symbols. */
1871 if (!bitmap_empty_p (suitable_for_renaming
))
1873 FOR_EACH_BB_FN (bb
, cfun
)
1874 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
);)
1876 gimple
*stmt
= gsi_stmt (gsi
);
1878 /* Re-write TARGET_MEM_REFs of symbols we want to
1879 rewrite into SSA form. */
1880 if (gimple_assign_single_p (stmt
))
1882 tree lhs
= gimple_assign_lhs (stmt
);
1883 tree rhs
, *rhsp
= gimple_assign_rhs1_ptr (stmt
);
1886 /* Rewrite LHS IMAG/REALPART_EXPR similar to
1887 gimplify_modify_expr_complex_part. */
1888 if ((TREE_CODE (lhs
) == IMAGPART_EXPR
1889 || TREE_CODE (lhs
) == REALPART_EXPR
)
1890 && DECL_P (TREE_OPERAND (lhs
, 0))
1891 && bitmap_bit_p (suitable_for_renaming
,
1892 DECL_UID (TREE_OPERAND (lhs
, 0))))
1894 tree other
= make_ssa_name (TREE_TYPE (lhs
));
1895 tree lrhs
= build1 (TREE_CODE (lhs
) == IMAGPART_EXPR
1896 ? REALPART_EXPR
: IMAGPART_EXPR
,
1898 TREE_OPERAND (lhs
, 0));
1899 gimple
*load
= gimple_build_assign (other
, lrhs
);
1900 location_t loc
= gimple_location (stmt
);
1901 gimple_set_location (load
, loc
);
1902 gimple_set_vuse (load
, gimple_vuse (stmt
));
1903 gsi_insert_before (&gsi
, load
, GSI_SAME_STMT
);
1904 gimple_assign_set_lhs (stmt
, TREE_OPERAND (lhs
, 0));
1905 gimple_assign_set_rhs_with_ops
1906 (&gsi
, COMPLEX_EXPR
,
1907 TREE_CODE (lhs
) == IMAGPART_EXPR
1908 ? other
: gimple_assign_rhs1 (stmt
),
1909 TREE_CODE (lhs
) == IMAGPART_EXPR
1910 ? gimple_assign_rhs1 (stmt
) : other
, NULL_TREE
);
1911 stmt
= gsi_stmt (gsi
);
1912 unlink_stmt_vdef (stmt
);
1917 /* Rewrite a vector insert via a BIT_FIELD_REF on the LHS
1918 into a BIT_INSERT_EXPR. */
1919 if (TREE_CODE (lhs
) == BIT_FIELD_REF
1920 && DECL_P (TREE_OPERAND (lhs
, 0))
1921 && bitmap_bit_p (suitable_for_renaming
,
1922 DECL_UID (TREE_OPERAND (lhs
, 0)))
1923 && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (lhs
, 0)))
1924 && TYPE_MODE (TREE_TYPE (TREE_OPERAND (lhs
, 0))) != BLKmode
1925 && operand_equal_p (TYPE_SIZE_UNIT (TREE_TYPE (lhs
)),
1926 TYPE_SIZE_UNIT (TREE_TYPE
1927 (TREE_TYPE (TREE_OPERAND (lhs
, 0)))),
1929 && (tree_to_uhwi (TREE_OPERAND (lhs
, 2))
1930 % tree_to_uhwi (TYPE_SIZE (TREE_TYPE (lhs
))) == 0))
1932 tree var
= TREE_OPERAND (lhs
, 0);
1933 tree val
= gimple_assign_rhs1 (stmt
);
1934 if (! types_compatible_p (TREE_TYPE (TREE_TYPE (var
)),
1937 tree tem
= make_ssa_name (TREE_TYPE (TREE_TYPE (var
)));
1939 = gimple_build_assign (tem
,
1940 build1 (VIEW_CONVERT_EXPR
,
1941 TREE_TYPE (tem
), val
));
1942 gsi_insert_before (&gsi
, pun
, GSI_SAME_STMT
);
1945 tree bitpos
= TREE_OPERAND (lhs
, 2);
1946 gimple_assign_set_lhs (stmt
, var
);
1947 gimple_assign_set_rhs_with_ops
1948 (&gsi
, BIT_INSERT_EXPR
, var
, val
, bitpos
);
1949 stmt
= gsi_stmt (gsi
);
1950 unlink_stmt_vdef (stmt
);
1955 /* Rewrite a vector insert using a MEM_REF on the LHS
1956 into a BIT_INSERT_EXPR. */
1957 if (TREE_CODE (lhs
) == MEM_REF
1958 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == ADDR_EXPR
1959 && (sym
= TREE_OPERAND (TREE_OPERAND (lhs
, 0), 0))
1961 && bitmap_bit_p (suitable_for_renaming
, DECL_UID (sym
))
1962 && VECTOR_TYPE_P (TREE_TYPE (sym
))
1963 && TYPE_MODE (TREE_TYPE (sym
)) != BLKmode
1964 /* If it is a full replacement we can do better below. */
1965 && maybe_ne (wi::to_poly_offset
1966 (TYPE_SIZE_UNIT (TREE_TYPE (lhs
))),
1968 (TYPE_SIZE_UNIT (TREE_TYPE (sym
))))
1969 && known_ge (mem_ref_offset (lhs
), 0)
1970 && known_gt (wi::to_poly_offset
1971 (TYPE_SIZE_UNIT (TREE_TYPE (sym
))),
1972 mem_ref_offset (lhs
))
1973 && multiple_of_p (sizetype
,
1974 TREE_OPERAND (lhs
, 1),
1975 TYPE_SIZE_UNIT (TREE_TYPE (lhs
))))
1977 tree val
= gimple_assign_rhs1 (stmt
);
1978 if (! types_compatible_p (TREE_TYPE (val
),
1979 TREE_TYPE (TREE_TYPE (sym
))))
1981 poly_uint64 lhs_bits
, nelts
;
1982 tree temtype
= TREE_TYPE (TREE_TYPE (sym
));
1983 if (poly_int_tree_p (TYPE_SIZE (TREE_TYPE (lhs
)),
1985 && multiple_p (lhs_bits
,
1987 (TYPE_SIZE (TREE_TYPE
1988 (TREE_TYPE (sym
)))),
1990 && maybe_ne (nelts
, 1u)
1991 && valid_vector_subparts_p (nelts
))
1992 temtype
= build_vector_type (temtype
, nelts
);
1993 tree tem
= make_ssa_name (temtype
);
1995 = gimple_build_assign (tem
,
1996 build1 (VIEW_CONVERT_EXPR
,
1997 TREE_TYPE (tem
), val
));
1998 gsi_insert_before (&gsi
, pun
, GSI_SAME_STMT
);
2002 = wide_int_to_tree (bitsizetype
,
2003 mem_ref_offset (lhs
) * BITS_PER_UNIT
);
2004 gimple_assign_set_lhs (stmt
, sym
);
2005 gimple_assign_set_rhs_with_ops
2006 (&gsi
, BIT_INSERT_EXPR
, sym
, val
, bitpos
);
2007 stmt
= gsi_stmt (gsi
);
2008 unlink_stmt_vdef (stmt
);
2013 /* We shouldn't have any fancy wrapping of
2014 component-refs on the LHS, but look through
2015 VIEW_CONVERT_EXPRs as that is easy. */
2016 while (TREE_CODE (lhs
) == VIEW_CONVERT_EXPR
)
2017 lhs
= TREE_OPERAND (lhs
, 0);
2018 if (TREE_CODE (lhs
) == MEM_REF
2019 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == ADDR_EXPR
2020 && integer_zerop (TREE_OPERAND (lhs
, 1))
2021 && (sym
= TREE_OPERAND (TREE_OPERAND (lhs
, 0), 0))
2023 && !TREE_ADDRESSABLE (sym
)
2024 && bitmap_bit_p (suitable_for_renaming
, DECL_UID (sym
)))
2027 lhs
= gimple_assign_lhs (stmt
);
2029 /* Rewrite the RHS and make sure the resulting assignment
2030 is validly typed. */
2031 maybe_rewrite_mem_ref_base (rhsp
, suitable_for_renaming
);
2032 rhs
= gimple_assign_rhs1 (stmt
);
2033 if (gimple_assign_lhs (stmt
) != lhs
2034 && !useless_type_conversion_p (TREE_TYPE (lhs
),
2037 if (gimple_clobber_p (stmt
))
2039 rhs
= build_constructor (TREE_TYPE (lhs
), NULL
);
2040 TREE_THIS_VOLATILE (rhs
) = 1;
2043 rhs
= fold_build1 (VIEW_CONVERT_EXPR
,
2044 TREE_TYPE (lhs
), rhs
);
2046 if (gimple_assign_lhs (stmt
) != lhs
)
2047 gimple_assign_set_lhs (stmt
, lhs
);
2049 if (gimple_assign_rhs1 (stmt
) != rhs
)
2051 gimple_stmt_iterator gsi
= gsi_for_stmt (stmt
);
2052 gimple_assign_set_rhs_from_tree (&gsi
, rhs
);
2056 else if (gimple_code (stmt
) == GIMPLE_CALL
)
2059 if (optimize_atomic_compare_exchange_p (stmt
))
2061 tree expected
= gimple_call_arg (stmt
, 1);
2062 if (bitmap_bit_p (suitable_for_renaming
,
2063 DECL_UID (TREE_OPERAND (expected
, 0))))
2065 fold_builtin_atomic_compare_exchange (&gsi
);
2069 else if (is_asan_mark_p (stmt
))
2071 tree var
= TREE_OPERAND (gimple_call_arg (stmt
, 1), 0);
2072 if (bitmap_bit_p (suitable_for_renaming
, DECL_UID (var
)))
2074 unlink_stmt_vdef (stmt
);
2075 if (asan_mark_p (stmt
, ASAN_MARK_POISON
))
2078 = gimple_build_call_internal (IFN_ASAN_POISON
, 0);
2079 gimple_call_set_lhs (call
, var
);
2080 gsi_replace (&gsi
, call
, true);
2084 /* In ASAN_MARK (UNPOISON, &b, ...) the variable
2085 is uninitialized. Avoid dependencies on
2086 previous out of scope value. */
2087 tree clobber
= build_clobber (TREE_TYPE (var
));
2088 gimple
*g
= gimple_build_assign (var
, clobber
);
2089 gsi_replace (&gsi
, g
, true);
2094 else if (gimple_call_internal_p (stmt
, IFN_GOMP_SIMT_ENTER
))
2095 for (i
= 1; i
< gimple_call_num_args (stmt
); i
++)
2097 tree
*argp
= gimple_call_arg_ptr (stmt
, i
);
2098 if (*argp
== null_pointer_node
)
2100 gcc_assert (TREE_CODE (*argp
) == ADDR_EXPR
2101 && VAR_P (TREE_OPERAND (*argp
, 0)));
2102 tree var
= TREE_OPERAND (*argp
, 0);
2103 if (bitmap_bit_p (suitable_for_renaming
, DECL_UID (var
)))
2104 *argp
= null_pointer_node
;
2106 for (i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
2108 tree
*argp
= gimple_call_arg_ptr (stmt
, i
);
2109 maybe_rewrite_mem_ref_base (argp
, suitable_for_renaming
);
2113 else if (gimple_code (stmt
) == GIMPLE_ASM
)
2115 gasm
*asm_stmt
= as_a
<gasm
*> (stmt
);
2117 for (i
= 0; i
< gimple_asm_noutputs (asm_stmt
); ++i
)
2119 tree link
= gimple_asm_output_op (asm_stmt
, i
);
2120 maybe_rewrite_mem_ref_base (&TREE_VALUE (link
),
2121 suitable_for_renaming
);
2123 for (i
= 0; i
< gimple_asm_ninputs (asm_stmt
); ++i
)
2125 tree link
= gimple_asm_input_op (asm_stmt
, i
);
2126 maybe_rewrite_mem_ref_base (&TREE_VALUE (link
),
2127 suitable_for_renaming
);
2131 else if (gimple_debug_bind_p (stmt
)
2132 && gimple_debug_bind_has_value_p (stmt
))
2134 tree
*valuep
= gimple_debug_bind_get_value_ptr (stmt
);
2136 maybe_rewrite_mem_ref_base (valuep
, suitable_for_renaming
);
2137 decl
= non_rewritable_mem_ref_base (*valuep
);
2139 && bitmap_bit_p (suitable_for_renaming
, DECL_UID (decl
)))
2140 gimple_debug_bind_reset_value (stmt
);
2143 if (gimple_references_memory_p (stmt
)
2144 || is_gimple_debug (stmt
))
2150 /* Update SSA form here, we are called as non-pass as well. */
2151 if (number_of_loops (cfun
) > 1
2152 && loops_state_satisfies_p (LOOP_CLOSED_SSA
))
2153 rewrite_into_loop_closed_ssa (NULL
, TODO_update_ssa
);
2155 update_ssa (TODO_update_ssa
);
2158 timevar_pop (TV_ADDRESS_TAKEN
);
2163 const pass_data pass_data_update_address_taken
=
2165 GIMPLE_PASS
, /* type */
2166 "addressables", /* name */
2167 OPTGROUP_NONE
, /* optinfo_flags */
2168 TV_ADDRESS_TAKEN
, /* tv_id */
2169 PROP_ssa
, /* properties_required */
2170 0, /* properties_provided */
2171 0, /* properties_destroyed */
2172 0, /* todo_flags_start */
2173 TODO_update_address_taken
, /* todo_flags_finish */
2176 class pass_update_address_taken
: public gimple_opt_pass
2179 pass_update_address_taken (gcc::context
*ctxt
)
2180 : gimple_opt_pass (pass_data_update_address_taken
, ctxt
)
2183 /* opt_pass methods: */
2185 }; // class pass_update_address_taken
2190 make_pass_update_address_taken (gcc::context
*ctxt
)
2192 return new pass_update_address_taken (ctxt
);