1 /* Miscellaneous SSA utility functions.
2 Copyright (C) 2001-2022 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
= build_debug_expr_decl (TREE_TYPE (value
));
439 def_temp
= gimple_build_debug_bind (vexpr
,
440 unshare_expr (value
),
443 /* FIXME: Is setting the mode really necessary? */
445 SET_DECL_MODE (vexpr
, DECL_MODE (value
));
447 SET_DECL_MODE (vexpr
, TYPE_MODE (TREE_TYPE (value
)));
450 gsi_insert_before (gsi
, def_temp
, GSI_SAME_STMT
);
453 gimple_stmt_iterator ngsi
= gsi_for_stmt (def_stmt
);
454 gsi_insert_before (&ngsi
, def_temp
, GSI_SAME_STMT
);
461 FOR_EACH_IMM_USE_STMT (stmt
, imm_iter
, var
)
463 if (!gimple_debug_bind_p (stmt
))
468 FOR_EACH_IMM_USE_ON_STMT (use_p
, imm_iter
)
469 /* unshare_expr is not needed here. vexpr is either a
470 SINGLE_RHS, that can be safely shared, some other RHS
471 that was unshared when we found it had a single debug
472 use, or a DEBUG_EXPR_DECL, that can be safely
474 SET_USE (use_p
, unshare_expr (value
));
475 /* If we didn't replace uses with a debug decl fold the
476 resulting expression. Otherwise we end up with invalid IL. */
477 if (TREE_CODE (value
) != DEBUG_EXPR_DECL
)
479 gimple_stmt_iterator gsi
= gsi_for_stmt (stmt
);
480 fold_stmt_inplace (&gsi
);
484 gimple_debug_bind_reset_value (stmt
);
491 /* Insert a DEBUG BIND stmt before STMT for each DEF referenced by
492 other DEBUG stmts, and replace uses of the DEF with the
493 newly-created debug temp. */
496 insert_debug_temps_for_defs (gimple_stmt_iterator
*gsi
)
502 if (!MAY_HAVE_DEBUG_BIND_STMTS
)
505 stmt
= gsi_stmt (*gsi
);
507 FOR_EACH_PHI_OR_STMT_DEF (def_p
, stmt
, op_iter
, SSA_OP_DEF
)
509 tree var
= DEF_FROM_PTR (def_p
);
511 if (TREE_CODE (var
) != SSA_NAME
)
514 insert_debug_temp_for_var_def (gsi
, var
);
518 /* Reset all debug stmts that use SSA_NAME(s) defined in STMT. */
521 reset_debug_uses (gimple
*stmt
)
525 imm_use_iterator imm_iter
;
528 if (!MAY_HAVE_DEBUG_BIND_STMTS
)
531 FOR_EACH_PHI_OR_STMT_DEF (def_p
, stmt
, op_iter
, SSA_OP_DEF
)
533 tree var
= DEF_FROM_PTR (def_p
);
535 if (TREE_CODE (var
) != SSA_NAME
)
538 FOR_EACH_IMM_USE_STMT (use_stmt
, imm_iter
, var
)
540 if (!gimple_debug_bind_p (use_stmt
))
543 gimple_debug_bind_reset_value (use_stmt
);
544 update_stmt (use_stmt
);
549 /* Delete SSA DEFs for SSA versions in the TOREMOVE bitmap, removing
550 dominated stmts before their dominators, so that release_ssa_defs
551 stands a chance of propagating DEFs into debug bind stmts. */
554 release_defs_bitset (bitmap toremove
)
559 /* Performing a topological sort is probably overkill, this will
560 most likely run in slightly superlinear time, rather than the
561 pathological quadratic worst case.
562 But iterate from max SSA name version to min one because
563 that mimics allocation order during code generation behavior best.
564 Use an array for this which we compact on-the-fly with a NULL
565 marker moving towards the end of the vector. */
566 auto_vec
<tree
, 16> names
;
567 names
.reserve (bitmap_count_bits (toremove
) + 1);
568 names
.quick_push (NULL_TREE
);
569 EXECUTE_IF_SET_IN_BITMAP (toremove
, 0, j
, bi
)
570 names
.quick_push (ssa_name (j
));
572 bitmap_tree_view (toremove
);
573 while (!bitmap_empty_p (toremove
))
575 j
= names
.length () - 1;
576 for (unsigned i
= names
.length () - 1; names
[i
];)
578 bool remove_now
= true;
581 imm_use_iterator uit
;
583 FOR_EACH_IMM_USE_STMT (stmt
, uit
, var
)
588 /* We can't propagate PHI nodes into debug stmts. */
589 if (gimple_code (stmt
) == GIMPLE_PHI
590 || is_gimple_debug (stmt
))
593 /* If we find another definition to remove that uses
594 the one we're looking at, defer the removal of this
595 one, so that it can be propagated into debug stmts
596 after the other is. */
597 FOR_EACH_SSA_DEF_OPERAND (def_p
, stmt
, dit
, SSA_OP_DEF
)
599 tree odef
= DEF_FROM_PTR (def_p
);
601 if (bitmap_bit_p (toremove
, SSA_NAME_VERSION (odef
)))
614 gimple
*def
= SSA_NAME_DEF_STMT (var
);
615 gimple_stmt_iterator gsi
= gsi_for_stmt (def
);
617 if (gimple_code (def
) == GIMPLE_PHI
)
618 remove_phi_node (&gsi
, true);
621 gsi_remove (&gsi
, true);
624 bitmap_clear_bit (toremove
, SSA_NAME_VERSION (var
));
632 bitmap_list_view (toremove
);
635 /* Disable warnings about missing quoting in GCC diagnostics for
636 the verification errors. Their format strings don't follow GCC
637 diagnostic conventions and the calls are ultimately followed by
638 one to internal_error. */
640 # pragma GCC diagnostic push
641 # pragma GCC diagnostic ignored "-Wformat-diag"
644 /* Verify virtual SSA form. */
647 verify_vssa (basic_block bb
, tree current_vdef
, sbitmap visited
)
651 if (!bitmap_set_bit (visited
, bb
->index
))
654 /* Pick up the single virtual PHI def. */
656 for (gphi_iterator si
= gsi_start_phis (bb
); !gsi_end_p (si
);
659 tree res
= gimple_phi_result (si
.phi ());
660 if (virtual_operand_p (res
))
664 error ("multiple virtual PHI nodes in BB %d", bb
->index
);
665 print_gimple_stmt (stderr
, phi
, 0);
666 print_gimple_stmt (stderr
, si
.phi (), 0);
675 current_vdef
= gimple_phi_result (phi
);
676 if (TREE_CODE (current_vdef
) != SSA_NAME
)
678 error ("virtual definition is not an SSA name");
679 print_gimple_stmt (stderr
, phi
, 0);
685 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
);
688 gimple
*stmt
= gsi_stmt (gsi
);
689 tree vuse
= gimple_vuse (stmt
);
692 if (vuse
!= current_vdef
)
694 error ("stmt with wrong VUSE");
695 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
);
696 fprintf (stderr
, "expected ");
697 print_generic_expr (stderr
, current_vdef
);
698 fprintf (stderr
, "\n");
701 tree vdef
= gimple_vdef (stmt
);
705 if (TREE_CODE (current_vdef
) != SSA_NAME
)
707 error ("virtual definition is not an SSA name");
708 print_gimple_stmt (stderr
, phi
, 0);
715 /* Verify destination PHI uses and recurse. */
718 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
720 gphi
*phi
= get_virtual_phi (e
->dest
);
722 && PHI_ARG_DEF_FROM_EDGE (phi
, e
) != current_vdef
)
724 error ("PHI node with wrong VUSE on edge from BB %d",
726 print_gimple_stmt (stderr
, phi
, 0, TDF_VOPS
);
727 fprintf (stderr
, "expected ");
728 print_generic_expr (stderr
, current_vdef
);
729 fprintf (stderr
, "\n");
734 err
|= verify_vssa (e
->dest
, current_vdef
, visited
);
740 /* Return true if SSA_NAME is malformed and mark it visited.
742 IS_VIRTUAL is true if this SSA_NAME was found inside a virtual
746 verify_ssa_name (tree ssa_name
, bool is_virtual
)
748 if (TREE_CODE (ssa_name
) != SSA_NAME
)
750 error ("expected an SSA_NAME object");
754 if (SSA_NAME_IN_FREE_LIST (ssa_name
))
756 error ("found an SSA_NAME that had been released into the free pool");
760 if (SSA_NAME_VAR (ssa_name
) != NULL_TREE
761 && TREE_TYPE (ssa_name
) != TREE_TYPE (SSA_NAME_VAR (ssa_name
)))
763 error ("type mismatch between an SSA_NAME and its symbol");
767 if (is_virtual
&& !virtual_operand_p (ssa_name
))
769 error ("found a virtual definition for a GIMPLE register");
773 if (is_virtual
&& SSA_NAME_VAR (ssa_name
) != gimple_vop (cfun
))
775 error ("virtual SSA name for non-VOP decl");
779 if (!is_virtual
&& virtual_operand_p (ssa_name
))
781 error ("found a real definition for a non-register");
785 if (SSA_NAME_IS_DEFAULT_DEF (ssa_name
)
786 && !gimple_nop_p (SSA_NAME_DEF_STMT (ssa_name
)))
788 error ("found a default name with a non-empty defining statement");
796 /* Return true if the definition of SSA_NAME at block BB is malformed.
798 STMT is the statement where SSA_NAME is created.
800 DEFINITION_BLOCK is an array of basic blocks indexed by SSA_NAME
801 version numbers. If DEFINITION_BLOCK[SSA_NAME_VERSION] is set,
802 it means that the block in that array slot contains the
803 definition of SSA_NAME.
805 IS_VIRTUAL is true if SSA_NAME is created by a VDEF. */
808 verify_def (basic_block bb
, basic_block
*definition_block
, tree ssa_name
,
809 gimple
*stmt
, bool is_virtual
)
811 if (verify_ssa_name (ssa_name
, is_virtual
))
814 if (SSA_NAME_VAR (ssa_name
)
815 && TREE_CODE (SSA_NAME_VAR (ssa_name
)) == RESULT_DECL
816 && DECL_BY_REFERENCE (SSA_NAME_VAR (ssa_name
)))
818 error ("RESULT_DECL should be read only when DECL_BY_REFERENCE is set");
822 if (definition_block
[SSA_NAME_VERSION (ssa_name
)])
824 error ("SSA_NAME created in two different blocks %i and %i",
825 definition_block
[SSA_NAME_VERSION (ssa_name
)]->index
, bb
->index
);
829 definition_block
[SSA_NAME_VERSION (ssa_name
)] = bb
;
831 if (SSA_NAME_DEF_STMT (ssa_name
) != stmt
)
833 error ("SSA_NAME_DEF_STMT is wrong");
834 fprintf (stderr
, "Expected definition statement:\n");
835 print_gimple_stmt (stderr
, SSA_NAME_DEF_STMT (ssa_name
), 4, TDF_VOPS
);
836 fprintf (stderr
, "\nActual definition statement:\n");
837 print_gimple_stmt (stderr
, stmt
, 4, TDF_VOPS
);
844 fprintf (stderr
, "while verifying SSA_NAME ");
845 print_generic_expr (stderr
, ssa_name
);
846 fprintf (stderr
, " in statement\n");
847 print_gimple_stmt (stderr
, stmt
, 4, TDF_VOPS
);
853 /* Return true if the use of SSA_NAME at statement STMT in block BB is
856 DEF_BB is the block where SSA_NAME was found to be created.
858 IDOM contains immediate dominator information for the flowgraph.
860 CHECK_ABNORMAL is true if the caller wants to check whether this use
861 is flowing through an abnormal edge (only used when checking PHI
864 If NAMES_DEFINED_IN_BB is not NULL, it contains a bitmap of ssa names
865 that are defined before STMT in basic block BB. */
868 verify_use (basic_block bb
, basic_block def_bb
, use_operand_p use_p
,
869 gimple
*stmt
, bool check_abnormal
, bitmap names_defined_in_bb
)
872 tree ssa_name
= USE_FROM_PTR (use_p
);
874 if (!TREE_VISITED (ssa_name
))
875 if (verify_imm_links (stderr
, ssa_name
))
878 TREE_VISITED (ssa_name
) = 1;
880 if (gimple_nop_p (SSA_NAME_DEF_STMT (ssa_name
))
881 && SSA_NAME_IS_DEFAULT_DEF (ssa_name
))
882 ; /* Default definitions have empty statements. Nothing to do. */
885 error ("missing definition");
888 else if (bb
!= def_bb
889 && !dominated_by_p (CDI_DOMINATORS
, bb
, def_bb
))
891 error ("definition in block %i does not dominate use in block %i",
892 def_bb
->index
, bb
->index
);
895 else if (bb
== def_bb
896 && names_defined_in_bb
!= NULL
897 && !bitmap_bit_p (names_defined_in_bb
, SSA_NAME_VERSION (ssa_name
)))
899 error ("definition in block %i follows the use", def_bb
->index
);
904 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ssa_name
))
906 error ("SSA_NAME_OCCURS_IN_ABNORMAL_PHI should be set");
910 /* Make sure the use is in an appropriate list by checking the previous
911 element to make sure it's the same. */
912 if (use_p
->prev
== NULL
)
914 error ("no immediate_use list");
920 if (use_p
->prev
->use
== NULL
)
921 listvar
= use_p
->prev
->loc
.ssa_name
;
923 listvar
= USE_FROM_PTR (use_p
->prev
);
924 if (listvar
!= ssa_name
)
926 error ("wrong immediate use list");
933 fprintf (stderr
, "for SSA_NAME: ");
934 print_generic_expr (stderr
, ssa_name
, TDF_VOPS
);
935 fprintf (stderr
, " in statement:\n");
936 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
);
943 /* Return true if any of the arguments for PHI node PHI at block BB is
946 DEFINITION_BLOCK is an array of basic blocks indexed by SSA_NAME
947 version numbers. If DEFINITION_BLOCK[SSA_NAME_VERSION] is set,
948 it means that the block in that array slot contains the
949 definition of SSA_NAME. */
952 verify_phi_args (gphi
*phi
, basic_block bb
, basic_block
*definition_block
)
956 size_t i
, phi_num_args
= gimple_phi_num_args (phi
);
958 if (EDGE_COUNT (bb
->preds
) != phi_num_args
)
960 error ("incoming edge count does not match number of PHI arguments");
965 for (i
= 0; i
< phi_num_args
; i
++)
967 use_operand_p op_p
= gimple_phi_arg_imm_use_ptr (phi
, i
);
968 tree op
= USE_FROM_PTR (op_p
);
970 e
= EDGE_PRED (bb
, i
);
974 error ("PHI argument is missing for edge %d->%d",
981 if (TREE_CODE (op
) != SSA_NAME
&& !is_gimple_min_invariant (op
))
983 error ("PHI argument is not SSA_NAME, or invariant");
987 if ((e
->flags
& EDGE_ABNORMAL
) && TREE_CODE (op
) != SSA_NAME
)
989 error ("PHI argument on abnormal edge is not SSA_NAME");
993 if (TREE_CODE (op
) == SSA_NAME
)
995 err
= verify_ssa_name (op
, virtual_operand_p (gimple_phi_result (phi
)));
996 err
|= verify_use (e
->src
, definition_block
[SSA_NAME_VERSION (op
)],
997 op_p
, phi
, e
->flags
& EDGE_ABNORMAL
, NULL
);
1000 if (TREE_CODE (op
) == ADDR_EXPR
)
1002 tree base
= TREE_OPERAND (op
, 0);
1003 while (handled_component_p (base
))
1004 base
= TREE_OPERAND (base
, 0);
1006 || TREE_CODE (base
) == PARM_DECL
1007 || TREE_CODE (base
) == RESULT_DECL
)
1008 && !TREE_ADDRESSABLE (base
))
1010 error ("address taken, but ADDRESSABLE bit not set");
1017 error ("wrong edge %d->%d for PHI argument",
1018 e
->src
->index
, e
->dest
->index
);
1024 fprintf (stderr
, "PHI argument\n");
1025 print_generic_stmt (stderr
, op
, TDF_VOPS
);
1033 fprintf (stderr
, "for PHI node\n");
1034 print_gimple_stmt (stderr
, phi
, 0, TDF_VOPS
|TDF_MEMSYMS
);
1042 /* Verify common invariants in the SSA web.
1043 TODO: verify the variable annotations. */
1046 verify_ssa (bool check_modified_stmt
, bool check_ssa_operands
)
1049 basic_block
*definition_block
= XCNEWVEC (basic_block
, num_ssa_names
);
1052 enum dom_state orig_dom_state
= dom_info_state (CDI_DOMINATORS
);
1053 auto_bitmap names_defined_in_bb
;
1055 gcc_assert (!need_ssa_update_p (cfun
));
1057 timevar_push (TV_TREE_SSA_VERIFY
);
1060 /* Keep track of SSA names present in the IL. */
1063 hash_map
<void *, tree
> ssa_info
;
1065 FOR_EACH_SSA_NAME (i
, name
, cfun
)
1068 TREE_VISITED (name
) = 0;
1070 verify_ssa_name (name
, virtual_operand_p (name
));
1072 stmt
= SSA_NAME_DEF_STMT (name
);
1073 if (!gimple_nop_p (stmt
))
1075 basic_block bb
= gimple_bb (stmt
);
1076 if (verify_def (bb
, definition_block
,
1077 name
, stmt
, virtual_operand_p (name
)))
1082 if (POINTER_TYPE_P (TREE_TYPE (name
)))
1083 info
= SSA_NAME_PTR_INFO (name
);
1084 else if (INTEGRAL_TYPE_P (TREE_TYPE (name
)))
1085 info
= SSA_NAME_RANGE_INFO (name
);
1089 tree
&val
= ssa_info
.get_or_insert (info
, &existed
);
1092 error ("shared SSA name info");
1093 print_generic_expr (stderr
, val
);
1094 fprintf (stderr
, " and ");
1095 print_generic_expr (stderr
, name
);
1096 fprintf (stderr
, "\n");
1105 calculate_dominance_info (CDI_DOMINATORS
);
1107 /* Now verify all the uses and make sure they agree with the definitions
1108 found in the previous pass. */
1109 FOR_EACH_BB_FN (bb
, cfun
)
1114 /* Make sure that all edges have a clear 'aux' field. */
1115 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
1119 error ("AUX pointer initialized for edge %d->%d", e
->src
->index
,
1125 /* Verify the arguments for every PHI node in the block. */
1126 for (gphi_iterator gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1128 gphi
*phi
= gsi
.phi ();
1129 if (verify_phi_args (phi
, bb
, definition_block
))
1132 bitmap_set_bit (names_defined_in_bb
,
1133 SSA_NAME_VERSION (gimple_phi_result (phi
)));
1136 /* Now verify all the uses and vuses in every statement of the block. */
1137 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
);
1140 gimple
*stmt
= gsi_stmt (gsi
);
1141 use_operand_p use_p
;
1143 if (check_modified_stmt
&& gimple_modified_p (stmt
))
1145 error ("stmt (%p) marked modified after optimization pass: ",
1147 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
);
1151 if (check_ssa_operands
&& verify_ssa_operands (cfun
, stmt
))
1153 print_gimple_stmt (stderr
, stmt
, 0, TDF_VOPS
);
1157 if (gimple_debug_bind_p (stmt
)
1158 && !gimple_debug_bind_has_value_p (stmt
))
1161 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_USE
|SSA_OP_VUSE
)
1163 op
= USE_FROM_PTR (use_p
);
1164 if (verify_use (bb
, definition_block
[SSA_NAME_VERSION (op
)],
1165 use_p
, stmt
, false, names_defined_in_bb
))
1169 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, iter
, SSA_OP_ALL_DEFS
)
1171 if (SSA_NAME_DEF_STMT (op
) != stmt
)
1173 error ("SSA_NAME_DEF_STMT is wrong");
1174 fprintf (stderr
, "Expected definition statement:\n");
1175 print_gimple_stmt (stderr
, stmt
, 4, TDF_VOPS
);
1176 fprintf (stderr
, "\nActual definition statement:\n");
1177 print_gimple_stmt (stderr
, SSA_NAME_DEF_STMT (op
),
1181 bitmap_set_bit (names_defined_in_bb
, SSA_NAME_VERSION (op
));
1185 bitmap_clear (names_defined_in_bb
);
1188 free (definition_block
);
1190 if (gimple_vop (cfun
)
1191 && ssa_default_def (cfun
, gimple_vop (cfun
)))
1193 auto_sbitmap
visited (last_basic_block_for_fn (cfun
) + 1);
1194 bitmap_clear (visited
);
1195 if (verify_vssa (ENTRY_BLOCK_PTR_FOR_FN (cfun
),
1196 ssa_default_def (cfun
, gimple_vop (cfun
)), visited
))
1200 /* Restore the dominance information to its prior known state, so
1201 that we do not perturb the compiler's subsequent behavior. */
1202 if (orig_dom_state
== DOM_NONE
)
1203 free_dominance_info (CDI_DOMINATORS
);
1205 set_dom_info_availability (CDI_DOMINATORS
, orig_dom_state
);
1207 timevar_pop (TV_TREE_SSA_VERIFY
);
1211 internal_error ("verify_ssa failed");
1215 # pragma GCC diagnostic pop
1218 /* Initialize global DFA and SSA structures.
1219 If SIZE is non-zero allocated ssa names array of a given size. */
1222 init_tree_ssa (struct function
*fn
, int size
)
1224 fn
->gimple_df
= ggc_cleared_alloc
<gimple_df
> ();
1225 fn
->gimple_df
->default_defs
= hash_table
<ssa_name_hasher
>::create_ggc (20);
1226 pt_solution_reset (&fn
->gimple_df
->escaped
);
1227 init_ssanames (fn
, size
);
1230 /* Deallocate memory associated with SSA data structures for FNDECL. */
1233 delete_tree_ssa (struct function
*fn
)
1237 /* We no longer maintain the SSA operand cache at this point. */
1238 if (ssa_operands_active (fn
))
1239 fini_ssa_operands (fn
);
1241 fn
->gimple_df
->default_defs
->empty ();
1242 fn
->gimple_df
->default_defs
= NULL
;
1243 pt_solution_reset (&fn
->gimple_df
->escaped
);
1244 if (fn
->gimple_df
->decls_to_pointers
!= NULL
)
1245 delete fn
->gimple_df
->decls_to_pointers
;
1246 fn
->gimple_df
->decls_to_pointers
= NULL
;
1247 fn
->gimple_df
= NULL
;
1249 /* We no longer need the edge variable maps. */
1250 redirect_edge_var_map_empty ();
1253 /* Return true if EXPR is a useless type conversion, otherwise return
1257 tree_ssa_useless_type_conversion (tree expr
)
1259 tree outer_type
, inner_type
;
1261 /* If we have an assignment that merely uses a NOP_EXPR to change
1262 the top of the RHS to the type of the LHS and the type conversion
1263 is "safe", then strip away the type conversion so that we can
1264 enter LHS = RHS into the const_and_copies table. */
1265 if (!CONVERT_EXPR_P (expr
)
1266 && TREE_CODE (expr
) != VIEW_CONVERT_EXPR
1267 && TREE_CODE (expr
) != NON_LVALUE_EXPR
)
1270 outer_type
= TREE_TYPE (expr
);
1271 inner_type
= TREE_TYPE (TREE_OPERAND (expr
, 0));
1273 if (inner_type
== error_mark_node
)
1276 return useless_type_conversion_p (outer_type
, inner_type
);
1279 /* Strip conversions from EXP according to
1280 tree_ssa_useless_type_conversion and return the resulting
1284 tree_ssa_strip_useless_type_conversions (tree exp
)
1286 while (tree_ssa_useless_type_conversion (exp
))
1287 exp
= TREE_OPERAND (exp
, 0);
1291 /* Return true if T, as SSA_NAME, has an implicit default defined value. */
1294 ssa_defined_default_def_p (tree t
)
1296 tree var
= SSA_NAME_VAR (t
);
1300 /* Parameters get their initial value from the function entry. */
1301 else if (TREE_CODE (var
) == PARM_DECL
)
1303 /* When returning by reference the return address is actually a hidden
1305 else if (TREE_CODE (var
) == RESULT_DECL
&& DECL_BY_REFERENCE (var
))
1307 /* Hard register variables get their initial value from the ether. */
1308 else if (VAR_P (var
) && DECL_HARD_REGISTER (var
))
1315 /* Return true if T, an SSA_NAME, has an undefined value. PARTIAL is what
1316 should be returned if the value is only partially undefined. */
1319 ssa_undefined_value_p (tree t
, bool partial
)
1323 if (ssa_defined_default_def_p (t
))
1326 /* The value is undefined iff its definition statement is empty. */
1327 def_stmt
= SSA_NAME_DEF_STMT (t
);
1328 if (gimple_nop_p (def_stmt
))
1331 /* The value is undefined if the definition statement is a call
1332 to .DEFERRED_INIT function. */
1333 if (gimple_call_internal_p (def_stmt
, IFN_DEFERRED_INIT
))
1336 /* The value is partially undefined if the definition statement is
1337 a REALPART_EXPR or IMAGPART_EXPR and its operand is defined by
1338 the call to .DEFERRED_INIT function. This is for handling the
1341 1 typedef _Complex float C;
1354 with -ftrivial-auto-var-init, compiler will insert the following
1355 artificial initialization:
1356 f = .DEFERRED_INIT (f, 2);
1357 _1 = REALPART_EXPR <f>;
1359 we should treat the definition _1 = REALPART_EXPR <f> as undefined. */
1360 if (partial
&& is_gimple_assign (def_stmt
)
1361 && (gimple_assign_rhs_code (def_stmt
) == REALPART_EXPR
1362 || gimple_assign_rhs_code (def_stmt
) == IMAGPART_EXPR
))
1364 tree real_imag_part
= TREE_OPERAND (gimple_assign_rhs1 (def_stmt
), 0);
1365 if (TREE_CODE (real_imag_part
) == SSA_NAME
1366 && gimple_call_internal_p (SSA_NAME_DEF_STMT (real_imag_part
),
1371 /* Check if the complex was not only partially defined. */
1372 if (partial
&& is_gimple_assign (def_stmt
)
1373 && gimple_assign_rhs_code (def_stmt
) == COMPLEX_EXPR
)
1377 rhs1
= gimple_assign_rhs1 (def_stmt
);
1378 rhs2
= gimple_assign_rhs2 (def_stmt
);
1379 return (TREE_CODE (rhs1
) == SSA_NAME
&& ssa_undefined_value_p (rhs1
))
1380 || (TREE_CODE (rhs2
) == SSA_NAME
&& ssa_undefined_value_p (rhs2
));
1386 /* Return TRUE iff STMT, a gimple statement, references an undefined
1390 gimple_uses_undefined_value_p (gimple
*stmt
)
1395 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, iter
, SSA_OP_USE
)
1396 if (ssa_undefined_value_p (op
))
1404 /* If necessary, rewrite the base of the reference tree *TP from
1405 a MEM_REF to a plain or converted symbol. */
1408 maybe_rewrite_mem_ref_base (tree
*tp
, bitmap suitable_for_renaming
)
1412 while (handled_component_p (*tp
))
1413 tp
= &TREE_OPERAND (*tp
, 0);
1414 if (TREE_CODE (*tp
) == MEM_REF
1415 && TREE_CODE (TREE_OPERAND (*tp
, 0)) == ADDR_EXPR
1416 && (sym
= TREE_OPERAND (TREE_OPERAND (*tp
, 0), 0))
1418 && !TREE_ADDRESSABLE (sym
)
1419 && bitmap_bit_p (suitable_for_renaming
, DECL_UID (sym
))
1420 && is_gimple_reg_type (TREE_TYPE (*tp
))
1421 && ! VOID_TYPE_P (TREE_TYPE (*tp
)))
1423 if (TREE_CODE (TREE_TYPE (sym
)) == VECTOR_TYPE
1424 && useless_type_conversion_p (TREE_TYPE (*tp
),
1425 TREE_TYPE (TREE_TYPE (sym
)))
1426 && multiple_p (mem_ref_offset (*tp
),
1427 wi::to_poly_offset (TYPE_SIZE_UNIT (TREE_TYPE (*tp
)))))
1429 *tp
= build3 (BIT_FIELD_REF
, TREE_TYPE (*tp
), sym
,
1430 TYPE_SIZE (TREE_TYPE (*tp
)),
1431 int_const_binop (MULT_EXPR
,
1432 bitsize_int (BITS_PER_UNIT
),
1433 TREE_OPERAND (*tp
, 1)));
1435 else if (TREE_CODE (TREE_TYPE (sym
)) == COMPLEX_TYPE
1436 && useless_type_conversion_p (TREE_TYPE (*tp
),
1437 TREE_TYPE (TREE_TYPE (sym
))))
1439 *tp
= build1 (integer_zerop (TREE_OPERAND (*tp
, 1))
1440 ? REALPART_EXPR
: IMAGPART_EXPR
,
1441 TREE_TYPE (*tp
), sym
);
1443 else if (integer_zerop (TREE_OPERAND (*tp
, 1))
1444 && DECL_SIZE (sym
) == TYPE_SIZE (TREE_TYPE (*tp
)))
1446 if (!useless_type_conversion_p (TREE_TYPE (*tp
),
1448 *tp
= build1 (VIEW_CONVERT_EXPR
,
1449 TREE_TYPE (*tp
), sym
);
1453 else if (DECL_SIZE (sym
)
1454 && TREE_CODE (DECL_SIZE (sym
)) == INTEGER_CST
1455 && (known_subrange_p
1456 (mem_ref_offset (*tp
),
1457 wi::to_offset (TYPE_SIZE_UNIT (TREE_TYPE (*tp
))),
1458 0, wi::to_offset (DECL_SIZE_UNIT (sym
))))
1459 && (! INTEGRAL_TYPE_P (TREE_TYPE (*tp
))
1460 || (wi::to_offset (TYPE_SIZE (TREE_TYPE (*tp
)))
1461 == TYPE_PRECISION (TREE_TYPE (*tp
))))
1462 && wi::umod_trunc (wi::to_offset (TYPE_SIZE (TREE_TYPE (*tp
))),
1463 BITS_PER_UNIT
) == 0)
1465 *tp
= build3 (BIT_FIELD_REF
, TREE_TYPE (*tp
), sym
,
1466 TYPE_SIZE (TREE_TYPE (*tp
)),
1467 wide_int_to_tree (bitsizetype
,
1468 mem_ref_offset (*tp
)
1469 << LOG2_BITS_PER_UNIT
));
1474 /* For a tree REF return its base if it is the base of a MEM_REF
1475 that cannot be rewritten into SSA form. Otherwise return NULL_TREE. */
1478 non_rewritable_mem_ref_base (tree ref
)
1482 /* A plain decl does not need it set. */
1486 if (! (base
= CONST_CAST_TREE (strip_invariant_refs (ref
))))
1488 base
= get_base_address (ref
);
1494 /* But watch out for MEM_REFs we cannot lower to a
1495 VIEW_CONVERT_EXPR or a BIT_FIELD_REF. */
1496 if (TREE_CODE (base
) == MEM_REF
1497 && TREE_CODE (TREE_OPERAND (base
, 0)) == ADDR_EXPR
)
1499 tree decl
= TREE_OPERAND (TREE_OPERAND (base
, 0), 0);
1500 if (! DECL_P (decl
))
1502 if (! is_gimple_reg_type (TREE_TYPE (base
))
1503 || VOID_TYPE_P (TREE_TYPE (base
))
1504 || TREE_THIS_VOLATILE (decl
) != TREE_THIS_VOLATILE (base
))
1506 if ((TREE_CODE (TREE_TYPE (decl
)) == VECTOR_TYPE
1507 || TREE_CODE (TREE_TYPE (decl
)) == COMPLEX_TYPE
)
1508 && useless_type_conversion_p (TREE_TYPE (base
),
1509 TREE_TYPE (TREE_TYPE (decl
)))
1510 && known_ge (mem_ref_offset (base
), 0)
1511 && known_gt (wi::to_poly_offset (TYPE_SIZE_UNIT (TREE_TYPE (decl
))),
1512 mem_ref_offset (base
))
1513 && multiple_p (mem_ref_offset (base
),
1514 wi::to_poly_offset (TYPE_SIZE_UNIT (TREE_TYPE (base
)))))
1516 /* For same sizes and zero offset we can use a VIEW_CONVERT_EXPR. */
1517 if (integer_zerop (TREE_OPERAND (base
, 1))
1518 && DECL_SIZE (decl
) == TYPE_SIZE (TREE_TYPE (base
)))
1520 /* For integral typed extracts we can use a BIT_FIELD_REF. */
1521 if (DECL_SIZE (decl
)
1522 && TREE_CODE (DECL_SIZE_UNIT (decl
)) == INTEGER_CST
1523 && (known_subrange_p
1524 (mem_ref_offset (base
),
1525 wi::to_poly_offset (TYPE_SIZE_UNIT (TREE_TYPE (base
))),
1526 0, wi::to_poly_offset (DECL_SIZE_UNIT (decl
))))
1527 /* ??? We can't handle bitfield precision extracts without
1528 either using an alternate type for the BIT_FIELD_REF and
1529 then doing a conversion or possibly adjusting the offset
1530 according to endianness. */
1531 && (! INTEGRAL_TYPE_P (TREE_TYPE (base
))
1532 || (wi::to_offset (TYPE_SIZE (TREE_TYPE (base
)))
1533 == TYPE_PRECISION (TREE_TYPE (base
))))
1534 && wi::umod_trunc (wi::to_offset (TYPE_SIZE (TREE_TYPE (base
))),
1535 BITS_PER_UNIT
) == 0)
1540 /* We cannot rewrite TARGET_MEM_REFs. */
1541 if (TREE_CODE (base
) == TARGET_MEM_REF
1542 && TREE_CODE (TREE_OPERAND (base
, 0)) == ADDR_EXPR
)
1544 tree decl
= TREE_OPERAND (TREE_OPERAND (base
, 0), 0);
1545 if (! DECL_P (decl
))
1553 /* For an lvalue tree LHS return true if it cannot be rewritten into SSA form.
1554 Otherwise return true. */
1557 non_rewritable_lvalue_p (tree lhs
)
1559 /* A plain decl is always rewritable. */
1563 /* We can re-write REALPART_EXPR and IMAGPART_EXPR sets in
1564 a reasonably efficient manner... */
1565 if ((TREE_CODE (lhs
) == REALPART_EXPR
1566 || TREE_CODE (lhs
) == IMAGPART_EXPR
)
1567 && DECL_P (TREE_OPERAND (lhs
, 0)))
1570 /* ??? The following could be relaxed allowing component
1571 references that do not change the access size. */
1572 if (TREE_CODE (lhs
) == MEM_REF
1573 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == ADDR_EXPR
)
1575 tree decl
= TREE_OPERAND (TREE_OPERAND (lhs
, 0), 0);
1577 /* A decl that is wrapped inside a MEM-REF that covers
1578 it full is also rewritable. */
1579 if (integer_zerop (TREE_OPERAND (lhs
, 1))
1581 && DECL_SIZE (decl
) == TYPE_SIZE (TREE_TYPE (lhs
))
1582 /* If the dynamic type of the decl has larger precision than
1583 the decl itself we can't use the decls type for SSA rewriting. */
1584 && ((! INTEGRAL_TYPE_P (TREE_TYPE (decl
))
1585 || compare_tree_int (DECL_SIZE (decl
),
1586 TYPE_PRECISION (TREE_TYPE (decl
))) == 0)
1587 || (INTEGRAL_TYPE_P (TREE_TYPE (lhs
))
1588 && (TYPE_PRECISION (TREE_TYPE (decl
))
1589 >= TYPE_PRECISION (TREE_TYPE (lhs
)))))
1590 /* Make sure we are not re-writing non-float copying into float
1591 copying as that can incur normalization. */
1592 && (! FLOAT_TYPE_P (TREE_TYPE (decl
))
1593 || types_compatible_p (TREE_TYPE (lhs
), TREE_TYPE (decl
)))
1594 && (TREE_THIS_VOLATILE (decl
) == TREE_THIS_VOLATILE (lhs
)))
1597 /* A vector-insert using a MEM_REF or ARRAY_REF is rewritable
1598 using a BIT_INSERT_EXPR. */
1600 && VECTOR_TYPE_P (TREE_TYPE (decl
))
1601 && TYPE_MODE (TREE_TYPE (decl
)) != BLKmode
1602 && known_ge (mem_ref_offset (lhs
), 0)
1603 && known_gt (wi::to_poly_offset (TYPE_SIZE_UNIT (TREE_TYPE (decl
))),
1604 mem_ref_offset (lhs
))
1605 && multiple_p (mem_ref_offset (lhs
),
1606 wi::to_poly_offset (TYPE_SIZE_UNIT (TREE_TYPE (lhs
))))
1607 && known_ge (wi::to_poly_offset (TYPE_SIZE (TREE_TYPE (decl
))),
1608 wi::to_poly_offset (TYPE_SIZE (TREE_TYPE (lhs
)))))
1610 poly_uint64 lhs_bits
, nelts
;
1611 if (poly_int_tree_p (TYPE_SIZE (TREE_TYPE (lhs
)), &lhs_bits
)
1612 && multiple_p (lhs_bits
,
1614 (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl
)))),
1616 && valid_vector_subparts_p (nelts
))
1618 if (known_eq (nelts
, 1u))
1620 /* For sub-vector inserts the insert vector mode has to be
1622 tree vtype
= build_vector_type (TREE_TYPE (TREE_TYPE (decl
)),
1624 if (TYPE_MODE (vtype
) != BLKmode
)
1630 /* A vector-insert using a BIT_FIELD_REF is rewritable using
1632 if (TREE_CODE (lhs
) == BIT_FIELD_REF
1633 && DECL_P (TREE_OPERAND (lhs
, 0))
1634 && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (lhs
, 0)))
1635 && TYPE_MODE (TREE_TYPE (TREE_OPERAND (lhs
, 0))) != BLKmode
1636 && operand_equal_p (TYPE_SIZE_UNIT (TREE_TYPE (lhs
)),
1638 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (lhs
, 0)))), 0)
1639 && (tree_to_uhwi (TREE_OPERAND (lhs
, 2))
1640 % tree_to_uhwi (TYPE_SIZE (TREE_TYPE (lhs
)))) == 0)
1646 /* When possible, clear TREE_ADDRESSABLE bit, set or clear DECL_NOT_GIMPLE_REG_P
1647 and mark the variable VAR for conversion into SSA. Return true when updating
1648 stmts is required. */
1651 maybe_optimize_var (tree var
, bitmap addresses_taken
, bitmap not_reg_needs
,
1652 bitmap suitable_for_renaming
)
1654 /* Global Variables, result decls cannot be changed. */
1655 if (is_global_var (var
)
1656 || TREE_CODE (var
) == RESULT_DECL
1657 || bitmap_bit_p (addresses_taken
, DECL_UID (var
)))
1660 bool maybe_reg
= false;
1661 if (TREE_ADDRESSABLE (var
))
1663 TREE_ADDRESSABLE (var
) = 0;
1667 fprintf (dump_file
, "No longer having address taken: ");
1668 print_generic_expr (dump_file
, var
);
1669 fprintf (dump_file
, "\n");
1673 /* For register type decls if we do not have any partial defs
1674 we cannot express in SSA form mark them as DECL_NOT_GIMPLE_REG_P
1675 as to avoid SSA rewrite. For the others go ahead and mark
1676 them for renaming. */
1677 if (is_gimple_reg_type (TREE_TYPE (var
)))
1679 if (bitmap_bit_p (not_reg_needs
, DECL_UID (var
)))
1681 DECL_NOT_GIMPLE_REG_P (var
) = 1;
1684 fprintf (dump_file
, "Has partial defs: ");
1685 print_generic_expr (dump_file
, var
);
1686 fprintf (dump_file
, "\n");
1689 else if (DECL_NOT_GIMPLE_REG_P (var
))
1692 DECL_NOT_GIMPLE_REG_P (var
) = 0;
1694 if (maybe_reg
&& is_gimple_reg (var
))
1698 fprintf (dump_file
, "Now a gimple register: ");
1699 print_generic_expr (dump_file
, var
);
1700 fprintf (dump_file
, "\n");
1702 bitmap_set_bit (suitable_for_renaming
, DECL_UID (var
));
1707 /* Return true when STMT is ASAN mark where second argument is an address
1708 of a local variable. */
1711 is_asan_mark_p (gimple
*stmt
)
1713 if (!gimple_call_internal_p (stmt
, IFN_ASAN_MARK
))
1716 tree addr
= get_base_address (gimple_call_arg (stmt
, 1));
1717 if (TREE_CODE (addr
) == ADDR_EXPR
1718 && VAR_P (TREE_OPERAND (addr
, 0)))
1720 tree var
= TREE_OPERAND (addr
, 0);
1721 if (lookup_attribute (ASAN_USE_AFTER_SCOPE_ATTRIBUTE
,
1722 DECL_ATTRIBUTES (var
)))
1725 unsigned addressable
= TREE_ADDRESSABLE (var
);
1726 TREE_ADDRESSABLE (var
) = 0;
1727 bool r
= is_gimple_reg (var
);
1728 TREE_ADDRESSABLE (var
) = addressable
;
1735 /* Compute TREE_ADDRESSABLE and whether we have unhandled partial defs
1736 for local variables. */
1739 execute_update_addresses_taken (void)
1742 auto_bitmap addresses_taken
;
1743 auto_bitmap not_reg_needs
;
1744 auto_bitmap suitable_for_renaming
;
1745 bool optimistic_not_addressable
= false;
1749 timevar_push (TV_ADDRESS_TAKEN
);
1751 /* Collect into ADDRESSES_TAKEN all variables whose address is taken within
1752 the function body. */
1753 FOR_EACH_BB_FN (bb
, cfun
)
1755 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
);
1758 gimple
*stmt
= gsi_stmt (gsi
);
1759 enum gimple_code code
= gimple_code (stmt
);
1762 if (code
== GIMPLE_CALL
)
1764 if (optimize_atomic_compare_exchange_p (stmt
))
1766 /* For __atomic_compare_exchange_N if the second argument
1767 is &var, don't mark var addressable;
1768 if it becomes non-addressable, we'll rewrite it into
1769 ATOMIC_COMPARE_EXCHANGE call. */
1770 tree arg
= gimple_call_arg (stmt
, 1);
1771 gimple_call_set_arg (stmt
, 1, null_pointer_node
);
1772 gimple_ior_addresses_taken (addresses_taken
, stmt
);
1773 gimple_call_set_arg (stmt
, 1, arg
);
1774 /* Remember we have to check again below. */
1775 optimistic_not_addressable
= true;
1777 else if (is_asan_mark_p (stmt
)
1778 || gimple_call_internal_p (stmt
, IFN_GOMP_SIMT_ENTER
))
1781 gimple_ior_addresses_taken (addresses_taken
, stmt
);
1784 /* Note all addresses taken by the stmt. */
1785 gimple_ior_addresses_taken (addresses_taken
, stmt
);
1787 /* If we have a call or an assignment, see if the lhs contains
1788 a local decl that requires not to be a gimple register. */
1789 if (code
== GIMPLE_ASSIGN
|| code
== GIMPLE_CALL
)
1791 tree lhs
= gimple_get_lhs (stmt
);
1793 && TREE_CODE (lhs
) != SSA_NAME
1794 && ((code
== GIMPLE_CALL
&& ! DECL_P (lhs
))
1795 || non_rewritable_lvalue_p (lhs
)))
1797 decl
= get_base_address (lhs
);
1799 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1803 if (gimple_assign_single_p (stmt
))
1805 tree rhs
= gimple_assign_rhs1 (stmt
);
1806 if ((decl
= non_rewritable_mem_ref_base (rhs
)))
1807 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1810 else if (code
== GIMPLE_CALL
)
1812 for (i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
1814 tree arg
= gimple_call_arg (stmt
, i
);
1815 if ((decl
= non_rewritable_mem_ref_base (arg
)))
1816 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1820 else if (code
== GIMPLE_ASM
)
1822 gasm
*asm_stmt
= as_a
<gasm
*> (stmt
);
1823 for (i
= 0; i
< gimple_asm_noutputs (asm_stmt
); ++i
)
1825 tree link
= gimple_asm_output_op (asm_stmt
, i
);
1826 tree lhs
= TREE_VALUE (link
);
1827 if (TREE_CODE (lhs
) != SSA_NAME
)
1829 decl
= get_base_address (lhs
);
1831 && (non_rewritable_lvalue_p (lhs
)
1832 /* We cannot move required conversions from
1833 the lhs to the rhs in asm statements, so
1834 require we do not need any. */
1835 || !useless_type_conversion_p
1836 (TREE_TYPE (lhs
), TREE_TYPE (decl
))))
1837 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1840 for (i
= 0; i
< gimple_asm_ninputs (asm_stmt
); ++i
)
1842 tree link
= gimple_asm_input_op (asm_stmt
, i
);
1843 if ((decl
= non_rewritable_mem_ref_base (TREE_VALUE (link
))))
1844 bitmap_set_bit (not_reg_needs
, DECL_UID (decl
));
1849 for (gphi_iterator gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
);
1853 gphi
*phi
= gsi
.phi ();
1855 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
1857 tree op
= PHI_ARG_DEF (phi
, i
), var
;
1858 if (TREE_CODE (op
) == ADDR_EXPR
1859 && (var
= get_base_address (TREE_OPERAND (op
, 0))) != NULL
1861 bitmap_set_bit (addresses_taken
, DECL_UID (var
));
1866 /* We cannot iterate over all referenced vars because that can contain
1867 unused vars from BLOCK trees, which causes code generation differences
1869 for (var
= DECL_ARGUMENTS (cfun
->decl
); var
; var
= DECL_CHAIN (var
))
1870 maybe_optimize_var (var
, addresses_taken
, not_reg_needs
,
1871 suitable_for_renaming
);
1873 FOR_EACH_VEC_SAFE_ELT (cfun
->local_decls
, i
, var
)
1874 maybe_optimize_var (var
, addresses_taken
, not_reg_needs
,
1875 suitable_for_renaming
);
1877 /* Operand caches need to be recomputed for operands referencing the updated
1878 variables and operands need to be rewritten to expose bare symbols. */
1879 if (!bitmap_empty_p (suitable_for_renaming
)
1880 || optimistic_not_addressable
)
1882 FOR_EACH_BB_FN (bb
, cfun
)
1883 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
);)
1885 gimple
*stmt
= gsi_stmt (gsi
);
1887 /* Re-write TARGET_MEM_REFs of symbols we want to
1888 rewrite into SSA form. */
1889 if (gimple_assign_single_p (stmt
))
1891 tree lhs
= gimple_assign_lhs (stmt
);
1892 tree rhs
, *rhsp
= gimple_assign_rhs1_ptr (stmt
);
1895 /* Rewrite LHS IMAG/REALPART_EXPR similar to
1896 gimplify_modify_expr_complex_part. */
1897 if ((TREE_CODE (lhs
) == IMAGPART_EXPR
1898 || TREE_CODE (lhs
) == REALPART_EXPR
)
1899 && DECL_P (TREE_OPERAND (lhs
, 0))
1900 && bitmap_bit_p (suitable_for_renaming
,
1901 DECL_UID (TREE_OPERAND (lhs
, 0))))
1903 tree other
= make_ssa_name (TREE_TYPE (lhs
));
1904 tree lrhs
= build1 (TREE_CODE (lhs
) == IMAGPART_EXPR
1905 ? REALPART_EXPR
: IMAGPART_EXPR
,
1907 TREE_OPERAND (lhs
, 0));
1908 suppress_warning (lrhs
);
1909 gimple
*load
= gimple_build_assign (other
, lrhs
);
1910 location_t loc
= gimple_location (stmt
);
1911 gimple_set_location (load
, loc
);
1912 gimple_set_vuse (load
, gimple_vuse (stmt
));
1913 gsi_insert_before (&gsi
, load
, GSI_SAME_STMT
);
1914 gimple_assign_set_lhs (stmt
, TREE_OPERAND (lhs
, 0));
1915 gimple_assign_set_rhs_with_ops
1916 (&gsi
, COMPLEX_EXPR
,
1917 TREE_CODE (lhs
) == IMAGPART_EXPR
1918 ? other
: gimple_assign_rhs1 (stmt
),
1919 TREE_CODE (lhs
) == IMAGPART_EXPR
1920 ? gimple_assign_rhs1 (stmt
) : other
, NULL_TREE
);
1921 stmt
= gsi_stmt (gsi
);
1922 unlink_stmt_vdef (stmt
);
1927 /* Rewrite a vector insert via a BIT_FIELD_REF on the LHS
1928 into a BIT_INSERT_EXPR. */
1929 if (TREE_CODE (lhs
) == BIT_FIELD_REF
1930 && DECL_P (TREE_OPERAND (lhs
, 0))
1931 && bitmap_bit_p (suitable_for_renaming
,
1932 DECL_UID (TREE_OPERAND (lhs
, 0)))
1933 && VECTOR_TYPE_P (TREE_TYPE (TREE_OPERAND (lhs
, 0)))
1934 && TYPE_MODE (TREE_TYPE (TREE_OPERAND (lhs
, 0))) != BLKmode
1935 && operand_equal_p (TYPE_SIZE_UNIT (TREE_TYPE (lhs
)),
1936 TYPE_SIZE_UNIT (TREE_TYPE
1937 (TREE_TYPE (TREE_OPERAND (lhs
, 0)))),
1939 && (tree_to_uhwi (TREE_OPERAND (lhs
, 2))
1940 % tree_to_uhwi (TYPE_SIZE (TREE_TYPE (lhs
))) == 0))
1942 tree var
= TREE_OPERAND (lhs
, 0);
1943 tree val
= gimple_assign_rhs1 (stmt
);
1944 if (! types_compatible_p (TREE_TYPE (TREE_TYPE (var
)),
1947 tree tem
= make_ssa_name (TREE_TYPE (TREE_TYPE (var
)));
1949 = gimple_build_assign (tem
,
1950 build1 (VIEW_CONVERT_EXPR
,
1951 TREE_TYPE (tem
), val
));
1952 gsi_insert_before (&gsi
, pun
, GSI_SAME_STMT
);
1955 tree bitpos
= TREE_OPERAND (lhs
, 2);
1956 gimple_assign_set_lhs (stmt
, var
);
1957 gimple_assign_set_rhs_with_ops
1958 (&gsi
, BIT_INSERT_EXPR
, var
, val
, bitpos
);
1959 stmt
= gsi_stmt (gsi
);
1960 unlink_stmt_vdef (stmt
);
1965 /* Rewrite a vector insert using a MEM_REF on the LHS
1966 into a BIT_INSERT_EXPR. */
1967 if (TREE_CODE (lhs
) == MEM_REF
1968 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == ADDR_EXPR
1969 && (sym
= TREE_OPERAND (TREE_OPERAND (lhs
, 0), 0))
1971 && bitmap_bit_p (suitable_for_renaming
, DECL_UID (sym
))
1972 && VECTOR_TYPE_P (TREE_TYPE (sym
))
1973 && TYPE_MODE (TREE_TYPE (sym
)) != BLKmode
1974 /* If it is a full replacement we can do better below. */
1975 && maybe_ne (wi::to_poly_offset
1976 (TYPE_SIZE_UNIT (TREE_TYPE (lhs
))),
1978 (TYPE_SIZE_UNIT (TREE_TYPE (sym
))))
1979 && known_ge (mem_ref_offset (lhs
), 0)
1980 && known_gt (wi::to_poly_offset
1981 (TYPE_SIZE_UNIT (TREE_TYPE (sym
))),
1982 mem_ref_offset (lhs
))
1983 && multiple_p (mem_ref_offset (lhs
),
1985 (TYPE_SIZE_UNIT (TREE_TYPE (lhs
)))))
1987 tree val
= gimple_assign_rhs1 (stmt
);
1988 if (! types_compatible_p (TREE_TYPE (val
),
1989 TREE_TYPE (TREE_TYPE (sym
))))
1991 poly_uint64 lhs_bits
, nelts
;
1992 tree temtype
= TREE_TYPE (TREE_TYPE (sym
));
1993 if (poly_int_tree_p (TYPE_SIZE (TREE_TYPE (lhs
)),
1995 && multiple_p (lhs_bits
,
1997 (TYPE_SIZE (TREE_TYPE
1998 (TREE_TYPE (sym
)))),
2000 && maybe_ne (nelts
, 1u)
2001 && valid_vector_subparts_p (nelts
))
2002 temtype
= build_vector_type (temtype
, nelts
);
2003 tree tem
= make_ssa_name (temtype
);
2005 = gimple_build_assign (tem
,
2006 build1 (VIEW_CONVERT_EXPR
,
2007 TREE_TYPE (tem
), val
));
2008 gsi_insert_before (&gsi
, pun
, GSI_SAME_STMT
);
2012 = wide_int_to_tree (bitsizetype
,
2013 mem_ref_offset (lhs
) * BITS_PER_UNIT
);
2014 gimple_assign_set_lhs (stmt
, sym
);
2015 gimple_assign_set_rhs_with_ops
2016 (&gsi
, BIT_INSERT_EXPR
, sym
, val
, bitpos
);
2017 stmt
= gsi_stmt (gsi
);
2018 unlink_stmt_vdef (stmt
);
2023 /* We shouldn't have any fancy wrapping of
2024 component-refs on the LHS, but look through
2025 VIEW_CONVERT_EXPRs as that is easy. */
2026 while (TREE_CODE (lhs
) == VIEW_CONVERT_EXPR
)
2027 lhs
= TREE_OPERAND (lhs
, 0);
2028 if (TREE_CODE (lhs
) == MEM_REF
2029 && TREE_CODE (TREE_OPERAND (lhs
, 0)) == ADDR_EXPR
2030 && integer_zerop (TREE_OPERAND (lhs
, 1))
2031 && (sym
= TREE_OPERAND (TREE_OPERAND (lhs
, 0), 0))
2033 && !TREE_ADDRESSABLE (sym
)
2034 && bitmap_bit_p (suitable_for_renaming
, DECL_UID (sym
)))
2037 lhs
= gimple_assign_lhs (stmt
);
2039 /* Rewrite the RHS and make sure the resulting assignment
2040 is validly typed. */
2041 maybe_rewrite_mem_ref_base (rhsp
, suitable_for_renaming
);
2042 rhs
= gimple_assign_rhs1 (stmt
);
2043 if (gimple_assign_lhs (stmt
) != lhs
2044 && !useless_type_conversion_p (TREE_TYPE (lhs
),
2047 if (gimple_clobber_p (stmt
))
2049 rhs
= build_constructor (TREE_TYPE (lhs
), NULL
);
2050 TREE_THIS_VOLATILE (rhs
) = 1;
2053 rhs
= fold_build1 (VIEW_CONVERT_EXPR
,
2054 TREE_TYPE (lhs
), rhs
);
2056 if (gimple_assign_lhs (stmt
) != lhs
)
2057 gimple_assign_set_lhs (stmt
, lhs
);
2059 if (gimple_assign_rhs1 (stmt
) != rhs
)
2061 gimple_stmt_iterator gsi
= gsi_for_stmt (stmt
);
2062 gimple_assign_set_rhs_from_tree (&gsi
, rhs
);
2066 else if (gimple_code (stmt
) == GIMPLE_CALL
)
2069 if (optimize_atomic_compare_exchange_p (stmt
))
2071 tree expected
= gimple_call_arg (stmt
, 1);
2072 tree decl
= TREE_OPERAND (expected
, 0);
2073 if (bitmap_bit_p (suitable_for_renaming
, DECL_UID (decl
)))
2075 fold_builtin_atomic_compare_exchange (&gsi
);
2078 else if (!TREE_ADDRESSABLE (decl
))
2079 /* If there are partial defs of the decl we may
2080 have cleared the addressable bit but set
2081 DECL_NOT_GIMPLE_REG_P. We have to restore
2082 TREE_ADDRESSABLE here. */
2083 TREE_ADDRESSABLE (decl
) = 1;
2085 else if (is_asan_mark_p (stmt
))
2087 tree var
= TREE_OPERAND (gimple_call_arg (stmt
, 1), 0);
2088 if (bitmap_bit_p (suitable_for_renaming
, DECL_UID (var
)))
2090 unlink_stmt_vdef (stmt
);
2091 if (asan_mark_p (stmt
, ASAN_MARK_POISON
))
2094 = gimple_build_call_internal (IFN_ASAN_POISON
, 0);
2095 gimple_call_set_lhs (call
, var
);
2096 gsi_replace (&gsi
, call
, true);
2100 /* In ASAN_MARK (UNPOISON, &b, ...) the variable
2101 is uninitialized. Avoid dependencies on
2102 previous out of scope value. */
2103 tree clobber
= build_clobber (TREE_TYPE (var
));
2104 gimple
*g
= gimple_build_assign (var
, clobber
);
2105 gsi_replace (&gsi
, g
, true);
2110 else if (gimple_call_internal_p (stmt
, IFN_GOMP_SIMT_ENTER
))
2111 for (i
= 1; i
< gimple_call_num_args (stmt
); i
++)
2113 tree
*argp
= gimple_call_arg_ptr (stmt
, i
);
2114 if (*argp
== null_pointer_node
)
2116 gcc_assert (TREE_CODE (*argp
) == ADDR_EXPR
2117 && VAR_P (TREE_OPERAND (*argp
, 0)));
2118 tree var
= TREE_OPERAND (*argp
, 0);
2119 if (bitmap_bit_p (suitable_for_renaming
, DECL_UID (var
)))
2120 *argp
= null_pointer_node
;
2122 for (i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
2124 tree
*argp
= gimple_call_arg_ptr (stmt
, i
);
2125 maybe_rewrite_mem_ref_base (argp
, suitable_for_renaming
);
2129 else if (gimple_code (stmt
) == GIMPLE_ASM
)
2131 gasm
*asm_stmt
= as_a
<gasm
*> (stmt
);
2133 for (i
= 0; i
< gimple_asm_noutputs (asm_stmt
); ++i
)
2135 tree link
= gimple_asm_output_op (asm_stmt
, i
);
2136 maybe_rewrite_mem_ref_base (&TREE_VALUE (link
),
2137 suitable_for_renaming
);
2139 for (i
= 0; i
< gimple_asm_ninputs (asm_stmt
); ++i
)
2141 tree link
= gimple_asm_input_op (asm_stmt
, i
);
2142 maybe_rewrite_mem_ref_base (&TREE_VALUE (link
),
2143 suitable_for_renaming
);
2147 else if (gimple_debug_bind_p (stmt
)
2148 && gimple_debug_bind_has_value_p (stmt
))
2150 tree
*valuep
= gimple_debug_bind_get_value_ptr (stmt
);
2152 maybe_rewrite_mem_ref_base (valuep
, suitable_for_renaming
);
2153 decl
= non_rewritable_mem_ref_base (*valuep
);
2155 && bitmap_bit_p (suitable_for_renaming
, DECL_UID (decl
)))
2156 gimple_debug_bind_reset_value (stmt
);
2159 if (gimple_references_memory_p (stmt
)
2160 || is_gimple_debug (stmt
))
2166 /* Update SSA form here, we are called as non-pass as well. */
2167 if (number_of_loops (cfun
) > 1
2168 && loops_state_satisfies_p (LOOP_CLOSED_SSA
))
2169 rewrite_into_loop_closed_ssa (NULL
, TODO_update_ssa
);
2171 update_ssa (TODO_update_ssa
);
2174 timevar_pop (TV_ADDRESS_TAKEN
);
2179 const pass_data pass_data_update_address_taken
=
2181 GIMPLE_PASS
, /* type */
2182 "addressables", /* name */
2183 OPTGROUP_NONE
, /* optinfo_flags */
2184 TV_ADDRESS_TAKEN
, /* tv_id */
2185 PROP_ssa
, /* properties_required */
2186 0, /* properties_provided */
2187 0, /* properties_destroyed */
2188 0, /* todo_flags_start */
2189 TODO_update_address_taken
, /* todo_flags_finish */
2192 class pass_update_address_taken
: public gimple_opt_pass
2195 pass_update_address_taken (gcc::context
*ctxt
)
2196 : gimple_opt_pass (pass_data_update_address_taken
, ctxt
)
2199 /* opt_pass methods: */
2201 }; // class pass_update_address_taken
2206 make_pass_update_address_taken (gcc::context
*ctxt
)
2208 return new pass_update_address_taken (ctxt
);